Timer tick can lead to a rounding error causing an overflow panic

[jacobgardner]

Bevy version

Confirmed broken on 0.5 and 00d8d5d (HEAD of main at time of bug report)

Operating system & version

Windows 10

What you did

    #[test]
    fn reproduce_bug() {
        let mut t = Timer::from_seconds(0.01, true);
        let duration = Duration::from_secs_f64(1.0 / 3.0);

        t.tick(duration);
        t.tick(duration);
        t.tick(duration);
    }

What you expected to happen

No run-time panic. Roughly the same behavior as seen when using Duration::from_secs_f32

What actually happened

PS E:\bevy\crates\bevy_core> cargo test reproduce_bug
    Blocking waiting for file lock on build directory
   Compiling bevy_core v0.5.0 (E:\bevy\crates\bevy_core)
    Finished test [unoptimized + debuginfo] target(s) in 17.81s
     Running unittests (E:\bevy\target\debug\deps\bevy_core-51c265877747d3ba.exe)

running 1 test
test time::timer::tests::reproduce_bug ... FAILED

failures:

---- time::timer::tests::reproduce_bug stdout ----
thread 'time::timer::tests::reproduce_bug' panicked at 'overflow when subtracting durations', library\core\src\time.rs:890:31
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Additional information

For a fixed timestep, I can work around this by using f32 or changing the offset, but if relying on a non-fixed timestep, I imagine this edge-case will periodically appear.

[jacobgardner]

It looks like Duration's nanosecond precision can cause Timer::percent() to return 1.0 even when it's just barely not quite there yet.

// From bevy_core/src/time/timer.rs:220 - 222

  self.times_finished = self.percent().floor() as u32;
  // Duration does not have a modulo
  self.set_elapsed(self.elapsed() - self.duration() * self.times_finished);

So times_finished should be at 0 still instead of 1 (or whatever rising edge we're at), but because percent's precision was too low it got rounded up prematurely.

[jacobgardner]

All the tests appear to pass when doing integer division directly, i.e.

        if self.finished() {
            if self.repeating() {
                self.times_finished = (self.elapsed().as_nanos() / self.duration.as_nanos()) as u32;
                // Duration does not have a modulo
                self.set_elapsed(self.elapsed() - self.duration() * self.times_finished);
            } else {
                self.times_finished = 1;
                self.set_elapsed(self.duration());
            }
        }