コード例 #1
0
ファイル: Program.cs プロジェクト: nongnoobjung/PortAIO
        private static void Combo()
        {
            var target = TargetSelector.GetTarget(E.Range, DamageType.Physical);

            if (target == null)
            {
                return;
            }
            var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            var hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (getCheckBoxItem(comboMenu, "useIgnite") &&
                ignitedmg > target.Health - IncDamages.GetEnemyData(target.NetworkId).DamageTaken&& hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) && !Q.IsReady() && !justQ)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (getSliderItem(comboMenu, "usew") > player.HealthPercent &&
                player.CountEnemiesInRange(500) > 0)
            {
                W.Cast();
            }
            if (R.IsReady() && getCheckBoxItem(comboMenu, "user"))
            {
                var Rtarget =
                    HeroManager.Enemies.FirstOrDefault(e => e.HealthPercent < 50 && e.CountAlliesInRange(660) > 0);
                if (Rtarget != null)
                {
                    R.CastIfWillHit(Rtarget, getSliderItem(comboMenu, "Rmin"));
                }
            }
            var dontQ   = false;
            var barrels =
                GetBarrels()
                .Where(
                    o =>
                    o.IsValid && !o.IsDead && o.LSDistance(player) < 1600 && o.BaseSkinName == "GangplankBarrel" &&
                    o.GetBuff("gangplankebarrellife").Caster.IsMe)
                .ToList();

            if (getCheckBoxItem(comboMenu, "useq") && Q.IsReady() && getCheckBoxItem(comboMenu, "usee") &&
                E.IsReady() && !justE)
            {
                var pred = Prediction.GetPrediction(target, 0.5f);
                if (pred.Hitchance >= HitChance.High)
                {
                    var Qbarrels = GetBarrels().Where(o => o.LSDistance(player) < Q.Range && KillableBarrel(o));
                    foreach (var Qbarrel in Qbarrels.OrderByDescending(b => b.LSDistance(target) < BarrelExplosionRange))
                    {
                        var targPred = Prediction.GetPrediction(target, GetQTime(Qbarrel));
                        if (Qbarrel.LSDistance(targPred.UnitPosition) < BarrelExplosionRange)
                        {
                            if (getCheckBoxItem(comboMenu, "useeAOE") && barrels.Count < 2)
                            {
                                var enemies =
                                    HeroManager.Enemies.Where(
                                        e => e.LSDistance(player) < 1600 && e.LSDistance(Qbarrel) > BarrelExplosionRange)
                                    .Select(e => Prediction.GetPrediction(e, 05f));
                                var pos =
                                    GetBarrelPoints(Qbarrel.Position)
                                    .Where(p => p.LSDistance(Qbarrel.Position) < BarrelConnectionRange)
                                    .OrderByDescending(
                                        p => enemies.Count(e => e.UnitPosition.LSDistance(p) < BarrelExplosionRange))
                                    .ThenBy(p => p.LSDistance(target.Position))
                                    .FirstOrDefault();
                                if (pos.IsValid() && pos.CountEnemiesInRange(BarrelExplosionRange) > 0 &&
                                    enemies.Count(e => e.UnitPosition.LSDistance(pos) < BarrelExplosionRange) > 0)
                                {
                                    dontQ = true;
                                    E.Cast(pos);
                                }
                            }
                            break;
                        }
                        var point =
                            GetBarrelPoints(Qbarrel.Position)
                            .Where(
                                p =>
                                p.IsValid() && !p.IsWall() && p.LSDistance(player.Position) < E.Range &&
                                target.LSDistance(p) < BarrelExplosionRange &&
                                p.LSDistance(targPred.UnitPosition) < BarrelExplosionRange &&
                                Qbarrel.LSDistance(p) < BarrelConnectionRange &&
                                savedBarrels.Count(b => b.barrel.Position.LSDistance(p) < BarrelExplosionRange) <
                                1)
                            .OrderBy(p => p.LSDistance(pred.UnitPosition))
                            .FirstOrDefault();
                        if (point.IsValid())
                        {
                            dontQ = true;
                            E.Cast(point);
                            Utility.DelayAction.Add(1, () => Q.CastOnUnit(Qbarrel));
                            return;
                        }
                    }
                }
            }
            var meleeRangeBarrel =
                barrels.FirstOrDefault(
                    b =>
                    (b.Health < 2 || (b.Health == 2 && !KillableBarrel(b, true) && Q.IsReady() && !justQ)) &&
                    KillableBarrel(b, true) && b.LSDistance(player) < Orbwalking.GetRealAutoAttackRange(b));
            var secondb =
                barrels.Where(
                    b =>
                    b.LSDistance(meleeRangeBarrel) < BarrelConnectionRange &&
                    HeroManager.Enemies.Count(
                        o =>
                        o.LSIsValidTarget() && o.LSDistance(b) < BarrelExplosionRange &&
                        b.LSDistance(Prediction.GetPrediction(o, 500).UnitPosition) < BarrelExplosionRange) > 0);

            if (meleeRangeBarrel != null &&
                ((HeroManager.Enemies.Count(
                      o =>
                      o.LSIsValidTarget() && o.LSDistance(meleeRangeBarrel) < BarrelExplosionRange &&
                      meleeRangeBarrel.LSDistance(Prediction.GetPrediction(o, 500).UnitPosition) < BarrelExplosionRange) >
                  0) || secondb != null) && !Q.IsReady() && !justQ && Orbwalker.CanAutoAttack)
            {
                Orbwalker.DisableAttacking = true;
                Player.IssueOrder(GameObjectOrder.AttackUnit, meleeRangeBarrel);
            }
            if (Q.IsReady())
            {
                if (barrels.Any())
                {
                    var detoneateTargetBarrels = barrels.Where(b => b.LSDistance(player) < Q.Range);
                    if (getCheckBoxItem(comboMenu, "detoneateTarget"))
                    {
                        if (detoneateTargetBarrels.Any())
                        {
                            foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                            {
                                if (!KillableBarrel(detoneateTargetBarrel))
                                {
                                    continue;
                                }
                                if (
                                    detoneateTargetBarrel.LSDistance(
                                        Prediction.GetPrediction(target, GetQTime(detoneateTargetBarrel)).UnitPosition) <
                                    BarrelExplosionRange &&
                                    target.LSDistance(detoneateTargetBarrel.Position) < BarrelExplosionRange)
                                {
                                    dontQ = true;
                                    Q.CastOnUnit(detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                    return;
                                }
                                var detoneateTargetBarrelSeconds =
                                    barrels.Where(b => b.LSDistance(detoneateTargetBarrel) < BarrelConnectionRange);
                                if (detoneateTargetBarrelSeconds.Any())
                                {
                                    if (detoneateTargetBarrelSeconds.Any(detoneateTargetBarrelSecond => detoneateTargetBarrelSecond.LSDistance(
                                                                             Prediction.GetPrediction(
                                                                                 target, GetQTime(detoneateTargetBarrel) + 0.15f).UnitPosition) <
                                                                         BarrelExplosionRange &&
                                                                         target.LSDistance(detoneateTargetBarrelSecond.Position) < BarrelExplosionRange))
                                    {
                                        dontQ = true;
                                        Q.CastOnUnit(detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                        return;
                                    }
                                }
                            }
                        }

                        if (getSliderItem(comboMenu, "detoneateTargets") > 1)
                        {
                            var enemies =
                                HeroManager.Enemies.Where(e => e.LSIsValidTarget() && e.LSDistance(player) < 600)
                                .Select(e => Prediction.GetPrediction(e, 0.25f));
                            var enemies2 =
                                HeroManager.Enemies.Where(e => e.LSIsValidTarget() && e.LSDistance(player) < 600)
                                .Select(e => Prediction.GetPrediction(e, 0.35f));
                            if (detoneateTargetBarrels.Any())
                            {
                                foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                                {
                                    if (!KillableBarrel(detoneateTargetBarrel))
                                    {
                                        continue;
                                    }
                                    var enemyCount =
                                        enemies.Count(
                                            e =>
                                            e.UnitPosition.LSDistance(detoneateTargetBarrel.Position) <
                                            BarrelExplosionRange);
                                    if (enemyCount >= getSliderItem(comboMenu, "detoneateTargets") &&
                                        detoneateTargetBarrel.CountEnemiesInRange(BarrelExplosionRange) >=
                                        getSliderItem(comboMenu, "detoneateTargets"))
                                    {
                                        dontQ = true;
                                        Q.CastOnUnit(detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                        return;
                                    }
                                    var detoneateTargetBarrelSeconds =
                                        barrels.Where(b => b.LSDistance(detoneateTargetBarrel) < BarrelConnectionRange);
                                    if (detoneateTargetBarrelSeconds.Any())
                                    {
                                        if (detoneateTargetBarrelSeconds.Any(detoneateTargetBarrelSecond => enemyCount +
                                                                             enemies2.Count(
                                                                                 e =>
                                                                                 e.UnitPosition.LSDistance(detoneateTargetBarrelSecond.Position) <
                                                                                 BarrelExplosionRange) >=
                                                                             getSliderItem(comboMenu, "detoneateTargets") &&
                                                                             detoneateTargetBarrelSecond.CountEnemiesInRange(BarrelExplosionRange) >=
                                                                             getSliderItem(comboMenu, "detoneateTargets")))
                                        {
                                            dontQ = true;
                                            Q.CastOnUnit(
                                                detoneateTargetBarrel, getCheckBoxItem(config, "packets"));
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (getCheckBoxItem(comboMenu, "useeAlways") && E.IsReady() && player.LSDistance(target) < E.Range &&
                    !justE && target.Health > Q.GetDamage(target) + player.GetAutoAttackDamage(target) &&
                    getSliderItem(comboMenu, "eStacksC") < E.Instance.Ammo)
                {
                    CastE(target, barrels);
                }
                var Qbarrels = GetBarrels().FirstOrDefault(o => o.LSDistance(player) < Q.Range);
                if (Qbarrels != null && E.Instance.Ammo > 0 && Q.IsReady() && getCheckBoxItem(comboMenu, "usee") &&
                    target.Health > Q.GetDamage(target))
                {
                    dontQ = true;
                }
                if (getCheckBoxItem(comboMenu, "useq") && Q.CanCast(target) && !justE &&
                    !dontQ)
                {
                    CastQonHero(target, barrels);
                }
            }
        }
コード例 #2
0
        private static void Combo()
        {
            AIHeroClient target = TargetSelector.GetTarget(E.Range, DamageType.Physical);

            if (target == null)
            {
                return;
            }
            if (GameObjects.Player.HealthPercent < mainMenu["Combo"].GetValue <MenuSlider>("wBelow").Value&& mainMenu["Combo"].GetValue <MenuBool>("Wuse").Enabled &&
                GameObjects.Player.CountEnemyHeroesInRange(500) > 0)
            {
                W.Cast();
            }
            //if (R.IsReady()&& mainMenu["Combo"].GetValue<MenuBool>("Ruse").Enabled)
            //{
            //    var Rtarget =
            //        GameObjects.EnemyHeroes.FirstOrDefault(e => e.HealthPercent < 50 && e.CountAllyHeroesInRange(660) > 0);
            //    if (Rtarget != null)
            //    {
            //        R.CastIfWillHit(Rtarget, 2);
            //    }
            //}
            var barrels =
                GetBarrels()
                .Where(
                    o =>
                    o.IsValid && !o.IsDead && o.Distance(GameObjects.Player) < 1600 && o.SkinName == "GangplankBarrel" &&
                    o.GetBuff("gangplankebarrellife").Caster.IsMe)
                .ToList();

            if (Q.IsReady() &&
                E.IsReady())
            {
                var Qbarrels = GetBarrels().Where(o => o.Distance(GameObjects.Player) < Q.Range && KillableBarrel(o));
                foreach (var Qbarrel in Qbarrels)
                {
                    if (Qbarrel.Distance(target) < BarrelExplosionRange)
                    {
                        continue;
                    }
                    var point =
                        GetBarrelPoints(Qbarrel.Position)
                        .Where(
                            p =>
                            p.IsValid() && !p.IsWall() && p.Distance(GameObjects.Player.Position) < E.Range &&
                            p.Distance(Prediction.GetPrediction(target, GetQTime(Qbarrel)).UnitPosition) <
                            BarrelExplosionRange && savedBarrels.Count(b => b.barrel.Position.Distance(p) < BarrelExplosionRange) < 1)
                        .OrderBy(p => p.Distance(target.Position))
                        .FirstOrDefault();
                    if (point != null && !justE)
                    {
                        E.Cast(point);
                        DelayAction.Add(1, () => Q.CastOnUnit(Qbarrel));
                        return;
                    }
                }
            }

            var minBarrel = mainMenu["Combo"].GetValue <MenuSlider>("minBarrel").Value;

            if (E.IsReady() && GameObjects.Player.Distance(target) < E.Range &&
                target.Health > Q.GetDamage(target) + GameObjects.Player.GetAutoAttackDamage(target) && Orbwalker.CanMove() &&
                minBarrel < E.Instance.Ammo)
            {
                CastE(target, barrels);
            }


            var meleeRangeBarrel =
                barrels.FirstOrDefault(
                    b =>
                    b.Health < 2 && b.Distance(GameObjects.Player) < GameObjects.Player.GetRealAutoAttackRange(b) &&
                    b.CountEnemyHeroesInRange(BarrelExplosionRange) > 0);

            if (meleeRangeBarrel != null)
            {
                Orbwalker.ForceTarget = meleeRangeBarrel;
            }
            if (Q.IsReady())
            {
                if (barrels.Any())
                {
                    var detoneateTargetBarrels = barrels.Where(b => b.Distance(GameObjects.Player) < Q.Range);

                    if (detoneateTargetBarrels.Any())
                    {
                        foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                        {
                            if (!KillableBarrel(detoneateTargetBarrel))
                            {
                                continue;
                            }
                            if (
                                detoneateTargetBarrel.Distance(
                                    Prediction.GetPrediction(target, GetQTime(detoneateTargetBarrel)).UnitPosition) <
                                BarrelExplosionRange &&
                                target.Distance(detoneateTargetBarrel.Position) < BarrelExplosionRange)
                            {
                                Q.CastOnUnit(detoneateTargetBarrel);
                                return;
                            }
                            var detoneateTargetBarrelSeconds =
                                barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
                            if (detoneateTargetBarrelSeconds.Any())
                            {
                                foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                {
                                    if (
                                        detoneateTargetBarrelSecond.Distance(
                                            Prediction.GetPrediction(
                                                target, GetQTime(detoneateTargetBarrel) + 0.15f).UnitPosition) <
                                        BarrelExplosionRange &&
                                        target.Distance(detoneateTargetBarrelSecond.Position) < BarrelExplosionRange)
                                    {
                                        Q.CastOnUnit(detoneateTargetBarrel);
                                        return;
                                    }
                                }
                            }
                        }
                    }

                    if (2 > 1)
                    {
                        var enemies =
                            GameObjects.EnemyHeroes.Where(e => e.IsValidTarget() && e.Distance(GameObjects.Player) < 600)
                            .Select(e => Prediction.GetPrediction(e, 0.25f));
                        var enemies2 =
                            GameObjects.EnemyHeroes.Where(e => e.IsValidTarget() && e.Distance(GameObjects.Player) < 600)
                            .Select(e => Prediction.GetPrediction(e, 0.35f));
                        if (detoneateTargetBarrels.Any())
                        {
                            foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                            {
                                if (!KillableBarrel(detoneateTargetBarrel))
                                {
                                    continue;
                                }
                                var enemyCount =
                                    enemies.Count(
                                        e =>
                                        e.UnitPosition.Distance(detoneateTargetBarrel.Position) <
                                        BarrelExplosionRange);
                                if (enemyCount >= 1 &&
                                    detoneateTargetBarrel.CountEnemyHeroesInRange(BarrelExplosionRange) >=
                                    1)
                                {
                                    Q.CastOnUnit(detoneateTargetBarrel);
                                    return;
                                }
                                var detoneateTargetBarrelSeconds =
                                    barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
                                if (detoneateTargetBarrelSeconds.Any())
                                {
                                    foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                    {
                                        if (enemyCount +
                                            enemies2.Count(
                                                e =>
                                                e.UnitPosition.Distance(detoneateTargetBarrelSecond.Position) <
                                                BarrelExplosionRange) >=
                                            1 &&
                                            detoneateTargetBarrelSecond.CountEnemyHeroesInRange(BarrelExplosionRange) >=
                                            1)
                                        {
                                            Q.CastOnUnit(
                                                detoneateTargetBarrel);
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (Q.CanCast(target))
                {
                    CastQonHero(target, barrels);
                }
            }
        }
コード例 #3
0
ファイル: Gangplank.cs プロジェクト: Pokerkoffer/HesaElobuddy
        private void Combo()
        {
            AIHeroClient target = ARAMTargetSelector.getBestTarget(
                E.Range);

            if (target == null)
            {
                return;
            }

            if (40 < player.HealthPercent &&
                player.CountEnemiesInRange(500) > 0)
            {
                W.Cast();
            }
            if (R.IsReady())
            {
                var Rtarget =
                    EntityManager.Enemies.FirstOrDefault(e => e.HealthPercent < 50 && e.CountAlliesInRange(660) > 0);
                if (Rtarget != null)
                {
                    R.CastIfWillHit(Rtarget, 2);
                }
            }
            var barrels =
                GetBarrels()
                .Where(
                    o =>
                    o.IsValid && !o.IsDead && o.Distance(player) < 1600 && o.BaseSkinName == "GangplankBarrel" &&
                    o.GetBuff("gangplankebarrellife").Caster.IsMe)
                .ToList();

            if (Q.IsReady() &&
                E.IsReady())
            {
                var Qbarrels = GetBarrels().Where(o => o.Distance(player) < Q.Range && KillableBarrel(o));
                foreach (var Qbarrel in Qbarrels)
                {
                    if (Qbarrel.Distance(target) < BarrelExplosionRange)
                    {
                        continue;
                    }
                    var point =
                        GetBarrelPoints(Qbarrel.Position)
                        .Where(
                            p =>
                            p.IsValid() && !p.IsWall() && p.Distance(player.Position) < E.Range &&
                            p.Distance(Q.GetPrediction(target).UnitPosition) <
                            BarrelExplosionRange && savedBarrels.Count(b => b.barrel.Position.Distance(p) < BarrelExplosionRange) < 1)
                        .OrderBy(p => p.Distance(target.Position))
                        .FirstOrDefault();
                    if (point != null && !justE)
                    {
                        E.Cast(point);
                        Core.DelayAction(() => Q.Cast(Qbarrel), 1);
                        return;
                    }
                }
            }

            if (E.IsReady() && player.Distance(target) < E.Range &&
                target.Health > Q.GetDamage(target) + player.GetAutoAttackDamage(target) && Orbwalker.CanMove &&
                0 < E.AmmoQuantity)
            {
                CastE(target, barrels);
            }
            var meleeRangeBarrel =
                barrels.FirstOrDefault(
                    b =>
                    b.Health < 2 && b.Distance(player) < player.GetAutoAttackDamage(b) &&
                    b.CountEnemiesInRange(BarrelExplosionRange) > 0);

            if (meleeRangeBarrel != null)
            {
                Orbwalker.ForcedTarget = meleeRangeBarrel;
            }
            if (Q.IsReady())
            {
                if (barrels.Any())
                {
                    var detoneateTargetBarrels = barrels.Where(b => b.Distance(player) < Q.Range);

                    if (detoneateTargetBarrels.Any())
                    {
                        foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                        {
                            if (!KillableBarrel(detoneateTargetBarrel))
                            {
                                continue;
                            }
                            if (
                                detoneateTargetBarrel.Distance(
                                    Q.GetPrediction(target).UnitPosition) <
                                BarrelExplosionRange &&
                                target.Distance(detoneateTargetBarrel.Position) < BarrelExplosionRange)
                            {
                                Q.Cast(detoneateTargetBarrel);
                                return;
                            }
                            var detoneateTargetBarrelSeconds =
                                barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
                            if (detoneateTargetBarrelSeconds.Any())
                            {
                                foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                {
                                    if (
                                        detoneateTargetBarrelSecond.Distance(
                                            Q.GetPrediction(
                                                target).UnitPosition) <
                                        BarrelExplosionRange &&
                                        target.Distance(detoneateTargetBarrelSecond.Position) < BarrelExplosionRange)
                                    {
                                        Q.Cast(detoneateTargetBarrel);
                                        return;
                                    }
                                }
                            }
                        }
                    }

                    if (2 > 1)
                    {
                        var enemies =
                            EntityManager.Enemies.Where(e => e.IsValidTarget() && e.Distance(player) < 600)
                            .Select(e => Q.GetPrediction(e));
                        var enemies2 =
                            EntityManager.Enemies.Where(e => e.IsValidTarget() && e.Distance(player) < 600)
                            .Select(e => Q.GetPrediction(e));
                        if (detoneateTargetBarrels.Any())
                        {
                            foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                            {
                                if (!KillableBarrel(detoneateTargetBarrel))
                                {
                                    continue;
                                }
                                var enemyCount =
                                    enemies.Count(
                                        e =>
                                        e.UnitPosition.Distance(detoneateTargetBarrel.Position) <
                                        BarrelExplosionRange);
                                if (enemyCount >= 1 &&
                                    detoneateTargetBarrel.CountEnemiesInRange(BarrelExplosionRange) >=
                                    1)
                                {
                                    Q.CastOnUnit(detoneateTargetBarrel);
                                    return;
                                }
                                var detoneateTargetBarrelSeconds =
                                    barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
                                if (detoneateTargetBarrelSeconds.Any())
                                {
                                    foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                    {
                                        if (enemyCount +
                                            enemies2.Count(
                                                e =>
                                                e.UnitPosition.Distance(detoneateTargetBarrelSecond.Position) <
                                                BarrelExplosionRange) >=
                                            1 &&
                                            detoneateTargetBarrelSecond.CountEnemiesInRange(BarrelExplosionRange) >=
                                            1)
                                        {
                                            Q.CastOnUnit(
                                                detoneateTargetBarrel);
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (Q.CanCast(target))
                {
                    CastQonHero(target, barrels);
                }
            }
        }
コード例 #4
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(
                E.Range, TargetSelector.DamageType.Physical, true, HeroManager.Enemies.Where(h => h.IsInvulnerable));

            if (target == null)
            {
                return;
            }
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite", true).GetValue <bool>() &&
                ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) && !Q.IsReady() && !justQ)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (config.Item("usew", true).GetValue <Slider>().Value > player.HealthPercent &&
                player.CountEnemiesInRange(500) > 0)
            {
                W.Cast();
            }
            if (R.IsReady() && config.Item("user", true).GetValue <bool>())
            {
                var Rtarget =
                    HeroManager.Enemies.FirstOrDefault(e => e.HealthPercent < 50 && e.CountAlliesInRange(660) > 0);
                if (Rtarget != null)
                {
                    R.CastIfWillHit(Rtarget, config.Item("Rmin", true).GetValue <Slider>().Value);
                }
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target), config.Item("AutoW", true).GetValue <bool>());
            }
            var barrels =
                GetBarrels()
                .Where(
                    o =>
                    o.IsValid && !o.IsDead && o.Distance(player) < 1600 && o.SkinName == "GangplankBarrel" &&
                    o.GetBuff("gangplankebarrellife").Caster.IsMe)
                .ToList();

            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && config.Item("usee", true).GetValue <bool>() &&
                E.IsReady() && Orbwalking.CanMove(100) && !justE)
            {
                var Qbarrels = GetBarrels().Where(o => o.Distance(player) < Q.Range && KillableBarrel(o));
                foreach (var Qbarrel in Qbarrels)
                {
                    if (Qbarrel.Distance(target) < BarrelExplosionRange)
                    {
                        continue;
                    }
                    var point =
                        GetBarrelPoints(Qbarrel.Position)
                        .Where(
                            p =>
                            p.IsValid() && !p.IsWall() && p.Distance(player.Position) < E.Range &&
                            p.Distance(Prediction.GetPrediction(target, GetQTime(Qbarrel)).UnitPosition) <
                            BarrelExplosionRange && Qbarrel.Distance(p) < BarrelConnectionRange &&
                            savedBarrels.Count(b => b.barrel.Position.Distance(p) < BarrelExplosionRange) < 1)
                        .OrderBy(p => p.Distance(target.Position))
                        .FirstOrDefault();
                    if (point != null)
                    {
                        E.Cast(point);
                        Utility.DelayAction.Add(1, () => Q.CastOnUnit(Qbarrel));
                        return;
                    }
                }
            }
            var meleeRangeBarrel =
                barrels.FirstOrDefault(
                    b =>
                    (b.Health < 2 || (b.Health == 2 && Q.IsReady())) &&
                    b.Distance(player) < Orbwalking.GetAutoAttackRange(player, b) &&
                    b.CountEnemiesInRange(BarrelExplosionRange) > 0);

            if (meleeRangeBarrel != null && Orbwalking.CanMove(100))
            {
                player.IssueOrder(GameObjectOrder.AutoAttack, meleeRangeBarrel);
            }
            if (Q.IsReady())
            {
                if (barrels.Any())
                {
                    var detoneateTargetBarrels = barrels.Where(b => b.Distance(player) < Q.Range);
                    if (config.Item("detoneateTarget", true).GetValue <bool>())
                    {
                        if (detoneateTargetBarrels.Any())
                        {
                            foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                            {
                                if (!KillableBarrel(detoneateTargetBarrel))
                                {
                                    continue;
                                }
                                if (
                                    detoneateTargetBarrel.Distance(
                                        Prediction.GetPrediction(target, GetQTime(detoneateTargetBarrel)).UnitPosition) <
                                    BarrelExplosionRange &&
                                    target.Distance(detoneateTargetBarrel.Position) < BarrelExplosionRange)
                                {
                                    Q.CastOnUnit(detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
                                    return;
                                }
                                var detoneateTargetBarrelSeconds =
                                    barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
                                if (detoneateTargetBarrelSeconds.Any())
                                {
                                    foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                    {
                                        if (
                                            detoneateTargetBarrelSecond.Distance(
                                                Prediction.GetPrediction(
                                                    target, GetQTime(detoneateTargetBarrel) + 0.15f).UnitPosition) <
                                            BarrelExplosionRange &&
                                            target.Distance(detoneateTargetBarrelSecond.Position) < BarrelExplosionRange)
                                        {
                                            Q.CastOnUnit(detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
                                            return;
                                        }
                                    }
                                }
                            }
                        }

                        if (config.Item("detoneateTargets", true).GetValue <Slider>().Value > 1)
                        {
                            var enemies =
                                HeroManager.Enemies.Where(e => e.IsValidTarget() && e.Distance(player) < 600)
                                .Select(e => Prediction.GetPrediction(e, 0.25f));
                            var enemies2 =
                                HeroManager.Enemies.Where(e => e.IsValidTarget() && e.Distance(player) < 600)
                                .Select(e => Prediction.GetPrediction(e, 0.35f));
                            if (detoneateTargetBarrels.Any())
                            {
                                foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                                {
                                    if (!KillableBarrel(detoneateTargetBarrel))
                                    {
                                        continue;
                                    }
                                    var enemyCount =
                                        enemies.Count(
                                            e =>
                                            e.UnitPosition.Distance(detoneateTargetBarrel.Position) <
                                            BarrelExplosionRange);
                                    if (enemyCount >= config.Item("detoneateTargets", true).GetValue <Slider>().Value&&
                                        detoneateTargetBarrel.CountEnemiesInRange(BarrelExplosionRange) >=
                                        config.Item("detoneateTargets", true).GetValue <Slider>().Value)
                                    {
                                        Q.CastOnUnit(detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
                                        return;
                                    }
                                    var detoneateTargetBarrelSeconds =
                                        barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
                                    if (detoneateTargetBarrelSeconds.Any())
                                    {
                                        foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                        {
                                            if (enemyCount +
                                                enemies2.Count(
                                                    e =>
                                                    e.UnitPosition.Distance(detoneateTargetBarrelSecond.Position) <
                                                    BarrelExplosionRange) >=
                                                config.Item("detoneateTargets", true).GetValue <Slider>().Value&&
                                                detoneateTargetBarrelSecond.CountEnemiesInRange(BarrelExplosionRange) >=
                                                config.Item("detoneateTargets", true).GetValue <Slider>().Value)
                                            {
                                                Q.CastOnUnit(
                                                    detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
                                                return;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && Orbwalking.CanMove(100) && !justE)
                {
                    CastQonHero(target, barrels);
                }
            }
        }
コード例 #5
0
        public static void Combo()
        {
            // Usa Q
            var UsaQ = Menu["Q"].Cast <CheckBox>().CurrentValue;
            // Usa W
            var UsaW = Menu["W2"].Cast <CheckBox>().CurrentValue;
            // Usa E
            var UsaE = Menu["E"].Cast <CheckBox>().CurrentValue;
            // Slide W
            var UsaW2 = Menu["WPerc"].Cast <Slider>().CurrentValue;
            // Usa Barril Extendido
            var EExtendido = Menu["E2"].Cast <CheckBox>().CurrentValue;
            // Usa AOE Extendido
            var AOEExtendido = Menu["AOE3"].Cast <Slider>().CurrentValue;

            // Usa Modo Barrel Extendido
            var ModoBExtended = Menu["SS"].Cast <ComboBox>().DisplayName;
            var target        = TargetSelector.GetTarget(E.Range, DamageType.Physical);

            if (target == null)
            {
                return;
            }
            if (true)//Atk Barril se estiver com 3 de Vida
            {
                var AtkBarrel = Barrils().OrderBy(o => o.IsValid).FirstOrDefault(o => o.Health >= 2 && o.Health >= 1 && o.Distance(player) < Player.Instance.GetAutoAttackRange(o));
                if (AtkBarrel != null && AtkBarrel.Health >= 2)
                {
                    Player.IssueOrder(GameObjectOrder.AttackUnit, AtkBarrel);//Auto estaka Barrel Atacando
                    //return;
                }
            }
            if (Player.Instance.HealthPercent <= UsaW2 && UsaW && Player.Instance.CountEnemiesInRange(800) >= 1)
            {
                W.Cast();
            }
            var NaoUsaQ = false;
            var barrels = Barrils().Where(o => o.IsValid && !o.IsDead && o.Distance(Player.Instance) < 1600 && o.BaseSkinName == "GangplankBarrel").ToList();

            if (EExtendido && Q.IsReady() && E.IsReady())
            {
                var Prediction = E.GetPrediction(target);
                if (Prediction.HitChance >= HitChance.Low)
                {
                    var Qbarrels = Barrils().Where(o => o.Distance(Player.Instance) <= Q.Range + 100 && KillableBarrel(o));
                    foreach (var Qbarrel in Qbarrels)  //.OrderByDescending(b => b.Distance(target) <= BarrelExplosionRange))
                    {
                        if (ModoBExtended == "☑ 1 职业") //Modo Profissional
                        {
                            if (Qbarrel.Distance(Prediction.UnitPosition) <= BarrelConnectionRange)
                            {
                                var enemies = EntityManager.Heroes.Enemies.Where(e => e.Distance(Player.Instance) <= 2000);
                                var pos     = GetBarrelPoints(Qbarrel.Position).Where(p => p.Distance(Qbarrel.Position) <= BarrelConnectionRange).OrderByDescending(p => p.Distance(p) <= BarrelExplosionRange).ThenBy(p => p.Distance(target.Position)).FirstOrDefault();
                                NaoUsaQ = true;
                                E.Cast(pos);
                            }
                        }
                        if (ModoBExtended == "☑ 2 高级")//Modo Avançado
                        {
                            var point = GetBarrelPoints(Qbarrel.Position).Where(p => p.IsValid() && !p.IsWall() && p.Distance(player.Position) < E.Range && target.Distance(p) < BarrelExplosionRange &&
                                                                                p.Distance(Prediction.UnitPosition) <= BarrelExplosionRange && Qbarrel.Distance(p) <= BarrelConnectionRange &&
                                                                                savedBarrels.Count(b => b.barrel.Position.Distance(p) <= BarrelExplosionRange) < 1)
                                        .OrderBy(p => p.Distance(Prediction.UnitPosition)).FirstOrDefault();
                            if (point.IsValid())
                            {
                                NaoUsaQ = true;
                                E.Cast(point);
                            }
                        }
                    }
                }
            }

            if (true)
            {
                if (barrels.Any() && Q.IsReady())
                {
                    var detoneateTargetBarrels = barrels.Where(b => b.Distance(player) <= Q.Range);
                    if (true)//Auto Atirar no Barril se detectado Inimigo Dentro
                    {
                        if (detoneateTargetBarrels.Any())
                        {
                            foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                            {
                                if (!KillableBarrel(detoneateTargetBarrel))
                                {
                                    continue;
                                }
                                if (detoneateTargetBarrel.Distance(target) < BarrelExplosionRange && target.Distance(detoneateTargetBarrel.Position) < BarrelExplosionRange)
                                {
                                    NaoUsaQ = true;
                                    Q.Cast(detoneateTargetBarrel);
                                    return;
                                }
                                var detoneateTargetBarrelSeconds = barrels.Where(b => b.Distance(detoneateTargetBarrel) <= BarrelConnectionRange);
                                if (detoneateTargetBarrelSeconds.Any())
                                {
                                    foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                    {
                                        if (detoneateTargetBarrelSecond.Distance(target) <= BarrelExplosionRange && target.Distance(detoneateTargetBarrelSecond.Position) <= BarrelExplosionRange)
                                        {
                                            NaoUsaQ = true;
                                            Q.Cast(detoneateTargetBarrel);
                                            return;
                                        }
                                    }
                                }
                            }
                        }
                        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                        if (AOEExtendido > 0)                                                                                                                            // 1 a 5 - padrao 2 - Blow up enemies with E
                        {
                            var enemies = EntityManager.Heroes.Enemies.Where(e => e.IsValidTarget() && e.Distance(Player.Instance) < 1050 && e.IsHPBarRendered == true); //normal 600
                            if (detoneateTargetBarrels.Any())
                            {
                                foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
                                {
                                    if (!KillableBarrel(detoneateTargetBarrel))
                                    {
                                        continue;
                                    }
                                    var enemyCount = enemies.Count(e => e.Distance(detoneateTargetBarrel.Position) < BarrelExplosionRange);
                                    if (enemyCount >= AOEExtendido && detoneateTargetBarrel.CountEnemiesInRange(BarrelExplosionRange) >= AOEExtendido)
                                    {
                                        NaoUsaQ = true;
                                        Q.Cast(detoneateTargetBarrel);
                                        return;
                                    }
                                    var detoneateTargetBarrelSeconds = barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
                                    if (detoneateTargetBarrelSeconds.Any())
                                    {
                                        foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
                                        {
                                            if (enemyCount + enemies.Count(e => e.Distance(detoneateTargetBarrelSecond.Position) < BarrelExplosionRange) >= AOEExtendido && detoneateTargetBarrelSecond.CountEnemiesInRange(BarrelExplosionRange) >= AOEExtendido)
                                            {
                                                NaoUsaQ = true;
                                                Q.Cast(detoneateTargetBarrel);
                                                return;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                /*   if (E.IsReady() && player.Distance(target) < E.Range &&//useeAlways menu
                 *     !justE && target.Health > Player.Instance.GetSpellDamage(target, SpellSlot.Q) + player.GetAutoAttackDamage(target) &&
                 *     Player.Instance.CanMove && 1 < Player.Instance.Spellbook.GetSpell(SpellSlot.E).Ammo) //eStacksC menu
                 * {
                 *     CastE(target, barrels);
                 * }*/

                var Barrils = BarrilsIE().FirstOrDefault(b => b.IsInRange(Player.Instance, Q.Range + 100));
                if (UsaE && Barrils == null && target.Distance(Player.Instance) <= E.Range)
                {
                    var vec     = target.ServerPosition / ObjectManager.Player.Position;
                    var Logica  = E.GetPrediction(Player.Instance).CastPosition + Vector3.Normalize(vec) * 350;
                    var Logica2 = E.GetPrediction(Player.Instance).CastPosition + Vector3.Normalize(vec) - 10;

                    if (Player.Instance.Distance(target.Position) >= 620)
                    {
                        E.Cast(Logica);
                        CastE(target, barrels);
                    }
                    if (Player.Instance.Distance(target.Position) <= 610)
                    {
                        E.Cast(Logica2);
                    }
                }
                var Qbarrels = BarrilsIE().FirstOrDefault(o => o.Distance(player) < Q.Range + 100);
                if (Qbarrels != null && Player.Instance.Spellbook.GetSpell(SpellSlot.E).Ammo > 0 && Q.IsReady() && target.Health > Player.Instance.GetSpellDamage(target, SpellSlot.Q))
                {
                    NaoUsaQ = true;
                }
                if (!NaoUsaQ && UsaQ)
                {
                    CastQonHero(target, barrels);
                }
            }
        }