@inventure71/paddockjs 4.1.0 → 4.3.0

package/src/simulation/driver/racingDriverProfile.js

@@ -0,0 +1,48 @@
+import { clamp } from '../simMath.js';
+import { simUnitsToMeters } from '../units.js';
+
+const JUDGEMENT_WAVELENGTH_METERS = 180;
+const DISTANCE_PHASE_RATE = Math.PI * 2 / JUDGEMENT_WAVELENGTH_METERS;
+
+function finiteOr(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+
+function normalizedSkill(value, minimum, maximum, neutral) {
+  return clamp((finiteOr(value, neutral) - minimum) / (maximum - minimum), 0, 1);
+}
+
+// Input skills are DriverData's constructor values, not its 0..100 ratings.
+// Ability controls available precision/margin; willingness to risk it is a
+// separate personality input. This policy does not change physical grip.
+export function racingDriverProfile(car = {}) {
+  const pace = normalizedSkill(car.pace, 0.92, 1.08, 1);
+  const racecraft = normalizedSkill(car.racecraft, 0.62, 0.94, 0.78);
+  const ability = pace * 0.6 + racecraft * 0.4;
+  const consistency = normalizedSkill(car.consistency, 0.59, 0.91, 0.75);
+  const aggression = clamp(finiteOr(car.aggression, finiteOr(car.personality?.baseAggression, 0.5)), 0, 1);
+  const riskTolerance = clamp(finiteOr(car.personality?.riskTolerance, 0.5), 0, 1);
+  const risk = riskTolerance * 0.6 + aggression * 0.4;
+
+  // A continuous distance phase gives a bounded, zero-mean judgement error.
+  // It never advances RNG or introduces abrupt per-frame/sector decisions.
+  const distanceMeters = simUnitsToMeters(finiteOr(car.raceDistance, finiteOr(car.progress, 0)));
+  const phase = distanceMeters * DISTANCE_PHASE_RATE +
+    finiteOr(car.index, 0) * 0.73 + finiteOr(car.driverNumber, 0) * 0.31;
+  const precisionError = (1 - ability * 0.7) * (1 - consistency * 0.7);
+  const lineErrorMeters = 0.2 * precisionError * Math.sin(phase);
+  const judgementError = (1 - ability * 0.65) * (1 - consistency * 0.7) * risk;
+  const anticipationVariation = 0.025 * judgementError * Math.sin(phase + 1.7);
+
+  return {
+    ability,
+    consistency,
+    risk,
+    lateralShare: 0.74 + 0.2 * ability + 0.02 * risk,
+    longitudinalShare: 0.86 + 0.09 * ability + 0.03 * risk,
+    anticipationSeconds: 0.16 + 0.12 * (1 - ability) +
+      0.04 * (1 - consistency) - 0.04 * risk + anticipationVariation,
+    lineErrorMeters,
+    speedJudgementScale: 1 + 0.012 * judgementError * Math.sin(phase + 0.8),
+  };
+}

package/src/simulation/driver/racingLinePlan.js

@@ -2,7 +2,7 @@ import { clamp, TWO_PI } from '../simMath.js';
 import { kphToSimSpeed, metersToSimUnits, simSpeedToKph, simUnitsToMeters } from '../units.js';
 import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
 import { DEFEND_MIN_OFFSET, DEFEND_REAR_GAP, LANE_EDGE_CLEARANCE_TARGET, LANE_OFFSETS, OVERTAKE_COMMIT_FRAMES, OVERTAKE_GAP_AGGRESSION, OVERTAKE_GAP_BASE, OVERTAKE_LATERAL_MIN, OVERTAKE_LATERAL_REWARD, PASS_SIDE_AGGRESSION, PASS_SIDE_BASE, TRAFFIC_GAP_AHEAD, TRAFFIC_REAR_WINDOW, TRAFFIC_SIDE_GAP, TRAFFIC_SIDE_OVERLAP } from './driverControlConstants.js';
-import { findDefensiveThreat, findLaneTrafficAhead, findLaneTrafficBeside, scanNearbyTraffic } from './trafficScan.js';
+import { findDefensiveThreat, findLaneTrafficAhead, findLaneTrafficBeside, scanNearbyTraffic, mainTrackCenterOffset, followingSpeedFromTraffic, laneMovementBounds } from './trafficScan.js';
 
 export function planRacingLine(car, orderIndex, race) {
   const aggression = car.aggression ?? car.personality?.baseAggression ?? 0.5;
@@ -10,23 +10,35 @@ export function planRacingLine(car, orderIndex, race) {
   const trackLimit = race.track.width / 2 - VEHICLE_LIMITS.carWidth * clamp(1.55 - aggression * 0.28, 1.26, 1.55);
   const preferred = Math.sin((car.index / Math.max(1, race.cars.length)) * TWO_PI) * metersToSimUnits(1.1);
   const currentOffset = clamp(car.desiredOffset ?? preferred, -trackLimit, trackLimit);
-  const ahead = race.orderedCars[orderIndex - 1];
   const traffic = scanNearbyTraffic(car, race);
-  const rearThreat = findDefensiveThreat(traffic);
-  const attackPlan = planAttackCommitment(car, ahead, traffic, trackLimit, aggression, race);
+  const corridorLimit = race.track.width / 2 + VEHICLE_LIMITS.carWidth / 2;
+  let aheadEntry = null;
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
+    if (Math.abs(entry.signedOffset) > corridorLimit) continue;
+    if (entry.gap > 0 && (!aheadEntry || entry.gap < aheadEntry.gap)) aheadEntry = entry;
+  }
+  const ahead = aheadEntry?.car;
+  const aheadGap = aheadEntry?.gap ?? Infinity;
+  const rearThreat = findDefensiveThreat(traffic, corridorLimit, car);
+  const attackPlan = planAttackCommitment(car, ahead, traffic, trackLimit, aggression, aheadGap);
 
   let bestOffset = currentOffset;
   let bestScore = -Infinity;
 
-  LANE_OFFSETS.forEach((rawOffset) => {
-    const offset = clamp(rawOffset, -trackLimit, trackLimit);
+  for (let laneIndex = 0; laneIndex < LANE_OFFSETS.length; laneIndex += 1) {
+    const offset = clamp(LANE_OFFSETS[laneIndex], -trackLimit, trackLimit);
     const edgeClearance = trackLimit - Math.abs(offset);
     let score = 80;
     score -= Math.abs(offset - preferred) * 0.18;
     score -= Math.abs(offset - currentOffset) * (0.09 - aggression * 0.025);
     score -= Math.max(0, LANE_EDGE_CLEARANCE_TARGET - edgeClearance) * (0.92 - aggression * 0.42);
 
-    traffic.forEach((entry) => {
+    for (let trafficIndex = 0; trafficIndex < traffic.length; trafficIndex += 1) {
+      const entry = traffic[trafficIndex];
+      // Separate pit/runoff traffic cannot be an overtaking opportunity or
+      // defensive target. Keep it in the scan for genuine overlapping lanes.
+      if (Math.abs(entry.signedOffset) > corridorLimit) continue;
       const lateral = Math.abs(entry.signedOffset - offset);
       if (entry.gap > 0 && entry.gap < TRAFFIC_GAP_AHEAD) {
         const overlapRisk = clamp(TRAFFIC_SIDE_OVERLAP - lateral, 0, TRAFFIC_SIDE_OVERLAP);
@@ -38,24 +50,26 @@ export function planRacingLine(car, orderIndex, race) {
         const sideOverlapRisk = clamp(TRAFFIC_SIDE_OVERLAP - lateral, 0, TRAFFIC_SIDE_OVERLAP);
         score -= sideOverlapRisk * (TRAFFIC_SIDE_OVERLAP + entry.gap) * 0.052 * (1 - riskTolerance * 0.22);
       }
-    });
+    }
 
-    if (ahead && car.gapAhead < TRAFFIC_GAP_AHEAD) {
+    if (ahead && aheadGap < TRAFFIC_GAP_AHEAD) {
       const passSide = attackPlan?.targetOffset ?? clamp(
-        (ahead.trackState.signedOffset * -0.65) + (car.index % 2 === 0 ? -1 : 1) * (PASS_SIDE_BASE + aggression * PASS_SIDE_AGGRESSION),
+        (mainTrackCenterOffset(ahead) * -0.65) + (car.index % 2 === 0 ? -1 : 1) * (PASS_SIDE_BASE + aggression * PASS_SIDE_AGGRESSION),
         -trackLimit,
         trackLimit,
       );
       const attackPressure = attackPlan?.pressure ?? 0.45;
       score -= Math.abs(offset - passSide) * (0.12 + aggression * 0.16) * attackPressure;
-      if (attackPlan && Math.sign(offset || passSide) === attackPlan.side && Math.abs(offset - ahead.trackState.signedOffset) > OVERTAKE_LATERAL_MIN) {
+      if (attackPlan && Math.sign(offset || passSide) === attackPlan.side && Math.abs(offset - mainTrackCenterOffset(ahead)) > OVERTAKE_LATERAL_MIN) {
         score += metersToSimUnits(4 + aggression * 5) * attackPressure;
       }
     }
 
     const defenseIntensity = clamp((aggression - 0.5) / 0.3, 0, 1) *
       clamp((Math.max(riskTolerance, aggression) - 0.42) / 0.4, 0, 1);
-    if (rearThreat && defenseIntensity > 0.04) {
+    // A pass needs a stable lane; reactive defense must not steer across the
+    // committed attacking line while the car is still passing its target.
+    if (rearThreat && !attackPlan && defenseIntensity > 0.04) {
       const threatSide = Math.sign(rearThreat.signedOffset || currentOffset || (car.index % 2 === 0 ? 1 : -1));
       const defendOffset = clamp(
         threatSide * Math.max(Math.abs(rearThreat.signedOffset) + metersToSimUnits(0.8), DEFEND_MIN_OFFSET),
@@ -73,17 +87,21 @@ export function planRacingLine(car, orderIndex, race) {
       bestScore = score;
       bestOffset = offset;
     }
-  });
+  }
 
   const laneChangeRate = metersToSimUnits(0.95 + car.racecraft * 0.32 + aggression * 0.78);
   car.desiredOffset = currentOffset + clamp(bestOffset - currentOffset, -laneChangeRate, laneChangeRate);
 
+  const movement = laneMovementBounds(traffic, mainTrackCenterOffset(car));
   return {
     offset: car.desiredOffset,
+    minimumOffset: movement.minimum,
+    maximumOffset: movement.maximum,
     sameLaneAhead: findLaneTrafficAhead(traffic, car.desiredOffset, TRAFFIC_GAP_AHEAD),
-    actualLaneAhead: findLaneTrafficAhead(traffic, car.trackState?.signedOffset ?? car.desiredOffset, TRAFFIC_GAP_AHEAD),
+    actualLaneAhead: findLaneTrafficAhead(traffic, mainTrackCenterOffset(car), TRAFFIC_GAP_AHEAD),
     sideRisk: findLaneTrafficBeside(traffic, car.desiredOffset),
     attackCommitted: Boolean(attackPlan),
+    followingSpeed: followingSpeedFromTraffic(car, traffic),
   };
 }
 
@@ -105,20 +123,20 @@ export function calculateActualOverlapPenalty(car, entry) {
   return clamp(urgent, 0, 72);
 }
 
-export function planAttackCommitment(car, ahead, traffic, trackLimit, aggression, race) {
+export function planAttackCommitment(car, ahead, traffic, trackLimit, aggression, aheadGap = car.gapAhead) {
   const existingFrames = Math.max(0, Math.floor(car.attackCommitmentFrames ?? 0));
   const relativeSpeed = ahead ? car.speed - ahead.speed : 0;
   const closeEnough = ahead &&
-    car.gapAhead > 0 &&
-    car.gapAhead < OVERTAKE_GAP_BASE + aggression * OVERTAKE_GAP_AGGRESSION + metersToSimUnits(28);
+    aheadGap > 0 &&
+    aheadGap < OVERTAKE_GAP_BASE + aggression * OVERTAKE_GAP_AGGRESSION + metersToSimUnits(28);
   const speedPressure = clamp(relativeSpeed / kphToSimSpeed(34), -0.4, 1);
 
   if (closeEnough && speedPressure > -0.15) {
-    const aheadOffset = ahead.trackState?.signedOffset ?? 0;
+    const aheadOffset = mainTrackCenterOffset(ahead);
     const currentSide = Math.sign(car.attackSide ?? 0);
     const blockedCommitment = currentSide &&
       Math.sign(aheadOffset || currentSide) === currentSide &&
-      Math.abs(aheadOffset - (car.trackState?.signedOffset ?? 0)) < TRAFFIC_SIDE_GAP &&
+      Math.abs(aheadOffset - mainTrackCenterOffset(car)) < TRAFFIC_SIDE_GAP &&
       Math.abs(aheadOffset) > trackLimit * 0.55;
 
     if (!existingFrames || !currentSide || blockedCommitment) {
@@ -140,7 +158,7 @@ export function planAttackCommitment(car, ahead, traffic, trackLimit, aggression
   if (!side || !ahead) return null;
 
   const targetOffset = clamp(
-    (ahead.trackState?.signedOffset ?? 0) + side * (PASS_SIDE_BASE + aggression * PASS_SIDE_AGGRESSION + metersToSimUnits(2.4)),
+    mainTrackCenterOffset(ahead) + side * (PASS_SIDE_BASE + aggression * PASS_SIDE_AGGRESSION + metersToSimUnits(2.4)),
     -trackLimit,
     trackLimit,
   );
@@ -164,3 +182,19 @@ export function chooseFreerAttackSide(traffic, preferredSide) {
   }, side === preferredSide ? 0.18 : 0);
   return sideScore(1) >= sideScore(-1) ? 1 : -1;
 }
+
+export function calculateRacingTrafficPenalty(car, lanePlan) {
+  const actualLaneLateral = lanePlan.actualLaneAhead
+    ? Math.abs(lanePlan.actualLaneAhead.signedOffset - mainTrackCenterOffset(car))
+    : Infinity;
+  const plannedPassingOverlap = lanePlan.attackCommitted && lanePlan.sameLaneAhead
+    ? Math.abs(lanePlan.sameLaneAhead.signedOffset - mainTrackCenterOffset(car)) > OVERTAKE_LATERAL_MIN
+    : false;
+  return Math.max(
+    lanePlan.sameLaneAhead ? calculatePlannedTrafficPenalty(lanePlan.sameLaneAhead, plannedPassingOverlap) : 0,
+    lanePlan.actualLaneAhead && actualLaneLateral < OVERTAKE_LATERAL_MIN
+      ? calculateActualOverlapPenalty(car, lanePlan.actualLaneAhead)
+      : 0,
+    lanePlan.sideRisk ? clamp(simUnitsToMeters(TRAFFIC_SIDE_GAP - lanePlan.sideRisk.lateral) * 0.78, 0, 30) : 0,
+  );
+}

package/src/simulation/driver/rejoinControls.js

@@ -1,116 +1,78 @@
 import { clamp } from '../simMath.js';
-import { kphToSimSpeed, simUnitsToMeters } from '../units.js';
+import { kphToSimSpeed, simUnitsToMeters, metersToSimUnits } from '../units.js';
 import { offsetTrackPoint, pointAt } from '../track/trackModel.js';
 import { REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX } from './driverControlConstants.js';
 import { angleToPoint } from './driverMath.js';
 import { createDriverInput } from './driverInput.js';
-import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+import { VEHICLE_LIMITS, isSimulatorPhysicsMode, tirePerformanceFactor } from '../vehicle/vehiclePhysics.js';
+import { advancedLateralAccelerationLimit } from '../vehicle/advancedTireForces.js';
+import { advancedSteeringToPoint, advancedSpeedControls } from './advancedPathControls.js';
 import { analyzeTrackEdgeMotion } from './recoveryDynamics.js';
 
 export function decideRejoinControls(car, race) {
-  if (race.physicsMode === 'advanced') {
+  if (isSimulatorPhysicsMode(race.physicsMode)) {
     return decideSimulatorRejoinControls(car, race);
   }
   return decideArcadeRejoinControls(car, race);
 }
 
-export function decideArcadeRejoinControls(car, race) {
-  return decideRejoinControlsForMode(car, race, {
-    simulatorMode: false,
-    inwardOffsetRatio: 0.34,
-    surfaceTargetSpeeds: {
-      track: 88,
-      kerb: 72,
-      gravel: 56,
-      grass: 48,
-      barrier: 34,
-    },
-    lowSpeedRecovery: {
-      barrier: 0.34,
-      default: 0.18,
-    },
-    throttleLimits: {
-      barrier: 0.68,
-      gravel: 0.46,
-      grass: 0.42,
-      default: 0.42,
-    },
-    brakeResponseKph: 30,
-    onTrackBrakeLimit: 0.46,
-    offTrackBrakeLimit: 0.74,
-    steerGain: 1.65,
-    outwardBrakeStartMps: 1.2,
-    outwardBrakeGain: 0.08,
-    misalignmentBrakeGain: 0.06,
-    slideThrottleDamping: 0.36,
-    offTrackForwardTargetScale: 0.42,
-    lowSpeedForwardTargetScale: 0,
-    lowSpeedOffTrackSteerLimit: 0.52,
-    lowSpeedRecoveryThrottle: 0.32,
-    lowSpeedOutwardBrakeStartMps: 1.2,
-    lowSpeedCrawlOutwardToleranceMps: 0,
-    lowSpeedHeadingOutwardThrottleLimit: 1,
-    stabilizeLowSpeedOutward: false,
-    stabilizeRejoinHoldOutsideRoad: false,
-    unsettledScale: () => 1,
-  });
-}
+const ARCADE_REJOIN_PROFILE = {
+  inwardOffsetRatio: 0.34,
+  surfaceTargetSpeeds: {
+    track: 88,
+    kerb: 72,
+    gravel: 56,
+    grass: 48,
+    barrier: 34,
+  },
+  lowSpeedRecovery: {
+    barrier: 0.34,
+    default: 0.18,
+  },
+  throttleLimits: {
+    barrier: 0.68,
+    gravel: 0.46,
+    grass: 0.42,
+    default: 0.42,
+  },
+  brakeResponseKph: 30,
+  onTrackBrakeLimit: 0.46,
+  offTrackBrakeLimit: 0.74,
+  steerGain: 1.65,
+  outwardBrakeStartMps: 1.2,
+  outwardBrakeGain: 0.08,
+  misalignmentBrakeGain: 0.06,
+  slideThrottleDamping: 0.36,
+  offTrackForwardTargetScale: 0.42,
+  lowSpeedForwardTargetScale: 0,
+  lowSpeedOffTrackSteerLimit: 0.52,
+  lowSpeedRecoveryThrottle: 0.32,
+};
 
 export function decideSimulatorRejoinControls(car, race) {
-  return decideRejoinControlsForMode(car, race, {
-    simulatorMode: true,
-    inwardOffsetRatio: 0.24,
-    surfaceTargetSpeeds: {
-      track: 78,
-      kerb: 58,
-      gravel: 62,
-      grass: 52,
-      barrier: 22,
-    },
-    lowSpeedRecovery: {
-      barrier: 0.42,
-      default: 0.36,
-    },
-    throttleLimits: {
-      barrier: 0.5,
-      gravel: 0.82,
-      grass: 0.76,
-      default: 0.52,
-    },
-    brakeResponseKph: 24,
-    onTrackBrakeLimit: 0.34,
-    offTrackBrakeLimit: 0.24,
-    steerGain: 0.94,
-    outwardBrakeStartMps: 0.45,
-    outwardBrakeGain: 0.12,
-    misalignmentBrakeGain: 0.08,
-    slideThrottleDamping: 0.62,
-    offTrackForwardTargetScale: 0.32,
-    lowSpeedForwardTargetScale: 0.22,
-    lowSpeedOffTrackSteerLimit: 0.68,
-    lowSpeedRecoveryThrottle: 0.68,
-    lowSpeedOutwardBrakeStartMps: 0.24,
-    lowSpeedCrawlOutwardToleranceMps: 0.42,
-    lowSpeedHeadingOutwardThrottleLimit: 0.24,
-    stabilizeLowSpeedOutward: true,
-    stabilizeRejoinHoldOutsideRoad: true,
-    unsettledScale: (entry) => clamp(
-      1 - Math.max(0, (entry.gripUsage ?? 0) - 0.55) * 0.75 - Math.abs(entry.slipAngleRadians ?? 0) * 1.65,
-      0.22,
-      1,
-    ),
-  });
+  const speed = simUnitsToMeters(car.speed);
+  if (Math.abs(car.slipAngleRadians ?? 0) > 0.5 && speed > 2) {
+    // Once the car is sliding sideways/backwards, path steering cannot recover
+    // its line. Arrest the slide before requesting a forward rejoin.
+    return createDriverInput().brake(1).controls();
+  }
+  const target = pointAt(race.track, car.progress + metersToSimUnits(clamp(10 + speed * 0.5, 10, 30)));
+  const { steering, curvature } = advancedSteeringToPoint(car, target);
+  const capacity = advancedLateralAccelerationLimit(car, speed, tirePerformanceFactor(car.tireEnergy ?? 100));
+  const surfaceSpeed = car.trackState.onTrack ? 22 : 12;
+  const targetSpeed = Math.min(surfaceSpeed, Math.sqrt(capacity * 0.55 / Math.max(Math.abs(curvature), 0.001)));
+  const { throttle, brake } = advancedSpeedControls(car, targetSpeed);
+  return createDriverInput().steer(steering).accelerate(throttle).brake(brake).controls();
 }
 
-function decideRejoinControlsForMode(car, race, profile) {
-  const simulatorMode = race.physicsMode === 'advanced';
-  const lookahead = clamp(car.speed * (profile.simulatorMode ? 0.58 : 0.72) + REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX);
+export function decideArcadeRejoinControls(car, race) {
+  const profile = ARCADE_REJOIN_PROFILE;
+  const lookahead = clamp(car.speed * 0.72 + REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX);
   const edgeMotion = analyzeTrackEdgeMotion(car, race);
   const lowSpeedOffTrack = !car.trackState.onTrack && car.speed < kphToSimSpeed(24);
   const distanceFromRoadMeters = simUnitsToMeters(Math.max(0, car.trackState.crossTrackError - race.track.width / 2));
-  const inRejoinHold = (car.rejoinRecoveryFrames ?? 0) > 0;
   const recoveringOutsideRoad = distanceFromRoadMeters > 0.25 &&
-    (!car.trackState.onTrack || (profile.stabilizeRejoinHoldOutsideRoad && inRejoinHold));
+    !car.trackState.onTrack;
   const offTrackTargetScale = lowSpeedOffTrack
     ? profile.lowSpeedForwardTargetScale
     : profile.offTrackForwardTargetScale;
@@ -145,26 +107,17 @@ function decideRejoinControlsForMode(car, race, profile) {
   const lowSpeedRecovery = car.speed < kphToSimSpeed(18)
     ? car.trackState.surface === 'barrier' ? profile.lowSpeedRecovery.barrier : profile.lowSpeedRecovery.default
     : 0;
-  const outwardBrakeStart = lowSpeedOffTrack
-    ? profile.lowSpeedOutwardBrakeStartMps
-    : profile.outwardBrakeStartMps;
-  const canCrawlSteerRecovery = lowSpeedOffTrack &&
-    car.speed < kphToSimSpeed(8) &&
-    edgeMotion.outwardSpeedMps < profile.lowSpeedCrawlOutwardToleranceMps;
+  const outwardBrakeStart = profile.outwardBrakeStartMps;
   const needsOutwardStabilization = recoveringOutsideRoad &&
-    (!lowSpeedOffTrack || profile.stabilizeLowSpeedOutward) &&
-    !canCrawlSteerRecovery &&
+    !lowSpeedOffTrack &&
     edgeMotion.outwardSpeedMps > outwardBrakeStart &&
     distanceFromRoadMeters > 0.25;
-  const recoveryThrottleFloorBase = profile.simulatorMode && !car.trackState.onTrack
-    ? (car.trackState.surface === 'barrier' ? profile.lowSpeedRecovery.barrier : profile.lowSpeedRecovery.default)
-    : lowSpeedRecovery;
   const lowSpeedRecoveryThrottle = lowSpeedOffTrack && car.trackState.surface !== 'barrier'
     ? profile.lowSpeedRecoveryThrottle
     : 0;
   const recoveryThrottleFloor = needsOutwardStabilization
     ? 0
-    : Math.max(recoveryThrottleFloorBase, lowSpeedRecoveryThrottle);
+    : Math.max(lowSpeedRecovery, lowSpeedRecoveryThrottle);
   const surfaceThrottleLimit = car.trackState.surface === 'barrier'
     ? profile.throttleLimits.barrier
     : car.trackState.surface === 'gravel'
@@ -172,9 +125,6 @@ function decideRejoinControlsForMode(car, race, profile) {
       : car.trackState.surface === 'grass'
         ? profile.throttleLimits.grass
         : profile.throttleLimits.default;
-  const throttleLimit = lowSpeedOffTrack && edgeMotion.headingOutward && distanceFromRoadMeters > 0.5
-    ? Math.min(surfaceThrottleLimit, profile.lowSpeedHeadingOutwardThrottleLimit)
-    : surfaceThrottleLimit;
   let brakeAmount = speedError < -kphToSimSpeed(5)
     ? clamp(Math.abs(speedError) / kphToSimSpeed(profile.brakeResponseKph), 0.04, car.trackState.onTrack ? profile.onTrackBrakeLimit : profile.offTrackBrakeLimit)
     : 0;
@@ -189,9 +139,6 @@ function decideRejoinControlsForMode(car, race, profile) {
       ),
     );
   }
-  const unsettledScale = lowSpeedOffTrack
-    ? Math.max(profile.unsettledScale(car), 0.82)
-    : profile.unsettledScale(car);
   const slideThrottleScale = 1 - clamp(
     Math.max(0, edgeMotion.outwardSpeedMps - profile.outwardBrakeStartMps) * profile.slideThrottleDamping +
       Math.max(0, Math.abs(angleError) - 1.25) * 0.22,
@@ -206,8 +153,8 @@ function decideRejoinControlsForMode(car, race, profile) {
   return createDriverInput()
     .steer(steeringRequest)
     .accelerate(brakeAmount > 0.05 ? 0 : speedError > 0
-      ? clamp(((speedError / kphToSimSpeed(24)) * alignment + recoveryThrottleFloor) * unsettledScale * slideThrottleScale, minimumAcceleration, throttleLimit)
-      : recoveryThrottleFloor * unsettledScale * slideThrottleScale)
+      ? clamp(((speedError / kphToSimSpeed(24)) * alignment + recoveryThrottleFloor) * slideThrottleScale, minimumAcceleration, surfaceThrottleLimit)
+      : recoveryThrottleFloor * slideThrottleScale)
     .brake(brakeAmount)
     .controls();
 }

package/src/simulation/driver/safetyCarControls.js

@@ -4,8 +4,14 @@ import { offsetTrackPoint, pointAt } from '../track/trackModel.js';
 import { SAFETY_CAR_LOOKAHEAD_MAX, SAFETY_CAR_LOOKAHEAD_MIN } from './driverControlConstants.js';
 import { angleToPoint } from './driverMath.js';
 import { createDriverInput } from './driverInput.js';
+import { isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
+import { advancedSteeringToPoint, advancedSpeedControls } from './advancedPathControls.js';
+import { decideSimulatorRejoinControls } from './rejoinControls.js';
 
 export function decideSafetyCarControls(car, orderIndex, race) {
+  if (isSimulatorPhysicsMode(race.physicsMode) && !car.trackState.onTrack) {
+    return decideSimulatorRejoinControls(car, race);
+  }
   const queueSlot = race.safetyCar.progress - race.rules.safetyCarLeadDistance - orderIndex * race.rules.safetyCarGap;
   const lookahead = clamp(car.speed * 0.55 + metersToSimUnits(20), SAFETY_CAR_LOOKAHEAD_MIN, SAFETY_CAR_LOOKAHEAD_MAX);
   const targetBase = pointAt(race.track, car.progress + lookahead);
@@ -27,6 +33,12 @@ export function decideSafetyCarControls(car, orderIndex, race) {
   );
   const speedError = desiredSpeed - car.speed;
 
+  if (isSimulatorPhysicsMode(race.physicsMode)) {
+    const { steering } = advancedSteeringToPoint(car, target);
+    const { throttle, brake } = advancedSpeedControls(car, simUnitsToMeters(desiredSpeed));
+    return createDriverInput().steer(steering).accelerate(throttle).brake(brake).controls();
+  }
+
   return createDriverInput()
     .steer(angleToPoint(car, target) * 1.18 + headingError * 0.32 + centerlineCorrection)
     .accelerate(speedError > kphToSimSpeed(1) ? clamp(speedError / kphToSimSpeed(16), 0, 0.5) : 0)

package/src/simulation/driver/trafficScan.js

@@ -1,26 +1,50 @@
-import { metersToSimUnits } from '../units.js';
-import { DEFEND_REAR_GAP, TRAFFIC_GAP_AHEAD, TRAFFIC_SIDE_GAP, TRAFFIC_REAR_WINDOW } from './driverControlConstants.js';
+import { metersToSimUnits, simUnitsToMeters, TOP_SPEED_SIM_UNITS_PER_SECOND } from '../units.js';
+import { DEFEND_REAR_GAP, TRAFFIC_SIDE_GAP, TRAFFIC_GAP_AHEAD } from './driverControlConstants.js';
 import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+import { canCollide } from '../participants/participantInteractions.js';
+import { signedLateralOffsetToPoint } from '../track/trackMath.js';
+
+const TRAFFIC_REAR_SCAN_WINDOW = metersToSimUnits(39);
+const TRAFFIC_FORWARD_SCAN_WINDOW = metersToSimUnits(134);
+const TRAFFIC_BESIDE_WINDOW = metersToSimUnits(28);
+
+// Entries are reused across calls: drivers consume the scan synchronously
+// within a single control decision, so a module-level pool avoids re-allocating
+// the candidate list for every car on every step.
+const TRAFFIC_SCRATCH = [];
+const TRAFFIC_ENTRY_POOL = [];
 
 export function scanNearbyTraffic(car, race) {
-  return race.cars
-    .filter((other) => other !== car)
-    .map((other) => ({
-      car: other,
-      gap: other.raceDistance - car.raceDistance,
-      signedOffset: other.trackState?.signedOffset ?? 0,
-      speed: other.speed,
-    }))
-    .filter((entry) => entry.gap > -metersToSimUnits(39) && entry.gap < metersToSimUnits(134));
-}
-
-export function findDefensiveThreat(traffic) {
+  const traffic = TRAFFIC_SCRATCH;
+  traffic.length = 0;
+  const cars = race.cars;
+  for (let index = 0; index < cars.length; index += 1) {
+    const other = cars[index];
+    if (other === car || !canCollide(car, other)) continue;
+    const gap = physicalTrafficGap(car, other, race.track?.length);
+    if (gap <= -TRAFFIC_REAR_SCAN_WINDOW || gap >= TRAFFIC_FORWARD_SCAN_WINDOW) continue;
+    const entry = TRAFFIC_ENTRY_POOL[traffic.length] ??= { car: null, gap: 0, signedOffset: 0, speed: 0 };
+    entry.car = other;
+    entry.gap = gap;
+    entry.signedOffset = mainTrackCenterOffset(other);
+    entry.speed = other.speed;
+    traffic.push(entry);
+  }
+  return traffic;
+}
+
+export function findDefensiveThreat(traffic, corridorLimit = Infinity, car = null) {
   let closest = null;
 
-  traffic.forEach((entry) => {
-    if (entry.gap >= -VEHICLE_LIMITS.carLength * 1.1 || entry.gap < -DEFEND_REAR_GAP) return;
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
+    if (Math.abs(entry.signedOffset) > corridorLimit) continue;
+    // A physically rearward car with greater race distance is lapping us.
+    // Yield ordinary road space instead of treating it as a position threat.
+    if (car && entry.car.raceDistance > car.raceDistance) continue;
+    if (entry.gap >= -VEHICLE_LIMITS.carLength * 1.1 || entry.gap < -DEFEND_REAR_GAP) continue;
     if (!closest || entry.gap > closest.gap) closest = entry;
-  });
+  }
 
   return closest;
 }
@@ -28,24 +52,109 @@ export function findDefensiveThreat(traffic) {
 export function findLaneTrafficAhead(traffic, offset, maxDistance) {
   let closest = null;
 
-  traffic.forEach((entry) => {
-    if (entry.gap <= 0 || entry.gap > maxDistance) return;
-    if (Math.abs(entry.signedOffset - offset) > TRAFFIC_SIDE_GAP) return;
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
+    if (entry.gap <= 0 || entry.gap > maxDistance) continue;
+    if (Math.abs(entry.signedOffset - offset) > TRAFFIC_SIDE_GAP) continue;
     if (!closest || entry.gap < closest.gap) closest = entry;
-  });
+  }
 
   return closest;
 }
 
 export function findLaneTrafficBeside(traffic, offset) {
   let closest = null;
+  let closestLateral = 0;
+  let closestRisk = -Infinity;
 
-  traffic.forEach((entry) => {
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
     const lateral = Math.abs(entry.signedOffset - offset);
-    if (Math.abs(entry.gap) > metersToSimUnits(28) || lateral > TRAFFIC_SIDE_GAP) return;
-    const risk = (metersToSimUnits(28) - Math.abs(entry.gap)) + (TRAFFIC_SIDE_GAP - lateral);
-    if (!closest || risk > closest.risk) closest = { ...entry, lateral, risk };
-  });
+    if (Math.abs(entry.gap) > TRAFFIC_BESIDE_WINDOW || lateral > TRAFFIC_SIDE_GAP) continue;
+    const risk = (TRAFFIC_BESIDE_WINDOW - Math.abs(entry.gap)) + (TRAFFIC_SIDE_GAP - lateral);
+    if (!closest || risk > closestRisk) {
+      closest = entry;
+      closestLateral = lateral;
+      closestRisk = risk;
+    }
+  }
 
-  return closest;
+  return closest ? { ...closest, lateral: closestLateral, risk: closestRisk } : null;
+}
+
+// Race classification distance can differ by whole laps while the cars occupy
+// the same piece of road. Keep traffic in the local, signed circuit frame.
+export function physicalTrafficGap(car, other, trackLength) {
+  if (!(trackLength > 0)) return other.raceDistance - car.raceDistance;
+  let gap = ((other.progress ?? other.raceDistance) - (car.progress ?? car.raceDistance)) % trackLength;
+  if (gap > trackLength / 2) gap -= trackLength;
+  else if (gap < -trackLength / 2) gap += trackLength;
+  return gap;
+}
+
+export function mainTrackCenterOffset(car) {
+  // Pit surfaces retain the chassis offset in the main-track frame. Ordinary
+  // signedOffset describes an outer wheel, so project the center instead.
+  const state = car.trackState;
+  if (state?.mainTrackSignedOffset != null) return state.mainTrackSignedOffset;
+  const projected = state ? signedLateralOffsetToPoint(state, car) : NaN;
+  return Number.isFinite(projected) ? projected : state?.signedOffset ?? 0;
+}
+
+export function followingSpeedLimit(car, cars, trackLength) {
+  const centerOffset = mainTrackCenterOffset(car);
+  let leader = null;
+  let gap = TRAFFIC_GAP_AHEAD;
+  for (let index = 0; index < cars.length; index += 1) {
+    const other = cars[index];
+    if (other === car || !canCollide(car, other)) continue;
+    const distance = physicalTrafficGap(car, other, trackLength);
+    if (distance <= 0 || distance > gap) continue;
+    const lateral = Math.abs(mainTrackCenterOffset(other) - centerOffset);
+    if (lateral >= VEHICLE_LIMITS.carWidth + metersToSimUnits(0.4)) continue;
+    leader = other;
+    gap = distance;
+  }
+  return followingTargetSpeed(car, leader, gap);
+}
+
+// The lane planner already has a filtered scan. Reuse it for pacing instead
+// of rescanning the entire field for every driver decision.
+export function followingSpeedFromTraffic(car, traffic) {
+  const centerOffset = mainTrackCenterOffset(car);
+  let leader = null;
+  let gap = TRAFFIC_GAP_AHEAD;
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
+    if (entry.gap <= 0 || entry.gap > gap) continue;
+    if (Math.abs(entry.signedOffset - centerOffset) >= VEHICLE_LIMITS.carWidth + metersToSimUnits(0.4)) continue;
+    leader = entry.car;
+    gap = entry.gap;
+  }
+  return followingTargetSpeed(car, leader, gap);
+}
+
+function followingTargetSpeed(car, leader, gap) {
+  if (!leader) return simUnitsToMeters(TOP_SPEED_SIM_UNITS_PER_SECOND);
+  const speed = simUnitsToMeters(car.speed);
+  const followingGap = simUnitsToMeters(VEHICLE_LIMITS.carLength) + 2 + speed * 0.35;
+  return Math.max(0, simUnitsToMeters(leader.speed) + (simUnitsToMeters(gap) - followingGap) * 1.2);
+}
+
+// Lane intentions and corner offsets compose differently in each mode. Return
+// the available lateral corridor so the final commanded path stays clear of
+// cars alongside, rather than checking only an intermediate lane intention.
+const LANE_MOVEMENT_BOUNDS = { minimum: -Infinity, maximum: Infinity };
+export function laneMovementBounds(traffic, currentOffset) {
+  const bounds = LANE_MOVEMENT_BOUNDS;
+  bounds.minimum = -Infinity;
+  bounds.maximum = Infinity;
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
+    if (Math.abs(entry.gap) > VEHICLE_LIMITS.carLength) continue;
+    const neighbor = entry.signedOffset - currentOffset;
+    if (neighbor > 0) bounds.maximum = Math.min(bounds.maximum, Math.max(currentOffset, entry.signedOffset - VEHICLE_LIMITS.carWidth));
+    else if (neighbor < 0) bounds.minimum = Math.max(bounds.minimum, Math.min(currentOffset, entry.signedOffset + VEHICLE_LIMITS.carWidth));
+  }
+  return bounds;
 }