@inventure71/paddockjs 2.0.0 → 3.0.0

package/src/simulation/track/trackQueryPitIndex.js

@@ -0,0 +1,140 @@
+import { createSpatialGrid, insertIdIntoGridBounds, candidateIdsFromGrid } from './trackQueryGrid.js';
+import { recordFallback, recordStat } from './trackQueryStats.js';
+
+export function createPitQueryIndex(track, cellSize) {
+  const pitLane = track.pitLane;
+  if (!pitLane?.enabled) return null;
+  const bounds = {
+    minX: pitLane.bounds.minX - cellSize,
+    maxX: pitLane.bounds.maxX + cellSize,
+    minY: pitLane.bounds.minY - cellSize,
+    maxY: pitLane.bounds.maxY + cellSize,
+  };
+  const roadGrid = createSpatialGrid(bounds, cellSize);
+  const boxGrid = createSpatialGrid(bounds, cellSize);
+  const roadSegments = [];
+  const routes = {};
+
+  [
+    ['entry', pitLane.entry?.roadCenterline],
+    ['main', pitLane.mainLane?.points],
+    ['working', pitLane.workingLane?.points],
+    ['exit', pitLane.exit?.roadCenterline],
+  ].forEach(([routeId, points]) => {
+    routes[routeId] = { start: roadSegments.length };
+    indexPitRoute(roadGrid, roadSegments, routeId, points, cellSize);
+    routes[routeId].end = roadSegments.length;
+  });
+
+  const boxCandidates = [];
+  [
+    ...(pitLane.serviceAreas ?? []).flatMap((area) => [
+      { type: 'service-area', target: area, polygon: area.corners },
+      { type: 'service-queue', target: area, polygon: area.queueCorners },
+    ]),
+    ...(pitLane.boxes ?? []).map((box) => ({ type: 'garage-box', target: box, polygon: box.corners })),
+  ]
+    .filter((candidate) => Array.isArray(candidate.polygon) && candidate.polygon.length >= 3)
+    .forEach((candidate) => {
+      const id = boxCandidates.length;
+      boxCandidates.push(candidate);
+      insertIdIntoGridBounds(boxGrid, id, polygonBounds(candidate.polygon, cellSize));
+    });
+
+  return {
+    roadGrid,
+    boxGrid,
+    routes,
+    roadSegments,
+    boxCandidates,
+  };
+}
+
+export function queryPitBoxCandidates(track, position) {
+  const index = track?.queryIndex;
+  const pit = index?.pit;
+  if (!pit?.boxGrid) {
+    recordFallback(index, 'pitFallbackReasons', 'missing-box-index');
+    return null;
+  }
+  if (!finitePoint(position)) {
+    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
+    return null;
+  }
+  index.stats.pitQueries += 1;
+  const ids = candidateIdsFromGrid(index, pit.boxGrid, position, 1);
+  if (!ids.length) {
+    recordStat(index, 'pitPaths', 'box-grid-miss');
+    return [];
+  }
+  recordStat(index, 'pitPaths', 'box-grid-hit');
+  return ids.map((id) => pit.boxCandidates[id]).filter(Boolean);
+}
+
+export function queryPitRoadSegmentCandidates(track, routeId, position) {
+  const candidatesByRoute = queryPitRoadSegmentCandidatesByRoute(track, position);
+  return candidatesByRoute?.[routeId] ?? candidatesByRoute;
+}
+
+export function queryPitRoadSegmentCandidatesByRoute(track, position) {
+  const index = track?.queryIndex;
+  const pit = index?.pit;
+  if (!pit?.roadGrid) {
+    recordFallback(index, 'pitFallbackReasons', 'missing-road-index');
+    return null;
+  }
+  if (!finitePoint(position)) {
+    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
+    return null;
+  }
+  index.stats.pitQueries += 1;
+  const ids = candidateIdsFromGrid(index, pit.roadGrid, position, 1);
+  if (!ids.length) {
+    recordStat(index, 'pitPaths', 'road-grid-miss');
+    return null;
+  }
+  const candidatesByRoute = { entry: [], main: [], working: [], exit: [] };
+  ids.forEach((id) => {
+    const segment = pit.roadSegments[id];
+    if (!segment || !candidatesByRoute[segment.routeId]) return;
+    candidatesByRoute[segment.routeId].push(segment.segmentIndex);
+  });
+  recordStat(index, 'pitPaths', 'road-grid-hit');
+  return candidatesByRoute;
+}
+
+function indexPitRoute(grid, roadSegments, routeId, points, expansion) {
+  if (!Array.isArray(points) || points.length < 2) return;
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const start = points[index];
+    const end = points[index + 1];
+    const id = roadSegments.length;
+    roadSegments.push({ routeId, segmentIndex: index });
+    const bounds = {
+      minX: Math.min(start.x, end.x) - expansion,
+      maxX: Math.max(start.x, end.x) + expansion,
+      minY: Math.min(start.y, end.y) - expansion,
+      maxY: Math.max(start.y, end.y) + expansion,
+    };
+    insertIdIntoGridBounds(grid, id, bounds);
+  }
+}
+
+function polygonBounds(polygon, expansion) {
+  const bounds = polygon.reduce((current, point) => ({
+    minX: Math.min(current.minX, point.x),
+    maxX: Math.max(current.maxX, point.x),
+    minY: Math.min(current.minY, point.y),
+    maxY: Math.max(current.maxY, point.y),
+  }), { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity });
+  return {
+    minX: bounds.minX - expansion,
+    maxX: bounds.maxX + expansion,
+    minY: bounds.minY - expansion,
+    maxY: bounds.maxY + expansion,
+  };
+}
+
+function finitePoint(point) {
+  return Number.isFinite(point?.x) && Number.isFinite(point?.y);
+}

package/src/simulation/track/trackQueryScratch.js

@@ -0,0 +1,46 @@
+export function createQueryScratch(index) {
+  const segmentCount = Math.max(0, index?.centerline?.segmentCount ?? 0);
+  const maxId = Math.max(
+    segmentCount,
+    index?.pit?.roadSegments?.length ?? 0,
+    index?.pit?.boxCandidates?.length ?? 0,
+  );
+  const grid = index?.segmentGrid ?? index?.grid;
+  const cellCount = Math.max(0, (grid?.columns ?? 0) * (grid?.rows ?? 0));
+  return {
+    candidateMarks: new Uint32Array(Math.max(1, maxId)),
+    candidateEpoch: 1,
+    sampleMarks: new Uint32Array(Math.max(1, segmentCount)),
+    sampleEpoch: 1,
+    raySegmentMarks: new Uint32Array(Math.max(1, segmentCount)),
+    raySegmentEpoch: 1,
+    rayCellMarks: new Uint32Array(Math.max(1, cellCount)),
+    rayCellEpoch: 1,
+    raySegmentIds: [],
+    rayVisitedCells: [],
+    rayTraceCache: new Map(),
+  };
+}
+
+export function ensureQueryScratch(index) {
+  if (index.queryScratch) return index.queryScratch;
+  index.queryScratch = createQueryScratch(index);
+  return index.queryScratch;
+}
+
+export function ensureScratchArray(scratch, key, minimumLength) {
+  if (!scratch[key] || scratch[key].length < minimumLength) {
+    scratch[key] = new Uint32Array(Math.max(1, minimumLength));
+  }
+  return scratch[key];
+}
+
+export function nextScratchEpoch(scratch, key, marks) {
+  let epoch = (scratch[key] ?? 0) + 1;
+  if (epoch >= 0xFFFFFFFF) {
+    marks.fill(0);
+    epoch = 1;
+  }
+  scratch[key] = epoch;
+  return epoch;
+}

package/src/simulation/track/trackQueryStats.js

@@ -0,0 +1,28 @@
+export function createQueryStats() {
+  return {
+    nearestQueries: 0,
+    nearestFallbacks: 0,
+    nearestPaths: {},
+    nearestFallbackReasons: {
+      'spatial-grid-no-candidates': 0,
+    },
+    pitQueries: 0,
+    pitFallbacks: 0,
+    pitPaths: {},
+    pitFallbackReasons: {},
+  };
+}
+
+export function recordFallback(index, bucket, reason) {
+  if (!index?.stats) return;
+  if (bucket === 'nearestFallbackReasons') index.stats.nearestFallbacks += 1;
+  if (bucket === 'pitFallbackReasons') index.stats.pitFallbacks += 1;
+  recordStat(index, bucket, reason);
+}
+
+export function recordStat(index, bucket, key) {
+  if (!index?.stats || !bucket || !key) return;
+  const target = index.stats[bucket] ?? {};
+  target[key] = (target[key] ?? 0) + 1;
+  index.stats[bucket] = target;
+}

package/src/simulation/track/trackStatePolicy.js

@@ -17,7 +17,6 @@ export function nearestTrackStateForCar(
 ) {
   const resolvedAllowPitOverride = options.allowPitOverride ?? pitOverrideAllowedForCar(car);
   return nearestTrackState(track, position, progressHint, {
-    indexMode: options.indexMode ?? 'legacy',
     ...options,
     allowPitOverride: resolvedAllowPitOverride,
   });

package/src/simulation/vehicle/contactResolution.js

@@ -15,10 +15,32 @@ function forwardVector(car) {
   return { x: Math.cos(car.heading), y: Math.sin(car.heading) };
 }
 
+function velocityVector(car) {
+  if (Number.isFinite(car.velocityX) && Number.isFinite(car.velocityY)) {
+    return { x: car.velocityX, y: car.velocityY };
+  }
+  const forward = forwardVector(car);
+  return { x: forward.x * car.speed, y: forward.y * car.speed };
+}
+
 function dot(a, b) {
   return a.x * b.x + a.y * b.y;
 }
 
+function applyVelocityVector(car, velocity) {
+  const speed = clamp(Math.hypot(velocity.x, velocity.y), 0, VEHICLE_LIMITS.maxSpeed);
+  if (speed <= 0) {
+    car.velocityX = 0;
+    car.velocityY = 0;
+    car.speed = 0;
+    return;
+  }
+  const scale = speed / Math.max(1e-9, Math.hypot(velocity.x, velocity.y));
+  car.velocityX = velocity.x * scale;
+  car.velocityY = velocity.y * scale;
+  car.speed = speed;
+}
+
 export function resolveCollisionsForSimulation(sim) {
   const collidableCars = sim.cars.filter(isCollidable);
   if (collidableCars.length < 2) return;
@@ -57,8 +79,8 @@ export function resolveCollisionsForSimulation(sim) {
       }
 
       if (oneCarFixed) {
-        if (!firstPitControlled) first.speed = clamp(first.speed * 0.985, 0, VEHICLE_LIMITS.maxSpeed);
-        if (!secondPitControlled) second.speed = clamp(second.speed * 0.985, 0, VEHICLE_LIMITS.maxSpeed);
+        if (!firstPitControlled) dampPitContactVelocity(first, 0.985, sim.physicsMode === 'advanced');
+        if (!secondPitControlled) dampPitContactVelocity(second, 0.985, sim.physicsMode === 'advanced');
       } else {
         applyContactVelocityResponse(sim, first, second, collision.axis);
       }
@@ -99,6 +121,37 @@ export function resolveCollisionsForSimulation(sim) {
 }
 
 export function applyContactVelocityResponse(sim, first, second, axis) {
+  if (
+    sim.physicsMode === 'advanced' ||
+    Number.isFinite(first.velocityX) ||
+    Number.isFinite(second.velocityX)
+  ) {
+    const firstVelocity = velocityVector(first);
+    const secondVelocity = velocityVector(second);
+    const relativeNormalVelocity = dot({
+      x: secondVelocity.x - firstVelocity.x,
+      y: secondVelocity.y - firstVelocity.y,
+    }, axis);
+
+    if (relativeNormalVelocity < 0) {
+      const impulse = clamp(-relativeNormalVelocity * (0.34 + sim.rules.collisionRestitution), 0, 16);
+      firstVelocity.x -= axis.x * impulse;
+      firstVelocity.y -= axis.y * impulse;
+      secondVelocity.x += axis.x * impulse;
+      secondVelocity.y += axis.y * impulse;
+    }
+
+    applyVelocityVector(first, {
+      x: firstVelocity.x * 0.997,
+      y: firstVelocity.y * 0.997,
+    });
+    applyVelocityVector(second, {
+      x: secondVelocity.x * 0.997,
+      y: secondVelocity.y * 0.997,
+    });
+    return;
+  }
+
   const firstForward = forwardVector(first);
   const secondForward = forwardVector(second);
   const firstNormal = dot(firstForward, axis);
@@ -114,3 +167,15 @@ export function applyContactVelocityResponse(sim, first, second, axis) {
   first.speed = clamp(first.speed * 0.997, 0, VEHICLE_LIMITS.maxSpeed);
   second.speed = clamp(second.speed * 0.997, 0, VEHICLE_LIMITS.maxSpeed);
 }
+
+function dampPitContactVelocity(car, factor, syncVelocity = false) {
+  if (syncVelocity || Number.isFinite(car.velocityX) || Number.isFinite(car.velocityY)) {
+    const velocity = velocityVector(car);
+    applyVelocityVector(car, {
+      x: velocity.x * factor,
+      y: velocity.y * factor,
+    });
+    return;
+  }
+  car.speed = clamp(car.speed * factor, 0, VEHICLE_LIMITS.maxSpeed);
+}

package/src/simulation/vehicle/runoffResponse.js

@@ -1,11 +1,12 @@
 import { VEHICLE_GEOMETRY, getVehicleGeometryState, vehicleAxes } from './vehicleGeometry.js';
 import { applyWheelSurfaceState } from './wheelSurface.js';
+import { freezeVehicleMotion } from './vehicleKinematics.js';
 import { nearestTrackStateForCar, pitOverrideAllowedForCar } from '../track/trackStatePolicy.js';
 import { markCarDnf } from '../race/retirements.js';
 
 export function applyRunoffResponseForSimulation(sim, car) {
   if (car.destroyed) {
-    car.speed = 0;
+    freezeBarrierMotion(car, sim.physicsMode);
     applyWheelSurfaceState(car, sim.track);
     return;
   }
@@ -67,17 +68,7 @@ function destroyCarOnBarrier(sim, car) {
   car.drsEligible = false;
   car.drsZoneId = null;
   car.drsZoneEnabled = false;
-  car.speed = 0;
-  car.throttle = 0;
-  car.brake = 1;
-  car.steeringAngle = 0;
-  car.yawRate = 0;
-  car.longitudinalAcceleration = 0;
-  car.lateralAcceleration = 0;
-  car.longitudinalG = 0;
-  car.lateralG = 0;
-  car.tractionLimited = false;
-  car.stabilityState = 'destroyed';
+  freezeBarrierMotion(car, sim.physicsMode);
   sim.events.unshift({
     type: 'car-destroyed',
     at: sim.time,
@@ -86,3 +77,11 @@ function destroyCarOnBarrier(sim, car) {
     reason: 'barrier',
   });
 }
+
+function freezeBarrierMotion(car, physicsMode) {
+  freezeVehicleMotion(car, {
+    clearManualControls: true,
+    physicsMode,
+    stabilityState: 'destroyed',
+  });
+}

package/src/simulation/vehicle/vehicleKinematics.js

@@ -0,0 +1,37 @@
+export function freezeVehicleMotion(car, {
+  brake = 1,
+  clearManualControls = false,
+  physicsMode = 'arcade',
+  stabilityState = car.stabilityState ?? 'stable',
+} = {}) {
+  car.speed = 0;
+  if (physicsMode === 'advanced') {
+    car.velocityX = 0;
+    car.velocityY = 0;
+  } else {
+    car.velocityX = null;
+    car.velocityY = null;
+  }
+  car.throttle = 0;
+  car.brake = brake;
+  car.appliedControls = { steering: 0, throttle: 0, brake };
+  if (clearManualControls) car.manualControls = null;
+  car.steeringAngle = 0;
+  car.yawRate = 0;
+  car.turnRadius = Infinity;
+  car.longitudinalAcceleration = 0;
+  car.lateralAcceleration = 0;
+  car.longitudinalG = 0;
+  car.lateralG = 0;
+  car.gripUsage = 0;
+  car.slipAngleRadians = 0;
+  car.tractionLimited = false;
+  car.stabilityState = stabilityState;
+}
+
+export function syncVehicleVelocityToHeading(car) {
+  const speed = Number.isFinite(car.speed) ? car.speed : 0;
+  const heading = Number.isFinite(car.heading) ? car.heading : 0;
+  car.velocityX = Math.cos(heading) * speed;
+  car.velocityY = Math.sin(heading) * speed;
+}

package/src/simulation/vehicle/vehiclePhysics.js

@@ -11,7 +11,7 @@ import { VEHICLE_GEOMETRY, getCarCorners, vehicleAxes } from './vehicleGeometry.
 
 const G = 9.80665;
 
-export const PHYSICS_MODES = ['arcade', 'simulator'];
+export const PHYSICS_MODES = ['arcade', 'advanced'];
 export const DEFAULT_PHYSICS_MODE = 'arcade';
 
 export const VEHICLE_LIMITS = {
@@ -50,7 +50,7 @@ const SIMULATOR_SURFACE_MODEL = {
 };
 
 export function normalizePhysicsMode(value) {
-  return value === 'simulator' ? 'simulator' : DEFAULT_PHYSICS_MODE;
+  return value === 'advanced' ? 'advanced' : DEFAULT_PHYSICS_MODE;
 }
 
 function accelerationLimit(speed, surfaceGrip) {
@@ -111,7 +111,7 @@ function setPhysicsTelemetry(car, {
 }
 
 export function integrateVehiclePhysics(car, controls, dt, options = {}) {
-  if (normalizePhysicsMode(options.physicsMode) === 'simulator') {
+  if (normalizePhysicsMode(options.physicsMode) === 'advanced') {
     return integrateSimulatorVehiclePhysics(car, controls, dt, options);
   }
   return integrateArcadeVehiclePhysics(car, controls, dt, options);
@@ -305,12 +305,13 @@ function integrateSimulatorVehiclePhysics(car, controls, dt, options = {}) {
     ? 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;
+    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);

package/src/simulation/vehicle/vehicleSnapshots.js

@@ -16,6 +16,11 @@ function serializeAppliedControls(car, dependencies) {
   };
 }
 
+function serializeVelocityComponent(car, component, dependencies) {
+  if (dependencies.physicsMode !== 'advanced') return null;
+  return finiteOrNull(car[component]);
+}
+
 export function serializeWheels(wheels = []) {
   return wheels.map((wheel) => ({
     id: wheel.id,
@@ -99,6 +104,8 @@ export function serializeCar(car, rank, penaltySeconds = 0, dependencies) {
     heading: car.heading,
     steeringAngle: car.steeringAngle,
     yawRate: car.yawRate,
+    velocityX: serializeVelocityComponent(car, 'velocityX', dependencies),
+    velocityY: serializeVelocityComponent(car, 'velocityY', dependencies),
     turnRadius: car.turnRadius,
     speed: car.speed,
     speedKph: simSpeedToKph(car.speed),
@@ -134,6 +141,17 @@ export function serializeCar(car, rank, penaltySeconds = 0, dependencies) {
     signedOffset: car.trackState?.signedOffset ?? 0,
     crossTrackError: car.trackState?.crossTrackError ?? 0,
     surface: car.trackState?.surface ?? 'track',
+    trackState: car.trackState ? {
+      distance: car.trackState.distance,
+      signedOffset: car.trackState.signedOffset,
+      crossTrackError: car.trackState.crossTrackError,
+      surface: car.trackState.surface,
+      inPitLane: Boolean(car.trackState.inPitLane),
+      pitLanePart: car.trackState.pitLanePart ?? null,
+      pitBoxId: car.trackState.pitBoxId ?? null,
+      curvature: car.trackState.curvature ?? 0,
+      heading: car.trackState.heading,
+    } : null,
     wheels: serializeWheels(car.wheelStates),
     inPitLane: Boolean(car.trackState?.inPitLane),
     pitLanePart: car.trackState?.pitLanePart ?? null,
@@ -193,6 +211,8 @@ export function serializeObservationCar(car, rank, dependencies) {
     heading: car.heading,
     steeringAngle: car.steeringAngle,
     yawRate: car.yawRate,
+    velocityX: serializeVelocityComponent(car, 'velocityX', dependencies),
+    velocityY: serializeVelocityComponent(car, 'velocityY', dependencies),
     speed: car.speed,
     speedKph: simSpeedToKph(car.speed),
     throttle: car.throttle,
@@ -261,6 +281,8 @@ export function serializeTrainingCar(car, rank, dependencies) {
     heading: car.heading,
     steeringAngle: car.steeringAngle,
     yawRate: car.yawRate,
+    velocityX: serializeVelocityComponent(car, 'velocityX', dependencies),
+    velocityY: serializeVelocityComponent(car, 'velocityY', dependencies),
     speed: car.speed,
     speedKph: simSpeedToKph(car.speed),
     throttle: car.throttle,

package/src/simulation/vehicle/vehicleState.js

@@ -121,6 +121,7 @@ export function applyExternalCarState(car, partial, context) {
     cars,
     computeLap,
     nearestDistanceOnRoute,
+    physicsMode,
     progressDelta,
     raceControl,
     releaseRaceStart,
@@ -137,6 +138,7 @@ export function applyExternalCarState(car, partial, context) {
     if (partial.destroyed === false) nextPartial.destroyed = car.destroyed;
     if (partial.outOfRace === false) nextPartial.outOfRace = car.outOfRace;
   }
+  assertFiniteExternalCarState(nextPartial);
   Object.assign(car, nextPartial);
   if (
     !raceControl.finished &&
@@ -160,8 +162,9 @@ export function applyExternalCarState(car, partial, context) {
       releaseRaceStart();
     }
   }
-  car.speed = clamp(car.speed, 0, VEHICLE_LIMITS.maxSpeed);
-  car.heading = normalizeAngle(car.heading);
+  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');
   const centerState = nearestTrackStateForCar(track, car, car, car.progress ?? car.raceDistance);
   applyWheelSurfaceState(car, track, { centerState });
   if (
@@ -184,3 +187,34 @@ export function applyExternalCarState(car, partial, context) {
   resetTimingLineCrossings(car, time);
   resetLapTelemetry(car, time, track, totalLaps);
 }
+
+function assertFiniteExternalCarState(partial) {
+  Object.entries(partial ?? {}).forEach(([key, value]) => {
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+      throw new Error(`External car state ${key} must be a finite number.`);
+    }
+  });
+}
+
+function syncExternalVelocityState(car, partial, simulatorMode = false) {
+  const hasVelocityX = Object.hasOwn(partial, 'velocityX');
+  const hasVelocityY = Object.hasOwn(partial, 'velocityY');
+  const hasVelocity = hasVelocityX || hasVelocityY;
+  if (hasVelocity && (partial.velocityX == null || partial.velocityY == null)) {
+    car.velocityX = null;
+    car.velocityY = null;
+    return;
+  }
+  if (hasVelocity) {
+    const fallbackX = Math.cos(car.heading) * car.speed;
+    const fallbackY = Math.sin(car.heading) * car.speed;
+    car.velocityX = Number.isFinite(car.velocityX) ? car.velocityX : fallbackX;
+    car.velocityY = Number.isFinite(car.velocityY) ? car.velocityY : fallbackY;
+    car.speed = clamp(Math.hypot(car.velocityX, car.velocityY), 0, VEHICLE_LIMITS.maxSpeed);
+    return;
+  }
+  if (simulatorMode && (Object.hasOwn(partial, 'speed') || Object.hasOwn(partial, 'heading'))) {
+    car.velocityX = Math.cos(car.heading) * car.speed;
+    car.velocityY = Math.sin(car.heading) * car.speed;
+  }
+}

package/src/simulation/vehicle/wheelSurface.js

@@ -121,12 +121,14 @@ export function applyWheelSurfaceState(car, track, options = {}) {
     track,
     geometrySignature: geometry.signature,
     centerSignature: centerStateSignature(options.centerState),
+    pitOverrideAllowed: pitOverrideAllowedForCar(car),
   };
   const cached = car.wheelSurfaceCache;
   if (
     cached?.track === cacheKey.track &&
     cached.geometrySignature === cacheKey.geometrySignature &&
-    cached.centerSignature === cacheKey.centerSignature
+    cached.centerSignature === cacheKey.centerSignature &&
+    cached.pitOverrideAllowed === cacheKey.pitOverrideAllowed
   ) {
     car.wheelStates = cached.result.wheels;
     car.trackLimitState = cached.result.trackLimits;

package/src/simulation/warmup/runtimeWarmup.js

@@ -116,7 +116,6 @@ function createWarmupFingerprint(options, { surface, steps }) {
     trackGeneration: options.trackGeneration ?? null,
     track: summarizeTrack(options.track),
     physicsMode: options.physicsMode ?? null,
-    trackQueryIndex: options.trackQueryIndex !== false,
     rules: options.rules ?? null,
     participantInteractions: options.participantInteractions ?? null,
     replayGhosts: summarizeReplayGhosts(options.replayGhosts),