예제 #1
0
        private static void AutoUseEvent()
        {
            if (MiscOption.GetKey("R", "SemiRKey").Active)
            {
                Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);

                if (Me.Spellbook.GetSpell(SpellSlot.R).Level > 0 && R.IsReady())
                {
                    var target = MyTargetSelector.GetTarget(R.Range);
                    if (target.IsValidTarget(R.Range) && !target.IsValidTarget(MiscOption.GetSlider("R", "GlobalRMin").Value))
                    {
                        var rPred = R.GetPrediction(target);

                        if (rPred.Hitchance >= HitChance.High)
                        {
                            R.Cast(rPred.CastPosition);
                        }
                    }
                }
            }

            if (MiscOption.GetBool("W", "WSlow").Enabled&& W.IsReady() && Me.HasBuffOfType(BuffType.Slow))
            {
                W.Cast();
            }
        }
예제 #2
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(Q.Range);

            if (target.IsValidTarget(Q.Range))
            {
                if (ComboOption.UseE && E.IsReady() && Me.HasBuff("QuinnR") && target.IsValidTarget(E.Range))
                {
                    E.CastOnUnit(target);
                }

                if (ComboOption.UseQ && Q.IsReady() && !Me.HasBuff("QuinnR"))
                {
                    if (target.DistanceToPlayer() <= Me.AttackRange + Me.BoundingRadius + target.BoundingRadius - 50 && HavePassive(target))
                    {
                        return;
                    }

                    var qPred = Q.GetPrediction(target);

                    if (qPred.Hitchance >= HitChance.High)
                    {
                        Q.Cast(qPred.UnitPosition);
                    }
                }

                if (ComboOption.UseW && W.IsReady())
                {
                    if (target.PreviousPosition.IsGrass())
                    {
                        W.Cast();
                    }
                }
            }
        }
예제 #3
0
        private static void OneKeyCastE()
        {
            var target = MyTargetSelector.GetTarget(E.Range);

            if (target.IsValidTarget(E.Range))
            {
                if (target.Health <
                    Me.GetSpellDamage(target, SpellSlot.E) * (target.GetBuffCount("TristanaECharge") * 0.30) +
                    Me.GetSpellDamage(target, SpellSlot.E))
                {
                    E.CastOnUnit(target);
                }

                if (Me.CountEnemyHeroesInRange(1200) == 1)
                {
                    if (Me.HealthPercent >= target.HealthPercent && Me.Level + 1 >= target.Level)
                    {
                        E.CastOnUnit(target);
                    }
                    else if (Me.HealthPercent + 20 >= target.HealthPercent &&
                             Me.HealthPercent >= 40 && Me.Level + 2 >= target.Level)
                    {
                        E.CastOnUnit(target);
                    }
                }
            }
        }
예제 #4
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(Q.Range);

            if (target.IsValidTarget(Q.Range))
            {
                if (ComboOption.UseE && E.Ready && Me.HasBuff("QuinnR") && target.IsValidTarget(E.Range))
                {
                    E.CastOnUnit(target);
                }

                if (ComboOption.UseQ && Q.Ready && !Me.HasBuff("QuinnR"))
                {
                    if (target.DistanceToPlayer() <= Me.AttackRange + Me.BoundingRadius + target.BoundingRadius - 50 && HavePassive(target))
                    {
                        return;
                    }

                    var qPred = Q.GetPrediction(target);

                    if (qPred.HitChance >= HitChance.High)
                    {
                        Q.Cast(qPred.UnitPosition);
                    }
                }

                if (ComboOption.UseW && W.Ready)
                {
                    if (NavMesh.WorldToCell(target.ServerPosition).Flags == NavCellFlags.Grass)
                    {
                        W.Cast();
                    }
                }
            }
        }
예제 #5
0
        private static void SemiRLogic()
        {
            var target = MyTargetSelector.GetTarget(R.Range);

            if (target != null && !target.HaveShiledBuff() && target.IsValidTarget(R.Range))
            {
                R2.Cast(target);
            }
        }
예제 #6
0
        private static void OneKeyCastR()
        {
            var target = MyTargetSelector.GetTarget(R.Range);

            if (target != null && target.IsValidTarget(R.Range))
            {
                R.CastOnUnit(target);
            }
        }
예제 #7
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(E.Range);

            if (target.IsValidTarget(E.Range))
            {
                if (ComboOption.UseR && R.IsReady())
                {
                    if (ComboOption.GetBool("ComboRKillSteal").Enabled&&
                        GameObjects.EnemyHeroes.Count(x => x.DistanceToPlayer() <= R.Range) <= 2 &&
                        target.Health <= Me.GetAutoAttackDamage(target) * 4 + GetRealEDamage(target) * 2)
                    {
                        R.Cast();
                    }

                    if (GameObjects.EnemyHeroes.Count(x => x.DistanceToPlayer() <= R.Range) >= ComboOption.GetSlider("ComboRCount").Value)
                    {
                        R.Cast();
                    }
                }

                if (ComboOption.UseQ && Q.IsReady() &&
                    GameObjects.EnemyHeroes.Count(x => x.DistanceToPlayer() <= ComboOption.GetSlider("ComboQRange").Value) >=
                    ComboOption.GetSlider("ComboQCount").Value)
                {
                    Q.Cast();
                }

                if (ComboOption.UseW && W.IsReady() && target.IsValidTarget(W.Range) &&
                    target.Health > GetRealEDamage(target) && GetEStackCount(target) < 6 &&
                    Me.Mana > Q.Mana + W.Mana + E.Mana + R.Mana)
                {
                    var wPred = W.GetPrediction(target);

                    if (wPred.Hitchance >= HitChance.High)
                    {
                        W.Cast(wPred.CastPosition);
                    }
                }

                if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(E.Range) &&
                    target.Buffs.Any(b => b.Name.ToLower() == "twitchdeadlyvenom"))
                {
                    if (ComboOption.GetBool("ComboEFull").Enabled&& GetEStackCount(target) >= 6)
                    {
                        E.Cast();
                    }

                    if (ComboOption.GetBool("ComboEKill").Enabled&& target.Health <= GetRealEDamage(target) &&
                        target.IsValidTarget(E.Range))
                    {
                        E.Cast();
                    }
                }
            }
        }
예제 #8
0
        private static void Auto()
        {
            if (MiscOption.GetBool("Q", "AutoQ").Enabled&& Q.IsReady() &&
                Orbwalker.ActiveMode != OrbwalkerMode.Combo && Orbwalker.ActiveMode != OrbwalkerMode.Harass)
            {
                var target = MyTargetSelector.GetTarget(Q.Range - 50);

                if (target.IsValidTarget(Q.Range) && !target.CanMoveMent())
                {
                    Q.Cast(target.PreviousPosition);
                }
            }

            if (W.IsReady())
            {
                if (MiscOption.GetBool("W", "AutoWCC").Enabled)
                {
                    foreach (
                        var target in
                        GameObjects.EnemyHeroes.Where(
                            x => x.IsValidTarget(W.Range) && !x.CanMoveMent() && !x.HasBuff("caitlynyordletrappublic")))
                    {
                        if (Variables.GameTimeTickCount - lastWTime > 1500)
                        {
                            W.Cast(target.PreviousPosition);
                        }
                    }
                }

                if (MiscOption.GetBool("W", "AutoWTP").Enabled)
                {
                    var obj =
                        ObjectManager
                        .Get <AIBaseClient>()
                        .FirstOrDefault(x => !x.IsAlly && !x.IsMe && x.DistanceToPlayer() <= W.Range &&
                                        x.Buffs.Any(
                                            a =>
                                            a.Name.ToLower().Contains("teleport") ||
                                            a.Name.ToLower().Contains("gate")) &&
                                        !ObjectManager.Get <AIBaseClient>()
                                        .Any(b => b.Name.ToLower().Contains("trap") && b.Distance(x) <= 150));

                    if (obj != null)
                    {
                        if (Variables.GameTimeTickCount - lastWTime > 1500)
                        {
                            W.Cast(obj.PreviousPosition);
                        }
                    }
                }
            }
        }
예제 #9
0
        private static void Auto()
        {
            if (Q.IsReady())
            {
                if (MiscOption.GetKey("Q", "SemiQ").Active)
                {
                    var target = MyTargetSelector.GetTarget(Q.Range);

                    if (target != null && target.IsValidTarget(Q.Range))
                    {
                        var qPred = Q.GetPrediction(target);

                        if (qPred.Hitchance >= HitChance.High)
                        {
                            Q.Cast(qPred.CastPosition);
                        }
                    }
                }

                if (MiscOption.GetBool("Q", "AutoQImmobile").Enabled)
                {
                    var target = GameObjects.EnemyHeroes.FirstOrDefault(x => x.IsValidTarget(Q.Range) && !x.CanMoveMent());

                    if (target != null && target.IsValidTarget(Q.Range))
                    {
                        Q.Cast(target.PreviousPosition);
                    }
                }
            }

            if (W.IsReady())
            {
                if (MiscOption.GetKey("CardSelect", "CardSelectYellow").Active)
                {
                    HumanizerCardSelect.Select = HumanizerCards.Yellow;
                    HumanizerCardSelect.StartSelecting(HumanizerCards.Yellow);
                }

                if (MiscOption.GetKey("CardSelect", "CardSelectBlue").Active)
                {
                    HumanizerCardSelect.Select = HumanizerCards.Blue;
                    HumanizerCardSelect.StartSelecting(HumanizerCards.Blue);
                }

                if (MiscOption.GetKey("CardSelect", "CardSelectRed").Active)
                {
                    HumanizerCardSelect.Select = HumanizerCards.Red;
                    HumanizerCardSelect.StartSelecting(HumanizerCards.Red);
                }
            }
        }
예제 #10
0
        private static void SemiRLogic()
        {
            var target = MyTargetSelector.GetTarget(R.Range - 150);

            if (target.IsValidTarget(R.Range))
            {
                var rPred = R.GetPrediction(target);

                if (rPred.Hitchance >= HitChance.High)
                {
                    R.Cast(rPred.UnitPosition);
                }
            }
        }
예제 #11
0
        private static void OneKeyCastR()
        {
            var target = MyTargetSelector.GetTarget(R.Range);

            if (target.IsValidTarget(R.Range) && !target.IsValidTarget(MiscOption.GetSlider("R", "RRange").Value))
            {
                var rPred = R.GetPrediction(target);

                if (rPred.HitChance >= HitChance.High)
                {
                    R.Cast(rPred.CastPosition);
                }
            }
        }
예제 #12
0
        private static void ComboEvent()
        {
            if (ComboOption.GetBool("ComboGapcloser").Enabled)
            {
                ForcusAttack();
            }

            var target = MyTargetSelector.GetTarget(Q.Range);

            if (target != null && target.IsValidTarget(Q.Range))
            {
                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range) && !target.InAutoAttackRange())
                {
                    var qPred = Q.GetPrediction(target);

                    if (qPred.Hitchance >= HitChance.High)
                    {
                        Q.Cast(qPred.CastPosition);
                    }
                }

                if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(E.Range) &&
                    Variables.GameTimeTickCount - lastETime > 500 + Game.Ping)
                {
                    if (target.Health < E.GetKalistaRealDamage(target,
                                                               MiscOption.GetSliderBool("E", "EToler").Enabled,
                                                               MiscOption.GetSliderBool("E", "EToler").Value) &&
                        !target.IsUnKillable())
                    {
                        E.Cast();
                    }

                    if (ComboOption.GetBool("ComboESlow").Enabled&&
                        target.DistanceToPlayer() > Me.AttackRange + Me.BoundingRadius + 100 &&
                        target.IsValidTarget(E.Range))
                    {
                        var EKillMinion = GameObjects.Minions.Where(x => x.IsValidTarget(Me.GetRealAutoAttackRange(x)))
                                          .FirstOrDefault(x => x.Buffs.Any(a => a.Name.ToLower().Contains("kalistaexpungemarker")) &&
                                                          x.DistanceToPlayer() <= E.Range && x.Health < E.GetKalistaRealDamage(x));

                        if (EKillMinion != null && EKillMinion.IsValidTarget(E.Range) &&
                            target.IsValidTarget(E.Range))
                        {
                            E.Cast();
                        }
                    }
                }
            }
        }
예제 #13
0
        private static void SemiRLogic()
        {
            if (R.Ready && R.GetBasicSpell().Ammo > 0)
            {
                var target = MyTargetSelector.GetTarget(R.Range);

                if (target.IsValidTarget(R.Range))
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.HitChance >= HitChance.High)
                    {
                        R.Cast(rPred.UnitPosition);
                    }
                }
            }
        }
예제 #14
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(R.Range, ComboOption.GetBool("ComboForcus").Enabled);

            if (target.IsValidTarget(R.Range) && !target.IsUnKillable())
            {
                if (ComboOption.UseR && R.Ready && ComboOption.GetSlider("ComboRLimit").Value > GetRCount &&
                    target.IsValidTarget(R.Range) && target.HealthPercent() <= ComboOption.GetSlider("ComboRHP").Value&&
                    (!ComboOption.GetBool("ComboROnlyOutAARange").Enabled ||
                     ComboOption.GetBool("ComboROnlyOutAARange").Enabled&& !target.IsValidAutoRange()))
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.HitChance >= HitChance.High)
                    {
                        R.Cast(rPred.CastPosition);
                    }
                }

                if (ComboOption.UseQ && Q.Ready && target.IsValidTarget(Q.Range))
                {
                    var qPred = Q.GetPrediction(target);

                    if (qPred.HitChance >= HitChance.Medium)
                    {
                        Q.Cast(qPred.CastPosition);
                    }
                }

                if (ComboOption.UseE && E.Ready && target.IsValidTarget(E.Range))
                {
                    var ePred = E.GetPrediction(target);

                    if (ePred.HitChance >= HitChance.High)
                    {
                        E.Cast(ePred.CastPosition);
                    }
                }

                if (ComboOption.UseW && W.Ready && target.IsValidTarget(W.Range) &&
                    !target.IsValidAutoRange() && Orbwalker.CanAttack())
                {
                    W.Cast();
                }
            }
        }
예제 #15
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(R.Range);

            if (target.IsValidTarget(R.Range) && !target.IsUnKillable() && (!target.IsValidAutoRange() || !Orbwalker.CanAttack()))
            {
                if (ComboOption.UseR && R.Ready &&
                    R.GetBasicSpell().Ammo >= ComboOption.GetSlider("ComboRLimit").Value&&
                    target.IsValidTarget(R.Range) && target.HealthPercent() <= ComboOption.GetSlider("ComboRHP").Value)
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.HitChance >= HitChance.High)
                    {
                        R.Cast(rPred.UnitPosition);
                    }
                    else if (rPred.HitChance == HitChance.Collision)
                    {
                        foreach (var collsion in rPred.CollisionObjects.Where(x => x.IsValidTarget(R.Range)))
                        {
                            if (collsion.DistanceSqr(target) <= 85 * 85)
                            {
                                R.Cast(collsion.ServerPosition);
                            }
                        }
                    }
                }

                if (ComboOption.UseQ && Q.Ready && target.IsValidTarget(Q.Range))
                {
                    var qPred = Q.GetPrediction(target);

                    if (qPred.HitChance >= HitChance.High)
                    {
                        Q.Cast(qPred.CastPosition);
                    }
                }

                if (ComboOption.UseE && E.Ready && target.IsValidTarget(E.Range))
                {
                    E.Cast();
                }
            }
        }
예제 #16
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(E.Range);

            if (target.IsValidTarget(E.Range))
            {
                if (ComboOption.UseQ && Q.IsReady())
                {
                    if (!ComboOption.GetBool("ComboQAlways").Enabled)
                    {
                        if (!E.IsReady() && target.HasBuff("TristanaECharge"))
                        {
                            Q.Cast();
                        }
                        else if (!E.IsReady() && !target.HasBuff("TristanaECharge") && E.CooldownTime > 4)
                        {
                            Q.Cast();
                        }
                    }
                    else
                    {
                        Q.Cast();
                    }
                }

                if (ComboOption.UseE && E.IsReady() && !ComboOption.GetBool("ComboQAlways").Enabled&& target.IsValidTarget(E.Range))
                {
                    E.CastOnUnit(target);
                }

                if (ComboOption.UseR && R.IsReady() && Me.HealthPercent <= ComboOption.GetSlider("ComboRHp").Value)
                {
                    var dangerenemy =
                        GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(R.Range))
                        .OrderBy(x => x.Distance(Me))
                        .FirstOrDefault();

                    if (dangerenemy != null)
                    {
                        R.CastOnUnit(dangerenemy);
                    }
                }
            }
        }
예제 #17
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(R.Range);

            if (target.IsValidTarget(R.Range) && !target.IsUnKillable() && (!target.InAutoAttackRange() || !Orbwalker.CanAttack()))
            {
                if (ComboOption.UseR && R.IsReady() &&
                    R.Ammo >= ComboOption.GetSlider("ComboRLimit").Value&&
                    target.IsValidTarget(R.Range) && target.HealthPercent <= ComboOption.GetSlider("ComboRHP").Value)
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.Hitchance >= HitChance.High)
                    {
                        R.Cast(rPred.UnitPosition);
                    }
                    else if (rPred.Hitchance == HitChance.Collision)
                    {
                        foreach (var collsion in rPred.CollisionObjects.Where(x => x.IsValidTarget(R.Range)))
                        {
                            if (collsion.DistanceSquared(target) <= Math.Pow(85, 2))
                            {
                                R.Cast(collsion.PreviousPosition);
                            }
                        }
                    }
                }

                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    var qPred = Q.GetPrediction(target);

                    if (qPred.Hitchance >= HitChance.High)
                    {
                        Q.Cast(qPred.CastPosition);
                    }
                }

                if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(E.Range))
                {
                    E.Cast(Me.PreviousPosition);
                }
            }
        }
예제 #18
0
        private static void SemiRLogic()
        {
            Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPosRaw);

            if (R.IsReady() && R.Ammo > 0)
            {
                var target = MyTargetSelector.GetTarget(R.Range);

                if (target.IsValidTarget(R.Range))
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.Hitchance >= HitChance.High)
                    {
                        R.Cast(rPred.CastPosition);
                    }
                }
            }
        }
예제 #19
0
        private static void OneKeyEQ()
        {
            Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPosRaw);

            if (E.IsReady() && Q.IsReady())
            {
                var target = MyTargetSelector.GetTarget(E.Range);

                if (target.IsValidTarget(E.Range))
                {
                    var ePred = E.GetPrediction(target);
                    if (ePred.CollisionObjects.Count == 0)
                    {
                        E.Cast(target);
                        Q.Cast(target);
                    }
                }
            }
        }
예제 #20
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(1500);

            if (target != null && target.IsValidTarget(1500))
            {
                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    if (target.DistanceToPlayer() > Me.GetRealAutoAttackRange(target) + 150 || !Orbwalker.CanAttack())
                    {
                        var qPred = Q.GetPrediction(target);

                        if (qPred.Hitchance >= HitChance.High)
                        {
                            Q.Cast(qPred.CastPosition);
                        }
                    }
                }

                if (!E.IsReady() || target.IsDashing())
                {
                    return;
                }

                if (ComboOption.UseE && target.Health < GetEDamage(target))
                {
                    E.Cast();
                }

                if (ComboOption.GetBool("ComboERoot").Enabled&& HitECount(target) >= 3 &&
                    !target.HasBuffOfType(BuffType.SpellShield))
                {
                    E.Cast();
                }

                if (ComboOption.GetBool("ComboELogic").Enabled&& Me.Level >= 5 &&
                    target.Health + target.HPRegenRate * 2 <
                    GetEDamage(target) + Me.GetSpellDamage(target, SpellSlot.Q) + Me.GetAutoAttackDamage(target))
                {
                    E.Cast();
                }
            }
        }
예제 #21
0
파일: Ashe.cs 프로젝트: aleks9829/AimTec-9
        private static void OneKeyR()
        {
            Orbwalker.Move(Game.CursorPos);

            if (R.Ready)
            {
                var target = MyTargetSelector.GetTarget(R.Range);

                if (target != null && !target.HasBuffOfType(BuffType.SpellShield) && target.IsValidTarget(R.Range))
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.HitChance >= HitChance.High)
                    {
                        R.Cast(rPred.CastPosition);
                    }
                }
            }
        }
예제 #22
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(R.Range);

            if (target.IsValidTarget(R.Range))
            {
                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    CastQ(target);
                }

                if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(800f) &&
                    !target.IsValidTarget(Me.AttackRange + Me.BoundingRadius + target.BoundingRadius + 50))
                {
                    ELogic(target);
                }

                if (ComboOption.UseW && W.IsReady() && target.IsValidTarget(W.Range) &&
                    (target.DistanceToPlayer() <= target.AttackRange + 70 ||
                     target.DistanceToPlayer() >= Me.AttackRange + Me.BoundingRadius - target.BoundingRadius + 15 + 80))
                {
                    var wPred = W.GetPrediction(target);

                    if (wPred.Hitchance >= HitChance.High)
                    {
                        W.Cast(wPred.UnitPosition);
                    }
                }

                if (ComboOption.GetSliderBool("ComboRCount").Enabled&& R.IsReady() && target.IsValidTarget(R.Range))
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.Hitchance >= HitChance.Medium)
                    {
                        if (rPred.AoeTargetsHitCount >= ComboOption.GetSliderBool("ComboRCount").Value)
                        {
                            R.Cast(rPred.CastPosition);
                        }
                    }
                }
            }
        }
예제 #23
0
        private static void OneKeyR()
        {
            Orbwalker.Move(Game.CursorPos);

            if (R.IsReady())
            {
                var target = MyTargetSelector.GetTarget(R.Range);

                if (target != null && !target.HasBuffOfType(BuffType.SpellShield) && target.IsValidTarget(R.Range))
                {
                    var rPred = R.GetPrediction(target,
                                                collisionable: CollisionObjects.Heroes | CollisionObjects.YasuoWall);

                    if (rPred.Hitchance >= HitChance.High)
                    {
                        R.Cast(rPred.CastPosition);
                    }
                }
            }
        }
예제 #24
0
        private static void OneKeyCastR()
        {
            Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPosRaw);

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

            var target = MyTargetSelector.GetTarget(R.Range);

            if (target.IsValidTarget(R.Range) && !target.IsValidTarget(MiscOption.GetSlider("R", "RRange").Value))
            {
                var rPred = R.GetPrediction(target);

                if (rPred.Hitchance >= HitChance.High)
                {
                    R.Cast(rPred.CastPosition);
                }
            }
        }
예제 #25
0
파일: Jayce.cs 프로젝트: aleks9829/AimTec-9
        private static void CastQCannonMouse()
        {
            Me.IssueOrder(OrderType.MoveTo, Game.CursorPos);

            if (isMelee && !R.Ready)
            {
                return;
            }

            if (isMelee && R.Ready)
            {
                R.Cast();
                return;
            }

            if (eCd == 0 && qCd == 0 && !isMelee)
            {
                if (MiscOption.GetList("QE", "SemiQEMode").Value == 1)
                {
                    var gateDis    = MiscOption.GetSlider("E", "gatePlace").Value;
                    var gateVector = Me.ServerPosition + Vector3.Normalize(Game.CursorPos - Me.ServerPosition) * gateDis;

                    if (E.Ready && QE.Ready)
                    {
                        E.Cast(gateVector);
                        QE.Cast(Game.CursorPos);
                    }
                }
                else
                {
                    var qTarget = MyTargetSelector.GetTarget(QE.Range);

                    if (qTarget != null && qTarget.IsValidTarget(QE.Range) && qCd == 0)
                    {
                        CastQCannon(qTarget, true);
                    }
                }
            }
        }
예제 #26
0
파일: Varus.cs 프로젝트: aleks9829/AimTec-9
        private static void SemiRLogic()
        {
            if (R.Ready)
            {
                if (Q.IsCharging)
                {
                    return;
                }

                var target = MyTargetSelector.GetTarget(R.Range);

                if (target.IsValidTarget(R.Range))
                {
                    var rPred = R.GetPrediction(target);

                    if (rPred.HitChance >= HitChance.High)
                    {
                        R.Cast(rPred.UnitPosition);
                    }
                }
            }
        }
예제 #27
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(Q2.Range);

            if (target.IsValidTarget(Q2.Range))
            {
                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q2.Range))
                {
                    QLogic(target, ComboOption.GetBool("ComboQ1").Enabled);
                }

                if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(E.Range))
                {
                    var ePred = E.GetPrediction(target);

                    if (ePred.Hitchance >= HitChance.High)
                    {
                        E.Cast(ePred.UnitPosition);
                    }
                }
            }
        }
예제 #28
0
        private static void Combo()
        {
            var target = MyTargetSelector.GetTarget(1500f);

            if (target.IsValidTarget(1500f))
            {
                if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range) && !Me.IsDashing())
                {
                    var qPred = Q.GetPrediction(target);

                    if (qPred.Hitchance >= HitChance.High)
                    {
                        Q.Cast(qPred.UnitPosition);
                    }
                }

                if (ComboOption.UseR && Me.CountEnemyHeroesInRange(850) >= ComboOption.GetSlider("ComboRCount").Value&&
                    (target.Health <= Me.GetAutoAttackDamage(target) * 3 && !Q.IsReady() ||
                     target.Health <= Me.GetAutoAttackDamage(target) * 3 + Me.GetSpellDamage(target, SpellSlot.Q)))
                {
                    R.Cast();
                }
            }
        }
예제 #29
0
        private static void Combo()
        {
            if (ComboOption.UseE && E.IsReady() && !Q.IsCharging && Variables.GameTimeTickCount - lastQTime > 750 + Game.Ping)
            {
                var target = MyTargetSelector.GetTarget(E.Range);

                if (target != null && target.IsValidTarget(E.Range) && (GetBuffCount(target) >= ComboOption.GetSlider("ComboEPassive").Value ||
                                                                        W.Level == 0 || target.Health < Me.GetSpellDamage(target, SpellSlot.E) + GetWDamage(target) ||
                                                                        !target.InAutoAttackRange() && !Q.IsReady()))
                {
                    var ePred = E.GetPrediction(target);

                    if (ePred.Hitchance >= HitChance.High)
                    {
                        E.Cast(ePred.UnitPosition);
                    }
                }
            }

            if (ComboOption.UseQ && Q.IsReady() && Variables.GameTimeTickCount - lastETime > 750 + Game.Ping)
            {
                var target = MyTargetSelector.GetTarget(1600f);

                if (target != null && target.IsValidTarget(1600f))
                {
                    if (Q.IsCharging)
                    {
                        if (ComboOption.GetBool("ComboQFast").Enabled&& target.IsValidTarget(800))
                        {
                            Q.ShootChargedSpell(target.Position);
                        }
                        else if (target.IsValidTarget(Q.ChargedMaxRange))
                        {
                            var qPred = Q.GetPrediction(target);

                            if (qPred.Hitchance >= HitChance.High)
                            {
                                Q.ShootChargedSpell(qPred.CastPosition);
                            }
                        }
                    }
                    else
                    {
                        if (GetBuffCount(target) >= ComboOption.GetSlider("ComboQPassive").Value || W.Level == 0 ||
                            target.Health < Me.GetSpellDamage(target, SpellSlot.Q) + GetWDamage(target))
                        {
                            Q.StartCharging();
                        }
                    }
                }
                else
                {
                    foreach (var t in GameObjects.EnemyHeroes.Where(x => !x.IsDead && x.IsValidTarget(1600)))
                    {
                        if (t.IsValidTarget(1600))
                        {
                            if (Q.IsCharging)
                            {
                                if (ComboOption.GetBool("ComboQFast").Enabled&& t.IsValidTarget(800))
                                {
                                    Q.ShootChargedSpell(t.Position);
                                }
                                else if (t.IsValidTarget(Q.ChargedMaxRange))
                                {
                                    var qPred = Q.GetPrediction(t);

                                    if (qPred.Hitchance >= HitChance.High)
                                    {
                                        Q.ShootChargedSpell(qPred.CastPosition);
                                    }
                                }
                            }
                            else
                            {
                                if (GetBuffCount(t) >= ComboOption.GetSlider("ComboQPassive").Value || W.Level == 0 ||
                                    t.Health < Me.GetSpellDamage(t, SpellSlot.Q) + GetWDamage(t))
                                {
                                    Q.StartCharging();
                                }
                            }
                        }
                    }
                }
            }

            if (ComboOption.UseR && R.IsReady())
            {
                var target = MyTargetSelector.GetTarget(R.Range);

                if (target.IsValidTarget(R.Range) && ComboOption.GetBool("ComboRSolo").Enabled&&
                    Me.CountEnemyHeroesInRange(1000) <= 2)
                {
                    if (target.Health + target.HPRegenRate * 2 <
                        Me.GetSpellDamage(target, SpellSlot.R) + GetWDamage(target) +
                        (E.IsReady() ? Me.GetSpellDamage(target, SpellSlot.E) : 0) +
                        (Q.IsReady() ? Me.GetSpellDamage(target, SpellSlot.Q) : 0) + Me.GetAutoAttackDamage(target) * 3)
                    {
                        var rPred = R.GetPrediction(target);

                        if (rPred.Hitchance >= HitChance.High)
                        {
                            R.Cast(rPred.UnitPosition);
                        }
                    }
                }

                foreach (var rTarget in GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(R.Range) && !x.HaveShiledBuff()))
                {
                    var rPred = R.GetPrediction(rTarget);

                    if (rPred.AoeTargetsHitCount >= ComboOption.GetSlider("ComboRCount").Value&&
                        Me.CountEnemyHeroesInRange(R.Range) >= ComboOption.GetSlider("ComboRCount").Value)
                    {
                        R.Cast(rPred.CastPosition);
                    }
                }
            }
        }
예제 #30
0
        private static void Combo()
        {
            if (ComboOption.UseR && R.IsReady())
            {
                var target = MyTargetSelector.GetTarget(R.Range);

                if (target.IsValidTarget(R.Range) && !target.IsUnKillable() && !Me.IsUnderEnemyTurret() &&
                    !target.IsValidTarget(Me.GetRealAutoAttackRange(target)))
                {
                    if (GameObjects.EnemyHeroes.Any(x => x.NetworkId != target.NetworkId && x.Distance(target) <= 550))
                    {
                        return;
                    }

                    var rAmmo = new float[] { 20, 25, 30 }[Me.Spellbook.GetSpell(SpellSlot.R).Level - 1];
                    var rDMG  = GetRDamage(target) * rAmmo;

                    if (target.Health + target.HPRegenRate * 3 < rDMG)
                    {
                        if (target.DistanceToPlayer() <= 800 && target.Health < rDMG * 0.6)
                        {
                            R.Cast(target);
                            return;
                        }

                        if (target.DistanceToPlayer() <= 1000 && target.Health < rDMG * 0.4)
                        {
                            R.Cast(target);
                        }
                    }
                }
            }

            if (havePassive || Me.Buffs.Any(x => x.Name.ToLower() == "lucianpassivebuff") || Me.IsDashing())
            {
                return;
            }

            if (ComboOption.GetBool("ComboEDash").Enabled&& E.IsReady())
            {
                var target = MyTargetSelector.GetTarget(950);

                if (target.IsValidTarget(950) && !target.IsValidTarget(550))
                {
                    DashELogic(target);
                }
            }

            if (Q.IsReady() && !havePassive && Me.Buffs.All(x => x.Name.ToLower() != "lucianpassivebuff") && !Me.IsDashing())
            {
                var target = MyTargetSelector.GetTarget(Q2.Range);

                if (ComboOption.UseQ)
                {
                    if (target.IsValidTarget(Q2.Range))
                    {
                        QLogic(target, ComboOption.GetBool("ComboQExtend").Enabled);
                    }
                }
            }
        }