@inventure71/paddockjs 2.0.1 → 4.0.0

package/src/environment/sensors/rayChannels.js

@@ -0,0 +1,108 @@
+const RAY_CHANNEL_FLAGS = Symbol('rayChannelFlags');
+
+export const RAY_CHANNELS = Object.freeze([
+  'roadEdge',
+  'kerb',
+  'illegalSurface',
+  'car',
+]);
+
+export function createRayChannelFlags() {
+  const flags = {
+    hasRoadEdge: false,
+    hasKerb: false,
+    hasIllegalSurface: false,
+    hasCar: false,
+    surfaceChannels: [],
+    has: channelFlagsHas,
+  };
+  Object.defineProperty(flags, RAY_CHANNEL_FLAGS, {
+    value: true,
+    enumerable: false,
+  });
+  return flags;
+}
+
+export function writeRayChannelFlags(target = createRayChannelFlags(), channels = []) {
+  ensureRayChannelFlags(target);
+  target.hasRoadEdge = false;
+  target.hasKerb = false;
+  target.hasIllegalSurface = false;
+  target.hasCar = false;
+  target.surfaceChannels.length = 0;
+
+  if (isRayChannelFlags(channels)) {
+    if (channels.hasRoadEdge) target.hasRoadEdge = true;
+    if (channels.hasKerb) {
+      target.hasKerb = true;
+      target.surfaceChannels.push('kerb');
+    }
+    if (channels.hasIllegalSurface) {
+      target.hasIllegalSurface = true;
+      target.surfaceChannels.push('illegalSurface');
+    }
+    if (channels.hasCar) target.hasCar = true;
+    return target;
+  }
+
+  if (Array.isArray(channels)) {
+    for (let index = 0; index < channels.length; index += 1) {
+      enableRayChannel(target, channels[index]);
+    }
+    return target;
+  }
+
+  if (channels && typeof channels.has === 'function') {
+    for (let index = 0; index < RAY_CHANNELS.length; index += 1) {
+      const channel = RAY_CHANNELS[index];
+      if (channels.has(channel)) enableRayChannel(target, channel);
+    }
+  }
+  return target;
+}
+
+export function isLegalRaySurface(surface) {
+  return surface === 'track' ||
+    surface === 'kerb' ||
+    surface === 'pit-entry' ||
+    surface === 'pit-lane' ||
+    surface === 'pit-exit' ||
+    surface === 'pit-box';
+}
+
+function ensureRayChannelFlags(target) {
+  if (!target.surfaceChannels) target.surfaceChannels = [];
+  target.has = channelFlagsHas;
+  if (!isRayChannelFlags(target)) {
+    Object.defineProperty(target, RAY_CHANNEL_FLAGS, {
+      value: true,
+      enumerable: false,
+    });
+  }
+}
+
+function isRayChannelFlags(value) {
+  return Boolean(value?.[RAY_CHANNEL_FLAGS]);
+}
+
+function enableRayChannel(target, channel) {
+  if (channel === 'roadEdge') {
+    target.hasRoadEdge = true;
+  } else if (channel === 'kerb') {
+    if (!target.hasKerb) target.surfaceChannels.push('kerb');
+    target.hasKerb = true;
+  } else if (channel === 'illegalSurface') {
+    if (!target.hasIllegalSurface) target.surfaceChannels.push('illegalSurface');
+    target.hasIllegalSurface = true;
+  } else if (channel === 'car') {
+    target.hasCar = true;
+  }
+}
+
+function channelFlagsHas(channel) {
+  if (channel === 'roadEdge') return this.hasRoadEdge;
+  if (channel === 'kerb') return this.hasKerb;
+  if (channel === 'illegalSurface') return this.hasIllegalSurface;
+  if (channel === 'car') return this.hasCar;
+  return false;
+}

package/src/environment/sensors/rayConfig.js

@@ -1,13 +1,11 @@
 import { DEFAULT_RAY_ANGLES_DEGREES } from './rayDefaults.js';
+import { RAY_CHANNELS } from './rayChannels.js';
 
-export const DEFAULT_RAY_LENGTH_METERS = 120;
+const NORMALIZED_RAY_OPTIONS = Symbol('normalizedRayOptions');
+
+export { RAY_CHANNELS } from './rayChannels.js';
 
-export const RAY_CHANNELS = Object.freeze([
-  'roadEdge',
-  'kerb',
-  'illegalSurface',
-  'car',
-]);
+export const DEFAULT_RAY_LENGTH_METERS = 120;
 
 export const RAY_PRECISION_MODES = Object.freeze(['driver', 'debug']);
 
@@ -26,6 +24,7 @@ export const RAY_LAYOUT_PRESETS = Object.freeze({
 });
 
 export function normalizeRayOptions(rayOptions = {}) {
+  if (rayOptions?.[NORMALIZED_RAY_OPTIONS]) return rayOptions;
   const defaultLengthMeters = positiveNumber(
     rayOptions.defaultLengthMeters ?? rayOptions.lengthMeters,
     DEFAULT_RAY_LENGTH_METERS,
@@ -33,10 +32,22 @@ export function normalizeRayOptions(rayOptions = {}) {
   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;
+  const anglesDegrees = new Array(rays.length);
+  let lengthMeters = rays.length ? 0 : defaultLengthMeters;
+  for (let index = 0; index < rays.length; index += 1) {
+    const ray = rays[index];
+    anglesDegrees[index] = ray.angleDegrees;
+    if (ray.lengthMeters > lengthMeters) lengthMeters = ray.lengthMeters;
+  }
+  let detectTrack = false;
+  let detectCars = false;
+  for (let index = 0; index < channels.length; index += 1) {
+    const channel = channels[index];
+    if (channel === 'roadEdge') detectTrack = true;
+    else if (channel === 'car') detectCars = true;
+  }
 
-  return {
+  const normalized = {
     ...rayOptions,
     enabled: rayOptions.enabled !== false,
     anglesDegrees,
@@ -45,20 +56,24 @@ export function normalizeRayOptions(rayOptions = {}) {
     rays,
     channels,
     precision,
-    detectTrack: channels.includes('roadEdge'),
-    detectCars: channels.includes('car'),
+    detectTrack,
+    detectCars,
   };
+  Object.defineProperty(normalized, NORMALIZED_RAY_OPTIONS, {
+    value: true,
+    enumerable: false,
+  });
+  return normalized;
 }
 
 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 source = configuredRays.length ? configuredRays : normalizeAngles(rayOptions.anglesDegrees);
+  const rays = new Array(source.length);
+  for (let index = 0; index < source.length; index += 1) {
+    const ray = source[index];
     const angleDegrees = finiteNumber(
       typeof ray === 'number' ? ray : ray?.angleDegrees,
       DEFAULT_RAY_ANGLES_DEGREES[index % DEFAULT_RAY_ANGLES_DEGREES.length],
@@ -67,12 +82,13 @@ function normalizeRays(rayOptions, defaultLengthMeters) {
       typeof ray === 'object' ? ray.lengthMeters : null,
       defaultLengthMeters,
     );
-    return {
+    rays[index] = {
       id: typeof ray === 'object' && ray.id ? String(ray.id) : `ray-${index}`,
       angleDegrees,
       lengthMeters,
     };
-  });
+  }
+  return rays;
 }
 
 function resolvePresetRays(layout) {
@@ -81,16 +97,24 @@ function resolvePresetRays(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];
+  if (!Array.isArray(value) || value.length === 0) return copyDefaultRayAngles();
+  const angles = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const angle = Number(value[index]);
+    if (Number.isFinite(angle)) angles.push(angle);
+  }
+  return angles.length ? angles : copyDefaultRayAngles();
 }
 
 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 = [];
+    for (let index = 0; index < rayOptions.channels.length; index += 1) {
+      const channel = rayOptions.channels[index];
+      if (!isKnownRayChannel(channel) || hasChannel(channels, channel)) continue;
+      channels.push(channel);
+    }
+    if (channels.length) return channels;
   }
 
   const channels = [];
@@ -99,6 +123,28 @@ function normalizeRayChannels(rayOptions) {
   return channels;
 }
 
+function isKnownRayChannel(channel) {
+  for (let index = 0; index < RAY_CHANNELS.length; index += 1) {
+    if (RAY_CHANNELS[index] === channel) return true;
+  }
+  return false;
+}
+
+function hasChannel(channels, channel) {
+  for (let index = 0; index < channels.length; index += 1) {
+    if (channels[index] === channel) return true;
+  }
+  return false;
+}
+
+function copyDefaultRayAngles() {
+  const angles = new Array(DEFAULT_RAY_ANGLES_DEGREES.length);
+  for (let index = 0; index < DEFAULT_RAY_ANGLES_DEGREES.length; index += 1) {
+    angles[index] = DEFAULT_RAY_ANGLES_DEGREES[index];
+  }
+  return angles;
+}
+
 function positiveNumber(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? number : fallback;

package/src/environment/sensors/rayGeometry.js

@@ -21,13 +21,31 @@ 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;
-  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 (Math.abs(rayX) < 1e-9) {
+    if (originX < -halfLength || originX > halfLength) return null;
+  } else {
+    const first = (-halfLength - originX) / rayX;
+    const second = (halfLength - originX) / rayX;
+    tMin = Math.max(tMin, Math.min(first, second));
+    tMax = Math.min(tMax, Math.max(first, second));
+  }
+
+  if (Math.abs(rayY) < 1e-9) {
+    if (originY < -halfWidth || originY > halfWidth) return null;
+  } else {
+    const first = (-halfWidth - originY) / rayY;
+    const second = (halfWidth - originY) / rayY;
+    tMin = Math.max(tMin, Math.min(first, second));
+    tMax = Math.min(tMax, Math.max(first, second));
+  }
+
   if (tMax < 0 || tMin > tMax) return null;
   return Math.max(0, tMin);
 }
@@ -46,15 +64,3 @@ export function normalizeRelativeHeading(angle) {
   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/sensorTargets.js

@@ -14,7 +14,10 @@ export function nearbyDetectableTargets(self, snapshot) {
   return nearbyDetectableTargetsForSnapshot(snapshot).filter((target) => !isSelfCarTarget(self, target));
 }
 
-export function rayDetectableTargetsForSnapshot(snapshot) {
+export function rayDetectableTargetsForSnapshot(snapshot, scratch = null) {
+  if (scratch) {
+    return writeRayDetectableTargetsForSnapshot(snapshot, scratch);
+  }
   return [
     ...detectableCars(snapshot, isRayDetectable),
     ...detectableReplayGhosts(snapshot, 'detectableByRays'),
@@ -45,6 +48,69 @@ function detectableCars(snapshot, predicate) {
     }));
 }
 
+function writeRayDetectableTargetsForSnapshot(snapshot, scratch) {
+  const targets = scratch.rayTargets ?? [];
+  const pool = scratch.rayTargetPool ?? [];
+  scratch.rayTargets = targets;
+  scratch.rayTargetPool = pool;
+  let count = 0;
+  let carOrder = 0;
+  const cars = snapshot.cars ?? [];
+  for (let index = 0; index < cars.length; index += 1) {
+    const car = cars[index];
+    if (!isRayDetectable(car)) continue;
+    const target = pool[count] ?? {};
+    pool[count] = target;
+    writeCarTarget(target, car, carOrder);
+    targets[count] = target;
+    count += 1;
+    carOrder += 1;
+  }
+  let ghostOrder = 0;
+  const carCount = cars.length;
+  const replayGhosts = snapshot.replayGhosts ?? [];
+  for (let index = 0; index < replayGhosts.length; index += 1) {
+    const ghost = replayGhosts[index];
+    if (ghost.sensors?.detectableByRays !== true) continue;
+    const target = pool[count] ?? {};
+    pool[count] = target;
+    writeReplayGhostTarget(target, ghost, carCount + ghostOrder);
+    targets[count] = target;
+    count += 1;
+    ghostOrder += 1;
+  }
+  targets.length = count;
+  return targets;
+}
+
+function writeCarTarget(target, car, order) {
+  target.entityType = SENSOR_TARGET_CAR;
+  target.id = car.id;
+  target.x = car.x;
+  target.y = car.y;
+  target.heading = car.heading;
+  target.velocityX = car.velocityX;
+  target.velocityY = car.velocityY;
+  target.speedKph = car.speedKph ?? 0;
+  target.lap = car.lap;
+  target.order = order;
+  return target;
+}
+
+function writeReplayGhostTarget(target, ghost, order) {
+  target.entityType = SENSOR_TARGET_REPLAY_GHOST;
+  target.id = ghost.id;
+  target.x = ghost.x;
+  target.y = ghost.y;
+  target.heading = ghost.heading;
+  target.velocityX = undefined;
+  target.velocityY = undefined;
+  target.speedKph = ghost.speedKph ?? 0;
+  target.lap = null;
+  target.order = order;
+  return target;
+}
+
 function detectableReplayGhosts(snapshot, sensorFlag) {
   const carCount = snapshot.cars?.length ?? 0;
   return (snapshot.replayGhosts ?? [])