test

Startcode/game.c

@@ -2,8 +2,9 @@
 #include <time.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h> // Für toupper()
 
-#define MAX_RAND_TRIES_PER_WORD 10
+#define MAX_RAND_TRIES_PER_WORD 100
 #define EMPTY_CHAR 0
 
 int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int wordCount, char words[][100], unsigned int gridSize)
@@ -15,10 +16,14 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsi
 
     // 2. Wörter platzieren
     for (unsigned int i = 0; i < wordCount; i++) {
+        // Steuerzeichen (\n, \r) und Leerzeichen am Ende des Wortes entfernen
         int len = (int)strlen(words[i]);
+        while (len > 0 && (words[i][len - 1] == '\n' || words[i][len - 1] == '\r' || words[i][len - 1] == ' ')) {
+            words[i][--len] = '\0';
+        }
 
-        // WICHTIG: Wenn das Wort länger ist als das eigentliche Spielfeld (gridSize), direkt überspringen!
+        // Wenn das Wort leer ist oder länger als das Spielfeld, überspringen
-        if (len == 0 || len > gridSize) continue;
+        if (len == 0 || (unsigned int)len > gridSize) continue;
 
         // Versuche eine freie Position zu finden
         for (int attempt = 0; attempt < MAX_RAND_TRIES_PER_WORD; attempt++) {
@@ -27,14 +32,17 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsi
             int dr = is_vert;         
             int dc = !is_vert;        
 
-            // Zufällige Position INNERHALB der gridSize wählen (nicht mehr 100x100!)
+            // Zufällige Position INNERHALB der gridSize wählen
             int row = rand() % (gridSize - (is_vert ? len - 1 : 0));
             int col = rand() % (gridSize - (is_vert ? 0 : len - 1));
 
             int canPlace = 1;
             for (int k = 0; k < len; k++) {
                 char current = salad[row + k * dr][col + k * dc];
-                if (current != EMPTY_CHAR && current != words[i][k]) {
+                char wordChar = (char)toupper((unsigned char)words[i][k]);
+
+                // Feld muss leer sein oder denselben Buchstaben enthalten
+                if (current != EMPTY_CHAR && current != wordChar) {
                     canPlace = 0;
                     break;
                 }
@@ -42,7 +50,7 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsi
 
             if (canPlace) {
                 for (int k = 0; k < len; k++) {
-                    salad[row + k * dr][col + k * dc] = words[i][k];
+                    salad[row + k * dr][col + k * dc] = (char)toupper((unsigned char)words[i][k]);
                 }
                 placedWordsCount++;
                 break; 
@@ -50,7 +58,7 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsi
         }
     }
 
-    // 3. Verbleibende leere Felder (nur innerhalb der gridSize!) mit Zufallsbuchstaben auffüllen
+    // 3. Verbleibende leere Felder (nur innerhalb der gridSize) mit Zufallsbuchstaben auffüllen
     for (unsigned int r = 0; r < gridSize; r++) {
         for (unsigned int c = 0; c < gridSize; c++) {
             if (salad[r][c] == EMPTY_CHAR) {

Startcode/input.c

@@ -1,78 +1,76 @@
-#include "input.h"
+#include "game.h"
+#include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
+#include <time.h>
 
-// TODO: erledigt
+#define MAX_RAND_TRIES_PER_WORD 100
-// eine Funktion implementieren, die ein einzelnes Wort aus einer Textdatei (words.txt) einliest und als C-String zurückgibt.
+#define EMPTY_CHAR 0
-char* readSingleWord(FILE *file, char *destination, int maxLen) 
-{
-    char buffer[256];
-    int ch;
-    int bufIndex = 0;
 
-    // Alle Trennzeichen überspringen, bis ein echter Buchstabe kommt
+// Enum zur sauberen Unterscheidung der Platzierungsrichtung
-    while ((ch = fgetc(file)) != EOF) 
+typedef enum {
+    DIR_HORIZONTAL = 0,
+    DIR_VERTICAL = 1
+} Direction;
+
+int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int wordCount, char words[][100], unsigned int gridSize)
 {
-        // Prüfen der Buchstaben
+    // 1. Spielfeld vollständig zurücksetzen
-        if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) 
+    memset(salad, EMPTY_CHAR, MAX_SEARCH_FIELD_LEN * MAX_SEARCH_FIELD_LEN);
-        {
+
-            // Wenn Kleinbuchstabe, in Großbuchstabe umwandeln
+    int placedWordsCount = 0;
-            if (ch >= 'a' && ch <= 'z') 
+
-            {
+    // 2. Wörter im Spielfeld platzieren
-                ch = ch - 32; 
+    for (unsigned int i = 0; i < wordCount; i++) {
+        unsigned int len = (unsigned int)strlen(words[i]);
+
+        // Wörter ignorieren, die zu lang für das eingestellte Spielfeld sind
+        if (len == 0 || len > gridSize) {
+            continue;
         }
-            buffer[bufIndex] = ch;
+
-            bufIndex++;
+        // Versuche, eine freie und kollisionsfreie Position zu finden
+        for (int attempt = 0; attempt < MAX_RAND_TRIES_PER_WORD; attempt++) {
+            Direction dir = (rand() % 2 == 0) ? DIR_HORIZONTAL : DIR_VERTICAL;
+
+            int dr = (dir == DIR_VERTICAL) ? 1 : 0;
+            int dc = (dir == DIR_HORIZONTAL) ? 1 : 0;
+
+            // Startkoordinaten so wählen, dass das Wort nicht aus dem Spielfeld herausragt
+            unsigned int maxRow = (dir == DIR_VERTICAL) ? (gridSize - len + 1) : gridSize;
+            unsigned int maxCol = (dir == DIR_HORIZONTAL) ? (gridSize - len + 1) : gridSize;
+
+            unsigned int row = (unsigned int)(rand() % maxRow);
+            unsigned int col = (unsigned int)(rand() % maxCol);
+
+            // Prüfen, ob die Felder frei oder mit demselben Buchstaben belegt sind
+            int canPlace = 1;
+            for (unsigned int k = 0; k < len; k++) {
+                char current = salad[row + k * dr][col + k * dc];
+                if (current != EMPTY_CHAR && current != words[i][k]) {
+                    canPlace = 0;
                     break;
                 }
             }
 
-    if (ch == EOF) 
+            // Wort eintragen, wenn der Platz gültig ist
-    {
+            if (canPlace) {
-        return NULL; 
+                for (unsigned int k = 0; k < len; k++) {
+                    salad[row + k * dr][col + k * dc] = words[i][k];
                 }
-
+                placedWordsCount++;
-    // Den Rest des Wortes einlesen (bricht bei Kommas, Leerzeichen etc. ab)
+                break;
-    while ((ch = fgetc(file)) != EOF && ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))) 
-    {
-        if (bufIndex < 255) 
-        {
-            if (ch >= 'a' && ch <= 'z') 
-            {
-                ch = ch - 32; 
             }
-            buffer[bufIndex] = ch;
-            bufIndex++;
         }
     }
 
-    // Zwischenspeicher abschließen
+    // 3. Verbleibende leere Felder innerhalb der gridSize mit Zufallsbuchstaben ('A'-'Z') füllen
-    buffer[bufIndex] = '\0'; 
+    for (unsigned int r = 0; r < gridSize; r++) {
+        for (unsigned int c = 0; c < gridSize; c++) {
+            if (salad[r][c] == EMPTY_CHAR) {
+                salad[r][c] = 'A' + (rand() % 26);
+            }
+        }
+    }
 
-    // Sicheres Kopieren in das Ziel-Array
+    return placedWordsCount;
-    strncpy(destination, buffer, maxLen - 1);
-    destination[maxLen - 1] = '\0'; 
-    
-    return destination;
-}
-// Read words from file and store in 'words' array
-int readWords(FILE *file, char words[][MAX_WORD_LEN], unsigned int maxWordCount)
-{
-    unsigned int count = 0;
-    // Schleife läuft, solange noch Platz im Array ist
-    while (count < maxWordCount) 
-    {
-        if (readSingleWord(file, words[count], MAX_WORD_LEN) != NULL) 
-        {
-            if (strlen(words[count]) > 0) // Prüfen, ob das Wort nicht leer ist
-            {
-                count++; //nächstes Wort
-            }
-        } 
-        else 
-        {
-            break; // Bei Dateiende wird die Schleife abgebrochen
-        }
-    }
-    return count;
 }