Exemplo n.º 1
0
        private void Combo()
        {
            Obj_AI_Hero target = null;

            if (E.IsCharging)
            {
                target = TargetSelector.GetTarget(
                    GetTargetRange(), TargetSelector.DamageType.Magical, true,
                    HeroManager.Enemies.Where(
                        h => h.IsInvulnerable && CombatHelper.GetAngle(player, target.Position) > 50));
            }
            else
            {
                target = TargetSelector.GetTarget(
                    GetTargetRange(), TargetSelector.DamageType.Magical, true,
                    HeroManager.Enemies.Where(h => h.IsInvulnerable));
            }
            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config);
            }
            if (config.Item("usew", true).GetValue <bool>() && W.CanCast(target) && !E.IsCharging)
            {
                W.Cast(config.Item("packets").GetValue <bool>());
            }
            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 > target.Health && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) && !Q.CanCast(target))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }

            if (rActive)
            {
                return;
            }

            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() && player.CanMove)
            {
                CastE(target);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && target.IsValidTarget() &&
                !E.IsCharging)
            {
                Q.CastIfHitchanceEquals(target, HitChance.Medium, config.Item("packets").GetValue <bool>());
            }

            if (R.IsReady() && config.Item("user", true).GetValue <bool>() &&
                config.Item("Rmin", true).GetValue <Slider>().Value <= player.CountEnemiesInRange(R.Range) &&
                !target.HasBuffOfType(BuffType.Knockback) && !target.HasBuffOfType(BuffType.Knockup) &&
                !target.HasBuffOfType(BuffType.Stun))
            {
                R.Cast(config.Item("packets").GetValue <bool>());
            }
        }
Exemplo n.º 2
0
        public static void updateArmaPlay()
        {
            if (!haveSeenMinion)
            {
                haveSeenMinion =
                    ObjectManager.Get <Obj_AI_Minion>().Any(min => min.IsTargetable && min.IsAlly && min.Health > 50) ||
                    ARAMDetFull.gameStart + 44 * 1000 < ARAMDetFull.now;
            }
            if (!haveSeenMinion)
            {
                return;
            }
            try
            {
                AutoLevelChamp.LevelUpOff();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            if ((player.InShop() || player.IsDead) /* && nextItem != null && nextItem.goldReach <= player.Gold*/)
            {
                buyItems();
            }
            if (champ != null)
            {
                champ.alwaysCheck();
            }

            setRambo();
            if (player.IsDead || player.IsChannelingImportantSpell())
            {
                return;
            }
            var fightLevel = MapControl.fightLevel();

            MapControl.updateReaches();

            var closestEnemy = HeroManager.Enemies.Where(ene => !ene.IsDead && ene.IsTargetable && !ARAMTargetSelector.IsInvulnerable(ene)).OrderBy(ene => player.Position.Distance(ene.Position, true)).FirstOrDefault();

            if (closestEnemy != null && ramboMode)
            {
                DeathWalker.deathWalk(closestEnemy.Position, true);
                return;
            }

            if (fightLevel != 0)
            {
                Aggresivity.addAgresiveMove(new AgresiveMove(40 * fightLevel, 2000, true, true));
            }

            agrobalance = Aggresivity.getAgroBalance();

            balance  = (ARAMTargetSelector.IsInvulnerable(player) || player.IsZombie) ? 250 : MapControl.balanceAroundPointAdvanced(player.Position.To2D(), 250 - agrobalance * 5) + agrobalance;
            inDanger = balance < 0;

            if (Game.MapId == GameMapId.SummonersRift)
            {
                if (player.IsRecalling())
                {
                    return;
                }
                if (player.InFountain() && player.HealthPercent < 90)
                {
                    player.IssueOrder(GameObjectOrder.Stop, player);
                    return;
                }
                if (player.HealthPercent > 85 && (player.MaxMana < 450 || player.ManaPercent > 85))
                {
                    needRecall = false;
                }
                if ((((player.HealthPercent < 32 || (player.MaxMana > 450 && player.ManaPercent < 5)) && player.CountEnemiesInRange(1000) == 0) || needRecall) && balance > 5)
                {
                    if (lastRecall + 9000 < DeathWalker.now)
                    {
                        needRecall = true;
                        var recall = new Spell(SpellSlot.Recall);
                        recall.Cast();
                        lastRecall = DeathWalker.now;
                        return;
                    }
                }
                else if (needRecall)
                {
                    player.IssueOrder(GameObjectOrder.MoveTo, fromNex.Position.Randomize(534, 1005));
                    return;
                }
            }

            if (champ != null)
            {
                try
                {
                    if (player.GetEnemiesInRange(ARAMSimulator.farmRange).Count(ene => !ene.IsDead && !ene.IsZombie) != 0)
                    {
                        champ.killSteal();
                    }
                    else
                    {
                        champ.farm();
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
            }

            if (!Sector.inTowerRange(player.Position.To2D()) || towerAttackedAlly || player.HealthPercent < 25)
            {
                try
                {
                    ItemHandler.useItems();
                    sSpells.useSumoners();
                    if (champ != null)
                    {
                        champ.useSpells();
                    }
                    else
                    {
                        MapControl.myControler.useSpells();
                        if (player.MaxMana < 350 || player.ManaPercent > 50)
                        {
                            MapControl.myControler.useSpellsOnMinions();
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
            }

            deepestAlly = HeroManager.Allies.OrderBy(al => toNex.Position.Distance(al.Position, true)).FirstOrDefault();
            var lookRange = player.AttackRange + ((player.IsMelee) ? 260 : 155);
            var easyKill  =
                HeroManager.Enemies.FirstOrDefault(ene => ene != null && !ene.IsZombie && !ene.IsDead && ene.Distance(player, true) < lookRange * lookRange &&
                                                   !ARAMTargetSelector.IsInvulnerable(ene) && ene.Health / 1.5 < player.GetAutoAttackDamage(ene));

            if (easyKill != null)
            {
                Aggresivity.addAgresiveMove(new AgresiveMove(45, 1500, true));
                //Console.WriteLine("go get easy");
                DeathWalker.deathWalk(easyKill.Position.To2D().Extend(player.Position.To2D(), player.AttackRange * 0.7f).To3D(), true);
            }


            if (balance < 0)
            {
                DeathWalker.deathWalk(player.Position.To2D().Extend(fromNex.Position.To2D(), 600).To3D(), true);
            }

            if ((!player.IsMelee || fightLevel < 2) && HeroManager.Enemies.Any(h => !h.IsDead) && moveToRelicIfForHeal())
            {
                return;
            }

            if (!player.UnderTurret(true))
            {
                towerAttackedMe   = false;
                towerAttackedAlly = false;
            }

            if (towerAttackedMe)
            {
                DeathWalker.CustomOrbwalkMode = false;
                // Game.PrintChat("ouch tower!");
                DeathWalker.deathWalk(player.Position.To2D().Extend(fromNex.Position.To2D(), 600).To3D(), true);
                return;
            }

            awayTo = eAwayFromTo();
            if (awayTo.IsValid() && awayTo.X != 0)
            {
                DeathWalker.CustomOrbwalkMode = false;
                if (champ != null)
                {
                    champ.kiteBack(awayTo);
                }
                DeathWalker.deathWalk(awayTo.To3D(), true);
                return;
            }
            else
            {
                var closestObj =
                    DeathWalker.EnemyObjectives.Where(
                        obj => obj.IsValidTarget(700) && !obj.IsDead && !obj.IsInvulnerable)
                    .OrderBy(obj => obj.Position.Distance(player.Position, true)).FirstOrDefault();
                if (closestObj != null && (!(closestObj is Obj_AI_Turret) || Sector.towerContainsAlly((Obj_AI_Turret)closestObj)))
                {
                    DeathWalker.deathWalk(
                        closestObj.Position.Extend(player.Position, player.AttackRange * 0.6f), true);
                    return;
                }

                if (player.IsMelee)
                {
                    var safeMeleeEnem = ARAMTargetSelector.getSafeMeleeTarget();
                    if (safeMeleeEnem != null)
                    {
                        DeathWalker.deathWalk(
                            safeMeleeEnem.Position.Extend(safeMeleeEnem.Direction, player.AttackRange * 0.3f), true);
                        return;
                    }
                }
                var fightOn = MapControl.fightIsOn();
                if (fightOn != null && MapControl.balanceAroundPointAdvanced(fightOn.Position.To2D(), 280, 450) > (-130) && fightOn.Distance(player, true) < 2500 * 2500 && (!player.IsMelee() || !Sector.inTowerRange(fightOn.Position.To2D())))
                {
                    Aggresivity.addAgresiveMove(new AgresiveMove(40 * MapControl.fightLevel(), 2000, true, true));
                    DeathWalker.deathWalk(fightOn.Position.Extend(player.Position, player.AttackRange * 0.8f), true);
                }
                else
                {/*
                  * if (player.HealthPercent < 69 && moveToRelicIfForHeal())
                  * {
                  *     return;
                  * }*/
                    if (!inDanger)
                    {
                        Sector orbSector  = null;
                        Sector prevSector = null;
                        foreach (var sector in sectors)
                        {
                            sector.update();
                            int sectorCheck = 1150 - MapControl.fearDistance;
                            if (sector.containsEnemyChamp && sector.enemyChampIn.Distance(player, true) < sectorCheck * sectorCheck)
                            {
                                orbSector = sector;
                                break;
                            }
                            if (sector.dangerPolig)
                            {
                                break;
                            }
                            //  if (!player.IsMelee)
                            // {
                            if (sector.containsEnemy && !sector.containsAlly)
                            {
                                break;
                            }
                            // }
                            // else
                            //  {
                            //     if (prevSector != null && sector.containsEnemy && !prevSector.containsAlly  && !sector.containsAlly)
                            //         break;
                            //  }
                            orbSector = sector;
                            if (sector.containsEnemy && sector.containsAlly)
                            {
                                break;
                            }
                            prevSector = sector;
                        }
                        if (orbSector == null)
                        {
                            return;
                        }
                        DeathWalker.deathWalk(orbSector.getRandomPointIn().To3D(), false, true);
                    }
                    else
                    {
                        DeathWalker.deathWalk(player.Position.To2D().Extend(fromNex.Position.To2D(), 600).To3D(), false);
                    }
                }
            }



            /*foreach (var ally in MapControl.ally_champions)
             * {
             *  if (ally.hero.Distance(player) < 800 && MapControl.myControler != null)
             *      MapControl.myControler.useNonSkillshots(ally.hero);
             * }*/
        }
Exemplo n.º 3
0
        private void Game_OnUpdate(EventArgs args)
        {
            float time = System.Environment.TickCount;

            foreach (Positions enemyInfo in
                     Enemies.Where(x => x.Player.IsVisible && !x.Player.IsDead && x.Player.IsValidTarget()))
            {
                enemyInfo.LastSeen = time;
                var prediction = Prediction.GetPrediction(enemyInfo.Player, 10);
                if (prediction != null)
                {
                    enemyInfo.predictedpos = prediction.UnitPosition;
                }
            }
            if (xerathUltActivated && R.IsReady() && !configMenu.Item("ComboBlock").GetValue <KeyBind>().Active&&
                player.HasBuff("xerathrshots"))
            {
                var enemy =
                    Enemies.Where(x => x.Player.NetworkId == xerathUltTarget.NetworkId && !x.Player.IsDead)
                    .FirstOrDefault();
                if (enemy != null)
                {
                    R.Cast(enemy.Player.Position);
                }
                else
                {
                    var target =
                        HeroManager.Enemies.Where(h => player.Distance(h) < xerathUltRange[R.Level - 1] && h.IsVisible)
                        .OrderBy(h => h.Health)
                        .FirstOrDefault();
                    if (target != null)
                    {
                        R.Cast(target);
                    }
                }
            }
            if (!SupportedChamps() || !configMenu.Item("UseR").GetValue <bool>() || !R.IsReady() || !enabled ||
                configMenu.Item("ComboBlock").GetValue <KeyBind>().Active)
            {
                return;
            }
            if (player.CountEnemiesInRange(configMenu.Item("EnemiesAroundYou").GetValue <Slider>().Value) >= 1)
            {
                return;
            }
            if (!configMenu.Item("OnlyCombo").GetValue <bool>() &&
                (configMenu.Item("OrbBlock1").GetValue <KeyBind>().Active ||
                 configMenu.Item("OrbBlock2").GetValue <KeyBind>().Active ||
                 configMenu.Item("OrbBlock3").GetValue <KeyBind>().Active))
            {
                return;
            }
            if (player.ChampionName == "Draven" && player.Spellbook.GetSpell(SpellSlot.R).Name != "DravenRCast")
            {
                return;
            }
            var HitChance = configMenu.Item("Hitchance").GetValue <Slider>().Value;

            foreach (Positions enemy in
                     Enemies.Where(
                         x =>
                         x.Player.IsValid <Obj_AI_Hero>() && !x.Player.IsDead &&
                         !configMenu.Item(x.Player.ChampionName + "DontUltRandomUlt").GetValue <bool>() &&
                         x.RecallData.Recall.Status == Packet.S2C.Teleport.Status.Start &&
                         x.RecallData.Recall.Type == Packet.S2C.Teleport.Type.Recall)
                     .OrderBy(x => x.RecallData.GetRecallTime()))
            {
                if (CheckBuffs(enemy.Player) || CheckBaseUlt(enemy.RecallData.GetRecallCountdown()) ||
                    !(Environment.TickCount - enemy.RecallData.RecallStartTime >
                      configMenu.Item("waitBeforeUlt").GetValue <Slider>().Value))
                {
                    continue;
                }
                var dist = (Math.Abs(enemy.LastSeen - enemy.RecallData.RecallStartTime) / 1000 * enemy.Player.MoveSpeed) -
                           enemy.Player.MoveSpeed / 3;
                var trueDist = Math.Abs(enemy.LastSeen - enemy.RecallData.RecallStartTime) / 1000 *
                               enemy.Player.MoveSpeed;
                var line = getpos(enemy, dist);
                switch (HitChance)
                {
                case 1:
                    break;

                case 2:
                    if (trueDist > 1000 && !enemy.Player.IsVisible)
                    {
                        continue;
                    }
                    break;

                case 3:
                    if (trueDist > 800 && !enemy.Player.IsVisible)
                    {
                        continue;
                    }
                    break;

                case 4:
                    if (trueDist > 650 && !enemy.Player.IsVisible)
                    {
                        continue;
                    }
                    break;

                case 5:
                    if (trueDist > 400 && !enemy.Player.IsVisible)
                    {
                        continue;
                    }
                    break;
                }
                Vector3 pos = line;
                if (enemy.Player.IsVisible)
                {
                    pos = enemy.Player.Position;
                }
                else if (line.Distance(enemy.Player.Position) < dist &&
                         (enemy.predictedpos.UnderTurret(true) ||
                          NavMesh.GetCollisionFlags(enemy.predictedpos).HasFlag(CollisionFlags.Grass)))
                {
                    pos = enemy.predictedpos;
                }
                {
                    if (dist > 1500)
                    {
                        continue;
                    }
                    pos =
                        PointsAroundTheTarget(enemy.Player.Position, trueDist)
                        .Where(
                            p =>
                            !p.IsWall() && line.Distance(p) < dist / 1.2f && GetPath(enemy.Player, p) < trueDist)
                        .OrderByDescending(p => NavMesh.GetCollisionFlags(p).HasFlag(CollisionFlags.Grass))
                        .ThenBy(p => line.Distance(p))
                        .FirstOrDefault();
                }
                if (pos != null)
                {
                    if (player.ChampionName == "Ziggs" && player.Distance(pos) > 5000f)
                    {
                        continue;
                    }
                    if (player.ChampionName == "Lux" && player.Distance(pos) > 3000f)
                    {
                        continue;
                    }
                    if (player.ChampionName == "Xerath" && player.Distance(pos) > xerathUltRange[R.Level - 1] - 500)
                    {
                        continue;
                    }
                    kill(enemy, new Vector3(pos.X, pos.Y, 0));
                }
            }
        }
Exemplo n.º 4
0
        public static void UseItems(Obj_AI_Hero target, Menu config, float comboDmg = 0f, bool cleanseSpell = false)
        {
            if (config.Item("hyd").GetValue <bool>() && player.ChampionName != "Renekton")
            {
                castHydra(target);
            }
            if (config.Item("hyd").GetValue <bool>())
            {
                hydraTarget = target;
                useHydra    = true;
            }
            else
            {
                useHydra = false;
            }
            if (config.Item("ran").GetValue <bool>() && Items.HasItem(randuins.Id) && Items.CanUseItem(randuins.Id))
            {
                if (target != null && player.Distance(target) < randuins.Range &&
                    player.CountEnemiesInRange(randuins.Range) >= config.Item("ranmin").GetValue <Slider>().Value)
                {
                    Items.UseItem(randuins.Id);
                }
            }
            if (config.Item("odin").GetValue <bool>() && target != null && Items.HasItem(odins.Id) &&
                Items.CanUseItem(odins.Id))
            {
                var odinDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.OdingVeils);
                if (config.Item("odinonlyks").GetValue <bool>())
                {
                    if (odinDmg > target.Health)
                    {
                        odins.Cast(target);
                    }
                }
                else if (player.CountEnemiesInRange(odins.Range) >= config.Item("odinmin").GetValue <Slider>().Value ||
                         (Math.Max(comboDmg, odinDmg) > target.Health && player.HealthPercent < 30 &&
                          player.Distance(target) < odins.Range && !CombatHelper.CheckCriticalBuffs(target)))
                {
                    odins.Cast();
                }
            }
            if (target != null && config.Item("bil").GetValue <bool>() && Items.HasItem(bilgewater.Id) &&
                Items.CanUseItem(bilgewater.Id))
            {
                var bilDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Bilgewater);
                if (config.Item("bilonlyks").GetValue <bool>())
                {
                    if (bilDmg > target.Health)
                    {
                        bilgewater.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("bilminr").GetValue <Slider>().Value&&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, bilDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
                         IsURF)
                {
                    bilgewater.Cast(target);
                }
            }
            if (target != null && config.Item("botr").GetValue <bool>() && Items.HasItem(botrk.Id) &&
                Items.CanUseItem(botrk.Id))
            {
                var botrDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Botrk);
                if (config.Item("botronlyks").GetValue <bool>())
                {
                    if (botrDmg > target.Health)
                    {
                        botrk.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("botrminr").GetValue <Slider>().Value&&
                          (player.Health / player.MaxHealth * 100f) <
                          config.Item("botrmyhealth").GetValue <Slider>().Value&&
                          (target.Health / target.MaxHealth * 100f) <
                          config.Item("botrenemyhealth").GetValue <Slider>().Value) ||
                         (IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, botrDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
                         IsURF)
                {
                    botrk.Cast(target);
                }
            }
            if (target != null && config.Item("hex").GetValue <bool>() && Items.HasItem(hexgun.Id) &&
                Items.CanUseItem(hexgun.Id))
            {
                var hexDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Hexgun);
                if (config.Item("hexonlyks").GetValue <bool>())
                {
                    if (hexDmg > target.Health)
                    {
                        hexgun.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("hexminr").GetValue <Slider>().Value&&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, hexDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
                         IsURF)
                {
                    hexgun.Cast(target);
                }
            }

            /*
             * if (config.Item("Muramana").GetValue<bool>() &&
             *  ((!MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value < player.ManaPercent) ||
             *   (MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value > player.ManaPercent)))
             * {
             *  if (Muramana.IsOwned() && Muramana.IsReady())
             *  {
             *      Muramana.Cast();
             *  }
             *  if (Muramana2.IsOwned() && Muramana2.IsReady())
             *  {
             *      Muramana2.Cast();
             *  }
             * }
             * MuramanaTime = System.Environment.TickCount;
             */
            if (config.Item("you").GetValue <bool>() && Items.HasItem(youmuu.Id) && Items.CanUseItem(youmuu.Id) &&
                target != null && player.Distance(target) < player.AttackRange + 50 && target.HealthPercent < 65)
            {
                youmuu.Cast();
            }

            if (Items.HasItem(frost.Id) && Items.CanUseItem(frost.Id) && target != null &&
                config.Item("frost").GetValue <bool>())
            {
                if ((config.Item("frostmin").GetValue <Slider>().Value <= player.CountEnemiesInRange(2000) ||
                     target.HealthPercent < 40) &&
                    (target.HealthPercent < 40 && config.Item("frostlow").GetValue <bool>() ||
                     !config.Item("frostlow").GetValue <bool>()))
                {
                    frost.Cast(target);
                }
            }

            if (config.Item("Zhonya").GetValue <bool>())
            {
                if (((config.Item("Zhonyadmg").GetValue <Slider>().Value / 100f * player.Health <=
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken ||
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) ||
                     (Danger() && player.HealthPercent < 30)) && player.IsValidTarget(10, false))
                {
                    if (Items.HasItem(Zhonya.Id) && Items.CanUseItem(Zhonya.Id))
                    {
                        Zhonya.Cast();
                        return;
                    }
                    if (Items.HasItem(Wooglet.Id) && Items.CanUseItem(Wooglet.Id))
                    {
                        Wooglet.Cast();
                        return;
                    }
                }
            }

            if (config.Item("Seraph").GetValue <bool>())
            {
                if (((config.Item("SeraphdmgHP").GetValue <Slider>().Value / 100f * player.Health <=
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken ||
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) ||
                     (config.Item("SeraphdmgSh").GetValue <Slider>().Value / 100f * (150 + player.Mana * 0.2f) <=
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken)) || Danger())
                {
                    if (Items.HasItem(Seraph.Id) && Items.CanUseItem(Seraph.Id))
                    {
                        Seraph.Cast();
                    }
                    if (Items.HasItem(SeraphDom.Id) && Items.CanUseItem(SeraphDom.Id))
                    {
                        SeraphDom.Cast();
                    }
                }
            }
            if (Items.HasItem(solari.Id) && Items.CanUseItem(solari.Id) && config.Item("solari").GetValue <bool>())
            {
                if ((config.Item("solariminally").GetValue <Slider>().Value <= player.CountAlliesInRange(solari.Range) &&
                     config.Item("solariminenemy").GetValue <Slider>().Value <= player.CountEnemiesInRange(solari.Range)) ||
                    ObjectManager.Get <Obj_AI_Hero>()
                    .FirstOrDefault(
                        h => h.IsAlly && !h.IsDead && solari.IsInRange(h) && CombatHelper.CheckCriticalBuffs(h)) !=
                    null ||
                    (Program.IncDamages.IncomingDamagesAlly.Any(
                         a => a.Hero.HealthPercent < 50 && (a.DamageTaken > 150 || a.DamageTaken > a.Hero.Health))))
                {
                    solari.Cast();
                }
            }
            if (Items.HasItem(mountain.Id) && Items.CanUseItem(mountain.Id) && config.Item("mountain").GetValue <bool>())
            {
                if (config.Item("castonme").GetValue <bool>() &&
                    ((player.Health / player.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value ||
                     Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) &&
                    (player.CountEnemiesInRange(700f) > 0 || CombatHelper.CheckCriticalBuffs(player)))
                {
                    mountain.Cast(player);
                    return;
                }
                var targ =
                    ObjectManager.Get <Obj_AI_Hero>()
                    .Where(
                        h =>
                        h.IsAlly && !h.IsMe && !h.IsDead && player.Distance(h) < mountain.Range &&
                        config.Item("mountainpriority" + h.ChampionName).GetValue <Slider>().Value > 0 &&
                        ((h.Health / h.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value ||
                         Program.IncDamages.GetAllyData(h.NetworkId).DamageTaken > h.Health));
                if (targ != null)
                {
                    var finaltarg =
                        targ.OrderByDescending(
                            t => config.Item("mountainpriority" + t.ChampionName).GetValue <Slider>().Value)
                        .ThenBy(t => t.Health)
                        .FirstOrDefault();
                    if (finaltarg != null &&
                        (finaltarg.CountEnemiesInRange(700f) > 0 || finaltarg.UnderTurret(true) ||
                         CombatHelper.CheckCriticalBuffs(finaltarg)))
                    {
                        mountain.Cast(finaltarg);
                    }
                }
            }
            if (config.Item("protoBelt").GetValue <bool>() && target != null && player.Distance(target) < 750)
            {
                if (config.Item("protoBeltEHealth").GetValue <Slider>().Value > target.HealthPercent &&
                    (player.Distance(target) > 150 ||
                     player.Distance(target) > Orbwalking.GetRealAutoAttackRange(target)))
                {
                    if (Items.HasItem(ProtoBelt.Id) && Items.CanUseItem(ProtoBelt.Id))
                    {
                        var pred = Prediction.GetPrediction(
                            target, 0.25f, 100, 2000,
                            new[]
                        {
                            CollisionableObjects.Heroes, CollisionableObjects.Minions, CollisionableObjects.Walls,
                            CollisionableObjects.YasuoWall
                        });
                        if (pred.Hitchance >= HitChance.High)
                        {
                            ProtoBelt.Cast(pred.CastPosition);
                        }
                    }
                }
            }
            if (config.Item("glp").GetValue <bool>() && target != null && player.Distance(target) < 650)
            {
                if (config.Item("glpEHealth").GetValue <Slider>().Value > target.HealthPercent)
                {
                    if (Items.HasItem(GLP.Id) && Items.CanUseItem(GLP.Id))
                    {
                        var pred = Prediction.GetPrediction(
                            target, 0.25f, 100, 1500,
                            new[] { CollisionableObjects.Heroes, CollisionableObjects.YasuoWall });
                        if (pred.Hitchance >= HitChance.High)
                        {
                            GLP.Cast(pred.CastPosition);
                        }
                    }
                }
            }
            if (config.Item("QSSEnabled").GetValue <bool>())
            {
                UseCleanse(config, cleanseSpell);
            }
        }
Exemplo n.º 5
0
        private static void Combo(bool useq, bool usew, bool user)
        {
            if (useq && _q.IsReady())
            {
                var qtarget = TargetSelector.GetTargetNoCollision(_q);
                if (qtarget.IsValidTarget())
                {
                    var poutput = _q.GetPrediction(qtarget);
                    if (poutput.Hitchance >= (HitChance)_menu.Item("hitchanceq").GetValue <Slider>().Value + 2)
                    {
                        _q.Cast(poutput.CastPosition);
                    }
                }
            }

            if (usew && _w.IsReady())
            {
                var wtarget = TargetSelector.GetTarget(_w.Range + 10, TargetSelector.DamageType.Magical);
                if (wtarget.IsValidTarget())
                {
                    if (!_menu.Item("waitfor").GetValue <bool>() || _mw * 1 >= wtarget.Health)
                    {
                        var poutput = _w.GetPrediction(wtarget);
                        if (poutput.Hitchance >= (HitChance)_menu.Item("hitchancew").GetValue <Slider>().Value + 2)
                        {
                            _w.Cast(poutput.CastPosition);
                        }
                    }
                }
            }

            if (user && _r.IsReady())
            {
                var ticks = _menu.Item("calcw").GetValue <Slider>().Value;

                var rtarget = TargetSelector.GetTarget(_r.Range, TargetSelector.DamageType.Magical);
                if (rtarget.IsValidTarget() && _menu.Item("rkill").GetValue <bool>())
                {
                    if (_mr + _mq + _mw * ticks + _ma * 3 + _mi + _guise >= rtarget.Health)
                    {
                        if (rtarget.Health > _mr + _ma * 2 + _mw * 2 && !rtarget.IsZombie)
                        {
                            if (_e.IsReady())
                            {
                                _e.CastOnUnit(Me);
                            }
                            _r.Cast();
                        }
                    }

                    if (Me.CountEnemiesInRange(_r.Range) >= _menu.Item("rcount").GetValue <Slider>().Value)
                    {
                        if (_e.IsReady())
                        {
                            _e.CastOnUnit(Me);
                        }

                        _r.Cast();
                    }
                }
            }
        }
Exemplo n.º 6
0
        public static void UseItems(Obj_AI_Hero target, Menu config, float comboDmg = 0f, bool cleanseSpell=false)
        {
            if (config.Item("hyd").GetValue<bool>() && player.BaseSkinName != "Renekton")
            {
                castHydra(target);
            }
            if (config.Item("ran").GetValue<bool>() && Items.HasItem(randuins.Id) && Items.CanUseItem(randuins.Id))
            {
                if (target != null && player.Distance(target) < randuins.Range &&
                    player.CountEnemiesInRange(randuins.Range) >= config.Item("ranmin").GetValue<Slider>().Value)
                {
                    Items.UseItem(randuins.Id);
                }
            }
            if (config.Item("odin").GetValue<bool>() && target != null && Items.HasItem(odins.Id) &&
                Items.CanUseItem(odins.Id))
            {
                var odinDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.OdingVeils);
                if (config.Item("odinonlyks").GetValue<bool>())
                {
                    if (odinDmg > target.Health)
                    {
                        odins.Cast(target);
                    }
                }
                else if (player.CountEnemiesInRange(odins.Range) >= config.Item("odinmin").GetValue<Slider>().Value ||
                         (Math.Max(comboDmg, odinDmg) > target.Health && player.HealthPercent<30 && player.Distance(target) < odins.Range &&
                          !CombatHelper.CheckCriticalBuffs(target)))
                {
                    odins.Cast();
                }
            }
            if (target != null && config.Item("bil").GetValue<bool>() && Items.HasItem(bilgewater.Id) &&
                Items.CanUseItem(bilgewater.Id))
            {
                var bilDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Bilgewater);
                if (config.Item("bilonlyks").GetValue<bool>())
                {
                    if (bilDmg > target.Health)
                    {
                        bilgewater.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("bilminr").GetValue<Slider>().Value &&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, bilDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50))
                {
                    bilgewater.Cast(target);
                }
            }
            if (target != null && config.Item("botr").GetValue<bool>() && Items.HasItem(botrk.Id) &&
                Items.CanUseItem(botrk.Id))
            {
                var botrDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Botrk);
                if (config.Item("botronlyks").GetValue<bool>())
                {
                    if (botrDmg > target.Health)
                    {
                        botrk.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("botrminr").GetValue<Slider>().Value &&
                          (player.Health / player.MaxHealth * 100f) <
                          config.Item("botrmyhealth").GetValue<Slider>().Value &&
                          (target.Health / target.MaxHealth * 100f) <
                          config.Item("botrenemyhealth").GetValue<Slider>().Value) ||
                         (IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, botrDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50))
                {
                    botrk.Cast(target);
                }
            }
            if (target != null && config.Item("hex").GetValue<bool>() && Items.HasItem(hexgun.Id) &&
                Items.CanUseItem(hexgun.Id))
            {
                var hexDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Hexgun);
                if (config.Item("hexonlyks").GetValue<bool>())
                {
                    if (hexDmg > target.Health)
                    {
                        hexgun.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("hexminr").GetValue<Slider>().Value &&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, hexDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50))
                {
                    hexgun.Cast(target);
                }
            }
            if (config.Item("Muramana").GetValue<bool>() &&
                ((!MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value < player.ManaPercent) ||
                 (MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value > player.ManaPercent)))
            {
                if (Muramana.IsOwned() && Muramana.IsReady())
                {
                    Muramana.Cast();
                }
                if (Muramana2.IsOwned() && Muramana2.IsReady())
                {
                    Muramana2.Cast();
                }
            }
            MuramanaTime = System.Environment.TickCount;
            if (config.Item("you").GetValue<bool>() && Items.HasItem(youmuu.Id) && Items.CanUseItem(youmuu.Id) &&
                target != null && player.Distance(target) < player.AttackRange + 50 && target.HealthPercent < 65)
            {
                youmuu.Cast();
            }

            if (Items.HasItem(frost.Id) && Items.CanUseItem(frost.Id) && target != null &&
                config.Item("frost").GetValue<bool>())
            {
                if (player.Distance(target) < frost.Range &&
                    (config.Item("frostmin").GetValue<Slider>().Value <= target.CountEnemiesInRange(225f) &&
                     ((target.Health / target.MaxHealth * 100f) < 40 && config.Item("frostlow").GetValue<bool>() ||
                      !config.Item("frostlow").GetValue<bool>())))
                {
                    frost.Cast(target);
                }
            }
            if (Items.HasItem(solari.Id) && Items.CanUseItem(solari.Id) && config.Item("solari").GetValue<bool>())
            {
                if ((config.Item("solariminally").GetValue<Slider>().Value <= player.CountAlliesInRange(solari.Range) &&
                     config.Item("solariminenemy").GetValue<Slider>().Value <= player.CountEnemiesInRange(solari.Range)) ||
                    ObjectManager.Get<Obj_AI_Hero>()
                        .FirstOrDefault(
                            h => h.IsAlly && !h.IsDead && solari.IsInRange(h) && CombatHelper.CheckCriticalBuffs(h)) !=
                    null)
                {
                    solari.Cast();
                }
            }
            if (Items.HasItem(mountain.Id) && Items.CanUseItem(mountain.Id) && config.Item("mountain").GetValue<bool>())
            {
                if (config.Item("castonme").GetValue<bool>() &&
                    (player.Health / player.MaxHealth * 100f) < config.Item("mountainmin").GetValue<Slider>().Value &&
                    (player.CountEnemiesInRange(700f) > 0 || CombatHelper.CheckCriticalBuffs(player)))
                {
                    mountain.Cast(player);
                    return;
                }
                var targ =
                    ObjectManager.Get<Obj_AI_Hero>()
                        .Where(
                            h =>
                                h.IsAlly && !h.IsMe && !h.IsDead && player.Distance(h) < mountain.Range &&
                                config.Item("mountainpriority" + h.ChampionName).GetValue<Slider>().Value > 0 &&
                                (h.Health / h.MaxHealth * 100f) < config.Item("mountainmin").GetValue<Slider>().Value);
                if (targ != null)
                {
                    var finaltarg =
                        targ.OrderByDescending(
                            t => config.Item("mountainpriority" + t.ChampionName).GetValue<Slider>().Value)
                            .ThenBy(t => t.Health)
                            .FirstOrDefault();
                    if (finaltarg != null &&
                        (finaltarg.CountEnemiesInRange(700f) > 0 || finaltarg.UnderTurret(true) ||
                         CombatHelper.CheckCriticalBuffs(finaltarg)))
                    {
                        mountain.Cast(finaltarg);
                    }
                }
            }
            if (config.Item("QSSEnabled").GetValue<bool>())
            {
                UseCleanse(config, cleanseSpell);
            }
        }
Exemplo n.º 7
0
        private static void Combo()
        {
            var target  = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
            var minR    = Config.Item("Min Targets For Ult").GetValue <Slider>().Value;
            var packets = Config.Item("Packets").GetValue <bool>();

            if (Q.IsReady() && target.IsValidTarget(Q.Range) && Config.SubMenu("Combo").Item("Use Q").GetValue <bool>() == true && !target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield))
            {
                Q.Cast(target, packets);
            }

            if (E.IsReady() && target.IsValidTarget(Q.Range) && target.HasBuff("RocketGrab") && Config.SubMenu("Combo").Item("Use E").GetValue <bool>() == true)
            {
                E.Cast();
                Orbwalking.ResetAutoAttackTimer();
                Player.IssueOrder(GameObjectOrder.AttackUnit, target);
            }

            if (E.IsReady() && target.IsValidTarget(Player.AttackRange) && Config.SubMenu("Combo").Item("Use E").GetValue <bool>() == true)
            {
                E.Cast();
                Orbwalking.ResetAutoAttackTimer();
                Player.IssueOrder(GameObjectOrder.AttackUnit, target);
            }

            if (R.IsReady() && target.IsValidTarget(R.Range) && Config.SubMenu("Combo").Item("Use R").GetValue <bool>() == true && Player.CountEnemiesInRange(R.Range) >= minR)
            {
                R.Cast(target, packets);
            }
        }
Exemplo n.º 8
0
        static void Game_OnUpdate(EventArgs args)
        {
            var feedmode  = A.Item("root.feedmode").GetValue <StringList>().SelectedIndex;
            var defaultto = A.Item("root.defaultto").GetValue <StringList>().SelectedIndex;

            Vector3 BotTurningPoint1 = new Vector3(12124, 1726, 52);
            Vector3 BotTurningPoint2 = new Vector3(13502, 3494, 51);

            Vector3 TopTurningPoint1 = new Vector3(1454, 11764, 53);
            Vector3 TopTurningPoint2 = new Vector3(3170, 13632, 53);

            Vector3 Dragon = new Vector3(10064, 4646, -71);
            Vector3 Baron  = new Vector3(4964, 10380, -71);

            Vector3 ChaosUniversal = new Vector3(14287f, 14383f, 172f);
            Vector3 OrderUniversal = new Vector3(417f, 469f, 182f);

            string[] MsgList = new[] { "wat", "how?", "What?", "how did you manage to do that?", "mate..", "-_-",
                                       "why?", "lag", "laaaaag", "oh my god this lag is unreal", "rito pls 500 ping", "god bless my ping",
                                       "if my ping was my iq i'd be 5 times smarter than einstein", "what's up with this lag?", "is the server lagging again?",
                                       "i call black magic", "( ͡° ͜ʖ ͡°)", "ツ" };

            if (IsDead)
            {
                if (!SaidDeadStuff && A.Item("root.chat2").GetValue <bool>())
                {
                    Random r = new Random();
                    Game.Say("/all " + MsgList[r.Next(0, 14)]);
                    SaidDeadStuff = true;
                }
            }

            if (Player.IsDead)
            {
                IsDead        = true;
                CycleStarted  = false;
                Point1Reached = false;
                Point2Reached = false;
            }
            else
            {
                IsDead        = false;
                SaidDeadStuff = false;

                CycleStarted = true;

                if (Player.InFountain())
                {
                    Point1Reached = false;
                    Point2Reached = false;
                }

                if (Player.Distance(BotTurningPoint1) <= 300 || Player.Distance(TopTurningPoint1) <= 300)
                {
                    Point1Reached = true;
                }
                if (Player.Distance(BotTurningPoint2) <= 300 || Player.Distance(TopTurningPoint2) <= 300)
                {
                    Point2Reached = true;
                }
            }

            if (A.Item("root.shouldfeed").GetValue <bool>())
            {
                if ((LastLaugh == 0 || LastLaugh < Game.Time) && A.Item("root.laugh").GetValue <bool>())
                {
                    LastLaugh = Game.Time + A.Item("root.laugh.delay").GetValue <Slider>().Value;
                    Game.Say("/laugh");
                }

                if (Ghost != SpellSlot.Unknown &&
                    Player.Spellbook.CanUseSpell(Ghost) == SpellState.Ready &&
                    A.Item("root.ghost").GetValue <bool>() &&
                    Player.InFountain())
                {
                    Player.Spellbook.CastSpell(Ghost);
                }

                if (Heal != SpellSlot.Unknown &&
                    Player.Spellbook.CanUseSpell(Heal) == SpellState.Ready &&
                    A.Item("root.heal").GetValue <bool>() &&
                    Player.IsMoving &&
                    Player.CountEnemiesInRange(1000) == 0)
                {
                    Player.Spellbook.CastSpell(Heal);
                }

                if (A.Item("root.items").GetValue <bool>() && Player.InShop())
                {
                    foreach (var item in Player.InventoryItems)
                    {
                        if (item.Id != ItemId.Boots_of_Speed &&
                            item.Id != ItemId.Boots_of_Mobility &&
                            //item.Id != ItemId.Boots_of_Mobility_Enchantment_Homeguard && -> apparently this shiet's been rekt since 5.23 rip D:
                            item.Id != ItemId.Amplifying_Tome &&
                            item.Id != ItemId.Aether_Wisp &&
                            item.Id != ItemId.Zeal &&
                            item.Id != ItemId.Runaans_Hurricane_Ranged_Only) // lol almost forgot this; that would've been fun
                        {
                            Player.SellItem(item.Slot);
                        }
                    }

                    if (Player.Gold >= 300 &&
                        !CheckForBoughtItem[0])
                    {
                        Player.BuyItem(ItemId.Boots_of_Speed);
                        CheckForBoughtItem[0] = true;
                    }
                    if (Player.Gold >= 600 &&
                        CheckForBoughtItem[0] &&
                        !CheckForBoughtItem[1])
                    {
                        Player.BuyItem(ItemId.Boots_of_Mobility);
                        CheckForBoughtItem[1] = true;
                    }

                    /*if (Player.Gold >= 475
                     *  && CheckForBoughtItem[1]
                     *  && !CheckForBoughtItem[2])
                     * {
                     *  Player.BuyItem(ItemId.Boots_of_Mobility_Enchantment_Homeguard);
                     *  CheckForBoughtItem[2] = true;
                     * }*/
                    if (Player.Gold >= 435 &&
                        CheckForBoughtItem[1] &&
                        !CheckForBoughtItem[2])
                    {
                        Player.BuyItem(ItemId.Amplifying_Tome);
                        CheckForBoughtItem[2] = true;
                    }
                    if (Player.Gold >= (415) &&
                        CheckForBoughtItem[2] &&
                        !CheckForBoughtItem[3])
                    {
                        Player.BuyItem(ItemId.Aether_Wisp);
                        CheckForBoughtItem[3] = true;
                    }
                    if (Player.Gold >= 1300 &&
                        CheckForBoughtItem[3] &&
                        !Items.HasItem((int)ItemId.Zeal, Player))
                    {
                        Player.BuyItem(ItemId.Zeal);
                    }
                    if (Player.Gold >= 1300 &&
                        CheckForBoughtItem[3] &&
                        Items.HasItem((int)ItemId.Zeal, Player))
                    {
                        Player.BuyItem(ItemId.Runaans_Hurricane_Ranged_Only);
                    }
                }


                switch (feedmode)
                {
                case 0:
                    if (HeroManager.Enemies.Where(x => x.IsValidTarget() && !x.IsDead).OrderBy(x => x.Distance(Player.Position)).FirstOrDefault().IsValidTarget())
                    {
                        Player.IssueOrder(GameObjectOrder.MoveTo,
                                          HeroManager.Enemies.Where(x => x.IsValidTarget() && !x.IsDead).OrderBy(x => x.Distance(Player.Position)).FirstOrDefault());
                    }
                    else
                    {
                        switch (defaultto)
                        {
                        case 0:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                                }
                                else if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                                }
                            }
                            else
                            {
                                if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                                }
                                else if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                                }
                            }
                        }
                        break;

                        case 1:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                                }
                                else if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                                }
                            }
                            else
                            {
                                if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                                }
                                else if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                                }
                            }
                        }
                        break;

                        case 2:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                            }
                            else
                            {
                                Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                            }
                        }
                        break;
                        }
                    }
                    break;

                case 1:
                {
                    if (Player.Team == GameObjectTeam.Order)
                    {
                        if (!Point1Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                        }
                        else if (!Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                        }
                        else if (Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                        }
                    }
                    else
                    {
                        if (!Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                        }
                        else if (!Point1Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                        }
                        else if (Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                        }
                    }
                }
                break;

                case 2:
                {
                    if (Player.Team == GameObjectTeam.Order)
                    {
                        Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                    }
                    else
                    {
                        Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                    }
                }
                break;

                case 3:
                {
                    if (Player.Team == GameObjectTeam.Order)
                    {
                        if (!Point1Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                        }
                        else if (!Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                        }
                        else if (Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                        }
                    }
                    else
                    {
                        if (!Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                        }
                        else if (!Point1Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                        }
                        else if (Point2Reached)
                        {
                            Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                        }
                    }
                }
                break;

                case 4:
                {
                    if ((LastChat == 0 || LastChat < Game.Time) && A.Item("root.chat").GetValue <bool>() &&
                        Player.Distance(Dragon) <= 300 &&
                        !Player.IsDead)
                    {
                        LastChat = Game.Time + A.Item("root.chat.delay").GetValue <Slider>().Value;
                        Game.Say("/all Come to dragon!");
                    }
                    Player.IssueOrder(GameObjectOrder.MoveTo, Dragon);
                }
                break;

                case 5:
                {
                    if ((LastChat == 0 || LastChat < Game.Time) && A.Item("root.chat").GetValue <bool>() &&
                        Player.Distance(Baron) <= 300 &&
                        !Player.IsDead)
                    {
                        LastChat = Game.Time + A.Item("root.chat.delay").GetValue <Slider>().Value;
                        Game.Say("/all Come to baron!");
                    }
                    Player.IssueOrder(GameObjectOrder.MoveTo, Baron);
                }
                break;

                case 6:
                {
                    if (HeroManager.Enemies.Where(x => x.IsValidTarget() && !x.IsDead).OrderBy(x => x.ChampionsKilled).LastOrDefault().IsValidTarget())
                    {
                        Player.IssueOrder(GameObjectOrder.MoveTo,
                                          HeroManager.Enemies.Where(x => x.IsValidTarget() && !x.IsDead).OrderBy(x => x.ChampionsKilled).LastOrDefault());
                    }
                    else
                    {
                        switch (defaultto)
                        {
                        case 0:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                                }
                                else if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                                }
                            }
                            else
                            {
                                if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                                }
                                else if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                                }
                            }
                        }
                        break;

                        case 1:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                                }
                                else if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                                }
                            }
                            else
                            {
                                if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                                }
                                else if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                                }
                            }
                        }
                        break;

                        case 2:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                            }
                            else
                            {
                                Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                            }
                        }
                        break;
                        }
                    }
                }
                break;

                case 7:
                {
                    if (HeroManager.Enemies.Where(x => x.IsValidTarget() && !x.IsDead &&
                                                  (x.ChampionName == "Katarina" || x.ChampionName == "Jhin" || x.ChampionName == "Vayne" || x.ChampionName == "Jinx" || x.ChampionName == "Xerath")
                                                  ).FirstOrDefault().IsValidTarget())
                    {
                        Player.IssueOrder(GameObjectOrder.MoveTo,
                                          HeroManager.Enemies.Where(x => x.IsValidTarget() && !x.IsDead &&
                                                                    (x.ChampionName == "Katarina" || x.ChampionName == "Jhin" || x.ChampionName == "Vayne" || x.ChampionName == "Jinx" || x.ChampionName == "Xerath")
                                                                    ).FirstOrDefault());
                    }
                    else
                    {
                        switch (defaultto)
                        {
                        case 0:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                                }
                                else if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                                }
                            }
                            else
                            {
                                if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint2);
                                }
                                else if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, BotTurningPoint1);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                                }
                            }
                        }
                        break;

                        case 1:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                                }
                                else if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                                }
                            }
                            else
                            {
                                if (!Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint2);
                                }
                                else if (!Point1Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, TopTurningPoint1);
                                }
                                else if (Point2Reached)
                                {
                                    Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                                }
                            }
                        }
                        break;

                        case 2:
                        {
                            if (Player.Team == GameObjectTeam.Order)
                            {
                                Player.IssueOrder(GameObjectOrder.MoveTo, ChaosUniversal);
                            }
                            else
                            {
                                Player.IssueOrder(GameObjectOrder.MoveTo, OrderUniversal);
                            }
                        }
                        break;
                        }
                    }
                }
                break;
                }
            }
        }
Exemplo n.º 9
0
        public static void UseItems(Obj_AI_Hero target)
        {
            if (player.BaseSkinName != "Renekton")
            {
                castHydra(target);
            }

            if (Items.HasItem(Zhonya.Id) && Items.CanUseItem(Zhonya.Id))
            {
                if (player.HealthPercent < 30 && ARAMSimulator.balance < -60)
                {
                    Items.UseItem(Zhonya.Id);
                }
            }
            if (Items.HasItem(locket.Id) && Items.CanUseItem(locket.Id))
            {
                if (player.HealthPercent < 80 && player.CountEnemiesInRange(550) > 0)
                {
                    Items.UseItem(locket.Id);
                }
            }
            if (Items.HasItem(randuins.Id) && Items.CanUseItem(randuins.Id))
            {
                if (player.Distance(target) < randuins.Range && player.Distance(target) > player.AttackRange + 100)
                {
                    Items.UseItem(randuins.Id);
                }
            }
            if (Items.HasItem(odins.Id) && Items.CanUseItem(odins.Id))
            {
                if (player.Distance(target) < odins.Range &&
                    (player.CountEnemiesInRange(odins.Range) > 1 ||
                     target.Health < Damage.GetItemDamage(player, target, Damage.DamageItems.OdingVeils)))
                {
                    Items.UseItem(odins.Id);
                }
            }
            if (Items.HasItem(bilgewater.Id) && Items.CanUseItem(bilgewater.Id))
            {
                bilgewater.Cast(target);
            }
            if (Items.HasItem(botrk.Id) && Items.CanUseItem(botrk.Id) && (player.Health < player.MaxHealth / 2 || Damage.GetItemDamage(player, target, Damage.DamageItems.Botrk) < target.Health))
            {
                botrk.Cast(target);
            }
            if (Items.HasItem(hexgun.Id) && Items.CanUseItem(hexgun.Id))
            {
                hexgun.Cast(target);
            }
            if (Items.HasItem(Dfg.Id) && Items.CanUseItem(Dfg.Id))
            {
                Dfg.Cast(target);
            }
            if (Items.HasItem(Bft.Id) && Items.CanUseItem(Bft.Id))
            {
                Bft.Cast(target);
            }
            if (Items.HasItem(youmuu.Id) && Items.CanUseItem(youmuu.Id) && player.Distance(target) < player.AttackRange + 50)
            {
                youmuu.Cast();
            }
        }
Exemplo n.º 10
0
 private void CastR(Obj_AI_Hero target)
 {
     if (R.IsReady() && !maoR &&
         player.Mana / player.MaxMana * 100 > config.Item("rmana", true).GetValue<Slider>().Value &&
         config.Item("user", true).GetValue<Slider>().Value <= target.CountEnemiesInRange(R.Range - 50))
     {
         R.Cast(config.Item("packets").GetValue<bool>());
     }
 }
Exemplo n.º 11
0
        static void HealUltManager(bool forceheal = false, bool forceult = false, Obj_AI_Hero target = null)
        {
            if (forceheal && target != null && W.IsReady() && Player.Distance(target) <= W.Range)
            {
                W.CastOnUnit(target);
                return;
            }
            if (forceult && target != null && R.IsReady() && Player.Distance(target) <= R.Range)
            {
                if (debug())
                {
                    Game.PrintChat("Forceult");
                }
                R.CastOnUnit(target);
                return;
            }

            if (GetBool("Healingon") && !GetBool("onlyhincdmg"))
            {
                var herolistheal = ObjectManager.Get<Obj_AI_Hero>()
                    .Where(
                        h =>
                            (h.IsAlly || h.IsMe) && !h.IsZombie && !h.IsDead && GetBool("heal" + h.ChampionName) &&
                            h.HealthPercent <= Getslider("hpct" + h.ChampionName) && Player.Distance(h) <= R.Range)
                    .OrderByDescending(i => i.IsMe)
                    .ThenBy(i => i.HealthPercent);
                
                if (W.IsReady())
                {
                    if (herolistheal.Contains(Player) && !Player.IsRecalling() && !Player.InFountain())
                    {
                        W.CastOnUnit(Player);
                        return;
                    }
                    else if (herolistheal.Any())
                    {
                        var hero = herolistheal.FirstOrDefault();

                        if (Player.Distance(hero) <= R.Range && !Player.IsRecalling() && !hero.IsRecalling() && !hero.InFountain())
                        {
                            W.CastOnUnit(hero);
                            return;
                        }
                    }
                }
            }

            if (GetBool("Ultingon") && !GetBool("onlyuincdmg"))
                {
                    Console.WriteLine(Player.HealthPercent);
                    var herolist = ObjectManager.Get<Obj_AI_Hero>()
                        .Where(
                            h =>
                                (h.IsAlly || h.IsMe) && !h.IsZombie && !h.IsDead &&
                                 GetBool("ult" + h.ChampionName) &&
                                h.HealthPercent <= Getslider("upct" + h.ChampionName) &&
                                Player.Distance(h) <= R.Range && Player.CountEnemiesInRange(500) > 0).OrderByDescending(i => i.IsMe).ThenBy(i => i.HealthPercent);

                    if (R.IsReady())
                    {
                        if (herolist.Contains(Player))
                        {
                        if (debug())
                        {
                            Game.PrintChat("regultself");
                        }
                        R.CastOnUnit(Player);
                            return;
                        }

                        else if (herolist.Any())
                        {
                            var hero = herolist.FirstOrDefault();

                            if (Player.Distance(hero) <= R.Range)
                            {
                            if (debug())
                            {
                                Game.PrintChat("regultotherorself");
                            }
                            R.CastOnUnit(hero);
                                return;
                            }
                        }
                    }
                }
            }
Exemplo n.º 12
0
        static void CastR(Obj_AI_Hero currenttarget)
        {
            var Check =
                HeroManager.Enemies
                .Where(
                    h => h.IsValidTarget(Spells["R"].Range) && h.CountEnemiesInRange(Spells["R"].Range) >= LissUtils.GetSlider("Combo.Rcount") && !LissUtils.Active("Blacklist." + h.ChampionName) && h.HealthPercent > LissUtils.GetSlider("Combo.MinRHealth")).ToList();

            if (Player.CountEnemiesInRange(Spells["R"].Range) >= LissUtils.GetSlider("Combo.Rcount"))
            {
                Check.Add(Player);
            }

            if (Check.Any())
            {
                if (Check.Contains(Player) && !LissUtils.isHealthy())
                {
                    Spells["R"].CastOnUnit(Player);
                    return;
                }
                var target = Check.MaxOrDefault(TargetSelector.GetPriority);
                if (target != null)
                {
                    Spells["R"].Cast(target);
                    return;
                }
            }

            if (LissUtils.Active("Blacklist." + currenttarget.ChampionName))
            {
                return;
            }

            if (currenttarget.IsKillableFromPoint(Player.ServerPosition) && Player.Distance(currenttarget) < Spells["R"].Range)
            {
                Spells["R"].Cast(currenttarget);
                return;
            }


            if (LissUtils.PointUnderAllyTurret(currenttarget.ServerPosition))
            {
                Spells["R"].Cast(currenttarget);
                return;
            }

            var dmgto = Player.GetSpellDamage(currenttarget, SpellSlot.R);

            if (dmgto > currenttarget.Health && currenttarget.Health >= 0.40 * dmgto)
            {
                Spells["R"].Cast(currenttarget);
                return;
            }

            var enemycount = LissUtils.GetSlider("Combo.Rcount");

            if (!LissUtils.isHealthy() && Player.CountEnemiesInRange(Spells["R"].Range - 100) >= enemycount)
            {
                Spells["R"].CastOnUnit(Player);
                return;
            }

            var possibilities = HeroManager.Enemies.Where(h => (h.IsValidTarget() && Vector3.Distance(h.ServerPosition, Player.ServerPosition) <= Spells["R"].Range || (h.IsKillableFromPoint(Player.ServerPosition) && h.IsValidTarget() && !h.IsInvulnerable)) && !LissUtils.Active("Blacklist." + h.ChampionName)).ToList();

            var arranged = possibilities.OrderByDescending(h => h.CountEnemiesInRange(Spells["R"].Range));

            if (LissUtils.Active("Misc.PrioritizeUnderTurret"))
            {
                var EnemyUnderTurret = arranged.Where(h => LissUtils.PointUnderAllyTurret(h.ServerPosition) && !h.IsInvulnerable);
                var Enemytofocus     = EnemyUnderTurret.MaxOrDefault(h => h.CountEnemiesInRange(Spells["R"].Range));
                if (Enemytofocus != null)
                {
                    Spells["R"].Cast(Enemytofocus);
                    return;
                }
            }
            var UltTarget = arranged.FirstOrDefault();

            if (UltTarget != null)
            {
                if (!LissUtils.isHealthy() &&
                    Player.CountEnemiesInRange(Spells["R"].Range) >
                    UltTarget.CountEnemiesInRange(Spells["R"].Range) + 1)
                {
                    Spells["R"].CastOnUnit(Player);
                    return;
                }
                Spells["R"].Cast(UltTarget);
            }
        }
Exemplo n.º 13
0
        private void Combo()
        {
            Obj_AI_Hero target = getTarget();

            if (target == null)
            {
                return;
            }
            if (config.Item("selected").GetValue <bool>())
            {
                target = CombatHelper.SetTarget(target, TargetSelector.GetSelectedTarget());
                orbwalker.ForceTarget(target);
            }
            var cmbDmg = GetComboDamage(target);

            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, cmbDmg);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && Orbwalking.CanMove(100) &&
                target.IsValidTarget() && !justJumped)
            {
                if (Program.IsSPrediction)
                {
                    Q.SPredictionCast(target, HitChance.High);
                    return;
                }
                else
                {
                    var targQ = Q.GetPrediction(target);
                    if (Q.Range - 100 > targQ.CastPosition.Distance(player.Position) &&
                        targQ.Hitchance >= HitChance.High)
                    {
                        Q.Cast(targQ.CastPosition);
                        return;
                    }
                }
            }
            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && Orbwalking.CanMove(100) && !justJumped &&
                (cmbDmg + player.GetAutoAttackDamage(target) > target.Health || player.Mana > Q.Instance.ManaCost * 2))
            {
                if (Program.IsSPrediction)
                {
                    W.SPredictionCast(target, HitChance.High);
                    return;
                }
                else
                {
                    var tarPered = W.GetPrediction(target);
                    if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position))
                    {
                        W.CastIfHitchanceEquals(target, HitChance.High);
                        return;
                    }
                }
            }
            if (R.IsReady() && !justJumped)
            {
                var dist = player.Distance(target);
                if (config.Item("user", true).GetValue <bool>() && !justQ && !Q.CanCast(target) && !justW &&
                    !W.CanCast(target) && !CombatHelper.CheckCriticalBuffs(target) &&
                    config.Item("usermin", true).GetValue <Slider>().Value < dist && 3000 > dist &&
                    target.Health < R.GetDamage(target) * 0.7 && target.CountAlliesInRange(600) < 1)
                {
                    R.CastIfHitchanceEquals(target, HitChance.High);
                }
                if (target.CountAlliesInRange(700) > 0)
                {
                    R.CastIfWillHit(target, config.Item("usertf", true).GetValue <Slider>().Value);
                }
            }
            bool canKill = cmbDmg > target.Health;

            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() &&
                ((config.Item("useekill", true).GetValue <bool>() && canKill) ||
                 (!config.Item("useekill", true).GetValue <bool>() &&
                  (target.CountEnemiesInRange(1200) <= target.CountAlliesInRange(1200) && player.Health > target.Health &&
                   TargetSelector.GetPriority(target) >= 2f) || canKill)))
            {
                var bestPositons =
                    (from pos in
                     CombatHelper.PointsAroundTheTarget(target.Position, 750)
                     .Where(
                         p =>
                         !p.IsWall() && p.IsValid() && p.Distance(player.Position) < E.Range &&
                         p.Distance(target.Position) < 680 && !p.UnderTurret(true))
                     let mob =
                         ObjectManager.Get <Obj_AI_Base>()
                         .Where(
                             m =>
                             m.IsEnemy && m.IsValidTarget() && m.Distance(target.Position) < 750 &&
                             m.SkinName != target.SkinName)
                         .OrderBy(m => m.Distance(pos))
                         .FirstOrDefault()
                         where (mob != null && mob.Distance(pos) > pos.Distance(target.Position) + 80) || (mob == null)
                         select pos).ToList();

                CastE(bestPositons, target);
            }
            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 > target.Health && hasIgnite &&
                !player.IsChannelingImportantSpell() && !justQ && !Q.CanCast(target) && !justW && !W.CanCast(target) &&
                !justJumped)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
        }
Exemplo n.º 14
0
        private void Combo()
        {
            Obj_AI_Hero target = DrawHelper.GetBetterTarget(1700, TargetSelector.DamageType.Magical, true);

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            var  edmg      = getEdamage(target);
            var  qdmg      = getQdamage(target);
            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) &&
                (!ActiveQ ||
                 (!(CombatHelper.IsFacing(player, target.Position, 30) && target.Distance(player) < Q.Range))))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && Qhit(target.Position) &&
                (preventSilence(Q) ||
                 (target.Health < PassiveDmg(target) * 2 || qdmg > target.Health) &&
                 target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target)))
            {
                Q.Cast(target.Position);
            }
            if (config.Item("usee", true).GetValue <bool>() && E.CanCast(target) &&
                (((preventSilence(E) ||
                   (target.Health < PassiveDmg(target) * 2 &&
                    target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target))) &&
                  (!ActiveE ||
                   System.Environment.TickCount - lastE > config.Item("eDelay", true).GetValue <Slider>().Value)) ||
                 edmg > target.Health))
            {
                E.CastIfHitchanceEquals(target, HitChance.High);
            }
            if (W.IsReady() && config.Item("wSpeed", true).GetValue <bool>() && ActiveQ && preventSilence(W) &&
                target.Distance(player) < Q.Range &&
                Prediction.GetPrediction(target, 0.2f).UnitPosition.Distance(player.Position) > Q.Range)
            {
                W.Cast();
            }
            var canR = ComboDamage(target) > target.Health && qdmg < target.Health && target.Distance(player) < Q.Range &&
                       !Silenced;

            if (R.IsReady() &&
                (((target.Health <
                   getRdamage(target) * ((target.CountAlliesInRange(600) > 0 && target.HealthPercent > 15) ? 5 : 3) &&
                   target.Distance(player) > Q.Range) ||
                  (target.Distance(player) < Q.Range && target.Health < getRdamage(target) * 3 + edmg &&
                   target.Health > qdmg)) ||
                 player.CountEnemiesInRange(R.Range) >= config.Item("Rmin", true).GetValue <Slider>().Value))
            {
                HandleR(target, canR);
            }
        }
Exemplo n.º 15
0
        private void Combo(Obj_AI_Hero target, float cmbDmg, bool canKill, bool bush)
        {
            if (target == null || !target.IsValidTarget())
            {
                return;
            }

            if (config.Item("useItems").GetValue<bool>())
            {
                ItemHandler.UseItems(target, config);
            }
            if (config.Item("usew", true).GetValue<bool>() && W.IsReady() && W.CanCast(target))
            {
                var tarPered = W.GetPrediction(target);
                if (justE && ePos.IsValid() && target.Distance(ePos) < 375)
                {
                    if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
                        tarPered.Hitchance >= HitChance.High)
                    {
                        W.Cast(target.Position, config.Item("packets").GetValue<bool>());
                    }
                }
                else
                {
                    if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
                        tarPered.Hitchance >= HitChance.VeryHigh)
                    {
                        W.Cast(tarPered.CastPosition, config.Item("packets").GetValue<bool>());
                    }
                }
            }
            if (config.Item("usee", true).GetValue<bool>() && E.IsReady() &&
                (((canKill && config.Item("useekill", true).GetValue<bool>()) ||
                  (!config.Item("useekill", true).GetValue<bool>() && CheckMana())) ||
                 config.Item("startWithE", true).GetValue<bool>()))
            {
                switch (config.Item("eType", true).GetValue<StringList>().SelectedIndex)
                {
                    case 0:
                        CastE(target);
                        return;
                    case 1:
                        CastE(target, false);
                        return;
                        break;
                }
            }
            if (config.Item("useq", true).GetValue<bool>() && Q.IsReady() && Q.CanCast(target) && target.IsValidTarget() &&
                !bush && !Estun)
            {
                CastQHero(target);
            }
            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 > target.Health && hasIgnite && !player.IsChannelingImportantSpell() && !justQ &&
                  !Q.CanCast(target) && !justR && !R.CanCast(target) && CheckW(target)) || IgniteTarget != null))
            {
                if (IgniteTarget != null)
                {
                    player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), IgniteTarget);
                    return;
                }
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            var castR = false;
            if (target.CountEnemiesInRange(2000) == 1)
            {
                castR = true;
            }
            else if (!config.Item("ult" + target.SkinName, true).GetValue<bool>())
            {
                castR = true;
            }
            if (R.IsReady() && R.CanCast(target) && config.Item("user", true).GetValue<bool>() &&  castR &&
                R.Instance.ManaCost < player.Mana && !target.Buffs.Any(b => CombatHelper.invulnerable.Contains(b.Name)) &&
                !CombatHelper.CheckCriticalBuffs(target))
            {
                if (config.Item("userPred", true).GetValue<bool>())
                {
                    var Whit = wPos.IsValid() && System.Environment.TickCount - wTime > 700 &&
                               Prediction.GetPrediction(target, 0.55f).UnitPosition.Distance(wPos) < W.Width;
                    var targetHP = HealthPrediction.GetHealthPrediction(target, 400);

                    var killWithIgnite = hasIgnite && config.Item("useIgnite", true).GetValue<bool>() &&
                                         R.GetDamage(target) + ignitedmg > targetHP && targetHP > R.GetDamage(target);

                    var killWithW = wPos != null && Whit && R.GetDamage(target) + W.GetDamage(target) > targetHP &&
                                    target.Health > R.GetDamage(target);

                    var killWithIgniteAndW = !killWithW && Whit && hasIgnite &&
                                             config.Item("useIgnite", true).GetValue<bool>() &&
                                             R.GetDamage(target) + W.GetDamage(target) + ignitedmg > targetHP &&
                                             targetHP > R.GetDamage(target) + W.GetDamage(target);

                    if (killWithW || (targetHP < R.GetDamage(target) && !justQ && CheckW(target)))
                    {
                        R.CastOnUnit(target, config.Item("packets").GetValue<bool>());
                    }

                    if ((killWithIgnite || killWithIgniteAndW) && CheckW(target))
                    {
                        R.CastOnUnit(target, config.Item("packets").GetValue<bool>());
                        IgniteTarget = target;
                        Utility.DelayAction.Add(500, () => IgniteTarget = null);
                    }
                }
                else
                {
                    if (target.Health < R.GetDamage(target))
                    {
                        R.CastOnUnit(target, config.Item("packets").GetValue<bool>());
                    }
                }
            }
        }
Exemplo n.º 16
0
        private void RLogic()
        {
            Obj_AI_Hero target = null;

            if (TargetSelector.GetSelectedTarget() != null &&
                TargetSelector.GetSelectedTarget().DistanceToPlayer() <=
                Menu.Item("RMenuMax", true).GetValue <Slider>().Value)
            {
                target = TargetSelector.GetSelectedTarget();
            }
            else
            {
                target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
            }

            if (R.IsReady() && CheckTarget(target, R.Range))
            {
                if (R.Instance.Name == "JhinR")
                {
                    if (Menu.Item("RMenuSemi", true).GetValue <KeyBind>().Active)
                    {
                        R.Cast(R.GetPrediction(target).UnitPosition, true);
                    }

                    if (!Menu.Item("RMenuAuto", true).GetValue <bool>())
                    {
                        return;
                    }

                    if (Menu.Item("RMenuCheck", true).GetValue <bool>() && Me.CountEnemiesInRange(800f) > 0)
                    {
                        return;
                    }

                    if (target.DistanceToPlayer() <= Menu.Item("RMenuMin", true).GetValue <Slider>().Value)
                    {
                        return;
                    }

                    if (target.DistanceToPlayer() > Menu.Item("RMenuMax", true).GetValue <Slider>().Value)
                    {
                        return;
                    }

                    if (target.Health > Me.GetSpellDamage(target, SpellSlot.R) * Menu.Item("RMenuKill", true).GetValue <Slider>().Value)
                    {
                        return;
                    }

                    R.Cast(R.GetPrediction(target).UnitPosition, true);
                }

                if (R.Instance.Name == "JhinRShot")
                {
                    foreach (var t in HeroManager.Enemies.Where(x => x.IsValidTarget(R.Range) && InRCone(x)))
                    {
                        if (!InRCone(t))
                        {
                            return;
                        }

                        if (Menu.Item("RMenuSemi", true).GetValue <KeyBind>().Active)
                        {
                            AutoUse(t);
                            R.Cast(R.GetPrediction(t).UnitPosition, true);
                        }

                        if (Menu.Item("ComboR", true).GetValue <bool>() &&
                            Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                        {
                            AutoUse(t);
                            R.Cast(R.GetPrediction(t).UnitPosition, true);
                        }

                        if (!Menu.Item("RMenuAuto", true).GetValue <bool>())
                        {
                            return;
                        }

                        AutoUse(t);
                        R.Cast(R.GetPrediction(t).UnitPosition, true);
                    }
                }
            }
        }
Exemplo n.º 17
0
 public int enemiesInRange(Obj_AI_Hero obj, float range)
 {
     return obj.CountEnemiesInRange(range);
 }
Exemplo n.º 18
0
        public static void CastBestLine(bool forceUlt, Spell spell, Spell spell2, int midPointRange, Menu menu, float extraPrerange = 1, bool wallCheck = true)
        {
            if (!spell.IsReady())
            {
                return;
            }

            int     maxHit = 0;
            Vector3 start  = Vector3.Zero;
            Vector3 end    = Vector3.Zero;

            //loop one
            foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range)))
            {
                //loop 2
                var target1 = target;
                var target2 = target;
                foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target1.NetworkId &&
                                                                              x.Distance(target1.Position) < spell2.Range - 100).OrderByDescending(x => x.Distance(target2.Position)))
                {
                    int hit = 2;

                    var targetPred = Prediction.GetPrediction(target, spell.Delay);
                    var enemyPred  = Prediction.GetPrediction(enemy, spell.Delay);

                    var midpoint = (enemyPred.CastPosition + targetPred.CastPosition) / 2;

                    var startpos = midpoint + Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
                    var endPos   = midpoint - Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;

                    Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(startpos, endPos, spell.Width);

                    if (!rec1.Points.Exists(Util.IsWall) && Player.CountEnemiesInRange(spell.Range + spell2.Range) > 2)
                    {
                        //loop 3
                        var target3 = target;
                        var enemy1  = enemy;
                        foreach (var enemy2 in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target3.NetworkId && x.NetworkId != enemy1.NetworkId && x.Distance(target3.Position) < 1000))
                        {
                            var      enemy2Pred = Prediction.GetPrediction(enemy2, spell.Delay);
                            Object[] obj        = Util.VectorPointProjectionOnLineSegment(startpos.To2D(), endPos.To2D(), enemy2Pred.CastPosition.To2D());
                            var      isOnseg    = (bool)obj[2];
                            var      pointLine  = (Vector2)obj[1];

                            if (pointLine.Distance(enemy2Pred.CastPosition.To2D()) < spell.Width && isOnseg)
                            {
                                hit++;
                            }
                        }
                    }

                    if (hit > maxHit && hit > 1 && !rec1.Points.Exists(Util.IsWall))
                    {
                        maxHit = hit;
                        start  = startpos;
                        end    = endPos;
                    }
                }
            }

            if (start != Vector3.Zero && end != Vector3.Zero && spell.IsReady())
            {
                spell2.UpdateSourcePosition(start, start);
                if (forceUlt)
                {
                    CastLineSpell(start, end);
                }
                if (menu.Item("ComboActive", true).GetValue <KeyBind>().Active&& maxHit >= menu.Item("Line_If_Enemy_Count_Combo", true).GetValue <Slider>().Value)
                {
                    CastLineSpell(start, end);
                }
                if (maxHit >= menu.Item("Line_If_Enemy_Count", true).GetValue <Slider>().Value)
                {
                    CastLineSpell(start, end);
                }
            }

            //check if only one target
            if (forceUlt)
            {
                CastSingleLine(spell, spell2, wallCheck, extraPrerange);
            }
        }
Exemplo n.º 19
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(700, TargetSelector.DamageType.Physical);

            if (target == null)
            {
                return;
            }
            var combodamage = ComboDamage(target);

            if (config.Item("useItems").GetValue <bool>() && !GarenQ)
            {
                ItemHandler.UseItems(target, config, combodamage);
            }
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (config.Item("useIgnite").GetValue <bool>() && hasIgnite &&
                ((R.IsReady() && ignitedmg + R.GetDamage(target) > target.Health) || ignitedmg > target.Health) &&
                (target.Distance(player) > E.Range || player.HealthPercent < 20))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() &&
                player.Distance(target) > player.AttackRange && !GarenE && !GarenQ &&
                player.Distance(target) > Orbwalking.GetRealAutoAttackRange(target) &&
                CombatHelper.IsPossibleToReachHim(target, 0.30f, new float[5] {
                1.5f, 2f, 2.5f, 3f, 3.5f
            }[Q.Level - 1]))
            {
                Q.Cast(config.Item("packets").GetValue <bool>());
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && !GarenQ &&
                (!GarenE || (Q.IsReady() && Damage.GetSpellDamage(player, target, SpellSlot.Q) > target.Health)))
            {
                if (GarenE)
                {
                    E.Cast(config.Item("packets").GetValue <bool>());
                }
                Q.Cast(config.Item("packets").GetValue <bool>());
                player.IssueOrder(GameObjectOrder.AutoAttack, target);
            }
            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() && !Q.IsReady() && !GarenQ && !GarenE &&
                player.CountEnemiesInRange(E.Range) > 0)
            {
                E.Cast(config.Item("packets").GetValue <bool>());
            }
            var targHP = target.Health + 20 - CombatHelper.IgniteDamage(target);
            var rLogic = config.Item("user", true).GetValue <bool>() && R.IsReady() && target.IsValidTarget() &&
                         (!config.Item("ult" + target.SkinName, true).GetValue <bool>() ||
                          player.CountEnemiesInRange(1500) == 1) && getRDamage(target) > targHP && targHP > 0;

            if (rLogic && target.Distance(player) < R.Range)
            {
                if (!(GarenE && target.Health < getEDamage(target, true) && target.Distance(player) < E.Range))
                {
                    if (GarenE)
                    {
                        E.Cast(config.Item("packets").GetValue <bool>());
                    }
                    else
                    {
                        R.Cast(target, config.Item("packets").GetValue <bool>());
                    }
                }
            }
            var data = Program.IncDamages.GetAllyData(player.NetworkId);

            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && target.IsFacing(player) &&
                data.DamageTaken > 40)
            {
                W.Cast(config.Item("packets").GetValue <bool>());
            }
            bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;

            if (config.Item("useFlash", true).GetValue <bool>() && hasFlash && rLogic &&
                target.Distance(player) < R.Range + 425 && target.Distance(player) > R.Range + 250 && !Q.IsReady() &&
                !CombatHelper.IsFacing(target, player.Position) && !GarenQ)
            {
                if (target.Distance(player) < R.Range + 300 && player.MoveSpeed > target.MoveSpeed)
                {
                    return;
                }
                if (GarenE)
                {
                    E.Cast(config.Item("packets").GetValue <bool>());
                }
                else if (!player.Position.Extend(target.Position, 425f).IsWall())
                {
                }
                {
                    player.Spellbook.CastSpell(
                        player.GetSpellSlot("SummonerFlash"), player.Position.Extend(target.Position, 425f));
                }
            }
        }
Exemplo n.º 20
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 &&
                            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;
                    }
                }
            }

            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() && player.Distance(target) < E.Range && !justE &&
                target.Health > Q.GetDamage(target) + player.GetAutoAttackDamage(target) && Orbwalking.CanMove(100) &&
                config.Item("eStacksC", true).GetValue <Slider>().Value < E.Instance.Ammo)
            {
                CastE(target, barrels);
            }
            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);
                }
            }
        }
Exemplo n.º 21
0
        public static void UseItems(Obj_AI_Hero target, Menu config, float comboDmg = 0f, bool cleanseSpell = false)
        {
            if (config.Item("hyd").GetValue <bool>() && player.BaseSkinName != "Renekton")
            {
                castHydra(target);
            }
            if (config.Item("ran").GetValue <bool>() && Items.HasItem(randuins.Id) && Items.CanUseItem(randuins.Id))
            {
                if (target != null && player.Distance(target) < randuins.Range &&
                    player.CountEnemiesInRange(randuins.Range) >= config.Item("ranmin").GetValue <Slider>().Value)
                {
                    Items.UseItem(randuins.Id);
                }
            }
            if (config.Item("odin").GetValue <bool>() && target != null && Items.HasItem(odins.Id) &&
                Items.CanUseItem(odins.Id))
            {
                var odinDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.OdingVeils);
                if (config.Item("odinonlyks").GetValue <bool>())
                {
                    if (odinDmg > target.Health)
                    {
                        odins.Cast(target);
                    }
                }
                else if (player.CountEnemiesInRange(odins.Range) >= config.Item("odinmin").GetValue <Slider>().Value ||
                         (Math.Max(comboDmg, odinDmg) > target.Health && player.HealthPercent < 30 && player.Distance(target) < odins.Range &&
                          !CombatHelper.CheckCriticalBuffs(target)))
                {
                    odins.Cast();
                }
            }
            if (target != null && config.Item("bil").GetValue <bool>() && Items.HasItem(bilgewater.Id) &&
                Items.CanUseItem(bilgewater.Id))
            {
                var bilDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Bilgewater);
                if (config.Item("bilonlyks").GetValue <bool>())
                {
                    if (bilDmg > target.Health)
                    {
                        bilgewater.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("bilminr").GetValue <Slider>().Value&&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, bilDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50))
                {
                    bilgewater.Cast(target);
                }
            }
            if (target != null && config.Item("botr").GetValue <bool>() && Items.HasItem(botrk.Id) &&
                Items.CanUseItem(botrk.Id))
            {
                var botrDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Botrk);
                if (config.Item("botronlyks").GetValue <bool>())
                {
                    if (botrDmg > target.Health)
                    {
                        botrk.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("botrminr").GetValue <Slider>().Value&&
                          (player.Health / player.MaxHealth * 100f) <
                          config.Item("botrmyhealth").GetValue <Slider>().Value&&
                          (target.Health / target.MaxHealth * 100f) <
                          config.Item("botrenemyhealth").GetValue <Slider>().Value) ||
                         (IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, botrDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50))
                {
                    botrk.Cast(target);
                }
            }
            if (target != null && config.Item("hex").GetValue <bool>() && Items.HasItem(hexgun.Id) &&
                Items.CanUseItem(hexgun.Id))
            {
                var hexDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Hexgun);
                if (config.Item("hexonlyks").GetValue <bool>())
                {
                    if (hexDmg > target.Health)
                    {
                        hexgun.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("hexminr").GetValue <Slider>().Value&&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, hexDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50))
                {
                    hexgun.Cast(target);
                }
            }
            if (config.Item("Muramana").GetValue <bool>() &&
                ((!MuramanaEnabled && config.Item("MuramanaMinmana").GetValue <Slider>().Value < player.ManaPercent) ||
                 (MuramanaEnabled && config.Item("MuramanaMinmana").GetValue <Slider>().Value > player.ManaPercent)))
            {
                if (Muramana.IsOwned() && Muramana.IsReady())
                {
                    Muramana.Cast();
                }
                if (Muramana2.IsOwned() && Muramana2.IsReady())
                {
                    Muramana2.Cast();
                }
            }
            MuramanaTime = System.Environment.TickCount;
            if (config.Item("you").GetValue <bool>() && Items.HasItem(youmuu.Id) && Items.CanUseItem(youmuu.Id) &&
                target != null && player.Distance(target) < player.AttackRange + 50 && target.HealthPercent < 65)
            {
                youmuu.Cast();
            }

            if (Items.HasItem(frost.Id) && Items.CanUseItem(frost.Id) && target != null &&
                config.Item("frost").GetValue <bool>())
            {
                if (player.Distance(target) < frost.Range &&
                    (config.Item("frostmin").GetValue <Slider>().Value <= target.CountEnemiesInRange(225f) &&
                     ((target.Health / target.MaxHealth * 100f) < 40 && config.Item("frostlow").GetValue <bool>() ||
                      !config.Item("frostlow").GetValue <bool>())))
                {
                    frost.Cast(target);
                }
            }
            if (Items.HasItem(solari.Id) && Items.CanUseItem(solari.Id) && config.Item("solari").GetValue <bool>())
            {
                if ((config.Item("solariminally").GetValue <Slider>().Value <= player.CountAlliesInRange(solari.Range) &&
                     config.Item("solariminenemy").GetValue <Slider>().Value <= player.CountEnemiesInRange(solari.Range)) ||
                    ObjectManager.Get <Obj_AI_Hero>()
                    .FirstOrDefault(
                        h => h.IsAlly && !h.IsDead && solari.IsInRange(h) && CombatHelper.CheckCriticalBuffs(h)) !=
                    null)
                {
                    solari.Cast();
                }
            }
            if (Items.HasItem(mountain.Id) && Items.CanUseItem(mountain.Id) && config.Item("mountain").GetValue <bool>())
            {
                if (config.Item("castonme").GetValue <bool>() &&
                    (player.Health / player.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value&&
                    (player.CountEnemiesInRange(700f) > 0 || CombatHelper.CheckCriticalBuffs(player)))
                {
                    mountain.Cast(player);
                    return;
                }
                var targ =
                    ObjectManager.Get <Obj_AI_Hero>()
                    .Where(
                        h =>
                        h.IsAlly && !h.IsMe && !h.IsDead && player.Distance(h) < mountain.Range &&
                        config.Item("mountainpriority" + h.ChampionName).GetValue <Slider>().Value > 0 &&
                        (h.Health / h.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value);
                if (targ != null)
                {
                    var finaltarg =
                        targ.OrderByDescending(
                            t => config.Item("mountainpriority" + t.ChampionName).GetValue <Slider>().Value)
                        .ThenBy(t => t.Health)
                        .FirstOrDefault();
                    if (finaltarg != null &&
                        (finaltarg.CountEnemiesInRange(700f) > 0 || finaltarg.UnderTurret(true) ||
                         CombatHelper.CheckCriticalBuffs(finaltarg)))
                    {
                        mountain.Cast(finaltarg);
                    }
                }
            }
            if (config.Item("QSSEnabled").GetValue <bool>())
            {
                UseCleanse(config, cleanseSpell);
            }
        }
Exemplo n.º 22
0
 public int enemiesInRange(Obj_AI_Hero obj, float range)
 {
     return(obj.CountEnemiesInRange(range));
 }
Exemplo n.º 23
0
        private static void KillSteal()
        {
            Obj_AI_Hero target = HeroList
                                 .Where(x => x.IsValidTarget() && x.Distance(Player.Position) < 1000f && !x.IsZombie)
                                 .MinOrDefault(x => x.Health);


            if (target != null)
            {
                if (Config.Item("UseIgnite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
                    Player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
                {
                    double igniteDmg = Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
                    if (igniteDmg > target.Health)
                    {
                        Player.Spellbook.CastSpell(IgniteSlot, target);
                        return;
                    }
                }

                if (Config.Item("autoescape").GetValue <bool>() && !ishealthy())
                {
                    var ally =
                        HeroList.FirstOrDefault(h => h.HealthPercent > 50 && h.CountEnemiesInRange(400) == 0 && !PointUnderEnemyTurret(h.ServerPosition));
                    if (ally != null && ally.IsValid)
                    {
                        E.Cast(ally.ServerPosition);
                        return;
                    }
                    var objAiturret = EnemyTurretPositions.Where(x => Vector3.Distance(Player.ServerPosition, x) <= 900f);
                    if (objAiturret.Any() || Player.CountEnemiesInRange(500) >= 1)
                    {
                        var bestposition = Player.ServerPosition.Extend(NexusPosition, E.Range);
                        E.Cast(bestposition);
                        return;
                    }
                }

                if (Config.Item("UseQKs").GetValue <bool>() && Q.IsReady() &&
                    Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= Q.Range)
                {
                    double QDmg = GetQDamage(target);
                    if (!Jumping && target.Health <= QDmg)
                    {
                        Q.Cast(target);
                        return;
                    }
                }

                if (Config.Item("UseEKs").GetValue <bool>() && E.IsReady() &&
                    Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= E.Range && Vector3.Distance(Player.ServerPosition, target.ServerPosition) > Q.Range)
                {
                    double EDmg = Player.GetSpellDamage(target, SpellSlot.E);
                    if (!Jumping && target.Health < EDmg)
                    {
                        Utility.DelayAction.Add(
                            Game.Ping + Config.Item("EDelay").GetValue <Slider>().Value, delegate
                        {
                            PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValid && !target.IsDead)
                            {
                                E.Cast(pred.CastPosition);
                            }
                        });
                    }
                }

                if (W.IsReady() && Wnorm && Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= W.Range &&
                    Config.Item("UseWKs").GetValue <bool>())
                {
                    double WDmg = Player.GetSpellDamage(target, SpellSlot.W);
                    if (target.Health <= WDmg)
                    {
                        var pred = W.GetPrediction(target);
                        if (pred.Hitchance >= HitChance.Medium)
                        {
                            W.Cast(pred.CastPosition);
                            return;
                        }
                    }
                }

                if (W.IsReady() && Wevolved &&
                    Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= W.Range &&
                    Config.Item("UseWKs").GetValue <bool>())
                {
                    double           WDmg = Player.GetSpellDamage(target, SpellSlot.W);
                    PredictionOutput pred = W.GetPrediction(target);
                    if (target.Health <= WDmg && pred.Hitchance > HitChance.Medium)
                    {
                        CastWE(target, pred.UnitPosition.To2D());
                        return;
                    }

                    if (pred.Hitchance >= HitChance.Collision)
                    {
                        List <Obj_AI_Base> PCollision = pred.CollisionObjects;
                        var x =
                            PCollision
                            .FirstOrDefault(PredCollisionChar => Vector3.Distance(PredCollisionChar.ServerPosition, target.ServerPosition) <= 30);
                        if (x != null)
                        {
                            W.Cast(x.Position);
                            return;
                        }
                    }
                }


                // Mixed's EQ KS
                if (Q.IsReady() && E.IsReady() &&
                    Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= E.Range + Q.Range &&
                    Config.Item("UseEQKs").GetValue <bool>())
                {
                    double QDmg = GetQDamage(target);
                    double EDmg = Player.GetSpellDamage(target, SpellSlot.E);
                    if ((target.Health <= QDmg + EDmg))
                    {
                        Utility.DelayAction.Add(Config.Item("EDelay").GetValue <Slider>().Value, delegate
                        {
                            PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValidTarget() && !target.IsZombie)
                            {
                                E.Cast(pred.CastPosition);
                            }
                        });
                    }
                }

                // MIXED EW KS
                if (W.IsReady() && E.IsReady() && Wnorm &&
                    Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= W.Range + E.Range &&
                    Config.Item("UseEWKs").GetValue <bool>())
                {
                    double WDmg = Player.GetSpellDamage(target, SpellSlot.W);
                    if (target.Health <= WDmg)
                    {
                        Utility.DelayAction.Add(Config.Item("EDelay").GetValue <Slider>().Value, delegate
                        {
                            PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValid && !target.IsDead)
                            {
                                E.Cast(pred.CastPosition);
                            }
                        });
                    }
                }


                if (Tiamat.IsReady() &&
                    Vector2.Distance(Player.ServerPosition.To2D(), target.ServerPosition.To2D()) <= Tiamat.Range &&
                    Config.Item("UseTiamatKs").GetValue <bool>())
                {
                    double Tiamatdmg = Player.GetItemDamage(target, Damage.DamageItems.Tiamat);
                    if (target.Health <= Tiamatdmg)
                    {
                        Tiamat.Cast();
                        return;
                    }
                }
                if (Hydra.IsReady() &&
                    Vector2.Distance(Player.ServerPosition.To2D(), target.ServerPosition.To2D()) <= Hydra.Range &&
                    Config.Item("UseTiamatKs").GetValue <bool>())
                {
                    double hydradmg = Player.GetItemDamage(target, Damage.DamageItems.Hydra);
                    if (target.Health <= hydradmg)
                    {
                        Hydra.Cast();
                    }
                }
            }
        }
Exemplo n.º 24
0
        private void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (sender.IsMe)
            {
                if (args.SData.Name == "KalistaExpungeWrapper")
                {
                    lastecast = Game.Time;
                    Orbwalking.ResetAutoAttackTimer();
                }
                if (args.SData.Name == "kalistaw")
                {
                    wCount++;
                }
            }

            if (R.IsReady() && sender.IsAlly && args.SData.Name == "RocketGrab" && Player.Distance(sender.Position) < R.Range && Player.Distance(sender.Position) > Config.Item("rangeBalista", true).GetValue <Slider>().Value)
            {
                grabTime = Game.Time;
            }

            if (!sender.IsEnemy || sender.IsMinion)
            {
                return;
            }

            if (E.IsReady() && Config.Item("Edead", true).GetValue <bool>() && sender.IsValidTarget(1500))
            {
                double dmg = 0;

                if (args.Target != null && args.Target.IsMe)
                {
                    dmg = dmg + sender.GetSpellDamage(Player, args.SData.Name);
                }
                else
                {
                    var castArea = Player.Distance(args.End) * (args.End - Player.ServerPosition).Normalized() + Player.ServerPosition;
                    if (castArea.Distance(Player.ServerPosition) < Player.BoundingRadius / 2)
                    {
                        dmg = dmg + sender.GetSpellDamage(Player, args.SData.Name);
                    }
                }

                if (Player.Health - dmg < (Player.CountEnemiesInRange(600) * Player.Level * 10) + (Player.Level * 10))
                {
                    CastE();
                }
            }
            if (R.IsReady())
            {
                if (AllyR != null && AllyR.IsVisible && AllyR.Distance(Player.Position) < R.Range)
                {
                    if (AllyR.Health < AllyR.CountEnemiesInRange(600) * AllyR.Level * 30)
                    {
                        R.Cast();
                    }
                    double dmg = 0;

                    if (args.Target != null && args.Target.NetworkId == AllyR.NetworkId)
                    {
                        dmg = dmg + sender.GetSpellDamage(Player, args.SData.Name);
                    }
                    else
                    {
                        var castArea = AllyR.Distance(args.End) * (args.End - AllyR.ServerPosition).Normalized() + AllyR.ServerPosition;
                        if (castArea.Distance(AllyR.ServerPosition) < AllyR.BoundingRadius / 2)
                        {
                            dmg = dmg + sender.GetSpellDamage(AllyR, args.SData.Name);
                        }
                    }

                    if (AllyR.Health - dmg < (Player.CountEnemiesInRange(600) * AllyR.Level * 10) + (AllyR.Level * 10))
                    {
                        R.Cast();
                    }
                }
            }
        }
Exemplo n.º 25
0
        private static void MoveTo(Vector3 position)
        {
            var delay = Menu.Item("orb_Misc_Humanizer").GetValue <Slider>().Value;

            if ((MyHero.ChampionName == "Katarina" || MyHero.ChampionName == "Velkoz") && delay < 400 && (R.IsReady() || MyHero.Spellbook.GetSpell(SpellSlot.R).State == SpellState.Surpressed) && MyHero.CountEnemiesInRange(1000) > 0)
            {
                delay = 400;
            }
            if (Environment.TickCount - _lastMovement < delay)
            {
                return;
            }
            _lastMovement = Environment.TickCount;

            var holdAreaRadius = Menu.Item("orb_Misc_Holdzone").GetValue <Slider>().Value;

            if (MyHero.ServerPosition.Distance(position) < holdAreaRadius)
            {
                if (MyHero.Path.Count() > 1)
                {
                    MyHero.IssueOrder(GameObjectOrder.HoldPosition, MyHero.Position);
                }
                return;
            }
            var point = MyHero.ServerPosition +
                        300 * (position.To2D() - MyHero.ServerPosition.To2D()).Normalized().To3D();

            MyHero.IssueOrder(GameObjectOrder.MoveTo, point);
        }
Exemplo n.º 26
0
        private static void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target);
            }
            bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;

            if (config.Item("usew").GetValue <bool>() && player.Distance(target.Position) < R.Range && W.IsReady())
            {
                W.Cast(config.Item("packets").GetValue <bool>());
            }

            if (config.Item("usee").GetValue <bool>() && E.IsReady())
            {
                if (config.Item("useewall").GetValue <bool>())
                {
                    var   bestpos  = CombatHelper.bestVectorToPoppyFlash(target);
                    float damage   = (float)(ComboDamage(target) + Damage.CalcDamage(player, target, Damage.DamageType.Magical, (eSecond[E.Level - 1] + 0.8f * player.FlatMagicDamageMod)) + (player.GetAutoAttackDamage(target) * 4));
                    float damageno = (float)(ComboDamage(target) + (player.GetAutoAttackDamage(target) * 4));
                    if (config.Item("useeflash").GetValue <bool>() && hasFlash && !CheckWalls(player, target) && damage > target.Health && target.Health > damageno && CombatHelper.bestVectorToPoppyFlash(target).IsValid())
                    {
                        player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), bestpos);
                        Utility.DelayAction.Add(100, () => E.CastOnUnit(target, config.Item("packets").GetValue <bool>()));
                    }
                    if (E.CanCast(target) && (CheckWalls(player, target) || target.Health < ComboDamage(target) + 2 * player.GetAutoAttackDamage(target, true)))
                    {
                        E.CastOnUnit(target, config.Item("packets").GetValue <bool>());
                    }
                }
                else
                {
                    if (E.CanCast(target))
                    {
                        E.CastOnUnit(target, config.Item("packets").GetValue <bool>());
                    }
                }
            }
            if (config.Item("user").GetValue <bool>())
            {
                if (R.IsReady() && player.Distance(target.Position) < E.Range && ComboDamage(target) + player.GetAutoAttackDamage(target) * 5 < target.Health && (ComboDamage(target) + player.GetAutoAttackDamage(target) * 3) * ultMod[R.Level - 1] > target.Health)
                {
                    R.CastOnUnit(target, config.Item("packets").GetValue <bool>());
                }
            }
            if (config.Item("userindanger").GetValue <Slider>().Value < player.CountEnemiesInRange(R.Range))
            {
                R.CastOnUnit(target, config.Item("packets").GetValue <bool>());
            }
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite && !E.CanCast(target) && !Q.CanCast(target))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
        }
Exemplo n.º 27
0
        private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            #region 自动QE塔下敌人
            if (Config.Item("控制塔攻击的敌人").GetValue <bool>() && sender.IsAlly && sender is Obj_AI_Turret && args.Target.IsEnemy && args.Target.Type == GameObjectType.obj_AI_Hero)
            {
                var target = args.Target as Obj_AI_Hero;
                var turret = sender as Obj_AI_Turret;

                if (turret.IsAlly && E.CanCast(target) && target.Distance(turret) < turret.AttackRange + E.Range)
                {
                    if (target.Distance(turret) < Player.Distance(turret))
                    {
                        E.Cast(target);
                    }
                    else
                    {
                        E.CastToReverse(target);
                    }
                }
                if (Player.Distance(turret) < turret.AttackRange && SpellQ.GetState() == QState.ThreshQ)
                {
                    SpellQ.CastQ1(target);
                }
            }
            #endregion

            #region 自动W
            if (!W.IsReady() || !sender.IsEnemy || !sender.IsValidTarget(1500))
            {
                return;
            }
            double value = 20 + (Player.Level * 20) + (0.4 * Player.FlatMagicDamageMod);

            foreach (var ally in HeroManager.Allies.Where(ally => ally.IsValid && !ally.IsDead && Player.Distance(ally.ServerPosition) < W.Range + 200))
            {
                double dmg = 0;
                if (args.Target != null && args.Target.NetworkId == ally.NetworkId)
                {
                    dmg = dmg + sender.GetSpellDamage(ally, args.SData.Name);
                }
                else
                {
                    var castArea = ally.Distance(args.End) * (args.End - ally.ServerPosition).Normalized() + ally.ServerPosition;
                    if (castArea.Distance(ally.ServerPosition) < ally.BoundingRadius / 2)
                    {
                        dmg = dmg + sender.GetSpellDamage(ally, args.SData.Name);
                    }
                    else
                    {
                        continue;
                    }
                }

                if (dmg > 0)
                {
                    if (dmg > value)
                    {
                        W.Cast(ally.Position);
                    }
                    else if (Player.Health - dmg < Player.CountEnemiesInRange(700) * Player.Level * 20)
                    {
                        W.Cast(ally.Position);
                    }
                    else if (ally.Health - dmg < ally.Level * 10)
                    {
                        W.Cast(ally.Position);
                    }
                }
            }
            #endregion
        }
Exemplo n.º 28
0
        static void GravesOnCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (sender.IsMe && args.SData.Name == "GravesMove")
            {
                LE = Utils.GameTimeTickCount;
            }

            if (sender.IsMe && args.SData.Name == "GravesClusterShot")
            {
                if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                {
                    if (Target.IsValidTarget(Quickdraw.Range + 450))
                    {
                        Utility.DelayAction.Add(Game.Ping + 250, () => CastE(Target));
                    }
                }
            }

            if (sender.IsMe && args.SData.Name == "GravesSmokeGrenade")
            {
                if (MainMenu.Item("fleekey").GetValue <KeyBind>().Active)
                {
                    if (Target.IsValidTarget(Quickdraw.Range + 450))
                    {
                        Utility.DelayAction.Add(Game.Ping + 250, () => Quickdraw.Cast(Game.CursorPos));
                    }
                }

                if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                {
                    if (Target.IsValidTarget(Quickdraw.Range + 450) && !Quickdraw.IsReady())
                    {
                        Utility.DelayAction.Add(Game.Ping + 250, () => CastE(Target));
                    }
                }
            }

            if (sender.IsEnemy && sender.Type == Me.Type)
            {
                if (sender.Distance(Me.ServerPosition) <= Smokescreen.Range)
                {
                    if ((args.SData.CastFrame / 30) > 500)
                    {
                        Smokescreen.Cast(sender.ServerPosition);
                    }
                }
            }

            if (sender.IsMe && args.SData.Name == "GravesChargeShot")
            {
                LR = Utils.GameTimeTickCount;

                if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
                    MainMenu.Item("allin").GetValue <KeyBind>().Active)
                {
                    if (Target.Distance(Me.ServerPosition) <= Chargeshot.Range)
                    {
                        Utility.DelayAction.Add(Game.Ping + 250, () =>
                        {
                            if (Target.Distance(Me.ServerPosition) > Quickdraw.Range - 55f)
                            {
                                if (Target.CountEnemiesInRange(Me.AttackRange) <= 2 && !Target.ServerPosition.UnderTurret(true))
                                {
                                    Quickdraw.Cast(Target.ServerPosition);
                                }
                            }

                            else
                            {
                                CastE(Target);
                            }
                        });
                    }
                }
            }
        }
Exemplo n.º 29
0
        static void HealUltManager(bool forceheal = false, bool forceult = false, Obj_AI_Hero target = null)
        {
            if (W.IsReady())
            {
                if (Utils.TickCount - LastHealDetection < 1000 && HealTarget.IsValidTarget(W.Range, false))
                {
                    var setvaluehealt = Getslider("hpct" + HealTarget.ChampionName);
                    if (HealTarget.Health <= setvaluehealt)
                    {
                        W.Cast(HealTarget);
                    }
                }
            }

            if (R.IsReady())
            {
                if (Utils.TickCount - LastUltDetection < 1000 && UltTarget.IsValidTarget(R.Range, false))
                {
                    var setvalueult = Getslider("upct" + UltTarget.ChampionName);
                    if (UltTarget.Health <= setvalueult)
                    {
                        R.Cast(UltTarget);
                    }
                }
            }

            if (forceheal && target != null && W.IsReady() && Player.Distance(target) <= W.Range)
            {
                W.CastOnUnit(target);
                return;
            }
            if (forceult && target != null && R.IsReady() && Player.Distance(target) <= R.Range)
            {
                if (debug())
                {
                    Game.PrintChat("Forceult");
                }
                R.CastOnUnit(target);
                return;
            }

            if (GetBool("Healingon") && !GetBool("onlyhincdmg"))
            {
                var herolistheal = HeroManager.Allies
                                   .Where(
                    h =>
                    !h.IsZombie && !h.IsDead && GetBool("heal" + h.ChampionName) &&
                    h.HealthPercent <= Getslider("hpct" + h.ChampionName) && Player.Distance(h) <= R.Range)
                                   .OrderByDescending(i => i.IsMe)
                                   .ThenBy(i => i.HealthPercent);

                if (W.IsReady())
                {
                    if (herolistheal.Contains(Player) && !Player.IsRecalling() && !Player.InFountain())
                    {
                        W.CastOnUnit(Player);
                        return;
                    }
                    else if (herolistheal.Any())
                    {
                        var hero = herolistheal.FirstOrDefault();

                        if (Player.Distance(hero) <= R.Range && !Player.IsRecalling() && !hero.IsRecalling() && !hero.InFountain())
                        {
                            W.CastOnUnit(hero);
                            return;
                        }
                    }
                }
            }

            if (GetBool("Ultingon") && !GetBool("onlyuincdmg"))
            {
                Console.WriteLine(Player.HealthPercent);
                var herolist = HeroManager.Allies
                               .Where(
                    h =>
                    !h.IsZombie && !h.IsDead &&
                    GetBool("ult" + h.ChampionName) &&
                    h.HealthPercent <= Getslider("upct" + h.ChampionName) &&
                    Player.Distance(h) <= R.Range && Player.CountEnemiesInRange(500) > 0).OrderByDescending(i => i.IsMe).ThenBy(i => i.HealthPercent);

                if (R.IsReady())
                {
                    if (herolist.Contains(Player))
                    {
                        if (debug())
                        {
                            Game.PrintChat("regultself");
                        }
                        R.CastOnUnit(Player);
                        return;
                    }

                    else if (herolist.Any())
                    {
                        var hero = herolist.FirstOrDefault();

                        if (Player.Distance(hero) <= R.Range)
                        {
                            if (debug())
                            {
                                Game.PrintChat("regultotherorself");
                            }
                            R.CastOnUnit(hero);
                            return;
                        }
                    }
                }
            }
        }
Exemplo n.º 30
0
        private void Combo()
        {
            Obj_AI_Hero target = getTarget();

            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            if (config.Item("usee", true).GetValue <bool>() && player.HasBuff("KennenLightningRush") &&
                player.Health > target.Health && !target.UnderTurret(true) && target.Distance(Game.CursorPos) < 250f)
            {
                orbwalker.SetMovement(false);
                player.IssueOrder(GameObjectOrder.MoveTo, target);
            }
            bool hasIgnite   = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            var  combodamage = ComboDamage(target);
            var  ignitedmg   = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
                !Q.CanCast(target) && !W.IsReady())
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }

            if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && Orbwalking.CanMove(100) &&
                !target.IsDashing())
            {
                if (Program.IsSPrediction)
                {
                    Q.SPredictionCast(target, HitChance.High);
                }
                else
                {
                    Q.CastIfHitchanceEquals(target, HitChance.High);
                }
            }
            if (config.Item("usew", true).GetValue <bool>() && W.IsReady())
            {
                if (player.HasBuff("KennenShurikenStorm"))
                {
                    if (HeroManager.Enemies.Count(e => e.Distance(player) < R.Range && MarkOfStorm(e) > 0) ==
                        player.CountEnemiesInRange(R.Range))
                    {
                        W.Cast();
                    }
                }
                else if (W.Range > player.Distance(target) && MarkOfStorm(target) > 0)
                {
                    W.Cast();
                }
            }
            if (config.Item("usee", true).GetValue <bool>() && !target.UnderTurret(true) && E.IsReady() &&
                (player.Distance(target) < 80 ||
                 (!player.HasBuff("KennenLightningRush") && !Q.CanCast(target) &&
                  config.Item("useemin", true).GetValue <Slider>().Value < player.Health / player.MaxHealth * 100 &&
                  MarkOfStorm(target) > 0 &&
                  CombatHelper.IsPossibleToReachHim(target, 1f, new float[5] {
                2f, 2f, 2f, 2f, 2f
            }[Q.Level - 1]))))
            {
                E.Cast();
            }

            if (R.IsReady() && !player.HasBuffOfType(BuffType.Snare) &&
                (config.Item("user", true).GetValue <Slider>().Value <=
                 player.CountEnemiesInRange(config.Item("userrange", true).GetValue <Slider>().Value) ||
                 (config.Item("usertarget", true).GetValue <bool>() &&
                  player.CountEnemiesInRange(config.Item("userrange", true).GetValue <Slider>().Value) == 1 &&
                  combodamage + player.GetAutoAttackDamage(target) * 3 > target.Health && !Q.CanCast(target) &&
                  player.Distance(target) < config.Item("userrange", true).GetValue <Slider>().Value)) ||
                (config.Item("userLow", true).GetValue <Slider>().Value <=
                 HeroManager.Enemies.Count(
                     e =>
                     e.IsValidTarget(config.Item("userrange", true).GetValue <Slider>().Value) &&
                     e.HealthPercent < 75)))
            {
                R.Cast();
            }
        }
Exemplo n.º 31
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(1100, TargetSelector.DamageType.Physical, true);

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            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 > target.Health && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) &&
                ((target.Distance(player) > Orbwalking.GetRealAutoAttackRange(target) &&
                  (!Q.IsReady() || Q.ManaCost < player.Mana)) || player.HealthPercent < 35))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (Q.CanCast(target))
            {
                if (config.Item("useqLimit", true).GetValue <bool>())
                {
                    if (player.CountEnemiesInRange(Q.Range) == 1 && config.Item("useq", true).GetValue <bool>() &&
                        (target.Distance(player) > Orbwalking.GetRealAutoAttackRange(target) ||
                         (Q.GetDamage(target) > target.Health) &&
                         (player.HealthPercent < 50 || player.CountAlliesInRange(900) > 0)))
                    {
                        if (Q.CastOnUnit(target))
                        {
                            HandleECombo();
                        }
                    }
                    if ((player.CountEnemiesInRange(Q.Range) > 1 && config.Item("useqSec", true).GetValue <bool>() &&
                         Q.GetDamage(target) > target.Health) || player.HealthPercent < 35f ||
                        target.Distance(player) > Orbwalking.GetRealAutoAttackRange(target))
                    {
                        if (Q.CastOnUnit(target))
                        {
                            HandleECombo();
                        }
                    }
                }
                else
                {
                    if (Q.CastOnUnit(target))
                    {
                        HandleECombo();
                    }
                }
            }
            if (R.IsReady() && config.Item("user", true).GetValue <bool>())
            {
                if (player.CountEnemiesInRange(Q.Range) >= config.Item("userMin", true).GetValue <Slider>().Value&&
                    Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > 40)
                {
                    R.Cast();
                }
                if (config.Item("userDmg", true).GetValue <bool>() &&
                    Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken >= player.Health * 0.3f &&
                    player.Distance(target) < 450f)
                {
                    R.Cast();
                }
            }
            if (config.Item("useeAA", true).GetValue <bool>() && !Eactive &&
                Program.IncDamages.GetAllyData(player.NetworkId).AADamageTaken > target.GetAutoAttackDamage(player) - 10)
            {
                E.Cast();
            }
            if (Eactive)
            {
                if (E.IsReady() && target.IsValidTarget() && !target.MagicImmune &&
                    ((Prediction.GetPrediction(target, 0.1f).UnitPosition.Distance(player.Position) >
                      Orbwalking.GetRealAutoAttackRange(target) && target.Distance(player.Position) <= E.Range) ||
                     config.Item("useeStun", true).GetValue <bool>()))
                {
                    E.Cast();
                }
            }
            else
            {
                if (config.Item("useeStun", true).GetValue <bool>() &&
                    Prediction.GetPrediction(target, 0.1f).UnitPosition.Distance(player.Position) <
                    Orbwalking.GetRealAutoAttackRange(target) && target.Distance(player.Position) <= E.Range)
                {
                    E.Cast();
                }
            }
        }
Exemplo n.º 32
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(GetTargetRange(), TargetSelector.DamageType.Physical);

            if (target == null)
            {
                return;
            }
            var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
            var cmbdmg  = ComboDamage(target) + ItemHandler.GetItemsDamage(target);

            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, cmbdmg);
            }
            var dist = player.Distance(target);

            if (lastR > 4000f)
            {
                lastR = 0f;
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) &&
                dist < config.Item("useqMaxRange", true).GetValue <Slider>().Value&& !player.IsDashing())
            {
                if (dist < 550)
                {
                    Q.CastIfHitchanceEquals(target, HitChance.Medium, config.Item("packets").GetValue <bool>());
                }
                else
                {
                    Q.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue <bool>());
                }
            }
            if (config.Item("usee", true).GetValue <bool>() && E.CanCast(eTarget) &&
                dist < config.Item("useeMaxRange", true).GetValue <Slider>().Value)
            {
                E.Cast(eTarget, config.Item("packets").GetValue <bool>());
            }
            if (config.Item("user", true).GetValue <bool>() && R.IsReady())
            {
                R.Range = rRanges[R.Level - 1];
            }
            if (config.Item("user", true).GetValue <bool>() && lastR.Equals(0) && !target.UnderTurret(true) &&
                R.CanCast(target) &&
                ((qTrailOnMe && eBuff(target) &&
                  target.MoveSpeed > player.MoveSpeed && dist > 360 && target.HealthPercent < 60) ||
                 (dist < rRanges[R.Level - 1] && dist > 900 && target.CountAlliesInRange(2000) >=
                  target.CountEnemiesInRange(2000) &&
                  cmbdmg + Environment.Hero.GetAdOverFive(target) > target.Health &&
                  (target.Health > Q.GetDamage(target) || !Q.IsReady())) ||
                 (player.HealthPercent < 40 && target.HealthPercent < 40 && target.CountAlliesInRange(1000) == 1 &&
                  target.CountEnemiesInRange(1000) == 1)))
            {
                R.Cast(target, config.Item("packets").GetValue <bool>());
                lastR = System.Environment.TickCount;
            }
            if (config.Item("user", true).GetValue <bool>() && !lastR.Equals(0) && R.CanCast(target) &&
                ((cmbdmg * 1.6 + Environment.Hero.GetAdOverFive(target) > target.Health ||
                  R.GetDamage(target) > target.Health || (qTrailOnMe && eBuff(target) &&
                                                          target.MoveSpeed > player.MoveSpeed && dist > 360 && target.HealthPercent < 60))))
            {
                var time = System.Environment.TickCount - lastR;
                if (time > 3500f || player.Distance(target) > E.Range || cmbdmg > target.Health ||
                    (player.HealthPercent < 40 && target.HealthPercent < 40))
                {
                    R.Cast(target, config.Item("packets").GetValue <bool>());
                    lastR = 0f;
                }
            }
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
                !E.CanCast(target))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
        }
Exemplo n.º 33
0
 private static bool Checkinrange(Obj_AI_Hero i)
 {
     if (i.CountEnemiesInRange(750) >= 1 && i.CountEnemiesInRange(750) < 3)
     {
         return true;
     }
     return false;
 }
Exemplo n.º 34
0
        private void Combo()
        {
            Obj_AI_Hero target = null;

            if (E.IsCharging)
            {
                target = DrawHelper.GetBetterTarget(
                    GetTargetRange(), TargetSelector.DamageType.Magical, true,
                    HeroManager.Enemies.Where(
                        h => h.IsInvulnerable && CombatHelper.GetAngle(player, target.Position) > 50));
            }
            else
            {
                target = DrawHelper.GetBetterTarget(
                    GetTargetRange(), TargetSelector.DamageType.Magical, true,
                    HeroManager.Enemies.Where(h => h.IsInvulnerable));
            }
            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config);
            }
            if (config.Item("usew", true).GetValue <bool>() && W.CanCast(target) && !E.IsCharging)
            {
                W.Cast();
            }
            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 > target.Health && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) && !Q.CanCast(target))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }

            if (rActive)
            {
                orbwalker.SetAttack(false);
                Orbwalking.Attack = false;
                return;
            }

            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() && player.CanMove)
            {
                CastE(target);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && target.IsValidTarget() &&
                !E.IsCharging)
            {
                Q.CastIfHitchanceEquals(target, HitChance.Medium);
            }

            if (R.IsReady() && config.Item("user", true).GetValue <bool>() &&
                config.Item("Rmin", true).GetValue <Slider>().Value <= player.CountEnemiesInRange(R.Range) &&
                !target.HasBuffOfType(BuffType.Knockback) && !target.HasBuffOfType(BuffType.Knockup) &&
                !target.HasBuffOfType(BuffType.Stun))
            {
                R.Cast();
            }
            if (config.Item("collectBlobsC", true).GetValue <bool>() && !E.IsCharging)
            {
                var blob =
                    ObjectManager.Get <Obj_AI_Base>()
                    .Where(
                        o =>
                        !o.IsDead && o.IsValid && o.Name == "BlobDrop" && o.Team == player.Team &&
                        o.Distance(player) < Orbwalking.GetRealAutoAttackRange(player))
                    .OrderBy(o => o.Distance(player))
                    .FirstOrDefault();
                if (blob != null && Orbwalking.CanMove(300) && !Orbwalking.CanAttack() && !player.IsWindingUp)
                {
                    orbwalker.SetMovement(false);
                    Orbwalking.Move = false;
                    player.IssueOrder(GameObjectOrder.MoveTo, blob.Position);
                }
            }
        }
Exemplo n.º 35
0
        private static void Game_OnUpdate(EventArgs args)
        {
            didhs = menu.Item("harasskey").GetValue<KeyBind>().Active;

            // ulti check
            uo = player.GetSpell(SpellSlot.R).Name != "RivenFengShuiEngine";

            // hydra check
            hashd = Items.HasItem(3077) || Items.HasItem(3074);
            canhd = !didaa && (Items.CanUseItem(3077) || Items.CanUseItem(3074));

            // main target (riven targ)
            rtarg = TargetSelector.GetTarget(900, TargetSelector.DamageType.Physical);
            ctarg = TargetSelector.GetTarget(q.Range + w.Range, TargetSelector.DamageType.Physical);

            btarg = rtarg != null && ctarg != null &&
                    TargetSelector.GetPriority(rtarg) > TargetSelector.GetPriority(ctarg)
                ? rtarg
                : ctarg;

            truerange = player.AttackRange + player.Distance(player.BBox.Minimum) + 1;

            // if no valid target cancel to cursor pos
            if (!qtarg.IsValidTarget(truerange + 100))
                 qtarg = player;

            // can we burst?
            cb = rtarg != null && r.IsReady() && q.IsReady() &&
                ((ComboDamage(rtarg)/1.6) >= rtarg.Health || rtarg.CountEnemiesInRange(w.Range) >= menuslide("multic"));

            // set player skin
            player.SetSkin(player.BaseSkinName, menu.Item("skinset").GetValue<StringList>().SelectedIndex);

            // move behind me
            if (qtarg != player && qtarg.IsFacing(player) && qtarg.Distance(player.ServerPosition) < truerange + 120)
                movepos = player.ServerPosition + (player.ServerPosition - qtarg.ServerPosition).Normalized()*28;

            // move towards target (thanks yol0)
            if (qtarg != player && (!qtarg.IsFacing(player) || qtarg.Distance(player.ServerPosition) > truerange + 120))
                movepos = player.ServerPosition.Extend(qtarg.ServerPosition, 350);

            // move to game cursor pos
            if (qtarg == player)
                movepos = Game.CursorPos;

            // orbwalk movement
            orbwalker.SetAttack(canmv);
            orbwalker.SetMovement(canmv);

            // reqs ->
            SemiQ();
            AuraUpdate();
            CombatCore();
            Windslash();

            if (btarg.IsValidTarget() &&
                menu.Item("combokey").GetValue<KeyBind>().Active)
            {
                ComboTarget(btarg);
            }

            if (rtarg.IsValidTarget() &&
                menu.Item("shycombo").GetValue<KeyBind>().Active)
            {
                if (rtarg.Distance(player.ServerPosition) <= truerange)
                {
                    if ((Items.HasItem(3077) || Items.HasItem(3074)))
                    {
                        if ((Items.CanUseItem(3077) || Items.CanUseItem(3074)))
                        {
                            OrbTo(rtarg);
                        }
                    }
                }

                if (rtarg.IsValidTarget(w.Range))
                {
                    if (w.IsReady())
                        w.Cast();
                }

                TryFlashInitiate(rtarg);
            }

            if (didhs && ctarg.IsValidTarget())
            {
                HarassTarget(ctarg);
            }

            if (player.IsValid &&
                menu.Item("clearkey").GetValue<KeyBind>().Active)
            {
                Clear();
                Wave();
            }

            if (player.IsValid &&
                menu.Item("fleekey").GetValue<KeyBind>().Active)
            {
                Flee();
            }
        }
Exemplo n.º 36
0
        private void Combo()
        {
            var target = TargetSelector.GetSelectedTarget() ??
                         TargetSelector.GetTarget(EQ.Range, TargetSelector.DamageType.Physical);

            if (CheckTarget(target, EQ.Range))
            {
                if (Menu.Item("ComboQ", true).GetValue <bool>() && Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    Q.CastTo(target);
                }

                if (Menu.Item("ComboW", true).GetValue <bool>() && W.IsReady() && target.IsValidTarget(W.Range))
                {
                    W.CastTo(target, true);
                }

                if (Menu.Item("ComboE", true).GetValue <bool>() && E.IsReady() && target.IsValidTarget(EQ.Range) &&
                    !Me.UnderTurret(true))
                {
                    var usee = false;

                    if (target.DistanceToPlayer() > Orbwalking.GetRealAutoAttackRange(Me) &&
                        Me.CountEnemiesInRange(1200) <= 2 && CheckTargetSureCanKill(target))
                    {
                        if (HealthPrediction.GetHealthPrediction(target, 250) > 0)
                        {
                            if (target.Health < E.GetDamage(target) + Me.GetAutoAttackDamage(target) &&
                                target.Distance(Game.CursorPos) < Me.Distance(Game.CursorPos))
                            {
                                usee = true;
                            }

                            if (target.Health < E.GetDamage(target) + W.GetDamage(target) && W.IsReady() &&
                                target.Distance(Game.CursorPos) + 350 < Me.Distance(Game.CursorPos))
                            {
                                usee = true;
                            }

                            if (target.Health < E.GetDamage(target) + Q.GetDamage(target) && Q.IsReady() &&
                                target.Distance(Game.CursorPos) + 300 < Me.Distance(Game.CursorPos))
                            {
                                usee = true;
                            }
                        }
                        else
                        {
                            usee = false;
                        }
                    }

                    if (usee)
                    {
                        E.Cast(Me.Position.Extend(Game.CursorPos, E.Range));
                        usee = false;
                    }
                }

                if (Menu.Item("ComboR", true).GetValue <bool>() && R.IsReady())
                {
                    var RTarget = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);

                    if (CheckTarget(RTarget))
                    {
                        if (RTarget.Health + RTarget.HPRegenRate * 2 <= R.GetDamage(target) &&
                            RTarget.IsValidTarget(1500))
                        {
                            R.CastTo(RTarget);
                        }
                        else if (RTarget.IsValidTarget(Q.Range + E.Range - 200) &&
                                 RTarget.Health + RTarget.MagicalShield + RTarget.HPRegenRate * 2 <=
                                 R.GetDamage(RTarget) + Q.GetDamage(RTarget) + W.GetDamage(RTarget) &&
                                 Q.IsReady() && W.IsReady() &&
                                 RTarget.CountAlliesInRange(Q.Range + E.Range - 200) <= 1)
                        {
                            R.CastTo(RTarget);
                        }
                        else if (RTarget.IsValidTarget())
                        {
                            R.CastIfWillHit(RTarget, Menu.Item("ComboRMin", true).GetValue <Slider>().Value);
                        }
                    }
                }
            }
        }
Exemplo n.º 37
0
 private static void Fuckingw(Obj_AI_Hero hero)
 {
     if (hero == null) return;
     var qmana = _player.Spellbook.GetSpell(SpellSlot.Q).ManaCost;
     var wmana = _player.Spellbook.GetSpell(SpellSlot.W).ManaCost;
     var emana = _player.Spellbook.GetSpell(SpellSlot.E).ManaCost;
     var rmana = _player.Spellbook.GetSpell(SpellSlot.R).ManaCost;
     var diveTower = _config.Item("diveintower").GetValue<bool>();
     if ((hero.UnderTurret() && !diveTower) || !_w.IsReady()) return;
     var usewhE = (100 * (_player.Health / _player.MaxHealth)) > _config.Item("UseWHE").GetValue<Slider>().Value;
     if (usewhE && hero.IsValidTarget(_q.Range + _w.Range) &&
         hero.CountEnemiesInRange(_q.Range + _w.Range) <= _config.Item("EnemyC").GetValue<Slider>().Value &&
         _player.Distance(hero) > Orbwalking.GetRealAutoAttackRange(_player))
     {
         if (hero.Health < (_player.GetAutoAttackDamage(hero, true) * 2))
         {
             _w.Cast(hero.Position);
         }
         else if (hero.Health < _q.GetDamage(hero) && _player.MaxMana > qmana + wmana && _q.IsReady())
         {
             _w.Cast(hero.Position);
         }
         else if (hero.Health < _e.GetDamage(hero) && _player.MaxMana > emana + wmana && _e.IsReady())
         {
             _w.Cast(hero.Position);
         }
         else if (hero.Health < _e.GetDamage(hero) + _q.GetDamage(hero) && _player.MaxMana > qmana + emana + wmana &&
                  _e.IsReady() && _e.IsReady())
         {
             _w.Cast(hero.Position);
         }
         else if (hero.Health < _q.GetDamage(hero) + _r.GetDamage(hero) && _q.IsReady() && _r.IsReady() &&
                  _player.MaxMana > qmana + wmana + rmana)
         {
             _w.Cast(hero.Position);
         }
     }
 }
Exemplo n.º 38
0
        private static void Game_OnUpdate(EventArgs args)
        {
            didhs = menu.Item("harasskey").GetValue<KeyBind>().Active;

            // ulti check
            uo = player.GetSpell(SpellSlot.R).Name != "RivenFengShuiEngine";

            // hydra check
            hashd = Items.HasItem(3077) || Items.HasItem(3074);
            canhd = !didaa && (Items.CanUseItem(3077) || Items.CanUseItem(3074));

            // main target (riven targ)
            rtarg = TargetSelector.GetTarget(1100, TargetSelector.DamageType.Physical);

            // my radius
            truerange = player.AttackRange + player.Distance(player.BBox.Minimum) + 1;

            // if no valid target cancel to cursor pos
            if (!qtarg.IsValidTarget(truerange + 100))
                 qtarg = player;

            // riven w range
            wrange = uo ? w.Range + 25 : w.Range;

            // can we burst?
            cb = rtarg != null && r.IsReady() && q.IsReady() &&
                ((ComboDamage(rtarg)/1.6) >= rtarg.Health || rtarg.CountEnemiesInRange(w.Range) >= menuslide("multic"));

            // move behind me
            if (qtarg != player && qtarg.IsFacing(player) && qtarg.Distance(player.ServerPosition) < truerange + 120)
                movepos = player.ServerPosition + (player.ServerPosition - qtarg.ServerPosition).Normalized()*28;

            // move towards target (thanks yol0)
            if (qtarg != player && (!qtarg.IsFacing(player) || qtarg.Distance(player.ServerPosition) > truerange + 120))
                movepos = player.ServerPosition.Extend(qtarg.ServerPosition, 350);

            // move to game cursor pos
            if (qtarg == player)
                movepos = Game.CursorPos;

            // orbwalk movement
            orbwalker.SetAttack(canmv);
            orbwalker.SetMovement(canmv);

            // reqs ->
            SemiQ();
            AuraUpdate();
            CombatCore();
            Windslash();

            if (rtarg.IsValidTarget() &&
                menu.Item("combokey").GetValue<KeyBind>().Active)
            {
                ComboTarget(rtarg);
                TryIgnote(rtarg);
            }

            if (rtarg.IsValidTarget() &&
                menu.Item("shycombo").GetValue<KeyBind>().Active)
            {
                if (rtarg.Distance(player.ServerPosition) <= wrange)
                {
                    w.Cast();
                }

                OrbTo(rtarg, 350);
                TryFlashInitiate(rtarg);
                TryIgnote(rtarg);

                if (q.IsReady() && rtarg.Distance(player.ServerPosition) <= q.Range + 30)
                {
                    useinventoryitems(rtarg);
                    CheckR();

                    if (menulist("emode") == 0 || (ComboDamage(rtarg) / 1.7) >= rtarg.Health)
                    {
                        if (Items.CanUseItem(3077) || Items.CanUseItem(3074))
                            return;
                    }

                    if (canq)
                        q.Cast(rtarg.ServerPosition);
                }
            }

            if (didhs && rtarg.IsValidTarget())
            {
                HarassTarget(rtarg);
            }

            if (player.IsValid &&
                menu.Item("clearkey").GetValue<KeyBind>().Active)
            {
                Clear();
                Wave();
            }

            if (player.IsValid &&
                menu.Item("fleekey").GetValue<KeyBind>().Active)
            {
                Flee();
            }
        }