stewbeet 2.1.8__tar.gz → 2.2.1__tar.gz

{stewbeet-2.1.8 → stewbeet-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stewbeet
-Version: 2.1.8
+Version: 2.2.1
 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

{stewbeet-2.1.8 → stewbeet-2.2.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stewbeet"
-version = "2.1.8"
+version = "2.2.1"
 description = "Beet Framework made to help generating advanced Minecraft datapack contents"
 readme = "README.md"
 license = "MIT"

stewbeet-2.2.1/stewbeet/continuous_delivery/cd_utils.py

@@ -0,0 +1,47 @@
+
+# Imports
+import os
+
+from stouputils.continuous_delivery.cd_utils import load_credentials  # type: ignore # noqa: F401
+
+from ..core.constants import LATEST_MC_VERSION
+from ..utils import ProjectConfig, get_project_config
+
+
+# Function that replace the "~" by the user's home directory
+def replace_tilde(path: str) -> str:
+	return path.replace("~", os.path.expanduser("~"))
+
+# Supported versions
+def get_supported_versions(version: str | None = None) -> list[str]:
+	""" Get the supported versions for a given version of Minecraft
+
+	Args:
+		version (str): Version of Minecraft
+	Returns:
+		list[str]: List of supported versions, ex: ["1.21.3", "1.21.2"]
+	"""
+	# If version is None, get it from the project config, otherwise use the default version
+	if version is None:
+		try:
+			config: ProjectConfig = get_project_config()
+			version = config.minecraft or LATEST_MC_VERSION
+		except AssertionError:
+			version = LATEST_MC_VERSION
+
+	# Some versions are considered the same for compatibility purposes
+	sames: list[list[str]] = [
+		["1.21", "1.21", "1.21.1"],
+		["1.21.2", "1.21.3"],
+		["1.21.6", "1.21.7", "1.21.8"],
+		["1.21.9", "1.21.10"],
+	]
+
+	# Find the matching list of versions
+	for s in sames:
+		if version in s:
+			return s
+
+	# If no match, return the version itself in a list
+	return [version]
+

{stewbeet-2.1.8 → stewbeet-2.2.1}/stewbeet/core/constants.py

@@ -2,13 +2,55 @@
 # ruff: noqa: E501, RUF012
 # Imports
 from beet.core.utils import JsonDict
+from beet.library import base
 
 from ..dependencies.bookshelf import BOOKSHELF_MODULES
 
-# Minecraft version constants
-MINECRAFT_VERSION: str = "1.21.8"	# Text used when loading the datapack to warn the user when the data version is not right
-DATA_VERSION: int = 4435			# Depending on MC version, given by /data get entity @p DataVersion to check if the datapack is not running in an older version of MC
-
+# Minecraft version specific constants
+MORE_DATA_PACK_FORMATS: dict[tuple[int, ...], int] = {
+	(1, 21): 48,
+	(1, 21, 0): 48,
+	(1, 21, 1): 48,
+	(1, 21, 2): 57,
+	(1, 21, 3): 57,
+	(1, 21, 4): 61,
+	(1, 21, 5): 71,
+	(1, 21, 6): 80,
+	(1, 21, 7): 81,
+	(1, 21, 8): 81,
+	(1, 21, 9): 88,
+	(1, 21, 10): 88,
+}
+MORE_ASSETS_PACK_FORMATS: dict[tuple[int, ...], int] = {
+	(1, 21): 34,
+	(1, 21, 0): 34,
+	(1, 21, 1): 34,
+	(1, 21, 2): 42,
+	(1, 21, 3): 42,
+	(1, 21, 4): 46,
+	(1, 21, 5): 55,
+	(1, 21, 6): 63,
+	(1, 21, 7): 64,
+	(1, 21, 8): 64,
+	(1, 21, 9): 69,
+	(1, 21, 10): 69,
+}
+MORE_DATA_VERSIONS: dict[tuple[int, ...], int] = {
+	(1, 21): 3953,
+	(1, 21, 0): 3953,
+	(1, 21, 1): 3955,
+	(1, 21, 2): 4080,
+	(1, 21, 3): 4082,
+	(1, 21, 4): 4189,
+	(1, 21, 5): 4325,
+	(1, 21, 6): 4435,
+	(1, 21, 7): 4438,
+	(1, 21, 8): 4440,
+	(1, 21, 9): 4554,
+	(1, 21, 10): 4556,
+}
+LATEST_MC_VERSION: str = ".".join(str(x) for x in list(MORE_DATA_VERSIONS.keys())[-1])
+base.LATEST_MINECRAFT_VERSION = LATEST_MC_VERSION
 
 # Databases
 CATEGORY: str = "category"								# Key for the category, used for recipes and the manual, ex: CATEGORY:"material" or CATEGORY:"equipment"
@@ -22,7 +64,8 @@ VANILLA_BLOCK_FOR_ORES: JsonDict = {"id":"minecraft:polished_deepslate", "apply_
 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)
 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"}
-WIKI_COMPONENT: str = "wiki_components"				# Key to a text component that will be used to generate the wiki button in the manual
+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"
+WIKI_COMPONENT: str = "wiki_components"					# Key to a text component that will be used to generate the wiki button in the manual
 RESULT_OF_CRAFTING: str = "result_of_crafting"			# Key to a list of recipes to craft the item, ex: "adamantium": {RESULT_OF_CRAFTING: [...]}
 USED_FOR_CRAFTING: str = "used_for_crafting"			# Should not be used unless you are crafting a vanilla item (ex: iyc.chainmail -> chainmail armor)
 NOT_COMPONENTS: list[str] = [							# Keys that should not be considered as components. Used for recipes, loot tables, etc.
@@ -35,6 +78,7 @@ NOT_COMPONENTS: list[str] = [							# Keys that should not be considered as comp
 	NO_SILK_TOUCH_DROP,
 	OVERRIDE_MODEL,
 	SMITHED_CRAFTER_COMMAND,
+	GROWING_SEED,
 ]
 
 # Technical constants

{stewbeet-2.1.8 → stewbeet-2.2.1}/stewbeet/core/definitions_helper/equipments.py

@@ -32,13 +32,15 @@ class DefaultOre(Enum):
 	DIAMOND = "diamond"
 	IRON = "iron"
 	GOLD = "golden"
-	CHAINMAIL = "stone"		# stone tools
-	LEATHER = "wooden"		# wood tools
+	CHAINMAIL = "stone"		# Stone tools
+	COPPER = "copper"		# Copper added in 1.21.9
+	LEATHER = "wooden"		# Wooden tools
 
 class VanillaEquipments(Enum):
 	""" Default vanilla equipments values (durability, armor, armor_toughness, knockback_resistance, attack_damage, attack_speed) """
 	HELMET			= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 55,		"armor": 1},
+						DefaultOre.COPPER:		{"durability": 121,		"armor": 2},
 						DefaultOre.CHAINMAIL:	{"durability": 165,		"armor": 2},
 						DefaultOre.IRON:		{"durability": 165,		"armor": 2},
 						DefaultOre.GOLD:		{"durability": 77,		"armor": 2},
@@ -47,6 +49,7 @@ class VanillaEquipments(Enum):
 					})
 	CHESTPLATE		= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 80,		"armor": 3},
+						DefaultOre.COPPER:		{"durability": 176,		"armor": 4},
 						DefaultOre.CHAINMAIL:	{"durability": 240,		"armor": 5},
 						DefaultOre.IRON:		{"durability": 240,		"armor": 6},
 						DefaultOre.GOLD:		{"durability": 112,		"armor": 5},
@@ -55,6 +58,7 @@ class VanillaEquipments(Enum):
 					})
 	LEGGINGS		= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 75,		"armor": 2},
+						DefaultOre.COPPER:		{"durability": 165,		"armor": 3},
   						DefaultOre.CHAINMAIL:	{"durability": 225,		"armor": 4},
 						DefaultOre.IRON:		{"durability": 225,		"armor": 5},
 						DefaultOre.GOLD:		{"durability": 105,		"armor": 3},
@@ -63,6 +67,7 @@ class VanillaEquipments(Enum):
 					})
 	BOOTS			= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 65,		"armor": 1},
+						DefaultOre.COPPER:		{"durability": 143,		"armor": 1},
 						DefaultOre.CHAINMAIL:	{"durability": 195,		"armor": 1},
 						DefaultOre.IRON:		{"durability": 195,		"armor": 2},
 						DefaultOre.GOLD:		{"durability": 95,		"armor": 1},
@@ -71,6 +76,7 @@ class VanillaEquipments(Enum):
 					})
 	SWORD			= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 59,		"attack_damage": 4,		"attack_speed": -2.40},
+						DefaultOre.COPPER:		{"durability": 190,		"attack_damage": 5,		"attack_speed": -2.40},
 						DefaultOre.CHAINMAIL:	{"durability": 131,		"attack_damage": 5,		"attack_speed": -2.40},
 						DefaultOre.IRON:		{"durability": 250,		"attack_damage": 6,		"attack_speed": -2.40},
 						DefaultOre.GOLD:		{"durability": 32,		"attack_damage": 4,		"attack_speed": -2.40},
@@ -79,6 +85,7 @@ class VanillaEquipments(Enum):
 					})
 	PICKAXE			= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 59,		"attack_damage": 2,		"attack_speed": -2.8},
+						DefaultOre.COPPER:		{"durability": 190,		"attack_damage": 3,		"attack_speed": -2.8},
 						DefaultOre.CHAINMAIL:	{"durability": 131,		"attack_damage": 3,		"attack_speed": -2.8},
 						DefaultOre.IRON:		{"durability": 250,		"attack_damage": 4,		"attack_speed": -2.8},
 						DefaultOre.GOLD:		{"durability": 32,		"attack_damage": 2,		"attack_speed": -2.8},
@@ -87,6 +94,7 @@ class VanillaEquipments(Enum):
 					})
 	AXE				= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 59,		"attack_damage": 7,		"attack_speed": -3.20},
+						DefaultOre.COPPER:		{"durability": 190,		"attack_damage": 9,		"attack_speed": -3.20},
 						DefaultOre.CHAINMAIL:	{"durability": 131,		"attack_damage": 9,		"attack_speed": -3.20},
 						DefaultOre.IRON:		{"durability": 250,		"attack_damage": 9,		"attack_speed": -3.10},
 						DefaultOre.GOLD:		{"durability": 32,		"attack_damage": 7,		"attack_speed": -3.00},
@@ -95,6 +103,7 @@ class VanillaEquipments(Enum):
 					})
 	SHOVEL			= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 59,		"attack_damage": 2.5,	"attack_speed": -3.00},
+						DefaultOre.COPPER:		{"durability": 190,		"attack_damage": 3.5,	"attack_speed": -3.00},
 						DefaultOre.CHAINMAIL:	{"durability": 131,		"attack_damage": 3.5,	"attack_speed": -3.00},
 						DefaultOre.IRON:		{"durability": 250,		"attack_damage": 4.5,	"attack_speed": -3.00},
 						DefaultOre.GOLD:		{"durability": 32,		"attack_damage": 2.5,	"attack_speed": -3.00},
@@ -103,6 +112,7 @@ class VanillaEquipments(Enum):
 					})
 	HOE				= cast(dict[DefaultOre, dict[str, float]],
 					{	DefaultOre.LEATHER:		{"durability": 59,		"attack_damage": 1,		"attack_speed": -3.00},
+						DefaultOre.COPPER:		{"durability": 190,		"attack_damage": 1,		"attack_speed": -2.00},
 						DefaultOre.CHAINMAIL:	{"durability": 131,		"attack_damage": 1,		"attack_speed": -2.00},
 						DefaultOre.IRON:		{"durability": 250,		"attack_damage": 1,		"attack_speed": -1.00},
 						DefaultOre.GOLD:		{"durability": 32,		"attack_damage": 1,		"attack_speed": -3.00},

{stewbeet-2.1.8 → stewbeet-2.2.1}/stewbeet/core/definitions_helper/materials.py

@@ -114,51 +114,57 @@ def generate_everything_about_this_material(
 
 
 	## Armor (helmet, chestplate, leggings, boots)
-	for gear in ["helmet", "chestplate", "leggings", "boots"]:
-		armor = material_base + "_" + gear
-		if armor + ".png" not in textures:
-			continue
-		if armor not in Mem.definitions:
-			Mem.definitions[armor] = {}
-		Mem.definitions[armor]["id"] = f"minecraft:leather_{gear}"		# Leather armor by default
-		Mem.definitions[armor][CATEGORY] = "equipment"					# Category
-		Mem.definitions[armor]["custom_data"] = {"smithed":{}}			# Smithed convention
-		Mem.definitions[armor]["custom_data"]["smithed"]["dict"] = {"armor": {material_base: True, gear: True}}
-		gear_config = {}
-		if gear == "helmet":
-			if not ignore_recipes:
-				Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XXX","X X"],"ingredients":{"X": main_ingredient}}]
-			if equipments_config:
-				gear_config = VanillaEquipments.HELMET.value[equipments_config.equivalent_to]
-				Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
-			if top_layer:
-				Mem.definitions[armor]["equippable"] = {"slot":"head", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
-		elif gear == "chestplate":
-			if not ignore_recipes:
-				Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X X","XXX","XXX"],"ingredients":{"X": main_ingredient}}]
+	if equipments_config is not None:
+		for gear in ["helmet", "chestplate", "leggings", "boots"]:
+			armor = material_base + "_" + gear
+			if armor + ".png" not in textures:
+				continue
+			if armor not in Mem.definitions:
+				Mem.definitions[armor] = {}
+			equivalent_to: str = equipments_config.equivalent_to.value
+			if equivalent_to == "stone":
+				equivalent_to = "chainmail"
+			elif equivalent_to == "wooden":
+				equivalent_to = "leather"
+			Mem.definitions[armor]["id"] = f"minecraft:{equivalent_to}_{gear}"
+			Mem.definitions[armor][CATEGORY] = "equipment"					# Category
+			Mem.definitions[armor]["custom_data"] = {"smithed":{}}			# Smithed convention
+			Mem.definitions[armor]["custom_data"]["smithed"]["dict"] = {"armor": {material_base: True, gear: True}}
+			gear_config = {}
+			if gear == "helmet":
+				if not ignore_recipes:
+					Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XXX","X X"],"ingredients":{"X": main_ingredient},"manual_priority":0}]
+				if equipments_config:
+					gear_config = VanillaEquipments.HELMET.value[equipments_config.equivalent_to]
+					Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
+				if top_layer:
+					Mem.definitions[armor]["equippable"] = {"slot":"head", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
+			elif gear == "chestplate":
+				if not ignore_recipes:
+					Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X X","XXX","XXX"],"ingredients":{"X": main_ingredient},"manual_priority":0}]
+				if equipments_config:
+					gear_config = VanillaEquipments.CHESTPLATE.value[equipments_config.equivalent_to]
+					Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
+				if top_layer:
+					Mem.definitions[armor]["equippable"] = {"slot":"chest", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
+			elif gear == "leggings":
+				if not ignore_recipes:
+					Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XXX","X X","X X"],"ingredients":{"X": main_ingredient},"manual_priority":0}]
+				if equipments_config:
+					gear_config = VanillaEquipments.LEGGINGS.value[equipments_config.equivalent_to]
+					Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
+				if bottom_layer:
+					Mem.definitions[armor]["equippable"] = {"slot":"legs", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
+			elif gear == "boots":
+				if not ignore_recipes:
+					Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X X","X X"],"ingredients":{"X": main_ingredient},"manual_priority":0}]
+				if equipments_config:
+					gear_config = VanillaEquipments.BOOTS.value[equipments_config.equivalent_to]
+					Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
+				if bottom_layer:
+					Mem.definitions[armor]["equippable"] = {"slot":"feet", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
 			if equipments_config:
-				gear_config = VanillaEquipments.CHESTPLATE.value[equipments_config.equivalent_to]
-				Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
-			if top_layer:
-				Mem.definitions[armor]["equippable"] = {"slot":"chest", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
-		elif gear == "leggings":
-			if not ignore_recipes:
-				Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XXX","X X","X X"],"ingredients":{"X": main_ingredient}}]
-			if equipments_config:
-				gear_config = VanillaEquipments.LEGGINGS.value[equipments_config.equivalent_to]
-				Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
-			if bottom_layer:
-				Mem.definitions[armor]["equippable"] = {"slot":"legs", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
-		elif gear == "boots":
-			if not ignore_recipes:
-				Mem.definitions[armor][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X X","X X"],"ingredients":{"X": main_ingredient}}]
-			if equipments_config:
-				gear_config = VanillaEquipments.BOOTS.value[equipments_config.equivalent_to]
-				Mem.definitions[armor]["max_damage"] = int(gear_config["durability"] * durability_factor)
-			if bottom_layer:
-				Mem.definitions[armor]["equippable"] = {"slot":"feet", "asset_id":f"{Mem.ctx.project_id}:{material_base}"}
-		if equipments_config:
-			Mem.definitions[armor]["attribute_modifiers"] = format_attributes(equipments_config.get_armor_attributes(), SLOTS[gear], gear_config)
+				Mem.definitions[armor]["attribute_modifiers"] = format_attributes(equipments_config.get_armor_attributes(), SLOTS[gear], gear_config)
 
 	# Tools (sword, pickaxe, axe, shovel, hoe)
 	for gear in ["sword", "pickaxe", "axe", "shovel", "hoe"]:
@@ -179,31 +185,31 @@ def generate_everything_about_this_material(
 				gear_config = VanillaEquipments.SWORD.value[equipments_config.equivalent_to]
 				Mem.definitions[tool]["max_damage"] = int(gear_config["durability"] * durability_factor)
 			if not ignore_recipes:
-				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X","X","S"],"ingredients": tools_ingr}]
+				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X","X","S"],"ingredients": tools_ingr,"manual_priority":0}]
 		elif gear == "pickaxe":
 			if equipments_config:
 				gear_config = VanillaEquipments.PICKAXE.value[equipments_config.equivalent_to]
 				Mem.definitions[tool]["max_damage"] = int(gear_config["durability"] * durability_factor)
 			if not ignore_recipes:
-				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XXX"," S "," S "],"ingredients": tools_ingr}]
+				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XXX"," S "," S "],"ingredients": tools_ingr,"manual_priority":0}]
 		elif gear == "axe":
 			if equipments_config:
 				gear_config = VanillaEquipments.AXE.value[equipments_config.equivalent_to]
 				Mem.definitions[tool]["max_damage"] = int(gear_config["durability"] * durability_factor)
 			if not ignore_recipes:
-				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XX","XS"," S"],"ingredients": tools_ingr}]
+				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XX","XS"," S"],"ingredients": tools_ingr,"manual_priority":0}]
 		elif gear == "shovel":
 			if equipments_config:
 				gear_config = VanillaEquipments.SHOVEL.value[equipments_config.equivalent_to]
 				Mem.definitions[tool]["max_damage"] = int(gear_config["durability"] * durability_factor)
 			if not ignore_recipes:
-				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X","S","S"],"ingredients": tools_ingr}]
+				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["X","S","S"],"ingredients": tools_ingr,"manual_priority":0}]
 		elif gear == "hoe":
 			if equipments_config:
 				gear_config = VanillaEquipments.HOE.value[equipments_config.equivalent_to]
 				Mem.definitions[tool]["max_damage"] = int(gear_config["durability"] * durability_factor)
 			if not ignore_recipes:
-				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XX"," S"," S"],"ingredients": tools_ingr}]
+				Mem.definitions[tool][RESULT_OF_CRAFTING] = [{"type":"crafting_shaped","result_count":1,"category":"equipment","shape":["XX"," S"," S"],"ingredients": tools_ingr,"manual_priority":0}]
 		if equipments_config:
 			Mem.definitions[tool]["attribute_modifiers"] = format_attributes(equipments_config.get_tools_attributes(), SLOTS[gear], gear_config)
 		if gear == "sword": # Remove the mining_efficiency attribute from swords

{stewbeet-2.1.8 → stewbeet-2.2.1}/stewbeet/core/ingredients.py

@@ -14,7 +14,16 @@ from .constants import NOT_COMPONENTS, PULVERIZING
 # Recipes constants
 FURNACES_RECIPES_TYPES: tuple[str, ...] = ("smelting", "blasting", "smoking", "campfire_cooking")
 CRAFTING_RECIPES_TYPES: tuple[str, ...] = ("crafting_shaped", "crafting_shapeless")
+OTHER_RECIPES_TYPES: tuple[str, ...] = ("smithing_transform", "smithing_trim", "stonecutting")
+UNUSED_RECIPES_TYPES: tuple[str, ...] = (
+	"crafting_decorated_pot", "crafting_special_armordye", "crafting_special_bannerduplicate",
+	"crafting_special_bookcloning", "crafting_special_firework_rocket", "crafting_special_firework_star",
+	"crafting_special_firework_star_fade", "crafting_special_mapcloning", "crafting_special_mapextending",
+	"crafting_special_repairitem", "crafting_special_shielddecoration", "crafting_special_tippedarrow",
+	"crafting_transmute",
+)
 SPECIAL_RECIPES_TYPES: tuple[str, ...] = (PULVERIZING, )
+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
@@ -69,6 +78,8 @@ def ingr_to_id(ingredient: JsonDict, add_namespace: bool = True) -> str:
 	Returns:
 		str: The id of the ingredient, ex: "minecraft:stick" or "iyc:adamantium_ingot"
 	"""
+	if isinstance(ingredient, str):
+		ingredient = {"item": ingredient}
 	if ingredient.get("item"):
 		if not add_namespace:
 			return ingredient["item"].split(":")[1]
@@ -103,6 +114,8 @@ def get_vanilla_item_id_from_ingredient(ingredient: JsonDict, add_namespace: boo
 	Returns:
 		str: The id of the vanilla item, ex: "minecraft:stick"
 	"""
+	if isinstance(ingredient, str):
+		ingredient = {"item": ingredient}
 	ns, ingr_id = ingr_to_id(ingredient).split(":")
 	if ns == Mem.ctx.project_id:
 		if add_namespace:
@@ -132,6 +145,8 @@ def get_item_from_ingredient(ingredient: JsonDict) -> JsonDict:
 	Returns:
 		dict: The item data dict, ex: {"id": "minecraft:stick", "count": 1}
 	"""
+	if isinstance(ingredient, str):
+		ingredient = {"item": ingredient}
 	ingr_id = ingr_to_id(ingredient)
 	ns, id = ingr_id.split(":")
 

{stewbeet-2.1.8 → stewbeet-2.2.1}/stewbeet/plugins/custom_recipes/smithed.py

@@ -154,6 +154,9 @@ class SmithedRecipeHandler:
             crafts += list(data.get("used_for_crafting", []))
 
             for recipe in crafts:
+                if recipe.get("type") not in ["crafting_shapeless", "crafting_shaped"]:
+                    continue
+
                 # Get ingredients
                 ingr = recipe.get("ingredients", {})
                 if not ingr:
@@ -170,7 +173,7 @@ class SmithedRecipeHandler:
                     ingr = [recipe.get("ingredient", {})]
 
                 # If there is a component in the ingredients of shaped/shapeless, use smithed crafter
-                if recipe.get("type") in ["crafting_shapeless", "crafting_shaped"] and any(i.get("components") for i in ingr):
+                if any(i.get("components") for i in ingr):
                     if not official_lib_used("smithed.crafter"):
                         debug("Found a crafting table recipe using custom item in ingredients, adding 'smithed.crafter' dependency")
 

{stewbeet-2.1.8 → stewbeet-2.2.1}/stewbeet/plugins/custom_recipes/vanilla.py

@@ -7,19 +7,25 @@ from beet.core.utils import JsonDict
 from stouputils.decorators import simple_cache
 
 from ...core.__memory__ import Mem
-from ...core.ingredients import get_ingredients_from_recipe, get_item_from_ingredient, get_vanilla_item_id_from_ingredient, ingr_repr, item_to_id_ingr_repr
+from ...core.ingredients import (
+    FURNACES_RECIPES_TYPES,
+    get_ingredients_from_recipe,
+    get_item_from_ingredient,
+    get_vanilla_item_id_from_ingredient,
+    ingr_repr,
+    item_to_id_ingr_repr,
+)
 from ...core.utils.io import set_json_encoder, write_function
 
 
 class VanillaRecipeHandler:
     """ Handler for vanilla recipe generation.
 
-    This class handles the generation of vanilla recipes (shapeless, shaped, furnace).
+    This class handles the generation of vanilla recipes (shapeless, shaped, furnace, ...).
     """
 
     def __init__(self) -> None:
         """ Initialize the handler. """
-        self.SMELTING: list[str] = ["smelting", "blasting", "smoking"]
         self.vanilla_generated_recipes: list[tuple[str, str]] = []
 
     @classmethod
@@ -166,6 +172,86 @@ advancement revoke @s only {Mem.ctx.project_id}:unlock_recipes
         to_return["result"]["count"] = recipe["result_count"]
         return to_return
 
+    @simple_cache()
+    def vanilla_stonecutting_recipe(self, recipe: JsonDict, item: str) -> JsonDict:
+        """ Generate a vanilla stonecutting recipe.
+
+        Args:
+            recipe (Dict[str, Any]): The recipe data.
+            item (str): The item to generate the recipe for.
+
+        Returns:
+            Dict[str, Any]: The generated recipe.
+        """
+        result_ingr = ingr_repr(item, Mem.ctx.project_id) if not recipe.get("result") else recipe["result"]
+        ingredient_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["ingredient"])
+
+        to_return: JsonDict = {
+            "type": "minecraft:" + recipe["type"],
+            "group": recipe.get("group"),
+            "ingredient": ingredient_vanilla,
+            "result": item_to_id_ingr_repr(get_item_from_ingredient(result_ingr)),
+        }
+
+        if not to_return["group"]:
+            del to_return["group"]
+
+        to_return["result"]["count"] = recipe["result_count"]
+        return to_return
+
+    @simple_cache()
+    def vanilla_smithing_transform_recipe(self, recipe: JsonDict, item: str) -> JsonDict:
+        """ Generate a vanilla smithing transform recipe.
+
+        Args:
+            recipe (Dict[str, Any]): The recipe data.
+            item (str): The item to generate the recipe for.
+
+        Returns:
+            Dict[str, Any]: The generated recipe.
+        """
+        result_ingr = ingr_repr(item, Mem.ctx.project_id) if not recipe.get("result") else recipe["result"]
+        base_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["base"])
+        addition_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["addition"])
+        template_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["template"])
+
+        to_return: JsonDict = {
+            "type": "minecraft:" + recipe["type"],
+            "base": base_vanilla,
+            "addition": addition_vanilla,
+            "template": template_vanilla,
+            "result": item_to_id_ingr_repr(get_item_from_ingredient(result_ingr)),
+        }
+
+        to_return["result"]["count"] = recipe["result_count"]
+        return to_return
+
+    @simple_cache()
+    def vanilla_smithing_trim_recipe(self, recipe: JsonDict, item: str) -> JsonDict:
+        """ Generate a vanilla smithing trim recipe.
+
+        Args:
+            recipe (Dict[str, Any]): The recipe data.
+            item (str): The item to generate the recipe for.
+
+        Returns:
+            Dict[str, Any]: The generated recipe.
+        """
+        base_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["base"])
+        addition_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["addition"])
+        template_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["template"])
+        pattern_vanilla: str = get_vanilla_item_id_from_ingredient(recipe["pattern"])
+
+        to_return: JsonDict = {
+            "type": "minecraft:" + recipe["type"],
+            "base": base_vanilla,
+            "addition": addition_vanilla,
+            "template": template_vanilla,
+            "pattern": pattern_vanilla,
+        }
+
+        return to_return
+
     def generate_recipes(self) -> None:
         """ Generate all vanilla recipes. """
         for item, data in Mem.definitions.items():
@@ -196,13 +282,48 @@ advancement revoke @s only {Mem.ctx.project_id}:unlock_recipes
                         i += 1
                         self.vanilla_generated_recipes.append((name, item))
 
-                elif recipe["type"] in [*self.SMELTING, "campfire_cooking"]:
+                elif recipe["type"] in FURNACES_RECIPES_TYPES:
                     if isinstance(ingr, dict) and cast(JsonDict, ingr).get("item"):
                         r = self.vanilla_furnace_recipe(recipe, item)
                         self.write_recipe_file(name, r)
                         i += 1
                         self.vanilla_generated_recipes.append((name, item))
 
+                elif recipe["type"] == "stonecutting":
+                    if isinstance(ingr, dict) and cast(JsonDict, ingr).get("item"):
+                        r = self.vanilla_stonecutting_recipe(recipe, item)
+                        self.write_recipe_file(name, r)
+                        i += 1
+                        self.vanilla_generated_recipes.append((name, item))
+
+                elif recipe["type"] == "smithing_transform":
+                    # Check if all required ingredients are present
+                    base = recipe.get("base", {})
+                    addition = recipe.get("addition", {})
+                    template = recipe.get("template", {})
+                    if (isinstance(base, dict) and cast(JsonDict, base).get("item") and
+                        isinstance(addition, dict) and cast(JsonDict, addition).get("item") and
+                        isinstance(template, dict) and cast(JsonDict, template).get("item")):
+                        r = self.vanilla_smithing_transform_recipe(recipe, item)
+                        self.write_recipe_file(name, r)
+                        i += 1
+                        self.vanilla_generated_recipes.append((name, item))
+
+                elif recipe["type"] == "smithing_trim":
+                    # Check if all required ingredients are present
+                    base = recipe.get("base", {})
+                    addition = recipe.get("addition", {})
+                    template = recipe.get("template", {})
+                    pattern = recipe.get("pattern", {})
+                    if (isinstance(base, dict) and cast(JsonDict, base).get("item") and
+                        isinstance(addition, dict) and cast(JsonDict, addition).get("item") and
+                        isinstance(template, dict) and cast(JsonDict, template).get("item") and
+                        isinstance(pattern, dict) and cast(JsonDict, pattern).get("item")):
+                        r = self.vanilla_smithing_trim_recipe(recipe, item)
+                        self.write_recipe_file(name, r)
+                        i += 1
+                        self.vanilla_generated_recipes.append((name, item))
+
     def write_recipe_file(self, name: str, content: JsonDict) -> None:
         """ Write a recipe file.
 

{stewbeet-2.1.8 → stewbeet-2.2.1}/stewbeet/plugins/datapack/custom_blocks/__init__.py

@@ -139,7 +139,7 @@ execute as @e[type=item_frame,tag={ns}.new,tag={ns}.{item}] at @s run function {
 
 				## Place function
 				content = ""
-				if block["apply_facing"]:
+				if block.get("apply_facing") not in (False, "entity"):
 					content += f"function {ns}:custom_blocks/get_rotation\n"
 					content += "setblock ~ ~ ~ air\n"
 					block_states = []
@@ -152,6 +152,8 @@ execute as @e[type=item_frame,tag={ns}.new,tag={ns}.{item}] at @s run function {
 						else:
 							content += f"execute if score #rotation {ns}.data matches {i+1} run setblock ~ ~ ~ {block_id}[facing={face}]{beautify_name}\n"
 				else:
+					if block.get("apply_facing") == "entity":
+						content += f"function {ns}:custom_blocks/get_rotation\n"
 					# Simple setblock
 					content += "setblock ~ ~ ~ air\n"
 					content += f"setblock ~ ~ ~ {block_id}{beautify_name}\n"