.

Author: Platane

packages/demo/demo.astar.ts

@@ -7,5 +7,6 @@
 	"getPathTo",
 	"svg",
 	"rust",
-	"astar"
+	"rust_astar",
+	"rust_astar_snake"
 ]

packages/demo/demo.json

@@ -7,7 +7,7 @@ import { grid } from "./sample";
 
 	const g = api.IGrid.create(grid.width, grid.height, grid.data);
 
-	const freeCells = api.iget_free_cell(g);
+	const freeCells = api.iget_free_cells(g);
 
 	{
 		const { canvas, draw, highlightCell } = createCanvas(g);

packages/demo/demo.rust.ts

@@ -1,4 +1,4 @@
-use crate::grid::{Point, DIRECTIONS};
+use crate::grid::{get_distance, Point, DIRECTIONS};
 use std::cmp::Reverse;
 use std::collections::{BinaryHeap, HashMap};
 
@@ -29,7 +29,7 @@ impl PartialOrd for Node {
 }
 
 fn get_heuristic(a: &Point, b: &Point) -> u8 {
-    (a.x - b.x).abs() as u8 + (a.y - b.y).abs() as u8
+    get_distance(a, b)
 }
 
 pub fn get_path<F>(mut walkable: F, start: &Point, end: &Point) -> Option<Vec<Point>>

packages/solver-r/src/astar.rs

@@ -3,6 +3,9 @@ pub struct Point {
     pub x: i8,
     pub y: i8,
 }
+pub fn get_distance(a: &Point, b: &Point) -> u8 {
+    (a.x - b.x).abs() as u8 + (a.y - b.y).abs() as u8
+}
 
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
 #[repr(u8)]
@@ -32,7 +35,7 @@ impl Grid {
         }
     }
 
-    pub fn get_index(&self, x: i8, y: i8) -> usize {
+    fn get_index(&self, x: i8, y: i8) -> usize {
         return (x as usize) * (self.height as usize) + (y as usize);
     }
     pub fn get_cell(&self, p: &Point) -> Cell {
@@ -48,6 +51,25 @@ impl Grid {
     }
 }
 
+pub struct WalkableGrid {
+    grid: Grid,
+    wall: Cell,
+}
+impl WalkableGrid {
+    pub fn create(grid: Grid, wall: Cell) -> WalkableGrid {
+        WalkableGrid { grid, wall }
+    }
+    pub fn is_cell_walkable(&self, p: &Point) -> bool {
+        !self.grid.is_inside(p) || self.grid.get_cell(p) < self.wall
+    }
+    pub fn set_wall(&mut self, wall: Cell) -> () {
+        self.wall = wall;
+    }
+    pub fn is_inside(&self, p: &Point) -> bool {
+        self.grid.is_inside(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 };

packages/solver-r/src/grid.rs

@@ -1,14 +1,16 @@
 mod astar;
+mod astar_snake;
 mod grid;
 mod snake;
 mod snake_compact;
 mod snake_walk;
 mod solver;
 
 use astar::get_path;
+use astar_snake::get_snake_path;
 use grid::{Cell, Grid, Point};
 use js_sys;
-use solver::get_free_cell;
+use solver::get_free_cells;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
@@ -96,12 +98,22 @@ impl From<IPoint> for Point {
         }
     }
 }
+impl From<&IPoint> for Point {
+    fn from(value: &IPoint) -> Self {
+        Self {
+            x: value.x,
+            y: value.y,
+        }
+    }
+}
+
+type ISnake = Vec<IPoint>;
 
 #[wasm_bindgen]
-pub fn iget_free_cell(grid: &IGrid) -> js_sys::Uint8Array {
+pub fn iget_free_cells(grid: &IGrid) -> js_sys::Uint8Array {
     let g = Grid::from(grid.clone());
 
-    let (_, out) = get_free_cell(&g, Cell::Color1);
+    let (_, out) = get_free_cells(&g, Cell::Color1);
 
     let o: Vec<u8> = out.iter().flat_map(|p| [p.x as u8, p.y as u8]).collect();
 
@@ -125,3 +137,21 @@ pub fn iastar(grid: &IGrid, start: IPoint, end: IPoint) -> Option<js_sys::Array>
 
     res.map(|l| l.into_iter().map(IPoint::from).map(JsValue::from).collect())
 }
+
+#[wasm_bindgen]
+pub fn iastar_snake(grid: &IGrid, start: ISnake, end: IPoint) -> Option<js_sys::Array> {
+    let g = Grid::from(grid.clone());
+    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)
+        },
+        &start.iter().map(Point::from).collect(),
+        &Point::from(end),
+    );
+
+    res.map(|l| l.into_iter().map(IPoint::from).map(JsValue::from).collect())
+}

packages/solver-r/src/lib.rs

@@ -11,18 +11,15 @@ pub fn move_snake(s: &mut Snake, dir: &Point) -> () {
     e.y = s[0].y + dir.y;
     s.insert(0, e);
 }
-pub fn snake_will_self_collide(s: &Snake, dir: &Point) -> bool {
-    let next_head = Point {
-        x: s[0].x + dir.x,
-        y: s[0].y + dir.y,
-    };
+pub fn snake_will_self_collide(s: &[Point], dir: &Point) -> bool {
+    let next_head = get_next_snake_head(s, dir);
 
     (&s[0..(s.len() - 1)]).contains(&next_head)
 }
-pub fn get_snake_head(s: &Snake) -> Point {
+pub fn get_snake_head(s: &[Point]) -> Point {
     s[0]
 }
-pub fn get_next_snake_head(s: &Snake, dir: &Point) -> Point {
+pub fn get_next_snake_head(s: &[Point], dir: &Point) -> Point {
     Point {
         x: s[0].x + dir.x,
         y: s[0].y + dir.y,

packages/solver-r/src/snake.rs

@@ -1,65 +1,135 @@
 use std::collections::HashSet;
 
 use crate::astar::get_path;
-use crate::grid::{Cell, Grid, Point, DIRECTIONS};
+use crate::grid::{get_distance, Cell, Grid, Point, WalkableGrid, DIRECTIONS};
 use crate::snake::{
     get_next_snake_head, get_snake_head, move_snake, snake_will_self_collide, Snake,
 };
 
 struct Node {
-    point: Point,
-    weight: u8,
-    h: u8,
-    parent: Option<Point>,
+    cells_eaten: u8,
+    path: Vec<Point>,
+}
+
+pub fn can_snake_reach_outside(
+    grid: &WalkableGrid,
+    free_cells: &HashSet<Point>,
+    snake: &Snake,
+) -> bool {
+    let mut open_list: Vec<Snake> = Vec::new();
+    open_list.push(snake.clone());
+
+    let mut close_list: HashSet<Snake> = HashSet::new();
+
+    while let Some(s) = open_list.pop() {
+        for dir in DIRECTIONS {
+            if snake_will_self_collide(&s, &dir) {
+                continue;
+            }
+
+            let next_head = get_next_snake_head(&s, &dir);
+
+            if !grid.is_inside(&next_head) {
+                return true;
+            }
+
+            if !free_cells.contains(&next_head) {
+                continue;
+            }
+
+            let mut next_snake = s.clone();
+            move_snake(&mut next_snake, &dir);
+
+            if close_list.contains(&next_snake) {
+                continue;
+            }
+
+            open_list.push(next_snake);
+        }
+
+        close_list.insert(s);
+    }
+
+    false
 }
 
 pub fn get_route_to_eat_all(
-    grid: &Grid,
-    walkable: Cell,
+    grid: &WalkableGrid,
+    free_cells: &HashSet<Point>,
     initial_snake: &Snake,
-    cells_to_eat: HashSet<Point>,
+    cells_to_eat: Vec<Point>,
 ) -> Vec<Point> {
-    // let mut targets: Vec<Point> = cells_to_eat.iter().map(|p| p.clone()).collect();
+    // element 0 is the snake head
+    let mut path: Vec<Point> = Vec::new();
+
+    // path.append(&mut initial_snake.clone());
+
+    // while true {
+    //     let head = path[0];
+
+    //     let forbidden_direction = Point {
+    //         x: path[1].x - head.x,
+    //         y: path[1].y - head.y,
+    //     };
+
+    //     // get best route to best target
+    //     let route = vec![];
+    // }
+
+    path
+}
+
+/*
+* snake astar
+*/
 
-    // let open_list = get_path(|p|);
+pub fn get_route_to_cell(grid: &WalkableGrid, snake: &Snake, target: &Point) -> Vec<Point> {
+    let mut open_list: Vec<Node> = Vec::new();
+
+    vec![]
+}
 
-    let mut targets: Vec<&Point> = cells_to_eat.iter().collect();
+pub fn get_route_to_eat_all_2(
+    grid: &WalkableGrid,
+    free_cells: &HashSet<Point>,
+    initial_snake: &Snake,
+    cells_to_eat: Vec<Point>,
+) -> Vec<Point> {
+    let mut open_list: Vec<Node> = Vec::new();
 
     let mut path: Vec<Point> = Vec::new();
 
     let mut initial_snake = initial_snake.clone();
 
-    while let Some(target) = targets.pop() {
-        // prepare
-        let mut open_list: HashSet<(Snake, Vec<Point>)> = HashSet::new();
-        open_list.insert((initial_snake.clone(), Vec::new()));
+    open_list.push(Node {
+        cells_eaten: 0,
+        path: {
+            let mut initial_path = initial_snake.clone();
+            initial_path.reverse();
+            initial_path
+        },
+    });
 
-        while let Some(x) = open_list.iter().next().cloned() {
-            open_list.remove(&x);
+    while let Some(n) = open_list.pop() {
+        // determine next target
 
-            let snake = x.0;
-            let mut sub_path = x.1;
-
-            if get_snake_head(&snake) == *target {
-                path.append(&mut sub_path);
-                initial_snake = snake;
-                break;
+        let mut best_target = None;
+        let mut min_score: u8 = 200;
+        for t in cells_to_eat.iter() {
+            // if already visited ignore
+            if n.path.contains(t) {
+                continue;
             }
 
-            for dir in DIRECTIONS {
-                if {
-                    let h = get_next_snake_head(&snake, &dir);
-                    grid.get_cell(&h) <= walkable
-                } && !snake_will_self_collide(&snake, &dir)
-                {
-                    let mut next_snake = snake.clone();
-                    move_snake(&mut next_snake, &dir);
+            let head = n.path.last().unwrap();
+
+            let distance = get_distance(head, t);
 
-                    let mut next_sub_path = sub_path.clone();
-                    next_sub_path.push(dir.clone());
+            let score = distance;
 
-                    open_list.insert((next_snake, next_sub_path));
-                }
+            if score < min_score {
+                min_score = score;
+                best_target = Some(t);
             }
         }
     }

packages/solver-r/src/snake_walk.rs

@@ -2,7 +2,7 @@ use std::collections::HashSet;
 
 use crate::grid::{Cell, Grid, Point};
 
-pub fn get_free_cell(grid: &Grid, walkable: Cell) -> (HashSet<Point>, HashSet<Point>) {
+pub fn get_free_cells(grid: &Grid, walkable: Cell) -> (HashSet<Point>, HashSet<Point>) {
     let mut free_cells: HashSet<Point> = HashSet::new();
     let mut one_way_cells: HashSet<Point> = HashSet::new();
     let mut open_list: HashSet<Point> = HashSet::new();
@@ -113,7 +113,7 @@ fn it_should_collect_free_cell() {
 
     grid.set_cell(&Point { x: 1, y: 1 }, Cell::Color2);
 
-    let (free_cells, _) = get_free_cell(&grid, Cell::Color1);
+    let (free_cells, _) = get_free_cells(&grid, Cell::Color1);
 
     assert_eq!(
         free_cells,

packages/solver-r/src/solver.rs

@@ -107,3 +107,4 @@ export const smallFull = createRandom(10, 7, 0);
 // small realistic
 export const realistic = createRandom(52, 7, 3);
 export const realisticFull = createRandom(52, 7, 0);
+