Kleines Bug entfernt:

Startcode/game.c

@@ -1,17 +1,131 @@
-#include "game.h"
-#include <time.h>
-#include <stdlib.h>
-#include <string.h>
 
-#define MAX_RAND_TRIES_PER_WORD 10
-#define EMPTY_CHAR 0
+#include "game.h"      // Bindet die Definitionen fuer das Spielfeld ein.
+#include <stdlib.h>    // Stellt die Zufallsfunktion rand() bereit.
+#include <string.h>    // Stellt die Funktion strlen() bereit.
 
-//TODO: Spiellogik implementieren:
-/* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
-   * restliche Felder mit zufälligen Buchstaben füllen */
+#define MAX_RAND_TRIES_PER_WORD 10 // Legt fest, wie oft eine Position versucht wird.
+#define EMPTY_CHAR 0               // Kennzeichnet ein leeres Feld.
 
-// 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( // Erstellt das Spielfeld und gibt die Anzahl platzierter Woerter zurueck.
+    char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], // Speichert alle Buchstaben im Spielfeld.
+    unsigned int searchFieldLen,                           // Gibt die tatsaechliche Spielfeldgroesse an.
+    const char words[][MAX_WORD_LEN],                      // Enthaelt die einzutragenden Woerter.
+    unsigned int wordCount)                                // Gibt die Anzahl der Woerter an.
 {
+    if (searchFieldLen == 0 || searchFieldLen > MAX_SEARCH_FIELD_LEN) // Prueft die Spielfeldgroesse.
+    {
+        return 0; // Beendet die Funktion bei ungueltiger Groesse.
+    }
 
+    for (unsigned int row = 0; row < searchFieldLen; row++) // Durchlaeuft alle Zeilen.
+    {
+        for (unsigned int col = 0; col < searchFieldLen; col++) // Durchlaeuft alle Spalten.
+        {
+            salad[row][col] = EMPTY_CHAR; // Setzt jedes Feld auf leer.
+        }
+    }
+
+    unsigned int placedWords = 0; // Zaehlt die erfolgreich platzierten Woerter.
+
+    for (unsigned int w = 0; w < wordCount; w++) // Durchlaeuft alle Woerter aus der Wortliste.
+
+    {
+        
+        unsigned int len = (unsigned int)strlen(words[w]); // Ermittelt die Laenge des aktuellen Wortes.
+
+        if (len == 0 || len > searchFieldLen) // Prueft, ob das Wort in das Spielfeld passt.
+        {
+            continue; // Ueberspringt ein ungueltiges oder zu langes Wort.
+        }
+
+        for (int attempt = 0; attempt < MAX_RAND_TRIES_PER_WORD; attempt++) // Versucht verschiedene Positionen.
+        {
+            int direction = rand() % 2; // Waehlt 0 fuer waagerecht oder 1 fuer senkrecht.
+
+            if(!direction)
+            {
+                int Zeile_Rand = rand() % searchFieldLen; 
+                int Spalte_Rand = rand() % searchFieldLen;
+
+                if((searchFieldLen - Spalte_Rand) < len)
+                /*Wuerde heissen, dass es nicht genug Platz gibt, Wort einzulesen
+                da wo wir es wollen.*/
+                {
+                    continue;
+                    /*Versuche eine neue Position.*/
+                }
+                /*navodno tacno.*/
+
+                int i = 0;
+
+                for(int j = 0; j < len; j ++)
+                {
+                    if(salad[Zeile_Rand][Spalte_Rand + j] == EMPTY_CHAR)
+                    i ++;
+                }
+
+                if(i != len)
+                {
+                    continue;
+                }
+
+                    /*Wort einlesbar.*/
+                    strncpy(&salad[Zeile_Rand][Spalte_Rand], words[w], len);
+
+                    placedWords ++;
+                    break;
+            }
+
+            if(direction)
+            {
+                int Zeile_Rand = rand() % searchFieldLen; /*Assuming SearchFieldLen is 20*/
+                int Spalte_Rand = rand() % searchFieldLen;
+
+                if((searchFieldLen - Zeile_Rand) < len)
+                   /*Das wuerde heissen, dass es nicht genug Platz gibt, um Worter reinzulesen.*/
+                {
+                    continue;
+                    /*Versuche eine neue Position.*/
+                }
+
+                int i = 0;
+
+                for(int j = 0; j < len; j ++)
+                {
+                    if(salad[Zeile_Rand + j][Spalte_Rand] == EMPTY_CHAR)
+                    {
+                        i++;
+                    }
+                }
+
+                 if(i != len)
+                {
+                    continue;
+                }
+
+                /*Wort einlesbar.*/
+                for (int j = 0; j < len; j++)
+                {
+                    salad[Zeile_Rand + j][Spalte_Rand] = words[w][j];
+                }
+
+                placedWords ++;
+                break;
+            }
+        }
+    }
+
+    for (unsigned int row = 0; row < searchFieldLen; row++) // Durchlaeuft alle Zeilen des Spielfeldes.
+    {
+        for (unsigned int col = 0; col < searchFieldLen; col++) // Durchlaeuft alle Spalten der aktuellen Zeile.
+        {
+            if (salad[row][col] == EMPTY_CHAR) // Prueft, ob das aktuelle Feld noch leer ist.
+            {
+                salad[row][col] = (char)('A' + rand() % 26); // Schreibt einen zufaelligen Grossbuchstaben von A bis Z.
+            }
+        }
+    }
+
+    return (int)placedWords; 
 }
+

Startcode/input.c

@@ -1,12 +1,80 @@
-#include "input.h"
-#include <string.h>
-#include <ctype.h>
+#include "input.h"      // Bindet die eigene Headerdatei mit den Konstanten ein.
+#include <string.h>     // Stellt Funktionen wie strtok(), strlen() und strncpy() bereit.
+#include <ctype.h>      // Stellt die Funktion toupper() zum Umwandeln in Grossbuchstaben bereit.
+#include <stdio.h>
+#include <stdlib.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) // Liest Woerter aus einer Datei und gibt deren Anzahl zurueck.
 {
+    int count = 0;
 
+    /*Als Parameter fuer Words wird der Spaltenanzahl gegeben, der 
+    bekannt werden muss, sonst ist die maximale Laenge des Wortes nicht eindeutig.*/
+
+    FILE *file_zeiger;
+    file_zeiger = fopen("words.txt", "r");
+    /*Die Datei mit den Woertern wird geoeffnet.*/
+
+    if(file_zeiger == NULL){exit(1);};
+    /*Code wird terminiert in dem Fall, dass die Datei nicht eingelesen werden kann.*/
+
+    char Text_Speicher[1000];
+    /*1000 weil der .txt File offensichtlich weniger als 1000 Characters besitzt,
+    und passt somit in dieses Array.*/
+    /*Wir speichern den Text in einen Array, sodass wir mit Zeigerarithmetik arbeiten
+    koennen, was fuer ein File-Pointer nicht geht. Z.B.:
+    (*fgets dereferenziert zeigt nicht auf das Character aus den Text auf der Addresse.)
+    (fgets ++ springt nicht auf die Addresse des naechsten Characters.)*/
+
+    int Lese_Ein = fread(Text_Speicher, 1, sizeof(Text_Speicher) - 1, file_zeiger);
+    Text_Speicher[Lese_Ein] = '\0';
+    fclose(file_zeiger); 
+    /*Wir kopieren die Textdatei ins Array.*/
+
+    char *fptr = Text_Speicher;
+    /*Weil man die Zeigerarithmetik nicht mit Text_Speicher machen kann.*/
+
+    if(fptr != NULL)
+    {
+
+        while(*fptr != '\0' && count < maxWordCount)
+        {
+            while(*fptr == '\n' || *fptr == ',' || *fptr == ';' || *fptr == ' ' || *fptr == '\t' || *fptr == '\r')
+            {
+                fptr++;
+            }
+
+            if(*fptr == '\0') break; /*Das wuerde heissen, dass man
+            schon ueber den letzten Element durchgelaufen hat.*/
+
+    
+            int char_Index = 0;
+            while(*fptr != '\n' && *fptr != ',' && *fptr != ';' && *fptr != ' ' && *fptr != '\t' && *fptr != '\0')
+            {
+                if (char_Index < MAX_WORD_LEN - 1) {
+                    words[count][char_Index] = *fptr;
+                    char_Index++;
+                    /*char_Index++ = naechste Spalte*/
+                }
+                fptr++;
+                /*geht auf die naechste Addresse.*/
+
+                /*falls man raus aus dieser Schleife geht, heisst das, dass man
+                ein Wort eingelesen hat, da die oben in der Schleife benannten Characters
+                genau diejenige sind, die die Woerter trennen.*/
+            }
+
+            while (char_Index < MAX_WORD_LEN) 
+            {
+                words[count][char_Index] = '\0';
+                char_Index++;
+            }
+            /*Wir fuellen den Rest der Zeile mit \0, falls es noch
+            uebrigen Platz gibt (weniger Buchstaben eingelesen als es Raum in der Zeile gibt.)*/
+            
+            count++; 
+        }
+    }
+
+    return count;
 }

Startcode/main.c

@@ -7,6 +7,8 @@
 #define MAX_NUMBER_OF_WORDS 100
 #define SALAD_SIZE 20
 
+/*Hallo von Erik.*/
+
 int main(int argc, char *argv[])
 {
     int exitCode = EXIT_SUCCESS;
@@ -36,12 +38,19 @@ 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
-            // error message if some words couldn't be placed
             
+                if (placedWords == wordCount) // Prueft, ob alle Woerter platziert wurden.
+                {
+                    printf("Alle %u Woerter wurden platziert!\n", placedWords); // Gibt eine Erfolgsmeldung aus.
+                    startGame(wordSalad, SALAD_SIZE, words, wordCount, WINDOW_WIDTH); // Startet das grafische Wortsalat-Spiel.
                 }
+                else // Wird ausgefuehrt, wenn nicht alle Woerter platziert wurden.
+                {
+                    fprintf(stderr, "Nur %u von %u Woertern platziert!\n", placedWords, wordCount); // Gibt eine Fehlermeldung aus.
+                    exitCode = EXIT_FAILURE; // Kennzeichnet das Programm als fehlgeschlagen.
+                }
+        }
+           
         else
         {
             // Print error message if file couldn't be opened

test.txt

@@ -0,0 +1 @@
+test