Example #1
0
        // Cougar Q Logic
        internal static void CastTakedown(Obj_AI_Base target, string mode)
        {
            if (KL.CatForm())
            {
                if (!KL.SpellTimer["Takedown"].IsReady() || !KN.Root.Item("ndcq" + mode).GetValue <bool>())
                {
                    return;
                }

                // temp logic to prevent takdown cast before swipe
                if (!KL.SpellTimer["Swipe"].IsReady() || KL.NotLearned(KL.Spells["Swipe"]) || !KN.Root.Item("ndce" + mode).GetValue <bool>())
                {
                    if (target.IsValidTarget(KL.Player.AttackRange + KL.Spells["Takedown"].Range))
                    {
                        KL.Spells["Takedown"].CastOnUnit(target);
                    }
                }
            }
        }
Example #2
0
        internal static void Game_OnUpdate(EventArgs args)
        {
            Target = TargetSelector.GetTarget(KL.Spells["Javelin"].Range, TargetSelector.DamageType.Magical);

            #region Active Modes

            if (Root.Item("usecombo").GetValue <KeyBind>().Active)
            {
                Combo();
            }

            if (Root.Item("useharass").GetValue <KeyBind>().Active)
            {
                Harass();
            }

            if (Root.Item("usefarm").GetValue <KeyBind>().Active)
            {
                Clear();
            }

            if (Root.Item("flee").GetValue <KeyBind>().Active)
            {
                Flee();
            }

            #endregion

            #region Auto Heal

            // auto heal on ally hero
            if (Root.Item("ndheon").GetValue <bool>() && KL.SpellTimer["Primalsurge"].IsReady())
            {
                if (!KL.NotLearned(KL.Spells["Primalsurge"]))
                {
                    if (!Player.Spellbook.IsChanneling && !Player.IsRecalling())
                    {
                        if (Root.Item("flee").GetValue <KeyBind>().Active&& KL.CatForm())
                        {
                            return;
                        }

                        if (Player.Mana / Player.MaxMana * 100 < Root.Item("ndhemana").GetValue <Slider>().Value)
                        {
                            return;
                        }

                        if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.None || !KL.CatForm())
                        {
                            foreach (
                                var hero in
                                HeroManager.Allies.Where(
                                    h => Root.Item("xx" + h.ChampionName).GetValue <bool>() &&
                                    h.IsValidTarget(KL.Spells["Primalsurge"].Range, false) &&
                                    h.Health / h.MaxHealth * 100 <
                                    Root.Item("zz" + h.ChampionName).GetValue <Slider>().Value)
                                .OrderBy(x => x.HealthPercent))
                            {
                                if (KL.CatForm() == false)
                                {
                                    KL.Spells["Primalsurge"].CastOnUnit(hero);
                                }

                                if (KL.CatForm() && Root.Item("ndhesw").GetValue <bool>() &&
                                    KL.Spells["Aspect"].IsReady())
                                {
                                    KL.Spells["Aspect"].Cast();
                                }
                            }
                        }
                    }
                }
            }

            #endregion
        }
Example #3
0
        internal static void SwitchForm(Obj_AI_Base target, string mode)
        {
            if (!target.IsValidTarget(KL.Spells["Javelin"].Range))
            {
                return;
            }

            // catform -> human
            if (KL.CatForm() && KL.Spells["Aspect"].IsReady() && KN.Root.Item("ndcr" + mode).GetValue <bool>())
            {
                // get hitbox
                var radius = KL.Player.AttackRange + KL.Player.Distance(KL.Player.BBox.Minimum) + 1;

                // dont switch if have Q buff and near target
                if (KL.SpellTimer["Takedown"].IsReady() && KL.Player.HasBuff("Takedown") &&
                    target.Distance(KL.Player.ServerPosition) <= KL.Spells["Takedown"].Range + 45f)
                {
                    return;
                }

                // change form if Q is ready and meets hitchance
                if (KL.SpellTimer["Javelin"].IsReady() && target.IsChampion())
                {
                    var poutput = KL.Spells["Javelin"].GetPrediction(target);
                    if (poutput.Hitchance >= HitChance.High)
                    {
                        KL.Spells["Aspect"].Cast();
                    }
                }

                // is jungling
                if (mode == "jg")
                {
                    if (KL.SpellTimer["Bushwhack"].IsReady() && KL.Spells["Bushwhack"].Level > 0 ||
                        KL.SpellTimer["Javelin"].IsReady() && KL.Spells["Javelin"].Level > 0)
                    {
                        if (KL.Spells["Javelin"].Cast(target) != Spell.CastStates.Collision &&
                            KL.SpellTimer["Javelin"].IsReady() || KL.SpellTimer["Bushwhack"].IsReady())
                        {
                            if (!KL.SpellTimer["Swipe"].IsReady() || !KL.SpellTimer["Takedown"].IsReady() ||
                                KL.Player.Distance(target.ServerPosition) > 355)
                            {
                                KL.Spells["Aspect"].Cast();
                            }
                        }
                    }
                }
                else
                {
                    // change to human if out of pounce range and can die
                    if (!KL.SpellTimer["Pounce"].IsReady() && target.Distance(KL.Player.ServerPosition) <= 525)
                    {
                        if (target.Distance(KL.Player.ServerPosition) > radius)
                        {
                            if (KL.Player.GetAutoAttackDamage(target, true) * 3 >= target.Health)
                            {
                                KL.Spells["Aspect"].Cast();
                            }
                        }
                    }
                }
            }

            // human -> catform
            if (!KL.CatForm() && KL.Spells["Aspect"].IsReady() && KN.Root.Item("ndhr" + mode).GetValue <bool>())
            {
                if (mode == "jg")
                {
                    if (KL.Counter < KN.Root.Item("aareq").GetValue <Slider>().Value&&
                        KN.Root.Item("jgaacount").GetValue <KeyBind>().Active)
                    {
                        return;
                    }
                }

                if (mode == "gap")
                {
                    if (target.IsValidTarget(375))
                    {
                        KL.Spells["Aspect"].Cast();
                        return;
                    }
                }

                if (mode == "wc")
                {
                    if (target.IsValidTarget(375) && target.IsMinion)
                    {
                        KL.Spells["Aspect"].Cast();
                        return;
                    }
                }

                if (target.IsHunted())
                {
                    // force switch no swipe/takedown req
                    if (!KN.Root.Item("ndhrcreq").GetValue <bool>() && mode == "co" ||
                        !KN.Root.Item("ndhrjreq").GetValue <bool>() && mode == "jg")
                    {
                        KL.Spells["Aspect"].Cast();
                        return;
                    }

                    if (target.Distance(KL.Player) > KL.Spells["Takedown"].Range + 50 &&
                        KL.NotLearned(KL.Spells["Pounce"]))
                    {
                        return;
                    }

                    // or check if pounce timer is ready before switch
                    if (KL.Spells["Aspect"].IsReady() && target.IsValidTarget(KL.Spells["ExPounce"].Range))
                    {
                        // dont pounce if swipe or takedown isn't ready
                        if ((KL.SpellTimer["Takedown"].IsReady() || KL.SpellTimer["Swipe"].IsReady()) &&
                            KL.SpellTimer["Pounce"].IsReady(1))
                        {
                            KL.Spells["Aspect"].Cast();
                        }
                    }
                }
                else
                {
                    // check if in pounce range oops.
                    if (target.Distance(KL.Player.ServerPosition) <= KL.Spells["Pounce"].Range + 100)
                    {
                        if (target.IsValidTarget(KL.Spells["Pounce"].Range + 100))
                        {
                            if (mode != "jg")
                            {
                                // switch to cougar if can kill target
                                if (KL.CatDamage(target) >= target.Health)
                                {
                                    if (mode == "co" && target.IsValidTarget(KL.Spells["Pounce"].Range))
                                    {
                                        KL.Spells["Aspect"].Cast();
                                    }
                                }

                                // switch if Q disabled in menu
                                if (!KN.Root.Item("ndhq" + mode).GetValue <bool>() ||

                                    // or Q is not learned
                                    KL.NotLearned(KL.Spells["Javelin"]) ||

                                    // delay the cast .5 seconds
                                    Utils.GameTimeTickCount - (int)(KL.TimeStamp["Javelin"] * 1000) +
                                    ((6 + (6 * KL.Player.PercentCooldownMod)) * 1000) >= 500 &&

                                    // if Q is not ready in 2 seconds
                                    !KL.SpellTimer["Javelin"].IsReady(2))
                                {
                                    KL.Spells["Aspect"].Cast();
                                }
                            }
                            else
                            {
                                if (KL.Spells["Javelin"].Cast(target) == Spell.CastStates.Collision && KN.Root.Item("spcol").GetValue <bool>())
                                {
                                    if (!KL.SpellTimer["Bushwhack"].IsReady() || KL.NotLearned(KL.Spells["Bushwhack"]))
                                    {
                                        if (KL.Spells["Aspect"].IsReady())
                                        {
                                            KL.Spells["Aspect"].Cast();
                                        }
                                    }
                                }
                            }
                        }
                    }

                    if (KN.Target.IsValidTarget(KL.Spells["Javelin"].Range) && target.IsChampion())
                    {
                        if (KL.SpellTimer["Javelin"].IsReady())
                        {
                            // check if in pounce range.
                            if (target.Distance(KL.Player.ServerPosition) <= KL.Spells["Pounce"].Range + 25)
                            {
                                // if we dont meet hitchance on Q target pounce nearest target
                                var poutput = KL.Spells["Javelin"].GetPrediction(target);
                                if (poutput.Hitchance >= (HitChance)(KN.Root.Item("ndhqch").GetValue <StringList>().SelectedIndex + 3))
                                {
                                    if (KL.Spells["Aspect"].IsReady())
                                    {
                                        KL.Spells["Aspect"].Cast();
                                    }
                                }
                            }
                        }

                        if (KN.Target.IsHunted() && KN.Target.Distance(KL.Player.ServerPosition) >
                            KL.Spells["ExPounce"].Range + 100)
                        {
                            if (target.Distance(KL.Player.ServerPosition) <= KL.Spells["Pounce"].Range + 25)
                            {
                                if (KL.Spells["Aspect"].IsReady())
                                {
                                    KL.Spells["Aspect"].Cast();
                                }
                            }
                        }

                        if (!KL.SpellTimer["Javelin"].IsReady())
                        {
                            if (target.Distance(KL.Player.ServerPosition) <= KL.Spells["Pounce"].Range + 125)
                            {
                                KL.Spells["Aspect"].Cast();
                            }
                        }
                    }
                }
            }
        }