mathzoo 0.2.0

Colorful real-time mathematical simulations and generative art for your terminal
use crate::canvas::Canvas;
use crate::color::{palette, scale, PALETTE_COUNT, PALETTE_NAMES};
use crate::rng::{seed_from_time, Rng};
use crate::scene::{Key, Scene};

const PRESETS: [(&str, f32, f32); 5] = [
    ("coral", 0.0545, 0.062),
    ("maze", 0.029, 0.057),
    ("mitosis", 0.0367, 0.0649),
    ("fingerprint", 0.037, 0.060),
    ("spots", 0.030, 0.062),
];

const SEED_PATTERNS: [&str; 5] = ["bloom", "ring", "grid", "spiral", "scatter"];

fn wrap_offset(center: usize, offset: f64, extent: usize) -> usize {
    ((center as f64 + offset).round() as i64).rem_euclid(extent as i64) as usize
}

pub struct Reaction {
    w: usize,
    h: usize,
    u: Vec<f32>,
    v: Vec<f32>,
    nu: Vec<f32>,
    nv: Vec<f32>,
    preset: usize,
    seed_pattern: usize,
    pal: usize,
    phase: f64,
    spf: usize,
    rng: Rng,
}

fn laplacian(
    a: &[f32],
    w: usize,
    x: usize,
    y: usize,
    xm: usize,
    xp: usize,
    ym: usize,
    yp: usize,
) -> f32 {
    -a[y * w + x]
        + 0.2 * (a[y * w + xm] + a[y * w + xp] + a[ym * w + x] + a[yp * w + x])
        + 0.05 * (a[ym * w + xm] + a[ym * w + xp] + a[yp * w + xm] + a[yp * w + xp])
}

impl Reaction {
    pub fn new() -> Self {
        Reaction {
            w: 0,
            h: 0,
            u: Vec::new(),
            v: Vec::new(),
            nu: Vec::new(),
            nv: Vec::new(),
            preset: 0,
            seed_pattern: 0,
            pal: 0,
            phase: 0.0,
            spf: 12,
            rng: Rng::new(seed_from_time()),
        }
    }

    fn drop_seed(&mut self, cx: usize, cy: usize) {
        let (w, h) = (self.w as i64, self.h as i64);
        for dy in -4i64..=4 {
            for dx in -4i64..=4 {
                let x = (cx as i64 + dx).rem_euclid(w) as usize;
                let y = (cy as i64 + dy).rem_euclid(h) as usize;
                let i = y * self.w + x;
                self.u[i] = 0.5;
                self.v[i] = 0.25;
            }
        }
    }

    fn seed(&mut self) {
        if self.w == 0 || self.h == 0 {
            return;
        }
        for i in 0..self.u.len() {
            self.u[i] = 1.0;
            self.v[i] = 0.0;
        }
        let (cx, cy) = (self.w / 2, self.h / 2);
        let radius = self.w.min(self.h) as f64 * 0.22;
        match self.seed_pattern {
            0 => {
                self.drop_seed(cx, cy);
                for i in 0..8 {
                    let angle = std::f64::consts::TAU * i as f64 / 8.0;
                    self.drop_seed(
                        wrap_offset(cx, angle.cos() * radius * 0.65, self.w),
                        wrap_offset(cy, angle.sin() * radius * 0.65, self.h),
                    );
                }
            }
            1 => {
                for i in 0..16 {
                    let angle = std::f64::consts::TAU * i as f64 / 16.0;
                    self.drop_seed(
                        wrap_offset(cx, angle.cos() * radius, self.w),
                        wrap_offset(cy, angle.sin() * radius, self.h),
                    );
                }
            }
            2 => {
                for gy in 1..=3 {
                    for gx in 1..=3 {
                        self.drop_seed(self.w * gx / 4, self.h * gy / 4);
                    }
                }
            }
            3 => {
                for i in 0..18 {
                    let t = i as f64 / 17.0;
                    let angle = t * std::f64::consts::TAU * 3.0;
                    let distance = radius * t;
                    self.drop_seed(
                        wrap_offset(cx, angle.cos() * distance, self.w),
                        wrap_offset(cy, angle.sin() * distance, self.h),
                    );
                }
            }
            _ => {
                let drops = (self.w * self.h / 1500).max(4);
                for _ in 0..drops {
                    self.add_random_drop();
                }
            }
        }
    }

    fn add_random_drop(&mut self) {
        let cx = (self.rng.f64() * self.w as f64) as usize;
        let cy = (self.rng.f64() * self.h as f64) as usize;
        self.drop_seed(cx.min(self.w - 1), cy.min(self.h - 1));
    }

    fn step(&mut self) {
        let (w, h) = (self.w, self.h);
        let (f, k) = (PRESETS[self.preset].1, PRESETS[self.preset].2);
        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 i = y * w + x;
                let (u, v) = (self.u[i], self.v[i]);
                let uvv = u * v * v;
                let lu = laplacian(&self.u, w, x, y, xm, xp, ym, yp);
                let lv = laplacian(&self.v, w, x, y, xm, xp, ym, yp);
                self.nu[i] = (u + lu - uvv + f * (1.0 - u)).clamp(0.0, 1.0);
                self.nv[i] = (v + 0.5 * lv + uvv - (k + f) * v).clamp(0.0, 1.0);
            }
        }
        std::mem::swap(&mut self.u, &mut self.nu);
        std::mem::swap(&mut self.v, &mut self.nv);
    }
}

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

    fn status(&self) -> String {
        let (name, f, k) = PRESETS[self.preset];
        format!(
            "Gray-Scott {} F={:.4} k={:.4} | {} seeds | c: {} palette  g: shape  p: chemistry  x: add seeds  +/-: speed",
            name,
            f,
            k,
            SEED_PATTERNS[self.seed_pattern],
            PALETTE_NAMES[self.pal]
        )
    }

    fn resize(&mut self, px_w: usize, px_h: usize) {
        self.w = px_w;
        self.h = px_h;
        let n = px_w * px_h;
        self.u = vec![1.0; n];
        self.v = vec![0.0; n];
        self.nu = vec![1.0; n];
        self.nv = vec![0.0; n];
        self.seed();
    }

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

    fn update(&mut self, dt: f64) {
        if self.w == 0 || self.h == 0 {
            return;
        }
        self.phase += dt * 0.02;
        for _ in 0..self.spf {
            self.step();
        }
    }

    fn draw(&self, canvas: &mut Canvas) {
        for y in 0..self.h {
            for x in 0..self.w {
                let v = self.v[y * self.w + x] as f64;
                let t = (v * 2.6).min(1.0);
                if t > 0.02 {
                    let base = palette(0.35 + t * 0.55 + self.phase, self.pal);
                    canvas.set(x as i32, y as i32, scale(base, t.powf(0.55)));
                }
            }
        }
    }

    fn key(&mut self, key: Key) {
        match key {
            Key::Char('p') => {
                self.preset = (self.preset + 1) % PRESETS.len();
                self.seed();
            }
            Key::Char('c') => self.pal = (self.pal + 1) % PALETTE_COUNT,
            Key::Char('g') => {
                self.seed_pattern = (self.seed_pattern + 1) % SEED_PATTERNS.len();
                self.seed();
            }
            Key::Char('x') => {
                if self.w > 0 && self.h > 0 {
                    for _ in 0..4 {
                        self.add_random_drop();
                    }
                }
            }
            Key::Char('+') | Key::Char('=') => self.spf = (self.spf + 4).min(60),
            Key::Char('-') | Key::Char('_') => self.spf = self.spf.saturating_sub(4).max(2),
            _ => {}
        }
    }
}