@inventure71/paddockjs 3.0.0 → 4.1.0

package/src/simulation/pit/pitRouteMovement.js

@@ -6,7 +6,7 @@ import {
   distanceToNextLimiterSegment,
   nearestDistanceOnRoute,
   routeLimiterActiveAt,
-  sampleRoute,
+  sampleRouteInto,
 } from './pitRouting.js';
 import { syncPitCarKinematics } from './pitKinematics.js';
 import { completePitPenaltyService } from './pitPenaltyService.js';
@@ -26,6 +26,11 @@ import {
   pointDistance,
 } from './pitServiceConstants.js';
 
+function samplePitStopRoute(stop, route, distanceAlong) {
+  const target = stop.routeSample ?? (stop.routeSample = { x: 0, y: 0, heading: 0, limiterActive: false });
+  return sampleRouteInto(target, route, distanceAlong);
+}
+
 export function applyPitRoutePosition(sim, car, delta) {
   const stop = car.pitStop;
   if (!stop?.route) return false;
@@ -33,7 +38,7 @@ export function applyPitRoutePosition(sim, car, delta) {
   const route = stop.route;
   if (stop.phase === 'queue-release') {
     const nextProgress = Math.min(route.length, (stop.routeProgress ?? 0) + PIT_QUEUE_RELEASE_SPEED * delta);
-    const point = sampleRoute(route, nextProgress);
+    const point = samplePitStopRoute(stop, route, nextProgress);
     if (!point) return false;
     const previousHeading = car.heading;
     car.previousX = car.x;
@@ -63,7 +68,7 @@ export function applyPitRoutePosition(sim, car, delta) {
     return route.length - stop.routeProgress <= PIT_QUEUE_RELEASE_FINISH_DISTANCE;
   }
   stop.routeProgress = clamp(nearestDistanceOnRoute(route, car, stop.routeProgress ?? 0), 0, route.length);
-  const routeEnd = route.points.at(-1);
+  const routeEnd = route.points[route.points.length - 1];
   const limiterActive = routeLimiterActiveAt(route, stop.routeProgress);
   let targetSpeed = limiterActive
     ? Math.min(speedLimit, VEHICLE_LIMITS.maxSpeed)
@@ -93,7 +98,7 @@ export function applyPitRoutePosition(sim, car, delta) {
   }
 
   const nextProgress = Math.min(route.length, stop.routeProgress + Math.max(0, targetSpeed) * delta);
-  const point = sampleRoute(route, nextProgress);
+  const point = samplePitStopRoute(stop, route, nextProgress);
   if (!point) return false;
   const previousSpeed = car.speed;
   const previousHeading = car.heading;

package/src/simulation/pit/pitRouting.js

@@ -128,18 +128,17 @@ export function pointDistance(first, second) {
 }
 
 export function createRoute(points) {
-  const routePoints = points
-    .filter(Boolean)
-    .map((point) => routePoint(point))
-    .filter(Boolean)
-    .reduce((deduped, point) => {
-      if (!sameRoutePoint(deduped.at(-1), point)) {
-        deduped.push(point);
-      } else if (point.limiterActive) {
-        deduped.at(-1).limiterActive = true;
-      }
-      return deduped;
-    }, []);
+  const routePoints = [];
+  for (let index = 0; index < points.length; index += 1) {
+    const point = routePoint(points[index]);
+    if (!point) continue;
+    const previous = routePoints.length > 0 ? routePoints[routePoints.length - 1] : null;
+    if (!sameRoutePoint(previous, point)) {
+      routePoints.push(point);
+    } else if (point.limiterActive) {
+      previous.limiterActive = true;
+    }
+  }
   const segments = [];
   let totalLength = 0;
 
@@ -176,6 +175,12 @@ export function createRoute(points) {
   };
 }
 
+function recordRouteBenchmarkStat(route, key, amount = 1) {
+  const stats = route?.runtimeBenchmarkStats;
+  if (!stats) return;
+  stats[key] = (stats[key] ?? 0) + amount;
+}
+
 function findRouteSegment(route, distanceAlong, endPadding = 0) {
   if (!route?.segments?.length) return null;
   const clampedDistance = clamp(distanceAlong, 0, route.length);
@@ -205,35 +210,62 @@ function findRouteSegment(route, distanceAlong, endPadding = 0) {
     clampedDistance < segment.startDistance - 0.001 ||
     clampedDistance > segment.endDistance - endPadding
   ) {
-    segment = segments.find((candidate) => (
-      clampedDistance >= candidate.startDistance - 0.001 &&
-      clampedDistance <= candidate.endDistance - endPadding
-    )) ?? segments.at(-1);
-    index = segments.indexOf(segment);
+    recordRouteBenchmarkStat(route, 'segmentFallbackScans');
+    segment = segments[segments.length - 1];
+    index = segments.length - 1;
+    for (let candidateIndex = 0; candidateIndex < segments.length; candidateIndex += 1) {
+      const candidate = segments[candidateIndex];
+      if (
+        clampedDistance >= candidate.startDistance - 0.001 &&
+        clampedDistance <= candidate.endDistance - endPadding
+      ) {
+        segment = candidate;
+        index = candidateIndex;
+        break;
+      }
+    }
   }
 
   route.segmentCursor = Math.max(0, index);
   return segment;
 }
 
-export function sampleRoute(route, distanceAlong) {
-  if (!route?.segments?.length) return route?.points?.[0] ?? null;
+function writeRouteSample(target, route, distanceAlong, statKey) {
+  if (!route?.segments?.length) {
+    const point = route?.points?.[0] ?? null;
+    if (!point || !target) return point;
+    target.x = point.x;
+    target.y = point.y;
+    target.heading = point.heading;
+    target.limiterActive = Boolean(point.limiterActive);
+    return target;
+  }
+  const output = target ?? {};
   const clampedDistance = clamp(distanceAlong, 0, route.length);
-  const segment = findRouteSegment(route, clampedDistance) ?? route.segments.at(-1);
+  const segment = findRouteSegment(route, clampedDistance) ?? route.segments[route.segments.length - 1];
   const amount = clamp((clampedDistance - segment.startDistance) / segment.length, 0, 1);
 
-  return {
-    x: segment.start.x + (segment.end.x - segment.start.x) * amount,
-    y: segment.start.y + (segment.end.y - segment.start.y) * amount,
-    heading: segment.heading,
-    limiterActive: segment.limiterActive,
-  };
+  output.x = segment.start.x + (segment.end.x - segment.start.x) * amount;
+  output.y = segment.start.y + (segment.end.y - segment.start.y) * amount;
+  output.heading = segment.heading;
+  output.limiterActive = segment.limiterActive;
+  recordRouteBenchmarkStat(route, statKey);
+  return output;
+}
+
+export function sampleRouteInto(target, route, distanceAlong) {
+  return writeRouteSample(target, route, distanceAlong, 'sampleRouteIntoCalls');
+}
+
+export function sampleRoute(route, distanceAlong) {
+  if (!route?.segments?.length) return route?.points?.[0] ?? null;
+  return writeRouteSample({}, route, distanceAlong, 'sampleRouteAllocations');
 }
 
 export function routeLimiterActiveAt(route, distanceAlong) {
   if (!route?.segments?.length) return false;
   const clampedDistance = clamp(distanceAlong, 0, route.length);
-  const segment = findRouteSegment(route, clampedDistance, 0.001) ?? route.segments.at(-1);
+  const segment = findRouteSegment(route, clampedDistance, 0.001) ?? route.segments[route.segments.length - 1];
   return Boolean(segment?.limiterActive);
 }
 
@@ -251,7 +283,7 @@ function easeInOut(value) {
   return amount * amount * (3 - 2 * amount);
 }
 
-function projectPositionToSegment(position, segment) {
+function projectPositionToSegmentInto(target, position, segment) {
   const dx = segment.end.x - segment.start.x;
   const dy = segment.end.y - segment.start.y;
   const lengthSquared = dx * dx + dy * dy;
@@ -260,26 +292,29 @@ function projectPositionToSegment(position, segment) {
     : 0;
   const x = segment.start.x + dx * amount;
   const y = segment.start.y + dy * amount;
-  const distanceSquared = (position.x - x) ** 2 + (position.y - y) ** 2;
-
-  return {
-    distanceAlong: segment.startDistance + segment.length * amount,
-    distanceSquared,
-  };
+  target.distanceAlong = segment.startDistance + segment.length * amount;
+  target.distanceSquared = (position.x - x) ** 2 + (position.y - y) ** 2;
+  return target;
 }
 
 export function nearestDistanceOnRoute(route, position, previousDistance = 0) {
   if (!route?.segments?.length) return 0;
-  let best = null;
+  let bestDistanceAlong = previousDistance;
+  let bestDistanceSquared = Infinity;
   const backtrackAllowance = metersToSimUnits(90);
+  const projection = route._projectionScratch ?? (route._projectionScratch = { distanceAlong: 0, distanceSquared: 0 });
+
+  for (let index = 0; index < route.segments.length; index += 1) {
+    const segment = route.segments[index];
+    if (segment.endDistance < previousDistance - backtrackAllowance) continue;
+    projectPositionToSegmentInto(projection, position, segment);
+    if (projection.distanceSquared < bestDistanceSquared) {
+      bestDistanceSquared = projection.distanceSquared;
+      bestDistanceAlong = projection.distanceAlong;
+    }
+  }
 
-  route.segments.forEach((segment) => {
-    if (segment.endDistance < previousDistance - backtrackAllowance) return;
-    const projected = projectPositionToSegment(position, segment);
-    if (!best || projected.distanceSquared < best.distanceSquared) best = projected;
-  });
-
-  return clamp(best?.distanceAlong ?? previousDistance, 0, route.length);
+  return clamp(bestDistanceAlong, 0, route.length);
 }
 
 export function createPitApproachPoints(track, car, pitLane, entryRaceDistance) {

package/src/simulation/pit/pitState.js

@@ -103,6 +103,7 @@ export function initializePitStops({ cars, pitLane, pitStops, totalLaps, trackLe
       serviceProfile: null,
       queueingForService: false,
       route: null,
+      routeSample: null,
       routeProgress: 0,
       routeStartRaceDistance: null,
       routeEndRaceDistance: null,

package/src/simulation/pit/pitTireService.js

@@ -51,13 +51,17 @@ export function completePitService(sim, car) {
 
   const driveLaneOffset = pitDriveLaneOffset(pitLane);
   const boxReleaseDistance = Math.min(pitLane.mainLane.length, box.distanceAlongLane + PIT_BOX_APPROACH_DISTANCE);
-  const route = createRoute([
+  const routePoints = [
     routePoint(box.center, pitLane.mainLane.heading, { limiterActive: true }),
     routePoint(box.laneTarget, pitLane.mainLane.heading, { limiterActive: true }),
     routePoint(pitMainLanePointAt(pitLane, boxReleaseDistance, driveLaneOffset), pitLane.mainLane.heading, { limiterActive: true }),
     routePoint(pitMainLanePointAt(pitLane, pitLane.mainLane.length, driveLaneOffset), pitLane.mainLane.heading, { limiterActive: true }),
-    ...(pitLane.exit.roadCenterline ?? []).map((point) => routePoint(point)),
-  ]);
+  ];
+  const exitCenterline = pitLane.exit.roadCenterline ?? [];
+  for (let index = 0; index < exitCenterline.length; index += 1) {
+    routePoints.push(routePoint(exitCenterline[index]));
+  }
+  const route = createRoute(routePoints);
   stop.status = 'exiting';
   stop.phase = 'exit';
   stop.route = route;

package/src/simulation/race/raceFinish.js

@@ -1,13 +1,22 @@
 import { isRaceDnf } from './retirements.js';
 
-export function evaluateRaceFinishForSimulation(sim) {
+export function evaluateRaceFinishForSimulation(sim, orderedCars = sim.orderedCars()) {
   if (sim.raceControl.finished) return;
   if (sim.raceControl.mode === 'pre-start') return;
 
-  const ordered = sim.orderedCars();
-  const newlyFinished = ordered.filter((car) => !isRaceDnf(car) && !car.finished && car.raceDistance >= sim.finishDistance);
+  const ordered = orderedCars;
+  if (!ordered.length) return;
+
+  let allFinishedOrDnf = true;
+  let newlyFinishedCount = 0;
+  for (let index = 0; index < ordered.length; index += 1) {
+    const car = ordered[index];
+    if (isRaceDnf(car) || car.finished) continue;
+    if (car.raceDistance < sim.finishDistance) {
+      allFinishedOrDnf = false;
+      continue;
+    }
 
-  newlyFinished.forEach((car) => {
     car.finished = true;
     car.finishTime = sim.time;
     car.finishRank = sim.raceControl.finishOrder.length + 1;
@@ -27,9 +36,17 @@ export function evaluateRaceFinishForSimulation(sim) {
       winnerId: sim.raceControl.winnerId,
     });
     sim.reviewTireRequirement(car);
-  });
+    newlyFinishedCount += 1;
+  }
 
-  if (!ordered.length || !ordered.every((car) => car.finished || isRaceDnf(car))) return;
+  if (!allFinishedOrDnf) {
+    if (!newlyFinishedCount && sim.runtimeBenchmarkStats) {
+      sim.runtimeBenchmarkStats.finishEvalNoFinishFastPathCalls = (
+        sim.runtimeBenchmarkStats.finishEvalNoFinishFastPathCalls ?? 0
+      ) + 1;
+    }
+    return;
+  }
 
   sim.applyOutstandingServicePenalties();
   const classification = sim.buildClassificationFromFinishOrder();
@@ -41,8 +58,8 @@ export function evaluateRaceFinishForSimulation(sim) {
   sim.raceControl.classification = classification;
   sim.raceControl.frozenOrder = classification.map((entry) => entry.id);
   sim.safetyCar.deployed = true;
-  const leader = sim.cars.find((car) => car.id === sim.raceControl.winnerId) ?? ordered[0];
-  const safetyCarProgress = (leader?.raceDistance ?? 0) + sim.rules.safetyCarLeadDistance;
+  const safetyCarLeader = sim.cars.find((car) => car.id === sim.raceControl.winnerId) ?? ordered[0];
+  const safetyCarProgress = (safetyCarLeader?.raceDistance ?? 0) + sim.rules.safetyCarLeadDistance;
   if (sim.safetyCar.progress < safetyCarProgress) {
     sim.moveSafetyCarTo(safetyCarProgress);
   }

package/src/simulation/race/raceOrder.js

@@ -1,45 +1,194 @@
 import { clamp } from '../simMath.js';
 import { affectsRaceOrder } from '../participants/participantInteractions.js';
 import { distanceForward } from './raceDistance.js';
-import { isRaceDnf, raceDnfCars } from './retirements.js';
+import { compareDnfOrder, isRaceDnf } from './retirements.js';
 
 function canAppearInRaceOrder(car) {
   return car?.interaction?.affectsRaceOrder !== false;
 }
 
-export function orderedCarsForSimulation(sim) {
-  const raceCars = raceOrderCarsForSimulation(sim);
-  const dnfCars = raceDnfCars(sim.cars.filter(canAppearInRaceOrder));
-  const sortLive = (cars) => [...cars].sort((a, b) => {
+function partitionRaceOrderParticipants(cars) {
+  const live = [];
+  const dnf = [];
+  for (let index = 0; index < cars.length; index += 1) {
+    const car = cars[index];
+    if (!canAppearInRaceOrder(car)) continue;
+    if (isRaceDnf(car)) dnf.push(car);
+    else live.push(car);
+  }
+  dnf.sort(compareDnfOrder);
+  return { live, dnf };
+}
+
+function sortLiveRaceOrderInPlace(cars) {
+  cars.sort((a, b) => {
     const delta = b.raceDistance - a.raceDistance;
     return delta === 0 ? a.index - b.index : delta;
   });
-  const byId = new Map(sim.cars.map((car) => [car.id, car]));
+  return cars;
+}
+
+function appendCars(target, source) {
+  for (let index = 0; index < source.length; index += 1) {
+    target.push(source[index]);
+  }
+  return target;
+}
+
+function collectLiveRaceOrderedCars(orderedCars, scratch) {
+  const physicalCars = scratch?.physicalCars ?? [];
+  physicalCars.length = 0;
+  for (let index = 0; index < orderedCars.length; index += 1) {
+    const car = orderedCars[index];
+    if (!affectsRaceOrder(car) || isRaceDnf(car)) continue;
+    physicalCars.push(car);
+  }
+  if (scratch) scratch.physicalCars = physicalCars;
+  return physicalCars;
+}
+
+function sortPhysicalCarsInTrackOrder(sim, physicalCars) {
+  physicalCars.sort((a, b) => {
+    const progressDelta = (b.progress ?? b.raceDistance ?? 0) - (a.progress ?? a.raceDistance ?? 0);
+    if (progressDelta !== 0) return progressDelta;
+    const raceDistanceDelta = (b.raceDistance ?? 0) - (a.raceDistance ?? 0);
+    return raceDistanceDelta === 0 ? a.index - b.index : raceDistanceDelta;
+  });
+  return physicalCars;
+}
+
+function canUseRaceOrderAsPhysicalOrder(sim, physicalCars) {
+  if (physicalCars.length < 2) return true;
+  const leaderDistance = physicalCars[0]?.raceDistance;
+  const tailDistance = physicalCars[physicalCars.length - 1]?.raceDistance;
+  return Number.isFinite(leaderDistance) &&
+    Number.isFinite(tailDistance) &&
+    leaderDistance - tailDistance < sim.track.length - 1e-6;
+}
+
+function buildFullFieldDrsReferenceArrayForSimulation(sim, orderedCars, references) {
+  if (orderedCars.length !== sim.cars.length || !orderedCars.length) return false;
+  let wrappedEligibleCar = null;
+  for (let index = orderedCars.length - 1; index >= 0; index -= 1) {
+    const car = orderedCars[index];
+    if (!affectsRaceOrder(car) || isRaceDnf(car)) return false;
+    if (!car.finished && !sim.isCarInActivePitStop(car) && wrappedEligibleCar == null) {
+      wrappedEligibleCar = car;
+    }
+  }
+  if (!canUseRaceOrderAsPhysicalOrder(sim, orderedCars)) return false;
+
+  const trackLength = sim.track.length;
+  let previousEligibleCar = wrappedEligibleCar;
+  for (let index = 0; index < orderedCars.length; index += 1) {
+    const car = orderedCars[index];
+    const candidate = previousEligibleCar === car ? null : previousEligibleCar;
+    if (candidate) {
+      const delta = distanceForward(
+        car.progress ?? car.raceDistance ?? 0,
+        candidate.progress ?? candidate.raceDistance ?? 0,
+        trackLength,
+      );
+      references[car.index] = delta > 0 && delta <= trackLength / 2 ? candidate : null;
+    } else {
+      references[car.index] = null;
+    }
+    if (!car.finished && !sim.isCarInActivePitStop(car)) previousEligibleCar = car;
+  }
+  return true;
+}
+
+function buildDrsReferenceArrayForSimulation(sim, orderedCars = orderedCarsForSimulation(sim)) {
+  const scratch = sim._drsReferenceScratch ??= {};
+  const references = scratch.references ?? [];
+  references.length = sim.cars.length;
+  if (buildFullFieldDrsReferenceArrayForSimulation(sim, orderedCars, references)) {
+    scratch.references = references;
+    if (sim?.runtimeBenchmarkStats) {
+      sim.runtimeBenchmarkStats.drsReferenceScratchBuilds = (sim.runtimeBenchmarkStats.drsReferenceScratchBuilds ?? 0) + 1;
+      sim.runtimeBenchmarkStats.drsReferenceFullFieldFastPathCalls = (sim.runtimeBenchmarkStats.drsReferenceFullFieldFastPathCalls ?? 0) + 1;
+      sim.runtimeBenchmarkStats.drsReferenceOrderedFastPathCalls = (sim.runtimeBenchmarkStats.drsReferenceOrderedFastPathCalls ?? 0) + 1;
+    }
+    return references;
+  }
+  const physicalCars = collectLiveRaceOrderedCars(orderedCars, scratch);
+  for (let index = 0; index < references.length; index += 1) {
+    references[index] = null;
+  }
+  if (!physicalCars.length) return references;
+  if (canUseRaceOrderAsPhysicalOrder(sim, physicalCars)) {
+    if (sim?.runtimeBenchmarkStats) {
+      sim.runtimeBenchmarkStats.drsReferenceOrderedFastPathCalls = (sim.runtimeBenchmarkStats.drsReferenceOrderedFastPathCalls ?? 0) + 1;
+    }
+  } else {
+    sortPhysicalCarsInTrackOrder(sim, physicalCars);
+  }
+
+  const trackLength = sim.track.length;
+  let wrappedEligibleCar = null;
+  for (let index = physicalCars.length - 1; index >= 0; index -= 1) {
+    const car = physicalCars[index];
+    if (!car.finished && !sim.isCarInActivePitStop(car)) {
+      wrappedEligibleCar = car;
+      break;
+    }
+  }
+
+  let previousEligibleCar = wrappedEligibleCar;
+  for (let index = 0; index < physicalCars.length; index += 1) {
+    const car = physicalCars[index];
+    const candidate = previousEligibleCar === car ? null : previousEligibleCar;
+    if (candidate) {
+      const delta = distanceForward(
+        car.progress ?? car.raceDistance ?? 0,
+        candidate.progress ?? candidate.raceDistance ?? 0,
+        trackLength,
+      );
+      references[car.index] = delta > 0 && delta <= trackLength / 2 ? candidate : null;
+    } else {
+      references[car.index] = null;
+    }
+    if (!car.finished && !sim.isCarInActivePitStop(car)) previousEligibleCar = car;
+  }
+  scratch.references = references;
+  if (sim?.runtimeBenchmarkStats) {
+    sim.runtimeBenchmarkStats.drsReferenceScratchBuilds = (sim.runtimeBenchmarkStats.drsReferenceScratchBuilds ?? 0) + 1;
+  }
+  return references;
+}
+
+export function orderedCarsForSimulation(sim) {
+  const participants = partitionRaceOrderParticipants(sim.cars);
+  const raceCars = participants.live;
+  const dnfCars = participants.dnf;
 
   if (sim.raceControl.finished && sim.raceControl.classification?.length) {
+    const byId = new Map(sim.cars.map((car) => [car.id, car]));
     const classified = sim.raceControl.classification.map((entry) => byId.get(entry.id)).filter(Boolean);
     const classifiedIds = new Set(classified.map((car) => car.id));
     return [
       ...classified,
-      ...sortLive(raceCars.filter((car) => !classifiedIds.has(car.id))),
+      ...sortLiveRaceOrderInPlace(raceCars.filter((car) => !classifiedIds.has(car.id))),
       ...dnfCars.filter((car) => !classifiedIds.has(car.id)),
     ];
   }
 
   if (sim.raceControl.finishOrder?.length) {
+    const byId = new Map(sim.cars.map((car) => [car.id, car]));
     const finished = sim.raceControl.finishOrder.map((id) => byId.get(id)).filter(Boolean);
     const finishedIds = new Set(finished.map((car) => car.id));
-    const missedFinished = sim.cars
-      .filter((car) => canAppearInRaceOrder(car) && !isRaceDnf(car) && car.finished && !finishedIds.has(car.id))
+    const missedFinished = raceCars
+      .filter((car) => car.finished && !finishedIds.has(car.id))
       .sort((a, b) => {
         const delta = (a.finishRank ?? Infinity) - (b.finishRank ?? Infinity);
         return delta === 0 ? a.index - b.index : delta;
       });
-    const running = sortLive(raceCars.filter((car) => !finishedIds.has(car.id) && !car.finished && !isRaceDnf(car)));
+    const running = sortLiveRaceOrderInPlace(raceCars.filter((car) => !finishedIds.has(car.id) && !car.finished));
     return [...finished, ...missedFinished, ...running, ...dnfCars.filter((car) => !finishedIds.has(car.id))];
   }
 
   if (sim.safetyCar.deployed && sim.raceControl.frozenOrder?.length) {
+    const byId = new Map(sim.cars.map((car) => [car.id, car]));
     const frozen = sim.raceControl.frozenOrder.map((id) => byId.get(id)).filter(Boolean);
     const activeFrozen = frozen.filter((car) => !isRaceDnf(car));
     const activeFrozenIds = new Set(activeFrozen.map((car) => car.id));
@@ -49,9 +198,11 @@ export function orderedCarsForSimulation(sim) {
     ];
   }
 
-  return [...sortLive(raceCars.filter((car) => !isRaceDnf(car))), ...dnfCars];
+  sortLiveRaceOrderInPlace(raceCars);
+  return appendCars(raceCars, dnfCars);
 }
 
+
 export function raceOrderCarsForSimulation(sim) {
   return sim.cars.filter((car) => affectsRaceOrder(car) && !isRaceDnf(car));
 }
@@ -68,14 +219,36 @@ export function driverRaceContextForSimulation(sim, orderedCars = orderedCarsFor
   };
 }
 
-export function computeAggressionForSimulation(sim, car, orderIndex = Math.max(0, (car.rank ?? 1) - 1)) {
+export function buildDrsReferenceByCarId(sim, orderedCars = orderedCarsForSimulation(sim)) {
+  const referencesByIndex = buildDrsReferenceArrayForSimulation(sim, orderedCars);
+  const references = new Map();
+  for (let index = 0; index < orderedCars.length; index += 1) {
+    const car = orderedCars[index];
+    if (!affectsRaceOrder(car) || isRaceDnf(car)) continue;
+    references.set(car.id, referencesByIndex[car.index] ?? null);
+  }
+  return references;
+}
+
+export function assignDrsReferenceCarsForSimulation(sim, orderedCars = orderedCarsForSimulation(sim)) {
+  return buildDrsReferenceArrayForSimulation(sim, orderedCars);
+}
+
+export function computeAggressionForSimulation(
+  sim,
+  car,
+  orderIndex = Math.max(0, (car.rank ?? 1) - 1),
+  fieldDepth = null,
+) {
   const personality = car.personality ?? { baseAggression: 0.5, riskTolerance: 0.5, patience: 0.5 };
   if (sim.safetyCar.deployed || car.canAttack === false) {
     return clamp(personality.baseAggression * 0.62, 0.08, 0.62);
   }
 
-  const fieldDepth = Math.max(1, raceOrderCarsForSimulation(sim).length - 1);
-  const positionPressure = clamp(orderIndex / fieldDepth, 0, 1);
+  const resolvedFieldDepth = Number.isFinite(fieldDepth)
+    ? Math.max(1, fieldDepth)
+    : Math.max(1, raceOrderCarsForSimulation(sim).length - 1);
+  const positionPressure = clamp(orderIndex / resolvedFieldDepth, 0, 1);
   const gapPressure = Number.isFinite(car.gapAhead) ? clamp((230 - car.gapAhead) / 230, 0, 1) : 0;
   const tireConfidence = clamp(((car.tireEnergy ?? 100) - 42) / 58, 0, 1);
   const patienceDamping = (1 - gapPressure) * personality.patience * 0.08;
@@ -92,22 +265,6 @@ export function computeAggressionForSimulation(sim, car, orderIndex = Math.max(0
 }
 
 export function getDrsReferenceCarForSimulation(sim, car) {
-  let closest = null;
-  sim.cars.forEach((candidate) => {
-    if (
-      candidate === car ||
-      !affectsRaceOrder(candidate) ||
-      isRaceDnf(candidate) ||
-      candidate.finished ||
-      sim.isCarInActivePitStop(candidate)
-    ) return;
-    const delta = distanceForward(
-      car.progress ?? car.raceDistance ?? 0,
-      candidate.progress ?? candidate.raceDistance ?? 0,
-      sim.track.length,
-    );
-    if (delta <= 0 || delta > sim.track.length / 2) return;
-    if (!closest || delta < closest.delta) closest = { car: candidate, delta };
-  });
-  return closest?.car ?? null;
+  if (!car) return null;
+  return buildDrsReferenceArrayForSimulation(sim)[car.index] ?? null;
 }