Prototipo del motore: scena, camminata, verbi, inventario, dialoghi, salvataggio

Motore guidato dai dati con due scene di prova (Piazza e salita alla Fortezza),
percorsi su area concava, clic intelligente e pressione lunga, test della soluzione
completa in node e nel browser con Playwright. Nel documento la leggenda del nonno.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/engine/geometry.js

@@ -0,0 +1,97 @@
+// Area calpestabile: un poligono semplice (anche concavo) in coordinate di scena.
+// Il percorso passa per i vertici concavi (grafo di visibilità + A*), così il personaggio
+// gira attorno agli angoli invece di attraversare i muri.
+const EPS = 1e-6;
+
+export const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+
+function onSegment(p, a, b, tol = 0.5) {
+    const [px, py] = p, [ax, ay] = a, [bx, by] = b;
+    const len2 = (bx - ax) ** 2 + (by - ay) ** 2;
+    const t = len2 ? Math.max(0, Math.min(1, ((px - ax) * (bx - ax) + (py - ay) * (by - ay)) / len2)) : 0;
+    return dist(p, [ax + t * (bx - ax), ay + t * (by - ay)]) <= tol;
+}
+
+// Dentro o sul bordo (con tolleranza di mezzo pixel).
+export function inside(poly, p) {
+    let hit = false;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const a = poly[i], b = poly[j];
+        if (onSegment(p, a, b)) return true;
+        if ((a[1] > p[1]) !== (b[1] > p[1]) && p[0] < (b[0] - a[0]) * (p[1] - a[1]) / (b[1] - a[1]) + a[0]) hit = !hit;
+    }
+    return hit;
+}
+
+const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+
+// Incrocio proprio: i due segmenti si tagliano in un punto interno a entrambi.
+function crosses(p1, p2, q1, q2) {
+    const d1 = cross(q1, q2, p1), d2 = cross(q1, q2, p2), d3 = cross(p1, p2, q1), d4 = cross(p1, p2, q2);
+    return ((d1 > EPS && d2 < -EPS) || (d1 < -EPS && d2 > EPS)) && ((d3 > EPS && d4 < -EPS) || (d3 < -EPS && d4 > EPS));
+}
+
+export function visible(poly, a, b) {
+    if (!inside(poly, a) || !inside(poly, b)) return false;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++)
+        if (crosses(a, b, poly[i], poly[j])) return false;
+    // Un segmento che passa per due vertici può uscire senza incrociare nessun lato: si campiona.
+    for (let k = 1; k < 8; k++) {
+        const t = k / 8;
+        if (!inside(poly, [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t])) return false;
+    }
+    return true;
+}
+
+export function nearestInside(poly, p) {
+    if (inside(poly, p)) return [p[0], p[1]];
+    let best = null, bestD = Infinity;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const [ax, ay] = poly[j], [bx, by] = poly[i];
+        const len2 = (bx - ax) ** 2 + (by - ay) ** 2;
+        const t = len2 ? Math.max(0, Math.min(1, ((p[0] - ax) * (bx - ax) + (p[1] - ay) * (by - ay)) / len2)) : 0;
+        const q = [ax + t * (bx - ax), ay + t * (by - ay)], d = dist(p, q);
+        if (d < bestD) { bestD = d; best = q; }
+    }
+    return best;
+}
+
+function signedArea(poly) {
+    let s = 0;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) s += poly[j][0] * poly[i][1] - poly[i][0] * poly[j][1];
+    return s / 2;
+}
+
+// I vertici concavi (svolta contraria al verso del poligono) sono gli unici dove un percorso minimo può piegare.
+export function concaveVertices(poly) {
+    const sign = Math.sign(signedArea(poly)), n = poly.length;
+    return poly.filter((v, i) => sign * cross(poly[(i - 1 + n) % n], v, poly[(i + 1) % n]) < -EPS);
+}
+
+export function findPath(poly, from, to) {
+    const start = nearestInside(poly, from), goal = nearestInside(poly, to);
+    if (visible(poly, start, goal)) return [goal];
+    const nodes = [start, goal, ...concaveVertices(poly)];
+    const g = new Map([[0, 0]]), prev = new Map(), open = new Set([0]), done = new Set();
+    while (open.size) {
+        let cur = -1, curF = Infinity;
+        for (const i of open) {
+            const f = g.get(i) + dist(nodes[i], goal);
+            if (f < curF) { curF = f; cur = i; }
+        }
+        if (cur === 1) break;
+        open.delete(cur);
+        done.add(cur);
+        for (let i = 0; i < nodes.length; i++) {
+            if (i === cur || done.has(i) || !visible(poly, nodes[cur], nodes[i])) continue;
+            const cost = g.get(cur) + dist(nodes[cur], nodes[i]);
+            if (cost < (g.get(i) ?? Infinity)) { g.set(i, cost); prev.set(i, cur); open.add(i); }
+        }
+    }
+    if (!prev.has(1)) return [start];
+    const path = [];
+    for (let i = 1; i !== 0; i = prev.get(i)) path.unshift(nodes[i]);
+    return path;
+}
+
+export const inBox = ([x, y, w, h], p) => p[0] >= x && p[0] <= x + w && p[1] >= y && p[1] <= y + h;