Contêineres de Blocos
Aprenda a como adicionar contêineres a suas entidades de blocos.
Implementar Container é uma boa prática ao criar blocos que podem armazenar itens, como baús e fornalhas. Isso torna possível, por exemplo, interagir com o bloco usando funis.
Nesse tutorial, nós criaremos um bloco que usa os seus contêineres para duplicar quaisquer itens colocados dentro dele.
Criando o Bloco
Isso deve ser familiar ao leitor caso tenha seguido os guias Criando o Seu Primeiro Bloco e Blocos de Entidade. Nós criaremos um DuplicatorBlock que estende BaseEntityBlock e implementa EntityBlock.
public class DuplicatorBlock extends BaseEntityBlock {
@Nullable
@Override
public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
return new DuplicatorBlockEntity(pos, state);
}
// ...
}2
3
4
5
6
7
8
9
Então, nós precisamos criar um DuplicatorBlockEntity, que precisa implementar a interface Container. Assim como a maioria dos contêineres geralmente funcionam da mesma maneira, você pode copiar e colar essa interface auxiliar chamada ImplementedContainer que faz a maior parte do trabalho, nos deixando apenas com alguns métodos a implementar.
Mostrar ImplementedContainer
package com.example.docs.container;
import net.minecraft.core.NonNullList;
import net.minecraft.world.Container;
import net.minecraft.world.ContainerHelper;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
/**
* A simple {@link Container} implementation with only default methods + an item list getter.
*
* @author Juuz
*/
public interface ImplementedContainer extends Container {
/**
* Retrieves the item list of this container.
* Must return the same instance every time it's called.
*/
NonNullList<ItemStack> getItems();
/**
* Creates a container from the item list.
*/
static ImplementedContainer of(NonNullList<ItemStack> items) {
return () -> items;
}
/**
* Creates a new container with the specified size.
*/
static ImplementedContainer ofSize(int size) {
return of(NonNullList.withSize(size, ItemStack.EMPTY));
}
/**
* Returns the container size.
*/
@Override
default int getContainerSize() {
return this.getItems().size();
}
/**
* Checks if the container is empty.
* @return true if this container has only empty stacks, false otherwise.
*/
@Override
default boolean isEmpty() {
for (int i = 0; i < this.getContainerSize(); i++) {
ItemStack stack = this.getItem(i);
if (!stack.isEmpty()) {
return false;
}
}
return true;
}
/**
* Retrieves the item in the slot.
*/
@Override
default ItemStack getItem(int slot) {
return this.getItems().get(slot);
}
/**
* Removes items from a container slot.
* @param slot The slot to remove from.
* @param count How many items to remove. If there are fewer items in the slot than what are requested,
* takes all items in that slot.
*/
@Override
default ItemStack removeItem(int slot, int count) {
ItemStack result = ContainerHelper.removeItem(this.getItems(), slot, count);
if (!result.isEmpty()) {
this.setChanged();
}
return result;
}
/**
* Removes all items from a container slot.
* @param slot The slot to remove from.
*/
@Override
default ItemStack removeItemNoUpdate(int slot) {
return ContainerHelper.takeItem(this.getItems(), slot);
}
/**
* Replaces the current stack in an container slot with the provided stack.
* @param slot The container slot of which to replace the item stack.
* @param stack The replacing item stack. If the stack is too big for
* this container ({@link Container#getMaxStackSize()}),
* it gets resized to this container's maximum amount.
*/
@Override
default void setItem(int slot, ItemStack stack) {
this.getItems().set(slot, stack);
stack.limitSize(this.getMaxStackSize(stack));
this.setChanged();
}
/**
* Clears the container.
*/
@Override
default void clearContent() {
this.getItems().clear();
}
/**
* Marks that the state has changed.
* Must be called after changes in the container, so that the game can properly save
* the container contents and notify neighboring blocks of container changes.
*/
@Override
default void setChanged() {
// Override if you want behavior.
}
/**
* @return true if the player can use the container, false otherwise.
*/
@Override
default boolean stillValid(Player player) {
return true;
}
}2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
public class DuplicatorBlockEntity extends BlockEntity implements ImplementedContainer {
private final NonNullList<ItemStack> items = NonNullList.withSize(1, ItemStack.EMPTY);
public DuplicatorBlockEntity(BlockPos pos, BlockState state) {
super(ModBlockEntities.DUPLICATOR_BLOCK_ENTITY, pos, state);
}
@Override
public NonNullList<ItemStack> getItems() {
return this.items;
}
}2
3
4
5
6
7
8
9
10
11
12
A lista Items é onde os conteúdos do contêiner são armazenados. Para este bloco, definimos o tamanho do inventário de entrada como 1 slot.
Não esqueça de registrar o bloco e o bloco de entidade em suas respectivas classes!
Salvando e Carregando
Se nós quisermos que os conteúdos persistam entre recarregamentos de jogo como um BlockEntity vanilla, nós precisamos salvá-lo como NBT. Felizmente, a Mojang fornece uma classe auxiliar chamada ContainerHelper com toda a lógica necessária.
@Override
protected void loadAdditional(ValueInput input) {
super.loadAdditional(input);
ContainerHelper.loadAllItems(input, this.items);
}
@Override
protected void saveAdditional(ValueOutput output) {
ContainerHelper.saveAllItems(output, this.items);
super.saveAdditional(output);
}2
3
4
5
6
7
8
9
10
11
Interagindo com o Contêiner
Tecnicamente, o contêiner já está funcional. No entanto, para inserir itens, no momento precisamos usar funis. Vamos fazer com que nós possamos inserir itens no bloco clicando com o botão direito do mouse.
Para fazer isso, nós precisamos sobrescrever o método useItemOn no DuplicatorBlock:
@Override
protected InteractionResult useItemOn(ItemStack stack, BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hit) {
if (!(world.getBlockEntity(pos) instanceof DuplicatorBlockEntity duplicatorBlockEntity)) {
return InteractionResult.PASS;
}
if (!player.getItemInHand(hand).isEmpty() && duplicatorBlockEntity.isEmpty()) {
duplicatorBlockEntity.setItem(0, player.getItemInHand(hand).copy());
player.getItemInHand(hand).setCount(0);
}
return InteractionResult.SUCCESS;
}2
3
4
5
6
7
8
9
10
11
12
13
Aqui, se o jogador está segurando um item e há um slot vazio, nós movemos o item da mão do jogador para o contêiner do bloco e retornamos InteractionResult.SUCCESS.
Agora quando você clica o botão direito do mouse no bloco com um item, você não terá mais ele! Se você executar /data get block no bloco, você verá o item no campo items no NBT.

Duplicando Items
Agora vamos fazer com que o bloco duplique a pilha de itens que você jogou nele, mas apenas dois itens por vez. E vamos fazer com que ele espere um segundo toda vez para não encher o jogador de itens!
Para fazer isso, nós adicionaremos uma função tick ao DuplicatorBlockEntity, e um campo para armazenar a quantidade de tempo que nós esperamos:
private int timeSinceDropped = 0;
public static void tick(Level world, BlockPos blockPos, BlockState blockState, DuplicatorBlockEntity duplicatorBlockEntity) {
if (duplicatorBlockEntity.isEmpty()) return;
duplicatorBlockEntity.timeSinceDropped++;
if (duplicatorBlockEntity.timeSinceDropped < 10) return;
duplicatorBlockEntity.timeSinceDropped = 0;
ItemStack duplicate = duplicatorBlockEntity.getItem(0).split(1);
Block.popResourceFromFace(world, blockPos, Direction.UP, duplicate);
Block.popResourceFromFace(world, blockPos, Direction.UP, duplicate);
}2
3
4
5
6
7
8
9
10
11
12
13
14
Agora o DuplicatorBlock deve ter um método getTicker que retorna uma referência para o DuplicatorBlockEntity::tick.
Worldly Containers
Por padrão, você pode inserir e extrair itens do contêiner a partir de qualquer lado. No entanto, às vezes esse comportamento não é desejado: por exemplo, uma fornalha apenas aceita combustível a partir das laterais e itens por cima.
Para criar esse comportamento, nós precisamos implementar a interface WorldlyContainer no BlockEntity. Essa interface possui três métodos:
getSlotsForFace(Direction)permite que você controle quais slots podem ser interagidos a partir de um determinado lado.canPlaceItemThroughFace(int, ItemStack, Direction)permite que você controle se um item pode ser inserido em um slot a partir de um determinado lado.canTakeItemThroughFace(int, ItemStack, Direction)permite que você controle se um item pode ser extraído a partir de um determinado lado.
Vamos modificar o DuplicatorBlockEntity para que apenas aceite items da parte de cima:
@Override
public int[] getSlotsForFace(Direction side) {
return new int[]{ 0 };
}
@Override
public boolean canPlaceItemThroughFace(int slot, ItemStack stack, @Nullable Direction dir) {
return dir == Direction.UP;
}
@Override
public boolean canTakeItemThroughFace(int slot, ItemStack stack, Direction dir) {
return true;
}2
3
4
5
6
7
8
9
10
11
12
13
14
O getSlotsForFace retorna um array com os índices dos slots que podem ser interagidos a partir do lado determinado. Nesse caso, nós temos apenas um único slot (0), então nós retornamos um array com apenas aquele índice.
Da mesma forma, nós devemos modificar o método useItemOn para que ele realmente respeite o novo comportamento:
if (!duplicatorBlockEntity.canPlaceItemThroughFace(0, stack, hit.getDirection())) {
return InteractionResult.PASS;
}2
3
Agora, se nós tentarmos inserir itens a partir das laterais ao invés da parte cima, não vai funcionar!
Menus
Para acessar o novo bloco de contêiner pelo menu, assim como você faz com um baú, consulte o guia Menus de Contêiner.

