Exemple #1
0
        public override void Update(float frameTime)
        {
            base.Update(frameTime);

            if (!RuleStarted)
            {
                return;
            }

            if (_timeUntilNextEvent > 0)
            {
                _timeUntilNextEvent -= frameTime;
                return;
            }

            // No point hammering this trying to find events if none are available
            var stationEvent = FindEvent(AvailableEvents());

            if (stationEvent == null ||
                !_prototype.TryIndex <GameRulePrototype>(stationEvent.Id, out var proto))
            {
                return;
            }

            GameTicker.AddGameRule(proto);
            ResetTimer();
            _sawmill.Info($"Started event {proto.ID}. Next event in {_timeUntilNextEvent} seconds");
        }
    public AlertsFramePresenter()
    {
        // This is a lot easier than a factory
        IoCManager.InjectDependencies(this);

        _logger = _logMan.GetSawmill("alerts");
        _logger.Info("Constructor");

        _alertsFrame = new AlertsUI(_chatManager);
        _userInterfaceManager.StateRoot.AddChild((AlertsUI)_alertsFrame);

        // This is required so that if we load after the system is initialized, we can bind to it immediately
        if (_systemManager.TryGetEntitySystem <ClientAlertsSystem>(out var alertsSystem))
        {
            SystemBindingChanged(alertsSystem);
        }

        _systemManager.SystemLoaded   += OnSystemLoaded;
        _systemManager.SystemUnloaded += OnSystemUnloaded;

        _alertsFrame.AlertPressed += OnAlertPressed;

        // initially populate the frame if system is available
        var alerts = alertsSystem?.ActiveAlerts;

        if (alerts != null)
        {
            SystemOnSyncAlerts(alertsSystem, alerts);
        }
    }
            public void Info(string message, params object[] args)
            {
                if (Level > LogLevel.Info)
                {
                    return;
                }

                _sawmill.Info(message, args);
            }
    /// <inheritdoc />
    public void Dispose()
    {
        _logger.Info("Destructor");
        _userInterfaceManager.StateRoot.RemoveChild((AlertsUI)_alertsFrame);
        _alertsFrame.Dispose();
        _alertsFrame = null !;

        SystemBindingChanged(null);
        _systemManager.SystemLoaded   -= OnSystemLoaded;
        _systemManager.SystemUnloaded -= OnSystemUnloaded;
    }
        /// <summary>
        ///     Loads groups from the yaml file. Existing groups will not be overwritten.
        ///     Call Clear() if you want to empty the container first.
        /// </summary>
        public void LoadGroups()
        {
            if (_resMan.UserData.Exists(_groupPath))
            {
                _logger.Info($"Loading permGroups from UserData: {_groupPath}");
                var file = _resMan.UserData.Open(_groupPath, FileMode.Open);
                LoadGroupYamlStream(file);
                return;
            }

            if (_resMan.TryContentFileRead(_groupPath, out var memoryStream))
            {
                _logger.Info($"Loading permGroups from content: {_groupPath}");
                LoadGroupYamlStream(memoryStream);
                return;
            }

            _logger.Warning($"Permission group file not found: {_groupPath}");
        }
    public async Task AddNote(IPlayerSession createdBy, Guid player, string message)
    {
        _sawmill.Info($"Player {createdBy.Name} added note with message {message}");

        _systems.TryGetEntitySystem(out GameTicker? ticker);
        int?round     = ticker == null || ticker.RoundId == 0 ? null : ticker.RoundId;
        var createdAt = DateTime.UtcNow;
        var noteId    = await _db.AddAdminNote(round, player, message, createdBy.UserId, createdAt);

        var note = new SharedAdminNote(
            noteId,
            round,
            message,
            createdBy.Name,
            createdBy.Name,
            createdAt,
            createdAt
            );

        NoteAdded?.Invoke(note);
    }