@inventure71/paddockjs 1.0.0 → 2.0.0

package/src/rendering/track/trackMaterialRenderer.js

@@ -0,0 +1,326 @@
+import { Graphics, TilingSprite } from 'pixi.js';
+import { offsetTrackPoint } from '../../simulation/trackModel.js';
+import { ASPHALT_COLOR, BARRIER_WALL_WIDTH, EDGE_REVEAL_OFFSET, EDGE_REVEAL_WIDTH, GRASS_COLOR, GRAVEL_COLOR, KERB_CURVATURE_THRESHOLD, KERB_OFFSET, KERB_STEP, KERB_WIDTH, MATERIAL_TILE_SCALE, OUTER_BOUNDARY_OFFSET, OUTER_BOUNDARY_WIDTH, RUNOFF_GRASS_COLOR, SEGMENTED_STROKE_STEP, WORLD_BACKGROUND_PADDING_MULTIPLIER } from './trackRenderConstants.js';
+import { makeTrackPath, textureOrWhite } from './trackRenderGeometry.js';
+import { getOffsetGapBridges, getOffsetStrokeSegments, offsetSegmentIsSafe } from './offsetStrokeSafety.js';
+
+export function drawOffsetSegment(graphics, start, end, {
+  width,
+  color,
+  alpha,
+  cap,
+}) {
+  graphics.moveTo(start.x, start.y);
+  graphics.lineTo(end.x, end.y);
+  graphics.stroke({
+    width,
+    color,
+    alpha,
+    join: 'round',
+    cap,
+  });
+}
+
+export function drawContinuousOffsetStroke(graphics, track, {
+  side,
+  offset,
+  width,
+  color,
+  alpha = 1,
+  step = SEGMENTED_STROKE_STEP,
+}) {
+  const samples = track.samples.slice(0, -1).filter((_, index) => index % step === 0);
+  if (samples.length < 2) return;
+
+  const first = offsetTrackPoint(samples[0], side * offset);
+  graphics.moveTo(first.x, first.y);
+  samples.slice(1).forEach((sample) => {
+    const point = offsetTrackPoint(sample, side * offset);
+    graphics.lineTo(point.x, point.y);
+  });
+  graphics.closePath();
+  graphics.stroke({
+    width,
+    color,
+    alpha,
+    join: 'round',
+    cap: 'round',
+  });
+}
+
+export function drawSegmentedOffsetStroke(graphics, track, {
+  side,
+  offset,
+  width,
+  color,
+  alpha = 1,
+  step = SEGMENTED_STROKE_STEP,
+  cap = 'round',
+}) {
+  const segments = getOffsetStrokeSegments(track, { side, offset, step });
+
+  segments.forEach((segment) => {
+    if (!segment.safe) return;
+    drawOffsetSegment(graphics, segment.start, segment.end, {
+      width,
+      color,
+      alpha,
+      cap,
+    });
+  });
+
+  getOffsetGapBridges(track, segments, width).forEach((bridge) => {
+    drawOffsetSegment(graphics, bridge.start, bridge.end, {
+      width,
+      color,
+      alpha,
+      cap: 'round',
+    });
+  });
+}
+
+export function addGrass(asset) {
+    const grass = new Graphics();
+    const padding = Math.max(asset.world.width, asset.world.height) * WORLD_BACKGROUND_PADDING_MULTIPLIER;
+    const bounds = {
+      x: -padding,
+      y: -padding,
+      width: asset.world.width + padding * 2,
+      height: asset.world.height + padding * 2,
+    };
+    grass.label = 'world-grass';
+    grass.worldGrassBounds = bounds;
+    grass.rect(
+      bounds.x,
+      bounds.y,
+      bounds.width,
+      bounds.height,
+    ).fill(GRASS_COLOR);
+    asset.container.addChild(grass);
+
+}
+
+export function addGravelRunoff(asset, track) {
+    const bands = getTrackMaterialBands(track);
+    const gravel = new Graphics();
+    gravel.label = 'track-gravel';
+    const gravelCenterOffset = (bands.gravel.inner + bands.gravel.outer) / 2;
+    const gravelWidth = bands.gravel.outer - bands.gravel.inner;
+
+    [-1, 1].forEach((side) => {
+      drawContinuousOffsetStroke(gravel, track, {
+        side,
+        offset: gravelCenterOffset,
+        width: gravelWidth,
+        color: GRAVEL_COLOR,
+        step: 4,
+      });
+    });
+    asset.container.addChild(gravel);
+
+    const runoff = new Graphics();
+    runoff.label = 'track-runoff';
+    const runoffCenterOffset = (bands.runoff.inner + bands.runoff.outer) / 2;
+    const runoffWidth = bands.runoff.outer - bands.runoff.inner;
+    [-1, 1].forEach((side) => {
+      drawContinuousOffsetStroke(runoff, track, {
+        side,
+        offset: runoffCenterOffset,
+        width: runoffWidth,
+        color: RUNOFF_GRASS_COLOR,
+        alpha: 0.82,
+        step: 4,
+      });
+    });
+    asset.container.addChild(runoff);
+
+}
+
+export function addBoundaryUnderlay(asset, track) {
+    const boundary = new Graphics();
+    [-1, 1].forEach((side) => {
+      drawContinuousOffsetStroke(boundary, track, {
+        side,
+        offset: track.width / 2 + OUTER_BOUNDARY_OFFSET,
+        width: OUTER_BOUNDARY_WIDTH,
+        color: 0x090a0d,
+        alpha: 0.64,
+        step: 2,
+      });
+    });
+
+    drawKerbStripes(asset, boundary, track, { clipUnsafeSegments: false });
+
+    [-1, 1].forEach((side) => {
+      drawContinuousOffsetStroke(boundary, track, {
+        side,
+        offset: track.width / 2 + EDGE_REVEAL_OFFSET,
+        width: EDGE_REVEAL_WIDTH,
+        color: 0xf8fafc,
+        alpha: 0.94,
+        step: 2,
+      });
+    });
+
+    asset.container.addChild(boundary);
+
+}
+
+export function addBarriers(asset, track) {
+    const barriers = new Graphics();
+    barriers.label = 'track-barriers';
+    const bands = getTrackMaterialBands(track);
+    const wallWidth = bands.barrier.width;
+    const offset = bands.barrier.center;
+    [-1, 1].forEach((side) => {
+      drawContinuousOffsetStroke(barriers, track, {
+        side,
+        offset,
+        width: wallWidth,
+        color: 0x171717,
+        alpha: 0.94,
+        step: 3,
+      });
+      drawContinuousOffsetStroke(barriers, track, {
+        side,
+        offset: offset - wallWidth * 0.7,
+        width: wallWidth * 0.35,
+        color: 0xf8fafc,
+        alpha: 0.42,
+        step: 3,
+      });
+    });
+    asset.container.addChild(barriers);
+
+}
+
+export function getTrackMaterialBands(track) {
+    const roadEdge = track.width / 2;
+    const kerbOuter = roadEdge + (track.kerbWidth ?? 0);
+    const gravelOuter = kerbOuter + track.gravelWidth;
+    const runoffOuter = gravelOuter + track.runoffWidth;
+    const barrierWidth = track.barrierWidth ?? BARRIER_WALL_WIDTH;
+    return {
+      road: { inner: -roadEdge, outer: roadEdge },
+      kerb: { inner: roadEdge, outer: kerbOuter },
+      gravel: { inner: kerbOuter, outer: gravelOuter },
+      runoff: { inner: gravelOuter, outer: runoffOuter },
+      barrier: {
+        inner: runoffOuter - barrierWidth / 2,
+        center: runoffOuter,
+        outer: runoffOuter + barrierWidth / 2,
+        width: barrierWidth,
+      },
+    };
+}
+
+export function drawKerbStripes(asset, kerbs, track, { clipUnsafeSegments }) {
+    const samples = track.samples.slice(0, -1);
+
+    for (let index = 0; index < samples.length; index += KERB_STEP) {
+      const sample = samples[index];
+      const next = samples[(index + KERB_STEP) % samples.length];
+      const curvature = Math.max(sample.curvature, next.curvature);
+      if (curvature < KERB_CURVATURE_THRESHOLD) continue;
+
+      const color = Math.floor(index / KERB_STEP) % 2 === 0 ? 0xe10600 : 0xf8fafc;
+      [-1, 1].forEach((side) => {
+        const offset = side * (track.width / 2 + KERB_OFFSET);
+        const start = offsetTrackPoint(sample, offset);
+        const end = offsetTrackPoint(next, offset);
+        if (clipUnsafeSegments && !offsetSegmentIsSafe(track, sample, next, start, end, offset)) return;
+        kerbs.moveTo(start.x, start.y);
+        kerbs.lineTo(end.x, end.y);
+        kerbs.stroke({
+          width: KERB_WIDTH,
+          color,
+          alpha: 1,
+          join: 'round',
+          cap: 'butt',
+        });
+      });
+    }
+
+}
+
+export function addMaskedMaterial(asset, { track, texture, strokeWidth, alpha, tileScale }) {
+    const sprite = new TilingSprite({
+      texture: textureOrWhite(texture),
+      width: asset.world.width,
+      height: asset.world.height,
+      tileScale,
+    });
+    sprite.alpha = alpha;
+
+    const mask = makeTrackPath(track);
+    mask.stroke({
+      width: strokeWidth,
+      color: 0xffffff,
+      alpha: 1,
+      join: 'round',
+      cap: 'butt',
+    });
+    mask.renderable = false;
+    sprite.mask = mask;
+    asset.container.addChild(sprite, mask);
+
+}
+
+export function addAsphalt(asset, track) {
+    const asphaltBase = makeTrackPath(track);
+    asphaltBase.label = 'track-asphalt';
+    asphaltBase.stroke({
+      width: track.width,
+      color: ASPHALT_COLOR,
+      alpha: 1,
+      join: 'round',
+      cap: 'butt',
+    });
+    asset.container.addChild(asphaltBase);
+
+    addMaskedMaterial(asset, {
+      track,
+      texture: asset.textures.asphalt,
+      strokeWidth: track.width,
+      alpha: 0.18,
+      tileScale: MATERIAL_TILE_SCALE.asphalt,
+    });
+
+
+}
+
+export function addBorders(asset, track) {
+    const borders = new Graphics();
+    borders.label = 'track-borders';
+
+    [-1, 1].forEach((side) => {
+      drawSegmentedOffsetStroke(borders, track, {
+        side,
+        offset: track.width / 2,
+        width: 5,
+        color: 0xf8fafc,
+        alpha: 0.86,
+        step: 4,
+      });
+
+      drawSegmentedOffsetStroke(borders, track, {
+        side,
+        offset: track.width / 2 + 15,
+        width: 7,
+        color: 0x090a0d,
+        alpha: 0.56,
+        step: 4,
+      });
+    });
+
+    asset.container.addChild(borders);
+
+}
+
+export function addKerbs(asset, track) {
+    const kerbs = new Graphics();
+    kerbs.label = 'track-kerbs';
+    drawKerbStripes(asset, kerbs, track, { clipUnsafeSegments: true });
+    asset.container.addChild(kerbs);
+
+}

package/src/rendering/track/trackRenderConstants.js

@@ -0,0 +1,38 @@
+import { metersToSimUnits } from '../../simulation/units.js';
+import { TRACK } from '../../simulation/track/trackConstants.js';
+
+export const MATERIAL_TILE_SCALE = {
+  asphalt: { x: 0.66, y: 0.66 },
+};
+export const WORLD_BACKGROUND_PADDING_MULTIPLIER = 8;
+export const GRASS_COLOR = 0x2e7d32;
+export const RUNOFF_GRASS_COLOR = 0x2f8a3a;
+export const GRAVEL_COLOR = 0xb49a68;
+export const ASPHALT_COLOR = 0x4a4d52;
+export const PIT_ASPHALT_COLOR = ASPHALT_COLOR;
+export const PIT_BOX_COLOR = 0x242831;
+export const PIT_LINE_COLOR = 0xf8fafc;
+export const PIT_SPEED_LINE_COLOR = 0xffd166;
+export const PIT_CONNECTOR_WIDTH = metersToSimUnits(12);
+export const PIT_EDGE_WIDTH = metersToSimUnits(0.35);
+export const EDGE_REVEAL_OFFSET = metersToSimUnits(0.35);
+export const EDGE_REVEAL_WIDTH = metersToSimUnits(0.5);
+export const OUTER_BOUNDARY_OFFSET = metersToSimUnits(1.1);
+export const OUTER_BOUNDARY_WIDTH = metersToSimUnits(0.75);
+export const BARRIER_WALL_WIDTH = TRACK.barrierWidth;
+export const KERB_OFFSET = metersToSimUnits(0.45);
+export const KERB_WIDTH = metersToSimUnits(1.25);
+export const FINISH_LINE_DEPTH = metersToSimUnits(8);
+export const FINISH_LINE_COLUMNS = 10;
+export const START_GRID_SLOT_COUNT = 20;
+export const START_GRID_SLOT_SPACING = metersToSimUnits(8);
+export const START_GRID_FIRST_DISTANCE = metersToSimUnits(-6);
+export const START_GRID_LATERAL_OFFSET = metersToSimUnits(3.2);
+export const START_GRID_BOX_LENGTH = metersToSimUnits(7);
+export const START_GRID_BOX_WIDTH = metersToSimUnits(3.2);
+export const SEGMENTED_STROKE_STEP = 2;
+export const KERB_STEP = 4;
+export const KERB_CURVATURE_THRESHOLD = 0.00038;
+export const OFFSET_SEGMENT_SAMPLE_COUNT = 7;
+export const NON_LOCAL_SAMPLE_STEP = 8;
+export const OFFSET_GAP_SAMPLE_COUNT = 4;

package/src/rendering/track/trackRenderGeometry.js

@@ -0,0 +1,94 @@
+import { Graphics, Texture } from 'pixi.js';
+import { offsetTrackPoint } from '../../simulation/trackModel.js';
+import { PIT_LINE_COLOR } from './trackRenderConstants.js';
+
+export function colorToNumber(color, fallback = PIT_LINE_COLOR) {
+  if (typeof color === 'number' && Number.isFinite(color)) return color;
+  if (typeof color !== 'string') return fallback;
+  const normalized = color.trim().replace(/^#/, '');
+  if (!/^[0-9a-f]{6}$/i.test(normalized)) return fallback;
+  return Number.parseInt(normalized, 16);
+}
+
+export function makeTrackPath(track, offset = 0) {
+  const path = new Graphics();
+  const samples = track.samples.slice(0, -1);
+  const first = offset === 0 ? samples[0] : offsetTrackPoint(samples[0], offset);
+  path.moveTo(first.x, first.y);
+
+  samples.slice(1).forEach((sample) => {
+    const point = offset === 0 ? sample : offsetTrackPoint(sample, offset);
+    path.lineTo(point.x, point.y);
+  });
+  path.closePath();
+
+  return path;
+}
+
+export function textureOrWhite(texture) {
+  return texture ?? Texture.WHITE;
+}
+
+export function destroyDisplayChildren(container) {
+  container.removeChildren().forEach((child) => {
+    child.destroy?.({ children: true, texture: false, textureSource: false });
+  });
+}
+
+export function arcDistance(track, first, second) {
+  const delta = Math.abs(first - second);
+  return Math.min(delta, track.length - delta);
+}
+
+export function interpolatedSegmentPoint(start, end, amount) {
+  return {
+    x: start.x + (end.x - start.x) * amount,
+    y: start.y + (end.y - start.y) * amount,
+  };
+}
+
+export function pointDistance(first, second) {
+  return Math.hypot(second.x - first.x, second.y - first.y);
+}
+
+export function drawPolyline(graphics, points, {
+  width,
+  color,
+  alpha = 1,
+  cap = 'round',
+  join = 'round',
+}) {
+  if (!Array.isArray(points) || points.length < 2) return;
+  graphics.moveTo(points[0].x, points[0].y);
+  points.slice(1).forEach((point) => {
+    graphics.lineTo(point.x, point.y);
+  });
+  graphics.stroke({
+    width,
+    color,
+    alpha,
+    cap,
+    join,
+  });
+}
+
+export function offsetVectorPoint(point, vector, amount) {
+  return {
+    x: point.x + vector.x * amount,
+    y: point.y + vector.y * amount,
+  };
+}
+
+export function createTeamPitGroupCorners(boxes) {
+  const ordered = [...boxes].sort((left, right) => left.index - right.index);
+  const first = ordered[0];
+  const last = ordered.at(-1);
+  if (!first || !last) return [];
+
+  return [
+    first.corners[0],
+    last.corners[1],
+    last.corners[2],
+    first.corners[3],
+  ];
+}

package/src/simulation/collisionGeometry.js

@@ -3,7 +3,7 @@ import {
   createVehicleGeometryState,
   getVehicleGeometryState,
   interpolateVehiclePose,
-} from './vehicleGeometry.js';
+} from './vehicle/vehicleGeometry.js';
 
 const DEFAULT_SWEEP_STEPS = 16;
 const BROADPHASE_PADDING = 0.001;

package/src/simulation/driver/driverControlConstants.js

@@ -0,0 +1,28 @@
+import { metersToSimUnits } from '../units.js';
+
+export const LANE_OFFSETS = [-8, -5.6, -3.2, 0, 3.2, 5.6, 8].map(metersToSimUnits);
+export const EDGE_RECOVERY_MIN_LOOKAHEAD = metersToSimUnits(28);
+export const LOOKAHEAD_BASE_DISTANCE = metersToSimUnits(52);
+export const LOOKAHEAD_MAX_DISTANCE = metersToSimUnits(115);
+export const BRAKING_LOOKAHEAD_MAX_DISTANCE = metersToSimUnits(560);
+export const TRAFFIC_GAP_AHEAD = metersToSimUnits(58);
+export const TRAFFIC_SIDE_GAP = metersToSimUnits(4.1);
+export const TRAFFIC_SIDE_OVERLAP = metersToSimUnits(4.6);
+export const TRAFFIC_REAR_WINDOW = metersToSimUnits(42);
+export const OVERTAKE_GAP_BASE = metersToSimUnits(26);
+export const OVERTAKE_GAP_AGGRESSION = metersToSimUnits(28);
+export const OVERTAKE_LATERAL_MIN = metersToSimUnits(2.4);
+export const OVERTAKE_LATERAL_REWARD = metersToSimUnits(1.35);
+export const PASS_SIDE_BASE = metersToSimUnits(3.4);
+export const PASS_SIDE_AGGRESSION = metersToSimUnits(4.6);
+export const DEFEND_REAR_GAP = metersToSimUnits(46);
+export const DEFEND_MIN_OFFSET = metersToSimUnits(2.4);
+export const LANE_EDGE_CLEARANCE_TARGET = metersToSimUnits(0.75);
+export const REJOIN_LOOKAHEAD_BASE = metersToSimUnits(56);
+export const REJOIN_LOOKAHEAD_MAX = metersToSimUnits(105);
+export const SAFETY_CAR_LOOKAHEAD_MIN = metersToSimUnits(24);
+export const SAFETY_CAR_LOOKAHEAD_MAX = metersToSimUnits(48);
+export const CURVATURE_LOOKAHEAD_SAMPLES = 5;
+export const PREVIEW_CURVATURE_CAP = 0.00115;
+export const REJOIN_HOLD_FRAMES = 150;
+export const OVERTAKE_COMMIT_FRAMES = 150;

package/src/simulation/driver/driverController.js

@@ -0,0 +1,47 @@
+import { REJOIN_HOLD_FRAMES } from './driverControlConstants.js';
+import { createDriverInput } from './driverInput.js';
+import { decideRacingControls } from './racingControls.js';
+import { decideRejoinControls } from './rejoinControls.js';
+import { shouldContinueRejoinRecovery } from './edgeRecovery.js';
+import { decideSafetyCarControls } from './safetyCarControls.js';
+import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+
+export function decideDriverControls({ car, orderIndex, race }) {
+  if (car.manualControls) return car.manualControls;
+
+  if (car.gridLocked) {
+    return createDriverInput().brake(1).controls();
+  }
+
+  if (race.safetyCar.deployed) {
+    return decideSafetyCarControls(car, orderIndex, race);
+  }
+
+  if (!car.trackState.onTrack) {
+    car.rejoinRecoveryFrames = REJOIN_HOLD_FRAMES;
+    car.attackCommitmentFrames = 0;
+    return decideRejoinControls(car, race);
+  }
+
+  if (shouldStabilizeSimulatorCar(car, race)) {
+    car.rejoinRecoveryFrames = Math.max(car.rejoinRecoveryFrames ?? 0, Math.floor(REJOIN_HOLD_FRAMES * 0.45));
+    car.attackCommitmentFrames = 0;
+    return decideRejoinControls(car, race);
+  }
+
+  if (shouldContinueRejoinRecovery(car, race)) {
+    return decideRejoinControls(car, race);
+  }
+
+  return decideRacingControls(car, orderIndex, race);
+}
+
+function shouldStabilizeSimulatorCar(car, race) {
+  if (race.physicsMode !== 'simulator') return false;
+  const gripUsage = car.gripUsage ?? 0;
+  const slipAngle = Math.abs(car.slipAngleRadians ?? 0);
+  const edgeDistance = race.track.width / 2 - VEHICLE_LIMITS.carWidth * 2.25;
+  const nearEdge = (car.trackState?.crossTrackError ?? 0) > edgeDistance;
+  const unstable = car.stabilityState === 'spin-risk' || gripUsage > 1.25 || slipAngle > 0.24;
+  return unstable && (nearEdge || slipAngle > 0.34 || gripUsage > 1.7);
+}

package/src/simulation/driver/driverInput.js

@@ -0,0 +1,28 @@
+import { clamp } from '../simMath.js';
+import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+
+export function createDriverInput() {
+  const state = {
+    steering: 0,
+    throttle: 0,
+    brake: 0,
+  };
+
+  return {
+    steer(amount) {
+      state.steering = clamp(amount, -VEHICLE_LIMITS.maxSteer, VEHICLE_LIMITS.maxSteer);
+      return this;
+    },
+    accelerate(amount) {
+      state.throttle = clamp(amount, 0, 1);
+      return this;
+    },
+    brake(amount) {
+      state.brake = clamp(amount, 0, 1);
+      return this;
+    },
+    controls() {
+      return { ...state };
+    },
+  };
+}

package/src/simulation/driver/driverMath.js

@@ -0,0 +1,6 @@
+import { normalizeAngle } from '../simMath.js';
+
+export function angleToPoint(car, target) {
+  const angle = Math.atan2(target.y - car.y, target.x - car.x);
+  return normalizeAngle(angle - car.heading);
+}

package/src/simulation/driver/driverPersonality.js

@@ -0,0 +1,25 @@
+import { clamp, seededRange } from '../simMath.js';
+
+export function buildDriverPersonality(driver, index, racecraft, random) {
+  const numberSeed = Number(driver.driverNumber ?? index + 1);
+  const numberBias = (((Number.isFinite(numberSeed) ? numberSeed : index + 1) % 11) - 5) * 0.014;
+  const baseAggression = clamp(
+    driver.personality?.aggression ?? 0.36 + racecraft * 0.34 + numberBias + seededRange(random, -0.045, 0.045),
+    0.18,
+    0.88,
+  );
+
+  return {
+    baseAggression,
+    riskTolerance: clamp(
+      driver.personality?.riskTolerance ?? baseAggression * 0.72 + racecraft * 0.24 + seededRange(random, -0.04, 0.04),
+      0.12,
+      0.95,
+    ),
+    patience: clamp(
+      driver.personality?.patience ?? 0.72 - baseAggression * 0.36 + racecraft * 0.12 + seededRange(random, -0.05, 0.05),
+      0.18,
+      0.9,
+    ),
+  };
+}

package/src/simulation/driver/edgeRecovery.js

@@ -0,0 +1,48 @@
+import { clamp, normalizeAngle } from '../simMath.js';
+import { metersToSimUnits } from '../units.js';
+import { pointAt } from '../track/trackModel.js';
+import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+import { REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX } from './driverControlConstants.js';
+
+export function calculateTrackEdgeGuard(car, race) {
+  const simulatorMode = race.physicsMode === 'simulator';
+  const trackLimit = race.track.width / 2;
+  const halfCarWidth = VEHICLE_LIMITS.carWidth / 2;
+  const wholeCarOutsideLimit = trackLimit + halfCarWidth;
+  const softLimit = trackLimit - halfCarWidth * (simulatorMode ? 3.0 : 1.9);
+  const recoveryOffset = trackLimit - halfCarWidth * (simulatorMode ? 2.2 : 1.62);
+  const crossTrackError = car.trackState?.crossTrackError ?? 0;
+  const side = Math.sign(car.trackState?.signedOffset ?? 0);
+  const pressure = clamp(
+    (crossTrackError - softLimit) / Math.max(1, wholeCarOutsideLimit - softLimit),
+    0,
+    1,
+  );
+  const overLimitPressure = clamp(
+    (crossTrackError - wholeCarOutsideLimit) / Math.max(1, (race.track.kerbWidth ?? 0) + halfCarWidth),
+    0,
+    1,
+  );
+
+  return {
+    softLimit,
+    recoveryOffset,
+    pressure,
+    overLimitPressure,
+    side,
+  };
+}
+
+export function shouldContinueRejoinRecovery(car, race) {
+  const frames = Math.max(0, Math.floor(car.rejoinRecoveryFrames ?? 0));
+  if (frames <= 0) return false;
+
+  const lookahead = clamp(car.speed * 0.66 + REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX);
+  const targetBase = pointAt(race.track, car.progress + lookahead);
+  const headingError = Math.abs(normalizeAngle(targetBase.heading - car.heading));
+  const edgeBuffer = race.track.width / 2 - VEHICLE_LIMITS.carWidth * 1.35;
+  const stillUnsettled = car.trackState.crossTrackError > edgeBuffer || headingError > 0.34;
+
+  car.rejoinRecoveryFrames = stillUnsettled ? frames - 1 : 0;
+  return stillUnsettled;
+}