CatStation/Content.Server/StationEvents/BasicStationEventSchedulerSystem.cs

using System.Linq;
using Content.Server.Administration;
using Content.Server.GameTicking;
using Content.Server.StationEvents.Components;
using Content.Shared.Administration;
using Content.Shared.EntityTable;
using Content.Shared.GameTicking.Components;
using Content.Shared.GameTicking.Rules;
using JetBrains.Annotations;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Toolshed;

namespace Content.Server.StationEvents
{
    /// <summary>
    ///     The basic event scheduler rule, loosely based off of /tg/ events, which most
    ///     game presets use.
    /// </summary>
    [UsedImplicitly]
    public sealed partial class BasicStationEventSchedulerSystem : GameRuleSystem<BasicStationEventSchedulerComponent>
    {
        [Dependency] private IRobustRandom _random = default!;
        [Dependency] private EventManagerSystem _event = default!;

        protected override void Started(Entity<BasicStationEventSchedulerComponent, GameRuleComponent> ent, ref GameRuleStartedEvent args)
        {
            // A little starting variance so schedulers dont all proc at once.
            ent.Comp1.TimeUntilNextEvent = RobustRandom.NextFloat(ent.Comp1.MinimumTimeUntilFirstEvent, ent.Comp1.MinimumTimeUntilFirstEvent + ent.Comp1.MaximumSpanUntilFirstEvent);
        }

        protected override void Ended(Entity<BasicStationEventSchedulerComponent> rule, ref GameRuleEndedEvent args)
        {
            rule.Comp.TimeUntilNextEvent = rule.Comp.MinimumTimeUntilFirstEvent;
        }

        public override void Update(float frameTime)
        {
            base.Update(frameTime);

            if (!_event.EventsEnabled)
                return;

            var query = EntityQueryEnumerator<BasicStationEventSchedulerComponent, GameRuleComponent>();
            while (query.MoveNext(out var uid, out var eventScheduler, out var gameRule))
            {
                if (!GameTicker.IsGameRuleActive((uid, gameRule)))
                    continue;

                if (eventScheduler.TimeUntilNextEvent > 0)
                {
                    eventScheduler.TimeUntilNextEvent -= frameTime;
                    continue;
                }

                _event.RunRandomEvent(eventScheduler.ScheduledGameRules);
                ResetTimer(eventScheduler);
            }
        }

        /// <summary>
        /// Reset the event timer once the event is done.
        /// </summary>
        private void ResetTimer(BasicStationEventSchedulerComponent component)
        {
            component.TimeUntilNextEvent = component.MinMaxEventTiming.Next(_random);
        }
    }

    [ToolshedCommand, AdminCommand(AdminFlags.Debug)]
    public sealed class StationEventCommand : ToolshedCommand
    {
        private EventManagerSystem? _stationEvent;
        private EntityTableSystem? _entityTable;
        private IComponentFactory? _compFac;
        private IRobustRandom? _random;
        private IPrototypeManager? _protoMan;

        /// <summary>
        ///     Estimates the expected number of times an event will run over the course of X rounds, taking into account weights and
        ///     how many events are expected to run over a given timeframe for a given playercount by repeatedly simulating rounds.
        ///     Effectively /100 (if you put 100 rounds) = probability an event will run per round.
        /// </summary>
        /// <remarks>
        ///     This isn't perfect. Code path eventually goes into <see cref="EventManagerSystem.CanRun"/>, which requires
        ///     state from <see cref="ServerGameTicker"/>. As a result, you should probably just run this locally and not doing
        ///     a real round (it won't pollute the state, but it will get contaminated by previously ran events in the actual round)
        ///     and things like `MaxOccurrences` and `ReoccurrenceDelay` won't be respected.
        ///
        ///     I consider these to not be that relevant to the analysis here though (and I don't want most uses of them
        ///     to even exist) so I think it's fine.
        /// </remarks>
        [CommandImplementation("simulate")]
        public IEnumerable<(string, float)> Simulate([CommandArgument] EntProtoId eventSchedulerProto, [CommandArgument] int rounds, [CommandArgument] int playerCount, [CommandArgument] float roundEndMean, [CommandArgument] float roundEndStdDev)
        {
            _stationEvent ??= GetSys<EventManagerSystem>();
            _entityTable ??= GetSys<EntityTableSystem>();
            _compFac ??= IoCManager.Resolve<IComponentFactory>();
            _random ??= IoCManager.Resolve<IRobustRandom>();
            _protoMan ??= IoCManager.Resolve<IPrototypeManager>();

            var occurrences = new Dictionary<string, int>();

            foreach (var ev in _stationEvent.AllEvents())
            {
                occurrences.Add(ev.Key.ID, 0);
            }

            var eventScheduler = _protoMan.Index(eventSchedulerProto);

            if (!eventScheduler.TryComp<BasicStationEventSchedulerComponent>(out var basicScheduler, _compFac))
            {
                return occurrences.Select(p => (p.Key, (float)p.Value)).OrderByDescending(p => p.Item2);
            }

            var compMinMax = basicScheduler.MinMaxEventTiming; // we gotta do this since we cant execute on comp w/o an ent.

            for (var i = 0; i < rounds; i++)
            {
                var curTime = TimeSpan.Zero;
                var randomEndTime = _random.NextGaussian(roundEndMean, roundEndStdDev) * 60; // Its in minutes, should probably be a better time format once we get that in toolshed like [hh:mm:ss]
                if (randomEndTime <= 0)
                    continue;

                while (curTime.TotalSeconds < randomEndTime)
                {
                    // sim an event
                    curTime += TimeSpan.FromSeconds(compMinMax.Next(_random));

                    if (!_stationEvent.TryBuildLimitedEvents(basicScheduler.ScheduledGameRules,
                            out var selectedEvents,
                            currentTime: curTime,
                            playerCount: playerCount))
                    {
                        continue; // doesnt break because maybe the time is preventing events being available.
                    }

                    if (_stationEvent.FindEvent(selectedEvents.Value) is not { } ev)
                        continue;

                    occurrences[ev] += 1;
                }
            }

            return occurrences.Select(p => (p.Key, (float)p.Value)).OrderByDescending(p => p.Item2);
        }

        [CommandImplementation("lsprob")]
        public IEnumerable<(string, double)> LsProb([CommandArgument] EntProtoId eventSchedulerProto)
        {
            _compFac ??= IoCManager.Resolve<IComponentFactory>();
            _stationEvent ??= GetSys<EventManagerSystem>();
            _protoMan ??= IoCManager.Resolve<IPrototypeManager>();

            var eventScheduler = _protoMan.Index(eventSchedulerProto);

            if (!eventScheduler.TryComp<BasicStationEventSchedulerComponent>(out var basicScheduler, _compFac))
                yield break;

            var sortedEvents
                = _stationEvent.ListLimitedEvents(basicScheduler.ScheduledGameRules)
                .OrderBy(x => -x.Item2);

            foreach (var eventProb in sortedEvents)
            {
                yield return eventProb;
            }
        }

        [CommandImplementation("lsprobtheoretical")]
        public IEnumerable<(EntProtoId, double)> LsProbTime([CommandArgument] EntProtoId eventSchedulerProto, [CommandArgument] int playerCount, [CommandArgument] float time)
        {
            _compFac ??= IoCManager.Resolve<IComponentFactory>();
            _stationEvent ??= GetSys<EventManagerSystem>();
            _protoMan ??= IoCManager.Resolve<IPrototypeManager>();

            var eventScheduler = _protoMan.Index(eventSchedulerProto);

            if (!eventScheduler.TryComp<BasicStationEventSchedulerComponent>(out var basicScheduler, _compFac))
                yield break;

            var timemins = time * 60;
            var theoryTime = TimeSpan.Zero + TimeSpan.FromSeconds(timemins);

            var sortedEvents
                = _stationEvent.ListLimitedEvents(basicScheduler.ScheduledGameRules,
                        currentTime: theoryTime,
                        playerCount: playerCount)
                    .OrderBy(x => -x.Item2);

            foreach (var eventProb in sortedEvents)
            {
                yield return eventProb;
            }
        }

        [CommandImplementation("prob")]
        public double Prob([CommandArgument] EntProtoId eventSchedulerProto, [CommandArgument] string eventId)
        {
            _compFac ??= IoCManager.Resolve<IComponentFactory>();
            _stationEvent ??= GetSys<EventManagerSystem>();
            _protoMan ??= IoCManager.Resolve<IPrototypeManager>();

            var eventScheduler = _protoMan.Index(eventSchedulerProto);

            if (!eventScheduler.TryComp<BasicStationEventSchedulerComponent>(out var basicScheduler, _compFac))
                return 0f;

            foreach (var (proto, prob) in _stationEvent.ListLimitedEvents(basicScheduler.ScheduledGameRules))
            {
                if (eventSchedulerProto != proto)
                    continue;

                return prob;
            }

            return 0f;
        }
    }
}