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; } }
public SpawnTimer(double spawntime, SpawnDelegate cb, string name) { SpawnTime = spawntime; callback = cb; CanDelete = false; Name = name; }
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; } }
void FindSpawns(Type type) { if (type.GetCustomAttribute <SpawnFactoryAttribute>() != null) { //networkFactoryMethods.AddRange(type.GetMethods().Where(methodInfo => methodInfo.IsDefined(typeof(NetworkInstantiatorAttribute), false))); var methods = type .GetMethods() .Where(_ => _.IsDefined(typeof(SpawnAttribute), false)) .ToArray(); foreach (var method in methods) { SpawnDelegate spawn = null; try { spawn = (SpawnDelegate)Delegate.CreateDelegate( typeof(SpawnDelegate), method); } catch (Exception) { throw new Exception(string.Format("Wrong signature for {0}. Signature requires static Entity {0}(EntityManager)", method.Name)); } int instanceId = method.GetCustomAttribute <SpawnAttribute>().InstanceId; RegisterSpawn(instanceId, spawn); } } }
public void SpawnPlayer() { currTimeToRevive = 0; reviveTimeElapsed = 0; travelTimeElapsed = 0; if (reviveSlot != null) { reviveSlot.RemovePlayer(); reviveSlot = null; } else { GameObject parent = SpawnDelegate.getInstance().getPlayerSpawnLocation(playerNum); gameObject.transform.SetParent(parent.transform, false); gameObject.transform.position = parent.transform.position; } playerRevivingMe = null; playerState = PlayerState.SPAWNING; deathState = DeathState.STARTING; if (rend == null) { rend = GetComponent <SpriteRenderer> ().GetComponent <Renderer> (); } ToggleBarrels(currentWeapon, true); rend.enabled = true; head.GetComponent <SpriteRenderer> ().enabled = true; initDone = true; StartCoroutine(Flash(SPAWNING_TIME, 0.05f)); }
/// <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, SpawnDelegate 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; }
private void SpawnEnemy(string enemyName, SpawnDelegate spawnDelegate) { // Get the corresponding spawn information SpawnPositionAndArea spawnPositionAndArea = spawnDelegate(); // Spawn the enemy object _objectPooler.Spawn(enemyName, spawnPositionAndArea.spawnPosition, Quaternion.identity, spawnPositionAndArea.spawnAreaName); }
internal static bool GetSpawnHandler(NetworkHash128 assetId, out SpawnDelegate handler) { if (NetworkScene.s_SpawnHandlers.ContainsKey(assetId)) { handler = NetworkScene.s_SpawnHandlers[assetId]; return true; } handler = null; return false; }
/// <summary> /// Gets the spawn handler of an asset. /// </summary> /// <param name="assetIndex">Index of the asset.</param> /// <param name="handler">The handler.</param> /// <returns></returns> public bool GetSpawnHandler(int assetIndex, out SpawnDelegate handler) { if (_spawnHandlers.ContainsKey(assetIndex)) { handler = _spawnHandlers[assetIndex]; return(true); } handler = null; return(false); }
static internal bool GetSpawnHandler(NetworkHash128 assetId, out SpawnDelegate handler) { if (s_SpawnHandlers.ContainsKey(assetId)) { handler = s_SpawnHandlers[assetId]; return(true); } handler = null; return(false); }
public static void Prepare() { SpawnCitizenAI = GameConnectionManager.Instance.HumanAIConnection.SpawnCitizenAI; StartPathFindCitizenAI = GameConnectionManager.Instance.HumanAIConnection.StartPathFindCitizenAI; SimulationStepCitizenAI = GameConnectionManager.Instance.HumanAIConnection.SimulationStepCitizenAI; ArriveAtDestination = GameConnectionManager.Instance.HumanAIConnection.ArriveAtDestination; InvalidPath = GameConnectionManager.Instance.HumanAIConnection.InvalidPath; PathfindFailure = GameConnectionManager.Instance.HumanAIConnection.PathfindFailure; PathfindSuccess = GameConnectionManager.Instance.HumanAIConnection.PathfindSuccess; }
internal static bool GetSpawnHandler(Guid assetId, out SpawnDelegate handler) { if (s_SpawnHandlers.ContainsKey(assetId)) { handler = s_SpawnHandlers[assetId]; return(true); } handler = null; return(false); }
/// <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, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { // We need this check here because we don't want a null handler in the lambda expression below if (spawnHandler == null) { logger.LogError($"Can not Register null SpawnHandler for {assetId}"); return; } RegisterSpawnHandler(assetId, msg => spawnHandler(msg.position, msg.assetId), unspawnHandler); }
internal static HumanAIConnection GetConnection() { try { StartPathFindDelegate startPathFindCitizenAI = TranspilerUtil.CreateDelegate <StartPathFindDelegate>( typeof(CitizenAI), "StartPathFind", true); SimulationStepDelegate simulationStepCitizenAI = AccessTools.MethodDelegate <SimulationStepDelegate>( TranspilerUtil.DeclaredMethod <SimulationStepTarget>(typeof(CitizenAI), "SimulationStep"), null, false); ArriveAtDestinationDelegate arriveAtDestination = TranspilerUtil.CreateDelegate <ArriveAtDestinationDelegate>( typeof(HumanAI), "ArriveAtDestination", true); SpawnDelegate spawnCitizenAI = TranspilerUtil.CreateDelegate <SpawnDelegate>( typeof(HumanAI), "Spawn", true); InvalidPathHumanAIDelegate invalidPath = TranspilerUtil.CreateDelegate <InvalidPathHumanAIDelegate>( typeof(CitizenAI), "InvalidPath", true); PathfindFailureHumanAIDelegate pathfindFailure = TranspilerUtil.CreateDelegate <PathfindFailureHumanAIDelegate>( typeof(HumanAI), "PathfindFailure", true); PathfindSuccessHumanAIDelegate pathfindSuccess = TranspilerUtil.CreateDelegate <PathfindSuccessHumanAIDelegate>( typeof(HumanAI), "PathfindSuccess", true); return(new HumanAIConnection( spawnCitizenAI, startPathFindCitizenAI, simulationStepCitizenAI, arriveAtDestination, invalidPath, pathfindFailure, pathfindSuccess)); } catch (Exception e) { Log.Error(e.Message); return(null); } }
public static void RegisterSpawnHandler(Guid assetId, SpawnDelegate 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; }
internal HumanAIConnection(SpawnDelegate spawnCitizenAI, StartPathFindDelegate startPathFindCitizenAI, SimulationStepDelegate simulationStepCitizenAI, ArriveAtDestinationDelegate arriveAtDestination, InvalidPathHumanAIDelegate invalidPath, PathfindFailureHumanAIDelegate pathfindFailure, PathfindSuccessHumanAIDelegate pathfindSuccess) { SpawnCitizenAI = spawnCitizenAI ?? throw new ArgumentNullException(nameof(spawnCitizenAI)); StartPathFindCitizenAI = startPathFindCitizenAI ?? throw new ArgumentNullException(nameof(startPathFindCitizenAI)); SimulationStepCitizenAI = simulationStepCitizenAI ?? throw new ArgumentNullException(nameof(simulationStepCitizenAI)); ArriveAtDestination = arriveAtDestination ?? throw new ArgumentNullException(nameof(arriveAtDestination)); InvalidPath = invalidPath ?? throw new ArgumentNullException(nameof(invalidPath)); PathfindFailure = pathfindFailure ?? throw new ArgumentNullException(nameof(pathfindFailure)); PathfindSuccess = pathfindSuccess ?? throw new ArgumentNullException(nameof(pathfindSuccess)); }
/// <summary> /// Registers a spawn handler. /// </summary> /// <param name="assetIndex">Id of the asset.</param> /// <param name="spawnHandler">The spawn handler.</param> /// <param name="unspawnHandler">The unspawn handler.</param> public void RegisterSpawnHandler(int assetIndex, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (spawnHandler == null || unspawnHandler == null) { if (TinyNetLogLevel.logError) { TinyLogger.LogError("RegisterSpawnHandler custom spawn function null for " + assetIndex); } return; } if (TinyNetLogLevel.logDebug) { TinyLogger.Log("RegisterSpawnHandler asset '" + assetIndex + "' " + spawnHandler.Method.Name + "/" + unspawnHandler.Method.Name); } _spawnHandlers[assetIndex] = spawnHandler; _unspawnHandlers[assetIndex] = unspawnHandler; }
static internal void RegisterSpawnHandler(NetworkHash128 assetId, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (spawnHandler == null || unspawnHandler == null) { if (LogFilter.logError) { Debug.LogError("RegisterSpawnHandler custom spawn function null for " + assetId); } return; } if (LogFilter.logDebug) { Debug.Log("RegisterSpawnHandler asset '" + assetId + "' " + spawnHandler.GetMethodName() + "/" + unspawnHandler.GetMethodName()); } s_SpawnHandlers[assetId] = spawnHandler; s_UnspawnHandlers[assetId] = 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> /// 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, SpawnDelegate 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; } // We need this check here because we don't want a null handler in the lambda expression below if (spawnHandler == null) { logger.LogError($"Can not Register null SpawnHandler for {assetId}"); return; } RegisterPrefab(prefab, msg => spawnHandler(msg.position, msg.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, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { RegisterPrefab(prefab, msg => spawnHandler(msg.position, msg.assetId), unspawnHandler); }
/// <summary> /// <para>Registers a prefab with the UNET spawning system.</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> /// <param name="newAssetId">An assetId to be assigned to this prefab. This allows a dynamically created game object to be registered for an already known asset Id.</param> public static void RegisterPrefab(GameObject prefab, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkScene.RegisterPrefab(prefab, spawnHandler, unspawnHandler); }
internal static void RegisterPrefab(GameObject prefab, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkIdentity component = prefab.GetComponent<NetworkIdentity>(); if ((Object) component == (Object) null) { if (!LogFilter.logError) return; Debug.LogError((object) ("Could not register '" + prefab.name + "' since it contains no NetworkIdentity component")); } else if (spawnHandler == null || unspawnHandler == null) { if (!LogFilter.logError) return; Debug.LogError((object) ("RegisterPrefab custom spawn function null for " + (object) component.assetId)); } else if (!component.assetId.IsValid()) { if (!LogFilter.logError) return; Debug.LogError((object) ("RegisterPrefab game object " + prefab.name + " has no prefab. Use RegisterSpawnHandler() instead?")); } else { if (LogFilter.logDebug) Debug.Log((object) ("Registering custom prefab '" + prefab.name + "' as asset:" + (object) component.assetId + " " + spawnHandler.Method.Name + "/" + unspawnHandler.Method.Name)); NetworkScene.s_SpawnHandlers[component.assetId] = spawnHandler; NetworkScene.s_UnspawnHandlers[component.assetId] = unspawnHandler; } }
internal static void RegisterSpawnHandler(NetworkHash128 assetId, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (spawnHandler == null || unspawnHandler == null) { if (!LogFilter.logError) return; Debug.LogError((object) ("RegisterSpawnHandler custom spawn function null for " + (object) assetId)); } else { if (LogFilter.logDebug) Debug.Log((object) ("RegisterSpawnHandler asset '" + (object) assetId + "' " + spawnHandler.Method.Name + "/" + unspawnHandler.Method.Name)); NetworkScene.s_SpawnHandlers[assetId] = spawnHandler; NetworkScene.s_UnspawnHandlers[assetId] = unspawnHandler; } }
/// <summary> /// <para>This is an advanced spawning funciotn that registers a custom assetId with the UNET spawning system.</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(NetworkHash128 assetId, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkScene.RegisterSpawnHandler(assetId, spawnHandler, unspawnHandler); }
protected void CallRegisterPrefab(GameObject prefab, RegisterPrefabOverload overload, SpawnDelegate spawnHandler) { UnSpawnDelegate unspawnHandler = new UnSpawnDelegate(x => {}); switch (overload) { case RegisterPrefabOverload.Prefab_SpawnDelegate: NetworkClient.RegisterPrefab(prefab, spawnHandler, unspawnHandler); break; case RegisterPrefabOverload.Prefab_SpawnDelegate_NewAssetId: NetworkClient.RegisterPrefab(prefab, anotherGuid, spawnHandler, unspawnHandler); break; case RegisterPrefabOverload.Prefab: case RegisterPrefabOverload.Prefab_NewAssetId: case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate: case RegisterPrefabOverload.Prefab_SpawnHandlerDelegate_NewAssetId: Debug.LogError("Overload did not have SpawnDelegate parameter"); break; default: Debug.LogError("Overload not found"); break; } }
public static void RegisterSpawnHandler(NetworkHash128 assetId, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkScene.RegisterSpawnHandler(assetId, spawnHandler, unspawnHandler); }
internal static void RegisterSpawnHandler(NetworkHash128 assetId, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if ((spawnHandler == null) || (unspawnHandler == null)) { if (LogFilter.logError) { Debug.LogError("RegisterSpawnHandler custom spawn function null for " + assetId); } } else { if (LogFilter.logDebug) { Debug.Log(string.Concat(new object[] { "RegisterSpawnHandler asset '", assetId, "' ", DotNetCompatibility.GetMethodName(spawnHandler), "/", DotNetCompatibility.GetMethodName(unspawnHandler) })); } s_SpawnHandlers[assetId] = spawnHandler; s_UnspawnHandlers[assetId] = unspawnHandler; } }
internal static void RegisterSpawnHandler(NetworkHash128 assetId, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { if (spawnHandler == null || unspawnHandler == null) { if (LogFilter.logError) { Debug.LogError("RegisterSpawnHandler custom spawn function null for " + assetId); } return; } if (LogFilter.logDebug) { Debug.Log(string.Concat(new object[] { "RegisterSpawnHandler asset '", assetId, "' ", spawnHandler.Method.Name, "/", unspawnHandler.Method.Name })); } NetworkScene.s_SpawnHandlers[assetId] = spawnHandler; NetworkScene.s_UnspawnHandlers[assetId] = unspawnHandler; }
/// <summary> /// Gets the spawn handler of an asset. /// </summary> /// <param name="assetGUID">The asset unique identifier.</param> /// <param name="handler">The handler.</param> /// <returns></returns> public bool GetSpawnHandler(string assetGUID, out SpawnDelegate handler) { return(GetSpawnHandler(GetAssetIdFromAssetGUID(assetGUID), out handler)); }
internal static void RegisterPrefab(GameObject prefab, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkIdentity component = prefab.GetComponent<NetworkIdentity>(); if (component == null) { if (LogFilter.logError) { Debug.LogError("Could not register '" + prefab.get_name() + "' since it contains no NetworkIdentity component"); } return; } if (spawnHandler == null || unspawnHandler == null) { if (LogFilter.logError) { Debug.LogError("RegisterPrefab custom spawn function null for " + component.assetId); } return; } if (!component.assetId.IsValid()) { if (LogFilter.logError) { Debug.LogError("RegisterPrefab game object " + prefab.get_name() + " has no prefab. Use RegisterSpawnHandler() instead?"); } return; } if (LogFilter.logDebug) { Debug.Log(string.Concat(new object[] { "Registering custom prefab '", prefab.get_name(), "' as asset:", component.assetId, " ", spawnHandler.Method.Name, "/", unspawnHandler.Method.Name })); } NetworkScene.s_SpawnHandlers[component.assetId] = spawnHandler; NetworkScene.s_UnspawnHandlers[component.assetId] = unspawnHandler; }
// Use this for initialization void Start() { spawnCallback += SpawnOrc; spawnCallback += SpawnTroll; }
// Use this for initialization void Start() { // Subscribe all functions to delegate spawnCallback += SpawnOrc; spawnCallback += SpawnTroll; }
/// <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, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { RegisterSpawnHandler(assetId, msg => spawnHandler(msg.position, msg.assetId), unspawnHandler); }
public static void RegisterPrefab(GameObject prefab, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkScene.RegisterPrefab(prefab, spawnHandler, unspawnHandler); }
internal static void RegisterPrefab(GameObject prefab, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler) { NetworkIdentity component = prefab.GetComponent<NetworkIdentity>(); if (component == null) { if (LogFilter.logError) { Debug.LogError("Could not register '" + prefab.name + "' since it contains no NetworkIdentity component"); } } else if ((spawnHandler == null) || (unspawnHandler == null)) { if (LogFilter.logError) { Debug.LogError("RegisterPrefab custom spawn function null for " + component.assetId); } } else if (!component.assetId.IsValid()) { if (LogFilter.logError) { Debug.LogError("RegisterPrefab game object " + prefab.name + " has no prefab. Use RegisterSpawnHandler() instead?"); } } else { if (LogFilter.logDebug) { Debug.Log(string.Concat(new object[] { "Registering custom prefab '", prefab.name, "' as asset:", component.assetId, " ", DotNetCompatibility.GetMethodName(spawnHandler), "/", DotNetCompatibility.GetMethodName(unspawnHandler) })); } s_SpawnHandlers[component.assetId] = spawnHandler; s_UnspawnHandlers[component.assetId] = unspawnHandler; } }
// Use this for initialization void Start() { // Subscribe to the function spawnCallback += SpawnOrc; spawnCallback += SpawnTroll; }
void Awake() { instance = this; }