Merge pull request #108 from tamirelazar/dev

Promote dev to master: cell-path overlays + headless-ansi (8a)

Author: tamirelazar

src/app/mod.rs

@@ -12,6 +12,7 @@ use crate::exploration::{Explorer, ExplorerConfig, PresetBehavior};
 use crate::export::GifExporter;
 use crate::export::WebmExporter;
 use crate::render::adaptive_brightness::AdaptiveBrightness;
+use crate::render::ansi::{render_ansi_framed, FrameGeometry};
 use crate::render::charset::Charset;
 use crate::render::dither::DitherMode;
 use crate::render::downsample::{downsample, DownsampledFrame};
@@ -20,10 +21,13 @@ use crate::render::overlay::{
     ConfigBrowserOverlay, ConfigSaveOverlay, DashboardOverlay, KeyboardHintsOverlay, PauseOverlay,
     PresetComparisonOverlay, RenderedOverlay,
 };
-use crate::render::palette::{hex_to_rgb, palette_accent_color, RgbColor};
+use crate::render::palette::{
+    hex_to_rgb, palette_accent_color, IntensityMapping, Palette, RgbColor,
+};
 use crate::render::palette_editor::{
     EditorComponent, EditorMode, PaletteEditorOverlay, PaletteEditorState,
 };
+use crate::render::window::{FRAME_RING_COLS, FRAME_RING_ROWS, GRID_COLOR, GRID_OPACITY};
 use crate::simulation;
 use crate::simulation::config::{
     Attractor, DiffusionKernel, InitMode, Preset, SimConfig, TerrainType,
@@ -624,6 +628,22 @@ pub fn run() -> io::Result<()> {
         return Ok(());
     }
 
+    if args.mode() == Mode::HeadlessAnsi {
+        let seed = args.seed.unwrap_or(1);
+        let agents = args.population.unwrap_or(50_000);
+        print!(
+            "{}",
+            headless_ansi_frame(
+                args.headless_cols,
+                args.headless_rows,
+                args.headless_steps,
+                seed,
+                agents,
+            )
+        );
+        return Ok(());
+    }
+
     args.validate()
         .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
 
@@ -677,6 +697,72 @@ pub fn run() -> io::Result<()> {
     Ok(())
 }
 
+/// Renders the exact ANSI frame the vendored wasm's `render_ansi_frame`
+/// produces for a `cols`×`rows` terminal, from fresh isolated state.
+///
+/// Mirrors the `/info` route identity byte-for-byte: a 400×200 `Simulation`
+/// seeded with `InitMode::Random`, `Palette::Warm`, bare
+/// `AdaptiveBrightness::new(100, true)` gain (no brightness divisor), and the
+/// same grid/accent parameters — so `--headless-ansi` output is a golden
+/// frame the wasm reproduces byte-identically when configured to the same
+/// identity (Warm palette, brightness 1.0).
+pub fn headless_ansi_frame(
+    cols: usize,
+    rows: usize,
+    steps: usize,
+    seed: u64,
+    agents: usize,
+) -> String {
+    let (sim_w, sim_h) = (400usize, 200usize);
+    let mut config = SimConfig::default();
+    if let Some(species) = config.species_configs.first_mut() {
+        species.count = agents;
+    }
+    let mut sim = Simulation::new(sim_w, sim_h, config, seed, InitMode::Random, 0);
+
+    let geom = FrameGeometry {
+        cols,
+        rows,
+        ring_cols: FRAME_RING_COLS,
+        ring_rows: FRAME_RING_ROWS,
+    };
+    let (iw, ih) = geom.interior();
+
+    let mut adaptive = AdaptiveBrightness::new(100, true);
+
+    let mut grid = GridRenderer::new(GridStyle::Cross, 5, GRID_COLOR, GRID_OPACITY, false);
+    grid.initialize(iw, ih);
+
+    let mut frame = DownsampledFrame::new(iw, ih);
+    let mut trail: Vec<f32> = Vec::new();
+
+    let mapping = IntensityMapping::logarithmic(10.0);
+    let accent = palette_accent_color(&Palette::Warm, false, false, 0.0, Some(&mapping));
+
+    let mut out = String::new();
+    for _ in 1..=steps {
+        sim.update(1.0);
+        sim.trail_map_blended(&mut trail);
+        downsample(&trail, sim_w, sim_h, iw, ih, &mut frame);
+
+        adaptive.update(frame.cells());
+        let gain = adaptive.get_max_brightness();
+
+        out = render_ansi_framed(
+            frame.cells(),
+            &geom,
+            Palette::Warm,
+            Charset::Ascii,
+            gain,
+            Some(&grid),
+            GRID_COLOR,
+            GRID_OPACITY,
+            Some(accent),
+        );
+    }
+    out
+}
+
 /// Executes the "Print" mode.
 ///
 /// Advances the simulation one step and writes a single frame to stdout,
@@ -1484,6 +1570,16 @@ mod tests {
     use crate::simulation::config::WindowFrame;
     use crate::terminal::control::MouseInteractionMode;
 
+    #[test]
+    fn headless_ansi_is_deterministic_and_framed() {
+        let a = crate::app::headless_ansi_frame(80, 24, 50, 1, 50_000);
+        let b = crate::app::headless_ansi_frame(80, 24, 50, 1, 50_000);
+        assert_eq!(a, b, "fresh state + fixed steps ⇒ identical");
+        assert!(a.contains('\u{2588}'), "glow ring present");
+        let c = crate::app::headless_ansi_frame(80, 24, 51, 1, 50_000);
+        assert_ne!(a, c, "different step count ⇒ different frame");
+    }
+
     #[test]
     fn sync_renderer_caches_pushes_charset_and_window_frame() {
         let mut rs = RuntimeState::new(

src/cli.rs

@@ -36,6 +36,9 @@ pub enum Mode {
     GifExport,
     /// Export animation to WebM.
     WebmExport,
+    /// Deterministic headless ANSI golden-frame mode (mirrors the wasm
+    /// `render_ansi_frame`, byte-for-byte, from fresh isolated state).
+    HeadlessAnsi,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -671,6 +674,40 @@ pub struct Args {
     /// Directory to save captured frames.
     pub frame_dir: String,
 
+    #[arg(
+        long = "headless-ansi",
+        help = "Print the exact ANSI frame the wasm's render_ansi_frame produces and exit (deterministic golden mode)"
+    )]
+    /// Deterministic headless ANSI golden-frame mode (mirrors the wasm `render_ansi_frame`).
+    pub headless_ansi: bool,
+
+    #[arg(
+        long = "cols",
+        value_name = "INT",
+        default_value_t = 80,
+        help = "Terminal columns for --headless-ansi"
+    )]
+    /// Terminal column count used by `--headless-ansi`.
+    pub headless_cols: usize,
+
+    #[arg(
+        long = "rows",
+        value_name = "INT",
+        default_value_t = 24,
+        help = "Terminal rows for --headless-ansi"
+    )]
+    /// Terminal row count used by `--headless-ansi`.
+    pub headless_rows: usize,
+
+    #[arg(
+        long = "steps",
+        value_name = "INT",
+        default_value_t = 300,
+        help = "Simulation steps to run for --headless-ansi"
+    )]
+    /// Simulation step count used by `--headless-ansi`.
+    pub headless_steps: usize,
+
     #[arg(
         short = 's',
         long = "seed",
@@ -1813,7 +1850,9 @@ pub struct Args {
 impl Args {
     /// Determines the operational mode based on flags.
     pub fn mode(&self) -> Mode {
-        if self.screensaver {
+        if self.headless_ansi {
+            Mode::HeadlessAnsi
+        } else if self.screensaver {
             Mode::Screensaver
         } else if self.live {
             Mode::Live
@@ -2227,6 +2266,10 @@ impl Default for Args {
             explore: false,
             explore_behavior: None,
             explore_iterations: 100,
+            headless_ansi: false,
+            headless_cols: 80,
+            headless_rows: 24,
+            headless_steps: 300,
             seed: None,
             population: Some(population::DEFAULT_POPULATION),
             sensor_angle: Some(agent_consts::DEFAULT_SENSOR_ANGLE),