refactor event schedulers to use explicit game rules

Content.Server/GameTicking/Rules/Components/RandomRuleComponent.cs

@@ -0,0 +1,25 @@
+using Content.Shared.Storage;
+
+namespace Content.Server.GameTicking.Rules.Components;
+
+[RegisterComponent, Access(typeof(RandomRuleSystem))]
+public sealed partial class RandomRuleComponent : Component
+{
+    /// <summary>
+    /// The gamerules that get added at random.
+    /// </summary>
+    [DataField(required: true)]
+    public List<EntitySpawnEntry> SelectableGameRules = new();
+
+    /// <summary>
+    /// The maximum gamerules that get added at a time.
+    /// </summary>
+    [DataField]
+    public int MaxRules = 1;
+
+    /// <summary>
+    /// The minimum gamerules that get added at a time.
+    /// </summary>
+    [DataField]
+    public int MinRules = 1;
+}

Content.Server/GameTicking/Rules/RandomRuleSystem.cs

@@ -0,0 +1,79 @@
+using Content.Server.Administration.Logs;
+using Content.Server.Chat.Managers;
+using Content.Server.GameTicking.Rules.Components;
+using Content.Server.StationEvents;
+using Content.Shared.GameTicking.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Content.Shared.Storage;
+using Content.Server.StationEvents.Components;
+
+namespace Content.Server.GameTicking.Rules;
+
+public sealed class RandomRuleSystem : GameRuleSystem<RandomRuleComponent>
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly IAdminLogManager _adminLogger = default!;
+    [Dependency] private readonly IChatManager _chatManager = default!;
+    [Dependency] private readonly IComponentFactory _compFact = default!;
+    [Dependency] private readonly EventManagerSystem _event = default!;
+
+    private string _ruleCompName = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+    }
+
+    protected override void Added(EntityUid uid, RandomRuleComponent component, GameRuleComponent gameRule, GameRuleAddedEvent args)
+    {
+        var selectedRules = EntitySpawnCollection.GetSpawns(component.SelectableGameRules, _random);
+
+        Random rnd = new Random();
+        int ruleQuant = rnd.Next(component.MinRules, component.MaxRules);
+
+        for (int i = 0; i < ruleQuant; i++)
+        {
+            var availableEvents = _event.AvailableEvents(); // handles the player counts and individual event restrictions, we need to do it each i incase it changes
+            string? slag = null;
+
+            foreach (var rule in selectedRules)
+            {
+                if (selectedRules == null)
+                    return;
+                // If the station is already initialized, just start the rule, otherwise let that happen at the start of round.
+                if (GameTicker.RunLevel <= GameRunLevel.InRound)
+                {
+                    GameTicker.AddGameRule(rule);
+                }
+                else
+                {
+                    _prototypeManager.TryIndex(rule, out var ruleEnt);
+                    if (ruleEnt == null)
+                    {
+                        Log.Warning("The selected random rule is null!");
+                        continue;
+                    }
+
+                    if (ruleEnt.TryGetComponent<StationEventComponent>(out _, _compFact))
+                    {
+                        if (!availableEvents.ContainsKey(ruleEnt))
+                        {
+                            Log.Warning("The selected random rule is not available!");
+                            continue;
+                        }
+                        GameTicker.StartGameRule(rule);
+                    }
+                }
+                slag = rule;
+            }
+
+            // prevents same gamerule twice in one run.
+            if (!string.IsNullOrEmpty(slag))
+            {
+                selectedRules.RemoveAt(selectedRules.IndexOf(slag));
+            }
+        }
+    }
+
+}

Content.Server/StationEvents/BasicStationEventSchedulerSystem.cs

@@ -23,8 +23,9 @@ public sealed class BasicStationEventSchedulerSystem : GameRuleSystem<BasicStati
         [Dependency] private readonly IRobustRandom _random = default!;
         [Dependency] private readonly EventManagerSystem _event = default!;
 
-        public const float MinEventTime = 60 * 3;
-        public const float MaxEventTime = 60 * 10;
+        // someome yell at me if I forget to change this back, I need to test it without dying of old
+        public const float MinEventTime = 60 * 3; // 60 * 3;
+        public const float MaxEventTime = 60 * 10; // 60 * 10;
 
         protected override void Ended(EntityUid uid, BasicStationEventSchedulerComponent component, GameRuleComponent gameRule,
             GameRuleEndedEvent args)
@@ -37,7 +38,7 @@ public override void Update(float frameTime)
         {
             base.Update(frameTime);
 
-            if (!_event.EventsEnabled)
+            if (!_event.EventsEnabled)  // comment for testing
                 return;
 
             var query = EntityQueryEnumerator<BasicStationEventSchedulerComponent, GameRuleComponent>();
@@ -52,7 +53,7 @@ public override void Update(float frameTime)
                     return;
                 }
 
-                _event.RunRandomEvent();
+                _event.RunLimitedEvent(eventScheduler.ScheduledGameRules);
                 ResetTimer(eventScheduler);
             }
         }

Content.Server/StationEvents/Components/BasicStationEventSchedulerComponent.cs

@@ -1,14 +1,22 @@
-namespace Content.Server.StationEvents.Components;
+using Content.Shared.Storage;
+
+namespace Content.Server.StationEvents.Components;
 
 [RegisterComponent, Access(typeof(BasicStationEventSchedulerSystem))]
 public sealed partial class BasicStationEventSchedulerComponent : Component
 {
-    public const float MinimumTimeUntilFirstEvent = 300;
+    public const float MinimumTimeUntilFirstEvent = 300; // Someone yell at me if I dont change this back to 300, I need to test it without dying of old
 
     /// <summary>
     /// How long until the next check for an event runs
     /// </summary>
     /// Default value is how long until first event is allowed
     [ViewVariables(VVAccess.ReadWrite)]
     public float TimeUntilNextEvent = MinimumTimeUntilFirstEvent;
+
+    /// <summary>
+    /// The gamerules that the scheduler can choose from
+    /// </summary>
+    [DataField(required: true)]
+    public List<EntitySpawnEntry> ScheduledGameRules = new();
 }

Content.Server/StationEvents/Components/RampingStationEventSchedulerComponent.cs

@@ -1,4 +1,6 @@
-namespace Content.Server.StationEvents.Components;
+using Content.Shared.Storage;
+
+namespace Content.Server.StationEvents.Components;
 
 [RegisterComponent, Access(typeof(RampingStationEventSchedulerSystem))]
 public sealed partial class RampingStationEventSchedulerComponent : Component
@@ -14,4 +16,10 @@ public sealed partial class RampingStationEventSchedulerComponent : Component
 
     [DataField("timeUntilNextEvent"), ViewVariables(VVAccess.ReadWrite)]
     public float TimeUntilNextEvent;
+
+    /// <summary>
+    /// The gamerules that the scheduler can choose from
+    /// </summary>
+    [DataField(required: true)]
+    public List<EntitySpawnEntry> ScheduledGameRules = new();
 }

Content.Server/StationEvents/EventManagerSystem.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Linq;
 using Content.Server.Chat.Managers;
 using Content.Server.GameTicking;
@@ -7,11 +8,13 @@
 using Robust.Shared.Configuration;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
+using Content.Shared.Storage;
 
 namespace Content.Server.StationEvents;
 
 public sealed class EventManagerSystem : EntitySystem
 {
+    [Dependency] private readonly IComponentFactory _compFac = default!;
     [Dependency] private readonly IConfigurationManager _configurationManager = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
     [Dependency] private readonly IRobustRandom _random = default!;
@@ -44,7 +47,7 @@ public string RunRandomEvent()
         }
 
         var ent = GameTicker.AddGameRule(randomEvent);
-        var str = Loc.GetString("station-event-system-run-event",("eventName", ToPrettyString(ent)));
+        var str = Loc.GetString("station-event-system-run-event", ("eventName", ToPrettyString(ent)));
         _chat.SendAdminAlert(str);
         Log.Info(str);
         return str;
@@ -60,6 +63,71 @@ public string RunRandomEvent()
         return FindEvent(availableEvents);
     }
 
+    /// <summary>
+    /// Randomly runs an event from provided EntitySpawnCollection.
+    /// </summary>
+    public string? RunLimitedEvent(List<EntitySpawnEntry>? limitedEventsList)
+    {
+        if (limitedEventsList != null)
+        {
+            var availableEvents = AvailableEvents(); // handles the player counts and individual event restrictions
+
+            if (availableEvents.Count == 0)
+            {
+                Log.Warning("No events were available to run!");
+                return null;
+            }
+
+            var selectedEvents = EntitySpawnCollection.GetSpawns(limitedEventsList, _random); // storage function for game rules, smh my head.
+            // fuck it though, it works and gives us all the random selection utility we want.
+
+            Log.Info($"Picking from {limitedEventsList.Count} subsetted events");
+
+            var limitedEvents = new Dictionary<EntityPrototype, StationEventComponent>();
+            foreach (var eventid in selectedEvents)
+            {
+                if (!_prototype.TryIndex(eventid, out var eventproto))
+                {
+                    Log.Warning("An event ID has no prototype index!");
+                    continue;
+                }
+
+                if (eventproto.Abstract)
+                    continue;
+
+                if (!eventproto.TryGetComponent<StationEventComponent>(out var stationEvent, _compFac))
+                    continue;
+
+                if (!availableEvents.ContainsKey(eventproto))
+                    continue;
+
+                limitedEvents.Add(eventproto, stationEvent);
+            }
+
+            var randomLimitedEvent = FindEvent(limitedEvents); // this picks the event, It might be better to use the GetSpawns to do it, but that will be a major rebalancing fuck.
+            if (randomLimitedEvent == null)
+            {
+                Log.Warning("The selected random event is null!");
+                return null;
+            }
+
+            if (!_prototype.TryIndex(randomLimitedEvent, out _))
+            {
+                Log.Warning("A requested event is not available!");
+                return null;
+            }
+
+            var ent = GameTicker.AddGameRule(randomLimitedEvent);
+            var str = Loc.GetString("station-event-system-run-event", ("eventName", ToPrettyString(ent)));
+            _chat.SendAdminAlert(str);
+            Log.Info(str);
+            return str;
+        }
+        Log.Warning("A scheduler has requested null as event!");
+        return null;
+    }
+
+
     /// <summary>
     /// Pick a random event from the available events at this time, also considering their weightings.
     /// </summary>

Content.Server/StationEvents/RampingStationEventSchedulerSystem.cs

@@ -1,4 +1,4 @@
-using Content.Server.GameTicking;
+using Content.Server.GameTicking;
 using Content.Server.GameTicking.Rules;
 using Content.Server.GameTicking.Rules.Components;
 using Content.Server.StationEvents.Components;
@@ -63,7 +63,7 @@ public override void Update(float frameTime)
             }
 
             PickNextEventTime(uid, scheduler);
-            _event.RunRandomEvent();
+            _event.RunLimitedEvent(scheduler.ScheduledGameRules);
         }
     }
 

Resources/Prototypes/GameRules/cargo_gifts.yml

@@ -1,3 +1,42 @@
+# Add your new event to this RandomRule if you want it to happen via the basic/ramping schedulers.
+- type: entity
+  parent: BaseGameRule
+  id: RandomCargoGiftsRule
+  components:
+  - type: RandomRule
+    selectableGameRules:
+    # Make the probability sum to 1 or I will remove your fingernails with toothpicks.
+    - id: GiftsPizzaPartySmall
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsPizzaPartyLarge
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsEngineering
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsVendingRestock
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsJanitor
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsMedical
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsSpacingSupplies
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsFireProtection
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsSecurityGuns
+      prob: 0.1
+      orGroup: Gifts
+    - id: GiftsSecurityRiot
+      prob: 0.1
+      orGroup: Gifts
+
 - type: entity
   id: CargoGiftsBase
   parent: BaseGameRule