protected List <Coordinate> removeImpossibleMoves(Piece[,] board, List <Coordinate> possibleMoves,
Coordinate position, bool kingIsWhite)
{
//creating simulated board of all possible moves
for (short index = 0; index < possibleMoves.Count; index++)
{
Coordinate i = possibleMoves[index];
Piece[,] simulatedBoard = (Piece[, ])board.Clone();
simulatedBoard[i.X, i.Y] = simulatedBoard[position.X, position.Y];
simulatedBoard[position.X, position.Y] = null;
(King, Coordinate)king = findKing(simulatedBoard, kingIsWhite);
if (king.Item1.isCheck(simulatedBoard, king.Item2))
{
Coordinate move = possibleMoves[index];
possibleMoves.RemoveAt(index);
index--;
}
}
return(possibleMoves);
}
/// <summary>
/// Metod som kollar om draget man gjort kommer orsaka schack för sin egna kung.
/// </summary>
/// <param name="Pieces">Spelbrädet som används.</param>
/// <param name="xIndex">X koordinaten för den valda pjäsen.</param>
/// <param name="yIndex">Y koordinaten för den valda pjäsen.</param>
/// <param name="xTarget">X koordinaten för dit den valda pjäsen ska flytta till.</param>
/// <param name="yTarget">Y koordinaten för dit den valda pjäsen ska flytta till.</param>
/// <returns>Returnerar om det draget man gjort kommer schacka sin kung.</returns>
public static bool WillMoveCauseCheck(Piece[,] Pieces, int xIndex, int yIndex, int xTarget, int yTarget)
{
Piece[,] tempBoard = (Piece[, ])Pieces.Clone();
var piece = tempBoard[xIndex, yIndex];
tempBoard[xIndex, yIndex] = null;
tempBoard[xTarget, yTarget] = piece;
return(Check(tempBoard));
}
public bool MovePutsPlayerInCheck(Player player, Square from, Square to)
{
Piece[,] newBoard = (Piece[, ])board.Clone();
Board workingBoard = new Board(player, newBoard);
workingBoard.MovePiece(from, to);
return(workingBoard.PlayerIsInCheck(player));
}
/// <summary>
/// Gets all moves the king can make
/// </summary>
/// <param name="currentState">The game's current state</param>
/// <param name="currentPosition">The king's current position</param>
/// <returns>a list of the valid moves</returns>
public override List <PotentialMove> GetAllValidMoves(Piece[,] currentState, int[] currentPosition)
{
List <PotentialMove> possibleMoves = new List <PotentialMove>();
Piece[,] tempState = new Piece[8, 8];
int newX, newY;
newX = currentPosition[0] - 1;
newY = currentPosition[1] - 1;
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
newX = currentPosition[0];
newY = currentPosition[1] - 1;
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
newX = currentPosition[0] + 1;
newY = currentPosition[1] - 1;
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
newX = currentPosition[0] - 1;
newY = currentPosition[1];
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
newX = currentPosition[0] + 1;
newY = currentPosition[1];
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
newX = currentPosition[0] - 1;
newY = currentPosition[1] + 1;
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
newX = currentPosition[0];
newY = currentPosition[1] + 1;
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
newX = currentPosition[0] + 1;
newY = currentPosition[1] + 1;
tempState = (Piece[, ])currentState.Clone();
TestValidMove(currentState, currentPosition, ref possibleMoves, tempState, newX, newY);
return(possibleMoves);
}
//evaluate current board
public Board(Piece [,] basePieces)
{
//set default values
pieces = (Piece[, ])basePieces.Clone();
sideTable = new SideTable(BoardManager.GetInstance().table1);
playerOneMoves = new List <Square> ();
playerTwoMoves = new List <Square> ();
eval = 0;
playerOneMoves = GetAllLegalMoves(isPlayerOnesTurn: true);
playerTwoMoves = GetAllLegalMoves(isPlayerOnesTurn: false);
eval = Evaluate();
}
public Piece[,] GetBoardAfterMove(Move move)
{
var newBoard = (Piece[, ])Board.Clone();
var position = GetPiecePosition(move.Piece);
var oldId = move.Piece.Id;
if (move.Piece is Pawn && move.Piece.Color == Color.White && move.TargetPosition.Y == 0)
{
move.Piece = new Queen(move.Piece.Color, oldId);
}
if (move.Piece is Pawn && move.Piece.Color == Color.Black && move.TargetPosition.Y == 7)
{
move.Piece = new Queen(move.Piece.Color, oldId);
}
newBoard[position.Y, position.X] = null;
newBoard[move.TargetPosition.Y, move.TargetPosition.X] = move.Piece;
return(newBoard);
}
public void MovePiece(Square from, Square to)
{
var movingPiece = board[from.Row, from.Col];
if (movingPiece == null)
{
return;
}
if (movingPiece.Player != CurrentPlayer)
{
throw new ArgumentException("The supplied piece does not belong to the current player.");
}
//If the space we're moving to is occupied, we need to mark it as captured.
if (board[to.Row, to.Col] != null)
{
OnPieceCaptured(board[to.Row, to.Col]);
}
if (movingPiece.GetType() == typeof(Pawn))
{
if (to.Col != from.Col && GetPiece(to) == null)
{
OnPieceCaptured(board[from.Row, to.Col]);
board[from.Row, to.Col] = null;
}
}
PreviousBoard = (Piece[, ])board.Clone();
//Move the piece and set the 'from' square to be empty.
board[to.Row, to.Col] = board[from.Row, from.Col];
board[from.Row, from.Col] = null;
CurrentPlayer = movingPiece.Player == Player.White ? Player.Black : Player.White;
OnCurrentPlayerChanged(CurrentPlayer);
}
protected Piece[,] Clone(Piece[,] board)
{
return((Piece[, ])board.Clone()); // Shallow Copy
}
private bool AddMove(Player player, string pos, out int errorInPosString)
{
Color curPlayerColor = player.GetColorEmum();
string from;
string to;
string[] subStr = pos.Split(" ");
if (subStr.Length != 2)
{
errorInPosString = -1;
return(false);
}
from = subStr[0].Trim().ToUpper();
to = subStr[1].Trim().ToUpper();
if (!posMapStr.ContainsKey(from))
{
errorInPosString = 1;
return(false);
}
if (!posMapStr.ContainsKey(to))
{
errorInPosString = 2;
return(false);
}
int posFrom = posMapStr[from];
Piece pieceFrom = cellPiece(posFrom);
if (pieceFrom == null || (pieceFrom != null && pieceFrom.GetColor() != curPlayerColor))
{
errorInPosString = 1;
return(false);
}
int posTo = posMapStr[to];
Piece pieceTo = cellPiece(posTo);
if (pieceTo != null && pieceTo.GetColor() == curPlayerColor)
{
errorInPosString = 2;
return(false);
}
var tupleFrom = PosFrom1DTo2D(posFrom);
var tupleTo = PosFrom1DTo2D(posTo);
if (pieceFrom.IsPossibleMove(tupleFrom.Item1, tupleFrom.Item2, tupleTo.Item1, tupleTo.Item2))
{
if (pieceFrom.GetPieceType() == PieceType.King && IsInCheckmate(pieceFrom.GetOtherColor(), tupleTo.Item1, tupleTo.Item2))
{
Console.WriteLine("Invalid move it will be CheckMate!");
errorInPosString = 2;
return(false);
}
// Makes a copy of the board.
var boardTmp = board.Clone();
// Make Move;
board[tupleTo.Item1, tupleTo.Item2] = pieceFrom;
board[tupleFrom.Item1, tupleFrom.Item2] = null;
// Update All references in the peaces to the board.
foreach (Piece p in board)
{
if (p != null)
{
p.SetBoard(this);
}
}
// Get my king position.
int kingRow = -1;
int kingCol = -1;
for (int row = 0; row < 8; row++)
{
for (int col = 0; col < 8; col++)
{
Piece piece = board[row, col];
if (piece != null && piece.GetColor() == curPlayerColor && piece.GetPieceType() == PieceType.King)
{
kingRow = row;
kingCol = col;
}
}
}
if (IsInCheckmate(pieceFrom.GetOtherColor(), kingRow, kingCol))
{
// Reverts the play.
board = (Piece[, ])boardTmp;
// Update All references in the peaces to the board.
foreach (Piece p in board)
{
if (p != null)
{
p.SetBoard(this);
}
}
Console.WriteLine("Invalid move it will be CheckMate!");
errorInPosString = 1;
return(false);
}
errorInPosString = -1;
return(true);
}
errorInPosString = 2;
return(false);
}
public Board Move(IntPoint location, IntPoint targetLocation, out Piece eatenPiece)
{
Debug.Assert(board[location.Y, location.X] != null, $"想要从({location.X},{location.Y})走子，但该位置没有棋子。");
var newBoard = (Piece[, ])board.Clone();
eatenPiece = newBoard[targetLocation.Y, targetLocation.X];
newBoard[targetLocation.Y, targetLocation.X] = newBoard[location.Y, location.X];
newBoard[location.Y, location.X] = null;
var b = new Board(newBoard);
b.redXEqualityRepresentation = redXEqualityRepresentation;
b.redYEqualityRepresentation = redYEqualityRepresentation;
b.blackXEqualityRepresentation = blackXEqualityRepresentation;
b.blackYEqualityRepresentation = blackYEqualityRepresentation;
var movingColor = board[location.Y, location.X].Color;
var movingId = board[location.Y, location.X].ID;
if (movingColor == ChessColor.Red)
{
b.redXEqualityRepresentation -= GetEqualityDigit(movingId, location.X);
b.redYEqualityRepresentation -= GetEqualityDigit(movingId, location.Y);
b.redXEqualityRepresentation += GetEqualityDigit(movingId, targetLocation.X);
b.redYEqualityRepresentation += GetEqualityDigit(movingId, targetLocation.Y);
if (eatenPiece != null)
{
b.blackXEqualityRepresentation -= GetEqualityDigit(eatenPiece.ID, targetLocation.X);
b.blackYEqualityRepresentation -= GetEqualityDigit(eatenPiece.ID, targetLocation.Y);
}
}
else
{
b.blackXEqualityRepresentation -= GetEqualityDigit(movingId, location.X);
b.blackYEqualityRepresentation -= GetEqualityDigit(movingId, location.Y);
b.blackXEqualityRepresentation += GetEqualityDigit(movingId, targetLocation.X);
b.blackYEqualityRepresentation += GetEqualityDigit(movingId, targetLocation.Y);
if (eatenPiece != null)
{
b.redXEqualityRepresentation -= GetEqualityDigit(eatenPiece.ID, targetLocation.X);
b.redYEqualityRepresentation -= GetEqualityDigit(eatenPiece.ID, targetLocation.Y);
}
}
#if DEBUG
ulong rx = b.redXEqualityRepresentation,
ry = b.redYEqualityRepresentation,
bx = b.blackXEqualityRepresentation,
by = b.blackYEqualityRepresentation;
b.InitilizeEqualityRepresentation();
Debug.Assert(b.redXEqualityRepresentation == rx);
Debug.Assert(b.redYEqualityRepresentation == ry);
Debug.Assert(b.blackXEqualityRepresentation == bx);
Debug.Assert(b.blackYEqualityRepresentation == by);
#endif
return(b);
}
private double Minimax(Piece[,] board, int depth, bool whiteSide, bool maximizingPlayer, double alpha, double beta)
{
double initial = 0;
Piece[,] tempBoard;
if (depth == 0)
{
return(GetHeuristic(board, whiteSide));
}
// Volver a calcular los movimientos posibles
List <Move> possibleMoves = new List <Move>();
List <Vector2> forcedPieces = new List <Vector2>();
// Mirar si es obligatorio matar con alguna pieza
forcedPieces = FindForcedPieces(board, whiteSide);
// Si hay alguna incluir los movimientos posibles de ellas
if (forcedPieces.Count > 0)
{
possibleMoves = GetForcedMoves(board, forcedPieces);
}
// Si no incluir todos los movimientos posibles
else if (forcedPieces.Count == 0)
{
possibleMoves = GetAllValidMoves(board, whiteSide);
}
// Si el jugador busca MAX
if (maximizingPlayer)
{
initial = double.NegativeInfinity;
for (int i = 0; i < possibleMoves.Count; i++)
{
tempBoard = (Piece[, ])board.Clone();
MakeMove(tempBoard, possibleMoves[i]);
double result = Minimax(tempBoard, depth - 1, !whiteSide, !maximizingPlayer, alpha, beta);
if (result > initial)
{
initial = result;
}
if (initial > alpha)
{
alpha = initial;
}
if (alpha >= beta)
{
break;
}
}
}
// Si busca MIN
else
{
initial = double.PositiveInfinity;
for (int i = 0; i < possibleMoves.Count; i++)
{
tempBoard = (Piece[, ])board.Clone();
MakeMove(tempBoard, possibleMoves[i]);
double result = Minimax(tempBoard, depth - 1, !whiteSide, !maximizingPlayer, alpha, beta);
if (result < initial)
{
initial = result;
}
if (initial < alpha)
{
alpha = initial;
}
if (alpha >= beta)
{
break;
}
}
}
return(initial);
}
private Move MinimaxStart(Piece[,] board, int depth, bool whiteSide, bool maximizingPlayer)
{
double alpha = double.NegativeInfinity;
double beta = double.PositiveInfinity;
List <Move> possibleMoves = new List <Move>();
List <Vector2> forcedPieces = new List <Vector2>();
// Mirar si es obligatorio matar con alguna pieza y guardar sus x e y
forcedPieces = FindForcedPieces(board, whiteSide);
// Si hay alguna incluir los movimientos posibles de ellas
if (forcedPieces.Count > 0)
{
possibleMoves = GetForcedMoves(board, forcedPieces);
}
// Si no incluir todos los movimientos posibles
else if (forcedPieces.Count == 0)
{
possibleMoves = GetAllValidMoves(board, whiteSide);
}
// Si no hay movimientos posibles return null
if (possibleMoves.Count == 0)
{
Debug.Log("NO HAY MOVIMIENTOS");
return(null);
}
// Crear la lista para guardar los valores de los estados
List <double> heuristics = new List <double>();
// Crear un tablero temporal
Piece[,] tempBoard;
// Por cada uno de los movimientos posibles
for (int i = 0; i < possibleMoves.Count; i++)
{
tempBoard = (Piece[, ])board.Clone();
// Hacer el movimiento en el tablero temporal
MakeMove(tempBoard, possibleMoves[i]);
// Hacer el calculo
heuristics.Add(Minimax(tempBoard, depth - 1, !whiteSide, !maximizingPlayer, alpha, beta));
}
// Buscar el valor maximo en la lista de heuristicas
double maxHeuristics = double.NegativeInfinity;
for (int i = heuristics.Count - 1; i >= 0; i--)
{
if (heuristics[i] >= maxHeuristics)
{
maxHeuristics = heuristics[i];
}
}
// Filtrar segun resultado dejando solo los movimientos mas valiosos
for (int i = 0; i < heuristics.Count; i++)
{
if (heuristics[i] < maxHeuristics)
{
heuristics.RemoveAt(i);
possibleMoves.RemoveAt(i);
i--;
}
}
// Devolver aleatoriamente un movimiento de entre los de igual valia
int rand = (int)Random.Range(0, possibleMoves.Count);
return(possibleMoves[rand]);
}
/// <summary>
/// Gets all valid moves
/// </summary>
/// <param name="currentState">The current state of the game</param>
/// <param name="currentPosition">the pawn's current position</param>
/// <returns>the list of valid moves</returns>
public override List <PotentialMove> GetAllValidMoves(Piece[,] currentState, int[] currentPosition)
{
List <PotentialMove> possibleMoves = new List <PotentialMove>();
Piece[,] tempState = new Piece[8, 8];
int newX, newY;
if (PieceTeam == true)
{
newX = currentPosition[0];
newY = currentPosition[1];
newY++;
if (ValidatePawnMove(currentPosition, new[] { newX, newY }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
if (ValidatePawnMove(currentPosition, new[] { newX + 1, newY }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX + 1, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX + 1, newY }, tempState));
}
if (ValidatePawnMove(currentPosition, new[] { newX - 1, newY }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX - 1, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX - 1, newY }, tempState));
}
if (ValidatePawnMove(currentPosition, new[] { newX, newY + 1 }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY + 1] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY + 1 }, tempState));
}
}
else if (PieceTeam == false)
{
newX = currentPosition[0];
newY = currentPosition[1];
newY--;
if (ValidatePawnMove(currentPosition, new[] { newX, newY }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
if (ValidatePawnMove(currentPosition, new[] { newX + 1, newY }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX + 1, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX + 1, newY }, tempState));
}
if (ValidatePawnMove(currentPosition, new[] { newX - 1, newY }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX - 1, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX - 1, newY }, tempState));
}
if (ValidatePawnMove(currentPosition, new[] { newX, newY - 1 }, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY - 1] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY - 1 }, tempState));
}
}
return(possibleMoves);
}
public Piece[,] GetTable()
{
return((Piece[, ])table.Clone());
}
/// <summary>
/// Gets all rook valid moves
/// </summary>
/// <param name="currentState">The game's current state</param>
/// <param name="currentPosition">The rook's current position</param>
/// <returns>A list of all valid moves found</returns>
public List <PotentialMove> GetAllValidRookMoves(Piece[,] currentState, int[] currentPosition)
{
List <PotentialMove> possibleMoves = new List <PotentialMove>();
Piece[,] tempState = new Piece[8, 8];
int newX, newY;
newX = currentPosition[0];
newY = currentPosition[1];
tempState = (Piece[, ])currentState.Clone();
newX++;
while (TestValidMove(new[] { newX, newY }, currentPosition, PieceTeam, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
if (currentState[newX, newY] != null && currentState[newX, newY].PieceTeam != currentState[currentPosition[0], currentPosition[1]].pieceTeam)
{
break;
}
newX++;
}
newX = currentPosition[0];
newY = currentPosition[1];
tempState = (Piece[, ])currentState.Clone();
newY++;
while (TestValidMove(new[] { newX, newY }, currentPosition, PieceTeam, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
if (currentState[newX, newY] != null && currentState[newX, newY].PieceTeam != currentState[currentPosition[0], currentPosition[1]].pieceTeam)
{
break;
}
newY++;
}
newX = currentPosition[0];
newY = currentPosition[1];
tempState = (Piece[, ])currentState.Clone();
newX--;
while (TestValidMove(new[] { newX, newY }, currentPosition, PieceTeam, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
if (currentState[newX, newY] != null && currentState[newX, newY].PieceTeam != currentState[currentPosition[0], currentPosition[1]].pieceTeam)
{
break;
}
newX--;
}
newX = currentPosition[0];
newY = currentPosition[1];
tempState = (Piece[, ])currentState.Clone();
newY--;
while (TestValidMove(new[] { newX, newY }, currentPosition, PieceTeam, currentState))
{
tempState = (Piece[, ])currentState.Clone();
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
if (currentState[newX, newY] != null && currentState[newX, newY].PieceTeam != currentState[currentPosition[0], currentPosition[1]].pieceTeam)
{
break;
}
newY--;
}
return(possibleMoves);
}
/// <summary>
/// Gets all moves a given knight could make
/// </summary>
/// <param name="currentState">TYhe game's current state</param>
/// <param name="currentPosition">The knight's current position</param>
/// <returns>The list of valid moves</returns>
public override List <PotentialMove> GetAllValidMoves(Piece[,] currentState, int[] currentPosition)
{
List <PotentialMove> possibleMoves = new List <PotentialMove>();
Piece[,] tempState = new Piece[8, 8];
int newX, newY;
newX = currentPosition[0] - 1;
newY = currentPosition[1] - 2;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
newX = currentPosition[0] + 1;
newY = currentPosition[1] - 2;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
newX = currentPosition[0] - 1;
newY = currentPosition[1] + 2;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
newX = currentPosition[0] + 1;
newY = currentPosition[1] + 2;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
newX = currentPosition[0] + 2;
newY = currentPosition[1] - 1;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
newX = currentPosition[0] + 2;
newY = currentPosition[1] + 1;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
newX = currentPosition[0] - 2;
newY = currentPosition[1] - 1;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
newX = currentPosition[0] - 2;
newY = currentPosition[1] + 1;
tempState = (Piece[, ])currentState.Clone();
if (TestValidMove(new[] { newX, newY }, currentPosition, currentState[currentPosition[0], currentPosition[1]].PieceTeam, currentState))
{
tempState[newX, newY] = tempState[currentPosition[0], currentPosition[1]];
tempState[currentPosition[0], currentPosition[1]] = null;
possibleMoves.Add(new PotentialMove(currentPosition, new[] { newX, newY }, tempState));
}
return(possibleMoves);
}
