Commit message

.

.gitignore

@@ -1 +1,2 @@
 target/**
+src/test/c/test_test.c

src/main/c/Mathe.c

@@ -0,0 +1,198 @@
+
+// Geschrieben von Yasin Al Satouf
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "Mathe.h"
+
+
+
+void initialisiereZufallsgenerator();
+
+
+int generiereZufallszahl(int minimum, int maximum);
+
+
+char generiereZufallsOperator();
+
+
+int addiere(int zahl1, int zahl2);
+
+
+int subtrahiere(int zahl1, int zahl2);
+
+
+int multipliziere(int zahl1, int zahl2);
+
+int dividiere(int zahl1, int zahl2);
+
+int berechneErgebnis(int zahl1, int zahl2, char operator);
+
+void spieleRunde(int schwierigkeitsgrad);
+
+void zeigeAnleitung();
+
+void zeigeHighscore(int punkte);
+
+int holeSpielerAntwort();
+
+
+void bewerteAntwort(int spielerAntwort, int ergebnis, int* punkte);
+
+
+void zeigeRundenEnde(int punkte);
+
+
+
+
+
+
+void zeigeAuswahl(const char* text);
+
+
+void initialisiereZufallsgenerator() {
+    srand(time(NULL));
+}
+
+
+
+int generiereZufallszahl(int minimum, int maximum) {
+    return minimum + (int)((double)rand() / (RAND_MAX + 1) * (maximum - minimum + 1));
+}
+
+char generiereZufallsOperator() {
+    char operatoren[] = {'+', '-', '*', '/'};
+    int indexnumber = rand() % 4;
+    return operatoren[indexnumber];
+}
+
+void zeigeAnleitung() {
+    printf("\n=== Anleitung ===\n");
+    printf("Löse die folgenden mathematischen Aufgaben, um Punkte zu erzielen.\n");
+    printf("Sie haben die Möglichkeit, zwischen verschiedenen Schwierigkeitsgraden zu wählen.\n");
+    printf("Versuche, so viele Aufgaben wie möglich korrekt zu lösen, um einen höheren Highscore zu erzielen.!\n");
+}
+
+
+void zeigeHighscore(int punkte) {
+    printf("\n=== Highscore ===\n");
+    printf("Dein aktueller Highscore ist: %d Punkte\n", punkte);
+}
+
+
+void bewerteAntwort(int spielerAntwort, int ergebnis, int* punkte) {
+    if (spielerAntwort == ergebnis) {
+        printf("Super, das ist richtig! Du erhältst einen Punkt.\n");
+        (*punkte)++;
+    } else {
+        printf(" Leider Falsch! Die richtige Antwort ist %d\n", ergebnis);
+    }
+}
+
+
+void zeigeRundenEnde(int punkte) {
+    printf("Runde beendet. Du hast insgesamt %d Punkte erreicht.\n", punkte);
+}
+
+int addiere(int ersteZahl, int zweiteZahl) {
+    return ersteZahl + zweiteZahl;
+}
+
+int subtrahiere(int zahl1, int zahl2) {
+    return zahl1 - zahl2;
+}
+
+int multipliziere(int zahl1, int zahl2) {
+    return zahl1 * zahl2;
+}
+
+int dividiere(int zahl1, int zahl2) {
+    if (zahl2 != 0) {
+        return zahl1 / zahl2;
+    } else {
+        printf("Fehler: Division durch Null vermieden.\n");
+        return 0;
+    }
+}
+
+
+
+void zeigeAuswahl(const char* text) {
+    printf("%s\n", text);
+}
+
+int holeSpielerAntwort() {
+    int spielerAntwort;
+    zeigeAuswahl("Deine Antwort: ");
+    scanf("%d", &spielerAntwort);
+    return spielerAntwort;
+}
+
+int berechneErgebnis(int zahl1, int zahl2, char operator) {
+    switch (operator) {
+        case '+':
+            return addiere(zahl1, zahl2);
+        case '-':
+            return subtrahiere(zahl1, zahl2);
+        case '*':
+            return multipliziere(zahl1, zahl2);
+        case '/':
+            return dividiere(zahl1, zahl2);
+        default:
+            return 0;
+    }
+}
+
+
+
+
+
+void spieleRunde(int schwierigkeitsgrad) {
+    int punkte = 0;
+    int anzahlAufgaben = 5;
+    zeigeAuswahl("Berechne die folgenden Aufgaben:");
+
+    for (int i = 0; i < anzahlAufgaben; i++) {
+        int zahl1 = generiereZufallszahl(1 * schwierigkeitsgrad, 10 * schwierigkeitsgrad);
+        int zahl2 = generiereZufallszahl(1 * schwierigkeitsgrad, 10 * schwierigkeitsgrad);
+        char operator = generiereZufallsOperator();
+        if (operator == '/' && zahl2 == 0) {
+            zahl2 = generiereZufallszahl(1 * schwierigkeitsgrad, 10 * schwierigkeitsgrad);
+        }
+        int ergebnis = berechneErgebnis(zahl1, zahl2, operator);
+        printf("Aufgabe %d: %d %c %d\n", i + 1, zahl1, operator, zahl2);
+        int spielerAntwort = holeSpielerAntwort();
+        bewerteAntwort(spielerAntwort, ergebnis, &punkte);
+    }
+
+    zeigeRundenEnde(punkte);
+}
+
+
+
+int mainx() {
+    srand(time(NULL));
+
+    int weiterSpielen = 1;
+    int gesamtPunkte = 0;
+
+    zeigeAnleitung();
+
+    while (weiterSpielen) {
+        int schwierigkeitsgrad;
+        printf("\n Schwierigkeitsgrad wählen (1 für einfach, 2 für mittel, 3 für schwer): ");
+        scanf("%d", &schwierigkeitsgrad);
+
+        spieleRunde(schwierigkeitsgrad);
+        zeigeHighscore(gesamtPunkte);
+
+        printf("\nMöchtest du eine weitere Runde spielen? (1 für Ja, 0 für Nein): ");
+        scanf("%d", &weiterSpielen);
+    }
+
+    printf("Vielen Dank fürs Spielen! Auf Wiedersehen.\n");
+
+    return 0;
+}
+

src/main/c/Mathe.h

@@ -0,0 +1,11 @@
+#ifndef TEST_H
+#define TEST_H
+int berechneErgebnis(int zahl1, int zahl2, char operator);
+int generiereZufallszahl(int minimum, int maximum);
+int multipliziere(int zahl1, int zahl2);
+int dividiere(int zahl1, int zahl2);
+int addiere(int ersteZahl, int zweiteZahl); 
+int subtrahiere(int zahl1, int zahl2);
+int multipliziere(int zahl1, int zahl2);
+char generiereZufallsOperator();
+#endif // MATHEMATIKSPIE

src/main/c/TicTacToe.c

@@ -0,0 +1,177 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ANSI_COLOR_BRIGHT_RED     "\x1b[91m"
+#define ANSI_COLOR_BRIGHT_CYAN    "\x1b[96m"
+#define ANSI_COLOR_BRIGHT_YELLOW  "\x1b[93m"
+#define ANSI_COLOR_RESET   "\x1b[0m"
+
+int Runde = 1;
+// Funktion, um das Spielboard zu initialisieren
+void initializeBoard(char board[3][3]) {
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++) {
+            board[i][j] = '_';
+        }
+    }
+}
+void displayBoard(char board[3][3]) {
+#ifdef _WIN32
+    system("cls");
+#else
+    system("clear");
+#endif
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++) {
+            if (board[i][j] == '_') {
+                printf(ANSI_COLOR_BRIGHT_YELLOW"%c "ANSI_COLOR_RESET, board[i][j]);
+            }
+            else if (board[i][j] == 'X') {
+                printf(ANSI_COLOR_BRIGHT_CYAN"%c "ANSI_COLOR_RESET, board[i][j]);
+            }
+            else {
+                printf(ANSI_COLOR_BRIGHT_RED"%c "ANSI_COLOR_RESET, board[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+int Winner(char board[3][3]) {
+    // Überprüfen Sieg
+    // Überprüfen Reihen
+    for (int i = 0; i < 3; i++) {
+        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != '_') {
+            if (board[i][0] == 'X') {
+                return 1;
+            }
+            else return 2;
+        }
+    }
+    // Überprüfen Spalten
+    for (int j = 0; j < 3; j++) {
+        if (board[0][j] == board[1][j] && board[1][j] == board[2][j] && board[0][j] != '_') {
+            if (board[0][j] == 'X') {
+                return 1;
+            }
+            else return 2;
+        }
+    }
+    // Überprüfen Diagonalen
+    if ((board[0][0] == board[1][1] && board[1][1] == board[2][2]) || (board[0][2] == board[1][1] && board[1][1] == board[2][0])) {
+        if (board[1][1] != '_') {
+            if (board[1][1] == 'X') {
+                return 1;
+            }
+            else return 2;
+        }
+    }
+    //Überprüfe Runde
+    for (int k = 0; k < 3; k++) {
+        for (int l = 0; l < 3; l++) {
+            if (board[k][l] == '_') {
+                return 9;
+            }
+        }
+    }
+    //Bestätige Unendschieden
+    printf("Es ist ein Unendschieden\n");
+    return 0;
+}
+void makeMove(char board[3][3], int row, int column) {
+    if (Runde < 10) {
+        if (Runde % 2 == 0) {
+            if (board[row][column] == '_') {
+                board[row][column] = 'O';
+            }
+            else {
+                printf("Das Feld ist schon besetzt. Gib ein anderes Feld ein:\n");
+                printf("Reihe:");
+                scanf("%d", &row);
+                printf("Spalte:");
+                scanf("%d", &column);
+                row -= 1;
+                column -= 1;
+                makeMove(board, row, column);
+            }
+        }
+        else {
+            if (board[row][column] == '_') {
+                board[row][column] = 'X';
+            }
+            else {
+                printf("Das Feld ist schon besetzt. Gib ein anderes Feld ein:\n");
+                printf("Reihe:");
+                scanf("%d", &row);
+                printf("Spalte:");
+                scanf("%d", &column);
+                row -= 1;
+                column -= 1;
+                makeMove(board, row, column);
+            }
+        }
+    }
+}
+// Hauptfunktion zum Spielen des Tic Tac Toe-Spiels
+int TicTacToe_ausfuehren() {
+    int row;
+    int column;
+    char board[3][3];
+    char Spieler1[50], Spieler2[50];
+    int Punkte1 = 0, Punkte2 = 0;
+    char Name1[50], Name2[50];
+    char Ende[50] = { "Weiter" };
+    printf("Name Spieler 1:");
+    scanf("%s", Name1);  
+    printf("Name Spieler 2:");
+    scanf("%s", Name2);
+    while (Ende[0] == 'W' || Ende[0] == 'w') {
+        Runde = 1;
+        initializeBoard(board);
+        printf("%s, Was willst du sein?\n[X/O]\n", Name1);
+        scanf("%s", Spieler1);
+        if (Spieler1[0] != 'X' && Spieler1[0] != 'O') {
+            printf("Ungültige Auswahl. Das Spiel wird beendet.\n");
+            break;
+        }
+        strcpy(Spieler2, (Spieler1[0] == 'X') ? Name2 : Name1);
+        strcpy(Spieler1, (Spieler1[0] == 'X') ? Name1 : Name2);
+        printf("\nWillkommen %s und %s. Eure Runde Beginnt jetzt.", Spieler1, Spieler2);
+        while (Winner(board) == 9) {
+            displayBoard(board);
+            if (Runde % 2 != 0) {
+                printf("Spieler 1 gebe das Feld an wo du dein X setzen willst.\n");
+            }
+            else printf("Spieler 2 gebe das Feld an wo du dein O setzen willst.\n");
+            printf("Reihe:");
+            scanf("%d", &row);
+            printf("Spalte:");
+            scanf("%d", &column);
+            row -= 1;
+            column -= 1;
+            if (row > 3 || column > 3) {
+                printf("Das ist nicht mehr im Feld. Versuch es nochmal:");
+                scanf("%d %d", &row, &column);
+                row -= 1;   //Für Index eins kleiner
+                column -= 1;
+            }
+            makeMove(board, row, column);
+            Runde++;
+        }
+        displayBoard(board);
+        if (Winner(board) == 1) {
+            printf("Der Sieger ist %s", Spieler1);
+            Punkte1++;
+        }
+        else if (Winner(board) == 2) {
+            printf("Der Sieger ist %s", Spieler2);
+            Punkte2++;
+        }
+        printf("%s - %d, %s - %d\n", Spieler1, Punkte1, Spieler2, Punkte2);
+        printf("Wollt ihr weiter spielen?\n[Weiter]\n[Ende]\n");
+        scanf("%s", Ende);
+    }
+    return 0;
+}

src/main/c/TicTacToe.h

@@ -0,0 +1,11 @@
+#ifndef TICTACTOE_H
+#define TICTACTOE_H
+
+void initializeBoard(char board[3][3]);
+void displayBoard(char board[3][3]);
+int Winner(char board[3][3]);
+void makeMove(char board[3][3], int row, int col);
+int TicTacToe_ausfuehren();
+
+#endif
+

src/main/c/VierGewinnt.c

@@ -0,0 +1,232 @@
+// Author  fdai7726 
+
+/*
+*Ein Vier-Gewinnt-Spiel, das in der Kommandozeile gespielt wird. 
+*Das Programm ermöglicht es zwei Spielern, abwechselnd Steine in eine Spalte zu setzen,
+*um eine Reihe von vier Steinen horizontal,
+*vertikal oder diagonal zu bilden und das Spiel zu gewinnen.
+*Das Spielfeld wird grafisch in der Kommandozeile dargestellt, 
+*und das Programm überprüft automatisch,
+*ob einer der Spieler gewonnen hat oder ob das Spielfeld voll ist.
+ */
+
+
+
+//Importiere wichtige Bibliotheken
+#include <stdio.h>
+#include <stdlib.h>
+
+//Definiere Feldgröße
+#define ROWS 6
+#define COLS 7
+
+// Definiere Farben
+#define RESET_COLOR "\033[0m"
+#define BLACK "\033[0;30m"
+#define RED "\033[0;31m"
+#define GREEN "\033[0;32m"
+#define YELLOW "\033[0;33m"
+#define BLUE "\033[0;34m"
+#define MAGENTA "\033[0;35m"
+#define CYAN "\033[0;36m"
+#define WHITE "\033[0;37m"
+
+//Funktionsprototypen
+void initializeBoard(char board[ROWS][COLS]);
+void printBoard(char board[ROWS][COLS]);
+void clearScreen();
+int isColumnFull(char board[ROWS][COLS], int col);
+int dropPiece(char board[ROWS][COLS], int col, char player);
+int checkWin(char board[ROWS][COLS], char player);
+int checkHorizontal(char board[ROWS][COLS], char player);
+int checkVertical(char board[ROWS][COLS], char player);
+int checkDiagonalRL(char board[ROWS][COLS], char player);
+void showInvalidInputWarning();
+void showColumnFullMessage();
+void showWinMessage(int player);
+
+
+int main_function() {
+    char board[ROWS][COLS];
+    int  Player = 1; 
+
+    initializeBoard(board);
+    printBoard(board);
+
+    int column;
+    while (1) {
+        printf(YELLOW"Spieler %d, wähle eine Spalte (1-7): "RESET_COLOR, Player);
+
+        scanf("%d", &column);
+        if (column < 1 || column > 7) {
+            showInvalidInputWarning();
+            continue;
+        }
+
+        column--;
+
+        if (isColumnFull(board, column)) {
+            showColumnFullMessage();
+            continue;
+        }
+
+        if (dropPiece(board, column, (Player == 1) ? 'X' : 'O')) {
+            printBoard(board);
+            if (checkWin(board, (Player == 1) ? 'X' : 'O')) {
+                showWinMessage(Player);
+                break;
+            }
+
+            Player = (Player == 1) ? 2 : 1;
+        }
+    }
+
+    return 0;
+}
+void initializeBoard(char board[ROWS][COLS]) {
+    for (int i = 0; i < ROWS; i++) {
+        for (int j = 0; j < COLS; j++) {
+            board[i][j] = ' ';
+        }
+    }
+}
+
+
+void printBoard(char board[ROWS][COLS]) {
+    clearScreen();
+    printf("\n");
+
+    for (int i = 0; i < ROWS; i++) {
+        for (int j = 0; j < COLS; j++) {
+            printf("| %c ", board[i][j]);
+        }
+        printf("|\n");
+
+        for (int j = 0; j < COLS; j++) {
+            printf("----");
+        }
+        printf("-\n");
+    }
+
+    printf("  1   2   3   4   5   6   7\n\n");
+}
+void clearScreen() {
+#ifdef _WIN32
+    system("cls");
+#else
+    system("clear");
+#endif
+}
+
+int isColumnFull(char board[ROWS][COLS], int col) {
+    return (board[0][col] != ' ');
+}
+
+int dropPiece(char board[ROWS][COLS], int col, char player) {
+    for (int i = ROWS - 1; i >= 0; i--) {
+        if (board[i][col] == ' ') {
+            board[i][col] = player;
+            return 1;
+        }
+    }
+
+    return 0; 
+}
+
+
+int checkHorizontal(char board[ROWS][COLS], char player) {
+    for (int row = 0; row < ROWS; row++) {
+        for (int col = 0; col <= COLS - 4; col++) {
+            if (board[row][col] == player &&
+                board[row][col + 1] == player &&
+                board[row][col + 2] == player &&
+                board[row][col + 3] == player) {
+                return 1;  
+            }
+        }
+    }
+    return 0;
+}
+
+int checkVertical(char board[ROWS][COLS], char player) {
+    for (int col = 0; col < COLS; col++) {
+        for (int row = 0; row <= ROWS - 4; row++) {
+            if (board[row][col] == player &&
+                board[row + 1][col] == player &&
+                board[row + 2][col] == player &&
+                board[row + 3][col] == player) {
+                return 1;  
+            }
+        }
+    }
+    return 0;
+}
+
+
+
+int checkDiagonalLR(char board[ROWS][COLS], char player) {
+    for (int row = 0; row <= ROWS - 4; row++) {
+        for (int col = 0; col <= COLS - 4; col++) {
+            if (board[row][col] == player &&
+                board[row + 1][col + 1] == player &&
+                board[row + 2][col + 2] == player &&
+                board[row + 3][col + 3] == player) {
+                return 1;  
+            }
+        }
+    }
+    return 0;
+}
+
+
+
+
+int checkDiagonalRL(char board[ROWS][COLS], char player) {
+    for (int row = 0; row <= ROWS - 4; row++) {
+        for (int col = 3; col < COLS; col++) {
+            if (board[row][col] == player &&
+                board[row + 1][col - 1] == player &&
+                board[row + 2][col - 2] == player &&
+                board[row + 3][col - 3] == player) {
+                return 1;  
+            }
+        }
+    }
+    return 0;
+
+}
+
+int checkWin(char board[ROWS][COLS], char player) {
+    return checkHorizontal(board, player) ||
+           checkVertical(board, player) ||
+           checkDiagonalLR(board, player) ||
+           checkDiagonalRL(board, player);
+}
+
+// Die Funktion showMessage gibt eine formatierte Nachricht aus, wobei die Farbe der Nachricht dynamisch festgelegt werden kann.
+void showMessage(const char* messageColor, const char* message) {
+    printf("%s%s"RESET_COLOR, messageColor, message);
+}
+
+//Die Funktion showInvalidInputWarning zeigt eine Warnung für ungültige Benutzereingaben an. Sie ruft die Funktion showMessage auf, um die Nachricht in roter Farbe auszugeben, die den Benutzer darüber informiert, dass die Eingabe ungültig ist und er eine Spalte zwischen 1 und 7 wählen soll.
+
+void showInvalidInputWarning() {
+    showMessage(RED, "Ungültige Eingabe. Bitte wähle eine Spalte zwischen 1 und 7.\n");
+}
+
+
+
+
+void showColumnFullMessage() {
+    showMessage(RED, "Die ausgewählte Spalte ist bereits belegt. Bitte wähle eine andere Spalte aus.\n");
+}
+
+
+
+void showWinMessage(int player) {
+printf("Spieler %d ist der Gewinner!\n", player);
+
+}
+
+
+

src/main/c/VierGewinnt.h

@@ -0,0 +1,20 @@
+#ifndef VIERGEWINNT_H
+#define VIERGEWINNT_H
+
+#define ROWS 6
+#define COLS 7
+
+void initializeBoard(char board[ROWS][COLS]);
+void printBoard(char board[ROWS][COLS]);
+int isColumnFull(char board[ROWS][COLS], int col);
+int dropPiece(char board[ROWS][COLS], int col, char player);
+int checkWin(char board[ROWS][COLS], char player);
+int checkHorizontal(char board[ROWS][COLS], char player);
+int checkVertical(char board[ROWS][COLS], char player);
+int checkDiagonalLR(char board[ROWS][COLS], char player);
+int checkDiagonalRL(char board[ROWS][COLS], char player);
+void showMessage(const char* messageColor, const char* message);
+void showInvalidInputMessage();
+void showColumnFullMessage();
+void showWinMessage(int player);
+#endif

src/main/c/global.h

@@ -0,0 +1,12 @@
+#ifndef GLOBAL_H
+#define GLOBAL_H
+
+typedef enum {
+    N, E, S, W
+} Direction;
+
+typedef enum {
+    WAY, WALL, SOLUTION
+} Field_State;
+
+#endif

src/main/c/hangman.c

@@ -0,0 +1,397 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <unistd.h>
+
+void protokoll();
+void clear_screen();
+void willkommen();
+int namePruefen();
+void nameWaehlen();
+void startauswahl();
+void nameAusgeben();
+void levelauswahl();
+void hauptSpiel(int level);
+void zeichne_galgen(int versuche);
+void erratenen_buchstaben_hinzufuegen(char* guessed_letters, char guessed_letter);
+char eingabe_buchstabe();
+void hole_zu_erratendes_wort(char* secret_word, int level, char* path);
+void zeige_Buchstabenfeld(char secret_word[100], char guessed_letters[100]);
+int buchstabe_im_zu_erratenden_wort(char guessed_letter, char secret_word[100]);
+int gewonnen(char secret_word[100], char guessed_letters[100]);
+void level_plus();
+int overlay();
+
+void protokoll(){
+	clear_screen();
+	willkommen();
+	namePruefen();
+	startauswahl();
+}
+
+void clear_screen() {
+    system("clear");
+	// system("cls"); // fuer Windows
+	// system("clear"); // fuer UNIX/Linux
+}
+
+void willkommen(){
+	char ENTERtxt[] = {"-Druecke ENTER zum starten-\n"};
+	
+	overlay();
+	printf("%s", ENTERtxt);
+	getchar();
+}
+
+int namePruefen() {
+    char KonfDatei[100];
+	int laengeKonfDatei = 0;
+	
+    FILE *fp = NULL;
+    fp = fopen("hangman.txt", "r");
+
+    if (fp == NULL) {
+        printf("Fehler beim Öffnen der Konfigurationsdatei\n");
+        return 1;
+    } else {
+		fscanf(fp, "%s", KonfDatei);								//Inhalt der KonfDatei wird ins Array gelesen
+		
+		while(KonfDatei[laengeKonfDatei] != 0){						//Laenge der KonfDatei wird ermittelt
+			laengeKonfDatei++;
+		}
+		
+		if(laengeKonfDatei > 14){									//mit der Laenge wird geschaut, ob ein Name gespeichert ist oder nicht
+			fclose(fp);
+			return 0;
+		} else {
+			printf("Sieht aus, als haettest du noch keinen Namen :(\n");
+			nameWaehlen();
+			fclose(fp);
+			return 0;
+		}
+	}
+    fclose(fp);
+}
+
+void nameWaehlen(){
+	char name[50];
+
+	FILE *fp = NULL;
+    fp = fopen("hangman.txt", "w");
+	
+	clear_screen(); //
+	overlay();
+    printf("Geben Sie den Namen ein: ");
+    scanf("%s", name);    
+
+    char KonfDatei[100];
+    snprintf(KonfDatei, sizeof(KonfDatei), "name:%s,level:01", name);
+
+	fprintf(fp, "%s", KonfDatei);
+	fclose(fp);
+}
+
+void startauswahl() {	
+	int auswahl;
+	int modus;
+	
+	clear_screen(); //
+	overlay();
+	printf("Willkommen ");
+	nameAusgeben();
+	printf("[1] Spielen\n[2] Namen aendern\n");
+	scanf("%d", &auswahl);
+	
+    if(auswahl == 1){
+		levelauswahl();
+	} else if (auswahl == 2){
+		nameWaehlen();
+	} else {
+		printf("Eingabe ungueltig");
+	}
+}
+
+void nameAusgeben(){
+	char KonfDatei[100];
+	char name[50];
+	int i = 5;
+	int zaehler = 0;
+	int nullterminante;
+	
+	FILE *fp = NULL;
+    fp = fopen("hangman.txt", "r");
+	
+	fscanf(fp, "%s", KonfDatei);
+	while(KonfDatei[i] != ','){
+		zaehler++;
+		i++;
+	}
+	nullterminante = zaehler;
+	while(zaehler != 0){
+		name[--zaehler] = KonfDatei[--i];
+	}
+	
+	i = 0;
+	while(name[i] != 0){
+		i++;
+	}
+	
+	name[nullterminante] = '\0';
+	printf("%s\n", name);
+	
+	fclose(fp);
+}
+
+void levelauswahl(){
+	char levelstr[3];
+	char KonfDatei[100];
+	int level;
+	int i = 0;
+	
+	clear_screen(); //
+	overlay();
+	
+	FILE *fp = NULL;
+    fp = fopen("hangman.txt", "r");
+	
+	fscanf(fp, "%s", KonfDatei);
+	while(KonfDatei[i] != 0){
+		i++;
+	}
+	levelstr[0] = KonfDatei[i-2];
+	levelstr[1] = KonfDatei[i-1];
+	levelstr[2] = '\0';
+	level = atoi(levelstr);
+	hauptSpiel(level);
+	fclose(fp);
+}
+
+void hauptSpiel(int level){
+	char secret_word[100];
+	int versuche = 0;
+	char guessed_letter;
+	char guessed_letters[100];
+	char path[] = "hangman_words.txt";
+	int result;
+	int won = 0;
+	
+	hole_zu_erratendes_wort(secret_word, level, path);
+	
+	while (versuche < 6 && won == 0) {
+		zeichne_galgen(versuche);
+		zeige_Buchstabenfeld(secret_word, guessed_letters);
+		guessed_letter = eingabe_buchstabe();
+		result = buchstabe_im_zu_erratenden_wort(guessed_letter, secret_word);
+		if (result == 0){
+			erratenen_buchstaben_hinzufuegen(guessed_letters, guessed_letter);
+		}
+		else {
+			versuche++;
+		}
+		won = gewonnen(secret_word, guessed_letters);
+	}
+	if (won == 1){
+		level_plus();
+	}
+}
+
+void zeichne_galgen(int versuche) {
+    clear_screen();
+    printf("Galgenmann!\n");
+	printf("v.1.0.2\n\n");
+
+    switch(versuche) {
+        case 0:
+            printf("   _______\n");
+            printf("  |       |\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("__|_________\n\n\n\n");
+            break;
+        case 1:
+            printf("   _______\n");
+            printf("  |       |\n");
+            printf("  |       O\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("__|_________\n\n\n\n");
+            break;
+        case 2:
+            printf("   _______\n");
+            printf("  |       |\n");
+            printf("  |       O\n");
+            printf("  |       |\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("__|_________\n\n\n\n");
+            break;
+        case 3:
+            printf("   _______\n");
+            printf("  |       |\n");
+            printf("  |       O\n");
+            printf("  |      /|\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("__|_________\n\n\n\n");
+            break;
+        case 4:
+            printf("   _______\n");
+            printf("  |       |\n");
+            printf("  |       O\n");
+            printf("  |      /|\\\n");
+            printf("  |\n");
+            printf("  |\n");
+            printf("__|_________\n\n\n\n");
+            break;
+        case 5:
+            printf("   _______\n");
+            printf("  |       |\n");
+            printf("  |       O\n");
+            printf("  |      /|\\\n");
+            printf("  |      /\n");
+            printf("  |\n");
+            printf("__|_________\n\n\n\n");
+            break;
+        case 6:
+            printf("   _______\n");
+            printf("  |       |\n");
+            printf("  |       O\n");
+            printf("  |      /|\\\n");
+            printf("  |      / \\\n");
+            printf("  |\n");
+            printf("__|_________\n\n\n\n");
+            break;
+        default:
+            break;
+    }
+}
+
+void erratenen_buchstaben_hinzufuegen(char* guessed_letters, char guessed_letter){
+	for (int i = 0; i < strlen(guessed_letters); i++){
+		if (guessed_letters[i] == guessed_letter){
+			return;
+		}
+	}
+	guessed_letters[strlen(guessed_letters)] = guessed_letter;
+	guessed_letters[strlen(guessed_letters) + 1] = '\0';
+}
+
+char eingabe_buchstabe(){
+		char guess;
+		scanf(" %c", &guess);
+        guess = tolower(guess);
+		return guess;
+}
+
+void hole_zu_erratendes_wort(char* secret_word, int level, char* path){
+	FILE *file = fopen(path, "r");
+	int count = 0;
+	if ( file != NULL )
+	{
+		char line[100]; /* or other suitable maximum line size */
+		while (fgets(line, sizeof line, file) != NULL) /* read a line */
+		{
+			if (count == level)
+			{
+				strcpy(secret_word, line);
+				secret_word[strlen(secret_word) - 1] = '\0';
+				return;
+			}
+			else
+			{
+				count++;
+			}
+		}
+		fclose(file);
+	}
+}
+
+void zeige_Buchstabenfeld(char secret_word[100], char guessed_letters[100]){
+	printf("Erratene Buchstaben: ");
+	for(int i = 0; i < strlen(secret_word); i++) {
+		if(strchr(guessed_letters, secret_word[i])){
+			printf("%c ", secret_word[i]);
+		}
+		else{
+			printf("_ ");
+		}
+	}
+	printf("\n");
+}
+
+int buchstabe_im_zu_erratenden_wort(char guessed_letter, char secret_word[100]){
+	for(int i = 0; i < strlen(secret_word); i++){
+		if(guessed_letter == secret_word[i]){
+			return 0;
+		}
+	}
+	return 1;
+}
+
+int gewonnen(char secret_word[100], char guessed_letters[100]){
+	int occured;
+	for (int i = 0; i < strlen(secret_word); i++){
+		occured = 0;
+		for (int k = 0; k < strlen(guessed_letters); k++){
+			if (secret_word[i] == guessed_letters[k]){
+				occured = 1;
+			}
+		}
+		if (occured == 0){
+			return 0;
+		}
+	}
+	return 1;
+}
+
+void level_plus(){
+	char KonfDatei[100];
+	char level[3];
+	int i = 0;
+	
+	FILE *fp = NULL;
+    fp = fopen("hangman.txt", "r+");
+	fscanf(fp, "%s", KonfDatei);
+	
+	while(KonfDatei[i] != 0){
+		i++;
+	}
+	level[0] = KonfDatei[i-2];
+	level[1] = KonfDatei[i-1];
+	level[2] = '\0';
+	if (level[1] == '9'){
+		KonfDatei[i-2]++;
+		KonfDatei[i-1] = '0'; 
+	} else {
+		KonfDatei[i-1]++; 
+	}
+	fclose(fp);
+    fp = fopen("hangman.txt", "w");
+	fprintf(fp, "%s", KonfDatei);
+	fclose(fp);
+}
+
+int overlay(){
+	char galgen_overlay[10][41] = {
+        "   _______    ",
+        "  |       |   ",
+        "  |		   ",
+        "  |		   ",
+        "  |		   ",
+        "  |		   ",
+        "__|_________\n"
+    };
+	
+	printf("Galgenmann!\n");
+	printf("v.1.0.2\n\n");
+
+
+	for (int i = 0; i < 9; i++) {
+       printf("%s\n", galgen_overlay[i]);
+   }
+   return 0;
+}

src/main/c/hangman.h

@@ -0,0 +1,23 @@
+#ifndef TEST_H
+#define TEST_H
+
+void protokoll();
+void clear_screen();
+void willkommen();
+int namePruefen();
+void nameWaehlen();
+void startauswahl();
+void nameAusgeben();
+void levelauswahl();
+void hauptSpiel(int level);
+void zeichne_galgen(int versuche);
+void erratenen_buchstaben_hinzufuegen(char* guessed_letters, char guessed_letter);
+char eingabe_buchstabe();
+void hole_zu_erratendes_wort(char* secret_word, int level, char* path);
+void zeige_Buchstabenfeld(char secret_word[100], char guessed_letters[100]);
+int buchstabe_im_zu_erratenden_wort(char guessed_letter, char secret_word[100]);
+int gewonnen(char secret_word[100], char guessed_letters[100]);
+void level_plus();
+int overlay();
+
+#endif // TEST_H

src/main/c/hangman.txt

@@ -0,0 +1 @@
+name:peter,level:02

src/main/c/hangman_words.txt

@@ -0,0 +1,20 @@
+fulda
+galgenmann
+programmiermethoden
+test
+peter
+ahmad
+joe
+celine
+sigi
+jonas
+mitochondrien
+aufmerksamkeitsdefizithyperaktivitaetsstoerung
+donaudampfschifffahrtelekrizitaetenhauptbetriebswerkbauunternehmenbeamtengesellschaft
+malaysia
+lucas
+yasin
+samuel
+celli
+hochschule
+fulda

src/main/c/labyrinth.c

@@ -0,0 +1,188 @@
+#include "labyrinth.h"
+
+#include "global.h"
+
+#include "stdio.h"
+#include "stdlib.h"
+
+void show_solution(Field_State** field, unsigned short len_x, unsigned short len_y){
+    for (int c_x = 0; c_x < len_x; c_x++){
+        for (int c_y = 0; c_y < len_y; c_y++){
+            printf("%hi", field[c_x][c_y]);
+        }
+        printf("\n");
+    }
+}
+
+unsigned short get_natural_number(char text[]){
+    unsigned short result;
+    printf("%s", text);
+    scanf("%hu", &result);
+    return result;
+}
+
+void ask_lab_dimensions(unsigned short *len_x, unsigned short *len_y){
+    *len_x = get_natural_number("Bitte gib die x-Laenge des Labyrinthes an:\n");
+    *len_y = get_natural_number("Bitte gib die y-Laenge des Labyrinthes an:\n");
+}
+
+short get_wall_input(unsigned short *x, unsigned short *y, unsigned short len_x, unsigned short len_y){
+    char answer;
+    printf("Moechten Sie die Koordinaten einer weiteren Labyrinthwand angeben? (y/n)\n");
+    scanf(" %c", &answer);
+
+    if (answer == 'n'){
+        return 1;
+    }
+
+    printf("Bitte geben Sie die Koordinaten von Labyrinthwaenden im Format x, y ein.\n");
+    scanf("%hu, %hu", x, y);
+
+    if (*x >= len_x || *y >= len_y){
+        printf("Die eingegebenen Koordinaten sind zu gross.\n");
+        return -1;
+    }
+
+    return 0;
+}
+
+void turn_direction_right(Direction *direction){
+    switch (*direction) {
+        case N:
+            *direction = E;
+            break;
+        case E:
+            *direction = S;
+            break;
+        case S:
+            *direction = W;
+            break;
+        case W:
+            *direction = N;
+            break;
+    }
+}
+
+void lab_move(unsigned short *x, unsigned short *y, Direction direction){
+
+    if (direction == N){
+        *x = *x - 1;
+        return;
+    }
+    if (direction == E){
+        *y = *y + 1;
+        return;
+    }
+    if (direction == S){
+        *x = *x + 1;
+        return;
+    }
+    if (direction == W){
+        *y = *y - 1;
+        return;
+    }
+
+}
+
+void set_wall(Field_State** field, unsigned short x, unsigned short y) {
+    field[x][y] = WALL;
+}
+
+void init_field(Field_State** field, unsigned short len_x, unsigned short len_y){
+	for (int c_x = 0; c_x < len_x; c_x++){
+		for (int c_y = 0; c_y < len_y; c_y++){
+			field[c_x][c_y] = WAY;
+		}
+	}
+}
+
+short lab_can_move(Field_State** field, unsigned short x, unsigned short y, Direction direction, unsigned short len_x, unsigned short len_y){
+	
+    lab_move(&x, &y, direction);
+    if (x >= len_x){
+        return 1;
+    }
+	if (y >= len_y){
+		return 1;
+	}
+    if (field[x][y] == WALL){
+        return 1;
+    }
+	if (field[x][y] == SOLUTION){
+		return 1;
+	}
+
+    return 0;
+}
+
+void ask_lab_walls(Field_State** field, unsigned short len_x, unsigned short len_y){
+    unsigned short x, y;
+    short wall_input_continue;
+
+    init_field(field, len_x, len_y);
+
+    do {
+        wall_input_continue = get_wall_input(&x, &y, len_x, len_y);
+        if (wall_input_continue == 0){
+            set_wall(field, x, y);
+            show_solution(field, len_x, len_y);
+        }
+    } while (wall_input_continue != 1);
+}
+
+short calculate_lab_way(Field_State** field, unsigned short len_x, unsigned short len_y, unsigned short x, unsigned short y){
+    Direction direction = N;
+
+    unsigned short current_x;
+    unsigned short current_y;
+
+    if (x == len_x-1 && y == len_y-1){
+        field[x][y] = SOLUTION;
+        return 0;
+    }
+
+    do {
+        current_x = x;
+        current_y = y;
+        if (lab_can_move(field, current_x, current_y, direction, len_x, len_y) == 0){
+            lab_move(&current_x, &current_y, direction);
+            printf("%d - %d\n", current_x, current_y);
+            field[current_x][current_y] = SOLUTION;
+            if (calculate_lab_way(field, len_x, len_y, current_x, current_y) == 0){
+                return 0;
+            }
+            field[current_x][current_y] = WAY;
+        }
+        turn_direction_right(&direction);
+    }
+    while (direction != N);
+    return 1;
+}
+
+void start_labyrinth_game(){
+    unsigned short len_x, len_y;
+    Field_State **field;
+
+    ask_lab_dimensions(&len_x, &len_y);
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+
+    ask_lab_walls(field, len_x, len_y);
+
+    if (calculate_lab_way(field, len_x, len_y, 0, 0) == 1){
+        printf("Keine Loesung moeglich!\n");
+    }
+
+    show_solution(field, len_x, len_y);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+
+}
+

src/main/c/labyrinth.h

@@ -0,0 +1,19 @@
+#ifndef TEST_H
+#define TEST_H
+
+#include "global.h"
+
+void turn_direction_right(Direction *direction);
+void lab_move(unsigned short *x, unsigned short *y, Direction direction);
+void set_wall(Field_State** field, unsigned short x, unsigned short y);
+void init_field(Field_State** field, unsigned short len_x, unsigned short len_y);
+short lab_can_move(Field_State** field, unsigned short x, unsigned short y, Direction direction, unsigned short len_x, unsigned short len_y);
+void show_solution(Field_State** field, unsigned short len_x, unsigned short len_y);
+unsigned short get_natural_number(char text[]);
+void ask_lab_dimensions(unsigned short *len_x, unsigned short *len_y);
+short get_wall_input(unsigned short *x, unsigned short *y, unsigned short len_x, unsigned short len_y);
+void ask_lab_walls(Field_State** field, unsigned short len_x, unsigned short len_y);
+short calculate_lab_way(Field_State** field, unsigned short len_x, unsigned short len_y, unsigned short x, unsigned short y);
+void labyrinth();
+
+#endif // TEST_H

src/main/c/sudoku.c

@@ -0,0 +1,623 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include "sudoku.h"
+
+#define SIZE_OF_GAMEBORD_AXIS_X 9
+#define SIZE_OF_GAMEBORD_AXIS_Y 9
+#define AVAILABLE_DIFFICULTIES 3
+#define AVAILABLE_LEVELS 3
+#define EMPTY 0
+#define LEVEL_NUMBER 3
+
+
+int selected_difficulty;
+int selected_level;
+bool check_solved;
+bool test_help = false;
+int test_row_e;
+int test_col_e;
+int test_num;
+
+
+void Game_loop(); //is instead of main
+void Level_Pool(int selected_difficulty);
+void Level_Selection(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void initializeGrid(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void create_playing_field(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y], int selected_difficulty, int level);
+void Player_actions_for_playing(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void giving_hints_to_player(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void write_userinput_into_Sudoku(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void printGrid(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void check_if_Sudoku_solved(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+
+
+
+
+int availableLevels[AVAILABLE_DIFFICULTIES][AVAILABLE_LEVELS][SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = {
+    { //easy
+    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
+     {6, 0, 0, 0, 7, 0, 1, 3, 2},
+     {9, 2, 1, 5, 0, 0, 7, 6, 4},
+     {7, 6, 0, 3, 0, 0, 4, 0, 0},
+     {8, 5, 4, 1, 9, 7, 0, 0, 0},
+     {1, 0, 0, 4, 0, 6, 0, 0, 0},
+     {2, 9, 0, 8, 1, 5, 0, 0, 6},
+     {0, 4, 8, 2, 0, 9, 5, 0, 0},
+     {5, 0, 0, 7, 0, 3, 2, 0, 0}},
+
+    {{7, 0, 2, 0, 0, 0, 9, 5, 0},
+     {0, 8, 0, 7, 5, 0, 2, 1, 6},
+     {0, 0, 5, 5, 2, 8, 7, 0, 3},
+     {5, 1, 8, 4, 3, 0, 6, 0, 0},
+     {0, 0, 6, 1, 0, 0, 5, 3, 0},
+     {0, 0, 0, 0, 6, 2, 0, 8, 1},
+     {0, 9, 0, 2, 0, 4, 0, 0, 5},
+     {0, 2, 0, 0, 9, 5, 0, 7, 4},
+     {0, 5, 1, 0, 0, 0, 0, 9, 2}},
+
+    {{4, 2, 5, 0, 9, 7, 1, 3, 0},
+     {0, 7, 0, 1, 0, 3, 0, 0, 6},
+     {0, 6, 1, 4, 8, 2, 0, 0, 0},
+     {1, 0, 0, 0, 3, 0, 0, 6, 0},
+     {7, 0, 8, 0, 2, 0, 0, 1, 3},
+     {9, 3, 0, 0, 4, 1, 5, 7, 2},
+     {0, 0, 7, 9, 6, 5, 0, 0, 0},
+     {0, 0, 4, 3, 7, 0, 2, 0, 5},
+     {0, 0, 0, 2, 1, 0, 0, 0, 0}}},
+
+    {//medium
+     {{0, 0, 3, 0, 2, 1, 8, 0, 0},
+     {6, 0, 0, 0, 0, 0, 1, 3, 2},
+     {0, 2, 1, 0, 0, 0, 7, 6, 4},
+     {7, 6, 0, 3, 0, 0, 4, 0, 0},
+     {0, 5, 0, 1, 0, 7, 0, 0, 0},
+     {1, 0, 0, 4, 0, 6, 0, 0, 0},
+     {2, 0, 0, 8, 0, 0, 0, 0, 6},
+     {0, 4, 0, 0, 0, 9, 5, 0, 0},
+     {5, 0, 0, 7, 0, 3, 2, 0, 0}},
+
+    {{7, 0, 2, 0, 0, 0, 9, 5, 0},
+     {0, 0, 0, 7, 5, 0, 2, 0, 6},
+     {0, 0, 5, 0, 2, 8, 7, 0, 3},
+     {5, 1, 8, 0, 3, 0, 6, 0, 0},
+     {0, 0, 6, 1, 0, 0, 0, 3, 0},
+     {0, 0, 0, 0, 6, 2, 0, 8, 1},
+     {0, 9, 0, 2, 0, 4, 0, 0, 5},
+     {0, 0, 0, 0, 9, 0, 0, 0, 4},
+     {0, 5, 1, 0, 0, 0, 0, 9, 2}},
+
+    {{4, 2, 5, 0, 9, 7, 1, 3, 0},
+     {0, 0, 0, 1, 0, 3, 0, 0, 6},
+     {0, 6, 0, 4, 0, 2, 0, 0, 0},
+     {1, 0, 0, 0, 3, 0, 0, 6, 0},
+     {7, 0, 8, 0, 2, 0, 0, 1, 3},
+     {0, 3, 0, 0, 0, 1, 0, 7, 2},
+     {0, 0, 7, 9, 6, 0, 0, 0, 0},
+     {0, 0, 4, 3, 7, 0, 2, 0, 5},
+     {0, 0, 0, 2, 1, 0, 0, 0, 0}}
+    },
+
+    {//hard
+    {{0, 0, 3, 0, 2, 0, 8, 0, 0},
+     {6, 0, 0, 0, 0, 0, 0, 3, 0},
+     {9, 2, 1, 5, 0, 0, 7, 6, 4},
+     {0, 0, 0, 3, 0, 0, 0, 0, 0},
+     {0, 5, 4, 1, 0, 7, 0, 0, 0},
+     {1, 0, 0, 0, 0, 0, 0, 0, 0},
+     {2, 0, 0, 0, 1, 5, 0, 0, 6},
+     {0, 4, 0, 2, 0, 0, 0, 0, 0},
+     {5, 0, 0, 0, 0, 3, 2, 0, 0}},
+
+    {{7, 0, 2, 0, 0, 0, 9, 0, 0},
+     {0, 0, 0, 7, 0, 0, 0, 1, 6},
+     {0, 0, 5, 0, 0, 8, 7, 0, 3},
+     {5, 0, 0, 4, 0, 0, 6, 0, 0},
+     {0, 0, 6, 1, 0, 0, 5, 3, 0},
+     {0, 0, 0, 0, 0, 2, 0, 0, 1},
+     {0, 9, 0, 2, 0, 4, 0, 0, 0},
+     {0, 2, 0, 0, 0, 5, 0, 7, 0},
+     {0, 5, 0, 0, 0, 0, 0, 9, 2}},
+
+    {{4, 0, 5, 0, 9, 7, 1, 3, 0},
+     {0, 0, 0, 0, 0, 3, 0, 0, 6},
+     {0, 6, 1, 4, 0, 2, 0, 0, 0},
+     {1, 0, 0, 0, 3, 0, 0, 6, 0},
+     {0, 0, 8, 0, 0, 0, 0, 0, 3},
+     {9, 3, 0, 0, 4, 1, 5, 7, 2},
+     {0, 0, 7, 9, 0, 5, 0, 0, 0},
+     {0, 0, 4, 3, 0, 0, 2, 0, 5},
+     {0, 0, 0, 2, 1, 0, 0, 0, 0}}
+    }
+};
+
+int solutionLevels[AVAILABLE_DIFFICULTIES][AVAILABLE_LEVELS][SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = {
+    
+    { //easy
+    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
+     {6, 8, 5, 9, 7, 4, 1, 3, 2},
+     {9, 2, 1, 5, 3, 8, 7, 6, 4},
+     {7, 6, 9, 3, 5, 2, 4, 8, 1},
+     {8, 5, 4, 1, 9, 7, 6, 2, 3},
+     {1, 3, 2, 4, 8, 6, 9, 7, 5},
+     {2, 9, 7, 8, 1, 5, 3, 4, 6},
+     {3, 4, 8, 2, 6, 9, 5, 1, 7},
+     {5, 1, 6, 7, 4, 3, 2, 9, 8}},
+
+    {{7, 3, 2, 6, 4, 1, 9, 5, 8},
+     {9, 8, 4, 7, 5, 3, 2, 1, 6},
+     {1, 6, 5, 9, 2, 8, 7, 4, 3},
+     {5, 1, 8, 4, 3, 7, 6, 2, 9},
+     {2, 4, 6, 1, 8, 9, 5, 3, 7},
+     {3, 7, 9, 5, 6, 2, 4, 8, 1},
+     {8, 9, 7, 2, 1, 4, 3, 6, 5},
+     {6, 2, 3, 8, 9, 5, 1, 7, 4},
+     {4, 5, 1, 3, 7, 6, 8, 9, 2}},
+
+    {{4, 2, 5, 6, 9, 7, 1, 3, 8},
+     {8, 7, 9, 1, 5, 3, 4, 2, 6},
+     {3, 6, 1, 4, 8, 2, 7, 5, 9},
+     {1, 5, 2, 7, 3, 9, 8, 6, 4},
+     {7, 4, 8, 5, 2, 6, 9, 1, 3},
+     {9, 3, 6, 8, 4, 1, 5, 7, 2},
+     {2, 8, 7, 9, 6, 5, 3, 4, 1},
+     {6, 1, 4, 3, 7, 8, 2, 9, 5},
+     {5, 9, 3, 2, 1, 4, 6, 8, 7}}},
+
+    {//medium
+     {{4, 7, 3, 6, 2, 1, 8, 5, 9},
+     {6, 8, 5, 9, 7, 4, 1, 3, 2},
+     {9, 2, 1, 5, 3, 8, 7, 6, 4},
+     {7, 6, 9, 3, 5, 2, 4, 8, 1},
+     {8, 5, 4, 1, 9, 7, 6, 2, 3},
+     {1, 3, 2, 4, 8, 6, 9, 7, 5},
+     {2, 9, 7, 8, 1, 5, 3, 4, 6},
+     {3, 4, 8, 2, 6, 9, 5, 1, 7},
+     {5, 1, 6, 7, 4, 3, 2, 9, 8}},
+
+    {{7, 3, 2, 6, 4, 1, 9, 5, 8},
+     {9, 8, 4, 7, 5, 3, 2, 1, 6},
+     {1, 6, 5, 9, 2, 8, 7, 4, 3},
+     {5, 1, 8, 4, 3, 7, 6, 2, 9},
+     {2, 4, 6, 1, 8, 9, 5, 3, 7},
+     {3, 7, 9, 5, 6, 2, 4, 8, 1},
+     {8, 9, 7, 2, 1, 4, 3, 6, 5},
+     {6, 2, 3, 8, 9, 5, 1, 7, 4},
+     {4, 5, 1, 3, 7, 6, 8, 9, 2}},
+
+    {{4, 2, 5, 6, 9, 7, 1, 3, 8},
+     {8, 7, 9, 1, 5, 3, 4, 2, 6},
+     {3, 6, 1, 4, 8, 2, 7, 5, 9},
+     {1, 5, 2, 7, 3, 9, 8, 6, 4},
+     {7, 4, 8, 5, 2, 6, 9, 1, 3},
+     {9, 3, 6, 8, 4, 1, 5, 7, 2},
+     {2, 8, 7, 9, 6, 5, 3, 4, 1},
+     {6, 1, 4, 3, 7, 8, 2, 9, 5},
+     {5, 9, 3, 2, 1, 4, 6, 8, 7}}
+    },
+
+    {//hard
+    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
+     {6, 8, 5, 9, 7, 4, 1, 3, 2},
+     {9, 2, 1, 5, 3, 8, 7, 6, 4},
+     {7, 6, 9, 3, 5, 2, 4, 8, 1},
+     {8, 5, 4, 1, 9, 7, 6, 2, 3},
+     {1, 3, 2, 4, 8, 6, 9, 7, 5},
+     {2, 9, 7, 8, 1, 5, 3, 4, 6},
+     {3, 4, 8, 2, 6, 9, 5, 1, 7},
+     {5, 1, 6, 7, 4, 3, 2, 9, 8}},
+
+    {{7, 3, 2, 6, 4, 1, 9, 5, 8},
+     {9, 8, 4, 7, 5, 3, 2, 1, 6},
+     {1, 6, 5, 9, 2, 8, 7, 4, 3},
+     {5, 1, 8, 4, 3, 7, 6, 2, 9},
+     {2, 4, 6, 1, 8, 9, 5, 3, 7},
+     {3, 7, 9, 5, 6, 2, 4, 8, 1},
+     {8, 9, 7, 2, 1, 4, 3, 6, 5},
+     {6, 2, 3, 8, 9, 5, 1, 7, 4},
+     {4, 5, 1, 3, 7, 6, 8, 9, 2}},
+
+    {{4, 2, 5, 6, 9, 7, 1, 3, 8},
+     {8, 7, 9, 1, 5, 3, 4, 2, 6},
+     {3, 6, 1, 4, 8, 2, 7, 5, 9},
+     {1, 5, 2, 7, 3, 9, 8, 6, 4},
+     {7, 4, 8, 5, 2, 6, 9, 1, 3},
+     {9, 3, 6, 8, 4, 1, 5, 7, 2},
+     {2, 8, 7, 9, 6, 5, 3, 4, 1},
+     {6, 1, 4, 3, 7, 8, 2, 9, 5},
+     {5, 9, 3, 2, 1, 4, 6, 8, 7}}
+    }
+};
+
+
+void Game_loop() {
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y];
+    selected_level = 0;
+
+    while (1) {
+        printf("\nDifficulty Function - Choose difficulty:\n");
+        printf("1. Easy\n2. Medium\n3. Hard\n");
+        printf("Enter the corresponding number or type 'quit' to exit: ");
+
+        if(!test_help){
+        char input[10];
+        scanf("%s", input);
+
+        if (strcmp(input, "quit") == 0) {
+            break;
+        }
+
+        selected_difficulty = input[0] - '0'; // Convert the first character to an integer
+        
+
+        if ((selected_difficulty >= 1 && selected_difficulty <= 3) && input[1] == '\0') {
+            Level_Pool(selected_difficulty);
+            Level_Selection(Sudoku_grid);
+            Player_actions_for_playing(Sudoku_grid);
+        } else {
+            printf("Invalid input. Please enter a number between 1 and 3.\n");
+        }
+        }
+        if(test_help){
+            Level_Pool(selected_difficulty);
+            break;
+        }
+    }
+}
+
+void Level_Pool(int selected_difficulty) {
+    printf("\nAvailable Levels for Difficulty %d:\n", selected_difficulty);
+    for (int i = 0; i < LEVEL_NUMBER; i++) {
+        printf("%d. Level %d\n", i + 1, i + 1);
+    }
+}
+
+
+
+void Level_Selection(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]) {
+    int level = 0;
+    printf("\nSelect a level:\n");
+    while (true){
+        if(!test_help){
+        char level_select[10];
+        scanf("%s", level_select);
+
+
+        level = level_select[0] - '0'; // Convert the first character to an integer
+
+        if ((level >= 1 && level <= 3) && level_select[1] == '\0') {
+            selected_level = level;
+
+            level--; // Adjust to 0-based index
+            
+            create_playing_field(Sudoku_grid, selected_difficulty, selected_level);
+            break;
+        } else {
+            printf("Invalid input. Please enter a number between 1 and 3.\n");
+            
+        }
+        }
+        if(test_help){
+            selected_level = level;
+            level--;
+            create_playing_field(Sudoku_grid, selected_difficulty, selected_level);
+            break;
+        }
+    }
+    
+    
+}
+
+void initializeGrid(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]) {
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; i++) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; j++) {
+            Sudoku_grid[i][j] = EMPTY;
+        }
+    }
+}
+
+void create_playing_field(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y], int selected_difficulty, int level) {
+    initializeGrid(Sudoku_grid);
+    if(!test_help){
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; i++) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; j++) {
+            Sudoku_grid[i][j] = availableLevels[selected_difficulty - 1][level - 1][i][j];
+        }
+    }
+    }
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; i++) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; j++) {
+            printf("%d", Sudoku_grid[i][j]);
+        }
+        printf("\n");
+    }
+   
+    
+}
+
+void Player_actions_for_playing(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]) {
+    while (1) {
+        printf("\nTurn function - Choose an action:\n");
+        printf("1. Hints\n");
+        printf("2. Insert Number into Game\n");
+        printf("3. Print Sudoku grid\n");
+        printf("4. Check if your Solution is correct\n");
+        printf("5. Select level\n");
+        printf("6. Quit\n");
+
+        
+        int action;
+        if(test_help){
+            printGrid(Sudoku_grid);
+            check_if_Sudoku_solved(Sudoku_grid);
+            break;
+        }
+        if(!test_help){
+        while (true){
+            char action_str[10];
+            scanf("%s", action_str);
+
+            action = action_str[0] - '0'; // Convert the first character to an integer
+
+            if ((action >= 1 && action <= 6) && action_str[1] == '\0') {
+                break;
+            } else {
+                printf("Invalid input. Please enter a number between 1 and 6.\n");
+            }
+        }
+        
+        switch (action) {
+            case 1:
+                giving_hints_to_player(Sudoku_grid);
+                break;
+            case 2:
+                write_userinput_into_Sudoku(Sudoku_grid);
+                break;
+            case 3:
+                printGrid(Sudoku_grid);
+                break;
+            case 4:
+                check_if_Sudoku_solved(Sudoku_grid);
+                break;
+            case 5:
+                Level_Selection(Sudoku_grid);
+                break;
+            case 6:
+                printf("Exiting Sudoku program.\n");
+                exit(0);
+            default:
+                printf("Invalid input. Please enter a number between 1 and 6.\n");
+        }
+        }
+    }
+}
+
+
+
+void giving_hints_to_player(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]) {
+    printf("\nTip function - Choose an option:\n");
+    printf("1. Set the user-specified cell to the right value\n");
+    printf("2. Set the user-specified 3x3 field to the right values\n");
+    printf("3. Solve the entire puzzle for the current level\n");
+    
+    if(test_help){
+        initializeGrid(Sudoku_grid);
+        for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; i++) {
+                for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; j++) {
+                    Sudoku_grid[i][j] = solutionLevels[selected_difficulty - 1][selected_level - 1][i][j];
+                }
+            }
+            printf("Puzzle solved. \n");
+            
+    }
+    int option = 0;
+    if(!test_help){
+    while (true){
+    char tip_str[10];
+        scanf("%s", tip_str);
+
+
+        option = tip_str[0] - '0'; // Convert the first character to an integer
+
+        if ((option >= 1 && option <= 3) && tip_str[1] == '\0') {
+            break;
+        } else {
+            printf("Invalid input. Please enter a number between 1 and 3.\n");
+        }
+    }
+    
+    switch (option) {
+        case 1:
+             printf("Enter the coordinates (row and column) separated by space:\n");
+            int row, col;
+
+            while (true){
+            char row_str[10];
+            char col_str[10];
+            scanf("%s %s", row_str, col_str);
+
+
+            row = row_str[0] - '0'; // Convert the first character to an integer
+            col = col_str[0] - '0'; // Convert the first character to an integer
+
+            if (((row >= 1 && row <= 9) && row_str[1] == '\0') && ((col >= 1 && col <= 9) && col_str[1] == '\0')) {
+                break;
+            } else {
+                printf("Invalid input. Please enter a number between 1 and 9.\n");
+            }
+        }
+            Sudoku_grid[row - 1][col - 1] = solutionLevels[selected_difficulty - 1][selected_level - 1][row - 1][col - 1];
+            printf("Value set successfully.\n");
+            break;
+
+        case 2:
+            printf("Enter the coordinates (top-left cell of the 3x3 field) separated by space:\n");
+            int startRow, startCol;
+
+            while (true){
+            char row_squ[10];
+            char col_squ[10];
+            scanf("%s %s", row_squ, col_squ);
+
+
+            startRow = row_squ[0] - '0'; // Convert the first character to an integer
+            startCol = col_squ[0] - '0'; // Convert the first character to an integer
+
+            if (((startRow >= 1 && startRow <= 9) && row_squ[1] == '\0') && ((startCol >= 1 && startCol <= 9) && col_squ[1] == '\0')) {
+                break;
+            } else {
+                printf("Invalid input. Please enter a number between 1 and 9.\n");
+            }
+        }
+            for (int i = 0; i < 3; i++) {
+                for (int j = 0; j < 3; j++) {
+                    Sudoku_grid[startRow - 1 + i][startCol - 1 + j] =
+                        solutionLevels[selected_difficulty - 1][selected_level - 1][startRow - 1 + i][startCol - 1 + j];
+                }
+            }
+            printf("3x3 field set successfully.\n");
+            break;
+
+        case 3:
+            for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; i++) {
+                for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; j++) {
+                    Sudoku_grid[i][j] = solutionLevels[selected_difficulty - 1][selected_level - 1][i][j];
+                }
+            }
+            printf("Puzzle solved. \n");
+            break;
+        default:
+            printf("Invalid option. Please enter a number between 1 and 3.\n");
+    }
+    }
+}
+
+void write_userinput_into_Sudoku(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]) {
+    printf("\nInput function - Choose an action:\n");
+    printf("1. Insert value in an empty field\n");
+    printf("2. Clear an already filled field\n");
+    
+    if(test_help){
+        initializeGrid(Sudoku_grid);
+        Sudoku_grid[test_row_e -1][test_col_e -1] = test_num;
+        printGrid(Sudoku_grid);
+    }
+
+    int action;
+    if(!test_help){
+    while (true){
+            char in_str[10];
+            scanf("%s", in_str);
+
+            action = in_str[0] - '0'; // Convert the first character to an integer
+
+            if ((action >= 1 && action <= 2) && in_str[1] == '\0') {
+                break;
+            } else {
+                printf("Invalid input. Please enter a number between 1 and 2.\n");
+            }
+        }
+
+        switch (action) {
+            case 1:
+                printf("Enter the coordinates (row and column) separated by space:\n");
+                int row_e, col_e, num;
+
+
+                while (true){
+                char rowe_str[10];
+                char cole_str[10];
+                scanf("%s %s", rowe_str, cole_str);
+
+                row_e = rowe_str[0] - '0'; // Convert the first character to an integer
+                col_e = cole_str[0] - '0'; // Convert the first character to an integer
+
+                if (((row_e >= 1 && row_e <= 9) && rowe_str[1] == '\0') && ((col_e >= 1 && col_e <= 9) && cole_str[1] == '\0')) {
+                    break;
+                } else {
+                    printf("Invalid input. Please enter a number between 1 and 9.\n");
+                }
+            }
+                printf("Enter the value to insert (1-9):\n");
+
+
+            
+
+                while (true){
+                char nume_str[10];
+                scanf("%s", nume_str);
+
+                num = nume_str[0] - '0'; // Convert the first character to an integer
+
+                if ((num >= 1 && num <= 9) && nume_str[1] == '\0') {
+                    Sudoku_grid[row_e - 1][col_e - 1] = num;
+                    printf("Value inserted successfully.\n");
+                    break;
+                } else {
+                    printf("Invalid input. Please enter a number between 1 and 9.\n");
+                }
+            }
+                break;
+            
+            case 2:
+                printf("Enter the coordinates (row and column) separated by space:\n");
+                int row_d, col_d;
+
+
+            while (true){
+                char rowd_str[10];
+                char cold_str[10];
+                scanf("%s %s", rowd_str, cold_str);
+
+                row_d = rowd_str[0] - '0'; // Convert the first character to an integer
+                col_d = cold_str[0] - '0'; // Convert the first character to an integer
+
+                if (((row_d >= 1 && row_d <= 9) && rowd_str[1] == '\0') && ((col_d >= 1 && col_d <= 9) && cold_str[1] == '\0')) {
+                    Sudoku_grid[row_d - 1][col_d - 1] = 0;
+                    printf("Cell cleared successfully.\n");
+                    break;
+                } else {
+                    printf("Invalid input. Please enter a number between 1 and 9.\n");
+                }
+            }
+                break;
+            default:
+                printf("Invalid input. Please enter 1 or 2.\n");
+        }
+        printGrid(Sudoku_grid);
+    }
+}
+
+
+void printGrid(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]) {
+    printf("\nSudoku Grid:\n");
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; i++) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; j++) {
+            printf("%d ", Sudoku_grid[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+void check_if_Sudoku_solved(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]) {
+    printf("\nDone function - Checking if the solution is correct...\n");
+
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; i++) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; j++) {
+            if (Sudoku_grid[i][j] != solutionLevels[selected_difficulty - 1][selected_level  - 1][i][j]) {
+                printf("Incorrect solution. Keep trying!\n");
+                check_solved = false;
+                return;
+            }
+        }
+    }
+    check_solved = true;
+    printf("Congratulations! Sudoku is solved correctly.\n");
+}
+
+
+int mainn(){
+    Game_loop();
+    return 0;
+}

src/main/c/sudoku.h

@@ -0,0 +1,41 @@
+#ifndef SUDOKU_H
+#define SUDOKU_H
+
+#include <stdbool.h>
+//constants
+#define SIZE_OF_GAMEBORD_AXIS_X 9
+#define SIZE_OF_GAMEBORD_AXIS_Y 9
+#define AVAILABLE_DIFFICULTIES 3
+#define AVAILABLE_LEVELS 3
+#define EMPTY 0
+#define LEVEL_NUMBER 3
+
+
+extern int selected_difficulty;
+extern int selected_level;
+extern int solutionLevels[AVAILABLE_DIFFICULTIES][AVAILABLE_LEVELS][SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y];
+extern int availableLevels[AVAILABLE_DIFFICULTIES][AVAILABLE_LEVELS][SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y];
+extern bool check_solved;
+extern bool test_help;
+extern int test_row_e;
+extern int test_col_e;
+extern int test_num;
+
+
+
+//functions
+void Game_loop(); //is instead of main
+void Level_Pool(int selected_difficulty);
+void Level_Selection(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void initializeGrid(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void create_playing_field(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y], int selected_difficulty, int level);
+void Player_actions_for_playing(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void giving_hints_to_player(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void write_userinput_into_Sudoku(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void printGrid(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+void check_if_Sudoku_solved(int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y]);
+int mainn();
+
+
+
+#endif // SUDOKU_H

src/main/c/test.c

@@ -1,6 +0,0 @@
-#include "test.h"
-
-int return_5(){
-    return 5;
-}
-

src/main/c/test.h

@@ -1,6 +0,0 @@
-#ifndef TEST_H
-#define TEST_H
-
-int return_5();
-
-#endif // TEST_H

src/test/c/test_Mathe.c

@@ -0,0 +1,130 @@
+#ifdef TEST
+#include "unity.h"
+#include "Mathe.h"
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_Mathe_plus(void)
+{
+   
+  int a=berechneErgebnis(1,2,'+');
+    /* assert */
+	TEST_ASSERT_EQUAL_INT(a,3);
+}
+
+
+void test_Mathe_minus(void)
+{
+   
+  int a=berechneErgebnis(1,2,'-');
+    /* assert */
+	TEST_ASSERT_EQUAL_INT(a,-1);
+}
+
+
+void test_Mathe_multi(void)
+{
+
+  int a=berechneErgebnis(1,2,'*');
+    /* assert */
+	TEST_ASSERT_EQUAL_INT(a,2);
+}
+
+
+
+void test_Mathe_divided(void)
+{
+
+  int a=berechneErgebnis(2,2,'/');
+    /* assert */
+	TEST_ASSERT_EQUAL_INT(a,1);
+}
+
+
+
+void test_Zufallszahl(void)
+{
+
+  int a= generiereZufallszahl(1, 10);
+
+    /* assert */
+TEST_ASSERT_INT_WITHIN (10, 1, a);
+
+}
+
+
+void testGeneriereZufallsOperator() {
+    // Since the function always returns one of {'+', '-', '*', '/'}, no specific range check is needed.
+    char result = generiereZufallsOperator();
+    TEST_ASSERT_TRUE(result == '+' || result == '-' || result == '*' || result == '/');
+}
+
+
+
+void test_multi()
+{
+
+
+int a=multipliziere(4, 3);
+    /* assert */
+        TEST_ASSERT_EQUAL_INT(a,12);
+
+
+
+}
+
+
+
+
+void test_dev()
+{
+
+int a=dividiere(10, 5);
+    /* assert */
+        TEST_ASSERT_EQUAL_INT(a,2);
+
+
+
+
+}
+
+
+
+
+
+void test_plus()
+{
+
+int a=addiere(10, 5);
+    /* assert */
+        TEST_ASSERT_EQUAL_INT(a,15);
+
+
+
+
+}
+
+
+
+void test_minus()
+{
+
+int a=subtrahiere(10, 5);
+    /* assert */
+        TEST_ASSERT_EQUAL_INT(a,5);
+
+
+
+
+}
+
+
+
+
+
+#endif

src/test/c/test_TicTacToe.c

@@ -0,0 +1,173 @@
+
+#include "unity.h"
+
+#include "TicTacToe.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_TicTacToe_Winner_X_line_1(void)
+{
+    /* arrange */
+        int expected = 1;
+        int actual;
+    char board[3][3] = {
+        {'X', 'X', 'X'},
+        {'O', 'O', '_'},
+        {'O', '_', '_'}
+    };
+    /* act */
+        actual = Winner(board);
+    
+    /* assert */
+        TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Winner_O_line_2(void)
+{
+    /* arrange */
+    int expected = 2;
+    int actual;
+    char board[3][3] = {
+        {'X', 'O', 'X'},
+        {'O', 'O', 'O'},
+        {'O', 'X', 'X'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Winner_X_line_3(void)
+{
+    /* arrange */
+    int expected = 1;
+    int actual;
+    char board[3][3] = {
+        {'O', '_', '_'},
+        {'O', 'O', '_'},
+        {'X', 'X', 'X'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Winner_O_col_1(void)
+{
+    /* arrange */
+        int expected = 2;
+        int actual;
+        char board[3][3] = {
+            {'O', 'X', 'X'},
+            {'O', 'O', '_'},
+            {'O', '_', '_'}
+        };
+    /* act */
+        actual = Winner(board);
+
+    /* assert */
+        TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Winner_X_col_2(void)
+{
+    /* arrange */
+    int expected = 1;
+    int actual;
+    char board[3][3] = {
+        {'O', 'X', 'X'},
+        {'_', 'X', 'O'},
+        {'O', 'X', '_'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Winner_O_col_3(void)
+{
+    /* arrange */
+    int expected = 2;
+    int actual;
+    char board[3][3] = {
+        {'X', 'X', 'O'},
+        {'_', 'O', 'O'},
+        {'_', '_', 'O'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Winner_X_diagonal_1(void)
+{
+    /* arrange */
+    int expected = 1;
+    int actual;
+    char board[3][3] = {
+        {'X', 'O', 'X'},
+        {'O', 'X', 'O'},
+        {'O', '_', 'X'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Winner_O_diagonal_2(void)
+{
+    /* arrange */
+    int expected = 2;
+    int actual;
+    char board[3][3] = {
+        {'O', 'X', 'O'},
+        {'X', 'O', 'X'},
+        {'O', '_', '_'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_mid_Round(void)
+{
+    /* arrange */
+    int expected = 9;
+    int actual;
+    char board[3][3] = {
+        {'X', 'X', 'O'},
+        {'_', 'O', 'X'},
+        {'_', '_', 'O'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+void test_TicTacToe_Tie(void)
+{
+    /* arrange */
+    int expected = 0;
+    int actual;
+    char board[3][3] = {
+        {'X', 'X', 'O'},
+        {'O', 'O', 'X'},
+        {'X', 'X', 'O'}
+    };
+    /* act */
+    actual = Winner(board);
+
+    /* assert */
+    TEST_ASSERT_EQUAL_INT(expected, actual);
+}

src/test/c/test_VierGewinnt.c

@@ -0,0 +1,151 @@
+#include "unity.h"
+#include "VierGewinnt.h"  
+
+void setUp(void) {
+}
+
+void tearDown(void) {
+}
+
+
+void test_dropPiece_ValidMove(void) {
+    char board[6][7];
+    initializeBoard(board);
+
+    TEST_ASSERT_EQUAL_INT(1, dropPiece(board, 3, 'X')); 
+}
+
+
+void test_dropPiece_FullColumn(void) {
+    char board[6][7] = {
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'},
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'},
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'}
+    };
+
+    TEST_ASSERT_EQUAL_INT(0, dropPiece(board, 3, 'X'));  // Spalte ist voll, sollte 0 zurückgeben
+}
+
+
+void test_checkWin_Horizontal_X(void) {
+    char board[6][7] = {
+        {'X', 'X', ' ', ' ', ' ', ' ', ' '},
+        {'O', 'O', 'O', ' ', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '},
+        {' ', 'X', 'X', 'X', 'X', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '}
+    };
+
+    TEST_ASSERT_EQUAL_INT(1, checkWin(board, 'X'));  // Horizontale Gewinnsituation für 'X'
+}
+
+void test_checkWin_Horizontal_O(void) {
+    char board[6][7] = {
+        {'X', 'X', ' ', ' ', ' ', ' ', ' '},
+        {'O', 'O', 'O', 'O', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '},
+        {' ', 'X', 'X', ' ', 'X', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '}
+    };
+
+    TEST_ASSERT_EQUAL_INT(1, checkWin(board, 'O'));  // Horizontale Gewinnsituation für 'X'
+}
+
+void test_checkWin_Diagonal_X(void) {
+    char board[6][7] = {
+        {'X', 'X', ' ', ' ', ' ', ' ', ' '},
+        {'O', 'O', 'O', 'X', ' ', ' ', ' '},
+        {' ', 'X', ' ', ' ', ' ', ' ', ' '},
+        {' ', 'X', 'X', 'X', 'X', ' ', ' '},
+        {' ', ' ', ' ','X', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', 'X', ' '}
+    };
+
+    TEST_ASSERT_EQUAL_INT(1, checkWin(board, 'X'));  // Horizontale Gewinnsituation für 'X'
+}
+
+
+
+
+
+void test_checkWin_Diagonal_O(void) {
+    char board[6][7] = {
+        {'X', 'X', ' ', ' ', ' ', ' ', ' '},
+        {'O', 'O', 'O', 'X', ' ', ' ', ' '},
+        {' ', 'O', ' ', ' ', ' ', ' ', ' '},
+        {' ', 'X', 'O', 'X', 'X', ' ', ' '},
+        {' ', ' ', ' ','O', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', 'X', ' '}
+    };
+
+    TEST_ASSERT_EQUAL_INT(1, checkWin(board, 'O'));  // Horizontale Gewinnsituation für 'X'
+}
+
+
+
+
+
+
+
+void test_checkWin_Vertical_X(void) {
+    char board[6][7] = {
+        {'X', 'O', ' ', ' ', ' ', ' ', ' '},
+        {'X', 'O', ' ', ' ', ' ', ' ', ' '},
+        {'X', 'O', ' ', ' ', ' ', ' ', ' '},
+        {'X', ' ', ' ', ' ', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '}
+    };
+
+    TEST_ASSERT_EQUAL_INT(1, checkWin(board, 'X'));  // Vertikale Gewinnsituation für 'X'
+}
+
+
+
+void test_checkWin_Vertical_O(void) {
+    char board[6][7] = {
+        {'X', 'O', ' ', ' ', ' ', ' ', ' '},
+        {'X', 'O', ' ', ' ', ' ', ' ', ' '},
+        {'X', 'O', ' ', ' ', ' ', ' ', ' '},
+        {' ', 'O', ' ', ' ', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '},
+        {' ', ' ', ' ', ' ', ' ', ' ', ' '}
+    };
+
+    TEST_ASSERT_EQUAL_INT(1, checkWin(board, 'O'));  // Vertikale Gewinnsituation für 'X'
+}
+void test_checkWin_NoWinner(void) {
+char board[6][7] = {
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'},
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'}
+    };
+
+
+
+
+    TEST_ASSERT_EQUAL_INT(0, checkWin(board, 'X'));  // Kein Gewinner, horizontale Reihe ist voll
+    TEST_ASSERT_EQUAL_INT(0, checkWin(board, 'O'));  // Kein Gewinner, horizontale Reihe ist voll
+}
+
+void test_isColumnFull(void) {
+    char board[6][7] = {
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'},
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'},
+        {'X', 'O', 'X', 'O', 'X', 'O', 'X'},
+        {'O', 'X', 'O', 'X', 'O', 'X', 'O'}
+    };
+
+    TEST_ASSERT_EQUAL_INT(1, isColumnFull(board, 3));  // Column 3 is full
+}
+

src/test/c/test_hangman_test.c

@@ -0,0 +1,147 @@
+#ifdef TEST
+
+#include "unity.h"
+#include "hangman.h"
+
+void setUp(void) {}
+
+void tearDown(void) {}
+
+void test_buchstabe_im_zu_erratenden_wort_eingabe_j_in_leerstring_falsch() {
+    // arrange
+	int expected = 1;
+    int actual;
+	char guessed_letter = 'j';
+	char secret_word[100] = "";
+	
+    // act
+	actual = buchstabe_im_zu_erratenden_wort(guessed_letter, secret_word);
+	
+    // assert
+	TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+
+void test_buchstabe_im_zu_erratenden_wort_eingabe_j_in_joe_richtig() {
+    // arrange
+	int expected = 0;
+    int actual;
+	char guessed_letter = 'j';
+	char secret_word[100] = "joe";
+	
+    // act
+	actual = buchstabe_im_zu_erratenden_wort(guessed_letter, secret_word);
+
+    // assert
+	TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+
+void test_buchstabe_im_zu_erratenden_wort_eingabe_k_in_joe_falsch() {
+    // arrange
+	int expected = 1;
+    int actual;
+	char guessed_letter = 'k';
+	char secret_word[100] = "joe";
+	
+    // act
+	actual = buchstabe_im_zu_erratenden_wort(guessed_letter, secret_word);
+
+    // assert
+	TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+
+void test_buchstabe_im_zu_erratenden_wort_eingabe_j_in_eoj_richtig() {
+    // arrange
+	int expected = 0;
+    int actual;
+	char guessed_letter = 'j';
+	char secret_word[100] = "eoj";
+	
+    // act
+	actual = buchstabe_im_zu_erratenden_wort(guessed_letter, secret_word);
+
+    // assert
+	TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+
+void test_erratenen_buchstaben_hinzufuegen_anhaengen_r_an_leerstring_zu_peter_richtig() {
+    // arrange
+	char expected[100] = "r";
+    char actual[100] = "";
+	char to_add = 'r';
+	
+    // act
+	erratenen_buchstaben_hinzufuegen(actual, to_add);
+
+    // assert
+	TEST_ASSERT_EQUAL_STRING(expected, actual);
+}
+
+void test_erratenen_buchstaben_hinzufuegen_anhaengen_r_an_pete_zu_peter_richtig() {
+    // arrange
+	char expected[100] = "peter";
+    char actual[100] = "pete";
+	char to_add = 'r';
+	
+    // act
+	erratenen_buchstaben_hinzufuegen(actual, to_add);
+
+    // assert
+	TEST_ASSERT_EQUAL_STRING(expected, actual);
+}
+
+void test_erratenen_buchstaben_hinzufuegen_anhaengen_r_an_peter_zu_peter_falsch() {
+    // arrange
+	char expected[100] = "peter";
+    char actual[100] = "peter";
+	char to_add = 'r';
+	
+    // act
+	erratenen_buchstaben_hinzufuegen(actual, to_add);
+
+    // assert
+	TEST_ASSERT_FALSE(expected == actual);
+}
+
+void test_gewonnen_petr_in_peter_richtig() {
+    // arrange
+	int expected = 1;
+    char actual;
+	char secret_word[100] = "peter";
+	char guessed_letters[100] = "petr";
+	
+    // act
+	actual = gewonnen(secret_word, guessed_letters);
+	
+    // assert
+	TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+
+void test_gewonnen_p_in_peter_falsch() {
+    // arrange
+	int expected = 0;
+    char actual;
+	char secret_word[100] = "peter";
+	char guessed_letters[100] = "p";
+	
+    // act
+	actual = gewonnen(secret_word, guessed_letters);
+	
+    // assert
+	TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+
+void test_gewonnen_petr_in_leerstring_richtig() {
+    // arrange
+	int expected = 1;
+    char actual;
+	char secret_word[100] = "";
+	char guessed_letters[100] = "petr";
+	
+    // act
+	actual = gewonnen(secret_word, guessed_letters);
+	
+    // assert
+	TEST_ASSERT_EQUAL_INT(expected, actual);
+}
+
+#endif // TEST

src/test/c/test_labyrinth.c

@@ -0,0 +1,737 @@
+#include "unity.h"
+
+#include "stdlib.h"
+
+#include "labyrinth.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_change_direction_from_N_expected_E(void)
+{
+    /* arrange */
+    Direction actual = N;
+    Direction expected = E;
+
+    /* act */
+    turn_direction_right(&actual);
+
+    /* assert */
+	TEST_ASSERT_TRUE(expected == actual);
+}
+
+void test_turn_direction_right_from_E_expected_S(void)
+{
+    /* arrange */
+    Direction actual = E;
+    Direction expected = S;
+
+    /* act */
+    turn_direction_right(&actual);
+
+    /* assert */
+	TEST_ASSERT_TRUE(expected == actual);
+}
+
+void test_turn_direction_right_from_S_expected_W(void)
+{
+    /* arrange */
+    Direction actual = S;
+    Direction expected = W;
+
+    /* act */
+    turn_direction_right(&actual);
+
+    /* assert */
+	TEST_ASSERT_TRUE(expected == actual);
+}
+
+void test_turn_direction_right_from_W_expected_N(void)
+{
+    /* arrange */
+    Direction actual = W;
+    Direction expected = N;
+
+    /* act */
+    turn_direction_right(&actual);
+
+    /* assert */
+	TEST_ASSERT_TRUE(expected == actual);
+}
+
+void test_lab_move_from_1_1_N_expected_0_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+    Direction direction = N;
+	
+	unsigned short x_expected = 0;
+	unsigned short y_expected = 1;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_lab_move_from_5_5_N_expected_4_5(void)
+{
+    /* arrange */
+	unsigned short x = 5;
+	unsigned short y = 5;
+    Direction direction = N;
+	
+	unsigned short x_expected = 4;
+	unsigned short y_expected = 5;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_lab_move_from_1_1_E_expected_1_2(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+    Direction direction = E;
+	
+	unsigned short x_expected = 1;
+	unsigned short y_expected = 2;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_lab_move_from_5_5_E_expected_5_6(void)
+{
+    /* arrange */
+	unsigned short x = 5;
+	unsigned short y = 5;
+    Direction direction = E;
+	
+	unsigned short x_expected = 5;
+	unsigned short y_expected = 6;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_lab_move_from_1_1_S_expected_2_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+    Direction direction = S;
+	
+	unsigned short x_expected = 2;
+	unsigned short y_expected = 1;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_lab_move_from_5_5_S_expected_6_5(void)
+{
+    /* arrange */
+	unsigned short x = 5;
+	unsigned short y = 5;
+    Direction direction = S;
+	
+	unsigned short x_expected = 6;
+	unsigned short y_expected = 5;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_lab_move_from_1_1_W_expected_1_0(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+    Direction direction = W;
+	
+	unsigned short x_expected = 1;
+	unsigned short y_expected = 0;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_lab_move_from_5_5_W_expected_5_4(void)
+{
+    /* arrange */
+	unsigned short x = 5;
+	unsigned short y = 5;
+    Direction direction = W;
+	
+	unsigned short x_expected = 5;
+	unsigned short y_expected = 4;
+
+    /* act */
+    lab_move(&x, &y, direction);
+
+    /* assert */
+	TEST_ASSERT_TRUE(x == x_expected && y == y_expected);
+}
+
+void test_set_wall_at_0_0_expected_WALL(void)
+{
+    /* arrange */
+	unsigned short x = 0;
+	unsigned short y = 0;
+	
+	unsigned short len_x = 1, len_y = 1;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	
+	field[x][y] = WAY;
+	
+	Field_State expected = WALL;
+
+    /* act */
+    set_wall(field, x, y);
+
+    /* assert */
+	TEST_ASSERT_TRUE(field[x][y] == expected);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_set_wall_at_2_3_expected_WALL(void)
+{
+    /* arrange */
+	unsigned short x = 2;
+	unsigned short y = 3;
+	
+	unsigned short len_x = 5, len_y = 5;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	
+	field[x][y] = WAY;
+	
+	Field_State expected = WALL;
+
+    /* act */
+    set_wall(field, x, y);
+
+    /* assert */
+	TEST_ASSERT_TRUE(field[x][y] == expected);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_init_field_at_0_0_expected_WAY(void)
+{
+    /* arrange */
+	unsigned short x = 0;
+	unsigned short y = 0;
+	
+	unsigned short len_x = 1, len_y = 1;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	
+	field[x][y] = WALL;
+	
+	Field_State expected = WAY;
+
+    /* act */
+    init_field(field, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_TRUE(field[x][y] == expected);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_init_field_at_2_0_expected_WAY(void)
+{
+    /* arrange */
+	unsigned short x = 2;
+	unsigned short y = 0;
+	
+	unsigned short len_x = 5, len_y = 5;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	
+	field[x][y] = WALL;
+	
+	Field_State expected = WAY;
+
+    /* act */
+    init_field(field, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_TRUE(field[x][y] == expected);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_init_field_at_2_3_expected_WAY(void)
+{
+    /* arrange */
+	unsigned short x = 2;
+	unsigned short y = 3;
+	
+	unsigned short len_x = 5, len_y = 5;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	
+	field[x][y] = WALL;
+	
+	Field_State expected = WAY;
+
+    /* act */
+    init_field(field, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_TRUE(field[x][y] == expected);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_0_0_direction_N_target_undefined_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 0;
+	unsigned short y = 0;
+	Direction direction = N;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 1, len_y = 1;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_0_0_direction_E_target_undefined_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 0;
+	unsigned short y = 0;
+	Direction direction = E;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 1, len_y = 1;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_0_0_direction_S_target_undefined_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 0;
+	unsigned short y = 0;
+	Direction direction = S;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 1, len_y = 1;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_0_0_direction_W_target_undefined_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 0;
+	unsigned short y = 0;
+	Direction direction = W;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 1, len_y = 1;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_N_target_WALL_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 0;
+	unsigned short y_target = 1;
+	Direction direction = N;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = WALL;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_E_target_WALL_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 1;
+	unsigned short y_target = 2;
+	Direction direction = E;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = WALL;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_S_target_WALL_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 2;
+	unsigned short y_target = 1;
+	Direction direction = S;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = WALL;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_W_target_WALL_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 1;
+	unsigned short y_target = 0;
+	Direction direction = W;
+	short expected = 1;
+	short actual;
+	
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = WALL;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_N_target_SOLUTION_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 0;
+	unsigned short y_target = 1;
+	Direction direction = N;
+	short expected = 1;
+	short actual;
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = SOLUTION;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_E_target_SOLUTION_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 1;
+	unsigned short y_target = 2;
+	Direction direction = E;
+	short expected = 1;
+	short actual;
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = SOLUTION;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_S_target_SOLUTION_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 2;
+	unsigned short y_target = 1;
+	Direction direction = S;
+	short expected = 1;
+	short actual;
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = SOLUTION;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+
+void test_lab_can_move_at_1_1_direction_W_target_SOLUTION_expected_1(void)
+{
+    /* arrange */
+	unsigned short x = 1;
+	unsigned short y = 1;
+	unsigned short x_target = 1;
+	unsigned short y_target = 0;
+	Direction direction = W;
+	short expected = 1;
+	short actual;
+	unsigned short len_x = 3, len_y = 3;
+    Field_State **field;
+
+    field = malloc(len_x * sizeof *field);
+    for (int c_index = 0; c_index < len_x; c_index++){
+        field[c_index] = malloc(len_y * sizeof field[c_index]);
+    }
+	field[x_target][y_target] = SOLUTION;
+
+    /* act */
+    actual = lab_can_move(field, x, y, direction, len_x, len_y);
+
+    /* assert */
+	TEST_ASSERT_EQUAL_INT8(expected, actual);
+
+    for (int c_index = 0; c_index < len_x; c_index++)
+    {
+        free(field[c_index]);
+    }
+    free(field);
+}
+

src/test/c/test_sudoku.c

@@ -0,0 +1,285 @@
+#ifdef TEST
+
+#include "unity.h"
+#include "sudoku.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+
+
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+//1
+
+// Unit test for Level_Pool() function
+void test_Level_Pool_0() {
+    selected_difficulty = 0;
+    Level_Pool(selected_difficulty);
+    //TEST_PASS();
+    printf("Unit test for Level_Pool_0() executed.\n");
+}
+
+void test_Level_Pool_5() {
+    selected_difficulty = 5;
+    Level_Pool(selected_difficulty);
+    //TEST_PASS();
+    printf("Unit test for Level_Pool_5() executed.\n");
+}
+
+void test_Level_Pool_neg_1() {
+    selected_difficulty = -1;
+    Level_Pool(selected_difficulty);
+    //TEST_PASS();
+    printf("Unit test for Level_Pool_-1() executed.\n\n");
+}
+
+//2
+
+void test_initializeGrid() {
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y];
+
+   
+    initializeGrid(Sudoku_grid);
+    int expected = EMPTY;
+
+
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; ++i) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; ++j) {
+            TEST_ASSERT_EQUAL_INT_MESSAGE(expected, Sudoku_grid[i][j], "Checking if every space is 0");
+        }
+    }
+
+    
+    printf("Unit test for initializeGrid() executed.\n\n");
+}
+
+
+//3
+
+void test_create_playing_field_level_medium_two() {
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y];
+    selected_difficulty = 2;
+    selected_level = 2; 
+    int expected_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = {{7, 0, 2, 0, 0, 0, 9, 5, 0},
+     {0, 0, 0, 7, 5, 0, 2, 0, 6},
+     {0, 0, 5, 0, 2, 8, 7, 0, 3},
+     {5, 1, 8, 0, 3, 0, 6, 0, 0},
+     {0, 0, 6, 1, 0, 0, 0, 3, 0},
+     {0, 0, 0, 0, 6, 2, 0, 8, 1},
+     {0, 9, 0, 2, 0, 4, 0, 0, 5},
+     {0, 0, 0, 0, 9, 0, 0, 0, 4},
+     {0, 5, 1, 0, 0, 0, 0, 9, 2}};
+
+    create_playing_field(Sudoku_grid, selected_difficulty, selected_level);
+
+    // Check if the generated Sudoku grid is valid
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; ++i) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; ++j) {
+            TEST_ASSERT_EQUAL_INT_MESSAGE(expected_grid[i][j], Sudoku_grid[i][j], "Checking if every space is correct");
+            }}
+
+    printf("Unit test for create_playing_field() executed.\n\n");
+}
+
+//4
+
+// Unit test for printGrid() function
+void test_printGrid() {
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = {
+        {5, 3, 0, 0, 7, 0, 0, 0, 0},
+        {6, 0, 0, 1, 9, 5, 0, 0, 0},
+        {0, 9, 8, 0, 0, 0, 0, 6, 0},
+        {8, 0, 0, 0, 6, 0, 0, 0, 3},
+        {4, 0, 0, 8, 0, 3, 0, 0, 1},
+        {7, 0, 0, 0, 2, 0, 0, 0, 6},
+        {0, 6, 0, 0, 0, 0, 2, 8, 0},
+        {0, 0, 0, 4, 1, 9, 0, 0, 5},
+        {0, 0, 0, 0, 8, 0, 0, 7, 9}
+    };
+
+    printf("Sudoku Grid:\n");
+    printGrid(Sudoku_grid);
+    //TEST_PASS();
+    printf("Unit test for printGrid() executed.\n\n");
+}
+
+
+//5
+
+// Unit test for check_if_Sudoku_solved() function
+void test_check_if_Sudoku_solved_everything_correct() {
+    selected_difficulty = 1;
+    selected_level = 1;
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = {
+     {4, 7, 3, 6, 2, 1, 8, 5, 9},
+     {6, 8, 5, 9, 7, 4, 1, 3, 2},
+     {9, 2, 1, 5, 3, 8, 7, 6, 4},
+     {7, 6, 9, 3, 5, 2, 4, 8, 1},
+     {8, 5, 4, 1, 9, 7, 6, 2, 3},
+     {1, 3, 2, 4, 8, 6, 9, 7, 5},
+     {2, 9, 7, 8, 1, 5, 3, 4, 6},
+     {3, 4, 8, 2, 6, 9, 5, 1, 7},
+     {5, 1, 6, 7, 4, 3, 2, 9, 8}};
+
+
+    check_if_Sudoku_solved(Sudoku_grid);
+    TEST_ASSERT_TRUE(check_solved);
+    
+
+    printf("Unit test for check_if_Sudoku_solved() executed.\n");
+}
+
+void test_check_if_Sudoku_solved_mistake_on_purpose() {
+    selected_difficulty = 1;
+    selected_level = 1;
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = {
+     {4, 7, 3, 6, 2, 1, 8, 5, 9},
+     {6, 8, 5, 9, 7, 4, 1, 3, 2},
+     {9, 2, 1, 5, 3, 8, 7, 6, 4},
+     {7, 6, 9, 3, 5, 2, 4, 8, 1},
+     {8, 5, 4, 1, 9, 7, 6, 2, 3},
+     {1, 3, 2, 4, 8, 6, 9, 7, 5},
+     {2, 9, 7, 8, 1, 5, 3, 4, 6},
+     {3, 4, 8, 2, 6, 9, 5, 1, 7},
+     {5, 1, 6, 7, 4, 3, 2, 9, 3}};
+
+
+    check_if_Sudoku_solved(Sudoku_grid);
+    TEST_ASSERT_FALSE(check_solved);
+    
+
+    printf("Unit test for check_if_Sudoku_solved() executed.\n\n");
+}
+
+
+//6
+
+void test_Game_loop_1(){
+    test_help = true;
+    selected_difficulty = 1;
+    Game_loop();
+    printf("Unit test for Game_loop() executed.\n\n");
+}
+
+//7
+
+void test_Level_Selection_2_2(){
+    test_help = true;
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y];
+    selected_difficulty = 1;
+    selected_level = 1;
+  
+     Level_Selection(Sudoku_grid);
+
+    int expected = EMPTY;
+
+
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; ++i) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; ++j) {
+            TEST_ASSERT_EQUAL_INT_MESSAGE(expected, Sudoku_grid[i][j], "Checking if level gets initialized correctly");
+        }
+    }
+
+    printf("Unit test for Level_Selection() executed.\n\n");
+}
+
+//8
+
+void test_Player_actions_for_playing_print_and_solve(){
+    test_help = true;
+    selected_difficulty = 1;
+    selected_level = 1;
+    
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = {
+     {4, 7, 3, 6, 2, 1, 8, 5, 9},
+     {6, 8, 5, 9, 7, 4, 1, 3, 2},
+     {9, 2, 1, 5, 3, 8, 7, 6, 4},
+     {7, 6, 9, 3, 5, 2, 4, 8, 1},
+     {8, 5, 4, 1, 9, 7, 6, 2, 3},
+     {1, 3, 2, 4, 8, 6, 9, 7, 5},
+     {2, 9, 7, 8, 1, 5, 3, 4, 6},
+     {3, 4, 8, 2, 6, 9, 5, 1, 7},
+     {5, 1, 6, 7, 4, 3, 2, 9, 8}};
+
+    Player_actions_for_playing(Sudoku_grid);
+    TEST_ASSERT_TRUE(check_solved);
+    printf("Unit test for Player_actions_for_playing() executed.\n\n");
+}
+
+
+
+//9
+
+void test_giving_hints_to_player(){
+    test_help = true;
+    int selected_difficulty = 1;
+    int selected_level = 1; 
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] =
+    {
+        {5, 3, 0, 0, 7, 0, 0, 0, 0},
+        {6, 0, 0, 1, 9, 5, 0, 0, 0},
+        {0, 9, 8, 0, 0, 0, 0, 6, 0},
+        {8, 0, 0, 0, 6, 0, 0, 0, 3},
+        {4, 0, 0, 8, 0, 3, 0, 0, 1},
+        {7, 0, 0, 0, 2, 0, 0, 0, 6},
+        {0, 6, 0, 0, 0, 0, 2, 8, 0},
+        {0, 0, 0, 4, 1, 9, 0, 0, 5},
+        {0, 0, 0, 0, 8, 0, 0, 7, 9}
+    };
+    int expected_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y] = 
+    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
+     {6, 8, 5, 9, 7, 4, 1, 3, 2},
+     {9, 2, 1, 5, 3, 8, 7, 6, 4},
+     {7, 6, 9, 3, 5, 2, 4, 8, 1},
+     {8, 5, 4, 1, 9, 7, 6, 2, 3},
+     {1, 3, 2, 4, 8, 6, 9, 7, 5},
+     {2, 9, 7, 8, 1, 5, 3, 4, 6},
+     {3, 4, 8, 2, 6, 9, 5, 1, 7},
+     {5, 1, 6, 7, 4, 3, 2, 9, 8}};
+
+    giving_hints_to_player(Sudoku_grid);
+
+    // Check if the generated Sudoku grid is valid
+    for (int i = 0; i < SIZE_OF_GAMEBORD_AXIS_X; ++i) {
+        for (int j = 0; j < SIZE_OF_GAMEBORD_AXIS_Y; ++j) {
+            TEST_ASSERT_EQUAL_INT_MESSAGE(expected_grid[i][j], Sudoku_grid[i][j], "Checking if every space is correct");
+            }}
+
+
+    printf("Unit test for giving_hints_to_player() executed.\n\n");
+}
+
+
+// 10
+
+void test_write_userinput_into_Sudoku_9_into_empty(){
+    test_help = true;
+    test_row_e = 1;
+    test_col_e = 1;
+    test_num = 9;
+    int Sudoku_grid[SIZE_OF_GAMEBORD_AXIS_X][SIZE_OF_GAMEBORD_AXIS_Y];
+    
+
+    write_userinput_into_Sudoku(Sudoku_grid);
+
+    TEST_ASSERT_EQUAL_INT_MESSAGE(test_num, Sudoku_grid[test_row_e -1][test_col_e -1], "Checking if number input is correct");
+            
+
+
+    printf("Unit test for write_userinput_into_Sudoku() executed.\n\n");
+}
+
+
+
+
+
+#endif // TEST

src/test/c/test_test.c

@@ -1,28 +0,0 @@
-#ifdef TEST
-
-#include "unity.h"
-
-#include "test.h"
-
-void setUp(void)
-{
-}
-
-void tearDown(void)
-{
-}
-
-void test_test__return_5(void)
-{
-    /* arrange */
-	int expected = 5;
-	int actual;
-
-    /* act */
-	actual = return_5();
-
-    /* assert */
-	TEST_ASSERT_EQUAL_INT(expected, actual);
-}
-
-#endif // TEST

team.md

@@ -1,6 +1,8 @@
-Joe Lukas Kalb, fdai7715
-Peter Wiebe, fdai7773
-Simon Hildebrandt, fdai7864
-Lucas Heil, fdai7356
-Celine Khazarian, fdai7781
-Ahmad Thaljeh, fdai7726
+- COMMITTER-NAME, FD-NUMMER
+- Joe Lukas Kalb, fdai7715
+- Peter Wiebe, fdai7773
+- Simon Hildebrandt, fdai7864
+- Lucas Heil, fdai7356
+- Celine Khazarian, fdai7781
+- fdai7726, fdai7726
+- fdai7731, fdai7731