public override void OnEndGame(EndGameMessage msg)
{
base.OnEndGame(msg);
var scene = GameObject.Find("GameScene").GetComponent <GameScene>();
scene.OpenPopup <PopupOneButton>("PopupOneButton", popup =>
{
if (msg.winnerPlayerIndex == playerInfo.netId)
{
popup.gameObject.GetComponent <SortingGroup>().sortingLayerName = "HandCards";
popup.gameObject.GetComponent <SortingGroup>().sortingOrder = 2500;
popup.text.text = "You win!";
}
else
{
popup.gameObject.GetComponent <SortingGroup>().sortingLayerName = "BoardCards";
popup.gameObject.GetComponent <SortingGroup>().sortingOrder = 2500;
popup.text.text = "You lose!";
}
popup.buttonText.text = "Exit";
popup.button.onClickEvent.AddListener(() =>
{
if (NetworkingUtils.GetLocalPlayer().isServer)
{
NetworkManager.singleton.StopHost();
}
else
{
NetworkManager.singleton.StopClient();
}
});
});
}
public void GameEnded()
{
EndGameMessage endGameMessage = new EndGameMessage();
int[] ranking = new int[4];
foreach (KeyValuePair <int, Player> player in lobby.players)
{
endGameMessage.scoreData.Add(new EndGameMessage.ScoreData {
playerID = player.Key, gold = player.Value.gold
});
}
endGameMessage.NumberOfScores = (byte)endGameMessage.scoreData.Count;
endGameMessage.scoreData.OrderBy(score => score.gold);
foreach (KeyValuePair <int, Player> player in lobby.players)
{
serverBehaviour.QeueMessage(new AdressedMessage(endGameMessage, player.Key));
}
Menu.Singleton.SetMenu(Menu.Menus.score);
Menu.Singleton.score.SetLastGameScores(lobby, endGameMessage.scoreData);
{
//upload score
List <EndGameMessage.ScoreData> scoreDataList = endGameMessage.scoreData.ToList();
for (int i = 0; i < scoreDataList.Count; i++)
{
ranking[i] = scoreDataList[i].playerID;
}
Menu.Singleton.score.UploadScore(ranking);
}
}
public void ShowScore(EndGameMessage message, List <PlayerData> players, PlayerData myData)
{
List <HighScorePair> highscores = new List <HighScorePair>();
for (int i = 0; i < message.PlayerIDHighscorePairs.Length; i++)
{
if (myData.playerIndex == message.PlayerIDHighscorePairs[i].playerID)
{
myData.score = message.PlayerIDHighscorePairs[i].score;
}
highscores.Add(message.PlayerIDHighscorePairs[i]);
}
highscores = highscores.OrderBy(x => x.score).Reverse().ToList();
nameText.text = "";
scoreText.text = "";
foreach (HighScorePair scores in highscores)
{
nameText.text += players.Find(x => x.playerIndex == scores.playerID).name + "\n";
scoreText.text += scores.score + "\n";
}
//upload score
if (DataBaseHandeler.userID != -1)
{
Debug.Log("user: "******"score: " + myData.score);
string url = "score_insert.php?user="******"&score=" + myData.score + "&session_id=" + DataBaseHandeler.sessionID;
StartCoroutine(DataBaseHandeler.GetHttp(url));
}
}
public void HandleEndGame(Message message)
{
EndGameMessage endGameMessage = (EndGameMessage)message;
Menu.Singleton.SetMenu(Menu.Menus.score);
Menu.Singleton.score.SetLastGameScores(lobby, endGameMessage.scoreData);
}
void EndGame(Player winner)
{
if (winner == Player.None)
{
Manager.UI.Message.SetText("Draw");
}
else if (winner == localRole)
{
Manager.UI.Message.SetText("You win!");
}
else
{
Manager.UI.Message.SetText("You lose!");
}
Manager.UI.Message.Show();
StopGame();
if (authoritative)
{
EndGameMessage message = new EndGameMessage();
message.Winner = winner;
Manager.Network.Engine.Send(message, LiteNetLib.SendOptions.ReliableOrdered);
}
}
public void ShowEndScreen(EndGameMessage message)
{
game.gameObject.SetActive(false);
resultScreen = Instantiate(Resources.Load <GameObject>("ResultScreen") as GameObject).GetComponent <ResultScreen>();
resultScreen.gameObject.name = "Result of player: " + myData.playerIndex;
resultScreen.ShowScore(message, players, myData);
}
private static EndGameMessage CreateEndGameMessage()
{
var endGameMessage = new EndGameMessage();
endGameMessage.BlueScore = CalculatePoints(RoleType.Blue);
endGameMessage.GreenScore = CalculatePoints(RoleType.Green);
return(endGameMessage);
}
public void EndGame(ref DataStreamReader reader)
{
var message = new EndGameMessage();
message.DeserializeObject(ref reader);
HighScorePair[] endScores = message.PlayerIDHighscorePairs;
dataHolder.ShowEndScreen(message);
}
public void TestEndGameMessage()
{
EndGameMessage origMessage = new EndGameMessage(1);
byte[] bytes = origMessage.Encode();
EndGameMessage decodedMessage = EndGameMessage.Decode(bytes);
Assert.AreEqual(origMessage.MessageType, 10, "Incorrect MessageType");
Assert.AreEqual(origMessage.MessageType, decodedMessage.MessageType, "MessageType did not match");
Assert.AreEqual(origMessage.GameId, decodedMessage.GameId, "GameId did not match");
}
public void OnGameEnd(NetworkMessage _networkMessage)
{
// Tell player object game is over
PlayerManager tempPlayer = NetworkHelper.GetObjectByNetIdValue <PlayerManager>((uint)this.clientPlayerInfo.playerObjectId, false);
// Read msg
EndGameMessage msg = _networkMessage.ReadMessage <EndGameMessage>();
// Run canvas routine
this.canvasManager.StartCoroutine(this.canvasManager.EndGameRoutine(msg.score, msg.names, msg.colours));
}
private void HandleEndGameMessage(String address, AbstractMessage message)
{
EndGameMessage endGameMessage = (EndGameMessage)message;
controller.SupressUpdate();
ScreenManager.GetInstance().RemoveLastScreen();
ScreenManager.GetInstance().AddScreen(new EndGameScreen(endGameMessage.Winner));
Controller.GetInstance().ClearGame();
controller.ReleaseUpdate();
}
public void InsertScore(MessageHeader message)
{
EndGameMessage endGame = message as EndGameMessage;
Debug.Log("EndGame");
for (int i = 0; i < endGame.numberOfScores; i++)
{
StartCoroutine(DatabaseManager.GetHttp($"InsertScore.php?User_ID={ PlayerManager.Instance.PlayersWhoLeft[endGame.playerID[i]].playerID} &Score={ endGame.highScorePairs[i] }&session_id={ DatabaseManager.sessionID }"));
}
Debug.Log("For end");
StatisticManager.Instance.UpdateStatistics();
}
private void OnEndGame(EndGameMessage msg, DateTime timestamp)
{
if (!this.IsGameOwner())
{
return;
}
this._gameManager.EndGame(this._gameHost);
foreach (var player in this._gameHost.Everyone)
{
this.Sessions.CloseSession(player.GameHostWebSocketId, 2008, "The game owner has ended the game");
}
}
public void EndGame()
{
HighScorePair[] highScorePairs = new HighScorePair[serverDataHolder.players.Count];
for (int i = 0; i < highScorePairs.Length; i++)
{
highScorePairs[i].playerID = serverDataHolder.players[i].playerIndex;
highScorePairs[i].score = (ushort)serverDataHolder.players[i].score;
}
EndGameMessage message = new EndGameMessage()
{
NumberOfScores = (byte)highScorePairs.Length,
PlayerIDHighscorePairs = highScorePairs
};
SendMessageToAll(message);
}
private EndGameMessage CreateEndGameMessage()
{
EndGameMessage ret = new EndGameMessage();
List <Player> players = controller.GetPlayers();
Player winner = null;
foreach (Player player in players)
{
if (player.GetCharacters().Exists(q => !q.Health.IsDead))
{
winner = player;
break;
}
}
ret.Winner = winner.Name;
return(ret);
}
//When a message is received to end the game
public void OnReceiveEndGameMessage(NetworkMessage networkMessage)
{
EndGameMessage endgame = networkMessage.ReadMessage <EndGameMessage> ();
if (isLocalPlayer)
{
Debug.Log("IsLocalPlayer");
if (BoundsChecker.checkValidBoundsTotal(endgame.x, bounds))
{
Instantiate(this.gameWinUI);
this.CmdReceiveEndGameMessage(false);
}
else
{
Instantiate(this.gameOverUI);
this.CmdReceiveEndGameMessage(true);
}
}
}
/// <summary>
/// Send to all clients when the game ends, with the high score in it.
/// </summary>
private void SendEndGame()
{
byte numberOfScore = System.Convert.ToByte(AllClientPlayerDictionary.Count);
List <int> playerIDs = new List <int>();
List <ushort> highScores = new List <ushort>();
// Get the high scores and sort them
foreach (KeyValuePair <Client, Player> keyValuePair in AllClientPlayerDictionary)
{
highScores.Add((ushort)keyValuePair.Value.TreasureAmount);
}
highScores.Sort(); // sort ascending
highScores.Reverse(); // reverse for descending
// get the corresponding player. If players have the same score this will just randomly decide whose the first and whose the second
foreach (int highScore in highScores)
{
foreach (KeyValuePair <Client, Player> clientPlayerPair in AllClientPlayerDictionary)
{
if (highScore == clientPlayerPair.Value.TreasureAmount)
{
playerIDs.Add(clientPlayerPair.Key.PlayerID);
}
}
}
// Send the message
var message = new EndGameMessage()
{
NumberOfScores = numberOfScore,
PlayerID = playerIDs,
HighScores = highScores
};
foreach (Client c in clientList)
{
server.SendMessage(message, c.Connection);
}
}
void OnTriggerEnter2D(Collider2D other)
{
//Check if this function has already been called
if (!this.getWin())
{
GameObject parentBlock = other.transform.parent.gameObject;
//If the parent is a deadblock, then end condition, sendd a message to stop the game
if (parentBlock.CompareTag("DeadBlock"))
{
setWin(true);
Debug.Log("Win! Game Over");
EndGameMessage endgame = new EndGameMessage();
endgame.player = 0;
endgame.message = "What a baller";
endgame.x = other.transform.position.x;
NetworkServer.SendToAll(7999, endgame);
}
}
}
public override void OnEndGame(EndGameMessage msg)
{
base.OnEndGame(msg);
var scene = GameObject.Find("GameScene").GetComponent <GameScene>();
scene.OpenPopup <PopupOneButton>("PopupOneButton", popup =>
{
if (msg.winnerPlayerIndex == playerInfo.netId)
{
popup.text.text = "人生の勝利者";
}
else
{
popup.text.text = "負け犬";
}
popup.buttonText.text = "閉じる";
popup.button.onClickEvent.AddListener(() =>
{
if (NetworkingUtils.GetLocalPlayer().isServer)
{
NetworkManager.singleton.StopHost();
}
else
{
NetworkManager.singleton.StopClient();
}
//追記
SceneManager.LoadScene("Home");
}
);
});
}
// Server
private void GameEnding()
{
Debug.Log("End Game!!");
// Find winner(s)
int highScore = 0;
// Find the highscore
for (int i = 0; i < this.numPlayers; i++)
{
if (this.playerScoreList[i] >= highScore)
{
highScore = this.playerScoreList[i];
}
}
// Store winner information
List <string> names = new List <string>();
List <Color> colours = new List <Color>();
for (int i = 0; i < this.numPlayers; i++)
{
if (this.playerScoreList[i] == highScore)
{
names.Add(this.playerInfoList[i].name);
colours.Add(this.playerInfoList[i].colour);
}
}
// Send msg
EndGameMessage msg = new EndGameMessage();
msg.score = highScore;
msg.names = names.ToArray();
msg.colours = colours.ToArray();
NetworkServer.SendToAll(CustomMsgType.EndGame, msg);
}
private INetworkMessage ReadCaveQuestMessage(DataStreamReader reader, Message message)
{
switch (message.messageType)
{
case MessageType.PlayerTurn:
var playerTurnMessage = new PlayerMessage(message.id, message.messageType);
playerTurnMessage.Deserialize(ref reader);
turn = playerTurnMessage.playerID == playerID;
UpdateUI(turn);
return(playerTurnMessage);
case MessageType.RoomInfo:
var roomInfo = new RoomInfo(message.id);
roomInfo.Deserialize(ref reader);
currentRoomInfo = roomInfo;
StartCoroutine(DrawRoom(roomInfo));
return(roomInfo);
case MessageType.PlayerEnterRoom:
var playerEnterRoom = new PlayerMessage(message.id, message.messageType);
playerEnterRoom.Deserialize(ref reader);
foreach (var textMesh in FindObjectsOfType <TextMesh>())
{
if (textMesh.text == playerEnterRoom.playerID.ToString())
{
Destroy(textMesh.transform.parent.gameObject);
break;
}
}
currentRoomInfo.numberOfOtherPlayers++;
var otherPlayerIDs = new NativeArray <int>(currentRoomInfo.numberOfOtherPlayers, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
for (int i = 0; i < currentRoomInfo.otherPlayerIDs.Length; i++)
{
var otherPlayerID = currentRoomInfo.otherPlayerIDs[i];
otherPlayerIDs[i] = otherPlayerID;
}
otherPlayerIDs[currentRoomInfo.numberOfOtherPlayers - 1] = playerEnterRoom.playerID;
currentRoomInfo.otherPlayerIDs = otherPlayerIDs.ToArray();
otherPlayerIDs.Dispose();
DrawPlayer(playerEnterRoom.playerID);
return(playerEnterRoom);
case MessageType.PlayerLeaveRoom:
var playerLeaveRoom = new PlayerMessage(message.id, message.messageType);
playerLeaveRoom.Deserialize(ref reader);
foreach (var textMesh in FindObjectsOfType <TextMesh>())
{
if (textMesh.text == playerLeaveRoom.playerID.ToString())
{
Destroy(textMesh.transform.parent.gameObject);
break;
}
}
currentRoomInfo.numberOfOtherPlayers--;
otherPlayerIDs = new NativeArray <int>(currentRoomInfo.numberOfOtherPlayers, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
bool tempBool = false;
for (int i = 0; i < currentRoomInfo.otherPlayerIDs.Length; i++)
{
var otherPlayerID = currentRoomInfo.otherPlayerIDs[i];
if (otherPlayerID == playerLeaveRoom.playerID)
{
tempBool = true;
continue;
}
var i2 = (tempBool) ? i - 1 : i;
otherPlayerIDs[i2] = otherPlayerID;
}
currentRoomInfo.otherPlayerIDs = otherPlayerIDs.ToArray();
otherPlayerIDs.Dispose();
return(playerLeaveRoom);
case MessageType.ObtainTreasure:
var obtainTreasureMessage = new ObtainTreasure(message.id);
obtainTreasureMessage.Deserialize(ref reader);
coinDisplay.text = (int.Parse(coinDisplay.text) + obtainTreasureMessage.amount).ToString();
currentRoomInfo.treasureInRoom = 0;
foreach (var hit in Physics2D.BoxCastAll(Vector2.zero, Vector2.one, 0, Vector2.zero, float.PositiveInfinity, LayerMask.GetMask("Raycast Target")))
{
if (hit.transform.name == "Treasure(Clone)")
{
Destroy(hit.transform.gameObject);
break;
}
}
return(obtainTreasureMessage);
case MessageType.HitMonster:
var hitMonsterMessage = new AttackMessage(message.id, message.messageType);
hitMonsterMessage.Deserialize(ref reader);
if (hitMonsterMessage.playerID == playerID || currentRoomInfo.otherPlayerIDs.Contains(hitMonsterMessage.playerID))
{
if (!(currentRoomInfo.containsMonster = false))
{
foreach (var hit in Physics2D.BoxCastAll(Vector2.zero, Vector2.one, 0, Vector2.zero, float.PositiveInfinity, LayerMask.GetMask("Raycast Target")))
{
if (hit.transform.name == "Monster(Clone)")
{
Destroy(hit.transform.gameObject);
break;
}
}
}
}
return(hitMonsterMessage);
case MessageType.HitByMonster:
var hitByMonsterMessage = new AttackMessage(message.id, message.messageType);
hitByMonsterMessage.Deserialize(ref reader);
if (playerID == hitByMonsterMessage.playerID)
{
healthDisplay.text = hitByMonsterMessage.value.ToString();
}
return(hitByMonsterMessage);
case MessageType.PlayerDefends:
var playerDefendMessage = new AttackMessage(message.id, message.messageType);
playerDefendMessage.Deserialize(ref reader);
return(playerDefendMessage);
case MessageType.PlayerLeftDungeon:
var playerLeftDungeon = new PlayerMessage(message.id, message.messageType);
playerLeftDungeon.Deserialize(ref reader);
foreach (var textMesh in FindObjectsOfType <TextMesh>())
{
if (textMesh.text == playerLeftDungeon.playerID.ToString())
{
Destroy(textMesh.transform.parent.gameObject);
break;
}
}
return(playerLeftDungeon);
case MessageType.PlayerDies:
var playerDiesMessage = new PlayerMessage(message.id, message.messageType);
playerDiesMessage.Deserialize(ref reader);
return(playerDiesMessage);
case MessageType.EndGame:
var endGameMessage = new EndGameMessage(message.id);
endGameMessage.Deserialize(ref reader);
SceneManager.LoadSceneAsync("Ending Screen").completed += (asyncOperation) =>
{
foreach (var highScore in endGameMessage.highScores.OrderByDescending(pair => pair.Value))
{
var endingScreenUIBinder = FindObjectOfType <EndingScreenUIBinder>();
endingScreenUIBinder.SpawnHighScoreUIField(highScore.Key, highScore.Value);
}
};
Destroy(this);
return(endGameMessage);
case MessageType.RequestDenied:
var requestDeniedMessage = new RequestDeniedMessage(message.id);
requestDeniedMessage.Deserialize(ref reader);
return(requestDeniedMessage);
case MessageType.PlayerLeft:
var playerLeftMessage = new PlayerMessage(message.id, message.messageType);
playerLeftMessage.Deserialize(ref reader);
foreach (var textMesh in FindObjectsOfType <TextMesh>())
{
if (textMesh.text == playerLeftMessage.playerID.ToString())
{
Destroy(textMesh.transform.parent.gameObject);
break;
}
}
return(playerLeftMessage);
default:
return(null);
}
}
void Update()
{
networkJobHandle.Complete();
for (int i = 0; i < connections.Length; ++i)
{
if (!connections[i].IsCreated)
{
connections.RemoveAtSwapBack(i);
--i;
}
}
NetworkConnection c;
while ((c = networkDriver.Accept()) != default)
{
if (GameHasStarted)
{
MakeRequestDeniedMessage(c, 0);
c.Disconnect(networkDriver);
return;
}
if (connections.Length > 4)
{
MakeRequestDeniedMessage(c, 1);
c.Disconnect(networkDriver);
return;
}
//Accepted Connection
connections.Add(c);
var colour = (Color32)UnityEngine.Random.ColorHSV();
var welcomeMessage = new WelcomeMessage
{
PlayerID = playerID,
Colour = ((uint)colour.r << 24) | ((uint)colour.g << 16) | ((uint)colour.b << 8) | colour.a
};
PlayerManager.Instance.Players.Add(new Players(playerID, "", welcomeMessage.Colour));
playerID++;
NetworkManager.SendMessage(networkDriver, welcomeMessage, c);
}
DataStreamReader reader;
for (int i = 0; i < connections.Length; ++i)
{
if (!connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = networkDriver.PopEventForConnection(connections[i], out reader)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var messageType = (MessageHeader.MessageType)reader.ReadUShort();
switch (messageType)
{
case MessageHeader.MessageType.None:
var noneMessage = NetworkManager.ReadMessage <StayAliveMessage>(reader, ServerMessageQueue);
NetworkManager.SendMessage(networkDriver, noneMessage, connections[i]);
break;
case MessageHeader.MessageType.SetName:
SetNameMessage setNameMessage = NetworkManager.ReadMessage <SetNameMessage>(reader, ServerMessageQueue) as SetNameMessage;
PlayerManager.Instance.Players[i].clientName = setNameMessage.Name;
var newPlayerMessage = new NewPlayerMessage()
{
PlayerID = PlayerManager.Instance.Players[i].playerID,
PlayerColor = PlayerManager.Instance.Players[i].clientColor,
PlayerName = setNameMessage.Name
};
//looping through all the connections to send the new player message
for (int j = 0; j < connections.Length; j++)
{
if (j != i)
{
NetworkManager.SendMessage(networkDriver, newPlayerMessage, connections[j]);
var connectedPlayersMessage = new NewPlayerMessage()
{
PlayerID = PlayerManager.Instance.Players[j].playerID,
PlayerColor = PlayerManager.Instance.Players[j].clientColor,
PlayerName = PlayerManager.Instance.Players[j].clientName
};
NetworkManager.SendMessage(networkDriver, connectedPlayersMessage, connections[i]);
}
}
break;
case MessageHeader.MessageType.PlayerLeft:
PlayerLeftMessage leftMessage = NetworkManager.ReadMessage <PlayerLeftMessage>(reader, ServerMessageQueue) as PlayerLeftMessage;
leftMessage.playerLeftID = (uint)i;
for (int j = 0; j < connections.Length; j++)
{
if (leftMessage.playerLeftID != PlayerManager.Instance.Players[i].playerID)
{
NetworkManager.SendMessage(networkDriver, leftMessage, connections[i]);
}
}
connections[i] = default;
break;
case MessageHeader.MessageType.MoveRequest:
var moveRequest = NetworkManager.ReadMessage <MoveRequest>(reader, ServerMessageQueue);
Debug.Log("MoveRequest");
if (CheckTileContent(i, TileContent.Monster) || CheckTileContent(i, TileContent.Both))
{
MakeRequestDeniedMessage(i, 2);
SendNewRoomInfo();
return;
}
MakeLeaveRoomMessage(i);
PlayerManager.Instance.MovePlayer(moveRequest, i);
MakeEnterRoommessage(i);
SendNewRoomInfo();
MonsterTurn();
NewTurnMessage();
break;
case MessageHeader.MessageType.AttackRequest:
var request = NetworkManager.ReadMessage <AttackRequestMessage>(reader, serverMessagesQueue);
Debug.Log(DebugTileContent(i));
if (!CheckTileContent(i, TileContent.Monster) && !CheckTileContent(i, TileContent.Both))
{
Debug.Log(CheckTileContent(i, TileContent.Monster));
Debug.Log(CheckTileContent(i, TileContent.Both));
MakeRequestDeniedMessage(i, 4);
SendNewRoomInfo();
return;
}
if (CheckTileContent(i, TileContent.Monster))
{
SetTileContent(i, TileContent.None);
}
if (CheckTileContent(i, TileContent.Both))
{
SetTileContent(i, TileContent.Treasure);
}
var message = new HitMonsterMessage();
NetworkManager.SendMessage(networkDriver, message, connections[i]);
SendNewRoomInfo();
NewTurnMessage();
MonsterTurn();
break;
case MessageHeader.MessageType.DefendRequest:
NetworkManager.ReadMessage <DefendRequestMessage>(reader, serverMessagesQueue);
PlayerManager.Instance.Players[i].DefendOneTurn = true;
var playerDefendMessage = new PlayerDefendsMessage()
{
PlayerID = PlayerManager.Instance.Players[i].playerID
};
Debug.Log(connections.Length);
for (int j = 0; j < connections.Length; j++)
{
NetworkManager.SendMessage(networkDriver, playerDefendMessage, connections[j]);
}
SendNewRoomInfo();
NewTurnMessage();
MonsterTurn();
break;
case MessageHeader.MessageType.ObtainTreasureRequest:
NetworkManager.ReadMessage <ClaimTreasureRequestMessage>(reader, serverMessagesQueue);
if (!CheckTileContent(i, TileContent.Treasure) && !CheckTileContent(i, TileContent.Both))
{
MakeRequestDeniedMessage(i, 5);
SendNewRoomInfo();
return;
}
if (CheckTileContent(i, TileContent.Both))
{
MakeRequestDeniedMessage(i, 6);
SendNewRoomInfo();
return;
}
Dictionary <Players, uint> players = PlayerManager.Instance.ClaimTreasureDivideItForPlayers(i);
uint amount;
int SendedItem = 0;
foreach (KeyValuePair <Players, uint> item in players)
{
amount = item.Value;
ObtainTreasureMessage obtainTreasure = new ObtainTreasureMessage()
{
Amount = (ushort)amount
};
for (int j = 0; j < PlayerManager.Instance.Players.Count; j++)
{
if (PlayerManager.Instance.Players[j].playerID == item.Key.playerID)
{
NetworkManager.SendMessage(networkDriver, obtainTreasure, connections[j]);
SendedItem++;
}
}
}
SetTileContent(i, TileContent.None);
SendNewRoomInfo();
MonsterTurn();
NewTurnMessage();
break;
case MessageHeader.MessageType.LeaveDungeonRequest:
NetworkManager.ReadMessage <LeaveDungeonRequest>(reader, serverMessagesQueue);
PlayerManager.Instance.PlayersWhoLeft.Add(PlayerManager.Instance.Players[i]);
PlayerLeftDungeonMessage playerLeftDungeonMessage = new PlayerLeftDungeonMessage()
{
playerID = i
};
PlayerManager.Instance.Players.RemoveAt(i);
for (int j = 0; j < connections.Length; j++)
{
if (i != j)
{
NetworkManager.SendMessage(networkDriver, playerLeftDungeonMessage, connections[j]);
}
}
if (PlayerManager.Instance.Players.Count < 1)
{
EndGameMessage endGameMessage = new EndGameMessage();
for (int j = 0; j < PlayerManager.Instance.PlayersWhoLeft.Count; j++)
{
endGameMessage.playerID.Add(PlayerManager.Instance.PlayersWhoLeft[j].playerID);
endGameMessage.highScorePairs.Add((ushort)PlayerManager.Instance.PlayersWhoLeft[j].treasureAmount);
NetworkManager.SendMessage(networkDriver, endGameMessage, connections[j]);
connections[j].Disconnect(networkDriver);
}
}
else
{
MonsterTurn();
SendNewRoomInfo();
NewTurnMessage();
}
break;
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
PlayerLeftMessage leftMessage = new PlayerLeftMessage();
leftMessage.playerLeftID = (uint)i;
for (int j = 0; j < connections.Length; j++)
{
if (leftMessage.playerLeftID != PlayerManager.Instance.Players[j].playerID)
{
NetworkManager.SendMessage(networkDriver, leftMessage, connections[j]);
}
}
Debug.Log("Client disconnected");
connections[i] = default;
}
}
}
networkJobHandle = networkDriver.ScheduleUpdate();
ProcessMessagesQueue();
}
public static void HandleEndGame(EndGameMessage message)
{
ObserverData.GameActive = false;
GameController.Instance.ActionsQueue.AddAction(new ObserverEndGame());
}
public void HandleEndGame(EndGameMessage endGame)
{
EndGame(endGame.Winner);
}
private void HandleEndGameMessage(EndGameMessage obj)
{
PlayingState = PlayingState.StartingGame;
}
/// <summary>
/// Called when the game ends.
/// </summary>
/// <param name="msg">End game message.</param>
public override void OnEndGame(EndGameMessage msg)
{
base.OnEndGame(msg);
gameEnded = true;
StopAllCoroutines();
}
private void HandleEndGameMessage(EndGameMessage message)
{
TextInChatBox += "Blue score: " + message.BlueScore + "\n";
TextInChatBox += "Green score: " + message.GreenScore + "\n";
OnPropertyChanged(nameof(TextInChatBox));
}
