@inventure71/paddockjs 2.0.1 → 4.0.0

package/src/simulation/vehicle/vehicleGeometry.js

@@ -49,77 +49,221 @@ export function vehicleAxes(heading) {
   };
 }
 
-function offsetPoint(center, axes, longitudinal, lateral) {
-  return {
-    x: center.x + axes.forward.x * longitudinal + axes.right.x * lateral,
-    y: center.y + axes.forward.y * longitudinal + axes.right.y * lateral,
-  };
+function writePoint(target, x, y) {
+  const point = target ?? {};
+  point.x = x;
+  point.y = y;
+  return point;
 }
 
-export function createOrientedRect({ id, type, center, heading, length, width }) {
-  const axes = vehicleAxes(heading);
+function writePose(target, pose) {
+  const next = target ?? {};
+  next.x = pose.x;
+  next.y = pose.y;
+  next.heading = pose.heading;
+  return next;
+}
+
+function writeCorner(target, centerX, centerY, forwardX, forwardY, rightX, rightY, longitudinal, lateral) {
+  return writePoint(
+    target,
+    centerX + forwardX * longitudinal + rightX * lateral,
+    centerY + forwardY * longitudinal + rightY * lateral,
+  );
+}
+
+function writeOrientedRectValues(target, {
+  id,
+  type,
+  centerX,
+  centerY,
+  heading,
+  length,
+  width,
+  forwardX,
+  forwardY,
+  rightX,
+  rightY,
+}, { writeCorners = true } = {}) {
+  const rect = target ?? {};
   const halfLength = length / 2;
   const halfWidth = width / 2;
-  const corners = [
-    offsetPoint(center, axes, halfLength, halfWidth),
-    offsetPoint(center, axes, halfLength, -halfWidth),
-    offsetPoint(center, axes, -halfLength, -halfWidth),
-    offsetPoint(center, axes, -halfLength, halfWidth),
-  ];
+  const corners = writeCorners || rect.corners ? (rect.corners ?? new Array(4)) : null;
 
-  return {
+  rect.id = id;
+  rect.type = type;
+  rect.center = writePoint(rect.center, centerX, centerY);
+  rect.heading = heading;
+  rect.length = length;
+  rect.width = width;
+  rect.halfLength = halfLength;
+  rect.halfWidth = halfWidth;
+  rect.forward = writePoint(rect.forward, forwardX, forwardY);
+  rect.right = writePoint(rect.right, rightX, rightY);
+  if (corners) {
+    corners[0] = writeCorner(corners[0], centerX, centerY, forwardX, forwardY, rightX, rightY, halfLength, halfWidth);
+    corners[1] = writeCorner(corners[1], centerX, centerY, forwardX, forwardY, rightX, rightY, halfLength, -halfWidth);
+    corners[2] = writeCorner(corners[2], centerX, centerY, forwardX, forwardY, rightX, rightY, -halfLength, -halfWidth);
+    corners[3] = writeCorner(corners[3], centerX, centerY, forwardX, forwardY, rightX, rightY, -halfLength, halfWidth);
+    rect.corners = corners;
+  }
+  return rect;
+}
+
+function writeOrientedRect(target, { id, type, center, heading, length, width }) {
+  const cos = Math.cos(heading);
+  const sin = Math.sin(heading);
+  return writeOrientedRectValues(target, {
     id,
     type,
-    center,
+    centerX: center.x,
+    centerY: center.y,
     heading,
     length,
     width,
-    halfLength,
-    halfWidth,
-    forward: axes.forward,
-    right: axes.right,
-    corners,
-  };
+    forwardX: cos,
+    forwardY: sin,
+    rightX: -sin,
+    rightY: cos,
+  });
 }
 
-export function createVehicleGeometry(car, options = {}) {
-  const pose = vehiclePose(car, options);
-  const axes = vehicleAxes(pose.heading);
-  const center = { x: pose.x, y: pose.y };
-  const body = createOrientedRect({
+function writeVehicleGeometry(target, pose) {
+  const geometry = target ?? {};
+  const forwardX = Math.cos(pose.heading);
+  const forwardY = Math.sin(pose.heading);
+  const rightX = -forwardY;
+  const rightY = forwardX;
+  const wheels = geometry.wheels ?? new Array(WHEEL_SPECS.length);
+  const shapes = geometry.shapes ?? new Array(1 + WHEEL_SPECS.length);
+
+  const body = writeOrientedRectValues(geometry.body, {
     id: 'body',
     type: 'body',
-    center,
+    centerX: pose.x,
+    centerY: pose.y,
     heading: pose.heading,
     length: VEHICLE_GEOMETRY.bodyLength,
     width: VEHICLE_GEOMETRY.bodyWidth,
+    forwardX,
+    forwardY,
+    rightX,
+    rightY,
   });
-  const wheels = WHEEL_SPECS.map((spec) => {
-    const wheelCenter = offsetPoint(
-      center,
-      axes,
-      spec.longitudinal * VEHICLE_GEOMETRY.wheelLongitudinalOffset,
-      spec.lateral * VEHICLE_GEOMETRY.wheelLateralOffset,
-    );
-    return createOrientedRect({
+
+  for (let index = 0; index < WHEEL_SPECS.length; index += 1) {
+    const spec = WHEEL_SPECS[index];
+    const wheelCenterX =
+      pose.x +
+      forwardX * (spec.longitudinal * VEHICLE_GEOMETRY.wheelLongitudinalOffset) +
+      rightX * (spec.lateral * VEHICLE_GEOMETRY.wheelLateralOffset);
+    const wheelCenterY =
+      pose.y +
+      forwardY * (spec.longitudinal * VEHICLE_GEOMETRY.wheelLongitudinalOffset) +
+      rightY * (spec.lateral * VEHICLE_GEOMETRY.wheelLateralOffset);
+    wheels[index] = writeOrientedRectValues(wheels[index], {
       id: spec.id,
       type: 'wheel',
-      center: wheelCenter,
+      centerX: wheelCenterX,
+      centerY: wheelCenterY,
       heading: pose.heading,
       length: VEHICLE_GEOMETRY.wheelLength,
       width: VEHICLE_GEOMETRY.wheelWidth,
+      forwardX,
+      forwardY,
+      rightX,
+      rightY,
     });
-  });
+    shapes[index + 1] = wheels[index];
+  }
 
+  shapes[0] = body;
+  geometry.body = body;
+  geometry.wheels = wheels;
+  geometry.contactPatches = wheels;
+  geometry.shapes = shapes;
+  return geometry;
+}
+
+function writeCurrentVehicleGeometry(target, pose) {
+  const geometry = target ?? {};
+  const forwardX = Math.cos(pose.heading);
+  const forwardY = Math.sin(pose.heading);
+  const rightX = -forwardY;
+  const rightY = forwardX;
+  const wheels = geometry.wheels ?? new Array(WHEEL_SPECS.length);
+
+  const body = writeOrientedRectValues(geometry.body, {
+    id: 'body',
+    type: 'body',
+    centerX: pose.x,
+    centerY: pose.y,
+    heading: pose.heading,
+    length: VEHICLE_GEOMETRY.bodyLength,
+    width: VEHICLE_GEOMETRY.bodyWidth,
+    forwardX,
+    forwardY,
+    rightX,
+    rightY,
+  }, { writeCorners: false });
+
+  for (let index = 0; index < WHEEL_SPECS.length; index += 1) {
+    const spec = WHEEL_SPECS[index];
+    const wheelCenterX =
+      pose.x +
+      forwardX * (spec.longitudinal * VEHICLE_GEOMETRY.wheelLongitudinalOffset) +
+      rightX * (spec.lateral * VEHICLE_GEOMETRY.wheelLateralOffset);
+    const wheelCenterY =
+      pose.y +
+      forwardY * (spec.longitudinal * VEHICLE_GEOMETRY.wheelLongitudinalOffset) +
+      rightY * (spec.lateral * VEHICLE_GEOMETRY.wheelLateralOffset);
+    wheels[index] = writeOrientedRectValues(wheels[index], {
+      id: spec.id,
+      type: 'wheel',
+      centerX: wheelCenterX,
+      centerY: wheelCenterY,
+      heading: pose.heading,
+      length: VEHICLE_GEOMETRY.wheelLength,
+      width: VEHICLE_GEOMETRY.wheelWidth,
+      forwardX,
+      forwardY,
+      rightX,
+      rightY,
+    }, { writeCorners: false });
+  }
+
+  geometry.body = body;
+  geometry.wheels = wheels;
+  geometry.contactPatches = wheels;
+  return geometry;
+}
+
+export function createOrientedRect({ id, type, center, heading, length, width }) {
+  return writeOrientedRect(null, { id, type, center, heading, length, width });
+}
+
+export function createVehicleGeometry(car, options = {}) {
+  const pose = vehiclePose(car, options);
+  return writeVehicleGeometry(null, pose);
+}
+
+function currentPoseSignature(pose) {
+  return [
+    pose.x,
+    pose.y,
+    pose.heading,
+  ].join(':');
+}
+
+function currentPoseState(car) {
   return {
-    body,
-    wheels,
-    contactPatches: wheels,
-    shapes: [body, ...wheels],
+    x: finiteOr(car.x, 0),
+    y: finiteOr(car.y, 0),
+    heading: normalizeAngle(finiteOr(car.heading, 0)),
   };
 }
 
-function geometryPoseSignature(pose) {
+function sweptPoseSignature(pose) {
   return [
     pose.x,
     pose.y,
@@ -131,9 +275,7 @@ function geometryPoseSignature(pose) {
 }
 
 function geometryPose(car) {
-  const x = finiteOr(car.x, 0);
-  const y = finiteOr(car.y, 0);
-  const heading = normalizeAngle(finiteOr(car.heading, 0));
+  const { x, y, heading } = currentPoseState(car);
   return {
     x,
     y,
@@ -144,12 +286,21 @@ function geometryPose(car) {
   };
 }
 
+function currentGeometryStateMatches(car, state) {
+  const pose = state?.pose;
+  if (!pose) return false;
+  const currentPose = currentPoseState(car);
+  return (
+    pose.x === currentPose.x &&
+    pose.y === currentPose.y &&
+    pose.heading === currentPose.heading
+  );
+}
+
 function geometryStateMatches(car, state) {
   const pose = state?.pose;
   if (!pose) return false;
-  const x = finiteOr(car.x, 0);
-  const y = finiteOr(car.y, 0);
-  const heading = normalizeAngle(finiteOr(car.heading, 0));
+  const { x, y, heading } = currentPoseState(car);
   return (
     pose.x === x &&
     pose.y === y &&
@@ -197,15 +348,21 @@ export function mergeAabbs(aabbs) {
 
 export function createVehicleGeometryState(car) {
   const pose = geometryPose(car);
-  const current = createVehicleGeometry(car);
-  const previous = createVehicleGeometry(car, { previous: true });
+  const current = writeVehicleGeometry(null, pose);
+  const previous = writeVehicleGeometry(null, {
+    x: pose.previousX,
+    y: pose.previousY,
+    heading: pose.previousHeading,
+  });
   const bodyAabb = createVehicleShapeAabb(current.body);
   const previousBodyAabb = createVehicleShapeAabb(previous.body);
   const sweptBodyAabb = mergeAabbs([previousBodyAabb, bodyAabb]);
 
   return {
     pose,
-    signature: geometryPoseSignature(pose),
+    currentSignature: currentPoseSignature(pose),
+    sweptSignature: sweptPoseSignature(pose),
+    signature: sweptPoseSignature(pose),
     current,
     previous,
     body: current.body,
@@ -217,12 +374,49 @@ export function createVehicleGeometryState(car) {
   };
 }
 
+export function createCurrentVehicleGeometryState(car, target = null) {
+  const pose = currentPoseState(car);
+  const current = writeCurrentVehicleGeometry(target?.current ?? null, pose);
+  const state = target ?? {};
+  state.pose = writePose(state.pose, pose);
+  state.current = current;
+  state.body = current.body;
+  state.wheels = current.wheels;
+  state.contactPatches = current.contactPatches;
+  return state;
+}
+
 export function getVehicleGeometryState(car) {
   if (geometryStateMatches(car, car.geometryState)) return car.geometryState;
   car.geometryState = createVehicleGeometryState(car);
   return car.geometryState;
 }
 
+export function getCurrentVehicleGeometryState(car) {
+  if (currentGeometryStateMatches(car, car.currentGeometryState)) return car.currentGeometryState;
+  if (currentGeometryStateMatches(car, car.geometryState)) return car.geometryState;
+  car.currentGeometryState = createCurrentVehicleGeometryState(car, car.currentGeometryState ?? null);
+  return car.currentGeometryState;
+}
+
+export function ensureOrientedRectCorners(rect) {
+  if (!rect) return [];
+  if (rect.corners) return rect.corners;
+  return writeOrientedRectValues(rect, {
+    id: rect.id ?? null,
+    type: rect.type ?? null,
+    centerX: rect.center?.x ?? 0,
+    centerY: rect.center?.y ?? 0,
+    heading: rect.heading ?? 0,
+    length: rect.length ?? 0,
+    width: rect.width ?? 0,
+    forwardX: rect.forward?.x ?? Math.cos(rect.heading ?? 0),
+    forwardY: rect.forward?.y ?? Math.sin(rect.heading ?? 0),
+    rightX: rect.right?.x ?? -Math.sin(rect.heading ?? 0),
+    rightY: rect.right?.y ?? Math.cos(rect.heading ?? 0),
+  }).corners;
+}
+
 export function createVehicleAabb(car, options = {}) {
   const geometry = createVehicleGeometry(car, options);
   return mergeAabbs(geometry.shapes.map(createVehicleShapeAabb));

package/src/simulation/vehicle/vehicleKinematics.js

@@ -1,11 +1,11 @@
 export function freezeVehicleMotion(car, {
   brake = 1,
   clearManualControls = false,
-  physicsMode = 'simulator',
+  physicsMode = 'arcade',
   stabilityState = car.stabilityState ?? 'stable',
 } = {}) {
   car.speed = 0;
-  if (physicsMode === 'simulator') {
+  if (physicsMode === 'advanced') {
     car.velocityX = 0;
     car.velocityY = 0;
   } else {

package/src/simulation/vehicle/vehiclePhysics.js

@@ -7,11 +7,11 @@ import {
   simUnitsToMeters,
   metersToSimUnits,
 } from '../units.js';
-import { VEHICLE_GEOMETRY, getCarCorners, vehicleAxes } from './vehicleGeometry.js';
+import { VEHICLE_GEOMETRY, getCarCorners } from './vehicleGeometry.js';
 
 const G = 9.80665;
 
-export const PHYSICS_MODES = ['arcade', 'simulator'];
+export const PHYSICS_MODES = ['arcade', 'advanced'];
 export const DEFAULT_PHYSICS_MODE = 'arcade';
 
 export const VEHICLE_LIMITS = {
@@ -50,7 +50,7 @@ const SIMULATOR_SURFACE_MODEL = {
 };
 
 export function normalizePhysicsMode(value) {
-  return value === 'simulator' ? 'simulator' : DEFAULT_PHYSICS_MODE;
+  return value === 'advanced' ? 'advanced' : DEFAULT_PHYSICS_MODE;
 }
 
 function accelerationLimit(speed, surfaceGrip) {
@@ -73,17 +73,26 @@ function surfaceResistance(surfaceName, model = SURFACE_MODEL) {
   return surface.drag * 0.14 + surface.rollingResistance * 2.4 + (1 - surface.grip) * 0.65;
 }
 
-function sideWheelResistance(wheels, side, model = SURFACE_MODEL) {
-  const sideWheels = wheels.filter((wheel) => wheel.id?.endsWith(`-${side}`));
-  if (!sideWheels.length) return 0;
-  return sideWheels.reduce((total, wheel) => total + surfaceResistance(wheel.surface, model), 0) / sideWheels.length;
-}
-
 function wheelDragYawRate(car, model = SURFACE_MODEL) {
   const wheels = Array.isArray(car.wheelStates) ? car.wheelStates : [];
   if (!wheels.length) return 0;
-  const leftResistance = sideWheelResistance(wheels, 'left', model);
-  const rightResistance = sideWheelResistance(wheels, 'right', model);
+  let leftResistanceTotal = 0;
+  let rightResistanceTotal = 0;
+  let leftCount = 0;
+  let rightCount = 0;
+  for (let index = 0; index < wheels.length; index += 1) {
+    const wheel = wheels[index];
+    const resistance = surfaceResistance(wheel.surface, model);
+    if (wheel.id?.endsWith('-left')) {
+      leftResistanceTotal += resistance;
+      leftCount += 1;
+    } else if (wheel.id?.endsWith('-right')) {
+      rightResistanceTotal += resistance;
+      rightCount += 1;
+    }
+  }
+  const leftResistance = leftCount > 0 ? leftResistanceTotal / leftCount : 0;
+  const rightResistance = rightCount > 0 ? rightResistanceTotal / rightCount : 0;
   const speedFactor = clamp(car.speed / VEHICLE_LIMITS.maxSpeed, 0, 1);
   return clamp(
     (rightResistance - leftResistance) * speedFactor * WHEEL_DRAG_YAW_GAIN,
@@ -111,7 +120,7 @@ function setPhysicsTelemetry(car, {
 }
 
 export function integrateVehiclePhysics(car, controls, dt, options = {}) {
-  if (normalizePhysicsMode(options.physicsMode) === 'simulator') {
+  if (normalizePhysicsMode(options.physicsMode) === 'advanced') {
     return integrateSimulatorVehiclePhysics(car, controls, dt, options);
   }
   return integrateArcadeVehiclePhysics(car, controls, dt, options);
@@ -194,20 +203,22 @@ function simulatorSurface(surfaceName) {
 function aggregateSimulatorSurface(car) {
   const wheels = Array.isArray(car.wheelStates) ? car.wheelStates : [];
   if (!wheels.length) return simulatorSurface(car.trackState?.surface ?? 'track');
-  const total = wheels.reduce((sum, wheel) => {
-    const surface = simulatorSurface(wheel.surface);
-    return {
-      grip: sum.grip + surface.grip,
-      drag: sum.drag + surface.drag,
-      rollingResistance: sum.rollingResistance + surface.rollingResistance,
-      scrub: sum.scrub + surface.scrub,
-    };
-  }, { grip: 0, drag: 0, rollingResistance: 0, scrub: 0 });
+  let grip = 0;
+  let drag = 0;
+  let rollingResistance = 0;
+  let scrub = 0;
+  for (let index = 0; index < wheels.length; index += 1) {
+    const surface = simulatorSurface(wheels[index].surface);
+    grip += surface.grip;
+    drag += surface.drag;
+    rollingResistance += surface.rollingResistance;
+    scrub += surface.scrub;
+  }
   return {
-    grip: total.grip / wheels.length,
-    drag: total.drag / wheels.length,
-    rollingResistance: total.rollingResistance / wheels.length,
-    scrub: total.scrub / wheels.length,
+    grip: grip / wheels.length,
+    drag: drag / wheels.length,
+    rollingResistance: rollingResistance / wheels.length,
+    scrub: scrub / wheels.length,
   };
 }
 
@@ -256,9 +267,13 @@ function integrateSimulatorVehiclePhysics(car, controls, dt, options = {}) {
   const speedRatio = clamp(speedBefore / VEHICLE_LIMITS.maxSpeed, 0, 1);
   const downforceGrip = car.downforceCoefficient * speedBeforeMps * speedBeforeMps / car.mass;
   const totalGripAcceleration = Math.max(0.1, (car.tireGrip * tireFactor * G + downforceGrip) * surfaceGrip);
-  const axes = vehicleAxes(car.heading ?? 0);
-  const forwardVelocity = car.velocityX * axes.forward.x + car.velocityY * axes.forward.y;
-  const lateralVelocity = car.velocityX * axes.right.x + car.velocityY * axes.right.y;
+  const heading = car.heading ?? 0;
+  const forwardX = Math.cos(heading);
+  const forwardY = Math.sin(heading);
+  const rightX = -forwardY;
+  const rightY = forwardX;
+  const forwardVelocity = car.velocityX * forwardX + car.velocityY * forwardY;
+  const lateralVelocity = car.velocityX * rightX + car.velocityY * rightY;
   const forwardSpeedMps = simUnitsToMeters(forwardVelocity);
   const lateralSpeedMps = simUnitsToMeters(lateralVelocity);
   const currentSlipAngle = Math.atan2(lateralSpeedMps, Math.max(Math.abs(forwardSpeedMps), 0.1));
@@ -328,8 +343,8 @@ function integrateSimulatorVehiclePhysics(car, controls, dt, options = {}) {
   car.wheelDragYawRate = requestedWheelDragYawRate;
   car.heading = normalizeAngle(car.heading + car.yawRate * dt);
 
-  const accelerationX = axes.forward.x * longitudinalAcceleration + axes.right.x * actualLateralAcceleration;
-  const accelerationY = axes.forward.y * longitudinalAcceleration + axes.right.y * actualLateralAcceleration;
+  const accelerationX = forwardX * longitudinalAcceleration + rightX * actualLateralAcceleration;
+  const accelerationY = forwardY * longitudinalAcceleration + rightY * actualLateralAcceleration;
   car.velocityX += metersToSimUnits(accelerationX) * dt;
   car.velocityY += metersToSimUnits(accelerationY) * dt;
   car.speed = limitSimulatorSpeed(car);

package/src/simulation/vehicle/vehicleSnapshots.js

@@ -17,7 +17,7 @@ function serializeAppliedControls(car, dependencies) {
 }
 
 function serializeVelocityComponent(car, component, dependencies) {
-  if (dependencies.physicsMode !== 'simulator') return null;
+  if (dependencies.physicsMode !== 'advanced') return null;
   return finiteOrNull(car[component]);
 }
 
@@ -141,6 +141,17 @@ export function serializeCar(car, rank, penaltySeconds = 0, dependencies) {
     signedOffset: car.trackState?.signedOffset ?? 0,
     crossTrackError: car.trackState?.crossTrackError ?? 0,
     surface: car.trackState?.surface ?? 'track',
+    trackState: car.trackState ? {
+      distance: car.trackState.distance,
+      signedOffset: car.trackState.signedOffset,
+      crossTrackError: car.trackState.crossTrackError,
+      surface: car.trackState.surface,
+      inPitLane: Boolean(car.trackState.inPitLane),
+      pitLanePart: car.trackState.pitLanePart ?? null,
+      pitBoxId: car.trackState.pitBoxId ?? null,
+      curvature: car.trackState.curvature ?? 0,
+      heading: car.trackState.heading,
+    } : null,
     wheels: serializeWheels(car.wheelStates),
     inPitLane: Boolean(car.trackState?.inPitLane),
     pitLanePart: car.trackState?.pitLanePart ?? null,
@@ -155,6 +166,29 @@ export function serializeCar(car, rank, penaltySeconds = 0, dependencies) {
   };
 }
 
+export function serializeRenderCarInto(target, car, dependencies) {
+  const { serializeRenderPitStop } = dependencies;
+  target.id = car.id;
+  target.color = car.color;
+  target.previousX = car.previousX ?? car.x;
+  target.previousY = car.previousY ?? car.y;
+  target.x = car.x;
+  target.y = car.y;
+  target.previousHeading = car.previousHeading ?? car.heading;
+  target.heading = car.heading;
+  target.drsActive = Boolean(car.drsActive);
+  target.destroyed = Boolean(car.destroyed);
+  target.destroyReason = car.destroyReason ?? null;
+  target.dnf = Boolean(car.destroyed || car.outOfRace);
+  target.dnfReason = car.dnfReason ?? car.destroyReason ?? null;
+  target.dnfAt = car.dnfAt ?? car.destroyedAt ?? null;
+  target.dnfOrder = car.dnfOrder ?? null;
+  target.outOfRace = Boolean(car.outOfRace || car.destroyed);
+  target.pitStop = serializeRenderPitStop(car.pitStop);
+  target.interaction = serializeParticipantInteraction(car.interaction);
+  return target;
+}
+
 export function serializeRenderCar(car, dependencies) {
   const { serializeRenderPitStop } = dependencies;
   return {

package/src/simulation/vehicle/vehicleState.js

@@ -96,6 +96,8 @@ export function createCar(driver, index, random, track, { standingStart = false,
     drsActive: false,
     drsZoneId: null,
     drsZoneEnabled: false,
+    _drsZoneRef: null,
+    _drsNextZoneIndex: null,
     timingHistory: [],
     lapTelemetry: createLapTelemetry?.(track, 0, gridDistance) ?? null,
     drsDetection: {},
@@ -113,6 +115,8 @@ export function clearCarDrsState(car) {
   car.drsZoneEnabled = false;
   car.drsActive = false;
   car.drsEligible = false;
+  car._drsZoneRef = null;
+  car._drsNextZoneIndex = null;
   car.drsDetection = {};
 }
 
@@ -158,13 +162,15 @@ export function applyExternalCarState(car, partial, context) {
     nextPartial.raceDistance != null
   ) {
     car.gridLocked = false;
+    car._drsZoneRef = null;
+    car._drsNextZoneIndex = null;
     if (raceControl.mode === 'pre-start' && cars.every((item) => !item.gridLocked)) {
       releaseRaceStart();
     }
   }
   car.speed = clamp(Number.isFinite(car.speed) ? car.speed : 0, 0, VEHICLE_LIMITS.maxSpeed);
   car.heading = normalizeAngle(Number.isFinite(car.heading) ? car.heading : 0);
-  syncExternalVelocityState(car, nextPartial, physicsMode === 'simulator');
+  syncExternalVelocityState(car, nextPartial, physicsMode === 'advanced');
   const centerState = nearestTrackStateForCar(track, car, car, car.progress ?? car.raceDistance);
   applyWheelSurfaceState(car, track, { centerState });
   if (