Station maps (#13027)

Content.Server/Pinpointer/NavMapSystem.cs

@@ -0,0 +1,158 @@
+using Content.Shared.Pinpointer;
+using Content.Shared.Tag;
+using Robust.Shared.GameStates;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Components;
+
+namespace Content.Server.Pinpointer;
+
+/// <summary>
+/// Handles data to be used for in-grid map displays.
+/// </summary>
+public sealed class NavMapSystem : SharedNavMapSystem
+{
+    [Dependency] private readonly TagSystem _tags = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<AnchorStateChangedEvent>(OnAnchorChange);
+        SubscribeLocalEvent<ReAnchorEvent>(OnReAnchor);
+        SubscribeLocalEvent<NavMapComponent, ComponentGetState>(OnGetState);
+        SubscribeLocalEvent<NavMapComponent, GridSplitEvent>(OnNavMapSplit);
+    }
+
+    private void OnNavMapSplit(EntityUid uid, NavMapComponent component, ref GridSplitEvent args)
+    {
+        var physicsQuery = GetEntityQuery<PhysicsComponent>();
+        var tagQuery = GetEntityQuery<TagComponent>();
+        var gridQuery = GetEntityQuery<MapGridComponent>();
+
+        foreach (var grid in args.NewGrids)
+        {
+            var newComp = EnsureComp<NavMapComponent>(grid);
+            RefreshGrid(newComp, gridQuery.GetComponent(grid), physicsQuery, tagQuery);
+        }
+
+        RefreshGrid(component, gridQuery.GetComponent(uid), physicsQuery, tagQuery);
+    }
+
+    private void RefreshGrid(NavMapComponent component, MapGridComponent grid, EntityQuery<PhysicsComponent> physicsQuery, EntityQuery<TagComponent> tagQuery)
+    {
+        component.Chunks.Clear();
+
+        var tiles = grid.GetAllTilesEnumerator();
+
+        while (tiles.MoveNext(out var tile))
+        {
+            var chunkOrigin = SharedMapSystem.GetChunkIndices(tile.Value.GridIndices, ChunkSize);
+
+            if (!component.Chunks.TryGetValue(chunkOrigin, out var chunk))
+            {
+                chunk = new NavMapChunk(chunkOrigin);
+            }
+
+            RefreshTile(grid, component, chunk, tile.Value.GridIndices, physicsQuery, tagQuery);
+        }
+    }
+
+    private void OnGetState(EntityUid uid, NavMapComponent component, ref ComponentGetState args)
+    {
+        var data = new Dictionary<Vector2i, int>(component.Chunks.Count);
+        foreach (var (index, chunk) in component.Chunks)
+        {
+            data.Add(index, chunk.TileData);
+        }
+
+        // TODO: Diffs
+        args.State = new NavMapComponentState()
+        {
+            TileData = data,
+        };
+    }
+
+    private void OnReAnchor(ref ReAnchorEvent ev)
+    {
+        if (TryComp<MapGridComponent>(ev.OldGrid, out var oldGrid) &&
+            TryComp<NavMapComponent>(ev.OldGrid, out var navMap))
+        {
+            var chunkOrigin = SharedMapSystem.GetChunkIndices(ev.TilePos, ChunkSize);
+
+            if (navMap.Chunks.TryGetValue(chunkOrigin, out var chunk))
+            {
+                var physicsQuery = GetEntityQuery<PhysicsComponent>();
+                var tagQuery = GetEntityQuery<TagComponent>();
+                RefreshTile(oldGrid, navMap, chunk, ev.TilePos, physicsQuery, tagQuery);
+            }
+        }
+
+        HandleAnchor(ev.Xform);
+    }
+
+    private void OnAnchorChange(ref AnchorStateChangedEvent ev)
+    {
+        HandleAnchor(ev.Transform);
+    }
+
+    private void HandleAnchor(TransformComponent xform)
+    {
+        if (!TryComp<NavMapComponent>(xform.GridUid, out var navMap) ||
+            !TryComp<MapGridComponent>(xform.GridUid, out var grid))
+            return;
+
+        var tile = grid.LocalToTile(xform.Coordinates);
+        var chunkOrigin = SharedMapSystem.GetChunkIndices(tile, ChunkSize);
+        var physicsQuery = GetEntityQuery<PhysicsComponent>();
+        var tagQuery = GetEntityQuery<TagComponent>();
+
+        if (!navMap.Chunks.TryGetValue(chunkOrigin, out var chunk))
+        {
+            chunk = new NavMapChunk(chunkOrigin);
+            navMap.Chunks[chunkOrigin] = chunk;
+        }
+
+        RefreshTile(grid, navMap, chunk, tile, physicsQuery, tagQuery);
+    }
+
+    private void RefreshTile(MapGridComponent grid, NavMapComponent component, NavMapChunk chunk, Vector2i tile,
+        EntityQuery<PhysicsComponent> physicsQuery,
+        EntityQuery<TagComponent> tagQuery)
+    {
+        var relative = SharedMapSystem.GetChunkRelative(tile, ChunkSize);
+
+        var existing = chunk.TileData;
+        var flag = GetFlag(relative);
+
+        chunk.TileData &= ~flag;
+
+        var enumerator = grid.GetAnchoredEntitiesEnumerator(tile);
+        // TODO: Use something to get convex poly.
+
+        while (enumerator.MoveNext(out var ent))
+        {
+            if (!physicsQuery.TryGetComponent(ent, out var body) ||
+                !body.CanCollide ||
+                !body.Hard ||
+                body.BodyType != BodyType.Static ||
+                (!_tags.HasTag(ent.Value, "Wall", tagQuery) &&
+                 !_tags.HasTag(ent.Value, "Window", tagQuery)))
+            {
+                continue;
+            }
+
+            chunk.TileData |= flag;
+            break;
+        }
+
+        if (chunk.TileData == 0)
+        {
+            component.Chunks.Remove(chunk.Origin);
+        }
+
+        if (existing == chunk.TileData)
+            return;
+
+        Dirty(component);
+    }
+}

Content.Server/Pinpointer/PinpointerSystem.cs

@@ -6,7 +6,7 @@ using Content.Server.Shuttles.Events;
 
 namespace Content.Server.Pinpointer
 {
-    public sealed class ServerPinpointerSystem : SharedPinpointerSystem
+    public sealed class PinpointerSystem : SharedPinpointerSystem
     {
         [Dependency] private readonly SharedTransformSystem _transform = default!;
 

Content.Server/Pinpointer/StationMapComponent.cs

@@ -0,0 +1,17 @@
+namespace Content.Server.Pinpointer;
+
+[RegisterComponent]
+public sealed class StationMapComponent : Component
+{
+
+}
+
+/// <summary>
+/// Added to an entity using station map so when its parent changes we reset it.
+/// </summary>
+[RegisterComponent]
+public sealed class StationMapUserComponent : Component
+{
+    [DataField("mapUid")]
+    public EntityUid Map;
+}

Content.Server/Pinpointer/StationMapSystem.cs

@@ -0,0 +1,43 @@
+using Content.Shared.Interaction.Events;
+using Content.Shared.Pinpointer;
+using Robust.Server.GameObjects;
+
+namespace Content.Server.Pinpointer;
+
+public sealed class StationMapSystem : EntitySystem
+{
+    [Dependency] private readonly UserInterfaceSystem _ui = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<StationMapUserComponent, EntParentChangedMessage>(OnUserParentChanged);
+        SubscribeLocalEvent<StationMapComponent, BoundUIOpenedEvent>(OnStationMapOpened);
+        SubscribeLocalEvent<StationMapComponent, BoundUIClosedEvent>(OnStationMapClosed);
+    }
+
+    private void OnStationMapClosed(EntityUid uid, StationMapComponent component, BoundUIClosedEvent args)
+    {
+        if (!Equals(args.UiKey, StationMapUiKey.Key) || args.Session.AttachedEntity == null)
+            return;
+
+        RemCompDeferred<StationMapUserComponent>(args.Session.AttachedEntity.Value);
+    }
+
+    private void OnUserParentChanged(EntityUid uid, StationMapUserComponent component, ref EntParentChangedMessage args)
+    {
+        if (TryComp<ActorComponent>(uid, out var actor))
+        {
+            _ui.TryClose(component.Map, StationMapUiKey.Key, actor.PlayerSession);
+        }
+    }
+
+    private void OnStationMapOpened(EntityUid uid, StationMapComponent component, BoundUIOpenedEvent args)
+    {
+        if (args.Session.AttachedEntity == null)
+            return;
+
+        var comp = EnsureComp<StationMapUserComponent>(args.Session.AttachedEntity.Value);
+        comp.Map = uid;
+    }
+}