stewbeet 2.2.5__tar.gz → 2.2.7__tar.gz

{stewbeet-2.2.5 → stewbeet-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stewbeet
-Version: 2.2.5
+Version: 2.2.7
 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.2.5 → stewbeet-2.2.7}/pyproject.toml

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

{stewbeet-2.2.5 → stewbeet-2.2.7}/stewbeet/core/definitions_helper/completion.py

@@ -12,7 +12,7 @@ from ..__memory__ import Mem
 
 
 # Add item model component
-def add_item_model_component(black_list: list[str] | None = None, ignore_paintings: bool = True) -> None:
+def add_item_model_component(black_list: list[str] | None = None) -> None:
 	""" Add an item model component to all items in the definitions.
 
 	Args:
@@ -24,8 +24,6 @@ def add_item_model_component(black_list: list[str] | None = None, ignore_paintin
 	for item, data in Mem.definitions.items():
 		if item in black_list or data.get("item_model", None) is not None:
 			continue
-		if ignore_paintings and data.get("painting_data", None) is not None:
-			continue
 		data["item_model"] = f"{Mem.ctx.project_id}:{item}"
 	return
 

{stewbeet-2.2.5 → stewbeet-2.2.7}/stewbeet/plugins/custom_paintings/__init__.py

@@ -53,23 +53,28 @@ def beet_default(ctx: Context) -> None:
             ordered_painting_data = {"asset_id": f"{ns}:{item}"}
             ordered_painting_data.update(painting_data)
             ordered_painting_data.pop("not_placeable", None)
+            ordered_painting_data.pop("texture", None)
 
             # Create the painting definition
             Mem.ctx.data[ns].painting_variants[item] = set_json_encoder(PaintingVariant(ordered_painting_data))
 
             ## Resource pack
             # Get the texture path
-            matching_textures: list[str] = [
-                relative_path(f"{root}/{file}")
-                for root, _, files in os.walk(textures_folder)
-                for file in files if file == f"{item}.png"
-            ]
-            if not matching_textures:
-                error(f"No texture found for painting '{item}' in the textures folder '{textures_folder}'. Expected a file named '{item}.png'.")
-                continue
-            elif len(matching_textures) > 1:
-                warning(f"Multiple textures found for painting '{item}' in the textures folder '{textures_folder}'. Using the first one found: '{matching_textures[0]}'.")
-            src: str = matching_textures[0]
+            if "texture" in painting_data:
+                texture: str = painting_data["texture"]
+                src: str = relative_path(f"{textures_folder}/{texture}.png")
+            else:
+                matching_textures: list[str] = [
+                    relative_path(f"{root}/{file}")
+                    for root, _, files in os.walk(textures_folder)
+                    for file in files if file == f"{item}.png"
+                ]
+                if not matching_textures:
+                    error(f"No texture found for painting '{item}' in the textures folder '{textures_folder}'. Expected a file named '{item}.png'.")
+                    continue
+                elif len(matching_textures) > 1:
+                    warning(f"Multiple textures found for painting '{item}' in the textures folder '{textures_folder}'. Using the first one found: '{matching_textures[0]}'.")
+                src: str = matching_textures[0]
             dst: str = f"painting/{item}"
 
             # Check if the texture is not already registered

{stewbeet-2.2.5 → stewbeet-2.2.7}/stewbeet/plugins/datapack/custom_blocks/__init__.py

@@ -1,10 +1,13 @@
 
 # Imports
-from beet import Advancement, BlockTag, Context, EntityTypeTag, Predicate
+import os
+from pathlib import Path
+
+from beet import Advancement, BlockTag, Context, EntityTypeTag, LootTable, Predicate
 from beet.core.utils import JsonDict
 from stouputils.decorators import measure_time
-from stouputils.io import super_json_dump
-from stouputils.print import debug, progress
+from stouputils.io import clean_path, relative_path, super_json_dump
+from stouputils.print import debug, error, progress
 
 from ....core.__memory__ import Mem
 from ....core.constants import (
@@ -13,13 +16,14 @@ from ....core.constants import (
 	CUSTOM_BLOCK_HEAD,
 	CUSTOM_BLOCK_HEAD_CUBE_RADIUS,
 	CUSTOM_BLOCK_VANILLA,
+	GROWING_SEED,
 	NO_SILK_TOUCH_DROP,
 	OFFICIAL_LIBS,
 	VANILLA_BLOCK,
 	VANILLA_BLOCK_FOR_ORES,
 	official_lib_used,
 )
-from ....core.utils.io import set_json_encoder, write_function, write_function_tag, write_versioned_function
+from ....core.utils.io import set_json_encoder, write_function, write_function_tag, write_load_file, write_versioned_function
 
 
 # Main entry point
@@ -34,10 +38,18 @@ def beet_default(ctx: Context):
 	# Set up memory context
 	if Mem.ctx is None: # pyright: ignore[reportUnnecessaryComparison]
 		Mem.ctx = ctx
+	ns: str = ctx.project_id
+	textures_folder: str = relative_path(ctx.meta.get("stewbeet", {}).get("textures_folder", ""))
 
 	# Assertions
 	assert ctx.project_id, "Project ID is not set. Please set it in the project configuration."
-	ns: str = ctx.project_id
+	assert textures_folder != "", "Textures folder path not found in 'ctx.meta.stewbeet.textures_folder'. Please set a directory path in project configuration."
+
+	# Textures
+	source_textures: dict[str, str] = {
+		clean_path(str(p)).split("/")[-1]: relative_path(str(p))
+		for p in Path(textures_folder).rglob("*.png")
+	}
 
 	# Stop if not custom block
 	if not any(data.get(VANILLA_BLOCK) for data in Mem.definitions.values()):
@@ -72,6 +84,7 @@ execute if score #rotation {ns}.data matches 0 if predicate {ns}:facing/west run
 	# For each custom block,
 	unique_blocks: set[str] = set()
 	custom_block_entities: set[str] = set()
+	has_growing_seed: bool = False
 	for item, data in Mem.definitions.items():
 		item: str
 		data: JsonDict
@@ -125,7 +138,25 @@ execute if score #rotation {ns}.data matches 0 if predicate {ns}:facing/west run
 advancement revoke @s only {ns}:custom_block_alternative/{item}
 
 # Execute the place function as and at the new placed item frame
-execute as @e[type=item_frame,tag={ns}.new,tag={ns}.{item}] at @s run function {ns}:custom_blocks/{item}/place_main
+tag @s add {ns}.to_refund
+execute as @e[type=item_frame,tag={ns}.new,tag={ns}.{item}] at @s run function {ns}:custom_blocks/{item}/place_check
+tag @s remove {ns}.to_refund
+""")
+
+				# Make place check function
+				write_function(f"{ns}:custom_blocks/{item}/place_check", f"""
+# Check if there is air block at the position
+execute if block ~ ~ ~ air run return run function {ns}:custom_blocks/{item}/place_main
+
+# If not air, give back the item to the player
+tag @e[type=item] add {ns}.temp
+execute as @p[tag={ns}.to_refund] at @s run loot spawn ~ ~ ~ loot {ns}:i/{item}
+data merge entity @n[type=item,tag=!{ns}.temp] {{PickupDelay:0s,Motion:[0.0d,0.0d,0.0d]}}
+data modify entity @n[type=item,tag=!{ns}.temp] Owner set from entity @p[tag={ns}.to_refund] UUID
+tag @n[type=item] remove {ns}.temp
+
+# And kill the item frame
+kill @s
 """)
 
 			# If the block is a custom block with a block id,
@@ -173,8 +204,13 @@ execute as @e[type=item_frame,tag={ns}.new,tag={ns}.{item}] at @s run function {
 scoreboard players add #total_custom_blocks {ns}.data 1
 scoreboard players add #total_vanilla_{block_id.replace('minecraft:','')} {ns}.data 1
 scoreboard players add #total_{item} {ns}.data 1
+{f"scoreboard players add #total_growing_seeds {ns}.data 1" if GROWING_SEED in data else ""}
 """
 
+				# If CUSTOM_BLOCK_ALTERNATIVE, we need to kill the old item frame
+				if data.get("id") == CUSTOM_BLOCK_ALTERNATIVE:
+					content += "kill @s[type=item_frame]\n"
+
 				# Write the file
 				write_function(f"{path}/place_main", content)
 
@@ -192,6 +228,7 @@ tag @s add smithed.block
 tag @s add {ns}.custom_block
 tag @s add {ns}.{item}
 tag @s add {ns}.vanilla.{block_id}
+{f"tag @s add {ns}.growing_seed" if GROWING_SEED in data else ""}
 
 # Add a custom name
 data merge entity @s {custom_name}
@@ -237,6 +274,7 @@ execute as @n[tag={ns}.new] at @s run function {ns}:custom_blocks/{item}/place_s
 scoreboard players add #total_custom_blocks {ns}.data 1
 scoreboard players add #total_vanilla_item_frame {ns}.data 1
 scoreboard players add #total_{item} {ns}.data 1
+{f"scoreboard players add #total_growing_seeds {ns}.data 1" if GROWING_SEED in data else ""}
 
 # Replace the placing sound
 playsound minecraft:block.stone.place block @a[distance=..5]
@@ -262,6 +300,7 @@ tag @s add smithed.block
 tag @s add {ns}.custom_block
 tag @s add {ns}.{item}
 tag @s add {ns}.vanilla.minecraft_item_frame
+{f"tag @s add {ns}.growing_seed" if GROWING_SEED in data else ""}
 
 # Add a custom name
 data merge entity @s {custom_name}
@@ -274,9 +313,108 @@ execute store result entity @s Facing byte 1 run scoreboard players get #item_fr
 execute at @s run tp @s ^ ^ ^0.1
 """)
 				pass
+
+			# If the block is a growing seed, make the update_seed_model function and call it in the place_secondary function
+			growing_seed: JsonDict = data.get(GROWING_SEED, {})
+			if growing_seed:
+				has_growing_seed = True
+				write_function(f"{ns}:custom_blocks/{item}/place_secondary", f"""
+# Update seed model
+scoreboard players add @s {ns}.growth_time 0
+function {ns}:custom_blocks/{item}/update_seed_model
+""")
+				# Get the number of growth stages
+				texture_basename: str = growing_seed.get("texture_basename", item)
+				starts: str = f"{texture_basename}_stage_"
+				num_stages: int = len({texture for texture in source_textures if os.path.basename(texture).startswith(starts)})
+				progress_stages: int = num_stages - 1 # Last stage is the full grown plant
+				growing_time: int = growing_seed["seconds"]
+
+				# Make the update function
+				content: str = ""
+				for stage in range(num_stages):
+					time_from: int = int(stage * growing_time / progress_stages)
+					time_to: int = int((stage + 1) * growing_time / progress_stages) - 1
+					time_to_str: str = str(time_to) if stage < progress_stages else ""
+					content += (
+						f"execute if score @s {ns}.growth_time matches {time_from}..{time_to_str} unless score @s {ns}.growth_stage matches {stage} run "
+						f"""function {ns}:custom_blocks/change_seed_stage {{stage:{stage}, model:"{ns}:seeds/{starts}{stage}"}}\n"""
+					)
+				write_function(f"{ns}:custom_blocks/{item}/update_seed_model", f"""
+# Update growth stage based on growth_time
+{content}
+""")
+				# Optimisation: If total growing time is higher than 60*stages second, we will increment the growth_time score every minute
+				for (speed, secs) in [(60, "minute"), (5, "second_5"), (1, "second")]:
+					if growing_time > speed * progress_stages:
+						write_function(f"{ns}:custom_blocks/{item}/{secs}", f"""
+# Increment growth time score by {speed} and update model
+scoreboard players add @s {ns}.growth_time {speed}
+function {ns}:custom_blocks/{item}/update_seed_model
+""")
+						break
+				else:
+					error(f"Growing seed '{item}' has a growing time < to the number of stages ({growing_time} seconds). Please increase the growing time or reduce the number of stages.")
+
+				# Make the loot table for the seed
+				loot_table: str | list[JsonDict] = growing_seed.get("loots", [])
+				if not isinstance(loot_table, str):
+					ctx.data[ns].loot_tables[f"seeds/{item}"] = set_json_encoder(LootTable({
+						"type": "minecraft:block",
+						"pools": [
+							{
+								"rolls": pool.get("rolls", 1),
+								"bonus_rolls": 0,
+								"entries": [
+									{
+										# Vanilla item if "minecraft:" in id,
+										# Custom item if plain string
+										# Another loot table if ':' in id
+										"type": "minecraft:item" if "minecraft:" in pool["id"] else "minecraft:loot_table",
+										"name" if "minecraft:" in pool["id"] else "value": (f"{ns}:i/{pool["id"]}" if ":" not in pool["id"] else pool["id"]),
+										**({} if not pool.get("fortune") else {
+											"functions": [
+												{
+													"function": "minecraft:apply_bonus",
+													"enchantment": "minecraft:fortune",
+													"formula": "minecraft:binomial_with_bonus_count",
+													"parameters": pool["fortune"],
+												},
+											]
+										})
+									}
+								]
+							}
+							for pool in loot_table
+						]
+					}), max_level=-1)
+					loot_table = f"{ns}:seeds/{item}"
+
+				# Make the is_fully_grown function that will be called on destroy
+				write_function(f"{ns}:custom_blocks/{item}/is_fully_grown", f"""
+# If fully grown, drop the loot table and kill the current entity (item)
+execute if score #growth_time {ns}.data matches {growing_time}.. as @p[gamemode=!spectator] run loot spawn ~ ~ ~ fish {loot_table} ~ ~ ~ mainhand
+execute if score #growth_time {ns}.data matches {growing_time}.. run kill @s
+""")
 			pass
 		pass
 
+	# Make the change_stage function for growing seeds and create scoreboard objectives
+	if has_growing_seed:
+		write_function(f"{ns}:custom_blocks/change_seed_stage", f"""
+# Update the growth stage score
+$scoreboard players set @s {ns}.growth_stage $(stage)
+
+# Change the item model to the right stage
+$execute if entity @s[type=item_display] run return run data modify entity @s item.components."minecraft:item_model" set value "$(model)"
+$execute if entity @s[type=item_frame] run return run data modify entity @s Item.components."minecraft:item_model" set value "$(model)"
+""")
+		write_load_file(f"""
+# Create objectives for growing seeds
+scoreboard objectives add {ns}.growth_time dummy
+scoreboard objectives add {ns}.growth_stage dummy
+""")
+
 	# Link the custom block library to the datapack
 	smithed_custom_blocks = [1 for data in Mem.definitions.values() if data.get("id") == CUSTOM_BLOCK_VANILLA]
 	if smithed_custom_blocks:
@@ -307,7 +445,7 @@ execute at @s run tp @s ^ ^ ^0.1
 
 	## Destroy functions
 	# For each unique block, if the vanilla block is missing, call the destroy function for the group
-	content = "\n"
+	content = "# Check for missing vanilla blocks\n"
 	for block_id in unique_blocks_sorted:
 		score_check: str = f"score #total_vanilla_{block_id.replace('minecraft:','')} {ns}.data matches 1.."
 		block_underscore = block_id.replace(":","_")
@@ -319,15 +457,34 @@ execute at @s run tp @s ^ ^ ^0.1
 		if block_id != CUSTOM_BLOCK_ALTERNATIVE:
 			content += (
 				f"execute if {score_check} if entity @s[tag={ns}.vanilla.{block_underscore}] "
-				f"unless block ~ ~ ~ {block_id} run function {ns}:custom_blocks/_groups/{block_underscore}\n"
+				f"unless block ~ ~ ~ {block_id} run return run function {ns}:custom_blocks/_groups/{block_underscore}\n"
 			)
 		else:
 			content += (
 				f"execute if {score_check} if entity @s[tag={ns}.vanilla.{block_underscore}] "
-				f"unless items entity @s contents *[minecraft:custom_data~{{{ns}:{{item_frame_destroy:true}}}}] run function {ns}:custom_blocks/_groups/{block_underscore}\n"
+				f"unless items entity @s contents *[minecraft:custom_data~{{{ns}:{{item_frame_destroy:true}}}}] run return run function {ns}:custom_blocks/_groups/{block_underscore}\n"
 			)
 	write_function(f"{ns}:custom_blocks/destroy", content)
 
+	# If there are growing seeds, we need to check the block below to see if it's still valid
+	if has_growing_seed:
+		content = ""
+		for item, data in Mem.definitions.items():
+			growing_seed: JsonDict = data.get(GROWING_SEED, {})
+			if growing_seed:
+				planted_on: str = growing_seed.get("planted_on", "dirt")
+				content += (
+					f"execute if score #total_{item} {ns}.data matches 1.. if entity @s[tag={ns}.{item}] "
+					f"""unless block ~ ~-1 ~ {planted_on} run return run function {ns}:custom_blocks/no_block_below {{item:"{item}"}}\n"""
+				)
+		write_function(f"{ns}:custom_blocks/destroy_growing_seeds", content)
+		write_function(f"{ns}:custom_blocks/no_block_below", f"""
+# Break the block we're at and call the destroy function
+execute if entity @s[type=item_frame] run summon item ~ ~ ~ {{Item:{{id:"minecraft:item_frame",count:1,components:{{"minecraft:custom_data":{{"{ns}":{{"item_frame_destroy":true}}}}}}}}}}
+execute if entity @s[type=item_display] run setblock ~ ~ ~ air destroy
+$function {ns}:custom_blocks/$(item)/destroy
+""")
+
 	# For each unique block, make the group function
 	for block_id in unique_blocks_sorted:
 
@@ -369,7 +526,6 @@ execute at @s run tp @s ^ ^ ^0.1
 	for item, data in Mem.definitions.items():
 		if data.get(VANILLA_BLOCK):
 			vanilla_block: JsonDict = data[VANILLA_BLOCK]
-			path = f"{ns}:custom_blocks/{item}"
 			if vanilla_block.get("id"):
 				block_id: str = vanilla_block["id"].split('[')[0].split('{')[0]
 			elif vanilla_block.get("contents", False):
@@ -385,6 +541,9 @@ execute at @s run tp @s ^ ^ ^0.1
 # Replace the item with the custom one
 execute as @n[type=item,nbt={{Item:{item_nbt}}},distance=..1] run function {ns}:custom_blocks/{item}/replace_item
 """
+			# If growing seed, get the growth_time score
+			if GROWING_SEED in data:
+				content = content.replace("custom one", f"custom one\nscoreboard players operation #growth_time {ns}.data = @s {ns}.growth_time", 1)
 
 			# Decrease count scores for stats and optimization
 			content += f"""
@@ -395,20 +554,37 @@ scoreboard players remove #total_{item} {ns}.data 1
 """
 
 			# Add the destroy function
-			write_function(f"{path}/destroy", content + "\n# Kill the custom block entity\nkill @s\n")
+			write_function(f"{ns}:custom_blocks/{item}/destroy", content + "\n# Kill the custom block entity\nkill @s\n")
 
 			# Replace item function
-			if vanilla_block != VANILLA_BLOCK_FOR_ORES:
+			if not data.get(NO_SILK_TOUCH_DROP):
 				content = f"""
+# Replace the item with the custom one
 data modify entity @s Item.components set from storage {ns}:items all.{item}.components
 data modify entity @s Item.id set from storage {ns}:items all.{item}.id
 """
 			else:
+				# If no VANILLA_BLOCK_FOR_ORES, check if the player has silk touch in mainhand
+				if data.get(VANILLA_BLOCK) != VANILLA_BLOCK_FOR_ORES:
+					write_function(f"{ns}:custom_blocks/{item}/destroy", f"""
+# Check if the player has silk touch in mainhand
+scoreboard players set #is_silk_touch {ns}.data 0
+execute as @p[distance=..10,gamemode=!spectator] if data entity @s SelectedItem.components."minecraft:enchantments"."minecraft:silk_touch" run scoreboard players set #is_silk_touch {ns}.data 1
+
+# If no item found, summon it
+execute unless entity @n[type=item,nbt={{Item:{item_nbt}}},distance=..1] run loot spawn ~ ~ ~ loot {{pools:[{{entries:[{{type:"minecraft:item",name:"minecraft:glass"}}],rolls:1}}]}}
+""", prepend=True)
+
+				# Handle no silk touch drop
 				no_silk_touch_drop: str | JsonDict = data[NO_SILK_TOUCH_DROP]
 				if isinstance(no_silk_touch_drop, dict):
 					item_to_drop: str = no_silk_touch_drop["id"]
-					item_count_min: int = no_silk_touch_drop["count"]["min"]
-					item_count_max: int = no_silk_touch_drop["count"]["max"]
+					if isinstance(no_silk_touch_drop.get("count"), int):
+						item_count_min = no_silk_touch_drop["count"]
+						item_count_max = no_silk_touch_drop["count"]
+					else:
+						item_count_min = no_silk_touch_drop["count"]["min"]
+						item_count_max = no_silk_touch_drop["count"]["max"]
 				else:
 					item_to_drop: str = no_silk_touch_drop
 					item_count_min: int = 1
@@ -436,11 +612,21 @@ execute if score #is_silk_touch {ns}.data matches 1 run data modify entity @s It
 
 # Else, no silk touch
 {silk_text}
-
+"""
+				if data.get(VANILLA_BLOCK) == VANILLA_BLOCK_FOR_ORES:
+					content += f"""
 # Get item count in every case
 execute store result entity @s Item.count byte 1 run scoreboard players get #item_count {ns}.data
 """
-			write_function(f"{path}/replace_item", content)
+			# If growing seed, call the loot table function
+			if GROWING_SEED in data:
+				content += f"""
+# Check if the seed is fully grown
+function {ns}:custom_blocks/{item}/is_fully_grown
+"""
+
+			# Write the function
+			write_function(f"{ns}:custom_blocks/{item}/replace_item", content)
 
 
 	# Write the used_vanilla_blocks tag, the predicate to check the blocks with the tag and an advanced one
@@ -501,6 +687,11 @@ execute if {score_check} as @e[type=#{ns}:custom_blocks,tag={ns}.custom_block,ta
 	write_versioned_function("second_5", f"""
 # 5 seconds break detection (item display only)
 execute if {score_check} as @e[type=item_display,tag={ns}.custom_block,predicate=!{ns}:advanced_check_vanilla_blocks] at @s run function {ns}:custom_blocks/destroy
+""")
+	if has_growing_seed:
+		write_versioned_function("second_5", f"""
+# 5 seconds growing seed break detection (below block check)
+execute if score #total_growing_seeds {ns}.data matches 1.. as @e[type=#{ns}:custom_blocks,tag={ns}.growing_seed] at @s run function {ns}:custom_blocks/destroy_growing_seeds
 """)
 	# Write the entity type tag for custom blocks
 	ctx.data[ns].entity_type_tags["custom_blocks"] = set_json_encoder(EntityTypeTag({"values": sorted(custom_block_entities)}))
@@ -558,6 +749,14 @@ execute as @n[type=item,nbt={{Item:{{id:"minecraft:item_frame"}}}},distance=..1]
 		f'scoreboard players add #total_custom_blocks {ns}.data 0',
 		prepend = True
 	)
+	if has_growing_seed:
+		write_function(f"{ns}:_stats_custom_blocks",
+			f'tellraw @s [{{"text":"- Total growing seeds: ","color":"dark_aqua"}},{{"score":{{"name":"#total_growing_seeds","objective":"{ns}.data"}},"color":"aqua"}}]'
+		)
+		write_function(f"{ns}:_stats_custom_blocks",
+			f'scoreboard players add #total_growing_seeds {ns}.data 0',
+			prepend = True
+		)
 
 
 

stewbeet-2.2.7/stewbeet/plugins/finalyze/custom_blocks_ticking/__init__.py

@@ -0,0 +1,67 @@
+
+# Imports
+from beet import Context
+from stouputils.decorators import measure_time
+from stouputils.print import progress
+
+from ....core.__memory__ import Mem
+from ....core.utils.io import write_function, write_versioned_function
+
+
+# Main entry point
+@measure_time(progress, message="Execution time of 'stewbeet.plugins.finalyze.custom_blocks_ticking'")
+def beet_default(ctx: Context):
+	""" Main entry point for the custom blocks ticking plugin.
+	This plugin sets up custom blocks ticks and second functions calls.
+
+	It will seek for "second.mcfunction", "tick.mcfunction", and more files in the custom_blocks folder
+	Then it will generate all functions to lead to the execution of these files by adding tags.
+
+	Args:
+		ctx (Context): The beet context.
+	"""
+	if Mem.ctx is None: # pyright: ignore[reportUnnecessaryComparison]
+		Mem.ctx = ctx
+
+	# Get namespace
+	assert ctx.project_id, "Project ID is not set. Please set it in the project configuration."
+	ns: str = ctx.project_id
+
+	# Get ticks functions from the context
+	for ticking in ["tick", "tick_2", "second", "second_5", "minute"]:
+		custom_blocks_tick: list[str] = []
+
+		# Check for custom block functions in the data pack
+		for function_path in ctx.data.functions:
+			if function_path.startswith(f"{ns}:custom_blocks/") and "/" in function_path[len(f"{ns}:custom_blocks/"):]:
+
+				# Split the path to get custom block name and function type
+				parts = function_path[len(f"{ns}:custom_blocks/"):].split("/")
+				if len(parts) == 2:
+					custom_block, function_name = parts
+					if function_name == ticking:
+						custom_blocks_tick.append(custom_block)
+
+		# For each custom block, add tags when placed
+		for custom_block in custom_blocks_tick:
+			write_function(f"{ns}:custom_blocks/{custom_block}/place_secondary",
+				f"# Add tag for loop every {ticking}\ntag @s add {ns}.{ticking}\nscoreboard players add #{ticking}_entities {ns}.data 1\n")
+			write_function(f"{ns}:custom_blocks/{custom_block}/destroy",
+				f"# Decrease the number of entities with {ticking} tag\nscoreboard players remove #{ticking}_entities {ns}.data 1\n")
+
+		# Write ticking functions
+		if custom_blocks_tick:
+			score_check: str = f"score #{ticking}_entities {ns}.data matches 1.."
+			write_versioned_function(ticking, f"# Custom blocks {ticking} functions\nexecute if {score_check} as @e[tag={ns}.{ticking}] at @s run function {ns}:custom_blocks/{ticking}")
+
+			content = "\n".join(
+				f"execute if entity @s[tag={ns}.{custom_block}] run function {ns}:custom_blocks/{custom_block}/{ticking}"
+				for custom_block in custom_blocks_tick
+			)
+			write_function(f"{ns}:custom_blocks/{ticking}", content)
+
+			# Write in stats_custom_blocks
+			write_function(f"{ns}:_stats_custom_blocks", f'scoreboard players add #{ticking}_entities {ns}.data 0', prepend=True)
+			write_function(f"{ns}:_stats_custom_blocks",
+				f'tellraw @s [{{"text":"- \'{ticking}\' tag function: ","color":"green"}},{{"score":{{"name":"#{ticking}_entities","objective":"{ns}.data"}},"color":"dark_green"}}]')
+

{stewbeet-2.2.5 → stewbeet-2.2.7}/stewbeet/plugins/ingame_manual/image_utils.py

@@ -111,7 +111,7 @@ def generate_high_res_font(item: str, item_image: Image.Image, count: int = 1) -
 		str: The font to the generated texture
 	"""
 	font = get_next_font()
-	item = f"{item}_{count}" if isinstance(count, str) or count > 1 else item
+	item = f"{item}_{str(count).replace('-', '_')}" if isinstance(count, str) or count > 1 else item
 
 	# Get output path
 	path = f"{SharedMemory.cache_path}/font/high_res/{item}.png"