die beste Version

Start_Mac/game.c

@@ -1,223 +1,93 @@
 #include "game.h"
-#include <time.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
-#define MAX_RAND_TRIES_PER_WORD 10
+#define EMPTY_CHAR '.' // Leeres Kästchen
-#define EMPTY_CHAR '.'
 
+typedef enum { HORIZONTAL, VERTICAL } Direction;
 
-// TODO: Spiellogik implementieren:
+// 1. Funktion – Array initialisieren
-/* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
+static void initializeArray(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int size)
- * restliche Felder mit zufälligen Buchstaben füllen */
-
-
-
-static void initializeArray(char salad [MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen) //Array initialisieren & mit Filler füllen
 {
-
+    for (unsigned int y = 0; y < size; y++)
-   for (int i = 0; i < searchFieldLen; i++)
+        for (unsigned int x = 0; x < size; x++)
-   {
+            salad[y][x] = EMPTY_CHAR;
-
-      for (int j = 0; j < searchFieldLen; j++)
-      {
-         salad[i][j] = EMPTY_CHAR;
-      }
-   }
 }
 
-
+// 2. Funktion – prüfen, ob Wort passt
-static void col_row (unsigned int searchFieldLen, int *x, int *y) //Zufällige x/y Koordinate für Anfang von Wort
+static int canPlace(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
+                    unsigned int size, unsigned int x, unsigned int y,
+                    const char *word, Direction dir)
 {
-   *x = rand() % searchFieldLen; 
+    unsigned int len = strlen(word);
+    if ((dir == HORIZONTAL && x + len > size) || (dir == VERTICAL && y + len > size))
+        return 0;
 
-   *y = rand() % searchFieldLen; 
+    for (unsigned int i = 0; i < len; i++) {
+        if ((dir == HORIZONTAL && salad[y][x + i] != EMPTY_CHAR) ||
+            (dir == VERTICAL && salad[y + i][x] != EMPTY_CHAR))
+            return 0;
+    }
+    return 1;
 }
 
-
+// 3. Funktion – Wort eintragen
-static int place(char salad [MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], int searchFieldLen, int len [],const char words [] [MAX_WORD_LEN], unsigned int wordCount) //Prüfen ob plazierbar und plazieren
+static void placeWord(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
+                      unsigned int x, unsigned int y, const char *word, Direction dir)
 {
-   int x, y;
+    for (unsigned int i = 0; i < strlen(word); i++) {
-   int placedWords = 0; //Counter plazierte Wörter
+        if (dir == HORIZONTAL)
-
+            salad[y][x + i] = word[i];
-
-   for(int i = 0; i < wordCount; i++)
-   {
-      int placed = 0;
-
-
-      for(int tries = 0; tries < MAX_RAND_TRIES_PER_WORD && !placed; tries++)
-      {
-         len[i] = (int)strlen(words[i]);
-
-         col_row(searchFieldLen, &x, &y);
-
-         int orient = rand() % 2;
-
-
-         if(orient == 0) //wir prüfen und füllen horizontal (in x-Richtung)
-         {
-            int works = 1;
-
-            if(((x + len[i]) > searchFieldLen)) 
-            {
-
-               works = 0;
-
-            }
-
-
         else
+            salad[y + i][x] = word[i];
+    }
+}
+
+// 4. Funktion – leere Felder mit Zufallsbuchstaben füllen
+static void fillRandomLetters(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int size)
 {
-
+    for (unsigned int y = 0; y < size; y++)
-               for(int j = x; j < (x + len[i]); j++)
+        for (unsigned int x = 0; x < size; x++)
-               {
+            if (salad[y][x] == EMPTY_CHAR)
-
+                salad[y][x] = 'A' + (rand() % 26);
-                  if(salad[y][j] != EMPTY_CHAR)
-                  {
-
-                     works = 0; 
-                     break;
-
-                  }
-               }
 }
 
-            // ab hier platzieren wir
+// Hauptfunktion – Wortsalat erzeugen
-
+int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],
-            if(works)
+                    unsigned int size, const char words[][MAX_WORD_LEN],
-            {
+                    unsigned int wordCount)
-
-               for (int k = 0; k < len[i]; k++)
-               {
-
-                  salad[y][x + k] = words[i][k];
-
-               }
-
-               placed = 1;
-               placedWords++;
-
-            }
-         }
-   
-
-         else //wir prüfen und füllen vertikal (in y-Richtung)
-         {
-            int works = 1;
-
-            if(((y + len[i]) > searchFieldLen))
-            {
-
-               works = 0;
-
-            }
-
-            else 
-            {
-
-               for(int j = y; j < (y + len[i]); j++)
-               {
-
-                  if(salad[j][x] != EMPTY_CHAR)
-                  {
-
-                     works = 0; 
-                     break;
-
-                  }
-               }
-            }
-
-            // ab hier platzieren wir 
-
-            if(works)
-            {
-
-               for (int k = 0; k < len[i]; k++)
-               {
-
-                  salad[y + k][x] = words[i][k];
-
-               } 
-
-               placed = 1;
-               placedWords++;
-
-            }   
-         }
-      }   
-   }
-
-return placedWords;
-
-}
-
-
-static void fillLetters(char salad [MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen) //Übrige freie Felder mit Buchstaben füllen
-{
-
-   for (int i = 0; i < searchFieldLen; i++)
-   {
-
-      for (int j = 0; j < searchFieldLen; j++)
-      {
-         
-         if (salad[i][j] == EMPTY_CHAR)
-         {
-
-            char random_letter = 'A' + (rand() % 26);
-            salad[i][j] = random_letter;
-
-         }
-      }
-   }
-}
-
-//Erstellt Wortsalat, plaziert Wörter zufällig & füllt die Lücken
-
-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));
+    initializeArray(salad, size);
 
-   initializeArray(salad, searchFieldLen);
+    int placed = 0;
-
+    for (unsigned int i = 0; i < wordCount; i++) {
-   int len [wordCount];
+        int success = 0;
-   int count = 0;
+        for (int tries = 0; tries < 1000 && !success; tries++) {
-
+            unsigned int x = rand() % size;
-   for(int i = 0; i < wordCount; i++)
+            unsigned int y = rand() % size;
-   {
+            Direction dir = rand() % 2 ? HORIZONTAL : VERTICAL;
-
-      if(words [i] [0] != '\0')
-      count++;
 
+            if (canPlace(salad, size, x, y, words[i], dir)) {
+                placeWord(salad, x, y, words[i], dir);
+                success = 1;
+                placed++;
+            }
+        }
     }
 
-   int placeWords = place(salad, searchFieldLen, len, words, count);
+    fillRandomLetters(salad, size);
-
+    return placed;
-
-   fillLetters(salad, searchFieldLen);
-
-   return placeWords;
-   
 }
 
-// Ausgabe von Wortsalat auf Konsole
+// Ausgabe-Funktion
-
+void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int size)
-void showWordSalad(const char salad [MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
 {
-
+    for (unsigned int y = 0; y < size; y++) {
-   for (int i = 0; i < searchFieldLen; i++)
+        for (unsigned int x = 0; x < size; x++)
-   {
+            printf("%c ", salad[y][x]);
-
-      for (int j = 0; j < searchFieldLen; j++)
-      {
-
-         printf("%c ", salad [i][j]);
-
-      }
-
         printf("\n");
-
     }
 }

Start_Mac/input.c

@@ -1,39 +1,38 @@
-#include "input.h"
+#include <stdio.h>      
+#include <stdlib.h>     
 #include <string.h>     
 #include <ctype.h>      
-#include <stdio.h>
+#include "input.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)
 {
 
-    unsigned int count = 0;
+    unsigned int count = 0;                                                                                             // wie viele Wörter bisher gespeichert wurden
-    char line[MAX_LINE_LEN];
+    char line[MAX_LINE_LEN];                                                                                            // Puffer für EINE gelesene Textzeile
 
-    while(fgets(line, sizeof(line), file)!= NULL && count < maxWordCount)
+    while(fgets(line, sizeof(line), file)!= NULL && count < maxWordCount)                                      //fgets liest eine komplette Zeile wenn es noch eine Zeile gibt und noch Platz für mehr Wörter ist
     {
-        const char *delims = "\t\n\r ,;";
+        const char *delims = "\t\n\r ,;";                                                                               //Liste der Trenner (z.B. Komma)
-        char *token = strtok(line, delims);
+        char *token = strtok(line, delims);                                                                             //strok  sucht in line das erste Wort, indem es an Trennzeichen teilt. Wenn kein Wort gefunden, wird NULL zurück gegeben
 
 
-        while (token != NULL && count < maxWordCount)
+        while (token != NULL && count < maxWordCount)                                                                   //Solange es noch ein Wort (token) gibt und noch Platz in words ist
         {
             for(unsigned int i = 0; token[i] != '\0'; i++)
             {
-                token[i] = toupper((unsigned char)token[i]);
+                token[i] = toupper((unsigned char)token[i]);                                                            //toupper macht jeden Buchstaben groß.
             }
-            strncpy(words[count], token, MAX_WORD_LEN -1);
+            strncpy(words[count], token, MAX_WORD_LEN -1);                                                        //Kopiert das Wort in den nächsten freien Slot words[count].
             words[count][MAX_WORD_LEN -1] = '\0';
-            count++;
+            count++;                                                                                                    //Wir habenein Wort abgespeichert count + 1
             token = strtok(NULL, delims); //hier
 
         }
-
     }
     return count;
-
 }
-

Start_Mac/main.c

@@ -10,84 +10,44 @@
 
 
 int main(int argc, char *argv[])
-{
 
+{
     int exitCode = EXIT_SUCCESS;
 
-
+    if (argc != 2)                                                                                                      //wenn keine zwei argumente gefunde -> alarm
-    // Check if the correct number of arguments is provided
-
-    if(argc != 2)
     {
-
+        fprintf(stderr, "Benutzung: %s <Pfad zur Wörterdatei>\n", argv[0]);
-        fprintf(stderr, "Usage: %s <path to file with search words>\n", argv[0]);
+        return EXIT_FAILURE;
-        exitCode = EXIT_FAILURE;
-
     }
 
-    else
+    char words[MAX_NUMBER_OF_WORDS][MAX_WORD_LEN];                                                                      //array mit eingelesenen wörtern
-    {
-
-        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");                                                                     //schaut in die words.txt datei
-
+    if (!file)                                                                                                          //wenn keine datei -> alarm
-        if(file != NULL)
     {
+        fprintf(stderr, "Konnte Datei %s nicht öffnen.\n", argv[1]);
+        return EXIT_FAILURE;
+    }
 
     unsigned int placedWords = 0;
-            char wordSalad [MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN]; // 2D array to store the word salad
+    char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
 
-
+    wordCount = readWords(file, words, MAX_NUMBER_OF_WORDS);                                                //holt sich aus readwords funktion die wortanzahl
-            // Read words from file and store in 'words' array
-
-            wordCount = readWords(file, words, MAX_NUMBER_OF_WORDS);
     fclose(file);
 
+    placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, wordCount);                                 //holt sich anzahl der platzierten wörter von createwordsalad funktion
 
-            // Create the word salad by placing words into grid
+    printf("\nWortsalat-Initialisierung\n");                                                                      //ganz viel printen
+    printf("-------------------------\n");
+    printf("Gelesene Woerter: %u\n", wordCount);
+    printf("Platzierte Woerter: %u\n", placedWords);
 
-            placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, MAX_NUMBER_OF_WORDS);
+    if (placedWords < wordCount)                                                                                        //macht checker, ob alle wörter salatiert wurden
-
+        printf("Hinweis: %u Woerter konnten nicht platziert werden.\n", wordCount - placedWords);
-
-            // TODO:
-            // Check if all words were successfully placed
-
-            if(placedWords == wordCount)
-            {
-
-                printf("Alle %u Wörter wurden erfolgreich platziert.", placedWords);
-
-                // Start the game if successful
-
-                startGame(wordSalad, SALAD_SIZE, words, wordCount, 800);
-
-            }
-
-            // error message if some words couldn't be placed
-
-
-            else
-            {
-
-                printf("Es konnten nicht alle Wörter ausgegeben werden. Nur %u von %u Wörtern wurde platziert.\n", placedWords, wordCount);
-
-            }
-        }
-
-
-        else
-        {
-
-            // Print error message if file couldn't be opened
-            
-            fprintf(stderr, "Could not open file %s for reading ...\n", argv[1]);
-            exitCode = EXIT_FAILURE;
-
-        }
-    }
 
+    printf("\nSpielfeld (%dx%d):\n\n", SALAD_SIZE, SALAD_SIZE);
+    showWordSalad(wordSalad, SALAD_SIZE);
+    printf("\nInitialisierung abgeschlossen.\n");
     return exitCode;
-
 }

Start_Mac/words.txt

@@ -1,16 +1,7 @@
-YETI
+Yeti,Nessie Werwolf; Vampir
-NESSIE
+Monster
-WERWOLF
+Hydra;Frankenstein; fortnite
-VAMPIR
+Dracula;KingKong;Gremlin;Kobold,Hexe;Poltergeist
-MONSTER
+Gespenst, Oger 
-HYDRA
+tomasschwester, lababage, eckesbokesseresekes
-FRANKENSTEIN
+Doener, Kebab, nacho, alejandrogarnacho, megafon, Telefon, gianluigibuffon, mehrweorter,
-DRACULA
-KINGKONG
-GREMLIN
-KOBOLD
-HEXE
-POLTERGEIST
-GESPENST
-OGER
-APFEL

Start_Mac/wordsalad.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.wordsalad</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

Start_Mac/wordsalad.dSYM/Contents/Resources/Relocations/aarch64/wordsalad.yml

@@ -0,0 +1,5 @@
+---
+triple:          'arm64-apple-darwin'
+binary-path:     wordsalad
+relocations:     []
+...

Start_Windows/game.c

@@ -1,23 +1,82 @@
 #include "game.h"
-#include <time.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
-#define MAX_RAND_TRIES_PER_WORD 10
+//große Funktion (Gitter bauen, Wörter legen, Zufallsbuchstaben)
-#define EMPTY_CHAR 0
+int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN],                                             //Gitter
-
+                    unsigned int size, const char words[][MAX_WORD_LEN],                                                //größe Quadrat,liste von Wörtern
-//TODO: Spiellogik implementieren:
+                    unsigned int wordCount)  {                                                                          //anzahl an Wörtern in der Liste
-/* * Wörter aus der Wortliste zufällig horizontal oder vertikal platzieren
+    #define EMPTY_CHAR '.'                                                                                              // leeres kästchen = "."
-   * restliche Felder mit zufälligen Buchstaben füllen */
+    typedef enum { HORIZONTAL, VERTICAL } Direction;                                                                    //neuer typ: waagrecht oder senkrecht
-
-// 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)
-{
 
+    //1.kleine Funktion(setzt jedes Kästchen auf ".")
+    void initializeArray() {
+        for (unsigned int y = 0; y < size; y++)                                                                         //Zeilen durchlaufen
+            for (unsigned int x = 0; x < size; x++)                                                                     //Spalten durchlaufen
+                salad[y][x] = EMPTY_CHAR;                                                                               //punkt schreiben
+    }
+    //2.kleine Funktion (prüfen ob Wort passt)
+    int canPlace(unsigned int x, unsigned int y, const char *word, Direction dir) {                                     //Startposition, das Wort, Richtung
+        unsigned int len = strlen(word);                                                                                //länge des Wortes
+        if ((dir == HORIZONTAL && x + len > size) || (dir == VERTICAL && y + len > size))                               //prüfen ob Wort über rechten bzw. unteren Rand geht
+            return 0;                                                                                                   //passt das wort nicht -> 0
+        for (unsigned int i = 0; i < len; i++) {                                                                        //jedes zeichen nacheinander prüfen
+            if ((dir == HORIZONTAL && salad[y][x + i] != EMPTY_CHAR) ||                                                 //prüfen ob nach rechts schon ein wort kommt
+                (dir == VERTICAL && salad[y + i][x] != EMPTY_CHAR))                                                     //prüfen ob nach unten ein Wort kommt
+                return 0;                                                                                               //ist dort bereits ein wort -> 0
+        }
+        return 1;                                                                                                       //passt das Wort -> 1
+    }
+    //3.kleine Funktion (Wort ins Gitter schreiben)
+    void placeWord(unsigned int x, unsigned int y, const char *word, Direction dir) {                                   //Startposition, das Wort, Richtung
+        for (unsigned int i = 0; i < strlen(word); i++) {                                                               //Buchstabe für Buchstabe
+            if (dir == HORIZONTAL)                                                                                      //i-ten Buchstaben an y,x+i schreiben bei waagrecht
+                salad[y][x + i] = word[i];
+            else                                                                                                        //i-ten Buchstaben an y+i,x schreiben bei senkrecht
+                salad[y + i][x] = word[i];
+        }
+    }
+    //4.kleine Funktion (alle leeren Kästchen bekommen Zufallsbuchstaben)
+    void fillRandomLetters() {                                                                                          //geht wieder über alle Zeilen und Spalten oh man
+        for (unsigned int y = 0; y < size; y++) {
+            for (unsigned int x = 0; x < size; x++) {
+                if (salad[y][x] == EMPTY_CHAR)                                                                          //wenns leer ist Zufallsbuchstabe
+                    salad[y][x] = 'A' + (rand() % 26);
+            }
+        }
     }
 
-// Prints the word salad to console
+    //Hauptschleife(Wörter zufällig platzieren)
-void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen)
+    srand(time(NULL));                                                                                             //durch aktuelle Sekundenzeit wirkklich zufällig
-{
+    initializeArray();                                                                                                  //1.kleine Funktion
 
+    int placed = 0;                                                                                                     //wie viele Wörter wurden gelegt?
+    for (unsigned int i = 0; i < wordCount; i++) {                                                                      //jedes Wort durchgehen
+        int success = 0;                                                                                                //für dieses Wort schon Platz gefunden?
+        for (int tries = 0; tries < 1000 && !success; tries++) {                                                        //1000 verschiedene Stellen und Richtungen probieren
+            unsigned int x = rand() % size;                                                                             //zufällige Position Spalte
+            unsigned int y = rand() % size;                                                                             //zufällige Postion Zeile
+            Direction dir = rand() % 2 ? HORIZONTAL : VERTICAL;                                                         //zufällige richtung 1-> Horizontal 0-> Vertical
+            if (canPlace(x, y, words[i], dir)) {                                                                        //2. kleine Funktion
+                placeWord(x, y, words[i], dir);                                                                         //3. kleine Funktion
+                success = 1;                                                                                            //Wort erfolgreich platziert
+                placed++;                                                                                               //Zähler der gelegten Wörter erhöhen
+            }
+        }
+    }
+
+    fillRandomLetters();                                                                                                //4. kleine Funktion
+
+    return placed;                                                                                                      //Rückgabe wie viele Wörter plaziert wurden
+}
+//Anzeige-Funktion
+void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int size) {                   //funktion printet das wortsalatfeld
+    for (unsigned int y = 0; y < size; y++) {
+        for (unsigned int x = 0; x < size; x++) {
+            printf("%c ", salad[y][x]);
+        }
+        printf("\n");
+    }
 }

Start_Windows/game.h

@@ -9,3 +9,4 @@ int createWordSalad(char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsi
 void showWordSalad(const char salad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN], unsigned int searchFieldLen);
 
 #endif
+

Start_Windows/input.c

@@ -1,12 +1,38 @@
 #include "input.h"
 #include <string.h>
 #include <ctype.h>
+#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)
 {
 
+    unsigned int count = 0;                                                                                             // wie viele Wörter bisher gespeichert wurden
+    char line[MAX_LINE_LEN];                                                                                            // Puffer für EINE gelesene Textzeile
+
+    while(fgets(line, sizeof(line), file)!= NULL && count < maxWordCount)                                      //fgets liest eine komplette Zeile wenn es noch eine Zeile gibt und noch Platz für mehr Wörter ist
+    {
+        const char *delims = "\t\n\r ,;";                                                                               //Liste der Trenner (z.B. Komma)
+        char *token = strtok(line, delims);                                                                             //strok  sucht in line das erste Wort, indem es an Trennzeichen teilt. Wenn kein Wort gefunden, wird NULL zurück gegeben
+
+
+        while (token != NULL && count < maxWordCount)                                                                   //Solange es noch ein Wort (token) gibt und noch Platz in words ist
+        {
+            for(unsigned int i = 0; token[i] != '\0'; i++)
+            {
+                token[i] = toupper((unsigned char)token[i]);                                                            //toupper macht jeden Buchstaben groß.
+            }
+            strncpy(words[count], token, MAX_WORD_LEN -1);                                                        //Kopiert das Wort in den nächsten freien Slot words[count].
+            words[count][MAX_WORD_LEN -1] = '\0';
+            count++;                                                                                                    //Wir habenein Wort abgespeichert count + 1
+            token = strtok(NULL, delims); //hier
+
+        }
+
+    }
+    return count;
+
 }

Start_Windows/main.c

@@ -11,44 +11,46 @@ int main(int argc, char *argv[])
 {
     int exitCode = EXIT_SUCCESS;
 
-    // Check if the correct number of arguments is provided
+    if (argc != 2)                                                                                                      //wenn keine zwei argumente gefunde -> alarm
-    if(argc != 2)
     {
-        fprintf(stderr, "Usage: %s <path to file with search words>\n", argv[0]);
+        fprintf(stderr, "Benutzung: %s <Pfad zur Wörterdatei>\n", argv[0]);
-        exitCode = EXIT_FAILURE;
+        return EXIT_FAILURE;
     }
-    else
+
-    {
+    char words[MAX_NUMBER_OF_WORDS][MAX_WORD_LEN];                                                                      //array mit eingelesenen wörtern
-        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");                                                                     //schaut in die words.txt datei
-
+    if (!file)                                                                                                          //wenn keine datei -> alarm
-        if(file != NULL)
     {
-            unsigned int placedWords = 0;
+        fprintf(stderr, "Konnte Datei %s nicht öffnen.\n", argv[1]);
-            char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN]; // 2D array to store the word salad
+        return EXIT_FAILURE;
+    }
 
-            // Read words from file and store in 'words' array
+    unsigned int placedWords = 0;
-            wordCount = readWords(file, words, MAX_NUMBER_OF_WORDS);
+    char wordSalad[MAX_SEARCH_FIELD_LEN][MAX_SEARCH_FIELD_LEN];
+
+    wordCount = readWords(file, words, MAX_NUMBER_OF_WORDS);                                                //holt sich aus readwords funktion die wortanzahl
     fclose(file);
 
-            // Create the word salad by placing words into grid
+    placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, wordCount);                                 //holt sich anzahl der platzierten wörter von createwordsalad funktion
-            placedWords = createWordSalad(wordSalad, SALAD_SIZE, words, wordCount);
 
-            // TODO:
+    printf("\nWortsalat-Initialisierung\n");                                                                      //ganz viel printen
-            // Check if all words were successfully placed
+    printf("-------------------------\n");
-            // Start the game if successful
+    printf("Gelesene Woerter: %u\n", wordCount);
-            // error message if some words couldn't be placed
+    printf("Platzierte Woerter: %u\n", placedWords);
 
-        }
+    if (placedWords < wordCount)                                                                                        //macht checker, ob alle wörter salatiert wurden
-        else
+        printf("Hinweis: %u Woerter konnten nicht platziert werden.\n", wordCount - placedWords);
-        {
+
-            // Print error message if file couldn't be opened
+    printf("\nSpielfeld (%dx%d):\n\n", SALAD_SIZE, SALAD_SIZE);
-            fprintf(stderr, "Could not open file %s for reading ...\n", argv[1]);
+    showWordSalad(wordSalad, SALAD_SIZE);
-            exitCode = EXIT_FAILURE;
+
-        }
+
-    }
+    printf("\nInitialisierung abgeschlossen.\n");
+
+    // Später evtl.:
+    // startGraphicalGame(wordSalad, SALAD_SIZE, words, wordCount);
 
     return exitCode;
 }

Start_Windows/words.txt

@@ -3,3 +3,5 @@ Monster
 Hydra;Frankenstein
 Dracula;KingKong;Gremlin;Kobold,Hexe;Poltergeist
 Gespenst, Oger
+tomasschwester, fortnite, lababage, eckesbokesseresekes
+Doener, Kebab, nacho, alejandrogarnacho, megafon, Telefon, gianluigibuffon, mehrweorter, flosschwester, gingerlatina