private int SortFunc(Units enemy1, Units enemy2)
{
if (!(enemy1 != null) || !(enemy2 != null) || !enemy1.isLive || !enemy2.isLive)
{
return(0);
}
Units home = MapManager.Instance.GetHome((TeamType)this.m_Owner.teamType);
if (home == null)
{
return(0);
}
float num = UnitFeature.DistanceToTargetSqr(home.mTransform, enemy1.mTransform);
float num2 = UnitFeature.DistanceToTargetSqr(home.mTransform, enemy2.mTransform);
if (num < num2)
{
return(-1);
}
if (num == num2)
{
return(0);
}
return(1);
}
public static void FilterTargetsRef(Units self, ref List <Units> targets, FindType findType, object param)
{
if (targets != null && targets.Count > 0)
{
switch (findType)
{
case FindType.FirstIndex:
{
int num = (int)param;
for (int i = 0; i < targets.Count; i++)
{
if (i > num)
{
targets.RemoveAt(i);
i--;
}
}
break;
}
case FindType.Distance:
{
float num2 = (float)param * (float)param;
for (int j = 0; j < targets.Count; j++)
{
float num3 = UnitFeature.DistanceToTargetSqr(self.mTransform, targets[j].mTransform);
if (num3 > num2)
{
targets.RemoveAt(j);
j--;
}
}
break;
}
case FindType.Blood:
{
float num4 = (float)param;
for (int k = 0; k < targets.Count; k++)
{
if (targets[k].hp > targets[k].hp_max * num4)
{
targets.RemoveAt(k);
k--;
}
}
break;
}
}
}
}
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 void SortTargets(Units self, SortType sortType, ref List <Units> target_units)
{
if (target_units != null && target_units.Count > 1)
{
switch (sortType)
{
case SortType.Hatred:
target_units.Sort(delegate(Units a, Units b)
{
if (a.unique_id == b.unique_id)
{
return(0);
}
int targetHatredValue = self.GetTargetHatredValue(a);
int targetHatredValue2 = self.GetTargetHatredValue(b);
int result = -1;
if (targetHatredValue > targetHatredValue2)
{
result = -1;
}
else if (targetHatredValue < targetHatredValue2)
{
result = 1;
}
return(result);
});
break;
case SortType.Distance:
target_units.Sort(delegate(Units a, Units b)
{
if (a.unique_id == b.unique_id)
{
return(0);
}
float num = 0f;
if (a != null)
{
num = UnitFeature.DistanceToTargetSqr(self.mTransform, a.mTransform);
}
float num2 = 0f;
if (b != null)
{
num2 = UnitFeature.DistanceToTargetSqr(self.mTransform, b.mTransform);
}
int result = -1;
if (num > num2)
{
result = 1;
}
else if (num < num2)
{
result = -1;
}
return(result);
});
break;
case SortType.Blood:
target_units.Sort(delegate(Units a, Units b)
{
if (a.unique_id == b.unique_id)
{
return(0);
}
float hp = a.hp;
float hp2 = b.hp;
int result = -1;
if (hp > hp2)
{
result = 1;
}
else if (hp < hp2)
{
result = -1;
}
return(result);
});
break;
case SortType.Magic:
target_units.Sort(delegate(Units a, Units b)
{
if (a.unique_id == b.unique_id)
{
return(0);
}
float mp = a.mp;
float mp2 = b.mp;
int result = -1;
if (mp > mp2)
{
result = 1;
}
else if (mp < mp2)
{
result = -1;
}
return(result);
});
break;
case SortType.Prority:
target_units.Sort(delegate(Units a, Units b)
{
if (a.unique_id == b.unique_id)
{
return(0);
}
int targetPorityValue = self.GetTargetPorityValue(a);
int targetPorityValue2 = self.GetTargetPorityValue(b);
int result = -1;
if (targetPorityValue > targetPorityValue2)
{
result = -1;
}
else if (targetPorityValue < targetPorityValue2)
{
result = 1;
}
return(result);
});
break;
}
}
}
