echiquier.cpp

Go to the documentation of this file.

#include "echiquier.hpp"
#include "pieces/tour.hpp"
#include "pieces/cavalier.hpp"
#include "pieces/fou.hpp"
#include "pieces/reine.hpp"
#include "pieces/roi.hpp"
#include "pieces/pion.hpp"
#include <iostream>
#include <algorithm>
 
class Piece;
 
Echiquier::Echiquier()
{
    for (auto & row : board)
    {
        for (auto & col : row)
        {
            col = nullptr;
        }
    }
 
    is_check = false;
 
    pieces[WHITE] = {
        new Tour("\u2656", "R", WHITE, 0, Square(0, 0), this),
        new Cavalier("\u2658", "N", WHITE, 1, Square(0, 1), this),
        new Fou("\u2657", "B", WHITE, 2, Square(0, 2), this),
        new Reine("\u2655", "Q", WHITE, 3, Square(0, 3), this),
        new Roi("\u2654", "K", WHITE, 4, Square(0, 4), this),
        new Fou("\u2657", "B", WHITE, 5, Square(0, 5), this),
        new Cavalier("\u2658", "N", WHITE, 6, Square(0, 6), this),
        new Tour("\u2656", "R", WHITE, 7, Square(0, 7), this)};
 
    pieces[BLACK] = {
        new Tour("\u265C", "R", BLACK, 0, Square(7, 0), this),
        new Cavalier("\u265E", "N", BLACK, 1, Square(7, 1), this),
        new Fou("\u265D", "B", BLACK, 2, Square(7, 2), this),
        new Reine("\u265B", "Q", BLACK, 3, Square(7, 3), this),
        new Roi("\u265A", "K", BLACK, 4, Square(7, 4), this),
        new Fou("\u265D", "B", BLACK, 5, Square(7, 5), this),
        new Cavalier("\u265E", "N", BLACK, 6, Square(7, 6), this),
        new Tour("\u265C", "R", BLACK, 7, Square(7, 7), this)};
 
    for (int i = 0; i < 8; i++)
    {
        pieces[WHITE].push_back(new Pion("\u2659", "P", WHITE, 8 + i, Square(1, i), this));
        pieces[BLACK].push_back(new Pion("\u265F", "P", BLACK, 8 + i, Square(6, i), this));
    }
}
 
bool Echiquier::castling(Color player, bool big){
    Roi* roi = dynamic_cast<Roi *>(get_piece_from_id(4, player));
    Tour* tour = dynamic_cast<Tour *>(get_piece_from_id(big ? 0 : 7, player));
    Square roiPos = roi->get_pos();
    Square tourPos = tour->get_pos();
    if(check_castling(player, big)){
        set_pos(nullptr, roiPos);
        set_pos(nullptr, tourPos);
        if(big){
            set_pos(roi, Square(player == WHITE ? 0 : 7, 2));
            set_pos(tour, Square(player == WHITE ? 0 : 7, 3));
        }else{
            set_pos(roi, Square(player == WHITE ? 0 : 7, 6));
            set_pos(tour, Square(player == WHITE ? 0 : 7, 5));
        }
        return true;
    }
    return false;
}
 
bool Echiquier::check_castling(Color player, bool big) const {
    Roi* roi = dynamic_cast<Roi*>(get_piece_from_id(4, player));
    Tour* tour = dynamic_cast<Tour*>(get_piece_from_id(big ? 0 : 7, player));
    if(is_check) return false;
    if(big){
        if(get_piece(Square(player == WHITE ? 0 : 7, 1)) == nullptr
        && get_piece(Square(player == WHITE ? 0 : 7, 2)) == nullptr
        && get_piece(Square(player == WHITE ? 0 : 7, 3)) == nullptr
        && !check_check(player, Square(player == WHITE ? 0 : 7, 1))
        && !check_check(player, Square(player == WHITE ? 0 : 7, 2))
        && !check_check(player, Square(player == WHITE ? 0 : 7, 3))) {
            return !roi->get_has_moved() && !tour->get_has_moved();
        }
        return false;
    }
 
    if(get_piece(Square(player == WHITE ? 0 : 7, 5)) == nullptr
        && get_piece(Square(player == WHITE ? 0 : 7, 6)) == nullptr
        && !check_check(player, Square(player == WHITE ? 0 : 7, 5))
        && !check_check(player, Square(player == WHITE ? 0 : 7, 6))) {
        return !roi->get_has_moved() && !tour->get_has_moved();
        }
    return false;
}
 
Piece* Echiquier::get_piece_from_id(int id, Color player) const {
    auto &vec = pieces[player];
    auto it = std::find_if(vec.begin(), vec.end(), [id](const Piece* piece) {
        return piece->get_id() == id;
    });
    if(it != vec.end()) return *it;
    return nullptr;
}
 
bool Echiquier::check_check(Color player, Square pos, Piece* exclude) const {
    for(int row = 0; row < 8; row++){
        for(int col = 0; col < 8; col++){
            Piece* piece = get_piece(Square(row, col));
            if(piece == nullptr) continue;
            if(piece->get_color() == player) continue;
            if(piece->est_menace(Square(row,col), pos)){
                return true;
            } 
        }
    }
 
    return false;
}
 
std::string Echiquier::canonical_position() const
{
    std::string output;
    for (int row = 0; row <= 7; row++)
    {
        for (int col = 0; col <= 7; col++)
        {
            auto piece = get_piece(Square(row, col));
            output += (piece == nullptr ? "" : piece->canonical(true, true)) + ",";
        }
    }
    return output;
}
 
void Echiquier::print_board() const
{
    std::cout << "   a     b     c     d     e     f     g     h   " << std::endl;
    std::cout << "┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐" << std::endl;
 
    for (int row = 7; row >= 0; row--)
    {
        if (row != 7) std::cout << "├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤" << std::endl;
        std::cout << "│";
        for (int col = 0; col <= 7; col++)
        {
            Piece *piece = get_piece(Square(row, col));
            std::cout << "  " << ((piece == nullptr) ? " " : piece->get_name()) << "  │";
        }
        std::cout << " " << row + 1 << std::endl;
    }
 
    std::cout << "└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘" << std::endl;
}
 
bool Echiquier::check_move(Square from, Square to, Color player) {
 
    Piece *piece = get_piece(from);
    if (piece == nullptr) return false;
    if (!piece->est_mouvement_legal(from, to)) return false;
 
    bool flag = true;
    // On copie l'échiquier actuel dans un autre échiquier
    Piece *old_board[8][8];
 
    for(int i = 0; i < 8; i++){
        std::copy_n(board[i], 8, old_board[i]);
    }
 
    set_pos(nullptr, from);
    set_pos(piece, to);
 
    // On vérifie si le roi va être mis en échec
    Roi* roi_player = dynamic_cast<Roi*>(get_piece_from_id(4, player));
 
    if(roi_player != nullptr) {
        Square pos_roi = roi_player->get_pos();
        if(check_check(player, pos_roi)){
            flag = false;
        }
    }
 
    // On remet l'échiquier à sa situation d'avant
 
    piece->set_pos(from);
    for(int i = 0; i < 8; i++){
        std::copy_n(old_board[i], 8, board[i]);
    }
 
    return flag;
}
 
bool Echiquier::check_check_mate(Color player) {
    return check_stalemate(player) && is_check;
}
 
bool Echiquier::check_stalemate(Color player) {
    auto vect = pieces[player];
    for (Piece *piece : vect) {
        if(!piece->get_is_active()) continue;
        for (int i = 0; i < 8; ++i) {
            for (int j = 0; j < 8; ++j) {
                if (check_move(piece->get_pos(), Square(i,j), player)) {
                    return false;
                }
            }
        }
    }
 
    return true;
}
 
 
bool Echiquier::move(Square from, Square to, Color player)
{
    Piece *piece = get_piece(from);
    Piece *old_piece = get_piece(to);
 
    if (piece == nullptr) return false;
    if (!check_move(from, to, player)) return false;
 
    set_pos(nullptr, from);
    set_pos(piece, to);
 
    piece->move_event(from);
 
    // Le roi de celui qui joue n'est plus en échec après avoir joué son coup
    Roi* roi_player = dynamic_cast<Roi*>(get_piece_from_id(4, player));
 
    if (roi_player != nullptr && is_check) {
        roi_player->set_is_checked(false);
        set_is_check(false);
    }
 
    // On vérifie si le roi ennemi est mis en échec.
    Roi* roi_ennemi = dynamic_cast<Roi*>(get_piece_from_id(4, player == WHITE ? BLACK : WHITE));
    if (check_check(player == WHITE ? BLACK : WHITE, roi_ennemi->get_pos())) {
        roi_ennemi->set_is_checked(true);
        set_is_check(true);
    }
 
    // On mange la pièce s'il y en avait une
    if (old_piece != nullptr) old_piece->set_is_active(false);
    moves.emplace_back(*piece, from, to);
    return true;
}
 
void Echiquier::setup()
{
    for (auto piece : pieces[WHITE]) set_pos(piece, piece->get_pos());
    for (auto piece : pieces[BLACK]) set_pos(piece, piece->get_pos());
}
 
Piece *Echiquier::get_piece(Square pos) const
{
    int row, col;
    pos.get_row_col(row, col);
    return board[7 - row][col];
}
 
void Echiquier::set_pos(Piece *piece, Square pos)
{
    int row, col;
    pos.get_row_col(row, col);
    board[7 - row][col] = piece;
    if(piece == nullptr) return;
    piece->set_pos(pos);
}
 
Echiquier::~Echiquier()
{
    for (Piece *piece : pieces[WHITE]) delete piece;
    for (Piece *piece : pieces[BLACK]) delete piece;
}
 
bool Echiquier::promote(Pion *pion, const std::string& type)
{
    auto &vect = pieces[pion->get_color()];
    if(type == "N"){
        auto new_piece = new Cavalier(
            pion->get_color() == WHITE ? "\u2658" : "\u265E",
            "N",
            pion->get_color(),
            pion->get_id() + 8,
            pion->get_pos(),
            this
        );
        new_piece->set_has_moved(true);
        vect.push_back(new_piece);
        set_pos(new_piece, pion->get_pos());
    } 
    if(type == "Q"){
        auto new_piece = new Reine(
            pion->get_color() == WHITE ? "\u2655" : "\u265B",
            "Q",
            pion->get_color(),
            pion->get_id() + 8,
            pion->get_pos(),
            this
        );
        new_piece->set_has_moved(true);
        vect.push_back(new_piece);
        set_pos(new_piece, pion->get_pos());
    }
    if(type == "B"){ 
        auto new_piece = new Fou(
            pion->get_color() == WHITE ? "\u2657" : "\u265D",
            "B",
            pion->get_color(),
            pion->get_id() + 8,
            pion->get_pos(),
            this
        );
        new_piece->set_has_moved(true);
        vect.push_back(new_piece);
        set_pos(new_piece, pion->get_pos());
    }
    if(type == "R") { 
        auto new_piece = new Tour(
            pion->get_color() == WHITE ? "\u2656" : "\u265C",
            "R",
            pion->get_color(),
            pion->get_id() + 8,
            pion->get_pos(),
            this
        );
        new_piece->set_has_moved(true);
        vect.push_back(new_piece);
        set_pos(new_piece, pion->get_pos());
    }
    else return false;
 
    pion->set_is_active(false);
    return true;
}
 
const std::list<Move>& Echiquier::get_moves() const {
    return moves;
}