@adatechnology/game-vehicles-driving 0.0.0-stage → 0.2.0

package/dist/index.global.js

@@ -0,0 +1,529 @@
+"use strict";
+var GameVehiclesDriving = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    bodyDamage: () => bodyDamage,
+    createArcadeDriver: () => createArcadeDriver,
+    createSemiSimDriver: () => createSemiSimDriver,
+    createSurfaces: () => createSurfaces,
+    defaultArcadeSpec: () => defaultArcadeSpec,
+    defaultFuelModel: () => defaultFuelModel,
+    defaultSemiSpec: () => defaultSemiSpec,
+    defaultSurfaces: () => defaultSurfaces,
+    fuelRate: () => fuelRate,
+    impactEnergy: () => impactEnergy,
+    runOver: () => runOver,
+    semiSpecFromStats: () => semiSpecFromStats,
+    speedLoss: () => speedLoss,
+    surfaceGrip: () => surfaceGrip,
+    vehicleCorners: () => vehicleCorners,
+    vehicleDamageFromImpact: () => vehicleDamageFromImpact
+  });
+
+  // src/arcade.ts
+  var defaultArcadeSpec = {
+    length: 4.3,
+    width: 1.9,
+    accel: 5.5,
+    brakeAgainstMotion: 12,
+    reverseAccel: 3,
+    drag: 0.5,
+    handbrakeDrag: 3,
+    maxForward: 17,
+    maxReverse: -5,
+    steerMax: 0.55,
+    steerResponse: 5,
+    wheelbase: 2.6,
+    engineNoiseInterval: 0.5,
+    engineNoiseBase: 25,
+    engineNoiseSpeedFactor: 2,
+    hornNoiseRadius: 120,
+    crash: { minSpeed: 0.5, damageSpeed: 4, damage: 9, shakeDivisor: 20, hurtSpeed: 9, hurtFactor: 1.2, bounce: -0.25, noiseRadius: 25 },
+    runOver: { knockSpeed: 3, killSpeed: 8, knockDamage: 2.5, stunSeconds: 1.4, throwFactor: 0.8, sideKick: 2, knockSlow: 0.93, killVehicleDamage: 3, holdDrag: 2.5, margin: 0.3 }
+  };
+  function vehicleCorners(spec, x, z, yaw) {
+    const c = Math.cos(yaw);
+    const s = Math.sin(yaw);
+    const hl = spec.length / 2;
+    const hw = spec.width / 2;
+    const out = [];
+    for (const [a, b] of [[hl, hw], [hl, -hw], [-hl, hw], [-hl, -hw], [hl, 0], [-hl, 0], [0, hw], [0, -hw]]) out.push([x + a * c + b * s, z - a * s + b * c]);
+    return out;
+  }
+  var clamp = (x, a, b) => Math.max(a, Math.min(b, x));
+  var lerp = (a, b, t) => a + (b - a) * t;
+  function createArcadeDriver(options = {}) {
+    const spec = {
+      ...defaultArcadeSpec,
+      ...options,
+      crash: { ...defaultArcadeSpec.crash, ...options.crash || {} },
+      runOver: { ...defaultArcadeSpec.runOver, ...options.runOver || {} }
+    };
+    const state = { x: 0, z: 0, yaw: 0, v: 0, steer: 0, noiseTimer: 0 };
+    const step = (input, dt, world) => {
+      const events = [];
+      const f = (input.throttle > 0 ? 1 : 0) - (input.brake > 0 ? 1 : 0);
+      if (f > 0) state.v += (state.v < 0 ? spec.brakeAgainstMotion : spec.accel) * dt * Math.min(1, input.throttle);
+      else if (f < 0) state.v -= (state.v > 0 ? spec.brakeAgainstMotion : spec.reverseAccel) * dt * Math.min(1, input.brake);
+      else state.v *= Math.exp(-spec.drag * dt);
+      if (input.handbrake) state.v *= Math.exp(-spec.handbrakeDrag * dt);
+      state.v = clamp(state.v, spec.maxReverse, spec.maxForward);
+      state.steer = lerp(state.steer, clamp(input.steer, -1, 1) * spec.steerMax, Math.min(1, dt * spec.steerResponse));
+      const nyaw = state.yaw + state.steer * state.v / spec.wheelbase * dt;
+      const fx = Math.cos(nyaw);
+      const fz = -Math.sin(nyaw);
+      const nx = state.x + fx * state.v * dt;
+      const nz = state.z + fz * state.v * dt;
+      if (!world.blocked(nx, nz, nyaw)) {
+        state.x = nx;
+        state.z = nz;
+        state.yaw = nyaw;
+      } else if (Math.abs(state.v) > spec.crash.minSpeed) {
+        const sp2 = Math.abs(state.v);
+        if (sp2 > spec.crash.damageSpeed) {
+          events.push({ type: "crash", speed: sp2, damage: sp2 * spec.crash.damage, shake: sp2 / spec.crash.shakeDivisor, hurtDriver: sp2 > spec.crash.hurtSpeed ? sp2 * spec.crash.hurtFactor : 0 });
+          events.push({ type: "noise", radius: spec.crash.noiseRadius, x: state.x, z: state.z, source: "crash" });
+        }
+        state.v *= spec.crash.bounce;
+      }
+      const sp = Math.abs(state.v);
+      const ro = spec.runOver;
+      const bodies = world.bodies ? world.bodies() : [];
+      for (let i = 0; i < bodies.length; i++) {
+        const body = bodies[i];
+        if (!body) continue;
+        const dx = body.x - state.x;
+        const dz = body.z - state.z;
+        const a = dx * fx + dz * fz;
+        const b = -dx * fz + dz * fx;
+        if (Math.abs(a) > spec.length / 2 + ro.margin || Math.abs(b) > spec.width / 2 + ro.margin) continue;
+        if (sp > ro.killSpeed) events.push({ type: "run_over", outcome: "kill", index: i, speed: sp, vehicleDamage: ro.killVehicleDamage });
+        else if (sp > ro.knockSpeed) {
+          events.push({
+            type: "run_over",
+            outcome: "knock",
+            index: i,
+            speed: sp,
+            damage: sp * sp * ro.knockDamage,
+            stunSeconds: ro.stunSeconds,
+            vx: fx * sp * ro.throwFactor + (b > 0 ? -fz : fz) * ro.sideKick,
+            vz: fz * sp * ro.throwFactor + (b > 0 ? fx : -fx) * ro.sideKick,
+            slow: ro.knockSlow
+          });
+          state.v *= ro.knockSlow;
+        } else {
+          state.v *= Math.exp(-ro.holdDrag * dt);
+          events.push({ type: "run_over", outcome: "push", index: i, speed: sp, dx: (b > 0 ? -fz : fz) * dt, dz: (b > 0 ? fx : -fx) * dt });
+        }
+      }
+      state.noiseTimer -= dt;
+      if (state.noiseTimer <= 0) {
+        state.noiseTimer = spec.engineNoiseInterval;
+        events.push({ type: "noise", radius: spec.engineNoiseBase + sp * spec.engineNoiseSpeedFactor, x: state.x, z: state.z, source: "engine" });
+      }
+      if (input.horn) {
+        events.push({ type: "noise", radius: spec.hornNoiseRadius, x: state.x, z: state.z, source: "horn" });
+        events.push({ type: "horn" });
+      }
+      return { state, events };
+    };
+    return {
+      spec,
+      state,
+      step,
+      place(x, z, yaw) {
+        state.x = x;
+        state.z = z;
+        state.yaw = yaw;
+        state.v = 0;
+        state.steer = 0;
+      }
+    };
+  }
+
+  // src/run-over.ts
+  function runOver(speed, rules = {}) {
+    const { knockSpeed, killSpeed } = { ...defaultArcadeSpec.runOver, ...rules };
+    const s = Math.abs(speed);
+    return s > killSpeed ? "kill" : s > knockSpeed ? "knock" : "push";
+  }
+
+  // src/semi/fuel.ts
+  var defaultFuelModel = { idleRate: 3e-4, fullRate: 35e-4, loadFactor: 0.5, damagedEngineExtra: 0.4 };
+  function fuelRate(model, rpmFraction, throttle, loadRatio, engineHealth) {
+    const base = model.idleRate + model.fullRate * Math.max(0, Math.min(1, rpmFraction)) * Math.max(0, Math.min(1, throttle));
+    return base * (1 + model.loadFactor * Math.max(0, loadRatio)) * (1 + model.damagedEngineExtra * (1 - Math.max(0, Math.min(1, engineHealth))));
+  }
+
+  // ../game-contracts/dist/index.js
+  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result[key];
+      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result;
+  };
+  var mergeById = (shipped, extra) => {
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+    return entries;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) entries.delete(id);
+  };
+
+  // src/semi/surfaces.ts
+  var defaultSurfaces = [
+    { id: "dry_asphalt", grip: 1 },
+    { id: "wet_asphalt", grip: 0.75, aquaplaningKmh: 90, aquaplaningFactor: 0.4, aquaplaningBand: 30 },
+    { id: "dirt", grip: 0.65 },
+    { id: "grass", grip: 0.55 },
+    { id: "mud", grip: 0.4, bogs: true },
+    /** Blood and bodies after a run-over; a driver applies it for a few seconds with `contaminate`. */
+    { id: "blood", grip: 0.5 }
+  ];
+  function createSurfaces(options = {}) {
+    const entries = mergeById(defaultSurfaces, options.packs?.flatMap((pack) => pack.surfaces ?? []));
+    applyPatches(entries, options.patch);
+    removeIds(entries, options.remove);
+    const fallback = entries.get("dry_asphalt") ?? { id: "dry_asphalt", grip: 1 };
+    return {
+      get: (id) => entries.get(id) ?? fallback,
+      get surfaces() {
+        return [...entries.values()];
+      }
+    };
+  }
+  function surfaceGrip(surface, speedMetresPerSecond) {
+    if (surface.aquaplaningKmh == null) return surface.grip;
+    const kmh = Math.abs(speedMetresPerSecond) * 3.6;
+    const band = surface.aquaplaningBand ?? 30;
+    const t = Math.max(0, Math.min(1, (kmh - surface.aquaplaningKmh) / band));
+    return surface.grip * (1 - (1 - (surface.aquaplaningFactor ?? 0.4)) * t);
+  }
+
+  // src/semi/driver.ts
+  var G = 9.81;
+  var clamp2 = (x, a, b) => Math.max(a, Math.min(b, x));
+  var MAX_SUBSTEP = 1 / 240;
+  var FLAT_BELOW = 0.2;
+  var STALL_HEALTH = 0.3;
+  var defaultSemiSpec = {
+    mass: 1300,
+    centreHeight: 0.5,
+    wheels: [
+      { x: 1.3, z: -0.75, steer: true },
+      { x: 1.3, z: 0.75, steer: true },
+      { x: -1.3, z: -0.75, drive: true, handbrake: true },
+      { x: -1.3, z: 0.75, drive: true, handbrake: true }
+    ],
+    wheelRadius: 0.32,
+    fourWheelDrive: false,
+    drag: 0.4,
+    rolling: 0.015,
+    bogResistance: 0.3,
+    maxSteer: 0.55,
+    brakeForce: 14e3,
+    engine: { idleRpm: 900, peakRpm: 4200, redlineRpm: 6500, peakTorque: 220 },
+    gears: [3.6, 2.2, 1.5, 1.1, 0.85],
+    reverseRatio: 3.4,
+    finalDrive: 3.7,
+    efficiency: 0.85,
+    upshiftFraction: 0.85,
+    downshiftFraction: 0.35,
+    suspension: { restLength: 0.4, spring: 32e3, damper: 3200 },
+    tyre: { friction: 1.05, corneringStiffness: 9 },
+    tank: { capacity: 45 }
+  };
+  var torqueAt = (spec, rpm) => {
+    const e = spec.engine;
+    if (rpm >= e.redlineRpm) return 0;
+    const t = rpm <= e.peakRpm ? 0.7 + 0.3 * clamp2((rpm - e.idleRpm) / (e.peakRpm - e.idleRpm), 0, 1) : 1 - 0.4 * ((rpm - e.peakRpm) / (e.redlineRpm - e.peakRpm));
+    return e.peakTorque * t;
+  };
+  function createSemiSimDriver(specification = {}, options = {}) {
+    const spec = { ...defaultSemiSpec, ...specification };
+    const surfaces = options.surfaces ?? createSurfaces();
+    const fuelModel = { ...defaultFuelModel, ...spec.tank };
+    const wheelbase = Math.max(...spec.wheels.map((w) => w.x)) - Math.min(...spec.wheels.map((w) => w.x));
+    const track = Math.max(...spec.wheels.map((w) => w.z)) - Math.min(...spec.wheels.map((w) => w.z));
+    const baseMass = spec.mass;
+    let cargo = 0;
+    let contamination = null;
+    const n = spec.wheels.length;
+    const state = {
+      x: 0,
+      z: 0,
+      yaw: 0,
+      u: 0,
+      w: 0,
+      yawRate: 0,
+      height: spec.suspension.restLength + spec.wheelRadius - spec.mass * G / (specification.wheels ? specification.wheels.length : defaultSemiSpec.wheels.length) / spec.suspension.spring,
+      heightRate: 0,
+      pitch: 0,
+      pitchRate: 0,
+      roll: 0,
+      rollRate: 0,
+      rpm: spec.engine.idleRpm,
+      gear: 1,
+      engineOn: true,
+      bogged: false,
+      fuel: spec.tank.capacity,
+      loads: new Array(n).fill(baseMass * G / n),
+      slip: new Array(n).fill(0),
+      steerAngle: 0
+    };
+    const driver = {
+      spec,
+      state,
+      condition: {},
+      setCargo(kg) {
+        cargo = Math.max(0, kg);
+      },
+      contaminate(surfaceId, seconds) {
+        contamination = { id: surfaceId, left: seconds };
+      },
+      refuel(litres) {
+        state.fuel = Math.min(spec.tank.capacity, state.fuel + litres);
+      },
+      place(x, z, yaw) {
+        state.x = x;
+        state.z = z;
+        state.yaw = yaw;
+        state.u = state.w = state.yawRate = 0;
+      },
+      step(input, dt, world = {}) {
+        const events = [];
+        const steps = Math.max(1, Math.ceil(dt / MAX_SUBSTEP));
+        const h = dt / steps;
+        for (let s = 0; s < steps; s++) substep(input, h, world, events);
+        return { state, events };
+      }
+    };
+    const stallWatch = { throttleTime: 0 };
+    function substep(input, dt, world, events) {
+      const cond = driver.condition;
+      const mass = baseMass + cargo;
+      const engineHealth = clamp2(cond.engine ?? 1, 0, 1);
+      const suspensionHealth = clamp2(cond.suspension ?? 1, 0, 1);
+      const inertia = (spec.yawInertia ?? baseMass * (wheelbase * wheelbase + track * track) / 12) * (mass / baseMass);
+      const pitchInertia = mass * (wheelbase * wheelbase + 1) / 12;
+      const rollInertia = mass * (track * track + 1) / 12;
+      if (contamination) {
+        contamination.left -= dt;
+        if (contamination.left <= 0) contamination = null;
+      }
+      const cs = Math.cos(state.yaw);
+      const sn = Math.sin(state.yaw);
+      const target = clamp2(input.steer, -1, 1) * spec.maxSteer;
+      state.steerAngle += (target - state.steerAngle) * Math.min(1, dt * 8);
+      let gear = state.gear;
+      if (input.gear != null) gear = input.gear;
+      else if (state.u < 0.5 && input.brake > 0 && input.throttle <= 0) gear = -1;
+      else if (gear <= 0 && !(gear === -1 && state.u < 0.5 && input.throttle <= 0)) gear = 1;
+      const ratioOf = (g) => g < 0 ? spec.reverseRatio : g === 0 ? 0 : spec.gears[g - 1];
+      const driveWheels = spec.wheels.map((w, i) => ({ w, i })).filter(({ w }) => spec.fourWheelDrive ? true : w.drive);
+      let driveSpeed = 0;
+      for (const { w } of driveWheels) driveSpeed += state.u + state.yawRate * w.z;
+      driveSpeed /= Math.max(1, driveWheels.length);
+      const wheelRpm = Math.abs(driveSpeed) / spec.wheelRadius * (60 / (2 * Math.PI));
+      if (input.gear == null && gear > 0) {
+        if (wheelRpm * ratioOf(gear) * spec.finalDrive > spec.engine.redlineRpm * spec.upshiftFraction && gear < spec.gears.length) gear++;
+        else if (gear > 1 && wheelRpm * ratioOf(gear) * spec.finalDrive < spec.engine.redlineRpm * spec.downshiftFraction) gear--;
+      }
+      if (gear !== state.gear) {
+        state.gear = gear;
+        events.push({ type: "shift", gear });
+      }
+      const reversing = state.gear < 0;
+      const accelInput = reversing ? input.brake : input.throttle;
+      const brakeInput = clamp2(reversing ? input.throttle : input.brake, 0, 1);
+      const ratio = ratioOf(state.gear) * spec.finalDrive;
+      state.rpm = clamp2(wheelRpm * ratio, spec.engine.idleRpm, spec.engine.redlineRpm + 200);
+      if (!state.engineOn || state.fuel <= 0) state.rpm = 0;
+      let throttle = clamp2(accelInput, 0, 1);
+      if (engineHealth < STALL_HEALTH && throttle > 0.8) {
+        stallWatch.throttleTime += dt;
+        if (state.pitch > 0.06 && stallWatch.throttleTime > 0.5 && state.engineOn) {
+          state.engineOn = false;
+          events.push({ type: "stall" });
+        }
+        throttle *= 0.5;
+      } else stallWatch.throttleTime = 0;
+      if (!state.engineOn && accelInput > 0 && Math.abs(state.u) < 0.5 && engineHealth >= STALL_HEALTH && state.fuel > 0) state.engineOn = true;
+      if (state.fuel <= 0 && state.engineOn) {
+        state.engineOn = false;
+        events.push({ type: "out_of_fuel" });
+      }
+      const engineTorque = state.engineOn ? torqueAt(spec, state.rpm) * throttle * (0.55 + 0.45 * engineHealth) : 0;
+      const driveForceTotal = state.gear === 0 ? 0 : (reversing ? -1 : 1) * engineTorque * ratio * spec.efficiency / spec.wheelRadius;
+      if (state.engineOn) {
+        const burned = fuelRate(fuelModel, state.rpm / spec.engine.redlineRpm, throttle, cargo / baseMass, engineHealth) * dt;
+        state.fuel = Math.max(0, state.fuel - burned);
+      }
+      const ride = spec.suspension.restLength;
+      let sumN = 0;
+      let sumNA = 0;
+      let sumNB = 0;
+      const wheelState = [];
+      let bogging = false;
+      for (let i = 0; i < n; i++) {
+        const w = spec.wheels[i];
+        const wx = state.x + w.x * cs + w.z * sn;
+        const wz = state.z - w.x * sn + w.z * cs;
+        const ground = world.ground ? world.ground(wx, wz) : {};
+        const surface = surfaces.get(contamination && contamination.left > 0 && surfaces.get(contamination.id).grip < surfaces.get(ground.surface ?? "dry_asphalt").grip ? contamination.id : ground.surface ?? "dry_asphalt");
+        const top = state.height + w.x * state.pitch - w.z * state.roll;
+        const length = top - (ground.height ?? 0) - spec.wheelRadius;
+        const compression = ride - length;
+        const rate = -(state.heightRate + w.x * state.pitchRate - w.z * state.rollRate);
+        const k = spec.suspension.spring * (0.5 + 0.5 * suspensionHealth);
+        const c = spec.suspension.damper * (0.5 + 0.5 * suspensionHealth);
+        const load = Math.max(0, k * compression + c * rate);
+        const tyreHealth = cond.tyres ? clamp2(cond.tyres[i] ?? 1, 0, 1) : 1;
+        const flat = tyreHealth < FLAT_BELOW;
+        const bog = !!surface.bogs && !spec.fourWheelDrive;
+        if (bog) bogging = true;
+        const grip = surfaceGrip(surface, state.u) * (flat ? 0.5 : 1);
+        wheelState.push({ n: load, grip, surface: surface.id, bog, flat });
+        sumN += load;
+        sumNA += load * w.x;
+        sumNB += load * w.z;
+      }
+      let fFwd = 0;
+      let fRight = 0;
+      let torque = 0;
+      let pitchTorque = 0;
+      let rollTorque = 0;
+      const handbrake = !!input.handbrake;
+      const loadSum = Math.max(1, wheelState.reduce((a, b) => a + b.n, 0));
+      const drivenCount = Math.max(1, driveWheels.length);
+      for (let i = 0; i < n; i++) {
+        const w = spec.wheels[i];
+        const ws = wheelState[i];
+        const delta = w.steer ? state.steerAngle : 0;
+        const cd = Math.cos(delta);
+        const sd = Math.sin(delta);
+        const vxw = state.u + state.yawRate * w.z;
+        const vyw = state.w - state.yawRate * w.x;
+        const vl = vxw * cd - vyw * sd;
+        const vc = vxw * sd + vyw * cd;
+        const capacity = spec.tyre.friction * ws.grip * ws.n;
+        let fl = 0;
+        if (driveWheels.some((d) => d.i === i)) fl += driveForceTotal / drivenCount;
+        const locked = handbrake && w.handbrake;
+        const brakeShare = spec.brakeForce * brakeInput * ws.n / loadSum;
+        const moving = Math.abs(vl) > 0.05;
+        if (locked) fl += moving ? -Math.sign(vl) * capacity : 0;
+        else if (brakeShare > 0 && moving) fl += -Math.sign(vl) * brakeShare;
+        const rolling = ws.bog && accelInput > 0 ? spec.bogResistance : spec.rolling * (ws.flat ? 6 : 1);
+        const alpha = Math.atan2(vc, Math.abs(vl) + 0.5);
+        let fc = -Math.tanh(spec.tyre.corneringStiffness * alpha) * capacity;
+        if (locked) fc *= 0.6;
+        const total = Math.hypot(fl, fc);
+        let used = 1;
+        if (total > capacity && total > 0) used = capacity / total;
+        fl *= used;
+        fc *= used;
+        if (moving) fl += -Math.sign(vl) * rolling * ws.n;
+        const slipRatio = capacity > 0 ? clamp2(total / capacity, 0, 1) : 0;
+        state.slip[i] = slipRatio;
+        if (ws.surface === "wet_asphalt" && Math.abs(state.u) * 3.6 > (surfaces.get(ws.surface).aquaplaningKmh ?? 1e9) && slipRatio >= 0.99) events.push({ type: "aquaplaning", wheel: i });
+        const fx = fl * cd + fc * sd;
+        const fy = -fl * sd + fc * cd;
+        fFwd += fx;
+        fRight += fy;
+        torque += w.z * fx - w.x * fy;
+        pitchTorque += fx * spec.centreHeight;
+        rollTorque += -fy * spec.centreHeight;
+      }
+      const bogNow = bogging && Math.abs(state.u) < 1 && accelInput > 0;
+      if (bogNow && !state.bogged) events.push({ type: "bogged" });
+      state.bogged = bogNow;
+      fFwd += -spec.drag * state.u * Math.abs(state.u);
+      fRight += -spec.drag * state.w * Math.abs(state.w);
+      const du = fFwd / mass - state.yawRate * state.w;
+      const dw = fRight / mass + state.yawRate * state.u;
+      state.u += du * dt;
+      state.w += dw * dt;
+      if (Math.abs(state.u) < 0.02 && accelInput <= 0) state.u = 0;
+      state.yawRate += torque / inertia * dt;
+      state.yaw += state.yawRate * dt;
+      const csn = Math.cos(state.yaw);
+      const snn = Math.sin(state.yaw);
+      state.x += (state.u * csn + state.w * snn) * dt;
+      state.z += (-state.u * snn + state.w * csn) * dt;
+      const ay = (sumN - mass * G) / mass;
+      state.heightRate += ay * dt;
+      state.height += state.heightRate * dt;
+      state.pitchRate += (sumNA + pitchTorque) / pitchInertia * dt;
+      state.pitch += state.pitchRate * dt;
+      state.rollRate += (-sumNB + rollTorque) / rollInertia * dt;
+      state.roll += state.rollRate * dt;
+      for (let i = 0; i < n; i++) state.loads[i] = wheelState[i].n;
+    }
+    return driver;
+  }
+
+  // src/semi/impact.ts
+  var impactEnergy = (vehicleMass, relativeSpeed) => 0.5 * vehicleMass * relativeSpeed * relativeSpeed;
+  var bodyDamage = (energy, bumperMultiplier, zoneFactor) => energy * bumperMultiplier * zoneFactor;
+  var vehicleDamageFromImpact = (energy, frontArmor, factor = 0.04) => energy * factor * (1 - frontArmor);
+  var speedLoss = (bodyMass, vehicleMass, speed) => bodyMass / (vehicleMass + bodyMass) * speed;
+
+  // src/semi/from-stats.ts
+  function semiSpecFromStats(stats, body, base = {}) {
+    const spec = { ...defaultSemiSpec, ...base };
+    const half = body.wheelbase / 2;
+    const side = body.track / 2;
+    const driveAll = !!body.fourWheelDrive;
+    const wheels = [
+      { x: half, z: -side, steer: true, drive: driveAll },
+      { x: half, z: side, steer: true, drive: driveAll },
+      { x: -half, z: -side, drive: true, handbrake: true },
+      { x: -half, z: side, drive: true, handbrake: true }
+    ];
+    const peakTorque = body.mass * (0.06 + 0.015 * stats.acceleration);
+    const engine = { ...spec.engine, peakTorque };
+    const top = stats.maxSpeedKmh / 3.6;
+    const lastRatio = engine.redlineRpm * 0.95 * 2 * Math.PI * spec.wheelRadius / (60 * top * spec.finalDrive);
+    const gears = [...spec.gears.slice(0, -1).map((g, i, all) => Math.max(g, lastRatio * 1.25 ** (all.length - i))), lastRatio];
+    const torqueAtTop = peakTorque * 0.76;
+    const thrust = torqueAtTop * lastRatio * spec.finalDrive * spec.efficiency / spec.wheelRadius;
+    const rollingForce = spec.rolling * body.mass * 9.81;
+    const drag = Math.max(0.01, (thrust - rollingForce) / (top * top));
+    return { ...spec, mass: body.mass, wheels, fourWheelDrive: driveAll, engine, gears, drag, tyre: { ...spec.tyre, friction: 0.8 + 0.03 * stats.handling } };
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map