@inventure71/paddockjs 4.1.0 → 4.3.0

package/src/simulation/vehicle/vehicleGeometry.js

@@ -110,24 +110,6 @@ function writeOrientedRectValues(target, {
   return rect;
 }
 
-function writeOrientedRect(target, { id, type, center, heading, length, width }) {
-  const cos = Math.cos(heading);
-  const sin = Math.sin(heading);
-  return writeOrientedRectValues(target, {
-    id,
-    type,
-    centerX: center.x,
-    centerY: center.y,
-    heading,
-    length,
-    width,
-    forwardX: cos,
-    forwardY: sin,
-    rightX: -sin,
-    rightY: cos,
-  });
-}
-
 function writeVehicleGeometry(target, pose) {
   const geometry = target ?? {};
   const forwardX = Math.cos(pose.heading);
@@ -238,10 +220,6 @@ function writeCurrentVehicleGeometry(target, pose) {
   return geometry;
 }
 
-export function createOrientedRect({ id, type, center, heading, length, width }) {
-  return writeOrientedRect(null, { id, type, center, heading, length, width });
-}
-
 export function createVehicleGeometry(car, options = {}) {
   const pose = vehiclePose(car, options);
   return writeVehicleGeometry(null, pose);
@@ -274,33 +252,22 @@ function sweptPoseSignature(pose) {
   ].join(':');
 }
 
-function geometryPose(car) {
-  const { x, y, heading } = currentPoseState(car);
-  return {
-    x,
-    y,
-    heading,
-    previousX: finiteOr(car.previousX, x),
-    previousY: finiteOr(car.previousY, y),
-    previousHeading: normalizeAngle(finiteOr(car.previousHeading, heading)),
-  };
-}
-
 function currentGeometryStateMatches(car, state) {
   const pose = state?.pose;
   if (!pose) return false;
-  const currentPose = currentPoseState(car);
   return (
-    pose.x === currentPose.x &&
-    pose.y === currentPose.y &&
-    pose.heading === currentPose.heading
+    pose.x === finiteOr(car.x, 0) &&
+    pose.y === finiteOr(car.y, 0) &&
+    pose.heading === normalizeAngle(finiteOr(car.heading, 0))
   );
 }
 
 function geometryStateMatches(car, state) {
   const pose = state?.pose;
   if (!pose) return false;
-  const { x, y, heading } = currentPoseState(car);
+  const x = finiteOr(car.x, 0);
+  const y = finiteOr(car.y, 0);
+  const heading = normalizeAngle(finiteOr(car.heading, 0));
   return (
     pose.x === x &&
     pose.y === y &&
@@ -312,6 +279,10 @@ function geometryStateMatches(car, state) {
 }
 
 export function createVehicleShapeAabb(shape) {
+  return writeVehicleShapeAabb({}, shape);
+}
+
+function writeVehicleShapeAabb(target, shape) {
   let minX = Infinity;
   let maxX = -Infinity;
   let minY = Infinity;
@@ -323,55 +294,80 @@ export function createVehicleShapeAabb(shape) {
     if (corner.y < minY) minY = corner.y;
     if (corner.y > maxY) maxY = corner.y;
   }
-  return {
-    minX,
-    maxX,
-    minY,
-    maxY,
-  };
+  target.minX = minX;
+  target.maxX = maxX;
+  target.minY = minY;
+  target.maxY = maxY;
+  return target;
 }
 
-export function mergeAabbs(aabbs) {
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-  for (let index = 0; index < aabbs.length; index += 1) {
-    const aabb = aabbs[index];
-    if (aabb.minX < minX) minX = aabb.minX;
-    if (aabb.maxX > maxX) maxX = aabb.maxX;
-    if (aabb.minY < minY) minY = aabb.minY;
-    if (aabb.maxY > maxY) maxY = aabb.maxY;
-  }
-  return { minX, maxX, minY, maxY };
+function writeGeometryPose(target, car) {
+  const pose = target ?? {};
+  const x = finiteOr(car.x, 0);
+  const y = finiteOr(car.y, 0);
+  const heading = normalizeAngle(finiteOr(car.heading, 0));
+  pose.x = x;
+  pose.y = y;
+  pose.heading = heading;
+  pose.previousX = finiteOr(car.previousX, x);
+  pose.previousY = finiteOr(car.previousY, y);
+  pose.previousHeading = normalizeAngle(finiteOr(car.previousHeading, heading));
+  return pose;
 }
 
-export function createVehicleGeometryState(car) {
-  const pose = geometryPose(car);
-  const current = writeVehicleGeometry(null, pose);
-  const previous = writeVehicleGeometry(null, {
-    x: pose.previousX,
-    y: pose.previousY,
-    heading: pose.previousHeading,
+function createGeometryStateShell() {
+  const state = {
+    pose: null,
+    current: null,
+    previous: null,
+    body: null,
+    wheels: null,
+    contactPatches: null,
+    bodyAabb: {},
+    previousBodyAabb: {},
+    sweptBodyAabb: {},
+  };
+  // Signatures are derived lazily from the pose: nothing on the hot path reads
+  // them, so the per-step string formatting cost must not be paid eagerly.
+  Object.defineProperties(state, {
+    currentSignature: {
+      get() { return currentPoseSignature(this.pose); },
+      enumerable: true,
+    },
+    sweptSignature: {
+      get() { return sweptPoseSignature(this.pose); },
+      enumerable: true,
+    },
+    signature: {
+      get() { return sweptPoseSignature(this.pose); },
+      enumerable: true,
+    },
   });
-  const bodyAabb = createVehicleShapeAabb(current.body);
-  const previousBodyAabb = createVehicleShapeAabb(previous.body);
-  const sweptBodyAabb = mergeAabbs([previousBodyAabb, bodyAabb]);
+  return state;
+}
 
-  return {
-    pose,
-    currentSignature: currentPoseSignature(pose),
-    sweptSignature: sweptPoseSignature(pose),
-    signature: sweptPoseSignature(pose),
-    current,
-    previous,
-    body: current.body,
-    wheels: current.wheels,
-    contactPatches: current.contactPatches,
-    bodyAabb,
-    previousBodyAabb,
-    sweptBodyAabb,
-  };
+const PREVIOUS_GEOMETRY_POSE_SCRATCH = { x: 0, y: 0, heading: 0 };
+
+export function createVehicleGeometryState(car, target = null) {
+  const state = target ?? createGeometryStateShell();
+  const pose = state.pose = writeGeometryPose(state.pose, car);
+  const current = state.current = writeVehicleGeometry(state.current, pose);
+  PREVIOUS_GEOMETRY_POSE_SCRATCH.x = pose.previousX;
+  PREVIOUS_GEOMETRY_POSE_SCRATCH.y = pose.previousY;
+  PREVIOUS_GEOMETRY_POSE_SCRATCH.heading = pose.previousHeading;
+  const previous = state.previous = writeVehicleGeometry(state.previous, PREVIOUS_GEOMETRY_POSE_SCRATCH);
+  const bodyAabb = writeVehicleShapeAabb(state.bodyAabb, current.body);
+  const previousBodyAabb = writeVehicleShapeAabb(state.previousBodyAabb, previous.body);
+  const sweptBodyAabb = state.sweptBodyAabb;
+  sweptBodyAabb.minX = Math.min(bodyAabb.minX, previousBodyAabb.minX);
+  sweptBodyAabb.maxX = Math.max(bodyAabb.maxX, previousBodyAabb.maxX);
+  sweptBodyAabb.minY = Math.min(bodyAabb.minY, previousBodyAabb.minY);
+  sweptBodyAabb.maxY = Math.max(bodyAabb.maxY, previousBodyAabb.maxY);
+
+  state.body = current.body;
+  state.wheels = current.wheels;
+  state.contactPatches = current.contactPatches;
+  return state;
 }
 
 export function createCurrentVehicleGeometryState(car, target = null) {
@@ -388,8 +384,13 @@ export function createCurrentVehicleGeometryState(car, target = null) {
 
 export function getVehicleGeometryState(car) {
   if (geometryStateMatches(car, car.geometryState)) return car.geometryState;
-  car.geometryState = createVehicleGeometryState(car);
-  return car.geometryState;
+  // Double-buffer pooled states: consumers may still hold the state returned
+  // for the previous pose within a step, so alternate between two reusable
+  // shells instead of allocating a fresh geometry tree on every pose change.
+  const next = createVehicleGeometryState(car, car._geometryStateSpare ?? null);
+  car._geometryStateSpare = car.geometryState ?? null;
+  car.geometryState = next;
+  return next;
 }
 
 export function getCurrentVehicleGeometryState(car) {
@@ -417,25 +418,6 @@ export function ensureOrientedRectCorners(rect) {
   }).corners;
 }
 
-export function createVehicleAabb(car, options = {}) {
-  const geometry = createVehicleGeometry(car, options);
-  return mergeAabbs(geometry.shapes.map(createVehicleShapeAabb));
-}
-
-export function interpolateVehiclePose(car, amount) {
-  const previousX = finiteOr(car.previousX, car.x);
-  const previousY = finiteOr(car.previousY, car.y);
-  const previousHeading = finiteOr(car.previousHeading, car.heading);
-  const headingDelta = normalizeAngle(finiteOr(car.heading, 0) - previousHeading);
-
-  return {
-    ...car,
-    x: previousX + (finiteOr(car.x, previousX) - previousX) * amount,
-    y: previousY + (finiteOr(car.y, previousY) - previousY) * amount,
-    heading: normalizeAngle(previousHeading + headingDelta * amount),
-  };
-}
-
 export function getCarCorners(car) {
   return createVehicleGeometry(car).body.corners;
 }

package/src/simulation/vehicle/vehicleKinematics.js

@@ -1,3 +1,5 @@
+import { normalizeAngle } from '../simMath.js';
+
 export function freezeVehicleMotion(car, {
   brake = 1,
   clearManualControls = false,
@@ -35,3 +37,11 @@ export function syncVehicleVelocityToHeading(car) {
   car.velocityX = Math.cos(heading) * speed;
   car.velocityY = Math.sin(heading) * speed;
 }
+
+export function shiftPreviousRenderPose(car, dx, dy, dheading = 0) {
+  car.previousX = Number.isFinite(car.previousX) ? car.previousX + dx : car.x + dx;
+  car.previousY = Number.isFinite(car.previousY) ? car.previousY + dy : car.y + dy;
+  car.previousHeading = normalizeAngle(
+    (Number.isFinite(car.previousHeading) ? car.previousHeading : car.heading) + dheading,
+  );
+}

package/src/simulation/vehicle/vehiclePhysics.js

@@ -1,9 +1,9 @@
+import { integrateAdvancedVehiclePhysics } from './advancedVehiclePhysics.js';
 import { clamp, normalizeAngle } from '../simMath.js';
 import {
   REAL_F1_WHEELBASE_METERS,
   SIM_UNITS_PER_METER,
   TOP_SPEED_SIM_UNITS_PER_SECOND,
-  metersPerSecondToSimSpeed,
   simUnitsToMeters,
   metersToSimUnits,
 } from '../units.js';
@@ -37,20 +37,12 @@ const SURFACE_MODEL = {
 const WHEEL_DRAG_YAW_GAIN = 0.08;
 const MAX_WHEEL_DRAG_YAW_RATE = 0.22;
 
-const SIMULATOR_SURFACE_MODEL = {
-  track: { grip: 1, drag: 0, rollingResistance: 0.008, scrub: 0 },
-  'pit-entry': { grip: 0.92, drag: 0.06, rollingResistance: 0.018, scrub: 1.2 },
-  'pit-lane': { grip: 0.9, drag: 0.08, rollingResistance: 0.02, scrub: 1.4 },
-  'pit-exit': { grip: 0.92, drag: 0.06, rollingResistance: 0.018, scrub: 1.2 },
-  'pit-box': { grip: 0.82, drag: 0.12, rollingResistance: 0.035, scrub: 2.5 },
-  kerb: { grip: 0.78, drag: 0.42, rollingResistance: 0.09, scrub: 8.5 },
-  gravel: { grip: 0.36, drag: 5.4, rollingResistance: 0.24, scrub: 18 },
-  grass: { grip: 0.3, drag: 3.4, rollingResistance: 0.2, scrub: 15 },
-  barrier: { grip: 0.08, drag: 15, rollingResistance: 2.4, scrub: 30 },
-};
-
 export function normalizePhysicsMode(value) {
-  return value === 'advanced' ? 'advanced' : DEFAULT_PHYSICS_MODE;
+  return PHYSICS_MODES.includes(value) ? value : DEFAULT_PHYSICS_MODE;
+}
+
+export function isSimulatorPhysicsMode(value) {
+  return value === 'advanced';
 }
 
 function accelerationLimit(speed, surfaceGrip) {
@@ -63,11 +55,39 @@ function brakingLimit(speed, surfaceGrip) {
   return SIM_UNITS_PER_METER * surfaceGrip * (20 + speedRatio * 14);
 }
 
+// Policy accessors use the same arcade model without changing its integrator.
+// Surface grip is the base coefficient; callers apply tire condition once.
+export function arcadeSurfaceGrip(car) {
+  return (SURFACE_MODEL[car.trackState?.surface] ?? SURFACE_MODEL.track).grip;
+}
+
+export function arcadeResistanceForce(car, speedMetersPerSecond) {
+  const surface = SURFACE_MODEL[car.trackState?.surface] ?? SURFACE_MODEL.track;
+  const dragMultiplier = car.drsActive ? 0.42 : 1;
+  return (car.dragCoefficient * dragMultiplier * 0.12 + surface.drag) * speedMetersPerSecond ** 2 +
+    surface.rollingResistance * car.mass * G;
+}
+
+// The existing limits take speed and return acceleration in simulator units.
+export { accelerationLimit as arcadeAccelerationLimit, brakingLimit as arcadeBrakingLimit };
+
 export function tirePerformanceFactor(tireEnergy = 100) {
   const normalized = clamp((Number(tireEnergy) || 1) / 100, 0.01, 1);
   return clamp(0.45 + 0.55 * normalized ** 0.72, 0.45, 1);
 }
 
+export function arcadeTrackCornerSpeedLimit(car, curvature, gripShare) {
+  const tire = tirePerformanceFactor(car.tireEnergy ?? 100);
+  // On tarmac the arcade yaw limit is (static + aero * speed²) / speed.
+  // Invert that same law for a future corner; the driver owns its grip reserve.
+  const staticCapacity = car.tireGrip * G * tire * tire;
+  const aeroCapacity = car.downforceCoefficient / car.mass * tire;
+  const denominator = Math.abs(curvature) - gripShare * aeroCapacity;
+  return denominator > 0
+    ? Math.min(simUnitsToMeters(VEHICLE_LIMITS.maxSpeed), Math.sqrt(gripShare * staticCapacity / denominator))
+    : simUnitsToMeters(VEHICLE_LIMITS.maxSpeed);
+}
+
 function surfaceResistance(surfaceName, model = SURFACE_MODEL) {
   const surface = model[surfaceName] ?? model.track;
   return surface.drag * 0.14 + surface.rollingResistance * 2.4 + (1 - surface.grip) * 0.65;
@@ -120,8 +140,14 @@ function setPhysicsTelemetry(car, {
 }
 
 export function integrateVehiclePhysics(car, controls, dt, options = {}) {
-  if (normalizePhysicsMode(options.physicsMode) === 'advanced') {
-    return integrateSimulatorVehiclePhysics(car, controls, dt, options);
+  const mode = normalizePhysicsMode(options.physicsMode);
+  if (mode === 'advanced') {
+    return integrateAdvancedVehiclePhysics(car, controls, dt, {
+      tireFactor: tirePerformanceFactor(car.tireEnergy ?? 100),
+      tireDegradationEnabled: options.tireDegradationEnabled,
+      maxSteer: VEHICLE_LIMITS.maxSteer,
+      steerRate: VEHICLE_LIMITS.steerRate,
+    });
   }
   return integrateArcadeVehiclePhysics(car, controls, dt, options);
 }
@@ -196,184 +222,4 @@ function integrateArcadeVehiclePhysics(car, controls, dt, options = {}) {
   return car;
 }
 
-function simulatorSurface(surfaceName) {
-  return SIMULATOR_SURFACE_MODEL[surfaceName] ?? SIMULATOR_SURFACE_MODEL.track;
-}
-
-function aggregateSimulatorSurface(car) {
-  const wheels = Array.isArray(car.wheelStates) ? car.wheelStates : [];
-  if (!wheels.length) return simulatorSurface(car.trackState?.surface ?? 'track');
-  let grip = 0;
-  let drag = 0;
-  let rollingResistance = 0;
-  let scrub = 0;
-  for (let index = 0; index < wheels.length; index += 1) {
-    const surface = simulatorSurface(wheels[index].surface);
-    grip += surface.grip;
-    drag += surface.drag;
-    rollingResistance += surface.rollingResistance;
-    scrub += surface.scrub;
-  }
-  return {
-    grip: grip / wheels.length,
-    drag: drag / wheels.length,
-    rollingResistance: rollingResistance / wheels.length,
-    scrub: scrub / wheels.length,
-  };
-}
-
-function simulatorStabilityState({ gripUsage, slipAngle, surfaceName, brake, throttle }) {
-  if (gripUsage > 1.32 || Math.abs(slipAngle) > 0.42) return 'spin-risk';
-  if (gripUsage > 1.02) return brake > 0.2 && throttle < 0.2 ? 'oversteer' : 'understeer';
-  if (surfaceName === 'kerb' && gripUsage > 0.72) return 'oversteer';
-  if ((surfaceName === 'gravel' || surfaceName === 'grass') && gripUsage > 0.5) return 'understeer';
-  return 'stable';
-}
-
-function ensureSimulatorVelocity(car) {
-  if (Number.isFinite(car.velocityX) && Number.isFinite(car.velocityY)) return;
-  const speed = clamp(Number(car.speed) || 0, 0, VEHICLE_LIMITS.maxSpeed);
-  car.velocityX = Math.cos(car.heading ?? 0) * speed;
-  car.velocityY = Math.sin(car.heading ?? 0) * speed;
-}
-
-function limitSimulatorSpeed(car) {
-  const speed = Math.hypot(car.velocityX, car.velocityY);
-  if (speed <= VEHICLE_LIMITS.maxSpeed || speed <= 0) return speed;
-  const scale = VEHICLE_LIMITS.maxSpeed / speed;
-  car.velocityX *= scale;
-  car.velocityY *= scale;
-  return VEHICLE_LIMITS.maxSpeed;
-}
-
-function integrateSimulatorVehiclePhysics(car, controls, dt, options = {}) {
-  ensureSimulatorVelocity(car);
-  const steeringTarget = clamp(controls.steering ?? 0, -VEHICLE_LIMITS.maxSteer, VEHICLE_LIMITS.maxSteer);
-  const steerDelta = clamp(
-    steeringTarget - car.steeringAngle,
-    -VEHICLE_LIMITS.steerRate * dt,
-    VEHICLE_LIMITS.steerRate * dt,
-  );
-  car.steeringAngle += steerDelta;
-
-  const throttle = clamp(controls.throttle ?? 0, 0, 1);
-  const brake = clamp(controls.brake ?? 0, 0, 1);
-  const surfaceName = car.trackState?.surface ?? 'track';
-  const surface = aggregateSimulatorSurface(car);
-  const tireFactor = tirePerformanceFactor(car.tireEnergy ?? 100);
-  const surfaceGrip = surface.grip * tireFactor;
-  const speedBefore = Math.hypot(car.velocityX, car.velocityY);
-  const speedBeforeMps = simUnitsToMeters(speedBefore);
-  const speedRatio = clamp(speedBefore / VEHICLE_LIMITS.maxSpeed, 0, 1);
-  const downforceGrip = car.downforceCoefficient * speedBeforeMps * speedBeforeMps / car.mass;
-  const totalGripAcceleration = Math.max(0.1, (car.tireGrip * tireFactor * G + downforceGrip) * surfaceGrip);
-  const heading = car.heading ?? 0;
-  const forwardX = Math.cos(heading);
-  const forwardY = Math.sin(heading);
-  const rightX = -forwardY;
-  const rightY = forwardX;
-  const forwardVelocity = car.velocityX * forwardX + car.velocityY * forwardY;
-  const lateralVelocity = car.velocityX * rightX + car.velocityY * rightY;
-  const forwardSpeedMps = simUnitsToMeters(forwardVelocity);
-  const lateralSpeedMps = simUnitsToMeters(lateralVelocity);
-  const currentSlipAngle = Math.atan2(lateralSpeedMps, Math.max(Math.abs(forwardSpeedMps), 0.1));
-  const engineForce = throttle *
-    car.powerNewtons *
-    (car.drsActive ? 1.07 : 1) *
-    Math.max(0.08, 1 - speedRatio ** 1.22);
-  const brakeForce = brake * car.brakeNewtons;
-  const driveAcceleration = Math.min(
-    engineForce / car.mass,
-    accelerationLimit(car.speed, surfaceGrip) / SIM_UNITS_PER_METER,
-  );
-  const brakeDeceleration = Math.min(
-    brakeForce / car.mass,
-    brakingLimit(car.speed, surfaceGrip) / SIM_UNITS_PER_METER,
-  );
-  const dragMultiplier = car.drsActive ? 0.46 : 1;
-  const dragAcceleration = (
-    (car.dragCoefficient * dragMultiplier * 0.28 + surface.drag * 0.018) *
-    speedBeforeMps * speedBeforeMps
-  ) / car.mass;
-  const rollingAcceleration = surface.rollingResistance * G;
-  const normalizedSteer = Math.abs(car.steeringAngle) / VEHICLE_LIMITS.maxSteer;
-  const speedSensitiveSteer = 1 / (1 + (Math.abs(forwardSpeedMps) / 58) ** 1.85 * 2.35);
-  const effectiveSteeringAngle = car.steeringAngle * clamp(speedSensitiveSteer, 0.16, 1);
-  const rawYawRate = Math.abs(forwardSpeedMps) <= 0.05
-    ? 0
-    : (forwardSpeedMps / REAL_F1_WHEELBASE_METERS) * Math.tan(effectiveSteeringAngle);
-  const sideSlipDamping = 4.2 + surfaceGrip * 2.1 + speedRatio * 1.6;
-  const desiredLateralAcceleration = forwardSpeedMps * rawYawRate - lateralSpeedMps * sideSlipDamping;
-  const longitudinalDemand = Math.max(driveAcceleration, brakeDeceleration);
-  const longitudinalUsage = clamp(longitudinalDemand / Math.max(totalGripAcceleration * 0.52, 1), 0, 0.94);
-  const lateralCapacity = totalGripAcceleration * Math.sqrt(Math.max(0.08, 1 - longitudinalUsage ** 2));
-  const desiredLateralAbs = Math.abs(desiredLateralAcceleration);
-  const lateralUsage = desiredLateralAbs / Math.max(lateralCapacity, 0.1);
-  const gripUsage = Math.sqrt(lateralUsage ** 2 + longitudinalUsage ** 2);
-  const tractionLimited = gripUsage > 1 || longitudinalUsage > 0.9;
-  const actualLateralAcceleration = clamp(desiredLateralAcceleration, -lateralCapacity, lateralCapacity);
-  const steeringYawRate = Math.abs(forwardSpeedMps) <= 0.05 ? 0 : actualLateralAcceleration / Math.max(Math.abs(forwardSpeedMps), 0.1);
-  const steeringScrubAcceleration = normalizedSteer ** 1.55 *
-    speedRatio ** 1.05 *
-    (42 + surface.scrub + Math.max(0, gripUsage - 0.55) * 18);
-  const tractionPowerScale = tractionLimited
-    ? clamp(1 - (gripUsage - 1) * 0.55 - longitudinalUsage * 0.18, 0.12, 1)
-    : 1;
-  const brakingDirection = forwardSpeedMps >= -0.2 ? 1 : -1;
-  const scrubDirection = forwardSpeedMps >= 0 ? 1 : -1;
-  const longitudinalAcceleration =
-    driveAcceleration * tractionPowerScale -
-    brakeDeceleration * brakingDirection -
-    dragAcceleration * Math.sign(forwardSpeedMps || 1) -
-    rollingAcceleration * Math.sign(forwardSpeedMps || 1) -
-    steeringScrubAcceleration * scrubDirection;
-
-  const requestedWheelDragYawRate = wheelDragYawRate(car, SIMULATOR_SURFACE_MODEL) * (surfaceName === 'kerb' ? 1.6 : 1);
-  const maxYawRate = speedBeforeMps <= 0.05 ? 0 : totalGripAcceleration / Math.max(speedBeforeMps, 0.1);
-  const slipSteeringAuthority = clamp(1 - Math.abs(currentSlipAngle) * 1.8, 0.35, 1);
-  const yawTarget = clamp(steeringYawRate * slipSteeringAuthority + requestedWheelDragYawRate, -maxYawRate, maxYawRate);
-  const yawResponse = 1.6 + surfaceGrip * 0.9 + speedRatio * 0.5;
-  const yawAccelerationCap = speedRatio < 0.18 ? 6.2 : 3.2;
-  const maxYawDelta = Math.min(Math.max(0.08, maxYawRate * yawResponse), yawAccelerationCap) * dt;
-  car.yawRate = clamp(
-    (car.yawRate ?? 0) + clamp(yawTarget - (car.yawRate ?? 0), -maxYawDelta, maxYawDelta),
-    -maxYawRate,
-    maxYawRate,
-  );
-  car.wheelDragYawRate = requestedWheelDragYawRate;
-  car.heading = normalizeAngle(car.heading + car.yawRate * dt);
-
-  const accelerationX = forwardX * longitudinalAcceleration + rightX * actualLateralAcceleration;
-  const accelerationY = forwardY * longitudinalAcceleration + rightY * actualLateralAcceleration;
-  car.velocityX += metersToSimUnits(accelerationX) * dt;
-  car.velocityY += metersToSimUnits(accelerationY) * dt;
-  car.speed = limitSimulatorSpeed(car);
-  car.x += car.velocityX * dt;
-  car.y += car.velocityY * dt;
-  car.throttle = throttle;
-  car.brake = brake;
-  car.steerSaturation = rawYawRate === 0 ? 0 : Math.abs(steeringYawRate / rawYawRate);
-  car.turnRadius = Math.abs(car.yawRate) < 0.001 ? Infinity : car.speed / Math.abs(car.yawRate);
-  const velocityHeading = car.speed <= 0.01 ? car.heading : Math.atan2(car.velocityY, car.velocityX);
-  const slipAngle = normalizeAngle(velocityHeading - car.heading);
-  setPhysicsTelemetry(car, {
-    lateralAcceleration: actualLateralAcceleration,
-    longitudinalAcceleration,
-    gripUsage,
-    slipAngleRadians: slipAngle,
-    tractionLimited,
-    stabilityState: simulatorStabilityState({ gripUsage, slipAngle, surfaceName, brake, throttle }),
-  });
-
-  if (options.tireDegradationEnabled !== false) {
-    const tyreLoad = Math.abs(car.lateralAcceleration) / G;
-    const tireCare = clamp(Number(car.tireCare) || 1, 0.45, 1.8);
-    const heatPenalty = Math.max(0, gripUsage - 0.72) * 0.24 + normalizedSteer * speedRatio * 0.08;
-    const wearRate = (0.045 + tyreLoad * 0.16 + brake * 0.09 + throttle * 0.035 + heatPenalty) / tireCare;
-    car.tireEnergy = clamp((car.tireEnergy ?? 100) - wearRate * dt, 1, 100);
-  }
-
-  return car;
-}
-
 export { getCarCorners };

package/src/simulation/vehicle/vehicleSnapshots.js

@@ -1,8 +1,11 @@
-import { serializeParticipantInteraction } from '../participants/participantInteractions.js';
+import { finiteOrNull } from '../simMath.js';
+export { finiteOrNull } from '../simMath.js';
+
+import {
+  serializeParticipantInteraction,
+  serializeParticipantInteractionCached,
+} from '../participants/participantInteractions.js';
 
-export function finiteOrNull(value) {
-  return Number.isFinite(value) ? value : null;
-}
 
 function serializeAppliedControls(car, dependencies) {
   const { VEHICLE_LIMITS } = dependencies;
@@ -21,6 +24,15 @@ function serializeVelocityComponent(car, component, dependencies) {
   return finiteOrNull(car[component]);
 }
 
+function serializeTeam(team) {
+  if (!team) return null;
+  return {
+    ...team,
+    ...(team.pitCrew && typeof team.pitCrew === 'object' ? { pitCrew: { ...team.pitCrew } } : {}),
+    ...(team.pitCrewStats && typeof team.pitCrewStats === 'object' ? { pitCrewStats: { ...team.pitCrewStats } } : {}),
+  };
+}
+
 export function serializeWheels(wheels = []) {
   return wheels.map((wheel) => ({
     id: wheel.id,
@@ -57,7 +69,7 @@ export function serializeCar(car, rank, penaltySeconds = 0, dependencies) {
     raceName: car.raceName,
     name: car.name,
     color: car.color,
-    team: car.team ? { ...car.team } : null,
+    team: serializeTeam(car.team),
     tire: car.tire,
     personality: { ...car.personality },
     aggression: car.aggression,
@@ -185,7 +197,7 @@ export function serializeRenderCarInto(target, car, dependencies) {
   target.dnfOrder = car.dnfOrder ?? null;
   target.outOfRace = Boolean(car.outOfRace || car.destroyed);
   target.pitStop = serializeRenderPitStop(car.pitStop);
-  target.interaction = serializeParticipantInteraction(car.interaction);
+  target.interaction = serializeParticipantInteractionCached(car);
   return target;
 }
 

package/src/simulation/vehicle/vehicleState.js

@@ -1,8 +1,8 @@
-import { buildDriverPersonality } from '../driverController.js';
+import { buildDriverPersonality } from '../driver/driverPersonality.js';
 import { clamp, normalizeAngle, seededRange } from '../simMath.js';
 import { offsetTrackPoint, pointAt } from '../track/trackModel.js';
 import { kphToSimSpeed, metersToSimUnits } from '../units.js';
-import { VEHICLE_LIMITS } from './vehiclePhysics.js';
+import { VEHICLE_LIMITS, isSimulatorPhysicsMode } from './vehiclePhysics.js';
 import { applyWheelSurfaceState } from './wheelSurface.js';
 import { nearestTrackStateForCar } from '../track/trackStatePolicy.js';
 import { clearCarDnf } from '../race/retirements.js';
@@ -73,8 +73,10 @@ export function createCar(driver, index, random, track, { standingStart = false,
     downforceCoefficient: vehicle.downforceCoefficient ?? 6.1 + seededRange(random, -0.18, 0.18),
     tireGrip: vehicle.tireGrip ?? 2.22 + racecraft * 0.28 + seededRange(random, -0.03, 0.03),
     tireCare: vehicle.tireCare ?? 1,
+    driverModel: driver.driverModel ?? vehicle.driverModel ?? null,
     pace,
     racecraft,
+    consistency: Number.isFinite(driver.consistency) ? clamp(driver.consistency, 0, 1) : 0.75,
     personality,
     aggression: personality.baseAggression,
     gridLocked: standingStart,
@@ -170,7 +172,7 @@ export function applyExternalCarState(car, partial, context) {
   }
   car.speed = clamp(Number.isFinite(car.speed) ? car.speed : 0, 0, VEHICLE_LIMITS.maxSpeed);
   car.heading = normalizeAngle(Number.isFinite(car.heading) ? car.heading : 0);
-  syncExternalVelocityState(car, nextPartial, physicsMode === 'advanced');
+  syncExternalVelocityState(car, nextPartial, isSimulatorPhysicsMode(physicsMode));
   const centerState = nearestTrackStateForCar(track, car, car, car.progress ?? car.raceDistance);
   applyWheelSurfaceState(car, track, { centerState });
   if (