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)
{
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;
}
}
private void SendIdToClient(int ci)
{
HandshakeMsg msg = new HandshakeMsg();
msg.player.id = playersIds[ci].ToString();
SendToClient(JsonUtility.ToJson(msg), m_Connections[ci]);
}
void OnConnect(NetworkConnection c)
{
Debug.Log("Accepted a connection");
// Example to send a handshake message:
HandshakeMsg hsm = new HandshakeMsg();
hsm.player.id = c.InternalId.ToString();
// send all connection to client
foreach (NetworkConnection con in m_Connections)
{
SendToClient(JsonUtility.ToJson(hsm), con);
}
ClientListMsg Clist = new ClientListMsg(ServerPlayersList);
SendToClient(JsonUtility.ToJson(Clist), c);
// send new player info
hsm.cmd = Commands.PLAYER_JOIN;
SendToClient(JsonUtility.ToJson(hsm), c);
// add to server player list and connection list
ServerPlayersList.Add(hsm.player);
m_Connections.Add(c);
print("User ID: " + hsm.player.id + " Connected!");
}
void OnConnect(NetworkConnection c)
{
m_Connections.Add(c);
Debug.Log("Accepted a connection");
HandshakeMsg message = new HandshakeMsg();
message.player.id = c.InternalId.ToString();
SendToClient(JsonUtility.ToJson(message), c);
NetworkObjects.NetworkPlayer nPlayer = new NetworkObjects.NetworkPlayer();
nPlayer.id = c.InternalId.ToString();
nPlayer.cubeColor = UnityEngine.Random.ColorHSV(0f, 1f, 1f, 1f, 0f, 1f);
nPlayer.cubPos = new Vector3(UnityEngine.Random.Range(-5, 5), UnityEngine.Random.Range(-5, 5), UnityEngine.Random.Range(0, 0));
for (int i = 0; i < m_Connections.Length; i++)
{
if (m_Connections[i] != c)
{
PlayerUpdateMsg othermessage = new PlayerUpdateMsg();
othermessage.cmd = Commands.PLAYER_JOINED;
othermessage.player = nPlayer;
SendToClient(JsonUtility.ToJson(othermessage), m_Connections[i]);
}
}
PlayerList.Add(nPlayer);
foreach (var player in PlayerList)
{
PlayerUpdateMsg otherothermessage = new PlayerUpdateMsg();
otherothermessage.cmd = Commands.PLAYER_JOINED;
otherothermessage.player = player;
SendToClient(JsonUtility.ToJson(otherothermessage), c);
}
}
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 OnData(DataStreamReader stream)
{
//these guys are converting unreadable data to readable and the final version will be called recMsg
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.ID_UPDATE:
IDUpdateMsg idMsg = JsonUtility.FromJson <IDUpdateMsg>(recMsg);
myPlayer.id = idMsg.id;
Debug.Log("Client: Server returned me my new id: " + myPlayer.id.ToString());
break;
case Commands.HANDSHAKE:
HandshakeMsg m = JsonUtility.FromJson <HandshakeMsg>(recMsg);
Debug.Log("(Server) Hello, player " + myPlayer.id.ToString());
break;
default:
Debug.Log("Unrecognized message received!");
break;
}
}
void OnConnect(NetworkConnection c)
{
m_Connections.Add(c);
//d_Connections.Add(c.InternalId.ToString(), c);
Debug.Log(c.ToString());
Debug.Log(c.InternalId.ToString());
Debug.Log("Accepted a connection");
Debug.Log("Added player:" + c.InternalId.ToString());
// Example to send a handshake message:
HandshakeMsg m = new HandshakeMsg();
//m.InternalServerID = c.InternalId.ToString();
//add the new player to our list of connected players
//connectedPlayers.Add(m.player);
SendToClient(JsonUtility.ToJson(m), c);
////send the new player all the other players and the other players the new player
//foreach (NetworkConnection connection in m_Connections)
//{
// if (connection.IsCreated)
// {
// Debug.Log("Sending connected players to player:" + connection.InternalId.ToString());
// NewPlayerUpdateMsg n = new NewPlayerUpdateMsg();
// n.players = new List<NetworkObjects.NetworkPlayer>(connectedPlayers);
// SendToClient(JsonUtility.ToJson(n), connection);
// }
//}
}
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 OnConnect(NetworkConnection c) //done
{
Debug.Log("Accepted a connection");
// Send a handshake message to Set ID
HandshakeMsg m = new HandshakeMsg();
m.player.id = c.InternalId.ToString();
Assert.IsTrue(c.IsCreated);
SendToClient(JsonUtility.ToJson(m), c);
// Send List of Players to new Client
SpawnedPlayersList playersInServer = new SpawnedPlayersList();
foreach (var client in clientLookUpTable)
{
playersInServer.players.Add(client.Value);
}
Assert.IsTrue(c.IsCreated);
SendToClient(JsonUtility.ToJson(playersInServer), c);
// Send new Client to All existing Players
NewPlayerMsg newPlayer = new NewPlayerMsg();
newPlayer.player.id = c.InternalId.ToString();
for (int i = 0; i < m_Connections.Length; i++)
{
Assert.IsTrue(m_Connections[i].IsCreated);
SendToClient(JsonUtility.ToJson(newPlayer), m_Connections[i]);
}
m_Connections.Add(c);
clientLookUpTable[c.InternalId.ToString()] = new NetworkObjects.NetworkPlayer();
clientLookUpTable[c.InternalId.ToString()].heartBeat = Time.time;
}
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 SendHandShake()
{
HandshakeMsg m = new HandshakeMsg();
m.player.id = m_Connection.InternalId.ToString();
SendToServer(JsonUtility.ToJson(m));
}
void OnConnect(NetworkConnection c)
{
Debug.Log("Accepted a connection");
HandshakeMsg m = new HandshakeMsg();
m.player.id = c.InternalId.ToString();
m.player.cubeColor = new Color(Random.Range(0, 1f), Random.Range(0, 1f), Random.Range(0, 1f));
SendToClient(JsonUtility.ToJson(m), c);
ListUpdateMsg lm = new ListUpdateMsg();
NetworkObjects.NetworkPlayer newPlayer = m.player;
newPlayer.lastHB = 0f;
playerList.Add(newPlayer); //
lm.players = playerList;
for (int i = 0; i < m_Connections.Length; ++i)
{
PlayerAddMsg am = new PlayerAddMsg();
am.player = m.player;
SendToClient(JsonUtility.ToJson(am), m_Connections[i]);
}
SendToClient(JsonUtility.ToJson(lm), c);
m_Connections.Add(c);
Debug.Log("Connect Init Finished");
}
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 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());
NetworkMessage header = JsonUtility.FromJson <NetworkMessage>(recMsg);
switch (header.cmd)
{
case Commands.HANDSHAKE:
HandshakeMsg hsMsg = JsonUtility.FromJson <HandshakeMsg>(recMsg);
AddPlayer(hsMsg);
break;
case Commands.PLAYER_UPDATE:
PlayerUpdateMsg puMsg = JsonUtility.FromJson <PlayerUpdateMsg>(recMsg);
UpdatePlayer(puMsg);
break;
case Commands.DISCONNECT:
DisconnectMsg dcMsg = JsonUtility.FromJson <DisconnectMsg>(recMsg);
RemovePlayer(dcMsg);
break;
default:
Debug.Log("SERVER ERROR: Unrecognized message received!");
break;
}
}
void OnConnect(NetworkConnection c)
{
m_Connections.Add(c);
Debug.Log("Accepted a connection");
Debug.Log("Added player:" + c.InternalId.ToString());
// Example to send a handshake message:
HandshakeMsg m = new HandshakeMsg();
m.player.id = c.InternalId.ToString();
//give the player a random starting location
m.player.cubPos = new Vector3(UnityEngine.Random.Range(-5, 5), UnityEngine.Random.Range(-5, 5), 0);
//add the new player to our list of connected players
connectedPlayers.Add(m.player);
SendToClient(JsonUtility.ToJson(m), c);
//send the new player all the other players and the other players the new player
foreach (NetworkConnection connection in m_Connections)
{
if (connection.IsCreated)
{
Debug.Log("Sending connected players to player:" + connection.InternalId.ToString());
NewPlayerUpdateMsg n = new NewPlayerUpdateMsg();
n.players = new List <NetworkObjects.NetworkPlayer>(connectedPlayers);
SendToClient(JsonUtility.ToJson(n), connection);
}
}
}
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;
}
}
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;
}
}
// 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;
}
}
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 HandShake()
{
//// Example to send a handshake message:
HandshakeMsg m = new HandshakeMsg();
m.player.id = m_Connection.InternalId.ToString();
SendToServer(JsonUtility.ToJson(m));
}
/**
* Client Response Functions from server messages
*/
// Response function to setup controlled players ID
void SetupClient(HandshakeMsg hsMsg) //done
{
controlledPlayer = Instantiate(playerPrefab);
controlledPlayer.GetComponent <PlayerController>().clientControlled = true;
controlledPlayer.GetComponent <PlayerController>().networkClient = this;
controlledPlayerUpdateMSG.player.id = hsMsg.player.id;
controlledClientID = hsMsg.player.id;
}
void SendRepeatedHandshake()
{
HandshakeMsg m = new HandshakeMsg();
m.player.id = myPlayer.id;
SendToServer(JsonUtility.ToJson(m));
Debug.Log("(Client: " + m.player.id.ToString() + ") Sending a handshake");
}
void OnConnect(NetworkConnection c)
{
m_connections.Add(c);
HandshakeMsg handshake = new HandshakeMsg();
handshake.player.id = c.InternalId.ToString();
SendToClient(JsonUtility.ToJson(handshake), c);
Debug.Log("New Client ID: " + handshake.player.id.ToString() + " Is Being Connected.");
}
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;
}
}
///-------------------Client Player Functions----------------------//
// Sends the client player to server to be included
void ConnectClientPlayer(HandshakeMsg msg)
{
clientPlayer.id = msg.player.id;
clientPlayer.pos = RandomPos(5);
HandshakeMsg handShake = new HandshakeMsg();
handShake.player = clientPlayer;
SendToServer(JsonUtility.ToJson(handShake));
}
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 OnConnect()
{
Debug.Log("We are now connected to the server");
HandshakeMsg m = new HandshakeMsg();
m.player.id = player.id;
SendToServer(JsonUtility.ToJson(m));
}
void HandShake()
{
foreach (NetworkConnection c in m_Connections)
{
//// Example to send a handshake message:
HandshakeMsg m = new HandshakeMsg();
m.player.id = c.InternalId.ToString();
SendToClient(JsonUtility.ToJson(m), c);
}
}
void Start()
{
if(rb == null) rb = GetComponent<Rigidbody>();
rb.isKinematic = !isLocalPlayer;
transform.SetParent(GameObject.Find("Play Area").transform);
transform.localPosition = Vector3.up * 2f;
if (this.isLocalPlayer)
{
HandshakeMsg msg = new HandshakeMsg();
msg.username = ((GameNetworkManager)NetworkManager.singleton).Username;
NetworkManager.singleton.client.Send(HandshakeMsg.msgType, msg);
}
}
