public void WillHaveTheAiMakeAMoveIfGameIsNotOver()
{
Mock <NodeService> mockNodeService = new Mock <NodeService>();
mockNodeService.Setup(x => x.process(It.IsAny <BoardGame>(), It.IsAny <PlayerColour>()))
.Returns(new List <INode>());
service = new GameService(mockNodeService.Object, new Mock <IDatabaseProvider>().Object);
Mock <BoardGame> mockCloned = new Mock <BoardGame>();
Mock <BoardGame> mockGame = new Mock <BoardGame>(MockBehavior.Loose);
mockGame.Setup(x => x.Clone())
.Returns(mockCloned.Object);
Mock <Player> p = new Mock <Player>();
p.Setup(x => x.makeMove(mockCloned.Object, It.IsAny <List <INode> >(), 0))
.Returns(new Mock <INode>().Object)
.Verifiable();
mockGame.Setup(x => x.getWinner())
.Throws(new NoWinnerException());
mockGame.SetupSequence(x => x.getWinner())
.Throws(new NoWinnerException());
Mock <Player> next = new Mock <Player>();
next.Setup(x => x.getName()).Returns("");
next.Setup(x => x.getColour()).Returns(PlayerColour.RED);
List <Player> players = new List <Player>
{
next.Object
};
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> >());
BoardGameDTO result = service.processMove(mockGame.Object, p.Object, players);
p.Verify();
}
public void WillPopulateThePlayersArrayWithJObjectRepresentationsOfThePlayers()
{
Mock <NodeService> mockNodeService = new Mock <NodeService>();
mockNodeService.Setup(x => x.process(It.IsAny <BoardGame>(), It.IsAny <PlayerColour>()))
.Returns(new List <INode>());
service = new GameService(mockNodeService.Object, new Mock <IDatabaseProvider>().Object);
Mock <BoardGame> mockGame = new Mock <BoardGame>(MockBehavior.Loose);
Mock <Player> p = new Mock <Player>();
p.Setup(x => x.makeMove(mockGame.Object, It.IsAny <List <INode> >(), 0))
.Returns(new Mock <INode>().Object);
p.Setup(x => x.getPlayerType()).Returns(PlayerType.RANDOM);
p.Setup(x => x.getName()).Returns("name");
Mock <Player> next = new Mock <Player>();
next.Setup(x => x.getName()).Returns("name");
next.Setup(x => x.getPlayerType()).Returns(PlayerType.RANDOM);
next.Setup(x => x.getColour()).Returns(PlayerColour.RED);
mockGame.Setup(x => x.getWinner()).Throws(new NoWinnerException());
mockGame.SetupSequence(x => x.getWinner()).Throws(new NoWinnerException()).Returns(0);
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> >());
mockGame.Setup(x => x.Clone()).Returns(mockGame.Object);
BoardGameDTO result = service.processMove(mockGame.Object, p.Object, new List <Player>
{
p.Object, next.Object
});
Assert.IsTrue(result.players.Count == 2);
}
public void WillReturnTheAisTheWinnerIfItsMoveWinsTheGame()
{
Mock <NodeService> mockNodeService = new Mock <NodeService>();
mockNodeService.Setup(x => x.process(It.IsAny <BoardGame>(), It.IsAny <PlayerColour>()))
.Returns(new List <INode>());
service = new GameService(mockNodeService.Object, new Mock <IDatabaseProvider>().Object);
Mock <BoardGame> mockGame = new Mock <BoardGame>(MockBehavior.Loose);
Mock <Player> p = new Mock <Player>();
p.Setup(x => x.makeMove(mockGame.Object, It.IsAny <List <INode> >(), 0))
.Returns(new Mock <INode>().Object);
mockGame.Setup(x => x.Clone()).Returns(mockGame.Object);
mockGame.SetupSequence(x => x.isWon()).Returns(false).Returns(true);
mockGame.Setup(x => x.getWinner()).Returns(0);
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> >());
Mock <Player> next = new Mock <Player>();
next.Setup(x => x.getName()).Returns("");
next.Setup(x => x.getColour()).Returns(PlayerColour.RED);
List <Player> players = new List <Player>
{
next.Object, next.Object
};
BoardGameDTO result = service.processMove(mockGame.Object, p.Object, players);
Assert.IsTrue(result.Winner == 0);
}
public void WillPassThePlayersArrayToTheGameService()
{
BoardGameDTO dto = new BoardGameDTO();
Mock <Player> mockPlayer = new Mock <Player>();
dto.players = new List <JObject>
{
new JObject()
};
List <Player> players = new List <Player>
{
mockPlayer.Object, mockPlayer.Object
};
Mock <IGameService> gameService = new Mock <IGameService>();
Mock <BoardCreationService> boardCreationService = new Mock <BoardCreationService>();
Mock <IPlayerCreationService> playerCreationService = new Mock <IPlayerCreationService>();
playerCreationService.Setup(x => x.createPlayers(dto.players))
.Returns(players);
gameService.Setup(x => x.processMove(It.IsAny <BoardGame>(), It.IsAny <Player>(), players))
.Returns((BoardGameDTO)null)
.Verifiable();
cont = new GameController(gameService.Object, boardCreationService.Object, playerCreationService.Object);
cont.makeMove(dto);
gameService.Verify();
}
public void WillAddTheNameOfTheNewCurPlayer()
{
Mock <NodeService> mockNodeService = new Mock <NodeService>();
mockNodeService.Setup(x => x.process(It.IsAny <BoardGame>(), It.IsAny <PlayerColour>()))
.Returns(new List <INode>());
service = new GameService(mockNodeService.Object, new Mock <IDatabaseProvider>().Object);
Mock <BoardGame> mockGame = new Mock <BoardGame>(MockBehavior.Loose);
Mock <Player> p = new Mock <Player>();
p.Setup(x => x.makeMove(mockGame.Object, It.IsAny <List <INode> >(), 0))
.Returns(new Mock <INode>().Object);
p.Setup(x => x.getPlayerType()).Returns(PlayerType.RANDOM);
p.Setup(x => x.getName()).Returns("name");
p.Setup(x => x.getColour()).Returns(PlayerColour.BLUE);
Mock <Player> next = new Mock <Player>();
next.Setup(x => x.getName()).Returns("name");
next.Setup(x => x.getPlayerType()).Returns((PlayerType)1000);
next.Setup(x => x.getColour()).Returns(PlayerColour.RED);
mockGame.Setup(x => x.getWinner()).Throws(new NoWinnerException());
mockGame.SetupSequence(x => x.getWinner()).Throws(new NoWinnerException()).Returns(0);
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> >());
mockGame.Setup(x => x.Clone()).Returns(mockGame.Object);
BoardGameDTO result = service.processMove(mockGame.Object, p.Object, new List <Player>
{
p.Object, next.Object
});
Assert.IsTrue(result.cur["name"].ToObject <string>() == "name");
}
public void WillAddTilesAlongWidth()
{
Mock <NodeService> mockNodeService = new Mock <NodeService>();
mockNodeService.Setup(x => x.process(It.IsAny <BoardGame>(), It.IsAny <PlayerColour>()))
.Returns(new List <INode>());
service = new GameService(mockNodeService.Object, new Mock <IDatabaseProvider>().Object);
Mock <BoardGame> mockGame = new Mock <BoardGame>(MockBehavior.Loose);
Mock <Player> p = new Mock <Player>();
mockGame.Setup(x => x.getWinner()).Throws(new NoWinnerException());
p.Setup(x => x.makeMove(mockGame.Object, It.IsAny <List <INode> >(), 0))
.Returns(new Mock <INode>().Object);
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> > {
new List <BoardGame>
{
new Tile(), new Tile()
}
});
mockGame.Setup(x => x.Clone()).Returns(mockGame.Object);
Mock <Player> next = new Mock <Player>();
next.Setup(x => x.getName()).Returns("");
next.Setup(x => x.getColour()).Returns(PlayerColour.RED);
List <Player> players = new List <Player>
{
next.Object
};
BoardGameDTO result = service.processMove(mockGame.Object, p.Object, players);
Assert.IsTrue(result.game[0].Count is 2);
}
public void WillAddOneTileWithPropertiesPopulated()
{
Mock <NodeService> mockNodeService = new Mock <NodeService>();
mockNodeService.Setup(x => x.process(It.IsAny <BoardGame>(), It.IsAny <PlayerColour>()))
.Returns(new List <INode>());
service = new GameService(mockNodeService.Object, new Mock <IDatabaseProvider>().Object);
Mock <BoardGame> mockGame = new Mock <BoardGame>(MockBehavior.Loose);
Mock <Player> p = new Mock <Player>();
mockGame.Setup(x => x.getWinner()).Throws(new NoWinnerException());
mockGame.Setup(x => x.Clone()).Returns(mockGame.Object);
p.Setup(x => x.makeMove(mockGame.Object, It.IsAny <List <INode> >(), 0))
.Returns(new Mock <INode>().Object);
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> > {
new List <BoardGame>
{
new Tile
{
owner = 0
}
}
});
Mock <Player> next = new Mock <Player>();
next.Setup(x => x.getName()).Returns("");
next.Setup(x => x.getColour()).Returns(PlayerColour.RED);
List <Player> players = new List <Player>
{
next.Object
};
BoardGameDTO result = service.processMove(mockGame.Object, p.Object, players);
Assert.IsNotNull(result.game[0][0]["owner"]);
}
public void WillSetTheMoveMadeByTheAiAsTheLastMove()
{
Mock <NodeService> mockNodeService = new Mock <NodeService>();
mockNodeService.Setup(x => x.process(It.IsAny <BoardGame>(), It.IsAny <PlayerColour>()))
.Returns(new List <INode>());
service = new GameService(mockNodeService.Object, new Mock <IDatabaseProvider>().Object);
Mock <Player> mockAi = new Mock <Player>();
Move m = new Move();
Mock <INode> mockNode = new Mock <INode>();
mockNode.Setup(x => x.getMove()).Returns(m);
mockAi.Setup(x => x.makeMove(It.IsAny <BoardGame>(), It.IsAny <List <INode> >(), 0))
.Returns(mockNode.Object);
mockAi.Setup(x => x.getPlayerType()).Returns(PlayerType.RANDOM);
Mock <BoardGame> mockGame = new Mock <BoardGame>();
mockGame.Setup(x => x.Clone()).Returns(mockGame.Object);
mockGame.Setup(x => x.getWinner()).Throws(new NoWinnerException());
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> >());
Mock <Player> next = new Mock <Player>();
next.Setup(x => x.getName()).Returns("");
next.Setup(x => x.getColour()).Returns(PlayerColour.RED);
List <Player> players = new List <Player>
{
next.Object
};
BoardGameDTO result = service.processMove(mockGame.Object, mockAi.Object, players);
Assert.AreSame(m, result.lastMove);
}
public BoardGameDTO processMove(BoardGame game, Player cur, List <Player> players)
{
BoardGameDTO result = new BoardGameDTO();
result.players = buildPlayersArray(players);
if (game.isWon())
{
result.Winner = game.getWinner();
SaveGame(players, game.getWinner());
}
else
{
if (cur.getPlayerType() != PlayerType.HUMAN)
{
HandleAiMove(cur, game, result, players);
if (game.isWon())
{
result.Winner = game.getWinner();
SaveGame(players, result.Winner);
}
}
else
{
result.cur = convertToJObject(cur);
result.game = convertToJObject(game.getBoard());
}
}
result.game = convertToJObject(game.getBoard());
result.availableMoves = game.getAvailableMoves();
return(result);
}
public BoardGame createBoardGame(BoardGameDTO gameDto)
{
BoardGame result = createBoardGame(gameDto.game);
result.validateBoard();
result.registerMove(gameDto.lastMove);
return(result);
}
public IActionResult makeMove([FromBody] BoardGameDTO gameDto)
{
BoardGame game = boardCreationService.createBoardGame(gameDto);
Player player = playerCreationService.createPlayer(gameDto.cur);
List <Player> players = playerCreationService.createPlayers(gameDto.players);
return(ExecuteApiAction(() => new ApiResult <BoardGameDTO> {
Model = gameService.processMove(game, player, players)
}));
}
public void WillReturnTheCurPlayerAsTheNextPlayerIfItIsAHumanPlayer()
{
Mock <Player> mockHuman = new Mock <Player>();
mockHuman.Setup(x => x.getPlayerType()).Returns(PlayerType.HUMAN);
mockHuman.Setup(x => x.getName()).Returns("name");
Mock <BoardGame> mockGame = new Mock <BoardGame>();
mockGame.Setup(x => x.getWinner()).Throws(new NoWinnerException());
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> >());
BoardGameDTO result = service.processMove(mockGame.Object, mockHuman.Object, new List <Player>());
Assert.AreEqual(PlayerType.HUMAN, result.cur["type"].ToObject <PlayerType>());
}
public void WillSetTheWinningPlayerIfGameIsOver()
{
Mock <BoardGame> mockGame = new Mock <BoardGame>(MockBehavior.Loose);
Mock <Player> p = new Mock <Player>();
p.Setup(x => x.getPlayerType()).Returns((PlayerType)0);
p.Setup(x => x.getName()).Returns("");
mockGame.Setup(x => x.isWon()).Returns(true);
mockGame.Setup(x => x.getWinner()).Returns(0);
mockGame.Setup(x => x.getBoard()).Returns(new List <List <BoardGame> >());
BoardGameDTO result = service.processMove(mockGame.Object, p.Object, new List <Player> {
p.Object, p.Object
});
Assert.AreEqual((PlayerColour)0, result.Winner);
}
public void WillPassTheGameToTheBoardGameCreationService()
{
BoardGameDTO dto = new BoardGameDTO();
List <List <JObject> > obj = new List <List <JObject> >
{
new List <JObject>
{
new JObject()
}
};
Mock <BoardCreationService> mockService = new Mock <BoardCreationService>(MockBehavior.Loose);
mockService.Setup(x => x.createBoardGame(dto)).Verifiable();
cont = new GameController(new Mock <IGameService>(MockBehavior.Loose).Object, mockService.Object, new Mock <IPlayerCreationService>().Object);
cont.makeMove(dto);
mockService.Verify();
}
public void WillCallPlayerCreationServiceToCreatePlayers()
{
BoardGameDTO dto = new BoardGameDTO();
Mock <Player> mockPlayer = new Mock <Player>();
dto.players = new List <JObject>
{
new JObject()
};
Mock <IGameService> gameService = new Mock <IGameService>();
Mock <BoardCreationService> boardCreationService = new Mock <BoardCreationService>();
Mock <IPlayerCreationService> playerCreationService = new Mock <IPlayerCreationService>();
playerCreationService.Setup(x => x.createPlayers(dto.players))
.Returns(new List <Player>())
.Verifiable();
cont = new GameController(gameService.Object, boardCreationService.Object, playerCreationService.Object);
cont.makeMove(dto);
playerCreationService.Verify();
}
public void WillAddTheAvailableMovesToTheDto()
{
Mock <BoardGame> mockGame = new Mock <BoardGame>();
mockGame.Setup(x => x.getBoard())
.Returns(new List <List <BoardGame> >());
List <Move> available = new List <Move>();
mockGame.Setup(x => x.getAvailableMoves()).Returns(available);
Mock <Player> mockHuman = new Mock <Player>();
mockHuman.Setup(x => x.getPlayerType()).Returns(PlayerType.HUMAN);
mockHuman.Setup(x => x.getName()).Returns("name");
mockHuman.Setup(x => x.makeMove(It.IsAny <BoardGame>(), It.IsNotNull <List <INode> >(), 0))
.Returns((INode)null)
.Verifiable();
BoardGameDTO result = service.processMove(mockGame.Object, mockHuman.Object, new List <Player>());
Assert.AreSame(available, result.availableMoves);
}
private void HandleAiMove(Player Ai, BoardGame game, BoardGameDTO result, List <Player> players)
{
List <INode> nodes = nodeService.process(game, Ai.getColour());
Player next = players.Find(x => !x.getColour().Equals(Ai.getColour()));
INode move = Ai.makeMove(game.Clone() as BoardGame, nodes, next.getUserId());
provider.updateUser(Ai.getUserId(), move.getReward());
game.makeMove(move.getMove());
List <List <BoardGame> > board = game.getBoard();
result.lastMove = move.getMove();
result.cur = convertToJObject(next);
result.lastMoveRating = move.getReward();
int place = 0;
double high = -1;
double low = 1;
foreach (INode node in nodes)
{
double reward = node.getReward();
if (reward > high)
{
high = reward;
}
if (reward < low)
{
low = reward;
}
if (move.getReward() < reward)
{
place++;
}
}
provider.saveMove(Ai.getUserId(), move.getReward(), place);
result.highOption = high;
result.lowOption = low;
}
