matrixr 1.0.0

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

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

use crossterm::event::{self, Event};
use crossterm::terminal;
use rand::thread_rng;
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 = thread_rng();

    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 control = runtime.handle_key(key);
                    if control == LoopControl::Quit {
                        return Ok(());
                    }

                    let now = Instant::now();
                    if runtime.update_delay() != previous_update_delay {
                        timing.next_simulation = now;
                    }
                    if control == LoopControl::RefreshRender {
                        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()) {
            if needs_redraw {
                clear_screen(terminal.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(terminal.writer(), &matrix, previous_message, *position)?;
                }
                last_overlay_message =
                    current_overlay_message.map(|(text, position)| (text.to_owned(), position));
            }

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

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