Files
Oshima-Game/tools/build_xinyin_motion_playback.py
2026-09-19 17:24:02 +08:00

203 lines
8.0 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
from __future__ import annotations
import argparse
import json
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont
ROOT = Path(__file__).resolve().parent.parent
PREVIEW_DIR = ROOT / "assets/images/2d-game-characters/02-xinyin/previews/playback"
BOARD_SIZE = (1200, 430)
PANEL_CENTERS = (220, 600, 980)
TARGETS = (
{"label": "100%", "height": 176, "cell": (128, 64)},
{"label": "75%", "height": 132, "cell": (96, 48)},
{"label": "50%", "height": 88, "cell": (64, 32)},
)
FOOT_BASELINE = 352
BACKGROUND = (16, 20, 29)
PANEL = (24, 30, 42)
PANEL_LINE = (65, 82, 112)
GRID_FILL = (39, 60, 84)
GRID_LINE = (87, 160, 222)
TEXT = (241, 245, 252)
MUTED = (151, 171, 201)
def load_font(size: int, semibold: bool = False) -> ImageFont.ImageFont:
font_name = "seguisb.ttf" if semibold else "segoeui.ttf"
path = Path("C:/Windows/Fonts") / font_name
if path.exists():
return ImageFont.truetype(str(path), size)
return ImageFont.load_default()
def alpha_bounds(image: Image.Image) -> tuple[int, int, int, int]:
bounds = image.getchannel("A").getbbox()
if bounds is None:
raise ValueError("Transparent frame has no visible pixels")
return bounds
def union_bounds(bounds_list: list[tuple[int, int, int, int]], size: tuple[int, int]) -> tuple[int, int, int, int]:
left = max(0, min(b[0] for b in bounds_list) - 8)
top = max(0, min(b[1] for b in bounds_list) - 8)
right = min(size[0], max(b[2] for b in bounds_list) + 8)
bottom = min(size[1], max(b[3] for b in bounds_list) + 8)
return left, top, right, bottom
def draw_diamond(draw: ImageDraw.ImageDraw, center_x: int, center_y: int, width: int, height: int) -> None:
points = [
(center_x, center_y - height // 2),
(center_x + width // 2, center_y),
(center_x, center_y + height // 2),
(center_x - width // 2, center_y),
]
draw.polygon(points, fill=GRID_FILL, outline=GRID_LINE, width=2)
def build_board(
title: str,
source: Image.Image,
crop: tuple[int, int, int, int],
fonts: dict[str, ImageFont.ImageFont],
) -> Image.Image:
board = Image.new("RGB", BOARD_SIZE, BACKGROUND)
draw = ImageDraw.Draw(board)
draw.text((38, 22), title, font=fonts["title"], fill=TEXT)
draw.text((40, 57), "fixed crop · fixed foot baseline · real frame timing", font=fonts["small"], fill=MUTED)
cropped = source.crop(crop)
crop_width, crop_height = cropped.size
for center_x, target in zip(PANEL_CENTERS, TARGETS):
panel_box = (center_x - 170, 92, center_x + 170, 402)
draw.rounded_rectangle(panel_box, radius=10, fill=PANEL, outline=PANEL_LINE, width=2)
draw.text((center_x - 145, 106), target["label"], font=fonts["label"], fill=TEXT)
draw.text(
(center_x - 145, 137),
f"character {target['height']} px · cell {target['cell'][0]}×{target['cell'][1]}",
font=fonts["small"],
fill=MUTED,
)
draw_diamond(draw, center_x, FOOT_BASELINE, target["cell"][0], target["cell"][1])
scale = target["height"] / crop_height
output_width = max(1, round(crop_width * scale))
resized = cropped.resize((output_width, target["height"]), Image.Resampling.LANCZOS)
paste_x = round(center_x - output_width / 2)
paste_y = FOOT_BASELINE - target["height"]
board.paste(resized, (paste_x, paste_y), resized)
draw.line((center_x - 7, FOOT_BASELINE, center_x + 7, FOOT_BASELINE), fill=(255, 88, 116), width=2)
return board
def save_gif(frames: list[Image.Image], durations: list[int], path: Path) -> None:
palette_source = Image.new("RGB", (BOARD_SIZE[0], BOARD_SIZE[1] * len(frames)), BACKGROUND)
for index, frame in enumerate(frames):
palette_source.paste(frame, (0, index * BOARD_SIZE[1]))
palette = palette_source.quantize(colors=256, method=Image.Quantize.MEDIANCUT)
paletted = [
frame.quantize(palette=palette, dither=Image.Dither.FLOYDSTEINBERG)
for frame in frames
]
paletted[0].save(
path,
save_all=True,
append_images=paletted[1:],
duration=durations,
loop=0,
disposal=2,
optimize=False,
)
def main() -> None:
parser = argparse.ArgumentParser(description="Build fixed-baseline motion playback previews for Xinyin.")
parser.add_argument("--direction", choices=("front-right", "front-left", "down", "up"), default="front-right")
parser.add_argument("--motion-version", type=int)
args = parser.parse_args()
motion_version = args.motion_version or (3 if args.direction == "front-right" else 1)
runtime_direction = {"front-right": "left", "front-left": "right", "down": "down", "up": "up"}[args.direction]
motion_dir = ROOT / f"assets/images/2d-game-characters/02-xinyin/motion/{args.direction}/v{motion_version}"
manifest_path = motion_dir / "motion-manifest.json"
report_path = motion_dir / "playback-report.json"
PREVIEW_DIR.mkdir(parents=True, exist_ok=True)
manifest = json.loads(manifest_path.read_text(encoding="utf-8-sig"))
definitions = {frame["name"]: frame for frame in manifest["frames"]}
images = {
name: Image.open(motion_dir / frame["file"]).convert("RGBA")
for name, frame in definitions.items()
}
source_size = next(iter(images.values())).size
if any(image.size != source_size for image in images.values()):
raise ValueError("Motion frames do not share a common canvas")
bounds_by_name = {name: alpha_bounds(image) for name, image in images.items()}
crop = union_bounds(list(bounds_by_name.values()), source_size)
crop_height = crop[3] - crop[1]
fonts = {
"title": load_font(25, semibold=True),
"label": load_font(20, semibold=True),
"small": load_font(13),
}
sequences = {
"idle": ["idle-inhale", "idle-neutral", "idle-exhale", "idle-neutral"],
"throw": ["throw-ready", "throw-windup", "throw-release", "throw-recover", "idle-neutral"],
}
outputs: dict[str, dict[str, object]] = {}
for sequence_name, names in sequences.items():
title = f"XIN YIN — {runtime_direction.upper()} {sequence_name.upper()} · 100 / 75 / 50%"
boards = [build_board(title, images[name], crop, fonts) for name in names]
durations = [int(definitions[name]["durationMs"]) for name in names]
output_path = PREVIEW_DIR / f"xinyin-{args.direction}-{sequence_name}-scale-loop-v1.gif"
save_gif(boards, durations, output_path)
outputs[sequence_name] = {
"file": output_path.relative_to(ROOT).as_posix(),
"frames": names,
"durationsMs": durations,
"cycleMs": sum(durations),
}
bottoms = [bounds[3] for bounds in bounds_by_name.values()]
report = {
"characterId": "02-xinyin",
"direction": args.direction,
"runtimeDirection": runtime_direction,
"version": 1,
"status": "playback-preview-validated",
"sourceManifest": manifest_path.relative_to(ROOT).as_posix(),
"sourceCanvas": {"width": source_size[0], "height": source_size[1]},
"fixedCrop": {"x": crop[0], "y": crop[1], "width": crop[2] - crop[0], "height": crop_height},
"footBaseline": FOOT_BASELINE,
"sourceVisibleBottomRange": {"min": min(bottoms), "max": max(bottoms), "delta": max(bottoms) - min(bottoms)},
"targets": list(TARGETS),
"outputs": outputs,
"notes": [
"All playback frames use one union crop and one foot baseline; no per-frame recentering is applied.",
"GIF timing uses the authored millisecond durations from motion-manifest.json.",
"The board background is diagnostic only; source motion PNG files remain transparent.",
],
}
report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
for image in images.values():
image.close()
print(f"Created {len(outputs)} animated playback previews.")
print(PREVIEW_DIR)
print(report_path)
if __name__ == "__main__":
main()