com/hypixel/hytale/server/core/inventory/Inventory.java
package com.hypixel.hytale.server.core.inventory;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.event.IEventDispatcher;
import com.hypixel.hytale.protocol.BlockMaterial;
import com.hypixel.hytale.protocol.BlockPosition;
import com.hypixel.hytale.protocol.InteractionChainData;
import com.hypixel.hytale.protocol.InteractionType;
import com.hypixel.hytale.protocol.ItemArmorSlot;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.PickupLocation;
import com.hypixel.hytale.protocol.SmartMoveType;
import com.hypixel.hytale.protocol.Vector3f;
import com.hypixel.hytale.protocol.packets.inventory.UpdatePlayerInventory;
import com.hypixel.hytale.server.core.HytaleServer;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemArmor;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemUtility;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemWeapon;
import com.hypixel.hytale.server.core.entity.InteractionChain;
import com.hypixel.hytale.server.core.entity.InteractionContext;
import com.hypixel.hytale.server.core.entity.InteractionManager;
import com.hypixel.hytale.server.core.entity.LivingEntity;
import com.hypixel.hytale.server.core.entity.StatModifiersManager;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.entity.entities.player.windows.ItemContainerWindow;
import com.hypixel.hytale.server.core.entity.entities.player.windows.Window;
import com.hypixel.hytale.server.core.event.events.entity.LivingEntityInventoryChangeEvent;
import com.hypixel.hytale.server.core.inventory.container.CombinedItemContainer;
import com.hypixel.hytale.server.core.inventory.container.EmptyItemContainer;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import com.hypixel.hytale.server.core.inventory.container.ItemContainerUtil;
import com.hypixel.hytale.server.core.inventory.container.SimpleItemContainer;
import com.hypixel.hytale.server.core.inventory.container.SortType;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MoveTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.none.ChangeActiveSlotInteraction;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import com.hypixel.hytale.server.core.util.UUIDUtil;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class Inventory implements NetworkSerializable<UpdatePlayerInventory> {
public static final short DEFAULT_HOTBAR_CAPACITY = 9;
public static final short DEFAULT_UTILITY_CAPACITY = 4;
public static final short DEFAULT_TOOLS_CAPACITY = 23;
public static final short DEFAULT_ARMOR_CAPACITY;
public static final short DEFAULT_STORAGE_ROWS = 4;
public static final short DEFAULT_STORAGE_COLUMNS = 9;
public static final short DEFAULT_STORAGE_CAPACITY = 36;
public static final int HOTBAR_SECTION_ID = -1;
public static final int STORAGE_SECTION_ID = -2;
public static final int ARMOR_SECTION_ID = -3;
public static final int UTILITY_SECTION_ID = -5;
public static final int TOOLS_SECTION_ID = -8;
public static final int BACKPACK_SECTION_ID = -9;
public static final byte INACTIVE_SLOT_INDEX = -1;
public static final int VERSION = 4;
public static final BuilderCodec<Inventory> CODEC;
private final AtomicBoolean isDirty;
private final AtomicBoolean needsSaving;
private ItemContainer storage;
private ItemContainer armor;
private ItemContainer hotbar;
private ItemContainer utility;
@Deprecated
private ItemContainer tools;
private ItemContainer backpack;
private CombinedItemContainer combinedHotbarFirst;
private CombinedItemContainer combinedStorageFirst;
private CombinedItemContainer combinedBackpackStorageHotbar;
private CombinedItemContainer combinedStorageHotbarBackpack;
private CombinedItemContainer combinedArmorHotbarStorage;
private CombinedItemContainer combinedArmorHotbarUtilityStorage;
private CombinedItemContainer combinedHotbarUtilityConsumableStorage;
private CombinedItemContainer combinedEverything;
private byte activeHotbarSlot;
private byte activeUtilitySlot;
private byte activeToolsSlot;
@Nullable
private LivingEntity entity;
@Deprecated
private SortType sortType;
@Nullable
private EventRegistration armorChange;
@Nullable
private EventRegistration storageChange;
@Nullable
private EventRegistration hotbarChange;
@Nullable
private EventRegistration utilityChange;
@Nullable
private EventRegistration toolChange;
@Nullable
private EventRegistration backpackChange;
private boolean _usingToolsItem;
private Inventory(Void dummy) {
this.isDirty = new AtomicBoolean();
this.needsSaving = new AtomicBoolean();
this.storage = EmptyItemContainer.INSTANCE;
this.armor = EmptyItemContainer.INSTANCE;
this.hotbar = EmptyItemContainer.INSTANCE;
this.utility = EmptyItemContainer.INSTANCE;
this.tools = EmptyItemContainer.INSTANCE;
this.backpack = EmptyItemContainer.INSTANCE;
this.activeUtilitySlot = -1;
this.activeToolsSlot = -1;
this.sortType = SortType.NAME;
this._usingToolsItem = false;
}
public Inventory() {
this((short)36, DEFAULT_ARMOR_CAPACITY, (short)9, (short)4, (short)23);
}
public Inventory(short storageCapacity, short armorCapacity, short hotbarCapacity, short utilityCapacity, short toolCapacity) {
this((ItemContainer)(storageCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(storageCapacity)), (ItemContainer)(armorCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(armorCapacity)), (ItemContainer)(hotbarCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(hotbarCapacity)), (ItemContainer)(utilityCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(utilityCapacity)), (ItemContainer)(toolCapacity == 0 ? EmptyItemContainer.INSTANCE : new SimpleItemContainer(toolCapacity)), EmptyItemContainer.INSTANCE);
}
public Inventory(ItemContainer storage, ItemContainer armor, ItemContainer hotbar, ItemContainer utility, ItemContainer tools, ItemContainer backpack) {
this.isDirty = new AtomicBoolean();
this.needsSaving = new AtomicBoolean();
this.storage = EmptyItemContainer.INSTANCE;
this.armor = EmptyItemContainer.INSTANCE;
this.hotbar = EmptyItemContainer.INSTANCE;
this.utility = EmptyItemContainer.INSTANCE;
this.tools = EmptyItemContainer.INSTANCE;
this.backpack = EmptyItemContainer.INSTANCE;
this.activeUtilitySlot = -1;
this.activeToolsSlot = -1;
this.sortType = SortType.NAME;
this._usingToolsItem = false;
this.storage = storage;
this.armor = ItemContainerUtil.trySetArmorFilters(armor);
this.hotbar = hotbar;
this.utility = ItemContainerUtil.trySetSlotFilters(utility, (type, container, slot, itemStack) -> itemStack == null || itemStack.getItem().getUtility().isUsable());
this.tools = tools;
this.backpack = backpack;
this.buildCombinedContains();
this.registerChangeEvents();
}
protected void registerChangeEvents() {
this.storageChange = this.storage.registerChangeEvent((e) -> {
this.markChanged();
IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
if (dispatcher.hasListener()) {
dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
}
});
this.armorChange = this.armor.registerChangeEvent((e) -> {
this.markChanged();
IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
if (dispatcher.hasListener()) {
dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
}
this.entity.invalidateEquipmentNetwork();
});
this.hotbarChange = this.hotbar.registerChangeEvent((e) -> {
this.markChanged();
IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
if (dispatcher.hasListener()) {
dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
}
if (this.activeHotbarSlot != -1 && this.entity != null && e.transaction().wasSlotModified((short)this.activeHotbarSlot)) {
Transaction patt0$temp = e.transaction();
if (patt0$temp instanceof SlotTransaction) {
SlotTransaction slot = (SlotTransaction)patt0$temp;
if (ItemStack.isEquivalentType(slot.getSlotBefore(), slot.getSlotAfter())) {
return;
}
}
StatModifiersManager statModifiersManager = this.entity.getStatModifiersManager();
this.entity.invalidateEquipmentNetwork();
statModifiersManager.setRecalculate(true);
ItemStack itemStack = this.getItemInHand();
if (itemStack == null) {
return;
}
ItemWeapon itemWeapon = itemStack.getItem().getWeapon();
if (itemWeapon == null) {
return;
}
int[] entityStatsToClear = itemWeapon.getEntityStatsToClear();
if (entityStatsToClear == null) {
return;
}
statModifiersManager.queueEntityStatsToClear(entityStatsToClear);
}
});
this.utilityChange = this.utility.registerChangeEvent((e) -> {
this.markChanged();
IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
if (dispatcher.hasListener()) {
dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
}
if (this.activeUtilitySlot != -1 && this.entity != null && e.transaction().wasSlotModified((short)this.activeUtilitySlot)) {
Transaction patt0$temp = e.transaction();
if (patt0$temp instanceof SlotTransaction) {
SlotTransaction slot = (SlotTransaction)patt0$temp;
if (ItemStack.isEquivalentType(slot.getSlotBefore(), slot.getSlotAfter())) {
return;
}
}
StatModifiersManager statModifiersManager = this.entity.getStatModifiersManager();
this.entity.invalidateEquipmentNetwork();
statModifiersManager.setRecalculate(true);
ItemStack itemStack = this.getUtilityItem();
if (itemStack == null) {
return;
}
ItemUtility itemUtility = itemStack.getItem().getUtility();
if (itemUtility == null) {
return;
}
int[] entityStatsToClear = itemUtility.getEntityStatsToClear();
if (entityStatsToClear == null) {
return;
}
statModifiersManager.queueEntityStatsToClear(entityStatsToClear);
}
});
this.toolChange = this.tools.registerChangeEvent((e) -> {
this.markChanged();
IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
if (dispatcher.hasListener()) {
dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
}
});
this.registerBackpackListener();
}
private void registerBackpackListener() {
this.unregisterBackpackChange();
this.backpackChange = this.backpack.registerChangeEvent((e) -> {
this.markChanged();
IEventDispatcher<LivingEntityInventoryChangeEvent, LivingEntityInventoryChangeEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(LivingEntityInventoryChangeEvent.class, this.entity.getWorld().getName());
if (dispatcher.hasListener()) {
dispatcher.dispatch(new LivingEntityInventoryChangeEvent(this.entity, e.container(), e.transaction()));
}
});
}
public void unregister() {
this.entity = null;
if (this.storageChange != null) {
this.storageChange.unregister();
this.storageChange = null;
}
if (this.armorChange != null) {
this.armorChange.unregister();
this.armorChange = null;
}
if (this.hotbarChange != null) {
this.hotbarChange.unregister();
this.hotbarChange = null;
}
if (this.utilityChange != null) {
this.utilityChange.unregister();
this.utilityChange = null;
}
if (this.toolChange != null) {
this.toolChange.unregister();
this.toolChange = null;
}
this.unregisterBackpackChange();
}
private void unregisterBackpackChange() {
if (this.backpackChange != null) {
this.backpackChange.unregister();
this.backpackChange = null;
}
}
public void markChanged() {
this.isDirty.set(true);
this.needsSaving.set(true);
}
public void moveItem(int fromSectionId, int fromSlotId, int quantity, int toSectionId, int toSlotId) {
ItemContainer fromContainer = this.getSectionById(fromSectionId);
if (fromContainer != null) {
ItemContainer toContainer = this.getSectionById(toSectionId);
if (toContainer != null) {
if (this.entity instanceof Player && (toSectionId == -1 && this.activeHotbarSlot == toSlotId || fromSectionId == -1 && this.activeHotbarSlot == fromSlotId)) {
ItemStack fromItem = fromContainer.getItemStack((short)fromSlotId);
ItemStack currentItem = toContainer.getItemStack((short)toSlotId);
if (ItemStack.isStackableWith(fromItem, currentItem) || ItemStack.isSameItemType(fromItem, currentItem)) {
fromContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, toContainer, (short)toSlotId);
return;
}
int interactionSlot = toSectionId == -1 && this.activeHotbarSlot == toSlotId ? toSlotId : this.activeHotbarSlot;
Ref<EntityStore> ref = this.entity.getReference();
Store<EntityStore> store = ref.getStore();
InteractionManager interactionManagerComponent = (InteractionManager)store.getComponent(ref, InteractionModule.get().getInteractionManagerComponent());
if (interactionManagerComponent != null) {
PlayerRef playerRefComponent = (PlayerRef)store.getComponent(ref, PlayerRef.getComponentType());
assert playerRefComponent != null;
InteractionContext context = InteractionContext.forInteraction(interactionManagerComponent, ref, InteractionType.SwapFrom, store);
context.getMetaStore().putMetaObject(Interaction.TARGET_SLOT, interactionSlot);
context.getMetaStore().putMetaObject(ChangeActiveSlotInteraction.PLACE_MOVED_ITEM, (Runnable)() -> {
fromContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, toContainer, (short)toSlotId);
playerRefComponent.getPacketHandler().write((Packet)this.toPacket());
});
String interactions = context.getRootInteractionId(InteractionType.SwapFrom);
InteractionChainData data = new InteractionChainData(-1, UUIDUtil.EMPTY_UUID, (Vector3f)null, (String)null, (BlockPosition)null, -interactionSlot - 1, (Vector3f)null);
InteractionChain chain = interactionManagerComponent.initChain(data, InteractionType.SwapFrom, context, RootInteraction.getRootInteractionOrUnknown(interactions), (Runnable)null, false);
interactionManagerComponent.queueExecuteChain(chain);
return;
}
}
fromContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, toContainer, (short)toSlotId);
}
}
}
public void smartMoveItem(int fromSectionId, int fromSlotId, int quantity, @Nonnull SmartMoveType moveType) {
ItemContainer targetContainer = this.getSectionById(fromSectionId);
if (targetContainer != null) {
switch (moveType) {
case EquipOrMergeStack:
ItemStack itemStack = targetContainer.getItemStack((short)fromSlotId);
Item item = itemStack.getItem();
ItemArmor itemArmor = item.getArmor();
if (itemArmor != null && fromSectionId != -3) {
targetContainer.moveItemStackFromSlotToSlot((short)fromSlotId, quantity, this.armor, (short)itemArmor.getArmorSlot().ordinal());
return;
}
if (this.entity instanceof Player) {
for(Window window : ((Player)this.entity).getWindowManager().getWindows()) {
if (window instanceof ItemContainerWindow) {
((ItemContainerWindow)window).getItemContainer().combineItemStacksIntoSlot(targetContainer, (short)fromSlotId);
}
}
}
this.combinedHotbarFirst.combineItemStacksIntoSlot(targetContainer, (short)fromSlotId);
break;
case PutInHotbarOrWindow:
if (fromSectionId >= 0) {
targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedHotbarFirst);
return;
}
if (this.entity instanceof Player) {
for(Window window : ((Player)this.entity).getWindowManager().getWindows()) {
if (window instanceof ItemContainerWindow) {
ItemContainer itemContainer = ((ItemContainerWindow)window).getItemContainer();
MoveTransaction<ItemStackTransaction> transaction = targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, itemContainer);
ItemStack remainder = ((ItemStackTransaction)transaction.getAddTransaction()).getRemainder();
if (ItemStack.isEmpty(remainder) || remainder.getQuantity() != quantity) {
return;
}
}
}
}
switch (fromSectionId) {
case -2:
targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, this.hotbar);
return;
case -1:
targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, this.storage);
return;
default:
targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedHotbarFirst);
return;
}
case PutInHotbarOrBackpack:
if (fromSectionId == -9) {
targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedHotbarFirst);
} else {
targetContainer.moveItemStackFromSlot((short)fromSlotId, quantity, (ItemContainer)this.combinedBackpackStorageHotbar);
}
}
}
}
@Nullable
public ListTransaction<MoveTransaction<ItemStackTransaction>> takeAll(int inventorySectionId) {
ItemContainer sectionById = this.getSectionById(inventorySectionId);
return sectionById != null ? sectionById.moveAllItemStacksTo(this.combinedArmorHotbarStorage) : null;
}
@Nullable
public ListTransaction<MoveTransaction<ItemStackTransaction>> putAll(int inventorySectionId) {
ItemContainer sectionById = this.getSectionById(inventorySectionId);
return sectionById != null ? this.storage.moveAllItemStacksTo(sectionById) : null;
}
@Nullable
public ListTransaction<MoveTransaction<ItemStackTransaction>> quickStack(int inventorySectionId) {
ItemContainer sectionById = this.getSectionById(inventorySectionId);
return sectionById != null ? this.combinedHotbarFirst.quickStackTo(new ItemContainer[]{sectionById}) : null;
}
@Nonnull
public List<ItemStack> dropAllItemStacks() {
List<ItemStack> items = new ObjectArrayList<ItemStack>();
items.addAll(this.storage.dropAllItemStacks());
items.addAll(this.armor.dropAllItemStacks());
items.addAll(this.hotbar.dropAllItemStacks());
items.addAll(this.utility.dropAllItemStacks());
items.addAll(this.backpack.dropAllItemStacks());
return items;
}
public void clear() {
this.storage.clear();
this.armor.clear();
this.hotbar.clear();
this.utility.clear();
this.backpack.clear();
}
public ItemContainer getStorage() {
return this.storage;
}
public ItemContainer getArmor() {
return this.armor;
}
public ItemContainer getHotbar() {
return this.hotbar;
}
public ItemContainer getUtility() {
return this.utility;
}
public ItemContainer getTools() {
return this.tools;
}
public ItemContainer getBackpack() {
return this.backpack;
}
public void resizeBackpack(short capacity, List<ItemStack> remainder) {
if (capacity > 0) {
this.backpack = ItemContainer.ensureContainerCapacity(this.backpack, capacity, SimpleItemContainer::new, remainder);
} else {
this.backpack = ItemContainer.copy(this.backpack, EmptyItemContainer.INSTANCE, remainder);
}
this.buildCombinedContains();
if (this.entity != null) {
this.registerBackpackListener();
}
this.markChanged();
}
public CombinedItemContainer getCombinedHotbarFirst() {
return this.combinedHotbarFirst;
}
public CombinedItemContainer getCombinedStorageFirst() {
return this.combinedStorageFirst;
}
public CombinedItemContainer getCombinedBackpackStorageHotbar() {
return this.combinedBackpackStorageHotbar;
}
public CombinedItemContainer getCombinedArmorHotbarStorage() {
return this.combinedArmorHotbarStorage;
}
public CombinedItemContainer getCombinedArmorHotbarUtilityStorage() {
return this.combinedArmorHotbarUtilityStorage;
}
public CombinedItemContainer getCombinedHotbarUtilityConsumableStorage() {
return this.combinedHotbarUtilityConsumableStorage;
}
public CombinedItemContainer getCombinedEverything() {
return this.combinedEverything;
}
@Nonnull
public ItemContainer getContainerForItemPickup(@Nonnull Item item, PlayerSettings playerSettings) {
if (item.getArmor() != null) {
return playerSettings.armorItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
} else if (item.getWeapon() == null && item.getTool() == null) {
if (item.getUtility().isUsable()) {
return playerSettings.usableItemsItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
} else {
BlockType blockType = item.hasBlockType() ? (BlockType)BlockType.getAssetMap().getAsset(item.getBlockId()) : BlockType.EMPTY;
if (blockType == null) {
blockType = BlockType.EMPTY;
}
if (blockType.getMaterial() == BlockMaterial.Solid) {
return playerSettings.solidBlockItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
} else {
return playerSettings.miscItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
}
}
} else {
return playerSettings.weaponAndToolItemsPreferredPickupLocation() == PickupLocation.Hotbar ? this.getCombinedHotbarFirst() : this.getCombinedStorageFirst();
}
}
public void setActiveSlot(int inventorySectionId, byte slot) {
int[] entityStatsToClear = null;
switch (inventorySectionId) {
case -8:
this.activeToolsSlot = slot;
break;
case -5:
this.activeUtilitySlot = slot;
ItemStack itemStack = this.getUtilityItem();
if (itemStack != null) {
ItemUtility utility = itemStack.getItem().getUtility();
entityStatsToClear = utility.getEntityStatsToClear();
}
break;
case -1:
this.activeHotbarSlot = slot;
ItemStack itemStack = this.getItemInHand();
if (itemStack != null) {
ItemWeapon weapon = itemStack.getItem().getWeapon();
if (weapon != null) {
entityStatsToClear = weapon.getEntityStatsToClear();
}
}
break;
default:
throw new IllegalArgumentException("Inventory section with id " + inventorySectionId + " cannot select an active slot");
}
StatModifiersManager statModifiersManager = this.entity.getStatModifiersManager();
this.entity.invalidateEquipmentNetwork();
statModifiersManager.setRecalculate(true);
if (entityStatsToClear != null) {
statModifiersManager.queueEntityStatsToClear(entityStatsToClear);
}
}
public byte getActiveSlot(int inventorySectionId) {
byte var10000;
switch (inventorySectionId) {
case -8 -> var10000 = this.activeToolsSlot;
case -5 -> var10000 = this.activeUtilitySlot;
case -1 -> var10000 = this.activeHotbarSlot;
default -> throw new IllegalArgumentException("Inventory section with id " + inventorySectionId + " cannot select an active slot");
}
return var10000;
}
public byte getActiveHotbarSlot() {
return this.activeHotbarSlot;
}
public void setActiveHotbarSlot(byte slot) {
this.setUsingToolsItem(false);
this.setActiveSlot(-1, slot);
}
@Nullable
public ItemStack getActiveHotbarItem() {
return this.activeHotbarSlot == -1 ? null : this.hotbar.getItemStack((short)this.activeHotbarSlot);
}
@Nullable
public ItemStack getActiveToolItem() {
return this.activeToolsSlot == -1 ? null : this.tools.getItemStack((short)this.activeToolsSlot);
}
@Nullable
public ItemStack getItemInHand() {
return this._usingToolsItem ? this.getActiveToolItem() : this.getActiveHotbarItem();
}
public byte getActiveUtilitySlot() {
return this.activeUtilitySlot;
}
public void setActiveUtilitySlot(byte slot) {
this.setActiveSlot(-5, slot);
}
@Nullable
public ItemStack getUtilityItem() {
return this.activeUtilitySlot == -1 ? null : this.utility.getItemStack((short)this.activeUtilitySlot);
}
public byte getActiveToolsSlot() {
return this.activeToolsSlot;
}
public void setActiveToolsSlot(byte slot) {
this.setUsingToolsItem(true);
this.setActiveSlot(-8, slot);
}
@Nullable
public ItemStack getToolsItem() {
return this.activeToolsSlot == -1 ? null : this.tools.getItemStack((short)this.activeToolsSlot);
}
@Nullable
public ItemContainer getSectionById(int id) {
if (id >= 0) {
if (this.entity instanceof Player) {
Window window = ((Player)this.entity).getWindowManager().getWindow(id);
if (window instanceof ItemContainerWindow) {
return ((ItemContainerWindow)window).getItemContainer();
}
}
return null;
} else {
ItemContainer var10000;
switch (id) {
case -9:
var10000 = this.backpack;
break;
case -8:
var10000 = this.tools;
break;
case -7:
case -6:
case -4:
default:
var10000 = null;
break;
case -5:
var10000 = this.utility;
break;
case -3:
var10000 = this.armor;
break;
case -2:
var10000 = this.storage;
break;
case -1:
var10000 = this.hotbar;
}
return var10000;
}
}
public boolean consumeIsDirty() {
return this.isDirty.getAndSet(false);
}
public boolean consumeNeedsSaving() {
return this.needsSaving.getAndSet(false);
}
public void setEntity(LivingEntity entity) {
this.entity = entity;
}
public void sortStorage(@Nonnull SortType type) {
this.sortType = type;
this.storage.sortItems(type);
this.markChanged();
}
public void setSortType(SortType type) {
this.sortType = type;
this.markChanged();
}
public boolean containsBrokenItem() {
boolean hasBrokenItem = false;
for(short i = 0; i < this.combinedEverything.getCapacity(); ++i) {
ItemStack itemStack = this.combinedEverything.getItemStack(i);
if (!ItemStack.isEmpty(itemStack) && itemStack.isBroken()) {
hasBrokenItem = true;
}
}
return hasBrokenItem;
}
@Nonnull
public UpdatePlayerInventory toPacket() {
UpdatePlayerInventory packet = new UpdatePlayerInventory();
packet.storage = this.storage.toPacket();
packet.armor = this.armor.toPacket();
packet.hotbar = this.hotbar.toPacket();
packet.utility = this.utility.toPacket();
packet.tools = this.tools.toPacket();
packet.backpack = this.backpack.toPacket();
packet.sortType = this.sortType.toPacket();
return packet;
}
public void doMigration(Function<String, String> blockMigration) {
Objects.requireNonNull(blockMigration);
this.hotbar.doMigration(blockMigration);
this.storage.doMigration(blockMigration);
this.armor.doMigration(blockMigration);
this.utility.doMigration(blockMigration);
this.tools.doMigration(blockMigration);
this.backpack.doMigration(blockMigration);
}
private void postDecode() {
this.armor = ItemContainerUtil.trySetArmorFilters(this.armor);
this.utility = ItemContainerUtil.trySetSlotFilters(this.utility, (type, container, slot, itemStack) -> itemStack == null || itemStack.getItem().getUtility().isUsable());
this.activeHotbarSlot = (byte)(this.activeHotbarSlot < this.hotbar.getCapacity() ? this.activeHotbarSlot : (this.hotbar.getCapacity() > 0 ? 0 : -1));
this.activeUtilitySlot = this.activeUtilitySlot < this.utility.getCapacity() ? this.activeUtilitySlot : -1;
this.activeToolsSlot = this.activeToolsSlot < this.tools.getCapacity() ? this.activeToolsSlot : -1;
this.buildCombinedContains();
this.registerChangeEvents();
}
private void buildCombinedContains() {
this.combinedHotbarFirst = new CombinedItemContainer(new ItemContainer[]{this.hotbar, this.storage});
this.combinedStorageFirst = new CombinedItemContainer(new ItemContainer[]{this.storage, this.hotbar});
this.combinedBackpackStorageHotbar = new CombinedItemContainer(new ItemContainer[]{this.backpack, this.storage, this.hotbar});
this.combinedStorageHotbarBackpack = new CombinedItemContainer(new ItemContainer[]{this.storage, this.hotbar, this.backpack});
this.combinedArmorHotbarStorage = new CombinedItemContainer(new ItemContainer[]{this.armor, this.hotbar, this.storage});
this.combinedArmorHotbarUtilityStorage = new CombinedItemContainer(new ItemContainer[]{this.armor, this.hotbar, this.utility, this.storage});
this.combinedHotbarUtilityConsumableStorage = new CombinedItemContainer(new ItemContainer[]{this.hotbar, this.utility, this.storage});
this.combinedEverything = new CombinedItemContainer(new ItemContainer[]{this.armor, this.hotbar, this.utility, this.storage, this.backpack});
}
public boolean equals(@Nullable Object o) {
if (this == o) {
return true;
} else if (o != null && this.getClass() == o.getClass()) {
Inventory inventory = (Inventory)o;
if (this.activeHotbarSlot != inventory.activeHotbarSlot) {
return false;
} else if (this.activeUtilitySlot != inventory.activeUtilitySlot) {
return false;
} else if (this.isDirty != inventory.isDirty) {
return false;
} else if (this.needsSaving != inventory.needsSaving) {
return false;
} else if (!Objects.equals(this.storage, inventory.storage)) {
return false;
} else if (!Objects.equals(this.armor, inventory.armor)) {
return false;
} else if (!Objects.equals(this.utility, inventory.utility)) {
return false;
} else if (!Objects.equals(this.tools, inventory.tools)) {
return false;
} else {
return !Objects.equals(this.backpack, inventory.backpack) ? false : Objects.equals(this.hotbar, inventory.hotbar);
}
} else {
return false;
}
}
public int hashCode() {
int result = this.storage != null ? this.storage.hashCode() : 0;
result = 31 * result + (this.armor != null ? this.armor.hashCode() : 0);
result = 31 * result + (this.hotbar != null ? this.hotbar.hashCode() : 0);
result = 31 * result + (this.utility != null ? this.utility.hashCode() : 0);
result = 31 * result + (this.tools != null ? this.tools.hashCode() : 0);
result = 31 * result + (this.backpack != null ? this.backpack.hashCode() : 0);
result = 31 * result + this.activeHotbarSlot;
result = 31 * result + this.activeUtilitySlot;
result = 31 * result + this.activeToolsSlot;
result = 31 * result + this.isDirty.hashCode();
result = 31 * result + this.needsSaving.hashCode();
return result;
}
@Nonnull
public String toString() {
String var10000 = String.valueOf(this.storage);
return "Inventory{, storage=" + var10000 + ", armor=" + String.valueOf(this.armor) + ", hotbar=" + String.valueOf(this.hotbar) + ", utility=" + String.valueOf(this.utility) + ", activeHotbarSlot=" + this.activeHotbarSlot + ", activeUtilitySlot=" + this.activeUtilitySlot + ", activeToolsSlot=" + this.activeToolsSlot + ", isDirty=" + String.valueOf(this.isDirty) + ", needsSaving=" + String.valueOf(this.needsSaving) + "}";
}
@Nonnull
public static Inventory ensureCapacity(@Nonnull Inventory inventory, List<ItemStack> remainder) {
ItemContainer storage = inventory.getStorage();
ItemContainer armor = inventory.getArmor();
ItemContainer hotbar = inventory.getHotbar();
ItemContainer utility = inventory.getUtility();
ItemContainer tool = inventory.getTools();
if (storage.getCapacity() == 36 && armor.getCapacity() == DEFAULT_ARMOR_CAPACITY && hotbar.getCapacity() == 9 && utility.getCapacity() == 4 && tool.getCapacity() == 23) {
return inventory;
} else {
ItemContainer newStorage = ItemContainer.ensureContainerCapacity(storage, (short)36, SimpleItemContainer::new, remainder);
ItemContainer newArmor = ItemContainer.ensureContainerCapacity(armor, DEFAULT_ARMOR_CAPACITY, SimpleItemContainer::new, remainder);
ItemContainer newHotbar = ItemContainer.ensureContainerCapacity(hotbar, (short)9, SimpleItemContainer::new, remainder);
ItemContainer newUtility = ItemContainer.ensureContainerCapacity(utility, (short)4, SimpleItemContainer::new, remainder);
ItemContainer newTool = ItemContainer.ensureContainerCapacity(tool, (short)23, SimpleItemContainer::new, remainder);
byte activeHotbarSlot = inventory.getActiveHotbarSlot();
if (activeHotbarSlot > newHotbar.getCapacity()) {
activeHotbarSlot = (byte)(hotbar.getCapacity() > 0 ? 0 : -1);
}
byte activeUtilitySlot = inventory.getActiveUtilitySlot();
if (activeUtilitySlot > newUtility.getCapacity()) {
activeUtilitySlot = -1;
}
byte activeToolsSlot = inventory.getActiveToolsSlot();
if (activeToolsSlot > newTool.getCapacity()) {
activeToolsSlot = -1;
}
inventory.unregister();
Inventory newInventory = new Inventory(newStorage, newArmor, newHotbar, newUtility, newTool, EmptyItemContainer.INSTANCE);
newInventory.activeHotbarSlot = activeHotbarSlot;
newInventory.activeUtilitySlot = activeUtilitySlot;
newInventory.activeToolsSlot = activeToolsSlot;
newInventory.setSortType(inventory.sortType);
return newInventory;
}
}
public void setUsingToolsItem(boolean value) {
this._usingToolsItem = value;
}
public boolean usingToolsItem() {
return this._usingToolsItem;
}
static {
DEFAULT_ARMOR_CAPACITY = (short)ItemArmorSlot.VALUES.length;
CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Inventory.class, () -> new Inventory((Void)null)).versioned()).codecVersion(4)).append(new KeyedCodec("Storage", ItemContainer.CODEC), (o, i) -> o.storage = i, (o) -> o.storage).add()).append(new KeyedCodec("Armor", ItemContainer.CODEC), (o, i) -> o.armor = i, (o) -> o.armor).add()).append(new KeyedCodec("HotBar", ItemContainer.CODEC), (o, i) -> o.hotbar = i, (o) -> o.hotbar).add()).append(new KeyedCodec("Utility", ItemContainer.CODEC), (o, i) -> o.utility = i, (o) -> o.utility).add()).append(new KeyedCodec("Backpack", ItemContainer.CODEC), (o, i) -> o.backpack = i, (o) -> o.backpack).add()).append(new KeyedCodec("ActiveHotbarSlot", Codec.BYTE), (o, i) -> o.activeHotbarSlot = i, (o) -> o.activeHotbarSlot).add()).append(new KeyedCodec("Tool", ItemContainer.CODEC), (o, i) -> o.tools = i, (o) -> o.tools).add()).append(new KeyedCodec("ActiveToolsSlot", Codec.BYTE), (o, i) -> o.activeToolsSlot = i, (o) -> o.activeToolsSlot).add()).append(new KeyedCodec("ActiveUtilitySlot", Codec.BYTE), (o, i) -> o.activeUtilitySlot = i, (o) -> o.activeUtilitySlot).add()).append(new KeyedCodec("SortType", new EnumCodec(SortType.class, EnumCodec.EnumStyle.LEGACY)), (o, i) -> o.sortType = i, (o) -> o.sortType).setVersionRange(0, 3).add()).append(new KeyedCodec("SortType", new EnumCodec(SortType.class)), (o, i) -> o.sortType = i, (o) -> o.sortType).setVersionRange(4, 4).add()).afterDecode(Inventory::postDecode)).build();
}
public static enum ItemPickupType {
PASSIVE,
INTERACTION;
private ItemPickupType() {
}
}
}
com/hypixel/hytale/server/core/inventory/ItemContext.java
package com.hypixel.hytale.server.core.inventory;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
public class ItemContext {
@Nonnull
private final ItemContainer container;
private final short slot;
@Nonnull
private final ItemStack itemStack;
public ItemContext(@Nonnull ItemContainer container, short slot, @Nonnull ItemStack itemStack) {
this.container = container;
this.slot = slot;
this.itemStack = itemStack;
}
@Nonnull
public ItemContainer getContainer() {
return this.container;
}
public short getSlot() {
return this.slot;
}
@Nonnull
public ItemStack getItemStack() {
return this.itemStack;
}
@Nonnull
public String toString() {
String.valueOf(.container);
+ var10000 + + .slot + + String.valueOf(.itemStack) + ;
}
}
com/hypixel/hytale/server/core/inventory/ItemStack.java
package com.hypixel.hytale.server.core.inventory;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.protocol.ItemQuantity;
import com.hypixel.hytale.protocol.ItemWithAllMetadata;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;
public class ItemStack implements NetworkSerializable<ItemWithAllMetadata> {
@Nonnull
public static final ItemStack[] EMPTY_ARRAY = new ItemStack[0];
@Nonnull
public static final BuilderCodec<ItemStack> CODEC;
@Nonnull
public static final ItemStack EMPTY;
protected String itemId;
protected int quantity;
protected double durability;
protected double maxDurability;
overrideDroppedItemAnimation;
BsonDocument metadata;
ItemWithAllMetadata cachedPacket;
{
.quantity = ;
(quantity <= ) {
(String.format(, quantity));
} (itemId == ) {
();
} (itemId.equals()) {
();
} {
.itemId = itemId;
.quantity = quantity;
.getItem().getMaxDurability();
.durability = maxDurability;
.maxDurability = maxDurability;
.metadata = metadata;
}
}
{
(itemId, quantity, metadata);
.durability = durability;
.maxDurability = maxDurability;
}
{
(itemId, );
}
{
(itemId, quantity, (BsonDocument));
}
{
.quantity = ;
}
String {
.itemId;
}
{
.quantity;
}
BsonDocument {
.metadata == ? : .metadata.clone();
}
{
.maxDurability <= ;
}
{
(.isUnbreakable()) {
;
} {
.durability == ;
}
}
{
.maxDurability;
}
{
.durability;
}
{
.itemId.equals();
}
{
.overrideDroppedItemAnimation;
}
{
.overrideDroppedItemAnimation = b;
}
String {
(.isEmpty()) {
;
} {
.getItem();
(item == ) {
;
} {
item.hasBlockType() ? item.getBlockId() : ;
}
}
}
Item {
(Item)Item.getAssetMap().getAsset(.itemId);
item != ? item : Item.UNKNOWN;
}
{
.isEmpty() || .getItem() != ;
}
ItemStack {
(.itemId, .quantity, MathUtil.clamp(durability, , .maxDurability), .maxDurability, .metadata);
}
ItemStack {
(.itemId, .quantity, Math.min(.durability, maxDurability), maxDurability, .metadata);
}
ItemStack {
.withDurability(.durability + inc);
}
ItemStack {
(.itemId, .quantity, maxDurability, maxDurability, .metadata);
}
ItemStack {
.getItem().getItemIdForState(state);
(newItemId == ) {
( + state);
} {
(newItemId, .quantity, .durability, .maxDurability, .metadata);
}
}
ItemStack {
(quantity == ) {
;
} {
quantity == .quantity ? : (.itemId, quantity, .durability, .maxDurability, .metadata);
}
}
ItemStack {
(.itemId, .quantity, .durability, .maxDurability, metadata);
}
<T> ItemStack {
.withMetadata(keyedCodec.getKey(), keyedCodec.getChildCodec(), data);
}
<T> ItemStack {
.metadata == ? () : .metadata.clone();
(data == ) {
clonedMeta.remove(key);
} {
BsonValue bsonValue;
var10000;
label39: {
bsonValue = codec.encode(data);
(!bsonValue.isNull()) {
label38: {
(bsonValue BsonDocument) {
(BsonDocument)bsonValue;
(doc.isEmpty()) {
label38;
}
}
var10000 = ;
label39;
}
}
var10000 = ;
}
var10000;
(empty) {
clonedMeta.remove(key);
} {
clonedMeta.put(key, bsonValue);
}
}
(clonedMeta.isEmpty()) {
clonedMeta = ;
}
(.itemId, .quantity, .durability, .maxDurability, clonedMeta);
}
ItemStack {
.metadata == ? () : .metadata.clone();
(bsonValue != && !bsonValue.isNull()) {
clonedMeta.put(key, bsonValue);
} {
clonedMeta.remove(key);
}
(.itemId, .quantity, .durability, .maxDurability, clonedMeta);
}
ItemWithAllMetadata {
(.cachedPacket != ) {
.cachedPacket;
} {
();
packet.itemId = .itemId.toString();
packet.quantity = .quantity;
packet.durability = .durability;
packet.maxDurability = .maxDurability;
packet.overrideDroppedItemAnimation = .overrideDroppedItemAnimation;
packet.metadata = .metadata != ? .metadata.toJson() : ;
.cachedPacket = packet;
.cachedPacket;
}
}
{
(itemStack == ) {
;
} (Double.compare(itemStack.durability, .durability) != ) {
;
} (Double.compare(itemStack.maxDurability, .maxDurability) != ) {
;
} (!.itemId.equals(itemStack.itemId)) {
;
} {
.metadata != ? .metadata.equals(itemStack.metadata) : itemStack.metadata == ;
}
}
{
(itemStack == ) {
;
} (!.itemId.equals(itemStack.itemId)) {
;
} {
.metadata != ? .metadata.equals(itemStack.metadata) : itemStack.metadata == ;
}
}
<T> T {
keyedCodec.getOrNull(.metadata);
}
<T> T {
.metadata == ? : .metadata.get(key);
(T)(bsonValue == ? : codec.decode(bsonValue));
}
<T> T {
.metadata == ? () : .metadata.clone();
(clonedMeta == ) {
codec.getDefaultValue();
} {
clonedMeta.get(key);
(T)(bsonValue == ? codec.getDefaultValue() : codec.decode(bsonValue));
}
}
{
( == o) {
;
} (o != && .getClass() == o.getClass()) {
(ItemStack)o;
(.quantity != itemStack.quantity) {
;
} (Double.compare(itemStack.durability, .durability) != ) {
;
} (Double.compare(itemStack.maxDurability, .maxDurability) != ) {
;
} (!.itemId.equals(itemStack.itemId)) {
;
} {
.metadata != ? .metadata.equals(itemStack.metadata) : itemStack.metadata == ;
}
} {
;
}
}
{
.itemId.hashCode();
result = * result + .quantity;
Double.doubleToLongBits(.durability);
result = * result + ()(temp ^ temp >>> );
temp = Double.doubleToLongBits(.maxDurability);
result = * result + ()(temp ^ temp >>> );
result = * result + (.metadata != ? .metadata.hashCode() : );
result;
}
String {
.itemId;
+ var10000 + + .quantity + + .maxDurability + + .durability + + String.valueOf(.metadata) + ;
}
{
itemFrom == || itemFrom.isEmpty();
}
{
a == b || a != && a.isStackableWith(b);
}
{
a == b || a != && a.isEquivalentType(b);
}
{
a == b || a != && b != && a.itemId.equals(b.itemId);
}
ItemStack {
(packet == ) {
;
} {
packet.quantity;
quantity <= ? : (packet.itemId, quantity, (BsonDocument));
}
}
{
CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ItemStack.class, ItemStack::).append( (, Codec.STRING), (itemStack, id) -> itemStack.itemId = id, (itemStack) -> itemStack.itemId).addValidator(Validators.nonNull()).addValidator(Item.VALIDATOR_CACHE.getValidator().late()).add()).append( (, Codec.INTEGER), (itemStack, quantity) -> itemStack.quantity = quantity, (itemStack) -> itemStack.quantity).addValidator(Validators.greaterThan()).add()).append( (, Codec.DOUBLE), (itemStack, durability) -> itemStack.durability = durability, (itemStack) -> itemStack.durability).addValidator(Validators.greaterThanOrEqual()).add()).append( (, Codec.DOUBLE), (itemStack, maxDurability) -> itemStack.maxDurability = maxDurability, (itemStack) -> itemStack.maxDurability).addValidator(Validators.greaterThanOrEqual()).add()).append( (, Codec.BSON_DOCUMENT), (itemStack, bsonDocument) -> itemStack.metadata = bsonDocument, (itemStack) -> itemStack.metadata).add()).append( (, Codec.BOOLEAN), (itemStack, b) -> itemStack.overrideDroppedItemAnimation = b, (itemStack) -> itemStack.overrideDroppedItemAnimation).add()).build();
EMPTY = () {
{
.itemId = ;
}
};
}
{
;
{
}
}
}
com/hypixel/hytale/server/core/inventory/MaterialQuantity.java
package com.hypixel.hytale.server.core.inventory;
import com.hypixel.hytale.assetstore.AssetRegistry;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.server.core.io.NetworkSerializable;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
public class MaterialQuantity implements NetworkSerializable<com.hypixel.hytale.protocol.MaterialQuantity> {
public static final MaterialQuantity[] EMPTY_ARRAY = new MaterialQuantity[0];
public static final BuilderCodec<MaterialQuantity> CODEC;
@Nullable
protected String itemId;
@Nullable
protected String resourceTypeId;
protected String tag;
protected int tagIndex = -2147483648;
protected int quantity = 1;
@Nullable
protected BsonDocument metadata;
public MaterialQuantity {
(itemId == && resourceTypeId == && tag == ) {
();
} (quantity <= ) {
( + quantity + );
} {
.itemId = itemId;
.resourceTypeId = resourceTypeId;
.tag = tag;
.quantity = quantity;
.metadata = metadata;
}
}
{
}
String {
.itemId;
}
String {
.resourceTypeId;
}
{
.tagIndex;
}
{
.quantity;
}
BsonDocument {
.metadata;
}
MaterialQuantity {
(.itemId, .resourceTypeId, .tag, quantity, .metadata);
}
ItemStack {
(.itemId == ) {
;
} {
.itemId.equals() ? ItemStack.EMPTY : (.itemId, .quantity, .metadata);
}
}
ResourceQuantity {
.resourceTypeId == ? : (.resourceTypeId, .quantity);
}
com.hypixel.hytale.protocol.MaterialQuantity {
com.hypixel.hytale.protocol. .hypixel.hytale.protocol.MaterialQuantity();
(.itemId != ) {
packet.itemId = .itemId.toString();
}
packet.itemTag = .tagIndex;
packet.resourceTypeId = .resourceTypeId;
packet.quantity = .quantity;
packet;
}
{
( == o) {
;
} (o != && .getClass() == o.getClass()) {
(MaterialQuantity)o;
(.quantity != that.quantity) {
;
} {
(.itemId != ) {
(!.itemId.equals(that.itemId)) {
;
}
} (that.itemId != ) {
;
}
(.resourceTypeId != ) {
(!.resourceTypeId.equals(that.resourceTypeId)) {
;
}
} (that.resourceTypeId != ) {
;
}
(.tag != ) {
(!.tag.equals(that.tag)) {
;
}
} (that.tag != ) {
;
}
.metadata != ? .metadata.equals(that.metadata) : that.metadata == ;
}
} {
;
}
}
{
.itemId != ? .itemId.hashCode() : ;
result = * result + (.resourceTypeId != ? .resourceTypeId.hashCode() : );
result = * result + (.tag != ? .tag.hashCode() : );
result = * result + .quantity;
result = * result + (.metadata != ? .metadata.hashCode() : );
result;
}
String {
.itemId;
+ var10000 + + .resourceTypeId + + .tag + + .quantity + + String.valueOf(.metadata) + ;
}
{
CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(MaterialQuantity.class, MaterialQuantity::).addField( (, Codec.STRING), (craftingMaterial, blockTypeKey) -> craftingMaterial.itemId = blockTypeKey, (craftingMaterial) -> craftingMaterial.itemId)).addField( (, Codec.STRING), (craftingMaterial, s) -> craftingMaterial.resourceTypeId = s, (craftingMaterial) -> craftingMaterial.resourceTypeId)).addField( (, Codec.STRING), (materialQuantity, s) -> materialQuantity.tag = s, (materialQuantity) -> materialQuantity.tag)).append( (, Codec.INTEGER), (craftingMaterial, s) -> craftingMaterial.quantity = s, (craftingMaterial) -> craftingMaterial.quantity).addValidator(Validators.greaterThan()).add()).addField( (, Codec.BSON_DOCUMENT), (craftingMaterial, s) -> craftingMaterial.metadata = s, (craftingMaterial) -> craftingMaterial.metadata)).afterDecode((materialQuantity, extraInfo) -> {
(materialQuantity.tag != ) {
materialQuantity.tagIndex = AssetRegistry.getOrCreateTagIndex(materialQuantity.tag);
}
})).build();
}
}
com/hypixel/hytale/server/core/inventory/ResourceQuantity.java
package com.hypixel.hytale.server.core.inventory;
import com.hypixel.hytale.protocol.ItemResourceType;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ResourceQuantity {
protected String resourceId;
protected int quantity;
public ResourceQuantity(String resourceId, int quantity) {
Objects.requireNonNull(resourceId, "resourceId cannot be null!");
if (quantity <= 0) {
throw new IllegalArgumentException("quantity " + quantity + " must be >0!");
} else {
this.resourceId = resourceId;
this.quantity = quantity;
}
}
protected ResourceQuantity() {
}
public String getResourceId() {
return this.resourceId;
}
public int getQuantity() {
return this.quantity;
}
ResourceQuantity {
(.resourceId, quantity);
}
ItemResourceType {
ItemContainer.getMatchingResourceType(item, .resourceId);
}
{
( == o) {
;
} (o != && .getClass() == o.getClass()) {
(ResourceQuantity)o;
(.quantity != itemStack.quantity) {
;
} {
.resourceId != ? .resourceId.equals(itemStack.resourceId) : itemStack.resourceId == ;
}
} {
;
}
}
{
.resourceId != ? .resourceId.hashCode() : ;
result = * result + .quantity;
result;
}
String {
+ .resourceId + + .quantity + ;
}
}
com/hypixel/hytale/server/core/inventory/container/CombinedItemContainer.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class CombinedItemContainer extends ItemContainer {
protected final ItemContainer[] containers;
public CombinedItemContainer(ItemContainer... containers) {
this.containers = containers;
}
public ItemContainer getContainer(int index) {
return this.containers[index];
}
public int getContainersSize() {
return this.containers.length;
}
@Nullable
ItemContainer {
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container;
}
slot -= capacity;
}
;
}
<V> V {
(V).readAction0(, action);
}
<V> V {
(V)(i >= .containers.length ? action.get() : .containers[i].readAction(() -> .readAction0(i + , action)));
}
<X, V> V {
(V).readAction0(, action, x);
}
<X, V> V {
(V)(i >= .containers.length ? action.apply(x) : .containers[i].readAction(() -> .readAction0(i + , action, x)));
}
<V> V {
(V).writeAction0(, action);
}
<V> V {
(V)(i >= .containers.length ? action.get() : .containers[i].writeAction(() -> .writeAction0(i + , action)));
}
<X, V> V {
(V).writeAction0(, action, x);
}
<X, V> V {
(V)(i >= .containers.length ? action.apply(x) : .containers[i].writeAction(() -> .writeAction0(i + , action, x)));
}
ClearTransaction {
ItemStack[] itemStacks = [.getCapacity()];
;
(ItemContainer container : .containers) {
container.internal_clear();
ItemStack[] items = clear.getItems();
( ; slot < itemStacks.length; ++slot) {
itemStacks[()(start + slot)] = items[slot];
}
start += container.getCapacity();
}
(, (), itemStacks);
}
ItemStack {
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container.internal_getSlot(slot);
}
slot -= capacity;
}
;
}
ItemStack {
(ItemStack.isEmpty(itemStack)) {
.internal_removeSlot(slot);
} {
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container.internal_setSlot(slot, itemStack);
}
slot -= capacity;
}
;
}
}
ItemStack {
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container.internal_removeSlot(slot);
}
slot -= capacity;
}
;
}
{
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container.cantAddToSlot(slot, itemStack, slotItemStack);
}
slot -= capacity;
}
;
}
{
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container.cantRemoveFromSlot(slot);
}
slot -= capacity;
}
;
}
{
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container.cantDropFromSlot(slot);
}
slot -= capacity;
}
;
}
{
(ItemContainer container : .containers) {
container.cantMoveToSlot(fromContainer, slotFrom);
(cantMoveToSlot) {
;
}
}
;
}
{
;
(ItemContainer container : .containers) {
capacity += container.getCapacity();
}
capacity;
}
CombinedItemContainer {
();
}
EventRegistration {
.registerChangeEvent(priority, consumer);
EventRegistration[] containerRegistrations = [.containers.length];
;
( ; i < .containers.length; ++i) {
.containers[i];
containerRegistrations[i] = container.internalChangeEventRegistry.register(priority, (Object), (event) -> consumer.accept( .ItemContainerChangeEvent(, event.transaction().toParent(, start, container))));
start += container.getCapacity();
}
EventRegistration.combine(thisRegistration, containerRegistrations);
}
{
(transaction.succeeded()) {
.sendUpdate(transaction);
;
(ItemContainer container : .containers) {
transaction.fromParent(, start, container);
(containerTransaction != ) {
(!containerTransaction.succeeded()) {
start += container.getCapacity();
;
}
container.sendUpdate(containerTransaction);
}
start += container.getCapacity();
}
}
}
{
(itemContainer == ) {
;
} {
(ItemContainer container : .containers) {
(container.containsContainer(itemContainer)) {
;
}
}
;
}
}
{
( == o) {
;
} (o CombinedItemContainer) {
(CombinedItemContainer)o;
.getCapacity();
capacity != that.getCapacity() ? : (Boolean).readAction((_that) -> (Boolean)_that.readAction((_that2) -> {
( ; i < capacity; ++i) {
(!Objects.equals(.internal_getSlot(i), _that2.internal_getSlot(i))) {
;
}
}
;
}, _that), that);
} {
;
}
}
{
.getCapacity();
(Integer).readAction(() -> {
;
( ; i < capacity; ++i) {
.internal_getSlot(i);
hash = * hash + (itemStack != ? itemStack.hashCode() : );
}
hash;
});
result = * result + capacity;
result;
}
{
();
}
{
(ItemContainer container : .containers) {
container.getCapacity();
(slot < capacity) {
container.setSlotFilter(actionType, slot, filter);
;
}
slot -= capacity;
}
}
}
com/hypixel/hytale/server/core/inventory/container/DelegateItemContainer.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class DelegateItemContainer<T extends ItemContainer> extends ItemContainer {
private T delegate;
private final Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters = new ConcurrentHashMap();
@Nonnull
private FilterType globalFilter;
public DelegateItemContainer(T delegate) {
this.globalFilter = FilterType.ALLOW_ALL;
Objects.requireNonNull(delegate, );
.delegate = delegate;
}
T {
.delegate;
}
<V> V {
(V).delegate.readAction(action);
}
<X, V> V {
(V).delegate.readAction(action, x);
}
<V> V {
(V).delegate.writeAction(action);
}
<X, V> V {
(V).delegate.writeAction(action, x);
}
ClearTransaction {
.delegate.internal_clear();
}
ItemStack {
.delegate.internal_getSlot(slot);
}
ItemStack {
.delegate.internal_setSlot(slot, itemStack);
}
ItemStack {
.delegate.internal_removeSlot(slot);
}
{
(!.globalFilter.allowInput()) {
;
} {
.testFilter(FilterActionType.ADD, slot, itemStack) ? : .delegate.cantAddToSlot(slot, itemStack, slotItemStack);
}
}
{
(!.globalFilter.allowOutput()) {
;
} {
.testFilter(FilterActionType.REMOVE, slot, (ItemStack)) ? : .delegate.cantRemoveFromSlot(slot);
}
}
{
.testFilter(FilterActionType.DROP, slot, (ItemStack)) ? : .delegate.cantDropFromSlot(slot);
}
{
.delegate.cantMoveToSlot(fromContainer, slotFrom);
}
{
Int2ObjectConcurrentHashMap<SlotFilter> map = (Int2ObjectConcurrentHashMap).slotFilters.get(actionType);
(map == ) {
;
} {
map.get(slot);
(filter == ) {
;
} {
!filter.test(actionType, , slot, itemStack);
}
}
}
{
.delegate.getCapacity();
}
ClearTransaction {
.delegate.clear();
}
DelegateItemContainer<T> {
<T>(.delegate);
}
{
.delegate.isEmpty();
}
{
.globalFilter = (FilterType)Objects.requireNonNull(globalFilter);
}
{
validateSlotIndex(slot, .getCapacity());
(filter != ) {
((Int2ObjectConcurrentHashMap).slotFilters.computeIfAbsent(actionType, (k) -> ())).put(slot, filter);
} {
.slotFilters.computeIfPresent(actionType, (k, map) -> {
map.remove(slot);
map.isEmpty() ? : map;
});
}
}
EventRegistration {
.registerChangeEvent(priority, consumer);
EventRegistration[] delegateRegistration = []{.delegate.internalChangeEventRegistry.register(priority, (Object), (event) -> consumer.accept( .ItemContainerChangeEvent(, event.transaction().toParent(, (), .delegate))))};
EventRegistration.combine(thisRegistration, delegateRegistration);
}
{
(transaction.succeeded()) {
.sendUpdate(transaction);
.delegate.externalChangeEventRegistry.dispatchFor((Object)).dispatch( .ItemContainerChangeEvent(.delegate, transaction));
}
}
{
( == o) {
;
} (o != && .getClass() == o.getClass()) {
DelegateItemContainer<?> that = (DelegateItemContainer)o;
(.delegate != ) {
(!.delegate.equals(that.delegate)) {
;
}
} (that.delegate != ) {
;
}
(.slotFilters != ) {
(!.slotFilters.equals(that.slotFilters)) {
;
}
} (that.slotFilters != ) {
;
}
.globalFilter == that.globalFilter;
} {
;
}
}
{
.delegate != ? .delegate.hashCode() : ;
result = * result + (.slotFilters != ? .slotFilters.hashCode() : );
result = * result + (.globalFilter != ? .globalFilter.hashCode() : );
result;
}
}
com/hypixel/hytale/server/core/inventory/container/EmptyItemContainer.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.function.consumer.ShortObjectConsumer;
import com.hypixel.hytale.protocol.ItemWithAllMetadata;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
public class EmptyItemContainer extends ItemContainer {
public static final EmptyItemContainer INSTANCE = new EmptyItemContainer();
public static final BuilderCodec<EmptyItemContainer> CODEC = BuilderCodec.builder(EmptyItemContainer.class, () -> INSTANCE).build();
private static final EventRegistration<Void, ItemContainer.ItemContainerChangeEvent> EVENT_REGISTRATION = <Void, ItemContainer.ItemContainerChangeEvent>(ItemContainer.ItemContainerChangeEvent.class, () -> , () -> {
});
{
}
{
;
}
ClearTransaction {
ClearTransaction.EMPTY;
}
{
}
<V> V {
(V)action.get();
}
<X, V> V {
(V)action.apply(x);
}
<V> V {
(V)action.get();
}
<X, V> V {
(V)action.apply(x);
}
ClearTransaction {
ClearTransaction.EMPTY;
}
ItemStack {
();
}
ItemStack {
();
}
ItemStack {
();
}
{
;
}
{
;
}
{
;
}
{
;
}
List<ItemStack> {
Collections.emptyList();
}
Map<Integer, ItemWithAllMetadata> {
Collections.emptyMap();
}
EmptyItemContainer {
INSTANCE;
}
EventRegistration {
EVENT_REGISTRATION;
}
{
}
{
validateSlotIndex(slot, );
}
}
com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilItemStack.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class InternalContainerUtilItemStack {
public InternalContainerUtilItemStack() {
}
protected static int testAddToExistingSlot(@Nonnull ItemContainer abstractItemContainer, short slot, ItemStack itemStack, int itemMaxStack, int testQuantityRemaining, boolean filter) {
ItemStack slotItemStack = abstractItemContainer.internal_getSlot(slot);
if (ItemStack.isEmpty(slotItemStack)) {
return testQuantityRemaining;
} (!slotItemStack.isStackableWith(itemStack)) {
testQuantityRemaining;
} (filter && abstractItemContainer.cantAddToSlot(slot, itemStack, slotItemStack)) {
testQuantityRemaining;
} {
slotItemStack.getQuantity();
Math.min(itemMaxStack - quantity, testQuantityRemaining);
testQuantityRemaining -= quantityAdjustment;
testQuantityRemaining;
}
}
ItemStackSlotTransaction {
container.internal_getSlot(slot);
(ItemStack.isEmpty(slotItemStack)) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
} (!slotItemStack.isStackableWith(itemStack)) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
} (filter && container.cantAddToSlot(slot, itemStack, slotItemStack)) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
} {
itemStack.getQuantity();
slotItemStack.getQuantity();
Math.min(itemMaxStack - quantity, quantityRemaining);
quantity + quantityAdjustment;
quantityRemaining -= quantityAdjustment;
(quantityAdjustment <= ) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
} {
slotItemStack.withQuantity(newQuantity);
(newQuantity > ) {
container.internal_setSlot(slot, slotNew);
} {
container.internal_removeSlot(slot);
}
quantityRemaining != itemStack.getQuantity() ? itemStack.withQuantity(quantityRemaining) : itemStack;
(, ActionType.ADD, slot, slotItemStack, slotNew, (ItemStack), , , filter, , itemStack, remainder);
}
}
}
ItemStackSlotTransaction {
container.internal_getSlot(slot);
(slotItemStack != && !slotItemStack.isEmpty()) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
} (filter && container.cantAddToSlot(slot, itemStack, slotItemStack)) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
} {
itemStack.getQuantity();
Math.min(itemMaxStack, quantityRemaining);
quantityRemaining -= quantityAdjustment;
itemStack.withQuantity(quantityAdjustment);
container.internal_setSlot(slot, slotNew);
itemStack.getQuantity() != quantityRemaining ? itemStack.withQuantity(quantityRemaining) : itemStack;
(, ActionType.ADD, slot, slotItemStack, slotNew, (ItemStack), , , filter, , itemStack, remainder);
}
}
{
( ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
container.internal_getSlot(i);
((slotItemStack == || slotItemStack.isEmpty()) && (!filter || !container.cantAddToSlot(i, itemStack, slotItemStack))) {
Math.min(itemMaxStack, testQuantityRemaining);
testQuantityRemaining -= quantityAdjustment;
}
}
testQuantityRemaining;
}
ItemStackSlotTransaction {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
(ItemStackSlotTransaction)itemContainer.writeAction(() -> {
itemStack.getQuantity();
itemContainer.internal_getSlot(slot);
(filter && itemContainer.cantAddToSlot(slot, itemStack, slotItemStack)) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
} (slotItemStack == ) {
itemContainer.internal_setSlot(slot, itemStack);
(, ActionType.ADD, slot, (ItemStack), itemStack, (ItemStack), allOrNothing, , filter, , itemStack, (ItemStack));
} {
slotItemStack.getQuantity();
(!itemStack.isStackableWith(slotItemStack)) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
} {
Math.min(slotItemStack.getItem().getMaxStack() - quantity, quantityRemaining);
quantity + quantityAdjustment;
quantityRemaining -= quantityAdjustment;
(allOrNothing && quantityRemaining > ) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
} (quantityAdjustment <= ) {
(, ActionType.ADD, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStack, itemStack);
} {
slotItemStack.withQuantity(newQuantity);
itemContainer.internal_setSlot(slot, newItemStack);
itemStack.withQuantity(quantityRemaining);
(, ActionType.ADD, slot, slotItemStack, newItemStack, (ItemStack), allOrNothing, , filter, , itemStack, remainder);
}
}
}
});
}
ItemStackSlotTransaction {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
(ItemStackSlotTransaction)itemContainer.writeAction(() -> {
itemContainer.internal_getSlot(slot);
(filter && itemContainer.cantAddToSlot(slot, itemStack, slotItemStack)) {
(, ActionType.SET, slot, slotItemStack, slotItemStack, (ItemStack), , , filter, , itemStack, itemStack);
} {
itemContainer.internal_setSlot(slot, itemStack);
(, ActionType.SET, slot, oldItemStack, itemStack, (ItemStack), , , filter, , itemStack, (ItemStack));
}
});
}
SlotTransaction {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
(SlotTransaction)itemContainer.writeAction(() -> {
(filter && itemContainer.cantRemoveFromSlot(slot)) {
itemContainer.internal_getSlot(slot);
(, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter, , (ItemStack), itemStack);
} {
itemContainer.internal_removeSlot(slot);
(, ActionType.REMOVE, slot, oldItemStack, (ItemStack), oldItemStack, , , );
}
});
}
ItemStackSlotTransaction {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
ItemContainer.validateQuantity(quantityToRemove);
(ItemStackSlotTransaction)itemContainer.writeAction(() -> {
(filter && itemContainer.cantRemoveFromSlot(slot)) {
itemContainer.internal_getSlot(slot);
(, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, , (ItemStack), itemStack.withQuantity(quantityToRemove));
} {
itemContainer.internal_getSlot(slot);
(slotItemStack == ) {
(, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, , (ItemStack), (ItemStack));
} {
slotItemStack.getQuantity();
Math.min(quantity, quantityToRemove);
quantity - quantityAdjustment;
quantityToRemove - quantityAdjustment;
(allOrNothing && quantityRemaining > ) {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , (ItemStack), slotItemStack.withQuantity(quantityRemaining));
} {
slotItemStack.withQuantity(newQuantity);
itemContainer.internal_setSlot(slot, itemStack);
slotItemStack.withQuantity(quantityAdjustment);
slotItemStack.withQuantity(quantityRemaining);
(, ActionType.REMOVE, slot, slotItemStack, itemStack, newStack, allOrNothing, , filter, , (ItemStack), remainder);
}
}
}
});
}
ItemStackSlotTransaction {
internal_removeItemStackFromSlot(itemContainer, slot, itemStackToRemove, quantityToRemove, allOrNothing, filter, (a, b) -> ItemStack.isStackableWith(a, b));
}
ItemStackSlotTransaction {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
ItemContainer.validateQuantity(quantityToRemove);
(ItemStackSlotTransaction)itemContainer.writeAction(() -> {
(filter && itemContainer.cantRemoveFromSlot(slot)) {
itemContainer.internal_getSlot(slot);
(, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
} {
itemContainer.internal_getSlot(slot);
((slotItemStack != || itemStackToRemove == ) && (slotItemStack == || itemStackToRemove != ) && (slotItemStack == || predicate.test(slotItemStack, itemStackToRemove))) {
(slotItemStack == ) {
(, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
} {
slotItemStack.getQuantity();
Math.min(quantity, quantityToRemove);
quantity - quantityAdjustment;
quantityToRemove - quantityAdjustment;
(allOrNothing && quantityRemaining > ) {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
} {
slotItemStack.withQuantity(newQuantity);
itemContainer.internal_setSlot(slot, itemStack);
slotItemStack.withQuantity(quantityAdjustment);
itemStackToRemove.withQuantity(quantityRemaining);
(, ActionType.REMOVE, slot, slotItemStack, itemStack, newStack, allOrNothing, , filter, , itemStackToRemove, remainder);
}
}
} {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, , itemStackToRemove, itemStackToRemove);
}
}
});
}
{
testRemoveItemStackFromSlot(container, slot, itemStack, testQuantityRemaining, filter, (a, b) -> ItemStack.isStackableWith(a, b));
}
{
(filter && container.cantRemoveFromSlot(slot)) {
testQuantityRemaining;
} {
container.internal_getSlot(slot);
(ItemStack.isEmpty(slotItemStack)) {
testQuantityRemaining;
} (!predicate.test(slotItemStack, itemStack)) {
testQuantityRemaining;
} {
slotItemStack.getQuantity();
Math.min(quantity, testQuantityRemaining);
testQuantityRemaining -= quantityAdjustment;
testQuantityRemaining;
}
}
}
ItemStackTransaction {
itemStack.getItem();
(item == ) {
(itemStack.getItemId() + );
} {
item.getMaxStack();
(ItemStackTransaction)itemContainer.writeAction(() -> {
(allOrNothing) {
itemStack.getQuantity();
(!fullStacks) {
testQuantityRemaining = testAddToExistingItemStacks(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
}
testQuantityRemaining = testAddToEmptySlots(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
(testQuantityRemaining > ) {
(, ActionType.ADD, itemStack, itemStack, allOrNothing, filter, Collections.emptyList());
}
}
List<ItemStackSlotTransaction> list = <ItemStackSlotTransaction>();
itemStack;
(!fullStacks) {
( ; i < itemContainer.getCapacity() && !ItemStack.isEmpty(remaining); ++i) {
internal_addToExistingSlot(itemContainer, i, remaining, itemMaxStack, filter);
list.add(transaction);
remaining = transaction.getRemainder();
}
}
( ; i < itemContainer.getCapacity() && !ItemStack.isEmpty(remaining); ++i) {
internal_addToEmptySlot(itemContainer, i, remaining, itemMaxStack, filter);
list.add(transaction);
remaining = transaction.getRemainder();
}
(, ActionType.ADD, itemStack, remaining, allOrNothing, filter, list);
});
}
}
ListTransaction<ItemStackTransaction> {
itemStacks != && !itemStacks.isEmpty() ? (ListTransaction)itemContainer.writeAction(() -> {
(allOrNothing) {
(ItemStack itemStack : itemStacks) {
itemStack.getItem().getMaxStack();
itemStack.getQuantity();
(!fullStacks) {
testQuantityRemaining = testAddToExistingItemStacks(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
}
testQuantityRemaining = testAddToEmptySlots(itemContainer, itemStack, itemMaxStack, testQuantityRemaining, filter);
(testQuantityRemaining > ) {
(, (List)itemStacks.stream().map((i) -> (, ActionType.ADD, itemStack, itemStack, allOrNothing, filter, Collections.emptyList())).collect(Collectors.toList()));
}
}
}
List<ItemStackTransaction> remainingItemStacks = <ItemStackTransaction>();
(ItemStack itemStack : itemStacks) {
remainingItemStacks.add(internal_addItemStack(itemContainer, itemStack, allOrNothing, fullStacks, filter));
}
(, remainingItemStacks);
}) : ListTransaction.getEmptyTransaction();
}
ListTransaction<ItemStackSlotTransaction> {
(itemStacks != && !itemStacks.isEmpty()) {
ItemContainer.validateSlotIndex(offset, itemContainer.getCapacity());
ItemContainer.validateSlotIndex(()(offset + itemStacks.size()), itemContainer.getCapacity());
(ListTransaction)itemContainer.writeAction(() -> {
(allOrNothing) {
( ; i < itemStacks.size(); ++i) {
()(offset + i);
(ItemStack)itemStacks.get(i);
itemStack.getItem().getMaxStack();
itemStack.getQuantity();
testQuantityRemaining = testAddToExistingSlot(itemContainer, slot, itemStack, itemMaxStack, testQuantityRemaining, filter);
(testQuantityRemaining > ) {
List<ItemStackSlotTransaction> list = <ItemStackSlotTransaction>();
( ; i1 < itemStacks.size(); ++i1) {
()(offset + i1);
list.add( (, ActionType.ADD, islot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, , itemStack, itemStack));
}
(, list);
}
}
}
List<ItemStackSlotTransaction> remainingItemStacks = <ItemStackSlotTransaction>();
( ; i < itemStacks.size(); ++i) {
()(offset + i);
remainingItemStacks.add(internal_addItemStackToSlot(itemContainer, slot, (ItemStack)itemStacks.get(i), allOrNothing, filter));
}
(, remainingItemStacks);
});
} {
ListTransaction.<ItemStackSlotTransaction>getEmptyTransaction();
}
}
{
( ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
testQuantityRemaining = testAddToExistingSlot(container, i, itemStack, itemMaxStack, testQuantityRemaining, filter);
}
testQuantityRemaining;
}
ItemStackTransaction {
itemStack.getItem();
(item == ) {
(itemStack.getItemId() + );
} {
(ItemStackTransaction)itemContainer.writeAction(() -> {
(allOrNothing) {
testRemoveItemStackFromItems(itemContainer, itemStack, itemStack.getQuantity(), filter);
(testQuantityRemaining > ) {
(, ActionType.REMOVE, itemStack, itemStack, allOrNothing, filter, Collections.emptyList());
}
}
List<ItemStackSlotTransaction> transactions = <ItemStackSlotTransaction>();
itemStack.getQuantity();
( ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
itemContainer.internal_getSlot(i);
(!ItemStack.isEmpty(slotItemStack) && slotItemStack.isStackableWith(itemStack)) {
internal_removeItemStackFromSlot(itemContainer, i, quantityRemaining, , filter);
transactions.add(transaction);
quantityRemaining = transaction.getRemainder() != ? transaction.getRemainder().getQuantity() : ;
}
}
quantityRemaining > ? itemStack.withQuantity(quantityRemaining) : ;
(, ActionType.REMOVE, itemStack, remainder, allOrNothing, filter, transactions);
});
}
}
ListTransaction<ItemStackTransaction> {
(itemStacks != && !itemStacks.isEmpty()) {
(ItemStack itemStack : itemStacks) {
itemStack.getItem();
(item == ) {
(itemStack.getItemId() + );
}
}
(ListTransaction)itemContainer.writeAction(() -> {
(allOrNothing) {
(ItemStack itemStack : itemStacks) {
testRemoveItemStackFromItems(itemContainer, itemStack, itemStack.getQuantity(), filter);
(testQuantityRemaining > ) {
(, (List)itemStacks.stream().map((ix) -> (, ActionType.ADD, itemStack, itemStack, allOrNothing, filter, Collections.emptyList())).collect(Collectors.toList()));
}
}
}
List<ItemStackTransaction> transactions = <ItemStackTransaction>();
( ; i < itemStacks.size(); ++i) {
transactions.add(internal_removeItemStack(itemContainer, (ItemStack)itemStacks.get(i), allOrNothing, filter));
}
(, transactions);
});
} {
ListTransaction.<ItemStackTransaction>getEmptyTransaction();
}
}
{
( ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
(!filter || !container.cantRemoveFromSlot(i)) {
container.internal_getSlot(i);
(!ItemStack.isEmpty(slotItemStack) && slotItemStack.isStackableWith(itemStack)) {
slotItemStack.getQuantity();
Math.min(quantity, testQuantityRemaining);
testQuantityRemaining -= quantityAdjustment;
}
}
}
testQuantityRemaining;
}
TestRemoveItemSlotResult {
testRemoveItemStackSlotFromItems(container, itemStack, testQuantityRemaining, filter, (a, b) -> ItemStack.isStackableWith(a, b));
}
TestRemoveItemSlotResult {
(testQuantityRemaining);
( ; i < container.getCapacity() && result.quantityRemaining > ; ++i) {
(!filter || !container.cantRemoveFromSlot(i)) {
container.internal_getSlot(i);
(!ItemStack.isEmpty(slotItemStack) && predicate.test(slotItemStack, itemStack)) {
slotItemStack.getQuantity();
Math.min(quantity, result.quantityRemaining);
result.quantityRemaining -= quantityAdjustment;
result.picked.put(i, quantityAdjustment);
}
}
}
result;
}
}
com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilMaterial.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MaterialSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MaterialTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ResourceSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.TagSlotTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class InternalContainerUtilMaterial {
public InternalContainerUtilMaterial() {
}
@Nonnull
protected static MaterialSlotTransaction internal_removeMaterialFromSlot(@Nonnull ItemContainer itemContainer, short slot, @Nonnull MaterialQuantity material, boolean allOrNothing, boolean filter) {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
ItemContainer.validateQuantity(material.getQuantity());
(material.getItemId() != ) {
InternalContainerUtilItemStack.internal_removeItemStackFromSlot(itemContainer, slot, material.toItemStack(), material.getQuantity(), allOrNothing, filter, (a, b) -> ItemStack.isEquivalentType(a, b));
(material, slotTransaction.getRemainder() != ? slotTransaction.getRemainder().getQuantity() : , slotTransaction);
} (material.getTagIndex() != -) {
InternalContainerUtilTag.internal_removeTagFromSlot(itemContainer, slot, material.getTagIndex(), material.getQuantity(), allOrNothing, filter);
(material, tagTransaction.getRemainder(), tagTransaction);
} {
InternalContainerUtilResource.internal_removeResourceFromSlot(itemContainer, slot, material.toResource(), allOrNothing, filter);
(material, resourceTransaction.getRemainder(), resourceTransaction);
}
}
MaterialTransaction {
(MaterialTransaction)itemContainer.writeAction(() -> {
(allOrNothing || exactAmount) {
testRemoveMaterialFromItems(itemContainer, material, material.getQuantity(), filter);
(testQuantityRemaining > ) {
(, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList());
}
(exactAmount && testQuantityRemaining < ) {
(, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList());
}
}
List<MaterialSlotTransaction> list = <MaterialSlotTransaction>();
material.getQuantity();
( ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
material.clone(quantityRemaining);
internal_removeMaterialFromSlot(itemContainer, i, clone, , filter);
(transaction.succeeded()) {
list.add(transaction);
quantityRemaining = transaction.getRemainder();
}
}
(quantityRemaining != material.getQuantity(), ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, list);
});
}
ListTransaction<MaterialTransaction> {
materials != && !materials.isEmpty() ? (ListTransaction)itemContainer.writeAction(() -> {
(allOrNothing || exactAmount) {
(MaterialQuantity material : materials) {
testRemoveMaterialFromItems(itemContainer, material, material.getQuantity(), filter);
(testQuantityRemaining > ) {
(, (List)materials.stream().map((remainder) -> (, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
}
(exactAmount && testQuantityRemaining < ) {
(, (List)materials.stream().map((remainder) -> (, ActionType.REMOVE, material, material.getQuantity(), allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
}
}
}
List<MaterialTransaction> transactions = <MaterialTransaction>();
(MaterialQuantity material : materials) {
transactions.add(internal_removeMaterial(itemContainer, material, allOrNothing, exactAmount, filter));
}
(, transactions);
}) : ListTransaction.getEmptyTransaction();
}
{
(material.getItemId() != ) {
InternalContainerUtilItemStack.testRemoveItemStackFromItems(container, material.toItemStack(), testQuantityRemaining, filter);
} {
material.getTagIndex() != - ? InternalContainerUtilTag.testRemoveTagFromItems(container, material.getTagIndex(), testQuantityRemaining, filter) : InternalContainerUtilResource.testRemoveResourceFromItems(container, material.toResource(), testQuantityRemaining, filter);
}
}
TestRemoveItemSlotResult {
(material.getItemId() != ) {
InternalContainerUtilItemStack.testRemoveItemStackSlotFromItems(container, material.toItemStack(), testQuantityRemaining, filter, (a, b) -> ItemStack.isEquivalentType(a, b));
} {
material.getTagIndex() != - ? InternalContainerUtilTag.testRemoveTagSlotFromItems(container, material.getTagIndex(), testQuantityRemaining, filter) : InternalContainerUtilResource.testRemoveResourceSlotFromItems(container, material.toResource(), testQuantityRemaining, filter);
}
}
ListTransaction<MaterialSlotTransaction> {
(materials != && !materials.isEmpty()) {
offset + materials.size() > itemContainer.getCapacity() ? ListTransaction.getEmptyTransaction() : (ListTransaction)itemContainer.writeAction(() -> {
(allOrNothing || exactAmount) {
( ; i < materials.size(); ++i) {
()(offset + i);
(MaterialQuantity)materials.get(i);
testRemoveMaterialFromSlot(itemContainer, slot, material, material.getQuantity(), filter);
(testQuantityRemaining > ) {
List<MaterialSlotTransaction> list = <MaterialSlotTransaction>();
( ; i1 < materials.size(); ++i1) {
()(offset + i1);
list.add( (material, material.getQuantity(), (, ActionType.REMOVE, islot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, exactAmount, filter)));
}
(, list);
}
(exactAmount && testQuantityRemaining < ) {
List<MaterialSlotTransaction> list = <MaterialSlotTransaction>();
( ; i1 < materials.size(); ++i1) {
()(offset + i1);
list.add( (material, material.getQuantity(), (, ActionType.REMOVE, islot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, exactAmount, filter)));
}
(, list);
}
}
}
List<MaterialSlotTransaction> transactions = <MaterialSlotTransaction>();
( ; i < materials.size(); ++i) {
()(offset + i);
(MaterialQuantity)materials.get(i);
transactions.add(internal_removeMaterialFromSlot(itemContainer, slot, material, allOrNothing, filter));
}
(, transactions);
});
} {
ListTransaction.<MaterialSlotTransaction>getEmptyTransaction();
}
}
{
(material.getItemId() != ) {
InternalContainerUtilItemStack.testRemoveItemStackFromSlot(container, slot, material.toItemStack(), testQuantityRemaining, filter, (a, b) -> ItemStack.isEquivalentType(a, b));
} {
material.getTagIndex() != - ? InternalContainerUtilTag.testRemoveTagFromSlot(container, slot, material.getTagIndex(), testQuantityRemaining, filter) : InternalContainerUtilResource.testRemoveResourceFromSlot(container, slot, material.toResource(), testQuantityRemaining, filter);
}
}
}
com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilResource.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.protocol.ItemResourceType;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ResourceSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ResourceTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class InternalContainerUtilResource {
public InternalContainerUtilResource() {
}
protected static ResourceSlotTransaction internal_removeResourceFromSlot(@Nonnull ItemContainer itemContainer, short slot, @Nonnull ResourceQuantity resource, boolean allOrNothing, boolean filter) {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
ItemContainer.validateQuantity(resource.getQuantity());
return (ResourceSlotTransaction)itemContainer.writeAction(() -> {
if (filter && itemContainer.cantRemoveFromSlot(slot)) {
itemContainer.internal_getSlot(slot);
(, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
} {
itemContainer.internal_getSlot(slot);
(slotItemStack == ) {
(, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
} {
slotItemStack.getItem();
slotItemStack.getQuantity();
resource.getResourceType(slotItem);
(resourceType == ) {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
} {
resourceType.quantity;
resource.getQuantity();
MathUtil.ceil(()quantityRemaining / ()resourceTypeQuantity);
Math.min(quantityInItems, quantityInItemsRemaining);
Math.max(quantityInItems - quantityInItemsAdjustment, );
quantityInItemsAdjustment * resourceTypeQuantity;
quantityRemaining -= quantityAdjustment;
(allOrNothing && quantityRemaining > ) {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
} (quantityAdjustment <= ) {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, resource, resource.getQuantity(), );
} {
slotItemStack.withQuantity(newItemStackQuantity);
itemContainer.internal_setSlot(slot, slotNewItemStack);
slotItemStack.withQuantity(quantityInItemsAdjustment);
(, ActionType.REMOVE, slot, slotItemStack, slotNewItemStack, newStack, allOrNothing, , filter, resource, quantityRemaining, quantityAdjustment);
}
}
}
}
});
}
ResourceTransaction {
(ResourceTransaction)itemContainer.writeAction(() -> {
(allOrNothing || exactAmount) {
testRemoveResourceFromItems(itemContainer, resource, resource.getQuantity(), filter);
(testQuantityRemaining > ) {
(, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList());
}
(exactAmount && testQuantityRemaining < ) {
(, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList());
}
}
List<ResourceSlotTransaction> list = <ResourceSlotTransaction>();
;
resource.getQuantity();
( ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
resource.clone(quantityRemaining);
internal_removeResourceFromSlot(itemContainer, i, clone, , filter);
(transaction.succeeded()) {
list.add(transaction);
quantityRemaining = transaction.getRemainder();
consumed += transaction.getConsumed();
}
}
(quantityRemaining != resource.getQuantity(), ActionType.REMOVE, resource, quantityRemaining, consumed, allOrNothing, exactAmount, filter, list);
});
}
ListTransaction<ResourceTransaction> {
resources != && !resources.isEmpty() ? (ListTransaction)itemContainer.writeAction(() -> {
(allOrNothing || exactAmount) {
(ResourceQuantity resource : resources) {
testRemoveResourceFromItems(itemContainer, resource, resource.getQuantity(), filter);
(testQuantityRemaining > ) {
(, (List)resources.stream().map((remainder) -> (, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
}
(exactAmount && testQuantityRemaining < ) {
(, (List)resources.stream().map((remainder) -> (, ActionType.REMOVE, resource, resource.getQuantity(), , allOrNothing, exactAmount, filter, Collections.emptyList())).collect(Collectors.toList()));
}
}
}
List<ResourceTransaction> transactions = <ResourceTransaction>();
(ResourceQuantity resource : resources) {
transactions.add(internal_removeResource(itemContainer, resource, allOrNothing, exactAmount, filter));
}
(, transactions);
}) : ListTransaction.getEmptyTransaction();
}
{
( ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
testQuantityRemaining = testRemoveResourceFromSlot(container, i, resource, testQuantityRemaining, filter);
}
testQuantityRemaining;
}
TestRemoveItemSlotResult {
(testQuantityRemaining);
( ; i < container.getCapacity() && result.quantityRemaining > ; ++i) {
testRemoveResourceFromSlot(container, i, resource, result.quantityRemaining, filter);
(newValue != result.quantityRemaining) {
result.quantityRemaining - newValue;
result.quantityRemaining = newValue;
result.picked.put(i, diff);
}
}
result;
}
{
(filter && container.cantRemoveFromSlot(slot)) {
testQuantityRemaining;
} {
container.internal_getSlot(slot);
(ItemStack.isEmpty(slotItemStack)) {
testQuantityRemaining;
} {
slotItemStack.getItem();
resource.getResourceType(slotItem);
(resourceType == ) {
testQuantityRemaining;
} {
resourceType.quantity;
MathUtil.ceil(()testQuantityRemaining / ()resourceTypeQuantity);
slotItemStack.getQuantity();
Math.min(quantityInItems, quantityInItemsRemaining);
quantityInItemsAdjustment * resourceTypeQuantity;
testQuantityRemaining -= quantityAdjustment;
testQuantityRemaining;
}
}
}
}
}
com/hypixel/hytale/server/core/inventory/container/InternalContainerUtilTag.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.assetstore.AssetExtraInfo;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.TagSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.TagTransaction;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;
public class InternalContainerUtilTag {
public InternalContainerUtilTag() {
}
protected static TagSlotTransaction internal_removeTagFromSlot(@Nonnull ItemContainer itemContainer, short slot, int tagIndex, int quantity, boolean allOrNothing, boolean filter) {
ItemContainer.validateSlotIndex(slot, itemContainer.getCapacity());
ItemContainer.validateQuantity(quantity);
return (TagSlotTransaction)itemContainer.writeAction(() -> {
if (filter && itemContainer.cantRemoveFromSlot(slot)) {
ItemStack itemStack = itemContainer.internal_getSlot(slot);
return new TagSlotTransaction(false, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), allOrNothing, , filter, tagIndex, quantity);
} {
itemContainer.internal_getSlot(slot);
(slotItemStack == ) {
(, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), allOrNothing, , filter, tagIndex, quantity);
} {
slotItemStack.getItem();
slotItemStack.getQuantity();
(slotItem.getData() != && slotItem.getData().getExpandedTagIndexes().contains(tagIndex)) {
Math.min(quantityInItems, quantity);
quantityInItems - quantityInItemsAdjustment;
quantity - quantityInItemsAdjustment;
(allOrNothing && quantityRemaining > ) {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, tagIndex, quantity);
} {
slotItemStack.withQuantity(newItemStackQuantity);
itemContainer.internal_setSlot(slot, slotNewItemStack);
slotItemStack.withQuantity(quantityInItemsAdjustment);
(, ActionType.REMOVE, slot, slotItemStack, slotNewItemStack, newStack, allOrNothing, , filter, tagIndex, quantityRemaining);
}
} {
(, ActionType.REMOVE, slot, slotItemStack, slotItemStack, (ItemStack), allOrNothing, , filter, tagIndex, quantity);
}
}
}
});
}
TagTransaction {
(TagTransaction)itemContainer.writeAction(() -> {
(allOrNothing || exactAmount) {
testRemoveTagFromItems(itemContainer, tagIndex, quantity, filter);
(testQuantityRemaining > ) {
(, ActionType.REMOVE, tagIndex, quantity, allOrNothing, exactAmount, filter, Collections.emptyList());
}
(exactAmount && testQuantityRemaining < ) {
(, ActionType.REMOVE, tagIndex, quantity, allOrNothing, exactAmount, filter, Collections.emptyList());
}
}
List<TagSlotTransaction> list = <TagSlotTransaction>();
quantity;
( ; i < itemContainer.getCapacity() && quantityRemaining > ; ++i) {
internal_removeTagFromSlot(itemContainer, i, tagIndex, quantityRemaining, allOrNothing, filter);
list.add(transaction);
quantityRemaining = transaction.getRemainder();
}
(, ActionType.REMOVE, tagIndex, quantityRemaining, allOrNothing, exactAmount, filter, list);
});
}
{
( ; i < container.getCapacity() && testQuantityRemaining > ; ++i) {
(!filter || !container.cantRemoveFromSlot(i)) {
container.internal_getSlot(i);
(!ItemStack.isEmpty(slotItemStack)) {
AssetExtraInfo. slotItemStack.getItem().getData();
(slotItemData != && slotItemData.getExpandedTagIndexes().contains(tagIndex)) {
slotItemStack.getQuantity();
testQuantityRemaining -= Math.min(quantityInItems, testQuantityRemaining);
}
}
}
}
testQuantityRemaining;
}
TestRemoveItemSlotResult {
(testQuantityRemaining);
( ; i < container.getCapacity() && result.quantityRemaining > ; ++i) {
(!filter || !container.cantRemoveFromSlot(i)) {
container.internal_getSlot(i);
(!ItemStack.isEmpty(slotItemStack)) {
AssetExtraInfo. slotItemStack.getItem().getData();
(slotItemData != && slotItemData.getExpandedTagIndexes().contains(tagIndex)) {
slotItemStack.getQuantity();
result.quantityRemaining -= Math.min(quantityInItems, result.quantityRemaining);
}
}
}
}
result;
}
{
(filter && container.cantRemoveFromSlot(slot)) {
testQuantityRemaining;
} {
container.internal_getSlot(slot);
(ItemStack.isEmpty(slotItemStack)) {
testQuantityRemaining;
} {
slotItemStack.getItem();
(!slotItem.getData().getExpandedTagIndexes().contains(tagIndex)) {
testQuantityRemaining;
} {
slotItemStack.getQuantity();
testQuantityRemaining -= Math.min(quantityInItems, testQuantityRemaining);
testQuantityRemaining;
}
}
}
}
}
com/hypixel/hytale/server/core/inventory/container/ItemContainer.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.fastutil.shorts.Short2ObjectConcurrentHashMap;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.event.EventPriority;
import com.hypixel.hytale.event.EventRegistration;
import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.event.SyncEventBusRegistry;
import com.hypixel.hytale.function.consumer.ShortObjectConsumer;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.InventorySection;
import com.hypixel.hytale.protocol.ItemResourceType;
import com.hypixel.hytale.protocol.ItemWithAllMetadata;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ActionType;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MaterialSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MaterialTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.MoveTransaction;
com.hypixel.hytale.server.core.inventory.transaction.MoveType;
com.hypixel.hytale.server.core.inventory.transaction.ResourceSlotTransaction;
com.hypixel.hytale.server.core.inventory.transaction.ResourceTransaction;
com.hypixel.hytale.server.core.inventory.transaction.SlotTransaction;
com.hypixel.hytale.server.core.inventory.transaction.TagSlotTransaction;
com.hypixel.hytale.server.core.inventory.transaction.TagTransaction;
com.hypixel.hytale.server.core.inventory.transaction.Transaction;
it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
it.unimi.dsi.fastutil.ints.IntArrays;
it.unimi.dsi.fastutil.objects.ObjectArrayList;
java.util.Arrays;
java.util.Collections;
java.util.List;
java.util.Map;
java.util.Objects;
java.util.function.Consumer;
java.util.function.Function;
java.util.function.Predicate;
java.util.function.Supplier;
javax.annotation.Nonnull;
javax.annotation.Nullable;
{
CodecMapCodec<ItemContainer> CODEC = <ItemContainer>();
;
;
;
;
;
HytaleLogger.forEnclosingClass();
SyncEventBusRegistry<Void, ItemContainerChangeEvent> externalChangeEventRegistry;
SyncEventBusRegistry<Void, ItemContainerChangeEvent> internalChangeEventRegistry;
{
.externalChangeEventRegistry = <Void, ItemContainerChangeEvent>(LOGGER, ItemContainerChangeEvent.class);
.internalChangeEventRegistry = <Void, ItemContainerChangeEvent>(LOGGER, ItemContainerChangeEvent.class);
}
;
;
;
ItemContainer ;
<V> V ;
<X, V> V ;
<V> V ;
<X, V> V ;
ClearTransaction ;
ItemStack ;
ItemStack ;
ItemStack ;
;
;
;
;
InventorySection {
();
packet.capacity = .getCapacity();
packet.items = .toProtocolMap();
packet;
}
Map<Integer, ItemWithAllMetadata> {
Map<Integer, ItemWithAllMetadata> map = ();
.forEachWithMeta((slot, itemStack, _map) -> {
(!ItemStack.isEmpty(itemStack) && itemStack.isValid()) {
_map.put(Integer.valueOf(slot), itemStack.toPacket());
}
}, map);
map;
}
EventRegistration {
.registerChangeEvent((), consumer);
}
EventRegistration {
.registerChangeEvent(priority.getValue(), consumer);
}
EventRegistration {
.externalChangeEventRegistry.register(priority, (Object), consumer);
}
ClearTransaction {
(ClearTransaction).writeAction(::internal_clear);
.sendUpdate(transaction);
transaction;
}
{
validateSlotIndex(slot, .getCapacity());
(Boolean).writeAction(() -> {
itemStack.getQuantity();
.internal_getSlot(slot);
(filter && .cantAddToSlot(slot, itemStack, slotItemStack)) {
;
} (slotItemStack == ) {
;
} (!itemStack.isStackableWith(slotItemStack)) {
;
} {
slotItemStack.getQuantity();
Math.min(slotItemStack.getItem().getMaxStack() - quantity, quantityRemaining);
quantityRemaining - quantityAdjustment;
allOrNothing ? quantityRemaining <= : quantityRemaining != newQuantityRemaining;
}
});
}
ItemStackSlotTransaction {
.addItemStackToSlot(slot, itemStack, , );
}
ItemStackSlotTransaction {
InternalContainerUtilItemStack.internal_addItemStackToSlot(, slot, itemStack, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
}
ItemStackSlotTransaction {
.setItemStackForSlot(slot, itemStack, );
}
ItemStackSlotTransaction {
InternalContainerUtilItemStack.internal_setItemStackForSlot(, slot, itemStack, filter);
.sendUpdate(transaction);
transaction;
}
ItemStack {
validateSlotIndex(slot, .getCapacity());
(ItemStack).readAction(() -> .internal_getSlot(slot));
}
ItemStackSlotTransaction {
.internal_replaceItemStack(slot, itemStackToRemove, itemStack);
.sendUpdate(transaction);
transaction;
}
ListTransaction<ItemStackSlotTransaction> {
.replaceAll(func, );
}
ListTransaction<ItemStackSlotTransaction> {
ListTransaction<ItemStackSlotTransaction> transaction = (ListTransaction).writeAction(() -> {
.getCapacity();
ObjectArrayList<ItemStackSlotTransaction> transactionsList = <ItemStackSlotTransaction>(capacity);
( ; slot < capacity; ++slot) {
.internal_getSlot(slot);
(!ignoreEmpty || !ItemStack.isEmpty(existing)) {
func.replace(slot, existing);
.internal_setSlot(slot, replacement);
transactionsList.add( (, ActionType.REPLACE, slot, existing, replacement, existing, , , , , replacement, replacement));
}
}
(, transactionsList);
});
.sendUpdate(transaction);
transaction;
}
ItemStackSlotTransaction {
validateSlotIndex(slot, .getCapacity());
(ItemStackSlotTransaction).writeAction(() -> {
.internal_getSlot(slot);
((slotItemStack != || itemStackToRemove == ) && (slotItemStack == || itemStackToRemove != ) && (slotItemStack == || itemStackToRemove.isStackableWith(slotItemStack))) {
.internal_setSlot(slot, itemStack);
(, ActionType.REPLACE, slot, slotItemStack, itemStack, slotItemStack, , , , , itemStack, (ItemStack));
} {
(, ActionType.REPLACE, slot, slotItemStack, slotItemStack, (ItemStack), , , , , itemStack, itemStack);
}
});
}
SlotTransaction {
.removeItemStackFromSlot(slot, );
}
SlotTransaction {
InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, filter);
.sendUpdate(transaction);
transaction;
}
ItemStackSlotTransaction {
.removeItemStackFromSlot(slot, quantityToRemove, , );
}
ItemStackSlotTransaction {
InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, quantityToRemove, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
}
ItemStackSlotTransaction {
InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, quantityToRemove, , );
}
ItemStackSlotTransaction {
.removeItemStackFromSlot(slot, itemStackToRemove, quantityToRemove, , );
}
ItemStackSlotTransaction {
InternalContainerUtilItemStack.internal_removeItemStackFromSlot(, slot, itemStackToRemove, quantityToRemove, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
}
MaterialSlotTransaction {
.removeMaterialFromSlot(slot, material, , , );
}
MaterialSlotTransaction {
InternalContainerUtilMaterial.internal_removeMaterialFromSlot(, slot, material, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
}
ResourceSlotTransaction {
.removeResourceFromSlot(slot, resource, , , );
}
ResourceSlotTransaction {
InternalContainerUtilResource.internal_removeResourceFromSlot(, slot, resource, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
}
TagSlotTransaction {
.removeTagFromSlot(slot, tagIndex, quantity, , );
}
TagSlotTransaction {
InternalContainerUtilTag.internal_removeTagFromSlot(, slot, tagIndex, quantity, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
}
MoveTransaction<ItemStackTransaction> {
.moveItemStackFromSlot(slot, containerTo, );
}
MoveTransaction<ItemStackTransaction> {
.moveItemStackFromSlot(slot, containerTo, , filter);
}
MoveTransaction<ItemStackTransaction> {
MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, containerTo, allOrNothing, filter);
.sendUpdate(transaction);
containerTo.sendUpdate(transaction.toInverted());
transaction;
}
MoveTransaction<ItemStackTransaction> {
validateSlotIndex(slot, .getCapacity());
(MoveTransaction).writeAction(() -> (MoveTransaction)containerTo.writeAction(() -> {
(filter && .cantRemoveFromSlot(slot)) {
;
} {
.internal_removeSlot(slot);
(ItemStack.isEmpty(itemFrom)) {
(, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
} {
(, ActionType.REMOVE, slot, itemFrom, (ItemStack), (ItemStack), , , filter);
InternalContainerUtilItemStack.internal_addItemStack(containerTo, itemFrom, allOrNothing, , filter);
addTransaction.getRemainder();
(!ItemStack.isEmpty(remainder)) {
InternalContainerUtilItemStack.internal_addItemStackToSlot(, slot, remainder, allOrNothing, );
}
(addTransaction.succeeded(), fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
}
}
}));
}
MoveTransaction<ItemStackTransaction> {
.moveItemStackFromSlot(slot, quantity, containerTo, , );
}
MoveTransaction<ItemStackTransaction> {
MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, quantity, containerTo, allOrNothing, filter);
.sendUpdate(transaction);
containerTo.sendUpdate(transaction.toInverted());
transaction;
}
MoveTransaction<ItemStackTransaction> {
validateSlotIndex(slot, .getCapacity());
validateQuantity(quantity);
(MoveTransaction).writeAction(() -> (MoveTransaction)containerTo.writeAction(() -> {
(filter && .cantRemoveFromSlot(slot)) {
;
} (filter && containerTo.cantMoveToSlot(, slot)) {
.internal_getSlot(slot);
(, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
} {
.internal_removeItemStack(slot, quantity);
(!fromTransaction.succeeded()) {
(, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
} {
fromTransaction.getOutput();
(ItemStack.isEmpty(itemFrom)) {
(, ActionType.REMOVE, slot, (ItemStack), (ItemStack), (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, ItemStackTransaction.FAILED_ADD);
} {
InternalContainerUtilItemStack.internal_addItemStack(containerTo, itemFrom, allOrNothing, , filter);
addTransaction.getRemainder();
(!ItemStack.isEmpty(remainder)) {
InternalContainerUtilItemStack.internal_addItemStackToSlot(, slot, remainder, allOrNothing, );
}
(addTransaction.succeeded(), fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
}
}
}
}));
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
.moveItemStackFromSlot(slot, , , containerTo);
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
ListTransaction<MoveTransaction<ItemStackTransaction>> transaction = .internal_moveItemStackFromSlot(slot, allOrNothing, filter, containerTo);
.sendUpdate(transaction);
(MoveTransaction<ItemStackTransaction> moveItemStackTransaction : transaction.getList()) {
moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
}
transaction;
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
List<MoveTransaction<ItemStackTransaction>> transactions = <MoveTransaction<ItemStackTransaction>>();
(ItemContainer itemContainer : containerTo) {
MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, itemContainer, allOrNothing, filter);
transactions.add(transaction);
(transaction.succeeded()) {
transaction.getAddTransaction();
(ItemStack.isEmpty(addTransaction.getRemainder())) {
;
}
}
}
<MoveTransaction<ItemStackTransaction>>(!transactions.isEmpty(), transactions);
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
.moveItemStackFromSlot(slot, quantity, , , containerTo);
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
ListTransaction<MoveTransaction<ItemStackTransaction>> transaction = .internal_moveItemStackFromSlot(slot, quantity, allOrNothing, filter, containerTo);
.sendUpdate(transaction);
(MoveTransaction<ItemStackTransaction> moveItemStackTransaction : transaction.getList()) {
moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
}
transaction;
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
List<MoveTransaction<ItemStackTransaction>> transactions = <MoveTransaction<ItemStackTransaction>>();
(ItemContainer itemContainer : containerTo) {
MoveTransaction<ItemStackTransaction> transaction = .internal_moveItemStackFromSlot(slot, quantity, itemContainer, allOrNothing, filter);
transactions.add(transaction);
(transaction.succeeded()) {
transaction.getAddTransaction();
(ItemStack.isEmpty(addTransaction.getRemainder())) {
;
}
}
}
<MoveTransaction<ItemStackTransaction>>(!transactions.isEmpty(), transactions);
}
MoveTransaction<SlotTransaction> {
.moveItemStackFromSlotToSlot(slot, quantity, containerTo, slotTo, );
}
MoveTransaction<SlotTransaction> {
MoveTransaction<SlotTransaction> transaction = .internal_moveItemStackFromSlot(slot, quantity, containerTo, slotTo, filter);
.sendUpdate(transaction);
containerTo.sendUpdate(transaction.toInverted());
transaction;
}
MoveTransaction<SlotTransaction> {
validateSlotIndex(slot, .getCapacity());
validateSlotIndex(slotTo, containerTo.getCapacity());
validateQuantity(quantity);
(MoveTransaction).writeAction(() -> (MoveTransaction)containerTo.writeAction(() -> {
(filter && .cantRemoveFromSlot(slot)) {
.internal_getSlot(slot);
(, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
} (filter && containerTo.cantMoveToSlot(, slot)) {
.internal_getSlot(slot);
(, ActionType.REMOVE, slot, itemStack, itemStack, (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
} {
.internal_removeItemStack(slot, quantity);
(!fromTransaction.succeeded()) {
(, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
} {
fromTransaction.getOutput();
(ItemStack.isEmpty(itemFrom)) {
(, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, SlotTransaction.FAILED_ADD);
} {
containerTo.getItemStack(slotTo);
(filter && containerTo.cantAddToSlot(slotTo, itemFrom, itemTo)) {
.internal_setSlot(slot, fromTransaction.getSlotBefore());
(, ActionType.REMOVE, slot, fromTransaction.getSlotBefore(), fromTransaction.getSlotAfter(), (ItemStack), , , filter);
(, ActionType.ADD, slotTo, itemTo, itemTo, (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
} (ItemStack.isEmpty(itemTo)) {
InternalContainerUtilItemStack.internal_setItemStackForSlot(containerTo, slotTo, itemFrom, filter);
(, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
} (!itemFrom.isStackableWith(itemTo)) {
(ItemStack.isEmpty(fromTransaction.getSlotAfter())) {
(filter && .cantAddToSlot(slot, itemTo, itemFrom)) {
.internal_setSlot(slot, fromTransaction.getSlotBefore());
(, ActionType.REMOVE, slot, fromTransaction.getSlotBefore(), fromTransaction.getSlotAfter(), (ItemStack), , , filter);
(, ActionType.ADD, slotTo, itemTo, itemTo, (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
} {
.internal_setSlot(slot, itemTo);
containerTo.internal_setSlot(slotTo, itemFrom);
(, ActionType.REPLACE, slot, itemFrom, itemTo, (ItemStack), , , filter);
(, ActionType.REPLACE, slotTo, itemTo, itemFrom, (ItemStack), , , filter);
(, from, MoveType.MOVE_FROM_SELF, containerTo, to);
}
} {
.internal_setSlot(slot, fromTransaction.getSlotBefore());
(, ActionType.REMOVE, slot, fromTransaction.getSlotBefore(), fromTransaction.getSlotAfter(), (ItemStack), , , filter);
(, ActionType.ADD, slotTo, itemTo, itemTo, (ItemStack), , , filter);
(, slotTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
}
} {
itemFrom.getItem().getMaxStack();
itemFrom.getQuantity() + itemTo.getQuantity();
(newQuantity <= maxStack) {
InternalContainerUtilItemStack.internal_setItemStackForSlot(containerTo, slotTo, itemTo.withQuantity(newQuantity), filter);
(, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
} {
InternalContainerUtilItemStack.internal_setItemStackForSlot(containerTo, slotTo, itemTo.withQuantity(maxStack), filter);
newQuantity - maxStack;
!ItemStack.isEmpty(fromTransaction.getSlotAfter()) ? fromTransaction.getSlotAfter().getQuantity() : ;
.internal_setSlot(slot, itemFrom.withQuantity(remainder + quantityLeft));
(, fromTransaction, MoveType.MOVE_FROM_SELF, containerTo, addTransaction);
}
}
}
}
}
}));
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
.moveAllItemStacksTo((Predicate), containerTo);
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
ListTransaction<MoveTransaction<ItemStackTransaction>> transaction = .internal_moveAllItemStacksTo(itemPredicate, containerTo);
.sendUpdate(transaction);
(MoveTransaction<ItemStackTransaction> moveItemStackTransaction : transaction.getList()) {
moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
}
transaction;
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
(ListTransaction).writeAction(() -> {
List<MoveTransaction<ItemStackTransaction>> transactions = <MoveTransaction<ItemStackTransaction>>();
( ; i < .getCapacity(); ++i) {
(!.cantRemoveFromSlot(i)) {
.internal_getSlot(i);
(!ItemStack.isEmpty(checkedItem) && (itemPredicate == || itemPredicate.test(checkedItem))) {
transactions.addAll(.moveItemStackFromSlot(i, containerTo).getList());
}
}
}
(, transactions);
});
}
ListTransaction<MoveTransaction<ItemStackTransaction>> {
.moveAllItemStacksTo((itemStack) -> {
(ItemContainer itemContainer : containerTo) {
(itemContainer.containsItemStacksStackableWith(itemStack)) {
;
}
}
;
}, containerTo);
}
ListTransaction<MoveTransaction<SlotTransaction>> {
ListTransaction<MoveTransaction<SlotTransaction>> transaction = .internal_combineItemStacksIntoSlot(containerTo, slotTo);
.sendUpdate(transaction);
(MoveTransaction<SlotTransaction> moveSlotTransaction : transaction.getList()) {
moveSlotTransaction.getOtherContainer().sendUpdate(moveSlotTransaction.toInverted());
}
transaction;
}
ListTransaction<MoveTransaction<SlotTransaction>> {
validateSlotIndex(slotTo, containerTo.getCapacity());
(ListTransaction).writeAction(() -> {
containerTo.internal_getSlot(slotTo);
itemStack.getItem();
item.getMaxStack();
(!ItemStack.isEmpty(itemStack) && itemStack.getQuantity() < maxStack) {
;
[] quantities = [.getCapacity()];
[] indexes = [.getCapacity()];
( ; i < .getCapacity(); ++i) {
(!.cantRemoveFromSlot(i)) {
.internal_getSlot(i);
(itemStack != itemFrom && !ItemStack.isEmpty(itemFrom) && itemFrom.isStackableWith(itemStack)) {
indexes[count] = i;
quantities[count] = itemFrom.getQuantity();
++count;
}
}
}
IntArrays.quickSort(quantities, indexes, , count);
itemStack.getQuantity();
List<MoveTransaction<SlotTransaction>> list = <MoveTransaction<SlotTransaction>>();
( ; ai < count && quantity < maxStack; ++ai) {
()indexes[ai];
.internal_getSlot(i);
MoveTransaction<SlotTransaction> transaction = .internal_moveItemStackFromSlot(i, itemFrom.getQuantity(), containerTo, slotTo, );
list.add(transaction);
quantity = !ItemStack.isEmpty(((SlotTransaction)transaction.getAddTransaction()).getSlotAfter()) ? ((SlotTransaction)transaction.getAddTransaction()).getSlotAfter().getQuantity() : ;
}
(, list);
} {
(, Collections.emptyList());
}
});
}
ListTransaction<MoveTransaction<SlotTransaction>> {
ListTransaction<MoveTransaction<SlotTransaction>> transaction = .internal_swapItems(srcPos, containerTo, destPos, length);
.sendUpdate(transaction);
(MoveTransaction<SlotTransaction> moveItemStackTransaction : transaction.getList()) {
moveItemStackTransaction.getOtherContainer().sendUpdate(moveItemStackTransaction.toInverted());
}
transaction;
}
ListTransaction<MoveTransaction<SlotTransaction>> {
(srcPos < ) {
();
} (srcPos + length > .getCapacity()) {
();
} (destPos < ) {
();
} (destPos + length > containerTo.getCapacity()) {
();
} {
(ListTransaction).writeAction(() -> (ListTransaction)containerTo.writeAction(() -> {
List<MoveTransaction<SlotTransaction>> list = <MoveTransaction<SlotTransaction>>(length);
( ; slot < length; ++slot) {
list.add(.internal_swapItems(containerTo, ()(srcPos + slot), ()(destPos + slot)));
}
(, list);
}));
}
}
MoveTransaction<SlotTransaction> {
.internal_removeSlot(slotFrom);
containerTo.internal_removeSlot(slotTo);
(itemTo != && !itemTo.isEmpty()) {
.internal_setSlot(slotFrom, itemTo);
}
(itemFrom != && !itemFrom.isEmpty()) {
containerTo.internal_setSlot(slotTo, itemFrom);
}
(, ActionType.REPLACE, slotFrom, itemFrom, itemTo, (ItemStack), , , );
(, ActionType.REPLACE, slotTo, itemTo, itemFrom, (ItemStack), , , );
<SlotTransaction>(, from, MoveType.MOVE_FROM_SELF, containerTo, to);
}
{
.canAddItemStack(itemStack, , );
}
{
itemStack.getItem();
(item == ) {
(itemStack.getItemId() + );
} {
item.getMaxStack();
(Boolean).readAction(() -> {
itemStack.getQuantity();
(!fullStacks) {
testQuantityRemaining = InternalContainerUtilItemStack.testAddToExistingItemStacks(, itemStack, itemMaxStack, testQuantityRemaining, filter);
}
testQuantityRemaining = InternalContainerUtilItemStack.testAddToEmptySlots(, itemStack, itemMaxStack, testQuantityRemaining, filter);
testQuantityRemaining <= ;
});
}
}
ItemStackTransaction {
.addItemStack(itemStack, , , );
}
ItemStackTransaction {
InternalContainerUtilItemStack.internal_addItemStack(, itemStack, allOrNothing, fullStacks, filter);
.sendUpdate(transaction);
transaction;
}
{
.canAddItemStacks(itemStacks, , );
}
{
(itemStacks != && !itemStacks.isEmpty()) {
List<TempItemData> tempItemDataList = <TempItemData>(itemStacks.size());
(ItemStack itemStack : itemStacks) {
itemStack.getItem();
(item == ) {
(itemStack.getItemId() + );
}
tempItemDataList.add( (itemStack, item));
}
(Boolean).readAction(() -> {
(TempItemData tempItemData : tempItemDataList) {
tempItemData.item().getMaxStack();
tempItemData.itemStack();
itemStack.getQuantity();
(!fullStacks) {
testQuantityRemaining = InternalContainerUtilItemStack.testAddToExistingItemStacks(, itemStack, itemMaxStack, testQuantityRemaining, filter);
}
testQuantityRemaining = InternalContainerUtilItemStack.testAddToEmptySlots(, itemStack, itemMaxStack, testQuantityRemaining, filter);
(testQuantityRemaining > ) {
;
}
}
;
});
} {
;
}
}
ListTransaction<ItemStackTransaction> {
.addItemStacks(itemStacks, , , );
}
ListTransaction<ItemStackTransaction> {
(itemStacks != && !itemStacks.isEmpty()) {
ListTransaction<ItemStackTransaction> transaction = InternalContainerUtilItemStack.internal_addItemStacks(, itemStacks, allOrNothing, fullStacks, filter);
.sendUpdate(transaction);
transaction;
} {
ListTransaction.<ItemStackTransaction>getEmptyTransaction();
}
}
ListTransaction<ItemStackSlotTransaction> {
.addItemStacksOrdered(itemStacks, , );
}
ListTransaction<ItemStackSlotTransaction> {
.addItemStacksOrdered(offset, itemStacks, , );
}
ListTransaction<ItemStackSlotTransaction> {
.addItemStacksOrdered((), itemStacks, allOrNothing, filter);
}
ListTransaction<ItemStackSlotTransaction> {
(itemStacks != && !itemStacks.isEmpty()) {
ListTransaction<ItemStackSlotTransaction> transaction = InternalContainerUtilItemStack.internal_addItemStacksOrdered(, offset, itemStacks, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
} {
ListTransaction.<ItemStackSlotTransaction>getEmptyTransaction();
}
}
{
.canRemoveItemStack(itemStack, , );
}
{
itemStack == ? : (Boolean).readAction(() -> {
InternalContainerUtilItemStack.testRemoveItemStackFromItems(, itemStack, itemStack.getQuantity(), filter);
testQuantityRemaining > ? : !exactAmount || testQuantityRemaining >= ;
});
}
ItemStackTransaction {
.removeItemStack(itemStack, , );
}
ItemStackTransaction {
InternalContainerUtilItemStack.internal_removeItemStack(, itemStack, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
}
{
.canRemoveItemStacks(itemStacks, , );
}
{
itemStacks != && !itemStacks.isEmpty() ? (Boolean).readAction(() -> {
(ItemStack itemStack : itemStacks) {
InternalContainerUtilItemStack.testRemoveItemStackFromItems(, itemStack, itemStack.getQuantity(), filter);
(testQuantityRemaining > ) {
;
}
(exactAmount && testQuantityRemaining < ) {
;
}
}
;
}) : ;
}
ListTransaction<ItemStackTransaction> {
.removeItemStacks(itemStacks, , );
}
ListTransaction<ItemStackTransaction> {
(itemStacks != && !itemStacks.isEmpty()) {
ListTransaction<ItemStackTransaction> transaction = InternalContainerUtilItemStack.internal_removeItemStacks(, itemStacks, allOrNothing, filter);
.sendUpdate(transaction);
transaction;
} {
ListTransaction.<ItemStackTransaction>getEmptyTransaction();
}
}
{
.canRemoveTag(tagIndex, quantity, , );
}
{
(Boolean).readAction(() -> {
InternalContainerUtilTag.testRemoveTagFromItems(, tagIndex, quantity, filter);
testQuantityRemaining > ? : !exactAmount || testQuantityRemaining >= ;
});
}
TagTransaction {
.removeTag(tagIndex, quantity, , , );
}
TagTransaction {
InternalContainerUtilTag.internal_removeTag(, tagIndex, quantity, allOrNothing, exactAmount, filter);
.sendUpdate(transaction);
transaction;
}
{
.canRemoveResource(resource, , );
}
{
resource == ? : (Boolean).readAction(() -> {
InternalContainerUtilResource.testRemoveResourceFromItems(, resource, resource.getQuantity(), filter);
testQuantityRemaining > ? : !exactAmount || testQuantityRemaining >= ;
});
}
ResourceTransaction {
.removeResource(resource, , , );
}
ResourceTransaction {
InternalContainerUtilResource.internal_removeResource(, resource, allOrNothing, exactAmount, filter);
.sendUpdate(transaction);
transaction;
}
{
.canRemoveResources(resources, , );
}
{
resources != && !resources.isEmpty() ? (Boolean).readAction(() -> {
(ResourceQuantity resource : resources) {
InternalContainerUtilResource.testRemoveResourceFromItems(, resource, resource.getQuantity(), filter);
(testQuantityRemaining > ) {
;
}
(exactAmount && testQuantityRemaining < ) {
;
}
}
;
}) : ;
}
ListTransaction<ResourceTransaction> {
.removeResources(resources, , , );
}
ListTransaction<ResourceTransaction> {
(resources != && !resources.isEmpty()) {
ListTransaction<ResourceTransaction> transaction = InternalContainerUtilResource.internal_removeResources(, resources, allOrNothing, exactAmount, filter);
.sendUpdate(transaction);
transaction;
} {
ListTransaction.<ResourceTransaction>getEmptyTransaction();
}
}
{
.canRemoveMaterial(material, , );
}
{
material == ? : (Boolean).readAction(() -> {
InternalContainerUtilMaterial.testRemoveMaterialFromItems(, material, material.getQuantity(), filter);
testQuantityRemaining > ? : !exactAmount || testQuantityRemaining >= ;
});
}
MaterialTransaction {
.removeMaterial(material, , , );
}
MaterialTransaction {
InternalContainerUtilMaterial.internal_removeMaterial(, material, allOrNothing, exactAmount, filter);
.sendUpdate(transaction);
transaction;
}
{
.canRemoveMaterials(materials, , );
}
{
materials != && !materials.isEmpty() ? (Boolean).readAction(() -> {
(MaterialQuantity material : materials) {
InternalContainerUtilMaterial.testRemoveMaterialFromItems(, material, material.getQuantity(), filter);
(testQuantityRemaining > ) {
;
}
(exactAmount && testQuantityRemaining < ) {
;
}
}
;
}) : ;
}
List<TestRemoveItemSlotResult> {
List<TestRemoveItemSlotResult> slotMaterials = <TestRemoveItemSlotResult>();
materials != && !materials.isEmpty() ? (List).readAction(() -> {
(MaterialQuantity material : materials) {
InternalContainerUtilMaterial.getTestRemoveMaterialFromItems(, material, material.getQuantity(), filter);
(testResult.quantityRemaining > ) {
slotMaterials.clear();
slotMaterials;
}
(exactAmount && testResult.quantityRemaining < ) {
slotMaterials.clear();
slotMaterials;
}
slotMaterials.add(testResult);
}
slotMaterials;
}) : slotMaterials;
}
ListTransaction<MaterialTransaction> {
.removeMaterials(materials, , , );
}
ListTransaction<MaterialTransaction> {
(materials != && !materials.isEmpty()) {
ListTransaction<MaterialTransaction> transaction = InternalContainerUtilMaterial.internal_removeMaterials(, materials, allOrNothing, exactAmount, filter);
.sendUpdate(transaction);
transaction;
} {
ListTransaction.<MaterialTransaction>getEmptyTransaction();
}
}
ListTransaction<MaterialSlotTransaction> {
.removeMaterialsOrdered(offset, materials, , , );
}
ListTransaction<MaterialSlotTransaction> {
.removeMaterialsOrdered((), materials, allOrNothing, exactAmount, filter);
}
ListTransaction<MaterialSlotTransaction> {
(materials != && !materials.isEmpty()) {
(offset + materials.size() > .getCapacity()) {
ListTransaction.<MaterialSlotTransaction>getEmptyTransaction();
} {
ListTransaction<MaterialSlotTransaction> transaction = InternalContainerUtilMaterial.internal_removeMaterialsOrdered(, offset, materials, allOrNothing, exactAmount, filter);
.sendUpdate(transaction);
transaction;
}
} {
ListTransaction.<MaterialSlotTransaction>getEmptyTransaction();
}
}
{
(Boolean).readAction(() -> {
( ; i < .getCapacity(); ++i) {
.internal_getSlot(i);
(itemStack != && !itemStack.isEmpty()) {
;
}
}
;
});
}
{
(Integer).readAction(() -> {
;
( ; i < .getCapacity(); ++i) {
.internal_getSlot(i);
(!ItemStack.isEmpty(itemStack) && itemPredicate.test(itemStack)) {
count += itemStack.getQuantity();
}
}
count;
});
}
{
(Boolean).readAction(() -> {
( ; i < .getCapacity(); ++i) {
.internal_getSlot(i);
(!ItemStack.isEmpty(checked) && itemStack.isStackableWith(checked)) {
;
}
}
;
});
}
{
( ; i < .getCapacity(); ++i) {
.getItemStack(i);
(!ItemStack.isEmpty(itemStack)) {
action.accept(i, itemStack);
}
}
}
<T> {
( ; i < .getCapacity(); ++i) {
.getItemStack(i);
(!ItemStack.isEmpty(itemStack)) {
consumer.accept(i, itemStack, meta);
}
}
}
List<ItemStack> {
List<ItemStack> items = <ItemStack>();
ListTransaction<SlotTransaction> transaction = (ListTransaction).writeAction(() -> {
List<SlotTransaction> transactions = <SlotTransaction>();
( ; i < .getCapacity(); ++i) {
(!.cantRemoveFromSlot(i)) {
.internal_removeSlot(i);
(!ItemStack.isEmpty(itemStack)) {
items.add(itemStack);
transactions.add( (, ActionType.REMOVE, i, itemStack, (ItemStack), itemStack, , , ));
}
}
}
(, transactions);
});
.sendUpdate(transaction);
items;
}
List<ItemStack> {
.dropAllItemStacks();
}
List<ItemStack> {
List<ItemStack> items = <ItemStack>();
ListTransaction<SlotTransaction> transaction = (ListTransaction).writeAction(() -> {
List<SlotTransaction> transactions = <SlotTransaction>();
( ; i < .getCapacity(); ++i) {
(!filter || !.cantDropFromSlot(i)) {
.internal_removeSlot(i);
(!ItemStack.isEmpty(itemStack)) {
items.add(itemStack);
transactions.add( (, ActionType.REMOVE, i, itemStack, (ItemStack), itemStack, , , ));
}
}
}
(, transactions);
});
.sendUpdate(transaction);
items;
}
ListTransaction<SlotTransaction> {
ListTransaction<SlotTransaction> transaction = .internal_sortItems(sort);
.sendUpdate(transaction);
transaction;
}
ListTransaction<SlotTransaction> {
(ListTransaction).writeAction(() -> {
ItemStack[] stacks = [.getCapacity()];
;
( ; i < stacks.length; ++i) {
(!.cantRemoveFromSlot(i)) {
.internal_getSlot(i);
(slot != ) {
slot.getItem();
item.getMaxStack();
slot.getQuantity();
(maxStack > ) {
( ; j < stackOffset && slotQuantity > ; ++j) {
stacks[j];
(slot.isStackableWith(stack)) {
stack.getQuantity();
(stackQuantity < maxStack) {
Math.min(slotQuantity, maxStack - stackQuantity);
slotQuantity -= adjust;
stacks[j] = stack.withQuantity(stackQuantity + adjust);
}
}
}
}
(slotQuantity > ) {
stacks[stackOffset++] = slotQuantity != slot.getQuantity() ? slot.withQuantity(slotQuantity) : slot;
}
}
}
}
Arrays.sort(stacks, sort.getComparator());
List<SlotTransaction> transactions = <SlotTransaction>(stacks.length);
stackOffset = ;
( ; i < stacks.length; ++i) {
(!.cantRemoveFromSlot(i)) {
.internal_getSlot(i);
stacks[stackOffset];
(!.cantAddToSlot(i, replacement, existing)) {
++stackOffset;
(existing != replacement) {
.internal_setSlot(i, replacement);
transactions.add( (, ActionType.REMOVE, i, existing, (ItemStack), replacement, , , ));
}
}
}
}
( stackOffset; i < stacks.length; ++i) {
(stacks[i] != ) {
();
}
}
(, transactions);
});
}
{
(transaction.succeeded()) {
(, transaction);
.externalChangeEventRegistry.dispatchFor((Object)).dispatch(event);
.internalChangeEventRegistry.dispatchFor((Object)).dispatch(event);
}
}
{
itemContainer == ;
}
{
Objects.requireNonNull(blockMigration);
.writeAction((_blockMigration) -> {
( ; i < .getCapacity(); ++i) {
.internal_getSlot(i);
(!ItemStack.isEmpty(slot)) {
slot.getItemId();
(String)_blockMigration.apply(slot.getItemId());
(!oldItemId.equals(newItemId)) {
.internal_setSlot(i, (newItemId, slot.getQuantity(), slot.getMetadata()));
}
}
}
;
}, blockMigration);
}
ItemResourceType {
ItemResourceType[] resourceTypes = item.getResourceTypes();
(resourceTypes == ) {
;
} {
(ItemResourceType resourceType : resourceTypes) {
(resourceId.equals(resourceType.id)) {
resourceType;
}
}
;
}
}
{
(quantity < ) {
( + quantity + );
}
}
{
(slot < ) {
( + slot + );
} (slot >= capacity) {
( + slot + + capacity);
}
}
<T > T {
from.forEach((slot, itemStack) -> {
(slot >= to.getCapacity()) {
(remainder != ) {
remainder.add(itemStack);
}
} (!ItemStack.isEmpty(itemStack)) {
to.setItemStackForSlot(slot, itemStack);
}
});
to;
}
<T > T {
(inputContainer == ) {
newContainerSupplier.apply(capacity);
} {
(T)(inputContainer.getCapacity() == capacity ? inputContainer : copy(inputContainer, newContainerSupplier.apply(capacity), remainder));
}
}
ItemContainer {
(ItemContainer)(capacity > ? (ItemContainer)supplier.apply(capacity) : EmptyItemContainer.INSTANCE);
}
{
}
<Void> {
String {
String.valueOf(.container);
+ var10000 + + String.valueOf(.transaction) + ;
}
}
}
com/hypixel/hytale/server/core/inventory/container/ItemContainerUtil.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.protocol.ItemArmorSlot;
import com.hypixel.hytale.server.core.inventory.container.filter.ArmorSlotAddFilter;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.NoDuplicateFilter;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
public class ItemContainerUtil {
public ItemContainerUtil() {
}
public static <T extends ItemContainer> T trySetArmorFilters(T container) {
if (container instanceof SimpleItemContainer itemContainer) {
ItemArmorSlot[] itemArmorSlots = ItemArmorSlot.VALUES;
for(short i = 0; i < itemContainer.getCapacity(); ++i) {
if (i < itemArmorSlots.length) {
if (i < 5) {
itemContainer.setSlotFilter(FilterActionType.ADD, i, new ArmorSlotAddFilter(itemArmorSlots[i]));
} else {
itemContainer.setSlotFilter(FilterActionType.ADD, i, new NoDuplicateFilter(itemContainer));
}
} else {
itemContainer.setSlotFilter(FilterActionType.ADD, i, SlotFilter.DENY);
}
}
}
return container;
}
<T > T {
(container SimpleItemContainer itemContainer) {
( ; i < itemContainer.getCapacity(); ++i) {
itemContainer.setSlotFilter(FilterActionType.ADD, i, filter);
}
}
container;
}
}
com/hypixel/hytale/server/core/inventory/container/ItemStackItemContainer.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.EmptyExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemStackContainerConfig;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.container.filter.TagFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
public class ItemStackItemContainer extends ItemContainer {
@Nonnull
public static KeyedCodec<BsonDocument> CONTAINER_CODEC;
@Nonnull
public static KeyedCodec<Short> CAPACITY_CODEC;
KeyedCodec<ItemStack[]> ITEMS_CODEC;
();
ItemContainer parentContainer;
itemStackSlot;
ItemStack originalItemStack;
capacity;
ItemStack[] items;
Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters = ();
FilterType globalFilter;
{
.globalFilter = FilterType.ALLOW_ALL;
.parentContainer = parentContainer;
.itemStackSlot = itemStackSlot;
.originalItemStack = originalItemStack;
.capacity = capacity;
.items = items;
}
ItemContainer {
.parentContainer;
}
{
.itemStackSlot;
}
ItemStack {
.originalItemStack;
}
{
.parentContainer.getItemStack(.itemStackSlot);
ItemStack.isEmpty(itemStack) ? : ItemStack.isSameItemType(itemStack, .originalItemStack);
}
{
.capacity;
}
{
.globalFilter = globalFilter;
}
{
validateSlotIndex(slot, .getCapacity());
(filter != ) {
((Int2ObjectConcurrentHashMap).slotFilters.computeIfAbsent(actionType, (k) -> ())).put(slot, filter);
} {
.slotFilters.computeIfPresent(actionType, (k, map) -> {
map.remove(slot);
map.isEmpty() ? : map;
});
}
}
ItemContainer {
();
}
<V> V {
.lock.readLock().lock();
Object var2;
{
var2 = action.get();
} {
.lock.readLock().unlock();
}
(V)var2;
}
<X, V> V {
.lock.readLock().lock();
Object var3;
{
var3 = action.apply(x);
} {
.lock.readLock().unlock();
}
(V)var3;
}
<V> V {
.lock.writeLock().lock();
Object var2;
{
var2 = action.get();
} {
.lock.writeLock().unlock();
}
(V)var2;
}
<X, V> V {
.lock.writeLock().lock();
Object var3;
{
var3 = action.apply(x);
} {
.lock.writeLock().unlock();
}
(V)var3;
}
{
.lock.readLock().lock();
i;
{
(.items != ) {
( ; i < .items.length; ++i) {
(!ItemStack.isEmpty(.items[i])) {
;
var2;
}
}
i = ;
i;
}
i = ;
} {
.lock.readLock().unlock();
}
i;
}
ClearTransaction {
(.items == ) {
(, (), ItemStack.EMPTY_ARRAY);
} {
ItemStack[] oldItems = .items;
.items = [oldItems.length];
writeToItemStack(.parentContainer, .itemStackSlot, .originalItemStack, .items);
(, (), oldItems);
}
}
ItemStack {
.items != ? .items[slot] : ;
}
ItemStack {
(.items == ) {
;
} (ItemStack.isEmpty(itemStack)) {
.internal_removeSlot(slot);
} {
.items[slot];
.items[slot] = itemStack;
writeToItemStack(.parentContainer, .itemStackSlot, .originalItemStack, .items);
old;
}
}
ItemStack {
(.items == ) {
;
} {
.items[slot];
.items[slot] = ;
writeToItemStack(.parentContainer, .itemStackSlot, .originalItemStack, .items);
old;
}
}
{
!.globalFilter.allowInput() ? : .testFilter(FilterActionType.ADD, slot, itemStack);
}
{
!.globalFilter.allowOutput() ? : .testFilter(FilterActionType.REMOVE, slot, (ItemStack));
}
{
.testFilter(FilterActionType.DROP, slot, (ItemStack));
}
{
fromContainer == .parentContainer && slotFrom == .itemStackSlot;
}
{
Int2ObjectConcurrentHashMap<SlotFilter> map = (Int2ObjectConcurrentHashMap).slotFilters.get(actionType);
(map == ) {
;
} {
map.get(slot);
(filter == ) {
;
} {
!filter.test(actionType, , slot, itemStack);
}
}
}
ItemStack {
validateSlotIndex(slot, .getCapacity());
.lock.readLock().lock();
ItemStack var2;
{
var2 = .internal_getSlot(slot);
} {
.lock.readLock().unlock();
}
var2;
}
{
(ItemStack.isEmpty(originalItemStack)) {
();
} {
itemContainer.getItemStack(slot);
(!ItemStack.isSameItemType(itemStack, originalItemStack)) {
();
} {
itemStack.getMetadata();
CONTAINER_CODEC.getOrNull(newMetadata, EmptyExtraInfo.EMPTY);
(containerDocument == ) {
();
} {
ITEMS_CODEC.put(containerDocument, items, EmptyExtraInfo.EMPTY);
itemContainer.setItemStackForSlot(slot, itemStack.withMetadata(newMetadata));
}
}
}
}
ItemStackItemContainer {
itemContainer.getItemStack(slot);
(ItemStack.isEmpty(itemStack)) {
;
} {
(BsonDocument)itemStack.getFromMetadataOrNull(CONTAINER_CODEC);
(containerDocument == ) {
;
} {
CAPACITY_CODEC.getOrNull(containerDocument, EmptyExtraInfo.EMPTY);
(capacity != && capacity > ) {
ItemStack[] items = ITEMS_CODEC.getOrNull(containerDocument, EmptyExtraInfo.EMPTY);
(items == ) {
items = [capacity];
}
(itemContainer, slot, itemStack, capacity, items);
} {
;
}
}
}
}
ItemStackItemContainer {
(capacity <= ) {
();
} {
itemContainer.getItemStack(slot);
(ItemStack.isEmpty(itemStack)) {
();
} {
getContainer(itemContainer, slot);
(itemStackItemContainer != && itemStackItemContainer.getCapacity() != ) {
();
} {
itemStack.getMetadata();
(newMetadata == ) {
newMetadata = ();
}
CONTAINER_CODEC.getOrNull(newMetadata, EmptyExtraInfo.EMPTY);
(containerDocument == ) {
containerDocument = ();
CONTAINER_CODEC.put(newMetadata, containerDocument, EmptyExtraInfo.EMPTY);
}
CAPACITY_CODEC.put(containerDocument, capacity, EmptyExtraInfo.EMPTY);
itemContainer.setItemStackForSlot(slot, itemStack.withMetadata(newMetadata));
(itemContainer, slot, itemStack, capacity, [capacity]);
}
}
}
}
ItemStackItemContainer {
(capacity <= ) {
();
} {
itemContainer.getItemStack(slot);
(ItemStack.isEmpty(itemStack)) {
;
} {
getContainer(itemContainer, slot);
(itemStackItemContainer != && itemStackItemContainer.getCapacity() != ) {
itemStackItemContainer;
} {
itemStack.getMetadata();
(newMetadata == ) {
newMetadata = ();
}
CONTAINER_CODEC.getOrNull(newMetadata, EmptyExtraInfo.EMPTY);
(containerDocument == ) {
containerDocument = ();
CONTAINER_CODEC.put(newMetadata, containerDocument, EmptyExtraInfo.EMPTY);
}
CAPACITY_CODEC.put(containerDocument, capacity, EmptyExtraInfo.EMPTY);
itemContainer.setItemStackForSlot(slot, itemStack.withMetadata(newMetadata));
(itemContainer, slot, itemStack, capacity, [capacity]);
}
}
}
}
ItemStackItemContainer {
ensureContainer(itemContainer, slot, config.getCapacity());
(itemStackItemContainer == ) {
;
} {
itemStackItemContainer.setGlobalFilter(config.getGlobalFilter());
config.getTagIndex();
(tagIndex != -) {
( ; i < itemStackItemContainer.getCapacity(); ++i) {
itemStackItemContainer.setSlotFilter(FilterActionType.ADD, i, (tagIndex));
}
}
itemStackItemContainer;
}
}
{
CONTAINER_CODEC = <BsonDocument>(, Codec.BSON_DOCUMENT);
CAPACITY_CODEC = <Short>(, Codec.SHORT);
ITEMS_CODEC = <ItemStack[]>(, (ItemStack.CODEC, (x$) -> [x$]));
}
}
com/hypixel/hytale/server/core/inventory/container/SimpleItemContainer.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.Short2ObjectMapCodec;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.entity.ItemUtils;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterActionType;
import com.hypixel.hytale.server.core.inventory.container.filter.FilterType;
import com.hypixel.hytale.server.core.inventory.container.filter.SlotFilter;
import com.hypixel.hytale.server.core.inventory.transaction.ClearTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackSlotTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
import com.hypixel.hytale.server.core.inventory.transaction.ListTransaction;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.function.Function;
java.util.function.Supplier;
javax.annotation.Nonnull;
javax.annotation.Nullable;
{
BuilderCodec<SimpleItemContainer> CODEC;
capacity;
();
Short2ObjectMap<ItemStack> items;
Map<FilterActionType, Int2ObjectConcurrentHashMap<SlotFilter>> slotFilters = ();
FilterType globalFilter;
{
.globalFilter = FilterType.ALLOW_ALL;
}
{
.globalFilter = FilterType.ALLOW_ALL;
(capacity <= ) {
( + capacity + );
} {
.capacity = capacity;
.items = <ItemStack>(capacity);
}
}
{
.globalFilter = FilterType.ALLOW_ALL;
.capacity = other.capacity;
other.lock.readLock().lock();
{
.items = <ItemStack>(other.items);
} {
other.lock.readLock().unlock();
}
.slotFilters.putAll(other.slotFilters);
.globalFilter = other.globalFilter;
}
<V> V {
.lock.readLock().lock();
Object var2;
{
var2 = action.get();
} {
.lock.readLock().unlock();
}
(V)var2;
}
<X, V> V {
.lock.readLock().lock();
Object var3;
{
var3 = action.apply(x);
} {
.lock.readLock().unlock();
}
(V)var3;
}
<V> V {
.lock.writeLock().lock();
Object var2;
{
var2 = action.get();
} {
.lock.writeLock().unlock();
}
(V)var2;
}
<X, V> V {
.lock.writeLock().lock();
Object var3;
{
var3 = action.apply(x);
} {
.lock.writeLock().unlock();
}
(V)var3;
}
ItemStack {
(ItemStack).items.get(slot);
}
ItemStack {
ItemStack.isEmpty(itemStack) ? .internal_removeSlot(slot) : (ItemStack).items.put(slot, itemStack);
}
ItemStack {
(ItemStack).items.remove(slot);
}
{
!.globalFilter.allowInput() ? : .testFilter(FilterActionType.ADD, slot, itemStack);
}
{
!.globalFilter.allowOutput() ? : .testFilter(FilterActionType.REMOVE, slot, (ItemStack));
}
{
.testFilter(FilterActionType.DROP, slot, (ItemStack));
}
{
;
}
{
Int2ObjectConcurrentHashMap<SlotFilter> map = (Int2ObjectConcurrentHashMap).slotFilters.get(actionType);
(map == ) {
;
} {
map.get(slot);
(filter == ) {
;
} {
!filter.test(actionType, , slot, itemStack);
}
}
}
{
.capacity;
}
ClearTransaction {
ItemStack[] itemStacks = [.getCapacity()];
( ; i < itemStacks.length; ++i) {
itemStacks[i] = (ItemStack).items.get(i);
}
.items.clear();
(, (), itemStacks);
}
SimpleItemContainer {
();
}
{
.lock.readLock().lock();
var1;
{
(!.items.isEmpty()) {
.isEmpty();
}
var1 = ;
} {
.lock.readLock().unlock();
}
var1;
}
{
.globalFilter = (FilterType)Objects.requireNonNull(globalFilter);
}
{
validateSlotIndex(slot, .getCapacity());
(filter != ) {
((Int2ObjectConcurrentHashMap).slotFilters.computeIfAbsent(actionType, (k) -> ())).put(slot, filter);
} {
.slotFilters.computeIfPresent(actionType, (k, map) -> {
map.remove(slot);
map.isEmpty() ? : map;
});
}
}
ItemStack {
validateSlotIndex(slot, .getCapacity());
.lock.readLock().lock();
ItemStack var2;
{
var2 = .internal_getSlot(slot);
} {
.lock.readLock().unlock();
}
var2;
}
{
( == o) {
;
} (o SimpleItemContainer) {
(SimpleItemContainer)o;
(.capacity != that.capacity) {
;
} {
.lock.readLock().lock();
var3;
{
var3 = .items.equals(that.items);
} {
.lock.readLock().unlock();
}
var3;
}
} {
;
}
}
{
.lock.readLock().lock();
result;
{
result = .items.hashCode();
} {
.lock.readLock().unlock();
}
result = * result + .capacity;
result;
}
ItemContainer {
ItemContainer.getNewContainer(capacity, SimpleItemContainer::);
}
{
itemContainer.addItemStack(itemStack);
transaction.getRemainder();
(!ItemStack.isEmpty(remainder)) {
ItemUtils.dropItem(ref, remainder, store);
;
} {
;
}
}
{
itemContainer.addItemStackToSlot(slot, itemStack);
transaction.getRemainder();
!ItemStack.isEmpty(remainder) ? addOrDropItemStack(store, ref, itemContainer, itemStack) : ;
}
{
ListTransaction<ItemStackTransaction> transaction = itemContainer.addItemStacks(itemStacks);
;
(ItemStackTransaction stackTransaction : transaction.getList()) {
stackTransaction.getRemainder();
(!ItemStack.isEmpty(remainder)) {
ItemUtils.dropItem(ref, remainder, store);
droppedItem = ;
}
}
droppedItem;
}
{
ListTransaction<ItemStackSlotTransaction> transaction = itemContainer.addItemStacksOrdered(itemStacks);
List<ItemStack> remainderItemStacks = ;
(ItemStackSlotTransaction stackTransaction : transaction.getList()) {
stackTransaction.getRemainder();
(!ItemStack.isEmpty(remainder)) {
(remainderItemStacks == ) {
remainderItemStacks = <ItemStack>();
}
remainderItemStacks.add(remainder);
}
}
addOrDropItemStacks(store, ref, itemContainer, remainderItemStacks);
}
{
CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SimpleItemContainer.class, SimpleItemContainer::).append( (, Codec.SHORT), (o, i) -> o.capacity = i, (o) -> o.capacity).addValidator(Validators.greaterThanOrEqual(Short.valueOf(()))).add()).append( (, (ItemStack.CODEC, Short2ObjectOpenHashMap::, )), (o, i) -> o.items = i, (o) -> o.items).add()).afterDecode((i) -> {
(i.items == ) {
i.items = <ItemStack>(i.capacity);
}
i.items.short2ObjectEntrySet().removeIf((e) -> e.getShortKey() < || e.getShortKey() >= i.capacity || ItemStack.isEmpty((ItemStack)e.getValue()));
})).build();
}
}
com/hypixel/hytale/server/core/inventory/container/SlotReplacementFunction.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.server.core.inventory.ItemStack;
public interface SlotReplacementFunction {
ItemStack replace(short var1, ItemStack var2);
}
com/hypixel/hytale/server/core/inventory/container/SortType.java
package com.hypixel.hytale.server.core.inventory.container;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.item.config.ItemQuality;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import java.util.Comparator;
import java.util.function.Function;
import javax.annotation.Nonnull;
public enum SortType {
NAME((i) -> i.getItem().getTranslationKey(), false, false),
TYPE((i) -> SortType.Dummy.ItemType.getType(i.getItem()), false, true),
RARITY((i) -> {
int qualityIndex = i.getItem().getQualityIndex();
ItemQuality itemQuality = (ItemQuality)ItemQuality.getAssetMap().getAsset(qualityIndex);
int itemQualityValue = (itemQuality != null ? itemQuality : ItemQuality.DEFAULT_ITEM_QUALITY).getQualityValue();
return itemQualityValue;
}, true, true);
@Nonnull
public static SortType[] VALUES = values();
@Nonnull
private final Comparator<ItemStack> comparator;
private <U extends Comparable<U>> SortType(@Nonnull final Function<ItemStack, U> key, final boolean inverted, thenName) {
Comparator<ItemStack> comp = comparatorFor(key);
(inverted) {
comp = comp.reversed();
}
(thenName) {
comp = comp.thenComparing(comparatorFor((i) -> i.getItem().getTranslationKey()));
}
.comparator = Comparator.nullsLast(comp);
}
Comparator<ItemStack> {
.comparator;
}
com.hypixel.hytale.protocol.SortType {
com.hypixel.hytale.protocol.SortType var10000;
(.ordinal()) {
-> var10000 = com.hypixel.hytale.protocol.SortType.Name;
-> var10000 = com.hypixel.hytale.protocol.SortType.Type;
-> var10000 = com.hypixel.hytale.protocol.SortType.Rarity;
-> ((String), (Throwable));
}
var10000;
}
SortType {
SortType var10000;
(sortType_) {
Type -> var10000 = TYPE;
Rarity -> var10000 = RARITY;
Name -> var10000 = NAME;
-> ((String), (Throwable));
}
var10000;
}
<U <U>> Comparator<ItemStack> {
(a, b) -> {
(U)((Comparable)key.apply(a));
(U)((Comparable)key.apply(b));
(akey == bkey) {
;
} (akey == ) {
;
} {
bkey == ? - : akey.compareTo(bkey);
}
};
}
{
Dummy() {
}
{
WEAPON,
ARMOR,
TOOL,
ITEM,
SPECIAL;
{
}
ItemType {
(item.getWeapon() != ) {
WEAPON;
} (item.getArmor() != ) {
ARMOR;
} (item.getTool() != ) {
TOOL;
} {
item.getBuilderToolData() != ? SPECIAL : ITEM;
}
}
}
}
}
com/hypixel/hytale/server/core/inventory/container/TestRemoveItemSlotResult.java
package com.hypixel.hytale.server.core.inventory.container;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import java.util.Map;
import java.util.Set;
public class TestRemoveItemSlotResult {
Map<Short, Integer> picked = new Object2IntOpenHashMap();
int quantityRemaining;
public TestRemoveItemSlotResult(int testQuantityRemaining) {
this.quantityRemaining = testQuantityRemaining;
}
public boolean hasResult() {
return !this.picked.isEmpty();
}
public Set<Short> getPickedSlots() {
return this.picked.keySet();
}
}
com/hypixel/hytale/server/core/inventory/container/filter/ArmorSlotAddFilter.java
package com.hypixel.hytale.server.core.inventory.container.filter;
import com.hypixel.hytale.protocol.ItemArmorSlot;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import javax.annotation.Nullable;
public class ArmorSlotAddFilter implements ItemSlotFilter {
private final ItemArmorSlot itemArmorSlot;
public ArmorSlotAddFilter(ItemArmorSlot itemArmorSlot) {
this.itemArmorSlot = itemArmorSlot;
}
public boolean test(@Nullable Item item) {
return item == null || item.getArmor() != null && item.getArmor().getArmorSlot() == this.itemArmorSlot;
}
public ItemArmorSlot getItemArmorSlot() {
return this.itemArmorSlot;
}
}
com/hypixel/hytale/server/core/inventory/container/filter/FilterActionType.java
package com.hypixel.hytale.server.core.inventory.container.filter;
public enum FilterActionType {
ADD,
REMOVE,
DROP;
private FilterActionType() {
}
}
com/hypixel/hytale/server/core/inventory/container/filter/FilterType.java
package com.hypixel.hytale.server.core.inventory.container.filter;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
public enum FilterType {
ALLOW_INPUT_ONLY(true, false),
ALLOW_OUTPUT_ONLY(false, true),
ALLOW_ALL(true, true),
DENY_ALL(false, false);
public static final Codec<FilterType> CODEC = new EnumCodec<FilterType>(FilterType.class);
private final boolean input;
private final boolean output;
private FilterType(boolean input, boolean output) {
this.input = input;
this.output = output;
}
public boolean allowInput() {
return this.input;
}
public boolean allowOutput() {
return this.output;
}
}
com/hypixel/hytale/server/core/inventory/container/filter/ItemSlotFilter.java
package com.hypixel.hytale.server.core.inventory.container.filter;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public interface ItemSlotFilter extends SlotFilter {
default boolean test(@Nonnull FilterActionType actionType, @Nonnull ItemContainer container, short slot, @Nullable ItemStack itemStack) {
boolean var10000;
switch (actionType) {
case ADD:
var10000 = this.test(itemStack != null ? itemStack.getItem() : null);
break;
case REMOVE:
case DROP:
itemStack = container.getItemStack(slot);
var10000 = this.test(itemStack != null ? itemStack.getItem() : null);
break;
default:
throw new MatchException((String)null, (Throwable)null);
}
return var10000;
}
boolean test;
}
com/hypixel/hytale/server/core/inventory/container/filter/NoDuplicateFilter.java
package com.hypixel.hytale.server.core.inventory.container.filter;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.SimpleItemContainer;
import javax.annotation.Nullable;
public class NoDuplicateFilter implements ItemSlotFilter {
private final SimpleItemContainer container;
public NoDuplicateFilter(SimpleItemContainer container) {
this.container = container;
}
public boolean test(@Nullable Item item) {
if (item != null && item.getId() != null) {
for(short i = 0; i < this.container.getCapacity(); ++i) {
ItemStack itemStack = this.container.getItemStack(i);
if (itemStack != null && itemStack.getItemId().equals(item.getId())) {
return false;
}
}
return true;
} else {
return false;
}
}
}
com/hypixel/hytale/server/core/inventory/container/filter/ResourceFilter.java
package com.hypixel.hytale.server.core.inventory.container.filter;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import javax.annotation.Nullable;
public class ResourceFilter implements ItemSlotFilter {
private final ResourceQuantity resource;
public ResourceFilter(ResourceQuantity resource) {
this.resource = resource;
}
public boolean test(@Nullable Item item) {
return item == null || this.resource.getResourceType(item) != null;
}
public ResourceQuantity getResource() {
return this.resource;
}
}
com/hypixel/hytale/server/core/inventory/container/filter/SlotFilter.java
package com.hypixel.hytale.server.core.inventory.container.filter;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nullable;
public interface SlotFilter {
SlotFilter ALLOW = (actionType, container, slot, itemStack) -> true;
SlotFilter DENY = (actionType, container, slot, itemStack) -> false;
boolean test(FilterActionType var1, ItemContainer var2, short var3, @Nullable ItemStack var4);
}
com/hypixel/hytale/server/core/inventory/container/filter/TagFilter.java
package com.hypixel.hytale.server.core.inventory.container.filter;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import javax.annotation.Nullable;
public class TagFilter implements ItemSlotFilter {
private final int tagIndex;
public TagFilter(int tagIndex) {
this.tagIndex = tagIndex;
}
public boolean test(@Nullable Item item) {
return item == null || item.getData().getExpandedTagIndexes().contains(this.tagIndex);
}
}
com/hypixel/hytale/server/core/inventory/transaction/ActionType.java
package com.hypixel.hytale.server.core.inventory.transaction;
public enum ActionType {
SET(true, false, true),
ADD(true, false, false),
REMOVE(false, true, false),
REPLACE(true, true, false);
private final boolean add;
private final boolean remove;
private final boolean destroy;
private ActionType(boolean add, boolean remove, boolean destroy) {
this.add = add;
this.remove = remove;
this.destroy = destroy;
}
public boolean isAdd() {
return this.add;
}
public boolean isRemove() {
return this.remove;
}
public boolean isDestroy() {
.destroy;
}
}
com/hypixel/hytale/server/core/inventory/transaction/ClearTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ClearTransaction implements Transaction {
public static final ClearTransaction EMPTY;
private final boolean succeeded;
private final short start;
@Nonnull
private final ItemStack[] items;
public ClearTransaction(boolean succeeded, short start, @Nonnull ItemStack[] items) {
this.succeeded = succeeded;
this.start = start;
this.items = items;
}
public boolean succeeded() {
return this.succeeded;
}
public boolean wasSlotModified(short slot) {
if (!this.succeeded) {
;
} {
slot = ()(slot - .start);
slot >= && slot < .items.length && .items[slot] != && !.items[slot].isEmpty();
}
}
ItemStack[] getItems() {
.items;
}
ClearTransaction {
()(start + .start);
(.succeeded, newStart, .items);
}
ClearTransaction {
()(.start - start);
container.getCapacity();
(newStart < ) {
-newStart;
.items.length + newStart > capacity ? (.succeeded, (), (ItemStack[])Arrays.copyOfRange(.items, from, from + capacity)) : (.succeeded, (), (ItemStack[])Arrays.copyOfRange(.items, from, .items.length));
} {
.items.length > capacity ? (.succeeded, newStart, (ItemStack[])Arrays.copyOf(.items, capacity)) : (.succeeded, newStart, .items);
}
}
String {
+ Arrays.toString(.items) + ;
}
{
EMPTY = (, (), ItemStack.EMPTY_ARRAY);
}
}
com/hypixel/hytale/server/core/inventory/transaction/ItemStackSlotTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ItemStackSlotTransaction extends SlotTransaction {
private final boolean addToExistingSlot;
@Nullable
private final ItemStack query;
@Nullable
private final ItemStack remainder;
public ItemStackSlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot, @Nullable ItemStack slotBefore, @Nullable ItemStack slotAfter, @Nullable ItemStack output, boolean allOrNothing, boolean exactAmount, boolean filter, boolean addToExistingSlot, @Nullable ItemStack query, @Nullable ItemStack remainder) {
super(succeeded, action, slot, slotBefore, slotAfter, output, allOrNothing, exactAmount, filter);
this.addToExistingSlot = addToExistingSlot;
this.query = query;
this.remainder = remainder;
}
public boolean isAddToExistingSlot {
.addToExistingSlot;
}
ItemStack {
.query;
}
ItemStack {
.remainder;
}
ItemStackSlotTransaction {
()(start + .getSlot());
(.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .addToExistingSlot, .query, .remainder);
}
ItemStackSlotTransaction {
()(.getSlot() - start);
newSlot >= && newSlot < container.getCapacity() ? (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .addToExistingSlot, .query, .remainder) : ;
}
String {
.addToExistingSlot;
+ var10000 + + String.valueOf(.query) + + String.valueOf(.remainder) + + .toString();
}
}
com/hypixel/hytale/server/core/inventory/transaction/ItemStackTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ItemStackTransaction implements Transaction {
public static final ItemStackTransaction FAILED_ADD;
private final boolean succeeded;
@Nullable
private final ActionType action;
@Nullable
private final ItemStack query;
@Nullable
private final ItemStack remainder;
private final boolean allOrNothing;
private final boolean filter;
@Nonnull
private final List<ItemStackSlotTransaction> slotTransactions;
public ItemStackTransaction(boolean succeeded, @Nullable ActionType action, @Nullable ItemStack query, ItemStack remainder, allOrNothing, filter, List<ItemStackSlotTransaction> slotTransactions) {
.succeeded = succeeded;
.action = action;
.query = query;
.remainder = remainder;
.allOrNothing = allOrNothing;
.filter = filter;
.slotTransactions = slotTransactions;
}
{
.succeeded;
}
{
(!.succeeded) {
;
} {
(ItemStackSlotTransaction t : .slotTransactions) {
(t.succeeded() && t.wasSlotModified(slot)) {
;
}
}
;
}
}
ActionType {
.action;
}
ItemStack {
.query;
}
ItemStack {
.remainder;
}
{
.allOrNothing;
}
{
.filter;
}
List<ItemStackSlotTransaction> {
.slotTransactions;
}
ItemStackTransaction {
List<ItemStackSlotTransaction> slotTransactions = (List).slotTransactions.stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
(.succeeded, .action, .query, .remainder, .allOrNothing, .filter, slotTransactions);
}
ItemStackTransaction {
List<ItemStackSlotTransaction> slotTransactions = (List).slotTransactions.stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
(slotTransactions.isEmpty()) {
;
} {
;
(ItemStackSlotTransaction transaction : slotTransactions) {
(transaction.succeeded()) {
succeeded = ;
;
}
}
(succeeded, .action, .query, .remainder, .allOrNothing, .filter, slotTransactions);
}
}
String {
.succeeded;
+ var10000 + + String.valueOf(.action) + + String.valueOf(.query) + + String.valueOf(.remainder) + + .allOrNothing + + .filter + + String.valueOf(.slotTransactions) + ;
}
{
FAILED_ADD = (, ActionType.ADD, (ItemStack), (ItemStack), , , Collections.emptyList());
}
}
com/hypixel/hytale/server/core/inventory/transaction/ListTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ListTransaction<T extends Transaction> implements Transaction {
public static final ListTransaction<?> EMPTY_SUCCESSFUL_TRANSACTION = new ListTransaction(true);
public static final ListTransaction<?> EMPTY_FAILED_TRANSACTION = new ListTransaction(false);
private final boolean succeeded;
@Nonnull
private final List<T> list;
public static <T extends Transaction> ListTransaction<T> getEmptyTransaction(boolean succeeded) {
return succeeded ? EMPTY_SUCCESSFUL_TRANSACTION : EMPTY_FAILED_TRANSACTION;
}
private ListTransaction( succeeded) {
.succeeded = succeeded;
.list = Collections.emptyList();
}
{
.succeeded = succeeded;
.list = Collections.unmodifiableList(list);
}
{
.succeeded;
}
{
(!.succeeded) {
;
} {
(T t : .list) {
(t.succeeded() && t.wasSlotModified(slot)) {
;
}
}
;
}
}
List<T> {
.list;
}
{
.list.size();
}
ListTransaction<T> {
List<T> list = (List).list.stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
<T>(.succeeded, list);
}
ListTransaction<T> {
List<T> list = (List).list.stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
(list.isEmpty()) {
;
} {
;
(T transaction : list) {
(transaction.succeeded()) {
succeeded = ;
;
}
}
<T>(succeeded, list);
}
}
String {
.succeeded;
+ var10000 + + String.valueOf(.list) + ;
}
}
com/hypixel/hytale/server/core/inventory/transaction/MaterialSlotTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class MaterialSlotTransaction extends SlotTransaction {
@Nonnull
private final MaterialQuantity query;
private final int remainder;
@Nonnull
private final SlotTransaction transaction;
public MaterialSlotTransaction(@Nonnull MaterialQuantity query, int remainder, @Nonnull SlotTransaction transaction) {
super(transaction.succeeded(), transaction.getAction(), transaction.getSlot(), transaction.getSlotBefore(), transaction.getSlotAfter(), transaction.getOutput(), transaction.isAllOrNothing(), transaction.isExactAmount(), transaction.isFilter());
this.query = query;
this.remainder = remainder;
this.transaction = transaction;
}
@Nonnull
public MaterialQuantity getQuery() {
return this.query;
}
public int getRemainder() {
return .remainder;
}
SlotTransaction {
.transaction;
}
MaterialSlotTransaction {
(.query, .remainder, .transaction.toParent(parent, start, container));
}
MaterialSlotTransaction {
.transaction.fromParent(parent, start, container);
newTransaction == ? : (.query, .remainder, newTransaction);
}
String {
String.valueOf(.query);
+ var10000 + + .remainder + + String.valueOf(.transaction) + + .toString();
}
}
com/hypixel/hytale/server/core/inventory/transaction/MaterialTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.MaterialQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class MaterialTransaction extends ListTransaction<MaterialSlotTransaction> {
@Nonnull
private final ActionType action;
@Nonnull
private final MaterialQuantity material;
private final int remainder;
private final boolean allOrNothing;
private final boolean exactAmount;
private final boolean filter;
public MaterialTransaction(boolean succeeded, @Nonnull ActionType action, @Nonnull MaterialQuantity material, int remainder, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull List<MaterialSlotTransaction> slotTransactions) {
super(succeeded, slotTransactions);
.action = action;
.material = material;
.remainder = remainder;
.allOrNothing = allOrNothing;
.exactAmount = exactAmount;
.filter = filter;
}
ActionType {
.action;
}
MaterialQuantity {
.material;
}
{
.remainder;
}
{
.allOrNothing;
}
{
.exactAmount;
}
{
.filter;
}
MaterialTransaction {
List<MaterialSlotTransaction> slotTransactions = (List).getList().stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
(.succeeded(), .action, .material, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
}
MaterialTransaction {
List<MaterialSlotTransaction> slotTransactions = (List).getList().stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
(slotTransactions.isEmpty()) {
;
} {
;
(MaterialSlotTransaction transaction : slotTransactions) {
(transaction.succeeded()) {
succeeded = ;
;
}
}
(succeeded, .action, .material, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
}
}
String {
String.valueOf(.action);
+ var10000 + + String.valueOf(.material) + + .remainder + + .allOrNothing + + .exactAmount + + .filter + + .toString();
}
}
com/hypixel/hytale/server/core/inventory/transaction/MoveTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class MoveTransaction<T extends Transaction> implements Transaction {
private final boolean succeeded;
@Nonnull
private final SlotTransaction removeTransaction;
@Nonnull
private final MoveType moveType;
@Nonnull
private final ItemContainer otherContainer;
private final T addTransaction;
public MoveTransaction(boolean succeeded, @Nonnull SlotTransaction removeTransaction, @Nonnull MoveType moveType, @Nonnull ItemContainer otherContainer, T addTransaction) {
this.succeeded = succeeded;
this.removeTransaction = removeTransaction;
this.moveType = moveType;
this.otherContainer = otherContainer;
this.addTransaction = addTransaction;
}
public boolean succeeded() {
return this.succeeded;
}
SlotTransaction {
.removeTransaction;
}
MoveType {
.moveType;
}
ItemContainer {
.otherContainer;
}
T {
.addTransaction;
}
MoveTransaction<T> {
<T>(.succeeded(), .removeTransaction, MoveType.MOVE_TO_SELF, itemContainer, .addTransaction);
}
{
(!.succeeded) {
;
} {
.addTransaction.succeeded() && .addTransaction.wasSlotModified(slot) || .removeTransaction.succeeded() && .removeTransaction.wasSlotModified(slot);
}
}
MoveTransaction<T> {
.getMoveType();
MoveTransaction var10000;
(moveType) {
MOVE_TO_SELF -> var10000 = (.succeeded(), .removeTransaction, moveType, .getOtherContainer(), .addTransaction.toParent(parent, start, container));
MOVE_FROM_SELF -> var10000 = (.succeeded(), .removeTransaction.toParent(parent, start, container), moveType, .getOtherContainer(), .addTransaction);
-> ((String), (Throwable));
}
var10000;
}
MoveTransaction<T> {
.getMoveType();
(moveType) {
MOVE_TO_SELF:
.addTransaction.fromParent(parent, start, container);
(newAddTransaction == ) {
;
}
<T>(.succeeded(), .getRemoveTransaction(), .getMoveType(), .getOtherContainer(), newAddTransaction);
MOVE_FROM_SELF:
.getRemoveTransaction().fromParent(parent, start, container);
(newRemoveTransaction == ) {
;
}
<T>(.succeeded(), newRemoveTransaction, .getMoveType(), .getOtherContainer(), .addTransaction);
:
( + String.valueOf(moveType));
}
}
String {
.succeeded;
+ var10000 + + String.valueOf(.removeTransaction) + + String.valueOf(.moveType) + + String.valueOf(.otherContainer) + + String.valueOf(.addTransaction) + ;
}
}
com/hypixel/hytale/server/core/inventory/transaction/MoveType.java
package com.hypixel.hytale.server.core.inventory.transaction;
public enum MoveType {
MOVE_TO_SELF,
MOVE_FROM_SELF;
private MoveType() {
}
}
com/hypixel/hytale/server/core/inventory/transaction/ResourceSlotTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ResourceSlotTransaction extends SlotTransaction {
@Nonnull
private final ResourceQuantity query;
private final int remainder;
private final int consumed;
public ResourceSlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot, @Nullable ItemStack slotBefore, @Nullable ItemStack slotAfter, @Nullable ItemStack output, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull ResourceQuantity query, int remainder, int consumed) {
super(succeeded, action, slot, slotBefore, slotAfter, output, allOrNothing, exactAmount, filter);
this.query = query;
this.remainder = remainder;
this.consumed = consumed;
}
@Nonnull
public ResourceQuantity getQuery {
.query;
}
{
.remainder;
}
{
.consumed;
}
ResourceSlotTransaction {
()(start + .getSlot());
(.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder, .consumed);
}
ResourceSlotTransaction {
()(.getSlot() - start);
newSlot >= && newSlot < container.getCapacity() ? (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder, .consumed) : ;
}
String {
String.valueOf(.query);
+ var10000 + + .remainder + + .consumed + + .toString();
}
}
com/hypixel/hytale/server/core/inventory/transaction/ResourceTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.ResourceQuantity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ResourceTransaction extends ListTransaction<ResourceSlotTransaction> {
@Nonnull
private final ActionType action;
@Nonnull
private final ResourceQuantity resource;
private final int remainder;
private final int consumed;
private final boolean allOrNothing;
private final boolean exactAmount;
private final boolean filter;
public ResourceTransaction(boolean succeeded, @Nonnull ActionType action, @Nonnull ResourceQuantity resource, int remainder, int consumed, boolean allOrNothing, boolean exactAmount, boolean filter, List<ResourceSlotTransaction> slotTransactions) {
(succeeded, slotTransactions);
.action = action;
.resource = resource;
.remainder = remainder;
.consumed = consumed;
.allOrNothing = allOrNothing;
.exactAmount = exactAmount;
.filter = filter;
}
ActionType {
.action;
}
ResourceQuantity {
.resource;
}
{
.remainder;
}
{
.consumed;
}
{
.allOrNothing;
}
{
.exactAmount;
}
{
.filter;
}
ResourceTransaction {
List<ResourceSlotTransaction> slotTransactions = (List).getList().stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
(.succeeded(), .action, .resource, .remainder, .consumed, .allOrNothing, .exactAmount, .filter, slotTransactions);
}
ResourceTransaction {
List<ResourceSlotTransaction> slotTransactions = (List).getList().stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
(slotTransactions.isEmpty()) {
;
} {
;
(ResourceSlotTransaction transaction : slotTransactions) {
(transaction.succeeded()) {
succeeded = ;
;
}
}
(succeeded, .action, .resource, .remainder, .consumed, .allOrNothing, .exactAmount, .filter, slotTransactions);
}
}
String {
String.valueOf(.action);
+ var10000 + + String.valueOf(.resource) + + .remainder + + .consumed + + .allOrNothing + + .exactAmount + + .filter + + .toString();
}
}
com/hypixel/hytale/server/core/inventory/transaction/SlotTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class SlotTransaction implements Transaction {
public static final SlotTransaction FAILED_ADD;
private final boolean succeeded;
@Nonnull
private final ActionType action;
private final short slot;
@Nullable
private final ItemStack slotBefore;
@Nullable
private final ItemStack slotAfter;
@Nullable
private final ItemStack output;
private final boolean allOrNothing;
private final boolean exactAmount;
private final boolean filter;
public SlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot, ItemStack slotBefore, ItemStack slotAfter, ItemStack output, allOrNothing, exactAmount, filter) {
.succeeded = succeeded;
.action = action;
.slot = slot;
.slotBefore = slotBefore;
.slotAfter = slotAfter;
.output = output;
.allOrNothing = allOrNothing;
.exactAmount = exactAmount;
.filter = filter;
}
{
.succeeded;
}
{
(!.succeeded) {
;
} {
.slot == slot;
}
}
ActionType {
.action;
}
{
.slot;
}
ItemStack {
.slotBefore;
}
ItemStack {
.slotAfter;
}
ItemStack {
.output;
}
{
.allOrNothing;
}
{
.exactAmount;
}
{
.filter;
}
SlotTransaction {
()(start + .slot);
(.succeeded, .action, newSlot, .slotBefore, .slotAfter, .output, .allOrNothing, .exactAmount, .filter);
}
SlotTransaction {
()(.slot - start);
newSlot >= && newSlot < container.getCapacity() ? (.succeeded, .action, newSlot, .slotBefore, .slotAfter, .output, .allOrNothing, .exactAmount, .filter) : ;
}
String {
.succeeded;
+ var10000 + + String.valueOf(.action) + + .slot + + String.valueOf(.slotBefore) + + String.valueOf(.slotAfter) + + .allOrNothing + + .exactAmount + + .filter + ;
}
{
FAILED_ADD = (, ActionType.ADD, ()-, (ItemStack), (ItemStack), (ItemStack), , , );
}
}
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class TagSlotTransaction extends SlotTransaction {
private final int query;
private final int remainder;
public TagSlotTransaction(boolean succeeded, @Nonnull ActionType action, short slot, @Nullable ItemStack slotBefore, @Nullable ItemStack slotAfter, @Nullable ItemStack output, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull int query, int remainder) {
super(succeeded, action, slot, slotBefore, slotAfter, output, allOrNothing, exactAmount, filter);
this.query = query;
this.remainder = remainder;
}
public int getQuery() {
return this.query;
}
public int getRemainder() {
.remainder;
}
TagSlotTransaction {
()(start + .getSlot());
(.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder);
}
TagSlotTransaction {
()(.getSlot() - start);
newSlot >= && newSlot < container.getCapacity() ? (.succeeded(), .getAction(), newSlot, .getSlotBefore(), .getSlotAfter(), .getOutput(), .isAllOrNothing(), .isExactAmount(), .isFilter(), .query, .remainder) : ;
}
String {
.query;
+ var10000 + + .remainder + + .toString();
}
}
com/hypixel/hytale/server/core/inventory/transaction/TagTransaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class TagTransaction extends ListTransaction<TagSlotTransaction> {
@Nonnull
private final ActionType action;
private final int tagIndex;
private final int remainder;
private final boolean allOrNothing;
private final boolean exactAmount;
private final boolean filter;
public TagTransaction(boolean succeeded, @Nonnull ActionType action, int tagIndex, int remainder, boolean allOrNothing, boolean exactAmount, boolean filter, @Nonnull List<TagSlotTransaction> slotTransactions) {
super(succeeded, slotTransactions);
this.action = action;
this.tagIndex = tagIndex;
this.remainder = remainder;
.allOrNothing = allOrNothing;
.exactAmount = exactAmount;
.filter = filter;
}
ActionType {
.action;
}
{
.tagIndex;
}
{
.remainder;
}
{
.allOrNothing;
}
{
.exactAmount;
}
{
.filter;
}
TagTransaction {
List<TagSlotTransaction> slotTransactions = (List).getList().stream().map((transaction) -> transaction.toParent(parent, start, container)).collect(Collectors.toList());
(.succeeded(), .action, .tagIndex, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
}
TagTransaction {
List<TagSlotTransaction> slotTransactions = (List).getList().stream().map((transactionx) -> transactionx.fromParent(parent, start, container)).filter(Objects::nonNull).collect(Collectors.toList());
(slotTransactions.isEmpty()) {
;
} {
;
(TagSlotTransaction transaction : slotTransactions) {
(transaction.succeeded()) {
succeeded = ;
;
}
}
(succeeded, .action, .tagIndex, .remainder, .allOrNothing, .exactAmount, .filter, slotTransactions);
}
}
String {
String.valueOf(.action);
+ var10000 + + .tagIndex + + .remainder + + .allOrNothing + + .exactAmount + + .filter + + .toString();
}
}
com/hypixel/hytale/server/core/inventory/transaction/Transaction.java
package com.hypixel.hytale.server.core.inventory.transaction;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public interface Transaction {
boolean succeeded();
boolean wasSlotModified(short var1);
@Nonnull
Transaction toParent(ItemContainer var1, short var2, ItemContainer var3);
@Nullable
Transaction fromParent(ItemContainer var1, short var2, ItemContainer var3);
}