Meine eigene input.c

Startcode/game.c

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

Startcode/input.c

@@ -1,80 +1,46 @@
-#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>
+#include "input.h"
+#include <string.h>
+#include <ctype.h>
 
-int readWords(FILE *file, char words[][MAX_WORD_LEN], unsigned int maxWordCount) // Liest Woerter aus einer Datei und gibt deren Anzahl zurueck.
+// 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 count = 0;
+    int count = 0; // zaehlt die gespeicherten Woerter
 
-    /*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)
+    if(file == NULL || maxWordCount == 0) // keine Datei oder kein Platz
     {
-
-        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 0; //Raus aus dem Programm und Abbruch
     }
 
-    return 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
 }