Storage system refactor & map init.

* Demonstrated map init working with guns, toolboxes, tool lockers. * Refactored EntityStorage and ServerStorage to have a common interface. * EntityStorage no longer uses ServerStorage PURELY for visuals. Use an appearance visualizer instead.
2019-05-05 18:52:06 +02:00
parent 030f1f2a57
commit e35d5390db
17 changed files with 384 additions and 950 deletions
--- a/Content.Server/GameObjects/Components/Items/Storage/EntityStorageComponent.cs
+++ b/Content.Server/GameObjects/Components/Items/Storage/EntityStorageComponent.cs
@@ -0,0 +1,194 @@
+using Content.Server.GameObjects.EntitySystems;
+using Robust.Server.GameObjects.Components.Container;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.GameObjects.Components;
+using Robust.Shared.Interfaces.Network;
+using Robust.Shared.Maths;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+using System.Linq;
+using Content.Server.GameObjects.Components.Items.Storage;
+using Content.Shared.GameObjects.Components.Storage;
+using Robust.Server.GameObjects;
+
+namespace Content.Server.GameObjects.Components
+{
+    public class EntityStorageComponent : Component, IAttackHand, IStorageComponent
+    {
+        public override string Name => "EntityStorage";
+
+        private int StorageCapacityMax;
+        private bool IsCollidableWhenOpen;
+        private Container Contents;
+        private IEntityQuery entityQuery;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            Contents = ContainerManagerComponent.Ensure<Container>(nameof(EntityStorageComponent), Owner);
+            entityQuery = new IntersectingEntityQuery(Owner);
+        }
+
+        public override void ExposeData(ObjectSerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref StorageCapacityMax, "Capacity", 30);
+            serializer.DataField(ref IsCollidableWhenOpen, "IsCollidableWhenOpen", false);
+        }
+
+        [ViewVariables]
+        public bool Open { get; private set; }
+
+        public bool AttackHand(AttackHandEventArgs eventArgs)
+        {
+            if (Open)
+            {
+                CloseStorage();
+            }
+            else
+            {
+                OpenStorage();
+            }
+            return true;
+        }
+
+        private void CloseStorage()
+        {
+            Open = false;
+            var entities = Owner.EntityManager.GetEntities(entityQuery);
+            var count = 0;
+            foreach (var entity in entities)
+            {
+                if (!AddToContents(entity))
+                {
+                    continue;
+                }
+                count++;
+                if (count >= StorageCapacityMax)
+                {
+                    break;
+                }
+            }
+            ModifyComponents();
+        }
+
+        private void OpenStorage()
+        {
+            Open = true;
+            EmptyContents();
+            ModifyComponents();
+        }
+
+        private void ModifyComponents()
+        { 
+            if (Owner.TryGetComponent<ICollidableComponent>(out var collidableComponent))
+            {
+                collidableComponent.CollisionEnabled = IsCollidableWhenOpen || !Open;
+            }
+
+            if (Owner.TryGetComponent<PlaceableSurfaceComponent>(out var placeableSurfaceComponent))
+            {
+                placeableSurfaceComponent.IsPlaceable = Open;
+            }
+
+            if (Owner.TryGetComponent(out AppearanceComponent appearance))
+            {
+                appearance.SetData(StorageVisuals.Open, Open);
+            }
+        }
+
+        private bool AddToContents(IEntity entity)
+        {
+            var collidableComponent = Owner.GetComponent<ICollidableComponent>();
+            if(entity.TryGetComponent<ICollidableComponent>(out var entityCollidableComponent))
+            {
+                if(collidableComponent.WorldAABB.Size.X < entityCollidableComponent.WorldAABB.Size.X
+                    || collidableComponent.WorldAABB.Size.Y < entityCollidableComponent.WorldAABB.Size.Y)
+                {
+                    return false;
+                }
+
+                if (collidableComponent.WorldAABB.Left > entityCollidableComponent.WorldAABB.Left)
+                {
+                    entity.Transform.WorldPosition += new Vector2(collidableComponent.WorldAABB.Left - entityCollidableComponent.WorldAABB.Left, 0);
+                }
+                else if (collidableComponent.WorldAABB.Right < entityCollidableComponent.WorldAABB.Right)
+                {
+                    entity.Transform.WorldPosition += new Vector2(collidableComponent.WorldAABB.Right - entityCollidableComponent.WorldAABB.Right, 0);
+                }
+                if (collidableComponent.WorldAABB.Bottom > entityCollidableComponent.WorldAABB.Bottom)
+                {
+                    entity.Transform.WorldPosition += new Vector2(0, collidableComponent.WorldAABB.Bottom - entityCollidableComponent.WorldAABB.Bottom);
+                }
+                else if (collidableComponent.WorldAABB.Top < entityCollidableComponent.WorldAABB.Top)
+                {
+                    entity.Transform.WorldPosition += new Vector2(0, collidableComponent.WorldAABB.Top - entityCollidableComponent.WorldAABB.Top);
+                }
+            }
+            if (Contents.CanInsert(entity))
+            {
+                Contents.Insert(entity);
+                return true;
+            }
+            return false;
+        }
+
+        private void EmptyContents()
+        {
+            foreach (var contained in Contents.ContainedEntities.ToArray())
+            {
+                Contents.Remove(contained);
+                contained.Transform.WorldPosition = Owner.Transform.WorldPosition;
+            }
+        }
+
+        public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
+        {
+            base.HandleMessage(message, netChannel, component);
+
+            switch (message)
+            {
+                case RelayMovementEntityMessage msg:
+                    if (msg.Entity.HasComponent<HandsComponent>())
+                    {
+                        OpenStorage();
+                    }
+                    break;
+            }
+        }
+
+        public bool Remove(IEntity entity)
+        {
+            return Contents.CanRemove(entity);
+        }
+
+        public bool Insert(IEntity entity)
+        {
+            // Trying to add while open just dumps it on the ground below us.
+            if (Open)
+            {
+                entity.Transform.WorldPosition = Owner.Transform.WorldPosition;
+                return true;
+            }
+
+            return Contents.Insert(entity);
+        }
+
+        public bool CanInsert(IEntity entity)
+        {
+            if (Open)
+            {
+                return true;
+            }
+
+            if (Contents.ContainedEntities.Count >= StorageCapacityMax)
+            {
+                return false;
+            }
+
+            return Contents.CanInsert(entity);
+        }
+    }
+}
--- a/Content.Server/GameObjects/Components/Items/Storage/Fill/ToolLockerFillComponent.cs
+++ b/Content.Server/GameObjects/Components/Items/Storage/Fill/ToolLockerFillComponent.cs
@@ -0,0 +1,92 @@
+using System;
+using Robust.Server.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+
+namespace Content.Server.GameObjects.Components.Items.Storage.Fill
+{
+    internal sealed class ToolLockerFillComponent : Component, IMapInit
+    {
+        public override string Name => "ToolLockerFill";
+
+#pragma warning disable 649
+        [Dependency] private readonly IEntityManager _entityManager;
+#pragma warning restore 649
+
+        void IMapInit.MapInit()
+        {
+            var storage = Owner.GetComponent<IStorageComponent>();
+            var random = new Random(DateTime.Now.GetHashCode() ^ Owner.Uid.GetHashCode());
+
+            void Spawn(string prototype)
+            {
+                storage.Insert(_entityManager.SpawnEntity(prototype));
+            }
+
+            if (random.Prob(0.4f))
+            {
+                Spawn("HazardVestClothing");
+            }
+
+            if (random.Prob(0.7f))
+            {
+                Spawn("FlashlightLantern");
+            }
+
+            if (random.Prob(0.7f))
+            {
+                Spawn("Screwdriver");
+            }
+
+            if (random.Prob(0.7f))
+            {
+                Spawn("Wrench");
+            }
+
+            if (random.Prob(0.7f))
+            {
+                Spawn("Welder");
+            }
+
+            if (random.Prob(0.7f))
+            {
+                Spawn("Crowbar");
+            }
+
+            if (random.Prob(0.7f))
+            {
+                Spawn("Wirecutter");
+            }
+
+            if (random.Prob(0.2f))
+            {
+                Spawn("Multitool");
+            }
+
+            if (random.Prob(0.2f))
+            {
+                Spawn("UtilityBeltClothing");
+            }
+
+            if (random.Prob(0.05f))
+            {
+                Spawn("YellowGloves");
+            }
+
+            if (random.Prob(0.4f))
+            {
+                Spawn("HelmetEngineering");
+            }
+
+            for (var i = 0; i < 3; i++)
+            {
+                if (random.Prob(0.3f))
+                {
+                    Spawn("CableStack");
+                }
+            }
+        }
+    }
+}
--- a/Content.Server/GameObjects/Components/Items/Storage/Fill/ToolboxElectricalFillComponent.cs
+++ b/Content.Server/GameObjects/Components/Items/Storage/Fill/ToolboxElectricalFillComponent.cs
@@ -0,0 +1,38 @@
+using System;
+using Robust.Server.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+
+namespace Content.Server.GameObjects.Components.Items.Storage.Fill
+{
+    internal sealed class ToolboxElectricalFillComponent : Component, IMapInit
+    {
+        public override string Name => "ToolboxElectricalFill";
+
+#pragma warning disable 649
+        [Dependency] private readonly IEntityManager _entityManager;
+#pragma warning restore 649
+
+        void IMapInit.MapInit()
+        {
+            var storage = Owner.GetComponent<IStorageComponent>();
+            var random = new Random(DateTime.Now.GetHashCode() ^ Owner.Uid.GetHashCode());
+
+            void Spawn(string prototype)
+            {
+                storage.Insert(_entityManager.SpawnEntity(prototype));
+            }
+
+            Spawn("Screwdriver");
+            Spawn("Crowbar");
+            Spawn("Wirecutter");
+            Spawn("CableStack");
+            Spawn("CableStack");
+
+            // 5% chance for a pair of fancy insulated gloves, else just a third cable coil.
+            Spawn(random.Prob(0.05f) ? "YellowGloves" : "CableStack");
+        }
+    }
+}
--- a/Content.Server/GameObjects/Components/Items/Storage/IStorageComponent.cs
+++ b/Content.Server/GameObjects/Components/Items/Storage/IStorageComponent.cs
@@ -0,0 +1,11 @@
+using Robust.Shared.Interfaces.GameObjects;
+
+namespace Content.Server.GameObjects.Components.Items.Storage
+{
+    public interface IStorageComponent
+    {
+        bool Remove(IEntity entity);
+        bool Insert(IEntity entity);
+        bool CanInsert(IEntity entity);
+    }
+}
--- a/Content.Server/GameObjects/Components/Items/Storage/ServerStorageComponent.cs
+++ b/Content.Server/GameObjects/Components/Items/Storage/ServerStorageComponent.cs
@@ -18,6 +18,7 @@ using Robust.Shared.GameObjects.EntitySystemMessages;
 using Robust.Shared.Interfaces.Map;
 using Robust.Shared.ViewVariables;
 using Content.Server.GameObjects.Components;
+using Content.Server.GameObjects.Components.Items.Storage;
 using Robust.Server.GameObjects.EntitySystemMessages;

 namespace Content.Server.GameObjects
@@ -25,7 +26,7 @@ namespace Content.Server.GameObjects
    /// <summary>
    /// Storage component for containing entities within this one, matches a UI on the client which shows stored entities
    /// </summary>
-    public class ServerStorageComponent : SharedStorageComponent, IAttackBy, IUse, IActivate
+    public class ServerStorageComponent : SharedStorageComponent, IAttackBy, IUse, IActivate, IStorageComponent
    {
 #pragma warning disable 649
        [Dependency] private readonly IMapManager _mapManager;
@@ -40,20 +41,6 @@ namespace Content.Server.GameObjects
        private int StorageCapacityMax = 10000;
        public HashSet<IPlayerSession> SubscribedSessions = new HashSet<IPlayerSession>();

-        [ViewVariables(VVAccess.ReadWrite)]
-        public bool Open
-        {
-            get => _open;
-            set
-            {
-                if (_open == value)
-                    return;
-
-                _open = value;
-                Dirty();
-            }
-        }
-
        public override void Initialize()
        {
            base.Initialize();
@@ -61,12 +48,6 @@ namespace Content.Server.GameObjects
            storage = ContainerManagerComponent.Ensure<Container>("storagebase", Owner);
        }

-        /// <inheritdoc />
-        public override ComponentState GetComponentState()
-        {
-            return new StorageComponentState(_open);
-        }
-
        public override void ExposeData(ObjectSerializer serializer)
        {
            base.ExposeData(serializer);
@@ -243,7 +224,10 @@ namespace Content.Server.GameObjects

        private void UpdateDoorState()
        {
-            Open = SubscribedSessions.Count != 0;
+            if (Owner.TryGetComponent(out AppearanceComponent appearance))
+            {
+                appearance.SetData(StorageVisuals.Open, SubscribedSessions.Count != 0);
+            }
        }

        public void HandlePlayerSessionChangeEvent(object obj, SessionStatusEventArgs SSEA)