/// <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> getLegalMove(BoardHelper board, Position pos, bool verify_check = true)
{
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == PieceType.None)
{
return(new List <Position>());
}
switch (p.piece)
{
case PieceType.Pawn:
return(LegalMoveSet.Pawn(board, pos, verify_check));
case PieceType.Rook:
return(LegalMoveSet.Rook(board, pos, verify_check));
case PieceType.Knight:
return(LegalMoveSet.Knight(board, pos, verify_check));
case PieceType.Bishop:
return(LegalMoveSet.Bishop(board, pos, verify_check));
case PieceType.Queen:
return(LegalMoveSet.Queen(board, pos, verify_check));
case PieceType.King:
return(LegalMoveSet.King(board, pos, verify_check));
default:
return(new List <Position>());
}
}
private static List <Position> Rook(BoardHelper board, Position pos, bool verify_check = true)
{
List <Position> moves = new List <Position>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == PieceType.None)
{
return(moves);
}
// slide along vert/hor for possible moves
moves.AddRange(Slide(board, p.player, pos, new Position(1, 0)));
moves.AddRange(Slide(board, p.player, pos, new Position(-1, 0)));
moves.AddRange(Slide(board, p.player, pos, new Position(0, 1)));
moves.AddRange(Slide(board, p.player, pos, new Position(0, -1)));
if (verify_check)// make sure each move doesn't put us in check
{
for (int i = moves.Count - 1; i >= 0; i--)
{
BoardHelper b2 = LegalMoveSet.move(board, new Move(pos, moves[i]));
if (isCheck(b2, p.player))
{
moves.RemoveAt(i);
}
}
}
return(moves);
}
public void Config(bool firstCall, BoardData board, PieceSide turn)
{
if (firstCall)
{
AI.GetInstance().UpdateFirstCall(false);
Grid = new piece_t[Const.RowCount][];
for (int i = 0; i < Const.RowCount; i++)
{
Grid[i] = new piece_t[Const.ColCount];
for (int j = 0; j < Const.ColCount; j++)
{
if (board.ArrPiece[j, i] != null)
{
Grid[i][j] = new piece_t(board.ArrPiece[j, i].Type, board.ArrPiece[j, i].Side);
}
else
{
Grid[i][j] = new piece_t(PieceType.None, PieceSide.White);
}
}
}
LastMove = new Dictionary <PieceSide, Position>();
LastMove[PieceSide.Black] = new Position();
LastMove[PieceSide.White] = new Position();
Kings = new Dictionary <PieceSide, Position>();
Pieces = new Dictionary <PieceSide, List <Position> >();
List <Position> blackPos = new List <Position>();
List <Position> whitePos = new List <Position>();
for (int i = 0; i < Const.RowCount; i++)
{
for (int j = 0; j < Const.ColCount; j++)
{
Piece temp = BoardData.GetInstance().ArrPiece[j, i];
if (temp != null)
{
if (temp.Side == PieceSide.Black)
{
if (temp.Type == PieceType.King)
{
Kings[PieceSide.Black] = new Position(temp.Position.X, temp.Position.Y);
}
blackPos.Add(new Position(temp.Position.X, temp.Position.Y));
}
else
{
if (temp.Type == PieceType.King)
{
Kings[PieceSide.White] = new Position(temp.Position.X, temp.Position.Y);
}
whitePos.Add(new Position(temp.Position.X, temp.Position.Y));
}
}
}
}
Pieces.Add(PieceSide.Black, blackPos);
Pieces.Add(PieceSide.White, whitePos);
}
}
public BoardHelper(BoardHelper copy)
{
// init piece position lists
Pieces = new Dictionary <PieceSide, List <Position> >();
Pieces.Add(PieceSide.Black, new List <Position>());
Pieces.Add(PieceSide.White, new List <Position>());
// 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 != PieceType.None)
{
Pieces[Grid[i][j].player].Add(new Position(j, i));
}
}
}
// copy last known move
LastMove = new Dictionary <PieceSide, Position>();
LastMove[PieceSide.Black] = new Position(copy.LastMove[PieceSide.Black]);
LastMove[PieceSide.White] = new Position(copy.LastMove[PieceSide.White]);
// copy king locations
Kings = new Dictionary <PieceSide, Position>();
Kings[PieceSide.Black] = new Position(copy.Kings[PieceSide.Black]);
Kings[PieceSide.White] = new Position(copy.Kings[PieceSide.White]);
}
private static List <Position> Knight(BoardHelper board, Position pos, bool verify_check = true)
{
List <Position> moves = new List <Position>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == PieceType.None)
{
return(moves);
}
// collect all relative moves possible
List <Position> relative = new List <Position>();
relative.Add(new Position(2, 1));
relative.Add(new Position(2, -1));
relative.Add(new Position(-2, 1));
relative.Add(new Position(-2, -1));
relative.Add(new Position(1, 2));
relative.Add(new Position(-1, 2));
relative.Add(new Position(1, -2));
relative.Add(new Position(-1, -2));
// iterate moves
foreach (Position move in relative)
{
Position moved = new Position(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 == PieceType.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--)
{
BoardHelper b2 = LegalMoveSet.move(board, new Move(pos, moves[i]));
if (isCheck(b2, p.player))
{
moves.RemoveAt(i);
}
}
}
return(moves);
}
public piece_t(piece_t copy)
{
this.piece = copy.piece;
this.player = copy.player;
this.lastPosition = copy.lastPosition;
}
private static List <Position> Pawn(BoardHelper board, Position pos, bool verify_check = true)
{
List <Position> moves = new List <Position>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == PieceType.None)
{
return(moves);
}
// gather relative moves
List <Position> relative = new List <Position>();
relative.Add(new Position(-1, 1 * ((p.player == PieceSide.Black) ? -1 : 1)));
relative.Add(new Position(0, 1 * ((p.player == PieceSide.Black) ? -1 : 1)));
relative.Add(new Position(0, 2 * ((p.player == PieceSide.Black) ? -1 : 1)));
relative.Add(new Position(1, 1 * ((p.player == PieceSide.Black) ? -1 : 1)));
// iterate moves
foreach (Position move in relative)
{
Position moved = new Position(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 == PieceType.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 == PieceSide.Black) ? 6 : 1);
if (board.Grid[moved.number + step][moved.letter].piece == PieceType.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 == PieceType.None)
{
moves.Add(moved);
}
// angled attack
else if (moved.letter != pos.letter && board.Grid[moved.number][moved.letter].piece != PieceType.None && board.Grid[moved.number][moved.letter].player != p.player)
{
moves.Add(moved);
}
// en passant
else if (isEnPassant(board, new Move(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--)
{
BoardHelper b2 = LegalMoveSet.move(board, new Move(pos, moves[i]));
if (isCheck(b2, p.player))
{
moves.RemoveAt(i);
}
}
}
return(moves);
}
private static List <Position> King(BoardHelper board, Position pos, bool verify_check = true)
{
List <Position> moves = new List <Position>();
piece_t p = board.Grid[pos.number][pos.letter];
if (p.piece == PieceType.None)
{
return(moves);
}
// collect all relative moves possible
List <Position> relative = new List <Position>();
relative.Add(new Position(-1, 1));
relative.Add(new Position(0, 1));
relative.Add(new Position(1, 1));
relative.Add(new Position(-1, 0));
relative.Add(new Position(1, 0));
relative.Add(new Position(-1, -1));
relative.Add(new Position(0, -1));
relative.Add(new Position(1, -1));
// Iterate moves
foreach (Position move in relative)
{
Position moved = new Position(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 == PieceType.None || board.Grid[moved.number][moved.letter].player != p.player)
{
if (verify_check) // make sure we don't put ourselves in check
{
BoardHelper b2 = LegalMoveSet.move(board, new Move(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(-1, -1)))
{
bool castleRight = allowCastle(board, p.player, pos, true);
bool castleLeft = allowCastle(board, p.player, pos, false);
if (castleRight)
{
moves.Add(new Position(6, pos.number));
}
if (castleLeft)
{
moves.Add(new Position(2, pos.number));
}
}
}
return(moves);
}
public piece_t(piece_t copy)
{
this.piece = copy.piece;
this.player = copy.player;
this.lastPosition = copy.lastPosition;
}
