Java IItemHandlerModifiable类代码示例

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
protected void readCapabilities(NBTTagCompound nbt, @Nullable EnumFacing side){
    IItemHandler inventory = this.getInventory(side);
    if(inventory != null && inventory instanceof IItemHandlerModifiable && nbt.hasKey("Inventory")){
        for(int i = 0; i < inventory.getSlots(); i++){ // clear the inventory, otherwise empty stacks doesn't get overriden while syncing. Forge Bug?
            ((IItemHandlerModifiable) inventory).setStackInSlot(i, ItemStack.EMPTY);
        }
        CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.readNBT(inventory, side, nbt.getTag("Inventory"));
    }
    IFluidHandler tank = getTank(side);
    if(tank != null && tank instanceof IFluidTank && nbt.hasKey("FluidTank")){
        CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.readNBT(tank, side, nbt.getCompoundTag("FluidTank"));
    }
    IEnergyStorage energy = getEnergy(side);
    if(energy != null && energy instanceof EnergyStorage && nbt.hasKey("Energy")){
        CapabilityEnergy.ENERGY.readNBT(energy, side, nbt.getTag("Energy"));
    }
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
public static void removeInputsFromInventory(List<RecipeInput> inputs, IItemHandlerModifiable inv, int start, int numSlots)
{
    List<RecipeInput> remaining = Lists.newLinkedList(inputs);

    for (int i = start; i < start + numSlots; i++)
    {
        ItemStack stack = inv.getStackInSlot(i);
        for (Iterator<RecipeInput> iterator = remaining.iterator(); iterator.hasNext(); )
        {
            RecipeInput input = iterator.next();
            if (stackMatchesRecipeInput(stack, input, true))
            {
                extractInput(input, inv, i);

                iterator.remove();
                break;
            }
        }
    }
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
@Nullable
private IItemHandlerModifiable getItemHandlerCapability(@Nullable EnumFacing facing)
{
    Capability<IItemHandler> capability = CapabilityItemHandler.ITEM_HANDLER_CAPABILITY;

    List<IItemHandlerModifiable> handlers = Lists.newLinkedList();

    for (TileEntityModule module : modules.values())
    {
        if (module.hasCapability(capability, facing))
            handlers.add((IItemHandlerModifiable) module.getCapability(capability, facing));
    }

    if (handlers.size() == 1)
        return handlers.get(0);
    else if (handlers.size() > 1)
        return new CombinedInvWrapper(handlers.toArray(new IItemHandlerModifiable[handlers.size()]));
    else
        return null;
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
public static ItemStack extract(TileEntity tile, EnumFacing from, boolean fullStack) {

		if (tile.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, from)) {
			IItemHandlerModifiable handler = (IItemHandlerModifiable) tile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, from);
			if (handler != null) {
				int invSize = handler.getSlots();

				for (int i = 0; i < invSize; i++) {
					ItemStack current = handler.getStackInSlot(i);

					if (current != null && !current.isEmpty() && current.getItem() != Items.AIR) {
						ItemStack stack = handler.extractItem(i, !fullStack ? 1 : current.getCount(), false);
						return stack;
					}
				}
			}
		} // TODO: TileEntities that don't have capabilities - needs testing

		return null;
	}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
private void copyInventory(IItemHandlerModifiable from, int[][] fromSlotIds, IItemHandlerModifiable to, int[][] toSlotIds)
{
    for (int i = 0; i < fromSlotIds.length; i++)
    {
        int[] slotIds = fromSlotIds[i];

        for (int j = 0; j < slotIds.length; j++)
        {
            int fromSlot = slotIds[j];
            if (j < toSlotIds[i].length)
            {
                int toSlot = toSlotIds[i][j];

                to.setStackInSlot(toSlot, from.getStackInSlot(fromSlot));
                from.setStackInSlot(fromSlot, ItemStack.EMPTY);
            }
        }
    }
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
@Override
public void putStack(ItemStack stack)
{
    if (this.getItemHandler() instanceof IItemHandlerModifiable)
    {
        //System.out.printf("SlotItemHandlerGeneric#putStack() - setStackInSlot() - slot: %3d stack: %s\n", this.getSlotIndex(), stack);
        ((IItemHandlerModifiable) this.getItemHandler()).setStackInSlot(this.getSlotIndex(), stack);
    }
    else
    {
        EnderUtilities.logger.warn("SlotItemHandlerGeneric#putStack() by insertItem() - things will not work well!");
        this.getItemHandler().insertItem(this.getSlotIndex(), stack, false);
    }

    this.onSlotChanged();
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
@Override
public void setDead() {
	//System.out.println("death and drop");
	if (!this.getEntityWorld().isRemote) {
		Block.spawnAsEntity(this.getEntityWorld(), this.getPosition(), new ItemStack(ItemLoader.itemTripod, 1));
		// last slot useless,so= -2 !=-1
		for (int i = Inventory.getSlots() - 2; i >= 0; --i) {
			if (Inventory.getStackInSlot(i) != null) {
				Block.spawnAsEntity(this.getEntityWorld(), this.getPosition(), Inventory.getStackInSlot(i));
				((IItemHandlerModifiable) Inventory).setStackInSlot(i, null);
			}
		}
	}
	super.setDead();
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
@Override
public void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
	TileEntityPhotoProcessor te = (TileEntityPhotoProcessor) worldIn.getTileEntity(pos);

	IItemHandler inv = te.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.UP);

	for (int i = inv.getSlots() - 1; i >= 0; --i) {
		if (inv.getStackInSlot(i) != null) {
			Block.spawnAsEntity(worldIn, pos, inv.getStackInSlot(i));
			((IItemHandlerModifiable) inv).setStackInSlot(i, null);
		}
	}

	super.breakBlock(worldIn, pos, state);
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
protected void writeCapabilities(NBTTagCompound nbt, @Nullable EnumFacing side){
    IItemHandler inventory = this.getInventory(side);
    if(inventory != null && inventory instanceof IItemHandlerModifiable){
        nbt.setTag("Inventory", CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.writeNBT(inventory, side));
    }
    IFluidHandler tank = getTank(side);
    if(tank != null && tank instanceof IFluidTank){
        nbt.setTag("FluidTank", CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.writeNBT(tank, side));
    }
    IEnergyStorage energy = getEnergy(side);
    if(energy != null && energy instanceof EnergyStorage){
        nbt.setTag("Energy", CapabilityEnergy.ENERGY.writeNBT(energy, side));
    }
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
static void extractInput(RecipeInput input, IItemHandlerModifiable from, int slot)
{
    if (input.isOreClass())
    {
        from.extractItem(slot, input.getOreClass().getAmount(), false);
    } else
    {
        ItemStack toExtract = input.getStack().getItemStack();
        from.extractItem(slot, toExtract.getCount(), false);
    }
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
public ItemHandlerMachine(int inputSlots, int outputSlots, int fuelSlots, TileEntity tile)
{
    super(inputSlots + outputSlots + fuelSlots, tile);
    this.inputSlots = inputSlots;
    this.outputSlots = outputSlots;
    this.fuelSlots = fuelSlots;

    inputHandler = inputSlots > 0 ? new RangedWrapper(this, 0, inputSlots)
                                  : (IItemHandlerModifiable) EmptyHandler.INSTANCE;
    outputHandler = outputSlots > 0 ? new RangedWrapper(this, inputSlots, inputSlots + outputSlots)
                                    : (IItemHandlerModifiable) EmptyHandler.INSTANCE;
    fuelHandler = fuelSlots > 0 ? new RangedWrapper(this, inputSlots + outputSlots, inputSlots + outputSlots + fuelSlots)
                                : (IItemHandlerModifiable) EmptyHandler.INSTANCE;
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
private Optional<IItemHandler> handlerForSide(EnumFacing facing)
{
    List<IItemHandlerModifiable> handlers = Lists.newArrayList();
    if (ArrayUtils.contains(supplier.sidesInput, facing))
        handlers.add(invHandler.getInputHandler());
    if (ArrayUtils.contains(supplier.sidesOutput, facing))
        handlers.add(invHandler.getOutputHandler());
    if (ArrayUtils.contains(supplier.sidesFuel, facing))
        handlers.add(invHandler.getFuelHandler());

    return Optional.ofNullable(handlers.isEmpty() ? null : new CombinedInvWrapper(handlers.toArray(new IItemHandlerModifiable[handlers.size()])));
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
public static boolean insert(ItemStack stack, TileEntity tile, EnumFacing from) {
	if (tile.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, from)) {
		IItemHandlerModifiable handler = (IItemHandlerModifiable) tile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, from);
		if (handler != null) {
			if (ItemHandlerHelper.insertItemStacked(handler, stack, false).isEmpty()) {
				return true;
			} else {
				return false;
			}
		}
	} // TODO: TileEntities that don't have capabilities - needs testing
	return false;
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
private CombinedInvWrapper createBottomSideHandler()
{
    IItemHandlerModifiable[] handlers = new IItemHandlerModifiable[outputHandlers.length + 1];
    System.arraycopy(outputHandlers, 0, handlers, 0, outputHandlers.length);
    handlers[handlers.length - 1] = fuelHandler;

    return new CombinedInvWrapper(handlers);
}
 

import net.minecraftforge.items.IItemHandlerModifiable; //导入依赖的package包/类
public IItemHandlerModifiable getHandlerForSide(@Nonnull EnumFacing facing)
{
    if (facing == EnumFacing.DOWN)
        return bottomSideHandler;
    if (facing == EnumFacing.UP)
        return topSideHandler;
    return sidesSideHandler;
}