public static bool AnyEnemyInTowerRange(Units tower, Units ruleOut = null)
{
TeamType teamType = (tower.teamType != 0) ? TeamType.LM : TeamType.BL;
IList <Units> mapUnits = MapManager.Instance.GetMapUnits(teamType, TargetTag.HeroAndMonster);
if (mapUnits == null)
{
return(false);
}
foreach (Units current in mapUnits)
{
if (UnitFeature.DistanceToTarget(tower.mTransform, current.mTransform) <= tower.GetAttackRange(current))
{
if (!(ruleOut != null) || !(current == ruleOut))
{
return(true);
}
}
}
return(false);
}
public static Units GetNearestTowerOfCustom(Units compareTarget, IList <Units> towers)
{
float num = 999999f;
Units result = null;
if (towers != null)
{
foreach (Units current in towers)
{
if (current.isLive)
{
float num2 = UnitFeature.DistanceToTarget(current.mTransform, compareTarget.mTransform);
if (num2 < num)
{
num = num2;
result = current;
}
}
}
}
return(result);
}
public static int GetNearestTransOfTarget(Units target, Dictionary <string, Transform> points)
{
float num = 999999f;
int result = -1;
if (points != null)
{
int num2 = -1;
foreach (string current in points.Keys)
{
num2++;
Transform owner = points[current];
float num3 = UnitFeature.DistanceToTarget(owner, target.mTransform);
if (num3 < num)
{
num = num3;
result = num2;
}
}
}
return(result);
}
private bool IfChoose(Units target)
{
return((!target.isMonster || target.teamType != 2) && (TeamManager.CanAttack(this.m_Owner, target) && target.CanBeSelected && !target.isItem && UnitFeature.DistanceToTarget(this.m_Owner.transform, target.transform) <= this.m_Owner.GetAttackRange(target)));
}
private bool IfChoose(Units target)
{
return(!(target == null) && (!target.isMonster || target.teamType != 2) && (target.isBuilding || UnitFeature.DistanceToTarget(this.m_Owner.transform, target.transform) <= this.m_Owner.warning_range) && (TeamManager.CanAttack(this.m_Owner, target) && target.CanBeSelected && target.isLive && !target.isItem));
}
public static bool IfChooseTarget(Units owner, Units target, bool isKillTarget = false, float range = 0f)
{
if (target == null || !target.isLive || !TeamManager.CanAttack(owner, target) || !target.CanBeSelected || target.isBuilding || target.isItem || (target.isMonster && target.teamType == 2) || !owner.CanBeSelected)
{
return(false);
}
if (!isKillTarget && target.isHero && UnitFeature.DistanceToTarget(owner.transform, target.transform) > owner.warning_range)
{
return(false);
}
Units home = MapManager.Instance.GetHome((TeamType)target.teamType);
if (home == null)
{
return(true);
}
if (owner.MeiHuo.IsInState)
{
return(true);
}
if (range != 0f && !HeroTargetingSystem.IsInrange(owner.mTransform.position, target.mTransform.position, range))
{
return(false);
}
bool arg_10E_0 = !StrategyManager.Instance.IsAuto() && owner.isPlayer;
UtilCounter counter = UtilManager.Instance.GetCounter(UtilType.Tower);
if (counter != null)
{
TowerCounter towerCounter = counter as TowerCounter;
Units towerOfLowestPriority = towerCounter.GetTowerOfLowestPriority(owner);
if (towerOfLowestPriority != null)
{
float num = UnitFeature.DistanceToTargetSqr(owner.transform, towerOfLowestPriority.transform);
float num2 = UnitFeature.DistanceToTargetSqr(owner.transform, target.transform);
if (num2 > num)
{
return(false);
}
}
}
bool flag = StrategyManager.Instance.IsHomeRecovery((TeamType)target.teamType);
if (flag)
{
Vector3 recoveryPos = StrategyManager.Instance.GetRecoveryPos((TeamType)target.teamType);
if (HeroTargetingSystem.IsInrange(target.transform.position, recoveryPos, 3f))
{
return(false);
}
}
Units nearestEnemyTowerOfTarget = TargetSelectHelper.GetNearestEnemyTowerOfTarget(target);
if (nearestEnemyTowerOfTarget != null)
{
float attackRange = nearestEnemyTowerOfTarget.GetAttackRange(owner);
if (HeroTargetingSystem.IsInrange(target.transform.position, nearestEnemyTowerOfTarget.transform.position, attackRange))
{
float num3 = UnitFeature.DistanceToTarget(target, nearestEnemyTowerOfTarget);
if (owner.GetAttackRange(target) + num3 > attackRange && !HeroTargetingSystem.IsInrange(owner.transform.position, nearestEnemyTowerOfTarget.transform.position, attackRange))
{
return(true);
}
Units attackTarget = nearestEnemyTowerOfTarget.GetAttackTarget();
if (attackTarget != null && attackTarget == owner)
{
return(false);
}
List <Units> allians = TargetSelectHelper.GetAllians(nearestEnemyTowerOfTarget, attackRange, TargetTag.Monster, false);
return(allians != null && allians.Count > 1 && !target.isHero);
}
}
return(true);
}
public static bool TargetInDistance(Transform owner, Transform target, float distance)
{
return(UnitFeature.DistanceToTarget(owner, target) <= distance);
}
public void MoveToTarget(Units target, float stopDistance)
{
if (target != null && this.self.CanMove)
{
bool flag = false;
if (this.curMoveState == EMoveState.MoveState_MoveToTarget)
{
if (this.curMoveStateTargetId == target.unique_id)
{
if (DateTime.Now.Ticks - this.lastSearchPath > 5000000L)
{
flag = true;
}
}
else
{
flag = true;
}
}
else
{
flag = true;
}
if (!flag)
{
return;
}
this.curMoveState = EMoveState.MoveState_MoveToTarget;
this.curMoveStateTargetId = target.unique_id;
this.lastSearchPath = DateTime.Now.Ticks;
if (Singleton <PvpManager> .Instance.IsInPvp)
{
if (this.self.isPlayer || (this.self.MirrorState && this.self.ParentUnit.isPlayer))
{
this.self.InterruptAction(SkillInterruptType.Initiative);
float num = UnitFeature.DistanceToTarget(this.self.mTransform, target.mTransform);
if (num < stopDistance + 3f)
{
this.m_DistanceToTargetType = DistanceToTargetType.NearByTarget;
}
else
{
this.m_DistanceToTargetType = DistanceToTargetType.FarFromTarget;
}
if (GlobalSettings.Instance.PvpSetting.isPlayerMoveBeforeServer && this.navAgent != null)
{
this.navAgent.MoveToTarget(target, stopDistance);
}
this.SendMoveToTarget(target.unique_id, target.transform.position, stopDistance);
}
}
else
{
this.self.InterruptAction(SkillInterruptType.Initiative);
float num2 = UnitFeature.DistanceToTarget(this.self.mTransform, target.mTransform);
if (num2 < stopDistance + 3f)
{
this.m_DistanceToTargetType = DistanceToTargetType.NearByTarget;
}
else
{
this.m_DistanceToTargetType = DistanceToTargetType.FarFromTarget;
}
if (this.navAgent != null)
{
this.navAgent.MoveToTarget(target, stopDistance);
}
}
}
}
public bool CheckInputTarget(InputTargetType targetType, GoalTarget goal)
{
if (goal != null)
{
Units unit = goal.m_Unit;
if (targetType == InputTargetType.MoveTarget)
{
return(unit != null && unit.isLive);
}
if (unit == null || !unit.isLive || !unit.CanBeSelected || !TeamManager.CanAttack(this.m_Owner, goal.m_Unit) || UnitFeature.DistanceToTarget(this.m_Owner.transform, unit.transform) > this.m_Owner.fog_range)
{
return(false);
}
switch (targetType)
{
case InputTargetType.AttackTarget:
case InputTargetType.KillTarget:
case InputTargetType.BuffTarget:
case InputTargetType.FixedTarget:
case InputTargetType.AttackYouTarget:
case InputTargetType.TauntTarget:
case InputTargetType.GuardTarget:
return(true);
case InputTargetType.SelectTarget:
return(this.m_Owner.isPlayer);
}
}
return(false);
}
