stewbeet 2.0.22__tar.gz → 2.0.23__tar.gz

{stewbeet-2.0.22 → stewbeet-2.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stewbeet
-Version: 2.0.22
+Version: 2.0.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

{stewbeet-2.0.22 → stewbeet-2.0.23}/pyproject.toml

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

{stewbeet-2.0.22 → stewbeet-2.0.23}/stewbeet/plugins/archive/__init__.py

@@ -71,8 +71,15 @@ def beet_default(ctx: Context) -> None:
 		# This approach writes pack contents directly to a zip file without modifying the original pack structure
 
 		# First pass: Create the zip file normally
-		with zipfile.ZipFile(archive_path, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as zip_file:
-			pack.dump(zip_file)
+		for i in range(10):
+			try:
+				with zipfile.ZipFile(archive_path, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as zip_file:
+					pack.dump(zip_file)
+				break
+			except Exception:
+				if i == 9:
+					raise
+				time.sleep(0.5)
 
 		# Second pass: Read all contents and recreate with consistent timestamps
 		# This is necessary because beet's dump() uses origin.open() which bypasses writestr() completely

{stewbeet-2.0.22 → stewbeet-2.0.23}/stewbeet/plugins/ingame_manual/image_utils.py

@@ -30,14 +30,14 @@ def load_simple_case_no_border(high_res: bool) -> Image.Image:
 	return result
 
 
-def careful_resize(image: Image.Image, max_result_size: int) -> Image.Image:
+def careful_resize(image: Image.Image, max_result_size: int, resampling: Image.Resampling = Image.Resampling.NEAREST) -> Image.Image:
 	"""Resize an image while keeping the aspect ratio"""
 	if image.size[0] >= image.size[1]:
 		factor = max_result_size / image.size[0]
-		return image.resize((max_result_size, int(image.size[1] * factor)), Image.Resampling.NEAREST)
+		return image.resize((max_result_size, int(image.size[1] * factor)), resampling)
 	else:
 		factor = max_result_size / image.size[1]
-		return image.resize((int(image.size[0] * factor), max_result_size), Image.Resampling.NEAREST)
+		return image.resize((int(image.size[0] * factor), max_result_size), resampling)
 
 def add_border(image: Image.Image, border_color: tuple[int, int, int, int], border_size: int, is_rectangle_shape: bool) -> Image.Image:
 	"""Add a border to every part of the image"""

{stewbeet-2.0.22 → stewbeet-2.0.23}/stewbeet/plugins/ingame_manual/main.py

@@ -78,6 +78,7 @@ from .shared_import import (
 	get_page_font,
 	get_page_number,
 )
+from .showcase_image import generate_showcase_images
 
 
 # Utility functions
@@ -635,6 +636,11 @@ def routine():
 				f.write(super_json_dump(book_content))
 			debug(f"Debug book_content at '{relative_path(json_dump_path)}'")
 
+		# Generate showcase images if requested
+		showcase_image: int = manual_config.get("showcase_image", 3)
+		if showcase_image > 0:
+			generate_showcase_images(showcase_image, categories, simple_case)
+
 
 	# Copy the font provider and the generated textures to the resource pack
 	Mem.ctx.assets[Mem.ctx.project_id].fonts["manual"] = Font(source_path=f"{SharedMemory.cache_path}/font/manual.json")

stewbeet-2.0.23/stewbeet/plugins/ingame_manual/showcase_image.py

@@ -0,0 +1,130 @@
+
+# Imports
+import os
+
+from PIL import Image
+from stouputils.io import relative_path
+from stouputils.print import debug, warning
+
+from ...core.__memory__ import Mem
+from .image_utils import careful_resize
+from .shared_import import SharedMemory
+
+
+# Functions
+def calculate_optimal_grid(item_count: int) -> tuple[int, int]:
+	""" Calculate optimal grid dimensions for a given number of items to achieve closest to 16:9 ratio
+
+	Args:
+        item_count (int): The total number of items to arrange in the grid.
+    Returns:
+        tuple[int, int]: The optimal number of rows and columns for the grid.
+	"""
+	if item_count == 0:
+		return 0, 0
+
+	best_ratio_diff: float = float('inf')
+	best_rows, best_cols = 1, item_count
+	target_ratio: float = 16/9
+
+	# Try different configurations
+	for rows in range(1, item_count + 1):
+		cols: int = (item_count + rows - 1) // rows  # Ceiling division
+		if rows * cols >= item_count:
+			ratio: float = cols / rows
+			ratio_diff: float = abs(ratio - target_ratio)
+			if ratio_diff < best_ratio_diff:
+				best_ratio_diff = ratio_diff
+				best_rows, best_cols = rows, cols
+
+	return best_rows, best_cols
+
+def generate_showcase_images(showcase_mode: int, categories: dict[str, list], simple_case: Image.Image):
+	""" Generate showcase images based on the showcase_mode parameter
+
+    Args:
+        showcase_mode   (int): Mode for generating showcase images:
+            1 - Showcase items in the manual
+            2 - Showcase all items, even those not in the manual
+            3 - Showcase both manual items and all items
+        categories      (dict[str, list]): Dictionary of categories with items.
+        simple_case     (Image.Image): Image of a simple case to use as background for items.
+	"""
+	# Get items for manual (mode 1 or 3)
+	if showcase_mode in [1, 3]:
+		manual_items: list[str] = []
+		for items in categories.values():
+			manual_items.extend(items)
+		if manual_items:
+			create_showcase_image(manual_items, "all_manual_items.jpg", simple_case)
+
+	# Get all items (mode 2 or 3)
+	if showcase_mode in [2, 3]:
+		all_items: list[str] = list(Mem.definitions.keys())
+		if all_items:
+			create_showcase_image(all_items, "all_items.jpg", simple_case)
+
+def create_showcase_image(items: list[str], filename: str, simple_case: Image.Image):
+	""" Create a showcase image with items arranged in optimal grid for 16:9 ratio
+
+    Args:
+        items           (list[str]): List of item IDs to include in the showcase.
+        filename        (str): Name of the output image file.
+        simple_case     (Image.Image): Image of a simple case to use as background for items.
+	"""
+	if not items:
+		return
+
+	rows, cols = calculate_optimal_grid(len(items))
+
+	# Big case size to make sure textures are not distorted
+	case_size: int = 512
+
+	# Resize the simple case to match our calculated case size
+	resized_case: Image.Image = simple_case.resize((case_size, case_size), Image.Resampling.NEAREST)
+
+	# Calculate image dimensions with border
+	img_width: int = cols * case_size
+	img_height: int = rows * case_size
+
+	# Create image
+	showcase_image: Image.Image = Image.new("RGBA", (img_width, img_height), (0, 0, 0, 0))
+
+	# Place items
+	for i, item in enumerate(items):
+		row: int = i // cols
+		col: int = i % cols
+
+		x: int = col * case_size
+		y: int = row * case_size
+
+		# Get item texture
+		texture_path: str = f"{SharedMemory.cache_path}/items/{Mem.ctx.project_id}/{item}.png"
+		if os.path.exists(texture_path):
+			item_image: Image.Image = Image.open(texture_path)
+		else:
+			warning(f"Missing texture at '{texture_path}', using empty texture for showcase")
+			item_image: Image.Image = Image.new("RGBA", (1, 1), (0, 0, 0, 0))
+
+		# Resize item image to 89% of case size
+		target_size: int = int(case_size * (0.890625))
+		print(target_size)
+		resized_item: Image.Image = careful_resize(item_image, target_size)
+
+		# Center the resized item image within the case
+		item_x: int = x + (case_size - resized_item.size[0]) // 2
+		item_y: int = y + (case_size - resized_item.size[1]) // 2
+
+		# Paste the resized case and the item image
+		showcase_image.paste(resized_case, (x, y))
+		if resized_item.mode == "RGBA":
+			mask: Image.Image = resized_item.split()[3]
+			showcase_image.paste(resized_item, (item_x, item_y), mask)
+		else:
+			showcase_image.paste(resized_item, (item_x, item_y))
+
+	# Save to output directory
+	output_path = os.path.join(Mem.ctx.output_directory, filename)
+	showcase_image.save(output_path, "PNG")
+	debug(f"Generated showcase image: {relative_path(output_path)} ({rows}x{cols} grid, {len(items)} items)")
+