@fonsecabarreto/genesis-gl-core 0.1.0

package/dist/Game/index.js

@@ -0,0 +1,353 @@
+import {
+  KeyboardInput
+} from "../chunk-P7QOKDLY.js";
+import "../chunk-SUNYSY45.js";
+import {
+  Mesh
+} from "../chunk-QCQVJCSR.js";
+import "../chunk-6LS6AO5H.js";
+import {
+  Model
+} from "../chunk-JK2HEZAT.js";
+import "../chunk-3ULETMWF.js";
+import "../chunk-5TAAXI6S.js";
+
+// src/Game/classes/AnimationController.ts
+var AnimationController = class {
+  /**
+   * @param animations - The model's animation map (same reference).
+   * @param playFn     - Callback that actually starts an animation clip
+   *                     on the model (e.g. `model.playAnimation`).
+   */
+  constructor(animations, playFn) {
+    this.animations = animations;
+    this.playFn = playFn;
+  }
+  animations;
+  playFn;
+  states = /* @__PURE__ */ new Map();
+  transitions = [];
+  currentStateName = null;
+  // ── State management ────────────────────────────────────────
+  /** Register an animation state. */
+  addState(state) {
+    this.states.set(state.name, state);
+    return this;
+  }
+  /** Convenience: register multiple states at once. */
+  addStates(states) {
+    for (const s of states) this.addState(s);
+    return this;
+  }
+  /** Register a transition between two states. */
+  addTransition(from, to, condition) {
+    this.transitions.push({ from, to, condition });
+    return this;
+  }
+  // ── Playback ────────────────────────────────────────────────
+  /** Force-start a specific state (e.g. on init). */
+  start(stateName) {
+    const state = this.states.get(stateName);
+    if (!state) {
+      console.warn(`[AnimationController] State "${stateName}" not found`);
+      return;
+    }
+    this.currentStateName = stateName;
+    this.playFn(state.clipName, state.loop ?? true);
+    const clip = this.animations.get(state.clipName);
+    if (clip) clip.speed = state.speed ?? 1;
+  }
+  /**
+   * Evaluate all transitions from the current state.
+   * Call this once per frame. The first matching transition wins.
+   */
+  evaluate() {
+    if (!this.currentStateName) return;
+    for (const t of this.transitions) {
+      if (t.from === this.currentStateName && t.condition()) {
+        this.start(t.to);
+        return;
+      }
+    }
+  }
+  /** The name of the currently active state (or `null`). */
+  get currentState() {
+    return this.currentStateName;
+  }
+};
+
+// src/Game/classes/Character.ts
+var Character = class extends Model {
+  id;
+  health = 100;
+  /** Friction applied when grounded — updated from the surface material on landing.
+   *  0 = no resistance (pure ice), 1 = instant stop. */
+  surfaceFriction = 0.3;
+  /** Horizontal damping while airborne. 0 = no air drag, 1 = instant stop. */
+  airFriction = 0.02;
+  speed = 0.2;
+  stamina = 10;
+  velocity = [0, 0, 0];
+  _isGrounded = false;
+  /** Setting to true (landing) resets the jump counter. */
+  get isGrounded() {
+    return this._isGrounded;
+  }
+  set isGrounded(v) {
+    if (v && !this._isGrounded) {
+      const hardLanding = this.velocity[1] <= this.minLandingImpact;
+      if (this.isInputActive && hardLanding) this._landingRoll = true;
+      this._jumpsUsed = 0;
+      this.isDoubleJumping = false;
+    }
+    this._isGrounded = v;
+  }
+  /** Pending auto-roll on landing after a double jump. */
+  _landingRoll = false;
+  /** Minimum downward impact speed (negative Y velocity) required to trigger
+   *  a landing roll. Tune this value — jumpForce is 0.65, so:
+   *  -0.20 = any jump from ground,  -0.40 = only falls from significant height */
+  minLandingImpact = -0.6;
+  /** True during the airborne period after a second (mid-air) jump. */
+  isDoubleJumping = false;
+  /** True while movement keys are held — drives run animation independently of velocity. */
+  isInputActive = false;
+  jumpForce = 0.65;
+  // ── Acceleration system — target velocity set by input each tick —————
+  // lerp rate is derived from surface friction so ice feels sluggish and
+  // sand feels grippy both when accelerating and decelerating.
+  _targetVx = 0;
+  _targetVz = 0;
+  animController;
+  // ── Roll state ───────────────────────────────────────────────
+  _isRolling = false;
+  _rollTimer = 0;
+  _rollDuration = 0.5;
+  // seconds
+  _rollSpeed = 0.2;
+  /** True when rolling was triggered by a hard landing (not a manual roll). */
+  isLandingRoll = false;
+  /** Direction captured at roll start (world-space XZ). */
+  _rollDir = [0, 1];
+  // ── Jump state ───────────────────────────────────────────────
+  _isJumping = false;
+  _jumpTimer = 0;
+  _jumpDuration = 0.1;
+  // seconds
+  _jumpsUsed = 0;
+  maxJumps = 2;
+  constructor(id, baseModel) {
+    super(
+      baseModel.meshes,
+      [...baseModel.translation],
+      [...baseModel.scale],
+      baseModel.name,
+      baseModel.skeleton?.clone() ?? null
+    );
+    this.id = id;
+    this.rotation = [...baseModel.rotation];
+    for (const [name, clip] of baseModel.animations) {
+      this.animations.set(name, clip.clone());
+    }
+    this.updateBoundingBox();
+    this.animController = new AnimationController(
+      this.animations,
+      (clip, loop) => this.playAnimation(clip, loop)
+    );
+  }
+  /** Whether the character has meaningful horizontal velocity.
+   *  Default threshold is 20% of configured speed — so the walk animation
+   *  plays until the character has genuinely slowed down, not just slightly. */
+  isMoving(threshold = this.speed * 0.6) {
+    return Math.abs(this.velocity[0]) > threshold || Math.abs(this.velocity[2]) > threshold;
+  }
+  /** True while the roll animation is playing. */
+  get isRolling() {
+    return this._isRolling;
+  }
+  /** True while the jump animation is playing. */
+  get isJumping() {
+    return this._isJumping;
+  }
+  /** Start a jump — first jump requires grounded, second can fire mid-air. */
+  jump() {
+    if (this._isRolling) return;
+    if (this._jumpsUsed >= this.maxJumps) return;
+    const isSecondJump = this._jumpsUsed >= 1;
+    this.velocity[1] = this.jumpForce;
+    if (this._targetVx !== 0 || this._targetVz !== 0) {
+      const boost = 0.5;
+      this.velocity[0] += this._targetVx * boost;
+      this.velocity[2] += this._targetVz * boost;
+    }
+    this.isGrounded = false;
+    this._isJumping = true;
+    this._jumpTimer = 0;
+    this._jumpsUsed++;
+    if (isSecondJump) this.isDoubleJumping = true;
+  }
+  /** Start a roll — only if grounded and not already rolling/jumping. */
+  roll() {
+    if (!this.isGrounded || this._isRolling || this._isJumping || !this.isInputActive)
+      return;
+    this.isLandingRoll = false;
+    this._beginRoll();
+  }
+  /** Internal roll starter — skips input guards (used for forced landing roll). */
+  _beginRoll(fromLanding = false) {
+    if (!this.isGrounded) return;
+    this._isRolling = true;
+    this.isLandingRoll = fromLanding;
+    this._rollTimer = 0;
+    const yaw = this.rotation[1];
+    this._rollDir = [Math.sin(yaw), Math.cos(yaw)];
+  }
+  getDirectionFromCamera(camera) {
+    const yaw = camera.yaw;
+    const forward = [Math.sin(yaw), 0, Math.cos(yaw)];
+    const right = [Math.cos(yaw), 0, -Math.sin(yaw)];
+    return { forward, right };
+  }
+  moveRelative(forwardAmount, rightAmount, camera) {
+    const { forward, right } = this.getDirectionFromCamera(camera);
+    const vx = forward[0] * forwardAmount + right[0] * rightAmount;
+    const vz = forward[2] * forwardAmount + right[2] * rightAmount;
+    const len = Math.sqrt(vx * vx + vz * vz);
+    const nx = len > 0 ? vx / len : 0;
+    const nz = len > 0 ? vz / len : 0;
+    const topSpeed = this.speed * (1 - this.surfaceFriction);
+    this._targetVx = nx * topSpeed;
+    this._targetVz = nz * topSpeed;
+    if (nx !== 0 || nz !== 0) {
+      this.setRotation(0, Math.atan2(nx, nz), 0);
+    }
+    this.consumeStamina();
+  }
+  consumeStamina() {
+    this.stamina = Math.max(0, this.stamina - 0.5);
+  }
+  update(deltaTime = 0.016) {
+    if (this._isRolling) {
+      this._rollTimer += deltaTime;
+      this.velocity[0] = this._rollDir[0] * this._rollSpeed;
+      this.velocity[2] = this._rollDir[1] * this._rollSpeed;
+      this._targetVx = 0;
+      this._targetVz = 0;
+      if (this._rollTimer >= this._rollDuration) {
+        this._isRolling = false;
+        this.isLandingRoll = false;
+      }
+    } else {
+      const fr = this.isGrounded ? this.surfaceFriction : this.airFriction;
+      const accel = Math.min(0.9, fr + 5e-3);
+      this.velocity[0] += (this._targetVx - this.velocity[0]) * accel;
+      this.velocity[2] += (this._targetVz - this.velocity[2]) * accel;
+      this._targetVx = 0;
+      this._targetVz = 0;
+      if (!this.isGrounded && this.velocity[1] < 0) {
+        this.velocity[1] *= 1 - this.airFriction * 4;
+      }
+    }
+    if (!this.isGrounded && this._jumpsUsed === 0) {
+      this._jumpsUsed = 1;
+    }
+    if (this._isJumping) {
+      this._jumpTimer += deltaTime;
+      if (this._jumpTimer >= this._jumpDuration && this.isGrounded) {
+        this._isJumping = false;
+        if (this._landingRoll && !this._isRolling) {
+          this._landingRoll = false;
+          this._beginRoll(true);
+        }
+      }
+    } else if (this.isGrounded) {
+      this._isJumping = false;
+      if (this._landingRoll && !this._isRolling) {
+        this._landingRoll = false;
+        this._beginRoll(true);
+      }
+    }
+    this.animController.evaluate();
+    super.update(deltaTime);
+    this.move(this.velocity[0], this.velocity[1], this.velocity[2]);
+    if (Math.abs(this.velocity[0]) < 1e-3) this.velocity[0] = 0;
+    if (Math.abs(this.velocity[1]) < 1e-3) this.velocity[1] = 0;
+    if (Math.abs(this.velocity[2]) < 1e-3) this.velocity[2] = 0;
+  }
+  stop() {
+    this.velocity = [0, 0, 0];
+  }
+};
+
+// src/Game/classes/BodyPieces/Arms.ts
+var Arm = class extends Mesh {
+  swingPhase = 0;
+  swingSpeed = 5;
+  swingAmount = 0.7;
+  side;
+  constructor(vertices, normals, material, side = 1) {
+    super("character_arm", vertices, normals, material);
+    this.side = side;
+  }
+  /**
+   * Updates the animation state for this arm.
+   * Returns the desired rotation (in radians) to be applied externally.
+   */
+  animate(moving, deltaTime, invert = 1) {
+    if (moving) {
+      this.swingPhase += deltaTime * this.swingSpeed;
+      return Math.sin(this.swingPhase) * this.swingAmount * invert * this.side;
+    } else {
+      this.swingPhase *= 0.9;
+      return 0;
+    }
+  }
+};
+
+// src/Game/classes/BodyPieces/Head.ts
+var Head = class _Head extends Mesh {
+  constructor(vertices, normals, material) {
+    super("character_head", vertices, normals, material);
+  }
+  /**
+   * Create a Head mesh from an existing Mesh.
+   * Optionally override translation and scale.
+   */
+  static fromMesh(mesh) {
+    return new _Head(mesh.vertices, mesh.normals, mesh.material);
+  }
+};
+
+// src/Game/classes/BodyPieces/Leg.ts
+var Leg = class extends Mesh {
+  swingAngle = 0;
+  swingSpeed = 12;
+  swingAmount = 0.4;
+  side;
+  constructor(vertices, normals, material, side) {
+    super("character_leg", vertices, normals, material);
+    this.side = side;
+  }
+  /**
+   * Updates the swing animation state for this leg.
+   * The actual rotation transform should be applied by a parent model/skeleton.
+   */
+  animate(moving, deltaTime) {
+    if (moving) {
+      this.swingAngle += deltaTime * this.swingSpeed;
+      return Math.sin(this.swingAngle) * this.swingAmount * this.side;
+    } else {
+      this.swingAngle *= 0.9;
+      return 0;
+    }
+  }
+};
+export {
+  AnimationController,
+  Arm,
+  Character,
+  Head,
+  KeyboardInput,
+  Leg
+};
+//# sourceMappingURL=index.js.map

package/dist/Game/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/Game/classes/AnimationController.ts","../../src/Game/classes/Character.ts","../../src/Game/classes/BodyPieces/Arms.ts","../../src/Game/classes/BodyPieces/Head.ts","../../src/Game/classes/BodyPieces/Leg.ts"],"sourcesContent":["import { AnimationClip } from '../../Core/classes/AnimationClip';\n\n/** A named state that maps to one animation clip. */\nexport interface AnimationState {\n  /** Unique state name, e.g. \"idle\", \"run\", \"jump\". */\n  name: string;\n  /** The animation clip name (key in Model.animations). */\n  clipName: string;\n  /** Whether the clip should loop (default `true`). */\n  loop?: boolean;\n  /** Playback speed multiplier (default `1`). 2 = double speed, 0.5 = half. */\n  speed?: number;\n}\n\n/**\n * A condition evaluated every frame to decide whether to transition.\n * Return `true` to trigger the transition.\n */\nexport type TransitionCondition = () => boolean;\n\n/** A rule that connects two states. */\nexport interface AnimationTransition {\n  from: string;\n  to: string;\n  condition: TransitionCondition;\n}\n\n/**\n * Decoupled animation state-machine controller.\n *\n * Register states (idle, run, …) and transitions between them,\n * then call `evaluate()` every frame. The controller resolves the\n * current state and drives `playAnimation` on the owner model —\n * no index juggling, no hardcoded names scattered around the codebase.\n *\n * @example\n * ```ts\n * const ctrl = new AnimationController(animations);\n *\n * ctrl.addState({ name: 'idle', clipName: 'Armature|idle' });\n * ctrl.addState({ name: 'run',  clipName: 'Armature|run'  });\n *\n * ctrl.addTransition('idle', 'run',  () => character.isMoving());\n * ctrl.addTransition('run',  'idle', () => !character.isMoving());\n *\n * ctrl.start('idle');\n *\n * // in game loop:\n * ctrl.evaluate();\n * ```\n */\nexport class AnimationController {\n  private states = new Map<string, AnimationState>();\n  private transitions: AnimationTransition[] = [];\n  private currentStateName: string | null = null;\n\n  /**\n   * @param animations - The model's animation map (same reference).\n   * @param playFn     - Callback that actually starts an animation clip\n   *                     on the model (e.g. `model.playAnimation`).\n   */\n  constructor(\n    private readonly animations: Map<string, AnimationClip>,\n    private readonly playFn: (clipName: string, loop: boolean) => void,\n  ) {}\n\n  // ── State management ────────────────────────────────────────\n\n  /** Register an animation state. */\n  addState(state: AnimationState): this {\n    this.states.set(state.name, state);\n    return this;\n  }\n\n  /** Convenience: register multiple states at once. */\n  addStates(states: AnimationState[]): this {\n    for (const s of states) this.addState(s);\n    return this;\n  }\n\n  /** Register a transition between two states. */\n  addTransition(\n    from: string,\n    to: string,\n    condition: TransitionCondition,\n  ): this {\n    this.transitions.push({ from, to, condition });\n    return this;\n  }\n\n  // ── Playback ────────────────────────────────────────────────\n\n  /** Force-start a specific state (e.g. on init). */\n  start(stateName: string): void {\n    const state = this.states.get(stateName);\n    if (!state) {\n      console.warn(`[AnimationController] State \"${stateName}\" not found`);\n      return;\n    }\n    this.currentStateName = stateName;\n    this.playFn(state.clipName, state.loop ?? true);\n    // Apply playback speed — must be set after playFn because playAnimation resets the clip\n    const clip = this.animations.get(state.clipName);\n    if (clip) clip.speed = state.speed ?? 1;\n  }\n\n  /**\n   * Evaluate all transitions from the current state.\n   * Call this once per frame. The first matching transition wins.\n   */\n  evaluate(): void {\n    if (!this.currentStateName) return;\n\n    for (const t of this.transitions) {\n      if (t.from === this.currentStateName && t.condition()) {\n        this.start(t.to);\n        return; // one transition per frame\n      }\n    }\n  }\n\n  /** The name of the currently active state (or `null`). */\n  get currentState(): string | null {\n    return this.currentStateName;\n  }\n}\n","import { Vector3 } from '../../Core/domain/interfaces/Vectors';\nimport { Camera } from '../../Core';\nimport { Model } from '../../Core/classes/Model';\nimport { AnimationController } from './AnimationController';\n\nexport class Character extends Model {\n  public id: string;\n  health = 100;\n  /** Friction applied when grounded — updated from the surface material on landing.\n   *  0 = no resistance (pure ice), 1 = instant stop. */\n  surfaceFriction = 0.3;\n  /** Horizontal damping while airborne. 0 = no air drag, 1 = instant stop. */\n  readonly airFriction = 0.02;\n  speed = 0.2;\n  stamina = 10;\n  public velocity: Vector3 = [0, 0, 0];\n  private _isGrounded = false;\n  /** Setting to true (landing) resets the jump counter. */\n  public get isGrounded(): boolean {\n    return this._isGrounded;\n  }\n  public set isGrounded(v: boolean) {\n    if (v && !this._isGrounded) {\n      // Queue a landing roll only if:\n      //  1. player is still pressing a direction\n      //  2. impact speed exceeds the minimum threshold (works for jumps AND falls)\n      const hardLanding = this.velocity[1] <= this.minLandingImpact;\n      if (this.isInputActive && hardLanding) this._landingRoll = true;\n      this._jumpsUsed = 0;\n      this.isDoubleJumping = false;\n    }\n    this._isGrounded = v;\n  }\n  /** Pending auto-roll on landing after a double jump. */\n  private _landingRoll = false;\n  /** Minimum downward impact speed (negative Y velocity) required to trigger\n   *  a landing roll. Tune this value — jumpForce is 0.65, so:\n   *  -0.20 = any jump from ground,  -0.40 = only falls from significant height */\n  public minLandingImpact = -0.60;\n  /** True during the airborne period after a second (mid-air) jump. */\n  public isDoubleJumping = false;\n  /** True while movement keys are held — drives run animation independently of velocity. */\n  public isInputActive = false;\n  private jumpForce = 0.65;\n\n  // ── Acceleration system — target velocity set by input each tick —————\n  // lerp rate is derived from surface friction so ice feels sluggish and\n  // sand feels grippy both when accelerating and decelerating.\n  private _targetVx = 0;\n  private _targetVz = 0;\n  public readonly animController: AnimationController;\n\n  // ── Roll state ───────────────────────────────────────────────\n  private _isRolling = false;\n  private _rollTimer = 0;\n  private readonly _rollDuration = 0.5; // seconds\n  private readonly _rollSpeed = 0.2;\n  /** True when rolling was triggered by a hard landing (not a manual roll). */\n  public isLandingRoll = false;\n  /** Direction captured at roll start (world-space XZ). */\n  private _rollDir: [number, number] = [0, 1];\n\n  // ── Jump state ───────────────────────────────────────────────\n  private _isJumping = false;\n  private _jumpTimer = 0;\n  private readonly _jumpDuration = 0.1; // seconds\n  private _jumpsUsed = 0;\n  readonly maxJumps = 2;\n\n  constructor(id: string, baseModel: Model) {\n    // Clone the base model — pass skeleton so the constructor's bbox\n    // computation includes the rootTransform from the very first frame.\n    super(\n      baseModel.meshes,\n      [...baseModel.translation],\n      [...baseModel.scale],\n      baseModel.name,\n      baseModel.skeleton?.clone() ?? null,\n    );\n\n    this.id = id;\n    this.rotation = [...baseModel.rotation];\n\n    // Carry over animations so the Character can play them\n    for (const [name, clip] of baseModel.animations) {\n      this.animations.set(name, clip.clone());\n    }\n\n    this.updateBoundingBox();\n\n    this.animController = new AnimationController(\n      this.animations,\n      (clip, loop) => this.playAnimation(clip, loop),\n    );\n  }\n\n  /** Whether the character has meaningful horizontal velocity.\n   *  Default threshold is 20% of configured speed — so the walk animation\n   *  plays until the character has genuinely slowed down, not just slightly. */\n  public isMoving(threshold = this.speed * 0.6): boolean {\n    return (\n      Math.abs(this.velocity[0]) > threshold ||\n      Math.abs(this.velocity[2]) > threshold\n    );\n  }\n\n  /** True while the roll animation is playing. */\n  public get isRolling(): boolean {\n    return this._isRolling;\n  }\n\n  /** True while the jump animation is playing. */\n  public get isJumping(): boolean {\n    return this._isJumping;\n  }\n\n  /** Start a jump — first jump requires grounded, second can fire mid-air. */\n  public jump(): void {\n    if (this._isRolling) return;\n    if (this._jumpsUsed >= this.maxJumps) return;\n    const isSecondJump = this._jumpsUsed >= 1;\n    this.velocity[1] = this.jumpForce;\n    // Directional boost — if the player has directional input this tick,\n    // add an impulse in that direction so jumps feel snappy and purposeful.\n    // Factor of 2.5 on top of the normal target velocity gives a clear boost\n    // without being excessive.\n    if (this._targetVx !== 0 || this._targetVz !== 0) {\n      const boost = 0.5;\n      this.velocity[0] += this._targetVx * boost;\n      this.velocity[2] += this._targetVz * boost;\n    }\n    this.isGrounded = false;\n    this._isJumping = true;\n    this._jumpTimer = 0;\n    this._jumpsUsed++;\n    if (isSecondJump) this.isDoubleJumping = true;\n  }\n\n  /** Start a roll — only if grounded and not already rolling/jumping. */\n  public roll(): void {\n    if (\n      !this.isGrounded ||\n      this._isRolling ||\n      this._isJumping ||\n      !this.isInputActive\n    )\n      return;\n    this.isLandingRoll = false;\n    this._beginRoll();\n  }\n\n  /** Internal roll starter — skips input guards (used for forced landing roll). */\n  private _beginRoll(fromLanding = false): void {\n    if (!this.isGrounded) return;\n    this._isRolling = true;\n    this.isLandingRoll = fromLanding;\n    this._rollTimer = 0;\n    const yaw = this.rotation[1];\n    this._rollDir = [Math.sin(yaw), Math.cos(yaw)];\n  }\n\n  private getDirectionFromCamera(camera: Camera): {\n    forward: Vector3;\n    right: Vector3;\n  } {\n    const yaw = camera.yaw;\n    const forward: Vector3 = [Math.sin(yaw), 0, Math.cos(yaw)];\n    const right: Vector3 = [Math.cos(yaw), 0, -Math.sin(yaw)];\n    return { forward, right };\n  }\n\n  public moveRelative(\n    forwardAmount: number,\n    rightAmount: number,\n    camera: Camera,\n  ) {\n    const { forward, right } = this.getDirectionFromCamera(camera);\n    const vx = forward[0] * forwardAmount + right[0] * rightAmount;\n    const vz = forward[2] * forwardAmount + right[2] * rightAmount;\n\n    // Normalise diagonal input so diagonal isn't faster than straight\n    const len = Math.sqrt(vx * vx + vz * vz);\n    const nx = len > 0 ? vx / len : 0;\n    const nz = len > 0 ? vz / len : 0;\n\n    // Set desired velocity — update() will lerp toward it this tick.\n    // Top speed is scaled by (1 - friction): ice ≈ full speed, sand ≈ 45% speed.\n    const topSpeed = this.speed * (1 - this.surfaceFriction);\n    this._targetVx = nx * topSpeed;\n    this._targetVz = nz * topSpeed;\n\n    if (nx !== 0 || nz !== 0) {\n      this.setRotation(0, Math.atan2(nx, nz), 0);\n    }\n\n    this.consumeStamina();\n  }\n\n  public consumeStamina() {\n    this.stamina = Math.max(0, this.stamina - 0.5);\n  }\n\n  public override update(deltaTime: number = 0.016) {\n    // ── Roll tick ——————————————————————————\n    if (this._isRolling) {\n      this._rollTimer += deltaTime;\n      // Drive character forward at roll speed\n      this.velocity[0] = this._rollDir[0] * this._rollSpeed;\n      this.velocity[2] = this._rollDir[1] * this._rollSpeed;\n      // Discard any pending input target\n      this._targetVx = 0;\n      this._targetVz = 0;\n      if (this._rollTimer >= this._rollDuration) {\n        this._isRolling = false;\n        this.isLandingRoll = false;\n      }\n    } else {\n      // ── Lerp horizontal velocity toward input target —————————\n      // accel is derived from friction — lower base (0.005) means\n      // very low friction surfaces (ice) take much longer to build speed:\n      //   ice  (0.005) → 0.010 → ~45% speed after 1s — very sluggish\n      //   grass(0.35)  → 0.355 → ~99% speed after 5 ticks — responsive\n      //   sand (0.55)  → 0.555 → instant — heavy/grippy\n      const fr = this.isGrounded ? this.surfaceFriction : this.airFriction;\n      const accel = Math.min(0.9, fr + 0.005);\n      this.velocity[0] += (this._targetVx - this.velocity[0]) * accel;\n      this.velocity[2] += (this._targetVz - this.velocity[2]) * accel;\n      // Reset target — must be re-set every tick by input or it decays to 0\n      this._targetVx = 0;\n      this._targetVz = 0;\n\n      // Vertical air resistance: damp downward velocity to create terminal velocity.\n      // Only applied while falling (velocity[1] < 0) and airborne.\n      if (!this.isGrounded && this.velocity[1] < 0) {\n        this.velocity[1] *= 1 - this.airFriction * 4;\n      }\n    }\n\n    // ── Jump tick ──────────────────────────────────────────────\n    // Consume the \"first jump\" slot when the player walks off a ledge without\n    // jumping — prevents getting 2 full mid-air jumps from a fall.\n    if (!this.isGrounded && this._jumpsUsed === 0) {\n      this._jumpsUsed = 1;\n    }\n    if (this._isJumping) {\n      this._jumpTimer += deltaTime;\n      if (this._jumpTimer >= this._jumpDuration && this.isGrounded) {\n        this._isJumping = false;\n        // Auto-roll on landing if coming from a double jump\n        if (this._landingRoll && !this._isRolling) {\n          this._landingRoll = false;\n          this._beginRoll(true);\n        }\n      }\n    } else if (this.isGrounded) {\n      this._isJumping = false;\n      if (this._landingRoll && !this._isRolling) {\n        this._landingRoll = false;\n        this._beginRoll(true);\n      }\n    }\n\n    // Evaluate animation state transitions\n    this.animController.evaluate();\n\n    // Advance skeletal animation (if any)\n    super.update(deltaTime);\n\n    // Movement\n    this.move(this.velocity[0], this.velocity[1], this.velocity[2]);\n\n    // Tiny threshold to stop completely (lerp never reaches exact 0)\n    if (Math.abs(this.velocity[0]) < 0.001) this.velocity[0] = 0;\n    if (Math.abs(this.velocity[1]) < 0.001) this.velocity[1] = 0;\n    if (Math.abs(this.velocity[2]) < 0.001) this.velocity[2] = 0;\n  }\n\n  public stop() {\n    this.velocity = [0, 0, 0];\n  }\n}\n","import { Material, Mesh } from '../../../Core';\n\nexport class Arm extends Mesh {\n  private swingPhase = 0;\n  private swingSpeed = 5;\n  private swingAmount = 0.7;\n  private side: 1 | -1;\n\n  constructor(\n    vertices: Float32Array,\n    normals: Float32Array,\n    material: Material,\n    side: 1 | -1 = 1, // right = 1, left = -1\n  ) {\n    super('character_arm', vertices, normals, material);\n    this.side = side;\n  }\n\n  /**\n   * Updates the animation state for this arm.\n   * Returns the desired rotation (in radians) to be applied externally.\n   */\n  public animate(moving: boolean, deltaTime: number, invert = 1): number {\n    if (moving) {\n      this.swingPhase += deltaTime * this.swingSpeed;\n      // Swing opposite arms with side factor and invert option\n      return Math.sin(this.swingPhase) * this.swingAmount * invert * this.side;\n    } else {\n      // When not moving, ease toward rest\n      this.swingPhase *= 0.9;\n      return 0;\n    }\n  }\n}\n","import { Material, Mesh } from '../../../Core';\n\nexport class Head extends Mesh {\n  constructor(\n    vertices: Float32Array,\n    normals: Float32Array,\n    material: Material,\n  ) {\n    super('character_head', vertices, normals, material);\n  }\n\n  /**\n   * Create a Head mesh from an existing Mesh.\n   * Optionally override translation and scale.\n   */\n  static fromMesh(mesh: Mesh) {\n    return new Head(mesh.vertices, mesh.normals, mesh.material);\n  }\n}\n","import { Material, Mesh } from '../../../Core';\n\nexport class Leg extends Mesh {\n  private swingAngle = 0;\n  private swingSpeed = 12;\n  private swingAmount = 0.4;\n  private side: 1 | -1;\n\n  constructor(\n    vertices: Float32Array,\n    normals: Float32Array,\n    material: Material,\n    side: 1 | -1,\n  ) {\n    super('character_leg', vertices, normals, material);\n    this.side = side;\n  }\n\n  /**\n   * Updates the swing animation state for this leg.\n   * The actual rotation transform should be applied by a parent model/skeleton.\n   */\n  public animate(moving: boolean, deltaTime: number): number {\n    if (moving) {\n      this.swingAngle += deltaTime * this.swingSpeed;\n      // Return desired rotation angle (around X axis)\n      return Math.sin(this.swingAngle) * this.swingAmount * this.side;\n    } else {\n      // Gradually relax back to rest\n      this.swingAngle *= 0.9;\n      return 0;\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/KeyboardControl-5w7Vm0J0.d.ts

@@ -0,0 +1,18 @@
+type ControlKey = 'up' | 'down' | 'left' | 'right' | 'jump' | 'roll';
+type ControlListener = (key: ControlKey, isPressed: boolean) => void;
+declare class KeyboardControl {
+    private pressedKeys;
+    private listeners;
+    private keyDownHandler?;
+    private keyUpHandler?;
+    enable(): void;
+    disable(): void;
+    onChange(listener: ControlListener): void;
+    /** Remove a previously registered listener. */
+    removeListener(listener: ControlListener): void;
+    private notify;
+    private mapKey;
+    isPressed(key: ControlKey): boolean;
+}
+
+export { KeyboardControl as K };

package/dist/KeyboardInput-DTsfj3tE.d.ts

@@ -0,0 +1,166 @@
+import { C as Camera } from './Camera-DY_8gx3C.js';
+import { K as KeyboardControl } from './KeyboardControl-5w7Vm0J0.js';
+import { Vector3 } from './Core/domain/interfaces/Vectors.js';
+import { a as AnimationClip, i as Model } from './Model-CQvDXd-b.js';
+
+/** A named state that maps to one animation clip. */
+interface AnimationState {
+    /** Unique state name, e.g. "idle", "run", "jump". */
+    name: string;
+    /** The animation clip name (key in Model.animations). */
+    clipName: string;
+    /** Whether the clip should loop (default `true`). */
+    loop?: boolean;
+    /** Playback speed multiplier (default `1`). 2 = double speed, 0.5 = half. */
+    speed?: number;
+}
+/**
+ * A condition evaluated every frame to decide whether to transition.
+ * Return `true` to trigger the transition.
+ */
+type TransitionCondition = () => boolean;
+/** A rule that connects two states. */
+interface AnimationTransition {
+    from: string;
+    to: string;
+    condition: TransitionCondition;
+}
+/**
+ * Decoupled animation state-machine controller.
+ *
+ * Register states (idle, run, …) and transitions between them,
+ * then call `evaluate()` every frame. The controller resolves the
+ * current state and drives `playAnimation` on the owner model —
+ * no index juggling, no hardcoded names scattered around the codebase.
+ *
+ * @example
+ * ```ts
+ * const ctrl = new AnimationController(animations);
+ *
+ * ctrl.addState({ name: 'idle', clipName: 'Armature|idle' });
+ * ctrl.addState({ name: 'run',  clipName: 'Armature|run'  });
+ *
+ * ctrl.addTransition('idle', 'run',  () => character.isMoving());
+ * ctrl.addTransition('run',  'idle', () => !character.isMoving());
+ *
+ * ctrl.start('idle');
+ *
+ * // in game loop:
+ * ctrl.evaluate();
+ * ```
+ */
+declare class AnimationController {
+    private readonly animations;
+    private readonly playFn;
+    private states;
+    private transitions;
+    private currentStateName;
+    /**
+     * @param animations - The model's animation map (same reference).
+     * @param playFn     - Callback that actually starts an animation clip
+     *                     on the model (e.g. `model.playAnimation`).
+     */
+    constructor(animations: Map<string, AnimationClip>, playFn: (clipName: string, loop: boolean) => void);
+    /** Register an animation state. */
+    addState(state: AnimationState): this;
+    /** Convenience: register multiple states at once. */
+    addStates(states: AnimationState[]): this;
+    /** Register a transition between two states. */
+    addTransition(from: string, to: string, condition: TransitionCondition): this;
+    /** Force-start a specific state (e.g. on init). */
+    start(stateName: string): void;
+    /**
+     * Evaluate all transitions from the current state.
+     * Call this once per frame. The first matching transition wins.
+     */
+    evaluate(): void;
+    /** The name of the currently active state (or `null`). */
+    get currentState(): string | null;
+}
+
+declare class Character extends Model {
+    id: string;
+    health: number;
+    /** Friction applied when grounded — updated from the surface material on landing.
+     *  0 = no resistance (pure ice), 1 = instant stop. */
+    surfaceFriction: number;
+    /** Horizontal damping while airborne. 0 = no air drag, 1 = instant stop. */
+    readonly airFriction = 0.02;
+    speed: number;
+    stamina: number;
+    velocity: Vector3;
+    private _isGrounded;
+    /** Setting to true (landing) resets the jump counter. */
+    get isGrounded(): boolean;
+    set isGrounded(v: boolean);
+    /** Pending auto-roll on landing after a double jump. */
+    private _landingRoll;
+    /** Minimum downward impact speed (negative Y velocity) required to trigger
+     *  a landing roll. Tune this value — jumpForce is 0.65, so:
+     *  -0.20 = any jump from ground,  -0.40 = only falls from significant height */
+    minLandingImpact: number;
+    /** True during the airborne period after a second (mid-air) jump. */
+    isDoubleJumping: boolean;
+    /** True while movement keys are held — drives run animation independently of velocity. */
+    isInputActive: boolean;
+    private jumpForce;
+    private _targetVx;
+    private _targetVz;
+    readonly animController: AnimationController;
+    private _isRolling;
+    private _rollTimer;
+    private readonly _rollDuration;
+    private readonly _rollSpeed;
+    /** True when rolling was triggered by a hard landing (not a manual roll). */
+    isLandingRoll: boolean;
+    /** Direction captured at roll start (world-space XZ). */
+    private _rollDir;
+    private _isJumping;
+    private _jumpTimer;
+    private readonly _jumpDuration;
+    private _jumpsUsed;
+    readonly maxJumps = 2;
+    constructor(id: string, baseModel: Model);
+    /** Whether the character has meaningful horizontal velocity.
+     *  Default threshold is 20% of configured speed — so the walk animation
+     *  plays until the character has genuinely slowed down, not just slightly. */
+    isMoving(threshold?: number): boolean;
+    /** True while the roll animation is playing. */
+    get isRolling(): boolean;
+    /** True while the jump animation is playing. */
+    get isJumping(): boolean;
+    /** Start a jump — first jump requires grounded, second can fire mid-air. */
+    jump(): void;
+    /** Start a roll — only if grounded and not already rolling/jumping. */
+    roll(): void;
+    /** Internal roll starter — skips input guards (used for forced landing roll). */
+    private _beginRoll;
+    private getDirectionFromCamera;
+    moveRelative(forwardAmount: number, rightAmount: number, camera: Camera): void;
+    consumeStamina(): void;
+    update(deltaTime?: number): void;
+    stop(): void;
+}
+
+/**
+ * Thin adapter: forwards keyboard state into the Character.
+ * Does NOT run its own requestAnimationFrame — the game loop polls
+ * {@link applyInput} every fixed-update tick.
+ */
+declare class KeyboardInput {
+    private control;
+    private cb?;
+    private keysPressed;
+    private rollRequested;
+    private jumpRequested;
+    constructor(control: KeyboardControl, cb?: ((pos: any) => void) | undefined);
+    /** Wire up key listeners. Call once after constructing. */
+    bind(): void;
+    /**
+     * Called once per fixed-update from the game loop.
+     * Reads currently pressed keys and drives the character.
+     */
+    applyInput(character: Character, camera: Camera): void;
+}
+
+export { AnimationController as A, Character as C, KeyboardInput as K, type TransitionCondition as T, type AnimationState as a, type AnimationTransition as b };

package/dist/Material-BGLkldxv.d.ts

@@ -0,0 +1,74 @@
+import { Vector3, Vector4 } from './Core/domain/interfaces/Vectors.js';
+import { W as WebGLCore } from './WebGLCore-DR7ZHJB0.js';
+
+interface TextureOptions {
+    /** When true, use gl.REPEAT wrap mode for tiling textures. */
+    repeat?: boolean;
+}
+
+/**
+ * Supported light types.
+ * - `directional` – parallel rays (sun-like).
+ * - `point`       – omnidirectional with distance attenuation.
+ * - `ambient`     – constant contribution everywhere.
+ */
+type LightType = 'directional' | 'point' | 'ambient';
+/**
+ * A scene light with type, position, direction, colour, intensity,
+ * and attenuation factors (for point lights).
+ */
+declare class Light {
+    type: LightType;
+    position: Vector3;
+    direction: Vector3;
+    color: Vector3;
+    intensity: number;
+    constant: number;
+    linear: number;
+    quadratic: number;
+    constructor(type?: LightType, position?: Vector3, // for point lights
+    direction?: Vector3, // for directional lights
+    color?: Vector3, intensity?: number, constant?: number, linear?: number, quadratic?: number);
+    move(dx: number, dy: number, dz: number): void;
+    rotateY(delta: number): void;
+}
+
+/** Maximum number of lights supported per draw call (must match the shader). */
+declare const MAX_LIGHTS = 5;
+/**
+ * Encapsulates GPU material state: shader program reference, uniform/attribute
+ * caches, albedo colour, textures, and lighting properties.
+ */
+declare class Material {
+    private webglCore;
+    program: WebGLProgram;
+    uniformLocations: Record<string, WebGLUniformLocation | null>;
+    attribLocations: Record<string, number>;
+    albedoColor: Vector4;
+    unlit: boolean;
+    texture?: WebGLTexture;
+    specular: Vector3;
+    shininess: number;
+    doubleSided: boolean;
+    ambientColor: Vector3;
+    dissolve: number;
+    diffuse: Vector3;
+    /** Physics friction coefficient [0–1]. 0 = no resistance (ice), 1 = instant stop. */
+    friction: number;
+    constructor(webglCore: WebGLCore, options?: Partial<Material>);
+    setColorHex(hex: string): void;
+    setColor(rgba: [number, number, number, number]): void;
+    /**
+     * Load an image from URL and create a WebGL texture.
+     */
+    loadTexture(url: string, options?: TextureOptions): Promise<void>;
+    /**
+     * Create an independent copy of this material.
+     * Shares the same WebGL program but copies all mutable properties.
+     * The texture reference is shared (immutable GPU resource).
+     */
+    clone(): Material;
+    apply(gl: WebGLRenderingContext, lights: Light[], viewPosition?: Vector3): void;
+}
+
+export { Light as L, MAX_LIGHTS as M, type LightType as a, Material as b };