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();
}
}
