stewbeet 2.2.21__tar.gz → 2.2.23__tar.gz

{stewbeet-2.2.21 → stewbeet-2.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stewbeet
-Version: 2.2.21
+Version: 2.2.23
 Summary: Beet Framework made to help generating advanced Minecraft datapack contents
 Project-URL: Homepage, https://github.com/Stoupy51/stewbeet
 Project-URL: Issues, https://github.com/Stoupy51/stewbeet/issues
@@ -14,7 +14,7 @@ Requires-Python: >=3.12
 Requires-Dist: beet>=0.112.0
 Requires-Dist: bolt>=0.49.2
 Requires-Dist: mecha>=0.99.0
-Requires-Dist: model-resolver>=1.11.1
+Requires-Dist: model-resolver>=1.11.2
 Requires-Dist: mutagen>=1.47.0
 Requires-Dist: pyperclip>=1.8.0
 Requires-Dist: smithed>=0.19.0

{stewbeet-2.2.21 → stewbeet-2.2.23}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stewbeet"
-version = "2.2.21"
+version = "2.2.23"
 description = "Beet Framework made to help generating advanced Minecraft datapack contents"
 readme = "README.md"
 license = "MIT"
@@ -17,7 +17,7 @@ classifiers = [
 ]
 dependencies = [
 	"stouputils>=1.4.1",
-	"model_resolver>=1.11.1",
+	"model_resolver>=1.11.2",
 	"beet>=0.112.0",
 	"bolt>=0.49.2",
 	"mecha>=0.99.0",

{stewbeet-2.2.21 → stewbeet-2.2.23}/stewbeet/core/constants.py

@@ -66,6 +66,7 @@ NO_SILK_TOUCH_DROP: str = "no_silk_touch_drop"			# Key to an item ID that will d
 VANILLA_BLOCK_FOR_ORES: JsonDict = {"id":"minecraft:polished_deepslate", "apply_facing": False}	# Vanilla block that will be used for an optimization tip for ores, don't ask questions
 OVERRIDE_MODEL: str = "override_model"					# Key to a dictionnary that will be used to override the whole model
 PULVERIZING: str = "simplenergy_pulverizing"			# Value of a recipe type, used to generate dusts from ores (used by SimplEnergy)
+AWAKENED_FORGE: str = "stardust_awakened_forge"			# Value of a recipe type, used to craft items in the Awakened Forge (used by Stardust Fragment)
 SMITHED_CRAFTER_COMMAND: str = "smithed_crafter_command"	# Key to a command that will be used in a recipe in the Smithed Crafter library. If not present, the command will be defaulted to a loot table. Ex: {"result":...,SMITHED_CRAFTER_COMMAND: "function your_namespace:calls/smithed_crafter/do_something_else"}
 PAINTING_DATA: str = "painting_data"					# Key to a dict that contains the painting data, like {"author":"","title":"","width":1,"height":1} where author and title defaults to beet config values if not given
 GROWING_SEED: str = "staged_seed"						# Key to a seed that has multiple growth stages, value needs to be a dict like {"texture_basename":"wheat","stages":8,"seconds":600,"planted_on":"stone","loots":[{"id":"minecraft:wheat_seeds","min_count":1,"max_count":3}]} where loots can be either this format or a loot table path "namespace:blocks/loot_table_name"

{stewbeet-2.2.21 → stewbeet-2.2.23}/stewbeet/core/definitions_helper/materials.py

@@ -54,7 +54,60 @@ def generate_everything_about_this_material(
 		material_base = material.split(":")[-1]										# Get the base material name (ex: "adamantium" from "adamantium_fragment")
 	main_ingredient = ingr_repr(material, Mem.ctx.project_id) 						# Get the main ingredient for recipes
 
-	# Placeables (ore, deepslate_ore, block, raw_block)
+
+	## Ingredients (ingot, nugget, raw, and other)
+	for item in [material_base, f"{material_base}_fragment", f"{material_base}_ingot", f"{material_base}_nugget", f"raw_{material_base}", f"{material_base}_dust", f"{material_base}_stick", f"{material_base}_rod"]:
+		if item + ".png" not in textures:
+			continue
+		if item not in Mem.definitions:
+			Mem.definitions[item] = {}
+		item_type = item.replace(f"{material_base}_", "").replace(f"_{material_base}", "")
+		Mem.definitions[item]["id"] = CUSTOM_ITEM_VANILLA		# Custom item
+		Mem.definitions[item][CATEGORY] = "material"			# Category
+		Mem.definitions[item]["custom_data"] = {"smithed":{}}	# Smithed convention
+		Mem.definitions[item]["custom_data"]["smithed"]["dict"] = {item_type: {material_base: True}}
+
+		# Recipes
+		if not ignore_recipes:
+			Mem.definitions[item][RESULT_OF_CRAFTING] = Mem.definitions[item].get(RESULT_OF_CRAFTING, [])
+			Mem.definitions[item][USED_FOR_CRAFTING] = Mem.definitions[item].get(USED_FOR_CRAFTING, [])
+			if item.endswith("ingot") or item.endswith("fragment") or item == material_base:
+				if f"{material_base}_block.png" in textures:
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shapeless","result_count":9,"category":"misc","group":material_base,"ingredients":[ingr_repr(f"{material_base}_block", Mem.ctx.project_id)]})
+				if f"{material_base}_nugget.png" in textures:
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shaped","result_count":1,"category":"misc","group":material_base,"shape":["XXX","XXX","XXX"],"ingredients":{"X":ingr_repr(f"{material_base}_nugget", Mem.ctx.project_id)}})
+				if f"raw_{material_base}.png" in textures:
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"raw_{material_base}", Mem.ctx.project_id)})
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"raw_{material_base}", Mem.ctx.project_id)})
+				if f"{material_base}_dust.png" in textures:
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"{material_base}_dust", Mem.ctx.project_id)})
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"{material_base}_dust", Mem.ctx.project_id)})
+				if f"{material_base}_ore.png" in textures:
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"{material_base}_ore", Mem.ctx.project_id)})
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"{material_base}_ore", Mem.ctx.project_id)})
+				if f"deepslate_{material_base}_ore.png" in textures:
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"deepslate_{material_base}_ore", Mem.ctx.project_id)})
+					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"deepslate_{material_base}_ore", Mem.ctx.project_id)})
+			if item.endswith("dust"):
+				Mem.definitions[item][USED_FOR_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(item, Mem.ctx.project_id),"result":main_ingredient})
+				Mem.definitions[item][USED_FOR_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(item, Mem.ctx.project_id),"result":main_ingredient})
+				Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":PULVERIZING,"result_count":1,"category":"misc","group":material_base,"ingredient":main_ingredient})
+				for pulv_ingr in [f"raw_{material_base}",f"{material_base}_ore",f"deepslate_{material_base}_ore"]:
+					if f"{pulv_ingr}.png" in textures:
+						Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":PULVERIZING,"result_count":2,"category":"misc","group":material_base,"ingredient":ingr_repr(pulv_ingr, Mem.ctx.project_id)})
+			if item.endswith("nugget"):
+				Mem.definitions[item][RESULT_OF_CRAFTING].insert(0, {"type":"crafting_shapeless","result_count":9,"category":"misc","group":material_base,"ingredients":[main_ingredient]})
+				for gear in SLOTS.keys():
+					if f"{material_base}_{gear}.png" in textures:
+						Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"equipment","experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"{material_base}_{gear}", Mem.ctx.project_id)})
+			if item.endswith("stick"):
+				Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shaped","result_count":4,"category":"misc","shape":["X","X"],"ingredients":{"X":main_ingredient}})
+			if item.endswith("rod"):
+				Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shaped","result_count":1,"category":"misc","shape":["X","X","X"],"ingredients":{"X":main_ingredient}})
+		pass
+
+
+	## Placeables (ore, deepslate_ore, block, raw_block)
 	for block in [f"{material_base}_block", f"{material_base}_ore", f"deepslate_{material_base}_ore", f"raw_{material_base}_block"]:
 		if block + ".png" not in textures:
 			continue
@@ -216,57 +269,6 @@ def generate_everything_about_this_material(
 			Mem.definitions[tool]["attribute_modifiers"] = [am for am in Mem.definitions[tool]["attribute_modifiers"] if am["type"] != "mining_efficiency"]
 	pass
 
-	## Ingredients (ingot, nugget, raw, and other)
-	for item in [material_base, f"{material_base}_ingot", f"{material_base}_nugget", f"raw_{material_base}", f"{material_base}_fragment", f"{material_base}_dust", f"{material_base}_stick", f"{material_base}_rod"]:
-		if item + ".png" not in textures:
-			continue
-		if item not in Mem.definitions:
-			Mem.definitions[item] = {}
-		item_type = item.replace(f"{material_base}_", "").replace(f"_{material_base}", "")
-		Mem.definitions[item]["id"] = CUSTOM_ITEM_VANILLA		# Custom item
-		Mem.definitions[item][CATEGORY] = "material"			# Category
-		Mem.definitions[item]["custom_data"] = {"smithed":{}}	# Smithed convention
-		Mem.definitions[item]["custom_data"]["smithed"]["dict"] = {item_type: {material_base: True}}
-
-		# Recipes
-		if not ignore_recipes:
-			Mem.definitions[item][RESULT_OF_CRAFTING] = Mem.definitions[item].get(RESULT_OF_CRAFTING, [])
-			Mem.definitions[item][USED_FOR_CRAFTING] = Mem.definitions[item].get(USED_FOR_CRAFTING, [])
-			if item.endswith("ingot") or item.endswith("fragment") or item == material_base:
-				if f"{material_base}_block.png" in textures:
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shapeless","result_count":9,"category":"misc","group":material_base,"ingredients":[ingr_repr(f"{material_base}_block", Mem.ctx.project_id)]})
-				if f"{material_base}_nugget.png" in textures:
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shaped","result_count":1,"category":"misc","group":material_base,"shape":["XXX","XXX","XXX"],"ingredients":{"X":ingr_repr(f"{material_base}_nugget", Mem.ctx.project_id)}})
-				if f"raw_{material_base}.png" in textures:
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"raw_{material_base}", Mem.ctx.project_id)})
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"raw_{material_base}", Mem.ctx.project_id)})
-				if f"{material_base}_dust.png" in textures:
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"{material_base}_dust", Mem.ctx.project_id)})
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"{material_base}_dust", Mem.ctx.project_id)})
-				if f"{material_base}_ore.png" in textures:
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"{material_base}_ore", Mem.ctx.project_id)})
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"{material_base}_ore", Mem.ctx.project_id)})
-				if f"deepslate_{material_base}_ore.png" in textures:
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"deepslate_{material_base}_ore", Mem.ctx.project_id)})
-					Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(f"deepslate_{material_base}_ore", Mem.ctx.project_id)})
-			if item.endswith("dust"):
-				Mem.definitions[item][USED_FOR_CRAFTING].append({"type":"smelting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":200,"ingredient":ingr_repr(item, Mem.ctx.project_id),"result":main_ingredient})
-				Mem.definitions[item][USED_FOR_CRAFTING].append({"type":"blasting","result_count":1,"category":"misc","group":material_base,"experience":0.8,"cookingtime":100,"ingredient":ingr_repr(item, Mem.ctx.project_id),"result":main_ingredient})
-				Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":PULVERIZING,"result_count":1,"category":"misc","group":material_base,"ingredient":main_ingredient})
-				for pulv_ingr in [f"raw_{material_base}",f"{material_base}_ore",f"deepslate_{material_base}_ore"]:
-					if f"{pulv_ingr}.png" in textures:
-						Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":PULVERIZING,"result_count":2,"category":"misc","group":material_base,"ingredient":ingr_repr(pulv_ingr, Mem.ctx.project_id)})
-			if item.endswith("nugget"):
-				Mem.definitions[item][RESULT_OF_CRAFTING].insert(0, {"type":"crafting_shapeless","result_count":9,"category":"misc","group":material_base,"ingredients":[main_ingredient]})
-				for gear in SLOTS.keys():
-					if f"{material_base}_{gear}.png" in textures:
-						Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"smelting","result_count":1,"category":"equipment","experience":0.8,"cookingtime":200,"ingredient":ingr_repr(f"{material_base}_{gear}", Mem.ctx.project_id)})
-			if item.endswith("stick"):
-				Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shaped","result_count":4,"category":"misc","shape":["X","X"],"ingredients":{"X":main_ingredient}})
-			if item.endswith("rod"):
-				Mem.definitions[item][RESULT_OF_CRAFTING].append({"type":"crafting_shaped","result_count":1,"category":"misc","shape":["X","X","X"],"ingredients":{"X":main_ingredient}})
-		pass
-
 
 # Generate everything about these ores
 def generate_everything_about_these_materials(ores: dict[str, EquipmentsConfig|None], ignore_recipes: bool = False) -> None:

{stewbeet-2.2.21 → stewbeet-2.2.23}/stewbeet/core/ingredients.py

@@ -3,13 +3,13 @@
 from typing import Any, cast
 
 from beet import LootTable
-from beet.core.utils import JsonDict
+from beet.core.utils import JsonDict, TextComponent
 from stouputils.decorators import simple_cache
 from stouputils.io import super_json_dump
 from stouputils.print import error
 
 from .__memory__ import Mem
-from .constants import NOT_COMPONENTS, PULVERIZING
+from .constants import AWAKENED_FORGE, NOT_COMPONENTS, PULVERIZING
 
 # Recipes constants
 FURNACES_RECIPES_TYPES: tuple[str, ...] = ("smelting", "blasting", "smoking", "campfire_cooking")
@@ -22,17 +22,17 @@ UNUSED_RECIPES_TYPES: tuple[str, ...] = (
 	"crafting_special_repairitem", "crafting_special_shielddecoration", "crafting_special_tippedarrow",
 	"crafting_transmute",
 )
-SPECIAL_RECIPES_TYPES: tuple[str, ...] = (PULVERIZING, )
+SPECIAL_RECIPES_TYPES: tuple[str, ...] = (PULVERIZING, AWAKENED_FORGE)
 ALL_RECIPES_TYPES: tuple[str, ...] = (*FURNACES_RECIPES_TYPES, *CRAFTING_RECIPES_TYPES, *OTHER_RECIPES_TYPES, *UNUSED_RECIPES_TYPES, *SPECIAL_RECIPES_TYPES)
 
 # Function mainly used for definitions generation
-@simple_cache
+@simple_cache()
 def ingr_repr(id: str, ns: str|None = None, count: int|None = None) -> JsonDict:
 	""" Get the identity of the ingredient from its id for custom crafts
 	Args:
 		id		(str):		The id of the ingredient, ex: adamantium_fragment
 		ns		(str|None):	The namespace of the ingredient (optional if 'id' argument is a vanilla item), ex: iyc
-		count	(int|None):	The count of the ingredient (optional, used only when this ingredient format is a result item)
+		count	(int|None):	The count of the ingredient (optional, used only when this ingredient format is a result item) (or use a special type of recipe that supports counts)
 	Returns:
 		str: The identity of the ingredient for custom crafts,
 			ex: {"components":{"minecraft:custom_data":{"iyc":{"adamantium_fragment":True}}}}
@@ -67,13 +67,14 @@ def item_to_id_ingr_repr(ingr: JsonDict) -> JsonDict:
 	return r
 
 # Mainly used for manual
-@simple_cache
+@simple_cache()
 def ingr_to_id(ingredient: JsonDict, add_namespace: bool = True) -> str:
 	""" Get the id from an ingredient dict
 	Args:
 		ingredient (dict): The ingredient dict
 			ex: {"components":{"minecraft:custom_data":{iyc:{adamantium_ingot:True}}}}
 			ex: {"item": "minecraft:stick"}
+		add_namespace (bool): Whether to add the namespace to the id
 	Returns:
 		str: The id of the ingredient, ex: "minecraft:stick" or "iyc:adamantium_ingot"
 	"""
@@ -104,8 +105,56 @@ def ingr_to_id(ingredient: JsonDict, add_namespace: bool = True) -> str:
 		return namespace + ":" + id
 	return id
 
+@simple_cache()
+def text_component_to_str(tc: TextComponent) -> str:
+	""" Convert a TextComponent to a string
+	Args:
+		tc (TextComponent): The TextComponent to convert
+	Returns:
+		str: The converted string
+	"""
+	if isinstance(tc, str):
+		return tc
+	elif isinstance(tc, list):
+		result: str = ""
+		for part in tc:
+			result += text_component_to_str(part)
+		return result
+	result: str = ""
+	if tc.get("text"):
+		result += tc["text"]
+	if tc.get("extra"):
+		for extra in tc["extra"]:
+			result += text_component_to_str(extra)
+	return result
+
+@simple_cache()
+def ingr_to_name(ingredient: JsonDict) -> str:
+	""" Get the name from an ingredient dict
+	Args:
+		ingredient (dict): The ingredient dict
+			ex: {"components":{"minecraft:custom_data":{iyc:{adamantium_ingot:True}}}}
+			ex: {"item": "minecraft:stick"}
+	Returns:
+		str: The name of the ingredient, ex: "Stick" or "Adamantium Ingot"
+	"""
+	# Internal definitions
+	id = ingr_to_id(ingredient, add_namespace=False)
+	for component in ("item_name", "custom_name"):
+		if Mem.definitions.get(id, {}).get(component):
+			return text_component_to_str(Mem.definitions[id][component])
+
+	# External definitions
+	external_id = ingr_to_id(ingredient, add_namespace=True)
+	for component in ("item_name", "custom_name"):
+		if Mem.external_definitions.get(external_id, {}).get(component):
+			return text_component_to_str(Mem.external_definitions[external_id][component])
+
+	# Default: prettify the id
+	return id.replace("_", " ").title()
+
 # Mainly used for recipes
-@simple_cache
+@simple_cache()
 def get_vanilla_item_id_from_ingredient(ingredient: JsonDict, add_namespace: bool = True) -> str:
 	""" Get the id of the vanilla item from an ingredient dict
 	Args:
@@ -185,7 +234,7 @@ def get_item_from_ingredient(ingredient: JsonDict) -> JsonDict:
 
 
 # Make a loot table
-@simple_cache
+@simple_cache()
 def loot_table_from_ingredient(result_ingredient: JsonDict, result_count: int | dict) -> str:
 	""" Get the loot table for an ingredient dict
 	Args:
@@ -233,7 +282,7 @@ def loot_table_from_ingredient(result_ingredient: JsonDict, result_count: int |
 	Mem.ctx.data[loot_table] = LootTable(super_json_dump(file, max_level=9))
 	return loot_table
 
-@simple_cache
+@simple_cache()
 def get_ingredients_from_recipe(recipe: JsonDict) -> list[str]:
 	""" Get the ingredients from a recipe dict
 	Args:

{stewbeet-2.2.21 → stewbeet-2.2.23}/stewbeet/plugins/custom_recipes/__init__.py

@@ -5,6 +5,7 @@ from stouputils.decorators import measure_time
 from stouputils.print import progress
 
 from ...core.__memory__ import Mem
+from .awakened_forge import AwakenedForgeRecipeHandler
 from .furnace import FurnaceRecipeHandler
 from .pulverizer import PulverizerRecipeHandler
 from .smithed import SmithedRecipeHandler
@@ -28,6 +29,7 @@ def beet_default(ctx: Context) -> None:
     # Do all the things
     VanillaRecipeHandler.routine()
     SmithedRecipeHandler.routine()
-    PulverizerRecipeHandler.routine()
     FurnaceRecipeHandler.routine()
+    PulverizerRecipeHandler.routine()
+    AwakenedForgeRecipeHandler.routine()
 

stewbeet-2.2.23/stewbeet/plugins/custom_recipes/awakened_forge.py

@@ -0,0 +1,174 @@
+
+# Imports
+import json
+
+from beet import Predicate
+from beet.core.utils import JsonDict
+from stouputils.decorators import simple_cache
+
+from ...core.__memory__ import Mem
+from ...core.constants import AWAKENED_FORGE
+from ...core.ingredients import (
+    get_item_from_ingredient,
+    ingr_repr,
+    ingr_to_id,
+    item_to_id_ingr_repr,
+    loot_table_from_ingredient,
+)
+from ...core.utils.io import set_json_encoder, write_function, write_load_file, write_versioned_function
+
+
+class AwakenedForgeRecipeHandler:
+    """ Handler for awakened forge recipe generation.
+
+    This class handles the generation of awakened forge recipes.
+    """
+    def __init__(self) -> None:
+        """ Initialize the handler. """
+        self.STARDUST_AWAKENED_FORGE_PATH: str = f"{Mem.ctx.project_id}:calls/stardust/awakened_forge_recipes"
+
+    @classmethod
+    def routine(cls) -> None:
+        """ Main routine for awakened forge recipe generation. """
+        handler = cls()
+        handler.generate_recipes()
+
+    @simple_cache()
+    def stardust_awakened_forge_recipe(self, recipe: JsonDict, item: str) -> str:
+        """ Generate a awakened forge recipe.
+
+        Args:
+            recipe (JsonDict): The recipe data.
+            item (str): The item to generate the recipe for.
+
+        Returns:
+            str: The generated recipe command.
+        """
+        # Determine the result
+        result: JsonDict = item_to_id_ingr_repr(get_item_from_ingredient(recipe["result"])) if recipe.get("result") else ingr_repr(item, Mem.ctx.project_id)
+        result_function: str = ingr_to_id(result, add_namespace=True).replace(":", "/")
+
+        # Get ingredients
+        ingredients: list[JsonDict] = recipe["ingredients"]
+        first_ingredient: JsonDict = ingredients[0]
+        assert first_ingredient.get("count", 1) <= 64, f"First ingredient must have count <= 64, for {item} recipe {recipe}"
+        ingredients = ingredients[1:]
+
+        # Prepare the check line
+        line: str = "execute if data entity @s Item" + json.dumps(item_to_id_ingr_repr(first_ingredient))
+        for ingredient in ingredients:
+            count: int = ingredient.get("count", 1)
+            while True:
+                ingredient_copy = ingredient.copy()
+                ingredient_copy["count"] = count if count < 64 else 64
+                line += f" if entity @n[type=item,nbt={{Item:{json.dumps(item_to_id_ingr_repr(ingredient_copy))}}},distance=..1]"
+                count -= 64
+                if count <= 0:
+                    break
+        line += f" run return run function {Mem.ctx.project_id}:calls/stardust/forge_recipes/{result_function}/timer"
+
+        # Write the first result function
+        particle: str = recipe.get("particle", r"minecraft:dust{color:[0,0,1],scale:2}")
+        write_function(f"{Mem.ctx.project_id}:calls/stardust/forge_recipes/{result_function}/timer", f"""
+# Timer
+scoreboard players add @s stardust.forge_timer 4
+scoreboard players remove @s[scores={{stardust.forge_timer=1..}}] stardust.forge_timer 3
+scoreboard players reset @s[scores={{stardust.forge_timer=..0}}] stardust.forge_timer
+execute if score @s stardust.forge_timer matches 1 run playsound stardust:awakened_forge_crafting ambient @a[distance=..25]
+execute if score @s stardust.forge_timer matches 1.. run particle {particle} ~ ~ ~ 5 5 5 0.1 125
+
+# When timer reaches 4, craft the item
+execute if score @s stardust.forge_timer matches 4 run function {Mem.ctx.project_id}:calls/stardust/forge_recipes/{result_function}/craft
+""")
+        # Write the second result function
+        kill_ingredients: str = ""
+        for ingredient in ingredients:
+            count: int = ingredient.get("count", 1)
+            while True:
+                ingredient_copy = ingredient.copy()
+                ingredient_copy["count"] = count if count < 64 else 64
+                kill_ingredients += f"kill @n[type=item,nbt={{Item:{json.dumps(item_to_id_ingr_repr(ingredient_copy))}}},distance=..1]\n"
+                count -= 64
+                if count <= 0:
+                    break
+        write_function(f"{Mem.ctx.project_id}:calls/stardust/forge_recipes/{result_function}/craft", f"""
+# Visual and audio feedback
+advancement grant @a[distance=..25] only stardust:visible/adventure/use_awakened_forge
+playsound block.anvil.use block @a[distance=..25]
+particle smoke ~ ~ ~ 0.4 0.4 0.4 0.2 1000
+
+# Kill ingredients
+kill @s
+{kill_ingredients}
+
+# Spawn result item with Motion [0.0,1.0,0.0]
+tag @e[type=item] add stardust.temp
+execute align xyz run loot spawn ~.5 ~.5 ~.5 loot {loot_table_from_ingredient(result, recipe['result_count'])}
+execute as @e[type=item,tag=!stardust.temp] run data merge entity @s {{Motion:[0.0d,1.0d,0.0d],Glowing:true}}
+tag @e[type=item,tag=stardust.temp] remove stardust.temp
+""")
+
+        # Return check line
+        return line
+
+    def generate_recipes(self) -> None:
+        """ Generate all pulverizer recipes. """
+        for item, data in Mem.definitions.items():
+            crafts: list[JsonDict] = list(data.get("result_of_crafting", []))
+            crafts += list(data.get("used_for_crafting", []))
+
+            for recipe in crafts:
+                if recipe["type"] == AWAKENED_FORGE:
+                    write_function(
+                        self.STARDUST_AWAKENED_FORGE_PATH,
+                        self.stardust_awakened_forge_recipe(recipe, item),
+                        tags=["stardust:calls/awakened_forge_recipes"],
+                    )
+
+        # Second clock function
+        if Mem.ctx.project_id == "stardust" and Mem.ctx.data["stardust"].functions.get("calls/stardust/awakened_forge_recipes"):
+            write_load_file("# Awakened Forge timer\nscoreboard objectives add stardust.forge_timer dummy")
+            write_versioned_function("second", """
+# Awakened Forge recipes
+execute as @e[type=item,predicate=stardust:awakened_forge_input] at @s run function stardust:forge/second
+""")
+            Mem.ctx.data["stardust"].predicates["awakened_forge_input"] = set_json_encoder(Predicate({
+                    "condition": "minecraft:entity_properties",
+                    "entity": "this",
+                    "predicate": {
+                        "nbt": """{Item:{components:{"minecraft:custom_data":{}}}}""",
+                        "stepping_on": {
+                            "block": {
+                                "blocks": "minecraft:glass"
+                            }
+                        }
+                    }
+            }), max_level=-1)
+
+            # Second function, check the structure and call the recipes
+            write_function("stardust:forge/second", """
+# Check for Awakened Forge structure
+execute unless function stardust:forge/verify_structure run return fail
+
+# Call Awakened Forge recipes
+function #stardust:calls/awakened_forge_recipes
+""")
+
+            # Check structure function
+            write_function("stardust:forge/verify_structure", """
+## Verify Awakened Forge multiblock structure
+scoreboard players set #success stardust.data 0
+
+# Structure Orientation
+execute if block ~-2 ~-2 ~-2 #minecraft:diamond_ores if block ~-2 ~-1 ~-2 #minecraft:iron_ores if block ~2 ~-2 ~-2 #minecraft:emerald_ores if block ~2 ~-1 ~-2 #minecraft:coal_ores if block ~2 ~-2 ~2 nether_quartz_ore if block ~2 ~-1 ~2 #minecraft:redstone_ores if block ~-2 ~-2 ~2 #minecraft:gold_ores if block ~-2 ~-1 ~2 #minecraft:lapis_ores run scoreboard players set #success stardust.data 1
+execute if block ~2 ~-2 ~2 #minecraft:diamond_ores if block ~2 ~-1 ~2 #minecraft:iron_ores if block ~-2 ~-2 ~2 #minecraft:emerald_ores if block ~-2 ~-1 ~2 #minecraft:coal_ores if block ~-2 ~-2 ~-2 nether_quartz_ore if block ~-2 ~-1 ~-2 #minecraft:redstone_ores if block ~2 ~-2 ~-2 #minecraft:gold_ores if block ~2 ~-1 ~-2 #minecraft:lapis_ores run scoreboard players set #success stardust.data 1
+execute if block ~2 ~-2 ~-2 #minecraft:diamond_ores if block ~2 ~-1 ~-2 #minecraft:iron_ores if block ~2 ~-2 ~2 #minecraft:emerald_ores if block ~2 ~-1 ~2 #minecraft:coal_ores if block ~-2 ~-2 ~2 nether_quartz_ore if block ~-2 ~-1 ~2 #minecraft:redstone_ores if block ~-2 ~-2 ~-2 #minecraft:gold_ores if block ~-2 ~-1 ~-2 #minecraft:lapis_ores run scoreboard players set #success stardust.data 1
+execute if block ~-2 ~-2 ~2 #minecraft:diamond_ores if block ~-2 ~-1 ~2 #minecraft:iron_ores if block ~-2 ~-2 ~-2 #minecraft:emerald_ores if block ~-2 ~-1 ~-2 #minecraft:coal_ores if block ~2 ~-2 ~-2 nether_quartz_ore if block ~2 ~-1 ~-2 #minecraft:redstone_ores if block ~2 ~-2 ~2 #minecraft:gold_ores if block ~2 ~-1 ~2 #minecraft:lapis_ores run scoreboard players set #success stardust.data 1
+
+# Continuation of the structure
+execute if score #success stardust.data matches 1 if block ~ ~-1 ~ glass if block ~2 ~ ~2 glass if block ~-2 ~ ~-2 glass if block ~-2 ~ ~2 glass if block ~2 ~ ~-2 glass if block ~ ~-2 ~ diamond_block if block ~1 ~-1 ~1 dragon_egg if block ~-1 ~-1 ~-1 dragon_egg if block ~-1 ~-1 ~1 dragon_egg if block ~1 ~-1 ~-1 dragon_egg if block ~2 ~-2 ~ beacon if block ~ ~-2 ~2 beacon if block ~-2 ~-2 ~ beacon if block ~ ~-2 ~-2 beacon if block ~1 ~-2 ~ red_concrete if block ~-1 ~-2 ~ red_concrete if block ~ ~-2 ~1 red_concrete if block ~ ~-2 ~-1 red_concrete if block ~1 ~-2 ~1 red_concrete if block ~-1 ~-2 ~1 red_concrete if block ~-1 ~-2 ~-1 red_concrete if block ~1 ~-2 ~-1 red_concrete if block ~1 ~-2 ~2 black_concrete if block ~-1 ~-2 ~2 black_concrete if block ~1 ~-2 ~-2 black_concrete if block ~-1 ~-2 ~-2 black_concrete if block ~2 ~-2 ~1 black_concrete if block ~-2 ~-2 ~1 black_concrete if block ~2 ~-2 ~-1 black_concrete if block ~-2 ~-2 ~-1 black_concrete run return 1
+
+# Else, fail
+return fail
+""")  # noqa: E501
+

{stewbeet-2.2.21 → stewbeet-2.2.23}/stewbeet/plugins/ingame_manual/craft_content.py

@@ -3,7 +3,7 @@
 from beet.core.utils import JsonDict, TextComponent
 
 from ...core.__memory__ import Mem
-from ...core.constants import PULVERIZING
+from ...core.constants import AWAKENED_FORGE, PULVERIZING
 from ...core.ingredients import FURNACES_RECIPES_TYPES, ingr_to_id
 from .book_components import get_item_component
 from .other_utils import convert_shapeless_to_shaped, high_res_font_from_craft
@@ -34,6 +34,11 @@ def generate_craft_content(craft: JsonDict, name: str, page_font: str, in_lore:
 		page_font = high_res_font_from_craft(craft)
 	use_dialog: bool = SharedMemory.use_dialog > 0 and not in_lore	# In lore, we don't need to re-align the content
 
+	# Convert AWAKENED_FORGE to shaped crafting
+	if craft_type == AWAKENED_FORGE:
+		craft = convert_shapeless_to_shaped(craft)
+		craft["type"] = AWAKENED_FORGE
+
 	# Show up item title and page font
 	titled = name.replace("_", " ").title() + "\n"
 	content.append({"text": titled, "font": "minecraft:default", "color": "black", "underlined": True})
@@ -156,6 +161,123 @@ def generate_craft_content(craft: JsonDict, name: str, page_font: str, in_lore:
 				if len(shape) < 2:
 					content.append("\n")
 
+	# If the craft is AWAKENED_FORGE type
+	elif craft_type == AWAKENED_FORGE:
+		shape: list[str] = craft["shape"]
+		is_small_craft: bool = len(shape) <= 3 and all(len(x) <= 3 for x in shape)
+		if use_dialog and not is_small_craft:
+			content[-1] = content[-1].replace(page_font, page_font + VERY_SMALL_NONE_FONT*2) # type: ignore
+
+		# Convert each ingredients to its text component
+		formatted_ingredients: dict[str, JsonDict] = {}
+		for k, v in craft["ingredients"].items():
+			formatted_ingredients[k] = get_item_component(v, count=v.get("count", 1))
+
+		# Adjust craft shape for special cases
+		# Special case: if it's 1 line with 3 columns, add empty lines to center it
+		if len(shape) == 1 and len(shape[0]) == 3:
+			shape = ["   ", shape[0], "   "]
+
+		# Special case: if it's 3 lines with 1 column each, center them horizontally
+		elif (len(shape) == 3 and
+			all(len(shape_line) == 1 for shape_line in shape)):
+			shape = [" " + line + " " for line in shape]
+
+		# Add each ingredient to the craft
+		for index, line in enumerate(shape):
+			for i in range(2):	# We need two lines to make a square, otherwise it will be a rectangle
+				content.append(SMALL_NONE_FONT)
+				for k in line:
+					if k == " ":
+						content.append(INVISIBLE_ITEM_WIDTH)
+					else:
+						if i == 0:
+							content.append(formatted_ingredients[k])
+						else:
+							copy = formatted_ingredients[k].copy()
+							copy["text"] = INVISIBLE_ITEM_WIDTH
+							content.append(copy)
+				if use_dialog and index != 1 and (not is_small_craft or i != 1):
+					content.append(INVISIBLE_ITEM_WIDTH * max(0, (3 if is_small_craft else 4) - len(line)))
+					if is_small_craft:
+						content.append(NONE_FONT * 2)
+					else:
+						content.append(NONE_FONT + SMALL_NONE_FONT)
+				content.append("\n")
+		if len(shape) == 1 and len(shape[0]) < 3:
+			content.append("\n")
+			pass
+
+		# Add the result to the craft
+		if is_small_craft:
+			# First layer of the square
+			len_line = len(shape[1]) if len(shape) > 1 else 0
+			offset = 4 - len_line
+			break_line_pos = content.index("\n", content.index("\n") + 1)	# Find the second line break
+			try:
+				break_line_pos = content.index("\n", break_line_pos + 1) # Find the third line break
+			except Exception:
+				content.append(SMALL_NONE_FONT)
+				break_line_pos = len(content)
+			content.insert(break_line_pos, (INVISIBLE_ITEM_WIDTH * (offset - 1) + SMALL_NONE_FONT * 2))
+			content.insert(break_line_pos + 1, result_component)
+			if use_dialog:
+				content.insert(break_line_pos + 2, VERY_SMALL_NONE_FONT + MICRO_NONE_FONT)
+				break_line_pos += 1
+
+			# Second layer of the square
+			try:
+				break_line_pos = content.index("\n", break_line_pos + 3)	# Find the fourth line break
+			except Exception:
+				content.append("\n" + SMALL_NONE_FONT)
+				break_line_pos = len(content)
+			content.insert(break_line_pos, (INVISIBLE_ITEM_WIDTH * (offset - 1) + SMALL_NONE_FONT * 2))
+			copy = result_component.copy()
+			copy["text"] = INVISIBLE_ITEM_WIDTH
+			content.insert(break_line_pos + 1, copy)
+			if use_dialog:
+				content.insert(break_line_pos + 2, VERY_SMALL_NONE_FONT + MICRO_NONE_FONT)
+
+			# Add break lines for the third layer of a 3x3 craft
+			if len(shape) < 3 and len(shape[0]) == 3:
+				content.append("\n\n")
+				if len(shape) < 2:
+					content.append("\n")
+		else:
+			# First layer of the square
+			len_line = len(shape[1]) if len(shape) > 1 else 0
+			offset = 4 - len_line
+			break_line_pos = content.index("\n", content.index("\n") + 1)	# Find the second line break
+			try:
+				break_line_pos = content.index("\n", break_line_pos + 1) # Find the third line break
+			except Exception:
+				content.append(SMALL_NONE_FONT)
+				break_line_pos = len(content)
+			content.insert(break_line_pos, (INVISIBLE_ITEM_WIDTH * (offset - 1)) + MICRO_NONE_FONT)
+			content.insert(break_line_pos + 1, result_component)
+			if use_dialog:
+				content.insert(break_line_pos + 2, VERY_SMALL_NONE_FONT + MICRO_NONE_FONT)
+				break_line_pos += 1
+
+			# Second layer of the square
+			try:
+				break_line_pos = content.index("\n", break_line_pos + 3)	# Find the fourth line break
+			except Exception:
+				content.append("\n" + SMALL_NONE_FONT)
+				break_line_pos = len(content)
+			content.insert(break_line_pos, (INVISIBLE_ITEM_WIDTH * (offset - 1)) + MICRO_NONE_FONT)
+			copy = result_component.copy()
+			copy["text"] = INVISIBLE_ITEM_WIDTH
+			content.insert(break_line_pos + 1, copy)
+			if use_dialog:
+				content.insert(break_line_pos + 2, VERY_SMALL_NONE_FONT + MICRO_NONE_FONT)
+
+			# Add break lines for the third layer of a 3x4 craft
+			if len(shape) < 3 and len(shape[0]) == 4:
+				content.append("\n\n")
+				if len(shape) < 2:
+					content.append("\n")
+		content.insert(3, "\n")
 
 	# If the type is furnace type,
 	elif craft_type in FURNACES_RECIPES_TYPES: