2023-2-WS_group_project_taktikmeister/src/Koenig.c

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <ctype.h>
#include "spieler.h"
#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 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},
        {-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 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 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 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
    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;
}