Пример #1
0
 public static List<Obj_AI_Base> GetMinions(float range,
     MinionTypes type = MinionTypes.All,
     MinionTeam team = MinionTeam.Enemy,
     MinionOrderTypes order = MinionOrderTypes.Health)
 {
     return GetMinions(ObjectManager.Player.ServerPosition, range, type, team, order);
 }
Пример #2
0
        public static Tuple<bool, Obj_AI_Base> IsCanLastHit(Vector3 from, float range, MinionTypes _MinionType, MinionTeam _MinionTeam, MinionOrderTypes _MinionOrderType, bool _IsRanged)
        {
            bool result = false;
            Obj_AI_Base target = null;

            if (HasTargonItem && !player.IsDead && player.Buffs.Any(x => x.Count > 0 && x.Name == "talentreaperdisplay") && IsAllyInRange(1500))
            {
                var minions = MinionManager.GetMinions(from, range, _MinionType, _MinionTeam, _MinionOrderType);
                var itemNum = player.InventoryItems.Any(x => x.Id == ItemId.Face_of_the_Mountain || x.Id == ItemId.Relic_Shield || x.Id == ItemId.Targons_Brace);

                foreach(var minion in minions)
                {
                    var a = player.Buffs.Any(x => x.DisplayName.Contains("ThreshPassiveSoulsGain")) ? player.Buffs.Find(x => x.DisplayName.Contains("ThreshPassiveSoulsGain")).Count : 0;
                    var dmg = _IsRanged ? player.GetAutoAttackDamage(minion) + a : GetItemDmg();

                    if (minion.Health < dmg && player.CanAttack && Orbwalking.InAutoAttackRange(minion))
                    {
                        result = true;
                        target = minion;
                    }
                }
            }

            return new Tuple<bool, Obj_AI_Base>(result, target);
        }
Пример #3
0
 public static List<Obj_AI_Minion> GetMinions(Vector3 from, float range, MinionTypes type = MinionTypes.All,
     MinionTeam team = MinionTeam.Enemy, MinionOrderTypes order = MinionOrderTypes.Health)
 {
     var result = from minion in ObjectManager.Get<Obj_AI_Minion>()
         where minion.IsValidTarget(range, false, @from)
         let minionTeam = minion.Team
         where
             (team == MinionTeam.Neutral && minionTeam == GameObjectTeam.Neutral)
             || (team == MinionTeam.Ally
                 && minionTeam
                 == (myHero.Team == GameObjectTeam.Chaos ? GameObjectTeam.Chaos : GameObjectTeam.Order))
             || (team == MinionTeam.Enemy
                 && minionTeam
                 == (myHero.Team == GameObjectTeam.Chaos ? GameObjectTeam.Order : GameObjectTeam.Chaos))
             || (team == MinionTeam.NotAlly && minionTeam != myHero.Team)
             || (team == MinionTeam.NotAllyForEnemy
                 && (minionTeam == myHero.Team || minionTeam == GameObjectTeam.Neutral))
             || team == MinionTeam.All
         where
             (minion.IsMelee() && type == MinionTypes.Melee)
             || (!minion.IsMelee() && type == MinionTypes.Ranged) || type == MinionTypes.All
         where MinionManager.IsMinion(minion) || minionTeam == GameObjectTeam.Neutral || IsPet(minion)
         select minion;
     switch (order)
     {
         case MinionOrderTypes.Health:
             result = result.OrderBy(i => i.Health);
             break;
         case MinionOrderTypes.MaxHealth:
             result = result.OrderBy(i => i.MaxHealth).Reverse();
             break;
     }
     return result.ToList();
 }
Пример #4
0
        /// <summary>
        /// Returns the minions in range from From.
        /// </summary>
        public static List<Obj_AI_Base> GetMinions(Vector3 from,
            float range,
            MinionTypes type = MinionTypes.All,
            MinionTeam team = MinionTeam.Enemy,
            MinionOrderTypes order = MinionOrderTypes.Health)
        {
            var result = new List<Obj_AI_Base>();

            foreach (var minion in ObjectManager.Get<Obj_AI_Minion>())
            {
                if (minion.IsValidTarget(range, false))
                {
                    if (team == MinionTeam.Neutral && minion.Team == GameObjectTeam.Neutral ||
                        team == MinionTeam.Ally &&
                        minion.Team ==
                        (ObjectManager.Player.Team == GameObjectTeam.Chaos ? GameObjectTeam.Chaos : GameObjectTeam.Order) ||
                        team == MinionTeam.Enemy &&
                        minion.Team ==
                        (ObjectManager.Player.Team == GameObjectTeam.Chaos ? GameObjectTeam.Order : GameObjectTeam.Chaos) ||
                        team == MinionTeam.NotAlly && minion.Team != ObjectManager.Player.Team ||
                        team == MinionTeam.NotAllyForEnemy &&
                        (minion.Team == ObjectManager.Player.Team || minion.Team == GameObjectTeam.Neutral) ||
                        team == MinionTeam.All)
                    {
                        if (minion.IsMelee() && type == MinionTypes.Melee ||
                            !minion.IsMelee() && type == MinionTypes.Ranged || type == MinionTypes.All)
                        {
                            result.Add(minion);
                        }
                    }
                }
            }

            if (order == MinionOrderTypes.Health)
            {
                result = result.OrderBy(o => o.Health).ToList();
            }
            else if (order == MinionOrderTypes.MaxHealth)
            {
                result = result.OrderBy(o => o.MaxHealth).Reverse().ToList();
            }

            return result;
        }
        /// <summary>
        ///     Returns the minions in range from From.
        /// </summary>
        public static List<Obj_AI_Base> GetMinions(Vector3 from,
            float range,
            MinionTypes type = MinionTypes.All,
            MinionTeam team = MinionTeam.Enemy,
            MinionOrderTypes order = MinionOrderTypes.Health)
        {
            var result = (from minion in GameObjects.Minions.Concat(GameObjects.Jungle)
                where minion.IsValidTarget(range, false, @from)
                let minionTeam = minion.Team
                where
                    team == MinionTeam.Neutral && minionTeam == GameObjectTeam.Neutral ||
                    team == MinionTeam.Ally &&
                    minionTeam ==
                    (ObjectManager.Player.Team == GameObjectTeam.Chaos ? GameObjectTeam.Chaos : GameObjectTeam.Order) ||
                    team == MinionTeam.Enemy &&
                    minionTeam ==
                    (ObjectManager.Player.Team == GameObjectTeam.Chaos ? GameObjectTeam.Order : GameObjectTeam.Chaos) ||
                    team == MinionTeam.NotAlly && minionTeam != ObjectManager.Player.Team ||
                    team == MinionTeam.NotAllyForEnemy &&
                    (minionTeam == ObjectManager.Player.Team || minionTeam == GameObjectTeam.Neutral) ||
                    team == MinionTeam.All
                where
                    minion.IsMelee() && type == MinionTypes.Melee || !minion.IsMelee() && type == MinionTypes.Ranged ||
                    type == MinionTypes.All
                where IsMinion(minion) || minionTeam == GameObjectTeam.Neutral
                select minion).Select(m => m as Obj_AI_Base).ToList();

            switch (order)
            {
                case MinionOrderTypes.Health:
                    result = result.OrderBy(o => o.Health).ToList();
                    break;
                case MinionOrderTypes.MaxHealth:
                    result = result.OrderBy(o => o.MaxHealth).Reverse().ToList();
                    break;
            }

            return result;
        }
Пример #6
0
 public static List<Obj_AI_Minion> GetMinions(float range, MinionTypes type = MinionTypes.All,
     MinionTeam team = MinionTeam.Enemy, MinionOrderTypes order = MinionOrderTypes.Health)
 {
     return GetMinions(myHero.ServerPosition, range, type, team, order);
 }
Пример #7
0
        public static List<Obj_AI_Base> GetMinions(Vector3 from,
            float range,
            MinionTypes type = MinionTypes.All,
            MinionTeam team = MinionTeam.Enemy,
            MinionOrderTypes order = MinionOrderTypes.Health)
        {
            var result = (from minion in ObjectManager.Get<Obj_AI_Minion>()
                          where minion.IsValidTarget(range, false, @from)
                          let minionTeam = minion.Team
                          where
                              team == MinionTeam.Neutral && minionTeam == GameObjectTeam.Neutral ||
                              team == MinionTeam.Ally &&
                              minionTeam ==
                              (ObjectManager.Player.Team == GameObjectTeam.Chaos ? GameObjectTeam.Chaos : GameObjectTeam.Order) ||
                              team == MinionTeam.Enemy &&
                              minionTeam ==
                              (ObjectManager.Player.Team == GameObjectTeam.Chaos ? GameObjectTeam.Order : GameObjectTeam.Chaos) ||
                              team == MinionTeam.NotAlly && minionTeam != ObjectManager.Player.Team ||
                              team == MinionTeam.NotAllyForEnemy &&
                              (minionTeam == ObjectManager.Player.Team || minionTeam == GameObjectTeam.Neutral) ||
                              team == MinionTeam.All
                          where
                              !minion.IsRanged && type == MinionTypes.Melee || minion.IsRanged && type == MinionTypes.Ranged ||
                              type == MinionTypes.All
                          where IsMinion(minion) || minionTeam == GameObjectTeam.Neutral && minion.MaxHealth > 5 && minion.IsHPBarRendered
                          select minion).Cast<Obj_AI_Base>().ToList();

            switch (order)
            {
                case MinionOrderTypes.Health:
                    result = result.OrderBy(o => o.Health).ToList();
                    break;
                case MinionOrderTypes.MaxHealth:
                    result = result.OrderByDescending(o => o.MaxHealth).ToList();
                    break;
            }

            return result;
        }
Пример #8
0
        public static List <Obj_AI_Minion> GetMinions(Vector3 from, float range, MinionTypes type = MinionTypes.All,
                                                      MinionTeam team = MinionTeam.Enemy, MinionOrderTypes order = MinionOrderTypes.Health)
        {
            var result = from minion in ObjectManager.Get <Obj_AI_Minion>()
                         where minion.LSIsValidTarget(range, false, @from)
                         let minionTeam = minion.Team
                                          where
                                          (team == MinionTeam.Neutral && minionTeam == GameObjectTeam.Neutral) ||
                                          (team == MinionTeam.Ally &&
                                           minionTeam
                                           == (myHero.Team == GameObjectTeam.Chaos ? GameObjectTeam.Chaos : GameObjectTeam.Order)) ||
                                          (team == MinionTeam.Enemy &&
                                           minionTeam
                                           == (myHero.Team == GameObjectTeam.Chaos ? GameObjectTeam.Order : GameObjectTeam.Chaos)) ||
                                          (team == MinionTeam.NotAlly && minionTeam != myHero.Team) ||
                                          (team == MinionTeam.NotAllyForEnemy &&
                                           (minionTeam == myHero.Team || minionTeam == GameObjectTeam.Neutral)) ||
                                          team == MinionTeam.All
                                          where
                                          (minion.IsMelee() && type == MinionTypes.Melee) ||
                                          (!minion.IsMelee() && type == MinionTypes.Ranged) || type == MinionTypes.All
                                          where MinionManager.IsMinion(minion) || minionTeam == GameObjectTeam.Neutral || IsPet(minion)
                                          select minion;

            switch (order)
            {
            case MinionOrderTypes.Health:
                result = result.OrderBy(i => i.Health);
                break;

            case MinionOrderTypes.MaxHealth:
                result = result.OrderBy(i => i.MaxHealth).Reverse();
                break;
            }
            return(result.ToList());
        }
Пример #9
0
 public static List <Obj_AI_Minion> GetMinions(float range, MinionTypes type = MinionTypes.All,
                                               MinionTeam team = MinionTeam.Enemy, MinionOrderTypes order = MinionOrderTypes.Health)
 {
     return(GetMinions(myHero.ServerPosition, range, type, team, order));
 }
Пример #10
0
        /// <summary>
        ///     Gets minions based on range, type, team and then orders them.
        /// </summary>
        /// <param name="from">The point to get the minions from.</param>
        /// <param name="range">The range.</param>
        /// <param name="type">The type.</param>
        /// <param name="team">The team.</param>
        /// <param name="order">The order.</param>
        /// <returns>List&lt;Obj_AI_Base&gt;.</returns>
        public static List <Obj_AI_Base> GetMinions(
            Vector3 from,
            float range,
            MinionTypes type       = MinionTypes.All,
            MinionTeam team        = MinionTeam.Enemy,
            MinionOrderTypes order = MinionOrderTypes.Health)
        {
            var result = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsMonster && x.Team == GameObjectTeam.Neutral && !x.IsMinion && !x.BaseSkinName.Contains("Plant")).Cast <Obj_AI_Base>().ToList();

            if (team == MinionTeam.All)
            {
                var a = EloBuddy.SDK.EntityManager.MinionsAndMonsters.Minions.Cast <Obj_AI_Base>().ToList();
                var b = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsMonster && x.Team == GameObjectTeam.Neutral && !x.IsMinion && !x.BaseSkinName.Contains("Plant")).Cast <Obj_AI_Base>().ToList();
                result = a.Concat(b).ToList();
            }

            if (team == MinionTeam.Ally)
            {
                result = EloBuddy.SDK.EntityManager.MinionsAndMonsters.AlliedMinions.Cast <Obj_AI_Base>().ToList();
            }

            if (team == MinionTeam.Enemy)
            {
                result = EloBuddy.SDK.EntityManager.MinionsAndMonsters.EnemyMinions.Cast <Obj_AI_Base>().ToList();
            }

            if (team == MinionTeam.Neutral)
            {
                result = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsMonster && x.Team == GameObjectTeam.Neutral && !x.IsMinion && !x.BaseSkinName.Contains("Plant")).Cast <Obj_AI_Base>().ToList();
            }

            if (team == MinionTeam.NotAlly)
            {
                var a = EloBuddy.SDK.EntityManager.MinionsAndMonsters.EnemyMinions.Cast <Obj_AI_Base>().ToList();
                var b = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsMonster && x.Team == GameObjectTeam.Neutral && !x.IsMinion && !x.BaseSkinName.Contains("Plant")).Cast <Obj_AI_Base>().ToList();
                result = a.Concat(b).ToList();
            }

            if (team == MinionTeam.NotAllyForEnemy)
            {
                var a = EloBuddy.SDK.EntityManager.MinionsAndMonsters.AlliedMinions.Cast <Obj_AI_Base>().ToList();
                var b = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsMonster && x.Team == GameObjectTeam.Neutral && !x.IsMinion && !x.BaseSkinName.Contains("Plant")).Cast <Obj_AI_Base>().ToList();
                result = a.Concat(b).ToList();
            }

            switch (type)
            {
            case MinionTypes.All:
                result = result;
                break;

            case MinionTypes.Melee:
                result = result.Where(x => x.IsMelee).ToList();
                break;

            case MinionTypes.Ranged:
                result = result.Where(x => !x.IsMelee).ToList();
                break;

            case MinionTypes.Wards:
                result = result.Where(x => x.Name.Contains("Ward") && x.IsHPBarRendered).ToList();
                break;
            }

            switch (order)
            {
            case MinionOrderTypes.Health:
                result = result.OrderBy(o => o.Health).ToList();
                break;

            case MinionOrderTypes.MaxHealth:
                result = result.OrderByDescending(o => o.MaxHealth).ToList();
                break;
            }

            result = result.Where(x => x.IsValidTarget(range, false, @from)).ToList();

            return(result);
        }