.

Author: Platane

packages/demo/demo.rust.ts

@@ -1,6 +1,7 @@
+import { createSnakeFromCells, snakeToCells } from "@snk/types/snake";
 import { createCanvas } from "./canvas";
 import "./menu";
-import { grid } from "./sample";
+import { grid, snake } from "./sample";
 
 (async () => {
 	const api = await import("@snk/solver-r");
@@ -9,16 +10,43 @@ import { grid } from "./sample";
 
 	const freeCells = api.iget_free_cells(g);
 
+	api.greet();
+
+	const path = api.ieat_free_cells(
+		g,
+		snakeToCells(snake).map((p) => api.IPoint.create(p.x, p.y)),
+	);
+
 	{
 		const { canvas, draw, highlightCell } = createCanvas(g);
 		document.body.appendChild(canvas);
 
-		draw({ width: g.width, height: g.height, data: g.data }, [] as any, []);
+		const snakeLength = snake.length / 2;
+
+		const onChange = () => {
+			const i = +input.value;
+			const s = createSnakeFromCells(path.slice(i, i + snakeLength).reverse());
+
+			draw({ width: g.width, height: g.height, data: g.data }, s, []);
+
+			// for (let i = freeCells.length / 2; i--; ) {
+			// 	const x = freeCells[i * 2 + 0];
+			// 	const y = freeCells[i * 2 + 1];
+			// 	highlightCell(x, y);
+			// }
+		};
+
+		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);
 
-		for (let i = freeCells.length / 2; i--; ) {
-			const x = freeCells[i * 2 + 0];
-			const y = freeCells[i * 2 + 1];
-			highlightCell(x, y);
-		}
+		onChange();
 	}
 })();

packages/solver-r/src/lib.rs

@@ -6,22 +6,34 @@ mod snake_compact;
 mod snake_walk;
 mod solver;
 
+use std::collections::HashSet;
+
 use astar::get_path;
 use astar_snake::get_snake_path;
 use grid::{Cell, Grid, Point, WalkableGrid};
 use js_sys;
+use log::info;
 use snake_walk::get_path_to_eat_all;
 use solver::get_free_cells;
 use wasm_bindgen::prelude::*;
 
+#[wasm_bindgen]
+pub fn init_panic_hook() {
+    console_error_panic_hook::set_once();
+}
+
 #[wasm_bindgen]
 extern "C" {
     fn alert(s: &str);
 }
 
 #[wasm_bindgen]
 pub fn greet() {
-    alert("Hello, wasm-game-of-life!");
+    init_panic_hook();
+    console_log::init_with_level(log::Level::Debug).unwrap();
+
+    info!("It works!");
+    // alert("Hello, wasm-game-of-life!");
 }
 
 #[wasm_bindgen]
@@ -122,7 +134,7 @@ type ISnake = Vec<IPoint>;
 pub fn iget_free_cells(grid: &IGrid) -> js_sys::Uint8Array {
     let g = Grid::from(grid.clone());
 
-    let (_, out) = get_free_cells(&g, Cell::Color1);
+    let (out, _) = get_free_cells(&g, Cell::Color1);
 
     let o: Vec<u8> = out.iter().flat_map(|p| [p.x as u8, p.y as u8]).collect();
 
@@ -172,9 +184,14 @@ pub fn ieat_free_cells(grid: &IGrid, snake: ISnake) -> Vec<IPoint> {
     let grid = WalkableGrid::create(Grid::from(grid.clone()), Cell::Color1);
     let snake: Vec<Point> = snake.iter().map(Point::from).collect();
 
-    let (free_cells, out) = get_free_cells(&grid.grid, Cell::Color1);
+    let (free_cells, _) = get_free_cells(&grid.grid, Cell::Color1);
+
+    let mut to_eat: HashSet<Point> = HashSet::new();
+    to_eat.insert(Point { x: 6, y: 6 });
+    to_eat.insert(Point { x: 5, y: 0 });
 
-    let path = get_path_to_eat_all(&grid, &snake, free_cells);
+    let path = get_path_to_eat_all(&grid, &snake, &to_eat);
+    // let path = get_path_to_eat_all(&grid, &snake, &free_cells);
 
     path.iter().map(IPoint::from).collect()
 }

packages/solver-r/src/snake_walk.rs

@@ -54,7 +54,7 @@ pub fn can_snake_reach_outside(grid: &WalkableGrid, snake: &Snake) -> bool {
 pub fn get_path_to_eat_all(
     grid: &WalkableGrid,
     snake: &[Point],
-    cells_to_eat: HashSet<Point>,
+    cells_to_eat: &HashSet<Point>,
 ) -> Vec<Point> {
     let snake_length = snake.len();
 
@@ -78,12 +78,12 @@ pub fn get_path_to_eat_all(
             }
 
             let snake = &path[0..snake_length];
-            let w = match best_route.as_ref() {
+            let max_weight = match best_route.as_ref() {
                 None => usize::MAX,
                 Some(path) => path.len() - snake_length,
             };
 
-            let res = get_snake_path(|c| grid.is_cell_walkable(c), snake, p, w);
+            let res = get_snake_path(|c| grid.is_cell_walkable(c), snake, p, max_weight);
 
             if let Some(sub_path) = res {
                 if match best_route.as_ref() {
@@ -96,15 +96,19 @@ pub fn get_path_to_eat_all(
         }
 
         if let Some(mut sub_path) = best_route {
-            path.append(&mut sub_path);
+            let eaten = sub_path[0];
 
-            let eaten = sub_path.last().unwrap();
-            cells_to_eat.retain(|p| p != eaten);
+            cells_to_eat.retain(|p| **p != eaten);
+
+            sub_path.truncate(sub_path.len() - snake_length);
+            sub_path.append(&mut path);
+            path = sub_path;
         } else {
-            assert!(false);
+            panic!("impossible to path to cell to eat");
         }
     }
 
+    path.reverse();
     path
 }