firework_rs::fireworks

Struct FireworkManager

Source 
pub struct FireworkManager {
    pub fireworks: Vec<Firework>,
    pub enable_loop: bool,
    pub install_form: FireworkInstallForm,
}
Expand description

FireworkManager manages all Fireworks

Fields§

§fireworks: Vec<Firework>§enable_loop: bool

If this is true, the whole fireworks show will restart when all the Fireworks are Gone

§install_form: FireworkInstallForm

Controls how fireworks are installed in FireworkManager

Implementations§

Source§

impl FireworkManager

Source

pub fn new(fireworks: Vec<Firework>) -> Self

Create a new FireworkManager with enable_loop set to false

Source

pub fn add_firework(&mut self, firework: Firework)

Add a Firework to a existing FireworkManager

Source

pub fn add_fireworks(&mut self, fireworks: Vec<Firework>)

Add Fireworks to a existing FireworkManager

Source

pub fn with_firework(self, firework: Firework) -> Self

Add a Firework to FireworkManager

Examples found in repository?
examples/heart.rs (lines 34-37)
23fn main() -> Result<()> {
24    let mut stdout = stdout();
25    let (_width, _height) = terminal::size()?;
26    let mut is_running = true;
27    let cfg = Config::default();
28
29    terminal::enable_raw_mode()?;
30    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
31
32    let mut time = SystemTime::now();
33    let mut term = Terminal::default();
34    let mut fm = FireworkManager::default().with_firework(gen_heart_firework(Vec2::new(
35        _width as f32 / 4.,
36        _height as f32 / 2.,
37    )));
38
39    while is_running {
40        if event::poll(Duration::ZERO)? {
41            match event::read()? {
42                event::Event::Key(e) => {
43                    if e.code == KeyCode::Esc {
44                        is_running = false;
45                    }
46                }
47                event::Event::Resize(_, _) => {
48                    fm.reset();
49                    term.reinit(&cfg);
50                }
51                _ => {}
52            };
53        }
54
55        let delta_time = SystemTime::now().duration_since(time).unwrap();
56        fm.update(time, delta_time);
57        time = SystemTime::now();
58
59        term.render(&fm, &cfg);
60        term.print(&mut stdout, &cfg);
61
62        if delta_time < Duration::from_secs_f32(0.05) {
63            let rem = Duration::from_secs_f32(0.05) - delta_time;
64            sleep(rem);
65        }
66    }
67
68    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
69    terminal::disable_raw_mode()?;
70
71    Ok(())
72}
More examples
Hide additional examples
examples/vortex.rs (lines 33-36)
22fn main() -> Result<()> {
23    let mut stdout = stdout();
24    let (_width, _height) = terminal::size()?;
25    let mut is_running = true;
26    let cfg = Config::default();
27
28    terminal::enable_raw_mode()?;
29    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
30
31    let mut time = SystemTime::now();
32    let mut term = Terminal::default();
33    let mut fm = FireworkManager::default().with_firework(gen_vortex_firework(Vec2::new(
34        _width as f32 / 4.,
35        _height as f32 / 2.,
36    )));
37
38    while is_running {
39        if event::poll(Duration::ZERO)? {
40            match event::read()? {
41                event::Event::Key(e) => {
42                    if e.code == KeyCode::Esc {
43                        is_running = false;
44                    }
45                }
46                event::Event::Resize(_, _) => {
47                    fm.reset();
48                    term.reinit(&cfg);
49                }
50                _ => {}
51            };
52        }
53
54        let delta_time = SystemTime::now().duration_since(time).unwrap();
55        fm.update(time, delta_time);
56        time = SystemTime::now();
57
58        term.render(&fm, &cfg);
59        term.print(&mut stdout, &cfg);
60
61        if delta_time < Duration::from_secs_f32(0.05) {
62            let rem = Duration::from_secs_f32(0.05) - delta_time;
63            sleep(rem);
64        }
65    }
66
67    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
68    terminal::disable_raw_mode()?;
69
70    Ok(())
71}
examples/fountain.rs (lines 34-37)
23fn main() -> Result<()> {
24    let mut stdout = stdout();
25    let (_width, _height) = terminal::size()?;
26    let mut is_running = true;
27    let cfg = Config::default();
28
29    terminal::enable_raw_mode()?;
30    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
31
32    let mut time = SystemTime::now();
33    let mut term = Terminal::default();
34    let mut fm = FireworkManager::default().with_firework(gen_fountain_firework(Vec2::new(
35        _width as f32 / 4.,
36        _height as f32 / 2. + 13.,
37    )));
38
39    while is_running {
40        if event::poll(Duration::ZERO)? {
41            match event::read()? {
42                event::Event::Key(e) => {
43                    if e.code == KeyCode::Esc {
44                        is_running = false;
45                    }
46                }
47                event::Event::Resize(_, _) => {
48                    fm.reset();
49                    term.reinit(&cfg);
50                }
51                _ => {}
52            };
53        }
54
55        let delta_time = SystemTime::now().duration_since(time).unwrap();
56        fm.update(time, delta_time);
57        time = SystemTime::now();
58
59        term.render(&fm, &cfg);
60        term.print(&mut stdout, &cfg);
61
62        if delta_time < Duration::from_secs_f32(0.05) {
63            let rem = Duration::from_secs_f32(0.05) - delta_time;
64            sleep(rem);
65        }
66    }
67
68    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
69    terminal::disable_raw_mode()?;
70
71    Ok(())
72}
Source

pub fn with_fireworks(self, fireworks: Vec<Firework>) -> Self

Source

pub fn enable_loop(self) -> Self

Set enable_loop to true

Source

pub fn disable_loop(self) -> Self

Set enable_loop to false

Source

pub fn reset(&mut self)

Reset the whole fireworks show

Examples found in repository?
examples/heart.rs (line 48)
23fn main() -> Result<()> {
24    let mut stdout = stdout();
25    let (_width, _height) = terminal::size()?;
26    let mut is_running = true;
27    let cfg = Config::default();
28
29    terminal::enable_raw_mode()?;
30    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
31
32    let mut time = SystemTime::now();
33    let mut term = Terminal::default();
34    let mut fm = FireworkManager::default().with_firework(gen_heart_firework(Vec2::new(
35        _width as f32 / 4.,
36        _height as f32 / 2.,
37    )));
38
39    while is_running {
40        if event::poll(Duration::ZERO)? {
41            match event::read()? {
42                event::Event::Key(e) => {
43                    if e.code == KeyCode::Esc {
44                        is_running = false;
45                    }
46                }
47                event::Event::Resize(_, _) => {
48                    fm.reset();
49                    term.reinit(&cfg);
50                }
51                _ => {}
52            };
53        }
54
55        let delta_time = SystemTime::now().duration_since(time).unwrap();
56        fm.update(time, delta_time);
57        time = SystemTime::now();
58
59        term.render(&fm, &cfg);
60        term.print(&mut stdout, &cfg);
61
62        if delta_time < Duration::from_secs_f32(0.05) {
63            let rem = Duration::from_secs_f32(0.05) - delta_time;
64            sleep(rem);
65        }
66    }
67
68    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
69    terminal::disable_raw_mode()?;
70
71    Ok(())
72}
More examples
Hide additional examples
examples/vortex.rs (line 47)
22fn main() -> Result<()> {
23    let mut stdout = stdout();
24    let (_width, _height) = terminal::size()?;
25    let mut is_running = true;
26    let cfg = Config::default();
27
28    terminal::enable_raw_mode()?;
29    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
30
31    let mut time = SystemTime::now();
32    let mut term = Terminal::default();
33    let mut fm = FireworkManager::default().with_firework(gen_vortex_firework(Vec2::new(
34        _width as f32 / 4.,
35        _height as f32 / 2.,
36    )));
37
38    while is_running {
39        if event::poll(Duration::ZERO)? {
40            match event::read()? {
41                event::Event::Key(e) => {
42                    if e.code == KeyCode::Esc {
43                        is_running = false;
44                    }
45                }
46                event::Event::Resize(_, _) => {
47                    fm.reset();
48                    term.reinit(&cfg);
49                }
50                _ => {}
51            };
52        }
53
54        let delta_time = SystemTime::now().duration_since(time).unwrap();
55        fm.update(time, delta_time);
56        time = SystemTime::now();
57
58        term.render(&fm, &cfg);
59        term.print(&mut stdout, &cfg);
60
61        if delta_time < Duration::from_secs_f32(0.05) {
62            let rem = Duration::from_secs_f32(0.05) - delta_time;
63            sleep(rem);
64        }
65    }
66
67    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
68    terminal::disable_raw_mode()?;
69
70    Ok(())
71}
examples/fountain.rs (line 48)
23fn main() -> Result<()> {
24    let mut stdout = stdout();
25    let (_width, _height) = terminal::size()?;
26    let mut is_running = true;
27    let cfg = Config::default();
28
29    terminal::enable_raw_mode()?;
30    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
31
32    let mut time = SystemTime::now();
33    let mut term = Terminal::default();
34    let mut fm = FireworkManager::default().with_firework(gen_fountain_firework(Vec2::new(
35        _width as f32 / 4.,
36        _height as f32 / 2. + 13.,
37    )));
38
39    while is_running {
40        if event::poll(Duration::ZERO)? {
41            match event::read()? {
42                event::Event::Key(e) => {
43                    if e.code == KeyCode::Esc {
44                        is_running = false;
45                    }
46                }
47                event::Event::Resize(_, _) => {
48                    fm.reset();
49                    term.reinit(&cfg);
50                }
51                _ => {}
52            };
53        }
54
55        let delta_time = SystemTime::now().duration_since(time).unwrap();
56        fm.update(time, delta_time);
57        time = SystemTime::now();
58
59        term.render(&fm, &cfg);
60        term.print(&mut stdout, &cfg);
61
62        if delta_time < Duration::from_secs_f32(0.05) {
63            let rem = Duration::from_secs_f32(0.05) - delta_time;
64            sleep(rem);
65        }
66    }
67
68    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
69    terminal::disable_raw_mode()?;
70
71    Ok(())
72}
Source

pub fn set_enable_loop(&mut self, enable_loop: bool)

Source

pub fn update(&mut self, now: SystemTime, delta_time: Duration)

The main update function

Examples found in repository?
examples/heart.rs (line 56)
23fn main() -> Result<()> {
24    let mut stdout = stdout();
25    let (_width, _height) = terminal::size()?;
26    let mut is_running = true;
27    let cfg = Config::default();
28
29    terminal::enable_raw_mode()?;
30    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
31
32    let mut time = SystemTime::now();
33    let mut term = Terminal::default();
34    let mut fm = FireworkManager::default().with_firework(gen_heart_firework(Vec2::new(
35        _width as f32 / 4.,
36        _height as f32 / 2.,
37    )));
38
39    while is_running {
40        if event::poll(Duration::ZERO)? {
41            match event::read()? {
42                event::Event::Key(e) => {
43                    if e.code == KeyCode::Esc {
44                        is_running = false;
45                    }
46                }
47                event::Event::Resize(_, _) => {
48                    fm.reset();
49                    term.reinit(&cfg);
50                }
51                _ => {}
52            };
53        }
54
55        let delta_time = SystemTime::now().duration_since(time).unwrap();
56        fm.update(time, delta_time);
57        time = SystemTime::now();
58
59        term.render(&fm, &cfg);
60        term.print(&mut stdout, &cfg);
61
62        if delta_time < Duration::from_secs_f32(0.05) {
63            let rem = Duration::from_secs_f32(0.05) - delta_time;
64            sleep(rem);
65        }
66    }
67
68    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
69    terminal::disable_raw_mode()?;
70
71    Ok(())
72}
More examples
Hide additional examples
examples/vortex.rs (line 55)
22fn main() -> Result<()> {
23    let mut stdout = stdout();
24    let (_width, _height) = terminal::size()?;
25    let mut is_running = true;
26    let cfg = Config::default();
27
28    terminal::enable_raw_mode()?;
29    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
30
31    let mut time = SystemTime::now();
32    let mut term = Terminal::default();
33    let mut fm = FireworkManager::default().with_firework(gen_vortex_firework(Vec2::new(
34        _width as f32 / 4.,
35        _height as f32 / 2.,
36    )));
37
38    while is_running {
39        if event::poll(Duration::ZERO)? {
40            match event::read()? {
41                event::Event::Key(e) => {
42                    if e.code == KeyCode::Esc {
43                        is_running = false;
44                    }
45                }
46                event::Event::Resize(_, _) => {
47                    fm.reset();
48                    term.reinit(&cfg);
49                }
50                _ => {}
51            };
52        }
53
54        let delta_time = SystemTime::now().duration_since(time).unwrap();
55        fm.update(time, delta_time);
56        time = SystemTime::now();
57
58        term.render(&fm, &cfg);
59        term.print(&mut stdout, &cfg);
60
61        if delta_time < Duration::from_secs_f32(0.05) {
62            let rem = Duration::from_secs_f32(0.05) - delta_time;
63            sleep(rem);
64        }
65    }
66
67    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
68    terminal::disable_raw_mode()?;
69
70    Ok(())
71}
examples/fountain.rs (line 56)
23fn main() -> Result<()> {
24    let mut stdout = stdout();
25    let (_width, _height) = terminal::size()?;
26    let mut is_running = true;
27    let cfg = Config::default();
28
29    terminal::enable_raw_mode()?;
30    execute!(stdout, terminal::EnterAlternateScreen, cursor::Hide)?;
31
32    let mut time = SystemTime::now();
33    let mut term = Terminal::default();
34    let mut fm = FireworkManager::default().with_firework(gen_fountain_firework(Vec2::new(
35        _width as f32 / 4.,
36        _height as f32 / 2. + 13.,
37    )));
38
39    while is_running {
40        if event::poll(Duration::ZERO)? {
41            match event::read()? {
42                event::Event::Key(e) => {
43                    if e.code == KeyCode::Esc {
44                        is_running = false;
45                    }
46                }
47                event::Event::Resize(_, _) => {
48                    fm.reset();
49                    term.reinit(&cfg);
50                }
51                _ => {}
52            };
53        }
54
55        let delta_time = SystemTime::now().duration_since(time).unwrap();
56        fm.update(time, delta_time);
57        time = SystemTime::now();
58
59        term.render(&fm, &cfg);
60        term.print(&mut stdout, &cfg);
61
62        if delta_time < Duration::from_secs_f32(0.05) {
63            let rem = Duration::from_secs_f32(0.05) - delta_time;
64            sleep(rem);
65        }
66    }
67
68    execute!(stdout, cursor::Show, terminal::LeaveAlternateScreen)?;
69    terminal::disable_raw_mode()?;
70
71    Ok(())
72}
Source

pub fn enable_dyn_install(self) -> Self

Set install_form to DynamicInstall

Trait Implementations§

Source§

impl Default for FireworkManager

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V