matrixr 1.1.0

Animated Matrix-style terminal screensaver
Documentation
mod console_font;
mod runtime;
mod timing;

use std::env;
use std::io;
use std::process;
use std::thread;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

use crossterm::SynchronizedUpdate;
use crossterm::event::{self, Event};
use crossterm::terminal;
use rand::{SeedableRng, rngs::SmallRng};
use thiserror::Error;

use crate::config::Config;
use crate::engine::MatrixState;
use crate::renderer::{MessagePosition, clear_screen, erase_message_overlay, render_frame};
use crate::terminal::Terminal;

use self::console_font::ConsoleFontGuard;
use self::runtime::{LoopControl, RuntimeState};
use self::timing::TimingController;

#[derive(Debug, Error)]
pub enum AppError {
    #[error("{0}")]
    Message(String),
    #[error("{0}")]
    Io(#[from] io::Error),
}

pub fn run(config: Config) -> Result<(), AppError> {
    if config.force_linux_term && env::var("TERM").unwrap_or_default() != "linux" {
        // SAFETY: matrixr is single-threaded, and this runs before terminal initialization.
        unsafe { env::set_var("TERM", "linux") };
    }

    let _console_font = ConsoleFontGuard::new(config.console)?;
    let mut terminal = Terminal::new(config.tty.as_deref())?;
    let mut rng = SmallRng::seed_from_u64(runtime_seed());

    let (width, height) = terminal::size().unwrap_or((80, 24));
    let mut matrix = MatrixState::new(width, height, &mut rng);
    let mut runtime = RuntimeState::from_config(config);
    let mut last_overlay_message: Option<(String, MessagePosition)> = None;
    let mut tick: u8 = 0;
    let mut needs_redraw = true;
    let mut timing = TimingController::new(Instant::now());

    loop {
        if event::poll(Duration::ZERO)? {
            match event::read()? {
                Event::Key(key) => {
                    let previous_update_delay = runtime.update_delay();
                    let shortcuts_were_visible = runtime.shortcuts_visible();
                    let control = runtime.handle_key(key, matrix.height() as u16);
                    if control == LoopControl::Quit {
                        return Ok(());
                    }

                    if shortcuts_were_visible && !runtime.shortcuts_visible() {
                        // Rain skips alternate columns, so erase popup text between the streams.
                        needs_redraw = true;
                    }

                    let now = Instant::now();
                    if runtime.update_delay() != previous_update_delay {
                        timing.next_simulation = now;
                    }
                    if control == LoopControl::RefreshRender || needs_redraw {
                        timing.next_render = now;
                    }
                }
                Event::Resize(new_width, new_height) => {
                    matrix.resize(new_width, new_height, &mut rng);
                    needs_redraw = true;
                }
                _ => {}
            }
        }

        let now = Instant::now();
        for _ in 0..timing.take_simulation_steps(now, runtime.update_delay()) {
            tick += 1;
            if tick > 4 {
                tick = 1;
            }
            matrix.step(tick, &runtime.engine_flags(), runtime.charset(), &mut rng);
        }

        let render_now = Instant::now();
        if timing.take_render_due(render_now, runtime.render_fps()) {
            terminal.writer().sync_update(|writer| -> io::Result<()> {
                if needs_redraw {
                    clear_screen(writer)?;
                    needs_redraw = false;
                }

                let current_overlay_message = runtime.message_for_render(render_now);
                let previous_overlay_key = last_overlay_message
                    .as_ref()
                    .map(|(text, position)| (text.as_str(), *position));

                if current_overlay_message != previous_overlay_key {
                    if let Some((previous_message, position)) = last_overlay_message.as_ref() {
                        erase_message_overlay(writer, &matrix, previous_message, *position)?;
                    }
                    last_overlay_message =
                        current_overlay_message.map(|(text, position)| (text.to_owned(), position));
                }

                render_frame(
                    writer,
                    &matrix,
                    &runtime.render_options(current_overlay_message),
                    &mut rng,
                )
            })??;
        }

        thread::sleep(timing.sleep_duration(Instant::now(), runtime.update_delay()));
    }
}

fn runtime_seed() -> u64 {
    let elapsed = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default();

    elapsed.as_secs().rotate_left(32) ^ u64::from(elapsed.subsec_nanos()) ^ u64::from(process::id())
}