Block Entitäten

Block Entitäten sind ein Weg für Blöcke zusätzliche Daten, die nicht Teil des Blockzustands sind, zu speichern: Inventarinhalte, benutzerdefinierter Name und so weiter. Minecraft nutzt Block Entitäten für Blöcke, wie Kisten, Öfen und Befehlsblöcke.

Als Beispiel werden wir einen Block erstellen, der zählt, wie oft er mit der rechten Maustaste angeklickt wurde.

Erstellen der Block Entität

Damit Minecraft die neuen Block Entitäten erkennt und lädt, müssen wir einen Block Entität Typen erstellen. Das machen wir, indem wir die BlockEntity Klasse erweitern und in einer neuen ModBlockEntities Klasse registrieren.

public class CounterBlockEntity extends BlockEntity {
	public CounterBlockEntity(BlockPos pos, BlockState state) {
		super(ModBlockEntities.COUNTER_BLOCK_ENTITY, pos, state);
	}

}

Wenn eine BlockEntity registriert wird, gibt es einen BlockEntityType zurück, wie bei dem COUNTER_BLOCK_ENTITY, welches wir oben benutzt haben:

public static final BlockEntityType<CounterBlockEntity> COUNTER_BLOCK_ENTITY =
		register("counter", CounterBlockEntity::new, ModBlocks.COUNTER_BLOCK);

private static <T extends BlockEntity> BlockEntityType<T> register(String name,
																BlockEntityType.BlockEntitySupplier<? extends T> entityFactory,
																Block... blocks) {
	ResourceLocation id = ResourceLocation.fromNamespaceAndPath(ExampleMod.MOD_ID, name);
	return Registry.register(BuiltInRegistries.BLOCK_ENTITY_TYPE, id, BlockEntityType.Builder.<T>of(entityFactory, blocks).build());
}

TIP

Man beachte, dass der Konstruktor von der CounterBlockEntity zwei Parameter benötigt, der Konstruktor von der BlockEntity jedoch drei: den BlockEntityType, BlockPos und den BlockState. Wenn wir den BlockEntityType nicht hart kodiert hätten, würde die Klasse ModBlockEntities nicht kompiliert werden! Das liegt daran, dass die BlockEntityFactory, die ein funktionales Interface ist, eine Funktion beschreibt, die nur zwei Parameter benötigt, genau wie unser Konstruktor.

Erstellen des Blocks

Um als Nächstes die Block Entität zu nutzen, brauchen wir einen Block, der EntityBlock implementiert. Lass uns einen erstellen und CounterBlock nennen.

TIP

Es gibt zwei Wege, um das zu machen:

• Einen Block erstellen, der BaseEntityBlock erweitert und die newBlockEntity Methode implementiert (und die getRenderType Methode, da BaseEntityBlock den Block standardmäßig Unsichtbar macht)
• Einen Block erstellen, der EntityBlock implementiert und die newBlockEntity Methode überschreibt

Wir werden in diesem Beispiel den ersten Weg nutzen, da BaseEntityBlock ein paar nützliche Funktionen anbietet.

public class CounterBlock extends BaseEntityBlock {
	public CounterBlock(Properties settings) {
		super(settings);
	}

	@Override
	protected MapCodec<? extends BaseEntityBlock> codec() {
		return simpleCodec(CounterBlock::new);
	}

	@Override
	protected RenderShape getRenderShape(BlockState state) {
		return RenderShape.MODEL;
	}

	@Nullable
	@Override
	public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
		return new CounterBlockEntity(pos, state);
	}

}

Da wir die BaseEntityBlock Klasse erweitern, müssen wir auch die codec Methode implementieren, was aber recht leicht ist.

Im Gegensatz zu Blöcken, die Singletons sind, wird für jede Instanz des Blocks eine neue Blockentität erstellt. Dies geschieht mit der Methode newBlockEntity, die die Position und den BlockState entgegennimmt und ein BlockEntity zurückgibt, oder null, wenn es keins geben sollte.

Vergiss nicht, den Block in der Klasse ModBlocks zu registrieren, genau wie in der Anleitung Deinen ersten Block erstellen:

public static final Block COUNTER_BLOCK = register(
		new CounterBlock(BlockBehaviour.Properties.of()), "counter_block", true
);

Nutzen der Block Entität

Jetzt, da wir eine Blockentität haben, können wir sie verwenden, um die Anzahl der Rechtsklicks auf den Block zu speichern. Dafür werden wir der Klasse CounterBlockEntity ein Feld clicks hinzufügen:

private int clicks = 0;
public int getClicks() {
	return clicks;
}

public void incrementClicks() {
	clicks++;
	setChanged();
}

Die Methode markDirty, die in incrementClicks verwendet wird, teilt dem Spiel mit, dass die Daten dieser Entität aktualisiert wurden; dies wird nützlich sein, wenn wir die Methoden hinzufügen, um den Zähler zu serialisieren und ihn aus der Speicherdatei zurückzuladen.

Als Nächstes müssen wir dieses Feld jedes Mal erhöhen, wenn der Block mit der rechten Maustaste angeklickt wird. Dies geschieht indem die Methode onUse in der Klasse CounterBlock überschrieben wird:

@Override
protected InteractionResult useWithoutItem(BlockState state, Level world, BlockPos pos, Player player, BlockHitResult hit) {
	if (!(world.getBlockEntity(pos) instanceof CounterBlockEntity counterBlockEntity)) {
		return super.useWithoutItem(state, world, pos, player, hit);
	}

	counterBlockEntity.incrementClicks();
	player.displayClientMessage(Component.literal("You've clicked the block for the " + counterBlockEntity.getClicks() + "th time."), true);

	return InteractionResult.SUCCESS;
}

Da die BlockEntity nicht an die Methode übergeben wird, verwenden wir world.getBlockEntity(pos), und wenn die BlockEntity nicht gültig ist, kehren wir aus der Methode zurück.

Speichern und Laden von Daten

Da wir nun einen funktionierenden Block haben, sollten wir dafür sorgen, dass der Zähler zwischen den Neustarts des Spiels nicht zurückgesetzt wird. Dies geschieht durch Serialisierung in NBT, wenn das Spiel speichert, und Deserialisierung, wenn es geladen wird.

Die Serialisierung erfolgt mit der Methode saveAdditional:

@Override
protected void saveAdditional(CompoundTag nbt, HolderLookup.Provider registryLookup) {
	nbt.putInt("clicks", clicks);

	super.saveAdditional(nbt, registryLookup);
}

Hier fügen wir die Felder hinzu, die in dem übergebenen NbtCompound gespeichert werden sollen: im Fall des Zählerblocks ist das das Feld clicks.

Das Lesen ist ähnlich, aber anstatt in dem NbtCompound zu speichern, holt man sich die Werte, die man vorher gespeichert hat, und speichert sie in den Feldern der BlockEntity:

@Override
protected void loadAdditional(CompoundTag nbt, HolderLookup.Provider registryLookup) {
	super.loadAdditional(nbt, registryLookup);

	clicks = nbt.getInt("clicks");
}

Wenn wir nun speichern und das Spiel neu laden, sollte der Zählerblock dort weitermachen, wo er beim Speichern aufgehört hat.

Ticker

Das Interface EntityBlock definiert auch eine Methode namens getTicker, mit der für jede Instanz des Blocks bei jedem Tick Code ausgeführt werden kann. Wir können das implementieren, indem wir eine statische Methode erstellen, die als BlockEntityTicker verwendet wird:

Die Methode getTicker sollte auch prüfen, ob der übergebene BlockEntityType derselbe ist wie der, den wir verwenden, und wenn ja, die Funktion zurückgeben, die bei jedem Tick aufgerufen wird. Glücklicherweise gibt es eine Hilfsfunktion, die diese Prüfung in BaseEntityBlock durchführt:

@Nullable
@Override
public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level world, BlockState state, BlockEntityType<T> type) {
	return createTickerHelper(type, ModBlockEntities.COUNTER_BLOCK_ENTITY, CounterBlockEntity::tick);
}

CounterBlockEntity::tick ist ein Verweis auf die statische Methode tick, die wir in der Klasse CounterBlockEntity erstellen sollten. Eine solche Strukturierung ist nicht erforderlich, aber es ist eine gute Praxis, um den Code sauber und übersichtlich zu halten.

Nehmen wir an, wir wollen, dass der Zähler nur alle 10 Ticks (2 Mal pro Sekunde) erhöht werden kann. Wir können dies tun, indem wir der Klasse CounterBlockEntity ein Feld ticksSinceLast hinzufügen und es bei jedem Tick erhöhen:

public static void tick(Level world, BlockPos blockPos, BlockState blockState, CounterBlockEntity entity) {
	entity.ticksSinceLast++;
}

Vergiss nicht, dieses Feld zu serialisieren und zu deserialisieren!

Jetzt können wir ticksSinceLast verwenden, um zu prüfen, ob der Zähler in incrementClicks erhöht werden kann:

if (ticksSinceLast < 10) return;
ticksSinceLast = 0;

TIP

Wenn die Blockentität nicht zu ticken scheint, überprüfe den Registrierungscode! Es sollte die Blöcke, die für diese Entität gültig sind, an den BlockEntityType.Builder, übergeben, sonst wird eine Warnung in der Konsole ausgegeben:

[13:27:55] [Server thread/WARN] (Minecraft) Block entity example-mod:counter @ BlockPos{x=-29, y=125, z=18} state Block{example-mod:counter_block} invalid for ticking: