:roclet: improve algorithm, add an intermediate phase to clean up residual cell from previous layer, before grabing the free ones

packages/compute/__tests__/getPathTo.spec.ts

@@ -0,0 +1,12 @@
+import { createEmptyGrid } from "@snk/types/grid";
+import { getHeadX, getHeadY } from "@snk/types/snake";
+import { snake3 } from "@snk/types/__fixtures__/snake";
+import { getPathTo } from "../getPathTo";
+
+it("should find it's way in vaccum", () => {
+  const grid = createEmptyGrid(5, 0);
+
+  const path = getPathTo(grid, snake3, 5, -1)!;
+
+  expect([getHeadX(path[0]), getHeadY(path[0])]).toEqual([5, -1]);
+});

packages/compute/cleanIntermediateLayer.ts

@@ -0,0 +1,131 @@
+import { getColor, isEmpty, setColorEmpty } from "@snk/types/grid";
+import {
+  getHeadX,
+  getHeadY,
+  getSnakeLength,
+  nextSnake,
+} from "@snk/types/snake";
+import { getPathTo } from "./getPathTo";
+import { getBestTunnel, trimTunnelEnd, trimTunnelStart } from "./getBestTunnel";
+import type { Snake } from "@snk/types/snake";
+import type { Color, Grid } from "@snk/types/grid";
+import type { Point } from "@snk/types/point";
+
+/**
+ * - list the cells lesser than <color> that are reachable going through <color>
+ * - for each cell of the list
+ *      compute the best tunnel to get to the cell and back to the outside ( best = less usage of <color> )
+ * - for each tunnel*
+ *      make the snake go to the start of the tunnel from where it was, traverse the tunnel
+ *      repeat
+ *
+ *  *sort the tunnel:
+ *    - first one to go is the tunnel with the longest line on less than <color>
+ *    - then the ones with the best ratio ( N of less than <color> ) / ( N of <color> )
+ */
+export const cleanIntermediateLayer = (
+  grid: Grid,
+  color: Color,
+  snake0: Snake
+) => {
+  const tunnels: Point[][] = [];
+  const chain: Snake[] = [snake0];
+
+  for (let x = grid.width; x--; )
+    for (let y = grid.height; y--; ) {
+      const c = getColor(grid, x, y);
+
+      if (!isEmpty(c) && c < color) {
+        const tunnel = getBestTunnel(grid, x, y, color, getSnakeLength(snake0));
+        if (tunnel) tunnels.push(tunnel);
+      }
+    }
+
+  // find the best first tunnel
+  let i = -1;
+  for (let j = tunnels.length; j--; )
+    if (
+      i === -1 ||
+      scoreFirst(grid, color, tunnels[i]) < scoreFirst(grid, color, tunnels[j])
+    )
+      i = j;
+
+  while (i >= 0) {
+    const [tunnel] = tunnels.splice(i, 1);
+
+    // push to chain
+    // 1\ the path to the start on the tunnel
+    const path = getPathTo(grid, chain[0], tunnel[0].x, tunnel[0].y)!;
+    chain.unshift(...path);
+    // 2\ the path into the tunnel
+    for (let i = 1; i < tunnel.length; i++) {
+      const dx = tunnel[i].x - getHeadX(chain[0]);
+      const dy = tunnel[i].y - getHeadY(chain[0]);
+      const snake = nextSnake(chain[0], dx, dy);
+      chain.unshift(snake);
+    }
+
+    // mutate grid
+    for (const { x, y } of tunnel) setColorEmpty(grid, x, y);
+
+    // remove the cell that we eat
+    for (let j = tunnels.length; j--; ) {
+      updateTunnel(grid, tunnels[j], tunnel);
+      if (!tunnels[j].length) tunnels.splice(j, 1);
+    }
+
+    // select the next one
+    i = -1;
+    for (let j = tunnels.length; j--; )
+      if (
+        i === -1 ||
+        score(grid, color, tunnels[i]) < score(grid, color, tunnels[j])
+      )
+        i = j;
+  }
+
+  return chain;
+};
+
+const scoreFirst = (grid: Grid, color: Color, tunnel: Point[]) =>
+  tunnel.findIndex(({ x, y }) => getColor(grid, x, y) === color);
+
+const score = (grid: Grid, color: Color, tunnel: Point[]) => {
+  let nColor = 0;
+  let nLessColor = 0;
+
+  for (let i = 0; i < tunnel.length; i++) {
+    const { x, y } = tunnel[i];
+
+    const j = tunnel.findIndex((u) => x === u.x && y === u.y);
+
+    if (i !== j) {
+      const c = getColor(grid, x, y);
+      if (c === color) nColor++;
+      else if (!isEmpty(c)) nLessColor++;
+    }
+  }
+
+  return nLessColor / nColor;
+};
+
+/**
+ * assuming the grid change and the colors got deleted, update the tunnel
+ */
+const updateTunnel = (grid: Grid, tunnel: Point[], toDelete: Point[]) => {
+  while (tunnel.length) {
+    const { x, y } = tunnel[0];
+    if (toDelete.some((p) => p.x === x && p.y === y)) {
+      tunnel.shift();
+      trimTunnelStart(grid, tunnel);
+    } else break;
+  }
+
+  while (tunnel.length) {
+    const { x, y } = tunnel[tunnel.length - 1];
+    if (toDelete.some((p) => p.x === x && p.y === y)) {
+      tunnel.pop();
+      trimTunnelEnd(grid, tunnel);
+    } else break;
+  }
+};

packages/compute/getBestRoute.ts

@@ -1,30 +1,34 @@
-import { copyGrid, isEmpty } from "@snk/types/grid";
+import { copyGrid } from "@snk/types/grid";
 import { pruneLayer } from "./pruneLayer";
 import { cleanLayer } from "./cleanLayer-monobranch";
-import type { Snake } from "@snk/types/snake";
+import { getSnakeLength, Snake } from "@snk/types/snake";
+import { cleanIntermediateLayer } from "./cleanIntermediateLayer";
 import type { Color, Grid } from "@snk/types/grid";
 
 export const getBestRoute = (grid0: Grid, snake0: Snake) => {
   const grid = copyGrid(grid0);
   const colors = extractColors(grid0);
-  const snakeN = snake0.length / 2;
+  const snakeN = getSnakeLength(snake0);
 
   const chain: Snake[] = [snake0];
 
   for (const color of colors) {
     const gridN = copyGrid(grid);
+
+    // clear the free colors
     const chunk = pruneLayer(grid, color, snakeN);
-    const c = cleanLayer(gridN, chain[0], chunk);
+    chain.unshift(...cleanLayer(gridN, chain[0], chunk));
-    chain.unshift(...c);
+
+    // clear the remaining colors, allowing to eat color+1
+    const nextColor = (color + 1) as Color;
+    chain.unshift(...cleanIntermediateLayer(grid, nextColor, chain[0]));
   }
 
   return chain.reverse().slice(1);
 };
 
 const extractColors = (grid: Grid): Color[] => {
-  const colors = new Set<Color>();
+  // @ts-ignore
-  grid.data.forEach((c: any) => {
+  let maxColor = Math.max(...grid.data);
-    if (!isEmpty(c)) colors.add(c);
+  return Array.from({ length: maxColor }, (_, i) => (i + 1) as Color);
-  });
-  return Array.from(colors.keys()).sort();
 };

packages/compute/getBestTunnel.ts

@@ -0,0 +1,159 @@
+import {
+  copyGrid,
+  getColor,
+  isEmpty,
+  isInside,
+  setColorEmpty,
+} from "@snk/types/grid";
+import { around4 } from "@snk/types/point";
+import { sortPush } from "./utils/sortPush";
+import {
+  createSnakeFromCells,
+  getHeadX,
+  getHeadY,
+  nextSnake,
+  snakeEquals,
+  snakeWillSelfCollide,
+} from "@snk/types/snake";
+import type { Snake } from "@snk/types/snake";
+import type { Color, Grid } from "@snk/types/grid";
+import type { Point } from "@snk/types/point";
+
+type M = {
+  snake: Snake;
+  grid: Grid;
+  parent: M | null;
+  w: number;
+  h: number;
+  f: number;
+};
+
+const unwrap = (m: M | null): Snake[] =>
+  m ? [m.snake, ...unwrap(m.parent)] : [];
+
+/**
+ * returns the path to reach the outside which contains the least color cell
+ */
+const getSnakeEscapePath = (grid0: Grid, snake0: Snake, color: Color) => {
+  const openList: M[] = [
+    { snake: snake0, grid: grid0, w: 0, h: 0, f: 0, parent: null },
+  ];
+  const closeList: Snake[] = [];
+
+  while (openList.length) {
+    const o = openList.shift()!;
+
+    for (const a of around4) {
+      if (!snakeWillSelfCollide(o.snake, a.x, a.y)) {
+        const y = getHeadY(o.snake) + a.y;
+        const x = getHeadX(o.snake) + a.x;
+
+        if (!isInside(grid0, x, y)) {
+          // unwrap and return
+          const points: Point[] = [];
+
+          points.push({ x, y });
+          let e: M["parent"] = o;
+          while (e) {
+            points.unshift({
+              y: getHeadY(e.snake),
+              x: getHeadX(e.snake),
+            });
+            e = e.parent;
+          }
+
+          return points;
+        }
+
+        const u = getColor(grid0, x, y);
+
+        if (isEmpty(u) || u <= color) {
+          const snake = nextSnake(o.snake, a.x, a.y);
+
+          if (!closeList.some((s0) => snakeEquals(s0, snake))) {
+            let grid = o.grid;
+            if (!isEmpty(u)) {
+              grid = copyGrid(grid);
+              setColorEmpty(grid, x, y);
+            }
+
+            const h = Math.abs(grid.height / 2 - y);
+            const w = o.w + (u === color ? 1 : 0);
+            const f = w * 1000 - h;
+            sortPush(
+              openList,
+              { snake, grid, parent: o, h, w, f },
+              (a, b) => a.f - b.f
+            );
+            closeList.push(snake);
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+};
+
+/**
+ * compute the best tunnel to get to the cell and back to the outside ( best = less usage of <color> )
+ */
+export const getBestTunnel = (
+  grid: Grid,
+  x: number,
+  y: number,
+  color: Color,
+  snakeN: number
+) => {
+  const c = { x, y };
+  const snake = createSnakeFromCells(Array.from({ length: snakeN }, () => c));
+
+  const one = getSnakeEscapePath(grid, snake, color);
+
+  if (!one) return null;
+
+  // get the position of the snake if it was going to leave the x,y cell
+  const snakeICells = one.slice(0, snakeN);
+  while (snakeICells.length < snakeN)
+    snakeICells.push(snakeICells[snakeICells.length - 1]);
+  const snakeI = createSnakeFromCells(snakeICells);
+
+  // remove from the grid the colors that one eat
+  const gridI = copyGrid(grid);
+  for (const { x, y } of one) setColorEmpty(gridI, x, y);
+
+  const two = getSnakeEscapePath(gridI, snakeI, color);
+
+  if (!two) return null;
+
+  one.reverse();
+  one.pop();
+
+  trimTunnelStart(grid, one);
+  trimTunnelEnd(grid, two);
+  one.push(...two);
+
+  return one;
+};
+
+/**
+ * remove empty cell from start
+ */
+export const trimTunnelStart = (grid: Grid, tunnel: Point[]) => {
+  while (tunnel.length) {
+    const { x, y } = tunnel[0];
+    if (!isInside(grid, x, y) || isEmpty(getColor(grid, x, y))) tunnel.shift();
+    else break;
+  }
+};
+
+/**
+ * remove empty cell from end
+ */
+export const trimTunnelEnd = (grid: Grid, tunnel: Point[]) => {
+  while (tunnel.length) {
+    const { x, y } = tunnel[tunnel.length - 1];
+    if (!isInside(grid, x, y) || isEmpty(getColor(grid, x, y))) tunnel.pop();
+    else break;
+  }
+};

packages/compute/getPathTo.ts

@@ -0,0 +1,66 @@
+import { isInsideLarge, getColor, isInside, isEmpty } from "@snk/types/grid";
+import { around4 } from "@snk/types/point";
+import {
+  getHeadX,
+  getHeadY,
+  nextSnake,
+  snakeEquals,
+  snakeWillSelfCollide,
+} from "@snk/types/snake";
+import { sortPush } from "./utils/sortPush";
+import type { Snake } from "@snk/types/snake";
+import type { Grid } from "@snk/types/grid";
+
+type M = { parent: M | null; snake: Snake; w: number; h: number; f: number };
+
+/**
+ * starting from snake0, get to the cell x,y
+ * return the snake chain (reversed)
+ */
+export const getPathTo = (grid: Grid, snake0: Snake, x: number, y: number) => {
+  const openList: M[] = [{ snake: snake0, w: 0 } as any];
+  const closeList: Snake[] = [];
+
+  while (openList.length) {
+    const c = openList.shift()!;
+
+    const cx = getHeadX(c.snake);
+    const cy = getHeadY(c.snake);
+
+    for (let i = 0; i < around4.length; i++) {
+      const { x: dx, y: dy } = around4[i];
+
+      const nx = cx + dx;
+      const ny = cy + dy;
+
+      if (nx === x && ny === y) {
+        // unwrap
+        const path = [nextSnake(c.snake, dx, dy)];
+        let e: M["parent"] = c;
+        while (e.parent) {
+          path.push(e.snake);
+          e = e.parent;
+        }
+        return path;
+      }
+
+      if (
+        isInsideLarge(grid, 2, nx, ny) &&
+        !snakeWillSelfCollide(c.snake, dx, dy) &&
+        (!isInside(grid, nx, ny) || isEmpty(getColor(grid, nx, ny)))
+      ) {
+        const nsnake = nextSnake(c.snake, dx, dy);
+
+        if (!closeList.some((s) => snakeEquals(nsnake, s))) {
+          const w = c.w + 1;
+          const h = Math.abs(nx - x) + Math.abs(ny - y);
+          const f = w + h;
+          const o = { snake: nsnake, parent: c, w, h, f };
+
+          sortPush(openList, o, (a, b) => a.f - b.f);
+          closeList.push(nsnake);
+        }
+      }
+    }
+  }
+};

packages/compute/pruneLayer.ts

@@ -15,8 +15,7 @@ import {
 
 type M = Point & { parent: M | null; h: number };
 
-const unwrap = (grid: Grid, m: M | null): Point[] =>
+const unwrap = (m: M | null): Point[] => (m ? [...unwrap(m.parent), m] : []);
-  m ? [...unwrap(grid, m.parent), m] : [];
 
 const getEscapePath = (grid: Grid, x: number, y: number, color: Color) => {
   const openList: M[] = [{ x, y, h: 0, parent: null }];
@@ -25,14 +24,13 @@ const getEscapePath = (grid: Grid, x: number, y: number, color: Color) => {
   while (openList.length) {
     const c = openList.shift()!;
 
-    if (c.y === -1 || c.y === grid.height) return unwrap(grid, c);
+    if (c.y === -1 || c.y === grid.height) return unwrap(c);
 
     for (const a of around4) {
       const x = c.x + a.x;
       const y = c.y + a.y;
 
-      if (!isInside(grid, x, y))
+      if (!isInside(grid, x, y)) return unwrap({ x, y, parent: c } as any);
-        return unwrap(grid, { x, y, parent: c } as any);
 
       const u = getColor(grid, x, y);
 
@@ -63,10 +61,10 @@ const snakeCanEscape = (grid: Grid, snake: Snake, color: Color) => {
     const s = openList.shift()!;
 
     for (const a of around4) {
-      const x = getHeadX(s) + a.x;
-      const y = getHeadY(s) + a.y;
-
       if (!snakeWillSelfCollide(s, a.x, a.y)) {
+        const x = getHeadX(s) + a.x;
+        const y = getHeadY(s) + a.y;
+
         if (!isInside(grid, x, y)) return true;
 
         const u = getColor(grid, x, y);

packages/demo/demo.getBestRoundTrip.ts

@@ -0,0 +1,54 @@
+import "./menu";
+import { createCanvas } from "./canvas";
+import { getSnakeLength } from "@snk/types/snake";
+import { grid, snake } from "./sample";
+import { getColor } from "@snk/types/grid";
+import { getBestTunnel } from "@snk/compute/getBestTunnel";
+import type { Color } from "@snk/types/grid";
+import type { Point } from "@snk/types/point";
+
+const { canvas, ctx, draw, highlightCell } = createCanvas(grid);
+document.body.appendChild(canvas);
+
+const ones: Point[] = [];
+
+for (let x = 0; x < grid.width; x++)
+  for (let y = 0; y < grid.height; y++)
+    if (getColor(grid, x, y) === 1) ones.push({ x, y });
+
+const points = getBestTunnel(
+  grid,
+  ones[0].x,
+  ones[0].y,
+  3 as Color,
+  getSnakeLength(snake)
+);
+
+let k = 0;
+
+const onChange = () => {
+  ctx.clearRect(0, 0, 9999, 9999);
+
+  draw(grid, [] as any, []);
+
+  if (points) {
+    points.forEach(({ x, y }) => highlightCell(x, y));
+    highlightCell(points[k].x, points[k].y, "blue");
+  }
+};
+
+onChange();
+
+const inputK = document.createElement("input") as any;
+inputK.type = "range";
+inputK.value = 0;
+inputK.step = 1;
+inputK.min = 0;
+inputK.max = points ? points.length - 1 : 0;
+inputK.style.width = "90%";
+inputK.style.padding = "20px 0";
+inputK.addEventListener("input", () => {
+  k = +inputK.value;
+  onChange();
+});
+document.body.append(inputK);

packages/demo/demo.getPathTo.ts

@@ -0,0 +1,75 @@
+import "./menu";
+import { createCanvas } from "./canvas";
+import { snakeToCells } from "@snk/types/snake";
+import { grid, snake } from "./sample";
+import { getColor } from "@snk/types/grid";
+import { getPathTo } from "@snk/compute/getPathTo";
+import type { Point } from "@snk/types/point";
+
+const { canvas, ctx, draw, highlightCell } = createCanvas(grid);
+document.body.appendChild(canvas);
+
+const ones: Point[] = [];
+
+for (let x = 0; x < grid.width; x++)
+  for (let y = 0; y < grid.height; y++)
+    if (getColor(grid, x, y) === 1) ones.push({ x, y });
+
+const chains = ones.map((p) => {
+  const chain = getPathTo(grid, snake, p.x, p.y);
+  return chain && [...chain, snake];
+});
+
+let k = 0;
+let i = 0;
+
+const onChange = () => {
+  ctx.clearRect(0, 0, 9999, 9999);
+
+  const chain = chains[k];
+
+  if (chain) {
+    draw(grid, chain[i], []);
+    chain
+      .map(snakeToCells)
+      .flat()
+      .forEach(({ x, y }) => highlightCell(x, y));
+  } else draw(grid, snake, []);
+};
+
+onChange();
+
+const inputK = document.createElement("input") as any;
+inputK.type = "range";
+inputK.value = k;
+inputK.step = 1;
+inputK.min = 0;
+inputK.max = chains.length - 1;
+inputK.style.width = "90%";
+inputK.style.padding = "20px 0";
+inputK.addEventListener("input", () => {
+  k = +inputK.value;
+  i = inputI.value = 0;
+  inputI.max = chains[k] ? chains[k]!.length - 1 : 0;
+  onChange();
+});
+document.body.append(inputK);
+
+const inputI = document.createElement("input") as any;
+inputI.type = "range";
+inputI.value = 0;
+inputI.max = chains[k] ? chains[k]!.length - 1 : 0;
+inputI.step = 1;
+inputI.min = 0;
+inputI.style.width = "90%";
+inputI.style.padding = "20px 0";
+inputI.addEventListener("input", () => {
+  i = +inputI.value;
+  onChange();
+});
+document.body.append(inputI);
+
+window.addEventListener("click", (e) => {
+  if (e.target === document.body || e.target === document.body.parentElement)
+    inputK.focus();
+});

packages/demo/demo.json

@@ -1 +1,8 @@
-["getAvailableRoutes", "pruneLayer", "getBestRoute", "interactive"]
+[
+  "getAvailableRoutes",
+  "pruneLayer",
+  "getBestRoute",
+  "getBestRoundTrip",
+  "getPathTo",
+  "interactive"
+]

packages/demo/demo.pruneLayer.ts

@@ -3,10 +3,11 @@ import { createCanvas } from "./canvas";
 import { Color, copyGrid } from "@snk/types/grid";
 import { grid, snake } from "./sample";
 import { pruneLayer } from "@snk/compute/pruneLayer";
+import { getSnakeLength } from "@snk/types/snake";
 
 const colors = [1, 2, 3] as Color[];
 
-const snakeN = snake.length / 2;
+const snakeN = getSnakeLength(snake);
 
 const layers = [{ grid, chunk: [] as { x: number; y: number }[] }];
 let grid0 = copyGrid(grid);

packages/types/__fixtures__/grid.ts

@@ -84,6 +84,41 @@ setColor(enclaveU, 1, 3, 1 as Color);
 setColor(enclaveU, 2, 4, 1 as Color);
 setColor(enclaveU, 16, 8, 1 as Color);
 
+export const closed = createEmptyGrid(16, 16);
+setColor(closed, 1 + 5, 1 + 5, 3 as Color);
+setColor(closed, 2 + 5, 4 + 5, 3 as Color);
+setColor(closed, 2 + 5, 1 + 5, 3 as Color);
+setColor(closed, 0 + 5, 2 + 5, 3 as Color);
+setColor(closed, 0 + 5, 3 + 5, 3 as Color);
+setColor(closed, 1 + 5, 4 + 5, 3 as Color);
+setColor(closed, 3 + 5, 1 + 5, 3 as Color);
+setColor(closed, 3 + 5, 2 + 5, 3 as Color);
+setColor(closed, 3 + 5, 3 + 5, 3 as Color);
+setColor(closed, 1 + 5, 2 + 5, 3 as Color);
+setColor(closed, 1 + 5, 3 + 5, 3 as Color);
+setColor(closed, 2 + 5, 2 + 5, 1 as Color);
+
+export const closedU = createEmptyGrid(20, 20);
+setColor(closedU, 1 + 10, 1 + 10, 3 as Color);
+setColor(closedU, 2 + 10, 1 + 10, 3 as Color);
+setColor(closedU, 3 + 10, 1 + 10, 3 as Color);
+setColor(closedU, 0 + 10, 1 + 10, 3 as Color);
+setColor(closedU, 0 + 10, 2 + 10, 3 as Color);
+setColor(closedU, 0 + 10, 3 + 10, 3 as Color);
+setColor(closedU, 3 + 10, 1 + 10, 3 as Color);
+setColor(closedU, 3 + 10, 2 + 10, 3 as Color);
+setColor(closedU, 3 + 10, 3 + 10, 3 as Color);
+setColor(closedU, 1 + 10, 4 + 10, 3 as Color);
+setColor(closedU, 3 + 10, 4 + 10, 3 as Color);
+setColor(closedU, 3 + 10, 5 + 10, 3 as Color);
+setColor(closedU, 1 + 10, 5 + 10, 3 as Color);
+setColor(closedU, 2 + 10, 5 + 10, 3 as Color);
+setColor(closedU, 2 + 10, 2 + 10, 1 as Color);
+setColor(closedU, 1 + 10, 2 + 10, 1 as Color);
+setColor(closedU, 2 + 10, 3 + 10, 1 as Color);
+setColor(closedU, 1 + 10, 3 + 10, 1 as Color);
+setColor(closedU, 2 + 10, 4 + 10, 1 as Color);
+
 const create = (width: number, height: number, emptyP: number) => {
   const grid = createEmptyGrid(width, height);
   const pm = new ParkMiller(10);

packages/types/grid.ts

@@ -1,4 +1,4 @@
-export type Color = (1 | 2 | 3 | 4 | 5 | 6) & { _tag: "__Color__" };
+export type Color = (1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9) & { _tag: "__Color__" };
 export type Empty = 0 & { _tag: "__Empty__" };
 
 export type Grid = {

packages/types/snake.ts

@@ -5,6 +5,8 @@ export type Snake = Uint8Array & { _tag: "__Snake__" };
 export const getHeadX = (snake: Snake) => snake[0] - 2;
 export const getHeadY = (snake: Snake) => snake[1] - 2;
 
+export const getSnakeLength = (snake: Snake) => snake.length / 2;
+
 export const copySnake = (snake: Snake) => snake.slice() as Snake;
 
 export const snakeEquals = (a: Snake, b: Snake) => {