public void ValidateTargetPosition(Position origin, Position destination)
{
if (!Board.piece(origin).PossibleMovements(destination))
{
throw new BoardException("The target position is not valid!");
}
}
public void checkDestinyPosition(Position origin, Position destiny)
{
if (!Board.piece(origin).isPossibleMoveTo(destiny))
{
throw new BoardException("Invalid destiny position");
}
}
public override bool[,] AvailableMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position positionBoard = new Position(0, 0);
//northwest position
positionBoard.SetValues(positionBoard.Line - 1, positionBoard.Column - 1);
while (Board.ValidPosition(positionBoard) && podeMover(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.SetValues(positionBoard.Line - 1, positionBoard.Column - 1);
}
//northeast position
positionBoard.SetValues(positionBoard.Line - 1, positionBoard.Column + 1);
while (Board.ValidPosition(positionBoard) && podeMover(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.SetValues(positionBoard.Line - 1, positionBoard.Column + 1);
}
//southeast position
positionBoard.SetValues(positionBoard.Line + 1, positionBoard.Column + 1);
while (Board.ValidPosition(positionBoard) && podeMover(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.SetValues(positionBoard.Line + 1, positionBoard.Column + 1);
}
//southwest position
positionBoard.SetValues(positionBoard.Line + 1, positionBoard.Column - 1);
while (Board.ValidPosition(positionBoard) && podeMover(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.SetValues(positionBoard.Line + 1, positionBoard.Column - 1);
}
return mat;
}
public override bool[,] AvailableMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position positionBoard = new Position(0, 0);
//north position
positionBoard.SetValues(Position.Line - 1, Position.Column);
while (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.Line -= 1;
}
//right position
positionBoard.SetValues(Position.Line, Position.Column + 1);
while (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.Column += 1;
}
//south position
positionBoard.SetValues(Position.Line + 1, Position.Column);
while (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.Line += 1;
}
//left position
positionBoard.SetValues(Position.Line, Position.Column - 1);
while (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
if (Board.piece(positionBoard) != null && Board.piece(positionBoard).Color != Color)
{
break;
}
positionBoard.Column -= 1;
}
return(mat);
}
public void ValidateOriginPosition(Position position)
{
if (Board.piece(position) == null)
{
throw new BoardException("There is no piece in the chosen origin position!");
}
if (CurrentPlayer != Board.piece(position).Color)
{
throw new BoardException("The chosen origin piece is not yours!");
}
if (!Board.piece(position).ExistsPossibleMovements())
{
throw new BoardException("There are not possible movements for the chosen piece!");
}
}
public void PerformeMove(Position origin, Position destination)
{
Piece capturedPiece = ExecuteMoviment(origin, destination);
if (IsInCheck(CurrentPlayer))
{
UndoMovement(origin, destination, capturedPiece);
throw new BoardException("You cannot put yourself in check");
}
Piece p = Board.piece(destination);
// #promocao
if (p is Pawn)
{
if ((p.Color == Color.White && destination.Line == 0) || (p.Color == Color.Black && destination.Line == 7))
{
p = Board.removePieceFromPosition(destination);
pieces.Remove(p);
Piece queen = new Queen(Board, p.Color);
Board.SetPieceInPosition(queen, destination);
pieces.Add(queen);
}
}
CheckMate = IsInCheck(Opponent(CurrentPlayer));
if (TestCheckMate(Opponent(CurrentPlayer)))
{
FinishedMatch = true;
}
else
{
Turn++;
ChangePlayer();
}
// #en passant
if (p is Pawn && (destination.Line == origin.Line - 2 || destination.Line == origin.Line + 2))
{
VulnerableEnPassant = p;
}
else
{
VulnerableEnPassant = null;
}
}
public void checkOriginPosition(Position pos)
{
if (Board.piece(pos) == null)
{
throw new BoardException("There is no piece in the chosen origin position");
}
if (CurrentPlayer != Board.piece(pos).color)
{
throw new BoardException("The piece chosen is not yours");
}
if (!Board.piece(pos).existsPossibleMoves())
{
throw new BoardException("There are no possible moves for the chosen piece");
}
}
private bool podeMover(Position positionBoard)
{
Piece piece = Board.piece(positionBoard);
return piece == null || piece.Color != Color;
}
private bool CanMove(Position position)
{
Piece piece = Board.piece(position);
return(piece == null || piece.Color != Color);
}
public override bool[,] AvailableMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position positionBoard = new Position(0, 0);
//north position
positionBoard.SetValues(Position.Line - 1, Position.Column);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
//northeast position
positionBoard.SetValues(Position.Line - 1, Position.Column + 1);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
//right position
positionBoard.SetValues(Position.Line, Position.Column + 1);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
//southeast position
positionBoard.SetValues(Position.Line + 1, Position.Column + 1);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
//south position
positionBoard.SetValues(Position.Line + 1, Position.Column);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
//southwest position
positionBoard.SetValues(Position.Line + 1, Position.Column - 1);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
//left position
positionBoard.SetValues(Position.Line, Position.Column - 1);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
//northwest position
positionBoard.SetValues(Position.Line - 1, Position.Column - 1);
if (Board.ValidPosition(positionBoard) && CanMove(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
// #Castle move
if (MovementQuantity == 0 && !match.CheckMate)
{
// #Castle Kingside
Position posT1 = new Position(Position.Line, Position.Column + 3);
if (TestTowerForCastleMove(posT1))
{
Position p1 = new Position(Position.Line, Position.Column + 1);
Position p2 = new Position(Position.Line, Position.Column + 2);
if (Board.piece(p1) == null && Board.piece(p2) == null)
{
mat[Position.Line, Position.Column + 2] = true;
}
}
// #Castle Queenside
Position posT2 = new Position(Position.Line, Position.Column - 4);
if (TestTowerForCastleMove(posT2))
{
Position p1 = new Position(Position.Line, Position.Column - 1);
Position p2 = new Position(Position.Line, Position.Column - 2);
Position p3 = new Position(Position.Line, Position.Column - 3);
if (Board.piece(p1) == null && Board.piece(p2) == null && Board.piece(p3) == null)
{
mat[Position.Line, Position.Column - 2] = true;
}
}
}
return(mat);
}
private bool TestTowerForCastleMove(Position position)
{
Piece p = Board.piece(position);
return(p != null && p is Tower && p.Color == Color && p.MovementQuantity == 0);
}
public override bool[,] AvailableMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position positionBoard = new Position(0, 0);
if (Color == Color.White)
{
positionBoard.SetValues(Position.Line - 1, Position.Column);
if (Board.ValidPosition(positionBoard) && Free(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
positionBoard.SetValues(Position.Line - 2, Position.Column);
Position p2 = new Position(Position.Line - 1, Position.Column);
if (Board.ValidPosition(p2) && Free(p2) && Board.ValidPosition(positionBoard) && Free(positionBoard) && MovementQuantity == 0)
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
positionBoard.SetValues(Position.Line - 1, Position.Column - 1);
if (Board.ValidPosition(positionBoard) && ExistsOpponent(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
positionBoard.SetValues(Position.Line - 1, Position.Column + 1);
if (Board.ValidPosition(positionBoard) && ExistsOpponent(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
// #en passant
if (Position.Line == 3)
{
Position left = new Position(Position.Line, Position.Column - 1);
if (Board.ValidPosition(left) && ExistsOpponent(left) && Board.piece(left) == match.VulnerableEnPassant)
{
mat[left.Line - 1, left.Column] = true;
}
Position right = new Position(Position.Line, Position.Column + 1);
if (Board.ValidPosition(right) && ExistsOpponent(right) && Board.piece(right) == match.VulnerableEnPassant)
{
mat[right.Line - 1, right.Column] = true;
}
}
}
else
{
positionBoard.SetValues(Position.Line + 1, Position.Column);
if (Board.ValidPosition(positionBoard) && Free(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
positionBoard.SetValues(Position.Line + 2, Position.Column);
Position p2 = new Position(Position.Line + 1, Position.Column);
if (Board.ValidPosition(p2) && Free(p2) && Board.ValidPosition(positionBoard) && Free(positionBoard) && MovementQuantity == 0)
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
positionBoard.SetValues(Position.Line + 1, Position.Column - 1);
if (Board.ValidPosition(positionBoard) && ExistsOpponent(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
positionBoard.SetValues(Position.Line + 1, Position.Column + 1);
if (Board.ValidPosition(positionBoard) && ExistsOpponent(positionBoard))
{
mat[positionBoard.Line, positionBoard.Column] = true;
}
// #en passant
if (Position.Line == 4)
{
Position left = new Position(Position.Line, Position.Column - 1);
if (Board.ValidPosition(left) && ExistsOpponent(left) && Board.piece(left) == match.VulnerableEnPassant)
{
mat[left.Line + 1, left.Column] = true;
}
Position right = new Position(Position.Line, Position.Column + 1);
if (Board.ValidPosition(right) && ExistsOpponent(right) && Board.piece(right) == match.VulnerableEnPassant)
{
mat[right.Line + 1, right.Column] = true;
}
}
}
return(mat);
}
private bool Free(Position positionBoard)
{
return(Board.piece(positionBoard) == null);
}
private bool ExistsOpponent(Position positionBoard)
{
Piece p = Board.piece(positionBoard);
return(p != null && p.Color != Color);
}
