Власні типи рецептів 1.21.11

Дізнайтеся, як створити власний тип рецепта.

WARNING

Ця сторінка написана для версії 1.21.11. Документація для старіших версій може бути неповною.

Власні типи рецептів — це спосіб створювати керовані даними рецепти для власної механіки майстрування вашого мода. Як приклад, ми створимо тип рецепта для блока покращувача, подібного до ковальського стола.

Створення класу введення рецептів

Перш ніж ви зможете почати створювати наш рецепт, вам потрібна реалізація RecipeInput, яка може зберігати вхідні предмети в інвентарі нашого блока. Ми хочемо, щоб рецепт покращення мав два вхідні предмети: базовий покращуваний предмет та саме покращення.

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

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

Створення класу рецепта

Тепер, коли у нас є спосіб зберігати вхідні предмети, ми можемо створити нашу реалізацію Recipe. Реалізації цього класу представляють окремий рецепт, визначений у пакеті даних. Вони несуть відповідальність за перевірку інгредієнтів і вимог рецепта, а також за поєднання цього в результат.

Почнемо з визначення результату та інгредієнтів рецепта.

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

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

	public ItemStack getResult() {
		return result;
	}

	public Ingredient getBaseItem() {
		return baseItem;
	}

	public Ingredient getUpgradeItem() {
		return upgradeItem;
	}
}

Зверніть увагу, як ми використовуємо об’єкти Ingredient для наших вхідних предметів. Це дозволяє нашому рецепту приймати кілька предметів взаємозамінно.

Реалізація методів

Далі запровадимо методи з інтерфейсу рецептів. Цікавими є методи matches і assemble. Метод matches перевіряє, чи вхідні предмети з нашої реалізації RecipeInput відповідають нашим інгредієнтам. Потім метод assemble створює кінцевий ItemStack.

Щоб перевірити, чи збігаються інгредієнти, ми можемо використати метод test наших інгредієнтів.

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

@Override
public ItemStack assemble(UpgradingRecipeInput recipeInput, HolderLookup.Provider provider) {
	return result.copy();
}

Створення серіалізатора рецептів

Серіалізатор рецептів використовує MapCodec для читання рецепта з JSON і StreamCodec для надсилання його через мережу.

Ми використаємо RecordCodecBuilder#mapCodec, щоб створити мапу кодека для нашого рецепта. Це дозволяє нам об’єднати наявні кодеки Minecraft у наші власні:

public class UpgradingRecipeSerializer implements RecipeSerializer<UpgradingRecipe> {
	public static final MapCodec<UpgradingRecipe> CODEC = RecordCodecBuilder.mapCodec(instance ->
					instance.group(
									ItemStack.STRICT_CODEC.fieldOf("result").forGetter(UpgradingRecipe::getResult),
									Ingredient.CODEC.fieldOf("baseItem").forGetter(UpgradingRecipe::getBaseItem),
									Ingredient.CODEC.fieldOf("upgradeItem").forGetter(UpgradingRecipe::getUpgradeItem)
					).apply(instance, UpgradingRecipe::new)
	);
}

Кодек потоку можна створити подібним чином за допомогою StreamCodec#composite:

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

Використаймо ці кодеки для реалізації методів із RecipeSerializer:

@Override
public MapCodec<UpgradingRecipe> codec() {
	return CODEC;
}

@Override
public StreamCodec<RegistryFriendlyByteBuf, UpgradingRecipe> streamCodec() {
	return STREAM_CODEC;
}

Тепер ми зареєструємо серіалізатор рецепта, а також тип рецепта. Ви можете зробити це в ініціалізаторі вашого мода або в окремому класі за допомогою методу, викликаного ініціалізатором вашого мода:

public static final UpgradingRecipeSerializer UPGRADING_RECIPE_SERIALIZER = Registry.register(
				BuiltInRegistries.RECIPE_SERIALIZER,
				Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, "upgrading"),
				new UpgradingRecipeSerializer()
);

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

Повертаючись до нашого класу рецептів, тепер ми можемо додати методи, які повертають щойно зареєстровані об’єкти:

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

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

Щоб завершити наш власний тип рецепта, нам просто потрібно реалізувати інші методи placementInfo і recipeBookCategory, які використовуються книгою рецептів для розміщення нашого рецепта на екрані. Наразі ми просто повернемо PlacementInfo.NOT_PLACEABLE і null, оскільки книгу рецептів не можна легко розширити до модових робочих станків. Ми також перевизначимо isSpecial, щоб повернути true, щоб запобігти запуску й реєстрації помилок деякої іншої логіки, пов’язаної з книгою рецептів.

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

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

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

Створення рецепта

Наш тип рецепта зараз працює, але нам все ще бракує двох важливих речей: рецепта для нашого типу рецепта та способу його створення.

Спочатку створимо рецепт. У теці resources створіть файл у data/example-mod/recipe з розширенням .json. Кожен json-файл рецепта має ключ "type", який посилається на серіалізатор рецепта. Інші ключі визначаються кодеком цього серіалізатора рецепта.

У нашому випадку дійсний файл рецепта виглядає так:

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

Створення меню

INFO

Подробиці про створення меню див. у розділі меню контейнерів.

Щоб ми могли створити наш рецепт в інтерфейсі, ми створимо блок із меню:

public class UpgradingMenu extends AbstractContainerMenu {
	private final Container input = new SimpleContainer(2) {
		@Override
		public void setChanged() {
			super.setChanged();
			slotsChanged(this);
		}
	};

	private final ResultContainer output = new ResultContainer();

	private final Level level;

	public UpgradingMenu(int i, Inventory inventory) {
		super(ExampleModRecipes.UPGRADING_MENU_TYPE, i);

		this.level = inventory.player.level();

		addSlot(new Slot(input, 0, 27, 47));
		addSlot(new Slot(input, 1, 76, 47));

		addSlot(new Slot(output, 0, 134, 47) {
			@Override
			public void onTake(Player player, ItemStack itemStack) {
				UpgradingMenu.this.onTake(player, itemStack);
			}
		});

		addStandardInventorySlots(inventory, 8, 84);
	}

	@Override
	public void slotsChanged(Container container) {
		super.slotsChanged(container);

		if (container == input) {
			if (level instanceof ServerLevel serverLevel) {
				UpgradingRecipeInput recipeInput = new UpgradingRecipeInput(input.getItem(0), input.getItem(1));
				Optional<RecipeHolder<UpgradingRecipe>> recipe = serverLevel.recipeAccess().getRecipeFor(ExampleModRecipes.UPGRADING_RECIPE_TYPE, recipeInput, serverLevel);

				if (recipe.isPresent()) {
					output.setItem(0, recipe.get().value().assemble(recipeInput, serverLevel.registryAccess()));
					output.setRecipeUsed(recipe.get());
				} else {
					output.clearContent();
					output.setRecipeUsed(null);
				}
			}
		}
	}

	public void onTake(Player player, ItemStack stack) {
		stack.onCraftedBy(player, stack.getCount());
		output.awardUsedRecipes(player, List.of(input.getItem(0), input.getItem(1)));

		input.removeItem(0, stack.getCount());
		input.removeItem(1, stack.getCount());
	}

	@Override
	public ItemStack quickMoveStack(Player player, int i) {
		return ItemStack.EMPTY;
	}

	@Override
	public boolean stillValid(Player player) {
		return true;
	}

	@Override
	public void removed(Player player) {
		super.removed(player);
		clearContainer(player, input);
	}
}

Тут багато чого розібрати! Це меню має два вхідні слоти та один вихідний.

Вхідний контейнер є анонімним підкласом SimpleContainer, який викликає метод slotsChanged меню, коли його предмети змінюються. У slotsChanged ми створюємо екземпляр нашого вхідного класу рецепта, заповнюючи його двома вхідними слотами.

Щоб перевірити, чи відповідає він будь-яким рецептам, ми спочатку переконаємося, що ми знаходимося на рівні сервера, оскільки клієнти не знають, які існують рецепти. Потім ми отримаємо RecipeManager через serverLevel.recipeAccess().

Ми викличемо serverLevel.recipeAccess().getRecipeFor з нашим уведенням рецепта, щоб отримати рецепт, який відповідає введеним даним. Якщо рецепт знайдено, ми можемо додати або видалити результат із результату контейнера.

Щоб визначити, коли користувач виймає результат, ми створюємо анонімний підклас Slot. Потім метод onTake нашого меню видаляє введені предмети.

Щоб запобігти видаленню предметів, важливо скинути введені дані, коли екран закрито, як показано в методі removed.

Синхронізація рецептів

INFO

Цей розділ необов’язковий і потрібен, лише якщо вам потрібно, щоб клієнти знали про рецепти.

Як згадувалося раніше, рецепти повністю обробляються на логічному сервері. Однак у деяких випадках клієнту може знадобитися знати, які існують рецепти — прикладом зі стандартної гри є каменеріз, яки повинен показувати доступні варіанти рецептів для певного інгредієнта. Крім того, плаґіни певних засобів перегляду рецептів, зокрема JEI, запускаються на логічному клієнті, вимагаючи від вас використання API синхронізації рецептів Fabric.

Щоб синхронізувати ваші рецепти, просто викличте RecipeSynchronization.synchronizeRecipeSerializer у своєму ініціалізаторі мода та надайте серіалізатор рецепта свого мода:

RecipeSynchronization.synchronizeRecipeSerializer(UPGRADING_RECIPE_SERIALIZER);

Після синхронізації рецепти можна отримати в будь-який момент із менеджера рецептів рівня клієнта:

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