private float ComputeHarassingFitness(GameEntityGUID cityGuid, WorldPosition colossusArmyPosition) { float num = 0f; bool flag = true; AIData_City aidata_City; if (this.aiDataRepositoryHelper.TryGetAIData <AIData_City>(cityGuid, out aidata_City)) { if (!this.departmentOfForeignAffairs.CanBesiegeCity(aidata_City.City)) { flag = false; } if (flag) { AIRegionData regionData = this.worldAtlasAIHelper.GetRegionData(base.AIEntity.Empire.Index, aidata_City.City.Region.Index); if (regionData != null) { num = regionData.HarassingScore; if (colossusArmyPosition.IsValid) { float num2 = (float)this.worldPositioningService.GetDistance(aidata_City.City.WorldPosition, colossusArmyPosition); float num3 = Mathf.Clamp01(num2 / this.averageMaximumMovementPoint / 5f); num = AILayer.Boost(num, num3 * -0.5f); } } } } return(num); }
private float ComputeDestroyInterest(CreepingNode target, AIEntity_Empire entityEmpire, Army army) { float normalizedScore = 0.1f; AILayer_Diplomacy layer = entityEmpire.GetLayer <AILayer_Diplomacy>(); if (layer != null) { float num = layer.GetWantWarScore(target.Empire); float num2 = layer.GetAllyScore(target.Empire); if (num2 > 0.5f || num < 0.25f || layer.GetPeaceWish(target.Empire.Index)) { return(-1f); } num = (num - 0.25f) / 0.75f; num2 = (num2 - 0.5f) / 0.5f; float boostFactor = 0.2f * (num - num2); normalizedScore = AILayer.Boost(normalizedScore, boostFactor); } float propertyValue = army.Empire.GetPropertyValue(SimulationProperties.MilitaryPower); float num3 = target.Empire.GetPropertyValue(SimulationProperties.MilitaryPower); if (num3 == 0f) { num3 = 1f; } float num4 = propertyValue / num3; if (num4 < 1f) { return(-1f); } float boostFactor2 = Mathf.Clamp01(num4 / 2f) * 0.2f; return(AILayer.Boost(normalizedScore, boostFactor2)); }
public static float ComputeBoost(float normalizedScoreA, float normalizedScoreB) { if (normalizedScoreA < 0f || normalizedScoreA > 1f) { AILayer.LogWarning("[SCORING] clamping invalid scoreA of {0}", new object[] { normalizedScoreA }); normalizedScoreA = Math.Max(1f, Math.Min(0f, normalizedScoreA)); } if (normalizedScoreB < 0f || normalizedScoreB > 1f) { AILayer.LogWarning("[SCORING] clamping invalid scoreB of {0}", new object[] { normalizedScoreB }); normalizedScoreB = Math.Max(1f, Math.Min(0f, normalizedScoreB)); } if (normalizedScoreA == 0f) { return(normalizedScoreB); } if (normalizedScoreA == 1f) { return(-(normalizedScoreA - normalizedScoreB)); } if (normalizedScoreA <= normalizedScoreB) { return((normalizedScoreB - normalizedScoreA) / (1f - normalizedScoreA)); } return(-(normalizedScoreA - normalizedScoreB) / normalizedScoreA); }
public static float GetCampDefenseLocalPriority(Camp camp, float unitRatioBoost, int simulatedUnitsCount = -1) { if (camp == null) { return(0f); } DepartmentOfForeignAffairs agency = camp.Empire.GetAgency <DepartmentOfForeignAffairs>(); if (agency.IsInWarWithSomeone() && AILayer_Military.AreaIsSave(camp.WorldPosition, 12, agency, false)) { return(0f); } if (camp.City.BesiegingEmpire != null) { return(0f); } float normalizedScore = 0f; float num; if (simulatedUnitsCount >= 0) { num = (float)simulatedUnitsCount / (float)camp.MaximumUnitSlot; } else { num = (float)camp.StandardUnits.Count / (float)camp.MaximumUnitSlot; } float normalizedScore2 = AILayer.Boost(normalizedScore, (1f - num) * unitRatioBoost); float developmentRatioOfCamp = AIScheduler.Services.GetService <IEntityInfoAIHelper>().GetDevelopmentRatioOfCamp(camp); return(AILayer.Boost(normalizedScore2, (1f - developmentRatioOfCamp) * AILayer_Military.cityDevRatioBoost)); }
private void ProcessUnitProduction(UnitDesign unitDesign) { int num = this.availableMilitaryBody.IndexOf(unitDesign.UnitBodyDefinition.Name); if (num >= 0) { this.overralUnitCount += 1f; List <float> list2; List <float> list = list2 = this.bodyCount; int index2; int index = index2 = num; float num2 = list2[index2]; list[index] = num2 + 1f; } if (unitDesign.Context != null && unitDesign.Context.SimulationObject != null) { this.needMilitaryPower -= unitDesign.Context.GetPropertyValue(SimulationProperties.MilitaryPower); } else { this.needMilitaryPower -= this.averageMilitaryPower; } this.maxNewUnits -= 1f; this.currentProductionPriority = AILayer.Boost(this.currentProductionPriority, -0.1f); }
private void VoteForSeasonEffect_TicketRaised(object sender, TicketRaisedEventArgs e) { OrderVoteForSeasonEffect orderVoteForSeasonEffect = e.Order as OrderVoteForSeasonEffect; Diagnostics.Assert(orderVoteForSeasonEffect != null); List <EvaluableMessage_VoteForSeasonEffect> list = new List <EvaluableMessage_VoteForSeasonEffect>(base.AIEntity.AIPlayer.Blackboard.GetMessages <EvaluableMessage_VoteForSeasonEffect>(BlackboardLayerID.Empire, (EvaluableMessage_VoteForSeasonEffect message) => message.SeasonEffectReference == orderVoteForSeasonEffect.SeasonEffectName)); if (list.Count == 0) { return; } if (list.Count > 1) { AILayer.LogWarning("There should not be several PopulationBuyout EvaluableMessages for the same city"); } EvaluableMessage_VoteForSeasonEffect evaluableMessage_VoteForSeasonEffect = list[0]; if (e.Result == PostOrderResponse.Processed) { evaluableMessage_VoteForSeasonEffect.SetObtained(); } else { evaluableMessage_VoteForSeasonEffect.SetFailedToObtain(); } }
private float GenerateMessagePriorityForCadavers() { if (this.aiEntityCity.City.IsInfected) { return(0f); } if (this.departmentOfPlanificationAndDevelopment.CountBoosters((BoosterDefinition match) => match.Name == "BoosterCadavers") > 5 * this.departmentOfTheInterior.NonInfectedCities.Count) { return(1f); } float num = this.GenerateMessagePriorityForFood(); bool flag = Services.GetService <IDownloadableContentService>().IsShared(DownloadableContent19.ReadOnlyName); bool value = Amplitude.Unity.Framework.Application.Registry.GetValue <bool>(SeasonManager.Registers.PlayWithMadSeason); if (!flag || !value) { return(num); } float num2 = base.AIEntity.AIPlayer.GetEntity <AIEntity_Empire>().GetLayer <AILayer_Military>().GlobalPriority; if (SimulationGlobal.GlobalTagsContains(Season.ReadOnlyHeatWave)) { return(AILayer.Boost(Math.Max(0f, num), 0.9f)); } if (num2 > 0f) { return(AILayer.Boost(num, -0.2f)); } return(num); }
public void UpdateScore() { this.UpdateLists(); this.DebugContext = null; if (Amplitude.Unity.Framework.Application.Preferences.EnableModdingTools) { this.DebugContext = new AIHeuristicAnalyser.Context(); string empty = string.Empty; this.PrintRegions(ref empty); } float num = 0f; float num2 = 0f; for (int i = 0; i < this.Orbs.Count; i++) { num2 += this.Orbs[i].CurrentOrbCount; } float num3 = 0.05f; float num4 = Mathf.Min(1f, num3 * num2); float num5 = 0.5f; num4 *= num5; num = AILayer.Boost(num, num4); float num6 = (float)this.Ruins.Count; float num7 = 0.1f; float num8 = Mathf.Min(1f, num7 * num6); float num9 = 0.3f; num8 *= num9; num = AILayer.Boost(num, num8); this.MantaZoneScore = num; }
private float DecisionScoreTransferFunctionDelegate(ConstructibleElement aiEvaluableElement, float score) { BoosterDefinition constructibleElement = aiEvaluableElement as BoosterDefinition; ConstructionResourceStock[] array; base.DepartmentOfTheTreasury.GetInstantConstructionResourceCostForBuyout(base.Empire, constructibleElement, out array); float num = 0f; for (int i = 0; i < array.Length; i++) { float num2 = 0f; if (!base.DepartmentOfTheTreasury.TryGetResourceStockValue(base.Empire, array[i].PropertyName, out num2, false) || num2 == 0f) { num = 1f; break; } float num3 = array[i].Stock / num2; if (num3 > num) { num = num3; } } score = AILayer.Boost(score, this.costFactorFromRegistry * (1f - num)); return(score); }
private void ExecutePopulationBuyout() { if (!DepartmentOfTheInterior.CanBuyoutPopulation(this.aiEntityCity.City)) { return; } List <EvaluableMessage_PopulationBuyout> list = new List <EvaluableMessage_PopulationBuyout>(this.aiEntityCity.Blackboard.GetMessages <EvaluableMessage_PopulationBuyout>(BlackboardLayerID.City, (EvaluableMessage_PopulationBuyout message) => message.CityGuid == this.aiEntityCity.City.GUID)); if (list.Count == 0) { return; } if (list.Count > 1) { AILayer.LogWarning("There should not be several PopulationBuyout EvaluableMessages for the same city ({0})", new object[] { this.aiEntityCity.City }); } EvaluableMessage_PopulationBuyout evaluableMessage_PopulationBuyout = list[0]; Diagnostics.Log("ELCP {0}/{1} ExecutePopulationBuyout {2}", new object[] { this.Empire, this.aiEntityCity.City, evaluableMessage_PopulationBuyout.EvaluationState }); if (evaluableMessage_PopulationBuyout.EvaluationState == EvaluableMessage.EvaluableMessageState.Validate) { AIScheduler.Services.GetService <ISynchronousJobRepositoryAIHelper>().RegisterSynchronousJob(new SynchronousJob(this.SynchronousJob_BuyoutPopulation)); } }
private void RefreshArmySupportMission(ColossusMission currentColossusMission, Unit colossus) { if (currentColossusMission.Objective != ColossusMission.MissionObjective.ArmySupport) { return; } WorldPosition colossusArmyPosition = WorldPosition.Invalid; if (colossus.Garrison is IWorldPositionable) { colossusArmyPosition = (colossus.Garrison as IWorldPositionable).WorldPosition; } float fitnessForMission = this.GetFitnessForMission(colossus, ColossusMission.MissionObjective.ArmySupport); float num = this.ComputeArmyFitness(currentColossusMission.TargetGuid, colossusArmyPosition); float num2 = num * fitnessForMission; ColossusMission colossusMissionPerTarget = this.GetColossusMissionPerTarget(currentColossusMission.TargetGuid); if (colossusMissionPerTarget != null && colossusMissionPerTarget.Objective == currentColossusMission.Objective && colossusMissionPerTarget.ColossusGuid != colossus.GUID && num2 < colossusMissionPerTarget.Fitness) { num *= 0.5f; } num = AILayer.Boost(num, 0.1f); currentColossusMission.EntityFitness = num; currentColossusMission.ColossusMissionFitness = fitnessForMission; }
protected float ClampedBoost(float score, float boostFactor) { if (score < 0f) { return(-AILayer.Boost(Mathf.Clamp01(-score), Mathf.Clamp(-boostFactor, -0.95f, 0.95f))); } return(AILayer.Boost(Mathf.Clamp01(score), Mathf.Clamp(boostFactor, -0.95f, 0.95f))); }
private float ComputePillageInterest(PointOfInterest target, AIEntity_Empire entityEmpire, Army army) { float normalizedScore = 0.1f; AILayer_Diplomacy layer = entityEmpire.GetLayer <AILayer_Diplomacy>(); if (layer != null) { if (layer.GetPeaceWish(target.Region.City.Empire.Index)) { return(-1f); } float num = layer.GetWantWarScore(target.Region.City.Empire); float num2 = layer.GetAllyScore(target.Region.City.Empire); if (num2 > 0.5f || num < 0.25f) { return(-1f); } num = (num - 0.25f) / 0.75f; num2 = (num2 - 0.5f) / 0.5f; float boostFactor = 0.2f * (num - num2); normalizedScore = AILayer.Boost(normalizedScore, boostFactor); } float propertyValue = army.Empire.GetPropertyValue(SimulationProperties.MilitaryPower); float num3 = target.Region.City.Empire.GetPropertyValue(SimulationProperties.MilitaryPower); if (num3 == 0f) { num3 = 1f; } float num4 = propertyValue / num3; if (num4 < 1f) { return(-1f); } float boostFactor2 = Mathf.Clamp01(num4 / 2f) * 0.2f; normalizedScore = AILayer.Boost(normalizedScore, boostFactor2); string a = target.Type; float boostFactor3; if (a == "ResourceDeposit") { boostFactor3 = 0.2f; } else if (a == "WatchTower") { boostFactor3 = 0.2f; } else { boostFactor3 = 0.2f; } normalizedScore = AILayer.Boost(normalizedScore, boostFactor3); return(AILayer.Boost(normalizedScore, this.ComputeInfluence(army, target) * 0.5f)); }
public static float Boost(float normalizedScore, float boostFactor) { if (boostFactor < -1f || boostFactor > 1f) { AILayer.LogWarning("[SCORING] clamping invalid booster of {0}", new object[] { boostFactor }); boostFactor = Math.Min(1f, Math.Max(-1f, boostFactor)); } if (boostFactor < 0f) { if (normalizedScore < 0f) { AILayer.LogWarning("[SCORING] score of {0} boosted by {1}. returning 0", new object[] { normalizedScore, boostFactor }); return(0f); } if (normalizedScore > 1f) { AILayer.LogWarning("[SCORING] score of {0} boosted by {1}. returning 0", new object[] { normalizedScore, boostFactor, 1f - boostFactor }); return(1f - Math.Abs(boostFactor)); } return(normalizedScore - normalizedScore * -boostFactor); } else { if (normalizedScore < 0f) { AILayer.LogWarning("[SCORING] score of {0} boosted by {1}. returning {1}", new object[] { normalizedScore, boostFactor }); return(boostFactor); } if (normalizedScore > 1f) { AILayer.LogWarning("[SCORING] score of {0} boosted by {1}. returning 1", new object[] { normalizedScore, boostFactor }); return(1f); } return(normalizedScore + boostFactor * (1f - normalizedScore)); } }
private float DecisionParameterContextModifier(SeasonEffect aievaluableelement, InterpreterContext context, StaticString outputName, AIHeuristicAnalyser.Context debugContext) { float num = 1f; float num2 = 0f; num2 = this.ComputeAttitudeBoostValue(outputName, debugContext, num2); num = AILayer.Boost(num, num2); float num3 = 1f; string regitryPath = "AI/MajorEmpire/AIEntity_Empire/AILayer_Altar/ElementEvaluatorContextMultiplier/" + outputName; num3 = this.personalityHelper.GetRegistryValue <float>(base.AIEntity.Empire, regitryPath, num3); return(num * num3); }
public IEnumerable <IAIParameter <InterpreterContext> > GetAIParameters(PillarDefinition pillarDefinition) { if (pillarDefinition == null) { throw new ArgumentNullException("pillarDefinition"); } IEnumerable <WorldEffectDefinition> enumerator = this.pillarService.GetActiveWorldEffectDefinitions(pillarDefinition.Name, base.AIEntity.Empire); if (enumerator != null) { foreach (WorldEffectDefinition worldEffectDefinition in enumerator) { IAIParameter <InterpreterContext>[] worldEffectAiParameters; if (!this.pillarEffectsAiParameters.TryGetValue(worldEffectDefinition.Name, out worldEffectAiParameters)) { IDatabase <AIParameterDatatableElement> aiParameterDatabase = Databases.GetDatabase <AIParameterDatatableElement>(false); Diagnostics.Assert(aiParameterDatabase != null); AIParameterDatatableElement aiParameterDatatableElement; if (aiParameterDatabase.TryGetValue(worldEffectDefinition.Name, out aiParameterDatatableElement)) { if (aiParameterDatatableElement.AIParameters != null) { worldEffectAiParameters = new IAIParameter <InterpreterContext> [aiParameterDatatableElement.AIParameters.Length]; for (int index = 0; index < aiParameterDatatableElement.AIParameters.Length; index++) { AIParameterDatatableElement.AIParameter parameterDefinition = aiParameterDatatableElement.AIParameters[index]; Diagnostics.Assert(parameterDefinition != null); worldEffectAiParameters[index] = parameterDefinition.Instantiate(); } } } else { AILayer.LogError("No AIParameters for WorldEffectDefinition {0}", new object[] { worldEffectDefinition.Name }); } } if (worldEffectAiParameters != null) { for (int index2 = 0; index2 < worldEffectAiParameters.Length; index2++) { yield return(worldEffectAiParameters[index2]); } } } } yield break; }
private void ComputeScoresByFIDSI() { IWorldPositionEvaluationAIHelper service = AIScheduler.Services.GetService <IWorldPositionEvaluationAIHelper>(); Diagnostics.Assert(service != null); IPersonalityAIHelper service2 = AIScheduler.Services.GetService <IPersonalityAIHelper>(); Diagnostics.Assert(service2 != null); WorldPositionScore[] worldPositionCreepingNodeImprovementScore = service.GetWorldPositionCreepingNodeImprovementScore(base.AIEntity.Empire, this.aiEntityCity.City, this.availableNodes); string regitryPath = "AI/MajorEmpire/AIEntity_Empire/AILayer_Research/ElementEvaluatorContextMultiplier/AIEmpireGrowth"; float registryValue = service2.GetRegistryValue <float>(base.AIEntity.Empire, regitryPath, 1f); regitryPath = "AI/MajorEmpire/AIEntity_Empire/AILayer_Research/ElementEvaluatorContextMultiplier/AIEmpireProduction"; float registryValue2 = service2.GetRegistryValue <float>(base.AIEntity.Empire, regitryPath, 1f); regitryPath = "AI/MajorEmpire/AIEntity_Empire/AILayer_Research/ElementEvaluatorContextMultiplier/AIEmpireResearch"; float registryValue3 = service2.GetRegistryValue <float>(base.AIEntity.Empire, regitryPath, 1f); regitryPath = "AI/MajorEmpire/AIEntity_Empire/AILayer_Research/ElementEvaluatorContextMultiplier/AIEmpireMoney"; float registryValue4 = service2.GetRegistryValue <float>(base.AIEntity.Empire, regitryPath, 1f); regitryPath = "AI/MajorEmpire/AIEntity_Empire/AILayer_Research/ElementEvaluatorContextMultiplier/AIEmpireEmpirePoint"; float registryValue5 = service2.GetRegistryValue <float>(base.AIEntity.Empire, regitryPath, 1f); List <float> list = new List <float>(); foreach (WorldPositionScore worldPositionScore in worldPositionCreepingNodeImprovementScore) { float num = worldPositionScore.Scores[0].Value * registryValue; float num2 = worldPositionScore.Scores[1].Value * registryValue2; float num3 = worldPositionScore.Scores[2].Value * registryValue3; float num4 = worldPositionScore.Scores[3].Value * registryValue4; float num5 = worldPositionScore.Scores[4].Value * registryValue5; float item = num + num2 + num3 + num4 + num5; list.Add(item); } if (list.Count > 0) { float num6 = list.Min(); float num7 = list.Max(); for (int j = 0; j < list.Count; j++) { float num8 = (num6 == num7) ? this.NormalizationFailSafeValue : Mathf.InverseLerp(num6, num7, list[j]); float score = this.availableNodes[j].score; float boostFactor = num8 * this.FIDSIWeight; this.availableNodes[j].score = AILayer.Boost(score, boostFactor); } } }
public override IEnumerator Initialize(AIEntity aiEntity) { this.aiEntityCity = (aiEntity as AIEntity_City); this.amasCityLayer = this.aiEntityCity.GetLayer <AILayer_AmasCity>(); yield return(base.Initialize(aiEntity)); base.AIEntity.RegisterPass(AIEntity.Passes.CreateLocalNeeds.ToString(), "LayerPopulation_CreateLocalNeedsPass", new AIEntity.AIAction(this.CreateLocalNeeds), this, new StaticString[] { "LayerAmasCity_CreateLocalNeedsPass", "LayerExtension_CreateLocalNeedsPass" }); base.AIEntity.RegisterPass(AIEntity.Passes.EvaluateNeeds.ToString(), "LayerPopulation_EvaluateNeedsPass", new AIEntity.AIAction(this.EvaluateNeeds), this, new StaticString[] { "LayerExtension_EvaluateNeedsPass" }); base.AIEntity.RegisterPass(AIEntity.Passes.ExecuteNeeds.ToString(), "LayerPopulation_ExecuteNeedsPass", new AIEntity.AIAction(this.ExecuteNeeds), this, new StaticString[] { "LayerExtension_ExecuteNeedsPass" }); this.interpreterContext = new InterpreterContext(this.aiEntityCity.City); for (int index = 0; index < AILayer_Population.PopulationResource.Length; index++) { this.interpreterContext.Register(AILayer_Population.PopulationResource[index], 1); } this.preferedPopulationMessageID = base.AIEntity.AIPlayer.Blackboard.AddMessage(new PreferedPopulationMessage(this.aiEntityCity.City.GUID)); if (!(this.aiEntityCity.AIPlayer is AIPlayer_MajorEmpire)) { AILayer.LogError("The agent context object is not an ai player."); } DepartmentOfIndustry industry = this.Empire.GetAgency <DepartmentOfIndustry>(); DepartmentOfIndustry.ConstructibleElement[] constructibleElements = ((IConstructibleElementDatabase)industry).GetAvailableConstructibleElements(new StaticString[] { DistrictImprovementDefinition.ReadOnlyCategory }); Diagnostics.Assert(constructibleElements != null); this.districtImprovement = Array.Find <DepartmentOfIndustry.ConstructibleElement>(constructibleElements, delegate(DepartmentOfIndustry.ConstructibleElement element) { AIPlayer_MajorEmpire aiPlayer; return(element.Name == aiPlayer.AIData_Faction.DistrictImprovement); }); Diagnostics.Assert(this.districtImprovement != null); IPersonalityAIHelper personalityAIHelper = AIScheduler.Services.GetService <IPersonalityAIHelper>(); this.populationThresholdForSacrifice = personalityAIHelper.GetRegistryValue <float>(this.Empire, "AI/MajorEmpire/AIEntity_City/AILayer_Population/PopulationThresholdForSacrifice", this.populationThresholdForSacrifice); this.approvalThresholdForSacrifice = personalityAIHelper.GetRegistryValue <float>(this.Empire, "AI/MajorEmpire/AIEntity_City/AILayer_Population/ApprovalThresholdForSacrifice", this.approvalThresholdForSacrifice); yield break; }
public static float GetCityDefenseLocalPriority(City city, float unitRatioBoost, int simulatedUnitsCount = -1) { if (city == null) { return(0f); } bool flag = false; DepartmentOfForeignAffairs agency = city.Empire.GetAgency <DepartmentOfForeignAffairs>(); if (!agency.IsInWarWithSomeone() && !AIScheduler.Services.GetService <IWorldAtlasAIHelper>().IsRegionPacified(city.Empire, city.Region)) { return(0f); } if (agency.IsInWarWithSomeone() && city.BesiegingEmpire == null) { flag = !AILayer_Military.AreaIsSave(city.WorldPosition, 10, agency, false); } float num = 0f; float num2; if (simulatedUnitsCount >= 0) { num2 = (float)simulatedUnitsCount / (float)city.MaximumUnitSlot; } else { num2 = (float)city.StandardUnits.Count / (float)city.MaximumUnitSlot; } num = AILayer.Boost(num, (1f - num2) * unitRatioBoost); if (city.BesiegingEmpire != null) { float propertyValue = city.GetPropertyValue(SimulationProperties.MaximumCityDefensePoint); float num3 = city.GetPropertyValue(SimulationProperties.CityDefensePoint) / propertyValue; num3 = 1f - num3; num = AILayer.Boost(num, num3 * AILayer_Military.cityDefenseUnderSiegeBoost); } else { float developmentRatioOfCity = AIScheduler.Services.GetService <IEntityInfoAIHelper>().GetDevelopmentRatioOfCity(city); num = AILayer.Boost(num, (1f - developmentRatioOfCity) * AILayer_Military.cityDevRatioBoost); if (flag) { num = AILayer.Boost(num, 0.5f); } } return(num); }
private void ComputeCurrentHeroSpecialty(Unit hero) { for (int i = 0; i < this.LongTermSpecialtyFitness.Length; i++) { this.CurrentSpecialtyFitness[i] = this.LongTermSpecialtyFitness[i]; if (i == this.ChosenSpecialty) { this.CurrentSpecialtyFitness[i] = AILayer.Boost(this.CurrentSpecialtyFitness[i], 0.5f); } } float num = hero.GetPropertyValue(SimulationProperties.Health); float propertyValue = hero.GetPropertyValue(SimulationProperties.MaximumHealth); num /= propertyValue; num = Mathf.Clamp01(num); this.CurrentSpecialtyFitness[4] = AILayer.Boost(this.CurrentSpecialtyFitness[4], -0.2f * (1f - num)); }
private float ComputeArmyFitness(GameEntityGUID armyGuid, WorldPosition colossusArmyPosition) { float num = 0f; AIData_Army aidata_Army; if (this.aiDataRepositoryHelper.TryGetAIData <AIData_Army>(armyGuid, out aidata_Army)) { num = aidata_Army.SupportScore; if (colossusArmyPosition.IsValid && num > 0f) { float num2 = (float)this.worldPositioningService.GetDistance(aidata_Army.Army.WorldPosition, colossusArmyPosition); float num3 = Mathf.Clamp01(num2 / this.averageMaximumMovementPoint / 5f); num = AILayer.Boost(num, num3 * -0.5f); } } return(num); }
protected WorldPosition ComputeMostOverlappingPositionForRange(PillarDefinition pillarDefinition, ref float pillarScore) { int activeRange = this.pillarService.GetActiveRange(pillarDefinition.Name, base.AIEntity.Empire); District district = null; int num = 0; for (int i = 0; i < this.aiEntityCity.City.Districts.Count; i++) { District district2 = this.aiEntityCity.City.Districts[i]; if (this.pillarService.IsPositionValidForPillar(base.AIEntity.Empire, district2.WorldPosition)) { WorldArea worldArea = new WorldArea(new List <WorldPosition> { district2.WorldPosition }); for (int j = 0; j < activeRange; j++) { worldArea = worldArea.Grow(); } int num2 = 0; for (int k = 0; k < worldArea.WorldPositions.Count; k++) { if (this.worldPositioningService.GetDistrict(WorldPosition.GetValidPosition(worldArea.WorldPositions[k], this.worldPositioningService.World.WorldParameters)) != null) { num2++; } } if (num2 > num) { num = num2; district = district2; } } } if (district == null) { return(WorldPosition.Invalid); } while (--num >= 0) { pillarScore = AILayer.Boost(pillarScore, 0.05f); } return(district.WorldPosition); }
private void UpdateCitiesDefenseScore() { for (int i = 0; i < this.departmentOfTheInterior.Cities.Count; i++) { City city = this.departmentOfTheInterior.Cities[i]; float num = 0.5f; float num2 = city.GetPropertyValue(SimulationProperties.CityDefensePoint) / city.GetPropertyValue(SimulationProperties.MaximumCityDefensePoint); float num3 = 0f; num = AILayer.Boost(num, -0.2f * num2); num = AILayer.Boost(num, -0.2f * num3); int num4 = this.endTurnService.Turn - 10; int num5 = 0; AIRegionData regionData; for (int j = 0; j < city.Region.Borders.Length; j++) { regionData = this.worldAtlasAIHelper.GetRegionData(base.AIEntity.Empire.Index, city.Region.Borders[j].NeighbourRegionIndex); if (regionData != null && regionData.LostByMeAtTurn > num4) { num5++; } } regionData = this.worldAtlasAIHelper.GetRegionData(base.AIEntity.Empire.Index, city.Region.Index); float num6; float num7; if (num5 > 0) { num6 = 0.5f; num7 = 0.8f + (float)num5 * 0.05f; } else if (regionData.BorderWithEnnemy > 0) { num6 = 0.3f; num7 = 0.8f + (float)regionData.BorderWithEnnemy * 0.05f; } else { num6 = -0.2f; num7 = 1f; } num = AILayer.Boost(num, num6 * num7); AIData_City aidata = this.aiDataRepositoryHelper.GetAIData <AIData_City>(this.departmentOfTheInterior.Cities[i].GUID); aidata.DefenseScore = num; } }
private void ScoreVillageNodes() { int num = Mathf.RoundToInt(base.AIEntity.Empire.GetPropertyValue(SimulationProperties.MinorFactionSlotCount)); ReadOnlyCollection <Faction> assimilatedFactions = this.departmentOfTheInterior.AssimilatedFactions; List <float> list = new List <float>(); for (int i = 0; i < this.availableNodes.Count; i++) { if (this.availableNodes[i].pointOfInterest.Type != "Village") { list.Add(0f); } else { MinorFaction minorFaction = this.worldPositionningService.GetRegion(this.availableNodes[i].pointOfInterest.WorldPosition).MinorEmpire.Faction as MinorFaction; float num2 = (float)num; for (int j = 0; j < assimilatedFactions.Count; j++) { if (assimilatedFactions[j].Name == minorFaction.Name) { float num3 = (float)this.departmentOfTheInterior.GetNumberOfOwnedMinorFactionVillages(minorFaction, false); num2 += this.MaxNumOfFactionVillages - num3; break; } } list.Add(num2); } } if (list.Count > 0) { float num4 = list.Min(); float num5 = list.Max(); for (int k = 0; k < list.Count; k++) { if (this.availableNodes[k].pointOfInterest.Type == "Village") { float num6 = (num4 == num5) ? this.NormalizationFailSafeValue : Mathf.InverseLerp(num4, num5, list[k]); float score = this.availableNodes[k].score; float boostFactor = num6 * this.VilageWeight; this.availableNodes[k].score = AILayer.Boost(score, boostFactor); } } } }
private void ScoreRuinsNodes() { List <int> list = new List <int>(); for (int i = 0; i < this.availableNodes.Count; i++) { AILayer_CreepingNode.EvaluableCreepingNode evaluableCreepingNode = this.availableNodes[i]; if (evaluableCreepingNode.pointOfInterest.Type.Equals(ELCPUtilities.QuestLocation)) { Region region = this.worldPositionningService.GetRegion(evaluableCreepingNode.pointOfInterest.WorldPosition); PointOfInterest[] pointOfInterests = region.PointOfInterests; bool flag = false; if (list.Contains(region.Index)) { flag = true; } else { list.Add(region.Index); } if (!flag) { for (int j = 0; j < this.departmentOfCreepingNodes.Nodes.Count; j++) { if (region.Index == this.departmentOfCreepingNodes.Nodes[j].Region.Index) { flag = true; break; } } } if (flag) { evaluableCreepingNode.score = AILayer.Boost(evaluableCreepingNode.score, -0.9f); } else { evaluableCreepingNode.score = AILayer.Boost(evaluableCreepingNode.score, this.RuinsWeight); } } } }
public float ComputeFitness(float[] specialtyNeeds) { float num = 0f; int num2 = -1; for (int i = 0; i < specialtyNeeds.Length; i++) { float num3 = specialtyNeeds[i] * this.CurrentSpecialtyFitness[i]; if (num3 > num) { num = num3; num2 = i; } } if (num2 == this.ChosenSpecialty) { num = AILayer.Boost(num, this.WantMySpecialtyScore * 0.5f); } return(num); }
private SynchronousJobState SynchronousJob_AssignPopulation() { if (this.assignPopulationOrder == null) { this.assignedPopulationThisTurn = true; return(SynchronousJobState.Failure); } Diagnostics.Assert(this.assignPopulationOrder.PopulationValues != null); float num = this.assignPopulationOrder.PopulationValues.Sum(); float propertyValue = this.aiEntityCity.City.GetPropertyValue(SimulationProperties.Workers); if (Math.Abs(num - propertyValue) > 1.401298E-45f) { AILayer.Log("[AI] Number of assignated workers {0} and real workers {1} doesn't match on city {2}, add the new workers.", new object[] { num, propertyValue, this.aiEntityCity.City.GUID }); float num2 = propertyValue - num; if (num2 > 0f) { this.assignPopulationOrder.PopulationValues[0] += num2; } else { for (int i = 0; i < this.assignPopulationOrder.PopulationValues.Length; i++) { float num3 = Mathf.Max(this.assignPopulationOrder.PopulationValues[i] + num2, 0f); num2 += this.assignPopulationOrder.PopulationValues[i] - num3; this.assignPopulationOrder.PopulationValues[i] = num3; } } } Ticket ticket; this.Empire.PlayerControllers.AI.PostOrder(this.assignPopulationOrder, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OrderAssignPopulation_TicketRaised)); return(SynchronousJobState.Success); }
private void UpdateHarassingScore(global::Empire empire) { DepartmentOfTheInterior agency = empire.GetAgency <DepartmentOfTheInterior>(); if (!this.departmentOfForeignAffairs.IsEnnemy(empire)) { return; } float num = 0.5f; if (this.departmentOfForeignAffairs.IsAtWarWith(empire)) { num = 1f; } for (int i = 0; i < agency.Cities.Count; i++) { AIRegionData regionData = this.worldAtlasAIHelper.GetRegionData(base.AIEntity.Empire.Index, agency.Cities[i].Region.Index); float num2 = regionData.MinimalDistanceToMyCities / this.averageMaximumMovementPoint; float num3 = (0.5f - Mathf.Clamp01(num2 / 10f)) / 0.5f; int num4 = regionData.WatchTowerPointOfInterestCount + regionData.ResourcePointOfInterestCount; float num5 = 0f; if (num4 > 0) { num5 = (float)(regionData.BuiltWatchTower + regionData.BuiltExtractor) / (float)num4; } float num6 = 0f; float num7 = 10f; if ((float)regionData.LostByMeAtTurn > (float)this.endTurnService.Turn - num7) { num6 = 1f - (float)(this.endTurnService.Turn - regionData.LostByMeAtTurn) / num7; } float num8 = 0f; num8 = AILayer.Boost(num8, num5 * 0.2f); num8 = AILayer.Boost(num8, num6 * 0.3f); num8 = AILayer.Boost(num8, num3 * 0.5f); num8 = AILayer.Boost(num8, num * 0.5f); regionData.HarassingScore = num8; } }
private float ComputeShiftPriority(AIData_Army army, Garrison target) { float num = 0f; float num2 = 0f; this.intelligenceAiHelper.EstimateMPInBattleground(army.Army, target, ref num2, ref num); float num3 = num / num2; if (num3 > 1.5f || num3 < 0.5f) { return(0f); } float propertyValue = target.Empire.GetPropertyValue(SimulationProperties.MilitaryPower); float a = num / propertyValue; float propertyValue2 = army.Army.Empire.GetPropertyValue(SimulationProperties.MilitaryPower); float b = num2 / propertyValue2; float num4 = Mathf.Max(a, b); num4 = Mathf.Clamp01(num4); float normalizedScore = 0.3f; return(AILayer.Boost(normalizedScore, num4)); }
private void BuyOutPopulation_TicketRaised(object sender, TicketRaisedEventArgs e) { List <EvaluableMessage_PopulationBuyout> list = new List <EvaluableMessage_PopulationBuyout>(this.aiEntityCity.Blackboard.GetMessages <EvaluableMessage_PopulationBuyout>(BlackboardLayerID.City, (EvaluableMessage_PopulationBuyout message) => message.CityGuid == this.aiEntityCity.City.GUID)); if (list.Count == 0) { return; } if (list.Count > 1) { AILayer.LogWarning("There should not be several PopulationBuyout EvaluableMessages for the same city"); } EvaluableMessage_PopulationBuyout evaluableMessage_PopulationBuyout = list[0]; if (e.Result == PostOrderResponse.Processed) { evaluableMessage_PopulationBuyout.SetObtained(); } else { evaluableMessage_PopulationBuyout.SetFailedToObtain(); } }