protected virtual void CurrentLookup_OnTimeout(ServiceCallback pSender)
{
_currentLookup.OnResponseOfT -= CurrentLookup_OnResponseOfT;
_currentLookup.OnTimeout -= CurrentLookup_OnTimeout;
_currentLookup = null;
_pendingObjects.Clear();
}
public virtual void AddPendingServiceCallback(ServiceCallback pCallback)
{
if (pCallback == null)
{
return;
}
pCallback.CallbackId = _usedServiceCallbackIds.GetNext();
_pendingServiceCallbacks.Add(pCallback.CallbackId, pCallback);
}
public virtual ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum> RegisterDynamicScene(uint pSourceNodeId, bool pRequireConfirmation, NetworkSceneTemplate pTemplate)
{
ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum> callback = NodeService.RegisterScene(pSourceNodeId, pRequireConfirmation, pTemplate);
if (callback.State == ServiceCallbackStateEnum.AWAITING_RESPONSE)
{
callback.OnResponse += (pResponseTime, pResponseData, pSender) => {
ConfirmRegisterDynamicScene(callback);
};
}
return(callback);
}
public virtual void FindNetworkSceneTemplate(string pSceneName)
{
if (!NodeManager.IsInitialized || !NodeManager.Instance.IsServer || _currentLookup != null || !_findSceneDelay.HasPassed)
{
return;
}
// Lookup if the scene resides on our Node
if (_nodeTemplate == null)
{
NetworkSceneTemplate foundTemplate = NodeManager.Instance.FindNetworkSceneTemplate(pSceneName, false, true, true, false);
if (foundTemplate != null)
{
_nodeTemplate = new NodeNetworkSceneTemplate(NodeManager.Instance.CurrentNode.NodeId, foundTemplate);
return;
}
}
// Lookup the NodeMap if there is a static NetworkScene we can find on another Node
if (_nodeTemplate == null && NodeManager.Instance.NodeMapSO != null)
{
_nodeTemplate = NodeManager.Instance.NodeMapSO.nodeMap.GetNodeTemplateBySceneName(pSceneName);
if (_nodeTemplate != null)
{
return;
}
}
// Lookup if the scene is a dynamic NetworkScene on another Node
if (_nodeTemplate == null && _enableLookup && _currentLookup == null)
{
_currentLookup = NodeManager.Instance.LookUpNetworkSceneTemplate(pSceneName);
if (_currentLookup.State == ServiceCallbackStateEnum.RESPONSE_SUCCESS)
{
_nodeTemplate = _currentLookup.ResponseDataOfT;
_currentLookup = null;
}
else if (_currentLookup.State == ServiceCallbackStateEnum.AWAITING_RESPONSE)
{
_currentLookup.OnResponseOfT += CurrentLookup_OnResponseOfT;
_currentLookup.OnTimeout += CurrentLookup_OnTimeout;
}
else
{
_pendingObjects.Clear();
_currentLookup = null;
}
}
_findSceneDelay.Start(_findSceneInterval);
}
public static ServiceCallback <RPCInstantiateInNode, ServiceCallbackStateEnum> InstantiateInNode(uint pSourceNodeId, uint pTargetNodeId, string pSceneName, int pCreateCode, IRPCSerializable pBehaviorData, Vector3?pPosition, Quaternion?pRotation, bool pSendTransform)
{
ServiceCallback <RPCInstantiateInNode, ServiceCallbackStateEnum> callback = new ServiceCallback <RPCInstantiateInNode, ServiceCallbackStateEnum>(0, pSourceNodeId, GameTime.fixedTime);
if (!IsInitialized)
{
callback.State = ServiceCallbackStateEnum.ERROR_SERVICE_NOT_INITIALIZED;
return(callback);
}
if (Instance.Manager == null || !Instance.Manager.HasNetworker || !Instance.Manager.Networker.IsConnected)
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_CONNECTION;
return(callback);
}
RPCInstantiateInNode requestData = new RPCInstantiateInNode()
{
targetNodeId = pTargetNodeId, sceneName = pSceneName, createCode = pCreateCode, sendTransform = pSendTransform
};
if (pBehaviorData != null)
{
requestData.behaviorData = pBehaviorData.ToByteArray();
}
if (pPosition != null)
{
requestData.position = pPosition.Value.ToRPC();
}
if (pRotation != null)
{
requestData.rotation = pRotation.Value.ToRPC();
}
callback.RequestDataOfT = requestData;
callback.State = ServiceCallbackStateEnum.AWAITING_RESPONSE;
Instance.AddPendingServiceCallback(callback);
MainThreadManager.Run(() => {
if (!IsInitialized || Instance.networkObject == null)
{
return;
}
Instance.networkObject.SendRpc(RPC_RELAY_INSTANTIATE_IN_NODE, Receivers.Server, callback.ToByteArray());
});
return(callback);
}
public virtual void InstantiatePendingObject(NodeNetworkSceneTemplate pNodeTemplate, NetworkBehavior pBehavior)
{
if (pNodeTemplate == null || pBehavior == null)
{
return;
}
INetworkSceneObject networkSceneObject = pBehavior as INetworkSceneObject;
NetworkObject nObj = networkSceneObject.GetNetworkObject();
if (nObj == null)
{
return;
}
if (pNodeTemplate.NodeId == NodeManager.Instance.CurrentNode.NodeId)
{
NetworkBehavior behavior = NodeManager.Instance.InstantiateInScene(pNodeTemplate.SceneName, nObj.CreateCode, (pBehavior as IRPCSerializable), _teleportTarget.position, _teleportTarget.rotation);
if (behavior == null)
{
return;
}
pBehavior.gameObject.SetActive(false);
SendNetworkSceneToPlayer(networkSceneObject, pNodeTemplate);
DestroyPendingObject(networkSceneObject);
}
else
{
ServiceCallback <RPCInstantiateInNode, ServiceCallbackStateEnum> callback = NodeManager.Instance.InstantiateInNode(pNodeTemplate.NodeId, pNodeTemplate.SceneName, nObj.CreateCode, (pBehavior as IRPCSerializable), _teleportTarget.position, _teleportTarget.rotation);
if (callback.State == ServiceCallbackStateEnum.AWAITING_RESPONSE)
{
// While the request is progressing this NetworkSceneTeleporter could have been destroyed.
NetworkSceneTeleporter tmpTeleporter = this;
callback.OnResponseOfT += (pResponseTime, pResponseDataOfT, pSender) => {
if (tmpTeleporter == null || pBehavior == null || networkSceneObject == null || pNodeTemplate == null)
{
return;
}
if (pResponseDataOfT == ServiceCallbackStateEnum.RESPONSE_SUCCESS)
{
pBehavior.gameObject.SetActive(false);
tmpTeleporter.SendNetworkSceneToPlayer(networkSceneObject, pNodeTemplate);
tmpTeleporter.DestroyPendingObject(networkSceneObject);
}
};
}
}
}
public static ServiceCallback <string, NodeNetworkSceneTemplate> LookupScene(uint pSourceNodeId, string pSceneName)
{
ServiceCallback <string, NodeNetworkSceneTemplate> callback = new ServiceCallback <string, NodeNetworkSceneTemplate>(0, pSourceNodeId, null, GameTime.fixedTime);
if (string.IsNullOrEmpty(pSceneName))
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_DATA;
return(callback);
}
if (!IsInitialized)
{
callback.State = ServiceCallbackStateEnum.ERROR_SERVICE_NOT_INITIALIZED;
return(callback);
}
if (Instance.Manager == null || !Instance.Manager.HasNetworker || !Instance.Manager.Networker.IsConnected)
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_CONNECTION;
return(callback);
}
callback.RequestDataOfT = pSceneName;
if (Instance.EnableLookupCaching)
{
NodeNetworkSceneTemplate nodeTemplate = Instance.GetCachedLookup(pSceneName);
if (nodeTemplate != null)
{
callback.State = ServiceCallbackStateEnum.RESPONSE_SUCCESS;
callback.ResponseTime = GameTime.fixedTime;
callback.ResponseDataOfT = nodeTemplate;
return(callback);
}
}
callback.State = ServiceCallbackStateEnum.AWAITING_RESPONSE;
Instance.AddPendingServiceCallback(callback);
MainThreadManager.Run(() => {
if (!IsInitialized || Instance.networkObject == null)
{
return;
}
Instance.networkObject.SendRpc(RPC_LOOKUP_SCENE, Receivers.Server, callback.ToByteArray());
});
return(callback);
}
public static ServiceCallback <string, ServiceCallbackStateEnum> UnregisterScene(uint pSourceNodeId, bool pRequireConfirmation, string pSceneName)
{
ServiceCallback <string, ServiceCallbackStateEnum> callback = new ServiceCallback <string, ServiceCallbackStateEnum>(0, pSourceNodeId, GameTime.fixedTime);
if (string.IsNullOrEmpty(pSceneName))
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_DATA;
return(callback);
}
if (!IsInitialized)
{
callback.State = ServiceCallbackStateEnum.ERROR_SERVICE_NOT_INITIALIZED;
return(callback);
}
if (Instance.Manager == null || !Instance.Manager.HasNetworker || !Instance.Manager.Networker.IsConnected)
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_CONNECTION;
return(callback);
}
callback.RequestDataOfT = pSceneName;
if (pRequireConfirmation)
{
callback.ResponseDataOfT = ServiceCallbackStateEnum.AWAITING_RESPONSE;
Instance.AddPendingServiceCallback(callback);
}
else
{
callback.State = ServiceCallbackStateEnum.RESPONSE_SUCCESS;
callback.ResponseTime = GameTime.fixedTime;
callback.ResponseDataOfT = callback.State;
}
MainThreadManager.Run(() => {
if (!IsInitialized || Instance.networkObject == null)
{
return;
}
Instance.networkObject.SendRpc(RPC_UNREGISTER_SCENE, Receivers.Server, pRequireConfirmation, callback.ToByteArray());
});
return(callback);
}
public static ServiceCallback <uint, ServiceCallbackStateEnum> RegisterNode(uint pSourceNodeId)
{
ServiceCallback <uint, ServiceCallbackStateEnum> callback = new ServiceCallback <uint, ServiceCallbackStateEnum>(0, pSourceNodeId, GameTime.fixedTime);
if (!IsInitialized)
{
callback.State = ServiceCallbackStateEnum.ERROR_SERVICE_NOT_INITIALIZED;
return(callback);
}
if (Instance.Manager == null || !Instance.Manager.HasNetworker || !Instance.Manager.Networker.IsConnected)
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_CONNECTION;
return(callback);
}
callback.State = ServiceCallbackStateEnum.RESPONSE_SUCCESS;
Instance.networkObject.SendRpc(RPC_REGISTER_NODE, Receivers.Server, pSourceNodeId);
return(callback);
}
public static ServiceCallback <RPCCreateNetworkSceneInNode, ServiceCallbackStateEnum> CreateNetworkSceneInNode(uint pSourceNodeId, uint pTargetNodeId, NetworkSceneTemplate pTemplate, bool pAutoAssignIp, bool pAutoAssignPort, byte[] pNetworkSceneMetaData)
{
ServiceCallback <RPCCreateNetworkSceneInNode, ServiceCallbackStateEnum> callback = new ServiceCallback <RPCCreateNetworkSceneInNode, ServiceCallbackStateEnum>(0, pSourceNodeId, GameTime.fixedTime);
if (pTemplate == null)
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_DATA;
return(callback);
}
if (!IsInitialized)
{
callback.State = ServiceCallbackStateEnum.ERROR_SERVICE_NOT_INITIALIZED;
return(callback);
}
if (Instance.Manager == null || !Instance.Manager.HasNetworker || !Instance.Manager.Networker.IsConnected)
{
callback.State = ServiceCallbackStateEnum.ERROR_NO_CONNECTION;
return(callback);
}
RPCCreateNetworkSceneInNode requestData = new RPCCreateNetworkSceneInNode()
{
targetNodeId = pTargetNodeId, template = pTemplate.ToRPC(), autoAssignIp = pAutoAssignIp, autoAssignPort = pAutoAssignPort, networkSceneMetaData = pNetworkSceneMetaData
};
callback.RequestDataOfT = requestData;
callback.State = ServiceCallbackStateEnum.AWAITING_RESPONSE;
Instance.AddPendingServiceCallback(callback);
MainThreadManager.Run(() => {
if (!IsInitialized || Instance.networkObject == null)
{
return;
}
Instance.networkObject.SendRpc(RPC_RELAY_CREATE_NETWORK_SCENE_IN_NODE, Receivers.Server, callback.ToByteArray());
});
return(callback);
}
protected virtual void CurrentLookup_OnResponseOfT(float pResponseTime, NodeNetworkSceneTemplate pResponseDataOfT, ServiceCallback <NodeNetworkSceneTemplate> pCallback)
{
_currentLookup.OnResponseOfT -= CurrentLookup_OnResponseOfT;
_currentLookup.OnTimeout -= CurrentLookup_OnTimeout;
_currentLookup = null;
// Only assign our result if there has been nothing found in the meantime!
if (_nodeTemplate == null && pCallback.State == ServiceCallbackStateEnum.RESPONSE_SUCCESS)
{
_nodeTemplate = pResponseDataOfT;
}
if (_nodeTemplate == null)
{
_pendingObjects.Clear();
}
else
{
TeleportPendingObjects(_nodeTemplate);
}
}
protected virtual void ConfirmRegisterDynamicScene(ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum> pCallback)
{
NetworkSceneItem item = FindNetworkSceneItemInDynamicScenes(pCallback.RequestDataOfT.sceneName);
if (item == null)
{
return;
}
if (pCallback.ResponseDataOfT == ServiceCallbackStateEnum.RESPONSE_SUCCESS)
{
item.IsRegistered = true;
item.RaiseRegistered();
ReadyNetworkScene(item);
}
else
{
item.IsUnregistered = true;
item.RaiseUnregistered();
UnloadNetworkScene(item);
}
}
