sci2-ts 0.0.0-stage → 0.2.2

package/packages/sci/src/gfx/view-file.ts

@@ -0,0 +1,233 @@
+import type { Cel } from "./cel.ts";
+import { decodeCel } from "./cel.ts";
+import { parseHunkPaletteFile, writeHunkPalette, type HunkPaletteFile } from "./pic-file.ts";
+
+/**
+ * A view resource with everything needed to write it back byte for byte. Measured on all
+ * 500 views of an SCI2 game (every one has this layout; all 9,628 cels are RLE-compressed):
+ *
+ *   header (18): +0 u16 16  +2 u8 loop count  +3 u8 0  +4 u8 `flags` (1)  +5 u8 0
+ *                +6 u8 total cels  +7 u8 0  +8 u32 palette offset  +12 u8 16  +13 u8 36
+ *   loop headers (16): +0 i8 linked loop (-1 = own cels)  +1 u8 mirror  +2 u8 cel count
+ *                      +3 ff ff ff ff 03 00 00 00 00  +12 u32 first cel header
+ *                      (a linked loop's points at where the next cel headers begin)
+ *   cel headers (36), loop by loop: +0 u16 w  +2 u16 h  +4 i16 dx  +6 i16 dy  +8 u8 skip
+ *                      +9 u8 0x8a  +12 u32 control+literal bytes  +16 u32 control bytes
+ *                      +24 control offset  +28 literal offset  +32 row table offset
+ *   00 03 u32 size | hunk palette
+ *   00 04 u32 size | every cel's control stream, then every cel's literal stream
+ *   00 05 u32 size | every cel's row table (u32 control offsets, then u32 literal offsets)
+ */
+export interface ViewFile {
+  flags: number;
+  loops: ViewLoop[];
+  palette: HunkPaletteFile | undefined;
+  /** The two chunk-size words (498 views: control+literal bytes, 0; 2 views: control, literal). */
+  chunkSizes?: [number, number];
+}
+
+export interface ViewLoop {
+  /** -1: this loop has its own cels; otherwise it reuses loop `link`'s (mirrored if `mirror`). */
+  link: number;
+  mirror: boolean;
+  cels: ViewCel[];
+}
+
+export interface ViewCel extends Cel {
+  /**
+   * The cel's compressed streams as read, reused while `pixels` still equals `original`.
+   * Sierra's encoder follows heuristics we don't reproduce exactly,
+   * so keeping them is what makes untouched views round-trip byte for byte.
+   */
+  encoded?: RleCel & { original: Uint8Array };
+}
+
+export interface RleCel {
+  control: number[] | Uint8Array;
+  literal: number[] | Uint8Array;
+  rowControl: number[];
+  rowLiteral: number[];
+}
+
+const HEADER = 18, LOOP = 16, CEL = 36;
+const LOOP_FILLER = [0xff, 0xff, 0xff, 0xff, 0x03, 0, 0, 0, 0];
+
+export function parseViewFile(data: Uint8Array): ViewFile {
+  const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const loopCount = data[2]!;
+  const palette = v.getUint32(8, true);
+  const loops: ViewLoop[] = [];
+  for (let i = 0; i < loopCount; i++) {
+    const lh = HEADER + LOOP * i;
+    const link = v.getInt8(lh);
+    const first = v.getUint32(lh + 12, true);
+    loops.push({
+      link,
+      mirror: data[lh + 1] === 1,
+      cels: link === -1 ? Array.from({ length: data[lh + 2]! }, (_, c) => readCel(data, first + CEL * c)) : [],
+    });
+  }
+  let chunkSizes: [number, number] | undefined;
+  const firstCel = loops.findIndex((l) => l.link === -1 && l.cels.length);
+  if (firstCel >= 0) {
+    const h = v.getUint32(HEADER + LOOP * firstCel + 12, true);
+    const ctrl = v.getUint32(h + 24, true), rows = v.getUint32(h + 32, true);
+    const litEnd = rows - 6;
+    chunkSizes = [v.getUint32(ctrl - 4, true), v.getUint32(litEnd + 2, true)];
+  }
+  return { flags: data[4]!, loops, palette: palette ? parseHunkPaletteFile(data, palette) : undefined, chunkSizes };
+}
+
+function readCel(data: Uint8Array, h: number): ViewCel {
+  const cel: ViewCel = decodeCel(data, h);
+  const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const ctrlSize = v.getUint32(h + 16, true), total = v.getUint32(h + 12, true);
+  const ctrl = v.getUint32(h + 24, true), lit = v.getUint32(h + 28, true), rows = v.getUint32(h + 32, true);
+  cel.encoded = {
+    control: data.slice(ctrl, ctrl + ctrlSize),
+    literal: data.slice(lit, lit + total - ctrlSize),
+    rowControl: Array.from({ length: cel.height }, (_, y) => v.getUint32(rows + y * 4, true)),
+    rowLiteral: Array.from({ length: cel.height }, (_, y) => v.getUint32(rows + (cel.height + y) * 4, true)),
+    original: cel.pixels.slice(),
+  };
+  return cel;
+}
+
+/**
+ * SCI32 cel RLE, one row at a time: transparent pixels as transparent runs (11nnnnnn), equal
+ * pixels as colour runs (10nnnnnn + the colour in the literal stream), the rest as literals
+ * (0nnnnnnn + that many bytes); runs hold up to 63 pixels, literal groups up to 127.
+ *
+ * Each row is split to use the fewest bytes: a transparent run costs 1, a colour run 2, a
+ * literal group 1 + its length (and may include a lone transparent pixel when that's
+ * cheaper, as Sierra's encoder also does). The result is never larger than Sierra's.
+ */
+export function encodeCelRle(cel: Cel): RleCel & { control: number[]; literal: number[] } {
+  const control: number[] = [], literal: number[] = [], rowControl: number[] = [], rowLiteral: number[] = [];
+  const { width: w, height: h, pixels, skipColor } = cel;
+  for (let y = 0; y < h; y++) {
+    rowControl.push(control.length);
+    rowLiteral.push(literal.length);
+    const row = pixels.subarray(y * w, (y + 1) * w);
+    let x = 0;
+    for (const [kind, n] of cheapestSplit(row, skipColor)) {
+      if (kind === "skip") control.push(0xc0 | n);
+      else if (kind === "run") {
+        control.push(0x80 | n);
+        literal.push(row[x]!);
+      } else {
+        control.push(n);
+        for (let k = 0; k < n; k++) literal.push(row[x + k]!);
+      }
+      x += n;
+    }
+  }
+  return { control, literal, rowControl, rowLiteral };
+}
+
+type Token = ["skip" | "run" | "lit", number];
+
+/** Fewest bytes for a row: dynamic programming from the end. */
+function cheapestSplit(row: Uint8Array, skipColor: number): Token[] {
+  const n = row.length;
+  const cost = new Array<number>(n + 1).fill(Infinity);
+  const pick: Token[] = new Array(n);
+  cost[n] = 0;
+  for (let i = n - 1; i >= 0; i--) {
+    let same = 1;
+    while (i + same < n && row[i + same] === row[i] && same < 63) same++;
+    const transparent = row[i] === skipColor;
+    for (let k = same; k >= (transparent ? 1 : 2); k--) {
+      const c = (transparent ? 1 : 2) + cost[i + k]!;
+      if (c < cost[i]!) (cost[i] = c), (pick[i] = [transparent ? "skip" : "run", k]);
+    }
+    for (let k = 1; k <= Math.min(127, n - i); k++) {
+      const c = 1 + k + cost[i + k]!;
+      if (c < cost[i]!) (cost[i] = c), (pick[i] = ["lit", k]);
+    }
+  }
+  const out: Token[] = [];
+  for (let i = 0; i < n; i += pick[i]![1]) out.push(pick[i]!);
+  return out;
+}
+
+/** The cel's streams: as read if its pixels are untouched, else freshly encoded. */
+function streamsOf(cel: ViewCel): RleCel {
+  const e = cel.encoded;
+  if (e && e.original.length === cel.pixels.length && e.original.every((p, i) => p === cel.pixels[i])) return e;
+  return encodeCelRle(cel);
+}
+
+export function writeView(view: ViewFile): Uint8Array {
+  const own = view.loops.filter((l) => l.link === -1);
+  const cels = own.flatMap((l) => l.cels);
+  const encoded = cels.map(streamsOf);
+  const palette = view.palette ? writeHunkPalette(view.palette) : undefined;
+  const headersEnd = HEADER + LOOP * view.loops.length + CEL * cels.length;
+  const paletteAt = palette ? headersEnd + 6 : 0;
+  const ctrlChunk = (palette ? paletteAt + palette.length : headersEnd) + 6;
+  const ctrlSize = encoded.reduce((n, e) => n + e.control.length, 0);
+  const litSize = encoded.reduce((n, e) => n + e.literal.length, 0);
+  const litAt = ctrlChunk + ctrlSize;
+  const rowsAt = litAt + litSize + 6;
+  const rowsSize = cels.reduce((n, c) => n + c.height * 8, 0);
+  const out = new Uint8Array(rowsAt + rowsSize);
+  const v = new DataView(out.buffer);
+
+  v.setUint16(0, HEADER - 2, true);
+  out[2] = view.loops.length;
+  out[4] = view.flags;
+  out[6] = cels.length;
+  v.setUint32(8, paletteAt, true);
+  out[12] = LOOP;
+  out[13] = CEL;
+
+  // Loop headers; cel headers follow in loop order.
+  let celHeader = HEADER + LOOP * view.loops.length;
+  let celIndex = 0;
+  let ctrl = ctrlChunk, lit = litAt, rows = rowsAt;
+  view.loops.forEach((loop, i) => {
+    const lh = HEADER + LOOP * i;
+    v.setInt8(lh, loop.link);
+    out[lh + 1] = loop.mirror ? 1 : 0;
+    out[lh + 2] = loop.link === -1 ? loop.cels.length : 0;
+    out.set(LOOP_FILLER, lh + 3);
+    v.setUint32(lh + 12, celHeader, true);
+    if (loop.link !== -1) return;
+    for (const cel of loop.cels) {
+      const e = encoded[celIndex++]!;
+      const h = celHeader;
+      v.setUint16(h, cel.width, true);
+      v.setUint16(h + 2, cel.height, true);
+      v.setInt16(h + 4, cel.displaceX, true);
+      v.setInt16(h + 6, cel.displaceY, true);
+      out[h + 8] = cel.skipColor;
+      out[h + 9] = 0x8a;
+      v.setUint32(h + 12, e.control.length + e.literal.length, true);
+      v.setUint32(h + 16, e.control.length, true);
+      v.setUint32(h + 24, ctrl, true);
+      v.setUint32(h + 28, lit, true);
+      v.setUint32(h + 32, rows, true);
+      out.set(e.control, ctrl);
+      out.set(e.literal, lit);
+      e.rowControl.forEach((o, y) => v.setUint32(rows + y * 4, o, true));
+      e.rowLiteral.forEach((o, y) => v.setUint32(rows + (cel.height + y) * 4, o, true));
+      ctrl += e.control.length;
+      lit += e.literal.length;
+      rows += cel.height * 8;
+      celHeader += CEL;
+    }
+  });
+
+  const [size4, size5] = view.chunkSizes ?? [ctrlSize + litSize, 0];
+  if (palette) {
+    out.set([0, 3], headersEnd);
+    v.setUint32(headersEnd + 2, palette.length, true);
+    out.set(palette, paletteAt);
+  }
+  out.set([0, 4], ctrlChunk - 6);
+  v.setUint32(ctrlChunk - 4, size4, true);
+  out.set([0, 5], rowsAt - 6);
+  v.setUint32(rowsAt - 4, size5, true);
+  return out;
+}

package/packages/sci/src/gfx/view.d.ts

@@ -0,0 +1,28 @@
+import { type Cel } from "./cel.ts";
+import { type Palette } from "./palette.ts";
+export interface Loop {
+    /** Loop drawn as a horizontal mirror of another (e.g. walking left = walking right, flipped). */
+    mirror: boolean;
+    cels: Cel[];
+}
+/** A view: sprite animations grouped into loops (usually one per facing direction). */
+export interface View {
+    loops: Loop[];
+    palette: Palette | undefined;
+}
+/**
+ * SCI32 view layout:
+ *
+ *   +0  u16 header size (loop headers start at 2 + this)
+ *   +2  u8  loop count
+ *   +8  u32 embedded palette offset (0 = none)
+ *   +12 u8  loop header size
+ *   +13 u8  cel header size
+ *
+ * Loop header:
+ *   +0  i8  linked loop (-1 = own cels; otherwise reuse that loop's cels)
+ *   +1  u8  1 = mirror the linked loop
+ *   +2  u8  cel count
+ *   +12 u32 offset of the first cel header
+ */
+export declare function parseView(data: Uint8Array): View;

package/packages/sci/src/gfx/view.js

@@ -0,0 +1,45 @@
+import { decodeCel } from "./cel.js";
+import { parseHunkPalette } from "./palette.js";
+/**
+ * SCI32 view layout:
+ *
+ *   +0  u16 header size (loop headers start at 2 + this)
+ *   +2  u8  loop count
+ *   +8  u32 embedded palette offset (0 = none)
+ *   +12 u8  loop header size
+ *   +13 u8  cel header size
+ *
+ * Loop header:
+ *   +0  i8  linked loop (-1 = own cels; otherwise reuse that loop's cels)
+ *   +1  u8  1 = mirror the linked loop
+ *   +2  u8  cel count
+ *   +12 u32 offset of the first cel header
+ */
+export function parseView(data) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const headerSize = v.getUint16(0, true);
+    const loopCount = data[2];
+    const paletteOffset = v.getUint32(8, true);
+    const loopHeaderSize = data[12];
+    const celHeaderSize = data[13];
+    const loopHeaderAt = (i) => 2 + headerSize + loopHeaderSize * i;
+    const decoded = new Map();
+    const celsOf = (loopNo) => {
+        let cels = decoded.get(loopNo);
+        if (!cels) {
+            const lh = loopHeaderAt(loopNo);
+            const celCount = data[lh + 2];
+            const first = v.getUint32(lh + 12, true);
+            cels = Array.from({ length: celCount }, (_, c) => decodeCel(data, first + celHeaderSize * c));
+            decoded.set(loopNo, cels);
+        }
+        return cels;
+    };
+    const loops = [];
+    for (let i = 0; i < loopCount; i++) {
+        const lh = loopHeaderAt(i);
+        const link = v.getInt8(lh);
+        loops.push(link === -1 ? { mirror: false, cels: celsOf(i) } : { mirror: data[lh + 1] === 1, cels: celsOf(link) });
+    }
+    return { loops, palette: paletteOffset ? parseHunkPalette(data, paletteOffset) : undefined };
+}

package/packages/sci/src/gfx/view.ts

@@ -0,0 +1,62 @@
+import { decodeCel, type Cel } from "./cel.ts";
+import { parseHunkPalette, type Palette } from "./palette.ts";
+
+export interface Loop {
+  /** Loop drawn as a horizontal mirror of another (e.g. walking left = walking right, flipped). */
+  mirror: boolean;
+  cels: Cel[];
+}
+
+/** A view: sprite animations grouped into loops (usually one per facing direction). */
+export interface View {
+  loops: Loop[];
+  palette: Palette | undefined;
+}
+
+/**
+ * SCI32 view layout:
+ *
+ *   +0  u16 header size (loop headers start at 2 + this)
+ *   +2  u8  loop count
+ *   +8  u32 embedded palette offset (0 = none)
+ *   +12 u8  loop header size
+ *   +13 u8  cel header size
+ *
+ * Loop header:
+ *   +0  i8  linked loop (-1 = own cels; otherwise reuse that loop's cels)
+ *   +1  u8  1 = mirror the linked loop
+ *   +2  u8  cel count
+ *   +12 u32 offset of the first cel header
+ */
+export function parseView(data: Uint8Array): View {
+  const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const headerSize = v.getUint16(0, true);
+  const loopCount = data[2]!;
+  const paletteOffset = v.getUint32(8, true);
+  const loopHeaderSize = data[12]!;
+  const celHeaderSize = data[13]!;
+
+  const loopHeaderAt = (i: number) => 2 + headerSize + loopHeaderSize * i;
+  const decoded = new Map<number, Cel[]>();
+
+  const celsOf = (loopNo: number): Cel[] => {
+    let cels = decoded.get(loopNo);
+    if (!cels) {
+      const lh = loopHeaderAt(loopNo);
+      const celCount = data[lh + 2]!;
+      const first = v.getUint32(lh + 12, true);
+      cels = Array.from({ length: celCount }, (_, c) => decodeCel(data, first + celHeaderSize * c));
+      decoded.set(loopNo, cels);
+    }
+    return cels;
+  };
+
+  const loops: Loop[] = [];
+  for (let i = 0; i < loopCount; i++) {
+    const lh = loopHeaderAt(i);
+    const link = v.getInt8(lh);
+    loops.push(link === -1 ? { mirror: false, cels: celsOf(i) } : { mirror: data[lh + 1] === 1, cels: celsOf(link) });
+  }
+
+  return { loops, palette: paletteOffset ? parseHunkPalette(data, paletteOffset) : undefined };
+}

package/packages/sci/src/index.d.ts

@@ -0,0 +1,38 @@
+export * from "./resource/types.ts";
+export * from "./resource/map.ts";
+export * from "./resource/lzs.ts";
+export * from "./resource/manager.ts";
+export * from "./resource/archive.ts";
+export * from "./gfx/palette.ts";
+export * from "./gfx/cel.ts";
+export * from "./gfx/view.ts";
+export * from "./gfx/pic.ts";
+export * from "./gfx/pic-file.ts";
+export * from "./gfx/quantize.ts";
+export * from "./gfx/view-file.ts";
+export * from "./text/font.ts";
+export * from "./text/message.ts";
+export * from "./script/kernel-names.ts";
+export * from "./script/vocab.ts";
+export * from "./script/script.ts";
+export * from "./script/opcodes.ts";
+export * from "./script/disasm.ts";
+export * from "./script/world.ts";
+export * from "./vm/value.ts";
+export * from "./vm/memory.ts";
+export * from "./vm/vm.ts";
+export * from "./vm/kernels/index.ts";
+export * from "./audio/sol.ts";
+export * from "./audio/index.ts";
+export * from "./audio/midi.ts";
+export * from "./audio/opl2.ts";
+export * from "./audio/adlib.ts";
+export * from "./audio/write.ts";
+export * from "./motion/pathfinding.ts";
+export * from "./vm/savegame.ts";
+export * from "./analysis/game.ts";
+export * from "./analysis/runtime.ts";
+export * from "./script/assembly.ts";
+export * from "./script/sexpr.ts";
+export * from "./script/compiler.ts";
+export * from "./vm/replace.ts";

package/packages/sci/src/index.js

@@ -0,0 +1,38 @@
+export * from "./resource/types.js";
+export * from "./resource/map.js";
+export * from "./resource/lzs.js";
+export * from "./resource/manager.js";
+export * from "./resource/archive.js";
+export * from "./gfx/palette.js";
+export * from "./gfx/cel.js";
+export * from "./gfx/view.js";
+export * from "./gfx/pic.js";
+export * from "./gfx/pic-file.js";
+export * from "./gfx/quantize.js";
+export * from "./gfx/view-file.js";
+export * from "./text/font.js";
+export * from "./text/message.js";
+export * from "./script/kernel-names.js";
+export * from "./script/vocab.js";
+export * from "./script/script.js";
+export * from "./script/opcodes.js";
+export * from "./script/disasm.js";
+export * from "./script/world.js";
+export * from "./vm/value.js";
+export * from "./vm/memory.js";
+export * from "./vm/vm.js";
+export * from "./vm/kernels/index.js";
+export * from "./audio/sol.js";
+export * from "./audio/index.js";
+export * from "./audio/midi.js";
+export * from "./audio/opl2.js";
+export * from "./audio/adlib.js";
+export * from "./audio/write.js";
+export * from "./motion/pathfinding.js";
+export * from "./vm/savegame.js";
+export * from "./analysis/game.js";
+export * from "./analysis/runtime.js";
+export * from "./script/assembly.js";
+export * from "./script/sexpr.js";
+export * from "./script/compiler.js";
+export * from "./vm/replace.js";

package/packages/sci/src/index.ts

@@ -0,0 +1,38 @@
+export * from "./resource/types.ts";
+export * from "./resource/map.ts";
+export * from "./resource/lzs.ts";
+export * from "./resource/manager.ts";
+export * from "./resource/archive.ts";
+export * from "./gfx/palette.ts";
+export * from "./gfx/cel.ts";
+export * from "./gfx/view.ts";
+export * from "./gfx/pic.ts";
+export * from "./gfx/pic-file.ts";
+export * from "./gfx/quantize.ts";
+export * from "./gfx/view-file.ts";
+export * from "./text/font.ts";
+export * from "./text/message.ts";
+export * from "./script/kernel-names.ts";
+export * from "./script/vocab.ts";
+export * from "./script/script.ts";
+export * from "./script/opcodes.ts";
+export * from "./script/disasm.ts";
+export * from "./script/world.ts";
+export * from "./vm/value.ts";
+export * from "./vm/memory.ts";
+export * from "./vm/vm.ts";
+export * from "./vm/kernels/index.ts";
+export * from "./audio/sol.ts";
+export * from "./audio/index.ts";
+export * from "./audio/midi.ts";
+export * from "./audio/opl2.ts";
+export * from "./audio/adlib.ts";
+export * from "./audio/write.ts";
+export * from "./motion/pathfinding.ts";
+export * from "./vm/savegame.ts";
+export * from "./analysis/game.ts";
+export * from "./analysis/runtime.ts";
+export * from "./script/assembly.ts";
+export * from "./script/sexpr.ts";
+export * from "./script/compiler.ts";
+export * from "./vm/replace.ts";

package/packages/sci/src/motion/pathfinding.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pathfinding over SCI polygons.
+ *
+ * Rooms describe walkable space with polygons of four access types:
+ *   Total     (0): can't enter; if you start inside you may walk out.
+ *   Nearest   (1): can't enter; clicking inside walks to its nearest edge.
+ *   Barred    (2): can't enter at all.
+ *   Contained (3): the walkable area itself: you can't leave it.
+ *
+ * `findPath` snaps unreachable start/end points to the nearest reachable point, builds a
+ * visibility graph over the polygon vertices (two points are connected if the straight
+ * segment between them stays walkable) and runs Dijkstra. Boundaries count as walkable,
+ * so paths can hug walls and corners, like the original.
+ */
+export declare const PolygonType: {
+    readonly Total: 0;
+    readonly Nearest: 1;
+    readonly Barred: 2;
+    readonly Contained: 3;
+};
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Polygon {
+    type: number;
+    points: Point[];
+}
+export type Containment = "inside" | "outside" | "edge";
+export declare function contains(poly: Polygon, p: Point): Containment;
+/** Walkable = inside (or on) every contained polygon and not strictly inside any obstacle. */
+export declare function walkable(polys: Polygon[], p: Point): boolean;
+/** Nearest walkable point to `p`, found on polygon edges (rounded to whole pixels). */
+export declare function nearestWalkable(polys: Polygon[], p: Point): Point;
+/**
+ * Shortest walkable path from `start` to `end`, including both endpoints. If the end is
+ * unreachable it's moved to the nearest reachable point; if the start is inside an
+ * obstacle (e.g. pushed into one), the path first steps out of it.
+ */
+export declare function findPath(start: Point, end: Point, polys: Polygon[]): Point[];

package/packages/sci/src/motion/pathfinding.js

@@ -0,0 +1,140 @@
+/**
+ * Pathfinding over SCI polygons.
+ *
+ * Rooms describe walkable space with polygons of four access types:
+ *   Total     (0): can't enter; if you start inside you may walk out.
+ *   Nearest   (1): can't enter; clicking inside walks to its nearest edge.
+ *   Barred    (2): can't enter at all.
+ *   Contained (3): the walkable area itself: you can't leave it.
+ *
+ * `findPath` snaps unreachable start/end points to the nearest reachable point, builds a
+ * visibility graph over the polygon vertices (two points are connected if the straight
+ * segment between them stays walkable) and runs Dijkstra. Boundaries count as walkable,
+ * so paths can hug walls and corners, like the original.
+ */
+export const PolygonType = { Total: 0, Nearest: 1, Barred: 2, Contained: 3 };
+const EPS = 1e-9;
+const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+function onSegment(p, a, b) {
+    if (Math.abs(cross(a, b, p)) > EPS)
+        return false;
+    return p.x >= Math.min(a.x, b.x) - EPS && p.x <= Math.max(a.x, b.x) + EPS && p.y >= Math.min(a.y, b.y) - EPS && p.y <= Math.max(a.y, b.y) + EPS;
+}
+function edges(poly) {
+    return poly.points.map((p, i) => [p, poly.points[(i + 1) % poly.points.length]]);
+}
+export function contains(poly, p) {
+    let inside = false;
+    for (const [a, b] of edges(poly)) {
+        if (onSegment(p, a, b))
+            return "edge";
+        if (a.y > p.y !== b.y > p.y && p.x < ((b.x - a.x) * (p.y - a.y)) / (b.y - a.y) + a.x)
+            inside = !inside;
+    }
+    return inside ? "inside" : "outside";
+}
+/** Walkable = inside (or on) every contained polygon and not strictly inside any obstacle. */
+export function walkable(polys, p) {
+    for (const poly of polys) {
+        const c = contains(poly, p);
+        if (poly.type === PolygonType.Contained ? c === "outside" : c === "inside")
+            return false;
+    }
+    return true;
+}
+/** True if segments ab and cd cross at a point interior to both. */
+function properlyIntersect(a, b, c, d) {
+    const d1 = cross(c, d, a), d2 = cross(c, d, b), d3 = cross(a, b, c), d4 = cross(a, b, d);
+    return ((d1 > EPS && d2 < -EPS) || (d1 < -EPS && d2 > EPS)) && ((d3 > EPS && d4 < -EPS) || (d3 < -EPS && d4 > EPS));
+}
+/** A segment is clear if it crosses no polygon edge and its interior stays walkable. */
+function clear(polys, a, b) {
+    for (const poly of polys)
+        for (const [c, d] of edges(poly))
+            if (properlyIntersect(a, b, c, d))
+                return false;
+    // Crossing no edges can still mean running through a polygon's interior (e.g. a diagonal
+    // between two of its vertices), so sample along the segment.
+    const steps = Math.max(2, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / 4));
+    for (let i = 1; i < steps; i++) {
+        const t = i / steps;
+        if (!walkable(polys, { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t }))
+            return false;
+    }
+    return true;
+}
+function nearestOnSegment(p, a, b) {
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const len2 = dx * dx + dy * dy;
+    const t = len2 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2)) : 0;
+    return { x: a.x + t * dx, y: a.y + t * dy };
+}
+/** Nearest walkable point to `p`, found on polygon edges (rounded to whole pixels). */
+export function nearestWalkable(polys, p) {
+    if (walkable(polys, p))
+        return p;
+    let best;
+    let bestDist = Infinity;
+    for (const poly of polys) {
+        for (const [a, b] of edges(poly)) {
+            const q = nearestOnSegment(p, a, b);
+            // Try the point and its integer neighbours; SCI coordinates are whole pixels.
+            for (const cand of [{ x: Math.round(q.x), y: Math.round(q.y) }, { x: Math.floor(q.x), y: Math.floor(q.y) }, { x: Math.ceil(q.x), y: Math.ceil(q.y) }, q]) {
+                const d = Math.hypot(cand.x - p.x, cand.y - p.y);
+                if (d < bestDist && walkable(polys, cand)) {
+                    best = cand;
+                    bestDist = d;
+                }
+            }
+        }
+    }
+    return best ?? p;
+}
+/**
+ * Shortest walkable path from `start` to `end`, including both endpoints. If the end is
+ * unreachable it's moved to the nearest reachable point; if the start is inside an
+ * obstacle (e.g. pushed into one), the path first steps out of it.
+ */
+export function findPath(start, end, polys) {
+    // Obstacles that contain the start are ignored, so an actor stuck in one can walk out.
+    const active = polys.filter((p) => p.type === PolygonType.Contained || contains(p, start) !== "inside");
+    const from = nearestWalkable(active, start);
+    const to = nearestWalkable(active, end);
+    const prefix = from.x !== start.x || from.y !== start.y ? [start] : [];
+    if (clear(active, from, to))
+        return [...prefix, from, to];
+    const nodes = [from, to];
+    for (const poly of active)
+        for (const p of poly.points)
+            if (walkable(active, p))
+                nodes.push(p);
+    // Dijkstra over the visibility graph (edges evaluated lazily; rooms have few vertices).
+    const dist = new Array(nodes.length).fill(Infinity);
+    const prev = new Array(nodes.length).fill(-1);
+    const done = new Array(nodes.length).fill(false);
+    dist[0] = 0;
+    for (;;) {
+        let u = -1;
+        for (let i = 0; i < nodes.length; i++)
+            if (!done[i] && dist[i] < Infinity && (u === -1 || dist[i] < dist[u]))
+                u = i;
+        if (u === -1 || u === 1)
+            break;
+        done[u] = true;
+        for (let v = 0; v < nodes.length; v++) {
+            if (done[v])
+                continue;
+            const w = Math.hypot(nodes[v].x - nodes[u].x, nodes[v].y - nodes[u].y);
+            if (dist[u] + w < dist[v] && clear(active, nodes[u], nodes[v])) {
+                dist[v] = dist[u] + w;
+                prev[v] = u;
+            }
+        }
+    }
+    if (prev[1] === -1)
+        return [...prefix, from]; // unreachable: stay put
+    const path = [];
+    for (let i = 1; i !== -1; i = prev[i])
+        path.unshift(nodes[i]);
+    return [...prefix, ...path];
+}