mathzoo 0.2.0

Colorful real-time mathematical simulations and generative art for your terminal
use crate::canvas::Canvas;
use crate::color::hsv;
use crate::hdr::{lin, Hdr};
use crate::rng::{seed_from_time, Rng};
use crate::scene::{Key, Scene};

const GLIDER: [(usize, usize); 5] = [(1, 0), (2, 1), (0, 2), (1, 2), (2, 2)];

pub struct Life {
    w: usize,
    h: usize,
    cells: Vec<u8>,
    next: Vec<u8>,
    hdr: Hdr,
    acc: f64,
    rate: f64,
    generation: u64,
    pop: usize,
    stale: u32,
    rng: Rng,
}

fn alive(c: &[u8], w: usize, x: usize, y: usize) -> u8 {
    (c[y * w + x] > 0) as u8
}

impl Life {
    pub fn new() -> Self {
        Life {
            w: 0,
            h: 0,
            cells: Vec::new(),
            next: Vec::new(),
            hdr: Hdr::new(),
            acc: 0.0,
            rate: 20.0,
            generation: 0,
            pop: 0,
            stale: 0,
            rng: Rng::new(seed_from_time()),
        }
    }

    fn seed(&mut self) {
        for c in self.cells.iter_mut() {
            *c = if self.rng.f64() < 0.22 { 1 } else { 0 };
        }
        self.generation = 0;
        self.stale = 0;
        self.pop = 0;
    }

    fn step(&mut self) {
        let (w, h) = (self.w, self.h);
        if w == 0 || h == 0 {
            return;
        }
        let mut pop = 0usize;
        {
            let cells = &self.cells;
            let next = &mut self.next;
            for y in 0..h {
                let (ym, yp) = ((y + h - 1) % h, (y + 1) % h);
                for x in 0..w {
                    let (xm, xp) = ((x + w - 1) % w, (x + 1) % w);
                    let n = alive(cells, w, xm, ym)
                        + alive(cells, w, x, ym)
                        + alive(cells, w, xp, ym)
                        + alive(cells, w, xm, y)
                        + alive(cells, w, xp, y)
                        + alive(cells, w, xm, yp)
                        + alive(cells, w, x, yp)
                        + alive(cells, w, xp, yp);
                    let age = cells[y * w + x];
                    let new_age = match (age > 0, n) {
                        (true, 2) | (true, 3) => age.saturating_add(1),
                        (false, 3) => 1,
                        _ => 0,
                    };
                    if new_age > 0 {
                        pop += 1;
                    }
                    next[y * w + x] = new_age;
                }
            }
        }
        std::mem::swap(&mut self.cells, &mut self.next);
        self.generation += 1;
        if pop == self.pop {
            self.stale += 1;
        } else {
            self.stale = 0;
        }
        self.pop = pop;
        if self.stale > 60 {
            self.seed();
        }
    }
}

impl Scene for Life {
    fn name(&self) -> &'static str {
        "life"
    }

    fn status(&self) -> String {
        format!(
            "Conway's Life | gen {} pop {} rate {:.0}/s | +/-: speed  x: reseed  g: glider",
            self.generation, self.pop, self.rate
        )
    }

    fn resize(&mut self, px_w: usize, px_h: usize) {
        self.w = px_w;
        self.h = px_h;
        self.cells = vec![0; px_w * px_h];
        self.next = vec![0; px_w * px_h];
        self.hdr.resize(px_w, px_h);
        self.seed();
    }

    fn reset(&mut self) {
        self.seed();
    }

    fn update(&mut self, dt: f64) {
        self.acc = (self.acc + dt * self.rate).min(10.0);
        while self.acc >= 1.0 {
            self.step();
            self.acc -= 1.0;
        }
        self.hdr.fade(0.78f32.powf(dt as f32 * 30.0));
        for y in 0..self.h {
            for x in 0..self.w {
                let a = self.cells[y * self.w + x];
                if a > 0 {
                    let hue = 190.0 + (a as f64).min(100.0) * 1.6;
                    let amount = if a == 1 { 1.6 } else { 0.9 };
                    self.hdr.add_px(x, y, lin(hsv(hue, 0.8, 1.0), amount));
                }
            }
        }
    }

    fn draw(&self, canvas: &mut Canvas) {
        self.hdr.blit(canvas, 1.2, 0.5);
    }

    fn key(&mut self, key: Key) {
        match key {
            Key::Char('+') | Key::Char('=') => self.rate = (self.rate * 1.3).min(240.0),
            Key::Char('-') | Key::Char('_') => self.rate = (self.rate / 1.3).max(2.0),
            Key::Char('x') => self.seed(),
            Key::Char('g') => {
                if self.w > 0 && self.h > 0 {
                    let ox = (self.rng.f64() * self.w as f64) as usize;
                    let oy = (self.rng.f64() * self.h as f64) as usize;
                    for (dx, dy) in GLIDER {
                        let x = (ox + dx) % self.w;
                        let y = (oy + dy) % self.h;
                        self.cells[y * self.w + x] = 1;
                    }
                }
            }
            _ => {}
        }
    }
}