kisch 1.0.0

package/src/manhattan-router.js

@@ -0,0 +1,176 @@
+import { Point, pointKey } from "../src/cartesian-math.js";
+
+function manhattan(a, b) {
+	return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
+}
+
+function rangeOverlap(a1, a2, b1, b2) {
+	const minA = Math.min(a1, a2);
+	const maxA = Math.max(a1, a2);
+	const minB = Math.min(b1, b2);
+	const maxB = Math.max(b1, b2);
+	return maxA > minB && maxB > minA;
+}
+
+/* ───────────────────────── Rect blocking (unchanged) ───────────────────────── */
+
+export function segmentBlocked(a, b, rects) {
+	const ax = a[0], ay = a[1];
+	const bx = b[0], by = b[1];
+
+	for (const r of rects) {
+		const rx = r.corner[0];
+		const ry = r.corner[1];
+		const rw = r.size[0];
+		const rh = r.size[1];
+
+		// horizontal
+		if (ay === by) {
+			if (
+				ay >= ry && ay <= ry + rh &&
+				rangeOverlap(ax, bx, rx, rx + rw)
+			) return true;
+		}
+
+		// vertical
+		if (ax === bx) {
+			if (
+				ax >= rx && ax <= rx + rw &&
+				rangeOverlap(ay, by, ry, ry + rh)
+			) return true;
+		}
+	}
+
+	return false;
+}
+
+/* ───────────────────────── Line blocking (NEW) ───────────────────────── */
+
+function similar(a,b) {
+	return Math.abs(a-b)<0.0000001
+}
+
+function segmentOverlapsLine(a1, a2, b1, b2) {
+	// horizontal
+//	if (a1[1] === a2[1] && b1[1] === b2[1] && a1[1] === b1[1]) {
+	if (similar(a1[1],a2[1]) && similar(b1[1],b2[1]) && similar(a1[1],b1[1])) {
+		return rangeOverlap(a1[0], a2[0], b1[0], b2[0]);
+	}
+
+	// vertical
+//	if (a1[0] === a2[0] && b1[0] === b2[0] && a1[0] === b1[0]) {
+	if (similar(a1[0],a2[0]) && similar(b1[0],b2[0]) && similar(a1[0],b1[0])) {
+		return rangeOverlap(a1[1], a2[1], b1[1], b2[1]);
+	}
+
+	return false;
+}
+
+export function segmentBlockedByLines(a, b, lines) {
+	for (const { a: l1, b: l2 } of lines) {
+		if (segmentOverlapsLine(a, b, l1, l2)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/* ───────────────────────── Path compression (unchanged) ───────────────────────── */
+
+function compressPath(points) {
+	if (points.length <= 2) return points;
+
+	const out = [points[0]];
+
+	for (let i = 1; i < points.length - 1; i++) {
+		const a = out[out.length - 1];
+		const b = points[i];
+		const c = points[i + 1];
+
+		const abx = b[0] - a[0];
+		const aby = b[1] - a[1];
+		const bcx = c[0] - b[0];
+		const bcy = c[1] - b[1];
+
+		if (
+			(abx === 0 && bcx === 0) ||
+			(aby === 0 && bcy === 0)
+		) continue;
+
+		out.push(b);
+	}
+
+	out.push(points[points.length - 1]);
+	return out; //.map(p=>p.snap(2.54));
+}
+
+/* ───────────────────────── Main router ───────────────────────── */
+
+export function findGridPath({
+	from,
+	to,
+	gridSize,
+	avoidRects = [],
+	avoidLines = []
+}) {
+	const open = new Map();
+	const closed = new Set();
+
+	open.set(pointKey(from), {
+		point: from,
+		g: 0,
+		f: manhattan(from, to),
+		parent: null
+	});
+
+	const steps = [
+		new Point([ gridSize, 0 ]),
+		new Point([ -gridSize, 0 ]),
+		new Point([ 0, gridSize ]),
+		new Point([ 0, -gridSize ])
+	];
+
+	while (open.size) {
+		let current = null;
+		for (const n of open.values()) {
+			if (!current || n.f < current.f) current = n;
+		}
+
+		if (current.point.equals(to)) {
+			const path = [];
+			let c = current;
+			while (c) {
+				path.push(c.point);
+				c = c.parent;
+			}
+			return compressPath(path.reverse());
+		}
+
+		open.delete(pointKey(current.point));
+		closed.add(pointKey(current.point));
+
+		for (const step of steps) {
+			const next = current.point.add(step);
+			const key = pointKey(next);
+
+			if (closed.has(key)) continue;
+			if (segmentBlocked(current.point, next, avoidRects)) continue;
+			if (segmentBlockedByLines(current.point, next, avoidLines)) continue;
+
+			const g = current.g + gridSize;
+			const f = g + manhattan(next, to);
+
+			const existing = open.get(key);
+			if (!existing || g < existing.g) {
+				open.set(key, {
+					point: next,
+					g,
+					f,
+					parent: current
+				});
+			}
+		}
+	}
+
+	throw new Error("No path found");
+}

package/src/place-rect.js

@@ -0,0 +1,45 @@
+export function placeRect({ rect, start, step, avoid, maxRadius = 1000 }) {
+    // test a candidate anchor point
+    function fitsAt(p) {
+        const placed = rect.translate(p);
+        return !avoid.some(r => placed.overlaps(r));
+    }
+
+    // try start position first
+    if (fitsAt(start)) {
+        return start;
+    }
+
+    let x = 0;
+    let y = 0;
+    let dir = 0;
+    let leg = 1;
+
+    const dirs = [
+        [ 1,  0], // right
+        [ 0,  1], // down
+        [-1,  0], // left
+        [ 0, -1], // up
+    ];
+
+    while (leg <= maxRadius) {
+        for (let repeat = 0; repeat < 2; repeat++) {
+            const [dx, dy] = dirs[dir & 3];
+
+            for (let i = 0; i < leg; i++) {
+                x += dx;
+                y += dy;
+
+                const p = start.add([x * step, y * step]);
+                if (fitsAt(p)) {
+                    return p;
+                }
+            }
+
+            dir++;
+        }
+        leg++;
+    }
+
+    return null;
+}

package/src/sexp.js

@@ -0,0 +1,178 @@
+import util from 'node:util';
+
+/*export function sexpFind(sexp, pred) {
+    if (!Array.isArray(sexp))
+        return;
+
+
+}*/
+
+export function sexpCallName(sexp) {
+    if (!Array.isArray(sexp))
+        return;
+
+    return symName(sexp[0]);
+}
+
+export function sym(name) {
+    return { $sym: String(name) }
+}
+
+export function isSym(v) {
+    return (
+        v !== null &&
+        typeof v === 'object' &&
+        typeof v.$sym === 'string'
+    )
+}
+
+export function symName(v) {
+    return isSym(v) ? v.$sym : null
+}
+
+export function symEq(v, other) {
+    if (!isSym(v)) return false
+
+    if (isSym(other)) {
+        return v.$sym === other.$sym
+    }
+
+    if (typeof other === 'string') {
+        return v.$sym === other
+    }
+
+    return false
+}
+
+export function sexpParse(input) {
+    let i = 0
+
+    const skipWhitespace = () => {
+        while (i < input.length && /\s/.test(input[i])) i++
+    }
+
+    const parseString = () => {
+        let str = ''
+        i++ // skip opening "
+        while (i < input.length) {
+            if (input[i] === '"') {
+                i++
+                break
+            } else if (input[i] === '\\') {
+                i++
+                str += input[i] || ''
+            } else {
+                str += input[i]
+            }
+            i++
+        }
+        return str
+    }
+
+    const parseAtomOrNumber = () => {
+        let start = i
+        while (i < input.length && /[^\s()]/.test(input[i])) i++
+        const token = input.slice(start, i)
+
+        if (!isNaN(token)) {
+            return Number(token)
+        }
+
+        return sym(token)
+    }
+
+    const parseList = () => {
+        const list = []
+        i++ // skip '('
+        while (i < input.length) {
+            skipWhitespace()
+            if (i >= input.length) break
+
+            if (input[i] === ')') {
+                i++
+                break
+            } else if (input[i] === '(') {
+                list.push(parseList())
+            } else if (input[i] === '"') {
+                list.push(parseString())
+            } else {
+                list.push(parseAtomOrNumber())
+            }
+        }
+        return list
+    }
+
+    const result = []
+    while (i < input.length) {
+        skipWhitespace()
+        if (i >= input.length) break
+
+        if (input[i] === '(') {
+            result.push(parseList())
+        } else if (input[i] === '"') {
+            result.push(parseString())
+        } else {
+            result.push(parseAtomOrNumber())
+        }
+    }
+
+    return result
+}
+
+export function sexpStringify(sexpr, indent) {
+    const pretty = typeof indent === 'number' && indent > 0
+    const space = (n) => pretty ? ' '.repeat(indent * n) : ''
+
+    const serializeAtom = (node) => {
+        if (isSym(node)) {
+            return symName(node)
+        }
+        if (typeof node === 'string') {
+            return `"${node.replace(/(["\\])/g, '\\$1')}"`
+        }
+        return String(node)
+    }
+
+    const serialize = (node, level) => {
+        // atom
+        if (!Array.isArray(node)) {
+            return serializeAtom(node)
+        }
+
+        if (node.length === 0) return '()'
+
+        const head = node[0]
+        const rest = node.slice(1)
+
+        let out = '(' + serializeAtom(head)
+        let i = 0
+
+        // inline atoms after head
+        while (i < rest.length && !Array.isArray(rest[i])) {
+            out += ' ' + serializeAtom(rest[i])
+            i++
+        }
+
+        // no pretty-printing or everything fit inline
+        if (!pretty || i === rest.length) {
+            for (; i < rest.length; i++) {
+                out += ' ' + serialize(rest[i], level + 1)
+            }
+            return out + ')'
+        }
+
+        // pretty-print remaining forms
+        const lines = rest.slice(i).map(
+            n => space(level + 1) + serialize(n, level + 1)
+        )
+
+        return (
+            out + '\n' +
+            lines.join('\n') +
+            '\n' +
+            space(level) + ')'
+        )
+    }
+
+    return sexpr.map(node => serialize(node, 0)).join(pretty ? '\n' : ' ')
+}