..

Author: Platane

cargo/snk-grid/src/direction.rs

@@ -18,6 +18,17 @@ pub const DIRECTIONS: [Direction; 4] = [
     Direction::RIGHT,
 ];
 
+impl Into<Point> for Direction {
+    fn into(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 },
+        }
+    }
+}
+
 impl Direction {
     pub fn to_point(&self) -> Point {
         match self {

cargo/snk-grid/src/grid_samples.rs

@@ -29,16 +29,18 @@ pub enum SampleGrid {
     Empty,
     OneDot,
     OneCave,
+    OneSmallCave,
     Caves,
     Realistic,
     Labyrinth,
     RandomPack,
     SolidBlock,
 }
-pub const SAMPLEGRIDS: [SampleGrid; 8] = [
+pub const SAMPLEGRIDS: [SampleGrid; 9] = [
     SampleGrid::Empty,
     SampleGrid::OneDot,
     SampleGrid::OneCave,
+    SampleGrid::OneSmallCave,
     SampleGrid::Caves,
     SampleGrid::Realistic,
     SampleGrid::Labyrinth,
@@ -73,6 +75,17 @@ _  ...  _
  .    . _
   ....  _
 
+"#,
+        ),
+
+        SampleGrid::OneSmallCave => Grid::<_>::from(
+            r#"
+_        _
+_  ###   _
+_  #.#   _
+_  ###   _
+_        _
+
 "#,
         ),
 

cargo/snk-grid/src/point.rs

@@ -1,9 +1,37 @@
+use std::ops::{Add, AddAssign};
+
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct Point {
     pub x: i8,
     pub y: i8,
 }
 
+impl Point {
+    pub fn new(x: i8, y: i8) -> Self {
+        Self { x, y }
+    }
+    pub fn zero() -> Self {
+        Self { x: 0, y: 0 }
+    }
+}
+
+impl Add for Point {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        Self {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        }
+    }
+}
+impl AddAssign for Point {
+    fn add_assign(&mut self, rhs: Self) {
+        self.x += rhs.x;
+        self.y += rhs.y;
+    }
+}
+
 pub fn add(a: Point, b: Point) -> Point {
     Point {
         x: a.x + b.x,

cargo/snk-solver/src/collect_cost.rs

@@ -1,14 +1,20 @@
 use snk_grid::{
     color::Color,
-    direction::{add_direction, iter_neighbour},
+    direction::{Direction, add_direction, iter_neighbour},
     grid::{Grid, iter_rectangle_hull},
+    grid_samples::{SampleGrid, get_grid_sample},
     point::Point,
+    snake::Snake4,
 };
 use std::collections::HashSet;
 
-use crate::{cost::Cost, path_to_outside_grid::ExitDirection};
+use crate::{
+    cost::Cost,
+    path_to_outside_grid::{ExitDirection, create_path_to_outside},
+};
 
-pub struct CollectionCost {
+pub struct Tunnel {
+    path: Vec<Point>,
     in_cost: Cost,
     out_cost: Cost,
 }
@@ -20,31 +26,84 @@ pub struct CollectionCost {
 // {
 // }
 
-pub fn get_collect_cost(
-    grid: &Grid<Color>,
-    exit_grid: &Grid<ExitDirection>,
-    dot: Point,
-) -> CollectionCost {
+pub fn get_collect_cost(grid: &Grid<Color>, exit_grid: &Grid<ExitDirection>, dot: Point) -> Tunnel {
     let in_cost = exit_grid.get(dot).cost;
 
     let mut grid = grid.clone();
 
+    let mut path_out_1 = Vec::new();
+
     let mut p = dot;
+
     loop {
-        let e = exit_grid.get(dot);
-        if e.cost.is_free() {
+        path_out_1.push(p);
+
+        let (dir, outside) = if exit_grid.is_inside(p) {
+            let e = exit_grid.get(p);
+            grid.set(p, Color::Empty);
+            (e.exit_direction, e.is_outside())
+        } else {
+            println!("{:?}", get_outside_direction(&grid, p));
+            (get_outside_direction(&grid, p), true)
+        };
+
+        if path_out_1.len() >= 6 && outside {
             break;
         }
-        grid.set(p, Color::Empty);
-        p = add_direction(p, e.exit_direction);
+
+        p += dir.into();
     }
 
+    println!("path_out_1 {:?}", path_out_1);
+
+    let path = path_out_1
+        .iter()
+        .take_while(|p| exit_grid.is_inside(**p) && !exit_grid.get(**p).is_outside())
+        .collect::<Vec<_>>();
+
+    println!("path {:?}", path);
+
+    let mut snake = Snake4::from_points(
+        path_out_1[0..4]
+            .try_into()
+            .expect("snake should be 4 points"),
+    );
+
+    println!("{:?}", snake);
+
     // TODO compute a probable initial snake
 
     // TODO from that snake, seak the outside without self-colliding
 
-    CollectionCost {
+    Tunnel {
+        path: path_out_1,
         in_cost,
         out_cost: Cost::zero(),
     }
 }
+
+fn get_outside_direction<T: Copy>(grid: &Grid<T>, p: Point) -> Direction {
+    if p.x < 0 {
+        Direction::LEFT
+    } else if p.y < 0 {
+        Direction::UP
+    } else if (p.x as u8) >= grid.width {
+        Direction::RIGHT
+    } else if (p.y as u8) >= grid.height {
+        Direction::DOWN
+    } else {
+        assert!(false, "fail here");
+        Direction::DOWN
+    }
+}
+
+#[test]
+#[ignore]
+fn it_should_compute_the_tunnel_for_small_cave() {
+    let grid = get_grid_sample(SampleGrid::OneSmallCave);
+    let pto = create_path_to_outside(&grid);
+
+    get_collect_cost(&grid, &pto, Point { x: 4, y: 2 });
+
+    assert!(false)
+}

cargo/snk-solver/src/lib.rs

@@ -5,4 +5,5 @@ mod cost;
 mod fitness;
 mod path_to_outside_grid;
 pub mod snake_path;
+mod snake_path_to_outside;
 pub mod solver;

cargo/snk-solver/src/path_to_outside_grid.rs

@@ -3,6 +3,7 @@ use snk_grid::{
     direction::{Direction, add_direction, iter_directions},
     grid::{Grid, iter_rectangle_hull},
     grid_ascii::grid_to_ascii_transformed,
+    grid_samples::{SampleGrid, get_grid_sample},
     point::Point,
 };
 use std::collections::HashSet;

cargo/snk-solver/src/snake_path_to_outside.rs

@@ -0,0 +1,120 @@
+use snk_grid::{
+    color::Color,
+    direction::{Direction, add_direction, iter_directions, iter_neighbour},
+    grid::{Grid, iter_rectangle_hull},
+    grid_samples::{SampleGrid, get_grid_sample},
+    point::Point,
+    snake::{Snake, Snake4, snake_will_self_collide},
+};
+use std::collections::{BinaryHeap, HashSet};
+
+use crate::{
+    cost::Cost,
+    path_to_outside_grid::{ExitDirection, create_path_to_outside},
+};
+
+#[derive(Clone, Debug)]
+struct Node {
+    pub snake: Snake4,
+    pub cost: Cost,
+    pub path: Vec<Direction>,
+}
+
+impl Eq for Node {}
+impl PartialEq for Node {
+    fn eq(&self, other: &Self) -> bool {
+        self.snake == other.snake
+    }
+}
+impl Ord for Node {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        other.cost.cmp(&self.cost)
+    }
+}
+impl PartialOrd for Node {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+pub fn get_snake_path_to_outside<FnOutside, FnCost>(
+    is_outside: FnOutside,
+    get_walk_cost: FnCost,
+    snake: &Snake4,
+) -> (Vec<Direction>, Cost)
+where
+    FnOutside: Fn(Point) -> bool,
+    FnCost: Fn(Point) -> Cost,
+{
+    let mut open_list: BinaryHeap<Node> = BinaryHeap::new();
+    let mut close_list: HashSet<Snake4> = HashSet::new();
+
+    open_list.push(Node {
+        snake: snake.clone(),
+        cost: Cost::zero(),
+        path: Vec::new(),
+    });
+
+    while let Some(node) = open_list.pop() {
+        let head = node.snake.get_head();
+        if is_outside(head) {
+            return (node.path, node.cost);
+        }
+
+        for dir in iter_directions() {
+            if snake_will_self_collide(&node.snake, dir) {
+                continue;
+            }
+
+            let snake = node.snake.clone_and_move(dir);
+
+            if close_list.contains(&snake) {
+                // need to update open_list
+                println!("need to update open_list");
+                continue;
+            }
+
+            let head = snake.get_head();
+
+            let cost = node.cost + get_walk_cost(head);
+            let mut path = node.path.clone();
+            path.push(dir);
+
+            open_list.push(Node { cost, path, snake });
+        }
+
+        close_list.insert(node.snake);
+    }
+
+    assert!(false, "should have terminated");
+    (vec![], Cost::zero())
+}
+
+#[test]
+fn it_should_get_snake_path_to_outside() {
+    let grid = Grid::<_>::from(
+        r#"
+_########  _
+_#    .  . _
+_#      # _
+_########  _
+
+"#,
+    );
+    let pto = create_path_to_outside(&grid);
+    let snake = Snake4::from_points([
+        Point { x: 2, y: 2 },
+        Point { x: 3, y: 2 },
+        Point { x: 4, y: 2 },
+        Point { x: 5, y: 2 },
+    ]);
+
+    let is_outside = |p| !pto.is_inside(p) || pto.get(p).is_outside();
+
+    let (path, cost) = get_snake_path_to_outside(is_outside, |p| grid.get_color(p).into(), &snake);
+
+    println!("{:?} {:?}", path, cost);
+    assert!(
+        cost < Cost::from(Color::Color2) * 2,
+        "should have taken the smallest path"
+    );
+}