/// <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);
}
