---
name: set-anima-scenes
description: Build sheets for every scene Set ships, so each one can be rebuilt as a replica, namely the six columns of the home page, /anima, /anima-all-weapons, /anima-scene and /item-models, with the portraits and the Anima Preview of a saved character. Use when composing a scene from Set API responses, reproducing one of Set's own pages, choosing how faithful a replica should be, or looking up which skill, which section of the math reference and which source file holds a given mechanic. Includes the contract every scene keeps and a schema for a scene and its actors.
license: Free to use when obtained from set.world, commercially too (the API, what it returns, the skills and downloaded models). The source code of Set is © Jimmy Lee under CC BY-NC 4.0 and its commercial use needs a paid waiver.
metadata:
  version: "0.8.9"
  title: Scenes
---

# Scenes (AnimaSystem)

A scene is a game built on Set: it takes complete API responses and adds a body, equipment, movement, combat and rendering in the client. Set ships ten of them: six columns on its home page and four pages. This skill is the build sheet for each, and the index of where every mechanic they use is written, so any of them can be rebuilt. Scenes never write back to the API, never store combat state on a server and never send a request per hit.

## How faithful a replica can be

| Depth | You build from | Terms |
| --- | --- | --- |
| The same rules, your own art | These skills and the math reference (`https://set.world/algorithms`). Every rule, formula, table and timing is written there | Free, commercial games included |
| The same models and motion | The GLB downloads: the body and its clips from `/anima`, any item from `/item-models` | Free, commercial games included |
| The same code | Set's source: `three-isometric-engine/` (rules, physics, rendering) and `components/` (the pages) | Read it, and reuse it non-commercially with credit. A commercial product needs a waiver ([AGENTS.md](https://set.world/AGENTS.md)) |

Two things exist only in the source: the keyframes of each weapon action (`three-isometric-engine/weapons/actions.ts`), and the runtime shaders (the liquid-metal body, the material patterns). A replica at the first two depths authors its own weapon motions from each action's name, delivery and timing, and its own surface.

## The contract every scene keeps

- **Real characters only.** An actor exists only after a successful `/api/roll/character` response. Keep the full response, its seed, its `contentVersion` and your own ID beside it. Never fabricate an actor or edit the response.
- **One request at a time.** A queue of jobs, each with its own derived seed ([Rolling a group](https://set.world/skills/rolling-a-group)); one request in flight. A failure keeps the actors already placed and lets the job retry with the same seed.
- **One snapshot.** All actors in a scene share one `contentVersion`. A change means clear and start again.
- **Local state beside the birth.** Health, stamina, position, cooldowns and equipment changes live in the scene, never in the response.
- **No request per hit.** Damage, stamina and targeting run in the client.
- **Honest clocks.** A fixed 60 Hz step, at most 5 catch-up steps per frame, the rest discarded. Hidden, paused and offscreen time grants no catch-up. Reduced-motion settings start a scene paused.
- **Explicit cleanup.** Each scene owns its canvas, requests, workers, skeletons and GPU uploads, and releases them on clear and on unmount.

## Every mechanic, and where it is written

Each mechanic has one skill that states its working rule, one part of the reference that derives it, and one place in the source. Source paths are under `three-isometric-engine/`, except those written with an alias: `@common/`, `@components/` and `@pages/` are the repository's own top-level folders.

| Mechanic | Skill | Reference | Source |
| --- | --- | --- | --- |
| Characters, items, seeds, orbs | [Rolling a character](https://set.world/skills/rolling-a-character), [Crafting an item](https://set.world/skills/crafting-an-item) | §1 to §11 | The API |
| The body: mesh, rig, skin weights | [Character models](https://set.world/skills/anima-character-models) | §15.1 to §15.6 | `avatar/model.ts`, `avatar/anima-rig.json` |
| Body colour from traits | [Character models](https://set.world/skills/anima-character-models) | §13.64 | `@common/anima-color.ts` |
| Liquid-metal surface and eyes | This skill, depth three | §15.18, §15.19 | `avatar/model.ts`, `avatar/eyes.ts` |
| Body motion: idle, walk and run, jump, punch, hit, kneel, get-up | [Animations](https://set.world/skills/anima-animations) | §15.7 to §15.13 | `avatar/motion.mjs`, `avatar/gait.ts`, `avatar/hit-reaction.ts` |
| Ragdoll, pickup, drag, flick, recovery | This skill | §15.16, §15.17 | `avatar/ragdoll.ts`, `avatar/interaction.ts`, `avatar/recovery.ts` |
| Held-item models and grips | [Item models](https://set.world/skills/anima-item-models) | §13.35 to §13.45, §13.48, §13.55 to §13.57 | `weapons/catalog.ts`, `weapons/meshes.ts`, `weapons/grip.ts` |
| Worn items: cloth, plates, layering | [Item models](https://set.world/skills/anima-item-models) | §13.52 to §13.54, §13.58, §13.59, §13.61, §13.66, §13.68 | `armor/` |
| Material looks | [Item models](https://set.world/skills/anima-item-models) | §13.63 | `items/material-looks.ts` |
| Weapon actions and how a hand wields | [Animations](https://set.world/skills/anima-animations) | §13.22, §13.69, §15.15 | `weapons/actions.ts`, `weapons/usage.ts` |
| Weight, stamina cost, stamina-priced hits | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.1 to §13.3, §13.47 | `weapons/handling.ts`, `weapons/impact.ts` |
| Tempo and reach | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.22, §13.69 | `weapons/tempo.ts`, `weapons/reach.ts` |
| Launch, flight, range, reload | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.4 to §13.8, §13.32 to §13.34 | `weapons/range.ts`, `weapons/ballistics.ts` |
| Bows, crossbows, the Rifle and the Hand cannon | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.26, §13.27, §13.60, §13.62 | `weapons/archery.ts`, `weapons/bow-aim.ts`, `weapons/gunfire.ts` |
| Whips, slings, chains, returning throws, harpoons, tethers | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.9, §13.10, §13.15 to §13.17, §13.49 to §13.51 | `weapons/flexible.ts`, `weapons/whip.ts`, `weapons/sling.ts`, `weapons/return-flight.ts`, `weapons/harpoon.ts`, `weapons/throw-tether.ts` |
| Magic: Flick, Repulse, Gaze, rings, Rupture | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.25, §13.72 | `weapons/magic.ts`, `weapons/repulse.ts` |
| Material weight, protection, ward, hit power, stamina recovery | [Derived stats](https://set.world/skills/anima-derived-stats) | §13.70, §13.71 | `anima-scene/anima-system.ts` |
| Levels and orbs per item | [Derived stats](https://set.world/skills/anima-derived-stats) | §13.30 | `anima-scene/generation.ts`, `anima-scene/progression.ts` |
| Whole-number health, stamina and damage | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.65 | `@common/local-resources.ts` |
| Teams, targets, sight, aim points | This skill | §13.18, §13.21 | `anima-scene/teams.ts`, `anima-scene/model.ts`, `weapons/target-markers.ts` |
| Movement, blocking, patrol, moving attacks, hand choice, winded retreat | This skill | §13.19, §13.20, §13.31 to §13.33 | `anima-scene/locomotion.ts`, `anima-scene/collision.ts`, `anima-scene/patrol.ts`, `anima-scene/tactics.ts` |
| Knockback | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.36 | `weapons/impact.ts` |
| WorldSpheres | This skill | §13.23, §13.24, §15.14 | `anima-scene/world-spheres.ts`, `avatar/world-sphere-rules.ts` |
| The floor | This skill | §13.46 | `anima-scene/floor.ts`, `anima-scene/floor-surface.ts` |
| Camera, lighting, the clock | This skill | §15.20 | `anima-scene/camera.ts`, `anima-scene/stage.ts`, `avatar/stage.ts` |
| Crowds: cloth in workers, shadow pacing, detail tiers | This skill | §13.53, §13.67 | `armor/cloth-pool.ts`, `anima-scene/shadow-governor.ts`, `common/view-level.ts` |
| Turn-based dungeon and its maze | [Derived combat](https://set.world/skills/anima-derived-combat) | §14, §16.7 | `dungeon/adventure.ts`, `dungeon/initiative.ts`, `common/dungeon-maze.ts` |
| Army battle | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.28 | `anima-scene/battle.ts` |
| Craft stone | This skill | §16.5 | `craft-rock-stage.ts`, `common/fracture-cells.ts` |
| Portraits | This skill | §13.68, §16.6 | `avatar/character-portraits.ts`, `items/portraits.ts` |
| One dressed body that walks and attacks on request (the item inspector, the Anima Preview) | This skill | §13.57 | `items/view-stage.ts`, `items/outfit.ts`, `items/weapon-showcase.ts` |
| Model and clip export | [Character models](https://set.world/skills/anima-character-models), [Item models](https://set.world/skills/anima-item-models) | §15.21 | `avatar/model.ts`, `items/export.ts` |
| Interface: dithering, header flames, liquid-metal buttons, layout | This skill, depth three | §16.2 to §16.4, §16.8 | `@common/bayer.ts`, `@common/character-flames.ts`, `@common/liquid-metal.ts` |

[Algorithms](https://set.world/skills/algorithms) is the map of the reference. The layout numbers in the sheets below that are not computed (the patrol square, the walk-to-run blend, the frame rates of the previews, the settling time after a battle) are written by hand from the engine as it stood at `anima-system-10`.

## From a response to an actor

Every scene with characters does the same five things, each owned by one skill:

1. **Stats.** Read `finalStats` and `attributes` once ([Rolling a character](https://set.world/skills/rolling-a-character)). A scene-based game then applies [Derived stats](https://set.world/skills/anima-derived-stats); a turn-based one does not.
2. **Body.** One shared template, one skeleton per actor, coloured by its traits ([Character models](https://set.world/skills/anima-character-models)).
3. **Equipment.** Two held items and thirteen worn ones, each in its rolled material ([Item models](https://set.world/skills/anima-item-models)).
4. **Motion.** One complete action at a time ([Animations](https://set.world/skills/anima-animations)).
5. **Rules.** [Derived combat](https://set.world/skills/anima-derived-combat) decides what an attack costs and deals. The actor stays hidden and untargetable until its equipment is ready to draw.

## Build sheets: the home page

`https://set.world` is a sidebar of these skills beside six columns. Each column is a small scene.

### Roll an item

- **Shows.** One item: its name linked to `/roll/item/<rolls>`, its grade, material, rarity score, orb value, slot themes, a still of its model, and its AnimaSystem reading.
- **Takes.** `GET /api/roll/item`, one request ([Rolling an item](https://set.world/skills/rolling-an-item)).
- **Build it.** Keep the previous result until a replacement succeeds. Read every value from the response's `breakdown` row; never parse the name. Draw the still from `slot`, `props[3].name` and `props[2].name`.
- **Source.** `@components/GeneratorSection.tsx`, `@components/ItemPreview.tsx`, `@pages/roll/item/[id].tsx`.

### Roll a character

- **Shows.** A full character sheet with two sliders, **Orbs per item** and **Level**.
- **Takes.** `GET /api/roll/character`, one request.
- **Build it.** Render the birth as returned. With the sliders above their defaults, project the birth with the level and orb recipe in [Derived stats](https://set.world/skills/anima-derived-stats), in the client, and show the projection. The link on the sheet saves only the original birth ([Rolling a character](https://set.world/skills/rolling-a-character)); the saved page replays the projection from the link's parameters.
- **Limits.** The projection is one game's progression, not Set's. Projected stats may pass 24.
- **Source.** `@components/CharacterElement.tsx`, `@common/character-sheet.ts`, `@common/character-simulation.ts`, `anima-scene/progression.ts`.

### Roll a party

- **Shows.** A roster, 4 by default, as cards with a face portrait, class, level, power rating and resource bars.
- **Takes.** One `GET /api/roll/character?seed=deriveSeed(seed, i)` per member, in order ([Rolling a group](https://set.world/skills/rolling-a-group)).
- **Build it.** Keep completed members when a later request fails; stop the run if `contentVersion` changes; replace the old party only when the new one's first member arrives. The same roster, even a partial one, feeds the adventure column.
- **Source.** `@components/GeneratorSection.tsx`, `@components/CharacterPortrait.tsx`.

### Adventure mode with party

- **Shows.** A first-person maze with a minimap and the party's cards. The party walks on its own (arrows and WASD also steer), stops at an enemy it faces and fights in turns.
- **Takes.** The party's births from the column beside it, then up to 6 enemies, one request each, on seeds derived from the first member's seed and `contentVersion`.
- **Build it.**
  1. Make a 15 by 15 maze keyed by the first member's ID, seed and snapshot, and find the route from the entrance to the farthest cell (§14.1, §16.7).
  2. Stand one enemy just past a corner of that route, at least 5 route steps apart, up to 6.
  3. When the party faces a living enemy from the next cell, start an encounter. The fight is the turn-based half of [Derived combat](https://set.world/skills/anima-derived-combat) (`dungeon-initiative-1`), which lists the steps under Adventure mode with party.
  4. Show each turn over 1.1 seconds and apply it at 0.36; these are presentation times and restore no stamina.
  5. Give only enemies a body: Anima in its generated outfit, holding both generated items. The items are gestures here; they change no number.
  6. End in victory when every enemy is cleared and the party is back at the entrance, and in defeat when no member lives. Replay restores the same cast to full resources.
- **Limits.** No rewards, progression, gear effects or status effects.
- **Source.** `@components/AdventureSection.tsx`, `@components/Dungeon.tsx`, `dungeon/`, `dungeon-stage.ts`.

### Craft an item using orbs

- **Shows.** A marble slab over a result card. Crafting renders the card under the stone, and the stone breaks from the point it was struck.
- **Takes.** `GET /api/craft?orbs=N&seed=`, one request ([Crafting an item](https://set.world/skills/crafting-an-item)).
- **Build it.** Cut a seeded outline into Voronoi cells ordered by distance from the strike; give each piece its own hull and mass; turn pieces dynamic as the fracture front reaches them and let rigid-body physics move them (§16.5). Lock one operation from the stone's preparation to the response, and reveal the card directly when motion is reduced or the renderer is not ready. The stone's sheen follows the slider and means nothing: it never shows an outcome or a probability.
- **Limits.** No wallet, refund or inventory. A failed craft keeps the previous card.
- **Source.** `@components/CraftingSection.tsx`, `@components/CraftRock.tsx`, `@components/CraftResult.tsx`, `craft-rock-stage.ts`, `common/fracture-cells.ts`.

### Battle with armies

- **Shows.** Two armies of 16 fighting to elimination under an overhead camera, with a card per fighter.
- **Takes.** 32 births at `deriveSeed(base, 0…31)`, one request at a time; even indexes are one army and odd the other.
- **Build it.** The fight is the scene-based half of [Derived combat](https://set.world/skills/anima-derived-combat), which lists the steps under Battle with armies, run on the Anima scene's model below. The column adds only its staging: opposite formations, 4 to a row, a board revealed once everyone is equipped, four seconds for bodies to settle after the result, and a Reload battle that reuses the same cast with no new request.
- **Limits.** No time limit and no forced damage, so a battle heavy with healing may never end. No pickup and no WorldSpheres.
- **Source.** `@components/ArmySection.tsx`, `@components/army/ArmyBattle.tsx`, `anima-scene/battle.ts`, `anima-scene/stage.ts`.

### Portraits

- **Character faces.** Each card and sheet shows the character's Anima from the face view, in its rolled outfit and trait colour, without held items. One shared offscreen renderer draws one still at a time into a 2D canvas, only for portraits on screen, and caches them (§16.6).
- **Item stills.** Each item row shows its model in its rolled material, drawn into a 2D canvas from the same meshes as the scenes.
- **Source.** `@components/AnimaPortrait.tsx`, `avatar/character-portraits.ts`, `@components/ItemPortrait.tsx`, `items/portraits.ts`.

### Anima Preview

- **Shows.** On a saved character's sheet (`/roll/character/<uuid>`), one window with that character's Anima: its trait colour and all 15 of its rolled items, worn or held in their rolled materials, on the shared floor.
- **Takes.** Nothing new: the birth the page has already loaded.
- **Build it.** Turn each equipped item into a model reference ([Item models](https://set.world/skills/anima-item-models)), the first `hand` and `finger` item on the right and the second on the left. Dress one body in layer order with `tool` in the right hand and `offhand` in the left. **Start walking** walks in place. **Start attack** alternates complete right and left actions, or loops the punch with empty hands ([Animations](https://set.world/skills/anima-animations)). Both can run together.
- **Controls.** Drag to turn, Zoom out, Zoom in, Fit, Start and Stop attack, Start and Stop walking. It opens at 1.5× the `/item-models` Anima pane's framing, and Fit returns to that opening view.
- **Limits.** A model preview, the same stage as the Anima pane of `/item-models`: actions play at that pane's fixed stats, not at this character's own tempo, and nothing takes damage. It sends no request and changes nothing saved.
- **Source.** `@components/AnimaPreview.tsx`, `@components/ItemModelView.tsx`, `items/view-stage.ts`, `items/outfit.ts`, `items/weapon-showcase.ts`.

## Build sheet: `/anima`

- **Shows.** Eight previews of the body on the shared floor, wearing whatever the item and material sidebars select: Base avatar, Portrait face, Walking, Jump, Attacking, Taking a hit, Kneeling, Lobbing a WorldSphere.
- **Takes.** Nothing from the API.
- **Build it.**
  1. Load the body once and give each preview its own skeleton ([Character models](https://set.world/skills/anima-character-models)).
  2. Drive each preview with one motion from the pose function ([Animations](https://set.world/skills/anima-animations)): breathing, the walk-to-run blend, the jump at a chosen height, the punch or the held items' actions, hits at a chosen rate and direction, the kneel, and the WorldSphere pickup, hold and lob.
  3. Dress every preview in the same outfit from the sidebars ([Item models](https://set.world/skills/anima-item-models)). In Attacking, two held items alternate complete right and left actions at all-16 stats; with none, the punch loops.
  4. Recolour all eight with the Color and Grayscale sliders.
  5. Export the body or a clip as GLB from the pose function, sampled at 60 Hz.
- **Controls.** Play and Pause, Replay, turn controls, and one slider per motion: walk to run, jump height, hits per minute with a direction.
- **Clock.** Idle previews draw at up to 30 frames per second and demonstrations at up to 60, only while visible.
- **Limits.** Visual only: no roll, request, damage or combat state.
- **Source.** `@pages/anima.tsx`, `@components/CharacterAvatar.tsx`, `@components/ItemSidebars.tsx`, `avatar/`.

## Build sheet: `/anima-all-weapons`

- **Shows.** One Anima for each of the 145 mainhands, holding its tool on the shared floor and playing its action, with the worn-slot sidebars dressing every Anima alike.
- **Takes.** Nothing from the API. Every Anima has fixed all-16 stats.
- **Build it.**
  1. Take the held-item table in [Derived combat](https://set.world/skills/anima-derived-combat): it gives each tool's grip, action, delivery, stamina cost and seconds at exactly this field's stats.
  2. Lay the field out by attack speed, fastest first, rows left to right, and label each Anima with its rank.
  3. Give each Anima its tool's model in the right hand ([Item models](https://set.world/skills/anima-item-models)) and loop its action at the table's `seconds`, paying the table's `stamina` once per action and recovering 10 a second.
  4. Run each action's delivery with the scene-based rules: melee contact, projectiles with their flight and reload, rings, cones and waves. Projectile actions aim at a practice target; nothing takes damage.
  5. Pickup, drag and flick any Anima; it lands, gets up, walks back to its cell and resumes.
- **Controls.** Show attacks, Stop attacks, Unique (one Anima per distinct action) and Dual wield (the same tool in both hands, alternating complete right and left actions, re-ranked by dual-wield speed).
- **Limits.** No combat, roll or request.
- **Source.** `@pages/anima-all-weapons.tsx`, `@components/AnimaWeapons.tsx`, `weapons/stage.ts`, `weapons/`.

## Build sheet: `/anima-scene`

The fullest scene: every mechanic in the table above runs here. Click the floor to add real characters, place teams, turn on Combat and watch them fight with their generated equipment.

- **Takes.** One `GET /api/roll/character` per placed Anima, on `deriveSeed(base, index)`, one in flight at a time, with a 30-second timeout and a retry that keeps the job's seed and place.
- **Controls.** A click on the mat queues one neutral Anima. **Place Team A** and **Place Team B** each queue 16. **Level** (1 to 99) and **Orbs per item** (0 to 15,625) are captured when a job is queued and never change placed actors. **Combat** starts off. **Place WorldSphere**, Pause, Shadows, Labels and Clear complete the bar.

### Allegiance and targets

- Team A fights Team B and neutrals; Team B fights Team A and neutrals; neutrals never fight each other.
- One rule decides who may be attacked, for sight, punches, weapon contacts, every projectile and every tether, so an ally never takes a hit. Healing rings include everyone.
- Dead, falling, held, landing and still-dressing Animas cannot be attacked.
- Team identity is on the label, never in the body colour: every Anima keeps its trait colour.

### Routine

- Each Anima follows one directive at a time: fetch a WorldSphere, retrieve its dropped offhand, engage, follow, patrol, hold its station, return, or idle. A committed attack, throw, pickup or hurt reaction finishes first.
- **Combat off.** Neutrals form a chain, ranked by Strength, then power rating, then arrival: the strongest walks the corners of a square 4 units from the centre and each other follows the next stronger one. Teams hold opposite stations, 4 to a row, facing inward.
- **Combat on.** Everyone runs. An Anima looks for opponents in a forward cone of about 160 degrees out to `8 × visionRange`, and hunts the nearest when none is in view. Beyond 5 units it uses a ranged hand if it has one, inside a melee hand ([Derived combat](https://set.world/skills/anima-derived-combat)).
- **Moving.** Walk and run blend over 0.65 seconds without resetting the stride. Attacks can start and finish while moving; kneeling shots plant the shooter.

### Bodies

- Living Animas block movement and cannot be shoved; knockback cannot pass through a body. Corpses stay solid and pushable.
- A damaging hit cancels the unfinished action and blocks new ones for 2.4 seconds after the latest hit.
- Death captures the pose into a ragdoll of sixteen articulated bodies, which stays until Clear.
- Any Anima can be picked up, dragged and flicked. A living one lands, gets up and rejoins its routine; a dead one stays down. A held Anima takes no attack and runs no routine.
- Rupture and a landed Javelin throw a living target into a short ragdoll tumble along the hit.

### WorldSpheres

- Only Place WorldSphere creates one: a large textured prop at a clear point, distinct from the item Orb.
- During Combat, fetching a free sphere comes before anything else. A carrier lobs it at an opponent in range for a fixed 222 damage with no dodge roll.
- Taking a sphere drops the offhand item on the ground; the Anima picks it up again before returning to its routine.

### Crowds

Geometry and surface detail are never reduced. Cloth solves in workers and freezes outside the view; only purely visual physics and the shadow map's size and rate scale down as Animas get small on screen (§13.53, §13.67).

- **Source.** `@pages/anima-scene.tsx`, `@components/AnimaScene.tsx`, `anima-scene/stage.ts` (the renderer and clock), `anima-scene/model.ts` (the fixed-step simulation), `anima-scene/equipment.ts` (held items in play).

## Build sheet: `/item-models`

- **Shows.** Every base type on the body and alone, in any material its table allows, with each material's AnimaSystem reading and a GLB download of the chosen item.
- **Takes.** Nothing at runtime; the catalog is the item tables ([Item properties](https://set.world/skills/item-properties)).
- **Build it.** One item per slot from query parameters, one focused item shown alone, the material picker limited to that slot's material table ([Item models](https://set.world/skills/anima-item-models)); the readings are the tables in [Derived stats](https://set.world/skills/anima-derived-stats) and [Derived combat](https://set.world/skills/anima-derived-combat).
- **Source.** `@pages/item-models.tsx`, `@components/ItemModels.tsx`, `@components/ItemModelView.tsx`, `@common/item-models.ts`, `items/`, `armor/`.

## A schema for a scene and its actors

No API object describes a scene; this is the shape Set's own scene keeps, simplified:

```ts
type SceneActor = {
  id: string;                      // your own ID, shown as the display name
  seed: number;
  contentVersion: string;
  birth: Character;                // the full response, never edited
  derived: AnimaCharacter;         // from Derived stats
  team: 'A' | 'B' | null;          // null is neutral
  settings: { level: number; orbsPerItem: number };   // captured when the actor was queued
  position: [number, number, number];
  facing: number;                  // yaw, in radians
  directive: 'fetch' | 'retrieve' | 'engage' | 'follow' | 'patrol' | 'station' | 'return' | 'idle';
  state: 'preparing' | 'alive' | 'held' | 'recovering' | 'dead';
  combat: CombatantState;          // from Derived combat
};

type Scene = {
  seed: number;                    // the base seed of the placement queue
  contentVersion: string;
  rules: { scaling: string; system: string };
  combat: boolean;
  time: number;                    // scene seconds; advances only while visible and unpaused
  queue: Array<{ index: number; seed: number; team: 'A' | 'B' | null; point: [number, number, number] }>;
  actors: SceneActor[];
};
```

```jsonc
{
  "seed": 7,
  "contentVersion": "4.swpi78HUCtcrZ1Eoi9dipw",
  "rules": { "scaling": "anima-scaling-5", "system": "anima-system-10" },
  "combat": true,
  "time": 12.35,
  "queue": [{ "index": 2, "seed": 1013904249, "team": "B", "point": [6, 0, -2] }],
  "actors": [
    {
      "id": "hero-1",
      "seed": 7,
      "contentVersion": "4.swpi78HUCtcrZ1Eoi9dipw",
      "birth": { /* Character */ },
      "derived": { /* AnimaCharacter */ },
      "team": "A",
      "settings": { "level": 1, "orbsPerItem": 0 },
      "position": [-6, 0, 2],
      "facing": 1.57,
      "directive": "engage",
      "state": "alive",
      "combat": { /* CombatantState */ }
    }
  ]
}
```

The positions, time and state are invented for the example.

## What to keep for a replay

The full roll, seed and `contentVersion` of every actor, your rule versions, and your simulation inputs. A content stamp alone cannot replay a changing spatial game, and a scene report is not a save file. Keep action randomness apart from visual randomness.

## Limits

No scene proves weapon balance, a frame rate or that every battle ends (healing includes opponents and nothing forces a winner). Set has not tested its models, clips or rules in other engines.