public async Task It_Creates_The_Game()
{
//--arrange
var numberOfHumanPlayers = 2;
var newGame = new NewGameRequest(TestUserName, numberOfHumanPlayers);
//--act
var result = await GamesClient.CreateGame(newGame, TestEnvironmentSettings.BaseApiUrl);
//--assert
result.NumberOfHumanPlayers.ShouldBe(newGame.NumberOfHumanPlayers);
result.NumberOfAiPlayers.ShouldBe(newGame.NumberOfAiPlayers);
result.GridSize.ShouldBe(50);
result.Id.ShouldBeGreaterThan(0);
result.Status.ShouldBe(GameStatus.NotStarted);
result.GenerationNumber.ShouldBe(0);
result.RoundNumber.ShouldBe(0);
result.TotalDeadCells.ShouldBe(0);
result.TotalRegeneratedCells.ShouldBe(0);
result.TotalLiveCells.ShouldBe(0);
result.EndOfGameCountDown.ShouldBeNull();
result.GrowthCycles.ShouldNotBeNull();
//--there should be no growth cycles if the game hasn't started
result.GrowthCycles.Count.ShouldBe(0);
result.StartingGameState.ShouldBeNull();
}
public ActionResult Post([FromBody] NewGameRequest gameRequest)
{
return(Ok(new GameResultModel
{
GameId = new Guid()
}));
}
public async Task <IActionResult> AddInGameUsers([FromBody] NewGameRequest newGameRequest)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
if (newGameRequest.UserNames.Count > 0)
{
try
{
return(Ok(await gameService.AddInGameUsersAsync(newGameRequest, userId)));
}
catch (ItemNotFoundException e)
{
return(BadRequest(e.Message));
}
catch (FormatException e)
{
return(BadRequest(e.Message));
}
catch (HostMisMatchException e)
{
return(BadRequest(e.Message));
}
}
else
{
return(BadRequest("Number of players must be higher than 0"));
}
}
public void WhenRunGame_ThenSouldCreateRound()
{
var newGameRequest = new NewGameRequest
{
MaxGuessNo = 10,
NoOfRounds = 1,
UsersInGame = new[] { 1, 2 }
};
var gameServiceFixture = new GameServiceFixture();
var gameService = gameServiceFixture.CreateGameService();
var gameId = gameService.Create(newGameRequest);
Assert.NotEqual(Guid.Empty, gameId);
var usersInGame = new[]
{
new UserInGame(1, 5),
new UserInGame(2, 20)
};
var roundRepository = new RoundRepositoryInMemory();
var roundOfGame = new RoundOfGame(gameServiceFixture.GameRepository, roundRepository,
gameServiceFixture.UnitOfWork);
var round = roundOfGame.RunGame(gameId, usersInGame);
Assert.NotNull(round);
}
public async Task <IHttpActionResult> Create(NewGameRequest game)
{
game.UserId = HttpContext.Current.User.Identity.GetUserId();
var domainGame = await games.CreateNewGame(game);
return(Ok(domainGame));
}
public async Task <Game> CreateNewGame(NewGameRequest request)
{
var game = Mapper.Map <NewGameRequest, Game>(request);
game.Date = DateTime.UtcNow;
return(await Games.Insert(game));
}
public void WhenGameStarted_ShouldReturnUsersInGame()
{
var gameServiceFixture = new GameServiceFixture();
var expectedUsers = _fixture.CreateMany <User>().ToList();
var gameService = gameServiceFixture
.WithUsers(expectedUsers)
.CreateGameService();
var gameRequest = new NewGameRequest
{
MaxGuessNo = 1,
NoOfRounds = 1,
UsersInGame = expectedUsers.Select(u => u.Id)
};
var gameId = gameService.Create(gameRequest);
var users = gameService.GetUsersInGame(gameId).ToList();
Assert.True(users.Count() > 1);
expectedUsers.ForEach(eu =>
{
var actualUser = users.First(au => au.Id == eu.Id);
Assert.Equal(eu, actualUser, new UserComparer());
});
}
public async Task <Game> CreateGame(NewGameRequest gameRequest)
{
var player = new Player
{
Name = gameRequest.PlayerName,
Token = Guid.NewGuid()
};
// TODO check this hasn't been used.
var code = GenerateGameCode().ToUpper();
var startingCards = await GetStartingCards();
var game = new Game
{
Code = code,
};
game.GameCards = startingCards;
game.Players.Add(player);
_gameContext.Games.Add(game);
await _gameContext.SaveChangesAsync();
player.OriginalGameId = game.Id;
await _gameContext.SaveChangesAsync();
return(game);
}
public void JoinSystem(StarSystemData starSystemData)
{
Application.LoadLevel("GameInstance");
NewGameRequest request = new NewGameRequest(OnGameCreated, starSystemData);
GameClient.Instance.SendRequest(request);
}
public IActionResult Start([FromBody] NewGameRequest newGameRequest)
{
var gameId = _gameService.Create(newGameRequest);
// add created ad root
return(Ok(gameId));
}
public virtual async Task <GameModel> CreateGame(NewGameRequest newGame, string baseApiUrl)
{
using (var client = new HttpClient())
{
var stringifiedObject = _serialization.SerializeToHttpStringContent(newGame);
var gamesUri = new Uri(baseApiUrl + "/games");
using (var response = await client.PostAsync(gamesUri, stringifiedObject))
{
using (var content = response.Content)
{
var data = await content.ReadAsStringAsync();
Debug.WriteLine($"POST request sent to '{gamesUri.AbsolutePath}' with data: '{await stringifiedObject.ReadAsStringAsync()}'.");
Debug.WriteLine($"Got response: '{data}'");
if (data != null && response.IsSuccessStatusCode)
{
return(_serialization.DeserializeObject <GameModel>(data));
}
var requestDataJson = await stringifiedObject.ReadAsStringAsync();
throw new ApiException(gamesUri, HttpMethod.Post, requestDataJson, response.StatusCode, data);
}
}
}
}
public void OnGuestCreated(JObject jsonObject)
{
Debug.Log("Guest created: " + jsonObject);
StarSystemData data = new StarSystemData();
string starSystemId = GameManager.Instance.starSystemEnvironment.name;
data.id = starSystemId;
ClientRequest request = new NewGameRequest(OnGameCreated, data);
GameClient.Instance.SendRequest(request);
}
public NewGameResponse Execute(NewGameRequest request)
{
Board board = _boardWriter.New();
return(new NewGameResponse
{
Board = board
});
}
public async Task <IActionResult> CreateGame([FromBody] NewGameRequest request, CancellationToken cancellationToken)
{
var command = NewGameMapper.ToCommand(User, request);
var gameId = await _newGameCommandHandler.HandleAsync(command, cancellationToken).ConfigureAwait(false);
var routeValues = new { gameId };
return(CreatedAtRoute(RouteNames.GetGameState, routeValues, null));
}
public void OnGuestCreated(JObject jsonObject)
{
Debug.Log("Guest created: " + jsonObject);
StarSystemData data = new StarSystemData();
string starSystemId = GameManager.Instance.starSystemEnvironment.name;
data.id = starSystemId;
ClientRequest request = new NewGameRequest(OnGameCreated, data);
GameClient.Instance.SendRequest(request);
}
public async Task <ActionResult <GameResponse> > PostGame(NewGameRequest gameRequest)
{
var game = await _gameService.CreateGame(gameRequest);
var currentPlayer = game.Players.First();
Response.Headers.Add("X-CurrentPlayerToken", currentPlayer.Token.ToString());
var gameResponse = _gameService.GetGameResponse(game, currentPlayer);
return(CreatedAtAction("GetGame", new { id = game.Id }, gameResponse));
}
public async Task <ActionResult <GameResponse> > Post(NewGameRequest request)
{
var userId = GetCurrentUserId();
var result = await gameService.NewGame(
userId,
request.Rows,
request.Columns,
request.Mines);
var response = mapper.Map <Game, GameResponse>(result);
return(Ok(response));
}
public void whenCreatingNewGame_ThenShouldCreateGameId()
{
var newGameRequest = new NewGameRequest
{
MaxGuessNo = 10,
NoOfRounds = 1,
UsersInGame = new[] { 1, 2 }
};
var gameService = new GameServiceFixture().CreateGameService();
var gameId = gameService.Create(newGameRequest);
Assert.NotEqual(Guid.Empty, gameId);
}
public GameResultViewModel RunGame(IEnumerable <NewGameRequest> gameInputs)
{
var game = new Game(_randomGenerator);
var result = game.Run(NewGameRequest.ToUserGame(gameInputs));
_repository.UpdateWinner(result.WinnerId);
var allUsers = _repository.Get();
var userName = allUsers.Where(u => u.Id == result.WinnerId).Select(u => u.Name).Single();
// return new GameResultViewModel(result.WinnerId, userName, result.RandomNumber);
// Fix this
return(new GameResultViewModel(1, "", 1));
}
public void startGame(string name)
{
NewGameRequest request = new NewGameRequest()
{
user = name
};
NewGameResponse response = AxiomzenMastermind.newGame(request);
GameData gameData = new GameData()
{
game_key = response.game_key
};
_games[Context.ConnectionId] = gameData;
Clients.Client(Context.ConnectionId).postHistory("New game started", "Start guessing a 8 digit code, with values from 1 to 8.");
}
public void Example_Json_For_Creating_A_Game()
{
//--arrange
var newGameRequest = new NewGameRequest("jake", 1, 2);
//--act
var jsonString = JsonConvert.SerializeObject(newGameRequest, new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
});
//--assert
Debug.WriteLine(jsonString);
}
public IActionResult NewGame([FromBody] NewGameRequest newGameRequest)
{
try
{
_gameStateService.InitializeNewGame(newGameRequest.PlayerOneName, newGameRequest.TotalNumberOfShipsPerPlayer);
_logger.LogDebug("New Game initiated");
return(StatusCode(201, _gameStateService.GetGameStatus()));
}
catch (Exception e)
{
return(StatusCode(500,
ApiErrorResponse.GetCustomInternalServerError(
"An unexpected error occured. Please contact API team.",
HttpContext.TraceIdentifier,
new List <string> {
e.Message
})));
}
}
public void WhenGameFinishes_ThenShouldSelectTheWinner()
{
var expectedGuessNo = 10;
var gameServiceFixture = new GameServiceFixture();
var gameService = gameServiceFixture.CreateGameService();
var newGameRequest = new NewGameRequest
{
MaxGuessNo = 10,
NoOfRounds = 3,
UsersInGame = new[] { 1, 2, 3 }
};
var gameId = gameService.Create(newGameRequest);
var roundRepository = new RoundRepositoryInMemory();
var roundOfGame = new RoundOfGame(gameServiceFixture.GameRepository, roundRepository,
gameServiceFixture.UnitOfWork);
var expectedNonWinner = new UserInGame(1, expectedGuessNo);
var expectedWinner = new UserInGame(2, expectedGuessNo - 4);
var usersInGame = new List <UserInGame>
{
expectedNonWinner,
expectedWinner,
new UserInGame(3, expectedGuessNo - 5)
};
roundOfGame.RunGame(gameId, usersInGame);
expectedNonWinner.Number = expectedGuessNo - 5;
expectedWinner.Number = expectedGuessNo;
roundOfGame.RunGame(gameId, usersInGame);
roundOfGame.RunGame(gameId, usersInGame);
var gameWinner = gameService.GetGameWinner(gameId);
Assert.Equal(expectedWinner.UserId, gameWinner);
}
public async Task <Game> AddInGameUsersAsync(NewGameRequest gameRequest, string userId)
{
gameRequest.UserNames
.Add(context.Users
.Where(u => u.Id == userId)
.SingleOrDefault().UserName);
var game = context.Games
.Where(g => g.Id == gameRequest.GameId)
.SingleOrDefault()
?? throw new ItemNotFoundException($"Game with id {gameRequest.GameId} not found.");
if (game.HostingUserId == userId)
{
await CreateInGameUsersBasedOnUserNameAsync(gameRequest.UserNames, game);
context.Update(game);
await context.SaveChangesAsync();
return(game);
}
throw new HostMisMatchException("You cannot delete this game, not belong to you.");
}
public static NewGameCommand ToCommand(ClaimsPrincipal user, NewGameRequest request)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(new NewGameCommand
{
HostPlayerDisplayName = user.GetDisplayName(),
HostPlayerId = user.GetUserId(),
InvitedPlayerId = request.InvitedPlayerId,
TableRows = request.TableRows,
TableColumns = request.TableColumns,
MineCount = request.MineCount
});
}
public ActionResult NewGame([FromBody] NewGameRequest ngr)
{
if (!TokenValidator.ValidatePlayerToken(ngr.PlayerToken))
{
return(BadRequest());
}
Game newGame = new Game {
Description = ngr.GameDescription
};
if (ngr.PlayerPickedWhite)
{
newGame.Player1Token = ngr.PlayerToken;
}
else
{
newGame.Player2Token = ngr.PlayerToken;
}
newGame.Token = TokenGenerator.GenerateGameToken(ngr.PlayerToken);
iRepository.AddGame(newGame);
return(CreatedAtAction("NewGame", newGame));
}
public async Task <IActionResult> NovaTentativaAsync(Tentativa tentativa)
{
if (ModelState.IsValid)
{
tentativa.IniciarTentativa();
Repositorio.AddTentativa(tentativa);
HttpClient client = MyHttpClient.Client;
string path = "/api/NewGame";
NewGameRequest newGameRequest = new NewGameRequest(tentativa.Nickname, tentativa.Classe);
string json = JsonConvert.SerializeObject(newGameRequest);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, path);
request.Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return(Redirect("/"));
}
string json_r = await response.Content.ReadAsStringAsync();
GameState gs = JsonConvert.DeserializeObject <GameState>(json_r);
tentativa.AtualizarDados(gs);
return(View("AreaDeJogo", tentativa));
}
else
{
return(View("NovaTentativa"));
}
}
public static NewGameResponse newGame(NewGameRequest newGameRequest)
{
try
{
string url = serviceUrl + "new_game?user="******"POST";
request.ContentType = "text/json";
using (var streamWriter = new StreamWriter(request.GetRequestStream()))
{
DataContractJsonSerializer jsonResponseSerializer = new DataContractJsonSerializer(typeof(NewGameRequest));
jsonResponseSerializer.WriteObject(streamWriter.BaseStream, newGameRequest);
streamWriter.Flush();
streamWriter.Close();
}
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception(String.Format("Server error (HTTP {0}: {1}).", response.StatusCode, response.StatusDescription));
}
DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(NewGameResponse));
object objResponse = jsonSerializer.ReadObject(response.GetResponseStream());
NewGameResponse jsonResponse = objResponse as NewGameResponse;
return(jsonResponse);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
}
public void NewGame(NewGameRequest request)
{
Board = new Board();
Status = GameStatus.Ok;
Board.Build(request.XLength, request.YLength, request.Bombs);
}
public async Task <IActionResult> NovaTentativaAutonomaAsync(Tentativa tentativa)
{
tentativa.IniciarTentativa();
Repositorio.AddTentativa(tentativa);
HttpClient client = MyHttpClient.Client;
string path = "/api/NewGame";
NewGameRequest newGameRequest = new NewGameRequest(tentativa.Nickname, tentativa.Classe);
string json = JsonConvert.SerializeObject(newGameRequest);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, path);
request.Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return(Redirect("/"));
}
string json_r = await response.Content.ReadAsStringAsync();
GameState gs = JsonConvert.DeserializeObject <GameState>(json_r);
tentativa.AtualizarDados(gs);
while (!tentativa.JogoFinalizado && gs.RoundNumber < 50)
{
tentativa.ExecutarAlgoritmo();
if ((tentativa.Nickname == "auto3" && gs.RoundNumber >= 3) || (tentativa.Nickname == "auto7" && gs.RoundNumber >= 7))
{
tentativa.Acao = Playeraction.Quit;
tentativa.FinalizarTentativa();
}
path = "/api/Play";
PlayRequest playRequest = new PlayRequest(tentativa.Id, tentativa.Acao);
json = JsonConvert.SerializeObject(playRequest);
request = new HttpRequestMessage(HttpMethod.Post, path);
request.Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
return(Redirect("/"));
}
json_r = await response.Content.ReadAsStringAsync();
gs = JsonConvert.DeserializeObject <GameState>(json_r);
if (tentativa.Acao != Playeraction.Quit)
{
tentativa.AtualizarDados(gs);
tentativa.ExecutarAcao();
}
RoundSummary rs = new RoundSummary();
rs.AtualizarDados(tentativa.Acao, tentativa.Posicao, tentativa.InimigosDerrotados, tentativa.InimigosFintados, tentativa.ContadorItensEncontrados, tentativa.ChaveNoBolso, tentativa.PontosDeVida, tentativa.PontosDeForca, tentativa.PontosDeSorte, tentativa.PocoesDeVida, tentativa.Resultado, tentativa.Ronda);
tentativa.FinalizarRonda(rs);
}
return(View("JogoFinalizadoAutonomo", tentativa));
}
protected async Task <GameModel> CreateValidGameForTesting(string userName, int numberOfHumanPlayers = 2, int numberOfAiPlayers = 1)
{
var newGameRequest = new NewGameRequest(userName, numberOfHumanPlayers, numberOfAiPlayers);
return(await GamesClient.CreateGame(newGameRequest, TestEnvironmentSettings.BaseApiUrl));
}
