three-player-controller 0.3.2 → 0.3.4

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/playerController.ts
-import * as THREE from "three";
+import * as THREE3 from "three";
 import { acceleratedRaycast, MeshBVH, MeshBVHHelper } from "three-mesh-bvh";
 import { RoundedBoxGeometry } from "three/examples/jsm/geometries/RoundedBoxGeometry.js";
 import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
@@ -15,18 +15,287 @@ var jump_default = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAA
 // assets/imgs/view.png
 var view_default = "data:image/png;base64,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";
 
+// src/utils/pathPlanner.ts
+import * as THREE from "three";
+var PathNode = class {
+  constructor(position) {
+    this.g = Infinity;
+    // 实际代价
+    this.h = 0;
+    // 估计代价
+    this.f = Infinity;
+    // f = g + h
+    this.parent = null;
+    this.position = position.clone();
+  }
+  equals(other) {
+    return this.position.distanceTo(other.position) < 0.01;
+  }
+};
+var PriorityQueue = class {
+  constructor() {
+    this.elements = [];
+  }
+  enqueue(item, priority) {
+    this.elements.push({ priority, item });
+    this.elements.sort((a, b) => a.priority - b.priority);
+  }
+  dequeue() {
+    return this.elements.shift()?.item;
+  }
+  isEmpty() {
+    return this.elements.length === 0;
+  }
+  contains(item, compareFn) {
+    return this.elements.some((e) => compareFn(e.item, item));
+  }
+  update(item, newPriority, compareFn) {
+    const index = this.elements.findIndex((e) => compareFn(e.item, item));
+    if (index !== -1) {
+      this.elements[index].priority = newPriority;
+      this.elements.sort((a, b) => a.priority - b.priority);
+    }
+  }
+};
+var PathPlanner = class {
+  constructor(obstacleChecker, config = {}) {
+    this.debugLines = [];
+    this.debugPoints = [];
+    this.obstacleChecker = obstacleChecker;
+    this.config = {
+      debugEnabled: false,
+      scale: 1,
+      ...config
+    };
+  }
+  // 计算启发式距离
+  heuristic(a, b) {
+    return a.distanceTo(b);
+  }
+  // A*路径规划算法
+  findPath(start, goal) {
+    const startTime = performance.now();
+    if (!this.obstacleChecker.isBlocked(start, goal)) {
+      return [goal];
+    }
+    const navigationPoints = this.obstacleChecker.getNavigationNodes(start, goal);
+    const allNodes = [new PathNode(start), new PathNode(goal), ...navigationPoints.map((p) => new PathNode(p))];
+    if (allNodes.length < 2) {
+      console.warn("\u5BFC\u822A\u8282\u70B9\u4E0D\u8DB3\uFF0C\u8FD4\u56DE\u76F4\u7EBF\u8DEF\u5F84");
+      return [goal];
+    }
+    const startNode = allNodes[0];
+    const goalNode = allNodes[1];
+    startNode.g = 0;
+    startNode.h = this.heuristic(startNode.position, goalNode.position);
+    startNode.f = startNode.h;
+    const openList = new PriorityQueue();
+    const closedSet = /* @__PURE__ */ new Set();
+    openList.enqueue(startNode, startNode.f);
+    const nodeEquals = (a, b) => a.equals(b);
+    while (!openList.isEmpty()) {
+      const current = openList.dequeue();
+      if (!current) break;
+      if (current.equals(goalNode)) {
+        const path = this.reconstructPath(current);
+        const endTime = performance.now();
+        if (this.config.debugEnabled) {
+          this.visualizePath([start, ...path]);
+        }
+        return path;
+      }
+      closedSet.add(current);
+      for (const neighbor of allNodes) {
+        if (closedSet.has(neighbor)) continue;
+        if (this.obstacleChecker.isBlocked(current.position, neighbor.position)) {
+          continue;
+        }
+        const tentativeG = current.g + current.position.distanceTo(neighbor.position);
+        if (tentativeG < neighbor.g) {
+          neighbor.parent = current;
+          neighbor.g = tentativeG;
+          neighbor.h = this.heuristic(neighbor.position, goalNode.position);
+          neighbor.f = neighbor.g + neighbor.h;
+          if (openList.contains(neighbor, nodeEquals)) {
+            openList.update(neighbor, neighbor.f, nodeEquals);
+          } else {
+            openList.enqueue(neighbor, neighbor.f);
+          }
+        }
+      }
+    }
+    console.warn("A*\u672A\u627E\u5230\u8DEF\u5F84\uFF0C\u4F7F\u7528\u76F4\u7EBF\u8DEF\u5F84");
+    return [goal];
+  }
+  /**
+   * 重建路径
+   */
+  reconstructPath(endNode) {
+    const path = [];
+    let current = endNode;
+    while (current !== null) {
+      path.unshift(current.position.clone());
+      current = current.parent;
+    }
+    if (path.length > 0) {
+      path.shift();
+    }
+    return this.smoothPath(path);
+  }
+  /**
+   * 路径平滑
+   */
+  smoothPath(path) {
+    if (path.length <= 2) return path;
+    const smoothed = [path[0]];
+    let current = 0;
+    while (current < path.length - 1) {
+      let farthest = current + 1;
+      for (let i = path.length - 1; i > current + 1; i--) {
+        if (!this.obstacleChecker.isBlocked(path[current], path[i])) {
+          farthest = i;
+          break;
+        }
+      }
+      smoothed.push(path[farthest]);
+      current = farthest;
+    }
+    return smoothed;
+  }
+  /**
+   * 可视化路径
+   */
+  visualizePath(path) {
+    if (!this.config.scene || !this.config.debugEnabled) return;
+    this.clearVisualization();
+    const scale = this.config.scale || 1;
+    if (path.length > 1) {
+      const points = path.map((p) => p.clone());
+      const geometry = new THREE.BufferGeometry().setFromPoints(points);
+      const material = new THREE.LineBasicMaterial({
+        color: 65280,
+        linewidth: 3
+      });
+      const line = new THREE.Line(geometry, material);
+      this.config.scene.add(line);
+      this.debugLines.push(line);
+    }
+    path.forEach((point, index) => {
+      const geometry = new THREE.SphereGeometry(20 * scale);
+      const material = new THREE.MeshBasicMaterial({
+        color: index === path.length - 1 ? 16711680 : 65280
+      });
+      const sphere = new THREE.Mesh(geometry, material);
+      sphere.position.copy(point);
+      this.config.scene.add(sphere);
+      this.debugPoints.push(sphere);
+    });
+  }
+  /**
+   * 清除路径可视化
+   */
+  clearVisualization() {
+    if (!this.config.scene) return;
+    this.debugLines.forEach((line) => {
+      this.config.scene.remove(line);
+      line.geometry.dispose();
+      line.material.dispose();
+    });
+    this.debugLines = [];
+    this.debugPoints.forEach((point) => {
+      this.config.scene.remove(point);
+      point.geometry.dispose();
+      point.material.dispose();
+    });
+    this.debugPoints = [];
+  }
+  /**
+   * 更新配置
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * 销毁
+   */
+  dispose() {
+    this.clearVisualization();
+  }
+};
+
+// src/utils/useVehicleController.ts
+import * as THREE2 from "three";
+function createVehicleController(world, chassisBody, wheels, wheelsInfo) {
+  if (!world || !chassisBody) return { vehicle: null, updateWheelVisuals: () => {
+  } };
+  const vehicle = world.createVehicleController(chassisBody);
+  const suspensionDirection = new THREE2.Vector3(0, -1, 0);
+  wheelsInfo.forEach((wheel, index) => {
+    vehicle.addWheel(wheel.position, suspensionDirection, wheel.axleCs, wheel.suspensionRestLength, wheel.radius);
+    vehicle.setWheelChassisConnectionPointCs(index, wheel.position);
+    vehicle.setWheelDirectionCs(index, suspensionDirection);
+    vehicle.setWheelAxleCs(index, wheel.axleCs);
+    vehicle.setWheelSuspensionRestLength(index, wheel.suspensionRestLength);
+    vehicle.setWheelRadius(index, wheel.radius);
+    vehicle.setWheelMaxSuspensionTravel(index, wheel.suspensionRestLength * 1);
+    vehicle.setWheelSuspensionStiffness(index, 250);
+    vehicle.setWheelSuspensionCompression(index, 6);
+    vehicle.setWheelSuspensionRelaxation(index, 6);
+    vehicle.setWheelMaxSuspensionForce(index, 1e4);
+    vehicle.setWheelBrake(index, 0);
+    vehicle.setWheelSteering(index, 0);
+    vehicle.setWheelEngineForce(index, 0);
+    vehicle.setWheelFrictionSlip(index, 20);
+    vehicle.setWheelSideFrictionStiffness(index, 2);
+  });
+  const up = new THREE2.Vector3(0, 1, 0);
+  const _wheelSteeringQuat = new THREE2.Quaternion();
+  const _wheelRotationQuat = new THREE2.Quaternion();
+  function updateWheelVisuals() {
+    for (const [index, wheelObj] of wheels.entries()) {
+      if (!wheelObj) continue;
+      try {
+        const wheelAxleCs = vehicle.wheelAxleCs(index) ?? new THREE2.Vector3(1, 0, 0);
+        const connection = vehicle.wheelChassisConnectionPointCs(index)?.y ?? 0;
+        const suspension = vehicle.wheelSuspensionLength(index) ?? 0;
+        const steering = vehicle.wheelSteering(index) ?? 0;
+        const rotationRad = vehicle.wheelRotation(index) ?? 0;
+        wheelObj.position.y = connection - suspension;
+        _wheelSteeringQuat.setFromAxisAngle(up, steering);
+        _wheelRotationQuat.setFromAxisAngle(wheelAxleCs, rotationRad);
+        wheelObj.quaternion.copy(_wheelSteeringQuat).multiply(_wheelRotationQuat);
+      } catch (e) {
+      }
+    }
+  }
+  function destroy() {
+    try {
+      world.removeVehicleController(vehicle);
+    } catch {
+    }
+  }
+  return {
+    vehicle,
+    updateWheelVisuals,
+    destroy
+  };
+}
+
 // src/playerController.ts
-THREE.Mesh.prototype.raycast = acceleratedRaycast;
+THREE3.Mesh.prototype.raycast = acceleratedRaycast;
 var controllerInstance = null;
-var clock = new THREE.Clock();
+var clock = new THREE3.Clock();
 var PlayerController = class {
   constructor() {
     // ==================== 基本配置与参数 ====================
     this.loader = new GLTFLoader();
-    // 0: 普通 1: 飞行 2: 车辆
+    this.controllerMode = 0;
+    // 0: 人物 1: 车辆
+    this.isChangeControllerTransitionTimer = null;
     // ==================== 玩家基本属性 ====================
     this.playerRadius = 45;
     this.playerHeight = 180;
+    // 玩家参考身高
     this.isFirstPerson = false;
     this.boundingBoxMinY = 0;
     // ==================== 测试参数 ====================
@@ -37,7 +306,59 @@ var PlayerController = class {
     this.collider = null;
     this.visualizer = null;
     this.person = null;
-    this.vehicle = null;
+    this.personHead = null;
+    this.collected = [];
+    this.dynamicCollider = null;
+    this.dynamicCollected = [];
+    // ==================== 多车辆相关 ====================
+    this.vehicles = [];
+    // 所有已加载车辆
+    this.activeVehicle = null;
+    // 当前驾驶/交互的车辆
+    this.vehicleLength = 6;
+    // 车辆参考长度
+    this.wheelSteeringQuat = new THREE3.Quaternion();
+    this.wheelRotationQuat = new THREE3.Quaternion();
+    this.RAPIER = null;
+    this.world = null;
+    // 全局车辆共享参数
+    this.vehicleParams = {
+      debug: {
+        showPhysicsBox: false
+      },
+      chassis: {
+        linearDamping: 0.5,
+        angularDamping: 0.5
+      },
+      model: {
+        rotation: -Math.PI / 2
+      },
+      power: {
+        accelerateForce: 50,
+        // 推进
+        brakeForce: 200,
+        // 刹车
+        maxSpeed: 1e4
+        // 最大速度
+      },
+      steering: {
+        maxSteerAngle: Math.PI / 4,
+        steerSpeed: 0.5,
+        steerReturnSpeed: 1
+      }
+    };
+    this.camBehindDir = new THREE3.Vector3(0, 0, 1);
+    // ==================== 上车相关 ====================
+    this.isMovingToBoardingPoint = false;
+    this.boardingWaypoints = [];
+    this.currentWaypointIndex = 0;
+    this.boardingTargetDir = null;
+    this.boardingMoveSpeed = 300;
+    this.boardingRotateSpeed = 10;
+    this.flip180Quat = new THREE3.Quaternion().setFromAxisAngle(new THREE3.Vector3(0, 1, 0), Math.PI);
+    this.enterVehicleTimer = null;
+    this.closeVehicleDoorTimer = null;
+    this.boardingPointWorld = null;
     // ==================== 状态开关 ====================
     this.playerIsOnGround = false;
     this.isupdate = true;
@@ -65,46 +386,63 @@ var PlayerController = class {
     this.lastTouchY = 0;
     // ==================== 第三人称相机参数 ====================
     this._camCollisionLerp = 0.18;
-    // 平滑系数
     this._camEpsilon = 0.35;
-    // 摄像机与障碍物之间的安全距离
     this._minCamDistance = 1;
-    // 摄像机最小距离
     this._maxCamDistance = 4.4;
-    // 摄像机最大距离
     this.orginMaxCamDistance = 4.4;
     // ==================== 物理/运动 ====================
-    this.playerVelocity = new THREE.Vector3();
-    // 玩家速度向量
-    this.upVector = new THREE.Vector3(0, 1, 0);
+    this.playerVelocity = new THREE3.Vector3();
+    this.upVector = new THREE3.Vector3(0, 1, 0);
     // ==================== 临时复用向量/矩阵 ====================
-    this.tempVector = new THREE.Vector3();
-    this.tempVector2 = new THREE.Vector3();
-    this.tempBox = new THREE.Box3();
-    this.tempMat = new THREE.Matrix4();
-    this.tempSegment = new THREE.Line3();
+    this.tempVector = new THREE3.Vector3();
+    this.tempVector2 = new THREE3.Vector3();
+    this.tempBox = new THREE3.Box3();
+    this.tempMat = new THREE3.Matrix4();
+    this.tempSegment = new THREE3.Line3();
     this.recheckAnimTimer = null;
     // ==================== 相机朝向/移动复用向量 ====================
-    this.camDir = new THREE.Vector3();
-    this.moveDir = new THREE.Vector3();
-    this.targetQuat = new THREE.Quaternion();
-    this.targetMat = new THREE.Matrix4();
+    this.camDir = new THREE3.Vector3();
+    this.moveDir = new THREE3.Vector3();
+    this.targetQuat = new THREE3.Quaternion();
+    this.targetMat = new THREE3.Matrix4();
     this.rotationSpeed = 10;
-    this.DIR_FWD = new THREE.Vector3(0, 0, -1);
-    this.DIR_BKD = new THREE.Vector3(0, 0, 1);
-    this.DIR_LFT = new THREE.Vector3(-1, 0, 0);
-    this.DIR_RGT = new THREE.Vector3(1, 0, 0);
-    this.DIR_UP = new THREE.Vector3(0, 1, 0);
+    this.DIR_FWD = new THREE3.Vector3(0, 0, -1);
+    this.DIR_BKD = new THREE3.Vector3(0, 0, 1);
+    this.DIR_LFT = new THREE3.Vector3(-1, 0, 0);
+    this.DIR_RGT = new THREE3.Vector3(1, 0, 0);
+    this.DIR_UP = new THREE3.Vector3(0, 1, 0);
     // ==================== 射线检测 ====================
-    this._personToCam = new THREE.Vector3();
-    this._originTmp = new THREE.Vector3();
-    this._raycaster = new THREE.Raycaster(new THREE.Vector3(), new THREE.Vector3(0, -1, 0));
-    this._raycasterPersonToCam = new THREE.Raycaster(new THREE.Vector3(), new THREE.Vector3());
-    /**
-     * 根据按键设置人物动画
-     */
+    this._personToCam = new THREE3.Vector3();
+    this._originTmp = new THREE3.Vector3();
+    this._raycaster = new THREE3.Raycaster(new THREE3.Vector3(), new THREE3.Vector3(0, -1, 0));
+    this._raycasterPersonToCam = new THREE3.Raycaster(new THREE3.Vector3(), new THREE3.Vector3());
+    // ==================== 物理与碰撞检测 ====================
+    this.ensureAttributesMinimal = (geom) => {
+      if (!geom.attributes.position) return null;
+      if (!geom.attributes.normal) geom.computeVertexNormals();
+      if (!geom.attributes.uv) {
+        const count = geom.attributes.position.count;
+        const dummyUV = new Float32Array(count * 2);
+        geom.setAttribute("uv", new THREE3.BufferAttribute(dummyUV, 2));
+      }
+      return geom;
+    };
     this.setAnimationByPressed = () => {
       this._maxCamDistance = this.orginMaxCamDistance;
+      if (this.isMovingToBoardingPoint) {
+        this.isMovingToBoardingPoint = false;
+        this.boardingWaypoints = [];
+        this.currentWaypointIndex = 0;
+        this.boardingTargetDir = null;
+      }
+      if (this.enterVehicleTimer) {
+        clearTimeout(this.enterVehicleTimer);
+        this.enterVehicleTimer = null;
+      }
+      if (this.closeVehicleDoorTimer) {
+        clearTimeout(this.closeVehicleDoorTimer);
+        this.closeVehicleDoorTimer = null;
+      }
       if (this.isFlying) {
         if (!this.fwdPressed) {
           this.playPersonAnimationByName("flyidle");
@@ -149,31 +487,33 @@ var PlayerController = class {
       }, 200);
     };
     // ==================== 事件处理 ====================
-    /**
-     * 键盘按下事件
-     */
     this._boundOnKeydown = async (e) => {
       if (e.ctrlKey && ["KeyW", "KeyA", "KeyS", "KeyD"].includes(e.code)) {
         e.preventDefault();
       }
       switch (e.code) {
         case "KeyW":
+        case "ArrowUp":
           this.fwdPressed = true;
           this.setAnimationByPressed();
           break;
         case "KeyS":
+        case "ArrowDown":
           this.bkdPressed = true;
           this.setAnimationByPressed();
           break;
         case "KeyD":
+        case "ArrowRight":
           this.rgtPressed = true;
           this.setAnimationByPressed();
           break;
         case "KeyA":
+        case "ArrowLeft":
           this.lftPressed = true;
           this.setAnimationByPressed();
           break;
         case "ShiftLeft":
+        case "ShiftRight":
           this.shiftPressed = true;
           this.setAnimationByPressed();
           this.controls.mouseButtons = { LEFT: 2, MIDDLE: 1, RIGHT: 0 };
@@ -194,6 +534,7 @@ var PlayerController = class {
           this.changeView();
           break;
         case "KeyF":
+          if (this.controllerMode == 1) return;
           this.isFlying = !this.isFlying;
           this.setAnimationByPressed();
           if (!this.isFlying && !this.playerIsOnGround) {
@@ -201,32 +542,39 @@ var PlayerController = class {
           }
           break;
         case "KeyE":
-          this.setDrive();
+          if (this.isFlying) return;
+          if (this.controllerMode == 0) {
+            this.enterVehicle();
+          } else {
+            this.exitVehicle();
+          }
           break;
       }
     };
-    /**
-     * 键盘抬起事件
-     */
     this._boundOnKeyup = (e) => {
       switch (e.code) {
         case "KeyW":
+        case "ArrowUp":
           this.fwdPressed = false;
           this.setAnimationByPressed();
           break;
         case "KeyS":
+        case "ArrowDown":
           this.bkdPressed = false;
           this.setAnimationByPressed();
           break;
         case "KeyD":
+        case "ArrowRight":
           this.rgtPressed = false;
           this.setAnimationByPressed();
           break;
         case "KeyA":
+        case "ArrowLeft":
           this.lftPressed = false;
           this.setAnimationByPressed();
           break;
         case "ShiftLeft":
+        case "ShiftRight":
           this.shiftPressed = false;
           this.setAnimationByPressed();
           this.controls.mouseButtons = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };
@@ -239,23 +587,14 @@ var PlayerController = class {
           break;
       }
     };
-    /**
-     * 鼠标移动事件
-     */
     this._mouseMove = (e) => {
       if (document.pointerLockElement !== document.body) return;
       this.setToward(e.movementX, e.movementY, 1e-4);
     };
-    /**
-     * 鼠标点击事件
-     */
-    this._mouseClick = (e) => {
+    this._mouseClick = (_e) => {
       this.setPointerLock();
     };
     // ==================== 移动端控制 ====================
-    /**
-     * 指针按下事件
-     */
     this.onPointerDown = (e) => {
       if (e.pointerType !== "touch") return;
       this.isLookDown = true;
@@ -265,9 +604,6 @@ var PlayerController = class {
       this.lookAreaEl?.setPointerCapture?.(e.pointerId);
       e.preventDefault();
     };
-    /**
-     * 指针移动事件
-     */
     this.onPointerMove = (e) => {
       if (!this.isLookDown || e.pointerId !== this.lookPointerId) return;
       const dx = e.clientX - this.lastTouchX;
@@ -277,9 +613,6 @@ var PlayerController = class {
       this.setInput({ lookDeltaX: dx, lookDeltaY: dy });
       e.preventDefault();
     };
-    /**
-     * 指针抬起事件
-     */
     this.onPointerUp = (e) => {
       if (e.pointerId !== this.lookPointerId) return;
       this.isLookDown = false;
@@ -290,19 +623,15 @@ var PlayerController = class {
     this._raycasterPersonToCam.firstHitOnly = true;
   }
   // ==================== 初始化相关方法 ====================
-  /**
-   * 初始化控制器
-   */
   async init(opts, callback) {
     this.scene = opts.scene;
     this.camera = opts.camera;
     this.camera.rotation.order = "YXZ";
     this.controls = opts.controls;
     this.playerModel = opts.playerModel;
-    this.initPos = opts.initPos ?? new THREE.Vector3(0, 0, 0);
+    this.initPos = opts.initPos ?? new THREE3.Vector3(0, 0, 0);
     this.mouseSensity = opts.mouseSensity ?? 5;
     const s = this.playerModel.scale;
-    this.visualizeDepth = 0 * s;
     this.gravity = (opts.playerModel.gravity ?? -2400) * s;
     this.jumpHeight = (opts.playerModel.jumpHeight ?? 800) * s;
     this.originPlayerSpeed = (opts.playerModel.speed ?? 400) * s;
@@ -314,52 +643,104 @@ var PlayerController = class {
     this._maxCamDistance = (opts.maxCamDistance ?? 440) * s;
     this.orginMaxCamDistance = this._maxCamDistance;
     this.thirdMouseMode = opts.thirdMouseMode ?? 1;
+    this.enableZoom = opts.enableZoom ?? false;
     const isMobileDevice = () => navigator.maxTouchPoints && navigator.maxTouchPoints > 0 || "ontouchstart" in window || /Mobi|Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
     this.isShowMobileControls = (opts.isShowMobileControls ?? true) && isMobileDevice();
     if (this.isShowMobileControls) {
       await this.initMobileControls();
     }
     await this.createBVH(opts.colliderMeshUrl);
-    this.createPlayer();
     await this.loadPersonGLB();
-    if (this.isFirstPerson && this.person) {
-      this.person.add(this.camera);
-    }
     this.onAllEvent();
     this.setCameraPos();
     this.setControls();
     if (callback) callback();
   }
-  /**
-   * 初始化加载器
-   */
   async initLoader() {
     const dracoLoader = new DRACOLoader();
     dracoLoader.setDecoderPath("https://unpkg.com/three@0.180.0/examples/jsm/libs/draco/gltf/");
     dracoLoader.setDecoderConfig({ type: "js" });
     this.loader.setDRACOLoader(dracoLoader);
   }
+  async initRapier() {
+    if (this.RAPIER) return;
+    this.RAPIER = await import("./rapier.es-XQHNYU2P.mjs");
+    await this.RAPIER.init();
+    const gravity = new this.RAPIER.Vector3(0, -9.81, 0);
+    this.world = new this.RAPIER.World(gravity);
+    this.world.maxCcdSubsteps = 2;
+    const addGeometryAsTrimesh = (RAPIER, world, geom) => {
+      let geometry = geom.index ? geom.clone().toNonIndexed() : geom.clone();
+      const posAttr = geometry.attributes.position;
+      const vertexCount = posAttr.count;
+      if (vertexCount % 3 !== 0) {
+        console.warn("\u9876\u70B9\u6570\u4E0D\u662F3\u7684\u500D\u6570\uFF0C\u4E09\u89D2\u5F62\u53EF\u80FD\u4E0D\u5B8C\u6574");
+      }
+      const vertices = new Float32Array(vertexCount * 3);
+      const tmp = new THREE3.Vector3();
+      for (let i = 0; i < vertexCount; i++) {
+        tmp.fromBufferAttribute(posAttr, i);
+        vertices[i * 3 + 0] = tmp.x;
+        vertices[i * 3 + 1] = tmp.y;
+        vertices[i * 3 + 2] = tmp.z;
+      }
+      const indices = vertexCount > 65535 ? new Uint32Array(vertexCount) : new Uint16Array(vertexCount);
+      for (let i = 0; i < vertexCount; i++) indices[i] = i;
+      const bodyDesc = RAPIER.RigidBodyDesc.fixed();
+      const body = world.createRigidBody(bodyDesc);
+      const colliderDesc = RAPIER.ColliderDesc.trimesh(vertices, indices).setRestitution(0).setFriction(0.8);
+      world.createCollider(colliderDesc, body);
+    };
+    for (const g of this.collected) {
+      addGeometryAsTrimesh(this.RAPIER, this.world, g);
+    }
+    const groundDesc = this.RAPIER.RigidBodyDesc.fixed();
+    const groundBody = this.world.createRigidBody(groundDesc);
+    groundBody.userData = { outOfBounds: true };
+  }
   // ==================== 玩家模型相关方法 ====================
-  /**
-   * 加载玩家模型与动画
-   */
   async loadPersonGLB() {
     try {
       const gltf = await this.loader.loadAsync(this.playerModel.url);
       this.person = gltf.scene;
-      const sc = this.playerModel.scale;
-      const h = this.playerHeight * sc;
-      this.person.scale.set(sc, sc, sc);
+      const { size } = this.getBbox(this.person);
+      const ratio = this.playerHeight / size.y;
+      const power = Math.round(Math.log10(ratio));
+      const modelScale = Math.pow(10, power);
+      this.playerRadius = Number(Math.min(size.x, size.z).toFixed(0)) * modelScale;
+      this.playerHeight = Number(size.y.toFixed(0)) * modelScale;
+      const scale = this.playerModel.scale;
+      const material = new THREE3.MeshStandardMaterial({
+        color: new THREE3.Color(1, 0, 0),
+        shadowSide: THREE3.DoubleSide,
+        depthTest: false,
+        transparent: true,
+        opacity: this.displayPlayer ? 0.5 : 0,
+        wireframe: true,
+        depthWrite: false
+      });
+      const r = this.playerRadius * scale;
+      const h = this.playerHeight * scale;
+      this.player = new THREE3.Mesh(new RoundedBoxGeometry(r * 2, h, r * 2, 1, 75), material);
+      this.player.geometry.translate(0, -h * 0.25, 0);
+      this.player.capsuleInfo = {
+        radius: r,
+        segment: new THREE3.Line3(new THREE3.Vector3(), new THREE3.Vector3(0, -h * 0.5, 0))
+      };
+      this.player.name = "capsule";
+      this.scene.add(this.player);
+      this.reset();
+      this.player.rotateY(this.playerModel.rotateY ?? 0);
+      this.person.scale.multiplyScalar(modelScale * scale);
       this.person.position.set(0, -h * 0.75, 0);
       this.person.traverse((child) => {
-        if (child.isMesh) {
-          child.castShadow = true;
-          child.receiveShadow = true;
+        if (child.name == this.playerModel?.headObjName) {
+          this.personHead = child;
         }
       });
       this.player.add(this.person);
       this.reset();
-      this.personMixer = new THREE.AnimationMixer(this.person);
+      this.personMixer = new THREE3.AnimationMixer(this.person);
       const animations = gltf.animations ?? [];
       this.personActions = /* @__PURE__ */ new Map();
       const animationMappings = [
@@ -371,7 +752,9 @@ var PlayerController = class {
         [this.playerModel.jumpAnim, "jumping"],
         [this.playerModel.runAnim, "running"],
         [this.playerModel.flyIdleAnim || this.playerModel.idleAnim, "flyidle"],
-        [this.playerModel.flyAnim || this.playerModel.idleAnim, "flying"]
+        [this.playerModel.flyAnim || this.playerModel.idleAnim, "flying"],
+        [this.playerModel.enterCarAnim || this.playerModel.idleAnim, "enterCar"],
+        [this.playerModel.exitCarAnim || this.playerModel.idleAnim, "exitCar"]
       ];
       const findClip = (name) => animations.find((a) => a.name === name);
       for (const [clipName, actionName] of animationMappings) {
@@ -379,11 +762,11 @@ var PlayerController = class {
         if (!clip) continue;
         const action = this.personMixer.clipAction(clip);
         if (actionName === "jumping") {
-          action.setLoop(THREE.LoopOnce, 1);
+          action.setLoop(THREE3.LoopOnce, 1);
           action.clampWhenFinished = true;
           action.setEffectiveTimeScale(1.2);
         } else {
-          action.setLoop(THREE.LoopRepeat, Infinity);
+          action.setLoop(THREE3.LoopRepeat, Infinity);
           action.clampWhenFinished = false;
           action.setEffectiveTimeScale(1);
         }
@@ -425,16 +808,20 @@ var PlayerController = class {
       console.error("\u52A0\u8F7D\u73A9\u5BB6\u6A21\u578B\u5931\u8D25:", error);
     }
   }
-  /**
-   * 平滑切换人物动画
-   */
   playPersonAnimationByName(name, fade = 0.18) {
     if (!this.personActions || this.ctPressed) return;
     const next = this.personActions.get(name);
     if (!next || this.actionState === next) return;
+    const duration = next.getClip().duration;
     const prev = this.actionState;
     next.reset();
     next.setEffectiveWeight(1);
+    if (name == "enterCar" || name == "exitCar") {
+      const enterTime = this.activeVehicle?.enterVehicleTime ?? 1.5;
+      next.setEffectiveTimeScale(duration / enterTime);
+      next.setLoop(THREE3.LoopOnce, 1);
+      next.clampWhenFinished = true;
+    }
     next.play();
     if (prev && prev !== next) {
       prev.fadeOut(fade);
@@ -444,135 +831,467 @@ var PlayerController = class {
     }
     this.actionState = next;
   }
-  /**
-   * 创建玩家胶囊体
-   */
-  createPlayer() {
-    const material = new THREE.MeshStandardMaterial({
-      color: new THREE.Color(1, 0, 0),
-      shadowSide: THREE.DoubleSide,
-      depthTest: false,
-      transparent: true,
-      opacity: this.displayPlayer ? 0.5 : 0,
-      wireframe: true,
-      depthWrite: false
-    });
-    const r = this.playerRadius * this.playerModel.scale;
-    const h = this.playerHeight * this.playerModel.scale;
-    this.player = new THREE.Mesh(new RoundedBoxGeometry(r * 2, h, r * 2, 1, 75), material);
-    this.player.geometry.translate(0, -h * 0.25, 0);
-    this.player.capsuleInfo = {
-      radius: r,
-      segment: new THREE.Line3(new THREE.Vector3(), new THREE.Vector3(0, -h * 0.5, 0))
-    };
-    this.player.name = "capsule";
-    this.scene.add(this.player);
-    this.reset();
-    this.player.rotateY(this.playerModel.rotateY ?? 0);
-  }
   // ==================== 车辆模型相关 ====================
   /**
-   * 加载车辆模型与动画
+   * 加载车辆模型
    */
-  async loadVehicleModel(params) {
+  async loadVehicleModel(opts) {
     try {
-      const { url, position, scale = 1 } = params;
-      const gltf = await this.loader.loadAsync(url);
-      this.vehicle = gltf.scene;
-      this.vehicle.scale.set(scale, scale, scale);
-      this.vehicle.position.copy(position);
-      this.vehicle.traverse((child) => {
-        if (child.isMesh) {
-          child.castShadow = true;
-          child.receiveShadow = true;
-        }
-      });
-      this.scene.add(this.vehicle);
-      const animations = gltf.animations ?? [];
-      this.vehicleActions = /* @__PURE__ */ new Map();
-      this.vehicleMixer = new THREE.AnimationMixer(this.vehicle);
-      const animationMappings = [
-        [params.animations?.openDoorAnim ?? "", "open_door"],
-        [params.animations?.wheelsTurnAnim ?? "", "wheels_turn"],
-        [params.animations?.turnLeftAnim ?? "", "turn_left"],
-        [params.animations?.turnRightAnim ?? "", "turn_right"]
-      ];
+      if (!this.playerModel.enterCarAnim) {
+        return console.warn("\u672A\u914D\u7F6E\u4E0A\u8F66\u52A8\u753B\uFF0C\u4E0D\u6267\u884C\u8F66\u8F86\u76F8\u5173\u903B\u8F91");
+      }
+      await this.initRapier();
+      if (!this.world) return;
+      const scale = opts.scale ?? 1;
+      const chassisRatio = opts.chassisRatio ?? 0.2;
+      const suspensionRestLengthRatio = opts.suspensionRestLengthRatio ?? 0.2;
+      this.vehicleParams.power.accelerateForce = 50 * scale;
+      this.vehicleParams.power.brakeForce = 200 * scale;
+      this.vehicleParams.power.maxSpeed = 1e4 * scale;
+      const vehicleModel = await this.loader.loadAsync(opts.url);
+      const { size: originalSize } = this.getBbox(vehicleModel.scene);
+      const ratio = this.vehicleLength / Math.max(originalSize.x, originalSize.y, originalSize.z);
+      const power = Math.round(Math.log10(ratio));
+      const modelScale = Math.pow(10, power);
+      const vehicleMixer = new THREE3.AnimationMixer(vehicleModel.scene);
+      const animations = vehicleModel.animations ?? [];
+      const vehicleActions = /* @__PURE__ */ new Map();
       const findClip = (name) => animations.find((a) => a.name === name);
-      for (const [clipName, actionName] of animationMappings) {
-        const clip = findClip(clipName);
-        if (!clip) continue;
-        const action = this.vehicleMixer.clipAction(clip);
-        action.setLoop(THREE.LoopOnce, 1);
+      const openDoorClip = findClip(opts.animations?.openDoorAnim || "");
+      if (openDoorClip) {
+        const action = vehicleMixer.clipAction(openDoorClip);
+        action.setLoop(THREE3.LoopOnce, 1);
         action.clampWhenFinished = true;
-        action.setEffectiveTimeScale(2);
+        action.setEffectiveTimeScale(openDoorClip.duration);
         action.enabled = true;
         action.setEffectiveWeight(0);
-        this.vehicleActions.set(actionName, action);
+        vehicleActions.set("openDoor", action);
+      }
+      const wheelObjects = [];
+      for (const wheelName of opts.wheelsNames) {
+        let found = false;
+        vehicleModel.scene.traverse((child) => {
+          if (child.name === wheelName && !found) {
+            wheelObjects.push(child);
+            found = true;
+          }
+        });
+        if (!found) console.warn(`\u672A\u627E\u5230\u8F6E\u5B50: ${wheelName}`);
       }
-      console.log("\u5F00\u95E8\u52A8\u753B", this.vehicleActions.get("open_door"));
+      const tempGroup = new THREE3.Group();
+      this.scene.add(tempGroup);
+      vehicleModel.scene.scale.multiplyScalar(modelScale * scale);
+      vehicleModel.scene.rotateY(this.vehicleParams.model.rotation);
+      const { size, bbox, center } = this.getBbox(vehicleModel.scene);
+      vehicleModel.scene.position.set(-center.x, -center.y, -center.z);
+      tempGroup.add(vehicleModel.scene);
+      tempGroup.updateMatrixWorld(true);
+      const wheelsInfo = [];
+      let wheelRadius = 0;
+      let wheelWidth = 0;
+      let suspensionRestLength = 0;
+      let chassisHeight = 0;
+      let wheelSizeInit = false;
+      for (let i = 0; i < wheelObjects.length; i++) {
+        const wheel = wheelObjects[i];
+        const worldPos = new THREE3.Vector3();
+        const worldQuat = new THREE3.Quaternion();
+        const worldScale = new THREE3.Vector3();
+        wheel.getWorldPosition(worldPos);
+        wheel.getWorldQuaternion(worldQuat);
+        wheel.getWorldScale(worldScale);
+        if (!wheelSizeInit) {
+          const { size: ws } = this.getBbox(wheel);
+          wheelRadius = Number((Math.max(ws.x, ws.y, ws.z) / 2).toFixed(2));
+          wheelWidth = Number(Math.min(ws.x, ws.y, ws.z).toFixed(2));
+          suspensionRestLength = Number((wheelRadius * 2 * suspensionRestLengthRatio).toFixed(2));
+          chassisHeight = Number((wheelRadius * 2 * chassisRatio).toFixed(2));
+          wheelSizeInit = true;
+        }
+        wheelsInfo.push({
+          axleCs: new THREE3.Vector3(0, 0, -1),
+          position: worldPos,
+          quaternion: worldQuat,
+          scale: worldScale,
+          radius: wheelRadius,
+          width: wheelWidth,
+          suspensionRestLength,
+          object: wheel
+        });
+      }
+      tempGroup.remove(vehicleModel.scene);
+      this.scene.remove(tempGroup);
+      const vehicleGroup = new THREE3.Group();
+      this.scene.add(vehicleGroup);
+      vehicleGroup.add(vehicleModel.scene);
+      vehicleGroup.updateMatrixWorld(true);
+      const wheelWrappers = [];
+      for (let i = 0; i < wheelsInfo.length; i++) {
+        const wheel = wheelsInfo[i];
+        const localPos = vehicleGroup.worldToLocal(wheel.position.clone());
+        const wheelWrapper = new THREE3.Group();
+        wheelWrapper.position.copy(localPos);
+        const wheelObj = wheelsInfo[i].object;
+        if (wheelObj.parent) wheelObj.parent.remove(wheelObj);
+        wheelObj.position.set(0, 0, 0);
+        wheelObj.quaternion.copy(wheel.quaternion);
+        wheelObj.scale.copy(wheel.scale);
+        wheelObj.updateMatrixWorld();
+        wheelWrapper.add(wheelObj);
+        vehicleGroup.add(wheelWrapper);
+        wheelWrappers.push(wheelWrapper);
+      }
+      const halfExtents = size.clone().multiplyScalar(0.5);
+      halfExtents.y -= chassisHeight / 2;
+      vehicleModel.scene.position.y -= chassisHeight / 2;
+      halfExtents.x *= 0.95;
+      halfExtents.z *= 0.95;
+      const chassisDesc = this.RAPIER.RigidBodyDesc.dynamic().setTranslation(opts.position.x, opts.position.y, opts.position.z).setLinearDamping(this.vehicleParams.chassis.linearDamping).setAngularDamping(this.vehicleParams.chassis.angularDamping).setCanSleep(false).setAdditionalMass(10);
+      const chassisBody = this.world.createRigidBody(chassisDesc);
+      const chassisCollider = this.RAPIER.ColliderDesc.cuboid(halfExtents.x, halfExtents.y, halfExtents.z);
+      this.world.createCollider(chassisCollider, chassisBody);
+      if (this.vehicleParams.debug.showPhysicsBox) {
+        const debugBox = new THREE3.Mesh(
+          new THREE3.BoxGeometry(halfExtents.x * 2, halfExtents.y * 2, halfExtents.z * 2),
+          new THREE3.MeshBasicMaterial({
+            color: 16711680,
+            wireframe: true,
+            transparent: true,
+            opacity: 0.3
+          })
+        );
+        vehicleGroup.add(debugBox);
+      }
+      vehicleGroup.position.copy(opts.position);
+      vehicleGroup.updateMatrixWorld(true);
+      const { vehicle, updateWheelVisuals } = createVehicleController(this.world, chassisBody, wheelWrappers, wheelsInfo);
+      const vehicleInstance = {
+        vehicleGroup,
+        chassisBody,
+        vehicleController: vehicle,
+        updateWheelVisuals,
+        vehicleMixer,
+        vehicleActions,
+        vehiclIsOpenDoor: false,
+        vehicleBBox: bbox.clone(),
+        pathPlanner: new PathPlanner(this._createObstacleCheckerFor(vehicleGroup, bbox, scale), {
+          debugEnabled: false,
+          scene: this.scene,
+          scale: this.playerModel.scale
+        }),
+        scale,
+        boardingPoint: opts.boardingPoint,
+        seatOffset: opts.seatOffset ?? new THREE3.Vector3(0, 0, 0),
+        enterVehicleTime: 1.5,
+        chassisRatio,
+        suspensionRestLengthRatio,
+        size: {
+          l: Math.max(size.x, size.z),
+          w: Math.min(size.x, size.z),
+          h: size.y
+        }
+      };
+      this.vehicles.push(vehicleInstance);
+      console.log(`\u8F66\u8F86\u52A0\u8F7D\u5B8C\u6210\uFF0C\u5F53\u524D\u5171 ${this.vehicles.length} \u8F86\u8F66`, vehicleInstance);
+      this.setControllerTransition();
     } catch (error) {
       console.error("\u52A0\u8F7D\u8F66\u8F86\u6A21\u578B\u5931\u8D25:", error);
     }
   }
-  // ==================== 相机与视角控制 ====================
+  getBbox(object) {
+    const bbox = new THREE3.Box3().setFromObject(object);
+    const center = new THREE3.Vector3();
+    const size = new THREE3.Vector3();
+    bbox.getCenter(center);
+    bbox.getSize(size);
+    return { bbox, center, size };
+  }
   /**
-   * 第一/三人称视角切换
+   * 为指定车辆创建障碍物检测器
    */
+  _createObstacleCheckerFor(vehicleGroup, bbox, scale) {
+    return {
+      isBlocked: (start, end) => {
+        const vehiclePos = vehicleGroup.position;
+        const vehicleQuat = vehicleGroup.quaternion;
+        const center = new THREE3.Vector3();
+        const size = new THREE3.Vector3();
+        bbox.getCenter(center);
+        bbox.getSize(size);
+        center.applyQuaternion(vehicleQuat).add(vehiclePos);
+        const halfSize = size.clone().multiplyScalar(0.5 * scale);
+        const corners = [];
+        for (let x = -1; x <= 1; x += 2) {
+          for (let y = -1; y <= 1; y += 2) {
+            for (let z = -1; z <= 1; z += 2) {
+              const localCorner = new THREE3.Vector3(halfSize.x * x, halfSize.y * y, halfSize.z * z);
+              const worldCorner = localCorner.applyQuaternion(vehicleQuat).add(center);
+              corners.push(worldCorner);
+            }
+          }
+        }
+        const expandedBBox = new THREE3.Box3();
+        corners.forEach((corner) => expandedBBox.expandByPoint(corner));
+        expandedBBox.expandByScalar(100 * this.playerModel.scale);
+        const direction = new THREE3.Vector3().subVectors(end, start);
+        const length = direction.length();
+        direction.normalize();
+        const ray = new THREE3.Ray(start, direction);
+        const intersection = new THREE3.Vector3();
+        const intersects = ray.intersectBox(expandedBBox, intersection);
+        return intersects !== null && start.distanceTo(intersection) < length;
+      },
+      getNavigationNodes: (start, _goal) => {
+        const nodes = [];
+        const vehiclePos = vehicleGroup.position;
+        const vehicleQuat = vehicleGroup.quaternion;
+        const vehicleForward = new THREE3.Vector3(0, 0, 1).applyQuaternion(vehicleQuat);
+        const vehicleRight = new THREE3.Vector3(1, 0, 0).applyQuaternion(vehicleQuat);
+        const bboxSize = new THREE3.Vector3();
+        bbox.getSize(bboxSize);
+        const halfLength = bboxSize.z / 2 * scale;
+        const halfWidth = bboxSize.x / 2 * scale;
+        const bypassMargin = 300 * this.playerModel.scale;
+        const extendedMargin = 500 * this.playerModel.scale;
+        const groundY = start.y;
+        for (const margin of [bypassMargin, extendedMargin]) {
+          nodes.push(
+            vehiclePos.clone().add(vehicleForward.clone().multiplyScalar(halfLength + margin)).add(vehicleRight.clone().multiplyScalar(-halfWidth - margin)).setY(groundY)
+          );
+          nodes.push(
+            vehiclePos.clone().add(vehicleForward.clone().multiplyScalar(halfLength + margin)).add(vehicleRight.clone().multiplyScalar(halfWidth + margin)).setY(groundY)
+          );
+          nodes.push(
+            vehiclePos.clone().add(vehicleForward.clone().multiplyScalar(-halfLength - margin)).add(vehicleRight.clone().multiplyScalar(-halfWidth - margin)).setY(groundY)
+          );
+          nodes.push(
+            vehiclePos.clone().add(vehicleForward.clone().multiplyScalar(-halfLength - margin)).add(vehicleRight.clone().multiplyScalar(halfWidth + margin)).setY(groundY)
+          );
+        }
+        return nodes;
+      }
+    };
+  }
+  /**
+   * 开关车门动画（操作当前 activeVehicle）
+   */
+  openVehicleDoor(isOpen = true) {
+    const v = this.activeVehicle;
+    if (!v?.vehicleActions) return;
+    const next = v.vehicleActions.get("openDoor");
+    if (!next) return;
+    const duration = next.getClip().duration;
+    next.reset();
+    next.setEffectiveWeight(1);
+    if (isOpen) {
+      next.setEffectiveTimeScale(duration * 2);
+      next.time = 0;
+      v.vehiclIsOpenDoor = true;
+    } else {
+      next.setEffectiveTimeScale(-duration * 2);
+      next.time = duration;
+      v.vehiclIsOpenDoor = false;
+    }
+    next.setLoop(THREE3.LoopOnce, 1);
+    next.clampWhenFinished = true;
+    next.play();
+  }
+  /**
+   * 上车：自动寻找最近的车辆
+   */
+  enterVehicle() {
+    if (this.vehicles.length === 0) return;
+    let nearestVehicle = null;
+    let nearestDist = Infinity;
+    let nearBoardingPointWorld = null;
+    for (const v2 of this.vehicles) {
+      const boardingPointLocal = v2.boardingPoint.clone().multiplyScalar(v2.scale);
+      const boardingPointWorld = new THREE3.Vector3();
+      v2.vehicleGroup.localToWorld(boardingPointWorld.copy(boardingPointLocal));
+      const dist = this.player.position.distanceTo(boardingPointWorld);
+      if (dist < 800 * this.playerModel.scale && dist < nearestDist) {
+        nearestDist = dist;
+        nearestVehicle = v2;
+        nearBoardingPointWorld = boardingPointWorld;
+      }
+    }
+    if (!nearestVehicle || !nearBoardingPointWorld) return;
+    this.activeVehicle = nearestVehicle;
+    const v = nearestVehicle;
+    this.boardingPointWorld = nearBoardingPointWorld;
+    const vehicleForward = new THREE3.Vector3(0, 0, 1).applyQuaternion(v.vehicleGroup.quaternion).normalize();
+    const path = v.pathPlanner.findPath(this.player.position.clone(), this.boardingPointWorld);
+    this.boardingWaypoints = path;
+    this.currentWaypointIndex = 0;
+    this.boardingTargetDir = vehicleForward;
+    this.isMovingToBoardingPoint = true;
+    this.playPersonAnimationByName("walking");
+  }
+  /**
+   * 走向上车点
+   */
+  updateMoveToBoardingPoint(delta) {
+    if (!this.isMovingToBoardingPoint || !this.boardingTargetDir || this.boardingWaypoints.length === 0) {
+      return;
+    }
+    if (this.currentWaypointIndex >= this.boardingWaypoints.length) {
+      this.finalizeBoarding(delta);
+      return;
+    }
+    const currentWaypoint = this.boardingWaypoints[this.currentWaypointIndex];
+    const currentPos = this.player.position.clone();
+    const horizontalDistance = new THREE3.Vector2(currentWaypoint.x - currentPos.x, currentWaypoint.z - currentPos.z).length();
+    const isLastWaypoint = this.currentWaypointIndex === this.boardingWaypoints.length - 1;
+    const waypointThreshold = isLastWaypoint ? 0 : 10 * this.playerModel.scale;
+    if (horizontalDistance > waypointThreshold) {
+      const moveDir = new THREE3.Vector3(currentWaypoint.x - currentPos.x, 0, currentWaypoint.z - currentPos.z).normalize();
+      const moveDistance = Math.min(this.boardingMoveSpeed * this.playerModel.scale * delta, horizontalDistance);
+      this.player.position.add(moveDir.multiplyScalar(moveDistance));
+      const lookTarget = this.player.position.clone().add(moveDir);
+      this.targetMat.lookAt(this.player.position, lookTarget, this.player.up);
+      this.targetQuat.setFromRotationMatrix(this.targetMat);
+      this.targetQuat.multiply(this.flip180Quat);
+      const rotateAlpha = Math.min(1, this.boardingRotateSpeed * delta);
+      this.player.quaternion.slerp(this.targetQuat, rotateAlpha);
+    } else {
+      this.currentWaypointIndex++;
+    }
+  }
+  /**
+   * 完成上车
+   */
+  finalizeBoarding(delta) {
+    const v = this.activeVehicle;
+    if (!this.boardingTargetDir || !v) return;
+    const currentDir = new THREE3.Vector3(0, 0, -1).applyQuaternion(this.player.quaternion).normalize();
+    const targetDir = this.boardingTargetDir.clone().normalize();
+    const angleDiff = currentDir.angleTo(targetDir);
+    if (angleDiff > 0.01) {
+      const lookTarget = this.player.position.clone().add(targetDir);
+      this.targetMat.lookAt(this.player.position, lookTarget, this.player.up);
+      this.targetQuat.setFromRotationMatrix(this.targetMat);
+      const rotateAlpha = Math.min(1, this.boardingRotateSpeed * delta);
+      this.player.quaternion.slerp(this.targetQuat, rotateAlpha);
+    } else {
+      this.boardingWaypoints = [];
+      this.currentWaypointIndex = 0;
+      this.boardingTargetDir = null;
+      v.pathPlanner?.clearVisualization();
+      this.playPersonAnimationByName("enterCar");
+      if (!v.vehiclIsOpenDoor) this.openVehicleDoor();
+      this.player.rotation.copy(v.vehicleGroup.rotation);
+      this.player.quaternion.multiply(this.flip180Quat);
+      this.closeVehicleDoorTimer = setTimeout(
+        () => {
+          this.openVehicleDoor(false);
+        },
+        v.enterVehicleTime * 1e3 - 500
+      );
+      this.enterVehicleTimer = setTimeout(() => {
+        if (this.boardingPointWorld) {
+          const offsetY = this.boardingPointWorld.y - this.player.position.y;
+          this.controllerMode = 1;
+          v.vehicleGroup.attach(this.player);
+          this.player.position.add(
+            v.seatOffset.clone().multiplyScalar(v.scale).add(new THREE3.Vector3(0, offsetY, 0))
+          );
+          this.isMovingToBoardingPoint = false;
+          if (this.isChangeControllerTransitionTimer) {
+            clearTimeout(this.isChangeControllerTransitionTimer);
+            this.isChangeControllerTransitionTimer = null;
+          }
+        }
+      }, v.enterVehicleTime * 1e3);
+    }
+  }
+  /**
+   * 下车
+   */
+  exitVehicle() {
+    const v = this.activeVehicle;
+    if (!v) return;
+    this.isMovingToBoardingPoint = false;
+    this.boardingWaypoints = [];
+    this.currentWaypointIndex = 0;
+    this.boardingTargetDir = null;
+    const vel = v.chassisBody.linvel();
+    const velSpeed = new THREE3.Vector3(vel.x, vel.y, vel.z).length();
+    if (velSpeed > 0.1) {
+      this.playPersonAnimationByName("idle");
+    } else {
+      this.playPersonAnimationByName("exitCar");
+    }
+    this.openVehicleDoor(true);
+    this.closeVehicleDoorTimer = setTimeout(
+      () => {
+        this.openVehicleDoor(false);
+      },
+      v.enterVehicleTime * 1e3 - 500
+    );
+    this.controllerMode = 0;
+    this.scene.attach(this.player);
+    if (this.isFirstPerson) {
+      this.setFirstPersonCamera();
+    }
+    this.setControllerTransition();
+  }
+  // ==================== 相机与视角控制 ====================
   changeView() {
     this.isFirstPerson = !this.isFirstPerson;
     if (this.isFirstPerson) {
-      this.player.attach(this.camera);
-      this.camera.position.set(0, 40 * this.playerModel.scale, 30 * this.playerModel.scale);
-      this.camera.rotation.set(0, Math.PI, 0);
+      this.setFirstPersonCamera();
     } else {
       this.scene.attach(this.camera);
       const worldPos = this.player.position.clone();
-      const dir = new THREE.Vector3(0, 0, -1).applyQuaternion(this.player.quaternion);
+      const dir = new THREE3.Vector3(0, 0, -1).applyQuaternion(this.player.quaternion);
       const angle = Math.atan2(dir.z, dir.x);
-      const offset = new THREE.Vector3(Math.cos(angle) * 400 * this.playerModel.scale, 200 * this.playerModel.scale, Math.sin(angle) * 400 * this.playerModel.scale);
+      const offset = new THREE3.Vector3(Math.cos(angle) * 400 * this.playerModel.scale, 200 * this.playerModel.scale, Math.sin(angle) * 400 * this.playerModel.scale);
       this.camera.position.copy(worldPos).add(offset);
       this.controls.target.copy(worldPos);
+      this.controls.enableZoom = this.enableZoom;
     }
     this.setPointerLock();
   }
-  setDrive() {
-    this.controllerMode = 2;
-    this.person?.attach(this.vehicle);
+  setFirstPersonCamera() {
+    if (this.personHead) {
+      this.personHead?.attach(this.camera);
+      this.camera.position.set(0, 10, 20);
+    } else {
+      this.player.attach(this.camera);
+      this.camera.position.set(0, 40 * this.playerModel.scale, 30 * this.playerModel.scale);
+    }
+    this.camera.rotation.set(0, Math.PI, 0);
+    this.controls.enableZoom = false;
   }
-  /**
-   * 设置指针锁定
-   */
   setPointerLock() {
     if ((this.thirdMouseMode === 0 || this.thirdMouseMode === 1) && !this.isFirstPerson || this.isFirstPerson) {
       document.body.requestPointerLock();
+    } else {
+      document.exitPointerLock();
     }
   }
-  /**
-   * 设置摄像机初始位置
-   */
   setCameraPos() {
-    if (this.isFirstPerson) {
-      this.camera.position.set(0, 40 * this.playerModel.scale, 30 * this.playerModel.scale);
-    } else {
-      const worldPos = this.player.position.clone();
-      const dir = new THREE.Vector3(0, 0, -1).applyQuaternion(this.player.quaternion);
-      const angle = Math.atan2(dir.z, dir.x);
-      const offset = new THREE.Vector3(Math.cos(angle) * 400 * this.playerModel.scale, -100 * this.playerModel.scale, Math.sin(angle) * 400 * this.playerModel.scale);
-      this.camera.position.copy(worldPos).add(offset);
-    }
-    this.camera.updateProjectionMatrix();
+    setTimeout(() => {
+      if (this.isFirstPerson) {
+        this.person.add(this.camera);
+        this.camera.position.set(0, 40 * this.playerModel.scale, 30 * this.playerModel.scale);
+      } else {
+        const worldPos = this.player.position.clone();
+        const dir = new THREE3.Vector3(0, 0, -1).applyQuaternion(this.player.quaternion);
+        const angle = Math.atan2(dir.z, dir.x);
+        const offset = new THREE3.Vector3(Math.cos(angle) * 400 * this.playerModel.scale, -100 * this.playerModel.scale, Math.sin(angle) * 400 * this.playerModel.scale);
+        this.camera.position.copy(worldPos).add(offset);
+        this.controls.enableZoom = this.enableZoom;
+      }
+      this.camera.updateProjectionMatrix();
+    }, 0);
   }
-  /**
-   * 设置控制器
-   */
   setControls() {
-    this.controls.enabled = !(this.thirdMouseMode === 0 || this.thirdMouseMode === 1);
+    this.controls.enableZoom = this.enableZoom;
     this.controls.rotateSpeed = this.mouseSensity * 0.05;
     this.controls.maxPolarAngle = Math.PI * (300 / 360);
+    this.controls.mouseButtons = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };
   }
-  /**
-   * 重置控制器
-   */
   resetControls() {
     if (!this.controls) return;
     this.controls.enabled = true;
@@ -582,38 +1301,60 @@ var PlayerController = class {
     this.controls.enableZoom = true;
     this.controls.mouseButtons = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };
   }
-  /**
-   * 设置朝向
-   */
   setToward(dx, dy, speed) {
-    if (this.isFirstPerson) {
-      const yaw = -dx * speed * this.mouseSensity;
-      const pitch = -dy * speed * this.mouseSensity;
-      this.player.rotateY(yaw);
-      this.camera.rotation.x = THREE.MathUtils.clamp(this.camera.rotation.x + pitch, -1.1, 1.4);
+    if (this.controllerMode == 0) {
+      if (this.isFirstPerson) {
+        if (this.isMovingToBoardingPoint) return;
+        const yaw = -dx * speed * this.mouseSensity;
+        const pitch = -dy * speed * this.mouseSensity;
+        this.player.rotateY(yaw);
+        this.camera.rotation.x = THREE3.MathUtils.clamp(this.camera.rotation.x + pitch, -1.1, 1.4);
+      } else {
+        const sensitivity = this.mouseSensity;
+        const deltaX = -dx * speed * sensitivity;
+        const deltaY = -dy * speed * sensitivity;
+        const target = this.player.position.clone();
+        const distance = this.camera.position.distanceTo(target);
+        const currentPosition = this.camera.position.clone().sub(target);
+        let theta = Math.atan2(currentPosition.x, currentPosition.z);
+        let phi = Math.acos(currentPosition.y / distance);
+        theta += deltaX;
+        phi += deltaY;
+        phi = Math.max(0.1, Math.min(Math.PI - 0.1, phi));
+        const newX = distance * Math.sin(phi) * Math.sin(theta);
+        const newY = distance * Math.cos(phi);
+        const newZ = distance * Math.sin(phi) * Math.cos(theta);
+        this.camera.position.set(target.x + newX, target.y + newY, target.z + newZ);
+        this.camera.lookAt(target);
+      }
     } else {
-      const sensitivity = this.mouseSensity;
-      const deltaX = -dx * speed * sensitivity;
-      const deltaY = -dy * speed * sensitivity;
-      const target = this.player.position.clone();
-      const distance = this.camera.position.distanceTo(target);
-      const currentPosition = this.camera.position.clone().sub(target);
-      let theta = Math.atan2(currentPosition.x, currentPosition.z);
-      let phi = Math.acos(currentPosition.y / distance);
-      theta += deltaX;
-      phi += deltaY;
-      phi = Math.max(0.1, Math.min(Math.PI - 0.1, phi));
-      const newX = distance * Math.sin(phi) * Math.sin(theta);
-      const newY = distance * Math.cos(phi);
-      const newZ = distance * Math.sin(phi) * Math.cos(theta);
-      this.camera.position.set(target.x + newX, target.y + newY, target.z + newZ);
-      this.camera.lookAt(target);
+      const v = this.activeVehicle;
+      if (!v) return;
+      if (this.isFirstPerson) {
+        const yaw = -dx * speed * this.mouseSensity;
+        const pitch = -dy * speed * this.mouseSensity;
+        this.camera.rotation.y = THREE3.MathUtils.clamp(this.camera.rotation.y + yaw, Math.PI * (3 / 4), Math.PI * (5 / 4));
+        this.camera.rotation.x = THREE3.MathUtils.clamp(this.camera.rotation.x + pitch, 0, Math.PI * (1 / 3));
+      } else {
+        const sensitivity = this.mouseSensity;
+        const deltaX = -dx * speed * sensitivity;
+        const deltaY = -dy * speed * sensitivity;
+        const target = v.vehicleGroup.position.clone();
+        const distance = this.camera.position.distanceTo(target);
+        const currentPosition = this.camera.position.clone().sub(target);
+        let theta = Math.atan2(currentPosition.x, currentPosition.z);
+        let phi = Math.acos(currentPosition.y / distance);
+        theta += deltaX;
+        phi += deltaY;
+        phi = Math.max(0.1, Math.min(Math.PI - 0.1, phi));
+        const newX = distance * Math.sin(phi) * Math.sin(theta);
+        const newY = distance * Math.cos(phi);
+        const newZ = distance * Math.sin(phi) * Math.cos(theta);
+        this.camera.position.set(target.x + newX, target.y + newY, target.z + newZ);
+        this.camera.lookAt(target);
+      }
     }
   }
-  // ==================== 物理与碰撞检测 ====================
-  /**
-   * 统一属性集合
-   */
   unifiedAttribute(collected) {
     const attrMap = /* @__PURE__ */ new Map();
     const attrConflict = /* @__PURE__ */ new Set();
@@ -660,28 +1401,14 @@ var PlayerController = class {
           const meta = attrMap.get(name);
           const len = count * meta.itemSize;
           const array = new meta.arrayCtor(len);
-          g.setAttribute(name, new THREE.BufferAttribute(array, meta.itemSize, meta.normalized));
+          g.setAttribute(name, new THREE3.BufferAttribute(array, meta.itemSize, meta.normalized));
         }
       }
     }
     return collected;
   }
-  /**
-   * BVH碰撞体构建
-   */
   async createBVH(meshUrl = "") {
     await this.initLoader();
-    const ensureAttributesMinimal = (geom) => {
-      if (!geom.attributes.position) return null;
-      if (!geom.attributes.normal) geom.computeVertexNormals();
-      if (!geom.attributes.uv) {
-        const count = geom.attributes.position.count;
-        const dummyUV = new Float32Array(count * 2);
-        geom.setAttribute("uv", new THREE.BufferAttribute(dummyUV, 2));
-      }
-      return geom;
-    };
-    let collected = [];
     if (meshUrl === "") {
       if (this.collider) {
         this.scene.remove(this.collider);
@@ -694,15 +1421,15 @@ var PlayerController = class {
             let geom = mesh.geometry.clone();
             geom.applyMatrix4(mesh.matrixWorld);
             if (geom.index) geom = geom.toNonIndexed();
-            const safe = ensureAttributesMinimal(geom);
-            if (safe) collected.push(safe);
+            const safe = this.ensureAttributesMinimal(geom);
+            if (safe) this.collected.push(safe);
           } catch (e) {
             console.warn("\u5904\u7406\u7F51\u683C\u65F6\u51FA\u9519\uFF1A", mesh, e);
           }
         }
       });
-      if (!collected.length) return;
-      collected = this.unifiedAttribute(collected);
+      if (!this.collected.length) return;
+      this.collected = this.unifiedAttribute(this.collected);
     } else {
       const gltf = await this.loader.loadAsync(meshUrl);
       const mesh = gltf.scene.children[0];
@@ -710,34 +1437,73 @@ var PlayerController = class {
       let geom = mesh.geometry.clone();
       geom.applyMatrix4(mesh.matrixWorld);
       if (geom.index) geom = geom.toNonIndexed();
-      const safe = ensureAttributesMinimal(geom);
-      if (safe) collected.push(safe);
+      const safe = this.ensureAttributesMinimal(geom);
+      if (safe) this.collected.push(safe);
     }
-    const merged = BufferGeometryUtils.mergeGeometries(collected, false);
+    const merged = BufferGeometryUtils.mergeGeometries(this.collected, false);
     if (!merged) {
       console.error("\u5408\u5E76\u51E0\u4F55\u5931\u8D25");
       return;
     }
     merged.boundsTree = new MeshBVH(merged, { maxDepth: 100 });
-    this.collider = new THREE.Mesh(
+    this.collider = new THREE3.Mesh(
       merged,
-      new THREE.MeshBasicMaterial({
+      new THREE3.MeshBasicMaterial({
         opacity: 0.5,
         transparent: true,
-        wireframe: true
+        wireframe: true,
+        depthTest: true
       })
     );
     if (this.displayCollider) this.scene.add(this.collider);
     if (this.displayVisualizer) {
       if (this.visualizer) this.scene.remove(this.visualizer);
-      this.visualizer = new MeshBVHHelper(this.collider, this.visualizeDepth);
+      this.visualizer = new MeshBVHHelper(this.collider, 0);
       this.scene.add(this.visualizer);
     }
     this.boundingBoxMinY = this.collider.geometry.boundingBox.min.y;
   }
-  /**
-   * 获取法线与Y轴的夹角
-   */
+  createDynamicBVH(objects = []) {
+    if (this.dynamicCollider) {
+      this.scene.remove(this.dynamicCollider);
+      this.dynamicCollider = null;
+    }
+    this.dynamicCollected = [];
+    objects.forEach((object) => {
+      object.traverse((c) => {
+        const mesh = c;
+        if (mesh?.isMesh && mesh.geometry && c.name !== "capsule") {
+          try {
+            let geom = mesh.geometry.clone();
+            geom.applyMatrix4(mesh.matrixWorld);
+            if (geom.index) geom = geom.toNonIndexed();
+            const safe = this.ensureAttributesMinimal(geom);
+            if (safe) this.dynamicCollected.push(safe);
+          } catch (e) {
+            console.warn("\u5904\u7406\u7F51\u683C\u65F6\u51FA\u9519\uFF1A", mesh, e);
+          }
+        }
+      });
+    });
+    if (!this.dynamicCollected.length) return;
+    this.dynamicCollected = this.unifiedAttribute(this.dynamicCollected);
+    const merged = BufferGeometryUtils.mergeGeometries(this.dynamicCollected, false);
+    if (!merged) {
+      console.error("\u5408\u5E76\u51E0\u4F55\u5931\u8D25");
+      return;
+    }
+    merged.boundsTree = new MeshBVH(merged);
+    this.dynamicCollider = new THREE3.Mesh(
+      merged,
+      new THREE3.MeshBasicMaterial({
+        opacity: 0.5,
+        transparent: true,
+        wireframe: true,
+        depthTest: true
+      })
+    );
+    if (this.displayCollider) this.scene.add(this.dynamicCollider);
+  }
   getAngleWithYAxis(normal) {
     const yAxis = { x: 0, y: 1, z: 0 };
     const dotProduct = normal.x * yAxis.x + normal.y * yAxis.y + normal.z * yAxis.z;
@@ -745,13 +1511,193 @@ var PlayerController = class {
     const cosTheta = dotProduct / normalMagnitude;
     return Math.acos(cosTheta);
   }
+  // ==================== 设置控制器过渡 ====================
+  setControllerTransition() {
+    if (this.isChangeControllerTransitionTimer) {
+      clearTimeout(this.isChangeControllerTransitionTimer);
+      this.isChangeControllerTransitionTimer = null;
+    }
+    this.isChangeControllerTransitionTimer = setTimeout(() => {
+      this.isChangeControllerTransitionTimer = null;
+      let vGroups = [];
+      for (const v of this.vehicles) {
+        this.clearVehicleVelocity(v);
+        vGroups.push(v.vehicleGroup);
+      }
+      this.createDynamicBVH(vGroups);
+    }, 3e3);
+  }
+  // 清除车辆速度
+  clearVehicleVelocity(v) {
+    if (!v || !this.world || !this.RAPIER) return;
+    const { chassisBody, vehicleController } = v;
+    const ZERO = new this.RAPIER.Vector3(0, 0, 0);
+    chassisBody.setLinvel(ZERO, true);
+    chassisBody.setAngvel(ZERO, true);
+    const BIG_BRAKE = 1e6;
+    for (let i = 0; i < 4; i++) {
+      vehicleController.setWheelEngineForce(i, 0);
+      vehicleController.setWheelBrake(i, BIG_BRAKE);
+    }
+    vehicleController.updateVehicle(1 / 60);
+    this.world.timestep = 1 / 60;
+    this.world.step();
+    chassisBody.setLinvel(ZERO, true);
+    chassisBody.setAngvel(ZERO, true);
+    for (let i = 0; i < 4; i++) {
+      vehicleController.setWheelBrake(i, 0);
+    }
+  }
   // ==================== 循环更新 ====================
-  /**
-   * 每帧更新
-   */
   async update(delta = clock.getDelta()) {
     if (!this.isupdate || !this.player || !this.collider) return;
     delta = Math.min(delta, 1 / 30);
+    if (this.controllerMode == 1) {
+      this.updateVehicle(delta);
+    } else {
+      this.updatePlayer(delta);
+      if (this.isChangeControllerTransitionTimer) this.updateVehicleInertia(delta);
+    }
+  }
+  /**
+   * 更新当前驾驶的车辆
+   */
+  updateVehicle(delta) {
+    const v = this.activeVehicle;
+    if (!v || !this.world) return;
+    const { vehicleController, chassisBody, vehicleGroup } = v;
+    const rotation = chassisBody.rotation();
+    const quat = new THREE3.Quaternion(rotation.x, rotation.y, rotation.z, rotation.w);
+    const forward = new THREE3.Vector3(1, 0, 0).applyQuaternion(quat);
+    const slopeAngle = Math.asin(forward.y);
+    let factor = 1;
+    if (slopeAngle < -0.05 && this.fwdPressed) {
+      factor = -Math.sin(slopeAngle) * 10;
+    }
+    const engineForce = (Number(this.fwdPressed) * this.vehicleParams.power.accelerateForce - Number(this.bkdPressed) * this.vehicleParams.power.accelerateForce) * factor;
+    vehicleController.setWheelEngineForce(0, engineForce);
+    vehicleController.setWheelEngineForce(1, engineForce);
+    vehicleController.setWheelEngineForce(2, engineForce);
+    vehicleController.setWheelEngineForce(3, engineForce);
+    const wheelBrake = Number(this.spacePressed) * this.vehicleParams.power.brakeForce * delta;
+    vehicleController.setWheelBrake(0, wheelBrake);
+    vehicleController.setWheelBrake(1, wheelBrake);
+    vehicleController.setWheelBrake(2, wheelBrake);
+    vehicleController.setWheelBrake(3, wheelBrake);
+    const currentSteering = vehicleController.wheelSteering(0) || 0;
+    const steerDirection = Number(this.lftPressed) - Number(this.rgtPressed);
+    let steerSpeed;
+    if (steerDirection === 0) {
+      steerSpeed = this.vehicleParams.steering.steerReturnSpeed || 0.15;
+    } else {
+      steerSpeed = this.vehicleParams.steering.steerSpeed || 0.08;
+    }
+    const steerLerpFactor = 1 - Math.pow(1 - steerSpeed, delta);
+    const targetSteering = this.vehicleParams.steering.maxSteerAngle * steerDirection;
+    const steering = THREE3.MathUtils.lerp(currentSteering, targetSteering, steerLerpFactor);
+    vehicleController.setWheelSteering(0, steering);
+    vehicleController.setWheelSteering(1, steering);
+    if ((this.rgtPressed || this.lftPressed) && this.shiftPressed) {
+      vehicleController.setWheelSideFrictionStiffness(2, 0.5);
+      vehicleController.setWheelSideFrictionStiffness(3, 0.5);
+    } else {
+      vehicleController.setWheelSideFrictionStiffness(2, 2);
+      vehicleController.setWheelSideFrictionStiffness(3, 2);
+    }
+    this.updateVehicleInertia(delta);
+    if (!this.isFirstPerson) {
+      const lookTarget = vehicleGroup.position.clone();
+      this.camera.position.sub(this.controls.target);
+      this.controls.target.copy(lookTarget);
+      this.camera.position.add(lookTarget);
+      this.controls.update();
+      const velocity = chassisBody.linvel();
+      const currentSpeed = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y + velocity.z * velocity.z);
+      const maxSpeed = this.vehicleParams.power.maxSpeed * v.scale;
+      const speedRatio = Math.min(currentSpeed / maxSpeed, 1);
+      const baseCamDistance = v.size.l * 0.8;
+      const maxCamDistanceLimit = v.size.l * 5;
+      const targetDistance = THREE3.MathUtils.lerp(baseCamDistance, maxCamDistanceLimit, speedRatio);
+      this._personToCam.subVectors(this.camera.position, vehicleGroup.position);
+      const origin = vehicleGroup.position.clone().add(new THREE3.Vector3(0, 0, 0));
+      const direction = this._personToCam.clone().normalize();
+      const desiredDist = targetDistance;
+      this._raycasterPersonToCam.set(origin, direction);
+      this._raycasterPersonToCam.far = desiredDist;
+      const intersects = this._raycasterPersonToCam.intersectObject(this.collider, false);
+      if (intersects.length > 0) {
+        const hit = intersects[0];
+        const safeDist = Math.max(hit.distance - this._camEpsilon, this._minCamDistance);
+        const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
+        this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
+      } else {
+        this._raycasterPersonToCam.far = maxCamDistanceLimit;
+        const intersectsMaxDis = this._raycasterPersonToCam.intersectObject(this.collider, false);
+        let safeDist = desiredDist;
+        if (intersectsMaxDis.length) {
+          const hitMax = intersectsMaxDis[0];
+          safeDist = Math.min(desiredDist, hitMax.distance - this._camEpsilon);
+        }
+        const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
+        this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
+      }
+      if (this.fwdPressed || this.bkdPressed) {
+        const vel = chassisBody.linvel();
+        const velHorizontal = new THREE3.Vector3(vel.x, vel.y, vel.z);
+        const velSpeed = velHorizontal.length();
+        if (velSpeed > 0.3) {
+          const targetBehindDir = velHorizontal.clone().normalize().negate();
+          this.camBehindDir.lerp(targetBehindDir, this._camCollisionLerp).normalize();
+          const camHeightOffset = v.size.h;
+          const targetCamPos = lookTarget.clone().add(this.camBehindDir.clone().multiplyScalar(desiredDist)).add(new THREE3.Vector3(0, camHeightOffset, 0));
+          this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
+          this.controls.update();
+        }
+      }
+    }
+    const vehicleUp = this.upVector.clone().applyQuaternion(vehicleGroup.quaternion);
+    const angleWithUp = vehicleUp.angleTo(this.upVector);
+    if (angleWithUp > Math.PI / 2) {
+      const size = new THREE3.Vector3();
+      v.vehicleBBox?.getSize(size);
+      const translation2 = chassisBody.translation();
+      chassisBody.setTranslation(new this.RAPIER.Vector3(translation2.x, translation2.y + size.y, translation2.z), true);
+      chassisBody.setRotation(new this.RAPIER.Quaternion(0, 0, 0, 1), true);
+      chassisBody.setLinvel(new this.RAPIER.Vector3(0, 0, 0), true);
+      chassisBody.setAngvel(new this.RAPIER.Vector3(0, 0, 0), true);
+    }
+  }
+  /**
+   * 更新所有车辆物理和位置
+   */
+  updateVehicleInertia(delta) {
+    if (!this.world) return;
+    this.world.timestep = delta;
+    this.world.step();
+    for (const v of this.vehicles) {
+      const { vehicleController, chassisBody, vehicleGroup, updateWheelVisuals } = v;
+      vehicleController.updateVehicle(delta);
+      const velocity = chassisBody.linvel();
+      const currentSpeed = Math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y + velocity.z * velocity.z);
+      const maxSpeed = this.vehicleParams.power.maxSpeed * v.scale;
+      if (currentSpeed > maxSpeed) {
+        const s = maxSpeed / currentSpeed;
+        chassisBody.setLinvel(new this.RAPIER.Vector3(velocity.x * s, velocity.y * s, velocity.z * s), true);
+      }
+      const translation = chassisBody.translation();
+      const rotationSync = chassisBody.rotation();
+      vehicleGroup.position.set(translation.x, translation.y, translation.z);
+      vehicleGroup.quaternion.set(rotationSync.x, rotationSync.y, rotationSync.z, rotationSync.w);
+      if (updateWheelVisuals) updateWheelVisuals();
+    }
+  }
+  /**
+   * 更新人物
+   */
+  updatePlayer(delta) {
+    if (this.isMovingToBoardingPoint) {
+      this.updateMoveToBoardingPoint(delta);
+    }
     if (!this.isFlying) {
       this.player.position.addScaledVector(this.playerVelocity, delta);
     }
@@ -782,32 +1728,24 @@ var PlayerController = class {
     const intersects = this._raycaster.intersectObject(this.collider, false);
     if (intersects.length > 0) {
       playerDistanceFromGround = this.player.position.y - intersects[0].point.y;
-      const normal = intersects[0].normal;
-      const angle2 = this.getAngleWithYAxis(normal) * 180 / Math.PI;
       const maxH = this.playerHeight * this.playerModel.scale * 0.9;
       const h = this.playerHeight * this.playerModel.scale * 0.75;
       const minH = this.playerHeight * this.playerModel.scale * 0.7;
       if (!this.isFlying) {
-        if (playerDistanceFromGround > maxH) {
+        if (playerDistanceFromGround >= maxH) {
           this.playerVelocity.y += delta * this.gravity;
           this.player.position.addScaledVector(this.playerVelocity, delta);
           this.playerIsOnGround = false;
-        } else if (playerDistanceFromGround > h && playerDistanceFromGround < maxH) {
-          if (angle2 >= 0 && angle2 < 5) {
-            this.playerVelocity.y += delta * this.gravity;
-            this.player.position.addScaledVector(this.playerVelocity, delta);
+        } else if (playerDistanceFromGround >= h && playerDistanceFromGround < maxH) {
+          if (!this.spacePressed) {
+            this.playerVelocity.set(0, 0, 0);
             this.playerIsOnGround = true;
-          } else {
-            if (this.spacePressed) {
-              this.playerVelocity.y += delta * this.gravity;
-            } else {
-              this.playerVelocity.set(0, 0, 0);
-              this.playerIsOnGround = true;
-            }
+            this.player.position.y = intersects[0].point.y + h;
           }
-        } else if (playerDistanceFromGround > minH && playerDistanceFromGround < h) {
+        } else if (playerDistanceFromGround >= minH && playerDistanceFromGround < h) {
           this.playerVelocity.set(0, 0, 0);
           this.playerIsOnGround = true;
+          this.player.position.y = intersects[0].point.y + h;
         } else if (playerDistanceFromGround < minH) {
           this.playerVelocity.set(0, 0, 0);
           this.player.position.set(this.player.position.x, intersects[0].point.y + h, this.player.position.z);
@@ -825,23 +1763,38 @@ var PlayerController = class {
     this.tempBox.expandByPoint(this.tempSegment.start);
     this.tempBox.expandByPoint(this.tempSegment.end);
     this.tempBox.expandByScalar(capsuleInfo.radius);
-    const bvh = this.collider?.geometry;
-    bvh?.boundsTree?.shapecast({
-      // 检测包围盒碰撞
-      intersectsBounds: (box) => box.intersectsBox(this.tempBox),
-      // 检测三角形碰撞
-      intersectsTriangle: (tri) => {
-        const triPoint = this.tempVector;
-        const capsulePoint = this.tempVector2;
-        const distance = tri.closestPointToSegment(this.tempSegment, triPoint, capsulePoint);
-        if (distance < capsuleInfo.radius) {
-          const depth = capsuleInfo.radius - distance;
-          const direction = capsulePoint.sub(triPoint).normalize();
-          this.tempSegment.start.addScaledVector(direction, depth);
-          this.tempSegment.end.addScaledVector(direction, depth);
+    if (!this.isMovingToBoardingPoint) {
+      this.collider?.geometry?.boundsTree?.shapecast({
+        intersectsBounds: (box) => box.intersectsBox(this.tempBox),
+        intersectsTriangle: (tri) => {
+          const triPoint = this.tempVector;
+          const capsulePoint = this.tempVector2;
+          const distance = tri.closestPointToSegment(this.tempSegment, triPoint, capsulePoint);
+          if (distance < capsuleInfo.radius) {
+            const normal = tri.getNormal(new THREE3.Vector3());
+            if (normal.y > 0.5 && !this.isFlying) return;
+            const depth = capsuleInfo.radius - distance;
+            const direction = capsulePoint.sub(triPoint).normalize();
+            this.tempSegment.start.addScaledVector(direction, depth);
+            this.tempSegment.end.addScaledVector(direction, depth);
+          }
         }
-      }
-    });
+      });
+      this.dynamicCollider?.geometry?.boundsTree?.shapecast({
+        intersectsBounds: (box) => box.intersectsBox(this.tempBox),
+        intersectsTriangle: (tri) => {
+          const triPoint = this.tempVector;
+          const capsulePoint = this.tempVector2;
+          const distance = tri.closestPointToSegment(this.tempSegment, triPoint, capsulePoint);
+          if (distance < capsuleInfo.radius) {
+            const depth = capsuleInfo.radius - distance;
+            const direction = capsulePoint.sub(triPoint).normalize();
+            this.tempSegment.start.addScaledVector(direction, depth);
+            this.tempSegment.end.addScaledVector(direction, depth);
+          }
+        }
+      });
+    }
     const newPosition = this.tempVector.copy(this.tempSegment.start).applyMatrix4(this.collider.matrixWorld);
     const deltaVector = this.tempVector2.subVectors(newPosition, this.player.position);
     const offset = Math.max(0, deltaVector.length() - 1e-5);
@@ -874,58 +1827,62 @@ var PlayerController = class {
       }
     }
     if (this.isFlying) {
-      this.camDir.y = 0;
-      this.camDir.normalize();
-      this.camDir.negate();
-      this.moveDir.normalize();
-      this.moveDir.negate();
-      const lookTarget = this.player.position.clone().add(this.fwdPressed ? this.moveDir : this.camDir);
-      this.targetMat.lookAt(this.player.position, lookTarget, this.player.up);
-      this.targetQuat.setFromRotationMatrix(this.targetMat);
-      const alpha = Math.min(1, this.rotationSpeed * delta);
-      this.player.quaternion.slerp(this.targetQuat, alpha);
+      if (!this.isFirstPerson) {
+        this.camDir.y = 0;
+        this.camDir.normalize();
+        this.camDir.negate();
+        this.moveDir.normalize();
+        this.moveDir.negate();
+        const lookTarget = this.player.position.clone().add(this.fwdPressed ? this.moveDir : this.camDir);
+        this.targetMat.lookAt(this.player.position, lookTarget, this.player.up);
+        this.targetQuat.setFromRotationMatrix(this.targetMat);
+        const alpha = Math.min(1, this.rotationSpeed * delta);
+        this.player.quaternion.slerp(this.targetQuat, alpha);
+      }
     }
     if (!this.isFirstPerson) {
       const lookTarget = this.player.position.clone();
-      lookTarget.y += 30 * this.playerModel.scale;
+      lookTarget.y += this.playerHeight / 6 * this.playerModel.scale;
       this.camera.position.sub(this.controls.target);
       this.controls.target.copy(lookTarget);
       this.camera.position.add(lookTarget);
       this.controls.update();
-      this._personToCam.subVectors(this.camera.position, this.player.position);
-      const origin = this.player.position.clone().add(new THREE.Vector3(0, 0, 0));
-      const direction = this._personToCam.clone().normalize();
-      const desiredDist = this._personToCam.length();
-      this._raycasterPersonToCam.set(origin, direction);
-      this._raycasterPersonToCam.far = desiredDist;
-      const intersects2 = this._raycasterPersonToCam.intersectObject(this.collider, false);
-      if (intersects2.length > 0) {
-        const hit = intersects2[0];
-        const safeDist = Math.max(hit.distance - this._camEpsilon, this._minCamDistance);
-        const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
-        this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
-      } else {
-        this._raycasterPersonToCam.far = this._maxCamDistance;
-        const intersectsMaxDis = this._raycasterPersonToCam.intersectObject(this.collider, false);
-        let safeDist = this._maxCamDistance;
-        if (intersectsMaxDis.length) {
-          const hitMax = intersectsMaxDis[0];
-          safeDist = hitMax.distance - this._camEpsilon;
+      if (!this.enableZoom) {
+        this._personToCam.subVectors(this.camera.position, this.player.position);
+        const origin = this.player.position.clone();
+        const direction = this._personToCam.clone().normalize();
+        const desiredDist = this._personToCam.length();
+        this._raycasterPersonToCam.set(origin, direction);
+        this._raycasterPersonToCam.far = desiredDist;
+        const intersectsCamera = this._raycasterPersonToCam.intersectObject(this.collider, false);
+        if (intersectsCamera.length > 0) {
+          const hit = intersectsCamera[0];
+          const safeDist = Math.max(hit.distance - this._camEpsilon, this._minCamDistance);
+          const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
+          this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
+        } else {
+          this._raycasterPersonToCam.far = this._maxCamDistance;
+          const intersectsMaxDis = this._raycasterPersonToCam.intersectObject(this.collider, false);
+          let safeDist = this._maxCamDistance;
+          if (intersectsMaxDis.length) {
+            const hitMax = intersectsMaxDis[0];
+            safeDist = hitMax.distance - this._camEpsilon;
+          }
+          const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
+          this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
         }
-        const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
-        this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
       }
     }
     if (this.player.position.y < this.boundingBoxMinY - 1) {
       this._originTmp.set(this.player.position.x, 1e4, this.player.position.z);
       this._raycaster.ray.origin.copy(this._originTmp);
-      const intersects2 = this._raycaster.intersectObject(this.collider, false);
-      if (intersects2.length > 0) {
+      const intersectsFall = this._raycaster.intersectObject(this.collider, false);
+      if (intersectsFall.length > 0) {
         console.log("\u73A9\u5BB6\u4E3Abug\u610F\u5916\u6389\u843D");
-        this.reset(new THREE.Vector3(this.player.position.x, intersects2[0].point.y + 5, this.player.position.z));
+        this.reset(new THREE3.Vector3(this.player.position.x, intersectsFall[0].point.y + 5, this.player.position.z));
       } else {
         console.log("\u73A9\u5BB6\u6B63\u5E38\u6389\u843D");
-        this.reset(new THREE.Vector3(this.player.position.x, this.player.position.y + 15, this.player.position.z));
+        this.reset(new THREE3.Vector3(this.player.position.x, this.player.position.y + 15, this.player.position.z));
       }
     }
   }
@@ -934,26 +1891,19 @@ var PlayerController = class {
    */
   updateMixers(delta) {
     if (this.personMixer) this.personMixer.update(delta);
-    if (this.vehicleMixer) this.vehicleMixer.update(delta);
+    for (const v of this.vehicles) {
+      v.vehicleMixer?.update(delta);
+    }
   }
-  /**
-   * 重置玩家位置
-   */
   reset(position) {
     if (!this.player) return;
     this.playerVelocity.set(0, 0, 0);
     this.player.position.copy(position ?? this.initPos);
   }
-  /**
-   * 获取玩家位置
-   */
   getPosition() {
     return this.player.position;
   }
   // ==================== 输入处理 ====================
-  /**
-   * 设置输入
-   */
   setInput(input) {
     if (typeof input.moveX === "number") {
       this.lftPressed = input.moveX === -1;
@@ -993,9 +1943,6 @@ var PlayerController = class {
       }
     }
   }
-  /**
-   * 事件绑定
-   */
   onAllEvent() {
     this.isupdate = true;
     this.setPointerLock();
@@ -1004,9 +1951,6 @@ var PlayerController = class {
     window.addEventListener("mousemove", this._mouseMove);
     window.addEventListener("click", this._mouseClick);
   }
-  /**
-   * 事件解绑
-   */
   offAllEvent() {
     this.isupdate = false;
     document.exitPointerLock();
@@ -1015,9 +1959,6 @@ var PlayerController = class {
     window.removeEventListener("mousemove", this._mouseMove);
     window.removeEventListener("click", this._mouseClick);
   }
-  /**
-   * 初始化移动端摇杆控制
-   */
   async initMobileControls() {
     this.controls.maxPolarAngle = Math.PI * (300 / 360);
     this.controls.touches = { ONE: null, TWO: null };
@@ -1068,9 +2009,7 @@ var PlayerController = class {
       const sprintThreshold = JOY_SIZE / 2;
       const isSprinting = distance >= sprintThreshold;
       const prev = this.prevJoyState || { dirX: 0, dirY: 0, shift: false };
-      if (dirX === prev.dirX && dirY === prev.dirY && isSprinting === prev.shift) {
-        return;
-      }
+      if (dirX === prev.dirX && dirY === prev.dirY && isSprinting === prev.shift) return;
       this.prevJoyState = { dirX, dirY, shift: isSprinting };
       this.setInput({ moveX: dirX, moveY: dirY, shift: isSprinting });
     });
@@ -1182,9 +2121,6 @@ var PlayerController = class {
       { passive: false }
     );
   }
-  /**
-   * 销毁移动端摇杆控制
-   */
   destroyMobileControls() {
     try {
       if (this.joystickManager && this.joystickManager.destroy) {
@@ -1220,9 +2156,6 @@ var PlayerController = class {
     }
   }
   // ==================== 销毁 ====================
-  /**
-   * 销毁人物控制器
-   */
   destroy() {
     this.offAllEvent();
     if (this.player) {
@@ -1244,6 +2177,12 @@ var PlayerController = class {
       this.collider = null;
     }
     this.destroyMobileControls();
+    for (const v of this.vehicles) {
+      this.scene.remove(v.vehicleGroup);
+      v.pathPlanner?.dispose();
+    }
+    this.vehicles = [];
+    this.activeVehicle = null;
     controllerInstance = null;
   }
 };
@@ -1252,13 +2191,16 @@ function playerController() {
   const c = controllerInstance;
   return {
     init: (opts, callback) => c.init(opts, callback),
+    loadVehicleModel: (params) => c.loadVehicleModel(params),
     changeView: () => c.changeView(),
     reset: (pos) => c.reset(pos),
     update: (dt) => c.update(dt),
     destroy: () => c.destroy(),
     setInput: (i) => c.setInput(i),
     getposition: () => c.getPosition(),
-    loadVehicleModel: (params) => c.loadVehicleModel(params)
+    getPerson: () => c.person,
+    getActiveVehicle: () => c.activeVehicle,
+    getAllVehicles: () => c.vehicles
   };
 }
 function onAllEvent() {