vehicle-path2 1.0.14 → 2.0.0

package/README.md

@@ -1,168 +1,168 @@
-# vehicle-path2
-
-Library untuk simulasi pergerakan kendaraan dual-axle sepanjang jalur.
-
-## Instalasi
-
-```bash
-npm install vehicle-path2
-```
-
-## Quick Start
-
-```tsx
-import { useVehicleSimulation } from 'vehicle-path2/react'
-
-function App() {
-  const sim = useVehicleSimulation({ wheelbase: 30 })
-
-  // Buat jalur
-  sim.addLine({ id: 'line1', start: [0, 0], end: [400, 0] })
-  sim.addLine({ id: 'line2', start: [400, 0], end: [400, 300] })
-  sim.connect('line1', 'line2')
-
-  // Tambah kendaraan
-  sim.addVehicles({ id: 'v1', lineId: 'line1', position: 0 })
-
-  // Gerakkan ke tujuan
-  sim.goto({ id: 'v1', lineId: 'line2', position: 1.0 })
-
-  // Jalankan animasi
-  sim.prepare()
-  sim.tick(5) // panggil di animation loop
-}
-```
-
-## API
-
-### Format Posisi
-
-Semua nilai posisi menggunakan format **0-1** untuk persentase:
-- `0` = 0% (awal line)
-- `0.5` = 50% (tengah line)
-- `1` = 100% (ujung line)
-
-Untuk posisi absolut (dalam satuan koordinat), gunakan `isPercentage: false`.
-
-### Setup
-
-```ts
-const sim = useVehicleSimulation({
-  wheelbase: 30,                    // jarak antar roda
-  tangentMode: 'proportional-40'    // mode kurva (opsional)
-})
-```
-
-### Scene
-
-```ts
-sim.addLine({ id: 'line1', start: [0, 0], end: [400, 0] })
-sim.updateLine('line1', { end: [500, 100] })
-sim.removeLine('line1')
-sim.clearScene()
-```
-
-### Koneksi
-
-```ts
-sim.connect('line1', 'line2')
-sim.connect('line1', 'line2', { fromOffset: 0.8, toOffset: 0.2 })
-sim.connect('line1', 'line2', { fromOffset: 150, fromIsPercentage: false, toOffset: 50, toIsPercentage: false })
-sim.updateConnection('line1', 'line2', { fromOffset: 0.5 })              // update offset
-sim.updateConnection('line1', 'line2', { toOffset: 100, toIsPercentage: false }) // absolute
-sim.disconnect('line1', 'line2')
-```
-
-### Kendaraan
-
-```ts
-sim.addVehicles({ id: 'v1', lineId: 'line1', position: 0 })
-sim.addVehicles({ id: 'v2', lineId: 'line1', position: 150, isPercentage: false }) // absolute
-sim.updateVehicle('v1', { position: 0.5 })                    // pindah ke 50%
-sim.updateVehicle('v1', { lineId: 'line2' })                  // pindah ke line lain
-sim.updateVehicle('v1', { lineId: 'line2', position: 0.8 })   // pindah ke 80% di line2
-sim.removeVehicle('v1')
-sim.clearVehicles()
-```
-
-### Pergerakan
-
-```ts
-sim.goto({ id: 'v1', lineId: 'line2' })                // default position = 1.0 (ujung)
-sim.goto({ id: 'v1', lineId: 'line2', position: 0.5 }) // 0.5 = tengah line
-sim.goto({ id: 'v1', lineId: 'line2', position: 150, isPercentage: false }) // absolute
-sim.goto({ id: 'v1', lineId: 'line2', payload: { orderId: '123' } })        // dengan payload
-sim.clearQueue('v1')
-```
-
-### Animasi
-
-```ts
-sim.prepare()              // siapkan sebelum animasi
-sim.tick(5)                // gerakkan 5 pixel per tick
-sim.reset()                // kembali ke posisi awal
-sim.isMoving()             // cek ada yang bergerak
-sim.continueVehicle('v1')  // lanjutkan vehicle yang wait
-```
-
-### Load dari DSL
-
-```ts
-sim.loadFromDSL(`
-  line1 : (0, 0) -> (400, 0)
-  line2 : (400, 0) -> (400, 300)
-  line1 -> line2
-`)
-```
-
-### State
-
-```ts
-sim.lines          // semua line
-sim.curves         // semua koneksi
-sim.vehicles       // kendaraan (posisi awal)
-sim.movingVehicles // kendaraan (posisi saat animasi)
-```
-
-## Contoh Lengkap
-
-```tsx
-import { useVehicleSimulation } from 'vehicle-path2/react'
-import { useEffect } from 'react'
-
-function AnimatedVehicle() {
-  const sim = useVehicleSimulation({ wheelbase: 30 })
-
-  useEffect(() => {
-    sim.addLine({ id: 'line1', start: [100, 100], end: [500, 100] })
-    sim.addVehicles({ id: 'v1', lineId: 'line1', position: 0 })
-    sim.goto({ id: 'v1', lineId: 'line1', position: 1.0 })
-    sim.prepare()
-
-    const animate = () => {
-      if (sim.tick(3)) {
-        requestAnimationFrame(animate)
-      }
-    }
-    requestAnimationFrame(animate)
-  }, [])
-
-  return (
-    <svg width={600} height={200}>
-      {sim.movingVehicles.map(v => (
-        <circle
-          key={v.id}
-          cx={v.rear.position.x}
-          cy={v.rear.position.y}
-          r={10}
-          fill="blue"
-        />
-      ))}
-    </svg>
-  )
-}
-```
-
-## License
-
-MIT
+# vehicle-path2
+
+Library untuk simulasi pergerakan kendaraan dual-axle sepanjang jalur.
+
+## Instalasi
+
+```bash
+npm install vehicle-path2
+```
+
+## Quick Start
+
+```tsx
+import { useVehicleSimulation } from 'vehicle-path2/react'
+
+function App() {
+  const sim = useVehicleSimulation({ wheelbase: 30 })
+
+  // Buat jalur
+  sim.addLine({ id: 'line1', start: [0, 0], end: [400, 0] })
+  sim.addLine({ id: 'line2', start: [400, 0], end: [400, 300] })
+  sim.connect('line1', 'line2')
+
+  // Tambah kendaraan
+  sim.addVehicles({ id: 'v1', lineId: 'line1', position: 0 })
+
+  // Gerakkan ke tujuan
+  sim.goto({ id: 'v1', lineId: 'line2', position: 1.0 })
+
+  // Jalankan animasi
+  sim.prepare()
+  sim.tick(5) // panggil di animation loop
+}
+```
+
+## API
+
+### Format Posisi
+
+Semua nilai posisi menggunakan format **0-1** untuk persentase:
+- `0` = 0% (awal line)
+- `0.5` = 50% (tengah line)
+- `1` = 100% (ujung line)
+
+Untuk posisi absolut (dalam satuan koordinat), gunakan `isPercentage: false`.
+
+### Setup
+
+```ts
+const sim = useVehicleSimulation({
+  wheelbase: 30,                    // jarak antar roda
+  tangentMode: 'proportional-40'    // mode kurva (opsional)
+})
+```
+
+### Scene
+
+```ts
+sim.addLine({ id: 'line1', start: [0, 0], end: [400, 0] })
+sim.updateLine('line1', { end: [500, 100] })
+sim.removeLine('line1')
+sim.clearScene()
+```
+
+### Koneksi
+
+```ts
+sim.connect('line1', 'line2')
+sim.connect('line1', 'line2', { fromOffset: 0.8, toOffset: 0.2 })
+sim.connect('line1', 'line2', { fromOffset: 150, fromIsPercentage: false, toOffset: 50, toIsPercentage: false })
+sim.updateConnection('line1', 'line2', { fromOffset: 0.5 })              // update offset
+sim.updateConnection('line1', 'line2', { toOffset: 100, toIsPercentage: false }) // absolute
+sim.disconnect('line1', 'line2')
+```
+
+### Kendaraan
+
+```ts
+sim.addVehicles({ id: 'v1', lineId: 'line1', position: 0 })
+sim.addVehicles({ id: 'v2', lineId: 'line1', position: 150, isPercentage: false }) // absolute
+sim.updateVehicle('v1', { position: 0.5 })                    // pindah ke 50%
+sim.updateVehicle('v1', { lineId: 'line2' })                  // pindah ke line lain
+sim.updateVehicle('v1', { lineId: 'line2', position: 0.8 })   // pindah ke 80% di line2
+sim.removeVehicle('v1')
+sim.clearVehicles()
+```
+
+### Pergerakan
+
+```ts
+sim.goto({ id: 'v1', lineId: 'line2' })                // default position = 1.0 (ujung)
+sim.goto({ id: 'v1', lineId: 'line2', position: 0.5 }) // 0.5 = tengah line
+sim.goto({ id: 'v1', lineId: 'line2', position: 150, isPercentage: false }) // absolute
+sim.goto({ id: 'v1', lineId: 'line2', payload: { orderId: '123' } })        // dengan payload
+sim.clearQueue('v1')
+```
+
+### Animasi
+
+```ts
+sim.prepare()              // siapkan sebelum animasi
+sim.tick(5)                // gerakkan 5 pixel per tick
+sim.reset()                // kembali ke posisi awal
+sim.isMoving()             // cek ada yang bergerak
+sim.continueVehicle('v1')  // lanjutkan vehicle yang wait
+```
+
+### Load dari DSL
+
+```ts
+sim.loadFromDSL(`
+  line1 : (0, 0) -> (400, 0)
+  line2 : (400, 0) -> (400, 300)
+  line1 -> line2
+`)
+```
+
+### State
+
+```ts
+sim.lines          // semua line
+sim.curves         // semua koneksi
+sim.vehicles       // kendaraan (posisi awal)
+sim.movingVehicles // kendaraan (posisi saat animasi)
+```
+
+## Contoh Lengkap
+
+```tsx
+import { useVehicleSimulation } from 'vehicle-path2/react'
+import { useEffect } from 'react'
+
+function AnimatedVehicle() {
+  const sim = useVehicleSimulation({ wheelbase: 30 })
+
+  useEffect(() => {
+    sim.addLine({ id: 'line1', start: [100, 100], end: [500, 100] })
+    sim.addVehicles({ id: 'v1', lineId: 'line1', position: 0 })
+    sim.goto({ id: 'v1', lineId: 'line1', position: 1.0 })
+    sim.prepare()
+
+    const animate = () => {
+      if (sim.tick(3)) {
+        requestAnimationFrame(animate)
+      }
+    }
+    requestAnimationFrame(animate)
+  }, [])
+
+  return (
+    <svg width={600} height={200}>
+      {sim.movingVehicles.map(v => (
+        <circle
+          key={v.id}
+          cx={v.rear.position.x}
+          cy={v.rear.position.y}
+          r={10}
+          fill="blue"
+        />
+      ))}
+    </svg>
+  )
+}
+```
+
+## License
+
+MIT

package/dist/core/algorithms/pathFinding.d.ts

@@ -41,7 +41,7 @@ export declare function calculateBezierArcLength(bezier: BezierCurve, segments?:
  *
  * Effective range: [wheelbase, lineLength]
  */
-export declare function resolveFromLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, wheelbase: number): number;
+export declare function resolveFromLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, maxWheelbase: number): number;
 /**
  * Resolve offset untuk TO line (garis tujuan kurva)
  * - 0% → 0 (awal garis)
@@ -49,7 +49,7 @@ export declare function resolveFromLineOffset(line: Line, offset: number | undef
  *
  * Effective range: [0, lineLength - wheelbase]
  */
-export declare function resolveToLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, wheelbase: number): number;
+export declare function resolveToLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, maxWheelbase: number): number;
 /**
  * Membangun graph dari lines dan curves
  */

package/dist/core/algorithms/vehicleMovement.d.ts

@@ -55,6 +55,16 @@ export declare function calculateFrontAxlePosition(path: PathResult, rearSegment
     segmentIndex: number;
     segmentDistance: number;
 } | null;
+/**
+ * Hitung posisi awal semua axle dari posisi rearmost axle.
+ *
+ * @param lineId - Line ID tempat vehicle diinisialisasi
+ * @param rearOffset - Absolute offset axle paling belakang (axles[N-1])
+ * @param axleSpacings - Jarak antar axle berurutan (N-1 nilai untuk N axle)
+ * @param line - Line object untuk kalkulasi posisi
+ * @returns Array AxleState, axles[0] = terdepan, axles[N-1] = paling belakang
+ */
+export declare function calculateInitialAxlePositions(lineId: string, rearOffset: number, axleSpacings: number[], line: Line): AxleState[];
 /**
  * Calculate initial front axle position from rear position
  *
@@ -128,26 +138,6 @@ export declare function updateAxlePosition(axleState: AxleState, axleExecution:
     execution: AxleExecutionState;
     completed: boolean;
 };
-export interface MoveVehicleInput {
-    rear: AxleState;
-    front: AxleState;
-    rearExecution: AxleExecutionState;
-    frontExecution: AxleExecutionState;
-}
-export interface MoveVehicleResult {
-    rear: AxleState;
-    front: AxleState;
-    rearExecution: AxleExecutionState;
-    frontExecution: AxleExecutionState;
-    arrived: boolean;
-}
-/**
- * Move a dual-axle vehicle along a path by a given distance.
- *
- * Coordinates rear and front axle updates, computes front maxOffset,
- * detects arrival at target, and clamps both axles to preserve wheelbase.
- */
-export declare function moveVehicle(input: MoveVehicleInput, path: PathResult, distance: number, linesMap: Map<string, Line>, curveDataMap: Map<number, CurveData>, targetLineId: string, targetOffset: number, wheelbase: number): MoveVehicleResult;
 export interface PreparedPath {
     path: PathResult;
     curveDataMap: Map<number, CurveData>;
@@ -192,3 +182,22 @@ export interface SegmentCompletionResult {
  */
 export declare function handleArrival(state: VehicleMovementState, ctx: SegmentCompletionContext): SegmentCompletionResult;
 export type { VehicleMovementState as SegmentVehicleState };
+/**
+ * Advance semua axle vehicle oleh `distance` sepanjang path.
+ *
+ * Ini adalah low-level tick primitive. Update semua axle menggunakan
+ * arc-length parameterization. Arrival = axles[0] (terdepan) mencapai ujung path.
+ *
+ * @param axleStates - Array AxleState saat ini, axles[0] = terdepan
+ * @param axleExecutions - Array AxleExecutionState sesuai urutan axleStates
+ * @param path - Path yang diikuti
+ * @param distance - Jarak yang dimaju per tick
+ * @param linesMap - Map line ID ke Line object
+ * @param curveDataMap - Pre-built bezier curve data
+ * @returns Updated axles, axleExecutions, dan arrival flag
+ */
+export declare function moveVehicle(axleStates: AxleState[], axleExecutions: AxleExecutionState[], path: PathResult, distance: number, linesMap: Map<string, Line>, curveDataMap: Map<number, CurveData>): {
+    axles: AxleState[];
+    axleExecutions: AxleExecutionState[];
+    arrived: boolean;
+};

package/dist/core/engine.d.ts

@@ -0,0 +1,160 @@
+/**
+ * PathEngine - Imperative, framework-agnostic vehicle simulation engine
+ *
+ * This module provides a class-based API over the vehicle-path core algorithms.
+ * Use this when you need stateful scene/vehicle management outside of React
+ * (e.g. game loops, Three.js useFrame, server-side simulations).
+ *
+ * @example
+ * ```typescript
+ * import { PathEngine } from 'vehicle-path/core'
+ *
+ * const engine = new PathEngine({ wheelbase: 30, tangentMode: 'proportional-40' })
+ *
+ * engine.setScene(lines, curves)
+ *
+ * const state = engine.initializeVehicle('line-1', 0)
+ * const execution = engine.preparePath(state, 'line-3', 1.0, true)
+ *
+ * // In your animation/game loop:
+ * function tick(deltaTime: number) {
+ *   const result = engine.moveVehicle(state, execution, speed * deltaTime)
+ *   state = result.state
+ *   execution = result.execution
+ *   if (result.arrived) { ... }
+ * }
+ * ```
+ */
+import type { Line, Curve, Point } from './types/geometry';
+import type { MovementConfig, CurveData } from './types/movement';
+import type { PathResult } from './algorithms/pathFinding';
+import type { TangentMode } from './types/config';
+export interface PathEngineConfig {
+    maxWheelbase: number;
+    tangentMode: TangentMode;
+}
+/**
+ * Multi-axle position state for use with PathEngine.
+ * axles[0] = terdepan, axles[N-1] = paling belakang.
+ */
+export interface VehiclePathState {
+    axles: Array<{
+        lineId: string;
+        offset: number;
+        position: Point;
+    }>;
+    /** N-1 jarak arc-length antar axle berurutan */
+    axleSpacings: number[];
+}
+/**
+ * Active path execution state for a vehicle in motion.
+ * Returned by preparePath() and updated by moveVehicle() each tick.
+ */
+export interface PathExecution {
+    path: PathResult;
+    curveDataMap: Map<number, CurveData>;
+    /** Execution state per axle, sesuai urutan VehiclePathState.axles */
+    axleExecutions: Array<{
+        segmentIndex: number;
+        segmentDistance: number;
+    }>;
+    targetLineId: string;
+    targetOffset: number;
+}
+export { moveVehicle } from './algorithms/vehicleMovement';
+/**
+ * Stateful, imperative vehicle simulation engine.
+ *
+ * Manages a scene (lines + curves + graph) and provides methods to
+ * initialize vehicles, prepare paths, and advance movement per tick.
+ *
+ * Designed for framework-agnostic use — no React, no render dependencies.
+ * The caller is responsible for the animation loop and state storage.
+ */
+export declare class PathEngine {
+    private graph;
+    private linesMap;
+    private curves;
+    private config;
+    constructor(engineConfig: PathEngineConfig);
+    get movementConfig(): MovementConfig;
+    get lines(): Line[];
+    getCurves(): Curve[];
+    /**
+     * Replace the entire scene and rebuild the graph.
+     */
+    setScene(lines: Line[], curves: Curve[]): void;
+    /**
+     * Add a single line. Returns false if a line with the same ID already exists.
+     */
+    addLine(line: Line): boolean;
+    /**
+     * Update start and/or end coordinates of an existing line.
+     */
+    updateLine(lineId: string, updates: {
+        start?: Point;
+        end?: Point;
+    }): boolean;
+    /**
+     * Update a single endpoint ('start' or 'end') of a line.
+     */
+    updateLineEndpoint(lineId: string, endpoint: 'start' | 'end', point: Point): boolean;
+    /**
+     * Rename a line ID and cascade the change to all connected curves.
+     */
+    renameLine(oldId: string, newId: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Remove a line and all curves connected to it.
+     */
+    removeLine(lineId: string): boolean;
+    /**
+     * Add a directional curve (connection) from one line to another.
+     */
+    addCurve(curve: Curve): void;
+    /**
+     * Update a curve by index. Returns false if index is out of bounds.
+     */
+    updateCurve(index: number, updates: Partial<Curve>): boolean;
+    /**
+     * Remove a curve by index. Returns false if index is out of bounds.
+     */
+    removeCurve(index: number): boolean;
+    /**
+     * Initialize a vehicle's N-axle position on a line.
+     *
+     * @param lineId - The line to place the vehicle on
+     * @param rearOffset - Absolute distance offset untuk axle paling belakang
+     * @param axleSpacings - Jarak antar axle berurutan (N-1 nilai untuk N axle)
+     * @returns Initial VehiclePathState, or null if lineId does not exist
+     */
+    initializeVehicle(lineId: string, rearOffset: number, axleSpacings: number[]): VehiclePathState | null;
+    /**
+     * Prepare a path from the vehicle's current position to a target.
+     *
+     * Must be called before moveVehicle(). Returns null if no path exists.
+     *
+     * @param vehicleState - Current vehicle state (from initializeVehicle or previous tick)
+     * @param targetLineId - ID of the target line
+     * @param targetOffset - Position on the target line
+     * @param isPercentage - If true, targetOffset is 0-1 fraction; if false, absolute distance
+     */
+    preparePath(vehicleState: VehiclePathState, targetLineId: string, targetOffset: number, isPercentage?: boolean): PathExecution | null;
+    /**
+     * Advance a vehicle by `distance` along its prepared path.
+     *
+     * Call this every tick. The returned `state` and `execution` replace the
+     * previous values. When `arrived` is true, the vehicle has reached the target.
+     *
+     * @param state - Current vehicle state
+     * @param execution - Current path execution (from preparePath or previous tick)
+     * @param distance - Distance to advance this tick (speed × deltaTime)
+     */
+    moveVehicle(state: VehiclePathState, execution: PathExecution, distance: number): {
+        state: VehiclePathState;
+        execution: PathExecution;
+        arrived: boolean;
+    };
+}

package/dist/core/index.d.ts

@@ -12,9 +12,10 @@
  */
 export type { Point, Line, BezierCurve, Curve } from './types/geometry';
 export type { VehicleState, VehicleStart, Vehicle, AxleState, GotoCommand, GotoCompletionInfo, GotoCompletionCallback } from './types/vehicle';
-export type { CurveData, PathExecutionState, AxleExecutionState, VehicleMovementState, MovementConfig, SceneContext } from './types/movement';
+export type { CurveData, AxleExecutionState, PathExecutionState, VehicleMovementState, MovementConfig, SceneContext } from './types/movement';
 export type { TangentMode } from './types/config';
 export type { CoordinateInput, SceneLineInput, SceneConnectionInput, SceneConfig, VehicleInput, VehicleUpdateInput, ConnectionUpdateInput, GotoCommandInput } from './types/api';
 export { buildGraph, findPath, calculateBezierArcLength, resolveFromLineOffset, resolveToLineOffset, type Graph, type GraphEdge, type PathSegment, type PathResult, type VehiclePosition } from './algorithms/pathFinding';
-export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialFrontPosition, type InitializationResult, updateAxlePosition, moveVehicle, type MoveVehicleInput, type MoveVehicleResult, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, getPositionFromOffset, getLineLength } from './algorithms/vehicleMovement';
+export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialAxlePositions, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, moveVehicle, getPositionFromOffset, getLineLength } from './algorithms/vehicleMovement';
+export { PathEngine, type PathEngineConfig, type VehiclePathState, type PathExecution } from './engine';
 export { distance, normalize, getPointOnLine, getPointOnLineByOffset, getPointOnBezier, createBezierCurve, buildArcLengthTable, distanceToT, getArcLength, calculateTangentLength, isPointNearPoint, type ArcLengthEntry, type CurveOffsetOptions } from './algorithms/math';

package/dist/core/types/api.d.ts

@@ -70,6 +70,15 @@ export interface VehicleInput {
     lineId: string;
     position?: number;
     isPercentage?: boolean;
+    /**
+     * Jarak arc-length antar axle berurutan.
+     * axleSpacings[i] = jarak antara axles[i] dan axles[i+1].
+     * axles[0] = terdepan, axles[N-1] = paling belakang.
+     * Contoh truk biasa: [30]  →  2 axle, jarak 30px
+     * Contoh truck+trailer: [20, 45]  →  3 axle
+     * Total panjang vehicle = sum(axleSpacings) harus ≤ maxWheelbase
+     */
+    axleSpacings: number[];
 }
 /**
  * Vehicle update input for updateVehicle()

package/dist/core/types/movement.d.ts

@@ -27,8 +27,7 @@ export interface PathExecutionState {
     path: import('../algorithms/pathFinding').PathResult;
     curveDataMap: Map<number, CurveData>;
     currentCommandIndex: number;
-    rear: AxleExecutionState;
-    front: AxleExecutionState;
+    axles: AxleExecutionState[];
 }
 /**
  * Movement state container for a vehicle
@@ -41,7 +40,7 @@ export interface VehicleMovementState {
  * Configuration for vehicle movement
  */
 export interface MovementConfig {
-    wheelbase: number;
+    maxWheelbase: number;
     tangentMode: TangentMode;
 }
 /**

package/dist/core/types/vehicle.d.ts

@@ -14,6 +14,8 @@ export interface VehicleStart {
     lineId: string;
     offset: number;
     isPercentage: boolean;
+    /** Optional: defaults to [maxWheelbase] jika tidak disediakan */
+    axleSpacings?: number[];
 }
 /**
  * State for a single axle (Front or Rear)
@@ -32,8 +34,8 @@ export interface Vehicle {
     offset: number;
     isPercentage: boolean;
     state: VehicleState;
-    rear: AxleState;
-    front: AxleState;
+    axles: AxleState[];
+    axleSpacings: number[];
 }
 /**
  * Command to move a vehicle to a target position