Esempio n. 1
0
        private static void Laneclear()
        {
            var rangedMinionsQ = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, _w.Range + _w.Width + 30,
                                                          MinionTypes.Ranged);
            var allMinionsQ = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, _w.Range + _w.Width + 30,
                                                       MinionTypes.All);
            var allMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, _e.Range, MinionTypes.All);
            var usewlane   = (100 * (_player.Health / _player.MaxHealth)) > _config.Item("UseWLane").GetValue <Slider>().Value;
            var useQ       = _config.Item("UseQL").GetValue <bool>();
            var useW       = _config.Item("UseWL").GetValue <bool>();
            var useE       = _config.Item("UseEL").GetValue <bool>();
            var tristanap  = _config.Item("Style").GetValue <StringList>().SelectedIndex == 0;

            foreach (var minion in allMinions)
            {
                if (allMinions.Count > 3)
                {
                    if (useE && _e.IsReady())
                    {
                        _e.Cast(minion);
                    }
                    if (useQ && _q.IsReady())
                    {
                        _q.CastOnUnit(ObjectManager.Player);
                    }
                }
            }
            if (usewlane && useW && _w.IsReady() && tristanap &&
                ObjectManager.Player.CountEnemiesInRange(1300) <= _config.Item("Enemylane").GetValue <Slider>().Value)
            {
                var fl1 = _w.GetCircularFarmLocation(rangedMinionsQ, _w.Width);
                var fl2 = _w.GetCircularFarmLocation(allMinionsQ, _w.Width);

                if (fl1.MinionsHit >= 3 && !_player.UnderTurret())
                {
                    _w.Cast(fl1.Position);
                }
                else if ((fl2.MinionsHit >= 2 || allMinionsQ.Count == 1) && !_player.UnderTurret())
                {
                    _w.Cast(fl2.Position);
                }
                else
                {
                    foreach (var minion in allMinionsQ)
                    {
                        if (!Orbwalking.InAutoAttackRange(minion) && !_player.UnderTurret() &&
                            minion.Health < 0.75 * _player.GetSpellDamage(minion, SpellSlot.Q))
                        {
                            _w.Cast(minion);
                        }
                    }
                }
            }
        }
Esempio n. 2
0
 static void Auto()
 {
     if (Config.AutoQ && SpellManager.Q.IsReady())
     {
         if (Config.ManaER && (SpellManager.R.IsReady() || SpellManager.E.IsReady()) && ((Player.Mana - Player.Spellbook.GetSpell(SpellManager.Q.Slot).ManaCost) < Player.Spellbook.GetSpell(SpellManager.R.Slot).ManaCost) || (Player.Mana - Player.Spellbook.GetSpell(SpellManager.Q.Slot).ManaCost) < Player.Spellbook.GetSpell(SpellManager.E.Slot).ManaCost)
         {
             return;
         }
         var  target          = ObjectManager.Get <Obj_AI_Hero>().Where(hero => hero.IsValidTarget(SpellManager.Q.Range) && hero.IsEnemy && Config.ShouldAuto(hero.ChampionName)).FirstOrDefault();
         bool bothUnderTurret = target.UnderTurret(true) && Player.UnderTurret(true);
         if (bothUnderTurret)
         {
             if (Config.AutoTurret)
             {
                 SpellManager.CastSpell(SpellManager.Q, target, HitChance.High, Config.UsePackets);
             }
             else
             {
                 return;
             }
         }
         else
         {
             SpellManager.CastSpell(SpellManager.Q, target, HitChance.High, Config.UsePackets);
         }
     }
     if (Config.AutoW && SpellManager.W.IsReady())
     {
         if (Config.ManaER && (SpellManager.R.IsReady() || SpellManager.E.IsReady()) && ((Player.Mana - Player.Spellbook.GetSpell(SpellManager.W.Slot).ManaCost) < Player.Spellbook.GetSpell(SpellManager.R.Slot).ManaCost) || (Player.Mana - Player.Spellbook.GetSpell(SpellManager.W.Slot).ManaCost) < Player.Spellbook.GetSpell(SpellManager.E.Slot).ManaCost)
         {
             return;
         }
         var  target          = ObjectManager.Get <Obj_AI_Hero>().Where(hero => hero.IsValidTarget(SpellManager.W.Range) && hero.IsEnemy && Config.ShouldAuto(hero.ChampionName)).FirstOrDefault();
         bool bothUnderTurret = target.UnderTurret(true) && Player.UnderTurret(true);
         if (bothUnderTurret)
         {
             if (Config.AutoTurret)
             {
                 SpellManager.CastSpell(SpellManager.W, target, HitChance.High, Config.UsePackets);
             }
             else
             {
                 return;
             }
         }
         else
         {
             SpellManager.CastSpell(SpellManager.W, target, HitChance.High, Config.UsePackets);
         }
     }
 }
Esempio n. 3
0
        private void AutoHarass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Menu.Item("AutoHarass", true).GetValue <KeyBind>().Active&&
                Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo &&
                Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Mixed &&
                !Me.IsRecalling())
            {
                Harass();
            }
        }
Esempio n. 4
0
        private void LogicR()
        {
            if (Player.UnderTurret(true) && Config.Item("Rturrent", true).GetValue <bool>())
            {
                return;
            }
            if (Game.Time - WCastTime > 0.9 && Config.Item("autoR", true).GetValue <bool>())
            {
                foreach (var target in Program.Enemies.Where(target => target.IsValidTarget(R.Range) && OktwCommon.ValidUlt(target)))
                {
                    var predictedHealth = target.Health - OktwCommon.GetIncomingDamage(target);
                    var Rdmg            = R.GetDamage(target, 1);

                    if (Rdmg > predictedHealth && !OktwCommon.IsSpellHeroCollision(target, R) && GetRealDistance(target) > bonusRange() + 200)
                    {
                        if (GetRealDistance(target) > bonusRange() + 300 + target.BoundingRadius && target.CountAlliesInRange(600) == 0 && Player.CountEnemiesInRange(400) == 0)
                        {
                            castR(target);
                        }
                        else if (target.CountEnemiesInRange(200) > 2)
                        {
                            R.Cast(target, true, true);
                        }
                    }
                }
            }
        }
Esempio n. 5
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);

                if (CheckTarget(target, R.Range))
                {
                    if (Menu.Item("HarassR", true).GetValue <bool>() && R.IsReady() &&
                        Menu.Item("HarassRLimit", true).GetValue <Slider>().Value >= GetRCount &&
                        target.IsValidTarget(R.Range))
                    {
                        R.CastTo(target);
                    }

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

                    if (Menu.Item("HarassE", true).GetValue <bool>() && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        E.CastTo(target);
                    }
                }
            }
        }
Esempio n. 6
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                var target = TargetSelector.GetTarget(Q1.Range, TargetSelector.DamageType.Physical);

                if (CheckTarget(target, Q1.Range))
                {
                    if (Menu.Item("HarassQ", true).GetValue <bool>() && Q.IsReady() && target.IsValidTarget(Q1.Range))
                    {
                        QLogic(target, Menu.Item("HarassQ1", true).GetValue <bool>());
                    }

                    if (Menu.Item("HarassE", true).GetValue <bool>() && E.IsReady() && target.IsValidTarget(E.Range))
                    {
                        E.Cast(target.Position, true);
                    }
                }
            }
        }
Esempio n. 7
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                var wTarget = TargetSelector.GetTarget(1500f, TargetSelector.DamageType.Physical);

                if (Menu.Item("HarassW", true).GetValue <bool>() && W.IsReady() && CheckTarget(wTarget, W.Range))
                {
                    if (Menu.Item("HarassWOnly", true).GetValue <bool>() && !HasPassive(wTarget))
                    {
                        return;
                    }

                    W.CastTo(wTarget);
                }

                var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Magical);

                if (Menu.Item("HarassE", true).GetValue <bool>() && E.IsReady() &&
                    CheckTarget(eTarget, E.Range) && Utils.TickCount - LastECast > 2500 && !IsAttack)
                {
                    E.CastTo(eTarget, true);
                }
            }
        }
Esempio n. 8
0
        private void Combo(Obj_AI_Hero target)
        {
            if (target == null)
            {
                return;
            }
            var   cmbDmg = ComboDamage(target);
            float dist   = (float)(Q.Range + player.MoveSpeed * 2.5);

            if ((config.Item("WaitForStealth", true).GetValue <bool>() && ShacoStealth && cmbDmg < target.Health) ||
                !Orbwalking.CanMove(100))
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, cmbDmg);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() &&
                Game.CursorPos.Distance(target.Position) < 250 && target.Distance(player) < dist &&
                (target.Distance(player) >= config.Item("useqMin", true).GetValue <Slider>().Value ||
                 (cmbDmg > target.Health && player.CountEnemiesInRange(2000) == 1)))
            {
                if (target.Distance(player) < Q.Range)
                {
                    Q.Cast(Prediction.GetPrediction(target, 0.5f).UnitPosition);
                }
                else
                {
                    if (!CheckWalls(target) || Environment.Map.GetPath(player, target.Position) < dist)
                    {
                        Q.Cast(
                            player.Position.Extend(target.Position, Q.Range));
                    }
                }
            }
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && !target.UnderTurret(true) &&
                target.Health > cmbDmg && player.Distance(target) < W.Range)
            {
                HandleW(target);
            }
            if (config.Item("usee", true).GetValue <bool>() && E.CanCast(target))
            {
                E.CastOnUnit(target);
            }
            if (config.Item("user", true).GetValue <bool>() && R.IsReady() && !ShacoClone && target.HealthPercent < 75 &&
                cmbDmg < target.Health && target.HealthPercent > cmbDmg && target.HealthPercent > 25)
            {
                R.Cast();
            }
            if (config.Item("useIgnite").GetValue <bool>() &&
                player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health && hasIgnite)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
        }
Esempio n. 9
0
 public static bool IsDangerousPosition(this Vector3 pos)
 {
     return
         (HeroManager.Enemies.Any(
              e => e.IsValidTarget() && e.IsVisible &&
              e.Distance(pos) < Program.ComboMenu.Item("QMinDist").GetValue <Slider>().Value) ||
          Traps.EnemyTraps.Any(t => pos.Distance(t.Position) < 125) ||
          (pos.UnderTurret(true) && !Player.UnderTurret(true)) || pos.IsWall());
 }
Esempio n. 10
0
        private void LogicR()
        {
            if (!IsCastingR)                // 쏘는 도중이 아니면... 즉 R 한방 나가면 최대 사거리는 3500로 재조정
            {
                R.Range = Config.Item("MaxRangeR", true).GetValue <Slider>().Value;
            }
            else
            {
                R.Range = 3500;
            }

            var t = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);

            if (t.IsValidTarget())
            {
                rPosLast = R.GetPrediction(t).CastPosition;
                if (Config.Item("useR", true).GetValue <KeyBind>().Active&& !IsCastingR)        // 메뉴얼 R 발동
                {
                    R.Cast(rPosLast);
                    rTargetLast = t;
                }

                if (!IsCastingR && Config.Item("Rks", true).GetValue <bool>() &&
                    GetRdmg(t) * 3 > t.Health && t.CountAlliesInRange(500) == 0 && Player.CountEnemiesInRange(Config.Item("Rsafe", true).GetValue <Slider>().Value) == 0 &&
                    Player.Distance(t) > Config.Item("MinRangeR", true).GetValue <Slider>().Value &&
                    !Player.UnderTurret(true) && OktwCommon.ValidUlt(t) && !OktwCommon.IsSpellHeroCollision(t, R))
                {
                    R.Cast(rPosLast);
                    rTargetLast = t;
                }

                if (IsCastingR)    // 2타 이후에 로직
                {
                    if (InCone(t)) // R 사정거리 안에 있으면
                    {
                        R.Cast(t);
                    }
                    else
                    {
                        // 만약 타겟을 놓치면 다른 적을 찾아냄.
                        foreach (var enemy in Enemies.Where(enemy => enemy.IsValidTarget(R.Range) && InCone(enemy)).OrderBy(enemy => enemy.Health))
                        {
                            R.Cast(t);
                            rPosLast    = R.GetPrediction(enemy).CastPosition;
                            rTargetLast = enemy;
                        }
                    }
                }
            }
            else if (IsCastingR && rTargetLast != null && !rTargetLast.IsDead)
            {
                if (!Config.Item("Rvisable", true).GetValue <bool>())
                {
                    R.Cast(rPosLast);
                }
            }
        }
Esempio n. 11
0
 public static bool IsDangerousPosition(this Vector3 pos)
 {
     return
         (HeroManager.Enemies.Any(
              e => e.IsValidTarget() && e.IsVisible &&
              e.Distance(pos) < 375) ||
          Traps.EnemyTraps.Any(t => pos.Distance(t.Position) < 125) ||
          (pos.UnderTurret(true) && !Player.UnderTurret(true)) || pos.IsWall());
 }
Esempio n. 12
0
        private void LogicE()
        {
            var t            = TargetSelector.GetTarget(1300, TargetSelector.DamageType.Physical);
            var dashPosition = Player.Position.Extend(Game.CursorPos, E.Range);

            foreach (var target in Program.Enemies.Where(target => target.IsValidTarget(270) && target.IsMelee))
            {
                var dashPos = Dash.CastDash();
                if (!dashPos.IsZero)
                {
                    E.Cast(dashPos);
                }
            }

            if (t.IsValidTarget() && Player.HealthPercent > 40 && !Player.UnderTurret(true) && (Game.Time - OverKill > 0.3) && dashPosition.CountEnemiesInRange(900) < 3)
            {
                if (t.Distance(Game.CursorPos) + 300 < t.Position.Distance(Player.Position) && !Orbwalking.InAutoAttackRange(t))
                {
                    var dmgCombo = 0f;

                    if (t.IsValidTarget(950))
                    {
                        dmgCombo = (float)Player.GetAutoAttackDamage(t) + E.GetDamage(t);
                    }

                    if (Q.IsReady() && Player.Mana > QMANA + EMANA && Q.WillHit(dashPosition, Q.GetPrediction(t).UnitPosition))
                    {
                        dmgCombo = Q.GetDamage(t);
                    }

                    if (W.IsReady() && Player.Mana > QMANA + EMANA + WMANA)
                    {
                        dmgCombo += W.GetDamage(t);
                    }

                    if (dmgCombo > t.Health && OktwCommon.ValidUlt(t))
                    {
                        E.Cast(dashPosition);
                        OverKill = Game.Time;
                        Program.debug("E ks combo");
                    }
                }
            }
        }
Esempio n. 13
0
        private void LogicR()
        {
            if (!IsCastingR)
            {
                R.Range = Config.Item("MaxRangeR", true).GetValue <Slider>().Value;
            }
            else
            {
                R.Range = 3500;
            }

            var t = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);

            if (t.IsValidTarget())
            {
                rPosLast = R.GetPrediction(t).CastPosition;
                if (Config.Item("useR", true).GetValue <KeyBind>().Active&& !IsCastingR)
                {
                    R.Cast(rPosLast);
                    rTargetLast = t;
                }

                if (!IsCastingR && Config.Item("Rks", true).GetValue <bool>() &&
                    GetRdmg(t) * 4 > t.Health && t.CountAlliesInRange(700) == 0 && Player.CountEnemiesInRange(Config.Item("Rsafe", true).GetValue <Slider>().Value) == 0 &&
                    Player.Distance(t) > Config.Item("MinRangeR", true).GetValue <Slider>().Value &&
                    !Player.UnderTurret(true) && OktwCommon.ValidUlt(t) && !OktwCommon.IsSpellHeroCollision(t, R))
                {
                    R.Cast(rPosLast);
                    rTargetLast = t;
                }
                if (IsCastingR)
                {
                    if (InCone(t.ServerPosition))
                    {
                        R.Cast(t);
                    }
                    else
                    {
                        foreach (var enemy in Program.Enemies.Where(enemy => enemy.IsValidTarget(R.Range) && InCone(t.ServerPosition)).OrderBy(enemy => enemy.Health))
                        {
                            R.Cast(t);
                            rPosLast    = R.GetPrediction(enemy).CastPosition;
                            rTargetLast = enemy;
                        }
                    }
                }
            }
            else if (IsCastingR && rTargetLast != null && !rTargetLast.IsDead)
            {
                if (!Config.Item("Rvisable", true).GetValue <bool>() && InCone(rTargetLast.Position) && InCone(rPosLast))
                {
                    R.Cast(rPosLast);
                }
            }
        }
Esempio n. 14
0
        public static void FlowersText_E()
        {
            if (ShouldSaveCondemn() || (Player.UnderTurret(true)))
            {
                return;
            }
            var condemnTargets =
                HeroManager.Enemies.Where(
                    h => Player.Distance(h.ServerPosition) < FlowersVayne.E.Range && !h.HasBuffOfType(BuffType.SpellShield));

            foreach (var hero in condemnTargets)
            {
                var pushDist = Player.ServerPosition.Distance(hero.ServerPosition) + 395;
                if (hero.IsDashing())
                {
                    if (Player.ServerPosition.Extend(hero.GetDashInfo().EndPos.To3D(), -400).challenge_IsCollisionable())
                    {
                        FlowersVayne.E.Cast(hero);
                    }
                    break;
                }

                challenge_condemnEndPosSimplified = Player.ServerPosition.To2D().Extend(hero.ServerPosition.To2D(), pushDist).To3D();

                challenge_condemnEndPos = Player.ServerPosition.To2D().Extend(hero.ServerPosition.To2D(), pushDist).To3D();

                if (challenge_condemnEndPos.challenge_IsCollisionable())
                {
                    if (FlowersVayne.Menu.Item("nightmoon.e.fash").GetValue <Boolean>())
                    {
                        if (hero.IsFacing(Player) || !hero.CanMove || !hero.IsMoving)
                        {
                            FlowersVayne.E.Cast(hero);
                        }
                        return;
                    }

                    if (!hero.CanMove || hero.GetWaypoints().Count <= 1 || !hero.IsMoving)
                    {
                        FlowersVayne.E.Cast(hero);
                        return;
                    }

                    var wayPoints = hero.GetWaypoints();
                    var wCount    = wayPoints.Count;

                    if (wayPoints.Count(w => Player.ServerPosition.Extend(w.To3D(), pushDist).challenge_IsCollisionable()) >=
                        wCount)
                    {
                        FlowersVayne.E.Cast(hero);
                        return;
                    }
                }
            }
        }
Esempio n. 15
0
 private static void KeelQLogic()
 {
     if (Menu.Item("KeepQALive", true).GetValue <bool>() && !Me.UnderTurret(true) &&
         !Me.IsRecalling() && Me.HasBuff("RivenTriCleave"))
     {
         if (Me.GetBuff("RivenTriCleave").EndTime - Game.Time < 0.3)
         {
             Q.Cast(Game.CursorPos);
         }
     }
 }
Esempio n. 16
0
        private void LogicR()
        {
            if (Player.UnderTurret(true) && Config.Item("Rturrent", true).GetValue <bool>())
            {
                return;
            }
            if (Game.Time - WCastTime > 0.9 && Config.Item("autoR", true).GetValue <bool>())
            {
                bool cast = false;
                foreach (var target in Program.Enemies.Where(target => target.IsValidTarget(R.Range) && OktwCommon.ValidUlt(target)))
                {
                    float predictedHealth = target.Health + target.HPRegenRate * 2;
                    var   Rdmg            = R.GetDamage(target, 1);

                    if (Rdmg > predictedHealth)
                    {
                        cast = true;
                        PredictionOutput output    = R.GetPrediction(target);
                        Vector2          direction = output.CastPosition.To2D() - Player.Position.To2D();
                        direction.Normalize();
                        List <Obj_AI_Hero> enemies = Program.Enemies.Where(x => x.IsEnemy && x.IsValidTarget()).ToList();
                        foreach (var enemy in enemies)
                        {
                            if (enemy.SkinName == target.SkinName || !cast)
                            {
                                continue;
                            }
                            PredictionOutput prediction        = R.GetPrediction(enemy);
                            Vector3          predictedPosition = prediction.CastPosition;
                            Vector3          v      = output.CastPosition - Player.ServerPosition;
                            Vector3          w      = predictedPosition - Player.ServerPosition;
                            double           c1     = Vector3.Dot(w, v);
                            double           c2     = Vector3.Dot(v, v);
                            double           b      = c1 / c2;
                            Vector3          pb     = Player.ServerPosition + ((float)b * v);
                            float            length = Vector3.Distance(predictedPosition, pb);
                            if (length < (R.Width + 150 + enemy.BoundingRadius / 2) && Player.Distance(predictedPosition) < Player.Distance(target.ServerPosition))
                            {
                                cast = false;
                            }
                        }

                        if (cast && GetRealDistance(target) > bonusRange() + 300 + target.BoundingRadius && target.CountAlliesInRange(600) == 0 && Player.CountEnemiesInRange(400) == 0)
                        {
                            castR(target);
                        }
                        else if (cast && target.CountEnemiesInRange(200) > 2 && GetRealDistance(target) > bonusRange() + 200 + target.BoundingRadius)
                        {
                            R.Cast(target, true, true);
                        }
                    }
                }
            }
        }
Esempio n. 17
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                if (Menu.Item("HarassW", true).GetValue <bool>() && Q.IsReady())
                {
                    var target = TargetSelector.GetTarget(QExtend.Range, TargetSelector.DamageType.Physical);

                    if (CheckTarget(target, QExtend.Range))
                    {
                        if (target.IsValidTarget(Q.Range))
                        {
                            Q.Cast(target);
                        }
                        else if (target.IsValidTarget(QExtend.Range) && Menu.Item("HarassQExtended", true).GetValue <bool>())
                        {
                            var pred       = QExtend.GetPrediction(target, true);
                            var collisions = MinionManager.GetMinions(Me.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.NotAlly);

                            if (!collisions.Any())
                            {
                                return;
                            }

                            foreach (var minion in collisions)
                            {
                                var poly = new Geometry.Polygon.Rectangle(Me.ServerPosition, Me.ServerPosition.Extend(minion.ServerPosition, QExtend.Range), QExtend.Width);

                                if (poly.IsInside(pred.UnitPosition))
                                {
                                    Q.Cast(minion);
                                }
                            }
                        }
                    }
                }

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

                    if (CheckTarget(target, W.Range))
                    {
                        W.CastTo(target);
                    }
                }
            }
        }
Esempio n. 18
0
        private static void Combo()
        {
            if (Player.HasBuff("KennenLightningRush"))
            {
                return;
            }

            var         qSpell  = Config.Item("UseQ").GetValue <bool>();
            var         eSpell  = Config.Item("UseE").GetValue <bool>();
            var         wSpell  = Config.Item("UseW").GetValue <bool>();
            var         rSpell  = Config.Item("useR").GetValue <bool>();
            var         rCount  = Config.Item("useRc").GetValue <Slider>().Value;
            var         emSpell = Config.Item("useemin").GetValue <Slider>().Value;
            Obj_AI_Hero target  = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

            if (Player.HasBuff("KennenLightningRush") && Player.Health > target.Health && target.UnderTurret(true))
            {
                Player.IssueOrder(GameObjectOrder.MoveTo, target);
            }
            if (eSpell &&
                E.IsReady() &&
                (Player.Distance(target) < 80 &&
                 !Q.CanCast(target) ||
                 (!Player.HasBuff("KennenLightningRush") &&
                  !target.UnderTurret(true) &&
                  emSpell < Player.MaxMana)))
            {
                E.Cast();
            }

            if (qSpell &&
                target.IsValidTarget(Q.Range) &&
                Q.IsReady())
            {
                Q.Cast(target);
            }

            if (wSpell &&
                target.IsValidTarget(W.Range) &&
                W.IsReady() &&
                target.Buffs.Any(buff => buff.Name == "kennenmarkofstorm" && buff.Count == 2))
            {
                W.Cast();
            }
            if (rSpell &&
                R.IsReady()
                & target.IsValidTarget(R.Range) &&
                target.CountEnemiesInRange(R.Range) >= rCount)
            {
                R.Cast();
            }
        }
Esempio n. 19
0
        public void CastSpell(Spell spell, SpellDataInst sDataInst)
        {
            target = GetTarget(spell);
            if (target != null && spell.IsReady())
            {
                if (target.UnderTurret(true))
                {
                    return;
                }

                var pred = spell.GetPrediction(target);

                if (sDataInst.SData.IsToggleSpell)
                {
                    if (spell.Instance.ToggleState == 1)
                    {
                        if (sDataInst.SData.TargettingType == SpellDataTargetType.Location)
                        {
                            spell.Cast(pred.CastPosition);
                        }
                        else if (sDataInst.SData.TargettingType == SpellDataTargetType.Unit)
                        {
                            spell.CastOnUnit(target);
                        }
                        else
                        {
                            spell.Cast();
                        }
                    }
                }
                else
                {
                    if (spell.IsReady())
                    {
                        if (sDataInst.SData.TargettingType == SpellDataTargetType.Self)
                        {
                            spell.Cast();
                        }
                        else if (sDataInst.SData.TargettingType == SpellDataTargetType.Unit)
                        {
                            spell.CastOnUnit(target);
                        }
                        else if (pred.Hitchance >= HitChance.Medium)
                        {
                            spell.Cast(pred.CastPosition);
                        }
                    }
                }
            }
        }
Esempio n. 20
0
        private void Auto()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Menu.Item("AutoQ", true).GetValue <bool>() && Q.IsReady())
            {
                foreach (var target in HeroManager.Enemies.Where(x => x.IsValidTarget(Q.Range) && !x.CanMove()))
                {
                    if (CheckTarget(target, Q.Range))
                    {
                        Q.CastTo(target);
                    }
                }
            }

            if (Menu.Item("AutoR", true).GetValue <bool>() && R.IsReady() && Me.CountEnemiesInRange(850) >= 3)
            {
                R.Cast();
            }
        }
Esempio n. 21
0
        private void AutoE()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo)
            {
                foreach (
                    var target in
                    HeroManager.Enemies.Where(
                        x =>
                        x.IsValidTarget(E.Range) && !x.HasBuffOfType(BuffType.SpellShield) &&
                        Menu.Item("AutoE" + x.ChampionName.ToLower(), true).GetValue <bool>()))
                {
                    if (CheckTarget(target, E.Range))
                    {
                        ELogic(target);
                    }
                }
            }
        }
Esempio n. 22
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);

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

                    if (Menu.Item("HarassE", true).GetValue <bool>() && E.IsReady() && target.IsValidTarget(E.Range) &&
                        target.HasBuff("kalistaexpungemarker"))
                    {
                        var buffcount = target.GetBuffCount("kalistaexpungemarker");

                        if (Menu.Item("HarassELeave", true).GetValue <bool>() && target.DistanceToPlayer() >= 800 &&
                            target.IsValidTarget(E.Range) &&
                            buffcount >= Menu.Item("HarassECount", true).GetValue <Slider>().Value)
                        {
                            E.Cast();
                        }

                        if (Menu.Item("HarassESlow", true).GetValue <bool>())
                        {
                            var EKillMinion =
                                MinionManager
                                .GetMinions(Me.Position, E.Range, MinionTypes.All, MinionTeam.NotAlly)
                                .FirstOrDefault(x => x.HasBuff("kalistaexpungemarker") &&
                                                x.DistanceToPlayer() <= E.Range && x.Health < GetRealEDamage(x));

                            if (EKillMinion != null && EKillMinion.DistanceToPlayer() <= E.Range &&
                                target.IsValidTarget(E.Range) &&
                                buffcount >= Menu.Item("HarassECount", true).GetValue <Slider>().Value)
                            {
                                E.Cast();
                            }
                        }
                    }
                }
            }
        }
Esempio n. 23
0
        private void LogicE()
        {
            var t = TargetSelector.GetTarget(1300, TargetSelector.DamageType.Physical);

            if (Config.Item("EAntiMelee", true).GetValue <bool>())
            {
                if (Program.Enemies.Any(target => target.IsValidTarget(1000) && target.IsMelee && Player.Distance(Prediction.GetPrediction(target, 0.2f).CastPosition) < 250))
                {
                    var dashPos = Dash.CastDash(true);
                    if (!dashPos.IsZero)
                    {
                        E.Cast(dashPos);
                    }
                }
            }

            if (t.IsValidTarget() && Program.Combo && Config.Item("EKsCombo", true).GetValue <bool>() && Player.HealthPercent > 40 && t.Distance(Game.CursorPos) + 300 < t.Position.Distance(Player.Position) && !SebbyLib.Orbwalking.InAutoAttackRange(t) && !Player.UnderTurret(true) && (Game.Time - OverKill > 0.3))
            {
                var dashPosition = Player.Position.Extend(Game.CursorPos, E.Range);

                if (dashPosition.CountEnemiesInRange(900) < 3)
                {
                    var dmgCombo = 0f;

                    if (t.IsValidTarget(950))
                    {
                        dmgCombo = (float)Player.GetAutoAttackDamage(t) + E.GetDamage(t);
                    }

                    if (Q.IsReady() && Player.Mana > QMANA + EMANA && Q.WillHit(dashPosition, Q.GetPrediction(t).UnitPosition))
                    {
                        dmgCombo = Q.GetDamage(t);
                    }

                    if (W.IsReady() && Player.Mana > QMANA + EMANA + WMANA)
                    {
                        dmgCombo += W.GetDamage(t);
                    }

                    if (dmgCombo > t.Health && OktwCommon.ValidUlt(t))
                    {
                        E.Cast(dashPosition);
                        OverKill = Game.Time;
                        Program.debug("E ks combo");
                    }
                }
            }
        }
Esempio n. 24
0
 private bool NeedToUlt(Obj_AI_Hero target)
 {
     if (player.Distance(target) > 300f && !Q.CanCast(target))
     {
         return(true);
     }
     if (player.UnderTurret(true))
     {
         return(true);
     }
     if (player.Health < target.Health && player.Health < player.MaxHealth / 2)
     {
         return(true);
     }
     return(false);
 }
Esempio n. 25
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

                if (Menu.Item("HarassQ", true).GetValue <bool>() && Q.IsReady() && CheckTarget(target, Q.Range))
                {
                    Q.CastTo(target);
                }
            }
        }
Esempio n. 26
0
        /// <summary>
        /// Swipe/Javelin on gapclosers
        /// </summary>
        /// <param name="gapcloser"></param>
        internal static void AntiGapcloser_OnEnemyGapcloser(ActiveGapcloser gapcloser)
        {
            var attacker = gapcloser.Sender;

            if (attacker.IsValidTarget(275f) && !Player.UnderTurret(true))
            {
                if (CatForm())
                {
                    CM.CastSwipe(attacker, "gap");
                    CM.SwitchForm(attacker, "gap");
                }

                else
                {
                    CM.CastJavelin(attacker, "gap");
                    CM.SwitchForm(attacker, "gap");
                }
            }
        }
Esempio n. 27
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassWMana", true).GetValue <Slider>().Value)
            {
                if (Menu.Item("HarassW", true).GetValue <bool>() && W.IsReady() && !Me.HasBuff("AsheQAttack"))
                {
                    var target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);

                    if (CheckTarget(target, W.Range))
                    {
                        W.CastTo(target);
                    }
                }
            }
        }
Esempio n. 28
0
        public void SetAttack()
        {
            AttackableUnit orbTarget = orb.GetTarget();

            if (orbTarget != null)
            {
                if (orbTarget is Obj_AI_Hero)
                {
                    if (!Player.UnderTurret(true))
                    {
                        SetOrbWalk(orbTarget);
                    }
                }
                else if (orbTarget is Obj_AI_Minion)
                {
                    status = "Follow";
                    if (orbTarget.Health <= Player.GetAutoAttackDamage(Player, true))
                    {
                        orb.SetAttack(true);
                        Player.IssueOrder(GameObjectOrder.AttackUnit, orbTarget);
                    }
                }
            }
            else
            {
                status = "Follow";
            }

            lstTurrets = ObjectHandler.Get <Obj_AI_Turret>().Enemies.ToList().FindAll(t => !t.IsDead);
            turret     = lstTurrets.OrderBy(t => t.Distance(Player)).ToList().Count > 0 ? lstTurrets.OrderBy(t => t.Distance(Player)).ToList()[0] : null;

            if (turret != null)
            {
                if (turret.Distance(Player) <= Player.AttackRange)
                {
                    orb.SetAttack(true);
                }
            }
        }
Esempio n. 29
0
 private static void TurretChargeOnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
 {
     if (Player.IsDead || !sender.IsEnemy || !args.Target.IsAlly || !Player.UnderTurret())
     {
         return;
     }
     if (args.Target.IsMe)
     {
         if (sender.InventoryItems.Any(i => i.DisplayName == "Penetrating Bullets"))
         {
             if (WarmingStack < 2)
             {
                 WarmingStack++;
             }
             else if (HeatedStack < 2)
             {
                 HeatedStack++;
             }
         }
         if (sender.InventoryItems.Any(i => i.DisplayName == "Lightning Rod"))
         {
             if (HeatStack < 120)
             {
                 HeatStack += 6;
             }
         }
     }
     else if (args.Target is Obj_AI_Hero)
     {
         WarmingStack = 0;
         HeatStack    = 0;
     }
     else
     {
         WarmingStack = 0;
         HeatedStack  = 0;
         HeatStack    = 0;
     }
 }
Esempio n. 30
0
        private void Harass()
        {
            if (Me.UnderTurret(true))
            {
                return;
            }

            if (Me.ManaPercent >= Menu.Item("HarassMana", true).GetValue <Slider>().Value)
            {
                if (Menu.Item("HarassW", true).GetValue <bool>() && W.IsReady())
                {
                    var wTarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);

                    if (CheckTarget(wTarget, W.Range))
                    {
                        W.CastTo(wTarget);
                    }
                }

                if (Menu.Item("HarassE", true).GetValue <bool>() && E.IsReady())
                {
                    var eTarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);

                    if (CheckTarget(eTarget, E.Range))
                    {
                        if (eTarget.DistanceToPlayer() > E.Range * 0.8 && eTarget.IsValidTarget(E.Range) &&
                            GetEStackCount(eTarget) >= Menu.Item("HarassEStack", true).GetValue <Slider>().Value)
                        {
                            E.Cast();
                        }
                        else if (GetEStackCount(eTarget) >= 6)
                        {
                            E.Cast();
                        }
                    }
                }
            }
        }
Esempio n. 31
0
        public void CastSpell(Spell spell, SpellDataInst sDataInst)
        {
            target = GetTarget(spell);
            if (target != null && spell.IsReady())
            {

                if (target.UnderTurret(true))
                    return;

                var pred = spell.GetPrediction(target);

                if (sDataInst.SData.IsToggleSpell)
                {
                    if (spell.Instance.ToggleState == 1)
                    {
                        if (sDataInst.SData.TargettingType == SpellDataTargetType.Location)
                            spell.Cast(pred.CastPosition);
                        else if (sDataInst.SData.TargettingType == SpellDataTargetType.Unit)
                            spell.CastOnUnit(target);
                        else
                            spell.Cast();
                    }
                }
                else
                {
                    if (spell.IsReady())
                    {
                        if (sDataInst.SData.TargettingType == SpellDataTargetType.Self)
                            spell.Cast();
                        else if (sDataInst.SData.TargettingType == SpellDataTargetType.Unit)
                            spell.CastOnUnit(target);
                        else if (pred.Hitchance >= HitChance.Medium)
                        {
                            spell.Cast(pred.CastPosition);
                        }
                    }
                }
            }
        }
Esempio n. 32
0
        private void Combo(Obj_AI_Hero target)
        {
            if (target == null)
            {
                return;
            }
            var cmbDmg = ComboDamage(target);
            float dist = (float)(Q.Range + player.MoveSpeed * 2.5);
            if (ShacoClone && !GhostDelay && config.Item("useClone", true).GetValue<bool>())
            {
                var Gtarget = TargetSelector.GetTarget(dist, TargetSelector.DamageType.Physical);
                switch (config.Item("ghostTarget", true).GetValue<StringList>().SelectedIndex)
                {
                    case 0:
                        Gtarget = TargetSelector.GetTarget(GhostRange, TargetSelector.DamageType.Physical);
                        break;
                    case 1:
                        Gtarget =
                            ObjectManager.Get<Obj_AI_Hero>()
                                .Where(i => i.IsEnemy && !i.IsDead && player.Distance(i) <= GhostRange)
                                .OrderBy(i => i.Health)
                                .FirstOrDefault();
                        break;
                    case 2:
                        Gtarget =
                            ObjectManager.Get<Obj_AI_Hero>()
                                .Where(i => i.IsEnemy && !i.IsDead && player.Distance(i) <= GhostRange)
                                .OrderBy(i => player.Distance(i))
                                .FirstOrDefault();
                        break;
                    default:
                        break;
                }
                var clone = ObjectManager.Get<Obj_AI_Minion>().FirstOrDefault(m => m.Name == player.Name && !m.IsMe);
                if (clone != null && (System.Environment.TickCount - cloneTime > 16500f || clone.HealthPercent < 10) &&
                    !clone.IsWindingUp)
                {
                    var pos =
                        CombatHelper.PointsAroundTheTarget(clone.Position, 600)
                            .OrderByDescending(p => p.CountEnemiesInRange(250))
                            .ThenBy(p => Environment.Minion.countMinionsInrange(p, 250))
                            .FirstOrDefault();
                    if (pos.IsValid())
                    {
                        R.Cast(pos, config.Item("packets").GetValue<bool>());
                    }
                }
                if (clone != null && Gtarget.IsValid && !clone.IsWindingUp)
                {
                    if (CanCloneAttack() || player.HealthPercent < 25)
                    {
                        R.CastOnUnit(Gtarget, config.Item("packets").GetValue<bool>());
                    }
                    else
                    {
                        var prediction = Prediction.GetPrediction(Gtarget, 2);
                        R.Cast(
                            target.Position.Extend(prediction.UnitPosition, Orbwalking.GetRealAutoAttackRange(Gtarget)),
                            config.Item("packets").GetValue<bool>());
                    }

                    GhostDelay = true;
                    Utility.DelayAction.Add(200, () => GhostDelay = false);
                }
            }
            if ((config.Item("WaitForStealth", true).GetValue<bool>() && ShacoStealth && cmbDmg < target.Health) ||
                !Orbwalking.CanMove(100))
            {
                return;
            }
            if (config.Item("useItems").GetValue<bool>())
            {
                ItemHandler.UseItems(target, config, cmbDmg);
            }
            if (config.Item("useq", true).GetValue<bool>() && Q.IsReady() &&
                Game.CursorPos.Distance(target.Position) < 250 && target.Distance(player) < dist &&
                (target.Distance(player) >= config.Item("useqMin", true).GetValue<Slider>().Value ||
                 (cmbDmg > target.Health && player.CountEnemiesInRange(2000) == 1)))
            {
                if (target.Distance(player) < Q.Range)
                {
                    Q.Cast(target.Position, config.Item("packets").GetValue<bool>());
                }
                else
                {
                    if (!CheckWalls(target) || Environment.Map.GetPath(player, target.Position) < dist)
                    {
                        Q.Cast(
                            player.Position.Extend(target.Position, Q.Range), config.Item("packets").GetValue<bool>());
                    }
                }
            }
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            if (config.Item("usew", true).GetValue<bool>() && W.IsReady() && !target.UnderTurret(true) &&
                target.Health > cmbDmg && player.Distance(target) < W.Range)
            {
                HandleW(target);
            }
            if (config.Item("usee", true).GetValue<bool>() && E.CanCast(target))
            {
                E.CastOnUnit(target, config.Item("packets").GetValue<bool>());
            }
            if (config.Item("user", true).GetValue<bool>() && R.IsReady() && !ShacoClone && target.HealthPercent < 75 &&
                cmbDmg < target.Health && target.HealthPercent > cmbDmg && target.HealthPercent > 25)
            {
                R.Cast(config.Item("packets").GetValue<bool>());
            }
            if (config.Item("useIgnite").GetValue<bool>() &&
                player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health && hasIgnite)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
        }
Esempio n. 33
0
        public void Combo()
        {
            if (m_target != null && m_target.IsDead)
                m_target = null;

            if (Spells[Q].IsReady() && Config.Item("CUSEQ").GetValue<bool>())
            {
                var t = TargetSelector.GetTarget(Spells[Q].Range, TargetSelector.DamageType.Magical);
                if (t != null)
                    Spells[Q].SPredictionCastArc(t, HitChance.High, Config.Item("QPREDTYPE").GetValue<StringList>().SelectedIndex == 0);
            }

            if (m_target == null)
                m_target = HeroManager.Enemies.Where(p => HasMoonlight(p) && p.ServerPosition.Distance(ObjectManager.Player.ServerPosition) <= 900).OrderByDescending(q => TargetSelector.GetPriority(q)).FirstOrDefault();

            if (Config.Item("CUSER").GetValue<bool>())
            {
                if (m_target != null && Config.Item("CUSERMETHOD").GetValue<StringList>().SelectedIndex != 2 && Spells[R].IsReady())
                {
                    if (Spells[R].IsInRange(m_target) && ((m_target.UnderTurret() && !Config.Item("CUSERTOWER").GetValue<bool>()) || !m_target.UnderTurret()))
                    {
                        Spells[R].CastOnUnit(m_target);
                        if (!m_target.IsDead && Spells[W].IsReady() && Config.Item("CUSEW").GetValue<bool>()) //overkill check
                            Spells[W].Cast();

                        if (!m_target.IsDead) //overkill check
                        {
                            if (Config.Item("CUSERMETHOD").GetValue<StringList>().SelectedIndex != 1)
                            {
                                if (Spells[R].IsReady() && ((m_target.UnderTurret() && !Config.Item("CUSERTOWER").GetValue<bool>()) || !m_target.UnderTurret()))
                                {
                                    Spells[R].CastOnUnit(m_target);
                                    m_target = null;
                                }
                            }
                            if(Spells[E].IsReady() && Config.Item("CUSEE").GetValue<bool>())
                                Spells[E].Cast();
                        }
                        else
                            m_target = null;
                        return;
                    }
                    m_target = null;
                }

                if (m_target == null && (Config.Item("CUSERMETHOD").GetValue<StringList>().SelectedIndex == 2 || Config.Item("CUSERMETHOD").GetValue<StringList>().SelectedIndex == 0))
                {
                    var t = TargetSelector.GetTarget(Spells[R].Range, TargetSelector.DamageType.Magical);
                    if (t != null)
                    {
                        if (Config.Item("CUSERMETHOD").GetValue<StringList>().SelectedIndex == 2 || (Config.Item("CUSERMETHOD").GetValue<StringList>().SelectedIndex == 0 && CalculateDamageR(t) >= t.Health))
                        {
                            m_target = t;
                            if(((m_target.UnderTurret() && !Config.Item("CUSERTOWER").GetValue<bool>()) || !m_target.UnderTurret()))
                                Spells[R].CastOnUnit(t);
                        }
                    }
                }
            }

            {
                var t = m_target == null ? TargetSelector.GetTarget(Spells[E].Range, TargetSelector.DamageType.Magical) : m_target;
                if (t != null)
                {
                    if (!t.IsDead)
                    {
                        if (Spells[W].IsReady() && !Spells[E].IsReady() && Spells[W].IsInRange(t) && Config.Item("CUSEW").GetValue<bool>())
                            Spells[W].Cast();

                        if (!t.IsDead && Spells[E].IsReady() && Spells[W].IsReady() && Spells[E].IsInRange(t))
                        {
                            if (Config.Item("CUSEW").GetValue<bool>())
                                Spells[W].Cast();
                            if (Config.Item("CUSEE").GetValue<bool>())
                                Spells[E].Cast();
                        }
                    }
                    m_target = null;
                }
            }
        }
Esempio n. 34
0
        static void Drawing_OnDraw(EventArgs args)
        {
            if (!Menu.Item("switch").GetValue<Boolean>())
                return;

            Target = TargetSelector.GetSelectedTarget() != null ? TargetSelector.GetSelectedTarget() : Player;

            var buffs = string.Empty;

            foreach (var buff in Target.Buffs)
            {
                buffs += "\n" + buff.Name + "[Count: " + buff.Count + "/Duration: " + (buff.EndTime - Game.ClockTime).ToString("0.00") +"],";
            }

            var Mobs = MinionManager.GetMinions(1500, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
            var MobsList = string.Empty;

            foreach (var Mob in Mobs)
            {
                MobsList += "\n" + Mob.Name + "[Skinname: " + Mob.SkinName + "/HP: " + Mob.Health + " / " + Mob.MaxHealth + "(" + Mob.HealthPercent.ToString("0.0") + "%)],";
            }

            Render.Circle.DrawCircle(Player.Position, 1500, Color.Red, 10);

            Text.text =
                //"Name: " + Target.Name + NewLine +
                "ChampionName: " + Target.ChampionName + NewLine +
                "SkinName: " + Target.SkinName + NewLine +
                //"Gold: " + Target.Gold + NewLine +
                //"Level: " + Target.Level + NewLine +
                "TotalAttackDamage: " + Utility.TotalAttackDamage(Target) + NewLine +
                "TotalMagicalDamage: " + Utility.TotalMagicalDamage(Target) + NewLine +
                "Armor: " + Target.Armor + NewLine +
                "Health: " + Target.Health + " / " + Target.MaxHealth + " (" + Target.HealthPercent.ToString("0.0") + "%)" + NewLine +
                "Mana: " + Target.Mana + " / " + Target.MaxMana + " (" + Target.HealthPercent.ToString("0.0") + "%)" + NewLine +
                "HPRegenRate: " + Target.HPRegenRate + NewLine +
                "PARRegenRate: " + Target.PARRegenRate + NewLine +
                "Experience: " + Target.Experience + NewLine +
                "Position: " + Target.Position + NewLine +
                "ServerPosition: " + Target.ServerPosition + NewLine +
                "Team: " + Target.Team + NewLine +
                "NetworkId: " + Target.NetworkId + NewLine +
                "MoveSpeed: " + Target.MoveSpeed + NewLine +
                "AttackRange: " + Target.AttackRange + NewLine +
                "RealAutoAttackRange: " + Orbwalking.GetRealAutoAttackRange(Target) + NewLine +
                //"DeathDuration: " + Target.DeathDuration + NewLine +
                "BoundingRadius: " + Target.BoundingRadius + NewLine +
                NewLine +
                "Buffs: " + buffs + NewLine +
                NewLine +
                "IsDead: " + Target.IsDead + NewLine +
                "IsImmovable: " + Target.IsImmovable + NewLine +
                "IsInvulnerable: " + Target.IsInvulnerable + NewLine +
                "IsMoving: " + Target.IsMoving + NewLine +
                "IsPacified: " + Target.IsPacified + NewLine +
                "IsTargetable: " + Target.IsTargetable + NewLine +
                "IsWindingUp: " + Target.IsWindingUp + NewLine +
                "IsZombie: " + Target.IsZombie + NewLine +
                "IsRecalling: " + Target.IsRecalling() + NewLine +
                "IsStunned: " + Target.IsStunned + NewLine +
                "IsRooted: " + Target.IsRooted + NewLine +
                "IsMelee: " + Target.IsMelee() + NewLine +
                "IsDashing: " + Target.IsDashing() + NewLine +
                "IsAlly: " + Target.IsAlly + NewLine +
                "IsCanMove: " + Orbwalking.CanMove(1) + NewLine +
                "UnderTurret: " + Target.UnderTurret() + NewLine +
                NewLine +
                "Mobs: " + MobsList + NewLine +
                NewLine +
                "Game_CursorPos: " + Game.CursorPos + NewLine +
                "Game_ClockTime: " + Game.ClockTime + NewLine +
                "Game_Time: " + Game.Time + NewLine +
                "Game_Type: " + Game.Type + NewLine +
                "Game_Version: " + Game.Version + NewLine +
                "Game_Region: " + Game.Region + NewLine +
                "Game_IP: " + Game.IP + NewLine +
                "Game_Port: " + Game.Port + NewLine +
                "Game_Ping: " + Game.Ping + NewLine +
                "Game_Mode: " + Game.Mode + NewLine +
                "Game_MapId: " + Game.MapId + NewLine +
                "Game_MapName: " + Utility.Map.GetMap().Name
                ;

            Text.OnEndScene();
        }
Esempio n. 35
0
 private void Combo(Obj_AI_Hero target)
 {
     if (target == null)
     {
         return;
     }
     var cmbDmg = ComboDamage(target);
     float dist = (float) (Q.Range + player.MoveSpeed * 2.5);
     if (ShacoClone && !GhostDelay && config.Item("useClone", true).GetValue<bool>() &&
         !config.Item("autoMoveClone", true).GetValue<bool>())
     {
         moveClone();
     }
     if ((config.Item("WaitForStealth", true).GetValue<bool>() && ShacoStealth && cmbDmg < target.Health) ||
         !Orbwalking.CanMove(100))
     {
         return;
     }
     if (config.Item("useItems").GetValue<bool>())
     {
         ItemHandler.UseItems(target, config, cmbDmg);
     }
     if (config.Item("useq", true).GetValue<bool>() && Q.IsReady() &&
         Game.CursorPos.Distance(target.Position) < 250 && target.Distance(player) < dist &&
         (target.Distance(player) >= config.Item("useqMin", true).GetValue<Slider>().Value ||
          (cmbDmg > target.Health && player.CountEnemiesInRange(2000) == 1)))
     {
         if (target.Distance(player) < Q.Range)
         {
             Q.Cast(Prediction.GetPrediction(target, 0.5f).UnitPosition, config.Item("packets").GetValue<bool>());
         }
         else
         {
             if (!CheckWalls(target) || Environment.Map.GetPath(player, target.Position) < dist)
             {
                 Q.Cast(
                     player.Position.Extend(target.Position, Q.Range), config.Item("packets").GetValue<bool>());
             }
         }
     }
     bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
     if (config.Item("usew", true).GetValue<bool>() && W.IsReady() && !target.UnderTurret(true) &&
         target.Health > cmbDmg && player.Distance(target) < W.Range)
     {
         HandleW(target);
     }
     if (config.Item("usee", true).GetValue<bool>() && E.CanCast(target))
     {
         E.CastOnUnit(target, config.Item("packets").GetValue<bool>());
     }
     if (config.Item("user", true).GetValue<bool>() && R.IsReady() && !ShacoClone && target.HealthPercent < 75 &&
         cmbDmg < target.Health && target.HealthPercent > cmbDmg && target.HealthPercent > 25)
     {
         R.Cast(config.Item("packets").GetValue<bool>());
     }
     if (config.Item("useIgnite").GetValue<bool>() &&
         player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health && hasIgnite)
     {
         player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
     }
 }
Esempio n. 36
0
 private void QPredict(Obj_AI_Hero target)
 {
     if (Vector3.Distance(Player.ServerPosition, target.ServerPosition) < Q.Range)
     {
         if (myUtility.MovementImpaired(target))
         {
             Q.Cast(target.ServerPosition);
         }
         PredictionOutput pred = Q.GetPrediction(target);
         if (pred.CollisionObjects.Count == 0)
         {
             if (target.UnderTurret(true) && !config.Item("TurretDive").GetValue<bool>()) return;
             var test1 = Prediction.GetPrediction(target, Q.Instance.SData.SpellCastTime).CastPosition;
             float movement = target.MoveSpeed * 100 / 1000;
             if (target.Distance(test1) > movement)
             {
                 Q.Cast(target.ServerPosition.Extend(test1, Q.Instance.SData.SpellCastTime * target.MoveSpeed));
             }
             else
             {
                 if (pred.Hitchance >= QHitChance)
                 {
                     Q.Cast(pred.CastPosition);
                 }
             }
         }
     }
 }
Esempio n. 37
0
        private static void OnCombo(Obj_AI_Hero target)
        {
            var pounceDistance = target.IsHunted() ? 730 : _pounce.Range;
            if (_player.IsCougar())
            {
                /*if (_menu.Item("useTakedown").GetValue<bool>() && _takedown.IsReady() &&
                    _player.Distance(target.Position) <= _takedown.Range)
                {
                    _takedown.Cast(true);
                }*/

                if (_pounce.IsReady() && MainMenu.Item("usePounce").GetValue<bool>())
                {
                    if (MainMenu.Item("turretSafety").GetValue<bool>() && target.UnderTurret(true))
                    {
                        return;
                    }

                    if (MainMenu.Item("pounceHunted").GetValue<bool>())
                    {
                        if (target.IsHunted() && _player.Distance(target.ServerPosition) <= pounceDistance &&
                            _player.Distance(target) > _swipe.Range)
                        {
                            _pounce.Cast(target.ServerPosition);
                        }
                        if (!target.IsHunted() && _player.GetSpellDamage(target, SpellSlot.W) > target.Health + 20 &&
                            _player.Distance(target.ServerPosition) <= pounceDistance)
                        {
                            _pounce.Cast(target.ServerPosition);
                        }
                    }
                    else
                    {
                        if (_player.Distance(target) <= pounceDistance && _player.Distance(target) > _swipe.Range)
                        {
                            _pounce.Cast(target.ServerPosition);
                        }
                    }
                }

                if (MainMenu.Item("useSwipe").GetValue<bool>() && _swipe.IsReady() &&
                    _player.Distance(target.Position, true) <= _swipe.RangeSqr)
                {
                    _swipe.Cast(target);
                }

                //I'd call it 0.5% ?

                if (MainMenu.Item("useHuman").GetValue<bool>())
                {
                    if (_player.Distance(target.ServerPosition) > pounceDistance && HQ < 0.5 &&
                        _player.Distance(target.ServerPosition) < _javelinToss.Range && CW < 0.5)
                    {
                        var prediction = _javelinToss.GetPrediction(target);
                        if (_aspectOfTheCougar.IsReady() && prediction.Hitchance >= HitChance.Medium)
                        {
                            _aspectOfTheCougar.Cast();
                            //Utility.DelayAction.Add(200, () => _javelinToss.Cast(prediction.CastPosition));
                        }
                    }
                }
            }
            else
            {
                if (MainMenu.Item("useJavelin").GetValue<bool>() && _javelinToss.IsReady() &&
                    target.IsValidTarget(_javelinToss.Range) &&
                    _player.Distance(target.Position) <= MainMenu.Item("javelinRange").GetValue<Slider>().Value)
                {
                    _javelinToss.CastIfHitchanceEquals(target, CustomHitChance);
                }

                if (MainMenu.Item("useBushwhack").GetValue<bool>() && _bushwhack.IsReady() &&
                    target.IsValidTarget(_bushwhack.Range) && _player.Distance(target.Position) <= _bushwhack.Range)
                {
                    _bushwhack.CastIfHitchanceEquals(target, CustomHitChance);
                }

                if (MainMenu.Item("useCougar").GetValue<bool>() && (CW < 0.2) && (CQ < 0.2) && (CE < 0.2) &&
                    !_javelinToss.IsReady() && _player.Distance(target) <= pounceDistance)
                {
                    if (MainMenu.Item("pounceHunted").GetValue<bool>()) {}
                    if (_aspectOfTheCougar.IsReady())
                    {
                        _aspectOfTheCougar.Cast();
                    }
                }
            }
        }
Esempio n. 38
0
        private static void GameOnOnUpdate(EventArgs args)
        {
            JumpTarget = CommonTargetSelector.GetTarget(Q.Range*3, TargetSelector.DamageType.Physical);
            if (ModeConfig.Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo)
            {
                return;
            }

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

            if (!JumpObject.IsValidTarget(Q.Range))
            {
                return;
            }

            if (!Q.IsReady())
            {
                return;
            }

            if (!MenuLocal.Item("Jump.Enabled").GetValue<KeyBind>().Active)
            {
                return;
            }
            var jumpMode = MenuLocal.Item("Jump.Mode").GetValue<StringList>().SelectedIndex;
            if (jumpMode != 0)
            {

                switch (jumpMode)
                {
                    case 1:
                    {
                        Q.CastOnUnit(JumpObject);
                        break;
                    }
                    case 2:
                        {
                            if (JumpTarget.CanStun())
                            {
                                Q.CastOnUnit(JumpObject);
                            }
                            break;
                        }
                    case 3:
                        {
                            if (JumpTarget.Health < CommonMath.GetComboDamage(JumpTarget))
                            {
                                Q.CastOnUnit(JumpObject);
                            }
                            break;
                        }
                    case 4:
                        {
                            if (JumpTarget.CanStun() || JumpTarget.Health < CommonMath.GetComboDamage(JumpTarget))
                            {
                                Q.CastOnUnit(JumpObject);
                            }
                            break;
                        }
                }

            }

            //if (!JumpTarget.IsValidTarget(Q.Range) && !JumpTarget.IsValidTarget(Q.Range + Orbwalking.GetRealAutoAttackRange(null) + 65))
            //{
            //    ObjectManager.Player.IssueOrder(GameObjectOrder.MoveTo, JumpTarget);
            //}

            return;

            if (JumpTarget.UnderTurret(true) && MenuLocal.Item("Jump.TurretControl").GetValue<StringList>().SelectedIndex == 0)
            {
                return;
            }

            if (JumpTarget.UnderTurret(true)
                && MenuLocal.Item("Jump.TurretControl").GetValue<StringList>().SelectedIndex == 1
                && JumpTarget.Health < Common.CommonMath.GetComboDamage(JumpTarget))
            {
                Q.CastOnUnit(JumpObject);
            }

            var jumpQ = MenuLocal.Item("Jump.TurretControl").GetValue<StringList>().SelectedIndex;

            switch (jumpQ)
            {
                case 0:
                {
                    Q.CastOnUnit(JumpObject);
                    break;
                }

                case 1:
                {
                    if (JumpTarget.CanStun())
                    {
                        Q.CastOnUnit(JumpObject);
                    }
                    break;
                }

                case 2:
                {
                    if (JumpTarget.Health < Common.CommonMath.GetComboDamage(JumpTarget))
                    {
                        Q.CastOnUnit(JumpObject);
                    }
                    break;
                }
                case 3:
                {
                    if (JumpTarget.CanStun() && JumpTarget.Health < Common.CommonMath.GetComboDamage(JumpTarget))
                    {
                        Q.CastOnUnit(JumpObject);
                    }
                    break;
                }
            }
        }
Esempio n. 39
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);
         }
     }
 }