hello_merge gelöscht. Test mit stage commmit push hat funktioniert.

Start_Linux/.vscode/settings.json

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

Start_Linux/game.c

@@ -1,4 +1,3 @@
-//Bearbeitet von Lukas Wörner, 02.11.25
 #include "game.h"
 #include <time.h>
 #include <stdlib.h>
@@ -7,7 +6,6 @@
 #define MAX_RAND_TRIES_PER_WORD 10
 #define EMPTY_CHAR 0
 
- //Position beinhaltet x, y und Richtung
 //TODO: Spiellogik implementieren:
 /* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
    * restliche Felder mit zufälligen Buchstaben füllen */
@@ -15,179 +13,11 @@
 // 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)
 {
-   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 gesetzteWoerter = 0;
-   clearWordSalad(salad, searchFieldLen);
-   gesetzteWoerter = fuelleSalatMitWoertern(salad, searchFieldLen, words, position, wordCount);
-   fillWordsaladRand(salad, searchFieldLen);
-   return gesetzteWoerter;
+
 }
 
 // Prints the word salad to console
 void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
 {
-   for(int i = 0; i < searchFieldLen; i++)
-   {
-      for(int k = 0; k < searchFieldLen; k++)
-      {
-         printf("%c", salad[i][k]);
-      }
-      printf("\n");
-   }
 
 }
-//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)
-{
-   for(unsigned int zeile = 0; zeile < searchFieldLen; zeile++)
-   {
-      for(unsigned int spalte = 0; spalte < searchFieldLen; spalte++)
-      {
-         salad[zeile][spalte] = '.'; // salad wird mit Punkten befüllt.
-      }
-   }
-}
-//Funktion für den Schluss: Übrige leere stellen werden random befüllt.
-void fillWordsaladRand(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
-{
-   for(int i = 0; i < searchFieldLen; i++)
-   {
-      for(int k = 0; k < searchFieldLen; k++)
-      {
-         if(salad[i][k] == '.')
-         {
-            salad[i][k] = 'A' + rand() % 26;
-         }
-      }
-   }
-}
-//hierbei: alle Positionen werden zunächst geprüft ob leer (.) danach wird nach rechts und nach unten geschaut ob:
-//a.) genügend Platz wäre, dass nicht aus dem array herausgeschrieben wird und
-//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];
-   int wordlen = strlen(word);
-   int positionamount = 0;
-   int rechtsfrei = 1;
-   int untenfrei = 1;
-   for(int i = 0; i < searchFieldLen; i++)
-   {
-      for(int k = 0; k < searchFieldLen; k++)
-      {
-         rechtsfrei = 1;
-         untenfrei = 1;
-         if(salad[i][k] == '.')
-         {
-            //nach rechts prüfen
-            if(searchFieldLen - k >= wordlen)
-            {
-               for(int p = k +1; p < k+ wordlen; p++)
-               {
-                  if(salad[i][p] != '.')
-                  {
-                     rechtsfrei = 0;
-                     break;
-                  }
-               }
-
-            }
-            else
-            {
-               rechtsfrei = 0;
-            }
-            //nach unten prüfen
-            if(searchFieldLen - i >= wordlen)
-            {
-               for(int q = i+1; q < i+ wordlen; q++)
-               {
-                  if(salad[q][k] != '.')
-                  {
-                     untenfrei = 0;
-                     break;
-                  }
-               }
-            }
-            else
-            {
-               untenfrei = 0;
-            }
-            if(rechtsfrei) //Positions array wird mit gültigen Positionen und Richtung befüllt.
-            {
-               positions[positionamount].x = k;
-               positions[positionamount].y = i;
-               positions[positionamount].richtung = RECHTS;
-               positionamount++;
-            }
-            if(untenfrei)
-            {
-               positions[positionamount].x = k;
-               positions[positionamount].y = i;
-               positions[positionamount].richtung = UNTEN;
-               positionamount++;
-            }
-         }
-      }
-   }
-
-   return positionamount;
-
-}
-
-//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 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 gesetzteWoerter = 0;
-   int positionsamount;
-   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
-      {
-         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[positiongewaehlt].x;
-            int t = 0;
-            for(int k = p; k < p + strlen(word); k++)
-            {
-               salad[position[positiongewaehlt].y][k] = word[t];
-               t++;
-            }
-         }
-         if(position[positiongewaehlt].richtung == UNTEN)
-         {
-            word = words[i];
-            int up = position[positiongewaehlt].y;
-            int ut = 0;
-            for(int uk = up; uk < up +strlen(word); uk++)
-            {
-               salad[uk][position[positiongewaehlt].x] = word[ut];
-               ut++;
-            }
-         }
-      }
-   }
-   return gesetzteWoerter;
-
-}

Start_Linux/game.h

@@ -1,26 +1,11 @@
-//Bearbeitet von Lukas Wörner, 02.11.25
 #ifndef GAME_H
 #define GAME_H
 
 #include "input.h"
 
 #define MAX_SEARCH_FIELD_LEN 100
-#define MIN_WORD_LEN 2
-
-typedef enum {RECHTS, UNTEN} RICHTUNG;
-
-typedef struct
-{
-   int x, y;
-   RICHTUNG richtung;
-}Position;
 
 int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen, const char words[][MAX_WORD_LEN], unsigned int wordCount);
 void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen);
-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 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

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

Start_Linux/input.c

@@ -1,45 +1,12 @@
-
-//erstellt von Harun Faizi am 01.11.2025
 #include "input.h"
 #include <string.h>
-#include <ctype.h>  // Wichtig für toupper()
-#include <stdio.h>
+#include <ctype.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

@@ -5,7 +5,7 @@
 #include "graphicalGame.h"
 
 #define MAX_NUMBER_OF_WORDS 100
-#define SALAD_SIZE 20 //20 Buchstaben breit und lang
+#define SALAD_SIZE 20
 
 int main(int argc, char *argv[])
 {
@@ -22,7 +22,7 @@ int main(int argc, char *argv[])
         char words[MAX_NUMBER_OF_WORDS][MAX_WORD_LEN]; // Array to hold the words to be used in the game
         unsigned int wordCount = 0;
 
-        FILE *file = fopen(argv[1], "r"); //FILE ZEIGER, öffne cmd zweites Wort: Zweites Wort ist ja words.txt also Wort file
+        FILE *file = fopen(argv[1], "r");
 
         if(file != NULL)
         {
@@ -36,15 +36,6 @@ int main(int argc, char *argv[])
             // Create the word salad by placing words into grid
             placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, wordCount);
 
-            if(placedWords == wordCount) //Checks if all words were placed
-            {
-                startGame(wordSalad, SALAD_SIZE, words, placedWords, 800);            }
-            else
-            {
-                printf("Error. Out of %d words just %d words could be placed.\n", wordCount, placedWords);
-            }
-
-
             // TODO:
             // Check if all words were successfully placed
             // Start the game if successful

Start_Linux/makefile

@@ -1,9 +1,9 @@
 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"
+CFLAGS = -g -Wall
+LDFLAGS = -lGL -lX11 -lm
 BINARIES = ./linux
 
-raylib_folder = ./raylib
+raylibfolder = ./raylib
 unityfolder = ./unity
 
 # --------------------------
@@ -19,45 +19,27 @@ 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 $< -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)
+	$(CC) $(CFLAGS) -c main.c
+
+input.o: input.c
+	$(CC) $(CFLAGS) -c input.c
 
 game.o: game.c
-	$(CC) $(CFLAGS) -c $< -o $@  # <- KORRIGIERT
+	$(CC) $(CFLAGS) -c game.c
 
 graphicalGame.o: graphicalGame.c
-	$(CC) $(CFLAGS) -c $< -o $@  # <- KORRIGIERT
+	$(CC) $(CFLAGS) -I$(raylibfolder) -c graphicalGame.c
 
 # --------------------------
 # Unit Tests
 # --------------------------
 TEST_BIN = runTests
 
-# 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 $@
+test: input.o game.o unit_tests.c
+	$(CC) -I$(unityfolder) -o $(TEST_BIN) input.o game.o unit_tests.c $(BINARIES)/libunity.a
 
 # --------------------------
 # Clean
 # --------------------------
-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.