private bool ShouldSeekAlternativeTarget(SmartEntity troopEntity)
{
if (troopEntity.TroopComp == null)
{
Service.Logger.Error("Non troop entity checking for alternative target in TargetingSystem");
return(false);
}
return(troopEntity.DefenderComp == null && !TroopController.IsEntityHealer(troopEntity) && !TroopController.IsEntityPhantom(troopEntity));
}
private bool WillCrushNearTarget(SmartEntity troop, SmartEntity target)
{
if (!TroopController.CanEntityCrushWalls(troop))
{
return(false);
}
BuildingComponent buildingComp = target.BuildingComp;
return(buildingComp != null && buildingComp.BuildingType.Type == BuildingType.Wall);
}
private void UpdateShieldInLineOfShoot(SmartEntity troop, SmartEntity target)
{
if (troop.TeamComp.TeamType == TeamType.Defender || TroopController.IsEntityHealer(troop))
{
return;
}
int x;
int y;
int x2;
int y2;
this.GetAttackEndPoints(troop, target, out x, out y, out x2, out y2);
this.hitShieldCell = BoardUtils.WhereDoesLineCrossFlag(Service.BoardController.Board, x, y, x2, y2, 8u);
}
public bool FindTargetForTroopNode(SmartEntity entity, bool onlyUpdateIfNewTargetFound)
{
if (entity.TroopComp.TroopShooterVO.TargetLocking && entity.ShooterComp.Target != null)
{
return(!onlyUpdateIfNewTargetFound);
}
if (!onlyUpdateIfNewTargetFound)
{
entity.ShooterComp.Target = null;
}
if (entity.TroopComp.TroopShooterVO.TargetSelf)
{
return(this.UpdateShooterTarget(onlyUpdateIfNewTargetFound, entity, entity));
}
bool flag = false;
if (TroopController.IsEntityHealer(entity))
{
SmartEntity smartEntity = this.FindBestTargetForHealer(entity);
flag = this.UpdateShooterTarget(onlyUpdateIfNewTargetFound, entity, smartEntity);
}
else if (entity.TeamComp.TeamType == TeamType.Attacker)
{
SmartEntity smartEntity = this.FindTargetForAttacker(entity);
if (smartEntity != null && entity.ShooterComp != null && entity.ShooterComp.ShooterVO.NewTargetOnReload)
{
entity.ShooterComp.AddEntityTargetIdToHistory(smartEntity.ID);
}
flag = this.UpdateShooterTarget(onlyUpdateIfNewTargetFound, entity, smartEntity);
}
else if (entity.TeamComp.TeamType == TeamType.Defender)
{
DefenderComponent defenderComp = entity.DefenderComp;
SmartEntity smartEntity = this.FindOffensiveTroopAsTarget(entity);
flag = this.UpdateShooterTarget(onlyUpdateIfNewTargetFound, entity, smartEntity);
if (smartEntity != null && entity.ShooterComp != null && entity.ShooterComp.ShooterVO.NewTargetOnReload)
{
entity.ShooterComp.AddEntityTargetIdToHistory(smartEntity.ID);
}
if (flag)
{
entity.DefenderComp.Patrolling = false;
}
else if ((defenderComp.Leashed || !entity.ShooterComp.FirstTargetAcquired) && !onlyUpdateIfNewTargetFound && entity.StateComp.CurState != EntityState.Disable)
{
this.TroopWandering(entity);
}
}
return(flag);
}
public void DeployDropShipTroops(IntPosition spawnPosition, string troopUid, uint count, TeamType teamType)
{
int num = 0;
StaticDataController staticDataController = Service.StaticDataController;
TroopTypeVO troopVO = staticDataController.Get <TroopTypeVO>(troopUid);
TroopController troopController = Service.TroopController;
int num2 = 0;
while ((long)num2 < (long)((ulong)count))
{
troopController.DeployTroopWithOffset(troopVO, ref num, spawnPosition, true, teamType);
num2++;
}
this.numHoveringInbound--;
}
public Entity DeployTroopWithOffset(TroopTypeVO troopVO, ref int currentOffsetIndex, IntPosition spawnPosition, bool forceAllow, TeamType teamType)
{
TroopController troopController = Service.TroopController;
IntPosition ip = TroopDeployer.OFFSETS[currentOffsetIndex] * troopVO.AutoSpawnSpreadingScale;
IntPosition boardPosition = spawnPosition + ip;
if (!troopController.ValidateAttackerTroopPlacement(boardPosition, troopVO.SizeX, false))
{
boardPosition = spawnPosition;
}
if (++currentOffsetIndex == TroopDeployer.OFFSETS.Length)
{
currentOffsetIndex = 0;
}
return(troopController.SpawnTroop(troopVO, teamType, boardPosition, TroopSpawnMode.Unleashed, true, forceAllow));
}
private bool HasLineOfSight(SmartEntity troop, SmartEntity target)
{
int x;
int y;
int x2;
int y2;
this.GetAttackEndPoints(troop, target, out x, out y, out x2, out y2);
BoardCell boardCell = null;
bool result = TroopController.IsEntityHealer(troop) || troop.TeamComp.TeamType == TeamType.Defender || BoardUtils.HasLineOfSight(Service.BoardController.Board, x, y, x2, y2, troop, target, out boardCell);
if (this.ShouldSeekObstacleTarget(troop))
{
this.hitShieldCell = boardCell;
}
return(result);
}
public void StartDefenseMission(CampaignMissionVO mission)
{
if (this.activeDefenseBattle)
{
Service.Logger.WarnFormat("Mission {0} is already in progress. Cannot start Mission {1}.", new object[]
{
this.currentMission.Uid,
mission.Uid
});
return;
}
this.troopController = Service.TroopController;
this.eventManager = Service.EventManager;
this.activeDefenseBattle = true;
this.autoMoveCamera = false;
this.currentMission = mission;
this.randomizeWaves = !mission.FixedWaves;
this.waves = DefensiveBattleController.ParseWaves(this.currentMission.Waves);
this.wavesDeployed = 0;
this.waveCount = this.waves.Count;
this.AllWavesClear = false;
if (mission.IsRaidDefense())
{
Service.RaidDefenseController.OnStartRaidDefenseMission();
}
this.eventManager.RegisterObserver(this, EventId.EntityKilled, EventPriority.BeforeDefault);
this.eventManager.RegisterObserver(this, EventId.UserStartedCameraMove, EventPriority.Default);
this.eventManager.RegisterObserver(this, EventId.CameraFinishedMoving, EventPriority.Default);
this.eventManager.RegisterObserver(this, EventId.PreEntityKilled, EventPriority.Default);
this.eventManager.RegisterObserver(this, EventId.EntityHit, EventPriority.Default);
TrapViewController trapViewController = Service.TrapViewController;
NodeList <TrapNode> trapNodeList = Service.BuildingLookupController.TrapNodeList;
for (TrapNode trapNode = trapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
{
trapViewController.UpdateTrapVisibility((SmartEntity)trapNode.Entity);
}
Vector3 zero = Vector3.zero;
Service.WorldInitializer.View.ZoomTo(0.7f);
Service.WorldInitializer.View.PanToLocation(zero);
this.DeployNextWave(0u, null);
}
protected bool IsTargetInRangeForAttack(SmartEntity troop, SmartEntity target, bool isLastTile)
{
if (target.ShieldBorderComp != null)
{
return(true);
}
if (this.WillCrushNearTarget(troop, target))
{
return(false);
}
if (isLastTile && GameUtils.IsEntityShieldGenerator(troop.ShooterComp.Target) && troop.ShooterComp.Target != target)
{
return(true);
}
ShooterComponent shooterComp = troop.ShooterComp;
int num = GameUtils.GetSquaredDistanceToTarget(shooterComp, target);
TroopComponent troopComp = troop.TroopComp;
uint num2 = 0u;
if (troopComp != null)
{
if (TroopController.IsEntityHealer(troop))
{
num += (int)((shooterComp.MaxAttackRangeSquared - shooterComp.MinAttackRangeSquared) / 2u);
}
if (!shooterComp.IsMelee)
{
num2 = Service.PathingManager.GetMaxAttackRange(troop, target);
}
}
if (num2 != 0u)
{
if (!this.shooterController.InRange(num, shooterComp, num2))
{
return(false);
}
}
else if (!this.shooterController.InRange(num, shooterComp))
{
return(false);
}
return(true);
}
private bool CheckTarget(SmartEntity shooter, SmartEntity target, ref int maxWeight)
{
if (shooter == null || target == null)
{
return(false);
}
TransformComponent transformComp = target.TransformComp;
TroopComponent troopComp = target.TroopComp;
if (transformComp == null || troopComp == null)
{
return(false);
}
ShooterComponent shooterComp = shooter.ShooterComp;
if ((long)GameUtils.GetSquaredDistanceToTarget(shooterComp, target) < (long)((ulong)shooterComp.MinAttackRangeSquared))
{
return(false);
}
if (TroopController.IsEntityPhantom(target))
{
return(false);
}
if (shooterComp.OriginalShooterVO.NewTargetOnReload && !shooterComp.IsPotentialTargetNew(target.ID))
{
return(false);
}
TransformComponent transformComp2 = shooter.TransformComp;
int squaredDistance = GameUtils.SquaredDistance(transformComp2.CenterGridX(), transformComp2.CenterGridZ(), transformComp.CenterGridX(), transformComp.CenterGridZ());
int targetNearness = this.spatialIndexController.CalcNearness(squaredDistance);
int num = this.CalculateWeight(shooterComp, null, troopComp.TroopType.ArmorType, targetNearness);
if (num > maxWeight)
{
maxWeight = num;
return(true);
}
return(false);
}
public bool IsHealable(SmartEntity target, object self)
{
if (target == null)
{
return(false);
}
SmartEntity smartEntity = (SmartEntity)self;
if (target == smartEntity)
{
return(false);
}
TroopComponent troopComp = target.TroopComp;
HealthComponent healthComp = target.HealthComp;
TeamComponent teamComp = target.TeamComp;
if (troopComp == null || healthComp == null || teamComp == null)
{
return(false);
}
if (target.TeamComp.TeamType != smartEntity.TeamComp.TeamType)
{
return(false);
}
if (TroopController.IsEntityPhantom(target))
{
return(false);
}
if (TroopController.IsEntityHealer(target))
{
return(false);
}
TroopComponent troopComp2 = smartEntity.TroopComp;
return(troopComp2 == null || !TroopController.IsEntityHealer(smartEntity) || this.CanBeHealed(target, smartEntity));
}
public unsafe static long $Invoke0(long instance, long *args)
{
return(GCHandledObjects.ObjectToGCHandle(TroopController.IsEntityHealer((SmartEntity)GCHandledObjects.GCHandleToObject(*args))));
}
private bool ShouldSeekObstacleTarget(SmartEntity troop)
{
return(!TroopController.IsEntityHealer(troop) && !troop.ShooterComp.ShooterVO.ProjectileType.PassThroughShield && troop.DefenderComp == null);
}
public void RotateGameObject(SmartEntity entity, float dx, float dz, float dt)
{
GameObjectViewComponent gameObjectViewComp = entity.GameObjectViewComp;
TransformComponent transformComp = entity.TransformComp;
if (entity.TroopComp != null && entity.TroopComp.TroopShooterVO.TargetSelf && transformComp.RotationInitialized)
{
return;
}
float num = transformComp.Rotation;
bool flag = dx != 0f || dz != 0f;
SmartEntity smartEntity = null;
GameObjectViewComponent gameObjectViewComponent = null;
SecondaryTargetsComponent secondaryTargetsComp = entity.SecondaryTargetsComp;
ShooterComponent shooterComp = entity.ShooterComp;
if (secondaryTargetsComp != null && shooterComp != null)
{
ShooterController shooterController = Service.Get <ShooterController>();
smartEntity = shooterController.GetTroopTarget(secondaryTargetsComp, shooterComp);
if (smartEntity != null && (gameObjectViewComponent = smartEntity.GameObjectViewComp) == null)
{
smartEntity = shooterController.GetPrimaryTarget(shooterComp);
if (smartEntity != null)
{
gameObjectViewComponent = smartEntity.GameObjectViewComp;
}
}
}
else
{
PathingComponent pathingComp = entity.PathingComp;
if (pathingComp != null)
{
smartEntity = pathingComp.Target;
if (smartEntity != null)
{
gameObjectViewComponent = smartEntity.GameObjectViewComp;
}
}
}
bool flag2 = !transformComp.RotationInitialized;
if (flag2 && smartEntity == null && (entity.DefenderComp != null || TroopController.IsEntityHealer(entity)))
{
gameObjectViewComp.MainGameObject.SetActive(true);
transformComp.RotationInitialized = true;
}
else
{
bool flag3 = flag2 || entity.StateComp.CurState == EntityState.Attacking || entity.StateComp.CurState == EntityState.Turning;
if (flag3 && gameObjectViewComponent != null)
{
gameObjectViewComp.ComputeRotationToTarget(gameObjectViewComponent, ref num);
flag = false;
if (flag2)
{
gameObjectViewComp.MainGameObject.SetActive(true);
transformComp.Rotation = num;
transformComp.RotationInitialized = true;
}
}
}
if (flag)
{
num = Mathf.Atan2(dz, dx);
}
num = MathUtils.MinAngle(transformComp.Rotation, num);
float num2 = (float)entity.WalkerComp.SpeedVO.RotationSpeed / 1000f;
float smoothTime = 0.7853982f / num2;
float num3 = (dt == 0f) ? transformComp.Rotation : Mathf.SmoothDampAngle(transformComp.Rotation, num, ref transformComp.RotationVelocity, smoothTime, num2, dt);
num3 = MathUtils.WrapAngle(num3);
gameObjectViewComp.Rotate(num3 + -1.57079637f);
transformComp.Rotation = num3;
}
public void UpdateTroop(SmartEntity troop)
{
this.EnsurePrimaryTarget(troop);
this.UpdateTroopShield(troop);
SmartEntity troopTarget = this.shooterController.GetTroopTarget(troop);
for (SmartEntity troopWallCrushingTarget = this.shooterController.GetTroopWallCrushingTarget(troop); troopWallCrushingTarget != null; troopWallCrushingTarget = this.shooterController.GetTroopWallCrushingTarget(troop))
{
if (!this.CanCrushNearTargetNow(troop, troopWallCrushingTarget))
{
break;
}
this.OnTargetWallIsDestroyed(troop, troopWallCrushingTarget);
}
while (troopTarget != null)
{
HealthComponent healthComp = troopTarget.HealthComp;
if (healthComp != null && !healthComp.IsDead())
{
break;
}
this.OnTargetIsDead(troop);
troopTarget = this.shooterController.GetTroopTarget(troop);
}
ShooterComponent shooterComp = troop.ShooterComp;
bool flag = shooterComp.PrimaryTargetMoved();
PathingComponent pathingComp = troop.PathingComp;
bool flag2 = pathingComp == null || pathingComp.CurrentPath == null || pathingComp.GetNextTile() == null;
if (troopTarget == null)
{
this.OnTargetIsNull(troop);
}
else if (!this.IsTargetInRangeForAttack(troop, troopTarget, flag2) || (flag && shooterComp.Target != troopTarget))
{
this.OnTargetIsOutOfRange(troop, flag);
}
else
{
if (troopTarget.TransformComp == null)
{
base.UpdateShooter(troop);
return;
}
this.hitShieldCell = null;
if (flag2)
{
this.UpdateShieldInLineOfShoot(troop, troopTarget);
base.UpdateShooter(troop);
return;
}
if (this.HasLineOfSight(troop, troopTarget))
{
if (!TroopController.IsEntityHealer(troop) || flag2)
{
base.UpdateShooter(troop);
}
return;
}
this.OnTargetIsOutOfRange(troop, flag2 || flag);
}
}
private bool UpdateNode(SmartEntity entity, TargetingController.OnTargetingDone onTroopTargetingDone, bool updateWallBreakingTroops)
{
if (entity.StateComp.CurState == EntityState.Disable)
{
return(false);
}
bool flag = false;
if (updateWallBreakingTroops)
{
return(this.UpdateWallBreakingTroops(entity, onTroopTargetingDone));
}
if (!GameUtils.IsEligibleToFindTarget(entity.ShooterComp))
{
return(false);
}
ShooterComponent shooterComp = entity.ShooterComp;
if (!shooterComp.Searching && !shooterComp.ReevaluateTarget)
{
return(false);
}
bool flag2;
if (shooterComp.Searching)
{
if (shooterComp.TargetingDelayAmount > 0)
{
shooterComp.TargetingDelayAmount--;
return(false);
}
flag2 = this.FindTargetForTroopNode(entity, false);
}
else
{
flag2 = this.FindTargetForTroopNode(entity, true);
}
shooterComp.ReevaluateTarget = false;
if (!flag2)
{
return(false);
}
if (!shooterComp.Searching)
{
shooterComp.AttackFSM.StopAttacking(true);
}
SmartEntity primaryTarget = this.shooterController.GetPrimaryTarget(entity.ShooterComp);
if (primaryTarget.TransformComp == null)
{
return(false);
}
flag = false;
TroopComponent troopComp = entity.TroopComp;
ITroopDeployableVO troopType = troopComp.TroopType;
IShooterVO shooterVO = shooterComp.ShooterVO;
uint maxAttackRange = this.pathingManager.GetMaxAttackRange(entity, primaryTarget);
PathTroopParams troopParams = new PathTroopParams
{
TroopWidth = entity.SizeComp.Width,
DPS = shooterVO.DPS,
MinRange = shooterVO.MinAttackRange,
MaxRange = maxAttackRange,
MaxSpeed = troopComp.SpeedVO.MaxSpeed,
PathSearchWidth = troopType.PathSearchWidth,
IsMelee = shooterComp.IsMelee,
IsOverWall = shooterComp.ShooterVO.OverWalls,
IsHealer = TroopController.IsEntityHealer(entity),
SupportRange = troopType.SupportFollowDistance,
CrushesWalls = TroopController.CanEntityCrushWalls(entity),
ProjectileType = shooterVO.ProjectileType,
IsTargetShield = GameUtils.IsEntityShieldGenerator(primaryTarget),
TargetInRangeModifier = troopType.TargetInRangeModifier
};
PathBoardParams boardParams = new PathBoardParams
{
IgnoreWall = TroopController.CanEntityIgnoreWalls(entity),
Destructible = entity.TeamComp.CanDestructBuildings()
};
bool flag3 = this.pathingManager.StartPathing(entity, primaryTarget, entity.TransformComp, true, out flag, -1, troopParams, boardParams, false, false);
if (!flag3)
{
onTroopTargetingDone(entity);
this.shooterController.StopSearch(shooterComp);
return(true);
}
if (!flag)
{
GameUtils.UpdateMinimumFrameCountForNextTargeting(shooterComp);
return(false);
}
this.RandomizeTargetingDelay(shooterComp);
onTroopTargetingDone(entity);
this.shooterController.StopSearch(shooterComp);
this.OnPathingComplete(entity, entity.SecondaryTargetsComp, entity.StateComp, shooterComp, primaryTarget);
return(true);
}
private void TroopWandering(SmartEntity entity)
{
BoardController boardController = Service.BoardController;
DefenderComponent defenderComp = entity.DefenderComp;
if (defenderComp == null || defenderComp.Patrolling)
{
return;
}
TransformComponent transformComp = entity.TransformComp;
if (transformComp == null)
{
return;
}
defenderComp.Patrolling = true;
int x = transformComp.X;
int z = transformComp.Z;
BoardCell cellAt = boardController.Board.GetCellAt(x, z);
int num = defenderComp.PatrolLoc;
int num2 = (defenderComp.SpawnBuilding != null) ? 4 : 8;
int viewRange = (int)entity.ShooterComp.ShooterVO.ViewRange;
for (int i = 0; i < num2; i++)
{
BoardCell boardCell;
if (defenderComp.SpawnBuilding == null)
{
num = (num + 1) % num2;
int x2 = defenderComp.SpawnX + viewRange * TargetingController.x_mul[num] / TargetingController.x_div[num] / 2;
int z2 = defenderComp.SpawnZ + viewRange * TargetingController.z_mul[num] / TargetingController.z_div[num] / 2;
boardCell = boardController.Board.GetClampedToBoardCellAt(x2, z2, entity.SizeComp.Width);
}
else
{
boardCell = defenderComp.SpawnBuilding.FindNextPatrolPoint(entity.SizeComp.Width, ref num);
}
if (boardCell.IsWalkable())
{
if (Service.PathingManager.StartPathingWorkerOrPatrol(entity, null, cellAt, boardCell, entity.SizeComp.Width, entity.TroopComp != null && TroopController.CanEntityCrushWalls(entity)))
{
Service.ShooterController.StartMoving(entity);
defenderComp.PatrolLoc = num;
Service.ShooterController.StopSearch(entity.ShooterComp);
return;
}
}
}
entity.StateComp.CurState = EntityState.Idle;
}
