protected bool HasSecondaryTarget(BaseNavyArmy army)
{
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return(false);
}
if (navyArmy.SecondaryTarget == null)
{
return(false);
}
if (navyArmy.SecondaryTarget.Type == BehaviorOpportunity.OpportunityType.Ruin)
{
PointOfInterest pointOfInterest = this.worldPositionService.GetPointOfInterest(navyArmy.SecondaryTarget.OpportunityPosition);
if (!this.CouldSearch(army, pointOfInterest))
{
navyArmy.SecondaryTarget = null;
}
}
else if (navyArmy.SecondaryTarget.Type == BehaviorOpportunity.OpportunityType.Orbs)
{
IOrbAIHelper service = AIScheduler.Services.GetService <IOrbAIHelper>();
OrbSpawnInfo orbSpawnInfo;
if (!service.TryGetOrbSpawnInfoAt(navyArmy.SecondaryTarget.OpportunityPosition, out orbSpawnInfo) || orbSpawnInfo.CurrentOrbCount == 0f)
{
navyArmy.SecondaryTarget = null;
}
}
else if (navyArmy.SecondaryTarget.Score <= 0.1f)
{
navyArmy.SecondaryTarget = null;
}
return(navyArmy.SecondaryTarget != null);
}
protected bool CouldSearch(BaseNavyArmy army, PointOfInterest pointOfInterest)
{
if (pointOfInterest == null)
{
return(false);
}
if (pointOfInterest.Type != "QuestLocation" && pointOfInterest.Type != "NavalQuestLocation")
{
return(false);
}
if (pointOfInterest.Interaction.IsLocked(army.Garrison.Empire.Index, "ArmyActionSearch"))
{
return(false);
}
if ((pointOfInterest.Interaction.Bits & army.Garrison.Empire.Bits) == army.Garrison.Empire.Bits)
{
return(false);
}
if ((pointOfInterest.Interaction.Bits & army.Garrison.Empire.Bits) != 0)
{
foreach (QuestMarker questMarker in this.questManagementService.GetMarkersByBoundTargetGUID(pointOfInterest.GUID))
{
if (questMarker.IsVisibleFor(army.Garrison.Empire))
{
return(false);
}
}
return(true);
}
return(true);
}
public BehaviorNodeReturnCode SelectBestOpportunity(BaseNavyArmy army)
{
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return(BehaviorNodeReturnCode.Failure);
}
float num = 0.1f;
BehaviorOpportunity secondaryTarget = null;
for (int i = 0; i < navyArmy.Opportunities.Count; i++)
{
if (navyArmy.Opportunities[i].Score > num)
{
num = navyArmy.Opportunities[i].Score;
secondaryTarget = navyArmy.Opportunities[i];
}
}
navyArmy.SecondaryTarget = secondaryTarget;
if (navyArmy.SecondaryTarget == null)
{
return(BehaviorNodeReturnCode.Failure);
}
return(BehaviorNodeReturnCode.Success);
}
public Amplitude.Unity.Game.Orders.Order CreateArmyFromMixedArmy(BaseNavyArmy army)
{
if (!this.IsMixed(army))
{
return(null);
}
if (!base.HasMovementLeft(army))
{
return(null);
}
WorldPosition armyPosition = WorldPosition.Invalid;
PathfindingMovementCapacity movementCapacity = PathfindingMovementCapacity.Water;
for (int i = 0; i < 6; i++)
{
WorldPosition neighbourTile = this.worldPositionService.GetNeighbourTile(army.Garrison.WorldPosition, (WorldOrientation)i, 1);
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(neighbourTile, movementCapacity))
{
armyPosition = neighbourTile;
break;
}
}
bool flag = false;
List <GameEntityGUID> list = new List <GameEntityGUID>();
for (int j = 0; j < army.Garrison.StandardUnits.Count; j++)
{
if (flag == army.Garrison.StandardUnits[j].IsSeafaring)
{
list.Add(army.Garrison.StandardUnits[j].GUID);
}
}
return(new OrderTransferGarrisonToNewArmy(army.Garrison.Empire.Index, army.Garrison.GUID, list.ToArray(), armyPosition, null, false, true, true));
}
private WorldPosition GetRandomRoamingPosition(BaseNavyArmy army, Func <WorldPosition, bool> whiteFilter = null)
{
int num = 0;
WorldPosition result = WorldPosition.Invalid;
int num2 = (int)army.Garrison.GUID;
System.Random random = new System.Random(num2 + army.Commander.RegionData.WaterRegionIndex);
Region region = this.worldPositionService.GetRegion(army.Commander.RegionData.WaterRegionIndex);
for (int i = 0; i < region.Borders.Length; i++)
{
int num3 = random.Next(3, 10);
Region.Border border = region.Borders[i];
for (int j = 0; j < border.WorldPositions.Length; j += num3)
{
if (whiteFilter == null || whiteFilter(border.WorldPositions[j]))
{
int distance = this.worldPositionService.GetDistance(army.Garrison.WorldPosition, border.WorldPositions[j]);
if (num < distance)
{
num = distance;
result = border.WorldPositions[j];
}
}
}
}
return(result);
}
public override NavyTaskEvaluation ComputeFitness(BaseNavyArmy navyGarrison)
{
NavyTaskEvaluation navyTaskEvaluation = new NavyTaskEvaluation();
navyTaskEvaluation.Fitness = new HeuristicValue(0f);
navyTaskEvaluation.Task = this;
if (navyGarrison.Garrison.GetPropertyValue(SimulationProperties.CityDefensePointLossPerTurn) <= 0f)
{
navyTaskEvaluation.Fitness.Value = -1f;
navyTaskEvaluation.Fitness.Log("Avoid using army without fortification damage.", new object[0]);
}
else
{
navyTaskEvaluation.Fitness.Add(1f, "(constant)", new object[0]);
float propertyValue = this.Target.GetPropertyValue(SimulationProperties.DefensivePower);
float propertyValue2 = this.Target.GetPropertyValue(SimulationProperties.CoastalDefensivePower);
if (propertyValue + propertyValue2 > 0f)
{
float num = (propertyValue + propertyValue2) / (float)navyGarrison.Garrison.UnitsCount;
using (IEnumerator <Unit> enumerator = navyGarrison.Garrison.Units.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (enumerator.Current.GetPropertyValue(SimulationProperties.Health) - num < num * 2f)
{
navyTaskEvaluation.Fitness.Subtract(0.2f, "(constant) Retaliation will kill units.", new object[0]);
}
}
}
}
float numberOfTurnToReach = (float)this.worldPositionService.GetDistance(navyGarrison.Garrison.WorldPosition, this.Target.WorldPosition) / navyGarrison.GetMaximumMovement();
navyTaskEvaluation.Fitness.Multiply(base.ComputeDistanceFitness(numberOfTurnToReach, navyGarrison.Role), "Distance", new object[0]);
}
return(navyTaskEvaluation);
}
public Amplitude.Unity.Game.Orders.Order Bombard(BaseNavyArmy army)
{
if (army.MainAttackableTarget == null)
{
return(null);
}
return(new OrderToggleNavalSiege(army.Garrison.Empire.Index, army.MainAttackableTarget.GUID, army.Garrison.GUID, true));
}
public Amplitude.Unity.Game.Orders.Order MoveToRoaming(BaseNavyArmy army)
{
if (!base.HasMovementLeft(army))
{
return(null);
}
return(base.FollowPath(army, army.PathToRoamingPosition));
}
protected bool IsOpportunityGoodEnough(BaseNavyArmy army)
{
if (!this.HasSecondaryTarget(army))
{
return(false);
}
NavyArmy navyArmy = army as NavyArmy;
return(navyArmy != null && this.IsDetourWorthChecking(army, navyArmy.SecondaryTarget.OpportunityPosition));
}
public override NavyTaskEvaluation ComputeFitness(BaseNavyArmy navyGarrison)
{
HeuristicValue taskFitness = this.GetTaskFitness(navyGarrison);
return(new NavyTaskEvaluation
{
Fitness = taskFitness,
Task = this
});
}
public BehaviorNodeReturnCode ChooseRoamingPosition(BaseNavyArmy army)
{
WorldPosition randomRoamingPosition = this.GetRandomRoamingPosition(army, null);
if (randomRoamingPosition.IsValid)
{
army.RoamingNextPosition = randomRoamingPosition;
return(BehaviorNodeReturnCode.Success);
}
return(BehaviorNodeReturnCode.Failure);
}
private bool NearCommanderRegion(BaseNavyArmy army, WorldPosition position)
{
BaseNavyCommander commander = army.Commander;
if (commander == null || commander.RegionData == null)
{
return(true);
}
Region positionRegion = this.worldPositionService.GetRegion(position);
return(commander.RegionData.WaterRegionIndex == positionRegion.Index || commander.RegionData.NeighbouringLandRegions.Exists((Region match) => match.Index == positionRegion.Index) || commander.RegionData.NeighbouringWaterRegions.Exists((Region match) => match.Index == positionRegion.Index));
}
private HeuristicValue GetTaskFitness(BaseNavyArmy navyGarrison)
{
HeuristicValue heuristicValue = new HeuristicValue(0f);
base.Owner.GetAgency <DepartmentOfForeignAffairs>();
if (navyGarrison.Garrison.GUID == base.TargetGuid)
{
heuristicValue.Value = -1f;
heuristicValue.Log("Cannot reinforce itself.", new object[0]);
}
else if (navyGarrison.Role == BaseNavyArmy.ArmyRole.Land || navyGarrison.Role == BaseNavyArmy.ArmyRole.Forteress || navyGarrison.Role == BaseNavyArmy.ArmyRole.Convoi)
{
heuristicValue.Value = -1f;
heuristicValue.Log("Role is not valid for the task. Role={0}.", new object[]
{
navyGarrison.Role.ToString()
});
}
else if (navyGarrison.Garrison.StandardUnits.Count == 0)
{
heuristicValue.Value = -1f;
heuristicValue.Log("Army is empty, cannot be used as reinforcement.", new object[0]);
}
else
{
heuristicValue.Add(this.NavyFortress.WantToKeepArmyFitness, "Fortress army need", new object[0]);
if (navyGarrison.Role == BaseNavyArmy.ArmyRole.TaskForce)
{
heuristicValue.Boost(-0.1f, "constant avoid reinforce while task force.", new object[0]);
float num = (float)navyGarrison.Garrison.CurrentUnitSlot;
float operand = Math.Abs((float)this.ReinforcementSlots - num);
HeuristicValue heuristicValue2 = new HeuristicValue(0f);
heuristicValue2.Add(operand, "ABS(TaskSlotNeeded - armySize)", new object[0]);
heuristicValue2.Divide(num, "Army size", new object[0]);
heuristicValue.Subtract(heuristicValue2, "Size ratio", new object[0]);
}
if (heuristicValue.Value > 0f)
{
if (this.NavyFortress.ArmySize < BaseNavyArmy.ArmyState.Medium)
{
heuristicValue.Boost(0.2f, "(constant)Under medium", new object[0]);
}
else if (this.NavyFortress.ArmySize < BaseNavyArmy.ArmyState.High)
{
heuristicValue.Boost(0.1f, "(constant)Under high", new object[0]);
}
float numberOfTurnToReach = (float)this.worldPositionService.GetDistance(navyGarrison.Garrison.WorldPosition, this.NavyFortress.Garrison.WorldPosition) / navyGarrison.GetMaximumMovement();
heuristicValue.Multiply(base.ComputeDistanceFitness(numberOfTurnToReach, navyGarrison.Role), "Distance", new object[0]);
}
}
return(heuristicValue);
}
protected BehaviorNodeReturnCode CollectOpportunityArmies(BaseNavyArmy army)
{
Army navy = army.Garrison as Army;
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null || navy == null || !(navy.Empire is MajorEmpire))
{
return(BehaviorNodeReturnCode.Failure);
}
float num = navy.GetPropertyValue(SimulationProperties.Movement);
if (num < 0.01f)
{
num = 1f;
}
List <IGarrison> list = new List <IGarrison>();
DepartmentOfForeignAffairs agency = navy.Empire.GetAgency <DepartmentOfForeignAffairs>();
AILayer_Military.HasSaveAttackableTargetsNearby(navy, Mathf.CeilToInt(num), agency, out list, true);
if (list.Count == 0)
{
return(BehaviorNodeReturnCode.Failure);
}
list.Sort((IGarrison left, IGarrison right) => this.worldPositionService.GetDistance((left as IWorldPositionable).WorldPosition, navy.WorldPosition).CompareTo(this.worldPositionService.GetDistance((right as IWorldPositionable).WorldPosition, navy.WorldPosition)));
foreach (IGarrison garrison in list)
{
IGameEntityWithWorldPosition gameEntityWithWorldPosition = garrison as IGameEntityWithWorldPosition;
IGarrisonWithPosition garrisonWithPosition = garrison as IGarrisonWithPosition;
if (gameEntityWithWorldPosition != null && garrisonWithPosition != null)
{
WorldPosition validTileToAttack = base.GetValidTileToAttack(army, gameEntityWithWorldPosition);
navyArmy.PathToSecondaryTarget = base.ComputePathToPosition(army, validTileToAttack, navyArmy.PathToSecondaryTarget);
if (navyArmy.PathToSecondaryTarget != null)
{
if (navyArmy.PathToSecondaryTarget.ControlPoints != null && navyArmy.PathToSecondaryTarget.ControlPoints.Length != 0)
{
return(BehaviorNodeReturnCode.Failure);
}
Diagnostics.Log("ELCP {0}/{1} found opportunitytarget {2} with path {3}", new object[]
{
navy.Empire,
navy.LocalizedName,
garrison.LocalizedName,
navyArmy.PathToSecondaryTarget
});
navyArmy.OpportunityAttackableTarget = garrisonWithPosition;
return(BehaviorNodeReturnCode.Success);
}
}
}
return(BehaviorNodeReturnCode.Failure);
}
public BehaviorNodeReturnCode GatherOpportunities(BaseNavyArmy army)
{
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return(BehaviorNodeReturnCode.Failure);
}
navyArmy.Opportunities.Clear();
this.ComputeOpportunityScore_PointOfInterest(army);
this.ComputeOpportunityScore_Orbs(army);
navyArmy.Opportunities.Sort((BehaviorOpportunity left, BehaviorOpportunity right) => - 1 * left.Score.CompareTo(right.Score));
return(BehaviorNodeReturnCode.Success);
}
public Amplitude.Unity.Game.Orders.Order MoveToSafe(BaseNavyArmy army)
{
if (!base.HasMovementLeft(army))
{
return(null);
}
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return(null);
}
return(base.FollowPath(army, navyArmy.PathToSafePosition));
}
public BehaviorNodeReturnCode ComputePathToRoaming(BaseNavyArmy army)
{
if (!this.HasValidRoamingPosition(army))
{
return(BehaviorNodeReturnCode.Failure);
}
army.PathToRoamingPosition = base.ComputePathToPosition(army, army.RoamingNextPosition, army.PathToRoamingPosition);
if (army.PathToRoamingPosition == null)
{
army.RoamingNextPosition = WorldPosition.Invalid;
return(BehaviorNodeReturnCode.Failure);
}
return(BehaviorNodeReturnCode.Success);
}
public Amplitude.Unity.Game.Orders.Order MoveSecondary(BaseNavyArmy army)
{
if (!base.HasMovementLeft(army))
{
return(null);
}
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return(null);
}
return(base.FollowPath(army, navyArmy.PathToSecondaryTarget));
}
public override NavyTaskEvaluation ComputeFitness(BaseNavyArmy navyGarrison)
{
NavyTaskEvaluation navyTaskEvaluation = new NavyTaskEvaluation();
navyTaskEvaluation.Fitness = new HeuristicValue(0f);
navyTaskEvaluation.Task = this;
if (base.ForbiddenGUIDs.Contains(navyGarrison.Garrison.GUID))
{
return(navyTaskEvaluation);
}
if (navyGarrison.Role == BaseNavyArmy.ArmyRole.Land || navyGarrison.Role == BaseNavyArmy.ArmyRole.Convoi)
{
navyTaskEvaluation.Fitness.Value = -1f;
navyTaskEvaluation.Fitness.Log("Role is not valid for the task. Role={0}.", new object[]
{
navyGarrison.Role.ToString()
});
}
else
{
float enemyPower = this.GetEnemyPower();
float propertyValue = navyGarrison.Garrison.GetPropertyValue(SimulationProperties.MilitaryPower);
navyTaskEvaluation.Fitness.Add(base.ComputePowerFitness(enemyPower, propertyValue), "MilitaryPower", new object[0]);
if (navyTaskEvaluation.Fitness > 0f)
{
WorldPosition targetPosition = this.GetTargetPosition();
float num = (float)this.worldPositionService.GetDistance(navyGarrison.Garrison.WorldPosition, targetPosition) / navyGarrison.GetMaximumMovement();
HeuristicValue operand = base.ComputeDistanceFitness(num, navyGarrison.Role);
navyTaskEvaluation.Fitness.Multiply(operand, "Distance", new object[0]);
if (num <= 1f && propertyValue > enemyPower * 1.2f)
{
navyTaskEvaluation.Fitness.Boost(0.9f, "Distance", new object[0]);
}
if (navyGarrison.Role == BaseNavyArmy.ArmyRole.Forteress)
{
navyTaskEvaluation.Fitness.Boost(-0.2f, "Fortress...", new object[0]);
}
else if (navyGarrison.Garrison.GetPropertyValue(SimulationProperties.ActionPointsSpent) > 0f)
{
navyTaskEvaluation.Fitness.Boost(-0.2f, "No more action point...", new object[0]);
}
}
}
if (base.AssignedArmy == navyGarrison)
{
navyTaskEvaluation.Fitness.Boost(0.2f, "Already assigned to the task", new object[0]);
}
return(navyTaskEvaluation);
}
public Amplitude.Unity.Game.Orders.Order Search(BaseNavyArmy army)
{
PointOfInterest pointOfInterest = this.worldPositionService.GetPointOfInterest(army.Garrison.WorldPosition);
if (pointOfInterest != null && this.CouldSearch(army, pointOfInterest))
{
OrderInteractWith orderInteractWith = new OrderInteractWith(army.Garrison.Empire.Index, army.Garrison.GUID, FleetAction_Dive.ReadOnlyName);
orderInteractWith.WorldPosition = army.Garrison.WorldPosition;
orderInteractWith.Tags.AddTag("NavalInteract");
orderInteractWith.TargetGUID = pointOfInterest.GUID;
orderInteractWith.ArmyActionName = FleetAction_Dive.ReadOnlyName;
return(orderInteractWith);
}
return(null);
}
private bool IsCloseEnoughToOrigin(BaseNavyArmy army, WorldPosition opportunityPosition)
{
float propertyValue = army.Garrison.GetPropertyValue(SimulationProperties.MaximumMovement);
float num;
if (army.Commander == null)
{
num = (float)this.worldPositionService.GetDistance(opportunityPosition, army.Garrison.WorldPosition);
}
else
{
num = (float)this.worldPositionService.GetDistance(opportunityPosition, army.Commander.RegionData.WaterRegion.Barycenter);
}
return(num / propertyValue <= 2f);
}
private bool IsDetourWorthChecking(BaseNavyArmy army, float detourTime)
{
float num = 2f;
if (army.CurrentMainTask != null && army.PathToMainTarget != null)
{
float num2 = (float)army.PathToMainTarget.WorldPositions.Length / army.Garrison.GetPropertyValue(SimulationProperties.MaximumMovement);
num = Mathf.Min(new float[]
{
num2,
num,
army.CurrentMainTask.EstimatedTurnEnd - (float)(this.gameService.Game as Game).Turn
});
}
return(detourTime <= 0f || detourTime <= num);
}
public Amplitude.Unity.Game.Orders.Order CreateArmyFromFortress(BaseNavyArmy army)
{
if (!this.IsFortress(army))
{
return(null);
}
WorldPosition armyPosition = WorldPosition.Invalid;
WorldOrientation orientation = WorldOrientation.East;
if (army.MainAttackableTarget != null)
{
orientation = this.worldPositionService.GetOrientation(army.Garrison.WorldPosition, army.MainAttackableTarget.WorldPosition);
}
Fortress fortress = army.Garrison as Fortress;
for (int i = 0; i < 6; i++)
{
WorldPosition neighbourTile = this.worldPositionService.GetNeighbourTile(fortress.WorldPosition, orientation.Rotate(i), 1);
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(neighbourTile, PathfindingMovementCapacity.Water))
{
armyPosition = neighbourTile;
break;
}
}
if (!armyPosition.IsValid)
{
for (int j = 0; j < fortress.Facilities.Count; j++)
{
for (int k = 0; k < 6; k++)
{
WorldPosition neighbourTile2 = this.worldPositionService.GetNeighbourTile(fortress.Facilities[j].WorldPosition, (WorldOrientation)k, 1);
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(neighbourTile2, PathfindingMovementCapacity.Water))
{
armyPosition = neighbourTile2;
break;
}
}
}
}
GameEntityGUID[] array = new GameEntityGUID[army.Garrison.StandardUnits.Count];
for (int l = 0; l < army.Garrison.StandardUnits.Count; l++)
{
array[l] = army.Garrison.StandardUnits[l].GUID;
}
return(new OrderTransferGarrisonToNewArmy(army.Garrison.Empire.Index, army.Garrison.GUID, array, armyPosition, null, false, true, true));
}
protected bool MayEndureRetaliationAnotherTurn(BaseNavyArmy army)
{
Army army2 = army.Garrison as Army;
if (army2 != null && army2.IsPrivateers)
{
return(true);
}
District district = this.worldPositionService.GetDistrict(army.Garrison.WorldPosition);
if (district != null)
{
if (district.City.Empire == army.Garrison.Empire)
{
return(true);
}
float propertyValue = district.City.GetPropertyValue(SimulationProperties.DefensivePower);
float propertyValue2 = district.City.GetPropertyValue(SimulationProperties.CoastalDefensivePower);
if (propertyValue + propertyValue2 <= 0f)
{
return(true);
}
DepartmentOfForeignAffairs agency = district.City.Empire.GetAgency <DepartmentOfForeignAffairs>();
if (agency != null)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(army.Garrison.Empire);
if (diplomaticRelation != null && diplomaticRelation.HasActiveAbility(DiplomaticAbilityDefinition.ImmuneToDefensiveImprovements))
{
return(true);
}
}
float num = (propertyValue + propertyValue2) / (float)army.Garrison.UnitsCount;
foreach (Unit unit in army.Garrison.Units)
{
float propertyValue3 = unit.GetPropertyValue(SimulationProperties.Health);
if (propertyValue3 - num < num * 2f)
{
return(false);
}
}
return(true);
}
return(true);
}
private void ComputeOpportunityScore_PointOfInterest(BaseNavyArmy army)
{
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return;
}
Army army2 = army.Garrison as Army;
if (army2 != null && army2.HasCatspaw)
{
return;
}
for (int i = 0; i < this.worldPositionService.World.Regions.Length; i++)
{
if (this.worldPositionService.World.Regions[i].IsOcean)
{
for (int j = 0; j < this.worldPositionService.World.Regions[i].PointOfInterests.Length; j++)
{
PointOfInterest pointOfInterest = this.worldPositionService.World.Regions[i].PointOfInterests[j];
float num = this.ComputeOpportunityTurnOverhead(army, pointOfInterest.WorldPosition);
if ((army.CurrentMainTask == null || this.IsDetourWorthChecking(army, num)) && this.CouldSearch(army, pointOfInterest) && this.IsCloseEnoughToOrigin(army, pointOfInterest.WorldPosition, 2f))
{
HeuristicValue heuristicValue = new HeuristicValue(0f);
heuristicValue.Add(1f, "constant", new object[0]);
HeuristicValue heuristicValue2 = new HeuristicValue(0f);
float operand = 1f;
heuristicValue2.Add(operand, "Factor from xml(constant for now)", new object[0]);
heuristicValue2.Multiply(num, "Nb turn added by opportunity", new object[0]);
heuristicValue2.Add(1f, "Constant to avoid divide by 0", new object[0]);
heuristicValue.Divide(heuristicValue2, "Distance factor", new object[0]);
navyArmy.Opportunities.Add(new BehaviorOpportunity
{
OpportunityPosition = pointOfInterest.WorldPosition,
Score = heuristicValue,
Type = BehaviorOpportunity.OpportunityType.Ruin
});
}
}
}
}
}
public BehaviorNodeReturnCode ComputePathToSecondary(BaseNavyArmy army)
{
if (!this.HasSecondaryTarget(army))
{
return(BehaviorNodeReturnCode.Failure);
}
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return(BehaviorNodeReturnCode.Failure);
}
navyArmy.PathToSecondaryTarget = base.ComputePathToPosition(army, navyArmy.SecondaryTarget.OpportunityPosition, navyArmy.PathToSecondaryTarget);
if (navyArmy.PathToSecondaryTarget == null)
{
navyArmy.SecondaryTarget = null;
return(BehaviorNodeReturnCode.Failure);
}
return(BehaviorNodeReturnCode.Success);
}
public BehaviorNodeReturnCode ComputePathToSafe(BaseNavyArmy army)
{
if (!this.HasSafeTarget(army))
{
return(BehaviorNodeReturnCode.Failure);
}
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return(BehaviorNodeReturnCode.Failure);
}
navyArmy.PathToSafePosition = base.ComputePathToPosition(army, navyArmy.SafePosition, navyArmy.PathToSafePosition);
if (navyArmy.PathToSafePosition == null)
{
navyArmy.SafePosition = WorldPosition.Invalid;
return(BehaviorNodeReturnCode.Failure);
}
return(BehaviorNodeReturnCode.Success);
}
private float ComputeOpportunityTurnOverhead(BaseNavyArmy army, WorldPosition opportunityPosition)
{
float propertyValue = army.Garrison.GetPropertyValue(SimulationProperties.MaximumMovement);
if (army.MainAttackableTarget == null || army.PathToMainTarget == null)
{
float num = (float)this.worldPositionService.GetDistance(opportunityPosition, army.Garrison.WorldPosition);
return(num / propertyValue);
}
float num2 = (float)army.PathToMainTarget.WorldPositions.Length;
float num3 = (float)this.worldPositionService.GetDistance(opportunityPosition, army.PathToMainTarget.Destination);
float num4 = (float)this.worldPositionService.GetDistance(opportunityPosition, army.Garrison.WorldPosition);
float num5 = num4 / propertyValue;
if (num2 < num5)
{
return(float.MaxValue);
}
return(num4 + num3 - num2);
}
private void ComputeOpportunityScore_Orbs(BaseNavyArmy army)
{
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null)
{
return;
}
IOrbAIHelper service = AIScheduler.Services.GetService <IOrbAIHelper>();
for (int i = 0; i < service.OrbSpawns.Count; i++)
{
OrbSpawnInfo orbSpawnInfo = service.OrbSpawns[i];
if (orbSpawnInfo != null && orbSpawnInfo.CurrentOrbCount != 0f)
{
HeuristicValue heuristicValue = orbSpawnInfo.EmpireNeedModifier[army.Garrison.Empire.Index];
if (heuristicValue > 0f)
{
float num = this.ComputeOpportunityTurnOverhead(army, orbSpawnInfo.WorldPosition);
if ((army.CurrentMainTask == null || this.IsDetourWorthChecking(army, num)) && this.worldPositionService.IsOceanTile(orbSpawnInfo.WorldPosition) && this.IsCloseEnoughToOrigin(army, orbSpawnInfo.WorldPosition, 1f))
{
HeuristicValue heuristicValue2 = new HeuristicValue(0f);
heuristicValue2.Add(heuristicValue, "Orb position eval", new object[0]);
float orbDistanceExponent = service.GetOrbDistanceExponent(army.Garrison.Empire);
HeuristicValue heuristicValue3 = new HeuristicValue(0f);
heuristicValue3.Add(num, "Nb turn added by opportunity", new object[0]);
heuristicValue3.Power(orbDistanceExponent, "From xml registry", new object[0]);
heuristicValue3.Add(1f, "avoid divide by 0", new object[0]);
heuristicValue2.Divide(heuristicValue3, "DistanceFactor", new object[0]);
navyArmy.Opportunities.Add(new BehaviorOpportunity
{
OpportunityPosition = orbSpawnInfo.WorldPosition,
Score = heuristicValue2,
Type = BehaviorOpportunity.OpportunityType.Orbs
});
}
}
}
}
}
protected bool HasReinforcementClose(BaseNavyArmy army)
{
NavyArmy navyArmy = army as NavyArmy;
if (navyArmy == null || navyArmy.NavyLayer == null)
{
return(false);
}
NavyTask_Reinforcement navyTask_Reinforcement = navyArmy.NavyLayer.FindTask <NavyTask_Reinforcement>((NavyTask_Reinforcement match) => match.TargetGuid == army.Garrison.GUID);
if (navyTask_Reinforcement != null && navyTask_Reinforcement.AssignedArmy != null)
{
float num = (float)this.worldPositionService.GetDistance(navyTask_Reinforcement.AssignedArmy.Garrison.WorldPosition, army.Garrison.WorldPosition);
BaseNavyArmy baseNavyArmy = navyTask_Reinforcement.AssignedArmy as BaseNavyArmy;
float num2 = num / baseNavyArmy.GetMaximumMovement();
if (num2 < 2f)
{
return(true);
}
}
return(false);
}
