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;