monolith

/// A plan's place in time. Every phase lasts `phase_ns`.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub struct Timeline {

    pub start_ns: u64,

    pub phase_ns: u64,

    pub phases: usize,

}

#[derive(Clone, Copy, Debug, PartialEq)]

pub enum Position {

    NotStarted,

    /// Inside `phase`, with linear time `t` in [0, 1) before easing.

    Phase {

        phase: usize,

        t: f64,

    },

    Finished,

}

impl Timeline {

    pub fn end_ns(&self) -> u64 {

        self.start_ns + self.phase_ns * self.phases as u64

    }

    pub fn locate(&self, now_ns: u64) -> Position {

        if now_ns < self.start_ns {

            return Position::NotStarted;

        }

        if self.phase_ns == 0 || now_ns >= self.end_ns() {

            return Position::Finished;

        }

        let elapsed = now_ns - self.start_ns;

        let phase = (elapsed / self.phase_ns) as usize;

        let t = (elapsed % self.phase_ns) as f64 / self.phase_ns as f64;

        Position::Phase { phase, t }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn locates_phases() {

        let tl = Timeline {

            start_ns: 1_000,

            phase_ns: 100,

            phases: 3,

        };

        assert_eq!(tl.locate(999), Position::NotStarted);

        assert_eq!(tl.locate(1_000), Position::Phase { phase: 0, t: 0.0 });

        assert_eq!(tl.locate(1_150), Position::Phase { phase: 1, t: 0.5 });

        assert_eq!(tl.locate(1_300), Position::Finished);

    }

    #[test]

    fn total_time_is_phases_times_duration() {

        let tl = Timeline {

            start_ns: 0,

            phase_ns: 160_000_000,

            phases: 4,

        };

        assert_eq!(tl.end_ns(), 640_000_000);

    }

}