Esempio n. 1
0
        public void CountOneMoveTest()
        {
            CandidateMovesAll allMoves = new CandidateMovesAll();
            HexBoard testBoard = new HexBoard(BoardSize);

            testBoard.PlayMove(5, 5, true);

            IEnumerable<Location> moves = allMoves.CandidateMoves(testBoard, 0);

            Assert.AreEqual(BoardCellCount - 1, moves.Count());
        }
Esempio n. 2
0
        public void BoardCopyTest()
        {
            HexBoard hexBoard = new HexBoard(BoardSize);
            HexBoard copyBoard = new HexBoard(hexBoard);

            Assert.IsTrue(copyBoard.Equals(hexBoard));

            copyBoard.PlayMove(0, 0, true);

            Assert.IsFalse(copyBoard.Equals(hexBoard));
        }
        public void CountOneMoveTest()
        {
            GoodMoves goods = new GoodMoves();
            CandidateMovesSelective moveFinder = new CandidateMovesSelective(goods, 0);
            HexBoard testBoard = new HexBoard(BoardSize);

            testBoard.PlayMove(5, 5, true);

            IEnumerable<Location> moves = moveFinder.CandidateMoves(testBoard, 0);

            Assert.Greater(BoardCellCount - 1, moves.Count());
        }
Esempio n. 4
0
        public void ClearTest()
        {
            HexBoard hexBoard = new HexBoard(BoardSize);

            // set a cell
            hexBoard.PlayMove(1, 1, true);
            Assert.AreEqual(Occupied.PlayerX, hexBoard.GetCellOccupiedAt(1, 1));

            Location loc11 = new Location(1, 1);
            Assert.AreEqual(Occupied.PlayerX, hexBoard.GetCellOccupiedAt(1, 1));
            Assert.AreEqual(Occupied.PlayerX, hexBoard.GetCellOccupiedAt(loc11));

            // reset it
            hexBoard.Clear();
            Assert.AreEqual(Occupied.Empty, hexBoard.GetCellOccupiedAt(1, 1));
            Assert.AreEqual(Occupied.Empty, hexBoard.GetCellOccupiedAt(loc11));
        }
Esempio n. 5
0
        public void CountDownTest()
        {
            CandidateMovesAll allMoves = new CandidateMovesAll();
            HexBoard testBoard = new HexBoard(BoardSize);

            int emptyCellCount = BoardSize * BoardSize;

            for (int x = 0; x < BoardSize; x++)
            {
                for (int y = 0; y < BoardSize; y++)
                {
                    // as cells are played, less empty cells are left
                    testBoard.PlayMove(x, y, true);
                    emptyCellCount--;

                    IEnumerable<Location> moves = allMoves.CandidateMoves(testBoard, 0);
                    Assert.AreEqual(emptyCellCount, moves.Count());
                }
            }
        }
Esempio n. 6
0
        private static void PlayerScoreAlmostBarricaded(IPathLengthFactory pathLengthFactory)
        {
            HexBoard hexBoard = new HexBoard(BoardSize);
            PathLengthBase pathLength = pathLengthFactory.CreatePathLength(hexBoard);

            // almost barricated board
            for (int y = 0; y < hexBoard.Size; y++)
            {
                if (y != 3)
                {
                    hexBoard.PlayMove(2, y, true);
                }
            }

            int xScore = pathLength.PlayerScore(true);
            Assert.IsTrue(xScore > 0);

            int yScore = pathLength.PlayerScore(false);
            Assert.IsTrue(yScore > xScore);

            // strong advantage to player 1
            int advantageMoveScore = pathLength.SituationScore();
            Assert.IsTrue(advantageMoveScore > 0);
        }
Esempio n. 7
0
        private static HexBoard RandomBoard(int size, int moves, Random rands)
        {
            HexBoard result = new HexBoard(size);

            for (int loopCount = 0; loopCount < moves; loopCount++)
            {
                int x = rands.Next(size);
                int y = rands.Next(size);

                if (result.GetCellOccupiedAt(x, y) == Occupied.Empty)
                {
                    result.PlayMove(x, y, (loopCount % 2 == 0));
                }
            }

            return result;
        }
Esempio n. 8
0
 private static void PlayFourMoves(HexBoard board)
 {
     board.PlayMove(2, 0, true); // playerX
     board.PlayMove(0, 2, false); // PlayerY
     board.PlayMove(2, 4, true); // playerX
     board.PlayMove(4, 2, false); // PlayerY
 }
Esempio n. 9
0
 private static void PlayTwoMoves(HexBoard playBoard)
 {
     // best move (and winning move ) is the middle (1,1) or corner (0, 2)
     // but it takes lookahead or 3 or more to see that
     // Should be quick to calc since there's only 9 cells
     // Search tree is not broad, we can go deep
     playBoard.PlayMove(1, 0, true); // PlayerX
     playBoard.PlayMove(2, 1, false); // PlayerY
 }
Esempio n. 10
0
        private static void PlayFourMoves(HexBoard playBoard)
        {
            // set up so the best move should be that the middle - a winning move for either player
            // can see this just looking at one move
            playBoard.PlayMove(1, 0, true); // PlayerX
            playBoard.PlayMove(2, 1, false); // PlayerY

            playBoard.PlayMove(0, 1, false); // PlayerX
            playBoard.PlayMove(1, 2, true); // PlayerY
        }
Esempio n. 11
0
        public void TestCalculateMove4()
        {
            HexBoard board = new HexBoard(3);

            board.PlayMove(0, 0, true); // playerX
            board.PlayMove(0, 1, false); // PlayerY
            board.PlayMove(0, 2, true); // playerX

            board.PlayMove(1, 0, false); // PlayerY
            board.PlayMove(1, 1, true); // PlayerX
            board.PlayMove(1, 2, false); // playerY

            Minimax minimax = MakeMinimaxForBoard(board);

            // test score at this point
            PathLengthLoop pathLength = new PathLengthLoop(board);
            int playerScore = pathLength.PlayerScore(true);
            Assert.AreEqual(1, playerScore);

            playerScore = pathLength.PlayerScore(false);
            Assert.AreEqual(1, playerScore);

            // only 3 cells are vacant
            minimax.DoMinimax(1, false);
            minimax.DoMinimax(1, true);

            minimax.DoMinimax(2, false);
            minimax.DoMinimax(2, true);

            minimax.DoMinimax(3, false);
            minimax.DoMinimax(3, true);

            minimax.DoMinimax(4, false);
            minimax.DoMinimax(4, true);

            minimax.DoMinimax(5, false);
            minimax.DoMinimax(5, true);
        }
Esempio n. 12
0
        public void DuplicatePlayTest()
        {
            HexBoard hexBoard = new HexBoard(BoardSize);

            // set a cell
            hexBoard.PlayMove(1, 1, true);
            hexBoard.PlayMove(1, 1, true);
        }
Esempio n. 13
0
        private static void PlayToWinInThreeMoves(HexBoard board)
        {
            // win in 3 moves
            board.PlayMove(2, 0, true); // playerX
            board.PlayMove(2, 1, true); // playerX
            board.PlayMove(2, 4, true); // playerX
            board.PlayMove(2, 5, true); // playerX

            board.PlayMove(0, 2, false); // playery
            board.PlayMove(3, 2, false); // playery
            board.PlayMove(4, 2, false); // playery
            board.PlayMove(5, 2, false); // playery
        }
Esempio n. 14
0
 public void MovesPlayedCountIncrementsAfterMove()
 {
     HexBoard hexBoard = new HexBoard(BoardSize);
     Assert.AreEqual(0, hexBoard.MovesPlayedCount);
     hexBoard.PlayMove(1, 1, true);
     Assert.AreEqual(1, hexBoard.MovesPlayedCount);
 }
Esempio n. 15
0
        public void ToStringTest()
        {
            HexBoard board = new HexBoard(4);
            board.PlayMove(1, 1, true);

            string out1 = board.ToString();
            Assert.IsFalse(String.IsNullOrEmpty(out1));

            board.PlayMove(2, 2, false);

            string out2 = board.ToString();
            Assert.IsFalse(String.IsNullOrEmpty(out2));

            Assert.AreNotEqual(out1, out2);
        }
Esempio n. 16
0
        public void MoveSetsCellOccupied()
        {
            HexBoard hexBoard = new HexBoard(BoardSize);
            Assert.AreEqual(Occupied.Empty, hexBoard.GetCellOccupiedAt(1, 1));

            hexBoard.PlayMove(1, 1, true);
            Assert.AreEqual(Occupied.PlayerX, hexBoard.GetCellAt(1, 1).IsOccupied);
            Assert.AreEqual(Occupied.PlayerX, hexBoard.GetCellOccupiedAt(1, 1));
        }
Esempio n. 17
0
        public void GetCellsTest()
        {
            HexBoard hexBoard = new HexBoard(BoardSize);

            Cell[,] cells = hexBoard.GetCells();
            Assert.AreEqual(cells[1, 1].IsOccupied, Occupied.Empty);
            Assert.AreEqual(cells[2, 2].IsOccupied, Occupied.Empty);
            Assert.AreEqual(cells[3, 3].IsOccupied, Occupied.Empty);

            hexBoard.PlayMove(1, 1, true);

            Assert.AreEqual(cells[1, 1].IsOccupied, Occupied.PlayerX);
            Assert.AreEqual(cells[2, 2].IsOccupied, Occupied.Empty);
            Assert.AreEqual(cells[3, 3].IsOccupied, Occupied.Empty);

            hexBoard.PlayMove(2, 2, false);

            Assert.AreEqual(cells[1, 1].IsOccupied, Occupied.PlayerX);
            Assert.AreEqual(cells[2, 2].IsOccupied, Occupied.PlayerY);
            Assert.AreEqual(cells[3, 3].IsOccupied, Occupied.Empty);
        }
Esempio n. 18
0
        public void EmptyCellsTest()
        {
            const int SmallBoardSize = 4;
            const int BoardCellCount = SmallBoardSize * SmallBoardSize;
            HexBoard source = new HexBoard(SmallBoardSize);

            Location[] emptyCells1 = source.EmptyCells().ToArray();

            Assert.IsNotNull(emptyCells1);
            Assert.AreEqual(BoardCellCount, emptyCells1.Length);

            source.PlayMove(2, 2, false);
            Location[] emptyCells2 = source.EmptyCells().ToArray();

            Assert.IsNotNull(emptyCells2);
            Assert.AreEqual(BoardCellCount - 1, emptyCells2.Length);
        }
Esempio n. 19
0
        public void TestNoLingering2()
        {
            // prefer a quick win to a slow one
            HexBoard board = new HexBoard(5);
            Minimax minimax = MakeMinimaxForBoard(board);

            // diagonal  - one move to win
            board.PlayMove(4, 0, true); // playerX
            board.PlayMove(3, 1, true); // playerX
            // this.board.PlayMove(2, 2, true); // playerX
            board.PlayMove(1, 3, true); // playerX
            board.PlayMove(0, 4, true); // playerX

            for (int depth = 1; depth < 6; depth++)
            {
                DoTestTestNoLingering2Win(minimax, depth);
            }
        }
Esempio n. 20
0
        public void TestMinimax4()
        {
            HexBoard board = new HexBoard(5);
            Minimax minimax = MakeMinimaxForBoard(board);

            /*
                on a 5 * 5 board, red(playerx) has 3, 0 and 1, 4  and 2,2
                    PlayerX has won, even if PlayerY goes next
                     should know this at look ahead 5
             */

            board.PlayMove(3, 0, true);
            board.PlayMove(1, 4, true);
            board.PlayMove(2, 2, true);

            MinimaxResult bestMove = minimax.DoMinimax(4, false);

            AssertWinner(bestMove.Score, Occupied.PlayerX);
        }
Esempio n. 21
0
 private static void PlayToWinInOneMove(HexBoard board, bool playerX)
 {
     // one move at 0,4 to win
     board.PlayMove(4, 0, playerX);
     board.PlayMove(3, 1, playerX);
     board.PlayMove(2, 2, playerX);
     board.PlayMove(1, 3, playerX);
 }
Esempio n. 22
0
        public void TestMinimax3()
        {
            HexBoard board = new HexBoard(5);
            Minimax minimax = MakeMinimaxForBoard(board);

            /*
                on a 5 * 5 board, red(playerx) has 3, 0 and 1, 4
                needs to play 2,2 to win - should know this at look ahead 5
             */

            board.PlayMove(3, 0, true);
            board.PlayMove(1, 4, true);

            MinimaxResult bestMove = minimax.DoMinimax(5, true);
            Location expectedMove = new Location(2, 2);

            Assert.IsTrue(MoveScoreConverter.IsWin(bestMove.Score), "No win " + bestMove.Score);
            Assert.AreEqual(expectedMove, bestMove.Move, "Wrong expected move");
        }
Esempio n. 23
0
        private static void PlayerScoreZigZag(IPathLengthFactory pathLengthFactory)
        {
            HexBoard hexBoard = new HexBoard(BoardSize);
            PathLengthBase pathLength = pathLengthFactory.CreatePathLength(hexBoard);

            for (int y = 0; y < hexBoard.Size - 1; y++)
            {
                hexBoard.PlayMove(2, y, true);
                hexBoard.PlayMove(5, hexBoard.Size - (1 + y), true);

                int xScore = pathLength.PlayerScore(true);
                Assert.IsTrue(xScore > 0);

                int yScore = pathLength.PlayerScore(false);
                Assert.IsTrue(yScore >= hexBoard.Size);
                if (y > (hexBoard.Size / 2))
                {
                    Assert.IsTrue(yScore > xScore);
                }

                // some advantage to player 1
                int advantageMoveScore = pathLength.SituationScore();
                Assert.IsTrue(advantageMoveScore >= y);
            }
        }
Esempio n. 24
0
        public void TestCalculateMove2SituationScoreMiddle()
        {
            HexBoard board = new HexBoard(3);
            PlayTwoMoves(board);

            // playing middle gets adavantage
            board.PlayMove(1, 1, true);

            PathLengthLoop pathLength = new PathLengthLoop(board);
            int moveScore = pathLength.SituationScore();
            Assert.AreEqual(1, moveScore);

            board.GetCellAt(1, 1).IsOccupied = Occupied.PlayerY;
            moveScore = pathLength.SituationScore();
            Assert.AreEqual(-1, moveScore);

            board.GetCellAt(1, 1).IsOccupied = Occupied.Empty;
        }
Esempio n. 25
0
        private static void PlayerScoreBaricaded(IPathLengthFactory pathLengthFactory)
        {
            HexBoard hexBoard = new HexBoard(BoardSize);
            PathLengthBase pathLength = pathLengthFactory.CreatePathLength(hexBoard);

            // baricaded board
            for (int y = 0; y < hexBoard.Size; y++)
            {
                hexBoard.PlayMove(2, y, true);
            }

            int xScore = pathLength.PlayerScore(true);
            Assert.AreEqual(xScore, 0);

            int yScore = pathLength.PlayerScore(false);
            Assert.IsTrue(yScore > hexBoard.Size);

            // winning advantage to player 1
            int winMoveScore = pathLength.SituationScore();
            AssertWinner(winMoveScore, Occupied.PlayerX);
        }
Esempio n. 26
0
        public void TestGetEmptyNeighbours2()
        {
            HexBoard hexBoard = new HexBoard(BoardSize);

            // get the neighbours2 with nothing inbetween
            Cell focus = hexBoard.GetCellAt(3, 3);
            Cell[][] neighbours2EmptyBoard = hexBoard.EmptyNeighbours2(focus);

            // should be six sets
            Assert.AreEqual(6, neighbours2EmptyBoard.Length);

            // playing an ajoining cell removes 2 sets
            hexBoard.PlayMove(3, 4, false);
            Cell[][] neighbours2PlayedCell = hexBoard.EmptyNeighbours2(focus);

            Assert.AreEqual(4, neighbours2PlayedCell.Length);
        }