protected virtual void HandleClientCallFunction(LiteNetLibMessageHandler messageHandler)
{
var reader = messageHandler.reader;
FunctionReceivers receivers = (FunctionReceivers)reader.GetByte();
long connectId = 0;
if (receivers == FunctionReceivers.Target)
{
connectId = (long)reader.GetPackedULong();
}
var info = LiteNetLibElementInfo.DeserializeInfo(reader);
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(info.objectId, out identity))
{
if (receivers == FunctionReceivers.Server)
{
identity.ProcessNetFunction(info, reader, true);
}
else
{
var netFunction = identity.ProcessNetFunction(info, reader, false);
if (receivers == FunctionReceivers.Target)
{
netFunction.Call(connectId);
}
else
{
netFunction.Call(receivers);
}
}
}
}
protected virtual void HandleClientCallFunction(LiteNetLibMessageHandler messageHandler)
{
NetDataReader reader = messageHandler.reader;
FunctionReceivers receivers = (FunctionReceivers)reader.GetByte();
long connectionId = -1;
if (receivers == FunctionReceivers.Target)
{
connectionId = (long)reader.GetPackedULong();
}
LiteNetLibElementInfo info = LiteNetLibElementInfo.DeserializeInfo(reader);
LiteNetLibIdentity identity;
if (Assets.TryGetSpawnedObject(info.objectId, out identity))
{
if (receivers == FunctionReceivers.Server)
{
identity.ProcessNetFunction(info, reader, true);
}
else
{
LiteNetLibFunction netFunction = identity.ProcessNetFunction(info, 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 void SendCall(FunctionReceivers receivers, long connectId)
{
var manager = Manager;
var peers = manager.Peers;
if (manager.IsServer)
{
switch (receivers)
{
case FunctionReceivers.Target:
NetPeer targetPeer;
if (peers.TryGetValue(connectId, out targetPeer))
{
SendCallForServer(targetPeer, receivers, connectId);
}
break;
case FunctionReceivers.All:
foreach (var peer in peers.Values)
{
SendCallForServer(peer, receivers, connectId);
}
break;
}
}
else if (manager.IsClientConnected)
{
SendCallForClient(receivers, connectId);
}
}
private void SerializeForClientSend(NetDataWriter writer, FunctionReceivers receivers, long connectionId)
{
writer.Put((byte)receivers);
if (receivers == FunctionReceivers.Target)
{
writer.PutPackedLong(connectionId);
}
SerializeForSend(writer);
}
internal void CallWithoutParametersSet(FunctionReceivers receivers)
{
if (!CanSync())
{
return;
}
SendCall(0, DeliveryMethod.ReliableOrdered, receivers, ConnectionId);
}
public void CallWithoutParametersSet(DeliveryMethod deliveryMethod, FunctionReceivers receivers)
{
if (!ValidateBeforeAccess())
{
return;
}
SendCall(deliveryMethod, receivers, ConnectionId);
}
protected void SerializeForClient(NetDataWriter writer, FunctionReceivers receivers, long connectionId)
{
writer.Put((byte)receivers);
if (receivers == FunctionReceivers.Target)
{
writer.PutPackedULong((ulong)connectionId);
}
SerializeForSend(writer);
}
public void Call(DeliveryMethod deliveryMethod, FunctionReceivers receivers, params object[] parameterValues)
{
if (!ValidateBeforeAccess())
{
return;
}
SetParameters(parameterValues);
SendCall(deliveryMethod, receivers, ConnectionId);
}
internal void Call(byte dataChannel, DeliveryMethod deliveryMethod, FunctionReceivers receivers, params object[] parameterValues)
{
if (!CanSync())
{
return;
}
SetParameters(parameterValues);
SendCall(dataChannel, deliveryMethod, receivers, ConnectionId);
}
public void Call(FunctionReceivers receivers, params object[] parameterValues)
{
if (!ValidateBeforeAccess())
{
return;
}
SetParameters(parameterValues);
SendCall(receivers, Behaviour.ConnectionId);
}
protected void SendCall(DeliveryMethod deliveryMethod, FunctionReceivers receivers, long targetConnectionId)
{
LiteNetLibGameManager manager = Manager;
if (manager.IsServer)
{
switch (receivers)
{
case FunctionReceivers.Target:
if (Identity.IsSubscribedOrOwning(targetConnectionId) && manager.ContainsConnectionId(targetConnectionId))
{
// Send function call message from server to target client by target connection Id
ServerSendCall(targetConnectionId, deliveryMethod);
}
break;
case FunctionReceivers.All:
foreach (long connectionId in manager.GetConnectionIds())
{
if (Manager.ClientConnectionId == connectionId)
{
// This is host's networking oject, so hook callback immediately
// Don't have to send message to the client, because it is currently run as both server and client
HookCallback();
}
else if (Identity.IsSubscribedOrOwning(connectionId))
{
// Send message to subscribing clients
ServerSendCall(connectionId, deliveryMethod);
}
}
if (!Manager.IsClientConnected)
{
// It's not a host(client+host), it's just a server
// So hook callback immediately to do the function at server
HookCallback();
}
break;
case FunctionReceivers.Server:
// Call server function at server
// So hook callback immediately to do the function at server
HookCallback();
break;
}
}
else if (manager.IsClientConnected)
{
// Client send net function call to server
// Then the server will hook callback or forward message to other clients
ClientSendCall(deliveryMethod, receivers, targetConnectionId);
}
}
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);
}
}
}
}
public void CallNetFunction(string id, DeliveryMethod deliveryMethod, FunctionReceivers receivers, params object[] parameters)
{
int elementId;
if (netFunctionIds.TryGetValue(id, out elementId))
{
Identity.netFunctions[elementId].Call(deliveryMethod, receivers, parameters);
}
else
{
if (Manager.LogError)
{
Debug.LogError("[" + name + "] [" + TypeName + "] cannot call function, function [" + id + "] not found.");
}
}
}
public void CallNetFunction(string id, FunctionReceivers receivers, params object[] parameters)
{
ushort elementId;
if (netFunctionIds.TryGetValue(id, out elementId))
{
var syncFunction = netFunctions[elementId];
syncFunction.Call(receivers, parameters);
}
else
{
if (Manager.LogError)
{
Debug.LogError("[" + name + "] [" + TypeName + "] cannot call function, function [" + id + "] not found.");
}
}
}
protected void SendCall(FunctionReceivers receivers, long targetConnectionId)
{
var manager = Manager;
if (manager.IsServer)
{
switch (receivers)
{
case FunctionReceivers.Target:
if (Behaviour.Identity.IsSubscribedOrOwning(targetConnectionId) && manager.ContainsConnectionId(targetConnectionId))
{
ServerSendCall(targetConnectionId, receivers, targetConnectionId);
}
break;
case FunctionReceivers.All:
foreach (var connectionId in manager.GetConnectionIds())
{
if (Behaviour.Identity.IsSubscribedOrOwning(connectionId))
{
ServerSendCall(connectionId, receivers, targetConnectionId);
}
}
if (!Manager.IsClientConnected)
{
HookCallback();
}
break;
case FunctionReceivers.Server:
HookCallback();
break;
}
}
else if (manager.IsClientConnected)
{
ClientSendCall(receivers, targetConnectionId);
}
}
protected void SendCall(DeliveryMethod deliveryMethod, FunctionReceivers receivers, long targetConnectionId)
{
LiteNetLibGameManager manager = Manager;
if (manager.IsServer)
{
switch (receivers)
{
case FunctionReceivers.Target:
if (Identity.IsSubscribedOrOwning(targetConnectionId) && manager.ContainsConnectionId(targetConnectionId))
{
ServerSendCall(targetConnectionId, deliveryMethod, receivers, targetConnectionId);
}
break;
case FunctionReceivers.All:
foreach (long connectionId in manager.GetConnectionIds())
{
if (Identity.IsSubscribedOrOwning(connectionId))
{
ServerSendCall(connectionId, deliveryMethod, receivers, targetConnectionId);
}
}
if (!Manager.IsClientConnected)
{
HookCallback();
}
break;
case FunctionReceivers.Server:
HookCallback();
break;
}
}
else if (manager.IsClientConnected)
{
ClientSendCall(deliveryMethod, receivers, targetConnectionId);
}
}
public void CallNetFunction <T1, T2>(NetFunctionDelegate <T1, T2> func, FunctionReceivers receivers, T1 param1, T2 param2)
{
CallNetFunction(func.Method.Name, DeliveryMethod.ReliableOrdered, receivers, param1, param2);
}
protected void ServerSendCall(long connectionId, DeliveryMethod deliveryMethod, FunctionReceivers receivers, long targetConnectionId)
{
SendingConnectionId = connectionId;
Manager.ServerSendPacket(connectionId, deliveryMethod, LiteNetLibGameManager.GameMsgTypes.CallFunction, (writer) => SerializeForSend(writer));
}
protected void ClientSendCall(DeliveryMethod deliveryMethod, FunctionReceivers receivers, long targetConnectionId)
{
Manager.ClientSendPacket(deliveryMethod, LiteNetLibGameManager.GameMsgTypes.CallFunction, (writer) => SerializeForClient(writer, receivers, targetConnectionId));
}
protected void ClientSendCall(FunctionReceivers receivers, long targetConnectionId)
{
Manager.ClientSendPacket(SendOptions.ReliableOrdered, LiteNetLibGameManager.GameMsgTypes.ClientCallFunction, (writer) => SerializeForClient(writer, receivers, targetConnectionId));
}
protected void ServerSendCall(long connectionId, FunctionReceivers receivers, long targetConnectionId)
{
Manager.ServerSendPacket(connectionId, SendOptions.ReliableOrdered, LiteNetLibGameManager.GameMsgTypes.ServerCallFunction, (writer) => SerializeForSend(writer));
}
public void CallNetFunction(NetFunctionDelegate func, FunctionReceivers receivers)
{
CallNetFunction(func.Method.Name, DeliveryMethod.ReliableOrdered, receivers);
}
protected void SendCall(byte dataChannel, DeliveryMethod deliveryMethod, FunctionReceivers receivers, long targetConnectionId)
{
LiteNetLibGameManager manager = Manager;
LiteNetLibServer server = manager.Server;
LiteNetLibClient client = manager.Client;
if (manager.IsServer)
{
switch (receivers)
{
case FunctionReceivers.Target:
if (Identity.HasSubscriberOrIsOwning(targetConnectionId) && manager.ContainsConnectionId(targetConnectionId))
{
// Prepare packet
TransportHandler.WritePacket(ServerWriter, GameMsgTypes.CallFunction);
SerializeForSend(ServerWriter);
// Send function call message from server to target client by target connection Id
server.SendMessage(targetConnectionId, dataChannel, deliveryMethod, ServerWriter);
}
break;
case FunctionReceivers.All:
// Send to all connections
foreach (long connectionId in manager.GetConnectionIds())
{
if (manager.ClientConnectionId == connectionId)
{
// This is host's networking oject, so hook callback immediately
// Don't have to send message to the client, because it is currently run as both server and client
HookCallback();
}
else if (Identity.HasSubscriberOrIsOwning(connectionId))
{
// Prepare packet
TransportHandler.WritePacket(ServerWriter, GameMsgTypes.CallFunction);
SerializeForSend(ServerWriter);
// Send message to subscribing clients
server.SendMessage(connectionId, dataChannel, deliveryMethod, ServerWriter);
}
}
if (!manager.IsClientConnected)
{
// It's not a host(client+host), it's just a server
// So hook callback immediately to do the function at server
HookCallback();
}
break;
case FunctionReceivers.Server:
// Call server function at server
// So hook callback immediately to do the function at server
HookCallback();
break;
}
}
else if (manager.IsClientConnected)
{
// Prepare packet
TransportHandler.WritePacket(ClientWriter, GameMsgTypes.CallFunction);
SerializeForClientSend(ClientWriter, receivers, targetConnectionId);
// Client send net function call to server
// Then the server will hook callback or forward message to other clients
client.SendMessage(dataChannel, deliveryMethod, ClientWriter);
}
}
public void CallNetFunction <T1, T2, T3, T4, T5, T6>(NetFunctionDelegate <T1, T2, T3, T4, T5, T6> func, DeliveryMethod deliveryMethod, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)
{
CallNetFunction(func.Method.Name, deliveryMethod, receivers, param1, param2, param3, param4, param5, param6);
}
public void CallNetFunction <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(NetFunctionDelegate <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func, DeliveryMethod deliveryMethod, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)
{
CallNetFunction(func.Method.Name, deliveryMethod, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
}
public void CallNetFunction <T1, T2, T3>(NetFunctionDelegate <T1, T2, T3> func, DeliveryMethod deliveryMethod, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3)
{
CallNetFunction(func.Method.Name, deliveryMethod, receivers, param1, param2, param3);
}
public void CallNetFunction <T1>(NetFunctionDelegate <T1> func, DeliveryMethod deliveryMethod, FunctionReceivers receivers, T1 param1)
{
CallNetFunction(func.Method.Name, deliveryMethod, receivers, param1);
}
public void CallNetFunction(NetFunctionDelegate func, DeliveryMethod deliveryMethod, FunctionReceivers receivers)
{
CallNetFunction(func.Method.Name, deliveryMethod, receivers);
}
public void CallNetFunction <T1, T2, T3, T4, T5, T6, T7, T8, T9>(NetFunctionDelegate <T1, T2, T3, T4, T5, T6, T7, T8, T9> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)
{
CallNetFunction(func.Method.Name, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5, param6, param7, param8, param9);
}
public void CallNetFunction <T1, T2, T3, T4, T5>(NetFunctionDelegate <T1, T2, T3, T4, T5> func, FunctionReceivers receivers, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
{
CallNetFunction(func.Method.Name, DeliveryMethod.ReliableOrdered, receivers, param1, param2, param3, param4, param5);
}
