@spawnite/engine 0.1.0-beta.15

package/dist/wiki/engine/behaviours/targeting.md

@@ -0,0 +1,155 @@
+---
+title: Targeting
+description: Chooses the player's target for her abilities, by soft lock, a click or a tap, and the Tab key, and marks it on the ground.
+useCases:
+    - tab target an enemy
+    - click to target an enemy
+    - soft lock target
+    - target marker under an enemy
+    - lock on to an enemy
+    - choose a target for spells
+    - highlight the selected enemy
+    - mmo style targeting
+    - make an enemy targetable
+sidebar:
+    order: 16
+---
+
+Targeting chooses which hostile the player's [abilities](/engine/behaviours/abilities/) strike. The chosen target is the `TargetTrait { entity, pinned }` trait on her character. Every ability reads the trait, and none asks how the target was chosen.
+
+Its props are in [`TargetingProps`](https://wiki.spawnite.com/reference/abilities/targetingprops/).
+
+## Choose targets with no settings
+
+Put `<Targeting />` anywhere in the scene:
+
+```tsx
+import { CharacterSpawn, Targeting } from "@spawnite/engine";
+
+export function Character() {
+    return (
+        <>
+            <CharacterSpawn abilities={["arcane-bolt"]} />
+            <Targeting />
+        </>
+    );
+}
+```
+
+With no props, it chooses as follows:
+
+- **Soft lock.** Each frame it targets the nearest hostile target in front of her: within 8 m, and within 60 degrees either side of her facing.
+- **A click or a tap** on a hostile target pins it. A pinned target stays, behind her or far away, until it dies or she pins another. Then soft lock takes over again. Where the camera walks her to a click, a click on a hostile target selects it and walks her nowhere.
+- **Tab** pins the next hostile target in front, nearest first, and the nearest again after the farthest.
+
+A target is anything with the `TargetableTrait { faction }` trait whose `faction` is `Faction.Hostile`, the default, and whose health is above zero. A click picks a target by the bounds of what it draws.
+
+It also draws a ring on the ground under the target, sized to its body and coloured by its faction: red for hostile, yellow for neutral and green for friendly. The ring is faint and thin while the soft lock chose the target, solid and wider once the player pinned it, and it flashes each time a hit lands on the target.
+
+## Make an enemy a target
+
+`<Health>` alone does not make an entity a target, and neither does an [NPC](/engine/entities/npc/)'s `faction`. Give each enemy `TargetableTrait` with a behaviour of the game's own beside its `<Health>`, as [Behaviours](/engine/entities/entity/#behaviours) describes; the behaviour sits inside an `<Npc>` as it does inside an `<Entity>`. A system that spawns enemies adds `TargetableTrait` among their traits, as [the spawner on the Health page](/engine/behaviours/health/#spawn-one-at-runtime) does. The room's tests mount this dummy in a room's scene, check that a player's page holds it as a hostile target and that the room lets a cast target it, and check that an entity with Health alone is no target:
+
+```tsx title="packages/room/test/outside/TrainingDummy.tsx"
+import {
+    defineBehaviour,
+    Entity,
+    Faction,
+    Health,
+    RunContext,
+    TargetableTrait,
+    useBehaviour,
+    type EntityProps,
+} from "@spawnite/engine";
+
+const TargetableBehaviour = defineBehaviour({
+    name: "targetable",
+    trait: TargetableTrait,
+    runsOn: RunContext.Server,
+    description: "An entity abilities and Targeting can pick.",
+});
+
+interface TargetableProps {
+    /** Whose side it is on: abilities strike a hostile one. */
+    faction?: Faction | `${Faction}`;
+}
+
+export function Targetable({ faction = Faction.Hostile }: TargetableProps) {
+    useBehaviour(TargetableBehaviour, { faction: faction as Faction });
+    return null;
+}
+
+export function TrainingDummy({ position }: Pick<EntityProps, "position">) {
+    return (
+        <Entity position={position}>
+            <Health maximum={60} />
+            <Targetable />
+            <mesh>
+                <cylinderGeometry args={[0.4, 0.4, 1.8]} />
+                <meshStandardMaterial color="#b08850" />
+            </mesh>
+        </Entity>
+    );
+}
+```
+
+## Change one thing
+
+Each prop changes one thing:
+
+- `mode`: `TargetMode.SoftLock`, the default, or `TargetMode.Tab` for classic tab-target, which selects nothing until the player clicks, taps or presses Tab.
+- `range`: metres within which a target is in front. 8 by default.
+- `angle`: degrees either side of her facing within which a target is in front. 60 by default.
+- `cycleKey`: the key that cycles, as `KeyboardEvent.code` names it. `"Tab"` by default.
+- `marker`: the mark under the target, one of the `GroundMark` shapes that [the player's walk marker](/engine/entities/player/) draws: `GroundMark.Ring`, the default, `Pulse`, `Sigil`, `Motes`, or `None` for no mark.
+- `colors`: the mark's colour for each faction, such as `{ [Faction.Hostile]: "#b04dff" }`. A faction left out keeps its default.
+
+```tsx
+import { Targeting, TargetMode } from "@spawnite/engine";
+
+export function TabTarget() {
+    return <Targeting mode={TargetMode.Tab} range={30} />;
+}
+```
+
+## Read the target
+
+`useTarget()` returns the player's target and whether she pinned it, as `{ entity, pinned }`, and re-renders when either changes. A target frame reads it:
+
+```tsx
+import { useHealth, useTarget } from "@spawnite/engine";
+
+export function TargetFrame() {
+    const { entity } = useTarget();
+    const health = useHealth(entity);
+    return health ? <p>{health.current}</p> : null;
+}
+```
+
+A game that draws its own mark under the target reads it the same way, and passes `marker={GroundMark.None}` so that `<Targeting>` draws none.
+
+## Write your own mode
+
+Targeting is one writer of `TargetTrait`. A game's own system that writes it has made a new mode, such as the lowest-health ally for a heal. Leave `<Targeting>` out, and write the trait on the player's character:
+
+```ts
+import type { Entity } from "koota";
+import { readLocalCharacter, pinTarget, type World } from "@spawnite/engine";
+
+export function targetBoss(world: World, boss: Entity) {
+    const character = readLocalCharacter(world);
+    if (character) pinTarget(character, boss);
+}
+```
+
+The functions `<Targeting>` runs are exported for a game's own mode: `findTargetsInFront`, `updateTarget`, `cycleTarget`, `pinTarget` and `findClickedTarget`.
+
+## In a room
+
+`TargetTrait` is the page's alone. No stream carries it, and the room never reads it: each cast press carries the target, which travels as the key the room files it under, and the room judges its own copy of that target. So a page cannot cast at a target out of range by writing `TargetTrait`, and a room's own world, which has no player of its own, chooses no target.
+
+## What the other engines do
+
+World of Warcraft and Final Fantasy XIV tab-target, and the bolt always lands. Guild Wars 2 and New World aim at a reticle and can miss. Unreal's Gameplay Ability System reads target data from a `TargetActor` that a game subclasses. Roblox, Unity, Godot and PlayCanvas leave targeting to each game. This engine soft-locks by default, so a player on a phone casts with no cursor, and keeps World of Warcraft's click and Tab on top.
+
+World of Warcraft marks the selected unit with a circle on the ground in its reaction colour. Final Fantasy XIV draws a turning ring and an arrow over the head, and Diablo outlines the model. This engine draws World of Warcraft's circle by default, with the same shapes as the walk marker, so one setting names a mark for both.

package/dist/wiki/engine/behaviours/track-mover.md

@@ -0,0 +1,121 @@
+---
+title: TrackMover
+description: Rides an entity along a track, steered and jumping.
+useCases:
+    - car racing game
+    - kart or sled steering
+    - downhill slope ride
+    - rail shooter path
+    - jump along a track
+    - water slide ride
+    - icy track with low friction
+    - endless runner on a path
+sidebar:
+    order: 8
+---
+
+TrackMover rides an entity along a `Track` in track coordinates: a distance along the centerline, an offset across it, and a height above it. It has no physics body. Gravity along the slope adds speed, and drag and friction take it away, so every number that decides the ride is a prop. A sled, a racer, a rail shooter and a water slide ride this way.
+
+## The track
+
+`new Track(points)` builds a track from two or more points. The curve passes through every point. Each point may name a `width` in metres, blended to the next point, and 8 when left out. It may also name a `zone`, such as `"ice"`, which a [TrackSurface](/engine/graphics/track-surface/) draws in its own material. The track answers the following lookups:
+
+- `length`: metres from the start to the end.
+- `frameAt(distance)`: the position, the direction of travel (`tangent`), the level `right`, the surface's `up` and the `halfWidth` at that distance.
+- `pointAt(distance, lateral)`: the world point at those track coordinates, `lateral` positive to the right of travel.
+- `locate(point)`: the `distance` and `lateral` of the track point nearest a world point.
+- `zoneWeight(distance, zone)`: how much of `zone` the track is at that distance, from 0 to 1, blended between points.
+
+A `Track` is data built once, so build it at module level or in a `useMemo`.
+
+## Surface friction
+
+`new Track(points, { friction })` gives the track a surface that slows a grounded mover by where it rides. `friction({ track, distance, lateral })` returns a loss in 1/s at those track coordinates, and `track.frictionAt(distance, lateral)` reads it, 0 when the track has none. Each step adds it to the mover's own `friction` prop, so every mover on the track rides the same surface. A kart game returns 1 on the grass past its racing line and 0 on the asphalt. Sled returns the depth of the snow under the rider times 1.14, which costs about 0.04/s on a snow lane, 0.4/s at a shoulder's outer edge, and nothing on ice.
+
+Unity, Unreal, Godot, Roblox and PlayCanvas read friction off the material of the collider under a body. A mover has no contact, so its track answers in track coordinates instead.
+
+## Props
+
+Its props are in [`TrackMoverProps`](https://wiki.spawnite.com/reference/entity/trackmoverprops/).
+
+The step reads the player's steer and jump into every mover on an entity with `authority={RunContext.Client}`. A steer shifts it across, and releasing it holds the line it is on through a bend. At the track's edge the outward shift stops. A jump leaves only from the ground. For any other mover, such as a rival racer, the game writes `steer` and `jump` on its `TrackMoverTrait`. The trait also holds the ride's state, which a game reads for a speedometer or a landing: `distance`, `lateral`, `height`, `speed` and `airSeconds`.
+
+At the track's end the mover stops: `distance` holds at the track's `length` and `speed` reads 0, so a speedometer reads the stop. Unity's and Unreal's spline followers stop at the spline's end with their velocity cleared, and Godot's `PathFollow3D` with `loop` off holds at `progress_ratio` 1. A game that wants its mover to come to rest before the end slows it itself, as Sled brakes a finished run, and gives the track a run-out to slow on. A game that wraps a mover back to the start, for a lap, sets its `distance` and its `speed` together as it wraps.
+
+## Launch
+
+`launchTrackMover(entity, speed)` sets a mover going at `speed` metres a second from where it stands, and enables it: a sling's release, a starting gate or a boost pad. The speed replaces the one it had, as Unreal's `LaunchCharacter` replaces a character's velocity. A mover mounted with `enabled={false}` holds at its start until the launch.
+
+## A throttle
+
+Gravity is the only speed the mover adds on its own, so a car on flat ground needs a throttle. A throttle is a game system that adds to `speed` before `tracks.systems.move`. Unity's `WheelCollider.motorTorque`, Godot's `VehicleBody3D.engine_force` and Roblox's `VehicleSeat.Throttle` do the same job.
+
+The following throttle reads the mover's `throttle`, which the step copies from the character's move, `characters.inputs.move`, as it copies the move's x into `steer`. The value is 1 while the player holds W or pushes a stick up, and −1 while the player holds S. A stick pushed part of the way gives a value between the two. [The player's input](/engine/structure/systems/#the-players-input) describes the step's input. A room's step carries no input, so this throttle drives a car only in a game played alone. The tracks plugin needs `characters()` listed, whose move and jump it reads.
+
+```ts title="packages/engine/test/outside/throttle.ts"
+import {
+    AuthorityTrait,
+    definePlugin,
+    RunContext,
+    type System,
+    TrackMoverTrait,
+    tracks,
+} from "@spawnite/engine";
+
+/** Metres a second squared that forward held all the way adds. */
+const acceleration = 12;
+
+/** Speeds up the mover the player steers while she holds forward, W or a
+ *  stick pushed up, and slows it while she holds back. */
+const throttle: System = (world, { deltaSeconds }) => {
+    world
+        .query(TrackMoverTrait, AuthorityTrait)
+        .updateEach(([mover, { context }]) => {
+            if (context !== RunContext.Client) return;
+            const push = mover.throttle;
+            mover.speed = Math.max(
+                0,
+                mover.speed + push * acceleration * deltaSeconds,
+            );
+        });
+};
+
+export const car = definePlugin({
+    name: "car",
+    description: "The player's car: a throttle on forward and a brake on back.",
+    systems: {
+        motion: {
+            throttle: {
+                system: throttle,
+                before: [tracks.systems.move],
+                description:
+                    "Speeds up the player's car on forward and slows it on back, before the move.",
+            },
+        },
+    },
+});
+```
+
+To use the throttle, list `car` beside `tracks()` in the game's plugins. The mover's `drag` and `friction` still slow the car, so a held throttle settles at a top speed.
+
+## Where it runs
+
+Client. The mover runs in the step's move block and stands the entity at its track coordinates, facing down the track.
+
+```tsx
+import { Entity, RunContext, Track, TrackMover } from "@spawnite/engine";
+
+const run = new Track([
+    { x: 0, y: 0, z: 0, width: 6 },
+    { x: 8, y: -4, z: -20 },
+    { x: -8, y: -8, z: -45 },
+]);
+
+export function Sled() {
+    return (
+        <Entity model="sled" authority={RunContext.Client}>
+            <TrackMover track={run} distance={6} gravity={15.7} />
+        </Entity>
+    );
+}
+```

package/dist/wiki/engine/behaviours/track-trigger.md

@@ -0,0 +1,117 @@
+---
+title: TrackTrigger
+description: Reports a track mover entering and leaving a region of its track.
+useCases:
+    - finish line
+    - lap counting
+    - checkpoint on a track
+    - obstacle hit box on a track
+    - coin on a track
+    - speed boost zone
+    - track region trigger
+    - detect a racer entering an area
+sidebar:
+    order: 9
+---
+
+TrackTrigger marks a region of a [track](/engine/behaviours/track-mover/#the-track) in track coordinates and reports a [TrackMover](/engine/behaviours/track-mover/) that rides through it. A rock's hit box, a coin, and a finish line across the whole width are each one. Unreal calls this a trigger volume, Godot an `Area3D`, and Roblox fires `Touched`. Those three test a physics body, and a mover has none, so the step tests the mover's own coordinates instead.
+
+Its props are in [`TrackTriggerProps`](https://wiki.spawnite.com/reference/entity/tracktriggerprops/).
+
+## The region
+
+The region is a box in track coordinates:
+
+- `start` and `end`: metres along the centerline.
+- `left` and `right`: metres across, positive to the right of travel.
+- `bottom` and `top`: metres above the surface, against the mover's `height`. A mover that jumps higher than `top` clears the region.
+
+A bound left out is open, so a finish line names only `start` and `end`. The test reads the mover's point and not its size: to hit a rider a metre wide, pad the region by half a metre each side. Only a mover on the trigger's own `track` counts.
+
+## What it reports
+
+The step writes the report for the region as a whole on the entity:
+
+- `inside` on `TrackTriggerTrait`: a mover stands in the region.
+- `TriggerEnteredEvent`: an event the step adds when a mover comes in while none stood in the region, with the mover as `other` and its key as `otherKey`.
+- `TriggerExitedEvent`: an event the step adds when the last mover leaves, with that mover as `other`.
+
+Both come from the authoritative step alone, the room's or a game played alone, so a track trigger is heard once. They are the events a physics trigger raises, with a track trigger's own rule: first in and last out, swept over the mover's path along the track, where a physics trigger samples what overlaps it at each step, as [the entity page](/engine/entities/entity/#contacts-and-triggers) says.
+
+An event lasts until the start of the next step. A fast mover can pass a thin region inside one step. The test covers the ground the mover's speed carried it over during the step, so that pass adds both `TriggerEnteredEvent` and `TriggerExitedEvent` on one step, with `inside` false. Setting a mover's `distance` moves it without passing the ground between, so a reset to the start enters nothing on the way back. Across and up, the test reads where the step ended.
+
+A trigger marked `lap` counts a lap of the mounted [Round](/engine/structure/round/#a-race) on each entry.
+
+A game's system reads `TriggerEnteredEvent` with `readEvents` to act once per pass, and a view hears it with `useEvent`. A rider sits inside a rock's box for several steps, and `TriggerEnteredEvent` is emitted on the first of them only. The report is data, so a headless test steps a course and reads it without a screen.
+
+## Each mover
+
+The step also names each mover. On a trigger's first step it adds `TrackTriggerMoversTrait` beside `TrackTriggerTrait`, with two lists of mover entities:
+
+- `inside`: each mover that stands in the region.
+- `entered`: each mover that came in this step, including a fast one that passed through.
+
+A second rider that rides into a rock while the first still stands in it is in `entered`, though the trigger gets no `TriggerEnteredEvent` because the region never emptied. No list names a mover that left; `TriggerExitedEvent` says when the last one did. The state dump, from `dumpState` or `spawnite play dump`, shows both lists under the trigger's `trackTriggerMovers`, each mover named by the key its own entry in the dump carries. In a room, the stream carries both lists to every page, so a page reads the movers of the room's last send. A mover destroyed since the step is already out of each list: a destroy takes an entity out of every list that names it.
+
+Godot's `Area3D` emits `body_entered` for each body, Unreal's `OnComponentBeginOverlap` fires for each actor, and Roblox's `Touched` fires for each part. Here the step writes a list rather than calling back, so a game's system in its plugin's `rules` reads it after the move, as it reads the rest of the report:
+
+```ts title="packages/engine/test/outside/payOnEntry.ts"
+import type { World } from "koota";
+import {
+    addCoins,
+    createQuery,
+    definePlugin,
+    readEach,
+    TrackTriggerMoversTrait,
+    type AuthoritativeStep,
+} from "@spawnite/engine/core";
+
+const regions = createQuery(TrackTriggerMoversTrait);
+
+/** Pays a coin to each mover that rides into a region. */
+function payOnEntry(world: World, step: AuthoritativeStep) {
+    readEach(world, regions, ([movers]) => {
+        for (const mover of movers.entered) addCoins(step, mover, 1);
+    });
+}
+
+export const tolls = definePlugin({
+    name: "tolls",
+    systems: { rules: { payOnEntry } },
+});
+```
+
+## Where it runs
+
+Client. The test runs in the step's move block, straight after the move, on the coordinates it wrote. What an entry does, such as a stun, a coin or a finish, is the game's own system.
+
+```tsx
+import { Entity, Track, TrackTrigger } from "@spawnite/engine";
+
+const run = new Track([
+    { x: 0, y: 0, z: 0, width: 6 },
+    { x: 0, y: -10, z: -80, width: 6 },
+]);
+
+export function Course() {
+    return (
+        <>
+            {/* A rock 40 m down, a metre wide, cleared by a jump over 0.4 m. */}
+            <Entity name="Rock">
+                <TrackTrigger
+                    track={run}
+                    start={39.5}
+                    end={40.5}
+                    left={-1}
+                    right={1}
+                    top={0.4}
+                />
+            </Entity>
+            {/* The finish: the last 10 m, across the whole width. */}
+            <Entity name="Finish">
+                <TrackTrigger track={run} start={70} end={80} />
+            </Entity>
+        </>
+    );
+}
+```

package/dist/wiki/engine/behaviours/trigger.md

@@ -0,0 +1,158 @@
+---
+title: Trigger
+description: Fires a callback while the player's character stands within a radius.
+useCases:
+    - trigger zone
+    - area that fires when the player enters
+    - proximity detection
+    - enter and exit events
+    - hidden trap area
+    - cutscene trigger area
+    - detect player nearby
+    - checkpoint area
+    - exit gate that wins the round
+    - door that opens with keys
+sidebar:
+    order: 7
+---
+
+Trigger fires a callback the frame the character comes within a radius of an entity, and another the frame she leaves. The character here is an entity that carries the `ControlledTrait` trait, whether or not a player controls it now: every character `<CharacterSpawn>` spawns, and any other entity `control` linked to a player, a kart she has left among them. A view reads her own character with `useCharacter()`.
+
+Its props are in [`TriggerProps`](https://wiki.spawnite.com/reference/entity/triggerprops/).
+
+The step marks `inside` while the character stands within `radius`, emits the `TriggerEnteredEvent` event as she comes in and `TriggerExitedEvent` as she leaves, each with her as `other` and her key as `otherKey`. Trigger fires `onEnter` and `onExit` as its view hears each event, so a character who passes straight through between two rendered frames still fires `onEnter` and then `onExit`. A system queries the same events; a view hears them with `useEvent`. A callback is allowed here because Trigger is client behaviour: it changes what the page shows, such as a banner or a sound, and never decides an outcome. A gate that wins the round, a door that takes a key or a trap that deals damage is a system, as the following section shows.
+
+## Decide an outcome in a system
+
+`onEnter` runs on a page. In a room it runs on the page of the player who crossed, and the room never hears it, so a callback that wins the round wins it on that page alone. An outcome belongs in a system, which runs on the room and in a game played alone.
+
+The step emits `TriggerEnteredEvent` only as the trigger goes from empty to occupied, with the nearest character as `other`. A second player who walks in while the first still stands there emits no event. A system that cares who stands in the trigger asks each step instead: `findNearestControlled(world, position, { accepts })` returns the nearest character that `accepts` lets through, and the system compares her `distance` with the trigger's `radius`.
+
+The following exit gate wins the round when a player walks in holding three keys. `countItem(character, item)` counts what her bag holds, as [Inventory](/engine/behaviours/inventory/) says, and `finishRound(world)` wins the round, as [Round](/engine/structure/round/#a-race) says. The gate's own trait carries the keys it wants, through a behaviour of the game's own, as [Behaviours](/engine/entities/entity/#behaviours) describes. The room's tests mount the gate on a room two players join, stand one player with two keys in it, then walk in a second with three:
+
+```tsx title="packages/room/test/outside/ExitGate.tsx"
+import { createQuery, type World } from "koota";
+import {
+    countItem,
+    defineBehaviour,
+    definePlugin,
+    defineTrait,
+    Entity,
+    findNearestControlled,
+    inventory,
+    readEach,
+    RunContext,
+    TransformTrait,
+    Trigger,
+    TriggerTrait,
+    useBehaviour,
+    type EntityProps,
+    type NearestControlledSearch,
+} from "@spawnite/engine";
+import { finishRound, rounds } from "@spawnite/engine/rounds";
+
+/** The keys a player must hold as she walks into the gate. */
+export const GateTrait = defineTrait("exitGate", { keys: 3, item: "key" });
+
+const GateBehaviour = defineBehaviour({
+    name: "exitGate",
+    trait: GateTrait,
+    runsOn: RunContext.Server,
+    description: "Wins the round when a player walks in holding its keys.",
+});
+
+const gates = createQuery(GateTrait, TriggerTrait, TransformTrait);
+
+//  The keys the gate being checked wants, written in place per gate, so
+//  every gate and every step reuses one set of search options.
+const checked = { keys: 0, item: "" };
+const keyHolders: NearestControlledSearch = {
+    accepts: (character) => countItem(character, checked.item) >= checked.keys,
+};
+
+//  On the room, which alone decides the round, from the bags it keeps. It
+//  asks who holding the keys stands nearest, rather than reading the
+//  trigger's enter event, which fires only as the first player comes in:
+//  a player with the keys who joins one without them still wins.
+function finishRoundsAtGates(world: World) {
+    readEach(world, gates, ([gate, trigger, { position }]) => {
+        checked.keys = gate.keys;
+        checked.item = gate.item;
+        const nearest = findNearestControlled(world, position, keyHolders);
+        if (nearest && nearest.distance <= trigger.radius) finishRound(world);
+    });
+}
+
+export const exitGates = definePlugin({
+    name: "exit-gates",
+    requires: [rounds, inventory],
+    systems: {
+        rules: {
+            finish: finishRoundsAtGates,
+        },
+    },
+});
+
+interface ExitGateProps extends Pick<EntityProps, "position"> {
+    /** The keys she must hold. */
+    keys: number;
+}
+
+function GateLock({ keys }: Pick<ExitGateProps, "keys">) {
+    useBehaviour(GateBehaviour, { keys, item: "key" });
+    return null;
+}
+
+export function ExitGate({ position, keys }: ExitGateProps) {
+    return (
+        <Entity position={position}>
+            <Trigger radius={1.5} />
+            <GateLock keys={keys} />
+            <mesh>
+                <torusGeometry args={[1.2, 0.2, 16, 32]} />
+                <meshStandardMaterial color="#8a7cff" />
+            </mesh>
+        </Entity>
+    );
+}
+```
+
+List `exitGates` in the game's plugins after `rounds()` and `inventory()`. Its system, `finishRoundsAtGates`, runs on the room alone, since it names no `runsOn`, and in a game played alone. `<Trigger>` gives the gate its radius, and its `onEnter` can still show a banner on the page, as [Show something on the page](#show-something-on-the-page) does.
+
+## Where it runs
+
+Client. The callbacks only change what this client shows.
+
+In a room, "the player's character" is each page's own. The room steps the entity and streams its trait, whose `inside` marks any player's character, and its `TriggerEnteredEvent` and `TriggerExitedEvent`, which carry whichever character crossed. Each page's Trigger ignores them: it measures its own character against the streamed `radius` each frame, and fires the `onEnter` and `onExit` its own scene passed as she crosses it. Another player walking through fires nothing on this page. A character who passes straight through between two frames on a page in a room fires neither callback. A Server behaviour that needs to know which character is inside reads `findNearestControlled` in its system, as Pickup and Chase do.
+
+## Show something on the page
+
+A callback changes what this page shows and nothing else. The following place name appears over the old mill while this page's character stands within 4 metres of it, and goes as she leaves. No other page sees it, the room never hears it, and the round goes on. The engine's tests step a character in and out of the mill and read the name off the page:
+
+```tsx title="packages/engine/test/outside/PlaceName.tsx"
+import { useState } from "react";
+import { Anchor, Entity, Panel, Text, Trigger } from "@spawnite/engine";
+
+export function OldMill() {
+    const [isNear, setIsNear] = useState(false);
+
+    return (
+        <Entity position={[0, 0, -10]}>
+            <Trigger
+                radius={4}
+                onEnter={() => setIsNear(true)}
+                onExit={() => setIsNear(false)}
+            />
+            {isNear && (
+                <Panel anchor={Anchor.Above}>
+                    <Text>The old mill</Text>
+                </Panel>
+            )}
+            <mesh>
+                <boxGeometry args={[3, 4, 3]} />
+                <meshStandardMaterial color="#b08860" />
+            </mesh>
+        </Entity>
+    );
+}
+```