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);
}
private bool CanIAttackTheCityFromTheDistrict(District district, GridMap <District> districtsMap, Army army, IPathfindingService pathfindingService, IWorldPositionningService worldPositionningService)
{
if (district == null)
{
return(false);
}
if (worldPositionningService.IsWaterTile(district.WorldPosition))
{
return(false);
}
using (new UnityProfilerSample("IsTileStopable"))
{
if (!pathfindingService.IsTileStopableAndPassable(district.WorldPosition, army, PathfindingFlags.IgnoreDiplomacy | PathfindingFlags.IgnoreFogOfWar | PathfindingFlags.IgnoreZoneOfControl | PathfindingFlags.IgnoreSieges, null))
{
return(false);
}
}
for (int i = 0; i < 6; i++)
{
WorldPosition neighbourTile = worldPositionningService.GetNeighbourTile(district.WorldPosition, (WorldOrientation)i, 1);
if (!worldPositionningService.IsWaterTile(neighbourTile))
{
District value = districtsMap.GetValue(neighbourTile);
if (value != null && District.IsACityTile(value))
{
using (new UnityProfilerSample("IsTransitionPassable"))
{
if (pathfindingService.IsTransitionPassable(district.WorldPosition, neighbourTile, army, OrderAttack.AttackFlags, null))
{
return(true);
}
}
}
}
}
return(false);
}
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 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);
}
public void AddDistrict(District district)
{
if (district == null)
{
throw new ArgumentNullException("district");
}
if (!district.GUID.IsValid)
{
Diagnostics.LogError("Cannot add district with invalid guid.");
return;
}
if (this.districts.Exists((District item) => item.GUID == district.GUID))
{
Diagnostics.Assert(district.City == this);
Diagnostics.LogWarning("Cannot add district twice to the same city, ignoring...");
return;
}
if (district.City != null)
{
Diagnostics.Assert(district.City != this);
Diagnostics.LogWarning("Cannot add district already linked to another city, ignoring...");
return;
}
this.districts.Add(district);
district.City = this;
base.AddChild(district);
if (district.Type != DistrictType.Exploitation)
{
this.ExtensionCount++;
}
if (this.DryDockPosition == WorldPosition.Invalid)
{
IWorldPositionningService service = this.gameService.Game.Services.GetService <IWorldPositionningService>();
if (service.IsWaterTile(district.WorldPosition) && !service.IsFrozenWaterTile(district.WorldPosition))
{
GridMap <byte> map = (this.gameService.Game as global::Game).World.Atlas.GetMap(WorldAtlas.Maps.Terrain) as GridMap <byte>;
Map <TerrainTypeName> map2 = (this.gameService.Game as global::Game).World.Atlas.GetMap(WorldAtlas.Tables.Terrains) as Map <TerrainTypeName>;
byte value = map.GetValue(district.WorldPosition);
StaticString empty = StaticString.Empty;
if (map2.Data.TryGetValue((int)value, ref empty) && empty.ToString().IndexOf("InlandWater") == -1)
{
this.DryDockPosition = district.WorldPosition;
}
}
}
this.OnCityDistrictCollectionChange(CollectionChangeAction.Add, district);
}
public District GetValidDistrictToTarget(Army army = null)
{
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>();
Diagnostics.Assert(service3 != null);
for (int i = 0; i < this.districts.Count; i++)
{
District district = this.districts[i];
if (District.IsACityTile(district))
{
for (int j = 0; j < 6; j++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(district.WorldPosition, (WorldOrientation)j, 1);
if (!service2.IsWaterTile(neighbourTile))
{
if (army == null || service3.IsTileStopable(neighbourTile, army, PathfindingFlags.IgnoreFogOfWar | PathfindingFlags.IgnoreZoneOfControl, null))
{
for (int k = 0; k < this.districts.Count; k++)
{
District district2 = this.districts[k];
if (district2.WorldPosition == neighbourTile)
{
if (service3.IsTransitionPassable(district2.WorldPosition, district.WorldPosition, PathfindingMovementCapacity.Ground, PathfindingFlags.IgnoreArmies | PathfindingFlags.IgnoreDiplomacy | PathfindingFlags.IgnoreFogOfWar | PathfindingFlags.IgnoreZoneOfControl | PathfindingFlags.IgnoreSieges))
{
Army armyAtPosition = service2.GetArmyAtPosition(district2.WorldPosition);
if (armyAtPosition == null || armyAtPosition == army)
{
return(district2);
}
}
break;
}
}
}
}
}
}
}
return(this.districts[0]);
}
public static bool IsELCPCityBattle(IWorldPositionningService worldPositionningService, List <IGarrison> MainContenders, out List <City> cities)
{
cities = new List <City>();
if (worldPositionningService == null)
{
Diagnostics.LogError("worldPositionningService");
}
foreach (IGarrison garrison in MainContenders)
{
if (!(garrison is IWorldPositionable))
{
Diagnostics.LogError("garrison {0}", new object[]
{
garrison.LocalizedName
});
}
District district = worldPositionningService.GetDistrict((garrison as IWorldPositionable).WorldPosition);
if (!worldPositionningService.IsWaterTile((garrison as IWorldPositionable).WorldPosition) && district != null && district.City != null && (District.IsACityTile(district) || district.Type == DistrictType.Exploitation) && !cities.Exists((City C) => C.GUID == district.City.GUID))
{
cities.Add(district.City);
}
}
return(cities.Count > 0);
}
protected override State Execute(AIBehaviorTree aiBehaviorTree, params object[] parameters)
{
if (this.TypeOfDiplomaticRelation == "VillageQuest" && (!(aiBehaviorTree.AICommander.Empire is MajorEmpire) || !aiBehaviorTree.AICommander.Empire.GetAgency <DepartmentOfScience>().CanParley()))
{
return(State.Failure);
}
if (this.DiplomacyLayer == null && aiBehaviorTree.AICommander.Empire is MajorEmpire)
{
AIEntity_Empire entity = aiBehaviorTree.AICommander.AIPlayer.GetEntity <AIEntity_Empire>();
this.DiplomacyLayer = entity.GetLayer <AILayer_Diplomacy>();
}
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
Army army;
if (base.GetArmyUnlessLocked(aiBehaviorTree, "$Army", out army) > AIArmyMission.AIArmyMissionErrorCode.None)
{
return(State.Failure);
}
if (!aiBehaviorTree.Variables.ContainsKey(this.TargetListVarName))
{
return(State.Failure);
}
List <IWorldPositionable> list = aiBehaviorTree.Variables[this.TargetListVarName] as List <IWorldPositionable>;
if (list == null || list.Count == 0)
{
aiBehaviorTree.ErrorCode = 10;
return(State.Failure);
}
List <IWorldPositionable> list2 = null;
if (this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Army)
{
list2 = list.FindAll((IWorldPositionable match) => match is Army);
}
else if (this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Ruin)
{
list2 = this.Execute_GetRuins(aiBehaviorTree, army, service, list);
}
else if (this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Village)
{
list2 = this.Execute_GetVillages(aiBehaviorTree, army, service, list);
}
else if (this.TypeOfTarget > AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Village && this.TypeOfTarget < AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.VolcanoformerDevice)
{
list2 = this.Execute_GetKaijus(aiBehaviorTree, army, service, list);
}
else if (this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.VolcanoformerDevice)
{
list2 = this.Execute_GetVolcanoformers(aiBehaviorTree, army, service, list);
}
else if (this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Fortress)
{
list2 = this.Execute_GetFortresses(aiBehaviorTree, army, service, list);
}
else if (this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Any)
{
list2 = new List <IWorldPositionable>(list);
}
if (army.Empire is MinorEmpire || army.Empire is NavalEmpire)
{
for (int i = list2.Count - 1; i >= 0; i--)
{
Garrison garrison = list2[i] as Garrison;
if (garrison != null && garrison.Hero != null && garrison.Hero.IsSkillUnlocked("HeroSkillLeaderMap07"))
{
list2.RemoveAt(i);
}
}
}
IGameEntityRepositoryService service2 = service.Game.Services.GetService <IGameEntityRepositoryService>();
IWorldPositionningService service3 = service.Game.Services.GetService <IWorldPositionningService>();
bool flag = false;
if (this.TypeOfDiplomaticRelation == "VillageQuest")
{
flag = true;
}
if (!string.IsNullOrEmpty(this.TypeOfDiplomaticRelationVariableName) && aiBehaviorTree.Variables.ContainsKey(this.TypeOfDiplomaticRelationVariableName))
{
this.TypeOfDiplomaticRelation = (aiBehaviorTree.Variables[this.TypeOfDiplomaticRelationVariableName] as string);
}
DepartmentOfForeignAffairs departmentOfForeignAffairs = null;
bool canAttack = false;
if (this.TypeOfDiplomaticRelation == "Enemy")
{
departmentOfForeignAffairs = aiBehaviorTree.AICommander.Empire.GetAgency <DepartmentOfForeignAffairs>();
canAttack = true;
}
else if (this.TypeOfDiplomaticRelation == "DangerForMe")
{
departmentOfForeignAffairs = aiBehaviorTree.AICommander.Empire.GetAgency <DepartmentOfForeignAffairs>();
canAttack = false;
}
for (int j = list2.Count - 1; j >= 0; j--)
{
if (!AIBehaviorTreeNode_Decorator_SelectTarget.ValidateTarget(army, list2[j] as IGameEntity, departmentOfForeignAffairs, canAttack, service2, service3))
{
list2.RemoveAt(j);
}
else if (list2[j] is IGarrison && departmentOfForeignAffairs != null && this.DiplomacyLayer != null && (list2[j] as IGarrison).Empire is MajorEmpire && this.DiplomacyLayer.GetPeaceWish((list2[j] as IGarrison).Empire.Index))
{
if (!(list2[j] is Army) || !(list2[j] as Army).IsPrivateers)
{
list2.RemoveAt(j);
}
}
else if (flag && list2[j] is Village && !this.ValidQuestVillage(list2[j] as Village, army))
{
list2.RemoveAt(j);
}
}
IWorldPositionningService worldPositionService = service.Game.Services.GetService <IWorldPositionningService>();
if (list2 != null && list2.Count != 0)
{
bool flag2;
if (this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Ruin || this.TypeOfTarget == AIBehaviorTreeNode_Decorator_SelectTarget.TargetType.Fortress)
{
flag2 = army.SimulationObject.Tags.Contains("MovementCapacitySail");
}
else
{
flag2 = army.HasSeafaringUnits();
}
Diagnostics.Assert(worldPositionService != null);
if (!flag2)
{
list2.RemoveAll((IWorldPositionable element) => worldPositionService.IsWaterTile(element.WorldPosition));
}
if (army.IsSeafaring)
{
list2.RemoveAll((IWorldPositionable element) => !worldPositionService.IsWaterTile(element.WorldPosition));
list2.RemoveAll((IWorldPositionable element) => worldPositionService.IsFrozenWaterTile(element.WorldPosition));
}
}
if (list2 != null && list2.Count != 0)
{
if (list2.Count > 1)
{
list2.Sort((IWorldPositionable left, IWorldPositionable right) => worldPositionService.GetDistance(left.WorldPosition, army.WorldPosition).CompareTo(worldPositionService.GetDistance(right.WorldPosition, army.WorldPosition)));
}
if (aiBehaviorTree.Variables.ContainsKey(this.Output_TargetVarName))
{
aiBehaviorTree.Variables[this.Output_TargetVarName] = list2[0];
}
else
{
aiBehaviorTree.Variables.Add(this.Output_TargetVarName, list2[0]);
}
}
else if (aiBehaviorTree.Variables.ContainsKey(this.Output_TargetVarName))
{
aiBehaviorTree.Variables.Remove(this.Output_TargetVarName);
}
State result;
if (this.Inverted)
{
if (list2 != null && list2.Count != 0)
{
result = State.Failure;
}
else
{
result = State.Success;
}
}
else if (list2 != null && list2.Count != 0)
{
result = State.Success;
}
else
{
aiBehaviorTree.ErrorCode = 10;
result = State.Failure;
}
return(result);
}
public override State CheckCondition(QuestBehaviour questBehaviour, GameEvent gameEvent, params object[] parameters)
{
if (this.Location != WorldPosition.Invalid)
{
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++)
{
WorldPosition worldPosition = agency.Armies[i].WorldPosition;
int distance = service2.GetDistance(this.Location, worldPosition);
int regionIndex = (int)service2.GetRegionIndex(worldPosition);
bool flag = service2.IsWaterTile(worldPosition) || service2.IsOceanTile(worldPosition);
if (distance == -1)
{
return(State.Failure);
}
if (distance <= this.Distance && (this.RegionIndex == -1 || regionIndex == this.RegionIndex) && (!this.ExcludeWaterTile || !flag))
{
return(State.Success);
}
}
}
else
{
Army army = agency.GetArmy(this.ArmyGuid);
if (army == null)
{
return(State.Failure);
}
int distance2 = service2.GetDistance(this.Location, army.WorldPosition);
int regionIndex2 = (int)service2.GetRegionIndex(army.WorldPosition);
bool flag2 = service2.IsWaterTile(army.WorldPosition) || service2.IsOceanTile(army.WorldPosition);
if (distance2 == -1)
{
return(State.Failure);
}
if (distance2 <= this.Distance && (this.RegionIndex == -1 || regionIndex2 == this.RegionIndex) && (!this.ExcludeWaterTile || !flag2))
{
return(State.Success);
}
}
}
return(State.Failure);
}
protected void SpawnArmy(QuestBehaviour questBehaviour)
{
if (!string.IsNullOrEmpty(this.ArmyDroplist))
{
IGameService service = Services.GetService <IGameService>();
if (service == null || service.Game == null)
{
Diagnostics.LogError("Failed to retrieve the game service.");
return;
}
global::Game game = service.Game as global::Game;
if (game == null)
{
Diagnostics.LogError("Failed to cast gameService.Game to Game.");
return;
}
IDatabase <Droplist> database = Databases.GetDatabase <Droplist>(false);
if (database == null)
{
return;
}
string text = this.ArmyDroplist;
if (this.ArmyDroplistSuffix != string.Empty)
{
text = text + "_" + this.ArmyDroplistSuffix;
}
Droplist droplist;
if (!database.TryGetValue(text, out droplist))
{
Diagnostics.LogError("Cannot retrieve drop list '{0}' in quest definition '{1}'", new object[]
{
text,
questBehaviour.Quest.QuestDefinition.Name
});
return;
}
if (!string.IsNullOrEmpty(this.EmpireArmyOwnerVarName))
{
global::Empire empire = null;
object obj;
if (questBehaviour.TryGetQuestVariableValueByName <object>(this.EmpireArmyOwnerVarName, out obj))
{
if (obj is global::Empire)
{
empire = (obj as global::Empire);
}
else if (obj is int)
{
empire = game.Empires[(int)obj];
}
if (empire != null)
{
this.EmpireArmyOwner = empire;
}
}
}
global::Empire empire2 = this.EmpireArmyOwner;
if (empire2 == null || empire2 is LesserEmpire || this.UseBehaviorInitiatorEmpire)
{
empire2 = questBehaviour.Initiator;
}
if (this.UseBehaviorInitiatorEmpire)
{
this.EmpireArmyOwner = questBehaviour.Initiator;
}
if (this.EmpireArmyOwner is MajorEmpire && (this.EmpireArmyOwner as MajorEmpire).ELCPIsEliminated)
{
return;
}
Droplist droplist2;
DroppableArmyDefinition droppableArmyDefinition = droplist.Pick(empire2, out droplist2, new object[0]) as DroppableArmyDefinition;
if (droppableArmyDefinition != null)
{
int num = 0;
if (this.ScaleWithMaxEra)
{
num = DepartmentOfScience.GetMaxEraNumber() - 1;
}
int val = 0;
IDatabase <AnimationCurve> database2 = Databases.GetDatabase <AnimationCurve>(false);
AnimationCurve animationCurve;
if (database2 != null && database2.TryGetValue(QuestBehaviourTreeNode_Action_SpawnArmy.questUnitLevelEvolution, out animationCurve))
{
float propertyValue = questBehaviour.Initiator.GetPropertyValue(SimulationProperties.GameSpeedMultiplier);
val = (int)animationCurve.EvaluateWithScaledAxis((float)game.Turn, propertyValue, 1f);
val = Math.Max(0, Math.Min(100, val));
}
num = Math.Max(num, val);
StaticString[] array = Array.ConvertAll <string, StaticString>(droppableArmyDefinition.UnitDesigns, (string input) => input);
bool flag = false;
IDatabase <UnitDesign> database3 = Databases.GetDatabase <UnitDesign>(false);
for (int i = 0; i < array.Length; i++)
{
UnitDesign unitDesign;
if (database3.TryGetValue(array[i], out unitDesign) && unitDesign != null && unitDesign.Tags.Contains(DownloadableContent16.TagSeafaring))
{
flag = true;
break;
}
}
IEnumerable <WorldPosition> enumerable = null;
questBehaviour.TryGetQuestVariableValueByName <WorldPosition>(this.ForbiddenSpawnLocationVarName, out enumerable);
List <WorldPosition> list = this.SpawnLocations.ToList <WorldPosition>().Randomize(null);
IWorldPositionningService service2 = game.Services.GetService <IWorldPositionningService>();
IPathfindingService service3 = game.Services.GetService <IPathfindingService>();
Diagnostics.Assert(service2 != null);
WorldPosition worldPosition = WorldPosition.Invalid;
if (!questBehaviour.Quest.QuestDefinition.IsGlobal)
{
PathfindingMovementCapacity pathfindingMovementCapacity = PathfindingMovementCapacity.Water;
if (!flag)
{
pathfindingMovementCapacity |= PathfindingMovementCapacity.Ground;
}
for (int j = 0; j < list.Count; j++)
{
WorldPosition worldPosition2 = list[j];
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(worldPosition2, pathfindingMovementCapacity))
{
if (enumerable != null)
{
if (enumerable.Contains(worldPosition2))
{
goto IL_330;
}
this.AddPositionToForbiddenSpawnPosition(questBehaviour, worldPosition2);
}
worldPosition = worldPosition2;
break;
}
IL_330 :;
}
if (!service3.IsTileStopable(worldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water, PathfindingFlags.IgnoreFogOfWar))
{
worldPosition = WorldPosition.Invalid;
}
if (!worldPosition.IsValid && list.Count > 0)
{
List <WorldPosition> list2 = new List <WorldPosition>();
Queue <WorldPosition> queue = new Queue <WorldPosition>();
worldPosition = list[0];
bool flag2 = false;
if (worldPosition.IsValid)
{
flag2 = service2.IsWaterTile(worldPosition);
}
do
{
if (queue.Count > 0)
{
worldPosition = queue.Dequeue();
}
for (int k = 0; k < 6; k++)
{
WorldPosition neighbourTileFullCyclic = service2.GetNeighbourTileFullCyclic(worldPosition, (WorldOrientation)k, 1);
if (!list2.Contains(neighbourTileFullCyclic) && list2.Count < 19)
{
queue.Enqueue(neighbourTileFullCyclic);
list2.Add(neighbourTileFullCyclic);
}
}
if (!DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(worldPosition, pathfindingMovementCapacity) || !service3.IsTileStopable(worldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water, PathfindingFlags.IgnoreFogOfWar) || flag2 != service2.IsWaterTile(worldPosition))
{
worldPosition = WorldPosition.Invalid;
}
}while (worldPosition == WorldPosition.Invalid && queue.Count > 0);
}
if (!worldPosition.IsValid)
{
string format = "Cannot find a valid position to spawn on: {0}";
object[] array2 = new object[1];
array2[0] = string.Join(",", list.Select(delegate(WorldPosition position)
{
WorldPosition worldPosition3 = position;
return(worldPosition3.ToString());
}).ToArray <string>());
Diagnostics.LogError(format, array2);
return;
}
}
OrderSpawnArmy orderSpawnArmy;
if (worldPosition.IsValid)
{
list.Clear();
list.Add(worldPosition);
WorldOrientation worldOrientation = WorldOrientation.East;
for (int l = 0; l < 6; l++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(worldPosition, worldOrientation, 1);
bool flag3 = flag == service2.IsWaterTile(neighbourTile);
if (neighbourTile.IsValid && flag3 && service3.IsTileStopable(worldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water, PathfindingFlags.IgnoreFogOfWar))
{
list.Add(neighbourTile);
}
worldOrientation = worldOrientation.Rotate(1);
}
orderSpawnArmy = new OrderSpawnArmy(this.EmpireArmyOwner.Index, list.ToArray(), num, true, this.CanMoveOnSpawn, true, questBehaviour.Quest.QuestDefinition.IsGlobal || this.ForceGlobalArmySymbol, array);
}
else
{
orderSpawnArmy = new OrderSpawnArmy(this.EmpireArmyOwner.Index, list.ToArray(), num, true, this.CanMoveOnSpawn, true, questBehaviour.Quest.QuestDefinition.IsGlobal || this.ForceGlobalArmySymbol, array);
}
orderSpawnArmy.GameEntityGUID = this.ArmyGUID;
Diagnostics.Log("Posting order: {0} at {1}", new object[]
{
orderSpawnArmy.ToString(),
worldPosition
});
if (!string.IsNullOrEmpty(this.TransferResourceName) && this.TransferResourceAmount > 0)
{
Ticket ticket;
this.EmpireArmyOwner.PlayerControllers.Server.PostOrder(orderSpawnArmy, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OrderSpawnArmy_TicketRaised));
return;
}
this.EmpireArmyOwner.PlayerControllers.Server.PostOrder(orderSpawnArmy);
}
}
}
public static bool CanTeleportToCity(City city, Army army, Region originRegion, IWorldPositionningService worldPositionningService, IEncounterRepositoryService encounterRepositoryService)
{
WorldPosition position;
return(city != null && city.GUID.IsValid && originRegion.City != null && city.Empire.Index == army.Empire.Index && city != originRegion.City && (encounterRepositoryService == null || !encounterRepositoryService.Any((Encounter encounter) => encounter.IsGarrisonInEncounter(city.GUID, false))) && army.Empire.GetAgency <DepartmentOfTransportation>().TryGetFirstCityTileAvailableForTeleport(city, out position) && position.IsValid && !worldPositionningService.IsWaterTile(position));
}
private bool CanSearch(Army army, PointOfInterest pointOfInterest, IQuestManagementService questManagementService, IQuestRepositoryService questRepositoryService, ref bool available)
{
IGameService service = Services.GetService <IGameService>();
if (service == null)
{
return(false);
}
global::Game game = service.Game as global::Game;
if (game == null)
{
return(false);
}
if (pointOfInterest == null)
{
return(false);
}
if (pointOfInterest.Type != ELCPUtilities.QuestLocation)
{
return(false);
}
if (ELCPUtilities.UseELCPPeacefulCreepingNodes)
{
if (pointOfInterest.CreepingNodeGUID != GameEntityGUID.Zero && pointOfInterest.Empire != army.Empire)
{
if (pointOfInterest.Empire == null)
{
return(false);
}
if (!(pointOfInterest.Empire is MajorEmpire))
{
return(false);
}
DepartmentOfForeignAffairs agency = army.Empire.GetAgency <DepartmentOfForeignAffairs>();
if (agency == null)
{
return(false);
}
if (!agency.IsFriend(pointOfInterest.Empire))
{
return(false);
}
}
}
else if (pointOfInterest.CreepingNodeGUID != GameEntityGUID.Zero && pointOfInterest.Empire != army.Empire)
{
return(false);
}
bool flag = false;
foreach (QuestMarker questMarker in questManagementService.GetMarkersByBoundTargetGUID(pointOfInterest.GUID))
{
Quest quest;
if (!questMarker.IgnoreInteraction && questRepositoryService.TryGetValue(questMarker.QuestGUID, out quest) && quest.EmpireBits == army.Empire.Bits)
{
if (!quest.QuestDefinition.SkipLockedQuestTarget)
{
available = true;
return(true);
}
flag = true;
}
}
if (pointOfInterest.UntappedDustDeposits && SimulationGlobal.GlobalTagsContains(SeasonManager.RuinDustDepositsTag))
{
return(true);
}
if (pointOfInterest.Interaction.IsLocked(army.Empire.Index, this.Name))
{
return(false);
}
IWorldPositionningService service2 = game.Services.GetService <IWorldPositionningService>();
if (service2 != null && service2.IsWaterTile(pointOfInterest.WorldPosition))
{
return(false);
}
global::Empire[] empires = game.Empires;
for (int i = 0; i < empires.Length; i++)
{
using (IEnumerator <Army> enumerator2 = empires[i].GetAgency <DepartmentOfDefense>().Armies.GetEnumerator())
{
while (enumerator2.MoveNext())
{
if (enumerator2.Current.WorldPosition == pointOfInterest.WorldPosition)
{
return(false);
}
}
}
}
if ((pointOfInterest.Interaction.Bits & army.Empire.Bits) == 0)
{
return(true);
}
available = true;
if (flag)
{
available = true;
return(true);
}
return(false);
}
protected override State Execute(AIBehaviorTree aiBehaviorTree, params object[] parameters)
{
Army army;
if (base.GetArmyUnlessLocked(aiBehaviorTree, "$Army", out army) != AIArmyMission.AIArmyMissionErrorCode.None)
{
return(State.Failure);
}
if (!aiBehaviorTree.Variables.ContainsKey(this.TargetVarName))
{
aiBehaviorTree.LogError("$Target not set {0}/{1}", new object[]
{
army.Empire,
army.LocalizedName
});
return(State.Failure);
}
IWorldPositionable worldPositionable = aiBehaviorTree.Variables[this.TargetVarName] as IWorldPositionable;
if (worldPositionable == null)
{
aiBehaviorTree.ErrorCode = 10;
return(State.Failure);
}
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>();
Diagnostics.Assert(service3 != null);
WorldPosition worldPosition;
if (worldPositionable is City)
{
City city = worldPositionable as City;
if (army.Empire != city.Empire)
{
worldPosition = this.NewDistrictToAttackCity(army, city);
}
else
{
District nearestDistrictToReinforce = this.GetNearestDistrictToReinforce(army, city);
if (nearestDistrictToReinforce == null)
{
aiBehaviorTree.ErrorCode = 2;
return(State.Failure);
}
worldPosition = nearestDistrictToReinforce.WorldPosition;
}
}
else if (worldPositionable is Fortress)
{
Fortress fortress = worldPositionable as Fortress;
WorldPosition worldPosition2 = worldPositionable.WorldPosition;
int num = service2.GetDistance(army.WorldPosition, worldPosition2);
foreach (PointOfInterest pointOfInterest in fortress.Facilities)
{
int distance = service2.GetDistance(army.WorldPosition, pointOfInterest.WorldPosition);
if (distance < num)
{
num = distance;
worldPosition2 = pointOfInterest.WorldPosition;
}
}
worldPosition = this.GetValidTileToAttack(service3, service2, worldPosition2, army);
}
else if (worldPositionable is Camp)
{
worldPosition = this.GetValidTileToAttack(service3, service2, worldPositionable.WorldPosition, army);
}
else if (worldPositionable is Village)
{
worldPosition = this.GetValidTileToAttack(service3, service2, worldPositionable.WorldPosition, army);
}
else if (worldPositionable is OrbSpawnInfo)
{
worldPosition = worldPositionable.WorldPosition;
}
else if (worldPositionable is MapBoostSpawnInfo)
{
worldPosition = worldPositionable.WorldPosition;
}
else if (worldPositionable is PointOfInterest)
{
worldPosition = this.GetValidTileToAttack(service3, service2, worldPositionable.WorldPosition, army);
}
else if (worldPositionable is Kaiju)
{
worldPosition = this.GetValidTileToAttack(service3, service2, worldPositionable.WorldPosition, army);
if (!worldPosition.IsValid && this.AllowBackupPosition)
{
worldPosition = worldPositionable.WorldPosition;
}
}
else if (worldPositionable is Army)
{
worldPosition = this.GetValidTileToAttack(service3, service2, worldPositionable.WorldPosition, army);
if (!worldPosition.IsValid && this.AllowBackupPosition)
{
worldPosition = worldPositionable.WorldPosition;
}
}
else if (service2.IsWaterTile(army.WorldPosition) != service2.IsWaterTile(worldPositionable.WorldPosition))
{
worldPosition = this.GetValidTileToAttack(service3, service2, worldPositionable.WorldPosition, army);
}
else
{
worldPosition = worldPositionable.WorldPosition;
}
if (worldPosition == WorldPosition.Invalid)
{
aiBehaviorTree.ErrorCode = 11;
return(State.Failure);
}
if (aiBehaviorTree.Variables.ContainsKey(this.Output_DestinationVarName))
{
aiBehaviorTree.Variables[this.Output_DestinationVarName] = worldPosition;
}
else
{
aiBehaviorTree.Variables.Add(this.Output_DestinationVarName, worldPosition);
}
return(State.Success);
}
