Esempio n. 1
0
        private static float GetComboDamage(Obj_AI_Hero enemy)
        {
            double Damage = 0;

            if (Q.IsReady())
            {
                Damage += Me.GetSpellDamage(enemy, SpellSlot.Q);
            }

            if (W.IsReady())
            {
                Damage += Me.GetSpellDamage(enemy, SpellSlot.W);
            }

            if (E.IsReady())
            {
                Damage += Me.GetSpellDamage(enemy, SpellSlot.E);
            }

            if (R.IsReady())
            {
                Damage += Me.GetSpellDamage(enemy, SpellSlot.R);
            }

            if (Dot.IsReady())
            {
                Damage += Me.GetSummonerSpellDamage(enemy, LeagueSharp.Common.Damage.SummonerSpell.Ignite);
            }

            return((float)Damage);
        }
Esempio n. 2
0
        public static float GetTotalDamage(Obj_AI_Base target)
        {
            float damage = 0f;

            if (SpellManager.Q.IsReady() && Config.ComboQ)
            {
                damage += GetQDamage(target);
            }
            if (SpellManager.E.IsReady() && Config.ComboE)
            {
                damage += GetEDamage(target);
            }
            if (SpellManager.R.IsReady() && Config.ComboR)
            {
                if (SpellManager.UltHasBeenCasted)
                {
                    damage += GetRemainingUltDamage(target);
                }
                else
                {
                    damage += GetUltInitialDamage(target) + GetUltTickDamage(target);
                }
            }
            if (SpellManager.IgniteSlot != SpellSlot.Unknown && Player.GetSpell(SpellManager.IgniteSlot).IsReady())
            {
                damage += (float)Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            }
            return(damage);
        }
Esempio n. 3
0
        private static double CalculateDamage(Obj_AI_Hero target, bool notR = false)
        {
            double total = 0;

            if (player.Spellbook.CanUseSpell(SpellSlot.Q) == SpellState.Ready)
            {
                total += player.GetSpellDamage(target, SpellSlot.Q);
            }
            if (player.Spellbook.CanUseSpell(SpellSlot.W) == SpellState.Ready)
            {
                total += player.GetSpellDamage(target, SpellSlot.W);
            }
            if (player.Spellbook.CanUseSpell(SpellSlot.E) == SpellState.Ready)
            {
                total += player.GetSpellDamage(target, SpellSlot.E);
            }
            if (player.Spellbook.CanUseSpell(SpellSlot.R) == SpellState.Ready && !notR)
            {
                total += player.GetSpellDamage(target, SpellSlot.R);
            }
            if (igniteCheck)
            {
                total += player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            }
            if (DFG.IsReady())
            {
                total += player.GetItemDamage(target, Damage.DamageItems.Dfg);
            }
            return(total);
        }
Esempio n. 4
0
        public static void KillSteal()
        {
            var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            var igniteDmg = player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (target.IsValidTarget(Q.Range) && Q.IsReady() && xMenu.Item("KillQ").GetValue <bool>() == true && ObjectManager.Player.GetSpellDamage(target, SpellSlot.Q) > target.Health)
            {
                Q.Cast(target, xMenu.Item("Packet").GetValue <bool>());
            }

            if (target.IsValidTarget(W.Range) && W.IsReady() && xMenu.Item("KillW").GetValue <bool>() == true && ObjectManager.Player.GetSpellDamage(target, SpellSlot.W) > target.Health)
            {
                W.Cast(target, xMenu.Item("Packet").GetValue <bool>());
            }

            if (target.IsValidTarget(3000) && R.IsReady() && xMenu.Item("KillR").GetValue <bool>() == true && ObjectManager.Player.GetSpellDamage(target, SpellSlot.R) > target.Health)
            {
                R.Cast(target, xMenu.Item("Packet").GetValue <bool>());
            }


            if (xMenu.Item("KillI").GetValue <bool>() == true && player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                if (igniteDmg > target.Health && player.Distance(target, false) < 600)
                {
                    player.Spellbook.CastSpell(IgniteSlot, target);
                }
            }
        }
Esempio n. 5
0
        private static float GetComboDamage(Obj_AI_Base vTarget)
        {
            var fComboDamage = 0d;

            if (Q.IsReady())
            {
                fComboDamage += Player.GetSpellDamage(vTarget, SpellSlot.Q) +
                                Player.GetSpellDamage(vTarget, SpellSlot.Q, 1);
            }
            if (E.IsReady())
            {
                fComboDamage += Player.GetSpellDamage(vTarget, SpellSlot.E);
            }

            if (R.IsReady())
            {
                fComboDamage += Player.GetSpellDamage(vTarget, SpellSlot.R) * R.Instance.Ammo;
            }

            if (Items.CanUseItem(3146))
            {
                fComboDamage += Player.GetItemDamage(vTarget, Damage.DamageItems.Hexgun);
            }

            if (IgniteSlot != SpellSlot.Unknown &&
                Player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                fComboDamage += Player.GetSummonerSpellDamage(vTarget, Damage.SummonerSpell.Ignite);
            }

            return((float)fComboDamage);
        }
Esempio n. 6
0
        private static void Ks()
        {
            List <Obj_AI_Hero> nearChamps = (from champ in ObjectManager.Get <Obj_AI_Hero>()
                                             where Player.Distance(champ.ServerPosition) <= 600 && champ.IsEnemy
                                             select champ).ToList();

            nearChamps.OrderBy(x => x.Health);

            foreach (Obj_AI_Hero target in nearChamps)
            {
                //ignite
                if (target != null && IsIgnite() && Player.Distance(target.ServerPosition) <= 600)
                {
                    if (Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health)
                    {
                        Player.Spellbook.CastSpell(IgniteSlot, target);
                    }
                }

                if (Player.Distance(target.ServerPosition) <= Q.Range &&
                    (Player.GetSpellDamage(target, SpellSlot.Q)) > target.Health)
                {
                    if (Q.IsReady())
                    {
                        Q.Cast(target);
                    }
                }
            }
        }
Esempio n. 7
0
        private float ComboDamage(Obj_AI_Hero hero)
        {
            double damage = 0;

            if (R.IsReady())
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.R);
            }
            damage += ItemHandler.GetItemsDamage(hero);

            if ((Items.HasItem(ItemHandler.Bft.Id) && Items.CanUseItem(ItemHandler.Bft.Id)) ||
                (Items.HasItem(ItemHandler.Dfg.Id) && Items.CanUseItem(ItemHandler.Dfg.Id)))
            {
                damage = (float)(damage * 1.2);
            }
            if (Q.IsReady() && !GarenQ)
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.Q);
            }
            if (E.IsReady() && !GarenE)
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.E) * 3;
            }
            var ignitedmg = player.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite);

            if (player.Spellbook.CanUseSpell(player.GetSpellSlot("summonerdot")) == SpellState.Ready && hero.Health < damage + ignitedmg)
            {
                damage += ignitedmg;
            }
            return((float)damage);
        }
Esempio n. 8
0
        public void startAttack(Camp.JungleMinion minion, bool smite)
        {
            usePots();
            getDPS(minion.unit);

            if (minion == null || !minion.unit.IsValid || !minion.unit.IsVisible)
            {
                return;
            }
            if ((smite || player.Health / player.MaxHealth < 0.14f) && minion.smiteBuff != Camp.JungleMinion.SmiteBuff.None)
            {
                if (HypaJungle.Config.Item("smiteToKill").GetValue <bool>())
                {
                    if (player.GetSummonerSpellDamage(minion.unit, Damage.SummonerSpell.Smite) >= minion.unit.Health)
                    {
                        doSmite(minion.unit);
                    }
                }
                else
                {
                    //if (minion.Health / getDPS(minion) > ((!HypaJungle.jTimer.jungleCamps.Where(cp => cp.isBuff).Any()) ? 8 : 5) * (player.Health / player.MaxHealth) || (JungleClearer.focusedCamp.isBuff && minion.MaxHealth >= 1400))
                    if (minion.unit.Health > getSmiteDmg() * 0.70f)
                    {
                        doSmite(minion.unit);
                    }
                }
            }
            attackMinion(minion.unit, smite);
        }
Esempio n. 9
0
        private static float ComboDamage(Obj_AI_Hero hero)
        {
            double damage = 0;

            if (Q.IsReady())
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.Q);
            }
            if (W.IsReady())
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.W);
            }
            if (R.IsReady())
            {
                damage += GetPassiveDamage(hero, 4);
            }
            damage += ItemHandler.GetItemsDamage(hero);
            var ignitedmg = player.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite);

            if (player.Spellbook.CanUseSpell(player.GetSpellSlot("summonerdot")) == SpellState.Ready &&
                hero.Health < damage + ignitedmg)
            {
                damage += ignitedmg;
            }
            return((float)damage);
        }
Esempio n. 10
0
        static float GetComboDamage(Obj_AI_Base target)
        {
            var damage = 0d;

            if (Q.IsReady())
            {
                damage += Player.GetSpellDamage(target, SpellSlot.Q);
            }

            if (E.IsReady())
            {
                damage += Player.GetSpellDamage(target, SpellSlot.E);
            }

            if (R.IsReady())
            {
                damage += Player.GetSpellDamage(target, SpellSlot.R);
            }

            if (IgniteSlot != SpellSlot.Unknown && Player.Spellbook.GetSpell(IgniteSlot).State == SpellState.Ready)
            {
                damage += Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            }

            damage += SoldiersManager.ActiveSoldiers.Count * Player.GetSpellDamage(target, SpellSlot.W);

            return((float)damage);
        }
Esempio n. 11
0
        private static float GetComboDamage(Obj_AI_Base enemy)
        {
            var damage = 0d;

            if (_q.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
            }

            if (_w.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.W);
            }

            if (_q.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
            }

            if (_igniteSlot != SpellSlot.Unknown && Player.Spellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
            {
                damage += Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }

            return((float)damage);
        }
Esempio n. 12
0
        private static float GetComboDamage(Obj_AI_Base enemy)
        {
            var damage = 0d;

            if (Q.IsReady() && Q.GetCollision(ObjectManager.Player.ServerPosition.To2D(), new List <Vector2> {
                enemy.ServerPosition.To2D()
            }).Count == 0)
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
            }

            if (W.IsReady())
            {
                damage += W.Instance.Ammo *
                          Player.GetSpellDamage(enemy, SpellSlot.W);
            }

            if (E.IsReady())
            {
                damage += Player.GetSpellDamage(enemy, SpellSlot.E);
            }

            if (IgniteSlot != SpellSlot.Unknown && Player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                damage += Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }

            if (R.IsReady())
            {
                damage += 7 * Player.GetSpellDamage(enemy, SpellSlot.R) / 10;
            }

            return((float)damage);
        }
Esempio n. 13
0
        private static float GetComboDamage(Obj_AI_Base enemy)
        {
            var damage = 0d;

            if (Q.IsReady())
            {
                damage += myHero.GetSpellDamage(enemy, SpellSlot.Q);
            }
            if (W.IsReady())
            {
                damage += myHero.GetSpellDamage(enemy, SpellSlot.W);
            }
            if (E.IsReady())
            {
                damage += myHero.GetSpellDamage(enemy, SpellSlot.E);
            }
            if (R.IsReady())
            {
                damage += myHero.GetSpellDamage(enemy, SpellSlot.R);
            }
            if (IgniteSlot != SpellSlot.Unknown && myHero.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                damage += myHero.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }
            return((float)damage);
        }
Esempio n. 14
0
        private static float GetComboDamage(Obj_AI_Base vTarget)
        {
            var fComboDamage = 0d;

            if (Q.IsReady())
            {
                fComboDamage += vPlayer.GetSpellDamage(vTarget, SpellSlot.Q);
            }

            if (E.IsReady())
            {
                fComboDamage += vPlayer.GetSpellDamage(vTarget, SpellSlot.E);
            }

            if (R.IsReady())
            {
                fComboDamage += vPlayer.GetSpellDamage(vTarget, SpellSlot.R);
            }

            if (Items.CanUseItem(3128))
            {
                fComboDamage += vPlayer.GetItemDamage(vTarget, Damage.DamageItems.Botrk);
            }

            if (IgniteSlot != SpellSlot.Unknown && vPlayer.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                fComboDamage += vPlayer.GetSummonerSpellDamage(vTarget, Damage.SummonerSpell.Ignite);
            }

            return((float)fComboDamage);
        }
Esempio n. 15
0
        public static float GetFullDamage(Obj_AI_Hero target)
        {
            // Auto attack damage
            var damage = (float)player.GetAutoAttackDamage(target);

            // Q - R damages
            damage += SpellManager.Spells.Sum(s => s.IsReady() ? s.GetRealDamage(target) : 0);

            // Check for DFG
            var dfgReady = false;

            if (ItemManager.DFG.IsOwned() || ItemManager.BLACKFIRE_TORCH.IsOwned())
            {
                dfgReady = true;
            }

            // Check for ignite
            var igniteReady = false;

            if (player.HasIgniteReady())
            {
                igniteReady = true;
            }

            return((dfgReady ? 1.2f : 1) * damage + (igniteReady ? (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) : 0) +
                   (dfgReady ? (float)player.GetItemDamage(target, ItemManager.DFG.IsOwned() ? Damage.DamageItems.Dfg : Damage.DamageItems.BlackFireTorch) : 0));
        }
Esempio n. 16
0
        private static void KillSteal()
        {
            foreach (var hero in ObjectManager.Get <Obj_AI_Hero>().Where(hero => hero.IsEnemy))
            {
                var igniteDmg = _player.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite);
                var qhDmg     = _player.GetSpellDamage(hero, SpellSlot.Q);

                if (hero.IsValidTarget(600) && _config.Item("UseIgnite").GetValue <bool>() && _igniteSlot != SpellSlot.Unknown &&
                    _player.Spellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
                {
                    if (igniteDmg > hero.Health)
                    {
                        _player.Spellbook.CastSpell(_igniteSlot, hero);
                    }
                }

                if (_q.IsReady() && hero.IsValidTarget(_q.Range) &&
                    _config.Item("UseQKs").GetValue <bool>())
                {
                    if (hero.Health <= qhDmg)
                    {
                        _q.Cast(hero, Packets());
                    }
                }
            }
        }
Esempio n. 17
0
        public void startAttack(Obj_AI_Minion minion, bool onlyAA)
        {
            usePots();
            getDPS(minion);

            if (minion == null || !minion.IsValid || !minion.IsVisible)
            {
                return;
            }

            if (HypaJungle.Config.Item("smiteToKill").GetValue <bool>())
            {
                if (player.GetSummonerSpellDamage(minion, Damage.SummonerSpell.Smite) >= minion.Health)
                {
                    if (((!HypaJungle.jTimer._jungleCamps.Any(cp => cp.isBuff && cp.State == JungleCampState.Alive)) && minion.MaxHealth >= 800) ||
                        (JungleClearer.focusedCamp.isBuff && minion.MaxHealth >= 1400))
                    {
                        doSmite(minion);
                    }
                }
            }
            else
            {
                if (minion.Health / getDPS(minion) > ((!HypaJungle.jTimer._jungleCamps.Where(cp => cp.isBuff).Any()) ? 8 : 5) * (player.Health / player.MaxHealth) || (JungleClearer.focusedCamp.isBuff && minion.MaxHealth >= 1400))
                {
                    doSmite(minion);
                }
            }


            attackMinion(minion, onlyAA);
        }
Esempio n. 18
0
        private static void KillSteal()
        {
            var target    = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Magical);
            var igniteDmg = Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            var QDmg      = Player.GetSpellDamage(target, SpellSlot.Q);
            var EDmg      = Player.GetSpellDamage(target, SpellSlot.E);

            if (target != null)
            {
                if (target != null && Config.Item("UseIgnite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
                    Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
                {
                    {
                        Player.SummonerSpellbook.CastSpell(IgniteSlot, target);
                    }
                }

                if (Config.Item("UseQKs").GetValue <bool>() && Q.IsReady())
                {
                    if (QDmg >= target.Health)
                    {
                        Q.Cast(target);
                    }
                }
                if (Config.Item("UseEKs").GetValue <bool>() && E.IsReady())
                {
                    if (EDmg >= target.Health)
                    {
                        E.Cast(target);
                    }
                }
            }
        }
Esempio n. 19
0
        private static float GetComboDamage(Obj_AI_Base qTarget)
        {
            var ComboDamage = 0d;

            if (Q.IsReady())
            {
                ComboDamage += Player.GetSpellDamage(qTarget, SpellSlot.Q);
            }

            if (R.IsReady())
            {
                ComboDamage += Player.GetSpellDamage(qTarget, SpellSlot.R);
            }

            if (E.IsReady())
            {
                ComboDamage += Player.GetSpellDamage(qTarget, SpellSlot.E);
            }

            if (IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                ComboDamage += Player.GetSummonerSpellDamage(qTarget, Damage.SummonerSpell.Ignite);
            }

            return((float)ComboDamage);
        }
Esempio n. 20
0
        private static void KillSteal(Obj_AI_Hero target)
        {
            var Qdmg      = Q.GetDamage(target, 0);
            var Edmg      = E.GetDamage(target, 0);
            var igniteDmg = Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (target != null)
            {
                if (Config.Item("UseQKs").GetValue <bool>() && Q.IsReady())
                {
                    if (target.Health <= Qdmg)
                    {
                        Q.Cast(target);
                    }
                }

                if (Config.Item("UseEKs").GetValue <bool>() && E.IsReady())
                {
                    if (target.Health <= Edmg)
                    {
                        E.Cast(target);
                    }
                }
                if (Config.Item("UseIgnite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
                {
                    if (target.Health < igniteDmg)
                    {
                        Player.SummonerSpellbook.CastSpell(IgniteSlot, target);
                    }
                }
            }
        }
Esempio n. 21
0
        private static void KillSteal()
        {
            var target    = TargetSelector.GetTarget(2000, TargetSelector.DamageType.Physical);
            var igniteDmg = _player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (target.IsValidTarget() && _config.Item("UseIgnitekill").GetValue <bool>() && _igniteSlot != SpellSlot.Unknown &&
                _player.Spellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
            {
                if (igniteDmg > target.Health && _player.Distance(target.ServerPosition) <= 600)
                {
                    _player.Spellbook.CastSpell(_igniteSlot, target);
                }
            }
            if (target.IsValidTarget() && _q.IsReady() && _config.Item("UseQM").GetValue <bool>() && _q.GetDamage(target) > target.Health)
            {
                if (_player.Distance(target.ServerPosition) <= _q.Range)
                {
                    _q.Cast(target);
                }
                else if (WShadow != null && WShadow.Distance(target.ServerPosition) <= _q.Range)
                {
                    _q.UpdateSourcePosition(WShadow.ServerPosition, WShadow.ServerPosition);
                    _q.Cast(target);
                }
            }
            if (_e.IsReady() && _config.Item("UseEM").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(_e.Range, TargetSelector.DamageType.Physical);
                if (_e.GetDamage(t) > t.Health && (_player.Distance(t.ServerPosition) <= _e.Range || WShadow.Distance(t.ServerPosition) <= _e.Range))
                {
                    _e.Cast();
                }
            }
        }
Esempio n. 22
0
        private static void KillSteal()
        {
            var target = ObjectManager.Get <Obj_AI_Hero>()
                         .Where(x => x.IsInvulnerable && !x.IsDead && x.IsEnemy && !x.IsZombie && x.IsValidTarget() && x.Distance(Player.Position) <= 800)
                         .OrderBy(x => x.Health).FirstOrDefault();

            if (target != null)
            {
                double igniteDmg  = Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
                double QDmg       = Player.GetSpellDamage(target, SpellSlot.Q);
                var    totalksdmg = igniteDmg + QDmg;

                if (target.Health <= QDmg && Player.Distance(target) <= Q.Range)
                {
                    Q.CastOnUnit(target);
                }
                if (target.Health <= igniteDmg && Player.Distance(target) <= Ignite.Range)
                {
                    Player.Spellbook.CastSpell(Ignite.Slot, target);
                }
                if (target.Health <= totalksdmg && Player.Distance(target) <= Q.Range)
                {
                    Q.CastOnUnit(target);
                    Player.Spellbook.CastSpell(Ignite.Slot, target);
                }
            }
        }
Esempio n. 23
0
        // TODO: DFG handling and so on :P
        public static double GetMainComboDamage(Obj_AI_Base target)
        {
            double damage = player.GetAutoAttackDamage(target);

            if (Q.IsReady())
            {
                damage += player.GetSpellDamage(target, SpellSlot.Q);
            }

            if (W.IsReady())
            {
                damage += player.GetSpellDamage(target, SpellSlot.W) * (target.IsAblazed() ? 2 : 1);
            }

            if (E.IsReady())
            {
                damage += player.GetSpellDamage(target, SpellSlot.E);
            }

            if (R.IsReady())
            {
                damage += player.GetSpellDamage(target, SpellSlot.R);
            }

            if (player.HasIgnite())
            {
                damage += player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            }

            return(damage);
        }
Esempio n. 24
0
        private static void KillSteal()
        {
            var enemyVisible =
                ObjectManager.Get <Obj_AI_Hero>().Where(enemy => enemy.IsValidTarget() && _player.Distance(enemy.ServerPosition) <= 600).FirstOrDefault();

            {
                if (_player.GetSummonerSpellDamage(enemyVisible, Damage.SummonerSpell.Ignite) > enemyVisible.Health && _igniteSlot != SpellSlot.Unknown &&
                    _player.Spellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
                {
                    _player.Spellbook.CastSpell(_igniteSlot, enemyVisible);
                }
            }
            if (_r.IsReady() && _config.Item("UseRM").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(_r.Range, TargetSelector.DamageType.Physical);
                if (_player.GetSpellDamage(t, SpellSlot.R) > t.Health && _player.Distance(t.ServerPosition) <= _r.Range)
                {
                    _r.CastOnUnit(t);
                }
            }


            if (_e.IsReady() && _config.Item("UseEM").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(_e.Range, TargetSelector.DamageType.Physical);
                if (_e.GetDamage(t) > t.Health && _player.Distance(t.ServerPosition) <= _e.Range)
                {
                    _e.Cast();
                }
            }
        }
Esempio n. 25
0
        private static void KillSteal()
        {
            var target    = SimpleTs.GetTarget(_q.Range, SimpleTs.DamageType.Magical);
            var igniteDmg = _player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (target != null && _config.Item("UseIgnitekill").GetValue <bool>() && _igniteSlot != SpellSlot.Unknown &&
                _player.SummonerSpellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
            {
                if (igniteDmg > target.Health)
                {
                    _player.SummonerSpellbook.CastSpell(_igniteSlot, target);
                }
            }
            if (_q.IsReady() && _config.Item("UseQM").GetValue <bool>())
            {
                var t = SimpleTs.GetTarget(_q.Range, SimpleTs.DamageType.Magical);
                if (_q.GetDamage(t) > t.Health && _player.Distance(t) <= _q.Range)
                {
                    _q.Cast(t, Packets());
                }
            }
            if (_r.IsReady() && _config.Item("UseRM").GetValue <bool>())
            {
                var t = SimpleTs.GetTarget(_r.Range, SimpleTs.DamageType.Magical);
                if (t != null)
                {
                    if (!t.HasBuff("JudicatorIntervention") && !t.HasBuff("Undying Rage") && _r.GetDamage(t) > t.Health)
                    {
                        _r.Cast(t, Packets(), true);
                    }
                }
            }
        }
Esempio n. 26
0
        public static void smartKS()
        {
            if (!menu.Item("smartKS").GetValue<bool>())
                return;

            var nearChamps = (from champ in ObjectManager.Get<Obj_AI_Hero>() where Player.Distance(champ.ServerPosition) <= 1375 && champ.IsEnemy select champ).ToList();
            nearChamps.OrderBy(x => x.Health);

            foreach (var target in nearChamps)
            {
                //ignite
                if (target != null && menu.Item("ignite").GetValue<bool>() && IgniteSlot != SpellSlot.Unknown &&
                                Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready && Player.Distance(target.ServerPosition) <= 600)
                {
                    var IgniteMode = menu.Item("igniteMode").GetValue<StringList>().SelectedIndex;
                    if (IgniteMode == 1 && Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health)
                    {
                        Player.SummonerSpellbook.CastSpell(IgniteSlot, target);
                    }
                }

                //dfg
                if (DFG.IsReady() && Player.GetItemDamage(target, Damage.DamageItems.Dfg) > target.Health + 20 && Player.Distance(target.ServerPosition) <= 750)
                {
                    DFG.Cast(target);
                    return;
                }

                //Q
                if (Player.Distance(target.ServerPosition) <= Q.Range && (Player.GetSpellDamage(target, SpellSlot.Q)) > target.Health + 20)
                {
                    if (Q.IsReady())
                    {
                        Q.Cast(target, packets());
                        return;
                    }
                }

                //E
                if (Player.Distance(target.ServerPosition) <= E.Range && (Player.GetSpellDamage(target, SpellSlot.E)) > target.Health + 20)
                {
                    if (E.IsReady() && E.GetPrediction(target).Hitchance >= HitChance.High)
                    {
                        E.Cast(target, packets());
                        return;
                    }
                }

                //W
                if (Player.Distance(target.ServerPosition) <= W.Range && (Player.GetSpellDamage(target, SpellSlot.W)) > target.Health + 20)
                {
                    if (W.IsReady())
                    {
                        W.Cast();
                        return;
                    }
                }
            }
        }
Esempio n. 27
0
        private static void Combo()
        {
            Ulti();
            float       perc   = (float)config.Item("minmana", true).GetValue <Slider>().Value / 100f;
            var         minHit = config.Item("useemin", true).GetValue <Slider>().Value;
            Obj_AI_Hero target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }

            var buffs = CombatHelper.SejuaniCountFrostHero(E.Range);

            if (E.IsReady() && me.Distance(target.Position) < E.Range && buffs > 0 &&
                ((buffs > minHit) || (Damage.GetSpellDamage(me, target, SpellSlot.E) >= target.Health) ||
                 (me.Distance(target) > config.Item("useEminr", true).GetValue <Slider>().Value&&
                  me.Distance(target) < E.Range && buffs == 1)))
            {
                if (!(Q.IsReady() && me.Mana - me.Spellbook.GetSpell(SpellSlot.Q).ManaCost < me.MaxMana * perc) ||
                    !(W.IsReady() && me.Mana - me.Spellbook.GetSpell(SpellSlot.W).ManaCost < me.MaxMana * perc))
                {
                    E.Cast();
                }
            }
            if (Q.IsReady() && config.Item("useq", true).GetValue <bool>() &&
                me.Distance(target.Position) > config.Item("useQminr", true).GetValue <Slider>().Value)
            {
                var hits = Q.GetHitCount(HitChance.High);
                if (target.CountEnemiesInRange(Q.Width) >= hits)
                {
                    Q.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue <bool>());
                }
            }
            bool hasIgnite = me.Spellbook.CanUseSpell(me.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            var  ignitedmg = (float)me.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (ignitedmg > target.Health && hasIgnite && !E.CanCast(target) && !W.CanCast(target) && !Q.CanCast(target))
            {
                me.Spellbook.CastSpell(me.GetSpellSlot("SummonerDot"), target);
            }
        }
Esempio n. 28
0
 private static float IgniteDamage(Obj_AI_Hero target)
 {
     if (IgniteSlot == SpellSlot.Unknown || Player.Spellbook.CanUseSpell(IgniteSlot) != SpellState.Ready)
     {
         return(0f);
     }
     return((float)Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite));
 }
Esempio n. 29
0
        private static void Combo()
        {
            var         minHit  = config.Item("useemin").GetValue <Slider>().Value;
            Obj_AI_Hero target  = TargetSelector.GetTarget(E.Range + 400, TargetSelector.DamageType.Magical);
            Obj_AI_Hero targetQ = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            var useE = config.Item("usee").GetValue <bool>() && E.IsReady() && player.Distance(target.Position) < E.Range;

            if (useE)
            {
                if (minHit > 1)
                {
                    CastEmin(target, minHit);
                }
                else if (player.Distance(target.Position) > player.AttackRange &&
                         E.GetPrediction(target).Hitchance >= HitChance.High)
                {
                    E.Cast(target, config.Item("packets").GetValue <bool>());
                }
            }
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
                !E.CanCast(target) && !Q.CanCast(target))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (useE && target.Health > Q.GetDamage(target))
            {
                return;
            }
            if (Q.IsReady() && config.Item("useq").GetValue <bool>() && Q.CanCast(targetQ) && Orbwalking.CanMove(100))
            {
                Q.CastOnUnit(targetQ, config.Item("packets").GetValue <bool>());
                currEnergy -= player.Spellbook.GetSpell(SpellSlot.Q).ManaCost;
            }
        }
Esempio n. 30
0
 public static bool CastSmite(Obj_AI_Base Target, bool Killable = true)
 {
     if (!SmiteReady() || !IsValid(Target, 760) || (Killable && Target.Health > Player.GetSummonerSpellDamage(Target, Damage.SummonerSpell.Smite)))
     {
         return(false);
     }
     return(Player.SummonerSpellbook.CastSpell(SmiteSlot, Target));
 }
Esempio n. 31
0
        public static float GetChampDmgToMe(Obj_AI_Hero enemy)
        {
            double result = 0;
            double basicDmg = 0;
            int attacks = (int) Math.Floor(enemy.AttackSpeedMod * 5);
            for (int i = 0; i < attacks; i++)
            {
                if (enemy.Crit > 0)
                {
                    basicDmg += enemy.GetAutoAttackDamage(player) * (1 + enemy.Crit / attacks);
                }
                else
                {
                    basicDmg += enemy.GetAutoAttackDamage(player);
                }
            }
            result += basicDmg;
            var spells = enemy.Spellbook.Spells;
            foreach (var spell in spells)
            {
                var t = spell.CooldownExpires - Game.Time;
                if (t < 0.5)
                {
                    switch (enemy.SkinName)
                    {
                        case "Ahri":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot));
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot, 1));
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Akali":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * spell.Ammo);
                            }
                            else if (spell.Slot == SpellSlot.Q)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot));
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot, 1));
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Amumu":
                            if (spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * 5);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Cassiopeia":
                            if (spell.Slot == SpellSlot.Q || spell.Slot == SpellSlot.E || spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * 2);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Fiddlesticks":
                            if (spell.Slot == SpellSlot.W || spell.Slot == SpellSlot.E)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * 5);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Garen":
                            if (spell.Slot == SpellSlot.E)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * 3);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Irelia":
                            if (spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * attacks);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Karthus":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * 4);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "KogMaw":
                            if (spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(enemy, player, spell.Slot) * attacks);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "LeeSin":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot, 1);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Lucian":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot) * 4;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Nunu":
                            if (spell.Slot != SpellSlot.R && spell.Slot != SpellSlot.Q)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "MasterYi":
                            if (spell.Slot != SpellSlot.E)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot) * attacks;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "MonkeyKing":
                            if (spell.Slot != SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot) * 4;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Pantheon":
                            if (spell.Slot == SpellSlot.E)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot) * 3;
                            }
                            else if (spell.Slot == SpellSlot.R)
                            {
                                result += 0;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }

                            break;
                        case "Rammus":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot) * 6;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Riven":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += RivenDamageQ(spell, enemy, player);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Viktor":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot, 1) * 5;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        case "Vladimir":
                            if (spell.Slot == SpellSlot.E)
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot) * 2;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            }
                            break;
                        default:
                            result += Damage.GetSpellDamage(enemy, player, spell.Slot);
                            break;
                    }
                }
            }
            if (enemy.Spellbook.CanUseSpell(player.GetSpellSlot("summonerdot")) == SpellState.Ready)
            {
                result += enemy.GetSummonerSpellDamage(player, Damage.SummonerSpell.Ignite);
            }
            foreach (var minions in
                ObjectManager.Get<Obj_AI_Minion>()
                    .Where(i => i.Distance(player.Position) < 750 && i.IsMinion && !i.IsAlly && !i.IsDead))
            {
                result += minions.GetAutoAttackDamage(player, false);
            }
            return (float) result;
        }
Esempio n. 32
0
        private static float ComboDamage(Obj_AI_Hero src, Obj_AI_Hero dsc)
        {
            if (!src.IsValid || !dsc.IsValid) return 0f;
            float basicDmg = 0;
            int attacks = (int)Math.Floor(src.AttackSpeedMod*5);
            if (src.Crit>0)
            {

                basicDmg += (float)src.GetAutoAttackDamage(dsc) * attacks * (1 + src.Crit);
            }
            else
            {

                basicDmg += (float)src.GetAutoAttackDamage(dsc) * attacks;
            }
            float damage = basicDmg;
            var spells = src.Spellbook.Spells;

            foreach (var spell in spells)
            {
                var t = spell.CooldownExpires - Game.Time;
                if (spell.Level > 0 && t < 0.5 && Damage.GetSpellDamage(src, dsc, spell.Slot) > 0)
                {
                    switch (src.SkinName)
                    {
                                case "Ahri":
                                    if (spell.Slot == SpellSlot.Q)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot));
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot,1));
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Akali":
                                    if (spell.Slot == SpellSlot.R)
                                    {
                                        damage += (float) (Damage.GetSpellDamage(src, dsc, spell.Slot)*spell.Ammo);
                                    }
                                    else if (spell.Slot == SpellSlot.Q)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot));
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot, 1));
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Amumu":
                                    if (spell.Slot == SpellSlot.W)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot) * 5);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Cassiopeia":
                                    if (spell.Slot == SpellSlot.Q || spell.Slot == SpellSlot.E || spell.Slot == SpellSlot.W)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot) * 2);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Fiddlesticks":
                                    if (spell.Slot == SpellSlot.W || spell.Slot == SpellSlot.E)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot)*5);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Garen":
                                    if (spell.Slot == SpellSlot.E)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot) * 3);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Irelia":
                                    if (spell.Slot == SpellSlot.W)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot) * attacks);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Karthus":
                                    if (spell.Slot == SpellSlot.Q)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot) * 4);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "KogMaw":
                                    if (spell.Slot == SpellSlot.W)
                                    {
                                        damage += (float)(Damage.GetSpellDamage(src, dsc, spell.Slot) * attacks);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "LeeSin":
                                    if (spell.Slot == SpellSlot.Q)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot,1);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Lucian":
                                    if (spell.Slot == SpellSlot.R)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot)*4;
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Nunu":
                                    if (spell.Slot != SpellSlot.R && spell.Slot != SpellSlot.Q)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "MasterYi":
                                    if (spell.Slot != SpellSlot.E)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot)*attacks;
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "MonkeyKing":
                                    if (spell.Slot != SpellSlot.R)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot) * 4;
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Pantheon":
                                    if (spell.Slot == SpellSlot.E)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot)*3;
                                    }
                                    else if (spell.Slot == SpellSlot.R)
                                    {
                                        damage +=0;
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);

                                    break;
                                case "Rammus":
                                    if (spell.Slot == SpellSlot.R)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot)*6;
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Riven":
                                    if (spell.Slot == SpellSlot.Q)
                                    {
                                        damage += RivenDamageQ(spell, src, dsc);
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Viktor":
                                    if (spell.Slot == SpellSlot.R)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot,1) * 5;
                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                case "Vladimir":
                                    if (spell.Slot == SpellSlot.E)
                                    {
                                        damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot) * 2;

                                    }
                                    else damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                    break;
                                default:
                                damage += (float)Damage.GetSpellDamage(src, dsc, spell.Slot);
                                break;
                    }

                }
            }

            if (src.Spellbook.CanUseSpell(src.GetSpellSlot("summonerdot")) == SpellState.Ready)
            {
                damage += (float)src.GetSummonerSpellDamage(dsc, Damage.SummonerSpell.Ignite);
            }
            return damage;
        }
Esempio n. 33
0
        public static float GetComboDMG(Obj_AI_Hero source, Obj_AI_Hero target)
        {
            double result = 0;
            double basicDmg = 0;
            int attacks = (int) Math.Floor(source.AttackSpeedMod * 5);
            for (int i = 0; i < attacks; i++)
            {
                if (source.Crit > 0)
                {
                    basicDmg += source.GetAutoAttackDamage(target, true) * (1f + source.Crit / attacks);
                }
                else
                {
                    basicDmg += source.GetAutoAttackDamage(target, true);
                }
            }
            result += basicDmg;
            var spells = source.Spellbook.Spells;
            foreach (var spell in spells)
            {
                var t = spell.CooldownExpires - Game.Time;
                if (t < 0.5)
                {
                    switch (source.SkinName)
                    {
                        case "Ahri":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot));
                                result += (Damage.GetSpellDamage(source, target, spell.Slot, 1));
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Akali":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * spell.Ammo);
                            }
                            else if (spell.Slot == SpellSlot.Q)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot));
                                result += (Damage.GetSpellDamage(source, target, spell.Slot, 1));
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Amumu":
                            if (spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * 5);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Cassiopeia":
                            if (spell.Slot == SpellSlot.Q || spell.Slot == SpellSlot.E || spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * 2);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Fiddlesticks":
                            if (spell.Slot == SpellSlot.W || spell.Slot == SpellSlot.E)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * 5);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Garen":
                            if (spell.Slot == SpellSlot.E)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * 3);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Irelia":
                            if (spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * attacks);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Karthus":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * 4);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "KogMaw":
                            if (spell.Slot == SpellSlot.W)
                            {
                                result += (Damage.GetSpellDamage(source, target, spell.Slot) * attacks);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "LeeSin":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                                result += Damage.GetSpellDamage(source, target, spell.Slot, 1);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Lucian":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot) * 4;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Nunu":
                            if (spell.Slot != SpellSlot.R && spell.Slot != SpellSlot.Q)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "MasterYi":
                            if (spell.Slot == SpellSlot.E)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot) * attacks;
                            }
                            else if (spell.Slot == SpellSlot.R)
                            {
                                result += basicDmg * 0.6f;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "MonkeyKing":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot) * 4;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Pantheon":
                            if (spell.Slot == SpellSlot.E)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot) * 3;
                            }
                            else if (spell.Slot == SpellSlot.R)
                            {
                                result += 0;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }

                            break;
                        case "Rammus":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot) * 6;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Riven":
                            if (spell.Slot == SpellSlot.Q)
                            {
                                result += RivenDamageQ(spell, source, target);
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Shyvana":
                            if (spell.Slot == SpellSlot.W)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot) * 4;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Viktor":
                            if (spell.Slot == SpellSlot.R)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                                result += Damage.GetSpellDamage(source, target, spell.Slot, 1) * 5;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        case "Vladimir":
                            if (spell.Slot == SpellSlot.E)
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot) * 2;
                            }
                            else
                            {
                                result += Damage.GetSpellDamage(source, target, spell.Slot);
                            }
                            break;
                        default:
                            result += Damage.GetSpellDamage(source, target, spell.Slot);
                            break;
                    }
                }
            }
            if (source.Spellbook.CanUseSpell(target.GetSpellSlot("summonerdot")) == SpellState.Ready)
            {
                result += source.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            }
            return (float) result;
        }