void OnData(DataStreamReader stream, int i)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.NEW_CLIENT:
NewClientMsg ncMsg = JsonUtility.FromJson <NewClientMsg>(recMsg);
Debug.Log("Server msg: New Client message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Server msg: Player update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
ServerMessage(suMsg);
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream, int i)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player update message received!");
UpdatePlayerInfo(puMsg.player);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void OnData(int i, DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.LOGIN:
LoginMsg lMsg = JsonUtility.FromJson <LoginMsg>(recMsg);
Debug.Log("[Server] Client login message received! : " + lMsg.clientId);
OnClientLogIn(i, lMsg.clientId);
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
//Debug.Log( "[Server] Player update message received! : " + puMsg.player.ToString() );
GameServerManager.Instance.UpdatePlayerCommands(puMsg.player, puMsg.commands);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("[Server] Server update message received!");
break;
default:
Debug.Log("[Server] Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream, int i)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp); // Convert the stream into bytes
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray()); // Convert bytes into string
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg); // Convert the string into a json object
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
clients[puMsg.player.id].cubPos = puMsg.player.cubPos;
//clients[puMsg.player.id].cubeColor = puMsg.player.cubeColor;
Debug.Log("Player update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void UpdateClient(NetworkConnection nc)
{
ServerUpdateMsg m = new ServerUpdateMsg();
m.players = allCubes;
SendToClient(JsonUtility.ToJson(m), nc);
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes); //Get bytes
string recMsg = Encoding.ASCII.GetString(bytes.ToArray()); //convert bytes to JSON string
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg); //convert JSON to c# class
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_INTERNALID:
PlayerUpdateMsg internalId = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Got internalId from server");
playerInfo.player.id = internalId.player.id;
playerInternalIdText.text = playerInfo.player.id;
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
//Debug.Log("Player update message received!");
Debug.Log("Got data from server, player Pos: " + puMsg.player.pos);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
UpdateClientsInfo(suMsg);
break;
//To spawn existed players
case Commands.SPAWN_EXISTED_PLAYERS:
ServerUpdateMsg existedPlayerInfo = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("existed player info received!");
SpawnExistedPlayer(existedPlayerInfo);
break;
//Spawn new player
case Commands.SPAWN_NEW_PLAYER:
PlayerUpdateMsg newPlayerInfo = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("new client info received!");
SpawnNewPlayer(newPlayerInfo);
break;
//handle disconnected player
case Commands.DISCONNECTED_PLAYER:
DisconnectedPlayersMsg dpm = JsonUtility.FromJson <DisconnectedPlayersMsg>(recMsg);
Debug.Log("Disconnected player info recieved!");
DeleteDisconnectPlayer(dpm);
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
void UpdateClientsInfo(ServerUpdateMsg suMsg)
{
for (int i = 0; i < suMsg.players.Count; ++i)
{
if (connectedClientsDict.ContainsKey(suMsg.players[i].id))
{
connectedClientsDict[suMsg.players[i].id].transform.position = suMsg.players[i].pos;
connectedClientsDict[suMsg.players[i].id].GetComponent <Renderer>().material.color = suMsg.players[i].color;
if (suMsg.players[i].isDead)
{
connectedClientsDict[suMsg.players[i].id].GetComponent <PlayerController>().isDead = true;
connectedClientsDict[suMsg.players[i].id].GetComponentInChildren <TextMeshProUGUI>().SetText(":(");
}
}
else if (playerInfo.player.id == suMsg.players[i].id)
{
player.gameObject.GetComponent <Renderer>().material.color = suMsg.players[i].color;
playerInfo.player.color = suMsg.players[i].color;
if (suMsg.players[i].isDead)
{
connectedClientsDict[suMsg.players[i].id].GetComponent <PlayerController>().isDead = true;
connectedClientsDict[suMsg.players[i].id].GetComponentInChildren <TextMeshProUGUI>().SetText(":(");
}
}
}
}
IEnumerator SendHandshakeToAllClient()
{
while (true)
{
ServerUpdateMsg suMsg = new ServerUpdateMsg();
foreach (KeyValuePair <string, NetworkObjects.NetworkPlayer> client in clients)
{
suMsg.players.Add(client.Value);
}
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
// Example to send a handshake message:
//HandshakeMsg m = new HandshakeMsg();
//m.player.id = m_Connections[i].InternalId.ToString();
SendToClient(JsonUtility.ToJson(suMsg), m_Connections[i]);
}
yield return(new WaitForSeconds(0.5f));
}
}
void OnData(DataStreamReader stream, int i, NetworkConnection client)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp); //Where to store bytes data
stream.ReadBytes(bytes); //Get bytes data from stream
string recMsg = Encoding.ASCII.GetString(bytes.ToArray()); //convert bytes data to string(JSON)
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg); //convert JSON to c# object
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Got " + puMsg.player.id + " player Info");
UpdateClientInfo(puMsg);
//Debug.Log("Player update message received!");
//Debug.Log("Got data from client, Player Pos: " + puMsg.player.pos);
//TestSendBack(client, puMsg);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream, int i, NetworkConnection client)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player position " + puMsg.player.pos);
UpdatePlayerInfo(puMsg);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg ServerUpdateMessage = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server Update.");
break;
default:
Debug.Log("ServerError (Default Log)");
break;
}
}
IEnumerator SendPlayerUpdateToAllClients()
{
while (true)
{
//Debug.Log("starting message!!!");
ServerUpdateMsg m = new ServerUpdateMsg();
foreach (NetworkObjects.NetworkPlayer players in playerList)
{
//players.id = m_Connections[i].InternalId.ToString();
m.players.Add(players);
Debug.Log("Player ADDED!!!");
}
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
//PlayerUpdateMsg m = new PlayerUpdateMsg();
//m.player.id = m_Connections[i].InternalId.ToString();
SendToClient(JsonUtility.ToJson(m), m_Connections[i]);
}
yield return(new WaitForSeconds(2));
}
}
void OnData(DataStreamReader stream, int i)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Server: Hello, player " + hsMsg.player.id.ToString());
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
m_listOfPlayers[i].body.transform.position = puMsg.player.body.transform.position;
ServerUpdateMsg serUpMsg = new ServerUpdateMsg();
serUpMsg.players = m_listOfPlayers;
SendToClient(JsonUtility.ToJson(serUpMsg), m_Connections[i]);
Debug.Log("Player update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("[Client] Handshake message received! " + hsMsg.player.id);
GameplayManager.Instance.SpawnPlayer(hsMsg.player, true);
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("[Client] Player update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("[Client] Server update message received!" + suMsg.players.ToArrayString());
GameplayManager.Instance.UpdatePlayers(suMsg.players);
break;
default:
Debug.Log("[Client] Unrecognized message received!");
break;
}
}
void Update()
{
m_Driver.ScheduleUpdate().Complete();
// CleanUpConnections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
m_Connections.RemoveAtSwapBack(i);
playersManager.RemovePlayer(m_Connections[i].InternalId);
--i;
}
}
// AcceptNewConnections
NetworkConnection c = m_Driver.Accept();
while (c != default(NetworkConnection))
{
OnConnect(c);
// Check if there is another new connection
c = m_Driver.Accept();
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
Assert.IsTrue(m_Connections[i].IsCreated);
NetworkEvent.Type cmd;
cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream);
while (cmd != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
OnData(stream, m_Connections[i].InternalId);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
OnDisconnect(i);
}
cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream);
}
}
if (playersManager.IsDirtyFlag)
{
for (int i = 0; i < m_Connections.Length; i++)
{
ServerUpdateMsg m = new ServerUpdateMsg(playersManager.GetPlayers());
SendToClient(JsonUtility.ToJson(m), m_Connections[i]);
}
playersManager.ClearDirtyFlag();
}
}
// on data received
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
// player handshake
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
SpawnPlayer(hsMsg.player);
Debug.Log("Handshake message received!");
break;
// player update
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
ClientPlayerUpdate(puMsg.players);
Debug.Log("Player update message received!");
break;
// server update
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
// player list update
case Commands.PLAYER_LIST:
ClientListMsg listMsg = JsonUtility.FromJson <ClientListMsg>(recMsg);
for (int p = 0; p < listMsg.players.Length; p++)
{
SpawnPlayer(listMsg.players[p]);
}
Debug.Log("Player list message received!");
break;
// player disconnect
case Commands.PLAYER_DISCONNECT:
DiscPlayerMsg discMsg = JsonUtility.FromJson <DiscPlayerMsg>(recMsg);
RemoveClientPlayer(discMsg.players);
Debug.Log("Player disconnect message received!");
break;
// player connect
case Commands.PLAYER_JOIN:
HandshakeMsg nhsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
ClientPlayerID = nhsMsg.player.id;
SpawnPlayer(nhsMsg.player);
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
private void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("[Notice] Handshake message received!");
break;
case Commands.PLAYER_UPDATE: //shouldnt happen
Debug.LogError("[Error] Player update message received! Client shouldn't receive messages from clients.");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
//Debug.Log("[Routine] Server update message received!");
UpdateRemotePlayers(suMsg.players);
break;
case Commands.PONG:
if (bVerboseDebug)
{
//Debug.Log("[Routine] Pong message received!");
}
break;
case Commands.SERVER_HANDSHAKE:
ServerHandshakeMsg shMsg = JsonUtility.FromJson <ServerHandshakeMsg>(recMsg);
Debug.Log("[Notice] Handshake from server received!");
m_clientIDDict.Add(shMsg.clientID, localClientCharacterRef); //Add local character to player dictionary
m_thisClientID = shMsg.clientID; //keep a reference to local player ID
SpawnRemotePlayers(shMsg.players); //Spawn remote players
StartCoroutine(UploadClientDataRoutine(m_clientUpdateInterval)); //Start routinely updating server with local cube character data
break;
case Commands.NEW_PLAYER:
PlayerUpdateMsg puMSg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("[Notice] A new player has connected. (" + puMSg.player.clientID + ")");
SpawnRemotePlayer(puMSg.player);
break;
case Commands.PLAYER_DISCONNECT:
PlayerIDMsg pdMSg = JsonUtility.FromJson <PlayerIDMsg>(recMsg);
Debug.Log("[Notice] A player has disconnected. (" + pdMSg.clientID + ")");
RemoveRemotePlayer(pdMSg.clientID);
break;
default:
Debug.LogError("[Error] Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream, int i)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player update message received!");
Debug.Log("Player List: " + serverPlayerList);
foreach (NetworkObjects.NetworkPlayer player in serverPlayerList)
{
if (player.id == puMsg.player.id)
{
player.cubeColor = puMsg.player.cubeColor;
player.cubPos = puMsg.player.cubPos;
player.cubRot = puMsg.player.cubRot;
}
}
break;
case Commands.PLAYER_BULLET:
PlayerBulletMsg pbMsg = JsonUtility.FromJson <PlayerBulletMsg>(recMsg);
Debug.Log("Player Bullet Fired!");
FireBulletForPlayers(pbMsg, m_Connections[i]);
break;
case Commands.PLAYER_JOINED:
PlayerJoinMessage pjMsg = JsonUtility.FromJson <PlayerJoinMessage>(recMsg);
Debug.Log("Player join message received!");
CreatePlayer(pjMsg, m_Connections[i]);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
case Commands.PLAYER_LEFT:
PlayerLeaveMsg plMsg = JsonUtility.FromJson <PlayerLeaveMsg>(recMsg);
Debug.Log("Player leave message recieved!");
OnDisconnect(int.Parse(plMsg.player.id));
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream, int i)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.PLAYER_CONNECTED:
ConnectionApprovedMsg cpMsg = JsonUtility.FromJson <ConnectionApprovedMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
//Debug.Log("Player update message received!");
playerData = puMsg;
Debug.Log("Player ID: " + playerData.player.id + " Player Position: " + playerData.player.cubPos);
//Debug.Log("Time As of Now: " + DateTime.Now);
playerData.player.pulse = DateTime.Now;
for (i = 0; i < ConnectedList.GameState.Count; i++)
{
if (playerData.player.id == ConnectedList.GameState[i].id)
{
ConnectedList.GameState.Insert(i, playerData.player);
ConnectedList.GameState.RemoveAt(i + 1);
}
Debug.Log("Transfered ID: " + ConnectedList.GameState[i].id + "Transfered Pos: " + ConnectedList.GameState[i].cubPos);
}
break;
case Commands.PLAYER_DISCONNECTED:
PlayerDisconnectMsg pdMsg = JsonUtility.FromJson <PlayerDisconnectMsg>(recMsg);
Debug.Log("Player Disconnect update message received!, Got This: " + i);
OnDisconnect(i);
break;
case Commands.GAMESTATE:
GameStateMsg gsMsg = JsonUtility.FromJson <GameStateMsg>(recMsg);
Debug.Log("GameState update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.PLAYER_INIT:
InitializeConnectionMsg piMsg = JsonUtility.FromJson <InitializeConnectionMsg>(recMsg);
playerUpdateMsg.player.id = piMsg.yourID;
HandshakeMsg m = new HandshakeMsg();
m.player = playerUpdateMsg.player;
m.player.id = piMsg.yourID;
SendToServer(JsonUtility.ToJson(m));
otherPlayers.Add(m.player.id, yourCharacter);
Debug.Log("Initialization message received! Your ID: " + piMsg.yourID);
break;
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
UpdateNetworkObjects(suMsg);
Debug.Log("Server update message received!");
break;
case Commands.PLAYER_DROPPED:
ConnectionDroppedMsg cdMsg = JsonUtility.FromJson <ConnectionDroppedMsg>(recMsg);
// Destroy
GameObject character = otherPlayers[cdMsg.droppedId];
otherPlayers.Remove(cdMsg.droppedId);
Destroy(character);
Debug.Log("Player dropped message received! " + cdMsg.droppedId);
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes); //Get bytes
string recMsg = Encoding.ASCII.GetString(bytes.ToArray()); //convert bytes to JSON string
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg); //convert JSON to c# class
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_WHOAMI:
PlayerUpdateMsg internalId = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Got internalId from server");
playerInfo.player.id = internalId.player.id;
playerIDText.SetText(playerInfo.player.id);
myIDLabel.SetText(playerInfo.player.id);
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Got data from server, player Pos: " + puMsg.player.pos);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
UpdateClientsInfo(suMsg);
break;
case Commands.ALREADY_HERE_PLAYERS:
ServerUpdateMsg alreadyHerePlayerInfo = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("existed player info received!");
SpawnPlayersAlreadyHere(alreadyHerePlayerInfo);
break;
case Commands.SPAWN_NEW_PLAYER:
PlayerUpdateMsg newPlayerMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("new client info received!");
SpawnNewPlayer(newPlayerMsg);
break;
case Commands.DISCONNECTED_PLAYER:
DisconnectedPlayersMsg dpMsg = JsonUtility.FromJson <DisconnectedPlayersMsg>(recMsg);
Debug.Log("Player disconnected :(");
DeleteDisconnectPlayer(dpMsg);
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
public void SpawnOldClients(ServerUpdateMsg oldClientsDatas)
{
for (int i = 0; i < oldClientsDatas.players.Count; ++i)
{
GameObject oc = Instantiate(clients);
listOfOldClients[oldClientsDatas.players[i].id] = oc;
oc.transform.position = oldClientsDatas.players[i].cubPos;
}
}
public void UpdatePlayer(string id, Vector3 position, Vector3 rotation)
{
ServerUpdateMsg msg = new ServerUpdateMsg();
msg.player.id = id;
msg.player.position = position;
msg.player.rotation.eulerAngles = rotation;
msg.player.lastBeat = System.DateTime.Now;
SendToServer(JsonUtility.ToJson(msg));
}
void AddPlayer(HandshakeMsg msg)
{
Allplayers.Add(msg.player);
ServerUpdateMsg ServerUpdate = new ServerUpdateMsg();
ServerUpdate.players = Allplayers;
ServerUpdate.type = ServerUpdateMsg.UpdateType.ADD;
SendToAllClients(JsonUtility.ToJson(ServerUpdate));
}
void UpdatePlayers(ServerUpdateMsg s)
{
Debug.Log("Server players: " + s.players.Count.ToString() + ",Client Players: " + m_Players.Count.ToString());
if (s.players.Count > m_Players.Count)
{ //spawn new
foreach (NetworkObjects.NetworkPlayer player in s.players)
{
if (!m_Players.Contains(player))
{
m_Players.Add(player);
SpawnPlayer(player);
}
}
}
else if (s.players.Count < m_Players.Count)
{
foreach (NetworkObjects.NetworkPlayer player in m_Players)
{
if (!s.players.Contains(player))
{
if (Int32.TryParse(player.id, out int index))
{
Destroy(m_cubes[index]);
m_cubes.Remove(m_cubes[index]);
m_Players.Remove(player);
}
}
}
}
else
{
foreach (NetworkObjects.NetworkPlayer clientPlayer in m_Players)
{
foreach (NetworkObjects.NetworkPlayer serverPlayer in m_Players)
{
if (serverPlayer.id == m_internalID)
{
continue;
}
else if (serverPlayer.id == clientPlayer.id)
{
clientPlayer.x = serverPlayer.x;
clientPlayer.y = serverPlayer.y;
clientPlayer.z = serverPlayer.z;
//this should be a separate function, but meh...
if (Int32.TryParse(clientPlayer.id, out int index))
{
m_cubes[index].transform.position = new Vector3(clientPlayer.x, clientPlayer.y, clientPlayer.z);
}
}
}
}
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received! ID : " + hsMsg.player.id);
serverInternalId = hsMsg.player.id;
clientList.Add(hsMsg.player.id, Instantiate(prefab));
break;
//case Commands.PLAYER_UPDATE:
// PlayerUpdateMsg puMsg = JsonUtility.FromJson<PlayerUpdateMsg>(recMsg);
// Debug.Log("Player update message received!");
// break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received! ");
Debug.Log("# of Players : " + suMsg.players.Count);
List <string> tempListId = new List <string>();
foreach (NetworkObjects.NetworkPlayer player in suMsg.players)
{
tempListId.Add(player.id);
Debug.Log(" >>>>>> ID : " + player.id);
if (!clientList.ContainsKey(player.id))
{
clientList.Add(player.id, Instantiate(prefab));
}
if (player.id != serverInternalId)
{
clientList[player.id].transform.position = player.cubPos;
clientList[player.id].GetComponent <Renderer>().material.color = player.cubeColor;
}
}
ServerListId.Clear();
ServerListId = tempListId;
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
//Spawn existed player in server
void SpawnExistedPlayer(ServerUpdateMsg data)
{
for (int i = 0; i < data.players.Count; ++i)
{
GameObject avatar = Instantiate(clientAvatar);
listOfClients[data.players[i].id] = avatar;
avatar.transform.position = data.players[i].pos;
avatar.GetComponentInChildren <TextMesh>().text = data.players[i].id;
}
}
void UpdatePlayersFromSever(ServerUpdateMsg serverMsg)
{
for (int j = 0; j < players.Count; j++)
{
if (players[j].id == serverMsg.player.id)
{
players[j].position = serverMsg.player.position;
players[j].rotation = serverMsg.player.rotation;
players[j].lastBeat = serverMsg.player.lastBeat;
}
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
case Commands.PLAYER_INTO:
PlayerIntoMsg pMsg = JsonUtility.FromJson <PlayerIntoMsg>(recMsg);
Debug.Log("Player into message received!");
if (ID != pMsg.UnityID)
{
Instantiate(playerCube, new Vector3(0.0f, 0.0f, 0.0f), Quaternion.identity);
}
break;
case Commands.PLAYER_CUBE:
PlayerCubeMsg pcMsg = JsonUtility.FromJson <PlayerCubeMsg>(recMsg);
Debug.Log("Player movement update message received!");
foreach (GameObject p in GameObject.FindGameObjectsWithTag("Player"))
{
if (p != CubeObj && pcMsg.UnityID != ID)
{
p.transform.position = pcMsg.Point;
}
}
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.NEW_CLIENT:
NewClientMsg ncMsg1 = JsonUtility.FromJson <NewClientMsg>(recMsg);
SpawnPlayer(ncMsg1.player);
Debug.Log("Client Msg: New Client message received!");
break;
case Commands.CLIENT_DROP:
DropPlayerMsg dpMsg = JsonUtility.FromJson <DropPlayerMsg>(recMsg);
RemovePlayers(dpMsg.players);
Debug.Log("Client Msg: Client drop message received!");
break;
case Commands.CLIENT_LIST:
PlayerListMsg nplMsg = JsonUtility.FromJson <PlayerListMsg>(recMsg);
for (int i = 0; i < nplMsg.players.Length; i++)
{
SpawnPlayer(nplMsg.players[i]);
}
Debug.Log("Client Msg: Client list message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
PlayerUpdate(puMsg.updatedPlayers);
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Client Msg: Server update message received!");
break;
case Commands.PLAYER_ID:
NewClientMsg ncMsg2 = JsonUtility.FromJson <NewClientMsg>(recMsg);
playerID = ncMsg2.player.id;
SpawnPlayer(ncMsg2.player);
break;
default:
Debug.Log("Client Msg: Unrecognized message received!");
break;
}
}
void OnData(DataStreamReader stream)
{
NativeArray <byte> bytes = new NativeArray <byte>(stream.Length, Allocator.Temp);
stream.ReadBytes(bytes);
string recMsg = Encoding.ASCII.GetString(bytes.ToArray());
NetworkHeader header = JsonUtility.FromJson <NetworkHeader>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("Handshake message received!");
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
Debug.Log("Player update message received!");
break;
case Commands.SERVER_UPDATE:
ServerUpdateMsg suMsg = JsonUtility.FromJson <ServerUpdateMsg>(recMsg);
Debug.Log("Server update message received!");
break;
//***
case Commands.NEW_PLAYER:
NewPlayer neMsg = JsonUtility.FromJson <NewPlayer>(recMsg);
Debug.Log("New Player Joining!");
if (P_ID != neMsg.ID)
{
Instantiate(Player, new Vector3(5.0f, 0.0f, 0.0f), Quaternion.identity);
}
break;
case Commands.PLAYER_INPUT:
PlayerInputMsg move = JsonUtility.FromJson <PlayerInputMsg>(recMsg);
Debug.Log("Player moving!");
foreach (GameObject cp in GameObject.FindGameObjectsWithTag("Player"))
{
if (cp != self)
{
cp.transform.position = move.move;
}
}
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
