/// <summary>
/// Initial Identity, will be called when spawned. If object id == 0, it will generate new object id
/// </summary>
/// <param name="manager"></param>
/// <param name="objectId"></param>
/// <param name="connectionId"></param>
internal void Initial(LiteNetLibGameManager manager, bool isSceneObject, uint objectId = 0, long connectionId = -1)
{
this.objectId = objectId;
this.connectionId = connectionId;
this.manager = manager;
destroyed = false;
if (objectId > HighestObjectId)
{
HighestObjectId = objectId;
}
if (!isSceneObject)
{
ValidateObjectId();
}
if (!hasSetupBehaviours)
{
// Setup behaviours index, we will use this as reference for network functions
Behaviours = GetComponents <LiteNetLibBehaviour>();
for (loopCounter = 0; loopCounter < Behaviours.Length; ++loopCounter)
{
Behaviours[loopCounter].Setup(Convert.ToByte(loopCounter));
}
hasSetupBehaviours = true;
}
// If this is host, hide it then will showing when rebuild subscribers
if (IsServer && IsClient)
{
OnServerSubscribingRemoved();
}
RebuildSubscribers(true);
}
internal void SendUpdate(bool isInitial)
{
if (!CanSync())
{
Logging.LogError(LogTag, "Error while set value, behaviour is empty");
return;
}
LiteNetLibGameManager manager = Manager;
LiteNetLibServer server = manager.Server;
LiteNetLibClient client = manager.Client;
switch (syncMode)
{
case SyncMode.ServerToClients:
TransportHandler.WritePacket(ServerWriter, isInitial ? GameMsgTypes.InitialSyncField : GameMsgTypes.UpdateSyncField);
SerializeForSend(ServerWriter);
foreach (long connectionId in manager.GetConnectionIds())
{
if (Identity.HasSubscriberOrIsOwning(connectionId))
{
server.SendMessage(connectionId, dataChannel, deliveryMethod, ServerWriter);
}
}
break;
case SyncMode.ServerToOwnerClient:
if (manager.ContainsConnectionId(ConnectionId))
{
TransportHandler.WritePacket(ServerWriter, isInitial ? GameMsgTypes.InitialSyncField : GameMsgTypes.UpdateSyncField);
SerializeForSend(ServerWriter);
server.SendMessage(ConnectionId, dataChannel, deliveryMethod, ServerWriter);
}
break;
case SyncMode.ClientMulticast:
if (IsOwnerClient)
{
TransportHandler.WritePacket(ClientWriter, isInitial ? GameMsgTypes.InitialSyncField : GameMsgTypes.UpdateSyncField);
SerializeForSend(ClientWriter);
// Client send data to server, then server send to other clients, it should be reliable-ordered
client.SendMessage(clientDataChannel, clientDeliveryMethod, ClientWriter);
}
else if (IsServer)
{
TransportHandler.WritePacket(ServerWriter, isInitial ? GameMsgTypes.InitialSyncField : GameMsgTypes.UpdateSyncField);
SerializeForSend(ServerWriter);
foreach (long connectionId in manager.GetConnectionIds())
{
if (Identity.HasSubscriberOrIsOwning(connectionId))
{
server.SendMessage(connectionId, dataChannel, deliveryMethod, ServerWriter);
}
}
}
break;
}
}
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);
}
}
internal void SendUpdate(bool isInitial, long connectionId)
{
if (!CanSync() || !IsServer)
{
return;
}
LiteNetLibGameManager manager = Manager;
LiteNetLibServer server = manager.Server;
TransportHandler.WritePacket(ServerWriter, isInitial ? GameMsgTypes.InitialSyncField : GameMsgTypes.UpdateSyncField);
SerializeForSend(ServerWriter);
if (manager.ContainsConnectionId(connectionId))
{
server.SendMessage(connectionId, dataChannel, deliveryMethod, ServerWriter);
}
}
/// <summary>
/// Initial Identity, will be called when spawned. If object id == 0, it will generate new object id
/// </summary>
/// <param name="manager"></param>
/// <param name="isSceneObject"></param>
/// <param name="objectId"></param>
/// <param name="connectionId"></param>
internal void Initial(LiteNetLibGameManager manager, bool isSceneObject, uint objectId = 0, long connectionId = -1)
{
Manager = manager;
ObjectId = objectId;
ConnectionId = connectionId;
UpdateHighestObjectId(objectId);
IsDestroyed = false;
IsSpawned = true;
IsSceneObject = isSceneObject;
if (!IsSceneObject)
{
AssignSceneObjectId();
}
if (!IsSetupBehaviours)
{
// Setup behaviours index, we will use this as reference for network functions
// NOTE: Maximum network behaviour for a identity is 255 (included children)
Behaviours = GetComponentsInChildren <LiteNetLibBehaviour>();
SyncBehaviours.Clear();
byte loopCounter;
for (loopCounter = 0; loopCounter < Behaviours.Length; ++loopCounter)
{
Behaviours[loopCounter].Setup(loopCounter);
if (Behaviours[loopCounter].CanSyncBehaviour())
{
SyncBehaviours.Add(Behaviours[loopCounter]);
}
}
IsSetupBehaviours = true;
}
// If this is host, hide it then will be showned when initialize subscribings
if (IsServer && IsClient)
{
OnServerSubscribingRemoved();
}
Manager.Assets.SpawnedObjects.Add(ObjectId, this);
if (IsServer && ConnectionId >= 0)
{
Player.SpawnedObjects.Add(ObjectId, this);
Player.Subscribe(ObjectId);
}
Manager.InterestManager.NotifyNewObject(this);
}
/// <summary>
/// Initial Identity, will be called when spawned. If object id == 0, it will generate new object id
/// </summary>
/// <param name="objectId"></param>
/// <param name="connectionId"></param>
internal void Initial(LiteNetLibGameManager manager, bool isSceneObject, uint objectId = 0, long connectionId = -1)
{
this.objectId = objectId;
Manager = manager;
ConnectionId = connectionId;
destroyed = false;
if (objectId > HighestObjectId)
{
HighestObjectId = objectId;
}
IsSceneObject = isSceneObject;
if (!IsSceneObject)
{
AssignSceneObjectId();
}
if (!IsSetupBehaviours)
{
// Setup behaviours index, we will use this as reference for network functions
// NOTE: Maximum network behaviour for a identity is 255 (included children)
Behaviours = GetComponentsInChildren <LiteNetLibBehaviour>();
SyncBehaviours.Clear();
byte loopCounter;
for (loopCounter = 0; loopCounter < Behaviours.Length; ++loopCounter)
{
Behaviours[loopCounter].Setup(loopCounter);
if (Behaviours[loopCounter].CanSyncBehaviour())
{
SyncBehaviours.Add(Behaviours[loopCounter]);
}
}
IsSetupBehaviours = true;
}
// If this is host, hide it then will showing when rebuild subscribers
if (IsServer && IsClient)
{
OnServerSubscribingRemoved();
}
RebuildSubscribers(true);
}
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 LiteNetLibPlayer(LiteNetLibGameManager manager, long connectionId)
{
Manager = manager;
ConnectionId = connectionId;
}
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);
}
}
