.gitignore

@@ -1,3 +0,0 @@
-makefile/
-.vscode/
-*.exe

.kdev4/info2Praktikum-Wortsalat.kdev4

@@ -1,5 +0,0 @@
-[Buildset]
-BuildItems=@Variant(\x00\x00\x00\t\x00\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x00\x01\x00\x00\x000\x00i\x00n\x00f\x00o\x002\x00P\x00r\x00a\x00k\x00t\x00i\x00k\x00u\x00m\x00-\x00W\x00o\x00r\x00t\x00s\x00a\x00l\x00a\x00t)
-
-[Project]
-VersionControlSupport=kdevgit

Start_Linux/makefile

@@ -1,9 +1,9 @@
 CC = gcc
-CFLAGS = -g -Wall
+CFLAGS = -g -Wall -I$(raylibfolder)
 LDFLAGS = -lGL -lX11 -lm
 BINARIES = ./linux
 
-raylibfolder = ./raylib
+raylib_folder = ./raylib
 unityfolder = ./unity
 
 # --------------------------
@@ -28,7 +28,7 @@ game.o: game.c
 	$(CC) $(CFLAGS) -c game.c
 
 graphicalGame.o: graphicalGame.c
-	$(CC) $(CFLAGS) -I$(raylibfolder) -c graphicalGame.c
+	$(CC) $(CFLAGS) -c graphicalGame.c
 
 # --------------------------
 # Unit Tests

Start_Linux/unit_tests.c

@@ -1,15 +1,16 @@
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
 #include "unity.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
-#include "input.h"
 #include "game.h"
+#include "input.h"
 
 // ANSI Escape Codes für Farben
-// Hinweis: damit das in CLion mit der integrierten Konsole/Output funktioniert, muss man auf die Run-Config gehen und
+// Hinweis: damit das in CLion mit der integrierten Konsole/Output funktioniert,
-// das Häkchen bei 'emulate terminal in the output console' setzen
+// muss man auf die Run-Config gehen und das Häkchen bei 'emulate terminal in
-// (s. auch: https://stackoverflow.com/questions/32742850/how-to-show-colored-console-output-in-clion)
+// the output console' setzen (s. auch:
+// https://stackoverflow.com/questions/32742850/how-to-show-colored-console-output-in-clion)
 #define RESET "\033[0m"
 #define GREEN "\033[32m"
 #define RED "\033[31m"
@@ -101,37 +102,7 @@ void test_createWordSalad_too_small(void) {
   }
 }
 
-void test_createWordSalad_allWordsPlaced() {
-    char words[3][MAX_WORD_LEN] = {"CAT", "DOG", "MOUSE"};
-    char saladHoriz[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
-    char saladVert[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
-
-    int placed = createWordSalad(saladHoriz, 20, words, 3);
-    for(int i = 0; i < MAX_SEARCH_FIELD_LEN; i++)
-    {
-        for(int j = 0; j < MAX_SEARCH_FIELD_LEN; j++)
-        {
-            saladVert[j][i] = saladHoriz[i][j];
-        }
-    }
-
-    for(int i = 0; i < 3; i++) {
-        const char* word = words[i];
-        int wordFound = 0;
-        for(int j = 0; j < MAX_SEARCH_FIELD_LEN; j++)
-        {
-            const char* row = saladHoriz[j];
-            const char* col = saladVert[j];
-            wordFound |= strstr(row, word) || strstr(col, word);
-        }
-        TEST_ASSERT_TRUE_MESSAGE(wordFound, "Not all words were placed.");
-    }
-
-    TEST_ASSERT_EQUAL_INT(3, placed);
-}
-
 // ---------- Test Setup und TearDown Funktionen ----------
-
 // Hier Setup- und TearDown-Funktionen definieren,
 // falls Vor- und Nachbereitungen für die Tests benötigt.
 
@@ -164,7 +135,6 @@ int main(void) {
   RUN_TEST(test_readWords_empty_file);
   RUN_TEST(test_createWordSalad_all_fit);
   RUN_TEST(test_createWordSalad_too_small);
-    RUN_TEST(test_createWordSalad_allWordsPlaced);
 
   int result = UNITY_END(); // Test-Ergebnisse
   print_test_result(result);

Start_Mac/makefile

@@ -4,7 +4,7 @@ LDFLAGS = -framework OpenGL -framework CoreFoundation -framework CoreGraphics -f
 ARCH := $(shell uname -m)
 BINARIES = ./macos-$(ARCH)
 
-raylibfolder = ./raylib
+raylib_folder = ./raylib
 unityfolder = ./unity
 
 # --------------------------
@@ -43,4 +43,4 @@ test: input.o game.o unit_tests.c $(BINARIES)/libunity.a
 # Clean
 # --------------------------
 clean:
-	rm -f *.o wordsalad $(TEST_BIN)
+	rm -f *.o wordsalad

Start_Mac/unit_tests.c

@@ -101,35 +101,6 @@ void test_createWordSalad_too_small(void) {
     }
 }
 
-void test_createWordSalad_allWordsPlaced() {
-    char words[3][MAX_WORD_LEN] = {"CAT", "DOG", "MOUSE"};
-    char saladHoriz[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
-    char saladVert[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
-
-    int placed = createWordSalad(saladHoriz, 20, words, 3);
-    for(int i = 0; i < MAX_SEARCH_FIELD_LEN; i++)
-    {
-        for(int j = 0; j < MAX_SEARCH_FIELD_LEN; j++)
-        {
-            saladVert[j][i] = saladHoriz[i][j];
-        }
-    }
-
-    for(int i = 0; i < 3; i++) {
-        const char* word = words[i];
-        int wordFound = 0;
-        for(int j = 0; j < MAX_SEARCH_FIELD_LEN; j++)
-        {
-            const char* row = saladHoriz[j];
-            const char* col = saladVert[j];
-            wordFound |= strstr(row, word) || strstr(col, word);
-        }
-        TEST_ASSERT_TRUE_MESSAGE(wordFound, "Not all words were placed.");
-    }
-
-    TEST_ASSERT_EQUAL_INT(3, placed);
-}
-
 // ---------- Test Setup und TearDown Funktionen ----------
 
 // Hier Setup- und TearDown-Funktionen definieren,
@@ -164,7 +135,6 @@ int main(void) {
     RUN_TEST(test_readWords_empty_file);
     RUN_TEST(test_createWordSalad_all_fit);
     RUN_TEST(test_createWordSalad_too_small);
-    RUN_TEST(test_createWordSalad_allWordsPlaced);
 
     int result = UNITY_END();  // Test-Ergebnisse
     print_test_result(result);

Start_Windows/game.c

@@ -1,23 +1,125 @@
 #include "game.h"
-#include <time.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
 #define MAX_RAND_TRIES_PER_WORD 10
 #define EMPTY_CHAR 0
 
-//TODO: Spiellogik implementieren:
+int createWordSalad(
-/* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
-   * restliche Felder mit zufälligen Buchstaben füllen */
 
-// Creates the word salad by placing words randomly and filling empty spaces
+    char salad[MAX_SEARCH_FIELD_LEN]
-int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], unsigned int wordCount)
+              [MAX_SEARCH_FIELD_LEN], // salad ist Spielfeld 2D Array mit 20*20
-{
+                                      // Buchstaben
+    unsigned int searchFieldLen, const char words[][MAX_WORD_LEN],
+    unsigned int wordCount) {
 
+  enum Richtung { HORIZONTAL, VERTIKAL };
+
+  for (int x = 0; x < searchFieldLen; x++) {
+
+    for (int y = 0; y < searchFieldLen; y++) {
+
+      salad[y][x] = EMPTY_CHAR; // Spielfeld auf EmptyChar setzen
+    }
+  }
+  unsigned int placedWords = 0; // variable platzierte Wörter
+
+  // Wörter platzieren
+  // for schleife mit wortNummer = 0 bis wordCount - 1 (insgesamt wordCount)
+
+  for (int wortNummer = 0; wortNummer < wordCount; wortNummer++) {
+
+    // strlen mit Wortlänge
+    int wortLen = strlen(words[wortNummer]);
+
+    int platziert = 0; // variable, um platziertes Wort zu signalisieren
+    int versuch = 0;   // veruche bis max rand tries
+
+    while (versuch < MAX_RAND_TRIES_PER_WORD &&
+           platziert == 0) { // wort platziert -> Schleife wird verlassen oder
+                             // konnte nach 10 Versuchen nicht platziert werden
+
+      enum Richtung r =
+          (rand() % 2) ? HORIZONTAL : VERTIKAL; // mit rand Richtung
+
+      int x = rand() % searchFieldLen; // mit rand Koordinaten bestimmen
+      int y = rand() % searchFieldLen;
+      int wortFrei = 1; // Wort passt ins Feld und überschneidet sich nicht
+
+      if (r == VERTIKAL) {
+
+        if ((y + wortLen) > (searchFieldLen)) { // Wortlänge größer als Feld
+          wortFrei = 0;
+        }
+
+        for (int i = 0; (i < wortLen) && (wortFrei != 0); i++) {
+          char var = salad[y + i][x];
+          if (var != EMPTY_CHAR) {
+            wortFrei = 0; // Wort überschneidet sich mit bereits platziertem
+                          // Wort
+          }
+        }
+
+        if (wortFrei != 0) {
+
+          for (int i = 0; i < wortLen; i++) {
+
+            salad[y + i][x] = words[wortNummer][i]; // Wort platzieren
+          }
+          placedWords++;
+          platziert = 1; // schleife wird verlassen
+        }
+
+      }
+
+      else if (r == HORIZONTAL) {
+
+        if ((x + wortLen) > searchFieldLen) {
+          wortFrei = 0;
+        }
+
+        for (int i = 0; (i < wortLen) && (wortFrei != 0); i++) {
+          char var = salad[y][x + i];
+          if (var != EMPTY_CHAR) {
+            wortFrei = 0;
+          }
+        }
+
+        if (wortFrei != 0) {
+
+          for (int i = 0; i < wortLen; i++) {
+
+            salad[y][x + i] = words[wortNummer][i];
+          }
+          placedWords++;
+          platziert = 1;
+        }
+      }
+
+      versuch++;
+    }
+  }
+
+  for (int i = 0; i < searchFieldLen; i++) {
+
+    for (int j = 0; j < searchFieldLen; j++) {
+
+      if (salad[i][j] == EMPTY_CHAR) {
+
+        salad[i][j] = rand() % (90 - 65 + 1) + 65;
+      }
+    }
+  }
+  return placedWords;
 }
 
-// Prints the word salad to console
+void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
-void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
+                   unsigned int searchFieldLen) {
-{
 
+  for (int i = 0; i < searchFieldLen; i++) {
+    for (int j = 0; j < searchFieldLen; j++) {
+      printf("%c", salad[i][j]);
+    }
+  }
 }

Start_Windows/graphicalGame.c

@@ -7,22 +7,19 @@
 #define MAX_MESSAGE_LEN 256
 #define MAX_SOLUTION_WORD_LEN 16
 
-typedef struct
+typedef struct {
-{
   Vector2 startPosition;
   Vector2 endPosition;
   int isSelected;
 } MouseSelection;
 
-typedef struct
+typedef struct {
-{
   Vector2 position;
   char character[2];
   int isMarked;
 } CharSquare;
 
-typedef struct
+typedef struct {
-{
   CharSquare *squares;
   unsigned int count;
   unsigned int squareSize;
@@ -31,16 +28,14 @@ typedef struct
   Vector2 size;
 } CharSquarePanel;
 
-typedef struct
+typedef struct {
-{
   char content[MAX_WORD_LEN];
   char *solution;
   Vector2 position;
   int wasFound;
 } SearchWord;
 
-typedef struct
+typedef struct {
-{
   SearchWord *words;
   unsigned int count;
   int fontSize;
@@ -48,15 +43,13 @@ typedef struct
   Vector2 size;
 } SearchWordPanel;
 
-typedef struct
+typedef struct {
-{
   char content[MAX_MESSAGE_LEN];
   Vector2 position;
   unsigned int size;
 } WinMessage;
 
-typedef struct
+typedef struct {
-{
   char text[MAX_MESSAGE_LEN];
   Vector2 position;
   Vector2 size;
@@ -64,14 +57,14 @@ typedef struct
 } HelperMessage;
 
 // Creates a helper message to guide the user
-static HelperMessage createHelperMessage(unsigned int screenWidth)
+static HelperMessage createHelperMessage(unsigned int screenWidth) {
-{
+  const char *text = "Please search below for the words located at the bottom "
-    const char *text = "Please search below for the words located at the bottom \nand draw a line exactly on the desired characters ...";
+                     "\nand draw a line exactly on the desired characters ...";
   HelperMessage msg = {"", {0, 0}, {screenWidth, 0}, 18};
 
   // Copy text into msg, ensuring does not exceed max length
   strncpy(msg.text, text, MAX_MESSAGE_LEN);
-    msg.text[MAX_MESSAGE_LEN-1] = '\0';
+  msg.text[MAX_MESSAGE_LEN - 1] = '\0';
 
   // Set the vertical size based on font size
   msg.size.y = 3 * msg.fontSize;
@@ -80,26 +73,25 @@ static HelperMessage createHelperMessage(unsigned int screenWidth)
 }
 
 // Creates a winning message when the user wins
-static WinMessage createWinMessage(unsigned int screenSize)
+static WinMessage createWinMessage(unsigned int screenSize) {
-{
   WinMessage winMsg;
   char *text = "Congratulations! You won!";
 
   strncpy(winMsg.content, text, MAX_MESSAGE_LEN);
-    winMsg.content[MAX_MESSAGE_LEN-1] = '\0';
+  winMsg.content[MAX_MESSAGE_LEN - 1] = '\0';
   winMsg.size = 30; // Set font size
 
   // Calculate x and y positions for centering the message
-    winMsg.position.x = (screenSize - strlen(winMsg.content)*winMsg.size*0.52) / 2;
+  winMsg.position.x =
+      (screenSize - strlen(winMsg.content) * winMsg.size * 0.52) / 2;
   winMsg.position.y = screenSize / 2;
 
   return winMsg;
 }
 
 // Frees memory associated with a search word panel
-static void freeSearchWordPanel(SearchWordPanel *panel)
+static void freeSearchWordPanel(SearchWordPanel *panel) {
-{
+  for (int i = 0; panel->words != NULL && i < panel->count; i++)
-    for(int i = 0; panel->words != NULL && i < panel->count; i++)
     free(panel->words[i].solution); // Free solution strings
   free(panel->words);               // Free word array
   panel->words = NULL;
@@ -109,41 +101,41 @@ static void freeSearchWordPanel(SearchWordPanel *panel)
 }
 
 // Creates a panel to display a list of search words
-static SearchWordPanel createSearchWordPanel(const char words[][MAX_WORD_LEN], unsigned int numberOfWords, unsigned int windowOffset)
+static SearchWordPanel createSearchWordPanel(const char words[][MAX_WORD_LEN],
-{
+                                             unsigned int numberOfWords,
+                                             unsigned int windowOffset) {
   const int maxStringLenInPx = 200;         // Max width of each word
   const int fontSize = 18;                  // Font size for displaying words
   const int rowHeight = fontSize * 1.2 + 5; // Height of each row of words
 
-    SearchWordPanel panel = {NULL, 0, fontSize, {0, windowOffset}, {windowOffset, 0}};
+  SearchWordPanel panel = {
+      NULL, 0, fontSize, {0, windowOffset}, {windowOffset, 0}};
 
   unsigned int xOffset = 5;
   unsigned int yOffset = 15;
 
   // Allocate memory for words if any are present
-    if(numberOfWords > 0)
+  if (numberOfWords > 0)
     panel.words = (SearchWord *)malloc(sizeof(SearchWord) * numberOfWords);
 
   // If memory allocation is successful
-    if(panel.words != NULL)
+  if (panel.words != NULL) {
-    {
     // Loop through and set up the words and their positions
-        for(int i = 0; i < numberOfWords; i++)
+    for (int i = 0; i < numberOfWords; i++) {
-        {
       strncpy(panel.words[i].content, words[i], MAX_SOLUTION_WORD_LEN);
-            panel.words[i].content[MAX_SOLUTION_WORD_LEN-1] = '\0';
+      panel.words[i].content[MAX_SOLUTION_WORD_LEN - 1] = '\0';
 
       // Truncate word if exceeds max length
-            if(strlen(words[i]) > MAX_SOLUTION_WORD_LEN-1)
+      if (strlen(words[i]) > MAX_SOLUTION_WORD_LEN - 1)
-                strncpy(panel.words[i].content+MAX_SOLUTION_WORD_LEN-4, "...", 4);
+        strncpy(panel.words[i].content + MAX_SOLUTION_WORD_LEN - 4, "...", 4);
 
       // Allocate memory for solution word
-            panel.words[i].solution = (char *)malloc(sizeof(char) * (strlen(words[i]) + 1));
+      panel.words[i].solution =
+          (char *)malloc(sizeof(char) * (strlen(words[i]) + 1));
 
-            if(panel.words[i].solution != NULL)
+      if (panel.words[i].solution != NULL)
         strcpy(panel.words[i].solution, words[i]);
-            else
+      else {
-            {
         freeSearchWordPanel(&panel); // Free memory in case of failure
         numberOfWords = 0;
         break;
@@ -157,8 +149,7 @@ static SearchWordPanel createSearchWordPanel(const char words[][MAX_WORD_LEN], u
       xOffset += maxStringLenInPx + 5;
 
       // Move to next row if needed
-            if(xOffset > windowOffset)
+      if (xOffset > windowOffset) {
-            {
         xOffset = 5;
         yOffset += rowHeight;
       }
@@ -166,7 +157,7 @@ static SearchWordPanel createSearchWordPanel(const char words[][MAX_WORD_LEN], u
     panel.count = numberOfWords; // Sets total word count
 
     // Adjust panel size based on last word's position
-        if(numberOfWords > 0)
+    if (numberOfWords > 0)
       panel.size.y = panel.words[numberOfWords - 1].position.y + rowHeight;
   }
 
@@ -174,8 +165,8 @@ static SearchWordPanel createSearchWordPanel(const char words[][MAX_WORD_LEN], u
 }
 
 // Creates a square for a character in the search grid
-static CharSquare createSquare(unsigned int rowIdx, unsigned int colIdx, char character, unsigned int squareSize)
+static CharSquare createSquare(unsigned int rowIdx, unsigned int colIdx,
-{
+                               char character, unsigned int squareSize) {
   CharSquare square;
   square.position.x = colIdx * squareSize;
   square.position.y = rowIdx * squareSize;
@@ -187,26 +178,29 @@ static CharSquare createSquare(unsigned int rowIdx, unsigned int colIdx, char ch
 }
 
 // Creates a panel of character squares (the search grid)
-static CharSquarePanel createCharSquarePanel(const char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldSizeInChars, int panelSizeInPx)
+static CharSquarePanel createCharSquarePanel(
-{
+    const char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
+    unsigned int searchFieldSizeInChars, int panelSizeInPx) {
   CharSquarePanel squarePanel;
-    squarePanel.squares = (CharSquare *)malloc(sizeof(CharSquare) * searchFieldSizeInChars * searchFieldSizeInChars);
+  squarePanel.squares = (CharSquare *)malloc(
+      sizeof(CharSquare) * searchFieldSizeInChars * searchFieldSizeInChars);
   squarePanel.count = 0;
-    squarePanel.squareSize = (double)panelSizeInPx / searchFieldSizeInChars;  // Calculate the square size
+  squarePanel.squareSize = (double)panelSizeInPx /
-    squarePanel.fontSize = squarePanel.squareSize * 0.75;  // Set font size relative to square size
+                           searchFieldSizeInChars; // Calculate the square size
+  squarePanel.fontSize =
+      squarePanel.squareSize * 0.75; // Set font size relative to square size
   squarePanel.position.x = 0;
   squarePanel.position.y = 0;
   squarePanel.size.x = panelSizeInPx;
   squarePanel.size.y = panelSizeInPx;
 
-    // If memory for squares is allocated successfully loop through grid and create squares for each character
+  // If memory for squares is allocated successfully loop through grid and
-    if(squarePanel.squares != NULL)
+  // create squares for each character
-    {
+  if (squarePanel.squares != NULL) {
-        for(int i = 0; i < searchFieldSizeInChars; i++)
+    for (int i = 0; i < searchFieldSizeInChars; i++) {
-        {
+      for (int j = 0; j < searchFieldSizeInChars; j++) {
-            for(int j = 0; j < searchFieldSizeInChars; j++)
+        squarePanel.squares[squarePanel.count] =
-            {
+            createSquare(i, j, wordSalad[i][j], squarePanel.squareSize);
-                squarePanel.squares[squarePanel.count] = createSquare(i, j, wordSalad[i][j], squarePanel.squareSize);
         squarePanel.count++;
       }
     }
@@ -216,50 +210,49 @@ static CharSquarePanel createCharSquarePanel(const char wordSalad[MAX_SEARCH_FIE
 }
 
 // Frees memory associated with CharSquarePanel
-static void freeCharSquarePanel(CharSquarePanel *squarePanel)
+static void freeCharSquarePanel(CharSquarePanel *squarePanel) {
-{
   free(squarePanel->squares); // Free squares array
   squarePanel->squares = NULL;
   squarePanel->count = 0; // Reset count
 }
 
 // Draws all squares of CharSquarePanel
-static void drawSquares(const CharSquarePanel squarePanel)
+static void drawSquares(const CharSquarePanel squarePanel) {
-{
   float fontOffset = squarePanel.squareSize / 4; // Offset for font positioning
 
   // Loop through all squares and draw them
-    for(int i = 0; i < squarePanel.count; i++)
+  for (int i = 0; i < squarePanel.count; i++) {
-    {
     CharSquare square = squarePanel.squares[i];
 
-        Vector2 squareScreenCoord = {squarePanel.position.x + square.position.x, squarePanel.position.y + square.position.y};
+    Vector2 squareScreenCoord = {squarePanel.position.x + square.position.x,
+                                 squarePanel.position.y + square.position.y};
     Color squareColor = DARKBLUE;
     Color fontColor = LIGHTGRAY;
 
     // Change colors if is marked
-        if(square.isMarked)
+    if (square.isMarked) {
-        {
       squareColor = GREEN;
       fontColor = BLACK;
     }
 
     // Draw square and its border
-        DrawRectangle(squareScreenCoord.x, squareScreenCoord.y, squarePanel.squareSize, squarePanel.squareSize, squareColor);
+    DrawRectangle(squareScreenCoord.x, squareScreenCoord.y,
-        for(int i = 1; i <= 3; i++)
+                  squarePanel.squareSize, squarePanel.squareSize, squareColor);
-            DrawRectangleLines(squareScreenCoord.x, squareScreenCoord.y, squarePanel.squareSize-i, squarePanel.squareSize-i, LIGHTGRAY);
+    for (int i = 1; i <= 3; i++)
+      DrawRectangleLines(squareScreenCoord.x, squareScreenCoord.y,
+                         squarePanel.squareSize - i, squarePanel.squareSize - i,
+                         LIGHTGRAY);
 
     // Draw character inside the square
-        DrawText(square.character, squareScreenCoord.x + fontOffset, squareScreenCoord.y + fontOffset, squarePanel.fontSize, fontColor);
+    DrawText(square.character, squareScreenCoord.x + fontOffset,
+             squareScreenCoord.y + fontOffset, squarePanel.fontSize, fontColor);
   }
 }
 
 // Checks if selected word is valid solution
-static int isSolution(const char *solution, SearchWordPanel searchWordPanel)
+static int isSolution(const char *solution, SearchWordPanel searchWordPanel) {
-{
+  for (int i = 0; i < searchWordPanel.count; i++)
-    for(int i = 0; i < searchWordPanel.count; i++)
+    if (strcmp(solution, searchWordPanel.words[i].solution) == 0) {
-        if(strcmp(solution, searchWordPanel.words[i].solution) == 0)
-        {
       // Mark word as found and return true if solution matches
       searchWordPanel.words[i].wasFound = 1;
       return 1;
@@ -269,23 +262,25 @@ static int isSolution(const char *solution, SearchWordPanel searchWordPanel)
 }
 
 // Updates the marked squares based on user selection
-static void updateSelectedSquares(const MouseSelection selection, CharSquarePanel squarePanel, SearchWordPanel searchWordPanel)
+static void updateSelectedSquares(const MouseSelection selection,
-{
+                                  CharSquarePanel squarePanel,
+                                  SearchWordPanel searchWordPanel) {
   unsigned int wordIdx = 0;
   char selectedWord[MAX_WORD_LEN];
   unsigned int selectedIdx[squarePanel.count];
   float radius = squarePanel.squareSize / 2;
 
   // Loop through all squares and check if selected
-    for(int i = 0; i < squarePanel.count && wordIdx < MAX_WORD_LEN-1; i++)
+  for (int i = 0; i < squarePanel.count && wordIdx < MAX_WORD_LEN - 1; i++) {
-    {
+    Vector2 center = {
-        Vector2 center = {squarePanel.squares[i].position.x + squarePanel.position.x, squarePanel.squares[i].position.y + squarePanel.position.y};
+        squarePanel.squares[i].position.x + squarePanel.position.x,
+        squarePanel.squares[i].position.y + squarePanel.position.y};
     center.x += radius;
     center.y += radius;
 
     // Check if square is selected by mouse
-        if(CheckCollisionCircleLine(center, radius, selection.startPosition, selection.endPosition))
+    if (CheckCollisionCircleLine(center, radius, selection.startPosition,
-        {
+                                 selection.endPosition)) {
       selectedWord[wordIdx] = squarePanel.squares[i].character[0];
       selectedIdx[wordIdx] = i;
       wordIdx++;
@@ -294,71 +289,76 @@ static void updateSelectedSquares(const MouseSelection selection, CharSquarePane
   selectedWord[wordIdx] = '\0';
 
   // If selected word is a solution, mark it
-    if(isSolution(selectedWord, searchWordPanel))
+  if (isSolution(selectedWord, searchWordPanel)) {
-    {
+    for (int i = 0; i < wordIdx; i++)
-        for(int i = 0; i < wordIdx; i++)
       squarePanel.squares[selectedIdx[i]].isMarked = 1;
   }
 }
 
 // Handles mouse input for selecting words in grid
-static void handleMouseInput(MouseSelection *selection, CharSquarePanel squarePanel, SearchWordPanel searchWordPanel)
+static void handleMouseInput(MouseSelection *selection,
-{
+                             CharSquarePanel squarePanel,
-    if(IsMouseButtonPressed(MOUSE_BUTTON_LEFT))  // Start new selection
+                             SearchWordPanel searchWordPanel) {
+  if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) // Start new selection
   {
     selection->startPosition = GetMousePosition();
     selection->endPosition = selection->startPosition;
     selection->isSelected = 1;
-    }
+  } else if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) // End selection
-    else if(IsMouseButtonReleased(MOUSE_BUTTON_LEFT))  // End selection
   {
     updateSelectedSquares(*selection, squarePanel, searchWordPanel);
 
     selection->isSelected = 0;
-    }
+  } else if (IsMouseButtonDown(
-    else if(IsMouseButtonDown(MOUSE_BUTTON_LEFT))  // Update end position while selecting
+                 MOUSE_BUTTON_LEFT)) // Update end position while selecting
   {
     selection->endPosition = GetMousePosition();
   }
 }
 
 // Draws selection line on screen if selection is active
-static void drawSelection(const MouseSelection selection)
+static void drawSelection(const MouseSelection selection) {
-{
+  if (selection.isSelected) {
-    if(selection.isSelected)
+    DrawLine(selection.startPosition.x, selection.startPosition.y,
-    {
+             selection.endPosition.x, selection.endPosition.y, WHITE);
-        DrawLine(selection.startPosition.x, selection.startPosition.y, selection.endPosition.x, selection.endPosition.y, WHITE);
   }
 }
 
 // Draws search word panel (list of words to be found)
-static void drawSearchWordPanel(SearchWordPanel searchWordPanel)
+static void drawSearchWordPanel(SearchWordPanel searchWordPanel) {
-{
+  for (int i = 0; i < searchWordPanel.count; i++) {
-    for(int i = 0; i < searchWordPanel.count; i++)
+    Vector2 wordScreenCoord = {
-    {
+        searchWordPanel.words[i].position.x + searchWordPanel.position.x,
-        Vector2 wordScreenCoord = {searchWordPanel.words[i].position.x + searchWordPanel.position.x, searchWordPanel.words[i].position.y + searchWordPanel.position.y};
+        searchWordPanel.words[i].position.y + searchWordPanel.position.y};
-        DrawText(searchWordPanel.words[i].content, wordScreenCoord.x, wordScreenCoord.y, searchWordPanel.fontSize, WHITE);
+    DrawText(searchWordPanel.words[i].content, wordScreenCoord.x,
+             wordScreenCoord.y, searchWordPanel.fontSize, WHITE);
 
     // If word has been found, highlight it
-        if(searchWordPanel.words[i].wasFound)
+    if (searchWordPanel.words[i].wasFound) {
-        {
+      int xOffset = MeasureText(searchWordPanel.words[i].content,
-            int xOffset = MeasureText(searchWordPanel.words[i].content, searchWordPanel.fontSize);
+                                searchWordPanel.fontSize);
-            for(int i = 0; i <= 3; i++)
+      for (int i = 0; i <= 3; i++)
-                DrawLine(wordScreenCoord.x - 3, wordScreenCoord.y + 5 + i, wordScreenCoord.x + xOffset + 3, wordScreenCoord.y + 5 + i, GREEN);
+        DrawLine(wordScreenCoord.x - 3, wordScreenCoord.y + 5 + i,
+                 wordScreenCoord.x + xOffset + 3, wordScreenCoord.y + 5 + i,
+                 GREEN);
     }
   }
 }
 
 // Draws helper message (instructions or tips for user)
-static void drawHelperMessage(const HelperMessage msg)
+static void drawHelperMessage(const HelperMessage msg) {
-{
+  DrawRectangle(msg.position.x, msg.position.y, msg.size.x, msg.size.y,
-    DrawRectangle(msg.position.x, msg.position.y, msg.size.x, msg.size.y, BLACK);  // Background for message
+                BLACK); // Background for message
-    DrawText(msg.text, msg.position.x + 5, msg.position.y + 5, msg.fontSize, WHITE);  // Display message text
+  DrawText(msg.text, msg.position.x + 5, msg.position.y + 5, msg.fontSize,
+           WHITE); // Display message text
 }
 
-// Draws the entire game content, including helper message, squares, and search words
+// Draws the entire game content, including helper message, squares, and search
-static void drawGameContent(const HelperMessage helperMsg, const CharSquarePanel squarePanel, const MouseSelection selection, const SearchWordPanel searchWordPanel)
+// words
-{
+static void drawGameContent(const HelperMessage helperMsg,
+                            const CharSquarePanel squarePanel,
+                            const MouseSelection selection,
+                            const SearchWordPanel searchWordPanel) {
   drawHelperMessage(helperMsg);
   drawSquares(squarePanel);
   drawSearchWordPanel(searchWordPanel);
@@ -366,69 +366,86 @@ static void drawGameContent(const HelperMessage helperMsg, const CharSquarePanel
 }
 
 // Draws success message when player wins
-static void drawSuccessContent(WinMessage msg)
+static void drawSuccessContent(WinMessage msg) {
-{
   unsigned int textWidth = MeasureText(msg.content, msg.size);
-    DrawRectangle(msg.position.x-20, msg.position.y-20, textWidth+40, msg.size+40, GREEN);  // Background for success message
+  DrawRectangle(msg.position.x - 20, msg.position.y - 20, textWidth + 40,
+                msg.size + 40, GREEN); // Background for success message
 
-    for(int i = 0; i < 5; i++)  // Draw borders around success message
+  for (int i = 0; i < 5; i++) // Draw borders around success message
-        DrawRectangleLines(msg.position.x-20+i, msg.position.y-20+i, textWidth+40-i*2, msg.size+40-i*2, WHITE);
+    DrawRectangleLines(msg.position.x - 20 + i, msg.position.y - 20 + i,
+                       textWidth + 40 - i * 2, msg.size + 40 - i * 2, WHITE);
 
-    DrawText(msg.content, msg.position.x, msg.position.y, msg.size, WHITE);  // Display success text
+  DrawText(msg.content, msg.position.x, msg.position.y, msg.size,
+           WHITE); // Display success text
 }
 
-// Draws entire game screen, including game content and success message if applicable
+// Draws entire game screen, including game content and success message if
-static void drawAll(const CharSquarePanel squarePanel, const MouseSelection selection, const SearchWordPanel searchWordPanel, const HelperMessage helperMsg, const WinMessage msg, int hasWon)
+// applicable
-{
+static void drawAll(const CharSquarePanel squarePanel,
+                    const MouseSelection selection,
+                    const SearchWordPanel searchWordPanel,
+                    const HelperMessage helperMsg, const WinMessage msg,
+                    int hasWon) {
   BeginDrawing();
   ClearBackground(BLACK); // Clear screen with a black background
-    drawGameContent(helperMsg, squarePanel, selection, searchWordPanel);  // Draw game content
+  drawGameContent(helperMsg, squarePanel, selection,
+                  searchWordPanel); // Draw game content
 
-    if(hasWon)  // If player has won, draw success message
+  if (hasWon) // If player has won, draw success message
     drawSuccessContent(msg);
 
   EndDrawing();
 }
 
 // Checks if all words in the search word panel have been found
-static int allWordsFound(SearchWordPanel searchWordPanel)
+static int allWordsFound(SearchWordPanel searchWordPanel) {
-{
   // Loop through all words and check if any is not found
-    for(int i = 0; i < searchWordPanel.count; i++)
+  for (int i = 0; i < searchWordPanel.count; i++)
-        if(!searchWordPanel.words[i].wasFound)
+    if (!searchWordPanel.words[i].wasFound)
       return 0; // Return false if any word is not found
   return 1;     // Return true if all words are found
 }
 
 // Main game loop where game is run and updated
-static void gameLoop(const Vector2 screenSize, MouseSelection mouseSelection, CharSquarePanel squarePanel, SearchWordPanel searchWordPanel, const HelperMessage helperMsg,  const WinMessage winMsg)
+static void gameLoop(const Vector2 screenSize, MouseSelection mouseSelection,
-{
+                     CharSquarePanel squarePanel,
-    InitWindow(screenSize.x, screenSize.y, "Word Salad");  // Initialize game window
+                     SearchWordPanel searchWordPanel,
+                     const HelperMessage helperMsg, const WinMessage winMsg) {
+  InitWindow(screenSize.x, screenSize.y,
+             "Word Salad"); // Initialize game window
 
   SetTargetFPS(60);
 
   while (!WindowShouldClose()) // Keep running until window is closed
   {
-        handleMouseInput(&mouseSelection, squarePanel, searchWordPanel);  // Handle mouse input (selection)
+    handleMouseInput(&mouseSelection, squarePanel,
+                     searchWordPanel); // Handle mouse input (selection)
 
-        // Draw all game content including helper message, squares, and search word panel
+    // Draw all game content including helper message, squares, and search word
-        drawAll(squarePanel, mouseSelection, searchWordPanel, helperMsg, winMsg, allWordsFound(searchWordPanel));
+    // panel
+    drawAll(squarePanel, mouseSelection, searchWordPanel, helperMsg, winMsg,
+            allWordsFound(searchWordPanel));
   }
 
   CloseWindow();
 }
 
-// Initializes and starts game, setting up necessary elements and entering game loop
+// Initializes and starts game, setting up necessary elements and entering game
-void startGame(const char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldSize, char words[][MAX_WORD_LEN], unsigned int numberOfWords, unsigned int windowSize)
+// loop
-{
+void startGame(const char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
+               unsigned int searchFieldSize, char words[][MAX_WORD_LEN],
+               unsigned int numberOfWords, unsigned int windowSize) {
   const int windowWidth = windowSize;
 
   Vector2 screenSize;
 
-    // Create necessary game elements like helper message, square panel, and search word panel
+  // Create necessary game elements like helper message, square panel, and
+  // search word panel
   HelperMessage helperMsg = createHelperMessage(windowWidth);
-    CharSquarePanel squarePanel = createCharSquarePanel(wordSalad, searchFieldSize, windowWidth);
+  CharSquarePanel squarePanel =
-    SearchWordPanel searchWordPanel = createSearchWordPanel(words, numberOfWords, windowWidth);
+      createCharSquarePanel(wordSalad, searchFieldSize, windowWidth);
+  SearchWordPanel searchWordPanel =
+      createSearchWordPanel(words, numberOfWords, windowWidth);
   WinMessage winMsg = createWinMessage(windowWidth);
 
   MouseSelection mouseSelection;
@@ -444,7 +461,8 @@ void startGame(const char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
   screenSize.y = helperMsg.size.y + squarePanel.size.y + searchWordPanel.size.y;
 
   // Start game loop
-    gameLoop(screenSize, mouseSelection, squarePanel, searchWordPanel, helperMsg, winMsg);
+  gameLoop(screenSize, mouseSelection, squarePanel, searchWordPanel, helperMsg,
+           winMsg);
 
   // Free up allocated memory when game is done
   freeCharSquarePanel(&squarePanel);
@@ -452,4 +470,4 @@ void startGame(const char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
 }
 
 /*gcc -fPIC -c input.c game.c graphicalGame.c main.c
-gcc -shared -o libwortsalat.a input.o game.o graphicalGame.o main.o*/
+gcc -shared -o libwordsalad.a input.o game.o graphicalGame.o main.o*/

Start_Windows/input.c

@@ -1,12 +1,44 @@
 #include "input.h"
-#include <string.h>
 #include <ctype.h>
-
+#include <string.h>
-// TODO:
-// eine Funktion implementieren, die ein einzelnes Wort aus einer Textdatei (words.txt) einliest und als C-String zurückgibt.
 
 // Read words from file and store in 'words' array
-int readWords(FILE *file, char words[][MAX_WORD_LEN], unsigned int maxWordCount)
+int readWords(FILE *file, char words[][MAX_WORD_LEN],
-{
+              unsigned int maxWordCount) {
 
+  if (file == NULL) {
+    printf("File couldn't be opened...");
+    return 0;
+  }
+
+  char line[MAX_LINE_LEN];    // fehlerhaften String zwischenspeichern
+  unsigned int wordCount = 0; // eingelesene Wörter
+
+  while ((fgets(line, sizeof(line), file) != NULL) &&
+         (wordCount < maxWordCount)) { // gesamte Wörterliste einlesen
+
+    // Token initialisieren
+    char *token = strtok(
+        line, " ,;.\n"); // Trennen der Wörter bei den angegebenen Zeichen
+
+    while (token && (wordCount < maxWordCount)) {
+
+      if (*token == '\0') {
+        token = strtok(NULL, " ,;.\n");
+        continue;
+      }
+
+      for (int i = 0; token[i] != '\0'; i++) {
+        token[i] = toupper(token[i]); // Alles in Großbuchstaben
+      }
+
+      strcpy(words[wordCount], token); // einzelnes Wort in words array
+                                       // speichern
+
+      wordCount++;                    // Nächstes Wort
+      token = strtok(NULL, " ,;.\n"); // Nächster Token
+    }
+  }
+
+  return wordCount; // Anzahl der eingelesenen Wörter
 }

Start_Windows/main.c

@@ -1,33 +1,32 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include "input.h"
 #include "game.h"
 #include "graphicalGame.h"
+#include "input.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
 
 #define MAX_NUMBER_OF_WORDS 100
 #define SALAD_SIZE 20
 
-int main(int argc, char *argv[])
+int main(int argc, char *argv[]) {
-{
+  srand(time(NULL));
   int exitCode = EXIT_SUCCESS;
 
   // Check if the correct number of arguments is provided
-    if(argc != 2)
+  if (argc != 2) {
-    {
     fprintf(stderr, "Usage: %s <path to file with search words>\n", argv[0]);
     exitCode = EXIT_FAILURE;
-    }
+  } else {
-    else
+    char words[MAX_NUMBER_OF_WORDS]
-    {
+              [MAX_WORD_LEN]; // Array to hold the words to be used in the game
-        char words[MAX_NUMBER_OF_WORDS][MAX_WORD_LEN]; // Array to hold the words to be used in the game
     unsigned int wordCount = 0;
 
     FILE *file = fopen(argv[1], "r");
 
-        if(file != NULL)
+    if (file != NULL) {
-        {
       unsigned int placedWords = 0;
-            char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN]; // 2D array to store the word salad
+      char wordSalad[MAX_SEARCH_FIELD_LEN]
+                    [MAX_SEARCH_FIELD_LEN]; // 2D array to store the word salad
 
       // Read words from file and store in 'words' array
       wordCount = readWords(file, words, MAX_NUMBER_OF_WORDS);
@@ -40,10 +39,23 @@ int main(int argc, char *argv[])
       // Check if all words were successfully placed
       // Start the game if successful
       // error message if some words couldn't be placed
+      printf("Placed Words: %d\n", placedWords);
+      printf("Word Count:%d\n", wordCount);
+
+      if (placedWords == wordCount) {
+
+        startGame(wordSalad, SALAD_SIZE, words, placedWords, 1024);
 
       }
+
       else
+
       {
+        // Print error message if words couldn't be placed
+        printf("Placed %d words of %d.", placedWords, wordCount);
+        exitCode = EXIT_FAILURE;
+      }
+    } else {
       // Print error message if file couldn't be opened
       fprintf(stderr, "Could not open file %s for reading ...\n", argv[1]);
       exitCode = EXIT_FAILURE;

Start_Windows/makefile

@@ -3,7 +3,7 @@ CFLAGS = -g -Wall
 LDFLAGS = -lopengl32 -lgdi32 -lwinmm
 BINARIES = ./windows
 
-raylibfolder = ./raylib
+raylib_folder = ./raylib
 unityfolder = ./unity
 
 # --------------------------
@@ -12,12 +12,21 @@ unityfolder = ./unity
 wordsalad_initial:
 	$(CC) -o wordsalad_initial $(BINARIES)/libwordsalad_complete.a $(BINARIES)/libraylib.a $(LDFLAGS)
 
+#---------------------------
+# eigenes Target bauen
+#---------------------------
+wordsalad_myversion: main.o graphicalGame.o input.o game.o
+	$(CC) main.o graphicalGame.o input.o game.o -o wordsalad_myversion $(BINARIES)/libraylib.a $(LDFLAGS)
+
 # --------------------------
 # Normales Spiel bauen
 # --------------------------
-all: main.o input.o game.o graphicalGame.o $(BINARIES)/libraylib.a
+all: $(BINARIES)/libwordsalad.a main.o input.o game.o graphicalGame.o $(BINARIES)/libraylib.a
 	$(CC) $(CFLAGS) -o wordsalad main.o input.o game.o graphicalGame.o $(BINARIES)/libraylib.a $(LDFLAGS)
 
+$(BINARIES)/libwordsalad.a: main.o input.o game.o graphicalGame.o
+	ar rcs $(BINARIES)/libwordsalad.a main.o input.o game.o graphicalGame.o
+
 main.o: main.c
 	$(CC) -c $(CFLAGS) main.c
 
@@ -28,7 +37,7 @@ game.o: game.c
 	$(CC) -c $(CFLAGS) game.c
 
 graphicalGame.o: graphicalGame.c
-	$(CC) -I$(raylibfolder) -c $(CFLAGS) graphicalGame.c
+	$(CC) -I$(raylib_folder) $(CFLAGS) -c graphicalGame.c
 
 # --------------------------
 # Unit Tests
@@ -42,4 +51,4 @@ test: input.o game.o unit_tests.c
 # Clean
 # --------------------------
 clean:
-	del /f *.o *.exe
+	rm -f *.o *.exe $(BINARIES)/libwordsalad.a

Start_Windows/unit_tests.c

@@ -101,35 +101,6 @@ void test_createWordSalad_too_small(void) {
     }
 }
 
-void test_createWordSalad_allWordsPlaced() {
-    char words[3][MAX_WORD_LEN] = {"CAT", "DOG", "MOUSE"};
-    char saladHoriz[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
-    char saladVert[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
-
-    int placed = createWordSalad(saladHoriz, 20, words, 3);
-    for(int i = 0; i < MAX_SEARCH_FIELD_LEN; i++)
-    {
-        for(int j = 0; j < MAX_SEARCH_FIELD_LEN; j++)
-        {
-            saladVert[j][i] = saladHoriz[i][j];
-        }
-    }
-
-    for(int i = 0; i < 3; i++) {
-        const char* word = words[i];
-        int wordFound = 0;
-        for(int j = 0; j < MAX_SEARCH_FIELD_LEN; j++)
-        {
-            const char* row = saladHoriz[j];
-            const char* col = saladVert[j];
-            wordFound |= strstr(row, word) || strstr(col, word);
-        }
-        TEST_ASSERT_TRUE_MESSAGE(wordFound, "Not all words were placed.");
-    }
-
-    TEST_ASSERT_EQUAL_INT(3, placed);
-}
-
 // ---------- Test Setup und TearDown Funktionen ----------
 
 // Hier Setup- und TearDown-Funktionen definieren,
@@ -164,7 +135,6 @@ int main(void) {
     RUN_TEST(test_readWords_empty_file);
     RUN_TEST(test_createWordSalad_all_fit);
     RUN_TEST(test_createWordSalad_too_small);
-    RUN_TEST(test_createWordSalad_allWordsPlaced);
 
     int result = UNITY_END();  // Test-Ergebnisse
     print_test_result(result);

Start_Windows/words.txt

@@ -1,5 +1,6 @@
 Yeti,Nessie Werwolf; Vampir
 Monster
 Hydra;Frankenstein
-Dracula;KingKong;Gremlin;Kobold,Hexe;Poltergeist
+Dracula;KingKong,xxxxxxxx
-Gespenst, Oger
+Max, Tobi, Kristin
+

info2Praktikum-Wortsalat.kdev4

@@ -1,4 +0,0 @@
-[Project]
-CreatedFrom=
-Manager=KDevGenericManager
-Name=info2Praktikum-Wortsalat