Example #1
0
 internal float GetSpellMinRangeForTarget(Unit target, SpellInfo spellInfo)
 {
     if (Mathf.Approximately(spellInfo.MinRangeFriend, spellInfo.MinRangeHostile))
     {
         return(spellInfo.GetMinRange(false));
     }
     if (target == null)
     {
         return(spellInfo.GetMinRange(true));
     }
     return(spellInfo.GetMinRange(!unit.IsHostileTo(target)));
 }
Example #2
0
        private SpellCastResult ValidateRange()
        {
            if (spellCastFlags.HasTargetFlag(SpellCastFlags.IgnoreRangeCheck))
            {
                return(SpellCastResult.Success);
            }

            switch (SpellInfo.ExplicitTargetType)
            {
            case SpellExplicitTargetType.None:
                return(SpellCastResult.Success);

            case SpellExplicitTargetType.Caster:
                return(SpellCastResult.Success);

            case SpellExplicitTargetType.Target:
                return(ValidateTargetRange());

            case SpellExplicitTargetType.Destination:
                return(ValidateDestinationRange());

            default:
                throw new ArgumentOutOfRangeException();
            }

            SpellCastResult ValidateTargetRange()
            {
                if (ExplicitTargets.Target == null || ExplicitTargets.Target == Caster)
                {
                    return(SpellCastResult.Success);
                }

                Unit target = ExplicitTargets.Target;

                float minRange = 0.0f;
                float maxRange = 0.0f;
                float rangeMod = 0.0f;

                if (SpellInfo.RangedFlags.HasTargetFlag(SpellRangeFlags.Melee))
                {
                    rangeMod = StatUtils.NominalMeleeRange;
                }
                else
                {
                    float meleeRange = 0.0f;
                    if (SpellInfo.RangedFlags.HasTargetFlag(SpellRangeFlags.Ranged))
                    {
                        meleeRange = StatUtils.MinMeleeReach;
                    }

                    minRange = Caster.Spells.GetSpellMinRangeForTarget(target, SpellInfo) + meleeRange;
                    maxRange = Caster.Spells.GetSpellMaxRangeForTarget(target, SpellInfo);
                }

                maxRange += rangeMod;

                if (Vector3.Distance(Caster.Position, target.Position) > maxRange)
                {
                    return(SpellCastResult.OutOfRange);
                }

                if (minRange > 0.0f && Vector3.Distance(Caster.Position, target.Position) < minRange)
                {
                    return(SpellCastResult.OutOfRange);
                }

                return(SpellCastResult.Success);
            }

            SpellCastResult ValidateDestinationRange()
            {
                if (!ExplicitTargets.Destination.HasValue)
                {
                    return(SpellCastResult.BadTargets);
                }

                Vector3 targetPosition = ExplicitTargets.Destination.Value;

                float minRange = SpellInfo.GetMinRange(false);
                float maxRange = SpellInfo.GetMaxRange(false);

                if (Vector3.Distance(Caster.Position, targetPosition) > maxRange)
                {
                    return(SpellCastResult.OutOfRange);
                }

                if (minRange > 0.0f && Vector3.Distance(Caster.Position, targetPosition) < minRange)
                {
                    return(SpellCastResult.OutOfRange);
                }

                return(SpellCastResult.Success);
            }
        }