@adatechnology/game-contracts 0.22.0 → 0.23.0

package/dist/index.d.ts

@@ -656,6 +656,8 @@ interface EventBase {
     /** Seconds since the world was created. */
     time: number;
     source?: string;
+    /** The kind of hit the event came out of (a shot, a blow, a cut, a blast...), when it came out of a hit; the sound of an impact is chosen by it. */
+    blow?: DamageType;
 }
 /** Points in events are in world space. */
 type DestructionEvent = (EventBase & {
@@ -679,7 +681,8 @@ type DestructionEvent = (EventBase & {
     exitPoint?: Vec3;
     powder?: {
         color: number;
-    };
+    }; /** Joules the round still carries out of the part, when the part knows. */
+    energyLeft?: number;
 }) | (EventBase & {
     type: 'crack';
     part: string;
@@ -985,6 +988,40 @@ declare function blastShove(blast: BlastSource, target: {
     readonly mass: number;
 }, options?: BlastShoveOptions): BlastShove | undefined;
 
+/** From this speed (m/s) a blast takes a standing body off its feet. Below it the body is only pushed. */
+declare const KNOCK_DOWN_SPEED = 2.5;
+/** The angle of a body lying where it fell (the same tilt a dead body takes). */
+declare const KNOCKED_DOWN_ANGLE = 1.35;
+/** Height of the chest above the feet: where the blast takes the body. */
+declare const KNOCK_CHEST = 1.1;
+/** What a blast is doing to one body: its velocity (m/s), whether it is in the air, and how far down it is (0 on its feet, 1 lying). */
+interface Knock {
+    velocity: [number, number, number];
+    airborne: boolean;
+    /** 0..1 */
+    lying: number;
+    /** Seconds left to lie on the ground after it stopped. */
+    lieLeft: number;
+    /** Knocked off its feet by this blast. */
+    down: boolean;
+}
+/** The mass of a body in kg from its height (m) and its build (1 = average): 70 kg at 1.75 m. */
+declare const bodyMass: (height: number, build?: number) => number;
+/**
+ * What a blast does to a body standing at `feet`: the shove of `game-contracts` taken at the chest, a hop when it goes up, and a fall when it is strong enough. Undefined when the blast does not
+ * reach it. The numbers are the host's (`ModuleHost.blastShove`), the same ones that throw its loose items.
+ */
+declare function knockOf(blast: BlastSource, feet: Vec3, mass: number, options?: BlastShoveOptions): Knock | undefined;
+/**
+ * Moves a body one step: it slides on the ground and slows, falls when it was knocked down, lies a while and gets up (a dead body stays down). Moves `position` in place; returns true when the
+ * body is on its feet and still, and the knock can be dropped.
+ */
+declare function stepKnock(knock: Knock, position: {
+    x: number;
+    y: number;
+    z: number;
+}, dt: number, groundAt: (x: number, z: number) => number, alive: boolean): boolean;
+
 interface CostOptions {
     /** Reads of `state()` and of `describe()` to time. Default 10 000. */
     reads?: number;
@@ -1725,6 +1762,11 @@ interface AnimationEventSpec {
     /** snake_case type the host maps (`sound`, `eject_casing`, `door_latch`...). */
     type: string;
     data?: Record<string, unknown>;
+    /**
+     * Seconds of real time the event fires before `t`, not stretched with the clip: a recorded sound whose hit comes that long after its start
+     * (the click of a magazine seating) starts early so the hit lands on `t`. The player passes the lead it could apply as `data.lead`.
+     */
+    lead?: number;
 }
 /** A use animation a module brings with its item. Poses between keys are interpolated by the player (the test room does it linearly). */
 interface AnimationClipSpec {
@@ -1762,6 +1804,10 @@ interface SoundRequest {
     readonly seed?: number;
     /** Seconds from now (the hit of a blow after its swing); the host schedules it on the audio clock, not on a timer. */
     readonly delay?: number;
+    /** Built now instead of waiting in the engine's deferred start queue: for a sound that has to land on the frame the player sees it (a blow's
+     * contact, a heel strike, a landing). The queue builds a voice on the next frame budget and drops it after its latency, which at a low frame
+     * rate is late or silent. Default false. */
+    readonly urgent?: boolean;
 }
 /** What `AudioSink.play` hands back; opaque to the module, given back to `stop`. */
 interface SoundHandle {
@@ -2017,6 +2063,20 @@ interface Thumbnail {
         wear?: 0 | 1 | 2;
     };
 }
+/**
+ * What an item sounds like when the hand works it, as names of sound sets the host knows (the kit's are `LEAF_FOLEY_SETS` and `PICKUP_CLASSES` of game-audio).
+ * Everything is optional: without it the host picks by the material of the part.
+ */
+interface ItemSounds {
+    /** How it sounds picked up: `metal`, `plastic`, `glass`, `paper`, `fabric`, `wood`, `food`. Default: by its heaviest material. */
+    handling?: string;
+    /** The sound set of each leaf worked by hand, by part id, `*` for every other leaf: `car_door`, `car_trunk`, `fridge`, `microwave`, `drawer`, `wood_door`, `metal_door`. */
+    leaves?: Readonly<Record<string, string>>;
+    /** The sound id of opening its seal (`can_open`, `bottle_open`). Default: a metal seal is a can, any other a screw cap. */
+    open?: string;
+    /** The sound id of each use while it is held (`drink`: `drink_gulp`, `eat`: `eat_chew`), played over and over while the use lasts. */
+    uses?: Readonly<Record<string, string>>;
+}
 /** One thing a module can put in the test room (or any viewer): a toy car, a chair, a pistol on a table. */
 interface TestableItem {
     /** snake_case id, unique inside the module. */
@@ -2045,6 +2105,8 @@ interface TestableItem {
     pushable?: boolean;
     /** Where a body sits or lies on it: the host can seat the player there. */
     seats?: readonly ItemSeat[];
+    /** What it sounds like in the hand (picked up, opened, used) and the sound set of its doors and lids. */
+    sounds?: ItemSounds;
     /** Building it takes a noticeable time (a vehicle, a district): the host's catalogue shows its loading indicator while it spawns one. `true`, or the text to show. */
     slow?: boolean | string;
     /**
@@ -2342,14 +2404,37 @@ interface FrameOptions {
     readonly order?: number;
 }
 /**
- * What the host lends a module that brings its own presentation (a weapon in the hands, sounds, ejected casings). `THREE`, `scene` and `camera`
- * are the host's three.js namespace, scene and camera: `unknown` here because the contracts do not depend on three.js.
+ * An extra view the host draws over its own, for a module that needs to see from somewhere else at the same time: a rear-view mirror, a side mirror, a reversing camera, a security
+ * monitor. The host renders the scene from `camera` into `rect` after the main view, every frame, until the returned function is called.
  */
+interface ModuleView {
+    /** A three.js camera the module moves itself every frame. Its aspect is set by the host to the rect's. */
+    camera: unknown;
+    /** Where on the screen, as fractions of the canvas from its top-left corner (0..1). */
+    rect: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    /** Draws it left-right flipped, as a mirror shows the world. */
+    mirror?: boolean;
+    /** Rounds the corners of the frame (a fraction of the shorter side, 0..0.5); 0 or absent is a plain rectangle. */
+    rounded?: number;
+    /** Short label the host may print on the frame. */
+    label?: string;
+    /** Renders it at this fraction of the canvas resolution (default 0.5): a mirror does not need full detail. */
+    resolution?: number;
+}
 interface HostGraphics {
     hordeDetail(): 'auto' | number;
     onChange(listener: () => void): () => void;
     report(key: string, value: number): void;
 }
+/**
+ * What the host lends a module that brings its own presentation (a weapon in the hands, sounds, ejected casings). `THREE`, `scene` and `camera`
+ * are the host's three.js namespace, scene and camera: `unknown` here because the contracts do not depend on three.js.
+ */
 interface ModuleHost {
     THREE: unknown;
     scene: unknown;
@@ -2428,6 +2513,15 @@ interface ModuleHost {
     reachFor?(reach: HostReach): void;
     /** Asks the tool in hand to do something (see `ToolCommand`). A host without accessories leaves it out. */
     command?(command: ToolCommand): ToolCommandResult;
+    /**
+     * Draws an extra view over the host's own (mirrors, a reversing camera). Returns the function that takes it away. A host that cannot draw more than one view leaves it out.
+     */
+    addView?(view: ModuleView): () => void;
+    /**
+     * Takes over the main view with the module's camera (a vehicle's chase, cockpit or hood camera) until it is called again with null. The player's own camera comes back then. A host
+     * that keeps its camera to itself leaves it out.
+     */
+    setViewCamera?(camera: unknown | null): void;
     /** Lent only to a module that declares controls, layers or metrics. */
     bench?: ModuleBench;
     /** The host's shared sound engine; a module that makes sound uses it when lent and stays silent (or brings its own) when not. */
@@ -2447,6 +2541,12 @@ interface ModuleHost {
      * so that it throws things the way the host throws its loose items. Absent when the host keeps the defaults.
      */
     blastShove?: BlastShoveOptions;
+    /**
+     * The share (0..1) of a blast at `point` that reaches `target` through the cover between them (walls, cars, furniture of the host's world): what a module passes as
+     * `BlastSource.reach` to `blastShove`, so a body behind a wall is not thrown like one in the open. `ignore` lists world objects that never block (the explosive).
+     * Absent when the host has no world: the whole blast reaches.
+     */
+    blastReach?(point: Vec3, target: Vec3, ignore?: readonly string[]): number;
     /** The host's loading indicator: a module with a slow job of its own (building a house, laying a district) shows it through this instead of freezing the page. Absent when the host has none. */
     loading?: BusySink;
 }
@@ -2561,6 +2661,12 @@ interface ToolClipPlayer {
         readonly clip: AnimationClipSpec;
     }>;
 }
+/**
+ * The clip with every event that has a `lead` moved that many seconds earlier, the lead it got in `data.lead`. A led event never goes before 0
+ * nor before the event written ahead of it (a fast clip keeps its order: the lead shrinks). Run after `scaleClip`: the lead is real time, the
+ * clip's stretch does not touch it.
+ */
+declare const leadClipEvents: (clip: AnimationClipSpec) => AnimationClipSpec;
 declare const createToolClipPlayer: (options: ToolClipPlayerOptions) => ToolClipPlayer;
 
 type Entry = {
@@ -2701,4 +2807,4 @@ declare function footprintBlocker(object: FootprintObject | (() => FootprintObje
 /** @deprecated Import it from `@adatechnology/game-contracts/testing`. */
 declare const resetWarnOnce: () => void;
 
-export { type ActionControl, type AnimationClipSpec, type AnimationEventSpec, type AnimationKey, type AnimationPose, type AreaPlacement, type AudioListener, type AudioSink, BLOW_IDS, BODY_FOLEY_IDS, BODY_SOUND_IDS, type BallisticExtras, type BenchChange, type BenchDeclaration, type BenchReport, type BenchSheet, type BlastOptions, type BlastReport, type BlastShove, type BlastShoveOptions, type BlastSource, type BlowId, type BlowTarget, type BodyFoleyId, type BodyRegion, type BodySlot, type BodySoundId, type BooleanControl, type BusyOptions, type BusySink, type BusyTask, type CategorizedOptions, type CategorizedReport, type CategoryDef, type CategoryOptions, type CategoryRegistry, type ChainDelay, type CheckOptions, type CheckSpecOptions, type ChoiceControl, type ChoiceOption, type ConfinementOptions, type ContainerSpec, type ContractChecker, type ContractContext, type ControlPatch, type ControlValue, type CostOptions, type Crack, DEFAULT_BLAST_SHOVE, DEFAULT_ENVIRONMENT, DEFAULT_IGNITION_RULES, DEFAULT_SURFACE, DEFERRED_PRIORITY, DEFERRED_QUEUE_ID, type DamageStage, type DamageType, type DebrisKind, type DeepPartial, type DeferredQueue, type DeferredQueueOptions, type DeferredQueueReport, type Dent, type DestructibleImpl, type DestructibleSpec, type DestructionEvent, type DestructionEventType, type EffectHandle, type EffectRequest, type EffectSink, type Enclosure, type EnclosureBox, type EnvironmentBus, type EnvironmentKey, type EnvironmentState, type ExplosionChain, FOOTSTEP_SOUND_IDS, FRAME_PHASES, type FluidKind, type Footprint, type FootprintObject, type FootstepSoundId, type FractureStyle, type Fragment, type FragmentHitOptions, type FragmentMark, type FrameOptions, type FramePhase, GAIT_IDS, type GaitId, type GroundLayout, type GroundZone, HEAVY_LANDING_SPEED, type HandPose, type HandTargetSource, type HandTargets, type Hit, type HitIgnition, type HitResult, type Hole, type HostEvent, type HostGraphics, type HostReach, type HostTool, type HostToolAttachment, IMPACT_CONTRACT, type IgnitionRules, type ImpactContract, type ItemAnimationContract, type ItemSeat, type ItemUseDef, type JointKind, type JointSpec, type JointState, KIT_ORIGIN_KEY, type KitOrigin, LANDING_IDS, LAND_SOUND_IDS, type LandSoundId, type LandingId, type LiquidId, type LoopHandle, MATERIAL_SURFACES, MISSING_BITS, type MaterialId, type ModuleArea, type ModuleBench, type ModuleControl, type ModuleHost, type ModuleItemFluid, type ModuleItemSeal, type ModuleLayer, type ModuleMetric, type ModuleScenario, type NumberControl, type ObjectState, type PartBreach, type PartShape, type PartSpec, type PartState, type PartStatus, type PartUnits, type PileSpec, type PlayerState, type Quat, type RayHit, type Reinforcement, STAGE_EVENT, SURFACE_IDS, SWING_LEAD_SECONDS, type SealBlock, type SealSpec, type SealState, type SegmentKind, type ShelterOptions, type Shot, type SoilLayer, type SoilProfile, type SoilState, type SoundHandle, type SoundRequest, type SpecReport, type StructureRole, type SurfaceId, type SurfaceLayer, type SurfaceRay, type SurfaceRayHit, TOOL_CLIP, TWIST_LIFT, type TensionRebar, type TestableItem, type TestableModule, type Thumbnail, type ToolAnimationStep, type ToolAnimator, type ToolClipId, type ToolClipPlayer, type ToolClipPlayerOptions, type ToolClipSet, type ToolCommand, type ToolCommandResult, type ToolKind, type ToolRig, type TunedMassDamper, type TwistOptions, type TwistStroke, type UnmarkedDrawing, type Use, type Vec3, type WarmUpProbes, type WindExposure, type WindState, applyPatches, blastShove, checkAnimation, checkBench, checkCategorized, checkDeferredQueue, checkDestructible, checkHit, checkSpec, checkToolClips, createEnvironmentBus, createToolClipPlayer, deepMerge, defineCategories, fillFactor, footprintBlocker, footstepSoundId, hitSoundId, ignitionChance, isSurfaceId, kitOriginOf, landSoundId, markKitOrigin, mergeById, removeIds, resetWarnOnce, resolveEntry, resolveIgnitionRules, sampleClip, scaleClip, sealBlock, sealOpener, shotExtras, shotToHit, sparkTargetFactor, surfaceOfMaterial, swingSoundId, toolAnimationStep, twistStroke, unmarkedDrawings, useToHit };
+export { type ActionControl, type AnimationClipSpec, type AnimationEventSpec, type AnimationKey, type AnimationPose, type AreaPlacement, type AudioListener, type AudioSink, BLOW_IDS, BODY_FOLEY_IDS, BODY_SOUND_IDS, type BallisticExtras, type BenchChange, type BenchDeclaration, type BenchReport, type BenchSheet, type BlastOptions, type BlastReport, type BlastShove, type BlastShoveOptions, type BlastSource, type BlowId, type BlowTarget, type BodyFoleyId, type BodyRegion, type BodySlot, type BodySoundId, type BooleanControl, type BusyOptions, type BusySink, type BusyTask, type CategorizedOptions, type CategorizedReport, type CategoryDef, type CategoryOptions, type CategoryRegistry, type ChainDelay, type CheckOptions, type CheckSpecOptions, type ChoiceControl, type ChoiceOption, type ConfinementOptions, type ContainerSpec, type ContractChecker, type ContractContext, type ControlPatch, type ControlValue, type CostOptions, type Crack, DEFAULT_BLAST_SHOVE, DEFAULT_ENVIRONMENT, DEFAULT_IGNITION_RULES, DEFAULT_SURFACE, DEFERRED_PRIORITY, DEFERRED_QUEUE_ID, type DamageStage, type DamageType, type DebrisKind, type DeepPartial, type DeferredQueue, type DeferredQueueOptions, type DeferredQueueReport, type Dent, type DestructibleImpl, type DestructibleSpec, type DestructionEvent, type DestructionEventType, type EffectHandle, type EffectRequest, type EffectSink, type Enclosure, type EnclosureBox, type EnvironmentBus, type EnvironmentKey, type EnvironmentState, type ExplosionChain, FOOTSTEP_SOUND_IDS, FRAME_PHASES, type FluidKind, type Footprint, type FootprintObject, type FootstepSoundId, type FractureStyle, type Fragment, type FragmentHitOptions, type FragmentMark, type FrameOptions, type FramePhase, GAIT_IDS, type GaitId, type GroundLayout, type GroundZone, HEAVY_LANDING_SPEED, type HandPose, type HandTargetSource, type HandTargets, type Hit, type HitIgnition, type HitResult, type Hole, type HostEvent, type HostGraphics, type HostReach, type HostTool, type HostToolAttachment, IMPACT_CONTRACT, type IgnitionRules, type ImpactContract, type ItemAnimationContract, type ItemSeat, type ItemSounds, type ItemUseDef, type JointKind, type JointSpec, type JointState, KIT_ORIGIN_KEY, KNOCKED_DOWN_ANGLE, KNOCK_CHEST, KNOCK_DOWN_SPEED, type KitOrigin, type Knock, LANDING_IDS, LAND_SOUND_IDS, type LandSoundId, type LandingId, type LiquidId, type LoopHandle, MATERIAL_SURFACES, MISSING_BITS, type MaterialId, type ModuleArea, type ModuleBench, type ModuleControl, type ModuleHost, type ModuleItemFluid, type ModuleItemSeal, type ModuleLayer, type ModuleMetric, type ModuleScenario, type ModuleView, type NumberControl, type ObjectState, type PartBreach, type PartShape, type PartSpec, type PartState, type PartStatus, type PartUnits, type PileSpec, type PlayerState, type Quat, type RayHit, type Reinforcement, STAGE_EVENT, SURFACE_IDS, SWING_LEAD_SECONDS, type SealBlock, type SealSpec, type SealState, type SegmentKind, type ShelterOptions, type Shot, type SoilLayer, type SoilProfile, type SoilState, type SoundHandle, type SoundRequest, type SpecReport, type StructureRole, type SurfaceId, type SurfaceLayer, type SurfaceRay, type SurfaceRayHit, TOOL_CLIP, TWIST_LIFT, type TensionRebar, type TestableItem, type TestableModule, type Thumbnail, type ToolAnimationStep, type ToolAnimator, type ToolClipId, type ToolClipPlayer, type ToolClipPlayerOptions, type ToolClipSet, type ToolCommand, type ToolCommandResult, type ToolKind, type ToolRig, type TunedMassDamper, type TwistOptions, type TwistStroke, type UnmarkedDrawing, type Use, type Vec3, type WarmUpProbes, type WindExposure, type WindState, applyPatches, blastShove, bodyMass, checkAnimation, checkBench, checkCategorized, checkDeferredQueue, checkDestructible, checkHit, checkSpec, checkToolClips, createEnvironmentBus, createToolClipPlayer, deepMerge, defineCategories, fillFactor, footprintBlocker, footstepSoundId, hitSoundId, ignitionChance, isSurfaceId, kitOriginOf, knockOf, landSoundId, leadClipEvents, markKitOrigin, mergeById, removeIds, resetWarnOnce, resolveEntry, resolveIgnitionRules, sampleClip, scaleClip, sealBlock, sealOpener, shotExtras, shotToHit, sparkTargetFactor, stepKnock, surfaceOfMaterial, swingSoundId, toolAnimationStep, twistStroke, unmarkedDrawings, useToHit };

package/dist/index.global.js

@@ -36,6 +36,9 @@ var GameContracts = (() => {
     HEAVY_LANDING_SPEED: () => HEAVY_LANDING_SPEED,
     IMPACT_CONTRACT: () => IMPACT_CONTRACT,
     KIT_ORIGIN_KEY: () => KIT_ORIGIN_KEY,
+    KNOCKED_DOWN_ANGLE: () => KNOCKED_DOWN_ANGLE,
+    KNOCK_CHEST: () => KNOCK_CHEST,
+    KNOCK_DOWN_SPEED: () => KNOCK_DOWN_SPEED,
     LANDING_IDS: () => LANDING_IDS,
     LAND_SOUND_IDS: () => LAND_SOUND_IDS,
     MATERIAL_SURFACES: () => MATERIAL_SURFACES,
@@ -47,6 +50,7 @@ var GameContracts = (() => {
     TWIST_LIFT: () => TWIST_LIFT,
     applyPatches: () => applyPatches,
     blastShove: () => blastShove,
+    bodyMass: () => bodyMass,
     checkAnimation: () => checkAnimation,
     checkBench: () => checkBench,
     checkCategorized: () => checkCategorized,
@@ -66,7 +70,9 @@ var GameContracts = (() => {
     ignitionChance: () => ignitionChance,
     isSurfaceId: () => isSurfaceId,
     kitOriginOf: () => kitOriginOf,
+    knockOf: () => knockOf,
     landSoundId: () => landSoundId,
+    leadClipEvents: () => leadClipEvents,
     markKitOrigin: () => markKitOrigin,
     mergeById: () => mergeById,
     removeIds: () => removeIds,
@@ -80,6 +86,7 @@ var GameContracts = (() => {
     shotExtras: () => shotExtras,
     shotToHit: () => shotToHit,
     sparkTargetFactor: () => sparkTargetFactor,
+    stepKnock: () => stepKnock,
     surfaceOfMaterial: () => surfaceOfMaterial,
     swingSoundId: () => swingSoundId,
     toolAnimationStep: () => toolAnimationStep,
@@ -107,6 +114,59 @@ var GameContracts = (() => {
     return { speed, direction: [direction[0] / length, direction[1] / length, direction[2] / length], distance, falloff };
   }
 
+  // src/blast-knock.ts
+  var KNOCK_DOWN_SPEED = 2.5;
+  var KNOCKED_DOWN_ANGLE = 1.35;
+  var LIE_SECONDS = 1.6;
+  var STAND_UP_PER_SPEED = 0.25;
+  var FALL_SECONDS = 0.25;
+  var RISE_SECONDS = 0.6;
+  var GROUND_FRICTION = 7;
+  var GRAVITY = 9.81;
+  var KNOCK_CHEST = 1.1;
+  var CHEST = KNOCK_CHEST;
+  var bodyMass = (height, build = 1) => 70 * (height / 1.75) ** 2 * build;
+  function knockOf(blast, feet, mass, options) {
+    const hit = blastShove(blast, { position: [feet[0], feet[1] + CHEST, feet[2]], mass }, options);
+    if (!hit) return void 0;
+    const [dx, dy, dz] = hit.direction;
+    return { velocity: [dx * hit.speed, Math.max(0, dy * hit.speed), dz * hit.speed], airborne: dy > 0, lying: 0, lieLeft: 0, down: hit.speed >= KNOCK_DOWN_SPEED };
+  }
+  function stepKnock(knock, position, dt, groundAt, alive) {
+    const v = knock.velocity;
+    position.x += v[0] * dt;
+    position.z += v[2] * dt;
+    const ground = groundAt(position.x, position.z);
+    if (knock.airborne || position.y > ground + 1e-4) {
+      v[1] -= GRAVITY * dt;
+      position.y += v[1] * dt;
+      if (position.y <= ground) {
+        position.y = ground;
+        v[1] = 0;
+        knock.airborne = false;
+      }
+    } else position.y = ground;
+    const horizontal = Math.hypot(v[0], v[2]);
+    if (!knock.airborne && horizontal > 0) {
+      const slowed = Math.max(0, horizontal - GROUND_FRICTION * dt);
+      v[0] *= slowed / horizontal;
+      v[2] *= slowed / horizontal;
+    }
+    const moving = horizontal > 0.05 || knock.airborne;
+    if (knock.down) {
+      if (moving) knock.lying = Math.min(1, knock.lying + dt / FALL_SECONDS);
+      else {
+        knock.lying = 1;
+        if (alive) {
+          knock.lieLeft = knock.lieLeft > 0 ? knock.lieLeft : LIE_SECONDS + Math.hypot(v[0], v[2]) * STAND_UP_PER_SPEED;
+          knock.lieLeft -= dt;
+          if (knock.lieLeft <= 0) knock.down = false;
+        }
+      }
+    } else if (knock.lying > 0) knock.lying = Math.max(0, knock.lying - dt / RISE_SECONDS);
+    return !moving && !knock.down && knock.lying === 0;
+  }
+
   // src/impact-cost.ts
   var DEFAULT_COST_READS = 1e4;
   var DEFAULT_COST_CEILING_MS = 50;
@@ -650,6 +710,21 @@ var GameContracts = (() => {
     }
     return { ok: problems.length === 0, problems };
   };
+  var leadClipEvents = (clip) => {
+    const events = clip.events ?? [];
+    if (!events.some((event) => (event.lead ?? 0) > 0)) return clip;
+    let floor = 0;
+    const led = events.map((event) => {
+      const lead = Math.max(0, Math.min(event.t - floor, event.lead ?? 0));
+      const t = event.t - lead;
+      floor = Math.max(floor, t);
+      if (event.lead === void 0) return event;
+      const moved = { ...event, t, data: lead > 0 ? { ...event.data, lead } : { ...event.data } };
+      delete moved.lead;
+      return moved;
+    });
+    return { ...clip, events: led };
+  };
   var createToolClipPlayer = (options) => {
     const { clips, rig, onEvent } = options;
     let instances = [];
@@ -692,7 +767,7 @@ var GameContracts = (() => {
         }
         const found = find(step.clip, step.variant);
         if (!found) return;
-        const clip = step.duration && step.duration > 0 ? scaleClip(found.clip, step.duration) : found.clip;
+        const clip = leadClipEvents(step.duration && step.duration > 0 ? scaleClip(found.clip, step.duration) : found.clip);
         const interval = options.repeatInterval?.() ?? 0.1;
         instances = instances.filter((existing) => existing.name !== found.name || existing.delay > 0);
         for (let round = 0; round < (step.repeat ?? 1); round++) {