Kleines Bug entfernt:

Startcode/game.c

@@ -8,30 +8,32 @@
 
 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 gitter_zeilen_spalten_anzahl,              // Gibt die tatsaechliche Spielfeldgroesse an.
+    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 (gitter_zeilen_spalten_anzahl == 0 || gitter_zeilen_spalten_anzahl > MAX_SEARCH_FIELD_LEN) // Prueft die Spielfeldgroesse.
+    if (searchFieldLen == 0 || searchFieldLen > MAX_SEARCH_FIELD_LEN) // Prueft die Spielfeldgroesse.
     {
         return 0; // Beendet die Funktion bei ungueltiger Groesse.
     }
 
-    for (unsigned int zeile = 0; zeile < gitter_zeilen_spalten_anzahl; zeile++) // Durchlaeuft alle Zeilen.
+    for (unsigned int row = 0; row < searchFieldLen; row++) // Durchlaeuft alle Zeilen.
     {
-        for (unsigned int spalte = 0; spalte < gitter_zeilen_spalten_anzahl; spalte++) // Durchlaeuft alle Spalten.
+        for (unsigned int col = 0; col < searchFieldLen; col++) // Durchlaeuft alle Spalten.
         {
-            salad[zeile][spalte] = EMPTY_CHAR; // Setzt jedes Feld auf leer.
+            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 > gitter_zeilen_spalten_anzahl) // Prueft, ob das Wort in das Spielfeld passt.
+        if (len == 0 || len > searchFieldLen) // Prueft, ob das Wort in das Spielfeld passt.
         {
             continue; // Ueberspringt ein ungueltiges oder zu langes Wort.
         }
@@ -40,54 +42,90 @@ int createWordSalad( // Erstellt das Spielfeld und gibt die Anzahl platzierter W
         {
             int direction = rand() % 2; // Waehlt 0 fuer waagerecht oder 1 fuer senkrecht.
 
-            unsigned int maxzeile = direction == 0 ? gitter_zeilen_spalten_anzahl : gitter_zeilen_spalten_anzahl - len + 1; // Berechnet die Anzahl moeglicher Startzeilen.
-            unsigned int maxspalte = direction == 0 ? gitter_zeilen_spalten_anzahl - len + 1 : gitter_zeilen_spalten_anzahl; // Berechnet die Anzahl moeglicher Startspalten.
-
-            unsigned int zeile = (unsigned int)rand() % maxzeile; // Bestimmt die zufaellige Startzeile.
-            unsigned int spalte = (unsigned int)rand() % maxspalte; // Bestimmt die zufaellige Startspalte.
-
-            int fits = 1; // Merkt sich, ob das Wort an dieser Position Platz hat.
-
-            for (unsigned int i = 0; i < len; i++) // Prueft alle benoetigten Felder.
+            if(!direction)
             {
-                unsigned int r = zeile + (direction == 1 ? i : 0); // Berechnet die Zeile des aktuellen Buchstabens.
-                unsigned int c = spalte + (direction == 0 ? i : 0); // Berechnet die Spalte des aktuellen Buchstabens.
+                int Zeile_Rand = rand() % searchFieldLen; 
+                int Spalte_Rand = rand() % searchFieldLen;
 
-                if (salad[r][c] != EMPTY_CHAR) // Prueft, ob das Feld bereits belegt ist.
+                if((searchFieldLen - Spalte_Rand) < len)
+                /*Wuerde heissen, dass es nicht genug Platz gibt, Wort einzulesen
+                da wo wir es wollen.*/
                 {
-                    fits = 0; // Kennzeichnet die Position als ungeeignet.
-                    break; // Bricht die Ueberpruefung dieser Position ab.
+                    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 (fits == 1) // Fuehrt die Platzierung nur aus, wenn alle Felder frei sind.
+            if(direction)
             {
-                for (unsigned int i = 0; i < len; i++) // Durchlaeuft alle Buchstaben des Wortes.
-                {
-                    unsigned int r = zeile + (direction == 1 ? i : 0); // Berechnet die Zielzeile.
-                    unsigned int c = spalte + (direction == 0 ? i : 0); // Berechnet die Zielspalte.
+                int Zeile_Rand = rand() % searchFieldLen; /*Assuming SearchFieldLen is 20*/
+                int Spalte_Rand = rand() % searchFieldLen;
 
-                    salad[r][c] = words[w][i]; // Schreibt den Buchstaben in das Spielfeld.
+                if((searchFieldLen - Zeile_Rand) < len)
+                   /*Das wuerde heissen, dass es nicht genug Platz gibt, um Worter reinzulesen.*/
+                {
+                    continue;
+                    /*Versuche eine neue Position.*/
                 }
 
-                placedWords++; // Erhoeht die Anzahl der platzierten Woerter.
-                break; // Beendet die Versuche fuer dieses erfolgreich platzierte Wort.
+                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 zeile = 0; zeile < gitter_zeilen_spalten_anzahl; zeile++) // Durchlaeuft alle Zeilen des Spielfeldes.
+    for (unsigned int row = 0; row < searchFieldLen; row++) // Durchlaeuft alle Zeilen des Spielfeldes.
     {
-        for (unsigned int spalte = 0; spalte < gitter_zeilen_spalten_anzahl; spalte++) // Durchlaeuft alle Spalten der aktuellen Zeile.
+        for (unsigned int col = 0; col < searchFieldLen; col++) // Durchlaeuft alle Spalten der aktuellen Zeile.
         {
-            if (salad[zeile][spalte] == EMPTY_CHAR) // Prueft, ob das aktuelle Feld noch leer ist.
+            if (salad[row][col] == EMPTY_CHAR) // Prueft, ob das aktuelle Feld noch leer ist.
             {
-                salad[zeile][spalte] = (char)('A' + rand() % 26); // Schreibt einen zufaelligen Grossbuchstaben von A bis Z.
+                salad[row][col] = (char)('A' + rand() % 26); // Schreibt einen zufaelligen Grossbuchstaben von A bis Z.
             }
         }
     }
 
-    return (int)placedWords; // Gibt die Anzahl der erfolgreich platzierten Woerter zurueck.
+    return (int)placedWords; 
 }
 

Startcode/input.c

@@ -1,46 +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.
-
-
-int readWords(FILE *file, char words[][MAX_WORD_LEN], unsigned int maxWordCount) // Read words from file and 
-//                                                                                  store in 'words' array
+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; // zaehlt die gespeicherten Woerter
+    int count = 0;
 
-    if(file == NULL || maxWordCount == 0) // keine Datei oder kein Platz
+    /*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)
     {
-        return 0; //Raus aus dem Programm und Abbruch
+
+        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++; 
+        }
     }
 
-    char line[MAX_LINE_LEN]; // Puffer fuer eine ganze Zeile 1024
-
-    while(fgets(line, MAX_LINE_LEN, file) != NULL)  // jede Zeile lesen
-    {
-        char *word = strtok(line, ",; \t\r\n");  // erstes Wort der Zeile      
-
-        while(word != NULL && count < maxWordCount) // jedes Wort der Zeile
-        {      
-
-            if(strlen(word) != 0 && strlen(word) < MAX_WORD_LEN)  // Wort gueltig?
-            {
-                strncpy(words[count], word, MAX_WORD_LEN -1);  // Wort sicher ins naechste Fach kopieren
-                words[count][MAX_WORD_LEN -1] = '\0';  // String sicher mit '\0' abschliessen
-
-                for(int i = 0; words[count][i] != '\0'; i++)
-                {
-                    words[count][i] = toupper(words[count][i]);
-
-                }
-                count++;  // ein Wort mehr gespeichert
-
-            }            
-            word = strtok(NULL, " ,; \t\n\r"); // naechstes Wort holen
-        }        
-    }    
-    return count;  // Anzahl der gespeicherten Woerter zurueckgeben
+    return count;
 }