gitignore

.gitignore

@@ -34,3 +34,4 @@ memory/
 uv.lock
 frontend/music/*.mp3
 /trailer
+/scripts/trailer

scripts/make_trailer.py

@@ -1,459 +0,0 @@
-"""Build the Ephemeral Hearts demo trailer from real generated game assets.
-
-Composes 1920x1080 stills with PIL (title cards, backdrop shots, in-game scene
-mockups, a relations-graph shot, an ending shot), animates each with ffmpeg
-(Ken Burns zoom/pan), chains them with crossfades, and scores the result with
-three of the game's music tracks (joyful -> dramatic -> romantic) to showcase
-the dynamic-soundtrack feature.
-
-Usage:  uv run python scripts/make_trailer.py
-Output: trailer/ephemeral_hearts_trailer.mp4  (1280x720, ~48 s)
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-import numpy as np
-from PIL import Image, ImageDraw, ImageFilter, ImageFont
-
-ROOT = Path(__file__).resolve().parent.parent
-CACHE = ROOT / ".cache" / "images"
-MUSIC = ROOT / "frontend" / "music"
-OUT = ROOT / "trailer"
-STILLS = OUT / "stills"
-CLIPS = OUT / "clips"
-
-W, H = 1920, 1080          # still resolution (rendered down to 720p)
-FPS = 25
-XFADE = 0.5                # crossfade between clips
-MUSIC_XF = 1.5             # crossfade between music tracks
-
-BG_DARK = (12, 9, 20)
-GOLD = (232, 193, 114)
-INK = (236, 232, 242)
-GREY = (186, 180, 198)
-RED = (212, 116, 116)
-GREEN = (126, 204, 160)
-AMBER = (226, 172, 96)
-
-FONTS = Path("C:/Windows/Fonts")
-
-
-def font(name: str, size: int) -> ImageFont.FreeTypeFont:
-    return ImageFont.truetype(str(FONTS / name), size)
-
-
-# --------------------------------------------------------------------------- #
-#  PIL helpers
-# --------------------------------------------------------------------------- #
-
-def dark_canvas() -> Image.Image:
-    img = Image.new("RGB", (W, H), BG_DARK)
-    glow = Image.new("L", (W, H), 0)
-    d = ImageDraw.Draw(glow)
-    d.ellipse([W // 2 - 620, H // 2 - 330, W // 2 + 620, H // 2 + 330], fill=46)
-    glow = glow.filter(ImageFilter.GaussianBlur(180))
-    tint = Image.new("RGB", (W, H), (52, 40, 28))
-    return Image.composite(tint, img, glow)
-
-
-def draw_tracked(d, center_xy, text, fnt, fill, tracking=0):
-    widths = [d.textlength(c, font=fnt) for c in text]
-    total = sum(widths) + tracking * (len(text) - 1)
-    x = center_xy[0] - total / 2
-    asc, desc = fnt.getmetrics()
-    y = center_xy[1] - (asc + desc) / 2
-    for c, w in zip(text, widths):
-        d.text((x, y), c, font=fnt, fill=fill)
-        x += w + tracking
-
-
-def card(lines: list[tuple[str, str, int, tuple]], rule=True, icon=None) -> Image.Image:
-    """Text card: (text, font_file, size, color) per line, vertically centered."""
-    img = dark_canvas()
-    d = ImageDraw.Draw(img)
-    gap = 34
-    fnts = [font(ff, size) for _, ff, size, _ in lines]
-    heights = [sum(f.getmetrics()) for f in fnts]
-    block = sum(heights) + gap * (len(lines) - 1)
-    y = (H - block) / 2
-    if icon == "mic":
-        _mic(d, W // 2, int(y) - 150)
-        y += 20
-    elif rule:
-        d.rectangle([W // 2 - 60, y - 56, W // 2 + 60, y - 50], fill=GOLD)
-    for (text, _, _, color), f, h in zip(lines, fnts, heights):
-        d.text((W / 2, y + h / 2), text, font=f, fill=color, anchor="mm")
-        y += h + gap
-    return img
-
-
-def _mic(d: ImageDraw.ImageDraw, cx: int, cy: int):
-    """Small golden microphone glyph."""
-    d.rounded_rectangle([cx - 26, cy - 60, cx + 26, cy + 28], radius=26, fill=GOLD)
-    d.arc([cx - 52, cy - 24, cx + 52, cy + 62], 0, 180, fill=GOLD, width=8)
-    d.line([cx, cy + 62, cx, cy + 92], fill=GOLD, width=8)
-    d.line([cx - 30, cy + 96, cx + 30, cy + 96], fill=GOLD, width=8)
-
-
-def title_card(subtitle: str, extra: list[tuple[str, str, int, tuple]] | None = None) -> Image.Image:
-    img = dark_canvas()
-    d = ImageDraw.Draw(img)
-    cy = H // 2 - (60 if extra else 20)
-    draw_tracked(d, (W // 2, cy - 40), "EPHEMERAL HEARTS", font("georgiab.ttf", 116), GOLD, tracking=16)
-    d.rectangle([W // 2 - 360, cy + 58, W // 2 + 360, cy + 61], fill=(120, 100, 70))
-    d.text((W / 2, cy + 116), subtitle, font=font("georgiai.ttf", 46), fill=GREY, anchor="mm")
-    if extra:
-        y = cy + 230
-        for text, ff, size, color in extra:
-            d.text((W / 2, y), text, font=font(ff, size), fill=color, anchor="mm")
-            y += size + 34
-    return img
-
-
-def prep_backdrop(name: str, v_bias: float = 0.45) -> Image.Image:
-    img = Image.open(CACHE / name).convert("RGB").resize((W, W), Image.LANCZOS)
-    ytop = int((W - H) * v_bias)
-    return img.crop((0, ytop, W, ytop + H))
-
-
-def load_sprite(name: str) -> Image.Image:
-    """Sprites in cache already carry a rembg alpha channel."""
-    img = Image.open(CACHE / name)
-    if img.mode == "RGBA" and img.getchannel("A").getextrema()[0] == 0:
-        return img
-    # fallback: flood-fill white background from borders
-    rgb = np.asarray(img.convert("RGB")).astype(np.int16)
-    near = (rgb > 255 - 28).all(axis=2)
-    seed = np.zeros_like(near)
-    seed[0, :], seed[-1, :], seed[:, 0], seed[:, -1] = near[0, :], near[-1, :], near[:, 0], near[:, -1]
-    prev = -1
-    while seed.sum() != prev:
-        prev = seed.sum()
-        grown = seed.copy()
-        grown[1:, :] |= seed[:-1, :]
-        grown[:-1, :] |= seed[1:, :]
-        grown[:, 1:] |= seed[:, :-1]
-        grown[:, :-1] |= seed[:, 1:]
-        seed = grown & near
-    alpha = Image.fromarray(np.where(seed, 0, 255).astype(np.uint8))
-    alpha = alpha.filter(ImageFilter.MinFilter(3)).filter(ImageFilter.GaussianBlur(1.2))
-    out = img.convert("RGBA")
-    out.putalpha(alpha)
-    return out
-
-
-def heart(d: ImageDraw.ImageDraw, cx: int, cy: int, s: int, color):
-    d.ellipse([cx - s, cy - s, cx, cy], fill=color)
-    d.ellipse([cx, cy - s, cx + s, cy], fill=color)
-    d.polygon([(cx - s, cy - s // 3), (cx + s, cy - s // 3), (cx, cy + s)], fill=color)
-
-
-def scene(bg_name: str, sprite_name: str, speaker: str, line1: str, line2: str,
-          sprite_h: int = 940, sprite_cx: int = 1290, v_bias: float = 0.45,
-          delta: int | None = None) -> Image.Image:
-    """In-game look: backdrop + sprite + VN dialogue box (+ relationship delta)."""
-    img = prep_backdrop(bg_name, v_bias).convert("RGBA")
-    shade = Image.new("L", (W, H), 0)
-    ImageDraw.Draw(shade).rectangle([0, H - 480, W, H], fill=110)
-    shade = shade.filter(ImageFilter.GaussianBlur(120))
-    img = Image.composite(Image.new("RGBA", (W, H), (8, 6, 14, 255)), img, shade)
-
-    sp = load_sprite(sprite_name)
-    ratio = sprite_h / sp.height
-    sp = sp.resize((int(sp.width * ratio), sprite_h), Image.LANCZOS)
-    img.alpha_composite(sp, (sprite_cx - sp.width // 2, H - sprite_h + 30))
-
-    box = Image.new("RGBA", (W, H), (0, 0, 0, 0))
-    bd = ImageDraw.Draw(box)
-    bd.rounded_rectangle([110, 770, 1810, 1040], radius=28,
-                         fill=(12, 9, 20, 214), outline=(*GOLD, 210), width=3)
-    img.alpha_composite(box)
-
-    d = ImageDraw.Draw(img)
-    d.text((170, 800), speaker, font=font("georgiab.ttf", 46), fill=GOLD)
-    d.text((170, 878), line1, font=font("georgiai.ttf", 40), fill=INK)
-    d.text((170, 940), line2, font=font("georgiai.ttf", 40), fill=INK)
-    if delta is not None:
-        dx, dy = 1620, 700
-        d.text((dx, dy), f"+{delta}", font=font("georgiab.ttf", 58), fill=GOLD,
-               stroke_width=4, stroke_fill=(12, 9, 20))
-        heart(d, dx + 118, dy + 30, 26, RED)
-    return img.convert("RGB")
-
-
-# --------------------------------------------------------------------------- #
-#  Relations graph + ending shots
-# --------------------------------------------------------------------------- #
-
-def face_node(img: Image.Image, sprite_name: str, cx: int, cy: int, name: str,
-              crop_rel: tuple[float, float, float, float], r: int = 115):
-    sp = Image.open(CACHE / sprite_name).convert("RGBA")
-    w, h = sp.size
-    box = (int(w * crop_rel[0]), int(h * crop_rel[1]), int(w * crop_rel[2]), int(h * crop_rel[3]))
-    face = sp.crop(box).resize((2 * r, 2 * r), Image.LANCZOS)
-    disc = Image.new("RGBA", (2 * r, 2 * r), (30, 26, 44, 255))
-    disc.alpha_composite(face)
-    mask = Image.new("L", (2 * r, 2 * r), 0)
-    ImageDraw.Draw(mask).ellipse([0, 0, 2 * r, 2 * r], fill=255)
-    img.paste(disc, (cx - r, cy - r), mask)
-    d = ImageDraw.Draw(img)
-    d.ellipse([cx - r, cy - r, cx + r, cy + r], outline=GOLD, width=6)
-    d.text((cx, cy + r + 46), name, font=font("georgiab.ttf", 44), fill=INK,
-           anchor="mm", stroke_width=3, stroke_fill=BG_DARK)
-
-
-def qbezier(p0, c, p1, n=60):
-    pts = []
-    for i in range(n + 1):
-        t = i / n
-        x = (1 - t) ** 2 * p0[0] + 2 * (1 - t) * t * c[0] + t ** 2 * p1[0]
-        y = (1 - t) ** 2 * p0[1] + 2 * (1 - t) * t * c[1] + t ** 2 * p1[1]
-        pts.append((x, y))
-    return pts
-
-
-def arc_label(d: ImageDraw.ImageDraw, p0, c, p1, color, label):
-    pts = qbezier(p0, c, p1)
-    d.line(pts, fill=color, width=7, joint="curve")
-    # arrowhead
-    (x1, y1), (x2, y2) = pts[-4], pts[-1]
-    vx, vy = x2 - x1, y2 - y1
-    ln = (vx * vx + vy * vy) ** 0.5 or 1
-    vx, vy = vx / ln, vy / ln
-    px, py = -vy, vx
-    d.polygon([(x2, y2), (x2 - 30 * vx + 14 * px, y2 - 30 * vy + 14 * py),
-               (x2 - 30 * vx - 14 * px, y2 - 30 * vy - 14 * py)], fill=color)
-    # label at curve midpoint
-    mx, my = pts[len(pts) // 2]
-    d.text((mx, my - 8), label, font=font("georgiaz.ttf", 42), fill=color,
-           anchor="mm", stroke_width=5, stroke_fill=BG_DARK)
-
-
-def relations_still() -> Image.Image:
-    img = dark_canvas()
-    d = ImageDraw.Draw(img)
-    draw_tracked(d, (W // 2, 130), "BETWEEN THEM", font("georgiab.ttf", 58), GOLD, tracking=12)
-    d.text((W / 2, 212), "the characters grow bonds of their own - and act on them",
-           font=font("georgiai.ttf", 40), fill=GREY, anchor="mm")
-
-    A = (520, 560)    # Hana
-    B = (1400, 560)   # Ren
-    C = (960, 880)    # Yuki
-    # arcs first, under the nodes
-    arc_label(d, (B[0] - 80, B[1] - 60), (W // 2, 320), (A[0] + 95, A[1] - 55), RED, "jealousy")
-    arc_label(d, (A[0] + 40, A[1] + 110), (640, 830), (C[0] - 125, C[1] - 25), GREEN, "camaraderie")
-    arc_label(d, (C[0] + 120, C[1] - 30), (1290, 830), (B[0] - 35, B[1] + 110), AMBER, "rivalry")
-
-    face_node(img, "sprite_001.tender_1c2d9ce96e14.png", *A, "Hana", (0.30, 0.04, 0.70, 0.44))
-    face_node(img, "sprite_002.neutral_1cdbb592ab0a.png", *B, "Ren", (0.32, 0.02, 0.68, 0.38))
-    face_node(img, "sprite_003.neutral_38f6b226c42e.png", *C, "Yuki", (0.31, 0.01, 0.69, 0.39))
-    return img
-
-
-def ending_still() -> Image.Image:
-    bg = prep_backdrop("bg_the_cherry_blossom_courtyard_11bfbdeafe4e.png", 0.4)
-    bg = bg.filter(ImageFilter.GaussianBlur(3)).convert("RGBA")
-    veil = Image.new("RGBA", (W, H), (10, 8, 18, 158))
-    bg.alpha_composite(veil)
-    d = ImageDraw.Draw(bg)
-    draw_tracked(d, (W // 2, H // 2 - 150), "A WARM ENDING", font("georgiab.ttf", 96), GOLD, tracking=20)
-    d.rectangle([W // 2 - 280, H // 2 - 64, W // 2 + 280, H // 2 - 61], fill=(170, 145, 100))
-    d.text((W / 2, H / 2 + 14), "Beneath the falling petals, she finally says it -",
-           font=font("georgiai.ttf", 46), fill=INK, anchor="mm")
-    d.text((W / 2, H / 2 + 84), "and the whole world seems to hold its breath.",
-           font=font("georgiai.ttf", 46), fill=INK, anchor="mm")
-    d.text((W / 2, H - 110), "win their heart or break it - every ending is written and illustrated live",
-           font=font("georgia.ttf", 34), fill=GREY, anchor="mm")
-    return bg.convert("RGB")
-
-
-# --------------------------------------------------------------------------- #
-#  ffmpeg helpers
-# --------------------------------------------------------------------------- #
-
-def run(cmd: list[str]):
-    r = subprocess.run(cmd, capture_output=True, text=True)
-    if r.returncode != 0:
-        print(r.stderr[-3000:], file=sys.stderr)
-        sys.exit(f"ffmpeg failed: {' '.join(cmd[:8])} …")
-
-
-def make_clip(still: Path, out: Path, dur: float, motion: str):
-    frames = int(dur * FPS)
-    if motion == "static":
-        vf = f"scale=1280:720,fps={FPS},format=yuv420p"
-    else:
-        if motion == "in":
-            zp = (f"zoompan=z='min(zoom+0.0009,1.13)'"
-                  f":x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'"
-                  f":d={frames}:s=1280x720:fps={FPS}")
-        elif motion == "out":
-            zp = (f"zoompan=z='if(lte(on,1),1.13,max(1.13-0.0009*on,1.0))'"
-                  f":x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'"
-                  f":d={frames}:s=1280x720:fps={FPS}")
-        else:  # pan
-            zp = (f"zoompan=z=1.10"
-                  f":x='(iw-iw/zoom)*on/{frames}':y='ih/2-(ih/zoom/2)'"
-                  f":d={frames}:s=1280x720:fps={FPS}")
-        vf = "scale=3840:-2," + zp + ",format=yuv420p"
-    run(["ffmpeg", "-y", "-loop", "1", "-framerate", str(FPS), "-t", f"{dur}",
-         "-i", str(still), "-vf", vf,
-         "-c:v", "libx264", "-preset", "fast", "-crf", "18", str(out)])
-
-
-# --------------------------------------------------------------------------- #
-#  Storyboard
-# --------------------------------------------------------------------------- #
-
-def build_stills() -> list[tuple[str, float, str, str | None]]:
-    """[(filename, duration, motion, music_cue)] - music_cue marks track switches."""
-    shots: list[tuple[str, float, str, str | None]] = []
-
-    def save(img, name, dur, motion, cue=None):
-        img.save(STILLS / name)
-        shots.append((name, dur, motion, cue))
-
-    # -- hooks ---------------------------------------------------------------
-    save(card([("No script.", "georgiab.ttf", 84, INK)], rule=False),
-         "00_hook1.png", 1.8, "static", cue="joyful")
-    save(card([("No branches.", "georgiab.ttf", 84, INK)], rule=False),
-         "01_hook2.png", 1.8, "static")
-    save(card([("Nothing is pre-written.", "georgiab.ttf", 78, GOLD)], rule=False),
-         "02_hook3.png", 2.4, "static")
-    save(title_card("an AI-improvised anime visual novel"),
-         "03_title.png", 3.8, "static")
-
-    # -- world montage ---------------------------------------------------------
-    save(prep_backdrop("bg_sakura_academy_courtyard_e9ee918cd6b4.png"),
-         "04_bg_sakura.png", 2.4, "in")
-    save(prep_backdrop("bg_seashell_cove_22a17fda1006.png"),
-         "05_bg_cove.png", 2.4, "pan")
-    save(prep_backdrop("bg_glowspore_glade_3497325c4038.png", 0.5),
-         "06_bg_glade.png", 2.4, "out")
-    save(card([("Every scene is painted", "georgia.ttf", 62, INK),
-               ("the moment you arrive", "georgia.ttf", 62, INK)]),
-         "07_card_scenes.png", 2.6, "static")
-
-    # -- characters ------------------------------------------------------------
-    save(scene("bg_the_cherry_blossom_courtyard_11bfbdeafe4e.png",
-               "sprite_001.tender_1c2d9ce96e14.png",
-               "Hana",
-               "You came... I was hoping you would.",
-               "The cherry trees bloomed early this year - almost like they knew."),
-         "08_scene1.png", 4.6, "in")
-    save(card([("Every character is improvised -", "georgia.ttf", 62, INK),
-               ("moods, secrets, feelings", "georgiai.ttf", 62, GOLD)]),
-         "09_card_chars.png", 2.6, "static")
-    save(scene("bg_after_school_rooftop_f8a0f52182b3.png",
-               "sprite_002.neutral_1cdbb592ab0a.png",
-               "Ren",
-               "Don't give me that look. I was not waiting for you...",
-               "I just happened to be here after class. Obviously.",
-               sprite_h=900, sprite_cx=1330, v_bias=0.4, delta=12),
-         "10_scene2.png", 4.6, "in")
-    save(card([("Speak with your voice -", "georgia.ttf", 62, INK),
-               ("they listen, and remember", "georgiai.ttf", 62, GOLD)], icon="mic"),
-         "11_card_voice.png", 2.6, "static")
-
-    # -- relations -------------------------------------------------------------
-    save(card([("And between them...", "georgiai.ttf", 72, INK)], rule=False),
-         "12_card_between.png", 2.2, "static", cue="dramatic")
-    save(relations_still(),
-         "13_relations.png", 4.8, "in")
-
-    # -- endings ---------------------------------------------------------------
-    save(card([("Win their heart...", "georgia.ttf", 66, INK),
-               ("or lose everything", "georgiai.ttf", 66, RED)]),
-         "14_card_win.png", 2.6, "static", cue="romantic")
-    save(ending_still(),
-         "15_ending.png", 4.6, "in")
-
-    # -- tech + final ------------------------------------------------------------
-    save(card([("Three small AIs. One living dream.", "georgiab.ttf", 64, INK),
-               ("Qwen3-14B  ·  SDXL-Turbo + LoRA  ·  Whisper", "georgia.ttf", 44, GOLD),
-               ("~18B parameters - everything generated live", "georgia.ttf", 36, GREY)]),
-         "16_card_tech.png", 3.4, "static")
-    save(title_card("an AI-improvised anime visual novel",
-                    extra=[("Play it now on Hugging Face Spaces", "georgia.ttf", 44, INK),
-                           ("Build Small Hackathon - June 2026", "georgia.ttf", 34, GREY)]),
-         "17_final.png", 6.0, "static")
-    return shots
-
-
-def main():
-    STILLS.mkdir(parents=True, exist_ok=True)
-    CLIPS.mkdir(parents=True, exist_ok=True)
-
-    print("[1/3] composing stills…")
-    shots = build_stills()
-
-    print("[2/3] animating clips…")
-    clip_paths = []
-    for name, dur, motion, _ in shots:
-        out = CLIPS / (Path(name).stem + ".mp4")
-        make_clip(STILLS / name, out, dur, motion)
-        clip_paths.append((out, dur))
-        print(f"   {name}  ({dur}s, {motion})")
-
-    print("[3/3] assembling with crossfades + 3-track score…")
-    n = len(clip_paths)
-    durs = [d for _, d in clip_paths]
-    total = sum(durs) - XFADE * (n - 1)
-
-    # clip start offsets in the final timeline
-    offsets = [0.0]
-    for i in range(1, n):
-        offsets.append(offsets[i - 1] + durs[i - 1] - XFADE)
-
-    # music segment boundaries from the cue marks
-    cues = [(offsets[i], shots[i][3]) for i in range(n) if shots[i][3]]
-    tracks = [c[1] for c in cues]                       # joyful, dramatic, romantic
-    bounds = [c[0] for c in cues[1:]] + [total]         # switch times + end
-
-    inputs: list[str] = []
-    for p, _ in clip_paths:
-        inputs += ["-i", str(p)]
-    for t in tracks:
-        inputs += ["-i", str(MUSIC / f"{t}.mp3")]
-
-    fc = []
-    last = "[0:v]"
-    for i in range(1, n):
-        out_lbl = f"[v{i}]"
-        fc.append(f"{last}[{i}:v]xfade=transition=fade:duration={XFADE}:offset={offsets[i]:.3f}{out_lbl}")
-        last = out_lbl
-    fc.append(f"{last}fade=t=out:st={total - 1.0:.3f}:d=1.0[vout]")
-
-    # audio: trim each track to its segment (+ crossfade halves), chain acrossfades
-    seg_start = 0.0
-    for k, t in enumerate(tracks):
-        seg = bounds[k] - seg_start
-        pad = (MUSIC_XF / 2) if k in (0, len(tracks) - 1) else MUSIC_XF
-        ln = seg + pad
-        fc.append(f"[{n + k}:a]atrim=0:{ln:.3f},asetpts=PTS-STARTPTS[a{k}]")
-        seg_start = bounds[k]
-    last_a = "[a0]"
-    for k in range(1, len(tracks)):
-        out_lbl = f"[ax{k}]"
-        fc.append(f"{last_a}[a{k}]acrossfade=d={MUSIC_XF}{out_lbl}")
-        last_a = out_lbl
-    fc.append(f"{last_a}afade=t=in:st=0:d=0.6,afade=t=out:st={total - 3.0:.3f}:d=3.0[aout]")
-
-    final = OUT / "ephemeral_hearts_trailer.mp4"
-    run(["ffmpeg", "-y", *inputs,
-         "-filter_complex", ";".join(fc),
-         "-map", "[vout]", "-map", "[aout]",
-         "-c:v", "libx264", "-preset", "slow", "-crf", "18",
-         "-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart",
-         "-t", f"{total:.3f}",
-         str(final)])
-    print(f"\ndone -> {final}  ({total:.1f}s)")
-    print("music cues:", list(zip(tracks, [0.0] + bounds[:-1])))
-
-
-if __name__ == "__main__":
-    main()