@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-BBGKQIJJ.mjs

@@ -0,0 +1,406 @@
+import { INPUT_STRIDE, GEAR_AUTO, INPUT_GEAR, STATE_STRIDE, VEHICLE_DESC_WORDS, MAX_WHEELS, DESC_IDLE_RPM, DESC_WHEEL_COUNT, NO_GROUND, DESC_HEADER, WHEEL_DESC_WORDS, WHEEL_DESC_REST, INPUT_THROTTLE, INPUT_BRAKE, INPUT_STEER, INPUT_HANDBRAKE, DESC_STEER_RATE, DESC_MAX_STEER, DESC_ACKERMANN, WHEEL_DESC_POSITION, WHEEL_DESC_STEER, WHEEL_DESC_RADIUS, WHEEL_DESC_TRAVEL, WHEEL_DESC_COMPRESSION, WHEEL_DESC_RELAXATION, WHEEL_DESC_STIFFNESS, WHEEL_DESC_MAX_FORCE, DESC_ANTI_ROLL, WHEEL_DESC_AXLE, NO_AXLE, DESC_ROLLING, WHEEL_DESC_DRIVE, WHEEL_DESC_SIDE, DESC_SKID_TORQUE, WHEEL_DESC_BRAKE, WHEEL_DESC_HANDBRAKE, DESC_HANDBRAKE_GRIP, DESC_FORCE_HEIGHT, WHEEL_DESC_GRIP, DESC_DOWNFORCE, DESC_DRAG, WHEEL_DESC_INERTIA, DESC_MAX_RPM, DESC_GEAR_COUNT, DESC_SHIFT_UP, DESC_SHIFT_DOWN, DESC_SHIFT_SECONDS, DESC_TORQUE_POINTS, DESC_TORQUE, DESC_TORQUE_RPM, DESC_ENGINE_BRAKING, DESC_ENGINE_INERTIA, DESC_EFFICIENCY, DESC_DIFFERENTIAL_LOCK, DESC_CENTER_LOCK, DESC_LEAN_STIFFNESS, DESC_LEAN_DAMPING, DESC_LEAN_SPEED, DESC_LEAN_MAX, DESC_RATIOS, DESC_FINAL_DRIVE, DESC_REVERSE, STATE_SPEED, STATE_RPM, STATE_GEAR, STATE_STEER, STATE_SHIFTING, WHEEL_CENTER, WHEEL_SPIN, WHEEL_STEER, WHEEL_LENGTH, WHEEL_GROUND, WHEEL_POINT, WHEEL_SLIP, WHEEL_SLIP_ANGLE, WHEEL_LOAD, WHEEL_OMEGA, WHEEL_FORCE_LONG, WHEEL_FORCE_LAT, STATE_GROUNDED, STEER_LIMIT, STATE_HEADER, WHEEL_STRIDE, CURVE_POINTS, CURVE_VALUE, CURVE_SLIP, WHEEL_DESC_LONGITUDINAL, WHEEL_DESC_LATERAL } from './chunk-RUVGVNOF.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/physics/vehicle-solver.ts
+var CHASSIS_T = 0, CHASSIS_Q = 3, CHASSIS_LINEAR = 7, CHASSIS_ANGULAR = 10, CHASSIS_COM = 13, CHASSIS_INV_MASS = 16, CHASSIS_INV_INERTIA = 19, CHASSIS_SLEEPING = 25, CHASSIS_WORDS = 26, HIT_TOI = 0, HIT_REACH = 0, HIT_NORMAL = 1, HIT_GROUND_VELOCITY = 4, HIT_GROUND_BODY = 7, HIT_WORDS = 8, NO_BODY = -1, DEFAULT_CAPACITY = 32, TYRE_ITERATIONS = 4, SLIP_SPEED_FLOOR = 0.5, AIRBORNE_SPIN_DAMPING = 0.5, ACKERMANN_EPSILON = 1e-4, RPM_PER_RADIAN_PER_SECOND = 9.549297, TWO_PI = Math.PI * 2, W_OMEGA = 0, W_SPIN = 1, W_STEER = 2, W_LENGTH = 3, W_CONTACT = 4, W_GROUND = 5, W_GROUND_BODY = 6, W_CENTER = 7, W_POINT = 10, W_NORMAL = 13, W_FORWARD = 16, W_RIGHT = 19, W_OFFSET = 22, W_GROUND_VELOCITY = 25, W_LOAD = 28, W_SLIP = 29, W_SLIP_ANGLE = 30, W_K_LONG = 31, W_K_LAT = 32, W_LIMIT_LONG = 33, W_LIMIT_LAT = 34, W_IMPULSE_LONG = 35, W_IMPULSE_LAT = 36, W_INERTIA = 37, W_BRAKE_LEFT = 38, W_STRIDE = 40, V_BODY = 0, V_STEER = 1, V_GEAR = 2, V_SHIFT = 3, V_RPM = 4, V_SPEED = 5, V_STRIDE = 8;
+function clamp(value, low, high) {
+  let lifted = value > low ? value : low;
+  return lifted < high ? lifted : high;
+}
+function curve(desc, at, io, slot) {
+  let slip = io[slot], n = desc[at + CURVE_POINTS], peak = 0;
+  for (let k = 1; k < n; k++) desc[at + CURVE_VALUE + k] > desc[at + CURVE_VALUE + peak] && (peak = k);
+  if (slip <= desc[at + CURVE_SLIP + peak]) {
+    io[slot] = desc[at + CURVE_VALUE + peak];
+    return;
+  }
+  for (let k = peak + 1; k < n; k++) {
+    let s1 = desc[at + CURVE_SLIP + k];
+    if (slip < s1) {
+      let s0 = desc[at + CURVE_SLIP + k - 1], v0 = desc[at + CURVE_VALUE + k - 1];
+      io[slot] = v0 + (desc[at + CURVE_VALUE + k] - v0) * ((slip - s0) / (s1 - s0));
+      return;
+    }
+  }
+  io[slot] = desc[at + CURVE_VALUE + n - 1];
+}
+var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_RESULT = 5, R_IX = 6, R_IY = 7, R_IZ = 8, R_FX = 9, R_FY = 10, R_FZ = 11, R_CURVE = 12, R_VECTOR = 13, REG_WORDS = 16, AXIS_UP = 0, AXIS_FORWARD = 3, AXIS_LEFT = 6, AXES = Float64Array.of(0, 1, 0, 0, 0, 1, -1, 0, 0), VehicleSolver = class {
+  constructor(world) {
+    this.capacity = 0;
+    this.inputs = new Float32Array(0);
+    this.states = new Float32Array(0);
+    this.descs = new Float32Array(0);
+    this.runs = new Float64Array(0);
+    this.vehicles = new Float64Array(0);
+    this.active = new Int32Array(0);
+    this.activeCount = 0;
+    this.free = new Int32Array(0);
+    this.freeCount = 0;
+    this.chassis = new Float64Array((26));
+    this.origin = new Float64Array(3);
+    this.direction = new Float64Array(3);
+    this.hit = new Float64Array((8));
+    this.impulse = new Float64Array(3);
+    this.point = new Float64Array(3);
+    this.tmp = new Float64Array(12);
+    this.reg = new Float64Array((16));
+    this.world = world;
+  }
+  get count() {
+    return this.activeCount;
+  }
+  reserve(capacity) {
+    if (!(capacity <= this.capacity)) {
+      if (this.activeCount > 0) throw new GameError("invalid_argument", "vehicle capacity is fixed once vehicles exist");
+      this.capacity = capacity, this.inputs = new Float32Array(capacity * INPUT_STRIDE);
+      for (let v = 0; v < capacity; v++) this.inputs[v * INPUT_STRIDE + INPUT_GEAR] = GEAR_AUTO;
+      this.states = new Float32Array(capacity * STATE_STRIDE), this.descs = new Float32Array(capacity * VEHICLE_DESC_WORDS), this.runs = new Float64Array(capacity * MAX_WHEELS * (40)), this.vehicles = new Float64Array(capacity * (8)), this.active = new Int32Array(capacity), this.free = new Int32Array(capacity);
+      for (let v = 0; v < capacity; v++) this.free[v] = capacity - 1 - v;
+      this.freeCount = capacity;
+    }
+  }
+  createVehicle(body, desc) {
+    if (this.capacity === 0 && this.reserve((32)), this.freeCount === 0) throw new GameError("capacity_exceeded", "vehicle capacity reached");
+    let id = this.free[--this.freeCount];
+    this.descs.set(desc.subarray(0, VEHICLE_DESC_WORDS), id * VEHICLE_DESC_WORDS);
+    let v = id * (8);
+    this.vehicles.fill(0, v, v + (8)), this.vehicles[v + (0)] = body, this.vehicles[v + (2)] = 1, this.vehicles[v + (4)] = desc[DESC_IDLE_RPM];
+    let wheels = desc[DESC_WHEEL_COUNT];
+    for (let w = 0; w < MAX_WHEELS; w++) {
+      let r = (id * MAX_WHEELS + w) * (40);
+      this.runs.fill(0, r, r + (40)), this.runs[r + (5)] = NO_GROUND, this.runs[r + (6)] = (-1), w < wheels && (this.runs[r + (3)] = desc[DESC_HEADER + w * WHEEL_DESC_WORDS + WHEEL_DESC_REST]);
+    }
+    let input = id * INPUT_STRIDE;
+    return this.inputs.fill(0, input, input + INPUT_STRIDE), this.inputs[input + INPUT_GEAR] = GEAR_AUTO, this.states.fill(0, id * STATE_STRIDE, (id + 1) * STATE_STRIDE), this.active[this.activeCount++] = id, id;
+  }
+  destroyVehicle(vehicle) {
+    for (let k = 0; k < this.activeCount; k++)
+      if (this.active[k] === vehicle) {
+        this.active[k] = this.active[--this.activeCount], this.free[this.freeCount++] = vehicle;
+        return;
+      }
+    throw new GameError("unknown_resource", `vehicle ${vehicle} does not exist`);
+  }
+  releaseBody(body) {
+    for (let k = this.activeCount - 1; k >= 0; k--) {
+      let id = this.active[k];
+      this.vehicles[id * (8) + (0)] === body && this.destroyVehicle(id);
+    }
+  }
+  vehicleInputs() {
+    return this.inputs;
+  }
+  vehicleStates() {
+    return this.states;
+  }
+  update(dt) {
+    this.reg[(0)] = dt;
+    for (let k = 0; k < this.activeCount; k++) this.stepVehicle(this.active[k]);
+  }
+  stepVehicle(id) {
+    let reg = this.reg, dt = reg[(0)], v = id * (8), body = this.vehicles[v + (0)] | 0, d = id * VEHICLE_DESC_WORDS, desc = this.descs, i = id * INPUT_STRIDE, rawThrottle = this.inputs[i + INPUT_THROTTLE], rawBrake = this.inputs[i + INPUT_BRAKE], rawSteer = this.inputs[i + INPUT_STEER], rawHandbrake = this.inputs[i + INPUT_HANDBRAKE], throttle = rawThrottle > 0 ? rawThrottle < 1 ? rawThrottle : 1 : 0, brake = rawBrake > 0 ? rawBrake < 1 ? rawBrake : 1 : 0, steerInput = rawSteer > -1 ? rawSteer < 1 ? rawSteer : 1 : -1, handbrake = rawHandbrake > 0 ? rawHandbrake < 1 ? rawHandbrake : 1 : 0;
+    reg[(1)] = throttle, reg[(2)] = this.inputs[i + INPUT_GEAR];
+    let active = throttle > 0 || brake > 0 || steerInput !== 0 || handbrake > 0, c = this.chassis;
+    if (!this.world.readChassis(body, c)) return;
+    if (c[(25)] !== 0) {
+      if (!active) {
+        this.writeState(id);
+        return;
+      }
+      if (this.world.wakeChassis(body), !this.world.readChassis(body, c)) return;
+    }
+    let t = this.tmp;
+    this.rotate(AXES, (0), t, 0);
+    let ux = t[0], uy = t[1], uz = t[2];
+    this.rotate(AXES, (3), t, 0);
+    let fx = t[0], fy = t[1], fz = t[2];
+    reg[(9)] = fx, reg[(10)] = fy, reg[(11)] = fz;
+    let rate = desc[d + DESC_STEER_RATE] * dt, steerDelta = steerInput * desc[d + DESC_MAX_STEER] - this.vehicles[v + (1)];
+    this.vehicles[v + (1)] += steerDelta > -rate ? steerDelta < rate ? steerDelta : rate : -rate;
+    let steer = this.vehicles[v + (1)], wheels = desc[d + DESC_WHEEL_COUNT] | 0, runs = this.runs, ackermann = desc[d + DESC_ACKERMANN], fixedZ = 0, fixedCount = 0, allZ = 0;
+    for (let w = 0; w < wheels; w++) {
+      let wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS;
+      allZ += desc[wd + WHEEL_DESC_POSITION + 2], desc[wd + WHEEL_DESC_STEER] === 0 && (fixedZ += desc[wd + WHEEL_DESC_POSITION + 2], fixedCount++);
+    }
+    let pivot = fixedCount > 0 ? fixedZ / fixedCount : allZ / Math.max(wheels, 1);
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40), wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS;
+      this.rotate(desc, wd + WHEEL_DESC_POSITION, t, 0);
+      let hx = c[(0)] + t[0], hy = c[(0) + 1] + t[1], hz = c[(0) + 2] + t[2], base = steer * desc[wd + WHEEL_DESC_STEER], wheelAngle = base;
+      if (ackermann > 0 && base !== 0) {
+        let reach2 = desc[wd + WHEEL_DESC_POSITION + 2] - pivot, b = base > -STEER_LIMIT ? base < STEER_LIMIT ? base : STEER_LIMIT : -STEER_LIMIT, tangent = Math.sin(b) / Math.cos(b), denominator = desc[wd + WHEEL_DESC_POSITION] * tangent + reach2;
+        denominator * reach2 > (1e-4) && (wheelAngle = base + (Math.atan(reach2 * tangent / denominator) - base) * ackermann);
+      }
+      let angle = wheelAngle > -STEER_LIMIT ? wheelAngle < STEER_LIMIT ? wheelAngle : STEER_LIMIT : -STEER_LIMIT;
+      runs[r + (2)] = wheelAngle;
+      let s = Math.sin(angle), co = Math.cos(angle);
+      reg[(13)] = -s, reg[(13) + 1] = 0, reg[(13) + 2] = co, this.rotate(reg, (13), runs, r + (16)), reg[(13)] = -co, reg[(13) + 2] = -s, this.rotate(reg, (13), runs, r + (19));
+      let radius = desc[wd + WHEEL_DESC_RADIUS], rest = desc[wd + WHEEL_DESC_REST], travel = desc[wd + WHEEL_DESC_TRAVEL], shortest = rest - travel, longest = rest + travel, reach = longest + radius;
+      this.origin[0] = hx, this.origin[1] = hy, this.origin[2] = hz, this.direction[0] = -ux, this.direction[1] = -uy, this.direction[2] = -uz;
+      let hit = this.hit;
+      hit[(0)] = reach;
+      let collider = this.world.castWheel(body, this.origin, this.direction, hit);
+      if (collider !== NO_GROUND) {
+        let toi = hit[(0)], nx = hit[(1)], ny = hit[(1) + 1], nz = hit[(1) + 2];
+        nx * nx + ny * ny + nz * nz < 0.5 && (nx = ux, ny = uy, nz = uz), runs[r + (4)] = 1, runs[r + (13)] = nx, runs[r + (13) + 1] = ny, runs[r + (13) + 2] = nz;
+        let span = toi - radius;
+        runs[r + (3)] = span > shortest ? span < longest ? span : longest : shortest, runs[r + (10)] = hx - ux * toi, runs[r + (10) + 1] = hy - uy * toi, runs[r + (10) + 2] = hz - uz * toi, runs[r + (5)] = collider, runs[r + (6)] = hit[(7)], runs[r + (25)] = hit[(4)], runs[r + (25) + 1] = hit[(4) + 1], runs[r + (25) + 2] = hit[(4) + 2];
+      } else
+        runs[r + (4)] = 0, runs[r + (13)] = ux, runs[r + (13) + 1] = uy, runs[r + (13) + 2] = uz, runs[r + (3)] = longest, runs[r + (10)] = hx - ux * reach, runs[r + (10) + 1] = hy - uy * reach, runs[r + (10) + 2] = hz - uz * reach, runs[r + (5)] = NO_GROUND, runs[r + (6)] = (-1), runs[r + (25)] = 0, runs[r + (25) + 1] = 0, runs[r + (25) + 2] = 0;
+      let length = runs[r + (3)];
+      runs[r + (7)] = hx - ux * length, runs[r + (7) + 1] = hy - uy * length, runs[r + (7) + 2] = hz - uz * length;
+    }
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40), wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS;
+      if (runs[r + (4)] === 0) {
+        runs[r + (28)] = 0;
+        continue;
+      }
+      runs[r + (22)] = runs[r + (10)] - c[(13)], runs[r + (22) + 1] = runs[r + (10) + 1] - c[(13) + 1], runs[r + (22) + 2] = runs[r + (10) + 2] - c[(13) + 2], this.relativeVelocity(r, t);
+      let compression = -(t[0] * ux + t[1] * uy + t[2] * uz), damping = compression > 0 ? desc[wd + WHEEL_DESC_COMPRESSION] : desc[wd + WHEEL_DESC_RELAXATION], force = desc[wd + WHEEL_DESC_STIFFNESS] * (desc[wd + WHEEL_DESC_REST] - runs[r + (3)]) + damping * compression, maxForce = desc[wd + WHEEL_DESC_MAX_FORCE];
+      runs[r + (28)] = force > 0 ? force < maxForce ? force : maxForce : 0;
+    }
+    let antiRoll = desc[d + DESC_ANTI_ROLL];
+    if (antiRoll > 0)
+      for (let a = 0; a < wheels; a++) {
+        let axle = desc[d + DESC_HEADER + a * WHEEL_DESC_WORDS + WHEEL_DESC_AXLE];
+        if (axle !== NO_AXLE)
+          for (let b = a + 1; b < wheels; b++) {
+            if (desc[d + DESC_HEADER + b * WHEEL_DESC_WORDS + WHEEL_DESC_AXLE] !== axle) continue;
+            let ra = (id * MAX_WHEELS + a) * (40), rb = (id * MAX_WHEELS + b) * (40), bar = (runs[rb + (3)] - runs[ra + (3)]) * antiRoll;
+            runs[ra + (4)] !== 0 && (runs[ra + (28)] = Math.max(runs[ra + (28)] + bar, 0)), runs[rb + (4)] !== 0 && (runs[rb + (28)] = Math.max(runs[rb + (28)] - bar, 0));
+          }
+      }
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40);
+      if (runs[r + (4)] === 0 || runs[r + (28)] <= 0) continue;
+      let amount = runs[r + (28)] * dt;
+      reg[(6)] = runs[r + (13)] * amount, reg[(7)] = runs[r + (13) + 1] * amount, reg[(8)] = runs[r + (13) + 2] * amount, this.applyImpulse(r);
+    }
+    this.drivetrain(id, d, wheels);
+    let torque = reg[(3)], rolling = desc[d + DESC_ROLLING];
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40), wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS, inertia = runs[r + (37)], wheelTorque = torque * desc[wd + WHEEL_DESC_DRIVE] + desc[wd + WHEEL_DESC_SIDE] * desc[d + DESC_SKID_TORQUE] * steerInput, omega = runs[r + (0)] + wheelTorque / inertia * dt, braking = (brake * desc[wd + WHEEL_DESC_BRAKE] + handbrake * desc[wd + WHEEL_DESC_HANDBRAKE]) / inertia * dt, damping = runs[r + (4)] !== 0 ? rolling : (0.5);
+      omega -= omega * Math.min(damping * dt, 1), runs[r + (0)] = omega, runs[r + (38)] = braking, this.brakeTowardRest(r);
+    }
+    let handbrakeGrip = 1 + (desc[d + DESC_HANDBRAKE_GRIP] - 1) * handbrake, lift = desc[d + DESC_FORCE_HEIGHT];
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40), wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS;
+      if (runs[r + (35)] = 0, runs[r + (36)] = 0, runs[r + (4)] === 0) {
+        runs[r + (29)] = 0, runs[r + (30)] = 0;
+        continue;
+      }
+      if (lift > 0) {
+        let depth = (runs[r + (22)] * ux + runs[r + (22) + 1] * uy + runs[r + (22) + 2] * uz) * lift;
+        runs[r + (22)] -= ux * depth, runs[r + (22) + 1] -= uy * depth, runs[r + (22) + 2] -= uz * depth;
+      }
+      let nx = runs[r + (13)], ny = runs[r + (13) + 1], nz = runs[r + (13) + 2], ax = runs[r + (16)], ay = runs[r + (16) + 1], az = runs[r + (16) + 2], along2 = ax * nx + ay * ny + az * nz;
+      ax -= nx * along2, ay -= ny * along2, az -= nz * along2;
+      let length = Math.sqrt(ax * ax + ay * ay + az * az), inv = length > 1e-12 ? 1 / length : 0;
+      ax *= inv, ay *= inv, az *= inv, runs[r + (16)] = ax, runs[r + (16) + 1] = ay, runs[r + (16) + 2] = az, runs[r + (19)] = ay * nz - az * ny, runs[r + (19) + 1] = az * nx - ax * nz, runs[r + (19) + 2] = ax * ny - ay * nx, this.relativeVelocity(r, t);
+      let vl = t[0] * ax + t[1] * ay + t[2] * az, vt = t[0] * runs[r + (19)] + t[1] * runs[r + (19) + 1] + t[2] * runs[r + (19) + 2], floor = Math.max(Math.abs(vl), (0.5)), radius = desc[wd + WHEEL_DESC_RADIUS], inertia = runs[r + (37)];
+      runs[r + (29)] = (runs[r + (0)] * radius - vl) / floor, runs[r + (30)] = Math.abs(vt) / floor, this.inverseMassAlong(r, (16)), runs[r + (31)] = reg[(5)] + radius * radius / inertia, this.inverseMassAlong(r, (19)), runs[r + (32)] = reg[(5)];
+      let grip = desc[wd + WHEEL_DESC_HANDBRAKE] > 0 ? desc[wd + WHEEL_DESC_GRIP] * handbrakeGrip : desc[wd + WHEEL_DESC_GRIP], budget = runs[r + (28)] * dt * grip;
+      reg[(12)] = Math.abs(runs[r + (29)]), curve(desc, wd + WHEEL_DESC_LONGITUDINAL, reg, (12)), runs[r + (33)] = reg[(12)] * budget, reg[(12)] = runs[r + (30)], curve(desc, wd + WHEEL_DESC_LATERAL, reg, (12)), runs[r + (34)] = reg[(12)] * budget;
+    }
+    for (let iteration = 0; iteration < (4); iteration++)
+      for (let w = 0; w < wheels; w++) {
+        let r = (id * MAX_WHEELS + w) * (40);
+        if (runs[r + (4)] === 0 || runs[r + (28)] <= 0) continue;
+        let wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS, radius = desc[wd + WHEEL_DESC_RADIUS], inertia = runs[r + (37)];
+        this.relativeVelocity(r, t);
+        let vl = t[0] * runs[r + (16)] + t[1] * runs[r + (16) + 1] + t[2] * runs[r + (16) + 2], vt = t[0] * runs[r + (19)] + t[1] * runs[r + (19) + 1] + t[2] * runs[r + (19) + 2], long = runs[r + (35)] - (vl - runs[r + (0)] * radius) / runs[r + (31)], lat = runs[r + (32)] > 0 ? runs[r + (36)] - vt / runs[r + (32)] : runs[r + (36)], ll = runs[r + (33)], lt = runs[r + (34)];
+        if (ll <= 0 || lt <= 0)
+          long = 0, lat = 0;
+        else {
+          let x = long / ll, y = lat / lt, excess = x * x + y * y;
+          if (excess > 1) {
+            let shrink = 1 / Math.sqrt(excess);
+            long *= shrink, lat *= shrink;
+          }
+        }
+        let dl = long - runs[r + (35)], dt2 = lat - runs[r + (36)];
+        runs[r + (35)] = long, runs[r + (36)] = lat, reg[(6)] = runs[r + (16)] * dl + runs[r + (19)] * dt2, reg[(7)] = runs[r + (16) + 1] * dl + runs[r + (19) + 1] * dt2, reg[(8)] = runs[r + (16) + 2] * dl + runs[r + (19) + 2] * dt2, this.applyImpulse(r), runs[r + (0)] -= dl * radius / inertia;
+      }
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40);
+      runs[r + (38)] > 0 && this.brakeTowardRest(r);
+    }
+    this.lockDifferentials(id, d, wheels);
+    let along = c[(7)] * fx + c[(7) + 1] * fy + c[(7) + 2] * fz, downforce = desc[d + DESC_DOWNFORCE];
+    if (downforce > 0) {
+      let push = -downforce * along * along * dt;
+      c[(7)] += c[(16)] * ux * push, c[(7) + 1] += c[(16) + 1] * uy * push, c[(7) + 2] += c[(16) + 2] * uz * push;
+    }
+    let drag = desc[d + DESC_DRAG];
+    if (drag > 0) {
+      let lx = c[(7)], ly = c[(7) + 1], lz = c[(7) + 2], amount = drag * Math.sqrt(lx * lx + ly * ly + lz * lz) * dt;
+      for (let axis = 0; axis < 3; axis++)
+        c[(7) + axis] -= c[(7) + axis] * Math.min(amount * c[(16) + axis], 1);
+    }
+    this.vehicles[v + (5)] = c[(7)] * fx + c[(7) + 1] * fy + c[(7) + 2] * fz, this.lean(id, d);
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40), spin = runs[r + (1)] + runs[r + (0)] * dt;
+      spin > Math.PI ? spin -= TWO_PI : spin < -Math.PI && (spin += TWO_PI), runs[r + (1)] = spin;
+    }
+    this.world.writeChassis(body, c, active);
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40), ground = runs[r + (6)] | 0;
+      if (ground === (-1)) continue;
+      let long = runs[r + (35)], lat = runs[r + (36)], load = runs[r + (28)] * dt;
+      for (let axis = 0; axis < 3; axis++)
+        this.impulse[axis] = -(runs[r + (16) + axis] * long + runs[r + (19) + axis] * lat + runs[r + (13) + axis] * load), this.point[axis] = runs[r + (10) + axis];
+      this.world.applyImpulseAtPoint(ground, this.impulse, this.point);
+    }
+    this.writeState(id);
+  }
+  drivetrain(id, d, wheels) {
+    let desc = this.descs, runs = this.runs, reg = this.reg, throttle = reg[(1)], gearRequest = reg[(2)], dt = reg[(0)];
+    reg[(3)] = 0;
+    let v = id * (8), share = 0, spin = 0;
+    for (let w = 0; w < wheels; w++) {
+      let wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS, r = (id * MAX_WHEELS + w) * (40), drive2 = desc[wd + WHEEL_DESC_DRIVE];
+      share += drive2, spin += drive2 * runs[r + (0)], runs[r + (37)] = desc[wd + WHEEL_DESC_INERTIA];
+    }
+    let idle = desc[d + DESC_IDLE_RPM], maxRpm = desc[d + DESC_MAX_RPM];
+    if (share <= 0) {
+      this.vehicles[v + (4)] = idle;
+      return;
+    }
+    let omega = spin / share, count = desc[d + DESC_GEAR_COUNT], gear = this.vehicles[v + (2)];
+    this.ratio(d, gear | 0);
+    let rpm = Math.abs(omega * reg[(4)]) * (9.549297);
+    rpm = rpm < idle ? idle : rpm > maxRpm ? maxRpm : rpm;
+    let previous = gear;
+    if (gearRequest >= GEAR_AUTO ? gear <= 0 ? gear = 1 : this.vehicles[v + (3)] <= 0 && (rpm > desc[d + DESC_SHIFT_UP] && gear < count ? gear += 1 : rpm < desc[d + DESC_SHIFT_DOWN] && gear > 1 && (gear -= 1)) : Number.isFinite(gearRequest) && (gear = clamp(Math.trunc(clamp(gearRequest, -1, 8)), -1, count)), gear !== previous && (this.vehicles[v + (3)] = desc[d + DESC_SHIFT_SECONDS], this.ratio(d, gear | 0), rpm = Math.abs(omega * reg[(4)]) * (9.549297), rpm = rpm < idle ? idle : rpm > maxRpm ? maxRpm : rpm), this.vehicles[v + (2)] = gear, this.vehicles[v + (4)] = rpm, this.vehicles[v + (3)] = Math.max(this.vehicles[v + (3)] - dt, 0), this.vehicles[v + (3)] > 0 || gear === 0) return;
+    let points = desc[d + DESC_TORQUE_POINTS], curveTorque = desc[d + DESC_TORQUE + points - 1];
+    if (rpm <= desc[d + DESC_TORQUE_RPM]) curveTorque = desc[d + DESC_TORQUE];
+    else
+      for (let k = 1; k < points; k++) {
+        let r1 = desc[d + DESC_TORQUE_RPM + k];
+        if (rpm < r1) {
+          let r0 = desc[d + DESC_TORQUE_RPM + k - 1], t0 = desc[d + DESC_TORQUE + k - 1];
+          curveTorque = t0 + (desc[d + DESC_TORQUE + k] - t0) * ((rpm - r0) / (r1 - r0));
+          break;
+        }
+      }
+    let drive = rpm >= maxRpm ? 0 : throttle * curveTorque, span = (rpm - idle) / (maxRpm - idle), engine = drive - (1 - throttle) * desc[d + DESC_ENGINE_BRAKING] * Math.max(span, 0);
+    this.ratio(d, gear | 0);
+    let ratio = reg[(4)], reflected = desc[d + DESC_ENGINE_INERTIA] * ratio * ratio / share;
+    for (let w = 0; w < wheels; w++) {
+      let wd = d + DESC_HEADER + w * WHEEL_DESC_WORDS;
+      runs[(id * MAX_WHEELS + w) * (40) + (37)] = desc[wd + WHEEL_DESC_INERTIA] + reflected * desc[wd + WHEEL_DESC_DRIVE];
+    }
+    reg[(3)] = engine * ratio * desc[d + DESC_EFFICIENCY] / share;
+  }
+  brakeTowardRest(r) {
+    let runs = this.runs, omega = runs[r + (0)], left = runs[r + (38)];
+    Math.abs(omega) <= left ? (runs[r + (38)] = left - Math.abs(omega), runs[r + (0)] = 0) : (runs[r + (0)] = omega > 0 ? omega - left : omega + left, runs[r + (38)] = 0);
+  }
+  lockDifferentials(id, d, wheels) {
+    let desc = this.descs, runs = this.runs, lock = desc[d + DESC_DIFFERENTIAL_LOCK];
+    if (lock > 0)
+      for (let i = 0; i < wheels; i++) {
+        let wi = d + DESC_HEADER + i * WHEEL_DESC_WORDS, axle = desc[wi + WHEEL_DESC_AXLE];
+        if (desc[wi + WHEEL_DESC_DRIVE] <= 0 || axle === NO_AXLE) continue;
+        let first = true;
+        for (let j = 0; j < i; j++) {
+          let wj = d + DESC_HEADER + j * WHEEL_DESC_WORDS;
+          desc[wj + WHEEL_DESC_AXLE] === axle && desc[wj + WHEEL_DESC_DRIVE] > 0 && (first = false);
+        }
+        if (!first) continue;
+        let weight = 0, sum = 0;
+        for (let j = i; j < wheels; j++) {
+          let wj = d + DESC_HEADER + j * WHEEL_DESC_WORDS;
+          if (desc[wj + WHEEL_DESC_AXLE] !== axle || desc[wj + WHEEL_DESC_DRIVE] <= 0) continue;
+          let r = (id * MAX_WHEELS + j) * (40);
+          weight += runs[r + (37)], sum += runs[r + (37)] * runs[r + (0)];
+        }
+        let mean = sum / weight;
+        for (let j = i; j < wheels; j++) {
+          let wj = d + DESC_HEADER + j * WHEEL_DESC_WORDS;
+          if (desc[wj + WHEEL_DESC_AXLE] !== axle || desc[wj + WHEEL_DESC_DRIVE] <= 0) continue;
+          let r = (id * MAX_WHEELS + j) * (40);
+          runs[r + (0)] += (mean - runs[r + (0)]) * lock;
+        }
+      }
+    let center = desc[d + DESC_CENTER_LOCK];
+    if (center > 0) {
+      let weight = 0, sum = 0;
+      for (let j = 0; j < wheels; j++) {
+        if (desc[d + DESC_HEADER + j * WHEEL_DESC_WORDS + WHEEL_DESC_DRIVE] <= 0) continue;
+        let r = (id * MAX_WHEELS + j) * (40);
+        weight += runs[r + (37)], sum += runs[r + (37)] * runs[r + (0)];
+      }
+      if (weight > 0) {
+        let mean = sum / weight;
+        for (let j = 0; j < wheels; j++) {
+          if (desc[d + DESC_HEADER + j * WHEEL_DESC_WORDS + WHEEL_DESC_DRIVE] <= 0) continue;
+          let r = (id * MAX_WHEELS + j) * (40);
+          runs[r + (0)] += (mean - runs[r + (0)]) * center;
+        }
+      }
+    }
+  }
+  lean(id, d) {
+    let desc = this.descs, stiffness = desc[d + DESC_LEAN_STIFFNESS], damping = desc[d + DESC_LEAN_DAMPING];
+    if (stiffness <= 0 && damping <= 0) return;
+    let reg = this.reg, fx = reg[(9)], fy = reg[(10)], fz = reg[(11)], dt = reg[(0)], t = this.tmp;
+    this.rotate(AXES, (6), t, 9);
+    let roll = -t[10], v = id * (8), maxSteer = desc[d + DESC_MAX_STEER], steer = maxSteer > 0 ? this.vehicles[v + (1)] / maxSteer : 0, speed = Math.min(Math.abs(this.vehicles[v + (5)]) / desc[d + DESC_LEAN_SPEED], 1), leanAngle = steer * desc[d + DESC_LEAN_MAX] * speed, target = Math.sin(leanAngle > -STEER_LIMIT ? leanAngle < STEER_LIMIT ? leanAngle : STEER_LIMIT : -STEER_LIMIT), c = this.chassis, rate = c[(10)] * fx + c[(10) + 1] * fy + c[(10) + 2] * fz, impulse = (stiffness * (target - roll) - damping * rate) * dt;
+    this.rotate(AXES, (0), t, 0);
+    let wheels = desc[d + DESC_WHEEL_COUNT], height = 0, grounded = 0;
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40);
+      this.runs[r + (4)] !== 0 && (height += (c[(13)] - this.runs[r + (10)]) * t[0] + (c[(13) + 1] - this.runs[r + (10) + 1]) * t[1] + (c[(13) + 2] - this.runs[r + (10) + 2]) * t[2], grounded++);
+    }
+    if (grounded > 0 && height > 0) {
+      let push = impulse / (height / grounded);
+      c[(7)] += c[(16)] * t[9] * push, c[(7) + 1] += c[(16) + 1] * t[10] * push, c[(7) + 2] += c[(16) + 2] * t[11] * push;
+      return;
+    }
+    reg[(6)] = fx * impulse, reg[(7)] = fy * impulse, reg[(8)] = fz * impulse, this.inertiaApply(t, 6), c[(10)] += t[6], c[(10) + 1] += t[7], c[(10) + 2] += t[8];
+  }
+  ratio(d, gear) {
+    let desc = this.descs, reg = this.reg;
+    gear > 0 ? reg[(4)] = desc[d + DESC_RATIOS + gear - 1] * desc[d + DESC_FINAL_DRIVE] : gear === -1 ? reg[(4)] = -desc[d + DESC_REVERSE] * desc[d + DESC_FINAL_DRIVE] : reg[(4)] = 0;
+  }
+  rotate(vector, from, out, at) {
+    let c = this.chassis, qx = c[(3)], qy = c[(3) + 1], qz = c[(3) + 2], qw = c[(3) + 3], x = vector[from], y = vector[from + 1], z = vector[from + 2], tx = 2 * (qy * z - qz * y), ty = 2 * (qz * x - qx * z), tz = 2 * (qx * y - qy * x);
+    out[at] = x + qw * tx + (qy * tz - qz * ty), out[at + 1] = y + qw * ty + (qz * tx - qx * tz), out[at + 2] = z + qw * tz + (qx * ty - qy * tx);
+  }
+  relativeVelocity(r, out) {
+    let c = this.chassis, runs = this.runs, ox = runs[r + (22)], oy = runs[r + (22) + 1], oz = runs[r + (22) + 2], wx = c[(10)], wy = c[(10) + 1], wz = c[(10) + 2];
+    out[0] = c[(7)] + (wy * oz - wz * oy) - runs[r + (25)], out[1] = c[(7) + 1] + (wz * ox - wx * oz) - runs[r + (25) + 1], out[2] = c[(7) + 2] + (wx * oy - wy * ox) - runs[r + (25) + 2];
+  }
+  inertiaApply(out, at) {
+    let c = this.chassis, reg = this.reg, x = reg[(6)], y = reg[(7)], z = reg[(8)], m11 = c[(19)], m12 = c[(19) + 1], m13 = c[(19) + 2], m22 = c[(19) + 3], m23 = c[(19) + 4], m33 = c[(19) + 5];
+    out[at] = m11 * x + m12 * y + m13 * z, out[at + 1] = m12 * x + m22 * y + m23 * z, out[at + 2] = m13 * x + m23 * y + m33 * z;
+  }
+  inverseMassAlong(r, axis) {
+    let c = this.chassis, runs = this.runs, reg = this.reg, dx = runs[r + axis], dy = runs[r + axis + 1], dz = runs[r + axis + 2], ox = runs[r + (22)], oy = runs[r + (22) + 1], oz = runs[r + (22) + 2], tx = oy * dz - oz * dy, ty = oz * dx - ox * dz, tz = ox * dy - oy * dx;
+    reg[(6)] = tx, reg[(7)] = ty, reg[(8)] = tz;
+    let t = this.tmp;
+    this.inertiaApply(t, 3), reg[(5)] = dx * c[(16)] * dx + dy * c[(16) + 1] * dy + dz * c[(16) + 2] * dz + tx * t[3] + ty * t[4] + tz * t[5];
+  }
+  applyImpulse(r) {
+    let c = this.chassis, runs = this.runs, reg = this.reg, ix = reg[(6)], iy = reg[(7)], iz = reg[(8)];
+    c[(7)] += c[(16)] * ix, c[(7) + 1] += c[(16) + 1] * iy, c[(7) + 2] += c[(16) + 2] * iz;
+    let ox = runs[r + (22)], oy = runs[r + (22) + 1], oz = runs[r + (22) + 2];
+    reg[(6)] = oy * iz - oz * iy, reg[(7)] = oz * ix - ox * iz, reg[(8)] = ox * iy - oy * ix;
+    let t = this.tmp;
+    this.inertiaApply(t, 6), c[(10)] += t[6], c[(10) + 1] += t[7], c[(10) + 2] += t[8];
+  }
+  writeState(id) {
+    let dt = this.reg[(0)], s = this.states, o = id * STATE_STRIDE, v = id * (8), runs = this.runs;
+    s[o + STATE_SPEED] = this.vehicles[v + (5)], s[o + STATE_RPM] = this.vehicles[v + (4)], s[o + STATE_GEAR] = this.vehicles[v + (2)], s[o + STATE_STEER] = this.vehicles[v + (1)], s[o + STATE_SHIFTING] = this.vehicles[v + (3)] > 0 ? 1 : 0;
+    let wheels = this.descs[id * VEHICLE_DESC_WORDS + DESC_WHEEL_COUNT], grounded = 0;
+    for (let w = 0; w < wheels; w++) {
+      let r = (id * MAX_WHEELS + w) * (40), at = o + STATE_HEADER + w * WHEEL_STRIDE;
+      s[at + WHEEL_CENTER] = runs[r + (7)], s[at + WHEEL_CENTER + 1] = runs[r + (7) + 1], s[at + WHEEL_CENTER + 2] = runs[r + (7) + 2], s[at + WHEEL_SPIN] = runs[r + (1)], s[at + WHEEL_STEER] = runs[r + (2)], s[at + WHEEL_LENGTH] = runs[r + (3)], s[at + WHEEL_GROUND] = runs[r + (5)], s[at + WHEEL_POINT] = runs[r + (10)], s[at + WHEEL_POINT + 1] = runs[r + (10) + 1], s[at + WHEEL_POINT + 2] = runs[r + (10) + 2], s[at + WHEEL_SLIP] = runs[r + (29)], s[at + WHEEL_SLIP_ANGLE] = runs[r + (30)], s[at + WHEEL_LOAD] = runs[r + (28)], s[at + WHEEL_OMEGA] = runs[r + (0)], s[at + WHEEL_FORCE_LONG] = runs[r + (35)] / dt, s[at + WHEEL_FORCE_LAT] = runs[r + (36)] / dt, runs[r + (4)] !== 0 && grounded++;
+    }
+    s[o + STATE_GROUNDED] = grounded;
+  }
+};
+
+export { CHASSIS_ANGULAR, CHASSIS_COM, CHASSIS_INV_INERTIA, CHASSIS_INV_MASS, CHASSIS_LINEAR, CHASSIS_Q, CHASSIS_SLEEPING, CHASSIS_T, HIT_GROUND_BODY, HIT_GROUND_VELOCITY, HIT_NORMAL, HIT_REACH, HIT_TOI, NO_BODY, VehicleSolver };