Merge branch 'Luis-Branch' into 'main'

Hinzufügen von Speichern und Historie

See merge request fdai7834/taktikmeister!6

src/Historie.c

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "Schachbrett.h"
+#include "Bauer.h"
+#include "Spieler.h"
+
+
+int** erstellen_historie() {
+    int MAX_ZUEGE = 70;
+    int ZUG_INFO = 5;
+
+    // Dynamisch Platz zuweisen für Historie
+    int** Historie = (int**)malloc(MAX_ZUEGE * sizeof(int*));
+
+    if (Historie == NULL) {
+        // Fehler bei Speicherzuweisung
+        return NULL;
+    }
+
+    for (int i = 0; i < MAX_ZUEGE; i++) {
+        Historie[i] = (int*)malloc(ZUG_INFO * sizeof(int));
+
+        if (Historie[i] == NULL) {
+            // Speicherfehlerbehebung
+            for (int j = 0; j < i; j++) {
+                free(Historie[j]);
+            }
+            free(Historie);
+            return NULL;
+        }
+    }
+
+    return Historie;
+}
+
+void Historie_freigeben(int** Historie) {
+    // Speicher freigeben für Historie
+    int MAX_ZUEGE = 70;
+
+    for (int i = 0; i < MAX_ZUEGE; i++) {
+        free(Historie[i]);
+    }
+    free(Historie);
+}
+
+
+
+void hinzufuegen_historie(int** Historie, int startX, int startY, int endX, int endY, Player player, int anzahl_Zuege) {
+
+     // Hier kannst du die Zuginformationen in die Historie eintragen
+    Historie[anzahl_Zuege][0] = startX;
+    Historie[anzahl_Zuege][1] = startY;
+    Historie[anzahl_Zuege][2] = endX;
+    Historie[anzahl_Zuege][3] = endY;
+    
+    if(player == PLAYER_WHITE){
+        Historie[anzahl_Zuege][4] = 0;
+    }else{
+        Historie[anzahl_Zuege][4] = 1;
+    }
+     
+}
+
+void print_Historie(int** Historie, int anzahl_Zuege) {
+    printf("Historie der Züge:\n");
+    for (int i = 0; i <= anzahl_Zuege; i++) {
+        if(Historie[i][4] == 0){
+        printf("%d. Zug: Von (%d, %d) nach (%d, %d) von Spieler Weiß\n", i + 1,
+               Historie[i][0], Historie[i][1],
+               Historie[i][2], Historie[i][3]);
+        }else{
+            printf("%d. Zug: Von (%d, %d) nach (%d, %d) von Spieler Schwarz\n", i + 1,
+               Historie[i][0], Historie[i][1],
+               Historie[i][2], Historie[i][3]);
+        }
+    }
+    printf("\n");
+}

src/Historie.h

@@ -0,0 +1,12 @@
+#ifndef HISTORIE
+#define HISTORIE
+
+#include "Spieler.h"
+
+int** erstellen_historie();
+void Historie_freigeben(int** Historie);
+void print_Historie(int** Historie, int anzahl_Zuege);
+void hinzufuegen_historie(int** Historie, int startX, int startY, int endX, int endY, Player player, int anzahl_Zuege);
+
+
+#endif // HISTORIE

src/Moving.c

@@ -5,6 +5,7 @@
 #include "Bauer.h"
 #include "Turm.h"
 #include "Springer.h"
+#include "Koenig.h"
 
 bool istzugerlaubt(char** Brett, int startX, int startY, int endX, int endY, Player player) {
     
@@ -41,6 +42,7 @@ bool istzugerlaubt(char** Brett, int startX, int startY, int endX, int endY, Pla
         break;    
     case 'K': 
             //Datei von König aufrufen
+            return (istzugerlaubt_Koenig(Brett, startX,startY,endX,endY,player));
         break;
     case 'P': 
            //Datei von Bauer aufrufen

src/Schachbrett.c

@@ -58,7 +58,6 @@ void print_Schachfeld(char** Brett) {
         printf("\n");
     }
     printf("\n");
-    printf("\n");
 }
 
 void Schachbrettspeicher_freigeben(char** Brett) { 

src/Speichern.c

@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "Schachbrett.h"
+#include "Bauer.h"
+#include "Spieler.h"
+#include "Historie.h"
+
+void speichern_spielstand_historie(int** Historie, int anzahl_Zuege, const char* dateiName) {
+    
+    int ZUG_INFO = 5;
+    FILE* datei = fopen(dateiName, "wb");
+
+    if (datei == NULL) {
+        printf("Fehler beim Öffnen der Datei zum Speichern.\n");
+        return;
+    }
+
+    // Schreibe die Anzahl der Züge in die Datei
+    fwrite(&anzahl_Zuege, sizeof(int), 1, datei);
+
+    // Schreibe die Historie in die Datei
+    fwrite(*Historie, sizeof(int), ZUG_INFO * (anzahl_Zuege + 1), datei);
+
+    fclose(datei);
+}
+
+int laden_spielstand_historie(int*** Historie, int* anzahl_Zuege, const char* dateiName) {
+    int ZUG_INFO = 5;
+    FILE* datei = fopen(dateiName, "rb");
+
+    if (datei == NULL) {
+        printf("Fehler beim Öffnen der Datei zum Laden.\n");
+        return 0; // Rückgabewert 0 bedeutet Fehler
+    }
+
+    // Lese die Anzahl der Züge aus der Datei
+    fread(anzahl_Zuege, sizeof(int), 1, datei);
+
+    // Allokiere Speicher für die Historie basierend auf der gelesenen Anzahl der Züge
+    *Historie = (int**)malloc((*anzahl_Zuege + 1) * sizeof(int*));
+
+    if (*Historie == NULL) {
+        printf("Fehler bei der Speicherzuweisung.\n");
+        fclose(datei);
+        return 0;
+    }
+
+    // Lese die Historie aus der Datei
+    fread(**Historie, sizeof(int), ZUG_INFO * (*anzahl_Zuege + 1), datei);
+
+    fclose(datei);
+
+    return 1; // Rückgabewert 1 bedeutet Erfolg
+}
+
+void speichern_spielstand_schachbrett(char** Brett, const char* dateiName){
+
+    FILE* datei = fopen(dateiName, "wb");
+
+    if (datei == NULL) {
+        printf("Fehler beim Öffnen der Datei zum Speichern.\n");
+        return;
+    }
+
+    // Schreibe das Schachbrett in die Datei
+    for (int i = 0; i < 8; i++) {
+        fwrite(Brett[i], sizeof(char), 8, datei);
+    }
+
+    fclose(datei);
+}
+
+void laden_spielstand_schachbrett(){
+        /* 
+            Binäre Datei muss geöffnet werden
+            Daten müsseneingelesen werden 
+            Daten werden in extra array gespeichert werden
+            Spielfeldarray wird auf den Stand von Speichern gebracht
+               
+            */
+}

src/Speichern.h

@@ -0,0 +1,11 @@
+#ifndef SPEICHERN
+#define SPEICHERN
+
+#include "Spieler.h"
+
+void speichern_spielstand_historie(int** Historie, int anzahl_Zuege, const char* dateiName);
+int laden_spielstand_historie(int*** Historie, int* anzahl_Zuege, const char* dateiName);
+void speichern_spielstand_schachbrett(char** Brett, const char* dateiName);
+void laden_spielstand_schachbrett();
+
+#endif // SPEICHERN

src/Turm.c

@@ -9,8 +9,7 @@ bool istzugerlaubt_Turm(char** Brett, int startX, int startY, int endX, int endY
  
 int counter = 0;
 
- if(startX == endX){
-    if(startY<endY){
+ if(startX == endX && startY < endY){
         counter = endY-startY;
     for(int i = 1; i<counter;i++){
         if(Brett[startY+i][startX] != ' '){
@@ -18,7 +17,7 @@ int counter = 0;
         }
     }
     return true;
-    }else{
+}else if(startX == endX && startY > endY){
         counter = startY-endY;
     for(int i = 1; i<counter;i++){
         if(Brett[startY-i][startX] != ' '){
@@ -26,11 +25,8 @@ int counter = 0;
         }
     }
     return true;
-    }
     
-
- }else if(startY == endY){
-    if(startX<endX){
+ }else if(startY == endY && startX<endX){
         counter = endX-startX;
         for(int i = 1; i<counter;i++){
         if(Brett[startY][startX+i] != ' '){
@@ -38,7 +34,7 @@ int counter = 0;
         }
     }
     return true;
-    }else{
+ }else if(startY == endY && startX>endX){
         counter = startX-endX;
         for(int i = 1; i<counter;i++){
         if(Brett[startY][startX-i] != ' '){
@@ -46,13 +42,9 @@ int counter = 0;
         }
     } 
     return true;
-    }
     
 }else{
     return false;
 }
-    
-
-return true;
 }
 

src/main.c

@@ -3,25 +3,5 @@
 #include "Spielstatus.h"
 
 int main() {
-    Spielstatus status;
-    initalisiereSpielstatus(&status);
-/*  int x = 8;
-    int y = 8;
-    int spieler = 0;
-    char** Spielfeld = create_Schachfeld(x, y);
-    while (checkmate() == 0){
-    print_Schachfeld(Spielfeld);
-    if(spieler % 2 == 0){
 
-        choose_Figur('w', Spielfeld);//weiß
-    } else {
-        choose_Figur('s', Spielfeld);//schwarz
-    }
-    spieler++;
-    }
-    
-    free_Schachfeld(Spielfeld, x);
-
-    return 0;
-    */
 }

test/test_Moving.c

@@ -5,6 +5,7 @@
 #include "Spieler.h"
 #include "Turm.h"
 #include "Bauer.h"
+#include "Koenig.h"
 #include "Springer.h"
 #include <stdlib.h>
 
@@ -39,6 +40,31 @@ void test_Bauern_bewegen(void) {
     free(brett);
 }
 
+void test_istzugerlaubt_Koenig_Verknuepfung(void) {
+     char **Brett = Schachbrett_erstellen();
+    Player player = PLAYER_WHITE;
+    //Vorbereitung für Test
+    Brett[1][4] = ' '; 
+    Brett[2][4] = 'p'; 
+
+    // Test bewegung
+    TEST_ASSERT_TRUE(istzugerlaubt(Brett, 4, 0, 4, 1, player)); // e1 zu e2
+    TEST_ASSERT_TRUE(istzugerlaubt(Brett, 4, 1, 4, 2, player)); // e2 zu e3 (Einnehmen von Figur)
+
+    Schachbrettspeicher_freigeben(Brett);
+    Brett = Schachbrett_erstellen();
+    player = PLAYER_BLACK;
+    //Vorbereitung für Test
+    Brett[6][4] = ' ';
+    Brett[5][4] = 'P';
+
+    // Test bewegung
+    TEST_ASSERT_TRUE(istzugerlaubt(Brett, 4, 7, 4, 6, player)); // e8 zu e7
+    TEST_ASSERT_TRUE(istzugerlaubt(Brett, 4, 6, 4, 5, player)); // e7 zu e6 (Einnehmen von Figur)
+
+    Schachbrettspeicher_freigeben(Brett);
+}
+
 void test_Bauer_Y_Verknuepfung_Bewegung(void) {
 
     char** brett = Schachbrett_erstellen();

test/test_Speichern.c

@@ -0,0 +1,47 @@
+#ifdef TEST
+#include "unity.h"
+#include <stdlib.h>
+#include "Historie.h"
+#include "Spieler.h"
+#include "Speichern.h"
+
+/*
+void test_speichern_spielstand_historie(void) {
+    // Annahme: Historie mit einigen Zügen ist bereits vorhanden
+    int** historie;
+    int anzahl_zuege = 3;  
+    historie = erstellen_historie();  
+
+   //Test-Daten
+    historie[0][0] = 1; historie[0][1] = 2; historie[0][2] = 3; historie[0][3] = 4; historie[0][4] = 0;  // Beispielzug 1
+    historie[1][0] = 5; historie[1][1] = 6; historie[1][2] = 7; historie[1][3] = 8; historie[1][4] = 1;  // Beispielzug 2
+    historie[2][0] = 9; historie[2][1] = 10; historie[2][2] = 11; historie[2][3] = 12; historie[2][4] = 0;  // Beispielzug 3
+
+    // Teste die Funktion zum Speichern des Spielstands
+    const char* test_dateiname = "test_spielstand.dat";
+    speichern_spielstand_historie(historie, anzahl_zuege, test_dateiname);
+
+    // Lese die gespeicherte Historie zurück
+    int** geladene_historie;
+    int geladene_anzahl_zuege;
+
+    laden_spielstand_historie(&geladene_historie, &geladene_anzahl_zuege, test_dateiname);
+
+    // Überprüfe, ob die geladene Historie mit der ursprünglichen Historie identisch ist
+    TEST_ASSERT_EQUAL_INT_MESSAGE(anzahl_zuege, geladene_anzahl_zuege, "Anzahl der Züge stimmt nicht überein");
+
+    for (int i = 0; i <= anzahl_zuege; i++) {
+        TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(historie[i], geladene_historie[i], 5, "Zuginformationen stimmen nicht überein");
+    }
+
+    // Freigabe des Speichers
+    for (int i = 0; i <= anzahl_zuege; i++) {
+        free(historie[i]);
+        free(geladene_historie[i]);
+    }
+    free(historie);
+    free(geladene_historie);
+}
+*/
+
+#endif // TEST

test/test_historie.c

@@ -0,0 +1,90 @@
+#ifdef TEST
+#include "unity.h"
+#include <stdlib.h>
+#include "Historie.h"
+#include "Spieler.h"
+
+
+
+void test_erstellen_historie(void) {
+    int MAX_ZUEGE = 70;
+    int ZUG_INFO = 5;
+
+    // Historie erstellen
+    int** meineHistorie = erstellen_historie();
+
+    // Überprüfen, ob die Historie erfolgreich erstellt wurde
+    TEST_ASSERT_NOT_NULL(meineHistorie);
+
+    // Speicher freigeben
+    for (int i = 0; i < MAX_ZUEGE; i++) {
+        free(meineHistorie[i]);
+    }
+    free(meineHistorie);
+}
+
+void test_hinzufuegen_historie(void) {
+    int MAX_ZUEGE = 70;
+    int ZUG_INFO = 5;
+
+    // Historie erstellen
+    int** meineHistorie = erstellen_historie();
+
+    // Testdaten
+    int startX = 1;
+    int startY = 2;
+    int endX = 3;
+    int endY = 4;
+    Player currentPlayer = PLAYER_WHITE;
+    int anzahl_Zuege = 0;
+
+    // Züge zur Historie hinzufügen
+    hinzufuegen_historie(meineHistorie, startX, startY, endX, endY, currentPlayer, anzahl_Zuege);
+
+    // Überprüfen, ob die Züge korrekt zur Historie hinzugefügt wurden
+    TEST_ASSERT_EQUAL_INT(startX, meineHistorie[anzahl_Zuege][0]);
+    TEST_ASSERT_EQUAL_INT(startY, meineHistorie[anzahl_Zuege][1]);
+    TEST_ASSERT_EQUAL_INT(endX, meineHistorie[anzahl_Zuege][2]);
+    TEST_ASSERT_EQUAL_INT(endY, meineHistorie[anzahl_Zuege][3]);
+
+    // Speicher freigeben
+    for (int i = 0; i < MAX_ZUEGE; i++) {
+        free(meineHistorie[i]);
+    }
+
+}
+
+void test_hinzufuegen_historie_Player_black(void) {
+    int MAX_ZUEGE = 70;
+    int ZUG_INFO = 5;
+
+    // Historie erstellen
+    int** meineHistorie = erstellen_historie();
+
+    // Testdaten
+    int startX = 1;
+    int startY = 1;
+    int endX = 1;
+    int endY = 4;
+    Player currentPlayer = PLAYER_BLACK;
+    int anzahl_Zuege = 0;
+
+    // Züge zur Historie hinzufügen
+    hinzufuegen_historie(meineHistorie, startX, startY, endX, endY, currentPlayer, anzahl_Zuege);
+
+    // Überprüfen, ob die Züge korrekt zur Historie hinzugefügt wurden
+    TEST_ASSERT_EQUAL_INT(startX, meineHistorie[anzahl_Zuege][0]);
+    TEST_ASSERT_EQUAL_INT(startY, meineHistorie[anzahl_Zuege][1]);
+    TEST_ASSERT_EQUAL_INT(endX, meineHistorie[anzahl_Zuege][2]);
+    TEST_ASSERT_EQUAL_INT(endY, meineHistorie[anzahl_Zuege][3]);
+    TEST_ASSERT_EQUAL_INT(1, meineHistorie[anzahl_Zuege][4]);//1 da Player Black
+
+    print_Historie(meineHistorie,anzahl_Zuege);
+
+    // Speicher freigeben
+    for (int i = 0; i < MAX_ZUEGE; i++) {
+        free(meineHistorie[i]);
+    }
+
+}
+#endif // TEST