public override bool[,] PossibleMovements()
{
bool[,] matrix = new bool[board.lines, board.columns];
Position pos = new Position(0, 0);
// Up-Right
pos.SetValues(position.line + 1, position.column + 1);
while (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
if (board.Piece(pos) != null && board.Piece(pos).color != color)
{
break;
}
pos.line += 1;
pos.column += 1;
}
// Down-Right
pos.SetValues(position.line - 1, position.column + 1);
while (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
if (board.Piece(pos) != null && board.Piece(pos).color != color)
{
break;
}
pos.line -= 1;
pos.column += 1;
}
// Down-Left
pos.SetValues(position.line + 1, position.column - 1);
while (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
if (board.Piece(pos) != null && board.Piece(pos).color != color)
{
break;
}
pos.line += 1;
pos.column -= 1;
}
// Up-Left
pos.SetValues(position.line - 1, position.column - 1);
while (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
if (board.Piece(pos) != null && board.Piece(pos).color != color)
{
break;
}
pos.line -= 1;
pos.column -= 1;
}
return(matrix);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position position = new Position(0, 0);
//Up
position.SetValues(Position.Line - 1, Position.Column);
while (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.Line -= 1;
}
//Down
position.SetValues(Position.Line + 1, Position.Column);
while (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.Line += 1;
}
//Right
position.SetValues(Position.Line, Position.Column + 1);
while (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.Column += 1;
}
//Left
position.SetValues(Position.Line, Position.Column - 1);
while (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.Column -= 1;
}
return(mat);
}
public override bool[,] PossibleMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position pos = new Position(0, 0);
//Above
pos.SetValues(Position.Line - 1, Position.Column);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != this.Color)
{
break;
}
pos.Line = pos.Line - 1;
}
//Right
pos.SetValues(Position.Line, Position.Column + 1);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != this.Color)
{
break;
}
pos.Column = pos.Column + 1;
}
//Below
pos.SetValues(Position.Line + 1, Position.Column);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != this.Color)
{
break;
}
pos.Line = pos.Line + 1;
}
//Left
pos.SetValues(Position.Line, Position.Column - 1);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != this.Color)
{
break;
}
pos.Column = pos.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);
}
/// <summary>
/// Possibles movements
/// </summary>
/// <returns>Possibles movements of kinight</returns>
public override bool[,] PossibleMovements()
{
bool[,] possiblesMovements = new bool[Board.Rows, Board.Columns];
Position position = new Position(0, 0);
for (int i = 0; i < Board.Rows; i++)
{
for (int j = 0; j < Board.Columns; j++)
{
position.SetValues(i, j);
if ((Board.IsPositionValid(position) && CanMove(position)) && (Position.Row - i == 2 && Position.Column - j == 1) ||
(Board.IsPositionValid(position) && CanMove(position)) && (Position.Row - i == 2 && j - Position.Column == 1) ||
(Board.IsPositionValid(position) && CanMove(position)) && (i - Position.Row == 2 && j - Position.Column == 1) ||
(Board.IsPositionValid(position) && CanMove(position)) && (i - Position.Row == 2 && Position.Column - j == 1) ||
(Board.IsPositionValid(position) && CanMove(position)) && (Position.Row - i == 1 && Position.Column - j == 2) ||
(Board.IsPositionValid(position) && CanMove(position)) && (Position.Row - i == 1 && j - Position.Column == 2) ||
(Board.IsPositionValid(position) && CanMove(position)) && (i - Position.Row == 1 && j - Position.Column == 2) ||
(Board.IsPositionValid(position) && CanMove(position)) && (i - Position.Row == 1 && Position.Column - j == 2))
{
possiblesMovements[i, j] = true;
}
else
{
possiblesMovements[i, j] = false;
}
}
}
return(possiblesMovements);
}
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[,] PossibleMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position pos = new Position(0, 0);
//northeast
pos.SetValues(Position.Line - 1, Position.Column + 1);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Line - 1, pos.Column + 1);
}
//Southeast
pos.SetValues(Position.Line + 1, Position.Column + 1);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Line + 1, pos.Column + 1);
}
//south-west
pos.SetValues(Position.Line + 1, Position.Column - 1);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Line + 1, pos.Column - 1);
}
//northwest
pos.SetValues(Position.Line - 1, Position.Column - 1);
while (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
if (Board.Piece(pos) != null && Board.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Line - 1, pos.Column - 1);
}
return(mat);
}
public override bool[,] PossibleMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position pos = new Position(0, 0);
pos.SetValues(Position.Line + 2, Position.Column + 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line + 1, Position.Column + 2);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line - 2, Position.Column + 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line - 1, Position.Column + 2);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line - 2, Position.Column - 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line - 1, Position.Column - 2);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line + 2, Position.Column - 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line + 1, Position.Column - 2);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
return(mat);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position position = new Position(0, 0);
//UpRight
position.SetValues(Position.Line - 1, Position.Column + 2);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line - 2, Position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//UpLeft
position.SetValues(Position.Line - 1, Position.Column - 2);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line - 2, Position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//DownRight
position.SetValues(Position.Line + 2, Position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line + 1, Position.Column + 2);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//DownLeft
position.SetValues(Position.Line + 2, Position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line + 1, Position.Column - 2);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
return(mat);
}
public override bool[,] PossibleMoves()
{
bool[,] matrix = new bool[Chessboard.Lines, Chessboard.Columns];
var position = new Position(0, 0);
// N
position.SetValues(Position.Line - 1, Position.Column);
while (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
if (Chessboard.GetPiece(position) != null && Chessboard.GetPiece(position).Color != Color)
{
break;
}
position.SetValues(position.Line - 1, Position.Column);
}
// S
position.SetValues(Position.Line + 1, Position.Column);
while (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
if (Chessboard.GetPiece(position) != null && Chessboard.GetPiece(position).Color != Color)
{
break;
}
position.SetValues(position.Line + 1, Position.Column);
}
// E
position.SetValues(Position.Line, Position.Column + 1);
while (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
if (Chessboard.GetPiece(position) != null && Chessboard.GetPiece(position).Color != Color)
{
break;
}
position.SetValues(Position.Line, position.Column + 1);
}
// W
position.SetValues(Position.Line, Position.Column - 1);
while (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
if (Chessboard.GetPiece(position) != null && Chessboard.GetPiece(position).Color != Color)
{
break;
}
position.SetValues(Position.Line, position.Column - 1);
}
return(matrix);
}
/// <summary>
/// Sets possibles movements by piece
/// </summary>
/// <returns>Possibles movements</returns>
public override bool[,] PossibleMovements()
{
bool[,] possiblesMovements = new bool[Board.Rows, Board.Columns];
Position position = new Position(0, 0);
// NW
position.SetValues(Position.Row - 1, Position.Column - 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row - 1, position.Column - 1);
}
// NE
position.SetValues(Position.Row - 1, Position.Column + 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row - 1, position.Column + 1);
}
// SE
position.SetValues(Position.Row + 1, Position.Column + 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row + 1, position.Column + 1);
}
// SW
position.SetValues(Position.Row + 1, Position.Column - 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row + 1, position.Column - 1);
}
return(possiblesMovements);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
//North
pos.SetValues(Position.Row - 1, Position.Column);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row - 1, pos.Column);
}
//South
pos.SetValues(Position.Row + 1, Position.Column);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row + 1, pos.Column);
}
//East
pos.SetValues(Position.Row, Position.Column + 1);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row, pos.Column + 1);
}
//West
pos.SetValues(Position.Row, Position.Column - 1);
while (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
if (Brd.Piece(pos) != null && Brd.Piece(pos).Color != Color)
{
break;
}
pos.SetValues(pos.Row, pos.Column - 1);
}
return(mat);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
pos.SetValues(Position.Row - 1, Position.Column - 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 2, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 2, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 1, Position.Column + 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column + 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 2, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 2, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column - 2);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
return(mat);
}
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);
}
public override bool[,] PossibleMoves()
{
bool[,] matrix = new bool[Chessboard.Lines, Chessboard.Columns];
var position = new Position(0, 0);
// N
position.SetValues(Position.Line - 1, Position.Column);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
// NE
position.SetValues(Position.Line - 1, Position.Column + 1);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
// E
position.SetValues(Position.Line, Position.Column + 1);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
// SE
position.SetValues(Position.Line + 1, Position.Column + 1);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
// S
position.SetValues(Position.Line + 1, Position.Column);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
// SW
position.SetValues(Position.Line + 1, Position.Column - 1);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
// W
position.SetValues(Position.Line, Position.Column - 1);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
// NW
position.SetValues(Position.Line - 1, Position.Column - 1);
if (Chessboard.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
if (Moves == 0 && !game.Mate)
{
// Roque Pequeno #SpecialMove
var firstPosition = new Position(Position.Line, Position.Column + 3);
if (TestRookForCastling(firstPosition))
{
var positionOne = new Position(Position.Line, Position.Column + 1);
var positionTwo = new Position(Position.Line, Position.Column + 2);
if (Chessboard.GetPiece(positionOne) == null && Chessboard.GetPiece(positionTwo) == null)
{
matrix[Position.Line, Position.Column + 2] = true;
}
}
// Roque Grande #SpecialMove
var secondPosition = new Position(Position.Line, Position.Column - 4);
if (TestRookForCastling(secondPosition))
{
var positionOne = new Position(Position.Line, Position.Column - 1);
var positionTwo = new Position(Position.Line, Position.Column - 2);
var positionThree = new Position(Position.Line, Position.Column - 3);
if (Chessboard.GetPiece(positionOne) == null && Chessboard.GetPiece(positionTwo) == null && Chessboard.GetPiece(positionThree) == null)
{
matrix[Position.Line, Position.Column - 2] = true;
}
}
}
return(matrix);
}
public override bool[,] PossibleMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position pos = new Position(0, 0);
//Above
pos.SetValues(Position.Line - 1, Position.Column);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//northeast
pos.SetValues(Position.Line - 1, Position.Column + 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//right
pos.SetValues(Position.Line, Position.Column + 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//Southeast
pos.SetValues(Position.Line + 1, Position.Column + 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//below
pos.SetValues(Position.Line + 1, Position.Column);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//south-west
pos.SetValues(Position.Line + 1, Position.Column - 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//left
pos.SetValues(Position.Line, Position.Column - 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//northwest
pos.SetValues(Position.Line - 1, Position.Column - 1);
if (Board.validPositionTest(pos) && CanMove(pos))
{
mat[pos.Line, pos.Column] = true;
}
//#EspecialPlay rock
if (MoveQuantity == 0 && !Match.Check)
{
//#EspecialPlay Small-Rock
Position posT1 = new Position(Position.Line, Position.Column + 3);
if (TestTowerRock(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;
}
}
//#EspecialPlay Big-Rock
Position posT2 = new Position(Position.Line, Position.Column - 4);
if (TestTowerRock(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);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
if (Color == Color.White)
{
pos.SetValues(Position.Row - 1, Position.Column);
if (Brd.IsValidPosition(pos) && Free(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 2, Position.Column);
Position p2 = new Position(Position.Row - 1, Position.Column);
if (Brd.IsValidPosition(p2) && Free(p2) && Brd.IsValidPosition(pos) && Free(pos) && MovementsQty == 0)
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row - 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
//#Special Play: En Passant
if (Position.Row == 3)
{
Position left = new Position(Position.Row, Position.Column - 1);
if (Brd.IsValidPosition(left) && IsThereEnemy(left) && Brd.Piece(left) == Match.VulnerableEnPassant)
{
mat[left.Row - 1, left.Column] = true;
}
Position right = new Position(Position.Row, Position.Column + 1);
if (Brd.IsValidPosition(right) && IsThereEnemy(right) && Brd.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Row - 1, right.Column] = true;
}
}
}
else
{
pos.SetValues(Position.Row + 1, Position.Column);
if (Brd.IsValidPosition(pos) && Free(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 2, Position.Column);
Position p2 = new Position(Position.Row + 1, Position.Column);
if (Brd.IsValidPosition(p2) && Free(p2) && Brd.IsValidPosition(pos) && Free(pos) && MovementsQty == 0)
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
pos.SetValues(Position.Row + 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && IsThereEnemy(pos))
{
mat[pos.Row, pos.Column] = true;
}
//#Special Play: En Passant
if (Position.Row == 4)
{
Position left = new Position(Position.Row, Position.Column - 1);
if (Brd.IsValidPosition(left) && IsThereEnemy(left) && Brd.Piece(left) == Match.VulnerableEnPassant)
{
mat[left.Row + 1, left.Column] = true;
}
Position right = new Position(Position.Row, Position.Column + 1);
if (Brd.IsValidPosition(right) && IsThereEnemy(right) && Brd.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Row + 1, right.Column] = true;
}
}
}
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);
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);
}
/// <summary>
/// Checks the possibles movements of a piece
/// </summary>
/// <returns>List of possible moviments</returns>
public override bool[,] PossibleMovements()
{
PossiblesExits = 0;
bool[,] possiblesMovements = new bool[Board.Rows, Board.Columns];
Position position = new Position(0, 0);
// N
position.SetValues(Position.Row - 1, Position.Column);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// NE
position.SetValues(Position.Row - 1, Position.Column + 1);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// E
position.SetValues(Position.Row, Position.Column + 1);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// SE
position.SetValues(Position.Row + 1, Position.Column + 1);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// S
position.SetValues(Position.Row + 1, Position.Column);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// SW
position.SetValues(Position.Row + 1, Position.Column - 1);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// W
position.SetValues(Position.Row, Position.Column - 1);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// NW
position.SetValues(Position.Row - 1, Position.Column - 1);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
PossiblesExits++;
}
// #SpecialPlay - Castling
if (NumberOfMovements == 0 && !Match.IsCheck)
{
// little castling
Position posT0 = new Position(Position.Row, Position.Column + 3);
if (TowerToCastling(posT0))
{
Position p1 = new Position(Position.Row, Position.Column + 1);
Position p2 = new Position(Position.Row, Position.Column + 2);
if (Board.Piece(p1) is null && Board.Piece(p2) is null)
{
possiblesMovements[p2.Row, p2.Column] = true;
}
}
// big castling
Position posT1 = new Position(Position.Row, Position.Column - 4);
if (TowerToCastling(posT1))
{
Position p1 = new Position(Position.Row, Position.Column - 1);
Position p2 = new Position(Position.Row, Position.Column - 2);
Position p3 = new Position(Position.Row, Position.Column - 3);
if (Board.Piece(p1) is null && Board.Piece(p2) is null && Board.Piece(p3) is null)
{
possiblesMovements[p2.Row, p2.Column] = true;
}
}
}
return(possiblesMovements);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Brd.Rows, Brd.Columns];
Position pos = new Position(0, 0);
//North
pos.SetValues(Position.Row - 1, Position.Column);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//North-East
pos.SetValues(Position.Row - 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//East
pos.SetValues(Position.Row, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//South-East
pos.SetValues(Position.Row + 1, Position.Column + 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//South
pos.SetValues(Position.Row + 1, Position.Column);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//South-West
pos.SetValues(Position.Row + 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//West
pos.SetValues(Position.Row, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//North-West
pos.SetValues(Position.Row - 1, Position.Column - 1);
if (Brd.IsValidPosition(pos) && CanMove(pos))
{
mat[pos.Row, pos.Column] = true;
}
//#Special Play: Castling
if (MovementsQty == 0 && !Match.Check)
{
//Castling Short
Position posR1 = new Position(Position.Row, Position.Column + 3);
if (CastlingTest(posR1))
{
Position p1 = new Position(Position.Row, Position.Column + 1);
Position p2 = new Position(Position.Row, Position.Column + 2);
if (Brd.Piece(p1) == null && Brd.Piece(p2) == null)
{
mat[Position.Row, Position.Column + 2] = true;
}
}
//Castling Long
Position posR2 = new Position(Position.Row, Position.Column - 4);
if (CastlingTest(posR2))
{
Position p1 = new Position(Position.Row, Position.Column - 1);
Position p2 = new Position(Position.Row, Position.Column - 2);
Position p3 = new Position(Position.Row, Position.Column - 3);
if (Brd.Piece(p1) == null && Brd.Piece(p2) == null && Brd.Piece(p3) == null)
{
mat[Position.Row, Position.Column - 2] = true;
}
}
}
return(mat);
}
public override bool[,] PossibleMoviments()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position pos = new Position(0, 0);
if (Color == Color.white)
{
pos.SetValues(Position.Line - 1, Position.Column);
if (Board.validPositionTest(pos) && Free(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line - 2, Position.Column);
if (Board.validPositionTest(pos) && Free(pos) && MoveQuantity == 0)
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line - 1, Position.Column - 1);
if (Board.validPositionTest(pos) && EnemyExist(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line - 1, Position.Column + 1);
if (Board.validPositionTest(pos) && EnemyExist(pos))
{
mat[pos.Line, pos.Column] = true;
}
//#EspecialPlay en passant
if (Position.Line == 3)
{
Position left = new Position(Position.Line, Position.Column - 1);
if (Board.validPositionTest(left) && EnemyExist(left) && Board.Piece(left) == Match.VulnerableEnPassant)
{
mat[left.Line - 1, left.Column] = true;
}
Position right = new Position(Position.Line, Position.Column + 1);
if (Board.validPositionTest(right) && EnemyExist(right) && Board.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Line - 1, right.Column] = true;
}
}
}
else
{
pos.SetValues(Position.Line + 1, Position.Column);
if (Board.validPositionTest(pos) && Free(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line + 2, Position.Column);
if (Board.validPositionTest(pos) && Free(pos) && MoveQuantity == 0)
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line + 1, Position.Column - 1);
if (Board.validPositionTest(pos) && EnemyExist(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos.SetValues(Position.Line + 1, Position.Column + 1);
if (Board.validPositionTest(pos) && EnemyExist(pos))
{
mat[pos.Line, pos.Column] = true;
}
//#EspecialPlay en passant
if (Position.Line == 4)
{
Position left = new Position(Position.Line, Position.Column - 1);
if (Board.validPositionTest(left) && EnemyExist(left) && Board.Piece(left) == Match.VulnerableEnPassant)
{
mat[left.Line + 1, left.Column] = true;
}
Position right = new Position(Position.Line, Position.Column + 1);
if (Board.validPositionTest(right) && EnemyExist(right) && Board.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Line + 1, right.Column] = true;
}
}
}
return(mat);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position position = new Position(0, 0);
if (Color == Color.White)
{
position.SetValues(Position.Line - 1, Position.Column);
if (Board.ValidPosition(position) && Free(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line - 2, Position.Column);
if (Board.ValidPosition(position) && Free(position) && NumberOfMovements == 0)
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line - 1, Position.Column - 1);
if (Board.ValidPosition(position) && ThereIsOponente(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line - 1, Position.Column + 1);
if (Board.ValidPosition(position) && ThereIsOponente(position))
{
mat[position.Line, position.Column] = true;
}
//#SpecialPlay EnPassant
if (Position.Line == 3)
{
Position left = new Position(Position.Line, Position.Column - 1);
if (Board.ValidPosition(left) && ThereIsOponente(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) && ThereIsOponente(right) && Board.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Line - 1, right.Column] = true;
}
}
}
else
{
position.SetValues(Position.Line + 1, Position.Column);
if (Board.ValidPosition(position) && Free(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line + 2, Position.Column);
if (Board.ValidPosition(position) && Free(position) && NumberOfMovements == 0)
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line + 1, Position.Column - 1);
if (Board.ValidPosition(position) && ThereIsOponente(position))
{
mat[position.Line, position.Column] = true;
}
position.SetValues(Position.Line + 1, Position.Column + 1);
if (Board.ValidPosition(position) && ThereIsOponente(position))
{
mat[position.Line, position.Column] = true;
}
//#SpecialPlay EnPassant
if (Position.Line == 4)
{
Position left = new Position(Position.Line, Position.Column - 1);
if (Board.ValidPosition(left) && ThereIsOponente(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) && ThereIsOponente(right) && Board.Piece(right) == Match.VulnerableEnPassant)
{
mat[right.Line + 1, right.Column] = true;
}
}
}
return(mat);
}
public override bool[,] PossibleMovements()
{
bool[,] mat = new bool[Board.Lines, Board.Columns];
Position position = new Position(0, 0);
//Up
position.SetValues(Position.Line - 1, Position.Column);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//Northeast
position.SetValues(Position.Line - 1, Position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//Right
position.SetValues(Position.Line, Position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//Southeast
position.SetValues(Position.Line + 1, Position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//Down
position.SetValues(Position.Line + 1, Position.Column);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//South-west
position.SetValues(Position.Line + 1, Position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//Left
position.SetValues(Position.Line, Position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//Northwest
position.SetValues(Position.Line - 1, Position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
mat[position.Line, position.Column] = true;
}
//#Special play Castling
if (NumberOfMovements == 0 && !Match.Check)
{
//#Special play castling short
Position positionRook = new Position(Position.Line, Position.Column + 3);
if (TestRookToCastling(positionRook))
{
Position kingMoreOne = new Position(Position.Line, Position.Column + 1);
Position kingMoreTwo = new Position(Position.Line, Position.Column + 2);
if (Board.Piece(kingMoreOne) == null && Board.Piece(kingMoreTwo) == null)
{
mat[Position.Line, Position.Column + 2] = true;
}
}
//#Special play castling long
Position positionRook2 = new Position(Position.Line, Position.Column + 3);
if (TestRookToCastling(positionRook))
{
Position kingOneLess = new Position(Position.Line, Position.Column - 1);
Position kingTwoLess = new Position(Position.Line, Position.Column - 2);
Position kingThreeLess = new Position(Position.Line, Position.Column - 3);
if (Board.Piece(kingOneLess) == null && Board.Piece(kingTwoLess) == null && Board.Piece(kingThreeLess) == null)
{
mat[Position.Line, Position.Column - 2] = true;
}
}
}
return(mat);
}
public override bool[,] PossibleMovements()
{
bool[,] matrix = new bool[board.lines, board.columns];
Position pos = new Position(0, 0);
int direction;
int enPassantLine;
if (color == Color.White)
{
direction = -1;
enPassantLine = 3;
}
else
{
direction = 1;
enPassantLine = 4;
}
// Forward
pos.SetValues(position.line + direction, position.column);
if (board.IsValidPosition(pos) && MightMove(pos))
{
if (board.Piece(pos) == null)
{
matrix[pos.line, pos.column] = true;
}
}
// Forward x2
if (movementAmount == 0)
{
pos.SetValues(position.line + direction + direction, position.column);
if (board.IsValidPosition(pos) && MightMove(pos))
{
if (board.Piece(pos) == null)
{
matrix[pos.line, pos.column] = true;
}
}
}
// Forward-Left
pos.SetValues(position.line + direction, position.column - 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
if (board.Piece(pos) != null)
{
matrix[pos.line, pos.column] = true;
}
}
// Forward-Right
pos.SetValues(position.line + direction, position.column + 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
if (board.Piece(pos) != null)
{
matrix[pos.line, pos.column] = true;
}
}
// # Special move: en passant
if (position.line == enPassantLine)
{
Position onTheLeft = new Position(position.line, position.column - 1);
if (board.IsValidPosition(onTheLeft) && board.Piece(onTheLeft) != null && board.Piece(onTheLeft) == _match.enPassantVulnerable)
{
matrix[onTheLeft.line + direction, onTheLeft.column] = true;
}
Position onTheRight = new Position(position.line, position.column + 1);
if (board.IsValidPosition(onTheRight) && board.Piece(onTheRight) != null && board.Piece(onTheRight) == _match.enPassantVulnerable)
{
matrix[onTheRight.line + direction, onTheRight.column] = true;
}
}
return(matrix);
}
public override bool[,] PossibleMovements()
{
bool[,] matrix = new bool[Board.Lines, Board.Columns];
Position position = new Position(0, 0);
//up
position.SetValues(position.Line - 1, position.Column);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
//top right diagonal
position.SetValues(position.Line - 1, position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
//right
position.SetValues(position.Line, position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
//bottom right diagonal
position.SetValues(position.Line + 1, position.Column + 1);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
//down
position.SetValues(position.Line + 1, position.Column);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
//bottom left diagonal
position.SetValues(position.Line + 1, position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
//left
position.SetValues(position.Line, position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
//top left diagonal
position.SetValues(position.Line - 1, position.Column - 1);
if (Board.ValidPosition(position) && CanMove(position))
{
matrix[position.Line, position.Column] = true;
}
return(matrix);
}
/// <summary>
/// Implements the possibles movements
/// </summary>
/// <returns>Possibles movements</returns>
public override bool[,] PossibleMovements()
{
bool[,] possiblesMovements = new bool[Board.Rows, Board.Columns];
Position position = new Position(0, 0);
for (int i = 0; i < Board.Rows; i++)
{
for (int j = 0; j < Board.Columns; j++)
{
position.SetValues(i, j);
if (Color is Color.White)
{
if ((Board.IsPositionValid(position) && CanMove(position) && Position != null) && (
(!Board.ExistsPiece(position) && Position.Row - i == 1 && Position.Column == j) ||
(!Board.ExistsPiece(position) && (NumberOfMovements < 1) && Position.Row - i == 2 && Position.Column == j) ||
(ExistsEnemy(position) && Position.Row - i == 1 && Position.Column - j == 1) ||
(ExistsEnemy(position) && Position.Row - i == 1 && j - Position.Column == 1)))
{
possiblesMovements[i, j] = true;
}
}
else if (Color is Color.Black)
{
if ((Board.IsPositionValid(position) && CanMove(position) && Position != null) && (
(!Board.ExistsPiece(position) && i - Position.Row == 1 && Position.Column == j) ||
(!Board.ExistsPiece(position) && (NumberOfMovements < 1) && i - Position.Row == 2 && Position.Column == j) ||
(ExistsEnemy(position) && i - Position.Row == 1 && j - Position.Column == 1) ||
(ExistsEnemy(position) && i - Position.Row == 1 && Position.Column - j == 1)))
{
possiblesMovements[i, j] = true;
}
}
}
}
// Checks enpassant
if (Position != null)
{
Position left = new Position(Position.Row, Position.Column - 1);
Position right = new Position(Position.Row, Position.Column + 1);
Piece pieceLeft = null;
Piece pieceRight = null;
if (Board.IsPositionValid(left))
{
pieceLeft = Board.Piece(left);
}
if (Board.IsPositionValid(right))
{
pieceRight = Board.Piece(right);
}
// Black
if (Position.Row == 4)
{
if (Board.IsPositionValid(left) && ExistsEnemy(left) && Match.EnableEnPassant == pieceLeft)
{
possiblesMovements[left.Row + 1, left.Column] = true;
}
else if (Board.IsPositionValid(right) && ExistsEnemy(right) && Match.EnableEnPassant == pieceRight)
{
possiblesMovements[right.Row + 1, right.Column] = true;
}
}
// White
else if (Position.Row == 3)
{
if (Board.IsPositionValid(left) && ExistsEnemy(left) && Match.EnableEnPassant == pieceLeft)
{
possiblesMovements[left.Row - 1, left.Column] = true;
}
else if (Board.IsPositionValid(right) && ExistsEnemy(right) && Match.EnableEnPassant == pieceRight)
{
possiblesMovements[right.Row - 1, right.Column] = true;
}
}
}
return(possiblesMovements);
}
/// <summary>
/// Possibles movements
/// </summary>
/// <returns></returns>
public override bool[,] PossibleMovements()
{
bool[,] possiblesMovements = new bool[Board.Rows, Board.Columns];
Position position = new Position(0, 0);
// N
for (int i = Position.Row - 1; i >= 0; i--)
{
position.SetValues(i, Position.Column);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
}
if (Board.Piece(position) != null && Board.Piece(position).Color != Color || (Board.Piece(position) != null && Board.Piece(position).Color == Color))
{
break;
}
}
// E
for (int i = Position.Column + 1; i <= 7; i++)
{
position.SetValues(Position.Row, i);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
}
if ((Board.Piece(position) != null && Board.Piece(position).Color != Color) || (Board.Piece(position) != null && Board.Piece(position).Color == Color))
{
break;
}
}
// S
for (int i = Position.Row + 1; i <= 7; i++)
{
position.SetValues(i, Position.Column);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
}
if (Board.Piece(position) != null && Board.Piece(position).Color != Color || (Board.Piece(position) != null && Board.Piece(position).Color == Color))
{
break;
}
}
// W
for (int i = Position.Column - 1; i >= 0; i--)
{
position.SetValues(Position.Row, i);
if (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
}
if (Board.Piece(position) != null && Board.Piece(position).Color != Color || (Board.Piece(position) != null && Board.Piece(position).Color == Color))
{
break;
}
}
// NW
position.SetValues(Position.Row - 1, Position.Column - 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row - 1, position.Column - 1);
}
// NE
position.SetValues(Position.Row - 1, Position.Column + 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row - 1, position.Column + 1);
}
// SE
position.SetValues(Position.Row + 1, Position.Column + 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row + 1, position.Column + 1);
}
// SW
position.SetValues(Position.Row + 1, Position.Column - 1);
while (Board.IsPositionValid(position) && CanMove(position))
{
possiblesMovements[position.Row, position.Column] = true;
if (Board.Piece(position) != null && Board.Piece(position).Color != Color)
{
break;
}
position.SetValues(position.Row + 1, position.Column - 1);
}
return(possiblesMovements);
}
public override bool[,] PossibleMovements()
{
bool[,] matrix = new bool[board.lines, board.columns];
Position pos = new Position(0, 0);
// Up-Left
pos.SetValues(position.line - 2, position.column - 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Up-Right
pos.SetValues(position.line - 2, position.column + 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Right-Up
pos.SetValues(position.line - 1, position.column + 2);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Right-Down
pos.SetValues(position.line + 1, position.column + 2);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Down-Right
pos.SetValues(position.line + 2, position.column + 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Down-Left
pos.SetValues(position.line + 2, position.column - 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Left-Down
pos.SetValues(position.line + 1, position.column - 2);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Left-Up
pos.SetValues(position.line - 1, position.column - 2);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
return(matrix);
}
public override bool[,] PossibleMovements()
{
bool[,] matrix = new bool[board.lines, board.columns];
Position pos = new Position(0, 0);
// Up
pos.SetValues(position.line - 1, position.column);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Up-Right
pos.SetValues(position.line - 1, position.column + 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Right
pos.SetValues(position.line, position.column + 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Down-Right
pos.SetValues(position.line + 1, position.column + 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Down
pos.SetValues(position.line + 1, position.column);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Down-Left
pos.SetValues(position.line + 1, position.column - 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Left
pos.SetValues(position.line, position.column - 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// Up-Left
pos.SetValues(position.line - 1, position.column - 1);
if (board.IsValidPosition(pos) && MightMove(pos))
{
matrix[pos.line, pos.column] = true;
}
// # Special move: castling.
if (movementAmount == 0 && !_match.check)
{
// Castling king side.
Position rookPosKingSide = new Position(position.line, position.column + 3);
if (RookCanDoCastling(rookPosKingSide))
{
Position firstField = new Position(position.line, position.column + 1);
Position secondField = new Position(position.line, position.column + 2);
if (board.Piece(firstField) == null && board.Piece(secondField) == null)
{
matrix[secondField.line, secondField.column] = true;
}
}
// Castling queen side.
Position rookPosQueenSide = new Position(position.line, position.column - 4);
if (RookCanDoCastling(rookPosQueenSide))
{
Position firstField = new Position(position.line, position.column - 1);
Position secondField = new Position(position.line, position.column - 2);
Position thirdField = new Position(position.line, position.column - 3);
if (board.Piece(firstField) == null && board.Piece(secondField) == null && board.Piece(thirdField) == null)
{
matrix[secondField.line, secondField.column] = true;
}
}
}
return(matrix);
}
