@mml-io/3d-web-client-core 0.0.0-experimental-8e124c7-20240520 → 0.0.0-experimental-ff88de3-20240530

package/build/index.js

@@ -246,7 +246,8 @@ var camValues = {
   invertFOVMapping: false,
   damping: 0.091,
   dampingScale: 0.01,
-  zoomScale: 0.01
+  zoomScale: 0.05,
+  zoomDamping: 0.3
 };
 var camOptions = {
   initialDistance: { min: 1, max: 5, step: 0.1 },
@@ -257,7 +258,8 @@ var camOptions = {
   minFOV: { min: 50, max: 100, step: 1 },
   damping: { min: 0.01, max: 0.15, step: 0.01 },
   dampingScale: { min: 1e-3, max: 0.02, step: 1e-3 },
-  zoomScale: { min: 5e-3, max: 0.025, step: 1e-3 }
+  zoomScale: { min: 5e-3, max: 0.3, step: 1e-3 },
+  zoomDamping: { min: 0, max: 2, step: 0.01 }
 };
 var CameraFolder = class {
   constructor(parentFolder, expand = false) {
@@ -277,6 +279,7 @@ var CameraFolder = class {
     this.folder.addBinding(camValues, "damping", camOptions.damping);
     this.folder.addBinding(camValues, "dampingScale", camOptions.dampingScale);
     this.folder.addBinding(camValues, "zoomScale", camOptions.zoomScale);
+    this.folder.addBinding(camValues, "zoomDamping", camOptions.zoomDamping);
   }
   setupChangeEvent(cameraManager) {
     this.folder.on("change", (e) => {
@@ -342,6 +345,11 @@ var CameraFolder = class {
           cameraManager.zoomScale = value;
           break;
         }
+        case "zoomDamping": {
+          const value = e.value;
+          cameraManager.zoomDamping = value;
+          break;
+        }
         default:
           break;
       }
@@ -375,6 +383,7 @@ var CameraManager = class {
     this.damping = camValues.damping;
     this.dampingScale = 0.01;
     this.zoomScale = camValues.zoomScale;
+    this.zoomDamping = camValues.zoomDamping;
     this.invertFOVMapping = camValues.invertFOVMapping;
     this.fov = this.initialFOV;
     this.targetFOV = this.initialFOV;
@@ -400,7 +409,7 @@ var CameraManager = class {
     this.targetPhi = initialPhi;
     this.theta = initialTheta;
     this.targetTheta = initialTheta;
-    this.camera = new PerspectiveCamera(this.fov, window.innerWidth / window.innerHeight, 0.1, 300);
+    this.camera = new PerspectiveCamera(this.fov, window.innerWidth / window.innerHeight, 0.1, 400);
     this.camera.position.set(0, 1.4, -this.initialDistance);
     this.rayCaster = new Raycaster();
     this.hasTouchControl = VirtualJoystick.checkForTouch();
@@ -408,7 +417,8 @@ var CameraManager = class {
       [targetElement, "mousedown", this.onMouseDown.bind(this)],
       [document, "mouseup", this.onMouseUp.bind(this)],
       [document, "mousemove", this.onMouseMove.bind(this)],
-      [targetElement, "wheel", this.onMouseWheel.bind(this)]
+      [targetElement, "wheel", this.onMouseWheel.bind(this)],
+      [targetElement, "contextmenu", this.onContextMenu.bind(this)]
     ]);
     if (this.hasTouchControl) {
       this.eventHandlerCollection.add(targetElement, "touchstart", this.onTouchStart.bind(this), {
@@ -458,21 +468,29 @@ var CameraManager = class {
       }
     }
   }
-  onMouseDown() {
-    this.dragging = true;
+  onMouseDown(event) {
+    if (event.button === 0 || event.button === 2) {
+      this.dragging = true;
+      document.body.style.cursor = "none";
+    }
   }
-  onMouseUp(_event) {
-    this.dragging = false;
+  onMouseUp(event) {
+    if (event.button === 0 || event.button === 2) {
+      this.dragging = false;
+      document.body.style.cursor = "default";
+    }
   }
   onMouseMove(event) {
-    if (!this.dragging || getTweakpaneActive())
+    if (getTweakpaneActive())
       return;
-    if (this.targetTheta === null || this.targetPhi === null)
-      return;
-    this.targetTheta += event.movementX * this.dampingScale;
-    this.targetPhi -= event.movementY * this.dampingScale;
-    this.targetPhi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this.targetPhi));
-    event.preventDefault();
+    if (this.dragging) {
+      if (this.targetTheta === null || this.targetPhi === null)
+        return;
+      this.targetTheta += event.movementX * this.dampingScale;
+      this.targetPhi -= event.movementY * this.dampingScale;
+      this.targetPhi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this.targetPhi));
+      event.preventDefault();
+    }
   }
   onMouseWheel(event) {
     const scrollAmount = event.deltaY * this.zoomScale * 0.1;
@@ -484,6 +502,9 @@ var CameraManager = class {
     this.desiredDistance = this.targetDistance;
     event.preventDefault();
   }
+  onContextMenu(event) {
+    event.preventDefault();
+  }
   setTarget(target) {
     if (!this.isLerping) {
       this.target.copy(target);
@@ -562,7 +583,7 @@ var CameraManager = class {
       this.adjustCameraPosition();
     }
     if (this.phi !== null && this.targetPhi !== null && this.theta !== null && this.targetTheta !== null) {
-      this.distance += (this.targetDistance - this.distance) * this.damping * 0.21;
+      this.distance += (this.targetDistance - this.distance) * this.damping * (0.21 + this.zoomDamping);
       this.phi += (this.targetPhi - this.phi) * this.damping;
       this.theta += (this.targetTheta - this.theta) * this.damping;
       const x = this.target.x + this.distance * Math.sin(this.phi) * Math.cos(this.theta);
@@ -871,6 +892,7 @@ var AnimationState = /* @__PURE__ */ ((AnimationState2) => {
   AnimationState2[AnimationState2["jumpToAir"] = 3] = "jumpToAir";
   AnimationState2[AnimationState2["air"] = 4] = "air";
   AnimationState2[AnimationState2["airToGround"] = 5] = "airToGround";
+  AnimationState2[AnimationState2["doubleJump"] = 6] = "doubleJump";
   return AnimationState2;
 })(AnimationState || {});
 
@@ -884,27 +906,36 @@ var _CharacterModel = class _CharacterModel {
     this.animations = {};
     this.animationMixer = null;
     this.currentAnimation = 0 /* idle */;
+    this.isPostDoubleJump = false;
   }
   async init() {
     await this.loadMainMesh();
-    await Promise.all([
-      this.setAnimationFromFile(
-        this.config.animationConfig.idleAnimationFileUrl,
-        0 /* idle */
-      ),
-      this.setAnimationFromFile(
-        this.config.animationConfig.jogAnimationFileUrl,
-        1 /* walking */
-      ),
-      this.setAnimationFromFile(
-        this.config.animationConfig.sprintAnimationFileUrl,
-        2 /* running */
-      ),
-      this.setAnimationFromFile(
-        this.config.animationConfig.airAnimationFileUrl,
-        4 /* air */
-      )
-    ]);
+    await this.setAnimationFromFile(
+      this.config.animationConfig.idleAnimationFileUrl,
+      0 /* idle */,
+      true
+    );
+    await this.setAnimationFromFile(
+      this.config.animationConfig.jogAnimationFileUrl,
+      1 /* walking */,
+      true
+    );
+    await this.setAnimationFromFile(
+      this.config.animationConfig.sprintAnimationFileUrl,
+      2 /* running */,
+      true
+    );
+    await this.setAnimationFromFile(
+      this.config.animationConfig.airAnimationFileUrl,
+      4 /* air */,
+      true
+    );
+    await this.setAnimationFromFile(
+      this.config.animationConfig.doubleJumpAnimationFileUrl,
+      6 /* doubleJump */,
+      false,
+      1.3
+    );
     this.applyCustomMaterials();
   }
   applyCustomMaterials() {
@@ -941,6 +972,13 @@ var _CharacterModel = class _CharacterModel {
     });
   }
   updateAnimation(targetAnimation) {
+    if (this.isPostDoubleJump) {
+      if (targetAnimation === 6 /* doubleJump */) {
+        targetAnimation = 4 /* air */;
+      } else {
+        this.isPostDoubleJump = false;
+      }
+    }
     if (this.currentAnimation !== targetAnimation) {
       this.transitionToAnimation(targetAnimation);
     }
@@ -1031,16 +1069,21 @@ var _CharacterModel = class _CharacterModel {
     });
     return animationClip;
   }
-  async setAnimationFromFile(animationFileUrl, animationType) {
+  async setAnimationFromFile(animationFileUrl, animationType, loop = true, playbackSpeed = 1) {
     return new Promise(async (resolve, reject) => {
       const animation = await this.config.characterModelLoader.load(animationFileUrl, "animation");
       const cleanAnimation = this.cleanAnimationClips(this.mesh, animation);
       if (typeof animation !== "undefined" && cleanAnimation instanceof AnimationClip) {
         this.animations[animationType] = this.animationMixer.clipAction(cleanAnimation);
         this.animations[animationType].stop();
+        this.animations[animationType].timeScale = playbackSpeed;
         if (animationType === 0 /* idle */) {
           this.animations[animationType].play();
         }
+        if (!loop) {
+          this.animations[animationType].setLoop(LoopRepeat, 1);
+          this.animations[animationType].clampWhenFinished = true;
+        }
         resolve();
       } else {
         reject(`failed to load ${animationType} from ${animationFileUrl}`);
@@ -1048,20 +1091,30 @@ var _CharacterModel = class _CharacterModel {
     });
   }
   transitionToAnimation(targetAnimation, transitionDuration = 0.15) {
-    if (!this.mesh)
+    if (!this.mesh) {
       return;
+    }
     const currentAction = this.animations[this.currentAnimation];
     this.currentAnimation = targetAnimation;
     const targetAction = this.animations[targetAnimation];
-    if (!targetAction)
+    if (!targetAction) {
       return;
+    }
     if (currentAction) {
-      currentAction.enabled = true;
       currentAction.fadeOut(transitionDuration);
     }
-    if (!targetAction.isRunning())
+    targetAction.reset();
+    if (!targetAction.isRunning()) {
       targetAction.play();
-    targetAction.setLoop(LoopRepeat, Infinity);
+    }
+    if (targetAnimation === 6 /* doubleJump */) {
+      targetAction.getMixer().addEventListener("finished", (_event) => {
+        if (this.currentAnimation === 6 /* doubleJump */) {
+          this.isPostDoubleJump = true;
+          this.updateAnimation(6 /* doubleJump */);
+        }
+      });
+    }
     targetAction.enabled = true;
     targetAction.fadeIn(transitionDuration);
   }
@@ -1473,15 +1526,189 @@ import { Euler as Euler2, Group as Group2, Quaternion as Quaternion5, Vector3 as
 
 // src/character/LocalController.ts
 import { Euler, Line3, Matrix4, Quaternion as Quaternion2, Ray, Raycaster as Raycaster2, Vector3 as Vector35 } from "three";
+
+// src/tweakpane/blades/characterControlsFolder.ts
+var characterControllerValues = {
+  gravity: 28,
+  jumpForce: 18,
+  doubleJumpForce: 17.7,
+  coyoteJump: 120,
+  airResistance: 0.5,
+  groundResistance: 0,
+  airControlModifier: 0.05,
+  groundWalkControl: 0.75,
+  groundRunControl: 1,
+  baseControlMultiplier: 200,
+  minimumSurfaceAngle: 0.905
+};
+var characterControllerOptions = {
+  gravity: { min: 1, max: 100, step: 0.05 },
+  jumpForce: { min: 1, max: 50, step: 0.05 },
+  doubleJumpForce: { min: 1, max: 50, step: 0.05 },
+  coyoteJump: { min: 60, max: 200, step: 1 },
+  airResistance: { min: 0.01, max: 0.9, step: 0.01 },
+  groundResistance: { min: -100, max: 0, step: 1 },
+  airControlModifier: { min: 1e-3, max: 0.15, step: 0.01 },
+  groundWalkControl: { min: 0.1, max: 1.5, step: 0.01 },
+  groundRunControl: { min: 0.5, max: 2, step: 0.01 },
+  baseControlMultiplier: { min: 150, max: 300, step: 1 },
+  minimumSurfaceAngle: { min: 0.254, max: 1, step: 1e-3 }
+};
+var CharacterControlsFolder = class {
+  constructor(parentFolder, expand = false) {
+    this.characterData = {
+      position: "(0, 0, 0)",
+      onGround: "false",
+      canJump: "false",
+      canDoubleJump: "false",
+      jumpCount: "0",
+      coyoteTime: "false",
+      coyoteJumped: "false"
+    };
+    this.folder = parentFolder.addFolder({ title: "character", expanded: expand });
+    this.folder.addBinding(this.characterData, "position", { readonly: true });
+    this.folder.addBinding(this.characterData, "onGround", { readonly: true });
+    this.folder.addBinding(this.characterData, "canJump", { readonly: true });
+    this.folder.addBinding(this.characterData, "canDoubleJump", { readonly: true });
+    this.folder.addBinding(this.characterData, "jumpCount", { readonly: true });
+    this.folder.addBinding(this.characterData, "coyoteTime", { readonly: true });
+    this.folder.addBinding(this.characterData, "coyoteJumped", { readonly: true });
+    this.folder.addBinding(
+      characterControllerValues,
+      "gravity",
+      characterControllerOptions.gravity
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "jumpForce",
+      characterControllerOptions.jumpForce
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "doubleJumpForce",
+      characterControllerOptions.doubleJumpForce
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "coyoteJump",
+      characterControllerOptions.coyoteJump
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "airResistance",
+      characterControllerOptions.airResistance
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "groundResistance",
+      characterControllerOptions.groundResistance
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "airControlModifier",
+      characterControllerOptions.airControlModifier
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "groundWalkControl",
+      characterControllerOptions.groundWalkControl
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "groundRunControl",
+      characterControllerOptions.groundRunControl
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "baseControlMultiplier",
+      characterControllerOptions.baseControlMultiplier
+    );
+    this.folder.addBinding(
+      characterControllerValues,
+      "minimumSurfaceAngle",
+      characterControllerOptions.minimumSurfaceAngle
+    );
+  }
+  setupChangeEvent(localController) {
+    this.folder.on("change", (e) => {
+      const target = e.target.key;
+      if (!target)
+        return;
+      switch (target) {
+        case "gravity": {
+          const value = e.value;
+          localController.gravity = value * -1;
+          break;
+        }
+        case "jumpForce": {
+          const value = e.value;
+          localController.jumpForce = value;
+          break;
+        }
+        case "doubleJumpForce": {
+          const value = e.value;
+          localController.doubleJumpForce = value;
+          break;
+        }
+        case "coyoteJump": {
+          const value = e.value;
+          localController.coyoteTimeThreshold = value;
+          break;
+        }
+        case "airResistance": {
+          const value = e.value;
+          localController.airResistance = value;
+          break;
+        }
+        case "groundResistance": {
+          const value = e.value;
+          localController.groundResistance = 0.99999999 + value * 1e-6;
+          break;
+        }
+        case "airControlModifier": {
+          const value = e.value;
+          localController.airControlModifier = value;
+          break;
+        }
+        case "groundWalkControl": {
+          const value = e.value;
+          localController.groundWalkControl = value;
+          break;
+        }
+        case "groundRunControl": {
+          const value = e.value;
+          localController.groundRunControl = value;
+          break;
+        }
+        case "baseControlMultiplier": {
+          const value = e.value;
+          localController.baseControl = value;
+          break;
+        }
+        case "minimumSurfaceAngle": {
+          const value = e.value;
+          localController.minimumSurfaceAngle = value;
+          break;
+        }
+        default:
+          break;
+      }
+    });
+  }
+  update(localController) {
+    const { x, y, z } = localController.latestPosition;
+    this.characterData.position = `(${x.toFixed(2)}, ${y.toFixed(2)}, ${z.toFixed(2)})`;
+    this.characterData.onGround = `${localController.characterOnGround}`;
+    this.characterData.canJump = `${localController.canJump || localController.coyoteTime ? "true" : "false"}`;
+    this.characterData.canDoubleJump = `${localController.canDoubleJump}`;
+    this.characterData.jumpCount = `${localController.jumpCounter}`;
+    this.characterData.coyoteTime = `${localController.coyoteTime}`;
+    this.characterData.coyoteJumped = `${localController.coyoteJumped}`;
+  }
+};
+
+// src/character/LocalController.ts
 var downVector = new Vector35(0, -1, 0);
-var airResistance = 0.5;
-var groundResistance = 0.99999999;
-var airControlModifier = 0.05;
-var groundWalkControl = 0.75;
-var groundRunControl = 1;
-var baseControl = 200;
-var collisionDetectionSteps = 15;
-var minimumSurfaceAngle = 0.9;
 var LocalController = class {
   constructor(config) {
     this.config = config;
@@ -1489,12 +1716,26 @@ var LocalController = class {
       radius: 0.4,
       segment: new Line3(new Vector35(), new Vector35(0, 1.05, 0))
     };
-    this.gravity = -42;
-    this.jumpForce = 20;
-    this.coyoteTimeThreshold = 70;
-    this.coyoteTime = false;
+    this.gravity = -characterControllerValues.gravity;
+    this.jumpForce = characterControllerValues.jumpForce;
+    this.doubleJumpForce = characterControllerValues.doubleJumpForce;
+    this.coyoteTimeThreshold = characterControllerValues.coyoteJump;
     this.canJump = true;
+    this.canDoubleJump = true;
+    this.coyoteJumped = false;
+    this.doubleJumpUsed = false;
+    this.jumpCounter = 0;
+    this.airResistance = characterControllerValues.airResistance;
+    this.groundResistance = 0.99999999 + characterControllerValues.groundResistance * 1e-7;
+    this.airControlModifier = characterControllerValues.airControlModifier;
+    this.groundWalkControl = characterControllerValues.groundWalkControl;
+    this.groundRunControl = characterControllerValues.groundRunControl;
+    this.baseControl = characterControllerValues.baseControlMultiplier;
+    this.minimumSurfaceAngle = characterControllerValues.minimumSurfaceAngle;
+    this.latestPosition = new Vector35();
     this.characterOnGround = false;
+    this.coyoteTime = false;
+    this.collisionDetectionSteps = 15;
     this.characterWasOnGround = false;
     this.characterAirborneSince = 0;
     this.currentHeight = 0;
@@ -1521,6 +1762,9 @@ var LocalController = class {
     this.surfaceTempVector5 = new Vector35();
     this.surfaceTempRay = new Ray();
     this.lastFrameSurfaceState = null;
+    this.jumpPressed = false;
+    // Tracks if the jump button is pressed
+    this.jumpReleased = true;
     this.networkState = {
       id: this.config.id,
       position: { x: 0, y: 0, z: 0 },
@@ -1538,6 +1782,9 @@ var LocalController = class {
     this.jump = this.config.keyInputManager.jump;
     this.anyDirection = this.config.keyInputManager.anyDirection || ((_e = this.config.virtualJoystick) == null ? void 0 : _e.hasDirection) || false;
     this.conflictingDirections = this.config.keyInputManager.conflictingDirection;
+    if (!this.jump) {
+      this.jumpReleased = true;
+    }
   }
   update() {
     this.updateControllerState();
@@ -1556,10 +1803,10 @@ var LocalController = class {
     if (this.anyDirection) {
       this.updateRotation();
     }
-    for (let i = 0; i < collisionDetectionSteps; i++) {
+    for (let i = 0; i < this.collisionDetectionSteps; i++) {
       this.updatePosition(
         this.config.timeManager.deltaTime,
-        this.config.timeManager.deltaTime / collisionDetectionSteps,
+        this.config.timeManager.deltaTime / this.collisionDetectionSteps,
         i
       );
     }
@@ -1573,6 +1820,9 @@ var LocalController = class {
       return 0 /* idle */;
     const jumpHeight = this.characterVelocity.y > 0 ? 0.2 : 1.8;
     if (this.currentHeight > jumpHeight && !this.characterOnGround) {
+      if (this.doubleJumpUsed) {
+        return 6 /* doubleJump */;
+      }
       return 4 /* air */;
     }
     if (this.conflictingDirections) {
@@ -1632,31 +1882,59 @@ var LocalController = class {
     const frameRotation = angularSpeed * this.config.timeManager.deltaTime;
     this.config.character.quaternion.rotateTowards(rotationQuaternion, frameRotation);
   }
-  applyControls(deltaTime) {
-    const resistance = this.characterOnGround ? groundResistance : airResistance;
-    const speedFactor = Math.pow(1 - resistance, deltaTime);
-    this.characterVelocity.multiplyScalar(speedFactor);
-    const acceleration = this.tempVector.set(0, 0, 0);
+  processJump(currentAcceleration, deltaTime) {
     if (this.characterOnGround) {
+      this.coyoteJumped = false;
+      this.canDoubleJump = false;
+      this.doubleJumpUsed = false;
+      this.jumpCounter = 0;
       if (!this.jump) {
+        this.canDoubleJump = !this.doubleJumpUsed && this.jumpReleased && this.jumpCounter === 1;
         this.canJump = true;
+        this.jumpReleased = true;
       }
-      if (this.jump && this.canJump) {
-        acceleration.y += this.jumpForce / deltaTime;
+      if (this.jump && this.canJump && this.jumpReleased) {
+        currentAcceleration.y += this.jumpForce / deltaTime;
         this.canJump = false;
+        this.jumpReleased = false;
+        this.jumpCounter++;
       } else {
-        if (this.currentSurfaceAngle.y < minimumSurfaceAngle) {
-          acceleration.y += this.gravity;
+        if (this.currentSurfaceAngle.y < this.minimumSurfaceAngle) {
+          currentAcceleration.y += this.gravity;
         }
       }
-    } else if (this.jump && this.coyoteTime) {
-      acceleration.y += this.jumpForce / deltaTime;
-      this.canJump = false;
     } else {
-      acceleration.y += this.gravity;
-      this.canJump = false;
+      if (this.jump && !this.coyoteJumped && this.coyoteTime) {
+        this.coyoteJumped = true;
+        currentAcceleration.y += this.jumpForce / deltaTime;
+        this.canJump = false;
+        this.jumpReleased = false;
+        this.jumpCounter++;
+      } else if (this.jump && this.canDoubleJump) {
+        currentAcceleration.y += this.doubleJumpForce / deltaTime;
+        this.doubleJumpUsed = true;
+        this.jumpReleased = false;
+        this.jumpCounter++;
+      } else {
+        currentAcceleration.y += this.gravity;
+        this.canJump = false;
+      }
+    }
+    if (!this.jump) {
+      this.jumpReleased = true;
+      if (!this.characterOnGround) {
+        currentAcceleration.y += this.gravity;
+      }
     }
-    const control = (this.characterOnGround ? this.run ? groundRunControl : groundWalkControl : airControlModifier) * baseControl;
+  }
+  applyControls(deltaTime) {
+    const resistance = this.characterOnGround ? this.groundResistance : this.airResistance;
+    const speedFactor = Math.pow(1 - resistance, deltaTime);
+    this.characterVelocity.multiplyScalar(speedFactor);
+    const acceleration = this.tempVector.set(0, 0, 0);
+    this.canDoubleJump = !this.doubleJumpUsed && this.jumpReleased && this.jumpCounter === 1;
+    this.processJump(acceleration, deltaTime);
+    const control = (this.characterOnGround ? this.run ? this.groundRunControl : this.groundWalkControl : this.airControlModifier) * this.baseControl;
     const controlAcceleration = this.tempVector2.set(0, 0, 0);
     if (!this.conflictingDirections) {
       if (this.forward) {
@@ -1709,10 +1987,18 @@ var LocalController = class {
     this.config.character.position.copy(avatarSegment.start);
     const deltaCollisionPosition = avatarSegment.start.sub(positionBeforeCollisions);
     this.characterOnGround = deltaCollisionPosition.y > 0;
+    if (this.characterOnGround) {
+      this.doubleJumpUsed = false;
+      this.jumpCounter = 0;
+    }
     if (this.characterWasOnGround && !this.characterOnGround) {
       this.characterAirborneSince = Date.now();
     }
+    if (!this.jump) {
+      this.jumpReleased = true;
+    }
     this.coyoteTime = this.characterVelocity.y < 0 && !this.characterOnGround && Date.now() - this.characterAirborneSince < this.coyoteTimeThreshold;
+    this.latestPosition = this.config.character.position.clone();
     this.characterWasOnGround = this.characterOnGround;
   }
   getMovementFromSurfaces(userPosition, deltaTime) {
@@ -1797,6 +2083,9 @@ var LocalController = class {
     this.characterVelocity.y = 0;
     this.config.character.position.y = 3;
     this.characterOnGround = false;
+    this.doubleJumpUsed = false;
+    this.jumpReleased = true;
+    this.jumpCounter = 0;
   }
 };
 
@@ -1917,6 +2206,9 @@ var CharacterManager = class {
     this.group.add(character);
     this.localCharacterSpawned = true;
   }
+  setupTweakPane(tweakPane) {
+    tweakPane.setupCharacterController(this.localController);
+  }
   spawnRemoteCharacter(id, username, characterDescription, spawnPosition = new Vector38(), spawnRotation = new Euler2()) {
     const character = new Character({
       username,
@@ -3109,6 +3401,7 @@ var TweakPane = class {
     this.character = new CharacterFolder(this.gui, false);
     this.environment = new EnvironmentFolder(this.gui, false);
     this.camera = new CameraFolder(this.gui, false);
+    this.characterControls = new CharacterControlsFolder(this.gui, false);
     this.toneMappingFolder.folder.hidden = rendererValues.toneMapping === 5 ? false : true;
     this.export = this.gui.addFolder({ title: "import / export", expanded: false });
     window.addEventListener("keydown", this.processKey.bind(this));
@@ -3162,12 +3455,18 @@ var TweakPane = class {
   setupCamPane(cameraManager) {
     this.camera.setupChangeEvent(cameraManager);
   }
+  setupCharacterController(localController) {
+    this.characterControls.setupChangeEvent(localController);
+  }
   updateStats(timeManager) {
     this.renderStatsFolder.update(this.renderer, this.composer, timeManager);
   }
   updateCameraData(cameraManager) {
     this.camera.update(cameraManager);
   }
+  updateCharacterData(localController) {
+    this.characterControls.update(localController);
+  }
   formatDateForFilename() {
     const date = /* @__PURE__ */ new Date();
     const year = date.getFullYear();