Shared subfloor system (#3590)

* Shared subfloor system

Will also cull the broadphase for server a lot.

* Nullable subfloor

* Snapgrid nullable

* Actually use ComponentDependency

Co-authored-by: Metal Gear Sloth <metalgearsloth@gmail.com>

Content.Shared/GameObjects/Components/SubFloorHideComponent.cs

@@ -0,0 +1,72 @@
+#nullable enable
+using Robust.Shared.GameObjects;
+using Robust.Shared.Log;
+
+namespace Content.Shared.GameObjects.Components
+{
+    /// <summary>
+    /// Simple component that automatically hides the sibling
+    /// <see cref="ISpriteComponent" /> when the tile it's on is not a sub floor
+    /// (plating).
+    /// </summary>
+    /// <seealso cref="P:Content.Shared.Maps.ContentTileDefinition.IsSubFloor" />
+    [RegisterComponent]
+    public sealed class SubFloorHideComponent : Component
+    {
+        [ComponentDependency(nameof(OnAddSnapGrid))]
+        private SnapGridComponent? _snapGridComponent;
+
+        /// <inheritdoc />
+        public override string Name => "SubFloorHide";
+
+        /// <inheritdoc />
+        protected override void Startup()
+        {
+            base.Startup();
+
+            Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new SubFloorHideDirtyEvent(Owner));
+        }
+
+        /// <inheritdoc />
+        protected override void Shutdown()
+        {
+            base.Shutdown();
+
+            if (Owner.Transform.Running == false)
+                return;
+
+            if (_snapGridComponent != null)
+            {
+                _snapGridComponent.OnPositionChanged -= SnapGridOnPositionChanged;
+            }
+
+            Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new SubFloorHideDirtyEvent(Owner));
+        }
+
+        private void OnAddSnapGrid()
+        {
+            if (_snapGridComponent == null)
+            {
+                // Shouldn't happen but allows us to use nullables. OnPositionChanged needs to be componentbus anyway.
+                Logger.Error("Snapgrid was null for subfloor {Owner}");
+                return;
+            }
+            _snapGridComponent.OnPositionChanged += SnapGridOnPositionChanged;
+        }
+
+        private void SnapGridOnPositionChanged()
+        {
+            Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new SubFloorHideDirtyEvent(Owner));
+        }
+    }
+
+    internal sealed class SubFloorHideDirtyEvent : EntityEventArgs
+    {
+        public IEntity Sender { get; }
+
+        public SubFloorHideDirtyEvent(IEntity sender)
+        {
+            Sender = sender;
+        }
+    }
+}

Content.Shared/GameObjects/EntitySystems/SubFloorHideSystem.cs

@@ -0,0 +1,108 @@
+#nullable enable
+using Content.Shared.GameObjects.Components;
+using Content.Shared.Maps;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Shared.GameObjects.EntitySystems
+{
+    /// <summary>
+    ///     Entity system backing <see cref="SubFloorHideComponent"/>.
+    /// </summary>
+    public class SubFloorHideSystem : EntitySystem
+    {
+        [Dependency] private readonly IMapManager _mapManager = default!;
+        [Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
+
+        private bool _showAll;
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool ShowAll
+        {
+            get => _showAll;
+            set
+            {
+                if (_showAll == value) return;
+                _showAll = value;
+
+                UpdateAll();
+            }
+        }
+
+        private void UpdateAll()
+        {
+            foreach (var comp in EntityManager.ComponentManager.EntityQuery<SubFloorHideComponent>(true))
+            {
+                if (!_mapManager.TryGetGrid(comp.Owner.Transform.GridID, out var grid)) return;
+
+                var snapPos = comp.Owner.GetComponent<SnapGridComponent>();
+                UpdateTile(grid, snapPos.Position);
+            }
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            IoCManager.InjectDependencies(this);
+
+            _mapManager.GridChanged += MapManagerOnGridChanged;
+            _mapManager.TileChanged += MapManagerOnTileChanged;
+
+            SubscribeLocalEvent<SubFloorHideDirtyEvent>(HandleDirtyEvent);
+        }
+
+        private void HandleDirtyEvent(SubFloorHideDirtyEvent ev)
+        {
+            if (!_mapManager.TryGetGrid(ev.Sender.Transform.GridID, out var grid))
+            {
+                return;
+            }
+
+            var indices = grid.WorldToTile(ev.Sender.Transform.WorldPosition);
+            UpdateTile(grid, indices);
+        }
+
+        private void MapManagerOnTileChanged(object? sender, TileChangedEventArgs e)
+        {
+            UpdateTile(_mapManager.GetGrid(e.NewTile.GridIndex), e.NewTile.GridIndices);
+        }
+
+        private void MapManagerOnGridChanged(object? sender, GridChangedEventArgs e)
+        {
+            foreach (var modified in e.Modified)
+            {
+                UpdateTile(e.Grid, modified.position);
+            }
+        }
+
+        private void UpdateTile(IMapGrid grid, Vector2i position)
+        {
+            var tile = grid.GetTileRef(position);
+            var tileDef = (ContentTileDefinition) _tileDefinitionManager[tile.Tile.TypeId];
+            foreach (var snapGridComponent in grid.GetSnapGridCell(position, SnapGridOffset.Center))
+            {
+                var entity = snapGridComponent.Owner;
+                if (!entity.TryGetComponent(out SubFloorHideComponent? subFloorComponent))
+                {
+                    continue;
+                }
+
+                // Show sprite
+                if (entity.TryGetComponent(out SharedSpriteComponent? spriteComponent))
+                {
+                    spriteComponent.Visible = ShowAll || !subFloorComponent.Running || tileDef.IsSubFloor;
+                }
+
+                // So for collision all we care about is that the component is running.
+                if (entity.TryGetComponent(out PhysicsComponent? physicsComponent))
+                {
+                    physicsComponent.CanCollide = !subFloorComponent.Running;
+                }
+            }
+        }
+    }
+}