Skip to content

notque/vexjoy-agent / skills/game/game-trailer

game-trailer

Verified

Make a trailer, promo, teaser, sizzle reel, launch or gameplay video for one of our browser games (Road to AEW / ROAD TO THE BIG TIME, 5 Star Booker, or any game built the same way) from the real game: frame-exact 4K capture under a virtual clock, a beat-mapped edit with poster overlays printed in the game's own CSS, a score written in code, the game's own sounds and its crowd engine. Use it whenever someone asks for a trailer, a promo or social video of a game, a YouTube or X cut, a re-cut or recapture of an existing trailer, or just 'make a video that shows the game off'. Carries the pace rules the owner settled on and the capture, edit and audio traps that cost time.

FileKindSize
SKILL.mdskill md12.9 KB
references/audio.mdmarkdown9.0 KB
references/capture.mdmarkdown10.9 KB
references/edit.mdmarkdown10.1 KB
references/lessons.mdmarkdown9.4 KB
references/pipeline.mdmarkdown11.1 KB
references/review.mdmarkdown7.7 KB
references/worked-example.mdmarkdown8.5 KB
scripts/beat_levels.pyscript5.7 KB
scripts/edl_table.pyscript6.1 KB
scripts/take_sheet.pyscript4.3 KB

scripts/edl_table.py

View on GitHub
#!/usr/bin/env python3
"""Shot and overlay table for a promo EDL, with a pace lint.

Reads the edit decision list (tmp/promo/edl.json, written by scripts/promo/edl.mjs) and prints every
shot (output span, length, take, fastest footage speed, tightest zoom) and every overlay (span,
length, kind, text). Then it flags what the owner's reviews rejected: shots shorter than --min-shot,
footage faster than --max-speed, zooms past --max-zoom, captions shorter than --min-caption, VS cards
shorter than --min-vs. The defaults are the edge of what the approved cut 6 of ROAD TO THE BIG TIME
contains (its fastest footage 1.13x, its quickest cuts 0.47 s inside a slow-motion sequence, its
shortest caption 0.9 s), so a clean run means nothing has slid back toward the cuts the owner
rejected. Speeds and camera keys in the EDL are already stretched by the running-order layout, so the
numbers are what the viewer sees.

Usage:
    python3 edl_table.py tmp/promo/edl.json [--min-shot 0.45] [--max-speed 1.15] [--max-zoom 2.5]
                         [--min-caption 0.9] [--min-vs 0.9] [--strict] [--json]

--strict exits 1 when any flag fires. Poster shots (take "black") are judged by their overlay, not by
the shot length.
"""

from __future__ import annotations

import argparse
import json
import statistics
import sys
from pathlib import Path

EPS = 1e-3  # a millisecond of slack: beat arithmetic lands a hair under round values


def overlay_text(el: dict) -> str:
    kind = el.get("kind")
    if kind == "caption":
        text = " / ".join(el.get("lines") or [])
        band = el.get("band")
        return f"{text} [{band}]" if band else text or "(band only)"
    if kind == "vs":
        opp = el.get("opp") or []
        lands = opp[-1] if opp else "?"
        return f"VS {lands}" + (f" (slot of {len(opp)})" if len(opp) > 1 else "")
    if kind == "cta":
        return f"CTA {el.get('url', '')}"
    return kind or "?"


def shot_rows(edl: dict, args: argparse.Namespace) -> list[dict]:
    rows = []
    for s in edl["shots"]:
        dur = s["t1"] - s["t0"]
        take = s.get("take") or "-"
        speeds = [v for _, v in (s.get("speed") or [[0, 1.0]])]
        zooms = [c.get("z", 1.0) for c in (s.get("cam") or [])] or [1.0]
        flags = []
        if take != "black":
            if dur < args.min_shot - EPS:
                flags.append(f"short {dur:.2f}s")
            if max(speeds) > args.max_speed + EPS:
                flags.append(f"fast {max(speeds):.2f}x")
            if max(zooms) > args.max_zoom + EPS:
                flags.append(f"zoom {max(zooms):.2f}")
        rows.append(
            {
                "t0": s["t0"],
                "t1": s["t1"],
                "dur": dur,
                "take": take,
                "speed_max": max(speeds),
                "speed_min": min(speeds),
                "zoom_max": max(zooms),
                "flags": flags,
            }
        )
    return rows


def overlay_rows(edl: dict, args: argparse.Namespace) -> list[dict]:
    rows = []
    for el in edl.get("overlays", []):
        dur = el["t1"] - el["t0"]
        kind = el.get("kind", "?")
        flags = []
        if kind == "caption" and dur < args.min_caption - EPS:
            flags.append(f"brief {dur:.2f}s")
        if kind == "vs" and dur < args.min_vs - EPS:
            flags.append(f"brief {dur:.2f}s")
        rows.append(
            {"t0": el["t0"], "t1": el["t1"], "dur": dur, "kind": kind, "text": overlay_text(el), "flags": flags}
        )
    rows.sort(key=lambda r: r["t0"])
    return rows


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("edl", type=Path)
    ap.add_argument("--min-shot", type=float, default=0.45, help="shortest acceptable take shot (s)")
    ap.add_argument("--max-speed", type=float, default=1.15, help="fastest acceptable footage speed")
    ap.add_argument("--max-zoom", type=float, default=2.5, help="tightest acceptable camera zoom")
    ap.add_argument("--min-caption", type=float, default=0.9, help="shortest acceptable caption (s)")
    ap.add_argument("--min-vs", type=float, default=0.9, help="shortest acceptable VS card (s)")
    ap.add_argument("--strict", action="store_true", help="exit 1 when any flag fires")
    ap.add_argument("--json", action="store_true")
    args = ap.parse_args()

    edl = json.loads(args.edl.read_text(encoding="utf-8"))
    shots = shot_rows(edl, args)
    overlays = overlay_rows(edl, args)
    take_shots = [r for r in shots if r["take"] != "black"]
    flagged = sum(1 for r in shots + overlays if r["flags"])
    summary = {
        "duration": edl.get("duration"),
        "shots": len(shots),
        "poster_shots": len(shots) - len(take_shots),
        "median_shot": statistics.median(r["dur"] for r in take_shots) if take_shots else None,
        "overlays": len(overlays),
        "flagged": flagged,
    }

    if args.json:
        print(json.dumps({"summary": summary, "shots": shots, "overlays": overlays}, indent=1))
    else:
        print("SHOTS    t0      t1     len  take        speed       zoom  flags")
        for r in shots:
            speed = (
                f"{r['speed_min']:.2f}-{r['speed_max']:.2f}x"
                if r["speed_min"] != r["speed_max"]
                else f"{r['speed_max']:.2f}x"
            )
            print(
                f"{r['t0']:8.2f} {r['t1']:7.2f} {r['dur']:6.2f}  {r['take']:<10} {speed:<11} {r['zoom_max']:5.2f}  "
                + ", ".join(r["flags"])
            )
        print("\nOVERLAYS t0      t1     len  kind     text")
        for r in overlays:
            print(
                f"{r['t0']:8.2f} {r['t1']:7.2f} {r['dur']:6.2f}  {r['kind']:<8} {r['text'][:70]}  "
                + ", ".join(r["flags"])
            )
        med = f"{summary['median_shot']:.2f} s" if summary["median_shot"] is not None else "-"
        print(
            f"\n{summary['duration']:.2f} s, {summary['shots']} shots ({summary['poster_shots']} poster), "
            f"median take shot {med}, {summary['overlays']} overlays, {flagged} flagged"
        )
    return 1 if (args.strict and flagged) else 0


if __name__ == "__main__":
    sys.exit(main())
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall