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" {
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() {
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())
}