Merge pull request #20 from ckaznable/tick_rate

feat: add --tps flags

Author: ckaznable

README.md

@@ -44,7 +44,8 @@ Usage: tenki [OPTIONS]
 
 Options:
       --mode <MODE>    [default: rain] [rain, snow, meteor]
-      --fps <FPS>      [default: 60] [1-60]
+      --fps <FPS>      Frame Per Second [default: 60] [1-240]
+      --tps <TPS>      Tick Per Second [default: 60] [1-240]
       --show-fps       Show fps at right-top in screen
       --timer-color    <COLOR>  Timer color [default: white] [red, green, blue, yellow, cyan, magenta, white, black]
       --wind <WIND>    Decide on the direction of the rain/snow [defualt: random] [random, disable, only-right, only-left, right, left]

src/app.rs

@@ -44,7 +44,7 @@ where
             terminal,
             state,
             args,
-            tui: Tui::new(args.fps as f64)?,
+            tui: Tui::new(args.fps as f64, args.tps as f64)?,
             should_quit: false,
             frame_in_second: 0,
             runtime_info: AppRuntimeInfo { fps: 0 },
@@ -60,8 +60,9 @@ where
                 match event {
                     Init => (),
                     Quit | Error => self.should_quit = true,
-                    Render => self.on_render(),
+                    Render => self.on_render()?,
                     Key(key) => self.handle_keyboard(key),
+                    Tick => self.on_tick(),
                     Timer => self.on_timer(),
                     Resize(columns, rows) => self.state.on_resize(columns, rows),
                 };
@@ -70,8 +71,6 @@ where
             if self.should_quit {
                 break;
             }
-
-            self.terminal.draw(|f| ui(f, &mut self.state, self.args, self.runtime_info))?;
         }
 
         Ok(())
@@ -84,11 +83,20 @@ where
         }
     }
 
-    fn on_render(&mut self) {
+    fn on_tick(&mut self) {
         self.state.tick();
         self.frame_in_second = self.frame_in_second.saturating_add(1);
     }
 
+    fn on_render(&mut self) -> anyhow::Result<()> {
+        if self.args.fps == self.args.tps {
+            self.on_tick()
+        }
+
+        self.terminal.draw(|f| ui(f, &mut self.state, self.args, self.runtime_info))?;
+        Ok(())
+    }
+
     fn on_timer(&mut self) {
         self.state.tick_timer();
         self.runtime_info.fps = self.frame_in_second;

src/cli.rs

@@ -12,12 +12,17 @@ pub struct Args {
     #[arg(long, default_value_t = Mode::Rain)]
     pub mode: Mode,
 
-    #[arg(long, value_parser = fps_range, default_value_t = 60)]
+    /// frame per second
+    #[arg(long, value_parser = process_rate_range, default_value_t = 60)]
     pub fps: u8,
 
+    /// tick per second
+    #[arg(long, value_parser = process_rate_range, default_value_t = 60)]
+    pub tps: u8,
+
     /// effect level, The lower, the stronger [4-1000]
-    #[arg(short, long, value_parser = level_range, default_value_t = 0)]
-    pub level: u16,
+    #[arg(short, long, value_parser = level_range)]
+    pub level: Option<u16>,
 
     /// color of the effect. [red, green, blue, yellow, cyan, magenta, white, black]
     #[arg(long, value_parser = Color::from_str, default_value = "white")]
@@ -32,8 +37,8 @@ pub struct Args {
     pub show_fps: bool,
 }
 
-fn fps_range(s: &str) -> Result<u8, String> {
-    number_range(s, 1, 60)
+fn process_rate_range(s: &str) -> Result<u8, String> {
+    number_range(s, 1, 240)
 }
 
 fn level_range(s: &str) -> Result<u16, String> {

src/tui.rs

@@ -15,44 +15,51 @@ pub enum Event {
     Quit,
     Error,
     Render,
+    Tick,
     Timer,
     Key(KeyEvent),
     Resize(u16, u16),
 }
 
 pub struct Tui {
     frame_rate: f64,
+    tick_rate: f64,
     event_rx: UnboundedReceiver<Event>,
     event_tx: UnboundedSender<Event>,
     task: Option<JoinHandle<()>>,
 }
 
 impl Tui {
-    pub fn new(frame_rate: f64) -> Result<Self> {
+    pub fn new(frame_rate: f64, tick_rate: f64) -> Result<Self> {
         let (event_tx, event_rx) = mpsc::unbounded_channel();
         let task = None;
         Ok(Self {
             task,
             event_rx,
             event_tx,
             frame_rate,
+            tick_rate,
         })
     }
 
     pub fn run(&mut self) {
         let render_delay = std::time::Duration::from_secs_f64(1.0 / self.frame_rate);
+        let tick_delay = std::time::Duration::from_secs_f64(1.0 / self.tick_rate);
         let timer_delay = std::time::Duration::from_secs_f64(1.0);
         let _event_tx = self.event_tx.clone();
+        let do_tick = self.frame_rate != self.tick_rate;
 
         let task = tokio::spawn(async move {
             _event_tx.send(Event::Init).unwrap();
             waiting_time_to_sync();
 
             let mut reader = crossterm::event::EventStream::new();
             let mut render_interval = tokio::time::interval(render_delay);
+            let mut tick_interval = tokio::time::interval(tick_delay);
             let mut timer_interval = tokio::time::interval(timer_delay);
 
             loop {
+                let tick_delay = tick_interval.tick();
                 let render_delay = render_interval.tick();
                 let timer_delay = timer_interval.tick();
                 let crossterm_event = reader.next().fuse();
@@ -78,6 +85,11 @@ impl Tui {
                             None => (),
                         }
                     },
+                    _ = tick_delay => {
+                        if do_tick {
+                            _event_tx.send(Event::Tick).unwrap();
+                        }
+                    },
                     _ = render_delay => {
                         _event_tx.send(Event::Render).unwrap();
                     },

src/weather/dropping.rs

@@ -19,7 +19,7 @@ impl GeneralDropping {
         Self {
             wind: WindState::new(args.wind),
             dropping: DroppingState {
-                threshold: if args.level == 0 { DEF_LEVEL } else { args.level },
+                threshold: args.level.unwrap_or(DEF_LEVEL),
                 mode: args.mode,
             },
         }
@@ -60,7 +60,7 @@ impl TailDropping {
             wind: WindState::new(args.wind.without_random()),
             tail: TailState::new(args.wind.into()),
             dropping: DroppingState {
-                threshold: if args.level == 0 { DEF_TAIL_LEVEL } else { args.level },
+                threshold: args.level.unwrap_or(DEF_TAIL_LEVEL),
                 mode: args.mode,
             },
         }