Beispiel #1
0
        private void Game_OnUpdate(EventArgs args)
        {
            if (q.IsReady() && player.Mana > q.ManaCost)
            {
                foreach (Obj_AI_Hero objAiHero in player.GetEnemiesInRange(q.Range).Where(hero => !hero.IsDead && !hero.IsZombie && q.IsKillable(hero)))
                {
                    PredictionOutput predictionOutput = q.GetPrediction(objAiHero);

                    if ((predictionOutput.Hitchance >= HitChance.High) &&
                        ((!q.GetCollision(player.Position.To2D(), new List <Vector2> {
                        predictionOutput.CastPosition.To2D()
                    }).Any()) ||
                         q.GetDamage(objAiHero) / 2 > objAiHero.Health))
                    {
                        q.Cast(predictionOutput.CastPosition);
                        //Console.WriteLine("ks q");
                    }
                }
            }

            if (e.IsReady() && player.Mana > e.ManaCost)
            {
                if (player.GetEnemiesInRange(e.Range).Any(hero => !hero.IsDead && !hero.IsZombie && e.IsKillable(hero)))
                {
                    e.Cast();
                    //Console.WriteLine("ks e");
                }
            }

            if (zedOrbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo || !zedShadows.CanCast)
            {
                return;
            }

            List <Obj_AI_Hero> heroList = ObjectManager.Player.GetEnemiesInRange(2000F);

            if (heroList.Count() == 1)
            {
                Obj_AI_Hero target = heroList.FirstOrDefault();

                if (target != null && zedShadows.CanCast && player.Distance(target) > Orbwalking.GetRealAutoAttackRange(target) &&
                    player.Distance(target) < w.Range + Orbwalking.GetRealAutoAttackRange(target) &&
                    player.GetAutoAttackDamage(target) > target.Health && player.Mana > w.ManaCost)
                {
                    zedShadows.Cast(target.Position);
                    //Console.WriteLine("ks w 1");
                    zedShadows.Switch();
                    //Console.WriteLine("ks w 2");
                }
            }
        }
Beispiel #2
0
        private static void UseBOTRK(Obj_AI_Hero enemy = null)
        {
            var botrk = ItemId.Bilgewater_Cutlass;

            if (Items.HasItem((int)ItemId.Blade_of_the_Ruined_King, Player))
            {
                botrk = ItemId.Blade_of_the_Ruined_King;
            }
            var targetsInRange = Player.GetEnemiesInRange(450).FindAll(e => !e.IsDead && e.IsValidTarget());

            if (targetsInRange.Count == 0 || !Items.CanUseItem((int)botrk))
            {
                return;
            }

            var target = targetsInRange.OrderBy(h => h.Armor)
                         .FirstOrDefault();

            if (botrk == ItemId.Bilgewater_Cutlass || Player.Health + Player.GetItemDamage(target, Damage.DamageItems.Botrk) < ObjectManager.Player.MaxHealth)
            {
                UseItem(botrk, target);
            }
            if (enemy != null)
            {
                UseItem(ItemId.Blade_of_the_Ruined_King, enemy);
            }
            else
            {
                if (target != null)
                {
                    UseItem(ItemId.Blade_of_the_Ruined_King, target);
                }
            }
        }
Beispiel #3
0
 private static void Game_OnUpdate(EventArgs args)
 {
     if (Player.IsRecalling())
     {
         return;
     }
     if (Player.CountEnemiesInRange(875) > 0 && _q.IsReady())
     {
         _q.CastOnUnit(Player.GetEnemiesInRange(875).OrderByDescending(target => target.Health).Last());
     }
 }
Beispiel #4
0
        private void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (sender == null || args == null || !r.IsReady() || r.Instance.ToggleState != 0 ||
                !player.GetEnemiesInRange(r.Range).Any() || args.Slot != SpellSlot.R || !sender.IsChampion() ||
                !sender.IsEnemy || !zedMenu.GetParamBool("koreanzed.miscmenu.rdodge.user") ||
                !zedMenu.CheckMenuItem("koreanzed.miscmenu.rdodge." + args.SData.Name.ToLowerInvariant()))
            {
                return;
            }

            if (((args.Target != null && args.Target.IsMe) ||
                 player.Distance(args.End) < Math.Max(args.SData.BounceRadius, args.SData.LineWidth)) &&
                zedMenu.GetParamBool("koreanzed.miscmenu.rdodge." + args.SData.Name.ToLowerInvariant()))
            {
                int delay = (int)Math.Truncate((double)(player.Distance(sender) / args.SData.MissileSpeed)) - 1;
                Utility.DelayAction.Add(delay, () => { r.Cast(TargetSelector.GetTarget(r.Range, r.DamageType)); });
            }
        }
Beispiel #5
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (Player.IsRecalling())
            {
                return;
            }
            if (Player.CountEnemiesInRange(725) > 0 && _w.IsReady())
            {
                _w.CastOnUnit(Player.GetEnemiesInRange(725).OrderByDescending(target => target.Health).Last());
            }

            if (Player.CountAlliesInRange(725) > 0 && _w.IsReady())
            {
                _w.CastOnUnit(Player.GetAlliesInRange(725).OrderByDescending(target => target.Health).Last());
            }

            if (Player.CountAlliesInRange(800) > 0 && _e.IsReady())
            {
                _e.CastOnUnit(Player.GetAlliesInRange(800).OrderByDescending(target => target.GoldEarned).First());
            }
        }
Beispiel #6
0
        public static void updateArmaPlay()
        {
            try
            {
                if (!haveSeenMinion)
                {
                    haveSeenMinion =
                        ObjectManager.Get <Obj_AI_Minion>().Any(min => min.IsTargetable && min.IsHPBarRendered && 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))
                {
                    buyItems();
                }

                if (champ != null)
                {
                    champ.alwaysCheck();
                }

                setRambo();

                if (player.IsDead || player.IsChannelingImportantSpell())
                {
                    return;
                }

                var fightLevel = MapControl.fightLevel();
                MapControl.updateReaches();

                var closestEnemy = EloBuddy.SDK.EntityManager.Heroes.Enemies.Where(ene => !ene.IsDead && ene.IsTargetable && ene.IsHPBarRendered && !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 (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 = EloBuddy.SDK.EntityManager.Heroes.Allies.OrderBy(al => toNex.Position.Distance(al.Position, true)).FirstOrDefault();

                var lookRange = player.AttackRange + ((player.IsMelee) ? 260 : 155);
                var easyKill  =
                    EloBuddy.SDK.EntityManager.Heroes.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) && ene.IsHPBarRendered);

                if (easyKill != null && easyKill.IsValidTarget())
                {
                    Aggresivity.addAgresiveMove(new AgresiveMove(45, 1500, true));
                    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(), 632).To3D(), true);
                }

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

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

                if (towerAttackedMe)
                {
                    DeathWalker.CustomOrbwalkMode = false;
                    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 =
                        EloBuddy.SDK.EntityManager.Turrets.Enemies.Where(
                            obj => obj.IsValidTarget(700) && !obj.IsDead && !obj.IsInvulnerable && obj.IsTargetable)
                        .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 && safeMeleeEnem.IsValidTarget())
                        {
                            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 (!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 (sector.containsEnemy && !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);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
Beispiel #7
0
        // TODO rework the logic of combo, especially if already barrel manually placed
        private static void Combo()
        {
            var target      = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical, true, HeroManager.Enemies.Where(e => e.IsInvulnerable));
            var ePrediction = Prediction.GetPrediction(target, 1f).CastPosition;
            var nbar        = NearestKeg(Player.ServerPosition.To2D());

            // ITEMS
            if (GetBool("bangplank.menu.item.youmuu") && HeroManager.Enemies != null && Items.HasItem(3142) && Items.CanUseItem(3142))
            {
                foreach (var e in HeroManager.Enemies)
                {
                    if (e.Distance(Player) <= Player.AttackRange + 50)
                    {
                        Items.UseItem(3142); //youmuu gb
                    }
                }
            }
            if (GetBool("bangplank.menu.item.hydra") && HeroManager.Enemies != null &&
                Items.HasItem(3074) && Items.CanUseItem(3074))
            {
                foreach (var e in HeroManager.Enemies)
                {
                    if (e.Distance(Player) <= 400)
                    {
                        Items.UseItem(3072); //ravenous hydra
                    }
                }
            }
            if (GetBool("bangplank.menu.item.tiamat") && HeroManager.Enemies != null &&
                Items.HasItem(3077) && Items.CanUseItem(3077))
            {
                foreach (var e in HeroManager.Enemies)
                {
                    if (e.Distance(Player) <= 400)
                    {
                        Items.UseItem(3077); //tiamat
                    }
                }
            }



            if (target == null)
            {
                return;
            }
            if ((E.Instance.Ammo == 0 || E.Level < 1) && Q.IsReady() && Q.IsInRange(target) && (LiveBarrels.Count == 0 || NearestKeg(Player.Position.To2D()).KegObj.Distance(Player) > Q.Range))
            {
                Q.CastOnUnit(target);
            }

            if (GetBool("bangplank.menu.misc.barrelmanager.edisabled") == false && R.Level == 0 && E.IsReady() && (LiveBarrels.Count == 0 || NearestKeg(Player.Position.To2D()).KegObj.Distance(Player) > E.Range)) // 2 keg
            {
                E.Cast(ePrediction);
            }
            if (R.Level == 1 && GetBool("bangplank.menu.misc.barrelmanager.edisabled") == false && E.IsReady()) // 3 Keg
            {
                if ((LiveBarrels.Count == 0 || nbar.KegObj.Distance(Player) > Q.Range) && E.Instance.Ammo >= 3)
                {
                    E.Cast(Player.ServerPosition);
                }
                if ((LiveBarrels.Count == 0 || nbar.KegObj.Distance(Player) > Q.Range) && E.Instance.Ammo < 3)
                {
                    foreach (var k in LiveBarrels)
                    {
                        if (k.KegObj.GetEnemiesInRange(ExplosionRange).Count >= 1 && Player.Distance(k.KegObj) < E.Range)
                        {
                            BarrelManager();
                            return;
                        }
                    }
                    E.Cast(ePrediction);
                }
            }
            if (R.Level == 2 && GetBool("bangplank.menu.misc.barrelmanager.edisabled") == false && E.IsReady()) // 4 Keg
            {
                if ((LiveBarrels.Count == 0 || nbar.KegObj.Distance(Player) > Q.Range) && E.Instance.Ammo >= 3)
                {
                    E.Cast(Player.ServerPosition);
                }
                if ((LiveBarrels.Count == 0 || nbar.KegObj.Distance(Player) > Q.Range) && E.Instance.Ammo < 3)
                {
                    foreach (var k in LiveBarrels)
                    {
                        if (k.KegObj.GetEnemiesInRange(ExplosionRange).Count >= 1 && Player.Distance(k.KegObj) < E.Range)
                        {
                            BarrelManager();
                            return;
                        }
                    }
                    E.Cast(ePrediction);
                }
            }
            if (R.Level == 3 && GetBool("bangplank.menu.misc.barrelmanager.edisabled") == false && E.IsReady()) // 5 Keg
            {
                if ((LiveBarrels.Count == 0 || nbar.KegObj.Distance(Player) > Q.Range) && E.Instance.Ammo >= 3 && Player.GetEnemiesInRange(E.Range).Count < 3)
                {
                    E.Cast(Player.ServerPosition);
                }
                if (((LiveBarrels.Count == 0 || nbar.KegObj.Distance(Player) > Q.Range) && E.Instance.Ammo < 3) || Player.GetEnemiesInRange(E.Range).Count >= 3)
                {
                    foreach (var k in LiveBarrels)
                    {
                        if (k.KegObj.GetEnemiesInRange(ExplosionRange).Count >= 1 && Player.Distance(k.KegObj) < E.Range)
                        {
                            BarrelManager();
                            return;
                        }
                    }
                    E.Cast(ePrediction);
                }
            }
            //Extend if possible and if the number of enemies is below 3
            if (Player.GetEnemiesInRange(E.Range).Count < 3 && GetBool("bangplank.menu.misc.barrelmanager.edisabled") == false)
            {
                if (Player.ServerPosition.Distance(nbar.KegObj.Position) < Q.Range && nbar.KegObj.Health < 3)
                {
                    if (target != null)
                    {
                        var prediction = Prediction.GetPrediction(target, 0.8f).CastPosition;
                        if (nbar.KegObj.Distance(prediction) < LinkRange)
                        {
                            E.Cast(prediction);
                            // if (Player.Level < 7 && nbar.KegObj.Health < 2)
                            // {
                            //    Q.Cast(nbar.KegObj);
                            // }
                            if (Player.Level < 13 && Player.Level >= 7 && nbar.KegObj.Health == 2)
                            {
                                Utility.DelayAction.Add(580 - Game.Ping, () =>
                                {
                                    Q.Cast(nbar.KegObj);
                                }
                                                        );
                            }

                            if (Player.Level >= 13 && nbar.KegObj.Health == 2)
                            {
                                Utility.DelayAction.Add((int)(80 - Game.Ping), () =>
                                {
                                    Q.Cast(nbar.KegObj);
                                }
                                                        );
                            }
                            if (nbar.KegObj.Health == 1)
                            {
                                Q.Cast(nbar.KegObj);
                            }
                        }
                    }
                }
            }

            if (GetBool("bangplank.menu.combo.r") && R.IsReady() && target.GetEnemiesInRange(600).Count + 1 > Getslider("bangplank.menu.combo.rmin") && target.HealthPercent < 30)
            {
                R.Cast(Prediction.GetPrediction(target, R.Delay).CastPosition);
            }
            BarrelManager();
        }
Beispiel #8
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() && player.ChampionName != "Varus"))
            {
                champ?.castingImportantSpell();
                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() || needRecall && lastRecall + 1000 > DeathWalker.now)
                {
                    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;
                    }
                }
                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 < 280 || 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(), 632).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 (balance < 70 && 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(), 3000, true, true));
                    DeathWalker.deathWalk(fightOn.Position.Extend(player.Position, player.AttackRange * 0.6f), 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(), 333).To3D(), false);
                    }
                }
            }



            /*foreach (var ally in MapControl.ally_champions)
             * {
             *  if (ally.hero.Distance(player) < 800 && MapControl.myControler != null)
             *      MapControl.myControler.useNonSkillshots(ally.hero);
             * }*/
        }
Beispiel #9
0
        private static void Combo()
        {
            bool vQ     = _q.IsReady() && _menu.Item("teddy.bear.combo.useq").GetValue <bool>();
            bool vW     = _w.IsReady() && _menu.Item("teddy.bear.combo.usew").GetValue <bool>();
            bool vE     = _e.IsReady() && _menu.Item("teddy.bear.combo.usee").GetValue <bool>();
            bool vR     = _r.IsReady() && _menu.Item("teddy.bear.combo.user").GetValue <bool>();
            bool useskW = _menu.Item("teddy.bear.misc.skW").GetValue <bool>();

            Obj_AI_Hero tsQ = TargetSelector.GetTarget(_q.Range, TargetSelector.DamageType.Magical);
            Obj_AI_Hero tsR = TargetSelector.GetTarget(_r.Range, TargetSelector.DamageType.Magical);

            #region Q-Cast
            if (vQ)
            {
                if (tsQ.Distance(Player.Position) >= 2500 && tsQ.Direction == Player.Direction && tsQ.MoveSpeed > Player.MoveSpeed &&
                    tsQ.MoveSpeed < Player.MoveSpeed * 1.3)
                {
                    _q.Cast(tsQ);
                }
                if (tsQ.GetEnemiesInRange(100).Any(enemies => enemies.IsEnemy && !enemies.IsDead) && tsQ.IsValidTarget())
                {
                    _q.Cast(tsQ);
                }
                else if (Player.CountAlliesInRange(500) >= 1 && tsQ.IsValidTarget())
                {
                    _q.Cast(tsQ);
                }
                else if (tsQ.IsValidTarget())
                {
                    _q.Cast(tsQ);
                }
            }
            #endregion

            #region W-Cast
            if (vW && useskW)
            {
                if (tsQ.IsValidTarget(_w.Range) && tsQ.Health < _w.GetDamage(tsQ))
                {
                    _w.CastOnUnit(tsQ);
                }
            }
            else if (vW)
            {
                if (tsQ.IsValidTarget(_w.Range))
                {
                    _w.CastOnUnit(tsQ);
                }
            }
            #endregion

            #region E-Cast
            if (vE)
            {
                if (tsQ.IsValidTarget(_e.Range) && tsQ.Distance(Player.Position) <= _w.Range)
                {
                    _e.Cast();
                }
            }
            #endregion

            #region R-Cast
            if (vR)
            {
                if (tsR.IsValidTarget(Player.AttackRange) && tsR.HealthPercent > 25)
                {
                    _r.Cast();
                }
            }
            #endregion
        }