public void RookImpossibleMoves() { var board = BoardGenerator.GetInitialBoard(); board.Move(_whitePlayer, new PiecePosition('A', 2), new PiecePosition('A', 4)); var position1 = new PiecePosition('A', 1); var position2 = new PiecePosition('A', 4); var position3 = new PiecePosition('A', 3); var position4 = new PiecePosition('H', 4); Assert.IsFalse(board.Move(_whitePlayer, position1, position2)); Assert.IsTrue(board.Move(_whitePlayer, position1, position3)); Assert.IsFalse(board.Move(_whitePlayer, position3, position4)); }
private static ChessMoveInfo GetMoveWithOffset(ChessBoard board, Piece pieceToMove, int horizontalOffset, int verticalOffset) { var moves = new List <ChessMoveInfo>(); var potentialNewPosition = new PiecePosition( (PieceHorizontalPosition)((int)pieceToMove.Position.HorizontalPosition + horizontalOffset), (PieceVerticalPosition)((int)pieceToMove.Position.VerticalPosition + verticalOffset)); if (board.IsPositionValidToMoveTo(potentialNewPosition, pieceInPosition => pieceInPosition.IsNone() || pieceInPosition.Player != pieceToMove.Player)) { return(board.CreateSimpleMove(pieceToMove, potentialNewPosition)); } return(null); }
private static void AssertEmptyPosition(PiecePosition position) { foreach (var side in ChessConstants.GameSides) { Assert.That(position[side], Is.EqualTo(Bitboard.None)); } Assert.That(position[Piece.None], Is.EqualTo(Bitboard.Everything)); foreach (var piece in ChessConstants.PiecesExceptNone) { Assert.That(position[piece], Is.EqualTo(Bitboard.None)); } foreach (var square in ChessHelper.AllSquares) { Assert.That(position[square], Is.EqualTo(Piece.None)); } }
private static List <ChessMoveInfo> GetCastlingMoves(ChessBoard board, Piece kingPiece) { var moves = new List <ChessMoveInfo>(); var verticalPosition = kingPiece.Position.VerticalPosition; var shortCastlingRookPosition = new PiecePosition(PieceHorizontalPosition.P_H, verticalPosition); var shortCastlingRookPiece = board.GetPiece(shortCastlingRookPosition); var canDoShortCastling = CanDoCastling(board, kingPiece, shortCastlingRookPiece); if (canDoShortCastling) { var newRookPosition = new PiecePosition(PieceHorizontalPosition.P_F, verticalPosition); var newKingPosition = new PiecePosition(PieceHorizontalPosition.P_G, verticalPosition); var firstMoveStep = new ChessMoveStepInfo(shortCastlingRookPosition, newRookPosition, shortCastlingRookPiece); var secondMoveStep = new ChessMoveStepInfo(kingPiece.Position, newKingPosition, kingPiece); var steps = new List <ChessMoveStepInfo> { firstMoveStep, secondMoveStep }; var move = new ChessMoveInfo(kingPiece.Player, steps, false, isCastling: true); moves.Add(move); } var longCastlingRookPosition = new PiecePosition(PieceHorizontalPosition.P_A, verticalPosition); var longCastlingRookPiece = board.GetPiece(longCastlingRookPosition); var canDoLongCastling = CanDoCastling(board, kingPiece, longCastlingRookPiece); if (canDoLongCastling) { var newRookPosition = new PiecePosition(PieceHorizontalPosition.P_D, verticalPosition); var newKingPosition = new PiecePosition(PieceHorizontalPosition.P_C, verticalPosition); var firstMoveStep = new ChessMoveStepInfo(longCastlingRookPosition, newRookPosition, longCastlingRookPiece); var secondMoveStep = new ChessMoveStepInfo(kingPiece.Position, newKingPosition, kingPiece); var steps = new List <ChessMoveStepInfo> { firstMoveStep, secondMoveStep }; var move = new ChessMoveInfo(kingPiece.Player, steps, false, isCastling: true); moves.Add(move); } return(moves); }
public void PawnFirstMove2CellsTest() { var board = BoardGenerator.GetInitialBoard(); for (char col = 'A'; col <= 'H'; col++) { var fromPosition = new PiecePosition(col, 2); var toPosition = new PiecePosition(col, 4); Assert.IsTrue(board.Move(_whitePlayer, fromPosition, toPosition)); Assert.IsFalse(board.Move(_blackPlayer, fromPosition, toPosition)); } for (char col = 'A'; col <= 'H'; col++) { var fromPosition = new PiecePosition(col, 7); var toPosition = new PiecePosition(col, 5); Assert.IsFalse(board.Move(_whitePlayer, fromPosition, toPosition)); Assert.IsTrue(board.Move(_blackPlayer, fromPosition, toPosition)); } }
public bool Move(PiecePosition from, PiecePosition to, bool sw = true) { var selectedPiece = Board[from].OccupyingPiece; if (!IsPlayersGo(selectedPiece.PieceOwner)) { Console.WriteLine("It is not your go.\nPress enter to continue..."); Console.Read(); return(false); } var move = selectedPiece.Move(to); if (move != null) { Move(move, sw); } return(move != null); }
public void OnBoardClick(PiecePosition position) { if (GameState == null || CurrentPiece == null) { return; } var player = CurrentPlayer as HumanPlayer; if (player == null) { return; } var move = new Move(CurrentPiece, position, _CurrentVariantNumber % CurrentPiece.Variants.Length); if (player.InvalidateMove(GameState, move)) { player.MoveSemaphore.Release(1); CurrentPiece = null; } }
public static bool IsPinned(Piece target, PiecePosition currentTilePos) { var _board = target._board; var currentTile = _board[currentTilePos]; var tiles = new List <BoardTile>(); if (_board[currentTilePos].OccupyingPiece != null) { // ignore piece if its the piece we're checking for pins if (_board[currentTilePos].OccupyingPiece != target) { if (_board[currentTilePos].OccupyingPiece.PieceName == "King" && _board[currentTilePos].OccupyingPiece.PieceOwner.Id == target.PieceOwner.Id) { return(true); } return(false); } } return(false); }
public void TestSetPiece() { foreach (var testSquare in ChessHelper.AllSquares) { foreach (var testPiece in ChessConstants.PiecesExceptNone) { var position = new PiecePosition(); var oldPiece1 = position.SetPiece(testSquare, testPiece); Assert.That(oldPiece1, Is.EqualTo(Piece.None)); foreach (var side in ChessConstants.GameSides) { var expectedSideBitboard = testPiece.GetSide() == side ? testSquare.Bitboard : Bitboard.None; Assert.That(position[side], Is.EqualTo(expectedSideBitboard)); } Assert.That(position[Piece.None], Is.EqualTo(~testSquare.Bitboard)); foreach (var piece in ChessConstants.PiecesExceptNone) { var expectedBitboard = piece == testPiece ? testSquare.Bitboard : Bitboard.None; Assert.That(position[piece], Is.EqualTo(expectedBitboard)); } foreach (var square in ChessHelper.AllSquares) { var expectedPiece = square == testSquare ? testPiece : Piece.None; Assert.That(position[square], Is.EqualTo(expectedPiece)); } var oldPiece2 = position.SetPiece(testSquare, Piece.None); Assert.That(oldPiece2, Is.EqualTo(testPiece)); AssertEmptyPosition(position); } } }
private void ManipulatePiece(Transform piece) { PiecePosition pieceScript = piece.GetComponent <PiecePosition>(); if (selection == SelectPiece.Returning) { if (!pieceScript.GetAlocatedSpaceTag().Equals("benchSpace")) { bench.AlocatePiece(piece); } } else if (selection == SelectPiece.Moving) { selectedPiece = piece; pieceSelected = true; } else if (selection == SelectPiece.Selling) { int amount = pieceScript.GetPieceDetail().sellingPrice; controller.BuySellPiece(amount); pieceScript.RemovePiece(); } selection = SelectPiece.Idling; }
public void PawnFirstMoves1CellTest() { var board = BoardGenerator.GetInitialBoard(); for (char col = 'A'; col <= 'H'; col++) { var position1 = new PiecePosition(col, 2); var position2 = new PiecePosition(col, 3); var position3 = new PiecePosition(col, 4); Assert.IsTrue(board.Move(_whitePlayer, position1, position2)); Assert.IsFalse(board.Move(_blackPlayer, position1, position2)); Assert.IsTrue(board.Move(_whitePlayer, position2, position3)); } for (char col = 'A'; col <= 'H'; col++) { var position1 = new PiecePosition(col, 7); var position2 = new PiecePosition(col, 6); var position3 = new PiecePosition(col, 4); Assert.IsFalse(board.Move(_whitePlayer, position1, position2)); Assert.IsTrue(board.Move(_blackPlayer, position1, position2)); Assert.IsFalse(board.Move(_blackPlayer, position2, position3)); } }
public BoardTile(PiecePosition pos) { ThreateningPieces = new List <Piece>(); Position = pos; }
internal GameBoardData() { PiecePosition = new PiecePosition(); _undoMoveDatas = new Stack <MakeMoveData>(); }
public void TestConstruction() { var position = new PiecePosition(); AssertEmptyPosition(position); }
public BoardTile this [PiecePosition p] { get { return(_board[p.row, p.col]); } set { _board[p.row, p.col] = value; } }
public static List <ChessMoveInfo> CalculateValidMovesForPawn(this ChessBoard board, Piece pieceToMove, int forwardMotion) { var pawnMoves = new List <ChessMoveInfo>(); var positionAStepForward = new PiecePosition(pieceToMove.Position.HorizontalPosition, pieceToMove.Position.VerticalPosition + forwardMotion); if (board.IsPositionValidToMoveTo(positionAStepForward, pieceInPosition => pieceInPosition.IsNone())) { var moveAStepForward = board.CreateSimpleMove(pieceToMove, positionAStepForward); var movesAStepForward = AddReplacementMoveStepsIfNecessary(moveAStepForward); pawnMoves.AddRange(movesAStepForward); // If it is the first move of the pawn, it can also move two steps forward if (pieceToMove.NumberOfPlayedMoves == 0) { var positionTwoStepsForward = new PiecePosition(positionAStepForward.HorizontalPosition, positionAStepForward.VerticalPosition + forwardMotion); if (board.IsPositionValidToMoveTo(positionTwoStepsForward, pieceInPosition => pieceInPosition.IsNone())) { var moveTwoStepsForward = board.CreateSimpleMove(pieceToMove, positionTwoStepsForward); pawnMoves.Add(moveTwoStepsForward); } } } var nextPositionInLeftDiagonal = new PiecePosition(pieceToMove.Position.HorizontalPosition - 1, pieceToMove.Position.VerticalPosition + forwardMotion); if (board.IsPositionValidToMoveTo(nextPositionInLeftDiagonal, pieceInPosition => !pieceInPosition.IsNone() && pieceInPosition.Player != pieceToMove.Player)) { var moveToNextPositionInLeftDiagonal = board.CreateSimpleMove(pieceToMove, nextPositionInLeftDiagonal); var movesToNextPositionInLeftDiagonal = AddReplacementMoveStepsIfNecessary(moveToNextPositionInLeftDiagonal); pawnMoves.AddRange(movesToNextPositionInLeftDiagonal); } var nextPositionInRightDiagonal = new PiecePosition(pieceToMove.Position.HorizontalPosition + 1, pieceToMove.Position.VerticalPosition + forwardMotion); if (board.IsPositionValidToMoveTo(nextPositionInRightDiagonal, pieceInPosition => !pieceInPosition.IsNone() && pieceInPosition.Player != pieceToMove.Player)) { var moveToNextPositionInRightDiagonal = board.CreateSimpleMove(pieceToMove, nextPositionInRightDiagonal); var movesToNextPositionInRightDiagonal = AddReplacementMoveStepsIfNecessary(moveToNextPositionInRightDiagonal); pawnMoves.AddRange(movesToNextPositionInRightDiagonal); } var isInEnPassantPosition = (pieceToMove.Player == Player.First && pieceToMove.Position.VerticalPosition == PieceVerticalPosition.P_5) || (pieceToMove.Player == Player.Second && pieceToMove.Position.VerticalPosition == PieceVerticalPosition.P_4); if (isInEnPassantPosition) { var moveHistory = board.GetMoveHistory(); var lastMoveStep = moveHistory.LastOrDefault()?.MoveSteps?.First(); if (lastMoveStep != null) { var positionToTheLeft = new PiecePosition(pieceToMove.Position.HorizontalPosition - 1, pieceToMove.Position.VerticalPosition); if (positionToTheLeft.IsValid()) { var pieceToTheLeft = board.GetPiece(positionToTheLeft); if (CanMakeEnPassantMove(pieceToMove, lastMoveStep, pieceToTheLeft)) { var enPassantToTheLeft = board.CreateSimpleMove(pieceToMove, nextPositionInLeftDiagonal, pieceToTheLeft); pawnMoves.Add(enPassantToTheLeft); } } var positionToTheRight = new PiecePosition(pieceToMove.Position.HorizontalPosition + 1, pieceToMove.Position.VerticalPosition); if (positionToTheRight.IsValid()) { var pieceToTheRight = board.GetPiece(positionToTheRight); if (CanMakeEnPassantMove(pieceToMove, lastMoveStep, pieceToTheRight)) { var enPassantToTheRight = board.CreateSimpleMove(pieceToMove, nextPositionInRightDiagonal, pieceToTheRight); pawnMoves.Add(enPassantToTheRight); } } } } return(pawnMoves); }
void OnMouseUpPlacement() { // If not dragging, return if (pieceOrigin == null) { return; } // Get mouse position on the screen var targetPosition = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0)); targetPosition.z = -1; // Inside placement board if (IsInsidePlacementBoard(targetPosition)) { // Target coordinate Coordinate newCoordinate = CoordinateOfVector3Placement(targetPosition); // If target square is not null and it is not the same square, move the piece if (GameCoordinator.Instance.IsPieceNull(newCoordinate, true) && (!newCoordinate.Equals(pieceOrigin.Coordinate) || !pieceOrigin.PlacementBoard)) { // Raise event to notify other player and update their board. If move is from placement board to placement board, don't notify. if (!pieceOrigin.PlacementBoard) { Debug.Log("Event is being raised. To placement board."); // Zero event code is for placing a piece. PhotonNetwork.RaiseEvent(PlayerNetworking.movePiecePlacementEventCode, new MoveInfoPlacement(false, true, pieceOrigin.Coordinate, newCoordinate, 1), new RaiseEventOptions { Receivers = ReceiverGroup.Others }, new SendOptions { Reliability = true }); } // Snap SnapPlacementBoard(targetPosition); // Visual and logical GameCoordinator.Instance.MoveSelfPiecePlacement(pieceOrigin.Coordinate, pieceOrigin.PlacementBoard, newCoordinate, true); // Null the origin pieceOrigin = null; } else { ResetMovingPiece(); return; } } // Inside game board else if (IsInsideGameBoard(targetPosition)) { // Target coordinate Coordinate newCoordinate = CoordinateOfVector3Game(targetPosition); // If target square is not null and it is not the same square, move the piece if (GameCoordinator.Instance.IsPieceNull(newCoordinate, false) && (!newCoordinate.Equals(pieceOrigin.Coordinate) || pieceOrigin.PlacementBoard) && newCoordinate.Row <= 2) { // Raise event to notify other player and update their board. // Zero event code is for placing a piece. Debug.Log("Event is being raised. To game board."); PhotonNetwork.RaiseEvent(PlayerNetworking.movePiecePlacementEventCode, new MoveInfoPlacement(pieceOrigin.PlacementBoard, false, pieceOrigin.Coordinate, newCoordinate, 1), new RaiseEventOptions { Receivers = ReceiverGroup.Others }, new SendOptions { Reliability = true }); // Snap SnapGameBoard(targetPosition); // Visual and logical GameCoordinator.Instance.MoveSelfPiecePlacement(pieceOrigin.Coordinate, pieceOrigin.PlacementBoard, newCoordinate, false); // Null the origin pieceOrigin = null; } else { ResetMovingPiece(); return; } } // Outside both boards else { ResetMovingPiece(); return; } Debug.Log("logic"); Debug.Log(GameCoordinator.Instance.GetLogicCoordinator()); Debug.Log("visual"); Debug.Log(GameCoordinator.Instance); }
public BoardClickEventArgs(PiecePosition position) { PiecePosition = new PiecePosition(position); }
public abstract void PossiblePositions(PiecePosition CurrentPosition); //Calculates possible positions
static void Main(string[] args) { var player1 = new Player(Guid.NewGuid().ToString(), "top"); var player2 = new Player(Guid.NewGuid().ToString(), "bottom"); var game = new Game(new List <Player>() { player1, player2 }); game.SetupDefault(); while (true) { try { game.Board.PrintBoard(); Console.WriteLine(game.NextMovePlayer.Side); // game.AIMove(); // Thread.Sleep(100); Console.WriteLine("\"undo\" to undo, \"ai\" to make computer take turn, \"quit\" to quit, or"); Console.Write("Select piece to move(format: <row>,<col>): "); var move = Console.ReadLine(); if (move == "undo") { game.Undo(); continue; } if (move == "ai") { game.AIMove(); continue; } if (move == "quit") { return; } var deets = move.Split(","); // MINUS ONE TO NORMALIZE INPUT. E.G 1,1 WILL BECOME 0,0 WHICH IS THE ACTUAL ARRAY INDEX PiecePosition selectedPosition = new PiecePosition(int.Parse(deets[0]) - 1, int.Parse(deets[1]) - 1); Piece selectedPiece = game.Board[selectedPosition].OccupyingPiece; game.Board.PrintBoard(selectedPiece); Console.Write("Select position to piece to (format: <row>,<col>): "); move = Console.ReadLine(); deets = move.Split(","); // MINUS ONE TO NORMALIZE INPUT. E.G 1,1 WILL BECOME 0,0 WHICH IS THE ACTUAL ARRAY INDEX PiecePosition movePosition = new PiecePosition(int.Parse(deets[0]) - 1, int.Parse(deets[1]) - 1); game.Move(selectedPosition, movePosition); } catch (Exception ex) { Console.WriteLine(ex); } } }
void ResetMovingPiece() { transform.position = pieceOrigin.Position; pieceOrigin = null; }