@inventure71/paddockjs 1.0.0 → 2.0.0

package/src/simulation/participants/participantInteractions.js

@@ -0,0 +1,120 @@
+export const PARTICIPANT_INTERACTION_PROFILES = Object.freeze({
+  normal: Object.freeze({
+    profile: 'normal',
+    collidable: true,
+    detectableByRays: true,
+    detectableAsNearby: true,
+    blocksPitLane: true,
+    affectsRaceOrder: true,
+  }),
+  'isolated-training': Object.freeze({
+    profile: 'isolated-training',
+    collidable: false,
+    detectableByRays: false,
+    detectableAsNearby: false,
+    blocksPitLane: false,
+    affectsRaceOrder: true,
+  }),
+  'batch-training': Object.freeze({
+    profile: 'batch-training',
+    collidable: false,
+    detectableByRays: false,
+    detectableAsNearby: false,
+    blocksPitLane: false,
+    affectsRaceOrder: false,
+  }),
+  'phantom-race': Object.freeze({
+    profile: 'phantom-race',
+    collidable: false,
+    detectableByRays: true,
+    detectableAsNearby: true,
+    blocksPitLane: false,
+    affectsRaceOrder: true,
+  }),
+  'time-trial-overlay': Object.freeze({
+    profile: 'time-trial-overlay',
+    collidable: false,
+    detectableByRays: false,
+    detectableAsNearby: false,
+    blocksPitLane: false,
+    affectsRaceOrder: false,
+  }),
+});
+
+const INTERACTION_FLAGS = Object.freeze([
+  'collidable',
+  'detectableByRays',
+  'detectableAsNearby',
+  'blocksPitLane',
+  'affectsRaceOrder',
+]);
+
+export function normalizeParticipantInteractions(options = {}) {
+  const defaultProfile = resolveProfileName(options.defaultProfile);
+  const defaultInteraction = { ...PARTICIPANT_INTERACTION_PROFILES[defaultProfile] };
+  const drivers = {};
+  Object.entries(options.drivers ?? {}).forEach(([driverId, override]) => {
+    drivers[driverId] = resolveInteraction(override, defaultProfile);
+  });
+  return {
+    defaultProfile,
+    defaultInteraction,
+    drivers,
+  };
+}
+
+export function attachParticipantInteractions(cars = [], options = {}) {
+  const normalized = normalizeParticipantInteractions(options);
+  cars.forEach((car) => {
+    car.interaction = normalized.drivers[car.id] ?? { ...normalized.defaultInteraction };
+  });
+  return normalized;
+}
+
+export function resolveInteraction(override = {}, fallbackProfile = 'normal') {
+  const profile = resolveProfileName(override?.profile ?? fallbackProfile);
+  const resolved = { ...PARTICIPANT_INTERACTION_PROFILES[profile] };
+  INTERACTION_FLAGS.forEach((flag) => {
+    if (override?.[flag] != null) resolved[flag] = Boolean(override[flag]);
+  });
+  return resolved;
+}
+
+export function canCollide(first, second) {
+  return isCollidable(first) && isCollidable(second);
+}
+
+export function isCollidable(car) {
+  if (car?.destroyed || car?.outOfRace) return false;
+  return car?.interaction?.collidable !== false;
+}
+
+export function isRayDetectable(car) {
+  if (car?.destroyed || car?.outOfRace) return false;
+  return car?.interaction?.detectableByRays !== false;
+}
+
+export function isNearbyDetectable(car) {
+  if (car?.destroyed || car?.outOfRace) return false;
+  return car?.interaction?.detectableAsNearby !== false;
+}
+
+export function blocksPitLane(car) {
+  if (car?.destroyed || car?.outOfRace) return false;
+  return car?.interaction?.blocksPitLane !== false;
+}
+
+export function affectsRaceOrder(car) {
+  if (car?.destroyed || car?.outOfRace) return false;
+  return car?.interaction?.affectsRaceOrder !== false;
+}
+
+export function serializeParticipantInteraction(interaction) {
+  const normalized = resolveInteraction(interaction ?? {}, interaction?.profile ?? 'normal');
+  return { ...normalized };
+}
+
+function resolveProfileName(profile) {
+  const key = String(profile ?? 'normal');
+  return PARTICIPANT_INTERACTION_PROFILES[key] ? key : 'normal';
+}

package/src/simulation/pit/pitFlow.js

@@ -0,0 +1,234 @@
+import { pitLaneStatusSnapshot } from './pitSnapshots.js';
+import {
+  firstDifferentCompound,
+  normalizePitIntent,
+  shouldStartPitStopForSimulation,
+  updateAutomaticPitIntentForSimulation,
+} from './pitIntent.js';
+import {
+  advancePitService,
+  applyPitRoutePosition,
+  beginPitQueue,
+  beginPitService,
+  finishPitExit,
+  getPitBoxRaceDistance,
+  getPitStopBox,
+  isPitServiceBusy,
+  isPitServiceQueueOccupied,
+  releasePitQueue,
+} from './pitService.js';
+import {
+  createPitApproachPoints,
+  createRoute,
+  pitDriveLaneOffset,
+  pitMainLanePointAt,
+  routePoint,
+} from './pitRouting.js';
+import { metersToSimUnits } from '../units.js';
+import { applyWheelSurfaceState } from '../vehicle/wheelSurface.js';
+
+const PIT_ENTRY_APPROACH_DISTANCE = metersToSimUnits(250);
+const PIT_BOX_APPROACH_DISTANCE = metersToSimUnits(34);
+const PIT_SERVICE_QUEUE_FALLBACK_GAP = metersToSimUnits(48);
+const PIT_ENTRY_LATE_THRESHOLD_DISTANCE = metersToSimUnits(90);
+
+export function isCarInActivePitStop(sim, car) {
+  return Boolean(car?.pitStop && car.pitStop.status !== 'pending' && car.pitStop.status !== 'completed');
+}
+
+export function schedulePitStopAtNextEntry(sim, car, stop) {
+  const pitLane = sim.track.pitLane;
+  if (!stop || !pitLane?.entry || !Number.isFinite(sim.track.length) || sim.track.length <= 0) return false;
+  const raceDistance = car.raceDistance ?? 0;
+  const entryOffset = pitLane.entry.distanceFromStart ?? 0;
+  let lapBase = Math.floor((raceDistance - entryOffset) / sim.track.length) * sim.track.length;
+  let entryRaceDistance = lapBase + entryOffset;
+
+  while (raceDistance > entryRaceDistance + PIT_ENTRY_LATE_THRESHOLD_DISTANCE) {
+    lapBase += sim.track.length;
+    entryRaceDistance = lapBase + entryOffset;
+  }
+
+  stop.lapBase = lapBase;
+  stop.entryRaceDistance = entryRaceDistance;
+  stop.plannedRaceDistance = entryRaceDistance - PIT_ENTRY_APPROACH_DISTANCE;
+  return true;
+}
+
+export function rearmCompletedPitStop(sim, car, stop) {
+  if (!stop || stop.status !== 'completed') return false;
+  stop.status = 'pending';
+  stop.phase = null;
+  stop.route = null;
+  stop.routeProgress = 0;
+  stop.routeStartRaceDistance = null;
+  stop.routeEndRaceDistance = null;
+  stop.serviceRemaining = 0;
+  stop.penaltyServiceRemaining = 0;
+  stop.penaltyServiceTotal = 0;
+  stop.servingPenaltyIds = [];
+  stop.queueingForService = false;
+  stop.serviceProfile = null;
+  stop.targetTire = stop.targetTire ?? firstDifferentCompound(car.tire, sim.rules.modules?.tireStrategy?.compounds);
+  return schedulePitStopAtNextEntry(sim, car, stop);
+}
+
+export function canStartPitStop(sim, car) {
+  const stop = car.pitStop;
+  const pitStops = sim.rules.modules?.pitStops;
+  if (!stop || !pitStops?.enabled) return false;
+  const active = sim.cars.filter((candidate) => candidate !== car && isCarInActivePitStop(sim, candidate));
+  const maxConcurrentPitLaneCars = Math.max(1, Math.floor(pitStops.maxConcurrentPitLaneCars ?? 3));
+  if (active.length >= maxConcurrentPitLaneCars) return false;
+
+  if (!pitStops.doubleStacking && stop.teamId) {
+    const box = getPitStopBox(sim, stop);
+    if (isPitServiceQueueOccupied(sim, car, box)) return false;
+  }
+
+  const minimumGap = Math.max(0, pitStops.minimumPitLaneGap ?? 0);
+  const candidateDistance = car.raceDistance ?? 0;
+  return active.every((candidate) => {
+    const gap = (candidate.raceDistance ?? 0) - candidateDistance;
+    return gap < 0 || gap >= minimumGap;
+  });
+}
+
+export function shouldStartPitStop(sim, car) {
+  return shouldStartPitStopForSimulation(sim, car);
+}
+
+export function updateAutomaticPitIntent(sim, car) {
+  updateAutomaticPitIntentForSimulation(sim, car);
+}
+
+export function isPitLaneOpenForStops(sim) {
+  return pitLaneStatusSnapshot(sim.raceControl, sim.track.pitLane, sim.rules.modules?.pitStops).open;
+}
+
+export function pitEntryLateThresholdDistance() {
+  return PIT_ENTRY_LATE_THRESHOLD_DISTANCE;
+}
+
+export function startPitStop(sim, car) {
+  const stop = car.pitStop;
+  const box = getPitStopBox(sim, stop);
+  const pitLane = sim.track.pitLane;
+  if (!stop || !box || !pitLane?.enabled) return false;
+
+  car.gridLocked = false;
+  car.drsActive = false;
+  car.drsEligible = false;
+  car.drsZoneId = null;
+  car.drsZoneEnabled = false;
+  car.canAttack = false;
+  stop.targetTire = stop.targetTire ?? firstDifferentCompound(car.tire, sim.rules.modules?.tireStrategy?.compounds);
+
+  const currentState = applyWheelSurfaceState(car, sim.track).representativeState;
+  sim.events.unshift({
+    type: 'pit-entry',
+    at: sim.time,
+    carId: car.id,
+    boxId: box.id,
+    teamId: box.teamId ?? null,
+  });
+
+  if (currentState.surface === 'pit-box' && currentState.pitBoxId === box.id) {
+    beginPitService(sim, car, box);
+    return true;
+  }
+
+  const hasServiceQueue = Boolean(box.queuePoint);
+  const shouldStageForService = hasServiceQueue;
+  const queueDistanceAlongLane = box.queueDistanceAlongLane ??
+    Math.max(0, box.distanceAlongLane - PIT_SERVICE_QUEUE_FALLBACK_GAP);
+  const stopDistanceAlongLane = shouldStageForService
+    ? queueDistanceAlongLane
+    : box.distanceAlongLane;
+  const serviceTarget = shouldStageForService ? box.queuePoint : box.center;
+  const driveLaneOffset = pitDriveLaneOffset(pitLane);
+  const boxApproachDistance = Math.max(
+    0,
+    (hasServiceQueue ? queueDistanceAlongLane : stopDistanceAlongLane) - PIT_BOX_APPROACH_DISTANCE,
+  );
+  const route = createRoute([
+    ...createPitApproachPoints(sim.track, car, pitLane, stop.entryRaceDistance),
+    ...(pitLane.entry.roadCenterline ?? []).map((point) => routePoint(point)),
+    routePoint(pitMainLanePointAt(pitLane, 0, driveLaneOffset), pitLane.mainLane.heading, { limiterActive: true }),
+    routePoint(pitMainLanePointAt(pitLane, boxApproachDistance, driveLaneOffset), pitLane.mainLane.heading, { limiterActive: true }),
+    routePoint(serviceTarget, pitLane.mainLane.heading, { limiterActive: true }),
+  ]);
+  stop.status = 'entering';
+  stop.phase = 'entry';
+  stop.queueingForService = shouldStageForService;
+  stop.route = route;
+  stop.routeProgress = 0;
+  stop.routeStartRaceDistance = car.raceDistance ?? stop.plannedRaceDistance;
+  stop.routeEndRaceDistance = getPitBoxRaceDistance(sim, stop, {
+    ...box,
+    distanceAlongLane: stopDistanceAlongLane,
+  });
+  return true;
+}
+
+export function advancePitStopCar(sim, car, delta) {
+  const pitStops = sim.rules.modules?.pitStops;
+  const stop = car.pitStop;
+  if (!pitStops?.enabled || !stop) return false;
+  if (stop.status === 'pending' || stop.status === 'completed') updateAutomaticPitIntent(sim, car);
+  if (stop.status === 'completed') return false;
+  if (stop.status === 'pending' && !shouldStartPitStop(sim, car)) return false;
+  if (stop.status === 'pending') startPitStop(sim, car);
+
+  if (stop.status === 'entering') {
+    const finishedRoute = applyPitRoutePosition(sim, car, delta);
+    const box = getPitStopBox(sim, stop);
+    if (finishedRoute && box) {
+      if (stop.queueingForService) {
+        if (!isPitServiceBusy(sim, car, box) && !isPitServiceQueueOccupied(sim, car, box)) {
+          releasePitQueue(sim, car, box, { fromCurrent: true });
+        } else {
+          beginPitQueue(sim, car, box);
+        }
+      }
+      else beginPitService(sim, car, box);
+    }
+    car.contactCooldown = Math.max(0, car.contactCooldown - delta);
+    return true;
+  }
+
+  if (stop.status === 'queued') {
+    const box = getPitStopBox(sim, stop);
+    if (!box) return true;
+    car.previousX = car.x;
+    car.previousY = car.y;
+    car.previousHeading = car.heading;
+    car.x = box.queuePoint.x;
+    car.y = box.queuePoint.y;
+    car.heading = sim.track.pitLane.mainLane.heading;
+    car.speed = 0;
+    car.throttle = 0;
+    car.brake = 1;
+    applyWheelSurfaceState(car, sim.track);
+    car.progress = car.trackState.distance;
+    car.raceDistance = getPitBoxRaceDistance(sim, stop, {
+      ...box,
+      distanceAlongLane: box.queueDistanceAlongLane ?? box.distanceAlongLane,
+    });
+    if (!isPitServiceBusy(sim, car, box)) releasePitQueue(sim, car, box);
+    return true;
+  }
+
+  if (stop.status === 'servicing') {
+    return advancePitService(sim, car, delta);
+  }
+
+  if (stop.status === 'exiting') {
+    const finishedRoute = applyPitRoutePosition(sim, car, delta);
+    if (finishedRoute) finishPitExit(sim, car);
+    car.contactCooldown = Math.max(0, car.contactCooldown - delta);
+    return true;
+  }
+
+  return false;
+}

package/src/simulation/pit/pitIntent.js

@@ -0,0 +1,92 @@
+export const PIT_INTENT_NONE = 0;
+export const PIT_INTENT_IF_FREE = 1;
+export const PIT_INTENT_COMMITTED = 2;
+
+export function firstDifferentCompound(currentTire, compounds) {
+  const available = Array.isArray(compounds) && compounds.length ? compounds : ['S', 'M', 'H'];
+  return available.find((compound) => compound !== currentTire) ?? currentTire;
+}
+
+export function normalizePitCompound(value, compounds) {
+  if (value == null || value === '') return null;
+  const available = Array.isArray(compounds) && compounds.length ? compounds : ['S', 'M', 'H'];
+  return available.includes(value) ? value : null;
+}
+
+export function normalizePitIntent(value) {
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < 0 || number > 2) return null;
+  return number;
+}
+
+export function setPitIntentForSimulation(sim, id, intent, targetCompound = undefined) {
+  const request = intent && typeof intent === 'object'
+    ? intent
+    : { intent, targetCompound };
+  const nextIntent = normalizePitIntent(request.intent ?? request.pitIntent);
+  if (nextIntent == null) return false;
+  const car = sim.cars.find((item) => item.id === id);
+  const stop = car?.pitStop;
+  const pitStops = sim.rules.modules?.pitStops;
+  if (!car || !stop || !pitStops?.enabled || !sim.track.pitLane?.enabled) return false;
+  if (sim.isCarInActivePitStop(car)) return false;
+
+  const compoundRequest = request.targetCompound ??
+    request.compound ??
+    request.pitCompound ??
+    request.pitTargetCompound ??
+    request.targetTire;
+  const hasCompoundRequest = compoundRequest != null && compoundRequest !== '';
+  if (hasCompoundRequest) {
+    const targetTire = normalizePitCompound(compoundRequest, sim.rules.modules?.tireStrategy?.compounds);
+    if (!targetTire) return false;
+    stop.targetTire = targetTire;
+  } else if (nextIntent !== 0 && (!stop.targetTire || stop.status === 'completed')) {
+    stop.targetTire = firstDifferentCompound(car.tire, sim.rules.modules?.tireStrategy?.compounds);
+  } else if (nextIntent === 0) {
+    stop.targetTire = firstDifferentCompound(car.tire, sim.rules.modules?.tireStrategy?.compounds);
+  }
+
+  stop.intent = nextIntent;
+  if (stop.status === 'pending' && nextIntent !== 0) {
+    sim.schedulePitStopAtNextEntry(car, stop);
+  } else if (stop.status === 'completed' && nextIntent !== 0) {
+    sim.rearmCompletedPitStop(car, stop);
+  }
+  return true;
+}
+
+export function shouldStartPitStopForSimulation(sim, car) {
+  const stop = car.pitStop;
+  if (!stop || stop.status !== 'pending' || car.finished) return false;
+  if (!sim.isPitLaneOpenForStops()) return false;
+  const intent = normalizePitIntent(stop.intent) ?? 0;
+  if (intent === 0) return false;
+  const raceDistance = car.raceDistance ?? 0;
+  if (raceDistance > stop.entryRaceDistance + sim.pitEntryLateThresholdDistance()) {
+    sim.schedulePitStopAtNextEntry(car, stop);
+    return false;
+  }
+  return raceDistance >= stop.plannedRaceDistance &&
+    (intent === 2 || sim.canStartPitStop(car));
+}
+
+export function updateAutomaticPitIntentForSimulation(sim, car) {
+  const stop = car.pitStop;
+  const pitStops = sim.rules.modules?.pitStops;
+  if (!stop || !['pending', 'completed'].includes(stop.status) || !pitStops?.enabled || car.finished) return;
+  if (car.automaticPitIntentEnabled === false) return;
+  const tireEnergy = Number(car.tireEnergy ?? 100);
+  const requestThreshold = Number(pitStops.tirePitRequestThresholdPercent ?? 50);
+  const commitThreshold = Number(pitStops.tirePitCommitThresholdPercent ?? 30);
+  if (!Number.isFinite(tireEnergy)) return;
+
+  let nextIntent = 0;
+  if (tireEnergy < commitThreshold) nextIntent = 2;
+  else if (tireEnergy < requestThreshold) nextIntent = 1;
+  if (nextIntent === 0 || nextIntent <= (normalizePitIntent(stop.intent) ?? 0)) return;
+
+  stop.intent = nextIntent;
+  if (stop.status === 'completed') sim.rearmCompletedPitStop(car, stop);
+  else sim.schedulePitStopAtNextEntry(car, stop);
+}

package/src/simulation/pit/pitOccupancy.js

@@ -0,0 +1,47 @@
+import { blocksPitLane } from '../participants/participantInteractions.js';
+import { PIT_SERVICE_CLEAR_DISTANCE, pointDistance } from './pitServiceConstants.js';
+
+export function getPitStopBox(sim, stop) {
+  return sim.track.pitLane?.serviceAreas?.find((box) => box.id === stop?.boxId) ??
+    sim.track.pitLane?.boxes?.find((box) => box.id === stop?.boxId) ??
+    null;
+}
+
+export function isPitServiceAreaOccupied(sim, candidate, box, clearDistance) {
+  if (!blocksPitLane(candidate)) return false;
+  const status = candidate?.pitStop?.status;
+  const phase = candidate?.pitStop?.phase;
+  if (!status || !box) return false;
+  if (status === 'servicing') return true;
+  if (status === 'entering' && phase === 'queue-release') return true;
+  if (status === 'exiting') return pointDistance(candidate, box.center) < clearDistance;
+  return false;
+}
+
+export function isPitServiceBusy(sim, car, box, clearDistance = PIT_SERVICE_CLEAR_DISTANCE) {
+  return sim.cars.some((candidate) => (
+    candidate !== car &&
+    blocksPitLane(candidate) &&
+    candidate.pitStop?.boxId === box?.id &&
+    isPitServiceAreaOccupied(sim, candidate, box, clearDistance)
+  ));
+}
+
+export function isPitServiceQueueOccupied(sim, car, box) {
+  return sim.cars.some((candidate) => (
+    candidate !== car &&
+    blocksPitLane(candidate) &&
+    candidate.pitStop?.boxId === box?.id &&
+    (
+      candidate.pitStop?.status === 'queued' ||
+      Boolean(candidate.pitStop?.queueingForService)
+    )
+  ));
+}
+
+export function getPitBoxRaceDistance(sim, stop, box) {
+  const pitLane = sim.track.pitLane;
+  const amount = pitLane?.mainLane?.length > 0 ? box.distanceAlongLane / pitLane.mainLane.length : 0;
+  return stop.lapBase + pitLane.entry.distanceFromStart +
+    (pitLane.exit.distanceFromStart - pitLane.entry.distanceFromStart) * amount;
+}

package/src/simulation/pit/pitPenaltyService.js

@@ -0,0 +1,71 @@
+import {
+  getPitServicePenaltySeconds,
+  isPenaltyPitServiceable,
+  servePitPenaltyRecord,
+} from '../rules/penaltyLedger.js';
+import { beginTireService } from './pitTireService.js';
+
+export function beginPitPenaltyService(sim, car) {
+  const stop = car.pitStop;
+  const penalties = getPitServicePenalties(sim, car.id);
+  if (!stop || !penalties.length) return false;
+
+  const totalSeconds = penalties.reduce((total, penalty) => (
+    total + getPitServicePenaltySeconds(penalty)
+  ), 0);
+  stop.servingPenaltyIds = penalties.map((penalty) => penalty.id);
+  stop.penaltyServiceTotal = totalSeconds;
+  stop.penaltyServiceRemaining = totalSeconds;
+
+  if (totalSeconds <= 0) {
+    completePitPenaltyService(sim, car);
+    return true;
+  }
+
+  stop.phase = 'penalty';
+  stop.serviceRemaining = totalSeconds;
+  sim.events.unshift({
+    type: 'pit-penalty-service-start',
+    at: sim.time,
+    carId: car.id,
+    penaltyIds: [...stop.servingPenaltyIds],
+    penaltyServiceSeconds: totalSeconds,
+  });
+  return true;
+}
+
+export function completePitPenaltyService(sim, car) {
+  const stop = car.pitStop;
+  if (!stop) return;
+  const servedIds = [...(stop.servingPenaltyIds ?? [])];
+  servedIds.forEach((penaltyId) => {
+    const penalty = sim.penalties.find((entry) => entry.id === penaltyId);
+    const beforeStatus = penalty?.status;
+    const result = servePitPenaltyRecord(penalty, sim.time);
+    if (result && beforeStatus !== result.status) {
+      sim.events.unshift({
+        type: 'penalty-served',
+        at: sim.time,
+        penaltyId: result.id,
+        driverId: result.driverId,
+        serviceType: result.serviceType,
+        serviceContext: 'pit-stop',
+      });
+    }
+  });
+  stop.penaltyServiceRemaining = 0;
+  stop.serviceRemaining = 0;
+  sim.events.unshift({
+    type: 'pit-penalty-service-complete',
+    at: sim.time,
+    carId: car.id,
+    penaltyIds: servedIds,
+  });
+  beginTireService(sim, car);
+}
+
+export function getPitServicePenalties(sim, driverId) {
+  return sim.penalties.filter((penalty) => (
+    penalty.driverId === driverId && isPenaltyPitServiceable(penalty)
+  ));
+}

package/src/simulation/pit/pitQueue.js

@@ -0,0 +1,55 @@
+import { applyWheelSurfaceState } from '../vehicle/wheelSurface.js';
+import { createRoute, routePoint } from './pitRouting.js';
+import { PIT_QUEUE_RELEASE_SPEED } from './pitServiceConstants.js';
+import { getPitBoxRaceDistance } from './pitOccupancy.js';
+
+export function beginPitQueue(sim, car, box) {
+  const stop = car.pitStop;
+  if (!stop || !box?.queuePoint) return false;
+  stop.status = 'queued';
+  stop.phase = 'queue';
+  stop.route = null;
+  stop.routeProgress = 0;
+  stop.queueingForService = false;
+  car.x = box.queuePoint.x;
+  car.y = box.queuePoint.y;
+  car.heading = sim.track.pitLane.mainLane.heading;
+  car.speed = 0;
+  car.throttle = 0;
+  car.brake = 1;
+  applyWheelSurfaceState(car, sim.track);
+  car.progress = car.trackState.distance;
+  car.raceDistance = getPitBoxRaceDistance(sim, stop, {
+    ...box,
+    distanceAlongLane: box.queueDistanceAlongLane ?? box.distanceAlongLane,
+  });
+  return true;
+}
+
+export function releasePitQueue(sim, car, box, { fromCurrent = false } = {}) {
+  const stop = car.pitStop;
+  if (!stop || !box?.center) return false;
+  const route = createRoute([
+    ...(fromCurrent ? [routePoint(car, car.heading, { limiterActive: true })] : []),
+    routePoint(box.queuePoint, sim.track.pitLane.mainLane.heading, { limiterActive: true }),
+    routePoint(box.center, sim.track.pitLane.mainLane.heading, { limiterActive: true }),
+  ]);
+  stop.status = 'entering';
+  stop.phase = 'queue-release';
+  stop.queueingForService = false;
+  stop.route = route;
+  stop.routeProgress = 0;
+  stop.routeStartRaceDistance = fromCurrent
+    ? car.raceDistance ?? getPitBoxRaceDistance(sim, stop, {
+        ...box,
+        distanceAlongLane: box.queueDistanceAlongLane ?? box.distanceAlongLane,
+      })
+    : getPitBoxRaceDistance(sim, stop, {
+        ...box,
+        distanceAlongLane: box.queueDistanceAlongLane ?? box.distanceAlongLane,
+      });
+  stop.routeEndRaceDistance = getPitBoxRaceDistance(sim, stop, box);
+  return true;
+}
+
+export { PIT_QUEUE_RELEASE_SPEED };