Ejemplo n.º 1
0
        private void WhmCureMode()
        {
            Recast recast       = new Recast();
            int    curePotency  = int.Parse(txt_CurePotency.Text);
            int    cure2Potency = int.Parse(txt_Cure2Potency.Text);
            int    hurtPlayers  = 0;

            Character        tank = null, tank2 = null;
            List <Character> monsters       = new List <Character>();
            List <Character> fate           = new List <Character>();
            List <Character> players        = new List <Character>();
            List <Character> npcs           = new List <Character>();
            List <Character> damagedTargets = new List <Character>();
            List <Character> deadTargets    = new List <Character>();

            Character statusAilment = null;

            MemoryFunctions.GetCharacters(monsters, fate, players, ref _user);
            MemoryFunctions.GetNPCs(npcs);

            _hotkeys.QuickRefreshAbilities();


            if (_user.ContainsStatusEffect(292, 0, false))
            {
                return;
            }

            players.AddRange(npcs);

            List <Character> targets = (from player in players from target in _targets where player.Name.ToLower() == target.ToLower() select player).ToList();

            targets = targets.Distinct().ToList();

            if (_user.Health_Current == 0)
            {
                return;
            }

            recast.Refresh();

            if (_hotkeys[SHROUD].PercentReady == 100 && _user.Mana_Percent <= 70 && chk_WHMMode.IsChecked == true) // Shroud
            {
                _hotkeys[SHROUD].UseAbility();
            }


            if (_hotkeys[SHROUD].PercentReady == 100)
            {
                AggroHelper ah = new AggroHelper();
                List <Tuple <int, byte> > aggro = ah.GetAggroListWithEmnity();
                foreach (Tuple <int, byte> a in aggro)
                {
                    // Check if hate level is above 95%
                    if (a.Item2 >= 95)
                    {
                        // Check if the monster has less than 95% life.
                        Character aggroMob = MemoryFunctions.GetCharacterFromID(a.Item1);
                        if (aggroMob == null)
                        {
                            continue;
                        }
                        if (aggroMob.Health_Percent <= 90 && aggroMob.Health_Percent >= 1 && aggroMob.Name.ToLower().Contains("plume") == false)
                        {
                            Debug.Print("Hate Detected: " + a.Item2.ToString() + "   " + aggroMob.Name + "\n");
                            _hotkeys[SHROUD].UseAbility();
                        }
                    }
                }
            }



            foreach (Character target in targets)
            {
                target.Refresh();

                if (target.Name == txt_Tank.Text && target.ContainsStatusEffect(432, 0, false) == false)
                {
                    tank = target;
                }

                if (target.Name == txt_Tank2.Text && target.ContainsStatusEffect(432, 0, false) == false)
                {
                    tank2 = target;
                }

                if (target.Valid == false)
                {
                    continue;
                }

                if (target.ContainsStatusEffect(292, 0, false))
                {
                    continue;
                }

                if (target.ContainsStatusEffect(432, 0, false)) // Leviathan debuff
                {
                    continue;
                }

                if (target.DistanceFrom(_user) >= 30)
                {
                    continue;
                }

                if (target.Health_Current == 0)
                {
                    deadTargets.Add(target);
                    continue;
                }

                int healthMissing = target.Health_Max - target.Health_Current;

                if (healthMissing >= curePotency || target.Health_Percent < 70)
                {
                    damagedTargets.Add(target);
                    hurtPlayers++;
                }

                foreach (var item in lst_StatusEffects.Items)
                {
                    if (target.ContainsStatusEffect(Int32.Parse(item.ToString()), 0, false) && target.ContainsStatusEffect(292, 0, false) == false)
                    {
                        statusAilment = target;
                    }
                }
            }

            if (chk_SwiftcastRaiseAll.IsChecked == true)
            {
                deadTargets.Clear();
                deadTargets.AddRange(from player in players where player.Valid where !player.ContainsStatusEffect(292, 0, false) where !(player.DistanceFrom(_user) >= 30) where player.Health_Current == 0 select player);
            }

            damagedTargets = damagedTargets.Distinct().ToList();

            // Raise Tanks and Healers first
            deadTargets.Sort((a, b) => a.JobPriority.CompareTo(b.JobPriority));

            // Check if tank needs healing first
            if (chk_TankPriority.IsChecked == true)
            {
                // Check who is main tank atm.
                if (tank != null && tank2 != null)
                {
                    Character tank1Target = MemoryFunctions.GetCharacterFromID(tank.TargetID);
                    Character tank2Target = MemoryFunctions.GetCharacterFromID(tank2.TargetID);
                    Character highestHp   = null;

                    if (tank2Target != null)
                    {
                        highestHp = tank2Target;
                    }

                    if (tank1Target != null)
                    {
                        highestHp = tank1Target;
                    }

                    if (tank2Target != null && highestHp != null)
                    {
                        if (tank2Target.Health_Max > highestHp.Health_Max)
                        {
                            highestHp = tank2Target;
                        }
                    }

                    if (highestHp != null)
                    {
                        Character monstersTarget = MemoryFunctions.GetCharacterFromID(highestHp.TargetID);

                        if (monstersTarget != null)
                        {
                            if (monstersTarget.Name == tank2.Name)
                            {
                                Character ph = tank;
                                tank  = tank2;
                                tank2 = ph;
                            }
                        }
                    }
                }

                if (tank != null)
                {
                    this.Title = "Main Tank: " + tank.Name;
                }

                if (CheckTankHealth(tank, deadTargets, recast, damagedTargets))
                {
                    return;
                }
                if (CheckTankHealth(tank2, deadTargets, recast, damagedTargets))
                {
                    return;
                }
            }



            if (_user.IsMoving || MemoryFunctions.GetGroundCursor() > 0)
            {
                if (_spellCastTimer != null)
                {
                    _spellCastTimer.Stop();
                    _spellCastTimer = null;
                }
                _spellCast = false;

                if (tank != null)
                {
                    if (tank.ContainsStatusEffect(158, _user.ID, true, (float)2.5) == false &&
                        _hotkeys[REGEN].PercentReady == 100 && tank.Health_Percent != 100)
                    {
                        tank.Target();
                        _hotkeys[REGEN].UseAbility();

                        return;
                    }
                }

                if (damagedTargets.Count > 0)
                {
                    damagedTargets.Sort((a, b) => a.Health_Percent.CompareTo(b.Health_Percent));
                    damagedTargets.First().Target();
                }

                return;
            }

            double avgMissingHealth = 0;

            if (damagedTargets.Count > 0)
            {
                avgMissingHealth = damagedTargets.Average(a => (a.Health_Max - a.Health_Current));
            }

            if ((chk_SwiftcastRaise.IsChecked == true || chk_SwiftcastRaiseAll.IsChecked == true) && deadTargets.Count > 0 && _hotkeys[SWIFTCAST].PercentReady == 100 && recast.WeaponSpecials.Count == 0 && _user.Mana_Current >= 798)
            {
                deadTargets.First().Target();
                Thread.Sleep(150);

                if (ForceSwiftcast())
                {
                    return;
                }

                Thread.Sleep(150);

                _hotkeys[RAISE].UseAbility();
                _hotkeys[RAISE].UseAbility();
                _hotkeys[RAISE].UseAbility();
                Thread.Sleep(50);
                _hotkeys[RAISE].UseAbility();


                Thread.Sleep(150);
            }
            else if (damagedTargets.Count > 0)
            {
                damagedTargets.Sort((a, b) => a.Health_Percent.CompareTo(b.Health_Percent));
                damagedTargets.First().Target();
                Thread.Sleep(100);

                recast.Refresh();

                // Benediction Check
                if (chk_TankPriority.IsChecked == false)
                {
                    if (damagedTargets.First().Health_Percent <= 30 && _hotkeys[BENEDICTION].PercentReady == 100)
                    {
                        _hotkeys[BENEDICTION].UseAbility();

                        _spellCastTimer = new Stopwatch();
                        _spellCastTimer.Reset();
                        _spellCastTimer.Start();
                        _spellCast = true;
                        return;
                    }
                }

                if (recast.WeaponSpecials.Count == 0)
                {
                    if (_spellCast)
                    {
                        _spellCastTimer = new Stopwatch();
                        _spellCastTimer.Reset();
                        _spellCastTimer.Start();
                        _spellCast = false;
                    }

                    // Make sure we are not spamming spells too quickly.
                    if (_spellCastTimer != null)
                    {
                        if (_spellCastTimer.ElapsedMilliseconds <= _castWaitTime)
                        {
                            return;
                        }
                        _spellCastTimer.Stop();
                        _spellCastTimer = null;
                    }

                    recast.Refresh();
                    Stopwatch timeout = new Stopwatch();
                    timeout.Reset();
                    timeout.Start();
                    //Debug.Print("Casting...");

                    bool useAoe = _hotkeys[MEDICA].TimeSinceLastUse.TotalSeconds > 6 &&
                                  _hotkeys[MEDICA2].TimeSinceLastUse.TotalSeconds > 6 &&
                                  _hotkeys[CURE3].TimeSinceLastUse.TotalSeconds > 6;

                    while (recast.WeaponSpecials.Count == 0)
                    {
                        UIWindow ui = new UIWindow();
                        ui.RefreshPointers();

                        if (ui.GetActiveWindowName() == "chatlog")
                        {
                            return;
                        }

                        if (timeout.ElapsedMilliseconds > 1000)
                        {
                            _spellCast = false;
                            break;
                        }

                        Whm_AI(hurtPlayers, damagedTargets, cure2Potency, useAoe);
                        recast.Refresh();
                        _hotkeys.QuickRefreshAbilities();
                        _spellCast = true;
                    }
                }
                else
                {
                    if (damagedTargets.Count > 2 && avgMissingHealth > curePotency)
                    {
                        if (_hotkeys[PRESENCEOFMIND].PercentReady == 100 && _user.ContainsStatusEffect(159, 0, false) == false)
                        {
                            _hotkeys[PRESENCEOFMIND].UseAbility();
                        }
                        else if (_hotkeys[DIVINESEAL].PercentReady == 100 && _user.ContainsStatusEffect(157, 0, false) == false)
                        {
                            _hotkeys[DIVINESEAL].UseAbility();
                        }
                    }
                }
            }
            else if (statusAilment != null)
            {
                statusAilment.Target();
                _hotkeys[ESUNA].UseAbility();
            }
        }