public void RefreshTerrainDescriptors()
{
if (base.SimulationObject == null)
{
return;
}
IWorldPositionningService service = ((global::Game)Services.GetService <IGameService>().Game).GetService <IWorldPositionningService>();
DepartmentOfTheInterior.RemoveAnyTerrainTypeDescriptor(base.SimulationObject);
DepartmentOfTheInterior.RemoveAnyBiomeTypeDescriptor(base.SimulationObject);
DepartmentOfTheInterior.RemoveAnyAnomalyDescriptor(base.SimulationObject);
DepartmentOfTheInterior.RemoveAnyRiverTypeDescriptor(base.SimulationObject);
byte terrainType = service.GetTerrainType(this.WorldPosition);
StaticString terrainTypeMappingName = service.GetTerrainTypeMappingName(terrainType);
DepartmentOfTheInterior.ApplyTerrainTypeDescriptor(base.SimulationObject, terrainTypeMappingName);
byte biomeType = service.GetBiomeType(this.WorldPosition);
StaticString biomeTypeMappingName = service.GetBiomeTypeMappingName(biomeType);
DepartmentOfTheInterior.ApplyBiomeTypeDescriptor(base.SimulationObject, biomeTypeMappingName);
byte anomalyType = service.GetAnomalyType(this.WorldPosition);
StaticString anomalyTypeMappingName = service.GetAnomalyTypeMappingName(anomalyType);
DepartmentOfTheInterior.ApplyAnomalyDescriptor(base.SimulationObject, anomalyTypeMappingName);
short riverId = service.GetRiverId(this.WorldPosition);
StaticString riverTypeMappingName = service.GetRiverTypeMappingName(riverId);
DepartmentOfTheInterior.ApplyRiverTypeDescriptor(base.SimulationObject, riverTypeMappingName);
this.Refresh(false);
}
public void Initialize(global::Empire dataOwner, Continent continent, IWorldPositionningService worldPositionningService)
{
this.DataOwner = dataOwner;
this.Regions = new List <Region>();
this.EmpireWithRegion = new List <global::Empire>();
this.ColonizationPercentByEmpire = new List <float>();
this.Continent = continent;
for (int i = 0; i < continent.RegionList.Length; i++)
{
Region region = worldPositionningService.GetRegion(continent.RegionList[i]);
this.Regions.Add(region);
if (region.IsLand)
{
int landRegionCount = this.LandRegionCount;
this.LandRegionCount = landRegionCount + 1;
}
}
this.CostalRegionRatio = (float)continent.CostalRegionList.Length / (float)this.LandRegionCount;
this.Type = AILayer_Colonization.ContinentData.ContinentType.Continent;
if (this.LandRegionCount == 0)
{
this.Type = AILayer_Colonization.ContinentData.ContinentType.Water;
return;
}
if (this.CostalRegionRatio > 0.8f)
{
this.Type = AILayer_Colonization.ContinentData.ContinentType.Island;
}
}
public override IEnumerator BindServices(IServiceContainer serviceContainer)
{
yield return(base.BindServices(serviceContainer));
yield return(base.BindService <IPathfindingService>(serviceContainer, delegate(IPathfindingService service)
{
this.PathfindingService = service;
}));
yield return(base.BindService <IWorldPositionningService>(serviceContainer, delegate(IWorldPositionningService service)
{
this.WorldPositionningService = service;
}));
this.pathfindingWorldContext = new PathfindingWorldContext(null, null);
this.pathfindingWorldContext.RegionIndexList = new List <int>(2);
this.pathfindingWorldContext.RegionIndexList.Add(-1);
this.pathfindingWorldContext.RegionIndexList.Add(-1);
this.pathfindingWorldContext.RegionIndexListType = PathfindingWorldContext.RegionListType.RegionWhiteList;
this.OceanPathfindingWorldContext = new PathfindingWorldContext(null, null);
this.OceanPathfindingWorldContext.RegionIndexList = new List <int>();
this.OceanPathfindingWorldContext.RegionIndexListType = PathfindingWorldContext.RegionListType.RegionWhiteList;
serviceContainer.AddService <ICadasterService>(this);
yield break;
}
public void RemoveRegion(AIRegionData regionData)
{
for (int i = 0; i < regionData.Region.PointOfInterests.Length; i++)
{
PointOfInterest pointOfInterest = regionData.Region.PointOfInterests[i];
if (pointOfInterest.Type == "ResourceDeposit")
{
this.Resources.Remove(pointOfInterest);
}
else if (pointOfInterest.Type == ELCPUtilities.QuestLocation)
{
this.Ruins.Remove(pointOfInterest);
}
}
IWorldPositionningService service = Services.GetService <IGameService>().Game.Services.GetService <IWorldPositionningService>();
IOrbAIHelper service2 = AIScheduler.Services.GetService <IOrbAIHelper>();
for (int j = 0; j < service2.OrbSpawns.Count; j++)
{
if ((int)service.GetRegionIndex(service2.OrbSpawns[j].WorldPosition) == regionData.RegionIndex)
{
this.Orbs.Remove(service2.OrbSpawns[j]);
}
}
this.Regions.Remove(regionData);
}
private void ListNearbyCreepingNodesFiltered(Army army)
{
if (army == null)
{
throw new ArgumentNullException("army");
}
this.creepingNodes.Clear();
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
global::Game game = service.Game as global::Game;
Diagnostics.Assert(game != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
IGameEntityRepositoryService service3 = service.Game.Services.GetService <IGameEntityRepositoryService>();
Diagnostics.Assert(service3 != null);
List <StaticString> list = new List <StaticString>();
List <WorldPosition> neighbours = army.WorldPosition.GetNeighbours(game.World.WorldParameters);
for (int i = 0; i < neighbours.Count; i++)
{
PointOfInterest pointOfInterest = service2.GetPointOfInterest(neighbours[i]);
if (pointOfInterest != null && pointOfInterest.CreepingNodeGUID != GameEntityGUID.Zero)
{
CreepingNode creepingNode = null;
if (service3.TryGetValue <CreepingNode>(pointOfInterest.CreepingNodeGUID, out creepingNode) && this.CanToggleOverCreepingNode(army, creepingNode, ref list) && !this.creepingNodes.Contains(creepingNode))
{
this.creepingNodes.Add(creepingNode);
}
}
}
}
private void InitializeAIParameter(IServiceContainer serviceContainer, global::Game game)
{
this.WorldPositionningService = game.Services.GetService <IWorldPositionningService>();
this.SimulationDescriptorDatabase = Databases.GetDatabase <SimulationDescriptor>(false);
int num = 0;
for (int i = 0; i < game.Empires.Length; i++)
{
if (game.Empires[i] is MinorEmpire)
{
break;
}
num++;
}
this.scoreByWorldPositionByEmpires = new GridMap <WorldPositionScore> [num];
this.cityProxyByEmpires = new SimulationObject[num];
this.districtProxyByEmpires = new SimulationObject[num];
SimulationDescriptor value = this.SimulationDescriptorDatabase.GetValue("ClassCity");
for (int j = 0; j < num; j++)
{
this.scoreByWorldPositionByEmpires[j] = new GridMap <WorldPositionScore>("PositionScore", (int)this.WorldPositionningService.World.WorldParameters.Columns, (int)this.WorldPositionningService.World.WorldParameters.Rows, null);
this.cityProxyByEmpires[j] = new SimulationObject("WorldPositionEvaluation.CityProxy#" + j);
this.cityProxyByEmpires[j].ModifierForward = ModifierForwardType.ChildrenOnly;
this.cityProxyByEmpires[j].AddDescriptor(value);
this.districtProxyByEmpires[j] = new SimulationObject("WorldPositionEvaluation.DistrictProxy#" + j);
this.districtProxyByEmpires[j].ModifierForward = ModifierForwardType.ChildrenOnly;
this.cityProxyByEmpires[j].AddChild_ModifierForwardType_ChildrenOnly(this.districtProxyByEmpires[j]);
game.Empires[j].SimulationObject.AddChild_ModifierForwardType_ChildrenOnly(this.cityProxyByEmpires[j]);
}
}
private void UpdateLists(AIRegionData regionData)
{
for (int i = 0; i < regionData.Region.PointOfInterests.Length; i++)
{
PointOfInterest pointOfInterest = regionData.Region.PointOfInterests[i];
if (pointOfInterest.Type == "ResourceDeposit")
{
string technologyName;
if (pointOfInterest.PointOfInterestImprovement == null && pointOfInterest.PointOfInterestDefinition.TryGetValue("VisibilityTechnology", out technologyName) && this.departmentOfScience.GetTechnologyState(technologyName) == DepartmentOfScience.ConstructibleElement.State.Researched && this.CanStopThere(pointOfInterest.WorldPosition))
{
this.Resources.Add(pointOfInterest);
}
}
else if (pointOfInterest.Type == ELCPUtilities.QuestLocation && (pointOfInterest.Interaction.Bits & this.owner.Bits) != this.owner.Bits && this.CanStopThere(pointOfInterest.WorldPosition))
{
this.Ruins.Add(pointOfInterest);
}
}
IWorldPositionningService service = Services.GetService <IGameService>().Game.Services.GetService <IWorldPositionningService>();
IOrbAIHelper service2 = AIScheduler.Services.GetService <IOrbAIHelper>();
for (int j = 0; j < service2.OrbSpawns.Count; j++)
{
if (service2.OrbSpawns[j].CurrentOrbCount != 0f && (int)service.GetRegionIndex(service2.OrbSpawns[j].WorldPosition) == regionData.RegionIndex && this.CanStopThere(service2.OrbSpawns[j].WorldPosition))
{
this.Orbs.Add(service2.OrbSpawns[j]);
}
}
}
public void ComputeFarestPositionInList(WorldPosition[] listOfPosition, WorldPosition origin, PathfindingMovementCapacity pathfindingCapacity, out WorldPosition final)
{
WorldPosition worldPosition = WorldPosition.Invalid;
if (listOfPosition.Length > 0)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
float num = 0f;
for (int i = 0; i < listOfPosition.Length; i++)
{
if (service3.IsTilePassable(listOfPosition[i], pathfindingCapacity, (PathfindingFlags)0) && service3.IsTileStopable(listOfPosition[i], pathfindingCapacity, (PathfindingFlags)0))
{
float num2 = (float)service2.GetDistance(listOfPosition[i], origin);
if (num2 > num)
{
worldPosition = listOfPosition[i];
num = num2;
}
}
}
}
final = worldPosition;
}
public override void ReadXml(XmlReader reader)
{
base.ReadXml(reader);
IWorldPositionningService service = Services.GetService <IGameService>().Game.Services.GetService <IWorldPositionningService>();
this.RegionTarget = service.GetRegion(base.RegionIndex);
}
protected override State Execute(QuestBehaviour questBehaviour, EventEmpireWorldTerraformed e, params object[] parameters)
{
if (!e.Reversible && base.CheckAgainstQuestInitiatorFilter(questBehaviour, e.TerraformingEmpire as global::Empire, base.QuestInitiatorFilter) && e.TerraformedTiles.Length != 0)
{
IGameService service = Services.GetService <IGameService>();
World world = (service.Game as global::Game).World;
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
for (int i = 0; i < e.TerraformedTiles.Length; i++)
{
QuestBehaviourTreeNode_Decorator_TerraformRegion.< > c__DisplayClass0_0 CS$ < > 8__locals1 = new QuestBehaviourTreeNode_Decorator_TerraformRegion.< > c__DisplayClass0_0();
CS$ < > 8__locals1.region = service2.GetRegion(e.TerraformedTiles[i]);
bool flag = true;
int k;
int j;
for (j = 0; j < CS$ < > 8__locals1.region.WorldPositions.Length; j = k + 1)
{
if (!service2.IsWaterTile(CS$ < > 8__locals1.region.WorldPositions[j]) && !service2.HasRidge(CS$ < > 8__locals1.region.WorldPositions[j]) && (!service2.ContainsTerrainTag(CS$ < > 8__locals1.region.WorldPositions[j], "TerrainTagVolcanic") || world.TemporaryTerraformations.Exists((World.TemporaryTerraformation tt) => tt.worldPosition == CS$ < > 8__locals1.region.WorldPositions[j])))
{
flag = false;
break;
}
k = j;
}
if (flag)
{
this.RegionTerraformed = flag;
base.UpdateQuestVariable(questBehaviour, this.Output_RegionTerraformedVarName, this.RegionTerraformed);
return(State.Success);
}
}
}
return(State.Running);
}
private bool POIAccessible(PointOfInterest POI)
{
IGameService service = Services.GetService <IGameService>();
IPathfindingService service2 = service.Game.Services.GetService <IPathfindingService>();
IWorldPositionningService service3 = service.Game.Services.GetService <IWorldPositionningService>();
PathfindingContext pathfindingContext = new PathfindingContext(GameEntityGUID.Zero, base.Empire, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.FrozenWater);
pathfindingContext.RefreshProperties(1f, float.PositiveInfinity, false, false, float.PositiveInfinity, float.PositiveInfinity);
foreach (WorldPosition worldPosition in WorldPosition.GetDirectNeighbourTiles(POI.WorldPosition))
{
if (Amplitude.Unity.Framework.Application.Preferences.EnableModdingTools)
{
Diagnostics.Log("ELCP {0} AICommander_Victory POIAccessible checking {1}/{2}", new object[]
{
base.Empire,
POI.WorldPosition,
worldPosition
});
}
if ((!service3.IsWaterTile(worldPosition) || service3.IsFrozenWaterTile(worldPosition)) && service2.IsTileStopable(worldPosition, pathfindingContext, PathfindingFlags.IgnoreArmies | PathfindingFlags.IgnoreFogOfWar, null) && service2.IsTransitionPassable(worldPosition, POI.WorldPosition, pathfindingContext, PathfindingFlags.IgnoreArmies | PathfindingFlags.IgnoreFogOfWar | PathfindingFlags.IgnorePOI, null))
{
if (Amplitude.Unity.Framework.Application.Preferences.EnableModdingTools)
{
Diagnostics.Log("valid");
}
return(true);
}
if (Amplitude.Unity.Framework.Application.Preferences.EnableModdingTools)
{
Diagnostics.Log("not valid");
}
}
return(false);
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
List <GameEntityGUID> list = new List <GameEntityGUID>();
int num = 0;
PathfindingMovementCapacity pathfindingMovementCapacity = PathfindingMovementCapacity.None;
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] is Unit)
{
Unit unit = parameters[i] as Unit;
num += (int)unit.GetPropertyValue(SimulationProperties.UnitSlotCount);
list.Add(unit.GUID);
pathfindingMovementCapacity = unit.GenerateContext().MovementCapacities;
}
else
{
if (!(parameters[i] is IEnumerable <Unit>))
{
return;
}
foreach (Unit unit2 in (parameters[i] as IEnumerable <Unit>))
{
num += (int)unit2.GetPropertyValue(SimulationProperties.UnitSlotCount);
list.Add(unit2.GUID);
if (pathfindingMovementCapacity == PathfindingMovementCapacity.None)
{
pathfindingMovementCapacity = unit2.GenerateContext().MovementCapacities;
}
else
{
pathfindingMovementCapacity &= unit2.GenerateContext().MovementCapacities;
}
}
}
}
IGameService service = Services.GetService <IGameService>();
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
bool flag = false;
bool flag2 = false;
if (this.CanTransferTo(army, army.WorldPosition, ref flag, ref flag2, service2, num) && this.TransferTo(army, army.WorldPosition, list, service2, playerController, out ticket, ticketRaisedEventHandler))
{
return;
}
for (int j = 0; j < 6; j++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(army.WorldPosition, (WorldOrientation)j, 1);
if (service3.IsTilePassable(neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0) && service3.IsTransitionPassable(army.WorldPosition, neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0))
{
if (this.CanTransferTo(army, neighbourTile, ref flag, ref flag2, service2, num) && this.TransferTo(army, neighbourTile, list, service2, playerController, out ticket, ticketRaisedEventHandler))
{
return;
}
}
}
}
public void MoveToRegion(WorldPosition position)
{
IGameService service = Services.GetService <IGameService>();
if (service == null)
{
Diagnostics.LogError("Cannot retreive the gameService.");
return;
}
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
if (service2 == null)
{
Diagnostics.LogError("Cannot retreive the worldPositionningService.");
return;
}
Region region = service2.GetRegion(position);
if (region == null)
{
Diagnostics.LogError("Cannot retreive the region.");
return;
}
Garrison activeTroops = this.GetActiveTroops();
List <Unit> list = new List <Unit>();
foreach (Unit unit in activeTroops.StandardUnits)
{
if (unit.SimulationObject.Tags.Contains(DownloadableContent16.TransportShipUnit))
{
list.Add(unit);
}
}
if (list.Count > 0)
{
for (int i = 0; i < list.Count; i++)
{
list[i].SwitchToEmbarkedUnit(false);
}
if (this.OnArmyMode())
{
this.KaijuArmy.SetSails();
}
}
this.MoveTo(position);
if (this.OnArmyMode())
{
this.ChangeToGarrisonMode(false);
return;
}
if (this.OnGarrisonMode())
{
this.LeaveCurrentRegion();
this.OwnRegion(region);
}
}
public override State CheckCondition(QuestBehaviour questBehaviour, GameEvent gameEvent, params object[] parameters)
{
if (this.RegionIndex != -1)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
global::Game game = service.Game as global::Game;
if (game == null)
{
return(State.Failure);
}
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
global::Empire empire;
if (gameEvent != null)
{
empire = (gameEvent.Empire as global::Empire);
}
else
{
empire = questBehaviour.Initiator;
}
DepartmentOfForeignAffairs agency = empire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
for (int i = 0; i < game.Empires.Length; i++)
{
if (i != empire.Index && (this.IgnoredEmpiresIndex == null || !this.IgnoredEmpiresIndex.Contains(i)))
{
global::Empire empire2 = game.Empires[i];
bool flag;
if (empire2 is MajorEmpire)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(empire2);
Diagnostics.Assert(diplomaticRelation != null);
Diagnostics.Assert(diplomaticRelation.State != null);
flag = (diplomaticRelation.State.Name == DiplomaticRelationState.Names.ColdWar || diplomaticRelation.State.Name == DiplomaticRelationState.Names.War || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Unknown);
}
else
{
flag = true;
}
if (flag)
{
DepartmentOfDefense agency2 = empire2.GetAgency <DepartmentOfDefense>();
for (int j = 0; j < agency2.Armies.Count; j++)
{
if ((this.IncludeNaval || !agency2.Armies[j].IsNaval) && (int)service2.GetRegionIndex(agency2.Armies[j].WorldPosition) == this.RegionIndex)
{
return(State.Success);
}
}
}
}
}
}
return(State.Failure);
}
protected override bool TryComputeArmyMissionParameter()
{
if (this.RegionTarget == null || base.AIDataArmyGUID == GameEntityGUID.Zero)
{
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
base.ArmyMissionParameters.Clear();
Army army = this.aiDataRepository.GetAIData <AIData_Army>(base.AIDataArmyGUID).Army;
if (army == null || !army.GUID.IsValid)
{
return(false);
}
if (this.game.Turn == 0 && army.StandardUnits != null && army.StandardUnits.Count > 1 && army.GetPropertyValue(SimulationProperties.Movement) > 1f)
{
List <Unit> list = army.StandardUnits.ToList <Unit>().FindAll((Unit U) => !U.IsSettler);
if (list != null)
{
IGameService service = Services.GetService <IGameService>();
IPathfindingService service2 = service.Game.Services.GetService <IPathfindingService>();
IWorldPositionningService service3 = service.Game.Services.GetService <IWorldPositionningService>();
WorldPosition validArmySpawningPosition = AILayer_ArmyRecruitment.GetValidArmySpawningPosition(army, service3, service2);
if (validArmySpawningPosition.IsValid)
{
OrderTransferGarrisonToNewArmy order = new OrderTransferGarrisonToNewArmy(base.Commander.Empire.Index, army.GUID, list.ConvertAll <GameEntityGUID>((Unit unit) => unit.GUID).ToArray(), validArmySpawningPosition, StaticString.Empty, false, true, true);
Ticket ticket;
base.Commander.Empire.PlayerControllers.Server.PostOrder(order, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OrderSplitUnit));
return(false);
}
}
}
if (this.RegionTarget == null || this.RegionTarget.IsRegionColonized() || !army.IsSettler)
{
return(base.TryCreateArmyMission("MajorFactionRoaming", new List <object>
{
this.RegionTarget.Index,
false
}));
}
if (base.AIDataArmyGUID == GameEntityGUID.Zero || this.PositionIndex >= this.ListOfPosition.Length)
{
return(false);
}
if (base.Commander.Empire.GetAgency <DepartmentOfTheInterior>().Cities.Count == 0)
{
return(base.TryCreateArmyMission("ColonizeAtImmediatly", new List <object>
{
this.ListOfPosition[this.PositionIndex]
}));
}
return(base.TryCreateArmyMission("ColonizeAt", new List <object>
{
this.ListOfPosition[this.PositionIndex]
}));
}
public static bool GetsFortificationBonus(IWorldPositionningService worldPositionningService, IGarrison garrison, City city)
{
if (garrison == null || city == null)
{
return(false);
}
District district = worldPositionningService.GetDistrict((garrison as IWorldPositionable).WorldPosition);
return(district != null && District.IsACityTile(district) && district.City == city && district.City.Empire == garrison.Empire);
}
public static bool AreaIsSave(WorldPosition pos, int size, DepartmentOfForeignAffairs departmentOfForeignAffairs, out float rangescore, out float incomingMP, bool NavalOnly = false)
{
incomingMP = 0f;
rangescore = 0f;
if (size < 1)
{
return(true);
}
List <global::Empire> list = new List <global::Empire>(Array.FindAll <global::Empire>((Services.GetService <IGameService>().Game as global::Game).Empires, (global::Empire match) => match is MajorEmpire && departmentOfForeignAffairs.IsAtWarWith(match)));
if (list.Count < 1)
{
return(true);
}
bool result = true;
IWorldPositionningService service = Services.GetService <IGameService>().Game.Services.GetService <IWorldPositionningService>();
foreach (global::Empire empire in list)
{
List <IGarrison> list2 = new List <IGarrison>();
DepartmentOfDefense agency = empire.GetAgency <DepartmentOfDefense>();
DepartmentOfTheInterior agency2 = empire.GetAgency <DepartmentOfTheInterior>();
if (!NavalOnly)
{
list2.AddRange(agency.Armies.ToList <Army>().FindAll((Army match) => !match.IsSeafaring && !match.IsSettler).Cast <IGarrison>());
list2.AddRange(agency2.Cities.Cast <IGarrison>());
list2.AddRange(agency2.Camps.Cast <IGarrison>());
list2.AddRange(agency2.ConvertedVillages.Cast <IGarrison>());
}
if (NavalOnly)
{
list2.AddRange(agency.Armies.ToList <Army>().FindAll((Army match) => match.IsNaval && !match.IsSettler).Cast <IGarrison>());
list2.AddRange(agency2.OccupiedFortresses.Cast <IGarrison>());
}
foreach (IGarrison garrison in list2)
{
if (garrison.UnitsCount > 0 && garrison is IWorldPositionable)
{
float num = (float)service.GetDistance((garrison as IWorldPositionable).WorldPosition, pos);
if (num <= (float)size)
{
incomingMP += garrison.GetPropertyValue(SimulationProperties.MilitaryPower);
result = false;
float num2 = 1f - num / (float)size;
if (num2 > rangescore)
{
rangescore = num2;
}
}
}
}
}
return(result);
}
protected override State Execute(AIBehaviorTree aiBehaviorTree, params object[] parameters)
{
Army army;
if (base.GetArmyUnlessLocked(aiBehaviorTree, "$Army", out army) > AIArmyMission.AIArmyMissionErrorCode.None)
{
return(State.Failure);
}
global::Empire empire = aiBehaviorTree.AICommander.Empire;
if (empire == null)
{
aiBehaviorTree.ErrorCode = 10;
return(State.Failure);
}
if (!(empire is MajorEmpire))
{
return(State.Failure);
}
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
Region region = service2.GetRegion(army.WorldPosition);
if (region == null)
{
return(State.Failure);
}
bool flag = false;
if (region != null && region.Owner == aiBehaviorTree.AICommander.Empire && !region.IsOcean)
{
flag = true;
}
if (flag)
{
if (this.Inverted)
{
return(State.Failure);
}
return(State.Success);
}
else
{
if (this.Inverted)
{
return(State.Success);
}
return(State.Failure);
}
}
public bool IsWorldPositionObstructingVision(WorldPosition observerPosition, WorldPosition tilePosition, int observerHeight, bool ignoreFog)
{
if (!observerPosition.IsValid || !tilePosition.IsValid)
{
return(true);
}
Diagnostics.Assert(this.elevationMap != null);
if ((int)observerPosition.Row >= this.elevationMap.Height || (int)observerPosition.Column >= this.elevationMap.Width || (int)tilePosition.Row >= this.elevationMap.Height || (int)tilePosition.Column >= this.elevationMap.Width)
{
return(true);
}
sbyte b = this.elevationMap.GetValue(tilePosition);
PathfindingMovementCapacity tileMovementCapacity = this.pathfindingService.GetTileMovementCapacity(observerPosition, (PathfindingFlags)0);
bool flag = tileMovementCapacity == PathfindingMovementCapacity.Water || tileMovementCapacity == PathfindingMovementCapacity.FrozenWater;
sbyte b2 = (!flag) ? this.elevationMap.GetValue(observerPosition) : this.waterHeightMap.GetValue(observerPosition);
if (this.ridgeMap.GetValue(tilePosition))
{
b = (sbyte)((int)b + (int)this.ridgeHeight);
}
IWorldPositionningService service = base.Game.GetService <IWorldPositionningService>();
if (service == null)
{
return(false);
}
Region region = service.GetRegion(tilePosition);
if (region != null && region.IsWasteland)
{
b = (sbyte)((int)b + (int)this.wastelandHeight);
}
if ((int)b - (int)b2 > observerHeight)
{
return(true);
}
if (service.GetDistance(tilePosition, observerPosition) <= 1)
{
return(false);
}
if (this.weatherService == null)
{
return(false);
}
if (region != null && region.IsOcean && !ignoreFog)
{
WeatherDefinition weatherDefinitionAtPosition = this.weatherService.GetWeatherDefinitionAtPosition(tilePosition);
if (weatherDefinitionAtPosition != null && weatherDefinitionAtPosition.ObstructVisibility)
{
return(true);
}
}
return(false);
}
public StaticString GetRegionBiome(Region region)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
byte biomeType = service2.GetBiomeType(region.WorldPositions[0]);
return(service2.GetBiomeTypeMappingName(biomeType));
}
public bool IsPositionInRange(WorldPosition origin, WorldPosition destination, int range)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
int distance = service2.GetDistance(origin, destination);
return(distance <= range);
}
public override State CheckCondition(QuestBehaviour questBehaviour, GameEvent gameEvent, params object[] parameters)
{
this.Initialize(questBehaviour);
if (this.RegionIndex != -1)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
if (service.Game as global::Game == null)
{
return(State.Failure);
}
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
global::Empire empire;
if (gameEvent != null)
{
empire = (gameEvent.Empire as global::Empire);
}
else
{
empire = questBehaviour.Initiator;
}
DepartmentOfDefense agency = empire.GetAgency <DepartmentOfDefense>();
if (this.CheckAllArmies)
{
for (int i = 0; i < agency.Armies.Count; i++)
{
if ((int)service2.GetRegionIndex(agency.Armies[i].WorldPosition) == this.RegionIndex)
{
return(State.Success);
}
}
}
else
{
Army army = agency.GetArmy(this.ArmyGuid);
if (army == null)
{
return(State.Failure);
}
Region region = service2.GetRegion(army.WorldPosition);
if (region == null)
{
return(State.Failure);
}
if (this.RegionIndex == region.Index)
{
return(State.Success);
}
}
}
return(State.Failure);
}
private bool CheckPointOfInterestImprovementPrerequisites(PointOfInterestImprovementDefinition pointOfInterestImprovementDefinition, ref List <StaticString> failureFlags)
{
if (this.lastFailureFlags.Contains(ConstructionFlags.Discard))
{
return(false);
}
IWorldPositionningService service = base.Game.Services.GetService <IWorldPositionningService>();
if (service == null)
{
this.lastFailureFlags.Add(ConstructionFlags.Discard);
return(false);
}
DepartmentOfIndustry agency = this.City.Empire.GetAgency <DepartmentOfIndustry>();
if (agency == null)
{
this.lastFailureFlags.Add(ConstructionFlags.Discard);
return(false);
}
ConstructionQueue constructionQueue = agency.GetConstructionQueue(this.City);
if (constructionQueue == null)
{
this.lastFailureFlags.Add(ConstructionFlags.Discard);
return(false);
}
int num = constructionQueue.Count(pointOfInterestImprovementDefinition);
int num2 = 0;
for (int i = 0; i < this.city.Region.PointOfInterests.Length; i++)
{
PointOfInterest pointOfInterest = this.city.Region.PointOfInterests[i];
if (!(pointOfInterest.PointOfInterestDefinition.PointOfInterestTemplateName != pointOfInterestImprovementDefinition.PointOfInterestTemplateName))
{
if (pointOfInterest.PointOfInterestImprovement == null)
{
int explorationBits = service.GetExplorationBits(pointOfInterest.WorldPosition);
if ((explorationBits & this.city.Empire.Bits) != 0)
{
num2++;
}
}
}
}
if (num2 <= num)
{
this.lastFailureFlags.Add(ConstructionFlags.Discard);
return(false);
}
return(true);
}
public static WorldPosition GetValidKaijuPosition(Region targetRegion, bool randomFallback = false)
{
IGameService service = Services.GetService <IGameService>();
IWorldPositionningService service3 = service.Game.Services.GetService <IWorldPositionningService>();
KaijuCouncil.attractivenessMap = (KaijuCouncil.world.Atlas.GetMap(WorldAtlas.Maps.KaijuAttractiveness) as GridMap <bool>);
WorldPosition[] array = (from position in targetRegion.WorldPositions
where KaijuCouncil.IsPositionValidForSettleKaiju(position, null)
select position).ToArray <WorldPosition>();
WorldPosition result = WorldPosition.Invalid;
if (array.Length != 0)
{
result = array[KaijuCouncil.random.Next(0, array.Length)];
if (!ELCPUtilities.UseELCPSymbiosisBuffs)
{
goto IL_185;
}
List <WorldPosition> list = array.ToList <WorldPosition>().Randomize(KaijuCouncil.random);
List <PointOfInterest> list2 = targetRegion.PointOfInterests.ToList <PointOfInterest>().FindAll((PointOfInterest PointOfInterest) => PointOfInterest.Type == ELCPUtilities.QuestLocation);
if (list2 == null || list2.Count <= 0)
{
goto IL_185;
}
using (List <WorldPosition> .Enumerator enumerator = list.GetEnumerator())
{
while (enumerator.MoveNext())
{
WorldPosition position = enumerator.Current;
if (list2.Any((PointOfInterest poi) => service3.GetDistance(poi.WorldPosition, position) == 1))
{
result = position;
break;
}
}
goto IL_185;
}
}
if (randomFallback)
{
Diagnostics.LogError("Could not find suitable position in starting region!... Picking a random one...");
result = targetRegion.WorldPositions[KaijuCouncil.random.Next(0, targetRegion.WorldPositions.Length)];
}
IL_185:
if (!result.IsValid)
{
Diagnostics.LogError("Could not find a valid kaiju position!");
}
return(result);
}
private void ReleaseKaijuArmyActions()
{
DepartmentOfDefense agency = this.Empire.GetAgency <DepartmentOfDefense>();
SimulationDescriptor value = this.SimulationDescriptorDatabase.GetValue(DepartmentOfTheInterior.ArmyStatusBesiegerDescriptorName);
this.KaijuArmy.RemoveDescriptor(value);
if (this.KaijuArmy.IsEarthquaker)
{
this.KaijuArmy.SetEarthquakerStatus(false, false, null);
}
if (this.KaijuArmy.PillageTarget.IsValid)
{
DepartmentOfDefense.StopPillage(this.KaijuArmy);
}
if (this.KaijuArmy.IsAspirating)
{
agency.StopAspirating(this.KaijuArmy);
}
if (this.KaijuArmy.IsDismantlingDevice)
{
ITerraformDeviceRepositoryService service = this.gameService.Game.Services.GetService <ITerraformDeviceRepositoryService>();
TerraformDevice device = service[this.KaijuArmy.DismantlingDeviceTarget] as TerraformDevice;
agency.StopDismantelingDevice(this.KaijuArmy, device);
}
if (this.KaijuArmy.IsDismantlingCreepingNode)
{
CreepingNode creepingNode = null;
if (this.gameEntityRepositoryService.TryGetValue <CreepingNode>(this.KaijuArmy.DismantlingCreepingNodeTarget, out creepingNode))
{
agency.StopDismantelingCreepingNode(this.KaijuArmy, creepingNode);
}
}
IWorldPositionningService service2 = this.gameService.Game.Services.GetService <IWorldPositionningService>();
Region region = service2.GetRegion(this.KaijuArmy.WorldPosition);
if (region.City != null && region.City.Empire != this.Empire)
{
DepartmentOfTheInterior agency2 = region.City.Empire.GetAgency <DepartmentOfTheInterior>();
if (agency2 != null)
{
if (region.City.BesiegingEmpire == this.Empire && agency2.NeedToStopSiege(region.City))
{
agency2.StopSiege(region.City);
}
agency2.StopNavalSiege(region.City, this.KaijuArmy);
}
IVisibilityService service3 = this.gameService.Game.Services.GetService <IVisibilityService>();
service3.NotifyVisibilityHasChanged(this.Empire);
}
}
public static bool AreaIsSave(WorldPosition pos, int size, DepartmentOfForeignAffairs departmentOfForeignAffairs, bool NavalOnly = false, bool ignoreColdwar = false)
{
if (size < 1)
{
return(true);
}
List <global::Empire> list = new List <global::Empire>();
if (ignoreColdwar)
{
list.AddRange(Array.FindAll <global::Empire>((Services.GetService <IGameService>().Game as global::Game).Empires, (global::Empire match) => match is MajorEmpire && departmentOfForeignAffairs.IsAtWarWith(match)));
}
else
{
list.AddRange(Array.FindAll <global::Empire>((Services.GetService <IGameService>().Game as global::Game).Empires, (global::Empire match) => match is MajorEmpire && !departmentOfForeignAffairs.IsFriend(match)));
}
if (list.Count == 0)
{
return(true);
}
IWorldPositionningService service = Services.GetService <IGameService>().Game.Services.GetService <IWorldPositionningService>();
foreach (global::Empire empire in list)
{
List <IGarrison> list2 = new List <IGarrison>();
DepartmentOfDefense agency = empire.GetAgency <DepartmentOfDefense>();
DepartmentOfTheInterior agency2 = empire.GetAgency <DepartmentOfTheInterior>();
if (!NavalOnly)
{
list2.AddRange(agency.Armies.ToList <Army>().FindAll((Army match) => !match.IsSeafaring && !match.IsSettler).Cast <IGarrison>());
list2.AddRange(agency2.Cities.Cast <IGarrison>());
list2.AddRange(agency2.Camps.Cast <IGarrison>());
list2.AddRange(agency2.ConvertedVillages.Cast <IGarrison>());
}
if (NavalOnly)
{
list2.AddRange(agency.Armies.ToList <Army>().FindAll((Army match) => match.IsNaval && !match.IsSettler).Cast <IGarrison>());
list2.AddRange(agency2.OccupiedFortresses.Cast <IGarrison>());
}
foreach (IGarrison garrison in list2)
{
if (garrison.UnitsCount > 0 && garrison is IWorldPositionable && service.GetDistance((garrison as IWorldPositionable).WorldPosition, pos) <= size)
{
return(false);
}
}
}
return(true);
}
public static WorldPosition GetValidArmySpawningPosition(Army army, IWorldPositionningService worldPositionningService, IPathfindingService pathfindingService)
{
WorldOrientation worldOrientation = WorldOrientation.East;
for (int i = 0; i < 6; i++)
{
WorldPosition neighbourTile = worldPositionningService.GetNeighbourTile(army.WorldPosition, worldOrientation, 1);
if (neighbourTile.IsValid && !worldPositionningService.IsWaterTile(neighbourTile) && pathfindingService.IsTransitionPassable(army.WorldPosition, neighbourTile, army, PathfindingFlags.IgnoreFogOfWar, null) && pathfindingService.IsTileStopableAndPassable(neighbourTile, army, PathfindingFlags.IgnoreFogOfWar, null))
{
return(neighbourTile);
}
worldOrientation = worldOrientation.Rotate(1);
}
return(WorldPosition.Invalid);
}
private bool POIAccessible()
{
IGameService service = Services.GetService <IGameService>();
IPathfindingService service2 = service.Game.Services.GetService <IPathfindingService>();
IWorldPositionningService service3 = service.Game.Services.GetService <IWorldPositionningService>();
foreach (WorldPosition worldPosition in WorldPosition.GetDirectNeighbourTiles(this.POI.WorldPosition))
{
if ((!service3.IsWaterTile(worldPosition) || service3.IsFrozenWaterTile(worldPosition)) && service2.IsTileStopable(worldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.FrozenWater, PathfindingFlags.IgnoreArmies | PathfindingFlags.IgnoreFogOfWar) && service2.IsTransitionPassable(worldPosition, this.POI.WorldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.FrozenWater, PathfindingFlags.IgnoreArmies | PathfindingFlags.IgnoreFogOfWar))
{
return(true);
}
}
return(false);
}
public bool CanChangeToGarrisonMode()
{
if (this.OnGarrisonMode())
{
return(false);
}
if (this.IsStunned())
{
return(false);
}
IWorldPositionningService service = this.GameService.Game.Services.GetService <IWorldPositionningService>();
Region region = service.GetRegion(this.KaijuArmy.WorldPosition);
return(region == null || region.Owner == null);
}
public void FillTargets(Army army, List <IGameEntity> gameEntities, ref List <StaticString> failureFlags)
{
if (army == null)
{
throw new ArgumentNullException("army");
}
IGameService service = Services.GetService <IGameService>();
if (service == null)
{
return;
}
global::Game x = service.Game as global::Game;
if (x == null)
{
return;
}
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
for (int i = 0; i < 6; i++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(army.WorldPosition, (WorldOrientation)i, 1);
Region region = service2.GetRegion(neighbourTile);
if (region != null && region.Kaiju != null)
{
Kaiju kaiju = region.Kaiju;
if (this.IsKaijuValidForTame(army, kaiju, ref failureFlags, true) && !gameEntities.Contains(kaiju))
{
gameEntities.Add(kaiju);
}
}
Army armyAtPosition = service2.GetArmyAtPosition(neighbourTile);
if (armyAtPosition != null && armyAtPosition is KaijuArmy)
{
KaijuArmy kaijuArmy = armyAtPosition as KaijuArmy;
if (kaijuArmy != null)
{
Kaiju kaiju2 = kaijuArmy.Kaiju;
if (kaiju2 != null && kaiju2.OnArmyMode() && !kaiju2.IsStunned() && !gameEntities.Contains(kaiju2))
{
gameEntities.Add(kaijuArmy.Kaiju);
}
}
}
}
}
