@inventure71/paddockjs 2.0.1 → 4.0.0

package/src/simulation/timing/lapTelemetry.js

@@ -12,7 +12,7 @@ function getSectorLength(track) {
   return track.length / TELEMETRY_SECTOR_COUNT;
 }
 
-function getLapTelemetryPosition(track, raceDistance, totalLaps = Infinity) {
+function writeLapTelemetryPosition(target, track, raceDistance, totalLaps = Infinity) {
   const positiveDistance = Math.max(0, raceDistance ?? 0);
   const lapIndex = Math.min(
     Math.floor(positiveDistance / track.length),
@@ -25,41 +25,40 @@ function getLapTelemetryPosition(track, raceDistance, totalLaps = Infinity) {
   const sectorIndex = Math.min(TELEMETRY_SECTOR_COUNT - 1, Math.floor(lapProgress / sectorLength));
   const sectorStart = sectorIndex * sectorLength;
 
-  return {
-    completedLaps: Math.floor(positiveDistance / track.length),
-    currentLap: Math.max(1, lapIndex + 1),
-    currentSector: sectorIndex + 1,
-    currentSectorProgress: clamp((lapProgress - sectorStart) / sectorLength, 0, 1),
-  };
+  target.completedLaps = Math.floor(positiveDistance / track.length);
+  target.currentLap = Math.max(1, lapIndex + 1);
+  target.currentSector = sectorIndex + 1;
+  target.currentSectorProgress = clamp((lapProgress - sectorStart) / sectorLength, 0, 1);
+  return target;
 }
 
-function createSectorProgress(position, currentSectors = null) {
+function createSectorProgress(position, currentSectors = null, { preserveCompletedSectors = false } = {}) {
   const activeIndex = clamp((position.currentSector ?? 1) - 1, 0, TELEMETRY_SECTOR_COUNT - 1);
-  return createEmptySectorTimes().map((_, index) => {
-    if (index < activeIndex && Number.isFinite(currentSectors?.[index])) return 1;
-    if (index === activeIndex) return clamp(position.currentSectorProgress ?? 0, 0, 1);
-    return 0;
-  });
+  const progress = createEmptySectorTimes();
+  writeSectorProgress(progress, position, currentSectors, { preserveCompletedSectors, activeIndex });
+  return progress;
 }
 
 export function createLapTelemetry(track, currentTime = 0, raceDistance = 0, totalLaps = Infinity) {
-  const position = getLapTelemetryPosition(track, raceDistance, totalLaps);
-  return {
-    ...position,
+  const telemetry = {
     currentLapStartedAt: currentTime,
     currentSectorStartedAt: currentTime,
     lastUpdatedAt: currentTime,
     currentLapTime: 0,
     currentSectorElapsed: 0,
     currentSectors: createEmptySectorTimes(),
-    sectorProgress: createSectorProgress(position),
+    sectorProgress: createEmptySectorTimes(),
     liveSectors: createEmptySectorTimes(),
     lastLapTime: null,
     bestLapTime: null,
     lastSectors: createEmptySectorTimes(),
     bestSectors: createEmptySectorTimes(),
     sectorPerformance: createEmptySectorPerformance(),
+    sectorPerformanceRevision: 0,
   };
+  writeLapTelemetryPosition(telemetry, track, raceDistance, totalLaps);
+  telemetry.sectorProgress = createSectorProgress(telemetry);
+  return telemetry;
 }
 
 export function resetLapTelemetry(car, currentTime, track, totalLaps) {
@@ -99,12 +98,25 @@ export function updateLapTelemetry(car, previousRaceDistance, currentTime, track
   const previousUpdateTime = Number.isFinite(telemetry.lastUpdatedAt) ? telemetry.lastUpdatedAt : currentTime;
   const elapsedTime = Math.max(0, currentTime - previousUpdateTime);
 
-  if (!Number.isFinite(previousDistance) || !Number.isFinite(currentDistance) || travelled < -1e-3 || travelled > track.length / 2) {
+  if (
+    !Number.isFinite(previousDistance) ||
+    !Number.isFinite(currentDistance) ||
+    Math.abs(travelled) > track.length / 2
+  ) {
     resetLapTelemetry(car, currentTime, track, totalLaps);
-    return;
+    return true;
+  }
+
+  if (travelled < -1e-3) {
+    syncLapTelemetryPosition(telemetry, currentTime, currentRaceDistance, track, totalLaps, {
+      preserveCompletedSectors: true,
+    });
+    telemetry.lastUpdatedAt = currentTime;
+    return false;
   }
 
   const sectorLength = getSectorLength(track);
+  let crossedBoundary = false;
   if (travelled > 1e-6) {
     const firstBoundary = Math.floor(previousDistance / sectorLength) + 1;
     const lastBoundary = Math.floor(currentDistance / sectorLength);
@@ -112,6 +124,7 @@ export function updateLapTelemetry(car, previousRaceDistance, currentTime, track
     for (let boundary = firstBoundary; boundary <= lastBoundary; boundary += 1) {
       const boundaryDistance = boundary * sectorLength;
       if (boundaryDistance <= previousDistance + 1e-3 || boundaryDistance > currentDistance + 1e-3) continue;
+      crossedBoundary = true;
 
       const boundaryRatio = clamp((boundaryDistance - previousDistance) / travelled, 0, 1);
       const crossingTime = previousUpdateTime + boundaryRatio * elapsedTime;
@@ -127,8 +140,8 @@ export function updateLapTelemetry(car, previousRaceDistance, currentTime, track
         telemetry.bestLapTime = Number.isFinite(telemetry.bestLapTime)
           ? Math.min(telemetry.bestLapTime, lapTime)
           : lapTime;
-        telemetry.lastSectors = serializeSectorTimes(telemetry.currentSectors);
-        telemetry.currentSectors = createEmptySectorTimes();
+        telemetry.lastSectors = copySectorTimes(telemetry.lastSectors, telemetry.currentSectors);
+        clearSectorTimes(telemetry.currentSectors);
         telemetry.currentLapStartedAt = crossingTime;
         telemetry.completedLaps = Math.max(telemetry.completedLaps + 1, Math.min(Math.floor(boundaryDistance / track.length), totalLaps));
       }
@@ -137,8 +150,18 @@ export function updateLapTelemetry(car, previousRaceDistance, currentTime, track
     }
   }
 
+  if (!crossedBoundary) {
+    syncInProgressLapTelemetry(telemetry, currentTime, currentRaceDistance, track, totalLaps);
+    telemetry.lastUpdatedAt = currentTime;
+    return false;
+  }
+
   syncLapTelemetryPosition(telemetry, currentTime, currentRaceDistance, track, totalLaps);
   telemetry.lastUpdatedAt = currentTime;
+  if (crossedBoundary) {
+    telemetry.sectorPerformanceRevision = (telemetry.sectorPerformanceRevision ?? 0) + 1;
+  }
+  return crossedBoundary;
 }
 
 function updateBestSector(telemetry, sectorIndex, sectorTime) {
@@ -155,28 +178,103 @@ function clearFutureSectorTelemetry(telemetry) {
   }
 }
 
-function syncLiveSectorTelemetry(telemetry) {
+function syncLiveSectorTelemetry(telemetry, { preserveCompletedSectors = false } = {}) {
   const activeIndex = clamp((telemetry.currentSector ?? 1) - 1, 0, TELEMETRY_SECTOR_COUNT - 1);
+  const liveSectors = ensureSectorTimesArray(telemetry.liveSectors);
+  clearSectorTimes(liveSectors);
+  for (let index = 0; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    const time = telemetry.currentSectors[index];
+    if (!preserveCompletedSectors && index >= activeIndex) continue;
+    if (!Number.isFinite(time)) continue;
+    liveSectors[index] = time;
+  }
+  if (!Number.isFinite(liveSectors[activeIndex])) {
+    liveSectors[activeIndex] = telemetry.currentSectorElapsed;
+  }
+  telemetry.liveSectors = liveSectors;
+}
 
-  telemetry.liveSectors = createEmptySectorTimes();
-  telemetry.currentSectors.forEach((time, index) => {
-    if (index >= activeIndex) return;
-    if (!Number.isFinite(time)) return;
-    telemetry.liveSectors[index] = time;
+function syncInProgressLapTelemetry(telemetry, currentTime, currentRaceDistance, track, totalLaps) {
+  const positiveDistance = Math.max(0, currentRaceDistance ?? 0);
+  const maxLapIndex = Math.max(0, totalLaps - 1);
+  const lapIndex = Math.min(Math.floor(positiveDistance / track.length), maxLapIndex);
+  const lapProgress = positiveDistance >= track.length * totalLaps
+    ? track.length
+    : positiveDistance - lapIndex * track.length;
+  const sectorLength = getSectorLength(track);
+  const activeIndex = Math.min(TELEMETRY_SECTOR_COUNT - 1, Math.floor(lapProgress / sectorLength));
+  const sectorStart = activeIndex * sectorLength;
+  const sectorProgress = ensureSectorTimesArray(telemetry.sectorProgress);
+  const liveSectors = ensureSectorTimesArray(telemetry.liveSectors);
+
+  telemetry.completedLaps = Math.floor(positiveDistance / track.length);
+  telemetry.currentLap = Math.max(1, lapIndex + 1);
+  telemetry.currentSector = activeIndex + 1;
+  telemetry.currentSectorProgress = clamp((lapProgress - sectorStart) / sectorLength, 0, 1);
+  telemetry.currentLapTime = Math.max(0, currentTime - telemetry.currentLapStartedAt);
+  telemetry.currentSectorElapsed = Math.max(0, currentTime - telemetry.currentSectorStartedAt);
+  for (let index = activeIndex; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    telemetry.currentSectors[index] = null;
+    liveSectors[index] = null;
+    sectorProgress[index] = 0;
+  }
+  sectorProgress[activeIndex] = telemetry.currentSectorProgress;
+  liveSectors[activeIndex] = telemetry.currentSectorElapsed;
+  telemetry.sectorProgress = sectorProgress;
+  telemetry.liveSectors = liveSectors;
+}
+
+function syncLapTelemetryPosition(telemetry, currentTime, currentRaceDistance, track, totalLaps, {
+  preserveCompletedSectors = false,
+} = {}) {
+  writeLapTelemetryPosition(telemetry, track, currentRaceDistance, totalLaps);
+  if (!preserveCompletedSectors) clearFutureSectorTelemetry(telemetry);
+  const sectorProgress = ensureSectorTimesArray(telemetry.sectorProgress);
+  writeSectorProgress(sectorProgress, telemetry, telemetry.currentSectors, {
+    preserveCompletedSectors,
   });
-  telemetry.liveSectors[activeIndex] = telemetry.currentSectorElapsed;
-}
-
-function syncLapTelemetryPosition(telemetry, currentTime, currentRaceDistance, track, totalLaps) {
-  const position = getLapTelemetryPosition(track, currentRaceDistance, totalLaps);
-  telemetry.completedLaps = position.completedLaps;
-  telemetry.currentLap = position.currentLap;
-  telemetry.currentSector = position.currentSector;
-  telemetry.currentSectorProgress = position.currentSectorProgress;
-  clearFutureSectorTelemetry(telemetry);
-  telemetry.sectorProgress = createSectorProgress(position, telemetry.currentSectors);
-  telemetry.completedLaps = Math.max(telemetry.completedLaps, Math.min(position.completedLaps, totalLaps));
+  telemetry.sectorProgress = sectorProgress;
+  telemetry.completedLaps = Math.max(telemetry.completedLaps, Math.min(telemetry.completedLaps, totalLaps));
   telemetry.currentLapTime = Math.max(0, currentTime - telemetry.currentLapStartedAt);
   telemetry.currentSectorElapsed = Math.max(0, currentTime - telemetry.currentSectorStartedAt);
-  syncLiveSectorTelemetry(telemetry);
+  syncLiveSectorTelemetry(telemetry, { preserveCompletedSectors });
+}
+
+function ensureSectorTimesArray(values) {
+  return Array.isArray(values) && values.length === TELEMETRY_SECTOR_COUNT
+    ? values
+    : createEmptySectorTimes();
+}
+
+function clearSectorTimes(values) {
+  for (let index = 0; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    values[index] = null;
+  }
+}
+
+function copySectorTimes(target, source) {
+  const nextTarget = ensureSectorTimesArray(target);
+  for (let index = 0; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    nextTarget[index] = finiteOrNull(source?.[index]);
+  }
+  return nextTarget;
+}
+
+function writeSectorProgress(target, position, currentSectors = null, { preserveCompletedSectors = false, activeIndex = null } = {}) {
+  const resolvedActiveIndex = activeIndex == null
+    ? clamp((position.currentSector ?? 1) - 1, 0, TELEMETRY_SECTOR_COUNT - 1)
+    : activeIndex;
+  for (let index = 0; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    if (preserveCompletedSectors && Number.isFinite(currentSectors?.[index])) {
+      target[index] = 1;
+      continue;
+    }
+    if (index < resolvedActiveIndex && Number.isFinite(currentSectors?.[index])) {
+      target[index] = 1;
+      continue;
+    }
+    target[index] = index === resolvedActiveIndex
+      ? clamp(position.currentSectorProgress ?? 0, 0, 1)
+      : 0;
+  }
 }

package/src/simulation/timing/raceTiming.js

@@ -5,7 +5,11 @@ export {
   updateLapTelemetry,
 } from './lapTelemetry.js';
 export { estimateGapAheadSeconds, estimateTimingLineGapSeconds, wholeLapGap } from './gapEstimation.js';
-export { createEmptySectorPerformance, createEmptySectorTimes, updateSectorPerformance } from './sectorPerformance.js';
+export {
+  createEmptySectorPerformance,
+  createEmptySectorTimes,
+  updateSectorPerformance,
+} from './sectorPerformance.js';
 export { recordTimingSample, resetTimingHistory, trimTimingHistory } from './timingHistory.js';
 export {
   createTimingLines,

package/src/simulation/timing/sectorPerformance.js

@@ -1,5 +1,9 @@
 import { TELEMETRY_SECTOR_COUNT } from './timingConstants.js';
 
+const OVERALL_BEST_0 = '_sectorPerformanceOverallBest0';
+const OVERALL_BEST_1 = '_sectorPerformanceOverallBest1';
+const OVERALL_BEST_2 = '_sectorPerformanceOverallBest2';
+
 export function createEmptySectorTimes() {
   return Array.from({ length: TELEMETRY_SECTOR_COUNT }, () => null);
 }
@@ -20,32 +24,80 @@ export function serializeSectorPerformance(values) {
   return createEmptySectorTimes().map((_, index) => values?.[index] ?? null);
 }
 
-export function updateSectorPerformance(cars) {
-  const overallBestSectors = createEmptySectorTimes();
-  cars.forEach((car) => {
-    car.lapTelemetry?.bestSectors?.forEach((value, index) => {
-      if (!Number.isFinite(value)) return;
-      const previousBest = overallBestSectors[index];
-      if (!Number.isFinite(previousBest) || value < previousBest) overallBestSectors[index] = value;
-    });
-  });
-  cars.forEach((car) => {
-    const telemetry = car.lapTelemetry;
-    if (!telemetry) return;
-    telemetry.sectorPerformance = {
-      current: telemetry.currentSectors.map((value, index) => classifySectorPerformance(
-        value,
-        telemetry.bestSectors[index],
-        overallBestSectors[index],
-      )),
-      last: telemetry.lastSectors.map((value, index) => classifySectorPerformance(
-        value,
-        telemetry.bestSectors[index],
-        overallBestSectors[index],
-      )),
-      best: telemetry.bestSectors.map((value, index) => classifySectorPerformance(value, value, overallBestSectors[index])),
-    };
-  });
+export function updateSectorPerformance(cars, stats = null) {
+  let overallBest0 = null;
+  let overallBest1 = null;
+  let overallBest2 = null;
+  let changedCars = 0;
+
+  for (let index = 0; index < cars.length; index += 1) {
+    const telemetry = cars[index]?.lapTelemetry;
+    if (!telemetry) continue;
+    const best0 = finiteOrNull(telemetry.bestSectors?.[0]);
+    const best1 = finiteOrNull(telemetry.bestSectors?.[1]);
+    const best2 = finiteOrNull(telemetry.bestSectors?.[2]);
+    const revision = telemetry.sectorPerformanceRevision ?? 0;
+    if (telemetry._sectorPerfAppliedRevision !== revision) changedCars += 1;
+    if (Number.isFinite(best0) && (!Number.isFinite(overallBest0) || best0 < overallBest0)) overallBest0 = best0;
+    if (Number.isFinite(best1) && (!Number.isFinite(overallBest1) || best1 < overallBest1)) overallBest1 = best1;
+    if (Number.isFinite(best2) && (!Number.isFinite(overallBest2) || best2 < overallBest2)) overallBest2 = best2;
+  }
+
+  const overallBestChanged =
+    overallBest0 !== cars[OVERALL_BEST_0] ||
+    overallBest1 !== cars[OVERALL_BEST_1] ||
+    overallBest2 !== cars[OVERALL_BEST_2];
+
+  if (stats) {
+    stats.sectorPerformanceChangedCars = (stats.sectorPerformanceChangedCars ?? 0) + changedCars;
+  }
+
+  if (!overallBestChanged && changedCars === 0) {
+    if (stats) stats.sectorPerformanceSkippedRebuilds = (stats.sectorPerformanceSkippedRebuilds ?? 0) + 1;
+    return false;
+  }
+
+  cars[OVERALL_BEST_0] = overallBest0;
+  cars[OVERALL_BEST_1] = overallBest1;
+  cars[OVERALL_BEST_2] = overallBest2;
+
+  let updatedCars = 0;
+  const overallBestSectors = [overallBest0, overallBest1, overallBest2];
+  for (let index = 0; index < cars.length; index += 1) {
+    const telemetry = cars[index]?.lapTelemetry;
+    if (!telemetry) continue;
+    const revision = telemetry.sectorPerformanceRevision ?? 0;
+    if (!overallBestChanged && telemetry._sectorPerfAppliedRevision === revision) continue;
+    const sectorPerformance = ensureSectorPerformanceShape(telemetry.sectorPerformance);
+    writeSectorPerformance(
+      sectorPerformance.current,
+      telemetry.currentSectors,
+      telemetry.bestSectors,
+      overallBestSectors,
+    );
+    writeSectorPerformance(
+      sectorPerformance.last,
+      telemetry.lastSectors,
+      telemetry.bestSectors,
+      overallBestSectors,
+    );
+    writeSectorPerformance(
+      sectorPerformance.best,
+      telemetry.bestSectors,
+      telemetry.bestSectors,
+      overallBestSectors,
+    );
+    telemetry.sectorPerformance = sectorPerformance;
+    telemetry._sectorPerfAppliedRevision = revision;
+    updatedCars += 1;
+  }
+
+  if (stats) {
+    stats.sectorPerformanceRebuilds = (stats.sectorPerformanceRebuilds ?? 0) + 1;
+    stats.sectorPerformanceUpdatedCars = (stats.sectorPerformanceUpdatedCars ?? 0) + updatedCars;
+    if (overallBestChanged) stats.sectorPerformanceOverallBestChanges = (stats.sectorPerformanceOverallBestChanges ?? 0) + 1;
+  }
+  return true;
 }
 
 export function finiteOrNull(value) {
@@ -58,3 +110,29 @@ function classifySectorPerformance(value, personalBest, overallBest) {
   if (Number.isFinite(personalBest) && Math.abs(value - personalBest) <= 1e-6) return 'personal-best';
   return 'slower';
 }
+
+function ensureSectorPerformanceShape(sectorPerformance) {
+  if (!sectorPerformance || typeof sectorPerformance !== 'object') {
+    return createEmptySectorPerformance();
+  }
+  sectorPerformance.current = ensureSectorArray(sectorPerformance.current);
+  sectorPerformance.last = ensureSectorArray(sectorPerformance.last);
+  sectorPerformance.best = ensureSectorArray(sectorPerformance.best);
+  return sectorPerformance;
+}
+
+function ensureSectorArray(values) {
+  return Array.isArray(values) && values.length === TELEMETRY_SECTOR_COUNT
+    ? values
+    : createEmptySectorTimes();
+}
+
+function writeSectorPerformance(target, sectorValues, bestSectors, overallBestSectors) {
+  for (let index = 0; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    target[index] = classifySectorPerformance(
+      sectorValues?.[index],
+      bestSectors?.[index],
+      overallBestSectors[index],
+    );
+  }
+}