Skip to content

notque/vexjoy-agent / skills/game/game-dev

game-dev

Flagged

Game development: design, asset pipelines, Phaser, Unity CLI and builds, vanilla JS frontend, GM mode, match booking.

FileKindSize
SKILL.mdskill md13.2 KB
references/anchor-alignment.mdmarkdown16.0 KB
references/animate-scaffolds.mdmarkdown2.0 KB
references/arcade-physics.mdmarkdown7.4 KB
references/artifacts-and-prototyping.mdmarkdown1.5 KB
references/asset-sources.mdmarkdown7.9 KB
references/audit-and-red-team.mdmarkdown795 B
references/autonomous-improvement.mdmarkdown10.3 KB
references/backend-chain.mdmarkdown10.4 KB
references/bg-removal-local.mdmarkdown22.7 KB
references/build-scaffolds.mdmarkdown2.0 KB
references/capabilities/01-design-red-team-audit.mdmarkdown3.9 KB
references/capabilities/02-emotional-canvas-moodboard.mdmarkdown3.7 KB
references/capabilities/03-game-design-attribution-audit.mdmarkdown3.6 KB
references/capabilities/04-game-design-bartle-archetype-audit.mdmarkdown3.7 KB
references/capabilities/05-game-design-big-five-personality-audit.mdmarkdown3.6 KB
references/capabilities/06-game-design-brainstorm-methods.mdmarkdown3.9 KB
references/capabilities/07-game-design-core-loop-extractor.mdmarkdown3.7 KB
references/capabilities/08-game-design-craft-critique.mdmarkdown3.5 KB
references/capabilities/09-game-design-creative-unblocker.mdmarkdown3.5 KB
references/capabilities/10-game-design-design-pillars-extractor.mdmarkdown3.5 KB
references/capabilities/11-game-design-emotional-canvas.mdmarkdown3.6 KB
references/capabilities/12-game-design-failure-loop-audit.mdmarkdown3.8 KB
references/capabilities/13-game-design-fairness-frustration-audit.mdmarkdown3.6 KB
references/capabilities/14-game-design-fantasy-extractor.mdmarkdown3.6 KB
references/capabilities/15-game-design-feature-prioritization.mdmarkdown3.6 KB
references/capabilities/16-game-design-five-options.mdmarkdown3.5 KB
references/capabilities/17-game-design-flow-audit.mdmarkdown3.6 KB
references/capabilities/18-game-design-fogg-behavior-audit.mdmarkdown3.6 KB
references/capabilities/19-game-design-friction-journey-audit.mdmarkdown3.8 KB
references/capabilities/20-game-design-ftue-hero-journey-audit.mdmarkdown3.7 KB
references/capabilities/21-game-design-goal-density-and-immediacy-audit.mdmarkdown3.5 KB
references/capabilities/22-game-design-goal-framing.mdmarkdown3.5 KB
references/capabilities/23-game-design-granular-player-motivation-audit.mdmarkdown4.0 KB
references/capabilities/24-game-design-grow-design.mdmarkdown3.5 KB
references/capabilities/25-game-design-ideal-outcome-backcasting.mdmarkdown3.4 KB
references/capabilities/26-game-design-kpi-coverage-audit.mdmarkdown3.8 KB
references/capabilities/27-game-design-leaderboard-audit.mdmarkdown3.9 KB
references/capabilities/28-game-design-leaderboard-builder.mdmarkdown3.8 KB
references/capabilities/29-game-design-molyneux-lens.mdmarkdown3.5 KB
references/capabilities/30-game-design-multiplayer-feature-audit.mdmarkdown3.8 KB
references/capabilities/31-game-design-novelty-spectrum-audit.mdmarkdown3.6 KB
references/capabilities/32-game-design-one-page-design-doc.mdmarkdown3.8 KB
references/capabilities/33-game-design-one-thing-to-remove.mdmarkdown3.6 KB
references/capabilities/34-game-design-option-generation.mdmarkdown3.5 KB
references/capabilities/35-game-design-peak-end-audit.mdmarkdown3.6 KB
references/capabilities/36-game-design-perceived-randomness-audit.mdmarkdown3.7 KB
references/capabilities/37-game-design-pitch-deck-audit.mdmarkdown3.8 KB
references/capabilities/38-game-design-player-motivation-audit.mdmarkdown3.5 KB
references/capabilities/39-game-design-player-need-satisfaction-audit.mdmarkdown3.6 KB
references/capabilities/40-game-design-player-persona-extractor.mdmarkdown4.2 KB
references/capabilities/41-game-design-player-perspective-reframe.mdmarkdown3.7 KB
references/capabilities/42-game-design-player-segment-perception-audit.mdmarkdown3.6 KB
references/capabilities/43-game-design-player-values-mapper.mdmarkdown3.8 KB
references/capabilities/44-game-design-premium-pass-audit.mdmarkdown3.8 KB
references/capabilities/45-game-design-prosocial-session-chapters.mdmarkdown3.7 KB
references/capabilities/46-game-design-prototype-intent-audit.mdmarkdown3.7 KB
references/capabilities/47-game-design-prototyping-companion.mdmarkdown3.6 KB
references/capabilities/48-game-design-roadblock-reframing.mdmarkdown3.5 KB
references/capabilities/49-game-design-smart-goal-audit.mdmarkdown3.6 KB
references/capabilities/50-game-design-social-satisfaction-matrix.mdmarkdown3.7 KB
references/capabilities/51-game-design-systematizing-empathizing-audit.mdmarkdown3.6 KB
references/capabilities/52-game-design-thinking-fast-and-slow-audit.mdmarkdown3.6 KB
references/capabilities/53-game-design-transformative-reuse.mdmarkdown3.6 KB
references/capabilities/54-game-design-unknown-unknowns-prototyping.mdmarkdown3.6 KB
references/capabilities/55-game-design-zeigarnik-effect-audit.mdmarkdown3.6 KB
references/capabilities/56-game-dev-budget-estimator.mdmarkdown3.8 KB
references/capabilities/57-game-dev-first-steps.mdmarkdown3.6 KB
references/capabilities/58-game-dev-team-gap.mdmarkdown3.6 KB
references/capabilities/59-game-dev-time-estimator.mdmarkdown3.8 KB
references/capabilities/60-moodboard-generator.mdmarkdown4.0 KB
references/capabilities/61-software-team-conflict-patterns.mdmarkdown3.8 KB
references/capability-catalog.mdmarkdown18.4 KB
references/capability-map.mdmarkdown1.7 KB
references/capability-matrix.mdmarkdown12.5 KB
references/capacitor-ios.mdmarkdown7.3 KB
references/cognition-and-choice.mdmarkdown1.2 KB
references/cognitive-and-behavioral-lenses.mdmarkdown1.2 KB
references/concept-and-loop.mdmarkdown1.5 KB
references/core-loop-and-pillars.mdmarkdown835 B
references/core-patterns.mdmarkdown8.2 KB
references/cpu-systems-harmony.mdmarkdown3.4 KB
references/creative-and-options.mdmarkdown2.0 KB
references/creative-direction.mdmarkdown1.3 KB
references/deploy.mdmarkdown5.3 KB
references/design-artifacts.mdmarkdown1.0 KB
references/emotion-and-presentation.mdmarkdown1.1 KB
references/error-catalog.mdmarkdown22.6 KB
references/fairness-and-failure.mdmarkdown1.2 KB
references/fairness-and-learning.mdmarkdown1.3 KB
references/fal-ai-image.mdmarkdown7.1 KB
references/frame-detection.mdmarkdown20.0 KB
references/full-diagnostic.mdmarkdown4.2 KB
references/game-asset-generator.mdmarkdown9.5 KB
references/game-audio.mdmarkdown7.5 KB
references/game-feel-patterns.mdmarkdown12.2 KB
references/game-pipeline.mdmarkdown11.5 KB
references/game-qa.mdmarkdown6.7 KB
references/game-sprite-pipeline.mdmarkdown33.4 KB
references/gm-brilliant-implementation.mdmarkdown13.4 KB
references/grid-shapes.mdmarkdown8.0 KB
references/meshyai.mdmarkdown7.3 KB
references/motion-pipeline.mdmarkdown7.5 KB
references/output-formats.mdmarkdown9.4 KB
references/pacing-and-return.mdmarkdown1.6 KB
references/performance.mdmarkdown7.8 KB
references/phaser-gamedev.mdmarkdown7.5 KB
references/pipeline-spec.jsonconfig23.0 KB
references/pixel-art-sprites.mdmarkdown8.7 KB
references/planning-and-communication.mdmarkdown1.6 KB
references/planning-and-production.mdmarkdown1.8 KB
references/player-and-social.mdmarkdown2.3 KB
references/polish-scaffolds.mdmarkdown1.9 KB
references/progression-and-economy.mdmarkdown1.0 KB
references/promo-video.mdmarkdown6.6 KB
references/prompt-rules.mdmarkdown15.2 KB
references/quality-gates.mdmarkdown6.4 KB
references/road-to-aew-integration.mdmarkdown7.8 KB
references/social-and-competitive-design.mdmarkdown1.1 KB
references/social-and-competitive.mdmarkdown1.5 KB
references/spritesheets.mdmarkdown6.2 KB
references/stage-contracts.mdmarkdown11.1 KB
references/style-presets.mdmarkdown5.1 KB
references/subagent-delegation.mdmarkdown2.2 KB
references/tilemaps-and-physics.mdmarkdown13.6 KB
references/tilemaps.mdmarkdown7.0 KB
references/unity-batchmode-builds.mdmarkdown9.2 KB
references/unity-cli.mdmarkdown10.9 KB
references/unity-licensing.mdmarkdown5.0 KB
references/vfx-containment.mdmarkdown3.1 KB
references/workflow-dag.mdmarkdown4.1 KB
references/worldlabs.mdmarkdown7.9 KB
references/wrestler-archetypes.mdmarkdown7.2 KB
scripts/deterministic_idle.pyscript7.8 KB
scripts/fal_queue_image_run.pyscript9.4 KB
scripts/imgdiff.pyscript5.0 KB
scripts/meshy-generate.mjsscript11.1 KB
scripts/optimize-glb.mjsscript3.8 KB
scripts/portrait_pipeline.pyscript31.2 KB
scripts/qa_artifacts.pyscript14.4 KB
scripts/road_to_aew_integration.pyscript6.6 KB
scripts/row_job_status.pyscript8.6 KB
scripts/sprite_anchor.pyscript30.1 KB
scripts/sprite_assemble.pyscript16.0 KB
scripts/sprite_bg.pyscript28.5 KB
scripts/sprite_canvas.pyscript11.9 KB
scripts/sprite_generate.pyscript13.9 KB
scripts/sprite_pipeline.pyscript54.9 KB
scripts/sprite_process.pyscript13.5 KB
scripts/sprite_prompt.pyscript41.8 KB
scripts/sprite_slicing.pyscript38.7 KB
scripts/sprite_verify.pyscript58.5 KB
scripts/test_content_aware_extraction.pyscript13.4 KB
scripts/test_no_status_laundering.pyscript6.9 KB
scripts/test_phases_4_5_7_8.pyscript16.4 KB
scripts/test_pipeline_glue.pyscript20.9 KB
scripts/test_pipeline_patterns.pyscript10.9 KB
scripts/test_rc3_frames_distinct_threshold.pyscript14.2 KB
scripts/test_rc4_mass_centroid_default.pyscript8.3 KB
scripts/test_rc5_despill_pre_upscale.pyscript7.9 KB
scripts/test_slice_grid_cells.pyscript6.4 KB
scripts/test_slicer_strict_pitch_default.pyscript11.6 KB
scripts/test_verifier_cell_parity.pyscript9.0 KB
scripts/test_verify_gates.pyscript23.2 KB
scripts/tests/test_fal_queue_image_run.pyscript908 B
scripts/video_extract_frames.pyscript4.3 KB
scripts/video_process_frames.pyscript7.6 KB
scripts/video_select_frames.pyscript6.4 KB
scripts/with_server.pyscript5.8 KB

scripts/test_verifier_cell_parity.py

View on GitHub
#!/usr/bin/env python3
"""Regression tests for ADR-207 Rule 3 (verify_raw_vs_final_cell_parity).

The new cell-parity gate fires when a raw cell has > 200 non-magenta pixels
but the corresponding final cell has <= 200 visible alpha pixels. This is
the conservative blank-cell check that catches ADR-207 RC-1 directly: raw
has content, final lost it.

These tests exercise:

  1. Negative case: raw + final both have content; gate passes.
  2. Positive case: raw has content in cells, final has them all blank;
     gate fires with detailed per-cell diagnostic.
  3. Mixed case: raw cell IS empty; final cell IS empty; gate's
     precondition not met for that cell (no false positive on legitimately
     empty cells).
  4. Actionable message references ADR-207 RC-1.

Run with pytest:

    pytest skills/game/game-dev/scripts/test_verifier_cell_parity.py -v
"""

from __future__ import annotations

import sys
from pathlib import Path

import numpy as np
from PIL import Image

SCRIPT_DIR = Path(__file__).resolve().parent
sys.path.insert(0, str(SCRIPT_DIR))

import sprite_verify

MAGENTA = (255, 0, 255, 255)
CHAR_RGB = (32, 224, 64)


def _make_raw_with_content_per_cell(cols: int, rows: int, cell_size: int, populated_cells: set[int]) -> Image.Image:
    """Build a raw sheet at exact pitch with a solid disk in each populated cell."""
    w = cols * cell_size
    h = rows * cell_size
    img = Image.new("RGBA", (w, h), MAGENTA)
    arr = np.array(img)
    radius = cell_size // 5
    for r in range(rows):
        for c in range(cols):
            idx = r * cols + c
            if idx not in populated_cells:
                continue
            cx = c * cell_size + cell_size // 2
            cy = r * cell_size + cell_size // 2
            yy, xx = np.ogrid[:h, :w]
            disk = (xx - cx) ** 2 + (yy - cy) ** 2 <= radius**2
            arr[disk, 0] = CHAR_RGB[0]
            arr[disk, 1] = CHAR_RGB[1]
            arr[disk, 2] = CHAR_RGB[2]
            arr[disk, 3] = 255
    return Image.fromarray(arr, "RGBA")


def _make_final_with_alpha_per_cell(cols: int, rows: int, cell_size: int, populated_cells: set[int]) -> Image.Image:
    """Build a final sheet with visible alpha-content in each populated cell."""
    w = cols * cell_size
    h = rows * cell_size
    img = Image.new("RGBA", (w, h), (0, 0, 0, 0))  # fully transparent
    arr = np.array(img)
    radius = cell_size // 5
    for r in range(rows):
        for c in range(cols):
            idx = r * cols + c
            if idx not in populated_cells:
                continue
            cx = c * cell_size + cell_size // 2
            cy = r * cell_size + cell_size // 2
            yy, xx = np.ogrid[:h, :w]
            disk = (xx - cx) ** 2 + (yy - cy) ** 2 <= radius**2
            arr[disk, 0] = CHAR_RGB[0]
            arr[disk, 1] = CHAR_RGB[1]
            arr[disk, 2] = CHAR_RGB[2]
            arr[disk, 3] = 255
    return Image.fromarray(arr, "RGBA")


# ---------------------------------------------------------------------------
# Test 1: negative case (full preservation)
# ---------------------------------------------------------------------------
def test_cell_parity_passes_when_all_raw_content_preserved(tmp_path: Path) -> None:
    """All 16 raw cells have content; all 16 final cells preserve it."""
    cells = set(range(16))
    raw = _make_raw_with_content_per_cell(4, 4, 256, cells)
    final = _make_final_with_alpha_per_cell(4, 4, 256, cells)
    raw_path = tmp_path / "raw_full.png"
    final_path = tmp_path / "final_full.png"
    raw.save(raw_path)
    final.save(final_path)

    result = sprite_verify.verify_raw_vs_final_cell_parity(raw_path, final_path, 4, 4, 256)
    assert result["passed"] is True, f"expected pass; got {result}"
    assert result["blank_cells"] == [], result
    assert result["total_cells_with_raw_content"] == 16, result
    assert result["cells_preserved"] == 16, result


# ---------------------------------------------------------------------------
# Test 2: positive case (raw has content, final blank — RC-1 signature)
# ---------------------------------------------------------------------------
def test_cell_parity_fires_when_raw_has_content_but_final_blank(tmp_path: Path) -> None:
    """All 16 raw cells have content; final has them ALL blank. Gate must fire."""
    cells = set(range(16))
    raw = _make_raw_with_content_per_cell(4, 4, 256, cells)
    # Final has zero populated cells -> entirely transparent
    final = _make_final_with_alpha_per_cell(4, 4, 256, set())
    raw_path = tmp_path / "raw_full2.png"
    final_path = tmp_path / "final_blank.png"
    raw.save(raw_path)
    final.save(final_path)

    result = sprite_verify.verify_raw_vs_final_cell_parity(raw_path, final_path, 4, 4, 256)
    assert result["passed"] is False, f"gate should fire on full-blank final; got {result}"
    assert len(result["blank_cells"]) == 16, f"expected 16 blank cells flagged; got {len(result['blank_cells'])}"
    # Each blank cell entry must include diagnostic detail.
    for blank in result["blank_cells"]:
        assert "cell_index" in blank, blank
        assert "raw_silhouette" in blank, blank
        assert "final_visible" in blank, blank
        assert blank["raw_silhouette"] > 200, blank  # precondition met
        assert blank["final_visible"] <= 200, blank  # final IS blank
    # Actionable message must point at ADR-207 RC-1.
    assert "ADR-207" in result.get("actionable_message", ""), result.get("actionable_message")
    assert "RC-1" in result.get("actionable_message", ""), result.get("actionable_message")


# ---------------------------------------------------------------------------
# Test 3: mixed case (some raw cells legitimately empty)
# ---------------------------------------------------------------------------
def test_cell_parity_skips_legitimately_empty_raw_cells(tmp_path: Path) -> None:
    """If raw cell IS empty, gate's precondition does not apply -> no false positive.

    Build a raw with only cells {0, 5, 10, 15} populated. Final has the
    same 4 cells populated. The other 12 cells: raw is magenta, final is
    transparent. Gate must NOT flag those 12 cells (precondition not met)
    AND must report total_cells_with_raw_content == 4.
    """
    populated = {0, 5, 10, 15}
    raw = _make_raw_with_content_per_cell(4, 4, 256, populated)
    final = _make_final_with_alpha_per_cell(4, 4, 256, populated)
    raw_path = tmp_path / "raw_partial.png"
    final_path = tmp_path / "final_partial.png"
    raw.save(raw_path)
    final.save(final_path)

    result = sprite_verify.verify_raw_vs_final_cell_parity(raw_path, final_path, 4, 4, 256)
    assert result["passed"] is True, f"all populated cells preserved; should pass: {result}"
    assert result["total_cells_with_raw_content"] == 4, (
        f"expected 4 cells with content (precondition met); got {result['total_cells_with_raw_content']}"
    )
    assert result["cells_preserved"] == 4, result
    assert result["blank_cells"] == [], result


# ---------------------------------------------------------------------------
# Test 4: partial loss (raw populated, only some final cells preserved)
# ---------------------------------------------------------------------------
def test_cell_parity_diagnoses_partial_loss(tmp_path: Path) -> None:
    """Raw has 16 cells with content; final preserves 12, drops 4. Gate flags 4."""
    raw = _make_raw_with_content_per_cell(4, 4, 256, set(range(16)))
    final = _make_final_with_alpha_per_cell(4, 4, 256, set(range(12)))  # last 4 dropped
    raw_path = tmp_path / "raw_loss.png"
    final_path = tmp_path / "final_loss.png"
    raw.save(raw_path)
    final.save(final_path)

    result = sprite_verify.verify_raw_vs_final_cell_parity(raw_path, final_path, 4, 4, 256)
    assert result["passed"] is False, result
    assert len(result["blank_cells"]) == 4, f"expected 4 dropped cells; got {len(result['blank_cells'])}"
    flagged_indexes = sorted(b["cell_index"] for b in result["blank_cells"])
    assert flagged_indexes == [12, 13, 14, 15], flagged_indexes
    assert result["total_cells_with_raw_content"] == 16, result
    assert result["cells_preserved"] == 12, result


# ---------------------------------------------------------------------------
# Standalone runner (works without pytest)
# ---------------------------------------------------------------------------
def main() -> int:
    import tempfile

    tests = [
        test_cell_parity_passes_when_all_raw_content_preserved,
        test_cell_parity_fires_when_raw_has_content_but_final_blank,
        test_cell_parity_skips_legitimately_empty_raw_cells,
        test_cell_parity_diagnoses_partial_loss,
    ]
    failures: list[tuple[str, str]] = []
    for t in tests:
        with tempfile.TemporaryDirectory() as td:
            try:
                t(Path(td))
                print(f"PASS {t.__name__}")
            except AssertionError as e:
                print(f"FAIL {t.__name__}: {e}")
                failures.append((t.__name__, str(e)))
    if failures:
        print(f"\n{len(failures)} FAIL")
        return 1
    print(f"\nAll {len(tests)} tests passed.")
    return 0


if __name__ == "__main__":
    sys.exit(main())
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 321kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 197kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall