story/

story.rs

use std::env;
use std::io::{self, Write};
use std::process::Command;
use std::thread;
use std::time::Duration;

use aisling::{
    Cell, Color, Effect, EffectConfig, EffectKind, Frame, Gradient, GradientDirection, Loader,
    LoaderConfig, LoaderKind, LoaderProgress,
};

const TEST_SH: &str = include_str!("../test.sh");
const TEXT_MARKER: &str = "__KNOTT_TEXT__";

fn main() {
    let args = Args::parse();
    let (terminal_width, terminal_height) = terminal_size();
    let width = terminal_width.max(112);
    let height = terminal_height.max(36);
    let fps = args.fps.max(1);
    let scene_ticks = (args.scene_seconds.max(1) * fps) as usize;
    let layout = Layout::new(width, height);
    let source = load_knott_text();
    let scenes = build_scenes(&source, &layout, scene_ticks);
    let total_ticks = args
        .seconds
        .map(|seconds| (seconds * fps) as usize)
        .unwrap_or(scene_ticks * scenes.len());
    let frame_delay = Duration::from_millis((1000 / fps) as u64);
    let mut stdout = io::stdout();
    let _guard = TerminalGuard::enter(&mut stdout, args.alt_screen);
    let tasks = story_tasks();
    let mut tick = 0usize;

    loop {
        let scene_index = (tick / scene_ticks) % scenes.len().max(1);
        let scene_tick = tick % scene_ticks;
        let frame = compose_story(
            &layout,
            &scenes,
            scene_index,
            scene_tick,
            tick,
            scene_ticks,
            total_ticks.max(1),
            &tasks,
        );
        write!(stdout, "\x1b[H{}\x1b[0m", frame.to_ansi_string()).unwrap();
        stdout.flush().unwrap();

        tick += 1;
        if args.once || tick >= total_ticks {
            break;
        }
        thread::sleep(frame_delay);
    }
}

#[derive(Clone, Debug)]
struct Args {
    seconds: Option<u64>,
    fps: u64,
    scene_seconds: u64,
    once: bool,
    alt_screen: bool,
}

impl Args {
    fn parse() -> Self {
        let mut args = env::args().skip(1);
        let mut parsed = Self {
            seconds: None,
            fps: 12,
            scene_seconds: 7,
            once: false,
            alt_screen: true,
        };
        while let Some(arg) = args.next() {
            match arg.as_str() {
                "--seconds" => parsed.seconds = args.next().and_then(|value| value.parse().ok()),
                "--fps" => {
                    parsed.fps = args
                        .next()
                        .and_then(|value| value.parse().ok())
                        .unwrap_or(parsed.fps)
                }
                "--scene-seconds" => {
                    parsed.scene_seconds = args
                        .next()
                        .and_then(|value| value.parse().ok())
                        .unwrap_or(parsed.scene_seconds)
                }
                "--once" => parsed.once = true,
                "--no-alt" => parsed.alt_screen = false,
                "-h" | "--help" | "help" => {
                    usage();
                    std::process::exit(0);
                }
                _ => {}
            }
        }
        parsed
    }
}

#[derive(Clone, Copy, Debug)]
struct Rect {
    x: usize,
    y: usize,
    w: usize,
    h: usize,
}

#[derive(Clone, Debug)]
struct Layout {
    width: usize,
    height: usize,
    header: Rect,
    stage: Rect,
    systems: Rect,
    bottom: Rect,
}

impl Layout {
    fn new(width: usize, height: usize) -> Self {
        let header_h = 4;
        let bottom_h = 8.min(height.saturating_sub(header_h + 10).max(5));
        let middle_h = height.saturating_sub(header_h + bottom_h).max(12);
        let systems_w = (width / 3).clamp(34, 56).min(width.saturating_sub(46));
        let stage_w = width.saturating_sub(systems_w + 3).max(40);
        Self {
            width,
            height,
            header: Rect {
                x: 0,
                y: 0,
                w: width,
                h: header_h,
            },
            stage: Rect {
                x: 1,
                y: header_h,
                w: stage_w,
                h: middle_h,
            },
            systems: Rect {
                x: stage_w + 2,
                y: header_h,
                w: systems_w,
                h: middle_h,
            },
            bottom: Rect {
                x: 1,
                y: header_h + middle_h,
                w: width.saturating_sub(2).max(1),
                h: bottom_h,
            },
        }
    }
}

#[derive(Clone, Debug)]
struct Scene {
    title: &'static str,
    subtitle: &'static str,
    effect: EffectKind,
    accent: Color,
    frames: Vec<Frame>,
    quote: String,
}

#[derive(Clone, Copy, Debug)]
struct StoryTask {
    label: &'static str,
    kind: LoaderKind,
    total: u64,
    offset: usize,
    speed: usize,
    rows: usize,
    unit: &'static str,
}

fn compose_story(
    layout: &Layout,
    scenes: &[Scene],
    scene_index: usize,
    scene_tick: usize,
    tick: usize,
    scene_ticks: usize,
    total_ticks: usize,
    tasks: &[StoryTask],
) -> Frame {
    let scene = &scenes[scene_index];
    let mut screen =
        Frame::with_background(layout.width, layout.height, Some(Color::rgb(3, 6, 10)));
    draw_story_background(&mut screen, tick, scene.accent);
    draw_header(
        &mut screen,
        layout.header,
        scene,
        scene_index,
        scenes.len(),
        tick,
    );
    draw_stage(&mut screen, layout.stage, scene, scene_tick, scene_ticks);
    draw_systems(
        &mut screen,
        layout.systems,
        tasks,
        tick,
        total_ticks,
        scene.accent,
    );
    draw_bottom_bus(
        &mut screen,
        layout.bottom,
        scenes,
        scene_index,
        tick,
        total_ticks,
        scene.accent,
    );
    screen
}

fn draw_header(
    screen: &mut Frame,
    area: Rect,
    scene: &Scene,
    scene_index: usize,
    total: usize,
    tick: usize,
) {
    fill_rect(screen, area, Some(Color::rgb(5, 10, 16)));
    for x in area.x..area.x + area.w {
        let color = if (x + tick) % 9 == 0 {
            scene.accent.brighten(0.25)
        } else {
            Color::rgb(35, 56, 72)
        };
        put_cell(
            screen,
            x,
            area.y + area.h - 1,
            '-',
            color,
            Some(Color::rgb(5, 10, 16)),
            false,
            true,
        );
    }
    put_text(
        screen,
        area.x + 2,
        area.y,
        "KNOTT DYNAMICS // HUMANOID STORY RIG",
        Color::rgb(255, 178, 78),
        Some(Color::rgb(5, 10, 16)),
        true,
    );
    put_text(
        screen,
        area.x + 2,
        area.y + 1,
        "tendons  leverage  motion  intelligence  field telemetry",
        Color::rgb(126, 194, 255),
        Some(Color::rgb(5, 10, 16)),
        false,
    );
    let right = format!(
        "ACT {:02}/{:02}  {}  EFFECT:{}  T+{:04}",
        scene_index + 1,
        total,
        scene.title,
        scene.effect.name(),
        tick
    );
    put_text_right(
        screen,
        area.x + area.w.saturating_sub(2),
        area.y,
        &right,
        scene.accent.brighten(0.2),
        Some(Color::rgb(5, 10, 16)),
        true,
    );
    put_text_right(
        screen,
        area.x + area.w.saturating_sub(2),
        area.y + 1,
        scene.subtitle,
        Color::rgb(184, 204, 220),
        Some(Color::rgb(5, 10, 16)),
        false,
    );
}

fn draw_stage(
    screen: &mut Frame,
    area: Rect,
    scene: &Scene,
    scene_tick: usize,
    scene_ticks: usize,
) {
    draw_panel(screen, area, "MANIFESTO PLAYBACK", scene.accent);
    let title = format!("{} :: {}", scene.title, scene.subtitle);
    put_text(
        screen,
        area.x + 2,
        area.y + 2,
        &title,
        scene.accent.brighten(0.18),
        Some(Color::rgb(7, 12, 18)),
        true,
    );
    let progress = scene_tick as f32 / scene_ticks.max(1) as f32;
    draw_progress_strip(
        screen,
        Rect {
            x: area.x + 2,
            y: area.y + 3,
            w: area.w.saturating_sub(4),
            h: 1,
        },
        progress,
        scene.accent,
        Color::rgb(42, 54, 64),
    );
    let effect_area = Rect {
        x: area.x + 3,
        y: area.y + 5,
        w: area.w.saturating_sub(6),
        h: area.h.saturating_sub(12).max(4),
    };
    let frame = &scene.frames[scene_tick.min(scene.frames.len().saturating_sub(1))];
    draw_frame_centered(screen, effect_area, frame);
    let quote_area = Rect {
        x: area.x + 3,
        y: area.y + area.h.saturating_sub(6),
        w: area.w.saturating_sub(6),
        h: 4,
    };
    draw_quote(screen, quote_area, &scene.quote, scene.accent);
}

fn draw_systems(
    screen: &mut Frame,
    area: Rect,
    tasks: &[StoryTask],
    tick: usize,
    total_ticks: usize,
    accent: Color,
) {
    draw_panel(screen, area, "FAKE DOWNLOADS // LAB SYSTEMS", accent);
    let mut y = area.y + 2;
    let inner_w = area.w.saturating_sub(4).max(1);
    for task in tasks {
        if y >= area.y + area.h.saturating_sub(1) {
            break;
        }
        let cycle = total_ticks.max(1) / task.speed.max(1) + 24;
        let current_tick = (tick + task.offset) % cycle.max(1);
        let fraction = current_tick as f32 / cycle.max(1) as f32;
        let current = (task.total as f32 * fraction).round() as u64;
        let progress = LoaderProgress::from_counts(current.min(task.total), task.total);
        let rows = task.rows.min(area.y + area.h - y - 1).max(1);
        let loader = Loader::with_config(
            task.kind,
            LoaderConfig::default()
                .with_size(inner_w, rows)
                .with_label(task.label)
                .with_unit(task.unit)
                .with_fraction(matches!(
                    task.kind,
                    LoaderKind::Tqdm | LoaderKind::Download | LoaderKind::Upload
                ))
                .with_gradient(
                    Gradient::new(
                        vec![accent, Color::rgb(74, 224, 255), Color::rgb(255, 186, 74)],
                        24,
                    ),
                    GradientDirection::Horizontal,
                ),
        );
        let frame = loader.frame(tick + task.offset, progress);
        draw_frame(screen, area.x + 2, y, &frame, inner_w, rows);
        y += rows + 1;
    }
}

fn draw_bottom_bus(
    screen: &mut Frame,
    area: Rect,
    scenes: &[Scene],
    scene_index: usize,
    tick: usize,
    total_ticks: usize,
    accent: Color,
) {
    draw_panel(screen, area, "STORY BUS // TELEMETRY", accent);
    let bus_w = area.w.saturating_sub(4).max(1);
    let scene_count = scenes.len().max(1);
    for (index, scene) in scenes.iter().enumerate() {
        let x0 = area.x + 2 + index * bus_w / scene_count;
        let x1 = area.x + 2 + (index + 1) * bus_w / scene_count;
        let active = index == scene_index;
        for x in x0..x1.min(area.x + area.w.saturating_sub(2)) {
            put_cell(
                screen,
                x,
                area.y + 2,
                if active { '=' } else { '-' },
                if active {
                    scene.accent
                } else {
                    Color::rgb(58, 70, 82)
                },
                Some(Color::rgb(7, 12, 18)),
                active,
                !active,
            );
        }
    }
    let global = tick as f32 / total_ticks.max(1) as f32;
    draw_progress_strip(
        screen,
        Rect {
            x: area.x + 2,
            y: area.y + 4,
            w: bus_w,
            h: 1,
        },
        global,
        Color::rgb(255, 178, 76),
        Color::rgb(42, 54, 64),
    );
    let logs = [
        "pulling tendon atlas from nature://forearm",
        "downloading leverage matrices into the gait lab",
        "burning actuator constraints into motion plans",
        "decrypting sensor noise into intention",
        "simulating force lines through cable and joint",
        "packing humanoid grace into repeatable frames",
    ];
    let log = logs[(tick / 18) % logs.len()];
    put_text(
        screen,
        area.x + 2,
        area.y + 5,
        log,
        Color::rgb(188, 210, 224),
        Some(Color::rgb(7, 12, 18)),
        false,
    );
    let pulse = Loader::with_config(
        LoaderKind::Braided,
        LoaderConfig::default()
            .with_size(area.w.saturating_sub(4).max(1), 1)
            .with_label("field bus")
            .with_percent(false)
            .with_gradient(
                Gradient::new(vec![accent, Color::rgb(255, 92, 212)], 16),
                GradientDirection::Horizontal,
            ),
    )
    .frame(tick, global);
    draw_frame(
        screen,
        area.x + 2,
        area.y + area.h.saturating_sub(2),
        &pulse,
        area.w.saturating_sub(4),
        1,
    );
}

fn build_scenes(source: &str, layout: &Layout, scene_ticks: usize) -> Vec<Scene> {
    let paragraphs = paragraphs(source);
    let effect_w = layout.stage.w.saturating_sub(8).max(40);
    let effect_h = layout.stage.h.saturating_sub(16).max(5).min(12);
    let specs = [
        (
            "BOOT SEQUENCE",
            "matrix rain resolves the mission",
            EffectKind::Matrix,
            Color::rgb(74, 255, 170),
            0usize,
        ),
        (
            "FORGE",
            "burning the actuator constraints",
            EffectKind::Burn,
            Color::rgb(255, 118, 54),
            3,
        ),
        (
            "STORM SENSORS",
            "signal and response in the weather",
            EffectKind::Thunderstorm,
            Color::rgb(96, 204, 255),
            2,
        ),
        (
            "LASER ETCH",
            "leverage maps cut into the frame",
            EffectKind::LaserEtch,
            Color::rgb(255, 220, 92),
            7,
        ),
        (
            "GRAVITY WELL",
            "weight and balance collapse into order",
            EffectKind::Blackhole,
            Color::rgb(164, 126, 255),
            5,
        ),
        (
            "ORBITAL BALANCE",
            "rings of motion settle around intent",
            EffectKind::Rings,
            Color::rgb(110, 255, 224),
            6,
        ),
        (
            "SWARM CALIBRATION",
            "many small forces become one gait",
            EffectKind::Swarm,
            Color::rgb(255, 112, 218),
            4,
        ),
        (
            "FIELD DEMO",
            "fireworks over the completed machine",
            EffectKind::Fireworks,
            Color::rgb(255, 180, 72),
            1,
        ),
    ];
    specs
        .iter()
        .enumerate()
        .map(
            |(index, (title, subtitle, kind, accent, paragraph_index))| {
                let paragraph = paragraphs
                    .get(*paragraph_index)
                    .or_else(|| paragraphs.get(index % paragraphs.len().max(1)))
                    .cloned()
                    .unwrap_or_else(|| source.to_string());
                let extra = match kind {
                    EffectKind::Matrix => "Data falls until it becomes purpose.",
                    EffectKind::Burn => "The forge removes everything that does not serve motion.",
                    EffectKind::Thunderstorm => "Noise becomes weather; weather becomes signal.",
                    EffectKind::LaserEtch => "Leverage is written as geometry and timing.",
                    EffectKind::Blackhole => {
                        "Weight collapses into balance before it expands into gait."
                    }
                    EffectKind::Rings => "Joints orbit a center of intention.",
                    EffectKind::Swarm => "Many corrections gather into one quiet step.",
                    _ => "The machine disappears into the grace of the whole.",
                };
                let text = wrap_text(&format!("{}\n\n{}", paragraph, extra), effect_w);
                let gradient = Gradient::new(
                    vec![*accent, accent.brighten(0.36), Color::rgb(235, 244, 250)],
                    32,
                );
                let config = EffectConfig::default()
                    .with_duration(scene_ticks.max(8))
                    .with_seed(700 + index as u64 * 97)
                    .with_canvas_size(effect_w, effect_h)
                    .with_gradient(gradient, GradientDirection::Diagonal);
                let frames = Effect::with_config(*kind, text.clone(), config).frames();
                Scene {
                    title,
                    subtitle,
                    effect: *kind,
                    accent: *accent,
                    frames,
                    quote: paragraph,
                }
            },
        )
        .collect()
}

fn story_tasks() -> Vec<StoryTask> {
    vec![
        StoryTask {
            label: "tendon_atlas.tar",
            kind: LoaderKind::Tqdm,
            total: 930,
            offset: 0,
            speed: 2,
            rows: 1,
            unit: "MB",
        },
        StoryTask {
            label: "decrypt_gait_kernel",
            kind: LoaderKind::Decrypt,
            total: 512,
            offset: 11,
            speed: 3,
            rows: 4,
            unit: "blk",
        },
        StoryTask {
            label: "forge_actuator_set",
            kind: LoaderKind::Burn,
            total: 740,
            offset: 23,
            speed: 3,
            rows: 4,
            unit: "N",
        },
        StoryTask {
            label: "storm_sensor_mesh",
            kind: LoaderKind::Thunderstorm,
            total: 384,
            offset: 37,
            speed: 4,
            rows: 4,
            unit: "pkt",
        },
        StoryTask {
            label: "laseretch_chassis",
            kind: LoaderKind::LaserEtch,
            total: 622,
            offset: 53,
            speed: 3,
            rows: 4,
            unit: "mm",
        },
        StoryTask {
            label: "balance_rings",
            kind: LoaderKind::Rings,
            total: 480,
            offset: 67,
            speed: 5,
            rows: 4,
            unit: "sim",
        },
        StoryTask {
            label: "swarm_corrections",
            kind: LoaderKind::Swarm,
            total: 2048,
            offset: 79,
            speed: 4,
            rows: 4,
            unit: "vec",
        },
        StoryTask {
            label: "upload_field_manifest",
            kind: LoaderKind::Upload,
            total: 128,
            offset: 91,
            speed: 2,
            rows: 1,
            unit: "MB",
        },
    ]
}

fn load_knott_text() -> String {
    let mut capture = false;
    let mut lines = Vec::new();
    for line in TEST_SH.lines() {
        if capture {
            if line.trim() == TEXT_MARKER {
                break;
            }
            lines.push(line);
        } else if line.contains(TEXT_MARKER) && line.contains("cat <<") {
            capture = true;
        }
    }
    lines.join("\n")
}

fn paragraphs(input: &str) -> Vec<String> {
    input
        .split("\n\n")
        .map(|paragraph| {
            paragraph
                .lines()
                .map(str::trim)
                .collect::<Vec<_>>()
                .join(" ")
        })
        .map(|paragraph| paragraph.trim().to_string())
        .filter(|paragraph| !paragraph.is_empty())
        .collect()
}

fn wrap_text(input: &str, width: usize) -> String {
    let mut out = Vec::new();
    for paragraph in input.split('\n') {
        if paragraph.trim().is_empty() {
            out.push(String::new());
            continue;
        }
        let mut line = String::new();
        for word in paragraph.split_whitespace() {
            if !line.is_empty() && line.len() + word.len() + 1 > width.max(12) {
                out.push(line);
                line = String::new();
            }
            if !line.is_empty() {
                line.push(' ');
            }
            line.push_str(word);
        }
        if !line.is_empty() {
            out.push(line);
        }
    }
    out.join("\n")
}

fn draw_story_background(screen: &mut Frame, tick: usize, accent: Color) {
    let width = screen.width();
    let height = screen.height();
    for y in 0..height {
        for x in 0..width {
            let n = noise(0x5107, x as u64, y as u64, (tick / 3) as u64);
            if n > 0.965 {
                let ch = if n > 0.985 { '1' } else { '0' };
                put_cell(
                    screen,
                    x,
                    y,
                    ch,
                    accent.dim(0.42),
                    Some(Color::rgb(3, 6, 10)),
                    false,
                    true,
                );
            } else if (x + y + tick / 2) % 41 == 0 {
                put_cell(
                    screen,
                    x,
                    y,
                    '.',
                    Color::rgb(34, 50, 62),
                    Some(Color::rgb(3, 6, 10)),
                    false,
                    true,
                );
            }
        }
    }
}

fn draw_panel(screen: &mut Frame, area: Rect, title: &str, accent: Color) {
    fill_rect(screen, area, Some(Color::rgb(7, 12, 18)));
    if area.w < 2 || area.h < 2 {
        return;
    }
    let border = Color::rgb(46, 70, 88);
    for x in area.x..area.x + area.w {
        put_cell(
            screen,
            x,
            area.y,
            '-',
            border,
            Some(Color::rgb(7, 12, 18)),
            false,
            true,
        );
        put_cell(
            screen,
            x,
            area.y + area.h - 1,
            '-',
            border,
            Some(Color::rgb(7, 12, 18)),
            false,
            true,
        );
    }
    for y in area.y..area.y + area.h {
        put_cell(
            screen,
            area.x,
            y,
            '|',
            border,
            Some(Color::rgb(7, 12, 18)),
            false,
            true,
        );
        put_cell(
            screen,
            area.x + area.w - 1,
            y,
            '|',
            border,
            Some(Color::rgb(7, 12, 18)),
            false,
            true,
        );
    }
    put_cell(
        screen,
        area.x,
        area.y,
        '+',
        accent,
        Some(Color::rgb(7, 12, 18)),
        true,
        false,
    );
    put_cell(
        screen,
        area.x + area.w - 1,
        area.y,
        '+',
        accent,
        Some(Color::rgb(7, 12, 18)),
        true,
        false,
    );
    put_cell(
        screen,
        area.x,
        area.y + area.h - 1,
        '+',
        accent,
        Some(Color::rgb(7, 12, 18)),
        true,
        false,
    );
    put_cell(
        screen,
        area.x + area.w - 1,
        area.y + area.h - 1,
        '+',
        accent,
        Some(Color::rgb(7, 12, 18)),
        true,
        false,
    );
    put_text(
        screen,
        area.x + 2,
        area.y,
        title,
        accent.brighten(0.12),
        Some(Color::rgb(7, 12, 18)),
        true,
    );
}

fn fill_rect(screen: &mut Frame, area: Rect, bg: Option<Color>) {
    for y in area.y..(area.y + area.h).min(screen.height()) {
        for x in area.x..(area.x + area.w).min(screen.width()) {
            let mut cell = Cell::new(' ');
            cell.colors.bg = bg;
            screen.set(x, y, cell);
        }
    }
}

fn draw_quote(screen: &mut Frame, area: Rect, quote: &str, accent: Color) {
    let wrapped = wrap_text(quote, area.w);
    put_text(
        screen,
        area.x,
        area.y,
        "SOURCE FROM test.sh:",
        accent,
        Some(Color::rgb(7, 12, 18)),
        true,
    );
    for (line_index, line) in wrapped.lines().take(area.h.saturating_sub(1)).enumerate() {
        put_text(
            screen,
            area.x,
            area.y + line_index + 1,
            line,
            Color::rgb(186, 204, 214),
            Some(Color::rgb(7, 12, 18)),
            false,
        );
    }
}

fn draw_frame_centered(screen: &mut Frame, area: Rect, frame: &Frame) {
    let x = area.x + area.w.saturating_sub(frame.width()) / 2;
    let y = area.y + area.h.saturating_sub(frame.height()) / 2;
    draw_frame(screen, x, y, frame, area.w, area.h);
}

fn draw_frame(screen: &mut Frame, x: usize, y: usize, frame: &Frame, max_w: usize, max_h: usize) {
    for fy in 0..frame.height().min(max_h) {
        for fx in 0..frame.width().min(max_w) {
            if let Some(cell) = frame.cell(fx, fy) {
                if cell.ch != ' ' || cell.has_style() {
                    screen.set(x + fx, y + fy, cell.clone());
                }
            }
        }
    }
}

fn draw_progress_strip(screen: &mut Frame, area: Rect, ratio: f32, fill: Color, empty: Color) {
    let active = (ratio.clamp(0.0, 1.0) * area.w as f32).round() as usize;
    for x in 0..area.w {
        let done = x < active;
        put_cell(
            screen,
            area.x + x,
            area.y,
            if done { '#' } else { '-' },
            if done { fill } else { empty },
            Some(Color::rgb(7, 12, 18)),
            done,
            !done,
        );
    }
}

fn put_text(
    screen: &mut Frame,
    x: usize,
    y: usize,
    text: &str,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
) {
    if y >= screen.height() {
        return;
    }
    for (offset, ch) in text.chars().enumerate() {
        let px = x + offset;
        if px >= screen.width() {
            break;
        }
        put_cell(screen, px, y, ch, fg, bg, bold, false);
    }
}

fn put_text_right(
    screen: &mut Frame,
    right_x: usize,
    y: usize,
    text: &str,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
) {
    let width = text.chars().count();
    let x = right_x.saturating_sub(width);
    put_text(screen, x, y, text, fg, bg, bold);
}

fn put_cell(
    screen: &mut Frame,
    x: usize,
    y: usize,
    ch: char,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
    dim: bool,
) {
    if x >= screen.width() || y >= screen.height() {
        return;
    }
    let mut cell = Cell::new(ch);
    cell.colors.fg = Some(fg);
    cell.colors.bg = bg;
    cell.bold = bold;
    cell.dim = dim;
    screen.set(x, y, cell);
}

fn noise(seed: u64, a: u64, b: u64, c: u64) -> f32 {
    let mut x = seed
        ^ a.wrapping_mul(0x9e37_79b9_7f4a_7c15)
        ^ b.wrapping_mul(0xbf58_476d_1ce4_e5b9)
        ^ c.wrapping_mul(0x94d0_49bb_1331_11eb);
    x ^= x >> 30;
    x = x.wrapping_mul(0xbf58_476d_1ce4_e5b9);
    x ^= x >> 27;
    x = x.wrapping_mul(0x94d0_49bb_1331_11eb);
    let value = (x ^ (x >> 31)) >> 40;
    value as f32 / ((1u64 << 24) - 1) as f32
}

fn terminal_size() -> (usize, usize) {
    let env_size = env::var("COLUMNS")
        .ok()
        .and_then(|columns| columns.parse::<usize>().ok())
        .zip(
            env::var("LINES")
                .ok()
                .and_then(|lines| lines.parse::<usize>().ok()),
        );
    if let Some((columns, lines)) = env_size {
        return (columns, lines);
    }
    let output = Command::new("stty").arg("size").output();
    if let Ok(output) = output {
        if output.status.success() {
            if let Ok(text) = String::from_utf8(output.stdout) {
                let mut parts = text.split_whitespace();
                if let (Some(lines), Some(columns)) = (parts.next(), parts.next()) {
                    if let (Ok(lines), Ok(columns)) =
                        (lines.parse::<usize>(), columns.parse::<usize>())
                    {
                        return (columns, lines);
                    }
                }
            }
        }
    }
    (132, 44)
}

fn usage() {
    println!("Usage:");
    println!("  cargo run --example story -- [--seconds N] [--fps N] [--scene-seconds N] [--once]");
    println!();
    println!("Examples:");
    println!("  ./story.sh");
    println!("  ./story.sh --seconds 90 --fps 12");
    println!("  ./story.sh --once --no-alt");
}

struct TerminalGuard {
    active: bool,
}

impl TerminalGuard {
    fn enter(stdout: &mut io::Stdout, alt_screen: bool) -> Self {
        if alt_screen {
            write!(stdout, "\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H").unwrap();
        } else {
            write!(stdout, "\x1b[?25l\x1b[2J\x1b[H").unwrap();
        }
        stdout.flush().unwrap();
        Self { active: alt_screen }
    }
}

impl Drop for TerminalGuard {
    fn drop(&mut self) {
        let mut stdout = io::stdout();
        if self.active {
            write!(stdout, "\x1b[0m\x1b[?25h\x1b[?1049l").unwrap();
        } else {
            write!(stdout, "\x1b[0m\x1b[?25h\n").unwrap();
        }
        stdout.flush().unwrap();
    }
}