public ChessBoard()
{
// init blank board grid
Grid = new piece_t[8][];
for (int i = 0; i < 8; i++)
{
Grid[i] = new piece_t[8];
for (int j = 0; j < 8; j++)
{
Grid[i][j] = new piece_t(Piece.NONE, Player.WHITE);
}
}
// init last moves
LastMove = new Dictionary <Player, position_t>();
LastMove[Player.BLACK] = new position_t();
LastMove[Player.WHITE] = new position_t();
// init king positions
Kings = new Dictionary <Player, position_t>();
// init piece position lists
Pieces = new Dictionary <Player, List <position_t> >();
Pieces.Add(Player.BLACK, new List <position_t>());
Pieces.Add(Player.WHITE, new List <position_t>());
}
public ChessBoard(ChessBoard copy)
{
// init piece position lists
Pieces = new Dictionary <Player, List <position_t> >();
Pieces.Add(Player.BLACK, new List <position_t>());
Pieces.Add(Player.WHITE, new List <position_t>());
// init board grid to copy locations
Grid = new piece_t[8][];
for (int i = 0; i < 8; i++)
{
Grid[i] = new piece_t[8];
for (int j = 0; j < 8; j++)
{
Grid[i][j] = new piece_t(copy.Grid[i][j]);
// add piece location to list
if (Grid[i][j].piece != Piece.NONE)
{
Pieces[Grid[i][j].player].Add(new position_t(j, i));
}
}
}
// copy last known move
LastMove = new Dictionary <Player, position_t>();
LastMove[Player.BLACK] = new position_t(copy.LastMove[Player.BLACK]);
LastMove[Player.WHITE] = new position_t(copy.LastMove[Player.WHITE]);
// copy king locations
Kings = new Dictionary <Player, position_t>();
Kings[Player.BLACK] = new position_t(copy.Kings[Player.BLACK]);
Kings[Player.WHITE] = new position_t(copy.Kings[Player.WHITE]);
}
private static List <position_t> Rook(ChessBoard board, position_t pos, bool verify_check = true)
{
List <position_t> moves = new List <position_t>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == Piece.NONE)
{
return(moves);
}
// slide along vert/hor for possible moves
moves.AddRange(Slide(board, p.player, pos, new position_t(1, 0)));
moves.AddRange(Slide(board, p.player, pos, new position_t(-1, 0)));
moves.AddRange(Slide(board, p.player, pos, new position_t(0, 1)));
moves.AddRange(Slide(board, p.player, pos, new position_t(0, -1)));
if (verify_check)// make sure each move doesn't put us in check
{
for (int i = moves.Count - 1; i >= 0; i--)
{
ChessBoard b2 = LegalMoveSet.move(board, new move_t(pos, moves[i]));
if (isCheck(b2, p.player))
{
moves.RemoveAt(i);
}
}
}
return(moves);
}
/// <summary>
/// Get any legal move from the current position on the provided board.
/// </summary>
/// <param name="board">The state of the game.</param>
/// <param name="pos">The piece/position to check for valid moves.</param>
/// <param name="verify_check">Whether or not to recurse and check if the current move puts you in check.</param>
/// <returns>A list of positions the piece can move to.</returns>
public static List <position_t> getLegalMove(ChessBoard board, position_t pos, bool verify_check = true)
{
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == Piece.NONE)
{
return(new List <position_t>());
}
switch (p.piece)
{
case Piece.PAWN:
return(LegalMoveSet.Pawn(board, pos, verify_check));
case Piece.ROOK:
return(LegalMoveSet.Rook(board, pos, verify_check));
case Piece.KNIGHT:
return(LegalMoveSet.Knight(board, pos, verify_check));
case Piece.BISHOP:
return(LegalMoveSet.Bishop(board, pos, verify_check));
case Piece.QUEEN:
return(LegalMoveSet.Queen(board, pos, verify_check));
case Piece.KING:
return(LegalMoveSet.King(board, pos, verify_check));
default:
return(new List <position_t>());
}
}
public ChessBoard(ChessBoard copy)
{
// init piece position lists
Pieces = new Dictionary<Player, List<position_t>>();
Pieces.Add(Player.BLACK, new List<position_t>());
Pieces.Add(Player.WHITE, new List<position_t>());
// init board grid to copy locations
Grid = new piece_t[8][];
for (int i = 0; i < 8; i++)
{
Grid[i] = new piece_t[8];
for (int j = 0; j < 8; j++)
{
Grid[i][j] = new piece_t(copy.Grid[i][j]);
// add piece location to list
if (Grid[i][j].piece != Piece.NONE)
Pieces[Grid[i][j].player].Add(new position_t(j, i));
}
}
// copy last known move
LastMove = new Dictionary<Player, position_t>();
LastMove[Player.BLACK] = new position_t(copy.LastMove[Player.BLACK]);
LastMove[Player.WHITE] = new position_t(copy.LastMove[Player.WHITE]);
// copy king locations
Kings = new Dictionary<Player, position_t>();
Kings[Player.BLACK] = new position_t(copy.Kings[Player.BLACK]);
Kings[Player.WHITE] = new position_t(copy.Kings[Player.WHITE]);
}
private static List <position_t> Knight(ChessBoard board, position_t pos, bool verify_check = true)
{
List <position_t> moves = new List <position_t>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == Piece.NONE)
{
return(moves);
}
// collect all relative moves possible
List <position_t> relative = new List <position_t>();
relative.Add(new position_t(2, 1));
relative.Add(new position_t(2, -1));
relative.Add(new position_t(-2, 1));
relative.Add(new position_t(-2, -1));
relative.Add(new position_t(1, 2));
relative.Add(new position_t(-1, 2));
relative.Add(new position_t(1, -2));
relative.Add(new position_t(-1, -2));
// iterate moves
foreach (position_t move in relative)
{
position_t moved = new position_t(move.letter + pos.letter, move.number + pos.number);
// bounds check
if (moved.letter < 0 || moved.letter > 7 || moved.number < 0 || moved.number > 7)
{
continue;
}
// if empty space or attacking
if (board.Grid[moved.number][moved.letter].piece == Piece.NONE ||
board.Grid[moved.number][moved.letter].player != p.player)
{
moves.Add(moved);
}
}
if (verify_check)// make sure each move doesn't put us in check
{
for (int i = moves.Count - 1; i >= 0; i--)
{
ChessBoard b2 = LegalMoveSet.move(board, new move_t(pos, moves[i]));
if (isCheck(b2, p.player))
{
moves.RemoveAt(i);
}
}
}
return(moves);
}
public ChessBoard()
{
// init blank board grid
Grid = new piece_t[8][];
for (int i = 0; i < 8; i++)
{
Grid[i] = new piece_t[8];
for (int j = 0; j < 8; j++)
Grid[i][j] = new piece_t(Piece.NONE, Player.WHITE);
}
// init last moves
LastMove = new Dictionary<Player, position_t>();
LastMove[Player.BLACK] = new position_t();
LastMove[Player.WHITE] = new position_t();
// init king positions
Kings = new Dictionary<Player, position_t>();
// init piece position lists
Pieces = new Dictionary<Player, List<position_t>>();
Pieces.Add(Player.BLACK, new List<position_t>());
Pieces.Add(Player.WHITE, new List<position_t>());
}
private static List <position_t> Pawn(ChessBoard board, position_t pos, bool verify_check = true)
{
List <position_t> moves = new List <position_t>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == Piece.NONE)
{
return(moves);
}
// gather relative moves
List <position_t> relative = new List <position_t>();
relative.Add(new position_t(-1, 1 * ((p.player == Player.BLACK) ? -1 : 1)));
relative.Add(new position_t(0, 1 * ((p.player == Player.BLACK) ? -1 : 1)));
relative.Add(new position_t(0, 2 * ((p.player == Player.BLACK) ? -1 : 1)));
relative.Add(new position_t(1, 1 * ((p.player == Player.BLACK) ? -1 : 1)));
// iterate moves
foreach (position_t move in relative)
{
position_t moved = new position_t(move.letter + pos.letter, move.number + pos.number);
// bounds check
if (moved.letter < 0 || moved.letter > 7 || moved.number < 0 || moved.number > 7)
{
continue;
}
// double forward move
if (moved.letter == pos.letter && board.Grid[moved.number][moved.letter].piece == Piece.NONE && Math.Abs(moved.number - pos.number) == 2)
{
// check the first step
int step = -((moved.number - pos.number) / (Math.Abs(moved.number - pos.number)));
bool hasnt_moved = pos.number == ((p.player == Player.BLACK) ? 6 : 1);
if (board.Grid[moved.number + step][moved.letter].piece == Piece.NONE && hasnt_moved)
{
moves.Add(moved);
}
}
// if it's not blocked we can move forward
else if (moved.letter == pos.letter && board.Grid[moved.number][moved.letter].piece == Piece.NONE)
{
moves.Add(moved);
}
// angled attack
else if (moved.letter != pos.letter && board.Grid[moved.number][moved.letter].piece != Piece.NONE && board.Grid[moved.number][moved.letter].player != p.player)
{
moves.Add(moved);
}
// en passant
else if (isEnPassant(board, new move_t(pos, moved)))
{
moves.Add(moved);
}
}
if (verify_check)// make sure each move doesn't put us in check
{
for (int i = moves.Count - 1; i >= 0; i--)
{
ChessBoard b2 = LegalMoveSet.move(board, new move_t(pos, moves[i]));
if (isCheck(b2, p.player))
{
moves.RemoveAt(i);
}
}
}
return(moves);
}
private static List <position_t> King(ChessBoard board, position_t pos, bool verify_check = true)
{
List <position_t> moves = new List <position_t>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == Piece.NONE)
{
return(moves);
}
// collect all relative moves possible
List <position_t> relative = new List <position_t>();
relative.Add(new position_t(-1, 1));
relative.Add(new position_t(0, 1));
relative.Add(new position_t(1, 1));
relative.Add(new position_t(-1, 0));
relative.Add(new position_t(1, 0));
relative.Add(new position_t(-1, -1));
relative.Add(new position_t(0, -1));
relative.Add(new position_t(1, -1));
// Iterate moves
foreach (position_t move in relative)
{
position_t moved = new position_t(move.letter + pos.letter, move.number + pos.number);
// bound check
if (moved.letter < 0 || moved.letter > 7 || moved.number < 0 || moved.number > 7)
{
continue;
}
// if it's not blocked we can move
if (board.Grid[moved.number][moved.letter].piece == Piece.NONE || board.Grid[moved.number][moved.letter].player != p.player)
{
if (verify_check) // make sure we don't put ourselves in check
{
ChessBoard b2 = LegalMoveSet.move(board, new move_t(pos, moved));
if (!isCheck(b2, p.player))
{
moves.Add(moved);
}
}
else
{
moves.Add(moved);
}
}
}
// Castling
/* A king can only castle if:
* king has not moved
* rook has not moved
* king is not in check
* king does not end up in check
* king does not pass through any other peieces
* king does not pass through any squares under attack
* king knows secret handshake
*/
if (verify_check)
{
if (!isCheck(board, p.player) &&
p.lastPosition.Equals(new position_t(-1, -1)))
{
bool castleRight = allowCastle(board, p.player, pos, true);
bool castleLeft = allowCastle(board, p.player, pos, false);
if (castleRight)
{
moves.Add(new position_t(6, pos.number));
}
if (castleLeft)
{
moves.Add(new position_t(2, pos.number));
}
}
}
return(moves);
}
