Exemplo n.º 1
0
        public async Task WhenLastMoveIsXThenExpectedY(Moves last, Moves expected)
        {
            var sut    = new TacticalComputerPlayer(last);
            var result = await sut.GetNextMove();

            result.Should().Be(expected);
        }
        public void WhenPreviousMoveIsNullRandomGameMoveGeneratorShouldBeCalledOnce()
        {
            // Arrange
            const GameMove expectedGameMove = GameMove.Paper;

            var randomMoveGeneratorMock = new Mock <IRandomMoveGenerator>();

            randomMoveGeneratorMock.Setup(m => m.GenerateRandomMove()).Returns(expectedGameMove);

            var tacticalMoveGeneratorMock = new Mock <ITacticalMoveGenerator>();

            tacticalMoveGeneratorMock.Setup(m => m.GenerateTacticalMove(It.IsAny <GameMove>())).Returns(GameMove.Rock);

            var tacticalComputerPlayer =
                new TacticalComputerPlayer(tacticalMoveGeneratorMock.Object, randomMoveGeneratorMock.Object)
            {
                PreviousMove = null
            };

            // Act
            tacticalComputerPlayer.GetComputerMove();

            // Assert
            randomMoveGeneratorMock.Verify(m => m.GenerateRandomMove(), Times.Once);
        }
Exemplo n.º 3
0
        public void TacticalComputerPlayer_Choses_Move_That_Beats_Last_Move()
        {
            var mockGameRules = new Mock <IGameRules>();

            mockGameRules.Setup(g => g.ValidOptions).Returns(() => new[] { "option1", "option2", "option3" });
            mockGameRules.Setup(g => g.WhatBeats("option1")).Returns(() => "option2");
            mockGameRules.Setup(g => g.WhatBeats("option2")).Returns(() => "option3");
            mockGameRules.Setup(g => g.WhatBeats("option3")).Returns(() => "option1");

            var computerPlayer = new TacticalComputerPlayer();
            var gameRules      = mockGameRules.Object;

            var firstMove = computerPlayer.MakeMove(gameRules);

            switch (firstMove.ChosenOption)
            {
            case "option1":
                Assert.Equal("option2", computerPlayer.MakeMove(gameRules).ChosenOption);
                break;

            case "option2":
                Assert.Equal("option3", computerPlayer.MakeMove(gameRules).ChosenOption);
                break;

            case "option3":
                Assert.Equal("option1", computerPlayer.MakeMove(gameRules).ChosenOption);
                break;

            default:
                Assert.True(false, "Uknown move made");
                break;
            }
        }
Exemplo n.º 4
0
        public void WhenDefaultFirstMoveIsNotUndefined()
        {
            var sut = new TacticalComputerPlayer();

            var result = sut.GetNextMove();

            result.Should().NotBe(Moves.Undefined);
        }
Exemplo n.º 5
0
        public void ShouldPlayARandomShapeIfItIsTheFirstRoundOfTheGame()
        {
            var player1 = new TacticalComputerPlayer(1);
            var player2 = new HumanPlayer(2);

            var game = GameState.NewGame(new RockPaperScissorsRules(), player1, player2);

            Assert.That(player1.MakeSelection(game),
                        Is.EqualTo(Shape.Rock).Or.EqualTo(Shape.Paper).Or.EqualTo(Shape.Scissors));
        }
Exemplo n.º 6
0
        public void MakeAMove_Should_ReturnRandomGesture_When_ItsAFirstMove()
        {
            var tacticalComputerPlayer = new TacticalComputerPlayer(
                new List <Gesture>
            {
                Gesture.Rock,
                Gesture.Paper,
                Gesture.Scissors
            },
                new FakeRandomNumberGenerator());

            Assert.AreEqual(Gesture.Rock, tacticalComputerPlayer.MakeAMove());
        }
Exemplo n.º 7
0
        public void MakeAMove_Should_UpdatePreviousGesture()
        {
            var tacticalComputerPlayer = new TacticalComputerPlayer(
                new List <Gesture>
            {
                Gesture.Rock,
                Gesture.Paper
            },
                new FakeRandomNumberGenerator());

            tacticalComputerPlayer.MakeAMove();
            tacticalComputerPlayer.MakeAMove();

            Assert.AreEqual(tacticalComputerPlayer.PreviousGesture, Gesture.Paper);
        }
Exemplo n.º 8
0
        public void ShouldPlayTheShapeThatWouldHaveBeatenItsLastChoiceIfItIsNotTheFirstRoundOfTheGame(
            Shape player1Shape, Shape player2Shape, int playerNumber, Shape expectedSelection)
        {
            var roundResults   = new List <RoundResult>();
            var computerPlayer = new TacticalComputerPlayer(playerNumber);
            var humanPlayer    = new HumanPlayer(playerNumber == 1 ? 2 : 1);
            var player1        = computerPlayer.Number == 1 ? (Player)computerPlayer : humanPlayer;
            var player2        = computerPlayer.Number == 2 ? (Player)computerPlayer : humanPlayer;

            var game = new GameState(new RockPaperScissorsRules().Rules,
                                     player1, player2, 2, 3,
                                     new List <RoundResult> {
                new RoundResult(1, player1Shape, player2Shape, null)
            });

            Assert.That(computerPlayer.MakeSelection(game), Is.EqualTo(expectedSelection));
        }
        public void WhenPreviousMoveIsNullTacticalGameMoveGeneratorShouldNeverBeCalled()
        {
            // Arrange
            var randomMoveGeneratorMock   = new Mock <IRandomMoveGenerator>();
            var tacticalMoveGeneratorMock = new Mock <ITacticalMoveGenerator>();

            var tacticalComputerPlayer =
                new TacticalComputerPlayer(tacticalMoveGeneratorMock.Object, randomMoveGeneratorMock.Object)
            {
                PreviousMove = null
            };

            // Act
            tacticalComputerPlayer.GetComputerMove();

            // Assert
            tacticalMoveGeneratorMock.Verify(m => m.GenerateTacticalMove(It.IsAny <GameMove>()), Times.Never);
        }
Exemplo n.º 10
0
        public void FirstMoveIsARandomMove()
        {
            var rockCount      = 0;
            var scisssorsCount = 0;
            var paperCount     = 0;

            IPlayer player;

            for (int i = 0; i < 100; i++)
            {
                player = new TacticalComputerPlayer();

                player.GetPlayerMove();
                var lastMove = player.GetPlayerMove();

                switch (lastMove)
                {
                case Move.Rock:
                    rockCount++;
                    break;

                case Move.Paper:
                    paperCount++;
                    break;

                case Move.Scissors:
                    scisssorsCount++;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Should only be rock, paper or scissors");
                }

                //within the tacticalcomputer player constructor is a random number generator with a time dependant seed.
                //Adding the millisecond between calling the constructor means the seed is different for each instances of player
                Thread.Sleep(1);
            }

            Assert.True(rockCount > 20);
            Assert.True(paperCount > 20);
            Assert.True(scisssorsCount > 20);
        }
        public void WhenPreviousMoveIsNotNullRandomGameMoveGeneratorShouldNeverBeCalled()
        {
            // Arrange
            const GameMove previousMove = GameMove.Rock;

            var randomMoveGeneratorMock   = new Mock <IRandomMoveGenerator>();
            var tacticalMoveGeneratorMock = new Mock <ITacticalMoveGenerator>();

            var tacticalComputerPlayer =
                new TacticalComputerPlayer(tacticalMoveGeneratorMock.Object, randomMoveGeneratorMock.Object)
            {
                PreviousMove = previousMove
            };

            // Act
            tacticalComputerPlayer.GetComputerMove();

            // Assert
            randomMoveGeneratorMock.Verify(m => m.GenerateRandomMove(), Times.Never);
        }
        public void WhenPreviousMoveIsNotNullTacticalGameMoveGeneratorShouldBeCalledOnceWithTheCorrectPreviousMove()
        {
            // Arrange
            const GameMove previousMove = GameMove.Rock;

            var randomMoveGeneratorMock   = new Mock <IRandomMoveGenerator>();
            var tacticalMoveGeneratorMock = new Mock <ITacticalMoveGenerator>();

            var tacticalComputerPlayer =
                new TacticalComputerPlayer(tacticalMoveGeneratorMock.Object, randomMoveGeneratorMock.Object)
            {
                PreviousMove = previousMove
            };

            // Act
            tacticalComputerPlayer.GetComputerMove();

            // Assert
            tacticalMoveGeneratorMock.Verify(m => m.GenerateTacticalMove(It.Is <GameMove>(x => x == previousMove)), Times.Once);
        }
Exemplo n.º 13
0
        public void PlaysSecondAndThirdMovesTactically()
        {
            //plays the move that would have defeated it's last move

            IPlayer player = new TacticalComputerPlayer();

            //get tatical player with it's first move as scissors, otherwise discard it
            while (player.LastMove != Move.Scissors)
            {
                player.GetPlayerMove();
            }



            //scissors are defeated by rock
            Assert.AreEqual(Move.Rock, player.GetPlayerMove());

            //rock is defeated by paper
            Assert.AreEqual(Move.Paper, player.GetPlayerMove());
        }
Exemplo n.º 14
0
        static bool TryCreatePlayer(string type, int number, out Player player)
        {
            switch (type)
            {
            case "H":
                player = new HumanPlayer(number);
                break;

            case "R":
                player = new RandomComputerPlayer(number);
                break;

            case "T":
                player = new TacticalComputerPlayer(number);
                break;

            default:
                player = null;
                break;
            }

            return(player != null);
        }