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 }

    }

}