Exemple #1
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 HeroManager.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(500) == 0 && Player.CountEnemiesInRange(400) == 0)
                        {
                            Program.CastSpell(R, target);
                        }
                        else if (target.CountEnemiesInRange(200) > 2)
                        {
                            R.Cast(target, true, true);
                        }
                    }
                }
            }
        }
Exemple #2
0
        private void LogicR()
        {
            var r = Config[Player.CharacterName]["RConfig"];

            if (Player.IsUnderEnemyTurret() && r.GetValue <MenuBool>("Rturret").Enabled)
            {
                return;
            }
            if (Game.Time - WCastTime > 0.9 && r.GetValue <MenuBool>("autoR").Enabled)
            {
                foreach (var target in GameObjects.EnemyHeroes.Where(target => target.IsValidTarget(R.Range) && OktwCommon.ValidUlt(target)))
                {
                    var predictedHealth = target.Health - OktwCommon.GetIncomingDamage(target);
                    var Rdmg            = R.GetDamage(target);

                    if (Rdmg > predictedHealth && !OktwCommon.IsSpellHeroCollision(target, R) && GetRealDistance(target) > bonusRange() + 200)
                    {
                        if (GetRealDistance(target) > bonusRange() + 300 + target.BoundingRadius && target.CountAllyHeroesInRange(500) == 0 && Player.CountEnemyHeroesInRange(400) == 0)
                        {
                            CastSpell(R, target);
                        }
                        else if (target.CountEnemyHeroesInRange(200) > 2)
                        {
                            R.Cast(target, true, false, true);
                        }
                    }
                }
            }
        }
Exemple #3
0
        private void LogicR()
        {
            if (Config.Item("autoR", true).GetValue <bool>())
            {
                foreach (var target in HeroManager.Enemies.Where(target => target.IsValidTarget(2000) && OktwCommon.ValidUlt(target)))
                {
                    var rDmg = OktwCommon.GetKsDamage(target, R);
                    if (Program.Combo && target.CountEnemiesInRange(250) > 2 && Config.Item("autoRaoe", true).GetValue <bool>() && target.IsValidTarget(1500))
                    {
                        Program.CastSpell(R, target);
                    }
                    if (Program.Combo && target.IsValidTarget(W.Range) && Config.Item("Rkscombo", true).GetValue <bool>() && Player.GetAutoAttackDamage(target) * 5 + rDmg + W.GetDamage(target) > target.Health && target.HasBuffOfType(BuffType.Slow) && !OktwCommon.IsSpellHeroCollision(target, R))
                    {
                        Program.CastSpell(R, target);
                    }
                    if (rDmg > target.Health && target.CountAlliesInRange(600) == 0 && target.Distance(Player.Position) > 1000)
                    {
                        if (!OktwCommon.IsSpellHeroCollision(target, R))
                        {
                            Program.CastSpell(R, target);
                        }
                    }
                }
            }

            if (Player.HealthPercent < 50)
            {
                foreach (var enemy in HeroManager.Enemies.Where(enemy => enemy.IsValidTarget(300) && enemy.IsMelee && Config.Item("GapCloser" + enemy.ChampionName).GetValue <bool>() && OktwCommon.ValidUlt(enemy)))
                {
                    R.Cast(enemy);
                    Program.debug("R Meele");
                }
            }
        }
Exemple #4
0
        private static void LogicR()
        {
            if (getCheckBoxItem(RMenu, "autoR"))
            {
                foreach (var target in SebbyLib.Program.Enemies.Where(target => target.IsValidTarget(R.Range) && OktwCommon.ValidUlt(target)))
                {
                    var rDmg = OktwCommon.GetKsDamage(target, R);
                    if (SebbyLib.Program.Combo && target.CountEnemiesInRange(250) > 2 && getCheckBoxItem(RMenu, "autoRaoe"))
                    {
                        SebbyLib.Program.CastSpell(R, target);
                    }
                    if (SebbyLib.Program.Combo && target.IsValidTarget(W.Range) && getCheckBoxItem(RMenu, "Rkscombo") && Player.GetAutoAttackDamage(target) * 5 + rDmg + W.GetDamage(target) > target.Health && target.HasBuffOfType(BuffType.Slow) && !OktwCommon.IsSpellHeroCollision(target, R))
                    {
                        SebbyLib.Program.CastSpell(R, target);
                    }
                    if (rDmg > target.Health && target.CountAlliesInRange(600) == 0 && target.Distance(Player.Position) > 1000)
                    {
                        if (!OktwCommon.IsSpellHeroCollision(target, R))
                        {
                            SebbyLib.Program.CastSpell(R, target);
                        }
                    }
                }
            }

            if (Player.HealthPercent < 50)
            {
                foreach (var enemy in SebbyLib.Program.Enemies.Where(enemy => enemy.IsValidTarget(300) && enemy.IsMelee && getCheckBoxItem(RMenu, "GapCloser" + enemy.ChampionName) && !OktwCommon.ValidUlt(enemy)))
                {
                    R.Cast(enemy);
                    SebbyLib.Program.debug("R Meele");
                }
            }
        }
        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);
                }
            }
        }
Exemple #6
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.IsValidTargetLS())
            {
                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 HeroManager.Enemies.Where(enemy => enemy.IsValidTargetLS(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);
                }
            }
        }
Exemple #7
0
        private static void LogicR()
        {
            if (!IsCastingR)
            {
                R.Range = getSliderItem(rMenu, "MaxRangeR");
            }
            else
            {
                R.Range = 3500;
            }

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

            if (t.LSIsValidTarget())
            {
                rPosLast = R.GetPrediction(t).CastPosition;
                if (getKeyBindItem(rMenu, "useR") && !IsCastingR)
                {
                    R.Cast(rPosLast);
                    rTargetLast = t;
                }

                if (!IsCastingR && getCheckBoxItem(rMenu, "Rks") &&
                    GetRdmg(t) * 4 > t.Health && t.CountAlliesInRange(700) == 0 && Player.LSCountEnemiesInRange(getSliderItem(rMenu, "Rsafe")) == 0 &&
                    Player.LSDistance(t) > getSliderItem(rMenu, "MinRangeR") &&
                    !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.LSIsValidTarget(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 (!getCheckBoxItem(rMenu, "Rvisable") && InCone(rTargetLast.Position) && InCone(rPosLast))
                {
                    R.Cast(rPosLast);
                }
            }
        }
Exemple #8
0
        private void LogicR()
        {
            foreach (var target in HeroManager.Enemies.Where(target => target.IsValidTarget(R1.Range) && OktwCommon.ValidUlt(target)))
            {
                double rDmg = OktwCommon.GetKsDamage(target, R);

                if (rDmg < target.Health)
                {
                    continue;
                }

                if (Config.Item("overkillR", true).GetValue <bool>() && target.Health < Player.Health)
                {
                    if (SebbyLib.Orbwalking.InAutoAttackRange(target))
                    {
                        continue;
                    }
                    if (target.CountAlliesInRange(400) > 0)
                    {
                        continue;
                    }
                }

                double rDmg2 = rDmg * 0.8;

                if (target.IsValidTarget(R.Range) && !OktwCommon.IsSpellHeroCollision(target, R) && rDmg > target.Health)
                {
                    Program.CastSpell(R, target);
                    Program.debug("Rdmg");
                }
                else if (rDmg2 > target.Health)
                {
                    if (!OktwCommon.IsSpellHeroCollision(target, R1))
                    {
                        Program.CastSpell(R1, target);
                        Program.debug("Rdmg2");
                    }
                    else if (target.IsValidTarget(1200))
                    {
                        Program.CastSpell(R1, target);
                        Program.debug("Rdmg2 collision");
                    }
                }
            }
        }
Exemple #9
0
        private void LogicR()
        {
            foreach (var target in GameObjects.EnemyHeroes.Where(e => e.IsValidTarget(R1.Range) && OktwCommon.ValidUlt(e)))
            {
                var rDmg = OktwCommon.GetKsDamage(target, R);

                if (rDmg < target.Health)
                {
                    continue;
                }

                if (overkillR.Enabled && target.Health < Player.Health)
                {
                    if (target.InAutoAttackRange())
                    {
                        continue;
                    }

                    if (target.CountAllyHeroesInRange(400) > 0)
                    {
                        continue;
                    }
                }

                var rDmg2 = rDmg * 0.8;

                if (target.IsValidTarget(R.Range) && !OktwCommon.IsSpellHeroCollision(target, R) && rDmg > target.Health)
                {
                    CastSpell(R, target);
                }
                else if (rDmg2 > target.Health)
                {
                    if (!OktwCommon.IsSpellHeroCollision(target, R1))
                    {
                        CastSpell(R1, target);
                    }
                    else if (target.IsValidTarget(1200))
                    {
                        CastSpell(R1, target);
                    }
                }
            }
        }
Exemple #10
0
        private static void KSAshe()
        {
            if (Menu.Item("KillSteal").GetValue <bool>())
            {
                var target = Orbwalker.GetTarget() as Obj_AI_Hero;

                if (target.IsValidTarget(W.Range) &&
                    (target.Health < W.GetDamage(target) + R.GetDamage(target) + OktwCommon.GetIncomingDamage(target)))
                {
                    DontREnemyNearAlly();
                    if (!target.CanMove || target.IsStunned)
                    {
                        W.Cast(target.Position);
                    }
                    if (!OktwCommon.IsSpellHeroCollision(target, R))
                    {
                        SebbySpell(R, target);
                    }
                }
                if (target.IsValidTarget(W.Range) &&
                    (target.Health < W.GetDamage(target) + OktwCommon.GetIncomingDamage(target)))
                {
                    if (target.CanMove)
                    {
                        SebbySpell(W, target);
                    }
                    else
                    {
                        W.Cast(target.Position);
                    }
                }
                if (target.IsValidTarget(1600) &&
                    (target.Health < R.GetDamage(target) + OktwCommon.GetIncomingDamage(target)))
                {
                    DontREnemyNearAlly();
                    if (!OktwCommon.IsSpellHeroCollision(target, R))
                    {
                        SebbySpell(R, target);
                    }
                }
                // More to be Added
            }
        }
Exemple #11
0
        private void KSAshe()
        {
            if (Config.KillSteal.GetValue <bool>())
            {
                var target = Orbwalker.GetTarget() as AIHeroClient;

                if (target.IsValidTarget(W.Range) &&
                    (target.Health < W.GetDamage(target) + R.GetDamage(target) + OktwCommon.GetIncomingDamage(target)))
                {
                    if (!OktwCommon.IsSpellHeroCollision(target, R))
                    {
                        SpellCast.SebbySpellMain(R, target);
                    }
                    if (!target.CanMove || target.IsStunned)
                    {
                        SpellCast.SebbySpellMain(W, target);
                    }
                }
                if (target.IsValidTarget(1600) &&
                    (target.Health < R.GetDamage(target) + OktwCommon.GetIncomingDamage(target)))
                {
                    if (!OktwCommon.IsSpellHeroCollision(target, R))
                    {
                        SpellCast.SebbySpellMain(R, target);
                    }
                }
                if (target.IsValidTarget(W.Range) &&
                    (target.Health < W.GetDamage(target) + OktwCommon.GetIncomingDamage(target)))
                {
                    if (target.CanMove)
                    {
                        SpellCast.SebbySpellMain(W, target);
                    }
                    else
                    {
                        SpellCast.SebbySpellMain(W, target);
                    }
                }
                // More to be Added
            }
        }
Exemple #12
0
        private static void RLogic()
        {
            if (!IsCastingR && Config.GetBool("自动R"))
            {
                var target = TargetSelector.GetTarget(R.Range - 400, TargetSelector.DamageType.Physical);
                if (target != null && target.IsValid && !target.IsDead &&
                    GetRDmg(target) > target.Health &&
                    OktwCommon.ValidUlt(target) && !OktwCommon.IsSpellHeroCollision(target, R) &&
                    target.CountAlliesInRange(600) == 0 &&
                    LastPosition.GetLastPositionsInRange(Player, 1000, 4000).Count == 0 &&
                    !Player.UnderTurret(true) &&
                    !target.InFountain())
                {
                    if (R.CastSpell(target))
                    {
                        RCharge.Target = target;
                    }
                }
            }

            #region 自动R逻辑

            if (IsCastingR)
            {
                if (Config.Item("R放眼").GetValue <bool>() && ScryingOrb.IsReady())
                {
                    var pistionList = VectorHelper.GetLastPositionInRCone().Where(m => !m.Hero.IsVisible && !m.Hero.IsDead && Game.ClockTime - m.LastSeen < 7 * 1000).OrderByDescending(m => m.LastSeen);

                    if (RCharge.Target == null && pistionList.Count() > 0)
                    {
                        var MissPosition = pistionList.First();
                        var MostNearBush = VectorHelper.GetBushNearPosotion(MissPosition.LastPosition);
                        if (MostNearBush != Vector3.Zero && MostNearBush.Distance(MissPosition.LastPosition) < 500)
                        {
                            ScryingOrb.Cast(MostNearBush);
                        }
                        else
                        {
                            ScryingOrb.Cast(MissPosition.LastPosition);
                        }
                    }
                    else if (RCharge.Target != null && !RCharge.Target.IsVisible && !RCharge.Target.IsDead)
                    {
                        var RTargetLastPosition = pistionList?.Find(m => m.Hero == RCharge.Target && Game.ClockTime - m.LastSeen < 3 * 1000);
                        if (RTargetLastPosition != null)
                        {
                            var MostNearBush = VectorHelper.GetBushNearPosotion(RTargetLastPosition.LastPosition);
                            if (MostNearBush.Distance(RTargetLastPosition.LastPosition) < 500)
                            {
                                ScryingOrb.Cast(MostNearBush);
                            }
                            else
                            {
                                ScryingOrb.Cast(RTargetLastPosition.LastPosition);
                            }
                        }
                    }
                }

                var target = GetTargetInR();
                if (target != null)
                {
                    #region 使用R,并记录R目标和施放时间
                    if (RCharge.Index == 0)
                    {
                        if (R.CastSpell(target))
                        {
                            RCharge.Target = target;
                        }
                    }
                    else
                    {
                        Utility.DelayAction.Add(delay[RCharge.Index - 1], () =>
                        {
                            if (R.CastSpell(target))
                            {
                                RCharge.Target = target;
                            }
                        });
                    }
                    #endregion
                }
            }

            #endregion
        }