/// <summary> /// Registers a prefab with the spawning system. /// <para>When a NetworkIdentity object is spawned on a server with NetworkServer.SpawnObject(), and the prefab that the object was created from was registered with RegisterPrefab(), the client will use that prefab to instantiate a corresponding client object with the same netId.</para> /// <para>The NetworkManager has a list of spawnable prefabs, it uses this function to register those prefabs with the ClientScene.</para> /// <para>The set of current spawnable object is available in the ClientScene static member variable ClientScene.prefabs, which is a dictionary of NetworkAssetIds and prefab references.</para> /// </summary> /// <param name="prefab">A Prefab that will be spawned.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public void RegisterPrefab(GameObject prefab, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkIdentity identity = prefab.GetComponent <NetworkIdentity>(); if (identity == null) { throw new InvalidOperationException("Could not register '" + prefab.name + "' since it contains no NetworkIdentity component"); } if (spawnHandler == null || unspawnHandler == null) { throw new InvalidOperationException("RegisterPrefab custom spawn function null for " + identity.AssetId); } if (identity.AssetId == Guid.Empty) { throw new InvalidOperationException("RegisterPrefab game object " + prefab.name + " has no " + nameof(prefab) + ". Use RegisterSpawnHandler() instead?"); } if (logger.LogEnabled()) { logger.Log("Registering custom prefab '" + prefab.name + "' as asset:" + identity.AssetId + " " + spawnHandler.GetMethodName() + "/" + unspawnHandler.GetMethodName()); } spawnHandlers[identity.AssetId] = spawnHandler; unspawnHandlers[identity.AssetId] = unspawnHandler; }
/// <summary> /// Registers a prefab with the spawning system. /// <para>When a NetworkIdentity object is spawned on a server with NetworkServer.SpawnObject(), and the prefab that the object was created from was registered with RegisterPrefab(), the client will use that prefab to instantiate a corresponding client object with the same netId.</para> /// <para>The NetworkManager has a list of spawnable prefabs, it uses this function to register those prefabs with the ClientScene.</para> /// <para>The set of current spawnable object is available in the ClientScene static member variable ClientScene.prefabs, which is a dictionary of NetworkAssetIds and prefab references.</para> /// </summary> /// <param name="prefab">A Prefab that will be spawned.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public static void RegisterPrefab(GameObject prefab, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkIdentity identity = prefab.GetComponent <NetworkIdentity>(); if (identity == null) { Debug.LogError("Could not register '" + prefab.name + "' since it contains no NetworkIdentity component"); return; } if (spawnHandler == null || unspawnHandler == null) { Debug.LogError("RegisterPrefab custom spawn function null for " + identity.assetId); return; } if (identity.assetId == Guid.Empty) { Debug.LogError("RegisterPrefab game object " + prefab.name + " has no prefab. Use RegisterSpawnHandler() instead?"); return; } if (LogFilter.Debug) { Debug.Log("Registering custom prefab '" + prefab.name + "' as asset:" + identity.assetId + " " + spawnHandler.GetMethodName() + "/" + unspawnHandler.GetMethodName()); } spawnHandlers[identity.assetId] = spawnHandler; unspawnHandlers[identity.assetId] = unspawnHandler; }
protected void CallRegisterPrefab(GameObject prefab, RegisterPrefabOverload overload, UnSpawnDelegate unspawnHandler) { SpawnDelegate spawnHandler = new SpawnDelegate((x, y) => null); SpawnHandlerDelegate spawnHandlerDelegate = new SpawnHandlerDelegate(x => null); switch (overload) { case RegisterPrefabOverload.Prefab_SpawnDelegate: ClientScene.RegisterPrefab(prefab, spawnHandler, unspawnHandler); break; case RegisterPrefabOverload.Prefab_SpawnDelegate_NewAssetId: ClientScene.RegisterPrefab(prefab, anotherGuid, spawnHandler, unspawnHandler); break; case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate: ClientScene.RegisterPrefab(prefab, spawnHandlerDelegate, unspawnHandler); break; case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate_NewAssetId: ClientScene.RegisterPrefab(prefab, anotherGuid, spawnHandlerDelegate, unspawnHandler); break; case RegisterPrefabOverload.Prefab: case RegisterPrefabOverload.Prefab_NewAssetId: Debug.LogError("Overload did not have UnSpawnDelegate parameter"); break; default: Debug.LogError("Overload not found"); break; } }
protected void CallRegisterPrefab(GameObject prefab, RegisterPrefabOverload overload, Guid guid) { SpawnDelegate spawnHandler = new SpawnDelegate((x, y) => null); SpawnHandlerDelegate spawnHandlerDelegate = new SpawnHandlerDelegate(x => null); UnSpawnDelegate unspawnHandler = new UnSpawnDelegate(x => {}); switch (overload) { case RegisterPrefabOverload.Prefab_NewAssetId: NetworkClient.RegisterPrefab(prefab, guid); break; case RegisterPrefabOverload.Prefab_SpawnDelegate_NewAssetId: NetworkClient.RegisterPrefab(prefab, guid, spawnHandler, unspawnHandler); break; case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate_NewAssetId: NetworkClient.RegisterPrefab(prefab, guid, spawnHandlerDelegate, unspawnHandler); break; case RegisterPrefabOverload.Prefab: case RegisterPrefabOverload.Prefab_SpawnDelegate: case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate: Debug.LogError("Overload did not have guid parameter"); break; default: Debug.LogError("Overload not found"); break; } }
/// <summary> /// This is an advanced spawning function that registers a custom assetId with the UNET spawning system. /// <para>This can be used to register custom spawning methods for an assetId - instead of the usual method of registering spawning methods for a prefab. This should be used when no prefab exists for the spawned objects - such as when they are constructed dynamically at runtime from configuration data.</para> /// </summary> /// <param name="assetId">Custom assetId string.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public void RegisterSpawnHandler(Guid assetId, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (logger.LogEnabled()) { logger.Log("RegisterSpawnHandler asset '" + assetId + "' " + spawnHandler.Method.Name + "/" + unspawnHandler.Method.Name); } spawnHandlers[assetId] = spawnHandler; unspawnHandlers[assetId] = unspawnHandler; }
/// <summary> /// This is an advanced spawning function that registers a custom prefabHash with the UNET spawning system. /// <para>This can be used to register custom spawning methods for an prefabHash - instead of the usual method of registering spawning methods for a prefab. This should be used when no prefab exists for the spawned objects - such as when they are constructed dynamically at runtime from configuration data.</para> /// </summary> /// <param name="prefabHash"></param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public void RegisterSpawnHandler(int prefabHash, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (logger.LogEnabled()) { logger.Log("RegisterSpawnHandler asset '" + prefabHash + "' " + spawnHandler.Method.Name + "/" + unspawnHandler.Method.Name); } spawnHandlers[prefabHash] = spawnHandler; unspawnHandlers[prefabHash] = unspawnHandler; }
/// <summary> /// Registers a delegate for spawning NetworkPrefabs, useful for object pooling /// </summary> /// <param name="prefabHash">The prefab hash to spawn</param> /// <param name="handler">The delegate handler</param> public static void RegisterSpawnHandler(ulong prefabHash, SpawnHandlerDelegate handler) { if (CustomSpawnHandlers.ContainsKey(prefabHash)) { CustomSpawnHandlers[prefabHash] = handler; } else { CustomSpawnHandlers.Add(prefabHash, handler); } }
/// <summary> /// This is an advanced spawning function that registers a custom prefabHash with the UNET spawning system. /// <para>This can be used to register custom spawning methods for an prefabHash - instead of the usual method of registering spawning methods for a prefab. This should be used when no prefab exists for the spawned objects - such as when they are constructed dynamically at runtime from configuration data.</para> /// </summary> /// <param name="prefabHash"></param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public void RegisterSpawnHandler(int prefabHash, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (logger.LogEnabled()) { var spawnName = spawnHandler?.Method.Name ?? "<NULL>"; var unspawnName = unspawnHandler?.Method.Name ?? "<NULL>"; logger.Log($"RegisterSpawnHandler PrefabHash:'{prefabHash}' Spawn:{spawnName} UnSpawn:{unspawnName}"); } _spawnHandlers[prefabHash] = spawnHandler; _unspawnHandlers[prefabHash] = unspawnHandler; }
/// <summary> /// Registers a prefab with the spawning system. /// <para>When a NetworkIdentity object is spawned on a server with NetworkServer.SpawnObject(), and the prefab that the object was created from was registered with RegisterPrefab(), the client will use that prefab to instantiate a corresponding client object with the same netId.</para> /// <para>The ClientObjectManager has a list of spawnable prefabs, it uses this function to register those prefabs with the ClientScene.</para> /// <para>The set of current spawnable object is available in the ClientScene static member variable ClientScene.prefabs, which is a dictionary of NetworkAssetIds and prefab references.</para> /// </summary> /// <param name="identity">A Prefab that will be spawned.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public void RegisterPrefab(NetworkIdentity identity, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (identity.AssetId == Guid.Empty) { throw new InvalidOperationException("RegisterPrefab game object " + identity.name + " has no " + nameof(identity) + ". Use RegisterSpawnHandler() instead?"); } if (logger.LogEnabled()) { logger.Log("Registering custom prefab '" + identity.name + "' as asset:" + identity.AssetId + " " + spawnHandler.Method.Name + "/" + unspawnHandler.Method.Name); } spawnHandlers[identity.AssetId] = spawnHandler; unspawnHandlers[identity.AssetId] = unspawnHandler; }
/// <summary> /// This is an advanced spawning function that registers a custom assetId with the UNET spawning system. /// <para>This can be used to register custom spawning methods for an assetId - instead of the usual method of registering spawning methods for a prefab. This should be used when no prefab exists for the spawned objects - such as when they are constructed dynamically at runtime from configuration data.</para> /// </summary> /// <param name="assetId">Custom assetId string.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public void RegisterSpawnHandler(Guid assetId, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (spawnHandler == null || unspawnHandler == null) { throw new InvalidOperationException("RegisterSpawnHandler custom spawn function null for " + assetId); } if (logger.LogEnabled()) { logger.Log("RegisterSpawnHandler asset '" + assetId + "' " + spawnHandler.GetMethodName() + "/" + unspawnHandler.GetMethodName()); } spawnHandlers[assetId] = spawnHandler; unspawnHandlers[assetId] = unspawnHandler; }
/// <summary> /// This is an advanced spawning function that registers a custom assetId with the UNET spawning system. /// <para>This can be used to register custom spawning methods for an assetId - instead of the usual method of registering spawning methods for a prefab. This should be used when no prefab exists for the spawned objects - such as when they are constructed dynamically at runtime from configuration data.</para> /// </summary> /// <param name="assetId">Custom assetId string.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public static void RegisterSpawnHandler(Guid assetId, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (spawnHandler == null || unspawnHandler == null) { Debug.LogError("RegisterSpawnHandler custom spawn function null for " + assetId); return; } if (LogFilter.Debug) { Debug.Log("RegisterSpawnHandler asset '" + assetId + "' " + spawnHandler.GetMethodName() + "/" + unspawnHandler.GetMethodName()); } spawnHandlers[assetId] = spawnHandler; unspawnHandlers[assetId] = unspawnHandler; }
/// <summary> /// Registers a prefab with the spawning system. /// <para>When a NetworkIdentity object is spawned on a server with NetworkServer.SpawnObject(), and the prefab that the object was created from was registered with RegisterPrefab(), the client will use that prefab to instantiate a corresponding client object with the same netId.</para> /// <para>The ClientObjectManager has a list of spawnable prefabs, it uses this function to register those prefabs with the ClientScene.</para> /// <para>The set of current spawnable object is available in the ClientScene static member variable ClientScene.prefabs, which is a dictionary of PrefabHash and prefab references.</para> /// </summary> /// <param name="identity">A Prefab that will be spawned.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public void RegisterPrefab(NetworkIdentity identity, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { var prefabHash = identity.PrefabHash; if (prefabHash == 0) { throw new InvalidOperationException("RegisterPrefab game object " + identity.name + " has no " + nameof(identity) + ". Use RegisterSpawnHandler() instead?"); } if (logger.LogEnabled()) { logger.Log("Registering custom prefab '" + identity.name + "' as asset:" + prefabHash + " " + spawnHandler.Method.Name + "/" + unspawnHandler.Method.Name); } _spawnHandlers[prefabHash] = spawnHandler; _unspawnHandlers[prefabHash] = unspawnHandler; }
public void SpawnDelegate_AddsHandlerToSpawnHandlers(RegisterPrefabOverload overload) { int handlerCalled = 0; Guid guid = GuidForOverload(overload); SpawnDelegate handler = new SpawnDelegate((pos, rot) => { handlerCalled++; return(null); }); CallRegisterPrefab(validPrefab, overload, handler); Assert.IsTrue(NetworkClient.spawnHandlers.ContainsKey(guid)); // check spawnHandler above is called SpawnHandlerDelegate handlerInDictionary = NetworkClient.spawnHandlers[guid]; handlerInDictionary.Invoke(default);
public void SpawnDelegate_AddsHandlerToSpawnHandlers() { int handlerCalled = 0; Guid guid = Guid.NewGuid(); SpawnDelegate spawnHandler = new SpawnDelegate((pos, rot) => { handlerCalled++; return(null); }); UnSpawnDelegate unspawnHandler = new UnSpawnDelegate(x => {}); ClientScene.RegisterSpawnHandler(guid, spawnHandler, unspawnHandler); Assert.IsTrue(spawnHandlers.ContainsKey(guid)); // check spawnHandler above is called SpawnHandlerDelegate handler = spawnHandlers[guid]; handler.Invoke(default);
/// <summary> /// This is an advanced spawning function that registers a custom assetId with the UNET spawning system. /// <para>This can be used to register custom spawning methods for an assetId - instead of the usual method of registering spawning methods for a prefab. This should be used when no prefab exists for the spawned objects - such as when they are constructed dynamically at runtime from configuration data.</para> /// </summary> /// <param name="assetId">Custom assetId string.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public static void RegisterSpawnHandler(Guid assetId, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (spawnHandler == null) { logger.LogError($"Can not Register null SpawnHandler for {assetId}"); return; } if (unspawnHandler == null) { logger.LogError($"Can not Register null UnSpawnHandler for {assetId}"); return; } if (assetId == Guid.Empty) { logger.LogError("Can not Register SpawnHandler for empty Guid"); return; } if (spawnHandlers.ContainsKey(assetId) || unspawnHandlers.ContainsKey(assetId)) { logger.LogWarning($"Replacing existing spawnHandlers for {assetId}"); } if (prefabs.ContainsKey(assetId)) { // this is error because SpawnPrefab checks prefabs before handler logger.LogError($"assetId '{assetId}' is already used by prefab '{prefabs[assetId].name}'"); } if (logger.LogEnabled()) { logger.Log("RegisterSpawnHandler asset '" + assetId + "' " + spawnHandler.GetMethodName() + "/" + unspawnHandler.GetMethodName()); } spawnHandlers[assetId] = spawnHandler; unspawnHandlers[assetId] = unspawnHandler; }
public static void RegisterPrefab(GameObject prefab, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) => NetworkClient.RegisterPrefab(prefab, spawnHandler, unspawnHandler);
public static void RegisterSpawnHandler(Guid assetId, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) => NetworkClient.RegisterSpawnHandler(assetId, spawnHandler, unspawnHandler);
/// <summary> /// Registers a prefab with the spawning system. /// <para>When a NetworkIdentity object is spawned on a server with NetworkServer.SpawnObject(), and the prefab that the object was created from was registered with RegisterPrefab(), the client will use that prefab to instantiate a corresponding client object with the same netId.</para> /// <para>The NetworkManager has a list of spawnable prefabs, it uses this function to register those prefabs with the ClientScene.</para> /// <para>The set of current spawnable object is available in the ClientScene static member variable ClientScene.prefabs, which is a dictionary of NetworkAssetIds and prefab references.</para> /// </summary> /// <param name="prefab">A Prefab that will be spawned.</param> /// <param name="spawnHandler">A method to use as a custom spawnhandler on clients.</param> /// <param name="unspawnHandler">A method to use as a custom un-spawnhandler on clients.</param> public static void RegisterPrefab(GameObject prefab, SpawnHandlerDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (prefab == null) { logger.LogError("Could not register handler for prefab because the prefab was null"); return; } NetworkIdentity identity = prefab.GetComponent <NetworkIdentity>(); if (identity == null) { logger.LogError("Could not register handler for '" + prefab.name + "' since it contains no NetworkIdentity component"); return; } if (identity.sceneId != 0) { logger.LogError($"Can not Register '{prefab.name}' because it has a sceneId, make sure you are passing in the original prefab and not an instance in the scene."); return; } Guid assetId = identity.assetId; if (assetId == Guid.Empty) { logger.LogError($"Can not Register handler for '{prefab.name}' because it had empty assetid. If this is a scene Object use RegisterSpawnHandler instead"); return; } if (spawnHandler == null) { logger.LogError($"Can not Register null SpawnHandler for {assetId}"); return; } if (unspawnHandler == null) { logger.LogError($"Can not Register null UnSpawnHandler for {assetId}"); return; } if (spawnHandlers.ContainsKey(assetId) || unspawnHandlers.ContainsKey(assetId)) { logger.LogWarning($"Replacing existing spawnHandlers for prefab '{prefab.name}' with assetId '{assetId}'"); } if (prefabs.ContainsKey(assetId)) { // this is error because SpawnPrefab checks prefabs before handler logger.LogError($"assetId '{assetId}' is already used by prefab '{prefabs[assetId].name}', unregister the prefab first before trying to add handler"); } NetworkIdentity[] identities = prefab.GetComponentsInChildren <NetworkIdentity>(); if (identities.Length > 1) { logger.LogWarning($"Prefab '{prefab.name}' has multiple NetworkIdentity components. There should only be one NetworkIdentity on a prefab, and it must be on the root object."); } if (logger.LogEnabled()) { logger.Log("Registering custom prefab '" + prefab.name + "' as asset:" + assetId + " " + spawnHandler.GetMethodName() + "/" + unspawnHandler.GetMethodName()); } spawnHandlers[assetId] = spawnHandler; unspawnHandlers[assetId] = unspawnHandler; }
protected void CallRegisterPrefab(GameObject prefab, RegisterPrefabOverload overload, SpawnHandlerDelegate spawnHandlerDelegate) { UnSpawnDelegate unspawnHandler = new UnSpawnDelegate(x => {}); switch (overload) { case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate: NetworkClient.RegisterPrefab(prefab, spawnHandlerDelegate, unspawnHandler); break; case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate_NewAssetId: NetworkClient.RegisterPrefab(prefab, anotherGuid, spawnHandlerDelegate, unspawnHandler); break; case RegisterPrefabOverload.Prefab: case RegisterPrefabOverload.Prefab_NewAssetId: case RegisterPrefabOverload.Prefab_SpawnDelegate: case RegisterPrefabOverload.Prefab_SpawnDelegate_NewAssetId: Debug.LogError("Overload did not have SpawnHandlerDelegate parameter"); break; default: Debug.LogError("Overload not found"); break; } }