public void IdentifyDiagonalStraightFromRightTop() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(2, 2)); moveList.AddMove(new Move(2, 3)); moveList.AddMove(new Move(1, 3)); moveList.AddMove(new Move(3, 1)); bool diagonal3InARow = winChecker.CheckForDiagonalWin(moveList.Moves); Assert.True(diagonal3InARow); }
public void IdentifyADiagonalWinFromLeftTop() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(2, 2)); moveList.AddMove(new Move(2, 3)); moveList.AddMove(new Move(1, 1)); moveList.AddMove(new Move(3, 3)); var didUserWin = winChecker.CheckForWin(moveList); Assert.True(didUserWin); }
public void IdentifyNotADiagonalWin() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(2, 1)); moveList.AddMove(new Move(2, 3)); moveList.AddMove(new Move(1, 1)); moveList.AddMove(new Move(3, 3)); var diagonal3InARow = winChecker.CheckForDiagonalWin(moveList.Moves); Assert.False(diagonal3InARow); }
public void IndentifyAUserDidntWin() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(2, 2)); moveList.AddMove(new Move(2, 3)); moveList.AddMove(new Move(1, 3)); moveList.AddMove(new Move(3, 2)); var didUserWin = winChecker.CheckForWin(moveList); Assert.False(didUserWin); }
public void IndenifyThisRandomWin() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(2, 4)); moveList.AddMove(new Move(4, 2)); moveList.AddMove(new Move(1, 3)); moveList.AddMove(new Move(3, 3)); bool diagonal3InARow = winChecker.CheckForDiagonalWin(moveList.Moves); Assert.True(diagonal3InARow); }
public void IndentifyAHorizontalWin() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(2, 2)); moveList.AddMove(new Move(2, 3)); moveList.AddMove(new Move(1, 3)); moveList.AddMove(new Move(3, 3)); var didUserWin = winChecker.CheckForWin(moveList); Assert.True(didUserWin); }
public void CheckIfListContains3StraightInARow() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(1, 2)); moveList.AddMove(new Move(2, 2)); moveList.AddMove(new Move(1, 1)); moveList.AddMove(new Move(1, 3)); var listOfX = winChecker.AddXCoordinatesIntoSortedList(moveList.Moves); var result = winChecker.ContainsStraightLine(listOfX); Assert.True(result); }
public void RetainMoves() { var moveList = new MoveList(); moveList.AddMove(new Move(1, 1)); moveList.AddMove(new Move(2, 2)); moveList.AddMove(new Move(2, 3)); var expectedMovesList = new List <Move> { new Move(1, 1), new Move(2, 2), new Move(2, 3) }; ContainsSameItems(expectedMovesList, moveList); }
public override MoveEventResponse MoveBeingGenerated(MoveList moves, int from, int to, MoveType type) { int nSquaresOnFirstBoard = Board.NumSquares / 2; if (type == MoveType.StandardMove) { if (to >= nSquaresOnFirstBoard) { if (Board[to - nSquaresOnFirstBoard] == null) { moves.AddMove(from, to - nSquaresOnFirstBoard, true); } } else { if (Board[to + nSquaresOnFirstBoard] == null) { moves.AddMove(from, to + nSquaresOnFirstBoard, true); } } return(MoveEventResponse.Handled); } else if (type == MoveType.StandardCapture) { if (to >= nSquaresOnFirstBoard) { moves.BeginMoveAdd(MoveType.StandardCapture, from, to - nSquaresOnFirstBoard); Piece pieceBeingMoved = moves.AddPickup(from); Piece pieceBeingCaptured = moves.AddPickup(to); moves.AddDrop(pieceBeingMoved, to - nSquaresOnFirstBoard); moves.EndMoveAdd(3000 + pieceBeingCaptured.PieceType.MidgameValue - (pieceBeingMoved.PieceType.MidgameValue / 16)); } else { moves.BeginMoveAdd(MoveType.StandardCapture, from, to + nSquaresOnFirstBoard); Piece pieceBeingMoved = moves.AddPickup(from); Piece pieceBeingCaptured = moves.AddPickup(to); moves.AddDrop(pieceBeingMoved, to + nSquaresOnFirstBoard); moves.EndMoveAdd(3000 + pieceBeingCaptured.PieceType.MidgameValue - (pieceBeingMoved.PieceType.MidgameValue / 16)); } return(MoveEventResponse.Handled); } return(MoveEventResponse.NotHandled); }
public void AddAMoveToMoveList() { var move = new Move(2, 2); var moveList = new MoveList(); moveList.AddMove(move); }
public void PutXCoordinatesIntoASortedIntegerList() { var moveList = new MoveList(); var winChecker = new WinChecker(); moveList.AddMove(new Move(1, 2)); moveList.AddMove(new Move(2, 2)); moveList.AddMove(new Move(1, 1)); moveList.AddMove(new Move(1, 3)); var result = winChecker.AddXCoordinatesIntoSortedList(moveList.Moves); var expectedList = new List <int> { 1, 1, 1, 2 }; Assert.Equal(expectedList, result); }
private void AddSingleStepMove(int directionY, ref MoveList moveList) { var oneStep = _position.PhysicalY + directionY; if (oneStep.IsOnBoard() && _board.PositionIsFree(_position.PhysicalX, oneStep)) { moveList.AddMove(_piece, _position, _position.PhysicalX, oneStep); } }
public override MoveEventResponse MoveBeingGenerated(MoveList moves, int from, int to, MoveType type) { Piece movingPiece = Board[from]; if (movingPiece.TypeNumber == promotingTypeNumber) { Location loc = Board.SquareToLocation(Board.PlayerSquare(movingPiece.Player, to)); PromotionOption option = condition(loc); if (option != PromotionOption.CannotPromote) { // enemy piece being captured (if any) Piece capturedEnemyPiece = Board[to]; // if promotion is optional, add move without promotion if (option == PromotionOption.CanPromote) { if (capturedEnemyPiece == null) { moves.AddMove(from, to, true); } else { moves.AddCapture(from, to, true); } } List <int> pieceTypesFound = new List <int>(); List <Piece> capturedPieces = Game.GetCapturedPieceList(movingPiece.Player); foreach (Piece capturedFriendlyPiece in capturedPieces) { if (capturedFriendlyPiece.TypeNumber != movingPiece.TypeNumber && !pieceTypesFound.Contains(capturedFriendlyPiece.TypeNumber)) { if (capturedEnemyPiece == null) { moves.BeginMoveAdd(MoveType.MoveReplace, from, to, capturedFriendlyPiece.TypeNumber); moves.AddPickup(from); moves.AddDrop(capturedFriendlyPiece, to); moves.EndMoveAdd(5000 + capturedFriendlyPiece.PieceType.MidgameValue); } else { moves.BeginMoveAdd(MoveType.CaptureReplace, from, to, capturedFriendlyPiece.TypeNumber); moves.AddPickup(from); moves.AddPickup(to); moves.AddDrop(capturedFriendlyPiece, to); moves.EndMoveAdd(5000 + capturedFriendlyPiece.PieceType.MidgameValue + capturedEnemyPiece.PieceType.MidgameValue); } pieceTypesFound.Add(capturedFriendlyPiece.TypeNumber); } } return(MoveEventResponse.Handled); } } return(MoveEventResponse.NotHandled); }
private void AddCapture(int directionX, int directionY, ref MoveList moveList) { var oneStep = _position.PhysicalY + directionY; var side = _position.PhysicalX + directionX; if (side.IsOnBoard() && !_board.PositionIsFree(side, oneStep)) { moveList.AddMove(_piece, _position, side, oneStep); } }
public static bool CustomMoveGenerationHandler(PieceType pieceType, Piece piece, MoveList moveList, bool capturesOnly) { MoveCapability[] moves; int nMoves = pieceType.GetMoveCapabilities(out moves); for (int nMove = 0; nMove < nMoves; nMove++) { MoveCapability move = moves[nMove]; int step = 1; int nextSquare = piece.Board.NextSquare(piece.Player, move.NDirection, piece.Square); while (nextSquare >= 0 && step <= move.MaxSteps) { Piece pieceOnSquare = piece.Board[nextSquare]; if (pieceOnSquare != null) { if (step >= move.MinSteps && move.CanCapture && pieceOnSquare.Player != piece.Player) { moveList.AddCapture(piece.Square, nextSquare); } else if (step >= move.MinSteps && pieceOnSquare.Player == piece.Player && piece.PieceType != pieceOnSquare.PieceType) { // self-capture move allowing relocation of friendly piece int currentSquare = piece.Square; while (currentSquare != nextSquare) { moveList.BeginMoveAdd(MoveType.MoveRelay, piece.Square, nextSquare, currentSquare); moveList.AddPickup(piece.Square); moveList.AddPickup(nextSquare); moveList.AddDrop(piece, nextSquare); moveList.AddDrop(pieceOnSquare, currentSquare); moveList.EndMoveAdd(piece.PieceType.GetMidgamePST(nextSquare) - piece.PieceType.GetMidgamePST(piece.Square) + pieceOnSquare.PieceType.GetMidgamePST(currentSquare) - pieceOnSquare.PieceType.GetMidgamePST(nextSquare)); currentSquare = piece.Board.NextSquare(piece.Player, move.NDirection, currentSquare); } } nextSquare = -1; } else { if (step >= move.MinSteps && !move.MustCapture && !capturesOnly) { moveList.AddMove(piece.Square, nextSquare); } nextSquare = piece.Board.NextSquare(piece.Player, move.NDirection, nextSquare); step++; } } } return(false); }
private void AddInitialDoubleStepMove(int homeY, int directionY, ref MoveList moveList) { if (_position.PhysicalY != homeY) { return; } var doubleStep = _position.PhysicalY + directionY + directionY; if (_board.PositionIsFree(_position.PhysicalX, doubleStep)) { moveList.AddMove(_piece, _position, _position.PhysicalX, doubleStep); } }
// *** HELPER FUNCTIONS *** // #region addMove protected void addMove(MoveList list, int fromSquare, int toSquare, bool capturesOnly) { if (toSquare >= 0 && toSquare < Board.NumSquares) { Piece pieceOnDestinationSquare = Board[toSquare]; if (pieceOnDestinationSquare == null) { if (!capturesOnly) { list.AddMove(fromSquare, toSquare); } } else if (pieceOnDestinationSquare.Player != Game.CurrentSide) { list.AddCapture(fromSquare, toSquare); } } }
public override MoveEventResponse MoveBeingGenerated(MoveList moves, int from, int to, MoveType type) { Piece movingPiece = Board[from]; foreach (PromotionCapability promotion in promotionCapabilities) { if (movingPiece.TypeNumber == promotion.PromotingTypeNumber) { Location toLocation = Board.SquareToLocation(Board.PlayerSquare(movingPiece.Player, to)); PromotionOption option = promotion.FromAndToConditionDelegate != null ? promotion.FromAndToConditionDelegate(Board.SquareToLocation(Board.PlayerSquare(movingPiece.Player, from)), toLocation) : promotion.ConditionDelegate(toLocation); if (option != PromotionOption.CannotPromote) { for (int x = 0; x < Game.MAX_PIECE_TYPES; x++) { typesUsed[x] = false; } // enemy piece being captured (if any) Piece capturedPiece = Board[to]; // if promotion is optional, add move without promotion if (option == PromotionOption.CanPromote) { if (capturedPiece == null) { moves.AddMove(from, to, true); } else { moves.AddCapture(from, to, true); } } // handle traditional promotion if (promotion.PromotionTypes != null) { if (capturedPiece == null) { foreach (PieceType promoteTo in promotion.PromotionTypes) { moves.BeginMoveAdd(MoveType.MoveWithPromotion, from, to); moves.AddPickup(from); moves.AddDrop(movingPiece, to, promoteTo); moves.EndMoveAdd(5000 + promoteTo.MidgameValue); typesUsed[promoteTo.TypeNumber] = true; } } else { foreach (PieceType promoteTo in promotion.PromotionTypes) { moves.BeginMoveAdd(MoveType.CaptureWithPromotion, from, to); moves.AddPickup(from); moves.AddPickup(to); moves.AddDrop(movingPiece, to, promoteTo); moves.EndMoveAdd(5000 + promoteTo.MidgameValue + capturedPiece.PieceType.MidgameValue); typesUsed[promoteTo.TypeNumber] = true; } } } // handle promotion by replacement if (promotion.ReplacementPromotionTypes != null) { List <Piece> capturedPieces = Game.GetCapturedPieceList(movingPiece.Player); foreach (Piece capturedFriendlyPiece in capturedPieces) { if (capturedFriendlyPiece.TypeNumber != movingPiece.TypeNumber && !typesUsed[capturedFriendlyPiece.TypeNumber] && promotion.ReplacementPromotionTypes.Contains(capturedFriendlyPiece.PieceType)) { if (capturedPiece == null) { moves.BeginMoveAdd(MoveType.MoveReplace, from, to, capturedFriendlyPiece.TypeNumber); moves.AddPickup(from); moves.AddDrop(capturedFriendlyPiece, to); moves.EndMoveAdd(5000 + capturedFriendlyPiece.PieceType.MidgameValue); } else { moves.BeginMoveAdd(MoveType.CaptureReplace, from, to, capturedFriendlyPiece.TypeNumber); moves.AddPickup(from); moves.AddPickup(to); moves.AddDrop(capturedFriendlyPiece, to); moves.EndMoveAdd(5000 + capturedFriendlyPiece.PieceType.MidgameValue + capturedPiece.PieceType.MidgameValue); } typesUsed[capturedFriendlyPiece.TypeNumber] = true; } } } return(MoveEventResponse.Handled); } } } return(MoveEventResponse.NotHandled); }
public static bool CustomMoveGenerationHandler(PieceType pieceType, Piece piece, MoveList moveList, bool capturesOnly) { MoveCapability[] moves; int nMoves = pieceType.GetMoveCapabilities(out moves); for (int nMove = 0; nMove < nMoves; nMove++) { MoveCapability move = moves[nMove]; int step = 1; int nextSquare = piece.Board.NextSquare(piece.Player, move.NDirection, piece.Square); while (nextSquare >= 0 && step <= move.MaxSteps) { Piece pieceOnSquare = piece.Board[nextSquare]; if (pieceOnSquare != null) { if (step >= move.MinSteps && move.CanCapture && pieceOnSquare.Player != piece.Player) { moveList.AddCapture(piece.Square, nextSquare); for (int x = 0; x < 8; x++) { int targetSquare = piece.Board.NextSquare(x, nextSquare); if (targetSquare >= 0 && piece.Board[targetSquare] != null && piece.Board[targetSquare].Player != piece.Player) { moveList.BeginMoveAdd(MoveType.ExtraCapture, piece.Square, nextSquare, targetSquare); moveList.AddPickup(piece.Square); moveList.AddPickup(nextSquare); moveList.AddPickup(targetSquare); moveList.AddDrop(piece, nextSquare); moveList.EndMoveAdd(4000 + piece.Board[nextSquare].PieceType.MidgameValue + piece.Board[targetSquare].PieceType.MidgameValue); } } } nextSquare = -1; } else { if (step >= move.MinSteps && !move.MustCapture) { if (!capturesOnly) { moveList.AddMove(piece.Square, nextSquare); } for (int x = 0; x < 8; x++) { int targetSquare = piece.Board.NextSquare(x, nextSquare); if (targetSquare >= 0 && piece.Board[targetSquare] != null && piece.Board[targetSquare].Player != piece.Player) { moveList.BeginMoveAdd(MoveType.ExtraCapture, piece.Square, nextSquare, targetSquare); moveList.AddPickup(piece.Square); moveList.AddPickup(targetSquare); moveList.AddDrop(piece, nextSquare); moveList.EndMoveAdd(3000 + piece.Board[targetSquare].PieceType.MidgameValue); } } } nextSquare = piece.Board.NextSquare(piece.Player, move.NDirection, nextSquare); step++; } } } return(false); }
public static bool CustomMoveGenerationHandler(PieceType pieceType, Piece piece, MoveList moveList, bool capturesOnly) { OdinsRuneChess game = (OdinsRuneChess)piece.Game; // determine what pieces are adjacent bool foundValkyrie = false; bool foundForestOx = false; bool foundRook = false; bool foundBishop = false; bool foundPawn = false; for (int x = 0; x < 8; x++) { int square = piece.Board.NextSquare(x, piece.Square); if (square >= 0 && piece.Board[square] != null && piece.Board[square].Player == piece.Player) { PieceType adjacentPieceType = piece.Board[square].PieceType; if (adjacentPieceType == game.Valkyrie) { foundValkyrie = true; } else if (adjacentPieceType == game.ForestOx) { foundForestOx = true; } else if (adjacentPieceType == game.Rook) { foundRook = true; } else if (adjacentPieceType == game.Bishop) { foundBishop = true; } else if (adjacentPieceType == game.Pawn) { foundPawn = true; } } } // generate moves of appropriate types if (foundValkyrie) { piece.GenerateMoves(game.Valkyrie, moveList, capturesOnly); } else { // don't generate rook or bishop if we have found valkyrie // because all their moves would be redundant if (foundRook) { piece.GenerateMoves(game.Rook, moveList, capturesOnly); } if (foundBishop) { piece.GenerateMoves(game.Bishop, moveList, capturesOnly); } } if (foundForestOx) { piece.GenerateMoves(game.ForestOx, moveList, capturesOnly); } if (foundPawn) { if (!foundBishop && !foundValkyrie) { piece.GenerateMoves(game.Pawn, moveList, capturesOnly); } else { // This gets tricky; we can't just generate all pawn moves // because we'd generate duplicative moves. So we need to // manually generate just the one unique pawn move (the // multi-path move.) // First, check to make sure that this move wasn't // already generated by a straight Valkyrie move if (!foundValkyrie || (game.Board.NextSquare(PredefinedDirections.N + piece.Player, piece.Square) >= 0 && game.Board[game.Board.NextSquare(PredefinedDirections.N + piece.Player, piece.Square)] != null)) { // Is the square two ahead both on the board and a square // we can move to? int targetSquare = game.Board.NextSquare(PredefinedDirections.N + piece.Player, piece.Square); if (targetSquare >= 0) { targetSquare = game.Board.NextSquare(PredefinedDirections.N + piece.Player, targetSquare); } if (targetSquare >= 0 && ((game.Board[targetSquare] == null && !capturesOnly) || (game.Board[targetSquare] != null && game.Board[targetSquare].Player != piece.Player))) { // This is a square we can move to, but first we // must establish that there's a clear path if ((game.Board.NextSquare(PredefinedDirections.NE + piece.Player, piece.Square) >= 0 && game.Board[game.Board.NextSquare(PredefinedDirections.NE + piece.Player, piece.Square)] == null) || (game.Board.NextSquare(PredefinedDirections.NW + piece.Player, piece.Square) >= 0 && game.Board[game.Board.NextSquare(PredefinedDirections.NW + piece.Player, piece.Square)] == null)) { // Ok, we're clear to generate the move/capture if (game.Board[targetSquare] == null) { moveList.AddMove(piece.Square, targetSquare); } else { moveList.AddCapture(piece.Square, targetSquare); } } } } } } return(false); }