private GameDTO BuildGame(CreateGameResponse data)
{
try {
return(new GameDTO()
{
Assignments = data.Assignments,
TeamId = data.TeamId,
DurationInMinutes = data.DurationInMinutes,
Id = data.Id,
IsCanceled = data.IsCanceled,
IsTimeTbd = data.IsTimeTbd,
Location = data.Location,
LocationDetails = data.LocationDetails,
MinutesToArriveEarly = data.MinutesToArriveEarly,
Notes = data.Notes,
NotForStandings = data.NotForStandings,
Opponent = data.Opponent,
StartDate = data.StartDate,
Type = data.Type,
Uniform = data.Uniform
});
}
catch (Exception exc) {
throw new InvalidOperationException("SchedulingService BuildGame()", exc);
}
}
private void HandleCreateGameResponse(CreateGameResponse response)
{
_logger.LogInformation("HandleCreateGameResponse Message={0}", response);
if (OnCreateGameResponse != null)
{
OnCreateGameResponse(response);
}
}
private static CreateGameResponse GetCreateGameResponse(OperationResponse op)
{
var res = new CreateGameResponse();
res.GameId = GetParameter <string>(op, Operations.ParameterCode.GameId, true);
res.Address = GetParameter <string>(op, Operations.ParameterCode.Address, true);
return(res);
}
public CreateGameResponse CreateGame(CreateGameRequest request)
{
CreateGameResponse response = new CreateGameResponse {
IsSuccess = true
};
return(response);
}
public void JoinGame(CreateGameResponse gameInformation)
{
var stringData = JsonConvert.SerializeObject(gameInformation);
var response = _dataReceiver.SendRequest("join", GetAccountDictionary(), stringData);
inGame = true;
gameKey = Decode <string>(response);
}
public override void Execute()
{
Guid userID = (request as CreateGameRequest).UserID;
Guid gameID = this.gameService.CreateGame(userID);
response = new CreateGameResponse(gameID);
SendMessage(userID); // Отправляем сформированный ответ
}
protected static CreateGameResponse GetCreateGameResponse(OperationResponse op)
{
var res = new CreateGameResponse
{
GameId = GetParameter <string>(op, ParameterCode.RoomName, true),
Address = GetParameter <string>(op, ParameterCode.Address, true)
};
return(res);
}
public CreateGameOutput CreateGame()
{
CreateGameResponse createGameResponse = DependencyResolver.Instance()
.GetInstanceOf <IService <CreateGameRequest, CreateGameResponse> >()
.Run(new CreateGameRequest());
return(new CreateGameOutput()
{
id = createGameResponse.id,
firstPlayer = createGameResponse.firstPlayer
});
}
public Task <GameDTO> CreateNewGameAsync(ManageGameDataModel newGameDataModel, CancellationTokenSource cancellationTokenSource) =>
Task <GameDTO> .Run(async() => {
if (!CrossConnectivity.Current.IsConnected)
{
throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
}
GameDTO createdGame = null;
CreateGameRequest createGameRequest = new CreateGameRequest()
{
AccessToken = GlobalSettings.Instance.UserProfile.AccesToken,
Data = newGameDataModel,
Url = GlobalSettings.Instance.Endpoints.ScheduleEndpoints.CreateNewGame
};
try {
CreateGameResponse createGameResponse = await _requestProvider.PostAsync <CreateGameRequest, CreateGameResponse>(createGameRequest);
if (createGameResponse != null)
{
createdGame = BuildGame(createGameResponse);
}
else
{
throw new InvalidOperationException(CREATE_NEW_GAME_COMMON_ERROR_MESSAGE);
}
}
catch (HttpRequestExceptionEx exc) {
CreateUpdateGameBadResponse createGameBadResponse = JsonConvert.DeserializeObject <CreateUpdateGameBadResponse>(exc.Message);
string output = string.Format("{0} {1} {2} {3} {4} {5} {6}",
createGameBadResponse.Errors?.FirstOrDefault(),
createGameBadResponse.LocationId?.FirstOrDefault(),
createGameBadResponse.OpponentId?.FirstOrDefault(),
createGameBadResponse.TeamId?.FirstOrDefault(),
createGameBadResponse.Type?.FirstOrDefault(),
createGameBadResponse.DurationInMinutes?.FirstOrDefault(),
createGameBadResponse.MinutesToArriveEarly?.FirstOrDefault());
output = (string.IsNullOrWhiteSpace(output) || string.IsNullOrEmpty(output)) ? CREATE_NEW_GAME_COMMON_ERROR_MESSAGE : output.Trim();
throw new InvalidOperationException(output);
}
catch (Exception exc) {
Crashes.TrackError(exc);
throw;
}
return(createdGame);
}, cancellationTokenSource.Token);
public async Task <IActionResult> CreateGame([FromBody] CreateGameRequest createGameRequest)
{
var user = await _UserLogic.GetUserAsync(HttpContext.User.Identity.Name).ConfigureAwait(false);
var org = await _OrganizationLogic.GetOrganizationByUserAsync(user.UserId).ConfigureAwait(false);
var game = await _GameLogic.CreateNewGameAsync(createGameRequest.GameVariantId, org.OrganizationId, user.UserId).ConfigureAwait(false);
var response = new CreateGameResponse(game.GameId, game.AccessCode);
return(Ok(response));
}
private void Realm_OnCreateGameResponse(CreateGameResponse Packet)
{
CreateGameResult result = Packet.Result;
if (result == CreateGameResult.Sucess)
{
this.Realm.WriteToLog("Game Created", Color.Green);
}
else
{
this.Realm.WriteToLog("Game Creation Failed, Reason: " + Packet.Result, Color.Red);
this.FailToCreateGameEvent?.Invoke();
}
}
public void CreateGameResponse_Correct_ObjectCreated()
{
// Arrange
var createGameResponse = new CreateGameResponse
{
GameId = this.gameGuid,
IsSuccessful = this.isSuccessful
};
// Act
// Assert
Assert.Equal(this.gameGuid, createGameResponse.GameId);
Assert.Equal(this.isSuccessful, createGameResponse.IsSuccessful);
}
private void CreateGame(object sender, ResponseEventArgs e)
{
CreateGameResponse response = e.Response as CreateGameResponse;
if (response != null)
{
if (response.IsSuccess)
{
Switcher.SwitchPage(new Game(true));
}
else
{
errorMessageTextBlock.Text = response.Error;
}
}
}
public async Task PostStartGameAsyncTest(string playerId, Lobby lobby, CreateGameResponse gameResponse)
{
// Arrange
_lobbyRepo.Setup(r => r.GetAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(lobby)
.Verifiable();
_lobbyRepo.Setup(r => r.UpdateAsync(It.IsAny <string>(), It.IsAny <Lobby>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
_gameService
.Setup(c => c.CreateGameAsync(
It.IsAny <protos.CreateGameRequest>(),
null,
null,
It.IsAny <CancellationToken>()
))
.Returns(new Grpc.Core.AsyncUnaryCall <CreateGameResponse>(
Task.FromResult(gameResponse),
null,
null,
null,
null
))
.Verifiable();
_host.ConfigureServices(services =>
{
services.AddTransient <protos.GamesService.GamesServiceClient>(_ => _gameService.Object);
services.AddTransient <ILobbyRepository>(_ => _lobbyRepo.Object);
});
// Act
using var server = await _host.StartAsync();
var client = server.GetTestClient();
var request = new HttpRequestMessage(HttpMethod.Post, $"{client.BaseAddress}{lobby.GameId}/start_game");
request.Headers.Add("Cookie", $"player_id={playerId};");
var response = await client.SendAsync(request, CancellationToken.None);
var result = response.Content.ReadAsStringAsync();
// Assert
result.Should().NotBeNull();
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
_lobbyRepo.Verify();
_gameService.Verify();
}
private void ProcessCreateGameRequest(CreateGameRequest request, int clientID)
{
Console.WriteLine($"Request to create room from player {clientID}");
Player player = players.FirstOrDefault(p => p.ClientID == clientID);
if (player == null)
{
Console.WriteLine($"Player {clientID} doesn't exist");
return;
}
if (player.Match != null)
{
Console.WriteLine($"Player {clientID} is already in the game");
DropRoom(player.Match);
}
string roomID = GetNewRoomNumber().ToString();
player.Name = request.PlayerName;
GameMatch match = new GameMatch();
match.Player1 = player;
match.RoomID = roomID;
match.CardPackName = request.CardPack;
match.Difficulty = request.Difficulty;
match.Width = request.Width;
match.Height = request.Height;
match.IsRunning = false;
player.Match = match;
matches.Add(match);
Console.WriteLine($"Room {roomID} created");
CreateGameResponse response = new CreateGameResponse();
response.RoomID = roomID;
Server.SendDataToClient(clientID, (int)DataTypes.CreateGameResponse, response);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
CreateGameResponse response = new CreateGameResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("Game", targetDepth))
{
var unmarshaller = GameDetailsUnmarshaller.Instance;
response.Game = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
void OnCreateGameResponse(CreateGameResponse response)
{
if (_request != null && response.RequestId == _request.RequestId)
{
ResetRequest();
if (response.IsSuccess)
{
CreatedGames.Add(response.Game);
_ = _localStorage.SetItemAsync(CREATED_GAMES_KEY, CreatedGames);
_ = ShowGamePlayer(response.Game);
}
else
{
IsCreateGameFailedDialogVisible = true;
CreateGameFailedDialogMessage = response.ErrorMessage;
InvokeStateChanged(EventArgs.Empty);
}
}
}
public async Task CreateGameAsync(CreateGameRequest request, Func <CreateGameResponse, Task> responseHandler)
{
_logger.LogInformation("CreateGame: Request={}", request);
var resp = new CreateGameResponse()
{
RequestId = request.RequestId
};
if (String.IsNullOrWhiteSpace(request.Game.GameName))
{
resp.ErrorMessage = "Invalid GameName";
await responseHandler(resp);
return;
}
var numPlayerGames = await _dbContext.GameStates
.CountAsync(x => x.PlayerId == request.Player.PlayerId && !x.IsFinished);
_logger.LogInformation($"numPlayerGames={numPlayerGames}");
if (numPlayerGames > MAX_GAMES_PER_USER)
{
resp.ErrorMessage = "Too many active games for player";
await responseHandler(resp);
return;
}
var gameEngine = new GameEngine(_loggerProvider, _dbContext, _cardRepo);
var playerState = await gameEngine.CreateGameAsync(request);
resp.IsSuccess = true;
resp.Game = gameEngine.GameState.Game;
await responseHandler(resp);
InvokeOnPlayerUpdate(MakePlayerUpdateResponse(playerState));
InvokeOnGameUpdate(MakeGameUpdateResponse(gameEngine.GameState));
InvokeOnTradeUpdate(null, MakeTradeUpdateResponse(gameEngine.GameState.GameId, gameEngine.GameState.Trades));
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
private void HandleCreateGameResponse(CreateGameResponse message)
{
if (message.Status)
{
this.log.Info("GameServerClientActor - a new game has been created; guid={0}", message.Guid);
// DeadWatch the game service.
this.gameServiceRef = Sender;
Context.Watch(this.gameServiceRef);
//
this.game.Guid = message.Guid;
//
this.game.OnGameCreated(message.Guid);
// start the game
this.gameServiceSelection.Tell(new Gomoku.Actors.StartGame(message.Guid));
}
else
{
this.log.Error("GameServerClientActor - failed to create a new game. Error: {0}", message.ErrorMessage);
}
}
public void ClientReceiveData(int type, object data)
{
switch ((DataTypes)type)
{
case DataTypes.StartGameResponse:
StartGameResponse startGameResponse = (StartGameResponse)data;
GameSettings.PlayersCount = 2;
GameSettings.IsOnline = true;
GameSettings.PlayerID = startGameResponse.PlayerID;
GameSettings.CardPackage = CardPackages.Packages[startGameResponse.CardPackName];
GameSettings.Difficulty = startGameResponse.Difficulty;
GameSettings.FieldHeight = startGameResponse.Field.GetLength(0);
GameSettings.FieldWidth = startGameResponse.Field.GetLength(1);
GameSettings.FieldData = startGameResponse.Field;
GameSettings.PlayersNames = startGameResponse.PlayersNames;
SceneManager.LoadScene("GameScene");
break;
case DataTypes.PlayersTurnData:
GameManager.Instance.CardManager.Handle((PlayersTurnData)data);
break;
case DataTypes.CreateGameResponse:
CreateGameResponse createGameResponse = (CreateGameResponse)data;
MainMenuUIManager.Instance.RoomCreated(createGameResponse.RoomID);
break;
case DataTypes.CreateGameRequest:
case DataTypes.JoinGameRequest:
case DataTypes.RestartGameRequest:
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public async Task <IActionResult> CreateGame(CreateGameRequest createGameRequest)
{
if (!createGameRequest.WhitePlayer.HasValue)
{
createGameRequest.WhitePlayer = (int)_randomService.GetRandomColor();
}
var newGame = await _directChessRepository.AddGame(
createGameRequest.Player1Name,
createGameRequest.Player2Name,
createGameRequest.WhitePlayer.Value);
var response = new CreateGameResponse
{
GameKey = newGame.GameKey,
Player1Name = newGame.Player1Name,
Player1Key = newGame.Player1Key,
Player2Name = newGame.Player2Name,
Player2Key = newGame.Player2Key,
WhitePlayer = newGame.WhitePlayer
};
return(Ok(response));
}
public void CreateGameCallBack(CreateGameResponse response)
{
syncContext.Post(new SendOrPostCallback(OnBroadcast <CreateGameResponse>), response);
}
public async Task <APIGatewayProxyResponse> Post(APIGatewayProxyRequest request, ILambdaContext context)
{
CreateGameRequest body = JsonSerializer.Deserialize <CreateGameRequest>(request.Body);
AmazonGameLiftClient amazonClient = new AmazonGameLiftClient(Amazon.RegionEndpoint.USEast1);
ListAliasesRequest aliasReq = new ListAliasesRequest();
aliasReq.Name = "WarshopServer";
Alias aliasRes = (await amazonClient.ListAliasesAsync(aliasReq)).Aliases[0];
DescribeAliasRequest describeAliasReq = new DescribeAliasRequest();
describeAliasReq.AliasId = aliasRes.AliasId;
string fleetId = (await amazonClient.DescribeAliasAsync(describeAliasReq.AliasId)).Alias.RoutingStrategy.FleetId;
CreateGameSessionRequest req = new CreateGameSessionRequest();
req.MaximumPlayerSessionCount = 2;
req.FleetId = fleetId;
req.CreatorId = body.playerId;
req.GameProperties.Add(new GameProperty()
{
Key = "IsPrivate",
Value = body.isPrivate.ToString()
});
req.GameProperties.Add(new GameProperty()
{
Key = "Password",
Value = body.password == null ? "" : body.password
});
try
{
CreateGameSessionResponse res = await amazonClient.CreateGameSessionAsync(req);
GameSession gameSession = res.GameSession;
int retries = 0;
while (gameSession.Status.Equals(GameSessionStatus.ACTIVATING) && retries < 100)
{
DescribeGameSessionsRequest describeReq = new DescribeGameSessionsRequest();
describeReq.GameSessionId = res.GameSession.GameSessionId;
gameSession = (await amazonClient.DescribeGameSessionsAsync(describeReq)).GameSessions[0];
retries++;
}
CreatePlayerSessionRequest playerSessionRequest = new CreatePlayerSessionRequest();
playerSessionRequest.PlayerId = body.playerId;
playerSessionRequest.GameSessionId = gameSession.GameSessionId;
CreatePlayerSessionResponse playerSessionResponse = await amazonClient.CreatePlayerSessionAsync(playerSessionRequest);
CreateGameResponse response = new CreateGameResponse {
playerSessionId = playerSessionResponse.PlayerSession.PlayerSessionId,
ipAddress = playerSessionResponse.PlayerSession.IpAddress,
port = playerSessionResponse.PlayerSession.Port
};
return(new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = JsonSerializer.Serialize(response),
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json" }
}
});
}
catch (NotFoundException e)
{
return(new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.NotFound,
Body = "Your game is out of date! Download the newest version\n" + e.Message,
});
}
catch (FleetCapacityExceededException e)
{
return(new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.InternalServerError,
Body = "Our game servers are too busy right now, come back later!\n" + e.Message,
});
}
catch (Exception e)
{
return(new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.InternalServerError,
Body = "An unexpected error occurred! Please notify the developers.\n" + e.Message,
});
}
}
