@terrafirmagreg-team/recipe 0.1.0 → 1.2.0

package/src/lib/calc/resolve.ts

@@ -1,19 +1,12 @@
-import { hydrateRecipe } from '@terrafirmagreg-team/recipe/lib/data/parse';
+import type { DatasetRef } from '@terrafirmagreg-team/sites/location';
 import type { Recipe } from '@terrafirmagreg-team/recipe/lib/data/dto';
 import { loadClientRecipe } from '@terrafirmagreg-team/recipe/lib/client/recipe';
-import { resolveClientTag } from '@terrafirmagreg-team/game/lib/dump/client/tags';
+import { resolveClientTag } from '@terrafirmagreg-team/dump/lib/dump/client/tags';
 import { recipesForOutput } from '@terrafirmagreg-team/recipe/lib/lookup';
-import {
-  calcAutoPick,
-  recipeDivisor,
-  toCalcRecipe,
-  type AutoPickResult,
-  type BuildContext,
-} from './tree';
+import { recipeDivisor, toCalcRecipe } from './tree';
 import type { RecipeCompactIndex, RecipeCompactRow } from '@terrafirmagreg-team/recipe/types';
 import type {
   CalcKind,
-  CalcNode,
   CalcRecipe,
   CalcRecipeSummary,
   TagResolution,
@@ -141,26 +134,6 @@ export function createSummaries(
   };
 }
 
-export type PickContext = Pick<
-  BuildContext,
-  'recipeMap' | 'getRecipesForItem' | 'recipesResolved' | 'deadIds'
->;
-
-export function pickAutoRecipe(
-  node: CalcNode,
-  selections: Record<string, string>,
-  ancestors: ReadonlySet<string>,
-  ctx: PickContext,
-): AutoPickResult {
-  const chosen = node.path
-    ? (selections[node.path] ?? selections[node.materialId])
-    : selections[node.materialId];
-  if (chosen && node.availableRecipes.some((row) => row.recipeId === chosen)) {
-    return { pick: chosen, wantRecipes: [], wantOut: [] };
-  }
-  return calcAutoPick(node.availableRecipes, node.materialId, ancestors, ctx);
-}
-
 export type Wanted = {
   recipes: Set<string>;
   outs: Set<string>;
@@ -175,7 +148,7 @@ export type FetchedSlices = {
 };
 
 export async function fetchSlices(
-  dataset: string,
+  dataset: DatasetRef,
   catalog: RecipeCompactIndex,
   wanted: Wanted,
 ): Promise<FetchedSlices> {
@@ -208,13 +181,7 @@ export async function fetchSlices(
       dead.add(id);
       continue;
     }
-    const category = catalog.categories?.find(
-      (row) => row.id === body.category,
-    );
-    const hydrated = category?.layout
-      ? hydrateRecipe(body, category.layout)
-      : body;
-    recipes.set(id, { calc: toCalcRecipe(hydrated), body: hydrated });
+    recipes.set(id, { calc: toCalcRecipe(body), body });
   }
   const outs = new Map(outRows);
   const tags = new Map<string, TagResolution>(
@@ -228,3 +195,4 @@ export async function fetchSlices(
   );
   return { recipes, outs, tags, dead };
 }
+

package/src/lib/calc/route/buckets.ts

@@ -46,3 +46,4 @@ export function createRectBuckets(
     return [...seen];
   };
 }
+

package/src/lib/calc/route/geometry.ts

@@ -1,6 +1,6 @@
 import type { Node } from '@terrafirmagreg-team/ui/lib/canvas/xyflow';
 import type { FlowPoint } from '@terrafirmagreg-team/ui/types/canvas';
-import type { CalcDirection } from '@terrafirmagreg-team/recipe/lib/calc/flow';
+import { portAnchorPoint } from '@terrafirmagreg-team/recipe/lib/calc/ports';
 
 export const CELL = 8;
 
@@ -9,6 +9,8 @@ export const PAD = 6;
 export type RouteNode = Pick<Node, 'id' | 'position'> & {
   width?: number;
   height?: number;
+  inputs?: number;
+  outputs?: number;
 };
 
 export type Rect = { x: number; y: number; w: number; h: number };
@@ -20,26 +22,17 @@ export const toRect = (node: RouteNode): Rect => ({
   h: node.height ?? 0,
 });
 
-export const sameRect = (a: Rect, b: Rect) =>
-  a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
-
 export function portAnchor(
   node: RouteNode,
   side: 'src' | 'tgt',
-  direction: CalcDirection,
+  index = 0,
 ): FlowPoint {
-  const w = node.width ?? 0;
-  const h = node.height ?? 0;
-  if (direction === 'horizontal') {
-    return {
-      x: node.position.x + (side === 'src' ? -w / 2 : w / 2),
-      y: node.position.y,
-    };
-  }
-  return {
-    x: node.position.x,
-    y: node.position.y + (side === 'src' ? -h / 2 : h / 2),
-  };
+  return portAnchorPoint(
+    node,
+    side,
+    index,
+    side === 'tgt' ? (node.inputs ?? 1) : (node.outputs ?? 1),
+  );
 }
 
 export const cellKey = (x: number, y: number) => (y + 32768) * 65536 + (x + 32768);
@@ -51,12 +44,8 @@ export function zRoute(
   b: FlowPoint,
   sa: FlowPoint,
   sb: FlowPoint,
-  direction: CalcDirection,
 ): FlowPoint[] {
-  if (direction === 'horizontal') {
-    const mid = (sa.x + sb.x) / 2;
-    return [a, sa, { x: mid, y: sa.y }, { x: mid, y: sb.y }, sb, b];
-  }
-  const mid = (sa.y + sb.y) / 2;
-  return [a, sa, { x: sa.x, y: mid }, { x: sb.x, y: mid }, sb, b];
+  const mid = (sa.x + sb.x) / 2;
+  return [a, sa, { x: mid, y: sa.y }, { x: mid, y: sb.y }, sb, b];
 }
+

package/src/lib/calc/route/index.ts

@@ -1,2 +1,3 @@
 export type { RouteNode } from './geometry';
 export { createCircuitRouter } from './router';
+

package/src/lib/calc/route/polyline.ts

@@ -1,5 +1,4 @@
 import type { FlowPoint } from '@terrafirmagreg-team/ui/types/canvas';
-import type { CalcDirection } from '@terrafirmagreg-team/recipe/lib/calc/flow';
 import { CELL } from './geometry';
 
 export function simplifyCells(
@@ -68,8 +67,8 @@ export function cellsToPolyline(
   return px;
 }
 
-export function orthoPoints(points: FlowPoint[], direction: CalcDirection): FlowPoint[] {
-  let prevAxis: 'h' | 'v' = direction === 'horizontal' ? 'h' : 'v';
+export function orthoPoints(points: FlowPoint[]): FlowPoint[] {
+  let prevAxis: 'h' | 'v' = 'h';
   const out: FlowPoint[] = [points[0]!];
   for (let i = 1; i < points.length; i += 1) {
     const prev = out[out.length - 1]!;
@@ -101,3 +100,4 @@ export function orthoPoints(points: FlowPoint[], direction: CalcDirection): Flow
   if (out.length > 1) clean.push(out[out.length - 1]!);
   return clean;
 }
+

package/src/lib/calc/route/router.ts

@@ -1,7 +1,6 @@
 import PF from 'pathfinding';
 import type { Edge } from '@terrafirmagreg-team/ui/lib/canvas/xyflow';
 import type { FlowPoint } from '@terrafirmagreg-team/ui/types/canvas';
-import type { CalcDirection } from '@terrafirmagreg-team/recipe/lib/calc/flow';
 import { createRectBuckets } from './buckets';
 import {
   CELL,
@@ -10,7 +9,6 @@ import {
   keyX,
   keyY,
   portAnchor,
-  sameRect,
   toRect,
   zRoute,
   type Rect,
@@ -20,30 +18,144 @@ import { cellsToPolyline, orthoPoints, simplifyCells } from './polyline';
 
 const WINDOW = 160;
 
-const MAX_CELLS = 60_000;
+const MAX_CELLS = 200_000;
 
-const STUB = 24;
+const STUB = 40;
+
+function stubLength(
+  from: FlowPoint,
+  dir: 1 | -1,
+  skip: Rect[],
+  clear: (x0: number, y0: number, x1: number, y1: number) => Iterable<Rect>,
+): number {
+  let max = STUB;
+  const end = from.x + dir * STUB;
+  const x0 = Math.min(from.x, end) - 1;
+  const x1 = Math.max(from.x, end) + 1;
+  for (const rect of clear(x0, from.y - 1, x1, from.y + 1)) {
+    if (skip.includes(rect)) continue;
+    if (from.y < rect.y - PAD || from.y > rect.y + rect.h + PAD) continue;
+    const edge = dir === 1 ? rect.x - PAD : rect.x + rect.w + PAD;
+    const room = (edge - from.x) * dir;
+    if (room < max) max = Math.max(0, room);
+  }
+  return max;
+}
+
+function growWindow(
+  bounds: { x0: number; y0: number; x1: number; y1: number },
+  query: (x0: number, y0: number, x1: number, y1: number) => Iterable<Rect>,
+  pad: number,
+): void {
+  for (let i = 0; i < 4; i += 1) {
+    let grew = false;
+    for (const rect of query(bounds.x0, bounds.y0, bounds.x1, bounds.y1)) {
+      const rx0 = rect.x - pad;
+      const ry0 = rect.y - pad;
+      const rx1 = rect.x + rect.w + pad;
+      const ry1 = rect.y + rect.h + pad;
+      if (rx0 < bounds.x0) { bounds.x0 = rx0; grew = true; }
+      if (ry0 < bounds.y0) { bounds.y0 = ry0; grew = true; }
+      if (rx1 > bounds.x1) { bounds.x1 = rx1; grew = true; }
+      if (ry1 > bounds.y1) { bounds.y1 = ry1; grew = true; }
+    }
+    if (!grew) break;
+  }
+}
+
+function detourRoute(
+  a: FlowPoint,
+  b: FlowPoint,
+  sa: FlowPoint,
+  sb: FlowPoint,
+  skip: Rect[],
+  query: (x0: number, y0: number, x1: number, y1: number) => Iterable<Rect>,
+): FlowPoint[] {
+  const bounds = {
+    x0: Math.min(sa.x, sb.x),
+    y0: Math.min(sa.y, sb.y),
+    x1: Math.max(sa.x, sb.x),
+    y1: Math.max(sa.y, sb.y),
+  };
+  growWindow(bounds, query, PAD);
+  const laneAt = (off: number): FlowPoint[][] => [
+    [sa, { x: bounds.x1 + off, y: sa.y }, { x: bounds.x1 + off, y: sb.y }, sb],
+    [sa, { x: bounds.x0 - off, y: sa.y }, { x: bounds.x0 - off, y: sb.y }, sb],
+    [sa, { x: sa.x, y: bounds.y0 - off }, { x: sb.x, y: bounds.y0 - off }, sb],
+    [sa, { x: sa.x, y: bounds.y1 + off }, { x: sb.x, y: bounds.y1 + off }, sb],
+  ];
+  const clearLane = (lane: FlowPoint[]): number | null => {
+    let len = 0;
+    for (let i = 0; i + 1 < lane.length; i += 1) {
+      const p = lane[i]!;
+      const q = lane[i + 1]!;
+      len += Math.abs(q.x - p.x) + Math.abs(q.y - p.y);
+      const sx0 = Math.min(p.x, q.x) - 1;
+      const sy0 = Math.min(p.y, q.y) - 1;
+      const sx1 = Math.max(p.x, q.x) + 1;
+      const sy1 = Math.max(p.y, q.y) + 1;
+      for (const rect of query(sx0, sy0, sx1, sy1)) {
+        if (skip.includes(rect)) continue;
+        return null;
+      }
+    }
+    return len;
+  };
+  for (let ring = 0; ring < 6; ring += 1) {
+    const off = CELL * (ring === 0 ? 1 : 2 ** (ring + 1));
+    let best: FlowPoint[] | null = null;
+    let bestLen = Infinity;
+    for (const lane of laneAt(off)) {
+      const len = clearLane(lane);
+      if (len !== null && len < bestLen) {
+        bestLen = len;
+        best = lane;
+      }
+    }
+    if (best) return best;
+    growWindow(bounds, query, PAD);
+  }
+  return zRoute(a, b, sa, sb).slice(1, -1);
+}
 
 type Committed = { keys: number[]; x0: number; y0: number; x1: number; y1: number };
 
-type EdgeState = { points: FlowPoint[]; committed?: Committed };
+type RouteEdge = Pick<Edge, 'id' | 'source' | 'target'> & {
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+};
+
+type EdgeState = {
+  points: FlowPoint[];
+  a: FlowPoint;
+  b: FlowPoint;
+  committed?: Committed;
+};
+
+const samePoint = (a: FlowPoint, b: FlowPoint) => a.x === b.x && a.y === b.y;
+
+const targetInput = (edge: RouteEdge) => {
+  const handle = edge.targetHandle;
+  const n = handle?.startsWith('in-') ? Number(handle.slice(3)) : 0;
+  return Number.isFinite(n) ? n : 0;
+};
+
+const sourceOut = (edge: RouteEdge) => {
+  const n = /^out-(\d+)$/.exec(edge.sourceHandle ?? '')?.[1];
+  return n != null && Number.isFinite(Number(n)) ? Number(n) : 0;
+};
 
 export function createCircuitRouter(): (
   nodes: RouteNode[],
-  edges: Pick<Edge, 'id' | 'source' | 'target'>[],
-  direction: CalcDirection,
+  edges: RouteEdge[],
 ) => Map<string, FlowPoint[]> {
-  let prevDir: CalcDirection | null = null;
-  let prevRects = new Map<string, Rect>();
   let prevEdges = new Map<string, EdgeState>();
 
-  return (nodes, edges, direction) => {
+  return (nodes, edges) => {
     const out = new Map<string, FlowPoint[]>();
     const nextEdges = new Map<string, EdgeState>();
     if (!edges.length) {
-      prevDir = direction;
       prevEdges = nextEdges;
-      prevRects = new Map(nodes.map((n) => [n.id, toRect(n)]));
       return out;
     }
 
@@ -51,11 +163,10 @@ export function createCircuitRouter(): (
     const rects = new Map(nodes.map((node) => [node.id, toRect(node)]));
     const rectsInWindow = createRectBuckets(rects.values());
 
-    const rebuild = prevDir !== direction;
     const committed: Committed[] = [];
     const used = new Set<number>();
     const pending: {
-      edge: Pick<Edge, 'id' | 'source' | 'target'>;
+      edge: RouteEdge;
       s: RouteNode;
       t: RouteNode;
       a: FlowPoint;
@@ -66,20 +177,11 @@ export function createCircuitRouter(): (
     for (const edge of edges) {
       const s = byId.get(edge.source);
       const t = byId.get(edge.target);
-      const sRect = rects.get(edge.source);
-      const tRect = rects.get(edge.target);
+      if (!s || !t) continue;
+      const a = portAnchor(s, 'src', sourceOut(edge));
+      const b = portAnchor(t, 'tgt', targetInput(edge));
       const prev = prevEdges.get(edge.id);
-      if (
-        !rebuild &&
-        prev &&
-        sRect &&
-        tRect &&
-        prevRects.get(edge.source) &&
-        prevRects.get(edge.target) &&
-        sameRect(prevRects.get(edge.source)!, sRect) &&
-        sameRect(prevRects.get(edge.target)!, tRect)
-      ) {
-
+      if (prev && samePoint(prev.a, a) && samePoint(prev.b, b)) {
         out.set(edge.id, prev.points);
         nextEdges.set(edge.id, prev);
         if (prev.committed) {
@@ -88,9 +190,6 @@ export function createCircuitRouter(): (
         }
         continue;
       }
-      if (!s || !t || !sRect || !tRect) continue;
-      const a = portAnchor(s, 'src', direction);
-      const b = portAnchor(t, 'tgt', direction);
       pending.push({
         edge,
         s,
@@ -109,28 +208,34 @@ export function createCircuitRouter(): (
 
     for (const job of pending) {
       const { a, b } = job;
-      const horizontal = direction === 'horizontal';
-
-      const gap = horizontal ? a.x - b.x : a.y - b.y;
-      if (gap > 0 && (horizontal ? a.y === b.y : a.x === b.x)) {
 
+      const gap = b.x - a.x;
+      if (gap > 0 && a.y === b.y) {
         const points = [a, b];
         out.set(job.edge.id, points);
-        nextEdges.set(job.edge.id, { points });
+        nextEdges.set(job.edge.id, { points, a, b });
         continue;
       }
 
-      const stub = gap > 0 ? Math.min(STUB, gap / 2) : STUB;
-      const sa = horizontal
-        ? { x: a.x - stub, y: a.y }
-        : { x: a.x, y: a.y - stub };
-      const sb = horizontal
-        ? { x: b.x + stub, y: b.y }
-        : { x: b.x, y: b.y + stub };
-      const wx0 = Math.min(sa.x, sb.x) - WINDOW;
-      const wy0 = Math.min(sa.y, sb.y) - WINDOW;
-      const wx1 = Math.max(sa.x, sb.x) + WINDOW;
-      const wy1 = Math.max(sa.y, sb.y) + WINDOW;
+      const sa = {
+        x: a.x + stubLength(a, 1, [rects.get(job.s.id)!], rectsInWindow),
+        y: a.y,
+      };
+      const sb = {
+        x: b.x - stubLength(b, -1, [rects.get(job.t.id)!], rectsInWindow),
+        y: b.y,
+      };
+      const bounds = {
+        x0: Math.min(sa.x, sb.x) - WINDOW,
+        y0: Math.min(sa.y, sb.y) - WINDOW,
+        x1: Math.max(sa.x, sb.x) + WINDOW,
+        y1: Math.max(sa.y, sb.y) + WINDOW,
+      };
+      growWindow(bounds, rectsInWindow, PAD + CELL);
+      const wx0 = bounds.x0;
+      const wy0 = bounds.y0;
+      const wx1 = bounds.x1;
+      const wy1 = bounds.y1;
       const ox = Math.floor(wx0 / CELL);
       const oy = Math.floor(wy0 / CELL);
       const gw = Math.ceil(wx1 / CELL) - ox + 1;
@@ -165,10 +270,11 @@ export function createCircuitRouter(): (
           x: Math.min(gw - 1, Math.max(0, Math.round(sb.x / CELL) - ox)),
           y: Math.min(gh - 1, Math.max(0, Math.round(sb.y / CELL) - oy)),
         };
-        for (let pass = 0; pass < 2 && !cells; pass += 1) {
+        let best: number[][] | null = null;
+        let bestGrid: InstanceType<typeof PF.Grid> | null = null;
+        for (let pass = 0; pass < 2; pass += 1) {
           const grid = base.clone();
           if (pass === 0) {
-
             for (const c of committed) {
               if (
                 c.x1 < ox ||
@@ -196,17 +302,36 @@ export function createCircuitRouter(): (
             tCell.y,
             grid,
           );
-          if (path.length) {
-            cells = path.map(([cx, cy]) => [cx + ox, cy + oy]);
-            passGrid = grid;
+          if (!path.length) continue;
+          const mapped = path.map(([cx, cy]) => [cx + ox, cy + oy]);
+          if (pass === 1) {
+            if (best && best.length <= mapped.length * 1.34) break;
+            best = mapped;
+            bestGrid = grid;
+            break;
           }
+          best = mapped;
+          bestGrid = grid;
         }
+        cells = best;
+        passGrid = bestGrid;
       }
 
       if (!cells || !passGrid) {
-        const points = orthoPoints(zRoute(a, b, sa, sb, direction), direction);
+        const points = orthoPoints([
+          a,
+          ...detourRoute(
+            a,
+            b,
+            sa,
+            sb,
+            [rects.get(job.s.id)!, rects.get(job.t.id)!],
+            rectsInWindow,
+          ),
+          b,
+        ]);
         out.set(job.edge.id, points);
-        nextEdges.set(job.edge.id, { points });
+        nextEdges.set(job.edge.id, { points, a, b });
         continue;
       }
 
@@ -221,7 +346,7 @@ export function createCircuitRouter(): (
           g.isWalkableAt(x - ox, y - oy),
       );
       const polyline = cellsToPolyline(simple, sa, sb);
-      const points = orthoPoints([a, sa, ...polyline, sb, b], direction);
+      const points = orthoPoints([a, sa, ...polyline, sb, b]);
       out.set(job.edge.id, points);
 
       const keys: number[] = [];
@@ -259,12 +384,11 @@ export function createCircuitRouter(): (
         y1: cy1 === -Infinity ? 0 : cy1,
       };
       committed.push(entry);
-      nextEdges.set(job.edge.id, { points, committed: entry });
+      nextEdges.set(job.edge.id, { points, a: job.a, b: job.b, committed: entry });
     }
 
-    prevDir = direction;
-    prevRects = rects;
     prevEdges = nextEdges;
     return out;
   };
 }
+