public static HRESULT GetThemeSysInt(IHandle hTheme, TMT iIntId, ref int piValue)
        {
            HRESULT result = GetThemeSysInt(hTheme.Handle, iIntId, ref piValue);

            GC.KeepAlive(hTheme);
            return(result);
        }
Пример #2
0
        public static BOOL GetThemeSysBool(IHandle hTheme, TMT iBoolId)
        {
            BOOL result = GetThemeSysBool(hTheme.Handle, iBoolId);

            GC.KeepAlive(hTheme);
            return(result);
        }
Пример #3
0
 public T EnsureEnumValue <T>(TMT propertyId, T defaultValue)
     where T : struct
 {
     if (!typeof(T).IsEnum)
     {
         throw new ArgumentException("Type must be enum");
     }
     return(EnsurePropertyValue(propertyId, TMT.ENUM, defaultValue));
 }
Пример #4
0
        public T EnsurePropertyValue <T>(TMT propertyId, TMT primitiveType, T defaultValue)
        {
            if (Find(propertyId, out T value))
            {
                return(value);
            }

            AddDefaultProperty(propertyId, primitiveType, defaultValue);
            return(defaultValue);
        }
Пример #5
0
        private static float GetComboDamage(Obj_AI_Base target)
        {
            double DamageDealt = 0;

            var useQ    = Config.Item("combo_Q").GetValue <bool>();
            var useW    = Config.Item("combo_W").GetValue <bool>();
            var useE    = Config.Item("combo_E").GetValue <bool>();
            var useR    = Config.Item("combo_R").GetValue <bool>();
            var useRUSH = Config.Item("combo_RUSH").GetValue <bool>();
            var useTMT  = Config.Item("item_TMT").GetValue <bool>();
            var useHYD  = Config.Item("item_HYD").GetValue <bool>();

            // Q
            if (Q.IsReady() && useQ)
            {
                DamageDealt += DamageDealt += Q.GetDamage(target);
            }


            // W
            if (W.IsReady() && useW)
            {
                DamageDealt += W.GetDamage(target);
            }

            // R
            if (R.IsReady() && (useR || useRUSH))
            {
                DamageDealt += R.GetDamage(target);
            }

            //  Tiamat
            if (TMT.IsReady() && useTMT)
            {
                DamageDealt += Player.GetItemDamage(target, Damage.DamageItems.Tiamat);
            }


            // Hydra
            if (HYD.IsReady() && useHYD)
            {
                DamageDealt += Player.GetItemDamage(target, Damage.DamageItems.Hydra);
            }

            // E damage amplification
            double[] Amp = { 0, 1.03, 1.06, 1.09, 1.12, 1.15 };

            if (E.IsReady() && useE)
            {
                DamageDealt += DamageDealt * Amp[E.Level];
            }

            return((float)DamageDealt);
        }
Пример #6
0
        public T FindProperty <T>(TMT propertyId, T defaultValue)
            where T : struct
        {
            var property = Properties.FirstOrDefault(x => x.PropertyId == propertyId);

            if (property != null)
            {
                return((T)property.Value);
            }
            return(defaultValue);
        }
Пример #7
0
 private static void UseItems(Obj_AI_Hero target)
 {
     if (player.Distance(target) < player.AttackRange + player.BoundingRadius)
     {
         TMT.Cast();
         HYD.Cast();
     }
     BWC.Cast(target);
     BRK.Cast(target);
     RO.Cast(target);
     YMG.Cast();
 }
Пример #8
0
 public ThemeProperty(
     IPropertyOwner owner, int index, long offset, TMT propertyId, TMT primitiveType,
     PropertyOrigin origin, object value)
 {
     Owner         = owner;
     Index         = index;
     Offset        = offset;
     PropertyId    = propertyId;
     PrimitiveType = primitiveType;
     Origin        = origin;
     Value         = value;
 }
Пример #9
0
        private static void UseItems(Obj_AI_Base unit, bool isMinion = false)
        {
            if (!unit.IsValidTarget())
            {
                return;
            }


            if (SKOMenu.Item("Hydra").GetValue <bool>() && player.Distance(unit) < HYD.Range)
            {
                HYD.Cast();
            }
            if (SKOMenu.Item("Hydra").GetValue <bool>() && player.Distance(unit) < TMT.Range)
            {
                TMT.Cast();
            }
            if (SKOMenu.Item("BOTRK").GetValue <bool>() && player.Distance(unit) <= BRK.Range)
            {
                if (isMinion)
                {
                    return;
                }
                BRK.Cast(unit);
            }
            if (SKOMenu.Item("BOTRK").GetValue <bool>() && player.Distance(unit) <= BWC.Range)
            {
                BWC.Cast(unit);
            }
            if (SKOMenu.Item("RO").GetValue <bool>() && player.Distance(unit) <= RO.Range)
            {
                if (isMinion)
                {
                    return;
                }
                RO.Cast();
            }
            if (SKOMenu.Item("DFG").GetValue <bool>() && player.Distance(unit) <= DFG.Range)
            {
                if (isMinion)
                {
                    return;
                }
                DFG.Cast(unit);
            }
            if (SKOMenu.Item("YMU").GetValue <bool>() && player.Distance(unit) <= YMG.Range)
            {
                YMG.Cast();
            }
            if (SKOMenu.Item("SOD").GetValue <bool>() && player.Distance(unit) <= STD.Range)
            {
                STD.Cast();
            }
        }
Пример #10
0
        public bool Find <T>(TMT propertyId, out T value)
        {
            var entry = Properties.FirstOrDefault(x => x.PropertyId == propertyId);

            if (entry == null)
            {
                value = default;
                return(false);
            }

            value = (T)entry.RawValue;
            return(true);
        }
Пример #11
0
        private static void Clear()
        {
            var allminions = MinionManager.GetMinions(_player.ServerPosition, 1000, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);

            foreach (var minion in allminions.Where(minion => minion.IsValidTarget()))
            {
                if (_player.Mana <= 4)
                {
                    if (Q.IsReady() && SKOMenu.Item("UseQC").GetValue <bool>() && _player.Distance(minion) <= Q.Range)
                    {
                        Q.Cast();
                    }
                    if (W.IsReady() && SKOMenu.Item("UseWC").GetValue <bool>() && _player.Distance(minion) <= W.Range)
                    {
                        W.Cast();
                    }
                    if (E.IsReady() && SKOMenu.Item("UseEC").GetValue <bool>() && _player.Distance(minion) <= E.Range)
                    {
                        E.Cast(minion, PacketCast);
                    }
                }
                if (_player.Mana == 5)
                {
                    if (SKOMenu.Item("Save").GetValue <bool>())
                    {
                        return;
                    }
                    if (SKOMenu.Item("FPrio").GetValue <StringList>().SelectedIndex == 0 && Q.IsReady() && SKOMenu.Item("UseQC").GetValue <bool>() && _player.Distance(minion) <= Q.Range)
                    {
                        Q.Cast();
                    }
                    if (SKOMenu.Item("FPrio").GetValue <StringList>().SelectedIndex == 1 && W.IsReady() && SKOMenu.Item("UseWC").GetValue <bool>() && _player.Distance(minion) <= W.Range)
                    {
                        W.Cast();
                    }
                    if (SKOMenu.Item("FPrio").GetValue <StringList>().SelectedIndex == 2 && E.IsReady() && SKOMenu.Item("UseEC").GetValue <bool>() && _player.Distance(minion) <= E.Range)
                    {
                        E.Cast(minion, PacketCast);
                    }
                }
                if (SKOMenu.Item("UseItemsClear").GetValue <bool>())
                {
                    if (_player.Distance(minion) < _player.AttackRange + 50)
                    {
                        TMT.Cast();
                        HYD.Cast();
                    }
                    YMG.Cast();
                }
            }
        }
Пример #12
0
        private static void TripleQ(Obj_AI_Hero target)
        {
            if (target.IsValidTarget())
            {
                if (Player.Mana == 5 && R.IsReady() && Player.Distance(target) <= R.Range && Q.IsReady())
                {
                    R.Cast();
                }
                if (Player.Mana < 5)
                {
                    Drawing.DrawText(Player.Position.X, Player.Position.Y, Color.Red, "R is not ready, or you do not have 5 ferocity");
                }


                if (Player.Mana == 5 && Player.HasBuff("RengarR") && Q.IsReady() && Player.Distance(target) <= Q.Range)
                {
                    Q.Cast();
                }
                if (Player.Mana == 5 && !Player.HasBuff("RengarR") && Q.IsReady() && Player.Distance(target) <= Q.Range)
                {
                    Q.Cast();
                }
                if (Player.Mana <= 4)
                {
                    if (Q.IsReady() && Player.Distance(target) <= Q.Range)
                    {
                        Q.Cast();
                    }
                    if (W.IsReady() && Player.Distance(target) <= W.Range)
                    {
                        W.Cast();
                    }
                    if (E.IsReady() && Player.Distance(target) <= E.Range)
                    {
                        E.Cast(target, PacketCast);
                    }
                }
                if (Player.Distance(target) < Player.AttackRange + 50)
                {
                    TMT.Cast();
                    HYD.Cast();
                    STD.Cast();
                }
                BWC.Cast(target);
                BRK.Cast(target);
                RO.Cast(target);
                YMG.Cast();
            }
        }
Пример #13
0
 private static bool IsImageFile(TMT property)
 {
     return
         (property == TMT.IMAGEFILE ||
          property == TMT.IMAGEFILE1 ||
          property == TMT.IMAGEFILE2 ||
          property == TMT.IMAGEFILE3 ||
          property == TMT.IMAGEFILE4 ||
          property == TMT.IMAGEFILE5 ||
          property == TMT.IMAGEFILE6 ||
          property == TMT.IMAGEFILE7 ||
          property == TMT.COMPOSEDIMAGEFILE1 ||
          property == TMT.COMPOSEDIMAGEFILE2 ||
          property == TMT.COMPOSEDIMAGEFILE3 ||
          property == TMT.COMPOSEDIMAGEFILE4 ||
          property == TMT.COMPOSEDIMAGEFILE5 ||
          property == TMT.COMPOSEDIMAGEFILE6 ||
          property == TMT.COMPOSEDIMAGEFILE7);
 }
Пример #14
0
        private static void Harass()
        {
            var target = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Physical);

            if (target.IsValidTarget())
            {
                if (_player.Mana <= 4)
                {
                    if (SKOMenu.Item("UseWH").GetValue <bool>() && _player.Distance(target) <= W.Range)
                    {
                        CastW(target);
                    }
                    if (SKOMenu.Item("UseEH").GetValue <bool>() && _player.Distance(target) <= E.Range)
                    {
                        CastE(target);
                    }
                }
                if (_player.Mana == 5)
                {
                    if (SKOMenu.Item("UseWH").GetValue <bool>() && SKOMenu.Item("HPrio").GetValue <StringList>().SelectedIndex == 0)
                    {
                        CastW(target);
                    }
                    if (SKOMenu.Item("UseEH").GetValue <bool>() && SKOMenu.Item("HPrio").GetValue <StringList>().SelectedIndex == 1)
                    {
                        CastE(target);
                    }
                }
                if (SKOMenu.Item("UseItemsHarass").GetValue <bool>())
                {
                    if (_player.Distance(target) < _player.AttackRange + 50)
                    {
                        TMT.Cast();
                        HYD.Cast();
                        STD.Cast();
                    }
                    BWC.Cast(target);
                    BRK.Cast(target);
                    RO.Cast(target);
                    YMG.Cast();
                }
            }
        }
Пример #15
0
 private static void TripleQ(Obj_AI_Hero target)
 {
     if (target.IsValidTarget())
     {
         if (_player.Mana == 5 && R.IsReady() && _player.Distance(target) <= R.Range && Q.IsReady())
         {
             R.Cast();
         }
         if (_player.Mana == 5 && _player.HasBuff("RengarR") && _player.Distance(target) <= Q.Range)
         {
             CastQ(target);
         }
         if (_player.Mana == 5 && !_player.HasBuff("RengarR") && _player.Distance(target) <= Q.Range)
         {
             CastQ(target);
         }
         if (_player.Mana <= 4)
         {
             if (_player.Distance(target) <= Q.Range)
             {
                 CastQ(target);
             }
             if (_player.Distance(target) <= W.Range)
             {
                 CastW(target);
             }
             if (_player.Distance(target) <= E.Range)
             {
                 CastE(target);
             }
         }
         if (_player.Distance(target) < _player.AttackRange + 50)
         {
             TMT.Cast();
             HYD.Cast();
             STD.Cast();
         }
         BWC.Cast(target);
         BRK.Cast(target);
         RO.Cast(target);
         YMG.Cast();
     }
 }
Пример #16
0
        private static void Clear()
        {
            var allminions = MinionManager.GetMinions(player.ServerPosition, MiniQ.Range, MinionTypes.All,
                                                      MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);


            foreach (var minions in allminions)
            {
                var qDmg     = player.GetSpellDamage(minions, SpellSlot.Q);
                var qpredmin = MiniQ.GetPrediction(minions);
                var qpredmeg = MegaQ.GetPrediction(minions);

                if (minions.IsValidTarget(MegaQ.Range) && MegaGnar)
                {
                    if (SKOMenu.Item("UseQC").GetValue <bool>() && MegaQ.IsReady() && player.Distance(minions) <= MegaQ.Range)
                    {
                        MegaQ.Cast(minions, PacketCast);
                    }
                    if (SKOMenu.Item("UseWC").GetValue <bool>() && MegaW.IsReady() && player.Distance(minions) <= MegaW.Range)
                    {
                        MegaW.Cast(minions, PacketCast);
                    }
                }
                else if (minions.IsValidTarget(MiniQ.Range) && !MegaGnar)
                {
                    if (SKOMenu.Item("UseQC").GetValue <bool>() && MiniQ.IsReady() && player.Distance(minions) <= MiniQ.Range)
                    {
                        MegaQ.Cast(minions, PacketCast);
                    }
                }
                if (SKOMenu.Item("UseItemsClear").GetValue <bool>())
                {
                    if (player.Distance(minions) < player.AttackRange + player.BoundingRadius)
                    {
                        TMT.Cast();
                        HYD.Cast();
                    }
                    YMG.Cast();
                }
            }
        }
Пример #17
0
 private static void Harass(Obj_AI_Hero target)
 {
     if (target.IsValidTarget())
     {
         if (Player.Mana <= 4)
         {
             if (SKOMenu.Item("UseWH").GetValue <bool>() && W.IsReady() && Player.Distance(target) <= W.Range)
             {
                 W.Cast();
             }
             if (SKOMenu.Item("UseEW").GetValue <bool>() && E.IsReady() && Player.Distance(target) <= E.Range)
             {
                 E.Cast(target, PacketCast);
             }
         }
         if (Player.Mana == 5)
         {
             if (SKOMenu.Item("UseWH").GetValue <bool>() && SKOMenu.Item("HPrio").GetValue <StringList>().SelectedIndex == 0 && W.IsReady())
             {
                 W.Cast();
             }
             if (SKOMenu.Item("UseEH").GetValue <bool>() && SKOMenu.Item("HPrio").GetValue <StringList>().SelectedIndex == 0 && E.IsReady())
             {
                 E.Cast(target, PacketCast);
             }
         }
         if (SKOMenu.Item("UseItemsHarass").GetValue <bool>())
         {
             if (Player.Distance(target) < Player.AttackRange + 50)
             {
                 TMT.Cast();
                 HYD.Cast();
                 STD.Cast();
             }
             BWC.Cast(target);
             BRK.Cast(target);
             RO.Cast(target);
             YMG.Cast();
         }
     }
 }
Пример #18
0
        private object GetEnum(int value, TMT symbolVal)
        {
            switch (symbolVal)
            {
            case TMT.BGTYPE: return((BGTYPE)value);

            case TMT.IMAGELAYOUT: return((IMAGELAYOUT)value);

            case TMT.BORDERTYPE: return((BORDERTYPE)value);

            case TMT.FILLTYPE: return((FILLTYPE)value);

            case TMT.SIZINGTYPE: return((SIZINGTYPE)value);

            case TMT.HALIGN: return((HALIGN)value);

            case TMT.CONTENTALIGNMENT: return((CONTENTALIGNMENT)value);

            case TMT.VALIGN: return((VALIGN)value);

            case TMT.OFFSETTYPE: return((OFFSETTYPE)value);

            case TMT.ICONEFFECT: return((ICONEFFECT)value);

            case TMT.TEXTSHADOWTYPE: return((TEXTSHADOWTYPE)value);

            case TMT.GLYPHTYPE: return((GLYPHTYPE)value);

            case TMT.IMAGESELECTTYPE: return((IMAGESELECTTYPE)value);

            case TMT.TRUESIZESCALINGTYPE: return((TRUESIZESCALINGTYPE)value);

            case TMT.GLYPHFONTSIZINGTYPE: return((GLYPHFONTSIZINGTYPE)value);

            case TMT.HCGLYPHBGCOLOR: return((HIGHCONTRASTCOLOR)value);

            default: return(value);
            }
        }
Пример #19
0
        private static void Combo(Obj_AI_Hero target)
        {
            if (target != null)
            {
                if (Config.Item("UseECombo").GetValue <bool>() && E.IsReady() && Player.Distance(target) <= Q.Range)
                {
                    E.Cast(target, true);
                }
                if (Config.Item("UseQCombo").GetValue <bool>() && Q.IsReady())
                {
                    Q.Cast(target, true);
                }
                if (Config.Item("UseWCombo").GetValue <bool>() && W.IsReady())
                {
                    W.Cast(target);
                }

                if (Config.Item("UseRCombo").GetValue <bool>() && R.IsReady() && !ult)
                {
                    if (GetEnemys(target) >= Config.Item("MinEnemys").GetValue <Slider>().Value)
                    {
                        R.Cast(target);
                    }
                }
                if (Config.Item("UseItems").GetValue <bool>())
                {
                    BKR.Cast(target);
                    YOU.Cast(target);
                    BWC.Cast(target);
                    DFG.Cast(target);
                    SOD.Cast(target);
                    RO.Cast(target);
                    HDR.Cast(target);
                    TMT.Cast(target);
                }
            }
        }
Пример #20
0
        public override void AddDefaultProperty(TMT propertyId, TMT primitiveType, object value)
        {
            var property = new ThemeProperty(State, -1, -1, propertyId, primitiveType, PropertyOrigin.Default, value);

            properties.Add(new OwnedThemePropertyViewModel(property));
        }
Пример #21
0
 public static partial BOOL GetThemeSysBool(IntPtr hTheme, TMT iBoolId);
Пример #22
0
 public static extern BOOL GetThemeSysBool(IntPtr hTheme, TMT iBoolId);
Пример #23
0
        private static void Combo()
        {
            Orbwalker.SetAttacks(true);

            var qTarget = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Magical);
            var eTarget = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);
            var rTarget = SimpleTs.GetTarget(R.Range, SimpleTs.DamageType.Magical);

            bool useQ = Config.Item("UseQCombo").GetValue <bool>();
            bool useW = Config.Item("UseWCombo").GetValue <bool>();
            bool useE = Config.Item("UseECombo").GetValue <bool>();
            bool useR = Config.Item("UseRCombo").GetValue <bool>();

            if (Config.Item("UseItems").GetValue <bool>())
            {
                BKR.Cast(qTarget);
                YOU.Cast();
                BWC.Cast(qTarget);
                if (Player.Distance(qTarget) <= HDR.Range)
                {
                    HDR.Cast(qTarget);
                }
                if (Player.Distance(qTarget) <= TMT.Range)
                {
                    TMT.Cast(qTarget);
                }
            }

            if (Q.IsReady() && E.IsReady() && R.IsReady() &&
                DamageLib.IsKillable(
                    qTarget,
                    new[]
            {
                DamageLib.SpellType.Q, DamageLib.SpellType.E, DamageLib.SpellType.R,
                DamageLib.SpellType.AD, DamageLib.SpellType.AD
            }))
            {
                if (qTarget != null && useQ && Q.IsReady())
                {
                    if ((Config.Item("NoQNear").GetValue <bool>() && Player.Distance(qTarget) < Player.AttackRange + 50) ||
                        (Config.Item("EbeforeQ").GetValue <bool>() && E.IsReady()))
                    {
                        return;
                    }
                }
                Q.Cast(qTarget, true, true);

                if (rTarget != null && useR && R.IsReady())
                {
                    R.Cast(rTarget, true);
                }

                if (useW && W.IsReady())
                {
                    if (Player.Health < (Player.MaxHealth * (Config.Item("SwitchLife").GetValue <Slider>().Value) * 0.01) && !WHealing)
                    {
                        W.Cast();
                    }
                    else
                    if (Player.Health > (Player.MaxHealth * (Config.Item("SwitchPower").GetValue <Slider>().Value) * 0.01) && WHealing)
                    {
                        W.Cast();
                    }
                }

                if (eTarget != null && useE && E.IsReady())
                {
                    E.Cast(eTarget, true);
                }
            }
            else
            {
                if (qTarget != null && useQ && Q.IsReady())
                {
                    if ((Config.Item("NoQNear").GetValue <bool>() && Player.Distance(qTarget) < Player.AttackRange + 50) ||
                        (Config.Item("EbeforeQ").GetValue <bool>() && E.IsReady()))
                    {
                        return;
                    }
                }
                Q.Cast(qTarget, true, true);

                if (useW && W.IsReady())
                {
                    if (Player.Health < (Player.MaxHealth * 0.4) && !WHealing)
                    {
                        W.Cast();
                    }
                    else
                    if (Player.Health > (Player.MaxHealth * 0.55) && WHealing)
                    {
                        W.Cast();
                    }
                }

                if (eTarget != null && useE && E.IsReady())
                {
                    E.Cast(eTarget, true);
                }
            }
        }
Пример #24
0
 public ThemeProperty FindProperty(TMT propertyId)
 {
     return(Properties.FirstOrDefault(x => x.PropertyId == propertyId)
            ?? Parent.FindProperty(propertyId));
 }
 public static extern HRESULT GetThemeSysInt(IntPtr hTheme, TMT iIntId, ref int piValue);
Пример #26
0
 public ThemeProperty FindProperty(TMT propertyId)
 {
     return(Properties.FirstOrDefault(x => x.PrimitiveType == propertyId));
 }
Пример #27
0
        private static void Game_OnGameUpdate(EventArgs args)
        {
            if (SKOMenu.Item("activeClear").GetValue <KeyBind>().Active)
            {
                Clear();
            }
            var tqtarget = SimpleTs.GetTarget(R.Range, SimpleTs.DamageType.Physical);

            if (SKOMenu.Item("TripleQ").GetValue <KeyBind>().Active)
            {
                TripleQ(tqtarget);
            }

            var target = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Physical);

            Q   = new Spell(SpellSlot.Q, Player.AttackRange + 90);
            YMG = new Items.Item(3142, Player.AttackRange + 50);
            STD = new Items.Item(3131, Player.AttackRange + 50);

            AutoHeal();
            KillSteal(target);

            if (SKOMenu.Item("activeCombo").GetValue <KeyBind>().Active)
            {
                if (target.IsValidTarget())
                {
                    if (Player.Mana <= 4)
                    {
                        if (SKOMenu.Item("UseQ").GetValue <bool>() && Q.IsReady() && Player.Distance(target) <= Q.Range)
                        {
                            Q.Cast();
                        }
                        if (SKOMenu.Item("UseW").GetValue <bool>() && W.IsReady() && Player.Distance(target) <= W.Range)
                        {
                            W.Cast();
                        }
                        if (SKOMenu.Item("UseE").GetValue <bool>() && E.IsReady() && Player.Distance(target) <= E.Range)
                        {
                            E.Cast(target, PacketCast);
                        }
                    }
                    if (Player.Mana == 5)
                    {
                        if (SKOMenu.Item("UseQ").GetValue <bool>() && SKOMenu.Item("CPrio").GetValue <StringList>().SelectedIndex == 0 && Q.IsReady() && Player.Distance(target) <= Q.Range)
                        {
                            Q.Cast();
                        }
                        if (SKOMenu.Item("UseW").GetValue <bool>() && SKOMenu.Item("CPrio").GetValue <StringList>().SelectedIndex == 1 && W.IsReady() && Player.Distance(target) <= W.Range)
                        {
                            W.Cast();
                        }
                        if (SKOMenu.Item("UseE").GetValue <bool>() && SKOMenu.Item("CPrio").GetValue <StringList>().SelectedIndex == 2 && E.IsReady() && Player.Distance(target) <= E.Range)
                        {
                            E.Cast(target);
                        }

                        //E if !Q.IsReady()
                        if (SKOMenu.Item("UseE").GetValue <bool>() && !Q.IsReady() && E.IsReady() && Player.Distance(target) > Q.Range)
                        {
                            E.Cast(target);
                        }
                    }
                    if (SKOMenu.Item("UseItemsCombo").GetValue <bool>())
                    {
                        if (Player.Distance(target) < Player.AttackRange + 50)
                        {
                            TMT.Cast();
                            HYD.Cast();
                            STD.Cast();
                        }
                        BWC.Cast(target);
                        BRK.Cast(target);
                        RO.Cast(target);
                        YMG.Cast();
                    }
                }
            }
            if (SKOMenu.Item("activeHarass").GetValue <KeyBind>().Active)
            {
                Harass(target);
            }
        }
Пример #28
0
        private static void doCombo()
        {
            try
            {
                // Menu Config
                var FeroSpell = Config.Item("FeroSpellC").GetValue <StringList>();
                var ForceW    = Config.Item("ForceWC").GetValue <Slider>();
                var ForceE    = Config.Item("ForceEC").GetValue <bool>();

                var Target = TargetSelector.GetSelectedTarget() ??
                             TargetSelector.GetTarget(1600f, TargetSelector.DamageType.Physical);

                // Force Leap to target
                if (Player.HasBuff("RengarR", true))
                {
                    LXOrbwalker.ForcedTarget = Target;
                    LXOrbwalker.SetAttack(LXOrbwalker.GetPossibleTarget() == Target);
                }

                // Use Tiamat / Hydra
                if (Target.IsValidTarget(TMT.Range))
                {
                    if (TMT.IsReady())
                    {
                        TMT.Cast();
                    }
                    else if (HYD.IsReady())
                    {
                        HYD.Cast();
                    }
                }

                // Use Yommus Ghostblade
                if (YGB.IsReady() &&
                    Target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player) +
                                         (Player.HasBuff("RengarR", true) ? Player.MoveSpeed / 2 : 0)))
                {
                    YGB.Cast();
                }

                // Cutlass
                if (BCL.IsReady() && Target.IsValidTarget(BCL.Range))
                {
                    BCL.Cast(Target);
                }

                // BORK
                if (BRK.IsReady() && Target.IsValidTarget(BRK.Range))
                {
                    BRK.Cast(Target);
                }

                // Ferocity Spell
                if (Player.Mana == 5)
                {
                    if (Player.Health / Player.MaxHealth < ForceW.Value / 100f && Target.IsValidTarget(W.Range))
                    {
                        W.CastOnUnit(Player, UsePackets);
                        return;
                    }

                    switch (FeroSpell.SelectedIndex)
                    {
                    case 1:
                        if (!Target.IsValidTarget(W.Range))
                        {
                            return;
                        }
                        W.CastOnUnit(Player, UsePackets);
                        break;

                    case 2:
                        if (!Target.IsValidTarget(E.Range) || Player.HasBuff("RengarR", true))
                        {
                            return;
                        }
                        E.Cast(Target, UsePackets);
                        break;
                    }
                    return;
                }

                // Don't cast W or E while ultimate is active (force leap)
                if (Player.HasBuff("RengarR", true))
                {
                    return;
                }

                if (E.IsReady() && Target.IsValidTarget(E.Range) &&
                    (!Target.HasBuff("RengarEFinalMAX", true) && !Target.HasBuff("rengareslow") &&
                     LastETick + 1500 < Environment.TickCount || ForceE))
                {
                    E.Cast(Target, UsePackets);
                }

                if (W.IsReady() && Target.IsValidTarget(W.Range))
                {
                    W.CastOnUnit(Player, UsePackets);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Combo Exception: {0}", e);
            }
        }
Пример #29
0
        public static ThemePropertyType GetPropertyType(TMT property)
        {
            switch (property)
            {
            case TMT.DIBDATA:
                return(ThemePropertyType.HBitmap);

            case TMT.GLYPHDIBDATA:
                return(ThemePropertyType.HBitmap);

            case TMT.ALWAYSSHOWSIZINGBAR:
                return(ThemePropertyType.Bool);

            case TMT.AUTOSIZE:
                return(ThemePropertyType.Bool);

            case TMT.BGFILL:
                return(ThemePropertyType.Bool);

            case TMT.BORDERONLY:
                return(ThemePropertyType.Bool);

            case TMT.COMPOSITED:
                return(ThemePropertyType.Bool);

            case TMT.COMPOSITEDOPAQUE:
                return(ThemePropertyType.Bool);

            case TMT.DRAWBORDERS:
                return(ThemePropertyType.Bool);

            case TMT.FLATMENUS:
                return(ThemePropertyType.Bool);

            case TMT.GLYPHONLY:
                return(ThemePropertyType.Bool);

            case TMT.GLYPHTRANSPARENT:
                return(ThemePropertyType.Bool);

            case TMT.INTEGRALSIZING:
                return(ThemePropertyType.Bool);

            case TMT.LOCALIZEDMIRRORIMAGE:
                return(ThemePropertyType.Bool);

            case TMT.MIRRORIMAGE:
                return(ThemePropertyType.Bool);

            case TMT.NOETCHEDEFFECT:
                return(ThemePropertyType.Bool);

            case TMT.SCALEDBACKGROUND:
                return(ThemePropertyType.Bool);

            case TMT.SOURCEGROW:
                return(ThemePropertyType.Bool);

            case TMT.SOURCESHRINK:
                return(ThemePropertyType.Bool);

            case TMT.TEXTAPPLYOVERLAY:
                return(ThemePropertyType.Bool);

            case TMT.TEXTGLOW:
                return(ThemePropertyType.Bool);

            case TMT.TEXTITALIC:
                return(ThemePropertyType.Bool);

            case TMT.TRANSPARENT:
                return(ThemePropertyType.Bool);

            case TMT.UNIFORMSIZING:
                return(ThemePropertyType.Bool);

            case TMT.USERPICTURE:
                return(ThemePropertyType.Bool);

            case TMT.ACCENTCOLORHINT:
                return(ThemePropertyType.Color);

            case TMT.ACTIVEBORDER:
                return(ThemePropertyType.Color);

            case TMT.ACTIVECAPTION:
                return(ThemePropertyType.Color);

            case TMT.APPWORKSPACE:
                return(ThemePropertyType.Color);

            case TMT.BACKGROUND:
                return(ThemePropertyType.Color);

            case TMT.BLENDCOLOR:
                return(ThemePropertyType.Color);

            case TMT.BODYTEXTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.BORDERCOLOR:
                return(ThemePropertyType.Color);

            case TMT.BORDERCOLORHINT:
                return(ThemePropertyType.Color);

            case TMT.BTNFACE:
                return(ThemePropertyType.Color);

            case TMT.BTNHIGHLIGHT:
                return(ThemePropertyType.Color);

            case TMT.BTNSHADOW:
                return(ThemePropertyType.Color);

            case TMT.BTNTEXT:
                return(ThemePropertyType.Color);

            case TMT.BUTTONALTERNATEFACE:
                return(ThemePropertyType.Color);

            case TMT.CAPTIONTEXT:
                return(ThemePropertyType.Color);

            case TMT.DKSHADOW3D:
                return(ThemePropertyType.Color);

            case TMT.EDGEDKSHADOWCOLOR:
                return(ThemePropertyType.Color);

            case TMT.EDGEFILLCOLOR:
                return(ThemePropertyType.Color);

            case TMT.EDGEHIGHLIGHTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.EDGELIGHTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.EDGESHADOWCOLOR:
                return(ThemePropertyType.Color);

            case TMT.FILLCOLOR:
                return(ThemePropertyType.Color);

            case TMT.FILLCOLORHINT:
                return(ThemePropertyType.Color);

            case TMT.FROMCOLOR1:
                return(ThemePropertyType.Color);

            case TMT.FROMCOLOR2:
                return(ThemePropertyType.Color);

            case TMT.FROMCOLOR3:
                return(ThemePropertyType.Color);

            case TMT.FROMCOLOR4:
                return(ThemePropertyType.Color);

            case TMT.FROMCOLOR5:
                return(ThemePropertyType.Color);

            case TMT.GLOWCOLOR:
                return(ThemePropertyType.Color);

            case TMT.GLYPHTEXTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.GLYPHTRANSPARENTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.GRADIENTACTIVECAPTION:
                return(ThemePropertyType.Color);

            case TMT.GRADIENTCOLOR1:
                return(ThemePropertyType.Color);

            case TMT.GRADIENTCOLOR2:
                return(ThemePropertyType.Color);

            case TMT.GRADIENTCOLOR3:
                return(ThemePropertyType.Color);

            case TMT.GRADIENTCOLOR4:
                return(ThemePropertyType.Color);

            case TMT.GRADIENTCOLOR5:
                return(ThemePropertyType.Color);

            case TMT.GRADIENTINACTIVECAPTION:
                return(ThemePropertyType.Color);

            case TMT.GRAYTEXT:
                return(ThemePropertyType.Color);

            case TMT.HEADING1TEXTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.HEADING2TEXTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.HIGHLIGHT:
                return(ThemePropertyType.Color);

            case TMT.HIGHLIGHTTEXT:
                return(ThemePropertyType.Color);

            case TMT.HOTTRACKING:
                return(ThemePropertyType.Color);

            case TMT.INACTIVEBORDER:
                return(ThemePropertyType.Color);

            case TMT.INACTIVECAPTION:
                return(ThemePropertyType.Color);

            case TMT.INACTIVECAPTIONTEXT:
                return(ThemePropertyType.Color);

            case TMT.INFOBK:
                return(ThemePropertyType.Color);

            case TMT.INFOTEXT:
                return(ThemePropertyType.Color);

            case TMT.LIGHT3D:
                return(ThemePropertyType.Color);

            case TMT.MENU:
                return(ThemePropertyType.Color);

            case TMT.MENUBAR:
                return(ThemePropertyType.Color);

            case TMT.MENUHILIGHT:
                return(ThemePropertyType.Color);

            case TMT.MENUTEXT:
                return(ThemePropertyType.Color);

            case TMT.SCROLLBAR:
                return(ThemePropertyType.Color);

            case TMT.SHADOWCOLOR:
                return(ThemePropertyType.Color);

            case TMT.TEXTBORDERCOLOR:
                return(ThemePropertyType.Color);

            case TMT.TEXTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.TEXTCOLORHINT:
                return(ThemePropertyType.Color);

            case TMT.TEXTSHADOWCOLOR:
                return(ThemePropertyType.Color);

            case TMT.TRANSPARENTCOLOR:
                return(ThemePropertyType.Color);

            case TMT.WINDOW:
                return(ThemePropertyType.Color);

            case TMT.WINDOWFRAME:
                return(ThemePropertyType.Color);

            case TMT.WINDOWTEXT:
                return(ThemePropertyType.Color);

            case TMT.ATLASIMAGE:
                return(ThemePropertyType.DiskStream);

            case TMT.BGTYPE:
                return(ThemePropertyType.Enum);

            case TMT.BORDERTYPE:
                return(ThemePropertyType.Enum);

            case TMT.CONTENTALIGNMENT:
                return(ThemePropertyType.Enum);

            case TMT.FILLTYPE:
                return(ThemePropertyType.Enum);

            case TMT.GLYPHTYPE:
                return(ThemePropertyType.Enum);

            case TMT.GLYPHFONTSIZINGTYPE:
                return(ThemePropertyType.Enum);

            case TMT.HALIGN:
                return(ThemePropertyType.Enum);

            case TMT.ICONEFFECT:
                return(ThemePropertyType.Enum);

            case TMT.IMAGELAYOUT:
                return(ThemePropertyType.Enum);

            case TMT.IMAGESELECTTYPE:
                return(ThemePropertyType.Enum);

            case TMT.OFFSETTYPE:
                return(ThemePropertyType.Enum);

            case TMT.SIZINGTYPE:
                return(ThemePropertyType.Enum);

            case TMT.TEXTSHADOWTYPE:
                return(ThemePropertyType.Enum);

            case TMT.TRUESIZESCALINGTYPE:
                return(ThemePropertyType.Enum);

            case TMT.VALIGN:
                return(ThemePropertyType.Enum);

            case TMT.GLYPHIMAGEFILE:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE1:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE2:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE3:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE4:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE5:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE6:
                return(ThemePropertyType.Filename);

            case TMT.IMAGEFILE7:
                return(ThemePropertyType.Filename);

            case TMT.BODYFONT:
                return(ThemePropertyType.Font);

            case TMT.CAPTIONFONT:
                return(ThemePropertyType.Font);

            case TMT.GLYPHFONT:
                return(ThemePropertyType.Font);

            case TMT.HEADING1FONT:
                return(ThemePropertyType.Font);

            case TMT.HEADING2FONT:
                return(ThemePropertyType.Font);

            case TMT.ICONTITLEFONT:
                return(ThemePropertyType.Font);

            case TMT.MENUFONT:
                return(ThemePropertyType.Font);

            case TMT.MSGBOXFONT:
                return(ThemePropertyType.Font);

            case TMT.SMALLCAPTIONFONT:
                return(ThemePropertyType.Font);

            case TMT.STATUSFONT:
                return(ThemePropertyType.Font);

            case TMT.ALPHALEVEL:
                return(ThemePropertyType.Int);

            case TMT.ALPHATHRESHOLD:
                return(ThemePropertyType.Int);

            case TMT.ANIMATIONDELAY:
                return(ThemePropertyType.Int);

            case TMT.ANIMATIONDURATION:
                return(ThemePropertyType.Int);

            case TMT.BORDERSIZE:
                return(ThemePropertyType.Int);

            case TMT.CHARSET:
                return(ThemePropertyType.Int);

            case TMT.COLORIZATIONCOLOR:
                return(ThemePropertyType.Int);

            case TMT.COLORIZATIONOPACITY:
                return(ThemePropertyType.Int);

            case TMT.FRAMESPERSECOND:
                return(ThemePropertyType.Int);

            case TMT.FROMHUE1:
                return(ThemePropertyType.Int);

            case TMT.FROMHUE2:
                return(ThemePropertyType.Int);

            case TMT.FROMHUE3:
                return(ThemePropertyType.Int);

            case TMT.FROMHUE4:
                return(ThemePropertyType.Int);

            case TMT.FROMHUE5:
                return(ThemePropertyType.Int);

            case TMT.GLOWINTENSITY:
                return(ThemePropertyType.Int);

            case TMT.GLYPHINDEX:
                return(ThemePropertyType.Int);

            case TMT.GRADIENTRATIO1:
                return(ThemePropertyType.Int);

            case TMT.GRADIENTRATIO2:
                return(ThemePropertyType.Int);

            case TMT.GRADIENTRATIO3:
                return(ThemePropertyType.Int);

            case TMT.GRADIENTRATIO4:
                return(ThemePropertyType.Int);

            case TMT.GRADIENTRATIO5:
                return(ThemePropertyType.Int);

            case TMT.HEIGHT:
                return(ThemePropertyType.Int);

            case TMT.IMAGECOUNT:
                return(ThemePropertyType.Int);

            case TMT.MINCOLORDEPTH:
                return(ThemePropertyType.Int);

            case TMT.MINDPI1:
                return(ThemePropertyType.Int);

            case TMT.MINDPI2:
                return(ThemePropertyType.Int);

            case TMT.MINDPI3:
                return(ThemePropertyType.Int);

            case TMT.MINDPI4:
                return(ThemePropertyType.Int);

            case TMT.MINDPI5:
                return(ThemePropertyType.Int);

            case TMT.MINDPI6:
                return(ThemePropertyType.Int);

            case TMT.MINDPI7:
                return(ThemePropertyType.Int);

            case TMT.OPACITY:
                return(ThemePropertyType.Int);

            case TMT.PIXELSPERFRAME:
                return(ThemePropertyType.Int);

            case TMT.PROGRESSCHUNKSIZE:
                return(ThemePropertyType.Int);

            case TMT.PROGRESSSPACESIZE:
                return(ThemePropertyType.Int);

            case TMT.ROUNDCORNERHEIGHT:
                return(ThemePropertyType.Int);

            case TMT.ROUNDCORNERWIDTH:
                return(ThemePropertyType.Int);

            case TMT.SATURATION:
                return(ThemePropertyType.Int);

            case TMT.TEXTBORDERSIZE:
                return(ThemePropertyType.Int);

            case TMT.TEXTGLOWSIZE:
                return(ThemePropertyType.Int);

            case TMT.TOCOLOR1:
                return(ThemePropertyType.Int);

            case TMT.TOCOLOR2:
                return(ThemePropertyType.Int);

            case TMT.TOCOLOR3:
                return(ThemePropertyType.Int);

            case TMT.TOCOLOR4:
                return(ThemePropertyType.Int);

            case TMT.TOCOLOR5:
                return(ThemePropertyType.Int);

            case TMT.TOHUE1:
                return(ThemePropertyType.Int);

            case TMT.TOHUE2:
                return(ThemePropertyType.Int);

            case TMT.TOHUE3:
                return(ThemePropertyType.Int);

            case TMT.TOHUE4:
                return(ThemePropertyType.Int);

            case TMT.TOHUE5:
                return(ThemePropertyType.Int);

            case TMT.TRUESIZESTRETCHMARK:
                return(ThemePropertyType.Int);

            case TMT.WIDTH:
                return(ThemePropertyType.Int);

            case TMT.TRANSITIONDURATIONS:
                return(ThemePropertyType.IntList);

            case TMT.CAPTIONMARGINS:
                return(ThemePropertyType.Margins);

            case TMT.CONTENTMARGINS:
                return(ThemePropertyType.Margins);

            case TMT.SIZINGMARGINS:
                return(ThemePropertyType.Margins);

            case TMT.MINSIZE:
                return(ThemePropertyType.Position);

            case TMT.MINSIZE1:
                return(ThemePropertyType.Position);

            case TMT.MINSIZE2:
                return(ThemePropertyType.Position);

            case TMT.MINSIZE3:
                return(ThemePropertyType.Position);

            case TMT.MINSIZE4:
                return(ThemePropertyType.Position);

            case TMT.MINSIZE5:
                return(ThemePropertyType.Position);

            case TMT.MINSIZE6:
                return(ThemePropertyType.Position);

            case TMT.MINSIZE7:
                return(ThemePropertyType.Position);

            case TMT.NORMALSIZE:
                return(ThemePropertyType.Position);

            case TMT.OFFSET:
                return(ThemePropertyType.Position);

            case TMT.TEXTSHADOWOFFSET:
                return(ThemePropertyType.Position);

            case TMT.ANIMATIONBUTTONRECT:
                return(ThemePropertyType.Rect);

            case TMT.ATLASRECT:
                return(ThemePropertyType.Rect);

            case TMT.CUSTOMSPLITRECT:
                return(ThemePropertyType.Rect);

            case TMT.DEFAULTPANESIZE:
                return(ThemePropertyType.Rect);

            case TMT.CAPTIONBARHEIGHT:
                return(ThemePropertyType.Size);

            case TMT.CAPTIONBARWIDTH:
                return(ThemePropertyType.Size);

            case TMT.MENUBARHEIGHT:
                return(ThemePropertyType.Size);

            case TMT.MENUBARWIDTH:
                return(ThemePropertyType.Size);

            case TMT.PADDEDBORDERWIDTH:
                return(ThemePropertyType.Size);

            case TMT.SCROLLBARHEIGHT:
                return(ThemePropertyType.Size);

            case TMT.SCROLLBARWIDTH:
                return(ThemePropertyType.Size);

            case TMT.SIZINGBORDERWIDTH:
                return(ThemePropertyType.Size);

            case TMT.SMCAPTIONBARHEIGHT:
                return(ThemePropertyType.Size);

            case TMT.SMCAPTIONBARWIDTH:
                return(ThemePropertyType.Size);

            case TMT.ALIAS:
                return(ThemePropertyType.String);

            case TMT.ATLASINPUTIMAGE:
                return(ThemePropertyType.String);

            case TMT.AUTHOR:
                return(ThemePropertyType.String);

            case TMT.CLASSICVALUE:
                return(ThemePropertyType.String);

            case TMT.COLORSCHEMES:
                return(ThemePropertyType.String);

            case TMT.COMPANY:
                return(ThemePropertyType.String);

            case TMT.COPYRIGHT:
                return(ThemePropertyType.String);

            case TMT.CSSNAME:
                return(ThemePropertyType.String);

            case TMT.DESCRIPTION:
                return(ThemePropertyType.String);

            case TMT.DISPLAYNAME:
                return(ThemePropertyType.String);

            case TMT.LASTUPDATED:
                return(ThemePropertyType.String);

            case TMT.SIZES:
                return(ThemePropertyType.String);

            case TMT.TEXT:
                return(ThemePropertyType.String);

            case TMT.TOOLTIP:
                return(ThemePropertyType.String);

            case TMT.URL:
                return(ThemePropertyType.String);

            case TMT.VERSION:
                return(ThemePropertyType.String);

            case TMT.XMLNAME:
                return(ThemePropertyType.String);

            case TMT.NAME:
                return(ThemePropertyType.String);

            case TMT.ENUM:
                return(ThemePropertyType.Enum);

            case TMT.STRING:
                return(ThemePropertyType.String);

            case TMT.INT:
                return(ThemePropertyType.Int);

            case TMT.BOOL:
                return(ThemePropertyType.Bool);

            case TMT.COLOR:
                return(ThemePropertyType.Color);

            case TMT.MARGINS:
                return(ThemePropertyType.Margins);

            case TMT.FILENAME:
                return(ThemePropertyType.Filename);

            case TMT.SIZE:
                return(ThemePropertyType.Size);

            case TMT.POSITION:
                return(ThemePropertyType.Position);

            case TMT.RECT:
                return(ThemePropertyType.Rect);

            case TMT.FONT:
                return(ThemePropertyType.Font);

            case TMT.INTLIST:
                return(ThemePropertyType.IntList);

            case TMT.HBITMAP:
                return(ThemePropertyType.HBitmap);

            case TMT.DISKSTREAM:
                return(ThemePropertyType.DiskStream);

            case TMT.STREAM:
                return(ThemePropertyType.Stream);

            case TMT.BITMAPREF:
                return(ThemePropertyType.BitmapRef);

            case TMT.FLOAT:
                return(ThemePropertyType.Float);

            case TMT.FLOATLIST:
                return(ThemePropertyType.FloatList);

            case TMT.SIMPLIFIEDIMAGETYPE:
                return(ThemePropertyType.SimplifiedImage);

            case TMT.HCCOLOR:
                return(ThemePropertyType.Int);

            case TMT.RESERVEDLOW:
            case TMT.RESERVEDHIGH:
            default:
                return(ThemePropertyType.None);
            }
        }
Пример #30
0
        private static void doCombo()
        {
            var useW = Config.Item("combo_W").GetValue <bool>();
            var useE = Config.Item("combo_E").GetValue <bool>();
            var useR = Config.Item("combo_R").GetValue <bool>();
            var useI = Config.Item("combo_IGN").GetValue <bool>();

            var useGB  = Config.Item("item_GB").GetValue <bool>();
            var useTMT = Config.Item("item_TMT").GetValue <bool>();
            var useHYD = Config.Item("item_HYD").GetValue <bool>();

            var useRush = Config.Item("combo_RUSH").GetValue <bool>();
            var useWE   = Config.Item("combo_WE").GetValue <bool>();

            var Target = LockedTarget ?? TargetSelector.GetTarget(1500f, TargetSelector.DamageType.Physical);

            // Ultimate Rush
            if (UltimateRush(Target) && useRush)
            {
                LockedTarget = Target;
                R.Cast();
            }

            // Items
            if (TMT.IsReady() && Target.IsValidTarget(TMT.Range) && useTMT)
            {
                TMT.Cast();
            }

            if (HYD.IsReady() && Target.IsValidTarget(HYD.Range) && useHYD)
            {
                HYD.Cast();
            }

            if (GB.IsReady() && Target.IsValidTarget(LXOrbwalker.GetAutoAttackRange(Player) + (Player.MoveSpeed / 2)) &&
                useGB)
            {
                GB.Cast();
            }

            // Spells
            if (W.IsReady() && useWE && useW && Target.IsValidTarget(W.Range) && !Player.HasBuff("TalonDisappear"))
            {
                W.Cast(Target);
            }
            else if (E.IsReady() && Target.IsValidTarget(E.Range) && useE)
            {
                E.CastOnUnit(Target);
            }
            else if (W.IsReady() && Target.IsValidTarget(W.Range) && useW)
            {
                W.Cast(Target.Position);
            }
            else if (R.IsReady() && Target.IsValidTarget(R.Range) && useR && R.GetDamage(Target) > Target.Health)
            {
                R.Cast();
            }

            // Auto Ignite
            if (!useI || Ignite == SpellSlot.Unknown || Player.Spellbook.CanUseSpell(Ignite) != SpellState.Ready)
            {
                return;
            }

            foreach (
                var enemy in
                ObjectManager.Get <Obj_AI_Hero>()
                .Where(
                    hero =>
                    hero.IsEnemy && hero.IsValidTarget(600f) && !hero.IsDead &&
                    hero.Health < Player.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite))
                .OrderByDescending(TargetSelector.GetPriority))
            {
                Player.Spellbook.CastSpell(Ignite, enemy);
                return;
            }
        }