to ascii

Author: Platane

packages/solver-r/src/_test_grid_samples.rs

@@ -2,45 +2,7 @@ use wasm_bindgen::prelude::wasm_bindgen;
 
 use crate::grid::{Color, Grid, Point};
 
-fn grid_from_ascii(ascii: &str) -> Grid<Color> {
-    let rows: Vec<_> = ascii.trim().split('\n').collect();
-
-    let width = rows.iter().fold(0, |max_len, r| max_len.max(r.len()));
-    let height = rows.len();
-
-    let mut grid = Grid::<Color>::create(width as u8, height as u8);
-
-    for x in 0..width {
-        for y in 0..height {
-            let c = rows[y].chars().nth(x).unwrap_or(' ');
-            let cell = match c {
-                ' ' => Color::Empty,
-                '_' => Color::Empty,
-                '1' => Color::Color1,
-                '2' => Color::Color2,
-                '3' => Color::Color3,
-                '4' => Color::Color4,
-
-                '.' => Color::Color1,
-                'o' => Color::Color2,
-                'O' => Color::Color3,
-                '#' => Color::Color4,
-                _ => panic!("unknow char \"{}\"", c),
-            };
-            grid.set(
-                &Point {
-                    x: x as i8,
-                    y: y as i8,
-                },
-                cell,
-            );
-        }
-    }
-
-    grid
-}
-
-fn randomly_fill_grid(grid: &mut Grid<Color>, probability: &[Color], seed: u32) -> () {
+fn randomly_fill_grid<T: Copy + Default>(grid: &mut Grid<T>, probability: &[T], seed: u32) -> () {
     // Pseudorandom number generator from the "Xorshift RNGs" paper by George Marsaglia.
     // https://github.com/rust-lang/rust/blob/1.55.0/library/core/src/slice/sort.rs#L559-L573
     fn random_numbers(seed: u32) -> impl Iterator<Item = u32> {
@@ -58,8 +20,8 @@ fn randomly_fill_grid(grid: &mut Grid<Color>, probability: &[Color], seed: u32)
     for x in 0..(grid.width as i8) {
         for y in 0..(grid.height as i8) {
             let random = rng.next().unwrap();
-            let cell = probability[random as usize % probability.len()];
-            grid.set(&Point { x, y }, cell);
+            let value: T = probability[random as usize % probability.len()];
+            grid.set(&Point { x, y }, value);
         }
     }
 }
@@ -74,17 +36,17 @@ pub enum SampleGrid {
 }
 pub fn get_grid_sample(g: SampleGrid) -> Grid<Color> {
     match g {
-        SampleGrid::Empty => grid_from_ascii(
-            &r#"
+        SampleGrid::Empty => Grid::<_>::from(
+            r#"
            _
            _
            _
            _
 "#,
         ),
 
-        SampleGrid::OneDot => grid_from_ascii(
-            &r#"
+        SampleGrid::OneDot => Grid::<_>::from(
+            r#"
            _
            _
     .      _
@@ -93,8 +55,8 @@ pub fn get_grid_sample(g: SampleGrid) -> Grid<Color> {
 "#,
         ),
 
-        SampleGrid::Realistic => grid_from_ascii(
-            &r#"
+        SampleGrid::Realistic => Grid::<_>::from(
+            r#"
 231 412 12213  13  213  421  121131   32123112 332 _
 412  12 4   331213 12214431 412  413 42133123  23 21
 123 2143 21211 2423    213 123 1233123432 223331233_
@@ -105,8 +67,8 @@ pub fn get_grid_sample(g: SampleGrid) -> Grid<Color> {
 "#,
         ),
 
-        SampleGrid::Labyrinthe => grid_from_ascii(
-            &r#"
+        SampleGrid::Labyrinthe => Grid::<_>::from(
+            r#"
 ################################################## #
 #                                                  #
 # ##################################################

packages/solver-r/src/astar_snake.rs

@@ -26,13 +26,13 @@ impl PartialOrd for Node {
 }
 
 pub fn get_snake_path<F>(
-    mut walkable: F,
+    walkable: F,
     snake: &[Point],
     end: &Point,
     max_weight: usize,
 ) -> Option<Vec<Point>>
 where
-    F: FnMut(&Point) -> bool,
+    F: Fn(&Point) -> bool,
 {
     let snake_length = snake.len();
 

packages/solver-r/src/exit_cost_grid.rs

@@ -1,7 +1,38 @@
-use crate::grid::{Color, Grid};
+use std::u32;
 
-pub fn get_exit_cost_grid(color_grid: &Grid<Color>) -> Grid<u8> {
-    let mut exit_cost_grid = Grid::<u8>::create(color_grid.width, color_grid.height);
+use crate::grid::{iter_neighbour4, Color, Grid};
+
+pub fn get_exit_cost_grid(color_grid: &Grid<Color>) -> Grid<u32> {
+    let mut exit_cost_grid = Grid::<u32>::create(color_grid.width, color_grid.height);
+    exit_cost_grid.fill(u32::MAX);
+
+    let mut open_list = color_grid.iter_hull().collect::<Vec<_>>();
+
+    while let Some(p) = open_list.pop() {
+        let neighbour_cost_min = iter_neighbour4(&p)
+            .map(|u| {
+                if !color_grid.is_inside(&u) {
+                    0
+                } else {
+                    exit_cost_grid.get(&u)
+                }
+            })
+            .min()
+            .unwrap();
+        let self_cost = (10 as u32).pow(color_grid.get(&p) as u32);
+
+        let cost = neighbour_cost_min + self_cost;
+
+        if exit_cost_grid.get(&p) != cost {
+            exit_cost_grid.set(&p, cost);
+
+            open_list.append(
+                &mut iter_neighbour4(&p)
+                    .filter(|u| color_grid.is_inside(u))
+                    .collect(),
+            );
+        }
+    }
 
     exit_cost_grid
 }

packages/solver-r/src/grid.rs

@@ -1,5 +1,7 @@
 use std::collections::HashSet;
 
+use crate::grid_ascii::{grid_from_ascii, grid_to_ascii};
+
 pub const DIRECTION_RIGHT: Point = Point { x: 1, y: 0 };
 pub const DIRECTION_LEFT: Point = Point { x: -1, y: 0 };
 pub const DIRECTION_UP: Point = Point { x: 0, y: 1 };
@@ -16,6 +18,26 @@ pub struct Point {
     pub x: i8,
     pub y: i8,
 }
+pub fn iter_neighbour4(p: &Point) -> impl Iterator<Item = Point> {
+    let mut i: usize = 0;
+    let px = p.x;
+    let py = p.y;
+    std::iter::from_fn(move || {
+        let out = DIRECTIONS.get(i).map(|dir| Point {
+            x: px + dir.x,
+            y: py + dir.y,
+        });
+
+        i += 1;
+        out
+    })
+}
+pub fn add(a: &Point, b: &Point) -> Point {
+    Point {
+        x: a.x + b.x,
+        y: a.y + b.y,
+    }
+}
 pub fn get_distance(a: &Point, b: &Point) -> u8 {
     (a.x - b.x).abs() as u8 + (a.y - b.y).abs() as u8
 }
@@ -29,38 +51,26 @@ pub enum Color {
     Color3 = 3,
     Color4 = 4,
 }
-
 impl Default for Color {
     fn default() -> Self {
         Color::Empty
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct Grid<T: Copy> {
     pub width: u8,
     pub height: u8,
     pub cells: Vec<T>,
 }
-impl<T: Copy + Default> Grid<T> {
-    pub fn create(width: u8, height: u8) -> Grid<T> {
-        let n = (width as usize) * (height as usize);
-        let cells = (0..n).map(|_| T::default()).collect();
-
-        Grid {
-            width,
-            height,
-            cells,
-        }
-    }
-
+impl<T: Copy> Grid<T> {
     fn get_index(&self, x: i8, y: i8) -> usize {
         return (x as usize) * (self.height as usize) + (y as usize);
     }
 
     pub fn fill(&mut self, value: T) -> () {
         let n = (self.width as usize) * (self.height as usize);
-        for i in (0..n) {
+        for i in 0..n {
             self.cells[i] = value;
         }
     }
@@ -97,6 +107,69 @@ impl<T: Copy + Default> Grid<T> {
             }
         })
     }
+    pub fn iter_hull(&self) -> impl Iterator<Item = Point> {
+        let mut i: usize = 0;
+        let width = self.width as usize;
+        let height = self.height as usize;
+        std::iter::from_fn(move || {
+            let mut p = Point { x: 0, y: 0 };
+
+            let mut k = i;
+
+            if k < width {
+                p.x = k as i8;
+                p.y = 0;
+            } else {
+                k -= width;
+                if k < width {
+                    p.x = k as i8;
+                    p.y = (height - 1) as i8;
+                } else {
+                    k -= width;
+                    if k < height {
+                        p.x = 0;
+                        p.y = k as i8;
+                    } else {
+                        k -= height;
+                        if k < height {
+                            p.x = (width - 1) as i8;
+                            p.y = k as i8;
+                        } else {
+                            return None;
+                        }
+                    }
+                }
+            }
+
+            i += 1;
+
+            Some(p)
+        })
+    }
+}
+impl<T: Default + Copy> Grid<T> {
+    pub fn create(width: u8, height: u8) -> Grid<T> {
+        let n = (width as usize) * (height as usize);
+        let cells = (0..n).map(|_| T::default()).collect();
+
+        Grid {
+            width,
+            height,
+            cells,
+        }
+    }
+}
+impl<T: Copy> Grid<T> {
+    pub fn create_with(width: u8, height: u8, item: T) -> Grid<T> {
+        let n = (width as usize) * (height as usize);
+        let cells = (0..n).map(|_| item).collect();
+
+        Grid {
+            width,
+            height,
+            cells,
+        }
+    }
 }
 
 #[test]
@@ -136,3 +209,25 @@ fn it_should_iterate() {
         ])
     );
 }
+#[test]
+fn it_should_iterate_hull() {
+    let grid = Grid::<Color>::create(3, 3);
+
+    assert_eq!(
+        grid.iter_hull().collect::<HashSet<_>>(),
+        HashSet::from([
+            Point { x: 0, y: 0 },
+            Point { x: 0, y: 1 },
+            Point { x: 0, y: 2 },
+            Point { x: 2, y: 0 },
+            Point { x: 2, y: 1 },
+            Point { x: 2, y: 2 },
+            Point { y: 0, x: 0 },
+            Point { y: 0, x: 1 },
+            Point { y: 0, x: 2 },
+            Point { y: 2, x: 0 },
+            Point { y: 2, x: 1 },
+            Point { y: 2, x: 2 },
+        ])
+    );
+}