diff --git a/Content.Client/Content.Client.csproj b/Content.Client/Content.Client.csproj
index 3bb92d3a11..9027e22d6f 100644
--- a/Content.Client/Content.Client.csproj
+++ b/Content.Client/Content.Client.csproj
@@ -69,6 +69,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="EntryPoint.cs" />
+    <Compile Include="GameObjects\Components\Storage\ClientStorageComponent.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="GameObjects\Components\Items\ClientHandsComponent.cs" />
     <Compile Include="GameObjects\Components\Doors\ClientDoorComponent.cs" />
diff --git a/Content.Client/EntryPoint.cs b/Content.Client/EntryPoint.cs
index 4fa5e40b21..4a9ecf740c 100644
--- a/Content.Client/EntryPoint.cs
+++ b/Content.Client/EntryPoint.cs
@@ -1,4 +1,5 @@
 using Content.Client.GameObjects;
+using Content.Client.GameObjects.Components.Storage;
 using Content.Client.Interfaces.GameObjects;
 using SS14.Shared.ContentPack;
 using SS14.Shared.Interfaces.GameObjects;
@@ -36,8 +37,11 @@ namespace Content.Client
             factory.RegisterIgnore("Projectile");
             factory.RegisterIgnore("MeleeWeapon");
 
+            factory.RegisterIgnore("Storeable");
+
             factory.Register<HandsComponent>();
             factory.RegisterReference<HandsComponent, IHandsComponent>();
+            factory.Register<ClientStorageComponent>();
 
             factory.Register<ClientDoorComponent>();
         }
diff --git a/Content.Client/GameObjects/Components/Items/ClientHandsComponent.cs b/Content.Client/GameObjects/Components/Items/ClientHandsComponent.cs
index e6aca6bea2..1762ea3e5b 100644
--- a/Content.Client/GameObjects/Components/Items/ClientHandsComponent.cs
+++ b/Content.Client/GameObjects/Components/Items/ClientHandsComponent.cs
@@ -57,5 +57,10 @@ namespace Content.Client.GameObjects
         {
             SendNetworkMessage(new ClientChangedHandMsg(index));
         }
+
+        public void UseActiveHand()
+        {
+            SendNetworkMessage(new ActivateInhandMsg());
+        }
     }
 }
diff --git a/Content.Client/GameObjects/Components/Storage/ClientStorageComponent.cs b/Content.Client/GameObjects/Components/Storage/ClientStorageComponent.cs
new file mode 100644
index 0000000000..ecebe16f24
--- /dev/null
+++ b/Content.Client/GameObjects/Components/Storage/ClientStorageComponent.cs
@@ -0,0 +1,200 @@
+using Content.Shared.GameObjects;
+using Content.Shared.GameObjects.Components.Storage;
+using SS14.Client.GameObjects;
+using SS14.Client.UserInterface;
+using SS14.Client.UserInterface.Controls;
+using SS14.Client.UserInterface.CustomControls;
+using SS14.Shared.GameObjects;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.Network;
+using SS14.Shared.IoC;
+using SS14.Shared.Log;
+using SS14.Shared.Maths;
+using SS14.Shared.Utility;
+using System;
+using System.Collections.Generic;
+
+namespace Content.Client.GameObjects.Components.Storage
+{
+    /// <summary>
+    /// Client version of item storage containers, contains a UI which displays stored entities and their size
+    /// </summary>
+    public class ClientStorageComponent : SharedStorageComponent
+    {
+        private Dictionary<EntityUid, int> StoredEntities { get; set; } = new Dictionary<EntityUid, int>();
+        private int StorageSizeUsed;
+        private int StorageCapacityMax;
+        private StorageWindow Window;
+
+        public override void OnAdd()
+        {
+            base.OnAdd();
+
+            Window = new StorageWindow()
+            { StorageEntity = this};
+        }
+
+        public override void OnRemove()
+        {
+            Window.Dispose();
+
+            base.OnRemove();
+        }
+
+        public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
+        {
+            switch (message)
+            {
+                //Updates what we are storing for the UI
+                case StorageHeldItemsMessage msg:
+                    HandleStorageMessage(msg);
+                    break;
+                //Opens the UI
+                case OpenStorageUIMessage msg:
+                    OpenUI();
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Copies received values from server about contents of storage container
+        /// </summary>
+        /// <param name="storagestate"></param>
+        private void HandleStorageMessage(StorageHeldItemsMessage storagestate)
+        {
+            StoredEntities = new Dictionary<EntityUid, int>(storagestate.StoredEntities);
+            StorageSizeUsed = storagestate.StorageSizeUsed;
+            StorageCapacityMax = storagestate.StorageSizeMax;
+            Window.BuildEntityList();
+        }
+
+        /// <summary>
+        /// Opens the storage UI
+        /// </summary>
+        private void OpenUI()
+        {
+            Window.AddToScreen();
+            Window.Open();
+        }
+
+        /// <summary>
+        /// Function for clicking one of the stored entity buttons in the UI, tells server to remove that entity
+        /// </summary>
+        /// <param name="entityuid"></param>
+        private void Interact(EntityUid entityuid)
+        {
+            SendNetworkMessage(new RemoveEntityMessage(entityuid));
+        }
+
+        /// <summary>
+        /// GUI class for client storage component
+        /// </summary>
+        private class StorageWindow : SS14Window
+        {
+            private Control VSplitContainer;
+            private VBoxContainer EntityList;
+            private Label Information;
+            public ClientStorageComponent StorageEntity;
+
+            protected override ResourcePath ScenePath => new ResourcePath("/Scenes/Storage/Storage.tscn");
+            
+            protected override void Initialize()
+            {
+
+                base.Initialize();
+
+                HideOnClose = true;
+
+                // Get all the controls.
+                VSplitContainer = Contents.GetChild("VSplitContainer");
+                EntityList = VSplitContainer.GetChild("ListScrollContainer").GetChild<VBoxContainer>("EntityList");
+                Information = VSplitContainer.GetChild<Label>("Information");
+            }
+
+            /// <summary>
+            /// Loops through stored entities creating buttons for each, updates information labels
+            /// </summary>
+            public void BuildEntityList()
+            {
+                EntityList.DisposeAllChildren();
+                
+                var storagelist = StorageEntity.StoredEntities;
+
+                foreach (var entityuid in storagelist)
+                {
+
+                    var entity = IoCManager.Resolve<IEntityManager>().GetEntity(entityuid.Key);
+
+                    var button = new EntityButton()
+                    {
+                        EntityuID = entityuid.Key
+                    };
+                    var container = button.GetChild("HBoxContainer");
+                    button.ActualButton.OnToggled += OnItemButtonToggled;
+                    //Name and Size labels set
+                    container.GetChild<Label>("Name").Text = entity.Name;
+                    container.GetChild<Control>("Control").GetChild<Label>("Size").Text = string.Format("{0}", entityuid.Value);
+
+                    //Gets entity sprite and assigns it to button texture
+                    if (entity.TryGetComponent(out SpriteComponent sprite))
+                    {
+                        var tex = sprite.CurrentSprite;
+                        var rect = container.GetChild("TextureWrap").GetChild<TextureRect>("TextureRect");
+
+                        if (tex != null)
+                        {
+                            rect.Texture = tex;
+                            // Copypasted but replaced with 32 dunno if good
+                            var scale = (float)32 / tex.Height;
+                            rect.Scale = new Vector2(scale, scale);
+                        }
+                        else
+                        {
+                            rect.Dispose();
+                        }
+                    }
+
+                    EntityList.AddChild(button);
+                }
+
+                //Sets information about entire storage container current capacity
+                if(StorageEntity.StorageCapacityMax != 0)
+                {
+                    Information.Text = String.Format("Items: {0}, Stored: {1}/{2}", storagelist.Count, StorageEntity.StorageSizeUsed, StorageEntity.StorageCapacityMax);
+                }
+                else
+                {
+                    Information.Text = String.Format("Items: {0}", storagelist.Count);
+                }
+            }
+
+            /// <summary>
+            /// Function assigned to button toggle which removes the entity from storage
+            /// </summary>
+            /// <param name="args"></param>
+            private void OnItemButtonToggled(BaseButton.ButtonToggledEventArgs args)
+            {
+                var control = (EntityButton)args.Button.Parent;
+                args.Button.Pressed = false;
+                StorageEntity.Interact(control.EntityuID);
+            }
+        }
+
+        /// <summary>
+        /// Button created for each entity that represents that item in the storage UI, with a texture, and name and size label
+        /// </summary>
+        private class EntityButton : Control
+        {
+            public EntityUid EntityuID { get; set; }
+            public Button ActualButton { get; private set; }
+
+            protected override ResourcePath ScenePath => new ResourcePath("/Scenes/Storage/StorageEntity.tscn");
+
+            protected override void Initialize()
+            {
+                base.Initialize();
+                ActualButton = GetChild<Button>("Button");
+            }
+        }
+    }
+}
diff --git a/Content.Client/UserInterface/HandsGui.cs b/Content.Client/UserInterface/HandsGui.cs
index d851fab8dd..a49be93ddf 100644
--- a/Content.Client/UserInterface/HandsGui.cs
+++ b/Content.Client/UserInterface/HandsGui.cs
@@ -1,4 +1,5 @@
-using Content.Client.Interfaces.GameObjects;
+using Content.Client.GameObjects;
+using Content.Client.Interfaces.GameObjects;
 using SS14.Client.GameObjects;
 using SS14.Client.Graphics;
 using SS14.Client.Graphics.Drawing;
@@ -11,6 +12,7 @@ using SS14.Client.UserInterface;
 using SS14.Client.UserInterface.Controls;
 using SS14.Shared.Interfaces.GameObjects;
 using SS14.Shared.IoC;
+using SS14.Shared.Log;
 using SS14.Shared.Maths;
 
 namespace Content.Client.UserInterface
@@ -63,16 +65,8 @@ namespace Content.Client.UserInterface
 
         protected override void Draw(DrawingHandle handle)
         {
-            if (_playerManager?.LocalPlayer == null)
-            {
+            if (!TryGetHands(out IHandsComponent hands))
                 return;
-            }
-
-            IEntity entity = _playerManager.LocalPlayer.ControlledEntity;
-            if (entity == null || !entity.TryGetComponent<IHandsComponent>(out var hands))
-            {
-                return;
-            }
 
             var leftActive = hands.ActiveIndex == "left";
 
@@ -98,20 +92,35 @@ namespace Content.Client.UserInterface
             }
         }
 
-        public void UpdateHandIcons()
+        /// <summary>
+        /// Gets the hands component controling this gui, returns true if successful and false if failure
+        /// </summary>
+        /// <param name="hands"></param>
+        /// <returns></returns>
+        private bool TryGetHands(out IHandsComponent hands)
         {
-            UpdateDraw();
-            if (_playerManager?.LocalPlayer.ControlledEntity == null)
+            hands = null;
+            if (_playerManager?.LocalPlayer == null)
             {
-                return;
+                return false;
             }
 
             IEntity entity = _playerManager.LocalPlayer.ControlledEntity;
-            if (!entity.TryGetComponent<IHandsComponent>(out var hands))
+            if (entity == null || !entity.TryGetComponent(out hands))
             {
-                return;
+                return false;
             }
 
+            return true;
+        }
+
+        public void UpdateHandIcons()
+        {
+            UpdateDraw();
+
+            if (!TryGetHands(out IHandsComponent hands))
+                return;
+
             var left = hands.GetEntity("left");
             var right = hands.GetEntity("right");
 
@@ -146,14 +155,21 @@ namespace Content.Client.UserInterface
 
         private void SendSwitchHandTo(string index)
         {
-            IEntity entity = _playerManager.LocalPlayer.ControlledEntity;
-            if (!entity.TryGetComponent<IHandsComponent>(out var hands))
-            {
+            if (!TryGetHands(out IHandsComponent hands))
                 return;
-            }
+
             hands.SendChangeHand(index);
         }
 
+        private void UseActiveHand()
+        {
+            if (!TryGetHands(out IHandsComponent hands))
+                return;
+
+            //Todo: remove hands interface, so weird
+            ((HandsComponent)hands).UseActiveHand();
+        }
+
         protected override bool HasPoint(Vector2 point)
         {
             return handL.Contains((Vector2i)point) || handR.Contains((Vector2i)point);
@@ -163,18 +179,28 @@ namespace Content.Client.UserInterface
         {
             base.MouseDown(args);
 
-            if (args.Button != Mouse.Button.Right)
-            {
-                return;
-            }
+            var lefthandcontains = handL.Contains((Vector2i)args.RelativePosition);
+            var righthandcontains = handR.Contains((Vector2i)args.RelativePosition);
 
-            if (handL.Contains((Vector2i)args.RelativePosition))
+            if (args.Button == Mouse.Button.Left)
             {
-                SendSwitchHandTo("left");
+                if (!TryGetHands(out IHandsComponent hands))
+                    return;
+
+                if ((hands.ActiveIndex == "left" && lefthandcontains)
+                    || (hands.ActiveIndex == "right" && righthandcontains))
+                    UseActiveHand();
             }
-            if (handR.Contains((Vector2i)args.RelativePosition))
+            else if (args.Button == Mouse.Button.Right)
             {
-                SendSwitchHandTo("right");
+                if (lefthandcontains)
+                {
+                    SendSwitchHandTo("left");
+                }
+                if (righthandcontains)
+                {
+                    SendSwitchHandTo("right");
+                }
             }
         }
 
diff --git a/Content.Server/Content.Server.csproj b/Content.Server/Content.Server.csproj
index 001f2bb0a2..4f91c37435 100644
--- a/Content.Server/Content.Server.csproj
+++ b/Content.Server/Content.Server.csproj
@@ -74,6 +74,8 @@
     <Compile Include="GameObjects\Components\Interactable\Tools\WelderComponent.cs" />
     <Compile Include="GameObjects\Components\Interactable\Tools\WirecutterComponent.cs" />
     <Compile Include="GameObjects\Components\Interactable\Tools\WrenchComponent.cs" />
+    <Compile Include="GameObjects\Components\Items\Storage\StoreableComponent.cs" />
+    <Compile Include="GameObjects\Components\Items\Storage\ServerStorageComponent.cs" />
     <Compile Include="GameObjects\Components\Power\PowerStorageComponent.cs" />
     <Compile Include="GameObjects\Components\Power\PowerGeneratorComponent.cs" />
     <Compile Include="GameObjects\Components\Power\PowerDevice.cs" />
@@ -93,7 +95,7 @@
     <Compile Include="Interfaces\GameObjects\Components\Items\IItemComponent.cs" />
     <Compile Include="GameObjects\Components\Items\ServerHandsComponent.cs" />
     <Compile Include="GameObjects\Components\Items\InventoryComponent.cs" />
-    <Compile Include="GameObjects\Components\Items\ItemComponent.cs" />
+    <Compile Include="GameObjects\Components\Items\Storage\ItemComponent.cs" />
     <Compile Include="GameObjects\Components\Damage\DamageableComponent.cs" />
     <Compile Include="GameObjects\Components\Damage\DestructibleComponent.cs" />
     <Compile Include="GameObjects\Components\Damage\ResistanceSet.cs" />
diff --git a/Content.Server/EntryPoint.cs b/Content.Server/EntryPoint.cs
index af22a9e22d..7dcded677f 100644
--- a/Content.Server/EntryPoint.cs
+++ b/Content.Server/EntryPoint.cs
@@ -55,9 +55,11 @@ namespace Content.Server
             factory.Register<InventoryComponent>();
             factory.RegisterReference<InventoryComponent, IInventoryComponent>();
 
+            factory.Register<StoreableComponent>();
             factory.Register<ItemComponent>();
             factory.RegisterReference<ItemComponent, IItemComponent>();
-            
+            factory.RegisterReference<ItemComponent, StoreableComponent>();
+
             factory.Register<DamageableComponent>();
             factory.Register<DestructibleComponent>();
             factory.Register<TemperatureComponent>();
@@ -83,6 +85,8 @@ namespace Content.Server
             factory.Register<ProjectileWeaponComponent>();
             factory.Register<ProjectileComponent>();
             factory.Register<MeleeWeaponComponent>();
+
+            factory.Register<ServerStorageComponent>();
         }
 
         /// <inheritdoc />
diff --git a/Content.Server/GameObjects/Components/Items/ServerHandsComponent.cs b/Content.Server/GameObjects/Components/Items/ServerHandsComponent.cs
index 59d3ed7715..c75d3335b3 100644
--- a/Content.Server/GameObjects/Components/Items/ServerHandsComponent.cs
+++ b/Content.Server/GameObjects/Components/Items/ServerHandsComponent.cs
@@ -1,10 +1,15 @@
 using System;
 using System.Collections.Generic;
+using Content.Server.GameObjects.EntitySystems;
 using Content.Server.Interfaces.GameObjects;
 using Content.Shared.GameObjects;
 using SS14.Server.Interfaces.GameObjects;
+using SS14.Server.Interfaces.Player;
 using SS14.Shared.GameObjects;
 using SS14.Shared.Input;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.Network;
+using SS14.Shared.IoC;
 using SS14.Shared.Utility;
 using YamlDotNet.RepresentationModel;
 
@@ -81,6 +86,8 @@ namespace Content.Server.GameObjects
             return slot.Item;
         }
 
+        public IItemComponent GetActiveHand => GetHand(ActiveIndex);
+
         /// <summary>
         ///     Enumerates over the hand keys, returning the active hand first.
         /// </summary>
@@ -233,19 +240,40 @@ namespace Content.Server.GameObjects
             ActiveIndex = orderedHands[index];
         }
 
-        public override void HandleMessage(object owner, ComponentMessage message)
+        public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
         {
-            base.HandleMessage(owner, message);
-
+            base.HandleMessage(message, netChannel, component);
+            
             switch (message)
             {
                 case ClientChangedHandMsg msg:
-                    if (HasHand(msg.Index))
-                        ActiveIndex = msg.Index;
-                    break;
+                    {
+                        var playerMan = IoCManager.Resolve<IPlayerManager>();
+                        var session = playerMan.GetSessionByChannel(netChannel);
+                        var playerentity = session.AttachedEntity;
 
+                        if (playerentity == Owner && HasHand(msg.Index))
+                            ActiveIndex = msg.Index;
+                        break;
+                    }
+
+                case ActivateInhandMsg msg:
+                    {
+                        var playerMan = IoCManager.Resolve<IPlayerManager>();
+                        var session = playerMan.GetSessionByChannel(netChannel);
+                        var playerentity = session.AttachedEntity;
+                        var used = GetActiveHand?.Owner;
+
+                        if (playerentity == Owner && used != null)
+                        {
+                            InteractionSystem.TryUseInteraction(Owner, used);
+                        }
+                        break;
+                    }
+
+                //Boundkeychangedmsg only works for the player entity
                 case BoundKeyChangedMsg msg:
-                    if(msg.State != BoundKeyState.Down)
+                    if (msg.State != BoundKeyState.Down)
                         return;
                     switch (msg.Function)
                     {
@@ -255,6 +283,13 @@ namespace Content.Server.GameObjects
                         case BoundKeyFunctions.Drop:
                             Drop(ActiveIndex);
                             break;
+                        case BoundKeyFunctions.ActivateItemInHand:
+                            var used = GetActiveHand?.Owner;
+                            if(used != null)
+                            {
+                                InteractionSystem.TryUseInteraction(Owner, used);
+                            }
+                            break;
                     }
                     break;
             }
diff --git a/Content.Server/GameObjects/Components/Items/ItemComponent.cs b/Content.Server/GameObjects/Components/Items/Storage/ItemComponent.cs
similarity index 92%
rename from Content.Server/GameObjects/Components/Items/ItemComponent.cs
rename to Content.Server/GameObjects/Components/Items/Storage/ItemComponent.cs
index 1ca94df250..a14b3376d7 100644
--- a/Content.Server/GameObjects/Components/Items/ItemComponent.cs
+++ b/Content.Server/GameObjects/Components/Items/Storage/ItemComponent.cs
@@ -1,12 +1,11 @@
 using Content.Server.Interfaces.GameObjects;
 using SS14.Server.Interfaces.GameObjects;
-using SS14.Shared.GameObjects;
 using System;
 using SS14.Shared.Interfaces.GameObjects;
 
 namespace Content.Server.GameObjects
 {
-    public class ItemComponent : Component, IItemComponent, EntitySystems.IAttackHand
+    public class ItemComponent : StoreableComponent, IItemComponent, EntitySystems.IAttackHand
     {
         public override string Name => "Item";
 
diff --git a/Content.Server/GameObjects/Components/Items/Storage/ServerStorageComponent.cs b/Content.Server/GameObjects/Components/Items/Storage/ServerStorageComponent.cs
new file mode 100644
index 0000000000..5da41c7f0b
--- /dev/null
+++ b/Content.Server/GameObjects/Components/Items/Storage/ServerStorageComponent.cs
@@ -0,0 +1,184 @@
+using Content.Server.GameObjects.EntitySystems;
+using Content.Server.Interfaces.GameObjects;
+using Content.Shared.GameObjects.Components.Storage;
+using SS14.Server.GameObjects;
+using SS14.Server.GameObjects.Components.Container;
+using SS14.Server.Interfaces.Player;
+using SS14.Shared.GameObjects;
+using SS14.Shared.GameObjects.Serialization;
+using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.Network;
+using SS14.Shared.IoC;
+using SS14.Shared.Log;
+using System.Collections.Generic;
+
+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
+    {
+        private Container storage;
+
+        private int StorageUsed = 0;
+        private int StorageCapacityMax = 10000;
+
+        public override void OnAdd()
+        {
+            base.OnAdd();
+
+            storage = Container.Create("storagebase", Owner);
+        }
+
+        public override void ExposeData(EntitySerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref StorageCapacityMax, "Capacity", 10000);
+        }
+
+        /// <summary>
+        /// Removes from the storage container and updates the stored value
+        /// </summary>
+        /// <param name="toremove"></param>
+        /// <returns></returns>
+        bool Remove(IEntity toremove)
+        {
+            if(storage.Remove(toremove))
+            {
+                StorageUsed -= toremove.GetComponent<StoreableComponent>().ObjectSize;
+                UpdateClientInventory();
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Inserts into the storage container
+        /// </summary>
+        /// <param name="toinsert"></param>
+        /// <returns></returns>
+        bool Insert(IEntity toinsert)
+        {
+            if(CanInsert(toinsert) && storage.Insert(toinsert))
+            {
+                StorageUsed += toinsert.GetComponent<StoreableComponent>().ObjectSize;
+                UpdateClientInventory();
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Verifies the object can be inserted by checking if it is storeable and if it keeps under the capacity limit
+        /// </summary>
+        /// <param name="toinsert"></param>
+        /// <returns></returns>
+        bool CanInsert(IEntity toinsert)
+        {
+            if(toinsert.TryGetComponent(out StoreableComponent store))
+            {
+                if (store.ObjectSize <= (StorageCapacityMax - StorageUsed))
+                    return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Inserts storeable entities into this storage container if possible, otherwise return to the hand of the user
+        /// </summary>
+        /// <param name="user"></param>
+        /// <param name="attackwith"></param>
+        /// <returns></returns>
+        bool IAttackby.Attackby(IEntity user, IEntity attackwith)
+        {
+            var hands = user.GetComponent<HandsComponent>();
+            //Check that we can drop the item from our hands first otherwise we obviously cant put it inside
+            if(hands.Drop(hands.ActiveIndex))
+            {
+                var inserted = Insert(attackwith);
+                if (inserted)
+                {
+                    return true;
+                }
+                else
+                {
+                    //Return the object to the hand since its too big or something like that
+                    hands.PutInHand(attackwith.GetComponent<IItemComponent>());
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Sends a message to open the storage UI
+        /// </summary>
+        /// <param name="user"></param>
+        /// <returns></returns>
+        bool IUse.UseEntity(IEntity user)
+        {
+            SendNetworkMessage(new OpenStorageUIMessage());
+            return false;
+        }
+
+        /// <summary>
+        /// Updates the storage UI on all clients telling them of the entities stored in this container
+        /// </summary>
+        private void UpdateClientInventory()
+        {
+            Dictionary<EntityUid, int> storedentities = new Dictionary<EntityUid, int>();
+            foreach (var entities in storage.ContainedEntities)
+            {
+                storedentities.Add(entities.Uid, entities.GetComponent<StoreableComponent>().ObjectSize);
+            }
+            SendNetworkMessage(new StorageHeldItemsMessage(storedentities, StorageUsed, StorageCapacityMax));
+        }
+
+        /// <summary>
+        /// Receives messages to remove entities from storage, verifies the player can do them,
+        /// and puts the removed entity in hand or on the ground
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="netChannel"></param>
+        /// <param name="component"></param>
+        public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
+        {
+            base.HandleMessage(message, netChannel, component);
+
+            switch (message)
+            {
+
+                case RemoveEntityMessage msg:
+                    var playerMan = IoCManager.Resolve<IPlayerManager>();
+                    var session = playerMan.GetSessionByChannel(netChannel);
+                    var playerentity = session.AttachedEntity;
+
+                    var ourtransform = Owner.GetComponent<TransformComponent>();
+                    var playertransform = playerentity.GetComponent<TransformComponent>();
+
+                    if (playertransform.LocalPosition.InRange(ourtransform.LocalPosition, 2)
+                        && (ourtransform.IsMapTransform || playertransform.ContainsEntity(ourtransform)))
+                    {
+                        var remove = (RemoveEntityMessage)message;
+                        var entity = IoCManager.Resolve<IEntityManager>().GetEntity(remove.EntityUid);
+                        if (entity != null && storage.Contains(entity))
+                        {
+                            Remove(entity);
+                            UpdateClientInventory();
+
+                            var item = entity.GetComponent<IItemComponent>();
+                            if (item != null && playerentity.TryGetComponent(out HandsComponent hands))
+                            {
+                                if (hands.PutInHand(item))
+                                    return;
+                            }
+
+                            entity.GetComponent<TransformComponent>().WorldPosition = Owner.GetComponent<TransformComponent>().WorldPosition;
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+}
diff --git a/Content.Server/GameObjects/Components/Items/Storage/StoreableComponent.cs b/Content.Server/GameObjects/Components/Items/Storage/StoreableComponent.cs
new file mode 100644
index 0000000000..a55ad62dec
--- /dev/null
+++ b/Content.Server/GameObjects/Components/Items/Storage/StoreableComponent.cs
@@ -0,0 +1,37 @@
+using SS14.Shared.GameObjects;
+using SS14.Shared.GameObjects.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Server.GameObjects
+{
+    public class StoreableComponent : Component
+    {
+        public override string Name => "Storeable";
+
+        public int ObjectSize = 0;
+
+        public override void ExposeData(EntitySerializer serializer)
+        {
+            base.ExposeData(serializer);
+
+            serializer.DataField(ref ObjectSize, "Size", 1);
+        }
+    }
+
+    /// <summary>
+    /// Enum for the storage capacity of various containers
+    /// </summary>
+    public enum ReferenceSizes
+    {
+        Wallet = 4,
+        Pocket = 12,
+        Box = 24,
+        Toolbox = 60,
+        Backpack = 100,
+        NoStoring = 9999
+    }
+}
diff --git a/Content.Server/GameObjects/EntitySystems/InteractionSystem.cs b/Content.Server/GameObjects/EntitySystems/InteractionSystem.cs
index 5b94fe8232..625bf8d307 100644
--- a/Content.Server/GameObjects/EntitySystems/InteractionSystem.cs
+++ b/Content.Server/GameObjects/EntitySystems/InteractionSystem.cs
@@ -148,32 +148,36 @@ namespace Content.Server.GameObjects.EntitySystems
             {
                 return;
             }
-            var item = hands.GetHand(hands.ActiveIndex)?.Owner;
+            var item = hands.GetActiveHand?.Owner;
 
 
+            if (!MobCanInteract(player))
+                return;
             //TODO: Mob status code that allows or rejects interactions based on current mob status
             //Check if client should be able to see that object to click on it in the first place, prevent using locaters by firing a laser or something
 
-            //Off entity click handling
-            if (attacked == null)
+            
+            //Clicked on empty space behavior, try using ranged attack
+            if (attacked == null && item != null)
             {
-                if(item != null)
-                {
-                    //AFTERATTACK: Check if we clicked on an empty location, if so the only interaction we can do is afterattack
-                    InteractAfterattack(player, item, msg.Coordinates);
-                    return;
-                }
+                //AFTERATTACK: Check if we clicked on an empty location, if so the only interaction we can do is afterattack
+                InteractAfterattack(player, item, msg.Coordinates);
                 return;
             }
-            //USE: Check if we clicked on the item we are holding in our active hand to use it
-            else if(attacked == item && item != null)
+            else if(attacked == null)
             {
-                UseInteraction(player, item);
+                return;
+            }
+
+            //Verify attacked object is on the map if we managed to click on it somehow
+            if (!attacked.GetComponent<TransformComponent>().IsMapTransform)
+            {
+                Logger.Warning(string.Format("Player named {0} clicked on object {1} that isn't currently on the map somehow", player.Name, attacked.Name));
                 return;
             }
 
             //Check if ClickLocation is in object bounds here, if not lets log as warning and see why
-            if(attacked != null && attacked.TryGetComponent(out BoundingBoxComponent boundingbox))
+            if (attacked.TryGetComponent(out BoundingBoxComponent boundingbox))
             {
                 if (!boundingbox.WorldAABB.Contains(msg.Coordinates.Position))
                 {
@@ -208,6 +212,15 @@ namespace Content.Server.GameObjects.EntitySystems
             }
         }
 
+        /// <summary>
+        /// TODO function for blocking activity based on mob status
+        /// </summary>
+        /// <returns></returns>
+        private static bool MobCanInteract(IEntity user)
+        {
+            return true; //Hook into future planned mob status system
+        }
+
         /// <summary>
         /// We didn't click on any entity, try doing an afterattack on the click location
         /// </summary>
@@ -276,6 +289,20 @@ namespace Content.Server.GameObjects.EntitySystems
             //Else check damage component to see if we damage if not attackby, and if so can we attack object
         }
 
+        /// <summary>
+        /// Activates the Use behavior of an object
+        /// Verifies that the user is capable of doing the use interaction first
+        /// </summary>
+        /// <param name="user"></param>
+        /// <param name="used"></param>
+        public static void TryUseInteraction(IEntity user, IEntity used)
+        {
+            if(user != null && used != null && MobCanInteract(user))
+            {
+                UseInteraction(user, used);
+            }
+        }
+
         /// <summary>
         /// Activates/Uses an object in control/possession of a user
         /// If the item has the IUse interface on one of its components we use the object in our hand
diff --git a/Content.Server/Interfaces/GameObjects/Components/Items/IHandsComponent.cs b/Content.Server/Interfaces/GameObjects/Components/Items/IHandsComponent.cs
index 0d8fc902d4..6fead188b0 100644
--- a/Content.Server/Interfaces/GameObjects/Components/Items/IHandsComponent.cs
+++ b/Content.Server/Interfaces/GameObjects/Components/Items/IHandsComponent.cs
@@ -1,4 +1,4 @@
-using SS14.Shared.Interfaces.GameObjects;
+using SS14.Shared.Interfaces.GameObjects;
 using System.Collections.Generic;
 
 namespace Content.Server.Interfaces.GameObjects
@@ -22,6 +22,11 @@ namespace Content.Server.Interfaces.GameObjects
         /// <returns>The item in the held, null if no item is held</returns>
         IItemComponent GetHand(string index);
 
+        /// <summary>
+        /// Gets item held by the current active hand
+        /// </summary>
+        IItemComponent GetActiveHand { get; }
+
         /// <summary>
         ///     Puts an item into any empty hand, preferring the active hand.
         /// </summary>
diff --git a/Content.Shared/Content.Shared.csproj b/Content.Shared/Content.Shared.csproj
index 7fbb85f6de..7678d4a08f 100644
--- a/Content.Shared/Content.Shared.csproj
+++ b/Content.Shared/Content.Shared.csproj
@@ -65,6 +65,7 @@
   <ItemGroup>
     <Compile Include="EntryPoint.cs" />
     <Compile Include="GameObjects\Components\Doors\SharedDoorComponent.cs" />
+    <Compile Include="GameObjects\Components\Storage\SharedStorageComponent.cs" />
     <Compile Include="GameObjects\ContentNetIDs.cs" />
     <Compile Include="GameObjects\PhysicalConstants.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
diff --git a/Content.Shared/GameObjects/Components/Items/SharedHandsComponent.cs b/Content.Shared/GameObjects/Components/Items/SharedHandsComponent.cs
index 65e99d8ec2..fff822da7b 100644
--- a/Content.Shared/GameObjects/Components/Items/SharedHandsComponent.cs
+++ b/Content.Shared/GameObjects/Components/Items/SharedHandsComponent.cs
@@ -1,4 +1,5 @@
 using SS14.Shared.GameObjects;
+using SS14.Shared.Serialization;
 using System;
 using System.Collections.Generic;
 
@@ -24,4 +25,16 @@ namespace Content.Shared.GameObjects
             ActiveIndex = activeIndex;
         }
     }
+
+    /// <summary>
+    /// A message that activates the inhand, presumed for now the activation will occur only on the active hand
+    /// </summary>
+    [Serializable, NetSerializable]
+    public class ActivateInhandMsg : ComponentMessage
+    {
+        public ActivateInhandMsg()
+        {
+            Directed = true;
+        }
+    }
 }
diff --git a/Content.Shared/GameObjects/Components/Storage/SharedStorageComponent.cs b/Content.Shared/GameObjects/Components/Storage/SharedStorageComponent.cs
new file mode 100644
index 0000000000..2e0dfc2996
--- /dev/null
+++ b/Content.Shared/GameObjects/Components/Storage/SharedStorageComponent.cs
@@ -0,0 +1,59 @@
+using SS14.Shared.GameObjects;
+using SS14.Shared.Serialization;
+using System;
+using System.Collections.Generic;
+
+namespace Content.Shared.GameObjects.Components.Storage
+{
+    public abstract class SharedStorageComponent : Component
+    {
+        public sealed override string Name => "Storage";
+        public override uint? NetID => ContentNetIDs.STORAGE;
+    }
+
+    /// <summary>
+    /// Updates the client component about what entities this storage is holding
+    /// </summary>
+    [Serializable, NetSerializable]
+    public class StorageHeldItemsMessage : ComponentMessage
+    {
+        public readonly int StorageSizeMax;
+        public readonly int StorageSizeUsed;
+        public Dictionary<EntityUid, int> StoredEntities;
+
+        public StorageHeldItemsMessage(Dictionary<EntityUid, int> storedentities, int storageused, int storagemaxsize)
+        {
+            Directed = true;
+            StorageSizeMax = storagemaxsize;
+            StorageSizeUsed = storageused;
+            StoredEntities = storedentities;
+        }
+    }
+
+    /// <summary>
+    /// Component message for removing a contained entity from the storage entity
+    /// </summary>
+    [Serializable, NetSerializable]
+    public class RemoveEntityMessage : ComponentMessage
+    {
+        public EntityUid EntityUid;
+
+        public RemoveEntityMessage(EntityUid entityuid)
+        {
+            Directed = true;
+            EntityUid = entityuid;
+        }
+    }
+
+    /// <summary>
+    /// Component message for opening the storage UI
+    /// </summary>
+    [Serializable, NetSerializable]
+    public class OpenStorageUIMessage : ComponentMessage
+    {
+        public OpenStorageUIMessage()
+        {
+            Directed = true;
+        }
+    }
+}
diff --git a/Content.Shared/GameObjects/ContentNetIDs.cs b/Content.Shared/GameObjects/ContentNetIDs.cs
index 905c08c640..340062e67f 100644
--- a/Content.Shared/GameObjects/ContentNetIDs.cs
+++ b/Content.Shared/GameObjects/ContentNetIDs.cs
@@ -8,5 +8,6 @@
         public const uint TEMPERATURE = 1002;
         public const uint HANDS = 1003;
         public const uint DOOR = 1004;
+        public const uint STORAGE = 1005;
     }
 }
diff --git a/Resources/Prototypes/Entities/Items.yml b/Resources/Prototypes/Entities/Items.yml
index 804831d819..4efdbd8b46 100644
--- a/Resources/Prototypes/Entities/Items.yml
+++ b/Resources/Prototypes/Entities/Items.yml
@@ -4,6 +4,7 @@
   components:
   - type: Transform
   - type: Item
+    Size: 5
   - type: Clickable
   - type: BoundingBox
   - type: Physics
@@ -18,6 +19,10 @@
     sprite: Items/toolbox_r.png
   - type: Icon
     icon: Items/toolbox_r.png
+  - type: Storage
+    Capacity: 60
+  - type: Item
+    Size: 9999
 
 - type: entity
   name: "Mechanical Toolbox With Handle"
@@ -28,6 +33,10 @@
     sprite: Items/toolbox_b.png
   - type: Icon
     icon: Items/toolbox_b.png
+  - type: Storage
+    Capacity: 60
+  - type: Item
+    Size: 9999
 
 - type: entity
   name: "Electrical Toolbox With Handle"
@@ -38,6 +47,10 @@
     sprite: Items/toolbox_y.png
   - type: Icon
     icon: Items/toolbox_y.png
+  - type: Storage
+    Capacity: 60
+  - type: Item
+    Size: 9999
 
 - type: entity
   name: "Extra-Grip™ Mop"
@@ -48,6 +61,8 @@
     sprite: Items/mop.png
   - type: Icon
     icon: Items/mop.png
+  - type: Item
+    Size: 10
 
 #handheld lights
 - type: entity
diff --git a/Resources/Prototypes/Entities/HitscanWeapons.yml b/Resources/Prototypes/Entities/Weapons.yml
similarity index 87%
rename from Resources/Prototypes/Entities/HitscanWeapons.yml
rename to Resources/Prototypes/Entities/Weapons.yml
index e26f6e62e1..bcd928c3d8 100644
--- a/Resources/Prototypes/Entities/HitscanWeapons.yml
+++ b/Resources/Prototypes/Entities/Weapons.yml
@@ -8,6 +8,8 @@
   - type: Icon
     icon: Objects/gun.png
   - type: HitscanWeapon
+  - type: Item
+    Size: 24
 
 - type: entity
   name: GUN
@@ -19,3 +21,6 @@
   - type: Icon
     icon: Objects/projectileweapon.png
   - type: ProjectileWeapon
+  - type: Item
+    Size: 24
+
diff --git a/Resources/Scenes/Storage/Storage.tscn b/Resources/Scenes/Storage/Storage.tscn
new file mode 100644
index 0000000000..d0221a94d5
--- /dev/null
+++ b/Resources/Scenes/Storage/Storage.tscn
@@ -0,0 +1,207 @@
+[gd_scene load_steps=3 format=2]
+
+[ext_resource path="res://Scenes/SS14Window/closewindow.png" type="Texture" id=1]
+
+[sub_resource type="StyleBoxFlat" id=1]
+
+content_margin_left = -1.0
+content_margin_right = -1.0
+content_margin_top = -1.0
+content_margin_bottom = -1.0
+bg_color = Color( 0.234375, 0.234375, 0.234375, 1 )
+draw_center = true
+border_width_left = 0
+border_width_top = 0
+border_width_right = 0
+border_width_bottom = 0
+border_color = Color( 0.8, 0.8, 0.8, 1 )
+border_blend = false
+corner_radius_top_left = 0
+corner_radius_top_right = 0
+corner_radius_bottom_right = 0
+corner_radius_bottom_left = 0
+corner_detail = 8
+expand_margin_left = 0.0
+expand_margin_right = 0.0
+expand_margin_top = 0.0
+expand_margin_bottom = 0.0
+shadow_color = Color( 0, 0, 0, 0.6 )
+shadow_size = 0
+anti_aliasing = true
+anti_aliasing_size = 1
+
+[node name="SS14Window" type="Panel" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_left = 100.0
+margin_top = 38.0
+margin_right = 361.0
+margin_bottom = 406.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 0
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+
+[node name="Contents" type="Container" parent="." index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = 10.0
+margin_top = 40.0
+margin_right = -10.0
+margin_bottom = -12.0
+rect_min_size = Vector2( 50, 50 )
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+_sections_unfolded = [ "Anchor", "Margin", "Mouse", "Rect" ]
+
+[node name="VSplitContainer" type="VSplitContainer" parent="Contents" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 1
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+split_offset = 0
+collapsed = false
+dragger_visibility = 0
+_sections_unfolded = [ "Anchor", "Grow Direction", "Hint", "Margin", "Rect" ]
+
+[node name="Information" type="Label" parent="Contents/VSplitContainer" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_right = 241.0
+margin_bottom = 14.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 4
+text = "Items: 0 Volume: 0/0 Stuff"
+align = 1
+percent_visible = 1.0
+lines_skipped = 0
+max_lines_visible = -1
+_sections_unfolded = [ "Anchor", "Margin" ]
+
+[node name="ListScrollContainer" type="ScrollContainer" parent="Contents/VSplitContainer" index="1"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_top = 26.0
+margin_right = 241.0
+margin_bottom = 316.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = true
+mouse_filter = 0
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 3
+size_flags_vertical = 1
+scroll_horizontal_enabled = true
+scroll_horizontal = 0
+scroll_vertical_enabled = true
+scroll_vertical = 0
+_sections_unfolded = [ "Anchor", "Focus", "Grow Direction", "Hint", "Margin", "Material", "Mouse", "Pause", "Rect", "Scroll", "Size Flags", "Theme", "Visibility" ]
+
+[node name="EntityList" type="VBoxContainer" parent="Contents/VSplitContainer/ListScrollContainer" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_right = 241.0
+margin_bottom = 176.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 1
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 3
+size_flags_vertical = 1
+alignment = 1
+_sections_unfolded = [ "Anchor", "Focus", "Hint", "Margin", "Mouse", "Rect", "Size Flags", "Theme", "custom_constants" ]
+
+[node name="Header" type="Panel" parent="." index="1"]
+
+editor/display_folded = true
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 1.0
+anchor_bottom = 0.0
+margin_bottom = 25.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+custom_styles/panel = SubResource( 1 )
+_sections_unfolded = [ "Margin", "Mouse", "custom_styles" ]
+
+[node name="Header Text" type="Label" parent="Header" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_right = -25.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 4
+text = "Storage Item"
+align = 1
+valign = 1
+clip_text = true
+percent_visible = 1.0
+lines_skipped = 0
+max_lines_visible = -1
+_sections_unfolded = [ "Margin", "Mouse" ]
+
+[node name="CloseButton" type="TextureButton" parent="Header" index="1"]
+
+anchor_left = 1.0
+anchor_top = 0.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = -25.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+focus_mode = 2
+mouse_filter = 0
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+toggle_mode = false
+enabled_focus_mode = 2
+shortcut = null
+group = null
+texture_normal = ExtResource( 1 )
+expand = true
+stretch_mode = 5
+_sections_unfolded = [ "Margin", "Textures" ]
+
+
diff --git a/Resources/Scenes/Storage/StorageEntity.tscn b/Resources/Scenes/Storage/StorageEntity.tscn
new file mode 100644
index 0000000000..3ee2f08949
--- /dev/null
+++ b/Resources/Scenes/Storage/StorageEntity.tscn
@@ -0,0 +1,160 @@
+[gd_scene load_steps=2 format=2]
+
+[sub_resource type="StyleBoxEmpty" id=1]
+
+content_margin_left = -1.0
+content_margin_right = -1.0
+content_margin_top = -1.0
+content_margin_bottom = -1.0
+
+[node name="StorageEntity" type="PanelContainer" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 0
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 3
+size_flags_vertical = 3
+custom_styles/panel = SubResource( 1 )
+_sections_unfolded = [ "Focus", "Hint", "Material", "Mouse", "Size Flags", "Theme", "Visibility", "custom_styles" ]
+
+[node name="Button" type="Button" parent="." index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_right = 1024.0
+margin_bottom = 600.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+focus_mode = 2
+mouse_filter = 0
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 3
+size_flags_vertical = 3
+toggle_mode = true
+enabled_focus_mode = 2
+shortcut = null
+group = null
+flat = false
+align = 1
+_sections_unfolded = [ "Grow Direction", "Size Flags" ]
+
+[node name="HBoxContainer" type="HBoxContainer" parent="." index="1"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_right = 1024.0
+margin_bottom = 600.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+alignment = 0
+_sections_unfolded = [ "Anchor", "Grow Direction", "Hint", "Margin", "Mouse", "Rect", "Size Flags", "Theme", "custom_constants" ]
+
+[node name="TextureWrap" type="Control" parent="HBoxContainer" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_right = 32.0
+margin_bottom = 600.0
+rect_min_size = Vector2( 32, 32 )
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 1
+_sections_unfolded = [ "Mouse", "Rect" ]
+
+[node name="TextureRect" type="TextureRect" parent="HBoxContainer/TextureWrap" index="0"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = true
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 4
+size_flags_vertical = 4
+stretch_mode = 0
+_sections_unfolded = [ "Focus", "Grow Direction", "Hint", "Margin", "Mouse", "Rect", "Size Flags", "Theme" ]
+
+[node name="Name" type="Label" parent="HBoxContainer" index="1"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_left = 36.0
+margin_top = 293.0
+margin_right = 95.0
+margin_bottom = 307.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 4
+text = "Backpack"
+percent_visible = 1.0
+lines_skipped = 0
+max_lines_visible = -1
+_sections_unfolded = [ "Anchor" ]
+
+[node name="Control" type="Control" parent="HBoxContainer" index="2"]
+
+anchor_left = 0.0
+anchor_top = 0.0
+anchor_right = 0.0
+anchor_bottom = 0.0
+margin_left = 99.0
+margin_right = 1024.0
+margin_bottom = 600.0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 3
+size_flags_vertical = 1
+_sections_unfolded = [ "Mouse", "Size Flags" ]
+
+[node name="Size" type="Label" parent="HBoxContainer/Control" index="0"]
+
+anchor_left = 1.0
+anchor_top = 0.5
+anchor_right = 1.0
+anchor_bottom = 0.5
+margin_left = -38.0
+margin_top = -7.0
+margin_right = -5.0
+margin_bottom = 7.0
+grow_horizontal = 0
+rect_pivot_offset = Vector2( 0, 0 )
+rect_clip_content = false
+mouse_filter = 2
+mouse_default_cursor_shape = 0
+size_flags_horizontal = 1
+size_flags_vertical = 4
+text = "Size 6"
+align = 2
+percent_visible = 1.0
+lines_skipped = 0
+max_lines_visible = -1
+_sections_unfolded = [ "Margin", "Mouse" ]
+
+
diff --git a/engine b/engine
index b5ca9095b0..32caf088ef 160000
--- a/engine
+++ b/engine
@@ -1 +1 @@
-Subproject commit b5ca9095b0c5ce08e8b5791140c155c8005098d0
+Subproject commit 32caf088efa9f6668482a48ad6f975292b95edbf