Пример #1
0
        private static float GetComboDamage(Obj_AI_Base enemy)
        {
            try
            {
                float damage = 0;

                if (!Orbwalker.IsAutoAttacking)
                {
                    damage += Player.GetAutoAttackDamage(enemy, true);
                }

                if (IgniteSpell.IsReady() && IgniteSpell.Slot != SpellSlot.Unknown)
                {
                    damage += (float)Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
                }

                if (Hydra.IsReady())
                {
                    damage += (float)Player.GetItemDamage(enemy, Damage.DamageItems.Hydra);
                }

                if (Tiamat.IsReady())
                {
                    damage += (float)Player.GetItemDamage(enemy, Damage.DamageItems.Tiamat);
                }

                if (Youmuu.IsReady())
                {
                    damage += Player.GetAutoAttackDamage(enemy, true) * 2;
                }

                if (Q.IsReady())
                {
                    damage += Q.GetDamage(enemy);
                }

                if (E.IsReady())
                {
                    damage += E.GetDamage(enemy);
                }

                if (W.IsReady())
                {
                    damage += W.GetDamage(enemy);
                }

                if (R.IsReady())
                {
                    damage += R.GetDamage(enemy);
                }

                return(damage);
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
            }

            return(0);
        }
Пример #2
0
        /// <summary>
        ///     Combo logic
        /// </summary>
        private static void OnCombo()
        {
            var target = TargetSelector.GetTarget(Q.Range, DamageType.Magical);

            if (target == null)
            {
                return;
            }

            if (getCheckBoxItem(comboMenu, "ElZilean.Combo.E") && E.IsReady())
            {
                if (Player.GetEnemiesInRange(E.Range).Any())
                {
                    var closestEnemy =
                        Player.GetEnemiesInRange(E.Range)
                        .OrderByDescending(h => (h.PhysicalDamageDealtPlayer + h.MagicDamageDealtPlayer))
                        .FirstOrDefault();

                    if (closestEnemy == null)
                    {
                        return;
                    }

                    if (closestEnemy.HasBuffOfType(BuffType.Stun))
                    {
                        return;
                    }

                    E.Cast(closestEnemy);
                }

                if (Player.GetAlliesInRange(E.Range).Any() && Player.GetEnemiesInRange(800f).Count >= 1)
                {
                    var closestToTarget =
                        Player.GetAlliesInRange(E.Range)
                        .OrderByDescending(h => (h.PhysicalDamageDealtPlayer + h.MagicDamageDealtPlayer))
                        .FirstOrDefault();

                    E.Cast(closestToTarget);
                }
            }

            if (getCheckBoxItem(comboMenu, "ElZilean.Combo.Q") && Q.IsReady() && target.LSIsValidTarget(Q.Range) && !target.IsZombie)
            {
                var pred = Q.GetPrediction(target);
                if (pred.Hitchance >= HitChance.VeryHigh)
                {
                    Q.Cast(pred.CastPosition);
                }
            }

            // Check if target has a bomb
            var isBombed = HeroManager.Enemies.Find(x => x.HasBuff("ZileanQEnemyBomb") && x.LSIsValidTarget(Q.Range));

            if (!isBombed.LSIsValidTarget())
            {
                return;
            }

            if (isBombed != null && isBombed.LSIsValidTarget(Q.Range))
            {
                if (Q.Instance.CooldownExpires - Game.Time < 3)
                {
                    return;
                }

                if (getCheckBoxItem(comboMenu, "ElZilean.Combo.W"))
                {
                    W.Cast();
                }
            }

            if (getCheckBoxItem(comboMenu, "ElZilean.Combo.W") && getCheckBoxItem(comboMenu, "ElZilean.Combo.W2") && W.IsReady() && !Q.IsReady())
            {
                if (Q.Instance.CooldownExpires - Game.Time < 3 ||
                    HeroManager.Enemies.Any(x => x.Health > Q.GetDamage(x) && x.LSIsValidTarget(Q.Range)))
                {
                    return;
                }

                W.Cast();
            }

            if (getCheckBoxItem(comboMenu, "ElZilean.Ignite") && isBombed != null)
            {
                if (Player.GetSpellSlot("summonerdot") == SpellSlot.Unknown)
                {
                    return;
                }

                if (Q.GetDamage(isBombed) + IgniteSpell.GetDamage(isBombed) > isBombed.Health)
                {
                    if (isBombed.LSIsValidTarget(Q.Range))
                    {
                        Player.Spellbook.CastSpell(IgniteSpell.Slot, isBombed);
                    }
                }
            }
        }
Пример #3
0
        /// <summary>
        ///     Combo logic
        /// </summary>
        private static void OnCombo()
        {
            try
            {
                var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
                if (target == null)
                {
                    return;
                }

                if (IsActive("ElFizz.Combo.R.SingleKill") && R.IsReady())
                {
                    if (Qkillable(target))
                    {
                        Q.Cast(target);
                    }

                    RLogicKill();
                }

                if (IsActive("ElFizz.Combo.Gapclose.E") &&
                    Player.ManaPercent < Menu.Item("ElFizz.Combo.Gapclose.E.Mana").GetValue <Slider>().Value)
                {
                    if (target.Distance(Player) > Q.Range && Q.GetDamage(target) > target.Health)
                    {
                        E.Cast(target.Position);
                    }
                }

                switch (Menu.Item("ElFizz.Combo.Type").GetValue <StringList>().SelectedIndex)
                {
                case 0:
                    if (IsActive("ElFizz.Combo.Q") && Q.IsReady() && target.IsValidTarget(Q.Range))
                    {
                        if (Q.Cast(target).IsCasted())
                        {
                            if (E.IsReady())
                            {
                                E.Cast(target);
                            }
                        }

                        if (R.IsReady())
                        {
                            RCastLogic(target);
                        }
                    }
                    break;

                case 1:
                    if (R.IsReady())
                    {
                        RCastLogic(target);
                    }

                    if (Q.Cast(target).IsCasted())
                    {
                        if (E.IsReady())
                        {
                            E.Cast(target);
                        }
                    }
                    break;
                }


                if (IsActive("ElFizz.Combo.Q") && Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    Q.Cast(target);
                }

                if (IsActive("ElFizz.Combo.Q") && IsActive("ElFizz.Ignite") && IgniteSpell.Slot != SpellSlot.Unknown)
                {
                    if (Q.GetDamage(target) + IgniteSpell.GetDamage(target) > target.Health)
                    {
                        if (target.IsValidTarget(Q.Range))
                        {
                            if (Q.Cast(target).IsCasted())
                            {
                                Player.Spellbook.CastSpell(IgniteSpell.Slot, target);
                            }
                        }
                    }
                }

                if (IsActive("ElFizz.Combo.W") && W.IsReady() && !Q.IsReady() && !E.IsReady() &&
                    target.IsValidTarget(W.Range))
                {
                    W.Cast(target);
                }

                if (IsActive("ElFizz.Combo.E") && E.IsReady() && target.IsValidTarget(E.Range) &&
                    E.Instance.Name.ToLower() == "fizzjump")
                {
                    if (Prediction.GetPrediction(target, 0.5f).UnitPosition.Distance(Player.Position) <= E.Range + 450)
                    {
                        E.Cast(GetEPosition(target));
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
Пример #4
0
        /// <summary>
        ///     Combo logic
        /// </summary>
        private static void OnCombo()
        {
            {
                var target = TargetSelector.GetTarget(Q.Range, DamageType.Magical);
                if (target == null || target.IsDead)
                {
                    return;
                }
                var isBombed2 = HeroManager.Enemies.Find(x => x.HasBuff("ZileanQEnemyBomb") && x.IsValidTarget(Q.Range));
                if (getCheckBoxItem(comboMenu, "ElZilean.Combo.Q") && Q.IsReady() && target.IsValidTarget(Q.Range) && !isBombed2.IsValidTarget(Q.Range))
                {
                    var pred = Q.GetPrediction(target);
                    if (QDmg(target) >= target.Health + target.HPRegenRate && pred.HitChance >= EloBuddy.SDK.Enumerations.HitChance.Low && !isBombed2.IsValidTarget())
                    {
                        Q.Cast(target);
                    }
                    if (pred.HitChance >= EloBuddy.SDK.Enumerations.HitChance.Medium && !isBombed2.IsValidTarget())
                    {
                        Q.Cast(target);
                    }
                }
                if (getCheckBoxItem(comboMenu, "ElZilean.Combo.Q") && Q.IsReady() && isBombed2.IsValidTarget(Q.Range) && isBombed2.IsValidTarget())
                {
                    var pred = Q.GetPrediction(isBombed2);
                    if (pred.HitChance >= EloBuddy.SDK.Enumerations.HitChance.Medium)
                    {
                        Utility.DelayAction.Add(50, () => Q.Cast(isBombed2));
                    }
                }
                if (!Q.IsReady())
                {
                    if (QDmg(target) >= target.Health + target.HPRegenRate && W.IsReady())
                    {
                        if (E.IsReady())
                        {
                            E.Cast();
                        }
                        W.Cast();
                    }
                }
                // Check if target has a bomb
                var isBombed = HeroManager.Enemies.Find(x => x.HasBuff("ZileanQEnemyBomb") && x.IsValidTarget(Q.Range));
                if (!isBombed.IsValidTarget())
                {
                    return;
                }

                if (isBombed != null && isBombed.IsValidTarget(Q.Range))
                {
                    if (Q.IsReady())
                    {
                        return;
                    }

                    if (getCheckBoxItem(comboMenu, "ElZilean.Combo.W"))
                    {
                        W.Cast();
                    }
                }

                if (getCheckBoxItem(comboMenu, "ElZilean.Combo.W") && getCheckBoxItem(comboMenu, "ElZilean.Combo.W2") && W.IsReady() && !Q.IsReady())
                {
                    if (!Q.IsReady())
                    {
                        W.Cast();
                    }
                }

                if (getCheckBoxItem(comboMenu, "ElZilean.Combo.E") && E.IsReady())
                {
                    if (Player.GetEnemiesInRange(E.Range).Any())
                    {
                        var closestEnemy =
                            Player.GetEnemiesInRange(E.Range)
                            .OrderByDescending(h => (h.PhysicalDamageDealtPlayer + h.MagicDamageDealtPlayer))
                            .FirstOrDefault();

                        if (closestEnemy == null || closestEnemy.HasBuffOfType(BuffType.Stun))
                        {
                            return;
                        }

                        E.Cast(closestEnemy);
                    }
                }

                if (getCheckBoxItem(comboMenu, "ElZilean.Ignite") && isBombed != null)
                {
                    if (Player.GetSpellSlot("summonerdot") == SpellSlot.Unknown)
                    {
                        return;
                    }

                    if (QDmg(isBombed) + IgniteSpell.GetDamage(isBombed) > isBombed.Health)
                    {
                        if (isBombed.IsValidTarget(Q.Range))
                        {
                            Player.Spellbook.CastSpell(IgniteSpell.Slot, isBombed);
                        }
                    }
                }
            }
        }
Пример #5
0
        /// <summary>
        ///     Combo logic
        /// </summary>
        private static void OnCombo()
        {
            var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }

            if (IsActive("ElZilean.Combo.Q"))
            {
                QCast(target);
            }

            // Check if target has a bomb
            var isBombed = HeroManager.Enemies.Find(x => x.HasBuff("ZileanQEnemyBomb") && x.IsValidTarget(Q.Range));

            if (!isBombed.IsValidTarget())
            {
                return;
            }

            if (isBombed != null && isBombed.IsValidTarget(Q.Range))
            {
                if (Q.Instance.CooldownExpires - Game.Time < 3)
                {
                    return;
                }

                TargetSelector.SetTarget(isBombed);
                Orbwalker.ForceTarget(isBombed);

                if (IsActive("ElZilean.Combo.W"))
                {
                    W.Cast();
                }
            }

            if (IsActive("ElZilean.Combo.W") && IsActive("ElZilean.Combo.W2") && W.IsReady() && !Q.IsReady())
            {
                if (HeroManager.Enemies.Any(x => x.Health > Q.GetDamage(x) && x.IsValidTarget(Q.Range)))
                {
                    return;
                }

                W.Cast();
            }

            if (IsActive("ElZilean.Combo.E") && E.IsReady())
            {
                if (Player.GetEnemiesInRange(E.Range).Any())
                {
                    var closestEnemy =
                        Player.GetEnemiesInRange(E.Range)
                        .OrderByDescending(h => (h.PhysicalDamageDealtPlayer + h.MagicDamageDealtPlayer))
                        .FirstOrDefault();

                    if (closestEnemy == null || closestEnemy.HasBuffOfType(BuffType.Stun))
                    {
                        return;
                    }

                    E.Cast(closestEnemy);
                }
            }

            if (IsActive("ElZilean.Ignite") && isBombed != null)
            {
                if (Player.GetSpellSlot("summonerdot") == SpellSlot.Unknown)
                {
                    return;
                }

                if (Q.GetDamage(isBombed) + IgniteSpell.GetDamage(isBombed) > isBombed.Health)
                {
                    if (isBombed.IsValidTarget(Q.Range))
                    {
                        Player.Spellbook.CastSpell(IgniteSpell.Slot, isBombed);
                    }
                }
            }
        }