public void testQueenMovementWithCapture()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
squarePos srcSquare = new squarePos(3, 3);
ourBoard.addPiece(pieceType.queen, pieceColour.white, srcSquare.x, srcSquare.y);
queenSquare queenie = (queenSquare)ourBoard[srcSquare];
// Place a black pawn on the board, and ensure that we can capture it, and
// that we cannot move through it.
ourBoard.addPiece(pieceType.pawn, pieceColour.black, 1, 1);
sizableArray<move> possibleMoves = queenie.getPossibleMoves(ourBoard);
List<move> expectedmoves = getExpectedMoveSquares(queenie);
// We don't expect to be able to move to (0,0), since that square is behind an
// enemy pawn..
bool found = false;
for (int i = 0; i < expectedmoves.Count; i++)
{
if (expectedmoves[i].dstPos.x == 0 && expectedmoves[i].dstPos.y == 0)
{
expectedmoves.RemoveAt(i);
found = true;
break;
}
}
if (!found)
throw new ArgumentOutOfRangeException();
VectorMovementTests.testListsAreOfSameMoves(expectedmoves, possibleMoves);
}
public static DoktorChessAIBoard makeFromFEN(string FENString, gameType newType, boardSearchConfig searchConfig)
{
DoktorChessAIBoard newBoard = new DoktorChessAIBoard(newType, searchConfig);
newBoard.makeFromFEN(FENString);
return newBoard;
}
public void testCheckDetectionAsWhite()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
ourBoard.addPiece(pieceType.rook, pieceColour.black, 1, 1);
ourBoard.addPiece(pieceType.king, pieceColour.white, 3, 1);
Assert.IsTrue(ourBoard.isPlayerInCheck(pieceColour.white));
}
public void testQueensideCastlingNotation()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourKing = ourBoard.addPiece(pieceType.king, pieceColour.white, 4, 0);
ourBoard.addPiece(pieceType.rook, pieceColour.white, 0, 0);
move theMove = new move(ourKing, new square(2, 0));
Assert.AreEqual("O-O-O", theMove.ToString(moveStringStyle.chessNotation));
}
public void testPieceMoveNotation()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square bish = new bishopSquare(new squarePos(0, 0), pieceColour.black);
square targetSpace = new square( new squarePos(0, 1) );
move theMove = new move(bish, targetSpace);
Assert.AreEqual("Ba2", theMove.ToString(moveStringStyle.chessNotation));
}
public threatMap(DoktorChessAIBoard newBoard)
{
_parentBoard = newBoard;
for (int y = 0; y < DoktorChessAIBoard.sizeY; y++)
{
for (int x = 0; x < DoktorChessAIBoard.sizeX; x++)
{
// Spawn lists of pieces which threaten each square
piecesWhichThreatenSquare[x, y] = new speedySquareList();
}
}
}
public void testQueenMovement()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
squarePos srcSquare = new squarePos(3, 3);
ourBoard.addPiece(pieceType.queen, pieceColour.white, srcSquare.x, srcSquare.y);
queenSquare queenie = (queenSquare) ourBoard[srcSquare];
sizableArray<move> possibleMoves = queenie.getPossibleMoves(ourBoard);
List<move> expectedmoves = getExpectedMoveSquares(queenie);
VectorMovementTests.testListsAreOfSameMoves(expectedmoves, possibleMoves);
}
public void testKingsideCastlingMoveIsExecutedCorrectly()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourKing = ourBoard.addPiece(pieceType.king, pieceColour.white, 4, 0);
square ourRook = ourBoard.addPiece(pieceType.rook, pieceColour.white, 7, 0);
ourBoard.addPiece(pieceType.king, pieceColour.black, 0, 0);
// Make our castling move..
move castlingMove = new move(ourKing, ourBoard[6, 0]);
ourBoard.doMove(castlingMove);
// Verify that the rook and king have both moved to their correct squares.
Assert.IsTrue(ourBoard[6, 0] == ourKing);
Assert.IsTrue(ourBoard[5, 0] == ourRook);
}
public void testFinishedGameScoreNoPieces()
{
// Generate a board which is lost via the 'no pieces remain' rule, and verify
// we get the correct score.
DoktorChessAIBoard ourboard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
ourboard.addPiece(pieceType.pawn, pieceColour.black, 1, 1);
// position is lost for white..
BoardScorer whiteScorer = new BoardScorer(ourboard, pieceColour.white, new scoreModifiers());
Assert.AreEqual(BoardScorer.lowest, whiteScorer.getScore());
// and won for black.
BoardScorer blackScorer = new BoardScorer(ourboard, pieceColour.black, new scoreModifiers());
Assert.AreEqual(BoardScorer.highest, blackScorer.getScore());
}
public void testThatKingWillNotMoveInToCheck()
{
boardSearchConfig config = boardSearchConfig.getDebugConfig();
config.searchDepth = 0;
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, config);
square blackKing = ourBoard.addPiece(pieceType.king, pieceColour.black, 0, 0);
ourBoard.addPiece(pieceType.rook, pieceColour.white, 1, 7);
ourBoard.addPiece(pieceType.king, pieceColour.white, 7, 7);
// Ensure that black cannot move in to the rook's line of fire.
sizableArray<move> moves = blackKing.getPossibleMoves(ourBoard);
foreach (move thisMove in moves)
Assert.IsTrue(thisMove.dstPos.x == 0, "King moved in to check");
Assert.IsTrue(moves.Length == 1);
}
public void testFinishedGameScorePawnToOtherEnd()
{
// We make two different boards here to test two different scenarios - if a black
// pawn is at rank 0 and a white at rank 7.
DoktorChessAIBoard pawnAt0 = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
pawnAt0.addPiece(pieceType.pawn, pieceColour.black, 1, 0);
// Should be a black win.
verifyWonForWhite(pawnAt0, pieceColour.black);
// Now the white pawn at rank 7.
DoktorChessAIBoard pawnAt7 = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
pawnAt7.addPiece(pieceType.pawn, pieceColour.white, 1, 7);
// Should be a white win.
verifyWonForWhite(pawnAt7, pieceColour.white);
}
public void testKingsideCastlingMoveIsNotAfterRookHasMoved()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourKing = ourBoard.addPiece(pieceType.king, pieceColour.white, 4, 0);
square ourRook = ourBoard.addPiece(pieceType.rook, pieceColour.white, 6, 0);
ourBoard.addPiece(pieceType.king, pieceColour.black, 0, 0);
// Move the rook to 7,0.
ourBoard.doMove(new move(ourRook, ourBoard[7,0]));
// Now make sure we cannot castle.
sizableArray<move> possibleMoves = ourKing.getPossibleMoves(ourBoard);
// None of these moves should end up at (6,0).
if (Array.Find(possibleMoves.getArray(), a => a.dstPos.isSameSquareAs(new squarePos(6, 0))) != null)
throw new AssertFailedException("Castling found after rook has moved");
}
public void testNonInitialPawnMovement()
{
// Pawns can only move one square after their initial move.
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
square ourPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.white, 1, 1);
// Mark pawn as having moved
ourPawn.movedCount++;
sizableArray<move> actual = ourPawn.getPossibleMoves(ourBoard);
// We expect that the pawn can move one space forward only.
List<move> expected = new List<move>
{
new move(ourPawn, ourBoard[1, 2])
};
VectorMovementTests.testListsAreOfSameMoves(expected, actual);
}
public void testInitialPawnMovement()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
ourBoard.addPiece(pieceType.pawn, pieceColour.white, 1, 1);
square ourPawn = ourBoard[1, 1];
sizableArray<move> actual = ourPawn.getPossibleMoves(ourBoard);
// We expect that the pawn can move two spaces forward, or one space forward.
List<move> expected = new List<move>
{
new move(ourPawn, ourBoard[1, 2]),
new move(ourPawn, ourBoard[1, 3])
};
VectorMovementTests.testListsAreOfSameMoves(expected, actual);
if (ourPawn.movedCount != 0)
throw new Exception("Pawn not move count not incremented");
}
public void testKingsideCastlingMoveIsFound()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourKing = ourBoard.addPiece(pieceType.king, pieceColour.white, 4, 0);
ourBoard.addPiece(pieceType.rook, pieceColour.white, 7, 0);
ourBoard.addPiece(pieceType.king, pieceColour.black, 0, 0);
sizableArray<move> possibleMoves = ourKing.getPossibleMoves(ourBoard);
// One of these moves should be a non-capturing move of the king to (6,0).
move[] castlingMoveList = Array.FindAll(possibleMoves.getArray(), a => !a.isCapture && a.dstPos.isSameSquareAs(new squarePos(6, 0)));
Assert.AreNotEqual(0, castlingMoveList.Length, "Castling move was not found");
Assert.AreEqual(1, castlingMoveList.Length, "Multiple castling moves were found");
// Verify some other stuff on the move.
move castlingMove = castlingMoveList[0];
if (!castlingMove.srcPos.isSameSquareAs(ourKing.position))
throw new AssertFailedException("Castling move has incorrect source square");
}
public BoardScorer(DoktorChessAIBoard toScore, pieceColour newViewpoint, scoreModifiers newModifiers)
{
modifiers = newModifiers;
viewpoint = newViewpoint;
List<square> myPieces = toScore.getPiecesForColour(viewpoint);
List<square> enemyPieces = toScore.getPiecesForColour(viewpoint == pieceColour.black ? pieceColour.white : pieceColour.black);
parentBoard = toScore;
if (viewpoint == pieceColour.black)
{
_myMaterialAdvantage = toScore.blackMaterialAdvantage;
_myMaterialDisadvantage = toScore.whiteMaterialAdvantage;
} else if (viewpoint == pieceColour.white)
{
_myMaterialAdvantage = toScore.whiteMaterialAdvantage;
_myMaterialDisadvantage = toScore.blackMaterialAdvantage;
}
_status = toScore.getGameStatus(myPieces, enemyPieces);
}
public void testMoveDoingUndoingWithPawnPromotion()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
ourBoard.addPiece(pieceType.pawn, pieceColour.white, 1, 6);
string origBoard = ourBoard.ToString();
sizableArray<move> potentialMoves = ourBoard.getMoves(pieceColour.white);
if (potentialMoves.Length == 0)
Assert.Inconclusive("No pawn moves found");
// Find promotion moves
move[] promotionMoves = Array.FindAll(potentialMoves.getArray(), a => a.isPawnPromotion);
if (promotionMoves.Length == 0)
Assert.Inconclusive("No promotion moves found");
foreach (move thisMove in promotionMoves)
{
ourBoard.doMove(thisMove);
if (ourBoard.ToString() == origBoard)
throw new AssertFailedException("After a pawn promotion move, the board has not changed");
// Additionally, verify that the pawn has been promoted
if (ourBoard[thisMove.dstPos].type != thisMove.typeToPromoteTo)
throw new AssertFailedException("Pawn was not promoted");
if (ourBoard[thisMove.dstPos].GetType() == typeof(pawnSquare))
throw new AssertFailedException("Pawn was not promoted, but type has changed");
if (ourBoard[thisMove.dstPos].colour != pieceColour.white)
throw new AssertFailedException("Pawn was promoted to wrong colour");
ourBoard.undoMove(thisMove);
if (ourBoard.ToString() != origBoard)
throw new AssertFailedException("After a pawn promotion move undo, the board has changed");
}
}
public void testKingsideCastlingMoveIsNotFoundThroughAPiece()
{
// Place an enemy pawn in the way which will prevent us from castling.
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourKing = ourBoard.addPiece(pieceType.king, pieceColour.white, 4, 0);
ourBoard.addPiece(pieceType.rook, pieceColour.white, 7, 0);
ourBoard.addPiece(pieceType.pawn, pieceColour.black, 6, 0);
ourBoard.addPiece(pieceType.king, pieceColour.black, 0, 0);
sizableArray<move> possibleMoves = ourKing.getPossibleMoves(ourBoard);
// None of these moves should end up at (6, 0).
if (Array.Find(possibleMoves.getArray(), a => a.dstPos.isSameSquareAs(new squarePos(6, 0))) != null)
throw new AssertFailedException("Castling found through an enemy piece");
}
public void testScoreWithDangling()
{
DoktorChessAIBoard ourboard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
ourboard.addPiece(pieceType.pawn, pieceColour.black, 3, 3);
ourboard.addPiece(pieceType.queen, pieceColour.white, 2, 2);
ourboard.addPiece(pieceType.king, pieceColour.black, 7, 7);
ourboard.addPiece(pieceType.king, pieceColour.white, 5, 5);
BoardScorer whiteScorer = new BoardScorer(ourboard, pieceColour.white, new scoreModifiers());
// White's queen is dangling, as is blacks pawn.
int expected = whiteScorer.modifiers.materialModifier * (8 - 1);
expected -= whiteScorer.modifiers.danglingModifier * 8;
expected += whiteScorer.modifiers.danglingModifier * 1;
Assert.AreEqual(expected, whiteScorer.getScore());
}
public void testVectorMovement(List<squarePos> expectedPos, vectorDirection dir)
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
squarePos srcSquare = new squarePos(3, 3);
ourBoard.addPiece(pieceType.queen, pieceColour.white, srcSquare.x, srcSquare.y);
queenSquare queenie = (queenSquare)ourBoard[srcSquare];
List<move> expectedmoves = new List<move>(expectedPos.Count);
foreach (squarePos thisPos in expectedPos)
expectedmoves.Add(new move((square) queenie, ourBoard[thisPos]));
sizableArray<move> possibleMoves = queenie.getMovesForVector(null, ourBoard, dir);
testListsAreOfSameMoves(expectedmoves, possibleMoves);
}
public void testKingsideCastlingMoveIsUnExecutedCorrectly()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourKing = ourBoard.addPiece(pieceType.king, pieceColour.white, 4, 0);
square ourRook = ourBoard.addPiece(pieceType.rook, pieceColour.white, 7, 0);
ourBoard.addPiece(pieceType.king, pieceColour.black, 0, 0);
string origBoard = ourBoard.ToString();
// Make out castling move
move castlingMove = new move(ourKing, ourBoard[6, 0]);
ourBoard.doMove(castlingMove);
Assert.AreNotEqual(origBoard, ourBoard.ToString(), "Castling did not affect the board");
// Now undo our castling and verify that we get back to the original position.
ourBoard.undoMove(castlingMove);
Assert.AreEqual(origBoard, ourBoard.ToString(), "Castling and then un-castling did not return the original board");
}
public void testMaterialAdvantage()
{
// Generate a boardScorer and present it with a queen (ours), and two pawns
// (enemy). Verify the resultant score as 8-2 = 6.
DoktorChessAIBoard ourboard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
ourboard.addPiece(pieceType.queen, pieceColour.white, 1, 1);
ourboard.addPiece(pieceType.pawn, pieceColour.black, 3, 4);
ourboard.addPiece(pieceType.pawn, pieceColour.black, 3, 5);
BoardScorer myscorer = new BoardScorer(ourboard, pieceColour.white, new scoreModifiers());
// Check only material advantage
myscorer.modifiers.danglingModifier = 0;
myscorer.modifiers.materialModifier = 1;
Assert.AreEqual(8 - 2, myscorer.getScore());
}
public void testPawnMovementWithCaptureCol0()
{
// Spawn a black pawn at 0,3 and a white pawn at 1,4. Verify that the black
// pawn can capture the white.
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
square ourPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.white, 0, 3);
square enemyPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.black, 1, 4);
sizableArray<move> possibleMoves = ourPawn.getPossibleMoves(ourBoard);
checkContainsSingleCapture(possibleMoves.getArray(), ourPawn, enemyPawn);
}
private void verifyWonForWhite(DoktorChessAIBoard ourBoard, pieceColour wonCol)
{
pieceColour lostCol = DoktorChessAIBoard.getOtherSide(wonCol);
// The position should be won/lost for white/black, respectively
Assert.IsTrue(ourBoard.getGameStatus(wonCol) == gameStatus.won);
Assert.IsTrue(ourBoard.getGameStatus(lostCol) == gameStatus.lost);
// and this should be reflected in the scores
BoardScorer whiteScorer = new BoardScorer(ourBoard, wonCol, new scoreModifiers());
Assert.AreEqual(BoardScorer.highest, whiteScorer.getScore());
// and won for black.
BoardScorer blackScorer = new BoardScorer(ourBoard, lostCol, new scoreModifiers());
Assert.AreEqual(BoardScorer.lowest, blackScorer.getScore());
}
public void testThatEnPassantOccursWhenItShouldAsBlack()
{
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
// En passant requires that the enemy pawn has just advanced two squares. Because of this, we make this move on a board and then check that en passant can occur.
square ourPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.black, 6, 3);
square enemyPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.white, 7, 1);
// Advance the enemy pawn
move advanceTwo = new move(enemyPawn, ourBoard[enemyPawn.position.up(2)]);
ourBoard.doMove(advanceTwo);
// Now verify that the enemy pawn is captured.
sizableArray<move> possibleMoves = ourPawn.getPossibleMoves(ourBoard);
move enPassantCapture = null;
foreach (move thisMove in possibleMoves)
{
if (thisMove.isCapture)
{
if (enPassantCapture != null)
throw new AssertFailedException("More than one capture was found");
// Note that our dest square is not the enemy square here.
Assert.IsTrue(thisMove.srcPos.isSameSquareAs(ourPawn.position));
Assert.IsTrue(thisMove.dstPos.isSameSquareAs(ourPawn.position.rightOne().downOne() ));
Assert.AreSame(thisMove.capturedSquare, enemyPawn);
enPassantCapture = thisMove;
}
}
if (enPassantCapture == null)
throw new AssertFailedException("En passant capture did not occur");
// Make sure that the en passant capture ends up putting our pawn in the square above the enemy pawn
Assert.IsTrue(enemyPawn.position.downOne().isSameSquareAs( enPassantCapture.dstPos) );
}
public void testPawnPromotionWithCapture()
{
// Verify promotion occurs when capturing in to the back row.
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.white, 1, 6);
ourPawn.movedCount++;
ourBoard.addPiece(pieceType.knight, pieceColour.black, 1, 7);
ourBoard.addPiece(pieceType.knight, pieceColour.black, 2, 7);
sizableArray<move> actual = ourPawn.getPossibleMoves(ourBoard);
// We expect a number of moves forward, all of which are promotions.
List<move> expected = new List<move>
{
new move(ourPawn, ourBoard[2, 7], pieceType.bishop),
new move(ourPawn, ourBoard[2, 7], pieceType.knight),
new move(ourPawn, ourBoard[2, 7], pieceType.queen),
new move(ourPawn, ourBoard[2, 7], pieceType.rook)
};
VectorMovementTests.testListsAreOfSameMoves(expected, actual);
}
public void testPawnPromotionAsBlack()
{
// Pawns should be able to be promoted to any piece of their own colour, other than a
// king.
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.normal, boardSearchConfig.getDebugConfig());
square ourPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.black, 1, 1);
ourPawn.movedCount++;
sizableArray<move> actual = ourPawn.getPossibleMoves(ourBoard);
// We expect a number of moves forward, all of which are promotions.
List<move> expected = new List<move>
{
new move(ourPawn, ourBoard[1, 0], pieceType.bishop),
new move(ourPawn, ourBoard[1, 0], pieceType.knight),
new move(ourPawn, ourBoard[1, 0], pieceType.queen),
new move(ourPawn, ourBoard[1, 0], pieceType.rook)
};
VectorMovementTests.testListsAreOfSameMoves(expected, actual);
}
public void testFinishedGameScoreStalemate()
{
// Generate a board two pawns, deadlocked in front of each other. This should
// be a draw via stalemate. Add a third pawn to ensure that stalemate is causing
// the '0' board score, not a materian mismatch.
DoktorChessAIBoard ourboard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
// Two deadlocked pawns
ourboard.addPiece(pieceType.pawn, pieceColour.white, 1, 2);
ourboard.addPiece(pieceType.pawn, pieceColour.black, 1, 3);
// an outlier pawn
ourboard.addPiece(pieceType.pawn, pieceColour.black, 4, 4);
Assert.IsTrue(ourboard.getGameStatus(pieceColour.white) == gameStatus.drawn);
Assert.IsTrue(ourboard.getGameStatus(pieceColour.black) == gameStatus.drawn);
BoardScorer whiteScorer = new BoardScorer(ourboard, pieceColour.white, new scoreModifiers());
Assert.AreEqual(0, whiteScorer.getScore());
BoardScorer blackScorer = new BoardScorer(ourboard, pieceColour.black, new scoreModifiers());
Assert.AreEqual(0, blackScorer.getScore());
}
public void testPawnMovementWithCaptureCol7()
{
// Now test the same, at the other end of the board. Test on the edge.
DoktorChessAIBoard ourBoard = new DoktorChessAIBoard(gameType.queenAndPawns, boardSearchConfig.getDebugConfig());
square ourPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.white, 6, 3);
square enemyPawn = ourBoard.addPiece(pieceType.pawn, pieceColour.black, 7, 4);
sizableArray<move> possibleMoves = ourPawn.getPossibleMoves(ourBoard);
checkContainsSingleCapture(possibleMoves.getArray(), ourPawn, enemyPawn);
}
public void verifyFiftyMoveRule(DoktorChessAIBoard ourBoard, int moveOffset)
{
for (int n = 0; n < 100 - moveOffset; n++)
{
Assert.AreEqual(gameStatus.inProgress, ourBoard.getGameStatus(pieceColour.white), "Game declared drawn at move " + n.ToString());
switch (n % 4)
{
case 0:
// Play Nc3
ourBoard.doMove(new move(ourBoard[1, 0], ourBoard[2, 2]));
break;
case 1:
// Play Nc6
ourBoard.doMove(new move(ourBoard[1, 7], ourBoard[2, 5]));
break;
case 2:
// And move knights back again.
// Nb1
ourBoard.doMove(new move(ourBoard[2, 2], ourBoard[1, 0]));
break;
case 3:
// nb8
ourBoard.doMove(new move(ourBoard[2, 5], ourBoard[1, 7]));
break;
default:
throw new ArgumentException();
}
}
// 50 moves have elapsed! It's a draw!
Assert.AreEqual(gameStatus.drawn, ourBoard.getGameStatus(pieceColour.white));
}
