@inventure71/paddockjs 4.1.0 → 4.3.0

package/src/environment/sensors/rayBandTrace.js

@@ -7,13 +7,13 @@ import { querySegmentNeighborhoodProjection, querySegmentNeighborhoodProjections
 import {
   ANALYTIC_TRACK_RAY_MAX_CURVATURE,
   DRIVER_RAY_REFINE_STEPS,
-  PIT_CONNECTOR_RAY_FALLBACK_METERS,
   TRACK_RAY_REFINE_STEPS,
   TRACK_RAY_STEP_METERS,
 } from './rayDefaults.js';
 import { findIndexedRayBoundaryDistances } from './indexedRayBands.js';
 import { createRayChannelFlags, isLegalRaySurface, writeRayChannelFlags } from './rayChannels.js';
 import { canUseIndexedRecoveryRayApproximation } from './rayGuards.js';
+import { isNearPitConnector } from './pitConnectorProximity.js';
 
 const BOUNDARY_VALIDATION_EPSILON_METERS = 0.25;
 const LOCAL_SEGMENT_RECOVERY_BATCH_SIZE = 16;
@@ -67,7 +67,6 @@ export function traceIndexedRayBands({
   }
 
   const trackHalfWidth = track.width / 2;
-  const kerbOuter = trackHalfWidth + (track.kerbWidth ?? 0);
   const boundaries = findIndexedSurfaceBoundaries(
     track,
     origin,
@@ -321,15 +320,6 @@ function directBoundaryFallbackReason({
   ) {
     return 'kerb-recovery';
   }
-  if (
-    channels.hasIllegalSurface &&
-    originState.surface === 'barrier' &&
-    boundaries.runoffOuterDistance == null &&
-    Math.abs(originState.signedOffset) > kerbOuter &&
-    !barrierOriginCanStayDirect
-  ) {
-    return 'illegal-surface-recovery';
-  }
   return null;
 }
 
@@ -1090,14 +1080,6 @@ function isInsideTrackBorder(state, track, includePitLane = false) {
   return Math.abs(state?.crossTrackError ?? Infinity) <= track.width / 2;
 }
 
-function createTrackMiss(lengthMeters) {
-  return writeTrackMiss({}, lengthMeters);
-}
-
-function createSurfaceMiss(lengthMeters) {
-  return writeSurfaceMiss({}, lengthMeters);
-}
-
 function writeTrackMiss(target, lengthMeters) {
   target.hit = false;
   target.distanceMeters = lengthMeters;
@@ -1119,24 +1101,6 @@ function writeSurfaceHit(target, distanceMeters, surface) {
   return target;
 }
 
-function isNearPitConnector(track, state) {
-  const pitLane = track.pitLane;
-  if (!pitLane?.enabled || !Number.isFinite(state?.distance)) return false;
-  const window = metersToSimUnits(PIT_CONNECTOR_RAY_FALLBACK_METERS);
-  const entryDistance = pitLane.entry?.trackDistance ?? pitLane.entry?.distanceFromStart;
-  const exitDistance = pitLane.exit?.trackDistance ?? pitLane.exit?.distanceFromStart;
-  return wrappedTrackDistance(state.distance, entryDistance, track.length) <= window ||
-    wrappedTrackDistance(state.distance, exitDistance, track.length) <= window;
-}
-
-function wrappedTrackDistance(first, second, totalLength) {
-  if (!Number.isFinite(first) || !Number.isFinite(second) || !Number.isFinite(totalLength) || totalLength <= 0) {
-    return Infinity;
-  }
-  const delta = Math.abs(first - second);
-  return Math.min(delta, totalLength - delta);
-}
-
 function minFinite(...values) {
   let minimum = Infinity;
   for (let index = 0; index < values.length; index += 1) {

package/src/environment/sensors/rayBatch.js

@@ -0,0 +1,81 @@
+import { createCarRayMiss } from './carRays.js';
+import { createTrackMiss, createTrackRayContext } from './trackRays.js';
+import { canUseBatchTrainingRayApproximation } from './rayGuards.js';
+import { degreesToRadians } from './rayGeometry.js';
+import { createRayChannelContext, estimateCarHitForRay, estimateRayBands } from './rayQuery.js';
+import { appendRayVectorValues, writeRayVectorValues, writeRichRay } from './rayOutputs.js';
+import { getFilteredCarTargets, getNormalizedRayOptions, getRayOrigin, getRayScratch, getScratchRayVector, getSharedRayQuery, prepareScratchArray } from './rayScratch.js';
+
+export function buildRaySensors(car, snapshot, rayOptions = {}, batchContext = null) {
+  return buildRayBatch(car, snapshot, rayOptions, batchContext, 'rich');
+}
+
+export function buildRaySensorVectorValues(car, snapshot, rayOptions = {}, batchContext = null) {
+  return buildRayBatch(car, snapshot, rayOptions, batchContext, 'vector');
+}
+
+export function appendRaySensorVectorValues(target, car, snapshot, rayOptions = {}, batchContext = null) {
+  return buildRayBatch(car, snapshot, rayOptions, batchContext, 'append', target);
+}
+
+function buildRayBatch(car, snapshot, rayOptions, batchContext, output, target = null) {
+  const scratch = getRayScratch(batchContext);
+  const normalized = getNormalizedRayOptions(rayOptions, scratch);
+  if (!normalized.enabled) return target ?? [];
+  const channelContext = createRayChannelContext(normalized);
+  const inactive = Boolean(car?.destroyed || car?.outOfRace);
+  const origin = inactive ? null : getRayOrigin(car, scratch);
+  const trackContext = !inactive && channelContext.hasRoadOrSurface
+    ? createTrackRayContext(car, snapshot, origin, normalized.precision)
+    : null;
+  const carTargets = !inactive && channelContext.hasCar
+    ? getFilteredCarTargets(car, snapshot, batchContext, scratch)
+    : [];
+  const skipEmptyCarQuery = output === 'rich' && canUseFastBatchTrainingRays(car, snapshot, trackContext) && carTargets.length === 0;
+  const values = target ?? (output === 'rich'
+    ? prepareScratchArray(scratch, 'rays', 'rayPool', normalized.rays.length, () => ({})) ?? normalized.rays.map(() => ({}))
+    : prepareScratchArray(scratch, 'rayVectorValues', 'rayVectorValuePool', normalized.rays.length, () => []) ?? normalized.rays.map(() => []));
+
+  for (let index = 0; index < normalized.rays.length; index += 1) {
+    const ray = normalized.rays[index];
+    const angleRadians = degreesToRadians(ray.angleDegrees);
+    const vector = inactive ? null : getScratchRayVector(scratch, index, car, angleRadians);
+    const sharedRayQuery = inactive ? null : getSharedRayQuery(scratch, index);
+    const { roadEdge, surfaceHits } = inactive
+      ? { roadEdge: createTrackMiss(ray.lengthMeters), surfaceHits: {} }
+      : estimateRayBands({
+        car,
+        snapshot,
+        ray,
+        angleDegrees: ray.angleDegrees,
+        origin,
+        vector,
+        normalized,
+        channelContext,
+        trackContext,
+        sharedRayQuery,
+        scratch,
+      });
+    const carHit = !inactive && channelContext.hasCar && !skipEmptyCarQuery
+      ? estimateCarHitForRay(car, snapshot, ray, origin, vector, carTargets, sharedRayQuery, scratch)
+      : createCarRayMiss(ray.lengthMeters);
+    if (output === 'rich') {
+      writeRichRay(values[index], ray, angleRadians, roadEdge, carHit, surfaceHits, channelContext.channels);
+    } else if (output === 'vector') {
+      writeRayVectorValues(values[index], ray.lengthMeters, roadEdge, carHit, surfaceHits, channelContext.surfaceChannels);
+    } else {
+      appendRayVectorValues(values, ray.lengthMeters, roadEdge, carHit, surfaceHits, channelContext.surfaceChannels);
+    }
+  }
+  return values;
+}
+
+function canUseFastBatchTrainingRays(car, snapshot, trackContext) {
+  return car?.interaction?.profile === 'batch-training' &&
+    !car.inPitLane &&
+    !trackContext?.originState?.inPitLane &&
+    Array.isArray(snapshot.track?.samples) &&
+    snapshot.track.samples.length > 0 &&
+    trackContext?.originState &&
+    canUseBatchTrainingRayApproximation(snapshot.track, trackContext.originState);
+}

package/src/environment/sensors/rayConfig.js

@@ -2,6 +2,7 @@ import { DEFAULT_RAY_ANGLES_DEGREES } from './rayDefaults.js';
 import { RAY_CHANNELS } from './rayChannels.js';
 
 const NORMALIZED_RAY_OPTIONS = Symbol('normalizedRayOptions');
+const NORMALIZED_RAY_INPUTS = new WeakMap();
 
 export { RAY_CHANNELS } from './rayChannels.js';
 
@@ -63,9 +64,34 @@ export function normalizeRayOptions(rayOptions = {}) {
     value: true,
     enumerable: false,
   });
+  NORMALIZED_RAY_INPUTS.set(normalized, copyRayOptionsInput(rayOptions));
   return normalized;
 }
 
+export function mergeRayOptionOverrides(baseRays = {}, overrides = {}) {
+  const baseInput = NORMALIZED_RAY_INPUTS.get(baseRays) ?? baseRays;
+  const overrideInput = NORMALIZED_RAY_INPUTS.get(overrides) ?? overrides;
+  const requested = Object.fromEntries(Object.entries(overrideInput).filter(([, value]) => value !== undefined));
+  const merged = { ...baseInput, ...requested };
+  if (Object.hasOwn(requested, 'lengthMeters') && !Object.hasOwn(requested, 'defaultLengthMeters')) {
+    delete merged.defaultLengthMeters;
+  }
+  if (Object.hasOwn(requested, 'rays')) return merged;
+  if (Object.hasOwn(requested, 'layout') || Object.hasOwn(requested, 'anglesDegrees')) {
+    delete merged.rays;
+    if (Object.hasOwn(requested, 'anglesDegrees') && !Object.hasOwn(requested, 'layout')) delete merged.layout;
+  }
+  return merged;
+}
+
+function copyRayOptionsInput(source) {
+  const input = { ...source };
+  if (Array.isArray(source.rays)) input.rays = source.rays.map((ray) => typeof ray === 'object' && ray ? { ...ray } : ray);
+  if (Array.isArray(source.anglesDegrees)) input.anglesDegrees = [...source.anglesDegrees];
+  if (Array.isArray(source.channels)) input.channels = [...source.channels];
+  return input;
+}
+
 function normalizeRays(rayOptions, defaultLengthMeters) {
   const configuredRays = Array.isArray(rayOptions.rays)
     ? rayOptions.rays

package/src/environment/sensors/rayGeometry.js

@@ -20,10 +20,6 @@ export function pointOnRay(origin, ray, distance) {
   };
 }
 
-export function intersectAxisAlignedBoxRay(origin, ray, halfLength, halfWidth) {
-  return intersectAxisAlignedBoxRayScalars(origin.x, origin.y, ray.x, ray.y, halfLength, halfWidth);
-}
-
 export function intersectAxisAlignedBoxRayScalars(originX, originY, rayX, rayY, halfLength, halfWidth) {
   let tMin = -Infinity;
   let tMax = Infinity;
@@ -50,10 +46,6 @@ export function intersectAxisAlignedBoxRayScalars(originX, originY, rayX, rayY,
   return Math.max(0, tMin);
 }
 
-export function dot(a, b) {
-  return a.x * b.x + a.y * b.y;
-}
-
 export function degreesToRadians(degrees) {
   return (degrees * Math.PI) / 180;
 }

package/src/environment/sensors/rayGuards.js

@@ -1,11 +1,5 @@
 import { metersToSimUnits } from '../../simulation/units.js';
 
-export function canUseLocalStripRayApproximation(track, state) {
-  if (!track || !state || state.inPitLane) return false;
-  const kerbOuter = track.width / 2 + (track.kerbWidth ?? 0);
-  return Number.isFinite(state.crossTrackError) && state.crossTrackError <= kerbOuter;
-}
-
 export function canUseIndexedRecoveryRayApproximation(track, state) {
   if (!track || !state || state.inPitLane) return false;
   const recoveryBand = track.width / 2 +

package/src/environment/sensors/rayOutputs.js

@@ -0,0 +1,75 @@
+import { createSurfaceMiss } from './surfaceRays.js';
+
+export function writeRichRay(target, ray, angleRadians, roadEdge, carHit, surfaceHits, channels) {
+  target.id = ray.id;
+  target.angleDegrees = ray.angleDegrees;
+  target.angleRadians = angleRadians;
+  target.lengthMeters = ray.lengthMeters;
+  target.roadEdge = writeTrackRayHit(target.roadEdge ?? {}, roadEdge);
+  target.track = target.roadEdge;
+  target.kerb = channels.hasKerb
+    ? writeSurfaceRayHit(target.kerb ?? {}, surfaceHits.kerb ?? createSurfaceMiss(ray.lengthMeters))
+    : writeSurfaceRayHit(target.kerb ?? {}, createSurfaceMiss(ray.lengthMeters));
+  target.illegalSurface = channels.hasIllegalSurface
+    ? writeSurfaceRayHit(target.illegalSurface ?? {}, surfaceHits.illegalSurface ?? createSurfaceMiss(ray.lengthMeters))
+    : writeSurfaceRayHit(target.illegalSurface ?? {}, createSurfaceMiss(ray.lengthMeters));
+  target.car = writeCarRayHit(target.car ?? {}, carHit);
+  return target;
+}
+
+function writeTrackRayHit(target, source) {
+  target.hit = Boolean(source?.hit);
+  target.distanceMeters = source?.distanceMeters;
+  target.kind = source?.kind ?? null;
+  return target;
+}
+
+function writeSurfaceRayHit(target, source) {
+  target.hit = Boolean(source?.hit);
+  target.distanceMeters = source?.distanceMeters;
+  target.surface = source?.surface ?? null;
+  return target;
+}
+
+function writeCarRayHit(target, source) {
+  target.hit = Boolean(source?.hit);
+  target.distanceMeters = source?.distanceMeters;
+  target.driverId = source?.driverId ?? null;
+  target.targetId = source?.targetId ?? null;
+  target.targetType = source?.targetType ?? null;
+  target.relativeSpeedKph = source?.relativeSpeedKph ?? 0;
+  return target;
+}
+
+export function writeRayVectorValues(values, lengthMeters, roadEdge, carHit, surfaceHits, surfaceChannels) {
+  values.length = 0;
+  appendRayVectorValues(values, lengthMeters, roadEdge, carHit, surfaceHits, surfaceChannels);
+  return values;
+}
+
+export function appendRayVectorValues(values, lengthMeters, roadEdge, carHit, surfaceHits, surfaceChannels) {
+  values.push(
+    ratio(roadEdge.distanceMeters, lengthMeters),
+    roadEdge.hit ? 1 : 0,
+    roadEdge.kind === 'exit' ? 1 : 0,
+    roadEdge.kind === 'entry' ? 1 : 0,
+    ratio(carHit.distanceMeters, lengthMeters),
+    carHit.hit ? 1 : 0,
+    carHit.relativeSpeedKph / 200,
+    carHit.targetType === 'replayGhost' ? 1 : 0,
+  );
+  for (let index = 0; index < surfaceChannels.length; index += 1) {
+    const channel = surfaceChannels[index];
+    const hit = surfaceHits[channel] ?? createSurfaceMiss(lengthMeters);
+    values.push(
+      ratio(hit.distanceMeters, lengthMeters),
+      hit.hit ? 1 : 0,
+    );
+  }
+  return values;
+}
+
+function ratio(value, max) {
+  const finite = Number.isFinite(value) ? value : max;
+  return Math.max(0, Math.min(1, finite / Math.max(1e-9, max)));
+}

package/src/environment/sensors/rayQuery.js

@@ -0,0 +1,110 @@
+import { estimateCarHit } from './carRays.js';
+import { createTrackMiss, estimateTrackHit } from './trackRays.js';
+import { estimateSurfaceHits } from './surfaceRays.js';
+import { traceIndexedRayBands } from './rayBandTrace.js';
+import { createRayChannelFlags, writeRayChannelFlags } from './rayChannels.js';
+import { getCarRayStats, getRayBandTraceStats } from './rayScratch.js';
+import { MODEL_RAY_SURFACE_CHANNELS } from '../observationSchema.js';
+import { pitOverrideAllowedForCar } from '../../simulation/track/trackStatePolicy.js';
+
+const CHANNEL_CONTEXT = Symbol('rayChannelContext');
+
+export function estimateCarHitForRay(car, snapshot, ray, origin, vector, carTargets, sharedRayQuery, scratch) {
+  return estimateCarHit(car, snapshot, ray.angleDegrees, ray.lengthMeters, origin, carTargets, {
+    rayVector: vector,
+    resultTarget: sharedRayQuery?.carHitResult,
+    stats: getCarRayStats(scratch),
+  });
+}
+
+export function createRayChannelContext(normalized) {
+  if (normalized?.[CHANNEL_CONTEXT]) return normalized[CHANNEL_CONTEXT];
+  const channels = writeRayChannelFlags(createRayChannelFlags(), normalized.channels);
+  const context = {
+    channels,
+    surfaceChannels: MODEL_RAY_SURFACE_CHANNELS.filter((channel) => channels.has(channel)),
+    hasRoadEdge: channels.hasRoadEdge,
+    hasCar: channels.hasCar,
+    hasRoadOrSurface: channels.hasRoadEdge || channels.surfaceChannels.length > 0,
+  };
+  if (normalized) {
+    Object.defineProperty(normalized, CHANNEL_CONTEXT, {
+      value: context,
+      enumerable: false,
+    });
+  }
+  return context;
+}
+
+export function estimateRayBands({
+  car,
+  snapshot,
+  ray,
+  angleDegrees,
+  origin,
+  vector,
+  normalized,
+  channelContext,
+  trackContext,
+  sharedRayQuery,
+  scratch,
+}) {
+  const stats = getRayBandTraceStats(scratch);
+  const canUseRayBandTrace = channelContext.hasRoadOrSurface &&
+    trackContext?.originState;
+  if (canUseRayBandTrace) {
+    const direct = traceIndexedRayBands({
+      track: snapshot.track,
+      origin,
+      vector,
+      lengthMeters: ray.lengthMeters,
+      originState: trackContext.originState,
+      channels: channelContext.channels,
+      precision: normalized.precision,
+      sharedRayQuery,
+      stats,
+      validateBoundaries: car?.interaction?.profile !== 'batch-training',
+      allowPitOverride: car?.interaction?.profile === 'batch-training'
+        ? false
+        : pitOverrideAllowedForCar(car),
+      mainTrackOnly: car?.interaction?.profile === 'batch-training',
+    });
+    if (direct.available) {
+      if (stats) {
+        if (direct.path === 'sampled') stats.sampledPathCount += 1;
+        else stats.directPathCount += 1;
+      }
+      return {
+        roadEdge: direct.roadEdge,
+        surfaceHits: {
+          kerb: direct.kerb,
+          illegalSurface: direct.illegalSurface,
+        },
+      };
+    }
+    if (stats) stats.fallbackCount += 1;
+  }
+
+  return {
+    roadEdge: channelContext.hasRoadEdge
+      ? estimateTrackHit(
+        car,
+        snapshot,
+        angleDegrees,
+        ray.lengthMeters,
+        trackContext,
+        { precision: normalized.precision, sharedRayQuery },
+      )
+      : createTrackMiss(ray.lengthMeters),
+    surfaceHits: estimateSurfaceHits(
+      car,
+      snapshot,
+      ray,
+      origin,
+      vector,
+      channelContext.surfaceChannels,
+      trackContext,
+      { precision: normalized.precision, sharedRayQuery },
+    ),
+  };
+}

package/src/environment/sensors/rayScratch.js

@@ -0,0 +1,146 @@
+import { normalizeRayOptions } from './rayConfig.js';
+import { getCarRayOrigin } from './rayGeometry.js';
+import { isSelfCarTarget, rayDetectableTargetsForSnapshot } from './sensorTargets.js';
+
+export function createRayBatchContext(snapshot, { scratch = false } = {}) {
+  const contextScratch = scratch === true
+    ? {}
+    : scratch && typeof scratch === 'object'
+      ? scratch
+      : null;
+  const context = {
+    rayTargets: rayDetectableTargetsForSnapshot(snapshot, contextScratch),
+  };
+  if (contextScratch) context.scratch = contextScratch;
+  return context;
+}
+
+export function getRayScratch(batchContext) {
+  return batchContext?.scratch ?? null;
+}
+
+export function getNormalizedRayOptions(rayOptions, scratch) {
+  if (!scratch || !rayOptions || typeof rayOptions !== 'object') return normalizeRayOptions(rayOptions);
+  if (rayOptions?.rays && rayOptions?.channels && rayOptions?.anglesDegrees) {
+    return normalizeRayOptions(rayOptions);
+  }
+  const cache = scratch.normalizedRayOptionsBySource ?? new WeakMap();
+  scratch.normalizedRayOptionsBySource = cache;
+  const cached = cache.get(rayOptions);
+  if (cached) return cached;
+  const normalized = normalizeRayOptions(rayOptions);
+  cache.set(rayOptions, normalized);
+  return normalized;
+}
+
+export function getRayOrigin(car, scratch) {
+  if (!scratch) return getCarRayOrigin(car);
+  const origin = scratch.origin ?? {};
+  scratch.origin = origin;
+  origin.x = car.x;
+  origin.y = car.y;
+  return origin;
+}
+
+export function getFilteredCarTargets(car, snapshot, batchContext, scratch) {
+  const targets = batchContext?.rayTargets ?? rayDetectableTargetsForSnapshot(snapshot);
+  if (!scratch) return targets.filter((target) => !isSelfCarTarget(car, target));
+  const filtered = scratch.carTargets ?? [];
+  scratch.carTargets = filtered;
+  let count = 0;
+  for (let index = 0; index < targets.length; index += 1) {
+    const target = targets[index];
+    if (isSelfCarTarget(car, target)) continue;
+    filtered[count] = target;
+    count += 1;
+  }
+  filtered.length = count;
+  return filtered;
+}
+
+export function prepareScratchArray(scratch, arrayKey, poolKey, count, createItem) {
+  if (!scratch) return null;
+  const values = scratch[arrayKey] ?? [];
+  const pool = scratch[poolKey] ?? [];
+  scratch[arrayKey] = values;
+  scratch[poolKey] = pool;
+  values.length = count;
+  for (let index = 0; index < count; index += 1) {
+    const item = pool[index] ?? createItem();
+    pool[index] = item;
+    values[index] = item;
+  }
+  return values;
+}
+
+export function getScratchRayVector(scratch, index, car, angleRadians) {
+  if (!scratch) {
+    return {
+      x: Math.cos((car.heading ?? 0) + angleRadians),
+      y: Math.sin((car.heading ?? 0) + angleRadians),
+    };
+  }
+  const vectors = scratch.rayVectors ?? [];
+  scratch.rayVectors = vectors;
+  const vector = vectors[index] ?? {};
+  vectors[index] = vector;
+  vector.x = Math.cos((car.heading ?? 0) + angleRadians);
+  vector.y = Math.sin((car.heading ?? 0) + angleRadians);
+  return vector;
+}
+
+export function getSharedRayQuery(scratch, index) {
+  if (!scratch) return {};
+  const queries = scratch.sharedRayQueries ?? [];
+  scratch.sharedRayQueries = queries;
+  const query = queries[index] ?? {};
+  queries[index] = query;
+  query.carHitResult = query.carHitResult ?? {};
+  query.surfaceBoundaries = null;
+  query.trackBandBoundaries = null;
+  query.boundaryStateCache = null;
+  query.sampleStateCache = null;
+  return query;
+}
+
+export function getCarRayStats(scratch) {
+  if (!scratch) return null;
+  const stats = scratch.carRayStats ?? {
+    callerVectorCount: 0,
+    computedVectorCount: 0,
+    resultTargetCount: 0,
+  };
+  scratch.carRayStats = stats;
+  return stats;
+}
+
+export function getRayBandTraceStats(scratch) {
+  if (!scratch) return null;
+  const stats = scratch.rayBandTraceStats ?? {
+    directPathCount: 0,
+    sampledPathCount: 0,
+    fallbackCount: 0,
+    channelSetAllocations: 0,
+  };
+  scratch.rayBandTraceStats = stats;
+  return stats;
+}
+
+export function clearRayBatchContextScratch(scratch) {
+  if (!scratch) return;
+  const arrayKeys = [
+    'rayTargets',
+    'rayTargetPool',
+    'carTargets',
+    'rayVectors',
+    'sharedRayQueries',
+    'rays',
+    'rayPool',
+    'rayVectorValues',
+    'rayVectorValuePool',
+  ];
+  for (let index = 0; index < arrayKeys.length; index += 1) {
+    const value = scratch[arrayKeys[index]];
+    if (Array.isArray(value)) value.length = 0;
+  }
+}

package/src/environment/sensors/sensorTargets.js

@@ -10,10 +10,6 @@ export function rayDetectableTargets(self, snapshot) {
   return rayDetectableTargetsForSnapshot(snapshot).filter((target) => !isSelfCarTarget(self, target));
 }
 
-export function nearbyDetectableTargets(self, snapshot) {
-  return nearbyDetectableTargetsForSnapshot(snapshot).filter((target) => !isSelfCarTarget(self, target));
-}
-
 export function rayDetectableTargetsForSnapshot(snapshot, scratch = null) {
   if (scratch) {
     return writeRayDetectableTargetsForSnapshot(snapshot, scratch);
@@ -31,6 +27,18 @@ export function nearbyDetectableTargetsForSnapshot(snapshot) {
   ];
 }
 
+// Shared only within one observation build, so mutable snapshots cannot leave
+// stale positions, detectability flags, or replay entities in a later result.
+export function createNearbyBatchContext(snapshot) {
+  const targetsById = new Map();
+  for (const car of snapshot.cars ?? []) targetsById.set(`car:${car.id}`, car);
+  for (const ghost of snapshot.replayGhosts ?? []) targetsById.set(`replayGhost:${ghost.id}`, ghost);
+  return {
+    nearbyTargets: nearbyDetectableTargetsForSnapshot(snapshot),
+    targetsById,
+  };
+}
+
 function detectableCars(snapshot, predicate) {
   return (snapshot.cars ?? [])
     .filter((car) => predicate(car))