public static void AddToMenu(Menu menu,
            string uniqueId,
            HealthCheckType checkType,
            HealthValueType valueType,
            string prefix = null,
            int value = 30,
            int minValue = 0,
            int maxValue = 100)
        {
            try
            {
                if (Menues.ContainsKey(uniqueId))
                {
                    throw new ArgumentException(
                        string.Format("HealthHealthger: UniqueID \"{0}\" already exist.", uniqueId));
                }

                menu.AddItem(
                    new MenuItem(
                        menu.Name + ".health-" + uniqueId,
                        (!string.IsNullOrEmpty(prefix) ? prefix + " " : string.Empty) +
                        (checkType == HealthCheckType.Minimum ? "Min. Health" : "Max. Health") +
                        (valueType == HealthValueType.Percent ? " %" : string.Empty)).SetValue(
                            new Slider(value, minValue, maxValue)));

                Menues[uniqueId] = new Tuple<Menu, HealthCheckType, HealthValueType>(menu, checkType, valueType);
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
        public static void AddToMenu(Menu theMenu)
        {
            _myMenu = theMenu;

            //add item list to menu
            CreateList();

            var offensiveItem = new Menu("Offensive Items", "Offensive Items");
            {
                foreach (var item in ItemList)
                {
                    AddOffensiveItem(offensiveItem, item);
                }
                _myMenu.AddSubMenu(offensiveItem);
            }

            var summoners = new Menu("Summoners", "Summoners");
            {
                var ignite = new Menu("Ignite", "Ignite");
                {
                    ignite.AddItem(new MenuItem("ignite", "Use Ignite", true).SetValue(true));
                    ignite.AddItem(
                        new MenuItem("igniteMode", "Ignite Mode", true).SetValue(new StringList(new[] { "Combo", "KS" })));
                    summoners.AddSubMenu(ignite);
                }
                _myMenu.AddSubMenu(summoners);
            }

            Orbwalking.AfterAttack += AfterAttack;
            Orbwalking.OnAttack += OnAttack;
            Game.OnUpdate += Game_OnGameUpdate;
        }
Beispiel #3
1
        private static void Game_OnGameLoad(EventArgs args)
        {
            EQDrawList = new List<Vector3>();
            Player = ObjectManager.Player;
            if (Player.ChampionName != ChampionName) return;
            Q = new Spell(SpellSlot.Q, 700f);
            Q.SetSkillshot(0.5f, 70f, float.MaxValue, false, SkillshotType.SkillshotLine);

            W = new Spell(SpellSlot.W, 300f);

            E = new Spell(SpellSlot.E, 830f);
            E.SetSkillshot(0.5f, 70f, float.MaxValue, false, SkillshotType.SkillshotCircle);
            Config = new Menu("J4Helper", "J4Helper", true);
            //Orbwalker
            Config.AddSubMenu(new Menu("Orbwalking", "Orbwalking"));
            Orbwalker = new Orbwalking.Orbwalker(Config.SubMenu("Orbwalking"));

            //Misc
            Config.AddSubMenu(new Menu("Keys", "Keys"));
            Config.SubMenu("Keys")
                .AddItem(
                    new MenuItem("EQMouse", "EQ to Mouse").SetValue(new KeyBind("T".ToCharArray()[0], KeyBindType.Press)));
            Config.AddToMainMenu();
            Game.OnUpdate += Game_OnUpdate;
            Drawing.OnDraw += Drawing_OnDraw;
            Game.PrintChat("J4Helper Loaded.");
            Obj_AI_Base.OnProcessSpellCast += Obj_AI_Base_OnProcessSpellCast;
        }
Beispiel #4
1
        public static void Init()
        {
            Map = Utility.Map.GetMap().Type;
            if (Map != Utility.Map.MapType.HowlingAbyss) return;
            Config = new Menu("AIM: " + ObjectManager.Player.ChampionName,
                "autosharp." + ObjectManager.Player.ChampionName, true);
            Config.AddItem(new MenuItem("autosharp.quit", "Quit after Game End").SetValue(true));
            var options = Config.AddSubMenu(new Menu("Options: ", "autosharp.options"));
            options.AddItem(new MenuItem("autosharp.options.healup", "Take Heals?").SetValue(true));
            var orbwalker = Config.AddSubMenu(new Menu("Orbwalker", "autosharp.orbwalker"));

            new PluginLoader();

            Cache.Load();
            Game.OnUpdate += Positioning.OnUpdate;
            Autoplay.Load();
            Game.OnEnd += OnEnd;
            Obj_AI_Base.OnIssueOrder += AntiShrooms;
            Game.OnUpdate += AntiShrooms2;
            Spellbook.OnCastSpell += OnCastSpell;
            Obj_AI_Base.OnDamage += OnDamage;


            Orbwalker = new MyOrbwalker.Orbwalker(orbwalker);

            Utility.DelayAction.Add(
                new Random().Next(1000, 10000), () =>
                {
                    new LeagueSharp.Common.AutoLevel(Utils.AutoLevel.GetSequence().Select(num => num - 1).ToArray());
                    LeagueSharp.Common.AutoLevel.Enable();
                    Console.WriteLine("AutoLevel Init Success!");
                });
        }
Beispiel #5
1
        private static void Game_OnGameLoad(EventArgs args)
        {
            Config = new Menu("SharpChatLiner", "SharpChatLiner", true);

            Config.AddSubMenu(new Menu("Text 1", "Text 1"));
            Config.SubMenu("Text 1").AddItem(new MenuItem("1", "Say txt File 1").SetValue(new KeyBind("1".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Text 1").AddItem(new MenuItem("ALL1", "Say txt File 1 To ALL")).SetValue(false);

            Config.AddSubMenu(new Menu("Text 2", "Text 2"));
            Config.SubMenu("Text 2").AddItem(new MenuItem("2", "Say txt File 2").SetValue(new KeyBind("2".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Text 2").AddItem(new MenuItem("ALL2", "Say txt File 2 To ALL")).SetValue(false);

            Config.AddSubMenu(new Menu("Text 3", "Text 3"));
            Config.SubMenu("Text 3").AddItem(new MenuItem("3", "Say txt File 3").SetValue(new KeyBind("3".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Text 3").AddItem(new MenuItem("ALL3", "Say txt File 3 To ALL")).SetValue(false);

            Config.AddSubMenu(new Menu("Text 4", "Text 4"));
            Config.SubMenu("Text 4").AddItem(new MenuItem("4", "Say txt File 4").SetValue(new KeyBind("4".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Text 4").AddItem(new MenuItem("ALL4", "Say txt File 4 To ALL")).SetValue(false);

            Config.AddSubMenu(new Menu("Text 5", "Text 5"));
            Config.SubMenu("Text 5").AddItem(new MenuItem("5", "Say txt File 5").SetValue(new KeyBind("5".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Text 5").AddItem(new MenuItem("ALL5", "Say txt File 5 To ALL")).SetValue(false);

            Config.AddSubMenu(new Menu("Text 6", "Text 6"));
            Config.SubMenu("Text 6").AddItem(new MenuItem("6", "Say txt File 6").SetValue(new KeyBind("6".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Text 6").AddItem(new MenuItem("ALL6", "Say txt File 6 To ALL")).SetValue(false);

            Config.AddToMainMenu();

            Game.OnGameUpdate += OnGameUpdate;
            Game.PrintChat("<font color='#FF00BF'>Sharp Chat Liner Loaded By</font> <font color='#FF0000'>The</font><font color='#FFFF00'>Kush</font><font color='#40FF00'>Style</font>");
        }
        public static void AddToMenu(Menu menu, List<Spell> spells)
        {
            try
            {
                _menu = menu;

                spells =
                    spells.DistinctBy(s => s.Slot)
                        .Where(s => s.Slot != SpellSlot.Unknown && (s.IsSkillshot || s.Range > 0f))
                        .ToList();

                foreach (var spell in spells)
                {
                    _menu.AddItem(
                        new MenuItem(_menu.Name + "." + spell.Slot, "Use " + spell.Slot).SetValue(
                            spell.Slot != SpellSlot.R && spell.Instance.Cooldown < 20));
                }

                _menu.AddItem(
                    new MenuItem(_menu.Name + ".min-distance", "Min. Enemy Distance").SetValue(
                        new Slider(1000, 200, 3000)));
                _menu.AddItem(new MenuItem(_menu.Name + ".min-mana", "Min. Mana %").SetValue(new Slider(95, 1)));
                _menu.AddItem(new MenuItem(_menu.Name + ".fountain", "Only Inside Fountain").SetValue(false));
                _menu.AddItem(new MenuItem(_menu.Name + ".enabled", "Enabled").SetValue(false));

                _spells = spells.OrderBy(s => s.ManaCost).ThenBy(s => s.Instance.Cooldown).ToList();
                Core.OnPostUpdate += OnCorePostUpdate;
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
Beispiel #7
1
 private static void CreateMenu()
 {
     Menu = new Menu("AIOAuto", "menu", true);
     Menu.AddItem(new MenuItem("timer", "timer")).SetValue(new Slider(500, 200, 5000));
     Menu.AddItem(new MenuItem("dbbuff", "Simple Buff Checker")).SetValue(new KeyBind("T".ToCharArray()[0], KeyBindType.Press, false));
     Menu.AddToMainMenu();
 }
Beispiel #8
1
        public SFXUtility()
        {
            try
            {
                Menu = new Menu(Name, Name, true);

                var miscMenu = new Menu("Misc", "Misc");

                var infoMenu = new Menu("Info", "Info");
                infoMenu.AddItem(new MenuItem("InfoVersion", string.Format("Version: {0}", Version)));
                infoMenu.AddItem(new MenuItem("InfoIRC", "IRC: Appril"));
                infoMenu.AddItem(new MenuItem("InfoGithub", "Github:").SetValue(new StringList(new[]
                {
                    "Smokyfox",
                    "Lizzaran",
                    "zUsername"
                })));

                miscMenu.AddSubMenu(infoMenu);

                miscMenu.AddItem(new MenuItem("MiscCircleThickness", "Circles Thickness").SetValue(new Slider(3, 10, 1)));

                Menu.AddSubMenu(miscMenu);
                AppDomain.CurrentDomain.DomainUnload += OnExit;
                AppDomain.CurrentDomain.ProcessExit += OnExit;
                CustomEvents.Game.OnGameEnd += OnGameEnd;
                Game.OnGameEnd += OnGameEnd;
                CustomEvents.Game.OnGameLoad += OnGameLoad;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
Beispiel #9
1
        public static void Game_OnGameLoad()
        {
            if (ObjectManager.Player.BaseSkinName != "Sion")
            {
                return;
            }

            //Spells
            Q = new LeagueSharp.Common.Spell(SpellSlot.Q, 1050);
            Q.SetSkillshot(0.6f, 100f, float.MaxValue, false, SkillshotType.SkillshotLine);
            Q.SetCharged("SionQ", "SionQ", 500, 720, 0.5f);

            E = new LeagueSharp.Common.Spell(SpellSlot.E, 800);
            E.SetSkillshot(0.25f, 80f, 1800, false, SkillshotType.SkillshotLine);

            //Make the menu
            Config = MainMenu.AddMenu("Sion", "Sion");

            comboMenu = Config.AddSubMenu("Combo", "Combo");
            comboMenu.Add("UseQCombo", new CheckBox("Use Q"));
            comboMenu.Add("UseWCombo", new CheckBox("Use W"));
            comboMenu.Add("UseECombo", new CheckBox("Use E"));

            Game.OnUpdate += Game_OnGameUpdate;
            Drawing.OnDraw += Drawing_OnDraw;
            Obj_AI_Base.OnProcessSpellCast += ObjAiHeroOnOnProcessSpellCast;
        }
Beispiel #10
1
 private static void Game_OnGameLoad(EventArgs args)
 {
     Config = new Menu("Tracker", "Tracker", true);
     HbTracker.AttachToMenu(Config);
     WardTracker.AttachToMenu(Config);
     Config.AddToMainMenu();
 }
Beispiel #11
0
        private static void LuxMain(EventArgs args)
        {
            Player = ObjectManager.Player;

            if (Player.BaseSkinName != "Lux")
            {
                return;
            }


            Config = LuxMenu.CreateMenu();

            Config.AddToMainMenu();

            InitializeSpells();

            ObjectHandling();

            AntiGapcloser.OnEnemyGapcloser += OnGapClose;

            Interrupter2.OnInterruptableTarget += OnInterruptableTarget;

            Game.OnUpdate += OnUpdate;
            Game.OnUpdate += CheckKillable;
            Drawing.OnDraw += OnDraw;
        }
        public SFXHumanize()
        {
            try
            {
                Menu = new Menu(Name, Name, true);

                var infoMenu = new Menu("Info", Name + "Info");

                infoMenu.AddItem(new MenuItem(infoMenu.Name + "Version", string.Format("{0}: {1}", "Version", Version)));
                infoMenu.AddItem(new MenuItem(infoMenu.Name + "Forum", "Forum" + ": Lizzaran"));
                infoMenu.AddItem(new MenuItem(infoMenu.Name + "Github", "GitHub" + ": Lizzaran"));
                infoMenu.AddItem(new MenuItem(infoMenu.Name + "IRC", "IRC" + ": Appril"));
                infoMenu.AddItem(new MenuItem(infoMenu.Name + "Exception", string.Format("{0}: {1}", "Exception", 0)));

                var globalMenu = new Menu("Settings", Name + "Settings");

                AddReport(globalMenu);

                Menu.AddSubMenu(infoMenu);
                Menu.AddSubMenu(globalMenu);

                AppDomain.CurrentDomain.DomainUnload += OnExit;
                AppDomain.CurrentDomain.ProcessExit += OnExit;
                CustomEvents.Game.OnGameEnd += OnGameEnd;
                CustomEvents.Game.OnGameLoad += OnGameLoad;
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
Beispiel #13
0
        public override void InterruptMenu(Menu config)
        {
            config.AddBool("GapcloserQ", "Use Q to Interrupt Gapcloser", true);

            config.AddBool("InterruptQ", "Use Q to Interrupt Spells", true);
            config.AddBool("InterruptR", "Use R to Interrupt Spells", true);
        }
Beispiel #14
0
        private static void CassMain(EventArgs args)
        {
            Player = ObjectManager.Player;

            if (Player.CharData.BaseSkinName != "Cassiopeia")
            {
                return;
            }


            Config = CassiopeiaMenu.CreateMenu();

            Config.AddToMainMenu();

            InitializeSpells();


            new CommonAutoLevel(skillorder);


            AntiGapcloser.OnEnemyGapcloser += OnGapClose;

            Interrupter2.OnInterruptableTarget += OnInterruptableTarget;

            Game.OnUpdate += OnUpdate;
            Game.OnUpdate += CheckKillable;
            Game.OnUpdate += AutoSpells;
            Drawing.OnDraw += OnDraw;
            Orbwalking.BeforeAttack += BeforeAuto;
        }
Beispiel #15
0
 public virtual void loadMenu()
 {
     menu                = new LeagueSharp.Common.Menu(_menuName, _menuName, true);
     _orbWalkerMenu      = new LeagueSharp.Common.Menu("Orbwalker", "Orbwalker");
     orb                 = new Orbwalking.Orbwalker(_orbWalkerMenu);
     _targetSelectorMenu = new LeagueSharp.Common.Menu("TargetSelector", "TargetSelector");
 }
Beispiel #16
0
        public PerfectWardTracker()
        {
            Game.OnStart   += OnGameStart;
            Game.OnUpdate  += Game_OnGameUpdate;
            Drawing.OnDraw += OnDraw;


            //Create the menu
            Config = new LeagueSharp.Common.Menu("PerfectWard", "PerfectWard", true);

            Config.SubMenu("Drawing").AddItem(new LeagueSharp.Common.MenuItem("drawplaces", "Draw ward places").SetValue(new Circle(true, System.Drawing.Color.FromArgb(100, 255, 0, 255))));
            Config.SubMenu("Drawing").AddItem(new LeagueSharp.Common.MenuItem("drawDistance", "Don't draw if the distance >")).SetValue(new Slider(2000, 10000, 1));
            Config.SubMenu("Drawing").AddItem(new LeagueSharp.Common.MenuItem("placekey", "NormalWard Key").SetValue(new KeyBind("Z".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("Drawing").AddItem(new LeagueSharp.Common.MenuItem("placekeypink", "PinkWard Key").SetValue(new KeyBind("C".ToCharArray()[0], KeyBindType.Press)));
            Config.SubMenu("AutoBushRevealer").AddItem(new MenuItem("AutoBushKey", "Key").SetValue(new KeyBind("Ctrl".ToCharArray()[0], KeyBindType.Press)));

            Config.AddSubMenu(new Menu("Auto Bush Revealer", "AutoBushRevealer"));

            Config.SubMenu("AutoBushRevealer").AddItem(new MenuItem("AutoBushEnabled", "Enabled").SetValue(true));
            Config.AddToMainMenu();

            foreach (var ward in _wards)
            {
                Config.SubMenu("Auto Bush Ward Type").AddItem(new MenuItem("AutoBush" + ward.Key, ward.Value).SetValue(true));
            }
            Game.OnUpdate += Game_OnGameUpdate;
        }
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     FoWSpellEnemyDetector.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("DETECTORS_FOWSPELLENEMY_MAIN"), "SAssembliesDetectorsFoWSpellEnemy"));
     FoWSpellEnemyDetector.MenuItems.Add(
         FoWSpellEnemyDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsFoWSpellEnemyActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(FoWSpellEnemyDetector);
 }
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     CloneTracker.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("TRACKERS_CLONE_MAIN"), "SAssembliesTrackersClone"));
     CloneTracker.MenuItems.Add(
         CloneTracker.Menu.AddItem(new MenuItem("SAssembliesTrackersCloneActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(CloneTracker);
 }
Beispiel #19
0
        static void Game_OnGameLoad(EventArgs args)
        {
            Game.PrintChat("Shoutbox loaded!");
            Config = new LeagueSharp.Common.Menu("Shoutbox", "Shoutbox", true);
            Config.AddToMainMenu();
            Config.AddItem(new LeagueSharp.Common.MenuItem("login", ".login user pw"));
            Config.AddItem(new LeagueSharp.Common.MenuItem("msg", ".sb message"));
            Config.AddItem(new LeagueSharp.Common.MenuItem("user", Shoutbox.account));
            Config.AddItem(new LeagueSharp.Common.MenuItem("pw", Shoutbox.password));

            Config.Item("user").SetValue <StringList>(new StringList(new string[] { Shoutbox.account }));
            StringList us = Config.Item("user").GetValue <StringList>();

            Config.Item("user").SetValue <StringList>(new StringList(new string[] { us.SList[0] }));

            Config.Item("pw").SetValue <StringList>(new StringList(new string[] { Shoutbox.account }));
            StringList pw = Config.Item("pw").GetValue <StringList>();

            Config.Item("pw").SetValue <StringList>(new StringList(new string[] { pw.SList[0] }));

            Shoutbox.account  = us.SList[0];
            Shoutbox.password = pw.SList[0];

            if (Shoutbox.account != "")
            {
                Shoutbox.Process("update msg");
            }
            Game.OnGameInput         += Game_OnGameInput;
            Game.OnGameProcessPacket += Game_OnGameProcessPacket;
        }
Beispiel #20
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu, bool useExisitingMenu = false)
 {
     Language.SetLanguage();
     if (!useExisitingMenu)
     {
         Timers.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("TIMERS_TIMER_MAIN"), "SAssembliesTimers"));
     }
     else
     {
         Timers.Menu = menu;
     }
     Timers.MenuItems.Add(
         Timers.Menu.AddItem(new MenuItem("SAssembliesTimersPingTimes", Language.GetString("GLOBAL_PING_TIMES")).SetValue(new Slider(0, 5, 0))));
     Timers.MenuItems.Add(
         Timers.Menu.AddItem(new MenuItem("SAssembliesTimersRemindTime", Language.GetString("TIMERS_REMIND_TIME")).SetValue(new Slider(0, 50, 0))));
     Timers.MenuItems.Add(
         Timers.Menu.AddItem(new MenuItem("SAssembliesTimersLocalPing", Language.GetString("GLOBAL_PING_LOCAL")).SetValue(true)));
     Timers.MenuItems.Add(
         Timers.Menu.AddItem(new MenuItem("SAssembliesTimersChatChoice", Language.GetString("GLOBAL_CHAT_CHOICE")).SetValue(new StringList(new[]
     {
         Language.GetString("GLOBAL_CHAT_CHOICE_NONE"),
         Language.GetString("GLOBAL_CHAT_CHOICE_LOCAL"),
         Language.GetString("GLOBAL_CHAT_CHOICE_SERVER")
     }))));
     Timers.MenuItems.Add(
         Timers.Menu.AddItem(new MenuItem("SAssembliesTimersNotification", Language.GetString("GLOBAL_NOTIFICATION")).SetValue(false)));
     Timers.MenuItems.Add(
         Timers.Menu.AddItem(new MenuItem("SAssembliesTimersTextScale", Language.GetString("TIMERS_TIMER_SCALE")).SetValue(new Slider(12, 8, 20))));
     if (!useExisitingMenu)
     {
         Timers.MenuItems.Add(Timers.Menu.AddItem(new MenuItem("SAssembliesTimersActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     }
     return(Timers);
 }
Beispiel #21
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     AntiVisualScreenStealthMisc.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("MISCS_ANTIVISUALSCREENSTEALTH_MAIN"), "SAssembliesMiscsAntiVisualScreenStealth"));
     AntiVisualScreenStealthMisc.MenuItems.Add(
         AntiVisualScreenStealthMisc.Menu.AddItem(new MenuItem("SAssembliesMiscsAntiVisualScreenStealthActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(AntiVisualScreenStealthMisc);
 }
Beispiel #22
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     TurnAroundMisc.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("MISCS_TURNAROUND_MAIN"), "SAssembliesMiscsTurnAround"));
     TurnAroundMisc.MenuItems.Add(
         TurnAroundMisc.Menu.AddItem(new MenuItem("SAssembliesMiscsTurnAroundActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(TurnAroundMisc);
 }
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     AutoDervishBladeActivator.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("ACTIVATORS_AUTOITEMS_DEFENSIVE_CLEANSE_DERVISHBLADE_MAIN"), "SAssembliesActivatorsAutoItemsDefensiveCleanseDervishBlade"));
     AutoDervishBladeActivator.MenuItems.Add(
         AutoDervishBladeActivator.Menu.AddItem(new MenuItem("SAssembliesActivatorsAutoItemsDefensiveCleanseDervishBladeActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(AutoDervishBladeActivator);
 }
Beispiel #24
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     HealthTimer.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("TIMERS_HEALTH_MAIN"), "SAssembliesTimersHealth"));
     HealthTimer.MenuItems.Add(
         HealthTimer.Menu.AddItem(new MenuItem("SAssembliesTimersHealthActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(true)));
     return(HealthTimer);
 }
Beispiel #25
0
        public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
        {
            var newMenu = Menu.GetSubMenu(menu, "SAssembliesDetectorsSharedExperience");

            if (newMenu == null)
            {
                SharedExperienceDetector.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("DETECTORS_SHAREDEXPERIENCE_MAIN"), "SAssembliesDetectorsSharedExperience"));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceResetTime", Language.GetString("DETECTORS_SHAREDEXPERIENCE_RESETTIME")).SetValue(new Slider(60, 120, 1)));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceTrackRange", Language.GetString("DETECTORS_SHAREDEXPERIENCE_TRACKRANGE")).SetValue(new Slider(2000, 10000, 100)));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceOnlyInvisible", Language.GetString("DETECTORS_SHAREDEXPERIENCE_ONLYINVISIBLE")).SetValue(true));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperiencePingTimes", Language.GetString("GLOBAL_PING_TIMES")).SetValue(new Slider(0, 5, 0)));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperiencePingType", Language.GetString("GLOBAL_PING_TYPE")).SetValue(new StringList(new[]
                {
                    Language.GetString("GLOBAL_PING_TYPE_NORMAL"),
                    Language.GetString("GLOBAL_PING_TYPE_DANGER"),
                    Language.GetString("GLOBAL_PING_TYPE_ENEMYMISSING"),
                    Language.GetString("GLOBAL_PING_TYPE_ONMYWAY"),
                    Language.GetString("GLOBAL_PING_TYPE_FALLBACK"),
                    Language.GetString("GLOBAL_PING_ASSISTME")
                })));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceLocalPing", Language.GetString("GLOBAL_PING_LOCAL")).SetValue(true));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceChat", Language.GetString("GLOBAL_CHAT")).SetValue(false));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceNotification", Language.GetString("GLOBAL_NOTIFICATION")).SetValue(false));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceVoice", Language.GetString("GLOBAL_VOICE")).SetValue(false));
                SharedExperienceDetector.Menu.AddItem(new MenuItem("SAssembliesDetectorsSharedExperienceDrawing", Language.GetString("GLOBAL_DRAWING")).SetValue(false));
                SharedExperienceDetector.CreateActiveMenuItem("SAssembliesDetectorsSharedExperienceActive", () => new SharedExperience());
            }
            return(SharedExperienceDetector);
        }
Beispiel #26
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     DestinationTracker.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("TRACKERS_DESTINATION_MAIN"), "SAssembliesTrackersDestination"));
     DestinationTracker.MenuItems.Add(
         DestinationTracker.Menu.AddItem(new MenuItem("SAssembliesTrackersDestinationActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(DestinationTracker);
 }
Beispiel #27
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     WaypointTracker.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("TRACKERS_WAYPOINT_MAIN"), "SAssembliesTrackersWaypoint"));
     WaypointTracker.MenuItems.Add(
         WaypointTracker.Menu.AddItem(new MenuItem("SAssembliesTrackersWaypointActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(WaypointTracker);
 }
Beispiel #28
0
        public Menu() : base("Universal MinimapHack", "UniversalMinimapHack", true)
        {
            _slider         = new MenuItem("scale", "Icon Scale % (F5 to Reload)").SetValue(new Slider(20));
            _iconOpacity    = new MenuItem("opacity", "Icon Opacity % (F5 to Reload)").SetValue(new Slider(70));
            _ssTimerEnabler = new MenuItem("enableSS", "Enable").SetValue(true);
            _ssTimerSize    = new MenuItem("sizeSS", "SS Text Size (F5 to Reload)").SetValue(new Slider(15));
            _ssTimerOffset  = new MenuItem("offsetSS", "SS Text Height").SetValue(new Slider(15, -50, +50));
            _ssTimerMin     = new MenuItem("minSS", "Show after X seconds").SetValue(new Slider(30, 1, 180));
            _ssTimerMinPing = new MenuItem("minPingSS", "Ping after X seconds").SetValue(new Slider(30, 5, 180));
            _ssFallbackPing = new MenuItem("fallbackSS", "Fallback ping (local)").SetValue(false);
            AddItem(new MenuItem("", "[Customize]"));
            AddItem(_slider);
            AddItem(_iconOpacity);
            var ssMenu = new LeagueSharp.Common.Menu("SS Timer", "ssTimer");

            ssMenu.AddItem(_ssTimerEnabler);
            ssMenu.AddItem(new MenuItem("1", "--- [Extra] ---"));
            ssMenu.AddItem(_ssTimerMin);
            ssMenu.AddItem(_ssFallbackPing);
            ssMenu.AddItem(_ssTimerMinPing);
            ssMenu.AddItem(new MenuItem("2", "--- [Customize] ---"));
            ssMenu.AddItem(_ssTimerSize);
            ssMenu.AddItem(_ssTimerOffset);
            var ssCircleMenu = new LeagueSharp.Common.Menu("SS Circles", "ccCircles");

            _ssCircle      = new MenuItem("ssCircle", "Enable").SetValue(true);
            _ssCircleSize  = new MenuItem("ssCircleSize", "Max Circle Size").SetValue(new Slider(7000, 500, 15000));
            _ssCircleColor = new MenuItem("ssCircleColor", "Circle color").SetValue(System.Drawing.Color.Green);
            ssCircleMenu.AddItem(_ssCircle);
            ssCircleMenu.AddItem(_ssCircleSize);
            ssCircleMenu.AddItem(_ssCircleColor);
            AddSubMenu(ssMenu);
            AddSubMenu(ssCircleMenu);
            AddToMainMenu();
        }
Beispiel #29
0
        private static void Game_OnGameLoad(EventArgs args)
        {
            if (Player.ChampionName != "Twitch")
                return;

            _w = new Spell(SpellSlot.W, wRange);
            _w.SetSkillshot(0.25f, 120f, 1400f, false, SkillshotType.SkillshotCircle);
            _e = new Spell(SpellSlot.E, eRange);

            _config = new Menu("Twitch", "Twitch", true);

            _orbwalker = new Orbwalking.Orbwalker(_config.SubMenu("Orbwalking"));

            var targetSelectorMenu = new Menu("Target Selector", "Target Selector");
            TargetSelector.AddToMenu(targetSelectorMenu);
            _config.AddSubMenu(targetSelectorMenu);

            _config.SubMenu("Combo").AddItem(new MenuItem("UseWCombo", "Use W").SetValue(true));
            _config.SubMenu("Combo").AddItem(new MenuItem("ghost", "Use Ghostblade").SetValue(true));
            _config.SubMenu("Combo").AddItem(new MenuItem("botrk", "Use Botrk").SetValue(true));

            _config.SubMenu("Drawings").AddItem(new MenuItem("ultDraw", "Draw ult range").SetValue(true));
            _config.SubMenu("Drawings").AddItem(new MenuItem("EDamage", "E Damage").SetValue(new Circle(true, Color.White)));
            _config.SubMenu("Drawings").AddItem(new MenuItem("stealthColor", "Stealth indicator").SetValue(new Circle(true, Color.Purple)));

            _config.AddToMainMenu();

            CustomDamageIndicator.Initialize(GetEDamage);
            Game.OnUpdate += Game_OnUpdate;
            Drawing.OnDraw += Drawing_OnDraw;
            Obj_AI_Base.OnProcessSpellCast += OnSpellProcess;
            Obj_AI_Base.OnDamage += OnDamage;
        }
Beispiel #30
0
        public Evader(out Menu _evade, EvadeMethods method = EvadeMethods.None, Spell spl = null)
        {
            SpecialMethod = method;
            EvadeSpell = spl;
            evade = new Menu("Evade", "Evade");

            foreach (var enemy in HeroManager.Enemies)
            {
                foreach (var spell in SpellDatabase.EvadeableSpells.Where(p => p.ChampionName == enemy.ChampionName && p.EvadeMethods.HasFlag(method)))
                    evade.AddItem(new MenuItem(spell.SpellName, String.Format("{0} ({1})", spell.ChampionName, spell.Slot)).SetValue(true));
            }

            evade.AddItem(new MenuItem("EVADEMETHOD", "Evade Method: ").SetValue(new StringList(new[] { "Near Turret", "Less Enemies", "Auto" }, 2)));
            evade.AddItem(new MenuItem("EVADEENABLE", "Enabled").SetValue(false));

            if (method.HasFlag(EvadeMethods.MorganaE) || method.HasFlag(EvadeMethods.KayleR))
            {
                shieldAlly = new Menu("Ally Shielding", "allyshield");
                foreach (var ally in HeroManager.Allies)
                    if(!ally.IsMe)
                        shieldAlly.AddItem(new MenuItem("shield" + ally.ChampionName, "Shield " + ally.ChampionName).SetValue(true));

                shieldAlly.AddItem(new MenuItem("SHIELDENABLED", "Enabled").SetValue(true));
                evade.AddSubMenu(shieldAlly);
            }

            _evade = evade;
            m_evade_thread = new Thread(new ThreadStart(EvadeThread));
            m_evade_thread.Start();
            Game.OnUpdate += Game_OnUpdate;
            Obj_AI_Base.OnProcessSpellCast += Obj_AI_Base_OnProcessSpellCast;

            Game.PrintChat("<font color='#ff3232'>Shine#: </font><font color='#d4d4d4'>Evader loaded for champion {0} !</font>", ObjectManager.Player.ChampionName);
        }
        private static void SetupMainMenu()
        {
            var menu = new LeagueSharp.Common.Menu("SAutoShield", "SAssembliesSActivatorsAutoShield", true);

            SetupMenu(menu);
            menu.AddToMainMenu();
        }
Beispiel #32
0
 public void loadMisc()
 {
     _miscMenu = new LeagueSharp.Common.Menu("Misc", "Misc");
     {
         _miscMenu.AddItem(new MenuItem("%R", "% R heal ").SetValue(new Slider(30, 0, 100)));
     }
 }
Beispiel #33
0
        public static void Initialize()
        {
            #region Initialize Menu
            Config = new Menu("SPredictioner", "spredictioner", true);
            TargetSelector.AddToMenu(Config.SubMenu("Target Selector"));
            Config.AddItem(new MenuItem("COMBOKEY", "Combo").SetValue(new KeyBind(32, KeyBindType.Press)));
            Config.AddItem(new MenuItem("HARASSKEY", "Harass").SetValue(new KeyBind('C', KeyBindType.Press)));
            Config.AddItem(new MenuItem("ENABLED", "Enabled").SetValue(true));
            SPrediction.Prediction.Initialize(Config);
            Config.SubMenu("SPRED").AddItem(new MenuItem("SPREDHITC", "Hit Chance").SetValue(new StringList(ShineCommon.Utility.HitchanceNameArray, 2)));
            Config.AddToMainMenu();
            #endregion

            #region Initialize Events
            Spellbook.OnCastSpell += EventHandlers.Spellbook_OnCastSpell;
            Obj_AI_Hero.OnProcessSpellCast += EventHandlers.Obj_AI_Hero_OnProcessSpellCast;
            #endregion

            #region Initialize Spells
            foreach (var spell in SpellDatabase.Spells)
            {
                if (spell.ChampionName == ObjectManager.Player.CharData.BaseSkinName)
                {
                    Spells[(int)spell.Slot] = new Spell(spell.Slot, spell.Range);
                    Spells[(int)spell.Slot].SetSkillshot(spell.Delay / 1000, spell.Radius, spell.MissileSpeed, spell.Collisionable, spell.Type);
                }
            }
            #endregion
        }
Beispiel #34
0
        public static void Load()
        {
            ks = Menu.AddSubMenu("KillSteal", "KillSteal");
            ks.Add("SpellsKS", new CheckBox("KS Spells"));
            ks.Add("ComboSmite", new CheckBox("Smite"));
            ks.Add("ComboIgnite", new CheckBox("Ignite"));

            jngl = Menu.AddSubMenu("Jungle", "Jungle");
            jngl.Add("jnglQ", new Slider("Use Javelin Mana %", 15, 0, 100));
            jngl.Add("jnglHeal", new Slider("Auto Heal", 15, 0, 95));

            heal = Menu.AddSubMenu("Heal", "Heal Manager");
            heal.Add("allyHeal", new Slider("Heal Allies Hp <= %", 45, 0, 80));
            heal.Add("SelfHeal", new Slider("Self Heal Hp <= %", 80, 0, 90));
            heal.Add("ManaHeal", new Slider("Mana <= %", 20, 0, 100));

            misc = Menu.AddSubMenu("Misc", "Misc");
            misc.Add("Gapcloser", new CheckBox("Gapcloser"));
            misc.Add("manaW", new Slider("Use W Mana %", 15, 0, 100));

            draw = Menu.AddSubMenu("Draw", "Draw");
            draw.Add("dind", new CheckBox("Draw damage indicator"));
            draw.Add("EngageDraw", new CheckBox("Engage Range"));
            draw.Add("fleeDraw", new CheckBox("Draw Flee Spots"));

            flee = Menu.AddSubMenu("Flee", "Flee");
            flee.Add("FleeMouse", new KeyBind("Flee (BETA)", false, KeyBind.BindTypes.HoldActive, 'A'));
        }
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     AutoShieldActivator.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("ACTIVATORS_AUTOSHIELD_MAIN"), "SAssembliesActivatorsAutoShield"));
     AutoShieldActivator.MenuItems.Add(
         AutoShieldActivator.Menu.AddItem(
             new MenuItem("SAssembliesActivatorsAutoShieldBlockAA", Language.GetString("ACTIVATORS_AUTOSHIELD_BLOCK_AA")).SetValue(false)));
     AutoShieldActivator.MenuItems.Add(
         AutoShieldActivator.Menu.AddItem(new MenuItem("SAssembliesActivatorsAutoShieldBlockCC", Language.GetString("ACTIVATORS_AUTOSHIELD_BLOCK_CC")).SetValue(false)));
     AutoShieldActivator.MenuItems.Add(
         AutoShieldActivator.Menu.AddItem(
             new MenuItem("SAssembliesActivatorsAutoShieldBlockDamageAmount", Language.GetString("ACTIVATORS_AUTOSHIELD_BLOCK_DMG")).SetValue(
                 new StringList(new[] { "Medium", "High", "Extreme" }))));
     AutoShieldActivator.MenuItems.Add(
         AutoShieldActivator.Menu.AddItem(
             new MenuItem("SAssembliesActivatorsAutoShieldBlockMinDamageAmount", Language.GetString("ACTIVATORS_AUTOSHIELD_BLOCK_DMG_MIN")).SetValue(
                 new Slider(50, 2000, 1))));
     AutoShieldActivator.MenuItems.Add(
         AutoShieldActivator.Menu.AddItem(new MenuItem("SAssembliesActivatorsAutoShieldBlockableSpellsActive", Language.GetString("ACTIVATORS_AUTOSHIELD_BLOCK_SPECIFIC_SPELL")).SetValue(false)));
     AutoShieldActivatorBlockableSpells.Menu =
         AutoShieldActivator.Menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("ACTIVATORS_AUTOSHIELD_BLOCK_BLOCKABLE_SPELL"),
                                                                         "SAssembliesActivatorsAutoShieldBlockableSpells"));
     foreach (var spell in AutoShield.GetBlockableSpells())
     {
         AutoShieldActivatorBlockableSpells.MenuItems.Add(
             AutoShieldActivatorBlockableSpells.Menu.AddItem(new MenuItem("SAssembliesActivatorsAutoShieldBlockableSpells" + spell, spell).SetValue(false)));
     }
     AutoShieldActivator.MenuItems.Add(
         AutoShieldActivator.Menu.AddItem(new MenuItem("SAssembliesActivatorsAutoShieldAlly", Language.GetString("ACTIVATORS_AUTOSHIELD_ALLY")).SetValue(false)));
     AutoShieldActivator.MenuItems.Add(
         AutoShieldActivator.Menu.AddItem(new MenuItem("SAssembliesActivatorsAutoShieldActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(AutoShieldActivator);
 }
Beispiel #36
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     SurrenderVoteMisc.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("MISCS_SURRENDERVOTE_MAIN"), "SAssembliesMiscsSurrenderVote"));
     SurrenderVoteMisc.MenuItems.Add(
         SurrenderVoteMisc.Menu.AddItem(new MenuItem("SAssembliesMiscsSurrenderVoteActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(SurrenderVoteMisc);
 }
Beispiel #37
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     RealTimeMisc.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("MISCS_REALTIME_MAIN"), "SAssembliesMiscsRealTime"));
     RealTimeMisc.MenuItems.Add(
         RealTimeMisc.Menu.AddItem(new MenuItem("SAssembliesMiscsRealTimeActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(RealTimeMisc);
 }
Beispiel #38
0
        private Obj_AI_Minion Get_Nearest_orb()
        {
            var Orb =
                ObjectManager.Get <Obj_AI_Minion>()
                .Where(obj => obj.IsValid && obj.Team == ObjectManager.Player.Team && obj.Name == "Seed")
                .ToList()
                .OrderBy(x => MyHero.Distance(x))
                .FirstOrDefault();

            if (Orb != null)
            {
                return(Orb);
            }

            if (!Menu.Item("W_Only_Orb").GetValue <bool>())
            {
                var minion = ObjectManager.Get <Obj_AI_Minion>().FirstOrDefault(x => x.IsValidTarget(W.Range));

                if (minion != null)
                {
                    return(minion);
                }
            }
            return(null);
        }
Beispiel #39
0
 public override void ComboMenu(Menu config)
 {
     config.AddBool("Combo.Q", "Use Q", true);
     config.AddBool("Combo.W", "Use W", true);
     config.AddBool("Combo.R", "Use R", true);
     config.AddSlider("Combo.R.Health", "Health to Ult", 15, 1, 100);
 }
Beispiel #40
0
        public static void BuildMenu(LeagueSharp.Common.Menu mainMenu, string displayName, string name)
        {
            var GPMenu = new LeagueSharp.Common.Menu(displayName, name);

            {
                var enemyHeroesNames = ObjectManager.Get <Obj_AI_Hero>().Where(h => h.IsEnemy).Select(hero => hero.ChampionName).ToList();

                foreach (var champ in enemyHeroesNames)
                {
                    if (Spells.All(h => h.ChampionName != champ))
                    {
                        continue;
                    }

                    var ChampMenu = new LeagueSharp.Common.Menu(champ, $"{name}.{champ.ToLowerInvariant()}");
                    GPMenu.AddSubMenu(ChampMenu);
                }

                foreach (var gp in Spells.Where(h => enemyHeroesNames.Contains(h.ChampionName)))
                {
                    var myMenu = GPMenu.SubMenu($"{name}.{gp.ChampionName.ToLowerInvariant()}");

                    myMenu.AddItem(new MenuItem(
                                       $"{name}.{gp.ChampionName.ToLowerInvariant()}.{gp.SpellName}",
                                       gp.ChampionName + " " + gp.Slot + " (" + gp.SpellName + ")").SetValue(true));
                }
            }
            GapMenu    = GPMenu;
            GPMenuName = name;

            mainMenu.AddSubMenu(GPMenu);
        }
Beispiel #41
0
        private static void Game_OnGameLoad(EventArgs args)
        {
            Config = new Menu("SkinHack", "SkinHack", true);

            var settings = Config.AddSubMenu(new Menu("Settings", "Settings"));
            settings.AddItem(new MenuItem("Champions", "Reskin Champions").SetValue(true));
            //settings.AddItem(new MenuItem("Pets", "Reskin Pets").SetValue(true));
            settings.AddItem(new MenuItem("Minions", "Pool Party Minions").SetValue(false));

            foreach (var hero in ObjectManager.Get<Obj_AI_Hero>())
            {
                var champMenu = new Menu(hero.ChampionName, hero.ChampionName);
                var modelUnit = new ModelUnit(hero);

                PlayerList.Add(modelUnit);

                if (hero.IsMe)
                {
                    Player = modelUnit;
                }

                foreach (Dictionary<string, object> skin in ModelManager.GetSkins(hero.ChampionName))
                {
                    Console.WriteLine(skin["name"].ToString());
                    var skinName = skin["name"].ToString().Equals("default")
                        ? hero.ChampionName
                        : skin["name"].ToString();
                    var skinId = (int) skin["num"];

                    var changeSkin = champMenu.AddItem(new MenuItem(skinName, skinName).SetValue(false));

                    if (hero.BaseSkinId.Equals(skinId) || changeSkin.IsActive())
                    {
                        changeSkin.SetValue(true);
                        modelUnit.SetModel(hero.CharData.BaseSkinName, skinId);
                    }

                    var hero1 = hero;
                    changeSkin.ValueChanged += (s, e) =>
                    {
                        if (e.GetNewValue<bool>())
                        {
                            champMenu.Items.ForEach(
                                p =>
                                {
                                    if (p.GetValue<bool>() && p.Name != skinName)
                                    {
                                        p.SetValue(false);
                                    }
                                });
                            modelUnit.SetModel(hero1.ChampionName, skinId);
                        }
                    };
                }
                Config.AddSubMenu(champMenu);
            }
            Config.AddToMainMenu();

            Game.OnInput += Game_OnInput;
        }
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     VisionRange.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("RANGES_VISION_MAIN"), "SAwarenessRangesVision"));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionMode", Language.GetString("RANGES_ALL_MODE")).SetValue(new StringList(new[]
     {
         Language.GetString("RANGES_ALL_MODE_ME"),
         Language.GetString("RANGES_ALL_MODE_ENEMY"),
         Language.GetString("RANGES_ALL_MODE_BOTH")
     }))));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionDisplayMe", Language.GetString("RANGES_VISION_ME")).SetValue(false)));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionDisplayChampion", Language.GetString("RANGES_VISION_CHAMPION")).SetValue(false)));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionDisplayTurret", Language.GetString("RANGES_VISION_TURRET")).SetValue(false)));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionDisplayMinion", Language.GetString("RANGES_VISION_MINION")).SetValue(false)));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionDisplayWard", Language.GetString("RANGES_VISION_WARD")).SetValue(false)));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionColorMe", Language.GetString("RANGES_ALL_COLORME")).SetValue(Color.Indigo)));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionColorEnemy", Language.GetString("RANGES_ALL_COLORENEMY")).SetValue(Color.Indigo)));
     VisionRange.MenuItems.Add(
         VisionRange.Menu.AddItem(new MenuItem("SAwarenessRangesVisionActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(VisionRange);
 }
Beispiel #43
0
        private static void ZiggsMain(EventArgs args)
        {
            Player = ObjectManager.Player;

            if (Player.CharData.BaseSkinName != "Ziggs")
            {
                return;
            }

            Config = ZiggsMenu.CreateMenu();

            Config.AddToMainMenu();

            InitializeSpells();

            ObjectHandling(); 

            AntiGapcloser.OnEnemyGapcloser += OnGapClose;

            Interrupter2.OnInterruptableTarget += OnInterruptableTarget;

            Game.OnUpdate += OnUpdate;
            Game.OnUpdate += AutoSpells;
            
            Drawing.OnDraw += OnDraw;
        }
Beispiel #44
0
 public virtual void LoadMenu(AzirMain azir)
 {
     GetMenu             = new LeagueSharp.Common.Menu(_menuName, _menuName, true);
     _orbWalkerMenu      = new LeagueSharp.Common.Menu("Orbwalker", "Orbwalker");
     Orb                 = new AzirWalker(_orbWalkerMenu, azir);
     _targetSelectorMenu = new LeagueSharp.Common.Menu("TargetSelector", "TargetSelector");
 }
        private static Menu _Menu()
        {
            var menu = new Menu(_MenuNameBase, "rendMenu");

            var subMenu = new Menu(".Kill","autoRendMenu");
            subMenu.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendNonKillables", "Rend NonKillables").SetValue(true));
            subMenu.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendEpics", "Rend epic monsters").SetValue(true));
            subMenu.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendBuffs", "Rend large buff monsters").SetValue(true));
            subMenu.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendSmallMonster", "Rend small monsters").SetValue(true));
            subMenu.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendEpicMinions", "Rend epic minions(Seige,Super)").SetValue(true));
            subMenu.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendEnemyChampions", "Rend enemies").SetValue(true));

            var subMenu2 = new Menu(".Cases", "caseRendMenu");

            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendMinions", "Rend minions").SetValue(true));
            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendMinions.Slider.Killed", "Required minions killed").SetValue(new Slider(1, 2, 10)));

            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendHarrassKill", "Rend harass (kills minion + stack on enemy)").SetValue(true));
            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendHarrassKill.Slider.Stacks", "Required stacks on enemy").SetValue(new Slider(1, 1, 5)));
            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendHarrassKill.Slider.Killed", "Required minions killed").SetValue(new Slider(2, 2, 10)));

            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendBeforeDeath", "Rend before death").SetValue(false));
            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendBeforeDeath.Slider.Enemies", "Required enimies with stacks").SetValue(new Slider(1, 1, 5)));
            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendBeforeDeath.Slider.Stacks", "Required stacks on enimies").SetValue(new Slider(1, 1, 5)));
            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendBeforeDeath.Slider.PercentHP", "Required remaining HP%(Player)").SetValue(new Slider(15, 1, 40)));

            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendOnLeave", "Rend on leave").SetValue(false));
            subMenu2.AddItem(new MenuItem(_MenuItemBase + "Boolean.RendOnLeave.Slider.Stacks", "Required stacks").SetValue(new Slider(4, 1, 10)));

            menu.AddSubMenu(subMenu);
            menu.AddSubMenu(subMenu2);

            return menu;
        }
Beispiel #46
0
        private void CreateMenu()
        {
            try
            {
                bool newMenu = false;
                LeagueSharp.Common.Menu menu;
                if (Menu.GetMenu("SAssembliesRoot") == null)
                {
                    menu    = new LeagueSharp.Common.Menu("SAssemblies", "SAssembliesRoot", true);
                    newMenu = true;
                }
                else
                {
                    menu = Menu.GetMenu("SAssembliesRoot");
                }

                MainMenu.Champion = Champion.SetupMenu(menu);
                mainMenu.UpdateDirEntry(ref MainMenu.TahmKench, TahmKench.SetupMenu(MainMenu.Champion.Menu));

                if (newMenu)
                {
                    menu.AddItem(new MenuItem("By Screeder", "By Screeder V" + Assembly.GetExecutingAssembly().GetName().Version));
                    menu.AddToMainMenu();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("SAssemblies: {0}", ex);
                throw;
            }
        }
Beispiel #47
0
        private static Menu DrawingMenu()
        {
            var drawMenu = new Menu("Drawing Settings", "Drawings");
            drawMenu
                .AddItem(
                    new MenuItem("drawoptions", "Drawing Mode Mode").SetValue(
                        new StringList(new[] { "Normal Mode", "Colorblind Mode" })));
            drawMenu.SubMenu("Drawings").AddItem(new MenuItem("Draw", "Display Drawings").SetValue(true));
            drawMenu.SubMenu("Drawings").AddItem(new MenuItem("qDraw", "Draw Q").SetValue(true));
            drawMenu.SubMenu("Drawings").AddItem(new MenuItem("eDraw", "Draw E").SetValue(true));
            drawMenu.SubMenu("Drawings").AddItem(new MenuItem("wDraw", "Draw W").SetValue(true));
            drawMenu.SubMenu("Drawings").AddItem(new MenuItem("stackDraw", "Stack Count").SetValue(true));
            drawMenu.SubMenu("Drawings").AddItem(new MenuItem("notdraw", "Draw Floating Text").SetValue(true));
            drawMenu.SubMenu("Drawings").AddItem(new MenuItem("keyBindDisplay", "Display Keybinds").SetValue(true));  

            var drawDamageMenu = new MenuItem("RushDrawEDamage", "Combo Damage").SetValue(true);
            var drawFill =
                new MenuItem("RushDrawWDamageFill", "Draw Damage Fill").SetValue(new Circle(true, Color.SeaGreen));
            drawMenu.SubMenu("Drawings").AddItem(drawDamageMenu);
            drawMenu.SubMenu("Drawings").AddItem(drawFill);

            //GlobalManager.EnableDrawingDamage = drawDamageMenu.GetValue<bool>();
            //GlobalManager.EnableFillDamage = drawFill.GetValue<Circle>().Active;
            //GlobalManager.DamageFillColor = drawFill.GetValue<Circle>().Color;

            return drawMenu;
        }
Beispiel #48
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     MinionLocationMisc.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("MISCS_MINIONLOCATION_MAIN"), "SAssembliesMiscsMinionLocation"));
     MinionLocationMisc.MenuItems.Add(
         MinionLocationMisc.Menu.AddItem(new MenuItem("SAssembliesMiscsMinionLocationActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(MinionLocationMisc);
 }
Beispiel #49
0
        public static void OnGameLoad(EventArgs args)
        {
            Menu = new Menu("Disrespect#", "masteryemotespammermenu", true);
            Menu.AddItem(new MenuItem("mode", "[ Respect ]").SetValue(new StringList(new[] { "MASTERY", "HARD FLAME" })));
            Menu.AddItem(new MenuItem("chatdisrespectmode", "[ Type ]").SetValue(new StringList(new[] { "DISABLED", "CHAMPION NAME", "SUMMONER NAME" })));
            Menu.AddItem(new MenuItem("onkill", "[ Mes Kills ]").SetValue(true));
            Menu.AddItem(new MenuItem("onassist", "[ Mes Assistances ]").SetValue(true));
            Menu.AddItem(new MenuItem("ondeath", "[ Mes Morts ]").SetValue(false));
            Menu.AddItem(new MenuItem("neardead", "[ Morts ]").SetValue(true));
            Menu.AddItem(new MenuItem("ondodgedskillshot", "[ Esquive ]").SetValue(true));
            Menu.AddItem(new MenuItem("afterignite", "[ Ignite ]").SetValue(true));
            Menu.AddItem(new MenuItem("afterflash", "[ Flash ]").SetValue(false));
            Menu.AddItem(new MenuItem("afterq", "[ A ]").SetValue(false));
            Menu.AddItem(new MenuItem("afterw", "[ Z ]").SetValue(false));
            Menu.AddItem(new MenuItem("aftere", "[ E ]").SetValue(false));
            Menu.AddItem(new MenuItem("afterr", "[ R ]").SetValue(false));
            Menu.AddToMainMenu();
            Random = new Random();
            FlashSlot = ObjectManager.Player.GetSpellSlot("SummonerFlash");
            IgniteSlot = ObjectManager.Player.GetSpellSlot("SummonerDot");
            Game.OnUpdate += OnUpdate;
            Obj_AI_Base.OnProcessSpellCast += OnProcessSpellCast;

            //init chat disrespekter
            foreach (var en in ObjectManager.Get<Obj_AI_Hero>().Where(h => h.IsEnemy))
            {
                DeathsHistory.Add(en.NetworkId, en.Deaths);
            }
        }
Beispiel #50
0
        private static void SetupMainMenu()
        {
            var menu = new LeagueSharp.Common.Menu("SChampions", "SAssembliesSChampions", true);

            SetupMenu(menu);
            menu.AddToMainMenu();
        }
Beispiel #51
0
        /// <summary>
        ///     메인메뉴를 만들고 root메뉴에 추가합니다.
        /// </summary>
        internal static void Initialize()
        {
            if (PluginLoader.CanLoadPlugin(ObjectManager.Player.ChampionName))
            {
                MenuInstance = new Menu("#Shooter Reworked: OK", "SharpShooterCommon", true);

                AddSubMenu("Champion", ObjectManager.Player.ChampionName);

                Champion.AddOrbwalker();
                Champion.AddTargetSelector();
            }
            else
            {
                MenuInstance = new Menu("#Shooter Reworked: X", "SharpShooterCommon", true);

                AddItem("txt1", "Sorry. " + ObjectManager.Player.ChampionName + " is not supported yet.", null);
                Game.PrintChat(
                    "<font color = \"#00D8FF\"><b>SharpShooter Reworked:</b></font> <font color = \"#FF007F\">" +
                    ObjectManager.Player.ChampionName + "</font> is not supported yet.");
            }

            MenuInstance.AddToMainMenu();

            Console.WriteLine("SharpShooter: MenuProvider Initialized.");
        }
Beispiel #52
0
        public override void OnPassive()
        {
            if (Menu.Item("Q_Auto_Harass").GetValue <KeyBind>().Active)
            {
                Cast_Q();
            }

            if (Menu.Item("Misc_QE_Mouse").GetValue <KeyBind>().Active)
            {
                var vec = MyHero.ServerPosition + Vector3.Normalize(Game.CursorPos - MyHero.ServerPosition) * (E.Range - 50);
                _qe.Cast(vec, UsePackets());
                _qe.LastCastAttemptT = Environment.TickCount;
            }

            var qTarget = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Magical);

            if (!Menu.Item("Q_Auto_Immobile").GetValue <bool>() || qTarget == null)
            {
                return;
            }
            if (Q.GetPrediction(qTarget).Hitchance == HitChance.Immobile)
            {
                Q.Cast(qTarget);
            }
        }
Beispiel #53
0
        public Khazix()
        {
            if (ObjectManager.Player.ChampionName != "Khazix")
            {
                return;
            }

            Init();
            GenerateMenu();
            Game.OnUpdate += OnUpdate;
            Game.OnUpdate += DoubleJump;
            Drawing.OnDraw += OnDraw;
            Spellbook.OnCastSpell += SpellCast;
            Orbwalker.OnPreAttack += BeforeAttack;

            menu = KhazixMenu.menu;
            harass = KhazixMenu.harass;
            combo = KhazixMenu.combo;
            farm = KhazixMenu.farm;
            ks = KhazixMenu.ks;
            safety = KhazixMenu.safety;
            djump = KhazixMenu.djump;
            draw = KhazixMenu.draw;
            debug = KhazixMenu.debug;
        }
Beispiel #54
0
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     InhibitorHealth.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("HEALTHS_INHIBITOR_MAIN"), "SAssembliesHealthsInhibitor"));
     InhibitorHealth.MenuItems.Add(
         InhibitorHealth.Menu.AddItem(new MenuItem("SAssembliesHealthsInhibitorActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(InhibitorHealth);
 }
        public static void AddToMenu(Menu menu, string uniqueId, Dictionary<string, HitChance> hitChances)
        {
            try
            {
                if (Menues.ContainsKey(uniqueId))
                {
                    throw new ArgumentException(
                        string.Format("HitchanceManager: UniqueID \"{0}\" already exist.", uniqueId));
                }

                var flashMenu = menu.AddSubMenu(new Menu("Flash", menu.Name + ".flash"));
                flashMenu.AddItem(new MenuItem(menu.Name + ".enabled", "Reduce Hitchance").SetValue(true));
                flashMenu.AddItem(new MenuItem(menu.Name + ".amount", "Amount").SetValue(new Slider(1, 0, 3)));
                flashMenu.AddItem(new MenuItem(menu.Name + ".time", "Seconds").SetValue(new Slider(3, 1, 10)));

                foreach (var hit in hitChances)
                {
                    menu.AddItem(
                        new MenuItem(menu.Name + "." + hit.Key.ToLower(), hit.Key.ToUpper()).SetValue(
                            new StringList(
                                new[] { "Medium", "High", "Very High" },
                                hit.Value == HitChance.Medium ? 0 : (hit.Value == HitChance.High ? 1 : 2))));
                }

                Menues[uniqueId] = menu;

                Obj_AI_Base.OnProcessSpellCast += OnObjAiBaseProcessSpellCast;
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
 public static Menu.MenuItemSettings SetupMenu(LeagueSharp.Common.Menu menu)
 {
     EasyRangedJungleMisc.Menu = menu.AddSubMenu(new LeagueSharp.Common.Menu(Language.GetString("MISCS_EASYRANGEDJUNGLE_MAIN"), "SAssembliesMiscsEasyRangedJungle"));
     EasyRangedJungleMisc.MenuItems.Add(
         EasyRangedJungleMisc.Menu.AddItem(new MenuItem("SAssembliesMiscsEasyRangedJungleActive", Language.GetString("GLOBAL_ACTIVE")).SetValue(false)));
     return(EasyRangedJungleMisc);
 }
Beispiel #57
0
        private static void Game_OnGameLoad(EventArgs args)
        {
            var spell = ObjectManager.Player.GetSpellSlot("summonersnowball");

            if (spell == SpellSlot.Unknown)
            {
                return;
            }


            Menu = new Menu("ARAMShooter", "ARAMShooter", true);
            Menu.AddItem(new MenuItem("DecreaseRange", "Decrease Range by").SetValue(new Slider(10)));
            Menu.AddItem(
                new MenuItem("HitChance", "MinHitChance").SetValue(
                    new StringList(
                        new[] { HitChance.Low.ToString(), HitChance.Medium.ToString(), HitChance.High.ToString() }, 1)));
            Menu.AddItem(new MenuItem("Auto", "AutoDash").SetValue(true));
            Menu.AddItem(new MenuItem("AutoThrow", "AutoThrow").SetValue(false));
            Menu.AddItem(new MenuItem("Throw", "Throw").SetValue(new KeyBind("T".ToCharArray()[0], KeyBindType.Press)));
            var dontThrow = new Menu("Don't throw at", "DontThrow");
            foreach (var hero in ObjectManager.Get<Obj_AI_Hero>().Where(hero => hero.IsEnemy))
            {
                dontThrow.AddItem(new MenuItem("DontThrow" + hero.SkinName, hero.SkinName)).SetValue(false);
            }
            Menu.AddSubMenu(dontThrow);
            Menu.Item("HitChance").ValueChanged += Program_ValueChanged;
            Menu.Item("DecreaseRange").ValueChanged += Program_ValueChanged1;
            Menu.AddToMainMenu();

            Throw = new Spell(spell, 2500f);
            Throw.SetSkillshot(.33f, 50f, 1600, true, SkillshotType.SkillshotLine);
            Throw.MinHitChance = GetHitChance();

            Game.OnUpdate += Game_OnUpdate;
        }
        public static void AddToMenu(Menu menu, bool ally, bool enemy)
        {
            try
            {
                _menu = menu;

                foreach (var hero in GameObjects.Heroes.Where(h => (ally && h.IsAlly || enemy && h.IsEnemy) && !h.IsMe))
                {
                    var spells =
                        SpellSlots.Select(slot => hero.GetSpell(slot))
                            .Where(spell => spell != null && !spell.SData.IsAutoAttack())
                            .Where(
                                spell =>
                                    spell.SData.TargettingType == SpellDataTargetType.Unit ||
                                    spell.SData.TargettingType == SpellDataTargetType.SelfAoe)
                            .ToList();
                    if (spells.Any())
                    {
                        var heroMenu = menu.AddSubMenu(new Menu(hero.ChampionName, menu.Name + "." + hero.ChampionName));
                        foreach (var spell in spells)
                        {
                            heroMenu.AddItem(
                                new MenuItem(heroMenu.Name + "." + spell.SData.Name, spell.Slot.ToString().ToUpper()))
                                .SetValue(true);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
Beispiel #59
0
 public override void ComboMenu(Menu config)
 {
     config.AddBool("ComboQ", "Use Q", true);
     config.AddBool("ComboW", "Use W", true);
     config.AddBool("ComboE", "Use E", true);
     config.AddBool("ComboR", "Use R1", true);
 }
        private static void SetupMainMenu()
        {
            var menu = new LeagueSharp.Common.Menu("SAssembliesWardCorrector", "SAssembliesWardsWardCorrector", true);

            SetupMenu(menu);
            menu.AddToMainMenu();
        }