AI tools: Play, test and profile

Playing the game, bots, screenshots, recordings, frame timing and checks. 73 tools. You see every step your AI takes and can undo any of them.

ai_report

Read actual enemy decisions and sight/hearing/radio per tick. mode=live reads only this engine's current Play session and never silently simulates. mode=simulate explicitly runs a separate stationary-player snapshot for 0...30 seconds, without changing the authoring scene, camera or saves. Rows include firstSeenTick/firstNoticedTick, reasons, routes, health and attack counts. History is bounded: dropped/omitted rows are explicit. First-seen ticks support checks such as noticed within 2 seconds (240 ticks). HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

audio_report

Measure the actual live pre-master stereo bus, using the same capture as listen. Reports levels, per-channel clipping and rendered source contributions, not just requested sound names. Optional explicit impulse probe can measure an isolated reverb decay; it never substitutes the geometric estimate for a measurement. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

audio_spatial_check

Measure the engine's headphone 3D (binaural) on the real mixer, offline: noise and tones from ahead, the sides, behind, above, below and at the shoulder, plus a sweep round the head. Reports each direction's ear delay (ms), level difference (dB), brightness and pinna-notch tones, and pass/fail checks. Pass binaural:false to measure the plain pan for comparison.

autoplay

Stress test: a bot plays the game many times through the real controls (pathfinding to objectives, hiding from guards/enemies, getting unstuck) and reports win rate, how runs fail, objectives it couldn't reach, where it got stuck, script errors and simulation cost, plus a picture of one run's end.

check_asset

Standard validity checks for a forged model or character, before anyone looks at it: connected parts, parts floating off the body (with the gap in mm and where), watertight (open and non-manifold edges), flipped or inside-out faces, degenerate triangles, scale sanity (with a units hint: authored in cm?), and broken data. With prop (a model with grip_start/grip_end points) and character, also the grip on every frame of the character's clips: palm-to-handle distance and handle-vs-grip-axis angle, with the failing frames. Writes Bench/<name>/validity.json. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

check_dialogue

Check the project's branching dialogue files (Dialogue/<id>.dialogue.json): errors that stop one from playing right (a goto to no node, a condition or action that can't be read, a node with both next and choices, empty choice text, more than 6 choices) and warnings (nodes never reached, missing voice files). Give `id` for one conversation, with its node and choice counts. Format: { start, nodes: { name: { speaker, text, portrait, emotion, side (left/right), voice (Sounds file), next, choices [{ text, if, do, goto }] (at most 6), if, else, do, end } } }. Conditions: flag:key, has:item[:n], state:key>=n (== != >= <= > <), quest:id=active (locked/open/active/done/failed), seen:dialogue.node, ! negates, && and ||. Actions: set:key=value, set:key+n, give:item[:n], take:item[:n], quest:id>start|done|fail|objective[+n], send:message, cutscene:name. A node with no text is logic only (its do runs, it goes straight on); a node whose if fails goes to its else (or ends).

check_quests

Check the project's quest files (Quests/<id>.quest.json) against its conversations and this scene: errors (unknown objective kinds, missing fields per kind, a talk objective on a node that isn't there, duplicate ids, bad reward actions, quests after missing ones or after themselves) and warnings (reach objects not in this scene, journal lines never written). Format: { title, summary, after [quest ids], auto_start, objectives [{ id, text, kind, item, count, key, dialogue, node, at, radius, tag, optional }], journal { start, <objective id>, done, failed: line }, reward { items { id: n }, do [dialogue actions] } }. Kinds: item (item, count), count (key, count), flag (key), talk (dialogue, node), reach (at, radius m, default 3), kill (tag, count), script (only by hand). State lives in the game state (quest.<id>.state etc.), so it carries across scenes and saves.

No arguments.

check_request

Before saying done, check every word of the person's request yourself: splits it into checkable claims ("a big red rotating cube" → big, red, rotating), finds the object each describes, and checks each against the scene and a short headless play on a copy (size from the mesh and scale, colour from the material, rotating/moving/falling/bouncing measured over the play, glowing, solid, physics, in the middle). Answers MET / NOT MET / UNCHECKED per claim with the numbers. Never tell the person to "hit Play to see it": fix what's NOT MET and check again.

check_sights

First person: check a gun's sights the way the game holds it (a character with view "first_person" and the shooter kit's gun.js): finds the sight line on the gun's model (rear and front sight, or a red dot's axis), aims down it for cameras looking level, up, down and turned, and reports how far the drawn rear and front sights land from the screen's centre at 1920×1080 (through the view model's field of view; aligned is under 1 px), then flies a bullet zeroed at `zero` m and lists where it passes the sight line at 10, 25, 50, 100 and 200 m (cm above + / below −). `view` takes gun.js's first-person data (sight, eye_relief, zero, view_fov, ads_view_fov, view_scale, ads_zoom) to try values before putting them in the kit's params.

clip_check

Clothes clipping, measured (Gordon: clothing that never clips): a character's skin, garments and worn gear (things attached to its bones: a carrier, boots, a helmet; not what the hands hold) as drawn, frame by frame for `seconds` (live in Play while it moves: walk, run, crouch, raise the arms) or once now. Two kinds: POKE, a layer showing through the one over it (skin through a sleeve, a shirt through the vest, a trouser leg through a boot), and INTO, a piece cutting into another limb's flesh (the vest's edge in a raised arm, a thigh into the carrier, a boot shaft in the calf). Reports the deepest of each, where, in which frame, and every clip pair with its count and depth; mark: true draws the worst points live (red pokes, magenta into). Clips over 2 mm (poke) and 3 mm (into) count; depth at rest is subtracted.

clothes_check

Clothes clipping on a character, in plain words, with a red view (Beta 2 fix tools; any outfit and body, forged or imported): watches it for `seconds` (in Play while it moves: drive it with play_input wait false; 0 one frame now) and says where clothing goes through the body ("the shirt cuts 2.1 cm into the left forearm (t=1.4 s)", "skin shows through the trousers at the right thigh"), how deep, how often, and the fix for each (clothes_fix, clothes_fit). show: true marks every clip on the character: red where a layer shows through the one over it, amber where cloth measures inside a limb (bigger = deeper; false clears). Also lists its garments and the fit in force (looser/tighter per garment from clothes_fit, fixes from clothes_fix). clip_check gives the raw numbers.

collision_view

Shows what bullets and feet actually meet: every collider within 40 m of the camera drawn over the picture as its boxes, coloured by what each is made of (a forged model's parts: wood orange, fabric violet, glass cyan, metal blue, ceramic white, plaster cream, plastic green, stone grey; a plain collider whose material is only guessed from its names grey; walk-through zones yellow). Lists boxes by material and the drawn objects with no collision at all. Edit and play; never saved. Forged models carry their own part boxes (collider shape "parts").

combat_report

Read who hit whom, simulation ticks, move frames, zones, guard/dodge outcomes and actual damage. With seconds>0 plus actor/target, run the real sparring bot on an isolated scene clone; no teleport or direct damage. Otherwise read this engine's live combat or the last unchanged-scene simulation. No run means authoring-only, never an invented pass. The combat_knockout proof requirement uses the same movement and attack path. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

compare_reference

Check a model against a reference drawing: one view of a three-view (side, top, bottom, front, back) is filled into a silhouette, the model is drawn alone from that exact direction, and the two are lined up and compared: a match score, a picture (red where the drawing has shape the model lacks, blue where the model has extra) and, station by station, how many meters each edge is off. Drawings go in Assets/References/<model>/.

crash_test

Measure a 40–100 km/h barrier crash (default 60). With object, exercises native part detachment and vertex dents on the authored car, returns a real rendered still and verifies source preservation. Preset-only is explicitly numerical. Reports measured impact speed and energy. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

culling

What the camera drew last frame and what it left out, and why: outside the view, wholly in a room nobody can see, or hidden behind last frame's depth (occlusion; it stands down while the camera moves fast, and the report says when and why). Also the clustered meshes (virtual geometry) and the detail levels drawn. Switch a stage off and on (occlusion, frustum, virtual_geometry, lod) to measure what it saves with frame_profile at the same camera; switches last until set again.

debug_overlays

The play systems' debug views drawn over the picture (Engine.debugOverlays), by name: with no arguments, which are on and how many boxes each draws from the camera now. `off` "name" (or "all") switches views off. Each view is switched on by its own system's tool (crumple {view: {on: true}}: the crumple lattices coloured by strain).

debug_view

Watch a game closely: switch debug views on or off over the picture (colliders: the collision view, every collider's boxes coloured by material, as collision_view; triggers: cyan boxes; joints: a line from each pin to what it holds, coloured by kind; cloth: each world cloth's edge, its pins as orange dots and red where it's inside something solid, and in the editor it runs the cloth too) and set the play speed (1 real time, 0.5, 0.25, 0.1: slow motion for a jump, a hit or a joint; nothing saved changes). The person has the same in the toolbar (the eye and the speed buttons). debug_overlays lists every view that's on, the systems' own too (crumple, magnet, board).

deformation_critic

Judge how a rigged character's skin holds up as it moves: every major joint through its range one at a time (shoulder, elbow, forearm roll, wrist, hip, knee, ankle, spine, neck) and six reference poses (deep squat, arms overhead, forward lean, mid-stride, cross-body reach), skinned as the engine skins. Per joint region: the worst volume change (flesh doesn't compress), crumple (crinkled skin), folded triangles, shading break and seam gap, each with the pose it came from; each limb's narrowest section (candy-wrapper twists); skin inside skin. Scored against the bars a body keeps in motion. show: a pose label from the report, held on the character for pictures (rig_release gives it back). HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

detail_critic

Detail Critic: judge how the scene reads up close, from the editor camera or a viewpoint, with the real renderer: texture detail at three scales, colour variation, roughness variation (not one plastic gloss), edges that catch light, shimmer as the camera moves a fraction of a pixel (against a supersampled reference), blotchy patches on flat surfaces, sharpness and the difference to the reference. Each score has a gate; under it fails with the reason. Returns a sheet (final, reference, normals, base colour) with the scores. Mac renderer only.

drive_test

The car's feel report, which every car must pass: three racing-driver laps (lap-time consistency, slip angle, off-line distance), a panic swerve, a lane change and a handbrake turn (spin-outs; only the handbrake may drift), with what to change when it fails. Then a 32-gate circuit at three assist levels: with object, the authored car and meshes in a separate native PlaySession with a real rendered still; with preset only, a labelled numerical fixture. Never edits source art. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

editor_layout_check

Check the editor's panels the way a person reads them: buttons or labels whose words don't fit, controls on top of each other, controls past the panel's edge. Name a panel, or leave it out for every panel. narrow: true checks at the side docks' narrowest width, then puts them back.

equipment_report

What a character has on: each slot's item and how it's worn (fitted cloth, or riding which bone), the model it draws, fits not made yet, and anything that couldn't go on. Without an entity: every item in Assets/Items that can be worn or held, by slot, and item files that don't read. Check clipping in motion with clip_check.

escape_check

Can the player get out, or get stuck? (Play.) Floods every place the player can reach from where they stand (or `from` [x, y, z]) over the scene's real colliders with the player's own body and moves: walking with its step height, dropping off edges, and jumps as high and as far as its jump speed and sprint carry it. Reports WAYS OUT (ground reached outside the boundary: the hull of every collider tagged "boundary", or `bounds` {min: [x, z], max: [x, z]}; and any walk or jump off into nothing), TRAPS (places it gets into and can't get out of, with the way in) and PERCHES (the highest things it can stand on, and the jump that gets there: is each meant to be climbed?). Cells of `cell` m (default 0.5; a snag smaller than that is for play_input walks). Holds the game still while it runs (up to `seconds`, default 40; then it reports what it has, marked unfinished). Run it after every change to a level's edges, with sense_check.

feel_check

Does the fight feel right? (Beta 2, 3D game feel) Plays the scene headless for `seconds` (its own fighters, brains and scripts; inputs drive the player like play_test's, e.g. [{from: 0, to: 8, move: [0, 1], fire: true}]) and reports every hit's feedback: hit-stop, camera shake, what flies off what was hit, its sound, the hit flash, a kill's slow motion, the controller's rumble, naming what was missing and on how many hits. With feel settings (shake, flash, hit_stop, rumble, effects) it checks the game as tuned. Nothing in the scene changes. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

fit_check

Check how a forged model's parts fit together like a real assembly: every pair of parts that come near each other with the gap between their surfaces and how deep one is sunk into the other (2 mm tolerance), groups floating free of the main body (a wing or light hovering off the hull), and parts poking through glass. snap: true fixes floating groups by moving each onto the body (nearest first, 1 mm in) by adding f.fit({snap: true}) to the recipe and rebuilding, then reports again. For a separate model in the same frame (a glow-lights model on a hull) pass against: the other recipe, so it is checked sitting on that one. In recipes: f.socket / f.attach join faces, f.mount slides a part onto a surface, f.fit reports and snaps. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

frame_governor

The frame governor: holds the frame rate on the fly without switching anything off. Over budget, it turns down one small step at a time what the eye notices least (bounced light re-learning more slowly, more minor lamps folded into light cuts' residuals, fewer light shaft steps, a coarser traced bounce, the render scale last), measures what each step saved and takes back any that saved nothing, and gives steps back when there is room. On while playing by default. Reports what it holds and what it did.

frame_profile core

Where the frame's time goes, measured live without turning anything off: every render stage's GPU time per frame (and CPU encoding), the frame interval and GPU busy time, whether the GPU or the CPU is the limit, and why the expensive stages cost what they do, by name: the lamps whose shadow maps were drawn again and the reason (the light moved, a caster it reaches changed, a moving character in it), the static casters that changed, the moving casters. Use it before optimizing anything (and after, with the same camera) instead of switching features off to guess. mode isolated times each stage alone (exact, but the frame slows down while measured). With experiments, surface_features or skip_passes, an HTTP call returns a job_id at once: read the result with tool_job.

frame_timing

Measure performance honestly: records every frame for a while (after a short warm-up) and reports the distribution of frame intervals and GPU time (median, p95, p99, max, frames over the 60 fps budget), plus the render resolution. Use it for before/after comparisons with the same camera and scene; engine_overview's GPU figure is a smoothed average that hides periodic spikes.

game_brief

The person's game in their own words: the pitch (what they asked for), what they said no to (avoid), the brief's requirements, the Game Plan's protected decisions and the next build-path step. Read it before changing a game you didn't just start; write the pitch when a new game starts ({pitch: their request, as they said it}) and add each "no" they give ({avoid: "no guns"}). Stored with the open scene's brief (Briefs/<scene>.brief.json).

game_ui_actions

List the game's named input actions as players get them: keyboard keys, mouse buttons, controller buttons, and the prompt glyph on each controller family (Xbox, PlayStation, Nintendo). Shows conflicts. Read only.

game_ui_lifecycle

Give a game the full lifecycle with no code (stock plain-row menus are rebuilt; a custom authored menu is kept exactly as it is and the reply lists what it lacks): title (Continue / New game / Load / Settings / Quit), save and load pages with slot names, time played and thumbnails (slot 0 is the autosave), pause with Save / Load / Retry from checkpoint, game over with Retry / Restart / Load, controls with keyboard and controller rebinding, dead zone and reset, accessibility (reduced motion, fewer flashes) and full screen. Keeps the layout's HUD, shop, dialogue and theme. Optionally declares named actions (controls: id, logicalKey, pad buttons a/b/x/y/lb/rb/lt/rt/l3/r3/view/dpad_*, label) and the game's save-state version with migrations (UI/save_schema.json). Add a game_flow component (autosave_seconds, retry, lives) and checkpoints: checkpoint_2d areas in 2D; in 3D a trigger whose script calls game.flow.checkpoint("Gate") when the player enters (kit_playbook game-ui).

game_ui_saves

Read a game's save slots from the editor's saves folder (Saves/): each slot's status (ok, empty, newer, damaged), name, scene, time played, checkpoint, game state version, thumbnail and backup. action restore_backup puts a slot's previous save back; delete moves a slot to the Trash.

ground_check

Quality check: is anything floating above the land or sunk into it? Measures every placed model (or one group, or named objects) against the terrain under it: the base of its box against the ground at its middle and part way out to its corners (plants and trees at the middle only, where the trunk stands). Lists floating objects with their gap, sunk ones with their depth, and how many sit right. settle: true moves every floating one down to rest `sink` metres into the land (one undoable step); run it after placing anything outdoors.

hang_report

Every moment the editor's main thread stopped answering for over 100 ms this launch (the spinning wheel is one that reached about 2 s): how long, what was running (tool, scene open, forge...) and the hottest code frames. Use it after a change that could freeze the editor; reset: true starts a fresh count.

hold_check

Check each hand's hold: fails on a finger floating more than 2 mm off the object, the hand more than 1 mm into it, a wrist bent past 20°, or a palm more than 5 mm off its hold point. Returns the readout either way.

impact_analysis

Before (or after) changing objects: what depends on them. Game Plan requirements and protected decisions that name them, plan routes that pass them, scripts and attachments that refer to them, engine capabilities they rely on (and how proven), which tests go stale, and whether to rehearse first.

import_report

The last import's report (Logs/last-import.json): every item with what came in, what was fixed, and what failed and why.

No arguments.

inspect_bench

Inspection Bench: see exactly how a generated character, creature or model differs from its reference sheet. Cuts the sheet into views, solves each view's camera and light so the model's render lies on the picture pixel for pixel, then returns a bench sheet per view (reference, model, 50% overlay, edge overlay, red/blue outline difference, shading or normal-map difference, close-ups at a fixed real-world scale) and a critic report: overlap, outline and edge distances in mm, landmarks, detail per scale band (too smooth = cartoon), colour ΔE, symmetry, and the worst regions ranked with a suggested sculpt_edit for each. Cameras are saved beside the sheet (.bench.json) for next time. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

items_report

What a project's Assets/Items holds (items, loot tables, recipes, shops) and every problem: files that don't read, names nothing defines, recipes no station can make, shops selling things with no price. With "id", one thing in full.

lab_run

Run a Motion & Interaction Lab station: its scene's bot repeats the move many times with random variation (body size, speed, approach angle, strength...), every trial measured (the bot's own scores plus foot sliding and soles in the ground from the drawn poses, and the frame time) and judged by the station's bars. A move counts as working at 98% of trials passing (500 trials for the record). Returns the pass rate, each score's spread, the failing trials with what was varied, and writes <station>-report.json/.txt and a contact sheet of the first trials' telling moments into `out`. Opens the station's scene in the editor (refused with unsaved changes); play it to watch the bot live.

listen

Hear the game: records what it's playing for a few seconds (works while the editor is muted) and reports loudness over time, peaks and clipping, where the energy sits (rumble to hiss), brightness, a spectrogram picture, and which sounds played how far away. Use it to judge sound like inspect judges looks; start Play first.

machine_profile

What this computer can run: GPU, memory, the graphics tier to use and which advanced systems (ray-traced shadows, GI, volumetric clouds, dense forests, upscaling) to turn on or keep off for a smooth frame rate.

No arguments.

memory_report

How much memory the editor uses and where it goes: the process footprint (what Activity Monitor shows), the GPU total, GPU memory by renderer part (models, surfaces, render targets, shadow maps, bounced light, reflections, hair) and the models holding the most. Use it before and after a change that could grow memory, and when the Mac slows down.

movement_score

The AAA movement scorecard: drives the third-person player through the real controls on a fixed course (starts from standing, stops, 90° and 180° changes walking and sprinting, a slow walk, running while the view swings; or `legs` of your own) and measures every drawn frame: (1) reaction, ms from a stick change to the body's hips visibly answering (and the first foot lifting from standing); (2) speed tracking, how closely the body's speed follows the speed the stick asks and the time to 90% of it; (3) foot slide, cm a planted foot slides; (4) PoseAnatomy failures (hinges folding backwards, limbs twisted past a person's range, feet backwards, hands in the body) per frame; (5) pivot, time and foot slide on each 180° reversal; (6) camera jitter and jerk. Each number beside its AAA target, with why. Starts and returns at once; call again with report true when the course is done (it hands the controls back).

nature_report

What nature the scene has: ground-cover layers (kind, area, density, expected plants, painted share), water bodies (kind, size, level, flow), waterfalls, the wind; with `point` [x, y, z], what the water does there (in water? surface height, flow, depth).

play_clip

Film a moment of play (Beta 2): plays the scene headless for `seconds` (2-3 is a hit, a jump, a door; up to 10) with play_test's inputs and camera, and answers a contact sheet of `frames` evenly spaced stills (default 8, labelled with their time) plus an MP4 of every frame at `fps` (default 30) in `dir` (default a new folder in the project's Captures). See motion, impacts and timing frame by frame: a hit's hit-stop and flash, a sail parting round a body, a landing. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

play_eval core

Run a little JavaScript in the live game (Play mode) as its scripts see it (game, world, input and what the kits publish: game.builder, game.strategyCamera...) and get the value of its last expression back as JSON. Read state (game.builder.money, world.all("villager").length) or set a test up (a time of day, the weather, coins, a piece placed). Runs on the game's next tick; nothing is saved to the scene; an error comes back with its message and stack. Doesn't take the person's controls. While a menu or a dialogue holds the game (no tick comes), it reads the game as it stands, without stepping time.

play_input core

Play the live game (Play mode) through the player's own controls, like a person: move [x, z] (a stick: x right, z forward, -1...1, as play_test's inputs take it) or hold keys (keys "w", "wa", "s"...; any other key in it is held for the game's scripts: "1", "q"), press (keys with longer names, for the scripts: ["SPACE"], ["RETURN"]), sprint, crouch, jump, fire (left button), aim (right button: aim down sights), reload (R), use (E), turn [yaw°, pitch°] (yaw positive right, pitch positive up) spread over the time, look_at [x, y, z] (turns there at up to 540°/s), or track_zombie (keeps the nearest visible zombie's chest under the crosshair; fire_on_target: tracks too and holds the trigger only while one is under the crosshair), for `seconds` (0.05...10). Takes the controls on first use (the keyboard is ignored until play_release). wait (default true): return when the command is done, with play_state's report. Works in games without a player character too (builders, strategy, card and rhythm games): keys and buttons go to the scripts, and pointer [x, y] (-1...1 across and up, as input.pointer() reads it) or point_at [x, y, z] (a world point, kept under the pointer as the camera moves) puts the pointer there until play_release; a click is fire with the pointer on it. While a menu or a dialogue holds the game, the keys go to it as a person's do: press ["RETURN"] (or use / fire) goes on, arrows or keys "w"/"s" move, ["ESCAPE"] goes back.

play_mode

Start or stop Play in the editor so the person can watch or play the game live. Play runs on a copy; Stop restores the scene exactly.

play_release

Give the game's controls back to the keyboard and mouse (after play_input).

No arguments.

play_report

Play Watch's report of a Play session (written when Play stops; every live session, the person's, the bot's or a replay's): issues found with where they happened (the player stuck and against what, walked through something with no collider, fell, enemies stuck, script errors, slow motion, a leak), frame spikes grouped by place with what happened around them, the slowest square metres of the map and which way the player faced, the events, and the replay file that reproduces the game. No arguments: the latest. list: the recent reports. name: one of them.

play_sequence

Play a sequence. While the game is playing in the editor, it starts there (the person watches it live, slow motion and all). Otherwise it plays headless on a copy of the scene and reports what happened: cuts taken, events fired, story and clock seconds, problems, where tracked objects ended, and a picture of its last frame.

play_state core

What the live game knows now, as the player: where the player is, where they face and look, speed, the HUD (health, ammo, wave, points, objective, outcome), and every zombie (nearest first): distance, where it is from the player's eyes (ahead / left / right and how far round), in sight or hidden behind something, how fast it moves, and STUCK when it has made no progress for over 2 s while away from the player. Script errors too.

No arguments.

play_teleport

Move the player during Play without stopping it (editing the Player object stops Play): to `position` [x, y, z], feet on whatever is solid under it (snap, default true: a deck, a floor or the land: any collider, found straight down from 2 m above), stopped, and turned to `look_at` [x, y, z] when given. Says what they landed on: "nothing under it" means a floor you can see but not stand on. For playthroughs and checks of where a player arrives.

play_test core

Play the game headless for some seconds on a copy of the scene (or rehearsal): runs scripts, triggers and physics, then reports the outcome (won/failed), on-screen messages, script errors with lines, script logs, and a screenshot of the last frame. Optional record.video encodes the successfully recorded PNG frames as an H.264 movie with measured frame count and duration. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

play_walk_to

Walk the player to a point during Play with the player's own controls (looking along the way, holding W, sprinting if asked), along a route the walking map finds for the player's body: round walls and furniture, up stairs and ramps (the zombies' map). Returns when arrived (within `arrive` m, default 0.8), stuck (where, and the waypoint it was heading for), or no route; at most `timeout` s (default 50, max 55: call again to go on). For playthroughs a person would play: walk the route, then use/look/fire with play_input.

proof_report

Prove the game against its brief, for the person to read: plays each requirement of the open scene's game brief (Briefs/<game>.brief.json) in a short headless scenario and returns a table (requirement, what it means in plain words, PASS / FAIL / PENDING, the numbers behind it) with the FIRST broken requirement called out, the steps that needed a person (the goal is none), and a plain-language "How this game works" (goal, win and lose, controls, rules, what each piece does and where to tune it). Show it to the person before saying a game is done. With build, also verifies a finished build for promo: Game Plan tests, a bot playing it many times (autoplay) and frame timing, written to promo/<build>/proof.md with a caption summary. "TTR doesn't just generate, it verifies." HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

quality_lab

Measure movement quality: a character runs a fixed course through the real controls (stand, run, sprint, strafe, the backward diagonal, backpedal, stop, crouch walk, turn on the spot, strafe while aiming) on a copy of the scene, and its final drawn pose is measured every step against the ground: planted-foot sliding, feet sinking into or floating above the land, foot tilt against the slope, joint snaps (pose jumps), ground slope and pose cost. Lists failed checks.

record

Capture build footage: start/stop an MP4. Visible viewport records at up to 30 fps and may drop frames to preserve latency; hidden/covered/other-Space viewport renders offscreen with lossless frame pacing (encoder backpressure, fixed 30 fps timestamps and simulation). No extra hidden GPU work without recording. Files go to promo/<build>/ with moments.md captions; still captures are separate.

record_physics

Bake physics into a sequence: plays a copy of the scene with the sequence up to from, lets physics take the object there (thrown at velocity [x,y,z] m/s with spin degrees/s, or moving as its keys were; a launch event at from works too; a ragdoll event in the stretch records every bone), records it on every tick until to (slow motion included, so it stays smooth slowed down) and keeps the keys a straight line between neighbours doesn't already give. Then edit any key (set_key, with falloff to reshape the arc) and it plays back the same every run. ignore: objects left out of the physics (the thrower's own body). Reports where it hit things and came to rest.

record_play

Film a scripted play run for judging movement by eye: every frame from cameras that travel with the player (side, three_quarter, over_shoulder, front, feet), at real speed (fps, default 30) and optionally a slow-motion window rendered at up to 120 fps (every simulation tick). Writes numbered PNGs into dir/<camera>/ and dir/<camera>_slow/, plus dir/locomotion.csv (the player's speed, gaits, blend, stepping phase, stride and leg turn every tick). Turn the folders into videos with ffmpeg.

reload_check

Check a keyed reload frame by frame: where the support hand goes into the gun (and which part), where the arm can't reach its key, and each key's moment. Fails on the hand more than 3 mm into the gun or 1 cm short of a key.

replay

Replays: every Play is recorded (the player's controls each tick, a few KB) into the project's Replays folder, and plays back exactly. list: newest first. watch: play one back live in the viewport (the player's own camera). check: replay it headless and compare the ending with the recording. race_ghost: start Play with the person in control and the replay racing alongside as a ghost (a tinted copy of its player and what they drive, moving exactly as recorded; nothing in the game can touch it).

retarget_check

Does an animation made for another rig look right on this character? Plays `clip` from `library` (an animation pack or rigged model under Assets: a GLB, an imported FBX's GLB, or a .bvh) on `entity` the way a game plays a library (limbs matched, legs planted) and judges it frame by frame against the source (RetargetCheck): feet sliding, sinking or floating while planted, a crouch or fold (hips low, knees or torso bent more than the source's), feet tipped, limbs or hands away from the source's, a two-hand hold coming apart, a foot inside the other leg, the body check failing where the source's doesn't. RETARGET PASS or FAIL with every flaw named. all: every clip of the library, a line each (no stills). report: the verdicts written to Scripts/data/<report> for the game (game.data). rest (every_bone or limbs) and legs try another way for this check only; library_rest / library_legs change how games play libraries. keep_feet: plant the legs (default as legs). save_as keeps the result as a pose clip (default <clip>_<entity>).

road_report

What the scene's road network is: each road (type, length, lanes, speed, bridges), every intersection (number, kind, where, arms and their control), ramp merges, overpasses, props, the lane graph, and checks (dead ends, unreachable lanes).

No arguments.

run_tests

Run the Game Plan's tests on the scene (or the open rehearsal). Failures explain what's wrong and which object is to blame; include_picture adds an image of the problem.

screenshot core

See the scene: a PNG from the editor camera, or from any position looking at any point.

sense_check

Does it make sense? Run it before calling a place done (Gordon 10-30: never build things that don't make sense). Checks every place a player arrives (their start, checkpoints, anything tagged "arrival", and `points` given as {name, position}): the first surface seen straight below must be solid (an object with a collider, or the land), else it's a floor the player can see but falls through. Then, across the scene: big floor-like models (decks, platforms, floors, booths, gates: anything big and solid-looking at ground level) with no collider; things floating with nothing under them; objects whose about-role is empty (what is it? what is it for?). Lists findings and, for each arrival, the camera for a player's-eye screenshot (look at every one: is there a way in and out, and does it read as a real place?). In Play it also runs escape_check: every way out of the boundary, every trap, every perch (escape: false skips it).

strings_check

Check the game's translations: for each language (or `language`), how many of the game's texts are translated, which are missing, placeholders dropped or invented, plural forms the language needs, texts left as the English, whether the game's fonts have the language's letters (else the system face for the language is used), and text that won't fit: every screen of the game's layout drawn in that language at `size` (default 1280x720), each text measured the way the renderer sets it (Chinese and Japanese break between letters, Arabic runs from the right), listing what is cut off, what breaks mid-word and what has to shrink below 80%. Fix by shortening the translation, widening the box, or a smaller font for that language. Codes: es, pt (pt-BR), fr, de, it, nl, pl, tr, vi, id, ru, uk, el, ja, ko, zh-Hans, zh-Hant, ar, he, hi, th (any BCP 47 code works). The engine's own menu words already come in es, pt, fr, de, ru, ja, ko, zh-Hans and ar.

ui_report

Read and validate saved game UI, screen/widget bindings and Deck-size layout; every line of text (titles, subtitles, text widgets with their id and rect) and the preset sample lines still showing. This is source/layout evidence, not proof of play: use proof_report checks ui_pause_resume and ui_inventory_pickup. With export_job, read that export's durable completion receipt.

view_channel

Switches the live viewport to one render channel until set back to picture: zebra (every surface mirrors bands of light; on a fair surface they flow in smooth curves, a dent, ripple or step between panels bends or breaks them: how car bodies are judged), normals, materials, base_color, lighting_only, wireframe, shadows, bounced_light, light_complexity, shadow_atlas. For a still, use screenshot's debug_view instead.

viewport_report

Where did an object go? For the person's live viewport right now: every model and whether it is in view, outside the camera's view, hidden by see-through walls (it stands between the camera and the point the camera turns around), still loading, or missing; with its level of detail and distance, plus the camera and its orbit point. Use it when someone says objects disappear.