@inventure71/paddockjs 1.0.0 → 2.0.0

package/src/environment/sensors/index.js

@@ -0,0 +1,157 @@
+import { createCarRayMiss, estimateCarHit } from './carRays.js';
+import { normalizeRayOptions } from './rayConfig.js';
+import { degreesToRadians, getCarRayOrigin } from './rayGeometry.js';
+import { rayDetectableTargetsForSnapshot } from './sensorTargets.js';
+import { createTrackMiss, createTrackRayContext, estimateTrackHit } from './trackRays.js';
+import { createSurfaceMiss, estimateSurfaceHits, requestedSurfaceChannels } from './surfaceRays.js';
+import { canUseBatchTrainingRayApproximation } from './rayGuards.js';
+
+export { buildNearbyCars } from './nearbyCars.js';
+export { DEFAULT_RAY_ANGLES_DEGREES } from './rayDefaults.js';
+export { normalizeRayOptions, RAY_CHANNELS, RAY_LAYOUT_PRESETS } from './rayConfig.js';
+export { getCarRayOrigin, getCarRayVector } from './rayGeometry.js';
+
+export function createRayBatchContext(snapshot) {
+  return {
+    rayTargets: rayDetectableTargetsForSnapshot(snapshot),
+  };
+}
+
+export function buildRaySensors(car, snapshot, rayOptions = {}, batchContext = null) {
+  const normalized = normalizeRayOptions(rayOptions);
+  if (!normalized.enabled) return [];
+  if (car?.destroyed || car?.outOfRace) {
+    return buildInactiveCarRays(normalized);
+  }
+  const origin = getCarRayOrigin(car);
+  const usesTrackContext = normalized.channels.includes('roadEdge') ||
+    requestedSurfaceChannels(normalized.channels).length > 0;
+  const trackContext = !usesTrackContext
+    ? null
+    : createTrackRayContext(car, snapshot, origin);
+  const carTargets = normalized.channels.includes('car')
+    ? (batchContext?.rayTargets ?? rayDetectableTargetsForSnapshot(snapshot)).filter((target) => target.id !== car.id)
+    : [];
+
+  if (canUseFastBatchTrainingRays(car, snapshot, trackContext)) {
+    return buildFastBatchTrainingRays(car, snapshot, normalized, origin, carTargets, trackContext);
+  }
+
+  return normalized.rays.map((ray) => {
+    const angleDegrees = ray.angleDegrees;
+    const vector = {
+      x: Math.cos((car.heading ?? 0) + degreesToRadians(angleDegrees)),
+      y: Math.sin((car.heading ?? 0) + degreesToRadians(angleDegrees)),
+    };
+    const sharedRayQuery = {};
+    const roadEdge = normalized.channels.includes('roadEdge')
+      ? estimateTrackHit(
+        car,
+        snapshot,
+        angleDegrees,
+        ray.lengthMeters,
+        trackContext,
+        { precision: normalized.precision, sharedRayQuery },
+      )
+      : createTrackMiss(ray.lengthMeters);
+    const carHit = normalized.channels.includes('car')
+      ? estimateCarHit(car, snapshot, angleDegrees, ray.lengthMeters, origin, carTargets)
+      : createCarRayMiss(ray.lengthMeters);
+    const surfaceHits = estimateSurfaceHits(
+      car,
+      snapshot,
+      ray,
+      origin,
+      vector,
+      normalized.channels,
+      trackContext,
+      { precision: normalized.precision, sharedRayQuery },
+    );
+
+    return {
+      id: ray.id,
+      angleDegrees,
+      angleRadians: degreesToRadians(angleDegrees),
+      lengthMeters: ray.lengthMeters,
+      roadEdge,
+      track: roadEdge,
+      kerb: surfaceHits.kerb ?? createSurfaceMiss(ray.lengthMeters),
+      illegalSurface: surfaceHits.illegalSurface ?? createSurfaceMiss(ray.lengthMeters),
+      car: carHit,
+    };
+  });
+}
+
+function buildInactiveCarRays(normalized) {
+  return normalized.rays.map((ray) => ({
+    id: ray.id,
+    angleDegrees: ray.angleDegrees,
+    angleRadians: degreesToRadians(ray.angleDegrees),
+    lengthMeters: ray.lengthMeters,
+    roadEdge: createTrackMiss(ray.lengthMeters),
+    track: createTrackMiss(ray.lengthMeters),
+    kerb: createSurfaceMiss(ray.lengthMeters),
+    illegalSurface: createSurfaceMiss(ray.lengthMeters),
+    car: createCarRayMiss(ray.lengthMeters),
+  }));
+}
+
+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);
+}
+
+function buildFastBatchTrainingRays(car, snapshot, normalized, origin, carTargets, trackContext) {
+  const channels = new Set(normalized.channels);
+
+  return normalized.rays.map((ray) => {
+    const angleRadians = degreesToRadians(ray.angleDegrees);
+    const heading = (car.heading ?? 0) + angleRadians;
+    const vector = { x: Math.cos(heading), y: Math.sin(heading) };
+    const sharedRayQuery = {};
+    const roadEdge = channels.has('roadEdge')
+      ? estimateTrackHit(
+        car,
+        snapshot,
+        ray.angleDegrees,
+        ray.lengthMeters,
+        trackContext,
+        { precision: normalized.precision, sharedRayQuery },
+      )
+      : createTrackMiss(ray.lengthMeters);
+    const carHit = channels.has('car') && carTargets.length > 0
+      ? estimateCarHit(car, snapshot, ray.angleDegrees, ray.lengthMeters, origin, carTargets)
+      : createCarRayMiss(ray.lengthMeters);
+    const surfaceHits = estimateSurfaceHits(
+      car,
+      snapshot,
+      ray,
+      origin,
+      vector,
+      normalized.channels,
+      trackContext,
+      { precision: normalized.precision, sharedRayQuery },
+    );
+
+    return {
+      id: ray.id,
+      angleDegrees: ray.angleDegrees,
+      angleRadians,
+      lengthMeters: ray.lengthMeters,
+      roadEdge,
+      track: roadEdge,
+      kerb: channels.has('kerb')
+        ? (surfaceHits.kerb ?? createSurfaceMiss(ray.lengthMeters))
+        : createSurfaceMiss(ray.lengthMeters),
+      illegalSurface: channels.has('illegalSurface')
+        ? (surfaceHits.illegalSurface ?? createSurfaceMiss(ray.lengthMeters))
+        : createSurfaceMiss(ray.lengthMeters),
+      car: carHit,
+    };
+  });
+}

package/src/environment/sensors/indexedRayBands.js

@@ -0,0 +1,103 @@
+import { queryTrackSegmentsAlongRay } from '../../simulation/track/trackQueryIndex.js';
+import { metersToSimUnits } from '../../simulation/units.js';
+
+const RAY_BOUND_QUERY_MARGIN_METERS = 18;
+
+export function findIndexedRayBoundaryHit(track, origin, vector, lengthMeters, offsets) {
+  const boundaries = findIndexedRayBoundaryDistances(track, origin, vector, lengthMeters, offsets);
+  if (!boundaries.available) return { available: false, distance: null };
+  return {
+    available: true,
+    distance: minFinite(...boundaries.distances),
+  };
+}
+
+export function findIndexedRayBoundaryDistances(track, origin, vector, lengthMeters, offsets) {
+  const finiteOffsets = offsets.filter(Number.isFinite);
+  if (finiteOffsets.length === 0) return { available: true, distances: [] };
+  const maxDistance = metersToSimUnits(lengthMeters);
+  const maxOffset = Math.max(0, ...finiteOffsets.map((offset) => Math.abs(offset)));
+  const margin = maxOffset + metersToSimUnits(RAY_BOUND_QUERY_MARGIN_METERS);
+  const segments = queryTrackSegmentsAlongRay(track, origin, vector, maxDistance, margin);
+  if (!segments) return { available: false, distances: [] };
+  const distances = finiteOffsets.map(() => Infinity);
+
+  for (const segment of segments) {
+    finiteOffsets.forEach((offset, offsetIndex) => {
+      const start = offsetSegmentStart(segment, offset);
+      const finish = offsetSegmentEnd(segment, offset);
+      const distance = raySegmentIntersectionDistance(origin, vector, start, finish, maxDistance);
+      if (distance != null && distance < distances[offsetIndex]) distances[offsetIndex] = distance;
+    });
+  }
+
+  return {
+    available: true,
+    distances: distances.map((distance) => (Number.isFinite(distance) ? distance : null)),
+  };
+}
+
+export function findIndexedTrackBandBoundaries(
+  track,
+  origin,
+  vector,
+  lengthMeters,
+  trackHalfWidth,
+  kerbOuterWidth,
+  cache = null,
+) {
+  if (cache?.trackBandBoundaries) return cache.trackBandBoundaries;
+  const boundaries = findIndexedRayBoundaryDistances(
+    track,
+    origin,
+    vector,
+    lengthMeters,
+    [trackHalfWidth, -trackHalfWidth, kerbOuterWidth, -kerbOuterWidth],
+  );
+  const result = {
+    available: boundaries.available,
+    trackEdgeDistance: minFinite(boundaries.distances[0], boundaries.distances[1]),
+    kerbOuterDistance: minFinite(boundaries.distances[2], boundaries.distances[3]),
+  };
+  if (cache) cache.trackBandBoundaries = result;
+  return result;
+}
+
+function offsetSegmentStart(segment, offset) {
+  return {
+    x: segment.startX + segment.normalX * offset,
+    y: segment.startY + segment.normalY * offset,
+  };
+}
+
+function offsetSegmentEnd(segment, offset) {
+  return {
+    x: segment.endX + segment.endNormalX * offset,
+    y: segment.endY + segment.endNormalY * offset,
+  };
+}
+
+function raySegmentIntersectionDistance(origin, ray, start, end, maxDistance) {
+  const sx = end.x - start.x;
+  const sy = end.y - start.y;
+  const denominator = cross(ray.x, ray.y, sx, sy);
+  if (Math.abs(denominator) < 1e-9) return null;
+
+  const ox = start.x - origin.x;
+  const oy = start.y - origin.y;
+  const rayDistance = cross(ox, oy, sx, sy) / denominator;
+  const segmentAmount = cross(ox, oy, ray.x, ray.y) / denominator;
+
+  if (rayDistance < 0 || rayDistance > maxDistance) return null;
+  if (segmentAmount < -1e-6 || segmentAmount > 1 + 1e-6) return null;
+  return rayDistance;
+}
+
+function cross(ax, ay, bx, by) {
+  return ax * by - ay * bx;
+}
+
+function minFinite(...values) {
+  const minimum = Math.min(...values.filter((value) => Number.isFinite(value)));
+  return Number.isFinite(minimum) ? minimum : null;
+}

package/src/environment/sensors/nearbyCars.js

@@ -0,0 +1,52 @@
+import { metersToSimUnits, simUnitsToMeters } from '../../simulation/units.js';
+import { normalizeRelativeHeading } from './rayGeometry.js';
+import { nearbyDetectableTargets } from './sensorTargets.js';
+
+export function buildNearbyCars(car, snapshot, { maxCars = 6, radiusMeters = 150 } = {}) {
+  const limit = Math.max(0, Math.floor(maxCars));
+  if (limit === 0) return [];
+  const radius = metersToSimUnits(radiusMeters);
+  const radiusSquared = radius * radius;
+  const forwardX = Math.cos(car.heading);
+  const forwardY = Math.sin(car.heading);
+  const rightX = -Math.sin(car.heading);
+  const rightY = Math.cos(car.heading);
+  const nearest = [];
+
+  nearbyDetectableTargets(car, snapshot).forEach((other) => {
+    const dx = other.x - car.x;
+    const dy = other.y - car.y;
+    const distanceSquared = dx * dx + dy * dy;
+    if (distanceSquared > radiusSquared) return;
+
+    const forward = forwardX * dx + forwardY * dy;
+    const right = rightX * dx + rightY * dy;
+    const entry = {
+      id: other.id,
+      relativeForwardMeters: simUnitsToMeters(forward),
+      relativeRightMeters: simUnitsToMeters(right),
+      relativeDistanceMeters: simUnitsToMeters(Math.sqrt(distanceSquared)),
+      relativeSpeedKph: other.speedKph - car.speedKph,
+      relativeHeadingRadians: normalizeRelativeHeading(other.heading - car.heading),
+      ahead: forward > 0,
+      sameLap: other.lap != null && other.lap === car.lap,
+      entityType: other.entityType,
+      distanceSquared,
+      order: other.order,
+    };
+    insertNearestCar(nearest, entry, limit);
+  });
+
+  return nearest.map(({ distanceSquared, order, ...entry }) => entry);
+}
+
+function insertNearestCar(nearest, entry, limit) {
+  let insertAt = nearest.findIndex((candidate) => (
+    entry.distanceSquared < candidate.distanceSquared ||
+    (entry.distanceSquared === candidate.distanceSquared && entry.order < candidate.order)
+  ));
+  if (insertAt < 0) insertAt = nearest.length;
+  if (insertAt >= limit) return;
+  nearest.splice(insertAt, 0, entry);
+  if (nearest.length > limit) nearest.pop();
+}

package/src/environment/sensors/opponentRadar.js

@@ -0,0 +1,65 @@
+import { kphToSimSpeed, simSpeedToMetersPerSecond, simUnitsToMeters } from '../../simulation/units.js';
+import { VEHICLE_GEOMETRY } from '../../simulation/vehicle/vehicleGeometry.js';
+
+export function enrichOpponentRadar(car, nearbyCars, snapshot) {
+  const targetsById = new Map([
+    ...(snapshot.cars ?? []).map((entry) => [entry.id, entry]),
+    ...(snapshot.replayGhosts ?? []).map((entry) => [entry.id, entry]),
+  ]);
+
+  return nearbyCars.map((nearby) => {
+    const target = targetsById.get(nearby.id);
+    const derived = target ? deriveRadarFields(car, target, nearby) : fallbackRadarFields(nearby);
+    return {
+      ...nearby,
+      ...derived,
+    };
+  });
+}
+
+function deriveRadarFields(car, target, nearby) {
+  const dx = (target.x ?? 0) - (car.x ?? 0);
+  const dy = (target.y ?? 0) - (car.y ?? 0);
+  const distance = Math.max(1e-9, Math.hypot(dx, dy));
+  const selfVelocity = velocity(car);
+  const targetVelocity = velocity(target);
+  const relativeVelocity = {
+    x: targetVelocity.x - selfVelocity.x,
+    y: targetVelocity.y - selfVelocity.y,
+  };
+  const closingRate = -((relativeVelocity.x * dx + relativeVelocity.y * dy) / distance);
+  const closingRateMetersPerSecond = simSpeedToMetersPerSecond(closingRate);
+  const distanceMeters = nearby.relativeDistanceMeters ?? simUnitsToMeters(distance);
+  const longitudinalOverlap = Math.abs(nearby.relativeForwardMeters ?? 0) <= simUnitsToMeters(VEHICLE_GEOMETRY.bodyLength);
+  const lateralOverlap = Math.abs(nearby.relativeRightMeters ?? 0) <= simUnitsToMeters(VEHICLE_GEOMETRY.bodyWidth);
+  const sideOverlap = longitudinalOverlap && lateralOverlap;
+
+  return {
+    behind: !nearby.ahead,
+    closingRateMetersPerSecond,
+    timeToContactSeconds: closingRateMetersPerSecond > 0
+      ? distanceMeters / closingRateMetersPerSecond
+      : null,
+    leftOverlap: sideOverlap && (nearby.relativeRightMeters ?? 0) < 0,
+    rightOverlap: sideOverlap && (nearby.relativeRightMeters ?? 0) > 0,
+  };
+}
+
+function fallbackRadarFields(nearby) {
+  return {
+    behind: !nearby.ahead,
+    closingRateMetersPerSecond: 0,
+    timeToContactSeconds: null,
+    leftOverlap: false,
+    rightOverlap: false,
+  };
+}
+
+function velocity(car) {
+  const speed = Number.isFinite(car.speed) ? car.speed : kphToSimSpeed(car.speedKph ?? 0);
+  const heading = car.heading ?? car.headingRadians ?? 0;
+  return {
+    x: Math.cos(heading) * speed,
+    y: Math.sin(heading) * speed,
+  };
+}

package/src/environment/sensors/rayConfig.js

@@ -0,0 +1,110 @@
+import { DEFAULT_RAY_ANGLES_DEGREES } from './rayDefaults.js';
+
+export const DEFAULT_RAY_LENGTH_METERS = 120;
+
+export const RAY_CHANNELS = Object.freeze([
+  'roadEdge',
+  'kerb',
+  'illegalSurface',
+  'car',
+]);
+
+export const RAY_PRECISION_MODES = Object.freeze(['driver', 'debug']);
+
+export const RAY_LAYOUT_PRESETS = Object.freeze({
+  compact: DEFAULT_RAY_ANGLES_DEGREES.map((angleDegrees) => ({ angleDegrees })),
+  'driver-front-heavy': [
+    -140, -100, -70, -50, -35, -20, -10, 0, 10, 20, 35, 50, 70, 100, 140, 180,
+  ].map((angleDegrees) => ({
+    angleDegrees,
+    lengthMeters: Math.abs(angleDegrees) <= 70 ? 240 : Math.abs(angleDegrees) <= 100 ? 90 : 60,
+  })),
+  'lidar-lite': Array.from({ length: 25 }, (_, index) => ({
+    angleDegrees: -120 + index * 10,
+    lengthMeters: Math.abs(-120 + index * 10) <= 70 ? 260 : 100,
+  })),
+});
+
+export function normalizeRayOptions(rayOptions = {}) {
+  const defaultLengthMeters = positiveNumber(
+    rayOptions.defaultLengthMeters ?? rayOptions.lengthMeters,
+    DEFAULT_RAY_LENGTH_METERS,
+  );
+  const rays = normalizeRays(rayOptions, defaultLengthMeters);
+  const channels = normalizeRayChannels(rayOptions);
+  const precision = RAY_PRECISION_MODES.includes(rayOptions.precision) ? rayOptions.precision : 'driver';
+  const anglesDegrees = rays.map((ray) => ray.angleDegrees);
+  const lengthMeters = rays.length ? Math.max(...rays.map((ray) => ray.lengthMeters)) : defaultLengthMeters;
+
+  return {
+    ...rayOptions,
+    enabled: rayOptions.enabled !== false,
+    anglesDegrees,
+    lengthMeters,
+    defaultLengthMeters,
+    rays,
+    channels,
+    precision,
+    detectTrack: channels.includes('roadEdge'),
+    detectCars: channels.includes('car'),
+  };
+}
+
+function normalizeRays(rayOptions, defaultLengthMeters) {
+  const configuredRays = Array.isArray(rayOptions.rays)
+    ? rayOptions.rays
+    : resolvePresetRays(rayOptions.layout);
+  const source = configuredRays.length
+    ? configuredRays
+    : normalizeAngles(rayOptions.anglesDegrees).map((angleDegrees) => ({ angleDegrees }));
+
+  return source.map((ray, index) => {
+    const angleDegrees = finiteNumber(
+      typeof ray === 'number' ? ray : ray?.angleDegrees,
+      DEFAULT_RAY_ANGLES_DEGREES[index % DEFAULT_RAY_ANGLES_DEGREES.length],
+    );
+    const lengthMeters = positiveNumber(
+      typeof ray === 'object' ? ray.lengthMeters : null,
+      defaultLengthMeters,
+    );
+    return {
+      id: typeof ray === 'object' && ray.id ? String(ray.id) : `ray-${index}`,
+      angleDegrees,
+      lengthMeters,
+    };
+  });
+}
+
+function resolvePresetRays(layout) {
+  if (typeof layout !== 'string') return [];
+  return RAY_LAYOUT_PRESETS[layout] ?? [];
+}
+
+function normalizeAngles(value) {
+  if (!Array.isArray(value) || value.length === 0) return [...DEFAULT_RAY_ANGLES_DEGREES];
+  const angles = value.map((angle) => Number(angle)).filter((angle) => Number.isFinite(angle));
+  return angles.length ? angles : [...DEFAULT_RAY_ANGLES_DEGREES];
+}
+
+function normalizeRayChannels(rayOptions) {
+  if (Array.isArray(rayOptions.channels) && rayOptions.channels.length) {
+    const channelSet = new Set(RAY_CHANNELS);
+    const channels = rayOptions.channels.filter((channel) => channelSet.has(channel));
+    if (channels.length) return [...new Set(channels)];
+  }
+
+  const channels = [];
+  if (rayOptions.detectTrack !== false) channels.push('roadEdge');
+  if (rayOptions.detectCars !== false) channels.push('car');
+  return channels;
+}
+
+function positiveNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+
+function finiteNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}

package/src/environment/sensors/rayDefaults.js

@@ -0,0 +1,6 @@
+export const TRACK_RAY_STEP_METERS = 1;
+export const TRACK_RAY_REFINE_STEPS = 12;
+export const DRIVER_RAY_REFINE_STEPS = 0;
+export const ANALYTIC_TRACK_RAY_MAX_CURVATURE = 0.00005;
+export const PIT_CONNECTOR_RAY_FALLBACK_METERS = 55;
+export const DEFAULT_RAY_ANGLES_DEGREES = [-135, -60, -20, 0, 20, 60, 135, 180];

package/src/environment/sensors/rayGeometry.js

@@ -0,0 +1,60 @@
+export function getCarRayOrigin(car) {
+  return {
+    x: car.x,
+    y: car.y,
+  };
+}
+
+export function getCarRayVector(car, angleDegrees) {
+  const angle = car.heading + degreesToRadians(angleDegrees);
+  return {
+    x: Math.cos(angle),
+    y: Math.sin(angle),
+  };
+}
+
+export function pointOnRay(origin, ray, distance) {
+  return {
+    x: origin.x + ray.x * distance,
+    y: origin.y + ray.y * distance,
+  };
+}
+
+export function intersectAxisAlignedBoxRay(origin, ray, halfLength, halfWidth) {
+  let tMin = -Infinity;
+  let tMax = Infinity;
+  const xRange = intersectSlab(origin.x, ray.x, -halfLength, halfLength);
+  const yRange = intersectSlab(origin.y, ray.y, -halfWidth, halfWidth);
+  if (!xRange || !yRange) return null;
+  tMin = Math.max(tMin, xRange.min, yRange.min);
+  tMax = Math.min(tMax, xRange.max, yRange.max);
+  if (tMax < 0 || tMin > tMax) return null;
+  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;
+}
+
+export function normalizeRelativeHeading(angle) {
+  let value = angle;
+  while (value > Math.PI) value -= Math.PI * 2;
+  while (value < -Math.PI) value += Math.PI * 2;
+  return value;
+}
+
+function intersectSlab(origin, direction, min, max) {
+  if (Math.abs(direction) < 1e-9) {
+    return origin >= min && origin <= max ? { min: -Infinity, max: Infinity } : null;
+  }
+  const first = (min - origin) / direction;
+  const second = (max - origin) / direction;
+  return {
+    min: Math.min(first, second),
+    max: Math.max(first, second),
+  };
+}

package/src/environment/sensors/rayGuards.js

@@ -0,0 +1,19 @@
+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 +
+    (track.kerbWidth ?? 0) +
+    (track.gravelWidth ?? 0) +
+    (track.runoffWidth ?? 0) +
+    metersToSimUnits(64);
+  return Number.isFinite(state.crossTrackError) && state.crossTrackError <= recoveryBand;
+}
+
+export const canUseBatchTrainingRayApproximation = canUseIndexedRecoveryRayApproximation;

package/src/environment/sensors/sensorTargets.js

@@ -0,0 +1,60 @@
+import {
+  isNearbyDetectable,
+  isRayDetectable,
+} from '../../simulation/participants/participantInteractions.js';
+
+export const SENSOR_TARGET_CAR = 'car';
+export const SENSOR_TARGET_REPLAY_GHOST = 'replayGhost';
+
+export function rayDetectableTargets(self, snapshot) {
+  return rayDetectableTargetsForSnapshot(snapshot).filter((target) => target.id !== self.id);
+}
+
+export function nearbyDetectableTargets(self, snapshot) {
+  return nearbyDetectableTargetsForSnapshot(snapshot).filter((target) => target.id !== self.id);
+}
+
+export function rayDetectableTargetsForSnapshot(snapshot) {
+  return [
+    ...detectableCars(snapshot, isRayDetectable),
+    ...detectableReplayGhosts(snapshot, 'detectableByRays'),
+  ];
+}
+
+export function nearbyDetectableTargetsForSnapshot(snapshot) {
+  return [
+    ...detectableCars(snapshot, isNearbyDetectable),
+    ...detectableReplayGhosts(snapshot, 'detectableAsNearby'),
+  ];
+}
+
+function detectableCars(snapshot, predicate) {
+  return (snapshot.cars ?? [])
+    .filter((car) => predicate(car))
+    .map((car, order) => ({
+      entityType: SENSOR_TARGET_CAR,
+      id: car.id,
+      x: car.x,
+      y: car.y,
+      heading: car.heading,
+      speedKph: car.speedKph ?? 0,
+      lap: car.lap,
+      order,
+    }));
+}
+
+function detectableReplayGhosts(snapshot, sensorFlag) {
+  const carCount = snapshot.cars?.length ?? 0;
+  return (snapshot.replayGhosts ?? [])
+    .filter((ghost) => ghost.sensors?.[sensorFlag] === true)
+    .map((ghost, index) => ({
+      entityType: SENSOR_TARGET_REPLAY_GHOST,
+      id: ghost.id,
+      x: ghost.x,
+      y: ghost.y,
+      heading: ghost.heading,
+      speedKph: ghost.speedKph ?? 0,
+      lap: null,
+      order: carCount + index,
+    }));
+}