C# MenuItem.IsActive方法代码示例

        public RandomiserMenu(Menu rootMenu)
        {
            var menu = new Menu("Randomiser", "randomiser");

            var enabled =
                new MenuItem("enabled", "Enabled").SetValue(false)
                    .SetTooltip("Will intentionally fail to counter abilities");
            menu.AddItem(enabled);
            enabled.ValueChanged += (sender, args) => Enabled = args.GetNewValue<bool>();
            Enabled = enabled.IsActive();

            var nukesOnly =
                new MenuItem("nukesOnly", "Nukes only").SetValue(true)
                    .SetTooltip(
                        "If enabled, only nukes will be randomised and disable abilities will always be countered");
            menu.AddItem(nukesOnly);
            nukesOnly.ValueChanged += (sender, args) => NukesOnly = args.GetNewValue<bool>();
            NukesOnly = nukesOnly.IsActive();

            var failChance = new MenuItem("failChance", "Fail chance").SetValue(new Slider(20, 5, 50));
            menu.AddItem(failChance);
            failChance.ValueChanged += (sender, args) => FailChance = args.GetNewValue<Slider>().Value;
            FailChance = failChance.GetValue<Slider>().Value;

            rootMenu.AddSubMenu(menu);
        }

        public DebugMenu(Menu rootMenu)
        {
            var menu = new Menu("Debug", "debug").SetFontColor(Color.PaleVioletRed);

            var drawAbilities =
                new MenuItem("debugAbilities", "Draw abilities").SetValue(false)
                    .SetTooltip("Draw enemy ability ranges, timings and projectiles when casted");
            menu.AddItem(drawAbilities);
            drawAbilities.ValueChanged += (sender, args) => DrawAbilities = args.GetNewValue<bool>();
            DrawAbilities = drawAbilities.IsActive();

            var drawMap = new MenuItem("debugDrawMap", "Draw obstacles map").SetValue(false);
            menu.AddItem(drawMap);
            drawMap.ValueChanged += (sender, args) => DrawMap = args.GetNewValue<bool>();
            DrawMap = drawMap.IsActive();

            var logAbilityUsage = new MenuItem("debugLogAbilityUsage", "Log ability usage").SetValue(false);
            menu.AddItem(logAbilityUsage);
            logAbilityUsage.ValueChanged += (sender, args) => LogAbilityUsage = args.GetNewValue<bool>();
            LogAbilityUsage = logAbilityUsage.IsActive();

            var logInformation = new MenuItem("debugLogInformation", "Log information").SetValue(false);
            menu.AddItem(logInformation);
            logInformation.ValueChanged += (sender, args) => LogInformation = args.GetNewValue<bool>();
            LogInformation = logInformation.IsActive();

            var logIntersection = new MenuItem("debugLogIntersection", "Log intersections").SetValue(false);
            menu.AddItem(logIntersection);
            logIntersection.ValueChanged += (sender, args) => LogIntersection = args.GetNewValue<bool>();
            LogIntersection = logIntersection.IsActive();

            var logModifiers = new MenuItem("debugLogModifiers", "Log modifiers").SetValue(false);
            menu.AddItem(logModifiers);
            logModifiers.ValueChanged += (sender, args) => LogModifiers = args.GetNewValue<bool>();
            LogModifiers = logModifiers.IsActive();

            var logParticles = new MenuItem("debugLogParticles", "Log particles").SetValue(false);
            menu.AddItem(logParticles);
            logParticles.ValueChanged += (sender, args) => LogParticles = args.GetNewValue<bool>();
            LogParticles = logParticles.IsActive();

            var logProjectiles = new MenuItem("debugLogProjectiles", "Log projectiles").SetValue(false);
            menu.AddItem(logProjectiles);
            logProjectiles.ValueChanged += (sender, args) => LogProjectiles = args.GetNewValue<bool>();
            LogProjectiles = logProjectiles.IsActive();

            var logUnits = new MenuItem("debugLogUnits", "Log units").SetValue(false);
            menu.AddItem(logUnits);
            logUnits.ValueChanged += (sender, args) => { LogUnits = args.GetNewValue<bool>(); };
            LogUnits = logUnits.IsActive();

            rootMenu.AddSubMenu(menu);
        }

        public static void Initialize(MenuItem drawPix)
        {
            _drawPix = drawPix;
            FindPix();
            _circle = new Render.Circle(Vector3.Zero, 50, Color.Purple);
            _circle.VisibleCondition += sender => _drawPix.IsActive();
            _circle.Add();

            Obj_AI_Base.OnBuffRemove += (sender, args) =>
            {
                if (args.Buff.SourceName == ObjectManager.Player.ChampionName && (args.Buff.Name == "luluevision" || args.Buff.Name == "lulufaerieshield"))
                {
                    _lastECast = 0;
                }
            };
            Game.OnUpdate += Game_OnUpdate;
            Obj_AI_Base.OnProcessSpellCast += Obj_AI_Base_OnProcessSpellCast;
        }

        public AlliesSettingsMenu(Menu rootMenu)
        {
            var menu = new Menu("Allies settings", "alliesSettings");

            var helpAllies = new MenuItem("helpAllies", "Help allies").SetValue(false);
            menu.AddItem(helpAllies);
            helpAllies.ValueChanged += (sender, args) => HelpAllies = args.GetNewValue<bool>();
            HelpAllies = helpAllies.IsActive();

            menu.AddItem(new AllyHeroesToggler("enabledAllies", "Allies", allyToggler));

            var multiIntersection =
                new MenuItem("multiIntersectionDisable", "Multi intersection disable").SetValue(false)
                    .SetTooltip(
                        "Will disable enemy who's using AOE disable which will hit multiple allies (priority settings will be ignored)");
            menu.AddItem(multiIntersection);
            multiIntersection.ValueChanged += (sender, args) => MultiIntersectionEnemyDisable = args.GetNewValue<bool>();
            MultiIntersectionEnemyDisable = multiIntersection.IsActive();

            rootMenu.AddSubMenu(menu);
        }

        public HotkeysMenu(Menu rootMenu)
        {
            var menu = new Menu("Hotkeys", "hotkeys");

            var enabledEvader =
                new MenuItem("enable", "Enable evader").SetValue(new KeyBind(36, KeyBindType.Toggle, true));
            menu.AddItem(enabledEvader);
            enabledEvader.ValueChanged += (sender, args) => EnabledEvader = args.GetNewValue<KeyBind>().Active;
            EnabledEvader = enabledEvader.IsActive();

            var enabledPathfinder =
                new MenuItem("enablePathfinder", "Enable pathfinder").SetValue(
                    new KeyBind(35, KeyBindType.Toggle, true));
            menu.AddItem(enabledPathfinder);
            enabledPathfinder.ValueChanged += (sender, args) => EnabledPathfinder = args.GetNewValue<KeyBind>().Active;
            EnabledPathfinder = enabledPathfinder.IsActive();

            menu.AddItem(
                    new MenuItem("forceBlink", "Force blink").SetValue(new KeyBind(46, KeyBindType.Press))
                        .SetTooltip("Blink in front of your hero as soon as possible")).ValueChanged +=
                (sender, args) => ForceBlink = args.GetNewValue<KeyBind>().Active;

            rootMenu.AddSubMenu(menu);
        }

        public static void Initialize(Menu menu, Dictionary<SpellSlot, int[]> manaDictionary)
        {
            _manaBarItem = menu.AddCircle("ManaBarEnabled", "Draw Mana Indicator", Color.Black);
            _manaBarItem.SetTooltip("Draw indicator on mana bar. Red means not enough mana.");

            Drawing.OnPreReset += DrawingOnOnPreReset;
            Drawing.OnPostReset += DrawingOnOnPostReset;
            AppDomain.CurrentDomain.DomainUnload += CurrentDomainOnDomainUnload;
            AppDomain.CurrentDomain.ProcessExit += CurrentDomainOnDomainUnload;

            Drawing.OnEndScene += eventArgs =>
            {
                if (ObjectManager.Player.IsDead || !_manaBarItem.IsActive())
                {
                    return;
                }

                var spell = ObjectManager.Player.Spellbook;
                var totalMana = manaDictionary.Sum(kvp => kvp.Value[spell.GetSpell(kvp.Key).Level]);

                DrawManaPercent(
                    totalMana, totalMana > ObjectManager.Player.Mana ? new ColorBGRA(255, 0, 0, 255) : DrawColor);
            };
        }

//.........这里部分代码省略.........
                    harassMenu.SubMenu("Harass")
                        .AddItem(
                            new MenuItem("ElEasy.Katarina.Harass.Mode", "Harass mode:").SetValue(
                                new StringList(new[] { "Q", "Q - W", "Q - E - W" })));
                }

                this.Menu.AddSubMenu(harassMenu);

                var clearMenu = new Menu("Clear", "Clear");
                {
                    clearMenu.SubMenu("Lasthit")
                        .AddItem(new MenuItem("ElEasy.Katarina.Lasthit.Q", "Use Q").SetValue(true));
                    clearMenu.SubMenu("Lasthit")
                        .AddItem(new MenuItem("ElEasy.Katarina.Lasthit.W", "Use W").SetValue(true));
                    clearMenu.SubMenu("Lasthit")
                        .AddItem(new MenuItem("ElEasy.Katarina.Lasthit.E", "Use E").SetValue(false));
                    clearMenu.SubMenu("Laneclear")
                        .AddItem(new MenuItem("ElEasy.Katarina.LaneClear.Q", "Use Q").SetValue(true));
                    clearMenu.SubMenu("Laneclear")
                        .AddItem(new MenuItem("ElEasy.Katarina.LaneClear.W", "Use W").SetValue(true));
                    clearMenu.SubMenu("Laneclear")
                        .AddItem(new MenuItem("ElEasy.Katarina.LaneClear.E", "Use E").SetValue(false));
                    clearMenu.SubMenu("Jungleclear")
                        .AddItem(new MenuItem("ElEasy.Katarina.JungleClear.Q", "Use Q").SetValue(true));
                    clearMenu.SubMenu("Jungleclear")
                        .AddItem(new MenuItem("ElEasy.Katarina.JungleClear.W", "Use W").SetValue(true));
                    clearMenu.SubMenu("Jungleclear")
                        .AddItem(new MenuItem("ElEasy.Katarina.JungleClear.E", "Use E").SetValue(false));
                }

                this.Menu.AddSubMenu(clearMenu);

                var wardjumpMenu = new Menu("Wardjump", "Wardjump");
                {
                    wardjumpMenu.AddItem(
                        new MenuItem("ElEasy.Katarina.Wardjump", "Wardjump key").SetValue(
                            new KeyBind("Z".ToCharArray()[0], KeyBindType.Press)));

                    wardjumpMenu.AddItem(new MenuItem("ElEasy.Wardjump.Mouse", "Move to mouse").SetValue(true));
                    wardjumpMenu.AddItem(new MenuItem("ElEasy.Wardjump.Minions", "Jump to minions").SetValue(false));
                    wardjumpMenu.AddItem(new MenuItem("ElEasy.Wardjump.Champions", "Jump to champions").SetValue(false));
                }

                this.Menu.AddSubMenu(wardjumpMenu);

                var itemMenu = new Menu("Items", "Items");
                {
                    itemMenu.AddItem(
                        new MenuItem("ElEasy.Katarina.Items.hextech", "Use Hextech Gunblade").SetValue(true));
                }

                this.Menu.AddSubMenu(itemMenu);

                var killstealMenu = new Menu("Killsteal", "Killsteal");
                {
                    killstealMenu.AddItem(new MenuItem("ElEasy.Katarina.Killsteal", "Killsteal").SetValue(true));
                    killstealMenu.AddItem(
                        new MenuItem("ElEasy.Katarina.Killsteal.R", "Killsteal with R").SetValue(true));
                }

                this.Menu.AddSubMenu(killstealMenu);

                var miscellaneousMenu = new Menu("Miscellaneous", "Miscellaneous");
                {
                    miscellaneousMenu.AddItem(
                        new MenuItem("ElEasy.Katarina.Draw.off", "Turn drawings off").SetValue(true));
                    miscellaneousMenu.AddItem(new MenuItem("ElEasy.Katarina.Draw.Q", "Draw Q").SetValue(new Circle()));
                    miscellaneousMenu.AddItem(new MenuItem("ElEasy.Katarina.Draw.W", "Draw W").SetValue(new Circle()));
                    miscellaneousMenu.AddItem(new MenuItem("ElEasy.Katarina.Draw.E", "Draw E").SetValue(new Circle()));
                    miscellaneousMenu.AddItem(new MenuItem("ElEasy.Katarina.Draw.R", "Draw R").SetValue(new Circle()));

                    var dmgAfterE = new MenuItem("ElEasy.Katarina.DrawComboDamage", "Draw combo damage").SetValue(true);
                    var drawFill =
                        new MenuItem("ElEasy.Katarina.DrawColour", "Fill colour", true).SetValue(
                            new Circle(true, Color.FromArgb(204, 204, 0, 0)));
                    miscellaneousMenu.AddItem(drawFill);
                    miscellaneousMenu.AddItem(dmgAfterE);

                    DrawDamage.DamageToUnit = this.GetComboDamage;
                    DrawDamage.Enabled = dmgAfterE.IsActive();
                    DrawDamage.Fill = drawFill.GetValue<Circle>().Active;
                    DrawDamage.FillColor = drawFill.GetValue<Circle>().Color;

                    dmgAfterE.ValueChanged +=
                        delegate(object sender, OnValueChangeEventArgs eventArgs)
                            {
                                DrawDamage.Enabled = eventArgs.GetNewValue<bool>();
                            };

                    drawFill.ValueChanged += delegate(object sender, OnValueChangeEventArgs eventArgs)
                        {
                            DrawDamage.Fill = eventArgs.GetNewValue<Circle>().Active;
                            DrawDamage.FillColor = eventArgs.GetNewValue<Circle>().Color;
                        };
                }

                this.Menu.AddSubMenu(miscellaneousMenu);
            }
            rootMenu.AddSubMenu(this.Menu);
        }

//.........这里部分代码省略.........
                {
                    comboMenu.AddItem(new MenuItem("GFUELTalon.Combo.Q", "Use Q").SetValue(true));
                    comboMenu.AddItem(new MenuItem("GFUELTalon.Combo.W", "Use W").SetValue(true));
                    comboMenu.AddItem(new MenuItem("GFUELTalon.Combo.E", "Use E").SetValue(true));
                    comboMenu.AddItem(new MenuItem("GFUELTalon.Combo.Items", "Use Items").SetValue(true));
                    comboMenu.AddItem(new MenuItem("GFUELTalon.Combo.Towercheck", "Check under tower").SetValue(false));

                    comboMenu.SubMenu("R Settings").AddItem(new MenuItem("GFUELTalon.Combo.R", "Use R").SetValue(true));
                    comboMenu.SubMenu("R Settings")
                        .AddItem(new MenuItem("GFUELTalon.Combo.Killability", "R on killability").SetValue(true));
                    comboMenu.SubMenu("R Settings")
                        .AddItem(new MenuItem("GFUELTalon.Combo.Count", "R when ult can hit"))
                        .SetValue(new Slider(1, 1, 5));
                    comboMenu.SubMenu("R Settings")
                        .AddItem(new MenuItem("GFUELTalon.Combo.Overkill.R", "Check R overkill").SetValue(false));
                }

                Menu.AddSubMenu(comboMenu);

                var harassMenu = new Menu("Harass", "Harass");
                {
                    harassMenu.AddItem(new MenuItem("GFUELTalon.Harass.W", "Use W").SetValue(true));
                }

                Menu.AddSubMenu(harassMenu);

                var laneclearMenu = new Menu("Laneclear", "Laneclear");
                {
                    laneclearMenu.AddItem(new MenuItem("GFUELTalon.laneclear.E", "Use E").SetValue(false));
                    laneclearMenu.AddItem(new MenuItem("GFUELTalon.laneclear.W", "Use W").SetValue(true));

                    laneclearMenu.AddItem(new MenuItem("GFUELTalon.laneclear.count", "Minimum minion count"))
                        .SetValue(new Slider(3, 2, 6));

                    laneclearMenu.AddItem(
                        new MenuItem("GFUELTalon.laneclear.Mana", "Minimum mana").SetValue(new Slider(20, 0, 100)));
                }

                Menu.AddSubMenu(laneclearMenu);

                var jungleclearMenu = new Menu("Jungleclear", "Jungleclear");
                {
                    jungleclearMenu.AddItem(new MenuItem("GFUELTalon.jungleclear.Q", "Use Q").SetValue(false));
                    jungleclearMenu.AddItem(new MenuItem("GFUELTalon.jungleclear.E", "Use E").SetValue(false));
                    jungleclearMenu.AddItem(new MenuItem("GFUELTalon.jungleclear.W", "Use W").SetValue(true));
                    jungleclearMenu.AddItem(
                        new MenuItem("GFUELTalon.jungleclear.Mana", "Minimum mana").SetValue(new Slider(20, 0, 100)));
                }

                Menu.AddSubMenu(jungleclearMenu);

                var killstealMenu = new Menu("Killsteal", "Killsteal");
                {
                    killstealMenu.AddItem(new MenuItem("GFUELTalon.Killsteal.W", "Killsteal W").SetValue(false));
                }

                Menu.AddSubMenu(killstealMenu);

                var miscellaneousMenu = new Menu("Miscellaneous", "Miscellaneous");
                {
                    miscellaneousMenu.AddItem(new MenuItem("GFUELTalon.Draw.Off", "Disable drawings").SetValue(false));
                    miscellaneousMenu.AddItem(new MenuItem("GFUELTalon.Draw.W", "Draw E").SetValue(true));

                    miscellaneousMenu.AddItem(
                        new MenuItem("GFUELTalon.Misc.Antigapcloser", "Use E - Antigapcloser").SetValue(true));

                    var dmgAfterE = new MenuItem("GFUELTalon.DrawComboDamage", "Draw combo damage").SetValue(true);
                    var drawFill =
                        new MenuItem("GFUELTalon.DrawColour", "Fill colour", true).SetValue(
                            new Circle(true, Color.Goldenrod));
                    miscellaneousMenu.AddItem(drawFill);
                    miscellaneousMenu.AddItem(dmgAfterE);

                    DamageIndicator.DamageToUnit = GetComboDamage;
                    DamageIndicator.Enabled = dmgAfterE.IsActive();
                    DamageIndicator.Fill = drawFill.GetValue<Circle>().Active;
                    DamageIndicator.FillColor = drawFill.GetValue<Circle>().Color;

                    dmgAfterE.ValueChanged +=
                        delegate(object sender, OnValueChangeEventArgs eventArgs)
                            {
                                DamageIndicator.Enabled = eventArgs.GetNewValue<bool>();
                            };

                    drawFill.ValueChanged += delegate(object sender, OnValueChangeEventArgs eventArgs)
                        {
                            DamageIndicator.Fill = eventArgs.GetNewValue<Circle>().Active;
                            DamageIndicator.FillColor = eventArgs.GetNewValue<Circle>().Color;
                        };
                }

                Menu.AddSubMenu(miscellaneousMenu);

                Menu.AddToMainMenu();
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
            }
        }

        /// <summary>
        ///     Creates the menu
        /// </summary>
        /// <value>
        ///     Creates the menu
        /// </value>
        private static void GenerateMenu()
        {
            try
            {
                Menu = new Menu("GFUEL QUINN", "GFUELQUINN", true);

                var targetselectorMenu = new Menu("Target Selector", "Target Selector");
                {
                    TargetSelector.AddToMenu(targetselectorMenu);
                }

                Menu.AddSubMenu(targetselectorMenu);

                var orbwalkMenu = new Menu("Orbwalker", "Orbwalker");
                {
                    Orbwalker = new Orbwalking.Orbwalker(orbwalkMenu);
                }

                Menu.AddSubMenu(orbwalkMenu);

                var comboMenu = new Menu("Combo", "Combo");
                {
                    comboMenu.AddItem(new MenuItem("GFUELQuinn.Combo.Q", "Use Q").SetValue(true));
                    comboMenu.AddItem(new MenuItem("GFUELQuinn.Combo.E", "Use E").SetValue(true));
                    comboMenu.AddItem(new MenuItem("GFUELQuinn.Combo.Ghostblade", "Use Ghostblade").SetValue(true));
                }

                Menu.AddSubMenu(comboMenu);

                var harassMenu = new Menu("Harass", "Harass");
                {
                    harassMenu.AddItem(new MenuItem("GFUELQuinn.Harass.Q", "Use Q").SetValue(true));
                }

                Menu.AddSubMenu(harassMenu);

                var laneclearMenu = new Menu("Laneclear", "Laneclear");
                {
                    laneclearMenu.AddItem(new MenuItem("GFUELQuinn.laneclear.Q", "Use Q").SetValue(true));
                    laneclearMenu.AddItem(new MenuItem("GFUELQuinn.laneclear.E", "Use E").SetValue(false));
                    laneclearMenu.AddItem(new MenuItem("GFUELQuinn.laneclear.count", "Minimum minion count"))
                        .SetValue(new Slider(3, 2, 6));

                    laneclearMenu.AddItem(
                        new MenuItem("GFUELQuinn.laneclear.Mana", "Minimum mana").SetValue(new Slider(20, 0, 100)));
                }

                Menu.AddSubMenu(laneclearMenu);

                var jungleclearMenu = new Menu("Jungleclear", "Jungleclear");
                {
                    jungleclearMenu.AddItem(new MenuItem("GFUELQuinn.jungleclear.Q", "Use Q").SetValue(true));
                    jungleclearMenu.AddItem(new MenuItem("GFUELQuinn.jungleclear.E", "Use E").SetValue(true));
                    jungleclearMenu.AddItem(
                        new MenuItem("GFUELQuinn.jungleclear.Mana", "Minimum mana").SetValue(new Slider(20, 0, 100)));
                }

                Menu.AddSubMenu(jungleclearMenu);

                var killstealMenu = new Menu("Killsteal", "Killsteal");
                {
                    killstealMenu.AddItem(new MenuItem("GFUELElise.Killsteal.Q", "Killsteal Q").SetValue(true));
                }

                Menu.AddSubMenu(killstealMenu);

                var miscellaneousMenu = new Menu("Miscellaneous", "Miscellaneous");
                {
                    miscellaneousMenu.AddItem(new MenuItem("GFUELQuinn.Draw.Off", "Disable drawings").SetValue(false));
                    miscellaneousMenu.AddItem(new MenuItem("GFUELQuinn.Draw.Q", "Draw Q").SetValue(new Circle()));
                    miscellaneousMenu.AddItem(new MenuItem("GFUELQuinn.Draw.E", "Draw E").SetValue(new Circle()));

                    miscellaneousMenu.AddItem(
                        new MenuItem("GFUELQuinn.Misc.Antigapcloser", "Use E - Antigapcloser").SetValue(true));
                    miscellaneousMenu.AddItem(
                        new MenuItem("GFUELQuinn.Misc.Interrupter", "Use E - interrupter").SetValue(true));

                    var dmgAfterE = new MenuItem("GFUELQuinn.DrawComboDamage", "Draw combo damage").SetValue(true);
                    var drawFill =
                        new MenuItem("ElDiana.DrawColour", "Fill colour", true).SetValue(
                            new Circle(true, Color.Goldenrod));
                    miscellaneousMenu.AddItem(drawFill);
                    miscellaneousMenu.AddItem(dmgAfterE);

                    DamageIndicator.DamageToUnit = GetComboDamage;
                    DamageIndicator.Enabled = dmgAfterE.IsActive();
                    DamageIndicator.Fill = drawFill.GetValue<Circle>().Active;
                    DamageIndicator.FillColor = drawFill.GetValue<Circle>().Color;

                    dmgAfterE.ValueChanged +=
                        delegate(object sender, OnValueChangeEventArgs eventArgs)
                            {
                                DamageIndicator.Enabled = eventArgs.GetNewValue<bool>();
                            };
//.........这里部分代码省略.........

        public void AddAbility(string abilityName, AbilityType abilityType)
        {
            switch (abilityType)
            {
                case AbilityType.Counter:
                    if (counterAbilities.ContainsKey(abilityName))
                    {
                        return;
                    }
                    counterAbilityToggler.Add(abilityName);
                    usableCounterAbilities.SetValue(counterAbilityToggler);
                    break;
                case AbilityType.Blink:
                    if (blinkAbilities.ContainsKey(abilityName))
                    {
                        return;
                    }
                    blinkAbilityToggler.Add(abilityName);
                    usableBlinkAbilities.SetValue(blinkAbilityToggler);
                    break;
                case AbilityType.Disable:
                    if (disableAbilities.ContainsKey(abilityName))
                    {
                        return;
                    }
                    disableAbilityToggler.Add(abilityName);
                    usableDiasbleAbilities.SetValue(disableAbilityToggler);
                    break;
            }

            switch (abilityName)
            {
                case "item_bloodstone":
                    var bloodstoneMenu = new Menu(string.Empty, "bloodstoneMenu", textureName: abilityName);

                    var autoSuicide = new MenuItem("bsAutoSuicide", "Auto suicide").SetValue(false);
                    bloodstoneMenu.AddItem(autoSuicide);
                    autoSuicide.ValueChanged += (sender, args) => BloodstoneAutoSuicide = args.GetNewValue<bool>();
                    BloodstoneAutoSuicide = autoSuicide.IsActive();

                    var hpCheck = new MenuItem("bsHpCheck", "Use when HP% lower than").SetValue(new Slider(15, 1, 50));
                    bloodstoneMenu.AddItem(hpCheck);
                    hpCheck.ValueChanged += (sender, args) => BloodstoneHpThreshold = args.GetNewValue<Slider>().Value;
                    BloodstoneHpThreshold = hpCheck.GetValue<Slider>().Value;

                    var enemyCheck =
                        new MenuItem("bsEnemyCheck", "Use only when enemy in range of").SetValue(
                            new Slider(750, 0, 2000));
                    bloodstoneMenu.AddItem(enemyCheck);
                    enemyCheck.ValueChanged += (sender, args) => BloodstoneEnemyRange = args.GetNewValue<Slider>().Value;
                    BloodstoneEnemyRange = enemyCheck.GetValue<Slider>().Value;

                    specials.AddSubMenu(bloodstoneMenu);
                    break;
                case "item_armlet":
                    var armletMenu = new Menu(string.Empty, "armletMenu", textureName: abilityName);

                    var autoToggle = new MenuItem("armletAutoToggle", "Auto toggle").SetValue(true);
                    armletMenu.AddItem(autoToggle);
                    autoToggle.ValueChanged += (sender, args) => ArmletAutoToggle = args.GetNewValue<bool>();
                    ArmletAutoToggle = autoToggle.IsActive();

                    var armetHpThreshold =
                        new MenuItem("armletHpThreshold", "Minimum hp").SetValue(new Slider(222, 100, 300));
                    armletMenu.AddItem(armetHpThreshold);
                    armetHpThreshold.ValueChanged +=
                        (sender, args) => ArmetHpThreshold = args.GetNewValue<Slider>().Value;
                    ArmetHpThreshold = armetHpThreshold.GetValue<Slider>().Value;

                    var enemyNearOnly = new MenuItem("armletOnlyNearEnemies", "Only near enemies").SetValue(true);
                    enemyNearOnly.SetTooltip("If enabled, will toggle only when enemies are near");
                    armletMenu.AddItem(enemyNearOnly);
                    enemyNearOnly.ValueChanged += (sender, args) => ArmletEnemiesCheck = args.GetNewValue<bool>();
                    ArmletEnemiesCheck = enemyNearOnly.IsActive();

                    specials.AddSubMenu(armletMenu);
                    break;
                case "puck_phase_shift":
                    var phaseShiftMenu = new Menu(string.Empty, "phaseShiftMenu", textureName: abilityName);

                    var phaseShiftBlock = new MenuItem("phaseShiftBlock", "Action block").SetValue(true);
                    phaseShiftBlock.SetTooltip("Block player movement/attack actions when evader used phase shift");
                    phaseShiftMenu.AddItem(phaseShiftBlock);
                    phaseShiftBlock.ValueChanged += (sender, args) => PhaseShiftBlock = args.GetNewValue<bool>();
                    PhaseShiftBlock = phaseShiftBlock.IsActive();

                    var phaseShiftBlockTime =
                        new MenuItem("phaseShiftBlockTime", "Block for (ms)").SetValue(new Slider(500, 100, 3000));
                    phaseShiftBlockTime.SetTooltip("Action won't be blocked longer than phase shift duration");
                    phaseShiftMenu.AddItem(phaseShiftBlockTime);
                    phaseShiftBlockTime.ValueChanged +=
                        (sender, args) => PhaseShiftBlockTime = args.GetNewValue<Slider>().Value;
                    PhaseShiftBlockTime = phaseShiftBlockTime.GetValue<Slider>().Value;

                    specials.AddSubMenu(phaseShiftMenu);
                    break;
            }
        }

        public async Task AddAbility(EvadableAbility ability)
        {
            var ownerName = ability.Name.StartsWith("item_") ? "items" : ability.AbilityOwner.Name;
            var abilityName = ability.Name;
            var menuItemName = ownerName + abilityName;
            var modifierOnly = ability.GetType().BaseType?.Name == "EvadableAbility";

            if (addedAbilities.Contains(menuItemName))
            {
                var abilityEnabledItem = menu.Item(menuItemName + "enabled");
                ability.Enabled = abilityEnabledItem.GetValue<bool>();
                abilityEnabledItem.ValueChanged += (sender, args) => { ability.Enabled = args.GetNewValue<bool>(); };

                if (ability is IModifier)
                {
                    var modiferCounterItem = menu.Item(menuItemName + "modifier");
                    modiferCounterItem.ValueChanged +=
                        (sender, args) => { ability.ModifierCounterEnabled = args.GetNewValue<bool>(); };
                    ability.ModifierCounterEnabled = modiferCounterItem.IsActive();
                }

                if (!modifierOnly)
                {
                    var customPriorityItem = menu.Item(menuItemName + "customPriority");
                    customPriorityItem.ValueChanged +=
                        (sender, args) => { ability.UseCustomPriority = args.GetNewValue<bool>(); };
                    ability.UseCustomPriority = customPriorityItem.IsActive();

                    var abilityPriorityItem = menu.Item(menuItemName + "priorityFix");
                    var abilityTogglerItem = menu.Item(menuItemName + "togglerFix");

                    abilityPriorityItem.ValueChanged += (sender, args) => {
                        var changer = args.GetNewValue<PriorityChanger>();
                        ability.Priority.Clear();

                        foreach (var item in
                            changer.Dictionary.OrderByDescending(x => x.Value)
                                .Select(x => x.Key)
                                .Where(x => abilityTogglerItem.GetValue<AbilityToggler>().IsEnabled(x)))
                        {
                            switch (item)
                            {
                                case "item_sheepstick":
                                    ability.Priority.Add(EvadePriority.Disable);
                                    break;
                                case "item_cyclone":
                                    ability.Priority.Add(EvadePriority.Counter);
                                    break;
                                case "item_blink":
                                    ability.Priority.Add(EvadePriority.Blink);
                                    break;
                                case "centaur_stampede":
                                    ability.Priority.Add(EvadePriority.Walk);
                                    break;
                            }
                        }
                    };

                    abilityTogglerItem.ValueChanged += (sender, args) => {
                        var changer = abilityPriorityItem.GetValue<PriorityChanger>();
                        ability.Priority.Clear();

                        foreach (var item in
                            changer.Dictionary.OrderByDescending(x => x.Value)
                                .Select(x => x.Key)
                                .Where(x => args.GetNewValue<AbilityToggler>().IsEnabled(x)))
                        {
                            switch (item)
                            {
                                case "item_sheepstick":
                                    ability.Priority.Add(EvadePriority.Disable);
                                    break;
                                case "item_cyclone":
                                    ability.Priority.Add(EvadePriority.Counter);
                                    break;
                                case "item_blink":
                                    ability.Priority.Add(EvadePriority.Blink);
                                    break;
                                case "centaur_stampede":
                                    ability.Priority.Add(EvadePriority.Walk);
                                    break;
                            }
                        }
                    };

                    var hpIgnoreItem = menu.Item(menuItemName + "hpIgnore");
                    hpIgnoreItem.ValueChanged +=
                        (sender, args) => ability.AllyHpIgnore = args.GetNewValue<Slider>().Value;
                    ability.AllyHpIgnore = hpIgnoreItem.GetValue<Slider>().Value;

                    var abilityChangerItem = abilityPriorityItem.GetValue<PriorityChanger>();
                    foreach (var priority in
                        abilityChangerItem.Dictionary.OrderByDescending(x => x.Value)
                            .Select(x => x.Key)
                            .Where(x => abilityTogglerItem.GetValue<AbilityToggler>().IsEnabled(x)))
                    {
                        switch (priority)
                        {
                            case "item_sheepstick":
                                ability.Priority.Add(EvadePriority.Disable);
//.........这里部分代码省略.........

        public SettingsMenu(Menu rootMenu)
        {
            var menu = new Menu("Settings", "settings");

            defaultPriority =
                new MenuItem("defaultPriorityFix", "Default priority").SetValue(
                    new PriorityChanger(
                        new List<string>
                        {
                            "item_sheepstick",
                            "item_cyclone",
                            "item_blink",
                            "centaur_stampede"
                        },
                        "defaultPriorityChangerFix"));
            menu.AddItem(defaultPriority);
            defaultPriority.ValueChanged += DefaultPriorityOnValueChanged;

            defaultToggler =
                new MenuItem("defaultTogglerFix", "Enabled priority").SetValue(
                    new AbilityToggler(
                        new Dictionary<string, bool>
                        {
                            { "item_sheepstick", false },
                            { "item_cyclone", true },
                            { "item_blink", true },
                            { "centaur_stampede", true }
                        }));
            menu.AddItem(defaultToggler);
            defaultToggler.ValueChanged += DefaultTogglerOnValueChanged;

            var modifierAllyCounter =
                new MenuItem("modifierAllyCounter", "Modifier ally counter").SetValue(true)
                    .SetTooltip("Will use abilities (shields, heals...) on allies");
            menu.AddItem(modifierAllyCounter);
            modifierAllyCounter.ValueChanged += (sender, args) => ModifierAllyCounter = args.GetNewValue<bool>();
            ModifierAllyCounter = modifierAllyCounter.IsActive();

            var modifierEnemyCounter =
                new MenuItem("modifierEnemyCounter", "Modifier enemy counter").SetValue(true)
                    .SetTooltip("Will use abilities (euls, purges, stuns...) on enemies");
            menu.AddItem(modifierEnemyCounter);
            modifierEnemyCounter.ValueChanged += (sender, args) => ModifierEnemyCounter = args.GetNewValue<bool>();
            ModifierEnemyCounter = modifierEnemyCounter.IsActive();

            var pathfinderEffect =
                new MenuItem("pathfinderEffect", "Pathfinder effect").SetValue(true)
                    .SetTooltip("Show particle effect when your hero is controlled by pathfinder");
            menu.AddItem(pathfinderEffect);
            pathfinderEffect.ValueChanged += (sender, args) => PathfinderEffect = args.GetNewValue<bool>();
            PathfinderEffect = pathfinderEffect.IsActive();

            var blockAbilityUsage =
                new MenuItem("blockPlayerAbilities", "Block ability usage").SetValue(true)
                    .SetTooltip("Abilities will be blocked while evading");
            menu.AddItem(blockAbilityUsage);
            blockAbilityUsage.ValueChanged += (sender, args) => BlockAbilityUsage = args.GetNewValue<bool>();
            BlockAbilityUsage = blockAbilityUsage.IsActive();

            var invisIgnore =
                new MenuItem("invisIgnore", "Ignore counter if invisible").SetValue(false)
                    .SetTooltip("Don't counter enemy abilities if your hero is invisible");
            menu.AddItem(invisIgnore);
            invisIgnore.ValueChanged += (sender, args) => InvisIgnore = args.GetNewValue<bool>();
            InvisIgnore = invisIgnore.IsActive();

            var cancelAnimation =
                new MenuItem("cancelAnimation", "Cancel animation").SetValue(true)
                    .SetTooltip("Cancel cast animation to evade stun ability");
            menu.AddItem(cancelAnimation);
            cancelAnimation.ValueChanged += (sender, args) => CancelAnimation = args.GetNewValue<bool>();
            CancelAnimation = cancelAnimation.IsActive();

            var changer = defaultPriority.GetValue<PriorityChanger>();

            foreach (var priority in
                changer.Dictionary.OrderByDescending(x => x.Value)
                    .Select(x => x.Key)
                    .Where(x => defaultToggler.GetValue<AbilityToggler>().IsEnabled(x)))
            {
                switch (priority)
                {
                    case "item_sheepstick":
                        DefaultPriority.Add(EvadePriority.Disable);
                        break;
                    case "item_cyclone":
                        DefaultPriority.Add(EvadePriority.Counter);
                        break;
                    case "item_blink":
                        DefaultPriority.Add(EvadePriority.Blink);
                        break;
                    case "centaur_stampede":
                        DefaultPriority.Add(EvadePriority.Walk);
                        break;
                }
            }

            //menu.AddItem(mouseEmulation = new MenuItem("mouseEmulation", "Mouse emulation").SetValue(false))
            //    .ValueChanged += (sender, args) =>
            //        {
//.........这里部分代码省略.........

        public async Task AddHeroMenu(Hero hero)
        {
            var heroName = hero.StoredName();
            var heroMenu = new Menu(hero.GetRealName(), heroName, false, heroName, true);

            menu.AddSubMenu(heroMenu);
            heroMenus.Add(hero, heroMenu);

            var key = hero.StoredName();
            if (hero.Equals(myHero))
            {
                key += "myHero";
            }

            var settings = new Menu("Settings", key + "settings");
            heroMenus.First(x => x.Key.Equals(hero)).Value.AddSubMenu(settings);
            await Task.Delay(200);

            var abilities = new MenuItem(key + "generateAbilities", "Generate ability ranges").SetValue(false);
            settings.AddItem(abilities);
            await Task.Delay(200);

            abilities.ValueChanged += async (sender, args) => {
                if (!args.GetNewValue<bool>())
                {
                    args.Process = false;
                    return;
                }
                await AddAbilities(hero);
            };

            if (abilities.IsActive())
            {
                await AddAbilities(hero);
            }

            var items = new MenuItem(key + "generateItems", "Generate item ranges").SetValue(false);
            enabledItemsMenu.Add(hero, items);
            settings.AddItem(items);
            await Task.Delay(200);

            items.ValueChanged += async (sender, args) => {
                if (!args.GetNewValue<bool>())
                {
                    args.Process = false;
                    return;
                }
                await AddAItems(hero);
            };

            if (items.IsActive())
            {
                await AddAItems(hero);
            }

            var attack = new MenuItem(key + "generateAttack", "Generate attack range").SetValue(false);
            settings.AddItem(attack);
            await Task.Delay(200);

            attack.ValueChanged += async (sender, args) => {
                if (!args.GetNewValue<bool>())
                {
                    args.Process = false;
                    return;
                }
                await AddMenuItem(hero, null, Ranges.CustomRange.Attack);
            };

            if (attack.IsActive())
            {
                await AddMenuItem(hero, null, Ranges.CustomRange.Attack);
            }

            var expirience = new MenuItem(key + "generateExpirience", "Generate expirience range").SetValue(false);
            settings.AddItem(expirience);
            await Task.Delay(200);

            expirience.ValueChanged += async (sender, args) => {
                if (!args.GetNewValue<bool>())
                {
                    args.Process = false;
                    return;
                }
                await AddMenuItem(hero, null, Ranges.CustomRange.Expiriece);
            };

            if (expirience.IsActive())
            {
                await AddMenuItem(hero, null, Ranges.CustomRange.Expiriece);
            }
        }

        public async Task AddMenuItem(
            Hero hero,
            Ability ability,
            Ranges.CustomRange customRange = Ranges.CustomRange.None)
        {
            var isItem = ability is Item;
            var abilityName = isItem ? ability.GetDefaultName() : ability?.StoredName();
            var texture = abilityName;
            var menuName = string.Empty;

            switch (customRange)
            {
                case Ranges.CustomRange.Attack:
                    abilityName = "attackRange";
                    menuName = "Attack range";
                    texture = null;
                    break;
                case Ranges.CustomRange.Expiriece:
                    abilityName = "expRange";
                    menuName = "Exp range";
                    texture = null;
                    break;
            }

            if (string.IsNullOrEmpty(abilityName))
            {
                return;
            }

            var key = hero.StoredName() + abilityName;
            if (hero.Equals(myHero))
            {
                key += "myHero";
            }

            var abilityMenu = new Menu(texture == null ? menuName : " ", key, false, texture, true);

            var enable = new MenuItem(key + "enabled", "Enabled").SetValue(false);
            await Task.Delay(100);

            var radiusOnly = new MenuItem(key + "radius", "Damage radius only").SetValue(false);
            await Task.Delay(100);

            var red = new MenuItem(key + "red", "Red").SetValue(new Slider(255, 0, 255));
            await Task.Delay(100);

            var green = new MenuItem(key + "green", "Green").SetValue(new Slider(0, 0, 255));
            await Task.Delay(100);

            var blue = new MenuItem(key + "blue", "Blue").SetValue(new Slider(0, 0, 255));
            await Task.Delay(100);

            enable.ValueChanged += (sender, arg) => {
                var enabled = arg.GetNewValue<bool>();
                abilityMenu.DisplayName = enabled
                                              ? abilityMenu.DisplayName + "*"
                                              : abilityMenu.DisplayName.Replace("*", "");
                OnChange?.Invoke(
                    this,
                    new AbilityEventArgs
                    {
                        Hero = hero,
                        Name = abilityName,
                        Enabled = enabled,
                        Redraw = true
                    });
            };

            radiusOnly.ValueChanged += (sender, args) => {
                OnChange?.Invoke(
                    this,
                    new AbilityEventArgs
                    {
                        Hero = hero,
                        Name = abilityName,
                        Enabled = enable.IsActive(),
                        RadiusOnly = args.GetNewValue<bool>(),
                        Redraw = true
                    });
            };

            red.ValueChanged += (sender, arg) => {
                OnChange?.Invoke(
                    this,
                    new AbilityEventArgs
                    {
                        Hero = hero,
                        Name = abilityName,
                        Red = arg.GetNewValue<Slider>().Value
                    });
            };

            green.ValueChanged += (sender, arg) => {
                OnChange?.Invoke(
                    this,
                    new AbilityEventArgs
                    {
                        Hero = hero,
                        Name = abilityName,
                        Green = arg.GetNewValue<Slider>().Value
//.........这里部分代码省略.........