Exemple #1
0
 public void BoardFunctionalTest()
 {
     BoardField[,] fields = BoardTest.CreateTestMap().Board;
     Assert.IsTrue(fields.Length == 12);
     Assert.IsTrue(fields[0, 0].Neighbours[Direction.Up] == null);
     Assert.IsTrue(fields[0, 0].Neighbours[Direction.Down] == fields[0, 1]);
 }
Exemple #2
0
        public void KillByEatingTailTest()
        {
            //set up
            BoardField[,] fields = this.testBoard;

            var killed           = new PlayerModel(new Color(), fields[0, 2]);
            var killer           = new PlayerModel(new Color(), fields[1, 2]);
            var killedController = new PlayerController(killed, fields[0, 2], 0, 0);
            var killerController = new PlayerController(killer, fields[1, 2], 0, 0);

            killedController.ChangeNextDirection(Direction.Up);
            killerController.ChangeNextDirection(Direction.Left);

            Assert.IsTrue(killer.Stats.Kills == 0);
            Assert.IsTrue(killer.Stats.Deaths == 0);

            //test
            killedController.Update();
            killerController.Update();

            Assert.IsTrue(killer.Stats.Kills == 1);
            Assert.IsTrue(killed.Stats.Deaths == 1);
            Assert.IsInstanceOfType(killedController.MovingState, typeof(WaitingForRespawnState));

            //tear down
            BoardTest.ClearTestBoard(fields);
        }
Exemple #3
0
        public void ReturnTest()
        {
            //set up
            BoardField[,] fields = this.testBoard;
            var tailFields = new BoardField[]
            {
                fields[0, 1],
                fields[0, 0],
                fields[1, 0],
                fields[2, 0],
                fields[2, 1],
                fields[2, 2],
            };
            var expectedClaimedFields = new BoardField[] {
                fields[0, 2],
                fields[0, 1],
                fields[0, 0],
                fields[1, 2],
                fields[1, 1],
                fields[1, 0],
                fields[2, 2],
                fields[2, 1],
                fields[2, 0]
            };
            var expectedNotClaimedFields = new BoardField[] {
                fields[3, 2],
                fields[3, 1],
                fields[3, 0]
            };

            var player     = new PlayerModel(new Color(), fields[0, 2]);
            var controller = new PlayerController(player, fields[0, 2], 0, 0);

            controller.ChangeNextDirection(Direction.Right);
            //player.State = new AttackingState(player);

            fields[1, 2].Owner = player;
            player.Tail.Positions.AddRange(tailFields);

            //test
            controller.Update();
            controller.Update();

            foreach (BoardField field in expectedClaimedFields)
            {
                Assert.IsTrue(field.Owner == player);
            }

            foreach (BoardField field in expectedNotClaimedFields)
            {
                Assert.IsTrue(field.Owner == MissingPlayer.Instance);
            }

            //tear down
            BoardTest.ClearTestBoard(fields);
        }
Exemple #4
0
        public void UpdateTest()
        {
            PlayerModel player     = PlayerControllerMock.GetPlayerModel();
            GameBoard   board      = BoardTest.CreateTestMap();
            var         scoreboard = new Scoreboard(new System.Collections.Generic.List <PlayerModel>()
            {
                player
            }, board);

            board.Board[0, 0].Owner = player;

            scoreboard.Update(null, null);

            Assert.IsTrue(player.Stats.Territory == 1);
        }
Exemple #5
0
        public void UpdatePlayersTerritoryTest()
        {
            var board  = this.gameBoard;
            var player = new PlayerModel(new Color(), board.Board[0, 0]);

            board.Board[0, 0].Owner = player;
            board.Board[0, 1].Owner = player;
            board.Board[1, 0].Owner = player;

            board.UpdatePlayersTerritory(new PlayerModel[] { player });

            Assert.IsTrue(player.Stats.Territory == 3);

            BoardTest.ClearTestBoard(board.Board);
        }
        public void AddTerritoryTest()
        {
            //set up
            BoardField[,] fields = BoardTest.CreateTestMap().Board;
            var tailFields = new BoardField[]
            {
                fields[0, 2],
                fields[0, 1],
                fields[0, 0],
                fields[1, 0],
                fields[2, 0],
                fields[2, 1],
                fields[2, 2],
            };
            var expectedClaimedFields = new BoardField[] {
                fields[0, 2],
                fields[0, 1],
                fields[0, 0],
                fields[1, 2],
                fields[1, 1],
                fields[1, 0],
                fields[2, 2],
                fields[2, 1],
                fields[2, 0]
            };
            var expectedNotClaimedFields = new BoardField[] {
                fields[3, 2],
                fields[3, 1],
                fields[3, 0]
            };

            var player = new PlayerModel(new Color(), fields[1, 2]);

            fields[1, 2].Owner = player;
            player.Tail.Positions.AddRange(tailFields);
            //test
            PlayerServices.AddTerritory(player);

            foreach (BoardField field in expectedClaimedFields)
            {
                Assert.IsTrue(field.Owner == player);
            }

            foreach (BoardField field in expectedNotClaimedFields)
            {
                Assert.IsTrue(field.Owner == MissingPlayer.Instance);
            }
        }
Exemple #7
0
        public void ClaimStartingTerritoriesTest()
        {
            var board  = this.gameBoard;
            var player = new PlayerModel(new Color(), board.Board[0, 0]);

            board.ClaimStartingTerritories(new PlayerModel[] { player });

            Assert.IsTrue(board.Board[0, 0].Owner == player);
            Assert.IsTrue(board.Board[0, 1].Owner == player);
            Assert.IsTrue(board.Board[1, 0].Owner == player);
            Assert.IsTrue(board.Board[1, 1].Owner == MissingPlayer.Instance);
            Assert.IsTrue(board.Board[2, 0].Owner == MissingPlayer.Instance);
            Assert.IsTrue(board.Board[0, 2].Owner == MissingPlayer.Instance);

            BoardTest.ClearTestBoard(board.Board);
        }