From 5b5d0d3969bd38a40b5812f7f81d88b9e9e625c0 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 02:24:31 +0000 Subject: [PATCH 01/13] =?UTF-8?q?Springer=20hinzugef=C3=BCgt=20+=20Test,?= =?UTF-8?q?=20Anton=20Lohrey?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Springer.c | 31 +++++++++++++++++++++++++++++++ src/Springer.h | 7 +++++++ test/test_Springer.c | 18 ++++++++++++++++++ 3 files changed, 56 insertions(+) create mode 100644 src/Springer.c create mode 100644 src/Springer.h create mode 100644 test/test_Springer.c diff --git a/src/Springer.c b/src/Springer.c new file mode 100644 index 0000000..785d840 --- /dev/null +++ b/src/Springer.c @@ -0,0 +1,31 @@ +#include +#include +#include +#include +#include "spieler.h" +#include "Moving.h" +#include "Springer.h" + +bool istzugerlaubt_Springer(char** Brett, int startX, int startY, int endX, int endY, Player player) { + // Berechnung des unterschieds der start und endpositionen + int dx = abs(endX - startX); + int dy = abs(endY - startY); + + + + // Schaut ob die bewegung eine L-form hat + if ((dx == 2 && dy == 1) || (dx == 1 && dy == 2)) { + + char EndPosition = Brett[endY][endX]; + + if (player == PLAYER_WHITE && islower(EndPosition)) { + return true; // Erlaubter zug weil die Position leer ist oder von einer gegnerischen Figur belegt ist + } else if (player == PLAYER_BLACK && isupper(EndPosition)) { + return true; // Erlaubter zug weil die Position leer ist oder von einer gegnerischen Figur belegt ist + } else if (EndPosition == ' ') { + return true; // Erlaubter zug weil die Zielposition leer ist + } + } + + return false; // kein erlaubter zug +} diff --git a/src/Springer.h b/src/Springer.h new file mode 100644 index 0000000..f7cc8e7 --- /dev/null +++ b/src/Springer.h @@ -0,0 +1,7 @@ +#ifndef Springer +#define Springer +#include "spieler.h" + +bool istzugerlaubt_Springer(char** Brett, int startX, int startY, int endX, int endY, Player player); + +#endif // Springer diff --git a/test/test_Springer.c b/test/test_Springer.c new file mode 100644 index 0000000..790a465 --- /dev/null +++ b/test/test_Springer.c @@ -0,0 +1,18 @@ +#ifdef TEST +#include "unity.h" +#include +#include +#include +#include "Springer.h" +#include "Schachbrett.h" +#include "Spieler.h" + +void test_istzugerlaubt_Springer_LegalMove(void) { + char **Brett = Schachbrett_erstellen(); + + // Teste legaler Zug für weißen Springer : b1 zu a3 + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 1, 0, 0, 2, PLAYER_WHITE)); + + Schachbrettspeicher_freigeben(Brett); +} +#endif // TEST From 910ee7ac17ebe08a52cd1717ad0dc642bb718f2c Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 02:43:36 +0000 Subject: [PATCH 02/13] Extra Checks, Anton Lohrey --- src/Springer.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/Springer.c b/src/Springer.c index 785d840..aff2cbe 100644 --- a/src/Springer.c +++ b/src/Springer.c @@ -7,6 +7,10 @@ #include "Springer.h" bool istzugerlaubt_Springer(char** Brett, int startX, int startY, int endX, int endY, Player player) { + // Schauen ob der zug auf dem Spielbrett passiert + if (endX < 0 || endX >= 8 || endY < 0 || endY >= 8) { + return false; + } // Berechnung des unterschieds der start und endpositionen int dx = abs(endX - startX); int dy = abs(endY - startY); @@ -17,6 +21,16 @@ bool istzugerlaubt_Springer(char** Brett, int startX, int startY, int endX, int if ((dx == 2 && dy == 1) || (dx == 1 && dy == 2)) { char EndPosition = Brett[endY][endX]; + //schaut ob die Endposition von einer eigenen Figur belegt ist + if (player == PLAYER_WHITE) { + if (isupper(EndPosition) && EndPosition != ' ') { + return false; + } + } else { // PLAYER_BLACK + if (islower(EndPosition) && EndPosition != ' ') { + return false; + } + } if (player == PLAYER_WHITE && islower(EndPosition)) { return true; // Erlaubter zug weil die Position leer ist oder von einer gegnerischen Figur belegt ist From 9e430bbd282a29f0573023b94a3f9173265f624d Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 03:02:36 +0000 Subject: [PATCH 03/13] Mehr Tests, Anton Lohrey --- test/test_Springer.c | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/test/test_Springer.c b/test/test_Springer.c index 790a465..88e5fcd 100644 --- a/test/test_Springer.c +++ b/test/test_Springer.c @@ -10,8 +10,35 @@ void test_istzugerlaubt_Springer_LegalMove(void) { char **Brett = Schachbrett_erstellen(); - // Teste legaler Zug für weißen Springer : b1 zu a3 + // Viele Test um legale Züge zu prüfen TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 1, 0, 0, 2, PLAYER_WHITE)); + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 1, 0, 2, 2, PLAYER_WHITE)); + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 4, 3, 3, 5, PLAYER_WHITE)); + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 4, 3, 2, 2, PLAYER_WHITE)); + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 4, 3, 6, 2, PLAYER_BLACK)); + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 6, 7, 5, 5, PLAYER_BLACK)); + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 6, 7, 7, 5, PLAYER_BLACK)); + TEST_ASSERT_TRUE(istzugerlaubt_Springer(Brett, 4, 3, 5, 5, PLAYER_BLACK)); + + Schachbrettspeicher_freigeben(Brett); +} +void test_istzugerlaubt_Springer_IllegalMove(void) { + char **Brett = Schachbrett_erstellen(); + + // Landet auf eigener Figur + TEST_ASSERT_FALSE(istzugerlaubt_Springer(Brett, 6, 7, 4, 6, PLAYER_BLACK)); + TEST_ASSERT_FALSE(istzugerlaubt_Springer(Brett, 1, 7, 3, 6, PLAYER_BLACK)); + TEST_ASSERT_FALSE(istzugerlaubt_Springer(Brett, 6, 0, 4, 1, PLAYER_WHITE)); + TEST_ASSERT_FALSE(istzugerlaubt_Springer(Brett, 1, 0, 3, 1, PLAYER_WHITE)); + + // versucht sich geradeaus zu bewegen + TEST_ASSERT_FALSE(istzugerlaubt_Springer(Brett, 1, 0, 1, 3, PLAYER_WHITE)); + + // Versucht Diagonal zu bewegen + TEST_ASSERT_FALSE(istzugerlaubt_Springer(Brett, 7, 0, 6, 1, PLAYER_WHITE)); + + // Vom Brett springen + TEST_ASSERT_FALSE(istzugerlaubt_Springer(Brett, 7, 0, 8, 2, PLAYER_WHITE)); Schachbrettspeicher_freigeben(Brett); } From dc75886b6e3198e1e020e3b6353d59fe31cde508 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 03:53:21 +0000 Subject: [PATCH 04/13] bewegeSpringer + Tests, Anton Lohrey --- src/Springer.c | 14 ++++++++++++++ src/Springer.h | 2 +- test/test_Springer.c | 39 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+), 1 deletion(-) diff --git a/src/Springer.c b/src/Springer.c index aff2cbe..6ace74b 100644 --- a/src/Springer.c +++ b/src/Springer.c @@ -43,3 +43,17 @@ bool istzugerlaubt_Springer(char** Brett, int startX, int startY, int endX, int return false; // kein erlaubter zug } +bool bewegeSpringer(char** Brett, int startX, int startY, int endX, int endY, Player player) { + // Überprüfen ob der Zug legal ist + if (!istzugerlaubt_Springer(Brett, startX, startY, endX, endY, player)) { + return false; // Zug ist nicht erlaubt + } + + char springer = Brett[startY][startX]; + + // Aktualisiere das Brett. + Brett[startY][startX] = ' '; + Brett[endY][endX] = springer; + + return true; +} diff --git a/src/Springer.h b/src/Springer.h index f7cc8e7..f8d00ab 100644 --- a/src/Springer.h +++ b/src/Springer.h @@ -3,5 +3,5 @@ #include "spieler.h" bool istzugerlaubt_Springer(char** Brett, int startX, int startY, int endX, int endY, Player player); - +bool bewegeSpringer(char** Brett, int startX, int startY, int endX, int endY, Player player); #endif // Springer diff --git a/test/test_Springer.c b/test/test_Springer.c index 88e5fcd..923bc6a 100644 --- a/test/test_Springer.c +++ b/test/test_Springer.c @@ -42,4 +42,43 @@ void test_istzugerlaubt_Springer_IllegalMove(void) { Schachbrettspeicher_freigeben(Brett); } +void test_bewegeSpringer(void) { + char **Brett = Schachbrett_erstellen(); + bool Ergebnis; + + // Scenario 1: Legaler Zug, weißer Springer von b1 zu c3 + Ergebnis = bewegeSpringer(Brett, 1, 0, 2, 2, PLAYER_WHITE); + TEST_ASSERT_TRUE(Ergebnis); + TEST_ASSERT_EQUAL_CHAR('N', Brett[2][2]); + TEST_ASSERT_EQUAL_CHAR(' ', Brett[0][1]); + + Schachbrettspeicher_freigeben(Brett); + Brett = Schachbrett_erstellen(); + + // Scenario 2: Illegaler Zug , vom Brett + Ergebnis = bewegeSpringer(Brett, 7, 6, 8, 8, PLAYER_WHITE); + TEST_ASSERT_FALSE(Ergebnis); + + // Scenario 3: Legaler Zug, schwarzer Springer von g8 zu f6 + Ergebnis = bewegeSpringer(Brett, 6, 7, 5, 5, PLAYER_BLACK); + TEST_ASSERT_TRUE(Ergebnis); + TEST_ASSERT_EQUAL_CHAR('n', Brett[5][5]); + TEST_ASSERT_EQUAL_CHAR(' ', Brett[7][6]); + + Schachbrettspeicher_freigeben(Brett); + Brett = Schachbrett_erstellen(); + + // Scenario 4: Illegaler Zug, schwarzer Springer bewegt sich auf andere schwarze Figur + Brett[5][5] = 'n'; // ein anderer Springer als Hindernis + Ergebnis = bewegeSpringer(Brett, 6, 7, 5, 5, PLAYER_BLACK); + TEST_ASSERT_FALSE(Ergebnis); + + // Scenario 5: Legaler Zug zum einnehmen feindlicher Figur + Brett[5][5] = 'P'; // Weißer Bauer auf F6 + Ergebnis = bewegeSpringer(Brett, 6, 7, 5, 5, PLAYER_BLACK); + TEST_ASSERT_TRUE(Ergebnis); + TEST_ASSERT_EQUAL_CHAR('n', Brett[5][5]); + + Schachbrettspeicher_freigeben(Brett); +} #endif // TEST From 2c86630ed5e5a6934c658fe42e21c28f295e3008 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 05:20:02 +0000 Subject: [PATCH 05/13] =?UTF-8?q?Anfang=20K=C3=B6nig=20+=20test,=20Anton?= =?UTF-8?q?=20Lohrey?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Koenig.c | 31 ++++++++++++++++++++++++++++++ src/Koenig.h | 6 ++++++ test/test_Koenig.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 85 insertions(+) create mode 100644 src/Koenig.c create mode 100644 src/Koenig.h create mode 100644 test/test_Koenig.c diff --git a/src/Koenig.c b/src/Koenig.c new file mode 100644 index 0000000..7de33e2 --- /dev/null +++ b/src/Koenig.c @@ -0,0 +1,31 @@ +#include +#include +#include +#include +#include "spieler.h" +#include "Moving.h" +#include "Koenig.h" + +bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player) { + // Schauen ob der zug auf dem Spielbrett passiert + if (endX < 0 || endX >= 8 || endY < 0 || endY >= 8) + return false; + + // Berechnung des unterschieds der start und endpositionen + int dx = abs(endX - startX); + int dy = abs(endY - startY); + + // Schauen ob sich nur ein feld bewegt wird + if (dx > 1 || dy > 1) return false; + + // Nicht auf befreundete Figuren bewegen + char endPosition = Brett[endY][endX]; + if (player == PLAYER_WHITE && isupper(endPosition)) + return false; + if (player == PLAYER_BLACK && islower(endPosition)) + return false; + + // mehr checks noch benötigt + + return true; +} diff --git a/src/Koenig.h b/src/Koenig.h new file mode 100644 index 0000000..c8d0328 --- /dev/null +++ b/src/Koenig.h @@ -0,0 +1,6 @@ +#ifndef Springer +#define Springer +#include "Spieler.h" + +bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player); +#endif // Springer diff --git a/test/test_Koenig.c b/test/test_Koenig.c new file mode 100644 index 0000000..23bd7ad --- /dev/null +++ b/test/test_Koenig.c @@ -0,0 +1,48 @@ +#ifdef TEST +#include "unity.h" +#include +#include +#include +#include "Spieler.h" +#include "Schachbrett.h" +#include "Koenig.h" + + +void test_istzugerlaubt_Koenig_LegalMoves(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_Koenig(Brett, 4, 0, 4, 1, player)); // e1 zu e2 + TEST_ASSERT_TRUE(istzugerlaubt_Koenig(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_Koenig(Brett, 4, 7, 4, 6, player)); // e8 zu e7 + TEST_ASSERT_TRUE(istzugerlaubt_Koenig(Brett, 4, 6, 4, 5, player)); // e7 zu e6 (Einnehmen von Figur) + + Schachbrettspeicher_freigeben(Brett); +} + +void test_istzugerlaubt_Koenig_IllegalMoves(void) { + char **Brett = Schachbrett_erstellen(); + Player player = PLAYER_WHITE; + + // Illegaler zug: König versucht sich 2 Felder zu bewegen + TEST_ASSERT_FALSE(istzugerlaubt_Koenig(Brett, 4, 0, 4, 2, player)); + + // Illegaler zug: König versucht sich auf besetztes Feld zu bewegen + TEST_ASSERT_FALSE(istzugerlaubt_Koenig(Brett, 4, 0, 3, 1, player)); + + Schachbrettspeicher_freigeben(Brett); +} +#endif // TEST From 30036b38ed835a1a851910a5e786d0b90c943488 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 05:32:49 +0000 Subject: [PATCH 06/13] Hardcode von print_Schachfeld, Anton Lohrey --- src/Schachbrett.c | 6 +++--- src/Schachbrett.h | 2 +- src/main.c | 2 +- test/test_Bauer.c | 2 +- test/test_Moving.c | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/Schachbrett.c b/src/Schachbrett.c index a4ba5ea..a707b25 100644 --- a/src/Schachbrett.c +++ b/src/Schachbrett.c @@ -46,9 +46,9 @@ char** Schachbrett_erstellen() { return Brett; } -void print_Schachfeld(char** Brett, int Reihen, int Spalten) { - for (int i = 0; i < Reihen; i++) { - for (int j = 0; j < Spalten; j++) { +void print_Schachfeld(char** Brett) { + for (int i = 0; i < 8; i++) { + for (int j = 0; j < 8; j++) { printf(" %c ", Brett[i][j]); } printf("\n"); diff --git a/src/Schachbrett.h b/src/Schachbrett.h index f5e8f99..980975d 100644 --- a/src/Schachbrett.h +++ b/src/Schachbrett.h @@ -2,7 +2,7 @@ #define SCHACHBRETT_H char** Schachbrett_erstellen(); -void print_Schachfeld(char** Brett, int Reihen, int Spalten); +void print_Schachfeld(char** Brett); void Schachbrettspeicher_freigeben(char** Brett); #endif // SCHACHBRETT_H diff --git a/src/main.c b/src/main.c index 5b6b7db..2c88941 100644 --- a/src/main.c +++ b/src/main.c @@ -8,7 +8,7 @@ int main() { int spieler = 0; char** Spielfeld = create_Schachfeld(x, y); while (checkmate() == 0){ - print_Schachfeld(Spielfeld, x, y); + print_Schachfeld(Spielfeld); if(spieler % 2 == 0){ choose_Figur('w', Spielfeld);//weiß diff --git a/test/test_Bauer.c b/test/test_Bauer.c index 567a1e4..657545b 100644 --- a/test/test_Bauer.c +++ b/test/test_Bauer.c @@ -48,7 +48,7 @@ void test_Bauer_Schlag_Bewegung(void) { brett[startY][startX] = 'P'; brett[endY][endX] = 'p'; - print_Schachfeld(brett,8,8); + print_Schachfeld(brett); TEST_ASSERT_FALSE(istzugerlaubt_Bauer( brett, startX, startY, endX, endY, player)); diff --git a/test/test_Moving.c b/test/test_Moving.c index 9a49832..fdf9a48 100644 --- a/test/test_Moving.c +++ b/test/test_Moving.c @@ -24,7 +24,7 @@ void test_Bauern_bewegen(void) { machezug( brett, startX, startY, endX, endY, player); - print_Schachfeld(brett,8,8); + print_Schachfeld(brett); TEST_ASSERT_EQUAL('P', brett[2][0]); TEST_ASSERT_EQUAL(' ', brett[1][0]); From f72563d84b896268f707779e01a37b04b0508cc8 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 06:53:30 +0000 Subject: [PATCH 07/13] Anfang Feldsicherheits-check + Test, Anton Lohrey --- src/Koenig.c | 29 ++++++++++++++++++++++++ src/Koenig.h | 9 ++++---- test/test_Feldsicherheit.c | 46 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 80 insertions(+), 4 deletions(-) create mode 100644 test/test_Feldsicherheit.c diff --git a/src/Koenig.c b/src/Koenig.c index 7de33e2..b912f9a 100644 --- a/src/Koenig.c +++ b/src/Koenig.c @@ -6,6 +6,35 @@ #include "Moving.h" #include "Koenig.h" +bool GreiftSpringerAn(char** Brett, int x, int y, Player player) { + int Springerzüge[8][2] = { + {2, 1}, {1, 2}, {-1, 2}, {-2, 1}, + {-2, -1}, {-1, -2}, {1, -2}, {2, -1} + }; + + for (int i = 0; i < 8; i++) { + int neuX = x + Springerzüge[i][0]; + int neuY = y + Springerzüge[i][1]; + if (neuX >= 0 && neuX < 8 && neuY >= 0 && neuY < 8) { + char Figur = Brett[neuY][neuX]; + if (player == PLAYER_WHITE && Figur == 'n') { + return true; + } else if (player == PLAYER_BLACK && Figur == 'N') { + return true; + } + } + } + return false; +} +bool istFeldUnsicher(char** Brett, int x, int y, Player player) { + + if (GreiftSpringerAn(Brett, x, y, player)) { + return true; + } + + return false; +} + bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player) { // Schauen ob der zug auf dem Spielbrett passiert if (endX < 0 || endX >= 8 || endY < 0 || endY >= 8) diff --git a/src/Koenig.h b/src/Koenig.h index c8d0328..f83b79c 100644 --- a/src/Koenig.h +++ b/src/Koenig.h @@ -1,6 +1,7 @@ -#ifndef Springer -#define Springer +#ifndef Koenig +#define Koenig #include "Spieler.h" - +bool GreiftSpringerAn(char** Brett, int x, int y, Player player); +bool istFeldUnsicher(char** Brett, int x, int y, Player player); bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player); -#endif // Springer +#endif // Koenig diff --git a/test/test_Feldsicherheit.c b/test/test_Feldsicherheit.c new file mode 100644 index 0000000..0b2b5a4 --- /dev/null +++ b/test/test_Feldsicherheit.c @@ -0,0 +1,46 @@ +#ifdef TEST +#include "unity.h" +#include +#include +#include +#include "Spieler.h" +#include "Koenig.h" + +char** ErstelleTestBrett() { + char** Brett = malloc(8 * sizeof(char*)); + for (int i = 0; i < 8; i++) { + Brett[i] = malloc(8 * sizeof(char)); + for (int j = 0; j < 8; j++) { + Brett[i][j] = ' '; //Erstelle komplett leeres Brett + } + } + return Brett; +} + +void freeTestBrett(char** Brett) { + for (int i = 0; i < 8; i++) { + free(Brett[i]); + } + free(Brett); +} + +void test_GreiftSpringerAn(void) { + char** Brett = ErstelleTestBrett(); + + // Plaziert ein schwarzen Springer (3,4) und testet 'Angriff' auf e3 (4,2) + Brett[4][3] = 'n'; + Player player = PLAYER_WHITE; + TEST_ASSERT_TRUE(GreiftSpringerAn(Brett, 4, 2, player)); + + // Plaziert ein weißen Springer (5,2) und testet 'Angriff' auf e5 (4,4) + Brett[2][5] = 'N'; + player = PLAYER_BLACK; + TEST_ASSERT_TRUE(GreiftSpringerAn(Brett, 4, 4, player)); + + // Testet Feld ohne Bedrohung + TEST_ASSERT_FALSE(GreiftSpringerAn(Brett, 0, 0, player)); + + freeTestBrett(Brett); +} +#endif // TEST + From 45112bd37a363bc613f48e7532d5f665d97ca497 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 07:13:03 +0000 Subject: [PATCH 08/13] Feldsicherheit Bauer + Test, Anton Lohrey --- src/Koenig.c | 25 +++++++++++++++++++++++++ src/Koenig.h | 1 + test/test_Feldsicherheit.c | 21 +++++++++++++++++++++ 3 files changed, 47 insertions(+) diff --git a/src/Koenig.c b/src/Koenig.c index b912f9a..3f7e7e1 100644 --- a/src/Koenig.c +++ b/src/Koenig.c @@ -6,6 +6,28 @@ #include "Moving.h" #include "Koenig.h" +bool GreiftBauerAn(char** Brett, int x, int y, Player player) { + // Checke für weißen Bauer + if (player == PLAYER_BLACK) { + if (y > 0 && x > 0 && Brett[y - 1][x - 1] == 'P') { // Linke Diagonale + return true; + } + if (y > 0 && x < 7 && Brett[y - 1][x + 1] == 'P') { // Rechte Diagonale + return true; + } + } + // Checke für schwarzen Bauer + if (player == PLAYER_WHITE) { + if (y < 7 && x > 0 && Brett[y + 1][x - 1] == 'p') { // Linke Diagonale + return true; + } + if (y < 7 && x < 7 && Brett[y + 1][x + 1] == 'p') { // Rechte Diagonale + return true; + } + } + return false; +} + bool GreiftSpringerAn(char** Brett, int x, int y, Player player) { int Springerzüge[8][2] = { {2, 1}, {1, 2}, {-1, 2}, {-2, 1}, @@ -31,6 +53,9 @@ bool istFeldUnsicher(char** Brett, int x, int y, Player player) { if (GreiftSpringerAn(Brett, x, y, player)) { return true; } + if (GreiftBauerAn(Brett, x, y, player)) { + return true; + } return false; } diff --git a/src/Koenig.h b/src/Koenig.h index f83b79c..e3d9657 100644 --- a/src/Koenig.h +++ b/src/Koenig.h @@ -1,6 +1,7 @@ #ifndef Koenig #define Koenig #include "Spieler.h" +bool GreiftBauerAn(char** Brett, int x, int y, Player player); bool GreiftSpringerAn(char** Brett, int x, int y, Player player); bool istFeldUnsicher(char** Brett, int x, int y, Player player); bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player); diff --git a/test/test_Feldsicherheit.c b/test/test_Feldsicherheit.c index 0b2b5a4..42644fe 100644 --- a/test/test_Feldsicherheit.c +++ b/test/test_Feldsicherheit.c @@ -24,6 +24,27 @@ void freeTestBrett(char** Brett) { free(Brett); } +void test_GreiftBauerAn(void) { + char** Brett = ErstelleTestBrett(); + + // Plaziert weißen Bauer auf d5 (3,4) und testet 'angriff' auf c6 (2,5) und e6 (4,5) + Brett[4][3] = 'P'; + Player player = PLAYER_BLACK; + TEST_ASSERT_TRUE(GreiftBauerAn(Brett, 2, 5, player)); + TEST_ASSERT_TRUE(GreiftBauerAn(Brett, 4, 5, player)); + + // Plaziert schwarzen Bauer auf e4 (4,3) und testet 'angriff' auf d3 (3,2) und f3 (5,2) + Brett[3][4] = 'p'; + player = PLAYER_WHITE; + TEST_ASSERT_TRUE(GreiftBauerAn(Brett, 3, 2, player)); + TEST_ASSERT_TRUE(GreiftBauerAn(Brett, 5, 2, player)); + + // Test ein Feld ohne Bedrohung + TEST_ASSERT_FALSE(GreiftBauerAn(Brett, 0, 0, player)); + + freeTestBrett(Brett); +} + void test_GreiftSpringerAn(void) { char** Brett = ErstelleTestBrett(); From 08441e30c74db18253304937fe6039e5e5fe2eca Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 07:46:35 +0000 Subject: [PATCH 09/13] Feldsicherheit Turm + Tests, Anton Lohrey --- src/Koenig.c | 48 ++++++++++++++++++++++++++++++++++++++ src/Koenig.h | 1 + test/test_Feldsicherheit.c | 26 +++++++++++++++++++++ 3 files changed, 75 insertions(+) diff --git a/src/Koenig.c b/src/Koenig.c index 3f7e7e1..751a032 100644 --- a/src/Koenig.c +++ b/src/Koenig.c @@ -28,6 +28,51 @@ bool GreiftBauerAn(char** Brett, int x, int y, Player player) { return false; } +bool GreiftTurmAn(char** Brett, int x, int y, Player player) { + char Turm = player == PLAYER_WHITE ? 'r' : 'R'; + + // Check Vertikal Hoch + for (int i = y - 1; i >= 0; i--) { + if (Brett[i][x] != ' ') { + if (Brett[i][x] == Turm) { + return true; + } + break; // Stoppt wenn irgendeine Figur gefunden wird + } + } + + // Vertikal Runter + for (int i = y + 1; i < 8; i++) { + if (Brett[i][x] != ' ') { + if (Brett[i][x] == Turm) { + return true; + } + break; + } + } + + // Horizontal Links + for (int j = x - 1; j >= 0; j--) { + if (Brett[y][j] != ' ') { + if (Brett[y][j] == Turm) { + return true; + } + break; + } + } + + // Horizontal Rechts + for (int j = x + 1; j < 8; j++) { + if (Brett[y][j] != ' ') { + if (Brett[y][j] == Turm) { + return true; + } + break; + } + } + return false; +} + bool GreiftSpringerAn(char** Brett, int x, int y, Player player) { int Springerzüge[8][2] = { {2, 1}, {1, 2}, {-1, 2}, {-2, 1}, @@ -56,6 +101,9 @@ bool istFeldUnsicher(char** Brett, int x, int y, Player player) { if (GreiftBauerAn(Brett, x, y, player)) { return true; } + if (GreiftTurmAn(Brett, x, y, player)) { + return true; + } return false; } diff --git a/src/Koenig.h b/src/Koenig.h index e3d9657..56e2d7a 100644 --- a/src/Koenig.h +++ b/src/Koenig.h @@ -2,6 +2,7 @@ #define Koenig #include "Spieler.h" bool GreiftBauerAn(char** Brett, int x, int y, Player player); +bool GreiftTurmAn(char** Brett, int x, int y, Player player); bool GreiftSpringerAn(char** Brett, int x, int y, Player player); bool istFeldUnsicher(char** Brett, int x, int y, Player player); bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player); diff --git a/test/test_Feldsicherheit.c b/test/test_Feldsicherheit.c index 42644fe..5bbd917 100644 --- a/test/test_Feldsicherheit.c +++ b/test/test_Feldsicherheit.c @@ -45,6 +45,32 @@ void test_GreiftBauerAn(void) { freeTestBrett(Brett); } +void test_GreiftTurmAn(void) { + char** Brett = ErstelleTestBrett(); + + // Plaziert weißen Turm auf d4 (3,3) und testet für Angriffe + Brett[3][3] = 'R'; + Player player = PLAYER_BLACK; + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 3, 0, player)); // Checkt vertikalen Angriff auf d1 + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 3, 7, player)); // Checkt vertikalen Angriff auf d8 + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 0, 3, player)); // Checkt horizontalen Angriff auf a4 + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 7, 3, player)); // Checkt horizontalen Angriff auf h4 + + // Plaziert schwarzen Turm auf e5 (4,4) und Tauscht Spieler zu weiß + Brett[3][3] = ' '; // Alten turm wegmachen + Brett[4][4] = 'r'; + player = PLAYER_WHITE; + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 4, 0, player)); // Checkt vertikalen Angriff auf e1 + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 4, 7, player)); // Checkt vertikalen Angriff auf e8 + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 0, 4, player)); // Checkt horizontalen Angriff auf a5 + TEST_ASSERT_TRUE(GreiftTurmAn(Brett, 7, 4, player)); // Checkt horizontalen Angriff auf h5 + + // Checkt sicheres Feld + TEST_ASSERT_FALSE(GreiftTurmAn(Brett, 0, 0, player)); + + freeTestBrett(Brett); +} + void test_GreiftSpringerAn(void) { char** Brett = ErstelleTestBrett(); From e53f13dd7381142ce613af23dbebac88d01399a4 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 17:46:50 +0000 Subject: [PATCH 10/13] =?UTF-8?q?Feldsicherheit=20L=C3=A4ufer=20+=20Tests,?= =?UTF-8?q?=20Anton=20Lohrey?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Koenig.c | 54 ++++++++++++++++++++++++++++++++++++-- src/Koenig.h | 1 + test/test_Feldsicherheit.c | 52 ++++++++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+), 2 deletions(-) diff --git a/src/Koenig.c b/src/Koenig.c index 751a032..4a39fb0 100644 --- a/src/Koenig.c +++ b/src/Koenig.c @@ -93,15 +93,65 @@ bool GreiftSpringerAn(char** Brett, int x, int y, Player player) { } return false; } + +bool GreiftLaeuferAn(char** Brett, int x, int y, Player player) { + char Laeufer = player == PLAYER_WHITE ? 'b' : 'B'; + + // Check oben Rechts + for (int i = x + 1, j = y - 1; i < 8 && j >= 0; i++, j--) { + if (Brett[j][i] != ' ') { + if (Brett[j][i] == Laeufer) { + return true; + } + break; + } + } + + // Check oben Links + for (int i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) { + if (Brett[j][i] != ' ') { + if (Brett[j][i] == Laeufer) { + return true; + } + break; + } + } + + // Check unten Rechts + for (int i = x + 1, j = y + 1; i < 8 && j < 8; i++, j++) { + if (Brett[j][i] != ' ') { + if (Brett[j][i] == Laeufer) { + return true; + } + break; + } + } + + // Check unten Links + for (int i = x - 1, j = y + 1; i >= 0 && j < 8; i--, j++) { + if (Brett[j][i] != ' ') { + if (Brett[j][i] == Laeufer) { + return true; + } + break; + } + } + + return false; +} + bool istFeldUnsicher(char** Brett, int x, int y, Player player) { if (GreiftSpringerAn(Brett, x, y, player)) { return true; } - if (GreiftBauerAn(Brett, x, y, player)) { + if (GreiftBauerAn(Brett, x, y, player)) { + return true; + } + if (GreiftTurmAn(Brett, x, y, player)) { return true; } - if (GreiftTurmAn(Brett, x, y, player)) { + if (GreiftLaeuferAn(Brett, x, y, player)) { return true; } diff --git a/src/Koenig.h b/src/Koenig.h index 56e2d7a..0b77adb 100644 --- a/src/Koenig.h +++ b/src/Koenig.h @@ -4,6 +4,7 @@ bool GreiftBauerAn(char** Brett, int x, int y, Player player); bool GreiftTurmAn(char** Brett, int x, int y, Player player); bool GreiftSpringerAn(char** Brett, int x, int y, Player player); +bool GreiftLaeuferAn(char** Brett, int x, int y, Player player); bool istFeldUnsicher(char** Brett, int x, int y, Player player); bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player); #endif // Koenig diff --git a/test/test_Feldsicherheit.c b/test/test_Feldsicherheit.c index 5bbd917..c4fb7ab 100644 --- a/test/test_Feldsicherheit.c +++ b/test/test_Feldsicherheit.c @@ -89,5 +89,57 @@ void test_GreiftSpringerAn(void) { freeTestBrett(Brett); } +void test_GreiftLaeuferAn(void) { + char** Brett = ErstelleTestBrett(); + + // Plaziert einen weißen Läufer auf c4 (2,3) und testet Angriffe + Brett[3][2] = 'B'; + + Player player = PLAYER_BLACK; + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 0, 1, player)); // Check unten Links + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 5, 0, player)); // Check oben Links + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 4, 5, player)); // Check unten Rechts + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 3, 2, player)); // Check oben Rechts + + // Plaziert einen schwarzen Läufer auf e5 (4,4) und testet Angriffe vom anderen spieler + Brett[2][3] = ' '; + Brett[4][4] = 'b'; + player = PLAYER_WHITE; + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 2, 2, player)); // Check unten Rechts + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 2, 6, player)); // Check oben Links + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 6, 6, player)); // Check unten Rechts + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 6, 2, player)); // Check oben Rechts + + // Check sicheres Feld + TEST_ASSERT_FALSE(GreiftLaeuferAn(Brett, 0, 1, player)); + + freeTestBrett(Brett); +} +void test_GreiftLaeuferAn(void) { + char** Brett = ErstelleTestBrett(); + + // Plaziert einen weißen Läufer auf c4 (2,3) und testet Angriffe + Brett[3][2] = 'B'; + + Player player = PLAYER_BLACK; + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 0, 1, player)); // Check unten Links + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 5, 0, player)); // Check oben Links + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 4, 5, player)); // Check unten Rechts + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 3, 2, player)); // Check oben Rechts + + // Plaziert einen schwarzen Läufer auf e5 (4,4) und testet Angriffe vom anderen spieler + Brett[2][3] = ' '; + Brett[4][4] = 'b'; + player = PLAYER_WHITE; + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 2, 2, player)); // Check unten Rechts + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 2, 6, player)); // Check oben Links + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 6, 6, player)); // Check unten Rechts + TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 6, 2, player)); // Check oben Rechts + + // Check sicheres Feld + TEST_ASSERT_FALSE(GreiftLaeuferAn(Brett, 0, 1, player)); + + freeTestBrett(Brett); +} #endif // TEST From c6431cd3d49f8772bd9d66fd69fdeff61a1b188c Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 19:21:27 +0000 Subject: [PATCH 11/13] Feldsicherheit Dame + Tests, Anton Lohrey --- src/Koenig.c | 22 ++++++++++++++++++++++ src/Koenig.h | 1 + test/test_Feldsicherheit.c | 35 +++++++++++++++-------------------- 3 files changed, 38 insertions(+), 20 deletions(-) diff --git a/src/Koenig.c b/src/Koenig.c index 4a39fb0..16aa2c2 100644 --- a/src/Koenig.c +++ b/src/Koenig.c @@ -157,6 +157,28 @@ bool istFeldUnsicher(char** Brett, int x, int y, Player player) { return false; } +bool GreiftDameAn(char** Brett, int x, int y, Player player) { + char Dame = player == PLAYER_WHITE ? 'q' : 'Q'; + + //Schaut in alle Richtungen + int Richtungen[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}}; + for (int i = 0; i < 8; i++) { + int dx = Richtungen[i][0]; + int dy = Richtungen[i][1]; + int nx = x + dx; + int ny = y + dy; + while (nx >= 0 && nx < 8 && ny >= 0 && ny < 8) { + if (Brett[ny][nx] != ' ') { + if (Brett[ny][nx] == Dame) return true; + break; + } + nx += dx; + ny += dy; + } + } + + return false; +} bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player) { // Schauen ob der zug auf dem Spielbrett passiert diff --git a/src/Koenig.h b/src/Koenig.h index 0b77adb..b66f9d1 100644 --- a/src/Koenig.h +++ b/src/Koenig.h @@ -5,6 +5,7 @@ bool GreiftBauerAn(char** Brett, int x, int y, Player player); bool GreiftTurmAn(char** Brett, int x, int y, Player player); bool GreiftSpringerAn(char** Brett, int x, int y, Player player); bool GreiftLaeuferAn(char** Brett, int x, int y, Player player); +bool GreiftDameAn(char** Brett, int x, int y, Player player); bool istFeldUnsicher(char** Brett, int x, int y, Player player); bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player); #endif // Koenig diff --git a/test/test_Feldsicherheit.c b/test/test_Feldsicherheit.c index c4fb7ab..15639e2 100644 --- a/test/test_Feldsicherheit.c +++ b/test/test_Feldsicherheit.c @@ -115,31 +115,26 @@ void test_GreiftLaeuferAn(void) { freeTestBrett(Brett); } -void test_GreiftLaeuferAn(void) { - char** Brett = ErstelleTestBrett(); - - // Plaziert einen weißen Läufer auf c4 (2,3) und testet Angriffe - Brett[3][2] = 'B'; +void test_GreiftDameAn(void) { + char** Brett = ErstelleTestBrett(); + // Plaziert weiße dame auf d4 + Brett[3][3] = 'Q'; Player player = PLAYER_BLACK; - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 0, 1, player)); // Check unten Links - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 5, 0, player)); // Check oben Links - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 4, 5, player)); // Check unten Rechts - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 3, 2, player)); // Check oben Rechts - // Plaziert einen schwarzen Läufer auf e5 (4,4) und testet Angriffe vom anderen spieler - Brett[2][3] = ' '; - Brett[4][4] = 'b'; - player = PLAYER_WHITE; - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 2, 2, player)); // Check unten Rechts - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 2, 6, player)); // Check oben Links - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 6, 6, player)); // Check unten Rechts - TEST_ASSERT_TRUE(GreiftLaeuferAn(Brett, 6, 2, player)); // Check oben Rechts + // Test Oben/Seitlich + TEST_ASSERT_TRUE(GreiftDameAn(Brett, 3, 7, player)); // d8 + TEST_ASSERT_TRUE(GreiftDameAn(Brett, 0, 3, player)); // a4 - // Check sicheres Feld - TEST_ASSERT_FALSE(GreiftLaeuferAn(Brett, 0, 1, player)); + // Test Diagonal + TEST_ASSERT_TRUE(GreiftDameAn(Brett, 1, 5, player)); // b6 - freeTestBrett(Brett); + // Plaziert eigene Figur zum blocken + Brett[4][3] = 'P'; + // Test blockiert von eigener Figur + TEST_ASSERT_FALSE(GreiftDameAn(Brett, 3, 7, player)); // d8 blocked + + freeTestBrett(Brett); } #endif // TEST From b44ece9116e9f407e626601eca8db6c2341f49d4 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 19:54:47 +0000 Subject: [PATCH 12/13] =?UTF-8?q?Feldsicherheit=20K=C3=B6nig=20+=20Tests,?= =?UTF-8?q?=20Anton=20Lohrey?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Koenig.c | 64 ++++++++++++++++++++++++++++---------- src/Koenig.h | 1 + test/test_Feldsicherheit.c | 26 ++++++++++++++++ 3 files changed, 74 insertions(+), 17 deletions(-) diff --git a/src/Koenig.c b/src/Koenig.c index 16aa2c2..ae21665 100644 --- a/src/Koenig.c +++ b/src/Koenig.c @@ -140,23 +140,6 @@ bool GreiftLaeuferAn(char** Brett, int x, int y, Player player) { return false; } -bool istFeldUnsicher(char** Brett, int x, int y, Player player) { - - if (GreiftSpringerAn(Brett, x, y, player)) { - return true; - } - if (GreiftBauerAn(Brett, x, y, player)) { - return true; - } - if (GreiftTurmAn(Brett, x, y, player)) { - return true; - } - if (GreiftLaeuferAn(Brett, x, y, player)) { - return true; - } - - return false; -} bool GreiftDameAn(char** Brett, int x, int y, Player player) { char Dame = player == PLAYER_WHITE ? 'q' : 'Q'; @@ -179,6 +162,53 @@ bool GreiftDameAn(char** Brett, int x, int y, Player player) { return false; } +bool GreiftKoenigAn(char** Brett, int x, int y, Player player) { + // Mögliche Züge eines Königs + int koenigZuege[8][2] = { + {1, 0}, {-1, 0}, + {0, 1}, {0, -1}, + {1, 1}, {1, -1}, + {-1, 1}, {-1, -1} + }; + char gegnerischerKoenig = (player == PLAYER_WHITE) ? 'k' : 'K'; + + for (int i = 0; i < 8; i++) { + int neuX = x + koenigZuege[i][0]; + int neuY = y + koenigZuege[i][1]; + if (neuX >= 0 && neuX < 8 && neuY >= 0 && neuY < 8) { + if (Brett[neuY][neuX] == gegnerischerKoenig) { + return true; + } + } + } + + return false; +} + +bool istFeldUnsicher(char** Brett, int x, int y, Player player) { + + if (GreiftSpringerAn(Brett, x, y, player)) { + return true; + } + if (GreiftBauerAn(Brett, x, y, player)) { + return true; + } + if (GreiftTurmAn(Brett, x, y, player)) { + return true; + } + if (GreiftLaeuferAn(Brett, x, y, player)) { + return true; + } + if (GreiftDameAn(Brett, x, y, player)) { + return true; + } + if (GreiftKoenigAn(Brett, x, y, player)) { + return true; + } + + return false; +} + bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player) { // Schauen ob der zug auf dem Spielbrett passiert diff --git a/src/Koenig.h b/src/Koenig.h index b66f9d1..7dd9444 100644 --- a/src/Koenig.h +++ b/src/Koenig.h @@ -6,6 +6,7 @@ bool GreiftTurmAn(char** Brett, int x, int y, Player player); bool GreiftSpringerAn(char** Brett, int x, int y, Player player); bool GreiftLaeuferAn(char** Brett, int x, int y, Player player); bool GreiftDameAn(char** Brett, int x, int y, Player player); +bool GreiftKoenigAn(char** Brett, int x, int y, Player player); bool istFeldUnsicher(char** Brett, int x, int y, Player player); bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player); #endif // Koenig diff --git a/test/test_Feldsicherheit.c b/test/test_Feldsicherheit.c index 15639e2..e5b1326 100644 --- a/test/test_Feldsicherheit.c +++ b/test/test_Feldsicherheit.c @@ -136,5 +136,31 @@ void test_GreiftDameAn(void) { freeTestBrett(Brett); } +void test_GreiftKoenigAn(void) { + char** Brett = ErstelleTestBrett(); + + // Plaziert schwarzen König auf e5 (4,4) und einen weißen auf d4 (3,3) + Brett[4][4] = 'k'; + Brett[3][3] = 'K'; + print_Schachfeld(Brett); + // Test ob der schwarze könig Felder angreifen kann + TEST_ASSERT_TRUE(GreiftKoenigAn(Brett, 3, 4, PLAYER_WHITE)); // d5 + TEST_ASSERT_TRUE(GreiftKoenigAn(Brett, 5, 4, PLAYER_WHITE)); // f5 + TEST_ASSERT_TRUE(GreiftKoenigAn(Brett, 4, 3, PLAYER_WHITE)); // e4 + + // Test ob der weiße könig Felder angreifen kann + TEST_ASSERT_TRUE(GreiftKoenigAn(Brett, 2, 3, PLAYER_BLACK)); // c4 + TEST_ASSERT_TRUE(GreiftKoenigAn(Brett, 3, 2, PLAYER_BLACK)); // d3 + TEST_ASSERT_TRUE(GreiftKoenigAn(Brett, 4, 3, PLAYER_BLACK)); // e4 + + // Tests für nicht angegriffene Felder + TEST_ASSERT_FALSE(GreiftKoenigAn(Brett, 2, 4, PLAYER_WHITE)); + TEST_ASSERT_FALSE(GreiftKoenigAn(Brett, 6, 4, PLAYER_WHITE)); + TEST_ASSERT_FALSE(GreiftKoenigAn(Brett, 1, 3, PLAYER_BLACK)); + TEST_ASSERT_FALSE(GreiftKoenigAn(Brett, 5, 3, PLAYER_BLACK)); + TEST_ASSERT_FALSE(GreiftKoenigAn(Brett, 3, 1, PLAYER_BLACK)); + + freeTestBrett(Brett); +} #endif // TEST From 4f9f6660992a8eb16cc82f9e3ba1ef768731e5b3 Mon Sep 17 00:00:00 2001 From: fdai7492 Date: Fri, 2 Feb 2024 20:38:22 +0000 Subject: [PATCH 13/13] Feldsicherheit fertig + tests, Anton Lohrey --- src/Koenig.c | 3 ++- test/test_Feldsicherheit.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/src/Koenig.c b/src/Koenig.c index ae21665..dd97a02 100644 --- a/src/Koenig.c +++ b/src/Koenig.c @@ -229,7 +229,8 @@ bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int en if (player == PLAYER_BLACK && islower(endPosition)) return false; - // mehr checks noch benötigt + if (istFeldUnsicher(Brett, endX, endY, player)) + return false; return true; } diff --git a/test/test_Feldsicherheit.c b/test/test_Feldsicherheit.c index e5b1326..644fdc5 100644 --- a/test/test_Feldsicherheit.c +++ b/test/test_Feldsicherheit.c @@ -162,5 +162,34 @@ void test_GreiftKoenigAn(void) { freeTestBrett(Brett); } +void test_istFeldUnsicher(void) { + char** Brett = ErstelleTestBrett(); + Brett[4][4] = 'p'; + print_Schachfeld(Brett); + TEST_ASSERT_TRUE(istFeldUnsicher(Brett, 5, 3, player)); + TEST_ASSERT_FALSE(istFeldUnsicher(Brett, 0, 0, player)); + + Brett[4][4] = ' '; + Brett[0][1] = 'N'; + player = PLAYER_BLACK; + + TEST_ASSERT_TRUE(istFeldUnsicher(Brett, 2, 2, player)); + TEST_ASSERT_FALSE(istFeldUnsicher(Brett, 0, 0, player)); + + Brett[0][1] = ' '; + Brett[7][0] = 'r'; + player = PLAYER_WHITE; + + TEST_ASSERT_TRUE(istFeldUnsicher(Brett, 0, 0, player)); + TEST_ASSERT_FALSE(istFeldUnsicher(Brett, 4, 4, player)); + + Brett[7][0] = ' '; + Brett[3][3] = 'Q'; + player = PLAYER_BLACK; + TEST_ASSERT_TRUE(istFeldUnsicher(Brett, 7, 7, player)); + TEST_ASSERT_TRUE(istFeldUnsicher(Brett, 3, 0, player)); + + freeTestBrett(Brett); +} #endif // TEST