//whenever a building is added or removed, this method will be called to add/remove it to the lists in the spawn units: public void ReloadTaskLauncherLists (TaskLauncher TaskComp, bool Add) { if (TaskComp.UnitCreationTasks.Count > 0 && Units.Length > 0) { //Make sure that it can actually create units and that there units to spawn //go through the units to create: for (int i = 0; i < Units.Length; i++) { //loop through the unit creation tasks for (int j = 0; j < TaskComp.UnitCreationTasks.Count; j++) { int ID = TaskComp.UnitCreationTasks [j]; if (Add == false) { //if this task launcher is getting removed //and we found it in one of the lists: if (Units [i].SourceTaskLaunchers.Contains (TaskComp)) { Units [i].TasksIDs.RemoveAt (Units [i].SourceTaskLaunchers.IndexOf (TaskComp)); //remove this from the task IDs list //remove the task launcher from the list: Units [i].SourceTaskLaunchers.Remove (TaskComp); } } else { //if we are adding this task launcher //do the units match? if (Units [i].Prefab.Code == TaskComp.TasksList [ID].UnitCreationSettings.Prefabs[0].Code) { //if this task launcher is just built then the building will be added: Units [i].SourceTaskLaunchers.Add (TaskComp); //add the task ID as well: Units[i].TasksIDs.Add(ID); } } } } } }
/// <summary> /// Called each time a new TaskLauncher instance is initialized. /// </summary> /// <param name="taskLauncher">The new added TaskLauncher instance.</param> /// <param name="taskID">None.</param> /// <param name="taskQueueID">None.</param> private void OnTaskLauncherAdded(TaskLauncher taskLauncher, int taskID, int taskQueueID) { if (taskLauncher.FactionEntity.FactionID == FactionID) //make sure the new task launcher belongs to the faction managed by this component { taskLaunchers.Add(taskLauncher); //add task launcher to list. } }
void OnTaskLauncherAdded(TaskLauncher taskLauncher, int taskID = -1, int taskQueueID = -1) //called when a new task launcher has been added { if (taskLauncher.FactionEntity.FactionID == factionMgr.FactionID) //if the task launcher belongs to this faction { UpdateUpgradeTasks(taskLauncher, true); //update upgrade tasks } }
void OnTaskLauncherRemoved(TaskLauncher taskLauncher, int taskID = -1, int taskQueueID = -1) //called when a task launcher has been removed { if (factionMgr && taskLauncher.FactionEntity.FactionID == factionMgr.FactionID) //if the task launcher belongs to this faction { UpdateUpgradeTasks(taskLauncher, false); //update upgrade tasks } }
/// <summary> /// Adds a TaskLauncher instance to be tracked by the NPCUnitRegulator if it includes tasks that allow the regulated unit type. /// </summary> /// <param name="taskLauncher">TaskLauncher instance to add.</param> public void AddTaskLauncher(TaskLauncher taskLauncher) { if (unitCreators.ContainsKey(taskLauncher) || //if the task launcher is already registered taskLauncher.FactionEntity.FactionID != factionMgr.FactionID) //or the task launcher doesn't belong to the same NPC faction. { return; } for (int taskID = 0; taskID < taskLauncher.GetTasksCount(); taskID++) { FactionEntityTask nextTask = taskLauncher.GetTask(taskID); //if the task's type is unit creation and it the unit to create code matches the code of unit type that is regulated by this component if (nextTask.GetTaskType() == TaskTypes.createUnit && nextTask.UnitCode == Code) { if (unitCreators.TryGetValue(taskLauncher, out List <int> taskIDList)) //task launcher already is registered as key, just append value list { taskIDList.Add(taskID); } else //register task launcher as new key and task ID as the only element in the value list. { unitCreators.Add(taskLauncher, new List <int>(new int[] { taskID })); } } } }
/// <summary> /// Called each time a TaskLauncher instance is removed/destroyed. /// </summary> /// <param name="taskLauncher">The removed/destroyed TaskLauncher instance.</param> /// <param name="taskID">None.</param> /// <param name="taskQueueID">None.</param> private void OnTaskLauncherRemoved(TaskLauncher taskLauncher, int taskID, int taskQueueID) { if (taskLauncher.FactionEntity.FactionID == FactionID) //make sure the new task launcher belongs to the faction managed by this component { taskLaunchers.Remove(taskLauncher); //remove task launcher from list } }
public override void OnEnable() { base.OnEnable(); source = (TaskLauncher)target; taskLauncher_SO = new SerializedObject(source); }
public void UpdateTaskLauncherTasks(FactionEntity sourceEntity, TaskLauncher taskLauncher) { if (taskLauncher == null || taskLauncher.Initiated == false || taskLauncher.GetTasksCount() == 0) //if the task launcher is invalid or the source can't manage a task { return; } for (int taskID = 0; taskID < taskLauncher.GetTasksCount(); taskID++) //go through all tasks { FactionEntityTask task = taskLauncher.GetTask(taskID); if (task.IsEnabled() == true) { TaskUI taskUI = Add(new TaskUIAttributes { ID = taskID, type = task.GetTaskType(), icon = task.GetIcon(), source = sourceEntity, taskLauncher = taskLauncher }, task.GetTaskPanelCategory()); if (task.GetTaskType() == TaskTypes.createUnit) //if this is a unit creation task, check if it has reached its limit and change task ui image color accordinly { taskUI.GetComponent <Image>().color = sourceEntity.FactionMgr.HasReachedLimit(task.UnitCode, task.UnitCategory) == true ? Color.red : Color.white; } } } UpdateInProgressTasks(taskLauncher); //show the in progress tasks }
/// <summary> /// Called when a TaskLauncher instance is destroyed. /// </summary> /// <param name="taskLauncher">The TaskLauncher instance that is removed.</param> /// <param name="taskID">Ignore.</param> /// <param name="taskQueueID">Ignore.</param> private void OnTaskLauncherRemoved(TaskLauncher taskLauncher, int taskID = -1, int taskQueueID = -1) //called when a task launcher has been removed { if (taskLauncher.FactionEntity.FactionID == factionMgr.FactionID) //if the task launcher belongs to this faction { RemoveTaskLauncher(taskLauncher); } }
/// <summary> /// Called when a new TaskLauncher instance is initiated. /// </summary> /// <param name="taskLauncher">The TaskLauncher instance that is added.</param> /// <param name="taskID">Ignore.</param> /// <param name="taskQueueID">Ignore.</param> private void OnTaskLauncherAdded(TaskLauncher taskLauncher, int taskID = -1, int taskQueueID = -1) { if (taskLauncher.FactionEntity.FactionID == factionMgr.FactionID) //if the task launcher belongs to this faction { AddTaskLauncher(taskLauncher); } }
//a method used to request to launch an upgrade task, returns true if the upgrade task is launched, false if not public bool OnUpgradeLaunchRequest(TaskLauncher taskLauncher, int taskID, bool auto) { //if this attempt is done automatically (from the NPC Unit Creator itself) and the regulator doesn't allow it if (auto == true && autoUpgrade == false) { return(false); //do not proceed. } //if this has been requested from another NPC component and the regulator doesn't allow it if (auto == false && upgradeOnDemand == false) { return(false); //do not proceed. } //randomly decide (based on input values) if this would be accepetd or not: if (Random.value <= acceptanceRange.getRandomValue()) { //attempt to launch the task ErrorMessage addTaskMsg = gameMgr.TaskMgr.AddTask(new TaskUIAttributes { taskLauncher = taskLauncher, ID = taskID, type = TaskTypes.upgrade }); //TO BE ADDED: Handling insufficient resources. //if adding the upgrade task was successful, this would return true, if not then false. return(addTaskMsg == ErrorMessage.none); } else { return(false); } }
//for local player only, not for NPC factions public bool CanAddTask(TaskLauncher TaskComp, int TaskID, TaskTypes TaskType) { //Always check that the health is above the minimal limit to launch tasks and that the building was built (to max health) at least once: if (TaskComp.GetTaskHolderHealth() < TaskComp.MinTaskHealth) { UIMgr.ShowPlayerMessage("Health is too low to launch task!", UIManager.MessageTypes.Error); AudioManager.PlayAudio(GameMgr.GeneralAudioSource.gameObject, TaskComp.DeclinedTaskAudio, false); //Declined task audio. return(false); } else if (TaskComp.MaxTasks <= TaskComp.TasksQueue.Count) { //Notify the player that the maximum amount of tasks for this building has been reached UIMgr.ShowPlayerMessage("Maximum building tasks has been reached", UIManager.MessageTypes.Error); AudioManager.PlayAudio(GameMgr.GeneralAudioSource.gameObject, TaskComp.DeclinedTaskAudio, false); //Declined task audio. return(false); } //Do we have enough resources for this task? if (TaskType == TaskManager.TaskTypes.TaskUpgrade) { //upgrade task: //Make sure there are enough resources if (ResourceMgr.CheckResources(TaskComp.TasksList[TaskID].UnitCreationSettings.Upgrades[TaskComp.TasksList[TaskID].CurrentUpgradeLevel].UpgradeResources, GameManager.PlayerFactionID, 1.0f) == false) { UIMgr.ShowPlayerMessage("Not enough resources to launch upgrade task!", UIManager.MessageTypes.Error); AudioManager.PlayAudio(GameMgr.GeneralAudioSource.gameObject, TaskComp.DeclinedTaskAudio, false); //Declined task audio. return(false); } } else { if (ResourceMgr.CheckResources(TaskComp.TasksList[TaskID].RequiredResources, GameManager.PlayerFactionID, 1) == false) { UIMgr.ShowPlayerMessage("Not enough resources to launch task!", UIManager.MessageTypes.Error); AudioManager.PlayAudio(GameMgr.GeneralAudioSource.gameObject, TaskComp.DeclinedTaskAudio, false); //Declined task audio. return(false); } if (TaskType == TaskManager.TaskTypes.CreateUnit) { //create unit task if (GameMgr.Factions[GameManager.PlayerFactionID].CurrentPopulation >= GameMgr.Factions[GameManager.PlayerFactionID].MaxPopulation) { //Inform the player that there's no more room for new units. UIMgr.ShowPlayerMessage("Maximum population has been reached!", UIManager.MessageTypes.Error); AudioManager.PlayAudio(GameMgr.GeneralAudioSource.gameObject, TaskComp.DeclinedTaskAudio, false); //Declined task audio. return(false); } //if there's population slots but the local faction already hit the limit with this faction else if (GameMgr.Factions[GameManager.PlayerFactionID].FactionMgr.HasReachedLimit(TaskComp.TasksList[TaskID].UnitCreationSettings.Prefabs[0].Code)) { //inform the player that he can't create this unit UIMgr.ShowPlayerMessage("This unit has reached its creation limit", UIManager.MessageTypes.Error); AudioManager.PlayAudio(GameMgr.GeneralAudioSource.gameObject, TaskComp.DeclinedTaskAudio, false); //Declined task audio. return(false); } } } return(true); }
public void OnTaskCanceled(TaskLauncher TaskComp, int TaskID, int TaskQueueID) //called when a task launcher cancels a task { if (DebugEnabled == true) { Debug.Log("Task Launcher canceled a pending task."); } TaskCanceled(TaskComp, TaskID, TaskQueueID); }
/// <summary> /// Called whenever a FactionEntityTask instance is canceled while in progress in a TaskLauncher instance. /// </summary> /// <param name="taskLauncher">TaskLauncher instance whose task is cancelled.</param> /// <param name="taskID">ID of the cancelled task.</param> /// <param name="taskQueueID">None.</param> private void OnTaskCanceled(TaskLauncher taskLauncher, int taskID, int taskQueueID) { //if the canceled task is being tracked by this regulator. if (unitCreators.TryGetValue(taskLauncher, out List <int> taskIDList) && taskIDList.Contains(taskID)) { Remove(); } }
/// <summary> /// Called when a task is either canceled or completed. /// </summary> /// <param name="taskLauncher">TaskLauncher instance where the task is canceled or completed.</param> /// <param name="taskID">Index of the task.</param> /// <param name="taskQueueID">Index of the task on pending queue.</param> private void OnTaskStopped(TaskLauncher taskLauncher, int taskID, int taskQueueID) { if (taskLauncher.FactionEntity.FactionID == factionMgr.FactionID && //only if task launcher belongs to NPC faction taskLauncher.GetTask(taskID).GetTaskType() == TaskTypes.upgrade) //if this is an upgrade task, then add the upgrade source code to the pending upgrades list { pendingUpgrades.RemoveAll(code => code == taskLauncher.GetTask(taskID).GetUpgradeSourceCode()); } }
/* Unit creation */ void OnTaskLauncherAdded(TaskLauncher taskLauncher, int taskID = -1, int taskQueueID = -1) //called when a new task launcher has been added { if (taskLauncher.FactionEntity.FactionID == factionMgr.FactionID) //if the task launcher belongs to this faction { //update the source task launchers: UpdateUnitCreatorList(taskLauncher, true); } }
public void OnTaskCompleted(TaskLauncher TaskComp, int TaskID, int TaskQueueID) //called when a task launcher completes a task { if (DebugEnabled == true) { Debug.Log("Task Launcher completed a task."); } TaskCompleted(TaskComp, TaskID, TaskQueueID); }
public void OnTaskLauncherRemoved(TaskLauncher TaskComp) //called when a task launcher has been removed { if (DebugEnabled == true) { Debug.Log("Task Launcher has been removed."); } TaskLauncherRemoved(TaskComp); }
//update an upgraded unit creation task's info: private void UpdateUnitCreationTask(TaskLauncher taskLauncher, string upgradedUnitCode, Unit targetUnitPrefab, Upgrade.NewTaskInfo newTaskInfo) { //go through the tasks: for (int i = 0; i < taskLauncher.GetTasksCount(); i++) { taskLauncher.GetTask(i).Update(upgradedUnitCode, targetUnitPrefab, newTaskInfo); } }
void OnTaskLauncherRemoved(TaskLauncher taskLauncher, int taskID = -1, int taskQueueID = -1) //called when a task launcher has been removed { if (taskLauncher.FactionID == factionMgr.FactionID) //if the task launcher belongs to this faction { //update the source task launchers: UpdateUnitCreatorList(taskLauncher, false); } }
/// <summary> /// Gets the task IDs of a TaskLauncher instance that can create the regulated Unit type. /// </summary> /// <param name="taskLauncher">TaskLauncher instance whose tasks will be searched.</param> /// <returns>IEnumerable instance of integers that represent the task IDs if there are any, otherwise null.</returns> public IEnumerable <int> GetUnitCreationTasks(TaskLauncher taskLauncher) { if (unitCreators.TryGetValue(taskLauncher, out List <int> taskIDList)) { return(taskIDList); } return(null); }
//set the target for the next army unit to build: public void ReloadArmyUnitsPriority(TaskLauncher TaskComp, bool Add) { //make sure the building has army units: if (TaskComp.ArmyUnits.Count > 0) { //loop through them: for (int i = 0; i < TaskComp.ArmyUnits.Count; i++) { int NewPrefabID = 0; bool Found = false; int j = 0; while (Found == false && j < ArmyUnits.Length) { int x = 0; while (Found == false && x < ArmyUnits[j].Prefabs.Length) { if (ArmyUnits[j].Prefabs[x].Prefab.Code == TaskComp.TasksList[TaskComp.ArmyUnits[i]].UnitCreationSettings.Prefabs[0].Code) { //if the prefab was found. Found = true; if (Add == true) { //add the building: ArmyUnits[j].Prefabs[x].SpawnedTaskLaunchers.Add(TaskComp); NewPrefabID = x; } else { ArmyUnits[j].Prefabs[x].SpawnedTaskLaunchers.Remove(TaskComp); //if there no more buildings to produce this unit: if (ArmyUnits[j].Prefabs[x].SpawnedTaskLaunchers.Count == 0) { //check for priority: CheckArmyUnitsPriority(j, j); } } } x++; } j++; } if (Found == true && Add == true) { if (NewPrefabID < ArmyUnits[j - 1].PrefabID) { ArmyUnits[j - 1].PrefabID = NewPrefabID; ArmyUnits[j - 1].Prefab = ArmyUnits[j - 1].Prefabs[NewPrefabID].Prefab; } } } } }
//a method that is given a task in a task launcher and an upgrade component and that decides if the task handles that upgrade private bool IsUpgradeMatch(TaskLauncher taskLauncher, int taskID, Upgrade upgrade) { if (upgrade == null || taskLauncher == null) { return(false); } //true only if the source unit/building code match return(taskLauncher.GetTask(taskID).GetUpgradeSourceCode() == upgrade.Source.GetCode()); }
/// <summary> /// Adds a TaskLauncher instance's upgrade tasks. /// </summary> /// <param name="taskLauncher">The TaskLauncher instance to remove.</param> private void AddTaskLauncher(TaskLauncher taskLauncher) { //collect the upgrade tasks and add them as the value. upgradeTasks.Add(taskLauncher, taskLauncher.GetAll().Where(task => task.GetTaskType() == TaskTypes.upgrade).ToList()); if (autoUpgrade) { Activate(); //enable component if we can auto upgrade without an external upgrade request } }
public override void OnEnable() { base.OnEnable(); source = target as TaskLauncher; elementID = source.editorElementID; tabID = source.editorTabID; taskLauncher_SO = new SerializedObject(source); }
//called whenever a task is cancelled void OnTaskCanceled(TaskLauncher taskLauncher, int taskID, int taskQueueID) { //if this task is supposed to create a unit and the task launcher belongs to this faction: if (taskLauncher.GetTask(taskID).GetTaskType() == TaskTypes.createUnit && taskLauncher.FactionEntity.FactionID == factionMgr.FactionID) { if (taskLauncher.GetTask(taskID).GetCode() == code) { amount--; pendingAmount--; } } }
//called each time a task launcher status is updated (task added, cancelled or completed) private void OnTaskLauncherStatusUpdated(TaskLauncher taskLauncher, int taskID, int taskQueueID) { //only show the task launcher tasks if the task launcher is the only player entity selected if (SelectionManager.IsSelected(taskLauncher.FactionEntity.GetSelection(), true, true)) { Update(); if (taskLauncher.GetTask(taskID).IsAvailable == false) //if the task is no longer available { gameMgr.UIMgr.HideTooltip(); //hide the tooltip } } }
//sync all upgraded unit creation tasks for a task launcher: private void SyncUnitCreationTasks(TaskLauncher taskLauncher) { //go through the registered upgraded unit tasks foreach (UpgradedUnitTask uut in upgradedUnitTasks) { //if this task launcher belongs to the faction ID that has the upgraded unit creation task: if (uut.factionID == taskLauncher.FactionEntity.FactionID) { //sync the unit creation tasks. UpdateUnitCreationTask(taskLauncher, uut.upgradedUnitCode, uut.targetUnitPrefab, uut.newTaskInfo); } } }
//whenever a building is added or removed, this method will be called to add/remove it to the lists in the spawn units: public void UpdateUnitCreatorList(TaskLauncher taskLauncher, bool add) { //Make sure that this task launcher can actually create units and that there units to spawn if (taskLauncher.UnitCreationTasks.Count > 0) { //loop through the unit creation tasks foreach (int taskID in taskLauncher.UnitCreationTasks) { if (add == false) //if this task launcher is getting removed. { int i = 0; //go through all registerd task launchers in this component while (i < unitCreatorList.Count) { if (unitCreatorList[i].taskLauncher == taskLauncher) //if the task launcher matches: { //remove it: unitCreatorList.RemoveAt(i); } else { i++; //go to the next register unit creator } } } else //if we are adding this task launcher { //if there are valid prefab(s) assigned to this unit creation task if (taskLauncher.TasksList[taskID].UnitCreationSettings.Prefabs.Length > 0) { string prefabCode = taskLauncher.TasksList[taskID].UnitCreationSettings.Prefabs[0].Code; //if the unit code is included in the list => that unit is managed by this regulator if (prefabCode == code) { //go ahead and add it: UnitCreatorInfo newUnitCreator = new UnitCreatorInfo { //set the unit creator info: taskLauncher = taskLauncher, taskID = taskID }; //add it to the list: unitCreatorList.Add(newUnitCreator); } } } } } }
//called whenever a task is cancelled void OnTaskCanceled(TaskLauncher taskLauncher, int taskID, int taskQueueID) { //if this task is supposed to create a unit and the task launcher belongs to this faction: if (taskLauncher.TasksList[taskID].TaskType == TaskManager.TaskTypes.CreateUnit && taskLauncher.FactionID == factionMgr.FactionID) { //the prefabs assigned have the same code. if (taskLauncher.TasksList[taskID].UnitCreationSettings.Prefabs.Length > 0) { //we'll pick the first unit in array. Unit firstUnit = taskLauncher.TasksList[taskID].UnitCreationSettings.Prefabs[0]; if (firstUnit.Code == code) { RemoveItem(firstUnit); } } } }