protected virtual void OnCreateNetworkSceneInNode_ServerClient(RpcArgs pArgs)
{
byte[] data = pArgs.GetNext <byte[]>();
RPCServiceCallback callbackRPC = data.ByteArrayToObject <RPCServiceCallback>();
NetworkSceneItem item;
if (NodeManager.IsInitialized)
{
RPCCreateNetworkSceneInNode createNetworkSceneInNodeRPC = callbackRPC.data.ByteArrayToObject <RPCCreateNetworkSceneInNode>();
NetworkSceneTemplate template = new NetworkSceneTemplate(createNetworkSceneInNodeRPC.template);
if (createNetworkSceneInNodeRPC.autoAssignIp)
{
template.Settings.ServerAddress.Ip = NodeManager.Instance.MasterManager.Settings.ServerAddress.Ip;
template.Settings.ClientAddress.Ip = NodeManager.Instance.MasterManager.Settings.ClientAddress.Ip;
}
if (createNetworkSceneInNodeRPC.autoAssignPort)
{
template.Settings.ServerAddress.Port = NodeManager.Instance.UsedDynamicPorts.PeekNext();
template.Settings.ClientAddress.Port = template.Settings.ServerAddress.Port;
}
item = NodeManager.Instance.CreateNetworkScene(template, false, createNetworkSceneInNodeRPC.networkSceneMetaData);
}
else
{
item = null;
}
callbackRPC.state = (item != null) ? ServiceCallbackStateEnum.RESPONSE_SUCCESS : ServiceCallbackStateEnum.RESPONSE_FAILED;
callbackRPC.data = null;
networkObject.SendRpc(RPC_RELAY_CONFIRM_CREATE_NETWORK_SCENE_IN_NODE, Receivers.Server, callbackRPC.ObjectToByteArray());
}
public virtual void FromRPC(RPCNode pNetworkSceneNodeRPC)
{
_nodeId = pNetworkSceneNodeRPC.nodeId;
_nodeName = pNetworkSceneNodeRPC.nodeName;
_isMasterNode = pNetworkSceneNodeRPC.isMasterNode;
_dynamicPortMin = pNetworkSceneNodeRPC.portRangeMin;
_dynamicPortMax = pNetworkSceneNodeRPC.portRangeMax;
_masterNodeSetting = new NetworkSceneManagerSetting();
_masterNodeSetting.FromRPC(pNetworkSceneNodeRPC.masterNodeSettingRPC);
if (pNetworkSceneNodeRPC.networkSceneTemplatesRPC == null)
{
Init(null);
}
List <NetworkSceneTemplate> networkSceneTemplates = new List <NetworkSceneTemplate>(pNetworkSceneNodeRPC.networkSceneTemplatesRPC.Length);
for (int i = 0; i < pNetworkSceneNodeRPC.networkSceneTemplatesRPC.Length; i++)
{
NetworkSceneTemplate networkSceneTemplate = new NetworkSceneTemplate();
networkSceneTemplate.FromRPC(pNetworkSceneNodeRPC.networkSceneTemplatesRPC[i]);
networkSceneTemplates.Add(networkSceneTemplate);
}
Init(networkSceneTemplates.ToArray());
}
public virtual NetworkSceneItem CreateNetworkScene(NetworkSceneTemplate pSceneTemplate, bool pIsSceneStatic, byte[] pNetworkSceneMetaData = null)
{
ushort port = GetPortFromSetting(pSceneTemplate.Settings);
if (!pIsSceneStatic && _usedDynamicPorts.Contains(port))
{
return(null);
}
// Check if we already have created a scene with that name
NetworkSceneTemplate existingScene = FindNetworkSceneTemplate(pSceneTemplate.SceneName, false, true, true, true);
if (existingScene != null)
{
return(null);
}
// Create an empty Scene and put a new NetworkSceneManager in it
NetworkSceneManager manager = CreateEmptyNetworkScene(pSceneTemplate);
manager.NetworkSceneMetaData = pNetworkSceneMetaData;
// Create the Scene with the 'BuildIndex' and queue it up to be merged with our empty Scene
NetworkSceneItem newItem = new NetworkSceneItem(pSceneTemplate, manager);
if (pSceneTemplate.BuildIndex > 0)
{
SceneManager.LoadScene(pSceneTemplate.BuildIndex, LoadSceneMode.Additive);
_pendingScenes.Add(newItem);
}
else
{
newItem.IsCreated = true;
}
// Add the newItem to the respective collection
if (pIsSceneStatic)
{
_scenesStatic.Add(pSceneTemplate.SceneName, newItem);
}
else
{
_usedDynamicPorts.Add(port);
_scenesDynamic.Add(pSceneTemplate.SceneName, newItem);
}
// If the scene is 'dynamic' we need to register it so other Nodes know the scene is taken
if (_isServer && !pIsSceneStatic && _enableRegisterDynamicScenes)
{
RegisterDynamicScene(_registerDynamicScenesRequireConfirmation, pSceneTemplate);
newItem.IsRegistered = !_registerDynamicScenesRequireConfirmation;
}
else
{
newItem.IsRegistered = true;
}
ReadyNetworkScene(newItem);
return(newItem);
}
protected virtual void ReadBinaryClient(NetworkingPlayer pPlayer, Binary pFrame, NetWorker pSender)
{
if (pFrame.GroupId == CustomMessageGroupIds.PLAYER_CHANGE_NETWORK_SCENE)
{
byte[] data = pFrame.StreamData.byteArr;
RPCPlayerChangeNetworkScene changeSceneRPC = data.ByteArrayToObject <RPCPlayerChangeNetworkScene>();
NetworkSceneTemplate sceneTemplate = RPCPlayerChangeNetworkScene.ToNetworkSceneTemplate(changeSceneRPC);
MainThreadManager.Run(() => {
if (NodeManager.IsInitialized)
{
NodeManager.Instance.UnloadNetworkScenes(true, true);
NodeManager.Instance.RaisePlayerChangingNetworkScene(sceneTemplate);
NetworkSceneItem item = NodeManager.Instance.CreateNetworkScene(sceneTemplate, true);
if (item == null)
{
NodeManager.Instance.PlayerChangingSceneFailed(item);
return;
}
if (item.IsReady)
{
NodeManager.Instance.PlayerChangingSceneSucceeded(item);
}
else
{
item.OnReady += NodeManager.Instance.PlayerChangingSceneSucceeded;
item.OnUnloaded += NodeManager.Instance.PlayerChangingSceneFailed;
}
}
});
return;
}
}
public virtual void RaisePlayerChangingNetworkScene(NetworkSceneTemplate pTemplate)
{
if (OnPlayerChangingNetworkScene != null)
{
OnPlayerChangingNetworkScene(pTemplate);
}
}
public static NetworkSceneTemplate ToNetworkSceneTemplate(RPCPlayerChangeNetworkScene pChangeSceneRPC)
{
NetworkSceneTemplate template = new NetworkSceneTemplate(pChangeSceneRPC.buildIndex, pChangeSceneRPC.sceneName, pChangeSceneRPC.sceneOffset, new NetworkSceneManagerSetting());
template.Settings.UseTCP = pChangeSceneRPC.useTCP;
template.Settings.UseMainThreadManagerForRPCs = pChangeSceneRPC.useMainThreadManagerForRPCs;
template.Settings.ClientAddress.FromRPC(pChangeSceneRPC.clientAddress);
template.Settings.ClientNATAddress.FromRPC(pChangeSceneRPC.clientNATAddress);
return(template);
}
public virtual NetworkSceneManager CreateEmptyNetworkScene(NetworkSceneTemplate pTemplate, NetworkBehaviorListSO pBehaviorListSO)
{
Scene newScene = SceneManager.CreateScene(pTemplate.SceneName);
GameObject go = GameObject.Instantiate(_networkSceneManagerPrefab);
go.name = newScene.name + "_NetworkSceneManager";
NetworkSceneManager manager = go.GetComponent <NetworkSceneManager>();
manager.NetworkBehaviorListSO = pBehaviorListSO;
manager.Settings = pTemplate.Settings;
SceneManager.MoveGameObjectToScene(go, newScene);
return(manager);
}
public virtual bool ChangePlayerNetworkScene(NetworkSceneTemplate pTemplate, NetworkingPlayer pPlayer)
{
if (pTemplate == null)
{
return(false);
}
RPCPlayerChangeNetworkScene changeSceneRPC = RPCPlayerChangeNetworkScene.FromNetworkSceneTemplate(pTemplate);
Binary sceneTemplateFrame = new Binary(_networker.Time.Timestep, false, changeSceneRPC.ObjectToByteArray(), Receivers.Target, CustomMessageGroupIds.PLAYER_CHANGE_NETWORK_SCENE, pPlayer.Networker is BaseTCP);
SendFrame(sceneTemplateFrame, pPlayer);
return(true);
}
//Functions
public static RPCPlayerChangeNetworkScene FromNetworkSceneTemplate(NetworkSceneTemplate pTemplate)
{
return(new RPCPlayerChangeNetworkScene()
{
buildIndex = pTemplate.BuildIndex,
sceneName = pTemplate.SceneName,
sceneOffset = pTemplate.SceneOffset,
useTCP = pTemplate.Settings.UseTCP,
useMainThreadManagerForRPCs = pTemplate.Settings.UseMainThreadManagerForRPCs,
clientAddress = pTemplate.Settings.ClientAddress.ToRPC(),
clientNATAddress = pTemplate.Settings.ClientNATAddress.ToRPC()
});
}
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 virtual Node GetNodeWithTemplateOnly(string pSceneName)
{
//This creates a new and independent NetworkSceneNode with only the NetworkSceneTemplate in it.
Node node = GetBySceneName(pSceneName);
if (node == null)
{
return(null);
}
NetworkSceneTemplate networkSceneTemplate = node.GetBySceneName(pSceneName);
RPCNode nodeRPC = node.ToRPC();
nodeRPC.networkSceneTemplatesRPC = new RPCNetworkSceneTemplate[] { networkSceneTemplate.ToRPC() };
return(new Node(nodeRPC));
}
public virtual NetworkSceneTemplate FindNetworkSceneTemplate(string pSceneName, bool pSearchNodeMap, bool pSearchStaticScenes, bool pSearchDynamicScenes, bool pSearchCachedScenes)
{
//check in our static NodeMap
if (pSearchNodeMap)
{
NetworkSceneTemplate template = FindNetworkSceneTemplateInNodeMap(pSceneName);
if (template != null)
{
return(template);
}
}
//check our static scenes
if (pSearchStaticScenes)
{
NetworkSceneTemplate template = FindNetworkSceneTemplateInStaticScenes(pSceneName);
if (template != null)
{
return(template);
}
}
//check our dynamic scenes
if (pSearchDynamicScenes)
{
NetworkSceneTemplate template = FindNetworkSceneTemplateInDynamicScenes(pSceneName);
if (template != null)
{
return(template);
}
}
//check in our cached scenes
if (pSearchCachedScenes)
{
NetworkSceneTemplate template = FindNetworkSceneTemplateInCachedScenes(pSceneName);
if (template != null)
{
return(template);
}
}
return(null);
}
public virtual ServiceCallback <RPCCreateNetworkSceneInNode, ServiceCallbackStateEnum> CreateNetworkSceneInNode(uint pSourceNodeId, uint pTargetNodeId, NetworkSceneTemplate pTemplate, bool pAutoAssignIp = false, bool pAutoAssignPort = false, byte[] pNetworkSceneMetaData = null)
{
return(NodeService.CreateNetworkSceneInNode(pSourceNodeId, pTargetNodeId, pTemplate, pAutoAssignIp, pAutoAssignPort, pNetworkSceneMetaData));
}
public virtual NetworkSceneManager CreateEmptyNetworkScene(NetworkSceneTemplate pTemplate)
{
return(CreateEmptyNetworkScene(pTemplate, _networkSceneBehaviorListSO));
}
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);
}
public static ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum> RegisterScene(uint pSourceodeId, bool pRequireConfirmation, NetworkSceneTemplate pTemplate)
{
ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum> callback = new ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum>(0, pSourceodeId, 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);
}
callback.RequestDataOfT = pTemplate.ToRPC();
if (pRequireConfirmation)
{
callback.State = 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_REGISTER_SCENE, Receivers.Server, pRequireConfirmation, callback.ToByteArray());
});
return(callback);
}
public virtual ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum> RegisterDynamicScene(NetworkSceneTemplate pTemplate)
{
return(RegisterDynamicScene(_registerDynamicScenesRequireConfirmation, pTemplate));
}
public NetworkSceneTemplate(NetworkSceneTemplate pTemplate)
: this(pTemplate.BuildIndex, pTemplate.SceneName, pTemplate.SceneOffset, new NetworkSceneManagerSetting(pTemplate.Settings))
{
}
public virtual NetworkSceneItem CreateNetworkScene(NetworkSceneTemplate pSceneTemplate, byte[] pNetworkSceneMetaData = null)
{
return(CreateNetworkScene(pSceneTemplate, IsStaticScene(pSceneTemplate.SceneName), pNetworkSceneMetaData));
}
public virtual ServiceCallback <RPCNetworkSceneTemplate, ServiceCallbackStateEnum> RegisterDynamicScene(bool pRequireConfirmation, NetworkSceneTemplate pTemplate)
{
return(RegisterDynamicScene(_currentNode.NodeId, pRequireConfirmation, pTemplate));
}
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 NodeNetworkSceneTemplate(uint pNodeId, NetworkSceneTemplate pNetworkSceneTemplate) : base(pNetworkSceneTemplate)
{
_nodeId = pNodeId;
}
public virtual void StartAsClient(NetworkSceneTemplate pTemplate)
{
_isServer = false;
CreateNetworkScene(pTemplate, true);
}