@inventure71/paddockjs 3.0.0 → 4.1.0

package/src/placeholder/index.js

@@ -0,0 +1,61 @@
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function normalizeVariant(value) {
+  return value === 'custom' ? 'custom' : 'lights';
+}
+
+function renderAttributes(attributes = {}) {
+  if (!attributes || typeof attributes !== 'object') return '';
+  return Object.entries(attributes)
+    .filter(([name, value]) => (
+      value != null &&
+      value !== false &&
+      /^[a-zA-Z_][\w:.-]*$/.test(name) &&
+      !/^on/i.test(name)
+    ))
+    .map(([name, value]) => (value === true
+      ? ` ${escapeHtml(name)}`
+      : ` ${escapeHtml(name)}="${escapeHtml(value)}"`))
+    .join('');
+}
+
+export function createPaddockLoadingPlaceholder({
+  label = 'Loading simulator',
+  detail = '',
+  className = '',
+  variant = 'lights',
+  attributes,
+} = {}) {
+  const normalizedVariant = normalizeVariant(variant);
+  const extraClassName = className ? ` ${escapeHtml(className)}` : '';
+  const detailMarkup = detail
+    ? `<span class="paddock-placeholder__detail">${escapeHtml(detail)}</span>`
+    : '';
+  const lightsMarkup = normalizedVariant === 'lights'
+    ? `
+      <div class="paddock-placeholder__lights" aria-hidden="true">
+        <span></span>
+        <span></span>
+        <span></span>
+        <span></span>
+        <span></span>
+      </div>`
+    : '';
+
+  return `
+    <div class="paddock-placeholder${extraClassName}" data-paddock-placeholder data-paddock-placeholder-variant="${normalizedVariant}" role="status" aria-live="polite" aria-busy="true"${renderAttributes(attributes)}>
+      <div class="paddock-placeholder__content">
+        ${lightsMarkup}
+        <span class="paddock-placeholder__label">${escapeHtml(label)}</span>
+        ${detailMarkup}
+      </div>
+    </div>
+  `;
+}

package/src/placeholder.css

@@ -0,0 +1,72 @@
+.paddock-placeholder {
+  --paddock-placeholder-background: #000;
+  --paddock-placeholder-color: rgba(244, 241, 234, 0.78);
+  --paddock-placeholder-light: #ff1f18;
+  --paddock-placeholder-light-dim: #8f0804;
+  --paddock-placeholder-min-height: 420px;
+  position: relative;
+  display: grid;
+  min-height: var(--paddock-placeholder-min-height);
+  place-items: center;
+  overflow: hidden;
+  color: var(--paddock-placeholder-color);
+  background: var(--paddock-placeholder-background);
+}
+
+.paddock-placeholder__content {
+  display: grid;
+  justify-items: center;
+  gap: 0.8rem;
+  padding: 1.25rem;
+  text-align: center;
+}
+
+.paddock-placeholder__label {
+  font: 800 0.72rem/1.2 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+}
+
+.paddock-placeholder__detail {
+  max-width: 32rem;
+  font: 500 0.82rem/1.4 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  opacity: 0.72;
+}
+
+.paddock-placeholder__lights {
+  display: grid;
+  grid-template-columns: repeat(5, 0.78rem);
+  gap: 0.42rem;
+  padding: 0.32rem 0.46rem;
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.08);
+}
+
+.paddock-placeholder__lights span {
+  width: 0.78rem;
+  height: 0.78rem;
+  border-radius: 50%;
+  background: var(--paddock-placeholder-light-dim);
+  box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.08);
+  animation: paddock-placeholder-lights 1200ms cubic-bezier(0.45, 0, 0.2, 1) infinite;
+}
+
+.paddock-placeholder__lights span:nth-child(2) { animation-delay: 120ms; }
+.paddock-placeholder__lights span:nth-child(3) { animation-delay: 240ms; }
+.paddock-placeholder__lights span:nth-child(4) { animation-delay: 360ms; }
+.paddock-placeholder__lights span:nth-child(5) { animation-delay: 480ms; }
+
+.paddock-placeholder[data-paddock-placeholder-variant="custom"] .paddock-placeholder__content {
+  min-height: inherit;
+}
+
+@keyframes paddock-placeholder-lights {
+  0%, 100% {
+    background: var(--paddock-placeholder-light-dim);
+    box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.08);
+  }
+  45%, 70% {
+    background: var(--paddock-placeholder-light);
+    box-shadow: 0 0 14px rgba(225, 6, 0, 0.56);
+  }
+}

package/src/simulation/collisionGeometry.js

@@ -1,35 +1,40 @@
 import {
-  createVehicleGeometry,
-  createVehicleGeometryState,
   getVehicleGeometryState,
-  interpolateVehiclePose,
+  vehicleAxes,
 } from './vehicle/vehicleGeometry.js';
+import { normalizeAngle } from './simMath.js';
 
 const DEFAULT_SWEEP_STEPS = 16;
 const BROADPHASE_PADDING = 0.001;
 const DEFAULT_DISTANCE_WINDOW = 150;
+const COLLISION_PAIR_FIRST_INDEX = Symbol('collisionPairFirstIndex');
+const COLLISION_PAIR_SECOND_INDEX = Symbol('collisionPairSecondIndex');
 
 function dot(a, b) {
   return a.x * b.x + a.y * b.y;
 }
 
-function projectShape(shape, axis) {
+function projectShapeInto(target, shape, axis) {
   let min = Infinity;
   let max = -Infinity;
   for (let index = 0; index < shape.corners.length; index += 1) {
-    const value = dot(shape.corners[index], axis);
+    const corner = shape.corners[index];
+    const value = corner.x * axis.x + corner.y * axis.y;
     if (value < min) min = value;
     if (value > max) max = value;
   }
-  return {
-    min,
-    max,
-  };
+  target.min = min;
+  target.max = max;
+  return target;
 }
 
-function overlapOnAxis(first, second, axis) {
-  const a = projectShape(first, axis);
-  const b = projectShape(second, axis);
+function overlapOnAxis(first, second, axis, projectionScratch = null) {
+  const projections = projectionScratch ?? {
+    first: { min: Infinity, max: -Infinity },
+    second: { min: Infinity, max: -Infinity },
+  };
+  const a = projectShapeInto(projections.first, first, axis);
+  const b = projectShapeInto(projections.second, second, axis);
   return Math.min(a.max, b.max) - Math.max(a.min, b.min);
 }
 
@@ -37,58 +42,44 @@ function shapeContactType(firstShape, secondShape) {
   return `${firstShape.type}-${secondShape.type}`;
 }
 
-export function detectShapeCollision(firstShape, secondShape) {
-  const axes = [
-    firstShape.forward,
-    firstShape.right,
-    secondShape.forward,
-    secondShape.right,
-  ];
-  let depth = Infinity;
-  let axis = null;
-
-  for (const candidate of axes) {
-    const overlap = overlapOnAxis(firstShape, secondShape, candidate);
-    if (overlap <= 0) return null;
-    if (overlap < depth) {
-      depth = overlap;
-      axis = candidate;
-    }
-  }
+export function detectShapeCollision(firstShape, secondShape, scratch = null) {
+  const projectionScratch = ensureProjectionScratch(scratch);
+  let axis = firstShape.forward;
+  let depth = overlapOnAxis(firstShape, secondShape, axis, projectionScratch);
+  if (depth <= 0) return null;
 
-  const direction = {
-    x: secondShape.center.x - firstShape.center.x,
-    y: secondShape.center.y - firstShape.center.y,
-  };
-  if (dot(direction, axis) < 0) {
-    axis = { x: -axis.x, y: -axis.y };
+  let overlap = overlapOnAxis(firstShape, secondShape, firstShape.right, projectionScratch);
+  if (overlap <= 0) return null;
+  if (overlap < depth) {
+    depth = overlap;
+    axis = firstShape.right;
   }
 
-  return {
-    axis,
-    depth,
-    firstShapeId: firstShape.id,
-    secondShapeId: secondShape.id,
-    contactType: shapeContactType(firstShape, secondShape),
-  };
-}
+  overlap = overlapOnAxis(firstShape, secondShape, secondShape.forward, projectionScratch);
+  if (overlap <= 0) return null;
+  if (overlap < depth) {
+    depth = overlap;
+    axis = secondShape.forward;
+  }
 
-function collisionShapes(geometry) {
-  return [geometry.body];
-}
+  overlap = overlapOnAxis(firstShape, secondShape, secondShape.right, projectionScratch);
+  if (overlap <= 0) return null;
+  if (overlap < depth) {
+    depth = overlap;
+    axis = secondShape.right;
+  }
 
-function detectGeometryCollision(firstGeometry, secondGeometry) {
-  let best = null;
-  collisionShapes(firstGeometry).forEach((firstShape) => {
-    collisionShapes(secondGeometry).forEach((secondShape) => {
-      const collision = detectShapeCollision(firstShape, secondShape);
-      if (!collision) return;
-      if (!best || collision.depth < best.depth - 1e-6) {
-        best = collision;
-      }
-    });
-  });
-  return best;
+  const directionX = secondShape.center.x - firstShape.center.x;
+  const directionY = secondShape.center.y - firstShape.center.y;
+  const directionSign = directionX * axis.x + directionY * axis.y < 0 ? -1 : 1;
+  return writeShapeCollisionResult(
+    scratch ? (scratch.shapeCollisionResult ??= { axis: {} }) : { axis: {} },
+    firstShape,
+    secondShape,
+    axis.x * directionSign,
+    axis.y * directionSign,
+    depth,
+  );
 }
 
 function aabbsOverlap(first, second) {
@@ -104,34 +95,60 @@ function createSweptAabb(car) {
   return getVehicleGeometryState(car).sweptBodyAabb;
 }
 
-function withCollisionMetadata(collision, timeOfImpact, swept) {
-  return {
-    ...collision,
-    timeOfImpact,
-    swept: Boolean(swept),
-  };
+function writeShapeCollisionResult(target, firstShape, secondShape, axisX, axisY, depth) {
+  target.axis ??= {};
+  target.axis.x = axisX;
+  target.axis.y = axisY;
+  target.depth = depth;
+  target.firstShapeId = firstShape.id;
+  target.secondShapeId = secondShape.id;
+  target.contactType = shapeContactType(firstShape, secondShape);
+  return target;
+}
+
+function withCollisionMetadata(collision, timeOfImpact, swept, scratch) {
+  const target = scratch ? (scratch.vehicleCollisionResult ??= { axis: {} }) : { axis: {} };
+  target.axis ??= {};
+  target.axis.x = collision.axis.x;
+  target.axis.y = collision.axis.y;
+  target.depth = collision.depth;
+  target.firstShapeId = collision.firstShapeId;
+  target.secondShapeId = collision.secondShapeId;
+  target.contactType = collision.contactType;
+  target.timeOfImpact = timeOfImpact;
+  target.swept = Boolean(swept);
+  return target;
 }
 
-export function detectVehicleCollision(first, second, { sweepSteps = DEFAULT_SWEEP_STEPS } = {}) {
+function detectVehicleCollisionWithScratch(first, second, sweepSteps, scratch) {
   const firstState = getVehicleGeometryState(first);
   const secondState = getVehicleGeometryState(second);
-  const current = detectGeometryCollision(firstState.current, secondState.current);
-  if (current) return withCollisionMetadata(current, 1, false);
+  const current = detectShapeCollision(firstState.current.body, secondState.current.body, scratch);
+  if (current) return withCollisionMetadata(current, 1, false, scratch);
 
   if (!aabbsOverlap(createSweptAabb(first), createSweptAabb(second))) return null;
 
+  const sweepShapes = ensureSweepShapes(scratch, firstState.current.body, secondState.current.body);
   for (let step = 1; step < sweepSteps; step += 1) {
     const amount = step / sweepSteps;
-    const collision = detectGeometryCollision(
-      createVehicleGeometry(interpolateVehiclePose(first, amount)),
-      createVehicleGeometry(interpolateVehiclePose(second, amount)),
+    const collision = detectShapeCollision(
+      writeInterpolatedBodyShape(sweepShapes.first, firstState, amount),
+      writeInterpolatedBodyShape(sweepShapes.second, secondState, amount),
+      scratch,
     );
-    if (collision) return withCollisionMetadata(collision, amount, true);
+    if (collision) return withCollisionMetadata(collision, amount, true, scratch);
   }
 
   return null;
 }
 
+export function detectVehicleCollision(first, second, {
+  sweepSteps = DEFAULT_SWEEP_STEPS,
+  scratch = null,
+} = {}) {
+  return detectVehicleCollisionWithScratch(first, second, sweepSteps, scratch);
+}
+
 function normalizedDistance(car, trackLength) {
   if (!Number.isFinite(trackLength) || trackLength <= 0) return car.raceDistance;
   const distance = Number.isFinite(car.progress) ? car.progress : car.raceDistance;
@@ -147,34 +164,51 @@ function wrappedDistanceDelta(first, second, trackLength) {
 export function buildCollisionCandidatePairs(cars, {
   trackLength = null,
   distanceWindow = DEFAULT_DISTANCE_WINDOW,
+  scratch = null,
 } = {}) {
-  const candidates = [];
-  const candidateKeys = new Set();
-  const withDistance = [];
-  const withoutDistance = [];
-  const carOrder = new Map(cars.map((car, index) => [car, index]));
-
-  const addCandidate = (first, second) => {
-    const firstIndex = carOrder.get(first);
-    const secondIndex = carOrder.get(second);
-    const key = firstIndex < secondIndex ? `${firstIndex}:${secondIndex}` : `${secondIndex}:${firstIndex}`;
-    if (candidateKeys.has(key)) return;
-    candidateKeys.add(key);
-    candidates.push([first, second]);
+  const candidates = scratchArray(scratch, 'candidates');
+  const pairMarker = candidatePairMarker(scratch, cars.length);
+  const withDistance = scratchArray(scratch, 'withDistance');
+  const pairPool = scratchArray(scratch, 'pairPool', { clear: false });
+  const distanceEntryPool = scratchArray(scratch, 'distanceEntryPool', { clear: false });
+  const missingDistanceFlags = missingDistanceFlagScratch(scratch, cars.length);
+  const missingDistanceIndexes = scratchArray(scratch, 'missingDistanceIndexes');
+
+  const addCandidateByIndex = (firstIndex, secondIndex) => {
+    if (pairMarker.has(firstIndex, secondIndex)) return;
+    pairMarker.add(firstIndex, secondIndex);
+    const pair = pairPool[candidates.length] ?? [];
+    pair[0] = cars[firstIndex];
+    pair[1] = cars[secondIndex];
+    pair[COLLISION_PAIR_FIRST_INDEX] = firstIndex;
+    pair[COLLISION_PAIR_SECOND_INDEX] = secondIndex;
+    pairPool[candidates.length] = pair;
+    candidates.push(pair);
   };
 
-  cars.forEach((car) => {
+  for (let index = 0; index < cars.length; index += 1) {
+    const car = cars[index];
+    missingDistanceFlags[index] = 0;
     const distance = normalizedDistance(car, trackLength);
-    if (Number.isFinite(distance)) withDistance.push({ car, distance });
-    else withoutDistance.push(car);
-  });
+    if (Number.isFinite(distance)) {
+      const entry = distanceEntryPool[withDistance.length] ?? {};
+      entry.car = car;
+      entry.carIndex = index;
+      entry.distance = distance;
+      distanceEntryPool[withDistance.length] = entry;
+      withDistance.push(entry);
+    } else {
+      missingDistanceFlags[index] = 1;
+      missingDistanceIndexes.push(index);
+    }
+  }
 
   withDistance.sort((first, second) => first.distance - second.distance);
   for (let i = 0; i < withDistance.length; i += 1) {
     for (let j = i + 1; j < withDistance.length; j += 1) {
       const delta = withDistance[j].distance - withDistance[i].distance;
       if (delta > distanceWindow) break;
-      addCandidate(withDistance[i].car, withDistance[j].car);
+      addCandidateByIndex(withDistance[i].carIndex, withDistance[j].carIndex);
     }
   }
 
@@ -184,17 +218,18 @@ export function buildCollisionCandidatePairs(cars, {
       const firstWrappedIndex = lowerBoundDistance(withDistance, threshold);
       for (let j = Math.max(firstWrappedIndex, i + 1); j < withDistance.length; j += 1) {
         if (wrappedDistanceDelta(withDistance[i].distance, withDistance[j].distance, trackLength) <= distanceWindow) {
-          addCandidate(withDistance[i].car, withDistance[j].car);
+          addCandidateByIndex(withDistance[i].carIndex, withDistance[j].carIndex);
         }
       }
     }
   }
 
-  const missingDistance = new Set(withoutDistance);
-  for (let i = 0; i < cars.length; i += 1) {
-    for (let j = i + 1; j < cars.length; j += 1) {
-      if (missingDistance.has(cars[i]) || missingDistance.has(cars[j])) {
-        addCandidate(cars[i], cars[j]);
+  if (missingDistanceIndexes.length > 0) {
+    for (let i = 0; i < cars.length; i += 1) {
+      for (let j = i + 1; j < cars.length; j += 1) {
+        if (missingDistanceFlags[i] || missingDistanceFlags[j]) {
+          addCandidateByIndex(i, j);
+        }
       }
     }
   }
@@ -202,6 +237,135 @@ export function buildCollisionCandidatePairs(cars, {
   return candidates;
 }
 
+export function collisionCandidatePairFirstIndex(pair) {
+  return Number.isInteger(pair?.[COLLISION_PAIR_FIRST_INDEX])
+    ? pair[COLLISION_PAIR_FIRST_INDEX]
+    : -1;
+}
+
+export function collisionCandidatePairSecondIndex(pair) {
+  return Number.isInteger(pair?.[COLLISION_PAIR_SECOND_INDEX])
+    ? pair[COLLISION_PAIR_SECOND_INDEX]
+    : -1;
+}
+
+function scratchArray(scratch, key, { clear = true } = {}) {
+  const array = scratch ? (scratch[key] ??= []) : [];
+  if (clear) array.length = 0;
+  return array;
+}
+
+function candidatePairMarker(scratch, carCount) {
+  if (!scratch) return setBackedCandidatePairMarker(carCount);
+  const requiredLength = Math.max(1, carCount * carCount);
+  if (!(scratch.candidatePairMarks instanceof Uint32Array) || scratch.candidatePairMarks.length < requiredLength) {
+    scratch.candidatePairMarks = new Uint32Array(requiredLength);
+  }
+  scratch.candidatePairEpoch = ((scratch.candidatePairEpoch ?? 0) + 1) >>> 0;
+  if (scratch.candidatePairEpoch === 0) {
+    scratch.candidatePairMarks.fill(0);
+    scratch.candidatePairEpoch = 1;
+  }
+  const marks = scratch.candidatePairMarks;
+  const epoch = scratch.candidatePairEpoch;
+  return {
+    has(firstIndex, secondIndex) {
+      return marks[candidatePairMarkIndex(firstIndex, secondIndex, carCount)] === epoch;
+    },
+    add(firstIndex, secondIndex) {
+      marks[candidatePairMarkIndex(firstIndex, secondIndex, carCount)] = epoch;
+    },
+  };
+}
+
+function missingDistanceFlagScratch(scratch, carCount) {
+  if (!scratch) return new Uint8Array(Math.max(1, carCount));
+  if (!(scratch.missingDistanceFlags instanceof Uint8Array) || scratch.missingDistanceFlags.length < carCount) {
+    scratch.missingDistanceFlags = new Uint8Array(Math.max(1, carCount));
+  }
+  return scratch.missingDistanceFlags;
+}
+
+function setBackedCandidatePairMarker(carCount) {
+  const marks = new Uint32Array(Math.max(1, carCount * carCount));
+  return {
+    has(firstIndex, secondIndex) {
+      return marks[candidatePairMarkIndex(firstIndex, secondIndex, carCount)] === 1;
+    },
+    add(firstIndex, secondIndex) {
+      marks[candidatePairMarkIndex(firstIndex, secondIndex, carCount)] = 1;
+    },
+  };
+}
+
+function candidatePairMarkIndex(firstIndex, secondIndex, carCount) {
+  const low = firstIndex < secondIndex ? firstIndex : secondIndex;
+  const high = firstIndex < secondIndex ? secondIndex : firstIndex;
+  return low * carCount + high;
+}
+
+function ensureSweepShapes(scratch, firstBody, secondBody) {
+  const sweepShapes = scratch ? (scratch.sweepShapes ??= {}) : {};
+  sweepShapes.first ??= createSweepShape(firstBody);
+  sweepShapes.second ??= createSweepShape(secondBody);
+  return sweepShapes;
+}
+
+function ensureProjectionScratch(scratch) {
+  const projectionScratch = scratch ? (scratch.projectionScratch ??= {}) : {};
+  projectionScratch.first ??= { min: Infinity, max: -Infinity };
+  projectionScratch.second ??= { min: Infinity, max: -Infinity };
+  return projectionScratch;
+}
+
+function createSweepShape(body) {
+  return {
+    id: body.id,
+    type: body.type,
+    center: { x: body.center.x, y: body.center.y },
+    heading: body.heading,
+    length: body.length,
+    width: body.width,
+    halfLength: body.halfLength,
+    halfWidth: body.halfWidth,
+    forward: { x: body.forward.x, y: body.forward.y },
+    right: { x: body.right.x, y: body.right.y },
+    corners: Array.from({ length: 4 }, () => ({ x: 0, y: 0 })),
+  };
+}
+
+function writeInterpolatedBodyShape(target, geometryState, amount) {
+  const pose = geometryState.pose;
+  const headingDelta = normalizeAngle(pose.heading - pose.previousHeading);
+  const x = pose.previousX + (pose.x - pose.previousX) * amount;
+  const y = pose.previousY + (pose.y - pose.previousY) * amount;
+  const heading = normalizeAngle(pose.previousHeading + headingDelta * amount);
+  const axes = vehicleAxes(heading);
+  const halfLength = target.halfLength;
+  const halfWidth = target.halfWidth;
+
+  target.center.x = x;
+  target.center.y = y;
+  target.heading = heading;
+  target.forward.x = axes.forward.x;
+  target.forward.y = axes.forward.y;
+  target.right.x = axes.right.x;
+  target.right.y = axes.right.y;
+
+  writeOffsetCorner(target.corners[0], target.center, target.forward, target.right, halfLength, halfWidth);
+  writeOffsetCorner(target.corners[1], target.center, target.forward, target.right, halfLength, -halfWidth);
+  writeOffsetCorner(target.corners[2], target.center, target.forward, target.right, -halfLength, -halfWidth);
+  writeOffsetCorner(target.corners[3], target.center, target.forward, target.right, -halfLength, halfWidth);
+
+  return target;
+}
+
+function writeOffsetCorner(target, center, forward, right, longitudinal, lateral) {
+  target.x = center.x + forward.x * longitudinal + right.x * lateral;
+  target.y = center.y + forward.y * longitudinal + right.y * lateral;
+  return target;
+}
+
 function lowerBoundDistance(entries, target) {
   let low = 0;
   let high = entries.length;

package/src/simulation/pit/pitFlow.js

@@ -78,9 +78,14 @@ export function canStartPitStop(sim, car) {
   const stop = car.pitStop;
   const pitStops = sim.rules.modules?.pitStops;
   if (!stop || !pitStops?.enabled) return false;
-  const active = sim.cars.filter((candidate) => candidate !== car && isCarInActivePitStop(sim, candidate));
   const maxConcurrentPitLaneCars = Math.max(1, Math.floor(pitStops.maxConcurrentPitLaneCars ?? 3));
-  if (active.length >= maxConcurrentPitLaneCars) return false;
+  let activeCount = 0;
+  for (let index = 0; index < sim.cars.length; index += 1) {
+    const candidate = sim.cars[index];
+    if (candidate === car || !isCarInActivePitStop(sim, candidate)) continue;
+    activeCount += 1;
+    if (activeCount >= maxConcurrentPitLaneCars) return false;
+  }
 
   if (!pitStops.doubleStacking && stop.teamId) {
     const box = getPitStopBox(sim, stop);
@@ -89,10 +94,13 @@ export function canStartPitStop(sim, car) {
 
   const minimumGap = Math.max(0, pitStops.minimumPitLaneGap ?? 0);
   const candidateDistance = car.raceDistance ?? 0;
-  return active.every((candidate) => {
+  for (let index = 0; index < sim.cars.length; index += 1) {
+    const candidate = sim.cars[index];
+    if (candidate === car || !isCarInActivePitStop(sim, candidate)) continue;
     const gap = (candidate.raceDistance ?? 0) - candidateDistance;
-    return gap < 0 || gap >= minimumGap;
-  });
+    if (gap >= 0 && gap < minimumGap) return false;
+  }
+  return true;
 }
 
 export function shouldStartPitStop(sim, car) {
@@ -152,13 +160,17 @@ export function startPitStop(sim, car) {
     0,
     (hasServiceQueue ? queueDistanceAlongLane : stopDistanceAlongLane) - PIT_BOX_APPROACH_DISTANCE,
   );
-  const route = createRoute([
-    ...createPitApproachPoints(sim.track, car, pitLane, stop.entryRaceDistance),
-    ...(pitLane.entry.roadCenterline ?? []).map((point) => routePoint(point)),
+  const routePoints = createPitApproachPoints(sim.track, car, pitLane, stop.entryRaceDistance);
+  const entryCenterline = pitLane.entry.roadCenterline ?? [];
+  for (let index = 0; index < entryCenterline.length; index += 1) {
+    routePoints.push(routePoint(entryCenterline[index]));
+  }
+  routePoints.push(
     routePoint(pitMainLanePointAt(pitLane, 0, driveLaneOffset), pitLane.mainLane.heading, { limiterActive: true }),
     routePoint(pitMainLanePointAt(pitLane, boxApproachDistance, driveLaneOffset), pitLane.mainLane.heading, { limiterActive: true }),
     routePoint(serviceTarget, pitLane.mainLane.heading, { limiterActive: true }),
-  ]);
+  );
+  const route = createRoute(routePoints);
   stop.status = 'entering';
   stop.phase = 'entry';
   stop.queueingForService = shouldStageForService;

package/src/simulation/pit/pitQueue.js

@@ -34,11 +34,13 @@ export function beginPitQueue(sim, car, box) {
 export function releasePitQueue(sim, car, box, { fromCurrent = false } = {}) {
   const stop = car.pitStop;
   if (!stop || !box?.center) return false;
-  const route = createRoute([
-    ...(fromCurrent ? [routePoint(car, car.heading, { limiterActive: true })] : []),
+  const routePoints = [];
+  if (fromCurrent) routePoints.push(routePoint(car, car.heading, { limiterActive: true }));
+  routePoints.push(
     routePoint(box.queuePoint, sim.track.pitLane.mainLane.heading, { limiterActive: true }),
     routePoint(box.center, sim.track.pitLane.mainLane.heading, { limiterActive: true }),
-  ]);
+  );
+  const route = createRoute(routePoints);
   stop.status = 'entering';
   stop.phase = 'queue-release';
   stop.queueingForService = false;