matrixr 1.1.0

Animated Matrix-style terminal screensaver
Documentation
use std::time::{Duration, Instant};

use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyModifiers};

use crate::color::MatrixColor;
use crate::config::{BoldMode, Config};
use crate::engine::{Charset, EngineFlags};
use crate::help::{popup_max_scroll, popup_page_size};
use crate::renderer::{MessagePosition, RenderOptions};

const LOCK_MESSAGE_DISPLAY_DURATION: Duration = Duration::from_secs(3);
const STATUS_MESSAGE_DISPLAY_DURATION: Duration = Duration::from_secs(1);
const LOCK_MESSAGE_TEXT: &str = "Computer locked";
const UNLOCK_MESSAGE_TEXT: &str = "Computer unlocked";
const DEFAULT_RENDER_FPS: u16 = 60;
const MIN_RENDER_FPS: u16 = 1;
const MAX_RENDER_FPS: u16 = 120;

pub(super) struct RuntimeState {
    lock: bool,
    screensaver: bool,
    asynchronous: bool,
    deep: bool,
    bold: BoldMode,
    old_style: bool,
    update_delay: u64,
    render_fps: u16,
    color: MatrixColor,
    rainbow: bool,
    lambda_mode: bool,
    dynamic_chars: bool,
    paused: bool,
    classic: bool,
    xwindow: bool,
    console: bool,
    transient_message: Option<TimedMessage>,
    shortcuts_scroll: Option<usize>,
}

impl RuntimeState {
    pub(super) fn from_config(config: Config) -> Self {
        let transient_message = config
            .lock
            .then(|| TimedMessage::centered(LOCK_MESSAGE_TEXT));

        Self {
            lock: config.lock,
            screensaver: config.screensaver,
            asynchronous: config.asynchronous,
            deep: config.deep,
            bold: config.bold,
            old_style: config.old_style,
            update_delay: config.update_delay,
            render_fps: DEFAULT_RENDER_FPS,
            color: config.color,
            rainbow: config.rainbow,
            lambda_mode: config.lambda_mode,
            dynamic_chars: config.dynamic_chars,
            paused: false,
            classic: config.classic,
            xwindow: config.xwindow,
            console: config.console,
            transient_message,
            shortcuts_scroll: None,
        }
    }

    pub(super) fn update_delay(&self) -> u64 {
        self.update_delay
    }

    pub(super) fn render_fps(&self) -> u16 {
        self.render_fps
    }

    pub(super) fn shortcuts_visible(&self) -> bool {
        self.shortcuts_scroll.is_some()
    }

    pub(super) fn engine_flags(&self) -> EngineFlags {
        EngineFlags {
            asynchronous: self.asynchronous,
            deep: self.deep,
            old_style: self.old_style,
            dynamic_chars: self.dynamic_chars,
            paused: self.paused,
        }
    }

    pub(super) fn charset(&self) -> Charset {
        Charset::from_modes(self.classic, self.console || self.xwindow)
            .with_lambda_mode(self.lambda_mode)
    }

    pub(super) fn render_options<'a>(
        &self,
        message: Option<(&'a str, MessagePosition)>,
    ) -> RenderOptions<'a> {
        RenderOptions {
            bold: self.bold,
            color: self.color,
            rainbow: self.rainbow,
            deep: self.deep,
            console_or_xwindow: self.console || self.xwindow,
            old_style: self.old_style,
            message,
            shortcuts_scroll: self.shortcuts_scroll,
        }
    }

    pub(super) fn handle_key(&mut self, key: KeyEvent, rows: u16) -> LoopControl {
        let code = match key.code {
            KeyCode::Char(ch) => KeyCode::Char(normalize_runtime_hotkey(ch, key.modifiers)),
            code => code,
        };

        match key.kind {
            KeyEventKind::Press => {}
            KeyEventKind::Repeat
                if matches!(code, KeyCode::Char('d' | 'f'))
                    || (self.shortcuts_visible()
                        && matches!(
                            code,
                            KeyCode::Up
                                | KeyCode::Down
                                | KeyCode::PageUp
                                | KeyCode::PageDown
                                | KeyCode::Home
                                | KeyCode::End
                        )) => {}
            _ => return LoopControl::Continue,
        }

        if self.screensaver {
            return LoopControl::Quit;
        }

        if code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL) {
            if !self.lock {
                return LoopControl::Quit;
            }
            return LoopControl::Continue;
        }

        if self.handle_shortcuts_key(KeyEvent { code, ..key }, rows) {
            return LoopControl::RefreshRender;
        }

        let KeyCode::Char(ch) = code else {
            return LoopControl::Continue;
        };

        match ch {
            'q' if !self.lock => LoopControl::Quit,
            'D' => {
                self.deep = !self.deep;
                self.show_status_message(toggle_status_message("Deep", self.deep));
                LoopControl::RefreshRender
            }
            'a' => {
                self.asynchronous = !self.asynchronous;
                self.show_status_message(toggle_status_message("Asynchronous", self.asynchronous));
                LoopControl::RefreshRender
            }
            'b' if self.bold != BoldMode::Random => {
                self.bold = BoldMode::Random;
                self.show_status_message("Bold: random".to_owned());
                LoopControl::RefreshRender
            }
            'B' if self.bold != BoldMode::All => {
                self.bold = BoldMode::All;
                self.show_status_message("Bold: all".to_owned());
                LoopControl::RefreshRender
            }
            'k' => {
                self.dynamic_chars = !self.dynamic_chars;
                self.show_status_message(toggle_status_message(
                    "Dynamic chars",
                    self.dynamic_chars,
                ));
                LoopControl::RefreshRender
            }
            'o' => {
                self.old_style = !self.old_style;
                self.show_status_message(toggle_status_message("Old style", self.old_style));
                LoopControl::RefreshRender
            }
            'L' => {
                self.toggle_lock();
                LoopControl::RefreshRender
            }
            'n' if self.bold != BoldMode::None => {
                self.bold = BoldMode::None;
                self.show_status_message("Bold: off".to_owned());
                LoopControl::RefreshRender
            }
            '0'..='9' => {
                let update_delay = (ch as u8 - b'0') as u64;
                if update_delay == self.update_delay {
                    return LoopControl::Continue;
                }
                self.update_delay = update_delay;
                self.show_status_message(format!("Speed: {update_delay} (0-9)"));
                LoopControl::RefreshRender
            }
            'd' => self.update_render_fps(self.render_fps.saturating_sub(1).max(MIN_RENDER_FPS)),
            'f' => self.update_render_fps(self.render_fps.saturating_add(1).min(MAX_RENDER_FPS)),
            'r' => {
                self.rainbow = !self.rainbow;
                self.show_status_message(toggle_status_message("Rainbow", self.rainbow));
                LoopControl::RefreshRender
            }
            'm' => {
                self.lambda_mode = !self.lambda_mode;
                self.show_status_message(toggle_status_message("Lambda", self.lambda_mode));
                LoopControl::RefreshRender
            }
            'p' | 'P' => {
                self.paused = !self.paused;
                let state = if self.paused { "paused" } else { "running" };
                self.show_status_message(format!("Animation: {state}"));
                LoopControl::RefreshRender
            }
            'c' if !self.lock => {
                self.classic = !self.classic;
                self.show_status_message(toggle_status_message("Classic", self.classic));
                LoopControl::RefreshRender
            }
            'x' => {
                self.xwindow = !self.xwindow;
                self.show_status_message(toggle_status_message("X window", self.xwindow));
                LoopControl::RefreshRender
            }
            _ => {
                let Some(color) = MatrixColor::from_hotkey(ch) else {
                    return LoopControl::Continue;
                };
                if color == self.color && !self.rainbow {
                    return LoopControl::Continue;
                }
                self.color = color;
                self.rainbow = false;
                self.show_status_message(format!("Color: {color:?}"));
                LoopControl::RefreshRender
            }
        }
    }

    fn handle_shortcuts_key(&mut self, key: KeyEvent, rows: u16) -> bool {
        if matches!(key.code, KeyCode::Char('~')) {
            self.shortcuts_scroll = self.shortcuts_scroll.is_none().then_some(0);
            return true;
        }

        let Some(scroll) = self.shortcuts_scroll.as_mut() else {
            return false;
        };
        if key.modifiers.is_empty() {
            let max_scroll = popup_max_scroll(rows);
            let current = (*scroll).min(max_scroll);
            let next = match key.code {
                KeyCode::Up => Some(current.saturating_sub(1)),
                KeyCode::Down => Some(current.saturating_add(1).min(max_scroll)),
                KeyCode::PageUp => Some(current.saturating_sub(popup_page_size(rows))),
                KeyCode::PageDown => Some(
                    current
                        .saturating_add(popup_page_size(rows))
                        .min(max_scroll),
                ),
                KeyCode::Home => Some(0),
                KeyCode::End => Some(max_scroll),
                _ => None,
            };
            if let Some(next) = next {
                *scroll = next;
                return true;
            }
        }

        self.shortcuts_scroll = None;
        matches!(key.code, KeyCode::Esc)
    }

    pub(super) fn message_for_render(&self, now: Instant) -> Option<(&str, MessagePosition)> {
        self.transient_message
            .as_ref()
            .filter(|message| now <= message.visible_until)
            .map(|message| (message.text.as_str(), message.position))
    }

    fn update_render_fps(&mut self, render_fps: u16) -> LoopControl {
        self.render_fps = render_fps;
        self.show_status_message(format!("FPS: {render_fps} (d-/f+)"));
        LoopControl::RefreshRender
    }

    fn toggle_lock(&mut self) {
        self.lock = !self.lock;
        let text = if self.lock {
            LOCK_MESSAGE_TEXT
        } else {
            UNLOCK_MESSAGE_TEXT
        };
        self.transient_message = Some(TimedMessage::centered(text));
    }

    fn show_status_message(&mut self, text: String) {
        self.transient_message = Some(TimedMessage {
            text,
            visible_until: Instant::now() + STATUS_MESSAGE_DISPLAY_DURATION,
            position: MessagePosition::TopRight,
        });
    }
}

#[derive(Debug, PartialEq)]
pub(super) enum LoopControl {
    Continue,
    RefreshRender,
    Quit,
}

struct TimedMessage {
    text: String,
    visible_until: Instant,
    position: MessagePosition,
}

impl TimedMessage {
    fn centered(text: &str) -> Self {
        Self {
            text: text.to_owned(),
            visible_until: Instant::now() + LOCK_MESSAGE_DISPLAY_DURATION,
            position: MessagePosition::Center,
        }
    }
}

fn normalize_runtime_hotkey(ch: char, modifiers: KeyModifiers) -> char {
    if modifiers.contains(KeyModifiers::SHIFT) {
        match ch {
            '"' => return '@',
            '№' => return '#',
            ';' => return '$',
            ':' => return '^',
            '?' => return '&',
            _ => {}
        }
    }

    match ch {
        'Ё' => '~',
        'й' => 'q',
        'Й' => 'Q',
        'ф' => 'a',
        'Ф' => 'A',
        'в' => 'd',
        'В' => 'D',
        'а' => 'f',
        'А' => 'F',
        'и' => 'b',
        'И' => 'B',
        'л' => 'k',
        'Л' => 'K',
        'щ' => 'o',
        'Щ' => 'O',
        'д' => 'l',
        'Д' => 'L',
        'т' => 'n',
        'Т' => 'N',
        'к' => 'r',
        'К' => 'R',
        'ь' => 'm',
        'Ь' => 'M',
        'з' => 'p',
        'З' => 'P',
        'с' => 'c',
        'С' => 'C',
        'ч' => 'x',
        'Ч' => 'X',
        _ => ch,
    }
}

fn toggle_status_message(label: &str, enabled: bool) -> String {
    let state = if enabled { "on" } else { "off" };
    format!("{label}: {state}")
}

#[cfg(test)]
mod tests;