Beschreibung für game.c hinzugefügt.

Start_Linux/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "input.h": "c"
+    }
+}

Start_Linux/game.c

@@ -17,11 +17,11 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsi
 {
    srand(time(NULL));
    Position position[(2 * MAX_SEARCH_FIELD_LEN * (MAX_SEARCH_FIELD_LEN - MIN_WORD_LEN + 1))]; //Positionsarray Größe: Formel max. nötige Größe (für minimal großes wort)
-   int gesetzteWörter = 0;
+   int gesetzteWoerter = 0;
    clearWordSalad(salad, searchFieldLen);
-   gesetzteWörter = fuelleSalatMitWörtern(salad, searchFieldLen, words, position, wordCount);
+   gesetzteWoerter = fuelleSalatMitWoertern(salad, searchFieldLen, words, position, wordCount);
    fillWordsaladRand(salad, searchFieldLen);
-   return gesetzteWörter;
+   return gesetzteWoerter;
 }
 
 // Prints the word salad to console
@@ -37,7 +37,17 @@ void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
    }
 
 }
-//Logik für createWordSalad: Ein Wort nach dem anderen bis entweder alle Wörter drinnen, 
+//Logik für createWordSalad: 
+/* Salat ist das Wortsalat Array.
+1. Salat wird mit "." befüllt. Diese "." symbolisieren leere noch nicht befüllte Stellen
+2. Für jedes Wort aus dem Wort - Array werden nacheinander mögliche Punkte gesucht, welche als Start um dieses Wort
+   ins Array zu schreiben funktionieren. Diese Positionen werden in einer struct gespeichert. 
+3. Für das Wort wird dann per Zufall aus den möglichen Positionen eine ausgewählt
+4. Das Wort wird an der ausgewählten Position in den Salat geschrieben.
+5. Dies passiert für alle Wörter. Gibt es keinen Platz mehr wird das Wort nicht in den Salat geschrieben
+6. Restliche leere "." Stellen des Salats werden mit zufälligen Buchstaben befüllt
+*/
+
 //Funktion dafür den gesammten Salat mit . zu befüllen.
 void clearWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
 {
@@ -68,6 +78,7 @@ void fillWordsaladRand(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], u
 //b.) alle zu besetzenden Felder leer sind (.).
 //Positionamount gibt aus wie viele mögliche Positionen es für dieses Wort gibt. 
 //Wird mit 0 initialisiert. Wenns null bleibt, bedeutet dies es gibt keine verfügbaren Positionen.
+//rechtsfrei und untenfrei werden für jeden Position neu auf 1 initialisiert. Trifft a.) oder b.) nicht zu auf null gesetzt
 int findPossiblePositions(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN],  int wordidx, Position positions[])
 {
    const char *word = words[wordidx];
@@ -140,43 +151,43 @@ int findPossiblePositions(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN]
 
 //Nun muss für jedes Wort per zufall ausgesucht werden Wo es beginnt und welche richtung aus 
 //den ganzen möglichen fällen und dann das wort ins grid gezeichnet werden.
-int fuelleSalatMitWörtern(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], Position position[], unsigned int wordcount)
+int fuelleSalatMitWoertern(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], Position position[], unsigned int wordcount)
 {
-   int gesetzteWörter = 0;
+   int gesetzteWoerter = 0;
    int positionsamount;
-   int positiongewählt;
+   int positiongewaehlt;
    const char *word;
    for(int i = 0; i < wordcount; i++) //jedes Wort.
    {
       positionsamount = findPossiblePositions(salad, searchFieldLen, words, i, position); //für dieses Wort werden die Positionen gefunden
       if(positionsamount > 0)//es gibt Positionen
       {
-         gesetzteWörter++;
-         positiongewählt = rand() % positionsamount; //die wie vielte Position des Positionsarrays für dieses Wort wir nehmen
-         if(position[positiongewählt].richtung == RECHTS)
+         gesetzteWoerter++;
+         positiongewaehlt = rand() % positionsamount; //die wie vielte Position des Positionsarrays für dieses Wort wir nehmen
+         if(position[positiongewaehlt].richtung == RECHTS)
          {
             word = words[i];
-            int p = position[positiongewählt].x;
+            int p = position[positiongewaehlt].x;
             int t = 0;
             for(int k = p; k < p + strlen(word); k++)
             {
-               salad[position[positiongewählt].y][k] = word[t];
+               salad[position[positiongewaehlt].y][k] = word[t];
                t++;
             }
          }
-         if(position[positiongewählt].richtung == UNTEN)
+         if(position[positiongewaehlt].richtung == UNTEN)
          {
             word = words[i];
-            int up = position[positiongewählt].y;
+            int up = position[positiongewaehlt].y;
             int ut = 0;
             for(int uk = up; uk < up +strlen(word); uk++)
             {
-               salad[uk][position[positiongewählt].x] = word[ut];
+               salad[uk][position[positiongewaehlt].x] = word[ut];
                ut++;
             }
          }
       }
    }
-   return gesetzteWörter;
+   return gesetzteWoerter;
 
 }

Start_Linux/game.h

@@ -20,7 +20,7 @@ void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
 void clearWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen);
 void fillWordsaladRand(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen);
 int findPossiblePositions(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN],  int wordidx, Position positions[]);
-int fuelleSalatMitWörtern(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], Position position[], unsigned int wordcount);
+int fuelleSalatMitWoertern(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], Position position[], unsigned int wordcount);
 
 
 #endif

Start_Linux/goofywords.txt

@@ -0,0 +1,2 @@
+dartgoblin, haughrida, royal_knight, larry,
+larry_king, heheheha, huhui, schere, grrrrrr

Start_Linux/input.c

@@ -1,12 +1,45 @@
+
+//erstellt von Harun Faizi am 01.11.2025
 #include "input.h"
 #include <string.h>
-#include <ctype.h>
+#include <ctype.h>  // Wichtig für toupper()
+#include <stdio.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)
 {
+    if (file == NULL)
+        return 0; // Sicherheitsprüfung, also wurde ein File gefunden
 
+    char line[MAX_LINE_LEN]; // Puffer für eine Zeile aus Datei
+    unsigned int wordCount = 0; // zählt die gefundenen Wörter
+
+    // Lese Datei Zeile für Zeile
+    while(fgets(line, sizeof(line), file) != NULL)
+    {
+        // Zerlege die Zeile in Wörter anhand der Trennzeichen
+        char *token = strtok(line, ".,; \t\n");
+
+        while (token != NULL && wordCount < maxWordCount)
+        {
+            // Kopiere das aktuelle Token ins Array und sichere Nullterminierung
+            strncpy(words[wordCount], token, MAX_WORD_LEN - 1);
+            words[wordCount][MAX_WORD_LEN - 1] = '\0';
+
+            // --- HINZUGEFÜGT ---
+            // Wandle das gesamte Wort in Großbuchstaben um
+            for(int i = 0; words[wordCount][i] != '\0'; i++)
+            {
+               words[wordCount][i] = toupper(words[wordCount][i]);
+            }
+            // --- ENDE HINZUGEFÜGT ---
+
+            wordCount++;
+            token = strtok(NULL, ".,; \t\n"); // nächstes Token
+        }
+
+        if (wordCount >= maxWordCount)
+            break;
+    }
+
+    return wordCount;
 }

Start_Linux/main.c

@@ -38,8 +38,7 @@ int main(int argc, char *argv[])
 
             if(placedWords == wordCount) //Checks if all words were placed
             {
-                startGame(wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], SALAD_SIZE, words[MAX_NUMBER_OF_WORDS][MAX_WORD_LEN], placedWords, 800);
-            }
+                startGame(wordSalad, SALAD_SIZE, words, placedWords, 800);            }
             else
             {
                 printf("Error. Out of %d words just %d words could be placed.\n", wordCount, placedWords);

Start_Linux/makefile

@@ -1,17 +1,17 @@
-CC = gcc               # Compiler-Variable: welcher C-Compiler genutzt wird (hier gcc)
-CFLAGS = -g -Wall -I$(raylibfolder)   # -Wall  -> alle wichtigen Warnungen aktivieren, -I : suche dort (raylibfolder) nach datei.
-LDFLAGS = -lGL -lX11 -lm       # Linker-Flags: Bibliotheken, die an das Linker-Kommando übergeben werden
+CC = gcc
+CFLAGS = -g -Wall -I$(raylib_folder)   # <- KORRIGIERT
+LDFLAGS = -lGL -lX11 -lm #Linker Flags binden verschiedene Bibliotheken ein. Include "bib_name" -> -l"bib_name"
 BINARIES = ./linux
 
-raylib_folder = ./raylib     #Pfade zu raylib_folder und unityfolder
+raylib_folder = ./raylib
 unityfolder = ./unity
 
 # --------------------------
 # initiales Spiel bauen
 # --------------------------
-wordsalad_initial:    #hier kommen normalerweise Abhängikeiten hin. Z.b die Datei game.o muss vorhanden sein.
+wordsalad_initial:
 	$(CC) -o wordsalad_initial -L. $(BINARIES)/libwordsalad_complete.a $(BINARIES)/libraylib.a $(LDFLAGS)
-#wordsalad_initial linkt nur bibliotheken. Deshalb hat es keine Abhängigkeiten.
+
 # --------------------------
 # Normales Spiel bauen
 # --------------------------
@@ -19,29 +19,45 @@ wordsalad: main.o input.o game.o graphicalGame.o $(BINARIES)/libraylib.a
 	$(CC) $(CFLAGS) -o wordsalad main.o input.o game.o graphicalGame.o $(BINARIES)/libraylib.a $(LDFLAGS)
 
 main.o: main.c
-	$(CC) $(CFLAGS) -c main.c
-
-input.o: input.c
-	$(CC) $(CFLAGS) -c input.c
+	$(CC) $(CFLAGS) -c $< -o $@  # <- KORRIGIERT
+#bedeutung: $< erste Abhängigkeit (in diesem Fall main.c), %@ erstelle daraus eine main.o Datei.
+input.o: input.c input.h
+	$(CC) $(CFLAGS) -c $< -o $@  # <- KORRIGIERT (Zeile 25/26)
 
 game.o: game.c
-	$(CC) $(CFLAGS) -c game.c
+	$(CC) $(CFLAGS) -c $< -o $@  # <- KORRIGIERT
 
 graphicalGame.o: graphicalGame.c
-	$(CC) $(CFLAGS) -c graphicalGame.c
+	$(CC) $(CFLAGS) -c $< -o $@  # <- KORRIGIERT
 
 # --------------------------
 # Unit Tests
 # --------------------------
 TEST_BIN = runTests
 
-test: input.o game.o unit_tests.c
-	$(CC) -I$(unityfolder) -o $(TEST_BIN) input.o game.o unit_tests.c $(BINARIES)/libunity.a
+# KORRIGIERTE Test-Regel (umbenannt von neuer_test)
+test: input.o game.o unit_tests.o
+	$(CC) -I$(unityfolder) -o $(TEST_BIN) input.o game.o unit_tests.o $(BINARIES)/libunity.a
+
+# KORRIGIERTE unit_tests.o Regel
+unit_tests.o: unit_tests.c input.h game.h
+	$(CC) $(CFLAGS) -I$(unityfolder) -c $< -o $@
 
 # --------------------------
 # Clean
 # --------------------------
-wordsalad_myversion: main.o $(BINARIES)/libwordsalad.a #eigenes Programm erstellen.
+wordsalad_myversion: main.o $(BINARIES)/libwordsalad.a
 	$(CC) -o wordsalad_myversion main.o $(BINARIES)/libwordsalad.a
+
 clean:
 	rm -f *.o wordsalad $(TEST_BIN)
+# Tests starten mit ./runTests
+#Erklärung der veränderungen im Vergleich zu davor <- Korrigiert;
+#Das war nötig, weil make deinen alten Befehl ignoriert hat.
+
+# Das Problem mit dem alten Befehl: make hat deine Regel input.o: ... gesehen und wollte input.o erstellen. Es hat sich deinen Befehl $(CC) $(CFLAGS) -c input.c angesehen. 
+# Für make war dieser Befehl "unvollständig". Es stand dort nicht explizit, dass dieser Befehl die Datei input.o erstellt (obwohl gcc das automatisch tun würde).
+# make ignoriert den Befehl: Weil make deinen Befehl als unzureichend ansah, verwarf es ihn stillschweigend.
+# make nutzt seine eingebaute Regel: Stattdessen griff make auf seine eigene, eingebaute (implizite) Regel zurück, um eine .o-Datei zu erstellen. 
+# Diese eingebaute Regel ist jedoch falsch für uns: Sie versucht, die .c-Datei zu linken, nicht nur zu kompilieren.
+# Der Fehler: Diese (falsche) eingebaute Regel von make war es, die den Linker aufrief und den Fehler undefined reference to 'main' verursachte.