private void FightLoopHandler(WoWUnit unit, CancelEventArgs cancel)
        {
            if (specialization.RotationType == Enums.RotationType.Party &&
                _moveBehindTimer.IsReady)
            {
                if (ToolBox.StandBehindTargetCombat())
                {
                    _moveBehindTimer = new Timer(4000);
                }
            }
            else
            {
                if (IsTargetStunned() &&
                    !MovementManager.InMovement &&
                    Me.IsAlive &&
                    !Me.IsCast &&
                    ObjectManager.Target.IsAlive)
                {
                    Vector3 position = ToolBox.BackofVector3(ObjectManager.Target.Position, ObjectManager.Target, 2.5f);
                    MovementManager.Go(PathFinder.FindPath(position), false);

                    while (MovementManager.InMovement &&
                           StatusChecker.BasicConditions() &&
                           IsTargetStunned())
                    {
                        // Wait follow path
                        Thread.Sleep(200);
                    }
                }
            }
        }
Exemplo n.º 2
0
 private static void BuffRotation()
 {
     if (Me.ManaPercentage < HunterBeastMasterySettings.CurrentSetting.AspecofViper)
     {
         Extension.BuffSpell(AspecoftheViper);
     }
     if (!AspecoftheDragonhawk.KnownSpell && !AspecoftheCheetah.HaveBuff &&
         (Me.ManaPercentage > 90 || !AspecoftheViper.KnownSpell))
     {
         Extension.BuffSpell(AspecoftheHawk);
     }
     if (Me.ManaPercentage > 90 && !AspecoftheCheetah.HaveBuff)
     {
         Extension.BuffSpell(AspecoftheDragonhawk);
     }
     if (HunterBeastMasterySettings.CurrentSetting.Checkpet)
     {
         if (ObjectManager.Pet.IsAlive && ObjectManager.Pet.IsValid &&
             ObjectManager.Pet.HealthPercent < HunterBeastMasterySettings.CurrentSetting.PetHealth)
         {
             if (PetHealTimer.IsReady)
             {
                 Extension.PetSpell(MendPet);
                 PetHealTimer = new Timer(1000 * 15);
             }
         }
         return;
     }
 }
        // Approach spell target
        private void ApproachSpellTarget()
        {
            Timer limit = new Timer(10000);

            if (CurrentSpellTarget != null)
            {
                Logger.Log($"Approaching {CurrentSpellTarget.Name} to cast {CurrentSpell.Name} ({CurrentSpellTarget.GetDistance}/{CurrentSpell.MaxRange}");
                MovementManager.Go(PathFinder.FindPath(CurrentSpellTarget.Position), false);
                Thread.Sleep(1000);
                while (Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                       !limit.IsReady &&
                       (CurrentSpellTarget.IsAlive || CurrentSpell.OnDeadTarget) &&
                       (CurrentSpellTarget.GetDistance > CurrentSpell.MaxRange - 2 || TraceLine.TraceLineGo(CurrentSpellTarget.Position)))
                {
                    Thread.Sleep(100);
                }
                MovementManager.StopMoveNewThread();
            }
            else if (CurrentSpellLocation != null)
            {
                Logger.Log($"Approaching {CurrentSpellLocation} to cast {CurrentSpell.Name}");
                MovementManager.Go(PathFinder.FindPath(CurrentSpellLocation), false);
                Thread.Sleep(1000);
                while (Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                       !limit.IsReady &&
                       (CurrentSpellLocation.DistanceTo(ObjectManager.Me.Position) > CurrentSpell.MaxRange - 2))
                {
                    Thread.Sleep(100);
                }
                MovementManager.StopMoveNewThread();
            }
        }
        protected void StealthApproach()
        {
            Timer stealthApproachTimer = new Timer(7000);

            _isStealthApproching = true;

            if (ObjectManager.Me.IsAlive && ObjectManager.Target.IsAlive)
            {
                while (Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                       (ObjectManager.Target.GetDistance > 2.5f || !Claw.IsSpellUsable) &&
                       (specialization.RotationType == Enums.RotationType.Party || ToolBox.GetClosestHostileFrom(ObjectManager.Target, 20f) == null) &&
                       Fight.InFight &&
                       !stealthApproachTimer.IsReady &&
                       Me.HaveBuff("Prowl"))
                {
                    Vector3 position = ToolBox.BackofVector3(ObjectManager.Target.Position, ObjectManager.Target, 2.5f);
                    MovementManager.MoveTo(position);
                    Thread.Sleep(50);
                    CastOpener();
                }

                if (stealthApproachTimer.IsReady &&
                    ToolBox.Pull(cast, settings.AlwaysPull, new List <AIOSpell> {
                    FaerieFireFeral, MoonfireRank1, Wrath
                }))
                {
                    _combatMeleeTimer = new Timer(2000);
                    return;
                }

                //ToolBox.CheckAutoAttack(Attack);

                _isStealthApproching = false;
            }
        }
        private void FightLoopHandler(WoWUnit unit, CancelEventArgs cancel)
        {
            if (specialization is FeralDPSParty &&
                settings.PartyStandBehind &&
                _moveBehindTimer.IsReady)
            {
                if (ToolBox.StandBehindTargetCombat())
                {
                    _moveBehindTimer = new Timer(4000);
                }
            }

            if (specialization is Feral &&
                (ObjectManager.Target.HaveBuff("Pounce") || ObjectManager.Target.HaveBuff("Maim")) &&
                !MovementManager.InMovement &&
                Me.IsAlive &&
                !Me.IsCast &&
                ObjectManager.Target.IsAlive)
            {
                Vector3 position = ToolBox.BackofVector3(ObjectManager.Target.Position, ObjectManager.Target, 2.5f);
                MovementManager.Go(PathFinder.FindPath(position), false);

                while (MovementManager.InMovement &&
                       Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                       (ObjectManager.Target.HaveBuff("Pounce") || ObjectManager.Target.HaveBuff("Maim")))
                {
                    // Wait follow path
                    Thread.Sleep(500);
                }
            }
        }
 private void EventsWithArgsHandler(string id, List <string> args)
 {
     if (_behindTargetTimer.IsReady && args[11].Contains("You must be behind"))
     {
         _behindTargetTimer = new Timer(10000);
     }
 }
Exemplo n.º 7
0
    public void Initialize()
    {
        _isLaunched = true;
        var t = new Timer(15 * 1000); // check all 15 sec
        Logging.Write("[MemoryClean] Started.");

        while (_isLaunched && Products.IsStarted)
        {
            try
            {
                if (t.IsReady &&
                    Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                    !Conditions.IsAttackedAndCannotIgnore)
                {
                    Lua.LuaDoString("if gcinfo() > 270000 then RunMacroText('/reload') end"); // Change 270000 by max lua memory usage (in ko)
                    t.Reset();
                }
            }
            catch (Exception e)
            {
                Logging.WriteError("[MemoryClean]: " + e);
            }
            Thread.Sleep(150);
        }
    }
Exemplo n.º 8
0
 private void FightEventsOnOnFightStart(WoWUnit woWUnit, CancelEventArgs cancelable)
 {
     if (woWUnit.IsValid && woWUnit.IsAlive && !ObjectManager.Me.InCombat)
     {
         StanceLauncher(_pullStance);
         pullingTimer = new Timer(1100 * 2);
     }
 }
Exemplo n.º 9
0
 //FoodPart for Pet
 private static void Feed()
 {
     if (ObjectManager.Pet.IsAlive && PetFeedTimer.IsReady && Lua.LuaDoString <int>("happiness, damagePercentage, loyaltyRate = GetPetHappiness() return happiness", "") < 3)
     {
         FeedPet();
     }
     PetFeedTimer = new Timer(1000 * 15);
     return;
 }
Exemplo n.º 10
0
 private static void Pull()
 {
     if (MyTarget.IsAttackable && Me.Target > 0 && ObjectManager.Pet.IsValid && PetPullTimer.IsReady)
     {
         Extension.Frameunlock();
         Lua.LuaDoString("PetAttack();", false);
         PetPullTimer = new Timer(500);
     }
 }
Exemplo n.º 11
0
 private void FightLoopHandler(WoWUnit unit, CancelEventArgs cancel)
 {
     if (specialization is EnhancementParty &&
         settings.PartyStandBehind &&
         _moveBehindTimer.IsReady)
     {
         if (ToolBox.StandBehindTargetCombat())
         {
             _moveBehindTimer = new Timer(4000);
         }
     }
 }
Exemplo n.º 12
0
    private static void CombatRotation()
    {
        bool ffcheck = ObjectManager.Target.HaveBuff("Frost Fever");
        bool bpcheck = ObjectManager.Target.HaveBuff("Blood Plague");

        if (Extension.InterruptableUnit(5f) != null && MindFreeze.KnownSpell && MindFreeze.IsSpellUsable)
        {
            Logging.Write("Interrupt Target found");
            ObjectManager.Me.FocusGuid = Extension.InterruptableUnit(5f).Guid;
            Logging.Write("Interrupt Target Set" + Extension.InterruptableUnit(5f).Guid);
            Extension.FightSpell(MindFreeze, true);
        }
        if (Extension.InterruptableUnit(20f) != null && Strangulate.KnownSpell && Strangulate.IsSpellUsable)
        {
            Logging.Write("Interrupt Target found");
            ObjectManager.Me.FocusGuid = Extension.InterruptableUnit(20f).Guid;
            Logging.Write("Interrupt Target Set" + Extension.InterruptableUnit(20f).Guid);
            Extension.FightSpell(Strangulate, true);
        }
        if (ObjectManager.Target.IsElite)
        {
            Extension.FightSpell(MarkofBlood);
        }
        if (ObjectManager.Target.IsElite)
        {
            Extension.FightSpell(DancingRuneWeapon);
        }
        if (DeathKnightLevelSettings.CurrentSetting.DeathGrip && ObjectManager.Target.GetDistance > 10)
        {
            Extension.FightSpell(DeathGrip);
        }
        Extension.FightSpell(RuneStrike);
        if (!ffcheck && Extension.CanBleed(MyTarget))
        {
            Extension.FightSpell(IcyTouch);
        }
        if (!bpcheck)
        {
            Extension.FightSpell(PlagueStrike);
        }
        if (ffcheck && bpcheck &&
            Extension.GetAttackingUnits(10).Count() > 1 &&
            Pestilencetimer.IsReady &&
            Pestilence.IsSpellUsable &&
            Pestilence.KnownSpell)
        {
            Pestilence.Launch();
            Pestilencetimer = new Timer(7000);
        }
        UseBloodSkill();
        Extension.FightSpell(DeathStrike);
    }
        // Stops using wand and waits for its CD to be over
        private void StopWandWaitGCD(AIOSpell wandSpell)
        {
            CombatDebug("Stopping Wand and waiting for GCD");
            wandSpell.Launch();
            Timer limit = new Timer(1500);

            while (!CurrentSpell.IsSpellUsable && !limit.IsReady)
            {
                Thread.Sleep(50);
            }

            CombatDebug($"Waited for GCD after wand stop : {1500 - limit.TimeLeft()}");
        }
Exemplo n.º 14
0
 public void StanceLauncher(Stance stance)
 {
     if (stance == Stance.Battle && !ObjectManager.Me.HaveBuff(BattleStanceSpell.Id) && BattleStanceSpell.KnownSpell)
     {
         BattleStanceSpell.Launch();
         Logging.WriteDebug("WarriorHelper.StanceManager.BattleStance: ");
         spamTimer = new Timer(50);
         return;
     }
     else if (stance == Stance.Defensive && !ObjectManager.Me.HaveBuff(DefensiveStanceSpell.Id) && DefensiveStanceSpell.KnownSpell)
     {
         DefensiveStanceSpell.Launch();
         Logging.WriteDebug("WarriorHelper.StanceManager.DefensiveStance: ");
         spamTimer = new Timer(50);
         return;
     }
     else if (stance == Stance.Berserker && !ObjectManager.Me.HaveBuff(BerserkerStanceSpell.Id) && BerserkerStanceSpell.KnownSpell)
     {
         BerserkerStanceSpell.Launch();
         Logging.WriteDebug("WarriorHelper.StanceManager.BerserkerStance: ");
         spamTimer = new Timer(50);
         return;
     }
 }
Exemplo n.º 15
0
        private void FightLoopHandler(WoWUnit unit, CancelEventArgs cancelable)
        {
            float minDistance = RangeManager.GetMeleeRangeWithTarget() + 3f;

            // Do we need to backup?
            if ((ObjectManager.Target.HaveBuff("Frostbite") || ObjectManager.Target.HaveBuff("Frost Nova")) &&
                ObjectManager.Target.GetDistance < minDistance &&
                Me.IsAlive &&
                ObjectManager.Target.IsAlive &&
                !cast.IsBackingUp &&
                !Me.IsCast &&
                !RangeManager.CurrentRangeIsMelee() &&
                ObjectManager.Target.HealthPercent > 5 &&
                !_isPolymorphing)
            {
                cast.IsBackingUp = true;
                Timer timer = new Timer(3000);

                // Using CTM
                if (settings.BackupUsingCTM)
                {
                    Vector3 position = ToolBox.BackofVector3(Me.Position, Me, 15f);
                    MovementManager.Go(PathFinder.FindPath(position), false);
                    Thread.Sleep(500);

                    // Backup loop
                    while (MovementManager.InMoveTo &&
                           Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                           ObjectManager.Target.GetDistance < minDistance &&
                           ObjectManager.Me.IsAlive &&
                           ObjectManager.Target.IsAlive &&
                           (ObjectManager.Target.HaveBuff("Frostbite") || ObjectManager.Target.HaveBuff("Frost Nova")) &&
                           !timer.IsReady)
                    {
                        // Wait follow path
                        Thread.Sleep(300);
                        if (settings.BlinkWhenBackup)
                        {
                            cast.OnSelf(Blink);
                        }
                    }
                    MovementManager.StopMove();
                    Thread.Sleep(500);
                }
                // Using Keyboard
                else
                {
                    while (Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                           ObjectManager.Me.IsAlive &&
                           ObjectManager.Target.IsAlive &&
                           ObjectManager.Target.GetDistance < minDistance &&
                           (ObjectManager.Target.HaveBuff("Frostbite") || ObjectManager.Target.HaveBuff("Frost Nova")) &&
                           !timer.IsReady)
                    {
                        Move.Backward(Move.MoveAction.PressKey, 500);
                    }
                }
                cast.IsBackingUp = false;
            }

            // Polymorph
            if (settings.UsePolymorph &&
                ObjectManager.GetNumberAttackPlayer() > 1 &&
                Polymorph.KnownSpell &&
                !cast.IsBackingUp &&
                !cast.IsApproachingTarget &&
                specialization.RotationType != Enums.RotationType.Party &&
                _polymorphableEnemyInThisFight)
            {
                WoWUnit myNearbyPolymorphed = null;
                // Detect if a polymorph cast has succeeded
                if (_polymorphedEnemy != null)
                {
                    myNearbyPolymorphed = ObjectManager.GetObjectWoWUnit().Find(u => u.HaveBuff("Polymorph") && u.Guid == _polymorphedEnemy.Guid);
                }

                // If we don't have a polymorphed enemy
                if (myNearbyPolymorphed == null)
                {
                    _polymorphedEnemy = null;
                    _isPolymorphing   = true;
                    WoWUnit firstTarget = ObjectManager.Target;
                    WoWUnit potentialPolymorphTarget = null;

                    // Select our attackers one by one for potential polymorphs
                    foreach (WoWUnit enemy in ObjectManager.GetUnitAttackPlayer())
                    {
                        Interact.InteractGameObject(enemy.GetBaseAddress);

                        if ((enemy.CreatureTypeTarget == "Beast" || enemy.CreatureTypeTarget == "Humanoid") &&
                            enemy.Guid != firstTarget.Guid)
                        {
                            potentialPolymorphTarget = enemy;
                            break;
                        }
                    }

                    if (potentialPolymorphTarget == null)
                    {
                        _polymorphableEnemyInThisFight = false;
                    }

                    // Polymorph cast
                    if (potentialPolymorphTarget != null &&
                        _polymorphedEnemy == null &&
                        cast.OnFocusUnit(Polymorph, potentialPolymorphTarget))
                    {
                        Usefuls.WaitIsCasting();
                        _polymorphedEnemy = potentialPolymorphTarget;
                    }

                    _isPolymorphing = false;
                }
            }
        }
Exemplo n.º 16
0
    private static void CombatRotation()
    {
        // Pet attack
        if (Fight.InFight && Me.Target > 0UL && ObjectManager.Target.IsAttackable &&
            !ObjectManager.Pet.HaveBuff("Feed Pet Effect") && ObjectManager.Pet.Target != Me.Target)
        {
            Lua.LuaDoString("PetAttack();", false);
        }

        //Pethandle in Fight
        if (ObjectManager.Pet.HealthPercent < HunterLevelSettings.CurrentSetting.PetmendInFight &&
            PetHealTimer.IsReady)
        {
            Extension.PetSpell(MendPet);
            PetHealTimer = new Timer(1000 * 15);
            return;
        }

        if (Extension.InterruptableUnit(20f) != null && Intimidation.KnownSpell && Intimidation.IsSpellUsable)
        {
            Logging.Write("Interrupt Target found");
            ObjectManager.Me.Target = Extension.InterruptableUnit(20f).Guid;
            Logging.Write("Interrupt Target Set" + Extension.InterruptableUnit(20f).Guid);
            Extension.FightSpell(Intimidation);
        }

        if (ObjectManager.Target.IsElite || Extension.GetAttackingUnits(20).Count() > 1)
        {
            Extension.FightSpell(BestialWrath);
        }

        if (ObjectManager.Target.IsElite || Extension.GetAttackingUnits(20).Count() > 2)
        {
            Extension.BuffSpell(RapidFire);
        }

        //Ranged Attacks
        if (MyTarget.GetDistance >= 7)
        {
            Extension.FightSpell(HuntersMark);

            if (!Me.HaveBuff("Kill Command"))
            {
                Extension.FightSpell(KillCommand);
            }

            if (MyTarget.HealthPercent > 40)
            {
                Extension.FightSpell(SerpentSting);
            }
            Extension.FightSpell(ArcaneShot);

            if (MultiShotFeigndeath.IsReady && HunterLevelSettings.CurrentSetting.MultiS)
            {
                Extension.FightSpell(MultiShot);
            }

            Extension.FightSpell(SteadyShot, false, false, true);

            if (MyTarget.HealthPercent < 20)
            {
                Extension.FightSpell(KillShot);
            }

            if (Me.ManaPercentage < HunterLevelSettings.CurrentSetting.AspecofViper)
            {
                Extension.BuffSpell(AspecoftheViper);
            }

            if (Me.ManaPercentage > 30)
            {
                Extension.BuffSpell(AspecoftheDragonhawk);
            }

            if (!AspecoftheDragonhawk.KnownSpell && Me.ManaPercentage > 30)
            {
                Extension.BuffSpell(AspecoftheHawk);
            }
        }

        //Close  Combat  Attacks
        if (MyTarget.GetDistance <= 6)
        {
            Extension.FightSpell(RaptorStrike);

            if (!MyTarget.IsTargetingMe && ObjectManager.Pet.IsAlive && HunterLevelSettings.CurrentSetting.Dis)
            {
                Extension.BuffSpell(Disengage);
            }

            if (MyTarget.IsTargetingMe && ObjectManager.Pet.IsAlive)
            {
                Extension.BuffSpell(FeignDeath);
                Thread.Sleep(1500);
                MultiShotFeigndeath = new Timer(1000 * 5);
                return;
            }

            if (AspecoftheDragonhawk.KnownSpell)
            {
                Extension.BuffSpell(AspecoftheDragonhawk);
            }
        }
    }
        private void FightLoopHandler(WoWUnit unit, CancelEventArgs cancelable)
        {
            cast.IsBackingUp = false;

            float minDistance = RangeManager.GetMeleeRangeWithTarget() + settings.BackupDistance;

            // Do we need to backup?
            if (ObjectManager.Target.GetDistance < minDistance &&
                !ObjectManager.Target.IsTargetingMe &&
                !MovementManager.InMovement &&
                Me.IsAlive &&
                ObjectManager.Target.IsAlive &&
                !ObjectManager.Pet.HaveBuff("Pacifying Dust") &&
                !_canOnlyMelee &&
                !cast.IsApproachingTarget &&
                !ObjectManager.Pet.IsStunned &&
                !Me.IsCast &&
                settings.BackupFromMelee &&
                (!RaptorStrikeOn() || ObjectManager.Target.GetDistance > RangeManager.GetMeleeRangeWithTarget()))
            {
                // Stop trying if we reached the max amount of attempts
                if (_backupAttempts >= settings.MaxBackupAttempts)
                {
                    Logger.Log($"Backup failed after {_backupAttempts} attempts. Going in melee");
                    _canOnlyMelee = true;
                    RangeManager.SetRangeToMelee();
                    return;
                }

                cast.IsBackingUp = true;
                Timer timer = new Timer(3000);

                // Using CTM
                if (settings.BackupUsingCTM)
                {
                    Vector3 position = ToolBox.BackofVector3(Me.Position, Me, 12f);
                    MovementManager.Go(PathFinder.FindPath(position), false);
                    Thread.Sleep(500);

                    // Backup loop
                    while (Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                           ObjectManager.Me.IsAlive &&
                           !ObjectManager.Target.IsTargetingMe &&
                           ObjectManager.Target.GetDistance < minDistance &&
                           !timer.IsReady)
                    {
                        Thread.Sleep(100);
                    }
                }
                // Using Keyboard
                else
                {
                    while (Conditions.InGameAndConnectedAndAliveAndProductStartedNotInPause &&
                           ObjectManager.Me.IsAlive &&
                           !ObjectManager.Target.IsTargetingMe &&
                           ObjectManager.Target.GetDistance < minDistance &&
                           !timer.IsReady)
                    {
                        Move.Backward(Move.MoveAction.PressKey, 500);
                    }
                }

                _backupAttempts++;
                Logger.Log($"Backup attempt : {_backupAttempts}");
                //Logger.Log($"FINAL We are {ObjectManager.Target.GetDistance}/{minDistance} away from target");
                cast.IsBackingUp = false;

                if (RaptorStrikeOn())
                {
                    cast.OnTarget(RaptorStrike);
                }
                ReenableAutoshot();
            }
        }
        public bool AdvancedCast(AIOSpell spell, bool stopWandAndCast = true, bool onSelf = false, WoWUnit onUnitFocus = null, Vector3 location = null)
        {
            WoWUnit Me     = ObjectManager.Me;
            float   buffer = 600;

            if (IsApproachingTarget)
            {
                return(true);
            }

            CurrentSpell         = spell;
            CurrentSpellLocation = location;

            CombatDebug("*----------- INTO PRE CAST FOR " + CurrentSpell.Name);

            if (!CurrentSpell.KnownSpell ||
                IsBackingUp ||
                Me.CastingTimeLeft > buffer ||
                !CurrentSpell.IsForcedCooldownReady ||
                Me.IsStunned)
            {
                return(false);
            }

            // Define target
            if (onUnitFocus != null)
            {
                CurrentSpellTarget = onUnitFocus;
            }
            else if (CurrentSpellLocation != null)
            {
                CurrentSpellTarget = null;
            }
            else if (onSelf)
            {
                CurrentSpellTarget = ObjectManager.Me;
            }
            else
            {
                if (CurrentSpell.MaxRange <= 0 && ObjectManager.Target.GetDistance > RangeManager.GetMeleeRangeWithTarget())
                {
                    return(false);
                }
                CurrentSpellTarget = ObjectManager.Target;
            }

            // Now that we know the target
            if (CurrentSpellLocation == null)
            {
                if (CurrentSpellTarget == null ||
                    CurrentSpellTarget.GetDistance > 100 ||
                    (CurrentSpellTarget.IsDead && !CurrentSpell.OnDeadTarget) ||
                    (CurrentSpell.MinRange > 0 && CurrentSpellTarget.GetDistance <= CurrentSpell.MinRange) ||
                    UnitImmunities.Contains(CurrentSpellTarget, CurrentSpell.Name) ||
                    (!CurrentSpellTarget.IsValid && !CurrentSpell.OnDeadTarget))    // double check this
                {
                    return(false);
                }
            }

            CombatDebug("*----------- INTO CAST FOR " + CurrentSpell.Name);

            // CHECK COST
            if (CurrentSpell.PowerType == -2 && Me.Health < CurrentSpell.Cost)
            {
                CombatDebug($"{CurrentSpell.Name}: Not enough health {CurrentSpell.Cost}/{Me.Health}, SKIPPING");
                return(false);
            }
            else if (CurrentSpell.PowerType == 0 && Me.Mana < CurrentSpell.Cost)
            {
                CombatDebug($"{CurrentSpell.Name}: Not enough mana {CurrentSpell.Cost}/{Me.Mana}, SKIPPING");
                return(false);
            }
            else if (CurrentSpell.PowerType == 1 && Me.Rage < CurrentSpell.Cost)
            {
                CombatDebug($"{CurrentSpell.Name}: Not enough rage {CurrentSpell.Cost}/{Me.Rage}, SKIPPING");
                return(false);
            }
            else if (CurrentSpell.PowerType == 2 && ObjectManager.Pet.Focus < CurrentSpell.Cost)
            {
                CombatDebug($"{CurrentSpell.Name}: Not enough pet focus {CurrentSpell.Cost}/{ObjectManager.Pet.Focus}, SKIPPING");
                return(false);
            }
            else if (CurrentSpell.PowerType == 3 && Me.Energy < CurrentSpell.Cost)
            {
                CombatDebug($"{CurrentSpell.Name}: Not enough energy {CurrentSpell.Cost}/{Me.Energy}, SKIPPING");
                return(false);
            }

            // DON'T CAST BECAUSE WANDING
            if (WandSpell != null &&
                ToolBox.UsingWand() &&
                !stopWandAndCast)
            {
                CombatDebug("Didn't cast because we were wanding");
                return(false);
            }

            // COOLDOWN CHECKS
            float _spellCD = CurrentSpell.GetCurrentCooldown;

            CombatDebug($"Cooldown is {_spellCD}");

            if (_spellCD >= 500)
            {
                CombatDebug("Didn't cast because cd is too long");
                return(false);
            }

            // STOP WAND FOR CAST
            if (WandSpell != null &&
                ToolBox.UsingWand() &&
                stopWandAndCast)
            {
                StopWandWaitGCD(WandSpell);
            }


            // Wait for remaining Cooldown
            if (_spellCD > 0f && _spellCD < buffer)
            {
                CombatDebug($"{CurrentSpell.Name} is almost ready, waiting");
                while (CurrentSpell.GetCurrentCooldown > 0 && CurrentSpell.GetCurrentCooldown < 500)
                {
                    Thread.Sleep(50);
                }
                Thread.Sleep(50); // safety
            }

            if (!CurrentSpell.IsSpellUsable)
            {
                CombatDebug("Didn't cast because spell somehow not usable");
                return(false);
            }

            bool stopMove = CurrentSpell.CastTime > 0 || CurrentSpell.IsChannel;

            if (CurrentSpellLocation != null || CurrentSpellTarget.Guid != Me.Guid)
            {
                Vector3 spellPosition = CurrentSpellLocation != null ? CurrentSpellLocation : CurrentSpellTarget.Position;
                if (CurrentSpell.MaxRange > 0 && spellPosition.DistanceTo(Me.Position) > CurrentSpell.MaxRange || TraceLine.TraceLineGo(spellPosition))
                {
                    if (Me.HaveBuff("Spirit of Redemption"))
                    {
                        return(false);
                    }

                    Logger.LogFight($"Target not in range/sight, recycling {CurrentSpell.Name}");

                    if (Fight.InFight)
                    {
                        IsApproachingTarget = true;
                    }
                    else
                    {
                        ApproachSpellTarget();
                    }

                    return(true);
                }
            }

            if (onUnitFocus != null)
            {
                ObjectManager.Me.FocusGuid = CurrentSpellTarget.Guid;
            }

            string unit = onUnitFocus != null ? "focus" : "target";

            unit = onSelf || CurrentSpellLocation != null ? "player" : unit;

            // Wait for remaining cast in case of buffer
            while (Me.CastingTimeLeft > 0)
            {
                Thread.Sleep(25);
            }

            if (stopMove)
            {
                MovementManager.StopMoveNewThread();
            }

            if (CombatLogON)
            {
                string rankString = CurrentSpell.Rank > 0 ? $"(Rank {CurrentSpell.Rank})" : "";
                string target     = CurrentSpellLocation != null?CurrentSpellLocation.ToString() : CurrentSpellTarget.Name;

                Logger.Log($"[Spell] Casting {CurrentSpell.Name.Replace("()", "")} {rankString} on {target}");
            }

            CurrentSpell.Launch(stopMove, false, true, unit);

            if (CurrentSpell.IsClickOnTerrain)
            {
                ClickOnTerrain.Pulse(CurrentSpellLocation);
            }

            Thread.Sleep(50);

            ToolBox.ClearCursor();

            // Wait for channel to end
            if (CurrentSpell.IsChannel)
            {
                CombatDebug($"{CurrentSpell.Name} is channel, wait cast");
                while (ToolBox.GetChannelTimeLeft("player") < 0)
                {
                    Thread.Sleep(50);
                }

                CurrentSpell.StartForcedCooldown();
                return(true);
            }

            // Wait for instant cast GCD
            if (CurrentSpell.CastTime <= 0)
            {
                CurrentSpell.StartForcedCooldown();
                Timer gcdLimit = new Timer(1500);
                CombatDebug($"{CurrentSpell.Name} is instant, wait GCD");
                while (DefaultBaseSpell.GetCurrentCooldown > buffer && !gcdLimit.IsReady)
                {
                    Thread.Sleep(50);
                }

                if (gcdLimit.IsReady)
                {
                    Logger.LogError("We had to resort to timer wait (GCD)");
                }

                return(true);
            }

            if (CurrentSpell.CastTime > 0)
            {
                // Wait for cast to end
                buffer = CurrentSpell.PreventDoubleCast ? 0 : buffer;
                CombatDebug($"{CurrentSpell.Name} is normal, wait until {buffer} left");
                while (Me.CastingTimeLeft > buffer)
                {
                    if (CurrentSpell.IsResurrectionSpell && CurrentSpellTarget.IsAlive)
                    {
                        Lua.RunMacroText("/stopcasting");
                    }

                    Thread.Sleep(50);
                }
                CurrentSpell.StartForcedCooldown();
            }

            return(true);
        }
Exemplo n.º 19
0
 /// <summary>
 /// Creates a new instance of the <see cref="WoWSpell"/> class.
 /// </summary>
 /// <param name="spellNameEnglish">The spell name.</param>
 /// <param name="cooldownTimer">The cooldown time.</param>
 public WoWSpell(string spellNameEnglish, double cooldownTimer)
     : base(spellNameEnglish)
 {
     // Set timer
     this._timer = new Timer(cooldownTimer);
 }