make random rules prettier
This commit is contained in:
Vinzenz Schroeter
parent
b8eda9f316
commit
7da0730fab
1 changed files with 72 additions and 274 deletions
285
src/rules.rs
285
src/rules.rs
|
|
@ -1,5 +1,3 @@
|
|||
use std::collections::HashSet;
|
||||
|
||||
use rand::{Rng, thread_rng};
|
||||
use rand::rngs::ThreadRng;
|
||||
|
||||
|
|
@ -9,7 +7,7 @@ pub struct Rules<TState, TKernel, const KERNEL_SIZE: usize>
|
|||
where TState: Copy + PartialEq, TKernel: Copy
|
||||
{
|
||||
pub kernel: [[TKernel; KERNEL_SIZE]; KERNEL_SIZE],
|
||||
pub count_neighbor: fn(neighbor_state: TState, kernel_value: TKernel) -> i32,
|
||||
pub count_neighbor: Box<dyn Fn(TState, TKernel) -> i32>,
|
||||
pub next_state: Box<dyn Fn(TState, i32) -> TState>,
|
||||
}
|
||||
|
||||
|
|
@ -27,7 +25,7 @@ pub const NEUMANN_NEIGHBORHOOD: [[bool; 3]; 3] = [
|
|||
|
||||
pub const DIAGONALS_NEIGHBORHOOD: [[bool; 3]; 3] = [
|
||||
[true, false, true],
|
||||
[false, true, false],
|
||||
[false, false, false],
|
||||
[true, false, true]
|
||||
];
|
||||
|
||||
|
|
@ -36,252 +34,73 @@ 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 {
|
||||
Self::generate_bb3()
|
||||
#[must_use]
|
||||
pub fn generate_bb3() -> Rules<bool, bool, 3> {
|
||||
let mut rng = thread_rng();
|
||||
|
||||
/*
|
||||
match rand::thread_rng().gen_range(0..=5) {
|
||||
0 => Self::game_of_life(),
|
||||
1 => Self::high_life(),
|
||||
2 => Self::seeds(),
|
||||
3 => Self::day_and_night(),
|
||||
4 => Self::mazecetric(),
|
||||
5 => Self::generate_bb3(),
|
||||
_ => panic!(),
|
||||
}*/
|
||||
}
|
||||
let is_moore = rng.gen_bool(1.0 / 2.0);
|
||||
let kernel = if is_moore { MOORE_NEIGHBORHOOD } else { NEUMANN_NEIGHBORHOOD };
|
||||
let max_neighbors = if is_moore { 8 } else { 4 };
|
||||
|
||||
#[must_use]
|
||||
pub fn game_of_life() -> Self {
|
||||
println_info("game of life");
|
||||
Self {
|
||||
kernel: MOORE_NEIGHBORHOOD,
|
||||
count_neighbor: count_true_neighbor,
|
||||
next_state: Box::new(|old_state, neighbors|
|
||||
matches!((old_state, neighbors), (true, 2) | (true, 3) | (false, 3))),
|
||||
}
|
||||
}
|
||||
let birth = generate_neighbor_counts(rng.gen_range(1..=max_neighbors), &mut rng, &[0]);
|
||||
let survive = generate_neighbor_counts(rng.gen_range(1..=max_neighbors), &mut rng, &[]);
|
||||
|
||||
#[must_use]
|
||||
pub fn high_life() -> Self {
|
||||
println_info("high life");
|
||||
Self {
|
||||
kernel: MOORE_NEIGHBORHOOD,
|
||||
count_neighbor: count_true_neighbor,
|
||||
next_state: Box::new(|old_state, neighbors|
|
||||
matches!((old_state, neighbors), (true, 2) | (true, 3) | (false, 3)| (false, 6))),
|
||||
}
|
||||
}
|
||||
println_info(format!("generated bb3: Birth {birth:?} Survival {survive:?}, kernel: {kernel:?}"));
|
||||
|
||||
#[must_use]
|
||||
pub fn seeds() -> Self {
|
||||
println_info("seeds");
|
||||
Self {
|
||||
kernel: MOORE_NEIGHBORHOOD,
|
||||
count_neighbor: count_true_neighbor,
|
||||
next_state: Box::new(|state, neighbors|
|
||||
matches!((state, neighbors), (false, 2))),
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn day_and_night() -> Self {
|
||||
println_info("day_and_night");
|
||||
Self {
|
||||
kernel: MOORE_NEIGHBORHOOD,
|
||||
count_neighbor: count_true_neighbor,
|
||||
next_state: Box::new(|state, neighbors| {
|
||||
match (state, neighbors) {
|
||||
(false, 3) => true,
|
||||
(false, 6) => true,
|
||||
(false, 7) => true,
|
||||
(false, 8) => true,
|
||||
(true, 3) => true,
|
||||
(true, 4) => true,
|
||||
(true, 6) => true,
|
||||
(true, 7) => true,
|
||||
(true, 8) => true,
|
||||
_ => false,
|
||||
}
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn mazecetric() -> Self {
|
||||
println_info("mazecetric");
|
||||
Self {
|
||||
kernel: MOORE_NEIGHBORHOOD,
|
||||
count_neighbor: count_true_neighbor,
|
||||
next_state: Box::new(|state, neighbors| {
|
||||
match (state, neighbors) {
|
||||
(false, 3) => true,
|
||||
(true, 0) => false,
|
||||
(true, n) if n < 5 => true,
|
||||
_ => false,
|
||||
}
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn generate_bb3() -> Self {
|
||||
let mut rng = thread_rng();
|
||||
|
||||
let is_moore = rng.gen_bool(1.0 / 2.0);
|
||||
let kernel = if is_moore { MOORE_NEIGHBORHOOD } else { NEUMANN_NEIGHBORHOOD };
|
||||
let max_neighbors = if is_moore { 8 } else { 4 };
|
||||
|
||||
let birth = generate_neighbor_counts(rng.gen_range(1..=max_neighbors), &mut rng);
|
||||
let survive = generate_neighbor_counts(rng.gen_range(1..=max_neighbors), &mut rng);
|
||||
|
||||
println_info(format!("generated bb3 moore: Birth {birth:?} Survival {survive:?}, is moore: {is_moore}"));
|
||||
|
||||
Self {
|
||||
kernel,
|
||||
count_neighbor: count_true_neighbor,
|
||||
next_state: Box::new(move |old_state, neighbors| {
|
||||
old_state && survive.contains(&neighbors)
|
||||
|| !old_state && birth.contains(&neighbors)
|
||||
}),
|
||||
}
|
||||
Rules {
|
||||
kernel,
|
||||
count_neighbor: Box::new(count_true_neighbor),
|
||||
next_state: Box::new(move |old_state, neighbors| {
|
||||
old_state && survive.contains(&neighbors)
|
||||
|| !old_state && birth.contains(&neighbors)
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
fn generate_neighbor_counts(count: u8, rng: &mut ThreadRng) -> HashSet<i32> {
|
||||
let mut result = HashSet::new();
|
||||
fn generate_neighbor_counts(count: u8, rng: &mut ThreadRng, exclude: &[i32]) -> Vec<i32> {
|
||||
let mut result = vec!();
|
||||
for _ in 0..count {
|
||||
result.insert(rng.gen_range(0..=count) as i32);
|
||||
let value = rng.gen_range(0..=count) as i32;
|
||||
if !exclude.contains(&value) {
|
||||
result.push(value);
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
impl Rules<u8, bool, 3> {
|
||||
#[must_use]
|
||||
pub fn random_u8b3() -> Self {
|
||||
Self::generate_u8b3()
|
||||
/*
|
||||
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 generate_u8b3() -> Rules<u8, bool, 3> {
|
||||
let mut rng = thread_rng();
|
||||
|
||||
#[must_use]
|
||||
pub fn brians_brain() -> Self {
|
||||
const ALIVE: u8 = u8::MAX;
|
||||
const DYING: u8 = ALIVE / 2;
|
||||
const DEAD: u8 = 0;
|
||||
let kernel = match rng.gen_range(0..3) {
|
||||
0 => MOORE_NEIGHBORHOOD,
|
||||
1 => NEUMANN_NEIGHBORHOOD,
|
||||
2 => DIAGONALS_NEIGHBORHOOD,
|
||||
_ => panic!()
|
||||
};
|
||||
|
||||
Self {
|
||||
kernel: MOORE_NEIGHBORHOOD,
|
||||
count_neighbor: |state, kernel| {
|
||||
if kernel && state == u8::MAX { 1 } else { 0 }
|
||||
},
|
||||
next_state: Box::new(|state, neighbors| {
|
||||
match (state, neighbors) {
|
||||
(ALIVE, _) => DYING,
|
||||
(DYING, _) => DEAD,
|
||||
(DEAD, 2) => ALIVE,
|
||||
(random_state, _) => if random_state > DYING {
|
||||
ALIVE
|
||||
} else {
|
||||
DEAD
|
||||
}
|
||||
}
|
||||
}),
|
||||
}
|
||||
}
|
||||
let alive_threshold = rng.gen();
|
||||
|
||||
#[must_use]
|
||||
pub fn continuous_game_of_life() -> Self {
|
||||
Self {
|
||||
kernel: MOORE_NEIGHBORHOOD,
|
||||
count_neighbor: |state, kernel| {
|
||||
if kernel && state >= u8::MAX / 2 { 1 } else { 0 }
|
||||
},
|
||||
next_state: Box::new(|old_state, neighbors| {
|
||||
let is_alive = old_state >= u8::MAX / 2;
|
||||
let delta = match (is_alive, neighbors) {
|
||||
(true, 2) | (true, 3) | (false, 3) => 10,
|
||||
_ => -10,
|
||||
};
|
||||
let birth = generate_neighbor_counts(rng.gen_range(1..=9), &mut rng, &[0]);
|
||||
let survive = generate_neighbor_counts(rng.gen_range(1..=9 - birth.len()) as u8, &mut rng, &[]);
|
||||
|
||||
i32::clamp(old_state as i32 + delta, u8::MIN as i32, u8::MAX as i32) as u8
|
||||
}),
|
||||
}
|
||||
}
|
||||
let add = rng.gen_range(5..40);
|
||||
let sub = rng.gen_range(5..40);
|
||||
|
||||
#[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: Box::new(|old_state, neighbors| {
|
||||
if old_state % 42 == 0 {
|
||||
return u8::MAX;
|
||||
}
|
||||
println_info(format!("generated u8b3: Birth {birth:?} Survival {survive:?}, kernel: {kernel:?}, alive_thresh: {alive_threshold}, delta: {add}/{sub}"));
|
||||
|
||||
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
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn generate_u8b3() -> Self {
|
||||
let mut rng = thread_rng();
|
||||
|
||||
let is_moore = rng.gen_bool(1.0 / 2.0);
|
||||
let kernel = if is_moore { MOORE_NEIGHBORHOOD } else { NEUMANN_NEIGHBORHOOD };
|
||||
let max_neighbors = if is_moore { 8 } else { 4 };
|
||||
|
||||
let alive_threshold = rng.gen();
|
||||
|
||||
let birth = generate_neighbor_counts(rng.gen_range(1..=max_neighbors), &mut rng);
|
||||
let survive = generate_neighbor_counts(rng.gen_range(1..=max_neighbors), &mut rng);
|
||||
|
||||
let add= rng.gen_range(5..40);
|
||||
let sub = rng.gen_range(5..40);
|
||||
|
||||
println_info(format!("generated bb3 moore: Birth {birth:?} Survival {survive:?}, is moore: {is_moore}"));
|
||||
|
||||
Self {
|
||||
kernel,
|
||||
count_neighbor: |state, kernel| {
|
||||
if kernel { state as i32 } else { 0 }
|
||||
},
|
||||
next_state: Box::new(move |old_state, neighbors| {
|
||||
let neighbors = neighbors / alive_threshold as i32;
|
||||
let old_is_alive = old_state >= alive_threshold;
|
||||
let new_is_alive = old_is_alive && survive.contains(&neighbors)
|
||||
|| !old_is_alive && birth.contains(&neighbors);
|
||||
let delta = if new_is_alive { add as i32 } else { -(sub as i32) };
|
||||
i32::clamp(old_state as i32 + delta, u8::MIN as i32, u8::MAX as i32) as u8
|
||||
}),
|
||||
}
|
||||
Rules {
|
||||
kernel,
|
||||
count_neighbor: Box::new(|state, kernel| {
|
||||
if kernel { state as i32 } else { 0 }
|
||||
}),
|
||||
next_state: Box::new(move |old_state, neighbors| {
|
||||
let neighbors = neighbors / alive_threshold as i32;
|
||||
let old_is_alive = old_state >= alive_threshold;
|
||||
let new_is_alive = old_is_alive && survive.contains(&neighbors)
|
||||
|| !old_is_alive && birth.contains(&neighbors);
|
||||
let delta = if new_is_alive { add } else { -sub };
|
||||
i32::clamp(old_state as i32 + delta, u8::MIN as i32, u8::MAX as i32) as u8
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue