net.minecraftforge.items.ItemStackHandler Java Examples

public RecipeMapCategory(RecipeMap<?> recipeMap, IGuiHelper guiHelper) {
    this.recipeMap = recipeMap;
    FluidTank[] importFluidTanks = new FluidTank[recipeMap.getMaxFluidInputs()];
    for (int i = 0; i < importFluidTanks.length; i++)
        importFluidTanks[i] = new FluidTank(16000);
    FluidTank[] exportFluidTanks = new FluidTank[recipeMap.getMaxFluidOutputs()];
    for (int i = 0; i < exportFluidTanks.length; i++)
        exportFluidTanks[i] = new FluidTank(16000);
    this.modularUI = recipeMap.createJeiUITemplate(
        (importItems = new ItemStackHandler(recipeMap.getMaxInputs())),
        (exportItems = new ItemStackHandler(recipeMap.getMaxOutputs())),
        (importFluids = new FluidTankList(false, importFluidTanks)),
        (exportFluids = new FluidTankList(false, exportFluidTanks))
    ).build(new BlankUIHolder(), Minecraft.getMinecraft().player);
    this.modularUI.initWidgets();
    this.backgroundDrawable = guiHelper.createBlankDrawable(modularUI.getWidth(), modularUI.getHeight() * 2 / 3);
}
 

public static void generateLoot(ItemStackHandler items, String tableStr, long seed,
                                World world, EntityPlayer player) {
	Random rnd = new Random(seed);
	double maxFullness = (0.6 + rnd.nextDouble() * 0.2);
	int maxOccupiedSlots = (int)Math.ceil(items.getSlots() * maxFullness);
	
	LootTableManager manager = world.getLootTableManager();
	LootTable table = manager.getLootTableFromLocation(new ResourceLocation(tableStr));
	LootContext context = new LootContext(((player != null) ? player.getLuck() : 0),
	                                      (WorldServer)world, manager, player, null, null);
	List<ItemStack> loot = table.generateLootForPools(rnd, context);
	Collections.shuffle(loot);
	
	List<Integer> randomizedSlots = new ArrayList<Integer>(items.getSlots());
	for (int i = 0; i < items.getSlots(); i++) randomizedSlots.add(i);
	Collections.shuffle(randomizedSlots);
	for (int i = 0; (i < maxOccupiedSlots) && (i < loot.size()); i++) {
		ItemStack stack = loot.get(i);
		int slot = randomizedSlots.get(i);
		items.setStackInSlot(slot, stack);
	}
}
 

public static boolean tick(World world, BlockPos pos, ItemStack input, ItemStackHandler inventoryHandler, Function<IManaCapability, Double> consumeMana) {
	ICraftingPlateRecipe recipe = null;

	for (ICraftingPlateRecipe search : recipes) {
		if (search.doesRecipeExistInWorld(world, pos) || search.doesRecipeExistForItem(input)) {
			recipe = search;
			break;
		}
	}
	if (recipe == null) return false;

	if (!recipe.isDone(world, pos, input)) {
		recipe.tick(world, pos, input, inventoryHandler, consumeMana);
	} else {
		recipe.complete(world, pos, input, inventoryHandler);
		return true;
	}
	return false;
}
 

public TileEntityPhysicsInfuser() {
    handler = new ItemStackHandler(EnumInfuserCore.values().length) {
        @Override
        protected void onContentsChanged(int slot) {
            sendUpdateToClients = true;
        }
    };
    sendUpdateToClients = false;
    isTryingToAssembleShip = false;
    isTryingToDisassembleShip = false;
    isPhysicsEnabled = false;
    isTryingToAlignShip = false;
    coreOffsets = new HashMap<>();
    coreOffsetsPrevTick = new HashMap<>();
    for (EnumInfuserCore enumInfuserCore : EnumInfuserCore.values()) {
        coreOffsets.put(enumInfuserCore, 0D);
        coreOffsetsPrevTick.put(enumInfuserCore, 0D);
    }
}
 

@Override
protected IItemHandlerModifiable createImportItemHandler() {
    return new ItemStackHandler(1) {
        @Nonnull
        @Override
        public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) {
            if(OreDictUnifier.getOreDictionaryNames(stack).contains("string")) {
                return super.insertItem(slot, stack, simulate);
            }
            return stack;
        }
    };
}
 

public static void handle(PacketOpenFilterContainer msg, Supplier<NetworkEvent.Context> ctx) {
    ctx.get().enqueueWork(() -> {
        ServerPlayerEntity sender = ctx.get().getSender();
        if (sender == null)
            return;

        Container container = sender.openContainer;
        if (container == null)
            return;

        ItemStack stack = MiningGadget.getGadget(sender);
        if( stack.isEmpty() )
            return;

        ItemStackHandler ghostInventory = new ItemStackHandler(30) {
            @Override
            protected void onContentsChanged(int slot) {
                stack.getOrCreateTag().put(MiningProperties.KEY_FILTERS, serializeNBT());
            }
        };

        ghostInventory.deserializeNBT(stack.getOrCreateChildTag(MiningProperties.KEY_FILTERS));
        sender.openContainer(new SimpleNamedContainerProvider(
                (windowId, playerInventory, playerEntity) -> new FilterContainer(windowId, playerInventory, ghostInventory), new StringTextComponent("")
        ));
    });

    ctx.get().setPacketHandled(true);
}
 

public SimpleMachineMetaTileEntity(ResourceLocation metaTileEntityId, RecipeMap<?> recipeMap, OrientedOverlayRenderer renderer, int tier, boolean hasFrontFacing) {
    super(metaTileEntityId, recipeMap, renderer, tier);
    this.hasFrontFacing = hasFrontFacing;
    this.chargerInventory = new ItemStackHandler(1) {
        @Override
        public int getSlotLimit(int slot) {
            return 1;
        }
    };
}
 

public AutomationItemStackHandler(ItemStackHandler hidden, int validInputSlot, int validOutputSlot) {
	super();
	mainHandler = hidden;

	this.validOutputSlot = validOutputSlot;
	this.validInputSlot = validInputSlot;
}
 

public CraftingRecipeResolver(World world, ItemStackHandler craftingGrid, CraftingRecipeMemory recipeMemory) {
    this.world = world;
    this.craftingGrid = craftingGrid;
    this.recipeMemory = recipeMemory;
    this.itemSourceList = new ItemSourceList(world);
    this.itemSourceList.addItemListChangeCallback(this::notifyStoredItemsChanged);
}
 

public SimpleGeneratorMetaTileEntity(ResourceLocation metaTileEntityId, FuelRecipeMap recipeMap, OrientedOverlayRenderer renderer, int tier) {
    super(metaTileEntityId, tier);
    this.containerInventory = new ItemStackHandler(2);
    this.overlayRenderer = renderer;
    this.recipeMap = recipeMap;
    this.workableHandler = createWorkableHandler();
}
 

@SideOnly(Side.CLIENT)
public ContainerBackpack(EntityPlayer player, NBTTagCompound data) {
	this.player   = player;
	this.backpack = null;
	this.data     = null;
	
	size  = BackpackSize.parse(data.getTag(TAG_SIZE));
	items = new ItemStackHandler(size.getColumns() * size.getRows());
	
	title = data.getString(TAG_TITLE);
	titleLocalized = data.getBoolean(TAG_LOCALIZED);
	
	setupSlots();
}
 

public MetaTileEntityQuantumTank(ResourceLocation metaTileEntityId, int tier, int maxFluidCapacity) {
    super(metaTileEntityId);
    this.tier = tier;
    this.maxFluidCapacity = maxFluidCapacity;
    this.containerInventory = new ItemStackHandler(2);
    initializeInventory();
}
 

public void checkForNewBoxes()
{
	for (int i = 0; i < playerInv.mainInventory.length; i++)
	{
		if (!this.componentBoxList.contains(i))
		{
			ItemStack stack = playerInv.mainInventory[i];
			if (stack != null && stack.getItem() == CyberwareContent.componentBox.ib)
			{
				if (!stack.hasTagCompound())
				{
					stack.setTagCompound(new NBTTagCompound());
				}
				if (!stack.getTagCompound().hasKey("contents"))
				{
					ItemStackHandler slots = new ItemStackHandlerComponent(18);
					stack.getTagCompound().setTag("contents", slots.serializeNBT());
				}
				if (componentBox == null )
				{
					componentBox = i;
					componentBoxIndex = componentBoxList.size();
				}

				componentBoxList.add(i);
			}
		}
	}
}
 

@Override
public void tick(World world, BlockPos pos, ItemStack input, ItemStackHandler inventoryHandler, Function<IManaCapability, Double> consumeMana) {
	TileEntity tileEntity = world.getTileEntity(pos.offset(EnumFacing.UP));
	if (!(tileEntity instanceof TileJar)) return;
	TileJar jar = (TileJar) tileEntity;

	if (jar.fairy != null
			&& jar.fairy.infusedSpell.isEmpty()
			&& !jar.fairy.isDepressed
			&& !ManaManager.isManaFull(jar.fairy.handler)) {
		ManaManager.forObject(jar.fairy.handler).addMana(consumeMana.apply(jar.fairy.handler)).close();
		jar.markDirty();
	}
}
 

@Test
public void test_removeInputsFromInventory_ore()
{
    ItemStackHandler inv = new ItemStackHandler(2);
    inv.setStackInSlot(0, new ItemStack(Items.APPLE));
    inv.setStackInSlot(1, new ItemStack(Items.STICK, 3));

    RecipeInputImpl input1 = new RecipeInputImpl("stickWood", 2);
    RecipeInputImpl input2 = RecipeInputImpl.create(new ItemStack(Items.APPLE, 1));
    ItemHelper.removeInputsFromInventory(Lists.newArrayList(input1, input2), inv, 0, 2);

    assertTrue(inv.getStackInSlot(0).isEmpty());
    assertEquals(1, inv.getStackInSlot(1).getCount());
}
 

public SteamBoiler(ResourceLocation metaTileEntityId, boolean isHighPressure, OrientedOverlayRenderer renderer, int baseSteamOutput) {
    super(metaTileEntityId);
    this.renderer = renderer;
    this.isHighPressure = isHighPressure;
    this.baseSteamOutput = baseSteamOutput;
    BRONZE_BACKGROUND_TEXTURE = getGuiTexture("%s_gui");
    BRONZE_SLOT_BACKGROUND_TEXTURE = getGuiTexture("slot_%s");
    SLOT_FURNACE_BACKGROUND = getGuiTexture("slot_%s_furnace_background");
    this.containerInventory = new ItemStackHandler(2);
}
 

@Test
public void test_removeInputsFromInventory_stacks()
{
    ItemStackHandler inv = new ItemStackHandler(2);
    inv.setStackInSlot(0, new ItemStack(Items.APPLE));
    inv.setStackInSlot(1, new ItemStack(Items.STICK, 3));

    RecipeInputImpl input1 = RecipeInputImpl.create(new ItemStack(Items.STICK, 2));
    RecipeInputImpl input2 = RecipeInputImpl.create(new ItemStack(Items.APPLE, 1));
    ItemHelper.removeInputsFromInventory(Lists.newArrayList(input1, input2), inv, 0, 2);

    assertTrue(inv.getStackInSlot(0).isEmpty());
    assertEquals(1, inv.getStackInSlot(1).getCount());
}
 

@Override
public IItemHandlerModifiable createImportItemHandler() {
    return new ItemStackHandler(1) {
        @Nonnull
        @Override
        public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) {
            if (TileEntityFurnace.getItemBurnTime(stack) <= 0)
                return stack;
            return super.insertItem(slot, stack, simulate);
        }
    };
}
 

public SimpleItemFilter() {
    this.itemFilterSlots = new ItemStackHandler(MAX_MATCH_SLOTS) {
        @Override
        public int getSlotLimit(int slot) {
            return getMaxStackSize();
        }
    };
}
 

@Override
protected IItemHandlerModifiable createExportItemHandler() {
    return new ItemStackHandler(1);
}
 

@Override
protected IItemHandlerModifiable createExportItemHandler() {
    return new ItemStackHandler(2);
}
 

@Override
protected IItemHandlerModifiable createImportItemHandler() {
    return new ItemStackHandler(1);
}
 

@Override
protected IItemHandlerModifiable createExportItemHandler() {
    return new ItemStackHandler(1);
}
 

@Override
protected void initializeInventory() {
    super.initializeInventory();
    this.fluidInventory = new FluidTankList(false);
    this.itemInventory = new ItemStackHandler(0);
}
 

@Override
public void removeFromMultiBlock(MultiblockControllerBase controllerBase) {
    super.removeFromMultiBlock(controllerBase);
    this.fluidInventory = new FluidTankList(false);
    this.itemInventory = new ItemStackHandler(0);
}
 

@Override
protected void initializeInventory() {
    super.initializeInventory();
    ItemStackHandler emptyHandler = new ItemStackHandler(0);
    this.itemInventory = new ItemHandlerProxy(emptyHandler, emptyHandler);
}
 

public ItemStackHandler getItemFilterSlots() {
    return itemFilterSlots;
}
 

public ItemStackHandler getFilterInventory() {
    return filterInventory;
}
 

@Override
protected IItemHandlerModifiable createExportItemHandler() {
    return new ItemStackHandler(0);
}
 

@Override
protected IItemHandlerModifiable createImportItemHandler() {
    return new ItemStackHandler(1);
}