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); }