..

Author: Platane

cargo/Cargo.lock

@@ -22,21 +22,33 @@ pub fn log() {
 #[wasm_bindgen]
 pub fn get_snake_path(grid: IColorGrid, snake: Vec<IPoint>, to: IPoint) -> Option<Vec<IPoint>> {
     let grid = snk_grid::grid::Grid::from(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::get_snake_path(
-        |p| grid.get_color(p).cost(),
-        Snake4::from_points(
-            snake
-                .into_iter()
-                .map(|p| Point::from(p))
-                .collect::<Vec<_>>()
-                .try_into()
-                .expect("snake should be 4 points"),
-        ),
+        |p| match grid.get_color(p) {
+            Color::Empty => 1,
+            Color::Color1 => 10,
+            Color::Color2 => 100,
+            Color::Color3 => 200,
+            Color::Color4 => 300,
+        },
+        &snake,
         to.into(),
-        99999,
+        10,
     );
 
-    res.map(|d| d.into_iter().map(|d| IPoint::from(d.to_point())).collect())
+    res.map(|d| {
+        d.into_iter()
+            .map(|dir| dir.to_point())
+            .map(IPoint::from)
+            .collect()
+    })
 }
 
 // #[wasm_bindgen]

cargo/snk-js/src/lib.rs

@@ -7,3 +7,4 @@ authors.workspace = true
 
 [dependencies]
 snk-grid = { workspace = true }
+log = "0.4"

cargo/snk-solver/Cargo.toml

@@ -12,6 +12,25 @@ for each cell, true if there is two separated path from the cell to the outside
 
 useful because it means the snake can freely go there
 
+**coil**
+
+given a cave compute the max length of a snake that can loop
+
+assumptions: 
+- can add any cell that is linked to ast least two other coilable cells
+- should be rounded by 2
+
+edge case:
+```
+// tunnel
+######### 
+#     ### 
+# #   ### 
+# #   ### 
+#     ### 
+######### 
+```
+
 ## Steps
 
 For each color

cargo/snk-solver/README.md

@@ -1,19 +1,50 @@
 use snk_grid::{
     color::Color,
-    direction::iter_neighbour,
+    direction::{add_direction, iter_neighbour},
     grid::{Grid, iter_rectangle_hull},
     point::Point,
 };
 use std::collections::HashSet;
 
-struct CollectionCost {
+use crate::path_to_outside_grid::ExitDirection;
+
+pub struct CollectionCost {
     in_cost: u32,
     out_cost: u32,
 }
 
-pub fn get_collect_cost(is_outside: F, get_cost: C) -> CollectionCost
-where
-    F: Fn(Point) -> bool,
-    F: Fn(Point) -> u32,
-{
+// pub fn get_collect_cost_(is_outside: F, get_cost: C) -> CollectionCost
+// where
+//     F: Fn(Point) -> bool,
+//     F: Fn(Point) -> u32,
+// {
+// }
+
+pub fn get_collect_cost(
+    grid: &Grid<Color>,
+    exit_grid: &Grid<ExitDirection>,
+    dot: Point,
+) -> CollectionCost {
+    let in_cost = exit_grid.get(dot).cost;
+
+    let mut grid = grid.clone();
+
+    let mut p = dot;
+    loop {
+        let e = exit_grid.get(dot);
+        if e.cost == 0 {
+            break;
+        }
+        grid.set(p, Color::Empty);
+        p = add_direction(p, e.exit_direction);
+    }
+
+    // TODO compute a probable initial snake
+
+    // TODO from that snake, seak the outside without self-colliding
+
+    CollectionCost {
+        in_cost,
+        out_cost: 0,
+    }
 }

cargo/snk-solver/src/collect_cost.rs

@@ -1,5 +1,6 @@
 // pub mod cave;
 // pub mod reach_outside;
+mod collect_cost;
 pub mod cost_to_outside;
 mod fitness;
 mod path_to_outside_grid;

cargo/snk-solver/src/lib.rs

@@ -7,11 +7,16 @@ use snk_grid::{
 use std::collections::HashSet;
 
 #[derive(Copy, Clone)]
-pub struct ExitCell {
-    cost: u32,
-    exit_direction: Direction,
+pub struct ExitDirection {
+    pub cost: u32,
+    pub exit_direction: Direction,
 }
-impl ToString for ExitCell {
+impl ExitDirection {
+    pub fn is_outside(&self) -> bool {
+        self.cost == 0
+    }
+}
+impl ToString for ExitDirection {
     fn to_string(&self) -> String {
         if self.cost == 0 {
             "o".to_string()
@@ -23,11 +28,11 @@ impl ToString for ExitCell {
 
 //
 // cost_to_outside : for each cell return the minimal cost ( = sum of dot, with greater color costing more ) to get outside
-pub fn create_path_to_outside(grid: &Grid<Color>) -> Grid<ExitCell> {
-    let mut path_to_outside = Grid::<ExitCell>::create_with_value(
+pub fn create_path_to_outside(grid: &Grid<Color>) -> Grid<ExitDirection> {
+    let mut path_to_outside = Grid::<ExitDirection>::create_with_value(
         grid.width,
         grid.height,
-        ExitCell {
+        ExitDirection {
             cost: u32::MAX,
             exit_direction: Direction::UP,
         },

cargo/snk-solver/src/path_to_outside_grid.rs

@@ -1,3 +1,4 @@
+use log::info;
 use snk_grid::{
     direction::{Direction, iter_directions},
     point::{Point, get_distance},
@@ -9,23 +10,20 @@ use std::collections::{BinaryHeap, HashSet};
 struct Node {
     pub snake: Snake4,
     pub weight: u32,
-    pub heuristic: u32,
-    pub parent: Option<(Box<Node>, Direction)>,
-}
-impl Node {
-    fn f(&self) -> u32 {
-        self.weight + self.heuristic
-    }
+    pub distance: u32,
+    pub f: u32,
+    pub path: Vec<Direction>,
 }
+
 impl Eq for Node {}
 impl PartialEq for Node {
     fn eq(&self, other: &Self) -> bool {
-        self.parent == other.parent
+        self.path == other.path
     }
 }
 impl Ord for Node {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.f().cmp(&other.f()).reverse()
+        self.f.cmp(&other.f)
     }
 }
 impl PartialOrd for Node {
@@ -36,7 +34,7 @@ impl PartialOrd for Node {
 
 pub fn get_snake_path<F>(
     get_walk_cost: F,
-    from: Snake4,
+    from: &Snake4,
     to: Point,
     max_weight: u32,
 ) -> Option<Vec<Direction>>
@@ -47,21 +45,61 @@ where
     let mut close_list: HashSet<Snake4> = HashSet::new();
 
     open_list.push(Node {
-        heuristic: get_distance(from.get_head(), to) as u32,
-        snake: from,
+        distance: 0,
+        snake: from.clone(),
+        weight: 0,
+        f: 0,
+        path: Vec::new(),
+    });
+
+    open_list.push(Node {
+        distance: 0,
+        snake: from.clone(),
         weight: 0,
-        parent: None,
+        f: 3,
+        path: Vec::new(),
     });
 
+    open_list.push(Node {
+        distance: 0,
+        snake: from.clone(),
+        weight: 0,
+        f: 1,
+        path: Vec::new(),
+    });
+    open_list.push(Node {
+        distance: 0,
+        snake: from.clone(),
+        weight: 0,
+        f: 5,
+        path: Vec::new(),
+    });
+
+    log::info!(
+        "open_list {:?}",
+        open_list
+            .clone()
+            .into_iter()
+            .map(|n| n.f)
+            .collect::<Vec<_>>()
+    );
+
+    let mut loop_count = 0;
+
     while let Some(node) = open_list.pop() {
-        // println!(
-        //     "{:?}",
-        //     open_list
-        //         .clone()
-        //         .into_iter()
-        //         .map(|n| n.weight)
-        //         .collect::<Vec<_>>()
-        // );
+        loop_count += 1;
+
+        log::info!(
+            "loop {} node {} {:?} open_list {:?}",
+            loop_count,
+            node.f,
+            node.snake.get_head(),
+            open_list
+                .clone()
+                .into_iter()
+                .map(|n| n.f)
+                .collect::<Vec<_>>()
+        );
 
         for dir in iter_directions() {
             if snake_will_self_collide(&node.snake, dir) {
@@ -78,48 +116,61 @@ where
 
             if to == head {
                 // unroll and return
-                let mut path = vec![dir];
+                let mut path = node.path.clone();
+                path.push(dir);
 
-                let mut parent = node.parent;
-                while let Some((node, dir)) = parent {
-                    path.push(dir);
-                    parent = node.parent;
-                }
+                log::info!(" {:?} : {:?}", to, head);
+                log::info!("found loop {} length: {}", loop_count, path.len());
 
                 path.reverse();
                 return Some(path);
             }
 
             let weight = node.weight + get_walk_cost(head);
-            let heuristic = get_distance(head, to) as u32;
+            let distance = get_distance(head, to) as u32;
+            log::info!(" {:?} {:?}", head, distance);
 
-            if weight + heuristic > max_weight {
-                continue;
-            }
+            let f = weight + distance;
+            // if f > max_weight {
+            //     continue;
+            // }
 
+            let mut path = node.path.clone();
+            path.push(dir);
             open_list.push(Node {
                 snake,
                 weight,
-                heuristic,
-                parent: Some((Box::new(node.clone()), dir)),
+                distance,
+                f,
+                path,
             });
         }
 
         close_list.insert(node.snake);
+
+        log::info!(
+            "open_list {:?}",
+            open_list
+                .clone()
+                .into_iter()
+                .map(|n| n.f)
+                .collect::<Vec<_>>()
+        );
     }
 
     None
 }
 
 #[test]
+#[ignore]
 fn it_should_found_simple_path() {
     let snake = Snake4::from_points([
         Point { x: 0, y: 0 },
         Point { x: 1, y: 0 },
         Point { x: 2, y: 0 },
         Point { x: 3, y: 0 },
     ]);
-    let res = get_snake_path(|_| 1, snake, Point { x: 0, y: 3 }, 9999);
+    let res = get_snake_path(|_| 1, &snake, Point { x: 0, y: 3 }, 9999);
 
     assert_eq!(
         res,