public object Put()
{
var chessBoard = new ChessBoard();
(new TraditionalBoardStager()).Stage(chessBoard);
var chessGame = new ChessGame(
chessBoard,
PlayerTypeEnum.White,
new Dictionary<PlayerTypeEnum, List<ChessPiece>>());
var id = Guid.NewGuid();
m_chessGameRepo.Put(id, chessGame);
return new
{
_id = id,
_turn = ((char)chessGame.PlayerTurn),
_taken = new
{
w = chessGame.GetTakenPiecesByPlayer(PlayerTypeEnum.White).Select(x => (char)x.Type),
b = chessGame.GetTakenPiecesByPlayer(PlayerTypeEnum.Black).Select(x => (char)x.Type),
},
_state = chessBoard.GetBoardAsListOfString(),
_history = chessGame.GetMoves(),
_moves = new PotentialMoveService().GetPotentialMoves(chessGame, chessGame.PlayerTurn),
};
}
public void King_Two_Move_No_Rook()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
var move = g.PlayerMove(PlayerTypeEnum.White, "e1g1");
Assert.IsFalse(move.Success);
}
public void PawnSwap()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("f7", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn });
b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.White, "f7f8");
ChessPiece queen = b.Get("f8");
Assert.IsTrue(moveResult.Success);
Assert.IsTrue(queen.Type == PieceTypeEnum.Queen);
}
private bool CanMoveIntoAttackersPath(PlayerTypeEnum player, string lastMoveNotation, ChessBoard board, List<string> attackers, Tuple<int, int> opponentKingTuple)
{
if (attackers.Count > 1)
return false;
bool canBlockPathOfAttackers = false;
string attackerNotation = attackers.First();
Tuple<int, int> attackerTuple = NotationHelper.Translate(attackerNotation);
ChessPiece attackerPiece = board.Get(attackerTuple);
if (attackerPiece.Type == PieceTypeEnum.Knight)
return false;
// get star pattern of each attacker
List<Tuple<int, int>[]> relativePaths = new QueenRelativePathProvider().GetRelativePaths(
new ChessPiece() { Player = player });
var absolutePaths = BoardLogic.ConvertToAbsolutePaths(attackerTuple, relativePaths);
// get path that leads to king
var pathOfAttacker = BoardLogic.GetPathContaining(opponentKingTuple, absolutePaths);
var trimmedPathOfAttacker = BoardLogic.TrimToBeforeDestination(opponentKingTuple, pathOfAttacker);
// can any opponents move into path and block?
var opponentPlayerSquares = board.GetPiecesForPlayer(GetOppositePlayer(player));
foreach (var opponentSquare in opponentPlayerSquares)
{
bool canMoveIntoAttackersPath =
trimmedPathOfAttacker.Any(location =>
{
string dest = NotationHelper.Translate(location);
return CanMove(board, opponentSquare + dest, GetOppositePlayer(player), lastMoveNotation).Success;
});
if (canMoveIntoAttackersPath)
{
canBlockPathOfAttackers = true;
break;
}
}
return canBlockPathOfAttackers;
}
public void PotentialMoves()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("f7", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn });
b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
PotentialMoveService s = new PotentialMoveService();
s.GetPotentialMoves(g, PlayerTypeEnum.White);
var whiteMoves = s.GetPotentialMoves(g, PlayerTypeEnum.White);
var blackMoves = s.GetPotentialMoves(g, PlayerTypeEnum.Black);
Assert.AreEqual(5, whiteMoves["e1"].Count);
Assert.AreEqual(2, whiteMoves["f7"].Count);
Assert.AreEqual(5, blackMoves["e8"].Count);
}
public ChessGame(
ChessBoard b,
PlayerTypeEnum player,
Dictionary<PlayerTypeEnum,
List<ChessPiece>> takenPieces,
IRulesOfChess rules)
{
_chessBoard = b;
_currentPlayer = player;
_moves = new List<string>();
_takenPieces = takenPieces ?? new Dictionary<PlayerTypeEnum, List<ChessPiece>>();
List<ChessPiece> takenOut;
if (!_takenPieces.TryGetValue(PlayerTypeEnum.White, out takenOut) || takenOut == null)
_takenPieces[PlayerTypeEnum.White] = new List<ChessPiece>();
if (!_takenPieces.TryGetValue(PlayerTypeEnum.Black, out takenOut) || takenOut == null)
_takenPieces[PlayerTypeEnum.Black] = new List<ChessPiece>();
_rules = rules;
}
private ValidateMoveResult CanMove(ChessBoard board, string source, string dest, PlayerTypeEnum player, string lastMoveNotation, bool playerInCheck)
{
var result = new ValidateMoveResult();
var sourceTuple = NotationHelper.Translate(source);
if (!BoardLogic.IsOnBoard(sourceTuple))
return result.SetMessage(source + " is not on board");
var destTuple = NotationHelper.Translate(dest);
if (!BoardLogic.IsOnBoard(destTuple))
return result.SetMessage(dest + " is not on board");
if (source.Equals(dest, StringComparison.OrdinalIgnoreCase))
return result.SetMessage("source and dest are the same");
var sourcePiece = board.Get(sourceTuple);
if (sourcePiece == null)
return result.SetMessage("source piece is null");
if (sourcePiece.Player != player)
return result.SetMessage("piece does not belong to player.");
var destPiece = board.Get(destTuple);
if (destPiece != null && sourcePiece.Player == destPiece.Player)
return result.SetMessage("cannot move on top of own piece");
var relativeMoves = m_relativeMoveProviderFactory
.GetProviderByPieceType(sourcePiece.Type)
.GetRelativePaths(sourcePiece);
var absoluteMoves = BoardLogic.ConvertToAbsolutePaths(sourceTuple, relativeMoves);
bool destInPath = BoardLogic.IsInAtleastOnePath(destTuple, absoluteMoves);
if (!destInPath)
return result.SetMessage("destination not in available path");
string takenPiece = null;
string additionalMove = null;
switch (sourcePiece.Type)
{
case PieceTypeEnum.Pawn:
{
bool isRankOnlyMove = BoardLogic.IsRankOnlyMove(sourceTuple, destTuple);
if (isRankOnlyMove)
{
var pathContaingDestination = BoardLogic.GetPathContaining(destTuple, absoluteMoves);
if (!BoardLogic.IsPathClear(board, pathContaingDestination))
return result.SetMessage("path blocked");
var absDelta = BoardLogic.GetAbsoluteDelta(sourceTuple, destTuple);
if (absDelta.Item1 == 2 && sourcePiece.HasMoved)
return result.SetMessage("pawn has already moved, cannot jump 2 squares");
}
else
{
// en-passant
// > is piece in source *rank, destination *file an enemy pawn?
// > if yes, was its last move two squares?e
var pieceBehindTuple = new Tuple<int, int>(
sourceTuple.Item1,
destTuple.Item2);
var pieceBehind = board.Get(pieceBehindTuple);
bool targetWasLastMove = false;
bool twoSquareLastMove = false;
Tuple<string, string> lastMove = null;
if (lastMoveNotation != null)
{
lastMove = NotationHelper.Breakdown(lastMoveNotation);
var lastMoveSourceTuple = NotationHelper.Translate(lastMove.Item1);
var lastMoveDestTuple = NotationHelper.Translate(lastMove.Item2);
var lastMoveAbsDelta = BoardLogic.GetAbsoluteDelta(lastMoveSourceTuple, lastMoveDestTuple);
twoSquareLastMove = lastMoveAbsDelta.Item1 == 2;
targetWasLastMove =
pieceBehindTuple.Item1 == lastMoveDestTuple.Item1 &&
pieceBehindTuple.Item2 == lastMoveDestTuple.Item2;
}
bool enPassant =
pieceBehind != null &&
pieceBehind.Player != player &&
pieceBehind.Type == PieceTypeEnum.Pawn &&
twoSquareLastMove &&
targetWasLastMove
;
if (enPassant)
{
takenPiece = lastMove.Item2;
break;
}
if (destPiece == null)
return result.SetMessage("enemy piece not present at destination");
}
break;
}
case PieceTypeEnum.King:
{
// castle
if (BoardLogic.IsFileOnlyMove(sourceTuple, destTuple) &&
BoardLogic.GetAbsoluteDelta(sourceTuple, destTuple).Item2 == 2)
{
if (sourcePiece.HasMoved)
return result.SetMessage("king has already moved.");
ChessPiece rook = null;
Tuple<int, int> rookTuple = null;
Tuple<int, int> toRookDelta = null;
var rookNotations = board.GetPiecesOfType(player, PieceTypeEnum.Rook);
if (rookNotations != null && rookNotations.Count > 0)
{
var moveDelta = BoardLogic.GetDelta(sourceTuple, destTuple);
foreach (var rn in rookNotations)
{
rookTuple = NotationHelper.Translate(rn);
toRookDelta = BoardLogic.GetDelta(sourceTuple, rookTuple);
if (BoardLogic.IsFileOnlyMove(sourceTuple, rookTuple) &&
BoardLogic.AreDeltasInSameDirection(moveDelta.Item2, toRookDelta.Item2))
{
rook = board.Get(rn);
break;
}
}
}
if (rook == null)
return result.SetMessage("no rook present on rank " + sourceTuple.Item1);
if (rook.HasMoved)
return result.SetMessage("rook has moved.");
Tuple<int, int>[] kingToRookPath = BoardLogic.GetRankPath(sourceTuple, rookTuple);
Tuple<int, int>[] trimmedPath = BoardLogic.TrimToBeforeDestination(rookTuple,
kingToRookPath);
bool isPathClear = BoardLogic.IsPathClear(board, trimmedPath);
if (!isPathClear)
return result.SetMessage("path blocked");
if (playerInCheck)
return result.SetMessage("cannot castle out of check");
bool moveToLeft = toRookDelta.Item2 < 0;
additionalMove = NotationHelper.Translate(rookTuple) +
NotationHelper.Translate(new Tuple<int, int>(rookTuple.Item1,
destTuple.Item2 + (moveToLeft ? 1 : -1)));
}
break;
}
case PieceTypeEnum.Knight:
{
break;
}
case PieceTypeEnum.Bishop:
case PieceTypeEnum.Rook:
case PieceTypeEnum.Queen:
{
// cases handled in general
var pathContaingDestination = BoardLogic.GetPathContaining(destTuple, absoluteMoves);
var trimmedPath = BoardLogic.TrimToBeforeDestination(destTuple, pathContaingDestination);
if (!BoardLogic.IsPathClear(board, trimmedPath))
return result.SetMessage("path blocked");
break;
}
}
if (destPiece != null)
takenPiece = dest;
result.Success = true;
result.TakenPiece = takenPiece;
result.Moves = new[] { source + dest, additionalMove }.Where(x => x != null).ToArray();
return result;
}
private Tuple<bool, List<string>> IsInCheck(PlayerTypeEnum playerType, ChessBoard board, string lastMoveNotation)
{
PlayerTypeEnum opponentPlayerType = GetOppositePlayer(playerType);
List<string> opponentSquares = board.GetPiecesForPlayer(opponentPlayerType);
string kingNotation = board.GetKing(playerType);
if (kingNotation == null)
return new Tuple<bool, List<string>>(false, null);
bool isInCheck = false;
List<string> attackers = new List<string>();
foreach (var square in opponentSquares)
{
var opponentMoveResult = CanMove(board, square, kingNotation, opponentPlayerType, lastMoveNotation, false);
if (opponentMoveResult.Success)
{
isInCheck = true;
attackers.Add(square);
}
}
return new Tuple<bool, List<string>>(isInCheck, attackers);
}
public ValidateMoveResult CanMove(ChessBoard board, string move, PlayerTypeEnum player,
string lastMoveNotation)
{
Tuple<string, string> breakdown = NotationHelper.Breakdown(move);
string source = breakdown.Item1;
string destination = breakdown.Item2;
bool playerInCheck = IsInCheck(player, board, lastMoveNotation).Item1;
ValidateMoveResult canMoveResult = CanMove(board, source, destination, player, lastMoveNotation, playerInCheck);
if (canMoveResult.Success)
{
// pawn to queen swap
ChessPiece sourceBeforeSimulate = board.Get(source);
bool pawnSwap =
sourceBeforeSimulate != null &&
sourceBeforeSimulate.Type == PieceTypeEnum.Pawn &&
(sourceBeforeSimulate.Direction == -1 ? (int.Parse(destination[1].ToString()) == 8) : (int.Parse(destination[1].ToString()) == 1));
string swap = pawnSwap ? destination : null;
canMoveResult.Swap = swap;
ChessBoard boardAfterMove = board.SimulateMoves(move, canMoveResult.TakenPiece, swap);
// did player move into check?
var movedIntoCheckResult = IsInCheck(player, boardAfterMove, lastMoveNotation);
if (movedIntoCheckResult.Item1)
{
canMoveResult.Success = false;
return canMoveResult.SetMessage("cannot move into check.");
}
// did player put opponent in check?
var isOpponentInCheckResult = IsInCheck(GetOppositePlayer(player), boardAfterMove, lastMoveNotation);
bool isOpponentInCheck = isOpponentInCheckResult.Item1;
canMoveResult.MoveType = isOpponentInCheck ? MoveTypeEnum.Check : MoveTypeEnum.Normal;
// if player checked opponent, can opponent get out of check? if not, check mate
if (isOpponentInCheck)
{
string opponentKingNotation = boardAfterMove.GetKing(GetOppositePlayer(player));
Tuple<int, int> opponentKingTuple = NotationHelper.Translate(opponentKingNotation);
// can checked king move out of check?
bool canMoveOutOfCheck = CanMoveOutOfCheck(player, lastMoveNotation, boardAfterMove, opponentKingNotation, opponentKingTuple);
// can opponent kill piece that put king in check? is still in check afterwards?
bool canTakedownAttacker = false;
if (!canMoveOutOfCheck)
canTakedownAttacker = CanTakedownAttackers(player, lastMoveNotation, boardAfterMove, isOpponentInCheckResult.Item2);
// can block path of piece that put king in check? (brute force method)
bool canBlockPathOfAttackers = false;
if (!canMoveOutOfCheck && !canTakedownAttacker)
canBlockPathOfAttackers = CanMoveIntoAttackersPath(player, lastMoveNotation, boardAfterMove, isOpponentInCheckResult.Item2, opponentKingTuple);
if (!canMoveOutOfCheck && !canTakedownAttacker && !canBlockPathOfAttackers)
canMoveResult.MoveType = MoveTypeEnum.Checkmate;
}
}
return canMoveResult;
}
private bool CanMoveOutOfCheck(PlayerTypeEnum player, string lastMoveNotation, ChessBoard board, string opponentKingNotation, Tuple<int, int> opponentKingTuple)
{
bool canMoveOutOfCheck = false;
ChessPiece opponentKingPiece = board.Get(opponentKingTuple);
var relativeMoves = m_relativeMoveProviderFactory
.GetProviderByPieceType(opponentKingPiece.Type)
.GetRelativePaths(opponentKingPiece);
var absolutePaths = BoardLogic.ConvertToAbsolutePaths(opponentKingTuple, relativeMoves);
var flattenedAbsoluteMoves = absolutePaths.SelectMany(x => x);
foreach (var square in flattenedAbsoluteMoves)
{
// simulate move of king to available move
string destinationNotation = NotationHelper.Translate(square);
var getKingOutOfCheckMoveResult = CanMove(board, opponentKingNotation + destinationNotation,
GetOppositePlayer(player), lastMoveNotation);
if (getKingOutOfCheckMoveResult.Success)
{
canMoveOutOfCheck = true;
break;
}
}
return canMoveOutOfCheck;
}
private bool CanTakedownAttackers(PlayerTypeEnum player, string lastMoveNotation, ChessBoard board, List<string> attackers)
{
if (attackers.Count > 1)
return false;
bool canTakedownAttacker = false;
PlayerTypeEnum opponentPlayerType = GetOppositePlayer(player);
List<string> opponentSquares = board.GetPiecesForPlayer(opponentPlayerType);
string attackerNotation = attackers.First();
foreach (var square in opponentSquares)
{
bool canDefeatAllAttackers = CanMove(board, square + attackerNotation, opponentPlayerType, lastMoveNotation).Success;
if (canDefeatAllAttackers)
{
canTakedownAttacker = true;
break;
}
}
return canTakedownAttacker;
}
public void Cannot_Move_Into_Check()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King });
b.Set("h2", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Queen });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.White, "e1e2");
Assert.IsFalse(moveResult.Success);
}
static void RandomIntoCheck()
{
Random r = new Random(Guid.NewGuid().GetHashCode());
ChessBoard chessBoard = new ChessBoard();
(new TraditionalBoardStager()).Stage(chessBoard);
PlayerTypeEnum currentPlayer = PlayerTypeEnum.White;
ChessGame chessGame = new ChessGame(
chessBoard,
currentPlayer,
new Dictionary<PlayerTypeEnum, List<ChessPiece>>());
bool isCheckmate = false;
while (true)
{
int movesWithoutSuccess = 0;
while (true)
{
List<string> notation = chessBoard.GetPiecesForPlayer(currentPlayer);
List<string> opponentNotation =
chessBoard.GetPiecesForPlayer(currentPlayer == PlayerTypeEnum.White
? PlayerTypeEnum.Black
: PlayerTypeEnum.White);
if ((notation.Count == 1 && opponentNotation.Count == 1) || movesWithoutSuccess > 5000)
{
//Console.WriteLine("{0} on {1}, moves w/o success: {2}", notation.Count, notation.Count, movesWithoutSuccess);
chessBoard = new ChessBoard();
(new TraditionalBoardStager()).Stage(chessBoard);
currentPlayer = PlayerTypeEnum.White;
chessGame = new ChessGame(
chessBoard,
currentPlayer,
new Dictionary<PlayerTypeEnum, List<ChessPiece>>());
}
int randomPieceIndex = r.Next(0, notation.Count);
string randomSource = notation.ElementAt(randomPieceIndex);
int randomRank = r.Next(0, 8);
int randomFile = r.Next(0, 8);
string randomDestination = NotationHelper.Translate(randomRank, randomFile);
var move = chessGame.PlayerMove(currentPlayer, randomSource + randomDestination);
if (move.Success)
{
movesWithoutSuccess = 0;
if (move.MoveType == MoveTypeEnum.Checkmate)
{
(new ConsoleBoardPrinter()).PrintBoard(chessBoard.CreateStateCopy(), currentPlayer);
Console.WriteLine("Check: {0}, Moves: {1}", Enum.GetName(typeof(MoveTypeEnum), move.MoveType), string.Join(", ", move.Moves));
}
currentPlayer = move.Turn;
if (move.MoveType == MoveTypeEnum.Checkmate)
{
isCheckmate = true;
}
break;
}
++movesWithoutSuccess;
}
if (isCheckmate)
{
break;
}
}
}
public void Castle_Block()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("a1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Rook });
b.Set("b1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Knight });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.White, "e1c1");
Assert.IsFalse(moveResult.Success);
}
public void Overtake()
{
ChessBoard b = new ChessBoard();
b.Set("g4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn });
b.Set("h5", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn });
TraditionalRulesOfChess rules = new TraditionalRulesOfChess();
ChessGame chessGame = new ChessGame(
b,
PlayerTypeEnum.White,
null);
var move = chessGame.PlayerMove(PlayerTypeEnum.White, "g4h5");
Assert.IsTrue(move.Success, move.Error);
Assert.IsNotNull(move.Taken);
Assert.AreEqual(chessGame.GetTakenPiecesByPlayer(PlayerTypeEnum.White).Length, 1);
Assert.AreEqual(chessGame.GetTakenPiecesByPlayer(PlayerTypeEnum.White)[0].Player, PlayerTypeEnum.Black);
}
public void Checkmate()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King });
b.Set("h2", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Queen });
b.Set("g2", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Rook });
ChessGame g = new ChessGame(b, PlayerTypeEnum.Black, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.Black, "h2h1");
Assert.IsTrue(moveResult.Success);
Assert.IsTrue(moveResult.MoveType == MoveTypeEnum.Checkmate, "expected checkmate");
}
public void Pawn()
{
ChessBoard b = new ChessBoard();
b.Set("a2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn });
b.Set("a7", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn });
b.Set("e7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn });
b.Set("g4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn });
b.Set("h5", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn });
TraditionalRulesOfChess rules = new TraditionalRulesOfChess();
// basic move
var move = rules.CanMove(b, "a2a3", PlayerTypeEnum.White, null);
Assert.IsTrue(move.Success, move.Message);
// move two squares on first move
move = rules.CanMove(b, "a2a4", PlayerTypeEnum.White, null);
Assert.IsTrue(move.Success, move.Message);
// can't move two squares on subsequent moves
move = rules.CanMove(b, "a2a5", PlayerTypeEnum.White, null);
Assert.IsFalse(move.Success, move.Message);
// can't move backwards
move = rules.CanMove(b, "a2a1", PlayerTypeEnum.White, null);
Assert.IsFalse(move.Success, move.Message);
// piece does not exist
move = rules.CanMove(b, "h2g3", PlayerTypeEnum.White, null);
Assert.IsFalse(move.Success, move.Message);
// g4 pawn over-take h5 pawn
move = rules.CanMove(b, "g4h5", PlayerTypeEnum.White, null);
Assert.IsTrue(move.Success, move.Message);
b.RecordMoves(new[] { "a2a3" }, null, null);
move = rules.CanMove(b, "a3a5", PlayerTypeEnum.White, null);
Assert.IsFalse(move.Success, move.Message);
move = rules.CanMove(b, "a3a4", PlayerTypeEnum.White, null);
Assert.IsTrue(move.Success, move.Message);
move = rules.CanMove(b, "a7a8", PlayerTypeEnum.White, null);
Assert.IsTrue(move.Success, move.Message);
move = rules.CanMove(b, "e7e6", PlayerTypeEnum.Black, null);
Assert.IsTrue(move.Success, move.Message);
move = rules.CanMove(b, "e7e8", PlayerTypeEnum.Black, null);
Assert.IsFalse(move.Success, move.Message);
}
public void EnPassant()
{
ChessBoard b = new ChessBoard();
(new EnPassantTestingBoardStager()).Stage(b);
var rules = new TraditionalRulesOfChess();
var moveResult = rules.CanMove(
b, "a2a4", PlayerTypeEnum.White, null);
Assert.IsTrue(moveResult.Success);
b.RecordMoves(new[] { "a2a4" }, null, null);
moveResult = rules.CanMove(
b, "b4a3", PlayerTypeEnum.Black, "a2a4");
Assert.IsTrue(moveResult.Success);
Assert.AreEqual("a4", moveResult.TakenPiece, true);
}
public void White_Puts_Black_In_Check()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("d1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Queen });
b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.White, "d1a4");
Assert.IsTrue(moveResult.Success);
Assert.IsTrue(moveResult.MoveType == MoveTypeEnum.Check);
}
public void Cannot_Castle_Out_Of_Check()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("a1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Rook });
b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Queen });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.White, "e1c1");
Assert.IsFalse(moveResult.Success);
moveResult = g.PlayerMove(PlayerTypeEnum.White, "e1f1");
Assert.IsTrue(moveResult.Success);
}
public void Castle()
{
ChessBoard b = new ChessBoard();
b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("a1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Rook });
ChessGame g = new ChessGame(b, PlayerTypeEnum.White, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.White, "e1c1");
Assert.IsTrue(moveResult.Success);
Assert.IsNotNull(moveResult.Moves);
Assert.AreEqual(2, moveResult.Moves.Length);
Assert.AreEqual("e1c1", moveResult.Moves[0]);
Assert.AreEqual("a1d1", moveResult.Moves[1]);
Assert.IsNotNull(g.ChessBoard.Get("d1"));
Assert.AreEqual(PieceTypeEnum.Rook, g.ChessBoard.Get("d1").Type);
}
public ChessGame(ChessBoard b, PlayerTypeEnum player, Dictionary<PlayerTypeEnum, List<ChessPiece>> takenPieces)
: this(b, player, takenPieces, new TraditionalRulesOfChess())
{
}
public static bool IsPathClear(ChessBoard board, Tuple<int, int>[] path)
{
foreach (var move in path)
{
if (board.Get(move) != null)
return false;
}
return true;
}
static void InteractiveConsole()
{
ChessBoard chessBoard = new ChessBoard();
//(new TraditionalBoardStager()).Stage(chessBoard);
//(new RookTestingBoardStager()).Stage(chessBoard);
//(new BishopTestingBoardStager()).Stage(chessBoard);
//(new QueenTestingBoardStager()).Stage(chessBoard);
//(new EnPassantTestingBoardStager()).Stage(chessBoard);
//(new PawnSwapBoardStager()).Stage(chessBoard);
(new KnightTestingBoardStager()).Stage(chessBoard);
ChessGame chessGame = new ChessGame(
chessBoard,
PlayerTypeEnum.White,
new Dictionary<PlayerTypeEnum, List<ChessPiece>>());
ChessPiece[,] state = chessBoard.CreateStateCopy();
(new ConsoleBoardPrinter()).PrintBoard(state, PlayerTypeEnum.White);
PlayerTypeEnum playerTurn = PlayerTypeEnum.White;
Console.WriteLine("Input: 1 square [a2] to show possible moves; 2 square [a1b1] to move");
string move;
Console.Write("> ");
while (!string.IsNullOrWhiteSpace(move = Console.ReadLine()))
{
try
{
if (string.IsNullOrWhiteSpace(move))
break;
if (move.Length == 2)
{
var cpyb = new ChessBoard(chessBoard.CreateStateCopy());
var pm = (new PotentialMoveService()).GetPotentialMoves(chessGame, playerTurn);
List<string> moves;
pm.TryGetValue(move, out moves);
moves = moves ?? new List<string>();
(new ConsoleBoardPrinter()).PrintBoard(state, PlayerTypeEnum.White, new HashSet<string>(moves));
}
else if (move.Length == 4)
{
var moveResult = chessGame.PlayerMove(playerTurn, move);
playerTurn = moveResult.Turn;
state = chessBoard.CreateStateCopy();
(new ConsoleBoardPrinter()).PrintBoard(state, PlayerTypeEnum.White);
Console.WriteLine("{0} - {1} - {2} - {3} - {4}", moveResult.Success, moveResult.Error, moveResult.Taken, moveResult.MoveType, moveResult.Turn);
}
else
Console.WriteLine("Not implemented.");
Console.Write("> ");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
public void Double_Check()
{
ChessBoard b = new ChessBoard();
b.Set("h1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King });
b.Set("h4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Rook });
b.Set("h5", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn });
b.Set("f4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Bishop });
b.Set("h6", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King });
b.Set("g7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn });
ChessGame g = new ChessGame(b, PlayerTypeEnum.Black, null);
var moveResult = g.PlayerMove(PlayerTypeEnum.Black, "g7g5");
Assert.IsTrue(moveResult.Success);
moveResult = g.PlayerMove(PlayerTypeEnum.White, "h5g6");
Assert.IsTrue(moveResult.Success);
}
