Add a new almost_finish method for Timer with immediate first tick

action

Resolves #21860

This new method would tick the timer by `duration - 1 ns` leaving a
very short waiting time for the first tick initiated by the user allowing
immediate action.

Author: Rajveer100

crates/bevy_time/src/timer.rs

@@ -36,6 +36,7 @@ pub struct Timer {
     duration: Duration,
     mode: TimerMode,
     finished: bool,
+    almost_finished: bool,
     times_finished_this_tick: u32,
 }
 
@@ -206,6 +207,21 @@ impl Timer {
         self.tick(remaining);
     }
 
+    /// Almost finishes the timer leaving 1 ns of remaining time.
+    ///
+    /// # Examples
+    /// ```
+    /// # use bevy_time::*;
+    /// let mut timer = Timer::from_seconds(1.5, TimerMode::Once);
+    /// timer.almost_finish();
+    /// assert!(!timer.is_finished());
+    /// assert_eq!(t.remaining(), Duration::from_nanos(1));
+    /// ```
+    pub fn almost_finish(&mut self) {
+        self.almost_finished = true;
+        self.finish();
+    }
+
     /// Returns the mode of the timer.
     ///
     /// # Examples
@@ -256,7 +272,7 @@ impl Timer {
     /// assert_eq!(timer.elapsed_secs(), 1.0);
     /// assert_eq!(repeating.elapsed_secs(), 0.5);
     /// ```
-    pub fn tick(&mut self, delta: Duration) -> &Self {
+    pub fn tick(&mut self, mut delta: Duration) -> &Self {
         if self.is_paused() {
             self.times_finished_this_tick = 0;
             if self.mode == TimerMode::Repeating {
@@ -270,6 +286,10 @@ impl Timer {
             return self;
         }
 
+        if self.almost_finished {
+            delta -= Duration::from_nanos(1);
+            self.almost_finished = false;
+        }
         self.stopwatch.tick(delta);
         self.finished = self.elapsed() >= self.duration();
 
@@ -628,6 +648,21 @@ mod tests {
         assert_eq!(t.times_finished_this_tick(), 34);
     }
 
+    #[test]
+    fn almost_finished_repeating() {
+        let mut t = Timer::from_seconds(10.0, TimerMode::Repeating);
+        let duration = Duration::from_nanos(1);
+
+        t.almost_finish();
+        assert!(!t.is_finished());
+        assert_eq!(t.times_finished_this_tick(), 0);
+        assert_eq!(t.remaining(), Duration::from_nanos(1));
+
+        t.tick(duration);
+        assert!(t.is_finished());
+        assert_eq!(t.times_finished_this_tick(), 1);
+    }
+
     #[test]
     fn paused() {
         let mut t = Timer::from_seconds(10.0, TimerMode::Once);