Roundstart variation game rules (#24397)

* Raise `StationPostInitEvent` broadcast * Basic variation pass handling * standardize names + rule entities * why does it work like that? * add to defaults * light break variation pass * ent spawn entry * move some stationevent utility functions to gamerule + add one for finding random tile on specified station * forgot how statistics works * powered light variation pass is good now * station tile count function * public method to ensure all solutions (for procedural use before mapinit) * move gamerulesystem utility funcs to partial * ensure all solutions before spilling in puddlesystem. for use when spilling before mapinit * trash & puddle variation passes! * oh yeah * ehh lets live a little * std * utility for game rule check based on comp * entprotoid the trash spawner oops * generalize trash variation * use added instead of started for secret rule * random cleanup * generic replacement variation system * Wall rusting variation rule * account for modifying while enumerating * use localaabb * fix test * minor tweaks * reinforced wall replacer + puddletweaker (cherry picked from commit cc24ba6a317c4bee84ffa1eda8397c255ca92be9)
2026-04-17 13:37:47 +03:00 · 2024-01-31 06:52:35 +01:00
parent aa4c6f9c6a
commit d35e2f39a7
37 changed files with 978 additions and 149 deletions
--- a/Content.Server/GameTicking/Rules/GameRuleSystem.Utility.cs
+++ b/Content.Server/GameTicking/Rules/GameRuleSystem.Utility.cs
@@ -0,0 +1,137 @@
+using System.Diagnostics.CodeAnalysis;
+using Content.Server.GameTicking.Rules.Components;
+using Content.Server.Station.Components;
+using Robust.Shared.Collections;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Random;
+
+namespace Content.Server.GameTicking.Rules;
+
+public abstract partial class GameRuleSystem<T> where T: IComponent
+{
+    protected EntityQueryEnumerator<ActiveGameRuleComponent, T, GameRuleComponent> QueryActiveRules()
+    {
+        return EntityQueryEnumerator<ActiveGameRuleComponent, T, GameRuleComponent>();
+    }
+
+    protected bool TryRoundStartAttempt(RoundStartAttemptEvent ev, string localizedPresetName)
+    {
+        var query = EntityQueryEnumerator<ActiveGameRuleComponent, T, GameRuleComponent>();
+        while (query.MoveNext(out _, out _, out _, out var gameRule))
+        {
+            var minPlayers = gameRule.MinPlayers;
+            if (!ev.Forced && ev.Players.Length < minPlayers)
+            {
+                ChatManager.SendAdminAnnouncement(Loc.GetString("preset-not-enough-ready-players",
+                    ("readyPlayersCount", ev.Players.Length), ("minimumPlayers", minPlayers),
+                    ("presetName", localizedPresetName)));
+                ev.Cancel();
+                continue;
+            }
+
+            if (ev.Players.Length == 0)
+            {
+                ChatManager.DispatchServerAnnouncement(Loc.GetString("preset-no-one-ready"));
+                ev.Cancel();
+            }
+        }
+
+        return !ev.Cancelled;
+    }
+
+    /// <summary>
+    ///     Utility function for finding a random event-eligible station entity
+    /// </summary>
+    protected bool TryGetRandomStation([NotNullWhen(true)] out EntityUid? station, Func<EntityUid, bool>? filter = null)
+    {
+        var stations = new ValueList<EntityUid>(Count<StationEventEligibleComponent>());
+
+        filter ??= _ => true;
+        var query = AllEntityQuery<StationEventEligibleComponent>();
+
+        while (query.MoveNext(out var uid, out _))
+        {
+            if (!filter(uid))
+                continue;
+
+            stations.Add(uid);
+        }
+
+        if (stations.Count == 0)
+        {
+            station = null;
+            return false;
+        }
+
+        // TODO: Engine PR.
+        station = stations[RobustRandom.Next(stations.Count)];
+        return true;
+    }
+
+    protected bool TryFindRandomTile(out Vector2i tile,
+        [NotNullWhen(true)] out EntityUid? targetStation,
+        out EntityUid targetGrid,
+        out EntityCoordinates targetCoords)
+    {
+        tile = default;
+        targetStation = EntityUid.Invalid;
+        targetGrid = EntityUid.Invalid;
+        targetCoords = EntityCoordinates.Invalid;
+        if (TryGetRandomStation(out targetStation))
+        {
+            return TryFindRandomTileOnStation((targetStation.Value, Comp<StationDataComponent>(targetStation.Value)),
+                out tile,
+                out targetGrid,
+                out targetCoords);
+        }
+
+        return false;
+    }
+
+    protected bool TryFindRandomTileOnStation(Entity<StationDataComponent> station,
+        out Vector2i tile,
+        out EntityUid targetGrid,
+        out EntityCoordinates targetCoords)
+    {
+        tile = default;
+        targetCoords = EntityCoordinates.Invalid;
+        targetGrid = EntityUid.Invalid;
+
+        var possibleTargets = station.Comp.Grids;
+        if (possibleTargets.Count == 0)
+        {
+            targetGrid = EntityUid.Invalid;
+            return false;
+        }
+
+        targetGrid = RobustRandom.Pick(possibleTargets);
+
+        if (!TryComp<MapGridComponent>(targetGrid, out var gridComp))
+            return false;
+
+        var found = false;
+        var aabb = gridComp.LocalAABB;
+
+        for (var i = 0; i < 10; i++)
+        {
+            var randomX = RobustRandom.Next((int) aabb.Left, (int) aabb.Right);
+            var randomY = RobustRandom.Next((int) aabb.Bottom, (int) aabb.Top);
+
+            tile = new Vector2i(randomX, randomY);
+            if (_atmosphere.IsTileSpace(targetGrid, Transform(targetGrid).MapUid, tile,
+                    mapGridComp: gridComp)
+                || _atmosphere.IsTileAirBlocked(targetGrid, tile, mapGridComp: gridComp))
+            {
+                continue;
+            }
+
+            found = true;
+            targetCoords = _map.GridTileToLocal(targetGrid, gridComp, tile);
+            break;
+        }
+
+        return found;
+    }
+
+}