@adatechnology/game-player 0.3.0 → 0.4.0

package/README.md

@@ -59,3 +59,7 @@ carries it too.
 ## Pushing furniture
 
 `createFurniturePush(rules?)` is the logic of pushing a heavy thing on foot: `begin({ massKg, material })`, then `update(dt, { walk, isFree })` every frame answers the step and says the `phase` (`grip` while the hold timer fills, `push`, `strain`), the `progress` of the timer and the `block` (`too_heavy`, `obstacle`). The host answers `isFree` by sweeping the volume of the piece and draws the rest. `gripSecondsFor`, `pushSpeedFor` and `canPush` give the numbers; the force of the legs, the friction by material, the times and the speeds are all in `FurniturePushRules` (`FURNITURE_PUSH_DEFAULTS`).
+
+## Opening doors by hand
+
+`createDoorUse(rules?)` is the logic of working a door, lid or drawer by hand: `begin({ opening, massKg, locked })` answers where the leaf goes (1 open, 0 closed; a second `begin` in the middle of a swing turns it round) or null for a locked leaf, which only rattles. `step(dt, isFree)` then goes through `reach` (the hand to the handle), `swing` (the leaf follows the hand, a little at a time so it stops at the first thing in its way, `block: 'obstacle'`) and `release`. A heavier leaf swings slower (`swingSecondsFor`); every number is in `DoorUseRules` (`DOOR_USE_DEFAULTS`).

package/dist/index.d.ts

@@ -484,4 +484,71 @@ type PlayerTestModule = TestableModule<PlayerScenarioLike> & {
  */
 declare function createPlayerTestModule(options?: PlayerTestModuleOptions): PlayerTestModule;
 
-export { type AttributeId, type Attributes, type DeathCause, type Derived, type DerivedFormulas, type DerivedId, FURNITURE_PUSH_DEFAULTS, type FurniturePush, type FurniturePushBlock, type FurniturePushInput, type FurniturePushPhase, type FurniturePushRules, type FurniturePushStep, type FurniturePushTarget, type InfectionRule, type KnownDeathCause, type LinearFormula, type MeleeItem, PLAYER_DEFAULTS, PLAYER_TEXT, type Player, type PlayerAction, type PlayerCrowd, type PlayerEvent, type PlayerEventMap, type PlayerEventName, type PlayerInput, type PlayerMessageId, type PlayerNumbers, type PlayerOptions, type PlayerSave, type PlayerSoundId, type PlayerState, type PlayerTestModule, type PlayerTestModuleOptions, type PlayerText, type PlayerWorld, type WoundRule, type WoundTable, canPush, createFurniturePush, createPlayer, createPlayerTestModule, createRng, deriveVitals, drawWound, gripSecondsFor, playerTextOf, pushSpeedFor };
+/**
+ * Opening and closing a hinged or sliding leaf by hand (a house door, a wardrobe or fridge door, a drawer, a car door, a hood): the hand reaches the handle, the leaf
+ * follows the hand at a speed set by its mass, stops where something is in its way, and a locked leaf only rattles.
+ * Engine-agnostic: the host says how open the leaf is (0 closed, 1 open) and answers whether it can go to a new opening; this says how far it goes each step.
+ */
+type DoorUsePhase = 'idle' | 'reach' | 'swing' | 'release' | 'rattle';
+type DoorUseBlock = 'locked' | 'obstacle' | null;
+/** Every number of the use; a game overrides what it wants (`createDoorUse(rules)`). */
+interface DoorUseRules {
+    /** The hand going to the handle before the leaf moves, seconds. */
+    readonly reachSeconds: number;
+    /** A full swing: `base + perKg * mass` of the leaf, between `min` and `max` seconds (a fridge door is quick, a car door slower, a steel door slower still). */
+    readonly swingSeconds: {
+        readonly base: number;
+        readonly perKg: number;
+        readonly min: number;
+        readonly max: number;
+    };
+    /** The hand letting go and coming back, seconds. */
+    readonly releaseSeconds: number;
+    /** How long a locked leaf is shaken before the hand gives up, seconds. */
+    readonly rattleSeconds: number;
+    /** The part of the swing tested at a time against what is around (smaller is finer and costs more). */
+    readonly stepFraction: number;
+    /** Within this of closed or open a leaf counts as there: the last use's way no longer turns it round. */
+    readonly endTolerance: number;
+}
+declare const DOOR_USE_DEFAULTS: DoorUseRules;
+type DoorUseTarget = {
+    /** How open the leaf is now, 0 closed to 1 open. */
+    readonly opening: number;
+    readonly massKg: number;
+    readonly locked?: boolean;
+    /** Where the last use sent this leaf: a leaf stopped between closed and open goes the other way (a door blocked half open closes). */
+    readonly lastGoal?: 0 | 1;
+};
+type DoorUseStep = {
+    readonly phase: DoorUsePhase;
+    /** How open the leaf is after the step. */
+    readonly opening: number;
+    /** The phase's own progress, 0 to 1 (how far the hand is to the handle, how far the swing went, how much of the rattle is left). */
+    readonly progress: number;
+    /** Set on the step the leaf stopped short or would not move. */
+    readonly block: DoorUseBlock;
+    /** The leaf got where it was going on this step (fully open or fully closed). */
+    readonly arrived: boolean;
+};
+/** Seconds of a full swing for a leaf of this mass. */
+declare const swingSecondsFor: (massKg: number, rules?: DoorUseRules) => number;
+interface DoorUse {
+    readonly phase: DoorUsePhase;
+    /** Where the leaf is going: 1 opening, 0 closing. */
+    readonly goal: 0 | 1;
+    readonly opening: number;
+    /**
+     * Starts using a leaf: the other way from where the last use sent it (`lastGoal`), else a closed or half-open leaf opens and an open
+     * one closes. A use in the middle of a swing turns it round.
+     * Answers the goal (1 open, 0 closed), or null when the leaf is locked (it rattles instead).
+     */
+    begin(target: DoorUseTarget): 0 | 1 | null;
+    /** Advances the use; `isFree(from, to)` answers whether the leaf can go from one opening to the other (nothing in the way of its sweep). */
+    step(dt: number, isFree: (from: number, to: number) => boolean): DoorUseStep;
+    /** Lets go at once. */
+    cancel(): void;
+}
+declare function createDoorUse(rules?: Partial<DoorUseRules>): DoorUse;
+
+export { type AttributeId, type Attributes, DOOR_USE_DEFAULTS, type DeathCause, type Derived, type DerivedFormulas, type DerivedId, type DoorUse, type DoorUseBlock, type DoorUsePhase, type DoorUseRules, type DoorUseStep, type DoorUseTarget, FURNITURE_PUSH_DEFAULTS, type FurniturePush, type FurniturePushBlock, type FurniturePushInput, type FurniturePushPhase, type FurniturePushRules, type FurniturePushStep, type FurniturePushTarget, type InfectionRule, type KnownDeathCause, type LinearFormula, type MeleeItem, PLAYER_DEFAULTS, PLAYER_TEXT, type Player, type PlayerAction, type PlayerCrowd, type PlayerEvent, type PlayerEventMap, type PlayerEventName, type PlayerInput, type PlayerMessageId, type PlayerNumbers, type PlayerOptions, type PlayerSave, type PlayerSoundId, type PlayerState, type PlayerTestModule, type PlayerTestModuleOptions, type PlayerText, type PlayerWorld, type WoundRule, type WoundTable, canPush, createDoorUse, createFurniturePush, createPlayer, createPlayerTestModule, createRng, deriveVitals, drawWound, gripSecondsFor, playerTextOf, pushSpeedFor, swingSecondsFor };

package/dist/index.global.js

@@ -21,10 +21,12 @@ var GamePlayer = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    DOOR_USE_DEFAULTS: () => DOOR_USE_DEFAULTS,
     FURNITURE_PUSH_DEFAULTS: () => FURNITURE_PUSH_DEFAULTS,
     PLAYER_DEFAULTS: () => PLAYER_DEFAULTS,
     PLAYER_TEXT: () => PLAYER_TEXT,
     canPush: () => canPush,
+    createDoorUse: () => createDoorUse,
     createFurniturePush: () => createFurniturePush,
     createPlayer: () => createPlayer,
     createPlayerTestModule: () => createPlayerTestModule,
@@ -33,7 +35,8 @@ var GamePlayer = (() => {
     drawWound: () => drawWound,
     gripSecondsFor: () => gripSecondsFor,
     playerTextOf: () => playerTextOf,
-    pushSpeedFor: () => pushSpeedFor
+    pushSpeedFor: () => pushSpeedFor,
+    swingSecondsFor: () => swingSecondsFor
   });
 
   // src/data/defaults.json
@@ -1156,6 +1159,110 @@ var GamePlayer = (() => {
     };
     return module;
   }
+
+  // src/door-use.ts
+  var DOOR_USE_DEFAULTS = {
+    reachSeconds: 0.3,
+    swingSeconds: { base: 0.45, perKg: 0.02, min: 0.45, max: 1.6 },
+    releaseSeconds: 0.22,
+    rattleSeconds: 0.6,
+    stepFraction: 0.04,
+    endTolerance: 0.02
+  };
+  var swingSecondsFor = (massKg, rules = DOOR_USE_DEFAULTS) => Math.min(rules.swingSeconds.max, Math.max(rules.swingSeconds.min, rules.swingSeconds.base + rules.swingSeconds.perKg * Math.max(0, massKg)));
+  function createDoorUse(rules = {}) {
+    const r = { ...DOOR_USE_DEFAULTS, ...rules, swingSeconds: { ...DOOR_USE_DEFAULTS.swingSeconds, ...rules.swingSeconds } };
+    let phase = "idle";
+    let goal = 1;
+    let opening = 0;
+    let time = 0;
+    let swing = 1;
+    let start = 0;
+    const out = (progress, arrived = false, b = null) => ({ phase, opening, progress: Math.max(0, Math.min(1, progress)), block: b, arrived });
+    return {
+      get phase() {
+        return phase;
+      },
+      get goal() {
+        return goal;
+      },
+      get opening() {
+        return opening;
+      },
+      begin(target) {
+        opening = Math.max(0, Math.min(1, target.opening));
+        time = 0;
+        if (target.locked) {
+          phase = "rattle";
+          return null;
+        }
+        if (phase === "swing" || phase === "reach") goal = goal === 1 ? 0 : 1;
+        else if (target.lastGoal !== void 0 && opening > r.endTolerance && opening < 1 - r.endTolerance) goal = target.lastGoal === 1 ? 0 : 1;
+        else goal = opening > 0.5 ? 0 : 1;
+        swing = swingSecondsFor(target.massKg, r);
+        start = opening;
+        phase = phase === "swing" ? "swing" : "reach";
+        return goal;
+      },
+      step(dt, isFree) {
+        if (phase === "idle") return out(0);
+        time += dt;
+        if (phase === "rattle") {
+          const p2 = time / r.rattleSeconds;
+          if (p2 >= 1) {
+            phase = "idle";
+            return out(1, false, "locked");
+          }
+          return out(p2, false, time === dt ? "locked" : null);
+        }
+        if (phase === "reach") {
+          const p2 = time / r.reachSeconds;
+          if (p2 < 1) return out(p2);
+          phase = "swing";
+          time = 0;
+          start = opening;
+        }
+        if (phase === "swing") {
+          const want = goal - opening;
+          const reach = Math.min(Math.abs(want), dt / swing);
+          let moved = 0;
+          let stopped = false;
+          while (moved < reach - 1e-9) {
+            const inc = Math.min(r.stepFraction, reach - moved);
+            const next = opening + Math.sign(want) * inc;
+            if (!isFree(opening, next)) {
+              stopped = true;
+              break;
+            }
+            opening = next;
+            moved += inc;
+          }
+          const travel = Math.abs(goal - start) || 1;
+          if (stopped) {
+            phase = "release";
+            time = 0;
+            return out(1 - Math.abs(goal - opening) / travel, false, "obstacle");
+          }
+          if (Math.abs(goal - opening) < 1e-6) {
+            opening = goal;
+            phase = "release";
+            time = 0;
+            return out(1, true);
+          }
+          return out(1 - Math.abs(goal - opening) / travel);
+        }
+        const p = time / r.releaseSeconds;
+        if (p >= 1) {
+          phase = "idle";
+        }
+        return out(p, false, null);
+      },
+      cancel() {
+        phase = "idle";
+        time = 0;
+      }
+    };
+  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map