wip

Author: Platane

packages/demo/demo.json

@@ -1,12 +1,12 @@
 [
-	"interactive",
-	"getBestRoute",
-	"getBestTunnel",
-	"outside",
-	"getPathToPose",
-	"getPathTo",
-	"svg",
-	"rust",
-	"rust_astar",
-	"rust_astar_snake"
+  "interactive",
+  "getBestRoute",
+  "getBestTunnel",
+  "outside",
+  "getPathToPose",
+  "getPathTo",
+  "svg",
+  "rust",
+  "rust_astar",
+  "rust_astar_snake"
 ]

packages/demo/demo.rust.ts

@@ -4,48 +4,60 @@ import "./menu";
 import { grid, snake } from "./sample";
 
 (async () => {
-	const api = await import("@snk/solver-r");
-
-	const iColorGrid = api.IColorGrid.create(grid.width, grid.height, grid.data);
-	const iSnake = snakeToCells(snake).map((p) => api.IPoint.create(p.x, p.y));
-
-	// const colorGrid = api.get_color_grid_sample(api.SampleGrid.Labyrinthe);
-
-	const { canvas, draw, highlightCell } = createCanvas(iColorGrid);
-	document.body.appendChild(canvas);
-	draw(iColorGrid, snake, []);
-
-	api.greet();
-
-	const a = performance.now();
-	const path = api.solve(iColorGrid, iSnake).reverse();
-	console.log(performance.now() - a);
-
-	{
-		const snakeLength = snake.length / 2;
-
-		const onChange = () => {
-			const i = +input.value;
-			const s = createSnakeFromCells(path.slice(i, i + snakeLength).reverse());
-
-			draw(iColorGrid, s, []);
-
-			for (let j = i + snakeLength; j--; ) {
-				highlightCell(path[j].x, path[j].y, "#123bde");
-			}
-		};
-
-		const input = document.createElement("input") as any;
-		input.type = "range";
-		input.value = 0;
-		input.step = 1;
-		input.min = 0;
-		input.max = path.length - snakeLength;
-		input.style.width = "90%";
-		input.style.padding = "20px 0";
-		input.addEventListener("input", onChange);
-		document.body.append(input);
-
-		onChange();
-	}
+  const {IColorGrid,IPoint,greet,solve} = await import("@snk/solver-r");
+  greet();
+
+  const iColorGrid = IColorGrid.create(grid.width, grid.height, grid.data);
+  const iSnake = snakeToCells(snake).map((p) => IPoint.create(p.x, p.y));
+
+
+  const { canvas, draw, highlightCell } = createCanvas(iColorGrid);
+  document.body.appendChild(canvas);
+  draw(iColorGrid, snake, []);
+
+
+  const a = performance.now();
+  const path = solve(iColorGrid, iSnake).reverse();
+  console.log(performance.now() - a);
+
+  {
+    const snakeLength = snake.length / 2;
+
+    const onChange = () => {
+      const i = +input.value;
+      const s = createSnakeFromCells(path.slice(i, i + snakeLength).reverse());
+
+      const g = {
+        width: iColorGrid.width,
+        height: iColorGrid.height,
+        data: new Uint8Array([...iColorGrid.data as any]),
+      };
+      for (let j = i; j--; ) {
+        const { x, y } = path[j];
+        if (x >= 0 && y >= 0 && x < iColorGrid.width && y < iColorGrid.height) {
+          const index = x * g.height + y;
+          g.data[index] = 0;
+        }
+      }
+
+      draw(g, s, []);
+
+      for (let j = i + snakeLength; j--; ) {
+        highlightCell(path[j].x, path[j].y, "#123bde");
+      }
+    };
+
+    const input = document.createElement("input") as any;
+    input.type = "range";
+    input.value = 0;
+    input.step = 1;
+    input.min = 0;
+    input.max = path.length - snakeLength;
+    input.style.width = "90%";
+    input.style.padding = "20px 0";
+    input.addEventListener("input", onChange);
+    document.body.append(input);
+
+    onChange();
+  }
 })();

packages/demo/demo.rust_astar.ts

@@ -3,24 +3,24 @@ import "./menu";
 import { grid } from "./sample";
 
 (async () => {
-	const api = await import("@snk/solver-r");
+  const api = await import("@snk/solver-r");
 
-	const g = api.IGrid.create(grid.width, grid.height, grid.data);
-	const path = api.iastar(
-		g,
-		api.IPoint.create(-1, 0),
-		api.IPoint.create(47, 4),
-	);
+  const g = api.IGrid.create(grid.width, grid.height, grid.data);
+  const path = api.iastar(
+    g,
+    api.IPoint.create(-1, 0),
+    api.IPoint.create(47, 4),
+  );
 
-	{
-		const { canvas, draw, highlightCell } = createCanvas(g);
-		document.body.appendChild(canvas);
+  {
+    const { canvas, draw, highlightCell } = createCanvas(g);
+    document.body.appendChild(canvas);
 
-		draw({ width: g.width, height: g.height, data: g.data }, [] as any, []);
+    draw({ width: g.width, height: g.height, data: g.data }, [] as any, []);
 
-		if (path)
-			for (const p of path) {
-				highlightCell(p.x, p.y);
-			}
-	}
+    if (path)
+      for (const p of path) {
+        highlightCell(p.x, p.y);
+      }
+  }
 })();

packages/demo/demo.rust_astar_snake.ts

@@ -4,26 +4,44 @@ import "./menu";
 import { grid, snake } from "./sample";
 
 (async () => {
-	const api = await import("@snk/solver-r");
+  const { IColorGrid, IPoint, get_snake_path,greet } = await import("@snk/solver-r");
 
-	const g = api.IGrid.create(grid.width, grid.height, grid.data);
-	const path = api.iastar_snake(
-		g,
-		snakeToCells(snake).map((p) => api.IPoint.create(p.x, p.y)),
-		api.IPoint.create(7, 0),
-	);
+  greet();
 
-	{
-		const { canvas, draw, highlightCell } = createCanvas(g);
-		document.body.appendChild(canvas);
+  const colorGrid = IColorGrid.create(grid.width, grid.height, grid.data);
 
-		draw({ width: g.width, height: g.height, data: g.data }, [] as any, []);
+  const { canvas, draw, getPointedCell, highlightCell } =
+    createCanvas(colorGrid);
+  document.body.appendChild(canvas);
 
-		console.log(path);
+  let end = { x: 5, y: -1 };
+  const onChange = () => {
+    const isnake = snakeToCells(snake).map((p) => IPoint.create(p.x, p.y));
 
-		if (path)
-			for (const p of path) {
-				highlightCell(p.x, p.y);
-			}
-	}
+    const path = get_snake_path(colorGrid, isnake, IPoint.create(end.x, end.y));
+
+
+    draw(
+      {
+        width: colorGrid.width,
+        height: colorGrid.height,
+        data: colorGrid.data,
+      },
+      snake,
+      [],
+    );
+
+    if (path)
+      for (const p of path) {
+        highlightCell(p.x, p.y);
+      }
+  };
+  canvas.addEventListener("mousemove", (e) => {
+    const p = getPointedCell(e);
+    if( p.x === end.x && p.y === end.y) return
+
+    end = p;
+    onChange();
+  });
+  onChange();
 })();

packages/draw/drawSnake.ts

@@ -16,7 +16,7 @@ export const drawSnake = (
 
   for (let i = 0; i < cells.length; i++) {
     const u = Math.min((i + 1) * 0.6, o.sizeCell * 0.3);
-    
+
     ctx.save();
     ctx.fillStyle = o.colorSnake;
     ctx.translate(cells[i].x * o.sizeCell + u, cells[i].y * o.sizeCell + u);

packages/solver-r/package.json

@@ -1,12 +1,12 @@
 {
-	"name": "@snk/solver-r",
-	"version": "1.0.0",
-	"devDependencies": {
-		"wasm-pack": "0.13.1"
-	},
-	"main": "./pkg/snk_solver_rust.js",
-	"scripts": {
-		"build": "wasm-pack build",
-		"dev": "bunx nodemon --watch src -e rs --exec wasm-pack build"
-	}
+  "name": "@snk/solver-r",
+  "version": "1.0.0",
+  "devDependencies": {
+    "wasm-pack": "0.13.1"
+  },
+  "main": "./pkg/snk_solver_rust.js",
+  "scripts": {
+    "build": "wasm-pack build",
+    "dev": "bunx nodemon --watch src -e rs --exec wasm-pack build"
+  }
 }

packages/solver-r/src/_snake_self_locked.rs

@@ -0,0 +1,96 @@
+use std::collections::{BinaryHeap, HashSet};
+
+use crate::grid::{add, get_distance, Point, DIRECTIONS};
+
+struct Node {
+    w: usize,
+    h: usize,
+    f: usize,
+    snake: Vec<Point>,
+}
+
+impl Eq for Node {}
+impl PartialEq for Node {
+    fn eq(&self, other: &Self) -> bool {
+        self.snake == other.snake
+    }
+}
+impl Ord for Node {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.f.cmp(&other.f)
+    }
+}
+impl PartialOrd for Node {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// the snake is not self locked if it can find a way for this head to reach the current tail position
+pub fn is_snake_self_locked<F>(walkable: F, snake: &[Point]) -> bool
+where
+    F: Fn(&Point) -> bool,
+{
+    let end = &snake[snake.len() - 1];
+    let snake_len = snake.len();
+
+    let mut open_list = BinaryHeap::new();
+    let mut close_list: HashSet<Vec<Point>> = HashSet::new();
+
+    open_list.push({
+        let h = get_distance(&snake[0], &end) as usize;
+        Node {
+            snake: snake.to_vec(),
+            h,
+            f: h,
+            w: 0,
+        }
+    });
+
+    while let Some(node) = open_list.pop() {
+        for dir in DIRECTIONS {
+            let next_head = add(&node.snake[0], &dir);
+
+            if !walkable(&next_head) {
+                continue;
+            }
+
+            let head_collide_with_body = (0..snake_len).any(|i| node.snake[i] == next_head);
+
+            if head_collide_with_body {
+                continue;
+            }
+
+            if &next_head == end {
+                return true;
+            }
+
+            let next_snake = {
+                let mut snake = node.snake.clone();
+                snake.insert(0, next_head);
+                snake.truncate(snake_len);
+                snake
+            };
+
+            if close_list.contains(&next_snake) {
+                continue;
+            }
+
+            open_list.push({
+                let h = get_distance(&next_head, &end) as usize;
+                let w = node.w + 1;
+                let f = h + w;
+                Node {
+                    snake: next_snake,
+                    h,
+                    f,
+                    w,
+                }
+            });
+        }
+
+        close_list.insert(node.snake);
+    }
+
+    false
+}

packages/solver-r/src/_test_grid_samples.rs

@@ -33,6 +33,7 @@ pub enum SampleGrid {
     Realistic,
     Labyrinthe,
     RandomPack,
+    SolidBlock,
 }
 pub fn get_grid_sample(g: SampleGrid) -> Grid<Color> {
     match g {
@@ -88,5 +89,11 @@ pub fn get_grid_sample(g: SampleGrid) -> Grid<Color> {
             );
             grid
         }
+
+        SampleGrid::SolidBlock => {
+            let mut grid = Grid::<Color>::create(52, 7);
+            randomly_fill_grid(&mut grid, &[Color::Color1], 92u32);
+            grid
+        }
     }
 }