public sealed override void MovePiece(int originRow, int originColumn, int targetRow, int targetColumn)
{
var origin = RemovePiece(originRow, originColumn);
var target = RemovePiece(targetRow, targetColumn);
var specialMove = false;
var pawnsDoubleStepForward = false;
var incomingPromotion = false;
if (origin is Pawn)
{
if (Math.Abs(originRow - targetRow) == 2) // First move, Double-step-forward
{
EnPassantVulnerable = origin as Pawn;
pawnsDoubleStepForward = true;
}
else if (target is null && Math.Abs(originColumn - targetColumn) == 1) // En passant
{
RemovePiece(EnPassantVulnerable);
CapturedPieces.Add(EnPassantVulnerable);
}
else if (origin.Side == BoardSide.Bottom && targetRow == 0 || origin.Side == BoardSide.Top && targetRow == Rows - 1) // Promotion
{
incomingPromotion = true;
}
}
private GamePiece PerformMove(Position origin, Position destiny)
{
GamePiece piece = Board.RemovePiece(origin);
piece.IncrementNumberOfMovements();
GamePiece capturedPiece = Board.RemovePiece(destiny);
Board.PlacePiece(piece, destiny);
if (capturedPiece != null)
{
CapturedPieces.Add(capturedPiece);
}
// SPECIAL MOVES:
// Lesser Castling
if (piece is King && destiny.Column == origin.Column + 2)
{
Position rookOrigin = new Position(origin.Row, origin.Column + 3);
Position rookDestiny = new Position(origin.Row, origin.Column + 1);
GamePiece rook = Board.RemovePiece(rookOrigin);
rook.IncrementNumberOfMovements();
Board.PlacePiece(rook, rookDestiny);
}
// Greater Castling
if (piece is King && destiny.Column == origin.Column - 2)
{
Position rookOrigin = new Position(origin.Row, origin.Column - 4);
Position rookDestiny = new Position(origin.Row, origin.Column - 1);
GamePiece rook = Board.RemovePiece(rookOrigin);
rook.IncrementNumberOfMovements();
Board.PlacePiece(rook, rookDestiny);
}
// En Passent
if (piece is Pawn)
{
if (destiny.Column != origin.Column && capturedPiece == null)
{
Position targetPawnPosition;
if (piece.Color == Color.White)
{
targetPawnPosition = new Position(destiny.Row + 1, destiny.Column);
}
else
{
targetPawnPosition = new Position(destiny.Row - 1, destiny.Column);
}
capturedPiece = Board.RemovePiece(targetPawnPosition);
CapturedPieces.Add(capturedPiece);
}
}
return(capturedPiece);
}
private Piece MakeMove(Position source, Position target)
{
ChessPiece sourcePiece = (ChessPiece)Board.RemovePiece(source);
sourcePiece.IncreaseMoveCount();
Piece capturedPiece = Board.RemovePiece(target);
Board.PlacePiece(sourcePiece, target);
if (capturedPiece != null)
{
PiecesOnTheBoard.Remove(capturedPiece);
CapturedPieces.Add(capturedPiece);
}
//SpecialMove Castling KingSide Rook
if (sourcePiece is King && target.Column == source.Column + 2)
{
Position sourceRook = new Position(source.Row, source.Column + 3);
Position targetRook = new Position(source.Row, source.Column + 1);
ChessPiece rook = (ChessPiece)Board.RemovePiece(sourceRook);
Board.PlacePiece(rook, targetRook);
rook.IncreaseMoveCount();
}
//SpecialMove Castling QueenSide Rook
if (sourcePiece is King && target.Column == source.Column - 2)
{
Position sourceRook = new Position(source.Row, source.Column - 4);
Position targetRook = new Position(source.Row, source.Column - 1);
ChessPiece rook = (ChessPiece)Board.RemovePiece(sourceRook);
Board.PlacePiece(rook, targetRook);
rook.IncreaseMoveCount();
}
//SpecialMove EnPassant
if (sourcePiece is Pawn)
{
if (source.Column != target.Column && capturedPiece == null)
{
Position pawnPosition;
if (sourcePiece.Color == Color.White)
{
pawnPosition = new Position(target.Row + 1, target.Column);
}
else
{
pawnPosition = new Position(target.Row - 1, target.Column);
}
capturedPiece = Board.RemovePiece(pawnPosition);
CapturedPieces.Add(capturedPiece);
PiecesOnTheBoard.Remove(capturedPiece);
}
}
return(capturedPiece);
}
public Piece ExecuteMovement(Position origin, Position destiny)
{
Piece piece = Board.RemovePiece(origin);
piece.IncrementMovementQuantity();
Piece capturedPiece = Board.RemovePiece(destiny);
Board.PlacePiece(piece, destiny);
if (capturedPiece != null)
{
CapturedPieces.Add(capturedPiece);
}
// #SpecialMove Short Castling
if (piece is King && destiny.Column == origin.Column + 2)
{
Position originTower = new Position(origin.Row, origin.Column + 3);
Position destinyTower = new Position(origin.Row, origin.Column + 1);
Piece tower = Board.RemovePiece(originTower);
tower.IncrementMovementQuantity();
Board.PlacePiece(tower, destinyTower);
}
// #SpecialMove Long Castling
if (piece is King && destiny.Column == origin.Column - 2)
{
Position originTower = new Position(origin.Row, origin.Column - 4);
Position destinyTower = new Position(origin.Row, origin.Column - 1);
Piece tower = Board.RemovePiece(originTower);
tower.IncrementMovementQuantity();
Board.PlacePiece(tower, destinyTower);
}
// #Special Move en Passant
if (piece is Pawn)
{
if (origin.Column != destiny.Column && capturedPiece == null)
{
Position pawnPosition;
if (piece.Color == Color.White)
{
pawnPosition = new Position(destiny.Row + 1, destiny.Column);
}
else
{
pawnPosition = new Position(destiny.Row - 1, destiny.Column);
}
capturedPiece = Board.RemovePiece(pawnPosition);
CapturedPieces.Add(capturedPiece);
}
}
return(capturedPiece);
}
public Piece ChessMove(Position origin, Position destiny)
{
Piece movedPiece = Board.RemovePiece(origin);
movedPiece.IncreaseQtyMovement();
Piece takenPiece = Board.RemovePiece(destiny);
Board.AddressPiece(movedPiece, destiny);
if (takenPiece != null)
{
CapturedPieces.Add(takenPiece);
}
//Special move: Castling
////Short Castling
if (movedPiece is King && destiny.Column == origin.Column + 2)
{
Position rookOrigin = new Position(origin.Line, origin.Column + 3);
Position rookDestiny = new Position(origin.Line, origin.Column + 1);
Piece movedRook = Board.RemovePiece(rookOrigin);
movedRook.IncreaseQtyMovement();
Board.AddressPiece(movedRook, rookDestiny);
}
////Long Castling
if (movedPiece is King && destiny.Column == origin.Column - 2)
{
Position rookOrigin = new Position(origin.Line, origin.Column - 4);
Position rookDestiny = new Position(origin.Line, origin.Column - 1);
Piece movedRook = Board.RemovePiece(rookOrigin);
movedRook.IncreaseQtyMovement();
Board.AddressPiece(movedRook, rookDestiny);
}
//Special move: En passant
if (movedPiece is Pawn)
{
if (origin.Column != destiny.Column)
{
Position EnPassantCapture;
if (movedPiece.Color == Color.White)
{
EnPassantCapture = new Position(destiny.Line + 1, destiny.Column);
}
else
{
EnPassantCapture = new Position(destiny.Line - 1, destiny.Column);
}
takenPiece = Board.RemovePiece(EnPassantCapture);
CapturedPieces.Add(takenPiece);
}
}
return(takenPiece);
}
public Piece RunMoviment(Position origin, Position destiny)
{
Piece p = ChessBoard.RemovePiece(origin);
p.IncrementQnttMovies();
Piece CapturedPiece = ChessBoard.RemovePiece(destiny);
ChessBoard.InsertPiece(p, destiny);
if (CapturedPiece != null)
{
CapturedPieces.Add(CapturedPiece);
}
//#jogada especial roque pequeno
if (p is King && destiny.Column == origin.Column + 2)
{
Position originT = new Position(origin.Line, origin.Column + 3);
Position destinyT = new Position(origin.Line, origin.Column + 1);
Piece T = ChessBoard.RemovePiece(originT);
T.IncrementQnttMovies();
ChessBoard.InsertPiece(T, destinyT);
}
//#jogada especial roque Grande
if (p is King && destiny.Column == origin.Column - 2)
{
Position originT = new Position(origin.Line, origin.Column - 4);
Position destinyT = new Position(origin.Line, origin.Column - 1);
Piece T = ChessBoard.RemovePiece(originT);
T.IncrementQnttMovies();
ChessBoard.InsertPiece(T, destinyT);
}
//#jogada especial EnPassant
if (p is Pawn)
{
if (origin.Column != destiny.Column && CapturedPiece == null)
{
Position posP;
if (p.Color == Color.Branca)
{
posP = new Position(destiny.Line + 1, destiny.Column);
}
else
{
posP = new Position(destiny.Line - 1, destiny.Column);
}
CapturedPiece = ChessBoard.RemovePiece(posP);
CapturedPieces.Add(CapturedPiece);
}
}
return(CapturedPiece);
}
public void UndoMovement(Position origin, Position destiny, Piece capturedPiece)
{
Piece piece = Board.RemovePiece(destiny);
piece.DecreaseMovementQuantity();
if (capturedPiece != null)
{
Board.PlacePiece(capturedPiece, destiny);
CapturedPieces.Remove(capturedPiece);
}
Board.PlacePiece(piece, origin);
// #SpecialMove Short Castling
if (piece is King && destiny.Column == origin.Column + 2)
{
Position originTower = new Position(origin.Row, origin.Column + 3);
Position destinyTower = new Position(origin.Row, origin.Column + 1);
Piece tower = Board.RemovePiece(destinyTower);
tower.DecreaseMovementQuantity();
Board.PlacePiece(tower, originTower);
}
// #SpecialMove Long Castling
if (piece is King && destiny.Column == origin.Column - 2)
{
Position originTower = new Position(origin.Row, origin.Column - 4);
Position destinyTower = new Position(origin.Row, origin.Column - 1);
Piece tower = Board.RemovePiece(destinyTower);
tower.DecreaseMovementQuantity();
Board.PlacePiece(tower, originTower);
}
// #Special Move en Passant
if (piece is Pawn)
{
if (origin.Column != destiny.Column && capturedPiece == VulnerableEnPassant)
{
Piece pawn = Board.RemovePiece(destiny);
Position pawnPosition;
if (piece.Color == Color.White)
{
pawnPosition = new Position(3, destiny.Column);
}
else
{
pawnPosition = new Position(4, destiny.Column);
}
Board.PlacePiece(pawn, pawnPosition);
}
}
}
private void UndoMove(Position source, Position target, Piece capturedPiece)
{
ChessPiece p = (ChessPiece)Board.RemovePiece(target);
p.DecreaseMoveCount();
Board.PlacePiece(p, source);
if (capturedPiece != null)
{
Board.PlacePiece(capturedPiece, target);
CapturedPieces.Remove(capturedPiece);
PiecesOnTheBoard.Add(capturedPiece);
}
//SpecialMove Castling KingSide Rook
if (p is King && target.Column == source.Column + 2)
{
Position sourceRook = new Position(source.Row, source.Column + 3);
Position targetRook = new Position(source.Row, source.Column + 1);
ChessPiece rook = (ChessPiece)Board.RemovePiece(targetRook);
Board.PlacePiece(rook, sourceRook);
rook.DecreaseMoveCount();
}
//SpecialMove Castling QueenSide Rook
if (p is King && target.Column == source.Column - 2)
{
Position sourceRook = new Position(source.Row, source.Column - 4);
Position targetRook = new Position(source.Row, source.Column - 1);
ChessPiece rook = (ChessPiece)Board.RemovePiece(targetRook);
Board.PlacePiece(rook, sourceRook);
rook.DecreaseMoveCount();
}
//SpecialMove EnPassant
if (p is Pawn)
{
if (source.Column != target.Column && capturedPiece == EnPassantVulnerable)
{
ChessPiece pawn = (ChessPiece)Board.RemovePiece(target);
Position pawnPosition;
if (p.Color == Color.White)
{
pawnPosition = new Position(3, target.Column);
}
else
{
pawnPosition = new Position(3, target.Column);
}
Board.PlacePiece(pawn, pawnPosition);
}
}
}
private void UndoMove(Position origin, Position destiny, GamePiece capturedPiece)
{
GamePiece piece = Board.RemovePiece(destiny);
piece.DecrementNumberOfMovements();
if (capturedPiece != null)
{
Board.PlacePiece(capturedPiece, destiny);
CapturedPieces.Remove(capturedPiece);
}
Board.PlacePiece(piece, origin);
// SPECIAL MOVES:
// Lesser Castling
if (piece is King && destiny.Column == origin.Column + 2)
{
Position rookOrigin = new Position(origin.Row, origin.Column + 3);
Position rookDestiny = new Position(origin.Row, origin.Column + 1);
GamePiece rook = Board.RemovePiece(rookDestiny);
rook.DecrementNumberOfMovements();
Board.PlacePiece(rook, rookOrigin);
}
// Lesser Castling
if (piece is King && destiny.Column == origin.Column - 2)
{
Position rookOrigin = new Position(origin.Row, origin.Column - 4);
Position rookDestiny = new Position(origin.Row, origin.Column - 1);
GamePiece rook = Board.RemovePiece(rookDestiny);
rook.DecrementNumberOfMovements();
Board.PlacePiece(rook, rookOrigin);
}
// En Passent
if (piece is Pawn)
{
if (destiny.Column != origin.Column && capturedPiece == EnPassentTarget)
{
GamePiece targetPawn = Board.RemovePiece(destiny);
Position targetPawnPosition;
if (piece.Color == Color.White)
{
targetPawnPosition = new Position(3, destiny.Column);
}
else
{
targetPawnPosition = new Position(4, destiny.Column);
}
Board.PlacePiece(targetPawn, targetPawnPosition);
}
}
}
public void UndoMove(Position from, Position to, Piece capturedPiece)
{
Piece p = Board.RemovePiece(to);
p.SubtractQntMoves();
if (capturedPiece != null)
{
Board.PutPiece(capturedPiece, to);
CapturedPieces.Remove(capturedPiece);
}
Board.PutPiece(p, from);
}
public void UndoChessMove(Position origin, Position destiny, Piece takenPiece)
{
Piece returnedPiece = Board.RemovePiece(destiny);
returnedPiece.DecreaseQtyMovement();
Board.AddressPiece(returnedPiece, origin);
if (takenPiece != null)
{
Board.AddressPiece(takenPiece, destiny);
CapturedPieces.Remove(takenPiece);
}
//Special move: Castling
//Short Castling
if (returnedPiece is King && destiny.Column == origin.Column + 2)
{
Position rookOrigin = new Position(origin.Line, origin.Column + 3);
Position rookDestiny = new Position(origin.Line, origin.Column + 1);
Piece movedRook = Board.RemovePiece(rookDestiny);
movedRook.DecreaseQtyMovement();
Board.AddressPiece(movedRook, rookOrigin);
}
//Long Castling
if (returnedPiece is King && destiny.Column == origin.Column - 2)
{
Position rookOrigin = new Position(origin.Line, origin.Column - 4);
Position rookDestiny = new Position(origin.Line, origin.Column - 1);
Piece movedRook = Board.RemovePiece(rookDestiny);
movedRook.DecreaseQtyMovement();
Board.AddressPiece(movedRook, rookOrigin);
}
//Special move: En passant
if (returnedPiece is Pawn)
{
if (origin.Column != destiny.Column && takenPiece == VulnerableToEnPassant)
{
Piece EnPassantCapture = Board.RemovePiece(destiny);
Position EnPassantReturnPosition;
if (returnedPiece.Color == Color.White)
{
EnPassantReturnPosition = new Position(3, destiny.Column);
}
else
{
EnPassantReturnPosition = new Position(4, destiny.Column);
}
Board.AddressPiece(EnPassantCapture, EnPassantReturnPosition);
}
}
}
public Piece ExecuteMove(Position from, Position to)
{
Piece p = Board.RemovePiece(from);
p.SumQntMoves();
Piece capturedPiece = Board.RemovePiece(to);
Board.PutPiece(p, to);
if (capturedPiece != null)
{
CapturedPieces.Add(capturedPiece);
}
return(capturedPiece);
}
public void UndoMoviment(Position origin, Position destiny, Piece captPiece)
{
Piece p = ChessBoard.RemovePiece(destiny);
p.DecrementQnttMovies();
if (captPiece != null)
{
ChessBoard.InsertPiece(captPiece, destiny);
CapturedPieces.Remove(captPiece);
}
ChessBoard.InsertPiece(p, origin);
//#jogada especial roque pequeno
if (p is King && destiny.Column == origin.Column + 2)
{
Position originT = new Position(origin.Line, origin.Column + 3);
Position destinyT = new Position(origin.Line, origin.Column + 1);
Piece T = ChessBoard.RemovePiece(destinyT);
T.DecrementQnttMovies();
ChessBoard.InsertPiece(T, originT);
}
//#jogada especial roque pequeno
if (p is King && destiny.Column == origin.Column - 2)
{
Position originT = new Position(origin.Line, origin.Column - 4);
Position destinyT = new Position(origin.Line, origin.Column - 1);
Piece T = ChessBoard.RemovePiece(destinyT);
T.DecrementQnttMovies();
ChessBoard.InsertPiece(T, originT);
}
//#jogada especial EnPassant
if (p is Pawn)
{
if (origin.Column != destiny.Column && captPiece == VulnerableForEnPassant)
{
Piece pawn = ChessBoard.RemovePiece(destiny);
Position posP;
if (p.Color == Color.Branca)
{
posP = new Position(3, destiny.Column);
}
else
{
posP = new Position(4, destiny.Column);
}
}
}
}
public void UndoTurn(Turn turn, TurnResult turnResult, bool doChecks = true)
{
MiniMax.UndoTurnCount++;
AlphaBetaSearch.UndoTurnCount++;
InTurnPlayerIndex = 1 - InTurnPlayerIndex;
WinningPlayerIndex = null;
Vector movedPosition = turn.OriginalPosition.Add(turn.Move);
Piece piece = Board[movedPosition.X, movedPosition.Y];
if (turnResult.CapturedPieceType != null)
{
Piece capturedPiece = CapturedPieces.Pop();
if (doChecks)
{
if (!capturedPiece.IsCaptured)
{
throw new Exception("Huh");
}
if (capturedPiece.PlayerIndex != 1 - InTurnPlayerIndex)
{
throw new Exception("huh");
}
if (capturedPiece.PieceType != turnResult.CapturedPieceType)
{
throw new ArgumentException("Bad TurnResult.CapturedPieceType");
}
if (!capturedPiece.Position.Equals(movedPosition))
{
throw new ArgumentException("Bad CapturedPiece Position mismatch");
}
}
capturedPiece.IsCaptured = false;
Board[movedPosition.X, movedPosition.Y] = capturedPiece;
}
else
{
Board[movedPosition.X, movedPosition.Y] = null;
}
piece.Position = turn.OriginalPosition;
Board[turn.OriginalPosition.X, turn.OriginalPosition.Y] = piece;
Card tmp = GameCards[MiddleCardIndex];
GameCards[MiddleCardIndex] = GameCards[PlayerCardIndices[InTurnPlayerIndex][turn.CardIndex]];
GameCards[PlayerCardIndices[InTurnPlayerIndex][turn.CardIndex]] = tmp;
}
/// <summary>
/// Execute move of chess piece
/// </summary>
/// <param name="origin">Origin of piece</param>
/// <param name="target">Target position</param>
public Piece ExecuteMove(Position origin, Position target)
{
Piece piece = Board.RemovePiece(origin);
Piece capturedPiece = Board.RemovePiece(target);
Board.PutPiece(piece, target);
// Log
StringBuilder text = new StringBuilder();
text.AppendLine("Move piece");
text.AppendLine(string.Concat("Piece: ", piece.GetType()));
text.AppendLine(string.Concat("Color: ", piece.Color.ToString()));
text.AppendLine(string.Concat("Origin ChessPosition: ", origin.ToChessPosition().ToString(), " Origin CanvasPosition(Column, Row): ", origin.Column, ", ", origin.Row));
text.AppendLine(string.Concat("Target ChessPosition: ", target.ToChessPosition().ToString(), " Target CanvasPosition(Column, Row): ", target.Column, ", ", target.Row));
text.AppendLine(string.Concat("Turn: ", TotalMoves));
text.AppendLine(string.Concat("Date: ", DateTime.Now.ToShortDateString(), " Time: ", DateTime.Now.ToShortTimeString()));
piece.IncrementMovements();
if (capturedPiece != null)
{
CapturedPieces.Add(capturedPiece);
text.AppendLine(string.Concat("Captured: ", capturedPiece.GetType()));
}
WriteLog.ChecksLogs(text);
if (Board.Piece(target) is King && ((target.Column + 2 == origin.Column) || (target.Column - 2 == origin.Column)))
{
ExecuteCastling(Board.Piece(target));
}
if (Board.Piece(target) != null && Board.Piece(target) is Pawn && origin.Column != target.Column && capturedPiece == null)
{
capturedPiece = ExecuteEnPassant(Board.Piece(target), origin);
}
if (capturedPiece != null)
{
CapturedPieces.Add(capturedPiece);
}
return(capturedPiece);
}
void Start()
{
con = GameObject.FindObjectOfType <UCIConsole>();
con.STDIN = "Start Game <Board.cs>";
con.STDIN = myGUID.ToString();
FENString.ParseString("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq c6 0 2");
captured = yourPieces;
if (FENString.isValid)
{
_board = FENString.Layout;
con.STDIN = ("FEN " + FENString.RawString);
// Moves.Add(FENString);
_positionMatrix = BuildPositionMatrix();
}
SetupBoard(_board);
Upated = true;
}
public void MovePiece(ChessPiece piece, byte rowIndex, byte colIndex)
{
try
{
//remove the piece from its original position
ChessBoardCell originalPosition = piece.BoardPosition;
originalPosition.PieceInCell = null;
//Obtain the new position
ChessBoardCell cell = this[rowIndex, colIndex];
if (cell != null)
{
//Check if the new position capture a piece.
if (cell.PieceInCell != null)
{
if (cell.PieceInCell.Color != piece.Color)
{
//Capture the other piece
ChessPiece capturedPiece = cell.PieceInCell;
CapturedPieces.Add(capturedPiece);
//Player Expected Action: The player remove the piece of his active piece list.
//Piece Expected Action: Update its internal position record.
OnNewPieceCaptured?.Invoke(this, new PieceCapturedEventArgs(capturedPiece));
//Remove the captured piece from board.
cell.PieceInCell = null;
}
else
{
throw new ChessExceptionInvalidGameAction(ExceptionCode.InvalidAttemptToCapturePiece, "The piece that you are trying to capture has the same color than the moved piece");
}
}
cell.PieceInCell = piece;
piece.BoardPosition = cell;
}
}
catch (Exception)
{
throw new ChessExceptionInvalidGameAction(ExceptionCode.InvalidCellIndexes, "Row Index: " + rowIndex + ", Col Index: " + colIndex);
}
}
/// <summary>
/// Undo the movement itself that would put in check
/// </summary>
/// <param name="piece">Current piece</param>
/// <param name="capturedPiece">Captured piece</param>
/// <param name="origin">Origin of current piece</param>
private void UndoMovement(Position origin, Position target, Piece captured)
{
Piece piece = Board.RemovePiece(target);
piece.DecrementMovements();
StringBuilder text = new StringBuilder();
Position originAux = null;
if (captured != null)
{
text.AppendLine("Undo captured");
text.AppendLine(string.Concat("Captured Piece: ", captured.GetType()));
text.AppendLine(string.Concat("Color: ", captured.Color.ToString()));
if (captured != EnableEnPassant)
{
Board.PutPiece(captured, target);
text.AppendLine(string.Concat("Origin ChessPosition: ", origin.ToChessPosition().ToString(), " Origin CanvasPosition(Column, Row): ", origin.Column, ", ", origin.Row));
CapturedPieces.Remove(captured);
}
else
{
originAux = new Position(origin.Row, target.Column);
Board.PutPiece(captured, originAux);
CapturedPieces.Remove(captured);
text.AppendLine(string.Concat("Origin ChessPosition: ", originAux.ToChessPosition().ToString(), " Origin CanvasPosition(Column, Row): ", originAux.Column, ", ", originAux.Row));
}
text.AppendLine(string.Concat("Turn: ", TotalMoves));
text.AppendLine(string.Concat("Date: ", DateTime.Now.ToShortDateString(), " Time: ", DateTime.Now.ToShortTimeString()));
text.AppendLine();
}
Board.PutPiece(piece, origin);
text.AppendLine(string.Concat("Undo Piece: ", captured.GetType()));
text.AppendLine(string.Concat("Color: ", captured.Color.ToString()));
text.AppendLine(string.Concat("Origin ChessPosition: ", origin.ToChessPosition().ToString(), " Origin CanvasPosition(Column, Row): ", origin.Column, ", ", origin.Row));
text.AppendLine(string.Concat("Turn: ", TotalMoves));
text.AppendLine(string.Concat("Date: ", DateTime.Now.ToShortDateString(), " Time: ", DateTime.Now.ToShortTimeString()));
WriteLog.ChecksLogs(text);
}
public void Handle(PieceTaken message)
{
CapturedPieces.Add(PieceImageFactory.GetImage(message.Piece));
}
/// <summary>
/// Returns whether or not the game is finished after this move.
/// </summary>
public TurnResult PlayTurn(Turn turn, bool doChecks = true)
{
MiniMax.PlayTurnCount++;
AlphaBetaSearch.PlayTurnCount++;
Piece piece = Board[turn.OriginalPosition.X, turn.OriginalPosition.Y];
if (doChecks) // set doChecks to false for performance if necessary
{
if (piece == null)
{
throw new ArgumentException("Invalid Turn, bad OriginalPosition");
}
if (piece.PlayerIndex != InTurnPlayerIndex)
{
throw new ArgumentException("Invalid Turn, wrong piece");
}
if (piece.IsCaptured)
{
throw new ArgumentException("Invalid Turn, piece was already captured");
}
if (!InTurnPlayerCards.Contains(turn.Card))
{
throw new ArgumentException("Invalid Turn, wrong card");
}
if (!turn.Card.GetMoves(InTurnPlayerIndex).Contains(turn.Move))
{
throw new ArgumentException("Invalid Turn, bad move for card");
}
if (!IsValidMove(piece, turn.Move))
{
throw new ArgumentException("Invalid Turn, bad move");
}
}
// move pieces
Vector newPosition = turn.OriginalPosition.Add(turn.Move);
Piece captured = Board[newPosition.X, newPosition.Y];
Board[turn.OriginalPosition.X, turn.OriginalPosition.Y] = null;
piece.Position = newPosition;
Board[newPosition.X, newPosition.Y] = piece;
if (captured != null)
{
captured.IsCaptured = true;
CapturedPieces.Push(captured);
}
// swap played card with middle card
Card tmp = GameCards[MiddleCardIndex];
GameCards[MiddleCardIndex] = GameCards[PlayerCardIndices[InTurnPlayerIndex][turn.CardIndex]];
GameCards[PlayerCardIndices[InTurnPlayerIndex][turn.CardIndex]] = tmp;
bool gameIsFinshed = false;
if (captured != null && captured is King)
{
gameIsFinshed = true;
}
else if (piece is King && newPosition.Equals(Domain.Board.PlayerBases[1 - InTurnPlayerIndex]))
{
gameIsFinshed = true;
}
if (gameIsFinshed)
{
WinningPlayerIndex = InTurnPlayerIndex;
}
InTurnPlayerIndex = 1 - InTurnPlayerIndex; // let's toggle this for consistency, even when the game has just been finished.
return(new TurnResult(captured, gameIsFinshed));
}
