예제 #1
0
        public static float RDamage(Obj_AI_Base target)
        {
            if (target.HasBuff("garenpassiveenemytarget"))
            {
                return(_player.CalculateDamageOnUnit(target, DamageType.True, R.GetSpellDamage(target)));
            }

            return(_player.CalculateDamageOnUnit(target, R.DamageType, R.GetSpellDamage(target)));
        }
예제 #2
0
        private static void OnUpdate(EventArgs args)
        {
            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                ComboExec();
            }
            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear))
            {
                LaneExec();
            }
            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
            {
                HarassExec();
            }
            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit))
            {
                LastHitExec();
            }

            var target       = TargetSelector.GetTarget(Q.Range, DamageType.True, Player.Instance.Position);
            var ignitedamage = Ignite.GetSpellDamage(target);

            if (MiscMenu["igniteusage"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady() && target.Health + 50 < ignitedamage)
            {
                Ignite.Cast(target);
            }
        }
예제 #3
0
 private void Killsteal()
 {
     if (!KSQ && !KSE && !KSR && !KSIgnite)
     {
         return;
     }
     foreach (var enemy in EntityManager.Enemies.Where(ene => ene.IsInRange(Player.Instance, R.Range) && ene.Type == Player.Instance.Type && ene.IsVisible))
     {
         if (KSQ && Q.IsReady() && Q.IsInRange(enemy) && enemy.Health <= Q.GetSpellDamage(enemy))
         {
             Q.Cast(enemy);
         }
         else if (KSE && E.IsReady() && E.IsInRange(enemy) && enemy.Health <= E.GetSpellDamage(enemy))
         {
             E.Cast(enemy);
         }
         else if (KSR && R.IsReady() && R.IsInRange(enemy) && enemy.Health <= R.GetSpellDamage(enemy))
         {
             SmartRCast(enemy);
         }
         else if (KSIgnite && Player.Instance.Spellbook.CanUseSpell(Ignite) == SpellState.Ready && enemy.IsValidTarget(600f, true) && IgniteDamage(enemy) >= enemy.Health)
         {
             Player.Instance.Spellbook.CastSpell(Ignite, enemy);
         }
     }
 }
예제 #4
0
        private static void Drawing_OnDraw(EventArgs args)
        {
            var color = Color.Red;

            foreach (var enemy in EntityManager.Heroes.Enemies)                //Checks for every enemy
            {
                if (enemy.IsVisible && enemy.IsValidTarget() && !enemy.IsDead) //Are they visible, valid, and alive?
                {
                    if (enemy.Health < Q.GetSpellDamage(enemy) && Q.IsReady()) //Can we kill with Q?
                    {
                        canKill = "Kill with Q";
                        color   = Color.Lime;
                    }
                    if (enemy.Health < E.GetSpellDamage(enemy) * 7 && E.IsReady()) //Can we kill with E?
                    {
                        canKill = "Kill with E";
                        color   = Color.Lime;
                    }
                    if (enemy.Health < R.GetSpellDamage(enemy) && R.IsReady()) //Can we kill with R?
                    {
                        canKill = "Kill with R";
                        color   = Color.Lime;
                    }
                    Drawing.DrawText(enemy.HPBarPosition.X, enemy.HPBarPosition.Y + 50, color, canKill, 25); //Show text under enemy HP Bar showing we can kill them
                }
                if (!enemy.IsVisible || enemy.IsDead)                                                        //Are they not visible or dead?
                {
                    canKill = "Not Killable";
                }
            }
        }
예제 #5
0
파일: Program.cs 프로젝트: Ouija01/EloBuddy
        private static double IsRapeble(Obj_AI_Base victim)
        {
            double comboDamage = 0d;

            if (Q.IsReady())
            {
                comboDamage += Q.GetSpellDamage(victim) + Player.Instance.CalculateDamageOnUnit(victim, DamageType.Magical, (float)(45 + 35 * Q.Level + 0.5 * player.FlatMagicDamageMod));
            }
            if (E.IsReady())
            {
                comboDamage += E.GetSpellDamage(victim);
            }

            if (hasBuff(victim, "AkaliMota"))
            {
                comboDamage += Player.Instance.CalculateDamageOnUnit(victim, DamageType.Magical, (float)(45 + 35 * Q.Level + 0.5 * player.FlatMagicDamageMod));
            }
            //comboDamage += player.GetAutoAttackDamage(victim, true);

            comboDamage += player.CalculateDamageOnUnit(victim, DamageType.Magical, (float)CalcPassiveDmg());
            comboDamage += player.CalculateDamageOnUnit(victim, DamageType.Magical, (float)CalcItemsDmg(victim));

            foreach (var item in player.InventoryItems)
            {
                if ((int)item.Id == 3128)
                {
                    if (player.Spellbook.CanUseSpell((SpellSlot)item.Slot) == SpellState.Ready)
                    {
                        comboDamage *= 1.2;
                    }
                }
            }
            if (hasBuff(victim, "deathfiregraspspell"))
            {
                comboDamage *= 1.2;
            }

            if (ultiCount() > 0)
            {
                comboDamage += Player.Instance.GetSpellDamage(victim, SpellSlot.Unknown) * (ultiCount() - (int)(victim.Distance(player.Position) / R.Range));
            }
            if (IgniteSlot != SpellSlot.Unknown && player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                comboDamage += ObjectManager.Player.GetSummonerSpellDamage(victim, DamageLibrary.SummonerSpells.Ignite);
            }
            return(comboDamage);
        }
예제 #6
0
        public static void LaneE(bool lastHit = false)
        {
            if (!E.IsReady() || (!Config.laneclearMenu["ylm.laneclear.usee"].Cast <CheckBox>().CurrentValue&& !Config.lasthitMenu["ylm.lasthit.usee"].Cast <CheckBox>().CurrentValue))
            {
                return;
            }
            lastHit = lastHit && Config.lasthitMenu["ylm.lasthit.usee"].Cast <CheckBox>().CurrentValue;
            var minion =
                EntityManager.MinionsAndMonsters.Get(EntityManager.MinionsAndMonsters.EntityType.Minion, EntityManager.UnitTeam.Both, ObjectManager.Player.ServerPosition, E.Range)
                .FirstOrDefault(m => CanCastE(m) /*&& E.GetHealthPrediction(m) > 0*/);

            if (minion == null || !lastHit && !Config.laneclearMenu["ylm.laneclear.usee"].Cast <CheckBox>().CurrentValue)
            {
                return;
            }

            var mode = Config.laneclearMenu["ylm.laneclear.modee"].Cast <ComboBox>().CurrentValue;

            if (((lastHit || mode == 0) && E.GetHealthPrediction(minion) <= E.GetSpellDamage(minion)) ||
                mode == 1)
            {
                E.Cast(minion);
            }
        }
예제 #7
0
        private static void Combo()
        {
            var target = TargetSelector.GetTarget(Q.Range, DamageType.Magical);

            if (target == null)
            {
                return;
            }
            if (ComboMenu["UseQ"].Cast <CheckBox>().CurrentValue)
            {
                if (target.Distance(ObjectManager.Player) <= Q.Range && Q.IsReady() && !(E.IsReady()))
                {
                    if (Q.GetPrediction(target).HitChance >= HitChance.High)
                    {
                        Q.Cast(Q.GetPrediction(target).CastPosition);
                    }
                }
            }
            if (ComboMenu["UseW"].Cast <CheckBox>().CurrentValue)
            {
                if (target.Distance(ObjectManager.Player) <= W.Range && W.IsReady())
                {
                    W.Cast(W.GetPrediction(target).CastPosition);
                }
            }
            if (ComboMenu["UseE"].Cast <CheckBox>().CurrentValue)
            {
                if (target.Distance(ObjectManager.Player) <= E.Range && E.IsReady())
                {
                    var pred = Q.GetPrediction(target);
                    Q.Cast(Player.Position.Extend(pred.CastPosition, E.Range - 10).To3D());
                    E.Cast(Player.Position.Extend(pred.CastPosition, E.Range - 10).To3D());
                }
            }

            if (ComboMenu["UseR"].Cast <CheckBox>().CurrentValue)
            {
                if (R.IsReady() && target.IsValidTarget(R.Range) && Prediction.Health.GetPrediction(target, R.CastDelay) <= R.GetSpellDamage(target))
                {
                    R.Cast(target);
                }
            }
        }
예제 #8
0
        private static void Combo()
        {
            foreach (var Enemy in EntityManager.Heroes.Enemies)
            {
                if (Enemy.IsValidTarget())
                {
                    if (Smite != null && Smite.IsReady() && ComboSmite.CurrentValue)
                    {
                        var target = TargetSelector.SelectedTarget == null
                            ? TargetSelector.GetTarget(700, DamageType.Physical)
                            : TargetSelector.SelectedTarget;

                        if (target != null && target.IsValidTarget() && !target.IsDead && (target.Position - Player.Position).Length() < 500)
                        {
                            Smite.Cast(target);
                        }
                        else
                        {
                            Smite.Cast(target);
                        }
                    }
                    if (Cutlass.IsOwned() && Cutlass.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        var target = TargetSelector.SelectedTarget == null
                            ? TargetSelector.GetTarget(550, DamageType.Physical)
                            : TargetSelector.SelectedTarget;

                        if (target != null && target.IsValidTarget() && !target.IsDead && Cutlass.IsInRange(target))
                        {
                            Cutlass.Cast(target);
                        }
                        else
                        {
                            Cutlass.Cast(target);
                        }
                    }
                    if (Botrk.IsOwned() && Botrk.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        var target = TargetSelector.SelectedTarget == null
                            ? TargetSelector.GetTarget(550, DamageType.Physical)
                            : TargetSelector.SelectedTarget;

                        if (target != null && target.IsValidTarget() && !target.IsDead && Botrk.IsInRange(target))
                        {
                            Botrk.Cast(target);
                        }
                        else
                        {
                            Botrk.Cast(target);
                        }
                    }
                    if (Youmuu.IsOwned() && Youmuu.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(500) > 0)
                        {
                            Youmuu.Cast();
                        }
                    }
                    if (Ravenous_Hydra.IsOwned() && Ravenous_Hydra.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(385) > 0)
                        {
                            Ravenous_Hydra.Cast();
                        }
                    }
                    if (Tiamat.IsOwned() && Tiamat.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(385) > 0)
                        {
                            Tiamat.Cast();
                        }
                    }
                    if (Titanic_Hydra.IsOwned() && Titanic_Hydra.IsReady() && ComboItems.CurrentValue && !Player.IsDead)
                    {
                        if (Player.CountEnemyChampionsInRange(385) > 0)
                        {
                            Titanic_Hydra.Cast();
                        }
                    }
                    if (!ComboQAA.CurrentValue && ComboQ.CurrentValue && Q.IsReady() && Enemy.IsValidTarget(E.Range))
                    {
                        Q.Cast();
                    }
                    if (!Enemy.IsDead && Enemy != null && Enemy.IsValidTarget(E.Range) && ComboE.CurrentValue)
                    {
                        if ((Enemy.Position - Player.Position).Length() > ComboEmin.CurrentValue)
                        {
                            E.Cast(Enemy);
                        }
                        if (E.GetSpellDamage(Enemy) >= Enemy.TotalShieldHealth())
                        {
                            E.Cast(Enemy);
                        }
                        if (Enemy.IsDashing())
                        {
                            E.Cast(Enemy);
                        }
                        if (Enemy.HealthPercent < 15)
                        {
                            E.Cast(Enemy);
                        }
                    }
                    if (ComboW.CurrentValue && W.IsReady())
                    {
                        var target = TargetSelector.GetTarget(250, DamageType.Physical);
                        if (target != null)
                        {
                            W.Cast();
                        }
                    }
                    if (ComboR.CurrentValue && R.IsReady())
                    {
                        var RDamage = R.GetSpellDamage(Enemy);
                        if (Player.CountEnemyChampionsInRange(R.Range) >= ComboRmin.CurrentValue)
                        {
                            if (Enemy.HasBuff("xenzhaointimidate"))
                            {
                                R.Cast();
                            }
                        }
                        if (Enemy.TotalShieldHealth() < RDamage)
                        {
                            R.Cast();
                        }
                    }
                }
            }
        }