private void PlayerLeftLobby(ref DataStreamReader reader)
{
var playerLeftMessage = new PlayerLeftMessage();
playerLeftMessage.DeserializeObject(ref reader);
PlayerData removedData = dataHolder.players.Find(x => x.playerIndex == playerLeftMessage.PlayerLeftID);
dataHolder.players.Remove(removedData);
dataHolder.lobby.UpdateLobby(dataHolder.players.ToArray());
}
public void HandleDisconnect(int connectionID)
{
PlayerLeftMessage playerLeftMessage = new PlayerLeftMessage {
PlayerID = connectionID
};
lobby.players.Remove(connectionID);
//send left player to lobby
foreach (KeyValuePair <int, Player> player in lobby.players)
{
serverBehaviour.QeueMessage(new AdressedMessage(playerLeftMessage, player.Key));
}
}
public void DisableSpawnLabel(MessageHeader message)
{
PlayerLeftMessage playerLeftMessage = message as PlayerLeftMessage;
Debug.Log("HI");
for (int i = 0; i < labels.Count; i++)
{
Text textComponent = labels[i].GetComponentInChildren <Text>();
if (textComponent.text.Contains(playerLeftMessage.playerLeftID.ToString()))
{
GameObject.Destroy(labels[i].gameObject);
PlayerManager.Instance.Players.RemoveAt(i);
}
}
}
public void RemovePlayer(MessageHeader arg0)
{
PlayerLeftMessage PlayerLeft = arg0 as PlayerLeftMessage;
for (int i = 0; i < PlayerManager.Instance.Players.Count; i++)
{
if (PlayerManager.Instance.Players[i].playerID == PlayerLeft.playerLeftID)
{
Players playerToRemove = PlayerManager.Instance.Players[i];
Destroy(PlayerManager.Instance.Players[i].Sprite.gameObject);
PlayerManager.Instance.Players.RemoveAt(i);
break;
}
}
}
public override void OnPhotonPlayerDisconnected(PhotonPlayer otherPlayer)
{
Util.Log($"Player {otherPlayer.ID} disconnected.");
var cms = FindObjectOfType <HudNotifications>();
if (cms != null)
{
cms.AddMessage($"'{otherPlayer.NickName}' left");
}
if (!PhotonNetwork.isMasterClient)
{
return;
}
// Inefficient and global, but whatever...
foreach (UserBody body in FindObjectsOfType <UserBody>())
{
if (body.GetComponent <PhotonView>().OwnerActorNr == otherPlayer.ID)
{
PhotonNetwork.Destroy(body.gameObject);
}
}
// Reclaim all actors owned by this player. A bit surprised photon doesn't
// do this for us..
foreach (VoosActor actor in voosEngine.EnumerateActors())
{
if (actor.reliablePhotonView != null && actor.reliablePhotonView.OwnerActorNr == otherPlayer.ID)
{
// Why not call actor.RequestOwnership here? That would result in
// nothing happening, because the other player is definitely gone. But
// calling view.RequestOwnership() directly will go through the normal
// Photon flow, bypassing all our logic, and Photon should just grant us
// ownership.
actor.reliablePhotonView.RequestOwnership();
}
}
// Broadcast a message saying the player disconnected.
PlayerLeftMessage playerLeftMessage = new PlayerLeftMessage();
playerLeftMessage.id = otherPlayer.ID;
playerLeftMessage.nickName = otherPlayer.NickName;
voosEngine.BroadcastMessage("PlayerLeft", playerLeftMessage);
}
private void PlayerLeftCallback(PlayerLeftMessage msg, float travelTime)
{
var player = players.FirstOrDefault(a => a.ClientGuid == msg.ClientGuid && a.CtrlType == msg.CtrlType);
if (player != null)
{
players.Remove(player);
if (player.BallObject)
{
player.BallObject.CreateRemovalParticles();
Destroy(player.BallObject.gameObject);
}
if (MatchPlayerRemoved != null)
{
MatchPlayerRemoved(this, new MatchPlayerEventArgs(player, msg.ClientGuid == myGuid)); //TODO: determine if removed player was local
}
}
}
private void HandleLeftMessage(GameMessage msg)
{
PlayerLeftMessage leftMsg = msg as PlayerLeftMessage;
this.logger.LogInformation($"{leftMsg.PlayerId} left the server");
}
public virtual void onPlayerLeft(PlayerLeftMessage message)
{
}
public void Update()
{
networkJobHandle.Complete();
if (!connection.IsCreated)
{
return;
}
DataStreamReader reader;
NetworkEvent.Type cmd;
while ((cmd = connection.PopEvent(networkDriver, out reader)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
Debug.Log("Connected to server");
}
else if (cmd == NetworkEvent.Type.Data)
{
var messageType = (Message.MessageType)reader.ReadUShort();
Debug.Log("Client Received: " + messageType + " from Host");
Message message = null;
switch (messageType)
{
case Message.MessageType.None: break;
case Message.MessageType.NewPlayer: message = new NewPlayerMessage(); break;
case Message.MessageType.Welcome: message = new WelcomeMessage(); break;
case Message.MessageType.RequestDenied: message = new RequestDeniedMessage(); break;
case Message.MessageType.PlayerLeft: message = new PlayerLeftMessage(); break;
case Message.MessageType.StartGame: message = new StartGameMessage(); break;
case Message.MessageType.PlayerTurn: message = new PlayerTurnMessage(); break;
case Message.MessageType.RoomInfo: message = new RoomInfoMessage(); break;
case Message.MessageType.PlayerEnterRoom: message = new PlayerEnterRoomMessage(); break;
case Message.MessageType.PlayerLeaveRoom: message = new PlayerLeaveRoomMessage(); break;
case Message.MessageType.ObtainTreasure: message = new ObtainTreasureMessage(); break;
case Message.MessageType.HitMonster: message = new HitMonserMessage(); break;
case Message.MessageType.HitByMonster: message = new HitByMonserMessage(); break;
case Message.MessageType.PlayerDefends: message = new PlayerDefendsMessage(); break;
case Message.MessageType.PlayerLeftDungeon: message = new PlayerLeftDungeonMessage(); break;
case Message.MessageType.PlayerDies: message = new PlayerDiesMessage(); break;
case Message.MessageType.EndGame: break;
default: break;
}
if (message != null)
{
message.DeserializeObject(ref reader);
receivedMessagesQueue.Enqueue(message);
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Disconnected from server");
connection = default;
}
}
ProcessMessagesQueue();
if (Time.time - lastSendTime > STAY_ALIVE_AFTER_SECONDS)
{
SendMessage(new NoneMessage());
}
networkJobHandle = networkDriver.ScheduleUpdate();
}
public override void onPlayerLeft(PlayerLeftMessage message)
{
RemovePlayer(message.playerId);
}
void Update()
{
networkJobHandle.Complete();
for (int i = 0; i < connections.Length; ++i)
{
if (!connections[i].IsCreated)
{
connections.RemoveAtSwapBack(i);
--i;
}
}
NetworkConnection newConnection;
while ((newConnection = networkDriver.Accept()) != default)
{
if (connections.Length >= 4)
{
return;
}
connections.Add(newConnection);
//Debug.Log("Accepted new connection");
//new player data is set
//Color col = Random.ColorHSV();
Color col = ColorExtensions.colors[(ColorExtensions.RandomStartIndex + newConnection.InternalId) % ColorExtensions.colors.Length];
col.a = 1;
var colour = (Color32)col;
var playerID = newConnection.InternalId;
var welcomeMessage = new WelcomeMessage
{
PlayerID = playerID,
Colour = ((uint)colour.r << 24) | ((uint)colour.g << 16) | ((uint)colour.b << 8) | colour.a
};
SendMessage(welcomeMessage, newConnection);
//save it to list
PlayerData newData = new PlayerData();
newData.color = colour;
newData.playerIndex = playerID;
if (serverDataHolder.players == null)
{
serverDataHolder.players = new List <PlayerData>();
}
serverDataHolder.players.Add(newData);
//Debug.Log("server data holder players count: " + serverDataHolder.players.Count);
}
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:
StayAlive(i);
break;
case MessageHeader.MessageType.newPlayer:
break;
case MessageHeader.MessageType.welcome:
break;
case MessageHeader.MessageType.setName:
var message = new SetNameMessage();
message.DeserializeObject(ref reader);
messagesQueue.Enqueue(message);
PlayerData newPlayerData = GetPlayerData(connections[i]);
newPlayerData.name = message.Name;
NewPlayerJoined(connections[i]);
break;
case MessageHeader.MessageType.playerLeft:
break;
case MessageHeader.MessageType.moveRequest:
var moveRequest = new MoverequestMessage();
moveRequest.DeserializeObject(ref reader);
//messagesQueue.Enqueue(moveRequest);
bool canmove = HandleMoveRequest(moveRequest, i);
if (canmove)
{
NextPlayerTurn();
}
break;
case MessageHeader.MessageType.claimTreasureRequest:
var treasureRquest = new ClaimTreasureRequestMessage();
treasureRquest.DeserializeObject(ref reader);
HandleTreasureClaim(treasureRquest, i);
break;
case MessageHeader.MessageType.leaveDungeonRequest:
var leaveDungeonRequest = new LeavesDungeonRequestMessage();
leaveDungeonRequest.DeserializeObject(ref reader);
HandleLeaveDungeonRequest(leaveDungeonRequest, i);
break;
case MessageHeader.MessageType.defendRequest:
var defendRequest = new DefendRequestMessage();
defendRequest.DeserializeObject(ref reader);
HandleDefendRequest(defendRequest, i);
break;
case MessageHeader.MessageType.attackRequest:
var attackRequest = new AttackRequestMessage();
attackRequest.DeserializeObject(ref reader);
HandleAttackRequest(attackRequest, i);
break;
default:
break;
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
PlayerLeftMessage playerLeftMessage = new PlayerLeftMessage
{
PlayerLeftID = i
};
SendMessageToAll(playerLeftMessage);
Debug.Log("Client disconnected");
connections[i] = default;
}
}
}
networkJobHandle = networkDriver.ScheduleUpdate();
ProcessMessagesQueue();
}
void RecieveMessage(Message msg)
{
print("MESSAGE RECIEVED " + msg);
switch (msg.type)
{
case MessageTypes.PlayerJoined:
print("A NEW CHALLENGER APPROACHES");
PlayerJoinedMessage pjm = (PlayerJoinedMessage)msg;
m_playerController.AddPlayer(new PlayerData {
index = pjm.id, color = pjm.color, icon = (PhoneUserIcon)pjm.icon, name = pjm.name
});
if (onPlayerCountChange != null)
{
onPlayerCountChange.Invoke(m_playerController.PlayerCount);
}
break;
case MessageTypes.PlayerLeft:
PlayerLeftMessage plm = (PlayerLeftMessage)msg;
m_playerController.RemovePlayer(plm.id);
if (onPlayerCountChange != null)
{
onPlayerCountChange.Invoke(m_playerController.PlayerCount);
}
SceneManager.LoadScene(0);
break;
case MessageTypes.PlayerMove:
PlayerMoveMessage pmm = (PlayerMoveMessage)msg;
ThirdPersonUserControl player = ThirdPersonUserControl.players[pmm.pid - 1];
//if(pmm.x != null && pmm.y != null)
player.setAxis(pmm.x, pmm.y);
if (pmm.jmp)
{
player.jump = pmm.jmp;
}
if (pmm.drp)
{
player.drop = pmm.drp;
}
break;
case MessageTypes.PlayerAction:
PlayerActionMessage pam = (PlayerActionMessage)msg;
print(pam + " sad");
if (pam.jump)
{
ThirdPersonUserControl.players[pam.pid - 1].jump = true;
}
else
{
ThirdPersonUserControl.players[pam.pid - 1].drop = true;
}
break;
}
}
private void HandlePlayerLeft(PlayerLeftMessage msg)
{
// entitiesByPeerId.TryGetValue(msg.PeerId).IfSome(DestroyEntity);
}
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 void HandlePlayerLeft(Message message)
{
PlayerLeftMessage playerLeftMessage = (PlayerLeftMessage)message;
lobby.players.Remove(playerLeftMessage.PlayerID);
}
