Benutzerdefinierte Rezepttypen 26.2

Lerne, wie du einen benutzerdefinierten Rezepttyp erstellst.

WARNING

Wenn du versuchst, einen benutzerdefinierten Rezepttyp für einen Vanilla-Arbeitsplatz hinzuzufügen, lies bitte den Abschnitt Vanilla-Rezepte erweitern.

Benutzerdefinierte Rezepttypen bieten die Möglichkeit, datengetriebene Rezepte für die benutzerdefinierten Herstellungsmechaniken deines Mods zu erstellen. Als Beispiel erstellen wir einen Rezepttyp für einen Aufwertungsblock, ähnlich wie bei einem Schmiedetisch.

Erstellen einer Eingabeklasse für das Rezept

Bevor wir mit der Erstellung unseres Rezepts beginnen können, benötigen wir eine Implementierung von RecipeInput, die die Eingabeitems im Inventar unseres Blocks aufnehmen kann. Wir möchten, dass ein Aufwertungsrezept zwei Eingabeitems enthält: Ein Basisitem, das aufgewertet werden soll, und die Aufwertung selbst.

public record UpgradingRecipeInput(ItemStack baseItem, ItemStack upgradeItem) implements RecipeInput {
	@Override
	public ItemStack getItem(int index) {
		return switch (index) {
			case 0 -> this.baseItem;
			case 1 -> this.upgradeItem;
			default -> ItemStack.EMPTY;
		};
	}

	@Override
	public int size() {
		return 2;
	}
}

INFO

Alternativ könnten wir die beiden ItemStacks durch eine List ersetzen. Dies gilt auch für die anderen Klassen, die die beiden Ingredient- oder ItemStack-Objekte verwenden.

Die Rezeptklasse erstellen

Da wir nun eine Möglichkeit haben, die Eingabeitems zu speichern, können wir unsere Recipe-Implementierung erstellen. Implementierungen dieser Klasse stellen ein einzelnes Rezept dar, das in einem Datenpaket definiert ist. Sie sind dafür verantwortlich, die Zutaten und Vorgaben des Rezepts zu überprüfen und das in das Ergebnis zusammenzubauen.

Beginnen wir damit, das Ergebnis und die Zutaten des Rezepts zu definieren.

public class UpgradingRecipe implements Recipe<UpgradingRecipeInput> {
	private final ItemStackTemplate result;
	private final Ingredient baseItem;
	private final Ingredient upgradeItem;

	public UpgradingRecipe(ItemStackTemplate result, Ingredient baseItem, Ingredient upgradeItem) {
		this.baseItem = baseItem;
		this.upgradeItem = upgradeItem;
		this.result = result;
	}

	public ItemStackTemplate getResult() {
		return this.result;
	}

	public Ingredient getBaseItem() {
		return this.baseItem;
	}

	public Ingredient getUpgradeItem() {
		return this.upgradeItem;
	}
}

Beachte, dass wir für unsere Eingaben Ingredient-Objekte verwenden. Dadurch kann unser Rezept mehrere Items beliebig austauschbar verarbeiten. (Siehe auch: Zutaten-Seite aus der NeoForge-Dokumentation im Abschnitt Ressourcen.)

Die Methoden implementieren

Als Nächstes implementieren wir die Methoden aus dem Rezept-Interface. Die Interessanten sind matches und assemble. Die Methode matches prüft, ob die Eingabeitems aus unserer RecipeInput-Implementierung mit unseren Zutaten übereinstimmen. Die Methode assemble erstellt dann den resultierenden ItemStack.

Um zu prüfen, ob die Zutaten übereinstimmen, können wir die Methode test unserer Zutaten verwenden.

@Override
public boolean matches(UpgradingRecipeInput recipeInput, Level level) {
	return this.baseItem.test(recipeInput.baseItem()) && this.upgradeItem.test(recipeInput.upgradeItem());
}

@Override
public ItemStack assemble(UpgradingRecipeInput recipeInput) {
	return this.result.create();
}

Erstellen eines Rezept-Serialisierers

Der Rezept-Serializer verwendet einen MapCodec, um das Rezept aus JSON zu lesen, und einen StreamCodec, um es über das Netzwerk zu senden.

Wir werden RecordCodecBuilder#mapCodec verwenden, um einen Map-Codec für unser Rezept zu erstellen. Dadurch können wir die vorhandenen Codecs von Minecraft in unsere eigenen integrieren:

public static final MapCodec<UpgradingRecipe> CODEC = RecordCodecBuilder.mapCodec(instance ->
				instance.group(
								ItemStackTemplate.CODEC.fieldOf("result").forGetter(UpgradingRecipe::getResult),
								Ingredient.CODEC.fieldOf("baseItem").forGetter(UpgradingRecipe::getBaseItem),
								Ingredient.CODEC.fieldOf("upgradeItem").forGetter(UpgradingRecipe::getUpgradeItem)
				).apply(instance, UpgradingRecipe::new)
);

Der Stream-Codec kann auf ähnliche Weise mit StreamCodec#composite erstellt werden:

public static final StreamCodec<RegistryFriendlyByteBuf, UpgradingRecipe> STREAM_CODEC = StreamCodec.composite(
				ItemStackTemplate.STREAM_CODEC,
				UpgradingRecipe::getResult,
				Ingredient.CONTENTS_STREAM_CODEC,
				UpgradingRecipe::getBaseItem,
				Ingredient.CONTENTS_STREAM_CODEC,
				UpgradingRecipe::getUpgradeItem,
				UpgradingRecipe::new
);

Nun registrieren wir den Rezept-Serializer sowie einen Rezepttyp. Das kannst du im Initialisierer deines Mods tun oder in einer separaten Klasse, deren Methode vom Initialisierer deines Mods aufgerufen wird:

public static final RecipeSerializer<UpgradingRecipe> UPGRADING_RECIPE_SERIALIZER = Registry.register(
				BuiltInRegistries.RECIPE_SERIALIZER,
				Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "upgrading"),
				new RecipeSerializer<>(UpgradingRecipe.CODEC, UpgradingRecipe.STREAM_CODEC)
);

public static final RecipeType<UpgradingRecipe> UPGRADING_RECIPE_TYPE = Registry.register(
				BuiltInRegistries.RECIPE_TYPE,
				Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "upgrading"),
				new RecipeType<UpgradingRecipe>() { }
);

Zurück zu unserer Rezeptklasse: Wir können nun die Methoden hinzufügen, die die soeben registrierten Objekte zurückgeben:

@Override
public RecipeSerializer<? extends Recipe<UpgradingRecipeInput>> getSerializer() {
	return ExampleModRecipes.UPGRADING_RECIPE_SERIALIZER;
}

@Override
public RecipeType<? extends Recipe<UpgradingRecipeInput>> getType() {
	return ExampleModRecipes.UPGRADING_RECIPE_TYPE;
}

Um unseren benutzerdefinierten Rezepttyp zu vervollständigen, müssen wir nur noch die verbleibenden Methoden placementInfo, showNotification, group und recipeBookCategory implementieren, die vom Rezeptbuch verwendet werden, um unser Rezept auf einem Bildschirm zu platzieren. Vorerst geben wir einfach PlacementInfo.NOT_PLACEABLE und null zurück, da das Rezeptbuch nicht ohne Weiteres auf modifizierte Arbeitsplätze ausgeweitet werden kann. Außerdem werden wir die Methode isSpecial überschreiben, sodass sie true zurückgibt, um zu verhindern, dass bestimmte andere, mit dem Rezeptbuch zusammenhängende Logik ausgeführt wird und Fehler protokolliert.

@Override
public @Nullable RecipeBookCategory recipeBookCategory() {
	return null;
}

@Override
public PlacementInfo placementInfo() {
	return PlacementInfo.NOT_PLACEABLE;
}

@Override
public boolean isSpecial() {
	return true;
}

@Override
public boolean showNotification() {
	return true;
}

@Override
public String group() {
	return "upgrading";
}

Ein Rezept erstellen

Unser Rezepttyp funktioniert jetzt, aber es fehlen noch zwei wichtige Dinge: Ein Rezept für unseren Rezepttyp und eine Möglichkeit, es herzustellen.

Lasst uns zuerst ein Rezept erstellen. Erstelle in deinem Ordner resources im Verzeichnis data/example-mod/recipe eine Datei mit der Dateiendung .json. Jede JSON-Datei für ein Rezept enthält einen Schlüssel "type", der auf den Rezept-Serialisierer des jeweiligen Rezepts verweist. Die übrigen Schlüssel werden durch den Codec des jeweiligen Rezept-Serialisierers definiert.

In unserem Fall sieht eine gültige Rezeptdatei wie folgt aus:

{
  "type": "example-mod:upgrading",
  "baseItem": "minecraft:iron_pickaxe",
  "upgradeItem": "minecraft:diamond",
  "result": {
    "id": "minecraft:diamond_pickaxe"
  }
}

Rezeptsynchronisierung

INFO

Dieser Abschnitt ist optional und nur erforderlich, wenn du möchtest, dass die Clients über Rezepte informiert werden.

Wie bereits erwähnt, werden Rezepte vollständig auf dem logischen Server verarbeitet. In manchen Fällen muss ein Client jedoch wissen, welche Rezepte es gibt - ein Beispiel aus Vanilla sind Steinsägen, das die verfügbaren Rezeptoptionen für eine bestimmte Zutat anzeigen muss. Außerdem laufen die Plugins bestimmter Rezeptbetrachter, darunter JEI, auf dem logischen Client, sodass du die Rezept-Synchronisations-API von Fabric verwenden musst.

Um deine Rezepte zu synchronisieren, rufe einfach RecipeSynchronization.synchronizeRecipeSerializer in deinem Mod-Initialisierer auf und gib den Rezept-Serialisierer deines Mods an:

RecipeSynchronization.synchronizeRecipeSerializer(UPGRADING_RECIPE_SERIALIZER);

Nach der Synchronisierung können die Rezepte jederzeit über den Rezeptmanager auf Client-Ebene abgerufen werden:

clientLevel.recipeAccess().getSynchronizedRecipes().getAllOfType(ExampleModRecipes.UPGRADING_RECIPE_TYPE);

Arbeitsplätze

Möchtest du einen benutzerdefinierten Arbeitsplatz erstellen, der zu deinem Rezepttyp passt? Siehe Arbeitsplätze.