/

Author: Platane

cargo/Cargo.lock

@@ -0,0 +1,18 @@
+[workspace]
+resolver = "3"
+
+members = [
+"snk-js",
+"snk-grid",
+# "snk-solver",
+# "snk-gif-creator"
+]
+
+[workspace.package]
+version = "1.0.0"
+edition = "2024"
+authors = ["platane"]
+
+[workspace.dependencies]
+snk-grid = { path = "snk-grid" }
+snk-solver = { path = "snk-solver" }

cargo/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "snk-grid"
+
+version.workspace = true
+edition.workspace = true
+authors.workspace = true

cargo/snk-grid/Cargo.toml

@@ -0,0 +1,70 @@
+use crate::point::{Point, add};
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+#[repr(u8)]
+pub enum Direction {
+    UP,
+    DOWN,
+    LEFT,
+    RIGHT,
+}
+
+pub const DIRECTIONS: [Direction; 4] = [
+    Direction::UP,
+    Direction::DOWN,
+    Direction::LEFT,
+    Direction::RIGHT,
+];
+
+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::LEFT => Point { x: -1, y: 0 },
+            Direction::RIGHT => Point { x: 1, y: 0 },
+        }
+    }
+}
+
+pub fn add_direction(a: Point, dir: Direction) -> Point {
+    add(a, dir.to_point())
+}
+
+pub fn iter_directions() -> impl Iterator<Item = Direction> {
+    DIRECTIONS.iter().map(|dir| dir.clone())
+}
+
+pub fn iter_neighbour(p: Point) -> impl Iterator<Item = Point> {
+    iter_directions().map(move |dir| add_direction(p, dir))
+}
+
+#[test]
+fn it_should_iter_direction() {
+    let directions: Vec<_> = iter_directions().collect();
+
+    assert_eq!(
+        directions,
+        vec![
+            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();
+
+    assert_eq!(
+        directions,
+        vec![
+            Point { x: 0, y: 1 },
+            Point { x: 0, y: -1 },
+            Point { x: -1, y: 0 },
+            Point { x: 1, y: 0 }
+        ]
+    );
+}

cargo/snk-grid/src/direction.rs

@@ -0,0 +1,150 @@
+use crate::point::Point;
+
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+#[repr(u8)]
+pub enum Color {
+    Empty = 0,
+    Color1 = 1,
+    Color2 = 2,
+    Color3 = 3,
+    Color4 = 4,
+}
+impl Default for Color {
+    fn default() -> Self {
+        Color::Empty
+    }
+}
+
+pub fn iter_rectangle_fill(width: i8, height: i8) -> impl Iterator<Item = Point> {
+    (0..height).flat_map(move |y| (0..width).map(move |x| Point { x, y }))
+}
+pub fn iter_rectangle_hull(width: i8, height: i8) -> impl Iterator<Item = Point> {
+    (1..(width - 1))
+        .map(|x| Point { x, y: 0 })
+        .chain((1..(width - 1)).map(move |x| Point { x, y: height - 1 }))
+        .chain((0..height).map(move |y| Point { x: 0, y }))
+        .chain((0..height).map(move |y| Point { x: width - 1, y }))
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Grid<T: Copy> {
+    pub width: u8,
+    pub height: u8,
+    pub cells: Vec<T>,
+}
+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) -> () {
+        self.cells.fill(value);
+    }
+    pub fn get(&self, p: Point) -> T {
+        let i = self.get_index(p.x, p.y);
+        return self.cells[i];
+    }
+    pub fn set(&mut self, p: Point, value: T) -> () {
+        let i = self.get_index(p.x, p.y);
+        self.cells[i] = value;
+    }
+    pub fn is_inside(&self, p: Point) -> bool {
+        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
+    }
+
+    /// ⚠️ assuming the point is inside the grid
+    pub fn distance_from_outside(&self, p: Point) -> u8 {
+        let x = p.x as u8;
+        let y = p.y as u8;
+        y.min(self.height - 1 - y).min(x).min(self.width - 1 - x)
+    }
+
+    pub fn create_with_value(width: u8, height: u8, value: T) -> Grid<T> {
+        let n = (width as usize) * (height as usize);
+        let cells = (0..n).map(|_| value).collect();
+
+        Grid {
+            width,
+            height,
+            cells,
+        }
+    }
+}
+impl<T: Default + Copy> Grid<T> {
+    pub fn create_with_default(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 Grid<Color> {
+    pub fn is_walkable(&self, walkable: Color, p: Point) -> bool {
+        !self.is_inside(p) || self.get(p) <= walkable
+    }
+}
+
+#[test]
+fn it_should_sort_cell() {
+    assert_eq!(Color::Empty < Color::Color1, true);
+    assert_eq!(Color::Color1 < Color::Color2, true);
+    assert_eq!(Color::Color2 < Color::Color3, true);
+    assert_eq!(Color::Color3 < Color::Color4, true);
+}
+#[test]
+fn it_should_grid_create() {
+    let grid = Grid::<Color>::create_with_default(30, 10);
+
+    assert_eq!(grid.width, 30);
+    assert_eq!(grid.height, 10);
+    assert_eq!(grid.get(Point { x: 2, y: 3 }), Color::Empty);
+}
+#[test]
+fn it_should_grid_setter() {
+    let mut grid = Grid::<Color>::create_with_default(20, 10);
+
+    grid.set(Point { x: 12, y: 3 }, Color::Color1);
+
+    assert_eq!(grid.get(Point { x: 12, y: 3 }), Color::Color1);
+}
+#[test]
+fn it_should_iterate() {
+    assert_eq!(
+        iter_rectangle_fill(2, 2).collect::<std::collections::HashSet<_>>(),
+        std::collections::HashSet::from([
+            Point { x: 0, y: 0 },
+            Point { x: 0, y: 1 },
+            Point { x: 1, y: 0 },
+            Point { x: 1, y: 1 },
+        ])
+    );
+}
+
+#[test]
+fn it_should_iterate_hull() {
+    assert_eq!(
+        iter_rectangle_hull(3, 3).collect::<std::collections::HashSet<_>>(),
+        std::collections::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 },
+        ])
+    );
+}