Exemplo n.º 1
0
        public static double CalculateDamage(Obj_AI_Base target)
        {
            double totaldamage = 0;
            bool   marked      = checkformark(target);

            tSpells.useignite = false;
            tSpells.usedfg    = false;
            if ((ObjectManager.Player.Distance(target) < Q.Range || ObjectManager.Player.Distance(target) < E.Range && E.IsReady()) && Q.IsReady() && (W.IsReady() || E.IsReady() || R.IsReady()))
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.Q);
            }
            if ((ObjectManager.Player.Distance(target) < W.Range || ObjectManager.Player.Distance(target) < E.Range && E.IsReady()) && W.IsReady())
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.W);
            }
            if (ObjectManager.Player.Distance(target) < E.Range && E.IsReady())
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.E);
            }
            if ((ObjectManager.Player.Distance(target) < R.Range || ObjectManager.Player.Distance(target) < E.Range && E.IsReady()) && R.IsReady())
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.R);
            }
            if (!Q.IsReady() && marked)
            {
                totaldamage += DamageLib.CalcMagicDmg(((ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).Level * 15)) + (0.15 * ObjectManager.Player.FlatMagicDamageMod), target);
            }

            if (totaldamage > target.Health)
            {
                return(totaldamage);
            }

            if (Config.Item("dfg").GetValue <bool>() && Items.HasItem(3128) && Items.CanUseItem(3128))
            {
                totaldamage = (totaldamage * 1.2) + DamageLib.CalcMagicDmg(target.MaxHealth * 0.15, target);
            }

            if (totaldamage > target.Health)
            {
                tSpells.usedfg = true;
                return(totaldamage);
            }

            if (Config.Item("ignite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown && ObjectManager.Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready && ObjectManager.Player.Distance(target) < 600)
            {
                if (totaldamage + DamageLib.getDmg(target, DamageLib.SpellType.IGNITE) > target.Health)
                {
                    tSpells.useignite = true;
                    totaldamage      += DamageLib.getDmg(target, DamageLib.SpellType.IGNITE);
                }
            }
            tSpells.usedfg = true;

            return(totaldamage);
        }
        public static Obj_AI_Hero GetTarget(float range, DamageType damageType)
        {
            Obj_AI_Hero bestTarget = null;
            var         bestRatio  = 0f;

            if (SelectedTarget.IsValidTarget() && !IsInvulnerable(SelectedTarget) &&
                (range < 0 && Orbwalking.InAutoAttackRange(SelectedTarget) ||
                 ObjectManager.Player.Distance(SelectedTarget) < range))
            {
                return(SelectedTarget);
            }

            foreach (var hero in ObjectManager.Get <Obj_AI_Hero>())
            {
                if (!hero.IsValidTarget() || IsInvulnerable(hero) ||
                    ((!(range < 0) || !Orbwalking.InAutoAttackRange(hero)) &&
                     !(ObjectManager.Player.Distance(hero) < range)))
                {
                    continue;
                }
                var damage = 0f;

                switch (damageType)
                {
                case DamageType.Magical:
                    damage = (float)DamageLib.CalcMagicDmg(100, hero);
                    break;

                case DamageType.Physical:
                    damage = (float)DamageLib.CalcPhysicalDmg(100, hero);
                    break;

                case DamageType.True:
                    damage = 100;
                    break;
                }

                var ratio = damage / (1 + hero.Health) * GetPriority(hero);

                if (ratio > bestRatio)
                {
                    bestRatio  = ratio;
                    bestTarget = hero;
                }
            }

            return(bestTarget);
        }
Exemplo n.º 3
0
        public static double CalculateDamageDrawing(Obj_AI_Base target)
        {
            double totaldamage = 0;
            bool   marked      = checkformark(target);

            if (Q.IsReady() && (W.IsReady() || E.IsReady() || R.IsReady()))
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.Q);
            }
            if (E.IsReady() && W.IsReady())
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.W);
            }
            if (E.IsReady())
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.E);
            }
            if (R.IsReady())
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.R);
            }
            if (!Q.IsReady() && marked)
            {
                totaldamage += DamageLib.CalcMagicDmg(((ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).Level * 15)) + (0.15 * ObjectManager.Player.FlatMagicDamageMod), target);
            }

            if (Config.Item("dfg").GetValue <bool>() && Items.HasItem(3128) && Items.CanUseItem(3128))
            {
                totaldamage = (totaldamage * 1.2) + DamageLib.CalcMagicDmg(target.MaxHealth * 0.15, target);
            }

            if (Config.Item("ignite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown && ObjectManager.Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
            {
                totaldamage += DamageLib.getDmg(target, DamageLib.SpellType.IGNITE);
            }
            return(totaldamage);
        }
Exemplo n.º 4
0
        static Orbwalking()
        {
            Player = ObjectManager.Player;
            Obj_AI_Base.OnProcessSpellCast += OnProcessSpell;
            GameObject.OnCreate            += Obj_SpellMissile_OnCreate;
            Game.OnGameProcessPacket       += OnProcessPacket;

            //Add the passive damages
            PassiveDamage p;

            #region PassiveDamages

            #region Caitlyn

            p = new PassiveDamage
            {
                ChampionName = "Caitlyn",
                IsActive     = minion => (Player.HasBuff("CaitlynHeadshotReady")),
                GetDamage    =
                    minion =>
                    ((float)
                     DamageLib.CalcPhysicalDmg(
                         1.5d * (Player.BaseAttackDamage + Player.FlatPhysicalDamageMod), minion)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Draven

            p = new PassiveDamage
            {
                ChampionName = "Draven",
                IsActive     = minion => (Player.HasBuff("dravenspinning")),
                GetDamage    =
                    minion =>
                    ((float)
                     DamageLib.CalcPhysicalDmg(
                         0.45d * (Player.BaseAttackDamage + Player.FlatPhysicalDamageMod), minion)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Corki

            p = new PassiveDamage
            {
                ChampionName = "Corki",
                IsActive     = minion => (Player.HasBuff("RapidReload")),
                GetDamage    = minion => ((float)0.1d * (Player.BaseAttackDamage + Player.FlatPhysicalDamageMod)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Gnar

            p = new PassiveDamage
            {
                ChampionName = "Gnar",
                IsActive     =
                    minion =>
                    (from buff in minion.Buffs where buff.DisplayName == "GnarWProc" select buff.Count)
                    .FirstOrDefault() == 2,
                GetDamage = minion => ((float)DamageLib.getDmg(minion, DamageLib.SpellType.W)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Jinx

            p = new PassiveDamage
            {
                ChampionName = "Jinx",
                IsActive     = minion => (Player.HasBuff("JinxQ")),
                GetDamage    =
                    minion =>
                    ((float)
                     DamageLib.CalcPhysicalDmg(
                         0.1d * (Player.BaseAttackDamage + Player.FlatPhysicalDamageMod), minion)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Katarina

            p = new PassiveDamage
            {
                ChampionName = "Katarina",
                IsActive     = minion => (minion.HasBuff("KataQMark1")),
                GetDamage    =
                    minion => ((float)DamageLib.getDmg(minion, DamageLib.SpellType.Q, DamageLib.StageType.FirstDamage)),
            };
            AttackPassives.Add(p);

            #endregion

            #region KogMaw

            p = new PassiveDamage
            {
                ChampionName = "KogMaw",
                IsActive     = minion => (Player.HasBuff("KogMawBioArcaneBarrage")),
                GetDamage    = minion => ((float)DamageLib.getDmg(minion, DamageLib.SpellType.W)),
            };
            AttackPassives.Add(p);

            #endregion

            #region MissFortune

            p = new PassiveDamage
            {
                ChampionName = "MissFortune",
                IsActive     = minion => (Player.HasBuff("MissFortunePassive")),
                GetDamage    =
                    minion =>
                    (float)
                    DamageLib.CalcMagicDmg(
                        (float)0.06d * (Player.BaseAttackDamage + Player.FlatPhysicalDamageMod), minion),
            };
            AttackPassives.Add(p);

            #endregion

            #region Nasus

            p = new PassiveDamage
            {
                ChampionName = "Nasus",
                IsActive     = minion => (Player.HasBuff("SiphoningStrike")),
                GetDamage    = minion => ((float)DamageLib.getDmg(minion, DamageLib.SpellType.Q)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Orianna

            p = new PassiveDamage
            {
                ChampionName = "Orianna",
                IsActive     = minion => (Player.HasBuff("OrianaSpellSword")),
                GetDamage    =
                    minion =>
                    (float)
                    DamageLib.CalcMagicDmg(
                        (float)0.15d * Player.FlatMagicDamageMod +
                        new float[] { 10, 10, 10, 18, 18, 18, 26, 26, 26, 34, 34, 34, 42, 42, 42, 50, 50, 50 }[
                            Player.Level - 1], minion),
            };
            AttackPassives.Add(p);

            #endregion

            #region Teemo

            p = new PassiveDamage
            {
                ChampionName = "Teemo",
                IsActive     = minion => (Player.HasBuff("Toxic Attack")),
                GetDamage    =
                    minion =>
                    ((float)
                     DamageLib.CalcMagicDmg(
                         Player.Spellbook.GetSpell(SpellSlot.E).Level * 10 + Player.FlatMagicDamageMod * 0.3d,
                         minion)),
            };
            AttackPassives.Add(p);

            #endregion

            #region TwistedFate

            p = new PassiveDamage
            {
                ChampionName = "TwistedFate",
                IsActive     = minion => (Player.HasBuff("Pick A Card Blue")),
                GetDamage    =
                    minion =>
                    (float)DamageLib.getDmg(minion, DamageLib.SpellType.W, DamageLib.StageType.FirstDamage) -
                    (float)
                    DamageLib.CalcPhysicalDmg(
                        (ObjectManager.Player.BaseAttackDamage + ObjectManager.Player.FlatPhysicalDamageMod),
                        minion),
            };
            AttackPassives.Add(p);

            p = new PassiveDamage
            {
                ChampionName = "TwistedFate",
                IsActive     = minion => (Player.HasBuff("CardMasterStackParticle")),
                GetDamage    = minion => (float)DamageLib.getDmg(minion, DamageLib.SpellType.E),
            };
            AttackPassives.Add(p);

            #endregion

            #region Varus

            p = new PassiveDamage
            {
                ChampionName = "Varus",
                IsActive     = minion => (Player.HasBuff("VarusW")),
                GetDamage    = minion => ((float)DamageLib.getDmg(minion, DamageLib.SpellType.W)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Vayne

            p = new PassiveDamage
            {
                ChampionName = "Vayne",
                IsActive     = minion => (Player.HasBuff("VayneTumble")),
                GetDamage    = minion => ((float)DamageLib.getDmg(minion, DamageLib.SpellType.Q)),
            };
            AttackPassives.Add(p);

            p = new PassiveDamage
            {
                ChampionName = "Vayne",
                IsActive     =
                    minion =>
                    (from buff in minion.Buffs where buff.DisplayName == "VayneSilverDebuff" select buff.Count)
                    .FirstOrDefault() == 2,
                GetDamage = minion => ((float)DamageLib.getDmg(minion, DamageLib.SpellType.W)),
            };
            AttackPassives.Add(p);

            #endregion

            #region Ziggs

            p = new PassiveDamage
            {
                ChampionName = "Ziggs",
                IsActive     = minion => (Player.HasBuff("ziggsShortFuse")),
                GetDamage    =
                    minion =>
                    (float)
                    DamageLib.CalcMagicDmg(
                        (float)0.25d * Player.FlatMagicDamageMod +
                        new float[]
                        { 20, 24, 28, 32, 36, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124, 136, 148, 160 }[
                            Player.Level - 1], minion),
            };
            AttackPassives.Add(p);

            #endregion

            #endregion
        }
Exemplo n.º 5
0
        private void GetNormalTarget()
        {
            Obj_AI_Hero newtarget = null;

            if (_mode != Mode.AutoPriority)
            {
                foreach (var target in ObjectManager.Get <Obj_AI_Hero>())
                {
                    if (target.IsValidTarget() && Geometry.Distance(target) <= _range)
                    {
                        if (newtarget == null)
                        {
                            newtarget = target;
                        }
                        else
                        {
                            switch (_mode)
                            {
                            case Mode.LowHP:
                                if (target.Health < newtarget.Health)
                                {
                                    newtarget = target;
                                }
                                break;

                            case Mode.MostAD:
                                if (target.BaseAttackDamage + target.FlatPhysicalDamageMod <
                                    newtarget.BaseAttackDamage + newtarget.FlatPhysicalDamageMod)
                                {
                                    newtarget = target;
                                }
                                break;

                            case Mode.MostAP:
                                if (target.FlatMagicDamageMod < newtarget.FlatMagicDamageMod)
                                {
                                    newtarget = target;
                                }
                                break;

                            case Mode.Closest:
                                if (Geometry.Distance(target) < Geometry.Distance(newtarget))
                                {
                                    newtarget = target;
                                }
                                break;

                            case Mode.NearMouse:
                                if (SharpDX.Vector2.Distance(Game.CursorPos.To2D(), target.Position.To2D()) <
                                    SharpDX.Vector2.Distance(Game.CursorPos.To2D(), newtarget.Position.To2D()))
                                {
                                    newtarget = target;
                                }
                                break;

                            case Mode.LessAttack:
                                if ((target.Health - DamageLib.CalcPhysicalDmg(target.Health, target)) <
                                    (newtarget.Health - DamageLib.CalcPhysicalDmg(newtarget.Health, newtarget)))
                                {
                                    newtarget = target;
                                }
                                break;

                            case Mode.LessCast:
                                if ((target.Health - DamageLib.CalcMagicDmg(target.Health, target)) <
                                    (target.Health - DamageLib.CalcMagicDmg(newtarget.Health, newtarget)))
                                {
                                    newtarget = target;
                                }
                                break;
                            }
                        }
                    }
                }
            }
            else
            {
                newtarget = AutoPriority();
            }

            Target = newtarget;
        }