.

Author: Platane

packages/solver-r/src/astar_snake.rs

@@ -5,6 +5,7 @@ use std::collections::{BinaryHeap, HashSet};
 
 struct Node {
     h: usize,
+    f: usize,
     path: Vec<Point>,
 }
 
@@ -16,9 +17,7 @@ impl PartialEq for Node {
 }
 impl Ord for Node {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        let f1 = self.h + self.path.len();
-        let f2 = other.h + other.path.len();
-        f1.cmp(&f2)
+        self.f.cmp(&other.f)
     }
 }
 impl PartialOrd for Node {
@@ -27,7 +26,12 @@ impl PartialOrd for Node {
     }
 }
 
-pub fn get_snake_path<F>(mut walkable: F, snake: &Snake, end: &Point) -> Option<Vec<Point>>
+pub fn get_snake_path<F>(
+    mut walkable: F,
+    snake: &[Point],
+    end: &Point,
+    max_weight: usize,
+) -> Option<Vec<Point>>
 where
     F: FnMut(&Point) -> bool,
 {
@@ -36,14 +40,22 @@ where
     let mut open_list = BinaryHeap::new();
     let mut close_list: HashSet<Vec<Point>> = HashSet::new();
 
-    open_list.push(Reverse(Node {
-        path: snake.clone(),
-        h: get_distance(&snake[0], &end) as usize,
+    open_list.push(Reverse({
+        let h = get_distance(&snake[0], &end) as usize;
+        Node {
+            path: snake.to_vec(),
+            h,
+            f: h,
+        }
     }));
 
     while let Some(n) = open_list.pop() {
         let node = n.0;
 
+        if node.f > max_weight {
+            return None;
+        }
+
         for dir in DIRECTIONS {
             let next_head = Point {
                 x: node.path[0].x + dir.x,
@@ -56,16 +68,16 @@ where
                 continue;
             }
 
+            if !walkable(&next_head) {
+                continue;
+            }
+
             if &next_head == end {
                 let mut path = node.path.clone();
                 path.insert(0, next_head);
                 return Some(path);
             }
 
-            if !walkable(&next_head) {
-                continue;
-            }
-
             let next_path = {
                 let mut path = node.path.clone();
                 path.insert(0, next_head);
@@ -78,9 +90,15 @@ where
                 continue;
             }
 
-            let h = get_distance(&next_head, &end) as usize;
-
-            open_list.push(Reverse(Node { path: next_path, h }));
+            open_list.push(Reverse({
+                let h = get_distance(&next_head, &end) as usize;
+                let f = h + next_path.len() - snake_length;
+                Node {
+                    path: next_path,
+                    h,
+                    f,
+                }
+            }));
         }
 
         let snake = {
@@ -102,6 +120,7 @@ fn it_should_find_path() {
         |_| true,
         &vec![Point { x: 0, y: 0 }, Point { x: -1, y: 0 }],
         &Point { x: 3, y: 0 },
+        10,
     );
 
     assert_eq!(
@@ -123,6 +142,7 @@ fn it_should_180_to_find_path() {
         |_| true,
         &vec![Point { x: 0, y: 0 }, Point { x: -1, y: 0 }],
         &Point { x: -2, y: 0 },
+        10,
     );
 
     assert_eq!(

packages/solver-r/src/grid.rs

@@ -52,18 +52,18 @@ impl Grid {
 }
 
 pub struct WalkableGrid {
-    grid: Grid,
-    wall: Cell,
+    pub grid: Grid,
+    walkable: Cell,
 }
 impl WalkableGrid {
-    pub fn create(grid: Grid, wall: Cell) -> WalkableGrid {
-        WalkableGrid { grid, wall }
+    pub fn create(grid: Grid, walkable: Cell) -> WalkableGrid {
+        WalkableGrid { grid, walkable }
     }
     pub fn is_cell_walkable(&self, p: &Point) -> bool {
-        !self.grid.is_inside(p) || self.grid.get_cell(p) < self.wall
+        !self.grid.is_inside(p) || self.grid.get_cell(p) <= self.walkable
     }
-    pub fn set_wall(&mut self, wall: Cell) -> () {
-        self.wall = wall;
+    pub fn set_walkable(&mut self, walkable: Cell) -> () {
+        self.walkable = walkable;
     }
     pub fn is_inside(&self, p: &Point) -> bool {
         self.grid.is_inside(p)

packages/solver-r/src/lib.rs

@@ -8,8 +8,9 @@ mod solver;
 
 use astar::get_path;
 use astar_snake::get_snake_path;
-use grid::{Cell, Grid, Point};
+use grid::{Cell, Grid, Point, WalkableGrid};
 use js_sys;
+use snake_walk::get_path_to_eat_all;
 use solver::get_free_cells;
 use wasm_bindgen::prelude::*;
 
@@ -90,6 +91,14 @@ impl From<Point> for IPoint {
         }
     }
 }
+impl From<&Point> for IPoint {
+    fn from(value: &Point) -> Self {
+        Self {
+            x: value.x,
+            y: value.y,
+        }
+    }
+}
 impl From<IPoint> for Point {
     fn from(value: IPoint) -> Self {
         Self {
@@ -141,6 +150,7 @@ 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 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)
@@ -149,9 +159,22 @@ pub fn iastar_snake(grid: &IGrid, start: ISnake, end: IPoint) -> Option<js_sys::
                     && -3 <= p.y
                     && p.y <= grid.height as i8 + 4)
         },
-        &start.iter().map(Point::from).collect(),
+        &snake,
         &Point::from(end),
+        200,
     );
 
     res.map(|l| l.into_iter().map(IPoint::from).map(JsValue::from).collect())
 }
+
+#[wasm_bindgen]
+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, out) = get_free_cells(&grid.grid, Cell::Color1);
+
+    let path = get_path_to_eat_all(&grid, &snake, free_cells);
+
+    path.iter().map(IPoint::from).collect()
+}