@inventure71/paddockjs 1.0.0 → 2.0.0

package/src/simulation/track/proceduralCenterline.js

@@ -0,0 +1,237 @@
+import { clamp, createMulberry32, seededRange } from '../simMath.js';
+import { CENTERLINE_CONTROLS, TRACK_BOUNDARY_PADDING, WORLD, MIN_TRACK_SHAPE_VARIATION } from './trackConstants.js';
+import { distance } from './trackMath.js';
+
+export function normalizeSeed(seed) {
+  if (Number.isFinite(seed)) return seed >>> 0;
+  let hash = 2166136261;
+  String(seed ?? 'f1-track').split('').forEach((character) => {
+    hash ^= character.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  });
+  return hash >>> 0;
+}
+
+export function rotateControls(controls, random) {
+  const rotation = Math.floor(seededRange(random, 0, controls.length));
+  return [...controls.slice(rotation), ...controls.slice(0, rotation)];
+}
+
+function cellKey(x, y) {
+  return `${x},${y}`;
+}
+
+function randomInteger(random, min, max) {
+  return Math.floor(seededRange(random, min, max + 1));
+}
+
+function clampInteger(value, min, max) {
+  return Math.round(clamp(value, min, max));
+}
+
+function createRandomRegionTemplate(seed, options = {}) {
+  const random = createMulberry32(seed);
+  const cornerDensity = Number.isFinite(options.cornerDensity) ? Math.max(0.5, options.cornerDensity) : 1;
+  const extraColumns = Math.round((cornerDensity - 1) * 4);
+  const extraFeatures = Math.round((cornerDensity - 1) * 3);
+  const columns = randomInteger(random, options.minColumns ?? 10, options.maxColumns ?? (14 + extraColumns));
+  const rows = randomInteger(random, options.minRows ?? 7, options.maxRows ?? (8 + Math.max(0, Math.round(extraColumns / 2))));
+  const top = new Array(columns).fill(1);
+  const bottom = new Array(columns).fill(rows - 2);
+  let topCursor = randomInteger(random, 1, 2);
+  let bottomCursor = rows - randomInteger(random, 2, 3);
+
+  for (let column = 1; column < columns - 1; column += 1) {
+    topCursor += randomInteger(random, -1, 1);
+    bottomCursor += randomInteger(random, -1, 1);
+    topCursor = clampInteger(topCursor, 1, rows - 4);
+    bottomCursor = clampInteger(bottomCursor, topCursor + 2, rows - 2);
+    top[column] = topCursor;
+    bottom[column] = bottomCursor;
+  }
+
+  const featureCount = randomInteger(random, options.minFeatures ?? 4, options.maxFeatures ?? (6 + extraFeatures));
+  for (let feature = 0; feature < featureCount; feature += 1) {
+    const column = randomInteger(random, 2, columns - 3);
+    const width = randomInteger(random, 1, 2);
+    const carvesTop = random() < 0.5;
+    const amount = random() < 0.76 ? 1 : 2;
+
+    for (let offset = 0; offset < width; offset += 1) {
+      const target = clampInteger(column + offset, 1, columns - 2);
+      if (carvesTop) {
+        top[target] = clampInteger(top[target] + amount, 1, bottom[target] - 2);
+        top[target - 1] = clampInteger(top[target - 1] - 1, 1, bottom[target - 1] - 2);
+      } else {
+        bottom[target] = clampInteger(bottom[target] - amount, top[target] + 2, rows - 2);
+        bottom[target - 1] = clampInteger(bottom[target - 1] + 1, top[target - 1] + 2, rows - 2);
+      }
+    }
+  }
+
+  const cells = [];
+  for (let column = 1; column < columns - 1; column += 1) {
+    for (let row = top[column]; row <= bottom[column]; row += 1) {
+      cells.push([column, row]);
+    }
+  }
+
+  return { columns, rows, cells };
+}
+
+function traceRegionBoundary(template) {
+  const selected = new Set(template.cells.map(([x, y]) => cellKey(x, y)));
+  const edges = [];
+
+  template.cells.forEach(([x, y]) => {
+    if (!selected.has(cellKey(x, y - 1))) edges.push([[x, y], [x + 1, y]]);
+    if (!selected.has(cellKey(x + 1, y))) edges.push([[x + 1, y], [x + 1, y + 1]]);
+    if (!selected.has(cellKey(x, y + 1))) edges.push([[x + 1, y + 1], [x, y + 1]]);
+    if (!selected.has(cellKey(x - 1, y))) edges.push([[x, y + 1], [x, y]]);
+  });
+
+  const outgoing = new Map();
+  edges.forEach(([start, end]) => {
+    const key = cellKey(start[0], start[1]);
+    if (!outgoing.has(key)) outgoing.set(key, []);
+    outgoing.get(key).push(end);
+  });
+
+  const start = edges[0][0];
+  let current = start;
+  const boundary = [start];
+
+  for (let index = 0; index < edges.length; index += 1) {
+    const next = outgoing.get(cellKey(current[0], current[1]))?.shift();
+    if (!next) break;
+    current = next;
+    if (current[0] === start[0] && current[1] === start[1]) return boundary;
+    boundary.push(current);
+  }
+
+  return boundary;
+}
+
+function smoothRegionBoundary(points, amount = 0.34, rounds = 2) {
+  let smoothed = points;
+  for (let round = 0; round < rounds; round += 1) {
+    const next = [];
+    smoothed.forEach((point, index) => {
+      const following = smoothed[(index + 1) % smoothed.length];
+      next.push({
+        x: point.x + (following.x - point.x) * amount,
+        y: point.y + (following.y - point.y) * amount,
+      });
+      next.push({
+        x: point.x + (following.x - point.x) * (1 - amount),
+        y: point.y + (following.y - point.y) * (1 - amount),
+      });
+    });
+    smoothed = next;
+  }
+  return smoothed;
+}
+
+function createRegionTransform(random, options = {}) {
+  const scale = Number.isFinite(options.scale) ? Math.max(0.05, options.scale) : 1;
+  return {
+    centerX: 0.5 + seededRange(random, -0.015, 0.015),
+    centerY: 0.5 + seededRange(random, -0.015, 0.015),
+    scaleX: seededRange(random, 0.9, 0.98) * scale,
+    scaleY: seededRange(random, 0.9, 0.98) * scale,
+    phaseX: seededRange(random, 0, Math.PI * 2),
+    phaseY: seededRange(random, 0, Math.PI * 2),
+    warpX: seededRange(random, 0.018, 0.044),
+    warpY: seededRange(random, 0.018, 0.052),
+  };
+}
+
+function regionPointToWorld([x, y], template, transform) {
+  const usableWidth = WORLD.width - TRACK_BOUNDARY_PADDING * 2;
+  const usableHeight = WORLD.height - TRACK_BOUNDARY_PADDING * 2;
+  const normalizedX = x / template.columns;
+  const normalizedY = y / template.rows;
+  const radialX = normalizedX - 0.5;
+  const radialY = normalizedY - 0.5;
+  const edgeInfluence = clamp((Math.abs(radialX) + Math.abs(radialY) - 0.22) / 0.36, 0, 1);
+  const warpX = Math.sin(normalizedY * Math.PI * 4.4 + transform.phaseX) * transform.warpX * edgeInfluence;
+  const warpY = Math.sin(normalizedX * Math.PI * 4.2 + transform.phaseY) * transform.warpY * edgeInfluence;
+
+  return {
+    x: TRACK_BOUNDARY_PADDING + clamp(
+      transform.centerX + radialX * transform.scaleX + warpX,
+      0.04,
+      0.96,
+    ) * usableWidth,
+    y: TRACK_BOUNDARY_PADDING + clamp(
+      transform.centerY + radialY * transform.scaleY + warpY,
+      0.06,
+      0.94,
+    ) * usableHeight,
+  };
+}
+
+export function generateRegionCenterlineControls(seed, options = {}) {
+  const normalizedSeed = normalizeSeed(seed);
+  const random = createMulberry32(normalizedSeed);
+  const template = options.fallback
+    ? createRandomRegionTemplate(normalizedSeed, {
+      minColumns: 9,
+      maxColumns: 13,
+      minRows: 6,
+      maxRows: 8,
+      minFeatures: 3,
+      maxFeatures: 5,
+      cornerDensity: options.cornerDensity,
+    })
+    : createRandomRegionTemplate(normalizedSeed, { cornerDensity: options.cornerDensity });
+  const transform = createRegionTransform(random, options);
+  const boundary = traceRegionBoundary(template).map((point) => regionPointToWorld(point, template, transform));
+  return rotateControls(smoothRegionBoundary(boundary), random);
+}
+
+export function strengthenShapeVariation(controls, minimumVariation = MIN_TRACK_SHAPE_VARIATION) {
+  const center = { x: WORLD.width / 2, y: WORLD.height / 2 };
+  const radii = controls.map((point) => distance(point, center));
+  const mean = radii.reduce((total, radius) => total + radius, 0) / Math.max(1, radii.length);
+  const variation = mean > 0
+    ? Math.sqrt(radii.reduce((total, radius) => total + (radius - mean) ** 2, 0) / Math.max(1, radii.length)) / mean
+    : 0;
+  if (variation > minimumVariation + 0.015) return controls;
+
+  return controls.map((point) => {
+    const radius = distance(point, center);
+    if (radius <= 0) return point;
+    const amount = mean + (radius - mean) * 1.18;
+    const scale = amount / radius;
+    return {
+      x: clamp(center.x + (point.x - center.x) * scale, TRACK_BOUNDARY_PADDING, WORLD.width - TRACK_BOUNDARY_PADDING),
+      y: clamp(center.y + (point.y - center.y) * scale, TRACK_BOUNDARY_PADDING, WORLD.height - TRACK_BOUNDARY_PADDING),
+    };
+  });
+}
+
+export function generateCenterlineControls(seed, options = {}) {
+  return strengthenShapeVariation(generateRegionCenterlineControls(seed, options), options.variation);
+}
+
+export function generateFallbackCenterlineControls(seed, options = {}) {
+  return strengthenShapeVariation(
+    generateRegionCenterlineControls(seed ^ 0xa5a5a5a5, { ...options, fallback: true }),
+    options.variation,
+  );
+}
+
+export function generateSafeFallbackCenterlineControls(seed, options = {}) {
+  const center = { x: WORLD.width / 2, y: WORLD.height / 2 };
+  const scale = (0.78 + ((seed >>> 3) % 4) * 0.02) *
+    (Number.isFinite(options.scale) ? Math.max(0.05, options.scale) : 1);
+  const mirrorX = (seed & 1) === 1 ? -1 : 1;
+  const mirrorY = (seed & 2) === 2 ? -1 : 1;
+  const controls = CENTERLINE_CONTROLS.map((point) => ({
+    x: center.x + (point.x - center.x) * scale * mirrorX,
+    y: center.y + (point.y - center.y) * scale * mirrorY,
+  }));
+
+  return rotateControls(controls, createMulberry32(seed ^ 0x9e3779b9));
+}

package/src/simulation/track/sampleGeometry.js

@@ -0,0 +1,49 @@
+import { normalizeAngle } from '../simMath.js';
+import { distance } from './trackMath.js';
+
+export function recalculateSampleGeometry(samples) {
+  const usableCount = samples.length - 1;
+  for (let index = 0; index < usableCount; index += 1) {
+    const sample = samples[index];
+    const previous = samples[(index - 1 + usableCount) % usableCount];
+    const next = samples[(index + 1) % usableCount];
+    const nextNext = samples[(index + 2) % usableCount];
+    const heading = Math.atan2(next.y - previous.y, next.x - previous.x);
+    const nextHeading = Math.atan2(nextNext.y - sample.y, nextNext.x - sample.x);
+    sample.heading = heading;
+    sample.normalX = -Math.sin(heading);
+    sample.normalY = Math.cos(heading);
+    sample.curvature = Math.abs(normalizeAngle(nextHeading - heading)) / 28;
+  }
+
+  samples[usableCount] = {
+    ...samples[0],
+    distance: samples[usableCount].distance,
+  };
+
+  return samples;
+}
+
+export function rebuildSampleDistances(samples) {
+  const usable = samples.slice(0, -1).map((sample) => ({ ...sample }));
+  let rebuiltLength = 0;
+
+  usable.forEach((sample, index) => {
+    if (index > 0) rebuiltLength += distance(usable[index - 1], sample);
+    sample.distance = rebuiltLength;
+  });
+
+  rebuiltLength += distance(usable.at(-1), usable[0]);
+  const rebuilt = [
+    ...usable,
+    {
+      ...usable[0],
+      distance: rebuiltLength,
+    },
+  ];
+
+  return {
+    samples: recalculateSampleGeometry(rebuilt),
+    totalLength: rebuiltLength,
+  };
+}

package/src/simulation/track/spatialQueries.js

@@ -0,0 +1,154 @@
+import { clamp, normalizeAngle, wrapDistance } from '../simMath.js';
+import { NEAREST_HINT_WINDOW_SAMPLES, PIT_LANE_WIDTH } from './trackConstants.js';
+import { nearestPitLaneState } from './pitLaneState.js';
+import { queryNearestTrackProjection } from './trackQueryIndex.js';
+
+export function pointAt(track, distanceAlong) {
+  const wrapped = wrapDistance(distanceAlong, track.length);
+  const low = sampleIndexAtDistance(track, wrapped);
+
+  const next = track.samples[low] ?? track.samples[0];
+  const previous = track.samples[Math.max(0, low - 1)] ?? next;
+  const span = Math.max(1, next.distance - previous.distance);
+  const amount = clamp((wrapped - previous.distance) / span, 0, 1);
+
+  return {
+    x: previous.x + (next.x - previous.x) * amount,
+    y: previous.y + (next.y - previous.y) * amount,
+    heading: previous.heading + normalizeAngle(next.heading - previous.heading) * amount,
+    normalX: previous.normalX + (next.normalX - previous.normalX) * amount,
+    normalY: previous.normalY + (next.normalY - previous.normalY) * amount,
+    curvature: previous.curvature + (next.curvature - previous.curvature) * amount,
+    distance: wrapped,
+  };
+}
+
+export function sampleIndexAtDistance(track, distanceAlong) {
+  const wrapped = wrapDistance(distanceAlong, track.length);
+  let low = 0;
+  let high = track.samples.length - 1;
+
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (track.samples[mid].distance < wrapped) low = mid + 1;
+    else high = mid;
+  }
+
+  return low;
+}
+
+export function nearestSampleInRange(track, position, startIndex, endIndex) {
+  const sampleCount = track.samples.length - 1;
+  let best = null;
+  let bestDistance = Infinity;
+
+  for (let index = startIndex; index <= endIndex; index += 1) {
+    const wrappedIndex = ((index % sampleCount) + sampleCount) % sampleCount;
+    const sample = track.samples[wrappedIndex];
+    const dx = position.x - sample.x;
+    const dy = position.y - sample.y;
+    const squared = dx * dx + dy * dy;
+    if (squared < bestDistance) {
+      bestDistance = squared;
+      best = sample;
+    }
+  }
+
+  return { best, bestDistance };
+}
+
+export function nearestSampleGlobal(track, position) {
+  return nearestSampleInRange(track, position, 0, track.samples.length - 2);
+}
+
+export function createTrackState(track, position, best) {
+  const dx = position.x - best.x;
+  const dy = position.y - best.y;
+  const signedOffset = dx * best.normalX + dy * best.normalY;
+  const crossTrackError = Math.abs(signedOffset);
+  const trackEdge = track.width / 2;
+  const kerbEdge = trackEdge + (track.kerbWidth ?? 0);
+  const gravelEdge = kerbEdge + track.gravelWidth;
+  const runoffEdge = gravelEdge + track.runoffWidth;
+  const surface = crossTrackError <= trackEdge
+    ? 'track'
+    : crossTrackError <= kerbEdge
+      ? 'kerb'
+      : crossTrackError <= gravelEdge
+        ? 'gravel'
+        : crossTrackError <= runoffEdge
+          ? 'grass'
+          : 'barrier';
+
+  return {
+    ...best,
+    signedOffset,
+    crossTrackError,
+    surface,
+    onTrack: surface === 'track' || surface === 'kerb',
+  };
+}
+
+export function nearestTrackState(track, position, progressHint = null, options = {}) {
+  const allowPitOverride = options.allowPitOverride !== false;
+  const best = options.indexMode === 'legacy'
+    ? nearestTrackSampleLegacy(track, position, progressHint)
+    : queryNearestTrackProjection(track, position, progressHint, {
+      indexMode: options.indexMode,
+      hintMaxDistance: options.hintMaxDistance,
+    }) ??
+    nearestTrackSampleLegacy(track, position, progressHint);
+  const trackState = createTrackState(track, position, best);
+  if (!allowPitOverride) return trackState;
+  const pitState = nearestPitLaneState(track, position);
+  if (!pitState) return trackState;
+
+  const mainRoadEdge = track.width / 2 + (track.kerbWidth ?? 0);
+  if (trackState.crossTrackError <= mainRoadEdge && pitState.surface !== 'pit-box') return trackState;
+
+  const mergeBuffer = PIT_LANE_WIDTH * 0.16;
+  const isMainTrackMerge =
+    trackState.surface === 'track' &&
+    (
+      (pitState.surface === 'pit-entry' && pitState.pitLaneDistanceAlong <= mergeBuffer) ||
+      (pitState.surface === 'pit-exit' && (pitState.pitLaneTotalLength - pitState.pitLaneDistanceAlong) <= mergeBuffer)
+    );
+
+  if (isMainTrackMerge) return trackState;
+
+  return {
+    ...pitState,
+    mainTrackSignedOffset: trackState.signedOffset,
+    mainTrackCrossTrackError: trackState.crossTrackError,
+    signedOffset: trackState.signedOffset,
+    crossTrackError: trackState.crossTrackError,
+  };
+}
+
+function nearestTrackSampleLegacy(track, position, progressHint = null) {
+  let nearest = null;
+
+  if (Number.isFinite(progressHint)) {
+    const centerIndex = sampleIndexAtDistance(track, progressHint);
+    nearest = nearestSampleInRange(
+      track,
+      position,
+      centerIndex - NEAREST_HINT_WINDOW_SAMPLES,
+      centerIndex + NEAREST_HINT_WINDOW_SAMPLES,
+    );
+    const fallbackDistance = track.width / 2 + (track.kerbWidth ?? 0) + track.gravelWidth + track.runoffWidth + 180;
+    if (!nearest.best || nearest.bestDistance > fallbackDistance * fallbackDistance) {
+      nearest = null;
+    }
+  }
+
+  return nearest?.best ?? nearestSampleGlobal(track, position).best;
+}
+
+export function offsetTrackPoint(point, offset) {
+  return {
+    x: point.x + point.normalX * offset,
+    y: point.y + point.normalY * offset,
+    heading: point.heading,
+  };
+}

package/src/simulation/track/startStraight.js

@@ -0,0 +1,141 @@
+import { normalizeAngle } from '../simMath.js';
+import { START_STRAIGHT_BLEND_LENGTH, START_STRAIGHT_EXIT_LENGTH, START_STRAIGHT_GRID_LENGTH, START_STRAIGHT_LOCK_EXTRA } from './trackConstants.js';
+import { blendPoint, distanceForwardAlongTrack, pointWorldClearance, smoothstep } from './trackMath.js';
+import { rebuildSampleDistances } from './sampleGeometry.js';
+
+function resolveStartStraightOptions(options = {}) {
+  return {
+    grid: options.grid ?? START_STRAIGHT_GRID_LENGTH,
+    exit: options.exit ?? START_STRAIGHT_EXIT_LENGTH,
+    blend: options.blend ?? START_STRAIGHT_BLEND_LENGTH,
+    lockExtra: options.lockExtra ?? START_STRAIGHT_LOCK_EXTRA,
+  };
+}
+
+export function straightenStandingStartSamples(samples, totalLength, options = {}) {
+  const startStraight = resolveStartStraightOptions(options);
+  const start = samples[0];
+  const forward = {
+    x: Math.cos(start.heading),
+    y: Math.sin(start.heading),
+  };
+  const gridLockLength = startStraight.grid + startStraight.lockExtra;
+  const exitLockLength = startStraight.exit + startStraight.lockExtra;
+
+  const straightened = samples.slice(0, -1).map((sample) => {
+    const distanceFromStart = sample.distance;
+    const distanceToStart = totalLength - sample.distance;
+    let lineDistance = null;
+    let blendAmount = 0;
+
+    if (distanceFromStart <= exitLockLength + startStraight.blend) {
+      lineDistance = distanceFromStart;
+      blendAmount = distanceFromStart <= exitLockLength
+        ? 1
+        : 1 - smoothstep((distanceFromStart - exitLockLength) / startStraight.blend);
+    } else if (distanceToStart <= gridLockLength + startStraight.blend) {
+      lineDistance = -distanceToStart;
+      blendAmount = distanceToStart <= gridLockLength
+        ? 1
+        : 1 - smoothstep((distanceToStart - gridLockLength) / startStraight.blend);
+    }
+
+    if (lineDistance == null || blendAmount <= 0) return { ...sample };
+
+    return blendPoint(sample, {
+      ...sample,
+      x: start.x + forward.x * lineDistance,
+      y: start.y + forward.y * lineDistance,
+    }, blendAmount);
+  });
+
+  return rebuildSampleDistances([
+    ...straightened,
+    {
+      ...straightened[0],
+      distance: totalLength,
+    },
+  ]);
+}
+
+export function chooseStandingStartIndex(samples, totalLength, options = {}) {
+  const startStraight = resolveStartStraightOptions(options);
+  const usableSamples = samples.slice(0, -1);
+  let best = { index: 0, score: Infinity };
+
+  for (let index = 0; index < usableSamples.length; index += 1) {
+    const candidate = usableSamples[index];
+    const candidateForward = {
+      x: Math.cos(candidate.heading),
+      y: Math.sin(candidate.heading),
+    };
+    const projectedGridEnd = {
+      x: candidate.x - candidateForward.x * startStraight.grid,
+      y: candidate.y - candidateForward.y * startStraight.grid,
+    };
+    const projectedExitEnd = {
+      x: candidate.x + candidateForward.x * startStraight.exit,
+      y: candidate.y + candidateForward.y * startStraight.exit,
+    };
+    const projectedClearance = Math.min(pointWorldClearance(projectedGridEnd), pointWorldClearance(projectedExitEnd));
+    if (projectedClearance < 0) continue;
+
+    let gridTurn = 0;
+    let gridCurvature = 0;
+    let gridCount = 0;
+    let exitTurn = 0;
+    let exitCurvature = 0;
+    let exitCount = 0;
+
+    for (let offset = 1; offset < usableSamples.length; offset += 1) {
+      const sample = usableSamples[(index - offset + usableSamples.length) % usableSamples.length];
+      const distanceToLine = distanceForwardAlongTrack(sample.distance, candidate.distance, totalLength);
+      if (distanceToLine > startStraight.grid) break;
+      gridTurn = Math.max(gridTurn, Math.abs(normalizeAngle(candidate.heading - sample.heading)));
+      gridCurvature += sample.curvature;
+      gridCount += 1;
+    }
+
+    for (let offset = 1; offset < usableSamples.length; offset += 1) {
+      const sample = usableSamples[(index + offset) % usableSamples.length];
+      const distanceFromLine = distanceForwardAlongTrack(candidate.distance, sample.distance, totalLength);
+      if (distanceFromLine > startStraight.exit) break;
+      exitTurn = Math.max(exitTurn, Math.abs(normalizeAngle(sample.heading - candidate.heading)));
+      exitCurvature += sample.curvature;
+      exitCount += 1;
+    }
+
+    const score =
+      gridTurn * 5 +
+      exitTurn * 1.2 +
+      (gridCurvature / Math.max(1, gridCount)) * 2600 +
+      (exitCurvature / Math.max(1, exitCount)) * 650 -
+      projectedClearance * 0.002;
+
+    if (score < best.score) best = { index, score };
+  }
+
+  return best.index;
+}
+
+export function rotateSamplesToStandingStart(samples, totalLength, options = {}) {
+  const usableSamples = samples.slice(0, -1);
+  const startIndex = chooseStandingStartIndex(samples, totalLength, options);
+  const startDistance = usableSamples[startIndex].distance;
+
+  const rotated = [
+    ...usableSamples.slice(startIndex),
+    ...usableSamples.slice(0, startIndex),
+  ].map((sample) => ({
+    ...sample,
+    distance: distanceForwardAlongTrack(startDistance, sample.distance, totalLength),
+  }));
+
+  return [
+    ...rotated,
+    {
+      ...rotated[0],
+      distance: totalLength,
+    },
+  ];
+}

package/src/simulation/track/trackConstants.js

@@ -0,0 +1,109 @@
+import { metersToSimUnits } from '../units.js';
+
+export const WORLD = {
+  width: metersToSimUnits(3550),
+  height: metersToSimUnits(2148),
+};
+
+export const TRACK = {
+  name: 'Apex Harbor GP',
+  width: metersToSimUnits(15),
+  kerbWidth: metersToSimUnits(1.5),
+  gravelWidth: metersToSimUnits(12),
+  runoffWidth: metersToSimUnits(20),
+  barrierWidth: metersToSimUnits(0.55),
+  sampleCount: 3600,
+  drsZones: [
+    { id: 'main-straight', startRatio: 0.02, endRatio: 0.18 },
+    { id: 'back-straight', startRatio: 0.43, endRatio: 0.60 },
+    { id: 'harbor-straight', startRatio: 0.82, endRatio: 0.96 },
+  ],
+};
+
+export const GENERATED_TRACK_MIN_LENGTH = metersToSimUnits(3600);
+export const GENERATED_TRACK_MAX_LENGTH = metersToSimUnits(9000);
+export const GENERATED_TRACK_ATTEMPTS = 24;
+export const GENERATED_FALLBACK_ATTEMPTS = 8;
+export const TRACK_BOUNDARY_PADDING = metersToSimUnits(248);
+export const MIN_NON_ADJACENT_ARC_DISTANCE = metersToSimUnits(700);
+export const MIN_TRACK_CLEARANCE_MULTIPLIER = 1.55;
+export const MIN_TRACK_SHAPE_VARIATION = 0.28;
+export const MAX_LOCAL_TURN_RADIANS = 1.42;
+export const MAX_SAMPLE_HEADING_DELTA_RADIANS = 0.08;
+export const START_STRAIGHT_GRID_LENGTH = metersToSimUnits(496);
+export const START_STRAIGHT_EXIT_LENGTH = metersToSimUnits(500);
+export const START_STRAIGHT_LOCK_EXTRA = metersToSimUnits(43);
+export const START_STRAIGHT_BLEND_LENGTH = metersToSimUnits(320);
+export const NEAREST_HINT_WINDOW_SAMPLES = 240;
+export const PIT_LANE_WIDTH = metersToSimUnits(12);
+export const PIT_LANE_EDGE_GAP = metersToSimUnits(16);
+export const PIT_ACCESS_MIN_LENGTH = metersToSimUnits(70);
+export const PIT_ACCESS_MAX_LENGTH = metersToSimUnits(150);
+export const PIT_ACCESS_TANGENT_RATIO = 0.72;
+export const PIT_ACCESS_SAMPLE_STEPS = 24;
+export const PIT_ACCESS_TRACK_OVERLAP = PIT_LANE_WIDTH * 0.52;
+export const PIT_ACCESS_SEARCH_STEP = metersToSimUnits(8);
+export const PIT_ENTRY_SEARCH_BEFORE = metersToSimUnits(230);
+export const PIT_ENTRY_SEARCH_AFTER = metersToSimUnits(250);
+export const PIT_EXIT_SEARCH_BEFORE = metersToSimUnits(60);
+export const PIT_EXIT_SEARCH_AFTER = metersToSimUnits(560);
+export const PIT_TEAM_COUNT = 10;
+export const PIT_BOXES_PER_TEAM = 2;
+export const PIT_BOX_COUNT = PIT_TEAM_COUNT * PIT_BOXES_PER_TEAM;
+export const PIT_BOX_LENGTH = metersToSimUnits(9);
+export const PIT_BOX_DEPTH = metersToSimUnits(4.5);
+export const PIT_BOX_PAIR_GAP = metersToSimUnits(4);
+export const PIT_TEAM_GAP = metersToSimUnits(14);
+export const PIT_BOX_TO_LANE_GAP = metersToSimUnits(1.5);
+export const PIT_WORKING_LANE_GAP = metersToSimUnits(1.5);
+export const PIT_WORKING_LANE_WIDTH = metersToSimUnits(8);
+export const PIT_SERVICE_AREA_LENGTH = metersToSimUnits(11);
+export const PIT_SERVICE_AREA_DEPTH = metersToSimUnits(5);
+export const PIT_SERVICE_QUEUE_GAP = metersToSimUnits(12);
+export const PIT_LANE_ENTRY_BUFFER = metersToSimUnits(44);
+export const PIT_LANE_EXIT_BUFFER = metersToSimUnits(44);
+export const PIT_LANE_FINISH_RATIO = 0.64;
+export const PIT_WORLD_PADDING = metersToSimUnits(24);
+export const PIT_TRACK_CLEARANCE_MARGIN = metersToSimUnits(5);
+export const PIT_LANE_OFFSET_SEARCH_STEP = metersToSimUnits(12);
+export const PROCEDURAL_TRACK_TEMPLATES = [
+  [
+    [0.08, 0.55], [0.10, 0.80], [0.22, 0.89], [0.42, 0.84], [0.52, 0.93],
+    [0.60, 0.75], [0.74, 0.88], [0.91, 0.76], [0.94, 0.54], [0.82, 0.46],
+    [0.94, 0.28], [0.78, 0.18], [0.62, 0.31], [0.54, 0.13], [0.43, 0.30],
+    [0.33, 0.17], [0.20, 0.24], [0.12, 0.38], [0.22, 0.48], [0.13, 0.50],
+  ],
+  [
+    [0.07, 0.46], [0.14, 0.72], [0.25, 0.83], [0.39, 0.73], [0.47, 0.88],
+    [0.56, 0.70], [0.67, 0.82], [0.88, 0.84], [0.95, 0.63], [0.83, 0.56],
+    [0.92, 0.43], [0.79, 0.35], [0.88, 0.20], [0.68, 0.15], [0.58, 0.29],
+    [0.47, 0.18], [0.34, 0.30], [0.21, 0.19], [0.10, 0.28], [0.17, 0.39],
+  ],
+  [
+    [0.06, 0.61], [0.13, 0.86], [0.31, 0.91], [0.43, 0.79], [0.57, 0.87],
+    [0.71, 0.70], [0.92, 0.72], [0.95, 0.50], [0.84, 0.43], [0.91, 0.32],
+    [0.74, 0.24], [0.69, 0.11], [0.54, 0.18], [0.45, 0.08], [0.35, 0.22],
+    [0.23, 0.17], [0.11, 0.31], [0.24, 0.43], [0.15, 0.52], [0.28, 0.60],
+  ],
+];
+
+export const CENTERLINE_CONTROLS = [
+  { x: WORLD.width * 0.05, y: WORLD.height * 0.56 },
+  { x: WORLD.width * 0.10, y: WORLD.height * 0.81 },
+  { x: WORLD.width * 0.23, y: WORLD.height * 0.91 },
+  { x: WORLD.width * 0.35, y: WORLD.height * 0.80 },
+  { x: WORLD.width * 0.48, y: WORLD.height * 0.90 },
+  { x: WORLD.width * 0.59, y: WORLD.height * 0.75 },
+  { x: WORLD.width * 0.71, y: WORLD.height * 0.87 },
+  { x: WORLD.width * 0.82, y: WORLD.height * 0.72 },
+  { x: WORLD.width * 0.94, y: WORLD.height * 0.66 },
+  { x: WORLD.width * 0.96, y: WORLD.height * 0.47 },
+  { x: WORLD.width * 0.88, y: WORLD.height * 0.33 },
+  { x: WORLD.width * 0.74, y: WORLD.height * 0.31 },
+  { x: WORLD.width * 0.64, y: WORLD.height * 0.18 },
+  { x: WORLD.width * 0.54, y: WORLD.height * 0.31 },
+  { x: WORLD.width * 0.43, y: WORLD.height * 0.13 },
+  { x: WORLD.width * 0.29, y: WORLD.height * 0.18 },
+  { x: WORLD.width * 0.17, y: WORLD.height * 0.31 },
+  { x: WORLD.width * 0.08, y: WORLD.height * 0.43 },
+];