You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

235 lines
6.1 KiB

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4. #include <ctype.h>
  5. #include "spieler.h"
  6. #include "Moving.h"
  7. #include "Koenig.h"
  8. bool GreiftBauerAn(char** Brett, int x, int y, Player player) {
  9. // Checke für weißen Bauer
  10. if (player == PLAYER_BLACK) {
  11. if (y > 0 && x > 0 && Brett[y - 1][x - 1] == 'P') { // Linke Diagonale
  12. return true;
  13. }
  14. if (y > 0 && x < 7 && Brett[y - 1][x + 1] == 'P') { // Rechte Diagonale
  15. return true;
  16. }
  17. }
  18. // Checke für schwarzen Bauer
  19. if (player == PLAYER_WHITE) {
  20. if (y < 7 && x > 0 && Brett[y + 1][x - 1] == 'p') { // Linke Diagonale
  21. return true;
  22. }
  23. if (y < 7 && x < 7 && Brett[y + 1][x + 1] == 'p') { // Rechte Diagonale
  24. return true;
  25. }
  26. }
  27. return false;
  28. }
  29. bool GreiftTurmAn(char** Brett, int x, int y, Player player) {
  30. char Turm = player == PLAYER_WHITE ? 'r' : 'R';
  31. // Check Vertikal Hoch
  32. for (int i = y - 1; i >= 0; i--) {
  33. if (Brett[i][x] != ' ') {
  34. if (Brett[i][x] == Turm) {
  35. return true;
  36. }
  37. break; // Stoppt wenn irgendeine Figur gefunden wird
  38. }
  39. }
  40. // Vertikal Runter
  41. for (int i = y + 1; i < 8; i++) {
  42. if (Brett[i][x] != ' ') {
  43. if (Brett[i][x] == Turm) {
  44. return true;
  45. }
  46. break;
  47. }
  48. }
  49. // Horizontal Links
  50. for (int j = x - 1; j >= 0; j--) {
  51. if (Brett[y][j] != ' ') {
  52. if (Brett[y][j] == Turm) {
  53. return true;
  54. }
  55. break;
  56. }
  57. }
  58. // Horizontal Rechts
  59. for (int j = x + 1; j < 8; j++) {
  60. if (Brett[y][j] != ' ') {
  61. if (Brett[y][j] == Turm) {
  62. return true;
  63. }
  64. break;
  65. }
  66. }
  67. return false;
  68. }
  69. bool GreiftSpringerAn(char** Brett, int x, int y, Player player) {
  70. int Springerzüge[8][2] = {
  71. {2, 1}, {1, 2}, {-1, 2}, {-2, 1},
  72. {-2, -1}, {-1, -2}, {1, -2}, {2, -1}
  73. };
  74. for (int i = 0; i < 8; i++) {
  75. int neuX = x + Springerzüge[i][0];
  76. int neuY = y + Springerzüge[i][1];
  77. if (neuX >= 0 && neuX < 8 && neuY >= 0 && neuY < 8) {
  78. char Figur = Brett[neuY][neuX];
  79. if (player == PLAYER_WHITE && Figur == 'n') {
  80. return true;
  81. } else if (player == PLAYER_BLACK && Figur == 'N') {
  82. return true;
  83. }
  84. }
  85. }
  86. return false;
  87. }
  88. bool GreiftLaeuferAn(char** Brett, int x, int y, Player player) {
  89. char Laeufer = player == PLAYER_WHITE ? 'b' : 'B';
  90. // Check oben Rechts
  91. for (int i = x + 1, j = y - 1; i < 8 && j >= 0; i++, j--) {
  92. if (Brett[j][i] != ' ') {
  93. if (Brett[j][i] == Laeufer) {
  94. return true;
  95. }
  96. break;
  97. }
  98. }
  99. // Check oben Links
  100. for (int i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {
  101. if (Brett[j][i] != ' ') {
  102. if (Brett[j][i] == Laeufer) {
  103. return true;
  104. }
  105. break;
  106. }
  107. }
  108. // Check unten Rechts
  109. for (int i = x + 1, j = y + 1; i < 8 && j < 8; i++, j++) {
  110. if (Brett[j][i] != ' ') {
  111. if (Brett[j][i] == Laeufer) {
  112. return true;
  113. }
  114. break;
  115. }
  116. }
  117. // Check unten Links
  118. for (int i = x - 1, j = y + 1; i >= 0 && j < 8; i--, j++) {
  119. if (Brett[j][i] != ' ') {
  120. if (Brett[j][i] == Laeufer) {
  121. return true;
  122. }
  123. break;
  124. }
  125. }
  126. return false;
  127. }
  128. bool GreiftDameAn(char** Brett, int x, int y, Player player) {
  129. char Dame = player == PLAYER_WHITE ? 'q' : 'Q';
  130. //Schaut in alle Richtungen
  131. int Richtungen[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}};
  132. for (int i = 0; i < 8; i++) {
  133. int dx = Richtungen[i][0];
  134. int dy = Richtungen[i][1];
  135. int nx = x + dx;
  136. int ny = y + dy;
  137. while (nx >= 0 && nx < 8 && ny >= 0 && ny < 8) {
  138. if (Brett[ny][nx] != ' ') {
  139. if (Brett[ny][nx] == Dame) return true;
  140. break;
  141. }
  142. nx += dx;
  143. ny += dy;
  144. }
  145. }
  146. return false;
  147. }
  148. bool GreiftKoenigAn(char** Brett, int x, int y, Player player) {
  149. // Mögliche Züge eines Königs
  150. int koenigZuege[8][2] = {
  151. {1, 0}, {-1, 0},
  152. {0, 1}, {0, -1},
  153. {1, 1}, {1, -1},
  154. {-1, 1}, {-1, -1}
  155. };
  156. char gegnerischerKoenig = (player == PLAYER_WHITE) ? 'k' : 'K';
  157. for (int i = 0; i < 8; i++) {
  158. int neuX = x + koenigZuege[i][0];
  159. int neuY = y + koenigZuege[i][1];
  160. if (neuX >= 0 && neuX < 8 && neuY >= 0 && neuY < 8) {
  161. if (Brett[neuY][neuX] == gegnerischerKoenig) {
  162. return true;
  163. }
  164. }
  165. }
  166. return false;
  167. }
  168. bool istFeldUnsicher(char** Brett, int x, int y, Player player) {
  169. if (GreiftSpringerAn(Brett, x, y, player)) {
  170. return true;
  171. }
  172. if (GreiftBauerAn(Brett, x, y, player)) {
  173. return true;
  174. }
  175. if (GreiftTurmAn(Brett, x, y, player)) {
  176. return true;
  177. }
  178. if (GreiftLaeuferAn(Brett, x, y, player)) {
  179. return true;
  180. }
  181. if (GreiftDameAn(Brett, x, y, player)) {
  182. return true;
  183. }
  184. if (GreiftKoenigAn(Brett, x, y, player)) {
  185. return true;
  186. }
  187. return false;
  188. }
  189. bool istzugerlaubt_Koenig(char** Brett, int startX, int startY, int endX, int endY, Player player) {
  190. // Schauen ob der zug auf dem Spielbrett passiert
  191. if (endX < 0 || endX >= 8 || endY < 0 || endY >= 8)
  192. return false;
  193. // Berechnung des unterschieds der start und endpositionen
  194. int dx = abs(endX - startX);
  195. int dy = abs(endY - startY);
  196. // Schauen ob sich nur ein feld bewegt wird
  197. if (dx > 1 || dy > 1) return false;
  198. // Nicht auf befreundete Figuren bewegen
  199. char endPosition = Brett[endY][endX];
  200. if (player == PLAYER_WHITE && isupper(endPosition))
  201. return false;
  202. if (player == PLAYER_BLACK && islower(endPosition))
  203. return false;
  204. // mehr checks noch benötigt
  205. return true;
  206. }