@inventure71/paddockjs 3.0.0 → 4.1.0

package/src/simulation/vehicle/contactResolution.js

@@ -1,4 +1,9 @@
-import { buildCollisionCandidatePairs, detectVehicleCollision } from '../collisionGeometry.js';
+import {
+  buildCollisionCandidatePairs,
+  collisionCandidatePairFirstIndex,
+  collisionCandidatePairSecondIndex,
+  detectVehicleCollision,
+} from '../collisionGeometry.js';
 import { canCollide, isCollidable } from '../participants/participantInteractions.js';
 import { clamp, normalizeAngle } from '../simMath.js';
 import { VEHICLE_LIMITS } from './vehiclePhysics.js';
@@ -11,54 +16,84 @@ function isPitPositionControlledCar(car) {
   return status === 'entering' || status === 'queued' || status === 'servicing' || status === 'exiting';
 }
 
-function forwardVector(car) {
-  return { x: Math.cos(car.heading), y: Math.sin(car.heading) };
+function velocityComponentX(car) {
+  return Number.isFinite(car.velocityX) && Number.isFinite(car.velocityY)
+    ? car.velocityX
+    : Math.cos(car.heading) * car.speed;
 }
 
-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 velocityComponentY(car) {
+  return Number.isFinite(car.velocityX) && Number.isFinite(car.velocityY)
+    ? car.velocityY
+    : Math.sin(car.heading) * car.speed;
 }
 
-function applyVelocityVector(car, velocity) {
-  const speed = clamp(Math.hypot(velocity.x, velocity.y), 0, VEHICLE_LIMITS.maxSpeed);
+function applyVelocityScalars(car, velocityX, velocityY) {
+  const rawSpeed = Math.hypot(velocityX, velocityY);
+  const speed = clamp(rawSpeed, 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;
+  const scale = speed / Math.max(1e-9, rawSpeed);
+  car.velocityX = velocityX * scale;
+  car.velocityY = velocityY * scale;
   car.speed = speed;
 }
 
+function recordContactVelocityResponse(stats) {
+  if (!stats) return;
+  stats.contactVelocityResponses += 1;
+  stats.contactVelocityVectorObjectAllocations += 0;
+}
+
+function prepareReportedContactMarks(scratch, carCount) {
+  const requiredLength = Math.max(1, carCount * carCount);
+  if (!(scratch.reportedContactMarks instanceof Uint32Array) || scratch.reportedContactMarks.length < requiredLength) {
+    scratch.reportedContactMarks = new Uint32Array(requiredLength);
+  }
+  scratch.reportedContactEpoch = ((scratch.reportedContactEpoch ?? 0) + 1) >>> 0;
+  if (scratch.reportedContactEpoch === 0) {
+    scratch.reportedContactMarks.fill(0);
+    scratch.reportedContactEpoch = 1;
+  }
+  return scratch.reportedContactMarks;
+}
+
+function contactMarkIndex(firstIndex, secondIndex, carCount) {
+  const low = firstIndex < secondIndex ? firstIndex : secondIndex;
+  const high = firstIndex < secondIndex ? secondIndex : firstIndex;
+  return low * carCount + high;
+}
+
 export function resolveCollisionsForSimulation(sim) {
-  const collidableCars = sim.cars.filter(isCollidable);
+  sim.collisionScratch ??= {};
+  const collidableCars = sim.collisionScratch.collidableCars ?? [];
+  sim.collisionScratch.collidableCars = collidableCars;
+  collidableCars.length = 0;
+  for (let index = 0; index < sim.cars.length; index += 1) {
+    const car = sim.cars[index];
+    if (isCollidable(car)) collidableCars.push(car);
+  }
   if (collidableCars.length < 2) return;
-  const reportedContacts = new Set();
+  const reportedContactMarks = prepareReportedContactMarks(sim.collisionScratch, collidableCars.length);
+  const reportedContactEpoch = sim.collisionScratch.reportedContactEpoch;
 
   for (let pass = 0; pass < 3; pass += 1) {
-    const candidates = buildCollisionCandidatePairs(collidableCars, { trackLength: sim.track.length });
-    for (const [first, second] of candidates) {
+    const candidates = buildCollisionCandidatePairs(collidableCars, {
+      trackLength: sim.track.length,
+      scratch: sim.collisionScratch,
+    });
+    for (const pair of candidates) {
+      const [first, second] = pair;
       if (!canCollide(first, second)) continue;
-      const collision = detectVehicleCollision(first, second);
+      const collision = detectVehicleCollision(first, second, { scratch: sim.collisionScratch });
       if (!collision) continue;
       const firstPitControlled = isPitPositionControlledCar(first);
       const secondPitControlled = isPitPositionControlledCar(second);
       if (firstPitControlled && secondPitControlled) continue;
-      const stewardCollision = {
-        ...collision,
-        trackLength: sim.track.length,
-      };
       const oneCarFixed = firstPitControlled || secondPitControlled;
 
       const correction = Math.min(
@@ -100,9 +135,15 @@ export function resolveCollisionsForSimulation(sim) {
       first.contactCooldown = 1;
       second.contactCooldown = 1;
 
-      const contactKey = `${first.id}:${second.id}`;
-      if (freshContact && pass === 0 && !reportedContacts.has(contactKey)) {
-        reportedContacts.add(contactKey);
+      const firstPairIndex = collisionCandidatePairFirstIndex(pair);
+      const secondPairIndex = collisionCandidatePairSecondIndex(pair);
+      const canMarkContact = firstPairIndex >= 0 && secondPairIndex >= 0;
+      const contactIndex = canMarkContact
+        ? contactMarkIndex(firstPairIndex, secondPairIndex, collidableCars.length)
+        : -1;
+      const alreadyReported = canMarkContact && reportedContactMarks[contactIndex] === reportedContactEpoch;
+      if (freshContact && pass === 0 && !alreadyReported) {
+        if (canMarkContact) reportedContactMarks[contactIndex] = reportedContactEpoch;
         sim.events.unshift({
           type: 'contact',
           at: sim.time,
@@ -114,48 +155,44 @@ export function resolveCollisionsForSimulation(sim) {
           depth: collision.depth,
           timeOfImpact: collision.timeOfImpact,
         });
-        sim.reviewCollision(first, second, stewardCollision);
+        sim.reviewCollision(first, second, collision, {
+          scratch: sim.collisionScratch,
+          trackLength: sim.track.length,
+        });
       }
     }
   }
 }
 
-export function applyContactVelocityResponse(sim, first, second, axis) {
+export function applyContactVelocityResponse(sim, first, second, axis, options = {}) {
+  recordContactVelocityResponse(options.stats);
   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);
+    let firstVelocityX = velocityComponentX(first);
+    let firstVelocityY = velocityComponentY(first);
+    let secondVelocityX = velocityComponentX(second);
+    let secondVelocityY = velocityComponentY(second);
+    const relativeNormalVelocity = (secondVelocityX - firstVelocityX) * axis.x +
+      (secondVelocityY - firstVelocityY) * axis.y;
 
     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;
+      firstVelocityX -= axis.x * impulse;
+      firstVelocityY -= axis.y * impulse;
+      secondVelocityX += axis.x * impulse;
+      secondVelocityY += 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,
-    });
+    applyVelocityScalars(first, firstVelocityX * 0.997, firstVelocityY * 0.997);
+    applyVelocityScalars(second, secondVelocityX * 0.997, secondVelocityY * 0.997);
     return;
   }
 
-  const firstForward = forwardVector(first);
-  const secondForward = forwardVector(second);
-  const firstNormal = dot(firstForward, axis);
-  const secondNormal = dot(secondForward, axis);
+  const firstNormal = Math.cos(first.heading) * axis.x + Math.sin(first.heading) * axis.y;
+  const secondNormal = Math.cos(second.heading) * axis.x + Math.sin(second.heading) * axis.y;
   const relativeNormalVelocity = second.speed * secondNormal - first.speed * firstNormal;
 
   if (relativeNormalVelocity < 0) {
@@ -170,11 +207,11 @@ export function applyContactVelocityResponse(sim, first, second, axis) {
 
 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,
-    });
+    applyVelocityScalars(
+      car,
+      velocityComponentX(car) * factor,
+      velocityComponentY(car) * factor,
+    );
     return;
   }
   car.speed = clamp(car.speed * factor, 0, VEHICLE_LIMITS.maxSpeed);

package/src/simulation/vehicle/mainTrackWheelSurface.js

@@ -11,8 +11,13 @@ export function mainTrackSurface(track, crossTrackError) {
 }
 
 export function wheelFullyOutside(samples, trackLimit) {
-  const rightOutside = samples.every((state) => !state.inPitLane && state.signedOffset > trackLimit);
-  const leftOutside = samples.every((state) => !state.inPitLane && state.signedOffset < -trackLimit);
+  let rightOutside = true;
+  let leftOutside = true;
+  for (let index = 0; index < samples.length; index += 1) {
+    const state = samples[index];
+    if (state.inPitLane || state.signedOffset <= trackLimit) rightOutside = false;
+    if (state.inPitLane || state.signedOffset >= -trackLimit) leftOutside = false;
+  }
   return {
     rightOutside,
     leftOutside,
@@ -33,50 +38,84 @@ export function wheelOutsideFromOffsets(minimumSignedOffset, maximumSignedOffset
 }
 
 export function analyticWheelState(patch, centerState, track, trackLimit) {
+  return writeAnalyticWheelStateWithProjectedHalfWidth(
+    {},
+    patch,
+    centerState,
+    track,
+    trackLimit,
+    analyticWheelProjectedHalfWidth(patch, centerState),
+  );
+}
+
+export function writeAnalyticWheelState(target, patch, centerState, track, trackLimit) {
+  return writeAnalyticWheelStateWithProjectedHalfWidth(
+    target,
+    patch,
+    centerState,
+    track,
+    trackLimit,
+    analyticWheelProjectedHalfWidth(patch, centerState),
+  );
+}
+
+export function analyticWheelProjectedHalfWidth(patch, centerState) {
+  return (
+    Math.abs(patch.forward.x * centerState.normalX + patch.forward.y * centerState.normalY) * patch.halfLength +
+    Math.abs(patch.right.x * centerState.normalX + patch.right.y * centerState.normalY) * patch.halfWidth
+  );
+}
+
+export function writeAnalyticWheelStateWithProjectedHalfWidth(
+  target,
+  patch,
+  centerState,
+  track,
+  trackLimit,
+  projectedHalfWidth,
+) {
   const wheelCenterOffset =
     (patch.center.x - centerState.x) * centerState.normalX +
     (patch.center.y - centerState.y) * centerState.normalY;
-  const projectedHalfWidth =
-    Math.abs(patch.forward.x * centerState.normalX + patch.forward.y * centerState.normalY) * patch.halfLength +
-    Math.abs(patch.right.x * centerState.normalX + patch.right.y * centerState.normalY) * patch.halfWidth;
   const minimumSignedOffset = wheelCenterOffset - projectedHalfWidth;
   const maximumSignedOffset = wheelCenterOffset + projectedHalfWidth;
   const signedOffset = Math.abs(minimumSignedOffset) > Math.abs(maximumSignedOffset)
     ? minimumSignedOffset
     : maximumSignedOffset;
-  const state = stateFromSignedOffset(centerState, track, signedOffset);
   const outside = wheelOutsideFromOffsets(minimumSignedOffset, maximumSignedOffset, trackLimit);
+  const sampledStates = target.sampledStates ?? [];
+  const state = sampledStates.length === 1 ? (sampledStates[0] ?? {}) : {};
+  sampledStates.length = 1;
+  sampledStates[0] = state;
+  writeStateFromSignedOffset(state, centerState, track, signedOffset);
 
-  return {
-    id: patch.id,
-    x: patch.center.x,
-    y: patch.center.y,
-    signedOffset: state.signedOffset,
-    crossTrackError: state.crossTrackError,
-    surface: state.surface,
-    onTrack: Boolean(state.onTrack),
-    inPitLane: false,
-    pitLanePart: null,
-    pitBoxId: null,
-    minimumSignedOffset,
-    maximumSignedOffset,
-    fullyOutsideWhiteLine: outside.fullyOutsideWhiteLine,
-    outsideSide: outside.outsideSide,
-    sampledStates: [state],
-  };
+  target.id = patch.id;
+  target.x = patch.center.x;
+  target.y = patch.center.y;
+  target.signedOffset = state.signedOffset;
+  target.crossTrackError = state.crossTrackError;
+  target.surface = state.surface;
+  target.onTrack = Boolean(state.onTrack);
+  target.inPitLane = false;
+  target.pitLanePart = null;
+  target.pitBoxId = null;
+  target.minimumSignedOffset = minimumSignedOffset;
+  target.maximumSignedOffset = maximumSignedOffset;
+  target.fullyOutsideWhiteLine = outside.fullyOutsideWhiteLine;
+  target.outsideSide = outside.outsideSide;
+  target.sampledStates = sampledStates;
+  return target;
 }
 
-function stateFromSignedOffset(centerState, track, signedOffset) {
+function writeStateFromSignedOffset(target, centerState, track, signedOffset) {
   const crossTrackError = Math.abs(signedOffset);
   const surface = mainTrackSurface(track, crossTrackError);
-  return {
-    ...centerState,
-    signedOffset,
-    crossTrackError,
-    surface,
-    onTrack: surface === 'track' || surface === 'kerb',
-    inPitLane: false,
-    pitLanePart: null,
-    pitBoxId: null,
-  };
+  target.signedOffset = signedOffset;
+  target.crossTrackError = crossTrackError;
+  target.surface = surface;
+  target.onTrack = surface === 'track' || surface === 'kerb';
+  target.inPitLane = false;
+  target.pitLanePart = null;
+  target.pitBoxId = null;
+  return target;
 }

package/src/simulation/vehicle/pitWheelSurface.js

@@ -2,10 +2,6 @@ import { metersToSimUnits } from '../units.js';
 
 const PIT_CONNECTOR_FULL_SAMPLE_WINDOW = metersToSimUnits(35);
 
-export function patchSamples(patch) {
-  return [patch.center, ...patch.corners];
-}
-
 export function isNearPitConnector(track, centerState) {
   const pitLane = track.pitLane;
   if (!pitLane?.enabled) return false;
@@ -20,33 +16,81 @@ export function canUseAnalyticPitWheels(geometry, centerState) {
   const roadWidth = Number(centerState?.pitLaneRoadWidth);
   if (!centerState?.inPitLane || !Number.isFinite(roadWidth) || roadWidth <= 0) return false;
   const halfRoadWidth = roadWidth / 2;
-  return geometry.contactPatches.every((patch) => {
-    const range = patchPitOffsetRange(patch, centerState);
-    return range.minimum >= -halfRoadWidth - 0.001 && range.maximum <= halfRoadWidth + 0.001;
-  });
+  for (let index = 0; index < geometry.contactPatches.length; index += 1) {
+    const range = patchPitOffsetRange(geometry.contactPatches[index], centerState);
+    if (range.minimum < -halfRoadWidth - 0.001 || range.maximum > halfRoadWidth + 0.001) return false;
+  }
+  return true;
+}
+
+export function canSkipConnectorPitChecks(track, geometry, centerState, epsilon = 0.001) {
+  const laneSide = Math.sign(track?.pitLane?.side ?? 0);
+  if (
+    !laneSide ||
+    !geometry?.contactPatches?.length ||
+    !centerState ||
+    centerState.inPitLane ||
+    !centerState.onTrack
+  ) return false;
+  for (let index = 0; index < geometry.contactPatches.length; index += 1) {
+    if (!connectorPitCheckCanBeSkippedForPatch(track, geometry.contactPatches[index], centerState, epsilon)) return false;
+  }
+  return true;
+}
+
+export function pitPatchOffsetRange(patch, centerState) {
+  return patchPitOffsetRange(patch, centerState);
 }
 
-export function analyticPitWheelState(patch, centerState) {
+export function pitPatchInsideRoad(patch, centerState, epsilon = 0.001) {
+  const roadWidth = Number(centerState?.pitLaneRoadWidth);
+  if (!centerState?.inPitLane || !Number.isFinite(roadWidth) || roadWidth <= 0) return false;
+  const halfRoadWidth = roadWidth / 2;
   const range = patchPitOffsetRange(patch, centerState);
-  return {
-    id: patch.id,
-    x: patch.center.x,
-    y: patch.center.y,
-    signedOffset: centerState.mainTrackSignedOffset ?? centerState.signedOffset,
-    crossTrackError: centerState.mainTrackCrossTrackError ?? centerState.crossTrackError,
-    surface: centerState.surface,
-    onTrack: true,
-    inPitLane: true,
-    pitLanePart: centerState.pitLanePart ?? null,
-    pitBoxId: centerState.pitBoxId ?? null,
-    minimumSignedOffset: centerState.mainTrackSignedOffset ?? centerState.signedOffset,
-    maximumSignedOffset: centerState.mainTrackSignedOffset ?? centerState.signedOffset,
-    pitLaneMinimumSignedOffset: range.minimum,
-    pitLaneMaximumSignedOffset: range.maximum,
-    fullyOutsideWhiteLine: false,
-    outsideSide: 0,
-    sampledStates: [centerState],
-  };
+  return range.minimum >= -halfRoadWidth - epsilon && range.maximum <= halfRoadWidth + epsilon;
+}
+
+export function pitPatchOverlapsRoad(patch, centerState, epsilon = 0.001) {
+  const roadWidth = Number(centerState?.pitLaneRoadWidth);
+  if (!centerState?.inPitLane || !Number.isFinite(roadWidth) || roadWidth <= 0) return false;
+  const halfRoadWidth = roadWidth / 2;
+  const range = patchPitOffsetRange(patch, centerState);
+  return range.minimum <= halfRoadWidth + epsilon && range.maximum >= -halfRoadWidth - epsilon;
+}
+
+export function writeAnalyticPitWheelState(target, patch, centerState) {
+  const range = patchPitOffsetRange(patch, centerState);
+  const signedOffset = centerState.mainTrackSignedOffset ?? centerState.signedOffset;
+  const sampledStates = target.sampledStates ?? [];
+  const sampleState = sampledStates.length === 1 ? (sampledStates[0] ?? {}) : {};
+  sampledStates.length = 1;
+  sampledStates[0] = sampleState;
+  sampleState.signedOffset = centerState.signedOffset;
+  sampleState.crossTrackError = centerState.crossTrackError;
+  sampleState.surface = centerState.surface;
+  sampleState.onTrack = Boolean(centerState.onTrack);
+  sampleState.inPitLane = true;
+  sampleState.pitLanePart = centerState.pitLanePart ?? null;
+  sampleState.pitBoxId = centerState.pitBoxId ?? null;
+
+  target.id = patch.id;
+  target.x = patch.center.x;
+  target.y = patch.center.y;
+  target.signedOffset = signedOffset;
+  target.crossTrackError = centerState.mainTrackCrossTrackError ?? centerState.crossTrackError;
+  target.surface = centerState.surface;
+  target.onTrack = true;
+  target.inPitLane = true;
+  target.pitLanePart = centerState.pitLanePart ?? null;
+  target.pitBoxId = centerState.pitBoxId ?? null;
+  target.minimumSignedOffset = signedOffset;
+  target.maximumSignedOffset = signedOffset;
+  target.pitLaneMinimumSignedOffset = range.minimum;
+  target.pitLaneMaximumSignedOffset = range.maximum;
+  target.fullyOutsideWhiteLine = false;
+  target.outsideSide = 0;
+  target.sampledStates = sampledStates;
+  return target;
 }
 
 function patchPitOffsetRange(patch, centerState) {
@@ -62,6 +106,15 @@ function patchPitOffsetRange(patch, centerState) {
   };
 }
 
+function connectorPitCheckCanBeSkippedForPatch(track, patch, centerState, epsilon) {
+  const laneSide = Math.sign(track?.pitLane?.side ?? 0);
+  if (!laneSide || !patch || !centerState || centerState.inPitLane || !centerState.onTrack) return false;
+  const range = patchPitOffsetRange(patch, centerState);
+  return laneSide > 0
+    ? range.maximum <= epsilon
+    : range.minimum >= -epsilon;
+}
+
 function wrappedDistanceDelta(first, second, length) {
   if (!Number.isFinite(first) || !Number.isFinite(second) || !Number.isFinite(length) || length <= 0) return Infinity;
   const delta = Math.abs(first - second);

package/src/simulation/vehicle/runoffResponse.js

@@ -1,58 +1,83 @@
-import { VEHICLE_GEOMETRY, getVehicleGeometryState, vehicleAxes } from './vehicleGeometry.js';
+import {
+  VEHICLE_GEOMETRY,
+  vehicleAxes,
+} from './vehicleGeometry.js';
 import { applyWheelSurfaceState } from './wheelSurface.js';
 import { freezeVehicleMotion } from './vehicleKinematics.js';
-import { nearestTrackStateForCar, pitOverrideAllowedForCar } from '../track/trackStatePolicy.js';
+import { queryRunoffTrackStateForCar } from '../track/trackStatePolicy.js';
 import { markCarDnf } from '../race/retirements.js';
 
+export function clearRunoffCenterState(car) {
+  if (car) car.pendingRunoffCenterState = null;
+}
+
+export function storeRunoffCenterState(car, state) {
+  car.pendingRunoffCenterState = {
+    state,
+    x: car.x,
+    y: car.y,
+    heading: car.heading,
+  };
+}
+
+export function takeValidRunoffCenterState(car) {
+  const pending = car?.pendingRunoffCenterState;
+  if (!pending) return null;
+  car.pendingRunoffCenterState = null;
+  return pending.x === car.x &&
+    pending.y === car.y &&
+    pending.heading === car.heading
+    ? pending.state
+    : null;
+}
+
 export function applyRunoffResponseForSimulation(sim, car) {
   if (car.destroyed) {
+    clearRunoffCenterState(car);
     freezeBarrierMotion(car, sim.physicsMode);
     applyWheelSurfaceState(car, sim.track);
     return;
   }
-  const allowPitOverride = pitOverrideAllowedForCar(car);
-  const state = nearestTrackStateForCar(sim.track, car, car, car.progress, { allowPitOverride });
-  const mainTrackState = state.inPitLane
-    ? nearestTrackStateForCar(sim.track, car, car, car.progress, { allowPitOverride: false })
-    : state;
+  const { state, mainTrackState } = queryRunoffTrackStateForCar(sim.track, car);
   const barrierCenter = sim.track.width / 2 + (sim.track.kerbWidth ?? 0) + sim.track.gravelWidth + sim.track.runoffWidth;
   const signedLimit = barrierCenter - (sim.track.barrierWidth ?? 0) / 2;
   const side = Math.sign(mainTrackState.signedOffset) || 1;
   const outwardReach = getOutwardVehicleReach(car, mainTrackState, side);
   const overshoot = Math.abs(mainTrackState.signedOffset) + outwardReach - signedLimit;
   if (overshoot <= 0) {
-    if (state.inPitLane) {
-      applyWheelSurfaceState(car, sim.track, { centerState: state });
-      return;
-    }
-    applyWheelSurfaceState(car, sim.track, { centerState: state });
+    storeRunoffCenterState(car, state);
     return;
   }
 
+  clearRunoffCenterState(car);
   destroyCarOnBarrier(sim, car);
   applyWheelSurfaceState(car, sim.track, { centerState: mainTrackState });
 }
 
 function getOutwardVehicleReach(car, state, side) {
-  const visualReach = getVisualFootprintOutwardReach(car, state);
-  const geometry = getVehicleGeometryState(car);
-  let reach = visualReach;
-  geometry.current.shapes.forEach((shape) => {
-    shape.corners.forEach((corner) => {
-      const lateral =
-        (corner.x - car.x) * state.normalX +
-        (corner.y - car.y) * state.normalY;
-      reach = Math.max(reach, lateral * side);
-    });
-  });
-  return reach;
+  const axes = vehicleAxes(car.heading ?? 0);
+  const forwardDot = axes.forward.x * state.normalX + axes.forward.y * state.normalY;
+  const rightDot = axes.right.x * state.normalX + axes.right.y * state.normalY;
+  return Math.max(
+    orientedHalfExtent(VEHICLE_GEOMETRY.visualLength / 2, VEHICLE_GEOMETRY.visualWidth / 2, forwardDot, rightDot),
+    orientedHalfExtent(VEHICLE_GEOMETRY.bodyLength / 2, VEHICLE_GEOMETRY.bodyWidth / 2, forwardDot, rightDot),
+    wheelOutwardReach(forwardDot, rightDot, side),
+  );
 }
 
-function getVisualFootprintOutwardReach(car, state) {
-  const axes = vehicleAxes(car.heading ?? 0);
-  return (
-    Math.abs(axes.forward.x * state.normalX + axes.forward.y * state.normalY) * VEHICLE_GEOMETRY.visualLength / 2 +
-    Math.abs(axes.right.x * state.normalX + axes.right.y * state.normalY) * VEHICLE_GEOMETRY.visualWidth / 2
+function orientedHalfExtent(halfLength, halfWidth, forwardDot, rightDot) {
+  return Math.abs(forwardDot) * halfLength + Math.abs(rightDot) * halfWidth;
+}
+
+function wheelOutwardReach(forwardDot, rightDot, side) {
+  const centerOffset =
+    Math.abs(forwardDot) * VEHICLE_GEOMETRY.wheelLongitudinalOffset +
+    Math.abs(rightDot * side) * VEHICLE_GEOMETRY.wheelLateralOffset;
+  return centerOffset + orientedHalfExtent(
+    VEHICLE_GEOMETRY.wheelLength / 2,
+    VEHICLE_GEOMETRY.wheelWidth / 2,
+    forwardDot,
+    rightDot,
   );
 }