Implement word placement logic and file reading functionality for word salad game

.gitignore

@@ -1,6 +1 @@
-wordsalad_initial
+Start_Linux/wordsalad_initial
-runTests
-.vscode
-*.o
-*.exe
-wordsalad

Start_Linux/game.c

@@ -2,27 +2,159 @@
 #include <time.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 
 #define MAX_RAND_TRIES_PER_WORD 10
 #define EMPTY_CHAR 0
 
-//TODO: Spiellogik implementieren:
+// Helper function to check if a word can be placed at a specific position
-/* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
+static int canPlaceWord(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
-   * restliche Felder mit zufälligen Buchstaben füllen */
+                       const char *word, unsigned int row, unsigned int col, 
+                       int horizontal, unsigned int searchFieldLen)
+{
+    unsigned int wordLen = strlen(word);
+    
+    if (horizontal)
+    {
+        // Check if word fits horizontally
+        if (col + wordLen > searchFieldLen)
+            return 0;
+            
+        // Check if all positions are empty or match the word
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            if (salad[row][col + i] != EMPTY_CHAR && salad[row][col + i] != word[i])
+                return 0;
+        }
+    }
+    else
+    {
+        // Check if word fits vertically
+        if (row + wordLen > searchFieldLen)
+            return 0;
+            
+        // Check if all positions are empty or match the word
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            if (salad[row + i][col] != EMPTY_CHAR && salad[row + i][col] != word[i])
+                return 0;
+        }
+    }
+    
+    return 1;
+}
+
+// Helper function to place a word at a specific position
+static void placeWord(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                     const char *word, unsigned int row, unsigned int col, 
+                     int horizontal)
+{
+    unsigned int wordLen = strlen(word);
+    
+    if (horizontal)
+    {
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            salad[row][col + i] = word[i];
+        }
+    }
+    else
+    {
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            salad[row + i][col] = word[i];
+        }
+    }
+}
 
 // Creates the word salad by placing words randomly and filling empty spaces
-int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], unsigned int wordCount)
+int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                    unsigned int searchFieldLen, 
+                    const char words[][MAX_WORD_LEN], 
+                    unsigned int wordCount)
 {
+    // Initialize random seed
+    srand(time(NULL));
     
+    // Initialize the grid with empty characters
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            salad[i][j] = EMPTY_CHAR;
+        }
+    }
+    
+    unsigned int placedWords = 0;
+    
+    // Try to place each word
+    for (unsigned int w = 0; w < wordCount; w++)
+    {
+        unsigned int wordLen = strlen(words[w]);
+        int placed = 0;
+        
+        // Skip empty words or words that are too long
+        if (wordLen == 0 || wordLen > searchFieldLen)
+            continue;
+        
+        // Try to place the word MAX_RAND_TRIES_PER_WORD times
+        for (int tries = 0; tries < MAX_RAND_TRIES_PER_WORD && !placed; tries++)
+        {
+            // Random direction: 0 = horizontal, 1 = vertical
+            int horizontal = rand() % 2;
+            
+            // Random position
+            unsigned int row = rand() % searchFieldLen;
+            unsigned int col = rand() % searchFieldLen;
+            
+            // Check if word can be placed
+            if (canPlaceWord(salad, words[w], row, col, horizontal, searchFieldLen))
+            {
+                placeWord(salad, words[w], row, col, horizontal);
+                placed = 1;
+                placedWords++;
+            }
+        }
+    }
+    
+    // Fill remaining empty spaces with random letters
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            if (salad[i][j] == EMPTY_CHAR)
+            {
+                salad[i][j] = 'A' + (rand() % 26);
+            }
+        }
+    }
+    
+    return placedWords;
 }
 
 // Prints the word salad to console
-void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
+void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                   unsigned int searchFieldLen)
 {
+    printf("\nWord Salad:\n");
+    printf("  ");
     
+    // Print column numbers
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        printf("%2u ", i);
     }
+    printf("\n");
     
-//Fill up Word salad
+    // Print rows with row numbers
-void fillWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN]){
+    for (unsigned int i = 0; i < searchFieldLen; i++)
-   
+    {
+        printf("%2u ", i);
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            printf("%2c ", salad[i][j]);
+        }
+        printf("\n");
+    }
+    printf("\n");
 }

Start_Linux/input.c

@@ -2,23 +2,38 @@
 #include <string.h>
 #include <ctype.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)
 {
-    char word[MAX_WORD_LEN];
+    unsigned int wordCount = 0;
+    char line[MAX_LINE_LEN];
     
-    // we possibly don't need fopen, since file is already a parameter 
+    // Read file line by line
-    // fopen(stream)
+    while (fgets(line, MAX_LINE_LEN, file) != NULL && wordCount < maxWordCount)
+    {
+        // Process each line to extract words separated by delimiters
+        char *token = strtok(line, " ,;\n\t\r");
         
-    fgets(word, MAX_WORD_LEN,file);
+        while (token != NULL && wordCount < maxWordCount)
-    // fgets(string, length, file *stream)
+        {
+            // Convert word to uppercase and store it
+            unsigned int i = 0;
+            while (token[i] != '\0' && i < MAX_WORD_LEN - 1)
+            {
+                words[wordCount][i] = toupper((unsigned char)token[i]);
+                i++;
+            }
+            words[wordCount][i] = '\0';
             
-    strcpy(words[maxWordCount-1], word);
+            // Only count non-empty words
-    maxWordCount++;
+            if (i > 0)
-    // we possibly also won't need to close the 
+            {
-    //    fclose( *<stream>) 
+                wordCount++;
-    return 0;
+            }
+            
+            token = strtok(NULL, " ,;\n\t\r");
+        }
+    }
+    
+    return wordCount;
 }

Start_Linux/main.c

@@ -36,10 +36,26 @@ int main(int argc, char *argv[])
             // Create the word salad by placing words into grid
             placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, wordCount);
 
-            // TODO:
             // Check if all words were successfully placed
-            // Start the game if successful
+            if (placedWords == wordCount)
-            // error message if some words couldn't be placed
+            {
+                // All words placed successfully - start the game
+                printf("Successfully placed all %u words!\n", placedWords);
+                showWordSalad(wordSalad, SALAD_SIZE);
+                
+                // Start the graphical game
+                startGraphicalGame(wordSalad, SALAD_SIZE, words, wordCount);
+            }
+            else
+            {
+                // Some words couldn't be placed
+                fprintf(stderr, "Warning: Could only place %u out of %u words.\n", 
+                        placedWords, wordCount);
+                showWordSalad(wordSalad, SALAD_SIZE);
+                
+                // Start the game anyway with the words that were placed
+                startGraphicalGame(wordSalad, SALAD_SIZE, words, wordCount);
+            }
 
         }
         else

Start_Linux/makefile

@@ -6,6 +6,12 @@ BINARIES = ./linux
 raylibfolder = ./raylib
 unityfolder = ./unity
 
+# --------------------------
+# initiales Spiel bauen
+# --------------------------
+wordsalad_initial:
+	$(CC) -o wordsalad_initial -L. $(BINARIES)/libwordsalad_complete.a $(BINARIES)/libraylib.a $(LDFLAGS)
+
 # --------------------------
 # Normales Spiel bauen
 # --------------------------
@@ -24,13 +30,6 @@ game.o: game.c
 graphicalGame.o: graphicalGame.c
 	$(CC) $(CFLAGS) -I$(raylibfolder) -c graphicalGame.c
 
-
-# --------------------------
-# initiales Spiel bauen
-# --------------------------
-wordsalad_initial:
-	$(CC) -o wordsalad_initial -L. $(BINARIES)/libwordsalad_complete.a $(BINARIES)/libraylib.a $(LDFLAGS)
-
 # --------------------------
 # Unit Tests
 # --------------------------
@@ -39,7 +38,6 @@ TEST_BIN = runTests
 test: input.o game.o unit_tests.c
 	$(CC) -I$(unityfolder) -o $(TEST_BIN) input.o game.o unit_tests.c $(BINARIES)/libunity.a
 
-
 # --------------------------
 # Clean
 # --------------------------

Start_Mac/game.c

@@ -2,22 +2,159 @@
 #include <time.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 
 #define MAX_RAND_TRIES_PER_WORD 10
 #define EMPTY_CHAR 0
 
-//TODO: Spiellogik implementieren:
+// Helper function to check if a word can be placed at a specific position
-/* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
+static int canPlaceWord(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
-   * restliche Felder mit zufälligen Buchstaben füllen */
+                       const char *word, unsigned int row, unsigned int col, 
+                       int horizontal, unsigned int searchFieldLen)
+{
+    unsigned int wordLen = strlen(word);
+    
+    if (horizontal)
+    {
+        // Check if word fits horizontally
+        if (col + wordLen > searchFieldLen)
+            return 0;
+            
+        // Check if all positions are empty or match the word
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            if (salad[row][col + i] != EMPTY_CHAR && salad[row][col + i] != word[i])
+                return 0;
+        }
+    }
+    else
+    {
+        // Check if word fits vertically
+        if (row + wordLen > searchFieldLen)
+            return 0;
+            
+        // Check if all positions are empty or match the word
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            if (salad[row + i][col] != EMPTY_CHAR && salad[row + i][col] != word[i])
+                return 0;
+        }
+    }
+    
+    return 1;
+}
+
+// Helper function to place a word at a specific position
+static void placeWord(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                     const char *word, unsigned int row, unsigned int col, 
+                     int horizontal)
+{
+    unsigned int wordLen = strlen(word);
+    
+    if (horizontal)
+    {
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            salad[row][col + i] = word[i];
+        }
+    }
+    else
+    {
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            salad[row + i][col] = word[i];
+        }
+    }
+}
 
 // Creates the word salad by placing words randomly and filling empty spaces
-int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], unsigned int wordCount)
+int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                    unsigned int searchFieldLen, 
+                    const char words[][MAX_WORD_LEN], 
+                    unsigned int wordCount)
 {
+    // Initialize random seed
+    srand(time(NULL));
     
+    // Initialize the grid with empty characters
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            salad[i][j] = EMPTY_CHAR;
+        }
+    }
+    
+    unsigned int placedWords = 0;
+    
+    // Try to place each word
+    for (unsigned int w = 0; w < wordCount; w++)
+    {
+        unsigned int wordLen = strlen(words[w]);
+        int placed = 0;
+        
+        // Skip empty words or words that are too long
+        if (wordLen == 0 || wordLen > searchFieldLen)
+            continue;
+        
+        // Try to place the word MAX_RAND_TRIES_PER_WORD times
+        for (int tries = 0; tries < MAX_RAND_TRIES_PER_WORD && !placed; tries++)
+        {
+            // Random direction: 0 = horizontal, 1 = vertical
+            int horizontal = rand() % 2;
+            
+            // Random position
+            unsigned int row = rand() % searchFieldLen;
+            unsigned int col = rand() % searchFieldLen;
+            
+            // Check if word can be placed
+            if (canPlaceWord(salad, words[w], row, col, horizontal, searchFieldLen))
+            {
+                placeWord(salad, words[w], row, col, horizontal);
+                placed = 1;
+                placedWords++;
+            }
+        }
+    }
+    
+    // Fill remaining empty spaces with random letters
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            if (salad[i][j] == EMPTY_CHAR)
+            {
+                salad[i][j] = 'A' + (rand() % 26);
+            }
+        }
+    }
+    
+    return placedWords;
 }
 
 // Prints the word salad to console
-void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
+void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                   unsigned int searchFieldLen)
 {
+    printf("\nWord Salad:\n");
+    printf("  ");
     
+    // Print column numbers
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        printf("%2u ", i);
+    }
+    printf("\n");
+    
+    // Print rows with row numbers
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        printf("%2u ", i);
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            printf("%2c ", salad[i][j]);
+        }
+        printf("\n");
+    }
+    printf("\n");
 }

Start_Mac/input.c

@@ -2,11 +2,38 @@
 #include <string.h>
 #include <ctype.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)
 {
+    unsigned int wordCount = 0;
+    char line[MAX_LINE_LEN];
     
+    // Read file line by line
+    while (fgets(line, MAX_LINE_LEN, file) != NULL && wordCount < maxWordCount)
+    {
+        // Process each line to extract words separated by delimiters
+        char *token = strtok(line, " ,;\n\t\r");
+        
+        while (token != NULL && wordCount < maxWordCount)
+        {
+            // Convert word to uppercase and store it
+            unsigned int i = 0;
+            while (token[i] != '\0' && i < MAX_WORD_LEN - 1)
+            {
+                words[wordCount][i] = toupper((unsigned char)token[i]);
+                i++;
+            }
+            words[wordCount][i] = '\0';
+            
+            // Only count non-empty words
+            if (i > 0)
+            {
+                wordCount++;
+            }
+            
+            token = strtok(NULL, " ,;\n\t\r");
+        }
+    }
+    
+    return wordCount;
 }

Start_Mac/main.c

@@ -36,10 +36,26 @@ int main(int argc, char *argv[])
             // Create the word salad by placing words into grid
             placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, wordCount);
 
-            // TODO:
             // Check if all words were successfully placed
-            // Start the game if successful
+            if (placedWords == wordCount)
-            // error message if some words couldn't be placed
+            {
+                // All words placed successfully - start the game
+                printf("Successfully placed all %u words!\n", placedWords);
+                showWordSalad(wordSalad, SALAD_SIZE);
+                
+                // Start the graphical game
+                startGraphicalGame(wordSalad, SALAD_SIZE, words, wordCount);
+            }
+            else
+            {
+                // Some words couldn't be placed
+                fprintf(stderr, "Warning: Could only place %u out of %u words.\n", 
+                        placedWords, wordCount);
+                showWordSalad(wordSalad, SALAD_SIZE);
+                
+                // Start the game anyway with the words that were placed
+                startGraphicalGame(wordSalad, SALAD_SIZE, words, wordCount);
+            }
 
         }
         else

Start_Windows/game.c

@@ -2,22 +2,159 @@
 #include <time.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 
 #define MAX_RAND_TRIES_PER_WORD 10
 #define EMPTY_CHAR 0
 
-//TODO: Spiellogik implementieren:
+// Helper function to check if a word can be placed at a specific position
-/* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
+static int canPlaceWord(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
-   * restliche Felder mit zufälligen Buchstaben füllen */
+                       const char *word, unsigned int row, unsigned int col, 
+                       int horizontal, unsigned int searchFieldLen)
+{
+    unsigned int wordLen = strlen(word);
+    
+    if (horizontal)
+    {
+        // Check if word fits horizontally
+        if (col + wordLen > searchFieldLen)
+            return 0;
+            
+        // Check if all positions are empty or match the word
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            if (salad[row][col + i] != EMPTY_CHAR && salad[row][col + i] != word[i])
+                return 0;
+        }
+    }
+    else
+    {
+        // Check if word fits vertically
+        if (row + wordLen > searchFieldLen)
+            return 0;
+            
+        // Check if all positions are empty or match the word
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            if (salad[row + i][col] != EMPTY_CHAR && salad[row + i][col] != word[i])
+                return 0;
+        }
+    }
+    
+    return 1;
+}
+
+// Helper function to place a word at a specific position
+static void placeWord(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                     const char *word, unsigned int row, unsigned int col, 
+                     int horizontal)
+{
+    unsigned int wordLen = strlen(word);
+    
+    if (horizontal)
+    {
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            salad[row][col + i] = word[i];
+        }
+    }
+    else
+    {
+        for (unsigned int i = 0; i < wordLen; i++)
+        {
+            salad[row + i][col] = word[i];
+        }
+    }
+}
 
 // Creates the word salad by placing words randomly and filling empty spaces
-int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], unsigned int wordCount)
+int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                    unsigned int searchFieldLen, 
+                    const char words[][MAX_WORD_LEN], 
+                    unsigned int wordCount)
 {
+    // Initialize random seed
+    srand(time(NULL));
     
+    // Initialize the grid with empty characters
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            salad[i][j] = EMPTY_CHAR;
+        }
+    }
+    
+    unsigned int placedWords = 0;
+    
+    // Try to place each word
+    for (unsigned int w = 0; w < wordCount; w++)
+    {
+        unsigned int wordLen = strlen(words[w]);
+        int placed = 0;
+        
+        // Skip empty words or words that are too long
+        if (wordLen == 0 || wordLen > searchFieldLen)
+            continue;
+        
+        // Try to place the word MAX_RAND_TRIES_PER_WORD times
+        for (int tries = 0; tries < MAX_RAND_TRIES_PER_WORD && !placed; tries++)
+        {
+            // Random direction: 0 = horizontal, 1 = vertical
+            int horizontal = rand() % 2;
+            
+            // Random position
+            unsigned int row = rand() % searchFieldLen;
+            unsigned int col = rand() % searchFieldLen;
+            
+            // Check if word can be placed
+            if (canPlaceWord(salad, words[w], row, col, horizontal, searchFieldLen))
+            {
+                placeWord(salad, words[w], row, col, horizontal);
+                placed = 1;
+                placedWords++;
+            }
+        }
+    }
+    
+    // Fill remaining empty spaces with random letters
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            if (salad[i][j] == EMPTY_CHAR)
+            {
+                salad[i][j] = 'A' + (rand() % 26);
+            }
+        }
+    }
+    
+    return placedWords;
 }
 
 // Prints the word salad to console
-void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
+void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], 
+                   unsigned int searchFieldLen)
 {
+    printf("\nWord Salad:\n");
+    printf("  ");
     
+    // Print column numbers
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        printf("%2u ", i);
+    }
+    printf("\n");
+    
+    // Print rows with row numbers
+    for (unsigned int i = 0; i < searchFieldLen; i++)
+    {
+        printf("%2u ", i);
+        for (unsigned int j = 0; j < searchFieldLen; j++)
+        {
+            printf("%2c ", salad[i][j]);
+        }
+        printf("\n");
+    }
+    printf("\n");
 }

Start_Windows/input.c

@@ -2,11 +2,38 @@
 #include <string.h>
 #include <ctype.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)
 {
+    unsigned int wordCount = 0;
+    char line[MAX_LINE_LEN];
     
+    // Read file line by line
+    while (fgets(line, MAX_LINE_LEN, file) != NULL && wordCount < maxWordCount)
+    {
+        // Process each line to extract words separated by delimiters
+        char *token = strtok(line, " ,;\n\t\r");
+        
+        while (token != NULL && wordCount < maxWordCount)
+        {
+            // Convert word to uppercase and store it
+            unsigned int i = 0;
+            while (token[i] != '\0' && i < MAX_WORD_LEN - 1)
+            {
+                words[wordCount][i] = toupper((unsigned char)token[i]);
+                i++;
+            }
+            words[wordCount][i] = '\0';
+            
+            // Only count non-empty words
+            if (i > 0)
+            {
+                wordCount++;
+            }
+            
+            token = strtok(NULL, " ,;\n\t\r");
+        }
+    }
+    
+    return wordCount;
 }

Start_Windows/main.c

@@ -36,10 +36,26 @@ int main(int argc, char *argv[])
             // Create the word salad by placing words into grid
             placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, wordCount);
 
-            // TODO:
             // Check if all words were successfully placed
-            // Start the game if successful
+            if (placedWords == wordCount)
-            // error message if some words couldn't be placed
+            {
+                // All words placed successfully - start the game
+                printf("Successfully placed all %u words!\n", placedWords);
+                showWordSalad(wordSalad, SALAD_SIZE);
+                
+                // Start the graphical game
+                startGraphicalGame(wordSalad, SALAD_SIZE, words, wordCount);
+            }
+            else
+            {
+                // Some words couldn't be placed
+                fprintf(stderr, "Warning: Could only place %u out of %u words.\n", 
+                        placedWords, wordCount);
+                showWordSalad(wordSalad, SALAD_SIZE);
+                
+                // Start the game anyway with the words that were placed
+                startGraphicalGame(wordSalad, SALAD_SIZE, words, wordCount);
+            }
 
         }
         else

todo.md

@@ -1,273 +0,0 @@
-# Word Salad Game - Comprehensive TODO List
-
-## Project Overview
-A word search puzzle game where words are randomly placed in a grid (horizontally or vertically), and players must find them by drawing lines over the letters. Built with C and Raylib graphics library.
-
----
-
-## 📋 Core Implementation Tasks
-
-### 🔴 CRITICAL - Must be implemented for basic functionality
-
-#### 1. **input.c - Word Reading Function** ⚠️ HIGH PRIORITY
-**Function:** `readWords()`
-
-**Requirements:**
-- [ ] Read words from file (`words.txt`) line by line
-- [ ] Handle multiple delimiters: comma (`,`), semicolon (`;`), space (` `), newline (`\n`)
-- [ ] Convert all words to uppercase for consistency
-- [ ] Store words in the provided `words[][]` array
-- [ ] Return the total count of words read
-- [ ] Handle empty files gracefully (return 0)
-- [ ] Validate max word count limit (`maxWordCount`)
-- [ ] Trim whitespace from words
-- [ ] Skip empty words/lines
-
-**Implementation Notes:**
-- Use `fgets()` to read lines (max `MAX_LINE_LEN`)
-- Use `strtok()` for tokenizing with multiple delimiters: `", ;\n\t\r"`
-- Use `toupper()` to convert characters to uppercase
-- Use `isalpha()` to validate word characters
-- Handle buffer overflow protection
-
-**Test Coverage:**
-- `test_readWords_simple()` - Basic newline-separated words
-- `test_readWords_with_delimiters()` - Multiple delimiter types
-- `test_readWords_empty_file()` - Empty file handling
-
----
-
-#### 2. **game.c - Word Salad Creation** ⚠️ HIGH PRIORITY
-**Function:** `createWordSalad()`
-
-**Requirements:**
-- [ ] Initialize the grid with `EMPTY_CHAR` (0)
-- [ ] Seed random number generator with `srand(time(NULL))`
-- [ ] For each word, attempt placement:
-  - [ ] Try random positions and orientations (horizontal/vertical)
-  - [ ] Max attempts: `MAX_RAND_TRIES_PER_WORD` (10)
-  - [ ] Check if word fits without overlapping incorrectly
-  - [ ] Place word character by character
-- [ ] Fill remaining empty cells with random uppercase letters (A-Z)
-- [ ] Return count of successfully placed words
-
-**Placement Algorithm:**
-1. Random orientation: 0 = horizontal, 1 = vertical
-2. Random starting position within valid bounds
-3. Check if entire word fits
-4. Check for conflicts (can overwrite same letter, not different letters)
-5. Place word if valid
-6. Increment placed counter
-
-**Edge Cases:**
-- Words too long for grid size
-- Grid too small for multiple words
-- All positions occupied
-
-**Test Coverage:**
-- `test_createWordSalad_all_fit()` - All words fit in large grid
-- `test_createWordSalad_too_small()` - Grid too small for some words
-- `test_createWordSalad_allWordsPlaced()` - Verify words are actually in grid
-
----
-
-#### 3. **game.c - Display Function** 🟡 MEDIUM PRIORITY
-**Function:** `showWordSalad()`
-
-**Requirements:**
-- [ ] Print grid to console in readable format
-- [ ] Add spacing between characters for clarity
-- [ ] Optional: Add row/column numbers for debugging
-- [ ] Format: Each row on separate line
-
-**Example Output:**
-```
-  0 1 2 3 4
-0 Y E T I X
-1 N A B C D
-2 M O N S T E R
-3 O G H I J
-```
-
----
-
-#### 4. **main.c - Game Validation & Launch** ⚠️ HIGH PRIORITY
-
-**Requirements:**
-- [ ] Compare `placedWords` with `wordCount`
-- [ ] If all words placed successfully:
-  - [ ] Call `startGame()` with word salad and parameters
-  - [ ] Pass `SALAD_SIZE` as search field size
-  - [ ] Use appropriate window size (e.g., 800)
-- [ ] If some words couldn't be placed:
-  - [ ] Print error message to stderr
-  - [ ] Indicate how many words failed
-  - [ ] Set `exitCode = EXIT_FAILURE`
-  - [ ] Don't start the game
-
-**Implementation:**
-```c
-// TODO: Complete this section
-if (placedWords == wordCount) {
-    // All words successfully placed - start the game
-    showWordSalad(wordSalad, SALAD_SIZE);  // Optional: show in console
-    startGame(wordSalad, SALAD_SIZE, words, wordCount, 800);
-} else {
-    // Error: Not all words could be placed
-    fprintf(stderr, "Error: Only %u out of %u words could be placed in the grid.\n", 
-            placedWords, wordCount);
-    exitCode = EXIT_FAILURE;
-}
-```
-
----
-
-## 🧪 Testing & Validation
-
-### Unit Tests
-- [ ] Run all unit tests: `./unit_tests` or `make test`
-- [ ] Ensure all 6 tests pass:
-  - [ ] `test_readWords_simple`
-  - [ ] `test_readWords_with_delimiters`
-  - [ ] `test_readWords_empty_file`
-  - [ ] `test_createWordSalad_all_fit`
-  - [ ] `test_createWordSalad_too_small`
-  - [ ] `test_createWordSalad_allWordsPlaced`
-
-### Integration Testing
-- [ ] Test with provided `words.txt` file
-- [ ] Test with custom word lists
-- [ ] Test with edge cases:
-  - [ ] Empty file
-  - [ ] Single word
-  - [ ] Very long words
-  - [ ] Maximum word count
-  - [ ] Special characters/numbers (should be filtered)
-
----
-
-## 🔧 Build & Compilation
-
-### Prerequisites
-- [ ] GCC compiler installed
-- [ ] Make utility available
-- [ ] Raylib library (already included in project)
-- [ ] Unity test framework (already included)
-
-### Build Commands
-```bash
-# Build main executable
-make
-
-# Build and run unit tests
-make test
-
-# Clean build artifacts
-make clean
-```
-
-### Platform-Specific Notes
-- **Windows:** Use `Start_Windows/` directory
-- **Linux:** Use `Start_Linux/` directory  
-- **macOS:** Use `Start_Mac/` directory
-
----
-
-## 📦 Additional Enhancements (Optional)
-
-### Nice-to-Have Features
-- [ ] Add diagonal word placement
-- [ ] Add backward word placement (reverse strings)
-- [ ] Difficulty levels (grid size, word count)
-- [ ] Save/load game state
-- [ ] High score tracking
-- [ ] Time-based gameplay
-- [ ] Hint system
-- [ ] Multiple language support
-
-### Code Quality
-- [ ] Add comprehensive comments
-- [ ] Follow consistent naming conventions
-- [ ] Memory leak detection with Valgrind
-- [ ] Static analysis with cppcheck
-- [ ] Code formatting with clang-format
-
-### Documentation
-- [ ] Update README.md with:
-  - [ ] Build instructions
-  - [ ] How to play
-  - [ ] Screenshots
-  - [ ] System requirements
-- [ ] Add inline code documentation
-- [ ] Create developer guide
-
----
-
-## 🐛 Known Issues & Debugging
-
-### Common Problems
-- [ ] **Segmentation fault:** Check array bounds, null pointers
-- [ ] **Words not found:** Ensure uppercase conversion in both placement and search
-- [ ] **Random seed:** Call `srand(time(NULL))` only once
-- [ ] **File not found:** Check relative paths, working directory
-
-### Debugging Tips
-- Use `printf()` to trace execution
-- Test functions individually
-- Use debugger (gdb/lldb) for complex issues
-- Enable compiler warnings: `-Wall -Wextra`
-
----
-
-## ✅ Definition of Done
-
-A task is considered complete when:
-- [ ] Code compiles without warnings
-- [ ] All relevant unit tests pass
-- [ ] Function meets specification requirements
-- [ ] Edge cases are handled
-- [ ] Code is properly commented
-- [ ] No memory leaks (verified with Valgrind on Linux/Mac)
-- [ ] Integrated and tested with other components
-
----
-
-## 📅 Suggested Implementation Order
-
-1. ✅ **Week 1:** Implement `readWords()` in `input.c`
-   - Start with simple parsing
-   - Add delimiter handling
-   - Test with unit tests
-
-2. ✅ **Week 2:** Implement `createWordSalad()` in `game.c`
-   - Grid initialization
-   - Word placement algorithm
-   - Random fill
-   - Test with unit tests
-
-3. ✅ **Week 3:** Implement `showWordSalad()` and complete `main.c`
-   - Console display
-   - Game validation logic
-   - Integration testing
-
-4. ✅ **Week 4:** Testing, debugging, and polish
-   - Fix all unit test failures
-   - Test with various word lists
-   - Optimize performance
-   - Code cleanup
-
----
-
-## 📝 Notes
-
-- The graphical interface (`graphicalGame.c`) is already implemented
-- Raylib library handles all graphics rendering
-- Focus on the core game logic implementation
-- Test frequently to catch bugs early
-- Use the provided Unity test framework
-
----
-
-**Last Updated:** November 5, 2025  
-**Project:** Word Salad Game (Wortsalat)  
-**Course:** Informatik 2 - Programmierung (3. Semester)