private static bool ValidateTarget(Army myArmy, IGameEntity gameEntity, DepartmentOfForeignAffairs departmentOfForeignAffairs, bool canAttack, IGameEntityRepositoryService gameEntityRepositoryService, IWorldPositionningService worldPositionningService)
{
if (gameEntity == null)
{
return(false);
}
if (!gameEntityRepositoryService.Contains(gameEntity.GUID))
{
return(false);
}
if (departmentOfForeignAffairs != null)
{
IGarrison garrison = gameEntity as IGarrison;
if (gameEntity is Kaiju)
{
garrison = (gameEntity as Kaiju).GetActiveTroops();
gameEntity = garrison;
}
IWorldPositionable worldPositionable = gameEntity as IWorldPositionable;
Region region = worldPositionningService.GetRegion(worldPositionable.WorldPosition);
if (garrison == null || worldPositionable == null)
{
return(false);
}
if (canAttack)
{
if (!departmentOfForeignAffairs.CanAttack(gameEntity) || garrison.Empire.Index == myArmy.Empire.Index)
{
return(false);
}
}
else if (!departmentOfForeignAffairs.IsEnnemy(garrison.Empire))
{
return(false);
}
if ((garrison.Empire is MinorEmpire || garrison is Village) && region != null && region.IsRegionColonized() && departmentOfForeignAffairs != null && departmentOfForeignAffairs.IsEnnemy(region.Owner))
{
return(false);
}
}
Army army = gameEntity as Army;
if (army != null)
{
if (myArmy.Empire is LesserEmpire && !(army.Empire is MajorEmpire))
{
return(false);
}
District district = worldPositionningService.GetDistrict(army.WorldPosition);
if (district != null && district.Type != DistrictType.Exploitation && army.Empire == district.Empire)
{
return(false);
}
if (!myArmy.HasSeafaringUnits() && army.IsNaval)
{
return(false);
}
}
return(true);
}
public virtual void Bind(IGarrison garrison, IGarrison militia = null, GameObject parent = null)
{
this.Unbind();
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.IsOtherEmpire = (service.ActivePlayerController.Empire != garrison.Empire);
this.Garrison = garrison;
this.Militia = militia;
this.guiUnits.Clear();
for (int i = 0; i < this.Garrison.StandardUnits.Count; i++)
{
this.guiUnits.Add(new GuiUnit(this.Garrison.StandardUnits[i], null));
}
if (this.Militia != null)
{
for (int j = 0; j < this.Militia.StandardUnits.Count; j++)
{
this.guiUnits.Add(new GuiUnit(this.Militia.StandardUnits[j], null));
}
}
this.DepartmentOfTheTreasury = this.Garrison.Empire.GetAgency <DepartmentOfTheTreasury>();
this.DepartmentOfScience = this.Garrison.Empire.GetAgency <DepartmentOfScience>();
Diagnostics.Assert(this.Garrison.Empire != null, "Garrison has not assigned Empire");
this.departmentOfDefense = this.Garrison.Empire.GetAgency <DepartmentOfDefense>();
this.departmentOfTheInterior = this.Garrison.Empire.GetAgency <DepartmentOfTheInterior>();
this.parent = parent;
}
private bool TransferUnits(GameEntityGUID destinationGuid)
{
AIData_Army aidata = this.aiDataRepository.GetAIData <AIData_Army>(base.AIDataArmyGUID);
if (aidata.Army.IsInEncounter || aidata.Army.IsLocked)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer source IsInEncounter or IsLocked");
return(false);
}
IGameEntity gameEntity;
if (!this.gameEntityRepositoryService.TryGetValue(destinationGuid, out gameEntity))
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Destination Guid is not valid");
return(false);
}
IGarrison garrison = gameEntity as IGarrison;
if (garrison == null)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Destination Guid is not a Garrison");
return(false);
}
if (garrison.IsInEncounter)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer destination IsInEncounter");
return(false);
}
if (garrison is Army)
{
Army army = garrison as Army;
if (army.IsLocked)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer destination IsLocked");
return(false);
}
if (this.worldPositionningService.GetDistance(aidata.Army.WorldPosition, army.WorldPosition) != 1 || !this.pathfindingService.IsTransitionPassable(aidata.Army.WorldPosition, army.WorldPosition, aidata.Army, (PathfindingFlags)0, null))
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer destination is not valid");
return(false);
}
}
GameEntityGUID[] array = null;
this.ClampUnitToGarrison(garrison, this.UnitGuids, out array);
if (array != null && array.Length != 0)
{
OrderTransferUnits order = new OrderTransferUnits(base.Commander.Empire.Index, base.AIDataArmyGUID, destinationGuid, array, false);
base.Commander.Empire.PlayerControllers.Server.PostOrder(order, out this.currentTicket, new EventHandler <TicketRaisedEventArgs>(this.OrderTransferUnitToArmyTicketRaised));
if (aidata.CommanderMission != this)
{
Diagnostics.LogWarning("LOCKING: [AICommanderMission_RegroupArmyAt] Strange desynchronization between the actual Army CommanderMission and the current CommanderMission");
}
aidata.UnassignCommanderMission();
return(true);
}
return(false);
}
protected bool IsCloseEnoughToAttack(Army army, IGarrison target)
{
City city = target as City;
District district = target as District;
if (district != null)
{
city = district.City;
}
if (city != null && army.IsNaval)
{
District district2 = this.worldPositionService.GetDistrict(army.WorldPosition);
return(district2 != null && district2.City == city);
}
Fortress fortress = target as Fortress;
if (fortress != null)
{
if (this.worldPositionService.GetDistance(army.WorldPosition, fortress.WorldPosition) == 1 && this.pathfindingService.IsTransitionPassable(army.WorldPosition, fortress.WorldPosition, army, OrderAttack.AttackFlags, null))
{
return(true);
}
for (int i = 0; i < fortress.Facilities.Count; i++)
{
if (this.worldPositionService.GetDistance(army.WorldPosition, fortress.Facilities[i].WorldPosition) == 1 && this.pathfindingService.IsTransitionPassable(army.WorldPosition, fortress.Facilities[i].WorldPosition, army, OrderAttack.AttackFlags, null))
{
return(true);
}
}
}
IGameEntityWithWorldPosition gameEntityWithWorldPosition = target as IGameEntityWithWorldPosition;
if (gameEntityWithWorldPosition != null)
{
if (this.worldPositionService.GetDistance(army.WorldPosition, gameEntityWithWorldPosition.WorldPosition) > 1)
{
return(false);
}
if (army.IsSeafaring && !this.worldPositionService.IsOceanTile(gameEntityWithWorldPosition.WorldPosition))
{
return(false);
}
if (this.worldPositionService.IsWaterTile(army.WorldPosition) != this.worldPositionService.IsWaterTile(gameEntityWithWorldPosition.WorldPosition))
{
return(false);
}
if (this.pathfindingService.IsTransitionPassable(army.WorldPosition, gameEntityWithWorldPosition.WorldPosition, army, OrderAttack.AttackFlags, null))
{
return(true);
}
}
return(false);
}
private int GetSettlerCount(IGarrison garrison)
{
int num = 0;
for (int i = 0; i < garrison.StandardUnits.Count; i++)
{
if (garrison.StandardUnits[i].IsSettler)
{
num++;
}
}
return(num);
}
private void ClampUnitToGarrison(IGarrison currentTarget, GameEntityGUID[] unitListCandidate, out GameEntityGUID[] unitsToGarrison)
{
int val = Math.Max(0, currentTarget.MaximumUnitSlot - currentTarget.CurrentUnitSlot);
int num = Math.Min(unitListCandidate.Length, val);
if (num <= 0)
{
unitsToGarrison = null;
return;
}
unitsToGarrison = new GameEntityGUID[num];
int num2 = 0;
while (num2 < unitListCandidate.Length && num2 != num)
{
unitsToGarrison[num2] = unitListCandidate[num2];
num2++;
}
}
protected override State Execute(AIBehaviorTree aiBehaviorTree, params object[] parameters)
{
if (this.ticket != null)
{
if (!this.ticket.Raised)
{
return(State.Running);
}
if (this.ticket.PostOrderResponse == PostOrderResponse.PreprocessHasFailed)
{
this.ticket = null;
aiBehaviorTree.ErrorCode = 1;
return(State.Failure);
}
this.ticket = null;
return(State.Success);
}
else
{
Army army;
if (base.GetArmyUnlessLocked(aiBehaviorTree, "$Army", out army) != AIArmyMission.AIArmyMissionErrorCode.None)
{
return(State.Failure);
}
if (!aiBehaviorTree.Variables.ContainsKey(this.TargetVarName))
{
aiBehaviorTree.LogError("${0} not set", new object[]
{
this.TargetVarName
});
return(State.Failure);
}
IGameEntity gameEntity = aiBehaviorTree.Variables[this.TargetVarName] as IGameEntity;
if (!(gameEntity is IWorldPositionable))
{
return(State.Failure);
}
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
if (!service.Game.Services.GetService <IGameEntityRepositoryService>().Contains(gameEntity.GUID))
{
return(State.Success);
}
IEncounterRepositoryService service2 = service.Game.Services.GetService <IEncounterRepositoryService>();
if (service2 != null)
{
IEnumerable <Encounter> enumerable = service2;
if (enumerable != null && enumerable.Any((Encounter encounter) => encounter.IsGarrisonInEncounter(army.GUID, false)))
{
return(State.Running);
}
}
IGarrison garrison = gameEntity as IGarrison;
if (gameEntity is Kaiju)
{
garrison = (gameEntity as Kaiju).GetActiveTroops();
}
if (garrison == null)
{
return(State.Failure);
}
if (garrison.Empire.Index == aiBehaviorTree.AICommander.Empire.Index)
{
return(State.Failure);
}
GameEntityGUID guid = gameEntity.GUID;
if (!aiBehaviorTree.Variables.ContainsKey(this.PathVarName))
{
aiBehaviorTree.LogError("{0} not set", new object[]
{
this.PathVarName
});
return(State.Failure);
}
WorldPath worldPath = aiBehaviorTree.Variables[this.PathVarName] as WorldPath;
if (worldPath == null || worldPath.Length < 2)
{
aiBehaviorTree.LogError("Path is null.", new object[0]);
aiBehaviorTree.ErrorCode = 3;
return(State.Failure);
}
if (!worldPath.IsValid)
{
aiBehaviorTree.ErrorCode = 3;
return(State.Failure);
}
if (!aiBehaviorTree.Variables.ContainsKey(this.ArmyActionVarName))
{
aiBehaviorTree.LogError("${0} not set", new object[]
{
this.ArmyActionVarName
});
return(State.Failure);
}
OrderGoToAndExecute orderGoToAndExecute = new OrderGoToAndExecute(army.Empire.Index, army.GUID, this.ArmyActionVarName, worldPath.Destination, guid);
orderGoToAndExecute.Flags = (PathfindingFlags)0;
aiBehaviorTree.AICommander.Empire.PlayerControllers.AI.PostOrder(orderGoToAndExecute, out this.ticket, null);
return(State.Running);
}
}
protected override bool TryGetArmyData()
{
if (this.createFirstArmyTicket != null)
{
return(false);
}
if (base.AIDataArmyGUID.IsValid)
{
return(true);
}
if (this.currentTicket != null)
{
return(false);
}
IGameEntity gameEntity;
if (!this.gameEntityRepositoryService.TryGetValue(this.SourceGuid, out gameEntity))
{
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
for (int i = this.UnitGuids.Length - 1; i >= 0; i--)
{
AIData_Unit aidata_Unit;
this.aiDataRepository.TryGetAIData <AIData_Unit>(this.UnitGuids[i], out aidata_Unit);
if (aidata_Unit == null)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] no AIData for Unit {0}", new object[]
{
this.UnitGuids[i].ToString()
});
}
else
{
if (aidata_Unit.IsUnitLocked() && !aidata_Unit.IsUnitLockedByMe(base.InternalGUID))
{
WorldPosition worldPosition = WorldPosition.Invalid;
if (aidata_Unit.Unit.Garrison is IWorldPositionable)
{
worldPosition = (aidata_Unit.Unit.Garrison as IWorldPositionable).WorldPosition;
}
Diagnostics.LogWarning(string.Format("{1} {2} LOCKING: Unit shouldn't be in use, current unit state: {0}", aidata_Unit.GetLockingStateString(), base.Commander.Empire, worldPosition));
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
if (aidata_Unit.Unit.UnitDesign.Tags.Contains(DownloadableContent9.TagSolitary))
{
Diagnostics.LogWarning("You cannot regroup Colossus or Solitary unit with something else.");
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
}
}
IGarrison garrison = gameEntity as IGarrison;
if (garrison == null)
{
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
if (this.AICommanderRegroupArmies != null && this.AICommanderRegroupArmies.RequestUnitListMessageID != 0UL)
{
RequestUnitListMessage requestUnitListMessage = base.Commander.AIPlayer.Blackboard.GetMessage(this.AICommanderRegroupArmies.RequestUnitListMessageID) as RequestUnitListMessage;
if (requestUnitListMessage == null)
{
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
requestUnitListMessage.ExecutionState = RequestUnitListMessage.RequestUnitListState.Regrouping;
}
bool flag = false;
for (int j = 0; j < this.UnitGuids.Length; j++)
{
if (!garrison.ContainsUnit(this.UnitGuids[j]))
{
flag = true;
break;
}
}
if (flag)
{
List <GameEntityGUID> list = new List <GameEntityGUID>();
for (int k = 0; k < this.UnitGuids.Length; k++)
{
if (garrison.ContainsUnit(this.UnitGuids[k]))
{
list.Add(this.UnitGuids[k]);
}
}
this.UnitGuids = list.ToArray();
}
if (this.UnitGuids.Length == 0)
{
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
WorldPosition armyPosition = WorldPosition.Invalid;
Army army = gameEntity as Army;
if (army != null)
{
AIData_Army aidata = this.aiDataRepository.GetAIData <AIData_Army>(gameEntity.GUID);
Diagnostics.Assert(aidata != null);
if (army.GetPropertyValue(SimulationProperties.Movement) <= 0f)
{
return(false);
}
if (aidata.CommanderMission != null)
{
aidata.CommanderMission.Interrupt();
}
if (aidata.Army.IsInEncounter || aidata.Army.IsLocked)
{
return(false);
}
if (aidata.Army.StandardUnits.Count != this.UnitGuids.Length)
{
armyPosition = AILayer_ArmyRecruitment.GetValidArmySpawningPosition(aidata.Army, this.worldPositionningService, this.pathfindingService);
int num = (int)base.Commander.Empire.GetPropertyValue(SimulationProperties.ArmyUnitSlot);
if (aidata.Army.StandardUnits.Count > num)
{
Array.Resize <GameEntityGUID>(ref this.UnitGuids, num);
}
}
else
{
if (!aidata.AssignCommanderMission(this))
{
base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
return(false);
}
base.AIDataArmyGUID = gameEntity.GUID;
return(true);
}
}
else if (gameEntity is Village)
{
Village village = gameEntity as Village;
if (village.IsInEncounter)
{
return(false);
}
WorldPosition worldPosition2 = village.WorldPosition;
WorldOrientation worldOrientation = WorldOrientation.East;
if (this.AICommanderRegroupArmies.FinalPosition.IsValid)
{
worldOrientation = this.worldPositionningService.GetOrientation(worldPosition2, this.AICommanderRegroupArmies.FinalPosition);
}
for (int l = 0; l < 6; l++)
{
WorldPosition neighbourTile = this.worldPositionningService.GetNeighbourTile(worldPosition2, worldOrientation, 1);
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(neighbourTile, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water) && this.pathfindingService.IsTransitionPassable(village.WorldPosition, neighbourTile, this.pathfindingContext, PathfindingFlags.IgnoreFogOfWar, null) && this.pathfindingService.IsTilePassable(neighbourTile, this.pathfindingContext, (PathfindingFlags)0, null) && this.pathfindingService.IsTileStopable(neighbourTile, this.pathfindingContext, (PathfindingFlags)0, null))
{
if (this.worldPositionningService.GetArmyAtPosition(neighbourTile) == null)
{
armyPosition = neighbourTile;
break;
}
}
else
{
worldOrientation = worldOrientation.Rotate(1);
}
}
}
else if (gameEntity is City)
{
City city = gameEntity as City;
if (city.IsInEncounter)
{
return(false);
}
if (!DepartmentOfTheInterior.TryGetWorldPositionForNewArmyFromCity(city, this.pathfindingService, this.pathfindingContext, out armyPosition))
{
return(false);
}
}
else
{
Diagnostics.LogError(string.Format("[AICommanderMission_RegroupArmyAt] The garrison {0} is not valid.", garrison.GUID));
}
if (armyPosition.IsValid)
{
if (army != null && army.WorldPath != null && army.WorldPath.Destination != army.WorldPosition)
{
OrderGoTo orderGoTo = new OrderGoTo(army.Empire.Index, army.GUID, army.WorldPosition);
orderGoTo.Flags = (PathfindingFlags)0;
base.Commander.Empire.PlayerControllers.AI.PostOrder(orderGoTo, out this.currentTicket, new EventHandler <TicketRaisedEventArgs>(this.MoveOrder_TicketRaised));
if (this.currentTicket != null)
{
return(false);
}
if (!this.orderExecuted)
{
Diagnostics.LogError("[AICommanderMission_RegroupArmyAt] new cancelation move order was not executed, from {0} to {1}", new object[]
{
army.WorldPosition,
army.WorldPosition
});
return(false);
}
}
for (int m = 0; m < this.UnitGuids.Length; m++)
{
AIData_Unit aidata_Unit2;
this.aiDataRepository.TryGetAIData <AIData_Unit>(this.UnitGuids[m], out aidata_Unit2);
if (aidata_Unit2 == null)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] no AIData for Unit {0}", new object[]
{
this.UnitGuids[m].ToString()
});
}
else if (!aidata_Unit2.IsUnitLockedByMe(base.InternalGUID))
{
aidata_Unit2.TryLockUnit(base.InternalGUID, base.GetType().ToString(), AIData_Unit.AIDataReservationExtraTag.Regrouping, base.Commander.GetPriority(this));
}
}
OrderTransferGarrisonToNewArmy order = new OrderTransferGarrisonToNewArmy(base.Commander.Empire.Index, this.SourceGuid, this.UnitGuids, armyPosition, "Regroup", false, true, true);
base.Commander.Empire.PlayerControllers.Server.PostOrder(order, out this.createFirstArmyTicket, new EventHandler <TicketRaisedEventArgs>(this.OrderTransferUnitToNewArmyTicketRaised));
}
return(false);
}
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);
}
private void RecruitArmiesUnits(RequestUnitListMessage requestUnitListMessage, Intelligence.BestRecruitementCombination bestRecruits)
{
IAIDataRepositoryAIHelper service = AIScheduler.Services.GetService <IAIDataRepositoryAIHelper>();
this.unitsGUIDS.Clear();
for (int i = 0; i < bestRecruits.CombinationOfArmiesUnits.Count; i++)
{
AIData_GameEntity aidata_GameEntity = bestRecruits.CombinationOfArmiesUnits[i];
if (aidata_GameEntity is AIData_Army)
{
AIData_Army aidata_Army = aidata_GameEntity as AIData_Army;
if (aidata_Army.Army == null)
{
AILayer.LogWarning(string.Format("[AILayer_ArmyRecruitment.UnitAssignation] Army was not found, was it destroyed?", new object[0]));
}
else
{
if (aidata_Army.CommanderMission != null)
{
aidata_Army.CommanderMission.Interrupt();
}
for (int j = 0; j < aidata_Army.Army.StandardUnits.Count; j++)
{
Unit unit = aidata_Army.Army.StandardUnits[j];
AIData_Unit aidata_Unit;
if (service.TryGetAIData <AIData_Unit>(unit.GUID, out aidata_Unit))
{
this.unitsGUIDS.Add(unit.GUID);
aidata_Unit.ClearLock();
aidata_Unit.TryLockUnit(base.InternalGUID, base.GetType().ToString(), AIData_Unit.AIDataReservationExtraTag.ArmyRecruitment, requestUnitListMessage.Priority);
}
}
}
}
else if (aidata_GameEntity is AIData_Unit)
{
AIData_Unit aidata_Unit2 = aidata_GameEntity as AIData_Unit;
Unit unit2 = aidata_Unit2.Unit;
if (unit2 == null || unit2.Garrison == null)
{
AILayer.LogWarning(string.Format("[AILayer_ArmyRecruitment.UnitAssignation] Unit was not found, was it destroyed?", new object[0]));
}
else
{
this.unitsGUIDS.Add(unit2.GUID);
if (aidata_Unit2.IsUnitLocked() && !aidata_Unit2.IsUnitLockedByMe(base.InternalGUID))
{
IGarrison garrison = unit2.Garrison;
if (garrison is Army)
{
Army army = garrison as Army;
AIData_Army aidata = service.GetAIData <AIData_Army>(army.GUID);
if (aidata == null)
{
AILayer.LogWarning(string.Format("[AILayer_ArmyRecruitment.UnitAssignation] Army was not found, was it destroyed?", new object[0]));
}
else if (aidata.CommanderMission != null)
{
aidata.CommanderMission.Interrupt();
}
else
{
AILayer.LogWarning(string.Format("[AILayer_ArmyRecruitment.UnitAssignation] Although unit is locked, Army commander mission was not found.", new object[0]));
aidata_Unit2.ClearLock();
}
}
else if (garrison is City)
{
aidata_Unit2.ClearLock();
}
else
{
aidata_Unit2.ClearLock();
}
}
aidata_Unit2.TryLockUnit(base.InternalGUID, base.GetType().ToString(), AIData_Unit.AIDataReservationExtraTag.ArmyRecruitment, requestUnitListMessage.Priority);
}
}
else
{
AILayer.LogError("[AILayer_ArmyRecruitment.UnitAssignation] Unknown GameEntity Type {0}", new object[]
{
aidata_GameEntity.GetType().ToString()
});
}
}
if (this.unitsGUIDS.Count != 0)
{
this.CreateNewCommanderRegroup(this.unitsGUIDS.ToArray(), requestUnitListMessage);
requestUnitListMessage.ExecutionState = RequestUnitListMessage.RequestUnitListState.Regrouping;
}
}
