114 lines
3.0 KiB
TypeScript
114 lines
3.0 KiB
TypeScript
import { copyGrid, getColor, 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 { isOutside } from "./outside";
|
|
import { trimTunnelEnd, trimTunnelStart } from "./tunnel";
|
|
import type { Outside } from "./outside";
|
|
import type { Snake } from "@snk/types/snake";
|
|
import type { Empty, Color, Grid } from "@snk/types/grid";
|
|
import type { Point } from "@snk/types/point";
|
|
|
|
const getColorSafe = (grid: Grid, x: number, y: number) =>
|
|
isInside(grid, x, y) ? getColor(grid, x, y) : (0 as Empty);
|
|
|
|
const setEmptySafe = (grid: Grid, x: number, y: number) => {
|
|
if (isInside(grid, x, y)) setColorEmpty(grid, x, y);
|
|
};
|
|
|
|
type M = { snake: Snake; parent: M | null; w: number };
|
|
|
|
const unwrap = (m: M | null): Point[] =>
|
|
!m
|
|
? []
|
|
: [...unwrap(m.parent), { x: getHeadX(m.snake), y: getHeadY(m.snake) }];
|
|
|
|
/**
|
|
* returns the path to reach the outside which contains the least color cell
|
|
*/
|
|
const getSnakeEscapePath = (
|
|
grid: Grid,
|
|
outside: Outside,
|
|
snake0: Snake,
|
|
color: Color,
|
|
) => {
|
|
const openList: M[] = [{ snake: snake0, w: 0 } as any];
|
|
const closeList: Snake[] = [];
|
|
|
|
while (openList[0]) {
|
|
const o = openList.shift()!;
|
|
|
|
const x = getHeadX(o.snake);
|
|
const y = getHeadY(o.snake);
|
|
|
|
if (isOutside(outside, x, y)) return unwrap(o);
|
|
|
|
for (const a of around4) {
|
|
const c = getColorSafe(grid, x + a.x, y + a.y);
|
|
|
|
if (c <= color && !snakeWillSelfCollide(o.snake, a.x, a.y)) {
|
|
const snake = nextSnake(o.snake, a.x, a.y);
|
|
|
|
if (!closeList.some((s0) => snakeEquals(s0, snake))) {
|
|
const w = o.w + 1 + +(c === color) * 1000;
|
|
sortPush(openList, { snake, w, parent: o }, (a, b) => a.w - b.w);
|
|
closeList.push(snake);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* compute the best tunnel to get to the cell and back to the outside ( best = less usage of <color> )
|
|
*
|
|
* notice that it's one of the best tunnels, more with the same score could exist
|
|
*/
|
|
export const getBestTunnel = (
|
|
grid: Grid,
|
|
outside: Outside,
|
|
x: number,
|
|
y: number,
|
|
color: Color,
|
|
snakeN: number,
|
|
) => {
|
|
const c = { x, y };
|
|
const snake0 = createSnakeFromCells(Array.from({ length: snakeN }, () => c));
|
|
|
|
const one = getSnakeEscapePath(grid, outside, snake0, 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) setEmptySafe(gridI, x, y);
|
|
|
|
const two = getSnakeEscapePath(gridI, outside, snakeI, color);
|
|
|
|
if (!two) return null;
|
|
|
|
one.shift();
|
|
one.reverse();
|
|
one.push(...two);
|
|
|
|
trimTunnelStart(grid, one);
|
|
trimTunnelEnd(grid, one);
|
|
|
|
return one;
|
|
};
|