Java InvWrapper类代码示例

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
public static IItemHandler getItemHandler(World world, BlockPos pos, EnumFacing side, boolean includeEntities) {
	TileEntity te = world.getTileEntity(pos);
	if (te instanceof IDrawer) {
		return new DrawerWrapper((IDrawer) te);
	} else if (te instanceof IDrawerGroup) {
		return new DrawerGroupWrapper((IDrawerGroup) te);
	} else if (te == null || !te.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side)) {
		IInventory inv = includeEntities ? TileEntityHopper.getInventoryAtPosition(world, pos.getX(), pos.getY(), pos.getZ()) : (te instanceof IInventory ? (IInventory) te : null);
		if (inv != null) {
			if (inv instanceof ISidedInventory) {
				return new SidedInvWrapper((ISidedInventory) inv, side);
			} else {
				return new InvWrapper(inv);
			}
		} else
			return null;
	} else {
		return te.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side);
	}
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
/**
 * Used to handle the common case of a fluid item right-clicking on a fluid handler.
 * First it tries to fill the container item from the fluid handler,
 * if that action fails then it tries to drain the container item into the fluid handler.
 *
 * Returns true if interaction was successful.
 * Returns false if interaction failed.
 */
public static boolean interactWithFluidHandler(ItemStack stack, IFluidHandler fluidHandler, EntityPlayer player)
{
    if (stack == null || fluidHandler == null || player == null)
    {
        return false;
    }

    IItemHandler playerInventory = new InvWrapper(player.inventory);
    return tryFillContainerAndStow(stack, fluidHandler, playerInventory, Integer.MAX_VALUE, player) ||
            tryEmptyContainerAndStow(stack, fluidHandler, playerInventory, Integer.MAX_VALUE, player);
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
@SuppressWarnings ("unchecked")
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
        return (T) new InvWrapper(getStorage());
    }
    return super.getCapability(capability, facing);
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
@SuppressWarnings ("unchecked")
@Override
public <T> T getCapability(@Nonnull Capability<T> capability, EnumFacing facing) {
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
        return (T) new InvWrapper(this);
    }
    return null;
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
@Deprecated
public static IItemHandler getItemHandlerCap(TileEntity tileEntity, EnumFacing face) {
    if (tileEntity.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, face)) {
        return tileEntity.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, face);
    } else if (tileEntity instanceof ISidedInventory && face != null) {
        return new SidedInvWrapper(((ISidedInventory) tileEntity), face);
    } else if (tileEntity instanceof IInventory) {
        return new InvWrapper(((IInventory) tileEntity));
    }
    return new EmptyHandler();
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
/**
 * Grabs the IItemHandler capability for the tile,
 * Will wrap if the cap doesnt exist, If you care about only interacting with the cap,
 * Then use {@link #hasItemHandler_Raw} to check if the tile only has the cap before calling.
 *
 * @param tile The tile.
 * @param face The face.
 * @return The handler, wrapped if the tile uses legacy interfaces and no cap.
 */
public static IItemHandler getItemHandler_Raw(TileEntity tile, EnumFacing face) {
    if (hasItemHandler(tile, face)) {
        if (hasItemHandler_Raw(tile, face)) {
            return tile.getCapability(ITEM_HANDLER, face);
        } else {
            if (tile instanceof ISidedInventory && face != null) {
                return new SidedInvWrapper((ISidedInventory) tile, face);
            } else {
                return new InvWrapper((IInventory) tile);
            }
        }
    }
    return null;
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
@Override
public boolean onBlockActivated(World w, BlockPos pos, IBlockState state, EntityPlayer p, EnumHand h, EnumFacing f, float x, float y, float z) {
	ItemStack is = p.getHeldItem(h);
	if (!w.isRemote) {
		TileEntity te = w.getTileEntity(pos);
		if (te instanceof TileEntityFluxGen) {
			FluidActionResult far = FluidUtil.tryEmptyContainerAndStow(is, (TileEntityFluxGen) te, new InvWrapper(p.inventory), TileEntityFluxGen.fluidCap, p);
			if (far.success)
				p.setHeldItem(h, far.result);
			else
				p.openGui(MCFlux.MF, R.MF_GUI_FLUXGEN, w, pos.getX(), pos.getY(), pos.getZ());
		}
	}
	return true;
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
public ContainerHandyBag(EntityPlayer player, ItemStack containerStack)
{
    super(player, new InventoryItemModular(containerStack, player, true, ModuleType.TYPE_MEMORY_CARD_ITEMS));
    this.inventoryItemModular = (InventoryItemModular) this.inventory;
    this.inventoryItemModular.setHostInventory(this.playerInv);
    this.craftMatrix = new InventoryCraftingEnderUtilities(2, 2, new ItemStackHandlerBasic(4), this.craftResult, player);
    this.craftMatrixWrapper = new InvWrapper(this.craftMatrix);
    this.inventoryNonWrapped = (InventoryItemModular) this.inventory;

    this.addCustomInventorySlots();
    this.addPlayerInventorySlots(8, 174);
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
/**
 * Gets a wrapped **InventoryCraftingPermissions** instance.
 * This must be used by anything that wants to modify the crafting grid contents,
 * so that the recipe and output slot will get updated properly!
 * @param gridId
 * @param player
 * @return
 */
@Nullable
private IItemHandler getWrappedCraftingInventoryFromContainer(int gridId, EntityPlayer player)
{
    if (player.openContainer instanceof ContainerCreationStation)
    {
        return new InvWrapper(((ContainerCreationStation) player.openContainer).getCraftingInventory(gridId));
    }

    return null;
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
/**
 * Moves as many items from the output slot to the owner's vanilla Ender Chest as possible.
 * Tries to first fill matching stacks to their max, then puts items into the first empty slot.
 * @return true if some items were moved
 */
private boolean moveItemsToEnderChest()
{
    if (this.getBaseItemHandler().getStackInSlot(SLOT_OUTPUT).isEmpty() ||
        this.ownerData == null || this.ownerData.getOwnerUUID() == null)
    {
        return false;
    }

    EntityPlayer player = this.getWorld().getPlayerEntityByUUID(this.ownerData.getOwnerUUID());

    if (player == null)
    {
        return false;
    }
    // Player is online

    ItemStack stack = this.getBaseItemHandler().extractItem(SLOT_OUTPUT, 64, false);

    if (stack.isEmpty())
    {
        return false;
    }

    int origSize = stack.getCount();
    IItemHandler inv = new InvWrapper(player.getInventoryEnderChest());
    stack = InventoryUtils.tryInsertItemStackToInventory(inv, stack);

    if (stack.isEmpty())
    {
        return true;
    }

    boolean movedItems = origSize != stack.getCount();
    this.getBaseItemHandler().insertItem(SLOT_OUTPUT, stack, false);

    return movedItems;
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
public static IItemHandler tryGetHandler(TileEntity te, EnumFacing side) {
	if (te == null) return null;

	if (te.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side))
		return te.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side);

	if (te instanceof ISidedInventory)
		return new SidedInvWrapper((ISidedInventory)te, side);

	if (te instanceof IInventory)
		return new InvWrapper((IInventory)te);

	return null;
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
	return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY ? (T) new InvWrapper(inv) : null;
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
public TileEntityItemHandler() {
	itemCapability = new InvWrapper(this);
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
private IItemHandler createUnSidedHandler() {
    return new InvWrapper(this);
}
 

import net.minecraftforge.items.wrapper.InvWrapper; //导入依赖的package包/类
public PlayerMainInvWrapperNoSync(InventoryPlayer inv)
{
    super(new InvWrapper(inv), 0, inv.mainInventory.size());

    this.inventoryPlayer = inv;
}