private void ResetOrderPositions()
{
this._behaviourState = BehaviorRetakeCastleKeyPosition.BehaviourState.UnSet;
this._gatheringSide = this.DetermineGatheringSide();
SiegeLane siegeLane = TeamAISiegeComponent.SiegeLanes.FirstOrDefault <SiegeLane>((Func <SiegeLane, bool>)(sl => sl.LaneSide == this._gatheringSide));
WorldFrame defenseWaitFrame = siegeLane.DefensePoints.FirstOrDefault <ICastleKeyPosition>().DefenseWaitFrame;
this._gatheringTacticalPos = siegeLane.DefensePoints.FirstOrDefault <ICastleKeyPosition>().WaitPosition;
if (this._gatheringTacticalPos != null)
{
this._gatherOrder = MovementOrder.MovementOrderMove(this._gatheringTacticalPos.Position);
this._gatheringFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else if (defenseWaitFrame.Origin.IsValid)
{
double num = (double)defenseWaitFrame.Rotation.f.Normalize();
this._gatherOrder = MovementOrder.MovementOrderMove(defenseWaitFrame.Origin);
this._gatheringFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else
{
this._gatherOrder = MovementOrder.MovementOrderMove(this.formation.QuerySystem.MedianPosition);
this._gatheringFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
this._attackOrder = MovementOrder.MovementOrderMove(TeamAISiegeComponent.SiegeLanes.FirstOrDefault <SiegeLane>((Func <SiegeLane, bool>)(sl => sl.LaneSide == this.behaviorSide)).DefensePoints.FirstOrDefault <ICastleKeyPosition>().MiddleFrame.Origin);
this._attackFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
this.CurrentOrder = this._behaviourState == BehaviorRetakeCastleKeyPosition.BehaviourState.Attacking ? this._attackOrder : this._gatherOrder;
this.CurrentFacingOrder = this._behaviourState == BehaviorRetakeCastleKeyPosition.BehaviourState.Attacking ? this._attackFacingOrder : this._gatheringFacingOrder;
}
private void ResetFollowOrder()
{
this._followedEntity = (GameEntity)null;
this._followTacticalPosition = (TacticalPosition)null;
if (this._ladders.Any <SiegeLadder>())
{
this._followedEntity = (this._ladders.FirstOrDefault <SiegeLadder>((Func <SiegeLadder, bool>)(l => !l.IsDeactivated && l.InitialWaitPosition.HasScriptOfType <TacticalPosition>())) ?? this._ladders.FirstOrDefault <SiegeLadder>((Func <SiegeLadder, bool>)(l => !l.IsDeactivated))).InitialWaitPosition;
if ((NativeObject)this._followedEntity == (NativeObject)null)
{
this._followedEntity = this._ladders.FirstOrDefault <SiegeLadder>((Func <SiegeLadder, bool>)(l => !l.IsDeactivated)).InitialWaitPosition;
}
this._followOrder = MovementOrder.MovementOrderFollowEntity(this._followedEntity);
}
else if (this._breachedWallSegment != null)
{
this._followedEntity = this._breachedWallSegment.GameEntity.CollectChildrenEntitiesWithTag("attacker_wait_pos").FirstOrDefault <GameEntity>();
this._followOrder = MovementOrder.MovementOrderFollowEntity(this._followedEntity);
}
else
{
this._followOrder = MovementOrder.MovermentOrderNull;
}
if (!((NativeObject)this._followedEntity != (NativeObject)null))
{
return;
}
this._followTacticalPosition = this._followedEntity.GetFirstScriptOfType <TacticalPosition>();
}
private bool IsTacticalPositionEligible(TacticalPosition tacticalPosition)
{
if (!this.CheckAndDetermineFormation(ref this._mainInfantry, (Func <Formation, bool>)(f => f.QuerySystem.IsInfantryFormation)))
{
return(false);
}
float num1 = this.team.QuerySystem.AveragePosition.Distance(tacticalPosition.Position.AsVec2);
Vec2 vec2 = this.team.QuerySystem.AverageEnemyPosition;
float num2 = vec2.Distance(this._mainInfantry.QuerySystem.AveragePosition);
if ((double)num1 > 20.0 && (double)num1 > (double)num2 * 0.5)
{
return(false);
}
int countOfUnits = this._mainInfantry.CountOfUnits;
if ((double)this._mainInfantry.MaximumInterval * (double)(countOfUnits - 1) + (double)this._mainInfantry.UnitDiameter * (double)countOfUnits < (double)tacticalPosition.Width)
{
return(false);
}
vec2 = this.team.QuerySystem.AverageEnemyPosition - tacticalPosition.Position.AsVec2;
vec2 = vec2.Normalized();
float num3 = vec2.DotProduct(tacticalPosition.Direction);
return(tacticalPosition.IsInsurmountable ? (double)Math.Abs(num3) >= 0.5 : (double)num3 >= 0.5);
}
private void ResetOrderPositions()
{
this.behaviorSide = this.DetermineGatheringSide();
SiegeLane siegeLane = TeamAISiegeComponent.SiegeLanes.FirstOrDefault <SiegeLane>((Func <SiegeLane, bool>)(sl => sl.LaneSide == this.behaviorSide));
WorldFrame worldFrame = siegeLane == null ? WorldFrame.Invalid : siegeLane.DefensePoints.FirstOrDefault <ICastleKeyPosition>().DefenseWaitFrame;
this._gatheringTacticalPos = siegeLane != null?siegeLane.DefensePoints.FirstOrDefault <ICastleKeyPosition>().WaitPosition : (TacticalPosition)null;
if (this._gatheringTacticalPos != null)
{
this._gatherOrder = MovementOrder.MovementOrderMove(this._gatheringTacticalPos.Position);
this._gatheringFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else if (worldFrame.Origin.IsValid)
{
double num = (double)worldFrame.Rotation.f.Normalize();
this._gatherOrder = MovementOrder.MovementOrderMove(worldFrame.Origin);
this._gatheringFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else
{
this._gatherOrder = MovementOrder.MovementOrderMove(this.formation.QuerySystem.MedianPosition);
this._gatheringFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
this._attackOrder = MovementOrder.MovementOrderChargeToTarget(this._targetEnemyFormation);
this._attackFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
this.CurrentOrder = this._behaviourState == BehaviorEliminateEnemyInsideCastle.BehaviourState.Attacking ? this._attackOrder : this._gatherOrder;
this.CurrentFacingOrder = this._behaviourState == BehaviorEliminateEnemyInsideCastle.BehaviourState.Attacking ? this._attackFacingOrder : this._gatheringFacingOrder;
}
private bool IsTacticalPositionEligible(TacticalPosition tacticalPosition)
{
float num1 = this._mainInfantry != null?this._mainInfantry.QuerySystem.AveragePosition.Distance(tacticalPosition.Position.AsVec2) : this.team.QuerySystem.AveragePosition.Distance(tacticalPosition.Position.AsVec2);
float num2 = this.team.QuerySystem.AverageEnemyPosition.Distance(this._mainInfantry != null ? this._mainInfantry.QuerySystem.AveragePosition : this.team.QuerySystem.AveragePosition);
return(((double)num1 <= 20.0 || (double)num1 <= (double)num2 * 0.5) && tacticalPosition.IsInsurmountable);
}
private float GetCavalryFactor(TacticalPosition tacticalPosition)
{
if (tacticalPosition.TacticalRegionMembership == TacticalRegion.TacticalRegionTypeEnum.Opening)
{
return(1f);
}
double overallPowerRatio = (double)this.team.QuerySystem.OverallPowerRatio;
double teamPower = (double)this.team.QuerySystem.TeamPower;
float num = this.team.QuerySystem.EnemyTeams.Sum <TeamQuerySystem>((Func <TeamQuerySystem, float>)(et => et.TeamPower));
return((float)(teamPower - teamPower * ((double)this.team.QuerySystem.CavalryRatio + (double)this.team.QuerySystem.RangedCavalryRatio) * 0.5) / (num - (float)((double)num * ((double)this.team.QuerySystem.EnemyCavalryRatio + (double)this.team.QuerySystem.EnemyRangedCavalryRatio) * 0.5)) / this.team.QuerySystem.OverallPowerRatio);
}
private List <TacticalPosition> ExtractPossibleTacticalPositionsFromTacticalRegion(
TacticalRegion tacticalRegion)
{
List <TacticalPosition> tacticalPositionList = new List <TacticalPosition>();
tacticalRegion.LinkedTacticalPositions.Where <TacticalPosition>((Func <TacticalPosition, bool>)(ltp => ltp.TacticalPositionType == TacticalPosition.TacticalPositionTypeEnum.HighGround));
if (tacticalRegion.tacticalRegionType == TacticalRegion.TacticalRegionTypeEnum.DifficultTerrain || tacticalRegion.tacticalRegionType == TacticalRegion.TacticalRegionTypeEnum.Opening)
{
Vec2 direction = (this.team.QuerySystem.AverageEnemyPosition - tacticalRegion.Position.AsVec2).Normalized();
TacticalPosition tacticalPosition = new TacticalPosition(tacticalRegion.Position, direction, tacticalRegion.radius, isInsurmountable: true, tacticalRegionMembership: tacticalRegion.tacticalRegionType);
tacticalPositionList.Add(tacticalPosition);
}
return(tacticalPositionList);
}
private float GetTacticalPositionScore(TacticalPosition tacticalPosition)
{
if (!this.CheckAndDetermineFormation(ref this._mainInfantry, (Func <Formation, bool>)(f => f.QuerySystem.IsInfantryFormation)) || !this.CheckAndDetermineFormation(ref this._archers, (Func <Formation, bool>)(f => f.QuerySystem.IsRangedFormation)))
{
return(0.0f);
}
double num1 = (double)MBMath.Lerp(1f, 1.5f, MBMath.ClampFloat(tacticalPosition.Slope, 0.0f, 60f) / 60f);
Formation formation = this.team.Formations.Where <Formation>((Func <Formation, bool>)(f => f.QuerySystem.IsRangedFormation)).MaxBy <Formation, int>((Func <Formation, int>)(f => f.CountOfUnits));
float num2 = Math.Max(formation.arrangement.Depth, formation.arrangement.Width);
float num3 = MBMath.ClampFloat(tacticalPosition.Width / num2, 0.7f, 1f);
float num4 = tacticalPosition.IsInsurmountable ? 1.5f : 1f;
float cavalryFactor = this.GetCavalryFactor(tacticalPosition);
float num5 = MBMath.Lerp(0.7f, 1f, (float)((150.0 - (double)MBMath.ClampFloat(this._mainInfantry.QuerySystem.AveragePosition.Distance(tacticalPosition.Position.AsVec2), 50f, 150f)) / 100.0));
double num6 = (double)num3;
return((float)(num1 * num6) * num4 * cavalryFactor * num5);
}
private bool IsTacticalPositionEligible(TacticalPosition tacticalPosition)
{
if (tacticalPosition.TacticalPositionType == TacticalPosition.TacticalPositionTypeEnum.SpecialMissionPosition)
{
return(true);
}
Vec2 vec2;
WorldPosition position;
double num1;
if (this._mainInfantry == null)
{
vec2 = this.team.QuerySystem.AveragePosition;
ref Vec2 local = ref vec2;
position = tacticalPosition.Position;
Vec2 asVec2 = position.AsVec2;
num1 = (double)local.Distance(asVec2);
}
private float GetTacticalPositionScore(TacticalPosition tacticalPosition)
{
if (!this.CheckAndDetermineFormation(ref this._mainInfantry, (Func <Formation, bool>)(f => f.QuerySystem.IsInfantryFormation)))
{
return(0.0f);
}
double num1 = (double)MBMath.Lerp(1f, 1.5f, MBMath.ClampFloat(tacticalPosition.Slope, 0.0f, 60f) / 60f);
int countOfUnits = this._mainInfantry.CountOfUnits;
float num2 = MBMath.Lerp(0.67f, 1.5f, (float)(((double)MBMath.ClampFloat((float)((double)this._mainInfantry.Interval * (double)(countOfUnits - 1) + (double)this._mainInfantry.UnitDiameter * (double)countOfUnits) / tacticalPosition.Width, 0.5f, 3f) - 0.5) / 2.5));
float num3 = 1f;
if (this.CheckAndDetermineFormation(ref this._archers, (Func <Formation, bool>)(f => f.QuerySystem.IsRangedFormation)) && tacticalPosition.LinkedTacticalPositions.Where <TacticalPosition>((Func <TacticalPosition, bool>)(lcp => lcp.TacticalPositionType == TacticalPosition.TacticalPositionTypeEnum.Cliff)).ToList <TacticalPosition>().Any <TacticalPosition>())
{
num3 = MBMath.Lerp(1f, 1.5f, (float)(((double)MBMath.ClampFloat(this.team.QuerySystem.RangedRatio, 0.05f, 0.25f) - 0.0500000007450581) * 5.0));
}
float num4 = MBMath.Lerp(0.7f, 1f, (float)((150.0 - (double)MBMath.ClampFloat(this._mainInfantry.QuerySystem.AveragePosition.Distance(tacticalPosition.Position.AsVec2), 50f, 150f)) / 100.0));
double num5 = (double)num2;
return((float)(num1 * num5) * num3 * num4);
}
private void ResetOrderPositions()
{
SiegeLane siegeLane = TeamAISiegeComponent.SiegeLanes.FirstOrDefault <SiegeLane>((Func <SiegeLane, bool>)(sl => sl.LaneSide == FormationAI.BehaviorSide.Middle));
WorldFrame worldFrame = (siegeLane != null ? siegeLane.DefensePoints.FirstOrDefault <ICastleKeyPosition>()?.DefenseWaitFrame : new WorldFrame?()) ?? WorldFrame.Invalid;
this._gatheringTacticalPos = siegeLane != null?siegeLane.DefensePoints.FirstOrDefault <ICastleKeyPosition>()?.WaitPosition : (TacticalPosition)null;
if (this._gatheringTacticalPos != null)
{
this._gatherOrder = MovementOrder.MovementOrderMove(this._gatheringTacticalPos.Position);
}
else if (worldFrame.Origin.IsValid)
{
double num = (double)worldFrame.Rotation.f.Normalize();
this._gatherOrder = MovementOrder.MovementOrderMove(worldFrame.Origin);
}
else
{
this._gatherOrder = MovementOrder.MovementOrderMove(this.formation.QuerySystem.MedianPosition);
}
this._attackOrder = MovementOrder.MovementOrderCharge;
this.CurrentOrder = this._calculateShouldStartAttacking ? this._attackOrder : this._gatherOrder;
}
internal override void ResetBehavior()
{
base.ResetBehavior();
this.TacticalDefendPosition = (TacticalPosition)null;
}
internal override void ResetBehavior()
{
base.ResetBehavior();
this._defensePosition = WorldPosition.Invalid;
this._tacticalDefendPosition = (TacticalPosition)null;
}
private void ResetOrderPositions()
{
this.behaviorSide = this.formation.AI.Side;
this._innerGate = (CastleGate)null;
this._outerGate = (CastleGate)null;
this._laddersOnThisSide.Clear();
int num1 = Mission.Current.ActiveMissionObjects.FindAllWithType <CastleGate>().Any <CastleGate>((Func <CastleGate, bool>)(cg => cg.DefenseSide == this.behaviorSide && cg.GameEntity.HasTag("outer_gate"))) ? 1 : 0;
this._isDefendingWideGap = false;
WorldFrame worldFrame1;
WorldFrame worldFrame2;
if (num1 != 0)
{
CastleGate outerGate = this._teamAISiegeDefender.OuterGate;
this._innerGate = this._teamAISiegeDefender.InnerGate;
this._outerGate = this._teamAISiegeDefender.OuterGate;
worldFrame1 = outerGate.MiddleFrame;
worldFrame2 = outerGate.DefenseWaitFrame;
this._tacticalMiddlePos = outerGate.MiddlePosition;
this._tacticalWaitPos = outerGate.WaitPosition;
this._isDefendingWideGap = false;
}
else
{
WallSegment wallSegment = Mission.Current.ActiveMissionObjects.FindAllWithType <WallSegment>().Where <WallSegment>((Func <WallSegment, bool>)(ws => ws.DefenseSide == this.behaviorSide && ws.IsBreachedWall)).FirstOrDefault <WallSegment>();
if (wallSegment != null)
{
worldFrame1 = wallSegment.MiddleFrame;
worldFrame2 = wallSegment.DefenseWaitFrame;
this._tacticalMiddlePos = wallSegment.MiddlePosition;
this._tacticalWaitPos = wallSegment.WaitPosition;
this._isDefendingWideGap = false;
}
else
{
IEnumerable <SiegeWeapon> source = Mission.Current.ActiveMissionObjects.FindAllWithType <SiegeWeapon>().Where <SiegeWeapon>((Func <SiegeWeapon, bool>)(sw =>
{
if (!(sw is IPrimarySiegeWeapon) || (sw as IPrimarySiegeWeapon).WeaponSide != this.behaviorSide)
{
return(false);
}
return(!sw.IsDestroyed || (sw as IPrimarySiegeWeapon).HasCompletedAction());
}));
if (!source.Any <SiegeWeapon>())
{
worldFrame1 = WorldFrame.Invalid;
worldFrame2 = WorldFrame.Invalid;
this._tacticalMiddlePos = (TacticalPosition)null;
this._tacticalWaitPos = (TacticalPosition)null;
}
else
{
this._laddersOnThisSide = source.Where <SiegeWeapon>((Func <SiegeWeapon, bool>)(aw => aw is SiegeLadder)).Select <SiegeWeapon, SiegeLadder>((Func <SiegeWeapon, SiegeLadder>)(aw => aw as SiegeLadder)).ToList <SiegeLadder>();
ICastleKeyPosition targetCastlePosition = (source.FirstOrDefault <SiegeWeapon>() as IPrimarySiegeWeapon).TargetCastlePosition as ICastleKeyPosition;
worldFrame1 = targetCastlePosition.MiddleFrame;
worldFrame2 = targetCastlePosition.DefenseWaitFrame;
this._tacticalMiddlePos = targetCastlePosition.MiddlePosition;
this._tacticalWaitPos = targetCastlePosition.WaitPosition;
}
}
}
if (this._tacticalMiddlePos != null)
{
this._readyOrder = MovementOrder.MovementOrderMove(this._tacticalMiddlePos.Position);
this._readyFacingOrder = FacingOrder.FacingOrderLookAtDirection(this._tacticalMiddlePos.Direction);
}
else if (worldFrame1.Origin.IsValid)
{
double num2 = (double)worldFrame1.Rotation.f.Normalize();
this._readyOrder = MovementOrder.MovementOrderMove(worldFrame1.Origin);
this._readyFacingOrder = FacingOrder.FacingOrderLookAtDirection(worldFrame1.Rotation.f.AsVec2);
}
else
{
this._readyOrder = MovementOrder.MovementOrderStop;
this._readyFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
if (this._tacticalWaitPos != null)
{
this._waitOrder = MovementOrder.MovementOrderMove(this._tacticalWaitPos.Position);
this._waitFacingOrder = FacingOrder.FacingOrderLookAtDirection(this._tacticalWaitPos.Direction);
}
else if (worldFrame2.Origin.IsValid)
{
double num2 = (double)worldFrame2.Rotation.f.Normalize();
this._waitOrder = MovementOrder.MovementOrderMove(worldFrame2.Origin);
this._waitFacingOrder = FacingOrder.FacingOrderLookAtDirection(worldFrame2.Rotation.f.AsVec2);
}
else
{
this._waitOrder = MovementOrder.MovementOrderStop;
this._waitFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
this.CurrentOrder = this._behaviourState == BehaviorDefendCastleKeyPosition.BehaviourState.Ready ? this._readyOrder : this._waitOrder;
this.CurrentFacingOrder = this.formation.QuerySystem.ClosestEnemyFormation == null || !TeamAISiegeComponent.IsFormationInsideCastle(this.formation.QuerySystem.ClosestEnemyFormation.Formation, true) ? (this._behaviourState == BehaviorDefendCastleKeyPosition.BehaviourState.Ready ? this._readyFacingOrder : this._waitFacingOrder) : FacingOrder.FacingOrderLookAtEnemy;
}
