public PlayerDto RunTurn(TurnDto Turn)
{
if (Turn.Players.Count != 2)
{
throw new Exception(ERROR_MESSAGE_NUMBER_PLAYERS_INCORRECT);
}
var p1 = Turn.Players[0];
var p2 = Turn.Players[1];
if (p1.Move == p2.Move)
{
return(p1);
}
switch (p1.Move)
{
case 'R':
return(p2.Move == 'S' ? p1 : p2);
case 'P':
return(p2.Move == 'R' ? p1 : p2);
case 'S':
return(p2.Move == 'P' ? p1 : p2);
default:
throw new Exception(message: ERROR_MESSAGE_STRATEGY_ERROR);
}
}
public IHttpActionResult PostUserTurn(UserTurnDto playersTurn)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var turnDto = new TurnDto
{
GameId = playersTurn.GameId,
PlayerId = playersTurn.PlayerId,
X = playersTurn.X ?? 0,
Y = playersTurn.Y ?? 0
};
var res = _gameService.MakeTurn(turnDto);
return(Ok(res));
}
catch (CustomValidationException ex)
{
ModelState.AddModelError(ex.Property, ex.Message);
return(BadRequest(ModelState));
}
}
private GameDto makeTurn(TurnDto turnDto, Game game)
{
var gameState = getGameState(game);
if (gameState[turnDto.X, turnDto.Y] != 0)
{
throw new CustomValidationException("Requested cell already contains value", string.Empty);
}
game.Game2Players.Add(new Game2Player
{
Date = DateTime.Now,
PlayerId = turnDto.PlayerId,
X = turnDto.X,
Y = turnDto.Y,
GameId = turnDto.GameId ?? 0
});
if (game.Id > 0)
{
game.IsFinished = _gameResultChecker.DoesGameFinished(getGameState(game));
_database.Games.Update(game);
}
else
{
_database.Games.Create(game);
}
_database.Save();
return(convertToDto(game));
}
private static TurnDto getAiTurn(Game game)
{
var res = new TurnDto
{
GameId = game.Id
};
var state = getGameState(game);
for (var x = 0; x < state.GetLength(0); x++)
{
for (var y = 0; y < state.GetLength(1); y++)
{
if (state[x, y] != 0)
{
continue;
}
res.X = x;
res.Y = y;
return(res);
}
}
return(res);
}
public GameDto MakeTurn(TurnDto turnDto)
{
var game = turnDto.GameId.HasValue && turnDto.GameId.Value > 0
? _database.Games.Get(turnDto.GameId.Value)
: new Game();
validateGame(game);
return(makeTurn(turnDto, game));
}
public TurnDto AddTurn(List <PlayerDto> players)
{
TurnDto Turn = new TurnDto();
foreach (var player in players)
{
Turn.Players.Add(player);
}
return(Turn);
}
public void TestMakeTurn()
{
//Arrange
_gameRepository.Setup(gr => gr.Get(It.IsAny <int>())).Returns(new Game
{
Id = 1,
IsFinished = false,
Game2Players = new List <Game2Player>
{
new Game2Player
{
Id = 1,
Date = DateTime.Now,
GameId = 1,
PlayerId = 1,
X = 0,
Y = 0
},
new Game2Player
{
Id = 2,
Date = DateTime.Now,
GameId = 1,
PlayerId = 1,
X = 1,
Y = 1
}
}
});
_unitOfWorkMock.SetupGet(uow => uow.Games).Returns(_gameRepository.Object);
var gameService = new GameService(_unitOfWorkMock.Object);
var turnDto = new TurnDto
{
GameId = 1,
PlayerId = 1,
X = 2,
Y = 2
};
//Act
var result = gameService.MakeTurn(turnDto);
//Assert
Assert.IsTrue(result.IsFinished);
Assert.AreEqual(result.State[0, 0], 2);
Assert.AreEqual(result.State[1, 1], 2);
Assert.AreEqual(result.State[2, 2], 2);
}
public GameDto GetGame()
{
var Game = new GameDto();
var Turn1 = new TurnDto();
Turn1.Players.Add(new PlayerDto {
PlayerName = "Armando", Move = 'P'
});
Turn1.Players.Add(new PlayerDto {
PlayerName = "Dave", Move = 'S'
});
Game.Turn.Add(Turn1);
var Turn2 = new TurnDto();
Turn2.Players.Add(new PlayerDto {
PlayerName = "Richard", Move = 'R'
});
Turn2.Players.Add(new PlayerDto {
PlayerName = "Michael", Move = 'S'
});
Game.Turn.Add(Turn2);
var Turn3 = new TurnDto();
Turn3.Players.Add(new PlayerDto {
PlayerName = "Allen", Move = 'S'
});
Turn3.Players.Add(new PlayerDto {
PlayerName = "Omer", Move = 'P'
});
Game.Turn.Add(Turn3);
var Turn4 = new TurnDto();
Turn4.Players.Add(new PlayerDto {
PlayerName = "David E.", Move = 'R'
});
Turn4.Players.Add(new PlayerDto {
PlayerName = "Richard X.", Move = 'P'
});
Game.Turn.Add(Turn4);
return(Game);
}
public async Task <Game> CastTurn(TurnDto turnDto)
{
Game game = await _gameRepository.GetByIdAsync(turnDto.Game);
Cell cell = _ticTacToeHelper.GetCellFromRowAndCol(
game.TicTacToe.Cells, turnDto.Row, turnDto.Column);
if (!_ticTacToeHelper.ShouldSetCell(game, turnDto.CastedBy, cell))
{
throw new TurnUncastedException();
}
cell.CastedBy = turnDto.CastedBy;
game.TicTacToe = _ticTacToeHelper.CastTurn(game.TicTacToe, cell, game.GameState);
game.GameState = _ticTacToeHelper.CalculateGameState(game.TicTacToe, cell.CellState);
return(await _gameRepository.UpdateAsync(game));
}
public IList <TurnDto> GetRequestList(DateTime date, int hourId, int campId)
{
try
{
IList <TurnDto> results = new List <TurnDto>();
var list = turnRepository.RequestList(date, hourId, campId);
foreach (Turn turn in list)
{
int?teamId = null;
if (turn.Team != null)
{
teamId = turn.Team.Id;
}
TurnDto turnDto = new TurnDto(turn.Id, turn.Date, turn.FullName, turn.Field.Name, teamId);
results.Add(turnDto);
}
return(results);
}
catch
{
throw;
}
}
