public override void OnMissionTick(float dt)
{
base.OnMissionTick(dt);
if (!this._IsNewlyPopulatedFormationGivenOrder)
{
foreach (Formation formation in this.Mission.Teams.Where <Team>((Func <Team, bool>)(t => t.Side == BattleSideEnum.Defender)).SelectMany <Team, Formation>((Func <Team, IEnumerable <Formation> >)(t => t.FormationsIncludingSpecial)))
{
formation.MovementOrder = MovementOrder.MovementOrderMove(formation.QuerySystem.MedianPosition);
this._IsNewlyPopulatedFormationGivenOrder = true;
}
}
this._dtSum = 0.0f;
}
public static bool GetSubstituteOrder_Prefix(MovementOrder __instance, ref MovementOrder __result,
Formation formation)
{
if (__instance.OrderType == OrderType.ChargeWithTarget)
{
var position = formation.QuerySystem.MedianPosition;
position.SetVec2(formation.CurrentPosition);
__result = MovementOrder.MovementOrderMove(position);
return(false);
}
return(true);
}
public override Waypoint GetActiveWaypoint()
{
if (this.UnitClass.UnitType == GameConstants.UnitType.Mine)
{
return null;
}
if (MovementOrder != null && MovementOrder.CountWaypoints > 0)
{
return MovementOrder.GetActiveWaypoint();
}
else if (TargetDetectedUnit != null)
{
if (TargetDetectedUnit.IsMarkedForDeletion)
{
SearchForTarget();
}
if (TargetDetectedUnit != null && !TargetDetectedUnit.IsMarkedForDeletion)
{
Waypoint wp = new Waypoint(TargetDetectedUnit);
return wp;
}
else
{
return null;
}
}
else if (TargetPosition != null)
{
Waypoint wp = new Waypoint(TargetPosition);
return wp;
}
else
{
SearchForTarget();
if (TargetDetectedUnit == null)
{
GameManager.Instance.Log.LogDebug(string.Format(
"MissileUnit->ActiveWaypoint Unit {0} has no destination or target and is being deleted.",
ToString()));
IsMarkedForDeletion = true; //delete missile with no target
HitPoints = 0;
DirtySetting = TTG.NavalWar.NWComms.GameConstants.DirtyStatus.UnitChanged;
return null;
}
else
{
Waypoint wp = new Waypoint(TargetDetectedUnit);
return wp;
}
}
}
static bool PrefixCalculateCurrentOrder(ref Formation ___formation, ref MovementOrder ____currentOrder)
{
if (___formation != null && ___formation.QuerySystem.IsInfantryFormation && ___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation != null)
{
Formation significantEnemy = Utilities.FindSignificantEnemy(___formation, true, true, false, false, false);
if (significantEnemy != null)
{
____currentOrder = MovementOrder.MovementOrderChargeToTarget(significantEnemy);
return(false);
}
}
____currentOrder = MovementOrder.MovementOrderCharge;
return(false);
}
static void PostfixCalculateCurrentOrder(Formation ____mainFormation, Formation ___formation, ref MovementOrder ____currentOrder, ref FacingOrder ___CurrentFacingOrder)
{
if (____mainFormation != null && ___formation != null)
{
MethodInfo method = typeof(FacingOrder).GetMethod("FacingOrderLookAtDirection", BindingFlags.NonPublic | BindingFlags.Static);
method.DeclaringType.GetMethod("FacingOrderLookAtDirection");
___CurrentFacingOrder = (FacingOrder)method.Invoke(___CurrentFacingOrder, new object[] { ____mainFormation.Direction });
WorldPosition medianPosition = ____mainFormation.QuerySystem.MedianPosition;
//medianPosition.SetVec2(medianPosition.AsVec2 - ____mainFormation.Direction * ((____mainFormation.Depth + ___formation.Depth) * 1.5f));
medianPosition.SetVec2(medianPosition.AsVec2 - ____mainFormation.Direction * ((____mainFormation.Depth + ___formation.Depth) * 0.25f + 0.0f));
____currentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
}
static void PostfixCalculateCurrentOrder(ref Formation ___formation, BehaviorSkirmish __instance, ref BehaviorState ____behaviorState, ref MovementOrder ____currentOrder)
{
if (___formation != null && ___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation != null)
{
Vec2 enemyDirection = ___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2 - ___formation.QuerySystem.AveragePosition;
float distance = enemyDirection.Normalize();
switch (____behaviorState)
{
case BehaviorState.Shooting:
if (waitCountShooting > 50)
{
if (___formation.QuerySystem.MakingRangedAttackRatio < 0.4f && distance > 30f)
{
WorldPosition medianPosition = ___formation.QuerySystem.MedianPosition;
medianPosition.SetVec2(medianPosition.AsVec2 + ___formation.Direction * 5f);
____currentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
waitCountShooting = 0;
}
else
{
waitCountShooting++;
}
break;
case BehaviorState.Approaching:
if (waitCountApproaching > 20)
{
if (distance < 200f)
{
WorldPosition medianPosition = ___formation.QuerySystem.MedianPosition;
medianPosition.SetVec2(medianPosition.AsVec2 + enemyDirection * 5f);
approachingRanging = medianPosition.AsVec2;
____currentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
waitCountApproaching = 0;
}
else
{
WorldPosition medianPosition = ___formation.QuerySystem.MedianPosition;
medianPosition.SetVec2(approachingRanging);
____currentOrder = MovementOrder.MovementOrderMove(medianPosition);
waitCountApproaching++;
}
break;
}
}
}
public Order Clone()
{
MovementOrder MO = new MovementOrder();
MO.idPlayer = this.idPlayer;
MO.isActive = this.isActive;
MO.units = this.units;
MO.movements = this.movements;
MO.destiny = this.destiny;
MO.timeCounter = this.timeCounter;
MO.rangeConsidered = this.rangeConsidered;
return(MO);
}
public void ResolveMovementOrder(MovementOrder currentOrder)
{
Vector3 movementDirection = currentOrder.destination - character.transform.localPosition;
if (movementDirection.magnitude < .1)
{
actionQueue.Pop();
Debug.Log("Character " + name + " completed movement order");
}
else
{
movementDirection.Normalize();
character.transform.localPosition += movementDirection * Time.deltaTime * stats.MoveSpeed;
}
}
private MovementOrder UncapturedFlagMoveOrder()
{
if (this._flagpositions.Any <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team)))
{
FlagCapturePoint flagCapturePoint = this._flagpositions.Where <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team)).MinBy <FlagCapturePoint, float>((Func <FlagCapturePoint, float>)(fp => this.formation.Team.QuerySystem.GetLocalEnemyPower(fp.Position.AsVec2)));
return(MovementOrder.MovementOrderMove(new WorldPosition(Mission.Current.Scene, UIntPtr.Zero, flagCapturePoint.Position, false)));
}
if (!this._flagpositions.Any <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) == this.formation.Team)))
{
return(MovementOrder.MovementOrderStop);
}
Vec3 position = this._flagpositions.Where <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) == this.formation.Team)).MinBy <FlagCapturePoint, float>((Func <FlagCapturePoint, float>)(fp => fp.Position.AsVec2.DistanceSquared(this.formation.QuerySystem.AveragePosition))).Position;
return(MovementOrder.MovementOrderMove(new WorldPosition(Mission.Current.Scene, UIntPtr.Zero, position, false)));
}
public void Resolve()
{
if (actionQueue.Count > 0)
{
if (actionQueue.Peek() is MovementOrder)
{
MovementOrder currentOrder = (MovementOrder)actionQueue.Peek();
parentChar.ResolveMovementOrder(currentOrder);
}
if (actionQueue.Peek() is AttackOrder)
{
AttackOrder currentOrder = (AttackOrder)actionQueue.Peek();
parentChar.ResolveAttackOrder(currentOrder);
}
}
}
protected override void CalculateCurrentOrder()
{
WorldPosition medianPosition = this.formation.QuerySystem.MedianPosition;
if (this.formation.QuerySystem.ClosestEnemyFormation == null)
{
medianPosition.SetVec2(this.formation.QuerySystem.AveragePosition);
this.CurrentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
else
{
Vec2 vec2 = (this.formation.QuerySystem.AveragePosition - this.formation.QuerySystem.ClosestEnemyFormation.MedianPosition.AsVec2).Normalized();
medianPosition.SetVec2(this.formation.QuerySystem.AveragePosition + 50f * vec2);
this.CurrentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
}
protected override void CalculateCurrentOrder()
{
if (this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation == null || (double)this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2.DistanceSquared(this.formation.QuerySystem.AveragePosition) > 2500.0)
{
this.CurrentOrder = this.UncapturedFlagMoveOrder();
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else
{
FlagCapturePoint flagCapturePoint = (FlagCapturePoint)null;
if (this._flagpositions.Any <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team && !fp.IsContested)))
{
flagCapturePoint = this._flagpositions.Where <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team && !fp.IsContested)).MinBy <FlagCapturePoint, float>((Func <FlagCapturePoint, float>)(fp => this.formation.QuerySystem.AveragePosition.DistanceSquared(fp.Position.AsVec2)));
}
if (!this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.IsInfantryFormation && flagCapturePoint != null)
{
this.CurrentOrder = MovementOrder.MovementOrderMove(new WorldPosition(Mission.Current.Scene, UIntPtr.Zero, flagCapturePoint.Position, false));
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else if (this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.IsRangedFormation)
{
this.CurrentOrder = MovementOrder.MovementOrderChargeToTarget(this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.Formation);
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else
{
Vec2 direction = this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2 - this.formation.QuerySystem.AveragePosition;
float num = direction.Normalize();
WorldPosition medianPosition = this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition;
if ((double)num > (double)this.formation.QuerySystem.MissileRange)
{
medianPosition.SetVec2(medianPosition.AsVec2 - direction * (this.formation.QuerySystem.MissileRange - this.formation.Depth * 0.5f));
}
else if ((double)num < (double)this.formation.QuerySystem.MissileRange * 0.400000005960464)
{
medianPosition.SetVec2(medianPosition.AsVec2 - direction * (this.formation.QuerySystem.MissileRange * 0.7f));
}
else
{
direction = direction.RightVec();
medianPosition.SetVec2(this.formation.QuerySystem.AveragePosition + direction * 20f);
}
this.CurrentOrder = MovementOrder.MovementOrderMove(medianPosition);
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
}
}
}
private void CheckAndChangeState()
{
WorldPosition position = this._movementOrder.GetPosition(this.formation);
switch (this._protectFlankState)
{
case BehaviorProtectFlank.BehaviourState.HoldingFlank:
if (this.formation.QuerySystem.ClosestEnemyFormation == null)
{
break;
}
float num1 = (float)(50.0 + ((double)this.formation.Depth + (double)this.formation.QuerySystem.ClosestEnemyFormation.Formation.Depth) / 2.0);
if ((double)this.formation.QuerySystem.ClosestEnemyFormation.MedianPosition.AsVec2.DistanceSquared(position.AsVec2) >= (double)num1 * (double)num1)
{
break;
}
this._chargeToTargetOrder = MovementOrder.MovementOrderChargeToTarget(this.formation.QuerySystem.ClosestEnemyFormation.Formation);
this.CurrentOrder = this._chargeToTargetOrder;
this._protectFlankState = BehaviorProtectFlank.BehaviourState.Charging;
break;
case BehaviorProtectFlank.BehaviourState.Charging:
if (this.formation.QuerySystem.ClosestEnemyFormation == null)
{
this.CurrentOrder = this._movementOrder;
this._protectFlankState = BehaviorProtectFlank.BehaviourState.Returning;
break;
}
float num2 = (float)(60.0 + ((double)this.formation.Depth + (double)this.formation.QuerySystem.ClosestEnemyFormation.Formation.Depth) / 2.0);
if ((double)this.formation.QuerySystem.AveragePosition.DistanceSquared(position.AsVec2) <= (double)num2 * (double)num2)
{
break;
}
this.CurrentOrder = this._movementOrder;
this._protectFlankState = BehaviorProtectFlank.BehaviourState.Returning;
break;
case BehaviorProtectFlank.BehaviourState.Returning:
if ((double)this.formation.QuerySystem.AveragePosition.DistanceSquared(position.AsVec2) >= 400.0)
{
break;
}
this._protectFlankState = BehaviorProtectFlank.BehaviourState.HoldingFlank;
break;
}
}
public static bool GetSubstituteOrder_Prefix(MovementOrder __instance, ref MovementOrder __result,
Formation formation)
{
if (__instance.OrderType == OrderType.ChargeWithTarget && CommandSystemConfig.Get().AttackSpecificFormation)
{
var position = formation.QuerySystem.MedianPosition;
position.SetVec2(formation.CurrentPosition);
if (formation.Team == Mission.Current.PlayerTeam)
{
Utility.DisplayFormationReadyMessage(formation);
}
__result = MovementOrder.MovementOrderMove(position);
return(false);
}
return(true);
}
public void AircraftMovement()
{
GameManager.Instance.Log.LogDebug("*** Running test AircraftMovement");
Player player = new Player();
Group group = new Group();
GameManager.Instance.GameData.InitAllData();
GameManager.Instance.CreateGame(player, "test game");
GameManager.Instance.Game.UpperLeftCorner = new Coordinate(70, -10);
GameManager.Instance.Game.LowerRightCorner = new Coordinate(40, 10);
Position pos = new Position(60, 3, 0, 80);
BaseUnit unit = GameManager.Instance.GameData.CreateUnit(player, group, "arleighburke", "Arleigh Burke", pos, true);
AircraftUnit helo = unit.AircraftHangar.Aircraft.First <AircraftUnit>();
unit.LaunchAircraft(new List <AircraftUnit> {
helo
}, string.Empty, string.Empty, null, "");
var wp = new Waypoint(new Position(new Coordinate(70, -13)));
wp.Position.HeightOverSeaLevelM = 500;
var moveOrder = new MovementOrder(wp);
helo.MovementOrder = moveOrder;
helo.SetActualSpeed(300);
helo.UserDefinedSpeed = GameConstants.UnitSpeedType.Cruise;
int countLoop = 100;
double lastBearingDeg = (double)helo.ActualBearingDeg;
for (int i = 0; i < countLoop; i++)
{
helo.MoveToNewPosition3D(1);
double newBearingDeg = (double)helo.ActualBearingDeg;
double bearingDiffRad = Math.Abs(newBearingDeg.ToRadian() - lastBearingDeg.ToRadian());
if (i > 2 && bearingDiffRad > 0.001)
{
GameManager.Instance.Log.LogDebug(
string.Format("BearingDeg has changed: Iteration {0} Old {1:F} New {2:F}",
i, lastBearingDeg, newBearingDeg));
Assert.IsTrue(false, "Bearing should never change abruptly.");
}
lastBearingDeg = newBearingDeg;
}
double distanceM = MapHelper.CalculateDistance3DM(pos, helo.Position);
Assert.IsTrue(distanceM > 8000, "Helo should have moved over 8000m."); //in fact, around 8333 m in 100 sec at 300 kph
}
protected override void CalculateCurrentOrder()
{
Vec2 direction = this.TacticalDefendPosition == null ? (this.formation.QuerySystem.ClosestEnemyFormation != null ? ((double)this.formation.Direction.DotProduct((this.formation.QuerySystem.ClosestEnemyFormation.MedianPosition.AsVec2 - this.formation.QuerySystem.AveragePosition).Normalized()) < 0.5 ? this.formation.QuerySystem.ClosestEnemyFormation.MedianPosition.AsVec2 - this.formation.QuerySystem.AveragePosition : this.formation.Direction).Normalized() : this.formation.Direction) : this.TacticalDefendPosition.Direction;
if (this.TacticalDefendPosition != null)
{
this.CurrentOrder = MovementOrder.MovementOrderMove(this.TacticalDefendPosition.Position);
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
}
else
{
WorldPosition medianPosition = this.formation.QuerySystem.MedianPosition;
medianPosition.SetVec2(this.formation.QuerySystem.AveragePosition);
this.CurrentOrder = MovementOrder.MovementOrderMove(medianPosition);
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
}
}
protected override void CalculateCurrentOrder()
{
FieldInfo property = typeof(BehaviorComponent).GetField("formation", BindingFlags.NonPublic | BindingFlags.Instance);
property.DeclaringType.GetField("formation");
property.SetValue(this, attackingFormation, BindingFlags.NonPublic | BindingFlags.SetProperty, null, null);
PropertyInfo PreserveExpireTimeInfo = typeof(BehaviorComponent).GetProperty("PreserveExpireTime", BindingFlags.NonPublic | BindingFlags.Instance);
PreserveExpireTimeInfo.DeclaringType.GetProperty("PreserveExpireTime");
PreserveExpireTimeInfo.SetValue(this, 0f, BindingFlags.NonPublic, null, null, null);
FieldInfo _navmeshlessTargetPenaltyTimeInfo = typeof(BehaviorComponent).GetField("_navmeshlessTargetPenaltyTime", BindingFlags.NonPublic | BindingFlags.Instance);
_navmeshlessTargetPenaltyTimeInfo.DeclaringType.GetField("_navmeshlessTargetPenaltyTime");
_navmeshlessTargetPenaltyTimeInfo.SetValue(this, new Timer(MBCommon.GetTime(MBCommon.TimeType.Mission), 20f), BindingFlags.NonPublic, null, null);
WorldPosition position;
if (attackingFormation != null && victimFormation != null && attackingFormation.QuerySystem.ClosestEnemyFormation != null)
{
Vec2 vec;
if (attackingFormation.AI.Side == FormationAI.BehaviorSide.Left)
{
Vec2 v = (attackingFormation.QuerySystem.Team.MedianTargetFormationPosition.AsVec2 - victimFormation.QuerySystem.MedianPosition.AsVec2).Normalized();
vec = victimFormation.CurrentPosition + v.LeftVec().Normalized() * (victimFormation.Width + attackingFormation.Width + 5f);
vec -= v * (victimFormation.Depth + attackingFormation.Depth);
}
else
{
Vec2 v = (attackingFormation.QuerySystem.Team.MedianTargetFormationPosition.AsVec2 - victimFormation.QuerySystem.MedianPosition.AsVec2).Normalized();
vec = victimFormation.CurrentPosition + v.RightVec().Normalized() * (victimFormation.Width + attackingFormation.Width + 5f);
vec -= v * (victimFormation.Depth + attackingFormation.Depth);
}
WorldPosition medianPosition = victimFormation.QuerySystem.MedianPosition;
medianPosition.SetVec2(vec);
//position = (attackingFormation.AI.Side == FormationAI.BehaviorSide.Right) ? victimFormation.QuerySystem.Team.RightFlankEdgePosition : victimFormation.QuerySystem.Team.LeftFlankEdgePosition;
//Vec2 direction = (position.AsVec2 - attackingFormation.QuerySystem.AveragePosition).Normalized();
base.CurrentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
//CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
}
private void ResetOrderPositions()
{
this._primarySiegeWeapons = Mission.Current.ActiveMissionObjects.FindAllWithType <UsableMachine>().Where <UsableMachine>((Func <UsableMachine, bool>)(amo => amo is IPrimarySiegeWeapon)).Select <UsableMachine, IPrimarySiegeWeapon>((Func <UsableMachine, IPrimarySiegeWeapon>)(amo => amo as IPrimarySiegeWeapon)).ToList <IPrimarySiegeWeapon>();
this._primarySiegeWeapons.RemoveAll((Predicate <IPrimarySiegeWeapon>)(uM => uM.WeaponSide != this.behaviorSide));
IEnumerable <ICastleKeyPosition> source = TeamAISiegeComponent.SiegeLanes.Where <SiegeLane>((Func <SiegeLane, bool>)(sl => sl.LaneSide == this.behaviorSide)).SelectMany <SiegeLane, ICastleKeyPosition>((Func <SiegeLane, IEnumerable <ICastleKeyPosition> >)(sila => (IEnumerable <ICastleKeyPosition>)sila.DefensePoints));
this._innerGate = this._teamAISiegeComponent.InnerGate;
this._isGateLane = this._teamAISiegeComponent.OuterGate.DefenseSide == this.behaviorSide;
this._wallSegment = !this._isGateLane ? (!(source.FirstOrDefault <ICastleKeyPosition>((Func <ICastleKeyPosition, bool>)(dp => dp is WallSegment && (dp as WallSegment).IsBreachedWall)) is WallSegment wallSegment) ? this._primarySiegeWeapons.MaxBy <IPrimarySiegeWeapon, float>((Func <IPrimarySiegeWeapon, float>)(psw => psw.SiegeWeaponPriority)).TargetCastlePosition as WallSegment : wallSegment) : (WallSegment)null;
this._stopOrder = MovementOrder.MovementOrderStop;
this._chargeOrder = MovementOrder.MovementOrderCharge;
bool flag = this._teamAISiegeComponent.OuterGate != null && this.behaviorSide == this._teamAISiegeComponent.OuterGate.DefenseSide;
this._attackEntityOrderOuterGate = !flag || this._teamAISiegeComponent.OuterGate.IsDeactivated || this._teamAISiegeComponent.OuterGate.State == CastleGate.GateState.Open ? MovementOrder.MovementOrderStop : MovementOrder.MovementOrderAttackEntity(this._teamAISiegeComponent.OuterGate.GameEntity, false);
this._attackEntityOrderInnerGate = !flag || this._teamAISiegeComponent.InnerGate == null || (this._teamAISiegeComponent.InnerGate.IsDeactivated || this._teamAISiegeComponent.InnerGate.State == CastleGate.GateState.Open) ? MovementOrder.MovementOrderStop : MovementOrder.MovementOrderAttackEntity(this._teamAISiegeComponent.InnerGate.GameEntity, false);
this._castleGateMoveOrder = MovementOrder.MovementOrderMove(this._teamAISiegeComponent.OuterGate.MiddleFrame.Origin);
this._wallSegmentMoveOrder = !this._isGateLane ? MovementOrder.MovementOrderMove(this._wallSegment.MiddleFrame.Origin) : this._castleGateMoveOrder;
this._facingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
static bool PrefixTickOccasionally(ref Formation ___formation, ref MovementOrder ____currentOrder, ref FacingOrder ___CurrentFacingOrder, BehaviorVanguard __instance)
{
MethodInfo method = typeof(BehaviorVanguard).GetMethod("CalculateCurrentOrder", BindingFlags.NonPublic | BindingFlags.Instance);
method.DeclaringType.GetMethod("CalculateCurrentOrder");
method.Invoke(__instance, new object[] { });
___formation.MovementOrder = ____currentOrder;
___formation.FacingOrder = ___CurrentFacingOrder;
if (___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation != null && ___formation.QuerySystem.AveragePosition.DistanceSquared(___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2) > 1600f && ___formation.QuerySystem.UnderRangedAttackRatio > 0.2f - ((___formation.ArrangementOrder.OrderEnum == ArrangementOrder.ArrangementOrderEnum.Loose) ? 0.1f : 0f))
{
___formation.ArrangementOrder = ArrangementOrder.ArrangementOrderLoose;
}
else
{
___formation.ArrangementOrder = ArrangementOrder.ArrangementOrderLine;
}
return(false);
}
public BehaviorUseSiegeMachines(Formation formation)
: base(formation)
{
this.behaviorSide = formation.AI.Side;
this._primarySiegeWeapons = Mission.Current.ActiveMissionObjects.FindAllWithType <UsableMachine>().ToList <UsableMachine>();
this._primarySiegeWeapons.RemoveAll((Predicate <UsableMachine>)(uM => !(uM is IPrimarySiegeWeapon) || (uM as IPrimarySiegeWeapon).WeaponSide != this.behaviorSide));
this._teamAISiegeComponent = (TeamAISiegeComponent)formation.Team.TeamAI;
this.BehaviorCoherence = 0.0f;
this._stopOrder = MovementOrder.MovementOrderStop;
this.RecreateFollowEntityOrder();
if (this._followEntityOrder != (object)null)
{
this._behaviourState = BehaviorUseSiegeMachines.BehaviourState.Follow;
this.CurrentOrder = this._followEntityOrder;
}
else
{
this._behaviourState = BehaviorUseSiegeMachines.BehaviourState.Stop;
this.CurrentOrder = this._stopOrder;
}
}
protected override void CalculateCurrentOrder()
{
Vec2 direction;
WorldPosition medianPosition;
if (this._mainFormation != null)
{
direction = this._mainFormation.Direction;
Vec2 vec2 = (this.formation.QuerySystem.Team.MedianTargetFormationPosition.AsVec2 - this._mainFormation.QuerySystem.MedianPosition.AsVec2).Normalized();
medianPosition = this._mainFormation.QuerySystem.MedianPosition;
medianPosition.SetVec2(this._mainFormation.CurrentPosition + vec2 * (float)(((double)this._mainFormation.Depth + (double)this.formation.Depth) * 0.5 + 10.0));
}
else
{
direction = this.formation.Direction;
medianPosition = this.formation.QuerySystem.MedianPosition;
medianPosition.SetVec2(this.formation.QuerySystem.AveragePosition);
}
this.CurrentOrder = MovementOrder.MovementOrderMove(medianPosition);
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
}
protected AttackOrder(List <Unit> units)
{
this.needAlertAttack = true;
if (units.Count == 0)
{
this.isActive = false;
return;
}
this.idPlayer = units[0].idPlayer;
this.units = new List <Unit>();
this.movementOrder = null;
this.timeCounter = 0;
foreach (Unit unit in units)
{
this.units.Add(unit);
}
RemoveAnotherOrder(this.units);
}
static bool PrefixCalculateCurrentOrder(ref Formation ___formation, ref MovementOrder ____currentOrder, ref FacingOrder ___CurrentFacingOrder)
{
if (___formation != null && ___formation.QuerySystem.IsInfantryFormation && ___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation != null)
{
Formation significantEnemy = Utilities.FindSignificantEnemy(___formation, true, true, false, false, false);
if (significantEnemy != null)
{
___formation.ArrangementOrder = ArrangementOrder.ArrangementOrderLine;
___formation.FiringOrder = FiringOrder.FiringOrderFireAtWill;
___formation.FormOrder = FormOrder.FormOrderWide;
___formation.WeaponUsageOrder = WeaponUsageOrder.WeaponUsageOrderUseAny;
WorldPosition medianPosition = ___formation.QuerySystem.MedianPosition;
____currentOrder = MovementOrder.MovementOrderMove(medianPosition);
Vec2 direction = (significantEnemy.QuerySystem.MedianPosition.AsVec2 - ___formation.QuerySystem.AveragePosition).Normalized();
___CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
return(false);
}
}
return(true);
}
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;
}
protected override void CalculateCurrentOrder()
{
if (this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation == null || (double)this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2.DistanceSquared(this.formation.QuerySystem.AveragePosition) > 2500.0)
{
this.CurrentOrder = this.UncapturedFlagMoveOrder();
}
else
{
FlagCapturePoint flagCapturePoint = (FlagCapturePoint)null;
if (this._flagpositions.Any <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team && !fp.IsContested)))
{
flagCapturePoint = this._flagpositions.Where <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team && !fp.IsContested)).MinBy <FlagCapturePoint, float>((Func <FlagCapturePoint, float>)(fp => this.formation.QuerySystem.AveragePosition.DistanceSquared(fp.Position.AsVec2)));
}
if ((!this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.IsRangedFormation ? 0 : ((double)this.formation.QuerySystem.FormationPower / (double)this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.FormationPower / (double)this.formation.Team.QuerySystem.OverallPowerRatio > 0.699999988079071 ? 1 : 0)) == 0 && flagCapturePoint != null)
{
this.CurrentOrder = MovementOrder.MovementOrderMove(new WorldPosition(Mission.Current.Scene, UIntPtr.Zero, flagCapturePoint.Position, false));
}
else
{
this.CurrentOrder = MovementOrder.MovementOrderChargeToTarget(this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.Formation);
}
}
}
static void PostfixCalculateCurrentOrder(ref Formation ___formation, BehaviorSkirmish __instance, ref BehaviorState ____behaviorState, ref MovementOrder ____currentOrder)
{
switch (____behaviorState)
{
case BehaviorState.Shooting:
if (waitCount > 50)
{
if (___formation != null && ___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation != null && ___formation.QuerySystem.MakingRangedAttackRatio < 0.4f && ___formation.QuerySystem.MedianPosition.AsVec2.Distance(___formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.Formation.QuerySystem.MedianPosition.AsVec2) > 30f)
{
WorldPosition medianPosition = ___formation.QuerySystem.MedianPosition;
medianPosition.SetVec2(medianPosition.AsVec2 + ___formation.Direction * 5f);
____currentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
waitCount = 0;
}
else
{
waitCount++;
}
break;
}
}
public BehaviorWaitForLadders(Formation formation)
: base(formation)
{
this.behaviorSide = formation.AI.Side;
this._ladders = Mission.Current.ActiveMissionObjects.Where <MissionObject>((Func <MissionObject, bool>)(amo => amo is SiegeLadder)).Select <MissionObject, SiegeLadder>((Func <MissionObject, SiegeLadder>)(amo => amo as SiegeLadder)).ToList <SiegeLadder>();
this._ladders.RemoveAll((Predicate <SiegeLadder>)(l => l.IsDeactivated || l.WeaponSide != this.behaviorSide));
this._teamAISiegeComponent = (TeamAISiegeComponent)formation.Team.TeamAI;
SiegeLane siegeLane = TeamAISiegeComponent.SiegeLanes.FirstOrDefault <SiegeLane>((Func <SiegeLane, bool>)(sl => sl.LaneSide == this.behaviorSide));
this._breachedWallSegment = (siegeLane != null ? siegeLane.DefensePoints.FirstOrDefault <ICastleKeyPosition>((Func <ICastleKeyPosition, bool>)(dp => dp is WallSegment && (dp as WallSegment).IsBreachedWall)) : (ICastleKeyPosition)null) as WallSegment;
this.ResetFollowOrder();
this._stopOrder = MovementOrder.MovementOrderStop;
if (this._followOrder != (object)null)
{
this.CurrentOrder = this._followOrder;
this._behaviourState = BehaviorWaitForLadders.BehaviourState.Follow;
}
else
{
this.CurrentOrder = this._stopOrder;
this._behaviourState = BehaviorWaitForLadders.BehaviourState.Stop;
}
}
protected override void CalculateCurrentOrder()
{
if (this._mainFormation == null || this.formation.AI.IsMainFormation || this.formation.QuerySystem.ClosestEnemyFormation == null)
{
this.CurrentOrder = MovementOrder.MovementOrderStop;
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtEnemy;
}
else
{
if (this._protectFlankState != BehaviorProtectFlank.BehaviourState.HoldingFlank && this._protectFlankState != BehaviorProtectFlank.BehaviourState.Returning)
{
return;
}
Vec2 direction = this._mainFormation.Direction;
Vec2 vec2_1 = (this.formation.QuerySystem.Team.MedianTargetFormationPosition.AsVec2 - this._mainFormation.QuerySystem.MedianPosition.AsVec2).Normalized();
Vec2 vec2_2 = this.behaviorSide == FormationAI.BehaviorSide.Right || this.FlankSide == FormationAI.BehaviorSide.Right ? this._mainFormation.CurrentPosition + vec2_1.RightVec().Normalized() * (float)((double)this._mainFormation.Width + (double)this.formation.Width + 10.0) - vec2_1 * (this._mainFormation.Depth + this.formation.Depth) : (this.behaviorSide == FormationAI.BehaviorSide.Left || this.FlankSide == FormationAI.BehaviorSide.Left ? this._mainFormation.CurrentPosition + vec2_1.LeftVec().Normalized() * (float)((double)this._mainFormation.Width + (double)this.formation.Width + 10.0) - vec2_1 * (this._mainFormation.Depth + this.formation.Depth) : this._mainFormation.CurrentPosition + vec2_1 * (float)(((double)this._mainFormation.Depth + (double)this.formation.Depth) * 0.5 + 10.0));
WorldPosition medianPosition = this._mainFormation.QuerySystem.MedianPosition;
medianPosition.SetVec2(vec2_2);
this._movementOrder = MovementOrder.MovementOrderMove(medianPosition);
this.CurrentOrder = this._movementOrder;
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
}
}
protected override void CalculateCurrentOrder()
{
BehaviorSergeantMPInfantry.BehaviorState behaviorState = this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation == null || (!this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.IsRangedFormation || (double)this.formation.QuerySystem.AveragePosition.DistanceSquared(this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2) > (this._behaviorState == BehaviorSergeantMPInfantry.BehaviorState.Attacking ? 3600.0 : 2500.0)) && (!this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.IsInfantryFormation || (double)this.formation.QuerySystem.AveragePosition.DistanceSquared(this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2) > (this._behaviorState == BehaviorSergeantMPInfantry.BehaviorState.Attacking ? 900.0 : 400.0)) ? BehaviorSergeantMPInfantry.BehaviorState.GoingToFlag : BehaviorSergeantMPInfantry.BehaviorState.Attacking;
if (behaviorState == BehaviorSergeantMPInfantry.BehaviorState.Attacking && (this._behaviorState != BehaviorSergeantMPInfantry.BehaviorState.Attacking || this.CurrentOrder.OrderEnum != MovementOrder.MovementOrderEnum.ChargeToTarget || this.CurrentOrder.TargetFormation.QuerySystem != this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation))
{
this._behaviorState = BehaviorSergeantMPInfantry.BehaviorState.Attacking;
this.CurrentOrder = MovementOrder.MovementOrderChargeToTarget(this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.Formation);
}
if (behaviorState != BehaviorSergeantMPInfantry.BehaviorState.GoingToFlag)
{
return;
}
this._behaviorState = behaviorState;
WorldPosition position;
if (this._flagpositions.Any <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team)))
{
position = new WorldPosition(Mission.Current.Scene, UIntPtr.Zero, this._flagpositions.Where <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) != this.formation.Team)).MinBy <FlagCapturePoint, float>((Func <FlagCapturePoint, float>)(fp => fp.Position.AsVec2.DistanceSquared(this.formation.QuerySystem.AveragePosition))).Position, false);
}
else if (this._flagpositions.Any <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) == this.formation.Team)))
{
position = new WorldPosition(Mission.Current.Scene, UIntPtr.Zero, this._flagpositions.Where <FlagCapturePoint>((Func <FlagCapturePoint, bool>)(fp => this._flagDominationGameMode.GetFlagOwnerTeam(fp) == this.formation.Team)).MinBy <FlagCapturePoint, float>((Func <FlagCapturePoint, float>)(fp => fp.Position.AsVec2.DistanceSquared(this.formation.QuerySystem.AveragePosition))).Position, false);
}
else
{
position = this.formation.QuerySystem.MedianPosition;
position.SetVec2(this.formation.QuerySystem.AveragePosition);
}
if (this.CurrentOrder.OrderEnum != MovementOrder.MovementOrderEnum.Invalid && !(this.CurrentOrder.GetPosition(this.formation).AsVec2 != position.AsVec2))
{
return;
}
Vec2 direction = this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation != null ? (this.formation.QuerySystem.ClosestSignificantlyLargeEnemyFormation.MedianPosition.AsVec2 - this.formation.QuerySystem.AveragePosition).Normalized() : this.formation.Direction;
this.CurrentOrder = MovementOrder.MovementOrderMove(position);
this.CurrentFacingOrder = FacingOrder.FacingOrderLookAtDirection(direction);
}
protected override void CalculateCurrentOrder()
{
WorldPosition medianPosition = this.formation.QuerySystem.MedianPosition;
if (this._mainFormation == null)
{
medianPosition.SetVec2(this.formation.QuerySystem.AveragePosition);
}
else
{
Vec2 asVec2 = this._mainFormation.MovementOrder.GetPosition(this._mainFormation).AsVec2;
if (asVec2.IsValid)
{
Vec2 vec2_1 = (asVec2 - this._mainFormation.QuerySystem.AveragePosition).Normalized();
Vec2 vec2_2 = asVec2 - vec2_1 * this._mainFormation.Depth * 2f;
medianPosition.SetVec2(vec2_2);
}
else
{
medianPosition.SetVec2(this.formation.QuerySystem.AveragePosition);
}
}
this.CurrentOrder = MovementOrder.MovementOrderMove(medianPosition);
}
