@woosh/meep-engine 2.138.18 → 2.138.20

package/src/engine/control/first-person/FirstPersonPlayerController.d.ts

@@ -0,0 +1,229 @@
+/**
+ * First-person camera + body controller. See DESIGN.md (sibling file) for
+ * the goals, layered architecture, and tuning rationale.
+ *
+ * Lifecycle: only `config` is serialized. `intent`, `state`, `pose`,
+ * `signals`, and `eyeEntity` are transient — rebuilt by the system on
+ * link.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class FirstPersonPlayerController {
+    static typeName: string;
+    config: FirstPersonPlayerControllerConfig;
+    intent: FirstPersonIntent;
+    state: FirstPersonState;
+    pose: FirstPersonPose;
+    signals: FirstPersonSignals;
+    /**
+     * ID of the entity carrying the eye Transform + Camera. Created by
+     * the system on link if -1. Held as a plain number rather than
+     * EntityReference to keep serialization simple — the relationship
+     * is rebuilt on link anyway.
+     * @type {number}
+     */
+    eyeEntity: number;
+    toJSON(): {
+        config: {
+            body: {
+                height: number;
+                crouchHeight: number;
+                radius: number;
+                mass: number;
+            };
+            motion: {
+                walkSpeed: number; /** Hold state — true while jump button is held. @type {boolean} */
+                sprintSpeed: number;
+                crouchSpeed: number;
+                airControl: number;
+                groundAccel: number;
+                groundDecel: number;
+                airAccel: number;
+            };
+            jump: {
+                anticipation: {
+                    duration: number;
+                    dipAmount: number;
+                };
+                peakHeight: number;
+                timeToApex: number;
+                coyoteTime: number;
+                bufferTime: number;
+                fallGravityMult: number;
+                cutGravityMult: number;
+            };
+            landing: {
+                recovery: {
+                    spring: {
+                        halfLife: number;
+                        zeta: number; /** {verticalSpeed:number, kind:"soft"|"hard"} */
+                    };
+                    dipPerVy: number;
+                    dipMax: number;
+                };
+                softThreshold: number;
+                hardThreshold: number;
+            };
+            crouch: {
+                transitionTime: number;
+                mode: string;
+            };
+            bob: {
+                stepFreqAtWalk: number;
+                stepFreqExp: number;
+                verticalAmpAtWalk: number;
+                lateralAmpAtWalk: number;
+                ampMassScale: number;
+                rollAtWalkDeg: number;
+                minStepSpeed: number;
+            };
+            breath: {
+                rateRestHz: number;
+                rateMaxHz: number;
+                amplitudeRestM: number;
+                amplitudeMaxM: number;
+                pitchAmpRestDeg: number;
+                pitchAmpMaxDeg: number;
+                noiseAmount: number;
+            };
+            exertion: {
+                sprintRiseRate: number;
+                jumpRise: number;
+                idleDecayRate: number;
+                rateDecayHalfLife: number;
+                ampDecayHalfLife: number;
+            };
+            lean: {
+                spring: {
+                    halfLife: number;
+                    zeta: number;
+                };
+                enabled: boolean;
+                maxRollDeg: number;
+            };
+            fov: {
+                base: number;
+                sprintAdd: number;
+                crouchAdd: number;
+                smoothHalfLife: number;
+            };
+            look: {
+                pitchMinDeg: number;
+                pitchMaxDeg: number;
+                invertY: boolean; /**
+                 * @param {FirstPersonPlayerController} other
+                 */
+            };
+            gravity: {
+                magnitude: number;
+            };
+        };
+    };
+    fromJSON(json: any): void;
+    /**
+     * @param {FirstPersonPlayerController} other
+     */
+    copy(other: FirstPersonPlayerController): void;
+    clone(): FirstPersonPlayerController;
+    equals(other: any): boolean;
+    hash(): number;
+}
+export namespace FirstPersonPlayerController {
+    export { FirstPersonActionState as ActionState };
+}
+import { FirstPersonPlayerControllerConfig } from "./FirstPersonPlayerControllerConfig.js";
+/**
+ * Intent — what the player (or AI) wants the body to do. All fields are
+ * latched ("hold-state") except `look`, which accumulates deltas between
+ * fixed updates and is zeroed by the system on consume.
+ *
+ * The system performs its own edge detection on `jump` (and on `crouch`
+ * when toggle-mode is configured). This is what guarantees a held jump
+ * button does not produce repeated jumps.
+ */
+declare class FirstPersonIntent {
+    /** [-1..1, -1..1] forward+/right+ in body-local. @type {Vector2} */
+    move: Vector2;
+    /**
+     * Accumulated look delta (radians). x = yaw, y = pitch. Consumed and
+     * zeroed by the system in fixedUpdate.
+     * @type {Vector2}
+     */
+    look: Vector2;
+    /** Hold state — true while jump button is held. @type {boolean} */
+    jump: boolean;
+    /** Hold state — meaning depends on config.crouch.mode. @type {boolean} */
+    crouch: boolean;
+    /** Hold state — true while sprint button is held. @type {boolean} */
+    sprint: boolean;
+}
+/**
+ * Derived state — read-only outputs. Useful for HUDs, sound systems, AI
+ * sensors that need to know "is the player crouched / sprinting / etc."
+ */
+declare class FirstPersonState {
+    grounded: boolean;
+    timeSinceGrounded: number;
+    /** Set by the physics layer (or the prototype's flat-ground integrator). */
+    groundNormal: Vector3;
+    surfaceTag: any;
+    speed: number;
+    /** [0..1] vs sprint speed — drives bob amp and FOV kick. */
+    speedNormalized: number;
+    /** "Idle" | "Walk" | "Sprint" | "Crouch" | "Air" */
+    moveMode: string;
+    verticalSpeed: number;
+    airborneTime: number;
+    fallDistance: number;
+    jumpBufferRemaining: number;
+    inJumpAnticipation: boolean;
+    isVariableJumpCut: boolean;
+    /** Set to true while jumping ascent until apex; gates the cut behavior. */
+    isAscending: boolean;
+    exertion: number;
+    breathPhase: number;
+    breathRateHz: number;
+    breathAmplitudeM: number;
+    stridePhase: number;
+    stepCount: number;
+    /** Which foot fires next: 0 = right, 1 = left. */
+    nextFoot: number;
+    eyeHeight: number;
+    /** Set true when crouch was released but a ceiling above prevents standing. */
+    crouchBlocked: boolean;
+    /** True while in crouch pose (independent of intent — see crouchBlocked). */
+    crouchActive: boolean;
+    leanRollRad: number;
+}
+import { FirstPersonPose } from "./pose/FirstPersonPose.js";
+/**
+ * Event surface. All signals are sent from fixedUpdate so listeners see
+ * consistent state across the same simulation tick.
+ */
+declare class FirstPersonSignals {
+    /** {side:"L"|"R", speed:number, surfaceTag:string?} */
+    onFootStep: Signal<any, any, any, any, any, any, any, any>;
+    /** {peakHeight:number} fired at impulse, after anticipation finishes. */
+    onJumpStart: Signal<any, any, any, any, any, any, any, any>;
+    /** No payload. */
+    onJumpApex: Signal<any, any, any, any, any, any, any, any>;
+    /** {reason:"jump"|"fall"} */
+    onLeaveGround: Signal<any, any, any, any, any, any, any, any>;
+    /** {verticalSpeed:number, kind:"soft"|"hard"} */
+    onLand: Signal<any, any, any, any, any, any, any, any>;
+    onCrouchEnter: Signal<any, any, any, any, any, any, any, any>;
+    onCrouchExit: Signal<any, any, any, any, any, any, any, any>;
+    onSprintStart: Signal<any, any, any, any, any, any, any, any>;
+    onSprintStop: Signal<any, any, any, any, any, any, any, any>;
+    /** {amplitude:number, rateHz:number} fired at peak inhale (phase 0.25). */
+    onBreathIn: Signal<any, any, any, any, any, any, any, any>;
+    /** {amplitude:number, rateHz:number} fired at peak exhale (phase 0.75). */
+    onBreathOut: Signal<any, any, any, any, any, any, any, any>;
+}
+import { FirstPersonActionState } from "./pose/FirstPersonPose.js";
+import Vector2 from "../../../core/geom/Vector2.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import Signal from "../../../core/events/signal/Signal.js";
+export {};
+//# sourceMappingURL=FirstPersonPlayerController.d.ts.map

package/src/engine/control/first-person/FirstPersonPlayerController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FirstPersonPlayerController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerController.js"],"names":[],"mappings":"AA6GA;;;;;;;;;;GAUG;AACH;IACI,wBAAgD;IAG5C,0CAAqD;IACrD,0BAAqC;IACrC,wBAAmC;IACnC,sBAAiC;IACjC,4BAAuC;IAEvC;;;;;;OAMG;IACH,WAFU,MAAM,CAEG;IAGvB;;;;;;;;;mCAlHA,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;sCAuEnE,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAqDjD;;mBAEG;;;;;;MAVF;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;kDA1KiD,wCAAwC;AAG1F;;;;;;;;GAQG;AACH;IACI,oEAAoE;IACpE,MADyD,OAAO,CACvC;IAEzB;;;;OAIG;IACH,MAFU,OAAO,CAEQ;IAEzB,mEAAmE;IACnE,MADwD,OAAO,CAClD;IAEb,0EAA0E;IAC1E,QAD+D,OAAO,CACvD;IAEf,qEAAqE;IACrE,QAD0D,OAAO,CAClD;CAClB;AAED;;;GAGG;AACH;IACI,kBAAgB;IAChB,0BAAsB;IAEtB,4EAA4E;IAC5E,sBAAoC;IACpC,gBAAkB;IAElB,cAAU;IACV,4DAA4D;IAC5D,wBAAoB;IACpB,oDAAoD;IACpD,iBAAkB;IAElB,sBAAkB;IAClB,qBAAiB;IACjB,qBAAiB;IAEjB,4BAAwB;IACxB,4BAA2B;IAC3B,2BAA0B;IAC1B,2EAA2E;IAC3E,qBAAoB;IAEpB,iBAAa;IACb,oBAAgB;IAChB,qBAAiB;IACjB,yBAAqB;IAErB,oBAAgB;IAChB,kBAAc;IACd,kDAAkD;IAClD,iBAAa;IAEb,kBAAiB;IAEjB,+EAA+E;IAC/E,uBAAsB;IACtB,6EAA6E;IAC7E,sBAAqB;IAErB,oBAAgB;CACnB;gCA9EuD,2BAA2B;AAgFnF;;;GAGG;AACH;IACI,uDAAuD;IACvD,2DAA0B;IAC1B,yEAAyE;IACzE,4DAA2B;IAC3B,kBAAkB;IAClB,2DAA0B;IAC1B,6BAA6B;IAC7B,8DAA6B;IAC7B,iDAAiD;IACjD,uDAAsB;IACtB,8DAA6B;IAC7B,6DAA4B;IAC5B,8DAA6B;IAC7B,6DAA4B;IAC5B,2EAA2E;IAC3E,2DAA0B;IAC1B,2EAA2E;IAC3E,4DAA2B;CAC9B;uCAvGuD,2BAA2B;oBAH/D,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}

package/src/engine/control/first-person/FirstPersonPlayerController.js

@@ -0,0 +1,176 @@
+import Signal from "../../../core/events/signal/Signal.js";
+import Vector2 from "../../../core/geom/Vector2.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { FirstPersonPlayerControllerConfig } from "./FirstPersonPlayerControllerConfig.js";
+import { FirstPersonActionState, FirstPersonPose } from "./pose/FirstPersonPose.js";
+
+/**
+ * Intent — what the player (or AI) wants the body to do. All fields are
+ * latched ("hold-state") except `look`, which accumulates deltas between
+ * fixed updates and is zeroed by the system on consume.
+ *
+ * The system performs its own edge detection on `jump` (and on `crouch`
+ * when toggle-mode is configured). This is what guarantees a held jump
+ * button does not produce repeated jumps.
+ */
+class FirstPersonIntent {
+    /** [-1..1, -1..1] forward+/right+ in body-local. @type {Vector2} */
+    move = new Vector2(0, 0);
+
+    /**
+     * Accumulated look delta (radians). x = yaw, y = pitch. Consumed and
+     * zeroed by the system in fixedUpdate.
+     * @type {Vector2}
+     */
+    look = new Vector2(0, 0);
+
+    /** Hold state — true while jump button is held. @type {boolean} */
+    jump = false;
+
+    /** Hold state — meaning depends on config.crouch.mode. @type {boolean} */
+    crouch = false;
+
+    /** Hold state — true while sprint button is held. @type {boolean} */
+    sprint = false;
+}
+
+/**
+ * Derived state — read-only outputs. Useful for HUDs, sound systems, AI
+ * sensors that need to know "is the player crouched / sprinting / etc."
+ */
+class FirstPersonState {
+    grounded = true;
+    timeSinceGrounded = 0;
+
+    /** Set by the physics layer (or the prototype's flat-ground integrator). */
+    groundNormal = new Vector3(0, 1, 0);
+    surfaceTag = null;
+
+    speed = 0;
+    /** [0..1] vs sprint speed — drives bob amp and FOV kick. */
+    speedNormalized = 0;
+    /** "Idle" | "Walk" | "Sprint" | "Crouch" | "Air" */
+    moveMode = "Idle";
+
+    verticalSpeed = 0;
+    airborneTime = 0;
+    fallDistance = 0;
+
+    jumpBufferRemaining = 0;
+    inJumpAnticipation = false;
+    isVariableJumpCut = false;
+    /** Set to true while jumping ascent until apex; gates the cut behavior. */
+    isAscending = false;
+
+    exertion = 0;
+    breathPhase = 0;
+    breathRateHz = 0;
+    breathAmplitudeM = 0;
+
+    stridePhase = 0;
+    stepCount = 0;
+    /** Which foot fires next: 0 = right, 1 = left. */
+    nextFoot = 0;
+
+    eyeHeight = 1.80;
+
+    /** Set true when crouch was released but a ceiling above prevents standing. */
+    crouchBlocked = false;
+    /** True while in crouch pose (independent of intent — see crouchBlocked). */
+    crouchActive = false;
+
+    leanRollRad = 0;
+}
+
+/**
+ * Event surface. All signals are sent from fixedUpdate so listeners see
+ * consistent state across the same simulation tick.
+ */
+class FirstPersonSignals {
+    /** {side:"L"|"R", speed:number, surfaceTag:string?} */
+    onFootStep = new Signal();
+    /** {peakHeight:number} fired at impulse, after anticipation finishes. */
+    onJumpStart = new Signal();
+    /** No payload. */
+    onJumpApex = new Signal();
+    /** {reason:"jump"|"fall"} */
+    onLeaveGround = new Signal();
+    /** {verticalSpeed:number, kind:"soft"|"hard"} */
+    onLand = new Signal();
+    onCrouchEnter = new Signal();
+    onCrouchExit = new Signal();
+    onSprintStart = new Signal();
+    onSprintStop = new Signal();
+    /** {amplitude:number, rateHz:number} fired at peak inhale (phase 0.25). */
+    onBreathIn = new Signal();
+    /** {amplitude:number, rateHz:number} fired at peak exhale (phase 0.75). */
+    onBreathOut = new Signal();
+}
+
+/**
+ * First-person camera + body controller. See DESIGN.md (sibling file) for
+ * the goals, layered architecture, and tuning rationale.
+ *
+ * Lifecycle: only `config` is serialized. `intent`, `state`, `pose`,
+ * `signals`, and `eyeEntity` are transient — rebuilt by the system on
+ * link.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class FirstPersonPlayerController {
+    static typeName = "FirstPersonPlayerController";
+
+    constructor() {
+        this.config = new FirstPersonPlayerControllerConfig();
+        this.intent = new FirstPersonIntent();
+        this.state = new FirstPersonState();
+        this.pose = new FirstPersonPose();
+        this.signals = new FirstPersonSignals();
+
+        /**
+         * ID of the entity carrying the eye Transform + Camera. Created by
+         * the system on link if -1. Held as a plain number rather than
+         * EntityReference to keep serialization simple — the relationship
+         * is rebuilt on link anyway.
+         * @type {number}
+         */
+        this.eyeEntity = -1;
+    }
+
+    toJSON() {
+        return { config: this.config.toJSON() };
+    }
+
+    fromJSON(json) {
+        if (json && json.config) {
+            this.config.fromJSON(json.config);
+        }
+    }
+
+    /**
+     * @param {FirstPersonPlayerController} other
+     */
+    copy(other) {
+        this.config.copy(other.config);
+        // intent/state/pose/signals/eyeEntity are transient
+    }
+
+    clone() {
+        const c = new FirstPersonPlayerController();
+        c.copy(this);
+        return c;
+    }
+
+    equals(other) {
+        // config-only equality (the rest is runtime state)
+        return JSON.stringify(this.config.toJSON()) === JSON.stringify(other.config.toJSON());
+    }
+
+    hash() {
+        // hashing transient state is undesirable; the config is large; return 0
+        return 0;
+    }
+}
+
+FirstPersonPlayerController.ActionState = FirstPersonActionState;

package/src/engine/control/first-person/FirstPersonPlayerControllerConfig.d.ts

@@ -0,0 +1,251 @@
+/**
+ * Tunable parameters for {@link FirstPersonPlayerController}. The full
+ * config is the only serialized portion of the component — everything else
+ * (intent, state, pose, signals) is transient and rebuilt on link.
+ *
+ * Defaults aim for a baseline "human soldier" feel — see DESIGN.md §4.1.
+ * Every value is exposed so designers can mod it to taste.
+ */
+export class FirstPersonPlayerControllerConfig {
+    body: {
+        /** Standing eye height, meters above body origin. */
+        height: number;
+        /** Crouched eye height. */
+        crouchHeight: number;
+        /** Capsule radius, for downstream physics. */
+        radius: number;
+        /** Kilograms — drives bob amplitude and land-impact magnitude. */
+        mass: number;
+    };
+    motion: {
+        walkSpeed: number;
+        sprintSpeed: number;
+        crouchSpeed: number;
+        /** [0..1] how much intent influences velocity while airborne. */
+        airControl: number;
+        /** m/s^2 horizontal acceleration toward intent on ground. */
+        groundAccel: number;
+        /** m/s^2 horizontal deceleration toward 0 when intent is zero. */
+        groundDecel: number;
+        /** m/s^2 horizontal acceleration while airborne. */
+        airAccel: number;
+    };
+    jump: {
+        /** Apex height of a clean jump, meters. */
+        peakHeight: number;
+        /** Seconds to reach apex from launch. Together these two derive g. */
+        timeToApex: number;
+        coyoteTime: number;
+        bufferTime: number;
+        /** Gravity multiplier while falling (vy <= 0). */
+        fallGravityMult: number;
+        /** Gravity multiplier when jump released early during ascent. */
+        cutGravityMult: number;
+        anticipation: {
+            duration: number;
+            dipAmount: number;
+        };
+    };
+    landing: {
+        /** m/s impact threshold; below = soft landing signal. */
+        softThreshold: number;
+        /** m/s impact threshold; above = hard landing signal. */
+        hardThreshold: number;
+        recovery: {
+            /** Meters of eye dip per m/s of impact velocity. */
+            dipPerVy: number;
+            /** Clamp on total dip. */
+            dipMax: number;
+            spring: {
+                halfLife: number;
+                /** zeta < 1 → rings once before settling, reads as compression. */
+                zeta: number;
+            };
+        };
+    };
+    crouch: {
+        /** Seconds to lerp eye height between standing and crouched. */
+        transitionTime: number;
+        /** "hold" or "toggle" */
+        mode: string;
+    };
+    bob: {
+        stepFreqAtWalk: number;
+        stepFreqExp: number;
+        verticalAmpAtWalk: number;
+        lateralAmpAtWalk: number;
+        /** Extra amplitude per kg above 80kg (reference mass). */
+        ampMassScale: number;
+        rollAtWalkDeg: number;
+        /** Speeds below this don't tick the stride at all. */
+        minStepSpeed: number;
+    };
+    breath: {
+        rateRestHz: number;
+        rateMaxHz: number;
+        amplitudeRestM: number;
+        amplitudeMaxM: number;
+        pitchAmpRestDeg: number;
+        pitchAmpMaxDeg: number;
+        /** ±20% amplitude noise rides on the sine. */
+        noiseAmount: number;
+    };
+    exertion: {
+        sprintRiseRate: number;
+        jumpRise: number;
+        idleDecayRate: number;
+        rateDecayHalfLife: number;
+        ampDecayHalfLife: number;
+    };
+    lean: {
+        enabled: boolean;
+        /** Degrees of roll per (lateral m/s^2 / 9.81). */
+        maxRollDeg: number;
+        spring: {
+            halfLife: number;
+            zeta: number;
+        };
+    };
+    fov: {
+        base: number;
+        sprintAdd: number;
+        crouchAdd: number;
+        smoothHalfLife: number;
+    };
+    look: {
+        pitchMinDeg: number;
+        pitchMaxDeg: number;
+        invertY: boolean;
+    };
+    gravity: {
+        /** Default gravity magnitude (m/s^2). Overridden by computeJumpFromApex once
+         *  the jump tunables are resolved; kept here so non-jumping entities (NPCs,
+         *  paused players) still have a sensible fall behavior. */
+        magnitude: number;
+    };
+    toJSON(): {
+        body: {
+            /** Standing eye height, meters above body origin. */
+            height: number;
+            /** Crouched eye height. */
+            crouchHeight: number;
+            /** Capsule radius, for downstream physics. */
+            radius: number;
+            /** Kilograms — drives bob amplitude and land-impact magnitude. */
+            mass: number;
+        };
+        motion: {
+            walkSpeed: number;
+            sprintSpeed: number;
+            crouchSpeed: number;
+            /** [0..1] how much intent influences velocity while airborne. */
+            airControl: number;
+            /** m/s^2 horizontal acceleration toward intent on ground. */
+            groundAccel: number;
+            /** m/s^2 horizontal deceleration toward 0 when intent is zero. */
+            groundDecel: number;
+            /** m/s^2 horizontal acceleration while airborne. */
+            airAccel: number;
+        };
+        jump: {
+            anticipation: {
+                duration: number;
+                dipAmount: number;
+            };
+            /** Apex height of a clean jump, meters. */
+            peakHeight: number;
+            /** Seconds to reach apex from launch. Together these two derive g. */
+            timeToApex: number;
+            coyoteTime: number;
+            bufferTime: number;
+            /** Gravity multiplier while falling (vy <= 0). */
+            fallGravityMult: number;
+            /** Gravity multiplier when jump released early during ascent. */
+            cutGravityMult: number;
+        };
+        landing: {
+            recovery: {
+                spring: {
+                    halfLife: number;
+                    /** zeta < 1 → rings once before settling, reads as compression. */
+                    zeta: number;
+                };
+                /** Meters of eye dip per m/s of impact velocity. */
+                dipPerVy: number;
+                /** Clamp on total dip. */
+                dipMax: number;
+            };
+            /** m/s impact threshold; below = soft landing signal. */
+            softThreshold: number;
+            /** m/s impact threshold; above = hard landing signal. */
+            hardThreshold: number;
+        };
+        crouch: {
+            /** Seconds to lerp eye height between standing and crouched. */
+            transitionTime: number;
+            /** "hold" or "toggle" */
+            mode: string;
+        };
+        bob: {
+            stepFreqAtWalk: number;
+            stepFreqExp: number;
+            verticalAmpAtWalk: number;
+            lateralAmpAtWalk: number;
+            /** Extra amplitude per kg above 80kg (reference mass). */
+            ampMassScale: number;
+            rollAtWalkDeg: number;
+            /** Speeds below this don't tick the stride at all. */
+            minStepSpeed: number;
+        };
+        breath: {
+            rateRestHz: number;
+            rateMaxHz: number;
+            amplitudeRestM: number;
+            amplitudeMaxM: number;
+            pitchAmpRestDeg: number;
+            pitchAmpMaxDeg: number;
+            /** ±20% amplitude noise rides on the sine. */
+            noiseAmount: number;
+        };
+        exertion: {
+            sprintRiseRate: number;
+            jumpRise: number;
+            idleDecayRate: number;
+            rateDecayHalfLife: number;
+            ampDecayHalfLife: number;
+        };
+        lean: {
+            spring: {
+                halfLife: number;
+                zeta: number;
+            };
+            enabled: boolean;
+            /** Degrees of roll per (lateral m/s^2 / 9.81). */
+            maxRollDeg: number;
+        };
+        fov: {
+            base: number;
+            sprintAdd: number;
+            crouchAdd: number;
+            smoothHalfLife: number;
+        };
+        look: {
+            pitchMinDeg: number;
+            pitchMaxDeg: number;
+            invertY: boolean;
+        };
+        gravity: {
+            /** Default gravity magnitude (m/s^2). Overridden by computeJumpFromApex once
+             *  the jump tunables are resolved; kept here so non-jumping entities (NPCs,
+             *  paused players) still have a sensible fall behavior. */
+            magnitude: number;
+        };
+    };
+    fromJSON(json: any): void;
+    /**
+     * @param {FirstPersonPlayerControllerConfig} other
+     */
+    copy(other: FirstPersonPlayerControllerConfig): void;
+    clone(): FirstPersonPlayerControllerConfig;
+}
+//# sourceMappingURL=FirstPersonPlayerControllerConfig.d.ts.map

package/src/engine/control/first-person/FirstPersonPlayerControllerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FirstPersonPlayerControllerConfig.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerConfig.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;IACI;QACI,qDAAqD;;QAErD,2BAA2B;;QAE3B,8CAA8C;;QAE9C,kEAAkE;;MAEpE;IAMF;;;;QAII,iEAAiE;;QAEjE,6DAA6D;;QAE7D,kEAAkE;;QAElE,oDAAoD;;MAEtD;IAEF;QACI,2CAA2C;;QAE3C,sEAAsE;;;;QAItE,kDAAkD;;QAElD,iEAAiE;;;;;;MAMnE;IAEF;QACI,yDAAyD;;QAEzD,yDAAyD;;;YAGrD,oDAAoD;;YAEpD,0BAA0B;;;;gBAItB,mEAAmE;;;;MAI7E;IAEF;QACI,gEAAgE;;QAEhE,yBAAyB;;MAE3B;IAEF;;;;;QAKI,0DAA0D;;;QAG1D,sDAAsD;;MAExD;IAEF;;;;;;;QAOI,8CAA8C;;MAEhD;IAEF;;;;;;MAME;IAEF;;QAEI,kDAAkD;;;;;;MAGpD;IAEF;;;;;MAKE;IAEF;;;;MAIE;IAEF;QACI;;mEAE2D;;MAE7D;IAEF;;YAhII,qDAAqD;;YAErD,2BAA2B;;YAE3B,8CAA8C;;YAE9C,kEAAkE;;;;;;;YAYlE,iEAAiE;;YAEjE,6DAA6D;;YAE7D,kEAAkE;;YAElE,oDAAoD;;;;;;;;YAKpD,2CAA2C;;YAE3C,sEAAsE;;;;YAItE,kDAAkD;;YAElD,iEAAiE;;;;;;;oBAoBzD,mEAAmE;;;gBANvE,oDAAoD;;gBAEpD,0BAA0B;;;YAP9B,yDAAyD;;YAEzD,yDAAyD;;;;YAgBzD,gEAAgE;;YAEhE,yBAAyB;;;;;;;;YASzB,0DAA0D;;;YAG1D,sDAAsD;;;;;;;;;;YAWtD,8CAA8C;;;;;;;;;;;;;;;;YAc9C,kDAAkD;;;;;;;;;;;;;;;YAmBlD;;uEAE2D;;;MAyB9D;IAED,0BA6BC;IAED;;OAEG;IACH,YAFW,iCAAiC,QAI3C;IAED,2CAIC;CACJ"}