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