protected void ReadPacket(long connectionId, NetDataReader reader)
{
var msgType = reader.GetPackedUShort();
MessageHandlerDelegate handlerDelegate;
if (messageHandlers.TryGetValue(msgType, out handlerDelegate))
{
var messageHandler = new LiteNetLibMessageHandler(msgType, this, connectionId, reader);
handlerDelegate.Invoke(messageHandler);
}
}
protected void HandleServerPing(LiteNetLibMessageHandler messageHandler)
{
isPinging = false;
Rtt = Timestamp - pingTime;
// Time offset = server time - current timestamp - rtt
ServerUnixTimeOffset = messageHandler.reader.GetPackedLong() - Timestamp - Rtt;
if (LogDev)
{
Logging.Log(LogTag, "Rtt: " + Rtt + ", ServerUnixTimeOffset: " + ServerUnixTimeOffset);
}
}
protected virtual void HandleServerCallFunction(LiteNetLibMessageHandler messageHandler)
{
NetDataReader reader = messageHandler.reader;
LiteNetLibElementInfo info = LiteNetLibElementInfo.DeserializeInfo(reader);
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(info.objectId, out identity))
{
identity.ProcessNetFunction(info, reader, true);
}
}
protected virtual void HandleServerTime(LiteNetLibMessageHandler messageHandler)
{
// Server time updated at server, if this is host (client and server) then skip it.
if (IsServer)
{
return;
}
ServerTimeMessage message = messageHandler.ReadMessage <ServerTimeMessage>();
ServerUnixTimeOffset = message.serverUnixTime - Timestamp;
ServerTimeOffset = message.serverTime - Time.unscaledTime;
}
protected virtual void HandleClientCallFunction(LiteNetLibMessageHandler messageHandler)
{
NetDataReader reader = messageHandler.reader;
FunctionReceivers receivers = (FunctionReceivers)reader.GetByte();
long connectionId = -1;
if (receivers == FunctionReceivers.Target)
{
connectionId = reader.GetPackedLong();
}
LiteNetLibElementInfo info = LiteNetLibElementInfo.DeserializeInfo(reader);
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(info.objectId, out identity))
{
LiteNetLibFunction netFunction = identity.GetNetFunction(info);
if (netFunction == null)
{
// There is no net function that player try to call (player may try to hack)
return;
}
if (!netFunction.CanCallByEveryone && messageHandler.connectionId != identity.ConnectionId)
{
// The function not allowed anyone except owner client to call this net function
// And the client is also not the owner client
return;
}
if (receivers == FunctionReceivers.Server)
{
// Request from client to server, so hook callback at server immediately
identity.ProcessNetFunction(netFunction, reader, true);
}
else
{
// Request from client to other clients, so hook callback later
identity.ProcessNetFunction(netFunction, reader, false);
// Use call with out parameters set because parameters already set while process net function
if (receivers == FunctionReceivers.Target)
{
netFunction.CallWithoutParametersSet(connectionId);
}
else
{
netFunction.CallWithoutParametersSet(DeliveryMethod.ReliableOrdered, receivers);
}
}
}
}
protected virtual void HandleServerDestroyObject(LiteNetLibMessageHandler messageHandler)
{
ServerDestroyObjectMessage message = messageHandler.ReadMessage <ServerDestroyObjectMessage>();
if (!IsServer)
{
Assets.NetworkDestroy(message.objectId, message.reasons);
}
// If this is host and reasons is removed from subscribing so hide it, don't destroy it
LiteNetLibIdentity identity;
if (IsServer && message.reasons == DestroyObjectReasons.RemovedFromSubscribing && Assets.TryGetSpawnedObject(message.objectId, out identity))
{
identity.OnServerSubscribingRemoved();
}
}
protected virtual void HandleServerSpawnSceneObject(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <ServerSpawnSceneObjectMessage>();
if (!IsServer)
{
Assets.NetworkSpawnScene(message.objectId, message.position, message.rotation);
}
LiteNetLibIdentity identity;
// If it is host, it may hidden so show it
if (IsServer && Assets.TryGetSpawnedObject(message.objectId, out identity))
{
identity.OnServerSubscribingAdded();
}
}
protected virtual void HandleServerUpdateSyncList(LiteNetLibMessageHandler messageHandler)
{
// List updated at server, if this is host (client and server) then skip it.
if (IsServer)
{
return;
}
NetDataReader reader = messageHandler.reader;
LiteNetLibElementInfo info = LiteNetLibElementInfo.DeserializeInfo(reader);
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(info.objectId, out identity))
{
identity.ProcessSyncList(info, reader);
}
}
protected virtual void HandleClientSendTransform(LiteNetLibMessageHandler messageHandler)
{
NetDataReader reader = messageHandler.reader;
uint objectId = reader.GetPackedUInt();
byte behaviourIndex = reader.GetByte();
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(objectId, out identity))
{
LiteNetLibTransform netTransform;
if (identity.TryGetBehaviour(behaviourIndex, out netTransform))
{
netTransform.HandleClientSendTransform(reader);
}
}
}
protected virtual void HandleServerSyncBehaviour(LiteNetLibMessageHandler messageHandler)
{
// Behaviour sync from server, if this is host (client and server) then skip it.
if (IsServer)
{
return;
}
NetDataReader reader = messageHandler.reader;
uint objectId = reader.GetPackedUInt();
byte behaviourIndex = reader.GetByte();
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(objectId, out identity))
{
identity.ProcessSyncBehaviour(behaviourIndex, reader);
}
}
protected virtual void HandleServerSpawnObject(LiteNetLibMessageHandler messageHandler)
{
var message = messageHandler.ReadMessage <ServerSpawnObjectMessage>();
if (!IsServer)
{
Assets.NetworkSpawn(message.hashAssetId, message.position, message.rotation, message.objectId, 0);
}
// Setup owner client
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(message.objectId, out identity))
{
identity.SetOwnerClient(message.isOwner);
// If it is host, it may hidden so show it
if (IsServer)
{
identity.OnServerSubscribingAdded();
}
}
}
protected virtual void HandleClientUpdateSyncField(LiteNetLibMessageHandler messageHandler)
{
// Field updated at owner-client, if this is server then multicast message to other clients
if (!IsServer)
{
return;
}
NetDataReader reader = messageHandler.reader;
LiteNetLibElementInfo info = LiteNetLibElementInfo.DeserializeInfo(reader);
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(info.objectId, out identity))
{
LiteNetLibSyncField syncField = identity.GetSyncField(info);
// Sync field at server also have to be client multicast to allow it to multicast to other clients
if (syncField != null && syncField.syncMode == LiteNetLibSyncField.SyncMode.ClientMulticast)
{
// If this is server but it is not host, set data (deserialize) then pass to other clients
// If this is host don't set data because it's already did (in LiteNetLibSyncField class)
if (!identity.IsOwnerClient)
{
syncField.Deserialize(reader, false);
}
// Send to other clients
foreach (long connectionId in GetConnectionIds())
{
// Don't send the update to owner client because it was updated before send update to server
if (connectionId == messageHandler.connectionId)
{
continue;
}
// Send update to clients except owner client
if (identity.IsSubscribedOrOwning(connectionId))
{
syncField.SendUpdate(false, connectionId);
}
}
}
}
}
protected virtual void HandleServerSceneChange(LiteNetLibMessageHandler messageHandler)
{
// Server scene changes made from server, if this is host (client and server) then skip it.
if (IsServer)
{
return;
}
// Scene name sent from server
ServerSceneChangeMessage message = messageHandler.ReadMessage <ServerSceneChangeMessage>();
string serverSceneName = message.serverSceneName;
if (string.IsNullOrEmpty(serverSceneName) || serverSceneName.Equals(SceneManager.GetActiveScene().name))
{
Assets.Initialize();
OnClientOnlineSceneLoaded();
SendClientReady();
}
else
{
// If scene is difference, load changing scene
StartCoroutine(LoadSceneRoutine(serverSceneName, true));
}
}
protected virtual void HandleServerSpawnSceneObject(LiteNetLibMessageHandler messageHandler)
{
ServerSpawnSceneObjectMessage message = messageHandler.ReadMessage <ServerSpawnSceneObjectMessage>();
if (!IsServer)
{
Assets.NetworkSpawnScene(message.objectId, message.position, message.rotation);
}
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(message.objectId, out identity))
{
// If it is not server, read its initial data
if (!IsServer)
{
identity.ReadInitialSyncFields(messageHandler.reader);
}
// If it is host, it may hidden so show it
if (IsServer)
{
identity.OnServerSubscribingAdded();
}
}
}
protected virtual void HandleServerEnterGame(LiteNetLibMessageHandler messageHandler)
{
ClientConnectionId = messageHandler.reader.GetLong();
}
protected virtual void HandleClientEnterGame(LiteNetLibMessageHandler messageHandler)
{
SendServerSceneChange(messageHandler.connectionId, ServerSceneName);
}
protected virtual void HandleClientNotReady(LiteNetLibMessageHandler messageHandler)
{
SetPlayerNotReady(messageHandler.connectionId, messageHandler.reader);
}