381 lines
16 KiB
Python
381 lines
16 KiB
Python
import re
|
|
from PIL import Image, ImageDraw, ImageFont # Make sure ImageDraw is imported
|
|
import os
|
|
import zipfile
|
|
|
|
TEXTURE_SIZE = 16 # Default Minecraft texture size in pixels
|
|
|
|
# --- Constants for Blueprint Generation ---
|
|
OUTPUT_BLUEPRINT_DIR = "blueprints" # Directory to save generated blueprints
|
|
|
|
# --- Define the name for your missing texture file ---
|
|
MISSING_TEXTURE_FILENAME = "missing_texture.png" # Make sure this matches your file name
|
|
|
|
|
|
# --- Function to extract base block name from Java block string ---
|
|
def get_base_java_block_name(java_block_string, overrides):
|
|
"""
|
|
Extracts the base block name (e.g., 'stone', 'oak_log') from a full
|
|
Java block string (e.g., 'minecraft:stone', 'minecraft:oak_log[axis=y]'),
|
|
applying texture name overrides.
|
|
"""
|
|
# 1. Get the raw base name from the Java block string
|
|
name_without_prefix = java_block_string.replace("minecraft:", "")
|
|
raw_base_name = name_without_prefix.split('[')[0] # e.g., "spruce_trapdoor"
|
|
|
|
# 2. Apply override if defined, otherwise return the raw_base_name
|
|
overridden_name = overrides.get(raw_base_name, raw_base_name)
|
|
|
|
return overridden_name
|
|
|
|
def parse_block_states(java_block_string):
|
|
"""
|
|
Parses a Java block string to extract its state properties.
|
|
e.g., "minecraft:spruce_trapdoor[facing=north,half=bottom]" -> {'facing': 'north', 'half': 'bottom'}
|
|
"""
|
|
states = {}
|
|
match = re.search(r'\[(.*?)\]', java_block_string)
|
|
if match:
|
|
properties_str = match.group(1)
|
|
# Split by comma, then by equals sign
|
|
for prop_pair in properties_str.split(','):
|
|
if '=' in prop_pair:
|
|
key, value = prop_pair.split('=', 1)
|
|
states[key] = value
|
|
return states
|
|
|
|
def extract_java_textures(java_jar_path, output_dir):
|
|
"""
|
|
Extracts block textures from a Minecraft Java Edition client JAR.
|
|
|
|
Args:
|
|
java_jar_path (str): Full path to the Minecraft client JAR file.
|
|
output_dir (str): Directory where the extracted textures will be saved (e.g., 'java_textures' will be created inside this).
|
|
"""
|
|
if not os.path.exists(java_jar_path):
|
|
print(f"Error: Java JAR file not found at {java_jar_path}")
|
|
return
|
|
|
|
texture_source_path_in_jar = 'assets/minecraft/textures/block/'
|
|
extracted_texture_path = os.path.join(output_dir, 'java_textures') # Save to a subfolder
|
|
|
|
os.makedirs(extracted_texture_path, exist_ok=True)
|
|
|
|
print(f"Extracting textures from {java_jar_path} to {extracted_texture_path}...")
|
|
|
|
with zipfile.ZipFile(java_jar_path, 'r') as zip_ref:
|
|
for member in zip_ref.namelist():
|
|
if member.startswith(texture_source_path_in_jar) and member.endswith('.png'):
|
|
# Get the relative path within the block textures folder
|
|
relative_path = os.path.relpath(member, texture_source_path_in_jar)
|
|
|
|
# Construct the full output path
|
|
destination_path = os.path.join(extracted_texture_path, relative_path)
|
|
|
|
# Ensure the directory exists
|
|
os.makedirs(os.path.dirname(destination_path), exist_ok=True)
|
|
|
|
# Extract the file
|
|
with open(destination_path, 'wb') as outfile:
|
|
outfile.write(zip_ref.read(member))
|
|
|
|
print("Texture extraction complete.")
|
|
|
|
def create_arrow_texture(direction, size=TEXTURE_SIZE):
|
|
"""
|
|
Creates a red arrow pointing in the specified direction.
|
|
Args:
|
|
direction (str): 'north', 'south', 'east', 'west'.
|
|
size (int): The size of the square texture (e.g., 16).
|
|
Returns:
|
|
PIL.Image: An RGBA image of the arrow.
|
|
"""
|
|
arrow_img = Image.new('RGBA', (size, size), (0, 0, 0, 0)) # Transparent background
|
|
draw = ImageDraw.Draw(arrow_img)
|
|
|
|
line_color = (255, 0, 0, 255) # Red with full alpha
|
|
line_width = 1 # Pixels
|
|
|
|
center_x, center_y = size // 2, size // 2
|
|
|
|
# Define arrow head size relative to TEXTURE_SIZE
|
|
# head_size = size // 4 # Example: 4 pixels for 16x16 texture
|
|
head_size = size // 8 # Example: 2 pixels for 16x16 texture
|
|
|
|
if direction == 'north': # Arrow points up (towards decreasing Z)
|
|
draw.line([(center_x, size), (center_x, 0)], fill=line_color, width=line_width)
|
|
draw.polygon([(center_x, 0), (center_x - head_size, head_size), (center_x + head_size, head_size)], fill=line_color)
|
|
elif direction == 'south': # Arrow points down (towards increasing Z)
|
|
draw.line([(center_x, 0), (center_x, size)], fill=line_color, width=line_width)
|
|
draw.polygon([(center_x, size), (center_x - head_size, size - head_size), (center_x + head_size, size - head_size)], fill=line_color)
|
|
elif direction == 'west': # Arrow points left (towards decreasing X)
|
|
draw.line([(size, center_y), (0, center_y)], fill=line_color, width=line_width)
|
|
draw.polygon([(0, center_y), (head_size, center_y - head_size), (head_size, center_y + head_size)], fill=line_color)
|
|
elif direction == 'east': # Arrow points right (towards increasing X)
|
|
draw.line([(0, center_y), (size, center_y)], fill=line_color, width=line_width)
|
|
draw.polygon([(size, center_y), (size - head_size, center_y - head_size), (size - head_size, center_y + head_size)], fill=line_color)
|
|
else:
|
|
print(f"Warning: Unknown direction '{direction}' for arrow.")
|
|
return Image.new('RGBA', (size, size), (0, 0, 0, 0)) # Return transparent if direction is invalid
|
|
|
|
return arrow_img
|
|
|
|
def draw_door_state_overlay(texture: Image.Image, is_open: bool):
|
|
"""
|
|
Draws a small overlay symbol in the top-left corner of the texture to indicate door state.
|
|
- Green open rectangle for open
|
|
- Red closed rectangle for closed
|
|
"""
|
|
draw = ImageDraw.Draw(texture)
|
|
size = texture.width
|
|
overlay_size = size // 4 # 1/4 of texture size
|
|
|
|
x0, y0 = 2, 2
|
|
x1, y1 = x0 + overlay_size, y0 + overlay_size
|
|
|
|
if is_open:
|
|
# Draw a green open rectangle (open door shape)
|
|
draw.rectangle([x0, y0, x1, y1], outline=(0, 200, 0, 255), width=2)
|
|
# Draw a gap to indicate "open"
|
|
draw.line([x0 + overlay_size//2, y0, x1, y1], fill=(0, 200, 0, 255), width=2)
|
|
else:
|
|
# Draw a red closed rectangle (closed door shape)
|
|
draw.rectangle([x0, y0, x1, y1], outline=(200, 0, 0, 255), width=2)
|
|
# Draw a line to indicate "closed"
|
|
draw.line([x0, y0, x1, y1], fill=(200, 0, 0, 255), width=2)
|
|
|
|
def combine_door_halves(
|
|
bottom_texture: Image.Image,
|
|
top_texture: Image.Image,
|
|
half: str = "lower",
|
|
overlay_opacity: int = 128 # 0-255, 128 = 50% opacity
|
|
) -> Image.Image:
|
|
"""
|
|
Combines the bottom and top door textures into a single 16x16 image.
|
|
The 'other' half is shown with a semi-transparent white overlay.
|
|
Args:
|
|
bottom_texture: PIL.Image for the door bottom (8x16 or 16x16, will be cropped).
|
|
top_texture: PIL.Image for the door top (8x16 or 16x16, will be cropped).
|
|
half: "lower" or "upper" (which half is the real one)
|
|
overlay_opacity: Opacity for the overlay (0=transparent, 255=opaque)
|
|
Returns:
|
|
PIL.Image: The combined 16x16 image.
|
|
"""
|
|
# Ensure both textures are 16x16 (crop or resize if needed)
|
|
size = 16
|
|
bottom = bottom_texture.crop((0, 0, size, size))
|
|
top = top_texture.crop((0, 0, size, size))
|
|
|
|
# Create a new blank image
|
|
combined = Image.new("RGBA", (size, size), (0, 0, 0, 0))
|
|
|
|
if half == "lower":
|
|
# Place bottom half as normal
|
|
combined.paste(bottom, (0, 8))
|
|
# Place top half above, faded
|
|
faded_top = top.crop((0, 0, size, 8)).copy()
|
|
overlay = Image.new("RGBA", (size, 8), (255, 255, 255, overlay_opacity))
|
|
faded_top = Image.alpha_composite(faded_top, overlay)
|
|
combined.paste(faded_top, (0, 0), faded_top)
|
|
else: # half == "upper"
|
|
# Place top half as normal
|
|
combined.paste(top, (0, 0))
|
|
# Place bottom half below, faded
|
|
faded_bottom = bottom.crop((0, 8, size, 16)).copy()
|
|
overlay = Image.new("RGBA", (size, 8), (255, 255, 255, overlay_opacity))
|
|
faded_bottom = Image.alpha_composite(faded_bottom, overlay)
|
|
combined.paste(faded_bottom, (0, 8), faded_bottom)
|
|
|
|
return combined
|
|
|
|
def draw_door_overlay_symbols(
|
|
texture: Image.Image,
|
|
show_lock: bool = False,
|
|
hinge_side: str = "left"
|
|
):
|
|
"""
|
|
Draws overlay symbols in the top-left corner of the texture for doors:
|
|
- Optionally draws an unlocked (open) padlock (if show_lock is True)
|
|
- Optionally draws a small gray vertical bar on the hinge side ('left' or 'right')
|
|
Args:
|
|
texture (PIL.Image): The texture to draw on.
|
|
show_lock (bool): If True, draws an unlocked padlock.
|
|
hinge_side (str): 'left' or 'right' to indicate hinge side, or None.
|
|
"""
|
|
|
|
# Flip texture if hinge is right
|
|
if hinge_side =="right":
|
|
texture = texture.transpose(Image.FLIP_LEFT_RIGHT)
|
|
|
|
draw = ImageDraw.Draw(texture)
|
|
size = texture.width
|
|
overlay_size = size // 4 # 1/4 of texture size
|
|
|
|
x0, y0 = 2, 2
|
|
x1, y1 = x0 + overlay_size, y0 + overlay_size
|
|
|
|
# Draw hinge bar if specified
|
|
if hinge_side in ("left", "right"):
|
|
bar_width = max(1, overlay_size // 6)
|
|
bar_color = (120, 120, 120, 255) # Gray
|
|
if hinge_side == "left":
|
|
bar_x0 = x0
|
|
bar_x1 = x0 + bar_width
|
|
else: # "right"
|
|
bar_x0 = x1 - bar_width
|
|
bar_x1 = x1
|
|
draw.rectangle([bar_x0, y0, bar_x1, y1], fill=bar_color)
|
|
|
|
if show_lock:
|
|
# Draw an unlocked (open) padlock
|
|
lock_body_top = y1 - overlay_size // 3
|
|
lock_body_bottom = y1 - 2
|
|
lock_body_left = x0 + overlay_size // 4
|
|
lock_body_right = x1 - overlay_size // 4
|
|
# Body of the lock
|
|
draw.rectangle(
|
|
[lock_body_left, lock_body_top, lock_body_right, lock_body_bottom],
|
|
fill=(200, 200, 0, 255), outline=(120, 120, 0, 255), width=1
|
|
)
|
|
# Shackle of the lock (open arc)
|
|
shackle_box = [
|
|
lock_body_left - overlay_size // 8, lock_body_top - overlay_size // 4,
|
|
lock_body_right + overlay_size // 8, lock_body_top + overlay_size // 4
|
|
]
|
|
# Draw only part of the arc to look "open"
|
|
draw.arc(shackle_box, start=30, end=150, fill=(120, 120, 0, 255), width=2)
|
|
|
|
def render_grid(
|
|
textures_2d,
|
|
texture_size,
|
|
normal_padding=1,
|
|
bold_padding=3,
|
|
grid_line_color=(150, 150, 150, 255),
|
|
grid_line_bold_color=(80, 80, 80, 255),
|
|
grid_line_width=1,
|
|
grid_line_bold_width=3,
|
|
font_path="arial.ttf",
|
|
font_size=10,
|
|
margin=24
|
|
):
|
|
"""
|
|
Renders a 2D grid of textures with variable padding for gridlines, bold every 5th line,
|
|
and draws numbering outside the grid in an expanded canvas.
|
|
Args:
|
|
textures_2d: 2D list of PIL.Image objects (row-major: [z][x])
|
|
texture_size: Size of each texture square (pixels)
|
|
normal_padding: Space (pixels) between cells for normal gridlines
|
|
bold_padding: Space (pixels) between cells for every 5th (bold) gridline
|
|
grid_line_color: Color for normal grid lines
|
|
grid_line_bold_color: Color for every 5th grid line
|
|
grid_line_width: Width for normal grid lines
|
|
grid_line_bold_width: Width for every 5th grid line
|
|
font_path: Path to the font file
|
|
font_size: Font size for numbering
|
|
margin: Margin in pixels for numbering outside the grid
|
|
Returns:
|
|
PIL.Image: The rendered grid image with variable padding, gridlines, and outside numbering
|
|
"""
|
|
length = len(textures_2d)
|
|
width = len(textures_2d[0]) if length > 0 else 0
|
|
|
|
# Build padding arrays for columns and rows
|
|
paddings_col = []
|
|
for col in range(width + 1):
|
|
if col % 5 == 0:
|
|
paddings_col.append(bold_padding)
|
|
else:
|
|
paddings_col.append(normal_padding)
|
|
paddings_row = []
|
|
for row in range(length + 1):
|
|
if row % 5 == 0:
|
|
paddings_row.append(bold_padding)
|
|
else:
|
|
paddings_row.append(normal_padding)
|
|
|
|
# Calculate total image size (without margin)
|
|
img_width = width * texture_size + sum(paddings_col)
|
|
img_height = length * texture_size + sum(paddings_row)
|
|
|
|
# Create expanded image with margin for numbering (top and left)
|
|
expanded_width = img_width + margin
|
|
expanded_height = img_height + margin
|
|
out_img = Image.new('RGBA', (expanded_width, expanded_height), (255, 255, 255, 0))
|
|
draw = ImageDraw.Draw(out_img)
|
|
|
|
# Try to load a default font; fallback if not available
|
|
try:
|
|
font = ImageFont.truetype(font_path, font_size)
|
|
except Exception:
|
|
font = ImageFont.load_default()
|
|
|
|
# Precompute cumulative paddings for fast lookup
|
|
cum_paddings_col = [0]
|
|
for pad in paddings_col[:-1]:
|
|
cum_paddings_col.append(cum_paddings_col[-1] + pad + texture_size)
|
|
cum_paddings_row = [0]
|
|
for pad in paddings_row[:-1]:
|
|
cum_paddings_row.append(cum_paddings_row[-1] + pad + texture_size)
|
|
|
|
# Paste textures with variable padding, offset by margin
|
|
for z in range(length):
|
|
for x in range(width):
|
|
tx = margin + sum(paddings_col[:x+1]) + x * texture_size
|
|
ty = margin + sum(paddings_row[:z+1]) + z * texture_size
|
|
out_img.paste(textures_2d[z][x], (tx, ty), textures_2d[z][x])
|
|
|
|
# Draw vertical gridlines and outside numbering
|
|
x = margin
|
|
for col in range(width + 1):
|
|
is_bold = (col % 5 == 0)
|
|
color = grid_line_bold_color if is_bold else grid_line_color
|
|
line_width = grid_line_bold_width if is_bold else grid_line_width
|
|
pad = paddings_col[col]
|
|
offset = (pad - line_width) // 2
|
|
draw.line([(x + offset, margin), (x + offset, margin + img_height)], fill=color, width=line_width)
|
|
|
|
# Draw numbering outside the grid (above the grid)
|
|
if is_bold and col != 0 and x < margin + img_width:
|
|
text = str(col)
|
|
bbox = font.getbbox(text)
|
|
text_width = bbox[2] - bbox[0]
|
|
text_height = bbox[3] - bbox[1]
|
|
text_x = x + offset - text_width // 2 + line_width // 2
|
|
text_y = (margin - text_height - 2) if (margin - text_height - 2) > 0 else 2
|
|
draw.rectangle(
|
|
[text_x, text_y, text_x + text_width, text_y + text_height],
|
|
fill=(255, 255, 255, 180)
|
|
)
|
|
draw.text((text_x, text_y), text, fill=(0, 0, 0, 255), font=font)
|
|
x += pad + (texture_size if col < width else 0)
|
|
|
|
# Draw horizontal gridlines and outside numbering
|
|
y = margin
|
|
for row in range(length + 1):
|
|
is_bold = (row % 5 == 0)
|
|
color = grid_line_bold_color if is_bold else grid_line_color
|
|
line_width = grid_line_bold_width if is_bold else grid_line_width
|
|
pad = paddings_row[row]
|
|
offset = (pad - line_width) // 2
|
|
draw.line([(margin, y + offset), (margin + img_width, y + offset)], fill=color, width=line_width)
|
|
|
|
# Draw numbering outside the grid (to the left of the grid)
|
|
if is_bold and row != 0 and y < margin + img_height:
|
|
text = str(row)
|
|
bbox = font.getbbox(text)
|
|
text_width = bbox[2] - bbox[0]
|
|
text_height = bbox[3] - bbox[1]
|
|
text_x = (margin - text_width - 2) if (margin - text_width - 2) > 0 else 2
|
|
text_y = y + offset - text_height // 2 + line_width // 2
|
|
draw.rectangle(
|
|
[text_x, text_y, text_x + text_width, text_y + text_height],
|
|
fill=(255, 255, 255, 180)
|
|
)
|
|
draw.text((text_x, text_y), text, fill=(0, 0, 0, 255), font=font)
|
|
y += pad + (texture_size if row < length else 0)
|
|
|
|
return out_img
|
|
|
|
|
|
|