Gamerule Entities (#15513)

Content.Server/GameTicking/Rules/InactivityTimeRestartRuleSystem.cs

@@ -1,98 +1,109 @@
 using System.Threading;
 using Content.Server.Chat.Managers;
-using Content.Server.GameTicking.Rules.Configurations;
+using Content.Server.GameTicking.Rules.Components;
 using Robust.Server.Player;
 using Timer = Robust.Shared.Timing.Timer;
 
 namespace Content.Server.GameTicking.Rules;
 
-public sealed class InactivityTimeRestartRuleSystem : GameRuleSystem
+public sealed class InactivityTimeRestartRuleSystem : GameRuleSystem<InactivityRuleComponent>
 {
     [Dependency] private readonly IChatManager _chatManager = default!;
     [Dependency] private readonly IPlayerManager _playerManager = default!;
 
-    public override string Prototype => "InactivityTimeRestart";
-
-    private CancellationTokenSource _timerCancel = new();
-
-    public TimeSpan InactivityMaxTime { get; set; } = TimeSpan.FromMinutes(10);
-    public TimeSpan RoundEndDelay { get; set; } = TimeSpan.FromSeconds(10);
-
     public override void Initialize()
     {
         base.Initialize();
 
         SubscribeLocalEvent<GameRunLevelChangedEvent>(RunLevelChanged);
-    }
-
-    public override void Started()
-    {
-        if (Configuration is not InactivityGameRuleConfiguration inactivityConfig)
-            return;
-        InactivityMaxTime = inactivityConfig.InactivityMaxTime;
-        RoundEndDelay = inactivityConfig.RoundEndDelay;
         _playerManager.PlayerStatusChanged += PlayerStatusChanged;
     }
 
-    public override void Ended()
+    public override void Shutdown()
     {
+        base.Shutdown();
         _playerManager.PlayerStatusChanged -= PlayerStatusChanged;
-
-        StopTimer();
     }
 
-    public void RestartTimer()
+    protected override void Ended(EntityUid uid, InactivityRuleComponent component, GameRuleComponent gameRule, GameRuleEndedEvent args)
     {
-        _timerCancel.Cancel();
-        _timerCancel = new CancellationTokenSource();
-        Timer.Spawn(InactivityMaxTime, TimerFired, _timerCancel.Token);
+        base.Ended(uid, component, gameRule, args);
+
+        StopTimer(uid, component);
     }
 
-    public void StopTimer()
+    public void RestartTimer(EntityUid uid, InactivityRuleComponent? component = null)
     {
-        _timerCancel.Cancel();
+        if (!Resolve(uid, ref component))
+            return;
+
+        component.TimerCancel.Cancel();
+        component.TimerCancel = new CancellationTokenSource();
+        Timer.Spawn(component.InactivityMaxTime, () => TimerFired(uid, component), component.TimerCancel.Token);
     }
 
-    private void TimerFired()
+    public void StopTimer(EntityUid uid, InactivityRuleComponent? component = null)
     {
+        if (!Resolve(uid, ref component))
+            return;
+
+        component.TimerCancel.Cancel();
+    }
+
+    private void TimerFired(EntityUid uid, InactivityRuleComponent? component = null)
+    {
+        if (!Resolve(uid, ref component))
+            return;
+
         GameTicker.EndRound(Loc.GetString("rule-time-has-run-out"));
 
-        _chatManager.DispatchServerAnnouncement(Loc.GetString("rule-restarting-in-seconds", ("seconds",(int) RoundEndDelay.TotalSeconds)));
+        _chatManager.DispatchServerAnnouncement(Loc.GetString("rule-restarting-in-seconds", ("seconds",(int) component.RoundEndDelay.TotalSeconds)));
 
-        Timer.Spawn(RoundEndDelay, () => GameTicker.RestartRound());
+        Timer.Spawn(component.RoundEndDelay, () => GameTicker.RestartRound());
     }
 
     private void RunLevelChanged(GameRunLevelChangedEvent args)
     {
-        if (!RuleAdded)
-            return;
-
-        switch (args.New)
+        var query = EntityQueryEnumerator<InactivityRuleComponent, GameRuleComponent>();
+        while (query.MoveNext(out var uid, out var inactivity, out var gameRule))
         {
-            case GameRunLevel.InRound:
-                RestartTimer();
-                break;
-            case GameRunLevel.PreRoundLobby:
-            case GameRunLevel.PostRound:
-                StopTimer();
-                break;
+            if (!GameTicker.IsGameRuleActive(uid, gameRule))
+                return;
+
+            switch (args.New)
+            {
+                case GameRunLevel.InRound:
+                    RestartTimer(uid, inactivity);
+                    break;
+                case GameRunLevel.PreRoundLobby:
+                case GameRunLevel.PostRound:
+                    StopTimer(uid, inactivity);
+                    break;
+            }
         }
     }
 
     private void PlayerStatusChanged(object? sender, SessionStatusEventArgs e)
     {
-        if (GameTicker.RunLevel != GameRunLevel.InRound)
+        var query = EntityQueryEnumerator<InactivityRuleComponent, GameRuleComponent>();
+        while (query.MoveNext(out var uid, out var inactivity, out var gameRule))
         {
-            return;
-        }
+            if (!GameTicker.IsGameRuleActive(uid, gameRule))
+                return;
 
-        if (_playerManager.PlayerCount == 0)
-        {
-            RestartTimer();
-        }
-        else
-        {
-            StopTimer();
+            if (GameTicker.RunLevel != GameRunLevel.InRound)
+            {
+                return;
+            }
+
+            if (_playerManager.PlayerCount == 0)
+            {
+                RestartTimer(uid, inactivity);
+            }
+            else
+            {
+                StopTimer(uid, inactivity);
+            }
         }
     }
 }