@playcraft/cli 0.0.44 → 0.0.47

package/project-templates/phaser/skills/playable-art/scripts/build-atlas.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""Pack source PNGs into Phaser 3 JSON Hash atlases."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+from import_gpt_art_pipeline import project_root
+
+ROOT = project_root()
+IMAGES = ROOT / "assets" / "images"
+OUT = ROOT / "assets" / "atlas"
+
+TILE_W = 176
+TILE_H = 216
+
+EXPECTED_FRAME_SIZES: dict[str, tuple[int, int]] = {
+    "wan_1": (176, 216), "wan_2": (176, 216), "wan_3": (176, 216),
+    "tong_1": (176, 216), "tong_2": (176, 216), "tong_3": (176, 216),
+    "tiao_1": (176, 216), "tiao_2": (176, 216), "tiao_3": (176, 216),
+    "gold": (176, 216), "back": (176, 216),
+    "digit_0": (48, 64), "digit_1": (48, 64), "digit_2": (48, 64),
+    "digit_3": (48, 64), "digit_4": (48, 64), "digit_5": (48, 64),
+    "digit_6": (48, 64), "digit_7": (48, 64), "digit_8": (48, 64),
+    "digit_9": (48, 64),
+    "digit_0_glow": (48, 64), "digit_1_glow": (48, 64), "digit_2_glow": (48, 64),
+    "digit_3_glow": (48, 64), "digit_4_glow": (48, 64), "digit_5_glow": (48, 64),
+    "digit_6_glow": (48, 64), "digit_7_glow": (48, 64), "digit_8_glow": (48, 64),
+    "digit_9_glow": (48, 64),
+    "digit_x": (48, 64), "digit_colon": (48, 64), "digit_slash": (48, 64),
+    "ui_cta_btn": (820, 190), "ui_timer_panel": (392, 96), "ui_pairs_panel": (392, 96),
+    "ui_knot": (190, 310), "ui_ingots": (310, 230), "ui_panda": (230, 300),
+    "ui_finger": (60, 90), "ui_highlight": (80, 80),
+    "ui_panel_win": (600, 360), "ui_panel_lose": (600, 360),
+    "ui_boot_title": (480, 80), "ui_boot_loading": (280, 48),
+    "reward_combo_bg": (300, 68), "reward_gift": (128, 128),
+    "reward_toast_1": (600, 120), "reward_toast_2": (600, 120), "reward_toast_3": (600, 120),
+    "reward_bonus_1": (640, 400), "reward_bonus_2": (640, 400), "reward_bonus_3": (640, 400),
+}
+
+ATLAS_SPECS = [
+    {
+        "name": "tiles",
+        "atlas_key": "atlas_tiles",
+        "entries": [
+            ("wan_1", "tiles/wan_1.png"),
+            ("wan_2", "tiles/wan_2.png"),
+            ("wan_3", "tiles/wan_3.png"),
+            ("tong_1", "tiles/tong_1.png"),
+            ("tong_2", "tiles/tong_2.png"),
+            ("tong_3", "tiles/tong_3.png"),
+            ("tiao_1", "tiles/tiao_1.png"),
+            ("tiao_2", "tiles/tiao_2.png"),
+            ("tiao_3", "tiles/tiao_3.png"),
+            ("gold", "tiles/gold.png"),
+            ("back", "tiles/back.png"),
+        ],
+    },
+    {
+        "name": "digits",
+        "atlas_key": "atlas_digits",
+        "entries": [
+            ("digit_0", "digits/0.png"),
+            ("digit_1", "digits/1.png"),
+            ("digit_2", "digits/2.png"),
+            ("digit_3", "digits/3.png"),
+            ("digit_4", "digits/4.png"),
+            ("digit_5", "digits/5.png"),
+            ("digit_6", "digits/6.png"),
+            ("digit_7", "digits/7.png"),
+            ("digit_8", "digits/8.png"),
+            ("digit_9", "digits/9.png"),
+            ("digit_0_glow", "digits/0_glow.png"),
+            ("digit_1_glow", "digits/1_glow.png"),
+            ("digit_2_glow", "digits/2_glow.png"),
+            ("digit_3_glow", "digits/3_glow.png"),
+            ("digit_4_glow", "digits/4_glow.png"),
+            ("digit_5_glow", "digits/5_glow.png"),
+            ("digit_6_glow", "digits/6_glow.png"),
+            ("digit_7_glow", "digits/7_glow.png"),
+            ("digit_8_glow", "digits/8_glow.png"),
+            ("digit_9_glow", "digits/9_glow.png"),
+            ("digit_x", "digits/x.png"),
+            ("digit_colon", "digits/colon.png"),
+            ("digit_slash", "digits/slash.png"),
+        ],
+    },
+    {
+        "name": "ui",
+        "atlas_key": "atlas_ui",
+        "entries": [
+            ("ui_cta_btn", "ui/cta_btn.png"),
+            ("ui_timer_panel", "ui/timer_panel.png"),
+            ("ui_pairs_panel", "ui/pairs_panel.png"),
+            ("ui_knot", "ui/knot.png"),
+            ("ui_ingots", "ui/ingots.png"),
+            ("ui_panda", "ui/panda.png"),
+            ("ui_finger", "ui/finger.png"),
+            ("ui_highlight", "ui/highlight.png"),
+            ("ui_panel_win", "ui/panel_win.png"),
+            ("ui_panel_lose", "ui/panel_lose.png"),
+            ("ui_boot_title", "ui/boot_title.png"),
+            ("ui_boot_loading", "ui/boot_loading.png"),
+        ],
+    },
+    {
+        "name": "rewards",
+        "atlas_key": "atlas_rewards",
+        "entries": [
+            ("reward_combo_bg", "rewards/combo_bg.png"),
+            ("reward_gift", "rewards/gift.png"),
+            ("reward_toast_1", "rewards/toast_1.png"),
+            ("reward_toast_2", "rewards/toast_2.png"),
+            ("reward_toast_3", "rewards/toast_3.png"),
+            ("reward_bonus_1", "rewards/bonus_1.png"),
+            ("reward_bonus_2", "rewards/bonus_2.png"),
+            ("reward_bonus_3", "rewards/bonus_3.png"),
+        ],
+    },
+]
+
+
+def next_power_of_two(value: int) -> int:
+    if value <= 1:
+        return 1
+    return 1 << (value - 1).bit_length()
+
+
+def normalize_image(image: Image.Image, frame_name: str, path: Path) -> Image.Image:
+    expected = EXPECTED_FRAME_SIZES.get(frame_name)
+    if not expected:
+        return image
+    ew, eh = expected
+    if image.size == (ew, eh):
+        return image
+    print(f"WARN: resize {path.name} {image.size[0]}x{image.size[1]} -> {ew}x{eh}")
+    return image.resize((ew, eh), Image.Resampling.LANCZOS)
+
+
+def load_image(path: Path, frame_name: str) -> Image.Image:
+    if path.exists():
+        return normalize_image(Image.open(path).convert("RGBA"), frame_name, path)
+
+    ew, eh = EXPECTED_FRAME_SIZES.get(frame_name, (280, 48))
+    image = Image.new("RGBA", (ew, eh), (42, 21, 0, 255))
+    draw = ImageDraw.Draw(image)
+    draw.text((ew // 2, eh // 2), path.stem, fill=(212, 168, 56, 255), anchor="mm")
+    print(f"WARN: placeholder generated for missing {path}")
+    return image
+
+
+def generate_fx_images() -> dict[str, Image.Image]:
+    glow_w = TILE_W + 12
+    glow_h = TILE_H + 12
+    glow = Image.new("RGBA", (glow_w, glow_h), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(glow)
+    draw.rounded_rectangle(
+        (2, 2, glow_w - 3, glow_h - 3),
+        radius=10,
+        fill=(212, 168, 56, 48),
+        outline=(255, 215, 0, 220),
+        width=5,
+    )
+
+    def soft_glow(size: int) -> Image.Image:
+        image = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+        gdraw = ImageDraw.Draw(image)
+        cx = cy = size // 2
+        for radius in range(size // 2, 0, -1):
+            t = radius / (size / 2)
+            alpha = int(240 * (1 - t) ** 2.2)
+            r = 255
+            g = int(210 + 30 * t)
+            b = int(90 + 70 * t)
+            gdraw.ellipse(
+                (cx - radius, cy - radius, cx + radius, cy + radius),
+                fill=(r, g, b, max(0, alpha)),
+            )
+        return image
+
+    def spark_streak(w: int, h: int) -> Image.Image:
+        image = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+        sdraw = ImageDraw.Draw(image)
+        cx = w // 2
+        for inset in range(0, w // 2):
+            t = inset / (w / 2)
+            alpha = int(255 * (1 - t) ** 1.6)
+            sdraw.rounded_rectangle(
+                (inset, 2, w - inset - 1, h - 3),
+                radius=max(1, (w // 2) - inset),
+                fill=(255, 236, 170, max(0, alpha)),
+            )
+        sdraw.line((cx, 0, cx, h - 1), fill=(255, 255, 240, 255), width=1)
+        return image
+
+    def tile_shard(w: int, h: int, face: tuple[int, int, int], edge: tuple[int, int, int]) -> Image.Image:
+        image = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+        sdraw = ImageDraw.Draw(image)
+        sdraw.rounded_rectangle((1, 1, w - 2, h - 2), radius=max(2, min(w, h) // 6), fill=face + (255,), outline=edge + (220,), width=1)
+        sdraw.line((2, 2, w - 3, 2), fill=(255, 255, 255, 70))
+        return image
+
+    return {
+        "particle_gold": soft_glow(32),
+        "particle_spark": spark_streak(10, 36),
+        "particle_shard_lg": tile_shard(28, 36, (245, 230, 200), (212, 168, 56)),
+        "particle_shard_md": tile_shard(20, 26, (245, 230, 200), (212, 168, 56)),
+        "particle_shard_sm": tile_shard(14, 18, (240, 224, 190), (196, 152, 48)),
+        "tile_glow": glow,
+    }
+
+
+def pack_frames(
+    frames: list[tuple[str, Image.Image]],
+    padding: int,
+    power_of_two: bool,
+) -> tuple[Image.Image, dict]:
+    if not frames:
+        raise ValueError("No frames to pack")
+
+    max_w = max(img.width for _, img in frames)
+    max_h = max(img.height for _, img in frames)
+    cell_w = max_w + padding * 2
+    cell_h = max_h + padding * 2
+
+    cols = max(1, math.ceil(math.sqrt(len(frames))))
+    rows = math.ceil(len(frames) / cols)
+
+    sheet_w = cols * cell_w
+    sheet_h = rows * cell_h
+
+    if power_of_two:
+        sheet_w = next_power_of_two(sheet_w)
+        sheet_h = next_power_of_two(sheet_h)
+
+    atlas = Image.new("RGBA", (sheet_w, sheet_h), (0, 0, 0, 0))
+    frame_data: dict = {}
+
+    for index, (name, image) in enumerate(frames):
+        col = index % cols
+        row = index // cols
+        x = col * cell_w + padding
+        y = row * cell_h + padding
+        atlas.paste(image, (x, y), image)
+
+        w, h = image.size
+        frame_data[name] = {
+            "frame": {"x": x, "y": y, "w": w, "h": h},
+            "rotated": False,
+            "trimmed": False,
+            "spriteSourceSize": {"x": 0, "y": 0, "w": w, "h": h},
+            "sourceSize": {"w": w, "h": h},
+        }
+
+    return atlas, frame_data
+
+
+def build_atlas(spec: dict, padding: int, power_of_two: bool) -> None:
+    frames: list[tuple[str, Image.Image]] = []
+
+    for frame_name, rel_path in spec["entries"]:
+        frames.append((frame_name, load_image(IMAGES / rel_path, frame_name)))
+
+    if spec["name"] == "fx":
+        for name, generated in generate_fx_images().items():
+            source = IMAGES / "fx" / f"{name}.png"
+            if source.exists():
+                frames.append((name, Image.open(source).convert("RGBA")))
+            else:
+                frames.append((name, generated))
+
+    atlas_image, frame_data = pack_frames(frames, padding, power_of_two)
+    png_path = OUT / f"{spec['name']}.png"
+    json_path = OUT / f"{spec['name']}.json"
+
+    save_atlas_png(atlas_image, png_path)
+    payload = {
+        "frames": frame_data,
+        "meta": {
+            "app": "build-atlas.py",
+            "version": "1.0",
+            "image": png_path.name,
+            "format": "RGBA8888",
+            "size": {"w": atlas_image.width, "h": atlas_image.height},
+            "scale": "1",
+        },
+    }
+    json_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    print(f"Built {png_path.name} ({len(frames)} frames, {atlas_image.width}x{atlas_image.height})")
+
+
+def save_atlas_png(image: Image.Image, path: Path) -> None:
+    """Save atlas PNGs compactly enough for playable-ad budgets."""
+    image.save(path, format="PNG", optimize=True)
+    if path.stat().st_size <= 1024 * 1024:
+        return
+
+    # Large GPT-generated UI atlases compress extremely well as indexed PNGs.
+    # Browser/Phaser can load them normally, and alpha remains suitable for sprites.
+    quantized = image.convert("RGBA").quantize(
+        colors=256,
+        method=Image.Quantize.FASTOCTREE,
+        dither=Image.Dither.NONE,
+    )
+    quantized.save(path, format="PNG", optimize=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Build Phaser 3 atlases")
+    parser.add_argument("--padding", type=int, default=2)
+    parser.add_argument("--power-of-two", action="store_true", default=True)
+    parser.add_argument("--no-power-of-two", action="store_false", dest="power_of_two")
+    args = parser.parse_args()
+
+    OUT.mkdir(parents=True, exist_ok=True)
+
+    for spec in ATLAS_SPECS:
+        build_atlas(spec, args.padding, args.power_of_two)
+
+    fx_spec = {"name": "fx", "atlas_key": "atlas_fx", "entries": []}
+    build_atlas(fx_spec, args.padding, args.power_of_two)
+
+    print(f"All atlases saved to {OUT}")
+
+
+if __name__ == "__main__":
+    main()

package/project-templates/phaser/skills/playable-art/scripts/chroma-key.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+Chroma key green background removal using PIL with configurable tolerance.
+Usage: python chroma-key.py <input.png> <output.png> [--tolerance 80]
+"""
+import argparse, sys
+from PIL import Image
+import numpy as np
+
+def chroma_key_array(img, key_color=(0, 255, 0), tolerance=80, feather=1.5):
+    """Remove green screen using numpy for speed."""
+    arr = np.array(img.convert('RGBA'))
+    r, g, b = key_color
+    
+    # Compute color distance
+    dr = arr[:,:,0].astype(np.float32) - r
+    dg = arr[:,:,1].astype(np.float32) - g
+    db = arr[:,:,2].astype(np.float32) - b
+    dist = np.sqrt(dr*dr + dg*dg + db*db)
+    
+    # Alpha based on distance: fully transparent within tolerance,
+    # feathered transition between tolerance and tolerance*feather
+    alpha = np.clip((dist - tolerance) / (tolerance * (feather - 1) + 1e-6), 0, 1)
+    alpha = (alpha * 255).astype(np.uint8)
+    
+    # Also desaturate green spill near the edge
+    green_dominance = arr[:,:,1].astype(np.float32) - (arr[:,:,0].astype(np.float32) + arr[:,:,2].astype(np.float32)) / 2
+    green_spill = np.clip(green_dominance / 80, 0, 1)
+    
+    # Reduce green channel where there's spill
+    arr[:,:,1] = np.clip(arr[:,:,1].astype(np.float32) - green_spill * 60, 0, 255).astype(np.uint8)
+    
+    arr[:,:,3] = np.minimum(arr[:,:,3], alpha)
+    return Image.fromarray(arr)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('input')
+    parser.add_argument('output')
+    parser.add_argument('--tolerance', type=int, default=80)
+    parser.add_argument('--feather', type=float, default=1.5)
+    args = parser.parse_args()
+    
+    img = Image.open(args.input)
+    out = chroma_key_array(img, tolerance=args.tolerance, feather=args.feather)
+    out.save(args.output)
+    print(f"Saved: {args.output}")
+
+if __name__ == '__main__':
+    main()

package/project-templates/phaser/skills/playable-art/scripts/extract-alpha-split.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Extract RGBA from a side-by-side RGB + grayscale alpha image."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+from PIL import Image, ImageOps
+
+
+def copy_raw(source: Path, raw_dir: Path | None) -> Path | None:
+    if raw_dir is None:
+        return None
+    raw_dir.mkdir(parents=True, exist_ok=True)
+    target = raw_dir / source.name
+    if source.resolve() != target.resolve():
+        shutil.copy2(source, target)
+    return target
+
+
+def extract_alpha_split(source: Path, output: Path) -> dict:
+    img = Image.open(source).convert("RGB")
+    if img.width % 2 != 0:
+        raise ValueError(f"{source} width must be even for left RGB / right alpha split")
+    half = img.width // 2
+    rgb = img.crop((0, 0, half, img.height)).convert("RGBA")
+    alpha_src = img.crop((half, 0, img.width, img.height))
+    alpha = ImageOps.grayscale(alpha_src)
+    rgb.putalpha(alpha)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    rgb.save(output)
+    return {
+        "source": str(source),
+        "output": str(output),
+        "width": half,
+        "height": img.height,
+        "mode": "RGBA",
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("source", type=Path, help="Side-by-side image: left RGB, right grayscale alpha")
+    parser.add_argument("output", type=Path, help="Output RGBA PNG/WebP path")
+    parser.add_argument("--raw-dir", type=Path, default=Path("assets/reference/raw"))
+    parser.add_argument("--no-raw-copy", action="store_true", help="Do not preserve source under raw-dir")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    raw_copy = copy_raw(args.source, None if args.no_raw_copy else args.raw_dir)
+    report = extract_alpha_split(args.source, args.output)
+    if raw_copy:
+        report["rawCopy"] = str(raw_copy)
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    else:
+        print(f"[alpha-split] wrote {args.output} ({report['width']}x{report['height']} RGBA)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/project-templates/phaser/skills/playable-art/scripts/extract-dual-bg-alpha.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Extract RGBA from two geometry-matched renders on different flat backgrounds."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+
+def parse_hex_color(raw: str) -> np.ndarray:
+    value = raw.strip().lstrip("#")
+    if len(value) != 6:
+        raise ValueError(f"Expected RRGGBB color, got {raw!r}")
+    return np.array([int(value[i : i + 2], 16) for i in (0, 2, 4)], dtype=np.float32)
+
+
+def copy_raw(paths: list[Path], raw_dir: Path | None) -> list[str]:
+    if raw_dir is None:
+        return []
+    raw_dir.mkdir(parents=True, exist_ok=True)
+    copied: list[str] = []
+    for source in paths:
+        target = raw_dir / source.name
+        if source.resolve() != target.resolve():
+            shutil.copy2(source, target)
+        copied.append(str(target))
+    return copied
+
+
+def extract_dual_bg(
+    image_a: Path,
+    image_b: Path,
+    output: Path,
+    bg_a: np.ndarray,
+    bg_b: np.ndarray,
+    residual_threshold: float,
+) -> dict:
+    a_img = Image.open(image_a).convert("RGB")
+    b_img = Image.open(image_b).convert("RGB")
+    if a_img.size != b_img.size:
+        raise ValueError(f"Geometry mismatch: {image_a} size {a_img.size} != {image_b} size {b_img.size}")
+
+    a = np.asarray(a_img, dtype=np.float32)
+    b = np.asarray(b_img, dtype=np.float32)
+    bg_delta = np.abs(bg_a - bg_b)
+    usable = bg_delta > 1
+    if not np.any(usable):
+        raise ValueError("Background colors must differ in at least one channel")
+
+    diff_ratio = np.abs(a[:, :, usable] - b[:, :, usable]) / bg_delta[usable]
+    alpha = 1.0 - np.clip(np.mean(diff_ratio, axis=2), 0.0, 1.0)
+    safe_alpha = np.maximum(alpha, 1.0 / 255.0)
+    rgb = (a - ((1.0 - alpha[:, :, None]) * bg_a)) / safe_alpha[:, :, None]
+    rgb = np.clip(rgb, 0, 255)
+
+    predicted_b = (alpha[:, :, None] * rgb) + ((1.0 - alpha[:, :, None]) * bg_b)
+    residual = float(np.mean(np.abs(predicted_b - b)))
+    if residual > residual_threshold:
+        raise ValueError(
+            f"dual-bg geometry residual {residual:.2f} > {residual_threshold:.2f}; "
+            "regenerate matched backgrounds or switch to rgb-alpha-split"
+        )
+
+    rgba = np.dstack([rgb, alpha * 255.0]).astype(np.uint8)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    Image.fromarray(rgba).save(output)
+    return {
+        "sourceA": str(image_a),
+        "sourceB": str(image_b),
+        "output": str(output),
+        "width": a_img.width,
+        "height": a_img.height,
+        "mode": "RGBA",
+        "geometryResidual": round(residual, 4),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("image_a", type=Path)
+    parser.add_argument("image_b", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--bg-a", required=True, help="Flat background color for image_a, RRGGBB")
+    parser.add_argument("--bg-b", required=True, help="Flat background color for image_b, RRGGBB")
+    parser.add_argument("--residual-threshold", type=float, default=4.0)
+    parser.add_argument("--raw-dir", type=Path, default=Path("assets/reference/raw"))
+    parser.add_argument("--no-raw-copy", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    raw_copies = copy_raw([args.image_a, args.image_b], None if args.no_raw_copy else args.raw_dir)
+    report = extract_dual_bg(
+        args.image_a,
+        args.image_b,
+        args.output,
+        parse_hex_color(args.bg_a),
+        parse_hex_color(args.bg_b),
+        args.residual_threshold,
+    )
+    if raw_copies:
+        report["rawCopies"] = raw_copies
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    else:
+        print(
+            f"[dual-bg-alpha] wrote {args.output} "
+            f"({report['width']}x{report['height']} RGBA, residual={report['geometryResidual']})"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())