Deine erste Entität erstellen 26.1.2

Lerne, wie man eine einfache Entität registriert, ihr Ziele gibt, sie rendert, modelliert und animiert.

Entitäten sind im Spiel dynamische, interaktive Objekte, die nicht Teil des Terrain (wie Blöcke) sind. Entitäten können sich bewegen und auf unterschiedliche Wege mit der Welt interagieren. Einige Beispiele sind folgende:

• Villager, Pig, und Goat sind alles Beispiele eines Mob, der häufigste Typ einer Entität - etwas das lebt.
• Zombie und Skeleton sind Beispiele für ein Monster, eine Variante einer Entity, die feindlich zu einem Player ist.
• Minecart und Boat sind Beispiele für eine VehicleEntity, die eine spezielle Logik zur Akzeptierung von Spielereingaben besitzt.

Dieses Tutorial führt dich Schritt für Schritt durch die Erstellung eines benutzerdefinierten Mini-Golem. Diese Entität wird lustige Animationen haben. Es wird ein PathfinderMob, die Klasse, die von den meisten Mobs mit Wegfindung verwendet wird, wie beispielsweise Zombie und Villager, sein.

Deine erste Entität vorbereiten

Der erste Schritt bei der Erstellung einer benutzerdefinierten Entität besteht darin, dessen Klasse zu definieren und sie im Spiel zu registrieren.

Wir werden die Klasse MiniGolemEntity für unsere Entität erstellen und beginnen damit, ihr Attribute zu geben. Attribute bestimmen verschiedene Eigenschaften, darunter die maximale Gesundheit, die Geschwindigkeit der Bewegung und die Reichweite der Entität.

public class MiniGolemEntity extends PathfinderMob {
	public MiniGolemEntity(Level world) {
		this(ModEntityTypes.MINI_GOLEM, world);
	}

	public MiniGolemEntity(EntityType<? extends MiniGolemEntity> entityType, Level world) {
		super(entityType, world);
	}

	public static AttributeSupplier.Builder createCubeAttributes() {
		return PathfinderMob.createMobAttributes()
				.add(Attributes.MAX_HEALTH, 5)
				.add(Attributes.TEMPT_RANGE, 10)
				.add(Attributes.MOVEMENT_SPEED, 0.3);
	}

Um deine Entitäten zu registrieren, empfiehlt es sich, eine eigene Klasse mit dem Namen ModEntityTypes zu erstellen, in der du alle Entitätstypen registrierst, deren Größe festlegst und deren Attribute registrierst.

public class ModEntityTypes {
	public static final EntityType<MiniGolemEntity> MINI_GOLEM = register(
			"mini_golem",
			EntityType.Builder.<MiniGolemEntity>of(MiniGolemEntity::new, MobCategory.MISC)
					.sized(0.75f, 1.75f)
	);

	private static <T extends Entity> EntityType<T> register(String name, EntityType.Builder<T> builder) {
		ResourceKey<EntityType<?>> key = ResourceKey.create(Registries.ENTITY_TYPE, Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, name));
		return Registry.register(BuiltInRegistries.ENTITY_TYPE, key, builder.build(key));
	}

	public static void registerModEntityTypes() {
		ExampleMod.LOGGER.info("Registering EntityTypes for " + ExampleMod.MOD_ID);
	}

	public static void registerAttributes() {
		FabricDefaultAttributeRegistry.register(MINI_GOLEM, MiniGolemEntity.createCubeAttributes());
	}
}

Ziele hinzufügen

Ziele sind das System, das die Ziele einer Entität regelt und ihr ein definiertes Verhaltensmuster vorgibt. Ziele haben eine bestimmte Priorität: Ziele mit einem geringeren Wert werden gegenüber den Zielen mit einem höheren Wert priorisiert.

Um der Entität Ziele hinzuzufügen, musst du in der Klasse deiner Entität eine Methode registerGoals erstellen, die die Ziele für die Entität definiert.

@Override
protected void registerGoals() {
	this.goalSelector.addGoal(0, new TemptGoal(this, 1, Ingredient.of(Items.WHEAT), false));
	this.goalSelector.addGoal(1, new RandomStrollGoal(this, 1));
	this.goalSelector.addGoal(2, new LookAtPlayerGoal(this, Cow.class, 4));
	this.goalSelector.addGoal(3, new RandomLookAroundGoal(this));
}

INFO

1. TemptGoal - Die Entität wird von einem Spieler angezogen, der ein Item in der Hand hält.
2. RandomStrollGoal - Geht/wandert in der Welt.
3. LookAtPlayerGoal - Trotz des Namens akzeptiert dieses jede beliebige Entität. Wird hier verwendet, um die Entität Cow anzusehen.
4. RandomLookAroundGoal - Schaut in zufällige Richtungen.

Das Rendering erstellen

Unter Rendering versteht man den Prozess, bei dem Spieldaten wie Blöcke, Entitäten und Umgebungen in visuelle Darstellungen umgewandelt werden, die auf dem Bildschirm des Spielers angezeigt werden. Dabei geht es darum, festzulegen, wie Objekte beleuchtet, schattiert und texturiert werden.

INFO

Das Rendering von Entitäten erfolgt immer clientseitig. Der Server steuert die Logik und das Verhalten der Entität, während der Client für die Darstellung des Modells, der Textur und der Animationen der Entität zuständig ist.

Das Rendern umfasst mehrere Schritte, die jeweils eigene Klassen beinhalten, aber wir beginnen mit der Klasse EntityRenderState.

public class MiniGolemEntityRenderState extends LivingEntityRenderState {
}

Die im Renderzustand gespeicherten Daten dienen dazu, zu bestimmen, wie die Entität visuell dargestellt wird, einschließlich Animationszuständen wie Bewegungs- und Ruheverhalten.

Das Modell einrichten

Die Klasse MiniGolemEntityModel definiert, wie deine Entität aussieht indem sie dessen Form udn Teile beschreibt. Modelle werden in der Regel mit Tools von Drittanbietern wie Blockbench erstellt und nicht von Hand geschrieben. Dennoch wird in dieser Anleitung anhand eines praktischen Beispiels gezeigt, wie das funktioniert.

WARNING

Blockbench unterstützt mehrere Mappings (wie beispielsweise Mojang Mappings, Yarn und andere). Achte darauf, dass du die richtigen Mappings für deine Entwicklungsumgebung auswählst - in diesem Tutorial werden Mojang-Mappings verwendet.

Nicht übereinstimmende Mappings können bei der Integration von durch Blockbench generiertem Code zu Fehlern führen.

public class MiniGolemEntityModel extends EntityModel<MiniGolemEntityRenderState> {
	private final ModelPart head;
	private final ModelPart leftLeg;
	private final ModelPart rightLeg;

	public MiniGolemEntityModel(ModelPart root) {
		super(root);
		this.head = root.getChild(PartNames.HEAD);
		this.leftLeg = root.getChild(PartNames.LEFT_LEG);
		this.rightLeg = root.getChild(PartNames.RIGHT_LEG);
	}

Die Klasse MiniGolemEntityModel definiert die visuellen Modelle für unsere Mini-Golem Entität. Sie erbt von EntityModel und legt fest, wie die Körperteile der Entität (Körper, Kopf, linkes und rechtes Bein) benannt werden.

public static LayerDefinition getTexturedModelData() {
	MeshDefinition modelData = new MeshDefinition();
	PartDefinition root = modelData.getRoot();
	root.addOrReplaceChild(
			PartNames.BODY,
			CubeListBuilder.create().addBox(
					/* x: */ -6,
					/* y: */ -6,
					/* z: */ -6,
					/* width: */ 12,
					/* height: */ 12,
					/* depth: */ 12
			),
			PartPose.offset(0, 8, 0)
	);
	root.addOrReplaceChild(
			PartNames.HEAD,
			CubeListBuilder.create().texOffs(36, 0).addBox(-3, -6, -3, 6, 6, 6),
			PartPose.offset(0, 2, 0)
	);
	root.addOrReplaceChild(
			PartNames.LEFT_LEG,
			CubeListBuilder.create().texOffs(48, 12).addBox(-2, 0, -2, 4, 10, 4),
			PartPose.offset(-2.5f, 14, 0)
	);
	root.addOrReplaceChild(
			PartNames.RIGHT_LEG,
			CubeListBuilder.create().texOffs(48, 12).addBox(-2, 0, -2, 4, 10, 4),
			PartPose.offset(2.5f, 14, 0)
	);
	return LayerDefinition.create(modelData, 64, 32);
}

Diese Methode definiert das 3D-Modell des Mini-Golems, indem sie dessen Körper, Kopf und Beine als Quader erstellt, deren Positionen und Texturzuordnungen festlegt und eine LayerDefinition für das Rendering zurückgibt.

Jedes Teil wird mit einem Versatzpunkt versehen, der als Ursprung für alle auf dieses Teil angewendeten Transformationen dient. Alle anderen Koordinaten im Teil des Modells werden relativ zu diesem Versatzpunkt gemessen.

WARNING

Höhere Y-Werte im Modell entsprechen der Unterseite der Entität. Dies ist das Gegenteil im Vergleich zu den Koordinaten im Spiel.

Wir müssen nun im Client-Paket eine Klasse mit dem Namen ModEntityModelLayers erstellen. Diese Entität hat nur eine einzige Textur-Ebene, andere Entitäten können jedoch mehrere verwenden - denke an die zweite Haut-Ebene bei Entitäten wie dem Player oder an die Augen einer Spider.

public class ModEntityModelLayers {
	public static final ModelLayerLocation MINI_GOLEM = createMain("mini_golem");

	private static ModelLayerLocation createMain(String name) {
		return new ModelLayerLocation(Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, name), "main");
	}

	public static void registerModelLayers() {
		ModelLayerRegistry.registerModelLayer(ModEntityModelLayers.MINI_GOLEM, MiniGolemEntityModel::getTexturedModelData);
	}
}

Diese Klasse muss dann im Client-Initialisierer des Mods initialisiert werden.

public class ExampleModCustomEntityClient implements ClientModInitializer {
	@Override
	public void onInitializeClient() {
		ModEntityModelLayers.registerModelLayers();
	}
}

Die Textur einrichten

TIP

Die Größe der Textur sollte mit den Werten in LayerDefinition.create(modelData, 64, 32) übereinstimmen: 64 Pixel breit und 32 Pixel hoch. Wenn du eine Textur in einer anderen Größe benötigst, vergiss nicht, die Größe in LayerDefinition.create entsprechend anzupassen.

Jedes Teil des Modells bzw. jede Box erwartet an einer bestimmten Stelle ein Netz auf der Textur. Standardmäßig wird die Position 0, 0 (oben links) erwartet, dies lässt sich jedoch durch Aufruf der Funktion texOffs in CubeListBuilder ändern.

Als Beispiel kannst du diese Textur für assets/example-mod/textures/entity/mini_golem.png verwenden.

Textur herunterladen

Den Renderer erstellen

Ein Renderer einer Entität erlaubt es dir, deine Entität im Spiel anzusehen. Wir erstellen eine neue Klasse MiniGolemEntityRenderer, die Minecraft mitteilen wird, welche Textur, welches Modell und welchen Renderzustand für diese Entität verwendet werden sollen.

public class MiniGolemEntityRenderer extends MobRenderer<MiniGolemEntity, MiniGolemEntityRenderState, MiniGolemEntityModel> {
	private static final Identifier TEXTURE = Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "textures/entity/mini_golem.png");

	public MiniGolemEntityRenderer(EntityRendererProvider.Context context) {
		super(context, new MiniGolemEntityModel(context.bakeLayer(ModEntityModelLayers.MINI_GOLEM)), 0.375f); // 0.375 shadow radius
	}

	@Override
	public MiniGolemEntityRenderState createRenderState() {
		return new MiniGolemEntityRenderState();
	}

	@Override
	public Identifier getTextureLocation(MiniGolemEntityRenderState state) {
		return TEXTURE;
	}
}

Hier wird auch der Schattenradius festgelegt; für diese Entität wird er 0.375f sein.

Dieser Renderer muss dann in dem Client-Initialisierer des Mods registriert werden.

EntityRenderers.register(ModEntityTypes.MINI_GOLEM, MiniGolemEntityRenderer::new);

Laufanimationen hinzufügen

Der folgende Code kann der Klasse MiniGolemEntityModel hinzugefügt werden, um der Entität eine Laufanimation zu geben.

	@Override
	public void setupAnim(MiniGolemEntityRenderState state) {
		super.setupAnim(state);

			this.head.xRot = state.xRot * Mth.RAD_TO_DEG;
			this.head.yRot = state.yRot * Mth.RAD_TO_DEG;
			float limbSwingAmplitude = state.walkAnimationSpeed;
			float limbSwingAnimationProgress = state.walkAnimationPos;
			this.leftLeg.xRot = Mth.cos(limbSwingAnimationProgress * 0.2f + Mth.PI) * 1.4f * limbSwingAmplitude;
			this.rightLeg.xRot = Mth.cos(limbSwingAnimationProgress * 0.2f) * 1.4f * limbSwingAmplitude;
	}
}

Um zu starten, wende zunächst die Drehung (Yaw) und Neigung (Pitch) auf das Kopfmodellteil an.

Anschließend wenden wir die Laufanimation auf die Teile des Beinmodells an. Wir verwenden die Funktion cos, um den allgemeinen Beinschwung-Effekt zu erzeugen, und transformieren dann die Kosinuswelle, um die richtige Schwunggeschwindigkeit und Amplitude zu erhalten.

• Die Konstante 0.2 in der Formel bestimmt die Frequenz der Kosinuswelle (wie schnell die Beine schwingen). Höhere Werte führen zu einer höheren Frequenz.
• Die Konstante 0.4 in der Formel bestimmt die Amplitude der Kosinuswelle (wie weit die Beine schwingen). Höhere Werte führen zu einer höheren Amplitude.
• Die Variable limbSwingAmplitude beeinflusst die Amplitude auf dieselbe Weise wie die Konstante 1.4. Diese Variable ändert sich in Abhängigkeit von der Geschwindigkeit der Entität, sodass die Beine stärker schwingen, wenn sich die Entität schneller bewegt, und weniger stark oder gar nicht schwingen, wenn sich die Entität langsamer bewegt oder stillsteht.
• Die Konstante Mth.PI für den linken Schenkel verschiebt die Kosinuswelle um eine halbe Phase, sodass das linke Bein in die entgegengesetzte Richtung zum rechten Bein schwingt.

Du kannst diese Werte in einem Diagramm darstellen, um zu sehen, wie sie aussehen:

Die blaue Kurve steht für das linke Bein und die braune für das rechte. Die horizontale x-Achse stellt die Zeit dar, und die y-Achse gibt den Winkel der Beinglieder an.

Probier ruhig mal aus, mit den Konstanten in Desmos zu experimentieren, um zu sehen, wie sie sich auf die Kurve auswirken.

Wenn du dir das im Spiel ansiehst, hast du nun alles, was du brauchst, um die Entität mit /summon example-mod:mini_golem zu erschaffen!

Daten zu der Entität hinzufügen

Um Daten an einer Entität zu speichern, ist der normale Weg einfach ein Feld der Klasse der Entität hinzuzufügen.

Manchmal müssen Daten aus der serverseitigen Entität mit der clientseitigen Entität synchronisiert werden. Weitere Informationen zur Client-Server-Architektur findest du auf der Netzwerkseite. Dazu können wir synchronisierte Daten [sic] verwenden, indem wir dafür einen EntityDataAccessor definieren.

In unserem Fall soll unsere Entität von Zeit zu Zeit tanzen; daher müssen wir einen Tanzzustand erstellen, der zwischen den Clients synchronisiert ist, damit er später animiert werden kann. Die Abklingzeit für das Tanzen muss jedoch nicht mit dem Client synchronisiert werden, da die Animation vom Server ausgelöst wird.

private static final EntityDataAccessor<Boolean> DANCING = SynchedEntityData.defineId(MiniGolemEntity.class, EntityDataSerializers.BOOLEAN);
private int dancingTimeLeft;

@Override
protected void defineSynchedData(SynchedEntityData.Builder builder) {
	super.defineSynchedData(builder);
	builder.define(DANCING, false);
}

public boolean isDancing() {
	return entityData.get(DANCING);
}

private void setDancing(boolean dancing) {
	entityData.set(DANCING, dancing);
}

@Override
public void tick() {
	super.tick();

	if (!level().isClientSide()) {
		if (this.isDancing()) {
			if (this.dancingTimeLeft-- <= 0) {
				this.setDancing(false);
			}
		} else {
			if (this.random.nextInt(1000) == 0) {
				this.setDancing(true);
				this.dancingTimeLeft = 100 + this.random.nextInt(100);
			}
		}
	}
}

Wie du sehen kannst, haben wir eine Tick-Methode hinzugefügt, um den Tanzzustand zu steuern.

Daten in NBT speichern

Für persistente Daten, die nach dem Schließen des Spiels gespeichert werden können, werden wir die Methoden addAdditionalSaveData und readAdditionalSaveData in MiniGolemEntity überschreiben. Wir können dies verwenden, um die übrige Zeit der Tanzanimation zu speichern.

@Override
protected void addAdditionalSaveData(ValueOutput valueOutput) {
	super.addAdditionalSaveData(valueOutput);
	valueOutput.putInt("dancing_time_left", this.dancingTimeLeft);
}

@Override
protected void readAdditionalSaveData(ValueInput valueInput) {
	super.readAdditionalSaveData(valueInput);
	this.dancingTimeLeft = valueInput.getInt("dancing_time_left").orElse(0);
	this.setDancing(this.dancingTimeLeft > 0);
}

Wenn die Entität nun geladen wird, stellt sie den Zustand wieder her.

Animationen hinzufügen

Der erste Schritt, um der Entität eine Animation hinzuzufügen, besteht darin, den Animationszustand in der Klasse der Entität hinzuzufügen. Wir werden einen Animationszustand erstellen, der verwendet werden wird, um die Entität zum Tanzen zu bringen.

public final AnimationState dancingAnimationState = new AnimationState();

@Override
public void onSyncedDataUpdated(EntityDataAccessor<?> data) {
	super.onSyncedDataUpdated(data);

	if (data == DANCING) {
		this.dancingAnimationState.animateWhen(this.isDancing(), this.tickCount);
	}
}

Wir haben die Methode onSyncedDataUpdated überschrieben. Dies wird immer dann aufgerufen, wenn synchronisierte Daten sowohl auf dem Server als auch auf dem Client aktualisiert werden. Die if-Anweisung prüft, ob es sich bei den aktualisierten synchronisierten Daten um die tanzenden synchronisierten Daten handelt.

Jetzt werden wir mit der Animation selbst fortfahren. Wir werden die Klasse MiniGolemAnimations erstellen und eine AnimationDefinition hinzufügen, um festzulegen, wie die Animation auf die Entität angewendet wird.

public class MiniGolemAnimations {
	public static final AnimationDefinition DANCING = AnimationDefinition.Builder.withLength(1)
			.looping()
			.addAnimation(PartNames.HEAD, new AnimationChannel(
					AnimationChannel.Targets.ROTATION,
					new Keyframe(0, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.2f, KeyframeAnimations.degreeVec(0, 0, 45), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.4f, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.6f, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.8f, KeyframeAnimations.degreeVec(0, 0, -45), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(1, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR)
			))
			.addAnimation(PartNames.LEFT_LEG, new AnimationChannel(
					AnimationChannel.Targets.ROTATION,
					new Keyframe(0, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.2f, KeyframeAnimations.degreeVec(0, 0, 45), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.4f, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR)
			))
			.addAnimation(PartNames.RIGHT_LEG, new AnimationChannel(
					AnimationChannel.Targets.ROTATION,
					new Keyframe(0.5f, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.7f, KeyframeAnimations.degreeVec(0, 0, -45), AnimationChannel.Interpolations.LINEAR),
					new Keyframe(0.9f, KeyframeAnimations.degreeVec(0, 0, 0), AnimationChannel.Interpolations.LINEAR)
			))
			.build();
}

Hier geschieht einiges; beachte die folgenden Schlüsselpunkte:

• withLength(1) sorgt dafür, dass die Animation eine Sekunde dauert.
• looping() sorgt dafür, dass die Animation fortlaufend wiederholt wird.
• Es folgt eine Reihe von addAnimation-Aufrufen, die individuelle Animationen für einzelne Modellteile hinzufügen. Hier haben wir verschiedene Animationen, die auf den Kopf, das linke Bein und das rechte Bein abzielen.
  • Jede Animation zielt auf eine bestimmte Eigenschaft dieses Modellteils ab; in unserem Fall ändern wir in jedem Fall die Drehung des Modellteils.
  • Eine Animation besteht aus einer Liste von Keyframes. Wenn der Zeitpunkt (die verstrichene Zeit in Sekunden) der Animation mit einem dieser Keyframes übereinstimmt, entspricht der Wert der betreffenden Eigenschaft dem Wert, den wir für diesen Keyframe festgelegt haben (in unserem Fall die Drehung).
  • Liegt der Zeitpunkt zwischen unseren Keyframes, wird der Wert zwischen den beiden benachbarten Keyframes interpoliert (überblendet).
  • Wir haben lineare Interpolation verwendet, die die einfachste Methode ist und den Wert (in unserem Fall die Drehung des Modellteils) von einem Keyframe zum nächsten mit konstanter Geschwindigkeit ändert. Vanilla bietet außerdem Catmull-Rom-Spline-Interpolation, wodurch ein flüssigerer Übergang zwischen den Keyframes erzielt wird.
  • Modder können auch benutzerdefinierte Interpolationstypen erstellen.

Um unseren Animationszustand dem Renderer zur Verfügung zu stellen, speichern wir eine Kopie davon in unserem MiniGolemEntityRenderState.

public final AnimationState dancingAnimationState = new AnimationState();

Um die Kopie durchzuführen, überschreiben wir die Methode extractRenderState im Entity-Renderer.

@Override
public void extractRenderState(MiniGolemEntity entity, MiniGolemEntityRenderState state, float tickProgress) {
	super.extractRenderState(entity, state, tickProgress);
	state.dancingAnimationState.copyFrom(entity.dancingAnimationState);
}

Zum Schluss, lasst uns die Animation mit dem Modell verbinden:

private final KeyframeAnimation dancing;

public MiniGolemEntityModel(ModelPart root) {
	// ...
	this.dancing = MiniGolemAnimations.DANCING.bake(root);
}
@Override
public void setupAnim(MiniGolemEntityRenderState state) {
	super.setupAnim(state);

	if (state.dancingAnimationState.isStarted()) {
		this.dancing.apply(state.dancingAnimationState, state.ageInTicks);
	} else {
		// ... the leg swing animation code from before
		this.head.xRot = state.xRot * Mth.RAD_TO_DEG;
		this.head.yRot = state.yRot * Mth.RAD_TO_DEG;
		float limbSwingAmplitude = state.walkAnimationSpeed;
		float limbSwingAnimationProgress = state.walkAnimationPos;
		this.leftLeg.xRot = Mth.cos(limbSwingAnimationProgress * 0.2f + Mth.PI) * 1.4f * limbSwingAmplitude;
		this.rightLeg.xRot = Mth.cos(limbSwingAnimationProgress * 0.2f) * 1.4f * limbSwingAmplitude;
	}
}

Während die Animation läuft, wenden wir die Animation an, andernfalls verwenden wir den alten Code für die Beinanimation.

Das Spawn-Ei hinzufügen

Um ein Spawn-Ei für die Mini-Golem Entität hinzuzufügen, lies den vollständigen Artikel unter ein Spawn-Ei erstellen.