a56fb4d60f
Still struggling to understand all these concepts, and I will admit to using ChatGPT to try and explain where I was going wrong which did help quite a bit. But if I get this right it will be much more robust and less "fragile" as they say.
403 lines
No EOL
15 KiB
C++
403 lines
No EOL
15 KiB
C++
// © 2025 A.M. Rowsell <amr@frzn.dev>
|
|
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
// This Source Code Form is "Incompatible With Secondary Licenses", as
|
|
// defined by the Mozilla Public License, v. 2.0.
|
|
|
|
#include "inc/Piece.hpp"
|
|
#include "inc/Board.hpp"
|
|
|
|
Piece::~Piece() {
|
|
return;
|
|
}
|
|
|
|
// TODO: Add operator overload for << to allow easy printing
|
|
// TODO: Test getPieceAt() function to see if it works as intended
|
|
|
|
// because the Piece class is instantiated in another class using
|
|
// unique_ptr, non-pure virtual functions apparently *must*
|
|
// have definitions, or the linker freaks out
|
|
// so this is just a stub that does nothing. it doesn't matter
|
|
// because only the derived class versions should be called.
|
|
|
|
std::vector<Move> Piece::getLegalMoves(const Square &from, Board &board) const {
|
|
std::vector<Move> moveList;
|
|
return moveList;
|
|
}
|
|
|
|
bool Piece::finalMoveChecks(std::vector<Move> *moveList, Board &board) {
|
|
// This function needs to do the final checks before declaring a move legal
|
|
// Check to see if the piece that is being moves is currently blocking check
|
|
// Check to see if a castle is trying to go through check or out of check
|
|
// Check if it's a piece trying to capture the King (though this shouldn't happen normally)
|
|
return true;
|
|
}
|
|
|
|
// *INDENT-OFF*
|
|
//
|
|
// ## #
|
|
// #
|
|
// # ## ## # ## ## #
|
|
// # # # # # # #
|
|
// ## # # # # #
|
|
// # # # # # # #
|
|
// ## ## ##### ### ## ###
|
|
// #
|
|
// ###
|
|
// *INDENT-ON*
|
|
bool King::checkForCheck(Board &board) const {
|
|
std::vector<std::vector<int>> kingVulnerable = {
|
|
{-1, 0}, // Up
|
|
{-1, -1}, // up-left
|
|
{-1, 1}, // up-right
|
|
{1, 0}, // Down
|
|
{1, -1}, // down-left
|
|
{1, 1}, // down-right
|
|
{0, -1}, // Left
|
|
{0, 1}, // Right
|
|
{-1, -2}, // 1
|
|
{-1, 2}, // 2
|
|
{-2, -1}, // 3
|
|
{-2, 1}, // 4
|
|
{1, -2}, // 5
|
|
{1, 2}, // 6
|
|
{2, -1}, // 7
|
|
{2, 1} // 8
|
|
};
|
|
// locate our King
|
|
return inCheck;
|
|
}
|
|
|
|
std::vector<Move> King::getLegalMoves(const Square &from, Board &board) const {
|
|
std::vector<Move> moveList;
|
|
std::vector<std::vector<int>> directions = {
|
|
{-1, 0}, // Up
|
|
{-1, -1}, // up-left
|
|
{-1, 1}, // up-right
|
|
{1, 0}, // Down
|
|
{1, -1}, // down-left
|
|
{1, 1}, // down-right
|
|
{0, -1}, // Left
|
|
{0, 1} // Right
|
|
};
|
|
for(auto &dir : directions) {
|
|
// establish r/f for square to check
|
|
int r = from.rank + dir[0];
|
|
int f = from.file + dir[1];
|
|
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
|
|
if(targetSquare.isValid()) {
|
|
const Piece *target = board.getPieceAt(targetSquare); // examine the target square
|
|
if(!target) { // if square is empty (nullptr)
|
|
moveList.push_back({from, targetSquare}); // then it's potentially a legal move
|
|
} else if(target && target->getColour() != this->getColour()) { // if it's occupied with a piece of opposite colour
|
|
moveList.push_back({from, targetSquare}); // then again it's potentially legal
|
|
break;
|
|
} else {
|
|
// otherwise it's one of our pieces
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// How to check for check:
|
|
// go through moveList.to, then check all directions to see if an enemy piece is threatening
|
|
// If a piece of opposite colour is detected:
|
|
// - Determine the piece type
|
|
// - Determine the direction we are looking at (diagonal or not)
|
|
// - If that piece can attack in that direction, it would be check, so remove this move from moveList
|
|
// We need to add knight attack to the directions to check
|
|
/*
|
|
* __3_4___
|
|
* _1___2__
|
|
* ___K____
|
|
* _5___6__
|
|
* __7_8___
|
|
*
|
|
*/
|
|
std::vector<std::vector<int>> knightAttacks = {
|
|
{-1, -2}, // 1
|
|
{-1, 2}, // 2
|
|
{-2, -1}, // 3
|
|
{-2, 1}, // 4
|
|
{1, -2}, // 5
|
|
{1, 2}, // 6
|
|
{2, -1}, // 7
|
|
{2, 1} // 8
|
|
};
|
|
directions.insert(directions.end(), knightAttacks.begin(), knightAttacks.end()); // concatenate the knight attacks
|
|
for(auto &moves : moveList) {
|
|
Square startSquare = moves.to; // get the potential moveto square
|
|
for(auto &dir : directions) { // now go through all directions
|
|
int r = startSquare.rank + dir[0];
|
|
int f = startSquare.file + dir[1];
|
|
bool diagonal = (abs(dir[0]) + abs(dir[1]) == 2) ? 1 : 0; // check if diagonal
|
|
bool knight = (abs(dir[0]) + abs(dir[1]) == 3) ? 1 : 0; // check if knight attack
|
|
while(r >= 0 && r < 8 && f >= 0 && f < 8) {
|
|
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
|
|
const Piece *target = board.getPieceAt(targetSquare); // access the square we're examining
|
|
if(!target) {
|
|
// empty square, continue
|
|
continue;
|
|
}
|
|
if(target && (target->getColour() != this->getColour())) { // is it occupied & an enemy?
|
|
if((target->getPieceType() == QUEEN || target->getPieceType() == BISHOP) && diagonal) {
|
|
// we are being attacked diagonally on this square, so remove it
|
|
moves.to.rank = INVALID_RANK;
|
|
moves.to.file = INVALID_FILE;
|
|
} else if(target->getPieceType() == KNIGHT && knight) {
|
|
// we are being attacked by a knight, so remove it
|
|
moves.to.rank = INVALID_RANK;
|
|
moves.to.file = INVALID_FILE;
|
|
} else if(target->getPieceType() == ROOK || target->getPieceType() == QUEEN && (!diagonal && !knight)) {
|
|
// again, being attacked, remove it
|
|
moves.to.rank = INVALID_RANK;
|
|
moves.to.file = INVALID_FILE;
|
|
}
|
|
if(target->getPieceType() == PAWN && (abs(r - startSquare.rank) == 1 && abs(f - startSquare.file) == 1)) {
|
|
moves.to.rank = INVALID_RANK;
|
|
moves.to.file = INVALID_FILE;
|
|
}
|
|
}
|
|
if(target && (target->getColour() == this->getColour())) {
|
|
// we've hit a friendly, stop
|
|
break;
|
|
}
|
|
if(!knight) {
|
|
r += dir[0];
|
|
f += dir[1];
|
|
} else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// will this actually work?
|
|
moveList.erase(
|
|
std::remove_if(moveList.begin(), moveList.end(),
|
|
[&](const auto & x) {
|
|
return !x.to.isValid();
|
|
}));
|
|
return moveList;
|
|
}
|
|
|
|
// *INDENT-OFF*
|
|
//
|
|
// ##
|
|
// #
|
|
// # ### ## ## # ##
|
|
// # # # # # # #
|
|
// # # # # # ##
|
|
// # # # # # # #
|
|
// #### ## ## ## ##
|
|
//
|
|
// *INDENT-OM*
|
|
|
|
std::vector<Move> Rook::getLegalMoves(const Square &from, Board &board) const {
|
|
std::vector<Move> moveList;
|
|
const int directions[4][2] = {
|
|
{-1, 0}, // Up
|
|
{1, 0}, // Down
|
|
{0, -1}, // Left
|
|
{0, 1} // Right
|
|
};
|
|
for(auto &dir : directions) {
|
|
int r = from.rank + dir[0];
|
|
int f = from.file + dir[1];
|
|
while(r >= 0 && r < 8 && f >= 0 && f < 8) {
|
|
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
|
|
const Piece *target = board.getPieceAt(targetSquare);
|
|
if(!target) {
|
|
moveList.push_back({from, targetSquare});
|
|
} else if(target && target->getColour() != this->getColour()) {
|
|
moveList.push_back({from, targetSquare});
|
|
break;
|
|
} else
|
|
break;
|
|
r += dir[0];
|
|
f += dir[1];
|
|
}
|
|
}
|
|
return moveList;
|
|
}
|
|
|
|
// *INDENT-OFF*
|
|
// ## # ## ## ## ## # ##
|
|
// # # # # # # # # # #
|
|
// # # # # ### ### # #
|
|
// # # # # # # # #
|
|
// ### ## # ### ### ### ##
|
|
// #
|
|
// ###
|
|
// *INDENT-ON*
|
|
|
|
std::vector<Move> Queen::getLegalMoves(const Square &from, Board &board) const {
|
|
std::vector<Move> moveList;
|
|
std::vector<std::vector<int>> directions = {
|
|
{-1, 0}, // Up
|
|
{-1, -1}, // up-left
|
|
{-1, 1}, // up-right
|
|
{1, 0}, // Down
|
|
{1, -1}, // down-left
|
|
{1, 1}, // down-right
|
|
{0, -1}, // Left
|
|
{0, 1} // Right
|
|
};
|
|
for(auto &dir : directions) {
|
|
// establish r/f for square to check
|
|
int r = from.rank + dir[0];
|
|
int f = from.file + dir[1];
|
|
while(r >= 0 && r < 8 && f >= 0 && f < 8) {
|
|
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
|
|
const Piece *target = board.getPieceAt(targetSquare);// examine the target square
|
|
if(!target) { // if square is empty (NULL)
|
|
moveList.push_back({from, targetSquare}); // then it's potentially a legal move
|
|
} else if(target && target->getColour() != this->getColour()) { // if it's occupied with a piece of opposite colour
|
|
moveList.push_back({from, targetSquare}); // then again it's potentially legal
|
|
break;
|
|
} else {
|
|
// otherwise it's one of our pieces
|
|
break;
|
|
}
|
|
r += dir[0];
|
|
f += dir[1];
|
|
}
|
|
}
|
|
return moveList;
|
|
}
|
|
|
|
// *INDENT-OFF*
|
|
// ## # ## #
|
|
// # # #
|
|
// # ## # ## ## ## # ### ####
|
|
// # # # # # # # # # #
|
|
// ## # # # # # # # #
|
|
// # # # # # # # # # # #
|
|
// ## ## ### ## ##### ### ### ## ##
|
|
// #
|
|
// ###
|
|
// *INDENT-ON*
|
|
|
|
std::vector<Move> Knight::getLegalMoves(const Square &from, Board &board) const {
|
|
std::vector<Move> moveList;
|
|
std::vector<std::vector<int>> directions = {
|
|
{-1, -2},
|
|
{-1, 2},
|
|
{-2, -1},
|
|
{-2, 1},
|
|
{1, -2},
|
|
{1, 2},
|
|
{2, -1},
|
|
{2, 1}
|
|
};
|
|
return moveList;
|
|
}
|
|
|
|
// *INDENT-OFF*
|
|
// ## # ##
|
|
// # #
|
|
// ### ## ### ### ## # ##
|
|
// # # # # # # # # # #
|
|
// # # # ## # # # # # #
|
|
// # # # # # # # # # #
|
|
// #### ##### ### ### ## ## ###
|
|
// #
|
|
// ###
|
|
// *INDENT-ON*
|
|
|
|
std::vector<Move> Bishop::getLegalMoves(const Square &from, Board &board) const {
|
|
std::vector<Move> moveList;
|
|
std::vector<std::vector<int>> directions = {
|
|
{-1, -1}, // up-left
|
|
{-1, 1}, // up-right
|
|
{1, -1}, // down-left
|
|
{1, 1}, // down-right
|
|
};
|
|
return moveList;
|
|
}
|
|
|
|
// *INDENT-OFF*
|
|
//
|
|
// # ## ## # # ## # ##
|
|
// # # # # # # # #
|
|
// # # ### # # # # #
|
|
// # # # # # # # #
|
|
// ### ## # # # ### ##
|
|
// #
|
|
// ###
|
|
// *INDENT-ON*
|
|
|
|
std::vector<Move> Pawn::getLegalMoves(const Square &from, Board &board) const {
|
|
std::vector<Move> moveList;
|
|
const int directions[2][4][2] = {
|
|
{
|
|
// black
|
|
{-1, 0}, // Up
|
|
{-2, 0}, // 2up first move
|
|
{-1, 1}, // attack to right
|
|
{-1, -1} // attack to left
|
|
},
|
|
{
|
|
// white
|
|
{1, 0}, // down
|
|
{2, 0}, // 2down first move
|
|
{1, 1}, // attack to right
|
|
{1, -1} // attack to left
|
|
}
|
|
};
|
|
if(this->getColour() == PIECE_BLACK) {
|
|
// go through black options
|
|
for(auto &dir : directions[0]) {
|
|
int r = from.rank + dir[0];
|
|
int f = from.file + dir[1];
|
|
if(r >= 0 && r < 8 && f >= 0 && f < 8) { // no need for a while loop as we only have finite moves in limited directions
|
|
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
|
|
const Piece *target = board.getPieceAt(targetSquare);
|
|
if(dir[0] == -2 && !this->checkIfMoved()) {
|
|
// then 2 is potentially legal
|
|
if(!target && board.isSquareEmpty(Square{static_cast<Rank>(r + 1), static_cast<File>(f)})) // check both squares for pieces of any colour
|
|
moveList.push_back({from, targetSquare});
|
|
else
|
|
continue;
|
|
} else if(abs(dir[1]) == 1) { // attempted capture (diagonal)
|
|
if(target && target->getColour() != this->getColour()) {
|
|
// legal capture
|
|
moveList.push_back({from, targetSquare});
|
|
} else
|
|
continue;
|
|
} else { // normal one square forward
|
|
if(!target)
|
|
moveList.push_back({from, targetSquare});
|
|
}
|
|
// now check if we are on 8th rank, for promotion
|
|
}
|
|
}
|
|
} else if(this->getColour() == PIECE_WHITE) {
|
|
for(auto &dir : directions[1]) {
|
|
// go through white options
|
|
int r = from.rank + dir[0];
|
|
int f = from.file + dir[1];
|
|
if(r >= 0 && r < 8 && f >= 0 && f < 8) { // no need for a while loop as we only have finite moves in limited directions
|
|
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
|
|
const Piece *target = board.getPieceAt(targetSquare);
|
|
if(dir[0] == 2 && !this->checkIfMoved()) {
|
|
// then 2 is potentially legal
|
|
if(!target && board.isSquareEmpty(Square{static_cast<Rank>(r + 1), static_cast<File>(f)}))
|
|
moveList.push_back({from, targetSquare});
|
|
else
|
|
continue;
|
|
} else if(abs(dir[1]) == 1) { // attempted capture (diagonal)
|
|
if(target && target->getColour() != this->getColour()) { // can only move there if it's a capture
|
|
// legal capture
|
|
moveList.push_back({from, targetSquare});
|
|
} else
|
|
continue;
|
|
} else { // normal one square forward
|
|
if(!target)
|
|
moveList.push_back({from, targetSquare});
|
|
}
|
|
// now check if we are on 8th rank, for promotion
|
|
}
|
|
}
|
|
}
|
|
return moveList;
|
|
} |