Esempio n. 1
0
        public static void AddToMenu(Menu menu, HeroListManagerArgs args, bool dangerous = false)
        {
            try
            {
                if (Menues.ContainsKey(args.UniqueId))
                {
                    throw new ArgumentException(
                              string.Format("GapcloserManager: UniqueID \"{0}\" already exist.", args.UniqueId));
                }

                args.Enemies = true;
                args.Allies  = false;

                menu.AddItem(
                    new MenuItem(menu.Name + ".gap-" + args.UniqueId + ".delay", "Delay").SetValue(
                        new Slider(100, 0, 500)));
                menu.AddItem(
                    new MenuItem(menu.Name + ".gap-" + args.UniqueId + ".distance", "Min. Distance").SetValue(
                        new Slider(150, 0, 500)));
                menu.AddItem(
                    new MenuItem(menu.Name + ".gap-" + args.UniqueId + ".dangerous", "Only Dangerous").SetValue(
                        dangerous));

                menu.AddItem(new MenuItem(menu.Name + ".gap-" + args.UniqueId + ".separator", string.Empty));

                HeroListManager.AddToMenu(menu, args);

                Menues[args.UniqueId] = menu;
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
Esempio n. 2
0
        public static void AddToMenu(Menu menu, List <BuffType> buffTypes, HeroListManagerArgs args, bool randomize)
        {
            try
            {
                if (Menues.ContainsKey(args.UniqueId))
                {
                    throw new ArgumentException(
                              string.Format("BuffManager: UniqueID \"{0}\" already exist.", args.UniqueId));
                }

                args.Enemies = true;
                args.Allies  = false;

                menu.AddItem(
                    new MenuItem(menu.Name + ".buff-" + args.UniqueId + ".delay", "Delay").SetValue(
                        new Slider(100, 0, 500)));
                if (randomize)
                {
                    menu.AddItem(
                        new MenuItem(menu.Name + ".buff-" + args.UniqueId + ".randomize", "Randomize Position").SetValue
                            (new Slider(10)));
                }

                menu.AddItem(new MenuItem(menu.Name + ".buff-" + args.UniqueId + ".separator", string.Empty));

                HeroListManager.AddToMenu(menu, args);

                Menues[args.UniqueId] = new Tuple <Menu, List <BuffType>, bool>(menu, buffTypes, randomize);
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
Esempio n. 3
0
        public static Menu AddToMenu(Menu menu,
                                     bool auto,
                                     bool autoInterrupt,
                                     bool interruptDelay,
                                     bool autoGapcloser,
                                     bool gapcloserDelay,
                                     bool flash,
                                     bool assisted,
                                     bool required,
                                     bool force)
        {
            try
            {
                _auto      = auto;
                _interrupt = autoInterrupt;
                _gapcloser = autoGapcloser;
                _flash     = flash;
                _assisted  = assisted;
                _required  = required;
                _force     = force;
                _menu      = menu;

                var ultimateMenu = menu.AddSubMenu(new Menu(Global.Lang.Get("F_Ultimate"), menu.Name + ".ultimate"));

                var uComboMenu =
                    ultimateMenu.AddSubMenu(new Menu(Global.Lang.Get("G_Combo"), ultimateMenu.Name + ".combo"));
                uComboMenu.AddItem(
                    new MenuItem(uComboMenu.Name + ".min", "R " + Global.Lang.Get("G_Min")).SetValue(
                        new Slider(2, 1, 5)));
                uComboMenu.AddItem(new MenuItem(uComboMenu.Name + ".duel", Global.Lang.Get("UM_Duel")).SetValue(true));
                uComboMenu.AddItem(
                    new MenuItem(uComboMenu.Name + ".enabled", Global.Lang.Get("G_Enabled")).SetValue(true));

                if (auto)
                {
                    var uAutoMenu =
                        ultimateMenu.AddSubMenu(new Menu(Global.Lang.Get("UM_Auto"), ultimateMenu.Name + ".auto"));
                    if (autoInterrupt)
                    {
                        var autoInterruptMenu =
                            uAutoMenu.AddSubMenu(
                                new Menu(Global.Lang.Get("G_InterruptSpell"), uAutoMenu.Name + ".interrupt"));
                        if (interruptDelay)
                        {
                            DelayManager.AddToMenu(
                                autoInterruptMenu, "ultimate-interrupt-delay", string.Empty, 250, 0, 1000);
                        }
                        HeroListManager.AddToMenu(autoInterruptMenu, "ultimate-interrupt", false, false, true, false);
                    }
                    if (autoGapcloser)
                    {
                        var autoGapcloserMenu =
                            uAutoMenu.AddSubMenu(
                                new Menu(Global.Lang.Get("G_Gapcloser"), uAutoMenu.Name + ".gapcloser"));
                        if (gapcloserDelay)
                        {
                            DelayManager.AddToMenu(
                                autoGapcloserMenu, "ultimate-gapcloser-delay", string.Empty, 250, 0, 1000);
                        }
                        HeroListManager.AddToMenu(autoGapcloserMenu, "ultimate-gapcloser", false, false, true, false);
                    }
                    uAutoMenu.AddItem(
                        new MenuItem(uAutoMenu.Name + ".min", "R " + Global.Lang.Get("G_Min")).SetValue(
                            new Slider(3, 1, 5)));
                    uAutoMenu.AddItem(
                        new MenuItem(uAutoMenu.Name + ".duel", Global.Lang.Get("UM_Duel")).SetValue(false));
                    uAutoMenu.AddItem(
                        new MenuItem(uAutoMenu.Name + ".enabled", Global.Lang.Get("G_Enabled")).SetValue(true));
                }

                if (flash)
                {
                    var uFlashMenu =
                        ultimateMenu.AddSubMenu(new Menu(Global.Lang.Get("G_Flash"), ultimateMenu.Name + ".flash"));
                    uFlashMenu.AddItem(
                        new MenuItem(uFlashMenu.Name + ".min", "R " + Global.Lang.Get("G_Min")).SetValue(
                            new Slider(3, 1, 5)));
                    uFlashMenu.AddItem(
                        new MenuItem(uFlashMenu.Name + ".duel", Global.Lang.Get("UM_Duel")).SetValue(true));
                    uFlashMenu.AddItem(
                        new MenuItem(uFlashMenu.Name + ".hotkey", Global.Lang.Get("G_Hotkey")).SetValue(
                            new KeyBind('U', KeyBindType.Press)));
                    uFlashMenu.AddItem(
                        new MenuItem(uFlashMenu.Name + ".move-cursor", Global.Lang.Get("UM_MoveCursor")).SetValue(true));
                    uFlashMenu.AddItem(
                        new MenuItem(uFlashMenu.Name + ".enabled", Global.Lang.Get("G_Enabled")).SetValue(true));
                }

                if (assisted)
                {
                    var uAssistedMenu =
                        ultimateMenu.AddSubMenu(
                            new Menu(Global.Lang.Get("UM_Assisted"), ultimateMenu.Name + ".assisted"));
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".min", "R " + Global.Lang.Get("G_Min")).SetValue(
                            new Slider(3, 1, 5)));
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".duel", Global.Lang.Get("UM_Duel")).SetValue(true));
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".hotkey", Global.Lang.Get("G_Hotkey")).SetValue(
                            new KeyBind('R', KeyBindType.Press)));
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".move-cursor", Global.Lang.Get("UM_MoveCursor")).SetValue(
                            true));
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".enabled", Global.Lang.Get("G_Enabled")).SetValue(true));
                }

                var uDuelMenu =
                    ultimateMenu.AddSubMenu(
                        new Menu(
                            Global.Lang.Get("UM_Duel") + " " + Global.Lang.Get("G_Settings"),
                            ultimateMenu.Name + ".duel"));

                var uDuelAlliesMenu =
                    uDuelMenu.AddSubMenu(new Menu(Global.Lang.Get("G_Allies"), uDuelMenu.Name + ".allies"));

                uDuelAlliesMenu.AddItem(
                    new MenuItem(uDuelAlliesMenu.Name + ".range", Global.Lang.Get("UM_MaxAlliesRange")).SetValue(
                        new Slider(1500, 500, 3000)));
                uDuelAlliesMenu.AddItem(
                    new MenuItem(uDuelAlliesMenu.Name + ".min", Global.Lang.Get("UM_MinAllies")).SetValue(
                        new Slider(0, 0, 4)));
                uDuelAlliesMenu.AddItem(
                    new MenuItem(uDuelAlliesMenu.Name + ".max", Global.Lang.Get("UM_MaxAllies")).SetValue(
                        new Slider(3, 0, 4)));

                var uDuelEnemiesMenu =
                    uDuelMenu.AddSubMenu(new Menu(Global.Lang.Get("G_Enemies"), uDuelMenu.Name + ".enemies"));

                uDuelEnemiesMenu.AddItem(
                    new MenuItem(uDuelEnemiesMenu.Name + ".range", Global.Lang.Get("UM_MaxEnemiesRange")).SetValue(
                        new Slider(2500, 500, 3000)));
                uDuelEnemiesMenu.AddItem(
                    new MenuItem(uDuelEnemiesMenu.Name + ".min", Global.Lang.Get("UM_MinEnemies")).SetValue(
                        new Slider(1, 1, 5)));
                uDuelEnemiesMenu.AddItem(
                    new MenuItem(uDuelEnemiesMenu.Name + ".max", Global.Lang.Get("UM_MaxEnemies")).SetValue(
                        new Slider(1, 1, 5)));

                var uDuelTargetMenu =
                    uDuelMenu.AddSubMenu(new Menu(Global.Lang.Get("G_Target"), uDuelMenu.Name + ".target"));

                uDuelTargetMenu.AddItem(
                    new MenuItem(uDuelTargetMenu.Name + ".min-health", Global.Lang.Get("UM_MinTargetHealth")).SetValue(
                        new Slider(15, 10)));
                uDuelTargetMenu.AddItem(
                    new MenuItem(uDuelTargetMenu.Name + ".max-health", Global.Lang.Get("UM_MaxTargetHealth")).SetValue(
                        new Slider(100, 10)));

                var uDuelDamageMenu =
                    uDuelMenu.AddSubMenu(new Menu(Global.Lang.Get("G_Damage"), uDuelMenu.Name + ".damage"));

                uDuelDamageMenu.AddItem(
                    new MenuItem(uDuelDamageMenu.Name + ".percent", Global.Lang.Get("UM_DamagePercent")).SetValue(
                        new Slider(100, 1, 200)));

                if (required)
                {
                    var uRequiredMenu =
                        ultimateMenu.AddSubMenu(
                            new Menu(Global.Lang.Get("UM_RequiredTarget"), ultimateMenu.Name + ".required"));

                    var requiredComboMenu =
                        uRequiredMenu.AddSubMenu(new Menu(Global.Lang.Get("G_Combo"), uRequiredMenu.Name + ".combo"));
                    requiredComboMenu.AddItem(
                        new MenuItem(requiredComboMenu.Name + ".min", Global.Lang.Get("G_Min")).SetValue(
                            new Slider(0, 0, 5)).DontSave());
                    HeroListManager.AddToMenu(
                        requiredComboMenu, "ultimate-required-combo", true, false, true, false, true);

                    var requiredAutoMenu =
                        uRequiredMenu.AddSubMenu(new Menu(Global.Lang.Get("UM_Auto"), uRequiredMenu.Name + ".auto"));
                    requiredAutoMenu.AddItem(
                        new MenuItem(requiredAutoMenu.Name + ".min", Global.Lang.Get("G_Min")).SetValue(
                            new Slider(0, 0, 5)).DontSave());
                    HeroListManager.AddToMenu(
                        requiredAutoMenu, "ultimate-required-auto", true, false, true, false, true);


                    uRequiredMenu.AddItem(
                        new MenuItem(uRequiredMenu.Name + ".range-check", Global.Lang.Get("UM_RangeCheck")).SetValue(
                            new Slider(2000, 1000, 3000)));
                }

                if (force)
                {
                    var uForceMenu =
                        ultimateMenu.AddSubMenu(
                            new Menu(Global.Lang.Get("UM_ForceTarget"), ultimateMenu.Name + ".force"));
                    uForceMenu.AddItem(
                        new MenuItem(uForceMenu.Name + ".additional", Global.Lang.Get("UM_AdditionalTargets")).SetValue(
                            new Slider(0, 0, 4)).DontSave());
                    uForceMenu.AddItem(
                        new MenuItem(uForceMenu.Name + ".combo-killable", Global.Lang.Get("UM_ComboKillable")).SetValue(
                            false).DontSave());
                    HeroListManager.AddToMenu(uForceMenu, "ultimate-force", true, false, true, false, true);
                }

                return(ultimateMenu);
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
            return(null);
        }
Esempio n. 4
0
        public Menu AddToMenu(Menu menu)
        {
            try
            {
                _menu = menu;

                var ultimateMenu = menu.AddSubMenu(new Menu("Ultimate", menu.Name + ".ultimate"));

                if (Required)
                {
                    var requiredMenu =
                        ultimateMenu.AddSubMenu(new Menu("Required Targets", ultimateMenu.Name + ".required"));

                    var modes = new List <UltimateModeType>();
                    if (Combo)
                    {
                        modes.Add(UltimateModeType.Combo);
                    }
                    if (Auto)
                    {
                        modes.Add(UltimateModeType.Auto);
                    }
                    if (Assisted)
                    {
                        modes.Add(UltimateModeType.Assisted);
                    }

                    requiredMenu.AddItem(
                        new MenuItem(requiredMenu.Name + ".mode", "Mode").SetValue(
                            new StringList(modes.Select(m => m.ToString()).ToArray()))).ValueChanged +=
                        delegate(object sender, OnValueChangeEventArgs eventArgs)
                    {
                        Utils.UpdateVisibleTags(requiredMenu, eventArgs.GetNewValue <StringList>().SelectedIndex + 1);
                    };

                    for (var i = 0; i < modes.Count; i++)
                    {
                        requiredMenu.AddItem(
                            new MenuItem(
                                requiredMenu.Name + "." + GetModeString(modes[i], true) + ".min", "Min. Required")
                            .SetValue(new Slider(1, 1, 5))).SetTag(i + 1);
                        HeroListManager.AddToMenu(
                            requiredMenu,
                            new HeroListManagerArgs("ultimate-required-" + GetModeString(modes[i], true))
                        {
                            IsWhitelist   = true,
                            Allies        = false,
                            Enemies       = true,
                            DefaultValue  = false,
                            DontSave      = true,
                            Enabled       = true,
                            MenuTag       = i + 1,
                            EnabledButton = false
                        });
                    }

                    Utils.UpdateVisibleTags(
                        requiredMenu, _menu.Item(requiredMenu.Name + ".mode").GetValue <StringList>().SelectedIndex + 1);
                }

                if (Force)
                {
                    var uForceMenu = ultimateMenu.AddSubMenu(new Menu("Forced Targets", ultimateMenu.Name + ".force"));
                    if (DamageCalculation != null)
                    {
                        uForceMenu.AddItem(
                            new MenuItem(uForceMenu.Name + ".damage-check", "Damage Check").SetValue(ForceDamageCheck));
                    }
                    uForceMenu.AddItem(
                        new MenuItem(uForceMenu.Name + ".additional", "Additional Targets").SetValue(
                            new Slider(0, 0, 4)));
                    HeroListManager.AddToMenu(
                        uForceMenu,
                        new HeroListManagerArgs("ultimate-force")
                    {
                        IsWhitelist   = true,
                        Allies        = false,
                        Enemies       = true,
                        DefaultValue  = false,
                        DontSave      = true,
                        Enabled       = true,
                        EnabledButton = false
                    });
                }

                if (Combo)
                {
                    var uComboMenu = ultimateMenu.AddSubMenu(new Menu("Combo", ultimateMenu.Name + ".combo"));
                    uComboMenu.AddItem(
                        new MenuItem(uComboMenu.Name + ".min", "Min. Hits").SetValue(new Slider(2, 1, 5)));
                    if (DamageCalculation != null)
                    {
                        uComboMenu.AddItem(
                            new MenuItem(uComboMenu.Name + ".damage-check", "Damage Check").SetValue(ComboDamageCheck));
                    }
                    uComboMenu.AddItem(new MenuItem(uComboMenu.Name + ".enabled", "Enabled").SetValue(true));
                }

                if (Auto)
                {
                    var uAutoMenu = ultimateMenu.AddSubMenu(new Menu("Auto", ultimateMenu.Name + ".auto"));
                    if (Interrupt)
                    {
                        var autoInterruptMenu =
                            uAutoMenu.AddSubMenu(new Menu("Interrupt", uAutoMenu.Name + ".interrupt"));
                        if (InterruptDelay)
                        {
                            DelayManager.AddToMenu(
                                autoInterruptMenu, "ultimate-interrupt-delay", string.Empty, 0, 0, 500);
                        }
                        HeroListManager.AddToMenu(
                            autoInterruptMenu,
                            new HeroListManagerArgs("ultimate-interrupt")
                        {
                            IsWhitelist  = false,
                            Allies       = false,
                            Enemies      = true,
                            DefaultValue = false,
                            DontSave     = false,
                            Enabled      = true
                        });
                    }
                    if (Gapcloser)
                    {
                        var autoGapcloserMenu =
                            uAutoMenu.AddSubMenu(new Menu("Gapcloser", uAutoMenu.Name + ".gapcloser"));
                        if (GapcloserDelay)
                        {
                            DelayManager.AddToMenu(
                                autoGapcloserMenu, "ultimate-gapcloser-delay", string.Empty, 0, 0, 500);
                        }
                        HeroListManager.AddToMenu(
                            autoGapcloserMenu,
                            new HeroListManagerArgs("ultimate-gapcloser")
                        {
                            IsWhitelist  = false,
                            Allies       = false,
                            Enemies      = true,
                            DefaultValue = false,
                            DontSave     = false,
                            Enabled      = false
                        });
                        BestTargetOnlyManager.AddToMenu(autoGapcloserMenu, "r-gapcloser", true);
                    }
                    uAutoMenu.AddItem(new MenuItem(uAutoMenu.Name + ".min", "Min. Hits").SetValue(new Slider(3, 1, 5)));
                    if (DamageCalculation != null)
                    {
                        uAutoMenu.AddItem(
                            new MenuItem(uAutoMenu.Name + ".damage-check", "Damage Check").SetValue(AutoDamageCheck));
                    }
                    uAutoMenu.AddItem(new MenuItem(uAutoMenu.Name + ".enabled", "Enabled").SetValue(true));
                }

                if (Assisted)
                {
                    var uAssistedMenu = ultimateMenu.AddSubMenu(new Menu("Assisted", ultimateMenu.Name + ".assisted"));
                    if (Flash)
                    {
                        uAssistedMenu.AddItem(
                            new MenuItem(ultimateMenu.Name + ".flash.min", "Flash Min. Hits").SetValue(
                                new Slider(3, 1, 5)));
                    }
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".min", "Min. Hits").SetValue(new Slider(1, 1, 5)));
                    if (Flash)
                    {
                        uAssistedMenu.AddItem(
                            new MenuItem(ultimateMenu.Name + ".flash.hotkey", "Flash").SetValue(
                                new KeyBind('Y', KeyBindType.Press)));
                    }
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".hotkey", "Hotkey").SetValue(
                            new KeyBind('T', KeyBindType.Press)));
                    uAssistedMenu.AddItem(
                        new MenuItem(uAssistedMenu.Name + ".move-cursor", "Move to Cursor").SetValue(true));
                    if (DamageCalculation != null)
                    {
                        uAssistedMenu.AddItem(
                            new MenuItem(uAssistedMenu.Name + ".damage-check", "Damage Check").SetValue(
                                AssistedDamageCheck));
                    }
                    uAssistedMenu.AddItem(new MenuItem(uAssistedMenu.Name + ".enabled", "Enabled").SetValue(true));
                }

                var uSingleMenu = ultimateMenu.AddSubMenu(new Menu("Single Target", ultimateMenu.Name + ".single"));
                uSingleMenu.AddItem(
                    new MenuItem(uSingleMenu.Name + ".min-health", "Min. Target Health %").SetValue(new Slider(15)));
                uSingleMenu.AddItem(
                    new MenuItem(uSingleMenu.Name + ".max-add-allies", "Max. Additional Allies").SetValue(
                        new Slider(3, 0, 4)));
                uSingleMenu.AddItem(
                    new MenuItem(uSingleMenu.Name + ".max-add-enemies", "Max. Additional Enemies").SetValue(
                        new Slider(0, 0, 4)));

                uSingleMenu.AddItem(
                    new MenuItem(uSingleMenu.Name + ".range-allies", "Allies Range Check").SetValue(
                        new Slider(1750, 500, 3000)));
                uSingleMenu.AddItem(
                    new MenuItem(uSingleMenu.Name + ".range-enemies", "Enemies Range Check").SetValue(
                        new Slider(1750, 500, 3000)));

                if (Combo)
                {
                    uSingleMenu.AddItem(new MenuItem(uSingleMenu.Name + ".combo", "Combo").SetValue(true));
                }
                if (Auto)
                {
                    uSingleMenu.AddItem(new MenuItem(uSingleMenu.Name + ".auto", "Auto").SetValue(false));
                }
                if (Assisted)
                {
                    if (Flash)
                    {
                        uSingleMenu.AddItem(new MenuItem(uSingleMenu.Name + ".flash", "Flash").SetValue(false));
                    }
                    uSingleMenu.AddItem(new MenuItem(uSingleMenu.Name + ".assisted", "Assisted").SetValue(false));
                }

                if (DamageCalculation != null)
                {
                    ultimateMenu.AddItem(
                        new MenuItem(ultimateMenu.Name + ".damage-percent-single", "Single Damage Check %").SetValue(
                            new Slider(SingleDamagePercent, 1, 200)));
                    ultimateMenu.AddItem(
                        new MenuItem(ultimateMenu.Name + ".damage-percent", "Damage Check %").SetValue(
                            new Slider(DamagePercent, 1, 200)));
                }

                return(ultimateMenu);
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
            return(null);
        }