.

Author: Platane

packages/solver-r/src/exitable.rs

@@ -0,0 +1,61 @@
+use std::collections::HashSet;
+
+use crate::grid::{Point, WalkableGrid, DIRECTIONS};
+
+pub fn initiate_exitable_with_border(
+    exitable_cells: &mut HashSet<Point>,
+    grid: &WalkableGrid,
+) -> () {
+    for x in 0..(grid.grid.width as i8) {
+        {
+            let p = Point { x, y: 0 };
+            if grid.is_cell_walkable(&p) {
+                exitable_cells.insert(p);
+            }
+        }
+        {
+            let p = Point {
+                x,
+                y: (grid.grid.height as i8) - 1,
+            };
+            if grid.is_cell_walkable(&p) {
+                exitable_cells.insert(p);
+            }
+        }
+    }
+    for y in 0..(grid.grid.height as i8) {
+        {
+            let p = Point { x: 0, y };
+            if grid.is_cell_walkable(&p) {
+                exitable_cells.insert(p);
+            }
+        }
+        {
+            let p = Point {
+                x: (grid.grid.width as i8) - 1,
+                y,
+            };
+            if grid.is_cell_walkable(&p) {
+                exitable_cells.insert(p);
+            }
+        }
+    }
+}
+
+pub fn propagate_exitable(exitable_cells: &mut HashSet<Point>, grid: &WalkableGrid) -> () {
+    let mut open_list: Vec<Point> = exitable_cells.iter().map(|p| p.clone()).collect();
+
+    while let Some(p) = open_list.pop() {
+        for dir in DIRECTIONS {
+            let u = Point {
+                x: p.x + dir.x,
+                y: p.y + dir.y,
+            };
+
+            if !exitable_cells.contains(&u) && grid.is_inside(&u) && grid.is_cell_walkable(&u) {
+                open_list.push(u);
+                exitable_cells.insert(u);
+            }
+        }
+    }
+}

packages/solver-r/src/grid.rs

@@ -1,3 +1,16 @@
+use std::collections::HashSet;
+
+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 };
+pub const DIRECTION_DOWN: Point = Point { x: 0, y: -1 };
+pub const DIRECTIONS: [Point; 4] = [
+    DIRECTION_RIGHT,
+    DIRECTION_LEFT,
+    DIRECTION_UP,
+    DIRECTION_DOWN,
+];
+
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct Point {
     pub x: i8,
@@ -47,7 +60,10 @@ impl Grid {
         self.cells[i] = value;
     }
     pub fn is_inside(&self, p: &Point) -> bool {
-        p.x >= 0 && p.x < (self.width as i8) && p.y >= 0 && p.y < (self.height as i8)
+        0 <= p.x && p.x < (self.width as i8) && 0 <= p.y && p.y < (self.height as i8)
+    }
+    pub fn is_inside_margin(&self, p: &Point, m: i8) -> bool {
+        -m <= p.x && p.x < (self.width as i8) + m && -m <= p.y && p.y < (self.height as i8) + m
     }
 }
 
@@ -68,22 +84,14 @@ impl WalkableGrid {
     pub fn is_inside(&self, p: &Point) -> bool {
         self.grid.is_inside(p)
     }
+    pub fn is_inside_margin(&self, p: &Point, margin: i8) -> bool {
+        self.grid.is_inside_margin(p, margin)
+    }
     pub fn get_cell(&self, p: &Point) -> Cell {
         self.grid.get_cell(p)
     }
 }
 
-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 };
-pub const DIRECTION_DOWN: Point = Point { x: 0, y: -1 };
-pub const DIRECTIONS: [Point; 4] = [
-    DIRECTION_RIGHT,
-    DIRECTION_LEFT,
-    DIRECTION_UP,
-    DIRECTION_DOWN,
-];
-
 #[test]
 fn it_should_sort_cell() {
     assert_eq!(Cell::Empty < Cell::Color1, true);

packages/solver-r/src/lib.rs

@@ -1,5 +1,6 @@
 mod astar;
 mod astar_snake;
+mod exitable;
 mod grid;
 mod snake;
 mod snake_compact;
@@ -10,6 +11,7 @@ use std::collections::HashSet;
 
 use astar::get_path;
 use astar_snake::get_snake_path;
+use exitable::{initiate_exitable_with_border, propagate_exitable};
 use grid::{Cell, Grid, Point, WalkableGrid};
 use js_sys;
 use log::info;
@@ -161,16 +163,10 @@ pub fn iastar(grid: &IGrid, start: IPoint, end: IPoint) -> Option<js_sys::Array>
 
 #[wasm_bindgen]
 pub fn iastar_snake(grid: &IGrid, start: ISnake, end: IPoint) -> Option<js_sys::Array> {
-    let g = Grid::from(grid.clone());
+    let grid = WalkableGrid::create(Grid::from(grid.clone()), Cell::Color1);
     let snake: Vec<Point> = start.iter().map(Point::from).collect();
     let res = get_snake_path(
-        |p| {
-            (!g.is_inside(p) || g.get_cell(p) <= Cell::Color1)
-                && (-3 <= p.x
-                    && p.x <= grid.width as i8 + 4
-                    && -3 <= p.y
-                    && p.y <= grid.height as i8 + 4)
-        },
+        |p| grid.is_cell_walkable(p) && grid.is_inside_margin(p, 4),
         &snake,
         &Point::from(end),
         200,
@@ -184,10 +180,12 @@ pub fn ieat_free_cells(grid: &IGrid, snake: ISnake) -> Vec<IPoint> {
     let grid = WalkableGrid::create(Grid::from(grid.clone()), Cell::Color1);
     let snake: Vec<Point> = snake.iter().map(Point::from).collect();
 
-    let (free_cells, _) = get_free_cells(&grid.grid, Cell::Color1);
+    let mut exitable_cells = HashSet::new();
+    initiate_exitable_with_border(&mut exitable_cells, &grid);
+    propagate_exitable(&mut exitable_cells, &grid);
 
     let cells_to_eat = {
-        let mut cells = free_cells.clone();
+        let mut cells = exitable_cells.clone();
         cells.retain(|p| grid.get_cell(p) == Cell::Color1);
         cells
     };
@@ -196,8 +194,9 @@ pub fn ieat_free_cells(grid: &IGrid, snake: ISnake) -> Vec<IPoint> {
     // to_eat.insert(Point { x: 6, y: 6 });
     // to_eat.insert(Point { x: 5, y: 0 });
 
-    // let path = get_path_to_eat_all(&grid, &snake, &to_eat);
-    let path = get_path_to_eat_all(&grid, &snake, &cells_to_eat);
+    let (path, unreachable) = get_path_to_eat_all(&grid, &snake, &cells_to_eat);
+
+    log::info!("unreachable {:?}", unreachable);
 
     path.iter().map(IPoint::from).collect()
 }