hoi4-agent-tools 1.0.0 → 1.1.0

package/dist/hoi4_agent_tools/focus/geometry.js

@@ -1,30 +1,217 @@
 // Shared visual contract for the renderer and constraint solver. Coordinates
-// remain ordinary HOI4 focus-grid units; the pixel conversion proves whether
-// two rendered node rectangles intersect.
+// remain ordinary HOI4 focus-grid units; connector geometry is converted to
+// the same deterministic pixel-space cubic used in SVG review artifacts.
 export const FOCUS_HORIZONTAL_GRID_PIXELS = 176;
 export const FOCUS_VERTICAL_GRID_PIXELS = 116;
 export const FOCUS_NODE_WIDTH_PIXELS = 144;
 export const FOCUS_NODE_HEIGHT_PIXELS = 76;
+export const FOCUS_CONNECTOR_FLATTEN_SEGMENTS = 24;
+const GEOMETRY_EPSILON = 1e-7;
+function resolvedGeometry(options) {
+    return {
+        horizontalSpacing: options.horizontalSpacing ?? FOCUS_HORIZONTAL_GRID_PIXELS,
+        verticalSpacing: options.verticalSpacing ?? FOCUS_VERTICAL_GRID_PIXELS,
+        nodeWidth: options.nodeWidth ?? FOCUS_NODE_WIDTH_PIXELS,
+        nodeHeight: options.nodeHeight ?? FOCUS_NODE_HEIGHT_PIXELS,
+        originX: options.originX ?? 0,
+        originY: options.originY ?? 0,
+    };
+}
 export function focusNodesVisiblyOverlap(left, right) {
     return (Math.abs(left.x - right.x) * FOCUS_HORIZONTAL_GRID_PIXELS < FOCUS_NODE_WIDTH_PIXELS &&
         Math.abs(left.y - right.y) * FOCUS_VERTICAL_GRID_PIXELS < FOCUS_NODE_HEIGHT_PIXELS);
 }
+export function focusNodeRectangle(node, options = {}) {
+    const geometry = resolvedGeometry(options);
+    const minimumX = geometry.originX + node.x * geometry.horizontalSpacing;
+    const minimumY = geometry.originY + node.y * geometry.verticalSpacing;
+    return {
+        minimumX,
+        minimumY,
+        maximumX: minimumX + geometry.nodeWidth,
+        maximumY: minimumY + geometry.nodeHeight,
+    };
+}
+/** The exact cubic rendered for a prerequisite connector. */
+export function focusConnectorCurve(parent, child, options = {}) {
+    const geometry = resolvedGeometry(options);
+    const parentRectangle = focusNodeRectangle(parent, geometry);
+    const childRectangle = focusNodeRectangle(child, geometry);
+    const start = {
+        x: (parentRectangle.minimumX + parentRectangle.maximumX) / 2,
+        y: parentRectangle.maximumY,
+    };
+    const end = {
+        x: (childRectangle.minimumX + childRectangle.maximumX) / 2,
+        y: childRectangle.minimumY,
+    };
+    const middleY = (start.y + end.y) / 2;
+    return {
+        start,
+        firstControl: { x: start.x, y: middleY },
+        secondControl: { x: end.x, y: middleY },
+        end,
+    };
+}
+/** Serialize the shared connector primitive without introducing renderer-only rounding. */
+export function focusConnectorSvgPath(curve) {
+    return `M ${curve.start.x} ${curve.start.y} C ${curve.firstControl.x} ${curve.firstControl.y}, ${curve.secondControl.x} ${curve.secondControl.y}, ${curve.end.x} ${curve.end.y}`;
+}
+function cubicCoordinate(start, firstControl, secondControl, end, progress) {
+    const remaining = 1 - progress;
+    return (remaining * remaining * remaining * start +
+        3 * remaining * remaining * progress * firstControl +
+        3 * remaining * progress * progress * secondControl +
+        progress * progress * progress * end);
+}
+/** Fixed-size flattening keeps intersection work deterministic and bounded. */
+export function flattenFocusConnectorCurve(curve) {
+    return Array.from({ length: FOCUS_CONNECTOR_FLATTEN_SEGMENTS + 1 }, (_unused, index) => {
+        const progress = index / FOCUS_CONNECTOR_FLATTEN_SEGMENTS;
+        return {
+            x: cubicCoordinate(curve.start.x, curve.firstControl.x, curve.secondControl.x, curve.end.x, progress),
+            y: cubicCoordinate(curve.start.y, curve.firstControl.y, curve.secondControl.y, curve.end.y, progress),
+        };
+    });
+}
+function pointBounds(points) {
+    let minimumX = Infinity;
+    let minimumY = Infinity;
+    let maximumX = -Infinity;
+    let maximumY = -Infinity;
+    for (const point of points) {
+        minimumX = Math.min(minimumX, point.x);
+        minimumY = Math.min(minimumY, point.y);
+        maximumX = Math.max(maximumX, point.x);
+        maximumY = Math.max(maximumY, point.y);
+    }
+    return { minimumX, minimumY, maximumX, maximumY };
+}
+function rectanglesOverlap(left, right) {
+    return !(left.maximumX < right.minimumX - GEOMETRY_EPSILON ||
+        right.maximumX < left.minimumX - GEOMETRY_EPSILON ||
+        left.maximumY < right.minimumY - GEOMETRY_EPSILON ||
+        right.maximumY < left.minimumY - GEOMETRY_EPSILON);
+}
 function orientation(first, second, third) {
-    return Math.sign((second.y - first.y) * (third.x - second.x) - (second.x - first.x) * (third.y - second.y));
-}
-/**
- * Returns true only for a proper interior intersection. Connector pairs that
- * merely touch, overlap collinearly, or share a focus endpoint are handled by
- * their callers and do not count as a crossing.
- */
-export function focusConnectorSegmentsProperlyCross(firstStart, firstEnd, secondStart, secondEnd) {
-    const values = [
-        orientation(firstStart, firstEnd, secondStart),
-        orientation(firstStart, firstEnd, secondEnd),
-        orientation(secondStart, secondEnd, firstStart),
-        orientation(secondStart, secondEnd, firstEnd),
+    const crossProduct = (second.x - first.x) * (third.y - first.y) - (second.y - first.y) * (third.x - first.x);
+    return Math.abs(crossProduct) <= GEOMETRY_EPSILON ? 0 : Math.sign(crossProduct);
+}
+function pointOnSegment(point, start, end) {
+    return (orientation(start, end, point) === 0 &&
+        point.x >= Math.min(start.x, end.x) - GEOMETRY_EPSILON &&
+        point.x <= Math.max(start.x, end.x) + GEOMETRY_EPSILON &&
+        point.y >= Math.min(start.y, end.y) - GEOMETRY_EPSILON &&
+        point.y <= Math.max(start.y, end.y) + GEOMETRY_EPSILON);
+}
+function segmentsIntersect(firstStart, firstEnd, secondStart, secondEnd) {
+    if (!rectanglesOverlap({
+        minimumX: Math.min(firstStart.x, firstEnd.x),
+        minimumY: Math.min(firstStart.y, firstEnd.y),
+        maximumX: Math.max(firstStart.x, firstEnd.x),
+        maximumY: Math.max(firstStart.y, firstEnd.y),
+    }, {
+        minimumX: Math.min(secondStart.x, secondEnd.x),
+        minimumY: Math.min(secondStart.y, secondEnd.y),
+        maximumX: Math.max(secondStart.x, secondEnd.x),
+        maximumY: Math.max(secondStart.y, secondEnd.y),
+    }))
+        return false;
+    const firstStartOrientation = orientation(firstStart, firstEnd, secondStart);
+    const firstEndOrientation = orientation(firstStart, firstEnd, secondEnd);
+    const secondStartOrientation = orientation(secondStart, secondEnd, firstStart);
+    const secondEndOrientation = orientation(secondStart, secondEnd, firstEnd);
+    if (firstStartOrientation * firstEndOrientation < 0 &&
+        secondStartOrientation * secondEndOrientation < 0)
+        return true;
+    return ((firstStartOrientation === 0 && pointOnSegment(secondStart, firstStart, firstEnd)) ||
+        (firstEndOrientation === 0 && pointOnSegment(secondEnd, firstStart, firstEnd)) ||
+        (secondStartOrientation === 0 && pointOnSegment(firstStart, secondStart, secondEnd)) ||
+        (secondEndOrientation === 0 && pointOnSegment(firstEnd, secondStart, secondEnd)));
+}
+function polylineSegments(points) {
+    const segments = [];
+    for (let index = 1; index < points.length; index += 1) {
+        const start = points[index - 1];
+        const end = points[index];
+        if (start === undefined || end === undefined)
+            continue;
+        segments.push({
+            start,
+            end,
+            minimumY: Math.min(start.y, end.y),
+            maximumY: Math.max(start.y, end.y),
+        });
+    }
+    return segments.sort((left, right) => left.minimumY - right.minimumY ||
+        left.maximumY - right.maximumY ||
+        left.start.x - right.start.x ||
+        left.end.x - right.end.x);
+}
+export function focusConnectorPolylinesIntersect(firstPoints, secondPoints) {
+    if (!rectanglesOverlap(pointBounds(firstPoints), pointBounds(secondPoints)))
+        return false;
+    const firstSegments = polylineSegments(firstPoints);
+    const secondSegments = polylineSegments(secondPoints);
+    let secondStartIndex = 0;
+    for (const first of firstSegments) {
+        while (secondStartIndex < secondSegments.length &&
+            (secondSegments[secondStartIndex]?.maximumY ?? Infinity) < first.minimumY - GEOMETRY_EPSILON)
+            secondStartIndex += 1;
+        for (let secondIndex = secondStartIndex; secondIndex < secondSegments.length; secondIndex += 1) {
+            const second = secondSegments[secondIndex];
+            if (second === undefined)
+                continue;
+            if (second.minimumY > first.maximumY + GEOMETRY_EPSILON)
+                break;
+            if (segmentsIntersect(first.start, first.end, second.start, second.end))
+                return true;
+        }
+    }
+    return false;
+}
+export function focusConnectorCurvesIntersect(first, second) {
+    return focusConnectorPolylinesIntersect(flattenFocusConnectorCurve(first), flattenFocusConnectorCurve(second));
+}
+export function focusConnectorsVisiblyIntersect(firstParent, firstChild, secondParent, secondChild, options = {}) {
+    return focusConnectorCurvesIntersect(focusConnectorCurve(firstParent, firstChild, options), focusConnectorCurve(secondParent, secondChild, options));
+}
+function pointInsideRectangle(point, rectangle) {
+    return (point.x >= rectangle.minimumX - GEOMETRY_EPSILON &&
+        point.x <= rectangle.maximumX + GEOMETRY_EPSILON &&
+        point.y >= rectangle.minimumY - GEOMETRY_EPSILON &&
+        point.y <= rectangle.maximumY + GEOMETRY_EPSILON);
+}
+export function focusConnectorPolylineIntersectsRectangle(points, rectangle) {
+    if (!rectanglesOverlap(pointBounds(points), rectangle))
+        return false;
+    const topLeft = { x: rectangle.minimumX, y: rectangle.minimumY };
+    const topRight = { x: rectangle.maximumX, y: rectangle.minimumY };
+    const bottomRight = { x: rectangle.maximumX, y: rectangle.maximumY };
+    const bottomLeft = { x: rectangle.minimumX, y: rectangle.maximumY };
+    const sides = [
+        [topLeft, topRight],
+        [topRight, bottomRight],
+        [bottomRight, bottomLeft],
+        [bottomLeft, topLeft],
     ];
-    return values.every((value) => value !== 0) && values[0] !== values[1] && values[2] !== values[3];
+    for (let index = 1; index < points.length; index += 1) {
+        const start = points[index - 1];
+        const end = points[index];
+        if (start === undefined || end === undefined)
+            continue;
+        if (pointInsideRectangle(start, rectangle) || pointInsideRectangle(end, rectangle))
+            return true;
+        if (sides.some(([sideStart, sideEnd]) => segmentsIntersect(start, end, sideStart, sideEnd)))
+            return true;
+    }
+    return false;
+}
+export function focusConnectorCurveIntersectsRectangle(curve, rectangle) {
+    return focusConnectorPolylineIntersectsRectangle(flattenFocusConnectorCurve(curve), rectangle);
+}
+export function focusConnectorIntersectsNode(parent, child, node, options = {}) {
+    return focusConnectorCurveIntersectsRectangle(focusConnectorCurve(parent, child, options), focusNodeRectangle(node, options));
 }
 export function focusNodeOrigin(node, minimumX, minimumY, padding, horizontalSpacing = FOCUS_HORIZONTAL_GRID_PIXELS, verticalSpacing = FOCUS_VERTICAL_GRID_PIXELS) {
     return {

package/dist/hoi4_agent_tools/focus/index.js

@@ -1,4 +1,5 @@
 export * from './compiler.js';
+export * from './compact.js';
 export * from './continuous-render.js';
 export * from './drift.js';
 export * from './geometry.js';