Java tutorial
/* * Minecraft Forge * Copyright (c) 2016-2019. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation version 2.1 * of the License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ package net.minecraftforge.items; import net.minecraft.entity.item.ItemEntity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.SoundEvents; import net.minecraft.item.ItemStack; import net.minecraft.util.SoundCategory; import net.minecraft.util.math.MathHelper; import net.minecraft.world.World; import net.minecraftforge.items.wrapper.PlayerMainInvWrapper; import javax.annotation.Nonnull; import javax.annotation.Nullable; public class ItemHandlerHelper { @Nonnull public static ItemStack insertItem(IItemHandler dest, @Nonnull ItemStack stack, boolean simulate) { if (dest == null || stack.isEmpty()) return stack; for (int i = 0; i < dest.getSlots(); i++) { stack = dest.insertItem(i, stack, simulate); if (stack.isEmpty()) { return ItemStack.EMPTY; } } return stack; } public static boolean canItemStacksStack(@Nonnull ItemStack a, @Nonnull ItemStack b) { if (a.isEmpty() || !a.isItemEqual(b) || a.hasTag() != b.hasTag()) return false; return (!a.hasTag() || a.getTag().equals(b.getTag())) && a.areCapsCompatible(b); } /** * A relaxed version of canItemStacksStack that stacks itemstacks with different metadata if they don't have subtypes. * This usually only applies when players pick up items. */ public static boolean canItemStacksStackRelaxed(@Nonnull ItemStack a, @Nonnull ItemStack b) { if (a.isEmpty() || b.isEmpty() || a.getItem() != b.getItem()) return false; if (!a.isStackable()) return false; // Metadata value only matters when the item has subtypes // Vanilla stacks non-subtype items with different metadata together // TODO Item subtypes, is this still necessary? /* e.g. a stick with metadata 0 and a stick with metadata 1 stack if (a.getHasSubtypes() && a.getMetadata() != b.getMetadata()) return false; */ if (a.hasTag() != b.hasTag()) return false; return (!a.hasTag() || a.getTag().equals(b.getTag())) && a.areCapsCompatible(b); } @Nonnull public static ItemStack copyStackWithSize(@Nonnull ItemStack itemStack, int size) { if (size == 0) return ItemStack.EMPTY; ItemStack copy = itemStack.copy(); copy.setCount(size); return copy; } /** * Inserts the ItemStack into the inventory, filling up already present stacks first. * This is equivalent to the behaviour of a player picking up an item. * Note: This function stacks items without subtypes with different metadata together. */ @Nonnull public static ItemStack insertItemStacked(IItemHandler inventory, @Nonnull ItemStack stack, boolean simulate) { if (inventory == null || stack.isEmpty()) return stack; // not stackable -> just insert into a new slot if (!stack.isStackable()) { return insertItem(inventory, stack, simulate); } int sizeInventory = inventory.getSlots(); // go through the inventory and try to fill up already existing items for (int i = 0; i < sizeInventory; i++) { ItemStack slot = inventory.getStackInSlot(i); if (canItemStacksStackRelaxed(slot, stack)) { stack = inventory.insertItem(i, stack, simulate); if (stack.isEmpty()) { break; } } } // insert remainder into empty slots if (!stack.isEmpty()) { // find empty slot for (int i = 0; i < sizeInventory; i++) { if (inventory.getStackInSlot(i).isEmpty()) { stack = inventory.insertItem(i, stack, simulate); if (stack.isEmpty()) { break; } } } } return stack; } /** giveItemToPlayer without preferred slot */ public static void giveItemToPlayer(PlayerEntity player, @Nonnull ItemStack stack) { giveItemToPlayer(player, stack, -1); } /** * Inserts the given itemstack into the players inventory. * If the inventory can't hold it, the item will be dropped in the world at the players position. * * @param player The player to give the item to * @param stack The itemstack to insert */ public static void giveItemToPlayer(PlayerEntity player, @Nonnull ItemStack stack, int preferredSlot) { if (stack.isEmpty()) return; IItemHandler inventory = new PlayerMainInvWrapper(player.inventory); World world = player.world; // try adding it into the inventory ItemStack remainder = stack; // insert into preferred slot first if (preferredSlot >= 0 && preferredSlot < inventory.getSlots()) { remainder = inventory.insertItem(preferredSlot, stack, false); } // then into the inventory in general if (!remainder.isEmpty()) { remainder = insertItemStacked(inventory, remainder, false); } // play sound if something got picked up if (remainder.isEmpty() || remainder.getCount() != stack.getCount()) { world.playSound(null, player.func_226277_ct_(), player.func_226278_cu_() + 0.5, player.func_226281_cx_(), SoundEvents.ENTITY_ITEM_PICKUP, SoundCategory.PLAYERS, 0.2F, ((world.rand.nextFloat() - world.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F); } // drop remaining itemstack into the world if (!remainder.isEmpty() && !world.isRemote) { ItemEntity entityitem = new ItemEntity(world, player.func_226277_ct_(), player.func_226278_cu_() + 0.5, player.func_226281_cx_(), remainder); entityitem.setPickupDelay(40); entityitem.setMotion(entityitem.getMotion().mul(0, 1, 0)); world.addEntity(entityitem); } } /** * This method uses the standard vanilla algorithm to calculate a comparator output for how "full" the inventory is. * This method is an adaptation of Container#calcRedstoneFromInventory(IInventory). * @param inv The inventory handler to test. * @return A redstone value in the range [0,15] representing how "full" this inventory is. */ public static int calcRedstoneFromInventory(@Nullable IItemHandler inv) { if (inv == null) { return 0; } else { int itemsFound = 0; float proportion = 0.0F; for (int j = 0; j < inv.getSlots(); ++j) { ItemStack itemstack = inv.getStackInSlot(j); if (!itemstack.isEmpty()) { proportion += (float) itemstack.getCount() / (float) Math.min(inv.getSlotLimit(j), itemstack.getMaxStackSize()); ++itemsFound; } } proportion = proportion / (float) inv.getSlots(); return MathHelper.floor(proportion * 14.0F) + (itemsFound > 0 ? 1 : 0); } } }