fix: display vehicle paths and hypertubes as splines

rockfactory · rockfactory · commit 7fe0962c0ca5 · 2026-05-11T00:20:58.000+02:00
diff --git a/src/map/MapFiltersPanel.tsx b/src/map/MapFiltersPanel.tsx
@@ -119,6 +119,7 @@ const INFRA_SPLINE_ICONS: Record<SplineKind, ReactNode> = {
   hyper: <IconRoute size={14} />,
   rail: <IconTrain size={14} />,
   power: <IconBolt size={14} />,
+  vehicle: <IconTruck size={14} />,
 };
 
 export interface MapFiltersPanelProps {
diff --git a/src/map/infrastructure/InfrastructureCanvasLayer.tsx b/src/map/infrastructure/InfrastructureCanvasLayer.tsx
@@ -7,6 +7,7 @@ import { useStore } from '@/core/zustand';
 import {
   INFRASTRUCTURE_CATEGORIES,
   type InfrastructureCategory,
+  type InfrastructureSplinesBlock,
   type ParsedInfrastructure,
   SPLINE_KINDS,
   type SplineKind,
@@ -336,6 +337,81 @@ function paintTileBuildings(
   ctx.globalAlpha = 1;
 }
 
+/**
+ * Appends a single polyline to `path`. When `step === 1` and the block
+ * has Hermite tangents (`block.tangentsXY`) the segments are emitted
+ * as `bezierCurveTo` so curved track / belt sections render as actual
+ * curves. Otherwise a straight `lineTo` chain is used, with sub-pixel
+ * points skipped to keep the tile-paint fast at low zoom.
+ *
+ * Shared between `paintTileSplines` (tile-batched main render) and
+ * `drawHighlight` (single-polyline hover stroke) so both paths use the
+ * same curve geometry — keeping the hover accent on top of the curve
+ * rather than collapsing it to chords.
+ */
+function appendPolylineToPath(
+  path: Path2D,
+  block: InfrastructureSplinesBlock,
+  polylineIndex: number,
+  a: AffineGameToContainer,
+  step: number,
+): void {
+  const start = block.offsets[polylineIndex];
+  const end = block.offsets[polylineIndex + 1];
+  if (end - start < 2) return;
+
+  const { pointsXY, tangentsXY } = block;
+  const sx = a.ox + pointsXY[start * 2] * a.ax;
+  const sy = a.oy + pointsXY[start * 2 + 1] * a.by;
+  path.moveTo(sx, sy);
+
+  if (step === 1 && tangentsXY != null) {
+    const t = tangentsXY;
+    let p0x = sx;
+    let p0y = sy;
+    for (let j = start + 1; j < end; j++) {
+      const p1x = a.ox + pointsXY[j * 2] * a.ax;
+      const p1y = a.oy + pointsXY[j * 2 + 1] * a.by;
+      const leaveX = (t[(j - 1) * 4 + 2] * a.ax) / 3;
+      const leaveY = (t[(j - 1) * 4 + 3] * a.by) / 3;
+      const arriveX = (t[j * 4] * a.ax) / 3;
+      const arriveY = (t[j * 4 + 1] * a.by) / 3;
+      path.bezierCurveTo(
+        p0x + leaveX,
+        p0y + leaveY,
+        p1x - arriveX,
+        p1y - arriveY,
+        p1x,
+        p1y,
+      );
+      p0x = p1x;
+      p0y = p1y;
+    }
+    return;
+  }
+
+  let lastDX = sx;
+  let lastDY = sy;
+  const lastIdx = end - 1;
+  for (let j = start + step; j < lastIdx; j += step) {
+    const px = a.ox + pointsXY[j * 2] * a.ax;
+    const py = a.oy + pointsXY[j * 2 + 1] * a.by;
+    const dx = px - lastDX;
+    const dy = py - lastDY;
+    if (dx * dx + dy * dy < 1) continue;
+    path.lineTo(px, py);
+    lastDX = px;
+    lastDY = py;
+  }
+  const lx = a.ox + pointsXY[lastIdx * 2] * a.ax;
+  const ly = a.oy + pointsXY[lastIdx * 2 + 1] * a.by;
+  const ldx = lx - lastDX;
+  const ldy = ly - lastDY;
+  if (ldx * ldx + ldy * ldy >= 1 || end - start === 2) {
+    path.lineTo(lx, ly);
+  }
+}
+
 function paintTileSplines(
   ctx: CanvasRenderingContext2D,
   infra: ParsedInfrastructure,
@@ -353,6 +429,7 @@ function paintTileSplines(
     hyper: 1,
     rail: 1.8,
     power: 0.75,
+    vehicle: 1,
   };
 
   const step = splineStepForZoom(zoom);
@@ -369,67 +446,13 @@ function paintTileSplines(
     if (!SPLINE_KINDS.includes(block.kind)) continue;
     if ((state.splineVisibility?.[block.kind] ?? true) === false) continue;
 
-    const start = block.offsets[polyIdx];
-    const end = block.offsets[polyIdx + 1];
-    if (end - start < 2) continue;
-
     let path = pathsByBlock.get(blockIdx);
     if (!path) {
       path = new Path2D();
       pathsByBlock.set(blockIdx, path);
     }
 
-    const { pointsXY, tangentsXY } = block;
-    const useBezier = step === 1 && tangentsXY != null;
-    const sx = a.ox + pointsXY[start * 2] * a.ax;
-    const sy = a.oy + pointsXY[start * 2 + 1] * a.by;
-    path.moveTo(sx, sy);
-
-    if (useBezier) {
-      const t = tangentsXY;
-      let p0x = sx;
-      let p0y = sy;
-      for (let j = start + 1; j < end; j++) {
-        const p1x = a.ox + pointsXY[j * 2] * a.ax;
-        const p1y = a.oy + pointsXY[j * 2 + 1] * a.by;
-        const leaveX = (t[(j - 1) * 4 + 2] * a.ax) / 3;
-        const leaveY = (t[(j - 1) * 4 + 3] * a.by) / 3;
-        const arriveX = (t[j * 4] * a.ax) / 3;
-        const arriveY = (t[j * 4 + 1] * a.by) / 3;
-        path.bezierCurveTo(
-          p0x + leaveX,
-          p0y + leaveY,
-          p1x - arriveX,
-          p1y - arriveY,
-          p1x,
-          p1y,
-        );
-        p0x = p1x;
-        p0y = p1y;
-      }
-      continue;
-    }
-
-    let lastDX = sx;
-    let lastDY = sy;
-    const lastIdx = end - 1;
-    for (let j = start + step; j < lastIdx; j += step) {
-      const px = a.ox + pointsXY[j * 2] * a.ax;
-      const py = a.oy + pointsXY[j * 2 + 1] * a.by;
-      const dx = px - lastDX;
-      const dy = py - lastDY;
-      if (dx * dx + dy * dy < 1) continue;
-      path.lineTo(px, py);
-      lastDX = px;
-      lastDY = py;
-    }
-    const lx = a.ox + pointsXY[lastIdx * 2] * a.ax;
-    const ly = a.oy + pointsXY[lastIdx * 2 + 1] * a.by;
-    const ldx = lx - lastDX;
-    const ldy = ly - lastDY;
-    if (ldx * ldx + ldy * ldy >= 1 || end - start === 2) {
-      path.lineTo(lx, ly);
-    }
+    appendPolylineToPath(path, block, polyIdx, a, step);
   }
 
   ctx.lineCap = 'round';
@@ -489,21 +512,11 @@ function drawHighlight(
     ctx.restore();
     return;
   }
-  const start = block.offsets[hit.polylineIndex];
-  const end = block.offsets[hit.polylineIndex + 1];
-  if (end - start < 2) {
-    ctx.restore();
-    return;
-  }
   const path = new Path2D();
-  const sx = a.ox + block.pointsXY[start * 2] * a.ax;
-  const sy = a.oy + block.pointsXY[start * 2 + 1] * a.by;
-  path.moveTo(sx, sy);
-  for (let j = start + 1; j < end; j++) {
-    const px = a.ox + block.pointsXY[j * 2] * a.ax;
-    const py = a.oy + block.pointsXY[j * 2 + 1] * a.by;
-    path.lineTo(px, py);
-  }
+  // step=1 forces the full point sequence; combined with tangentsXY it
+  // selects the bezier branch so the hover accent traces the curve
+  // instead of collapsing to straight chords on top of it.
+  appendPolylineToPath(path, block, hit.polylineIndex, a, 1);
 
   ctx.strokeStyle = 'rgba(255, 255, 255, 0.85)';
   ctx.lineWidth = 6;
diff --git a/src/map/infrastructure/infrastructureCategories.ts b/src/map/infrastructure/infrastructureCategories.ts
@@ -143,6 +143,9 @@ export const SplineColor: Record<SplineKind, Record<number, string>> = {
   power: {
     0: '#fde68a',
   },
+  vehicle: {
+    0: '#06b6d4',
+  },
 };
 
 export const SplineLabel: Record<SplineKind, string> = {
@@ -151,6 +154,7 @@ export const SplineLabel: Record<SplineKind, string> = {
   hyper: 'Hyper tubes',
   rail: 'Railroads',
   power: 'Power lines',
+  vehicle: 'Vehicle paths',
 };
 
 export function splineColor(kind: SplineKind, tier: number): string {
diff --git a/src/recipes/savegame/ParseSavegameMessages.ts b/src/recipes/savegame/ParseSavegameMessages.ts
@@ -25,14 +25,21 @@ export const INFRASTRUCTURE_CATEGORIES: InfrastructureCategory[] = [
   'other',
 ];
 
-export type SplineKind = 'belt' | 'pipe' | 'hyper' | 'rail' | 'power';
+export type SplineKind =
+  | 'belt'
+  | 'pipe'
+  | 'hyper'
+  | 'rail'
+  | 'power'
+  | 'vehicle';
 
 export const SPLINE_KINDS: SplineKind[] = [
   'belt',
   'pipe',
   'hyper',
   'rail',
   'power',
+  'vehicle',
 ];
 
 /**
diff --git a/src/recipes/savegame/infrastructure/classifyTypePath.test.ts b/src/recipes/savegame/infrastructure/classifyTypePath.test.ts
@@ -32,12 +32,32 @@ describe('classifyTypePath', () => {
     ).toEqual({ mode: 'spline', kind: 'pipe', tier: 1 });
   });
 
-  it('classifies hyper tubes before falling through to the generic pipe regex', () => {
+  it('classifies the hyper tube spline segment', () => {
     expect(
-      classifyTypePath('/Game/.../Build_PipelineHyper.Build_PipelineHyper_C'),
+      classifyTypePath(
+        '/Game/FactoryGame/Buildable/Factory/PipeHyper/Build_PipeHyper.Build_PipeHyper_C',
+      ),
     ).toEqual({ mode: 'spline', kind: 'hyper', tier: 0 });
   });
 
+  it('leaves hyper tube fittings (start, support, t-junction) classified as buildings', () => {
+    expect(
+      classifyTypePath(
+        '/Game/FactoryGame/Buildable/Factory/PipeHyperStart/Build_PipeHyperStart.Build_PipeHyperStart_C',
+      ),
+    ).toEqual({ mode: 'building' });
+    expect(
+      classifyTypePath(
+        '/Game/FactoryGame/Buildable/Factory/PipeHyperSupport/Build_PipeHyperSupport.Build_PipeHyperSupport_C',
+      ),
+    ).toEqual({ mode: 'building' });
+    expect(
+      classifyTypePath(
+        '/Game/FactoryGame/Buildable/Factory/PipeHyperTJunction/Build_HypertubeTJunction.Build_HypertubeTJunction_C',
+      ),
+    ).toEqual({ mode: 'building' });
+  });
+
   it('classifies railroad tracks (regular and integrated)', () => {
     expect(
       classifyTypePath('/Game/.../Build_RailroadTrack.Build_RailroadTrack_C'),
@@ -49,6 +69,32 @@ describe('classifyTypePath', () => {
     ).toEqual({ mode: 'spline', kind: 'rail', tier: 0 });
   });
 
+  it('classifies vehicle path segments and reads the mSplinePoints property', () => {
+    expect(
+      classifyTypePath(
+        '/Game/FactoryGame/Buildable/Vehicle/VehiclePath/Build_VehiclePath_Universal.Build_VehiclePath_Universal_C',
+      ),
+    ).toEqual({
+      mode: 'spline',
+      kind: 'vehicle',
+      tier: 0,
+      splineProperty: 'mSplinePoints',
+    });
+  });
+
+  it('leaves vehicle path nodes classified as buildings', () => {
+    expect(
+      classifyTypePath(
+        '/Game/FactoryGame/Buildable/Vehicle/VehiclePath/Build_VehiclePathNode_Default.Build_VehiclePathNode_Default_C',
+      ),
+    ).toEqual({ mode: 'building' });
+    expect(
+      classifyTypePath(
+        '/Game/FactoryGame/Buildable/Vehicle/VehiclePath/Build_VehiclePathNode_DockingStation.Build_VehiclePathNode_DockingStation_C',
+      ),
+    ).toEqual({ mode: 'building' });
+  });
+
   it('classifies power lines', () => {
     expect(
       classifyTypePath('/Game/.../Build_PowerLine.Build_PowerLine_C'),
diff --git a/src/recipes/savegame/infrastructure/classifyTypePath.ts b/src/recipes/savegame/infrastructure/classifyTypePath.ts
@@ -1,17 +1,17 @@
 import type { Classification } from './types';
 
 const RE_BELT = /Build_ConveyorBelt(?:Mk(\d+))?_C$/;
-const RE_HYPER = /Build_PipelineHyper.*_C$/;
+const RE_HYPER = /Build_PipeHyper(?:Mk\d+)?_C$/;
 const RE_PIPE = /Build_Pipeline(?:MK(\d+))?(?:_NoIndicator)?_C$/;
 const RE_RAIL = /Build_RailroadTrack(?:Integrated)?_C$/;
 const RE_POWER_LINE = /Build_PowerLine.*_C$/;
+const RE_VEHICLE_PATH = /Build_VehiclePath_Universal(?:_.*)?_C$/;
 
 /**
  * Decides how the worker should treat an entity given its `typePath`.
- * The order of checks matters: hyper tubes have to be checked before
- * the generic pipe regex (`Build_PipelineHyper*` would otherwise
- * match `Build_Pipeline*`), and rails before "anything else", because
- * the network branches each have their own data layout downstream.
+ * Each branch downstream has its own data layout — belts, pipes,
+ * hypertubes, rails, vehicle paths, and power lines all carry their
+ * spline / wire data in slightly different shapes.
  */
 export function classifyTypePath(typePath: string): Classification {
   const belt = typePath.match(RE_BELT);
@@ -30,6 +30,14 @@ export function classifyTypePath(typePath: string): Classification {
   if (RE_RAIL.test(typePath)) {
     return { mode: 'spline', kind: 'rail', tier: 0 };
   }
+  if (RE_VEHICLE_PATH.test(typePath)) {
+    return {
+      mode: 'spline',
+      kind: 'vehicle',
+      tier: 0,
+      splineProperty: 'mSplinePoints',
+    };
+  }
   if (RE_POWER_LINE.test(typePath)) {
     return { mode: 'powerline' };
   }
diff --git a/src/recipes/savegame/infrastructure/extractInfrastructure.ts b/src/recipes/savegame/infrastructure/extractInfrastructure.ts
@@ -289,7 +289,7 @@ export function ingestEntity(
   const cls = classifyTypePath(typePath);
 
   if (cls.mode === 'spline') {
-    const points = readSplineLocations(obj.properties);
+    const points = readSplineLocations(obj.properties, cls.splineProperty);
     if (points) {
       const bucket = getOrCreateBucket(acc, cls.kind, cls.tier);
       const built = buildRotatedPolyline(tx, ty, yaw, points);
diff --git a/src/recipes/savegame/infrastructure/getClearance.ts b/src/recipes/savegame/infrastructure/getClearance.ts
@@ -26,10 +26,33 @@ const HARDCODED_CLEARANCE_CM: Record<string, ClearanceCm> = {
   Build_ConveyorPoleStackable_C: { width: 100, length: 100, height: 400 },
   Build_ConveyorPoleWall_C: { width: 100, length: 100, height: 100 },
   Build_ConveyorCeilingAttachment_C: { width: 100, length: 100, height: 100 },
+  // Conveyor lifts are 2x2m in-game but ship with `null` clearance in
+  // the catalog, so without an override they fall back to the 8x8m
+  // factory default. Height varies by tier (Mk1 ~4m, taller tiers
+  // longer), but the visible footprint is identical: a 2x2m vertical
+  // shaft. Pick 4m as a shared height since the map only uses it for
+  // topmost-under-cursor stacking.
+  Build_ConveyorLiftMk1_C: { width: 200, length: 200, height: 400 },
+  Build_ConveyorLiftMk2_C: { width: 200, length: 200, height: 400 },
+  Build_ConveyorLiftMk3_C: { width: 200, length: 200, height: 400 },
+  Build_ConveyorLiftMk4_C: { width: 200, length: 200, height: 400 },
+  Build_ConveyorLiftMk5_C: { width: 200, length: 200, height: 400 },
+  Build_ConveyorLiftMk6_C: { width: 200, length: 200, height: 400 },
   Build_PipelineSupport_C: { width: 100, length: 100, height: 200 },
   Build_PipelineSupportWall_C: { width: 100, length: 100, height: 100 },
   Build_PipelineSupportWallHole_C: { width: 100, length: 100, height: 100 },
   Build_PipelineFlowIndicator_C: { width: 100, length: 100, height: 100 },
+  // Vehicle path waypoints: invisible markers in-game that just anchor
+  // the recorded route. The 8x8m fallback paints them as big squares
+  // sitting on top of the path spline. Render them as 1x1m so they
+  // read as discreet dots at path joints instead of competing with the
+  // spline itself.
+  Build_VehiclePathNode_Default_C: { width: 100, length: 100, height: 100 },
+  Build_VehiclePathNode_DockingStation_C: {
+    width: 400,
+    length: 400,
+    height: 200,
+  },
 };
 
 const SMALL_CLEARANCE_PATTERNS = [/Pole/, /Support/, /FlowIndicator/];
diff --git a/src/recipes/savegame/infrastructure/readSaveProperties.ts b/src/recipes/savegame/infrastructure/readSaveProperties.ts
diff --git a/src/recipes/savegame/infrastructure/types.ts b/src/recipes/savegame/infrastructure/types.ts
