fire-cli-rs 0.1.3

Terminal fire animation written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// Fire-CLI || Github: https://github.com/horizonwiki/fire || v0.1.3 || 2026-04-13
use std::{env, io};

mod terminal;
mod theme;
mod simulation;
mod renderer;
mod input;
mod help;

use terminal::Terminal;
use theme::{Theme, ColorMode};
use help::print_help;
use renderer::run_main_loop;
use fire_cli_rs::{VERSION, BUILD_DATE};

fn main() -> io::Result<()> {
    let args: Vec<String> = env::args().collect();
    let program_name = args.get(0).map(|s| s.as_str()).unwrap_or("fire-cli");

    let mut theme = Theme::std();
    let mut color_mode = ColorMode::Theme;
    let mut fps: u32 = 30;
    let mut use_color = true;
    let mut i = 1;
    
    while i < args.len() {
        match args[i].to_lowercase().as_str() {
            "-t" | "--theme" => {
                if i + 1 < args.len() {
                    let theme_arg = args[i + 1].to_lowercase();
                    let theme_str = theme_arg.as_str();
                    match theme_str {
                        "ash"     => theme = Theme::ash(),
                        "aurora"  => theme = Theme::aurora(),
                        "blue"    => theme = Theme::blue(),
                        "classic" => theme = Theme::classic(),
                        "copper"  => theme = Theme::copper(),
                        "crimson" => theme = Theme::crimson(),
                        "dusk"    => theme = Theme::dusk(),
                        "ember"   => theme = Theme::ember(),
                        "emerald" => theme = Theme::emerald(),
                        "forest"  => theme = Theme::forest(),
                        "frost"   => theme = Theme::frost(),
                        "ghost"   => theme = Theme::ghost(),
                        "gold"    => theme = Theme::gold(),
                        "ice"     => theme = Theme::ice(),
                        "magma"   => theme = Theme::magma(),
                        "nebula"  => theme = Theme::nebula(),
                        "pink"    => theme = Theme::pink(),
                        "plasma"  => theme = Theme::plasma(),
                        "rainbow" => color_mode = ColorMode::Rainbow,
                        "sakura"  => theme = Theme::sakura(),
                        "solar"   => theme = Theme::solar(),
                        "std"     => theme = Theme::std(),
                        "sulfur"  => theme = Theme::sulfur(),

                        "custom"  => {
                            eprintln!("Missing colors after 'custom:'. Example: -t custom:#ff0055.#ffcc00.#ffffff");
                            print_help(program_name);
                            return Ok(());
                        }
                        s if s.starts_with("custom:") => {
                            let input = &s["custom:".len()..];
                            match theme::parse_custom_theme(input) {
                                Some(t) => { theme = t; color_mode = ColorMode::Theme; }
                                None => {
                                    eprintln!("Invalid custom theme. Example: -t custom:#ff0055.#ffcc00.#ffffff");
                                    print_help(program_name);
                                    return Ok(());
                                }
                            }
                        }
                        _ => {
                            eprintln!("Invalid theme: {}", args[i + 1]);
                            print_help(program_name);
                            return Ok(());
                        }
                    }
                    i += 1;
                } else {
                    eprintln!("Missing theme name");
                    print_help(program_name);
                    return Ok(());
                }
            }
            "-f" | "--fps" => {
                if i + 1 < args.len() {
                    if let Ok(f) = args[i + 1].parse::<u32>() {
                        fps = f.clamp(15, 120);
                        i += 1;
                    } else {
                        eprintln!("Invalid FPS value: {}", args[i + 1]);
                        print_help(program_name);
                        return Ok(());
                    }
                } else {
                    eprintln!("Missing FPS value");
                    print_help(program_name);
                    return Ok(());
                }
            }
            "--no-color" | "-n-c" | "--nocolor" => use_color = false,
            "-h" | "--help"  => {
                print_help(program_name);
                return Ok(());
            }
            "-v" | "--version" => {
                println!("fire-cli v{} ({}-{}) built {}",
                VERSION,
                std::env::consts::ARCH,
                std::env::consts::OS,
                BUILD_DATE
                );
                return Ok(());
            }
            _ => {
                eprintln!("Invalid option: {}", args[i]);
                print_help(program_name);
                return Ok(());
            }
        }
        i += 1;
    }

    let _term = Terminal::new()?;
    
    std::panic::set_hook(Box::new(|info| {
        terminal::restore_terminal();
        eprintln!("panic: {}", info);
    }));
    
    run_main_loop(&theme, color_mode, fps, use_color)?;

    Ok(())
}