/// <summary> /// Attempts to spawn an item at a spawn point. /// If successful the return value will be true otherwise false. /// </summary> /// <param name="toSpawn">The transform of the object to spawn</param> /// <returns>True if the spawn was successful otherwise false</returns> public virtual bool spawn(Transform toSpawn) { #if ULTIMATE_SPAWNER_NETWORKED == true if (isServer == false) { NetError.raise(); } #endif // Check if we can spawn if (canSpawn() == false) { // Trigger failed invokeSpawnFailedEvent(); return(false); } // Get the spawn point ISpawn spawn = this.selectSpawn(spawnMode); // Get the spawn info SpawnInfo info = spawn.getSpawnInfo(); // Spawn the item info.spawnObjectAt(toSpawn); // Success invokeSpawnedEvent(toSpawn); return(true); }
/// <summary> /// Maintains an enumerator state between calls so thet subsiquent calls to this method will return the next spawn inline. /// </summary> /// <param name="inSpawn">Extension input</param> /// <returns></returns> public static ISpawn sequentialSpawn(this ISpawn inSpawn) { // Check for existing if (sequential.ContainsKey(inSpawn) == false) { sequential.Add(inSpawn, inSpawn.GetEnumerator()); } // Get the keypair IEnumerator <ISpawn> enumerator = sequential[inSpawn]; // Try to move the enumerator otherwise reset it if (enumerator.MoveNext() == false) { // Reset the enumerator (Cant use Reset in this case), Move next makes usre we start at the first item sequential[inSpawn] = inSpawn.GetEnumerator(); sequential[inSpawn].MoveNext(); // Update the local enumerator enumerator = sequential[inSpawn]; } // Get the current spawn return(enumerator.Current); }
/// <summary> /// Attempt to spawn an item using current settings. /// </summary> /// <returns>The transform of the spawned item</returns> public override Transform spawn() { #if ULTIMATE_SPAWNER_NETWORKED == true if (isServer == false) { NetError.raise(); } #endif // Make sure we can spawn if (canSpawn() == false) { // Spawn failed invokeSpawnFailedEvent(); return(null); } // Select the spawn location ISpawn spawn = this.selectSpawn(spawnMode); // Call spawn on the child Transform result = spawn.spawn(); // Trigger event if (result == null) { invokeSpawnFailedEvent(); } else { invokeSpawnedEvent(result); } return(result); }
// Constructor /// <summary> /// Create a new instance of the spawn info using a spawn location. /// </summary> /// <param name="owner">The spawn location that created this instance</param> /// <param name="transform">The transform representing the location and rotation</param> public SpawnInfo(ISpawn owner, Transform transform) { // Store the owner of this spawn point this.owner = owner; // Get the transform information this.spawnPoint = transform.position; this.spawnRotation = transform.rotation; }
public Npc(World world, ISpawn spawn, int difficulty) : base(world, spawn) { World = world; VisionRectangle = new VectorRectangle(); this.Difficulty = difficulty; //makeBody(); hitBehaviour = new HitBehaviour(this); }
public void Summon(ISpawn spawn) { if (this.spawns[spawn.Rank] <= 0) { throw new SpawnInventoryFullException("A Player cannot have more than 7 Junior, 5 Regular or 3 Senior Spawns!"); } this.playerInventory.Add(spawn); this.spawns[spawn.Rank]--; FileLogger.Log($" -- Player {this.Name} has summoned {spawn.Rank} {spawn.Type} {spawn.Name}!"); }
// Methods /// <summary> /// Iterates through all child spawns in a specified spawn and returns a collection of un-occupied spawns. /// </summary> /// <param name="inSpawn">Extension input</param> /// <returns></returns> public static IEnumerable <ISpawn> freeSpawns(this ISpawn inSpawn) { // Iterate through the spawn to check if there are any free spawns foreach (ISpawn spawn in inSpawn) { // Check if the spawn is occupied if (spawn.canSpawn() == true) { // Get the item yield return(spawn); } } }
/// <summary> /// Returns true of the spawner is configured correctly. /// </summary> /// <param name="inSpawn">The spawn point to validate</param> /// <returns>True is the spawner is correctly configured</returns> public static bool isValidConfiguration(this ISpawn inSpawn) { // Check for correct setup if (inSpawn.SpawnSettings == SpawnSettings.Custom) { if (inSpawn.Spawner == null) { return(false); } } return(true); }
private void Start() { navMesh = GetComponent <NavMeshAgent>(); moveSystem = new AIMovementSystem(); invisibilitySystem = new InvisibilitySystem(); spawnSystem = new SpawnSystem(); moveSystem.Setup(speed, raycastLimit); moveSystem.TriggerMovement(transform); invisibilitySystem.Show(false, model.gameObject); }
public Character(IParent parent, ISpawn spawn = null) : base(parent) { Spawn = spawn; MovableBehaviour = new MovableBehaviour(); _onDieListeners = new List<Delegate>(); _colorBehaviour = new ColorBehaviour(this); WalkingAcceleration = 15; WalkingSpeed = 40; jumpPower = 42; }
public bool Spawn(GameObject spawnController, Vector2 spawnPosition) { Instantiate(spawnController, new Vector3(spawnPosition.x, spawnPosition.y, 0), Quaternion.identity); ISpawn spawn = spawnController.gameObject.GetComponent <ISpawn>(); if (spawn != null) { spawn.Spawn(); return(true); } return(false); }
/// <summary> /// Called by Unity. /// </summary> protected virtual void Start() { // Check for parent if (transform.parent == null) { return; } // Get the parent object GameObject parentObject = transform.parent.gameObject; // Get the ISpawn parent parent = parentObject.GetComponent <ISpawn>(); }
public GameObject Spawn(string tag, Vector3?position = null, Quaternion?rotation = null, Transform parent = null, bool willSpawn = false) { GameObject obj = poolDictionary[tag].Dequeue(); obj.SetActive(true); obj.transform.position = position ?? new Vector3(0f, 0f, 0f); obj.transform.rotation = rotation ?? Quaternion.Euler(0f, 0f, 0f); poolDictionary[tag].Enqueue(obj); ISpawn spawn = obj.GetComponent <ISpawn>(); if (!(spawn is null)) { spawn.Spawn(); } return(obj); }
public GameObject SpawnUI(string tag, Vector3?position = null, Transform parent = null) { GameObject obj = poolDictionary[tag].Dequeue(); obj.SetActive(true); obj.transform.SetParent(parent, false); obj.transform.position = position ?? new Vector3(0f, 0f, 0f); poolDictionary[tag].Enqueue(obj); ISpawn spawn = obj.GetComponent <ISpawn>(); if (!(spawn is null)) { spawn.Spawn(); } return(obj); }
public GameObject GetObjectFromPool(GameObject argGameObject, bool argIgnoreAllActiveCheck = false, bool argActivateGameObject = true, bool argShouldPeek = false) { if (null == argGameObject) { Debug.LogError("Cannot Get object from pool because given object is null"); return(null); } if (m_objectPool.ContainsKey(argGameObject.name)) { if (m_objectPool[argGameObject.name].Peek().activeSelf&& !argIgnoreAllActiveCheck) { Debug.LogWarning("All objects in queue are active, given key=" + argGameObject.name); } GameObject poolObject; if (argShouldPeek) { poolObject = m_objectPool[argGameObject.name].Peek().gameObject; } else { poolObject = m_objectPool[argGameObject.name].Dequeue().gameObject; m_objectPool[argGameObject.name].Enqueue(poolObject); } if (argActivateGameObject) { poolObject.SetActive(true); } ISpawn spawnInterface = poolObject.GetComponent <ISpawn>(); if (null != spawnInterface) { spawnInterface.OnSpawn(); } return(poolObject); } else { Debug.LogError("Cannot get object from pool because key is invalid, given key=" + argGameObject.name); return(null); } }
public static List <ManagedJob> CreateJobs() { List <ManagedJob> jobCollection = new List <ManagedJob>(); List <JobElement> jobList = ConfigurationHelper.GetEnabledJobs(); foreach (JobElement job in jobList) { // Look for implementation for the Job Type jobImplClass = LoadImplementationClass(ConfigurationHelper.GetJobType(job)); if (jobImplClass != null) { JobArgumentCollection jac = ConfigurationHelper.GetJobArgumentCollection(job); List <object> arguments = new List <object>(); arguments.Add(job.Name); arguments.Add(job.WaitForEvent); arguments.Add(jac); // Create an instance of the job ManagedJob managedJob = Activator.CreateInstance(jobImplClass, arguments.ToArray()) as ManagedJob; ISpawn spawn = managedJob as ISpawn; if (spawn != null) { ManagedJob[] spawnedJobs = spawn.SpawnJobs(); foreach (ManagedJob j in spawnedJobs) { job.Log.FileName = Path.Combine(Path.GetDirectoryName(job.Log.FileName), j.Name) + Path.GetExtension(job.Log.FileName); InitializeTracing(j, job.Log); jobCollection.Add(j); } } else { InitializeTracing(managedJob, job.Log); jobCollection.Add(managedJob); } } } return(jobCollection); }
void Start() { spawn = FindObjectOfType<ISpawn>(); BeforeGameStart(); if (!player) { player = FindObjectOfType<CPlayer>(); } if (!camera) { camera = FindObjectOfType<CameraMovement>(); if (camera) camera.SetTarget(player); } OnGameStart(player); }
/// <summary> /// Selects a spawn based on the spawn mode from the collection of child spawns that are available. /// </summary> /// <param name="inSpawn">Extension input</param> /// <param name="spawnMode">The spawn mode to use for selection</param> /// <returns></returns> public static ISpawn selectSpawn(this ISpawn inSpawn, SpawnMode spawnMode) { // Different spawn modes switch (spawnMode) { default: case SpawnMode.Random: { // Select a random spawn (Area or point) return(inSpawn.randomSpawn()); } case SpawnMode.Sequential: { // Select the next spawn (Area or point) return(inSpawn.sequentialSpawn()); } } }
/// <summary> /// Iterates through all child spawns and selects a random un-occupied spawn. /// </summary> /// <param name="inSpawn">Extension input</param> /// <returns></returns> public static ISpawn randomSpawn(this ISpawn inSpawn) { // Find all free spawns IEnumerable <ISpawn> spawns = inSpawn.freeSpawns(); // Get the size int size = spawns.size(); // Check for error if (size == 0) { return(null); } // Select a random index int index = Random.Range(0, size); // Get the spawn return(spawns.element(index)); }
/// <summary> /// Create an instance for the current spawner. /// </summary> /// <param name="inSpawn">The spawn point to spawn from</param> /// <returns>The trnsform of the spawned instance</returns> public static Transform createSpawnableInstance(this ISpawn inSpawn) { Transform result = null; switch (inSpawn.SpawnSettings) { case SpawnSettings.Custom: { // Make sure our spawner is setup if (inSpawn.Spawner == null) { return(null); } // Try to spawn the enemy GameObject temp = inSpawn.Spawner.createSpawnable(); if (temp != null) { result = temp.transform; } } break; case SpawnSettings.UseParent: { // Make sure our parent is valid if (inSpawn.Parent == null) { Debug.Log("Null parent"); return(null); } // Try to spawn from our parent result = inSpawn.Parent.createSpawnableInstance(); } break; } return(result); }
/// <summary> /// Returns an instance of the spawn info class representing a free spawn point at the time of calling this method. /// This can be used to access the location and rotation of the spawn point for manual spawning. /// </summary> /// <returns>An instance of the spawn info class representing a specific spawn location</returns> public override SpawnInfo getSpawnInfo() { #if ULTIMATE_SPAWNER_NETWORKED == true if (isServer == false) { NetError.raise(); } #endif // Select a spawn using the spawn mode ISpawn spawn = this.selectSpawn(spawnMode); // Check for null if (spawn == null) { return(null); } // Get the spawn info return(spawn.getSpawnInfo()); }
public SpawnElementStrategy(ISpawn spawn) { _spawn = spawn; }
public static bool TryGetCreepOrSpawn(string name, out ICreep creep, Bodypart[] parts, ISpawn spawn) { if (Game.instance.creeps.TryGetValue(name, out creep)) { return(true); } Log(spawn?.SpawnCreep(parts, name).ToString() ?? "-42"); return(false); }
private void Awake() { _spawn = GetComponent <ISpawn>(); _destroy = GetComponent <IDestroy>(); _difficulty = GetComponent <IDifficulty>(); }
private void SetEnemy(ISpawn enemy) { spawn = enemy; }
public Player(World world, ISpawn spawn) : base(world, spawn) { _availableColorList = new List<Color>(); }
public void SetSpawner(ISpawn spawn) { spawner = spawn; }