Example #1
0
        private void BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
        {
            if (!Q.IsReady() || !Config.Item("autoQ", true).GetValue <bool>() || !(args.Target is Obj_AI_Hero))
            {
                return;
            }
            var t = (Obj_AI_Hero)args.Target;

            if (FishBoneActive && t.IsValidTarget())
            {
                var realDistance = GetRealDistance(t);
                if (Program.Combo && realDistance < GetRealPowPowRange(t) && (Player.Mana < RMANA + 20 || Player.GetAutoAttackDamage(t) * 3 < t.Health))
                {
                    Q.Cast();
                }
                else if (Program.Farm && Config.Item("Qharras", true).GetValue <bool>() && (realDistance > bonusRange() || realDistance < GetRealPowPowRange(t) || Player.Mana < RMANA + EMANA + WMANA + WMANA))
                {
                    Q.Cast();
                }
            }

            if (Program.LaneClear && !FishBoneActive && Config.Item("farmQ", true).GetValue <bool>() && Player.ManaPercent > Config.Item("Mana", true).GetValue <Slider>().Value&& Player.Mana > RMANA + EMANA + WMANA + 30)
            {
                var allMinionsQ = MinionManager.GetMinions(Player.ServerPosition, bonusRange());
                foreach (var minion in allMinionsQ.Where(
                             minion => args.Target.NetworkId != minion.NetworkId && minion.Distance(args.Target.Position) < 200 && (5 - Q.Level) * Player.GetAutoAttackDamage(minion) < args.Target.Health && (5 - Q.Level) * Player.GetAutoAttackDamage(minion) < minion.Health))
                {
                    Q.Cast();
                }
            }
        }
Example #2
0
        static float GetComboDamage(Obj_AI_Hero target)
        {
            var result = 0f;

            if (Q.IsReady())
            {
                result += 2 * Q.GetDamage(target);
            }

            if (W.IsReady())
            {
                result += W.GetDamage(target);
            }

            if (R.IsReady())
            {
                result += R.GetDamage(target);
            }

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

            result += 2 * (float)Player.GetAutoAttackDamage(target);

            return(result);
        }
Example #3
0
        private static void Lasthit()
        {
            var femana  = Config.Item("femana").GetValue <Slider>().Value;
            var minions = MinionManager.GetMinions(player.ServerPosition, E.Range);

            if (minions.Count <= 0)
            {
                return;
            }

            if (E.IsReady() && Config.Item("fE").GetValue <bool>() && player.HealthPercent >= femana)
            {
                var etarget =
                    minions.Where(
                        x =>
                        x.Distance(player) < E.Range &&
                        (x.Health < player.GetSpellDamage(x, SpellSlot.E) &&
                         !(x.Health < player.GetAutoAttackDamage(x))))
                    .OrderByDescending(x => x.Health)
                    .FirstOrDefault();
                if (HealthPrediction.GetHealthPrediction(etarget, (int)0.5) <=
                    player.GetSpellDamage(etarget, SpellSlot.E))
                {
                    E.Cast(etarget);
                }
            }
        }
Example #4
0
        private static void Orbwalking_BeforeAttack(SebbyLib.Orbwalking.BeforeAttackEventArgs args)
        {
            if (AIOmode == 2)
            {
                return;
            }

            if (Combo && Config.Item("comboDisableMode", true).GetValue <bool>())
            {
                var t = (Obj_AI_Hero)args.Target;
                if (6 * Player.GetAutoAttackDamage(t) < t.Health - OktwCommon.GetIncomingDamage(t) && !t.HasBuff("luxilluminatingfraulein") && !Player.HasBuff("sheen"))
                {
                    args.Process = false;
                }
            }

            if (!Player.IsMelee && OktwCommon.CollisionYasuo(Player.ServerPosition, args.Target.Position) && Config.Item("collAA", true).GetValue <bool>())
            {
                args.Process = false;
            }

            if (Orbwalker.ActiveMode == SebbyLib.Orbwalking.OrbwalkingMode.Mixed && Config.Item("supportMode", true).GetValue <bool>())
            {
                if (args.Target.Type == GameObjectType.obj_AI_Minion)
                {
                    args.Process = false;
                }
            }
        }
Example #5
0
        private static float GetComboDamage(Obj_AI_Base enemy)
        {
            double damage = 0d;

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

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

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

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

            damage += Player.GetAutoAttackDamage(enemy) * 2;

            return((float)damage);
        }
Example #6
0
        private static void LHlogic()
        {
            List <Obj_AI_Base> allMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range);
            var vminions = allMinions.Where(
                minion =>
                minion.IsValidTarget() && Player.Distance(minion) >
                Orbwalking.GetRealAutoAttackRange(ObjectManager.Player) && Player.Distance(minion) <= Q.Range &&
                HealthPrediction.GetHealthPrediction(minion, (int)((Player.Distance(minion) * 1000) / 1500) + 300 + Game.Ping / 2) <
                0.75 * Player.GetSpellDamage(minion, SpellSlot.Q));

            if (Config.Item("UseQfarm").GetValue <bool>() && Q.IsReady())
            {
                var bestminion = vminions.MaxOrDefault(x => x.MaxHealth);
                if (bestminion != null)
                {
                    Orbwalker.SetAttack(false);
                    Q.CastOnUnit(bestminion, false);
                    Orbwalker.SetAttack(true);
                }
            }


            if (Config.Item("UseEfarm").GetValue <bool>() && E.IsReady() && !Eon)
            {
                var minions = ObjectManager.Get <Obj_AI_Base>().Where(m => m.IsValidTarget() && m.Team != Player.Team && Player.Distance(m) <= incrange && HealthPrediction.GetHealthPrediction(m, (int)((Player.Distance(m) * 1000) / 1500) + 300 + Game.Ping / 2) <
                                                                      0.75 * Player.GetAutoAttackDamage(m));
                if (minions.Any())
                {
                    E.CastOnUnit(Player);
                }
            }
            //TODO Better Calculations + More Logic for E activation
        }
Example #7
0
        static void SpellCast(Spellbook sender, SpellbookCastSpellEventArgs args)
        {
            if (!Eevolved)
            {
                return;
            }
            if (args.Slot.Equals(SpellSlot.Q) && args.Target is Obj_AI_Hero && Config.Item("djumpenabled").GetValue <bool>() && Config.Item("save").GetValue <bool>())
            {
                var target = args.Target as Obj_AI_Hero;
                var qdmg   = GetQDamage(target);
                var dmg    = (Player.GetAutoAttackDamage(target) * 2) + qdmg;
                if (target.Health < dmg && target.Health > qdmg)
                { //save some unnecessary q's if target is killable with 2 autos + Q instead of Q as Q is important for double jumping
                  // Game.PrintChat("cancelled Q");
                    args.Process = false;
                }
            }

            /*
             * if (args.Slot.Equals(SpellSlot.E) && sender.IsCastingSpell && sender.ActiveSpellSlot == SpellSlot.Q) // if E is cast and another spell is being casted dont process
             * {
             *  args.Process = false;
             * }
             * */
        }
Example #8
0
        private static float ComboDamage(Obj_AI_Base enemy)
        {
            var damage = 0d;

            if (Items.HasItem(3077) && Items.CanUseItem(3077))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Tiamat);
            }
            if (Items.HasItem(3074) && Items.CanUseItem(3074))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Hydra);
            }
            if (Items.HasItem(3153) && Items.CanUseItem(3153))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Botrk);
            }
            if (Items.HasItem(3144) && Items.CanUseItem(3144))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Bilgewater);
            }
            if (_q.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.Q) * 1.3;
            }
            if (_w.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.W);
            }
            if (_r.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.R);
            }
            damage += _player.GetAutoAttackDamage(enemy, true) * _config.Item("autoattack").GetValue <Slider>().Value;
            return((float)damage);
        }
Example #9
0
        private void Clear()
        {
            if (Environment.Minion.KillableMinion(player.AttackRange))
            {
                return;
            }
            float perc = config.Item("minmana", true).GetValue <Slider>().Value / 100f;

            if (player.Mana < player.MaxMana * perc)
            {
                return;
            }
            MinionManager.FarmLocation bestPositionQ =
                Q.GetLineFarmLocation(MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly));
            if (config.Item("useqLC", true).GetValue <bool>() && Q.IsReady())
            {
                if (bestPositionQ.MinionsHit >= config.Item("qhitLC", true).GetValue <Slider>().Value)
                {
                    Q.Cast(bestPositionQ.Position);
                }
                var jungleMob = Jungle.GetNearest(player.Position, Q.Range * 0.75f);
                if (jungleMob != null && jungleMob.Health > player.GetAutoAttackDamage(jungleMob, true) * 2)
                {
                    Q.Cast(jungleMob.Position);
                }
            }
        }
Example #10
0
        private static float ComboDamage(Obj_AI_Hero hero)
        {
            var dmg = 0d;

            if (_q.IsReady())
            {
                dmg += _player.GetSpellDamage(hero, SpellSlot.Q) * 2;
            }
            if (_w.IsReady())
            {
                dmg += _player.GetSpellDamage(hero, SpellSlot.W);
            }
            if (_r.IsReady())
            {
                dmg += _player.GetSpellDamage(hero, SpellSlot.R);
            }
            if (ObjectManager.Player.GetSpellSlot("SummonerIgnite") != SpellSlot.Unknown)
            {
                dmg += _player.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite);
            }
            dmg += _player.GetAutoAttackDamage(hero, true) * 2;
            if (_player.HasBuff("dianaarcready"))
            {
                dmg += 15 + 5 * ObjectManager.Player.Level;
            }
            if (ObjectManager.Player.HasBuff("LichBane"))
            {
                dmg += _player.BaseAttackDamage * 0.75 + _player.FlatMagicDamageMod * 0.5;
            }
            return((float)dmg);
        }
Example #11
0
        private static void Farm()
        {
            var minions = MinionManager.GetMinions(player.ServerPosition, Q.Range);

            if (minions.Count <= 0)
            {
                return;
            }

            var lastmana = Config.Item("qfmana").GetValue <Slider>().Value;

            if (Q.IsReady() && Config.Item("fq").GetValue <bool>() && player.ManaPercent >= lastmana)
            {
                var qtarget =
                    minions.Where(
                        x =>
                        x.Distance(player) < Q.Range && Q.GetPrediction(x).Hitchance >= HitChance.Medium &&
                        (x.Health < player.GetSpellDamage(x, SpellSlot.Q) &&
                         !(x.Health < player.GetAutoAttackDamage(x))))
                    .OrderByDescending(x => x.Health)
                    .FirstOrDefault();
                if (HealthPrediction.GetHealthPrediction(qtarget, (int)0.25) <=
                    player.GetSpellDamage(qtarget, SpellSlot.Q))
                {
                    Q.Cast(qtarget);
                }
            }
        }
Example #12
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));
        }
Example #13
0
 private double AaDamage(Obj_AI_Hero target)
 {
     if (Player.Level > 12)
     {
         return(Player.GetAutoAttackDamage(target) * 1.3);
     }
     else if (Player.Level > 6)
     {
         return(Player.GetAutoAttackDamage(target) * 1.4);
     }
     else if (Player.Level > 0)
     {
         return(Player.GetAutoAttackDamage(target) * 1.5);
     }
     return(0);
 }
Example #14
0
        static float getComboDamage(Obj_AI_Base enemy)
        {
            if (enemy != null)
            {
                float damage = 0;

                if (_Q.IsReady())
                {
                    damage += _Q.GetDamage(enemy);
                }
                if (_E.IsReady())
                {
                    damage += _E.GetDamage(enemy);
                }
                if (_R.IsReady())
                {
                    damage += _R.GetDamage(enemy);
                }
                if (!Player.IsWindingUp)
                {
                    damage += (float)Player.GetAutoAttackDamage(enemy, true);
                }
                return(damage);
            }
            return(0);
        }
Example #15
0
        private static float ComboDamage(Obj_AI_Base enemy)
        {
            var itemscheck = _player.GetSpell(_smiteSlot).Name.ToLower() == "s5_summonersmiteplayerganker" ||
                             _player.GetSpell(_smiteSlot).Name.ToLower() == "s5_summonersmiteduel";
            var damage = 0d;

            if (_igniteSlot != SpellSlot.Unknown && _player.Spellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
            {
                damage += ObjectManager.Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }
            if (_q.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.Q);
            }
            if (_e.IsReady() || ObjectManager.Player.HasBuff("JudicatorRighteousFury"))
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.E);
                damage  = damage + _player.GetAutoAttackDamage(enemy, true) * 4;
            }

            if (itemscheck && ObjectManager.Player.Spellbook.CanUseSpell(_smiteSlot) == SpellState.Ready)
            {
                damage += ObjectManager.Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Smite);
            }

            if (ObjectManager.Player.HasBuff("LichBane"))
            {
                damage += _player.BaseAttackDamage * 0.75 + _player.FlatMagicDamageMod * 0.5;
            }

            return((float)damage);
        }
Example #16
0
        public static double GetDamageCanDeal(Obj_AI_Base target)
        {
            double dmg   = 0;
            var    mana  = Player.Mana;
            var    qCost = SpellManager.Q.Instance().Cost;
            var    eCost = SpellManager.E.Instance().Cost;
            var    rCost = SpellManager.R.Instance().Cost;

            if (SpellManager.Q.Ready)
            {
                dmg   = Player.GetSpellDamage(target, SpellSlot.Q);
                dmg  += (Player.SpellBook.GetSpell(SpellSlot.Q).Level * 20) + Player.GetAutoAttackDamage(target) + (Player.TotalAbilityDamage / 2);
                mana -= qCost;
            }
            if (Player.HasItem(ItemId.LichBane))
            {
                dmg += (Player.BaseAttackDamage * 0.75) + (Player.TotalAbilityDamage / 2);
            }
            if (SpellManager.E.Ready && mana >= eCost)
            {
                dmg  += Player.GetSpellDamage(target, SpellSlot.E);
                mana -= eCost;
            }
            if (SpellManager.R.Ready && mana >= eCost && !UltCasted)
            {
                dmg += GetUltTotalDamage(target);
            }
            return(dmg);
        }
Example #17
0
        public static float ComboDmg(Obj_AI_Base enemy)
        {
            var dmg = 0d;

            if (Spell[SpellSlot.W].IsReady())
            {
                dmg += Player.GetSpellDamage(enemy, SpellSlot.W);
            }
            if (Spell[SpellSlot.Q].IsReady())
            {
                dmg += Player.GetSpellDamage(enemy, SpellSlot.Q) + Player.GetAutoAttackDamage(enemy);
            }
            if (Spell[SpellSlot.R].IsReady())
            {
                dmg += Player.GetSpellDamage(enemy, SpellSlot.R);
            }

            dmg += Player.CalcDamage(enemy, Damage.DamageType.Physical, Player.TotalAttackDamage);

            if (Mechanics.IgniteSlot != SpellSlot.Unknown && Mechanics.IgniteSlot.IsReady())
            {
                dmg += Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }

            return((float)dmg);
        }
Example #18
0
 static float getComboDamage(Obj_AI_Base enemy)
 {
     try
     {
         if (enemy != null)
         {
             float damage = 0;
             if (_Q.IsReady())
             {
                 damage += _Q.GetDamage(enemy);
             }
             if (_W.IsReady())
             {
                 damage += _W.GetDamage(enemy);
             }
             if (!Player.IsWindingUp)
             {
                 damage += (float)Player.GetAutoAttackDamage(enemy, true);
             }
             return(damage);
         }
         return(0);
     }
     catch (Exception)
     {
         if (NowTime() > ErrorTime)
         {
             Game.PrintChat(ChampName + " in FreshBooster isn't Load. Error Code 04");
             ErrorTime = TickCount(10000);
         }
         return(0);
     }
 }
Example #19
0
        private static float ComboDamage(Obj_AI_Hero hero)
        {
            double damage = 0;

            if (activatedP)
            {
                return((float)player.GetAutoAttackDamage(hero, true));
            }
            if (Q.IsReady())
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.Q) * 2f;
            }
            if (W.IsReady() || activatedW)
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.W);
            }
            if (E.IsReady())
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.E);
            }
            if (R.IsReady())
            {
                damage += Damage.GetSpellDamage(player, hero, SpellSlot.R) * hero.Distance(player) > 1000 ? 2f : 1.3f;
            }
            //damage += ItemHandler.GetItemsDamage(target);
            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);
        }
Example #20
0
        private float GetComboDMG(Obj_AI_Base t)
        {
            float comboDMG = 0;

            if (Qcd < 1 && Ecd < 1)
            {
                comboDMG = Q.GetDamage(t) * 1.4f;
            }
            else if (Qcd < 1)
            {
                comboDMG = Q.GetDamage(t);
            }

            if (Q2cd < 1)
            {
                comboDMG = Q.GetDamage(t, 1);
            }

            if (Wcd < 1)
            {
                comboDMG += (float)Player.GetAutoAttackDamage(t) * 3;
            }

            if (W2cd < 1)
            {
                comboDMG += W.GetDamage(t) * 2;
            }

            if (E2cd < 1)
            {
                comboDMG += E.GetDamage(t) * 3;
            }
            return(comboDMG);
        }
Example #21
0
        static void OrbwalkingAfterAttack(AttackableUnit unit, AttackableUnit target)
        {
            var vTarget = target as Obj_AI_Hero;

            if (vTarget == null || !unit.IsMe)
            {
                return;
            }

            if (Orbwalker.ActiveMode.ToString().ToLower() == "combo")
            {
                if (Q.IsReady() && Config.Item("UseQ").GetValue <bool>() && vTarget.Distance(_player.Position) <= E.Range) //Q Logic
                {
                    Q.Cast(UsePackets());
                }
                if (Config.Item("UseE").GetValue <bool>() && E.IsReady() && vTarget.Distance(_player.Position) <= E.Range)
                {
                    CastE(vTarget);
                }
            }

            if (Orbwalker.ActiveMode.ToString().ToLower() == "mixed")
            {
                if (Config.Item("UseEH").GetValue <bool>() && E.IsReady() && vTarget.Distance(_player.Position) <= E.Range)
                {
                    CastE(vTarget);
                }
            }


            var damage = _player.GetAutoAttackDamage(vTarget, true) + R.GetDamage(vTarget);


            if (vTarget.HasBuff("explosiveshotdebuff", true))
            {
                damage += ((((_eTime - Game.Time) * E.GetDamage(vTarget)) / 5) - ((vTarget.HPRegenRate / 2) * (_eTime - Game.Time)));
            }

            if ((damage > vTarget.Health) && R.IsReady() && vTarget.Distance(_player.Position) <= R.Range && Config.Item("UseR").GetValue <bool>())
            {
                R.CastOnUnit(vTarget, UsePackets());
            }


            //double jump combo?
            //maybe check auto attack resets?
        }
Example #22
0
        /// <summary>
        /// Gets the hero average damage to the opposing team.
        /// </summary>
        /// <param name="player">The player.</param>
        /// <param name="Enemies">The enemies.</param>
        /// <returns></returns>
        public static float GetHeroAvgDamage(Obj_AI_Hero player, List<Obj_AI_Hero> Enemies)
        {
            var totalEnemies = Enemies.Count();
            if (totalEnemies == 0)
            {
                return -1;
            }
            var AADamage = Enemies.Aggregate(0, (current, s) => (int) (current + player.GetAutoAttackDamage(s) * 2));
            var QDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.Q).IsReady() ? player.GetSpellDamage(s, SpellSlot.Q) : 0f)));
            var WDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.W).IsReady() ? player.GetSpellDamage(s, SpellSlot.W) : 0f)));
            var EDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.E).IsReady() ? player.GetSpellDamage(s, SpellSlot.E) : 0f)));
            var RDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.R).IsReady() ? player.GetSpellDamage(s, SpellSlot.R) : 0f)));
            
            var itemsDamage = 0f;

            foreach (var item in player.InventoryItems)
            {
                foreach (var hero in Enemies)
                {
                    var itemID = item.Id;
                    switch (itemID)
                    {
                        case ItemId.Bilgewater_Cutlass:
                            itemsDamage +=
                                (float) player.GetItemDamage(hero, Damage.DamageItems.Bilgewater);
                            break;
                        case ItemId.Blade_of_the_Ruined_King:
                            itemsDamage += (float) player.GetItemDamage(hero, Damage.DamageItems.Botrk);
                            break;
                        case ItemId.Hextech_Gunblade:
                            itemsDamage += (float) player.GetItemDamage(hero, Damage.DamageItems.Hexgun);
                            break;
                        case ItemId.Frost_Queens_Claim:
                            itemsDamage +=
                                (float) player.GetItemDamage(hero, Damage.DamageItems.FrostQueenClaim);
                            break;
                        case ItemId.Tiamat_Melee_Only:
                            itemsDamage += player.IsMelee
                                ? (float) player.GetItemDamage(hero, Damage.DamageItems.Tiamat)
                                : 0f;
                            break;
                        case ItemId.Ravenous_Hydra_Melee_Only:
                            itemsDamage += player.IsMelee
                                ? (float) player.GetItemDamage(hero, Damage.DamageItems.Hydra)
                                : 0f;
                            break;
                        case ItemId.Liandrys_Torment:
                            itemsDamage +=
                                (float) player.GetItemDamage(hero, Damage.DamageItems.LiandrysTorment);
                            break;
                    }
                }
                
            }

            var totalDamage = AADamage + QDamage + WDamage + EDamage + RDamage + itemsDamage;

            return (float) totalDamage / totalEnemies;
        }
Example #23
0
        private static float ComboDamage(Obj_AI_Base enemy)
        {
            var damage = 0d;

            if (_igniteSlot != SpellSlot.Unknown &&
                _player.SummonerSpellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
            {
                damage += ObjectManager.Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
            }
            if (Items.HasItem(3077) && Items.CanUseItem(3077))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Tiamat);
            }
            if (Items.HasItem(3074) && Items.CanUseItem(3074))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Hydra);
            }
            if (Items.HasItem(3153) && Items.CanUseItem(3153))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Botrk);
            }
            if (Items.HasItem(3144) && Items.CanUseItem(3144))
            {
                damage += _player.GetItemDamage(enemy, Damage.DamageItems.Bilgewater);
            }
            if (_q.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.Q) * 1.2;
            }
            if (_q.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.Q) * 3;
            }
            if (_e.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.E);
            }
            if (_r.IsReady())
            {
                damage += _player.GetSpellDamage(enemy, SpellSlot.R);
            }

            damage += _player.GetAutoAttackDamage(enemy, true) * 1.1;
            damage += _player.GetAutoAttackDamage(enemy, true);
            return((float)damage);
        }
Example #24
0
 private static float PassiveDmg(Obj_AI_Base hero)
 {
     return
         ((float)
          (Damage.CalcDamage(
               player, hero, Damage.DamageType.Magical, 20 + (5 * player.Level) + player.AbilityPower() * 0.3f) +
           player.GetAutoAttackDamage(hero)));
 }
Example #25
0
 public static float GetAdOverFive(Obj_AI_Hero hero)
 {
     double basicDmg = 0;
     int attacks = (int) Math.Floor(hero.AttackSpeedMod * 5);
     for (int i = 0; i < attacks; i++)
     {
         if (hero.Crit > 0)
         {
             basicDmg += hero.GetAutoAttackDamage(player) * (1 + hero.Crit / attacks);
         }
         else
         {
             basicDmg += hero.GetAutoAttackDamage(player);
         }
     }
     return (float) basicDmg;
 }
Example #26
0
        private static float ComboDamage(Obj_AI_Hero hero)
        {
            var dmg = 0d;

            if (_q.IsReady())
            {
                dmg += _player.GetSpellDamage(hero, SpellSlot.Q);
            }
            if (_w.IsReady())
            {
                dmg += _player.GetSpellDamage(hero, SpellSlot.W);
            }
            if (_e.IsReady())
            {
                dmg += _player.GetSpellDamage(hero, SpellSlot.E);
            }
            if (_r.IsReady())
            {
                if (_config.Item("Style").GetValue <StringList>().SelectedIndex == 0)
                {
                    dmg += _player.GetSpellDamage(hero, SpellSlot.R) * 1.2;
                }
                else
                {
                    dmg += _player.GetSpellDamage(hero, SpellSlot.R);
                }
            }
            if (Items.HasItem(3153) && Items.CanUseItem(3153))
            {
                dmg += _player.GetItemDamage(hero, Damage.DamageItems.Botrk);
            }
            if (Items.HasItem(3146) && Items.CanUseItem(3146))
            {
                dmg += _player.GetItemDamage(hero, Damage.DamageItems.Hexgun);
            }
            if (ObjectManager.Player.HasBuff("LichBane"))
            {
                dmg += _player.BaseAttackDamage * 0.75 + _player.FlatMagicDamageMod * 0.5;
            }
            if (ObjectManager.Player.GetSpellSlot("SummonerIgnite") != SpellSlot.Unknown)
            {
                dmg += _player.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite);
            }
            dmg += _player.GetAutoAttackDamage(hero, true) * 2;
            return((float)dmg);
        }
Example #27
0
        private static void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                CF.UseSpells(target);
            }
            bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;

            //bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("usew").GetValue <bool>() && player.Distance(target.Position) < R.Range && W.IsReady())
            {
                W.Cast(config.Item("packets").GetValue <bool>());
            }

            if (config.Item("usee").GetValue <bool>() && E.IsReady())
            {
                if (config.Item("useewall").GetValue <bool>())
                {
                    var   bestpos  = CF.bestVectorToPoppyFlash(target);
                    float damage   = (float)(CF.ComboDamage(target) + Damage.CalcDamage(player, target, Damage.DamageType.Magical, (eSecond[E.Level - 1] + 0.8f * player.FlatMagicDamageMod)) + (player.GetAutoAttackDamage(target) * 4));
                    float damageno = (float)(CF.ComboDamage(target) + (player.GetAutoAttackDamage(target) * 4));
                    if (config.Item("useeflash").GetValue <bool>() && hasFlash && !CheckWalls(player, target) && damage > target.Health && target.Health > damageno && CF.bestVectorToPoppyFlash(target).IsValid())
                    {
                        player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), bestpos);
                        Utility.DelayAction.Add(100, () => E.CastOnUnit(target, config.Item("packets").GetValue <bool>()));
                    }
                    if (E.CanCast(target) && CheckWalls(player, target))
                    {
                        E.CastOnUnit(target, config.Item("packets").GetValue <bool>());
                    }
                }
                else
                {
                    if (E.CanCast(target))
                    {
                        E.CastOnUnit(target, config.Item("packets").GetValue <bool>());
                    }
                }
            }
            if (config.Item("user").GetValue <bool>())
            {
                if (R.IsReady() && player.Distance(target.Position) < E.Range && CF.ComboDamage(target) + player.GetAutoAttackDamage(target) * 5 < target.Health && (CF.ComboDamage(target) + player.GetAutoAttackDamage(target) * 3) * ultMod[R.Level - 1] > target.Health)
                {
                    R.CastOnUnit(target, config.Item("packets").GetValue <bool>());
                }
            }
            if (config.Item("userindanger").GetValue <Slider>().Value < player.CountEnemysInRange(R.Range))
            {
                R.CastOnUnit(target, config.Item("packets").GetValue <bool>());
            }
        }
Example #28
0
        private static void AfterAttack(AttackableUnit sender, AttackableUnit target)
        {
            if (!sender.IsMe)
            {
                return;
            }

            if (Config.Talon.Item("apollo.talon.misc.q.mode").GetValue <StringList>().SelectedIndex == 0)
            {
                if (Config.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo &&
                    Spell[SpellSlot.Q].IsReadyAndActive(MenuHelper.Mode.Combo))
                {
                    Spell[SpellSlot.Q].Cast(PacketCast);
                }
                else if ((Config.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed ||
                          Config.Talon.GetKeyBind("harass.key").Active) &&
                         Spell[SpellSlot.Q].IsReadyAndActive(MenuHelper.Mode.Harass) &&
                         Player.ManaPercent > Config.Talon.GetSlider("harass.mana"))
                {
                    Spell[SpellSlot.Q].Cast(PacketCast);
                }
            }
            else if (Config.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear &&
                     Spell[SpellSlot.Q].IsReadyAndActive(MenuHelper.Mode.Laneclear))
            {
                var laneMinions =
                    MinionManager.GetMinions(Player.ServerPosition, 300)
                    .Where(
                        h =>
                        h.IsValidTarget(Orbwalking.GetRealAutoAttackRange(h)) &&
                        h.Health < Player.GetSpellDamage(h, SpellSlot.Q) + Player.GetAutoAttackDamage(h))
                    .FirstOrDefault(h => h.Health > Player.GetAutoAttackDamage(h));
                if (laneMinions != null)
                {
                    Player.IssueOrder(GameObjectOrder.AttackUnit, laneMinions);
                    Spell[SpellSlot.Q].Cast(PacketCast);
                }
                else if (
                    MinionManager.GetMinions(Player.ServerPosition, 300, MinionTypes.All, MinionTeam.Neutral)
                    .Any(h => h.IsValidTarget(Orbwalking.GetRealAutoAttackRange(h))))
                {
                    Spell[SpellSlot.Q].Cast(PacketCast);
                }
            }
        }
Example #29
0
            public static float GetAdOverFive(Obj_AI_Hero hero)
            {
                double basicDmg = 0;
                int    attacks  = (int)Math.Floor(hero.AttackSpeedMod * 5);

                for (int i = 0; i < attacks; i++)
                {
                    if (hero.Crit > 0)
                    {
                        basicDmg += hero.GetAutoAttackDamage(player) * (1 + hero.Crit / attacks);
                    }
                    else
                    {
                        basicDmg += hero.GetAutoAttackDamage(player);
                    }
                }
                return((float)basicDmg);
            }
Example #30
0
File: Jayce.cs Project: betw01/detu
        public static bool hammerWillKill(Obj_AI_Base target)
        {
            float damage = (float)Player.GetAutoAttackDamage(target, true) + 50;

            damage += getJayceEHamDmg(target);
            damage += getJayceQHamDmg(target);

            return(target.Health < damage);
        }
Example #31
0
        public static float getRealAADmg(Obj_AI_Base targ)
        {
            if (!azir)
            {
                return((float)player.GetAutoAttackDamage(targ, true));
            }
            var solAround = solidersAroundEnemy(targ);

            if (solAround == 0)
            {
                return((float)player.GetAutoAttackDamage(targ));
            }
            int[] solBaseDmg = { 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 110, 120, 130, 140, 150, 160, 170 };

            var solDmg = solBaseDmg[player.Level - 1] + player.FlatMagicDamageMod * 0.6f;

            return((float)player.CalcDamage(targ, Damage.DamageType.Magical, solDmg + (solAround - 1) * solDmg * 0.25f));
        }
Example #32
0
        private void Game_OnGameUpdate(EventArgs args)
        {
            Obj_AI_Hero player = ObjectManager.Player;

            foreach (var enemy in _enemies.ToList())
            {
                double dmg = 0;
                try
                {
                    if (player.Spellbook.CanUseSpell(SpellSlot.Q) == SpellState.Ready)
                    {
                        dmg += player.GetSpellDamage(enemy.Key, SpellSlot.Q);
                    }
                }
                catch (InvalidOperationException)
                {
                }
                try
                {
                    if (player.Spellbook.CanUseSpell(SpellSlot.W) == SpellState.Ready)
                    {
                        dmg += player.GetSpellDamage(enemy.Key, SpellSlot.W);
                    }
                }
                catch (InvalidOperationException)
                {
                }
                try
                {
                    if (player.Spellbook.CanUseSpell(SpellSlot.E) == SpellState.Ready)
                    {
                        dmg += player.GetSpellDamage(enemy.Key, SpellSlot.E);
                    }
                }
                catch (InvalidOperationException)
                {
                }
                try
                {
                    if (player.Spellbook.CanUseSpell(SpellSlot.R) == SpellState.Ready)
                    {
                        dmg += player.GetSpellDamage(enemy.Key, SpellSlot.R);
                    }
                }
                catch (InvalidOperationException)
                {
                }
                try
                {
                    dmg += player.GetAutoAttackDamage(enemy.Key);
                }
                catch (InvalidOperationException)
                {
                }
                _enemies[enemy.Key] = dmg;
            }
        }
Example #33
0
        /// <summary>
        /// Gets the hero average damage to the opposing team.
        /// </summary>
        /// <param name="player">The player.</param>
        /// <param name="Enemies">The enemies.</param>
        /// <returns></returns>
        public static float GetHeroAvgDamage(Obj_AI_Hero player, List<Obj_AI_Hero> Enemies)
        {
            var totalEnemies = Enemies.Count();
            if (totalEnemies == 0)
            {
                return -1;
            }
            var AADamage = Enemies.Aggregate(0, (current, s) => (int) (current + player.GetAutoAttackDamage(s)));
            var QDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.Q).IsReady() ? player.GetSpellDamage(s, SpellSlot.Q) : 0)));
            var WDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.W).IsReady() ? player.GetSpellDamage(s, SpellSlot.W) : 0)));
            var EDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.E).IsReady() ? player.GetSpellDamage(s, SpellSlot.E) : 0)));
            var RDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.R).IsReady() ? player.GetSpellDamage(s, SpellSlot.R) : 0)));

            var totalDamage = AADamage + QDamage + WDamage + EDamage + RDamage;

            return (float) totalDamage / totalEnemies;
        }
Example #34
0
        public static double GetAlliesComboDmg(Obj_AI_Hero target, Obj_AI_Hero ally)
        {
            var SpellSlots = new List<SpellSlot>();
            double dmg = 0;
            #region SpellSots
            SpellSlots.Add(SpellSlot.Q);
            SpellSlots.Add(SpellSlot.W);
            SpellSlots.Add(SpellSlot.E);
            SpellSlots.Add(SpellSlot.R);
            #endregion

            foreach (var slot in SpellSlots)
            {
                var spell = ally.Spellbook.GetSpell(slot);

                dmg += ally.GetSpellDamage(target, slot);
                dmg += ally.GetAutoAttackDamage(target);
            }

            return dmg;
        }
Example #35
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;
        }
Example #36
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;
        }
Example #37
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;
        }
Example #38
0
        private static void Game_OnGameLoad(EventArgs args)
        {
            Player = ObjectManager.Player;
            if (Player.BaseSkinName != ChampionName) return;

            //Create the spells

            Q.SetSkillshot(0.25f, 40, 1200, true, SkillshotType.SkillshotLine);

            //Create the menu
            Config = new Menu(ChampionName, ChampionName, true);

            var targetSelectorMenu = new Menu("Target Selector", "Target Selector");
            SimpleTs.AddToMenu(targetSelectorMenu);
            Config.AddSubMenu(targetSelectorMenu);

            //Orbwalker submenu
            Config.AddSubMenu(new Menu("Orbwalking", "Orbwalking"));

            //Load the orbwalker and add it to the submenu.
            Orbwalker = new Orbwalking.Orbwalker(Config.SubMenu("Orbwalking"));

            Config.AddSubMenu(new Menu("Combo", "Combo"));
            Config.SubMenu("Combo").AddItem(new MenuItem("ComboQ", "Use Q?").SetValue(true));
            Config.SubMenu("Combo").AddItem(new MenuItem("ComboR","Use R?").SetValue(true));
            Config.SubMenu("Combo").AddItem(new MenuItem("ComboActive", "Combo!").SetValue(new KeyBind(32, KeyBindType.Press)));

            Config.AddSubMenu(new Menu("Harass", "Harass"));
            Config.SubMenu("Harass").AddItem(new MenuItem("UseQHarass", "Use Q").SetValue(true));
            Config.SubMenu("Harass").AddItem(new MenuItem("QMana", "Min Mana Q").SetValue(new Slider(40, 1, 100)));
            Config.SubMenu("Harass").AddItem(new MenuItem("HarassActive", "Harass!").SetValue(new KeyBind("C".ToCharArray()[0], KeyBindType.Press)));

            //Damage after combo:
            var eDamage = new MenuItem("DamageAfterCombo", "HP After Used Q+2AA").SetValue(true);
            Utility.HpBarDamageIndicator.DamageToUnit += hero => (float)(Player.GetSpellDamage(hero, SpellSlot.Q) + (Player.GetAutoAttackDamage(hero)*2));
            Utility.HpBarDamageIndicator.Enabled = eDamage.GetValue<bool>();
            eDamage.ValueChanged += delegate(object sender, OnValueChangeEventArgs eventArgs)
            {
                Utility.HpBarDamageIndicator.Enabled = eventArgs.GetNewValue<bool>();
            };

            Config.AddSubMenu(new Menu("KS", "KS"));
            Config.SubMenu("KS").AddItem(new MenuItem("StealE","Steal With E").SetValue(true));
            Config.AddSubMenu(new Menu("Misc", "Misc"));
            Config.SubMenu("Misc").AddItem(new MenuItem("eStacks", "E Stacks *Broken").SetValue(new Slider(10, 2, 30)));
            Config.SubMenu("Misc").AddItem(new MenuItem("eMana", "Min Mana E").SetValue(new Slider(40, 1, 100)));
            Config.SubMenu("Misc").AddItem(new MenuItem("safer", "Use R to save allies").SetValue(true));
            Config.SubMenu("Misc").AddItem(new MenuItem("savehp", "HP to Save %").SetValue(new Slider(40, 1, 100)));
            Config.SubMenu("Misc").AddItem(new MenuItem("Harasser", "Harass Allways").SetValue(true));
               // Config.AddItem(new MenuItem("packetCast", "Packet Cast").SetValue(true));
            Config.AddSubMenu(new Menu("Drawings", "Drawings"));
            Config.SubMenu("Drawings").AddItem(new MenuItem("QRange", "Q range").SetValue(new Circle(true, Color.FromArgb(255, 255, 255, 255))));
            Config.SubMenu("Drawings") .AddItem(new MenuItem("WRange", "W range").SetValue(new Circle(false, Color.FromArgb(255, 255, 255, 255))));
            Config.SubMenu("Drawings").AddItem(new MenuItem("RRange", "R range").SetValue(new Circle(false, Color.FromArgb(255, 255, 255, 255))));
            Config.SubMenu("Drawings").AddItem(eDamage);
            Config.AddToMainMenu();

            //Add the events we are going to use:
            Drawing.OnDraw += Drawing_OnDraw;
            Game.OnGameUpdate += Game_OnGameUpdate;
             GameObject.OnCreate += OnCreateObject;
             //   Orbwalking.BeforeAttack += OrbwalkingOnBeforeAttack;
            Game.PrintChat("<font color='#00FFFF'>>> Deniz Kalista v0.5 Loaded");
        }