private void Setup(MoveMessage setupMessage)
{
Log("Let's setup");
var map = Converter.Convert(setupMessage.map);
var myPunter = setupMessage.punter;
scorer.Init(map);
punter.Init(map, setupMessage.punters, new Punter {
Id = myPunter
});
var gameStateMessage = new GameStateMessage
{
MapContract = setupMessage.map,
Moves = new List <MoveCommand>(),
Punters = setupMessage.punters,
MyPunter = myPunter,
ScorerState = scorer.State,
PunterState = punter.State
};
transport.Send(new SetupCommand {
ready = myPunter, state = gameStateMessage
});
}
private void OnGameStateHandler(GameStateMessage gameStateMessage)
{
if (gameStateMessage.GameState == GameState.Playing && (GameManager.PreviousGameState == GameState.Menu || gameStateMessage.GameState == GameState.GameOver))
{
_Starfield.StarfieldSeed = Random.Range(0, int.MaxValue);
}
}
private void OnGameStatusChanged(GameStateMessage message)
{
TriggerPropertyChanged("IsPaused");
TriggerPropertyChanged("RemainedMines");
TriggerPropertyChanged("Flags");
TriggerPropertyChanged("State");
if (game.GameState == GameState.Failed)
{
IsMousePressed = false;
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
game.UpdateStatistics();
ShowLostWindow();
}));
}
else if (game.GameState == GameState.Success)
{
IsMousePressed = false;
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
game.UpdateStatistics();
ShowWonWindow();
}), DispatcherPriority.Input);
}
}
private void Listener()
{
var tcpClient = new TcpClient(Host, Config.Port);
Socket = tcpClient.Client;
var secureMessage = Socket.Receive <SecureMessage>();
var rsa = Config.CreateRsa();
rsa.ImportParameters(secureMessage.ToRsaParameters());
symmetric = new TripleDESCryptoServiceProvider();
symmetric.GenerateIV();
symmetric.GenerateKey();
Socket.SendRSA(new SecureReplyMessage(Nick, symmetric.Key, symmetric.IV), rsa);
var res = true;
while (res)
{
try
{
lastStateMessage = Socket.ReceiveTripleDES <GameStateMessage>(symmetric);
if (GameStateChanged != null)
{
GameStateChanged(lastStateMessage);
}
}
catch (SocketException se)
{
res = false;
}
}
}
private void OnGameStateResponse(NetworkMessage msg)
{
GameStateMessage message = msg.ReadMessage <GameStateMessage>();
_friendlyMonsterState = JsonConvert.DeserializeObject <Dictionary <int, int> >(message.HostMonsterState);
_enemyMonsterState = JsonConvert.DeserializeObject <Dictionary <int, int> >(message.GuestMonsterState);
_monstersWithAvailableMoves = _friendlyMonsterState.Keys.ToList();
}
void AnalyzeDiff(GameStateMessage gameStateMessage)
{
var priorityPlayer = gameStateMessage.turnInfo?.priorityPlayer;
if (priorityPlayer.HasValue)
{
State.PriorityPlayer = priorityPlayer.Value;
}
if (gameStateMessage.players != null)
{
foreach (var p in gameStateMessage.players)
{
// Update the players state
State.Players[p.systemSeatNumber] = p;
}
}
var currentGameObjects = AddNewGameObjects(gameStateMessage.gameObjects);
var annotationsByType = ParseAnnotations(gameStateMessage.annotations);
Log.Debug("Annotations: {annotationsByType}", annotationsByType.Select(x => (x.Key, x.Count())));
var objectIdChanges = ParseObjectIdChanges(annotationsByType);
var zoneTransfers = ParseZoneTransfers(annotationsByType, objectIdChanges);
var scries = ParseScryAnnotations(annotationsByType);
foreach (var(topIds, bottomIds) in scries)
{
State.HandleScryDone(topIds, bottomIds);
}
// Surveils should be handled by ZoneTransfers
var shuffles = ParseShuffles(annotationsByType);
// Clear the Mind draws in the same message with the shuffle
// so we have to handle shuffles before moves
State.HandleShuffles(shuffles);
State.HandleMoves(zoneTransfers);
var instanceIdsInZones = gameStateMessage.zones?.ToDictionary(z => zonesInfo[z.zoneId], z => z.objectInstanceIds);
var mulliganCount = gameStateMessage.players
?.FirstOrDefault(i => i.systemSeatNumber == State.MySeatId)
?.mulliganCount ?? 0;
if (mulliganCount > State.MyMulliganCount)
{
// Mulligan
State.MyMulliganCount = mulliganCount;
State.DrawHands(instanceIdsInZones, currentGameObjects);
}
State.SetGameObjects(instanceIdsInZones, currentGameObjects);
}
private void BroadcastGameState()
{
var newMsg = new GameStateMessage
{
SceneObjects = map.SceneObjects
};
this.ReplyToAll(newMsg);
}
//Hook to receive & update game state
public void OnStateUpdate(NetworkMessage netMsg)
{
GameStateMessage msg = netMsg.ReadMessage <GameStateMessage>();
playerList = msg.playerList;
teamScores = msg.teamScores;
((TeamDeathmatch)currentGamemode).timeRemaining = msg.gamemodeTimeLeft;
SaveLoad.SaveGame();
}
private void OnGameStateHandler(GameStateMessage gameStateMessage)
{
if (gameStateMessage.GameState == GameState.Pause)
{
gameObject.SetActive(true);
}
else
{
gameObject.SetActive(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="Message"></param>
protected void HandleGameStateMessage(GameStateMessage Message)
{
// set connection state
connectionState = ConnectionState.Online;
// log
Logger.Log(MODULENAME, LogType.Info, "ConnectionState: Online");
// start pinging
timPing.Enabled = true;
}
private void OnGameStateResponse(NetworkMessage msg)
{
GameStateMessage message = msg.ReadMessage <GameStateMessage>();
message.ActionNumber = AdjustActionNumber(message.ActionNumber);
//Convert json strings to objects
Dictionary <int, int> friendlyMonsterState = IsHost ? JsonConvert.DeserializeObject <Dictionary <int, int> >(message.HostMonsterState) : JsonConvert.DeserializeObject <Dictionary <int, int> >(message.GuestMonsterState);
Dictionary <int, int> enemyMonsterState = IsHost ? JsonConvert.DeserializeObject <Dictionary <int, int> >(message.GuestMonsterState) : JsonConvert.DeserializeObject <Dictionary <int, int> >(message.HostMonsterState);
GameState.UpdateGameState(message.ActionNumber, message.SubActionNumber, friendlyMonsterState, enemyMonsterState);
}
private void BroadcastGameState(params GameHost[] games)
{
foreach (var game in games)
{
var newMsg = new GameStateMessage
{
GameId = game.Id,
SceneObjects = game.Map.SceneObjects
};
this.ReplyToAll(game.Id, newMsg);
}
}
public void OnGameStateChange(NetworkMessage netMsg)
{
GameStateMessage _msg = netMsg.ReadMessage <GameStateMessage>();
Debug.Log("OnGameStateChange ");
if (_msg.gamestate.Equals("pause"))
{
OnlineGameManager.Instance.m_state = OnlineGameManager.STATE.Pause;
UIInterface.Instance.SetTextDisplay("Pause", true);
}
else
{
OnlineGameManager.Instance.m_state = OnlineGameManager.STATE.Playing;
UIInterface.Instance.SetTextDisplay("Pause", false);
}
}
private static GameState InitGameState(GameStateMessage state, List <MoveCommand> moves, IScorer scorer, IPunter punter)
{
state.Moves.AddRange(moves);
var map = Converter.Convert(state.MapContract, state.Moves);
scorer.State = state.ScorerState;
punter.State = state.PunterState;
var gameState = new GameState {
Map = map, CurrentPunter = new Punter {
Id = state.MyPunter
}
};
return(gameState);
}
void OnGameState(NetworkMessage message)
{
GameStateMessage newState = message.ReadMessage <GameStateMessage>();
if (gameState == null || newState.gameTime >= gameState.gameTime)
{
gameState = newState;
score = gameState.score;
Time.timeScale = gameState.isPause?0:1;
spaceship.nextDirection = gameState.playerDirection;
AsteroidController asteroid;
for (int i = 0; i < gameState.objects.Length; i++)
{
asteroid = PoolManager.instance.GetObjectByID(i) as AsteroidController;
asteroid.state = gameState.objects[i];
}
}
}
// server call
public void OnPauseGame()
{
isPause = !isPause;
GameStateMessage msg = new GameStateMessage();
msg.gamestate = (isPause) ? "pause" : "unpause";
m_state = (isPause) ? STATE.Pause : STATE.Playing;
UIInterface.Instance.SetTextDisplay("Pause", isPause);
if (isHost)
{
GameObject.Find("LobbyManager").GetComponent <LobbyManager>().ServerSendGameState(msg);
}
else
{
GameObject.Find("LobbyManager").GetComponent <LobbyManager>().ClientSendGameState(msg);
}
}
IEnumerator SendState()
{
while (isGameStarted)
{
gameState = new GameStateMessage();
gameState.gameTime = GameTimer.instance.GetGameTime();
gameState.score = score;
gameState.isPause = isPause;
gameState.playerDirection = spaceship.direction;
gameState.objects = new AsteroidState[PoolManager.instance.ObjectsCount];
for (int i = 0; i < PoolManager.instance.ObjectsCount; i++)
{
AsteroidController asteroid = PoolManager.instance.GetObjectByID(i) as AsteroidController;
gameState.objects[i] = asteroid.state;
}
MultiplayerManager.instance.SendGameStateMessge(gameState);
yield return(new WaitForSeconds(0.1f));
}
}
private void OnGameStateChanged(GameStateMessage message)
{
var game = message.Source as IClearMine;
if (IsEnabled && game != null)
{
if (game.GameState == GameState.Failed)
{
Player.Play(this["Lost"].Value as string);
}
else if (game.GameState == GameState.Success)
{
Player.Play(this["Won"].Value as string);
}
else if (game.GameState == GameState.Initialized)
{
Player.Play(this["New"].Value as string);
}
else
{
// Play nothing.
}
}
}
public void ClientSendGameState(GameStateMessage _msg)
{
Debug.Log("ClientSendGameState");
m_client.Send(SendMsgType.GameState, _msg);
}
public static void OnGameStateChanged(GameStateMessage arg) => GameStateChanged?.Invoke(arg);
private void Start()
{
_currentUserId = PreferencesFactory.GetString(Constants.ProfileUserId);
if (ShouldGetChallengesList)
{
RefreshChallengesList();
}
GS.GameSparksAuthenticated = (playerId) => {
_currentUserId = playerId;
// connection was interupted
// user now reconnect but challenge was canceled
if (GameSparksManager.Instance.GetCurrentChallengeId() != null)
{
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnErrorReceived(LocaliseText.Get("Challenge.NotAvailable"));
}
}
};
ChallengeIssuedMessage.Listener = (listener) =>
{
_currentChallengeId = listener.Challenge.ChallengeId;
GameSparksManager.Instance.SetCurrentChallengeId(_currentChallengeId);
var challengerId = listener.Challenge.Challenger.Id;
if (_currentUserId != challengerId)
{
var username = listener.Challenge.Challenger.Name;
if (_onChallengeDetected != null)
{
if (!_isRematch)
{
_onChallengeDetected.OnChallengeIssued(_currentChallengeId, username);
}
else
{
new AcceptChallengeRequest()
.SetChallengeInstanceId(_currentChallengeId)
.Send((response) => { });
}
}
}
};
ChallengeStartedMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var challenge = listener.Challenge;
if (challenge != null)
{
if (_currentUserId == null)
{
_currentUserId = PreferencesFactory.GetString(Constants.ProfileUserId);
}
_currentChallengeId = challenge.ChallengeId;
GameSparksManager.Instance.SetCurrentChallengeId(_currentChallengeId);
var acceptedPlayersEnumerator = challenge.Accepted.GetEnumerator();
var challengedEnumerator = challenge.Challenged.GetEnumerator();
var challenger = new Challenge
{
ChallengeId = challenge.ChallengeId,
UserName = challenge.Challenger.Name,
UserId = challenge.Challenger.Id,
AvatarUploadId = challenge.ScriptData.GetGSData(challenge.Challenger.Id).GetString("avatarUploadId"),
ExternalIds = challenge.ScriptData.GetGSData(challenge.Challenger.Id).GetGSData("externalIds")
};
GameSparksManager.Instance.Challenger = challenger;
while (challengedEnumerator.MoveNext())
{
var playerDetail = challengedEnumerator.Current;
if (playerDetail != null)
{
var challenged = new Challenge
{
ChallengeId = challenge.ChallengeId,
UserName = playerDetail.Name,
UserId = playerDetail.Id,
AvatarUploadId = challenge.ScriptData.GetGSData(playerDetail.Id).GetString("avatarUploadId"),
ExternalIds = challenge.ScriptData.GetGSData(playerDetail.Id).GetGSData("externalIds")
};
GameSparksManager.Instance.Challenged = challenged;
}
}
challengedEnumerator.Dispose();
while (acceptedPlayersEnumerator.MoveNext())
{
var playerDetail = acceptedPlayersEnumerator.Current;
if (playerDetail != null)
{
if (playerDetail.Id != _currentUserId)
{
var opponent = new Challenge
{
ChallengeId = challenge.ChallengeId,
UserName = playerDetail.Name,
UserId = playerDetail.Id,
AvatarUploadId = challenge.ScriptData.GetGSData(playerDetail.Id).GetString("avatarUploadId"),
ExternalIds = challenge.ScriptData.GetGSData(playerDetail.Id).GetGSData("externalIds")
};
GameSparksManager.Instance.Opponent = opponent;
}
}
}
acceptedPlayersEnumerator.Dispose();
var nextPlayerId = challenge.NextPlayer;
var isMyTurn = nextPlayerId == _currentUserId;
GameSparksManager.Instance.SetIsMyTurn(isMyTurn);
List <GSData> words = null;
var gsData = listener.Challenge.ScriptData;
_isRematch = false;
GameSparksManager.Instance.SetGameMode(GameMode.Multi);
if (gsData != null)
{
words = gsData.GetGSDataList("words");
GameSparksManager.Instance.SetWords(words);
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnChallengeStarted(isMyTurn, GameSparksManager.Instance.Challenger.UserName, GameSparksManager.Instance.Challenged.UserName);
}
}
if (words == null)
{
DialogManager.Instance.ShowError(LocaliseText.Get("Game.ChallengerNotCreated"), doneCallback: (DialogInstance dialogInstance) => {
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnErrorReceived("REJOIN_LOBBY");
}
});
return;
}
if (SceneManager.GetActiveScene().name != "Game")
{
GameManager.LoadSceneWithTransitions("Game");
}
}
}
else
{
MyDebug.Log("Challenge Started Error: " + listener.Errors.JSON.ToString());
}
};
ChallengeTurnTakenMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var challenge = listener.Challenge;
_currentChallengeId = challenge.ChallengeId;
var nextPlayerId = challenge.ScriptData.GetString("nextPlayer");
var isMyTurn = nextPlayerId == _currentUserId;
GameSparksManager.Instance.SetIsMyTurn(isMyTurn);
var scriptData = challenge.ScriptData;
if (scriptData != null)
{
var eventKey = scriptData.GetString("EventKey");
if (eventKey == "WordFound" && scriptData != null &&
scriptData.GetString("SenderPlayerId") != _currentUserId &&
scriptData.ContainsKey("WordFound"))
{
GSData wordFound = scriptData.GetGSData("WordFound");
if (wordFound.ContainsKey("state"))
{
WordState state = (WordState)wordFound.GetInt("state");
string word = wordFound.GetString("word");
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnWordFound(word, state);
}
}
else // backward compability
{
if (scriptData.ContainsKey("found_words"))
{
List <GSData> found_words = scriptData.GetGSDataList("found_words");
foreach (GSData _w in found_words)
{
string word = _w.GetString("word");
string player_id = _w.GetString("player_id");
if (_onChallengeDetected != null && player_id != _currentUserId)
{
_onChallengeDetected.OnWordFound(word, WordState.Found);
}
}
}
}
}
var wordDrag = scriptData.GetGSData("WordDrag");
if (eventKey == "WordDrag" && wordDrag != null &&
wordDrag.ContainsKey("positions"))
{
if (scriptData.GetString("SenderPlayerId") != _currentUserId)
{
List <DrawQueueItem> _positions = new List <DrawQueueItem>();
var center = Vector3.zero;
if (wordDrag.ContainsKey("positions"))
{
List <GSData> _l = wordDrag.GetGSDataList("positions");
foreach (GSData _d in _l)
{
string json = _d.GetString("item");
_positions.Add(new DrawQueueItem(json));
}
}
if (wordDrag.ContainsKey("center_x") && wordDrag.ContainsKey("center_y"))
{
float cx = (float)wordDrag.GetFloat("center_x");
float cy = (float)wordDrag.GetFloat("center_y");
float cz = (float)wordDrag.GetFloat("center_z");
center = new Vector3(cx, cy, cz);
}
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnPositionDetected(_positions, center);
}
}
}
if (((eventKey == "takeTurn" || eventKey == null) &&
scriptData.GetString("SenderPlayerId") != _currentUserId &&
scriptData.GetString("SenderPlayerId") != nextPlayerId) ||
scriptData.GetBoolean("TimeOut") != null)
{
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnTurnEnd(Vector3.zero, "word");
}
}
}
}
else
{
MyDebug.Log("Challenge Turn Taken Error: " + listener.Errors.JSON.ToString());
}
};
ChallengeDeclinedMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var challenge = listener.Challenge;
if (challenge != null)
{
var declined = challenge.Declined;
var enumerator = declined.GetEnumerator();
while (enumerator.MoveNext())
{
var playerDetail = enumerator.Current;
var playerName = playerDetail.Name;
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnChallengeDeclined(playerName);
}
}
enumerator.Dispose();
}
}
};
ChallengeExpiredMessage.Listener = (listener) => { RefreshChallengesList(); };
ScriptMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var extCode = listener.ExtCode;
if (extCode == "userLeaved")
{
var gameStateMessage = new GameStateMessage
{
Message = listener.Summary,
Points = 0
};
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Leaved, gameStateMessage);
}
}
if (extCode == "userTurn")
{
}
}
};
ChallengeWonMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
if (StringUtils.IsNullOrWhiteSpace(_currentChallengeId))
{
_currentChallengeId = GameSparksManager.Instance.GetCurrentChallengeId();
}
if (_currentChallengeId != null && _currentChallengeId.Equals(listener.Challenge.ChallengeId))
{
var scriptData = listener.Challenge.ScriptData;
if (scriptData != null)
{
var points = 0;
var point = scriptData.GetInt("winPoints");
if (point != null)
{
points = (int)point;
}
var message = LocaliseText.Get("Game.CongratsYouWon");
if (_onChallengeDetected != null)
{
var gameStateMessage = new GameStateMessage
{
Message = message,
Points = points
};
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Won,
gameStateMessage);
}
}
}
};
ChallengeDrawnMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
if (StringUtils.IsNullOrWhiteSpace(_currentChallengeId))
{
_currentChallengeId = GameSparksManager.Instance.GetCurrentChallengeId();
}
if (_currentChallengeId.Equals(listener.Challenge.ChallengeId))
{
var scriptData = listener.Challenge.ScriptData;
if (scriptData != null && scriptData.GetNumber("drawPoints") != null)
{
int points = (int)scriptData.GetNumber("drawPoints");
var message = "It's a draw game!";
if (_onChallengeDetected != null)
{
var gameStateMessage = new GameStateMessage
{
Message = message,
Points = points
};
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Draw,
gameStateMessage);
}
}
}
};
ChallengeLostMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
if (StringUtils.IsNullOrWhiteSpace(_currentChallengeId))
{
_currentChallengeId = GameSparksManager.Instance.GetCurrentChallengeId();
}
if (_currentChallengeId.Equals(listener.Challenge.ChallengeId))
{
var scriptData = listener.Challenge.ScriptData;
if (scriptData != null)
{
var points = 0;
var point = scriptData.GetInt("losePoints");
if (point != null)
{
points = (int)point;
}
var message = "You Lost. Better luck next time!";
if (_onChallengeDetected != null)
{
var gameStateMessage = new GameStateMessage
{
Message = message,
Points = points
};
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Lost,
gameStateMessage);
}
}
}
};
AchievementEarnedMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
var achievementName = listener.AchievementName;
if (_onAchievementDetected != null)
{
_onAchievementDetected.OnAchievmentEarned(achievementName);
}
};
}
public void ServerSendGameState(GameStateMessage _msg)
{
Debug.Log("ServerSendGameState");
NetworkServer.SendToAll(SendMsgType.GameState, _msg);
}
public void SendGameStateMessge(GameStateMessage message)
{
NetworkServer.SendToAll(GameMsgType.GameState, message);
}
