public override void restartGame(RestartMessage restartMessage)
{
base.restartGame(restartMessage);
lifeLeft = DifficultySettings.startGameHealth;
startTime = Time.time;
isPlaying = true;
}
public void TestHandleRestartSameGame()
{
string uid = "uid";
string userName = "******";
CreateExistingGame();
JoinGame(uid, userName, ExistingGameName);
JoinGame("uid2", "2", ExistingGameName);
JoinGame("uid3", "3", ExistingGameName);
MessagePackets messages = gm.HandleRestart(new RestartMessage(userName, true));
CollectionAssert.DoesNotContain(gm.GetPlayers().Select(p => p.Uid).ToList(), uid);
Assert.IsFalse(gm.HasEnded());
Assert.IsTrue(gm.HasStarted());
Assert.IsTrue(Utils.VerifyMessagePackets(messages, typeof(RestartMessage), typeof(DisconnectMessage)));
RestartMessage rm = (RestartMessage)messages.Messages[0].Message;
Assert.AreEqual(messages.Messages[0].SendTo.Count(), 1);
Assert.AreEqual(messages.Messages[0].SendTo.Single(), uid);
Assert.AreEqual(rm.PlayerName, userName);
Assert.IsTrue(rm.NewGame);
DisconnectMessage d = (DisconnectMessage)messages.Messages[1].Message;
Assert.AreEqual(messages.Messages[1].SendTo.Count(), 1);
Assert.AreEqual(messages.Messages[1].SendTo.Single(), ExistingUid);
Assert.AreEqual(d.PlayerName, userName);
Assert.IsFalse(d.ShouldDisableGame);
}
public override void restartGame(RestartMessage restartMessage)
{
foreach (uint id in spawnedEnemies.Keys)
{
Destroy(spawnedEnemies[id].gameObject);
}
spawnedEnemies.Clear();
}
private void btnRestart_Click(object sender, EventArgs e)
{
foreach (ListViewItem item in this.listView1.SelectedItems)
{
var restartMsg = new RestartMessage();
this.service.SendMessage((IntPtr)item.Tag, restartMsg);
}
}
public override void restartGame(RestartMessage restartMessage)
{
foreach (uint id in spawnedProjectiles.Keys)
{
try { Destroy(spawnedProjectiles[id].gameObject); } catch { }
}
spawnedProjectiles.Clear();
}
public override void restartGame(RestartMessage restartMessage)
{
this.enabled = true;
groupSpawnSize = startGroupSpawnSize;
groupSpawnDelay = startGroupSpawnDelay;
currentWaveLevel = 0;
nextWaveStartTime = Time.time + waveDuration;
}
public static void restartGame(RestartMessage restartMessage)
{
if (isServer == false)
{
return;
}
NetworkServer.SendToAll((short)CustomProtocol.RestartGame, restartMessage);
singleton.restartManagers(new GameObject[] { singleton.universalManagers, singleton.serverManagers }, restartMessage);
}
public void onRestartGamePressed()
{
if (CustomNetworkManager.isConnected)
{
PersistValues();
RestartMessage restartMessage = getDataFromRestartUI();
CustomNetworkManager.restartGame(restartMessage);
}
}
public static void UpdateFromRestartMessage(RestartMessage restartMessage)
{
roadLength = restartMessage.roadLength;
screenWidth = restartMessage.screenWidth;
screenHeight = restartMessage.screenHeight;
marginTop = restartMessage.marginTop;
marginBottom = restartMessage.marginBottom;
marginLeft = restartMessage.marginLeft;
marginRight = restartMessage.marginRight;
}
public override void restartGame(RestartMessage restartMessage)
{
purchuaseCosts.Clear();
purchuaseCosts.Add(PurchaseType.Damage, DifficultySettings.dmgUpgradeCost);
purchuaseCosts.Add(PurchaseType.Range, DifficultySettings.rangeUpgradeCost);
purchuaseCosts.Add(PurchaseType.Cooldown, DifficultySettings.cooldownUpgradeCost);
purchuaseCosts.Add(PurchaseType.Magazine, DifficultySettings.maxArrowsUpgradeCost);
currency = startCurrency;
broadcastCurrentCurrencyLevel();
}
private void handleRestartGameMsg(NetworkMessage msg)
{
RestartMessage restartMessage = msg.ReadMessage <RestartMessage>();
//Quick Hax in lack of priority list
DifficultySettings.dmgUpgradeCost = (uint)restartMessage.dmgCost;
DifficultySettings.rangeUpgradeCost = (uint)restartMessage.rangeCost;
DifficultySettings.cooldownUpgradeCost = (uint)restartMessage.cooldownCost;
DifficultySettings.maxArrowsUpgradeCost = (uint)restartMessage.magazineCost;
Debug.LogError("Setting cost: " + restartMessage.dmgCost);
restartManagers(new GameObject[] { singleton.universalManagers, singleton.clientManagers }, restartMessage);
}
private void HandleRestart(RestartMessage restartMessage)
{
ViewController.Instance.ClearGameLog();
ViewController.Instance.ShowGameOverWindow(false);
ViewController.Instance.ShowStoppedGame(false);
if (!restartMessage.NewGame)
{
ViewController.Instance.UpdateLog(restartMessage.PlayerName, "Restarted the game");
}
else
{
ViewController.Instance.ShowGameTypePopUp(true);
ViewController.Instance.ShowGameTable(false);
}
}
public override void restartGame(RestartMessage restartMessage)
{
if (CustomNetworkManager.isServer)
{
serverSettingsPanel.SetActive(false);
topPanelObject.SetActive(false);
gameOverPanel.SetActive(false);
setPosition(TabletPosition.Right);
}
dmgBuyTxt.text = "<b>" + DifficultySettings.dmgUpgradeCost + "$</b>";
rangeBuyText.text = "<b>" + DifficultySettings.rangeUpgradeCost + "$</b>";
cooldownBuyText.text = "<b>" + DifficultySettings.cooldownUpgradeCost + "$</b>";
magazineBuyText.text = "<b>" + DifficultySettings.maxArrowsUpgradeCost + "$</b>";
}
public override void restartGame(RestartMessage restartMessage)
{
StopAllCoroutines();
foreach (uint id in spawnedEnemies.Keys)
{
try { Destroy(spawnedEnemies[id].gameObject); }
catch { }
}
spawnedEnemies.Clear();
idCounter = 0;
difficultySettings = GetComponent <DifficultySettings>();
StartCoroutine(SpawnEnemyRoutine());
StartCoroutine(SpawnEnemyGroupRoutine());
}
/// <summary>
/// Get messages to send in response to a RestartMessage
/// </summary>
/// <param name="playerId"> The uid of the player </param>
/// <param name="restartMessage"></param>
/// <returns> List of messages to be sent </returns>
public MessagePackets HandleRestart(string playerId, RestartMessage restartMessage)
{
lock (this)
{
MessagePackets messages = new MessagePackets();
GameManager gm = GetGameManager(playerId);
messages.Add(Do(gm, () => gm.HandleRestart(restartMessage)));
if (restartMessage.NewGame)
{
RemovePlayer(playerId);
}
return(messages);
}
}
private RestartMessage getDataFromRestartUI()
{
RestartMessage restartMessage = new RestartMessage();
restartMessage.roadLength = int.Parse(roadLengthInput.text);
restartMessage.screenWidth = 6; //parseEnglishAndSwedishNotation(screenWidthInput.text);
restartMessage.screenHeight = 4; // parseEnglishAndSwedishNotation(screenHeightInput.text);
restartMessage.marginTop = 0.4666f; //parseEnglishAndSwedishNotation(marginTopInput.text);
restartMessage.marginBottom = 0.4666f; //parseEnglishAndSwedishNotation(marginBottomInput.text);
restartMessage.marginLeft = 0.5066666f; //parseEnglishAndSwedishNotation(marginLeftInput.text);
restartMessage.marginRight = 0.5066666f; //parseEnglishAndSwedishNotation(marginRightInput.text);
restartMessage.dmgCost = int.Parse(dmgCostInput.text);
restartMessage.rangeCost = int.Parse(rangeCostInput.text);
restartMessage.cooldownCost = int.Parse(cooldownCostInput.text);
restartMessage.magazineCost = int.Parse(magazineCostInput.text);
return(restartMessage);
}
/// <summary>
/// Handle a RestartMessage.
/// </summary>
/// <param name="restartMessage"></param>
/// <returns> List of messages to be sent </returns>
public MessagePackets HandleRestart(RestartMessage restartMessage)
{
if (!restartMessage.NewGame)
{
// Restart the same game
VerifyStarted();
Reset();
return(StartRound());
}
else
{
MessagePackets messages = new MessagePackets();
// Confirm restart request
Player player = Players.Where(p => p.Name == restartMessage.PlayerName).Single();
messages.Add(restartMessage, player.Uid);
// Inform other players the player left the old game
messages.Add(DisconnectPlayer(player));
return(messages);
}
}
private MessagePackets HandleMessage(string message)
{
RestartMessage restartMessage = JsonConvert.DeserializeObject <RestartMessage>(message);
if (restartMessage.IsValid())
{
return(GamesManager.Get().HandleRestart(ID, restartMessage));
}
GameTypeMessage gameTypeMessage = JsonConvert.DeserializeObject <GameTypeMessage>(message);
if (gameTypeMessage.IsValid())
{
return(GamesManager.Get().HandleGameTypes(ID, gameTypeMessage));
}
JoinMessage joinMessage = JsonConvert.DeserializeObject <JoinMessage>(message);
if (joinMessage.IsValid())
{
return(GamesManager.Get().HandleJoin(ID, joinMessage));
}
BidMessage bidMessage = JsonConvert.DeserializeObject <BidMessage>(message);
if (bidMessage.IsValid())
{
return(GamesManager.Get().HandleBid(ID, bidMessage));
}
KittyMessage kittyMessage = JsonConvert.DeserializeObject <KittyMessage>(message);
if (kittyMessage.IsValid())
{
return(GamesManager.Get().HandleKitty(ID, kittyMessage));
}
TrumpMessage trumpMessage = JsonConvert.DeserializeObject <TrumpMessage>(message);
if (trumpMessage.IsValid())
{
return(GamesManager.Get().HandleTrump(ID, trumpMessage));
}
MeldMessage meldMessage = JsonConvert.DeserializeObject <MeldMessage>(message);
if (meldMessage.IsValid())
{
return(GamesManager.Get().HandleMeld(ID, meldMessage));
}
PassMessage passMessage = JsonConvert.DeserializeObject <PassMessage>(message);
if (passMessage.IsValid())
{
return(GamesManager.Get().HandlePass(ID, passMessage));
}
TurnMessage turnMessage = JsonConvert.DeserializeObject <TurnMessage>(message);
if (turnMessage.IsValid())
{
return(GamesManager.Get().HandleTurn(ID, turnMessage));
}
return(new MessagePackets());
}
private void HandleMessage(string message)
{
try
{
lock (MessageTasks)
{
ErrorResponse errorResponse = JsonConvert.DeserializeObject <ErrorResponse>(message);
if (errorResponse.IsValid())
{
Debug.Log("ErrorResponse: " + errorResponse.ErrorMessage);
return;
}
DisconnectMessage disconnectMessage = JsonConvert.DeserializeObject <DisconnectMessage>(message);
if (disconnectMessage.IsValid())
{
HandleDisconnect(disconnectMessage);
return;
}
RestartMessage restartMessage = JsonConvert.DeserializeObject <RestartMessage>(message);
if (restartMessage.IsValid())
{
HandleRestart(restartMessage);
return;
}
GameTypeMessage gameTypeMessage = JsonConvert.DeserializeObject <GameTypeMessage>(message);
if (gameTypeMessage.IsValid())
{
ViewController.Instance.UpdateGameTypes(gameTypeMessage.GameTypes);
return;
}
JoinResponse joinResponse = JsonConvert.DeserializeObject <JoinResponse>(message);
if (joinResponse.IsValid())
{
HandleJoinResponse(joinResponse);
return;
}
AvailableGamesMessage gamesMessage = JsonConvert.DeserializeObject <AvailableGamesMessage>(message);
if (gamesMessage.IsValid())
{
ViewController.Instance.UpdateAvailableGames(gamesMessage.AvailableGames);
return;
}
JoinMessage joinMessage = JsonConvert.DeserializeObject <JoinMessage>(message);
if (joinMessage.IsValid())
{
HandleJoin(joinMessage);
return;
}
StartMessage startMessage = JsonConvert.DeserializeObject <StartMessage>(message);
if (startMessage.IsValid())
{
HandleStart(startMessage);
return;
}
BidMessage bidMessage = JsonConvert.DeserializeObject <BidMessage>(message);
if (bidMessage.IsValid())
{
HandleBid(bidMessage);
return;
}
KittyMessage kittyMessage = JsonConvert.DeserializeObject <KittyMessage>(message);
if (kittyMessage.IsValid())
{
HandleKitty(kittyMessage);
return;
}
TrumpMessage trumpMessage = JsonConvert.DeserializeObject <TrumpMessage>(message);
if (trumpMessage.IsValid())
{
HandleTrump(trumpMessage);
return;
}
MeldPointsMessage meldPointsMessage = JsonConvert.DeserializeObject <MeldPointsMessage>(message);
if (meldPointsMessage.IsValid())
{
HandleMeldPoints(meldPointsMessage);
return;
}
MeldMessage meldMessage = JsonConvert.DeserializeObject <MeldMessage>(message);
if (meldMessage.IsValid())
{
HandleMeld(meldMessage);
return;
}
PassMessage passMessage = JsonConvert.DeserializeObject <PassMessage>(message);
if (passMessage.IsValid())
{
HandlePass(passMessage);
return;
}
ScoreMessage scoreMessage = JsonConvert.DeserializeObject <ScoreMessage>(message);
if (scoreMessage.IsValid())
{
HandleScore(scoreMessage);
return;
}
TurnMessage turnMessage = JsonConvert.DeserializeObject <TurnMessage>(message);
if (turnMessage.IsValid())
{
HandleTurn(turnMessage);
return;
}
TrickMessage trickMessage = JsonConvert.DeserializeObject <TrickMessage>(message);
if (trickMessage.IsValid())
{
HandleTrick(trickMessage);
return;
}
TrickInfoMessage trickInfoMessage = JsonConvert.DeserializeObject <TrickInfoMessage>(message);
if (trickInfoMessage.IsValid())
{
HandleTrickInfo(trickInfoMessage);
return;
}
GameOverMessage gameOverMessage = JsonConvert.DeserializeObject <GameOverMessage>(message);
if (gameOverMessage.IsValid())
{
HandleGameOver(gameOverMessage);
return;
}
}
}
catch (Exception err)
{
Debug.Log("OnMessage error: " + err.Message);
Debug.Log("OnMessage stack trace: " + err.StackTrace);
}
}
public virtual void restartGame(RestartMessage restartMessage)
{
}
private void restartManagers(GameObject[] objs, RestartMessage restartMessage)
{
iterateManagers(objs, (BaseNetworkManager b) => b.restartGame(restartMessage));
}
public void HandleRestartMessage(RestartMessage restartMessage)
{
_dataManager.Restart();
}
public override void restartGame(RestartMessage restartMessage)
{
// Set correct values for the dimension manager from the restart message.
DimensionsManager.UpdateFromRestartMessage(restartMessage);
UpdateDimensions();
}
public override void restartGame(RestartMessage restartMessage)
{
}
