Added AnvilReceipts from BE

src/main/java/ru/bclib/blocks/LeveledAnvilBlock.java

@@ -0,0 +1,16 @@
+package ru.bclib.blocks;
+
+import net.minecraft.world.level.material.MaterialColor;
+
+public class LeveledAnvilBlock extends BaseAnvilBlock{
+        protected final int level;
+
+        public LeveledAnvilBlock(MaterialColor color, int level) {
+            super(color);
+            this.level = level;
+        }
+
+        public int getCraftingLevel() {
+            return level;
+        }
+}

src/main/java/ru/bclib/interfaces/AnvilScreenHandlerExtended.java

@@ -0,0 +1,36 @@
+package ru.bclib.interfaces;
+
+
+import java.util.List;
+
+import ru.bclib.recipes.AnvilRecipe;
+
+public interface AnvilScreenHandlerExtended {
+	void be_updateCurrentRecipe(AnvilRecipe recipe);
+	
+	AnvilRecipe be_getCurrentRecipe();
+	
+	List<AnvilRecipe> be_getRecipes();
+	
+	default void be_nextRecipe() {
+		List<AnvilRecipe> recipes = be_getRecipes();
+		if (recipes.size() < 2) return;
+		AnvilRecipe current = be_getCurrentRecipe();
+		int i = recipes.indexOf(current) + 1;
+		if (i >= recipes.size()) {
+			i = 0;
+		}
+		be_updateCurrentRecipe(recipes.get(i));
+	}
+	
+	default void be_previousRecipe() {
+		List<AnvilRecipe> recipes = be_getRecipes();
+		if (recipes.size() < 2) return;
+		AnvilRecipe current = be_getCurrentRecipe();
+		int i = recipes.indexOf(current) - 1;
+		if (i <= 0) {
+			i = recipes.size() - 1;
+		}
+		be_updateCurrentRecipe(recipes.get(i));
+	}
+}

src/main/java/ru/bclib/interfaces/UnknownReceipBookCategory.java

@@ -0,0 +1,4 @@
+package ru.bclib.interfaces;
+
+public interface UnknownReceipBookCategory {
+}

src/main/java/ru/bclib/mixin/client/AnvilScreenMixin.java

@@ -0,0 +1,96 @@
+package ru.bclib.mixin.client;
+
+import java.util.List;
+
+import com.google.common.collect.Lists;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.screens.inventory.AnvilScreen;
+import net.minecraft.client.gui.screens.inventory.ItemCombinerScreen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TextComponent;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.AnvilMenu;
+import net.minecraft.world.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import ru.bclib.interfaces.AnvilScreenHandlerExtended;
+
+@Mixin(AnvilScreen.class)
+public class AnvilScreenMixin extends ItemCombinerScreen<AnvilMenu> {
+	
+	@Shadow
+	private EditBox name;
+	
+	private final List<AbstractWidget> be_buttons = Lists.newArrayList();
+	
+	public AnvilScreenMixin(AnvilMenu handler, Inventory playerInventory, Component title, ResourceLocation texture) {
+		super(handler, playerInventory, title, texture);
+	}
+	
+	@Inject(method = "subInit", at = @At("TAIL"))
+	protected void be_subInit(CallbackInfo info) {
+		int x = (width - imageWidth) / 2;
+		int y = (height - imageHeight) / 2;
+		be_buttons.clear();
+		be_buttons.add(new Button(x + 8, y + 45, 15, 20, new TextComponent("<"), b -> be_previousRecipe()));
+		be_buttons.add(new Button(x + 154, y + 45, 15, 20, new TextComponent(">"), b -> be_nextRecipe()));
+	}
+	
+	@Inject(method = "renderFg", at = @At("TAIL"))
+	protected void be_renderForeground(PoseStack matrices, int mouseX, int mouseY, float delta, CallbackInfo info) {
+		be_buttons.forEach(button -> {
+			button.render(matrices, mouseX, mouseY, delta);
+		});
+	}
+	
+	@Inject(method = "slotChanged", at = @At("HEAD"), cancellable = true)
+	public void be_onSlotUpdate(AbstractContainerMenu handler, int slotId, ItemStack stack, CallbackInfo info) {
+		AnvilScreenHandlerExtended anvilHandler = (AnvilScreenHandlerExtended) handler;
+		if (anvilHandler.be_getCurrentRecipe() != null) {
+			if (anvilHandler.be_getRecipes().size() > 1) {
+				be_buttons.forEach(button -> button.visible = true);
+			}
+			else {
+				be_buttons.forEach(button -> button.visible = false);
+			}
+			name.setValue("");
+			info.cancel();
+		}
+		else {
+			be_buttons.forEach(button -> button.visible = false);
+		}
+	}
+	
+	private void be_nextRecipe() {
+		((AnvilScreenHandlerExtended) menu).be_nextRecipe();
+	}
+	
+	private void be_previousRecipe() {
+		((AnvilScreenHandlerExtended) menu).be_previousRecipe();
+	}
+	
+	@Override
+	public boolean mouseClicked(double mouseX, double mouseY, int button) {
+		if (minecraft != null) {
+			for (AbstractWidget elem : be_buttons) {
+				if (elem.visible && elem.mouseClicked(mouseX, mouseY, button)) {
+					if (minecraft.gameMode != null) {
+						int i = be_buttons.indexOf(elem);
+						minecraft.gameMode.handleInventoryButtonClick(menu.containerId, i);
+						return true;
+					}
+				}
+			}
+		}
+		return super.mouseClicked(mouseX, mouseY, button);
+	}
+}

src/main/java/ru/bclib/mixin/client/ClientLevelMixin.java

@@ -1,2 +0,0 @@
-package ru.bclib.mixin.client;public class ClientLevelMixin {
-}

src/main/java/ru/bclib/mixin/client/ClientRecipeBookMixin.java

@@ -0,0 +1,20 @@
+package ru.bclib.mixin.client;
+
+import net.minecraft.client.ClientRecipeBook;
+import net.minecraft.client.RecipeBookCategories;
+import net.minecraft.world.item.crafting.Recipe;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import ru.bclib.interfaces.UnknownReceipBookCategory;
+
+@Mixin(ClientRecipeBook.class)
+public abstract class ClientRecipeBookMixin {
+	@Inject(method = "getCategory", at = @At("HEAD"), cancellable = true)
+	private static void be_getGroupForRecipe(Recipe<?> recipe, CallbackInfoReturnable<RecipeBookCategories> info) {
+		if (recipe instanceof UnknownReceipBookCategory) {
+			info.setReturnValue(RecipeBookCategories.UNKNOWN);
+		}
+	}
+}

src/main/java/ru/bclib/mixin/client/ClientboundLoginPacketMixin.java

@@ -1,18 +0,0 @@
-package ru.bclib.mixin.client;
-
-import net.minecraft.network.protocol.game.ClientGamePacketListener;
-import net.minecraft.network.protocol.game.ClientboundLoginPacket;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ClientboundLoginPacket.class)
-public abstract class ClientboundLoginPacketMixin {
-	@Inject(method = "handle", cancellable = true, at=@At("HEAD"))
-	public void bclib_handle(ClientGamePacketListener clientGamePacketListener, CallbackInfo ci){
-		//cLevel.setBCLibDidSendHello();
-//		DataExchangeAPI.sendOnEnter();
-//		ci.cancel();
-	}
-}

src/main/java/ru/bclib/mixin/common/AnvilMenuMixin.java

@@ -1,5 +1,11 @@
 package ru.bclib.mixin.common;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.jetbrains.annotations.Nullable;
+
 import net.minecraft.tags.BlockTags;
 import net.minecraft.world.entity.player.Inventory;
 import net.minecraft.world.entity.player.Player;
@@ -9,18 +15,27 @@ import net.minecraft.world.inventory.DataSlot;
 import net.minecraft.world.inventory.ItemCombinerMenu;
 import net.minecraft.world.inventory.MenuType;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.RecipeManager;
+import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.state.BlockState;
-import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import ru.bclib.blocks.BaseAnvilBlock;
+import ru.bclib.blocks.LeveledAnvilBlock;
+import ru.bclib.interfaces.AnvilScreenHandlerExtended;
+import ru.bclib.recipes.AnvilRecipe;
 
 @Mixin(AnvilMenu.class)
-public abstract class AnvilMenuMixin extends ItemCombinerMenu {
+public abstract class AnvilMenuMixin extends ItemCombinerMenu implements AnvilScreenHandlerExtended {
+	private List<AnvilRecipe> be_recipes = Collections.emptyList();
+	private AnvilRecipe be_currentRecipe;
+	private DataSlot anvilLevel;
+
 	@Shadow
 	private int repairItemCountCost;
 	
@@ -31,9 +46,63 @@ public abstract class AnvilMenuMixin extends ItemCombinerMenu {
 	public AnvilMenuMixin(@Nullable MenuType<?> menuType, int i, Inventory inventory, ContainerLevelAccess containerLevelAccess) {
 		super(menuType, i, inventory, containerLevelAccess);
 	}
+
+	@Inject(method = "<init>(ILnet/minecraft/world/entity/player/Inventory;Lnet/minecraft/world/inventory/ContainerLevelAccess;)V", at = @At("TAIL"))
+	public void be_initAnvilLevel(int syncId, Inventory inventory, ContainerLevelAccess context, CallbackInfo info) {
+		this.anvilLevel = addDataSlot(DataSlot.standalone());
+		if (context != ContainerLevelAccess.NULL) {
+			int level = context.evaluate((world, blockPos) -> {
+				Block anvilBlock = world.getBlockState(blockPos).getBlock();
+				if (anvilBlock instanceof LeveledAnvilBlock) {
+					return ((LeveledAnvilBlock) anvilBlock).getCraftingLevel();
+				}
+				return 1;
+			}, 1);
+			anvilLevel.set(level);
+		}
+		else {
+			anvilLevel.set(1);
+		}
+	}
+
+	@Shadow
+	public abstract void createResult();
+
+	@Inject(method = "mayPickup", at = @At("HEAD"), cancellable = true)
+	protected void be_canTakeOutput(Player player, boolean present, CallbackInfoReturnable<Boolean> info) {
+		if (be_currentRecipe != null) {
+			info.setReturnValue(be_currentRecipe.checkHammerDurability(inputSlots, player));
+		}
+	}
 	
 	@Inject(method = "onTake", at = @At("HEAD"), cancellable = true)
 	protected void bclib_onTakeAnvilOutput(Player player, ItemStack stack, CallbackInfo info) {
+		if (be_currentRecipe != null) {
+			inputSlots.getItem(0).shrink(be_currentRecipe.getInputCount());
+			stack = be_currentRecipe.craft(inputSlots, player);
+			slotsChanged(inputSlots);
+			access.execute((world, blockPos) -> {
+				BlockState anvilState = world.getBlockState(blockPos);
+				BaseAnvilBlock anvil = (BaseAnvilBlock) anvilState.getBlock();
+				if (!player.getAbilities().instabuild && anvilState.is(BlockTags.ANVIL) && player.getRandom().nextDouble() < 0.1) {
+					BlockState damagedState = anvil.damageAnvilUse(anvilState, player.getRandom());
+					if (damagedState == null) {
+						world.removeBlock(blockPos, false);
+						world.levelEvent(1029, blockPos, 0);
+					}
+					else {
+						world.setBlock(blockPos, damagedState, 2);
+						world.levelEvent(1030, blockPos, 0);
+					}
+				}
+				else {
+					world.levelEvent(1030, blockPos, 0);
+				}
+			});
+			info.cancel();
+			return;
+		}
+
 		this.access.execute((level, blockPos) -> {
 			BlockState blockState = level.getBlockState(blockPos);
 			if (blockState.getBlock() instanceof BaseAnvilBlock) {
@@ -77,4 +146,68 @@ public abstract class AnvilMenuMixin extends ItemCombinerMenu {
 			}
 		});
 	}
+
+	@Inject(method = "createResult", at = @At("HEAD"), cancellable = true)
+	public void be_updateOutput(CallbackInfo info) {
+		RecipeManager recipeManager = this.player.level.getRecipeManager();
+		be_recipes = recipeManager.getRecipesFor(AnvilRecipe.TYPE, inputSlots, player.level);
+		if (be_recipes.size() > 0) {
+			int anvilLevel = this.anvilLevel.get();
+			be_recipes = be_recipes.stream()
+								   .filter(recipe -> anvilLevel >= recipe.getAnvilLevel())
+								   .collect(Collectors.toList());
+			if (be_recipes.size() > 0) {
+				if (be_currentRecipe == null || !be_recipes.contains(be_currentRecipe)) {
+					be_currentRecipe = be_recipes.get(0);
+				}
+				be_updateResult();
+				info.cancel();
+			}
+			else {
+				be_currentRecipe = null;
+			}
+		}
+	}
+
+	@Inject(method = "setItemName", at = @At("HEAD"), cancellable = true)
+	public void be_setNewItemName(String string, CallbackInfo info) {
+		if (be_currentRecipe != null) {
+			info.cancel();
+		}
+	}
+
+	@Override
+	public boolean clickMenuButton(Player player, int id) {
+		if (id == 0) {
+			be_previousRecipe();
+			return true;
+		}
+		else if (id == 1) {
+			be_nextRecipe();
+			return true;
+		}
+		return super.clickMenuButton(player, id);
+	}
+
+	private void be_updateResult() {
+		if (be_currentRecipe == null) return;
+		resultSlots.setItem(0, be_currentRecipe.assemble(inputSlots));
+		broadcastChanges();
+	}
+
+	@Override
+	public void be_updateCurrentRecipe(AnvilRecipe recipe) {
+		this.be_currentRecipe = recipe;
+		be_updateResult();
+	}
+
+	@Override
+	public AnvilRecipe be_getCurrentRecipe() {
+		return be_currentRecipe;
+	}
+
+	@Override
+	public List<AnvilRecipe> be_getRecipes() {
+		return be_recipes;
+	}
 }

src/main/java/ru/bclib/recipes/AnvilRecipe.java

@@ -0,0 +1,335 @@
+package ru.bclib.recipes;
+
+import java.util.Objects;
+
+import com.google.gson.JsonObject;
+
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.TagParser;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.Tag;
+import net.minecraft.util.GsonHelper;
+import net.minecraft.world.Container;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TieredItem;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraft.world.level.ItemLike;
+import net.minecraft.world.level.Level;
+import ru.bclib.BCLib;
+import ru.bclib.api.TagAPI;
+import ru.bclib.config.PathConfig;
+import ru.bclib.interfaces.UnknownReceipBookCategory;
+import ru.bclib.util.ItemUtil;
+import ru.bclib.util.RecipeHelper;
+
+public class AnvilRecipe implements Recipe<Container>, UnknownReceipBookCategory {
+    public final static String GROUP = "smithing";
+    public final static RecipeType<AnvilRecipe> TYPE = BCLRecipeManager.registerType(BCLib.MOD_ID, GROUP);
+    public final static Serializer SERIALIZER = BCLRecipeManager.registerSerializer(
+            BCLib.MOD_ID,
+            GROUP,
+            new Serializer()
+    );
+    public final static ResourceLocation ID = BCLib.makeID(GROUP);
+
+    private final ResourceLocation id;
+    private final Ingredient input;
+    private final ItemStack output;
+    private final int damage;
+    private final int toolLevel;
+    private final int anvilLevel;
+    private final int inputCount;
+
+    public AnvilRecipe(ResourceLocation identifier, Ingredient input, ItemStack output, int inputCount, int toolLevel, int anvilLevel, int damage) {
+        this.id = identifier;
+        this.input = input;
+        this.output = output;
+        this.toolLevel = toolLevel;
+        this.anvilLevel = anvilLevel;
+        this.inputCount = inputCount;
+        this.damage = damage;
+    }
+
+    public static Builder create(String id) {
+        return create(BCLib.makeID(id));
+    }
+
+    public static Builder create(ResourceLocation id) {
+        Builder.INSTANCE.id = id;
+        Builder.INSTANCE.input = null;
+        Builder.INSTANCE.output = null;
+        Builder.INSTANCE.inputCount = 1;
+        Builder.INSTANCE.toolLevel = 1;
+        Builder.INSTANCE.anvilLevel = 1;
+        Builder.INSTANCE.damage = 1;
+        Builder.INSTANCE.alright = true;
+        Builder.INSTANCE.exist = true;
+
+        return Builder.INSTANCE;
+    }
+
+    @Override
+    public RecipeSerializer<?> getSerializer() {
+        return SERIALIZER;
+    }
+
+    @Override
+    public ItemStack getResultItem() {
+        return this.output;
+    }
+
+    @Override
+    public boolean matches(Container craftingInventory, Level world) {
+        return this.matches(craftingInventory);
+    }
+
+    @Override
+    public ItemStack assemble(Container craftingInventory) {
+        return this.output.copy();
+    }
+
+    public ItemStack craft(Container craftingInventory, Player player) {
+        if (!player.isCreative()) {
+            if (!checkHammerDurability(craftingInventory, player)) return ItemStack.EMPTY;
+            ItemStack hammer = craftingInventory.getItem(1);
+            hammer.hurtAndBreak(this.damage, player, entity -> entity.broadcastBreakEvent((InteractionHand) null));
+        }
+        return this.assemble(craftingInventory);
+    }
+
+    public boolean checkHammerDurability(Container craftingInventory, Player player) {
+        if (player.isCreative()) return true;
+        ItemStack hammer = craftingInventory.getItem(1);
+        int damage = hammer.getDamageValue() + this.damage;
+        return damage < hammer.getMaxDamage();
+    }
+
+    public boolean matches(Container craftingInventory) {
+        ItemStack hammer = craftingInventory.getItem(1);
+        if (hammer.isEmpty() || !TagAPI.ITEM_HAMMERS.contains(hammer.getItem())) {
+            return false;
+        }
+        ItemStack material = craftingInventory.getItem(0);
+        int materialCount = material.getCount();
+        int level = ((TieredItem) hammer.getItem()).getTier().getLevel();
+        return this.input.test(craftingInventory.getItem(0)) && materialCount >= this.inputCount && level >= this.toolLevel;
+    }
+
+    public int getDamage() {
+        return this.damage;
+    }
+
+    public int getInputCount() {
+        return this.inputCount;
+    }
+
+    public int getAnvilLevel() {
+        return this.anvilLevel;
+    }
+
+    @Override
+    public NonNullList<Ingredient> getIngredients() {
+        NonNullList<Ingredient> defaultedList = NonNullList.create();
+        defaultedList.add(Ingredient.of(TagAPI.ITEM_HAMMERS.getValues()
+                                                           .stream()
+                                                           .filter(hammer -> ((TieredItem) hammer).getTier()
+                                                                                                  .getLevel() >= toolLevel)
+                                                           .map(ItemStack::new)));
+        defaultedList.add(input);
+
+        return defaultedList;
+    }
+
+    @Override
+    @Environment(EnvType.CLIENT)
+    public boolean canCraftInDimensions(int width, int height) {
+        return true;
+    }
+
+    @Override
+    public ResourceLocation getId() {
+        return this.id;
+    }
+
+    @Override
+    public RecipeType<?> getType() {
+        return TYPE;
+    }
+
+    @Override
+    public boolean isSpecial() {
+        return true;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        AnvilRecipe that = (AnvilRecipe) o;
+        return damage == that.damage && toolLevel == that.toolLevel && id.equals(that.id) && input.equals(that.input) && output
+                .equals(that.output);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, input, output, damage, toolLevel);
+    }
+
+    @Override
+    public String toString() {
+        return "AnvilRecipe [" + id + "]";
+    }
+
+    public static class Builder {
+        private final static Builder INSTANCE = new Builder();
+
+        private ResourceLocation id;
+        private Ingredient input;
+        private ItemStack output;
+        private int inputCount = 1;
+        private int toolLevel = 1;
+        private int anvilLevel = 1;
+        private int damage = 1;
+        private boolean alright;
+        private boolean exist;
+
+        private Builder() { }
+
+        public Builder setInput(ItemLike... inputItems) {
+            this.alright &= RecipeHelper.exists(inputItems);
+            this.setInput(Ingredient.of(inputItems));
+            return this;
+        }
+
+        public Builder setInput(Tag<Item> inputTag) {
+            this.setInput(Ingredient.of(inputTag));
+            return this;
+        }
+
+        public Builder setInput(Ingredient ingredient) {
+            this.input = ingredient;
+            return this;
+        }
+
+        public Builder setInputCount(int count) {
+            this.inputCount = count;
+            return this;
+        }
+
+        public Builder setOutput(ItemLike output) {
+            return this.setOutput(output, 1);
+        }
+
+        public Builder setOutput(ItemLike output, int amount) {
+            this.alright &= RecipeHelper.exists(output);
+            this.output = new ItemStack(output, amount);
+            return this;
+        }
+
+        public Builder setToolLevel(int level) {
+            this.toolLevel = level;
+            return this;
+        }
+
+        public Builder setAnvilLevel(int level) {
+            this.anvilLevel = level;
+            return this;
+        }
+
+        public Builder setDamage(int damage) {
+            this.damage = damage;
+            return this;
+        }
+
+        public Builder checkConfig(PathConfig config) {
+            exist |= config.getBoolean("anvil", id.getPath(), true);
+            return this;
+        }
+
+        public void build() {
+            if (exist) {
+                if (input == null) {
+                    BCLib.LOGGER.warning("Input for Anvil recipe can't be 'null', recipe {} will be ignored!", id);
+                    return;
+                }
+                if (output == null) {
+                    BCLib.LOGGER.warning("Output for Anvil recipe can't be 'null', recipe {} will be ignored!", id);
+                    return;
+                }
+                if (BCLRecipeManager.getRecipe(TYPE, id) != null) {
+                    BCLib.LOGGER.warning("Can't add Anvil recipe! Id {} already exists!", id);
+                    return;
+                }
+                if (!alright) {
+                    BCLib.LOGGER.debug("Can't add Anvil recipe {}! Ingeredient or output not exists.", id);
+                    return;
+                }
+                BCLRecipeManager.addRecipe(
+                        TYPE,
+                        new AnvilRecipe(id, input, output, inputCount, toolLevel, anvilLevel, damage)
+                );
+            }
+        }
+    }
+
+    public static class Serializer implements RecipeSerializer<AnvilRecipe> {
+        @Override
+        public AnvilRecipe fromJson(ResourceLocation id, JsonObject json) {
+            Ingredient input = Ingredient.fromJson(json.get("input"));
+            JsonObject result = GsonHelper.getAsJsonObject(json, "result");
+            ItemStack output = ItemUtil.fromJsonRecipe(result);
+            if (output == null) {
+                throw new IllegalStateException("Output item does not exists!");
+            }
+            if (result.has("nbt")) {
+                try {
+                    String nbtData = GsonHelper.getAsString(result, "nbt");
+                    CompoundTag nbt = TagParser.parseTag(nbtData);
+                    output.setTag(nbt);
+                }
+                catch (CommandSyntaxException ex) {
+                    BCLib.LOGGER.warning("Error parse nbt data for output.", ex);
+                }
+            }
+            int inputCount = GsonHelper.getAsInt(json, "inputCount", 1);
+            int toolLevel = GsonHelper.getAsInt(json, "toolLevel", 1);
+            int anvilLevel = GsonHelper.getAsInt(json, "anvilLevel", 1);
+            int damage = GsonHelper.getAsInt(json, "damage", 1);
+
+            return new AnvilRecipe(id, input, output, inputCount, toolLevel, anvilLevel, damage);
+        }
+
+        @Override
+        public AnvilRecipe fromNetwork(ResourceLocation id, FriendlyByteBuf packetBuffer) {
+            Ingredient input = Ingredient.fromNetwork(packetBuffer);
+            ItemStack output = packetBuffer.readItem();
+            int inputCount = packetBuffer.readVarInt();
+            int toolLevel = packetBuffer.readVarInt();
+            int anvilLevel = packetBuffer.readVarInt();
+            int damage = packetBuffer.readVarInt();
+
+            return new AnvilRecipe(id, input, output, inputCount, toolLevel, anvilLevel, damage);
+        }
+
+        @Override
+        public void toNetwork(FriendlyByteBuf packetBuffer, AnvilRecipe recipe) {
+            recipe.input.toNetwork(packetBuffer);
+            packetBuffer.writeItem(recipe.output);
+            packetBuffer.writeVarInt(recipe.inputCount);
+            packetBuffer.writeVarInt(recipe.toolLevel);
+            packetBuffer.writeVarInt(recipe.anvilLevel);
+            packetBuffer.writeVarInt(recipe.damage);
+        }
+    }
+}

src/main/java/ru/bclib/util/ItemUtil.java

@@ -0,0 +1,76 @@
+package ru.bclib.util;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import com.google.gson.JsonObject;
+
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.GsonHelper;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import ru.bclib.BCLib;
+
+public class ItemUtil {
+	
+	public static String toStackString(@NotNull ItemStack stack) {
+		try {
+			if (stack == null) {
+				throw new IllegalStateException("Stack can't be null!");
+			}
+			Item item = stack.getItem();
+			return Registry.ITEM.getKey(item) + ":" + stack.getCount();
+		}
+		catch (Exception ex) {
+			BCLib.LOGGER.error("ItemStack serialization error!", ex);
+		}
+		return "";
+	}
+	
+	@Nullable
+	public static ItemStack fromStackString(String stackString) {
+		if (stackString == null || stackString.equals("")) {
+			return null;
+		}
+		try {
+			String[] parts = stackString.split(":");
+			if (parts.length < 2) return null;
+			if (parts.length == 2) {
+				ResourceLocation itemId = new ResourceLocation(stackString);
+				Item item = Registry.ITEM.getOptional(itemId).orElseThrow(() -> {
+					return new IllegalStateException("Output item " + itemId + " does not exists!");
+				});
+				return new ItemStack(item);
+			}
+			ResourceLocation itemId = new ResourceLocation(parts[0], parts[1]);
+			Item item = Registry.ITEM.getOptional(itemId).orElseThrow(() -> {
+				return new IllegalStateException("Output item " + itemId + " does not exists!");
+			});
+			return new ItemStack(item, Integer.valueOf(parts[2]));
+		}
+		catch (Exception ex) {
+			BCLib.LOGGER.error("ItemStack deserialization error!", ex);
+		}
+		return null;
+	}
+	
+	@Nullable
+	public static ItemStack fromJsonRecipe(JsonObject recipe) {
+		try {
+			if (!recipe.has("item")) {
+				throw new IllegalStateException("Invalid JsonObject. Entry 'item' does not exists!");
+			}
+			ResourceLocation itemId = new ResourceLocation(GsonHelper.getAsString(recipe, "item"));
+			Item item = Registry.ITEM.getOptional(itemId).orElseThrow(() -> {
+				return new IllegalStateException("Output item " + itemId + " does not exists!");
+			});
+			int count = GsonHelper.getAsInt(recipe, "count", 1);
+			return new ItemStack(item, count);
+		}
+		catch (Exception ex) {
+			BCLib.LOGGER.error("ItemStack deserialization error!", ex);
+		}
+		return null;
+	}
+}

src/main/java/ru/bclib/util/RecipeHelper.java

@@ -0,0 +1,25 @@
+package ru.bclib.util;
+
+import net.minecraft.core.Registry;
+import net.minecraft.world.level.ItemLike;
+import net.minecraft.world.level.block.Block;
+
+public class RecipeHelper {
+	public static boolean exists(ItemLike item) {
+		if (item instanceof Block) {
+			return Registry.BLOCK.getKey((Block) item) != Registry.BLOCK.getDefaultKey();
+		}
+		else {
+			return Registry.ITEM.getKey(item.asItem()) != Registry.ITEM.getDefaultKey();
+		}
+	}
+	
+	public static boolean exists(ItemLike... items) {
+		for (ItemLike item : items) {
+			if (!exists(item)) {
+				return false;
+			}
+		}
+		return true;
+	}
+}

src/main/resources/bclib.mixins.client.json

@@ -11,7 +11,9 @@
 		"TextureAtlasMixin",
 		"ModelBakeryMixin",
 		"MinecraftMixin",
-		"GameMixin"
+		"GameMixin",
+		"AnvilScreenMixin",
+		"ClientRecipeBookMixin"
 	],
 	"injectors": {
 		"defaultRequire": 1