Exemplo n.º 1
0
        private static bool CheckMinions()
        {
            if (!Properties.Time.CheckRendDelay())
            {
                return(false);
            }

            if (Properties.MainMenu.Item("bUseManaManager").GetValue <bool>())
            {
                if (Properties.PlayerHero.ManaPercent < Properties.MainMenu.Item("sMinManaE").GetValue <Slider>().Value)
                {
                    return(false);
                }
            }

            var count = 0;

            var minions = MinionManager.GetMinions(Properties.PlayerHero.ServerPosition, Properties.Champion.E.Range);

            count += minions.Count(minion => minion.Health <= DamageCalc.GetRendDamage(minion) && minion.IsValid);
            if (Properties.MainMenu.Item("sAutoEMinionsKilled").GetValue <Slider>().Value > count)
            {
                return(false);
            }
#if DEBUG_MODE
            Console.WriteLine("Using Minion E:{0}", Properties.Time.TickCount);
#endif
            Properties.Champion.UseRend();
            return(true);
        }
Exemplo n.º 2
0
        public static void CheckNonKillables(AttackableUnit minion)
        {
            try
            {
                if (!Properties.Time.CheckNonKillable())
                {
                    return;
                }
                if (!Properties.MainMenu.Item("bUseENonKillables").GetValue <bool>() || !Properties.Champion.E.IsReady())
                {
                    return;
                }
                if (!(minion.Health <= DamageCalc.GetRendDamage((Obj_AI_Base)minion)) || minion.Health > 60)
                {
                    return;
                }
                if (minion.IsValidTarget(Properties.Champion.E.Range))
#if DEBUG_MODE
                { Console.WriteLine("Killing NonKillables"); }
#endif
                { Properties.Champion.UseNonKillableRend(); }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Exemplo n.º 3
0
        private static bool AutoEOnLeave()
        {
            if (!Properties.Time.CheckRendDelay())
            {
                return(false);
            }

            if (Properties.MainMenu.Item("bUseManaManager").GetValue <bool>())
            {
                if (Properties.PlayerHero.ManaPercent < Properties.MainMenu.Item("sMinManaE").GetValue <Slider>().Value)
                {
                    return(false);
                }
            }

            foreach (var target in HeroManager.Enemies)
            {
                if (!target.IsValid)
                {
                    continue;
                }
                if (!target.IsValidTarget(Properties.Champion.E.Range))
                {
                    continue;
                }
                if (!Properties.Time.CheckRendDelay())
                {
                    continue;
                }
                if (DamageCalc.CheckNoDamageBuffs(target))
                {
                    continue;
                }
                if (!Properties.Champion.E.IsInRange(target))
                {
                    continue;
                }
                if (target.IsDead)
                {
                    continue;
                }
                if (target.Distance(Properties.PlayerHero) < Properties.Champion.E.Range - 100)
                {
                    continue;
                }
                var stacks = target.GetBuffCount("kalistaexpungemarker");
                if (stacks <= Properties.MainMenu.Item("sStacksOnLeave").GetValue <Slider>().Value)
                {
                    continue;
                }
#if DEBUG_MODE
                Console.WriteLine("Using Rend On Long  E:{0}", Properties.Time.TickCount);
#endif
                Properties.Champion.UseRend();
                return(true);
            }
            return(false);
        }
Exemplo n.º 4
0
        private static bool CheckEpicMinions()
        {
            bool found = false;

            if (!Properties.Time.CheckRendDelay())
            {
                return(false);
            }

            if (Properties.MainMenu.Item("bUseManaManager").GetValue <bool>())
            {
                if (Properties.PlayerHero.ManaPercent < Properties.MainMenu.Item("sMinManaE").GetValue <Slider>().Value)
                {
                    return(false);
                }
            }

            foreach (var epic in MinionManager.GetMinions(Properties.PlayerHero.ServerPosition, Properties.Champion.E.Range).Where(epic => epic.IsValid))
            {
                if (epic.CharData.BaseSkinName.ToLower().Contains("siege"))
                {
                    if (DamageCalc.GetRendDamage(epic) < epic.Health)
                    {
                        continue;
                    }
                    found = true;
                    break;
                }
                if (!epic.CharData.BaseSkinName.ToLower().Contains("super"))
                {
                    continue;
                }
                if (DamageCalc.GetRendDamage(epic) < epic.Health)
                {
                    continue;
                }
                found = true;
                break;
            }
            if (!found)
            {
                return(false);
            }

            Properties.Champion.UseRend();
            return(true);
        }
Exemplo n.º 5
0
        public static bool CheckEnemies()
        {
            if (!Properties.Time.CheckRendDelay())
            {
                return(false);
            }

            foreach (var target in HeroManager.Enemies)
            {
                if (!target.IsValid)
                {
                    continue;
                }
                if (!target.IsValidTarget(Properties.Champion.E.Range))
                {
                    continue;
                }
                if (DamageCalc.CheckNoDamageBuffs(target))
                {
                    continue;
                }
                if (!Properties.Time.CheckRendDelay())
                {
                    continue;
                }
                if (!Properties.Champion.E.IsInRange(target))
                {
                    continue;
                }
                if (DamageCalc.GetRendDamage(target) < target.Health)
                {
                    continue;
                }
                if (target.IsDead)
                {
                    continue;
                }
#if DEBUG_MODE
                Console.WriteLine("Using Killing Enemy E:{0}", Properties.Time.TickCount);
#endif
                Properties.Champion.UseRend();
                return(true);
            }
            return(false);
        }
Exemplo n.º 6
0
        private static bool AutoEOnStacksAndMinions()
        {
            if (!Properties.Time.CheckRendDelay())
            {
                return(false);
            }

            foreach (var target in HeroManager.Enemies)
            {
                if (!target.IsValid)
                {
                    continue;
                }
                if (!target.IsValidTarget(Properties.Champion.E.Range))
                {
                    continue;
                }
                if (DamageCalc.CheckNoDamageBuffs(target))
                {
                    continue;
                }
                if (!Properties.Time.CheckRendDelay())
                {
                    continue;
                }
                var stacks = target.GetBuffCount("kalistaexpungemarker");
                if (stacks < Properties.MainMenu.Item("sUseEOnChampStacks").GetValue <Slider>().Value)
                {
                    continue;
                }
                var minions = MinionManager.GetMinions(Properties.PlayerHero.ServerPosition, Properties.Champion.E.Range);
                var count   = minions.Count(minion => minion.Health <= DamageCalc.GetRendDamage(minion) && minion.IsValid);
                if (Properties.MainMenu.Item("sUseEOnMinionKilled").GetValue <Slider>().Value > count)
                {
                    continue;
                }
                Properties.Champion.UseRend();
#if DEBUG_MODE
                Console.WriteLine("Using Stacks And Minions E:{0}", Environment.TickCount);
#endif
                return(true);
            }
            return(false);
        }
Exemplo n.º 7
0
        private static bool CheckBuffMonsters()
        {
            // ReSharper disable once UnusedVariable
            if (!Properties.Time.CheckRendDelay())
            {
                return(false);
            }
            if (Properties.MainMenu.Item("bUseManaManager").GetValue <bool>())
            {
                if (Properties.PlayerHero.ManaPercent < Properties.MainMenu.Item("sMinManaE").GetValue <Slider>().Value)
                {
                    return(false);
                }
            }

            foreach (var monster in MinionManager.GetMinions(Properties.PlayerHero.ServerPosition,
                                                             Properties.Champion.E.Range,
                                                             MinionTypes.All,
                                                             MinionTeam.Neutral,
                                                             MinionOrderTypes.MaxHealth))
            {
                if (!monster.CharData.BaseSkinName.Equals("SRU_Red") &&
                    !monster.CharData.BaseSkinName.Equals("SRU_Blue"))
                {
                    continue;
                }

                if (!(DamageCalc.GetRendDamage(monster) > monster.Health))
                {
                    continue;
                }
#if DEBUG_MODE
                Console.WriteLine("Using Buff E:{0}", Properties.Time.TickCount);
#endif
                Properties.Champion.UseRend();
                return(true);
            }
            return(false);
        }
Exemplo n.º 8
0
        private static void Drawing_OnDrawChamp(EventArgs args)
        {
            try
            {
                if (!Properties.MainMenu.Item("bDrawOnChamp").GetValue <bool>() ||
                    Drawing.DamageToUnit == null)
                {
                    return;
                }

                // For every enemis in E range
                foreach (
                    var unit in
                    HeroManager.Enemies.Where(
                        unit => unit.IsValid && unit.IsHPBarRendered && Properties.Champion.E.IsInRange(unit)))
                {
                    const int xOffset = 10;
                    const int yOffset = 20;
                    const int width   = 103;
                    const int height  = 8;

                    var barPos = unit.HPBarPosition;
                    var damage = DamageCalc.GetRendDamage(unit);
                    var percentHealthAfterDamage = Math.Max(0, unit.Health - damage) / unit.MaxHealth;
                    var yPos          = barPos.Y + yOffset;
                    var xPosDamage    = barPos.X + xOffset + width * percentHealthAfterDamage;
                    var xPosCurrentHp = barPos.X + xOffset + width * unit.Health / unit.MaxHealth;

                    if (Properties.MainMenu.Item("cDrawTextOnChamp").GetValue <Circle>().Active&& damage > unit.Health)
                    {
                        LeagueSharp.Drawing.DrawText(barPos.X + xOffset, barPos.Y + yOffset - 13,
                                                     Properties.MainMenu.Item("cDrawTextOnChamp").GetValue <Circle>().Color, "Killable");
                    }

                    LeagueSharp.Drawing.DrawLine(xPosDamage, yPos, xPosDamage, yPos + height, 1, Color.LightGray);

                    if (!Properties.MainMenu.Item("cDrawFillOnChamp").GetValue <Circle>().Active)
                    {
                        return;
                    }

                    var differenceInHp = xPosCurrentHp - xPosDamage;
                    var pos1           = barPos.X + 9 + (107 * percentHealthAfterDamage);

                    for (var i = 0; i < differenceInHp; i++)
                    {
                        LeagueSharp.Drawing.DrawLine(pos1 + i, yPos, pos1 + i, yPos + height, 1,
                                                     Properties.MainMenu.Item("cDrawFillOnChamp").GetValue <Circle>().Color);
                    }
                }

                if (!Properties.MainMenu.Item("bDrawTextOnSelf").GetValue <bool>())
                {
                    return;
                }

                var playerPos  = LeagueSharp.Drawing.WorldToScreen(Properties.PlayerHero.Position);
                var jungleBool = Properties.MainMenu.Item("bUseJungleClear").GetValue <KeyBind>().Active
                    ? "Enabled"
                    : "Disabled";
                var jungleClear = string.Format("Jungle Clear: {0}", jungleBool);
                var vColor      = GetColor(Properties.MainMenu.Item("bUseJungleClear").GetValue <KeyBind>().Active);
                LeagueSharp.Drawing.DrawText(playerPos.X - LeagueSharp.Drawing.GetTextExtent(jungleClear).Width + 50,
                                             playerPos.Y - LeagueSharp.Drawing.GetTextExtent(jungleClear).Height + 30, vColor, jungleClear);
            }
            catch
            {
                //Dumb Color Picker
            }
        }
Exemplo n.º 9
0
        private static void Drawing_OnDrawMonster(EventArgs args)
        {
            try
            {
                if (!Properties.MainMenu.Item("cDrawOnMonsters").GetValue <Circle>().Active ||
                    Drawing.DamageToMonster == null)
                {
                    return;
                }

                foreach (var minion in ObjectManager.Get <Obj_AI_Minion>())
                {
                    if (minion.Team != GameObjectTeam.Neutral || !minion.IsValidTarget() || !minion.IsHPBarRendered)
                    {
                        continue;
                    }

                    var rendDamage = DamageCalc.GetRendDamage(minion);
                    // Game.PrintChat(minion.CharData.BaseSkinName.ToString());
                    // Monster bar widths and offsets from ElSmite
                    var barWidth = 0;
                    var xOffset  = 0;
                    var yOffset  = 0;
                    var yOffset2 = 0;
                    var display  = true;
                    switch (minion.CharData.BaseSkinName)
                    {
                    case "SRU_Red":
                    case "SRU_Blue":
                    case "SRU_Dragon":
                        barWidth = 145;
                        xOffset  = 3;
                        yOffset  = 18;
                        yOffset2 = 10;
                        break;

                    case "SRU_Baron":
                        barWidth = 194;
                        xOffset  = -22;
                        yOffset  = 13;
                        yOffset2 = 16;
                        break;

                    case "Sru_Crab":
                        barWidth = 61;
                        xOffset  = 45;
                        yOffset  = 34;
                        yOffset2 = 3;
                        break;

                    case "SRU_Krug":
                        barWidth = 81;
                        xOffset  = 58;
                        yOffset  = 18;
                        yOffset2 = 4;
                        break;

                    case "SRU_Gromp":
                        barWidth = 87;
                        xOffset  = 62;
                        yOffset  = 18;
                        yOffset2 = 4;
                        break;

                    case "SRU_Murkwolf":
                        barWidth = 75;
                        xOffset  = 54;
                        yOffset  = 19;
                        yOffset2 = 4;
                        break;

                    case "SRU_Razorbeak":
                        barWidth = 75;
                        xOffset  = 54;
                        yOffset  = 18;
                        yOffset2 = 4;
                        break;

                    default:
                        display = false;
                        break;
                    }
                    if (!display)
                    {
                        continue;
                    }
                    var barPos = minion.HPBarPosition;
                    var percentHealthAfterDamage = Math.Max(0, minion.Health - rendDamage) / minion.MaxHealth;
                    var yPos          = barPos.Y + yOffset;
                    var xPosDamage    = barPos.X + xOffset + barWidth * percentHealthAfterDamage;
                    var xPosCurrentHp = barPos.X + xOffset + barWidth * minion.Health / minion.MaxHealth;

                    if (Properties.MainMenu.Item("bDisplayRemainingHealth").GetValue <bool>() && minion.Health > rendDamage || !Properties.MainMenu.Item("cKillableText").GetValue <Circle>().Active)
                    {
                        switch (minion.CharData.BaseSkinName)
                        {
                        case "SRU_Red":
                        case "SRU_Blue":
                        case "SRU_Dragon":
                        case "SRU_Baron":
                            var    playerPos = LeagueSharp.Drawing.WorldToScreen(Properties.PlayerHero.Position);
                            String mobString = String.Format("{0}:Remaining HP :{1}", minion.CharData.BaseSkinName, Math.Ceiling(minion.Health - rendDamage));
                            LeagueSharp.Drawing.DrawText(playerPos.X - LeagueSharp.Drawing.GetTextExtent(mobString).Width + 50,
                                                         playerPos.Y - LeagueSharp.Drawing.GetTextExtent(mobString).Height + 60, Color.DimGray, mobString);
                            break;

                        default:
                            LeagueSharp.Drawing.DrawText(minion.HPBarPosition.X + xOffset, minion.HPBarPosition.Y,
                                                         Properties.MainMenu.Item("cKillableText").GetValue <Circle>().Color, Math.Ceiling(minion.Health - rendDamage).ToString(CultureInfo.CurrentCulture));
                            break;
                        }
                    }
                    if (Properties.MainMenu.Item("cFillMonster").GetValue <Circle>().Active)
                    {
                        var differenceInHp = xPosCurrentHp - xPosDamage;
                        var pos1           = barPos.X + xOffset;

                        for (var i = 0; i < differenceInHp; i++)
                        {
                            LeagueSharp.Drawing.DrawLine(pos1 + i, yPos, pos1 + i, yPos + yOffset2, 1,
                                                         Properties.MainMenu.Item("cFillMonster").GetValue <Circle>().Color);
                        }
                    }
                    else
                    {
                        LeagueSharp.Drawing.DrawLine(xPosDamage, yPos, xPosDamage, yPos + yOffset2, 1,
                                                     Properties.MainMenu.Item("cDrawOnMonsters").GetValue <Circle>().Color);
                    }

                    if (!(rendDamage > minion.Health))
                    {
                        continue;
                    }
                    if (!Properties.MainMenu.Item("cKillableText").GetValue <Circle>().Active)
                    {
                        return;
                    }

                    LeagueSharp.Drawing.DrawText(minion.HPBarPosition.X + xOffset, minion.HPBarPosition.Y,
                                                 Properties.MainMenu.Item("cKillableText").GetValue <Circle>().Color, "Killable");
                }
            }
            catch
            {
                //Dumb color picker
            }
        }
Exemplo n.º 10
0
        private static void LaneClear()
        {
            if (Properties.MainMenu.Item("bUseQLaneClear").GetValue <bool>())
            {
                if (!Properties.PlayerHero.IsWindingUp && !Properties.PlayerHero.IsDashing())
                {
                    var minions = MinionManager.GetMinions(Properties.PlayerHero.ServerPosition,
                                                           Properties.Champion.Q.Range);

                    if (Properties.MainMenu.Item("sLaneClearMinionsKilledQ").GetValue <Slider>().Value <= minions.Count)
                    {
                        foreach (var minion in minions.Where(x => x.Health <= Properties.Champion.Q.GetDamage(x)))
                        {
                            var killcount = 0;

                            foreach (
                                var colminion in
                                GetCollisionMinions(Properties.PlayerHero,
                                                    Properties.PlayerHero.ServerPosition.Extend(minion.ServerPosition, Properties.Champion.Q.Range), Properties.Champion.Q))
                            {
                                if (colminion.Health <= Properties.Champion.Q.GetDamage(colminion))
                                {
                                    killcount++;
                                }
                                else
                                {
                                    break;
                                }
                            }

                            if (killcount <
                                Properties.MainMenu.Item("sLaneClearMinionsKilledQ").GetValue <Slider>().Value)
                            {
                                continue;
                            }

                            Properties.Champion.Q.Cast(minion.ServerPosition);
                            break;
                        }
                    }
                }
            }

            if (Properties.MainMenu.Item("bUseELaneClear").GetValue <bool>())
            {
                var count   = 0;
                var minions = MinionManager.GetMinions(Properties.PlayerHero.ServerPosition, Properties.Champion.E.Range);
                count += minions.Count(minion => minion.Health <= DamageCalc.GetRendDamage(minion) && minion.IsValid);
                if (Properties.MainMenu.Item("sLaneClearMinionsKilled").GetValue <Slider>().Value <= count)
                {
                    if (Properties.Time.CheckRendDelay())
                    {
                        Properties.Champion.UseRend();
#if DEBUG_MODE
                        Console.WriteLine("Using Lane Clear E:{0}", Properties.Time.TickCount);
#endif
                    }
                }
            }

            if (!Properties.MainMenu.Item("bUseJungleClear").GetValue <KeyBind>().Active)
            {
                return;
            }
            foreach (var monster in MinionManager.GetMinions(Properties.PlayerHero.ServerPosition,
                                                             Properties.Champion.E.Range,
                                                             MinionTypes.All,
                                                             MinionTeam.Neutral,
                                                             MinionOrderTypes.MaxHealth))
            {
                if (!(DamageCalc.GetRendDamage(monster) > monster.Health))
                {
                    continue;
                }
                if (!Properties.Time.CheckRendDelay())
                {
                    return;
                }
                Console.WriteLine("Using Jungle CLear E:{0}", Properties.Time.TickCount);
                Properties.Champion.UseRend();
                return;
            }
        }
Exemplo n.º 11
0
        //Cool Q in mid Auto
        //if (Properties.PlayerHero.IsWindingUp || Properties.PlayerHero.IsDashing())
        //Properties.Champion.Q.Cast(predictionPosition.CastPosition);

        private static void Mixed()
        {
            if (Properties.MainMenu.Item("bUseQMixed").GetValue <bool>() && Properties.Champion.Q.IsReady())
            {
                if (!Properties.MainMenu.Item("bUseManaManager").GetValue <bool>() ||
                    Properties.MainMenu.Item("bUseManaManager").GetValue <bool>() &&
                    Properties.PlayerHero.ManaPercent > Properties.MainMenu.Item("sMinManaQ").GetValue <Slider>().Value)
                {
                    var target = TargetSelector.GetTarget(Properties.Champion.Q.Range,
                                                          TargetSelector.DamageType.Physical);
                    var predictionPosition = Properties.Champion.Q.GetPrediction(target);
                    if (predictionPosition.Hitchance >= GetHitChance())
                    {
                        if (predictionPosition.Hitchance >= GetHitChance())
                        {
                            if (Properties.MainMenu.Item("bUseQMixedReset").GetValue <bool>())
                            {
                                if (Properties.PlayerHero.IsWindingUp || Properties.PlayerHero.IsDashing())
                                {
                                    Properties.Champion.Q.Cast(predictionPosition.CastPosition);
                                }
                            }
                            else if (!Properties.PlayerHero.IsWindingUp && !Properties.PlayerHero.IsDashing())
                            {
                                Properties.Champion.Q.Cast(predictionPosition.CastPosition);
                            }
                        }
                    }
                }
            }

            if (!Properties.MainMenu.Item("bUseEMixed").GetValue <bool>())
            {
                return;
            }

            if (!Properties.MainMenu.Item("bUseManaManager").GetValue <bool>() ||
                Properties.MainMenu.Item("bUseManaManager").GetValue <bool>() &&
                Properties.PlayerHero.ManaPercent > Properties.MainMenu.Item("sMinManaE").GetValue <Slider>().Value)
            {
                // ReSharper disable once UnusedVariable
                foreach (var stacks in from target in HeroManager.Enemies
                         where target.IsValid
                         where target.IsValidTarget(Properties.Champion.E.Range)
                         where !DamageCalc.CheckNoDamageBuffs(target)
                         select target.GetBuffCount("kalistaexpungemarker")
                         into stacks
                         where stacks >= Properties.MainMenu.Item("sMixedStacks").GetValue <Slider>().Value
                         select stacks)
                {
                    if (!Properties.Time.CheckRendDelay()) // Wait for rend delay
                    {
                        continue;
                    }
#if DEBUG_MODE
                    Console.WriteLine("Using Mixed E:{0}", Properties.Time.TickCount);
#endif
                    Properties.Champion.UseRend();
                }
            }
        }
Exemplo n.º 12
0
        private static void OrbWalkMinions()
        {
            var target = TargetSelector.GetTarget(Properties.Champion.E.Range * 1.2f, TargetSelector.DamageType.Physical);

            if (target != null)
            {
                // ReSharper disable once InconsistentNaming
                var Minions = MinionManager.GetMinions(Properties.PlayerHero.Position, Orbwalking.GetRealAutoAttackRange(Properties.PlayerHero), MinionTypes.All, MinionTeam.NotAlly);

                if (Minions == null)
                {
                    return;
                }

                var target2 = TargetSelector.GetTarget(700, TargetSelector.DamageType.Physical);

                foreach (var minion in Minions)
                {
                    if (target2 != null)
                    {
                        continue;
                    }
                    if (Vector3.Distance(ObjectManager.Player.ServerPosition, minion.Position) > Orbwalking.GetRealAutoAttackRange(Properties.PlayerHero) + 50)
                    {
                        continue;
                    }
                    if (minion.CharData.BaseSkinName == "gangplankbarrel")
                    {
                        continue;
                    }
                    Properties.PlayerHero.IssueOrder(GameObjectOrder.AttackUnit, minion);
                    break;
                }

                if (target.GetBuffCount("kalistaexpungemarker") <= 0)
                {
                    return;
                }

                if (!(Properties.PlayerHero.Distance(target, true) > Math.Pow(Orbwalking.GetRealAutoAttackRange(target), 2)))
                {
                    return;
                }

                var minions = ObjectManager.Get <Obj_AI_Minion>().Where(m => m.IsValidTarget(Orbwalking.GetRealAutoAttackRange(m)));

                var objAiMinions = minions as Obj_AI_Minion[] ?? minions.ToArray();
                if (
                    objAiMinions.Any(
                        m => Properties.Champion.E.CanCast(m) && m.Health <= Properties.Champion.E.GetDamage(m)))
                {
                    Properties.Champion.UseRend();
                }
                else
                {
                    // ReSharper disable once PossibleMultipleEnumeration
                    var minion =
                        VectorHelper.GetDashObjects(objAiMinions)
                        .Find(
                            m =>
                            m.Health > Properties.PlayerHero.GetAutoAttackDamage(m) &&
                            m.Health <
                            Properties.PlayerHero.GetAutoAttackDamage(m) + DamageCalc.GetRendDamage(m));
                    if (minion != null && minion.CharData.BaseSkinName != "gangplankbarrel")
                    {
                        if (Properties.SkyWalker != null)
                        {
                            Properties.SkyWalker.ForceTarget(minion);
                        }
                        else if (Properties.CommonWalker != null)
                        {
                            Properties.CommonWalker.ForceTarget(minion);
                        }
                    }
                }
            }
            else
            {
                var minions = MinionManager.GetMinions(Properties.PlayerHero.Position, Orbwalking.GetRealAutoAttackRange(Properties.PlayerHero), MinionTypes.All, MinionTeam.NotAlly);
                foreach (var minion in minions)
                {
                    if (Vector3.Distance(ObjectManager.Player.ServerPosition, minion.Position) > Orbwalking.GetRealAutoAttackRange(Properties.PlayerHero) + 50)
                    {
                        continue;
                    }
                    if (minion.CharData.BaseSkinName == "gangplankbarrel")
                    {
                        continue;
                    }
                    Properties.PlayerHero.IssueOrder(GameObjectOrder.AttackUnit, minion);
                    break;
                }
            }
        }
Exemplo n.º 13
0
        private static bool CheckEpicMonsters()
        {
            // ReSharper disable once UnusedVariable

            if (!Properties.Time.CheckRendDelay())
            {
                return(false);
            }

            if (Properties.MainMenu.Item("bUseManaManager").GetValue <bool>())
            {
                if (Properties.PlayerHero.ManaPercent < Properties.MainMenu.Item("sMinManaE").GetValue <Slider>().Value)
                {
                    return(false);
                }
            }

            if (!MinionManager.GetMinions(Properties.PlayerHero.ServerPosition,
                                          Properties.Champion.E.Range,
                                          MinionTypes.All,
                                          MinionTeam.Neutral,
                                          MinionOrderTypes.MaxHealth)
                .Where(mob => mob.Name.Contains("Baron") || mob.Name.Contains("Dragon")).Any(mob => DamageCalc.GetRendDamage(mob) > mob.Health))
            {
                return(false);
            }

            Properties.Champion.UseRend();
#if DEBUG_MODE
            Console.WriteLine("Using Baron and Dragon E:{0}", Properties.Time.TickCount);
#endif
            return(true);
        }