@inventure71/paddockjs 4.1.0 → 4.3.0

package/src/simulation/driver/arcadeRacingControls.js

@@ -0,0 +1,111 @@
+import { clamp, normalizeAngle } from '../simMath.js';
+import { kphToSimSpeed, metersToSimUnits, simUnitsToMeters } from '../units.js';
+import { pointAtInto } from '../track/trackModel.js';
+import { VEHICLE_LIMITS, tirePerformanceFactor, arcadeTrackCornerSpeedLimit, arcadeSurfaceGrip } from '../vehicle/vehiclePhysics.js';
+import { mainTrackCenterOffset } from './trafficScan.js';
+import { createDriverInput } from './driverInput.js';
+import { angleToPoint } from './driverMath.js';
+import { calculateTrackEdgeGuard } from './edgeRecovery.js';
+import { calculateRacingTrafficPenalty, planRacingLine } from './racingLinePlan.js';
+import { arcadePreviewLookahead, arcadePreviewSpeed, arcadeRacingLookahead, calculateRacingLineOffset, maxLookaheadCurvature } from './arcadeRacePace.js';
+import { arcadeRacingSpeedControls, arcadeLongitudinalLimits } from './arcadeRacingEnvelope.js';
+import { racingDriverProfile } from './racingDriverProfile.js';
+
+const TARGET_BASE_SCRATCH = { x: 0, y: 0, heading: 0, normalX: 0, normalY: 0, curvature: 0, distance: 0 };
+const TARGET_POINT_SCRATCH = { x: 0, y: 0 };
+
+export function decideArcadeRacingControls(car, orderIndex, race) {
+  const aggression = car.aggression ?? car.personality?.baseAggression ?? 0.5;
+  const profile = racingDriverProfile(car);
+  const edgeGuard = calculateTrackEdgeGuard(car, race);
+  const previewLookahead = arcadePreviewLookahead(car.speed);
+  const previewCurvature = maxLookaheadCurvature(race.track, car.progress, previewLookahead);
+  const lookahead = arcadeRacingLookahead(car.speed);
+  const targetBase = pointAtInto(race.track, car.progress + lookahead, TARGET_BASE_SCRATCH);
+  const curvature = Math.max(car.trackState.curvature, targetBase.curvature, previewCurvature);
+  const lanePlan = planRacingLine(car, orderIndex, race);
+  const cornerOffsetDamping = clamp(curvature / 0.0012, 0, 0.58);
+  const recoveryOffset = edgeGuard.side * edgeGuard.recoveryOffset;
+  const racingOffset = calculateRacingLineOffset(car, race, lookahead, curvature, edgeGuard);
+  const trafficPressure = lanePlan.attackCommitted || lanePlan.sameLaneAhead || lanePlan.actualLaneAhead || lanePlan.sideRisk ? 1 : 0;
+  const racingLineWeight = lanePlan.attackCommitted ? 0.18 : trafficPressure ? 0.52 : 1;
+  const cornerOffsetFactor = 1 - cornerOffsetDamping * (lanePlan.attackCommitted ? 0.28 : trafficPressure ? 0.58 : 1);
+  const plannedTargetOffset = clamp(
+    (lanePlan.offset + racingOffset * racingLineWeight + metersToSimUnits(profile.lineErrorMeters)) * cornerOffsetFactor * (1 - edgeGuard.pressure * 0.8) +
+      recoveryOffset * edgeGuard.pressure * 0.8,
+    -edgeGuard.recoveryOffset,
+    edgeGuard.recoveryOffset,
+  );
+  // A committed passing lane must unwind with the corner. Moving laterally
+  // while the current turn consumes most grip sends a safe speed target off
+  // the road. Edge recovery retains priority over holding the current line.
+  const cornerHold = trafficPressure && edgeGuard.pressure < 0.2
+    ? clamp((car.gripUsage ?? 0) / 0.7, 0, 1) ** 2 : 0;
+  const currentOffset = mainTrackCenterOffset(car);
+  const targetOffset = clamp(
+    currentOffset + (plannedTargetOffset - currentOffset) * (1 - cornerHold),
+    -edgeGuard.recoveryOffset,
+    edgeGuard.recoveryOffset,
+  );
+  TARGET_POINT_SCRATCH.x = targetBase.x + targetBase.normalX * targetOffset;
+  TARGET_POINT_SCRATCH.y = targetBase.y + targetBase.normalY * targetOffset;
+  const angleError = angleToPoint(car, TARGET_POINT_SCRATCH);
+  const headingError = normalizeAngle(targetBase.heading - car.heading);
+  const steeringLimit = car.trackState.surface === 'kerb' ? VEHICLE_LIMITS.maxSteer * 0.96 : VEHICLE_LIMITS.maxSteer;
+  // Invert the arcade bicycle yaw law for the curvature to the chosen lane point.
+  // Tire wear scales yaw response in the integrator, so it also scales this inverse.
+  const pursuitCurve = 2 * Math.sin(angleError) / Math.max(
+    Math.hypot(TARGET_POINT_SCRATCH.x - car.x, TARGET_POINT_SCRATCH.y - car.y),
+    metersToSimUnits(1),
+  );
+  const steeringRequest = clamp(
+    Math.atan(VEHICLE_LIMITS.wheelbase * pursuitCurve / tirePerformanceFactor(car.tireEnergy ?? 100)),
+    -steeringLimit,
+    steeringLimit,
+  );
+  const cornerTargetKph = arcadePreviewSpeed(car, race.track, previewLookahead, aggression, profile);
+  const edgePenalty = edgeGuard.pressure > 0.42
+    ? simUnitsToMeters(Math.max(0, car.trackState.crossTrackError - edgeGuard.softLimit)) *
+      (5.8 - aggression * 1.1) + edgeGuard.overLimitPressure * 48
+    : edgeGuard.overLimitPressure * 48;
+  const steeringPenalty = clamp((Math.abs(angleError) - 0.38) * 24, 0, 12);
+  const headingPenalty = clamp((Math.abs(headingError) - 0.48) * 42, 0, 24);
+  const recoveryAlignmentPenalty = edgeGuard.pressure > 0.2
+    ? clamp((Math.abs(headingError) - 0.46) * 64, 0, 38)
+    : 0;
+  const steeringLoadPenalty = clamp(
+    (Math.abs(steeringRequest) / Math.max(steeringLimit, 1e-6) - 0.82) * 42,
+    0,
+    18,
+  ) * clamp(Math.abs(headingError) / 0.48, 0, 1);
+  const trafficPenalty = calculateRacingTrafficPenalty(car, lanePlan) * (1 - aggression * 0.28);
+  const minimumDesiredSpeedKph = edgeGuard.pressure > 0.55 ? 34 : car.trackState.surface === 'kerb' ? 58 : 52;
+  const desiredSpeedKph = clamp(
+    cornerTargetKph - edgePenalty - steeringPenalty - headingPenalty - recoveryAlignmentPenalty - steeringLoadPenalty - trafficPenalty,
+    minimumDesiredSpeedKph,
+    330,
+  );
+  // Corner capacity and physical traffic take precedence over maneuvering
+  // floors: a stopped leader may require the car to stop until the pass clears.
+  const desiredSpeed = Math.min(
+    metersToSimUnits(lanePlan.followingSpeed),
+    kphToSimSpeed(cornerTargetKph),
+    metersToSimUnits(arcadeTrackCornerSpeedLimit(car, pursuitCurve * metersToSimUnits(1), profile.lateralShare * arcadeSurfaceGrip(car))),
+    clamp(kphToSimSpeed(desiredSpeedKph), kphToSimSpeed(minimumDesiredSpeedKph), VEHICLE_LIMITS.maxSpeed),
+  );
+  const pedals = arcadeRacingSpeedControls(car, simUnitsToMeters(desiredSpeed), profile);
+  const brakeLimit = arcadeLongitudinalLimits(car).brakeDeceleration * car.mass / car.brakeNewtons;
+  let brakeAmount = pedals.brake;
+  if (edgeGuard.pressure > 0.46 && car.speed > kphToSimSpeed(48)) {
+    brakeAmount = Math.max(brakeAmount, clamp((edgeGuard.pressure - 0.42) * 0.9, 0, brakeLimit));
+  }
+  const recoveryThrottleScale = edgeGuard.pressure > 0.24
+    ? 1 - clamp((Math.abs(headingError) - 0.38) / 0.92, 0, 0.82)
+    : 1;
+
+  return createDriverInput()
+    .steer(steeringRequest)
+    .accelerate(brakeAmount > 0 ? 0 : pedals.throttle * recoveryThrottleScale)
+    .brake(brakeAmount)
+    .controls();
+}

package/src/simulation/driver/arcadeRacingEnvelope.js

@@ -0,0 +1,63 @@
+import { clamp } from '../simMath.js';
+import { metersToSimUnits, simUnitsToMeters } from '../units.js';
+import {
+  arcadeAccelerationLimit,
+  arcadeBrakingLimit,
+  arcadeResistanceForce,
+  arcadeSurfaceGrip,
+  tirePerformanceFactor,
+  VEHICLE_LIMITS,
+} from '../vehicle/vehiclePhysics.js';
+import { racingDriverProfile } from './racingDriverProfile.js';
+
+const SPEED_RESPONSE_SECONDS = 0.0625;
+
+function brakeDecelerationAt(car, speedSim, grip) {
+  return Math.min(car.brakeNewtons / car.mass, simUnitsToMeters(arcadeBrakingLimit(speedSim, grip)));
+}
+
+// All accelerations/speeds here are SI. Arcade has independent longitudinal
+// and yaw limits, so this envelope does not add a fictional friction circle.
+export function arcadeLongitudinalLimits(car, speedMps = simUnitsToMeters(car.speed)) {
+  const speed = clamp(speedMps, 0, simUnitsToMeters(VEHICLE_LIMITS.maxSpeed));
+  const speedSim = metersToSimUnits(speed);
+  const speedRatio = clamp(speedSim / VEHICLE_LIMITS.maxSpeed, 0, 1);
+  const grip = arcadeSurfaceGrip(car) * tirePerformanceFactor(car.tireEnergy ?? 100);
+  const engineForce = car.powerNewtons * (car.drsActive ? 1.08 : 1) *
+    Math.max(0.12, 1 - speedRatio ** 1.15);
+  const drsBonus = car.drsActive ? 1.06 : 1;
+  return {
+    speed,
+    engineForce,
+    drsBonus,
+    driveAcceleration: Math.min(engineForce / car.mass, simUnitsToMeters(arcadeAccelerationLimit(speedSim, grip))) * drsBonus,
+    brakeDeceleration: brakeDecelerationAt(car, speedSim, grip),
+    resistanceDeceleration: arcadeResistanceForce(car, speed) / car.mass,
+  };
+}
+
+export function arcadeBrakingDeceleration(car, speedMps, profile = racingDriverProfile(car)) {
+  const speed = clamp(speedMps, 0, simUnitsToMeters(VEHICLE_LIMITS.maxSpeed));
+  const grip = arcadeSurfaceGrip(car) * tirePerformanceFactor(car.tireEnergy ?? 100);
+  // Preview needs only braking, not engine taper or acceleration capacity.
+  return brakeDecelerationAt(car, metersToSimUnits(speed), grip) * clamp(profile.longitudinalShare, 0, 1) +
+    arcadeResistanceForce(car, speed) / car.mass;
+}
+
+export function arcadeRacingSpeedControls(car, targetSpeedMps, profile = racingDriverProfile(car)) {
+  const limits = arcadeLongitudinalLimits(car);
+  const target = clamp(targetSpeedMps, 0, simUnitsToMeters(VEHICLE_LIMITS.maxSpeed));
+  const share = clamp(profile.longitudinalShare, 0, 1);
+  // A single signed force request includes only resistance needed to hold a
+  // moving target. Stopping must not request throttle to overcome rolling drag.
+  const demand = car.mass * ((target - limits.speed) / SPEED_RESPONSE_SECONDS +
+    (target > 0 ? limits.resistanceDeceleration : 0));
+  const fullEngineForce = Math.max(limits.engineForce * limits.drsBonus, 1e-9);
+  const fullBrakeForce = Math.max(car.brakeNewtons, 1e-9);
+  return {
+    throttle: clamp(demand / fullEngineForce, 0,
+      Math.min(1, limits.driveAcceleration * car.mass * share / fullEngineForce)),
+    brake: clamp(-demand / fullBrakeForce, 0,
+      Math.min(1, limits.brakeDeceleration * car.mass * share / fullBrakeForce)),
+  };
+}

package/src/simulation/driver/driverControlConstants.js

@@ -1,9 +1,7 @@
 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);

package/src/simulation/driver/driverController.js

@@ -4,7 +4,8 @@ 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';
+import { VEHICLE_LIMITS, isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
+import { normalizeAngle } from '../simMath.js';
 
 export function decideDriverControls({ car, orderIndex, race }) {
   if (car.manualControls) return car.manualControls;
@@ -23,6 +24,15 @@ export function decideDriverControls({ car, orderIndex, race }) {
     return decideRejoinControls(car, race);
   }
 
+  // Forward path pursuit is ambiguous when the car faces away from the road.
+  // Let the existing recovery controller turn it around before resuming pace.
+  if (!isSimulatorPhysicsMode(race.physicsMode) &&
+      Math.abs(normalizeAngle(car.heading - car.trackState.heading)) > Math.PI / 2) {
+    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;
@@ -37,11 +47,12 @@ export function decideDriverControls({ car, orderIndex, race }) {
 }
 
 function shouldStabilizeSimulatorCar(car, race) {
-  if (race.physicsMode !== 'advanced') return false;
-  const gripUsage = car.gripUsage ?? 0;
+  if (!isSimulatorPhysicsMode(race.physicsMode)) return false;
   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);
+  // Tire force demand can exceed capacity during a straight launch. Recovery
+  // responds to lost directional stability, not longitudinal demand alone.
+  const unstable = car.stabilityState === 'spin-risk' || slipAngle > 0.24;
+  return unstable && (nearEdge || slipAngle > 0.34);
 }

package/src/simulation/driver/edgeRecovery.js

@@ -1,11 +1,10 @@
 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 { VEHICLE_LIMITS, isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
 import { REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX } from './driverControlConstants.js';
 
 export function calculateTrackEdgeGuard(car, race) {
-  const simulatorMode = race.physicsMode === 'advanced';
+  const simulatorMode = isSimulatorPhysicsMode(race.physicsMode);
   const trackLimit = race.track.width / 2;
   const halfCarWidth = VEHICLE_LIMITS.carWidth / 2;
   const wholeCarOutsideLimit = trackLimit + halfCarWidth;

package/src/simulation/driver/racingControls.js

@@ -1,399 +1,13 @@
-import { clamp, normalizeAngle } from '../simMath.js';
-import { kphToSimSpeed, metersToSimUnits, simUnitsToMeters } from '../units.js';
-import { offsetTrackPoint, pointAt } from '../track/trackModel.js';
-import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
-import { BRAKING_LOOKAHEAD_MAX_DISTANCE, CURVATURE_LOOKAHEAD_SAMPLES, EDGE_RECOVERY_MIN_LOOKAHEAD, LOOKAHEAD_BASE_DISTANCE, LOOKAHEAD_MAX_DISTANCE, OVERTAKE_LATERAL_MIN, PREVIEW_CURVATURE_CAP, TRAFFIC_GAP_AHEAD, TRAFFIC_SIDE_GAP } from './driverControlConstants.js';
-import { createDriverInput } from './driverInput.js';
-import { angleToPoint } from './driverMath.js';
-import { calculateTrackEdgeGuard } from './edgeRecovery.js';
-import { calculateActualOverlapPenalty, calculatePlannedTrafficPenalty, planRacingLine } from './racingLinePlan.js';
-import { analyzeTrackEdgeMotion } from './recoveryDynamics.js';
+import { isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
+import { decideArcadeRacingControls } from './arcadeRacingControls.js';
+import { decideAdvancedRacingControls } from './advancedRacingControls.js';
 
-export function decideRacingControls(car, orderIndex, race) {
-  if (race.physicsMode === 'advanced') {
-    return decideSimulatorRacingControls(car, orderIndex, race);
-  }
-  return decideArcadeRacingControls(car, orderIndex, race);
-}
-
-export function decideArcadeRacingControls(car, orderIndex, race) {
-  return decideRacingControlsForMode(car, orderIndex, race, {
-    simulatorMode: false,
-    baseLookaheadSpeedFactor: (aggression) => 1.62 - aggression * 0.12,
-    previewLookaheadSpeedFactor: 3.15,
-    edgeLookaheadPenaltyMeters: 18,
-    cornerPressureCurvature: 0.001,
-    edgeLineDamping: 0.8,
-    edgeRecoveryWeight: 0.8,
-    headingFeedForwardBase: (carEntry, edgeGuard) => 0.34 + carEntry.racecraft * 0.18 + edgeGuard.pressure * 0.12,
-    headingFeedForwardLimit: 0.42,
-    pathSteerGain: (carEntry, edgeGuard) => 0.72 + carEntry.racecraft * 0.12 + edgeGuard.pressure * 0.42,
-    edgeRecoveryStart: 0.22,
-    edgeRecoveryGain: 1.18,
-    edgeRecoveryOverLimitGain: 0.55,
-    edgeRecoveryLimit: 0.52,
-    steeringLimitScale: () => 1,
-    gripBudget: (carEntry, aggression) => 14.8 + carEntry.racecraft * 3.4 + (carEntry.tireEnergy ?? 100) * 0.011 + aggression * 1.8,
-    cornerSpeedMultiplier: (aggression) => 1.12 + aggression * 0.08,
-    paceBonus: (carEntry) => (carEntry.pace - 1) * 20,
-    aggressionSpeedBonus: (aggression) => aggression * 10,
-    minCornerSpeedKph: 96,
-    maxCornerSpeedKph: 318,
-    edgePenaltyMetersScale: (aggression) => 5.8 - aggression * 1.1,
-    edgePenaltyPressure: 48,
-    edgePressureSpeedPenalty: 0,
-    edgeOutwardSpeedPenalty: 0,
-    edgeHeadingOutwardPenalty: 0,
-    steeringPenaltyStart: 0.38,
-    steeringPenaltyGain: 24,
-    steeringPenaltyMax: 12,
-    headingPenaltyStart: 0.48,
-    headingPenaltyGain: 42,
-    headingPenaltyMax: 24,
-    recoveryHeadingStart: 0.46,
-    recoveryHeadingGain: 64,
-    recoveryHeadingMax: 38,
-    steeringLoadStart: 0.82,
-    steeringLoadMax: 18,
-    steeringLoadHeadingScale: 0.48,
-    loadPenalty: () => 0,
-    minimumSpeeds: { edge: 34, kerb: 58, track: 52 },
-    desiredSpeedMaxKph: 330,
-    minimumThrottle: (aggression) => 0.1 + aggression * 0.08,
-    brakeLimits: { kerb: (aggression) => 0.42, track: (aggression) => 0.72 - aggression * 0.08 },
-    brakeResponseKph: (aggression) => 28 + aggression * 11,
-    extraGripBrake: () => 0,
-    edgeBrakeLimitScale: 1,
-    edgeSlideBrakeStart: 1.1,
-    edgeSlideBrakeGain: 0,
-    edgeSlideVelocityBrakeGain: 0,
-    edgeSlideHeadingBrake: 0,
-    edgeSlideBrakeLimitScale: 0,
-    edgeSlideThrottleDamping: 0,
-    recoveryHeadingThrottleStart: 0.38,
-    throttleResponseKph: 16,
-    throttleScale: () => 1,
-  });
-}
+export { decideArcadeRacingControls } from './arcadeRacingControls.js';
+export { decideAdvancedRacingControls as decideSimulatorRacingControls } from './advancedRacingControls.js';
+export { calculateRacingLineOffset, maxLookaheadCurvature } from './arcadeRacePace.js';
 
-export function decideSimulatorRacingControls(car, orderIndex, race) {
-  return decideRacingControlsForMode(car, orderIndex, race, {
-    simulatorMode: true,
-    baseLookaheadSpeedFactor: (aggression) => 2.45 - aggression * 0.06,
-    previewLookaheadSpeedFactor: 6.15,
-    edgeLookaheadPenaltyMeters: 34,
-    cornerPressureCurvature: 0.00072,
-    edgeLineDamping: 1.55,
-    edgeRecoveryWeight: 1.45,
-    headingFeedForwardBase: (carEntry, edgeGuard) => 0.2 + carEntry.racecraft * 0.08 + edgeGuard.pressure * 0.07,
-    headingFeedForwardLimit: 0.25,
-    pathSteerGain: (carEntry, edgeGuard) => 0.46 + carEntry.racecraft * 0.06 + edgeGuard.pressure * 0.18,
-    edgeRecoveryStart: 0.04,
-    edgeRecoveryGain: 3.1,
-    edgeRecoveryOverLimitGain: 1.15,
-    edgeRecoveryLimit: 0.78,
-    steeringLimitScale: (carEntry, speedRatio, gripUsage) => clamp(1 - speedRatio * 0.55 - gripUsage * 0.14, 0.26, 1),
-    gripBudget: (carEntry, aggression) => 10.6 + carEntry.racecraft * 1.55 + (carEntry.tireEnergy ?? 100) * 0.006 + aggression * 0.55,
-    cornerSpeedMultiplier: (aggression) => 0.93 + aggression * 0.035,
-    paceBonus: (carEntry) => (carEntry.pace - 1) * 12,
-    aggressionSpeedBonus: (aggression) => aggression * 4,
-    minCornerSpeedKph: 58,
-    maxCornerSpeedKph: 292,
-    edgePenaltyMetersScale: (aggression) => 10.5 - aggression * 0.8,
-    edgePenaltyPressure: 92,
-    edgePressureSpeedPenalty: 32,
-    edgeOutwardSpeedPenalty: 30,
-    edgeHeadingOutwardPenalty: 22,
-    steeringPenaltyStart: 0.27,
-    steeringPenaltyGain: 42,
-    steeringPenaltyMax: 28,
-    headingPenaltyStart: 0.32,
-    headingPenaltyGain: 62,
-    headingPenaltyMax: 42,
-    recoveryHeadingStart: 0.28,
-    recoveryHeadingGain: 86,
-    recoveryHeadingMax: 58,
-    steeringLoadStart: 0.58,
-    steeringLoadMax: 36,
-    steeringLoadHeadingScale: 0.32,
-    loadPenalty: (entry, gripUsage, slipAngle, cornerPressure, outwardDriftAngle) =>
-      clamp((gripUsage - 0.52) * 92, 0, 54) +
-      clamp(slipAngle * 130, 0, 42) +
-      cornerPressure * 18 +
-      clamp(outwardDriftAngle * 330, 0, 62),
-    minimumSpeeds: { edge: 44, kerb: 58, track: 76 },
-    desiredSpeedMaxKph: 302,
-    minimumThrottle: (aggression) => 0.03 + aggression * 0.03,
-    brakeLimits: { kerb: (aggression) => 0.36, track: (aggression) => 0.9 - aggression * 0.03 },
-    brakeResponseKph: (aggression) => 15 + aggression * 5,
-    extraGripBrake: (gripUsage, slipAngle, brakeLimit) => clamp((gripUsage - 0.68) * 0.42 + slipAngle * 0.5, 0, brakeLimit * 0.6),
-    edgeBrakeLimitScale: 1.08,
-    edgeSlideBrakeStart: 0.22,
-    edgeSlideBrakeGain: 0.78,
-    edgeSlideVelocityBrakeGain: 0.12,
-    edgeSlideHeadingBrake: 0.1,
-    edgeSlideBrakeLimitScale: 0.86,
-    edgeSlideThrottleDamping: 0.9,
-    recoveryHeadingThrottleStart: 0.3,
-    throttleResponseKph: 18,
-    throttleScale: (steeringLoad, gripUsage, slipAngle, edgeGuard) => clamp(
-      1 - steeringLoad * 0.42 - Math.max(0, gripUsage - 0.58) * 0.58 - slipAngle * 1.25 - edgeGuard.pressure * 0.42,
-      0,
-      1,
-    ),
-  });
-}
-
-function decideRacingControlsForMode(car, orderIndex, race, profile) {
-  const aggression = car.aggression ?? car.personality?.baseAggression ?? 0.5;
-  const simulatorMode = profile.simulatorMode;
-  const edgeGuard = calculateTrackEdgeGuard(car, race);
-  const edgeMotion = analyzeTrackEdgeMotion(car, race);
-  const gripUsage = Number.isFinite(car.gripUsage) ? car.gripUsage : 0;
-  const slipAngle = Math.abs(car.slipAngleRadians ?? 0);
-  const baseLookahead = clamp(
-    car.speed * profile.baseLookaheadSpeedFactor(aggression) +
-      LOOKAHEAD_BASE_DISTANCE -
-      edgeGuard.pressure * metersToSimUnits(profile.edgeLookaheadPenaltyMeters),
-    EDGE_RECOVERY_MIN_LOOKAHEAD,
-    LOOKAHEAD_MAX_DISTANCE,
-  );
-  const previewLookahead = clamp(
-    car.speed * profile.previewLookaheadSpeedFactor + LOOKAHEAD_BASE_DISTANCE,
-    baseLookahead,
-    BRAKING_LOOKAHEAD_MAX_DISTANCE,
-  );
-  const previewCurvature = maxLookaheadCurvature(race.track, car.progress, previewLookahead);
-  const cornerPressure = clamp(previewCurvature / profile.cornerPressureCurvature, 0, 1);
-  const lookahead = clamp(
-    baseLookahead * (1 - cornerPressure * 0.46),
-    EDGE_RECOVERY_MIN_LOOKAHEAD,
-    LOOKAHEAD_MAX_DISTANCE,
-  );
-  const targetBase = pointAt(race.track, car.progress + lookahead);
-  const curvature = Math.max(
-    car.trackState.curvature,
-    targetBase.curvature,
-    previewCurvature,
-  );
-  const lanePlan = planRacingLine(car, orderIndex, race);
-  const cornerOffsetDamping = clamp(curvature / 0.0012, 0, 0.58);
-  const recoveryOffset = edgeGuard.side * edgeGuard.recoveryOffset;
-  const racingOffset = calculateRacingLineOffset(car, race, lookahead, curvature, edgeGuard);
-  const trafficPressure = lanePlan.attackCommitted || lanePlan.sameLaneAhead || lanePlan.actualLaneAhead || lanePlan.sideRisk ? 1 : 0;
-  const racingLineWeight = lanePlan.attackCommitted ? 0.18 : trafficPressure ? 0.52 : 1;
-  const cornerOffsetFactor = 1 - cornerOffsetDamping * (lanePlan.attackCommitted ? 0.28 : trafficPressure ? 0.58 : 1);
-  const targetOffset = clamp(
-    (lanePlan.offset + racingOffset * racingLineWeight) * cornerOffsetFactor * (1 - edgeGuard.pressure * profile.edgeLineDamping) +
-      recoveryOffset * edgeGuard.pressure * profile.edgeRecoveryWeight,
-    -edgeGuard.recoveryOffset,
-    edgeGuard.recoveryOffset,
-  );
-  const target = offsetTrackPoint(targetBase, targetOffset);
-  const angleError = angleToPoint(car, target);
-  const headingError = normalizeAngle(targetBase.heading - car.heading);
-  const lateralError = car.trackState?.signedOffset ?? 0;
-  const outwardDriftAngle = simulatorMode &&
-    Math.sign(lateralError) !== 0 &&
-    Math.sign(normalizeAngle(car.heading - (car.trackState?.heading ?? targetBase.heading))) === Math.sign(lateralError)
-    ? Math.abs(normalizeAngle(car.heading - (car.trackState?.heading ?? targetBase.heading)))
-    : 0;
-  const cornerCommitment = clamp(Math.abs(headingError) / 0.9, 0, 0.72);
-  const lateralCorrection = -Math.atan2(
-    lateralError * (0.85 + edgeGuard.pressure * 0.5),
-    Math.max(car.speed, kphToSimSpeed(35)),
-  ) * (1 - cornerCommitment * (simulatorMode ? 0.78 : 0.62));
-  const headingFeedForward = clamp(
-    headingError * profile.headingFeedForwardBase(car, edgeGuard),
-    -profile.headingFeedForwardLimit,
-    profile.headingFeedForwardLimit,
-  );
-  let pathSteer = angleError * profile.pathSteerGain(car, edgeGuard) + headingFeedForward;
-  if (edgeGuard.side !== 0 && Math.sign(pathSteer) === edgeGuard.side) {
-    pathSteer *= 1 - edgeGuard.pressure * 0.85;
-  }
-  const edgeRecoverySteer = -edgeGuard.side * clamp(
-    (edgeGuard.pressure - profile.edgeRecoveryStart) * profile.edgeRecoveryGain +
-      edgeGuard.overLimitPressure * profile.edgeRecoveryOverLimitGain +
-      (simulatorMode ? outwardDriftAngle * clamp(Math.abs(lateralError) / (race.track.width * 0.26), 0, 1) * 1.8 : 0),
-    0,
-    profile.edgeRecoveryLimit,
-  );
-  const speedRatio = clamp(car.speed / VEHICLE_LIMITS.maxSpeed, 0, 1);
-  const simulatorSteeringLimit = VEHICLE_LIMITS.maxSteer *
-    profile.steeringLimitScale(car, speedRatio, gripUsage);
-  const steeringLimit = simulatorMode
-    ? (car.trackState.surface === 'kerb' ? simulatorSteeringLimit * 0.82 : simulatorSteeringLimit)
-    : car.trackState.surface === 'kerb'
-      ? VEHICLE_LIMITS.maxSteer * 0.96
-      : VEHICLE_LIMITS.maxSteer;
-  let steeringRequest = clamp(pathSteer + lateralCorrection + edgeRecoverySteer, -steeringLimit, steeringLimit);
-  if (simulatorMode && edgeGuard.pressure > 0.62 && Math.sign(steeringRequest) === edgeGuard.side) {
-    steeringRequest = clamp(
-      -edgeGuard.side * Math.max(Math.abs(steeringRequest), steeringLimit * 0.55),
-      -steeringLimit,
-      steeringLimit,
-    );
-  }
-  const cornerRadiusMeters = simUnitsToMeters(1 / Math.max(curvature, 1e-7));
-  const lateralGripBudget = profile.gripBudget(car, aggression);
-  const cornerTargetKph = clamp(
-    Math.sqrt(lateralGripBudget * cornerRadiusMeters) * 3.6 *
-      profile.cornerSpeedMultiplier(aggression) +
-      profile.paceBonus(car) + profile.aggressionSpeedBonus(aggression),
-    profile.minCornerSpeedKph,
-    profile.maxCornerSpeedKph,
-  );
-  const edgePenalty = edgeGuard.pressure > 0.42
-    ? simUnitsToMeters(Math.max(0, car.trackState.crossTrackError - edgeGuard.softLimit)) *
-      profile.edgePenaltyMetersScale(aggression) +
-      edgeGuard.overLimitPressure * profile.edgePenaltyPressure
-    : edgeGuard.overLimitPressure * profile.edgePenaltyPressure +
-      edgeGuard.pressure * profile.edgePressureSpeedPenalty;
-  const edgeMotionPenalty =
-    edgeMotion.outwardSpeedMps * profile.edgeOutwardSpeedPenalty * clamp(edgeGuard.pressure, 0, 1) +
-    (edgeMotion.headingOutward ? profile.edgeHeadingOutwardPenalty * clamp(edgeGuard.pressure, 0, 1) : 0);
-  const steeringPenalty = clamp((Math.abs(angleError) - profile.steeringPenaltyStart) * profile.steeringPenaltyGain, 0, profile.steeringPenaltyMax);
-  const headingPenalty = clamp((Math.abs(headingError) - profile.headingPenaltyStart) * profile.headingPenaltyGain, 0, profile.headingPenaltyMax);
-  const recoveryAlignmentPenalty = edgeGuard.pressure > 0.2
-    ? clamp((Math.abs(headingError) - profile.recoveryHeadingStart) * profile.recoveryHeadingGain, 0, profile.recoveryHeadingMax)
-    : 0;
-  const steeringLoadPenalty = clamp(
-    (Math.abs(steeringRequest) / Math.max(steeringLimit, 1e-6) - profile.steeringLoadStart) * 42,
-    0,
-    profile.steeringLoadMax,
-  ) * clamp(Math.abs(headingError) / profile.steeringLoadHeadingScale, 0, 1);
-  const simulatorLoadPenalty = profile.loadPenalty(car, gripUsage, slipAngle, cornerPressure, outwardDriftAngle);
-  const actualLaneLateral = lanePlan.actualLaneAhead
-    ? Math.abs(lanePlan.actualLaneAhead.signedOffset - (car.trackState?.signedOffset ?? 0))
-    : Infinity;
-  const plannedPassingOverlap = lanePlan.attackCommitted && lanePlan.sameLaneAhead
-    ? Math.abs(lanePlan.sameLaneAhead.signedOffset - (car.trackState?.signedOffset ?? 0)) > OVERTAKE_LATERAL_MIN
-    : false;
-  const trafficPenalty = 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,
-  ) * (1 - aggression * 0.28);
-  const minimumDesiredSpeedKph = edgeGuard.pressure > 0.55
-    ? profile.minimumSpeeds.edge
-    : car.trackState.surface === 'kerb' ? profile.minimumSpeeds.kerb : profile.minimumSpeeds.track;
-  const desiredSpeedKph = clamp(
-    (car.drsActive ? cornerTargetKph + 22 : cornerTargetKph) -
-      edgePenalty -
-      edgeMotionPenalty -
-      steeringPenalty -
-      headingPenalty -
-      recoveryAlignmentPenalty -
-      steeringLoadPenalty -
-      simulatorLoadPenalty -
-      trafficPenalty,
-    minimumDesiredSpeedKph,
-    profile.desiredSpeedMaxKph,
-  );
-  const desiredSpeed = clamp(
-    kphToSimSpeed(desiredSpeedKph),
-    kphToSimSpeed(minimumDesiredSpeedKph),
-    VEHICLE_LIMITS.maxSpeed,
-  );
-  const speedError = desiredSpeed - car.speed;
-  const minimumThrottle = edgeGuard.pressure > 0.2 ? 0 : profile.minimumThrottle(aggression);
-  const brakeLimit = simulatorMode
-    ? car.trackState.surface === 'kerb'
-      ? profile.brakeLimits.kerb(aggression)
-      : profile.brakeLimits.track(aggression)
-    : car.trackState.surface === 'kerb'
-      ? profile.brakeLimits.kerb(aggression)
-      : profile.brakeLimits.track(aggression);
-  let brakeAmount = speedError < -kphToSimSpeed(3)
-    ? clamp(Math.abs(speedError) / kphToSimSpeed(profile.brakeResponseKph(aggression)), 0, brakeLimit)
-    : 0;
-  const simulatorBrakeRisk = cornerPressure > 0.15 ||
-    edgeGuard.pressure > 0.2 ||
-    outwardDriftAngle > 0.03 ||
-    car.speed > kphToSimSpeed(132) ||
-    speedError < kphToSimSpeed(8);
-  if (simulatorMode && simulatorBrakeRisk && (gripUsage > 0.9 || slipAngle > 0.12)) {
-    brakeAmount = Math.max(brakeAmount, profile.extraGripBrake(gripUsage, slipAngle, brakeLimit));
-  }
-  if (simulatorMode && car.speed < kphToSimSpeed(58) && edgeGuard.pressure < 0.75) {
-    brakeAmount *= 0.25;
-  }
-  if (edgeGuard.pressure > 0.46 && car.speed > kphToSimSpeed(48)) {
-    brakeAmount = Math.max(brakeAmount, clamp((edgeGuard.pressure - 0.42) * 0.9 * profile.edgeBrakeLimitScale, 0, brakeLimit));
-  }
-  if (edgeGuard.pressure > profile.edgeSlideBrakeStart && edgeMotion.outwardSpeedMps > 0.25) {
-    brakeAmount = Math.max(
-      brakeAmount,
-      clamp(
-        (edgeGuard.pressure - profile.edgeSlideBrakeStart) * profile.edgeSlideBrakeGain +
-          edgeMotion.outwardSpeedMps * profile.edgeSlideVelocityBrakeGain +
-          (edgeMotion.headingOutward ? profile.edgeSlideHeadingBrake : 0),
-        0,
-        brakeLimit * profile.edgeSlideBrakeLimitScale,
-      ),
-    );
-  }
-  const recoveryThrottleScale = edgeGuard.pressure > 0.24
-    ? 1 - clamp((Math.abs(headingError) - profile.recoveryHeadingThrottleStart) / 0.92, 0, 0.82)
-    : 1;
-  const throttleRequest = speedError > kphToSimSpeed(1)
-    ? clamp(speedError / kphToSimSpeed(profile.throttleResponseKph), minimumThrottle, 1)
-    : 0;
-  const steeringLoad = Math.abs(steeringRequest) / Math.max(steeringLimit, 1e-6);
-  const simulatorThrottleScale = profile.throttleScale(steeringLoad, gripUsage, slipAngle, edgeGuard);
-  const edgeSlideThrottleScale = 1 - clamp(
-    (
-      Math.max(0, edgeGuard.pressure - 0.18) +
-      edgeMotion.outwardSpeedMps * 0.16 +
-      (edgeMotion.headingOutward ? 0.18 : 0)
-    ) * profile.edgeSlideThrottleDamping,
-    0,
-    0.92,
-  );
-
-  return createDriverInput()
-    .steer(steeringRequest)
-    .accelerate(brakeAmount > 0.05 ? 0 : throttleRequest * recoveryThrottleScale * simulatorThrottleScale * edgeSlideThrottleScale)
-    .brake(brakeAmount)
-    .controls();
-}
-
-export function maxLookaheadCurvature(track, progress, lookahead) {
-  let maximum = 0;
-  let previous = pointAt(track, progress);
-  for (let index = 1; index <= CURVATURE_LOOKAHEAD_SAMPLES; index += 1) {
-    const sample = pointAt(track, progress + lookahead * (index / CURVATURE_LOOKAHEAD_SAMPLES));
-    const segmentDistance = Math.max(1, lookahead / CURVATURE_LOOKAHEAD_SAMPLES);
-    const segmentCurvature = Math.abs(normalizeAngle(sample.heading - previous.heading)) / segmentDistance;
-    maximum = Math.max(maximum, Math.abs(sample.curvature ?? 0), Math.min(segmentCurvature, PREVIEW_CURVATURE_CAP));
-    previous = sample;
-  }
-  return maximum;
-}
-
-export function calculateRacingLineOffset(car, race, lookahead, curvature, edgeGuard) {
-  const cornerStrength = clamp((curvature - 0.00012) / 0.00095, 0, 1);
-  if (cornerStrength <= 0) return 0;
-
-  const entry = pointAt(race.track, car.progress - lookahead * 0.35);
-  const apex = pointAt(race.track, car.progress + lookahead * 0.55);
-  const exit = pointAt(race.track, car.progress + lookahead * 1.25);
-  const signedEntry = normalizeAngle(apex.heading - entry.heading);
-  const signedExit = normalizeAngle(exit.heading - apex.heading);
-  const turnDirection = Math.sign(Math.abs(signedEntry) > Math.abs(signedExit) ? signedEntry : signedExit);
-  if (turnDirection === 0) return 0;
-
-  const aggression = car.aggression ?? car.personality?.baseAggression ?? 0.5;
-  const simulatorMode = race.physicsMode === 'advanced';
-  const safeEdge = race.track.width / 2 - VEHICLE_LIMITS.carWidth *
-    (simulatorMode ? 2.05 - aggression * 0.08 : 1.15 - aggression * 0.12);
-  const apexOffset = turnDirection * safeEdge *
-    (simulatorMode ? 0.42 + aggression * 0.05 : 0.72 + aggression * 0.08);
-
-  return apexOffset * cornerStrength * (1 - edgeGuard.pressure * (simulatorMode ? 0.82 : 0.65));
+export function decideRacingControls(car, orderIndex, race) {
+  return isSimulatorPhysicsMode(race.physicsMode)
+    ? decideAdvancedRacingControls(car, orderIndex, race)
+    : decideArcadeRacingControls(car, orderIndex, race);
 }