C# WoWUnit.GetAllAuras方法代码示例

 public static bool IsCrowdControlled(WoWUnit unit)
 {
     return unit.GetAllAuras().Any(a => a.IsHarmful &&
         (a.Spell.Mechanic == WoWSpellMechanic.Shackled ||
         a.Spell.Mechanic == WoWSpellMechanic.Polymorphed ||
         a.Spell.Mechanic == WoWSpellMechanic.Horrified ||
         a.Spell.Mechanic == WoWSpellMechanic.Rooted ||
         a.Spell.Mechanic == WoWSpellMechanic.Frozen ||
         a.Spell.Mechanic == WoWSpellMechanic.Stunned ||
         a.Spell.Mechanic == WoWSpellMechanic.Fleeing ||
         a.Spell.Mechanic == WoWSpellMechanic.Banished ||
         a.Spell.Mechanic == WoWSpellMechanic.Sapped));
 }

        public static TimeSpan GetAuraTimeLeft(string auraName, WoWUnit onUnit, bool fromMyAura)
        {
            if (onUnit == null)
            {
                return TimeSpan.Zero;
            }

            WoWAura wantedAura =
                onUnit.GetAllAuras().Where(a => a.Name == auraName && (!fromMyAura || a.CreatorGuid == Me.Guid)).FirstOrDefault();

            if (wantedAura != null)
            {
                return wantedAura.TimeLeft;
            }
            return TimeSpan.Zero;
        }

 //Used for checking debuff timers
 private int DebuffTime(String spellName, WoWUnit unit)
 {
     using (new FrameLock())
     {
         if (unit.HasAura(spellName))
         {
             var auras = unit.GetAllAuras();
             foreach (var b in auras)
             {
                 if (b.Name == spellName)
                 {
                     return b.TimeLeft.Seconds;
                 }
             }
         }
     }
     return 0;
 }

 /// <summary>
 /// Checks to see if specified target is under the effect of crowd control
 /// </summary>
 /// <param name="target">Target</param>
 /// <returns></returns>
 private static bool IsCrowdControlled(WoWUnit target)
 {
     // Just want to throw a shout-out to Singular for this function.
     return
         target.GetAllAuras().Any(
             unit =>
             unit.Spell.Mechanic == WoWSpellMechanic.Banished || unit.Spell.Mechanic == WoWSpellMechanic.Charmed
             || unit.Spell.Mechanic == WoWSpellMechanic.Horrified
             || unit.Spell.Mechanic == WoWSpellMechanic.Incapacitated
             || unit.Spell.Mechanic == WoWSpellMechanic.Polymorphed
             || unit.Spell.Mechanic == WoWSpellMechanic.Sapped
             || unit.Spell.Mechanic == WoWSpellMechanic.Shackled
             || unit.Spell.Mechanic == WoWSpellMechanic.Asleep
             || unit.Spell.Mechanic == WoWSpellMechanic.Frozen);
 }

 /// <summary>returns true if the unit is crowd controlled.</summary>
 /// <param name="unit">unit to check</param>
 /// <param name="breakOnDamageOnly">true for break on damage</param>
 /// <returns>The unit is controlled.</returns>
 public static bool UnitIsControlled(WoWUnit unit, bool breakOnDamageOnly)
 {
     return unit != null && unit.GetAllAuras().Any(x => x.IsHarmful && (ControlDebuffs.Contains(x.Name) || (!breakOnDamageOnly && ControlUnbreakableDebuffs.Contains(x.Name))));
 }

 private static int CountMagicBuffPurge(WoWUnit target)
 {
     return target.GetAllAuras().Count<WoWAura>(a => ((a.IsActive && !a.IsHarmful) && (a.get_Spell().get_DispelType() == ((WoWDispelType)((int)WoWDispelType.Magic)))));
 }

        private static WoWAura GetPurgeEnemyAura(WoWUnit target)
        {
            if (SingularSettings.Instance.PurgeBuffs == PurgeAuraFilter.All)
                return target.GetAllAuras().FirstOrDefault(a => a.TimeLeft.TotalSeconds > 1 && a.Spell.DispelType == WoWDispelType.Magic);

            SpellList sl = StyxWoW.Me.Class == WoWClass.Mage ? MageSteallist.Instance.SpellList : PurgeWhitelist.Instance.SpellList;
            return target.GetAllAuras().FirstOrDefault(a => a.TimeLeft.TotalSeconds > 1 && a.Spell.DispelType == WoWDispelType.Magic && sl.Contains(a.SpellId));
        }

 public static bool IsSilenced(WoWUnit unit)
 {
     return unit.GetAllAuras().Any(a => a.IsHarmful &&
         (a.Spell.Mechanic == WoWSpellMechanic.Interrupted || 
         a.Spell.Mechanic == WoWSpellMechanic.Silenced));
 }

        /// <summary>Check the aura stack count thats created by the specified unit</summary>
        /// <param name="unit">The unit to check auras for.</param>
        /// <param name="auraId">The Id of the aura</param>
        /// <param name="fromMyAura">True if you applied the aura</param>
        /// <returns>The get aura stack.</returns>
        public static uint GetAuraStack(WoWUnit unit, int auraId, bool fromMyAura)
        {
            if (unit != null)
            {
                var wantedAura = unit.GetAllAuras().FirstOrDefault(a => a.SpellId == auraId && a.StackCount > 0 && (!fromMyAura || a.CreatorGuid == Me.Guid));
                return wantedAura != null ? wantedAura.StackCount : 0;
            }

            CLULogger.DiagnosticLog(" [GetAuraStack] Unit is null ");
            return 0;
        }

 private static bool CanHex(WoWUnit target)
 {
     return target.GetAllAuras().All<WoWAura>(aura => !HexImmuneAura.Contains(aura.SpellId));
 }

 private static bool NeedTremor(WoWUnit target, int duration, bool writelog = true)
 {
     foreach (WoWAura aura in target.GetAllAuras())
     {
         if ((((aura.TimeLeft.TotalMilliseconds >= duration) && (aura.SpellId != 30283)) && (aura.SpellId != 132168)) && ((DebuffNeedTremor.Contains(aura.SpellId) || (aura.get_Spell().get_Mechanic() == ((WoWSpellMechanic)((int)WoWSpellMechanic.Asleep)))) || (((aura.get_Spell().get_Mechanic() == ((WoWSpellMechanic)((int)WoWSpellMechanic.Charmed))) || (aura.get_Spell().get_Mechanic() == ((WoWSpellMechanic)((int)WoWSpellMechanic.Fleeing)))) || (aura.get_Spell().get_Mechanic() == ((WoWSpellMechanic)((int)WoWSpellMechanic.Horrified))))))
         {
             if (writelog)
             {
                 Logging.Write("NeedTremor {0} {1} ID: {2}", new object[] { target.SafeName, aura.Name, aura.SpellId });
             }
             return true;
         }
     }
     return false;
 }

 private static bool NeedPurgeASAPResto(WoWUnit target)
 {
     return target.GetAllAuras().Any<WoWAura>(aura => NeedPurgeASAPRestoHS.Contains(aura.Name));
 }

 private static bool GetMyShieldonUnit(WoWUnit target)
 {
     return target.GetAllAuras().Any<WoWAura>(delegate(WoWAura aura)
     {
         if (aura.CreatorGuid != target.Guid)
         {
             return false;
         }
         if ((aura.SpellId != 974) && (aura.SpellId != 324))
         {
             return (aura.SpellId == 52127);
         }
         return true;
     });
 }

 private static bool Debuff63280Duration(WoWUnit target, double duration, bool LogSpell = false)
 {
     return target.GetAllAuras().Any<WoWAura>(aura => Debuff63280DurationHS.Contains(aura.SpellId));
 }

 //Used for checking auras that has no time
 private bool IsMyAuraActive(WoWUnit Who, String What)
 {
     using (new FrameLock())
     {
         return Who.GetAllAuras().Where(p => p.CreatorGuid == Me.Guid && p.Name == What).FirstOrDefault() != null;
     }
 }