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

Start_Linux/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_Linux/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_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_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