/// <summary> /// Starts game from game data /// </summary> /// <param name="response"></param> public void LoadGameScene(StartGameResponse response) { Debug.Log("Loading game"); GameDataToStart = response; SceneManager.LoadScene(GameSceneName); }
public HttpResponseMessage Start([ModelBinder(typeof(JsonNetModelBinder))] StartGameRequest request) { var room = Data.FindRoom(request.GameName); if (room == null) { var startGameFailedResponse = new StartGameResponse() { Result = false }; return(new JsonNetResponseMessage(startGameFailedResponse)); } if (room.Game != null) { var startGameFailedResponse = new StartGameResponse() { Result = false }; return(new JsonNetResponseMessage(startGameFailedResponse)); } room.Game = new Game(room.Players, room.GameSetting.Difficultly); var response = new StartGameResponse() { Result = true }; return(new JsonNetResponseMessage(response)); }
/// <summary> /// When the start game message comes from the server it starts the game /// </summary> /// <param name="startGameResponse">Start game response.</param> private void ProcessStartGame(StartGameResponse startGameResponse) { Debug.Log("Starting game now"); opponentPaddle.GetComponent <Renderer>().enabled = true; ball.GetComponentsInChildren <Renderer>()[0].enabled = true; gameLogic.StartGame(); }
public async Task <ActionResult <StartGameResponse> > StartGame(string gameId) { var startGame = await _GameLogic.StartGameAsync(gameId).ConfigureAwait(false); var response = new StartGameResponse() { Started = startGame }; return(Ok(response)); }
public async Task <StartGameResponse> StartGame(string lobbyName) { MessageListener <StartGameResponse> startGameResponseListener = new MessageListener <StartGameResponse>(); startGameResponseListener.Subscribe(_messageProcessor); StartGameRequest startGameRequest = new StartGameRequest(Guid.NewGuid(), lobbyName, _loggedInUser.Id); await _networkConnector.SendMessageAsync(startGameRequest, CancellationToken.None); StartGameResponse startGameResponse = await startGameResponseListener.ReceiveMessageAsync(); startGameResponseListener.Unsubscribe(); return(startGameResponse); }
private void StartGame(StartGameResponse response) { Debug.Log("Starting game"); PlayerManager.Instance.Initialize(); GameID = Guid.Parse(response.GameState.GameID); PlayerManager.Instance.SetPlayerState(response.GameState.MainPlayer); PlayerManager.Instance.SetEnemyState(response.GameState.EnemyPlayer); FieldManager.Instance.GenerateMainField(response.GameState.MainField); FieldManager.Instance.GenerateEnemyField(response.GameState.EnemyField); }
/// <summary> /// Начинает игру, если все игроки готовы /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void StartGame(object sender, ResponseEventArgs e) { StartGameResponse response = e.Response as StartGameResponse; if (response != null) { if (response.IsSuccess) { _stateGame = StateGame.Game; SetEnableControls(_stateGame); ClientManager.Instance.Callback.RemoveHandler <StartGameResponse>(); TransferTurn(response.NextShotUserId); } } }
private void HandleStartGameResponseEvent(object sender, StartGameResponseEventArgs e) { var startGameResponse = new StartGameResponse { RequestingClientMac = e.RequestingClientMac, RespondingClientMac = e.RespondingClientMac, StartGameAccepted = e.StartGameAccepted }; var msg = new Message() { MessageId = StartGameResponse.MessageId, Contents = startGameResponse }; Events.OnSendMessageEvent(this, new ByteArrayEventArgs(msg.Serialize())); }
public async Task <StartGameResponse> ConfirmToPlay(int playerId) { StartGameResponse response; Logger.Info("Player{0} requested to confirm", playerId); IGame game = Logic.GetGameByPlayerId(playerId); bool isConfirmed = false; bool yourTurn = game.Players[0].OnlineId == playerId; ManualResetEvent waitHandle = new ManualResetEvent(false); PropertyChangedEventHandler stateEventHandler = null; stateEventHandler = (s, e) => { if (game.State.Equals(GameState.Confirmed)) { Logger.Info("Player{0} vs Player{1} - game status was changed to Confirmed", game.Players[0].OnlineId, game.Players[1].OnlineId); game.OnStateChanged -= stateEventHandler; waitHandle.Set(); } else { Logger.Warning("Player{0} vs Player{1} - game status was changed to {2}. It should be changed only to Confirmed.", null, game.Players[0].OnlineId, game.Players[1].OnlineId, game.State); } }; game.OnStateChanged += stateEventHandler; Logic.ConfirmPlayer(playerId); Logger.Info("Player{0} confirmed", playerId); isConfirmed = waitHandle.WaitOne(10000); int rivalId = game.Players.SingleOrDefault(p => p.OnlineId != playerId).OnlineId; if (isConfirmed) { Logger.Info("Request confirmed by Player{0}'s rival, Player{1}", playerId, rivalId); } else { Logger.Info("Timeout! Player{0} didn't confirm his request to play. " + "Player{1} will be looking for rival again.", rivalId, playerId); Logic.RunningGames.Remove(game); } response = new StartGameResponse(isConfirmed, playerId, yourTurn); Logger.Info("StartGameResponse was send back to client: Player{0}", playerId); return(await Task.Factory.StartNew(() => response)); }
private async Task <List <IPlayer> > RequestOnlinePlayer() { var players = new List <IPlayer>(); OnlineGameResponse waitingResponse = new OnlineGameResponse(); isRequestingOnlineGame = true; while (!waitingResponse.IsReady && !isOnlineGameRequestCancelled) { waitingResponse = await proxy.OnlineGameRequest(myOnlineId); myOnlineId = waitingResponse.PlayerId; //Quit requesting online game when isOnlineGameRequestCancelled is true //(user is not in online game page) if (isOnlineGameRequestCancelled) { break; } if (waitingResponse.IsReady) { StartGameResponse startGameResponse = await proxy.ConfirmToPlay(waitingResponse.PlayerId); if (startGameResponse.IsConfirmed) { if (startGameResponse.YourTurn) { players.Add(playerFactory.Create(PlayerType.Human, waitingResponse.PlayerId)); players.Add(playerFactory.Create(PlayerType.OnlinePlayer, 0)); } else { players.Add(playerFactory.Create(PlayerType.OnlinePlayer, 0)); players.Add(playerFactory.Create(PlayerType.Human, waitingResponse.PlayerId)); } } else { waitingResponse.IsReady = false; } } } isRequestingOnlineGame = false; return(players); }
public async Task <StartGameResponse> TryStartNewGame() { StartGameResponse ret = null; using (var client = new HttpClient()) { var response = await client.GetAsync($"{ _baseAddress }/{ API_CONTROLLER }"); if (response.IsSuccessStatusCode) { var json = await response.Content.ReadAsStringAsync(); ret = JsonConvert.DeserializeObject <StartGameResponse>(json); } } return(ret); }
/// <summary> /// Instructs the PlayFab game server hosting service to instantiate a new Game Server Instance /// </summary> public static void StartGame(StartGameRequest request, StartGameCallback resultCallback, ErrorCallback errorCallback, object customData = null) { if (PlayFabSettings.DeveloperSecretKey == null) { throw new Exception("Must have PlayFabSettings.DeveloperSecretKey set to call this method"); } string serializedJson = JsonConvert.SerializeObject(request, Util.JsonFormatting, Util.JsonSettings); Action <CallRequestContainer> callback = delegate(CallRequestContainer requestContainer) { StartGameResponse result = ResultContainer <StartGameResponse> .HandleResults(requestContainer, resultCallback, errorCallback); if (result != null) { } }; PlayFabHTTP.Post("/Matchmaker/StartGame", serializedJson, "X-SecretKey", PlayFabSettings.DeveloperSecretKey, callback, request, customData); }
/// <summary> /// Starts match between two players and sends them game info /// </summary> /// <param name="match"></param> public void StartMatch(GameMatch match) { Console.WriteLine($"Starting match"); StartGameResponse response = new StartGameResponse { GameState = GetPlayer1MatchStateData(match) }; Server.SendDataToClient(match.Player1.ClientID, (int)DataTypes.StartGameResponse, response); if (match.GameMode == GameMode.Practice) { return; } response = new StartGameResponse { GameState = GetPlayer2MatchStateData(match) }; Server.SendDataToClient(match.Player2.ClientID, (int)DataTypes.StartGameResponse, response); }
/// <summary> /// Try to find a game. /// </summary> /// <returns>required data for starting the game</returns> public StartGameResponse FindGame() { StartGameResponse ret; // make sure only 2 players enter the game creation _semaphoreMatchmaking.WaitOne(); // determine the game id (same id for both players) int gameId = _maxId + 1; // wait until both players have set the game id (this makes sure they have the same id) _barrierGameCreationSync.SignalAndWait(); // make sure only the first of the two players creates the game _mutexGameCreation.WaitOne(); bool isFirst = !Matches.ContainsKey(gameId); if (isFirst) { // first player's part: create a new game Matches.Add(gameId, new ChessMatchSession(gameId)); _maxId++; // now that the game is created, let the second player enter the section _mutexGameCreation.ReleaseMutex(); } else { // let the next 2 players enter the game creation section _mutexGameCreation.ReleaseMutex(); _semaphoreMatchmaking.Release(2); } // return the required response data ret = new StartGameResponse() { GameId = gameId, IsFirst = isFirst }; return(ret); }
/// <summary> /// Try to find a chess match. Init the session accordingly if successful. Otherwise retry up to 3 times. /// </summary> /// <param name="timeout">the timeout in seconds</param> /// <returns>a boolean indicating whether the matchmaking was successful</returns> public bool FindMatch(int timeout = 300) { bool ret = false; for (int i = 0; i < 3; i++) { try { var task = httpHelper.TryStartNewGame(); if (task.Wait(timeout * 1000)) { _gameInfo = task.Result; ret = true; break; } } catch (Exception) { /* nothing to do here ... */ } } return(ret); }
private void ProcessRestartGameRequest(RestartGameRequest request, int clientID) { Console.WriteLine($"Request to restart game 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 not in the game"); return; } GameMatch match = player.Match; if (!match.IsRunning) { Console.WriteLine($"Match isn't running"); return; } int[,] field = CreateField(match.Width - match.Difficulty, match.Height - match.Difficulty); StartGameResponse response = new StartGameResponse(); response.CardPackName = match.CardPackName; response.Difficulty = match.Difficulty; response.PlayerID = 0; response.Field = field; Server.SendDataToClient(match.Player1.ClientID, (int)DataTypes.StartGameResponse, response); response.PlayerID = 1; Server.SendDataToClient(match.Player2.ClientID, (int)DataTypes.StartGameResponse, response); Console.WriteLine($"Player {clientID} successfully joined"); }
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); } }
private void HandleStartGameResponse(StartGameResponse response) { GameManager.Instance.LoadGameScene(response); }
public void StartGame(StartGameResponse response) { syncContext.Post(new SendOrPostCallback(OnBroadcast <StartGameResponse>), response); }
private void ProcessJoinGameRequest(JoinGameRequest request, int clientID) { Console.WriteLine($"Request to join room {request.RoomID} 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) { if (player.Match.IsRunning) { Console.WriteLine($"Player {clientID} is already in the game"); return; } } if (string.IsNullOrWhiteSpace(request.RoomID)) { Console.WriteLine($"Room ID can't be empty"); return; } GameMatch match = matches.FirstOrDefault(m => m.RoomID == request.RoomID); if (match == null) { Console.WriteLine($"Room {request.RoomID} doesn't exist"); return; } if (player.Match != null) { if (match == player.Match) { Console.WriteLine($"Player {player.ClientID} trying to join same room {match.RoomID}"); return; } DropRoom(player.Match); } player.Name = request.PlayerName; match.Player2 = player; match.IsRunning = true; player.Match = match; Console.WriteLine($"Player {clientID} successfully joined"); int[,] field = CreateField(match.Width - match.Difficulty, match.Height - match.Difficulty); StartGameResponse response = new StartGameResponse(); response.CardPackName = match.CardPackName; response.Difficulty = match.Difficulty; response.Field = field; response.PlayersNames = match.GetPlayersNames(); response.PlayerID = 0; Server.SendDataToClient(match.Player1.ClientID, (int)DataTypes.StartGameResponse, response); response.PlayerID = 1; Server.SendDataToClient(match.Player2.ClientID, (int)DataTypes.StartGameResponse, response); Console.WriteLine($"Match {match.RoomID} started"); }
protected virtual void OnStartGameResponse(object source, EventArgs e) { StartGameResponse?.Invoke(source, e); }