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); } }