public static void LogCast(string sname, WoWUnit unit, double health, double dist)
 {
     if (unit.IsMe)
         Logger.Write("Casting {0} on Me @ {1:F1}%", sname, health);
     else
         Logger.Write("Casting {0} on {1} @ {2:F1}% at {3:F1} yds", sname, unit.SafeName(), health, dist);
 }

        /// <summary>
        /// WillChainHealHop()
        /// Tests whether casting Chain Lightning on 'healTarget' results in a minimum 
        /// of 2 hops (3 people healed.) 
        /// </summary>
        /// <param name="healTarget"></param>
        /// <returns></returns>
        public static bool WillChainHealHop(WoWUnit healTarget)
        {
            double threshhold = SingularSettings.Instance.Shaman.RAF_ChainHeal_Health;

            if (healTarget == null)
                return false;

            var t = (from o in ObjectManager.ObjectList
                     where o is WoWPlayer && healTarget.Location.Distance(o.Location) < 12
                     let p = o.ToPlayer()
                     where p != null
                           && p.IsHorde == StyxWoW.Me.IsHorde
                           && !p.IsPet
                           && p != healTarget
                           && p.IsAlive
                           && p.HealthPercent < threshhold
                     let c = (from oo in ObjectManager.ObjectList
                              where oo is WoWPlayer && p.Location.Distance(oo.Location) < 12
                              let pp = oo.ToPlayer()
                              where pp != null
                                    && pp.IsHorde == p.IsHorde
                                    && !pp.IsPet
                                    && pp.IsAlive
                                    && pp.HealthPercent < threshhold
                              select pp).Count()
                     orderby c descending, p.Distance ascending
                     select new { Player = p, Count = c }).FirstOrDefault();

            if (t == null || t.Count < 3)
                return false;
            return true;
        }

 public bool CastIfHasBuff(WoWGlobal wowinfo, WoWUnit unit) {
     if (unit.HasBuff(this.ID)) {
         this.SendCast();
         return true;
     }
     return false;
 }

 /// <summary>
 ///  Returns maximum spell range based on hitbox of unit. 
 /// </summary>
 /// <param name="spell"></param>
 /// <param name="unit"></param>
 /// <returns>Maximum spell range</returns>
 public static float ActualMaxRange(this WoWSpell spell, WoWUnit unit)
 {
     if (spell.MaxRange == 0)
         return 0;
     // 0.3 margin for error
     return unit != null ? spell.MaxRange + unit.CombatReach + 1f : spell.MaxRange;
 }

 private void formatslog(string type, string reason, string spell, WoWUnit target)
 {
     System.Drawing.Color textcolor;
     switch (type)
     {
         case "Heal":
             textcolor = Color.Green;
             break;
         case "Cleanse":
             textcolor = Color.Magenta;
             break;
         case "Buff":
             textcolor = Color.Brown;
             break;
         case "OhShit":
             textcolor = Color.Red;
             break;
         case "Mana":
             textcolor = Color.Blue;
             break;
         case "DPS":
             textcolor = Color.Violet;
             break;
         case "Utility":
             textcolor = Color.Orange;
             break;
         default:
             textcolor = Color.Black;
             break;
     }
     slog(textcolor, reason + ": casting {0} on {1} at distance {2} with type {3} at hp {4}", spell, privacyname(target), Round(target.Distance), type, Round(target.HealthPercent));
 }

        static bool ValidUnit(WoWUnit p)
        {
            if (IgnoreMobs.Contains(p.Entry))
                return false;

            // Ignore shit we can't select/attack
            if (!p.CanSelect || !p.Attackable)
                return false;

            // Ignore friendlies!
            if (p.IsFriendly)
                return false;

            // Duh
            if (p.Dead)
                return false;

            // Dummies/bosses are valid by default. Period.
            if (p.IsTrainingDummy() || p.IsBoss())
                return true;

            // If its a pet, lets ignore it please.
            if (p.IsPet || p.OwnedByRoot != null)
                return false;

            // And ignore critters/non-combat pets
            if (p.IsNonCombatPet || p.IsCritter)
                return false;

            return true;
        }

 private static bool CanCastFortitudeOn(WoWUnit unit)
 {
     //return !unit.HasAura("Blood Pact") &&
     return !unit.HasAura("Power Word: Fortitude") &&
            !unit.HasAura("Qiraji Fortitude") &&
            !unit.HasAura("Commanding Shout");
 }

        private static void DoMovement(WoWUnit Target)
        {
            // Thought i might try add this, just to see if this might catch wow's error
            // prob a longggggggggg shot, but worth the try.
            // -> my thoughts, if theres something to catch, maybe it wont crash wow it self?, but im guessing hb will still cause crash
            try
            {
                // If we are > 2, we need to get closer to them at all costs.
                if (Target.Distance > 2)
                {
                    ClickToMove.MoveTo(Target.Location);
                    return;
                }

                //// If player not moving and we not behind, lets get behind
                //if ((Target.MovementInfo.CurrentSpeed == 0) && (!Target.MeIsSafelyBehind))
                //{
                //    WoWPoint BehindLocation = WoWMathHelper.CalculatePointBehind(Target.Location, Target.Rotation, 1.5f);
                //    ClickToMove.MoveTo(BehindLocation);
                //}

                //// If where behind them and not facing them, Face them
                //if ((Target.MeIsSafelyBehind) && (!Me.IsSafelyFacing(Target)))
                //{
                //    Target.Face();
                //}

            } catch (Exception) { }
        }

 public override Task<bool> CastOnTarget(WoWUnit target)
 {
     base.Conditions.Clear();
     InitializeBase();
     base.Conditions.Add(_energy);
     base.Conditions.Add(new TargetNotAuraUpCondition(target, Spell));
     return base.CastOnTarget(target);
 }

 public override Task<bool> CastOnTarget(WoWUnit target)
 {
     base.Conditions.Clear();
     InitializeBase();
     Conditions.Add(Energy);
     Conditions.Add(new BooleanCondition(target != null && target.IsWithinMeleeRange));
     return base.CastOnTarget(target);
 }

 /// <summary>
 /// Returns the estimated combat time left for this unit. (Time until death)
 /// If the unit is invalid; TimeSpan.MinValue is returned.
 /// </summary>
 /// <param name="u"></param>
 /// <returns></returns>
 public static TimeSpan GetCombatTimeLeft(WoWUnit u)
 {
     if (DpsInfos.ContainsKey(u.Guid))
     {
         return DpsInfos[u.Guid].CombatTimeLeft;
     }
     return TimeSpan.MinValue;
 }

 public override Task<bool> CastOnTarget(WoWUnit target)
 {
     Conditions.Clear();
     InitializeBase();
     Conditions.Add(new InMeeleRangeCondition());
     Conditions.Add(new BooleanCondition(Me.ComboPoints <= 2));
     Conditions.Add(new BooleanCondition(SettingsManager.Instance.UseMFD));
     return base.CastOnTarget(target);
 }

 /// <summary>
 /// Returns the current DPS on a specific unit, or -1 if the unit is not currently being tracked, or doesn't exist.
 /// </summary>
 /// <param name="u"></param>
 /// <returns></returns>
 public static double GetDps(WoWUnit u)
 {
     if (DpsInfos.ContainsKey(u.Guid))
     {
         return DpsInfos[u.Guid].CurrentDps;
     }
     // -1 is a fail case.
     return -1;
 }

 public static UnitOracle FindUnit(WoWUnit unit)
 {
     try {
         // CLU.DebugLog(Color.GreenYellow, "[CLU-ORACLE] " + CLU.Version + ": FindUnit [" + unit + "] = [" + unit.Guid + "]");
         return instances[unit.Guid];
     } catch {
         return null;
     }
 }

 public override bool ReCast(WoWGlobal wowinfo, WoWUnit unit) {
     if (!unit.HasBuff(this.ID) && !wowinfo.SpellIsPending && wowinfo.HasRunesFor(cost)) {
         this.SendCast();
         return true;
     }
     else {
         return false;
     }
 }

        /// <summary>
        /// Casts spell
        /// </summary>
        /// <param name="SpellName"></param>
        /// <param name="Player"></param>
        /// <returns></returns>
        public static bool Cast(string SpellName, WoWUnit CastOn)
        {
            if (SpellManager.HasSpell(SpellName) == false) return false;
            if (SpellManager.CanCast(SpellName) == false) return false;

            Log.Write("Casting {0} on [{1}]", SpellName, CastOn.Name);

            return SpellManager.Cast(SpellName, CastOn);
        }

        /// <summary>
        /// Returns the string "Myself" if the unit name is equal to our name.
        /// </summary>
        /// <param name="unit">the unit to check</param>
        /// <returns>a safe name for the log</returns>
        public static string SafeName(WoWUnit unit)
        {
            if (unit != null)
            {
                return (unit.Name == StyxWoW.Me.Name) ? "Myself" : unit.Name;
            }

            return "No Target";
        }

 public virtual bool ReCast(WoWGlobal wowinfo, WoWUnit unit) {
     if (!unit.HasBuff(this.ID) /*&& !wowinfo.SpellIsPending*/) {
         this.SendCast();
         return true;
     }
     else {
         return false;
     }
 }

 public override bool ReCast(WoWGlobal wowinfo, WoWUnit unit) {
     if (!unit.HasBuff(cot) && !unit.HasBuff(cote) && !unit.HasBuff(cow) && !unit.HasBuff(coe)) {
         this.SendCast();
         return true; 
     }
     else {
         return false;
     }
 }

        public static void MoveBehind(WoWUnit Unit)
        {
            // Movement Checks
            if (GlueEnabled && Unit.Distance < 10) return;
            if (!ClassSettings._Instance.GeneralMovement) return;

            WoWPoint BehindLocation = WoWMathHelper.CalculatePointBehind(Unit.Location, Unit.Rotation, 2.3f);
            Navigator.MoveTo(BehindLocation);
        }