@inventure71/paddockjs 2.0.0 → 2.0.1

package/src/simulation/track/trackQueryIndex.js

@@ -1,5 +1,21 @@
 import { clamp, wrapDistance } from '../simMath.js';
 import { metersToSimUnits } from '../units.js';
+import {
+  candidateIdsFromGrid,
+  candidateIdsFromGridBounds,
+  createSpatialGrid,
+  gridCellForPoint,
+  insertIdIntoGridBounds,
+} from './trackQueryGrid.js';
+import { createPitQueryIndex } from './trackQueryPitIndex.js';
+import { createQueryScratch, ensureQueryScratch, ensureScratchArray, nextScratchEpoch } from './trackQueryScratch.js';
+import { createQueryStats, recordFallback, recordStat } from './trackQueryStats.js';
+
+export {
+  queryPitBoxCandidates,
+  queryPitRoadSegmentCandidates,
+  queryPitRoadSegmentCandidatesByRoute,
+} from './trackQueryPitIndex.js';
 
 const DEFAULT_GRID_CELL_SIZE = metersToSimUnits(32);
 const GRID_NEIGHBOR_LIMIT = 2;
@@ -263,59 +279,6 @@ function projectionTieScore(projection, preferredDistance) {
   return Math.abs(projection.distance - preferredDistance);
 }
 
-export function queryPitBoxCandidates(track, position) {
-  const index = track?.queryIndex;
-  const pit = index?.pit;
-  if (!pit?.boxGrid) {
-    recordFallback(index, 'pitFallbackReasons', 'missing-box-index');
-    return null;
-  }
-  if (!finitePoint(position)) {
-    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
-    return null;
-  }
-  index.stats.pitQueries += 1;
-  const ids = candidateIdsFromGrid(index, pit.boxGrid, position, 1);
-  if (!ids.length) {
-    recordStat(index, 'pitPaths', 'box-grid-miss');
-    return [];
-  }
-  recordStat(index, 'pitPaths', 'box-grid-hit');
-  return ids.map((id) => pit.boxCandidates[id]).filter(Boolean);
-}
-
-export function queryPitRoadSegmentCandidates(track, routeId, position) {
-  const candidatesByRoute = queryPitRoadSegmentCandidatesByRoute(track, position);
-  return candidatesByRoute?.[routeId] ?? candidatesByRoute;
-}
-
-export function queryPitRoadSegmentCandidatesByRoute(track, position) {
-  const index = track?.queryIndex;
-  const pit = index?.pit;
-  if (!pit?.roadGrid) {
-    recordFallback(index, 'pitFallbackReasons', 'missing-road-index');
-    return null;
-  }
-  if (!finitePoint(position)) {
-    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
-    return null;
-  }
-  index.stats.pitQueries += 1;
-  const ids = candidateIdsFromGrid(index, pit.roadGrid, position, 1);
-  if (!ids.length) {
-    recordStat(index, 'pitPaths', 'road-grid-miss');
-    return null;
-  }
-  const candidatesByRoute = { entry: [], main: [], working: [], exit: [] };
-  ids.forEach((id) => {
-    const segment = pit.roadSegments[id];
-    if (!segment || !candidatesByRoute[segment.routeId]) return;
-    candidatesByRoute[segment.routeId].push(segment.segmentIndex);
-  });
-  recordStat(index, 'pitPaths', 'road-grid-hit');
-  return candidatesByRoute;
-}
-
 export function queryNearbyTrackProjections(track, position, { neighborLimit = GRID_NEIGHBOR_LIMIT } = {}) {
   const index = track?.queryIndex;
   if (!index?.centerline?.segmentCount || !finitePoint(position)) return null;
@@ -422,35 +385,6 @@ export function snapshotTrackQueryStats(track) {
   return stats ? JSON.parse(JSON.stringify(stats)) : null;
 }
 
-function createQueryStats() {
-  return {
-    nearestQueries: 0,
-    nearestFallbacks: 0,
-    nearestPaths: {},
-    nearestFallbackReasons: {
-      'spatial-grid-no-candidates': 0,
-    },
-    pitQueries: 0,
-    pitFallbacks: 0,
-    pitPaths: {},
-    pitFallbackReasons: {},
-  };
-}
-
-function recordFallback(index, bucket, reason) {
-  if (!index?.stats) return;
-  if (bucket.startsWith('nearest')) index.stats.nearestFallbacks += 1;
-  if (bucket.startsWith('pit')) index.stats.pitFallbacks += 1;
-  recordStat(index, bucket, reason);
-}
-
-function recordStat(index, bucket, reason) {
-  if (!index?.stats || !reason) return;
-  const target = index.stats[bucket] ?? {};
-  target[reason] = (target[reason] ?? 0) + 1;
-  index.stats[bucket] = target;
-}
-
 function createTrackBands(track) {
   const trackEdge = track.width / 2;
   const kerbEdge = trackEdge + (track.kerbWidth ?? 0);
@@ -559,18 +493,6 @@ function expandedSampleBounds(samples, expansion) {
   };
 }
 
-function createSpatialGrid(bounds, cellSize) {
-  const columns = Math.max(1, Math.ceil((bounds.maxX - bounds.minX) / cellSize));
-  const rows = Math.max(1, Math.ceil((bounds.maxY - bounds.minY) / cellSize));
-  return {
-    bounds,
-    cellSize,
-    columns,
-    rows,
-    cells: new Array(columns * rows),
-  };
-}
-
 function insertSegmentIntoGrid(grid, centerline, segmentId, expansion) {
   insertIdIntoGridBounds(grid, segmentId, {
     minX: centerline.minX[segmentId] - expansion,
@@ -580,19 +502,6 @@ function insertSegmentIntoGrid(grid, centerline, segmentId, expansion) {
   });
 }
 
-function insertIdIntoGridBounds(grid, id, bounds) {
-  const minCell = gridCellForPoint(grid, { x: bounds.minX, y: bounds.minY }, true);
-  const maxCell = gridCellForPoint(grid, { x: bounds.maxX, y: bounds.maxY }, true);
-  for (let row = minCell.row; row <= maxCell.row; row += 1) {
-    for (let column = minCell.column; column <= maxCell.column; column += 1) {
-      const cellIndex = row * grid.columns + column;
-      const cell = grid.cells[cellIndex];
-      if (cell) cell.push(id);
-      else grid.cells[cellIndex] = [id];
-    }
-  }
-}
-
 function candidateIdsFromArcBuckets(index, distanceAlong, radius) {
   const arcBuckets = index?.arcBuckets;
   if (!arcBuckets?.count || !Number.isFinite(distanceAlong)) return [];
@@ -613,73 +522,6 @@ function candidateIdsFromArcBuckets(index, distanceAlong, radius) {
   return ids;
 }
 
-function candidateIdsFromGrid(index, grid, position, neighborLimit) {
-  const center = gridCellForPoint(grid, position, false);
-  if (!center) return [];
-  const scratch = ensureQueryScratch(index);
-  const maxId = Math.max(index.centerline.segmentCount, index.pit?.roadSegments?.length ?? 0, index.pit?.boxCandidates?.length ?? 0);
-  const idMarks = ensureScratchArray(scratch, 'candidateMarks', maxId);
-  const ids = [];
-  for (let radius = 0; radius <= neighborLimit; radius += 1) {
-    const candidateEpoch = nextScratchEpoch(scratch, 'candidateEpoch', idMarks);
-    ids.length = 0;
-    for (let row = center.row - radius; row <= center.row + radius; row += 1) {
-      for (let column = center.column - radius; column <= center.column + radius; column += 1) {
-        if (column < 0 || row < 0 || column >= grid.columns || row >= grid.rows) continue;
-        const cell = grid.cells[row * grid.columns + column];
-        if (!cell) continue;
-        for (const id of cell) {
-          if (idMarks[id] === candidateEpoch) continue;
-          idMarks[id] = candidateEpoch;
-          ids.push(id);
-        }
-      }
-    }
-    if (ids.length) return ids.slice();
-  }
-  return [];
-}
-
-function candidateIdsFromGridBounds(index, grid, bounds) {
-  if (
-    bounds.maxX < grid.bounds.minX ||
-    bounds.minX > grid.bounds.maxX ||
-    bounds.maxY < grid.bounds.minY ||
-    bounds.minY > grid.bounds.maxY
-  ) return [];
-  const minPoint = { x: bounds.minX, y: bounds.minY };
-  const maxPoint = { x: bounds.maxX, y: bounds.maxY };
-  const minCell = gridCellForPoint(grid, minPoint, true);
-  const maxCell = gridCellForPoint(grid, maxPoint, true);
-  const scratch = ensureQueryScratch(index);
-  const maxId = Math.max(index.centerline.segmentCount, index.pit?.roadSegments?.length ?? 0, index.pit?.boxCandidates?.length ?? 0);
-  const idMarks = ensureScratchArray(scratch, 'candidateMarks', maxId);
-  const candidateEpoch = nextScratchEpoch(scratch, 'candidateEpoch', idMarks);
-  const ids = [];
-  for (let row = minCell.row; row <= maxCell.row; row += 1) {
-    for (let column = minCell.column; column <= maxCell.column; column += 1) {
-      const cell = grid.cells[row * grid.columns + column];
-      if (!cell) continue;
-      for (const id of cell) {
-        if (idMarks[id] === candidateEpoch) continue;
-        idMarks[id] = candidateEpoch;
-        ids.push(id);
-      }
-    }
-  }
-  return ids;
-}
-
-function gridCellForPoint(grid, point, clampToGrid) {
-  const column = Math.floor((point.x - grid.bounds.minX) / grid.cellSize);
-  const row = Math.floor((point.y - grid.bounds.minY) / grid.cellSize);
-  if (!clampToGrid && (column < 0 || row < 0 || column >= grid.columns || row >= grid.rows)) return null;
-  return {
-    column: clampToGrid ? clamp(column, 0, grid.columns - 1) : column,
-    row: clampToGrid ? clamp(row, 0, grid.rows - 1) : row,
-  };
-}
-
 function projectIndexedSegment(centerline, segmentId, position) {
   const ax = centerline.startX[segmentId];
   const ay = centerline.startY[segmentId];
@@ -733,134 +575,6 @@ function segmentFromIndex(centerline, segmentId) {
   };
 }
 
-function createPitQueryIndex(track, cellSize) {
-  const pitLane = track.pitLane;
-  if (!pitLane?.enabled) return null;
-  const bounds = {
-    minX: pitLane.bounds.minX - cellSize,
-    maxX: pitLane.bounds.maxX + cellSize,
-    minY: pitLane.bounds.minY - cellSize,
-    maxY: pitLane.bounds.maxY + cellSize,
-  };
-  const roadGrid = createSpatialGrid(bounds, cellSize);
-  const boxGrid = createSpatialGrid(bounds, cellSize);
-  const roadSegments = [];
-  const routes = {};
-
-  [
-    ['entry', pitLane.entry?.roadCenterline],
-    ['main', pitLane.mainLane?.points],
-    ['working', pitLane.workingLane?.points],
-    ['exit', pitLane.exit?.roadCenterline],
-  ].forEach(([routeId, points]) => {
-    routes[routeId] = { start: roadSegments.length };
-    indexPitRoute(roadGrid, roadSegments, routeId, points, cellSize);
-    routes[routeId].end = roadSegments.length;
-  });
-
-  const boxCandidates = [];
-  [
-    ...(pitLane.serviceAreas ?? []).flatMap((area) => [
-      { type: 'service-area', target: area, polygon: area.corners },
-      { type: 'service-queue', target: area, polygon: area.queueCorners },
-    ]),
-    ...(pitLane.boxes ?? []).map((box) => ({ type: 'garage-box', target: box, polygon: box.corners })),
-  ]
-    .filter((candidate) => Array.isArray(candidate.polygon) && candidate.polygon.length >= 3)
-    .forEach((candidate) => {
-      const id = boxCandidates.length;
-      boxCandidates.push(candidate);
-      insertIdIntoGridBounds(boxGrid, id, polygonBounds(candidate.polygon, cellSize));
-    });
-
-  return {
-    roadGrid,
-    boxGrid,
-    routes,
-    roadSegments,
-    boxCandidates,
-  };
-}
-
-function indexPitRoute(grid, roadSegments, routeId, points, expansion) {
-  if (!Array.isArray(points) || points.length < 2) return;
-  for (let index = 0; index < points.length - 1; index += 1) {
-    const start = points[index];
-    const end = points[index + 1];
-    const id = roadSegments.length;
-    roadSegments.push({ routeId, segmentIndex: index });
-    const bounds = {
-      minX: Math.min(start.x, end.x) - expansion,
-      maxX: Math.max(start.x, end.x) + expansion,
-      minY: Math.min(start.y, end.y) - expansion,
-      maxY: Math.max(start.y, end.y) + expansion,
-    };
-    insertIdIntoGridBounds(grid, id, bounds);
-  }
-}
-
-function polygonBounds(polygon, expansion) {
-  const bounds = polygon.reduce((current, point) => ({
-    minX: Math.min(current.minX, point.x),
-    maxX: Math.max(current.maxX, point.x),
-    minY: Math.min(current.minY, point.y),
-    maxY: Math.max(current.maxY, point.y),
-  }), { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity });
-  return {
-    minX: bounds.minX - expansion,
-    maxX: bounds.maxX + expansion,
-    minY: bounds.minY - expansion,
-    maxY: bounds.maxY + expansion,
-  };
-}
-
-function createQueryScratch(index) {
-  const segmentCount = Math.max(0, index?.centerline?.segmentCount ?? 0);
-  const maxId = Math.max(
-    segmentCount,
-    index?.pit?.roadSegments?.length ?? 0,
-    index?.pit?.boxCandidates?.length ?? 0,
-  );
-  const grid = index?.segmentGrid ?? index?.grid;
-  const cellCount = Math.max(0, (grid?.columns ?? 0) * (grid?.rows ?? 0));
-  return {
-    candidateMarks: new Uint32Array(Math.max(1, maxId)),
-    candidateEpoch: 1,
-    sampleMarks: new Uint32Array(Math.max(1, segmentCount)),
-    sampleEpoch: 1,
-    raySegmentMarks: new Uint32Array(Math.max(1, segmentCount)),
-    raySegmentEpoch: 1,
-    rayCellMarks: new Uint32Array(Math.max(1, cellCount)),
-    rayCellEpoch: 1,
-    raySegmentIds: [],
-    rayVisitedCells: [],
-    rayTraceCache: new Map(),
-  };
-}
-
-function ensureQueryScratch(index) {
-  if (index.queryScratch) return index.queryScratch;
-  index.queryScratch = createQueryScratch(index);
-  return index.queryScratch;
-}
-
-function ensureScratchArray(scratch, key, minimumLength) {
-  if (!scratch[key] || scratch[key].length < minimumLength) {
-    scratch[key] = new Uint32Array(Math.max(1, minimumLength));
-  }
-  return scratch[key];
-}
-
-function nextScratchEpoch(scratch, key, marks) {
-  let epoch = (scratch[key] ?? 0) + 1;
-  if (epoch >= 0xFFFFFFFF) {
-    marks.fill(0);
-    epoch = 1;
-  }
-  scratch[key] = epoch;
-  return epoch;
-}
-
 function seedRayTraceFromNearbyCache(
   index,
   grid,

package/src/simulation/track/trackQueryPitIndex.js

@@ -0,0 +1,140 @@
+import { createSpatialGrid, insertIdIntoGridBounds, candidateIdsFromGrid } from './trackQueryGrid.js';
+import { recordFallback, recordStat } from './trackQueryStats.js';
+
+export function createPitQueryIndex(track, cellSize) {
+  const pitLane = track.pitLane;
+  if (!pitLane?.enabled) return null;
+  const bounds = {
+    minX: pitLane.bounds.minX - cellSize,
+    maxX: pitLane.bounds.maxX + cellSize,
+    minY: pitLane.bounds.minY - cellSize,
+    maxY: pitLane.bounds.maxY + cellSize,
+  };
+  const roadGrid = createSpatialGrid(bounds, cellSize);
+  const boxGrid = createSpatialGrid(bounds, cellSize);
+  const roadSegments = [];
+  const routes = {};
+
+  [
+    ['entry', pitLane.entry?.roadCenterline],
+    ['main', pitLane.mainLane?.points],
+    ['working', pitLane.workingLane?.points],
+    ['exit', pitLane.exit?.roadCenterline],
+  ].forEach(([routeId, points]) => {
+    routes[routeId] = { start: roadSegments.length };
+    indexPitRoute(roadGrid, roadSegments, routeId, points, cellSize);
+    routes[routeId].end = roadSegments.length;
+  });
+
+  const boxCandidates = [];
+  [
+    ...(pitLane.serviceAreas ?? []).flatMap((area) => [
+      { type: 'service-area', target: area, polygon: area.corners },
+      { type: 'service-queue', target: area, polygon: area.queueCorners },
+    ]),
+    ...(pitLane.boxes ?? []).map((box) => ({ type: 'garage-box', target: box, polygon: box.corners })),
+  ]
+    .filter((candidate) => Array.isArray(candidate.polygon) && candidate.polygon.length >= 3)
+    .forEach((candidate) => {
+      const id = boxCandidates.length;
+      boxCandidates.push(candidate);
+      insertIdIntoGridBounds(boxGrid, id, polygonBounds(candidate.polygon, cellSize));
+    });
+
+  return {
+    roadGrid,
+    boxGrid,
+    routes,
+    roadSegments,
+    boxCandidates,
+  };
+}
+
+export function queryPitBoxCandidates(track, position) {
+  const index = track?.queryIndex;
+  const pit = index?.pit;
+  if (!pit?.boxGrid) {
+    recordFallback(index, 'pitFallbackReasons', 'missing-box-index');
+    return null;
+  }
+  if (!finitePoint(position)) {
+    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
+    return null;
+  }
+  index.stats.pitQueries += 1;
+  const ids = candidateIdsFromGrid(index, pit.boxGrid, position, 1);
+  if (!ids.length) {
+    recordStat(index, 'pitPaths', 'box-grid-miss');
+    return [];
+  }
+  recordStat(index, 'pitPaths', 'box-grid-hit');
+  return ids.map((id) => pit.boxCandidates[id]).filter(Boolean);
+}
+
+export function queryPitRoadSegmentCandidates(track, routeId, position) {
+  const candidatesByRoute = queryPitRoadSegmentCandidatesByRoute(track, position);
+  return candidatesByRoute?.[routeId] ?? candidatesByRoute;
+}
+
+export function queryPitRoadSegmentCandidatesByRoute(track, position) {
+  const index = track?.queryIndex;
+  const pit = index?.pit;
+  if (!pit?.roadGrid) {
+    recordFallback(index, 'pitFallbackReasons', 'missing-road-index');
+    return null;
+  }
+  if (!finitePoint(position)) {
+    recordFallback(index, 'pitFallbackReasons', 'invalid-position');
+    return null;
+  }
+  index.stats.pitQueries += 1;
+  const ids = candidateIdsFromGrid(index, pit.roadGrid, position, 1);
+  if (!ids.length) {
+    recordStat(index, 'pitPaths', 'road-grid-miss');
+    return null;
+  }
+  const candidatesByRoute = { entry: [], main: [], working: [], exit: [] };
+  ids.forEach((id) => {
+    const segment = pit.roadSegments[id];
+    if (!segment || !candidatesByRoute[segment.routeId]) return;
+    candidatesByRoute[segment.routeId].push(segment.segmentIndex);
+  });
+  recordStat(index, 'pitPaths', 'road-grid-hit');
+  return candidatesByRoute;
+}
+
+function indexPitRoute(grid, roadSegments, routeId, points, expansion) {
+  if (!Array.isArray(points) || points.length < 2) return;
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const start = points[index];
+    const end = points[index + 1];
+    const id = roadSegments.length;
+    roadSegments.push({ routeId, segmentIndex: index });
+    const bounds = {
+      minX: Math.min(start.x, end.x) - expansion,
+      maxX: Math.max(start.x, end.x) + expansion,
+      minY: Math.min(start.y, end.y) - expansion,
+      maxY: Math.max(start.y, end.y) + expansion,
+    };
+    insertIdIntoGridBounds(grid, id, bounds);
+  }
+}
+
+function polygonBounds(polygon, expansion) {
+  const bounds = polygon.reduce((current, point) => ({
+    minX: Math.min(current.minX, point.x),
+    maxX: Math.max(current.maxX, point.x),
+    minY: Math.min(current.minY, point.y),
+    maxY: Math.max(current.maxY, point.y),
+  }), { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity });
+  return {
+    minX: bounds.minX - expansion,
+    maxX: bounds.maxX + expansion,
+    minY: bounds.minY - expansion,
+    maxY: bounds.maxY + expansion,
+  };
+}
+
+function finitePoint(point) {
+  return Number.isFinite(point?.x) && Number.isFinite(point?.y);
+}

package/src/simulation/track/trackQueryScratch.js

@@ -0,0 +1,46 @@
+export function createQueryScratch(index) {
+  const segmentCount = Math.max(0, index?.centerline?.segmentCount ?? 0);
+  const maxId = Math.max(
+    segmentCount,
+    index?.pit?.roadSegments?.length ?? 0,
+    index?.pit?.boxCandidates?.length ?? 0,
+  );
+  const grid = index?.segmentGrid ?? index?.grid;
+  const cellCount = Math.max(0, (grid?.columns ?? 0) * (grid?.rows ?? 0));
+  return {
+    candidateMarks: new Uint32Array(Math.max(1, maxId)),
+    candidateEpoch: 1,
+    sampleMarks: new Uint32Array(Math.max(1, segmentCount)),
+    sampleEpoch: 1,
+    raySegmentMarks: new Uint32Array(Math.max(1, segmentCount)),
+    raySegmentEpoch: 1,
+    rayCellMarks: new Uint32Array(Math.max(1, cellCount)),
+    rayCellEpoch: 1,
+    raySegmentIds: [],
+    rayVisitedCells: [],
+    rayTraceCache: new Map(),
+  };
+}
+
+export function ensureQueryScratch(index) {
+  if (index.queryScratch) return index.queryScratch;
+  index.queryScratch = createQueryScratch(index);
+  return index.queryScratch;
+}
+
+export function ensureScratchArray(scratch, key, minimumLength) {
+  if (!scratch[key] || scratch[key].length < minimumLength) {
+    scratch[key] = new Uint32Array(Math.max(1, minimumLength));
+  }
+  return scratch[key];
+}
+
+export function nextScratchEpoch(scratch, key, marks) {
+  let epoch = (scratch[key] ?? 0) + 1;
+  if (epoch >= 0xFFFFFFFF) {
+    marks.fill(0);
+    epoch = 1;
+  }
+  scratch[key] = epoch;
+  return epoch;
+}

package/src/simulation/track/trackQueryStats.js

@@ -0,0 +1,28 @@
+export function createQueryStats() {
+  return {
+    nearestQueries: 0,
+    nearestFallbacks: 0,
+    nearestPaths: {},
+    nearestFallbackReasons: {
+      'spatial-grid-no-candidates': 0,
+    },
+    pitQueries: 0,
+    pitFallbacks: 0,
+    pitPaths: {},
+    pitFallbackReasons: {},
+  };
+}
+
+export function recordFallback(index, bucket, reason) {
+  if (!index?.stats) return;
+  if (bucket === 'nearestFallbackReasons') index.stats.nearestFallbacks += 1;
+  if (bucket === 'pitFallbackReasons') index.stats.pitFallbacks += 1;
+  recordStat(index, bucket, reason);
+}
+
+export function recordStat(index, bucket, key) {
+  if (!index?.stats || !bucket || !key) return;
+  const target = index.stats[bucket] ?? {};
+  target[key] = (target[key] ?? 0) + 1;
+  index.stats[bucket] = target;
+}

package/src/simulation/vehicle/contactResolution.js

@@ -15,10 +15,32 @@ function forwardVector(car) {
   return { x: Math.cos(car.heading), y: Math.sin(car.heading) };
 }
 
+function velocityVector(car) {
+  if (Number.isFinite(car.velocityX) && Number.isFinite(car.velocityY)) {
+    return { x: car.velocityX, y: car.velocityY };
+  }
+  const forward = forwardVector(car);
+  return { x: forward.x * car.speed, y: forward.y * car.speed };
+}
+
 function dot(a, b) {
   return a.x * b.x + a.y * b.y;
 }
 
+function applyVelocityVector(car, velocity) {
+  const speed = clamp(Math.hypot(velocity.x, velocity.y), 0, VEHICLE_LIMITS.maxSpeed);
+  if (speed <= 0) {
+    car.velocityX = 0;
+    car.velocityY = 0;
+    car.speed = 0;
+    return;
+  }
+  const scale = speed / Math.max(1e-9, Math.hypot(velocity.x, velocity.y));
+  car.velocityX = velocity.x * scale;
+  car.velocityY = velocity.y * scale;
+  car.speed = speed;
+}
+
 export function resolveCollisionsForSimulation(sim) {
   const collidableCars = sim.cars.filter(isCollidable);
   if (collidableCars.length < 2) return;
@@ -57,8 +79,8 @@ export function resolveCollisionsForSimulation(sim) {
       }
 
       if (oneCarFixed) {
-        if (!firstPitControlled) first.speed = clamp(first.speed * 0.985, 0, VEHICLE_LIMITS.maxSpeed);
-        if (!secondPitControlled) second.speed = clamp(second.speed * 0.985, 0, VEHICLE_LIMITS.maxSpeed);
+        if (!firstPitControlled) dampPitContactVelocity(first, 0.985, sim.physicsMode === 'simulator');
+        if (!secondPitControlled) dampPitContactVelocity(second, 0.985, sim.physicsMode === 'simulator');
       } else {
         applyContactVelocityResponse(sim, first, second, collision.axis);
       }
@@ -99,6 +121,37 @@ export function resolveCollisionsForSimulation(sim) {
 }
 
 export function applyContactVelocityResponse(sim, first, second, axis) {
+  if (
+    sim.physicsMode === 'simulator' ||
+    Number.isFinite(first.velocityX) ||
+    Number.isFinite(second.velocityX)
+  ) {
+    const firstVelocity = velocityVector(first);
+    const secondVelocity = velocityVector(second);
+    const relativeNormalVelocity = dot({
+      x: secondVelocity.x - firstVelocity.x,
+      y: secondVelocity.y - firstVelocity.y,
+    }, axis);
+
+    if (relativeNormalVelocity < 0) {
+      const impulse = clamp(-relativeNormalVelocity * (0.34 + sim.rules.collisionRestitution), 0, 16);
+      firstVelocity.x -= axis.x * impulse;
+      firstVelocity.y -= axis.y * impulse;
+      secondVelocity.x += axis.x * impulse;
+      secondVelocity.y += axis.y * impulse;
+    }
+
+    applyVelocityVector(first, {
+      x: firstVelocity.x * 0.997,
+      y: firstVelocity.y * 0.997,
+    });
+    applyVelocityVector(second, {
+      x: secondVelocity.x * 0.997,
+      y: secondVelocity.y * 0.997,
+    });
+    return;
+  }
+
   const firstForward = forwardVector(first);
   const secondForward = forwardVector(second);
   const firstNormal = dot(firstForward, axis);
@@ -114,3 +167,15 @@ export function applyContactVelocityResponse(sim, first, second, axis) {
   first.speed = clamp(first.speed * 0.997, 0, VEHICLE_LIMITS.maxSpeed);
   second.speed = clamp(second.speed * 0.997, 0, VEHICLE_LIMITS.maxSpeed);
 }
+
+function dampPitContactVelocity(car, factor, syncVelocity = false) {
+  if (syncVelocity || Number.isFinite(car.velocityX) || Number.isFinite(car.velocityY)) {
+    const velocity = velocityVector(car);
+    applyVelocityVector(car, {
+      x: velocity.x * factor,
+      y: velocity.y * factor,
+    });
+    return;
+  }
+  car.speed = clamp(car.speed * factor, 0, VEHICLE_LIMITS.maxSpeed);
+}