.

Author: Platane

cargo/snk-js/src/lib.rs

@@ -1,5 +1,10 @@
 use js_sys;
-use snk_grid::{color::Color, grid_samples::SampleGrid, point::Point, snake::Snake4};
+use snk_grid::{
+    color::Color,
+    grid_samples::SampleGrid,
+    point::Point,
+    snake::{Snake, Snake4},
+};
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
@@ -51,11 +56,38 @@ pub fn get_best_tunnel_to_collect_point(grid: &IColorGrid, to: &IPoint) -> Vec<I
     let res =
         snk_solver::collect_cost::get_best_tunnel_to_collect_point(&grid, &exit_grid, to.into());
 
-    log::info!("{:?} {:?} {:?}",res.path,res.in_cost,res.out_cost);
-
+    log::info!("{:?} {:?} {:?}", res.path, res.in_cost, res.out_cost);
 
     res.path.into_iter().map(IPoint::from).collect()
 }
+#[wasm_bindgen]
+pub fn get_snake_path_to_outside(grid: &IColorGrid, snake: Vec<IPoint>) -> Vec<IPoint> {
+    let grid = snk_grid::grid::Grid::from(grid);
+    let exit_grid = snk_solver::exit_grid::ExitGrid::create_from_grid_color(&grid);
+    let snake = Snake4::from_points(
+        snake
+            .into_iter()
+            .map(|p| Point::from(p))
+            .collect::<Vec<_>>()
+            .try_into()
+            .expect("snake should be 4 points"),
+    );
+    let res = snk_solver::snake_path_to_outside::get_snake_path_to_outside(
+        |p| exit_grid.is_outside(p),
+        |p| grid.get_color(p).into(),
+        &snake,
+    );
+
+    let mut p = snake.get_head();
+    res.0
+        .into_iter()
+        .map(|dir| {
+            p = p + dir.to_point();
+            p
+        })
+        .map(IPoint::from)
+        .collect()
+}
 
 // #[wasm_bindgen]
 // pub fn solve(grid: IColorGrid) -> js_sys::Uint8Array {
@@ -123,6 +155,10 @@ impl IColorGrid {
         let o: Vec<u8> = self.cells.iter().map(|u| *u as u8).collect();
         js_sys::Uint8Array::from(&o[..])
     }
+
+    pub fn set(&mut self, x: i8, y: i8, color: u8) {
+        self.cells[(x as usize) * (self.height as usize) + (y as usize)] = color.into();
+    }
 }
 
 impl From<IColorGrid> for snk_grid::grid::Grid<Color> {

cargo/snk-solver/src/collect_cost.rs

@@ -95,9 +95,9 @@ _        _
     );
     assert_eq!(grid.get_color(Point { x: 4, y: 2 }), Color::Color1);
 
-    let pto = ExitGrid::create_from_grid_color(&grid);
+    let exit_grid = ExitGrid::create_from_grid_color(&grid);
 
-    let tunnel = get_best_tunnel_to_collect_point(&grid, &pto, Point { x: 4, y: 2 });
+    let tunnel = get_best_tunnel_to_collect_point(&grid, &exit_grid, Point { x: 4, y: 2 });
 
     assert_eq!(tunnel.in_cost.get_color_count(Color::Color4), 1);
     assert_eq!(tunnel.out_cost.get_color_count(Color::Color4), 1);
@@ -123,9 +123,35 @@ _        _
 
     assert_eq!(grid.get_color(Point { x: 5, y: 3 }), Color::Color1);
 
+    let exit_grid = ExitGrid::create_from_grid_color(&grid);
+
+    let tunnel = get_best_tunnel_to_collect_point(&grid, &exit_grid, Point { x: 5, y: 3 });
+    assert_eq!(tunnel.in_cost.get_color_count(Color::Color4), 1);
+    assert_eq!(tunnel.out_cost.get_color_count(Color::Color4), 0);
+
+    assert_eq!(tunnel.in_cost.get_color_count(Color::Color1), 1);
+    assert_eq!(tunnel.out_cost.get_color_count(Color::Color1), 0);
+}
+
+#[test]
+fn it_should_compute_the_tunnel_for_enclaved_dot_in_large_cave_2() {
+    let grid = Grid::<_>::from(
+        r#"
+_           _
+_  ######   _
+_  ##   #   _
+_  ## . #   _
+_  ######   _
+_           _
+
+"#,
+    );
+
+    assert_eq!(grid.get_color(Point { x: 6, y: 3 }), Color::Color1);
+
     let pto = ExitGrid::create_from_grid_color(&grid);
 
-    let tunnel = get_best_tunnel_to_collect_point(&grid, &pto, Point { x: 5, y: 3 });
+    let tunnel = get_best_tunnel_to_collect_point(&grid, &pto, Point { x: 6, y: 3 });
     assert_eq!(tunnel.in_cost.get_color_count(Color::Color4), 1);
     assert_eq!(tunnel.out_cost.get_color_count(Color::Color4), 0);
 

cargo/snk-solver/src/lib.rs

@@ -5,5 +5,5 @@ mod cost;
 pub mod exit_grid;
 mod fitness;
 pub mod snake_path;
-mod snake_path_to_outside;
+pub mod snake_path_to_outside;
 pub mod solver;

cargo/snk-solver/src/snake_path_to_outside.rs

@@ -101,7 +101,7 @@ _########  _
 
 "#,
         );
-        let pto = ExitGrid::create_from_grid_color(&grid);
+        let exit_grid = ExitGrid::create_from_grid_color(&grid);
         let snake = Snake4::from_points([
             Point { x: 2, y: 2 },
             Point { x: 3, y: 2 },
@@ -110,13 +110,51 @@ _########  _
         ]);
 
         let (path, cost) =
-            get_snake_path_to_outside(|p| pto.is_outside(p), |p| grid.get_color(p).into(), &snake);
+            get_snake_path_to_outside(|p| exit_grid.is_outside(p), |p| grid.get_color(p).into(), &snake);
 
         println!("{:?} {:?}", path, cost);
+
         assert_eq!(
             cost.get_color_count(Color::Color4),
             1,
             "should have taken the smallest path"
         );
     }
+
+    #[test]
+    fn it_should_get_snake_path_to_outside_2() {
+        let mut grid = Grid::<_>::from(
+            r#"
+_          _
+_  #####   _
+_  #   #   _
+_  #   #   _
+_  #####   _
+_          _
+
+"#,
+        );
+
+        assert_eq!(grid.get_color(Point { x: 5, y: 4 }),Color::Color4);
+
+        let exit_grid = ExitGrid::create_from_grid_color(&grid);
+        let snake = Snake4::from_points([
+            Point { x: 5, y: 4 },
+            Point { x: 5, y: 5 },
+            Point { x: 5, y: 6 },
+            Point { x: 5, y: 7 },
+        ]);
+
+        grid.set(Point { x: 5, y: 4 }, Color::Empty);
+
+        let (path, cost) =
+            get_snake_path_to_outside(|p| exit_grid.is_outside(p), |p| grid.get_color(p).into(), &snake);
+
+        println!("{:?} {:?}", path, cost);
+        assert_eq!(
+            cost.get_color_count(Color::Color4),
+            0,
+            "should have taken the smallest path"
+        );
+    }
 }

packages/demo3/dev.ts

@@ -2,13 +2,14 @@ import { serve } from "bun";
 import * as childProcess from "child_process";
 import * as fs from "fs";
 import * as path from "path";
-
+import snake_exit_page from "./snake_exit/index.html";
 import tunnel_page from "./tunnel/index.html";
 
 const server = serve({
 	routes: {
 		"/": tunnel_page,
 		"/tunnel": tunnel_page,
+		"/snake_exit": snake_exit_page,
 	},
 
 	// Enable development mode for:

packages/demo3/snake_exit/index.html

@@ -0,0 +1,8 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <script type="module" src="./index.ts"></script>
+  </head>
+</html>

packages/demo3/snake_exit/index.ts

@@ -0,0 +1,41 @@
+import init, {
+	get_best_tunnel_to_collect_point,
+	get_grid_sample,
+	get_snake_path_to_outside,
+	IPoint,
+	init_log,
+	init_panic_hook,
+} from "snk-js";
+import wasmUrl from "snk-js/snk_js_bg.wasm";
+import { createCanvas } from "../utils/canvas";
+
+await init(wasmUrl);
+init_panic_hook();
+init_log();
+
+const grid = get_grid_sample("caves");
+grid.set(29, 4, 0);
+
+const snake = [
+	{ x: 29, y: 4 },
+	{ x: 29, y: 5 },
+	{ x: 29, y: 6 },
+	{ x: 29, y: 7 },
+];
+
+const path = get_snake_path_to_outside(
+	grid,
+	snake.map(({ x, y }) => IPoint.create(x, y)),
+);
+
+console.log(path);
+
+const { canvas, draw, getPointedCell, highlightCell } = createCanvas(grid);
+document.body.appendChild(canvas);
+draw(
+	{ width: grid.width, height: grid.height, data: grid.cells },
+	snake.flatMap(({ x, y }) => [x + 2, y + 2]) as any,
+	[],
+);
+
+for (const { x, y } of path) highlightCell(x, y);

packages/demo3/tunnel/index.ts

@@ -13,12 +13,15 @@ init_panic_hook();
 init_log();
 
 const grid = get_grid_sample("caves");
-const g = { width: grid.width, height: grid.height, data: grid.cells };
 const { canvas, draw, getPointedCell, highlightCell } = createCanvas(grid);
 document.body.appendChild(canvas);
 
 const drawBestTunnel = ({ x, y }: { x: number; y: number }) => {
-	draw(g, [] as any, []);
+	draw(
+		{ width: grid.width, height: grid.height, data: grid.cells },
+		[] as any,
+		[],
+	);
 
 	const path = get_best_tunnel_to_collect_point(grid, IPoint.create(x, y));