добавь в меню пункт отключения раунда, чтобы больше он не начинался пока снова не включить его

using CounterStrikeSharp.API;
using CounterStrikeSharp.API.Core;
using CounterStrikeSharp.API.Modules.Commands;
using CounterStrikeSharp.API.Modules.Menu;
using CounterStrikeSharp.API.Modules.Utils;
using CustomRounds.Rounds;
using Microsoft.Extensions.DependencyInjection;

namespace CustomRounds;

public class CustomRoundsManager
{
    private readonly IServiceProvider _serviceProvider;
    private readonly Plugin _plugin;
    private readonly CustomRoundsTypes _roundTypes;
    private readonly Config<MainConfig> _config;
    private readonly Queue<(string Name, Type Round)> _currentRounds = new();
    private ICustomRound? _currentRound;
    private readonly Dictionary<string, int> _roundCounts = new();
    private bool _roundStarted;
    private bool _warmupEnd;
    
    private CCSGameRules? GameRules => Utilities.FindAllEntitiesByDesignerName<CCSGameRulesProxy>("cs_gamerules").First().GameRules;

    public CustomRoundsManager(IServiceProvider serviceProvider, Plugin plugin, CustomRoundsTypes roundTypes,
        Config<MainConfig> config)
    {
        _serviceProvider = serviceProvider;
        _plugin = plugin;
        _roundTypes = roundTypes;
        _config = config;

        plugin.RegisterListener<Listeners.OnMapStart>(OnMapStart);
        plugin.RegisterEventHandler<EventRoundStart>(EventRoundStart);
        plugin.RegisterEventHandler<EventRoundEnd>(EventRoundEnd);

        plugin.AddCommand("css_cr", "", OnCustomRoundsCommand);
    }

    private void OnCustomRoundsCommand(CCSPlayerController? player, CommandInfo commandinfo)
    {
        if (player is null) return;

        if (_config.Value.Random)
        {
            player.PrintToChat($"[{ChatColors.Blue}CustomRounds\x01] Выбор кастомных раундов в меню отключен!");
            return;
        }

        var menu = new CenterHtmlMenu("Custom Rounds", _plugin);

        foreach (var (name, type) in _roundTypes)
        {
            menu.AddMenuOption(name, (controller, option) =>
            {
                if (_config.Value.Rounds.TryGetValue(name, out var count))
                {
                    _currentRounds.Clear();
                    _roundCounts.Clear();

                    for (int i = 0; i < count; i++)
                    {
                        _currentRounds.Enqueue((name, type));
                    }

                    _roundCounts[name] = count;
                    
                    _warmupEnd = GameRules?.WarmupPeriod == true;
                    if (_warmupEnd)
                    {
                        Server.ExecuteCommand("mp_warmup_end");
                        _warmupEnd = false;
                    }

                    if (_roundStarted && !_warmupEnd)
                    {
                        Server.ExecuteCommand("mp_restartgame 1");
                    }
                }
            });
        }

        menu.Open(player);
    }

    private HookResult EventRoundStart(EventRoundStart @event, GameEventInfo info)
    {
        var gameRules = GameRules;
        if (gameRules is null || gameRules.WarmupPeriod)
            return HookResult.Continue;

        if (!_currentRounds.TryDequeue(out var roundType)) return HookResult.Continue;

        StartRound(roundType.Round);

        _roundStarted = true;

        Server.NextFrame(() => _currentRound?.Start());

        return HookResult.Continue;
    }

    private void StartRound(Type type)
    {
        EndRound();

        _currentRound = (ICustomRound)_serviceProvider.GetRequiredService(type);
    }

    private HookResult EventRoundEnd(EventRoundEnd @event, GameEventInfo info)
    {
        EndRound();

        if (_currentRounds.Count > 0)
        {
            var (name, type) = _currentRounds.Peek();

            if (_roundCounts.TryGetValue(name, out var count) && count > 1)
                _roundCounts[name] = count - 1;
            else
                _currentRounds.Dequeue();

            _currentRound = (ICustomRound)_serviceProvider.GetRequiredService(type);
        }

        return HookResult.Continue;
    }

    public void OnMapStart(string map)
    {
        _roundStarted = false;
        EndRound();
        var roundNames = _config.Value.Rounds.OrderBy(x => Guid.NewGuid());
        foreach (var (key, value) in roundNames)
        {
            var type = _roundTypes[key];
            for (var i = 0; i < value; i++)
            {
                _currentRounds.Enqueue((key, type));
            }
        }
    }

    public void EndRound()
    {
        if (_currentRound is not null)
        {
            _currentRound.End();
            _currentRound = null;
        }
    }
}