..

Author: Platane

cargo/snk-grid/src/grid.rs

@@ -13,8 +13,8 @@ pub fn iter_rectangle_hull(width: i8, height: i8) -> impl Iterator<Item = Point>
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct Grid<T: Copy> {
-    pub width: u8,
-    pub height: u8,
+    pub width: i8,
+    pub height: i8,
     pub cells: Vec<T>,
 }
 impl<T: Copy> Grid<T> {
@@ -45,13 +45,13 @@ impl<T: Copy> Grid<T> {
     }
 
     /// ⚠️ assuming the point is inside the grid
-    pub fn distance_from_outside(&self, p: Point) -> u8 {
-        let x = p.x as u8;
-        let y = p.y as u8;
-        y.min(self.height - 1 - y).min(x).min(self.width - 1 - x)
+    pub fn distance_from_outside(&self, p: Point) -> i8 {
+        p.y.min(self.height - 1 - p.y)
+            .min(p.x)
+            .min(self.width - 1 - p.x)
     }
 
-    pub fn create_with_value(width: u8, height: u8, value: T) -> Grid<T> {
+    pub fn create_with_value(width: i8, height: i8, value: T) -> Grid<T> {
         let n = (width as usize) * (height as usize);
         let cells = (0..n).map(|_| value).collect();
 
@@ -71,7 +71,7 @@ impl<T: Copy> Grid<T> {
     }
 }
 impl<T: Default + Copy> Grid<T> {
-    pub fn create_with_default(width: u8, height: u8) -> Grid<T> {
+    pub fn create_with_default(width: i8, height: i8) -> Grid<T> {
         let n = (width as usize) * (height as usize);
         let cells = (0..n).map(|_| T::default()).collect();
 

cargo/snk-grid/src/grid_ascii.rs

@@ -10,7 +10,7 @@ pub fn grid_from_ascii<T: Copy + Default + From<char>>(ascii: &str) -> Grid<T> {
     let width = rows.iter().fold(0, |max_len, r| max_len.max(r.len()));
     let height = rows.len();
 
-    let mut grid = Grid::<T>::create_with_default(width as u8, height as u8);
+    let mut grid = Grid::<T>::create_with_default(width as i8, height as i8);
 
     for p in iter_rectangle_fill(width as i8, height as i8) {
         let mut c = rows[p.y as usize].chars().nth(p.x as usize).unwrap_or(' ');
@@ -51,6 +51,25 @@ where
     out
 }
 
+pub fn get_ascii_grid<F>(grid_width: i8, grid_height: i8, to_string: F) -> String
+where
+    F: Fn(Point) -> String,
+{
+    let mut out: String = String::new();
+    for y in 0..grid_height {
+        for x in 0..grid_width {
+            let p = Point { x, y };
+            let s = to_string(p);
+            let fist_char = s.chars().nth(0).unwrap();
+            out.push(fist_char);
+        }
+        out.push('\n');
+    }
+
+    out.pop();
+    out
+}
+
 pub fn grid_to_ascii<T: Copy + ToString>(grid: &Grid<T>) -> String {
     grid_to_ascii_transformed(grid, |value| value.to_string())
 }

cargo/snk-grid/src/grid_samples.rs

@@ -91,14 +91,14 @@ _        _
 
         SampleGrid::Caves => Grid::<_>::from(
             r#"
-_  ###      ####          _
-  #  ###    #   #    ###  _
- #  ..  #  #  .  #   #.#  _
- #     #   #    #    # #  _
-  ### #    ### #          _
-    #.#                   _
-    ###                   _
-                          _
+_  ###      ####                   _
+  #  ###    #   #    ###  ######   _
+ #  ..  #  #  .  #   #.#  ##   #   _
+ #     #   #    #    # #  ##   #   _
+  ### #    ### #          ######   _
+    #.#                            _
+    ###                            _
+                                   _
 "#,
         ),
 

cargo/snk-js/src/lib.rs

@@ -1,9 +1,5 @@
 use js_sys;
-use log::info;
-use snk_grid::{
-    color::Color, direction::Direction, grid::Grid, grid_samples::SampleGrid, point::Point,
-    snake::Snake4,
-};
+use snk_grid::{color::Color, grid_samples::SampleGrid, point::Point, snake::Snake4};
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
@@ -12,10 +8,8 @@ pub fn init_panic_hook() {
 }
 
 #[wasm_bindgen]
-pub fn log() {
-    init_panic_hook();
+pub fn init_log() {
     console_log::init_with_level(log::Level::Debug).unwrap();
-
     log::info!("It works!");
 }
 
@@ -50,6 +44,18 @@ pub fn get_snake_path(grid: IColorGrid, snake: Vec<IPoint>, to: IPoint) -> Optio
             .collect()
     })
 }
+#[wasm_bindgen]
+pub fn get_best_tunnel_to_collect_point(grid: &IColorGrid, to: &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 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);
+
+
+    res.path.into_iter().map(IPoint::from).collect()
+}
 
 // #[wasm_bindgen]
 // pub fn solve(grid: IColorGrid) -> js_sys::Uint8Array {
@@ -85,14 +91,14 @@ pub fn get_grid_sample(sample_name: String) -> IColorGrid {
 #[wasm_bindgen]
 #[derive(Clone)]
 pub struct IColorGrid {
-    pub width: u8,
-    pub height: u8,
+    pub width: i8,
+    pub height: i8,
     cells: Vec<Color>,
 }
 
 #[wasm_bindgen]
 impl IColorGrid {
-    pub fn create(width: u8, height: u8, data: js_sys::Uint8Array) -> IColorGrid {
+    pub fn create(width: i8, height: i8, data: js_sys::Uint8Array) -> IColorGrid {
         if (width as usize) * (height as usize) != (data.length() as usize) {
             panic!(
                 "grid {}x{} should have {} elements, found {}",
@@ -128,6 +134,15 @@ impl From<IColorGrid> for snk_grid::grid::Grid<Color> {
         }
     }
 }
+impl From<&IColorGrid> for snk_grid::grid::Grid<Color> {
+    fn from(value: &IColorGrid) -> Self {
+        Self {
+            width: value.width,
+            height: value.height,
+            cells: value.cells.clone(),
+        }
+    }
+}
 impl From<snk_grid::grid::Grid<Color>> for IColorGrid {
     fn from(value: snk_grid::grid::Grid<Color>) -> Self {
         Self {

cargo/snk-solver/src/collect_cost.rs

@@ -1,22 +1,12 @@
-use snk_grid::{
-    color::Color,
-    direction::{Direction, add_direction, iter_neighbour},
-    grid::{Grid, iter_rectangle_hull},
-    grid_samples::{SampleGrid, get_grid_sample},
-    point::Point,
-    snake::Snake4,
-};
-use std::collections::HashSet;
-
-use crate::{
-    cost::Cost,
-    path_to_outside_grid::{ExitDirection, create_path_to_outside},
-};
+use snk_grid::{color::Color, grid::Grid, point::Point, snake::Snake4};
 
+use crate::{cost::Cost, exit_grid::ExitGrid, snake_path_to_outside::get_snake_path_to_outside};
+
+#[derive(Debug)]
 pub struct Tunnel {
-    path: Vec<Point>,
-    in_cost: Cost,
-    out_cost: Cost,
+    pub path: Vec<Point>,
+    pub in_cost: Cost,
+    pub out_cost: Cost,
 }
 
 // pub fn get_collect_cost_(is_outside: F, get_cost: C) -> CollectionCost
@@ -26,84 +16,119 @@ pub struct Tunnel {
 // {
 // }
 
-pub fn get_collect_cost(grid: &Grid<Color>, exit_grid: &Grid<ExitDirection>, dot: Point) -> Tunnel {
-    let in_cost = exit_grid.get(dot).cost;
+pub fn get_best_tunnel_to_collect_point(
+    grid: &Grid<Color>,
+    exit_grid: &ExitGrid,
+    dot: Point,
+) -> Tunnel {
+    let in_cost = exit_grid.get_cost_to_outside(dot);
 
     let mut grid = grid.clone();
 
+    // first path, from the dot to the outside, it should be at least snake length long and ends in outside
     let mut path_out_1 = Vec::new();
 
     let mut p = dot;
 
     loop {
         path_out_1.push(p);
-
-        let (dir, outside) = if exit_grid.is_inside(p) {
-            let e = exit_grid.get(p);
+        if grid.is_inside(p) {
             grid.set(p, Color::Empty);
-            (e.exit_direction, e.is_outside())
-        } else {
-            println!("{:?}", get_outside_direction(&grid, p));
-            (get_outside_direction(&grid, p), true)
-        };
+        }
 
-        if path_out_1.len() >= 6 && outside {
+        if path_out_1.len() >= 6 && exit_grid.is_outside(p) {
             break;
         }
 
-        p += dir.into();
+        p += exit_grid.get_exit_direction(p).into();
     }
 
-    println!("path_out_1 {:?}", path_out_1);
-
-    let path = path_out_1
+    // path from the outside to the dot
+    let mut path = path_out_1
         .iter()
-        .take_while(|p| exit_grid.is_inside(**p) && !exit_grid.get(**p).is_outside())
+        .map(|p| *p)
+        .take_while(|p| !exit_grid.is_outside(*p))
         .collect::<Vec<_>>();
+    path.reverse();
 
-    println!("path {:?}", path);
-
-    let mut snake = Snake4::from_points(
+    // snake arriving from the outside to the dot
+    let snake = Snake4::from_points(
         path_out_1[0..4]
             .try_into()
             .expect("snake should be 4 points"),
     );
 
-    println!("{:?}", snake);
+    // /!\
+    // at this stage the exit grid is not in sync with the grid_color
+    // since we modified the grid_color
 
-    // TODO compute a probable initial snake
-
-    // TODO from that snake, seak the outside without self-colliding
+    // from that snake, seek the outside without self-colliding
+    let (path_out, out_cost) = get_snake_path_to_outside(
+        |p| exit_grid.is_outside(p),
+        |p| grid.get_color(p).into(),
+        &snake,
+    );
+    for dir in path_out {
+        let p = *path.last().unwrap();
+        path.push(p + dir.into());
+    }
+    path.pop();
 
     Tunnel {
-        path: path_out_1,
+        path,
         in_cost,
-        out_cost: Cost::zero(),
+        out_cost,
     }
 }
 
-fn get_outside_direction<T: Copy>(grid: &Grid<T>, p: Point) -> Direction {
-    if p.x < 0 {
-        Direction::LEFT
-    } else if p.y < 0 {
-        Direction::UP
-    } else if (p.x as u8) >= grid.width {
-        Direction::RIGHT
-    } else if (p.y as u8) >= grid.height {
-        Direction::DOWN
-    } else {
-        assert!(false, "fail here");
-        Direction::DOWN
-    }
+#[test]
+fn it_should_compute_the_tunnel_for_enclaved_dot() {
+    let grid = Grid::<_>::from(
+        r#"
+_        _
+_  ###   _
+_  #.#   _
+_  ###   _
+_        _
+
+"#,
+    );
+    assert_eq!(grid.get_color(Point { x: 4, y: 2 }), Color::Color1);
+
+    let pto = ExitGrid::create_from_grid_color(&grid);
+
+    let tunnel = get_best_tunnel_to_collect_point(&grid, &pto, 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);
+
+    assert_eq!(tunnel.in_cost.get_color_count(Color::Color1), 1);
+    assert_eq!(tunnel.out_cost.get_color_count(Color::Color1), 0);
 }
 
 #[test]
-#[ignore]
-fn it_should_compute_the_tunnel_for_small_cave() {
-    let grid = get_grid_sample(SampleGrid::OneSmallCave);
-    let pto = create_path_to_outside(&grid);
+fn it_should_compute_the_tunnel_for_enclaved_dot_in_large_cave() {
+    let grid = Grid::<_>::from(
+        r#"
+_          _
+_  #####   _
+_  #   #   _
+_  # . #   _
+_  #   #   _
+_  #####   _
+_        _
+
+"#,
+    );
+
+    assert_eq!(grid.get_color(Point { x: 5, y: 3 }), Color::Color1);
+
+    let pto = ExitGrid::create_from_grid_color(&grid);
 
-    get_collect_cost(&grid, &pto, Point { x: 4, y: 2 });
+    let tunnel = get_best_tunnel_to_collect_point(&grid, &pto, 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!(false)
+    assert_eq!(tunnel.in_cost.get_color_count(Color::Color1), 1);
+    assert_eq!(tunnel.out_cost.get_color_count(Color::Color1), 0);
 }