// Update is called once per frame void Update() { //Defending: if (Defending == true) { //defense timer if (DefenseTimer > 0) { DefenseTimer -= Time.deltaTime; } if (DefenseTimer < 0) { //stop defending when the timer is done. StopDefending(); } } //searching the target faction timer: if (SetTargetTimer > 0) { SetTargetTimer -= Time.deltaTime; } if (SetTargetTimer < 0) { //pick the target faction: SetTargetTimer = 0.0f; PickTargetFaction(); } //if we don't have target yet and the target timer is not running and we're no longer in peace time if (TargetFaction == null && GameMgr.PeaceTime == 0.0f && SetTargetTimer == 0.0f) { //start the timer that will set the target faction at the end. SetTargetTimer = Random.Range(SetTargetReload.x, SetTargetReload.y); } //if we do have a target faction if (TargetFaction != null) { //if the target faction is the same as our faction or the targe faction has lost. if (TargetFaction.FactionID == FactionID || GameMgr.Factions [TargetFaction.FactionID].Lost == true) { //then the target faction is invalid. TargetFaction = null; } } //taking care of the army, creating army units and buildings: if (CheckArmyTimer > 0) { CheckArmyTimer -= Time.deltaTime; } if (CheckArmyTimer <= 0) { CheckArmyTimer = Random.Range(CheckArmyReload.x, CheckArmyReload.y); //Try to make the army: if (ArmyUnits.Length > 0) { //Decide how many army units we need to create: float ArmyPower = 0.0f; if (TargetFaction != null) { ArmyPower = TargetFaction.ArmyPower * ArmyPowerRatio; } if (ArmyPower < MinArmyPower) { ArmyPower = MinArmyPower; } //Loop through all different types of army units: for (int i = 0; i < ArmyUnits.Length; i++) { //Determine how many units we need: ArmyUnits [i].AmountNeeded = Mathf.RoundToInt(((ArmyUnits [i].AmountPerHundred * ArmyPower) / 100) / ArmyUnits [i].Prefab.gameObject.GetComponent <Attack>().UnitDamage) + 1; if (ArmyUnits [i].CurrentUnits.Count < ArmyUnits [i].AmountNeeded) { int j = 0; //We will check if the units we're searching for are already spawned. while (j < FactionMgr.Army.Count && ArmyUnits [i].CurrentUnits.Count < ArmyUnits [i].AmountNeeded) { //When the needed unit is found, add it to the list: if (FactionMgr.Army [j] != null && ArmyUnits [i].Prefab != null) { if (ArmyUnits [i].CurrentUnits.Contains(FactionMgr.Army [j].UnitMgr) == false) { //making sure the army unit has the code that we're looking for: if (FactionMgr.Army [j].UnitMgr.Code == ArmyUnits [i].Prefab.Code) { //add it to tAAhe list. ArmyUnits [i].CurrentUnits.Add(FactionMgr.Army [j].UnitMgr); FactionMgr.Army [j].ArmyUnitID = i; //Make all enemy units attack on range: FactionMgr.Army [j].AttackInRange = true; if (ArmyUnits [i].ProgressAmount > 0) { ArmyUnits [i].ProgressAmount--; } } } } j++; } int ID = -1; //This will hold the task ID that produces the required army type, if found. //If we still haven't found enough units then we'll simply look for buildings that can produce them. if (ArmyUnits [i].CurrentUnits.Count + ArmyUnits [i].ProgressAmount < ArmyUnits [i].AmountNeeded) { int n = 0; while (n < ArmyUnits [i].Prefabs [ArmyUnits [i].PrefabID].SpawnedBuildings.Count && ArmyUnits [i].CurrentUnits.Count + ArmyUnits [i].ProgressAmount < ArmyUnits [i].AmountNeeded) { Building Building = ArmyUnits [i].Prefabs [ArmyUnits [i].PrefabID].SpawnedBuildings [n]; //Make sure that the current building has enough health and is completely built. //Check if the building can produce army units and that it still have avilable space for a new task and that the building is not upgrading. if (Building.ArmyUnits.Count > 0 && Building.TasksQueue.Count < Building.MaxTasks && Building.BuildingUpgrading == false) { int Counter = 0; while (ID == -1 && Counter < Building.ArmyUnits.Count) { //if this is the unit we're looking for. if (Building.FactionID == FactionID && Building.BuildingTasksList[Building.ArmyUnits[Counter]].UnitPrefab.Code == ArmyUnits[i].Prefab.Code) { //make sure that the unit hasn't reached its limit: if (FactionMgr.HasReachedLimit(Building.BuildingTasksList[Building.ArmyUnits[Counter]].UnitPrefab.Code) == false) { ID = Building.ArmyUnits[Counter]; } } Counter++; } if (ID >= 0) { if (Building.IsBuilt == true && Building.Health >= Building.MinTaskHealth) { //Check if we have enough resources to launch this task: while (GameMgr.ResourceMgr.CheckResources(Building.BuildingTasksList[ID].RequiredResources, FactionID, GameMgr.ResourceMgr.FactionResourcesInfo[FactionID].NeedRatio) == true && ArmyUnits [i].CurrentUnits.Count + ArmyUnits [i].ProgressAmount < ArmyUnits [i].AmountNeeded && ArmyUnits [i].ProgressAmount < (ArmyUnits [i].AmountNeeded - ArmyUnits [i].CurrentUnits.Count) && GameMgr.Factions [FactionID].CurrentPopulation < GameMgr.Factions [FactionID].MaxPopulation) { //Add the new task to the building's task queue GameMgr.TaskMgr.LaunchTask(Building, ID, -1, TaskManager.TaskTypes.CreateUnit); //Start waiting for the new unit to be created: ArmyUnits [i].ProgressAmount++; } if (GameMgr.ResourceMgr.CheckResources(Building.BuildingTasksList[ID].RequiredResources, FactionID, GameMgr.ResourceMgr.FactionResourcesInfo[FactionID].NeedRatio) == false) // No resources are available for this task: { int RequiredAmount = ArmyUnits [i].AmountNeeded - (ArmyUnits [i].CurrentUnits.Count + ArmyUnits [i].ProgressAmount); for (int x = 0; x < Building.BuildingTasksList[ID].RequiredResources.Length; x++) { //ask the resource manager for resources to launch the unit creation task. if (ArmyUnits [i].AskedForTaskRscr == true) { RequiredAmount = 0; } FactionMgr.ResourceMgr.LookForResources(Building.BuildingTasksList [ID].RequiredResources [x].Name, Building.BuildingTasksList [ID].RequiredResources [x].Amount * RequiredAmount); } //Ask for resources: ArmyUnits[i].AskedForTaskRscr = true; } //If we don't have any more space for new units: if (GameMgr.Factions [FactionID].CurrentPopulation >= GameMgr.Factions [FactionID].MaxPopulation) { FactionMgr.BuildingMgr.AttemptToAddBuilding(FactionMgr.BuildingMgr.PopulationBuilding, false, null); } } else { //Call for builders as the building hasn't been built yet. if (Building.Placed == true) { FactionMgr.BuildingMgr.ConstructBuilding(Building); } } } } else { //... } n++; } } //No building to create if (ID == -1 && ArmyUnits [i].CurrentUnits.Count + ArmyUnits [i].ProgressAmount < ArmyUnits [i].AmountNeeded) { //We need to construct a buildign that can create the required army unit: //look for the suitable building to build this unit if we don't already have it saved: if (ArmyUnits [i].SourceBuilding == null) { ArmyUnits [i].SourceBuilding = FactionMgr.BuildingMgr.GetBuildingByUnit(ArmyUnits [i].Prefab); } FactionMgr.BuildingMgr.AttemptToAddBuilding(ArmyUnits [i].SourceBuilding, false, null); } } } //Make sure it's not the peace time and that the AI player is not under attack: if (GameMgr.PeaceTime == 0.0f && Defending == false && Attacking == false && UnderAttack == false) { //Attempt to launch an attack: if (CanAttack == true && TargetFaction != null) { //If the team can actually launch an attack and they have enough army power: if (FactionMgr.ArmyPower / TargetFaction.ArmyPower >= ArmyPowerRatio && FactionMgr.ArmyPower >= MinArmyPower) { Attacking = true; LaunchAttack(); } } } } } if (Attacking == true) //If the faction is currently in war: { if (TargetFaction != null) { if (AttackTimer > 0) { //Handling the attack timer. AttackTimer -= Time.deltaTime; if (TargetBuilding == null) { AttackTimer = -1.0f; } else if (TargetingBuilders == false && TargetBuilding.WorkerMgr.CurrentWorkers > 0) { SendUnitsToTargetBuilding(); } } if (AttackTimer < 0) { //Each time the attack timer is done, the faction gives order to its attacking units: //First check if we have reached the surrender army power: if (AttackingArmyPower <= SurrenderArmyPower) { //Cancel the attack. StopAttack(); } else { if (TargetBuilding == null) //If the target building is not valid //Search for one: { SetTargetBuilding(); } if (TargetBuilding != null) { //If we've found a target building, command the attacking units. SendUnitsToTargetBuilding(); } AttackTimer = Random.Range(AttackTimeRange.x, AttackTimeRange.y); //Reload the attack timer. } } } else { StopAttack(); } } }
/// <summary> /// Determines whether the regulator component has reached the maximum allowed amount for active instances or not. /// </summary> /// <returns>True if the maximum amount of instances is reached, otherwise false.</returns> public bool HasReachedMaxAmount() { return(Count >= MaxAmount || factionMgr.HasReachedLimit(Code, Category) || pendingAmount >= MaxPendingAmount); }
void Update() { if (Units.Length > 0 && AllCreated == false) { int ReadyUnits = 0; //amount of unit type that are created with the correct amounts. for (int i = 0; i < Units.Length; i++) //loop through the units to create { if (Units [i].StartCreatingAfter > 0) { Units [i].StartCreatingAfter -= Time.deltaTime; //the timer before starting to create any unit } else { //spawn timer: if (Units [i].SpawnTimer > 0) { Units [i].SpawnTimer -= Time.deltaTime; } else { Units [i].AllCreated = true; //initially we will set this to true then check: ReadyUnits++; //restart the timer: Units[i].SpawnTimer = Random.Range(Units[i].SpawnReloadRange.x, Units[i].SpawnReloadRange.y); //calculate the amount to create from this unit: Units [i].AmountNeeded = Mathf.RoundToInt(GameMgr.Factions [FactionID].MaxPopulation * Random.Range(Units [i].PopulationRatio.x, Units [i].PopulationRatio.y)); if (Units [i].AmountNeeded > Units [i].MaxAmount) //if the current goal is greater than the max allowed amount. { Units [i].AmountNeeded = Units [i].MaxAmount; //set it to the limit } if (Units [i].CurrentUnits.Count < Units [i].AmountNeeded) //still haven't reached our goal? { Units [i].AllCreated = false; ReadyUnits--; } if (Units [i].AllCreated == false) //still need to reach our goal: //check if the unit hasn't reached its limit: { if (FactionMgr.HasReachedLimit(Units[i].Prefab.Code) == false) { if ((GameMgr.Factions[FactionID].MaxPopulation - GameMgr.Factions[FactionID].CurrentPopulation) > 0) { //if we still have space in the population slots: //search for a building to create this unit: int AmountLeft = Units[i].AmountNeeded - Units[i].CurrentUnits.Count - Units[i].ProgressAmount; //Amount of units that we still need to create int j = 0; while (AmountLeft > 0 && j < Units[i].SourceBuildings.Count) { //go through the buildings that can create this unit: while (AmountLeft > 0 && Units[i].SourceBuildings[j].TasksQueue.Count < Units[i].SourceBuildings[j].MaxTasks) { //if this still has space for one more task and we still haven't finished creating all units //check if we have enough resources: if (GameMgr.ResourceMgr.CheckResources(Units[i].SourceBuildings[j].BuildingTasksList[Units[i].TasksIDs[j]].RequiredResources, FactionID, FactionMgr.ResourceMgr.ResourceNeedRatio)) { //create a unit GameMgr.TaskMgr.LaunchTask(Units[i].SourceBuildings[j], Units[i].TasksIDs[j], i, TaskManager.TaskTypes.CreateUnit); AmountLeft--; Units[i].ProgressAmount++; //mark the new unit creation as pending } else { AmountLeft = 0; } } j++; } } else { //not population } } else { //limit reached } } } } } if (ReadyUnits == Units.Length) { AllCreated = true; //all units have been created. } } }
//determine if we have reached the maximum amount or not on this regulator or if the item limits have been reached public bool HasReachedMaxAmount() { return(amount >= maxAmount || factionMgr.HasReachedLimit(code) || pendingAmount >= maxPendingAmount); }
//---------------------------------------------------------------------------------------------------------------------------------------------------------------- //Called each time we try to add a building to construct: public void AttemptToAddBuilding(Building Building, bool AllowMultiple, GameObject BuildAround) { /* * Building: The building prefab that we want to add. * Allow Multiple: When true, we need to wait to complete placing the same building before placing another. * Build Around: Sometimes we don't need to build directly around a city center but around a specific position (such as a resource). * * */ //if the building's limit has been reached, don't place building: if (FactionMgr.HasReachedLimit(Building.Code)) { return; //don't place building } //check building placement priorities: if (FactionMgr.ResourceMgr.MustHaveDropOff == true) { //if the faction must have a drop off building if (FactionMgr.DropOffBuildings.Count == 0) { //and there's still no drop off buildings //if the building that the faction is attempting to place is not a drop off building if (Building.ResourceDropOff == false) { return; //don't place it. } } } //if the same building is already getting placed and we can't have multiple buildings of the same type at once. if (IsBeingBuilt(Building) == true && AllowMultiple == false) { return; } //Check if the faction have enough resources to build this building: if (ResourceMgr.CheckResources(Building.BuildingResources, FactionID, ResourceMgr.FactionResourcesInfo[FactionID].NeedRatio) == true) { //Search a building center to construct building inside its borders: int CenterID = -1; if (BuildAround == null) { //if we can build anywhere. CenterID = GetAvailableCenterID(Building.Code); //search for an available center to build around. } else { //else get the nearest center to our build around point CenterID = FactionMgr.BuildingCenters.IndexOf(FactionMgr.BuildingMgr.GetNearestBuilding(BuildAround.transform.position, FactionMgr.BuildingMgr.BuildingCenter.Code)); } //If we found a suitable building center: if (CenterID != -1) { //If the building must be placed around a resource and it still hasn't one: if (Building.PlaceNearResource == true && BuildAround == null) { Resource BuildAroundResource = GetBorderResource(Building.ResourceName, FactionMgr.BuildingCenters[CenterID].BorderMgr); if (BuildAroundResource != null) //if a resource to build around is found { BuildAround = BuildAroundResource.gameObject; } else { return; //No resource to build around is found, abort building placement } } //run this method to add a new building to place: AddBuildingToList(Building, CenterID, BuildAround); } else { //if we can't find a building center AttemptToAddBuilding(BuildingCenter, false, null); //attempt to create a new building center. } } else { //no available resources //if this is a population building: if (Building == PopulationBuilding) { //if we still can ask for population building resources: if (AskForPopulationResources == true) { AskForPopulationResources = false; } else { return; //if not stop here. } } //ask for resources: AskForBuildingResources(Building); } }