---
name: set-anima-scenes
description: Build sheets for every scene Set ships, so each one can be rebuilt as a replica, namely every column of the home page, /anima, /anima-all-weapons, /anima-scene, /anima-stratagem, /anima-battle, /anima-battle-effects, /anima-analysis, /anima-prefixes-suffixes-effects, /anima-object-models, /anima-talents, /anima-class-talents and /anima-model-teams, plus /anima-adventure with its forest scene and its temple scene, 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 and the skills). Its models, animations and textures, Anima included, are CC BY 4.0: free to use with attribution to Jimmy Lee (j@internet.dev). 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.15.35"
  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 one for each column of its home page and for each of its 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 `/anima-object-models` | Free, commercial games included, with a credit to Jimmy Lee (j@internet.dev) (CC BY 4.0) |
| 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.

## What the scenes are built with

The scenes are the third part of Set, after the API and the Anima System's rules ([AGENTS.md](https://set.world/AGENTS.md)). They add nothing to either: a rule that decides an outcome is written in [Derived stats](https://set.world/skills/anima-derived-stats) or [Derived combat](https://set.world/skills/anima-derived-combat), and a scene only draws it.

- **Renderer.** Three.js 0.186.1 on WebGL, one canvas per scene. No rule depends on it: every build sheet below works in any engine that loads GLB.
- **Pages.** React 19 on Next.js 16. Each scene is one component that mounts a canvas and releases everything it made when it unmounts, except the two exploration scenes of `/anima-adventure` (`?scene=1`, the forest, and `?scene=2`, the temple), whose prepared stages are kept while the visitor is on that page and released once they leave it (their build sheets below). Once preloading starts, and only while no other loading job runs, Set's pages load the scenes' code and prepare what a scene needs before it can draw (the body's decoded geometry and the measures armor fits to, the painted floor, the motion poses every fight samples) and keep it for the visit, so a scene opened later starts sooner; none of it opens a renderer, and anything the page has already loaded for itself is counted, not loaded again. Preloading starts when the visitor presses **Start** on the toast **Start preloading?**, which appears only once the page has finished its own loading and nothing it covers has loaded yet, or as soon as the page finishes one preload task's work itself, whether it opened a scene on its own or because the visitor started a battle, rolled or placed Animas; then the question never shows, or leaves if it is showing, and only dismissing it first keeps the rest from loading. A scene's own loading counts from the first moment: each preload task whose work it finishes shows at once as an **Already loaded** toast, so the stack fills as the scene prepares to draw its Animas. Every module and result a task stands for marks itself done where its work happens, so every scene's loading reaches the same toasts.
- **Prepared measurements.** Every reading a rule takes from a held model's geometry (its mass, reach, size and the shapes the item effects spread over) depends only on the model, and each hand's closed grip depends only on the hand and the handle's size, so both are measured once when the site is built and shipped as data ([Randomness](https://set.world/skills/anima-randomness), Fixed). The Anima body's measurements that every garment fits to (its radial tables, limb samples and foot tables) are prepared the same way. A page builds a held model only to draw it, or to weigh a fist weapon fitted over a glove or ring, whose geometry depends on what that hand wears.
- **Physics.** The scenes' own fixed-step code moves bodies, ragdolls, ropes and cloth. The craft stone alone uses a Bullet build.
- **Workers.** Cloth solves off the main thread in a pool of workers, and the rigid head, hand, wrist and finger pieces are built there before an Anima is dressed ([Orchestration](https://set.world/skills/anima-orchestration)), so a crowd does not stall the page. The body's geometry is decoded once per page and shared by every actor.
- **Viewport.** Every scene that draws Animas fits its drawing buffer, antialiasing, shadows, floor texture and detail to the screen it is on, the same way on every device: [Viewport performance](https://set.world/skills/anima-viewport-performance).
- **Mobile browsers** (`set-world-0-15-35-mobile-browser-2`). A browser on a phone or tablet ends a page that uses more memory than its system allows, with no error a page can catch and no reading of memory beforehand; Safari on iOS ends one at about 100 MB on a small iPhone and 200 MB on an iPad. So on every mobile browser `/anima-scene` and `/anima-battle` place at most 8 Animas a side, one budget for all of them, and `/anima-scene` offers no **totally-random** team: each team is designed by a model or imported. A browser counts as mobile when any of these holds: its client hints (`navigator.userAgentData`, Chromium browsers) say `mobile` or name the platform Android, iOS, HarmonyOS or OpenHarmony; its user agent names, as a whole word, a phone or tablet system or browser: `iPhone`, `iPad`, `iPod`, `Android`, `Mobile`, `Mobi`, `Opera Mini`, `IEMobile`, `Windows Phone`, `WPDesktop`, `BlackBerry`, `BB10`, `PlayBook`, `webOS`, `hpwOS`, `KaiOS`, `Silk`, `Kindle`, `Symbian`, `SymbianOS`, `Series 60`, `S60`, `Nokia`, `MeeGo`, `Maemo`, `Sailfish`, `Tizen`, `HarmonyOS`, `OpenHarmony`, `ArkWeb`, `Fennec`, `Minimo` or `Tablet` (`Series 60` with or without its space, and `Tablet` never as Windows' `Tablet PC`); or it names a Macintosh on a screen with more than one touch point (an iPad asking for the desktop site). Everywhere else nothing is detected or reduced.
- **Loading.** Every piece of loading work runs through one job orchestrator: requests, held items and their motions, armor, layering, shader compiles, the floor, portraits and placements. Shared work runs once, what is on screen goes first, concurrency is bounded by slots, and no loader can spin forever: [Orchestration](https://set.world/skills/anima-orchestration).

## The contract every scene keeps

- **Real characters only in generated scenes.** The model previews use the base Anima without rolling a birth; `/anima-adventure` reads births prepared at build (the player's and its three companions' in both scenes, and Seth's in the temple) and rolls none. In a generated scene, 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, except a designed team's births, fetched together before its designer runs (`/anima-scene`, `/anima-model-teams`). 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 and none started once a frame's steps have taken 8 ms, the rest discarded, so an overloaded machine plays the same fight more slowly instead of stalling. Hidden, paused and offscreen time grants no catch-up, and a scene scrolled out of view draws nothing. 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, eyes and the author's tattoo | This skill, depth three | §15.18, §15.19, §15.22 | `avatar/liquid-metal.ts`, `avatar/model.ts`, `avatar/eyes.ts`, `avatar/tattoo.ts` |
| Body motion: idle, walk and run, jump, punch, hit, kneel, get-up, the Guard pose | [Animations](https://set.world/skills/anima-animations) | §15.7 to §15.13 | `avatar/motion.mjs`, `avatar/gait.ts`, `avatar/hit-reaction.ts` |
| Planted feet: the knockback stagger and Guard's turning steps | This skill | §15.12, §13.77 | `avatar/footing.ts`, `anima-scene/model.ts`, `anima-scene/stage.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, §13.75, §13.78 to §13.80 | `weapons/catalog.ts`, `weapons/meshes.ts`, `weapons/grip.ts`, `weapons/pole-heads.ts`, `weapons/shield.ts`, `weapons/anchor.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` |
| Heraldry: presets, image URLs, the flag and the ailettes | [Item models](https://set.world/skills/anima-item-models) | §13.52 | `@common/heraldry.ts`, `armor/emblems.ts`, `armor/body-armor.ts`, `armor/wardrobe.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, the armed hit, heavy blows, thrown weight | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.1 to §13.3, §13.8, §13.47, §13.71 | `weapons/handling.ts`, `weapons/held-mass.ts`, `weapons/impact.ts`, `weapons/heavy-blow.ts`, `weapons/thrown-weight.ts` |
| Tempo, blade aerodynamics and reach | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.22, §13.69 | `weapons/tempo.ts`, `weapons/blade-aero.ts`, `weapons/reach.ts` |
| Launch, flight, range and its level growth, reload, the range pause | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.4 to §13.8, §13.32 to §13.34, §13.71 | `weapons/range.ts`, `weapons/range-growth.ts`, `weapons/ballistics.ts`, `weapons/hand-reach.ts`, `weapons/pacing.ts` |
| Striking at an elevation: every reach counts the height between two Animas, every swing and punch turns toward a target above or below, and a floor-bound action reaches only as high as its band | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.91 | `anima-scene/elevation.ts`, `anima-scene/floor-reach.ts`, `anima-scene/strike-aim.ts`, `anima-scene/melee-probes.ts`, `anima-scene/equipment.ts` (`poseAttack`, `aimPunch`, `plan`) |
| 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/aim-pitch.ts`, `weapons/gunfire.ts`, `weapons/impact-puff.ts`, `weapons/cannon-dome.ts` |
| Whips, slings, chains, nunchaku and flail, 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, §13.78 | `weapons/flexible.ts`, `weapons/flexible-rules.ts`, `weapons/nunchaku.ts`, `weapons/whip.ts`, `weapons/sling.ts`, `weapons/sling-physics.ts`, `weapons/ballistics.ts` (the lob), `weapons/cannon-dome.ts` (its dome), `weapons/return-flight.ts`, `weapons/harpoon.ts`, `weapons/throw-tether.ts` |
| Magic: Flick, Repulse, Gaze, rings, the rupture waves, the magic charge, and CLEANSE! from a stamina-only ring (the Scroll) | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.22, §13.25, §13.72 | `weapons/magic.ts`, `weapons/magic-charge.ts`, `weapons/repulse.ts`, `anima-scene/model.ts` (`cleanse`) |
| The Tome's conjured fireballs: 2 per cast, up to 12 circling above the head, the caster standing while its target is in range, the slow volley at 12 or at 8 as the target leaves range, each fireball's dome, and the loss and cooldown when the caster is hit (`set-world-0-15-35-conjure-3`) | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.92 | `weapons/conjure.ts`, `anima-scene/equipment.ts` (`formFireball`, `unleash`, `disperse`), `anima-scene/model.ts`, `weapons/stage.ts`, `items/weapon-showcase.ts` |
| Songs: the instruments' songs to every teammate (stamina each tick, CLEANSE! as a song starts, effect resistance, less magic damage taken, attack speed), the Scroll's empowered magic damage, the player planted while it plays with notes streaming from its hand, and one note per song circling each listener's head, red for the Harp, green for the Flute, blue for the War horn (`set-world-0-15-35-songs-3`, `set-world-0-15-35-empower-1`, `set-world-0-15-35-song-notes-3`) | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.72 | `anima-scene/songs.ts`, `anima-scene/model.ts` (`sing`, `tickSongs`, `empower`), `anima-scene/equipment.ts`, `anima-scene/tactics.ts`, `anima-scene/song-notes.ts` |
| Stratagems: conditions, acts, the default and the file format | [Stratagems](https://set.world/skills/anima-stratagems) | §13.77 | `@common/stratagems.ts`, `anima-scene/stratagem-play.ts`, `anima-scene/model.ts` |
| Break: a tool breaks gear for the fight | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.86 | `weapons/break.ts`, `anima-scene/anima-system.ts`, `anima-scene/model.ts`, `armor/wardrobe.ts` |
| Stick: a pole holds its target, offhand only, until either is hit | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.87 | `weapons/stick.ts`, `weapons/catalog.ts`, `anima-scene/model.ts`, `anima-scene/equipment.ts`, `avatar/motion.mjs` |
| Disarm: a hooked blade takes the offhand | [Derived combat](https://set.world/skills/anima-derived-combat), [Stratagems](https://set.world/skills/anima-stratagems) | §13.85 | `weapons/disarm.ts`, `anima-scene/offhand.ts`, `anima-scene/model.ts` |
| Crush: a heavy blunt blow that flattens its target in place | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.84 | `weapons/crush.ts`, `weapons/point-shape.ts`, `anima-scene/model.ts`, `avatar/ragdoll.ts` |
| Pierce: a thrust that gets through and chains along its spatial contact path | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.83 | `weapons/pierce.ts`, `weapons/point-shape.ts`, `anima-scene/pierce-chain.ts`, `anima-scene/equipment.ts`, `anima-scene/model.ts`, `anima-scene/strike.ts`, `weapons/harpoon.ts` |
| Precise: a sword's chained backhand | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.82 | `weapons/precise.ts`, `weapons/point-shape.ts`, `anima-scene/equipment.ts`, `anima-scene/model.ts` |
| Shield block, the heavy-weapon block, shield bash, parry and the riposte draw (a parrying tool's natural chance, through every chance modifier) | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.73 | `weapons/block.ts`, `weapons/heavy-block.ts`, `weapons/shield-bash.ts`, `weapons/parry.ts`, `anima-scene/equipment.ts`, `anima-scene/model.ts` |
| Material weight, protection, ward, glance, hit power, stamina recovery | [Derived stats](https://set.world/skills/anima-derived-stats) | §13.70, §13.71, §13.81 | `anima-scene/anima-system.ts` |
| Levels and orbs per item | [Derived stats](https://set.world/skills/anima-derived-stats) | §13.30 | `anima-scene/generation-rules.ts`, `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` |
| Labels and floating counters: damage, MISS, BLOCK, PARRY!, RIPOSTE!, GLANCED, PRECISE!, PIERCE!, CRUSH!, DISARM!, BREAK!, STICK!, THORNS!, CLEANSE!, the status effects' words (BURNED! to EXALTED!, SHATTERED!, SURPRISE!) and their ticks in each effect's colour, Death's count above the head, Leech's `+N`, VIGILANCE! for a stopped crush, EXHAUSTED! and its ticks, heals, drains, released orbs, REPAIR! | This skill | §13.11, §13.15, §13.72 | `anima-scene/overlays.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, carried weight, blocking, patrol, moving attacks, hand choice, winded retreat | This skill | §13.19, §13.20, §13.31 to §13.33 | `weapons/carry-weight.ts`, `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 and its resolution ladder | [Viewport performance](https://set.world/skills/anima-viewport-performance) | §13.46 | `anima-scene/floor.ts`, `anima-scene/floor-surface.ts`, `anima-scene/floor-rules.ts` |
| The viewport: resizing, the drawing buffer, adaptive density, antialiasing and shadow texels | [Viewport performance](https://set.world/skills/anima-viewport-performance) | §13.67 | `common/viewport.ts`, `common/viewport-rules.ts`, `common/scene-target.ts`, `common/shadow-window.ts`, `anima-scene/stage.ts` |
| Camera, lighting, the clock | This skill | §15.20 | `anima-scene/camera.ts`, `anima-scene/stage.ts`, `avatar/stage.ts` |
| Loading: jobs shared by key, stalls, priorities, concurrency slots, barriers, idle and the idle preloader | [Orchestration](https://set.world/skills/anima-orchestration) | §16.9 | `common/orchestrator.ts`, `common/frames.ts`, `armor/cloth-pool.ts`, `common/warm-work.ts`, `@components/idle-preload.ts` |
| Randomness: the fresh fight seed and its four streams, one stream per purpose (each step's turn order among them), and the held-item measurements, hand grips and Anima body tables prepared when Set is built | [Randomness](https://set.world/skills/anima-randomness) | §6.1, §13.3, §13.28, §13.38, §13.52 | `@common/rng.ts`, `@common/prepared.ts`, `anima-scene/model.ts`, `weapons/weapon-measures.ts`, `weapons/prepared-measures.ts`, `armor/body-measures.ts`, `armor/prepared-body.ts` |
| Crowds: cloth and rigid armor pieces in workers, shadow pacing, detail tiers and mesh detail levels | This skill | §13.53, §13.67 | `armor/cloth-pool.ts`, `armor/arm-armor.ts`, `anima-scene/shadow-governor.ts`, `common/view-level.ts`, `common/detail-levels.ts`, `common/detail-geometry.ts`, `common/detail-worker.ts` |
| Dungeon mode (the turn-based fight: rounds, initiative order, the attack budget, adjacency) and the dungeon's maze | [Derived combat](https://set.world/skills/anima-derived-combat) | §14, §16.6 | `dungeon/dungeon-mode.ts`, `dungeon/dungeon-mode-rules.ts`, `dungeon/dungeon-hands.ts`, `weapons/held-profile.ts`, `dungeon/adventure.ts`, `common/dungeon-maze.ts` |
| Army battle | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.28 | `anima-scene/battle.ts` |
| The item analysis: every held item's readings at a level | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.47, §13.71 | `items/item-analysis.ts`, `items/item-analysis-rules.ts` |
| Craft stone | This skill | §16.4 | `craft-rock-stage.ts`, `common/fracture-cells.ts` |
| Portraits | This skill | §13.68, §16.5 | `avatar/character-portraits.ts`, `items/portraits.ts`, `items/rasterize.ts` |
| One dressed body that walks and attacks on request (the item inspector, the Anima Preview, each Anima of `/anima-model-teams`) | This skill | §13.57 | `items/view-stage.ts`, `items/outfit.ts`, `items/weapon-showcase.ts`, `anima-scene/team-practice-stage.ts` |
| Practice statues: the timber targets of the weapon field, `/anima-object-models` (single Anima and Group), the Anima Preview, `/anima`'s Attacking column and every Anima of `/anima-model-teams`, and their damage numbers | This skill | §13.74 | `structures/practice-statue.ts`, `structures/practice-statue-rules.ts`, `structures/beam.ts`, `structures/beam-rules.ts`, `anima-scene/team-practice.ts` |
| Practice pairs: an attacker that fights only its own practice Anima in rounds (one strike, walk home, wait), neither losing health; each cell's needed items and outcome made certain, buffs given from the start and kept, the reviving halo on every afflicted practice Anima, and the name of an effect that has no rule yet shown in light grey on every hit that lands | This skill | §13.88 | `anima-scene/status-field.ts`, `anima-scene/practice.ts`, `anima-scene/teams.ts`, `anima-scene/model.ts`, `anima-scene/equipment.ts`, `anima-scene/overlays.ts` |
| Status effects: their ticks, strength and anchored numbers, caps, speeds, damage factors, control and sides, Death's count, the rise, sure and homing strikes, charges, leech, steadfast footing, burden, float, pacifying, shock and the chance odds; the flames, particles, ice, stone, veil, faded, mirror images, rainbow and aura skins, smoke cloud, wrapped chains, shatter, halo, floor sigils, circling shields, defense orbs, piercing spikes, smoke over the eyes and the count above the head | [Derived combat](https://set.world/skills/anima-derived-combat) | §13.89, §15.13 | `anima-scene/status-effects.ts`, `anima-scene/model.ts`, `anima-scene/equipment.ts`, `anima-scene/stratagem-play.ts`, `anima-scene/teams.ts`, `anima-scene/burn-flames.ts`, `anima-scene/status-visuals.ts`, `anima-scene/status-particles.ts`, `anima-scene/status-skins.ts`, `anima-scene/status-shells.ts`, `anima-scene/status-halos.ts`, `anima-scene/status-sigils.ts`, `anima-scene/status-guards.ts`, `anima-scene/status-spikes.ts`, `anima-scene/status-blindfold.ts`, `anima-scene/status-smoke.ts`, `anima-scene/status-chains.ts`, `anima-scene/status-ice.ts`, `anima-scene/status-shatter.ts`, `anima-scene/overlays.ts`, `anima-scene/stage.ts`, `weapons/effects.ts`, `avatar/motion.mjs` |
| The item attribute reference: what every prefix, suffix and status effect gives at each item quality, the stat exchange rate across levels and the giant-slayer stat pool, how quality strengthens an effect, the stacked PETRIFIED! anchor, and how the effects are spread over the words | This skill (its build sheet) | §13.90 | `items/item-attribute-effects.ts`, `items/item-attribute-words.ts`, `items/item-attribute-reference.ts`, `@components/ItemAttributesRail.tsx` |
| Item words in a fight: the item-word receipt, its character readings (stats, speeds, health, critical, dodge, clarity, mass, glance, stamina recovery), luck in every roll, the effect contest, the two-part hit, outcome chance and damage, effects on hit and on a melee striker, buffs when struck, wounded, casting and as a fight starts, thorns, lifesteal and stamina leech, regeneration, contagion, item parry and riposte, block words, indestructible, steadiness, crush duration, magic area; and the dungeon's character readings and two-part punch | [Item attributes](https://set.world/skills/anima-item-attributes) | §13.90, §14 | `items/item-attributes.ts`, `items/item-attribute-effects.ts`, `items/item-attribute-words.ts`, `anima-scene/anima-system.ts`, `anima-scene/model.ts`, `anima-scene/equipment.ts`, `anima-scene/status-effects.ts`, `anima-scene/effect-contest.ts` (`contestChance`, `contestResistance`), `anima-scene/progression.ts` (`sceneEffectChance`), `avatar/ragdoll.ts`, `dungeon/dungeon-mode.ts`, `dungeon/adventure.ts` (`withAnimaSystem`) |
| 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, liquid-metal buttons, layout | This skill, depth three | §16.2, §16.3, §16.7 | `@common/bayer.ts`, `@common/liquid-metal.ts` |

[Algorithms](https://set.world/skills/algorithms) is the map of the reference.

## 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)). Both combat modes then apply [Derived stats](https://set.world/skills/anima-derived-stats) and every rule of [Item attributes](https://set.world/skills/anima-item-attributes).
2. **Body.** One shared template, one skeleton per actor, coloured by its traits ([Character models](https://set.world/skills/anima-character-models)).
3. **Equipment.** 2 held items and 13 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.

## Stratagems

Every Anima in `/anima-scene`, `/anima-stratagem`, `/anima-battle`, `/anima-battle-effects` and **Battle with armies** acts by a stratagem in combat: an ordered list of rules, each a condition and an act, read from the top whenever it rethinks. With combat off, or when no rule fires, it keeps its routine (below). The format, every condition and act, the reading, the default stratagem and import and export are in [Stratagems](https://set.world/skills/anima-stratagems).

## Build sheets: the home page

`https://set.world` is a sidebar of these skills beside a row of columns. Each column is a small scene. The AnimaSystem item analysis has its own page, `https://set.world/anima-analysis`, and so does the item attribute reference, `https://set.world/anima-prefixes-suffixes-effects` (both below).

### 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, one fact a row: its item quality, how much more or less of its material's bonus that quality keeps and its mass change; then each word, its archetype and its form (held, worn or any slot), one row for each effect at the item's quality, and the quality's points a word and effect strength; then each reading and its rank in rows of their own. Never join two values in one cell. The item page shows the same word reading as a full-width table (word, archetype, form, effect, one row per effect, with points a word and effect strength as its footer) under its grade.
- **Takes.** `GET /api/roll/item?seed=<seed>`, one request: the column's Seed, or a fresh one drawn in the browser when the field is blank, so the item can be shown with its seed and rolled again (an unseeded call answers `"seed": null`; [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`. Read the words from `props[0]`, `props[1]` and `props[4]` and price them through the item attributes of [`/anima-prefixes-suffixes-effects`](https://set.world/anima-prefixes-suffixes-effects); the word's mass (lighter, heavier) joins the item's.
- **Source.** `@components/GeneratorSection.tsx`, `@components/ItemPreview.tsx`, `@components/AnimaSystemItem.tsx`, `@components/ItemWords.tsx`, `@pages/roll/item/[id].tsx`.

### Roll a character

- **Shows.** A full character sheet with two sliders, **Orbs per item** and **Level**. Beside the AnimaSystem reading it shows every item's prefix and suffix, what each gives at its item's quality, and the totals: each effect, when it acts (always, every hit, mainhand or offhand hits, struck, struck in melee, the fight's start, wounded, casting, a foe falling), summed over every item, and the share from wisdom, perception, resolve and luck; stats an item word moves say so under their rows. Each derived attribute shows its value over the steps that built it, each with the value after it: the formula, the stats, the level ceiling, the words' stat points, the words' percentages and points, armor, worn weight, stamina recovery and each hand's hit. Effect chance and effect resistance, the two sides of every status contest, follow the same way. Seed and content version sit on two lines of the top bar of the character page. The words and their prices are at `https://set.world/anima-prefixes-suffixes-effects`.
- **Takes.** `GET /api/roll/character?seed=<seed>`, one request: the column's Seed, or a fresh one drawn in the browser when the field is blank.
- **Build it.** Render the birth as returned, and build its AnimaSystem reading with the birth's final stats, so the item words and the secondary-stat readings show on a raw birth too. 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, and, when a member's gear carries a prefix or suffix, one line with how many words it wears and the stat points they add.
- **Takes.** One `GET /api/roll/character?seed=deriveSeed(seed, i)` per member, in order, on the column's seed or a fresh one ([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`, `@components/CharacterWords.tsx`.

### Adventure mode with party

- **Shows.** A first-person maze with a minimap and the party's cards. The party walks on its own, stops at an enemy it faces and fights in Dungeon mode. Every card's and each enemy header's bars run against the character's attributes with its AnimaSystem readings applied (armor, worn weight and item words), the numbers the fight uses.
- **Takes.** The party's births from the column beside it, then one request for each enemy of up to 6 encounters of 1 to 3 enemies, 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.6).
  2. Stand an encounter just past a corner of that route, at least 5 route steps apart, up to 6. Each is a group of 1 to 3 enemies, its size drawn from the dungeon's seed, standing together in the cell: one in the middle, the others to either side a little deeper.
  3. When the party faces a living enemy from the next cell, start an encounter with every living enemy of its group. The fight is Dungeon mode, the turn-based half of [Derived combat](https://set.world/skills/anima-derived-combat) (`set-world-0-15-35-dungeon-mode-3`, presented under `set-world-0-15-35-dungeon-initiative-4`), which lists the steps under Adventure mode with party.
  4. Show each turn over 1.1 seconds and reveal its first attack at 0.36, each later attack 0.42 seconds after the one before, the turn lengthened by the same; each attack's counters and the bars move as it is revealed. These are presentation times: the fight's clock is its rounds, and on screen they restore no stamina.
  5. Give only enemies a body: Anima in its generated outfit, holding both generated items, each attack played with the hand that made it. The party stays off-camera: its cards' counters and bars show what it does.
  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.
  7. Hold the maze still until the party's cards show their faces: the walk starts once every member's portrait has been drawn or has failed, so the first fight never plays beside empty frames. The wait is an orchestrator barrier over the party's portraits, so a portrait that makes no progress is given up on and the wait always ends ([Orchestration](https://set.world/skills/anima-orchestration)).
- **Controls.** Play and Pause, Next turn while a paused fight waits, Replay adventure, Retry encounters when an enemy's request has failed, and Reload scene when the 3D view has fallen back to the map. Arrow keys or W A S D move and turn outside combat; Space plays and pauses, and Enter takes a paused fight's next turn.
- **Limits.** No rewards, progression, stratagems or talents; no positions, so nothing moves in a fight, and enemies show no status or fireball visuals beyond their counters.
- **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.4). Lock one operation from the stone's preparation to the response: the craft waits on the stone's own preparation job by its key, and the request is a job that ends if it makes no progress for 30 seconds. Show the card under the stone only after it has painted. The fall is a job that ends when the last piece lands, or after 7 seconds without progress, when the card is shown anyway ([Orchestration](https://set.world/skills/anima-orchestration)). 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.
- **Controls.** **Orbs used** (125 by default, up to 15,625) and an optional seed. **Craft an item** becomes **Recycle and Reforge** once a card shows: a fresh stone, then one request, on a fresh seed unless a different seed was typed in the field (a typed seed replays its craft). A click on the stone crafts on that stone; the card's **Recycle** covers the card with a fresh stone and sends no request.
- **Limits.** No wallet, refund or inventory. A failed craft keeps the previous card.
- **Card.** The result card is the item card of **Roll an item**, word reading included, so a craft that buys a rarer quality or a chosen word shows what it does.
- **Source.** `@components/CraftingSection.tsx`, `@components/CraftRock.tsx`, `@components/MarbleToneFilter.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 whose bars run against the AnimaSystem attributes the scene gives that Anima (item words included).
- **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, including its equipment contact paths and Pierce continuation protocol. The column adds only its staging: opposite formations, 4 to a row, a board revealed once everyone is equipped, every soldier asked for as soon as its birth arrives and dressed through the orchestrator's `dressing` slots, as many at once as the machine has cloth workers, behind anything visible on the page and behind everything while the column is off screen (the next starts the moment one is done; [Orchestration](https://set.world/skills/anima-orchestration)), combat released by a barrier over every soldier, while each joins the fight in its roster order, so the same characters and fight seed replay the same battle, 4 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 or guarding 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, in **Adventure mode with party**, its roster's portraits at once), and caches them (§16.5). Each still is a `visible` job, so its armor goes before any scene's, and a still that stops making progress is drawn again in a fresh renderer, then shown as failed ([Orchestration](https://set.world/skills/anima-orchestration)).
- **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 and dress one body by the hand and layer rules of [Item models](https://set.world/skills/anima-item-models). **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 (Shift and drag to pan), Zoom out, Zoom in, Fit, Start and Stop attack, Start and Stop walking. It opens at 1.5× the `/anima-object-models` Anima pane's framing, and Fit returns to that opening view.
- **Limits.** A model preview, the same stage as the Anima pane of `/anima-object-models`, except that actions play at this character's own tempo: its derived attributes with AnimaSystem applied ([Derived stats](https://set.world/skills/anima-derived-stats)), and each held item's mass with its item quality. 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, after the left-hand item is dropped on the mat.
  3. Dress every preview in the same outfit and heraldry 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. When a held item is not melee, stand one timber practice statue straight ahead at that item's range (as in the `/anima-object-models` Group, below), aim every shot at its crossbar, and frame the Anima and the statue together.
  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, with whatever the preview wears and holds; Attacking exports the unarmed punch.
- **Controls.** Play and Pause, Replay, turn controls, Full body and Face on the two idle previews, Color and Grayscale on Base avatar, and one control per motion: Walk to run, Jump height, Hits per minute with a direction (All 8 sides or one side), Walk while holding.
- **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.
- **Fetch.** A fetch returns the sidebars only; every preview, motion and download needs a browser ([Character models](https://set.world/skills/anima-character-models) and [Animations](https://set.world/skills/anima-animations) give the browser steps).
- **Source.** `@pages/anima.tsx`, `@components/CharacterAvatar.tsx`, `@components/ItemSidebars.tsx`, `avatar/`.

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

- **Shows.** One Anima for each of the 155 mainhands, holding its tool on the shared floor and playing its action, with the worn-slot sidebars dressing every Anima alike, in the sidebar's heraldry.
- **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, in the white body palette, 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. Stand a timber practice statue in front of each Anima: a square post as tall as the door shield with a crossbar through its middle, 5 board squares out for ranged and wave items (closer when the item cannot carry that far), for melee where its stroke, measured as it plays, first touches nearest the crossbar's centre (the Anima turned on its root so a stroke held beside the line, a spear, a bash or a twirl, meets it), and inside the ring for auras ([Algorithms](https://set.world/algorithms) §13.74). A melee hit counts only where the drawn tool touches the statue, and every rope aims at the crossbar. Space the cells 1.5 weapon cells apart so each statue stays in its Anima's cell.
  5. Run each action's delivery with the scene-based rules: melee contact, projectiles with their flight and reload, rings, cones and waves, all aimed at the statue's crossbar. Each hit on the statue shows its undefended damage above it, the nunchaku and drill once per mark of their volleys; the Scroll's ring shows the stamina it restores in blue, and an instrument (its song reaches only teammates, and the statue is none), Gaze, Pound and the ruptures show no number. The Tome gathers 2 fireballs each cast in a ring above the Anima's head and, at 12, sends them all slowly at the statue, each showing its hit and bursting in a dome. Nothing takes damage.
  6. Pickup, drag and flick any Anima; it lands, gets up, walks back to its cell and resumes.
- **Controls.** Start, Stop, Unique (one Anima per distinct action), Dual wield (the same tool in both hands, alternating complete right and left actions, re-ranked by dual-wield speed) and Elevate: every statue's post grows by its own height, lifting the crossbar to an elevation, and each statue moves to where the Anima's stroke, measured as it plays, or its flight meets the raised crossbar ([Algorithms](https://set.world/algorithms) §13.74, §13.91). An Anima that cannot hit its statue, raised or not, kneels instead of attacking; only the raised cross is a target (the pole beneath it stops a shot but counts nothing), a melee hit counts only where the angled-up weapon touches the cross, shots aim at it, and floor-bound actions (the Cane's Missile, rings, Flick and rupture waves, Gaze and Pound) cannot reach it, so those Animas kneel too.
- **Limits.** No combat, roll or request.
- **Fetch.** A fetch returns the sidebars only; the field runs in a browser. Every number it shows is a held-item reading of [Derived combat](https://set.world/skills/anima-derived-combat).
- **Source.** `@pages/anima-all-weapons.tsx`, `@components/AnimaWeapons.tsx`, `weapons/stage.ts`, `weapons/`.

## Build sheet: `/anima-scene`

The fullest scene: every scene-based mechanic in the table above runs here. Its equipment gathers Pierce candidates from the actual weapon sweeps and Harpoon flight; the model and shared strike resolver run the [Pierce path protocol](https://set.world/skills/anima-derived-combat), preserving one ledger per attack and feeding the landed result back to the delivery. Place real characters one at a time, or place two teams, each built by **totally-random**, designed by a model or imported from a battle file, and press Start to watch them fight.

- **Takes.** One `GET /api/roll/character` per placed Anima, on `deriveSeed(base, index)`, each stopped if it makes no progress for 30 seconds, with a retry that keeps the job's seed and place: a neutral, random or imported Anima's one in flight at a time, a designed team's 16 together, before its designer runs.
- **Controls.** **Place Random Anima** queues one neutral Anima near the centre of the mat, each at the next point of a golden-angle spiral that grows outward, point `n` at `1.5 × √n` units from the centre, so none lands on another, with the random growth and reforge of [Derived stats](https://set.world/skills/anima-derived-stats); clicking the floor places nothing. Each team has its own column in the bar, a select and an **Import team** button side by side above its **Place Team A** or **Place Team B** button, after which come **Place WorldSphere**, **Place Random Anima**, **Stop** and **Clear**, with **Start Battle!** in red at the right end of the bar; the select names who builds that team: **totally-random**, the same chance-based path every neutral Anima takes, a model (`claude-opus-5-5`, `claude-fable-5-1`, `gpt-6-astra`, `claude-sonnet-5-5`, `claude-haiku-4-5-20251001`, `claude-haiku-5-5`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.6-sol`, `gpt-5.6-terra` and `gpt-5.6-luna`), or a team imported with **Import team** (below). Each button queues 16 (8 on a mobile browser, above: a model's designer still designs all 16 from 16 births and its first 8 take the floor), built as its select says when pressed, once per team until Clear; a mobile browser's selects offer no **totally-random** (above), and one left on it builds Team A with the first model and Team B with the second. **Level** (1 to 99) and **Orbs per item** (0 to 15,625) are captured when a job is queued and never change placed actors. **Place WorldSphere** places a sphere; **Start Battle!** turns combat on and **Stop** turns it off, and placing never starts a fight; **Clear** removes everything and turns combat off. Space on the focused scene pauses and resumes; shadows, health and team labels and every counter always show.
- **Counters.** A hit shows the health it removed (a magic hit's in pink), a dodge MISS and a shield BLOCK in grey, a critical `CRITICAL!` above its red number; a heal is a green `+N`, stamina restored a blue `+N` (a song's on every listener at each of its ticks), stamina drained a violet `N`, and a fallen Anima's released orbs a gold `+N orbs` ([Derived stats](https://set.world/skills/anima-derived-stats)), a thorns word's prick its damage on the striker under `THORNS!` ([Item attributes](https://set.world/skills/anima-item-attributes)), and a stamina ring that ends the debuffs on an Anima `CLEANSE!` above it ([Derived combat](https://set.world/skills/anima-derived-combat)). Counters that land on one Anima together start stacked so each can be read, and a nunchaku volley's rise 2× slower and a drill volley's 2.4× ([Derived combat](https://set.world/skills/anima-derived-combat)).

### Designed teams

A model's designer is code it wrote once (`set-world-0-15-35-team-design-2`): it reads the 16 random births at the chosen level and orbs per item and returns the whole team, with no model called while the page runs. Each designer is a pure function, so the same births and settings always give the same team. Each team is designed at the level and orbs per item the sliders hold when its button is pressed, and neither designer sees the other's team.

- **Stays random.** Each birth's base stats, advantages, disadvantages and talents.
- **The designer decides.** Which birth stands at each formation place, front row first; each Anima's role name (at most 24 characters; designers name each role for the class its mainhand gives it, [Classes](https://set.world/skills/character-classes)); every item each Anima carries and wears: any gear of the slot (the mainhand sets the class), any material of a grade the orbs buy, any quality the orbs buy, and any prefix and suffix, or none ([Item attributes](https://set.world/skills/anima-item-attributes)); how the level's stat points (3 per level after the first) split among the 5 primaries, in whole grants of 0.25, spent exactly; and each Anima's own stratagem, at most 24 rules ([Stratagems](https://set.world/skills/anima-stratagems)).
- **What the orbs buy.** A material grade whose crafting price is within the orbs per item ([Crafting an item](https://set.world/skills/crafting-an-item)), the lowest grade always; and the best quality the lottery's candidates for those orbs reach at least 50% of the time, with every worse one (§13.30 in [Algorithms](https://set.world/skills/algorithms)). From each amount of orbs on:

| Orbs per item | Best grade | Best quality |
| ---: | --- | --- |
| 0 | F | Plain |
| 5 | E | Plain |
| 25 | D | Plain |
| 53 | D | Fine |
| 125 | C | Fine |
| 133 | C | Refined |
| 625 | B | Refined |
| 752 | B | Superior |
| 1,798 | B | Exceptional |
| 3,125 | A | Exceptional |
| 5,540 | A | Perfected |
| 15,625 | S | Perfected |

- **Heraldry.** A designed team carries its model's maker's heraldry on its flags and ailettes; a totally-random team, like every neutral Anima, carries the default, `usa`.
- **Receipt.** Each member's `generation.design` holds the model, the designer's version, the rules version, its role and its growth, beside the untouched birth in `generation.source`.

The designers, each with its own summary of the team it built and why that team is the best it could make (`/anima-model-teams`, below, shows each team at practice beside that summary and the designer's full rationale):

- **`claude-opus-5-5`** (`claude-opus-5-5-team-5`). Pierce through everything. Every weapon on the team can PIERCE!, the one result no dodge, glance, armor or global resistance stops, and the words stack the rest onto it: pierce chance to its cap and pierce damage to its cap, so a landed pierce strikes for about two and a half base hits whole, and critical damage words make a critical pierce worth several more. Eight Dialecticians hold the front two rows with a jian and a kite shield whose block words climb to their cap as the orbs allow; eight Whalers stand behind with a harpoon, the item most likely of all to pierce, which can drag what it hits into the front line, and a jian for anything that gets close. What the opponent cannot take away comes next: words raise effect resistance to the contest ceiling, so no status lands, and the rest buy buffs gained when struck, which nothing resists: VIGILANCE, so a hit does not cancel a thrust, FRENZY, STALKING and stamina. Every word is chosen by its value against its real cap at the quality the orbs buy, and growth balances damage, critical chance and health.
- **`claude-fable-5-1`** (`claude-fable-5-1-team-2`). Pierce what cannot be worn down, and floor what cannot be pierced. Every member first grows the stats that multiply together (vitality, for health and the reductions that compound toward their ceiling, then its own damage stat, by a greedy search over the scene readings), then spends its words on effect resistance until no disabling word can land at these settings, and only then on its kit, each word chosen by what it grants. Two maul Siegebreakers and two sarissa Phalanxes hold the front behind heater shields, two more Phalanxes and four Wizards stand in the two rows behind, and a Wizard carries a tome whose Rupture ring knocks every foe within it flat and a sarissa in the other hand, so the pikes thrust over the shields at tumbling bodies that cannot block or parry a pierce that ignores every reduction, with outcome damage stacked on the pierce. Four crossbow Bounty Hunters focus the weakest foe from the back rows and draw a rapier up close, and two flute Cantors play rings that heal and refill the stamina of the whole formation, so the slow heavy thrusts never run dry. Vigilance when struck keeps thrusts and casts from being interrupted; every fighter but a Cantor guards below thirty percent health, and a Cantor runs from whoever targets it and keeps playing.
- **`gpt-6-astra`** (`gpt-6-astra-team-2`). Four shield-and-rapier wardens screen four riflemen and four wave casters, with two healers and two Scroll bearers sustaining the formation. Shared targets concentrate damage; vigilance, resistance and recovery preserve the ability to act, while physical volleys and magic waves offer different answers to defenses. Births take the roles their reconciled stats suit, growth balances each role’s damage and survival, and affordable materials and item words are chosen by their readings with diminishing returns rather than fixed shopping lists.
- **`claude-sonnet-5-5`** (`claude-sonnet-5-5-team-1`). Four Peacekeepers (tonfa and pavise) hold the front rank, four Assassins (katar and buckler) the second, two Archers (longbow) flanking two Fencers (rapier) the third and four Cantors (flute and scroll) the back, all dressed in the best material and quality the orbs buy and flying the heraldic flag and ailettes of Anthropic. Each member's stat points and thirty item words are searched against one valuation of its own role: the wall grows toward vitality and agility and wears block, parry, protection and regeneration; the Assassins and Fencers grow strength and dexterity and carry damage words to the cap, with the rapier piercing what armour is left; the Archers shoot from behind the wall; the Cantors' rings heal the team and refill its stamina; and the words they wear give them a chance of Vigilance, so a hit does not break the action they are in. The team is built to win without its opponent's help: the wall is hard to hurt and hard to stagger, the strikers hit fast and keep hitting, and the choir keeps both fed, so the fight stays in the team's own rhythm whatever the other side brings.
- **`claude-haiku-4-5-20251001`** (`claude-haiku-4-5-20251001-team-1`). A balanced formation of four frontline shield-bearers, four mid-row fighters and casters, and eight backline ranged and support members. Every Anima grows the primary stats that multiply its role power: frontline prioritizes vitality and strength for durability, melee fighters emphasize strength with vitality, casters invest intelligence with vitality, ranged members focus dexterity and agility, and support chooses intelligence and vitality. Each role uses equipment suited to its purpose: longswords and heater shields for the front, hatchets for mid-range melee, staffs for casting, bows for ranged, and flutes for healing. Item words are chosen for each role specific needs: frontline wants reduction and blocks, melee wants damage and lifesteal, casters want spell power and area, ranged wants speed and critical effects, and support wants healing output. The team wins through layered defense, consistent damage from multiple ranges, and mutual support among members.
- **`claude-haiku-5-5`** (`claude-haiku-5-5-team-1`). A wall of four plated front-liners holds the first row: two longswords behind a heater and a shield, a spear behind a kite shield, and a halberd behind a pavise, all in heavy armour and weighted toward vitality and strength. Behind them stand four light melee fighters, a katana, a saber, a maul behind a targe, and a katar with a kris, that strike whichever foe the wall has engaged. Two healers in the middle play a harp and a flute, and a staff and a flute, mending allies who are hurt or debuffed and stepping back when struck. Two casters, a tome with a grimoire and a rod with an orb, cast from behind them. Four archers close the formation, a longbow, an arbalest with a buckler, a crossbow and a shortbow, keeping their distance from the foe and fighting with knives or daggers only when caught. Every member carries the highest material and item quality its orbs buy and the prefix and suffix that lift its family the most, so the wall protects the archers, the archers thin the foe, and the healers keep the wall standing.
- **`gpt-6-sol`** (`gpt-6-sol-team-1`). Four shielded melee Animas hold the front while a second rank of rupture, wave and gaze casters interrupts the opposing line. Five ranged attackers press exposed and shared targets; three rear supporters keep health, stamina and cleansing rings moving through the formation. Births are assigned to the jobs their stats suit, then every member receives affordable high quality gear, role-weighted growth, capped item-word gains and a stratagem for its own position. The line, control and recovery keep pressure on an unseen sixteen-member opponent through both short and long fights.
- **`gpt-6-luna`** (`gpt-6-luna-team-1`). Four pike-bearing shield wardens take the front row and turn close pressure into long-reach strikes, backed by eight ballistae and four rifles that keep heavy ranged hits arriving across the field. Every rear fighter carries a war horn to heal the most wounded ally, while the chosen words favor disabling effects on landed hits and the armor favors physical protection and ward; births with the strongest physical foundations take the heaviest posts, and each grows toward damage, protection, and effect resistance.
- **`gpt-5.6-sol`** (`gpt-5-6-sol-team-1`). Four Bulwarks hold the front under shields, four Lancers strike through them, two Alchemists and two Sharpshooters break clusters and finish exposed foes from the third rank, and two Minstrels, a Wizard and a Scrollmaster heal, restore stamina and repeatedly knock threats down from the rear. Every birth is assigned to the place that best fits its native stats, then its growth, materials, quality, affixes and individual stratagem reinforce that duty, giving the formation layered protection, control, ranged pressure and recovery against an opponent it cannot know in advance.
- **`gpt-5.6-terra`** (`gpt-5-6-terra-team-1`). A four-rank OpenAI host: Bulwarks with shield and door protect the injured at the front, Dragoons with pike and targe strike through the line behind them, paired Arbalestiers lock down distant targets with disabling bolts, and paired-wand Witches kite from the rear with separate shock, blind, poison and burn pressures. Every Anima wears its strongest permitted construction and a complete all-stat vestment, while its level growth and birth are matched to the work it must do, creating a formation that can absorb a charge, control its contact, and punish every range of an unseen opponent.
- **`gpt-5.6-luna`** (`gpt-5-6-luna-team-1`). Four shielded Animas hold the front and protect the approach, four melee fighters punish anything that reaches them, four ranged Animas keep pressure across the field, and four support casters sustain the formation while applying control. Births are assigned to the family their stats suit, every member grows toward its duty, and every hand and garment carries a purposeful material, quality, prefix and suffix so the formation stays cohesive at every shared level and orb setting.

### Imported teams

A team built by hand on `/anima-battle` plays here too: a battle team holds 16 Animas, the size of a scene team (16).

- **Import.** **Import team** reads a battle file, the file **Export battle** saves (its schema is under `/anima-battle`, below). Each of the file's teams that holds an Anima becomes a choice in both selects, named for the file's `name`, or its file name, and the team (`anima-battle.battle.json (Team A)`); the pressed team's select takes the file's team of the same key, or the other one when that is empty. Importing a file of the same name again replaces its choices. A file the battle page would refuse is refused here whole, with the Anima and the reason, and nothing changes.
- **Place it.** Place Team queues 16 Animas as for a random team, one birth at a time. Member `i` stands at formation place `i`, front row first, and is the file's Anima `i`: its birth grows to the **Level** slider's level with no orbs ([Derived stats](https://set.world/skills/anima-derived-stats)); **Orbs per item** and the file's own `level` are not read. It then wears exactly the file's outfit, as on `/anima-battle`: each item's gear, material (steel when none), quality, prefix and suffix, and no other item; it carries the file's heraldry, or `usa` when the file gives none, and acts by its own stratagem; its class follows the file's mainhand ([Classes](https://set.world/skills/character-classes)), or stays the birth's when it holds none. An Anima the file leaves out stands with no items and the default stratagem.
- **Stays random.** Each birth's base stats, advantages, disadvantages and talents, and its level growth, as for a random team.
- **Limits.** Nothing is exported from the scene, and Clear keeps the imported choices until the page is left.

### Allegiance and targets

- Team A fights Team B and neutrals; Team B fights Team A and neutrals; neutrals never fight each other. Two status effects change sides for a while: a SEDUCED! Anima fights for its seducer's team and every Anima treats it as a foe, and a hysterical one may turn on a friend ([Stratagems](https://set.world/skills/anima-stratagems), [Derived combat](https://set.world/skills/anima-derived-combat)).
- One rule decides who may be attacked, for sight, punches, weapon contacts, every projectile, ray and wave, every magic effect that harms or moves (Flick, Repulse, Gaze, Pound, Missile, Cross-rupture, Tri-rupture, the Tome's fireballs) and every tether, so an ally never takes a hit, a drain or a pull. The Scroll's stamina ring includes everyone inside it; a song reaches only the player's own team ([Derived combat](https://set.world/skills/anima-derived-combat)).
- Dead, falling, held, landing and still-dressing Animas cannot be attacked, except one staggered by combat (a rupture wave's pull, a blast's knockdown or a Javelin knock): it stays a target for every delivery but a tether until it lands (no harpoon or tether latches onto it), and a hit on it pushes its ragdoll.
- Team identity is on the label and on the heraldic items, never in the body colour: every Anima keeps its trait colour, and a flag or ailettes show its team's heraldry: a designed team's maker's, and the default `usa` for a totally-random team and every neutral Anima (above) ([Item models](https://set.world/skills/anima-item-models)).

### Routine

- Each Anima follows one directive at a time: fetch a WorldSphere, retrieve its dropped offhand, engage a foe, assist an ally, run from a foe, back away from a foe, charge a foe, advance on a foe behind a shield, lunge at a foe, keep a foe at range, hold ground, protect an ally, guard, follow, patrol, hold its station, return, or idle; a status effect can impose three more: avoid a foe (SCARED!), run in a circle or cower (HYSTERIA!). In combat its stratagem chooses (above). A committed attack, throw, pickup or hurt reaction finishes first.
- **Combat off (before Start, after Stop).** 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. Team B's grid is Team A's turned half a circle about the centre, never reflected across it: every Anima is right-handed, so turned, member `i` stands on the same hand of its own formation on both sides and two teams of one layout meet alike.
- **Combat on (after Start).** Everyone runs and follows its stratagem: a designed team member its designer's, an imported member its file's, every other Anima the default ([Stratagems](https://set.world/skills/anima-stratagems)). 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.
- **Moving.** Walk and run blend over 0.65 seconds without resetting the stride. Running at full pace costs 5 stamina a second ([Derived combat](https://set.world/skills/anima-derived-combat)); walking costs nothing. Attacks can start and finish while moving; kneeling shots plant the shooter, and an instrument plants its player while it plays.

### Bodies

- Living Animas block movement and cannot be shoved; knockback cannot pass through a body. Corpses stay solid and pushable.
- Nothing an Anima does hides it: attacking, charging, reloading, casting, guarding or reeling from a hit, it can be hit. What a hit cancels and how long it recovers are in [Derived combat](https://set.world/skills/anima-derived-combat); a guarding Anima's exception is in [Stratagems](https://set.world/skills/anima-stratagems).
- **Knockback is a stagger.** The pushed Anima's feet stay planted on the floor while its body is driven back, then step after it, one foot and then the other, in quick catch-up steps until it stands where the push left it (`set-world-0-15-35-hit-stagger-1`, `set-world-0-15-35-footing-1`). It never steps forward again to where it was struck, and the brief upper-body recoil never lifts it off the floor (§15.12 in [Algorithms](https://set.world/skills/algorithms)). Guard's feet step the same way as it turns.
- Hits land on the whole Anima: one vertical capsule from the floor to the top of the head, plus its posed limbs, torso and head as the simulation step poses them (never as a frame draws them), so a kneeling, leaning or reaching Anima is hit wherever its body is. Held items are not targets. A MISS counter means a dodge (the defender's dodge rate, cut by the attacker's clarity) or a punch that found no body; a weapon that passes by shows nothing.
- Death captures the pose into a ragdoll of 16 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 (with combat on, a neutral rejoins the fight at once when its stratagem names an Anima); a dead one stays down. A held Anima takes no attack and runs no routine.
- A rupture wave, a blast's dome and a landed Javelin throw a living target into a short ragdoll tumble along the hit. It is staggered, not out of the fight: only death makes its attackers stop.

### WorldSpheres

- Only Place WorldSphere creates one: a large, luminous blue fireball at the scene center, distinct from the item Orb. A scene holds one at a time: placing another removes the first, from the ground, the air or a hand.
- A sphere on the ground gathers the dead. Every corpse that has come to rest farther than 2 units from it is hauled toward it by the chest, at 4 units a second, and let go once it lies within 2 units. Animas that fall later are gathered once they settle, and when a thrown sphere lands, the dead follow it. The haul stops if the sphere is picked up or replaced, and a corpse you pick up is yours until you let it go. Corpses stay pushable, so a gathered pile never walls the sphere off.
- The sphere absorbs the dead. A corpse at rest within 2 units of it, on the ground or in an Anima's hands, dissolves into it over 1.2 seconds, armor and items too, and leaves the scene. An Anima carrying the sphere on patrol absorbs the dead it passes. It is cosmetic and keeps the board clear.
- With combat on, the default stratagem picks a sphere up only when it lies within the Anima's own melee range. A carrier lobs it at an opponent in range for a fixed 1000 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. Every drop (a sphere, a disarm, sleep, hysteria) starts where the hand holds the item in a pose made from the simulation alone at that step, never from a drawn frame, so where it lands is the same on every display and from every camera.

### Crowds

Cloth solves in workers and freezes outside the view. An Anima whose bounds, widened by 1.5 of its heights for held items, lunges and mirror images, lie outside both the view and the key light's shadow window keeps simulating but is not posed; anything that reads its body (a hit on its limbs, a ragdoll, a recoil, a change of mode) poses it first, and it shows its current pose on its first frame back in view. Purely visual physics, the shadow map's redraw rate and worn geometry finer than a pixel scale down as Animas get small on screen, and the drawing buffer, antialiasing, shadow texels and floor texture follow the screen ([Viewport performance](https://set.world/skills/anima-viewport-performance); §13.53, §13.67; the detail rule is in [Item models](https://set.world/skills/anima-item-models)).

- **Link.** `?teamA=<model id>&level=<level>&orbsPerItem=<orbs>` opens the scene with that designer chosen for Team A and both sliders set; an unknown designer or a refused pair is ignored, Team B's select is left as it is, and nothing is placed until a button is pressed.
- **Fetch.** A fetch returns the controls, the designers' model ids (`props.pageProps.teamModels` in the page's `__NEXT_DATA__`) and their description; the designs and the fight run in a browser. Build from this sheet and [Derived combat](https://set.world/skills/anima-derived-combat).
- **Source.** `@pages/anima-scene.tsx`, `@components/AnimaScene.tsx`, `anima-scene/team-design.ts` (the designer contract and offers), `anima-scene/team-constructors/` (one designer per model, and the catalog), `anima-scene/generation.ts` (the random, designed and imported preparations), `@common/battle.ts` (the battle file an imported team is read from), `anima-scene/stratagem.ts` (how an imported member is dressed), `anima-scene/mobile-browser.ts` (the mobile budget), `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: `/anima-stratagem`

Two Animas outfitted side by side, then a duel between them.

- **Shows.** Above, Anima A in the black body palette and Anima B in the white, each in its own Anima pane like `/anima-object-models` but closer, headed only `Anima A` or `Anima B` (no item list), and without its buttons (drag to turn, Shift and drag to pan, scroll to zoom), each dressed from its own two sidebars: A's catalog and materials on the left, B's materials and catalog on the right. Below, a duel floor like `/anima-scene` with the two of them facing each other, A on the left and B on the right, 13 world units apart, framed by each Anima's two stratagem columns, lined up with the sidebars above.
- **Takes.** The answer of one `GET /api/roll/character?seed=20261007`. Set's page reads that answer from the births prepared at build ([Randomness](https://set.world/skills/anima-randomness)) and makes the request only when they cannot answer; a replica may simply make it, once, stopped if it makes no progress for 30 seconds. That one birth is both Animas' body, so only the outfits differ.
- **Build it.**
  1. Read each side's selection from its own query parameters: the `/anima-object-models` parameters with an `a.` or `b.` prefix (`a.tool=<gear>&a.toolMaterial=<material>&a.focus=tool&b.chest=<gear>&b.heraldry=vmax`). A link on one side keeps the other side's parameters. With no parameters at all, A holds a sword and B a spear.
  2. Build each Anima's equipment from the birth: every chosen item takes the birth's item in that slot and replaces its gear, its material (steel when none is chosen) and its quality, prefix and suffix (the chosen ones, or Plain with neither when none is chosen, so no word comes from the birth); an unchosen slot is empty, so an Anima with no mainhand fights barehanded. A gauntlet or ring worn on one side fills only that side ([Item models](https://set.world/skills/anima-item-models)).
  3. Place A as Team A and B as Team B, each with its own stratagem and, when its sidebar has one, its own heraldry in place of its team's, and run the `/anima-scene` rules unchanged: AnimaSystem from the worn and held items, their words included ([Item attributes](https://set.world/skills/anima-item-attributes)), scene-based combat, counters, ragdolls and pickup ([Derived combat](https://set.world/skills/anima-derived-combat)). Changing either outfit places both again (`set-world-0-15-35-anima-stratagem-2`).
- **Controls.** **Start** turns combat on and begins the duel; **Stop** turns it off, and both walk back to their places, ready for Start again; **Reset** places both again at full health with combat off; **Reset Stratagems** returns both sides to the default stratagem and keeps their outfits. Beside the buttons the bar shows only the frame rate. The floor keeps `/anima-scene`'s camera angle, pause and pickup, starting 2.67× as close as that scene's and at the lowest camera tilt the orbit allows; a click adds no Anima.
- **Stratagems.** Below each side's item sidebars, two columns: on the left the acts and the conditions grouped by side (Self, Ally, Foe; each side's `status = …` conditions close its group), on the right the Anima's stratagem, numbered in the order it is read. A condition adds a rule with the focused rule's act (Mainhand when there is none) and focuses it; an act changes the focused rule; a rule focuses when chosen; its ↑ and ↓ move it one place up or down (the order it is read in), and its X removes it. **Import** reads a stratagem file, rules and outfit, and **Export** saves `anima-a.stratagem.json` or `anima-b.stratagem.json` with both ([Stratagems](https://set.world/skills/anima-stratagems)). Each side's rules live in its query as `a.stratagem` or `b.stratagem`, with the focused rule as `a.rule` or `b.rule`; the default stratagem leaves no parameter. A stratagem change reaches the duel at once, without placing the Animas again. While the duel runs, the rule deciding what each Anima does is shown in red.
- **Limits.** Two Animas, level 1, no orbs.
- **Fetch.** A fetch returns the sidebars and both default stratagems; the duel runs in a browser. The stratagem itself is [Stratagems](https://set.world/skills/anima-stratagems).
- **Source.** `@pages/anima-stratagem.tsx`, `@components/AnimaStratagem.tsx`, `@components/StratagemDuel.tsx`, `@components/scene-host.ts`, `@components/StratagemSidebars.tsx`, `@components/ItemSidebars.tsx`, `@common/item-models.ts`, `@common/stratagem.ts`, `@common/stratagems.ts`, `anima-scene/stratagem.ts`.

## Build sheet: `/anima-battle`

Two teams of Animas on one battleground, each Anima outfitted and given its own stratagem, and the whole battle saved or loaded as one file.

- **Shows.** One floor like `/anima-scene`, between two columns per side. Team A's 16 Animas stand on the left in the black body palette and Team B's on the right in the white, each team in rows of 4: the front rows 16 world units apart, each further row 3.6 further back, and the Animas 3.6 apart along a row, Team B's places Team A's turned half a circle about the centre, as on `/anima-scene`. Every Anima's label reads its team and its number, `A:1` to `B:16`. Each side edits a selection of its team: a roster row, `[ALL]` and then its units (`A:1 A:2 …`), under it the catalog and materials (Team B's mirrored) and under those the two stratagem columns, both showing the most recently added Anima of the selection. Nothing on the floor marks the selection.
- **Takes.** The answer of one `GET /api/roll/character?seed=20261007`. Set's page reads that answer from the births prepared at build ([Randomness](https://set.world/skills/anima-randomness)) and makes the request only when they cannot answer; a replica may simply make it, once, stopped if it makes no progress for 30 seconds. That one birth is every Anima's body, so only the outfits differ. The **Level** slider in the bar grows that birth to the chosen level with the `/anima-scene` rules and no orbs (`prepareSceneCharacter`, [Derived stats](https://set.world/skills/anima-derived-stats)), so every Anima fights at it, and each label shows `LVL n`; once the slider rests for 400 ms every Anima is placed again.
- **Build it.**
  1. Read each Anima's selection from its own query parameters: the `/anima-object-models` parameters with its key as a prefix, `a1.` to `a16.` and `b1.` to `b16.` (`a3.tool=<gear>&a3.toolMaterial=<material>&b1.heraldry=vmax`), its stratagem as `a3.stratagem` and its focused rule as `a3.rule`, as on `/anima-stratagem`. Each team's selection is `a.select` or `b.select`, a comma-separated list of unit numbers in the order they were added, the last being the one the sidebars show (just `1` leaves no parameter). With no parameters at all, every Anima of Team A holds a sword and every Anima of Team B a spear.
  2. Build each Anima's equipment from the birth exactly as `/anima-stratagem` does: a chosen item replaces the birth's gear, material (steel when no material is chosen), quality, prefix and suffix in that slot; an unchosen slot is empty.
  3. Place every Anima on its team, with its stratagem, its label and, when its sidebar has one, its own heraldry in place of its team's, and run the `/anima-scene` rules unchanged ([Derived combat](https://set.world/skills/anima-derived-combat)). Changing any outfit places every Anima again (`set-world-0-15-35-anima-battle-5`); a stratagem change reaches the battle at once.
- **Choosing Animas.** A click on an Anima on the floor (a press released without moving) selects only that Anima; pressing and dragging still picks it up. A roster link adds its unit to the selection or removes it (a team always keeps one). `[ALL]` selects every unit of the team, keeping the one the sidebars show, and choosing it again while every unit is selected keeps only that one. An item, material or heraldry choice in the sidebars changes that slot (or the heraldry) on every selected Anima and leaves their other slots as each has them; a stratagem change, import or removal of a rule replaces the stratagem (and, for an import whose file has one, the outfit) of every selected Anima.
- **Controls.** **Level**, then **Start**, **Stop**, **Reset** and **Reset Stratagems**, which work as on `/anima-stratagem`, for every Anima. The battle ends when a team has no Anima standing; an Anima dead under Resurrection still stands until it rises. **Export battle** saves `anima-battle.battle.json`; **Import battle** reads one and replaces the level and every Anima's outfit, heraldry and stratagem. Each Anima's stratagem columns keep their own Import and Export of a single stratagem ([Stratagems](https://set.world/skills/anima-stratagems)). A saved battle's teams also play on `/anima-scene` through its **Import team** (Imported teams, above). The floor starts 1.67× as close as `/anima-scene` and at the lowest camera tilt the orbit allows; a click on the bare floor adds no Anima.
- **The battle file.** Version 2 of `set-anima-battle`; Set reads versions 1 and 2. Teams are matched by `key`; each team lists at most 16 Animas in order, so the first is `A:1`. An Anima the file leaves out stands with no items and the default stratagem. `outfit` uses the stratagem file's outfit items, words included; a version 1 file's items have none and come in Plain. `stratagem` holds its rules, and `heraldry` is a preset name or an `http(s)` image URL, or `null` for the team's own ([Item models](https://set.world/skills/anima-item-models)). `level` is a whole number from 1 to 99 (1 when absent). A file that names an unknown slot, gear, material, quality, prefix, suffix, condition or act, or a level outside that range, is refused whole, with the Anima and the reason.

  ```ts
  type BattleFile = {
    format: 'set-anima-battle';
    version: 2;
    name: string | null;
    level: number;                      // the Level slider; 1 when left out
    teams: Array<{
      key: 'a' | 'b';
      name: string;                     // written for reading; Set matches teams by key
      animas: Array<{                   // at most 16, in order
        label: string;                  // written for reading, e.g. "A:1"
        outfit: StratagemOutfitItem[];  // Stratagems
        heraldry: string | null;        // preset name or http(s) image URL
        stratagem: StratagemRule[];     // Stratagems
      }>;
    }>;
  };
  ```

  ```json
  {
    "format": "set-anima-battle",
    "version": 2,
    "name": null,
    "level": 1,
    "teams": [
      {
        "key": "a",
        "name": "Team A",
        "animas": [
          {
            "label": "A:1",
            "outfit": [
              {
                "slot": "tool",
                "gear": "sword",
                "material": null,
                "quality": null,
                "prefix": null,
                "suffix": null
              }
            ],
            "heraldry": "openai",
            "stratagem": [
              {
                "condition": "self-hp-below-10",
                "act": "guard"
              },
              {
                "condition": "self-worldsphere-in-melee-range",
                "act": "grab-worldsphere"
              },
              {
                "condition": "self-status-disarmed",
                "act": "pick-up-offhand"
              },
              {
                "condition": "ally-status-debuffed",
                "act": "mainhand"
              },
              {
                "condition": "ally-status-debuffed",
                "act": "offhand"
              },
              {
                "condition": "foe-nearest-visible",
                "act": "throw-worldsphere"
              },
              {
                "condition": "foe-nearest",
                "act": "throw-worldsphere"
              },
              {
                "condition": "foe-status-exposed",
                "act": "melee"
              },
              {
                "condition": "foe-answers-melee",
                "act": "ranged"
              },
              {
                "condition": "foe-in-melee-range",
                "act": "melee"
              },
              {
                "condition": "foe-nearest-visible",
                "act": "ranged"
              },
              {
                "condition": "foe-nearest-visible",
                "act": "melee"
              },
              {
                "condition": "foe-nearest",
                "act": "ranged"
              },
              {
                "condition": "foe-nearest",
                "act": "melee"
              }
            ]
          }
        ]
      },
      {
        "key": "b",
        "name": "Team B",
        "animas": [
          {
            "label": "B:1",
            "outfit": [
              {
                "slot": "tool",
                "gear": "spear",
                "material": null,
                "quality": null,
                "prefix": null,
                "suffix": null
              }
            ],
            "heraldry": "anthropic",
            "stratagem": [
              {
                "condition": "self-hp-below-10",
                "act": "guard"
              },
              {
                "condition": "self-worldsphere-in-melee-range",
                "act": "grab-worldsphere"
              },
              {
                "condition": "self-status-disarmed",
                "act": "pick-up-offhand"
              },
              {
                "condition": "ally-status-debuffed",
                "act": "mainhand"
              },
              {
                "condition": "ally-status-debuffed",
                "act": "offhand"
              },
              {
                "condition": "foe-nearest-visible",
                "act": "throw-worldsphere"
              },
              {
                "condition": "foe-nearest",
                "act": "throw-worldsphere"
              },
              {
                "condition": "foe-status-exposed",
                "act": "melee"
              },
              {
                "condition": "foe-answers-melee",
                "act": "ranged"
              },
              {
                "condition": "foe-in-melee-range",
                "act": "melee"
              },
              {
                "condition": "foe-nearest-visible",
                "act": "ranged"
              },
              {
                "condition": "foe-nearest-visible",
                "act": "melee"
              },
              {
                "condition": "foe-nearest",
                "act": "ranged"
              },
              {
                "condition": "foe-nearest",
                "act": "melee"
              }
            ]
          }
        ]
      }
    ]
  }
  ```

  A game keeps its own battle on top of this: which Animas are whose, results and anything that changes after a battle. Set stores none of it.
- **Limits.** 16 Animas a team, one body at one level, no orbs. Every outfit change re-dresses every Anima. On a mobile browser (above) only `A:1` to `A:8` and `B:1` to `B:8` take the floor; the sidebars still edit every Anima and the battle file keeps them all.
- **Fetch.** A fetch returns the roster, sidebars and default stratagems; the battle runs in a browser. Build from the battle file above and [Stratagems](https://set.world/skills/anima-stratagems).
- **Source.** `@pages/anima-battle.tsx`, `@components/AnimaBattle.tsx`, `@components/Battleground.tsx`, `@components/scene-host.ts`, `@components/StratagemSidebars.tsx`, `@components/ItemSidebars.tsx`, `@common/battle.ts`, `@common/item-models.ts`, `@common/stratagems.ts`, `anima-scene/battleground.ts`, `anima-scene/stratagem.ts`, `anima-scene/mobile-browser.ts`.

## Build sheet: `/anima-battle-effects`

One pair of Animas for every battle effect, practised in rounds: the outcomes the scenes already play, THORNS! among them, each caused on every strike by an item that can cause it, so you can watch what the struck Anima does, and every named effect, so each has its place on the floor before a game gives it a mechanic. The page keeps every effect on, giving a debuff again with each round's hit and a buff again whenever it ends, so each can be watched at length; in a game each effect lasts only its own number of ticks ([Derived combat](https://set.world/skills/anima-derived-combat) has them), and that duration is part of its balance.

- **Shows.** A grid like `/anima-all-weapons` on the `/anima-scene` floor, beside the `/anima-object-models` catalog and materials sidebars (material and quality only: every cell already shows its effect, so no prefix or suffix is offered): 64 cells, 5 to a row, read left to right. The cells are the outcomes the scenes already play and the 49 status effects AnimaSystem plays, GUARD, MISS, BLOCK, PARRY, RIPOSTE, GLANCED, CRITICAL, PRECISE, PIERCE, CRUSH, DISARM, BREAK, STICK, THORNS, CLEANSE, BURNED, POISONED, BLEEDING, BLIGHTED, DECAYING, WITHERING, FROZEN, PETRIFIED, SLEEPING, SEDUCED, SILENCED, AFRAID, HYSTERIA, TAUNTED, PROVOKED, SCARED, EXPOSED, HIDDEN, STALKING, PHASED, RESIST, HASTED, SLOWED, SHIELDED, REGEN, DEATH, RESURRECTION, FORESIGHT, FORTIFIED, REINFORCED, WARDED, LEECHED, VIGOR, VIGILANCE, BERSERK, FRENZY, PROWESS, KEEN, EXALTED, HEAVY, LIGHT, FLOAT, FADED, DOOMED, BLINDED, FRAIL, ELECTROCUTED, COURAGE and CURSED, one for every name in [Effects](https://set.world/skills/status-effects) (Burned, Poisoned, Bleeding, Blighted, Decaying, Withering, Frozen, Petrified, Sleeping, Seduced, Silenced, Afraid, Hysteria, Taunted, Provoked, Scared, Exposed, Hidden, Stalking, Phased, Resist, Hasted, Slowed, Shielded, Regen, Death, Resurrection, Foresight, Fortified, Reinforced, Warded, Leeched, Vigor, Vigilance, Berserk, Frenzy, Prowess, Keen, Exalted, Heavy, Light, Float, Faded, Doomed, Blinded, Frail, Electrocuted, Courage and Cursed); a name the effects table gained without a rule would follow them, its name drawn in light grey on the plate and on every hit, and today there is none. In each cell a black Anima, whose plate shows the cell's effect over its health and stamina strips, faces a white practice Anima 6 world units away, which has no plate.
- **Takes.** The answer of one `GET /api/roll/character?seed=20261007`. Set's page reads that answer from the births prepared at build ([Randomness](https://set.world/skills/anima-randomness)) and makes the request only when they cannot answer; a replica may simply make it, once, stopped if it makes no progress for 30 seconds. That one birth is every Anima's body, so only the outfits differ.

The cells whose outcome needs a kind of item, and which Anima holds it:

| Cell | Anima | Hand | Accepts | Items that qualify | Default |
| --- | --- | --- | --- | --- | --- |
| BLOCK | White | Offhand | shield | 9 items | buckler |
| PARRY | Black | Mainhand | melee weapon | 119 items | assegai |
| PARRY | White | Mainhand | parrying tool | 3 items | jutte |
| RIPOSTE | Black | Mainhand | melee weapon | 119 items | assegai |
| RIPOSTE | White | Mainhand | parrying tool | 3 items | jutte |
| PRECISE | Black | Mainhand | sword | blade, bokken, broadsword, claymore, dao, falcata, falchion, flamberge, katana, khopesh, kopis, longsword, messer, nagamaki, nodachi, saber, scimitar, shashka, shortsword, shotel, sword, tachi and talwar | nodachi |
| PIERCE | Black | Mainhand | thrusting sword, spear or harpoon | assegai, corseque, estoc, gladius, goedendag, harpoon, iklwa, jian, lance, partizan, pike, pitchfork, ranseur, rapier, sarissa, spear, spetum, trident, xiphos and yari | harpoon |
| CRUSH | Black | Mainhand | heavy blunt weapon | club, crowbar, cudgel, hammer, macana, mace, maul, morningstar, patu, pickaxe, tetsubo and tree trunk | tree trunk |
| DISARM | Black | Mainhand | hooked short blade | karambit, kukri and sickle | sickle |
| DISARM | White | Offhand | offhand item | 152 items | buckler |
| BREAK | Black | Mainhand | breaking tool | cleaver, drill, ice pick and wrench | drill |
| STICK | Black | Mainhand | sticking pole or club | bardiche, bill, fauchard, glaive, goad, guisarme, halberd, naginata, rake, scythe and voulge | scythe |
| STICK | Black | Offhand | melee weapon that does not stick | 106 items | assegai |
| THORNS | Black | Mainhand | melee weapon | 119 items | assegai |
| CLEANSE | Black | Mainhand | item that restores stamina and heals no health | scroll | scroll |
| SLEEPING | White | Offhand | offhand item | 152 items | buckler |
| HYSTERIA | White | Offhand | offhand item | 152 items | buckler |
| REINFORCED | Black | Mainhand | bow, crossbow or gun | 10 items | bow |
| WARDED | Black | Mainhand | magic item that deals damage | 6 items | orb |
| VIGILANCE | Black | Mainhand | heavy blunt weapon | club, crowbar, cudgel, hammer, macana, mace, maul, morningstar, patu, pickaxe, tetsubo and tree trunk | tree trunk |
| KEEN | Black | Mainhand | bow, crossbow or gun | 10 items | bow |
| HEAVY | Black | Mainhand | heavy blunt weapon | club, crowbar, cudgel, hammer, macana, mace, maul, morningstar, patu, pickaxe, tetsubo and tree trunk | tree trunk |
| LIGHT | Black | Mainhand | heavy blunt weapon | club, crowbar, cudgel, hammer, macana, mace, maul, morningstar, patu, pickaxe, tetsubo and tree trunk | tree trunk |

- **Build it.**
  1. Read the selection from the `/anima-object-models` query parameters, held and worn items alike (`tool=<gear>&toolMaterial=<material>&chest=<gear>&heraldry=vmax`). With none, every black Anima fights barehanded and nobody wears anything.
  2. Build every Anima's equipment from the birth as `/anima-stratagem` does. Everyone wears the chosen worn items, except the BREAK cell's white Anima, which wears only a mythril breast plate, the RESIST cell's, which wears only mythril sabatons, mythril legplates, mythril gauntlet, mythril vambrace, mythril gothic plate, mythril girdle, mythril pauldrons, mythril gorget and mythril armet, and the HEAVY and LIGHT cells' black Animas, which wear only mythril sabatons, mythril legplates, mythril gauntlet, mythril vambrace, mythril gothic plate, mythril girdle, mythril pauldrons, mythril gorget and mythril armet. A bow, crossbow or gun is an item whose action is one of aim, fire, gunfire and blast. A black Anima holds every chosen held item and a white one holds nothing, except in the cells that need a certain item and the FLOAT cell, whose black Anima holds nothing. There that Anima holds only the items the cell needs: in each such hand the chosen item when it is the right kind, otherwise the default in the table above. For an effect with its own chance, an item is the right kind exactly when that chance is above 0 for it, so the table lists every item that can cause it and none that cannot. The default is, for an effect with its own chance, the item of that kind with the highest chance at steel (the one the item analysis ranks first for it), and otherwise the first item of that kind in the sidebar's alphabetical list that the cell prefers (a shield for an offhand item, a bow for a bow, crossbow or gun, a Repulse item for a magic item that deals damage), or the first of all when it prefers none, made of the chosen material for that hand when there is one. A hand the cell does not name stays empty.
  3. Lay pair `i` of `N` out in `C = 5` columns and `rows = ceil(N / C)`: `cellX = (i mod C − (min(C, N) − 1)/2) × 10`, `cellZ = (floor(i / C) − (rows − 1)/2) × 4.2`. The black Anima stands at `cellX − 6/2` as Team A and the white one at `cellX + 6/2` as Team B, facing each other ([Algorithms](https://set.world/algorithms) §13.88).
  4. Give both Animas of a cell the same pair number, and let two Animas oppose only when their teams differ and their pair numbers match. Each black Anima then sees, strikes, shoots, pulls and drains only its own white Anima, and its shots and waves pass through every other cell. Ring heals and body pushes still reach everyone.
  5. Practise in rounds (`set-world-0-15-35-practice-round-11`). The black Anima plays the default stratagem ([Stratagems](https://set.world/skills/anima-stratagems)) until it starts one attack. It finishes that attack and keeps fighting for as long as that attack holds the white Anima, so the effect plays out in full: while its pole holds the white Anima stuck it strikes with its other hand, and while a thrown chain or a harpoon is still out it uses its other hand too. Only then does it walk all the way back to its place. It plays again only once both Animas of its pair stand within 0.215 world units of their places, each idle and facing its own way within 0.1 radians (a guarding one within that reach of where it began guarding), unstuck, standing and holding its offhand; a petrified or hysterical white Anima counts as home where it stands, and a shattered one once it has faded in again. So the white Anima always recovers before the next strike. As the next round begins, every broken worn piece of either Anima is repaired, showing `REPAIR!`. The white Anima has an empty stratagem, so it never starts a fight and, after every push, walks back to its place and turns to face its attacker; in the STALKING cell it is placed facing away and turns its back to the attacker instead. In the GUARD cell its stratagem is the one rule `foe-nearest → guard`. Everything else is the `/anima-scene` rules ([Derived combat](https://set.world/skills/anima-derived-combat)): each item's real action, stamina, range, reload, damage roll, knockback and hit reaction. A strike between the Animas of a pair is never dodged (the striker's clarity counts as 1), never glances, and is never blocked or parried, unless its cell forces that. Neither Anima of a pair loses health: damage is shown and never taken, so nobody falls, except the PETRIFIED cell's shattering strike, after which the white Anima stands again, the end of the DEATH cell's count and every strike in the RESURRECTION cell, after which the white Anima rises again. Wherever the black Anima's hits give the white Anima an effect, the white Anima also keeps RESURRECTION, a blue halo above its head, given again as each round begins and never while it is down: if it dies, it rises with no effects, and the next round's hit afflicts it again.
  6. Make the cell's outcome certain on every strike the black Anima lands on its own white Anima with an item that can cause it (never with its other item), through the scene's own code path, so the white Anima reacts exactly as it would in a fight. Every effect wears the look the Seen and Burned's flames rules of [Derived combat](https://set.world/skills/anima-derived-combat) give it, and its word shows in the colour below:

     | Cell | Made certain | What the white Anima does |
     | --- | --- | --- |
     | GUARD | Its stratagem guards whenever it can | Guards as [Stratagems](https://set.world/skills/anima-stratagems) describes, until its stamina breaks the guard; each guarded hit shows `GUARD!` |
     | MISS | Every strike misses, including Gaze, Pound and rupture-wave contacts | Nothing: `MISS` and no push |
     | BLOCK | Its shield blocks every hit | Nothing: `BLOCK`, no damage and no push |
     | PARRY, RIPOSTE | Its parrying tool parries every melee hit (it must have the stamina for the riposte) | `PARRY!` on it, then its riposte ([Derived combat](https://set.world/skills/anima-derived-combat)) lands as the swing connects, `RIPOSTE!` on the black Anima, which takes the hit reaction. The two cells play the same exchange; read PARRY on the white Anima and RIPOSTE on the black |
     | GLANCED | Every hit glances off | Nothing: `GLANCED` and no push |
     | CRITICAL | The damage roll's critical chance is 1 | A larger hit reaction under `CRITICAL!` |
     | PRECISE | The sword's Precise chance is 1, and a chained stroke flinches the white Anima without pushing it | The stroke turns back for another hit, which is Precise again, without end: the round never closes, and Stop ends it |
     | PIERCE | The pierce chance is 1 | Takes damage with no reduction, under `PIERCE!` |
     | CRUSH | The crush chance is 1 | Is crushed where it stands ([Derived combat](https://set.world/skills/anima-derived-combat)), then rises from its kneel and walks back |
     | DISARM | The disarm chance is 1 | Drops its offhand item, flung along the hit, and goes to pick it up |
     | BREAK | The break chance is 1 | Wears only a mythril breast plate, whatever the sidebars choose, and loses it each round: `BREAK!`, and the plate is gone. When the next round begins the plate is repaired and `REPAIR!` shows above it in the released orbs' gold, a non-combat event nothing in a fight causes |
     | STICK | The pole's stick chance is 1 | Is held on the leash while the black Anima closes in and strikes with its offhand weapon; that hit breaks the hold, and the round ends |
     | THORNS | The white Anima answers every melee hit with a Plain thorns word, 2.5% of its own base hit, as if it wore one | Nothing new on it: the black Anima shows the prick's damage under `THORNS!` on every melee strike, and loses no health, as a practice pair never does ([Item attributes](https://set.world/skills/anima-item-attributes)) |
     | CLEANSE | The black Anima holds an item that restores stamina and heals no health (Scroll) and starts every round POISONED!; each of its rings that reaches itself cleanses for certain | `CLEANSE!` rises above the black Anima as the poison ends, and the poison is given again at its next decision, so every ring that reaches it cleanses again ([Derived combat](https://set.world/skills/anima-derived-combat)) |
     | BURNED | Its effect takes hold on every landed hit, from any item, with no item needed (in a fight it comes from an item word's chance, [Item attributes](https://set.world/skills/anima-item-attributes)) | `BURNED!` and its tick damage in burn orange, and it walks and acts a little slower. Each round's hit refreshes the effect, as in every status cell |
     | POISONED | As BURNED | `POISONED!` and every tick's damage in purple |
     | BLEEDING | As BURNED | `BLEEDING!` and every tick's damage in pink |
     | BLIGHTED | As BURNED | `BLIGHTED!` in acid green; its stamina is capped, so the strip stays short |
     | DECAYING | As BURNED | `DECAYING!` in brown; its health is shown against the lowered cap |
     | WITHERING | As BURNED | `WITHERING!` in violet; it walks back slowly |
     | FROZEN | As BURNED | `FROZEN!` in ice blue; no push moves it, so it stays at its place, turning only |
     | PETRIFIED | As BURNED | `PETRIFIED!` in stone grey, keeping the pose it was struck in. The next round's strike lands for more than its maximum health and shatters it ([Derived combat](https://set.world/skills/anima-derived-combat)); once the pieces are gone the white Anima fades in again at its place, whole, and the next round petrifies it again. Stop turns a statue back |
     | SLEEPING | As BURNED; it holds an offhand item (table above) | `SLEEPING!` in pale blue; it sleeps until its last tick wakes it, picks its item up and walks back, and only then does the next round begin |
     | SEDUCED | As BURNED | `SEDUCED!` in pink; it sides with the black Anima's team, which still strikes it, so each round's hit ends the charm and gives it again |
     | SILENCED | As BURNED | `SILENCED!` in violet; nothing else changes, since no talent exists yet |
     | AFRAID | As BURNED | `AFRAID!`; it runs from the black Anima as far as it can until the effect ends, then walks back |
     | HYSTERIA | As BURNED; it holds an offhand item | `HYSTERIA!` in yellow; on every tick it picks what to do ([Derived combat](https://set.world/skills/anima-derived-combat)), with no friend in its cell to attack. The round does not wait for it to come home: the black Anima walks back, then hunts it down wherever it has run and strikes again, refreshing the effect, so it stays hysterical for as long as the practice runs |
     | TAUNTED | As BURNED | `TAUNTED!`; it walks to the black Anima and attacks it until the effect ends |
     | PROVOKED | As BURNED | `PROVOKED!` in red; the next round's hit shows more damage (its stratagem is empty, so it has no defensive act to drop) |
     | SCARED | As BURNED | `SCARED!`; when the black Anima comes close it backs away slowly and punches back at it, then walks home once it is alone |
     | EXPOSED | As BURNED | `EXPOSED!`; a hit while the effect lasts shows more damage |
     | HIDDEN | It starts hidden and is hidden again whenever it is not | The black Anima finds no target and never strikes |
     | STALKING | The black Anima starts stalking and stalks again whenever it is not; the white Anima stands with its back to it | `STALKING!` in green over the black Anima. Every strike lands on the white Anima's back, so its damage shows 2 times larger with `SURPRISE!` in green beside it; each attack ends the stalk as it starts, its strike keeping the ambush, and the black Anima stalks again, and the white Anima walks back and turns its back again |
     | PHASED | The white Anima starts phased and is phased again whenever it is not | `PHASED!` in aqua. Each strike passes through it at Phased's chance, showing `PHASED!` and nothing else, or lands as in a fight |
     | RESIST | The white Anima starts with Resist and has it again whenever it does not; each landed hit carries an effect for it to resist (POISONED in the RESIST cell and BURNED in the EXALTED cell) | It wears only mythril sabatons, mythril legplates, mythril gauntlet, mythril vambrace, mythril gothic plate, mythril girdle, mythril pauldrons, mythril gorget and mythril armet, whatever the sidebars choose, so its rainbow skin shows over full armor, under `RESIST!` in rainbow letters. The cell makes the resistance certain: every hit shows `RESIST!` again, and the poison never takes hold |
     | HASTED | The black Anima starts hasted and is hasted again whenever it is not | `HASTED!` in gold over the black Anima; it walks, strikes and walks back faster ([Derived combat](https://set.world/skills/anima-derived-combat) has the factor) |
     | SLOWED | The black Anima starts slowed and is slowed again whenever it is not | `SLOWED!` in red over the black Anima; it walks, strikes and walks back slower |
     | SHIELDED | The white Anima starts shielded and raises a new shield whenever it has none | `SHIELDED!` in light blue. Each blow shows the damage the shield took in light blue and plays no hit reaction while the shield holds; the blow that empties it breaks it, and the white Anima raises a new one at once, `SHIELDED!` again |
     | REGEN | The white Anima starts regenerating and regenerates again whenever it is not | `REGEN!` in light green; every tick shows its healing as a green `+N` (shown even at full health, as a practice pair never loses health) |
     | DEATH | As BURNED, except that a hit never restarts a count already running | `DEATH!` in pale violet and its count above its head in a dark badge, beating in as it changes. When the count runs out it dies, whatever its health: its remaining health shows in pale violet and it falls. Its halo breaks and, 1.8 s later, it rises with `RESURRECTION!`, walks back and is struck again |
     | RESURRECTION | The white Anima starts with Resurrection and has it again as each round begins; every strike kills it | `RESURRECTION!` in blue. The strike takes all its health and it falls under the blow; 1.8 s later it rises with `RESURRECTION!` ([Derived combat](https://set.world/skills/anima-derived-combat)) and walks back, and the halo returns as the next round begins |
     | FORESIGHT | The black Anima starts with Foresight and has it again whenever it does not; the white Anima keeps Hidden (HIDDEN in the FORESIGHT cell) | `FORESIGHT!` in blue over the black Anima. The white Anima stays hidden, yet the black Anima sees it, walks to it and strikes it every round; its strikes are never dodged, glanced or passed through. A hit does not reveal the white Anima: it stays hidden, each hit showing 25% less damage, and once Hidden runs out it hides again with `HIDDEN!` as the next round begins |
     | FORTIFIED | The white Anima starts fortified and is fortified again whenever it is not | `FORTIFIED!` in blue; every physical hit lands for less |
     | REINFORCED | The white Anima starts reinforced and is reinforced again as soon as its last charge breaks; the black Anima shoots | `REINFORCED!` in blue. Each arrow or shot is taken whole by the orb nearest it: its damage shows in blue and the white Anima does not flinch. When the last orb is gone a new set grows in at once |
     | WARDED | The white Anima starts warded and is warded again whenever it is not; the black Anima holds a magic item that deals damage, the Orb by default, so it walks in and strikes with Repulse's ring | `WARDED!` in blue; every magic hit lands for less |
     | LEECHED | The black Anima starts with Leech and has it again whenever it does not | `LEECHED!` in deep red over the black Anima; each hit it lands shows the health it draws back as a deep-red `+N` above it (shown on every hit, as a practice pair never loses health) |
     | VIGOR | The black Anima starts with Vigor and has it again whenever it does not | `VIGOR!` in deep blue over the black Anima; each hit it lands shows the stamina it draws back as a `+N` above it (shown on every hit, as a practice pair never loses stamina) |
     | VIGILANCE | The white Anima starts vigilant and is vigilant again whenever it is not; the black Anima holds a heavy blunt weapon and every strike tries to crush (CRUSH in the VIGILANCE cell) | `VIGILANCE!` in gold. Each heavy blow lands its damage, but the white Anima neither moves, flinches nor falls, and each crush is stopped, showing `VIGILANCE!` where `CRUSH!` would be |
     | BERSERK | The black Anima starts berserk and is berserk again whenever it is not | `BERSERK!` in crimson over the black Anima; it strikes harder and faster and reloads and recovers sooner (and would take more damage) |
     | FRENZY | The black Anima starts frenzied and is frenzied again whenever it is not | `FRENZY!` in white over the black Anima; it strikes faster and recovers sooner |
     | PROWESS | The black Anima starts with Prowess and has it again whenever it does not | `PROWESS!` in white-gold over the black Anima. Every stat is raised while it lasts, so its plate shows more health and stamina, its hits show more damage, and it strikes, recovers and walks a little faster |
     | KEEN | The black Anima starts keen and is keen again whenever it is not; it shoots | `KEEN!` in light blue over the black Anima; its arrows and shots keep their arc and bend onto the white Anima wherever it steps, arriving on it and never missing |
     | EXALTED | The black Anima starts exalted and has it again whenever it does not; each landed hit gives the white Anima the effect it carries (POISONED in the RESIST cell and BURNED in the EXALTED cell) | `EXALTED!` in light blue over the black Anima; the white Anima catches fire, and each tick of its burn shows its damage times the Exalted factor |
     | HEAVY | The black Anima starts heavy and is heavy again whenever it is not; it wears only mythril sabatons, mythril legplates, mythril gauntlet, mythril vambrace, mythril gothic plate, mythril girdle, mythril pauldrons, mythril gorget and mythril armet, whatever the sidebars choose, and holds a heavy blunt weapon | `HEAVY!` in iron grey over the black Anima. Everything it wears and holds weighs 3 times as much, so its plate and weapon slow its walk and its swing |
     | LIGHT | The black Anima starts light and is light again whenever it is not; it wears the same mythril plate and holds a heavy blunt weapon | `LIGHT!` in white over the black Anima. Everything it wears and holds weighs 33% as much, so the same plate and weapon let it walk and swing faster |
     | FLOAT | Both Animas start floating and float again as each round begins; the black Anima fights barehanded whatever is chosen | `FLOAT!` in pale blue over both as they rise ([Derived combat](https://set.world/skills/anima-derived-combat)). The black Anima floats over and punches; the landed punch ends the white Anima's float and it falls, while the black Anima, still afloat, floats back to its place |
     | FADED | The white Anima starts faded and is faded again whenever it is not | `FADED!` in pale grey; each hit lands for 80% less, and a faded Anima's own hits would deal 80% less |
     | DOOMED | As BURNED | `DOOMED!` in red; every stat is 8% lower while it lasts, so its health, stamina and attributes shrink |
     | BLINDED | The black Anima starts blinded and is blinded again whenever it is not | `BLINDED!` in grey over the black Anima; 50% of its strikes miss with `MISS`, and every other chance it rolls loses the same share |
     | FRAIL | The black Anima starts frail and is frail again whenever it is not | `FRAIL!` in red over the black Anima; it starts no attack, so it walks up to the white Anima and stands before it without striking, and the round never ends |
     | ELECTROCUTED | As BURNED | `ELECTROCUTED!` in blue. Every later landed hit also shocks it ([Derived combat](https://set.world/skills/anima-derived-combat)), the shock's damage shown in blue under `ELECTROCUTED` |
     | COURAGE | The black Anima starts with Courage and has it again whenever it does not | `COURAGE!` in gold over the black Anima; every chance it rolls is 10 points higher |
     | CURSED | As BURNED | `CURSED!` in violet; it loses 8% of the giver's base hit as stamina every tick, shown in violet, and every chance rolled against it is 10 points higher |

  7. In the cell of a name with no rule, should the effects table gain one, whenever a black Anima's contact lands on its own white Anima (a hit that is not missed, blocked, parried or glanced; a Gaze or Pound contact; a rupture wave's pull; a stamina ring reaching it), show the effect's name with `!` in light grey above that hit's counters, with their timing. Any item shows any named effect. The name is a placeholder and applies nothing (`set-world-0-15-35-anima-battle-effects-15`).

  ```ts
  type PracticePair = { id: number; dummy: boolean; effect: string | null; away?: boolean };   // given to each placed Anima; both of a cell share id; away places the white Anima of a facing-away cell with its back to the black one
  type PracticeStart = { word: StatusWord; side: 'attacker' | 'dummy' };   // one effect a cell gives from the start: its buff, the effect it keeps on the white Anima for that buff to meet, and the reviving halo
  type PracticeEffect = 'GUARD' | 'MISS' | 'BLOCK' | 'PARRY' | 'RIPOSTE' | 'GLANCED' | 'CRITICAL' | 'PRECISE' | 'PIERCE' | 'CRUSH' | 'DISARM' | 'BREAK' | 'STICK' | 'THORNS' | 'CLEANSE' | StatusWord;   // StatusWord: Derived combat
  type PracticeNeed = { side: 'attacker' | 'dummy'; slot: 'tool' | 'offhand'; category: string };   // one row of the needs table
  type EffectMarker = { actorId: number; value: string; tone: 'effect' | 'named' | 'repair' | 'status'; status: StatusWord | null; born: number; seconds: number };   // GUARD! on a guarded hit, a named effect on each landed contact, REPAIR! when a round mends broken armor
  ```

  ```json
  [
    {
      "id": 58,
      "dummy": false,
      "effect": "DOOMED"
    },
    {
      "id": 58,
      "dummy": true,
      "effect": null,
      "away": false
    }
  ]
  ```

- **Controls.** **Start** turns combat on and begins the rounds, **Stop** turns it off and every black Anima walks back to its place, and **Reset** places every pair again; the bar shows the frame rate. Changing the outfit places every pair again. The floor keeps `/anima-scene`'s camera angle at 0.67× its zoom, framing the whole grid, with its pause and pickup; a click adds no Anima.
- **What stays the game's.** What applies each named effect, how long it lasts, its magnitude, its stacking and what resists it ([Effects](https://set.world/skills/status-effects)). Outside this page the outcomes happen only at their own chances ([Derived combat](https://set.world/skills/anima-derived-combat)).
- **Limits.** One body at level 1, no orbs, one outfit for every black Anima outside the cells that need an item. A strike can still whiff when the item's real motion does not reach. A Gaze, Pound or rupture-wave contact carries no hit, so only MISS is made certain on it. A named effect's marker does nothing.
- **Fetch.** A fetch returns the sidebars and a prose description of every cell (written for screen readers); the field runs in a browser. What each effect does is [Derived combat](https://set.world/skills/anima-derived-combat) (Taking hold, Seen).
- **Source.** `@pages/anima-battle-effects.tsx`, `@components/StatusEffectField.tsx`, `@components/ItemSidebars.tsx`, `@components/scene-host.ts`, `anima-scene/status-field.ts`, `anima-scene/practice.ts`, `anima-scene/status-effects.ts`, `anima-scene/burn-flames.ts`, `anima-scene/status-visuals.ts`, `anima-scene/status-particles.ts`, `anima-scene/status-skins.ts`, `anima-scene/status-shells.ts`, `anima-scene/status-halos.ts`, `anima-scene/status-sigils.ts`, `anima-scene/status-guards.ts`, `anima-scene/status-spikes.ts`, `anima-scene/status-blindfold.ts`, `anima-scene/status-smoke.ts`, `anima-scene/status-chains.ts`, `anima-scene/status-ice.ts`, `anima-scene/status-shatter.ts`, `weapons/effects.ts`, `anima-scene/teams.ts`, `anima-scene/model.ts`, `anima-scene/equipment.ts`, `anima-scene/overlays.ts`, `anima-scene/stratagem.ts`.

## Build sheet: `/anima-analysis`

The AnimaSystem item analysis, beside the home page's sidebar of skills: a table of readings with no body on screen.

- **Shows.** Every held item, with bare hands (`(nothing)`) as the first row, read at one level (`set-world-0-15-35-item-analysis-1`): a row of cards, one per measure (Fastest attack animation, Longest ranged reach, Fastest projectile, Longest melee reach, Heaviest melee weapons, Quickest recovery, Slowest recovery, Heaviest on stamina, Lightest on stamina, Highest base hit, Hardest single hit, Widest area, Most hits per action, Most likely to trigger PRECISE!, Most likely to trigger PIERCE!, Most likely to trigger CRUSH!, Most likely to trigger DISARM!, Most likely to trigger BREAK!, Most likely to trigger STICK!, Most likely to trigger GUARD!, Support items, Slowest to carry and Easiest to carry), each with its formula and its 50 best items, then one table of every item. Support items lists every item that heals, restores or drains stamina, or knocks down; Most hits per action lists only items that land more than one; Heaviest melee weapons lists only items that strike in melee, without shields or bare hands. Units are in the headings, never in the cells.
- **Takes.** Nothing from the API. The readings are the formulas of [Derived stats](https://set.world/skills/anima-derived-stats) and [Derived combat](https://set.world/skills/anima-derived-combat) evaluated on a hypothetical Anima.
- **Build it.**
  1. Make the Anima: all-16 stats plus the level's stat points (the level and orb recipe in [Derived stats](https://set.world/skills/anima-derived-stats)) spread evenly across the 5 primary stats, read as scene attributes. It holds each item alone, in steel.
  2. Measure each item's model once (its mass and built reach). For the chosen level read, per item: the seconds one action plays and the wait after it (reload included), its stamina cost, its base hit against a punch, its hit before defence and the contacts one action lands, its ranged reach and projectile speed, its melee reach from the body centre, the area it covers, a shield's or parry tool's guard chance, its chance of each shaped effect (PRECISE!, PIERCE!, CRUSH!, DISARM!, BREAK!, STICK!), its heal and stamina effects, whether it knocks down, and the walk speed its weight costs ([Derived combat](https://set.world/skills/anima-derived-combat)).
  3. Measure off the main thread: the first measurement takes seconds, each later level milliseconds. Start when the analysis first comes into view, ask again at every Level change, and never show an older level's answer as current.
- **Controls.** **Level** (1 to 99). A table heading sorts by its column; a second click reverses it.
- **Limits.** Formula values for one item held alone by a hypothetical stat block, not a battle: ranges are measured from the ground and ignore the motion a scene traces. No request, damage or combat state.
- **Fetch.** A fetch returns only the measures' names and formulas; every value is computed in the browser. The held items' level-1 readings are printed in [Derived combat](https://set.world/skills/anima-derived-combat).
- **Source.** `@pages/anima-analysis.tsx`, `@components/ItemAnalysisSection.tsx`, `items/item-analysis.ts`, `items/item-analysis-rules.ts`, `items/item-analysis-worker.ts`.

## Build sheet: `/anima-prefixes-suffixes-effects`

The canon reference of every item prefix, suffix and status effect AnimaSystem reads, and what each does at every item quality, beside the home page's sidebar of skills. The scenes, the army and the dungeon read the same rules.

- **Shows.** A fixed header with the item quality picker above a rail of home-width columns (`set-world-0-15-35-item-attributes-10`): a table of every quality's odds, points and effect strength; how it plays (what a held prefix acts on, a shield included, and the worn form a worn prefix takes, suffixes in every slot, stacking; a hit and an effect step by step, in the order the scene resolves them; the counterweights: one affix of each raiser beside one of what answers it; the effect contest; the two-part damage; the anchored status numbers at Plain and at the chosen quality; the triggers; and where it applies); levels 1 to 99 for an all-16 Anima with even growth (what one strength point is worth as physical damage and one vitality point as maximum health at each level, beside the chosen quality's strength word read the same way and its physical-damage word, which reads no level; its effect chance and effect resistance by level, and what a level-1 giver nets against each; and the giant-slayer table: the stat points 6 items of each quality add with every affix on a primary stat, and the bare level a level-1 Anima then matches, level 47 at the rarest); what wisdom, perception, resolve and luck read at the birth maximum and with a word of the rarest quality on top; the 25 prefix archetypes and 23 suffix archetypes as cards (a table of the words side by side with what each does on a weapon and worn, or in any slot); every prefix and every suffix with a search and a table of its amounts at every quality; the distribution of the 357 words (how many prefixes and suffixes carry each effect and each status effect, most carried first); every effect (44) with how it acts and its worn form, its price, its most from all items, how many prefixes and suffixes carry it, and a table of one affix by quality, or a row for every status it can carry; every one of the 49 status effects with its prose, what it does, its chance on hit stacked over 6 items and what of it passes full effect resistance, the words that carry it, its chance by quality and trigger and its strength by quality. Every text follows the picked quality, Plain at first; the quality picker and the word searches are the only controls, since every amount is the quality's. Every table has the same fixed-width first column.
- **Takes.** Nothing from the API: the reference reads the prefix and suffix tables and the item quality table, and the build fails if a word belongs to no group or to two.
- **Build it.** Price every word, status and contest with the rules of [Item attributes](https://set.world/skills/anima-item-attributes) at the picked quality, and lay each column out from them; the levels column reads the scene's level growth ([Derived stats](https://set.world/skills/anima-derived-stats)) for an all-16 Anima.
- **Limits.** A reference: it changes no item, character or fight itself. The scenes and the dungeon play every effect; practice pairs read stats and attributes only, so each cell stays certain.
- **Fetch.** A fetch returns everything: the HTML prints every table, and the page's `__NEXT_DATA__` script holds the same reference as JSON at `props.pageProps.reference` ([Item attributes](https://set.world/skills/anima-item-attributes) has its schema).
- **Source.** `@pages/anima-prefixes-suffixes-effects.tsx`, `@components/ItemAttributesRail.tsx`, `items/item-attribute-effects.ts`, `items/item-attribute-words.ts`, `items/item-attribute-reference.ts`; the scenes read them through `items/item-attributes.ts`.

## Build sheet: `/anima-object-models`

- **Shows.** Every base type on the body and alone, in any material its table allows and with any quality, prefix and suffix, with each material's AnimaSystem reading, what every quality, prefix and suffix does on the focused item, and a GLB download of the chosen item. The Anima pane's heading names each item with its tempo and speed; the Mesh pane's gives the focused item's mass in lbs, its reach in inches and its animation. Words change readings, never the look.
- **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, one quality, prefix and suffix per item (`<slot>Quality`, `<slot>Prefix`, `<slot>Suffix`, every word of the quality, prefix and suffix tables), and the heraldry from the sidebar's Heraldry group, a preset or an image URL, shown on the flag and ailettes ([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), and the word readings the item attributes of [`/anima-prefixes-suffixes-effects`](https://set.world/anima-prefixes-suffixes-effects). Under the material table: the chosen item's full name and word reading, then, full width and stacked, a quality table (odds, points a word, effect strength), a prefix table and a suffix table, each row a picker with the word and its effect overview: what it does on the focused item at the chosen quality, in the form the item gives it (a prefix on a held item acts on that item's hits, a prefix on a worn piece takes its worn form, a suffix acts in any slot). Mass and tempo read the quality and the words' lighter and heavier. The sidebar of `/anima`, `/anima-all-weapons`, `/anima-stratagem` and `/anima-battle` offers the same picks under the materials: the quality table, then a Prefix list and a Suffix list, each alphabetized, where pointing at a word (or focusing it from the keyboard) shows a tooltip with what it does on the focused item at the chosen quality and material, as the word reading table does; `/anima-battle-effects` offers only the quality. On the duel and the battle the outfitted item carries exactly the chosen words, so they act in the fight.
- **Controls.** Drag to turn (Shift and drag to pan), Zoom out, Zoom in, Fit; the Mesh pane adds Download model, and the Anima pane adds Start and Stop attack, Start and Stop walking, and **Group**: 16 Animas stand in a ring around an empty centre, each facing in and wearing the same outfit, with the camera pulled back to the board view to fit them. When a held item is not melee, one timber practice statue stands in the centre, the ring widens to that item's range, and every shot, throw and wave goes at it, each hit showing its damage above it and the Scroll's ring the stamina it restores in blue, while an instrument plays with no ring and no number; melee loadouts get no statue. Start attack and Start walking play on every one of them in place. Pressing Group again returns to one Anima at the camera it had before. The single Anima gets the same statue when a held item is not melee, straight ahead at that item's range, with the view framing both and each hit's damage shown above it.
- **Fetch.** A fetch returns the material table and the focused item's quality, prefix and suffix tables; the models, the weights in pounds and the GLB download need a browser ([Item models](https://set.world/skills/anima-item-models)).
- **Source.** `@pages/anima-object-models.tsx`, `@components/ItemModels.tsx`, `@components/ItemModelView.tsx`, `@components/ItemSidebars.tsx`, `@components/AnimaSystemMaterials.tsx`, `@components/ItemWords.tsx`, `@common/item-models.ts`, `@common/item-portrait.ts`, `items/`, `armor/`.

## Build sheet: `/anima-talents`

A scaffold for showing what every talent does, while talents are still being given their effects.

- **Shows.** The `/anima-object-models` item sidebars (catalog with heraldry, then materials, quality, prefix and suffix) beside one smaller Anima pane, and under it a table of every talent (288, in the talents table's order) with the columns Talent and Effects. No talent has an effect yet, so every Effects cell reads `[WORK IN PROGRESS]`.
- **Takes.** Nothing at runtime; the talent names are the talents table (`/api/talents`, [Talents](https://set.world/skills/character-talents)).
- **Build it.** The Anima pane of `/anima-object-models` alone, dressed from the sidebars as there (same query parameters and controls, Group included), with the table under it in the same scrolling column. Fill a cell only from a rule that exists; a talent with no rule stays marked as unfinished.
- **Limits.** Talents give a character no effect in any scene yet: the page shows names, not mechanics. No roll, request or combat state.
- **Fetch.** A fetch returns the talent names (each talent's `id` and `name`), from the same table as `GET /api/talents`.
- **Source.** `@pages/anima-talents.tsx`, `@components/AnimaTalents.tsx`, `@common/talents.ts`, `@components/ItemSidebars.tsx`, `@components/ItemModelView.tsx`.

## Build sheet: `/anima-class-talents`

A scaffold for the talents each class will have of its own, laid out like `/anima-talents`.

- **Shows.** The same sidebars and Anima pane, and a table of every class (155, in the classes table's order) with the columns Class, Class talent and Effects. No class has a talent of its own yet, so both of the other cells read `[WORK IN PROGRESS]`.
- **Takes.** Nothing at runtime; the classes are the classes table (`/api/classes`), each named for the mainhand it holds ([Classes](https://set.world/skills/character-classes)).
- **Build it.** As `/anima-talents`, except that each class name is a picker: choosing it puts that class's mainhand in the Anima's hand, choosing it again puts it away, and the row of the class whose mainhand is held is highlighted.
- **Limits.** As `/anima-talents`: names only, no effect, no request.
- **Fetch.** A fetch returns the class names (each class's `name` and `mainhand`), from the same table as `GET /api/classes`.
- **Source.** `@pages/anima-class-talents.tsx`, `@components/AnimaTalents.tsx`, `@common/classes.ts`, `@components/ItemSidebars.tsx`, `@components/ItemModelView.tsx`.

## Build sheet: `/anima-model-teams`

Each model's designed team at practice: the same 16 births, placed, equipped and grown by one designer at a time, every Anima attacking its own timber statue, beside that designer's own account of why it built that team (`set-world-0-15-35-team-practice-2`).

- **Shows.** Two sidebars on the left: the first lists every model that has written a designer (`claude-opus-5-5`, `claude-fable-5-1`, `gpt-6-astra`, `claude-sonnet-5-5`, `claude-haiku-4-5-20251001`, `claude-haiku-5-5`, `gpt-6-sol`, `gpt-6-luna`, `gpt-5.6-sol`, `gpt-5.6-terra` and `gpt-5.6-luna`), the chosen one highlighted; the second holds that designer's own account as plain paragraphs: first its summary, the team it built and why that team is the best it could make, then its full rationale, the reasoning behind every choice, when it has written one. Beside them, the shared floor with the chosen model's 16 Animas in its formation, 4 to a row, front row nearest the camera, each in its trait colour and its maker's heraldry, with its role named above it, facing its own timber practice statue. Under the floor, a bar like `/anima-scene`'s: **Orbs per item** and **Level**, the designer and its version, then **Place team**, **Fight in simulator**, **Start** and **Stop**. **Fight in simulator** opens `/anima-scene` with the chosen designer for Team A at the bar's level and orbs per item, leaving Team B for the player to choose. The floor is always drawn, framed for a full formation; no team stands on it until **Place team** is pressed.
- **Takes.** The answers of 16 `GET /api/roll/character` requests, read together once per visit on the first **Place team**, on `deriveSeed(20261017, index)` for each index below 16. Set's page reads them from the births prepared at build ([Randomness](https://set.world/skills/anima-randomness)) and makes a request only when they cannot answer; a replica may simply make them, each stopped if it makes no progress for 30 seconds, with a Retry that rolls them again. Every designer reads the same births, so two teams differ only by what their designers chose.
- **Build it.**
  1. When **Place team** is pressed, run the chosen designer on the births at the bar's level and orbs per item, which open at their highest, level 99 and 15,625 orbs per item, exactly as `/anima-scene` builds a designed team (Designed teams, above): validate the design, then prepare each member from its birth.
  2. Hold one team's 3D field at a time. Choosing another designer, or a slider coming to rest for 400 ms on a new value, interrupts the team at whatever step it has reached, even while it is still loading, and the births in flight keep rolling for the next team rather than starting again. It stops the attacks, clears the Animas at once (when any were dressed, by closing the whole field, renderer, Animas, statues, floor and every flight, and opening a fresh empty one) and leaves the floor without a team until **Place team** is pressed again, which builds the team on the same births: run the designer and prepare all 16 members first, and only then dress them onto the floor. Each member appears in its place as soon as it is dressed, in its 15 items, each in its material, with the designer's heraldry on the flag and ailettes ([Item models](https://set.world/skills/anima-item-models)), while the centre of the floor names each step: the field opening, then rolling the births, the designer designing, the members prepared so far and the Animas dressed so far. In high contrast nothing is built and no field opens.
  3. Stand a statue in front of each Anima where its farthest-reaching held item wants it, never nearer than just outside its body and never farther than 5 board squares, the bounds of `/anima-all-weapons`: at the depth of its strike for a rigid melee item, measured on that Anima's own pose of the strike; at the rope's reach for a flexible one; inside the ring for an aura; and 5 board squares out for shots and waves, closer when the item cannot carry that far (§13.74 in [Algorithms](https://set.world/skills/algorithms)). A melee item whose reach falls short of a farther statue still swings, but shows no hit.
  4. Keep the designer's places: 4 to a row, columns 1.1 standing heights apart. Every team stands on the same grid, centred on the board: each row behind the front one steps back by the farthest any practice statue may stand (5 board squares) plus 0.45 standing heights, so every row's statues fit in the gap before it, no statue stands inside another row, and no row moves or drifts off centre while the team arrives. Turn the whole formation 0.5 radians from facing the camera, so in the home view each statue stands to the side of its Anima rather than straight in front of it.
  5. **Start** plays every Anima's attacks in place at its own tempo: its derived attributes with AnimaSystem applied ([Derived stats](https://set.world/skills/anima-derived-stats)) and each held item's mass with its item quality, alternating complete actions of its two held items, or the punch with empty hands ([Animations](https://set.world/skills/anima-animations)), every delivery aimed at its statue. Each hit on a statue shows its undefended damage from that Anima's attributes and the item's material hit power, the nunchaku and drill once per mark of their volleys; a stamina ring shows the stamina it restores in blue, and an instrument plays with no ring and no number. **Stop** returns every Anima to rest.
- **Controls.** The designer list, **Orbs per item**, **Level**, **Place team**, **Fight in simulator**, **Start** and **Stop**. Drag to orbit, Shift and drag to pan, and scroll on the focused field to zoom; arrow keys turn and tilt, plus and minus zoom, and Home returns to the full view. The floor and camera are `/anima-scene`'s: each Anima covers as many board squares and as much of the screen as it does there, the camera opens centred on where a full formation stands, and placing an Anima never zooms or moves the view. `?model=<name>` opens straight on one designer, ready for **Place team**, without showing another first: `?model=claude-opus-5-5` for `claude-opus-5-5`, `?model=claude-fable-5-1` for `claude-fable-5-1`, `?model=gpt-6-astra` for `gpt-6-astra`, `?model=claude-sonnet-5-5` for `claude-sonnet-5-5`, `?model=claude-haiku-4-5-20251001` for `claude-haiku-4-5-20251001`, `?model=claude-haiku-5-5` for `claude-haiku-5-5`, `?model=gpt-6-sol` for `gpt-6-sol`, `?model=gpt-6-luna` for `gpt-6-luna`, `?model=gpt-5-6-sol` for `gpt-5.6-sol`, `?model=gpt-5-6-terra` for `gpt-5.6-terra` and `?model=gpt-5-6-luna` for `gpt-5.6-luna`; the exact model id works too, and an unknown name opens the first designer. A change of designer or settings returns every Anima to rest; Start and Stop work while a team stands on the floor.
- **Limits.** Practice, not a fight: no Anima leaves its place, no stratagem is read, nothing takes damage and no roll is drawn. No request follows the births, and nothing is saved.
- **Fetch.** A fetch returns the designers with their versions, summaries and rationales (`props.pageProps.teams` in the page's `__NEXT_DATA__`), the chosen designer, the opening level and orbs per item and the 16 birth seeds; the designs and the field run in a browser.
- **Source.** `@pages/anima-model-teams.tsx`, `@components/AnimaModelTeams.tsx`, `anima-scene/team-practice.ts`, `anima-scene/team-practice-stage.ts`, `anima-scene/team-constructors/` (each designer with its summary and rationale, and the catalog's query names), `anima-scene/team-design.ts`, `anima-scene/generation.ts`, `items/weapon-showcase.ts`, `items/outfit.ts`, `structures/practice-statue.ts`.

The designers' rationales, each in its own words:

- **`claude-opus-5-5`** (`claude-opus-5-5-team-5`)
  - I started from the question of what still works at the top of the sliders, where two designed teams will most often meet. A level-99 Anima already carries about 70% physical reduction from its stats, with armor and global resistance on top, so an ordinary hit lands a small fraction of its base hit. Any designer who thinks about statuses can also buy effect resistance up to the contest ceiling with a handful of cheap words, and that is why I gave up my stone team: one resistant opponent answered the whole idea. PIERCE! is the one result that skips nearly all of it. It cannot be dodged or glanced, and it ignores physical reduction, armor and global resistance alike; only a block or a parry stops it. Outcome damage words then add their share of the base hit to every pierce, up to 150%, and critical damage words add theirs to every critical hit, so a critical pierce is worth many ordinary hits.
  - So every weapon on the team can pierce. The jian is lighter and quicker than the rapier for almost the same chance, and it costs less stamina an action, which matters because stamina, not tempo, is what caps a sustained attack. The harpoon has the highest pierce chance of any item, reaches about ten units at the top level, and a hit that leaves its target alive drags it toward the Whaler if the Whaler is at least as strong, which brings it to the Dialecticians. In the offhand the Dialectician carries a kite shield in the heaviest material the orbs allow, because a heavier shield blocks more, and the Whaler carries a second jian, so it still pierces when a foe reaches it and strikes with it whenever a foe is in reach while the harpoon reloads.
  - Eight Dialecticians hold the front two rows and eight Whalers the back two. No ally ever absorbs a shot, so the harpoons fly through the front line. Each class reads a stat block as a weighted sum of the logarithms of what it needs: the Dialectician its physical damage, critical chance, health, stamina, attack speed and physical reduction; the Whaler its projectile damage first, then physical damage, critical chance, health, stamina and the charge speed the harpoon fires at. I score all sixteen births for both, standardise each class's scores so the two compare fairly, and give each place greedily to the birth that fits it best relative to the others. Each role carries the name of its mainhand's class, the jian's Dialectician and the harpoon's Whaler.
  - The level's points go out in whole grants, in at most ninety-six steps, each to the primary stat that raises the class's reading most from where that Anima already stands. Because the reading is a sum of logarithms, it spreads itself between damage and health, the two things a fight of pierces trades, and it counts critical chance at double, since with critical damage words stacked a critical pierce is worth about three plain ones.
  - Words decide most of this team. For every word the orbs allow, I price what it grants at the best quality they buy and take, one word at a time, whichever adds the most value against each effect's real cap in the rules. A word stops being worth anything once its effect is full, and a drawback costs something only if it takes a total below what is needed. Pierce chance and pierce damage come first, and the piercing prefix carries both until they cap. Effect resistance comes next, up to the contest ceiling less what the Anima's own stats already give, so no foe's status can land on it, whether it petrifies, seduces, frightens or counts down. After that each class wants its own: the Dialectician block chance for its shield up to its cap, then VIGILANCE when struck, critical damage and STALKING; the Whaler FRENZY when struck, critical damage, STALKING and stamina recovery. The choice follows the settings: at level one with no orbs every word is Plain and resistance takes most of the suffixes, while at the top the totals cap and the buffs fill in.
  - I lean on buffs gained when struck: they roll when a hit lands on the bearer and once as each fight starts, and only a striker's effect resistance beyond the bearer's own effect chance cuts them, which between equals is nothing. VIGILANCE matters most at the front. A landed hit normally cancels a thrust and stops new ones for 2.4 seconds, and a vigilant Anima keeps attacking through it. FRENZY speeds the Whaler's actions and divides its reload and recovery, which is what holds a harpoon back. STALKING doubles the stalker's opening hit on a foe facing away, which a crowded melee hands out often, and stamina recovery and VIGOR keep the thrusts coming, since stamina is what runs out first.
  - Every item takes the best quality the orbs reach, because quality sets how many points each word spends. Each weapon takes the material with the most hit power, the lighter one on a tie, the shield the heaviest, and every worn piece the material AnimaSystem rates best overall, which at the top is godhair: the lightest material there is, protecting nearly as well as the heaviest metals, so the armor slows neither walking, attacks nor stamina recovery. A pierce ignores armor in any case, so I spend nothing on weight.
  - The Dialectician picks its shield back up if a DISARM! knocks it away, strikes any foe within melee reach, and otherwise advances at a run on a foe that targets it, then on a foe targeting an ally, then on one its allies already target, then on the nearest it can see and the nearest. I tried Guard-advance in my reasoning and dropped it, because each guarded hit costs 40 stamina and the walk is slow, while the shield and its words already block most blows from the front. The Whaler picks its jian back up, strikes anything within melee reach, and otherwise shoots: at whoever targets it, at whoever targets an ally, at the weakest foe so that pierces finish wounded Animas, then at the nearest it can see, advancing only when no foe is in view. Shooting at foes that are already engaged gives the harpoons slower targets and turns pierces into kills sooner.
  - I wrote this without running a fight, as the protocol asks, so it is a prediction. Its weak points are visible in the rules. A shield's block and a parry both stop a pierce, so an opponent with heavy shields and block words of its own takes far fewer of them; the team carries no healer, so a long fight favours a side with rings, though those rings heal my Animas too; and at level one with no orbs the pierce chance is small and the team leans on its numbers. I also saw that RESURRECTION can be gained again every time a bearer drops under half health, so enough wounded-buff words might bring an Anima back over and over; I treated that as something to report, not to build on, and took none of it.
- **`claude-fable-5-1`** (`claude-fable-5-1-team-2`)
  - The thesis. Every defence in this system is a reduction, a dodge, a block or a glance, and a PIERCE! walks past all of them but the block and the parry: it cannot be dodged, cannot be glanced, and ignores physical reduction, armor, global resistance and the cut of a Guard. A team that can be worn down by ordinary hits can be built not to be, with reductions that compound toward their ceiling and a healer behind them; a team that is pierced has only its health. So the plan is to thrust, with the longest pike there is, over a wall that is hard to wear down, at bodies that have been knocked flat and cannot block the point, and to put every spare word into making the thrust land more often and hit harder when it does. Against that I set the one thing that undoes any plan, a disabling status, and buy resistance against it before anything else.
  - Why pierce and not a status. A status plan has to win the effect contest on every hit, and the contest is a difference of two chances that the defender can push to its ceiling with the same words I would use to push mine. Damage that cannot be reduced has no contest: a pierce lands its full base hit against the best-armoured foe and the plainest one alike, and the pierce words I wish for raise both its chance and the damage of that outcome. The sarissa is the longest thrusting polearm, and the pierce chance follows the shape of the item within its kind, length and thinness, so the longest pike stands near the top of its kind. Its reach also decides who strikes first: a foe is in melee range when it is within the longer of the two reaches, so a pike opens every exchange.
  - The five classes. Every role is the class of the mainhand it holds, read from the class table in code, so a changed weapon renames the role. Four Phalanxes hold sarissas behind heater shields. Two Siegebreakers swing mauls behind heater shields: a maul is heavy enough to block on its own, so it stacks its block with the shield’s, and a heavy blunt blow can CRUSH!, flattening the foe where it stands for a fixed hold, longer with the crush duration words they wish for. Four Wizards carry a tome, whose Rupture ring knocks every foe inside it down into a tumble, and a sarissa in the other hand to thrust at what is tumbling: a knocked-down Anima stays a target until it is back on its feet, the hits on it are never blocked and it cannot parry, and a pierce on it meets nothing else. Four Bounty Hunters carry crossbows, whose bolt flies faster than an arrow on the same reach and whose draw never depends on strength, and a rapier for whoever closes, a thrusting sword that also pierces. Two Cantors play flutes, whose ring heals health and restores the stamina of everyone inside it, and carry a crossbow to shoot between songs.
  - The formation. Front row: Phalanx, Siegebreaker, Siegebreaker, Phalanx, so the two shields that also block with their mauls stand in the middle where a charge lands, and the pikes on the corners thrust in from the flanks. Second row: Wizard, Phalanx, Phalanx, Wizard, four more long reaches thrusting over the front row’s shoulders, with the Rupture rings on the edges where a flanking foe arrives first. Third row: Wizard, Bounty Hunter, Bounty Hunter, Wizard, two shooters sheltered in the centre and two more rings on the edges. Back row: Bounty Hunter, Cantor, Cantor, Bounty Hunter: the two healers stand in the middle of the back, the farthest from the enemy and the nearest to the centre of the formation, so their rings cover the most allies, with a shooter on each side of them.
  - Who stands where. Each place has a fit score over the birth’s final stats above the minimum: a Phalanx wants strength and vitality with some dexterity and agility; a Siegebreaker vitality above strength; a Wizard vitality, then strength and intelligence evenly, since it thrusts as much as it casts; a Bounty Hunter dexterity first, then strength, agility and vitality; a Cantor intelligence first, then vitality and agility. Every pair of place and birth is scored, the pairs are sorted from the best fit down, and each is taken when both its place and its birth are still free, so the strongest fits are honoured first and no birth is used twice. The births’ traits are not read: the stats they produced already carry them.
  - Growth. The level’s points are spent one whole point at a time, four grants to a step. At each step every primary stat is tried and the one that most raises a fight value is taken. That value is the logarithm of the member’s output multiplied by its effective health, so it rewards multiplying the weaker side rather than stacking the stronger. Effective health is maximum health divided by the damage that gets through, weighted seven parts physical to three parts magic, and divided again by the share of hits a foe of middling clarity fails to land through the dodge. Output is physical damage for the melee plans and magic damage times cast speed for a Cantor, with the critical chance, the chance of landing through a foe’s dodge, the square root of stamina as the pace a fighter can keep, and a share of attack speed or charge speed. A Wizard’s output takes the square root of cast speed too, since it casts and thrusts in turn. Because reductions compound toward a ceiling and health multiplies them, the search mostly grows vitality first and the plan’s damage stat after, and it keeps choosing by the readings rather than by a fixed split, so a birth that arrived strong in one stat grows the other.
  - Materials and quality. Every item takes the best quality the orbs buy, read by its quality factor. A held item takes the material with the highest hit power the grade allows, the lighter one on a tie. A worn item is scored by the logarithm of its protection weighted seven, its ward weighted three and its weight drag weighted fifteen, so a material that slows walking, attacking and stamina recovery through worn weight must buy a great deal of protection to be chosen; again the lighter wins a tie. The orbs decide the grade and the quality; these rules only pick within them, so at zero orbs the team wears the plainest grade and still chooses the lightest protection in it.
  - Resistance before everything. The one way to lose a fight at once is a disabling status: a sleeping or petrified Anima does not think. So before any kit word, each member computes what it would take to be safe from the cheapest disabling word, SLEEPING, at these settings: the chance fifteen items could carry of it at this quality, plus the chance the strongest possible caster adds from its stats, with every stat at the maximum and intelligence raised by the level’s whole pool, plus a margin of ten points, all capped at the contest ceiling. From that it subtracts the resistance the member already has from its attributes and its resolve reading, and the remainder becomes its effect resistance wish at the heaviest weight any wish carries. It is a target, not a guarantee: at low quality a few resistance words reach it, and at high quality the ceiling means both sides can be full and nothing lands.
  - How words are chosen. Every prefix and suffix is read by what it grants, through the word tables and the grant amount at the chosen quality, never by name. Each plan has a list of wishes, a target amount and a weight for each grant key, and a word is worth the sum over its grants of weight times the share of the remaining room it fills, where room is the target, capped at the effect’s ceiling, less what the member’s earlier words already gave. A word with a drawback is charged for it at the larger of the drawback’s own wish weight and three, and refused outright when it would push a reading below three tenths of its cap. Worn items choose before held ones, so the body buys resistance and protection and the hands keep their words for the strike, and a worn prefix is read in its worn form. Ties go to the earlier word in alphabet, so the choice is the same every time.
  - What each plan wishes for. Everyone wishes for stamina recovery and maximum health first, then stamina, physical and magic protection, regeneration, dodge, a chance bonus, all stats, vitality and walk speed. Every melee plan adds Vigilance when struck and when wounded, lifesteal, critical damage and chance, clarity, physical damage, attack speed, strength and thorns. Phalanxes and Wizards put their heaviest wishes on the pierce chance and the pierce damage; Wizards add magic area and cast speed, so the Rupture ring is wider and comes sooner. Siegebreakers wish for the crush chance, crush damage and crush duration, block chance, thorns and more physical protection than anyone. Bounty Hunters wish for ranged damage above all, then critical chance and damage, clarity, Keen when struck, a little pierce for the rapier, dexterity and a little Vigilance. Cantors wish for cast speed above all, then magic area, intelligence, dodge and a little Vigilance.
  - Why Vigilance. A pike thrust and a Rupture cast are slow actions, and a hit that lands cancels an unfinished action. Vigilance lets a hit land its damage but never pushes, staggers or knocks down the Anima and plays no hit reaction, and it stops a CRUSH!. Granted when struck or when wounded, it keeps a Phalanx or Wizard on its feet and in its reach while it is hit, instead of pushed out of range or flattened mid-thrust. A Bounty Hunter wishes for Keen when struck instead: its bolts then bend onto the target wherever it moves and strike surely.
  - The stratagems. Every stratagem but a Cantor’s begins the same way: throw a WorldSphere it holds at the nearest foe in view, grab one lying within its own melee reach, guard below thirty percent health while a standing foe remains and stamina allows, and go back for a disarmed offhand. A Phalanx then strikes any foe in melee range, strikes whoever targets it, and otherwise advances on a foe targeting an ally, then the nearest in view, then the nearest at all, so it never stands idle. A Siegebreaker strikes in melee range, strikes a foe that is targeting an ally, protects an ally below forty percent health by getting between it and its nearest threat, strikes whoever targets it, and advances. A Wizard answers each case with both hands, mainhand then offhand, so a later Offhand rule adds the pike to the Rupture: in melee range, at a foe targeting an ally, at the nearest in view and at the nearest at all; with both hands allowed, whichever hand is ready and can reach acts, and the other follows while the first recovers, so the pike thrusts during the Rupture’s long cadence. A Bounty Hunter draws its rapier against a foe in melee range, otherwise shoots the foe with the lowest health, then whoever targets it, then whoever targets an ally, then the nearest in view, then the nearest, and only strikes the nearest when nothing can be shot. A Cantor fetches its crossbow if disarmed, plays its ring for an ally below sixty percent health, then for an ally below forty percent stamina, then for itself below seventy percent health, runs from any foe that targets it, and otherwise shoots the nearest foe in view or the nearest at all. It grabs no WorldSphere, since grabbing would set its crossbow down, and it never guards: running keeps it alive and playing.
  - Across the scales. At level one with no orbs there are no points to grow and only the plainest grade and quality; the plan then rests on the gear, which is free: the reach of the sarissa, the knockdown of the tome, the heal of the flute and the crossbow’s bolt do not depend on the orbs. As the orbs rise the quality raises every word’s amount, so the resistance target is reached with fewer words and more go to the kit, and the grade raises the hit power of every pike. As the level rises the growth search has more to spend and the resistance target rises with the strongest caster it imagines, since that caster’s intelligence grows with the same pool.
  - What could beat it. A team of shields that guards: a shield still blocks a pierce, Guard stops the front arc’s projectiles, and a Guard that holds while its healer plays could outlast the thrusts. A status that is not SLEEPING and lands through the margin, such as a seduction that turns a Phalanx on its own line, or a petrification whose resistance my target did not reach at a middle quality. A team that moves faster than the formation and gets behind the shields, where a shield blocks nothing. Fire that burns the slow front row while it waits for melee range. And a team with longer reach than mine does not exist, but a team that kites at crossbow range never enters it, and the Bounty Hunters alone must answer it.
- **`gpt-6-astra`** (`gpt-6-astra-team-2`)
  - My plan is sustained pressure from a formation that can survive interruption. A weapon contributes nothing while its bearer is disabled, recovering from a hit or unable to pay for another action. I therefore value vigilance, effect resistance, stamina recovery and healing alongside damage. These are selection priorities, not promises that every member obtains every buff. The design chooses from the actual word grants available at the selected quality.
  - The front row carries four rapiers with pavises. Both middle rows place rifles on the outside and Wand-and-Orb pairs inside. The back row places Flutes outside and Scrolls inside, all with Canes. This gives four front-line bodies, eight primary damage dealers and four support members. The starting positions encourage a protected centre; they do not enforce a permanent formation once stratagems move the members. Labels come from each chosen mainhand’s existing class, so the preview and the prepared character agree.
  - The rapier offers thrusting reach and a chance to pierce defenses. The pavise supplies frontal physical protection without the Door’s much greater burden. The front line uses its mainhand against a foe already in melee range, protects a critically wounded ally when that immediate threat is absent, and otherwise approaches behind its shield. Guard-advance cannot attack, so the melee rule must precede it. At critically low health it guards to buy time for support. Magic and attacks outside the shield’s front remain threats, and guarding spends stamina when hit.
  - Rifles deliver physical volleys and carry rapiers for an enemy that reaches melee range. Their ranged rules use Kite, allowing movement between shots without pretending they can fire while moving. Wands provide forward magic waves; Orbs provide nearby Repulse damage and stamina drain. This gives the team different damage channels and delivery shapes. The wave casters backstep when a foe is in melee range and can use either hand there. I accept the Wand’s charge and interruption risk instead of treating its light weight as free damage.
  - Two Flute bearers prioritize severe wounds, then less severe wounds and critically low allied stamina. Two Scroll bearers prioritize Death, petrification, a seduced target, other debuffs, and depleted stamina. Scroll cleansing is a chance, not a guaranteed cure. A seduced Anima is found through a foe condition because allegiance has changed. Every support member carries a Cane for missile pressure when no support condition decides, and backs away from a nearby foe after its support priorities. A ring reaches enemies too: assisting a crowded front can help the opposition. Four support places also mean four fewer dedicated attackers.
  - Conditions select one candidate and the first usable rule decides. They cannot express arbitrary combinations such as the nearest wounded ally who is also safely separated from enemies. Sleeping allies are down and are not directly selectable by ordinary status conditions; a ring cast for another nearby target may reach them, but I do not claim a reliable targeted sleep rescue. Petrified enemies can consume attacks, and this design has no general exclusion filter for them. Frail members guard while unable to attack. Disarmed members recover their offhand, and damage dealers collect a WorldSphere only when one is within their melee reach. A held sphere is thrown before other voluntary work.
  - Ranged damage dealers first handle an immediate melee threat, then prefer an Exposed foe, a Frail foe, and a foe already targeted by an ally. Their remaining rules find visible or threatening enemies and ultimately the nearest foe. Supports use similar focus priorities when their Canes are free to attack. This is coordination through the conditions the system provides, not a global order or a guarantee that every member chooses the same target. The front line keeps its guarded approach instead of abandoning it merely because a distant enemy targets an ally.
  - I read the reconciled birth stats, which already include advantages and disadvantages. For each job I score the attributes it needs, compare each birth with the group’s mean, and subtract its strongest remaining alternative use. Scroll and Flute jobs are assigned first, followed by the front line, rifles and wave casters. This is a deterministic greedy assignment, not a proof of the best allocation. Talent prose adds no assumed combat mechanic. The same births and settings always produce the same team.
  - Each growth step goes to the primary stat that most improves a weighted score of health, mitigation, global resistance, stamina, movement, the role’s damage channel and its action speed. Damage dealers also value clarity and critical chance; the front line gives health extra weight. The score uses the scene’s actual attribute readings and logarithmic value, so an already strong reading has less reason to absorb another point. Growth is spent in whole allowed grants, batched by one level’s allowance, until the pool is exhausted. Level one spends nothing. This is a compact planning heuristic, not a combat simulation.
  - Every item uses the best affordable quality. Worn materials balance physical protection, ward and the movement, attack and recovery cost of a full outfit on that member’s grown body, with a stronger physical preference for the front line. Held materials balance hit power against material mass; the Orb is exempt from that mass penalty because its held mass ignores material. This material score is deliberately inexpensive and does not claim to model every weapon’s complete handling cycle. Circlets, ailettes and flags establish the team’s appearance and OpenAI heraldry. Other worn shapes use their slot’s first available gear: their shape does not change the protection calculation.
  - For every slot I score allowed prefixes and suffixes by the marginal value of their actual grants. Worn prefixes use their worn forms; held prefixes keep their on-hit effect attached to that hand. Existing secondary-stat readings seed the totals, positive grants lose marginal value as they accumulate, caps limit their value and drawbacks subtract from it. Primary-stat preferences follow the role’s current attribute needs, while the appeal of an all-stat bonus declines as the grown stats rise. Offense, support and front-line jobs have different priorities. Exposed, Blind, Decay and Frail rotate as additional offensive preferences by formation place; none is a mandatory stack. This greedy choice does not search every complete outfit or guarantee that a low effect chance overcomes resistance.
  - A fast collapse of the support row, sustained magic into the shield line, strong effect resistance, or repeated disruption before vigilance takes hold can defeat the plan. Chasing a shared target can stretch the formation; healing rings can benefit enemies; shield advances can be slow and expensive under fire. Different levels and orb budgets change the chosen growth, materials, quality and words, but the team composition stays fixed. This preview explains and displays the design. It does not establish win rates, and I have used no fights, opponents’ constructors or comparative results to choose it.
- **`claude-sonnet-5-5`** (`claude-sonnet-5-5-team-1`)
  - My thesis is that this fight is decided by who keeps acting. A damaging hit, however small, cancels the action its target is in and blocks its next one for 2.4 seconds, unless the target is guarding or has Vigilance, and a hit that is dodged, blocked, parried or glanced does none of that. So the team that wins is the one that is hit least, is not staggered when it is hit, and refills its own health and stamina. I built three parts around that: a front rank that is hard to hurt and hard to stagger, a middle that hits fast because nothing interrupts it, and a back rank that feeds everyone.
  - Every role wishes for Vigilance, the effect that removes the hit reaction, the push, the knockdown and the crush: the buff-when-struck words, which also roll once as the fight begins, and the buff-when-wounded words below half health. The search takes as many as the quality of the items allows, up to the rule caps of fifty percent when struck and sixty when wounded. A Vigilant Anima stays in the mode it is in, so a Cantor under attack still finishes its ring and an Archer still releases its arrow. Every other wish is weighed against that one, and none of them is a list of words: each is an effect, and the code finds the words that carry it.
  - I do not fix a stat split. For each member the code reads the attributes the rules give a stat block and values them together as the logarithm of its damage (with the damage words weighed against foes whose protection is 10, 50 and 90 percent), of how often it can act (the lower of its tempo and its stamina recovery, the fighters' recovery counted one and a half times because the choir feeds them, and the Cantors counted by tempo alone because their own rings feed them), and of its durability: health over its physical and magical reduction and global resistance, its dodge discounted by a foe clarity of 35 percent, its glance, its shield block and parry, and its protection words weighed against foes whose damage words are 20, 70 and 120 percent. Walking speed and initiative count a little for everyone. The weights are the role: the Peacekeepers value durability at 1.0 and damage at 0.35, the strikers value damage at 1.0 and tempo at 0.6 to 0.8, the Cantors value their healing at 0.9 and their durability at 0.7. Each grant of the level is then given, in blocks of at most 80 steps, to the primary stat that raises that value most. Because the reductions saturate near 85 percent while damage and health grow in a straight line with stat points, the best split is a mixed one: mostly vitality with agility for the wall, strength and dexterity for the strikers, dexterity for the Archers, intelligence and vitality for the Cantors.
  - The thirty word cells (a prefix and a suffix on each of fifteen items) are filled after the draft growth, at the best quality the orbs buy for every item, since quality only adds points. For each cell the code knows what every word would give there: a held prefix keeps its effect on hit for that hand, a worn prefix takes its worn form (damage becomes protection, an effect on hit becomes one given to the attacker), and a suffix acts anywhere. It sums the grants under the rule caps and searches the cells, in up to two passes, for the word that raises the member's value most. Effects that multiply (health, stamina, speeds, recovery) are valued as logarithms, so the Sin suffixes pay for their drawbacks honestly and are taken when the drawback falls on something the role values little; protection and damage words are valued against the foe models above, because they subtract from or add to one pool; stat words are valued by the growth gradient, so the thirty-point cap on a stat is filled where it pays; and effects on hit are wishes whose targets are raised by the resistance of a reference foe less the member's own effect chance, so they are taken only where they can land. The growth is then redone with the words' stat points and percentages in hand.
  - Armour is not a list either. For every worn slot the code reads each material the grade allows at the best quality and searches the whole outfit, one slot at a time until nothing improves, for the armour factor, the ward factor, the glance and the load against the member's carrying capacity after growth, each weighted by role: at the top grade that is godhair everywhere, and with no orbs it is whatever cloth and wood the lowest grade holds. The shoulder and back slots take the gear that carries heraldry (ailettes and flag), found by asking the armour catalog, so the team shows its maker's colours. Held materials are chosen by hit power over mass; a shield takes the heaviest material no heavier than steel, because its block grows with its mass but its weight slows the other hand.
  - The Peacekeepers carry a tonfa and a pavise. The tonfa is a parrying tool, so a melee hit from the front can be parried at a shield's chance, at twice the stamina, and answered with a free strike; the pavise blocks physical hits from the front and, with the block and parry words the search may add, stacks with it; neither costs health when it works, and neither staggers. They take the first blow, regenerate, and with Vigilance they stay on their feet. The Assassins carry a katar, a quick fist weapon (about a second and a quarter a stroke, the longest reach of the quick ones) and among the cheapest in stamina for the damage it deals, which matters most at low levels where stamina binds; at higher levels the same quick stroke is what turns attack speed words into damage. The Fencers carry a rapier, whose thrust can pierce: a pierced hit cannot be dodged or glanced and ignores damage reduction and the guard's cut, which is what is left to hit a foe who is armoured and reduced to the limit. The Archers carry a longbow and shoot from behind the wall. The Cantors carry a flute, the lightest and quickest ring, which heals and restores stamina to everyone inside it, the caster included, and a scroll, whose ring restores stamina by the Cantor's magic damage and may cleanse debuffs.
  - The formation puts the four Peacekeepers on the front row, the four Assassins behind them, the Archers on the flanks of the third row with the two Fencers between them, and the four Cantors at the back, where the rings reach forward and the Cantors are the last to be met. Births are assigned by fit: for each role a weighted mean of the stats it wants (vitality and strength for the wall, strength and dexterity for the Assassins, dexterity for the Fencers and Archers, intelligence and vitality for the Cantors), and the place whose best birth is furthest ahead of its second best is filled first, so a scarce stat is spent where it matters.
  - Every fighter's stratagem ends in a rule that names the nearest foe, so a fighter never falls back to its routine while a foe stands. The Peacekeepers pick up a dropped shield first, guard below 30 percent health, strike a foe that targets them, then one in melee range, then one that targets an ally, then the nearest, always with the mainhand so the shield is never spent on a bash. The Assassins and Fencers take a WorldSphere within reach and throw it, pick up a dropped buckler, guard below 20 percent, and then answer a foe that targets them, one in melee range, one that targets an ally (which is how a Cantor under attack is helped), an exposed foe, a shocked foe (Assassins), one an ally already targets, and the nearest. The Archers take a sphere, pick up a dropped buckler, guard below 30 percent, and then Kite, which keeps them at the longbow's range, at an exposed foe, at one an ally targets, and at the nearest. The Cantors pick up a dropped scroll, guard below 20 percent, then heal: the flute at the nearest ally under half health with the scroll added for the same ally, the scroll for any debuffed ally and any ally below 40 percent stamina, then the flute below 80 percent health and 70 percent stamina, so both rings are free to alternate while one is cooling.
  - What I expect could beat it: a team whose clarity is high enough to cancel the dodge I count on, since I assume 35 percent; a team that breaks the wall's gear, since its block, parry and armour all depend on it; a team whose protection and damage words are both at the cap and who pierce, since the Fencers are only two; and a team that lands Petrified, Death or Frail on the Cantors through their resistance, because losing the choir loses the stamina engine. At level 1 with no orbs there is no growth and every item is Plain, so the thirty points a word may add to a stat are the only growth, and the gap to any other team there is mostly decided by births.
- **`claude-haiku-4-5-20251001`** (`claude-haiku-4-5-20251001-team-1`)
  - My design focuses on a balanced team that wins through clear role specialization and layered defense. Every Anima grows the stats that matter most for its position: frontline Animas build vitality and strength for holding ground, melee fighters balance strength and vitality with some dexterity, casters prioritize intelligence with vitality, ranged fighters emphasize dexterity and agility, and support focuses on intelligence and vitality.
  - The formation places four frontline Animas in the first two rows, four melee and casters in the middle, and eight ranged and support in the back two rows, creating a broad defensive base. Frontline members hold longswords and heater shields to maximize their reach and block chance, melee fighters use lighter hatchets and bucklers for speed, casters carry staves to focus their magic, ranged fighters hold bows with dagger backups, and support plays flutes with wands.
  - Every role except backline-support begins with the same key actions: throw a WorldSphere at the nearest foe, grab one within reach, guard when health falls below thirty percent, and fetch a dropped offhand. This ensures consistent base behavior. Frontline then strikes anyone in melee range and otherwise advances on foes targeting allies. Melee fighters target the weakest foe and protect low-health allies. Casters respond to all foes with their main hand. Ranged fighters focus the weakest foe from distance and switch to melee if pressed. Support plays healing and stamina restoration for allies below thresholds and runs from direct threats.
  - Word selection follows each role: frontline members prioritize physical reduction and block chance for durability; melee fighters want physical damage, critical chance, and lifesteal; casters focus magic damage and cast speed; ranged fighters seek attack speed and critical effects; support maximizes healing output and spell area. All roles wish for base health, stamina, and recovery.
  - At zero orbs all members fight with their chosen gear alone, which already provides meaningful differences: a longsword has longer reach than a hatchet, a staff casts area spells, a bow shoots from distance, and a flute heals. As orbs increase, better materials improve hit power and protection, and higher quality brings more from item words. As level increases, growth points are spent on the stats each role multiplies: frontline pours into vitality then strength, melee builds strength then vitality, casters invest intelligence then vitality, ranged favors dexterity then agility, and support splits intelligence and vitality.
  - The team lacks elaborate synergies or individual genius because its strength is structural: it presents a wall, delivers consistent damage from three angles, and keeps itself alive. It wins against uncoordinated foes through superior positioning and against coordinated teams through the redundancy of having members with different strengths that all work together toward a shared purpose.
- **`claude-haiku-5-5`** (`claude-haiku-5-5-team-1`)
  - I decided before any code that this team wins by protection and sustained fire rather than by one strong line. The wall in the first row is there to keep the back row alive, and the back row is there to do the damage, so the formation places each family where its job can be done.
  - The first row is four tanks in heavy armour. Two longswords sit in places 0 and 1 with a heater and a shield, a spear sits in place 2 with a kite shield, and a halberd sits in place 3 with a pavise. Their outfit is a full plate set from the heavy list, the helm, gorget, cloak, pauldrons, breast plate, belt, legplates, sabatons, vambrace, gauntlets and signet and ring. Tanks take the births with the most vitality, then strength, then agility, because health and the ability to hold a line matter more here than speed.
  - The second row is four melee fighters in light armour: a katana with a dagger in place 4, a saber with a dagger in place 5, a maul with a targe in place 6, and a katar with a kris in place 7. Light armour is there so they can move and recover quickly, and they take the births with the most strength, then agility, then dexterity. Their stratagem goes to a foe that is exposed first, then to melee range, then charges the lowest-health foe, and otherwise advances on the nearest visible foe.
  - The middle two rows are the healers and casters. Places 8 and 9 are healers: a harp and a staff in the mainhand, each with a flute in the offhand. I took the harp and the flute to be the ring items that heal and restore stamina, reading the combat skill's list of Play, Strum and Blow ring actions without checking which item carries which action, so this is the one assumption in the team that the code does not verify. They take the births with the most intelligence, then vitality and agility. Their stratagem heals a debuffed ally with either hand, heals an ally below half health or below seventy percent with the mainhand, restores an ally below forty percent of stamina, and backs away from any foe in reach. They run if two foes target them. Places 10 and 11 are casters, a tome with a grimoire and a rod with an orb, which take the intelligence-heavy births. They fire at the nearest visible foe, step back when a foe reaches them, and run below thirty percent health.
  - The back row is four archers: a longbow with a knife in place 12, an arbalest with a buckler in place 13, a crossbow with a knife in place 14, and a shortbow with a dagger in place 15. The buckler gives the arbalest a shield for shots from the front. These births take the most dexterity, then agility, then strength. Their stratagem kites any foe that reaches melee range, fires on exposed foes, kites the nearest visible foe, and fires at the nearest foe otherwise. Melee is their last resort, and running is their answer below thirty percent health.
  - Each member gets the best material its orbs buy in each slot. The orbs fix the highest grade, so the code takes the last material in the slot list the orbs allow, which is the highest tier, and the last quality the orbs allow, which is the best quality the lottery reaches often enough to be bought. At the lowest setting that is common material and Plain quality, and at the top it is the best material and legendary quality, so the team scales with the orbs and never asks for an item they cannot buy.
  - Prefixes and suffixes are chosen by what they grant to a family. Each word is read through its grants, the effects it gives on the item, and each family has a weight per effect. The tanks weigh physical and magical reduction, maximum health, block, glance and regeneration highest. The melee fighters weigh physical damage, critical chance and damage, and attack speed. The healers weigh clarity, stamina recovery and cast speed. The casters weigh magical damage and cast speed. The archers weigh ranged damage, attack speed and critical chance. The word with the highest weighted sum is chosen, and when no word adds anything the slot takes none.
  - Growth follows the same family weights. The level's stat points are split into whole grants in proportion to the family's weights, and any grants left over go to the stats with the largest remainders. Births are assigned to places by a greedy pass over every place and birth pair, so the highest fits go first: the births with the most strength, vitality or agility take the tank and melee places, the most intelligence takes the healers and casters, and the most dexterity takes the archers.
  - Each member's stratagem is one of five lists, one per family, and every rule names a condition and an act from the stratagem tables. The rules are ordered so that a member keeps its own job first: the tanks guard when low and protect a hurt ally, the melee fighters and archers handle exposed and adjacent foes before the nearest, and the healers heal before they strike. Every stratagem stays under the rule limit and uses only conditions and acts the format has.
  - What I expect could beat this team is a foe that splits its attention, such as a fast group that reaches the back row past the wall, or a foe that disables shields with disarms and keeps the tanks from guarding. I have not run any fight to check this, so the prediction is from reading the rules alone. The rationale describes this code and nothing else.
- **`gpt-6-sol`** (`gpt-6-sol-team-1`)
  - I put four shield carriers in front because their block and Guard choices can absorb the first physical volleys while the pike and spear project melee reach beyond the gladius pair. The gladii are the close anchors; the pike and spear make approaching that line costly. I let each fighter attack while stamina and health permit, then guard at a different low-health threshold. They reclaim a disarmed shield before continuing, prefer the foe threatening an ally or already engaged, and otherwise advance on the nearest visible foe.
  - I placed Tome, Grimoire, Torch and Eye behind them to bring different interruptions: Rupture, crossed and split waves, and stamina drain. Their wands give a second attack while a slower mainhand recovers. They advance and keep using the hand that can act, rather than waiting at their opening station for an opponent to enter a ring. Low-health backsteps buy space when the front is breached. I expect the knockdowns and stamina loss to create time for the rifle and wand line, and I accept that a foe with strong magic protection or effect resistance can blunt this part of the plan.
  - The two Rifles add longer physical reach and the two Canes and one double Wand supply magic pressure that shield Guard cannot block as a physical projectile. The rifle bearers target weakened or already engaged enemies; the casters use the same focus where their conditions allow it. They kite to their ranged reach, backstep when badly hurt, and recover a disarmed offhand. This mixes physical and magic damage so one protection profile is less likely to stop the whole rear rank.
  - Two Harps provide health rings from the rear. One carries a Scroll so a debuffed or exhausted ally can receive stamina and a chance of cleansing, and the other carries a Wand for attacks between heals. The Scrollmaster carries a Scroll and Harp, spending its first attention on debuffs and low stamina, then on health. Their healing acts name allies or themselves; the rings affect everyone inside, so I keep them behind the contact line. A flanker reaching them is a serious weakness, and their backstep rules can only make room while an enemy remains in view.
  - I assign each random birth by the weighted primary stats of the next formation job, using its reconciled final stats so traits have already moved the values. I then spend every grant by raising the stat furthest below that job’s desired share. Front jobs emphasize vitality and enough agility, strength and intelligence to endure both kinds of attack; controllers and healers emphasize intelligence and vitality; the Rifles favor dexterity and strength. At level one this keeps each birth unchanged, and at higher levels it spreads the granted points rather than pouring them into a single diminishing chance.
  - I choose the highest affordable quality because it improves protection, hit power, item mass and word strength together. For each allowed material I compare its actual AnimaSystem reading: held power against mass, or physical protection, magic protection and glance against worn mass. That makes the front accept more weight for defense and the casters prize lighter hands. I set ailettes and a back flag to carry OpenAI heraldry and keep the other worn gear in a consistent armored outfit; in this system the worn slot and material determine coverage and weight, so those names are not hidden combat bonuses.
  - I choose prefixes and suffixes from their grants at the affordable quality, score their useful amount for the role, and reduce the score as a reading approaches its cap. The front values health, both protections, block, glance and recovery; attackers value their damage channel, pace and control effects; supporters value area, casting, stamina recovery and survival. I give disabling effects a high value but limit the target amount of the strongest ones so other useful readings still enter the outfit. Worn prefixes use their worn form, while suffixes can help any slot land an effect. These are my predictions from the rules, not results from a fight.
  - The stratagems do not have a way to ask for the nearest foe who is not petrified, so an isolated stone target can still draw attacks. They also cannot identify which ally has the best future path into a healing ring. I kept those limits explicit in the plan rather than adding a rule outside the format, and I expect coordinated flanking, control-resistant casters or sustained pressure that separates the rear from the line to be its hardest opponents.
- **`gpt-6-luna`** (`gpt-6-luna-team-1`)
  - I built the team around a layered line that asks the opponent to cross long melee reach while facing twelve ranged attackers. The first four places carry pikes and shields: the pike is a melee weapon with unusually long reach and a heavy thrust, while the shield gives those front members a reason to guard when badly hurt and a chance to stop physical projectiles from the front. The next four and last four places use ballistae for their long reach and high single-action damage; the middle rear row uses rifles, whose volley cycles faster and can contribute several contacts in one action. I expect the line to punish slow approaches and to keep attacking when enemies are separated across the board.
  - The rear fighters carry war horns in the offhand. A horn’s Blow is a healing ring that restores health and stamina to everyone it reaches, so an ally below half health or suffering a debuff calls the horn instead of wasting its attack on a friend. The four pike fighters use shields in their offhands and keep their pikes for offense. Each team member has its own ordered rules: the vanguard retrieves a dropped hand, takes a nearby WorldSphere, guards at low health, and otherwise advances into pike range; the ranged members can fetch a dropped hand or sphere, aid wounded or debuffed allies with the horn, throw a sphere, and use their mainhand against the nearest visible foe. The order keeps rescue and support actions available while making the main attack the default.
  - I assign the strongest births to the pike and ballista places, because those weapons reward physical strength and the front line also benefits from vitality. Rifle places favor dexterity and agility somewhat more while retaining strength for their physical damage. At higher levels, I spend each available quarter point by comparing the effective scene attributes after a grant, valuing physical damage, both defenses, health, dodge, clarity, ailment resistance, speed, stamina recovery and effect chance. This recomputes from the birth stats, uses the full level pool, and lets diminishing returns shift later grants toward other useful readings instead of forcing one fixed stat ratio.
  - Every item receives the best quality the selected orb setting permits and a material chosen from that slot’s allowed grades. For held items I value the resulting AnimaSystem hit power while subtracting some handling weight. For armor I value both physical protection and ward, with a smaller penalty for mass. Suffixes are selected from the live word grants by their quality-scaled effect value; status words that can disable a foe, especially PETRIFIED, rank highly because each suffix acts on every hit regardless of slot. Held prefixes can add another on-hit status to the weapon hand. Worn prefixes are scored in their worn form, so they contribute defense or effects against a melee striker rather than pretending to inflict the held version. This applies the word table as it exists and remains useful if that table grows.
  - This design can be answered by a force that reaches the back line quickly, survives or resists the team’s repeated status attempts, or outlasts the heavy weapons’ stamina and reload costs. Ballista actions are costly and slow, pike members can be displaced or controlled before they settle into reach, and the war horn has to be close enough for its ring to help. The design has no guarantee against those cases; I chose the formation to make the opponent pay for each approach while the horns and armor preserve the line.
- **`gpt-5.6-sol`** (`gpt-5-6-sol-team-1`)
  - I built around a formation that can keep functioning while one part is countered. Four shield mainhands occupy the first row because Guard and Guard-advance turn physical projectiles aside from the front and reduce the damage and displacement that do land. Their scepters preserve an offensive magical hand for moments when guarding is less urgent. They protect wounded allies, hold nearby foes and otherwise advance behind their shields, so the line spends its durability on keeping access to the ranks behind it.
  - The second row is four Lancers with offhand shields. The lance gives reach and a piercing family attack while the shield gives each fighter a defensive second hand. They concentrate on exposed, stuck and low-health foes, protect a badly wounded ally when needed, and otherwise advance rather than use Charge, whose extra incoming damage is too dangerous against an unknown ranged formation. Their affix preferences favor physical damage, tempo, stamina returned by hits, exposure and pierce outcomes.
  - The third row alternates two hand cannons and two rifles. Hand cannons add a real projectile, knockback and a dome that can knock down clustered opponents; rifles supply repeated fast projectiles and reliable pressure on distant single targets. All four carry shields in the offhand, back away when wounded, avoid melee-answering targets, focus foes already named by allies and otherwise kite. I value ranged damage, clarity and stamina recovery here so shots land, matter and resume, while the two weapon families avoid making the entire rank answerable by one kind of defense.
  - The rear rank has two Harp Minstrels with Scroll offhands, one Tome Wizard with a shield and one Scrollmaster with a Harp offhand. The Minstrels heal damaged or debuffed allies and use their Scrolls when stamina is low. The Wizard sends Rupture knockdowns into foes attacking allies or already under focus, creating safe attack windows for the lances and firearms. The Scrollmaster restores stamina early and uses the Harp when health falls. These members retreat from close threats and favor intelligence, casting speed, area, recovery and defensive magic effects.
  - I assign births greedily by the weighted primary stats each place needs, preserving each random birth but giving the strongest natural fit the role that benefits most from it. I spend every quarter-point by repeatedly raising the role-important stat with the lowest current weighted return, which concentrates growth without blindly pouring the entire pool into one already-high stat. Shield bearers emphasize vitality, lances strength, firearms dexterity, and the rear intelligence, with secondary allocations for health, speed and action cadence.
  - For every item I choose the strongest affordable quality and score affordable materials from their actual AnimaSystem profile. Front armor favors physical protection, rear armor gives more weight to ward, held items favor action power, and mobile or casting roles penalize mass. Prefixes and suffixes are selected from their grants rather than their names. Repeating a word lowers its next score, so each outfit first takes its highest-value effects and then broadens into health, recovery, resistance, regeneration, vigilance, shielding and indestructibility instead of wasting all fifteen positions on one capped reading. I give no value to RESURRECTION because its wounded trigger can be regained after a rise and could repeat; the team does not rely on that flaw.
  - Every stratagem begins by recovering a dropped offhand and throwing a held WorldSphere before role behavior. The front reacts to focus fire with Guard, lances exploit control and exposure, firearms keep range and cooperate on targets, healers prioritize debuffs and missing health, and the cantor distinguishes stamina restoration from healing. The design is most vulnerable if control effects disable the rear before the shields establish contact, if attacks arrive from enough directions to bypass the frontal line, or if an opponent can outlast the shared healing and stamina engine while denying ranged actions.
- **`gpt-5.6-terra`** (`gpt-5-6-terra-team-1`)
  - I built this team around stable layers of contact. Four Bulwarks stand in the front row with a shield and door because their job is to make an opponent spend its first attacks on high vitality, physical reduction and guarding bodies. Their Protect rules converge on the ally with the least health, so the front line can cover a pierced opening instead of each defender pursuing a separate target. The four variants trade a little of the same core durability for petrification, resistance, and physical reduction, which gives the team several ways to survive an unknown damage mix.
  - I put four Dragoons immediately behind the Bulwarks. Pike has the long melee reach and high single-hit reading that lets this row attack across the opening created by the protectors. Their ordered rules reclaim a dropped offhand, exploit their own status conditions when they are already present, strike in reach, then lunge or advance. Petrify, bleeding, slowing, exposure, and precision make their hits useful against both durable and evasive foes while their strength, dexterity, vitality, and enough agility support force, accuracy, stamina, and arrival.
  - The third row is four paired Arbalestiers. Two hands preserve shot cadence and give their Kite rules a reliable ranged action. Their different bindings—freeze, silence, petrify, and bleeding—make the volley a distributed control plan instead of four copies of one chance. The targets differ by nearest, highest health, and lowest health so the row can keep pressure on the combat that matters without requiring knowledge of the opposing formation. I grow dexterity first for action speed and critical work, then agility for movement and strength and intelligence for the damage and clarity that support ranged shots.
  - The rear row uses paired wands because the fast wave action can deliver magical pressure while kiting behind the rest of the formation. Shock, blind, poison, and burn keep four independent status lines in play. Their intelligence-heavy growth supports magic and casting, with dexterity and agility keeping their action and retreat responsive. Every member first retrieves a dropped offhand, so a disarm or a WorldSphere exchange does not permanently turn a two-hand plan into a one-hand plan.
  - I choose the best material and quality presented in input.choices for every slot, which lets the same code respect the player-selected orb limit from no orbs through the maximum. Worn pieces use godly and world to build broad stat coverage for every role; the held items retain their role-specific words so the combat plan keeps its distinct effects. Growth is apportioned in whole stat-grant units and spends the complete pool, while birth assignment greedily reserves the strongest matching random stat block for each role. I expect a concentrated burst that reaches the rear quickly, unusually strong magic resistance, or sustained effects that defeat the protectors to be the clearest counters; the layered formation, broad resistances, kiting, and several unrelated status effects are the answers this design can make without seeing an opponent.
- **`gpt-5.6-luna`** (`gpt-5-6-luna-team-1`)
  - I built the team as four ranks because a sixteen-body formation needs jobs that remain useful when the opponent chooses a different distance or damage type. The first four places are the front row, so I made them shielded-front members with long tools and shields. The next two ranks provide close pressure and ranged pressure, while the back rank supplies support and control. This gives the team a protected centre and several ways to keep acting when one range is denied.
  - I assign births by a score rather than by their original order. The score rewards the family growth profile and the broad value of vitality, strength, dexterity, agility and intelligence. It is deliberately deterministic and leaves every birth used once. The role is read from the selected mainhand class, so changing the available gear or the orb setting cannot leave a stale invented role name behind.
  - The front rank favours vitality and strength because health, stamina, physical reduction and carried weight let a shield bearer hold ground. The melee rank divides its grants between strength, dexterity and agility to turn contact into damage while keeping its actions and movement responsive. The ranged rank gives the largest share to dexterity and agility, with enough intelligence and vitality for clarity, initiative and endurance. The support rank favours intelligence for magic, clarity and magical defence, with vitality and agility to survive and reposition. The allocator spends the exact level grant in whole stat-grant units at every level, including level one and the maximum level.
  - For equipment I choose each slot explicitly. The material and quality are taken from the end of the choices supplied by the current orb setting, so they can never exceed what the player bought. Gear is selected from the slot tables: shields accompany the two forward families, ranged tools occupy the third family, and the back family prefers magical or restorative tools. The word preferences are family-specific: protection and anchoring words for the front, sharp and swift words for melee, accuracy and elemental pressure for ranged attacks, and arcane, binding or silencing words for support. If a preferred word is unavailable, the designer still selects a valid available word.
  - Each member receives a separate stratagem. The shared opening rules recover a WorldSphere and a disarmed offhand before ordinary attacks. Shielded members advance under protection and sometimes protect an ally; melee members guard when wounded and lunge into contact; ranged members kite when threatened or when a foe closes; support members answer the lowest-health ally before turning their ranged tool on a foe. The rules are ordered so emergency actions precede ordinary attacks, while the normal routine remains available when no listed condition can act.
  - The design must work at no orbs as well as at the highest spend. That is why all choices come from input.choices and every slot is rewritten, including both paired hand and finger positions. I expect the main danger to be a fast opponent that reaches the support rank before the front can establish contact, which is why those members have guard, retreat and targeted ally rules rather than relying on a single healing assumption. I have not tested the team in a fight; this is the formation and allocation I infer from the documented rules.

## 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' | 'assist' | 'flee' | 'backstep' | 'guard-advance' | 'charge' | 'lunge' | 'kite' | 'hold' | 'protect' | 'guard' | 'follow' | 'patrol' | 'station' | 'return' | 'idle' | 'avoid' | 'circle' | 'cower';
  state: 'preparing' | 'alive' | 'held' | 'recovering' | 'dead';
  combat: CombatantState;          // from Derived combat
};

type Scene = {
  seed: number;                    // the base seed of the placement queue
  fightId: string;                 // a fresh UUID whenever a fight starts; its four streams are hashed from it; never a birth seed
  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,
  "fightId": "9b2f4c1e-6d3a-4f8b-a1c5-2e7d0b9f3a64",
  "contentVersion": "8.1bmmTgz1B0Y9UKhiu84STg",
  "rules": { "scaling": "set-world-0-15-35-anima-scaling-7", "system": "set-world-0-15-35-anima-system-16" },
  "combat": true,
  "time": 12.35,
  "queue": [{ "index": 2, "seed": 1013904249, "team": "B", "point": [6, 0, -2] }],
  "actors": [
    {
      "id": "hero-1",
      "seed": 7,
      "contentVersion": "8.1bmmTgz1B0Y9UKhiu84STg",
      "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, state and fight identity are invented for the example; a real fight identity is drawn fresh.

## What to keep for a replay

The full roll, seed and `contentVersion` of every actor, the fight identity, your rule versions, and your simulation inputs. Give every fight a fresh identity as it starts, a UUID from the cryptographic source and never the clock (Set's scenes draw one when the scene opens, on every Clear or Reset, and each time Combat turns on, and write it into a fight record with the start time, the rule stamps and the roster: [Randomness](https://set.world/skills/anima-randomness)), and seed each random stream by hashing the identity with the stream's name, so no two fights share an identity or roll the same; a birth seed decides who an Anima is, never how a fight goes. Then log every outside input with the fixed step it came at (a placement, Start and Stop, a pickup's grab, drags and throw velocity, a stratagem change, pause) and replay by clearing with the same identity and applying each input before its step, holding the simulation while anything the input needs still loads. Keep drawing-only state (pose blends, footing, hit recoil) out of the simulation. Set's scene does this: its Replay reruns everything since the last Clear, and the same session repeats on the same engine and release. A content stamp alone cannot replay a changing spatial game, and a scene report is not a save file. Step the fighters in a fresh order each step, drawn from a stream of its own, never in placement or id order: a fixed order hands whoever comes later a fresher view of the step, and with it one team an edge (Set's scenes shuffle every step and break every remaining tie by that order). Keep action randomness apart from visual randomness.

## Limits

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


## Build sheet: `/anima-adventure?scene=2`

`/anima-adventure` is one page with two scenes, chosen by its `scene` query (`ADVENTURE` in `@common/skill-catalog.ts`): `?scene=1` is the forest, the Oracle's grove (its build sheet below), `?scene=2` is this temple, and an address with no `scene`, or with any other value, opens the forest. `/anima-player` redirects permanently to the temple and `/anima-player-2` to the forest. The home sidebar lists the two scenes under ADVENTURE, above SHOWCASE.

- **Shows.** A controllable base Anima in plain steel armor in a misty teal stone temple. A wide corridor of great ashlar blocks, with moulded plinths, benches and pedestals, opens straight onto a ring of eight stout fluted Ionic columns, with Attic bases and volute capitals, under a moulded circular entablature whose soffit and inner frieze glow over the mist, so the whole colonnade frames the view from the start. Inside the ring a sunken, stepped basin holds a shallow pool of clear teal water, one step below the floor, under a low layer of softly lit mist, thick in some places and thin enough in others to show the water, with a billowing top and a haze rising off it to the capitals. The water mirrors the colonnade and every Anima, shows the stone bed through its depth (darker and greener where it is deeper, with light rippling over the bed), and catches the rotunda's lights as glints. Every Anima wades it: a wading body pushes a wake; each footfall, landing and fall raises a ring that spreads into a train of crests, slows over the shallow step and reflects off the stone; a click on the water raises one too, and a drip falls now and then. The player and Seth push the mist aside as they walk, so it parts in front of them, banks up beside them, swirls along behind them, and closes again once they leave. Light falls through an oculus in the ceiling as a faint shaft in the haze, a glow in the mist lights the columns' inner faces, and a light inside the rotunda throws long shadows down the corridor, which stays in deep teal shadow so the glowing rotunda carries the view. The masonry is built properly: the walls are great ashlar blocks and the floor large flagstones, every one of a surface the same rectangle, laid in courses with each course shifted by half a block, and the wall's upper string course sits on a course joint. The stone is physically based: each block has its own tone, a tooled granite surface with fine mineral grain, a gently cushioned face (the wall blocks swell from their joints, the flagstones only slightly), rounded and lightly worn arrises, dark joints, mineral streaks down the walls, and an occlusion that darkens the joints, the arrises and the tooled cavities; each Anima casts a soft contact shadow on the stone around it; the floor is honed, so all of it carries one soft sheen that mirrors the columns and the glowing mist, with no puddles or wet patches; only the basin's stone is wet, a darker, smoother band along the waterline. The temple is lit by baked global illumination: the light of the oculus, the glowing soffit, the mist and the lit stone bounces through the hall and down the corridor, the mist scatters that light too, and every Anima is lit by it where the player stands. There are no particles. The grade is a cool, slightly desaturated teal. Behind the spawn, the corridor dissolves into black through an ordered Bayer dither. In the pool at the bottom of the basin kneels Seth: a white Anima in mythril armor with a flamberge and a rondache, who rises as the player approaches and fights back once struck. The player wears plain steel (a cap, a shoulderguard on its left shoulder, gothic plate, armplates, gauntlets, legguards and sabatons) and holds a pale mythril arbalest in its right hand. The corridor's benches and the pedestals at its mouth are ledges the player can jump onto, catching an edge just out of reach and climbing over it. In the view's bottom-left corner, inset from its edges, a HUD shows the player's portrait (the same unframed portrait the speech card uses) on a transparent ground, so the scene shows behind the Anima, framed all around by a Gaelic border of wrought metal vine, one text cell thick, that covers the edges where the portrait cuts off the ears and the body. A slender straight rail lies on each edge of the portrait and crosses its neighbours past the corners. Around the rails a vine in pale gold wire is grown rather than tiled, so nothing in it repeats and no corner carries an emblem: a swaying, kinked stem rounds every corner in one loop, a thinner creeper twines over and under it in uneven eyes, and tendrils leave the creeper and curl into tapering scrolls, some ending in a bud and some forked, the largest reaching into the portrait's corners. It is drawn from one fixed seed, every wire with a dark outline, a diagonal sheen, a shaded side and a glint toward the light. To its right, on the scene itself with no panel behind them, sit PLAYER ONE in white, the class, and a health bar and a stamina bar in the house's dithered fill (red and blue), each followed by its value over its maximum, the text outlined in black so it reads over the dark temple and the bright grove alike. Three companions, Lean, Aire and Hoton, stand behind the player, each in its own trait colour, wearing the same steel and holding one mainhand. Above the player's HUD a column of three more, stacked one above the next, shows each companion's portrait, name, class, health and stamina: the same HUD drawn at `PLAYER_PARTY_RULES.hudScale` of the player's in every regard, its portrait, border, text, bars and gaps alike. In a view too short to hold that column above the player's HUD, the column stands beside it instead. There is no control bar or instruction text over the scene. This exploration example uses its own stone, rather than the model and combat demonstrations' cutting mat.
- **Inputs and state.** No character roll at runtime, inventory or persistence. Every body uses the prepared Anima template, with independent skeletons, and every one is a real character: a birth prepared at build. The player is the birth of its own seed grown to its level (`PLAYER_HERO_RULES.level`) by the scenes' level rules, the level's stat points spent by design rather than at random (`PLAYER_HERO_RULES.growth`, mostly agility, the stat behind both walk speed and jump height), with its equipment replaced by its mainhand, a legendary burning mythril arbalest of the ember (`PLAYER_HERO_RULES.mainhand`), which makes it an Arbalestier, and by the loadout it wears (`PLAYER_HERO_RULES.worn`: a steel cap, shoulderguard, gothic plate, armplates, gauntlets, legguards and sabatons, each plain, with no quality word, prefix or suffix), every other slot empty; it is read through AnimaSystem ([Derived stats](https://set.world/skills/anima-derived-stats)), so the arbalest's words add their points and the steel gives its protection, its glance and its worn weight, and drawn as the base grey Anima wearing the steel and holding the arbalest. Its walking pace and the height of its jump are its own: `PLAYER_RULES.speed` times its walk speed, which the weight of what it wears lowers (times the carried-weight factor of what it holds), and a takeoff that reaches the base apex times its jump height, which worn weight leaves alone. Seth is the build-prepared birth of the stratagem duel's seed (`20261007`) at `PLAYER_KEEPER_RULES.level`, which is `levelShare` times the player's level, so twice the player's and the party's: its stats are the scenes' own seeded growth for that birth at that level (`sceneStatGrowth` over the birth's progression seed, the stats the Level slider of `/anima-scene` gives it, not a designed spend), and it is then dressed by `outfitCharacter` and read through AnimaSystem, in the `white` palette. The three companions (`PLAYER_PARTY_RULES.members`) are built the way the player is (`playerCharacter`, through `partyCharacters`): each is the birth of its own seed grown to `PLAYER_PARTY_RULES.level` with that level's stat points spent as its `growth`, its equipment replaced by its one mainhand, which gives its class (Lean a mythril bokken, so a Sword Saint; Aire a mythril glaive, so a Warden; Hoton a burning mythril maul of the ember, so a Siegebreaker), and by the party's worn loadout (`PLAYER_PARTY_RULES.worn`, the player's own), read through AnimaSystem and drawn in its own trait colour wearing that steel. Movement, hand actions, targets, camera, proximity, the entrance, the levels, the party, the duel and its rule that no one who falls rises again are local example choices; the duel resolves every hit with the scenes' rules ([Derived combat](https://set.world/skills/anima-derived-combat)). A game may replace them and supply its own characters, dialogue and rules.
- **Controls.** Any pointer press focuses the canvas, and so does the scene opening when nothing else holds focus, so the keys work at once, after a passage too; Tab reaches it, and its accessible description lists these controls. WASD moves relative to camera yaw; diagonal input is normalized, and a key pressed and released between two frames still counts. Right-click a floor to walk there (hold and drag to steer); on a touch screen, a tap on a floor that does not drag walks there, since touch has no right button. A left click never walks. Touch (or a pen) acts with several fingers at once and draws no buttons, the same screen on every device: a drag that starts on the left half moves like a stick, at the share of the pace it is pushed (`PLAYER_RULES.pointer.stickCssPixels` is full), its centre following a finger pushed past that; a drag on the right half turns the camera; two fingers that land together and spread or pinch zoom; while another finger is down, a tap strikes, the mainhand (Q) on the right half and the offhand (E) on the left; a quick upward flick jumps. Q strikes with the mainhand and E with the offhand, and a strike that reaches Seth starts a fight. Left-click (or tap) another Anima to target it; left-click it again, or left-click anywhere that is not an Anima, to let go. Space jumps once per press, with a short landing-input buffer and a brief grace after stepping off an edge, onto the benches and, with the player's jump height, onto the pedestals from the floor; a jump that falls short of an edge it presses toward catches it and climbs over. Drag rotates the camera, Left/Right rotate, Up/Down tilt, and the wheel zooms. Escape lets go of the target, then clears a walk, then pauses; any control key or pointer press resumes. Blur releases all held keys and the walk. Reduced motion starts paused and keeps ambient motion still after it resumes.
- **Hands.** Each hand plays one action at a time, as [Animations](https://set.world/skills/anima-animations) and [Derived combat](https://set.world/skills/anima-derived-combat) describe it. Q fires the arbalest with its own authored action at its own tempo, release and stamina cost (the reading [Derived combat](https://set.world/skills/anima-derived-combat) prints for a held item, at the player's attributes): the player kneels to aim, the string draws, an ethereal bolt grows on it, and the bolt leaves at the release; an empty hand, E's offhand, throws the shared `left-punch` (or `punch` in an empty mainhand) at the scenes' punch tempo times the player's attack speed, with its impact and clip length. A press made before the playing action's impact plus its follow-through waits and starts at that point; a press after it starts at once, so alternating Q and E chains. Holding Q or E keeps striking: the held hand starts again at each follow-through, and holding both alternates them. A press the hand cannot act on yet, because the player is staggered or down or its stamina cannot pay that hand's action, is kept for `PLAYER_RULES.actions.bufferSeconds` and starts as soon as it can, then is dropped; the stamina is paid when the action starts. The player moves at a reduced share of its pace while an action plays, and walking feet carry on under it. The step that crosses the action's impact records it, and the duel resolves the strike there, or looses the hand's shot (below). Between actions the arbalest rests in the hand's carry pose under walking, the guard, the jump and the hit reaction, with its string at rest and no bolt on it, and it falls and dissolves with the body.
- **Shots.** A held bow or crossbow shoots; every other hand, an empty one included, strikes at its measured reach. The shot is the hand reading's own launch ([Derived combat](https://set.world/skills/anima-derived-combat)) in temple units (`playerShotFlight`): the launch angle kept, its speed and gravity times `PLAYER_BODY_SHARE`, the temple's Anima scale over the scenes'. While the player holds its target the crossbow turns to it and the bolt leaves on the arc the scenes' aim solves to the target's chest (`playerShotAim`, `aimShare` of its height); with no target it leaves where the crossbow points, level at the launch angle. It flies its parabola through the temple, drawn as the scenes' ethereal bolt. Each frame the stretch it covered is tested in samples no longer than `sweepStep` (`playerShotContact`): one within `bodyRadius` of Seth's standing body, between its feet and its height, strikes it; one at or below the ground, or where no body could stand at that height (a wall, a column, a bench or pedestal the bolt is below), stops it, and it fades there. A companion never stops a shot. A shot that strikes is the player's hit from that hand, resolved on the next fixed step by the same strike sequence as a blow, so it can be blocked, parried or missed and can start the fight from across the hall. The hand cannot act again until its reading's reload has passed since the release, as in the scenes.
- **Targets.** A click that does not drag picks the Anima whose standing box the pointer ray meets first, unless a wall is closer. While a target is held the hero faces it every step, moves at the strafe share of its pace, and takes the guard stance with its feet planted and stepped toward where it is heading, so moving in any direction sidesteps around or toward the target. The camera eases behind the hero toward the target unless the pointer is dragging. A dashed ring spins on the target's floor and a crest bobs above its head, above the mist. Seth faces the player whenever it stands.
- **Movement.** Exponential acceleration, braking and turning run in fixed steps with a catch-up cap. The player slides along blocked axes, stays inside the hall and corridor, and cannot enter walls, columns or Seth, wherever Seth stands. A destination is walked toward at the player's pace, slowing as it nears, stops inside the arrival radius, and is dropped once progress stalls (a column or Seth in the way); any movement key cancels it, and a ripple marks where it was set. On the pool the destination is the point of the surface under the pointer, and the water ripples there. The floor is level except the basin, whose height is a continuous radial ramp over its visible steps. On it stand the ledges: a bench along each corridor wall and a taller pedestal at each side of the corridor's mouth. The ground under the player is the highest of the floor and any ledge its feet stand over, so walking down to Seth, standing on a bench and landing a jump all read one height function. A ledge higher than a small step blocks walking like a wall; walking off one falls with gravity, and a body slipping off an edge is pushed clear of its side rather than sinking into it. Grounded distance travelled advances the longer gait, with a damped idle blend. The renderer interpolates the previous and current fixed-step positions, Seth's too. A jump applies vertical launch velocity, rises under gravity and falls under stronger gravity, steers with reduced control in the air, lands on the ground under it, and keeps collision with walls, columns and Seth. At the base stride a standing jump clears a bench but not a pedestal; the player's jump height clears a pedestal too. A jump that presses toward a ledge it cannot clear, close enough to touch it and within reach of its top, catches the edge: the body pulls up beside the ledge, steps onto it and stands there, both eased, never passing through its side; a jump that does not press toward the ledge falls back. So a pedestal is reached from its bench or, by its edge, from the floor, and a late jump at a bench still lands on it. Holding Space never repeats takeoff. The airborne pose blends from the standard Anima jump with its authored vertical displacement removed, since the controller owns height.
- **Seth.** Waiting, it kneels at its post, holding its flamberge and rondache. Once the player comes within the rise radius it plays the kneel clip's get-up and stands facing the player; once the player is beyond the leave radius it walks back to its post and kneels again. Its build is the requested outfit at the best quality the orb cap buys, with words chosen the way the Opus 5.5 team's Dialectician (a sword-and-shield melee build on `/anima-model-teams`) chooses them: one word at a time, the word that adds the most value against each effect's cap, aiming at PRECISE! chance and damage (the flamberge cannot pierce, but it can chain PRECISE!), block, health, critical chance and damage, stamina recovery and walking speed; words whose effects the temple does not resolve are never chosen, and a drawback counts against a target. Its stratagem is the default one ([Stratagems](https://set.world/skills/anima-stratagems)).
- **The duel.** A strike that reaches Seth, the player's or a companion's, makes it hostile, wherever it is in its rise. From then it walks the default stratagem in order for the temple's world (no allies or WorldSpheres, and no status conditions): Guard below a tenth of health, otherwise Melee, alternating its flamberge and its rondache's shield bash, approaching at the base pace times its own walk speed and striking once its foe is in reach and in front, its hand's wait has passed and its stamina covers the cost. Its foe is the nearest standing one of the player and its companions, chosen again each time it is free to act; a swing already begun stays on the foe it began on. Every hit, both ways, runs the scenes' strike sequence: MISS, PARRY and riposte, BLOCK (the rondache), GLANCED (the struck Anima's armor: Seth's mythril, or the steel the player and the companions wear), the damage with critical hits, cut by the struck Anima's damage reduction, and PRECISE! chains. A held item's own outcome is shown under its word: PIERCE! ignores the struck Anima's damage reduction and CRUSH! (Hoton's maul) throws the hit reaction at a critical's strength, while STICK! (Aire's glaive), BREAK! and DISARM! are shown and change nothing more here, since the temple keeps no hold, broken gear or dropped offhand. Of the statuses, the temple resolves BURNED alone, the burn the arbalest's prefix and suffix put on a landed hit: each offer is contested by the effect contest ([Item attributes](https://set.world/skills/anima-item-attributes)), RESIST! when Seth resists, BURNED! when it lands; the burn then ticks Seth's health every status tick, outside the swing ceiling, slows its walk and its swings a little, flames rise from its body as in the scenes, and it ends when its ticks run out, when Seth falls (a burn that fells it lays it down without a push) or when the scene restarts. Seth's own words never cause a status. An interrupting hit plays the hit reaction and holds the struck Anima until it recovers; the player cannot move or strike meanwhile. Stamina recovers while an Anima neither acts nor guards. No swing, a blow with every PRECISE! chain and riposte it sets off, takes as much as the swing ceiling of the struck Anima's maximum health: a swing's rolled damage `d` deals `round(c × tanh(d / c))` with `c` that share of the maximum, so light blows land almost whole, heavy ones and criticals still land harder, and the player survives at least three of Seth's swings from full health. Every hit that interrupts throws the struck Anima's upper body with a brief physical recoil away from the blow, over the authored hit reaction. At zero health an Anima falls as a full ragdoll, pushed by the killing blow, and lies as a corpse; then it dissolves out through the Bayer dither and is gone. No one respawns: a fallen player, Seth or companion stays fallen, at zero health and stamina, and only reloading the page restores anyone. The fight is over once the player or Seth has fallen: no blow in flight lands and Seth is no longer hostile. A fallen Seth can no longer be targeted, blocks nobody and greets nobody. A fallen player takes no input; Seth walks back to its post and kneels, and the companions stand at their places. Leaving through the entrance and coming back starts a fresh fight among those still standing, each at full health and stamina, and raises no one. A live region announces the fight, Seth's defeat and the player's.
- **The party.** Lean, Aire and Hoton are fighters of the same duel, on the player's side, and never block the player: it walks through them, and a companion it crowds steps away. Each fixed step the party gives all three one stance. With no foe they **follow**: each keeps its own place behind the player (`PLAYER_PARTY_RULES.follow.slots`, a distance to the right and a distance back along the heading the player last travelled, so turning on the spot does not swing them round), sets off once it is farther than `follow.resume` from that place, stops within `follow.arrive`, hurries beyond `follow.hurry`, and once there turns to face that heading. Once the player has rested for the Loiter's settle time they **loiter** ([Stratagems](https://set.world/skills/anima-stratagems), Loiter): they stroll, kneel, sit, converse and dance, and the moment the player moves, acts, jumps or takes a target they get up. While the player holds a target that is at peace they **brace**: each steps to its place beside the player (`brace.slots`, measured along the line from the player to the target), faces the target and takes the guard stance, and strikes no blow. They **join** the fight once the player starts a hand action while holding the target, or once Seth is hostile (a strike reached it, or it fights): each walks to within `engage.approachShare` of its mainhand's reach of Seth and strikes with that mainhand when Seth is in reach and in front, its hand's wait has passed and its stamina covers the cost, through the same strike sequence, swing ceiling and counters as every other hit; the first such blow in reach makes Seth hostile. Letting go of a target that has not fought stands them down at once; once Seth is hostile they fight until it falls or the player does. A companion walks at its own pace (`PLAYER_RULES.speed` times its walk speed and its mainhand's carried-weight factor), keeps out of walls, columns, ledges, the player and Seth, turns its step aside by each of `detour.turns` in turn until one is free, and two companions closer than `spacing.gap` ease apart. A fallen companion lies and dissolves as Seth does and stays fallen: it is left out of the party's places, its spacing and Loiter, and it does not walk the forest either. Their words resolve as the player's do: Hoton's maul can burn Seth. The party is flavour and help in a fight; a game may give its companions any rules.
- **Counters.** Each event of the duel shows as a counter over the Anima it struck, worded and coloured as the scenes' counters (a number, red when critical, grey MISS, BLOCK, PARRY and GLANCED, PRECISE! and the other words with `!`, and a status's word and ticks in that status's colour), rising and drifting for a second. No health bar, stamina bar or name label is drawn over any Anima.
- **HUD.** The player's own health and stamina, in the bottom-left corner (above), follow the duel: a hit lowers the health bar, an action spends stamina and stamina recovers while no action plays; a fallen Anima's read zero. Each companion's HUD follows its own health and stamina the same way. The bars are meters with their labels, so a screen reader can read them; the page re-renders the HUD only when a shown whole number changes.
- **The entrance.** Every pixel whose world depth along the corridor lies past the start of the entrance darkness is dithered to black through 4×4 Bayer thresholds, more of it the deeper it lies, so the walls, floor and the Anima itself dissolve as they walk back. Crossing the departure line closes the whole frame with the same dither and leaves for `/anima-adventure?scene=1`, the Oracle's grove, which opens from that dark: it starts black, holds and dithers open, with its player at its arrival, at the tree's foot before the hollow it walked into, facing the knoll; the grove's entrance leads back here the same way, opening the temple with its player at its own arrival (`PLAYER_RULES.arrival`): in the corridor, nearer the entrance than the spawn, facing the rotunda, with the opening camera still in front of the darkness. Each scene has two places to start: its spawn when opened directly or reloaded, which opens with no fade, and its arrival when reached through the other scene's entrance; the companions start at their places behind the player at either. The passage is a client navigation on the same page that changes `scene` and carries a hidden flag the arriving scene reads once, so the address shown never has it. Arriving stands the player at its place with no target, walk or action, Seth at its post kneeling and at peace and the companions at their places behind the player, stills the pool and starts a fresh fight; whoever has fallen stays fallen and is not drawn. Reduced motion cuts instead of dithering, and an arrival opens at once. A dither cell spans the same CSS size at every pixel density.
- **Camera and conversation.** The camera starts well back, framing a share of the Anima's measured height from behind and a little above, so the corridor walls and the whole colonnade frame the small figure; it follows the height the player last stood on (the floor or a ledge, never the jump: it moves up only once the player lands, and down as the player falls), across with damping and up and down with a critically damped spring, so landing on a bench or a pedestal eases the view up without a jump. It raycasts against invisible proxies of the walls, ceilings and column shafts and draws its arm in before them, quickly but smoothly inside its clearance; the arm eases out when the obstruction clears. Entering Seth's proximity while it stands at peace opens a parchment speech card above that Anima, after a classic dialogue layout: the name in large white outlined letters across the top-left border, Seth's portrait (white and armored, as it stands) unframed on the left edge, rendered as soon as the stage opens so it is already there when the card first appears, the greeting in large dark ink revealed letter by letter, and a bordered tail aimed at Seth. The larger exit radius prevents flickering at the boundary, and the card stays closed during the fade and a fight, and for good once Seth has fallen. Projection tracks the camera; occluded, offscreen or top-clipped cards hide. Horizontal clamping keeps the tail aimed at the NPC. A separate live region announces the full greeting once per approach. Narrow layouts omit the portrait and set the words smaller. The card is a greeting, not a branching dialogue or an AI service.
- **Frame.** The stone is one lit material injection: world-space flagstone, ashlar or carved patterns; flagstone and ashlar laid in a running bond of one block size per surface, each course shifted by half a block; physically based maps drawn procedurally: a seeded tone per block, broad mottling, damp at the wall's foot, mineral streaks down the walls' vertical faces and a fine mineral grain for the albedo; a honed roughness on the floors (a seeded step per flagstone) and a dry one on the walls, rougher in the tooled cavities and the joints; a normal from a rounded arris whose width wears along each edge (never its outline) and a cushioned face, a slight seeded tilt per block, and a tooled surface whose finer octaves fade before they can alias; an occlusion that darkens the indirect light in the joints, at the arris and in the cavities, and an analytic occlusion from two spheres per Anima (pelvis and feet) that darkens it around each body; antialiased joints; and a roughness widened by the screen variance of its normal so polished stone never sparkles between pixels. The mottling, the wear, the streaks, the grain and the carved tone read one seeded noise lattice, a small repeating 3D texture read at a lattice point plus the smoothstep of the fraction, so one filtered fetch returns smoothstep-interpolated value noise; the fog's two octaves read the same lattice. The tooling keeps a hashed value noise, because its bump is the screen derivative of its height and a filtered texture read is quantized by its filter weights. The floors carry no wet films or puddles; the basin's stone is wet near the waterline (darker and smoother), and stone under the water gives up most of its specular light to the surface above it. The grain, bevels and tooling are skipped while the blurred floor reflection and the light probes are drawn. The floors add a planar reflection blurred by roughness and weighted by Fresnel, polish, occlusion and smoothness, one soft sheen over every flagstone; since the floors only ever read it blurred, draw it multisampled at half the pool reflection's size and read one mip level lower. Draw order keeps the stone cheap (`PLAYER_DRAW_RULES`): three.js draws opaque meshes by material, in the order the materials were made, so the walls and the ceiling are drawn after the Animas, their gear, the columns and the trim, and the floors, the costliest stone, last, and the depth test rejects every hidden stone pixel before it is shaded, with the same image. Global illumination is baked while the stage opens: a grid of L2 spherical-harmonic light probes over the hall and corridor, each a small cube capture of the temple projected on the GPU, captured once for direct light and emission and again for each bounce, in slices that yield to the page; the floors and a glowing proxy of the mist are shown to the capture, so they bounce and emit light. The stone's indirect diffuse light is the probes' irradiance at its point and normal, in place of the hemisphere light. The probes are read back once after the bake, and every frame their coefficients at the player feed one light probe, so every Anima takes the bounce light where the player stands, with the hemisphere dimmed beside it; a GPU without float render targets skips the bake and keeps the hemisphere. The grid is never added to the scene, since three.js compiles programs ahead without probe grids; the stone, the fog and the water read its texture through their own uniforms. The pool is not a mesh of the scene. Once the scene is drawn, a water pass draws the pool's surface over a copy of the scene's colour, reading the scene's colour and depth behind it. The copy is made only inside the pool's screen rectangle (the bounds of its projected rim, the whole view when the camera stands in it); the later passes read the copy inside that rectangle and the scene itself everywhere else, so no pass copies the whole frame, and while the pool is out of view there is no copy at all. By Fresnel reflectance it mixes a second planar reflection, taken in the pool's plane and drawn only inside that rectangle (widened by the farthest the water moves its read), over the water's body: the scene behind, refracted by the surface normal, tinted by absorption along the refracted path and by turbidity, lit by the caustics the curved surface focuses on the bed, plus the light the water scatters back. It adds a brighter meniscus at every waterline and glints of the spot, the glow and the sun. The normal is the slope of a ripple height field solved on the GPU: a leapfrog step whose restoring force is a sum of blurs of the field at octave widths, read from blur levels of the field (each half the size of the one before, the mean of its four texels, drawn after every step), which gives ripples the dispersion of water waves; the octaves are bounded by the depth, so ripples slow over the shallow step; cells beyond the shore mirror the field, so ripples reflect; a viscous term and a fade damp them. Its sources are displacements: each wading body by how deep it stands, and splashes with no net volume for footfalls, landings, falls, touches and drips. A faint seeded swell along the fog's wind keeps the surface alive between them. A frame pipeline then marches volumetric fog at reduced resolution, ending at the water's surface where the view ray meets it, scattering the oculus sun (enough to show its shaft) and the rotunda spot (faintly, so no hot spot hangs in the rotunda) through their own shadow maps, the mist with a forward and a back lobe and a soft isotropic second-order term and the thin air with the Rayleigh phase and a spectrum that favours shorter wavelengths (so distance cools while the mist stays neutral), the probes' average radiance at each sample (so the mist carries the temple's bounce light), and the dimly self-lit pool of mist; the ground layer and the pool are shaped by the mist wake, a small flow over the temple floor that the player and Seth stir as they move: it clears around them within a fraction of a second, carries the mist outward and along so it piles up beside and ahead of them, shifts the fog's noise with it so the billows slide away, sinks and raises the pool's top, and refills behind them over a few seconds, its edge bent by the fog's own noise; the march stops once the fog is opaque. The same pass measures screen-space ambient occlusion at the surface behind each fog pixel and folds it into the fog's transmittance, so corners, ledges and the Animas' feet darken while the fog in front of them does not. A jitter moves every frame and a temporal resolve reprojects and clamps the previous fog (and with it the occlusion), composites it with depth-aware upsampling, and adds bloom, vignette, ACES tone mapping, a saturation lift and a shadow lift. Every read of the scene's half-float colour (the copy, the water pass, the composite, the bloom prefilter, the floors' reflection) replaces a non-finite value with black and bounds the rest, and the bloom prefilter weighs its four taps by their inverse brightness, so one overflowing highlight on polished armor can never spread into blocks through the bloom's mip chain. The two reflection passes alone also draw a glowing proxy of the mist, so the polished floor and the pool mirror its glow. The two reflections and the shadow maps draw every Anima and everything it wears, Seth's mythril and the player's and the companions' steel alike, with the detail rule in [Item models](https://set.world/skills/anima-item-models), chosen every frame per Anima and given to that Anima's own outfit: in the reflections by its mirror image's distance on screen, in the shadows by the finer of the two shadow maps' texels where it stands; each Anima's armor casts through its shadow-only twins. The main pass, and every held item in every pass, keep full detail. The scene is drawn at one and a half times the CSS resolution (more only on displays denser than that), with 4× multisampling, antialiased with FXAA at that size, then filtered to the canvas with film grain and the Bayer darkness: box-filtered down where the internal image is the larger, and sharpened where the canvas is the larger (every 2× display), each pixel pushed away from the mean of its four neighbours and clamped to their range, so edges steepen and never overshoot. The environment light is kept low, so the corridor stays in teal shadow and the rotunda's light and its bounce lead. The environment map is a capture of the temple itself, taken after the bake so it holds the bounce light; every worn and held finish reflects it, keeping `light.finishChroma` of its colour (a metal has no diffuse light, so a full-colour reflection would turn steel the colour of the room; the share mixes the reflection toward its own luminance, [ALGORITHMS §13.63](https://set.world/algorithms#1363-item-materials-in-anima-object-models)), and Seth's gem inlays refract it (the `'environment'` transmission mode) rather than a second screen-space pass of the scene.
- **Lifecycle.** The host waits until visible, then opens the stage as an orchestrator job, which hears progress after the model, Seth's birth, the player's and the companions', Seth's build, each garment and rigid piece of every outfit as the cloth workers build it (they are asked for as soon as the characters are built, at the opening's own priority, so the workers fit them while the scene is prepared, and waited for before anyone is dressed; a piece they did not deliver is built as it is dressed), each slice of the light-probe bake, Seth's outfit, the player's steel and arbalest, the companions with theirs and the reaches, each compile, the dissolve's programs among them, so no program compiles when an Anima falls, and two warm frames. The stage is built apart from any page, on a canvas of its own, at one pixel: its last step draws one frame from the arrival and one from the spawn there, at full detail, so the geometry is uploaded and the shadows drawn before it is first seen. The page then attaches it (its viewport, speech card, counter overlay and callbacks), which starts it exactly as a fresh one opens, at the spawn or the arrival, with a fresh fade, camera, zoom, duel, pool, mist and counters. Once it shows, the host builds the grove the same way at background priority; the grove's host does the same for the temple. Leaving for the other scene keeps the stage detached (its frames stopped and its screen-sized targets shrunk to a pixel, everything else kept), so the passage either way, and any later visit to either scene by client navigation, opens with no load; a scene that opens before its preparation ends joins that preparation. Navigating to any other page disposes both scenes and stops a preparation in flight; a full page load starts over. A retry after a failure builds a fresh stage on a fresh canvas. Hidden, offscreen, forced-colour and print views stop frames, clear input and hide the counters without catching up. Forced colours and print show a text description. Failures offer Reload scene. A departure stops frames on the black frame, and the host then opens the grove. Disposal releases the model, Seth's outfit, the player's steel and arbalest and any shot in flight, the companions' steel and mainhands, the burn flames, any dissolve and the kept dissolve programs, temple, light probes, the noise lattice, markers, the mist wake, counters, render targets, shadows, renderer, observers, listeners and animation frame. Drawing-buffer density, multisampling and screen-sized shadows use [Viewport performance](https://set.world/skills/anima-viewport-performance); the scene's internal density adapts down to one pixel per CSS pixel when the GPU falls behind, fog and reflection resolution follow CSS pixels, and the main pass keeps every triangle of every Anima, everything it wears and every held item.
- **Source.** `@pages/anima-adventure.tsx`, `@components/AnimaAdventure.tsx`, `@components/AnimaPlayer.tsx`, `@components/AnimaPlayer.module.css`, `@components/scene-passage.ts`, `@components/PlayerHud.tsx`, `@components/KnotworkBorder.tsx`, `@components/knotwork-geometry.ts`, `player/rules.ts`, `player/hands.ts`, `player/hero-gear.ts`, `player/shot-rules.ts`, `player/shots.ts`, `player/keeper.ts`, `player/duel.ts`, `player/party.ts`, `player/loiter.ts`, `player/companions.ts`, `player/fallen.ts`, `player/party.spec.ts`, `player/overlay.ts`, `anima-scene/burn-flames.ts`, `player/environment.ts`, `player/stone.ts`, `player/noise.ts`, `player/probes.ts`, `player/markers.ts`, `player/mist.ts`, `player/water.ts`, `player/post.ts`, `player/stage.ts`. `ADVENTURE.temple` owns the route and sidebar label. `PLAYER_RULES` is the complete exploration configuration:

```json
{
  "version": "set-world-0-15-35-player-19",
  "scale": 0.45,
  "radius": 0.4,
  "speed": 2,
  "acceleration": 16,
  "braking": 22,
  "turnRate": 10,
  "motion": { "gait": 0.85, "blendRate": 12, "jumpPoseAmount": 0.5, "headingEpsilon": 0.000001, "blendSettled": 0.001, "actionBlendSeconds": 0.12 },
  "jump": { "speed": 5.6, "gravity": 17, "fallShare": 1.45, "bufferSeconds": 0.12, "coyoteSeconds": 0.1, "airControl": 0.55 },
  "ledge": { "stepUp": 0.12, "snapDown": 0.2, "footShare": 0.5, "reach": 0.45, "touch": 0.06, "facing": 0.35, "inset": 0.25, "riseSeconds": 0.18, "stepSeconds": 0.14 },
  "step": 0.008333333333333333,
  "maximumSteps": 8,
  "maximumFrame": 0.06666666666666667,
  "spawn": { "x": 0, "z": 8, "yaw": 0 },
  "arrival": { "x": 0, "z": 12, "yaw": 0 },
  "npc": { "x": 0, "z": -11 },
  "room": { "halfWidth": 22, "back": -30, "front": 42, "corridorHalfWidth": 6, "doorway": 0, "height": 20 },
  "corridor": {
    "bench": 1.1,
    "benchHeight": 0.55,
    "benchStart": 1.3,
    "benchLip": 0.08,
    "pedestalHeight": 1.15,
    "pedestalInset": 0.15,
    "wallHeight": 18,
    "wallThickness": 1,
    "mouldings": [[0.55, 1.02, 0.2], [1.02, 1.14, 0.12], [1.14, 1.5, 0.06], [5.75, 6, 0.08]]
  },
  "basin": { "inner": 6.4, "outer": 8.4, "depth": 0.75, "steps": 3, "curb": 0.32 },
  "columns": {
    "count": 8,
    "radius": 11,
    "centerZ": -11,
    "girth": 1.25,
    "bodyRadius": 0.56,
    "topRadius": 0.49,
    "baseRadius": 0.78,
    "height": 8.2,
    "plinth": 0.26,
    "base": 0.36,
    "capital": 0.78,
    "flutes": 24,
    "fluteDepth": 0.04,
    "fluteShare": 0.84,
    "fluteNormalShare": 0.8,
    "fluteShade": 0.32,
    "fluteEnd": 0.35,
    "radialSegments": 8,
    "heightSegments": 28,
    "entasisStart": 0.3333333333333333,
    "entasisPower": 1.4
  },
  "entablature": { "inner": 0.65, "outer": 0.78, "height": 2.3, "radialScale": 0.62, "segments": 160, "soffitGlow": 0.42 },
  "oculus": { "radius": 6.5, "ceilingThickness": 1.2, "skyHeight": 8, "skyRadius": 8.5 },
  "entrance": { "voidStart": 30, "voidEnd": 38, "depart": 34.5, "fadeSeconds": 0.65, "holdSeconds": 0.2, "ditherCssPixels": 2 },
  "conversation": { "enter": 4.2, "leave": 5, "liftShare": 1.12, "edge": 0.04, "revealPerSecond": 45 },
  "camera": {
    "distance": 18,
    "minimumDistance": 4,
    "maximumDistance": 28,
    "pitch": 0.24,
    "minimumPitch": 0.02,
    "maximumPitch": 1.05,
    "fieldOfView": 50,
    "near": 0.1,
    "far": 160,
    "targetShare": 0.95,
    "follow": 9,
    "rise": 4.5,
    "release": 5,
    "pull": 14,
    "orbitPerPixel": 0.005,
    "keyOrbit": 1.8,
    "zoomPerPixel": 0.002,
    "clearance": 0.35,
    "lockFollow": 2.4,
    "lockMinimum": 1.5
  },
  "actions": { "chainAfterImpact": 0.3, "moveShare": 0.55, "bufferSeconds": 0.25 },
  "target": {
    "strafeShare": 0.62,
    "footLead": 0.25,
    "ringShare": 1.9,
    "ringLift": 0.02,
    "ringSpin": 0.6,
    "ringIntensity": 2.6,
    "ringWidth": 0.07,
    "crestLift": 1.16,
    "crestSize": 0.7,
    "crestBob": 0.06,
    "crestBobRate": 2.4,
    "crestIntensity": 5
  },
  "travel": { "arrive": 0.12, "slowRadius": 0.9, "stuckSeconds": 0.35, "stuckShare": 0.25, "markerSeconds": 0.7, "markerRadius": 0.55, "markerIntensity": 2.2 },
  "pointer": { "clickCssPixels": 6, "stickCssPixels": 56, "flickSeconds": 0.28, "flickCssPixels": 28, "flickRise": 1.5, "pinchSeconds": 0.2 },
  "render": { "supersample": 1.5, "deviceSupersample": 0.75, "maximumDensity": 3, "maximumPixels": 8294400, "samples": 4 },
  "art": {
    "seed": 741,
    "noise": { "size": 64 },
    "floorBlock": [3, 2],
    "wallBlock": [6, 3],
    "trimBlock": [1.6, 0.6],
    "joint": 0.03,
    "bevel": 0.06,
    "wear": { "scale": 3, "share": 0.5 },
    "tilt": 0.025,
    "edgeShade": 0.12,
    "mottle": 0.45,
    "tileContrast": 0.3,
    "tooling": { "scale": 0.9, "depth": 0.06, "cavityTone": 0.45, "cavityRoughness": 0.3, "gradientLimit": 0.6 },
    "cushion": { "width": 0.7, "depth": 0.05, "floorDepth": 0.012 },
    "streaks": { "scale": [0.55, 0.045], "strength": 0.24, "edge": [0.45, 0.85] },
    "grain": { "scale": 7, "strength": 0.2 },
    "polish": { "roughness": 0.4, "variation": 0.14, "reflection": 0.42 },
    "occlusion": { "joint": 0.65, "edge": 0.3, "cavity": 0.45 },
    "dryRoughness": 0.86,
    "carvedRoughness": 0.74,
    "jointRoughness": 0.95,
    "dampHeight": 1.8,
    "dampStrength": 0.22,
    "wet": { "height": 0.16, "wick": 0.12, "darkening": 0.55, "roughness": 0.22, "stoneIndex": 1.5 },
    "reflection": { "strength": 1, "distortion": 0.02, "roughLevels": 5, "fresnelPower": 4, "fresnelBase": 0.06 },
    "mistMirror": { "radius": 10.5, "height": 2.4, "intensity": 0.4, "segments": 96, "captureIntensity": 0.9 },
    "sky": { "intensity": 2.5 },
    "parchment": { "size": 192, "grain": 0.07, "fibers": 160, "fiberLength": 16, "fiberAlpha": 0.06 }
  },
  "light": {
    "exposure": 1,
    "ambient": 0.24,
    "environment": 0.42,
    "finishChroma": 0.5,
    "fog": 0.012,
    "capture": { "position": [0, 2.2, 3], "size": 256, "blur": 0.04 },
    "probes": {
      "counts": [12, 4, 19],
      "lift": 0.35,
      "top": 12,
      "inset": 0.5,
      "cubemapSize": 16,
      "bounces": 2,
      "sliceProbes": 16,
      "intensity": 0.55,
      "environmentDiffuse": 0.2,
      "animaIntensity": 0.8,
      "animaAmbient": 0.25,
      "animaLift": 0.5
    },
    "occluders": { "pelvis": 0.24, "feet": 0.13, "feetLift": 0.06, "strength": 0.85 },
    "sun": { "intensity": 3.5, "height": 40, "lean": 0.12, "extent": 16, "bias": -0.001, "normalBias": 0.12, "radius": 4 },
    "spot": { "intensity": 300, "height": 3.8, "back": 1.5, "aimZ": 24, "angle": 0.62, "penumbra": 0.75, "distance": 0, "extent": 14, "bias": -0.0005, "normalBias": 0.09, "radius": 5 },
    "glow": { "intensity": 170, "height": 2.4 },
    "rim": { "intensity": 160, "height": 6.4, "decay": 2 }
  },
  "fog": {
    "resolution": 0.5,
    "cssResolution": 0.6,
    "steps": 24,
    "maximumDistance": 80,
    "base": 0.018,
    "ground": 0.09,
    "groundHeight": 0.8,
    "pool": 0.45,
    "poolTop": 0.42,
    "poolBillow": 0.6,
    "poolSoftness": 0.45,
    "poolVeil": 0.12,
    "poolHeight": 2.6,
    "poolRadius": 12.5,
    "poolInner": 0.62,
    "poolClear": [3, 11],
    "poolContrast": 2.5,
    "poolThin": 0.1,
    "extinction": 1,
    "noiseScale": 0.3,
    "noiseAmount": 0.85,
    "wind": [0.16, -0.05],
    "rise": 0.04,
    "anisotropy": 0.42,
    "backAnisotropy": -0.25,
    "forwardShare": 0.75,
    "multipleScatter": 0.5,
    "sun": 0.6,
    "spot": 0.04,
    "glow": 0.0015,
    "ambient": 0.04,
    "probeScatter": 0.35,
    "poolGlow": 0.32,
    "shadowBias": 0.0015,
    "opaque": 0.01,
    "history": 0.9,
    "jitterStep": 0.618034,
    "historyDepthShare": 0.08,
    "air": { "wavelengths": [680, 550, 440], "spectral": 0.3 },
    "wake": {
      "cell": 0.5,
      "radius": 2.4,
      "inner": 0.35,
      "clearSeconds": 0.3,
      "refillSeconds": 4,
      "strength": 0.94,
      "height": 2.4,
      "wisp": 0.6,
      "push": 2.6,
      "standing": 0.2,
      "drag": 0.6,
      "settleSeconds": 0.9,
      "pile": 1.8,
      "reach": 1.6,
      "carry": 1.2,
      "diffuse": 3,
      "lift": 0.6,
      "maximumSpeed": 6,
      "maximumSeconds": 0.03333333333333333
    }
  },
  "water": {
    "level": -0.3,
    "softness": 0.02,
    "index": 1.333,
    "clarity": 0.35,
    "haze": 2.2,
    "scatter": 0.5,
    "ambientLift": 0.3,
    "refraction": 0.5,
    "refractionDepth": 0.4,
    "distortion": 0.05,
    "roughness": 0.24,
    "glowGlint": 0.4,
    "minimumFacing": 0.04,
    "cullMargin": 0.5,
    "shadowBias": 0.0015,
    "meniscus": { "width": 0.05, "reflectance": 0.6 },
    "swell": { "waves": 6, "amplitude": 0.0012, "lengths": [0.3, 1.1], "spread": 1.2 },
    "caustics": { "strength": 1, "level": 1.5, "range": [0.45, 2.6] },
    "ripples": {
      "size": 512,
      "step": 0.016666666666666666,
      "maximumSteps": 3,
      "gravity": 9.81,
      "octaves": 5,
      "depthReach": 1.8,
      "fadeSeconds": 3,
      "viscosity": 0.00034,
      "events": 4,
      "queue": 16,
      "wake": { "radius": 0.14, "amplitude": 0.06, "depth": 0.45 },
      "splash": {
        "spread": 1.6,
        "limit": 0.2,
        "landing": { "radius": 0.22, "perSpeed": 0.03 },
        "fall": { "radius": 0.3, "strength": 0.18 },
        "touch": { "radius": 0.1, "strength": 0.05 },
        "footfall": { "radius": 0.09, "strength": 0.06, "stance": 0.35 }
      },
      "drips": { "seconds": [1.6, 4.5], "radius": 0.07, "strength": 0.035 }
    }
  },
  "post": {
    "reflectionScale": 0.5,
    "reflectionCss": 0.5,
    "floorReflectionShare": 0.5,
    "reflectiveLayer": 1,
    "mirrorLayer": 2,
    "hdrLimit": 48,
    "poolSegments": 128,
    "poolRect": { "points": 32, "texels": 2 },
    "occlusion": { "radius": 0.8, "nearShare": 0.2, "samples": 8, "strength": 0.9, "bias": 0.03, "power": 1.5 },
    "bloom": { "levels": 6, "threshold": 0.8, "knee": 0.5, "strength": 0.32, "radius": 1 },
    "vignette": { "inner": 0.32, "outer": 1.12, "strength": 0.52 },
    "lift": 0.045,
    "grain": 0.03,
    "saturation": 0.95,
    "sharpen": { "strength": 0.3, "fullScale": 1.3333333333333333 },
    "antialias": { "reduceMinimum": 0.0078125, "reduceShare": 0.125, "spanMaximum": 8 }
  }
}
```

The player's build (`PLAYER_HERO_RULES`: its seed, name, HUD title, level, growth, mainhand and `worn`, the pieces it wears, each a slot, a gear and a material), its birth's level and primary stats beside its grown ones, its class and its mainhand's name, its AnimaSystem readings (the damage reduction and the glance are its steel's), its stride (walking pace, takeoff speed and apex, beside the base pace and apex), its mainhand's hand reading (its delivery, stamina, seconds, impact, the reload after a release, hit power, PRECISE! chance, the shot's flight in temple units, speed, gravity, launch angle in radians and level range, and the burn it offers on a hit), and the most one swing can take from its full health:

```json
{
  "version": "set-world-0-15-35-player-hero-4",
  "seed": 20261122,
  "name": "Player",
  "title": "Player One",
  "level": 20,
  "growth": { "agility": 38, "vitality": 9.5, "strength": 9.5 },
  "mainhand": { "slot": "tool", "gear": "arbalest", "material": "mythril", "quality": "legendary", "prefix": "burning", "suffix": "ember" },
  "worn": [
    { "slot": "head", "gear": "cap", "material": "steel" },
    { "slot": "shoulders", "gear": "shoulderguard", "material": "steel" },
    { "slot": "chest", "gear": "gothic plate", "material": "steel" },
    { "slot": "wrist", "gear": "armplate", "material": "steel" },
    { "slot": "hand", "gear": "gauntlet", "material": "steel" },
    { "slot": "legs", "gear": "legguards", "material": "steel" },
    { "slot": "feet", "gear": "sabatons", "material": "steel" }
  ],
  "birthLevel": 1,
  "class": "Arbalestier",
  "mainhandName": "legendary burning mythril arbalest of the ember",
  "birthStats": { "strength": 14, "dexterity": 19, "agility": 16, "intelligence": 11, "vitality": 16 },
  "stats": { "strength": 23.5, "dexterity": 19, "agility": 54, "intelligence": 11, "vitality": 25.5 },
  "readings": {
    "maxHealth": 277,
    "stamina": 148,
    "physicalDamage": 44,
    "physicalDamageReduction": 0.64,
    "criticalHitChance": 0.133,
    "walkSpeed": 1.594,
    "jumpHeight": 1.555,
    "attackSpeed": 1.527,
    "staminaRecovery": 12.383,
    "glance": 0.062
  },
  "stride": { "walkPace": 3.189, "jumpSpeed": 6.983, "jumpApex": 1.434, "baseWalkPace": 2, "baseJumpApex": 0.922 },
  "heldReading": {
    "delivery": "projectile",
    "stamina": 27.119,
    "seconds": 1.618,
    "impactSeconds": 1.113,
    "reloadSeconds": 1.078,
    "hitPower": 3.367,
    "precise": 0,
    "shot": { "speed": 39.608, "gravity": 36.455, "angle": 0.209, "levelRange": 43.033 },
    "burns": [{ "status": "BURNED", "chance": 29, "strength": 2.143 }]
  },
  "largestSwing": 83
}
```

The shot's rules (`PLAYER_SHOT_RULES`: the longest stretch of flight tested at once and the radius of the body a shot can strike, in temple units, and the share of a body's height it is aimed at):

```json
{ "version": "set-world-0-15-35-player-shot-1", "sweepStep": 0.2, "bodyRadius": 0.4, "aimShare": 0.6 }
```

The duel's rules (`PLAYER_DUEL_RULES`, distances in temple units, times in seconds):

```json
{
  "version": "set-world-0-15-35-player-duel-6",
  "statuses": ["BURNED"],
  "bodyRadius": 0.4,
  "punchReach": { "minimumGap": 0.07500000000000001, "fistShare": 0.55 },
  "rise": { "enter": 6.5, "leave": 7.5, "seconds": 1.3, "hold": 0.85, "kneelSeconds": 1.5 },
  "facingCosine": 0.5,
  "approachShare": 0.9,
  "returnArrive": 0.15,
  "homeYaw": 3.141592653589793,
  "homeFacing": 0.05,
  "swingCeiling": 0.3,
  "defeat": { "corpseSeconds": 3.2, "dissolveSeconds": 1.4 },
  "defeatSeconds": 4.6,
  "guardStaminaPerSecond": 2
}
```

The party's rules (`PLAYER_PARTY_RULES`: its level, `worn`, the pieces every companion wears (the player's own), each companion's name, seed, growth and mainhand, the follow and brace places as `[right, back]`, the hysteresis, hurry, engage, yield, placing, detour and spacing bounds in temple units and radians, the share of the base pace under which the player counts as standing, the stride blend rate, and the HUD's scale):

```json
{
  "version": "set-world-0-15-35-player-party-4",
  "level": 20,
  "worn": [
    { "slot": "head", "gear": "cap", "material": "steel" },
    { "slot": "shoulders", "gear": "shoulderguard", "material": "steel" },
    { "slot": "chest", "gear": "gothic plate", "material": "steel" },
    { "slot": "wrist", "gear": "armplate", "material": "steel" },
    { "slot": "hand", "gear": "gauntlet", "material": "steel" },
    { "slot": "legs", "gear": "legguards", "material": "steel" },
    { "slot": "feet", "gear": "sabatons", "material": "steel" }
  ],
  "members": [
    {
      "name": "Lean",
      "seed": 20261123,
      "growth": { "agility": 28.5, "dexterity": 19, "vitality": 9.5 },
      "mainhand": { "slot": "tool", "gear": "bokken", "material": "mythril", "quality": "masterwork", "prefix": null, "suffix": null }
    },
    {
      "name": "Aire",
      "seed": 20261124,
      "growth": { "agility": 38, "strength": 9.5, "vitality": 9.5 },
      "mainhand": { "slot": "tool", "gear": "glaive", "material": "mythril", "quality": "masterwork", "prefix": null, "suffix": null }
    },
    {
      "name": "Hoton",
      "seed": 20261125,
      "growth": { "strength": 28.5, "vitality": 19, "agility": 9.5 },
      "mainhand": { "slot": "tool", "gear": "maul", "material": "mythril", "quality": "masterwork", "prefix": "burning", "suffix": "ember" }
    }
  ],
  "follow": { "slots": [[-1.15, 0.95], [1.15, 0.95], [-2.3, 1.7]], "arrive": 0.18, "resume": 0.9, "hurry": 3.5, "hurryPace": 1.5, "headingShare": 0.35 },
  "brace": { "slots": [[-1.3, -0.3], [1.3, -0.3], [-2.6, 0.1]], "arrive": 0.18, "resume": 0.5 },
  "engage": { "approachShare": 0.9 },
  "yield": { "gap": 1.1, "pace": 0.8 },
  "place": { "shrink": 0.75, "tries": 6 },
  "detour": { "turns": [0.35, 0.7, 1.05, 1.4, 1.75, 2.1, 2.45] },
  "spacing": { "gap": 0.9, "share": 0.5 },
  "stillShare": 0.05,
  "blendRate": 12,
  "hudScale": 0.6666666666666666
}
```

The builds those rules give the prepared births: each companion's level beside its birth's, its class and mainhand's name, its AnimaSystem readings (the damage reduction and the glance are its steel's), its walking pace, and its mainhand's hand reading (stamina, seconds, impact, hit power and the burn it offers on a hit):

```json
[
  {
    "name": "Lean",
    "seed": 20261123,
    "growth": { "agility": 28.5, "dexterity": 19, "vitality": 9.5 },
    "mainhand": { "slot": "tool", "gear": "bokken", "material": "mythril", "quality": "masterwork", "prefix": null, "suffix": null },
    "level": 20,
    "birthLevel": 1,
    "class": "Sword Saint",
    "mainhandName": "masterwork mythril bokken",
    "readings": {
      "maxHealth": 216,
      "stamina": 114,
      "physicalDamage": 43,
      "physicalDamageReduction": 0.596,
      "walkSpeed": 1.435,
      "attackSpeed": 1.509,
      "staminaRecovery": 10.154,
      "glance": 0.062
    },
    "walkPace": 2.87,
    "heldReading": { "stamina": 30.679, "seconds": 1.551, "impactSeconds": 0.512, "hitPower": 2.615, "burns": [] }
  },
  {
    "name": "Aire",
    "seed": 20261124,
    "growth": { "agility": 38, "strength": 9.5, "vitality": 9.5 },
    "mainhand": { "slot": "tool", "gear": "glaive", "material": "mythril", "quality": "masterwork", "prefix": null, "suffix": null },
    "level": 20,
    "birthLevel": 1,
    "class": "Warden",
    "mainhandName": "masterwork mythril glaive",
    "readings": {
      "maxHealth": 327.5,
      "stamina": 171,
      "physicalDamage": 36.75,
      "physicalDamageReduction": 0.674,
      "walkSpeed": 1.517,
      "attackSpeed": 1.251,
      "staminaRecovery": 13.441,
      "glance": 0.062
    },
    "walkPace": 3.033,
    "heldReading": { "stamina": 33.256, "seconds": 2.446, "impactSeconds": 0.807, "hitPower": 2.615, "burns": [] }
  },
  {
    "name": "Hoton",
    "seed": 20261125,
    "growth": { "strength": 28.5, "vitality": 19, "agility": 9.5 },
    "mainhand": { "slot": "tool", "gear": "maul", "material": "mythril", "quality": "masterwork", "prefix": "burning", "suffix": "ember" },
    "level": 20,
    "birthLevel": 1,
    "class": "Siegebreaker",
    "mainhandName": "masterwork burning mythril maul of the ember",
    "readings": {
      "maxHealth": 390,
      "stamina": 216,
      "physicalDamage": 74.5,
      "physicalDamageReduction": 0.706,
      "walkSpeed": 1.29,
      "attackSpeed": 1.208,
      "staminaRecovery": 14.79,
      "glance": 0.062
    },
    "walkPace": 2.581,
    "heldReading": { "stamina": 32.827, "seconds": 2.12, "impactSeconds": 0.7, "hitPower": 2.615, "burns": [{ "status": "BURNED", "chance": 21, "strength": 1.726 }] }
  }
]
```

Seth's rules (`PLAYER_KEEPER_RULES`: the birth's seed, its level as a share of the player's and the level that gives, palette, orbs per item, outfit, stratagem and the word targets):

```json
{
  "version": "set-world-0-15-35-player-keeper-3",
  "name": "Seth",
  "seed": 20261007,
  "levelShare": 2,
  "level": 40,
  "palette": "white",
  "orbsPerItem": 15625,
  "stratagem": [
    { "condition": "self-hp-below-10", "act": "guard" },
    { "condition": "self-worldsphere-in-melee-range", "act": "grab-worldsphere" },
    { "condition": "self-status-disarmed", "act": "pick-up-offhand" },
    { "condition": "ally-status-debuffed", "act": "mainhand" },
    { "condition": "ally-status-debuffed", "act": "offhand" },
    { "condition": "foe-nearest-visible", "act": "throw-worldsphere" },
    { "condition": "foe-nearest", "act": "throw-worldsphere" },
    { "condition": "foe-status-exposed", "act": "melee" },
    { "condition": "foe-answers-melee", "act": "ranged" },
    { "condition": "foe-in-melee-range", "act": "melee" },
    { "condition": "foe-nearest-visible", "act": "ranged" },
    { "condition": "foe-nearest-visible", "act": "melee" },
    { "condition": "foe-nearest", "act": "ranged" },
    { "condition": "foe-nearest", "act": "melee" }
  ],
  "gear": [
    { "slot": "tool", "gear": "flamberge", "material": "mythril" },
    { "slot": "offhand", "gear": "rondache", "material": "mythril" },
    { "slot": "head", "gear": "armet", "material": "mythril" },
    { "slot": "shoulders", "gear": "shoulderguard", "material": "mythril" },
    { "slot": "neck", "gear": "gorget", "material": "mythril" },
    { "slot": "chest", "gear": "magic infused plate", "material": "mythril" },
    { "slot": "wrist", "gear": "armguard", "material": "mythril" },
    { "slot": "hand", "gear": "gauntlet", "material": "mythril" },
    { "slot": "waist", "gear": "girdle", "material": "mythril" },
    { "slot": "legs", "gear": "legguards", "material": "mythril" },
    { "slot": "feet", "gear": "greaves", "material": "mythril" },
    { "slot": "finger", "gear": "claw", "material": "godhair" }
  ],
  "outcomeWeights": { "chance": 3, "damage": 3 },
  "words": [
    { "effect": "blockChance", "weight": 2 },
    { "effect": "maxHealth", "weight": 1.2 },
    { "effect": "criticalChance", "weight": 1 },
    { "effect": "criticalDamage", "weight": 1 },
    { "effect": "staminaRecovery", "weight": 1 },
    { "effect": "walkSpeed", "weight": 0.8 },
    { "effect": "physicalReduction", "weight": 0.6 },
    { "effect": "attackSpeed", "weight": 0.3 }
  ],
  "resolvedOutcomes": ["precise"],
  "unresolvedEffects": [
    "knockback",
    "magicArea",
    "regeneration",
    "riposteChance",
    "lifesteal",
    "staminaLeech",
    "afflictedDamage",
    "thorns",
    "statusPotency",
    "crushDuration",
    "indestructible",
    "onHitStatus",
    "struckStatus",
    "contagion",
    "struckBuff",
    "castBuff",
    "woundedBuff"
  ]
}
```

The build those rules choose for the prepared birth: its level beside its birth's, its birth's primary stats beside the ones the scenes' seeded growth gives it at that level, the best quality, the words chosen and its AnimaSystem readings:

```json
{
  "level": 40,
  "birthLevel": 1,
  "birthStats": { "strength": 23, "dexterity": 15, "agility": 21, "intelligence": 10, "vitality": 18 },
  "stats": { "strength": 45.75, "dexterity": 41.25, "agility": 43.25, "intelligence": 33.25, "vitality": 40.5 },
  "quality": "perfected",
  "words": {
    "tool": { "prefix": "precise", "suffix": "chaos" },
    "offhand": { "prefix": "precise", "suffix": "chaos" },
    "head": { "prefix": "precise", "suffix": "doors" },
    "shoulders": { "prefix": "precise", "suffix": "doors" },
    "neck": { "prefix": "precise", "suffix": "doors" },
    "chest": { "prefix": "precise", "suffix": "doors" },
    "wrist": { "prefix": "deadly", "suffix": "doors" },
    "hand": { "prefix": "precise", "suffix": "envious" },
    "waist": { "prefix": "deadly", "suffix": "exodus" },
    "legs": { "prefix": "boreal", "suffix": "exodus" },
    "feet": { "prefix": "boreal", "suffix": "gluttonous" },
    "finger": { "prefix": "boreal", "suffix": "gluttonous" }
  },
  "readings": {
    "maxHealth": 811.317,
    "stamina": 245.5,
    "physicalDamage": 83.25,
    "physicalDamageReduction": 0.774,
    "criticalHitChance": 0.759,
    "walkSpeed": 2.262,
    "attackSpeed": 1.644,
    "staminaRecovery": 16.794,
    "glance": 0.093
  }
}
```

The movement and action helpers need no renderer. Their derivation is [ALGORITHMS §16.10](https://set.world/algorithms#1610-player-exploration-controller), and the duel's [§16.11](https://set.world/algorithms#1611-seths-duel). Their shapes are:

```ts
type PlayerPoint = { x: number; z: number };
type PlayerObstacle = { x: number; z: number; radius: number };
type PlayerLedge = { left: number; right: number; back: number; front: number; top: number }; // PLAYER_LEDGES: the benches and pedestals
type HandSlot = 'tool' | 'offhand';                                       // Q is the mainhand ('tool'), E the offhand
type PlayerActionTiming = { rate: number; impact: number; seconds: number }; // authored seconds per real second, impact and clip length in authored seconds
type PlayerAction = { hand: HandSlot; time: number; timing: PlayerActionTiming; serial: number };
type PlayerInput = { forward: number; right: number; jump?: boolean; face?: PlayerPoint | null };
type PlayerClimb = { fromX: number; fromZ: number; fromY: number; toX: number; toZ: number; toY: number; time: number }; // a ledge catch: rise beside it, then step onto it
type PlayerStride = { speed: number; jumpSpeed: number };                  // the walker's pace and takeoff speed (playerStride(walkSpeed, jumpHeight))
type PlayerState = {
  x: number; z: number; velocityX: number; velocityZ: number;
  yaw: number; distance: number; y: number; velocityY: number;
  ground: number;                                                          // the floor or ledge top under the player
  grounded: boolean; coyote: number; jumpHeld: boolean; jumpBuffer: number; // coyote: seconds a jump is still allowed after leaving the ground
  destination: PlayerPoint | null; stuckSeconds: number;
  action: PlayerAction | null; queued: { hand: HandSlot; timing: PlayerActionTiming } | null; actions: number;
  impact: PlayerAction | null;                                             // the action whose impact this step crossed
  climb: PlayerClimb | null;                                               // the ledge catch in progress, or null
  stride: PlayerStride;                                                    // given to createPlayerState; PLAYER_STRIDE by default
};
type PlayerFade = { phase: 'clear' | 'closing' | 'dark' | 'opening' | 'gone'; seconds: number }; // the entrance's fade: 'closing' ends 'gone', black for good; an arrival starts 'dark', holds and opens
type DuelMode = 'kneel' | 'rise' | 'stand' | 'return' | 'kneeling' | 'fight' | 'guard' | 'hit' | 'down';
type DuelEvent = { id: number; side: 'hero' | 'keeper' | 'companion'; value: number | string; tone: 'damage' | 'magic' | 'status'; critical: boolean; status?: string }; // the counter to show over the fighter with that id; a status's (BURNED, RESIST) carries it, for its colour
type DuelLeader = { x: number; z: number; yaw: number; velocityX?: number; velocityZ?: number; grounded?: boolean }; // what duel.step reads of the player: a PlayerState fits
type PartyMode = 'follow' | 'loiter' | 'brace' | 'engage';                 // a companion's stance (Companion.mode)
type PartyLeader = { x: number; z: number; yaw: number; speed: number; busy: boolean }; // what party.step reads of the player: busy while it acts, is in the air or holds a target
type PartyOrders = { foe: PlayerPoint | null; engaged: boolean; locked(index: number): boolean; fallen(index: number): boolean; reach(index: number): number }; // PARTY_AT_EASE: no foe, nobody engaged, locked or fallen
type PlayerFallen = { has(name: string): boolean; add(name: string): void }; // the names of the fallen: PLAYER_FALLEN is the page's, shared by both scenes and never cleared
type PlayerVitals = { health: number; maxHealth: number; stamina: number; maxStamina: number }; // the HUD's whole numbers (playerVitals)
type ItemViewModel = { slot: string; gear: string; material?: string | null; quality?: string | null; prefix?: string | null; suffix?: string | null }; // one piece of an outfit, held or worn; a word left out is none, so the piece is plain
type PlayerBuild = { name: string; level: number; growth: Record<string, number>; mainhand: ItemViewModel; worn: readonly ItemViewModel[] }; // what playerCharacter(birth, build) makes of a birth: PLAYER_HERO_RULES, or a member of PLAYER_PARTY_RULES with the party's level and worn
```

A complete local step, for a source-based replica:

```ts
import { PLAYER_RULES, PLAYER_HERO_RULES, PLAYER_TEMPLE, createPlayerState, advancePlayer, advancePlayerSpring, playerFloorHeight, conversationInRange, playerDepartureDue, createPlayerFade, closePlayerFade, advancePlayerFade, playerFadeCoverage, requestPlayerAction, setPlayerDestination } from '@engine/player/rules';
import { playerHandAction } from '@engine/player/hands';
import { SLOT_HAND } from '@common/hands';
import { designKeeper, PLAYER_KEEPER_RULES } from '@engine/player/keeper';
import { PlayerDuel, PLAYER_DUEL_RULES, duelHeldReach, duelPunchReach, playerHeroCharacter, playerHeroStride } from '@engine/player/duel';
import { PlayerParty, partyCharacters } from '@engine/player/party';
import { PLAYER_FALLEN } from '@engine/player/fallen';
import { loiterStance } from '@engine/player/loiter';
import { playerVitals } from '@engine/player/hero-gear';
import { playerShotAim, playerShotContact, playerShotFlight } from '@engine/player/shot-rules';

const hero = playerHeroCharacter(heroBirth), keeper = designKeeper(keeperBirth).character; // the births of PLAYER_HERO_RULES.seed (grown, armed and dressed) and PLAYER_KEEPER_RULES.seed
const party = new PlayerParty(partyCharacters(partyBirths), PLAYER_TEMPLE);                // the births of PLAYER_PARTY_RULES.members, in order, standing at their places behind the spawn
const allyReaches = party.members.map(() => ({ right: duelHeldReach(mainhandForward), left: duelPunchReach(fistLeft) })); // each companion's own measured reaches
const duel = new PlayerDuel(hero, keeper, { hero: { right: duelHeldReach(arbalestForward), left: duelPunchReach(fistLeft) }, keeper: { right: duelHeldReach(flambergeForward), left: duelHeldReach(rondacheForward) } }, PLAYER_KEEPER_RULES.stratagem, undefined, { party, reaches: allyReaches }, PLAYER_FALLEN); // undefined: a fresh fight id; PLAYER_FALLEN: whoever falls stays fallen for the page
const player = createPlayerState(PLAYER_TEMPLE, arrivedThroughTheGrove, playerHeroStride(hero)); // at PLAYER_RULES.spawn (or .arrival), walking and jumping at the player's own stride
setPlayerDestination(player, { x: 3, z: 2 });                                             // a right-click on the floor
if (duel.heroMayAct('right')) requestPlayerAction(player, 'tool', playerHandAction('tool', duel.heroHand('right')).timing); // Q: the arbalest's own action, refused while it reloads
const input = { forward: 0, right: 0, jump: false, face: { x: duel.keeper.x, z: duel.keeper.z } }; // Seth is targeted
const cameraYaw = player.yaw;                                                             // the camera opens behind the player
advancePlayer(player, input, cameraYaw, PLAYER_RULES.step, duel.keeper.health > 0 ? [{ x: duel.keeper.x, z: duel.keeper.z, radius: PLAYER_RULES.radius }] : []); // a fallen Seth blocks nobody
duel.step(PLAYER_RULES.step, player, true, player.action !== null);                       // reads the player's place, yaw, velocity and grounded flag, and steps the party inside
const fightOver = duel.over;                                                            // the player or Seth has fallen: let go of the target; nobody rises again
const companions = party.members.map((member, index) => ({ x: member.x, z: member.z, yaw: member.yaw, mode: member.mode, stance: loiterStance(member.loiter), fighter: duel.allies[index] })); // draw each: its stance, or its fighter's action, hit or fall
const fade = createPlayerFade(arrivedThroughTheGrove);                                  // keep across frames; true starts black and opens
if (playerDepartureDue(player)) closePlayerFade(fade);                                  // leaving stays black
if (advancePlayerFade(fade, frameSeconds, reducedMotion)) leaveFor('/anima-adventure?scene=1'); // the frame is wholly dark
const darkness = playerFadeCoverage(fade);                                              // 0 to 1: draw the pixels whose Bayer threshold it reaches black
const sethBody = { x: duel.keeper.x, z: duel.keeper.z, feet: playerFloorHeight(duel.keeper.x, duel.keeper.z), height: bodyHeight }; // what a shot can strike while Seth stands
if (player.impact) {                                                                    // the action reaches its impact this step
  const hand = SLOT_HAND[player.impact.hand], held = duel.heroHand(hand);
  if (held.launch && heldModelHasBowstring) { duel.heroLoosed(hand); flyShot(playerShotFlight(held.launch), playerShotAim(sethBody, { x: 0, y: 0, z: 0 })); } // a bow or crossbow looses: the hand reloads and the shot flies
  else duel.heroStrike(hand);                                                           // anything else lands at its reach, facing Seth
}
const touched = playerShotContact(PLAYER_TEMPLE, shotWas, shotIs, sethBody);              // each drawn frame, over the stretch the shot flew: { fraction, struck } or null
if (touched?.struck) duel.heroLanded('right');                                          // on the next fixed step: the shot's hit, resolved as any blow
if (duel.heroInterrupted) { player.action = null; player.queued = null; }               // a hit staggered the player
const counters = duel.events.splice(0);                                                 // draw each over the fighter with its id (duel.fighters)
const hud = playerVitals(duel.hero.health, duel.hero.maximum, duel.hero.stamina, duel.hero.maxStamina); // redraw the HUD only when one of its numbers changes
const position = { x: player.x, y: player.y, z: player.z };                            // y is the feet: on the floor, a ledge or in the air
const aimHeight = { value: player.rest, velocity: 0 };                                  // keep this across frames
advancePlayerSpring(aimHeight, player.rest, PLAYER_RULES.camera.rise, frameSeconds);     // each drawn frame: aim above aimHeight.value, never above the jump
const keeperAt = { x: duel.keeper.x, y: playerFloorHeight(duel.keeper.x, duel.keeper.z), z: duel.keeper.z, mode: duel.keeper.mode };
const conversationOpen = duel.keeperPeaceful && conversationInRange(player, false, duel.keeper);
const { revision, dirX, dirZ, critical, fatal } = duel.hero.blow;                        // a new revision: recoil (or, when fatal, fall) away from (dirX, dirZ)
const gone = duel.keeper.mode === 'down' && duel.keeper.modeTime >= PLAYER_DUEL_RULES.defeatSeconds; // lain and dissolved: stop drawing it, for good
```

Call `advancePlayer` once per fixed step, using the stage's capped accumulator; it mutates only the supplied local state and advances the playing action by `step × timing.rate` authored seconds. `y` is the absolute foot height, `velocityY` is vertical speed, `ground` is the height of the floor or ledge under the player, `rest` is the height the camera rests on (the ground at the last grounded step, held through a jump or a climb and lowered only while the body falls below it), `jumpBuffer` is remaining input-buffer time and `coyote` the time a jump is still allowed after leaving the ground, both in seconds. Pass the current held state as `jump`, or omit it for ground-only input; release it before another takeoff. While `climb` is set the step ignores movement and jump input, eases the body up beside the caught ledge and then onto it, and clears `climb` once it stands there (`grounded` is `false` meanwhile, so draw the airborne pose). Pass the target's position as `face` while one is held, or `null`; the player then faces it and moves at `PLAYER_RULES.target.strafeShare` of its pace. Any nonzero `forward` or `right` clears `destination`; `setPlayerDestination(player, null)` clears it too. `requestPlayerAction` returns `true` when the action started and `false` when it waits for the playing one's follow-through; `serial` grows with each start, so a renderer can blend into a new action. `playerFloorHeight(x, z)` returns the navigation floor height (zero, or the basin's radial ramp) independently of airborne height, and `playerGroundHeight(x, z)` the ground a body standing there rests on: the floor or the top of a ledge in `PLAYER_LEDGES` (the benches and pedestals) whose box, widened by `PLAYER_RULES.ledge.footShare` of the body radius, holds the point. Place a walker that never climbs (Seth) with the first and the player's ripples with the second. `playerDepartureDue(player)` is true once the player crosses the departure line in the entrance darkness. The fade closes over `PLAYER_RULES.entrance.fadeSeconds`: `closePlayerFade(fade)` starts it (and returns `false` while one already runs), and `advancePlayerFade(fade, seconds, cut)` returns `true` on the step the frame becomes wholly dark. It stays black from there (`'gone'`): leave for the other scene. Pass `cut` under reduced motion to take every step at once. `createPlayerFade(true)` starts black, holds for `entrance.holdSeconds` and opens over `fadeSeconds`, for a scene reached through the other's entrance; `playerFadeCoverage(fade)` is the share of the frame's Bayer thresholds to draw black. Pass the previous conversation state to `conversationInRange` for hysteresis, and Seth's current place as its third argument (its post by default). `playerPositionAllowed(x, z, others, feet)` tests a candidate against the room, the columns, the circular `others` (by default `PLAYER_ANIMAS`, Seth at its post) and every ledge more than `PLAYER_RULES.ledge.stepUp` above `feet` (by default the floor height there); `advancePlayer` takes the same `others` as its last argument and passes the player's own feet. `player.impact` is the action whose impact the last step crossed, or `null`. `createPlayerState`'s third argument is the walker's stride: `playerStride(walkSpeed, jumpHeight)` is `PLAYER_RULES.speed × walkSpeed` and `PLAYER_RULES.jump.speed × √jumpHeight`, so the apex (`playerJumpApex(stride)`) is the base apex times the jump height; without one the walker takes `PLAYER_STRIDE`, the base. `advancePlayerSpring(spring, target, frequency, seconds)` advances a critically damped spring (`{ value, velocity }`) exactly by `seconds`, so it is independent of the frame rate; follow `rest` with it at `PLAYER_RULES.camera.rise` and the aim eases onto a ledge from rest, without overshoot.

Step the duel once per fixed step after `advancePlayer`, passing the player's state (its place, yaw, velocity and grounded flag), whether it targets Seth and whether a hand action plays; given a party (the constructor's last argument, with each companion's measured reaches), it steps the party inside that step, before anyone fights, with the orders the fight gives (the foe to face, whether to engage, who is held by a hit, a fall or a swing, and each mainhand's reach), and then lets each engaged companion strike; it returns nothing. A fallen fighter keeps its mode `down`, and its `modeTime` passes `defeatSeconds` (its corpse's `defeat.corpseSeconds` and its dissolve's `defeat.dissolveSeconds`) when nothing of it is left to draw; `duel.over` is true once the player or Seth has fallen, and `duel.reset(place)` starts a fresh fight among those still standing. `heroHand(hand)` is that hand's reading: the held item's (the arbalest, right) or the scenes' punch; `playerHandAction(slot, reading)` turns it into the action's pose (`null` for a held item, which plays its own action) and timing. `heroMayAct(hand)` is false while the player is staggered or down, while that hand reloads after a shot, or while its stamina cannot pay that hand's action; `heroActed(hand)` pays it when the action starts; `heroStrike(hand)` resolves the strike if Seth is within the hand's reach and in front, and makes it hostile; `heroLoosed(hand)` starts the hand's reload (its reading's `reload` seconds from that step) when it looses a shot; `heroLanded(hand)` resolves that hand's hit on Seth with no test of reach or facing, for a shot whose flight reached it, and makes it hostile. `playerShotFlight(launch)` is a shot's flight in temple units from a hand reading's `launch`, `playerShotAim(body, point)` writes the point of a body it is aimed at, and `playerShotContact(world, from, to, body)` answers what a stretch of flight touches first (`{ fraction, struck }`, struck when it is the body, or `null`), through any `PlayerWorld`. `heroInterrupted` is true for the step a hit staggered or felled the player; cancel its action then. `events` collects the counters to draw (a status's counter carries `status`, which colours it); empty it after drawing. `keeper` and `hero` expose `x`, `z`, `yaw`, `health`, `maximum`, `stamina`, `maxStamina`, `statuses` (BURNED while burning, for the flames), `mode`, `modeTime`, Seth's `action` (`hand`, `time` in seconds, `held.baseSeconds`, so its clip time is `time × WEAPON_ACTION_SECONDS / held.baseSeconds`) and each fighter's hit reaction (`hit`, for `sampleHitReaction`). Each fighter's `blow` (`revision`, the direction `dirX`, `dirZ` the blow travelled, `critical`, `fatal`) changes revision with every interrupting hit and with the killing one, which is where a renderer starts a recoil or a ragdoll; nobody is restored, so once a fallen fighter's `modeTime` has passed `defeatSeconds` a renderer stops drawing it for good, and `reset()` leaves it so. `swingDamage(rolled, maximum)` is the swing ceiling's curve, the health one swing takes for its rolled damage. `playerHeroCharacter(birth)` grows a birth to `PLAYER_HERO_RULES.level` by `PLAYER_HERO_RULES.growth` (refusing a growth that does not spend exactly that level's stat points in whole stat grants), replaces its equipment with `PLAYER_HERO_RULES.mainhand` and the pieces of `PLAYER_HERO_RULES.worn`, leaving every other slot empty, and reads the whole through AnimaSystem; `playerHeroHand(hands, hand, attributes)` is a hand's reading from `dungeonHands`, the punch in an empty hand; `playerHeroStride(character)` is its stride, its walk speed times each held item's carried-weight factor and its jump height. `playerVitals(health, maximum, stamina, maxStamina)` gives the HUD's whole numbers. `reset(place)` restores everyone, stands the party behind the player's place (the spawn by default) and starts a fresh fight. `allies` holds the companions' fighters in the party's order and `fighters` everyone, the player first, then Seth, then the companions; `party.members[index]` holds each companion's place, yaw, walked `distance`, `stride` (the share of its pace it is moving at, for the walk blend), `mode` and `loiter` state, and `loiterStance(member.loiter)` names the stance to draw (`kneel`, `sit`, `converse` or `dance`, [Animations](https://set.world/skills/anima-animations)) or `null`. `playerCharacter(birth, build)` is the build both the player and the companions use (a `PlayerBuild`), and `partyCharacters(births)` builds the three, each with the party's level and `worn`. The reaches are the stage's to measure from its models: an empty hand's fist forward distance at `IMPACT_TIME` (`duelPunchReach`) and each held item's (the player's arbalest, each companion's mainhand, Seth's flamberge and rondache) farthest forward point over its strike window (`duelHeldReach`), both in model units. How a shot is drawn in flight, and where its nock and its direction are read from the posed model, stay the renderer's. `designKeeper` measures the held items, so call it once while loading. Which Anima is targeted, how a pointer ray meets a floor or a body, and how a pose is drawn stay the game's. The floor, ledge and position helpers define this temple, not a general terrain solver; `advancePlayer` and `createPlayerState` walk any other world given as a `PlayerWorld` (its spawn, ledges, ground height and position test), the temple's `PLAYER_TEMPLE` by default, and the grove of `/anima-adventure?scene=1` is one (its build sheet below). A replica using downloaded clips instead may implement the same local inputs and collision shapes in its own engine. Plain HTTP returns the page shell, not a rendered temple.

## Build sheet: `/anima-adventure?scene=1`

Rule stamp: `set-world-0-15-35-grove-9` (`GROVE_RULES.version`).

- **Shows.** The same controllable base Anima as the temple (`/anima-adventure?scene=2`), in the same plain steel and holding its arbalest, with the same three companions behind it, dressed alike, and the same HUDs in the view's bottom-left corner, small in a forest glade in golden light, a meadow under a giant tree named Oracle. The player starts on a mossy knoll at the edge of a round clearing, centred in the view, looking across a shallow dell at the tree. The tree stands at the centre: a trunk many times the Anima's height, flared at its foot into buttresses, wrapped in rope-like ridges of warm plated bark with burls, lichen and moss in patches and on every surface that faces up, with great roots that snake out over the ground, branch into rootlets and sink into it. The side that faces the start holds a kind old face made of the tree itself: high mossy brows that droop at their outer ends, eyes closed in a smile, a long nose with a round tip, lifted cheeks, a mossy moustache over a closed smile and a chin, ivy down both temples, and beneath the chin a dark hollow that goes into the tree, a broad, low arch wider than it is tall whose top stays under the chin, so it never cuts into the face. It is carved from the same bark as the trunk: the bark's ropes run on faintly across it and its furrows and plates run through it almost as strongly as around it, its wood only a little smoother and paler, and it gives off no light: the crown leaves a window toward the sun, so sunlight falls on it. Boughs spread from the trunk over the whole clearing, each swelling into a collar where it leaves the trunk, with twigs that grow out of them the same way, carrying clusters of leaves and long hanging vines, some with leaves, that hang from inside the limb above them. The ground is a meadow over rolling hillocks that rises to the tree's foot: tall, dense grass of a lush green, its tips sunlit to a yellow-green and drier in seeded patches, its blades glinting where they turn the sun toward the viewer, leaning and rippling as gusts cross it, parted by a worn, wandering path of tan soil from below the knoll to the Oracle and leaning away from that path and from every root and boulder; it parts around the Anima as it walks, stays open in a wake behind it and closes again. Under the grass the ground is the grass's own dark green base with fallen leaves, so no soil shows between the blades; moss and bare soil with small stones lie only where no grass grows, on the path and in a few seeded bare patches. There are fern rosettes with arching fronds, broad-leaved plants, patches of small white flowers, and angular mossy boulders with smaller stones about them. Around the clearing stands a forest wall with no way through: great fluted, buttressed trunks foot to foot on a rising bank, no two alike, with low leafy limbs that grow out of the leaning trunks, saplings, bushes, fallen logs and rocks between them, and row on row of forest behind, fading into warm haze. Golden sunlight falls from high in front of the tree through the gaps in the canopy as shafts in the haze and as dappled light on the meadow. Motes of light drift everywhere, some as soft dots and some as rings, and dark leaves fall slowly, turning. Walking up to the tree opens the Oracle's speech card, and walking into the hollow leads to `/anima-player`.
- **Inputs and state.** No character roll at runtime, inventory or persistence. The player is the same build as in the temple (`PLAYER_HERO_RULES`: the prepared birth grown to its level, wearing its plain steel loadout and holding the legendary burning mythril arbalest of the ember), read through AnimaSystem for its stride and its hands, and drawn as the base grey Anima in that steel at the same scale. Its three companions are the temple's own builds (`PLAYER_PARTY_RULES`, the temple's build sheet above): here they only follow and loiter, since the grove has no Anima to target and no fight, and their HUDs show full health and stamina. No one who fell in the temple walks here, since nobody respawns: a fallen companion is absent and its HUD reads zero, and after a fallen player the grove shows no player, takes no movement or hand input and stands the companions at their places, until the page is reloaded (`PLAYER_FALLEN`, the temple's build sheet above). The HUD shows its full health, which nothing here lowers, and its stamina, which each hand action spends at that hand's cost (a press it cannot pay is refused) and which recovers at its stamina recovery while no action plays, as in the temple. Its arbalest shoots here as in the temple (the temple's Shots, above), with no target to aim at: the bolt leaves where the crossbow points, flies through the grove's own world and stops on the ground, a root, a boulder or a tree, and the hand waits out the same reload. The hollow is an entrance to the temple, `/anima-adventure?scene=2`, and the temple's entrance leads back. A game may replace the tree, its name and its words.
- **Controls.** The same as the temple's, without targets: any pointer press, or the scene opening, focuses the canvas; WASD moves relative to camera yaw; right-click the ground to walk there (hold and drag to steer), or tap it on a touch screen; Q strikes with the mainhand and E with the offhand, and holding either keeps striking; Space jumps; touch moves with a left-half stick, turns with a right-half drag, zooms with two fingers, strikes with a tap while another finger is down and jumps with an upward flick; drag rotates the camera, Left/Right rotate, Up/Down tilt, and the wheel zooms. Escape clears a walk, then pauses; any control key or pointer press resumes. Blur releases all held keys and the walk. Reduced motion starts paused and keeps the wind, mist, fireflies and leaves still after it resumes. No control bar, counter or label is drawn over the scene, and the only bars are the HUD's; a visually hidden paragraph lists the controls.
- **Movement.** `advancePlayer` runs in the same fixed steps with the same speeds, jump, hand actions and destinations, given the grove's world (`GROVE_WORLD`) in place of the temple's. The ground is one height function, `groveGroundHeight(x, z)`: a sum of seeded sine swells and of seeded hillocks (`GROVE_HILLOCKS`, the first the knoll under the start), both faded out toward the tree, plus a mound that rises to the tree's foot, plus a bank that rises under the forest. The player may stand anywhere inside the clearing's radius that is outside every obstacle circle (`GROVE_OBSTACLES`): the trunk at its radius on the ground (except inside the entrance, below), a chain of circles along each root as far as it is thick enough to block, and each boulder; boulders keep off the path. Nothing passes the clearing's radius, and that is where the forest wall stands: `GROVE_WALL` is one great tree every `wall.spacing` of the circle, each set back until the foot of its flare touches it, with neighbouring feet overlapping. The grove has no ledges, so a jump always lands on the ground under it. A destination is the point where the pointer's ray first passes under the ground (`groveGroundUnderRay`), unless the ray meets the trunk first outside the entrance; its ripple lies along the slope there (`groveGroundNormal`).
- **The entrance.** Beneath the face's chin an arched hollow goes into the trunk (`GROVE_RULES.entrance`). Its outline is a superellipse (`entrance.squareness`) `entrance.halfWidth` across the mouth and `entrance.height` high from the trunk's foot, its walls running toward the axis (`GROVE_ENTRANCE.halfAngle`); the trunk's grid is carved back to a wall `entrance.depth` behind the mouth (`GROVE_ENTRANCE.mouth`, the lobed mean radius at the face's foot), eased across `entrance.rim` of the outline and rolled into a bark lip of `entrance.lip` over `entrance.lipWidth` beyond it, and its surface shaded as a crease; the floor is the level ground inside the trunk. The worn path runs up to it. The player may walk into its fully open part, a body radius from its walls and back wall, and right-clicking its floor walks there. Every pixel whose world point lies inside `entrance.voidOutline` of the outline is dithered toward black by its depth behind the mouth, from nothing at `entrance.void[0]` to black at `entrance.void[1]`, through the temple's 4×4 Bayer thresholds and dither cell, so the hollow and the Anima walking in fall into darkness. Crossing `entrance.depart` behind the mouth (`groveDepartureDue`) closes the whole frame with the same dither over `PLAYER_RULES.entrance.fadeSeconds` and leaves for `/anima-adventure?scene=2`, the temple, which opens from that dark with its player at its arrival; the temple's entrance leads back here the same way, opening this grove from black with the player at its arrival (`GROVE_ARRIVAL`): on the face's bearing, `entrance.arrival` outside the mouth at the tree's foot, facing the knoll, with the camera behind it in the hollow, so the view looks out of the tree across the meadow. Opened directly or reloaded, the page opens with no fade and the player at its spawn on the knoll, facing the tree; reduced motion cuts instead of dithering. The card stays closed while the frame fades.
- **Camera and conversation.** The camera rules are the temple's own (`PLAYER_RULES.camera`): the same distance and zoom range, pitch and pitch range, field of view, follow, spring, orbit and arm easing, orbiting the Anima's measured head height, so the Anima starts centred with the camera behind it. Only the far plane and the collision are the grove's. The arm shortens (`groveCameraReach`) where a marched ray would stand deeper inside a solid than the Anima's aim point stands, or need more than `camera.rideSlope` of lift to clear the ground. The solids are what is drawn, each widened by `camera.clearance`: beyond the clearing by more than `camera.forestMargin`; the trunk out to its lobed mean surface (`groveTrunkSurface`) plus the face's raised relief and `camera.barkMargin` for its ropes, wobble and burls, open inside the entrance's hollow as far as its back wall; each root as a tube along its centre line as thick as it is drawn, at the heights its arch, flare and sink can carry it; and each boulder as an ellipsoid of its radius and squash times `camera.stoneReach`. So the arm stays whole while the Anima stands close to bark or a root, and when a root, a boulder or the trunk comes between them the arm stops in front of it, and the stage holds the camera there at once, then eases in at the pull rate. Over ground the camera is lifted rather than pulled in (`groveCameraRide`): by the least that keeps it `camera.groundClearance` above the ground under it and keeps its sight line to the Anima `camera.sightClearance` above every rise between, so it rides over hillocks. Under the arch it ducks (`groveCameraPitch`): while the Anima's aim point stands inside the hollow's footprint, the pitch is held low enough that the arm leaves under the arch, `camera.clearance` plus `camera.archMargin` below its outline where it crosses the mouth, never below `camera.minimumPitch`, so walking in keeps the whole arm instead of pulling the camera in against the bark above the arch; outside the mouth the pitch is the visitor's own. Within `conversation.enter` of the trunk's surface (and until `conversation.leave`) the Oracle's card opens: the same parchment card as Seth's, without a portrait, with the Oracle's name across its top-left border and its words revealed letter by letter (both below). The card points at the trunk beside the player (`groveOracleAnchor`: the point of the trunk nearest the player, `conversation.lift` above the ground, which is above the face's brow so the card never covers the face) and is kept wholly inside the view; it hides while that point is behind the camera. A live region announces the name and the words once per approach.
- **Frame.** Everything is procedural and seeded by `GROVE_RULES.seed`. The ground is two grids of the height function, a fine one over the clearing and a coarse one under the forest. The trunk is a grid over angle and height, its columns and rows closest together over the face, whose radius is `groveTrunkRadius(height)`, widened into a buttress over each root, displaced by two scales of rope ridges, a broad wobble and seeded burls, raised and sunk by the face's height field (`groveFaceRelief`, with the ropes calmed inside `groveFaceShare`), carved by the entrance's hollow and closed by a dome; each root, rootlet, temple strand, bough and twig is a lumpy tapered limb along a curve that carries its own bark coordinates, so the grain runs along it; a bough starts on the trunk's axis and a twig on its bough's, and each swells into a collar where it leaves the surface it grows from (`groveCollar`); vines are instanced tapered cylinders hung from inside the limb above them; the wall's and the forest's trunks and the saplings are instances of a few flared trunk shapes (`forest.variants` for the wall, `forest.rowVariants` coarser ones behind it, one for saplings), each built with its own buttress fins, flutes, knots and bow, and each tree's crown, leaves and collared limbs are seated on its own leaning, bowed axis; boulders are instances of four displaced spheres cut by seeded planes into facets, and their satellite stones and the pebbles instances of a fifth. One lit material injection (`grove/surface.ts`) draws ground, bark and rock: seeded moss greens in clumps with fine fibre, fallen leaves, soil with small stones and the path on the ground, and under the meadow the sward (below); bark furrowed along the grain and broken across it, darker in its creases, with lichen spots and moss in patches (more of it lower down) and on up-facing surfaces; layered, pitted stone with lichen and moss on top; a bump from value noise that fades with distance, read from a seeded packed lattice by two unfiltered fetches and interpolated in the shader so the bump never steps; and on the trunk the face's shaded creases, the bark running through it a little smoother, paler and barer, and the moss of its brows and moustache. Its fine detail is computed only near the camera and fades to cheaper noise by `surface.fade`. Leaves, fronds, broad leaves and flowers come from one painted atlas, alpha-tested, drawn double-sided in one pass with alpha to coverage: crown, limb, bush and ivy leaves as cards shaded with normals that point out of their cluster so a crown reads as a volume, fern fronds and broad leaves as bent strips that arch and droop, flowers as small tilted cards; all lit through by the sun from behind and swayed by the wind in the vertex stage. The meadow (`grove/meadow.ts`) is instanced tufts of `grass.blades` curved, tapered blades, one to a seat of a grid of `grass.tufts` seats over the clearing, each straying `grass.jitter` of its seat so the tufts stand evenly with no chance gaps; a seat keeps its tuft by the meadow's cover there (none inside an obstacle circle, fewer on the path and in seeded bare patches). The tufts are held in squares of `grass.cell`, so only the squares in view are drawn, nearest first. The same cover is baked into a texture of `grass.cover.size` texels a side that the ground's shader reads: where grass grows, the ground takes the sward's colour (the grass's root colour mixed `cover.green` toward its green, darkened by `cover.shade`, its edge sharpened by `cover.edge` and frayed by `cover.fray` of the ground's noise) and the seeded bare soil is left out, so the ground between the blades is the grass's own shaded base. One small shader bends and lights every blade in the vertex stage: its own lean, the wind (`wind.meadow`), the lean each tuft keeps away from the path and from obstacles, and the parting from the Anima (`grass.part`: followers that chase the Anima's place with the lags `part.lags`, each pushing blades outward and pressing them down); the sun through the one shadow map read once a vertex, a wrapped diffuse term, light transmitted toward the viewer, a glint where a blade's face turns the sun toward the viewer (`grass.light.gloss`, `glossPower`), and sky and ground light. Far from the camera it thins: a tuft's rank against `grass.thin` decides whether it is drawn, every tuft is whole near the camera, and the kept blades widen with distance (never past `thin.widen`), so the far meadow covers the same ground with fewer blades. Draw order keeps the frame cheap (`GROVE_DRAW_RULES`): the meadow first, then the Oracle, then the rest by material, each material's wedges about the tree nearest first, and the ground last, so hidden ground and bark are never shaded. No Anima casts into the shadow map, and nothing an Anima wears or holds does; every worn piece is drawn in full, since the grove has no reflection or shadow pass that could show less. The ground and the grass darken the direct light where the sun's ray to a point passes near any of three spheres up the body of the player or of a companion, and the indirect light around each one's feet. The sun's shadow map is drawn once, of the grove without any Anima, and never again. The frame pipeline (`grove/post.ts`) renders the scene to a multisampled half-float target with depth, marches the mist at reduced resolution (a uniform haze, a ground layer and a little more in the canopy, billowed by the temple's noise lattice; in-scattered sunlight where the shadow map says the sun reaches, with a forward and a backward lobe; and ambient skylight) and, in the same pass, darkens creases and contact with the temple's screen-space occlusion at the grove's own tuning (`post.occlusion`), resolves it against the previous frame, composites it with a depth-aware upsample, and then blooms, vignettes, warms, tone-maps, grades, antialiases and presents, reusing the temple's bloom, temporal resolve, FXAA and present programs; the present pass is given the grove's own void, the entrance's darkness, and draws the fade. It draws at `GROVE_RULES.render`: the temple's budget, except that a dense screen is drawn at its own pixels before the cap and the governor apply. The scene's reflections are one environment capture of the grove at the start; what the player and the companions hold and wear reflects it with `light.finishChroma` of its colour, the temple's own share, so their steel stays steel under the green of the forest.
- **Lifecycle.** As the temple: the host waits until visible, opens the stage as an orchestrator job that hears progress after the model, the player's birth, the companions' births, each garment and rigid piece the cloth workers build for what they wear (asked for and waited for as in the temple), the pipeline, the grove, the environment capture, the player's and the companions' gear, each compile and the two warm frames (one from the arrival, one from the spawn, at one pixel, so the meadow, the forest and the tree are uploaded and the sun's one shadow map is drawn before the grove is first seen); it is built on a canvas of its own and attached to the page, then the temple is built at background priority; it stops frames and clears input while hidden, offscreen, in forced colours or print (which show a text description with the Oracle's words), offers Reload scene on failure (a fresh stage on a fresh canvas), stops frames on the black frame of a departure before the host opens the temple, is kept detached while the visitor is on `/anima-adventure`, and is disposed with everything it made once a client navigation leaves that page.
- **Source.** `@pages/anima-adventure.tsx`, `@components/AnimaAdventure.tsx`, `@components/AnimaGrove.tsx`, `@components/PlayerHud.tsx`, `@components/KnotworkBorder.tsx`, `@components/knotwork-geometry.ts`, `@components/AnimaPlayer.module.css`, `@components/scene-passage.ts`, `grove/rules.ts`, `grove/shape.ts`, `grove/surface.ts`, `grove/foliage.ts`, `grove/meadow.ts`, `grove/oracle.ts`, `grove/forest.ts`, `grove/fireflies.ts`, `grove/environment.ts`, `grove/post.ts`, `grove/stage.ts`, with `player/rules.ts`, `player/hands.ts`, `player/hero-gear.ts`, `player/shot-rules.ts`, `player/shots.ts`, the player's build in `player/duel.ts` (`playerHeroCharacter`, `playerHeroHand`, `playerHeroStride`), `player/markers.ts`, `player/noise.ts`, `player/parchment.ts` and `player/post.ts`, and the party's `player/party.ts`, `player/loiter.ts`, `player/companions.ts` and `player/fallen.ts`, shared with the temple. `ADVENTURE.forest` owns the route and sidebar label. `GROVE_RULES` is the complete configuration (the camera's shared fields and the render budget's are `PLAYER_RULES`' own, each face bump is `[across, height, radius across, radius up, tilt, height of the swell]`, and each face moss patch the first five of those):

```json
{
  "version": "set-world-0-15-35-grove-9",
  "seed": 3187,
  "spawn": { "x": -10, "z": 55, "yaw": 0 },
  "clearing": { "radius": 76, "bank": 7, "bankLead": 1.5, "bankReach": 30 },
  "terrain": {
    "swells": [[34, 0.7], [21, 0.5], [13, 0.34], [8.5, 0.2], [4.6, 0.09], [2.7, 0.04]],
    "mound": 3.6,
    "moundReach": 14,
    "extent": 240,
    "slopeStep": 0.25,
    "knoll": { "radius": 9.5, "height": 6 },
    "hillocks": { "count": 9, "radius": [4.5, 9], "height": [0.9, 2.6], "inner": 4, "outer": 9, "apart": 0.8, "attempts": 60 }
  },
  "trunk": {
    "radius": 14,
    "flare": 7,
    "flareHeight": 7,
    "taper": 2.4,
    "height": 70,
    "crown": 5,
    "crownHeight": 14,
    "lobe": 0.14,
    "lobeTop": 0.04,
    "lobeHeight": 14,
    "lobeWidth": 0.2,
    "lobeRest": 0.25,
    "twist": 0.008,
    "rope": 2.3,
    "ropeCount": 21,
    "ropeStretch": 0.03,
    "ropeFine": 0.8,
    "ropeFineCount": 58,
    "bury": 4,
    "capRows": 8,
    "capHeight": 8,
    "columns": { "fine": 0.1, "coarse": 0.34, "ease": 1.7 },
    "rows": { "low": 0.5, "face": 0.11, "grow": 1.06, "high": 2.6 },
    "wobble": 1.3,
    "wobbleScale": 0.09,
    "burls": { "count": 34, "radius": [0.9, 2.4], "height": [0.35, 1.1], "reach": [3, 52] }
  },
  "roots": {
    "count": 9,
    "spread": 0.24,
    "length": [17, 31],
    "radius": [3.3, 0.38],
    "bend": 0.55,
    "wave": 0.07,
    "waves": [1.5, 3.5],
    "points": 14,
    "inset": 3.4,
    "blocking": 0.6,
    "rise": 0.3,
    "arch": 0.55,
    "flare": 0.6,
    "sink": 1.5,
    "radialSegments": 32,
    "lump": 0.22,
    "lumpScale": 0.55,
    "ridge": 0.16,
    "ridges": 7,
    "flatten": 0.82,
    "rootlets": 4,
    "rootletLength": [5, 13],
    "rootletRadius": [0.5, 0.07],
    "rootletFrom": [0.12, 0.7],
    "rootletTurn": [0.5, 1.2]
  },
  "face": {
    "centerHeight": 10.2,
    "halfHeight": 9.4,
    "halfWidth": 9.2,
    "calm": 0.82,
    "hollowDepth": 0.9,
    "reach": 16,
    "bumps": [
      [0, 16.6, 6.5, 2.4, 0, 0.7],
      [0, 17.3, 3.4, 0.16, 0, -0.14],
      [0, 18.3, 2.6, 0.15, 0, -0.1],
      [2.3, 14.9, 1.9, 0.8, 0.18, 1.25],
      [5.4, 14.6, 2.3, 0.85, -0.34, 1.35],
      [3.9, 12.6, 2.6, 1.7, 0, -0.55],
      [3.9, 12.75, 2, 1, -0.05, 0.75],
      [3.9, 11.55, 1.9, 0.6, 0, 0.55],
      [3.9, 12.3, 1.05, 0.2, 0, -0.75],
      [2.75, 12, 0.75, 0.19, 0.5, -0.6],
      [5.05, 12, 0.75, 0.19, -0.5, -0.6],
      [6.3, 12.25, 0.7, 0.13, 0.35, -0.3],
      [6.35, 11.8, 0.7, 0.13, -0.1, -0.3],
      [6.2, 11.35, 0.65, 0.12, -0.5, -0.26],
      [0, 12.6, 1.05, 2, 0, 0.8],
      [0, 10.6, 1.35, 1.8, 0, 1.3],
      [0, 8.9, 1.9, 1.5, 0, 2.3],
      [1.75, 8.6, 0.95, 0.8, 0, 1.1],
      [1.2, 8.05, 0.45, 0.2, 0.2, -0.45],
      [5.3, 9.7, 2.7, 2.2, 0.25, 1.5],
      [3, 8, 0.35, 1.3, 0.45, -0.5],
      [0, 7.75, 1.2, 0.6, 0, 0.6],
      [1.9, 7.55, 2.2, 0.75, -0.22, 0.95],
      [0, 6.55, 1.5, 0.22, 0, -0.8],
      [2.35, 6.8, 1.15, 0.2, 0.3, -0.7],
      [3.75, 7.3, 0.6, 0.2, 0.55, -0.5],
      [4.35, 7.55, 0.4, 0.4, 0, -0.35],
      [0, 5.85, 1.9, 0.55, 0, 0.6],
      [0, 4.2, 2.8, 1.5, 0, 1.2],
      [4.6, 5.2, 2.2, 2.2, 0, 0.5]
    ],
    "moss": [[2.3, 15.1, 1.9, 0.6, 0.18], [5.4, 14.8, 2.3, 0.65, -0.34], [0, 7.8, 1.2, 0.5, 0], [1.9, 7.6, 2.2, 0.6, -0.22]],
    "crease": 0.6,
    "creaseShare": 0.35,
    "locks": { "perSide": 7, "from": [8.5, 12.5], "top": [19, 27], "bottom": [5.5, 11], "radius": [0.16, 0.32], "away": 0.5, "wave": 0.45, "points": 8, "radialSegments": 9 }
  },
  "entrance": {
    "halfWidth": 3.2,
    "height": 2.8,
    "squareness": 2.4,
    "depth": 7.5,
    "rim": 0.14,
    "lip": 0.45,
    "lipWidth": 0.22,
    "void": [1, 5.5],
    "depart": 3.5,
    "voidOutline": 1.02,
    "arrival": 5
  },
  "boughs": {
    "count": 9,
    "start": [34, 62],
    "reach": [46, 86],
    "rise": [9, 34],
    "radius": [3.8, 0.6],
    "sag": 5.5,
    "points": 9,
    "tubeSegments": 72,
    "radialSegments": 24,
    "twigs": 5,
    "twigReach": [14, 32],
    "twigRadius": 1.2,
    "lump": 0.12,
    "lumpScale": 0.3,
    "framing": [{ "angle": -0.95, "start": 30, "reach": 72, "rise": 10 }, { "angle": 0.9, "start": 34, "reach": 64, "rise": 12 }]
  },
  "vines": { "count": 300, "length": [5, 26], "radius": [0.045, 0.11], "from": 0.25, "bunch": 2.5, "radialSegments": 7, "leaves": 0.4, "leafEvery": 2.1, "leafSize": [0.7, 1.5] },
  "boulders": {
    "count": 30,
    "radius": [0.8, 2.9],
    "inner": 6,
    "outer": 4,
    "clear": 9,
    "sink": 0.36,
    "squash": [0.55, 0.95],
    "pebbles": 420,
    "pebbleRadius": [0.1, 0.55],
    "attempts": 40,
    "satellites": [2, 5],
    "satelliteRadius": [0.18, 0.42],
    "satelliteReach": 1.5
  },
  "wall": { "spacing": 5, "radius": [1.7, 2.8], "jitter": 0.12, "setBack": [0.2, 1.6], "height": [52, 84], "flare": 1.9, "flareRise": 22 },
  "forest": {
    "rows": [{ "offset": 11, "spacing": 7 }, { "offset": 21, "spacing": 9.5 }, { "offset": 34, "spacing": 13 }, { "offset": 52, "spacing": 17 }, { "offset": 76, "spacing": 22 }],
    "rowJitter": 3.4,
    "radius": [1.1, 3.2],
    "lean": 0.05,
    "crownCards": 34,
    "crownRadius": [10, 18],
    "crownDepth": 0.5,
    "trunks": { "wall": [56, 44], "row": [24, 20], "sapling": [12, 12] },
    "variants": 4,
    "rowVariants": 2,
    "buttresses": [4, 7],
    "buttress": 0.34,
    "buttressTwist": 2.5,
    "flutes": [9, 16],
    "flute": 0.075,
    "fluteStretch": 5,
    "sweep": 0.5,
    "knots": [3, 7],
    "knotSwell": [0.1, 0.24],
    "knotHeight": [0.02, 0.045],
    "knotWidth": [0.22, 0.45],
    "knotFrom": [0.03, 0.3],
    "limbs": [2, 5],
    "limbHeight": [8, 30],
    "limbReach": [6, 14],
    "limbRise": [0.5, 5],
    "limbRadius": 0.24,
    "limbCards": 11,
    "limbCluster": [3, 5.5],
    "limbSize": [3, 6.5],
    "limbSegments": 16,
    "limbSides": 10,
    "limbRows": 2,
    "limbSpread": 1.7
  },
  "thicket": {
    "saplings": 190,
    "saplingHeight": [5, 15],
    "saplingRadius": [0.1, 0.3],
    "saplingCards": 12,
    "saplingCluster": [1.8, 3.6],
    "saplingSize": [1.6, 3.2],
    "depth": [0.5, 12],
    "bushes": 620,
    "bushCards": 8,
    "bushSize": [1.3, 3.1],
    "bushLift": [0.5, 2.6],
    "bushRadius": [1.3, 3],
    "bushDepth": [-0.6, 9],
    "logs": 14,
    "logLength": [7, 15],
    "logRadius": [0.55, 1.1],
    "logDepth": [1.2, 7],
    "rocks": 70,
    "rockRadius": [0.7, 2.3],
    "rockDepth": [0.4, 8]
  },
  "crown": {
    "cardSize": [5.5, 11.5],
    "cluster": 6.5,
    "squash": 0.6,
    "boughCards": 16,
    "boughFrom": 0.3,
    "spacing": 6.2,
    "fill": 90,
    "fillCards": 22,
    "fillRadius": 10,
    "fillHeight": [58, 90],
    "fillReach": 88,
    "gaps": 0.63,
    "gapScale": 0.04,
    "sunWindow": 15,
    "lift": 4,
    "normalLift": 0.45,
    "shade": [0.55, 1]
  },
  "understory": {
    "ferns": 1500,
    "fronds": [6, 11],
    "frondLength": [1.1, 3],
    "frondTilt": [0.5, 1.15],
    "frondDroop": [0.5, 1.1],
    "frondAspect": 0.4,
    "frondSegments": 5,
    "edgeShare": 0.5,
    "edge": 10,
    "clear": 3.5,
    "plants": 520,
    "leaves": [4, 8],
    "leafLength": [0.7, 1.9],
    "leafAspect": 0.55,
    "leafTilt": [0.35, 1],
    "leafDroop": [0.3, 0.8],
    "leafSegments": 3,
    "flowers": 3200,
    "stem": [0.3, 0.75],
    "bloom": [0.2, 0.36],
    "patchScale": 0.07,
    "patchShare": 0.58,
    "clusters": [3, 7],
    "clusterReach": 1.1
  },
  "grass": {
    "tufts": 380000,
    "blades": 7,
    "levels": 3,
    "height": [0.42, 0.9],
    "width": [0.044, 0.08],
    "spread": 0.36,
    "lean": [0.2, 0.6],
    "taper": 1.6,
    "facing": 0.6,
    "reach": 2,
    "cell": 10,
    "jitter": 1,
    "patchScale": 0.14,
    "bare": 0.1,
    "patchHeight": [0.7, 0.6],
    "tall": 0.07,
    "tallHeight": 1.6,
    "girth": [0.8, 1.3],
    "dryScale": 0.035,
    "dry": [-0.4, 0.75],
    "dryJitter": 0.22,
    "tipDry": 0.25,
    "pathThin": 1,
    "pathLean": 0.75,
    "pathReach": 3.2,
    "obstacleLean": 0.6,
    "obstacleReach": 1.6,
    "thin": { "near": 4, "far": 54, "share": 0.07, "band": 0.2, "widen": 3.2 },
    "cover": { "size": 256, "margin": 2, "edge": [0.3, 0.7], "fray": 0.5, "green": 0.4, "shade": 0.7 },
    "part": { "radius": 1.25, "push": 1.5, "flatten": 0.6, "lags": [0, 0.3, 0.7, 1.3, 2.1], "weights": [1, 0.75, 0.55, 0.4, 0.28], "jump": 1.2, "reach": 3 },
    "light": { "wrap": 0.45, "transmit": 0.85, "ambient": 1.3, "rootShade": 0.5, "rootReach": 0.55, "ridge": 0.22, "sheen": 0.16, "gloss": 0.06, "glossPower": 14, "shadowBias": 0.0015 }
  },
  "fireflies": {
    "count": 520,
    "radius": 84,
    "height": [0.5, 34],
    "drift": [1.2, 3.6],
    "rate": [0.12, 0.5],
    "size": [0.13, 0.36],
    "rings": 0.22,
    "ringWidth": 0.22,
    "intensity": 5.5,
    "flicker": 0.55,
    "flickerRate": [0.6, 2.2],
    "minimumPixels": 1.5
  },
  "motes": { "count": 90, "radius": 60, "height": [1, 30], "size": [0.14, 0.3], "fall": [0.4, 0.9], "drift": 2.2, "spin": [0.6, 2.4] },
  "wind": {
    "sway": 0.18,
    "rate": 0.9,
    "scale": 0.11,
    "gust": 0.5,
    "meadow": { "toward": [0.86, 0.5], "lean": 0.12, "gust": 0.42, "scale": 0.3, "rate": 1.4, "cross": 0.11, "flutter": 0.045, "flutterRate": 3.4 }
  },
  "conversation": { "enter": 14, "leave": 17, "lift": 20, "edge": 0.04, "tailInset": 0.12 },
  "camera": {
    "distance": 18,
    "minimumDistance": 4,
    "maximumDistance": 28,
    "pitch": 0.24,
    "minimumPitch": 0.02,
    "maximumPitch": 1.05,
    "fieldOfView": 50,
    "near": 0.1,
    "far": 640,
    "targetShare": 0.95,
    "follow": 9,
    "rise": 4.5,
    "release": 5,
    "pull": 14,
    "orbitPerPixel": 0.005,
    "keyOrbit": 1.8,
    "zoomPerPixel": 0.002,
    "clearance": 0.35,
    "lockFollow": 2.4,
    "lockMinimum": 1.5,
    "groundClearance": 1.5,
    "sightClearance": 0.9,
    "clearanceReach": 6,
    "rideSlope": 0.5,
    "marchStep": 0.45,
    "refine": 5,
    "forestMargin": 0,
    "barkMargin": 1.6,
    "stoneReach": 1.4,
    "pointerStep": 0.9,
    "archMargin": 0.1
  },
  "render": { "supersample": 1.5, "deviceSupersample": 1, "maximumDensity": 3, "maximumPixels": 8294400, "samples": 4 },
  "light": {
    "exposure": 1.18,
    "ambient": 2.5,
    "environment": 0.55,
    "finishChroma": 0.5,
    "capture": { "height": 3.4, "size": 256, "blur": 0.04 },
    "sun": { "intensity": 12.5, "toward": [-0.42, 0.8, 0.46], "distance": 260, "extent": 104, "depth": 560, "mapSize": 4096, "bias": -0.0006, "normalBias": 0.1, "radius": 2.5 },
    "hero": { "spheres": [[0.14, 0.2], [0.5, 0.24], [0.84, 0.17]], "softness": 0.55, "contact": 0.5, "contactReach": 0.42 },
    "leaf": { "transmit": 0.75, "wrap": 0.35 }
  },
  "surface": {
    "mossScale": 0.075,
    "mossDetail": 1.7,
    "sunny": 0.55,
    "soil": 0.3,
    "path": { "width": 2.2, "soft": 2.6, "strength": 0.72, "wander": 3.2, "wanderScale": 0.06, "short": 9 },
    "fuzz": { "scale": 6, "depth": 0.07, "octaves": 3 },
    "fade": [24, 80],
    "cushion": { "scale": 1.9, "depth": 0.3, "shade": 0.22, "lift": 0.22, "edge": [0.3, 0.7], "carpet": 0.78 },
    "litter": { "scale": 8, "share": 0.05, "depth": 0.012 },
    "fibre": { "scale": 52, "tone": 0.34, "depth": 0.018 },
    "gravel": { "share": 0.3, "depth": 0.05 },
    "bark": {
      "ridge": [0.95, 0.1],
      "ridgeDepth": 0.9,
      "plate": [0.5, 1.1],
      "plateDepth": 0.14,
      "crease": 0.55,
      "mossFrom": [0.58, 1.02],
      "patch": [0.52, 0.8],
      "patchShare": [0.12, 0.6],
      "mossHeight": 46,
      "damp": 0.4,
      "lichen": 0.4,
      "lichenScale": 0.9,
      "fine": 3.4,
      "fineDepth": 0.3,
      "faceShade": 0.72,
      "faceMoss": 0.8,
      "faceWorn": 0.12,
      "faceSmooth": 0.22,
      "faceBrow": 0.85
    },
    "rock": { "scale": 1.2, "depth": 0.3, "mossFrom": [0.3, 0.8], "strata": 2.6, "strataDepth": 0.12, "lichen": 0.5, "lichenScale": 2.2 },
    "roughness": { "moss": 0.96, "bark": 0.9, "rock": 0.8 },
    "lattice": { "size": 64, "stream": 5, "turn": [0, 0.8, 0.6, -0.8, 0.36, -0.48, -0.6, -0.48, 0.64] }
  },
  "fog": {
    "resolution": 0.5,
    "cssResolution": 0.6,
    "steps": 30,
    "maximumDistance": 260,
    "base": 0.0026,
    "ground": 0.0075,
    "groundHeight": 3.2,
    "canopy": 0.001,
    "canopyFrom": [28, 62],
    "noiseScale": 0.045,
    "noiseAmount": 0.75,
    "wind": [0.05, -0.03],
    "rise": 0.012,
    "anisotropy": 0.62,
    "backAnisotropy": -0.2,
    "forwardShare": 0.7,
    "multipleScatter": 0.9,
    "sun": 1.05,
    "ambient": 0.62,
    "open": 0.3,
    "shadowBias": 0.002,
    "opaque": 0.01,
    "sky": 0.7
  },
  "post": {
    "bloom": { "threshold": 1.05, "knee": 0.6, "strength": 0.4 },
    "vignette": { "inner": 0.45, "outer": 1.25, "strength": 0.26 },
    "lift": 0.012,
    "saturation": 1.02,
    "warmth": 0.085,
    "occlusion": { "radius": 1.1, "nearShare": 0.12, "samples": 10, "strength": 1.1, "bias": 0.035, "power": 1.3 }
  }
}
```

The Oracle's name and words (`GROVE_DIALOGUE`):

```json
{ "name": "Oracle", "text": "Darkness cannot drive out darkness: only light can do that. Hate cannot drive out hate: only love can do that." }
```

The grove's helpers need no renderer. Their derivation is [ALGORITHMS §16.12](https://set.world/algorithms#1612-the-oracles-grove). Their shapes are:

```ts
type PlayerPlace = PlayerPoint & { yaw: number };                          // where a player starts and the way it faces; the camera opens behind it
type PlayerWorld = {                                                       // what advancePlayer and createPlayerState walk on; PLAYER_TEMPLE by default
  spawn: PlayerPlace; arrival: PlayerPlace; ledges: readonly PlayerLedge[]; // the spawn for a direct visit, the arrival for a passage from the other scene
  groundHeight(x: number, z: number): number;
  positionAllowed(x: number, z: number, others: readonly PlayerObstacle[], feet: number): boolean;
};
type GrovePoint3 = { x: number; y: number; z: number };
type GroveRoot = { angle: number; points: readonly (PlayerObstacle & { share: number })[] }; // GROVE_ROOTS: each root's centre line from the trunk outward
type GroveBoulder = PlayerObstacle & { squash: number; turn: number; shape: number };       // GROVE_BOULDERS
type GroveHillock = PlayerObstacle & { height: number };                                    // GROVE_HILLOCKS: a centre, a radius and a height; the first is the start's knoll
type GroveWallTree = PlayerObstacle & { height: number; turn: number };                     // GROVE_WALL: the ring of trees at the clearing's edge
type GroveEntrance = { mouth: number; back: number; halfAngle: number; x: number; z: number }; // GROVE_ENTRANCE: the mouth's and back wall's distance from the axis, the half-angle of its walls, and the unit bearing (x, z) it opens along
```

A complete local step, for a source-based replica:

```ts
import { PLAYER_RULES, createPlayerState, advancePlayer, setPlayerDestination, createPlayerFade, closePlayerFade } from '@engine/player/rules';
import { PARTY_AT_EASE, PlayerParty, partyCharacters } from '@engine/player/party';
import { PLAYER_FALLEN } from '@engine/player/fallen';
import { GROVE_RULES, GROVE_WORLD, groveCameraPitch, groveCameraReach, groveCameraRide, groveDepartureDue, groveGroundHeight, groveGroundUnderRay, groveOracleAnchor, oracleInRange } from '@engine/grove/rules';

const player = createPlayerState(GROVE_WORLD, arrivedThroughTheTemple);                // at GROVE_RULES.spawn, or at GROVE_ARRIVAL when reached through the temple, on the ground
const party = new PlayerParty(partyCharacters(partyBirths), GROVE_WORLD);              // the temple's companions, on the grove's ground; party.reset(player) stands them behind the player
const fade = createPlayerFade(arrivedThroughTheTemple);                                // keep across frames; true starts black and opens
const walkTo = groveGroundUnderRay(pointerOrigin, pointerDirection, GROVE_RULES.camera.far, { x: 0, y: 0, z: 0 }); // a right-click: null on the trunk (outside the entrance) or the sky
if (walkTo) setPlayerDestination(player, walkTo);
advancePlayer(player, { forward: 1, right: 0, jump: false }, cameraYaw, PLAYER_RULES.step, [], GROVE_WORLD);
const leader = { x: player.x, z: player.z, yaw: player.yaw, speed: Math.hypot(player.velocityX, player.velocityZ), busy: player.action !== null || !player.grounded };
party.step(PLAYER_RULES.step, leader, { ...PARTY_AT_EASE, fallen: (index) => PLAYER_FALLEN.has(party.members[index].name) }, [{ x: player.x, z: player.z, radius: PLAYER_RULES.radius }]); // once per fixed step, after advancePlayer: at ease they follow, and loiter once the player rests; whoever fell in the temple is left out; the list is the bodies they walk around
const feet = { x: player.x, y: player.y, z: player.z };                                // y equals groveGroundHeight(x, z) while grounded
const speaking = oracleInRange(player, wasSpeaking) && fade.phase === 'clear';         // pass the previous answer for hysteresis; closed while the frame fades
if (groveDepartureDue(player)) closePlayerFade(fade);                                  // the same fade as the temple's (its build sheet above), leaving for /anima-adventure?scene=2
const cardPoint = groveOracleAnchor(player, { x: 0, y: 0, z: 0 });                     // where the card points
const pitch = groveCameraPitch(aim, cameraYaw, cameraPitch);                           // the visitor's pitch, lowered under the arch while the aim is inside the hollow
const towardCamera = { x: Math.sin(cameraYaw) * Math.cos(pitch), y: Math.sin(pitch), z: Math.cos(cameraYaw) * Math.cos(pitch) };
const arm = groveCameraReach(aim, towardCamera, zoomDistance);                         // how far the camera may sit from its aim point along a unit direction
const camera = { x: aim.x + towardCamera.x * arm, y: aim.y + towardCamera.y * arm + groveCameraRide(aim, towardCamera, arm), z: aim.z + towardCamera.z * arm }; // lifted over the ground, looking at aim
```

`createPlayerState(world, arriving)` and the last argument of `advancePlayer` take the world; both default to the temple (`PLAYER_TEMPLE`), and `arriving` (default `false`) starts the player at the world's arrival instead of its spawn, facing the place's yaw. `GROVE_ARRIVAL` is the grove's arrival and `groveCameraPitch(aim, yaw, pitch)` the pitch the camera uses at a yaw: the given pitch, or a lower one, never below `camera.minimumPitch`, that leaves the hollow under the arch while the aim stands inside it. `grovePositionAllowed(x, z, others)` is the grove's test and `GROVE_OBSTACLES` its circles; the trunk's circle does not stop a player inside the entrance's fully open part. `groveTrunkRadius(height)` is the trunk's mean radius at a height above its foot (`GROVE_TRUNK_BASE`, the ground height there), `groveTrunkLobe(height)` the share by which a buttress widens it, `groveTrunkRidge(angle)` how much of that share an angle takes from the nearest root (from `1 - trunk.lobeRest` over a root to `-trunk.lobeRest` between them) and `groveTrunkSurface(angle, height)` the lobed mean surface those give, before ropes, wobble, burls and the face. `groveEntranceOutline(angle, height, inset)` is where a point lies against the entrance's outline (1 on it, less inside; `inset` shrinks the outline by that distance), `groveEntranceHolds(x, y, z, inset)` whether a world point lies inside the hollow (within the outline, in front of the back wall) and `groveDepartureDue(player)` whether the player stands inside it past `entrance.depart` behind the mouth. At an angle about the trunk's axis and a height above its foot, `groveFaceRelief` is how far the face raises (or sinks) the bark, `groveFaceHollow` how deep in a crease or a socket the point lies (0 to 1), `groveFaceMoss` how mossed the brows and moustache are there (0 to 1) and `groveFaceShare` how far inside the face the point is (1 inside, 0 outside); `GROVE_FACE_ANGLE` is the bearing the face looks along. `grovePathAside(x, z)` is the distance from the path's centre line and `grovePathShare(x, z)` how worn the ground is there (0 to 1). How a pose is drawn, and the grove's meshes, shaders and frame pipeline, need a browser. Plain HTTP returns the page shell, not a rendered grove.
