.exe erstellt

Start_Linux/game.c

@@ -1,3 +1,4 @@
+//Bearbeitet von Lukas Wörner, 02.11.25
 #include "game.h"
 #include <time.h>
 #include <stdlib.h>
@@ -6,6 +7,7 @@
 #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 */
@@ -13,11 +15,168 @@
 // 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 gesetzteWörter = 0;
+   clearWordSalad(salad, searchFieldLen);
+   gesetzteWörter = fuelleSalatMitWörtern(salad, searchFieldLen, words, position, wordCount);
+   fillWordsaladRand(salad, searchFieldLen);
+   return gesetzteWörter;
 }
 
 // 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: Ein Wort nach dem anderen bis entweder alle Wörter drinnen, 
+//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.
+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 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 gesetzteWörter = 0;
+   int positionsamount;
+   int positiongewählt;
+   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)
+         {
+            word = words[i];
+            int p = position[positiongewählt].x;
+            int t = 0;
+            for(int k = p; k < p + strlen(word); k++)
+            {
+               salad[position[positiongewählt].y][k] = word[t];
+               t++;
+            }
+         }
+         if(position[positiongewählt].richtung == UNTEN)
+         {
+            word = words[i];
+            int up = position[positiongewählt].y;
+            int ut = 0;
+            for(int uk = up; uk < up +strlen(word); uk++)
+            {
+               salad[uk][position[positiongewählt].x] = word[ut];
+               ut++;
+            }
+         }
+      }
+   }
+   return gesetzteWörter;
+
+}

Start_Linux/game.h

@@ -1,11 +1,26 @@
+//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 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);
+
 
 #endif

Start_Linux/main.c

@@ -5,7 +5,7 @@
 #include "graphicalGame.h"
 
 #define MAX_NUMBER_OF_WORDS 100
-#define SALAD_SIZE 20
+#define SALAD_SIZE 20 //20 Buchstaben breit und lang
 
 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 *file = fopen(argv[1], "r"); //FILE ZEIGER, öffne cmd zweites Wort: Zweites Wort ist ja words.txt also Wort file
 
         if(file != NULL)
         {
@@ -36,6 +36,16 @@ 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[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], SALAD_SIZE, words[MAX_NUMBER_OF_WORDS][MAX_WORD_LEN], 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,17 +1,17 @@
-CC = gcc
-CFLAGS = -g -Wall -I$(raylibfolder)
-LDFLAGS = -lGL -lX11 -lm
+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
 BINARIES = ./linux
 
-raylib_folder = ./raylib
+raylib_folder = ./raylib     #Pfade zu raylib_folder und unityfolder
 unityfolder = ./unity
 
 # --------------------------
 # initiales Spiel bauen
 # --------------------------
-wordsalad_initial:
+wordsalad_initial:    #hier kommen normalerweise Abhängikeiten hin. Z.b die Datei game.o muss vorhanden sein.
 	$(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
 # --------------------------
@@ -41,5 +41,7 @@ test: input.o game.o unit_tests.c
 # --------------------------
 # Clean
 # --------------------------
+wordsalad_myversion: main.o $(BINARIES)/libwordsalad.a #eigenes Programm erstellen.
+	$(CC) -o wordsalad_myversion main.o $(BINARIES)/libwordsalad.a
 clean:
 	rm -f *.o wordsalad $(TEST_BIN)