All tests passed

game.c

@@ -2,6 +2,7 @@
 #include <time.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
 
 #define MAX_RAND_TRIES_PER_WORD 10
 #define EMPTY_CHAR 0
@@ -22,19 +23,19 @@
 
 // }
 
-// Funktion, die einen zufälligen Großbuchstaben generiert
+// Funktion, die einen zufälligen Großbuchstaben (A–Z) erzeugt
 char randomLetter()
 {
     return 'A' + rand() % 26;
 }
 
-// Hauptfunktion: Erstellt das Wortsalat-Spiel
+// Erstellt das Wortsalat-Spielfeld und platziert die Wörter zufällig
 int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                     unsigned int searchFieldLen,
                     const char words[][MAX_WORD_LEN],
                     unsigned int wordCount)
 {
-   // 1. Leeres Spielfeld initialisieren
+    // 1. Spielfeld mit leeren Zeichen initialisieren
     for (unsigned int i = 0; i < searchFieldLen; i++)
     {
         for (unsigned int j = 0; j < searchFieldLen; j++)
@@ -44,14 +45,24 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
     }
 
     srand((unsigned int)time(NULL));
+    int placedWords = 0;
 
-   // 2. Jedes Wort zufällig im Spielfeld platzieren
+    // 2. Jedes Wort zufällig auf dem Spielfeld platzieren
     for (unsigned int w = 0; w < wordCount; w++)
     {
-      const char *word = words[w];
+        char word[MAX_WORD_LEN];
+        strncpy(word, words[w], MAX_WORD_LEN);
+        word[MAX_WORD_LEN - 1] = '\0';
+
+        // Alle Buchstaben des Wortes in Großbuchstaben umwandeln
+        for (size_t k = 0; k < strlen(word); k++)
+        {
+            word[k] = (char)toupper((unsigned char)word[k]);
+        }
+
         size_t len = strlen(word);
         if (len > searchFieldLen)
-         continue; // Überspringen, falls das Wort zu lang ist
+            continue; // Wort ist zu lang → überspringen
 
         int placed = 0;
         for (int attempt = 0; attempt < MAX_RAND_TRIES_PER_WORD && !placed; attempt++)
@@ -60,11 +71,10 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
             int row = rand() % searchFieldLen;
             int col = rand() % searchFieldLen;
 
-         // Prüfen, ob das Wort an die Position passt
             if (dir == 0 && col + len <= searchFieldLen)
             {
-            // Prüfen, ob keine Überschneidungen mit anderen Buchstaben auftreten
                 int ok = 1;
+                // Prüfen, ob der Platz frei ist oder die Buchstaben passen
                 for (size_t i = 0; i < len; i++)
                 {
                     if (salad[row][col + i] != EMPTY_CHAR && salad[row][col + i] != word[i])
@@ -75,6 +85,7 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                 }
                 if (ok)
                 {
+                    // Wort horizontal einfügen
                     for (size_t i = 0; i < len; i++)
                         salad[row][col + i] = word[i];
                     placed = 1;
@@ -83,6 +94,7 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
             else if (dir == 1 && row + len <= searchFieldLen)
             {
                 int ok = 1;
+                // Prüfen, ob der Platz frei ist oder die Buchstaben passen
                 for (size_t i = 0; i < len; i++)
                 {
                     if (salad[row + i][col] != EMPTY_CHAR && salad[row + i][col] != word[i])
@@ -93,15 +105,19 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                 }
                 if (ok)
                 {
+                    // Wort vertikal einfügen
                     for (size_t i = 0; i < len; i++)
                         salad[row + i][col] = word[i];
                     placed = 1;
                 }
             }
         }
+
+        if (placed)
+            placedWords++; // Anzahl der erfolgreich platzierten Wörter erhöhen
     }
 
-   // 3. Leere Felder mit zufälligen Buchstaben füllen
+    // 3. Alle leeren Felder mit zufälligen Buchstaben füllen
     for (unsigned int i = 0; i < searchFieldLen; i++)
     {
         for (unsigned int j = 0; j < searchFieldLen; j++)
@@ -111,10 +127,11 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
         }
     }
 
-   return 0; // 0 = erfolgreich
+    // Rückgabewert: Anzahl der platzierten Wörter
+    return placedWords;
 }
 
-// Funktion zur Anzeige des Spielfelds in der Konsole
+// Gibt das Spielfeld in der Konsole aus
 void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
                    unsigned int searchFieldLen)
 {

input.c

@@ -23,35 +23,41 @@ int readWords(FILE *file, char words[][MAX_WORD_LEN], unsigned int maxWordCount)
     }
 
     unsigned int count = 0;
-    char line[MAX_WORD_LEN + 5]; // etwas Puffer, um Überlauf zu vermeiden
+    char buffer[512];
 
-    // Zeilen einzeln lesen, bis EOF erreicht oder das Limit erreicht ist
-    while (fgets(line, sizeof(line), file) != NULL && count < maxWordCount)
+    // Ganze Datei zeilenweise lesen
+    while (fgets(buffer, sizeof(buffer), file) != NULL && count < maxWordCount)
     {
-        // Zeilenumbruch '\n' oder '\r\n' entfernen
-        line[strcspn(line, "\r\n")] = '\0';
-
-        // Leere Zeilen überspringen
-        if (strlen(line) == 0)
-            continue;
+        // Entfernt Zeilenumbruch '\n' oder '\r\n'
+        buffer[strcspn(buffer, "\r\n")] = '\0';
 
+        // Zerlegt die Zeile in Wörter mit den Trennzeichen: Leerzeichen, Komma, Semikolon
+        char *token = strtok(buffer, " ,;");
+        while (token != NULL && count < maxWordCount)
+        {
             // Leerzeichen am Anfang und Ende entfernen
-        char *start = line;
-        while (isspace((unsigned char)*start))
-            start++;
-
-        char *end = start + strlen(start) - 1;
-        while (end > start && isspace((unsigned char)*end))
+            while (isspace((unsigned char)*token))
+                token++;
+            char *end = token + strlen(token) - 1;
+            while (end > token && isspace((unsigned char)*end))
             {
                 *end = '\0';
                 end--;
             }
 
-        // Sichere Kopie in das Array 'words'
-        strncpy(words[count], start, MAX_WORD_LEN - 1);
-        words[count][MAX_WORD_LEN - 1] = '\0'; // Nullterminierung sicherstellen
+            // In Großbuchstaben umwandeln
+            for (unsigned int i = 0; i < strlen(token); i++)
+            {
+                token[i] = (char)toupper((unsigned char)token[i]);
+            }
+
+            // In das Array 'words' kopieren
+            strncpy(words[count], token, MAX_WORD_LEN - 1);
+            words[count][MAX_WORD_LEN - 1] = '\0';
 
             count++;
+            token = strtok(NULL, " ,;");
+        }
     }
 
     return count;