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