studiorailgun/Renderer
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

break up inventoryutils

Browse Source
This commit is contained in:
austin 2025-05-14 11:36:49 -04:00
parent 91dd628cbb
commit 0cb08e3d42
22 changed files with 768 additions and 771 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/electrosphere/client/interact/ButtonInteraction.java
View File

@ -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());
}
}
}

4
src/main/java/electrosphere/client/ui/menu/ingame/MenuGeneratorsInventory.java
View File

@ -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));

3
src/main/java/electrosphere/controls/categories/ControlCategoryMainGame.java
View File

@ -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);
}
}
}

3
src/main/java/electrosphere/data/item/source/ItemSourcingTree.java
View File

@ -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;
}

4
src/main/java/electrosphere/entity/ClientEntityUtils.java
View File

@ -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);
}

5
src/main/java/electrosphere/entity/ServerEntityUtils.java
View File

@ -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){
ServerInventoryState serverInventoryState = InventoryUtils.serverGetInventoryState(entity);
if(ServerInventoryState.getServerInventoryState(entity) != null){
ServerInventoryState serverInventoryState = ServerInventoryState.getServerInventoryState(entity);
serverInventoryState.destroy();
}

158
src/main/java/electrosphere/entity/state/inventory/ClientInventoryState.java
View File

@ -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);
}
}

697
src/main/java/electrosphere/entity/state/inventory/InventoryUtils.java
View File

@ -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;
}
}

560
src/main/java/electrosphere/entity/state/inventory/ServerInventoryState.java
View File

@ -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){
ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
if(ServerInventoryState.getServerInventoryState(target) != null){
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){
ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
if(ServerInventoryState.getServerInventoryState(target) != null){
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){
ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
if(ServerInventoryState.getServerInventoryState(target) != null){
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){
ServerInventoryState targetState = InventoryUtils.serverGetInventoryState(target);
if(ServerInventoryState.getServerInventoryState(target) != null){
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);
}
}

4
src/main/java/electrosphere/entity/state/item/ServerChargeState.java
View File

@ -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

4
src/main/java/electrosphere/entity/types/common/CommonEntityUtils.java
View File

@ -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));
}
}

13
src/main/java/electrosphere/entity/types/creature/CreatureUtils.java
View File

@ -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()));
}
}
}

13
src/main/java/electrosphere/net/client/protocol/InventoryProtocol.java
View File

@ -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);
}
}

17
src/main/java/electrosphere/net/server/protocol/InventoryProtocol.java
View File

@ -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:

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

@ -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;
}

4
src/main/java/electrosphere/server/entity/unit/UnitUtils.java
View File

@ -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);

4
src/main/java/electrosphere/server/physics/terrain/editing/TerrainEditing.java
View File

@ -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);
}
}

11
src/main/java/electrosphere/server/player/CraftingActions.java
View File

@ -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);

6
src/test/java/electrosphere/entity/state/attack/ServerAttackTreeTests.java
View File

@ -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);

6
src/test/java/electrosphere/entity/state/equip/ClientEquipStateTests.java
View File

@ -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);

8
src/test/java/electrosphere/entity/state/equip/ServerEquipStateTests.java
View File

@ -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

8
src/test/java/electrosphere/entity/state/inventory/InventoryUtilsTests.java
View File

@ -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);