public static bool IsRegionValidForExploration(global::Empire empire, int regionIndex)
{
Diagnostics.Assert(AIScheduler.Services != null);
IWorldAtlasAIHelper service = AIScheduler.Services.GetService <IWorldAtlasAIHelper>();
Diagnostics.Assert(service != null);
if (empire != null)
{
DepartmentOfForeignAffairs agency = empire.GetAgency <DepartmentOfForeignAffairs>();
if (agency != null && !agency.CanMoveOn(regionIndex, false))
{
return(false);
}
}
DepartmentOfTheInterior agency2 = empire.GetAgency <DepartmentOfTheInterior>();
if (agency2 != null)
{
bool flag = false;
for (int i = 0; i < agency2.Cities.Count; i++)
{
if (agency2.Cities[i].Region.ContinentID == service.Regions[regionIndex].ContinentID)
{
flag = true;
break;
}
}
if (agency2.Cities.Count == 0)
{
flag = true;
}
if (!flag)
{
DepartmentOfCreepingNodes agency3 = empire.GetAgency <DepartmentOfCreepingNodes>();
if (agency3 != null)
{
using (List <CreepingNode> .Enumerator enumerator = agency3.Nodes.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (!enumerator.Current.IsUnderConstruction && AILayer_Exploration.IsTravelAllowedInNode(empire, enumerator.Current) && enumerator.Current.Region.ContinentID == service.Regions[regionIndex].ContinentID)
{
flag = true;
break;
}
}
}
}
}
if (!flag)
{
return(false);
}
}
return(!service.IsRegionExplored(empire.Index, regionIndex, 0.95f));
}
private float ComputeHeuristicBaseValue()
{
Diagnostics.Assert(base.AttitudeScore != null);
Diagnostics.Assert(base.DiplomaticRelation != null && base.DiplomaticRelation.State != null);
if (base.DiplomaticRelation.State.Name == DiplomaticRelationState.Names.Unknown)
{
return(0f);
}
float num = base.GetValueFromAttitude();
IWorldAtlasAIHelper service = AIScheduler.Services.GetService <IWorldAtlasAIHelper>();
float worldExplorationRatio = service.GetWorldExplorationRatio(base.Empire);
float worldExplorationRatio2 = service.GetWorldExplorationRatio(base.EmpireWhichReceives);
if (Mathf.Abs(worldExplorationRatio - worldExplorationRatio2) < 0.1f)
{
return(0f);
}
float value = Mathf.Max(0.1f, worldExplorationRatio2) / Mathf.Max(0.1f, worldExplorationRatio) - 1f;
num += this.explorationLeadBonus * Mathf.Clamp(value, -1f, 1f);
num *= this.multiplier;
return(num / 100f);
}
private void CalculateRegroupPositionForWaitToAttack()
{
if (this.RegionTarget == null || this.RegionTarget.City == null || this.RegionTarget.City.Empire == base.Commander.Empire || !base.AIDataArmyGUID.IsValid)
{
return;
}
AIData_Army aidata = this.aiDataRepository.GetAIData <AIData_Army>(base.AIDataArmyGUID);
if (aidata == null)
{
return;
}
PathfindingContext pathfindingContext = aidata.Army.GenerateContext();
pathfindingContext.Greedy = true;
PathfindingResult pathfindingResult;
if (this.targetFrontierPosition.IsValid)
{
Army armyAtPosition = this.worldPositionningService.GetArmyAtPosition(this.targetFrontierPosition);
if (armyAtPosition == null)
{
pathfindingResult = this.pathfindingService.FindPath(pathfindingContext, aidata.Army.WorldPosition, this.targetFrontierPosition, PathfindingManager.RequestMode.Default, null, PathfindingFlags.IgnoreFogOfWar, null);
if (pathfindingResult != null)
{
return;
}
}
else if (armyAtPosition.GUID == base.AIDataArmyGUID)
{
return;
}
}
if (this.worldPositionningService.GetRegion(aidata.Army.WorldPosition) == this.RegionTarget)
{
this.targetFrontierPosition = aidata.Army.WorldPosition;
return;
}
IWorldAtlasAIHelper service = AIScheduler.Services.GetService <IWorldAtlasAIHelper>();
List <Region> list = new List <Region>();
service.ComputeNeighbourRegions(this.RegionTarget, ref list);
list.RemoveAll((Region match) => match.Owner != base.Commander.Empire || !match.IsLand);
int num = int.MaxValue;
bool flag = false;
foreach (Region region in list)
{
foreach (WorldPosition worldPosition in region.WorldPositions)
{
if (!this.worldPositionningService.IsWaterTile(worldPosition) && this.pathfindingService.IsTileStopableAndPassable(worldPosition, aidata.Army, PathfindingFlags.IgnoreFogOfWar, null))
{
int distance = this.worldPositionningService.GetDistance(worldPosition, this.RegionTarget.City.WorldPosition);
if (distance < num)
{
num = distance;
this.targetFrontierPosition = worldPosition;
flag = true;
}
}
}
}
if (flag)
{
return;
}
pathfindingResult = this.pathfindingService.FindPath(pathfindingContext, aidata.Army.WorldPosition, this.RegionTarget.City.WorldPosition, PathfindingManager.RequestMode.Default, null, PathfindingFlags.IgnoreDiplomacy | PathfindingFlags.IgnoreFogOfWar, null);
if (pathfindingResult == null)
{
this.targetFrontierPosition = aidata.Army.WorldPosition;
return;
}
WorldPosition worldPosition2 = aidata.Army.WorldPosition;
foreach (WorldPosition worldPosition3 in pathfindingResult.GetCompletePath())
{
if (!(worldPosition3 == pathfindingResult.Start) && !(worldPosition3 == pathfindingResult.Goal) && this.pathfindingService.IsTileStopableAndPassable(worldPosition3, aidata.Army, PathfindingFlags.IgnoreFogOfWar, null))
{
if ((int)this.worldPositionningService.GetRegionIndex(worldPosition3) == this.RegionTarget.Index)
{
break;
}
worldPosition2 = worldPosition3;
}
}
this.targetFrontierPosition = worldPosition2;
}
public IEnumerable <IAIParameter <InterpreterContext> > GetAIParameters(Region regionElement)
{
IDatabase <AIParameterDatatableElement> aiParameterDatabase = Databases.GetDatabase <AIParameterDatatableElement>(false);
Diagnostics.Assert(aiParameterDatabase != null);
IWorldAtlasAIHelper worldAtlasHelper = AIScheduler.Services.GetService <IWorldAtlasAIHelper>();
Diagnostics.Assert(worldAtlasHelper != null);
StaticString biomeName = worldAtlasHelper.GetRegionBiome(regionElement);
Diagnostics.Assert(!StaticString.IsNullOrEmpty(biomeName));
IAIParameter <InterpreterContext>[] aiParameters;
if (!this.aiParametersByBiomeName.TryGetValue(biomeName, out aiParameters))
{
AIParameterDatatableElement aiParameterDatatableElement;
if (aiParameterDatabase.TryGetValue(biomeName, out aiParameterDatatableElement))
{
Diagnostics.Assert(aiParameterDatatableElement != null);
if (aiParameterDatatableElement.AIParameters != null)
{
aiParameters = 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);
aiParameters[index] = parameterDefinition.Instantiate();
}
}
else
{
Diagnostics.LogWarning("Biome {0} has no AI Parameters.", new object[]
{
biomeName
});
}
}
else
{
Diagnostics.LogWarning("Biome {0} has no AI Parameters.", new object[]
{
biomeName
});
}
this.aiParametersByBiomeName.Add(biomeName, aiParameters);
}
if (aiParameters != null)
{
for (int index2 = 0; index2 < aiParameters.Length; index2++)
{
yield return(aiParameters[index2]);
}
}
if (this.regionEvaluationAiParameters == null)
{
AIParameterDatatableElement aiParameterDatatableElement2;
if (aiParameterDatabase.TryGetValue("RegionEvaluation", out aiParameterDatatableElement2))
{
if (aiParameterDatatableElement2.AIParameters != null)
{
this.regionEvaluationAiParameters = new IAIParameter <InterpreterContext> [aiParameterDatatableElement2.AIParameters.Length];
for (int index3 = 0; index3 < aiParameterDatatableElement2.AIParameters.Length; index3++)
{
AIParameterDatatableElement.AIParameter parameterDefinition2 = aiParameterDatatableElement2.AIParameters[index3];
Diagnostics.Assert(parameterDefinition2 != null);
this.regionEvaluationAiParameters[index3] = parameterDefinition2.Instantiate();
}
}
else
{
Diagnostics.LogWarning("RegionEvaluation has no AI Parameters.");
}
}
else
{
Diagnostics.LogWarning("RegionEvaluation has no AI Parameters.");
}
}
for (int index4 = 0; index4 < this.regionEvaluationAiParameters.Length; index4++)
{
yield return(this.regionEvaluationAiParameters[index4]);
}
yield break;
}
