public void TestCanBearCheckersOffWhenAllCheckersInHomeBoard()
{
int[] gameBoard = new int[] { 0, 3, 3, 3, 3, 3,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
-3, -3, -3, -3, -3, 0 };
fd.SetReturnValues(new int[] { 2, 3 });
bg = new BackgammonGame(gameBoard, fd);
//With this setup, both players should be able to bear off checkers that are two, three or five positions away
HashSet <int> expectedLegalMovesBlack = HashSetFromArray(new int[] { 22, 23, BackgammonGame.BLACK_BEAR_OFF_ID });
HashSet <int> actualLegalMovesBlack = bg.GetLegalMovesFor(BLACK, 20);
Assert.IsTrue(expectedLegalMovesBlack.SetEquals(actualLegalMovesBlack));
HashSet <int> expectedLegalMovesWhite = new HashSet <int>()
{
2, 3, BackgammonGame.WHITE_BEAR_OFF_ID
};
HashSet <int> actualLegalMovesWhite = bg.GetLegalMovesFor(WHITE, 5);
Assert.IsTrue(expectedLegalMovesWhite.SetEquals(actualLegalMovesWhite));
}
public void TestChangesRegisteredProperlyAfterOneMoveWhite()
{
List <int[]> moves = new List <int[]> {
ar(1, 3)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd);
bg.Move(White, 6, 3);
var changes = bg.GetChanges();
Assert.AreEqual(3, changes.Count());
var c1 = changes[0];
var c2 = changes[1];
var c3 = changes[2];
Assert.IsTrue(c1.IsDiceState(), "c1 is not dice state");
Assert.IsTrue(c2.IsMove(), "c2 is not move");
Assert.IsTrue(c3.IsDiceState(), "c3 is not dice state");
Assert.IsTrue(arrayEqual(ar(1, 3), c1.AsDiceState().GetDiceValues()), "Expected 1,3 but got " + string.Join(",", c1.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 6 3", c2.AsMove().DebugString(), "Expected w 6 3, got " + c2.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 1 }, c3.AsDiceState().GetDiceValues()));
}
static Player LearnVsNaive(int gameCount)
{
Player white, black;
var game = new BackgammonGame(BackgammonGame.DefaultGameBoard, new RealDice());
if (gameCount % 2 == 0)
{
white = new MachAI(game);
black = new NaiveAI(game, Black);
}
else
{
black = new MachAI(game);
white = new NaiveAI(game, White);
}
while (!TemporalDifference.GameOver(game.GetGameBoardState()))
{
if (game.playerToMove() == White)
{
white.MakeMove();
}
else
{
black.MakeMove();
}
}
TemporalDifference.UpdateWeights(game.GetGameBoardState(), game.GetGameBoardState(), (gameCount % 2 == 0) ? White : Black);
return((game.GetGameBoardState().getCheckersOnTarget(White) == 15) ? white : black);
}
public void TestCannotMoveFromOutsideTheGameBoard()
{
initialGameBoard[0]++; //Removing a black checker from position 1
initialGameBoard[23]--; //Removing a white checker from position 24
fd.SetReturnValues(new int[] { 3, 2 });
//Creating a game with the above specificed game board, and one checker of each type bore offsa
bg = new BackgammonGame(initialGameBoard, fd, 0, 1, 0, 1);
HashSet <int> whiteMovesFromBearOff = bg.GetLegalMovesFor(WHITE, WHITE.BearOffPositionID());
Assert.IsTrue(whiteMovesFromBearOff.Count() == 0);
HashSet <int> whiteMovesFromOutsideBoard = bg.GetLegalMovesFor(WHITE, 26);
Assert.IsTrue(whiteMovesFromOutsideBoard.Count() == 0);
HashSet <int> blackMovesFromBearOff = bg.GetLegalMovesFor(BLACK, BLACK.BearOffPositionID());
Assert.IsTrue(blackMovesFromBearOff.Count() == 0);
HashSet <int> blackMovesFromOutsideBoard = bg.GetLegalMovesFor(BLACK, -2);
Assert.IsTrue(blackMovesFromOutsideBoard.Count() == 0);
}
public void TestCannotMoveCheckersOnBoardWhenHasCheckerOnBar()
{
//removing a checker white at position 6. WILL BE RESET AFTER TEST
initialGameBoard[5] -= 1;
//removing a black checker at position 19. WILL BE RESET AFTER TEST
initialGameBoard[18] += 1;
//putting one black and one white checker on the bar
bg = new BackgammonGame(initialGameBoard, fd, 1, 0, 1, 0);
//Ensures that any checker will reach any reachable position on the board
fd.SetReturnValues(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 });
//Since white player has a checker on the bar, it should not be possible to move another checker.
//Checking that white cannot move to any positions with another checker
HashSet <int> legalMovesWhite = bg.GetLegalMovesFor(WHITE, 13);
Assert.AreEqual(0, legalMovesWhite.Count);
//Since black player has a checker on the bar, it should not be possible to move another checker.
//Checking that black cannot move to any positions with another checker
HashSet <int> legalMovesBlack = bg.GetLegalMovesFor(BLACK, 12);
Assert.AreEqual(0, legalMovesBlack.Count);
}
public void TestCannotMoveToPositionWithTwoOrMoreEnemyCheckers()
{
fd.SetReturnValues(new int[] { 5, 2 });
bg = new BackgammonGame(initialGameBoard, fd);
//Given the initial board setup and the values 5 and 2 on the dice,
//white can only move to position 22 from position 24,
// due to 19 and 17 being blocked by more than 1 black checker
HashSet <int> expectedLegalMovesWhite = new HashSet <int>();
expectedLegalMovesWhite.Add(22);
HashSet <int> actualLegalMovesWhite =
bg.GetLegalMovesFor(WHITE, 24);
Assert.IsTrue(actualLegalMovesWhite.SetEquals(expectedLegalMovesWhite));
//Given the initial board setup and the values 5 and 2 on the dice,
//black can only move to position 3 from position 1, due to 6 and 8 being
//blocked by more than 1 white checker
HashSet <int> expectedLegalMovesBlack = new HashSet <int>();
expectedLegalMovesBlack.Add(3);
HashSet <int> actualLegalMovesBlack =
bg.GetLegalMovesFor(BLACK, 1);
Assert.IsTrue(actualLegalMovesBlack.SetEquals(expectedLegalMovesBlack));
}
public void TestCannotMoveCheckersOutsideGameBoard()
{
//Moving a black checker from position 19 to position 23. WILL BE RESET BEFORE NEXT TEST
initialGameBoard[18] += 1;
initialGameBoard[22] -= 1;
//Moving a white checker from position 6 to position 2. WILL BE RESET BEFORE NEXT TEST
initialGameBoard[5] -= 1;
initialGameBoard[1] += 1;
bg = new BackgammonGame(initialGameBoard, fd);
//Setting the dice values
fd.SetReturnValues(new int[] { 6, 2 });
//All possible moves for the white checer on position 2 ends up outside the board, while
//white is not bearing off his checkers. Therefore, there are no legal moves for the white checker
HashSet <int> actualLegalMovesWhite = bg.GetLegalMovesFor(WHITE, 2);
Assert.IsTrue(actualLegalMovesWhite.Count == 0);
//All possible moves for the black checer on position 23 ends up outside the board, while
//black is not bearing off his checkers. Therefore, there are no legal moves for that black checker
HashSet <int> actualLegalMovesBlack = bg.GetLegalMovesFor(BLACK, 23);
Assert.IsTrue(actualLegalMovesBlack.Count == 0);
}
public void TestChangesRegisteredProperlyCompundMovesOfMultipleSmallerMoves()
{
List <int[]> moves = new List <int[]>()
{
ar(1, 3), ar(4, 4)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd);
bg.Move(White, 13, 9);
var changes = bg.GetChanges();
Assert.AreEqual(5, changes.Count());
var c1 = changes[0];
var c2 = changes[1];
var c3 = changes[2];
var c4 = changes[3];
var c5 = changes[4];
Assert.IsTrue(c1.IsDiceState(), "c1 is not dice state");
Assert.IsTrue(c2.IsMove(), "c2 is not move");
Assert.IsTrue(c3.IsDiceState(), "c3 is not dice state");
Assert.IsTrue(arrayEqual(ar(1, 3), c1.AsDiceState().GetDiceValues()), "Expected 1,3 but got " + string.Join(",", c1.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 13 10", c2.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 1 }, c3.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 10 9", c4.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 4, 4, 4, 4 }, c5.AsDiceState().GetDiceValues()));
}
public void TestLegalMovesFromPointWithNoCheckerGivesEmptyResult()
{
bg = new BackgammonGame(initialGameBoard, fd);
//Ensures that at least one open position is reachable from anywhere on the board
fd.SetReturnValues(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 });
//There are no white or black checkers on position 14
//And
HashSet <int> legalMovesWhite =
bg.GetLegalMovesFor(WHITE, 14);
Assert.IsTrue(legalMovesWhite.Count == 0);
HashSet <int> legalMovesBlack =
bg.GetLegalMovesFor(BLACK, 14);
Assert.IsTrue(legalMovesBlack.Count == 0);
//There are black, but not white, checkers on position 12
//Test that it is not possible to move white checkers from here
legalMovesWhite =
bg.GetLegalMovesFor(WHITE, 12);
Assert.IsTrue(legalMovesWhite.Count == 0);
//There are white, but not black, checkers on position 13
//Test that it is not possible to move black checkers from here
legalMovesBlack =
bg.GetLegalMovesFor(BLACK, 13);
Assert.IsTrue(legalMovesBlack.Count == 0);
}
public void TestGetPreviousTurnWhenNoLegalMoves()
{
//When it becomes black's turn, there will be no legal moves, but the turn should change to white
//before bg.EndTurn(Black) is called
int[] board = new int[]
{
-15, 2, 2, 2, 2, 2,
2, 3, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0
};
List <int[]> moves = new List <int[]>()
{
ar(1, 3), ar(5, 3)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(board, fd);
bg.Move(White, 8, 5);
bg.Move(White, 8, 7);
var turn = bg.GetPreviousTurn();
Assert.AreEqual(White, turn.color);
Assert.IsTrue(arrayEquals(ar(1, 3), turn.dice.ToArray()));
Assert.AreEqual(2, turn.moves.Count());
bg.EndTurn(Black);
turn = bg.GetPreviousTurn();
Assert.AreEqual(Black, turn.color);
Assert.IsTrue(arrayEquals(ar(5, 3), turn.dice.ToArray()));
Assert.AreEqual(0, turn.moves.Count());
}
public void TestGetPreviousTurnWhenOnlySomeMovesCouldBeUsed()
{
//White will roll 1 and 3, so he will only be able to move the checker on position 24 to position 21.
//There will be no other legal moves, so the turn changes. We check that the previous turn mirrors this
int[] board = new int[]
{
14, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, -3, -2, -2,
-2, -2, 0, -2, -2, 1
};
fd.SetReturnValues(ar(1, 3));
bg = new BackgammonGame(board, fd);
bg.Move(White, 24, 21);
var turn = bg.GetPreviousTurn();
Assert.AreEqual(White, turn.color);
Assert.IsTrue(arrayEquals(ar(1, 3), turn.dice.ToArray()));
var moves = turn.moves;
Assert.AreEqual(1, moves.Count());
Assert.AreEqual("w 24 21", moves[0].DebugString());
}
public void TestThatIfWhiteCheckerIsCapturedAChangeShowsItIsMovedToTheBar()
{
int[] mainBoard = new int[] {
-2, 0, 0, 0, 0, 5,
0, 3, 0, 0, 0, -5,
5, 0, 0, 0, -3, 0,
-5, 0, 0, 1, 0, 1
};
fd.SetReturnValues(ar(1, 3));
bg = new BackgammonGame(mainBoard, fd, 0, 0, 0, 0, Black);
bg.Move(Black, 19, 22);
var changes = bg.GetChanges();
Assert.AreEqual(4, changes.Count());
var c1 = changes[0];
var c2 = changes[1];
var c3 = changes[2];
var c4 = changes[3];
Assert.IsTrue(c1.IsDiceState(), "c1 is not dice state");
Assert.IsTrue(c2.IsMove(), "c2 is not move");
Assert.IsTrue(c3.IsMove());
Assert.IsTrue(c4.IsDiceState(), "c3 is not dice state");
Assert.IsTrue(arrayEqual(ar(1, 3), c1.AsDiceState().GetDiceValues()), "Expected 1,3 but got " + string.Join(",", c1.AsDiceState().GetDiceValues()));
Assert.AreEqual("b 19 22", c2.AsMove().DebugString());
Assert.AreEqual("w 22 " + White.GetBar(), c3.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 1 }, c4.AsDiceState().GetDiceValues()));
}
private void Instantiate()
{
int[] InitialBoard = BackgammonGame.DefaultGameBoard; // Board.TestBoard3;
Board = new Board(InitialBoard);
Model = new BackgammonGame(InitialBoard, new RealDice());
ViewInterface = new ViewInterface(Model);
Model.ConnectView(this);
if (WhitePlayer == PlayerType.Online)
{
TCPManager.Instance.Instantiate(Model, White);
}
if (BlackPlayer == PlayerType.Online)
{
TCPManager.Instance.Instantiate(Model, Black);
}
if (OptionScreen.ShowPips.SwitchedOn)
{
WhitePips = new Image()
{
Text = "White: " + Model.GetGameBoardState().pip(White), Position = new Vector2(Board.midX, 700)
};
BlackPips = new Image()
{
Text = "Black: " + Model.GetGameBoardState().pip(Black), Position = new Vector2(Board.midX, 20)
};
WhitePips.LoadContent();
BlackPips.LoadContent();
}
}
public void TestIllegalMoveWhiteThrowsException()
{
fd.SetReturnValues(new int[] { 5, 1 });
bg = new BackgammonGame(initialGameBoard, fd);
bg.Move(WHITE, 6, 1);
}
internal void MakeMove(BackgammonGame model, CheckerColor color)
{
if (RemotePlayer == null)
{
Instantiate(model, color);
}
RemotePlayer.MakeMove();
}
public void TestChangesRegisteredProperlyAfterRolledTwoEqualDiceAndAllMovesConsumed()
{
List <int[]> moves = new List <int[]> {
ar(2, 2), ar(1, 5)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd);
bg.Move(White, 6, 4);
bg.Move(White, 6, 4);
bg.Move(White, 13, 11);
bg.Move(White, 24, 22);
var changes = bg.GetChanges();
Assert.AreEqual(9, changes.Count());
var c1 = changes[0];
var c2 = changes[1];
var c3 = changes[2];
var c4 = changes[3];
var c5 = changes[4];
var c6 = changes[5];
var c7 = changes[6];
var c8 = changes[7];
var c9 = changes[8];
Assert.IsTrue(c1.IsDiceState(), "c1 is not dice state");
Assert.IsTrue(c2.IsMove(), "c2 is not move");
Assert.IsTrue(c3.IsDiceState(), "c3 is not dice state");
Assert.IsTrue(c4.IsMove(), "c4 is not move");
Assert.IsTrue(c5.IsDiceState(), "c5 is not dice state");
Assert.IsTrue(c6.IsMove());
Assert.IsTrue(c7.IsDiceState());
Assert.IsTrue(c8.IsMove());
Assert.IsTrue(c9.IsDiceState());
Assert.IsTrue(arrayEqual(new int[] { 2, 2, 2, 2 }, c1.AsDiceState().GetDiceValues()), "Expected 1,3 but got " + string.Join(",", c1.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 6 4", c2.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 2, 2, 2 }, c3.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 6 4", c4.AsMove().DebugString());
Assert.IsTrue(arrayEqual(ar(2, 2), c5.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 13 11", c6.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 2 }, c7.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 24 22", c8.AsMove().DebugString());
Assert.IsTrue(arrayEqual(ar(1, 5), c9.AsDiceState().GetDiceValues()));
}
public void TestChangesRegisteredProperlyAfterBothWhiteAndBlackMoves()
{
List <int[]> moves = new List <int[]> {
ar(1, 3), ar(4, 5), ar(6, 3)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd);
bg.Move(White, 6, 3);
bg.Move(White, 6, 5);
bg.Move(Black, 19, 23);
bg.Move(Black, 17, 22);
var changes = bg.GetChanges();
Assert.AreEqual(9, changes.Count());
var c1 = changes[0];
var c2 = changes[1];
var c3 = changes[2];
var c4 = changes[3];
var c5 = changes[4];
var c6 = changes[5];
var c7 = changes[6];
var c8 = changes[7];
var c9 = changes[8];
Assert.IsTrue(c1.IsDiceState(), "c1 is not dice state");
Assert.IsTrue(c2.IsMove(), "c2 is not move");
Assert.IsTrue(c3.IsDiceState(), "c3 is not dice state");
Assert.IsTrue(c4.IsMove(), "c4 is not move");
Assert.IsTrue(c5.IsDiceState(), "c5 is not dice state");
Assert.IsTrue(c6.IsMove());
Assert.IsTrue(c7.IsDiceState());
Assert.IsTrue(c8.IsMove());
Assert.IsTrue(c9.IsDiceState());
Assert.IsTrue(arrayEqual(ar(1, 3), c1.AsDiceState().GetDiceValues()), "Expected 1,3 but got " + string.Join(",", c1.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 6 3", c2.AsMove().DebugString(), "Expected w 6 3, got " + c2.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 1 }, c3.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 6 5", c4.AsMove().DebugString());
Assert.IsTrue(arrayEqual(ar(4, 5), c5.AsDiceState().GetDiceValues()));
Assert.AreEqual("b 19 23", c6.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 5 }, c7.AsDiceState().GetDiceValues()));
Assert.AreEqual("b 17 22", c8.AsMove().DebugString());
Assert.IsTrue(arrayEqual(ar(6, 3), c9.AsDiceState().GetDiceValues()));
}
public void TestChangesRegisteredProperlyAfterNotifyViewFlushesChanges()
{
List <int[]> moves = new List <int[]>()
{
ar(1, 3), ar(4, 4)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd);
bg.Move(White, 6, 3);
var changes = bg.GetChanges();
Assert.AreEqual(3, changes.Count());
var c1 = changes[0];
var c2 = changes[1];
var c3 = changes[2];
Assert.IsTrue(c1.IsDiceState(), "c1 is not dice state");
Assert.IsTrue(c2.IsMove(), "c2 is not move");
Assert.IsTrue(c3.IsDiceState(), "c3 is not dice state");
Assert.IsTrue(arrayEqual(ar(1, 3), c1.AsDiceState().GetDiceValues()), "Expected 1,3 but got " + string.Join(",", c1.AsDiceState().GetDiceValues()));
Assert.AreEqual("w 6 3", c2.AsMove().DebugString(), "Expected w 6 3, got " + c2.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 1 }, c3.AsDiceState().GetDiceValues()));
//At least one view has to be present for backgammon game to flush the recent changes
View view = new DummyView();
bg.ConnectView(view);
bg.NotifyAllViews();
//Disconnecting the view again so that we may read the changes
bg.DisconnectView(view);
changes = bg.GetChanges();
Assert.AreEqual(0, changes.Count());
bg.Move(White, 6, 5);
changes = bg.GetChanges();
Assert.AreEqual(2, changes.Count());
var c4 = changes[0];
var c5 = changes[1];
Assert.IsTrue(c4.IsMove());
Assert.IsTrue(c5.IsDiceState());
Assert.AreEqual("w 6 5", c4.AsMove().DebugString());
Assert.IsTrue(arrayEqual(new int[] { 4, 4, 4, 4 }, c5.AsDiceState().GetDiceValues()));
}
public void initialize()
{
moves = new List <int[]>()
{
ar(1, 2), ar(4, 3), ar(1, 1), ar(1, 1), ar(6, 5), ar(3, 3)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd);
}
public void Initialize()
{
List <int[]> moves = new List <int[]>()
{
ar(1, 3), ar(5, 3), ar(6, 1), ar(1, 2)
};
fd = new FakeDice(moves);
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd);
}
public BackgammonVM(string playerA, string playerB)
{
PlayerA = playerA;
PlayerB = playerB;
PropertyChanged?.Invoke(null, new PropertyChangedEventArgs("PlayerA"));
PropertyChanged?.Invoke(null, new PropertyChangedEventArgs("PlayerB"));
InitDiceImageList();
IsWaitingForMove = false;
Game = new BackgammonGame();
Game.PropertyChanged += Game_PropertyChanged;
ChatResult.MoveRecievedEvent += ChatResult_MoveRecievedEvent;
}
public void TestMoveUpdatesCheckersOnPositionsBlack()
{
fd.SetReturnValues(new int[] { 2, 3 });
bg = new BackgammonGame(initialGameBoard, fd, 0, 0, 0, 0, BLACK);
bg.Move(BLACK, 19, 22);
int[] actualResult = bg.GetGameBoardState().getMainBoard();
int[] expectedResult = new int[] { -2, 0, 0, 0, 0, 5,
0, 3, 0, 0, 0, -5,
5, 0, 0, 0, -3, 0,
-4, 0, 0, -1, 0, 2 };
Assert.IsTrue(Enumerable.SequenceEqual(actualResult, expectedResult));
}
public void TestGetWhiteMovesFromBlackBarEmptyAndViceVersa()
{
bg = new BackgammonGame(initialGameBoard, fd);
fd.SetReturnValues(new int[] { 1, 2 });
HashSet <int> legalMovesWhite =
bg.GetLegalMovesFor(BLACK, BackgammonGame.WHITE_BAR_ID);
Assert.AreEqual(0, legalMovesWhite.Count());
HashSet <int> legalMovesBlack =
bg.GetLegalMovesFor(WHITE, BackgammonGame.BLACK_BAR_ID);
Assert.AreEqual(0, legalMovesBlack.Count());
}
public void TestChangesRegisteredProperlyWhenTurnChangesAndThereAreNoLegalMoves()
{
int[] board = new int[]
{
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, -15,
2, 2, 2, 2, 2, 5
};
fd.SetReturnValues(ar(1, 3));
bg = new BackgammonGame(board, fd);
bg.Move(White, 24, 23);
bg.Move(White, 24, 21);
}
private void Move(BackgammonGame model, CheckerColor c, Player ai)
{
if (ai == null)
{
if (naive)
{
ai = new NaiveAI(model, c);
}
else
{
ai = new MachAI(model);
}
}
ai.MakeMove();
}
public void TestGetLegalMovesForBlack()
{
fd.SetReturnValues(new int[] { 5, 3 });
bg = new BackgammonGame(initialGameBoard, fd);
//Get the legal moves for black's checkers on position 12
HashSet <int> ActualLegalMoves = bg.GetLegalMovesFor(BLACK, 12);
//with the initial board configuration and the dice showing 5 and 3,
//the legal positions to move to are {15, 17, 20}
HashSet <int> ExpectedLegalMoves = HashSetFromArray(new int[] { 15, 17, 20 });
Assert.IsTrue(ActualLegalMoves.SetEquals(ExpectedLegalMoves));
}
public void TestGetLegalMovesForWhite()
{
fd.SetReturnValues(new int[] { 2, 3 });
bg = new BackgammonGame(initialGameBoard, fd);
//Get the legal moves for whites checkers on position 13.
HashSet <int> ActualLegalMoves = bg.GetLegalMovesFor(WHITE, 13);
//with the initial board configuration and the dice showing 2 and 3,
//the legal positions to move to are {11, 10, 8}
HashSet <int> ExpectedLegalMoves = HashSetFromArray(new int[] { 8, 10, 11 });
Assert.IsTrue(ActualLegalMoves.SetEquals(ExpectedLegalMoves));
}
public void TestCannotBearOffCheckersWhenNotAllCheckersInHomeBoard()
{
bg = new BackgammonGame(initialGameBoard, fd);
fd.SetReturnValues(new int[] { 6, 1 });
//With this setup, the black checkers on position 19 and the white checkers on position 6 are able to
//reach their bear off position. However, all checkers are not in the homeboard, so it should not be available.
HashSet <int> legalBlackMoves = bg.GetLegalMovesFor(BLACK, 19);
Assert.IsFalse(legalBlackMoves.Contains(BackgammonGame.BLACK_BEAR_OFF_ID));
HashSet <int> legalWhiteMoves = bg.GetLegalMovesFor(WHITE, 6);
Assert.IsFalse(legalWhiteMoves.Contains(BackgammonGame.WHITE_BEAR_OFF_ID));
}
public void TestChangesContainsInitialMovesWhenGameStartesBlack()
{
fd.SetReturnValues(ar(1, 2));
bg = new BackgammonGame(BackgammonGame.DefaultGameBoard, fd, 0, 0, 0, 0, Black);
var changes = bg.GetChanges();
Assert.AreEqual(1, changes.Count());
Assert.IsTrue(changes[0].IsDiceState(), "expected true, got " + changes[0].IsDiceState());
var ds = changes[0].AsDiceState();
Assert.IsTrue(Enumerable.SequenceEqual(ds.GetDiceValues(), ar(1, 2)), "Expected {1,2}, was " + string.Join(",", ds.GetDiceValues()));
}
public void TestMoveConsistingOfMultipleMovesBlack()
{
fd.SetReturnValues(new int[] { 3, 1 });
bg = new BackgammonGame(initialGameBoard, fd, 0, 0, 0, 0, BLACK);
bg.Move(BLACK, 19, 23);
int[] expectedGameBoard = new int[] { -2, 0, 0, 0, 0, 5,
0, 3, 0, 0, 0, -5,
5, 0, 0, 0, -3, 0,
-4, 0, 0, 0, -1, 2 };
int[] actualGameBoard = bg.GetGameBoardState().getMainBoard();
Assert.IsTrue(Enumerable.SequenceEqual(expectedGameBoard, actualGameBoard));
}
