I have before made a chest in 1.12.2 but i think that it has changed since then so im not sure on how to make one in 1.16. Any help would be appriciated!

A brief summary would be nice!

You'll want to register a tile entity, in it you can have a field for the inventory, by instantiating an ItemStackHandler

you'll want to bind it to a block, by overriding hasTileEntity (to return true) and createTileEntity (to call create on the instance of the tile entity that you registered)

to open the gui when the player right clicks you'll need to call NetworkHooks.openGui, and pass an INamedContainerProvider, which you can implement in the tile entity (for the container provider you'll just need to make createMenu to return a new instance of a Container)

so you'll also need to register a container, in it you'll add the slots corresponding to the player inventory, and your tile entity inventory

and lastly you'll need a containerScreen for the gui

 

you can see some example here: https://github.com/TheGreyGhost/MinecraftByExample/tree/master/src/main/java/minecraftbyexample/mbe30_inventory_basic

 

personally i dont want mine to hahve a gui (only insert item into chest right clicked with an item). Thank you!

Edited March 17, 20214 yr by [email protected]

How would i write the item im holding to the tile entity?

in the onBlockActivated override, you have access to the position and to the world, you can call World#getTileEntity, to get the TE at the pos of the block, make sure it's your TE, and have a in the TE class that you can call that adds the item to the TE's inventory

under write and read method how do i make it store up to 9 items?

For the getTileEnityt method i cant find how to do that:

 

if(worldIn.getTileEntity(pos) == BlockPos)?

1 hour ago, [email protected] said:

under write and read method how do i make it store up to 9 items?

the read and write methods are use for nbt serialization, so that the game can save the data when the player closes the game.

the write method has a CompoundNBT as a parameter, you can write to it using CompoundNBT#put.

create a static final String in your TE class, to be the "key" of the data you want to keep, something like "inventory" (this will be the tag for referencing the inventory in NBT)

then you can call put, give it this tag, and then give it the inventory. you can use ItemStackHandler#serializeNBT to get an nbt object, that you can put in the tag

 

in the read method, you get the nbt that you saved in the write method. call nbt.getCompound(), to get an nbt object that you saved, using the string you saved it at.

then use ItemStackHandler#deserializeNBT, to recover the data from the nbt into the TE data.

 

this may sound a bit complex, so here's an example:

    private static final String INVENTORY_TAG = "inventory";
    private static final String CHARGE_TIME_LEFT_TAG = "chargeTimeLeft";
    private static final String CHARGE_TAG = "charge";
    private static final String MAX_CHARGE_TAG = "maxCharge";
    private static final String CHARGING_TAG = "charging";

    @Override
    public CompoundNBT write(CompoundNBT nbt) {
        super.write(nbt);

        nbt.put(INVENTORY_TAG, this.inventory.serializeNBT());
        nbt.putShort(CHARGE_TIME_LEFT_TAG, this.chargeTimeLeft);
        nbt.putShort(CHARGE_TAG, this.charge);
        nbt.putShort(MAX_CHARGE_TAG, this.maxCharge);
        nbt.putBoolean(CHARGING_TAG, this.charging);

        return nbt;
    }

    @Override
    public void read(BlockState state, CompoundNBT nbt) {
        super.read(state, nbt);

        this.inventory.deserializeNBT(nbt.getCompound(INVENTORY_TAG));
        this.chargeTimeLeft = nbt.getShort(CHARGE_TIME_LEFT_TAG);
        this.charge = nbt.getShort(CHARGE_TAG);
        this.maxCharge = nbt.getShort(MAX_CHARGE_TAG);
        this.charging = nbt.getBoolean(CHARGING_TAG);
    }

 

26 minutes ago, [email protected] said:

For the getTileEnityt method i cant find how to do that:

 

if(worldIn.getTileEntity(pos) == BlockPos)?

the getTileEntity, gets the TileEntity at a position.

you can then use this TileEntity

 

why are you checking if it is BlockPos in an if statement?

Then how do add the item the player is holding to the string? will i have to use a list or smth

39 minutes ago, [email protected] said:

Then how do add the item the player is holding to the string? will i have to use a list or smth

read and write methods are not for that, they are called when the chunk is loading or unloading, and you use it to save the TE data to a permanent format that can be stored in a file

Edited March 18, 20214 yr by kiou.23

So do i make a list for what i have right clicked in then save it using onChunkUnload? then i retrive it with the read and write methods. I it smth like that??

 

But ive just made my block a chest without a gui but i cant figure out how to add an item to its inventory withourt a gui i dont knwo what method u use to do addInventoryItem or smth

Edited March 18, 20214 yr by [email protected]

2 minutes ago, [email protected] said:

So do i make a list for what i have right clicked in then save it using onChunkUnload? then i retrive it with the read and write methods. I it smth like that??

it depends on how you want this chest to work.

don't worry too much about the read, write, and onChunkUnload methods, they do not concern your block or TE logic.

the preferred interface to store Items is an IItemHandler, with the default implementation of the ItemStackHandler

 

but if the amount is arbitrary, and it may only hold one type of item, you could store an Item reference, and an integer that tells the amount of the item in the TE. you'd have to think about when the ItemStack has nbt tho...

Quote

public MixingBowlBlockTileEntity(TileEntityType<?> tileEntityTypeIn) {
        super(tileEntityTypeIn);
    }
    
    public MixingBowlBlockTileEntity() {
        this(TileEntityTypesInit.MIXING_BOWL_BLOCK_TILE_ENTITY_TYPE.get());
    }
    
    private ItemStackHandler handler;
    
    @Override
    public CompoundNBT write(CompoundNBT tag) {
        CompoundNBT compound = getHandler().serializeNBT();
        tag.put("inv", compound);
        return super.write(compound);
    }
    @Override
    public void read(BlockState state, CompoundNBT tag) {
        CompoundNBT invTag = tag.getCompound("inv");
        getHandler().deserializeNBT(invTag);
        super.read(state, tag);
    }
    
    private ItemStackHandler getHandler() {
        if (handler == null) {
            handler = new ItemStackHandler(1);
        }
        return handler;
    }

    @Override
    public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
        if (cap == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
            return LazyOptional.of(() -> (T) getHandler());
        }
        return super.getCapability(cap, side);
    }

 

ive done that atm but it only works with hoppers idk what in that adds the item to the inventory tho. What is the method or line of code that adds the item to an "inventory" 

Edited March 19, 20214 yr by [email protected]

23 minutes ago, [email protected] said:

ive done that atm but it only works with hoppers idk what in that adds the item to the inventory tho

hoppers use the capability, so they are getting the ItemStackHandler you are returning in getCapability

 

24 minutes ago, [email protected] said:

What is the method or line of code that adds the item to an "inventory" 

to add an item to the ItemStackHandler you can use ItemStackHandler#setStackInSlot, or ItemStackHandler#insertItem

to get something you can use ItemStackHandler#extractItem

 

plus, I don't think you need to lazily load the ItemStackHandler

Quote

private LazyOptional<IItemHandler> handler = LazyOptional.of(this::createHandler).cast();

 

private ItemStackHandler createHandler() {
        return new ItemStackHandler(1) {
            @Override
            public boolean isItemValid(int slot, ItemStack stack) {
                return super.isItemValid(slot, stack);
            }

            @SuppressWarnings("static-access")
            @Nonnull
            @Override
            public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) {
                if (!MixingBowlBlock.C1.getCanMix().contains(stack.getItem())) {
                    return stack;
                }
                return super.insertItem(slot, stack, simulate);
            }

            @Override
            public ItemStack extractItem(int slot, int amount, boolean simulate) {

                return super.extractItem(slot, amount, simulate);
            }
        };
    }
 

Now that works for only accepting certain items but how do i add an item to that inventory in the onblockactivated method in my block class?

I cant figure out how to calll it in this case as it is inside of createHandler()

3 hours ago, [email protected] said:

I cant figure out how to calll it in this case as it is inside of createHandler()

and why are you initializing the ItemStackHandler in a method?

that would make it so every call to get the handler would return a new handler, instead of the same handler

 

you don't need to override insertItem and extractItem, just call them from the your block method... get the TE at the blockpos, from there it's simple

 

as Die said, please learn Java and OOP