.

Author: Platane

cargo/snk-grid/src/color.rs

@@ -23,9 +23,9 @@ impl Color {
         match self {
             Color::Empty => 0,
             Color::Color1 => 1,
-            Color::Color2 => 150,
-            Color::Color3 => 150 * 150,
-            Color::Color4 => 150 * 150 * 150,
+            Color::Color2 => 128,
+            Color::Color3 => 128 * 128,
+            Color::Color4 => 128 * 128 * 128,
         }
     }
 }

cargo/snk-grid/src/direction.rs

@@ -1,3 +1,5 @@
+use std::collections::HashSet;
+
 use crate::point::{Point, add};
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
@@ -19,18 +21,38 @@ pub const DIRECTIONS: [Direction; 4] = [
 impl Direction {
     pub fn to_point(&self) -> Point {
         match self {
-            Direction::UP => Point { x: 0, y: 1 },
-            Direction::DOWN => Point { x: 0, y: -1 },
+            Direction::UP => Point { x: 0, y: -1 },
+            Direction::DOWN => Point { x: 0, y: 1 },
             Direction::LEFT => Point { x: -1, y: 0 },
             Direction::RIGHT => Point { x: 1, y: 0 },
         }
     }
 
+    pub fn get_opposite(&self) -> Direction {
+        match self {
+            Direction::UP => Direction::DOWN,
+            Direction::DOWN => Direction::UP,
+            Direction::LEFT => Direction::RIGHT,
+            Direction::RIGHT => Direction::LEFT,
+        }
+    }
+
     pub fn iter() -> impl Iterator<Item = Direction> {
         DIRECTIONS.iter().map(|dir| dir.clone())
     }
 }
 
+impl ToString for Direction {
+    fn to_string(&self) -> String {
+        match self {
+            Direction::UP => "↑".to_string(),
+            Direction::DOWN => "↓".to_string(),
+            Direction::LEFT => "←".to_string(),
+            Direction::RIGHT => "→".to_string(),
+        }
+    }
+}
+
 pub fn add_direction(a: Point, dir: Direction) -> Point {
     add(a, dir.to_point())
 }
@@ -45,30 +67,30 @@ pub fn iter_neighbour(p: Point) -> impl Iterator<Item = Point> {
 
 #[test]
 fn it_should_iter_direction() {
-    let directions: Vec<_> = iter_directions().collect();
+    let directions: HashSet<_> = iter_directions().collect();
 
     assert_eq!(
         directions,
-        vec![
+        HashSet::from([
             Direction::UP,
             Direction::DOWN,
             Direction::LEFT,
             Direction::RIGHT,
-        ]
+        ])
     );
 }
 
 #[test]
 fn it_should_iter_direction_point() {
-    let directions: Vec<_> = iter_directions().map(|d| d.to_point()).collect();
+    let directions: HashSet<_> = iter_directions().map(|d| d.to_point()).collect();
 
     assert_eq!(
         directions,
-        vec![
+        HashSet::from([
             Point { x: 0, y: 1 },
             Point { x: 0, y: -1 },
             Point { x: -1, y: 0 },
             Point { x: 1, y: 0 }
-        ]
+        ])
     );
 }

cargo/snk-grid/src/grid.rs

@@ -29,6 +29,10 @@ impl<T: Copy> Grid<T> {
         let i = self.get_index(p.x, p.y);
         return self.cells[i];
     }
+    pub fn get_mut(&mut self, p: Point) -> &mut T {
+        let i = self.get_index(p.x, p.y);
+        return self.cells.get_mut(i).unwrap();
+    }
     pub fn set(&mut self, p: Point, value: T) -> () {
         let i = self.get_index(p.x, p.y);
         self.cells[i] = value;

cargo/snk-solver/src/lib.rs

@@ -2,5 +2,6 @@
 // pub mod reach_outside;
 pub mod cost_to_outside;
 mod fitness;
+mod path_to_outside_grid;
 pub mod snake_path;
 pub mod solver;

cargo/snk-solver/src/path_to_outside_grid.rs

@@ -0,0 +1,98 @@
+use snk_grid::{
+    color::Color,
+    direction::{Direction, add_direction, iter_directions},
+    grid::{Grid, iter_rectangle_hull},
+    point::Point,
+};
+use std::collections::HashSet;
+
+#[derive(Copy, Clone)]
+pub struct ExitCell {
+    cost: u32,
+    exit_direction: Direction,
+}
+impl ToString for ExitCell {
+    fn to_string(&self) -> String {
+        if self.cost == 0 {
+            "o".to_string()
+        } else {
+            self.exit_direction.to_string()
+        }
+    }
+}
+
+//
+// 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(
+        grid.width,
+        grid.height,
+        ExitCell {
+            cost: u32::MAX,
+            exit_direction: Direction::UP,
+        },
+    );
+
+    let mut changed: HashSet<Point> =
+        iter_rectangle_hull(grid.width as i8 + 2, grid.height as i8 + 2)
+            .map(|mut p| {
+                p.x -= 1;
+                p.y -= 1;
+                p
+            })
+            .collect();
+
+    while let Some(p) = {
+        let next = changed.iter().next();
+        next.map(|p| *p)
+    } {
+        changed.remove(&p);
+
+        let cost = if path_to_outside.is_inside(p) {
+            path_to_outside.get(p).cost
+        } else {
+            0
+        };
+
+        for dir in iter_directions() {
+            let p = add_direction(p, dir);
+            if path_to_outside.is_inside(p) {
+                let new_cost = cost + grid.get(p).cost();
+
+                let c = path_to_outside.get_mut(p);
+
+                if new_cost < c.cost {
+                    c.cost = new_cost;
+                    c.exit_direction = dir.get_opposite();
+                    changed.insert(p);
+                }
+            }
+        }
+    }
+
+    path_to_outside
+}
+
+#[test]
+fn it_should_compute_the_cost_to_outside() {
+    let grid = Grid::<_>::from(
+        r#"
+_....
+_. ..
+_....
+_....
+"#,
+    );
+    let pto = create_path_to_outside(&grid);
+
+    assert_eq!(
+        pto.to_string(),
+        r#"
+o←↑↑↑
+o←←→→
+o←↓→→
+o←↓↓→
+"#
+        .trim(),
+    );
+}