@inventure71/paddockjs 2.0.1 → 4.0.0

package/src/simulation/timing/timingHistory.js

@@ -1,39 +1,218 @@
 import { TIMING_HISTORY_MAX_SAMPLES, TIMING_HISTORY_WINDOW_SECONDS } from './timingConstants.js';
 
+const TIMING_HISTORY_START_INDEX = '_startIndex';
+const TIMING_HISTORY_COUNT = '_count';
+const TIMING_HISTORY_INTERPOLATION_OFFSET = '_interpolationOffset';
+const TIMING_HISTORY_INTERPOLATION_LOWER_DISTANCE = '_interpolationLowerDistance';
+const TIMING_HISTORY_INTERPOLATION_UPPER_DISTANCE = '_interpolationUpperDistance';
+const TIMING_HISTORY_INTERPOLATION_LOWER_TIME = '_interpolationLowerTime';
+const TIMING_HISTORY_INTERPOLATION_UPPER_TIME = '_interpolationUpperTime';
+const TIMING_HISTORY_INTERPOLATION_STATS = '_interpolationStats';
+
+function isStructuredTimingHistory(history) {
+  return Boolean(
+    history &&
+    history.times instanceof Float64Array &&
+    history.distances instanceof Float64Array,
+  );
+}
+
+function createStructuredTimingHistory(currentTime, raceDistance) {
+  const history = {
+    times: new Float64Array(TIMING_HISTORY_MAX_SAMPLES),
+    distances: new Float64Array(TIMING_HISTORY_MAX_SAMPLES),
+  };
+  history.times[0] = currentTime;
+  history.distances[0] = raceDistance;
+  history[TIMING_HISTORY_START_INDEX] = 0;
+  history[TIMING_HISTORY_COUNT] = 1;
+  return history;
+}
+
+function getTimingHistoryStartIndex(history) {
+  if (isStructuredTimingHistory(history)) {
+    const value = history[TIMING_HISTORY_START_INDEX];
+    return Number.isInteger(value) && value >= 0 ? value : 0;
+  }
+  const value = history?.[TIMING_HISTORY_START_INDEX];
+  return Number.isInteger(value) && value >= 0 ? value : 0;
+}
+
+function setTimingHistoryStartIndex(history, startIndex) {
+  if (isStructuredTimingHistory(history)) {
+    history[TIMING_HISTORY_START_INDEX] = startIndex;
+    return;
+  }
+  Object.defineProperty(history, TIMING_HISTORY_START_INDEX, {
+    value: startIndex,
+    writable: true,
+    configurable: true,
+    enumerable: false,
+  });
+}
+
+function clearTimingHistoryStartIndex(history) {
+  if (isStructuredTimingHistory(history)) {
+    history[TIMING_HISTORY_START_INDEX] = 0;
+    return;
+  }
+  delete history[TIMING_HISTORY_START_INDEX];
+}
+
+function activeTimingHistoryLength(history, startIndex = getTimingHistoryStartIndex(history)) {
+  if (isStructuredTimingHistory(history)) {
+    const count = history[TIMING_HISTORY_COUNT];
+    return Number.isInteger(count) && count >= 0 ? count : 0;
+  }
+  return Math.max(0, history.length - startIndex);
+}
+
+function compactTimingHistory(history, startIndex) {
+  if (isStructuredTimingHistory(history)) {
+    history[TIMING_HISTORY_START_INDEX] = startIndex;
+    return;
+  }
+  if (startIndex <= 0) {
+    clearTimingHistoryStartIndex(history);
+    return;
+  }
+  history.splice(0, startIndex);
+  clearTimingHistoryStartIndex(history);
+}
+
+function trimStructuredTimingHistory(history, currentTime) {
+  let startIndex = getTimingHistoryStartIndex(history);
+  let count = activeTimingHistoryLength(history, startIndex);
+  const cutoff = currentTime - TIMING_HISTORY_WINDOW_SECONDS;
+  while (
+    count > 2 &&
+    history.times[startIndex] < cutoff
+  ) {
+    startIndex = (startIndex + 1) % TIMING_HISTORY_MAX_SAMPLES;
+    count -= 1;
+  }
+  history[TIMING_HISTORY_START_INDEX] = startIndex;
+  history[TIMING_HISTORY_COUNT] = count;
+}
+
 export function trimTimingHistory(history, currentTime) {
+  if (isStructuredTimingHistory(history)) {
+    trimStructuredTimingHistory(history, currentTime);
+    return;
+  }
+  if (!Array.isArray(history)) return;
   const cutoff = currentTime - TIMING_HISTORY_WINDOW_SECONDS;
-  while (history.length > 2 && (history[0].time < cutoff || history.length > TIMING_HISTORY_MAX_SAMPLES)) {
-    history.shift();
+  let startIndex = getTimingHistoryStartIndex(history);
+  if (
+    startIndex === 0 &&
+    history.length <= TIMING_HISTORY_MAX_SAMPLES &&
+    history.length <= 2
+  ) return;
+  if (
+    startIndex === 0 &&
+    history.length <= TIMING_HISTORY_MAX_SAMPLES &&
+    history[0]?.time >= cutoff
+  ) return;
+  while (
+    activeTimingHistoryLength(history, startIndex) > 2 &&
+    (
+      history[startIndex]?.time < cutoff ||
+      activeTimingHistoryLength(history, startIndex) > TIMING_HISTORY_MAX_SAMPLES
+    )
+  ) {
+    startIndex += 1;
   }
+  if (startIndex > 0 && (startIndex >= 64 || startIndex * 2 >= history.length)) {
+    compactTimingHistory(history, startIndex);
+    return;
+  }
+  if (startIndex > 0) setTimingHistoryStartIndex(history, startIndex);
+  else clearTimingHistoryStartIndex(history);
 }
 
 export function resetTimingHistory(car, currentTime) {
-  car.timingHistory = [{ time: currentTime, raceDistance: car.raceDistance }];
+  car.timingHistory = createStructuredTimingHistory(currentTime, car.raceDistance);
 }
 
 export function recordTimingSample(car, currentTime) {
   if (!Number.isFinite(car.raceDistance)) return;
-  if (!Array.isArray(car.timingHistory)) {
+  if (!isStructuredTimingHistory(car.timingHistory)) {
     resetTimingHistory(car, currentTime);
-    return;
   }
-
-  const previous = car.timingHistory[car.timingHistory.length - 1];
+  const history = car.timingHistory;
+  const startIndex = getTimingHistoryStartIndex(history);
+  const count = activeTimingHistoryLength(history, startIndex);
+  const previousIndex = count > 0
+    ? (startIndex + count - 1) % TIMING_HISTORY_MAX_SAMPLES
+    : 0;
+  const previousTime = count > 0 ? history.times[previousIndex] : null;
+  const previousRaceDistance = count > 0 ? history.distances[previousIndex] : null;
   if (
-    previous &&
-    Math.abs(previous.time - currentTime) <= 1e-6 &&
-    Math.abs(previous.raceDistance - car.raceDistance) <= 1e-3
+    count > 0 &&
+    Math.abs(previousTime - currentTime) <= 1e-6 &&
+    Math.abs(previousRaceDistance - car.raceDistance) <= 1e-3
   ) {
     return;
   }
 
-  car.timingHistory.push({ time: currentTime, raceDistance: car.raceDistance });
-  trimTimingHistory(car.timingHistory, currentTime);
+  let nextStartIndex = startIndex;
+  let nextCount = count;
+  let writeIndex = 0;
+  if (nextCount < TIMING_HISTORY_MAX_SAMPLES) {
+    writeIndex = (nextStartIndex + nextCount) % TIMING_HISTORY_MAX_SAMPLES;
+    nextCount += 1;
+  } else {
+    writeIndex = nextStartIndex;
+    nextStartIndex = (nextStartIndex + 1) % TIMING_HISTORY_MAX_SAMPLES;
+  }
+  history.times[writeIndex] = currentTime;
+  history.distances[writeIndex] = car.raceDistance;
+  history[TIMING_HISTORY_START_INDEX] = nextStartIndex;
+  history[TIMING_HISTORY_COUNT] = nextCount;
+  trimStructuredTimingHistory(history, currentTime);
 }
 
 export function interpolateTimeAtDistance(history, targetDistance) {
-  if (!Array.isArray(history) || history.length < 2) return null;
-  for (let index = history.length - 1; index > 0; index -= 1) {
+  if (isStructuredTimingHistory(history)) {
+    const directCachedTime = interpolateDirectCachedSegment(history, targetDistance);
+    if (Number.isFinite(directCachedTime)) return directCachedTime;
+    const startIndex = getTimingHistoryStartIndex(history);
+    const count = activeTimingHistoryLength(history, startIndex);
+    if (count < 2) return null;
+    const cachedOffset = history[TIMING_HISTORY_INTERPOLATION_OFFSET];
+    if (Number.isInteger(cachedOffset) && cachedOffset >= 0 && cachedOffset < count - 1) {
+      const cachedTime = interpolateStructuredTimingHistoryAtOffset(history, startIndex, count, targetDistance, cachedOffset);
+      if (Number.isFinite(cachedTime)) return cachedTime;
+      const resolvedOffset = history[TIMING_HISTORY_INTERPOLATION_OFFSET];
+      if (Number.isInteger(resolvedOffset) && resolvedOffset >= 0 && resolvedOffset < count - 1) {
+        const currentPosition = count - 1 - resolvedOffset;
+        const currentIndex = (startIndex + currentPosition) % TIMING_HISTORY_MAX_SAMPLES;
+        const previousIndex = (startIndex + currentPosition - 1) % TIMING_HISTORY_MAX_SAMPLES;
+        const currentDistance = history.distances[currentIndex];
+        const previousDistance = history.distances[previousIndex];
+        if (targetDistance > currentDistance) {
+          for (let offset = resolvedOffset - 1; offset >= 0; offset -= 1) {
+            const value = interpolateStructuredTimingHistoryAtOffset(history, startIndex, count, targetDistance, offset);
+            if (Number.isFinite(value)) return value;
+          }
+        } else if (targetDistance < previousDistance) {
+          for (let offset = resolvedOffset + 1; offset < count - 1; offset += 1) {
+            const value = interpolateStructuredTimingHistoryAtOffset(history, startIndex, count, targetDistance, offset);
+            if (Number.isFinite(value)) return value;
+          }
+        }
+      }
+    }
+    for (let offset = 0; offset < count - 1; offset += 1) {
+      const value = interpolateStructuredTimingHistoryAtOffset(history, startIndex, count, targetDistance, offset);
+      if (Number.isFinite(value)) return value;
+    }
+    return null;
+  }
+  if (!Array.isArray(history)) return null;
+  const startIndex = getTimingHistoryStartIndex(history);
+  if (activeTimingHistoryLength(history, startIndex) < 2) return null;
+  for (let index = history.length - 1; index > startIndex; index -= 1) {
     const current = history[index];
     const previous = history[index - 1];
     if (targetDistance < previous.raceDistance || targetDistance > current.raceDistance) continue;
@@ -44,3 +223,39 @@ export function interpolateTimeAtDistance(history, targetDistance) {
   }
   return null;
 }
+
+function interpolateStructuredTimingHistoryAtOffset(history, startIndex, count, targetDistance, offsetFromTail) {
+  const currentPosition = count - 1 - offsetFromTail;
+  const currentIndex = (startIndex + currentPosition) % TIMING_HISTORY_MAX_SAMPLES;
+  const previousIndex = (startIndex + currentPosition - 1) % TIMING_HISTORY_MAX_SAMPLES;
+  const currentDistance = history.distances[currentIndex];
+  const previousDistance = history.distances[previousIndex];
+  if (targetDistance < previousDistance || targetDistance > currentDistance) return null;
+  history[TIMING_HISTORY_INTERPOLATION_OFFSET] = offsetFromTail;
+  history[TIMING_HISTORY_INTERPOLATION_LOWER_DISTANCE] = previousDistance;
+  history[TIMING_HISTORY_INTERPOLATION_UPPER_DISTANCE] = currentDistance;
+  history[TIMING_HISTORY_INTERPOLATION_LOWER_TIME] = history.times[previousIndex];
+  history[TIMING_HISTORY_INTERPOLATION_UPPER_TIME] = history.times[currentIndex];
+  const coveredDistance = currentDistance - previousDistance;
+  if (coveredDistance <= 1e-6) return history.times[currentIndex];
+  const ratio = (targetDistance - previousDistance) / coveredDistance;
+  return history.times[previousIndex] + (history.times[currentIndex] - history.times[previousIndex]) * ratio;
+}
+
+function interpolateDirectCachedSegment(history, targetDistance) {
+  const lowerDistance = history[TIMING_HISTORY_INTERPOLATION_LOWER_DISTANCE];
+  const upperDistance = history[TIMING_HISTORY_INTERPOLATION_UPPER_DISTANCE];
+  if (!Number.isFinite(lowerDistance) || !Number.isFinite(upperDistance)) return null;
+  if (targetDistance < lowerDistance || targetDistance > upperDistance) return null;
+
+  const lowerTime = history[TIMING_HISTORY_INTERPOLATION_LOWER_TIME];
+  const upperTime = history[TIMING_HISTORY_INTERPOLATION_UPPER_TIME];
+  const stats = history[TIMING_HISTORY_INTERPOLATION_STATS];
+  if (stats) {
+    stats.directSegmentCacheHits = (stats.directSegmentCacheHits ?? 0) + 1;
+  }
+  const coveredDistance = upperDistance - lowerDistance;
+  if (coveredDistance <= 1e-6) return upperTime;
+  const ratio = (targetDistance - lowerDistance) / coveredDistance;
+  return lowerTime + (upperTime - lowerTime) * ratio;
+}

package/src/simulation/timing/timingLines.js

@@ -3,6 +3,53 @@ import { metersToSimUnits, simUnitsToMeters } from '../units.js';
 import { pointAt } from '../track/trackModel.js';
 import { TIMING_LINE_HISTORY_LAPS, TIMING_LINE_TARGET_SPACING_METERS } from './timingConstants.js';
 
+function setTimingLineCrossingBounds(car, firstLine, lastLine) {
+  car.timingLineFirstStored = Number.isInteger(firstLine) ? firstLine : null;
+  car.timingLineLastStored = Number.isInteger(lastLine) ? lastLine : null;
+}
+
+function ensureTimingLineCrossingBounds(car) {
+  if (Number.isInteger(car.timingLineFirstStored) && Number.isInteger(car.timingLineLastStored)) {
+    return {
+      firstLine: car.timingLineFirstStored,
+      lastLine: car.timingLineLastStored,
+    };
+  }
+  const lineNumbers = Object.keys(car.timingLineCrossings)
+    .map((key) => Number(key))
+    .filter((value) => Number.isFinite(value))
+    .sort((left, right) => left - right);
+  const firstLine = lineNumbers[0];
+  const lastLine = lineNumbers[lineNumbers.length - 1];
+  setTimingLineCrossingBounds(car, firstLine, lastLine);
+  return {
+    firstLine: car.timingLineFirstStored,
+    lastLine: car.timingLineLastStored,
+  };
+}
+
+function setTimingLineCrossing(car, lineNumber, crossingTime) {
+  car.timingLineCrossings[lineNumber] = crossingTime;
+  const firstLine = car.timingLineFirstStored;
+  const lastLine = car.timingLineLastStored;
+  if (!Number.isInteger(firstLine) || lineNumber < firstLine) car.timingLineFirstStored = lineNumber;
+  if (!Number.isInteger(lastLine) || lineNumber > lastLine) car.timingLineLastStored = lineNumber;
+}
+
+function pruneTimingLineCrossings(car, cutoffLine) {
+  const { firstLine, lastLine } = ensureTimingLineCrossingBounds(car);
+  if (!Number.isInteger(firstLine) || !Number.isInteger(lastLine) || cutoffLine <= firstLine) return;
+  const pruneEnd = Math.min(lastLine, cutoffLine - 1);
+  for (let lineNumber = firstLine; lineNumber <= pruneEnd; lineNumber += 1) {
+    delete car.timingLineCrossings[lineNumber];
+  }
+  if (cutoffLine > lastLine) {
+    setTimingLineCrossingBounds(car, null, null);
+    return;
+  }
+  setTimingLineCrossingBounds(car, cutoffLine, lastLine);
+}
+
 export function createTimingLines(track) {
   const targetSpacing = metersToSimUnits(TIMING_LINE_TARGET_SPACING_METERS);
   const count = Math.max(1, Math.round(track.length / targetSpacing));
@@ -36,6 +83,8 @@ export function resetTimingLineCrossings(car, currentTime) {
   car.timingLineCrossings = Object.create(null);
   car.timingLineLastUpdatedAt = currentTime;
   car.previousRaceDistanceForTiming = car.raceDistance;
+  setTimingLineCrossingBounds(car, null, null);
+  car.timingLinePruneCutoff = null;
 }
 
 export function recordTimingLineCrossings(car, previousRaceDistance, currentTime, track) {
@@ -51,6 +100,18 @@ export function recordTimingLineCrossings(car, previousRaceDistance, currentTime
   const travelled = currentDistance - previousDistance;
   const previousTime = Number.isFinite(car.timingLineLastUpdatedAt) ? car.timingLineLastUpdatedAt : currentTime;
   const elapsed = Math.max(0, currentTime - previousTime);
+  const latestLine = getTimingLineNumber(track, currentDistance);
+  const cutoff = latestLine != null
+    ? latestLine - (track.timingLines.count * TIMING_LINE_HISTORY_LAPS)
+    : null;
+
+  if (Math.abs(travelled) <= 1e-6) {
+    car.timingLineLastUpdatedAt = currentTime;
+    if (!Number.isFinite(cutoff) || cutoff <= 0 || cutoff === car.timingLinePruneCutoff) return;
+    pruneTimingLineCrossings(car, cutoff);
+    car.timingLinePruneCutoff = cutoff;
+    return;
+  }
 
   if (travelled > 1e-6 && travelled < track.length / 2) {
     const firstLine = Math.floor(Math.max(0, previousDistance) / spacing) + 1;
@@ -59,17 +120,14 @@ export function recordTimingLineCrossings(car, previousRaceDistance, currentTime
       const lineDistance = lineNumber * spacing;
       if (lineDistance <= previousDistance + 1e-6 || lineDistance > currentDistance + 1e-6) continue;
       const ratio = clamp((lineDistance - previousDistance) / travelled, 0, 1);
-      car.timingLineCrossings[lineNumber] = previousTime + ratio * elapsed;
+      setTimingLineCrossing(car, lineNumber, previousTime + ratio * elapsed);
     }
   }
 
   car.timingLineLastUpdatedAt = currentTime;
-  const latestLine = getTimingLineNumber(track, currentDistance);
-  if (latestLine != null) {
-    const cutoff = latestLine - (track.timingLines.count * TIMING_LINE_HISTORY_LAPS);
-    Object.keys(car.timingLineCrossings).forEach((key) => {
-      if (Number(key) < cutoff) delete car.timingLineCrossings[key];
-    });
+  if (Number.isFinite(cutoff) && cutoff > 0 && cutoff !== car.timingLinePruneCutoff) {
+    pruneTimingLineCrossings(car, cutoff);
+    car.timingLinePruneCutoff = cutoff;
   }
 }
 

package/src/simulation/track/pitLaneLayout.js

@@ -1,9 +1,9 @@
 import { clamp } from '../simMath.js';
 import { metersToSimUnits } from '../units.js';
 import { WORLD, PIT_BOX_COUNT, PIT_BOX_DEPTH, PIT_BOX_LENGTH, PIT_BOX_PAIR_GAP, PIT_BOX_TO_LANE_GAP, PIT_ENTRY_SEARCH_AFTER, PIT_ENTRY_SEARCH_BEFORE, PIT_EXIT_SEARCH_AFTER, PIT_EXIT_SEARCH_BEFORE, PIT_LANE_EDGE_GAP, PIT_LANE_ENTRY_BUFFER, PIT_LANE_EXIT_BUFFER, PIT_LANE_FINISH_RATIO, PIT_LANE_OFFSET_SEARCH_STEP, PIT_LANE_WIDTH, PIT_SERVICE_AREA_DEPTH, PIT_SERVICE_AREA_LENGTH, PIT_SERVICE_QUEUE_GAP, PIT_TEAM_COUNT, PIT_TEAM_GAP, PIT_BOXES_PER_TEAM, PIT_WORKING_LANE_GAP, PIT_WORKING_LANE_WIDTH, PIT_ACCESS_MAX_LENGTH, PIT_ACCESS_MIN_LENGTH, PIT_ACCESS_TANGENT_RATIO, PIT_TRACK_CLEARANCE_MARGIN } from './trackConstants.js';
-import { clonePoint, distance, headingVector, interpolatePitPoint, normalizeVector, pointWorldClearance, projectPitPoint, createPointBounds } from './trackMath.js';
+import { clonePoint, distance, headingVector, interpolatePitPoint, nearestPointOnPolyline, normalizeVector, pointWorldClearance, projectPitPoint, createPointBounds } from './trackMath.js';
 import { findPitAccessConnection, createPitAccessRoadCenterline } from './pitLaneAccess.js';
-import { nearestTrackState, pointAt } from './spatialQueries.js';
+import { pointAt } from './spatialQueries.js';
 
 export function createStartStraightBasis(track) {
   const finish = pointAt(track, 0);
@@ -90,7 +90,7 @@ export function scorePitLanePlacement(track, side, laneOffset, layout) {
     minimumClearance = Math.min(minimumClearance, pointWorldClearance(lanePoint), pointWorldClearance(boxPoint));
     minimumTrackClearance = Math.min(
       minimumTrackClearance,
-      nearestTrackState(track, lanePoint).crossTrackError -
+      nearestMainTrackProjection(track, lanePoint).crossTrackError -
         (track.width / 2 + (track.kerbWidth ?? 0) + PIT_TRACK_CLEARANCE_MARGIN),
     );
   }
@@ -105,6 +105,10 @@ export function scorePitLanePlacement(track, side, laneOffset, layout) {
   };
 }
 
+function nearestMainTrackProjection(track, position) {
+  return nearestPointOnPolyline(track.samples, position) ?? { crossTrackError: Infinity };
+}
+
 export function choosePitLanePlacement(track, baseLaneOffset, layout) {
   const candidates = [];
   for (let offsetStep = 0; offsetStep <= 9; offsetStep += 1) {
@@ -270,6 +274,27 @@ export function createPitLaneBounds(pitLane) {
   return createPointBounds(points, padding);
 }
 
+export function createPitBoxBounds(pitLane) {
+  const points = [
+    ...(pitLane.boxes ?? []).flatMap((box) => box.corners ?? []),
+    ...(pitLane.serviceAreas ?? []).flatMap((area) => [
+      ...(area.corners ?? []),
+      ...(area.queueCorners ?? []),
+    ]),
+  ];
+  if (!points.length) return null;
+  const padding = Math.max(PIT_BOX_DEPTH, PIT_SERVICE_AREA_DEPTH) / 2 + metersToSimUnits(3);
+  return createPointBounds(points, padding);
+}
+
+export function createPitConnectorBounds(pitLane) {
+  const connectorPadding = metersToSimUnits(18);
+  return {
+    entry: createPointBounds(pitLane.entry?.connector ?? [], connectorPadding),
+    exit: createPointBounds(pitLane.exit?.connector ?? [], connectorPadding),
+  };
+}
+
 export function createPitLaneModel(track) {
   const layout = createPitLaneLayout();
   const laneOffset = track.width / 2 + (track.kerbWidth ?? 0) + PIT_LANE_EDGE_GAP + PIT_LANE_WIDTH / 2;
@@ -391,5 +416,7 @@ export function createPitLaneModel(track) {
   return {
     ...pitLane,
     bounds: createPitLaneBounds(pitLane),
+    boxBounds: createPitBoxBounds(pitLane),
+    connectorBounds: createPitConnectorBounds(pitLane),
   };
 }