public static LNSCreateRoomParameters FromReader(NetPacketReader reader)
{
if (reader.AvailableBytes > 0)
{
LNSCreateRoomParameters o = new LNSCreateRoomParameters();
try
{
o.isPublic = reader.GetBool();
if (reader.GetBool())
{
o.password = reader.GetString();
}
o.filters = LNSJoinRoomFilter.FromReader(reader);
o.maxPlayers = reader.GetInt();
o.isQuadTreeAllowed = reader.GetBool();
if (o.isQuadTreeAllowed)
{
Rect bounds = new Rect(reader.GetFloat(), reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
//bounds.center = new Vector2, reader.GetFloat());
o.quadTreeBounds = bounds;
}
o.idleLife = reader.GetLong();
}
catch
{
o.isQuadTreeAllowed = false;
}
return(o);
}
return(null);
}
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod delMethod)
{
Packet p = new Packet();
playerNewPos = p.PlayerPos;
ballNewPos.x = reader.GetFloat();
ballNewPos.z = reader.GetFloat();
var playerPos = clientPlayer.transform.position;
var ballPos = clientBall.transform.position;
playerOldPos = playerPos.z;
ballOldPos.x = ballPos.x;
ballOldPos.z = ballPos.z;
playerPos.z = playerNewPos;
ballPos.x = ballNewPos.x;
ballPos.z = ballNewPos.z;
clientPlayer.transform.position = playerPos;
clientBall.transform.position = ballPos;
playerLerpTime = 0f;
ballLerpTime = 0f;
}
void INetEventListener.OnNetworkReceive(NetPeer _netPeer, NetPacketReader _netPacketReader, DeliveryMethod deliveryMethod)
{
//_Processor.ReadAllPackets(_netPacketReader, _netPeer);
try
{
if (_netPacketReader.IsNull)
{
Console.WriteLine($"OnNetworkReceive <==== _netPacketReader.== null== null== null== null:");
return;
}
NetworkTags networkTag = (NetworkTags)_netPacketReader.GetInt();
if (networkTag == NetworkTags.Player_Position)
{
float x = _netPacketReader.GetFloat();
float y = _netPacketReader.GetFloat();
float z = _netPacketReader.GetFloat();
Console.WriteLine($"OnNetworkReceive <== UPDATE ID {_netPeer.Id} Tags.{networkTag}: {x} | {y} | {z}");
_dictionary_Server_Player[_netPeer.Id].X = x;
_dictionary_Server_Player[_netPeer.Id].Y = y;
_dictionary_Server_Player[_netPeer.Id].Z = z;
_dictionary_Server_Player[_netPeer.Id].Moved = true;
}
}
catch (Exception ex)
{
Console.WriteLine($"OnNetworkReceive Error: {ex.Message}");
}
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
recivedSpelarData = new SpelarData {
X = reader.GetFloat(),
Y = reader.GetFloat(),
Attack = reader.GetBool()
};
reader.Recycle();
}
public static void RecievePlayerSync(NetPacketReader reader)
{
int id = reader.GetInt();
if (!playerEnts.ContainsKey(id))
{
reader.Clear();
return;
}
playerEnts[id].pos.x = reader.GetFloat();
playerEnts[id].pos.y = reader.GetFloat();
playerEnts[id].angle = reader.GetFloat();
}
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod delMethod)
{
if (reader.RawData == null)
{
return;
}
Debug.Log("Client || OnNetworkReceive: " + reader.RawData.Length);
if (reader.RawData.Length >= 4)
{
NetworkTags netTag = (NetworkTags)reader.GetInt();
if (netTag == NetworkTags.PlayerPositionsArray)
{
int lengthArray = (reader.RawData.Length - 4) / (sizeof(long) + sizeof(float) * 3);
Debug.Log("Client || Positions array data num: " + lengthArray);
for (int i = 0; i < lengthArray; i++)
{
long playerId = reader.GetLong();
if (!netDictionary.ContainsKey(playerId))
{
netDictionary.Add(playerId, new NetPlayer());
}
netDictionary[playerId].Z = reader.GetFloat();
}
}
}
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
var pos = _player.transform.position;
pos.x = reader.GetFloat();
_player.transform.position = pos;
Debug.Log($"{this.name} : OnNetworkReceive");
}
public static object Read(NetPacketReader message)
{
var p = new ObjectUpdatePacket();
p.Tick = message.GetUInt();
p.PlayerHealth = message.GetFloat();
p.PlayerShield = message.GetFloat();
var pack = new BitReader(message.GetRemainingBytes(), 0);
var updateCount = pack.GetUInt(8);
p.Updates = new PackedShipUpdate[updateCount];
for (int i = 0; i < p.Updates.Length; i++)
{
p.Updates[i] = PackedShipUpdate.ReadFrom(ref pack);
}
return(p);
}
public static object Read(NetPacketReader message)
{
return(new PositionUpdatePacket()
{
Position = message.GetVector3(),
Orientation = message.GetQuaternion(),
Speed = message.GetFloat()
});
}
public static object Read(NetPacketReader message)
{
return(new SpawnDebrisPacket()
{
ID = message.GetInt(),
Archetype = message.GetString(),
Part = message.GetString(),
Position = message.GetVector3(),
Orientation = message.GetQuaternion(),
Mass = message.GetFloat()
});
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
_newBallPosX = reader.GetFloat();
var pos = _clientBall.transform.position;
_oldBallPosX = pos.x;
pos.x = _newBallPosX;
_clientBall.transform.position = pos;
_lerpTime = 0f;
}
public static NetShipLoadout Read(NetPacketReader message)
{
var s = new NetShipLoadout();
s.ShipCRC = message.GetUInt();
s.Health = message.GetFloat();
var cargoCount = (int)message.GetVariableUInt32();
s.Items = new List <NetShipCargo>(cargoCount);
for (int i = 0; i < cargoCount; i++)
{
s.Items.Add(new NetShipCargo(message.GetInt(), message.GetUInt(), message.GetUInt(), message.GetByte(), message.GetInt()));
}
return(s);
}
private void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
switch (reader.GetInt())
{
case 0:
Vector3 vec = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
transform.position = vec;
break;
case 1:
int id = reader.GetInt();
float x = reader.GetFloat();
float y = reader.GetFloat();
float z = reader.GetFloat();
string url = reader.GetString();
foreach (var speak in speakers)
{
if (speak.id == id)
{
speak.x = x;
speak.y = y;
speak.z = z;
speak.url = url;
StartCoroutine(DownloadAudioCli(speak.obj, url));
speak.obj.transform.position = new Vector3(x, y, z);
return;
}
}
var obj = Instantiate(defaultObj);
obj.transform.position = new Vector3(x, y, z);
StartCoroutine(DownloadAudioCli(obj, url));
speakers.Add(new Speaker()
{
id = id,
x = x,
y = y,
z = z,
url = url,
obj = obj
});
break;
case 2:
int id2 = reader.GetInt();
foreach (var speak in speakers)
{
if (speak.id == id2)
{
speakers.Remove(speak);
}
}
break;
}
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.RawData == null)
{
return;
}
if (reader.RawData.Length >= 4)
{
NetworkTags networkTag = (NetworkTags)reader.GetInt();
if (networkTag == NetworkTags.StartGame)
{
Debug.Log("[CLIENT] StartGame resieved");
ball.gameObject.SetActive(true);
if (id == 0)
{
Destroy(ball.GetComponent <Ball>());
}
}
else if (networkTag == NetworkTags.PlayerPositionsArray)
{
int lengthArr = (reader.RawData.Length - 4) / (sizeof(long) + sizeof(float) * 3);
Debug.Log("Got positions array data num : " + lengthArr);
for (int i = 0; i < lengthArr; i++)
{
long playerid = reader.GetLong();
if (!netPlayersDictionary.ContainsKey(playerid))
{
netPlayersDictionary.Add(playerid, new NetPlayer());
id = (int)playerid;
}
netPlayersDictionary[playerid].X = reader.GetFloat();
netPlayersDictionary[playerid].Y = reader.GetFloat();
netPlayersDictionary[playerid].Z = reader.GetFloat();
}
}
else if (networkTag == NetworkTags.BallPosition)
{
float x = reader.GetFloat();
float y = reader.GetFloat();
float z = reader.GetFloat();
ball.transform.position = new Vector3(x, y, z);
}
}
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.RawData == null)
{
return;
}
NetworkTags networkTag = (NetworkTags)reader.GetInt();
if (networkTag == NetworkTags.PlayerPosition)
{
float x = reader.GetFloat();
float y = reader.GetFloat();
float z = reader.GetFloat();
Debug.Log("Got position packet : " + x + " " + y + " " + z);
playersDictionary[peer.Id].X = x;
playersDictionary[peer.Id].Y = y;
playersDictionary[peer.Id].Z = z;
playersDictionary[peer.Id].Moved = true;
}
if (networkTag == NetworkTags.BallPosition)
{
float x = reader.GetFloat();
float y = reader.GetFloat();
float z = reader.GetFloat();
NetDataWriter writer = new NetDataWriter();
writer.Reset();
writer.Put((int)networkTag);
writer.Put(x);
writer.Put(y);
writer.Put(z);
foreach (var player in playersDictionary)
{
if (player.Key == 1)
{
player.Value.NetPeer.Send(writer, DeliveryMethod.ReliableOrdered);
}
}
}
}
void UpdatePlayerTransform(NetPeer peer, NetPacketReader reader)
{
if ((reader.UserDataSize - 4) == NetworkDataSize.Transform)
{
float posX = reader.GetFloat();
float posY = reader.GetFloat();
float posZ = reader.GetFloat();
float rotX = reader.GetFloat();
float rotY = reader.GetFloat();
float rotZ = reader.GetFloat();
float rotW = reader.GetFloat();
_networkPlayerDictionary[peer.Id].Position.x = posX;
_networkPlayerDictionary[peer.Id].Position.y = posY;
_networkPlayerDictionary[peer.Id].Position.z = posZ;
_networkPlayerDictionary[peer.Id].Rotation.x = rotX;
_networkPlayerDictionary[peer.Id].Rotation.y = rotY;
_networkPlayerDictionary[peer.Id].Rotation.z = rotZ;
_networkPlayerDictionary[peer.Id].Rotation.w = rotW;
_networkPlayerDictionary[peer.Id].Moved = true;
}
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
byte messageType = reader.GetByte();
if (messageType == GameServer.MESSAGE_OBJECT_BATCH)
{
NetworkedObject.NetworkReadAll(reader);
}
else if (messageType == GameServer.MESSAGE_CLIENT_INFO)
{
ownerId = reader.GetInt();
serverSyncTime = reader.GetFloat();
clientSyncTime = Time.time;
Debug.Log("Set client ID to " + ownerId);
}
else if (messageType == GameServer.MESSAGE_OBJECT_DESTROY)
{
NetworkedObject.HandleDestroyMessage(reader, peer.Id);
}
else if (messageType == GameServer.MESSAGE_COMPONENT_CUSTOM)
{
NetworkedObject.HandleComponentMessage(reader, peer.Id);
}
}
void UpdateNetworkPlayerPosition(NetPeer peer, NetPacketReader reader)
{
int dataNum = (reader.UserDataSize - 4) / NetworkDataSize.PlayerIdAndTransform;
for (int i = 0; i < dataNum; i++)
{
int playerId = reader.GetInt();
float posX = reader.GetFloat();
float posY = reader.GetFloat();
float posZ = reader.GetFloat();
float rotX = reader.GetFloat();
float rotY = reader.GetFloat();
float rotZ = reader.GetFloat();
float rotW = reader.GetFloat();
if (!_networkPlayersDictionary.ContainsKey(playerId))
{
GameObject go = GameObject.Instantiate(NetworkPlayerPrefab, new Vector3(posX, posY, posZ), new Quaternion(rotX, rotY, rotZ, rotW));
_networkPlayersDictionary.Add(playerId, go.transform);
}
Vector3 position = _networkPlayersDictionary[playerId].position;
position.x = posX;
position.y = posY;
position.z = posZ;
Quaternion rotation = _networkPlayersDictionary[playerId].rotation;
rotation.x = rotX;
rotation.y = rotY;
rotation.z = rotZ;
rotation.w = rotW;
_networkPlayersDictionary[playerId].position = position;
_networkPlayersDictionary[playerId].rotation = rotation;
}
}
public void ProcessReceivedData(LNSClient from, byte instructionCode, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
byte code = instructionCode;
if (code == LNSConstants.SERVER_EVT_LOCK_ROOM)
{
if (from.id == masterClient.id)
{
isOpen = false;
}
return;
}
else if (code == LNSConstants.SERVER_EVT_UNLOCK_ROOM)
{
if (from.id == masterClient.id)
{
isOpen = true;
}
return;
}
else if (code == LNSConstants.SERVER_EVT_RAW_DATA_TO_CLIENT)
{
string targetid = reader.GetString();
lock (thelock)
{
for (int i = 0; i < clients.Count; i++)
{
var targetClient = clients.Find(client => client.id == targetid);
writer.Reset();
writer.Put(LNSConstants.CLIENT_EVT_ROOM_RAW);
writer.Put(from.id);
writer.Put(reader.GetRemainingBytes());
targetClient.peer.Send(writer, deliveryMethod);
}
}
}
else if (code == LNSConstants.SERVER_EVT_RAW_DATA_TO_NEARBY_CLIENTS)
{
if (roomParameters.isQuadTreeAllowed)
{
Rect searchRect = new Rect(reader.GetFloat(), reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
from.position = searchRect.center;
lock (thelock)
{
quadTreeSearchResults.Clear();
quadTree.RetrieveObjectsInAreaNoAlloc(searchRect, ref quadTreeSearchResults);
//Debug.LogFormat("From {0} - Search Rect {1},{2} {3},{4} - Found: {5}", from.id, searchRect.center.x, searchRect.center.x, searchRect.width, searchRect.height, quadTreeSearchResults.Count);
writer.Reset();
writer.Put(LNSConstants.CLIENT_EVT_ROOM_RAW);
writer.Put(from.id);
writer.Put(reader.GetRemainingBytes());
for (int i = 0; i < quadTreeSearchResults.Count; i++)
{
if (quadTreeSearchResults[i].networkid != from.networkid)
{
quadTreeSearchResults[i].peer.Send(writer, deliveryMethod);
}
}
}
}
}
else if (code == LNSConstants.SERVER_EVT_RAW_DATA_CACHE)
{
lock (thelock)
{
string key = reader.GetString();
byte[] value = reader.GetRemainingBytes();
if (value.Length <= 1000)
{
if (persistentData.ContainsKey(key))
{
persistentData[key] = value;
}
else
{
persistentData.Add(key, value);
}
writer.Reset();
writer.Put(LNSConstants.CLIENT_EVT_ROOM_CACHE_DATA);
writer.Put(key);
writer.Put(value);
for (int i = 0; i < clients.Count; i++)
{
clients[i].peer.Send(writer, DeliveryMethod.ReliableOrdered);
}
}
}
}
else
{
lock (thelock)
{
writer.Reset();
writer.Put(LNSConstants.CLIENT_EVT_ROOM_RAW);
writer.Put(from.id);
writer.Put(reader.GetRemainingBytes());
for (int i = 0; i < clients.Count; i++)
{
if (clients[i].networkid != from.networkid)
{
clients[i].peer.Send(writer, deliveryMethod);
}
}
}
}
}
private static void OnListenerOnNetworkReceiveEvent(NetPeer fromPeer, NetPacketReader dataReader,
DeliveryMethod deliveryMethod)
{
ushort msgid = dataReader.GetUShort();
NetDataWriter writer = new NetDataWriter();
switch (msgid)
{
case 1:
var playerId = dataReader.GetInt();
var pName = dataReader.GetString();
var isHost = dataReader.GetBool();
var charId = dataReader.GetInt();
var pColorR = dataReader.GetFloat();
var pColorG = dataReader.GetFloat();
var pColorB = dataReader.GetFloat();
var player = new Player(fromPeer, playerId, isHost, pName, charId, pColorR, pColorG, pColorB);
Players.Add(playerId, player);
player.SendNewPlayerData(writer);
SendOthers(fromPeer, writer, DeliveryMethod.ReliableOrdered);
Console.WriteLine("registering player " + pName + " pid " + playerId);
break;
case 101: //create networkObject
int objectId;
do
{
objectId = rand.Next(1000000, 9999999);
} while (NetworkObjects.ContainsKey(objectId));
var netObj = new NetworkObject(
fromPeer,
dataReader.GetInt(),
objectId,
dataReader.GetInt(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat(),
dataReader.GetFloat());
NetworkObjects.Add(objectId, netObj);
netObj.SendObjectData(writer);
server.SendToAll(writer, DeliveryMethod.ReliableOrdered);
break;
case 102:
var objectToDelete = dataReader.GetInt();
NetworkObjects.Remove(objectToDelete);
writer.Put((ushort)102);
writer.Put(objectToDelete);
server.SendToAll(writer, DeliveryMethod.ReliableOrdered);
break;
case 103:
var objectToUpdate = dataReader.GetInt();
if (NetworkObjects.ContainsKey(objectToUpdate))
{
NetworkObjects[objectToUpdate].ReadData(dataReader);
NetworkObjects[objectToUpdate].WriteData(writer);
SendOthers(fromPeer, writer, DeliveryMethod.Unreliable);
}
break;
case 201:
byte[] data = new byte[dataReader.UserDataSize];
Array.Copy(dataReader.RawData, dataReader.UserDataOffset, data, 0, dataReader.UserDataSize);
var target = dataReader.GetByte();
var rpcName = dataReader.GetString();
var rpcObjectId = dataReader.GetInt();
switch (target)
{
case 0:
NetworkObjects[rpcObjectId].peer.Send(data, DeliveryMethod.ReliableUnordered);
break;
case 1:
SendOthers(NetworkObjects[rpcObjectId].peer, data, DeliveryMethod.ReliableUnordered);
break;
case 2:
server.SendToAll(data, DeliveryMethod.ReliableUnordered);
break;
}
break;
}
dataReader.Recycle();
}
void ReceivePackage(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
client.Statistics.BytesReceived += (ulong)reader.RawDataSize;
client.Statistics.PacketsReceived++;
NetDataWriter writer = new NetDataWriter();
ushort msgid = reader.GetUShort();
Debug.Log(msgid);
switch (msgid)
{
case 1: //register to server
var networkId = reader.GetInt();
var playerId = reader.GetInt();
var isHost = reader.GetBool();
var charId = 0;
var playerColor = _myColor;
var pName = _myName;
MyNetworkId = networkId;
IsHost = isHost;
InitPlayer(networkId, playerId, pName, isHost, charId, playerColor);
writer.Put((ushort)1);
writer.Put(playerId);
writer.Put(pName);
writer.Put(isHost);
writer.Put(charId);
writer.Put(playerColor.r);
writer.Put(playerColor.g);
writer.Put(playerColor.b);
Send(writer, DeliveryMethod.ReliableOrdered);
writer.Reset();
LobbyManager.Instance.NeedUpdate = true;
break;
case 2: //register new player;
var newNetworkId = reader.GetInt();
var newPlayerId = reader.GetInt();
var npName = reader.GetString();
var nIsHost = reader.GetBool();
var newCharId = reader.GetInt();
var newPlayerColor = new Color(
reader.GetFloat(),
reader.GetFloat(),
reader.GetFloat());
InitPlayer(newNetworkId, newPlayerId, npName, nIsHost, newCharId, newPlayerColor);
LobbyManager.Instance.NeedUpdate = true;
break;
case 3: //remove disconnected player
var rnid = reader.GetInt();
List <int> plrs = new List <int>();
foreach (var pl in Players)
{
if (pl.Value.networkId == rnid)
{
plrs.Add(pl.Key);
}
}
foreach (var i in plrs)
{
Players.Remove(i);
}
foreach (var no in NetworkObjects)
{
if (no.Value.networkId == rnid)
{
objectsToDestroy.Add(no.Key);
}
}
LobbyManager.Instance.NeedUpdate = true;
break;
case 4:
Players[reader.GetInt()].ReadPlayerData(reader);
LobbyManager.Instance.NeedUpdate = true;
break;
case 101:
var OBobjectType = reader.GetInt();
var OBobjectId = reader.GetInt();
var OBplayerId = reader.GetInt();
var OBnetId = reader.GetInt();
var OBposX = reader.GetFloat();
var OBposY = reader.GetFloat();
var OBposZ = reader.GetFloat();
var OBrotX = reader.GetFloat();
var OBrotY = reader.GetFloat();
var OBrotZ = reader.GetFloat();
var OBrotW = reader.GetFloat();
var OBpos = new Vector3(OBposX, OBposY, OBposZ);
var OBrot = new Quaternion(OBrotX, OBrotY, OBrotZ, OBrotW);
var OBnetObj = objectDataFactory.createObjectData(
OBobjectType,
OBnetId,
OBplayerId,
OBobjectId,
OBpos,
OBrot);
objectsToCreate.Add(OBnetObj);
break;
case 102:
var objectToDelete = reader.GetInt();
objectsToDestroy.Add(objectToDelete);
break;
case 103:
var UobjectId = reader.GetInt();
if (NetworkObjects.ContainsKey(UobjectId))
{
NetworkObjects[UobjectId].ReadData(reader);
}
break;
case 201:
var rpcTarget = reader.GetByte();
var rpcName = reader.GetString();
var rpcObjectId = reader.GetInt();
rpcList.Add(new Tuple <string, int, byte[]>(rpcName, rpcObjectId, reader.GetRemainingBytes()));
break;
case 301:
var levelId = reader.GetInt();
LevelToLoad = levelId;
break;
}
reader.Recycle();
}
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
{
if (reader.IsNull)
{
return;
}
// Debug.Log($" <--------------------- OnNetworkReceive: {reader.AvailableBytes}");
if (reader.AvailableBytes >= 4)
{
NetworkTags networkTag = (NetworkTags)reader.GetInt();
if (networkTag == NetworkTags.N_Players_Moved_Array)
{
int Nb_de_player = reader.GetInt();
// int Nb_de_player_O = (reader.AvailableBytes - 4) / (sizeof(long) + sizeof(float) * 3);//pour info
Debug.Log($" <--------------------- OnNetworkReceive - FOUND NetworkTags.{networkTag} Total player MOVED = { Nb_de_player} ");// ORIGINAL CODE = { Nb_de_player_O}");
if (!player_spown_decalage && (0 < Nb_de_player))
{
Vector3 new_Local_player_pose = new Vector3(player.transform.position.x + (1.5f * Nb_de_player), player.transform.position.y, player.transform.position.z);
player.transform.position = new_Local_player_pose;
Debug.Log($" <--------------------- OnNetworkReceive - ---------------> Decalage Player POSE {player.transform.position.x + (2f * Nb_de_player)} | {player.transform.position.y} | { player.transform.position.z}");
player_spown_decalage = true;
OnPeerConnected_ok = true;
}
for (int i = 0; i < Nb_de_player; i++)
{
int playerid = reader.GetInt();
if (!Dictionary_NetPlayer.ContainsKey(playerid))
{
Dictionary_NetPlayer.Add(playerid, new NetPlayer());
Debug.Log($" <--------------------- OnNetworkReceive CREAT NEW Dictionary_NetPlayer.Add ---> SERVER netpeer.id = " + playerid);
}
//Get online player MOVED inputs
//
//
//
//
//
//
Dictionary_NetPlayer[playerid].X = reader.GetFloat();
Dictionary_NetPlayer[playerid].Y = reader.GetFloat();
Dictionary_NetPlayer[playerid].Z = reader.GetFloat();
Debug.Log($" <--------------------- OnNetworkReceive UPDATE Dictionary_NetPlayer SERVER Playerid = SERVER netpeer.id = {playerid} POSE = " +
$" X = { Dictionary_NetPlayer[playerid].X } Y = { Dictionary_NetPlayer[playerid].Y} Z = { Dictionary_NetPlayer[playerid].Z}");
//
//
//
//
//
//
//
//
//
}
}
else if (networkTag == NetworkTags.No_Player_Online)
{
Debug.Log($" <--------------------- OnNetworkReceive: {NetworkTags.No_Player_Online} player_spown_decalage ANULLER OK AvailableBytes = {reader.AvailableBytes}");
player_spown_decalage = true;
OnPeerConnected_ok = true;
}
else if (networkTag == NetworkTags.On_Player_Disconected)
{
int Disconnected_netPeer_Id = reader.GetInt();
Debug.Log($" <--------------------- OnNetworkReceive: {NetworkTags.On_Player_Disconected} ID = {Disconnected_netPeer_Id} ");
if (Dictionary_NetPlayer.ContainsKey(Disconnected_netPeer_Id))
{
Destroy(Dictionary_NetPlayer[Disconnected_netPeer_Id].GameObject);
Dictionary_NetPlayer.Remove(Disconnected_netPeer_Id);
Debug.Log($" <--------------------- OnNetworkReceive: {NetworkTags.On_Player_Disconected} SUPRESION Disconected Player ID = {Disconnected_netPeer_Id}");
}
}
}
}