mazecetric, random one

src/rules.rs

@@ -1,3 +1,5 @@
+use rand::Rng;
+
 pub struct Rules<TState, TKernel, const KERNEL_SIZE: usize>
     where TState: Copy + PartialEq, TKernel: Copy
 {
@@ -12,12 +14,36 @@ pub const MOORE_NEIGHBORHOOD: [[bool; 3]; 3] = [
     [true, true, true]
 ];
 
+pub const NEUMANN_NEIGHBORHOOD: [[bool; 3]; 3] = [
+    [false, true, false],
+    [true, false, true],
+    [false, true, false]
+];
+
+pub const DIAGONALS_NEIGHBORHOOD: [[bool; 3]; 3] = [
+    [true, false, true],
+    [false, true, false],
+    [true, false, true]
+];
+
 pub fn count_true_neighbor(neighbor_state: bool, kernel_value: bool) -> i32
 {
     if neighbor_state && kernel_value { 1 } else { 0 }
 }
 
 impl Rules<bool, bool, 3> {
+    #[must_use]
+    pub fn random_bb3() -> Self {
+        match rand::thread_rng().gen_range(0..=4) {
+            0 => Self::game_of_life(),
+            1 => Self::high_life(),
+            2 => Self::seeds(),
+            3 => Self::day_and_night(),
+            4 => Self::mazecetric(),
+            _ => panic!(),
+        }
+    }
+
     #[must_use]
     pub fn game_of_life() -> Self {
         Self {
@@ -69,9 +95,35 @@ impl Rules<bool, bool, 3> {
             },
         }
     }
+
+    #[must_use]
+    pub fn mazecetric() -> Self {
+        Self {
+            kernel: MOORE_NEIGHBORHOOD,
+            count_neighbor: count_true_neighbor,
+            next_state: |state, neighbors| {
+                match (state, neighbors) {
+                    (false, 3) => true,
+                    (true, 0) => false,
+                    (true, n) if n < 5 => true,
+                    _ => false,
+                }
+            },
+        }
+    }
 }
 
 impl Rules<u8, bool, 3> {
+    #[must_use]
+    pub fn random_u8b3() -> Self {
+        match rand::thread_rng().gen_range(0..3) {
+            0 => Self::brians_brain(),
+            1 => Self::continuous_game_of_life(),
+            2 => Self::equalizer(),
+            _ => panic!(),
+        }
+    }
+
     #[must_use]
     pub fn brians_brain() -> Self {
         const ALIVE: u8 = u8::MAX;
@@ -98,6 +150,8 @@ impl Rules<u8, bool, 3> {
         }
     }
 
+
+    #[must_use]
     pub fn continuous_game_of_life() -> Self {
         Self {
             kernel: MOORE_NEIGHBORHOOD,
@@ -115,5 +169,38 @@ impl Rules<u8, bool, 3> {
             },
         }
     }
+
+    #[must_use]
+    pub fn equalizer() -> Self {
+        Self {
+            kernel: DIAGONALS_NEIGHBORHOOD,
+            count_neighbor: |state, kernel| {
+                let state = state as i32;
+                if kernel {
+                    state
+                } else {
+                    0
+                }
+            },
+            next_state: |old_state, neighbors| {
+                if old_state % 42 == 0 {
+                    return u8::MAX;
+                }
+
+                if old_state % 23 == 0 {
+                    return u8::MIN;
+                }
+
+                let average_health = neighbors / 5;
+                let delta = if average_health > old_state as i32 {
+                    10
+                } else {
+                    -10
+                };
+
+                i32::clamp(old_state as i32 + delta, u8::MIN as i32, u8::MAX as i32) as u8
+            },
+        }
+    }
 }