cost

Author: Platane

.github/workflows/main.yml

@@ -18,7 +18,7 @@ jobs:
 
       - run: bun install --frozen-lockfile
 
-      - run: cargo test
+      - run: cargo nextest run
         working-directory: cargo
 
       - run: cargo fmt --check

cargo/snk-grid/src/color.rs

@@ -19,15 +19,6 @@ impl Color {
     pub fn is_empty(&self) -> bool {
         *self == Color::Empty
     }
-    pub fn cost(&self) -> u32 {
-        match self {
-            Color::Empty => 0,
-            Color::Color1 => 1,
-            Color::Color2 => 128,
-            Color::Color3 => 128 * 128,
-            Color::Color4 => 128 * 128 * 128,
-        }
-    }
 }
 
 #[test]
@@ -37,8 +28,3 @@ fn it_should_sort_cell() {
     assert_eq!(Color::Color2 < Color::Color3, true);
     assert_eq!(Color::Color3 < Color::Color4, true);
 }
-#[test]
-fn it_should_sum_cost() {
-    // it should not panic
-    let _somehow_max_cost = Color::Color4.cost() * 350;
-}

cargo/snk-grid/src/grid_ascii.rs

@@ -24,15 +24,18 @@ pub fn grid_from_ascii<T: Copy + Default + From<char>>(ascii: &str) -> Grid<T> {
     grid
 }
 
-pub fn grid_to_ascii<T: Copy + ToString>(grid: &Grid<T>) -> String {
+pub fn grid_to_ascii_transformed<T: Copy, F>(grid: &Grid<T>, to_string: F) -> String
+where
+    F: Fn(T) -> String,
+{
     let mut out: String = String::new();
     for y in 0..grid.height {
         for x in 0..grid.width {
             let value = grid.get(Point {
                 x: x as i8,
                 y: y as i8,
             });
-            out.push(value.to_string().chars().nth(0).unwrap());
+            out.push(to_string(value).chars().nth(0).unwrap());
         }
         if match out.chars().last() {
             Some(c) => c == ' ',
@@ -48,6 +51,10 @@ pub fn grid_to_ascii<T: Copy + ToString>(grid: &Grid<T>) -> String {
     out
 }
 
+pub fn grid_to_ascii<T: Copy + ToString>(grid: &Grid<T>) -> String {
+    grid_to_ascii_transformed(grid, |value| value.to_string())
+}
+
 impl<T: ToString + Copy> ToString for Grid<T> {
     fn to_string(&self) -> String {
         grid_to_ascii(self)

cargo/snk-solver/src/collect_cost.rs

@@ -6,11 +6,11 @@ use snk_grid::{
 };
 use std::collections::HashSet;
 
-use crate::path_to_outside_grid::ExitDirection;
+use crate::{cost::Cost, path_to_outside_grid::ExitDirection};
 
 pub struct CollectionCost {
-    in_cost: u32,
-    out_cost: u32,
+    in_cost: Cost,
+    out_cost: Cost,
 }
 
 // pub fn get_collect_cost_(is_outside: F, get_cost: C) -> CollectionCost
@@ -32,7 +32,7 @@ pub fn get_collect_cost(
     let mut p = dot;
     loop {
         let e = exit_grid.get(dot);
-        if e.cost == 0 {
+        if e.cost.is_free() {
             break;
         }
         grid.set(p, Color::Empty);
@@ -45,6 +45,6 @@ pub fn get_collect_cost(
 
     CollectionCost {
         in_cost,
-        out_cost: 0,
+        out_cost: Cost::zero(),
     }
 }

cargo/snk-solver/src/cost.rs

@@ -0,0 +1,64 @@
+use std::ops::{Add, AddAssign, Mul};
+
+use snk_grid::color::Color;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Cost(pub u64);
+
+impl Add for Cost {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        Self(self.0 + rhs.0)
+    }
+}
+impl AddAssign for Cost {
+    fn add_assign(&mut self, rhs: Self) {
+        self.0 += rhs.0;
+    }
+}
+impl Mul<u64> for Cost {
+    type Output = Self;
+
+    fn mul(self, rhs: u64) -> Self {
+        Self(self.0 * rhs)
+    }
+}
+
+impl From<Color> for Cost {
+    fn from(color: Color) -> Self {
+        match color {
+            Color::Empty => Cost(1),
+            Color::Color1 => Cost(256),
+            Color::Color2 => Cost(256 * 200),
+            Color::Color3 => Cost(256 * 200 * 200),
+            Color::Color4 => Cost(256 * 200 * 200 * 200),
+        }
+    }
+}
+
+impl Cost {
+    pub fn zero() -> Self {
+        Self(0)
+    }
+    pub fn max() -> Self {
+        Self(u64::MAX)
+    }
+    pub fn is_free(&self) -> bool {
+        self.0 < 256
+    }
+}
+
+#[test]
+fn it_should_not_overflow() {
+    // it should not panic
+    let very_large_cost = Cost::from(Color::Color4) * 256;
+    assert!(very_large_cost < Cost::max())
+}
+
+#[test]
+fn it_should_sum_cost() {
+    let mut c = Cost::zero();
+    c = c + Color::Color1.into();
+    assert!(Cost::zero() < c);
+}

cargo/snk-solver/src/cost_to_outside.rs

@@ -1,7 +1,7 @@
 // pub mod cave;
 // pub mod reach_outside;
 mod collect_cost;
-pub mod cost_to_outside;
+mod cost;
 mod fitness;
 mod path_to_outside_grid;
 pub mod snake_path;

cargo/snk-solver/src/lib.rs

@@ -2,27 +2,21 @@ use snk_grid::{
     color::Color,
     direction::{Direction, add_direction, iter_directions},
     grid::{Grid, iter_rectangle_hull},
+    grid_ascii::grid_to_ascii_transformed,
     point::Point,
 };
 use std::collections::HashSet;
 
+use crate::cost::Cost;
+
 #[derive(Copy, Clone)]
 pub struct ExitDirection {
-    pub cost: u32,
+    pub cost: Cost,
     pub exit_direction: Direction,
 }
 impl ExitDirection {
     pub fn is_outside(&self) -> bool {
-        self.cost == 0
-    }
-}
-impl ToString for ExitDirection {
-    fn to_string(&self) -> String {
-        if self.cost == 0 {
-            "o".to_string()
-        } else {
-            self.exit_direction.to_string()
-        }
+        self.cost.is_free()
     }
 }
 
@@ -33,7 +27,7 @@ pub fn create_path_to_outside(grid: &Grid<Color>) -> Grid<ExitDirection> {
         grid.width,
         grid.height,
         ExitDirection {
-            cost: u32::MAX,
+            cost: Cost::max(),
             exit_direction: Direction::UP,
         },
     );
@@ -53,16 +47,16 @@ pub fn create_path_to_outside(grid: &Grid<Color>) -> Grid<ExitDirection> {
     } {
         changed.remove(&p);
 
-        let cost = if path_to_outside.is_inside(p) {
+        let cost: Cost = if path_to_outside.is_inside(p) {
             path_to_outside.get(p).cost
         } else {
-            0
+            Cost::zero()
         };
 
         for dir in iter_directions() {
             let p = add_direction(p, dir);
             if path_to_outside.is_inside(p) {
-                let new_cost = cost + grid.get(p).cost();
+                let new_cost = cost + grid.get(p).into();
 
                 let c = path_to_outside.get_mut(p);
 
@@ -79,25 +73,30 @@ pub fn create_path_to_outside(grid: &Grid<Color>) -> Grid<ExitDirection> {
 }
 
 #[test]
-#[ignore]
 fn it_should_compute_the_cost_to_outside() {
     let grid = Grid::<_>::from(
         r#"
 _...._
-_. .._
-_...._
-_...._
+_.  ._
+_.. ._
+_.   _
 "#,
     );
     let pto = create_path_to_outside(&grid);
 
     assert_eq!(
-        pto.to_string(),
+        grid_to_ascii_transformed(&pto, |c| {
+            if c.cost.is_free() {
+                c.cost.0.to_string()
+            } else {
+                "#".to_string()
+            }
+        }),
         r#"
-o↑↑↑→o
-o←←→→o
-o←↑↓→o
-o←↓↓→o
+1####1
+1#43#1
+1##2#1
+1#1111
 "#
         .trim(),
     );