break up inventoryutils

src/main/java/electrosphere/client/interact/ButtonInteraction.java

@@ -11,6 +11,7 @@ import electrosphere.data.common.interact.InteractionData;
 import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.state.equip.ClientEquipState;
+import electrosphere.entity.state.inventory.ClientInventoryState;
 import electrosphere.entity.state.inventory.InventoryUtils;
 import electrosphere.entity.types.common.CommonEntityFlags;
 import electrosphere.entity.types.common.CommonEntityUtils;
@@ -37,7 +38,7 @@ public class ButtonInteraction {
                 ButtonInteraction.performInteraction(target);
             } else if(ClientEquipState.hasEquipState(Globals.playerEntity) && Crosshair.hasTarget()){
                 if(InventoryUtils.hasNaturalInventory(Globals.playerEntity)){
-                    InventoryUtils.clientAttemptStoreItem(Globals.playerEntity, Crosshair.getTarget());
+                    ClientInventoryState.clientAttemptStoreItem(Globals.playerEntity, Crosshair.getTarget());
                 }
             }
         }

src/main/java/electrosphere/client/ui/menu/ingame/MenuGeneratorsInventory.java

@@ -6,7 +6,7 @@ import electrosphere.client.ui.menu.WindowUtils;
 import electrosphere.data.item.Item;
 import electrosphere.engine.Globals;
 import electrosphere.engine.assetmanager.AssetDataStrings;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ClientInventoryState;
 import electrosphere.entity.types.item.ItemUtils;
 import electrosphere.logger.LoggerInterface;
 import electrosphere.renderer.ui.elements.Div;
@@ -25,7 +25,7 @@ public class MenuGeneratorsInventory {
             LoggerInterface.loggerUI.INFO("World item drop capture window received drag release");
             if(Globals.draggedItem != null){
                     //drop item
-                    InventoryUtils.clientAttemptEjectItem(Globals.playerEntity,Globals.draggedItem);
+                    ClientInventoryState.clientAttemptEjectItem(Globals.playerEntity,Globals.draggedItem);
                     //play sound effect
                     if(Globals.virtualAudioSourceManager != null){
                         Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(ItemUtils.getType(Globals.draggedItem));

src/main/java/electrosphere/controls/categories/ControlCategoryMainGame.java

@@ -32,6 +32,7 @@ import electrosphere.entity.EntityTags;
 import electrosphere.entity.btree.BehaviorTree;
 import electrosphere.entity.state.equip.ClientEquipState;
 import electrosphere.entity.state.equip.ClientToolbarState;
+import electrosphere.entity.state.inventory.ClientInventoryState;
 import electrosphere.entity.state.inventory.InventoryUtils;
 import electrosphere.entity.state.inventory.UnrelationalInventoryState;
 import electrosphere.entity.state.movement.editor.ClientEditorMovementTree;
@@ -663,7 +664,7 @@ public class ControlCategoryMainGame {
                     UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(Globals.playerEntity);
                     if(inventory.getItems().size() > 0){
                         Entity itemToDrop = inventory.getItems().get(0);
-                        InventoryUtils.clientAttemptEjectItem(Globals.playerEntity,itemToDrop);
+                        ClientInventoryState.clientAttemptEjectItem(Globals.playerEntity,itemToDrop);
                     }
                 }
             }

src/main/java/electrosphere/data/item/source/ItemSourcingTree.java

@@ -13,6 +13,7 @@ import electrosphere.data.item.ItemIdStrings;
 import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.types.item.ItemUtils;
 
 /**
@@ -101,7 +102,7 @@ public class ItemSourcingTree {
         }
         if(sourcingData.trees.size() > 0){
             //if we don't have an axe in inventory, consider it a dependency
-            if(!InventoryUtils.serverHasTool(entity, CommonEntityTokens.TOKEN_AXE)){
+            if(!ServerInventoryState.serverHasTool(entity, CommonEntityTokens.TOKEN_AXE)){
                 ItemSourcingData axeSource = this.getCurrentDependencyRecursive(entity, inventoryIds, ItemIdStrings.ITEM_STONE_AXE);
                 return axeSource;
             }

src/main/java/electrosphere/entity/ClientEntityUtils.java

@@ -9,7 +9,7 @@ import electrosphere.client.interact.ClientInteractionEngine;
 import electrosphere.engine.Globals;
 import electrosphere.entity.state.attach.AttachUtils;
 import electrosphere.entity.state.hitbox.HitboxCollectionState;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ClientInventoryState;
 import electrosphere.entity.types.collision.CollisionObjUtils;
 import electrosphere.entity.types.item.ItemUtils;
 import electrosphere.renderer.actor.ActorUtils;
@@ -67,7 +67,7 @@ public class ClientEntityUtils {
 
             //is an item in an inventory
             if(ItemUtils.getContainingParent(entity) != null){
-                InventoryUtils.clientRemoveItemFromInventories(ItemUtils.getContainingParent(entity), entity);
+                ClientInventoryState.clientRemoveItemFromInventories(ItemUtils.getContainingParent(entity), entity);
             }
 
 

src/main/java/electrosphere/entity/ServerEntityUtils.java

@@ -7,7 +7,6 @@ import org.joml.Vector3d;
 import electrosphere.engine.Globals;
 import electrosphere.entity.state.attach.AttachUtils;
 import electrosphere.entity.state.hitbox.HitboxCollectionState;
-import electrosphere.entity.state.inventory.InventoryUtils;
 import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.state.server.ServerCharacterData;
 import electrosphere.entity.types.collision.CollisionObjUtils;
@@ -174,8 +173,8 @@ public class ServerEntityUtils {
 
         //
         //Stop inventory watching
-        if(InventoryUtils.serverGetInventoryState(entity) != null){
+        if(ServerInventoryState.getServerInventoryState(entity) != null){
-            ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(entity);
+            ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(entity);
             serverInventoryState.destroy();
         }
 

src/main/java/electrosphere/entity/state/inventory/ClientInventoryState.java

@@ -4,11 +4,15 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+import electrosphere.audio.VirtualAudioSourceManager.VirtualAudioSourceType;
 import electrosphere.client.ui.menu.WindowUtils;
 import electrosphere.data.creature.equip.EquipPoint;
+import electrosphere.data.item.Item;
 import electrosphere.engine.Globals;
+import electrosphere.engine.assetmanager.AssetDataStrings;
 import electrosphere.entity.ClientEntityUtils;
 import electrosphere.entity.Entity;
+import electrosphere.entity.EntityDataStrings;
 import electrosphere.entity.btree.BehaviorTree;
 import electrosphere.entity.state.equip.ClientEquipState;
 import electrosphere.entity.state.equip.ClientToolbarState;
@@ -16,6 +20,7 @@ import electrosphere.entity.state.item.ClientChargeState;
 import electrosphere.entity.types.item.ItemUtils;
 import electrosphere.logger.LoggerInterface;
 import electrosphere.net.parser.net.message.InventoryMessage;
+import electrosphere.net.parser.net.message.NetworkMessage;
 import electrosphere.net.server.protocol.InventoryProtocol;
 
 /**
@@ -66,7 +71,7 @@ public class ClientInventoryState implements BehaviorTree {
                         LoggerInterface.loggerNetworking.WARNING("Client create item " + message.getitemEntId());
                         Entity clientSideContainer = Globals.clientSceneWrapper.getEntityFromServerId(message.gettargetEntId());
                         //the ID we get is of the in-inventory item
-                        Entity inInventorySpawnedItem = InventoryUtils.clientConstructInInventoryItem(clientSideContainer,message.getitemTemplate());
+                        Entity inInventorySpawnedItem = ClientInventoryState.clientConstructInInventoryItem(clientSideContainer,message.getitemTemplate());
                         //map id
                         if(inInventorySpawnedItem != null){
                             Globals.clientSceneWrapper.mapIdToId(inInventorySpawnedItem.getId(), message.getitemEntId());
@@ -79,7 +84,7 @@ public class ClientInventoryState implements BehaviorTree {
                     LoggerInterface.loggerNetworking.WARNING("Client destroy item " + message.getentityId());
                     Entity item = Globals.clientSceneWrapper.getEntityFromServerId(message.getentityId());
                     if(item != null){
-                        InventoryUtils.clientRemoveItemFromInventories(parent, item);
+                        ClientInventoryState.clientRemoveItemFromInventories(parent, item);
                         //attempt re-render ui
                         WindowUtils.attemptRedrawInventoryWindows();
                     }
@@ -330,4 +335,153 @@ public class ClientInventoryState implements BehaviorTree {
         networkMessageQueue.add(networkMessage);
     }
 
+    /**
+     * Asks the server to add the item to the player's natural inventory
+     * @param item The item to store
+     */
+    public static void clientAddToNatural(Entity item){
+        //tell the server we want to try the transform
+        NetworkMessage requestPickupMessage = InventoryMessage.constructclientRequestAddNaturalMessage(
+            Globals.clientSceneWrapper.mapClientToServerId(item.getId())
+        );
+        Globals.clientConnection.queueOutgoingMessage(requestPickupMessage);
+    }
+
+    /**
+     * Attempts to store the in-world item entity in a creature inventory container
+     * @param creature the creature which has a natural inventory
+     * @param item the in-world item entity to store
+     */
+    public static void clientAttemptStoreItem(Entity creature, Entity item){
+        //tell the server we want to try the transform
+        NetworkMessage requestPickupMessage = InventoryMessage.constructaddItemToInventoryMessage(
+            Globals.clientSceneWrapper.mapClientToServerId(Globals.playerEntity.getId()),
+            Globals.clientSceneWrapper.mapClientToServerId(item.getId()),
+            ItemUtils.getType(item)
+        );
+        Globals.clientConnection.queueOutgoingMessage(requestPickupMessage);
+    }
+
+    /**
+     * Places an item of provided type in the parent container's natural inventory
+     * @param parentContainer The entity (typically a creature) which will receive the item in their natural inventory
+     * @param type The type of item to place in the inventory
+     * @return The in-inventory item entity
+     */
+    public static Entity clientConstructInInventoryItem(Entity parentContainer, String type){
+        //sanity checks
+        boolean hasInventory = InventoryUtils.hasNaturalInventory(parentContainer);
+        if(hasInventory){
+            //if we pass sanity checks, actually perform transform
+            //get inventory
+            //for the moment we're just gonna get natural inventory
+            //later we'll need to search through all creature inventories to find the item
+            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(parentContainer);
+            //create item
+            //TODO: optimize by directly creating the container item instead of first spawning regular item
+            LoggerInterface.loggerNetworking.DEBUG("[CLIENT] Spawning temporary in-world item before placing into inventory");
+            Entity spawnedItem = ItemUtils.clientSpawnBasicItem(type);
+            //convert to in-inventory
+            Entity inventoryItem = ItemUtils.clientRecreateContainerItem(spawnedItem, parentContainer);
+            //destroy the item that was left over
+            ClientEntityUtils.destroyEntity(spawnedItem);
+            //store item in inventory
+            inventory.addItem(inventoryItem);
+            //set item containing parent
+            ItemUtils.setContainingParent(inventoryItem, parentContainer);
+            //return
+            return inventoryItem;
+        }
+        //if we fail, return null
+        return null;
+    }
+
+    /**
+     * Attempts ejecting an item from a client's inventory
+     * need creature so we can figure out where to drop the item
+     * @param creature The creature
+     * @param item The item
+     */
+    public static void clientAttemptEjectItem(Entity creature, Entity item){
+        //if we're the client, tell the server we want to try the transform
+        NetworkMessage requestPickupMessage = InventoryMessage.constructremoveItemFromInventoryMessage(Globals.clientSceneWrapper.mapClientToServerId(item.getId()));
+        Globals.clientConnection.queueOutgoingMessage(requestPickupMessage);
+        if(Globals.virtualAudioSourceManager != null){
+            Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(ItemUtils.getType(item));
+            if(itemData != null && itemData.getItemAudio() != null && itemData.getItemAudio().getUIReleaseAudio() != null){
+                Globals.virtualAudioSourceManager.createVirtualAudioSource(itemData.getItemAudio().getUIReleaseAudio(), VirtualAudioSourceType.UI, false);
+            } else {
+                Globals.virtualAudioSourceManager.createVirtualAudioSource(AssetDataStrings.UI_SFX_ITEM_RELEASE, VirtualAudioSourceType.UI, false);
+            }
+        }
+    }
+
+    /**
+     * [CLIENT ONLY] Called when the server says to remove an item from all inventories
+     * Only does the remove, doesn't create the in-world item
+     * @param creature The creature to remove the item from (likely to be player entity)
+     * @param item The item to remove
+     */
+    public static void clientRemoveItemFromInventories(Entity creature, Entity item){
+        if(creature == null){
+            throw new Error("Creature is null!");
+        }
+        if(item == null){
+            throw new Error("Item is null!");
+        }
+        if(!ItemUtils.isItem(item)){
+            throw new Error("Item is not an item!");
+        }
+        if(!ItemUtils.itemIsInInventory(item)){
+            throw new Error("Item is not in an inventory!");
+        }
+        //check if the item is in an inventory
+        if(InventoryUtils.hasNaturalInventory(creature)){
+            //get inventory
+            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
+            //remove item from inventory
+            inventory.removeItem(item);
+        }
+        if(InventoryUtils.hasEquipInventory(creature)){
+            //get inventory
+            RelationalInventoryState inventory = InventoryUtils.getEquipInventory(creature);
+            //get real world item
+            Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
+            if(realWorldItem != null){
+                //drop item
+                ClientEquipState equipState = ClientEquipState.getEquipState(creature);
+                equipState.clientTransformUnequipPoint(inventory.getItemSlot(item));
+            }
+            //remove item from inventory
+            inventory.tryRemoveItem(item);
+        }
+        if(InventoryUtils.hasToolbarInventory(creature)){
+            RelationalInventoryState toolbarInventory = InventoryUtils.getToolbarInventory(creature);
+            toolbarInventory.tryRemoveItem(item);
+            Globals.cursorState.hintClearBlockCursor();
+            ClientToolbarState.getClientToolbarState(creature).update();
+        }
+    }
+
+    /**
+     * Gets the current inventory state
+     * @param target the entity to get inventory state from
+     * @return The inventory state behavior tree or null
+     */
+    public static ClientInventoryState getClientInventoryState(Entity target){
+        if(!target.containsKey(EntityDataStrings.CLIENT_INVENTORY_STATE)){
+            return null;
+        }
+        return (ClientInventoryState)target.getData(EntityDataStrings.CLIENT_INVENTORY_STATE);
+    }
+
+    /**
+     * Sets the current inventory state
+     * @param target The entity to attach inventory state to
+     * @param state The inventory state to attach
+     */
+    public static void setClientInventoryState(Entity target, ClientInventoryState state){
+        target.putData(EntityDataStrings.CLIENT_INVENTORY_STATE, state);
+    }
+    
 }

src/main/java/electrosphere/entity/state/inventory/InventoryUtils.java

@@ -4,36 +4,8 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import org.joml.Vector3d;
-
-import electrosphere.audio.VirtualAudioSourceManager.VirtualAudioSourceType;
-import electrosphere.data.creature.equip.EquipPoint;
-import electrosphere.data.item.Item;
-import electrosphere.engine.Globals;
-import electrosphere.engine.assetmanager.AssetDataStrings;
-import electrosphere.entity.ClientEntityUtils;
 import electrosphere.entity.Entity;
 import electrosphere.entity.EntityDataStrings;
-import electrosphere.entity.EntityUtils;
-import electrosphere.entity.ServerEntityUtils;
-import electrosphere.entity.state.equip.ClientEquipState;
-import electrosphere.entity.state.equip.ClientToolbarState;
-import electrosphere.entity.state.equip.ServerEquipState;
-import electrosphere.entity.state.equip.ServerToolbarState;
-import electrosphere.entity.state.gravity.GravityUtils;
-import electrosphere.entity.state.item.ServerChargeState;
-import electrosphere.entity.types.creature.CreatureUtils;
-import electrosphere.entity.types.item.ItemUtils;
-import electrosphere.logger.LoggerInterface;
-import electrosphere.net.parser.net.message.EntityMessage;
-import electrosphere.net.parser.net.message.InventoryMessage;
-import electrosphere.net.parser.net.message.NetworkMessage;
-import electrosphere.net.server.player.Player;
-import electrosphere.net.server.protocol.InventoryProtocol;
-import electrosphere.server.datacell.Realm;
-import electrosphere.server.datacell.ServerDataCell;
-import electrosphere.server.datacell.utils.DataCellSearchUtils;
-import electrosphere.server.utils.ServerScriptUtils;
 
 public class InventoryUtils {
     
@@ -128,658 +100,6 @@ public class InventoryUtils {
         return (RelationalInventoryState)target.getData(EntityDataStrings.INVENTORY_TOOLBAR);
     }
 
-    /**
-     * Gets the current inventory state
-     * @param target the entity to get inventory state from
-     * @return The inventory state behavior tree or null
-     */
-    public static ClientInventoryState clientGetInventoryState(Entity target){
-        if(!target.containsKey(EntityDataStrings.CLIENT_INVENTORY_STATE)){
-            return null;
-        }
-        return (ClientInventoryState)target.getData(EntityDataStrings.CLIENT_INVENTORY_STATE);
-    }
-
-    /**
-     * Gets the current inventory state
-     * @param target the entity to get inventory state from
-     * @return The inventory state behavior tree or null
-     */
-    public static ServerInventoryState serverGetInventoryState(Entity target){
-        if(!target.containsKey(EntityDataStrings.SERVER_INVENTORY_STATE)){
-            return null;
-        }
-        return (ServerInventoryState)target.getData(EntityDataStrings.SERVER_INVENTORY_STATE);
-    }
-
-    /**
-     * Sets the current inventory state
-     * @param target The entity to attach inventory state to
-     * @param state The inventory state to attach
-     */
-    public static void clientSetInventoryState(Entity target, ClientInventoryState state){
-        target.putData(EntityDataStrings.CLIENT_INVENTORY_STATE, state);
-    }
-
-    /**
-     * Sets the current inventory state
-     * @param target The entity to attach inventory state to
-     * @param state The inventory state to attach
-     */
-    public static void serverSetInventoryState(Entity target, ServerInventoryState state){
-        target.putData(EntityDataStrings.SERVER_INVENTORY_STATE, state);
-    }
-
-    /**
-     * Perform the entity transforms to actually store an item in an inventory, if server this has the side effect of also sending packets on success
-     * @param creature The creature to store the item in
-     * @param item The item to store
-     * @return The in-inventory item
-     */
-    public static Entity serverAttemptStoreItemTransform(Entity creature, Entity item){
-        if(item == null){
-            throw new Error("Null item provided! " + item);
-        }
-        if(!ItemUtils.isItem(item)){
-            throw new Error("Item is not an item!");
-        }
-        if(!InventoryUtils.hasNaturalInventory(creature)){
-            throw new Error("Creature does not have a natural inventory");
-        }
-        if(ItemUtils.itemIsInInventory(item)){
-            throw new Error("Item is already in an inventory!");
-        }
-        Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(item);
-        //get inventory
-        //for the moment we're just gonna get natural inventory
-        //later we'll need to search through all creature inventories to find the item
-        UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
-
-        //check if it should be added to an existing stack
-        Entity foundExisting = null;
-        if(itemData.getMaxStack() != null){
-            RelationalInventoryState toolbarInventory = InventoryUtils.getToolbarInventory(creature);
-            if(toolbarInventory != null){
-                for(Entity toolbarItem : toolbarInventory.getItems()){
-                    if(toolbarItem == null){
-                        continue;
-                    }
-                    Item toolbarData = Globals.gameConfigCurrent.getItemMap().getItem(toolbarItem);
-                    if(!toolbarData.getId().equals(itemData.getId())){
-                        continue;
-                    }
-                    ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(toolbarItem);
-                    if(serverChargeState.getCharges() >= itemData.getMaxStack()){
-                        continue;
-                    }
-                    foundExisting = toolbarItem;
-                    break;
-                }
-            }
-            if(foundExisting == null){
-                for(Entity naturalItem : inventory.getItems()){
-                    if(naturalItem == null){
-                        continue;
-                    }
-                    Item toolbarData = Globals.gameConfigCurrent.getItemMap().getItem(naturalItem);
-                    if(!toolbarData.getId().equals(itemData.getId())){
-                        continue;
-                    }
-                    ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(naturalItem);
-                    if(serverChargeState.getCharges() >= itemData.getMaxStack()){
-                        continue;
-                    }
-                    foundExisting = naturalItem;
-                    break;
-                }
-            }
-        }
-
-        //increase charges
-        if(foundExisting != null){
-            ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(foundExisting);
-            serverChargeState.setCharges(serverChargeState.getCharges() + 1);
-            //if we are the server, immediately send required packets
-            ServerDataCell dataCell = DataCellSearchUtils.getEntityDataCell(item);
-            dataCell.broadcastNetworkMessage(EntityMessage.constructDestroyMessage(item.getId()));
-
-            //tell entities watching this inventory that their item has another charge
-            ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(creature);
-            for(Entity watcher : serverInventoryState.getWatchers()){
-                if(CreatureUtils.hasControllerPlayerId(watcher)){
-                    //get the player
-                    int controllerPlayerID = CreatureUtils.getControllerPlayerId(watcher);
-                    Player controllerPlayer = Globals.playerManager.getPlayerFromId(controllerPlayerID);
-                    //send message
-                    controllerPlayer.addMessage(InventoryMessage.constructserverUpdateItemChargesMessage(foundExisting.getId(), serverChargeState.getCharges()));
-                }
-            }
-
-            //alert script engine
-            ServerScriptUtils.fireSignalOnEntity(creature, "itemPickup", item.getId(), foundExisting.getId());
-            //destroy the item that was left over
-            ServerEntityUtils.destroyEntity(item);
-            return foundExisting;
-        }
-
-        //destroy in-world entity and create in-inventory item
-        //we're doing this so that we're not constantly sending networking messages for invisible entities attached to the player
-        Entity inventoryItem = ItemUtils.serverRecreateContainerItem(item, creature);
-        //store item in inventory
-        inventory.addItem(inventoryItem);
-        //if we are the server, immediately send required packets
-        ServerDataCell dataCell = DataCellSearchUtils.getEntityDataCell(item);
-        // ServerDataCell dataCell = Globals.dataCellLocationResolver.getDataCellAtPoint(EntityUtils.getPosition(item),item);
-        //broadcast destroy entityq
-        dataCell.broadcastNetworkMessage(EntityMessage.constructDestroyMessage(item.getId()));
-
-        //tell entities watching this inventory that they have an item in their inventory
-        ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(creature);
-        for(Entity watcher : serverInventoryState.getWatchers()){
-            if(CreatureUtils.hasControllerPlayerId(watcher)){
-                //get the player
-                int controllerPlayerID = CreatureUtils.getControllerPlayerId(watcher);
-                Player controllerPlayer = Globals.playerManager.getPlayerFromId(controllerPlayerID);
-                //send message
-                controllerPlayer.addMessage(InventoryMessage.constructaddItemToInventoryMessage(creature.getId(), inventoryItem.getId(), ItemUtils.getType(inventoryItem)));
-            }
-        }
-
-        //alert script engine
-        ServerScriptUtils.fireSignalOnEntity(creature, "itemPickup", item.getId(), inventoryItem.getId());
-        //destroy the item that was left over
-        ServerEntityUtils.destroyEntity(item);
-        return inventoryItem;
-    }
-
-    /**
-     * Tries to add an item to a given inventory on a given container
-     * @param container The container to store the item in
-     * @param item The item to store
-     * @param containerType The type of container to store into
-     * @param slotId (Optional) The slot within the container to store into
-     * @return The in-inventory item
-     */
-    public static void serverAttemptStoreItemTransform(Entity container, Entity itemEnt, int containerType, String slotId){
-        if(itemEnt == null){
-            throw new Error("Null item provided! " + itemEnt);
-        }
-        if(!ItemUtils.isItem(itemEnt)){
-            throw new Error("Item is not an item!");
-        }
-        if(containerType != InventoryProtocol.INVENTORY_TYPE_EQUIP && containerType != InventoryProtocol.INVENTORY_TYPE_NATURAL && containerType != InventoryProtocol.INVENTORY_TYPE_TOOLBAR){
-            throw new Error("Invalid container type! " + containerType);
-        }
-
-        //check if should remove from existing container
-        if(ItemUtils.getContainingParent(itemEnt) != null && ItemUtils.getContainingParent(itemEnt) != container){
-            Entity existingContainer = ItemUtils.getContainingParent(itemEnt);
-            InventoryUtils.serverRemoveItemFromInventories(existingContainer,itemEnt);
-        }
-
-        if(containerType == InventoryProtocol.INVENTORY_TYPE_EQUIP){
-            ServerEquipState equipState = ServerEquipState.getEquipState(container);
-            EquipPoint point = equipState.getEquipPoint(slotId);
-            equipState.commandAttemptEquip(itemEnt, point);
-        } else if(containerType == InventoryProtocol.INVENTORY_TYPE_NATURAL){
-            InventoryUtils.serverAddToNatural(container, itemEnt);
-        } else if(containerType == InventoryProtocol.INVENTORY_TYPE_TOOLBAR){
-            ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(container);
-            serverToolbarState.attemptEquip(itemEnt, Integer.parseInt(slotId));
-        }
-    }
-
-    /**
-     * Perform the entity transforms to actually store an item in an inventory, if server this has the side effect of also sending packets on success
-     * @param creature The creature to store the item in
-     * @param item The item to store
-     * @return The in-inventory item
-     */
-    public static Entity serverAddToNatural(Entity creature, Entity item){
-        boolean itemIsItem = ItemUtils.isItem(item);
-        boolean hasInventory = hasNaturalInventory(creature);
-        //check if the item is already in an inventory
-        boolean itemIsInInventory = ItemUtils.itemIsInInventory(item);
-        if(itemIsItem && hasInventory){
-            //get inventory
-            //for the moment we're just gonna get natural inventory
-            //later we'll need to search through all creature inventories to find the item
-            UnrelationalInventoryState inventory = getNaturalInventory(creature);
-            //destroy in-world entity and create in-inventory item
-            //we're doing this so that we're not constantly sending networking messages for invisible entities attached to the player
-            Entity inventoryItem = item;
-            if(!itemIsInInventory){
-                inventoryItem = ItemUtils.serverRecreateContainerItem(item, creature);
-                ServerEntityUtils.destroyEntity(item);
-            }
-            if(InventoryUtils.hasEquipInventory(creature) && InventoryUtils.getEquipInventory(creature).containsItem(item)){
-                InventoryUtils.getEquipInventory(creature).tryRemoveItem(item);
-            }
-            if(InventoryUtils.hasToolbarInventory(creature) && InventoryUtils.getToolbarInventory(creature).containsItem(item)){
-                if(ServerToolbarState.getServerToolbarState(creature) != null){
-                    ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(creature);
-                    serverToolbarState.unequip(item);
-                }
-                InventoryUtils.getToolbarInventory(creature).tryRemoveItem(item);
-            }
-            //store item in inventory
-            inventory.addItem(inventoryItem);
-            //set item containing parent
-            ItemUtils.setContainingParent(inventoryItem, creature);
-
-            //tell entities watching this inventory that they have an item in their inventory
-            ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(creature);
-            for(Entity watcher : serverInventoryState.getWatchers()){
-                if(CreatureUtils.hasControllerPlayerId(watcher)){
-                    //get the player
-                    int controllerPlayerID = CreatureUtils.getControllerPlayerId(watcher);
-                    Player controllerPlayer = Globals.playerManager.getPlayerFromId(controllerPlayerID);
-                    //send message
-                    controllerPlayer.addMessage(InventoryMessage.constructaddItemToInventoryMessage(creature.getId(), inventoryItem.getId(), ItemUtils.getType(inventoryItem)));
-                }
-            }
-
-            //alert script engine
-            ServerScriptUtils.fireSignalOnEntity(creature, "itemAddToNatural", item.getId(), inventoryItem.getId());
-            return inventoryItem;
-        }
-        return null;
-    }
-
-    /**
-     * Asks the server to add the item to the player's natural inventory
-     * @param item The item to store
-     */
-    public static void clientAddToNatural(Entity item){
-        //tell the server we want to try the transform
-        NetworkMessage requestPickupMessage = InventoryMessage.constructclientRequestAddNaturalMessage(
-            Globals.clientSceneWrapper.mapClientToServerId(item.getId())
-        );
-        Globals.clientConnection.queueOutgoingMessage(requestPickupMessage);
-    }
-
-    /**
-     * Attempts to store the in-world item entity in a creature inventory container
-     * @param creature the creature which has a natural inventory
-     * @param item the in-world item entity to store
-     */
-    public static void clientAttemptStoreItem(Entity creature, Entity item){
-        //tell the server we want to try the transform
-        NetworkMessage requestPickupMessage = InventoryMessage.constructaddItemToInventoryMessage(
-            Globals.clientSceneWrapper.mapClientToServerId(Globals.playerEntity.getId()),
-            Globals.clientSceneWrapper.mapClientToServerId(item.getId()),
-            ItemUtils.getType(item)
-        );
-        Globals.clientConnection.queueOutgoingMessage(requestPickupMessage);
-    }
-
-    /**
-     * Places an item of provided type in the parent container's natural inventory
-     * @param parentContainer The entity (typically a creature) which will receive the item in their natural inventory
-     * @param type The type of item to place in the inventory
-     * @return The in-inventory item entity
-     */
-    public static Entity clientConstructInInventoryItem(Entity parentContainer, String type){
-        //sanity checks
-        boolean hasInventory = InventoryUtils.hasNaturalInventory(parentContainer);
-        if(hasInventory){
-            //if we pass sanity checks, actually perform transform
-            //get inventory
-            //for the moment we're just gonna get natural inventory
-            //later we'll need to search through all creature inventories to find the item
-            UnrelationalInventoryState inventory = getNaturalInventory(parentContainer);
-            //create item
-            //TODO: optimize by directly creating the container item instead of first spawning regular item
-            LoggerInterface.loggerNetworking.DEBUG("[CLIENT] Spawning temporary in-world item before placing into inventory");
-            Entity spawnedItem = ItemUtils.clientSpawnBasicItem(type);
-            //convert to in-inventory
-            Entity inventoryItem = ItemUtils.clientRecreateContainerItem(spawnedItem, parentContainer);
-            //destroy the item that was left over
-            ClientEntityUtils.destroyEntity(spawnedItem);
-            //store item in inventory
-            inventory.addItem(inventoryItem);
-            //set item containing parent
-            ItemUtils.setContainingParent(inventoryItem, parentContainer);
-            //return
-            return inventoryItem;
-        }
-        //if we fail, return null
-        return null;
-    }
-
-
-    /**
-     * Attempts the transform to eject an item from an inventory, if this is the server it has added side effect of sending packets on success
-     * @param creature The creature to eject the item from
-     * @param item The item to eject
-     */
-    public static void serverAttemptEjectItemTransform(Entity creature, Entity item){
-        if(creature == null){
-            throw new Error("Provided null creature!");
-        }
-        if(item == null){
-            throw new Error("Provided null item!");
-        }
-        //verify creature is creature, item is item, inventory exists, and item is in inventory
-        boolean itemIsItem = ItemUtils.isItem(item);
-        boolean hasNaturalInventory = hasNaturalInventory(creature);
-        boolean hasEquipInventory = hasEquipInventory(creature);
-        //check if the item is in an inventory
-        boolean itemIsInInventory = ItemUtils.itemIsInInventory(item);
-        if(itemIsItem && itemIsInInventory){
-            if(hasNaturalInventory){
-                //get inventory
-                UnrelationalInventoryState inventory = getNaturalInventory(creature);
-                //remove item from inventory
-                inventory.removeItem(item);
-            }
-            if(hasEquipInventory){
-                //get inventory
-                RelationalInventoryState inventory = getEquipInventory(creature);
-                //get inventory slot
-                String inventorySlot = inventory.getItemSlot(item);
-                //remove item from inventory
-                if(inventory.tryRemoveItem(item) != null){
-                    //get real world item
-                    Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
-                    if(realWorldItem != null){
-                        //Tell players to unequip the item
-                        Realm realm = Globals.realmManager.getEntityRealm(realWorldItem);
-                        if(realm != null){
-                            //get closest chunk
-                            ServerDataCell dataCell = Globals.entityDataCellMapper.getEntityDataCell(realWorldItem);
-                            //broadcast destroy item
-                            NetworkMessage unequipMessage = InventoryMessage.constructserverCommandUnequipItemMessage(creature.getId(), InventoryProtocol.INVENTORY_TYPE_EQUIP, inventorySlot);
-                            dataCell.broadcastNetworkMessage(unequipMessage);
-                        }
-                        //drop item
-                        ServerEquipState equipState = ServerEquipState.getEquipState(creature);
-                        equipState.serverTransformUnequipPoint(inventorySlot);
-                    }
-                }
-            }
-            InventoryUtils.serverRemoveItemFromInventories(creature, item);
-            //get parent realm
-            Realm realm = Globals.realmManager.getEntityRealm(creature);
-            //find "in front of creature"
-            Vector3d dropSpot = new Vector3d(EntityUtils.getPosition(creature));
-            if(CreatureUtils.getFacingVector(creature) != null){
-                dropSpot.add(CreatureUtils.getFacingVector(creature));
-            }
-            //
-            //tell player that the item is no longer in their inventory
-            ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(creature);
-            for(Entity watcher : serverInventoryState.getWatchers()){
-                if(CreatureUtils.hasControllerPlayerId(watcher)){
-                    //get player
-                    int playerId = CreatureUtils.getControllerPlayerId(watcher);
-                    Player controllerPlayer = Globals.playerManager.getPlayerFromId(playerId);
-                    //tell the player to destroy the item
-                    controllerPlayer.addMessage(EntityMessage.constructDestroyMessage(item.getId()));
-                }
-            }
-            //
-            //compose item into in-world entity
-            Entity inWorldItem = ItemUtils.serverSpawnBasicItem(realm,dropSpot,ItemUtils.getType(item));
-            //destroy the entity on server side
-            ServerEntityUtils.destroyEntity(item);
-            //activate gravity
-            GravityUtils.serverAttemptActivateGravity(inWorldItem);
-        }
-    }
-
-    //need creature so we can figure out where to drop the item
-    public static void serverAttemptEjectItem(Entity creature, Entity item){
-        if(creature == null){
-            throw new Error("Provided null creature!");
-        }
-        if(item == null){
-            throw new Error("Provided null item!");
-        }
-        //if we're the server, immediately attempt the transform
-        InventoryUtils.serverAttemptEjectItemTransform(creature,item);
-    }
-
-    /**
-     * Attempts ejecting an item from a client's inventory
-     * need creature so we can figure out where to drop the item
-     * @param creature The creature
-     * @param item The item
-     */
-    public static void clientAttemptEjectItem(Entity creature, Entity item){
-        //if we're the client, tell the server we want to try the transform
-        NetworkMessage requestPickupMessage = InventoryMessage.constructremoveItemFromInventoryMessage(Globals.clientSceneWrapper.mapClientToServerId(item.getId()));
-        Globals.clientConnection.queueOutgoingMessage(requestPickupMessage);
-        if(Globals.virtualAudioSourceManager != null){
-            Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(ItemUtils.getType(item));
-            if(itemData != null && itemData.getItemAudio() != null && itemData.getItemAudio().getUIReleaseAudio() != null){
-                Globals.virtualAudioSourceManager.createVirtualAudioSource(itemData.getItemAudio().getUIReleaseAudio(), VirtualAudioSourceType.UI, false);
-            } else {
-                Globals.virtualAudioSourceManager.createVirtualAudioSource(AssetDataStrings.UI_SFX_ITEM_RELEASE, VirtualAudioSourceType.UI, false);
-            }
-        }
-    }
-
-    /**
-     * [CLIENT ONLY] Called when the server says to remove an item from all inventories
-     * Only does the remove, doesn't create the in-world item
-     * @param creature The creature to remove the item from (likely to be player entity)
-     * @param item The item to remove
-     */
-    public static void clientRemoveItemFromInventories(Entity creature, Entity item){
-        if(creature == null){
-            throw new Error("Creature is null!");
-        }
-        if(item == null){
-            throw new Error("Item is null!");
-        }
-        if(!ItemUtils.isItem(item)){
-            throw new Error("Item is not an item!");
-        }
-        if(!ItemUtils.itemIsInInventory(item)){
-            throw new Error("Item is not in an inventory!");
-        }
-        //check if the item is in an inventory
-        if(InventoryUtils.hasNaturalInventory(creature)){
-            //get inventory
-            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
-            //remove item from inventory
-            inventory.removeItem(item);
-        }
-        if(InventoryUtils.hasEquipInventory(creature)){
-            //get inventory
-            RelationalInventoryState inventory = InventoryUtils.getEquipInventory(creature);
-            //get real world item
-            Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
-            if(realWorldItem != null){
-                //drop item
-                ClientEquipState equipState = ClientEquipState.getEquipState(creature);
-                equipState.clientTransformUnequipPoint(inventory.getItemSlot(item));
-            }
-            //remove item from inventory
-            inventory.tryRemoveItem(item);
-        }
-        if(InventoryUtils.hasToolbarInventory(creature)){
-            RelationalInventoryState toolbarInventory = InventoryUtils.getToolbarInventory(creature);
-            toolbarInventory.tryRemoveItem(item);
-            Globals.cursorState.hintClearBlockCursor();
-            ClientToolbarState.getClientToolbarState(creature).update();
-        }
-    }
-
-    /**
-     * [SERVER ONLY] Called when the server says to remove an item from all inventories
-     * Only does the remove, doesn't create the in-world item
-     * @param creature The creature to remove the item from (likely to be player entity)
-     * @param item The item to remove
-     */
-    public static void serverRemoveItemFromInventories(Entity creature, Entity item){
-        if(creature == null){
-            throw new Error("Creature is null!");
-        }
-        if(item == null){
-            throw new Error("Item is null!");
-        }
-        if(!ItemUtils.isItem(item)){
-            throw new Error("Item is not an item!");
-        }
-        if(!ItemUtils.itemIsInInventory(item)){
-            throw new Error("Item is not in an inventory!");
-        }
-        //check if the item is in an inventory
-        if(InventoryUtils.hasNaturalInventory(creature)){
-            //get inventory
-            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
-            //remove item from inventory
-            inventory.removeItem(item);
-        }
-        if(InventoryUtils.hasEquipInventory(creature)){
-            //get inventory
-            RelationalInventoryState inventory = InventoryUtils.getEquipInventory(creature);
-            //get real world item
-            Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
-            if(realWorldItem != null){
-                //drop item
-                ServerEquipState equipState = ServerEquipState.getEquipState(creature);
-                equipState.serverTransformUnequipPoint(inventory.getItemSlot(item));
-            }
-            //remove item from inventory
-            inventory.tryRemoveItem(item);
-        }
-        if(InventoryUtils.hasToolbarInventory(creature)){
-            RelationalInventoryState toolbarInventory = InventoryUtils.getToolbarInventory(creature);
-            toolbarInventory.tryRemoveItem(item);
-            Globals.cursorState.hintClearBlockCursor();
-            ServerToolbarState.getServerToolbarState(creature).update();
-        }
-        //
-        //tell player that the item is no longer in their inventory
-        ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(creature);
-        for(Entity watcher : serverInventoryState.getWatchers()){
-            if(CreatureUtils.hasControllerPlayerId(watcher)){
-                //get player
-                int playerId = CreatureUtils.getControllerPlayerId(watcher);
-                Player controllerPlayer = Globals.playerManager.getPlayerFromId(playerId);
-                //tell the player they don't have the item anymore
-                controllerPlayer.addMessage(InventoryMessage.constructremoveItemFromInventoryMessage(item.getId()));
-            }
-        }
-    }
-
-    /**
-     * Destroys an item that is in an inventory
-     * @param item The item
-     */
-    public static void serverDestroyInventoryItem(Entity item){
-        Entity creature = ItemUtils.getContainingParent(item);
-        if(creature == null){
-            throw new Error("Creature is null!");
-        }
-        if(item == null){
-            throw new Error("Item is null!");
-        }
-        if(!CreatureUtils.isCreature(creature)){
-            throw new Error("Creature is not a creature!");
-        }
-        if(!ItemUtils.isItem(item)){
-            throw new Error("Item is not an item!");
-        }
-        if(!ItemUtils.itemIsInInventory(item)){
-            throw new Error("Item is not in an inventory!");
-        }
-        //check if the item is in an inventory
-        if(InventoryUtils.hasNaturalInventory(creature)){
-            //get inventory
-            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
-            //remove item from inventory
-            inventory.removeItem(item);
-        }
-        if(InventoryUtils.hasEquipInventory(creature)){
-            //get inventory
-            RelationalInventoryState inventory = InventoryUtils.getEquipInventory(creature);
-            //get real world item
-            Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
-            if(realWorldItem != null){
-                //drop item
-                ServerEquipState equipState = ServerEquipState.getEquipState(creature);
-                equipState.serverTransformUnequipPoint(inventory.getItemSlot(item));
-            }
-            //remove item from inventory
-            inventory.tryRemoveItem(item);
-        }
-        if(InventoryUtils.hasToolbarInventory(creature)){
-            RelationalInventoryState inventory = InventoryUtils.getToolbarInventory(creature);
-            inventory.tryRemoveItem(item);
-            if(ServerToolbarState.hasServerToolbarState(creature)){
-                ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(creature);
-                serverToolbarState.update();
-            }
-        }
-        //
-        //tell player that the item is no longer in their inventory
-        ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(creature);
-        for(Entity watcher : serverInventoryState.getWatchers()){
-            if(CreatureUtils.hasControllerPlayerId(watcher)){
-                //get player
-                int playerId = CreatureUtils.getControllerPlayerId(watcher);
-                Player controllerPlayer = Globals.playerManager.getPlayerFromId(playerId);
-                //tell the player they don't have the item anymore
-                controllerPlayer.addMessage(InventoryMessage.constructremoveItemFromInventoryMessage(item.getId()));
-            }
-        }
-        ServerEntityUtils.destroyEntity(item);
-    }
-
-    /**
-     * Creates an item in the creature's inventory
-     * @param creature The creature
-     * @param itemId The item's ID
-     */
-    public static void serverCreateInventoryItem(Entity creature, String itemId, int count){
-        Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(itemId);
-        if(itemData.getMaxStack() == null){
-            for(int i = 0; i < count; i++){
-                ItemUtils.serverCreateContainerItem(creature, itemData);
-            }
-        } else {
-            //scan for items to add charges to first
-            int added = 0;
-            List<Entity> existingItems = InventoryUtils.getAllInventoryItems(creature);
-            for(Entity existingItem : existingItems){
-                Item existingData = Globals.gameConfigCurrent.getItemMap().getItem(existingItem);
-                if(existingData.getId().equals(itemId)){
-                    ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(existingItem);
-                    if(serverChargeState.getCharges() < existingData.getMaxStack()){
-                        int available = existingData.getMaxStack() - serverChargeState.getCharges();
-                        //just need to add charges to this
-                        if(available >= count - added){
-                            serverChargeState.attemptAddCharges(count - added);
-                            added = count;
-                            break;
-                        } else {
-                            serverChargeState.attemptAddCharges(available);
-                            added = added + available;
-                        }
-                    }
-                }
-            }
-            //need to start creating items to add more charges
-            Item targetData = Globals.gameConfigCurrent.getItemMap().getItem(itemId);
-            if(added < count){
-                int numFullItemsToAdd = (count - added) / targetData.getMaxStack();
-                int remainder = (count - added) % targetData.getMaxStack();
-                for(int i = 0; i < numFullItemsToAdd; i++){
-                    Entity newInventoryItem = ItemUtils.serverCreateContainerItem(creature, itemData);
-                    ServerChargeState.getServerChargeState(newInventoryItem).setCharges(targetData.getMaxStack());
-                }
-                if(remainder > 0){
-                    Entity newInventoryItem = ItemUtils.serverCreateContainerItem(creature, itemData);
-                    ServerChargeState.getServerChargeState(newInventoryItem).setCharges(remainder);
-                }
-            }
-        }
-    }
-
     /**
      * Gets the list of all items in all inventories of a creature
      * @param creature The creature
@@ -804,21 +124,4 @@ public class InventoryUtils {
         return rVal;
     }
 
-    /**
-     * Checks if the enity has a given type of tool
-     * @param entity The entity
-     * @param toolType The type of tool
-     * @return true if it has the type of tool, false otherwise
-     */
-    public static boolean serverHasTool(Entity entity, String toolType){
-        List<Entity> items = InventoryUtils.getAllInventoryItems(entity);
-        for(Entity itemEnt : items){
-            Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(itemEnt);
-            if(itemData.getTokens().contains(toolType)){
-                return true;
-            }
-        }
-        return false;
-    }
-
 }

src/main/java/electrosphere/entity/state/inventory/ServerInventoryState.java

@@ -3,19 +3,34 @@ package electrosphere.entity.state.inventory;
 import java.util.LinkedList;
 import java.util.List;
 
+import org.joml.Vector3d;
+
 import electrosphere.data.creature.equip.EquipPoint;
+import electrosphere.data.item.Item;
 import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
+import electrosphere.entity.EntityDataStrings;
+import electrosphere.entity.EntityUtils;
+import electrosphere.entity.ServerEntityUtils;
 import electrosphere.entity.btree.BehaviorTree;
 import electrosphere.entity.state.equip.ServerEquipState;
 import electrosphere.entity.state.equip.ServerToolbarState;
+import electrosphere.entity.state.gravity.GravityUtils;
+import electrosphere.entity.state.item.ServerChargeState;
 import electrosphere.entity.types.creature.CreatureUtils;
 import electrosphere.entity.types.item.ItemUtils;
 import electrosphere.logger.LoggerInterface;
+import electrosphere.net.parser.net.message.EntityMessage;
 import electrosphere.net.parser.net.message.InventoryMessage;
+import electrosphere.net.parser.net.message.NetworkMessage;
 import electrosphere.net.server.player.Player;
+import electrosphere.net.server.protocol.InventoryProtocol;
+import electrosphere.server.datacell.Realm;
+import electrosphere.server.datacell.ServerDataCell;
+import electrosphere.server.datacell.utils.DataCellSearchUtils;
 import electrosphere.server.datacell.utils.EntityLookupUtils;
 import electrosphere.server.datacell.utils.ServerBehaviorTreeUtils;
+import electrosphere.server.utils.ServerScriptUtils;
 
 /**
  * Principally used to handle network messages related to inventory and thread synchronization
@@ -66,10 +81,10 @@ public class ServerInventoryState implements BehaviorTree {
             networkMessageQueue.remove(message);
             switch(message.getMessageSubtype()){
                 case ADDITEMTOINVENTORY: {
-                    InventoryUtils.serverAttemptStoreItemTransform(parent, EntityLookupUtils.getEntityById(message.getitemEntId()));
+                    ServerInventoryState.serverAttemptStoreItemTransform(parent, EntityLookupUtils.getEntityById(message.getitemEntId()));
                 } break;
                 case REMOVEITEMFROMINVENTORY: {
-                    InventoryUtils.serverAttemptEjectItem(parent, EntityLookupUtils.getEntityById(message.getentityId()));
+                    ServerInventoryState.serverAttemptEjectItem(parent, EntityLookupUtils.getEntityById(message.getentityId()));
                 } break;
                 case CLIENTREQUESTEQUIPITEM: {
                     //item to equip
@@ -94,7 +109,7 @@ public class ServerInventoryState implements BehaviorTree {
                     }
                 } break;
                 case CLIENTREQUESTADDNATURAL: {
-                    InventoryUtils.serverAddToNatural(parent, EntityLookupUtils.getEntityById(message.getentityId()));
+                    ServerInventoryState.serverAddToNatural(parent, EntityLookupUtils.getEntityById(message.getentityId()));
                 } break;
                 case CLIENTREQUESTADDTOOLBAR: {
                     Entity itemEnt = EntityLookupUtils.getEntityById(message.getentityId());
@@ -121,12 +136,12 @@ public class ServerInventoryState implements BehaviorTree {
                         if(container != this.parent){
                             LoggerInterface.loggerEngine.WARNING("A client is trying to pick up an item for another entity!");
                         } else {
-                            InventoryUtils.serverAttemptStoreItemTransform(parent, itemEnt, message.getcontainerType(), message.getequipPointId());
+                            ServerInventoryState.serverAttemptStoreItemTransform(parent, itemEnt, message.getcontainerType(), message.getequipPointId());
                         }
                     }
                     //transfering from one container to another
                     if(currentParent != null){
-                        InventoryUtils.serverAttemptStoreItemTransform(container, itemEnt, message.getcontainerType(), message.getequipPointId());
+                        ServerInventoryState.serverAttemptStoreItemTransform(container, itemEnt, message.getcontainerType(), message.getequipPointId());
                     }
                 } break;
                 case CLIENTREQUESTWATCHINVENTORY: {
@@ -170,8 +185,8 @@ public class ServerInventoryState implements BehaviorTree {
         }
         if(!this.toWatch.contains(target)){
             this.toWatch.add(target);
-            if(InventoryUtils.serverGetInventoryState(target) != null){
+            if(ServerInventoryState.getServerInventoryState(target) != null){
-                ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
+                ServerInventoryState targetState = ServerInventoryState.getServerInventoryState(target);
                 if(!targetState.watchers.contains(this.parent)){
                     targetState.watchers.add(this.parent);
                     targetState.sendInventoryState(this.parent);
@@ -191,8 +206,8 @@ public class ServerInventoryState implements BehaviorTree {
         if(this.toWatch.contains(target)){
             this.toWatch.remove(target);
         }
-        if(InventoryUtils.serverGetInventoryState(target) != null){
+        if(ServerInventoryState.getServerInventoryState(target) != null){
-            ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
+            ServerInventoryState targetState = ServerInventoryState.getServerInventoryState(target);
             if(!targetState.watchers.contains(this.parent)){
                 targetState.watchers.remove(this.parent);
             }
@@ -222,15 +237,15 @@ public class ServerInventoryState implements BehaviorTree {
      */
     public void destroy(){
         for(Entity target : this.toWatch){
-            if(InventoryUtils.serverGetInventoryState(target) != null){
+            if(ServerInventoryState.getServerInventoryState(target) != null){
-                ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
+                ServerInventoryState targetState = ServerInventoryState.getServerInventoryState(target);
                 targetState.watchers.remove(this.parent);
                 targetState.toWatch.remove(this.parent);
             }
         }
         for(Entity target : this.watchers){
-            if(InventoryUtils.serverGetInventoryState(target) != null){
+            if(ServerInventoryState.getServerInventoryState(target) != null){
-                ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
+                ServerInventoryState targetState = ServerInventoryState.getServerInventoryState(target);
                 targetState.watchers.remove(this.parent);
                 targetState.toWatch.remove(this.parent);
             }
@@ -245,4 +260,523 @@ public class ServerInventoryState implements BehaviorTree {
         return this.watchers;
     }
 
+    /**
+     * Perform the entity transforms to actually store an item in an inventory, if server this has the side effect of also sending packets on success
+     * @param creature The creature to store the item in
+     * @param item The item to store
+     * @return The in-inventory item
+     */
+    public static Entity serverAttemptStoreItemTransform(Entity creature, Entity item){
+        if(item == null){
+            throw new Error("Null item provided! " + item);
+        }
+        if(!ItemUtils.isItem(item)){
+            throw new Error("Item is not an item!");
+        }
+        if(!InventoryUtils.hasNaturalInventory(creature)){
+            throw new Error("Creature does not have a natural inventory");
+        }
+        if(ItemUtils.itemIsInInventory(item)){
+            throw new Error("Item is already in an inventory!");
+        }
+        Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(item);
+        //get inventory
+        //for the moment we're just gonna get natural inventory
+        //later we'll need to search through all creature inventories to find the item
+        UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
+
+        //check if it should be added to an existing stack
+        Entity foundExisting = null;
+        if(itemData.getMaxStack() != null){
+            RelationalInventoryState toolbarInventory = InventoryUtils.getToolbarInventory(creature);
+            if(toolbarInventory != null){
+                for(Entity toolbarItem : toolbarInventory.getItems()){
+                    if(toolbarItem == null){
+                        continue;
+                    }
+                    Item toolbarData = Globals.gameConfigCurrent.getItemMap().getItem(toolbarItem);
+                    if(!toolbarData.getId().equals(itemData.getId())){
+                        continue;
+                    }
+                    ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(toolbarItem);
+                    if(serverChargeState.getCharges() >= itemData.getMaxStack()){
+                        continue;
+                    }
+                    foundExisting = toolbarItem;
+                    break;
+                }
+            }
+            if(foundExisting == null){
+                for(Entity naturalItem : inventory.getItems()){
+                    if(naturalItem == null){
+                        continue;
+                    }
+                    Item toolbarData = Globals.gameConfigCurrent.getItemMap().getItem(naturalItem);
+                    if(!toolbarData.getId().equals(itemData.getId())){
+                        continue;
+                    }
+                    ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(naturalItem);
+                    if(serverChargeState.getCharges() >= itemData.getMaxStack()){
+                        continue;
+                    }
+                    foundExisting = naturalItem;
+                    break;
+                }
+            }
+        }
+
+        //increase charges
+        if(foundExisting != null){
+            ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(foundExisting);
+            serverChargeState.setCharges(serverChargeState.getCharges() + 1);
+            //if we are the server, immediately send required packets
+            ServerDataCell dataCell = DataCellSearchUtils.getEntityDataCell(item);
+            dataCell.broadcastNetworkMessage(EntityMessage.constructDestroyMessage(item.getId()));
+
+            //tell entities watching this inventory that their item has another charge
+            ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(creature);
+            for(Entity watcher : serverInventoryState.getWatchers()){
+                if(CreatureUtils.hasControllerPlayerId(watcher)){
+                    //get the player
+                    int controllerPlayerID = CreatureUtils.getControllerPlayerId(watcher);
+                    Player controllerPlayer = Globals.playerManager.getPlayerFromId(controllerPlayerID);
+                    //send message
+                    controllerPlayer.addMessage(InventoryMessage.constructserverUpdateItemChargesMessage(foundExisting.getId(), serverChargeState.getCharges()));
+                }
+            }
+
+            //alert script engine
+            ServerScriptUtils.fireSignalOnEntity(creature, "itemPickup", item.getId(), foundExisting.getId());
+            //destroy the item that was left over
+            ServerEntityUtils.destroyEntity(item);
+            return foundExisting;
+        }
+
+        //destroy in-world entity and create in-inventory item
+        //we're doing this so that we're not constantly sending networking messages for invisible entities attached to the player
+        Entity inventoryItem = ItemUtils.serverRecreateContainerItem(item, creature);
+        //store item in inventory
+        inventory.addItem(inventoryItem);
+        //if we are the server, immediately send required packets
+        ServerDataCell dataCell = DataCellSearchUtils.getEntityDataCell(item);
+        // ServerDataCell dataCell = Globals.dataCellLocationResolver.getDataCellAtPoint(EntityUtils.getPosition(item),item);
+        //broadcast destroy entityq
+        dataCell.broadcastNetworkMessage(EntityMessage.constructDestroyMessage(item.getId()));
+
+        //tell entities watching this inventory that they have an item in their inventory
+        ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(creature);
+        for(Entity watcher : serverInventoryState.getWatchers()){
+            if(CreatureUtils.hasControllerPlayerId(watcher)){
+                //get the player
+                int controllerPlayerID = CreatureUtils.getControllerPlayerId(watcher);
+                Player controllerPlayer = Globals.playerManager.getPlayerFromId(controllerPlayerID);
+                //send message
+                controllerPlayer.addMessage(InventoryMessage.constructaddItemToInventoryMessage(creature.getId(), inventoryItem.getId(), ItemUtils.getType(inventoryItem)));
+            }
+        }
+
+        //alert script engine
+        ServerScriptUtils.fireSignalOnEntity(creature, "itemPickup", item.getId(), inventoryItem.getId());
+        //destroy the item that was left over
+        ServerEntityUtils.destroyEntity(item);
+        return inventoryItem;
+    }
+
+    /**
+     * Tries to add an item to a given inventory on a given container
+     * @param container The container to store the item in
+     * @param item The item to store
+     * @param containerType The type of container to store into
+     * @param slotId (Optional) The slot within the container to store into
+     * @return The in-inventory item
+     */
+    public static void serverAttemptStoreItemTransform(Entity container, Entity itemEnt, int containerType, String slotId){
+        if(itemEnt == null){
+            throw new Error("Null item provided! " + itemEnt);
+        }
+        if(!ItemUtils.isItem(itemEnt)){
+            throw new Error("Item is not an item!");
+        }
+        if(containerType != InventoryProtocol.INVENTORY_TYPE_EQUIP && containerType != InventoryProtocol.INVENTORY_TYPE_NATURAL && containerType != InventoryProtocol.INVENTORY_TYPE_TOOLBAR){
+            throw new Error("Invalid container type! " + containerType);
+        }
+
+        //check if should remove from existing container
+        if(ItemUtils.getContainingParent(itemEnt) != null && ItemUtils.getContainingParent(itemEnt) != container){
+            Entity existingContainer = ItemUtils.getContainingParent(itemEnt);
+            ServerInventoryState.serverRemoveItemFromInventories(existingContainer,itemEnt);
+        }
+
+        if(containerType == InventoryProtocol.INVENTORY_TYPE_EQUIP){
+            ServerEquipState equipState = ServerEquipState.getEquipState(container);
+            EquipPoint point = equipState.getEquipPoint(slotId);
+            equipState.commandAttemptEquip(itemEnt, point);
+        } else if(containerType == InventoryProtocol.INVENTORY_TYPE_NATURAL){
+            ServerInventoryState.serverAddToNatural(container, itemEnt);
+        } else if(containerType == InventoryProtocol.INVENTORY_TYPE_TOOLBAR){
+            ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(container);
+            serverToolbarState.attemptEquip(itemEnt, Integer.parseInt(slotId));
+        }
+    }
+
+    /**
+     * Perform the entity transforms to actually store an item in an inventory, if server this has the side effect of also sending packets on success
+     * @param creature The creature to store the item in
+     * @param item The item to store
+     * @return The in-inventory item
+     */
+    public static Entity serverAddToNatural(Entity creature, Entity item){
+        boolean itemIsItem = ItemUtils.isItem(item);
+        boolean hasInventory = InventoryUtils.hasNaturalInventory(creature);
+        //check if the item is already in an inventory
+        boolean itemIsInInventory = ItemUtils.itemIsInInventory(item);
+        if(itemIsItem && hasInventory){
+            //get inventory
+            //for the moment we're just gonna get natural inventory
+            //later we'll need to search through all creature inventories to find the item
+            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
+            //destroy in-world entity and create in-inventory item
+            //we're doing this so that we're not constantly sending networking messages for invisible entities attached to the player
+            Entity inventoryItem = item;
+            if(!itemIsInInventory){
+                inventoryItem = ItemUtils.serverRecreateContainerItem(item, creature);
+                ServerEntityUtils.destroyEntity(item);
+            }
+            if(InventoryUtils.hasEquipInventory(creature) && InventoryUtils.getEquipInventory(creature).containsItem(item)){
+                InventoryUtils.getEquipInventory(creature).tryRemoveItem(item);
+            }
+            if(InventoryUtils.hasToolbarInventory(creature) && InventoryUtils.getToolbarInventory(creature).containsItem(item)){
+                if(ServerToolbarState.getServerToolbarState(creature) != null){
+                    ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(creature);
+                    serverToolbarState.unequip(item);
+                }
+                InventoryUtils.getToolbarInventory(creature).tryRemoveItem(item);
+            }
+            //store item in inventory
+            inventory.addItem(inventoryItem);
+            //set item containing parent
+            ItemUtils.setContainingParent(inventoryItem, creature);
+
+            //tell entities watching this inventory that they have an item in their inventory
+            ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(creature);
+            for(Entity watcher : serverInventoryState.getWatchers()){
+                if(CreatureUtils.hasControllerPlayerId(watcher)){
+                    //get the player
+                    int controllerPlayerID = CreatureUtils.getControllerPlayerId(watcher);
+                    Player controllerPlayer = Globals.playerManager.getPlayerFromId(controllerPlayerID);
+                    //send message
+                    controllerPlayer.addMessage(InventoryMessage.constructaddItemToInventoryMessage(creature.getId(), inventoryItem.getId(), ItemUtils.getType(inventoryItem)));
+                }
+            }
+
+            //alert script engine
+            ServerScriptUtils.fireSignalOnEntity(creature, "itemAddToNatural", item.getId(), inventoryItem.getId());
+            return inventoryItem;
+        }
+        return null;
+    }
+
+    /**
+     * Attempts the transform to eject an item from an inventory, if this is the server it has added side effect of sending packets on success
+     * @param creature The creature to eject the item from
+     * @param item The item to eject
+     */
+    public static void serverAttemptEjectItemTransform(Entity creature, Entity item){
+        if(creature == null){
+            throw new Error("Provided null creature!");
+        }
+        if(item == null){
+            throw new Error("Provided null item!");
+        }
+        //verify creature is creature, item is item, inventory exists, and item is in inventory
+        boolean itemIsItem = ItemUtils.isItem(item);
+        boolean hasNaturalInventory = InventoryUtils.hasNaturalInventory(creature);
+        boolean hasEquipInventory = InventoryUtils.hasEquipInventory(creature);
+        //check if the item is in an inventory
+        boolean itemIsInInventory = ItemUtils.itemIsInInventory(item);
+        if(itemIsItem && itemIsInInventory){
+            if(hasNaturalInventory){
+                //get inventory
+                UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
+                //remove item from inventory
+                inventory.removeItem(item);
+            }
+            if(hasEquipInventory){
+                //get inventory
+                RelationalInventoryState inventory = InventoryUtils.getEquipInventory(creature);
+                //get inventory slot
+                String inventorySlot = inventory.getItemSlot(item);
+                //remove item from inventory
+                if(inventory.tryRemoveItem(item) != null){
+                    //get real world item
+                    Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
+                    if(realWorldItem != null){
+                        //Tell players to unequip the item
+                        Realm realm = Globals.realmManager.getEntityRealm(realWorldItem);
+                        if(realm != null){
+                            //get closest chunk
+                            ServerDataCell dataCell = Globals.entityDataCellMapper.getEntityDataCell(realWorldItem);
+                            //broadcast destroy item
+                            NetworkMessage unequipMessage = InventoryMessage.constructserverCommandUnequipItemMessage(creature.getId(), InventoryProtocol.INVENTORY_TYPE_EQUIP, inventorySlot);
+                            dataCell.broadcastNetworkMessage(unequipMessage);
+                        }
+                        //drop item
+                        ServerEquipState equipState = ServerEquipState.getEquipState(creature);
+                        equipState.serverTransformUnequipPoint(inventorySlot);
+                    }
+                }
+            }
+            ServerInventoryState.serverRemoveItemFromInventories(creature, item);
+            //get parent realm
+            Realm realm = Globals.realmManager.getEntityRealm(creature);
+            //find "in front of creature"
+            Vector3d dropSpot = new Vector3d(EntityUtils.getPosition(creature));
+            if(CreatureUtils.getFacingVector(creature) != null){
+                dropSpot.add(CreatureUtils.getFacingVector(creature));
+            }
+            //
+            //tell player that the item is no longer in their inventory
+            ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(creature);
+            for(Entity watcher : serverInventoryState.getWatchers()){
+                if(CreatureUtils.hasControllerPlayerId(watcher)){
+                    //get player
+                    int playerId = CreatureUtils.getControllerPlayerId(watcher);
+                    Player controllerPlayer = Globals.playerManager.getPlayerFromId(playerId);
+                    //tell the player to destroy the item
+                    controllerPlayer.addMessage(EntityMessage.constructDestroyMessage(item.getId()));
+                }
+            }
+            //
+            //compose item into in-world entity
+            Entity inWorldItem = ItemUtils.serverSpawnBasicItem(realm,dropSpot,ItemUtils.getType(item));
+            //destroy the entity on server side
+            ServerEntityUtils.destroyEntity(item);
+            //activate gravity
+            GravityUtils.serverAttemptActivateGravity(inWorldItem);
+        }
+    }
+
+    //need creature so we can figure out where to drop the item
+    public static void serverAttemptEjectItem(Entity creature, Entity item){
+        if(creature == null){
+            throw new Error("Provided null creature!");
+        }
+        if(item == null){
+            throw new Error("Provided null item!");
+        }
+        //if we're the server, immediately attempt the transform
+        ServerInventoryState.serverAttemptEjectItemTransform(creature,item);
+    }
+
+    /**
+     * [SERVER ONLY] Called when the server says to remove an item from all inventories
+     * Only does the remove, doesn't create the in-world item
+     * @param creature The creature to remove the item from (likely to be player entity)
+     * @param item The item to remove
+     */
+    public static void serverRemoveItemFromInventories(Entity creature, Entity item){
+        if(creature == null){
+            throw new Error("Creature is null!");
+        }
+        if(item == null){
+            throw new Error("Item is null!");
+        }
+        if(!ItemUtils.isItem(item)){
+            throw new Error("Item is not an item!");
+        }
+        if(!ItemUtils.itemIsInInventory(item)){
+            throw new Error("Item is not in an inventory!");
+        }
+        //check if the item is in an inventory
+        if(InventoryUtils.hasNaturalInventory(creature)){
+            //get inventory
+            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
+            //remove item from inventory
+            inventory.removeItem(item);
+        }
+        if(InventoryUtils.hasEquipInventory(creature)){
+            //get inventory
+            RelationalInventoryState inventory = InventoryUtils.getEquipInventory(creature);
+            //get real world item
+            Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
+            if(realWorldItem != null){
+                //drop item
+                ServerEquipState equipState = ServerEquipState.getEquipState(creature);
+                equipState.serverTransformUnequipPoint(inventory.getItemSlot(item));
+            }
+            //remove item from inventory
+            inventory.tryRemoveItem(item);
+        }
+        if(InventoryUtils.hasToolbarInventory(creature)){
+            RelationalInventoryState toolbarInventory = InventoryUtils.getToolbarInventory(creature);
+            toolbarInventory.tryRemoveItem(item);
+            Globals.cursorState.hintClearBlockCursor();
+            ServerToolbarState.getServerToolbarState(creature).update();
+        }
+        //
+        //tell player that the item is no longer in their inventory
+        ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(creature);
+        for(Entity watcher : serverInventoryState.getWatchers()){
+            if(CreatureUtils.hasControllerPlayerId(watcher)){
+                //get player
+                int playerId = CreatureUtils.getControllerPlayerId(watcher);
+                Player controllerPlayer = Globals.playerManager.getPlayerFromId(playerId);
+                //tell the player they don't have the item anymore
+                controllerPlayer.addMessage(InventoryMessage.constructremoveItemFromInventoryMessage(item.getId()));
+            }
+        }
+    }
+
+    /**
+     * Destroys an item that is in an inventory
+     * @param item The item
+     */
+    public static void serverDestroyInventoryItem(Entity item){
+        Entity creature = ItemUtils.getContainingParent(item);
+        if(creature == null){
+            throw new Error("Creature is null!");
+        }
+        if(item == null){
+            throw new Error("Item is null!");
+        }
+        if(!CreatureUtils.isCreature(creature)){
+            throw new Error("Creature is not a creature!");
+        }
+        if(!ItemUtils.isItem(item)){
+            throw new Error("Item is not an item!");
+        }
+        if(!ItemUtils.itemIsInInventory(item)){
+            throw new Error("Item is not in an inventory!");
+        }
+        //check if the item is in an inventory
+        if(InventoryUtils.hasNaturalInventory(creature)){
+            //get inventory
+            UnrelationalInventoryState inventory = InventoryUtils.getNaturalInventory(creature);
+            //remove item from inventory
+            inventory.removeItem(item);
+        }
+        if(InventoryUtils.hasEquipInventory(creature)){
+            //get inventory
+            RelationalInventoryState inventory = InventoryUtils.getEquipInventory(creature);
+            //get real world item
+            Entity realWorldItem = ItemUtils.getRealWorldEntity(item);
+            if(realWorldItem != null){
+                //drop item
+                ServerEquipState equipState = ServerEquipState.getEquipState(creature);
+                equipState.serverTransformUnequipPoint(inventory.getItemSlot(item));
+            }
+            //remove item from inventory
+            inventory.tryRemoveItem(item);
+        }
+        if(InventoryUtils.hasToolbarInventory(creature)){
+            RelationalInventoryState inventory = InventoryUtils.getToolbarInventory(creature);
+            inventory.tryRemoveItem(item);
+            if(ServerToolbarState.hasServerToolbarState(creature)){
+                ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(creature);
+                serverToolbarState.update();
+            }
+        }
+        //
+        //tell player that the item is no longer in their inventory
+        ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(creature);
+        for(Entity watcher : serverInventoryState.getWatchers()){
+            if(CreatureUtils.hasControllerPlayerId(watcher)){
+                //get player
+                int playerId = CreatureUtils.getControllerPlayerId(watcher);
+                Player controllerPlayer = Globals.playerManager.getPlayerFromId(playerId);
+                //tell the player they don't have the item anymore
+                controllerPlayer.addMessage(InventoryMessage.constructremoveItemFromInventoryMessage(item.getId()));
+            }
+        }
+        ServerEntityUtils.destroyEntity(item);
+    }
+
+    /**
+     * Creates an item in the creature's inventory
+     * @param creature The creature
+     * @param itemId The item's ID
+     */
+    public static void serverCreateInventoryItem(Entity creature, String itemId, int count){
+        Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(itemId);
+        if(itemData.getMaxStack() == null){
+            for(int i = 0; i < count; i++){
+                ItemUtils.serverCreateContainerItem(creature, itemData);
+            }
+        } else {
+            //scan for items to add charges to first
+            int added = 0;
+            List<Entity> existingItems = InventoryUtils.getAllInventoryItems(creature);
+            for(Entity existingItem : existingItems){
+                Item existingData = Globals.gameConfigCurrent.getItemMap().getItem(existingItem);
+                if(existingData.getId().equals(itemId)){
+                    ServerChargeState serverChargeState = ServerChargeState.getServerChargeState(existingItem);
+                    if(serverChargeState.getCharges() < existingData.getMaxStack()){
+                        int available = existingData.getMaxStack() - serverChargeState.getCharges();
+                        //just need to add charges to this
+                        if(available >= count - added){
+                            serverChargeState.attemptAddCharges(count - added);
+                            added = count;
+                            break;
+                        } else {
+                            serverChargeState.attemptAddCharges(available);
+                            added = added + available;
+                        }
+                    }
+                }
+            }
+            //need to start creating items to add more charges
+            Item targetData = Globals.gameConfigCurrent.getItemMap().getItem(itemId);
+            if(added < count){
+                int numFullItemsToAdd = (count - added) / targetData.getMaxStack();
+                int remainder = (count - added) % targetData.getMaxStack();
+                for(int i = 0; i < numFullItemsToAdd; i++){
+                    Entity newInventoryItem = ItemUtils.serverCreateContainerItem(creature, itemData);
+                    ServerChargeState.getServerChargeState(newInventoryItem).setCharges(targetData.getMaxStack());
+                }
+                if(remainder > 0){
+                    Entity newInventoryItem = ItemUtils.serverCreateContainerItem(creature, itemData);
+                    ServerChargeState.getServerChargeState(newInventoryItem).setCharges(remainder);
+                }
+            }
+        }
+    }
+
+    /**
+     * Checks if the enity has a given type of tool
+     * @param entity The entity
+     * @param toolType The type of tool
+     * @return true if it has the type of tool, false otherwise
+     */
+    public static boolean serverHasTool(Entity entity, String toolType){
+        List<Entity> items = InventoryUtils.getAllInventoryItems(entity);
+        for(Entity itemEnt : items){
+            Item itemData = Globals.gameConfigCurrent.getItemMap().getItem(itemEnt);
+            if(itemData.getTokens().contains(toolType)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Gets the current inventory state
+     * @param target the entity to get inventory state from
+     * @return The inventory state behavior tree or null
+     */
+    public static ServerInventoryState getServerInventoryState(Entity target){
+        if(!target.containsKey(EntityDataStrings.SERVER_INVENTORY_STATE)){
+            return null;
+        }
+        return (ServerInventoryState)target.getData(EntityDataStrings.SERVER_INVENTORY_STATE);
+    }
+
+    /**
+     * Sets the current inventory state
+     * @param target The entity to attach inventory state to
+     * @param state The inventory state to attach
+     */
+    public static void setServerInventoryState(Entity target, ServerInventoryState state){
+        target.putData(EntityDataStrings.SERVER_INVENTORY_STATE, state);
+    }
+    
 }

src/main/java/electrosphere/entity/state/item/ServerChargeState.java

@@ -3,7 +3,7 @@ package electrosphere.entity.state.item;
 
 import electrosphere.entity.btree.BehaviorTree;
 import electrosphere.entity.state.equip.ServerToolbarState;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.types.creature.CreatureUtils;
 import electrosphere.entity.types.item.ItemUtils;
 import electrosphere.engine.Globals;
@@ -81,7 +81,7 @@ public class ServerChargeState implements BehaviorTree {
         this.setCharges(this.getCharges() + charges);
         Entity containingParent = ItemUtils.getContainingParent(this.parent);
         if(this.charges <= 0){
-            InventoryUtils.serverDestroyInventoryItem(this.parent);
+            ServerInventoryState.serverDestroyInventoryItem(this.parent);
         } else if(containingParent != null) {
             if(CreatureUtils.hasControllerPlayerId(containingParent)){
                 //get the player

src/main/java/electrosphere/entity/types/common/CommonEntityUtils.java

@@ -444,7 +444,7 @@ public class CommonEntityUtils {
         if(rawType.getInventoryData() != null){
             if(rawType.getInventoryData().getNaturalSize() != null){
                 entity.putData(EntityDataStrings.NATURAL_INVENTORY,UnrelationalInventoryState.createUnrelationalInventory(rawType.getInventoryData().getNaturalSize()));
-                InventoryUtils.clientSetInventoryState(entity, ClientInventoryState.clientCreateInventoryState(entity));
+                ClientInventoryState.setClientInventoryState(entity, ClientInventoryState.clientCreateInventoryState(entity));
             }
         }
 
@@ -763,7 +763,7 @@ public class CommonEntityUtils {
         if(rawType.getInventoryData() != null){
             if(rawType.getInventoryData().getNaturalSize() != null){
                 entity.putData(EntityDataStrings.NATURAL_INVENTORY,UnrelationalInventoryState.createUnrelationalInventory(rawType.getInventoryData().getNaturalSize()));
-                InventoryUtils.serverSetInventoryState(entity, ServerInventoryState.serverCreateInventoryState(entity));
+                ServerInventoryState.setServerInventoryState(entity, ServerInventoryState.serverCreateInventoryState(entity));
             }
         }
 

src/main/java/electrosphere/entity/types/creature/CreatureUtils.java

@@ -24,7 +24,8 @@ import electrosphere.entity.state.equip.ClientToolbarState;
 import electrosphere.entity.state.equip.ServerEquipState;
 import electrosphere.entity.state.equip.ServerToolbarState;
 import electrosphere.entity.state.idle.ClientIdleTree;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ClientInventoryState;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.state.movement.groundmove.ClientGroundMovementTree;
 import electrosphere.entity.state.movement.groundmove.ServerGroundMovementTree;
 import electrosphere.entity.types.EntityTypes.EntityType;
@@ -176,7 +177,7 @@ public class CreatureUtils {
                     String equipSlot = equippedItem.getKey();
 
                     //add the item to the creature's inventory
-                    Entity itemInInventory = InventoryUtils.clientConstructInInventoryItem(creature,serialization.getSubtype());
+                    Entity itemInInventory = ClientInventoryState.clientConstructInInventoryItem(creature,serialization.getSubtype());
 
                     //equip the item to the slot defined in the template
                     ClientEquipState clientEquipState = ClientEquipState.getEquipState(creature);
@@ -188,7 +189,7 @@ public class CreatureUtils {
                 int i = 0;
                 for(EntitySerialization naturalItem : inventoryData.getNaturalItems()){
                     //add the item to the creature's inventory
-                    Entity itemInInventory = InventoryUtils.clientConstructInInventoryItem(creature,naturalItem.getSubtype());
+                    Entity itemInInventory = ClientInventoryState.clientConstructInInventoryItem(creature,naturalItem.getSubtype());
 
                     //map the constructed item to its server id
                     Globals.clientSceneWrapper.mapIdToId(itemInInventory.getId(), inventoryData.getNaturalId(i));
@@ -323,7 +324,7 @@ public class CreatureUtils {
                     Entity itemInWorld = ContentSerialization.serverHydrateEntitySerialization(realm, serialization);
 
                     //add the item to the creature's inventory
-                    Entity itemInInventory = InventoryUtils.serverAttemptStoreItemTransform(creature, EntityLookupUtils.getEntityById(itemInWorld.getId()));
+                    Entity itemInInventory = ServerInventoryState.serverAttemptStoreItemTransform(creature, EntityLookupUtils.getEntityById(itemInWorld.getId()));
 
                     //equip the item to the slot defined in the template
                     ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(creature);
@@ -337,7 +338,7 @@ public class CreatureUtils {
                     Entity itemInWorld = ItemUtils.serverSpawnBasicItem(realm, EntityUtils.getPosition(creature), serialization.getSubtype());
 
                     //add the item to the creature's inventory
-                    Entity itemInInventory = InventoryUtils.serverAttemptStoreItemTransform(creature, EntityLookupUtils.getEntityById(itemInWorld.getId()));
+                    Entity itemInInventory = ServerInventoryState.serverAttemptStoreItemTransform(creature, EntityLookupUtils.getEntityById(itemInWorld.getId()));
 
                     //equip the item to the slot defined in the template
                     ServerEquipState serverEquipState = ServerEquipState.getEquipState(creature);
@@ -348,7 +349,7 @@ public class CreatureUtils {
                     Entity itemInWorld = ItemUtils.serverSpawnBasicItem(realm, EntityUtils.getPosition(creature), naturalItem.getSubtype());
 
                     //add the item to the creature's inventory
-                    InventoryUtils.serverAttemptStoreItemTransform(creature, EntityLookupUtils.getEntityById(itemInWorld.getId()));
+                    ServerInventoryState.serverAttemptStoreItemTransform(creature, EntityLookupUtils.getEntityById(itemInWorld.getId()));
                 }
             }
         }

src/main/java/electrosphere/net/client/protocol/InventoryProtocol.java

@@ -2,7 +2,6 @@ package electrosphere.net.client.protocol;
 
 import electrosphere.engine.Globals;
 import electrosphere.entity.state.inventory.ClientInventoryState;
-import electrosphere.entity.state.inventory.InventoryUtils;
 import electrosphere.logger.LoggerInterface;
 import electrosphere.net.parser.net.message.InventoryMessage;
 import electrosphere.net.template.ClientProtocolTemplate;
@@ -24,7 +23,7 @@ public class InventoryProtocol implements ClientProtocolTemplate<InventoryMessag
                 LoggerInterface.loggerNetworking.DEBUG("[CLIENT] ADD ITEM TO INVENTORY " + message.getentityId());
                 if(Globals.playerEntity != null){
                     ClientInventoryState inventoryState;
-                    if((inventoryState = InventoryUtils.clientGetInventoryState(Globals.playerEntity))!=null){
+                    if((inventoryState = ClientInventoryState.getClientInventoryState(Globals.playerEntity))!=null){
                         inventoryState.addNetworkMessage(message);
                     }
                 }
@@ -33,7 +32,7 @@ public class InventoryProtocol implements ClientProtocolTemplate<InventoryMessag
                 LoggerInterface.loggerNetworking.DEBUG("[CLIENT] EQUIP ITEM " + message.getentityId());
                 if(Globals.playerEntity != null){
                     ClientInventoryState inventoryState;
-                    if((inventoryState = InventoryUtils.clientGetInventoryState(Globals.playerEntity))!=null){
+                    if((inventoryState = ClientInventoryState.getClientInventoryState(Globals.playerEntity))!=null){
                         inventoryState.addNetworkMessage(message);
                     }
                 }
@@ -42,7 +41,7 @@ public class InventoryProtocol implements ClientProtocolTemplate<InventoryMessag
                 LoggerInterface.loggerNetworking.DEBUG("[CLIENT] REMOVE ITEM FROM INVENTORY " + message.getentityId());
                 if(Globals.playerEntity != null){
                     ClientInventoryState inventoryState;
-                    if((inventoryState = InventoryUtils.clientGetInventoryState(Globals.playerEntity))!=null){
+                    if((inventoryState = ClientInventoryState.getClientInventoryState(Globals.playerEntity))!=null){
                         inventoryState.addNetworkMessage(message);
                     }
                 }
@@ -51,7 +50,7 @@ public class InventoryProtocol implements ClientProtocolTemplate<InventoryMessag
                 LoggerInterface.loggerNetworking.DEBUG("[CLIENT] MOVE ITEM INVENTORY " + message.getentityId());
                 if(Globals.playerEntity != null){
                     ClientInventoryState inventoryState;
-                    if((inventoryState = InventoryUtils.clientGetInventoryState(Globals.playerEntity))!=null){
+                    if((inventoryState = ClientInventoryState.getClientInventoryState(Globals.playerEntity))!=null){
                         inventoryState.addNetworkMessage(message);
                     }
                 }
@@ -60,7 +59,7 @@ public class InventoryProtocol implements ClientProtocolTemplate<InventoryMessag
                 LoggerInterface.loggerNetworking.DEBUG("[CLIENT] UNEQUIP ITEM " + message.getentityId());
                 if(Globals.playerEntity != null){
                     ClientInventoryState inventoryState;
-                    if((inventoryState = InventoryUtils.clientGetInventoryState(Globals.playerEntity))!=null){
+                    if((inventoryState = ClientInventoryState.getClientInventoryState(Globals.playerEntity))!=null){
                         inventoryState.addNetworkMessage(message);
                     }
                 }
@@ -69,7 +68,7 @@ public class InventoryProtocol implements ClientProtocolTemplate<InventoryMessag
                 LoggerInterface.loggerNetworking.DEBUG("[CLIENT] SET CHARGES OF " + message.getentityId());
                 if(Globals.playerEntity != null){
                     ClientInventoryState inventoryState;
-                    if((inventoryState = InventoryUtils.clientGetInventoryState(Globals.playerEntity))!=null){
+                    if((inventoryState = ClientInventoryState.getClientInventoryState(Globals.playerEntity))!=null){
                         inventoryState.addNetworkMessage(message);
                     }
                 }

src/main/java/electrosphere/net/server/protocol/InventoryProtocol.java

@@ -4,6 +4,7 @@ import electrosphere.data.crafting.RecipeData;
 import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.logger.LoggerInterface;
 import electrosphere.net.parser.net.message.InventoryMessage;
 import electrosphere.net.server.ServerConnectionHandler;
@@ -46,28 +47,28 @@ public class InventoryProtocol implements ServerProtocolTemplate<InventoryMessag
                 LoggerInterface.loggerNetworking.DEBUG("[SERVER] ADD ITEM TO INVENTORY " + message.getentityId());
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasNaturalInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
                 break;
             case REMOVEITEMFROMINVENTORY:
                 LoggerInterface.loggerNetworking.DEBUG("[SERVER] REMOVE ITEM FROM INVENTORY " + message.getentityId());
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasNaturalInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
                 break;
             case CLIENTREQUESTEQUIPITEM:
                 LoggerInterface.loggerNetworking.DEBUG("[SERVER] REQUEST EQUIP ITEM " + message.getentityId());
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasNaturalInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
                 break;
             case CLIENTREQUESTUNEQUIPITEM:
                 LoggerInterface.loggerNetworking.DEBUG("[SERVER] REQUEST UNEQUIP ITEM " + message.getentityId());
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasNaturalInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
                 break;
             case CLIENTREQUESTPERFORMITEMACTION: {
@@ -76,19 +77,19 @@ public class InventoryProtocol implements ServerProtocolTemplate<InventoryMessag
             case CLIENTREQUESTADDTOOLBAR: {
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasToolbarInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
             } break;
             case CLIENTREQUESTADDNATURAL: {
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasNaturalInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
             } break;
             case CLIENTUPDATETOOLBAR: {
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasToolbarInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
             } break;
             case CLIENTREQUESTCRAFT: {
@@ -106,7 +107,7 @@ public class InventoryProtocol implements ServerProtocolTemplate<InventoryMessag
             case CLIENTREQUESTSTOREITEM: {
                 target = EntityLookupUtils.getEntityById(connectionHandler.getPlayerEntityId());
                 if(target != null && InventoryUtils.hasNaturalInventory(target)){
-                    InventoryUtils.serverGetInventoryState(target).addNetworkMessage(message);
+                    ServerInventoryState.getServerInventoryState(target).addNetworkMessage(message);
                 }
             } break;
             case SERVERCOMMANDUNEQUIPITEM:

src/main/java/electrosphere/server/ai/nodes/actions/interact/CollectItemNode.java

@@ -5,7 +5,7 @@ import org.joml.Vector3d;
 import electrosphere.collision.CollisionEngine;
 import electrosphere.entity.Entity;
 import electrosphere.entity.EntityUtils;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.server.ai.blackboard.Blackboard;
 import electrosphere.server.ai.nodes.AITreeNode;
 import electrosphere.server.ai.nodes.plan.TargetEntityCategoryNode;
@@ -26,7 +26,7 @@ public class CollectItemNode implements AITreeNode {
         if(parentPos.distance(targetPos) > CollisionEngine.DEFAULT_INTERACT_DISTANCE){
             return AITreeNodeResult.FAILURE;
         }
-        InventoryUtils.serverAttemptStoreItemTransform(entity, target);
+        ServerInventoryState.serverAttemptStoreItemTransform(entity, target);
         TargetEntityCategoryNode.setTarget(blackboard, null);
         return AITreeNodeResult.SUCCESS;
     }

src/main/java/electrosphere/server/entity/unit/UnitUtils.java

@@ -8,7 +8,7 @@ import electrosphere.data.units.UnitLoader;
 import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.state.equip.ServerEquipState;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.types.creature.ObjectTemplate;
 import electrosphere.entity.types.EntityTypes.EntityType;
 import electrosphere.entity.types.creature.CreatureUtils;
@@ -61,7 +61,7 @@ public class UnitUtils {
                 Entity itemInWorld = ItemUtils.serverSpawnBasicItem(realm, position, equippedItem.getItemId());
 
                 //add the item to the creature's inventory
-                Entity itemInInventory = InventoryUtils.serverAttemptStoreItemTransform(rVal, itemInWorld);
+                Entity itemInInventory = ServerInventoryState.serverAttemptStoreItemTransform(rVal, itemInWorld);
 
                 //equip the item to the slot defined in the template
                 ServerEquipState serverEquipState = ServerEquipState.getEquipState(rVal);

src/main/java/electrosphere/server/physics/terrain/editing/TerrainEditing.java

@@ -11,7 +11,7 @@ import electrosphere.data.item.Item;
 import electrosphere.data.voxel.VoxelType;
 import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.server.datacell.Realm;
 import electrosphere.server.datacell.ServerWorldData;
 import electrosphere.server.datacell.interfaces.VoxelCellManager;
@@ -179,7 +179,7 @@ public class TerrainEditing {
                 VoxelType voxelType = Globals.gameConfigCurrent.getVoxelData().getTypeFromId(typeEntry.getKey());
                 Item voxelItem = Globals.gameConfigCurrent.getItemMap().getItem(Item.getVoxelTypeId(voxelType));
                 int count = -(int)(float)typeEntry.getValue();
-                InventoryUtils.serverCreateInventoryItem(sourceEntity, voxelItem.getId(), count);
+                ServerInventoryState.serverCreateInventoryItem(sourceEntity, voxelItem.getId(), count);
             }
 
         }

src/main/java/electrosphere/server/player/CraftingActions.java

@@ -13,6 +13,7 @@ import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.state.inventory.InventoryUtils;
 import electrosphere.entity.state.inventory.RelationalInventoryState;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.state.inventory.UnrelationalInventoryState;
 import electrosphere.entity.state.item.ServerChargeState;
 
@@ -28,7 +29,7 @@ public class CraftingActions {
      * @param recipe The recipe to craft
      */
     public static void attemptCraft(Entity crafter, Entity station, RecipeData recipe){
-        if(InventoryUtils.serverGetInventoryState(crafter) == null){
+        if(ServerInventoryState.getServerInventoryState(crafter) == null){
             return;
         }
         UnrelationalInventoryState naturalInventory = InventoryUtils.getNaturalInventory(crafter);
@@ -118,7 +119,7 @@ public class CraftingActions {
                         if(toolbarInventory != null){
                             toolbarInventory.tryRemoveItem(reagentEnt);
                         }
-                        InventoryUtils.serverDestroyInventoryItem(reagentEnt);
+                        ServerInventoryState.serverDestroyInventoryItem(reagentEnt);
                         ingredientAccretionMap.put(itemData.getId(),alreadyFound + available);
                     }
                 } else {
@@ -128,7 +129,7 @@ public class CraftingActions {
                     if(toolbarInventory != null){
                         toolbarInventory.tryRemoveItem(reagentEnt);
                     }
-                    InventoryUtils.serverDestroyInventoryItem(reagentEnt);
+                    ServerInventoryState.serverDestroyInventoryItem(reagentEnt);
                     ingredientAccretionMap.put(itemData.getId(),alreadyFound + 1);
                 }
             }
@@ -137,7 +138,7 @@ public class CraftingActions {
                 if(productType == null){
                     throw new Error("Could not locate product definition! " + productType + " " + product.getItemType());
                 }
-                InventoryUtils.serverCreateInventoryItem(crafter, product.getItemType(), product.getCount());
+                ServerInventoryState.serverCreateInventoryItem(crafter, product.getItemType(), product.getCount());
             }
         }
     }
@@ -150,7 +151,7 @@ public class CraftingActions {
      * @return true if it can perform the recipe, false otherwise
      */
     public static boolean canCraft(Entity crafter, Entity workstation, RecipeData recipe){
-        if(InventoryUtils.serverGetInventoryState(crafter) == null){
+        if(ServerInventoryState.getServerInventoryState(crafter) == null){
             return false;
         }
         UnrelationalInventoryState naturalInventory = InventoryUtils.getNaturalInventory(crafter);

src/test/java/electrosphere/entity/state/attack/ServerAttackTreeTests.java

@@ -10,7 +10,7 @@ import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.state.attack.ClientAttackTree.AttackTreeState;
 import electrosphere.entity.state.equip.ServerToolbarState;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.state.movement.fall.ServerFallTree;
 import electrosphere.entity.state.movement.groundmove.ServerGroundMovementTree;
 import electrosphere.entity.state.movement.groundmove.ClientGroundMovementTree.MovementRelativeFacing;
@@ -40,7 +40,7 @@ public class ServerAttackTreeTests extends EntityTestTemplate {
         Entity katana = ItemUtils.serverSpawnBasicItem(Globals.realmManager.first(), new Vector3d(0,0,0), "Katana2H");
 
         //equip
-        Entity inInventoryItem = InventoryUtils.serverAttemptStoreItemTransform(creature, katana);
+        Entity inInventoryItem = ServerInventoryState.serverAttemptStoreItemTransform(creature, katana);
         ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(creature);
         serverToolbarState.attemptEquip(inInventoryItem, 0);
         
@@ -75,7 +75,7 @@ public class ServerAttackTreeTests extends EntityTestTemplate {
         Entity katana = ItemUtils.serverSpawnBasicItem(Globals.realmManager.first(), new Vector3d(0,0,0), "Katana2H");
 
         //equip
-        Entity inInventoryItem = InventoryUtils.serverAttemptStoreItemTransform(creature, katana);
+        Entity inInventoryItem = ServerInventoryState.serverAttemptStoreItemTransform(creature, katana);
         ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(creature);
         serverToolbarState.attemptEquip(inInventoryItem, 0);
         

src/test/java/electrosphere/entity/state/equip/ClientEquipStateTests.java

@@ -14,7 +14,9 @@ import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.EntityTags;
 import electrosphere.entity.state.attach.AttachUtils;
+import electrosphere.entity.state.inventory.ClientInventoryState;
 import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.state.inventory.UnrelationalInventoryState;
 import electrosphere.entity.types.creature.ObjectTemplate;
 import electrosphere.entity.types.EntityTypes.EntityType;
@@ -54,7 +56,7 @@ public class ClientEquipStateTests extends EntityTestTemplate {
         assertEquals(1, clientSideItems.size());
 
         //equip
-        Entity inInventoryItem = InventoryUtils.serverAttemptStoreItemTransform(creature, katana);
+        Entity inInventoryItem = ServerInventoryState.serverAttemptStoreItemTransform(creature, katana);
         ServerEquipState serverEquipState = ServerEquipState.getServerEquipState(creature);
         serverEquipState.commandAttemptEquip(inInventoryItem, serverEquipState.getEquipPoint("handsCombined"));
 
@@ -106,7 +108,7 @@ public class ClientEquipStateTests extends EntityTestTemplate {
 
         //try to store item in inventory
         Entity katanaOnClient = clientSideItems.iterator().next();
-        InventoryUtils.clientAttemptStoreItem(Globals.playerEntity, katanaOnClient);
+        ClientInventoryState.clientAttemptStoreItem(Globals.playerEntity, katanaOnClient);
 
         //wait for server to perform transform
         TestEngineUtils.simulateFrames(5);

src/test/java/electrosphere/entity/state/equip/ServerEquipStateTests.java

@@ -12,7 +12,7 @@ import electrosphere.test.annotations.IntegrationTest;
 import electrosphere.engine.Globals;
 import electrosphere.entity.Entity;
 import electrosphere.entity.state.attach.AttachUtils;
-import electrosphere.entity.state.inventory.InventoryUtils;
+import electrosphere.entity.state.inventory.ServerInventoryState;
 import electrosphere.entity.types.creature.ObjectTemplate;
 import electrosphere.entity.types.EntityTypes.EntityType;
 import electrosphere.entity.types.creature.CreatureUtils;
@@ -37,7 +37,7 @@ public class ServerEquipStateTests extends EntityTestTemplate {
         Entity katana = ItemUtils.serverSpawnBasicItem(Globals.realmManager.first(), new Vector3d(0,0,0), "Katana2H");
 
         //equip
-        Entity inInventoryItem = InventoryUtils.serverAttemptStoreItemTransform(creature, katana);
+        Entity inInventoryItem = ServerInventoryState.serverAttemptStoreItemTransform(creature, katana);
         ServerEquipState serverEquipState = ServerEquipState.getServerEquipState(creature);
         serverEquipState.commandAttemptEquip(inInventoryItem, serverEquipState.getEquipPoint("handsCombined"));
 
@@ -70,7 +70,7 @@ public class ServerEquipStateTests extends EntityTestTemplate {
         Entity katana2 = ItemUtils.serverSpawnBasicItem(Globals.realmManager.first(), new Vector3d(0,0,0), "Katana2H");
 
         //equip
-        Entity inInventoryItem = InventoryUtils.serverAttemptStoreItemTransform(creature, katana);
+        Entity inInventoryItem = ServerInventoryState.serverAttemptStoreItemTransform(creature, katana);
         ServerEquipState serverEquipState = ServerEquipState.getServerEquipState(creature);
         serverEquipState.commandAttemptEquip(inInventoryItem, serverEquipState.getEquipPoint("handsCombined"));
 
@@ -78,7 +78,7 @@ public class ServerEquipStateTests extends EntityTestTemplate {
         TestEngineUtils.simulateFrames(1);
 
         //attempt to equip second katana
-        Entity inInventoryItem2 = InventoryUtils.serverAttemptStoreItemTransform(creature, katana2);
+        Entity inInventoryItem2 = ServerInventoryState.serverAttemptStoreItemTransform(creature, katana2);
         serverEquipState.commandAttemptEquip(inInventoryItem2, serverEquipState.getEquipPoint("handsCombined"));
 
         //propagate to client

src/test/java/electrosphere/entity/state/inventory/InventoryUtilsTests.java

@@ -49,7 +49,7 @@ public class InventoryUtilsTests extends EntityTestTemplate {
         Globals.playerEntity = clientCreature;
 
         //attempt to store
-        InventoryUtils.clientAttemptStoreItem(clientCreature, clientKatana);
+        ClientInventoryState.clientAttemptStoreItem(clientCreature, clientKatana);
 
         //propagate to client
         TestEngineUtils.simulateFrames(2);
@@ -102,7 +102,7 @@ public class InventoryUtilsTests extends EntityTestTemplate {
         Globals.playerEntity = clientCreature;
 
         //attempt to store
-        InventoryUtils.clientAttemptStoreItem(clientCreature, clientKatana);
+        ClientInventoryState.clientAttemptStoreItem(clientCreature, clientKatana);
 
         //allow time for client->server->client communication
         TestEngineUtils.simulateFrames(2);
@@ -110,7 +110,7 @@ public class InventoryUtilsTests extends EntityTestTemplate {
         //attempt to eject
         clientSideItems = Globals.clientSceneWrapper.getScene().getEntitiesWithTag(EntityTags.ITEM);
         clientKatana = clientSideItems.iterator().next();
-        InventoryUtils.clientAttemptEjectItem(clientCreature, clientKatana);
+        ClientInventoryState.clientAttemptEjectItem(clientCreature, clientKatana);
 
         //allow time for client->server->client communication
         TestEngineUtils.simulateFrames(2);
@@ -161,7 +161,7 @@ public class InventoryUtilsTests extends EntityTestTemplate {
         Globals.playerEntity = clientCreature;
 
         //try creating the item on the client
-        InventoryUtils.clientConstructInInventoryItem(clientCreature, "Katana2H");
+        ClientInventoryState.clientConstructInInventoryItem(clientCreature, "Katana2H");
 
         //verify we still have everything
         clientSideCreatures = Globals.clientSceneWrapper.getScene().getEntitiesWithTag(EntityTags.CREATURE);