game-execution

Files (1)

• SKILL.md

SKILL.md (first lines)

# Game Execution — Implementation, Testing & Capture

## Phases

### Risk Tasks (if game plan has any)

Implement each risk feature in isolation before the main build:

1. Set up minimal environment — only the nodes needed to exercise the risk
2. Run the implementation loop until the risk task's **Verify** criteria pass
3. Commit

### Main Build

Implement everything in the game plan's **Main Build**:

1. Generate scenes first, then scripts (scenes create nodes that scripts attach to)
2. Run the implementation loop until verification criteria pass
3. Run final verification including presentation video
4. Commit

---

## Implementation Loop

1. **Import assets** — `timeout 60 godot --headless --import` (generates `.import` files — without this, `load()` fails). Re-run after modifying assets.
2. **Generate scenes** — write scene builder scripts, compile to `.tscn`
3. **Generate scripts** — write `.gd` files
4. **Pre-validate** — `timeout 30 godot --headless --check-only -s <path>` for each new/modified `.gd`
5. **Validate project** — `timeout 60 godot --headless --quit 2>&1`
6. **Fix errors** — if validation fails, fix and re-validate
7. **Capture** — write test harness, run with `--write-movie`, produce screenshots
8. **Verify** — check captures against verification criteria + `reference.png` consistency. Check stdout for `ASSERT FAIL`.
9. **Visual QA** — delegate to Heimdall (visual-qa subagent) when applicable
10. If verification fails → fix and repeat from step 2

> **MCP alternative (when `godot_editor` is enabled — see `mcp-tools-godot` skill):** For step 5, use `run_project` + `get_debug_output` instead of `godot --headless --quit` for interactive validation with richer console output. Use `stop_project` to terminate. For pre-validation (step 4), use `get_diagnostics` from `godot_diagnostics` for LSP-level checks. Steps 1 and 7 have no MCP equivalent — always use bash for asset import and `--write-movie` capture.

After each phase: update the game plan spec status, write discoveries to knowledge graph (`memory` tools), git commit.

### Iteration Tracking

There is no fixed iteration limit — use judgment:

- If there is progress (even small iterative steps) — keep going
- If you recognize a **fundamental limitation** (wrong architecture, missing engine feature) — stop early, even after 2-5 iterations
- Stop signal: "making the same kind of fix repeatedly without convergence"

---

## Commands

```bash
# Import new/modified assets (MUST run before scene builders):
timeout 60 godot --headless --import

# Compile a scene builder (produces .tscn):
timeout 60 godot --headless --script <path_to_builder.gd>

# Pre-validate a single script:
timeout 30 godot --headless --check-only -s <path_to_script.gd>

# Validate all project scripts:
timeout 60 godot --headless --quit 2>&1
```

**Common errors:**

- `Parser Error` — syntax error, fix the line indicated
- `Invalid call` / `method not found` — wrong node type or API, delegate to Mimir for class lookup
- `Cannot infer type` — `:=` used with `instantiate()` or polymorphic math functions
- Script hangs — missing `quit()` in scene builder

---

## Test Harnesses

Write `test/test_{task_id}.gd` — a SceneTree script that loads the scene under test and verifies the task's goal. Do NOT call `quit()` — the movie writer handles exit.

### Contract

```gdscript
extends SceneTree

func _initialize() -> void:
    # Setup: load scene, position camera, configure test
    var scene: PackedScene = load("res://scenes/main.tscn")
    var root_scene = scene.instantiate()
    root.add_child(root_scene)

    # Camera must be activated explicitly
    var cam := Camera3D.new()
    cam.position = Vector3(0, 5, 10)
    cam.current = true
    root.add_child(cam)

func _process(delta: float) -> bool:
    # Return false to keep running
    return false
```

### Console Assertions

Use `print("ASSERT PASS/FAIL: ...")` for behavioral properties hard to judge visually (positions, velocities, state changes). After capture, check stdout for `ASSERT FAIL` lines.

### Simulated Input

```gdscript
var timer := Timer.new()
timer.wait_time = 1.0
timer.one_shot = true
timer.timeout.connect(func(): Input.action_press("move_forward"))
root.add_child(timer)
timer.start()
```

### Sustained Movement (Presentations)

Open-loop input (timed press/release) doesn't work for 30-second videos — per-frame errors compound. Use **closed-loop waypoint steering** based on actual position each frame.

From dragoscirjan/opencode-config, MIT.

More from dragoscirjan/opencode-config