.

Author: Platane

cargo/snk-grid/src/grid.rs

@@ -22,6 +22,9 @@ impl<T: Copy> Grid<T> {
         return (x as usize) * (self.height as usize) + (y as usize);
     }
 
+    pub fn copy(&mut self, other: &Self) -> () {
+        self.cells.clone_from_slice(&other.cells);
+    }
     pub fn fill(&mut self, value: T) -> () {
         self.cells.fill(value);
     }

cargo/snk-js/src/lib.rs

@@ -54,7 +54,7 @@ pub fn get_best_tunnel_to_collect_point(grid: &IColorGrid, to: &IPoint) -> Vec<I
     let grid = snk_grid::grid::Grid::from(grid);
     let exit_grid = snk_solver::exit_grid::ExitGrid::create_from_grid_color(&grid);
     let res =
-        snk_solver::collect_cost::get_best_tunnel_to_collect_point(&grid, &exit_grid, to.into());
+        snk_solver::best_tunnel::get_best_tunnel_to_collect_point(&grid, &exit_grid, to.into());
 
     log::info!("{:?} {:?} {:?}", res.path, res.in_cost, res.out_cost);
 

cargo/snk-solver/src/collect_cost.rs cargo/snk-solver/src/best_tunnel.rscargo/snk-solver/src/collect_cost.rs renamed to cargo/snk-solver/src/best_tunnel.rs

@@ -1,4 +1,6 @@
-use snk_grid::{color::Color, grid::Grid, point::Point, snake::Snake4};
+use snk_grid::{
+    color::Color, grid::Grid, grid_samples::get_grid_sample, point::Point, snake::Snake4,
+};
 
 use crate::{cost::Cost, exit_grid::ExitGrid, snake_path_to_outside::get_snake_path_to_outside};
 
@@ -9,13 +11,8 @@ pub struct Tunnel {
     pub out_cost: Cost,
 }
 
-// pub fn get_collect_cost_(is_outside: F, get_cost: C) -> CollectionCost
-// where
-//     F: Fn(Point) -> bool,
-//     F: Fn(Point) -> u32,
-// {
-// }
-
+///
+/// it's not accurate and might report worse tunnel
 pub fn get_best_tunnel_to_collect_point(
     grid: &Grid<Color>,
     exit_grid: &ExitGrid,
@@ -149,9 +146,29 @@ _           _
 
     assert_eq!(grid.get_color(Point { x: 6, y: 3 }), Color::Color1);
 
-    let pto = ExitGrid::create_from_grid_color(&grid);
+    let exit_grid = ExitGrid::create_from_grid_color(&grid);
+
+    let tunnel = get_best_tunnel_to_collect_point(&grid, &exit_grid, Point { x: 6, y: 3 });
+    assert_eq!(tunnel.in_cost.get_color_count(Color::Color4), 1);
+    assert_eq!(tunnel.out_cost.get_color_count(Color::Color4), 0);
+
+    assert_eq!(tunnel.in_cost.get_color_count(Color::Color1), 1);
+    assert_eq!(tunnel.out_cost.get_color_count(Color::Color1), 0);
+}
+
+#[test]
+fn it_should_get_snake_path_to_outside_3() {
+    let grid = get_grid_sample(snk_grid::grid_samples::SampleGrid::Caves);
+
+    assert_eq!(grid.get_color(Point { x: 29, y: 3 }), Color::Empty);
+    assert_eq!(grid.get_color(Point { x: 29, y: 4 }), Color::Color4);
+
+    let exit_grid = ExitGrid::create_from_grid_color(&grid);
+
+    let tunnel = get_best_tunnel_to_collect_point(&grid, &exit_grid, Point { x: 29, y: 3 });
+
+    println!("{:?}", tunnel);
 
-    let tunnel = get_best_tunnel_to_collect_point(&grid, &pto, Point { x: 6, y: 3 });
     assert_eq!(tunnel.in_cost.get_color_count(Color::Color4), 1);
     assert_eq!(tunnel.out_cost.get_color_count(Color::Color4), 0);
 

cargo/snk-solver/src/cost.rs

@@ -50,6 +50,9 @@ impl Cost {
     pub fn is_free(&self) -> bool {
         self.0 < 256
     }
+    pub fn set_empty_to_zero(&self) -> Self {
+        Self((self.0 / 256) * 256)
+    }
 
     // return the count for the given color
     pub fn get_color_count(&self, color: Color) -> u64 {

cargo/snk-solver/src/lib.rs

@@ -1,6 +1,6 @@
 // pub mod cave;
 // pub mod reach_outside;
-pub mod collect_cost;
+pub mod best_tunnel;
 mod cost;
 pub mod exit_grid;
 mod fitness;

cargo/snk-solver/src/snake_path_to_outside.rs

@@ -86,7 +86,9 @@ where
 mod tests {
     use super::*;
 
-    use snk_grid::{color::Color, grid::Grid, point::Point, snake::Snake4};
+    use snk_grid::{
+        color::Color, grid::Grid, grid_samples::get_grid_sample, point::Point, snake::Snake4,
+    };
 
     use crate::exit_grid::ExitGrid;
 

cargo/snk-solver/src/solver.rs

@@ -1,7 +1,47 @@
-use snk_grid::{color::Color, direction::Direction, grid::Grid, snake::Snake4};
+use std::collections::HashMap;
 
-pub fn solve(grid: &Grid<Color>, snake: &Snake4) -> Vec<Direction> {
-    vec![]
+use snk_grid::{
+    color::Color,
+    direction::Direction,
+    grid::{Grid, iter_rectangle_fill},
+    point::Point,
+    snake::Snake4,
+};
+
+use crate::{
+    best_tunnel::{Tunnel, get_best_tunnel_to_collect_point},
+    cost::Cost,
+    exit_grid::ExitGrid,
+};
+
+pub const COLORS: [Color; 4] = [Color::Color1, Color::Color2, Color::Color3, Color::Color4];
+
+pub fn solve(color_grid: &Grid<Color>, snake: &Snake4) -> Vec<Direction> {
+    let exit_grid = ExitGrid::create_from_grid_color(color_grid);
+
+    let snake = snake.clone();
+    let path = Vec::new();
+
+    for color in COLORS.into_iter() {
+        let to_collect = iter_rectangle_fill(color_grid.width, color_grid.height)
+            .filter(|p| color_grid.get_color(*p) == color)
+            .map(|p| {
+                let tunnel = get_best_tunnel_to_collect_point(&color_grid, &exit_grid, p);
+                let score = tunnel.in_cost.set_empty_to_zero() * 2
+                    + tunnel.out_cost.set_empty_to_zero() * 3;
+                (p, tunnel, score, exit_grid.get_cost_to_outside(p))
+            });
+
+        let (free_to_collect, mut rest): (Vec<_>, Vec<_>) =
+            to_collect.partition(|(_, _, global_cost,_)| global_cost.is_free());
+
+        // todo!("collect free points");
+
+        rest.sort_by(|a, b| a.2.cmp(&b.2));
+
+    }
+
+    path
 }
 
 #[cfg(test)]