From 3e3ebc9be09d016c082e6625a6c9b2261a4215d8 Mon Sep 17 00:00:00 2001
From: nertsal <nestralnertsal@gmail.com>
Date: Wed, 23 Oct 2024 21:44:49 +0300
Subject: [PATCH] convert timings (it compiles)

---
 crates/ctl-core/src/legacy/v1.rs      |  4 +-
 crates/ctl-core/src/model/level.rs    | 10 ++--
 crates/ctl-core/src/model/movement.rs |  8 +--
 crates/ctl-core/src/types.rs          | 47 +++++++++++++----
 crates/ctl-server/src/server/group.rs |  2 +-
 src/editor/action/level.rs            | 34 +++++++------
 src/editor/action/state.rs            |  4 +-
 src/editor/config.rs                  |  4 +-
 src/editor/handle_event.rs            |  6 +--
 src/editor/mod.rs                     | 69 ++++++++++++-------------
 src/editor/ui/config.rs               | 72 ++++++++++++++-------------
 src/editor/ui/edit.rs                 | 40 +++++++++------
 src/game.rs                           |  6 +--
 src/local/cache.rs                    |  2 +-
 src/local/fs.rs                       | 16 ++++--
 src/local/fs/native.rs                |  7 ++-
 src/media.rs                          |  6 +--
 src/menu/level.rs                     | 20 ++++----
 src/menu/main.rs                      | 10 ++--
 src/menu/splash.rs                    |  6 +--
 src/model/level/config.rs             | 14 +++---
 src/model/level/state.rs              | 26 +++++-----
 src/model/logic/event.rs              |  2 +-
 src/model/logic/mod.rs                | 35 +++++++------
 src/model/mod.rs                      | 34 ++++++-------
 src/model/player.rs                   | 10 ++--
 src/model/score.rs                    |  6 +--
 src/render/dither.rs                  |  2 +-
 src/render/editor/game.rs             | 20 ++++----
 src/render/editor/ui.rs               |  8 +--
 src/render/game.rs                    |  2 +-
 src/render/mod.rs                     |  4 +-
 src/render/util.rs                    |  4 +-
 src/ui/widget/timeline.rs             | 35 ++++++-------
 34 files changed, 313 insertions(+), 262 deletions(-)

diff --git a/crates/ctl-core/src/legacy/v1.rs b/crates/ctl-core/src/legacy/v1.rs
index c57b14b9..ad2a08f6 100644
--- a/crates/ctl-core/src/legacy/v1.rs
+++ b/crates/ctl-core/src/legacy/v1.rs
@@ -186,7 +186,7 @@ fn convert_level(beat_time: crate::FloatTime, value: Level) -> crate::Level {
             .events
             .into_iter()
             .map(|event| crate::TimedEvent {
-                beat: convert_time(beat_time, event.beat),
+                time: convert_time(beat_time, event.beat),
                 event: match event.event {
                     Event::Light(light) => crate::Event::Light(crate::LightEvent {
                         light: crate::LightSerde {
@@ -245,5 +245,5 @@ fn convert_frame(beat_time: crate::FloatTime, value: MoveFrame) -> crate::MoveFr
 }
 
 fn convert_time(beat_time: crate::FloatTime, time: crate::FloatTime) -> crate::Time {
-    crate::convert_time(beat_time * time)
+    crate::seconds_to_time(beat_time * time)
 }
diff --git a/crates/ctl-core/src/model/level.rs b/crates/ctl-core/src/model/level.rs
index 65fe2e29..33c1e4db 100644
--- a/crates/ctl-core/src/model/level.rs
+++ b/crates/ctl-core/src/model/level.rs
@@ -10,7 +10,7 @@ pub struct Level {
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct TimedEvent {
     /// The beat on which the event should happen.
-    pub beat: Time,
+    pub time: Time,
     pub event: Event,
 }
 
@@ -40,7 +40,7 @@ pub struct LightEvent {
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Telegraph {
-    /// How long (in beats) before the event should the telegraph occur.
+    /// How long (in milliseconds) before the event should the telegraph occur.
     pub precede_time: Time,
     /// How fast the telegraph is.
     pub speed: Coord,
@@ -51,11 +51,11 @@ impl Level {
         Self { events: Vec::new() }
     }
 
-    /// Calculate the last beat when anything happens.
-    pub fn last_beat(&self) -> Time {
+    /// Calculate the last time when anything happens.
+    pub fn last_time(&self) -> Time {
         self.events
             .iter()
-            .map(|event| event.beat + event.duration())
+            .map(|event| event.time + event.duration())
             .max()
             .unwrap_or(Time::ZERO)
     }
diff --git a/crates/ctl-core/src/model/movement.rs b/crates/ctl-core/src/model/movement.rs
index 3ff84721..6849079d 100644
--- a/crates/ctl-core/src/model/movement.rs
+++ b/crates/ctl-core/src/model/movement.rs
@@ -2,9 +2,9 @@ use super::*;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Movement {
-    /// Time (in beats) to spend fading into the initial position.
+    /// Time (in milliseconds) to spend fading into the initial position.
     pub fade_in: Time,
-    /// Time (in beats) to spend fading out of the last keyframe.
+    /// Time (in milliseconds) to spend fading out of the last keyframe.
     pub fade_out: Time,
     pub initial: Transform,
     #[serde(default)]
@@ -126,9 +126,9 @@ impl Interpolatable for Transform {
 }
 
 impl MoveFrame {
-    pub fn scale(lerp_time: Time, scale: impl Float) -> Self {
+    pub fn scale(lerp_time: impl Float, scale: impl Float) -> Self {
         Self {
-            lerp_time,
+            lerp_time: seconds_to_time(FloatTime::new(lerp_time.as_f32())),
             interpolation: MoveInterpolation::default(),
             change_curve: None,
             transform: Transform::scale(scale),
diff --git a/crates/ctl-core/src/types.rs b/crates/ctl-core/src/types.rs
index c26fb039..2a8d2a6f 100644
--- a/crates/ctl-core/src/types.rs
+++ b/crates/ctl-core/src/types.rs
@@ -10,10 +10,14 @@ pub type Name = Arc<str>;
 /// 1000 means that each time unit is a millisecond.
 pub const TIME_IN_FLOAT_TIME: Time = 1000;
 
-pub fn convert_time(time: FloatTime) -> Time {
+pub fn seconds_to_time(time: FloatTime) -> Time {
     (time.as_f32() / TIME_IN_FLOAT_TIME as f32).round() as Time
 }
 
+pub fn time_to_seconds(time: Time) -> FloatTime {
+    FloatTime::new(time as f32 * TIME_IN_FLOAT_TIME as f32)
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct BeatTime {
     /// 1 unit is 1/16 of a beat (typically a 1/64th note).
@@ -21,15 +25,35 @@ pub struct BeatTime {
 }
 
 impl BeatTime {
+    const UNITS_PER_BEAT: Time = 16;
+    /// A whole beat (typically a 1/4th note)
+    pub const WHOLE: Self = Self {
+        units: Self::UNITS_PER_BEAT,
+    };
+    /// A half beat (typically a 1/8th note)
+    pub const HALF: Self = Self {
+        units: Self::UNITS_PER_BEAT / 2,
+    };
+    /// A quarter beat (typically a 1/16th note)
+    pub const QUARTER: Self = Self {
+        units: Self::UNITS_PER_BEAT / 4,
+    };
+    /// An eighth beat (typically a 1/32th note)
+    pub const EIGHTH: Self = Self {
+        units: Self::UNITS_PER_BEAT / 8,
+    };
+
     /// From whole beats.
     pub fn from_beats(beats: Time) -> Self {
-        Self { units: beats * 64 }
+        Self {
+            units: beats * Self::UNITS_PER_BEAT,
+        }
     }
 
     /// From quarter beats.
     pub fn from_4ths(quarters: Time) -> Self {
         Self {
-            units: quarters * 16,
+            units: quarters * (Self::UNITS_PER_BEAT / 4),
         }
     }
 
@@ -39,7 +63,17 @@ impl BeatTime {
     }
 
     pub fn as_millis(&self, beat_time: Time) -> Time {
-        self.units * beat_time / 16
+        self.units * beat_time / Self::UNITS_PER_BEAT
+    }
+}
+
+impl Mul<Time> for BeatTime {
+    type Output = Self;
+
+    fn mul(self, rhs: Time) -> Self::Output {
+        Self {
+            units: self.units * rhs,
+        }
     }
 }
 
@@ -119,11 +153,6 @@ impl GroupInfo {
 }
 
 impl MusicInfo {
-    /// Returns the duration (in seconds) of a single beat.
-    pub fn beat_time(&self) -> FloatTime {
-        r32(60.0) / self.bpm
-    }
-
     /// Return the list of authors in a readable string format.
     pub fn authors(&self) -> String {
         let authors = self.authors.iter().map(|author| author.name.as_ref());
diff --git a/crates/ctl-server/src/server/group.rs b/crates/ctl-server/src/server/group.rs
index d49d1b70..840b4a50 100644
--- a/crates/ctl-server/src/server/group.rs
+++ b/crates/ctl-server/src/server/group.rs
@@ -475,7 +475,7 @@ fn validate_group(group: &LevelSet<LevelFull>) -> Result<()> {
     for level in &group.levels {
         // TODO: check realtime
         // but i think the format will change to use realtime inside the level
-        let duration = level.data.last_beat();
+        let duration = level.data.last_time();
         if duration < LEVEL_MIN_DURATION * ctl_core::types::TIME_IN_FLOAT_TIME {
             return Err(RequestError::LevelTooSmall);
         }
diff --git a/src/editor/action/level.rs b/src/editor/action/level.rs
index 619e239b..ab382657 100644
--- a/src/editor/action/level.rs
+++ b/src/editor/action/level.rs
@@ -21,8 +21,8 @@ pub enum LevelAction {
     SelectLight(LightId),
     DeselectLight,
     ToggleDanger(LightId),
-    ChangeFadeOut(LightId, Time),
-    ChangeFadeIn(LightId, Time),
+    ChangeFadeOut(LightId, Change<Time>),
+    ChangeFadeIn(LightId, Change<Time>),
     MoveLight(LightId, Change<Time>, Change<vec2<Coord>>),
 
     // Waypoint actions
@@ -46,10 +46,10 @@ pub enum Change<T> {
 }
 
 impl<T: Sub<Output = T>> Change<T> {
-    pub fn into_delta(self, reference_value: T) -> Self {
+    pub fn into_delta(self, reference_value: T) -> T {
         match self {
-            Change::Add(_) => self,
-            Change::Set(target_value) => Change::Add(target_value.sub(reference_value)),
+            Change::Add(delta) => delta,
+            Change::Set(target_value) => target_value.sub(reference_value),
         }
     }
 }
@@ -94,8 +94,8 @@ impl LevelAction {
             LevelAction::NewWaypoint => false,
             LevelAction::PlaceWaypoint(_) => false,
             LevelAction::ScaleWaypoint(_, _, delta) => *delta == Coord::ZERO,
-            LevelAction::ChangeFadeOut(_, delta) => *delta == 0,
-            LevelAction::ChangeFadeIn(_, delta) => *delta == 0,
+            LevelAction::ChangeFadeOut(_, delta) => delta.is_noop(&0),
+            LevelAction::ChangeFadeIn(_, delta) => delta.is_noop(&0),
             LevelAction::DeselectLight => false,
             LevelAction::SelectLight(_) => false,
             LevelAction::SelectWaypoint(_) => false,
@@ -187,7 +187,9 @@ impl LevelEditor {
                 if let Some(event) = self.level.events.get_mut(id.event) {
                     if let Event::Light(light) = &mut event.event {
                         let movement = &mut light.light.movement;
-                        movement.change_fade_out(movement.fade_out + change);
+                        let mut value = movement.fade_out;
+                        change.apply(&mut value);
+                        movement.change_fade_out(value);
                         self.save_state(HistoryLabel::FadeOut(id));
                     }
                 }
@@ -197,8 +199,9 @@ impl LevelEditor {
                     if let Event::Light(light) = &mut event.event {
                         let movement = &mut light.light.movement;
                         let from = movement.fade_in;
+                        let change = change.into_delta(from);
                         movement.change_fade_in(movement.fade_in + change);
-                        event.beat -= movement.fade_in - from;
+                        event.time -= movement.fade_in - from;
                         self.save_state(HistoryLabel::FadeIn(id));
                     }
                 }
@@ -256,9 +259,10 @@ impl LevelEditor {
             return;
         };
 
-        change_time.apply(&mut timed_event.beat);
+        change_time.apply(&mut timed_event.time);
 
-        let change_pos = change_pos.into_delta(event.light.movement.initial.translation);
+        let change_pos =
+            Change::Add(change_pos.into_delta(event.light.movement.initial.translation));
         change_pos.apply(&mut event.light.movement.initial.translation);
         for frame in &mut event.light.movement.key_frames {
             change_pos.apply(&mut frame.transform.translation);
@@ -455,7 +459,7 @@ impl LevelEditor {
         let beat = start_beat - light.light.movement.fade_in - light.telegraph.precede_time;
         let event = commit_light(light.clone());
         let event = TimedEvent {
-            beat,
+            time: beat,
             event: Event::Light(event),
         };
 
@@ -509,18 +513,18 @@ impl LevelEditor {
                 let time =
                     self.current_time - light.light.movement.fade_in - light.telegraph.precede_time;
                 light.light.movement.key_frames.push_front(MoveFrame {
-                    lerp_time: event.beat - time,
+                    lerp_time: event.time - time,
                     interpolation,
                     change_curve,
                     transform,
                 });
-                event.beat = time;
+                event.time = time;
             }
             Some(i) => {
                 // Insert keyframe
                 let last = light.light.movement.timed_positions().nth(i);
                 if let Some((_, _, last_time)) = last {
-                    let last_time = event.beat + light.telegraph.precede_time + last_time;
+                    let last_time = event.time + light.telegraph.precede_time + last_time;
                     let lerp_time = self.current_time - last_time;
 
                     light.light.movement.key_frames.insert(
diff --git a/src/editor/action/state.rs b/src/editor/action/state.rs
index 79bc5a1f..debc1ea5 100644
--- a/src/editor/action/state.rs
+++ b/src/editor/action/state.rs
@@ -71,7 +71,7 @@ impl EditorState {
                         delta.min(current)
                     } else {
                         -delta.abs().min(
-                            level_editor.level.last_beat() - timeline.visible_scroll() - current,
+                            level_editor.level.last_time() - timeline.visible_scroll() - current,
                         )
                     };
                     timeline.scroll(delta);
@@ -158,7 +158,7 @@ impl EditorState {
                             // delta = ((delta * 4.0).round() / 4.0).as_r32();
 
                             match waypoint {
-                                WaypointId::Initial => event.beat += delta,
+                                WaypointId::Initial => event.time += delta,
                                 WaypointId::Frame(i) => {
                                     if let Some(frame) = light.light.movement.key_frames.get_mut(i)
                                     {
diff --git a/src/editor/config.rs b/src/editor/config.rs
index 9b6abe1b..0b1b0de8 100644
--- a/src/editor/config.rs
+++ b/src/editor/config.rs
@@ -4,8 +4,8 @@ use super::*;
 #[load(serde = "ron")]
 pub struct EditorConfig {
     pub grid: GridConfig,
-    /// How much of the music to playback when scrolling.
-    pub playback_duration: Time,
+    /// How much of the music to playback when scrolling (in seconds).
+    pub playback_duration: FloatTime,
     pub scroll_slow: Time,
     pub scroll_normal: Time,
     pub scroll_fast: Time,
diff --git a/src/editor/handle_event.rs b/src/editor/handle_event.rs
index cc683670..16d68cbe 100644
--- a/src/editor/handle_event.rs
+++ b/src/editor/handle_event.rs
@@ -223,9 +223,9 @@ impl EditorState {
                             let scroll = scroll.as_f32() as Time;
                             let change = scroll * self.editor.config.scroll_slow;
                             let action = if shift {
-                                LevelAction::ChangeFadeOut(id, change)
+                                LevelAction::ChangeFadeOut(id, Change::Add(change))
                             } else {
-                                LevelAction::ChangeFadeIn(id, change)
+                                LevelAction::ChangeFadeIn(id, Change::Add(change))
                             };
                             actions.push(action.into());
                         }
@@ -367,7 +367,7 @@ impl EditorState {
                             let target = DragTarget::Light {
                                 double,
                                 light: LightId { event },
-                                initial_time: e.beat,
+                                initial_time: e.time,
                                 initial_translation: light.light.movement.initial.translation,
                             };
                             actions.push(EditorStateAction::StartDrag(target));
diff --git a/src/editor/mod.rs b/src/editor/mod.rs
index 84f4f67f..ad975fd3 100644
--- a/src/editor/mod.rs
+++ b/src/editor/mod.rs
@@ -36,7 +36,7 @@ pub struct EditorState {
     render: EditorRender,
     editor: Editor,
     framebuffer_size: vec2<usize>,
-    delta_time: Time,
+    delta_time: FloatTime,
     ui: EditorUI,
     ui_focused: bool,
     ui_context: UiContext,
@@ -119,7 +119,7 @@ pub struct Editor {
 
     pub grid_size: Coord,
     pub view_zoom: f32,
-    pub music_timer: Time,
+    pub music_timer: FloatTime,
     pub snap_to_grid: bool,
     /// Whether to visualize the lights' movement for the current beat.
     pub visualize_beat: bool,
@@ -132,10 +132,10 @@ pub struct Editor {
 
 #[derive(Debug)]
 pub struct Replay {
-    pub start_beat: Time,
-    pub end_beat: Time,
-    pub current_beat: Time,
-    pub speed: Time,
+    pub start_time: Time,
+    pub end_time: Time,
+    pub current_time: Time,
+    pub speed: FloatTime,
 }
 
 impl LevelEditor {
@@ -150,7 +150,7 @@ impl LevelEditor {
             context,
             level_state: EditorLevelState::default(),
             current_time: Time::ZERO,
-            real_time: Time::ZERO,
+            real_time: FloatTime::ZERO,
             selected_light: None,
             place_rotation: Angle::ZERO,
             place_scale: Coord::ONE,
@@ -198,7 +198,7 @@ impl LevelEditor {
                     Some(frame) => {
                         // Make the first frame the initial position
                         event.light.movement.initial = frame.transform;
-                        timed_event.beat += frame.lerp_time;
+                        timed_event.time += frame.lerp_time;
                     }
                 }
             }
@@ -249,7 +249,7 @@ impl EditorState {
                 visualize_beat: true,
                 show_only_selected: false,
                 snap_to_grid: true,
-                music_timer: Time::ZERO,
+                music_timer: FloatTime::ZERO,
 
                 group,
                 level_edit: None,
@@ -271,7 +271,7 @@ impl EditorState {
         (pos / self.editor.grid_size).map(Coord::round) * self.editor.grid_size
     }
 
-    fn update_level_editor(&mut self, delta_time: Time) {
+    fn update_level_editor(&mut self, delta_time: FloatTime) {
         let Some(level_editor) = &mut self.editor.level_edit else {
             return;
         };
@@ -282,9 +282,9 @@ impl EditorState {
 
         level_editor.real_time += delta_time;
 
-        if self.editor.music_timer > Time::ZERO {
+        if self.editor.music_timer > FloatTime::ZERO {
             self.editor.music_timer -= delta_time;
-            if self.editor.music_timer <= Time::ZERO {
+            if self.editor.music_timer <= FloatTime::ZERO {
                 self.context.music.stop();
             }
         }
@@ -296,7 +296,7 @@ impl EditorState {
                         // Set current time to align with the selected waypoint
                         if let Some(time) = light.light.movement.get_time(waypoint) {
                             level_editor.current_time =
-                                event.beat + light.telegraph.precede_time + time;
+                                event.time + light.telegraph.precede_time + time;
                         }
                     }
                 }
@@ -313,8 +313,7 @@ impl EditorState {
                     &level_editor.static_level.group.music,
                     level_editor.current_time,
                 );
-                self.editor.music_timer = level_editor.static_level.group.music.meta.beat_time()
-                    * self.editor.config.playback_duration;
+                self.editor.music_timer = self.editor.config.playback_duration;
             }
             level_editor.was_scrolling_time = false;
         }
@@ -322,13 +321,11 @@ impl EditorState {
         level_editor.scrolling_time = false;
 
         if let State::Playing { .. } = level_editor.state {
-            level_editor.current_time =
-                level_editor.real_time / level_editor.static_level.group.music.meta.beat_time();
+            level_editor.current_time = seconds_to_time(level_editor.real_time);
         } else if let Some(replay) = &mut level_editor.dynamic_segment {
-            replay.current_beat +=
-                replay.speed * delta_time / level_editor.static_level.group.music.meta.beat_time();
-            if replay.current_beat > replay.end_beat {
-                replay.current_beat = replay.start_beat;
+            replay.current_time += seconds_to_time(replay.speed * delta_time);
+            if replay.current_time > replay.end_time {
+                replay.current_time = replay.start_time;
             }
         }
 
@@ -361,8 +358,7 @@ impl EditorState {
         };
 
         let level = crate::game::PlayLevel {
-            start_time: level_editor.current_time
-                * level_editor.static_level.group.music.meta.beat_time(), // TODO: nonlinear time
+            start_time: level_editor.current_time,
             level: Rc::new(LevelFull {
                 meta: level_editor.static_level.level.meta.clone(),
                 data: level_editor.level.clone(),
@@ -388,7 +384,7 @@ impl geng::State for EditorState {
     }
 
     fn update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as f32);
+        let delta_time = FloatTime::new(delta_time as f32);
         self.delta_time = delta_time;
 
         self.context
@@ -737,13 +733,13 @@ impl LevelEditor {
     }
 
     fn scroll_time(&mut self, delta: Time) {
-        let margin = r32(1000.0);
+        let margin = 100 * TIME_IN_FLOAT_TIME;
         let min = Time::ZERO;
-        let max = margin + self.level.last_beat();
+        let max = margin + self.level.last_time();
         let target = (self.current_time + delta).clamp(min, max);
 
-        // Align with quarter beats
-        self.current_time = ((target.as_f32() * 4.0).round() / 4.0).as_r32();
+        // TODO: align with quarter beats
+        self.current_time = target;
 
         self.scrolling_time = true;
 
@@ -766,12 +762,9 @@ impl LevelEditor {
             let time = self.current_time;
             let dynamic = if visualize_beat {
                 if let Some(replay) = &self.dynamic_segment {
-                    Some(replay.current_beat)
+                    Some(replay.current_time)
                 } else {
-                    Some(
-                        time + (self.real_time / self.static_level.group.music.meta.beat_time())
-                            .fract(),
-                    )
+                    Some(time + seconds_to_time(self.real_time))
                 }
             } else {
                 None
@@ -810,14 +803,14 @@ impl LevelEditor {
             let light_id = *light_id;
             if let Some(timed_event) = self.level.events.get(light_id.event) {
                 if let Event::Light(light_event) = &timed_event.event {
-                    let event_time = timed_event.beat + light_event.telegraph.precede_time;
+                    let event_time = timed_event.time + light_event.telegraph.precede_time;
                     // If some waypoints overlap, render the temporaly closest one
                     let base_collider = Collider::new(vec2::ZERO, light_event.light.shape);
 
                     /// Waypoints past this time-distance are not rendered at all
-                    const MAX_VISIBILITY: f32 = 15.0;
+                    const MAX_VISIBILITY: Time = 5 * TIME_IN_FLOAT_TIME;
                     let visible = |beat: Time| {
-                        let d = (event_time + beat - self.current_time).abs().as_f32();
+                        let d = (event_time + beat - self.current_time).abs();
                         d <= MAX_VISIBILITY
                     };
 
@@ -829,8 +822,8 @@ impl LevelEditor {
                         .timed_positions()
                         .map(|(i, trans_control, time)| {
                             let trans_actual = match i {
-                                WaypointId::Initial => curve.get(0, Time::ZERO),
-                                WaypointId::Frame(i) => curve.get(i, Time::ONE),
+                                WaypointId::Initial => curve.get(0, FloatTime::ZERO),
+                                WaypointId::Frame(i) => curve.get(i, FloatTime::ONE),
                             }
                             .unwrap_or(trans_control); // Should be unreachable, but just in case
                             (
diff --git a/src/editor/ui/config.rs b/src/editor/ui/config.rs
index 761a67ec..88a6e908 100644
--- a/src/editor/ui/config.rs
+++ b/src/editor/ui/config.rs
@@ -17,12 +17,13 @@ pub struct EditorConfigWidget {
     pub all_level_names: Vec<(IconWidget, IconWidget, TextWidget)>,
 
     pub timeline: TextWidget,
-    /// Normal time scroll.
-    pub scroll_by: ValueWidget<BeatTime>, // TODO: 1/4 instead of 0.25
-    /// Slow time scroll.
-    pub shift_scroll: ValueWidget<BeatTime>,
-    /// Fast time scroll.
-    pub alt_scroll: ValueWidget<BeatTime>,
+    // TODO scroll time
+    // /// Normal time scroll.
+    // pub scroll_by: ValueWidget<BeatTime>,
+    // /// Slow time scroll.
+    // pub shift_scroll: ValueWidget<BeatTime>,
+    // /// Fast time scroll.
+    // pub alt_scroll: ValueWidget<BeatTime>,
     // pub snap_to: CheckboxWidget,
 }
 
@@ -44,24 +45,24 @@ impl EditorConfigWidget {
             all_level_names: Vec::new(),
 
             timeline: TextWidget::new("Timeline"),
-            scroll_by: ValueWidget::new_range(
-                "Scroll by",
-                r32(1.0),
-                r32(0.25)..=r32(4.0),
-                r32(0.25),
-            ),
-            shift_scroll: ValueWidget::new_range(
-                "Shift scroll",
-                r32(0.25),
-                r32(0.125)..=r32(1.0),
-                r32(0.125),
-            ),
-            alt_scroll: ValueWidget::new_range(
-                "Alt scroll",
-                r32(10.0),
-                r32(1.0)..=r32(20.0),
-                r32(0.5),
-            ),
+            // scroll_by: ValueWidget::new_range(
+            //     "Scroll by",
+            //     BeatTime::WHOLE,
+            //     BeatTime::QUARTER..=BeatTime::WHOLE * 4,
+            //     BeatTime::QUARTER,
+            // ),
+            // shift_scroll: ValueWidget::new_range(
+            //     "Shift scroll",
+            //     BeatTime::QUARTER,
+            //     BeatTime::EIGHTH..=BeatTime::WHOLE,
+            //     BeatTime::EIGHTH,
+            // ),
+            // alt_scroll: ValueWidget::new_range(
+            //     "Alt scroll",
+            //     BeatTime::WHOLE * 10,
+            //     BeatTime::WHOLE..=BeatTime::WHOLE * 20,
+            //     BeatTime::HALF,
+            // ),
         }
     }
 }
@@ -233,20 +234,21 @@ impl StatefulWidget for EditorConfigWidget {
         let timeline = bar.cut_top(context.font_size);
         self.timeline.update(timeline, context);
 
-        let mut config = state.config.clone();
+        // TODO: scroll time
+        // let mut config = state.config.clone();
 
-        let scroll_by = bar.cut_top(context.font_size);
-        self.scroll_by
-            .update(scroll_by, context, &mut config.scroll_normal);
+        // let scroll_by = bar.cut_top(context.font_size);
+        // self.scroll_by
+        //     .update(scroll_by, context, &mut config.scroll_normal);
 
-        let shift_scroll = bar.cut_top(context.font_size);
-        self.shift_scroll
-            .update(shift_scroll, context, &mut config.scroll_slow);
+        // let shift_scroll = bar.cut_top(context.font_size);
+        // self.shift_scroll
+        //     .update(shift_scroll, context, &mut config.scroll_slow);
 
-        let alt_scroll = bar.cut_top(context.font_size);
-        self.alt_scroll
-            .update(alt_scroll, context, &mut config.scroll_fast);
+        // let alt_scroll = bar.cut_top(context.font_size);
+        // self.alt_scroll
+        //     .update(alt_scroll, context, &mut config.scroll_fast);
 
-        actions.push(EditorAction::SetConfig(config).into());
+        // actions.push(EditorAction::SetConfig(config).into());
     }
 }
diff --git a/src/editor/ui/edit.rs b/src/editor/ui/edit.rs
index d49daf8d..9f738bf8 100644
--- a/src/editor/ui/edit.rs
+++ b/src/editor/ui/edit.rs
@@ -63,8 +63,8 @@ pub struct EditorEditWidget {
     pub light: TextWidget,
     pub light_delete: ButtonWidget,
     pub light_danger: CheckboxWidget,
-    pub light_fade_in: ValueWidget<Time>,
-    pub light_fade_out: ValueWidget<Time>,
+    pub light_fade_in: ValueWidget<FloatTime>,
+    pub light_fade_out: ValueWidget<FloatTime>,
 
     pub waypoint: ButtonWidget,
     pub prev_waypoint: IconButtonWidget,
@@ -111,15 +111,15 @@ impl EditorEditWidget {
             light_danger: CheckboxWidget::new("Danger"),
             light_fade_in: ValueWidget::new_range(
                 "Fade in",
-                r32(1.0),
-                r32(0.25)..=r32(25.0),
-                r32(0.25),
+                r32(0.5),
+                r32(0.25)..=r32(10.0),
+                r32(0.1),
             ),
             light_fade_out: ValueWidget::new_range(
                 "Fade out",
-                r32(1.0),
-                r32(0.25)..=r32(25.0),
-                r32(0.25),
+                r32(0.5),
+                r32(0.25)..=r32(10.0),
+                r32(0.1),
             ),
 
             waypoint: ButtonWidget::new("Waypoints"),
@@ -405,21 +405,31 @@ impl StatefulWidget for EditorEditWidget {
                         {
                             let fade_in = bar.cut_top(value_height);
                             bar.cut_top(spacing);
-                            let mut fade = light.movement.fade_in;
-                            let from = fade;
+                            let mut fade = time_to_seconds(light.movement.fade_in);
                             update!(self.light_fade_in, fade_in, &mut fade);
                             context.update_focus(self.light_fade_in.state.hovered);
-                            actions.push(LevelAction::ChangeFadeIn(light_id, fade - from).into());
+                            actions.push(
+                                LevelAction::ChangeFadeIn(
+                                    light_id,
+                                    Change::Set(seconds_to_time(fade)),
+                                )
+                                .into(),
+                            );
                         }
 
                         {
                             let fade_out = bar.cut_top(value_height);
                             bar.cut_top(spacing);
-                            let mut fade = light.movement.fade_out;
-                            let from = fade;
+                            let mut fade = time_to_seconds(light.movement.fade_out);
                             update!(self.light_fade_out, fade_out, &mut fade);
                             context.update_focus(self.light_fade_out.state.hovered);
-                            actions.push(LevelAction::ChangeFadeOut(light_id, fade - from).into());
+                            actions.push(
+                                LevelAction::ChangeFadeOut(
+                                    light_id,
+                                    Change::Set(seconds_to_time(fade)),
+                                )
+                                .into(),
+                            );
                         }
 
                         bar.cut_top(layout_size * 1.5);
@@ -606,7 +616,7 @@ impl StatefulWidget for EditorEditWidget {
             let replay = level_editor
                 .dynamic_segment
                 .as_ref()
-                .map(|replay| replay.current_beat);
+                .map(|replay| replay.current_time);
             self.timeline.update_time(level_editor.current_time, replay);
 
             let select = context.mods.ctrl;
diff --git a/src/game.rs b/src/game.rs
index b569e66a..c03ea1be 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -19,7 +19,7 @@ pub struct Game {
     debug_mode: bool,
 
     framebuffer_size: vec2<usize>,
-    delta_time: Time,
+    delta_time: FloatTime,
 
     active_touch: Option<u64>,
     ui: GameUI,
@@ -149,7 +149,7 @@ impl geng::State for Game {
     }
 
     fn update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as _);
+        let delta_time = FloatTime::new(delta_time as _);
         self.delta_time = delta_time;
 
         self.context
@@ -207,7 +207,7 @@ impl geng::State for Game {
     }
 
     fn fixed_update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as _);
+        let delta_time = FloatTime::new(delta_time as _);
 
         let pos = self.ui_context.cursor.position;
         let game_pos = geng_utils::layout::fit_aabb(
diff --git a/src/local/cache.rs b/src/local/cache.rs
index 8d269a4a..c2a3b0e4 100644
--- a/src/local/cache.rs
+++ b/src/local/cache.rs
@@ -209,7 +209,7 @@ impl LevelCache {
         }
 
         {
-            let groups = self.fs.load_groups_all().await?;
+            let groups = self.fs.load_groups_all(&self.inner.borrow().music).await?;
             let group_loaders = groups
                 .into_iter()
                 .map(|(path, group)| self.insert_group(path, group));
diff --git a/src/local/fs.rs b/src/local/fs.rs
index 39791f03..79be295b 100644
--- a/src/local/fs.rs
+++ b/src/local/fs.rs
@@ -59,7 +59,10 @@ impl Controller {
         }
     }
 
-    pub async fn load_groups_all(&self) -> Result<Vec<(PathBuf, LevelSet)>> {
+    pub async fn load_groups_all(
+        &self,
+        music: &HashMap<Id, Rc<CachedMusic>>,
+    ) -> Result<Vec<(PathBuf, LevelSet)>> {
         log::debug!("Loading all local groups");
 
         #[cfg(target_arch = "wasm32")]
@@ -74,7 +77,7 @@ impl Controller {
         }
         #[cfg(not(target_arch = "wasm32"))]
         {
-            native::load_groups_all().await
+            native::load_groups_all(music).await
         }
     }
 
@@ -239,16 +242,19 @@ impl CachedGroup {
     }
 }
 
-fn decode_group(bytes: &[u8]) -> Result<LevelSet> {
+fn decode_group(music: &HashMap<Id, Rc<CachedMusic>>, bytes: &[u8]) -> Result<LevelSet> {
     match cbor4ii::serde::from_slice(bytes) {
         Ok(value) => Ok(value),
         Err(err) => {
             // Try legacy version, for backwards compatibility
             if let Ok(value) = bincode::deserialize::<ctl_client::core::legacy::v1::LevelSet>(bytes)
             {
-                return Ok(value.into());
+                if let Some(music) = music.get(&value.music) {
+                    let beat_time = r32(60.0) / music.meta.bpm;
+                    let value = ctl_client::core::legacy::v1::convert_group(beat_time, value);
+                    return Ok(value);
+                }
             }
-
             Err(err.into())
         }
     }
diff --git a/src/local/fs/native.rs b/src/local/fs/native.rs
index 02a233be..81413c06 100644
--- a/src/local/fs/native.rs
+++ b/src/local/fs/native.rs
@@ -47,7 +47,9 @@ async fn load_music(geng: &Geng, path: PathBuf) -> Result<CachedMusic> {
     res
 }
 
-pub async fn load_groups_all() -> Result<Vec<(PathBuf, LevelSet)>> {
+pub async fn load_groups_all(
+    music: &HashMap<Id, Rc<CachedMusic>>,
+) -> Result<Vec<(PathBuf, LevelSet)>> {
     let groups_path = fs::all_groups_path();
     if !groups_path.exists() {
         return Ok(Vec::new());
@@ -72,7 +74,8 @@ pub async fn load_groups_all() -> Result<Vec<(PathBuf, LevelSet)>> {
             let bytes = file::load_bytes(&path)
                 .await
                 .with_context(|| "when loading file")?;
-            let group: LevelSet = decode_group(&bytes).with_context(|| "when deserializing")?;
+            let group: LevelSet =
+                decode_group(music, &bytes).with_context(|| "when deserializing")?;
             anyhow::Ok((path, group))
         }
         .await
diff --git a/src/media.rs b/src/media.rs
index 572af8bd..01fb993e 100644
--- a/src/media.rs
+++ b/src/media.rs
@@ -9,7 +9,7 @@ pub struct MediaState {
     dither: DitherRender,
     text: String,
     theme: Theme,
-    time: Time,
+    time: FloatTime,
     camera: Camera2d,
 }
 
@@ -20,7 +20,7 @@ impl MediaState {
             dither: DitherRender::new(&context.geng, &context.assets),
             text: String::new(),
             theme: Theme::default(),
-            time: Time::ZERO,
+            time: FloatTime::ZERO,
             camera: Camera2d {
                 center: vec2::ZERO,
                 rotation: Angle::ZERO,
@@ -61,7 +61,7 @@ impl geng::State for MediaState {
     }
 
     fn update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as f32);
+        let delta_time = FloatTime::new(delta_time as f32);
         self.time += delta_time;
     }
 }
diff --git a/src/menu/level.rs b/src/menu/level.rs
index 2dd17ecd..0f7998b0 100644
--- a/src/menu/level.rs
+++ b/src/menu/level.rs
@@ -35,8 +35,8 @@ pub struct LevelMenu {
     masked: MaskedRender,
 
     framebuffer_size: vec2<usize>,
-    last_delta_time: Time,
-    time: Time,
+    last_delta_time: FloatTime,
+    time: FloatTime,
 
     ui: MenuUI,
     ui_focused: bool,
@@ -209,8 +209,8 @@ impl LevelMenu {
             masked: MaskedRender::new(&context.geng, &context.assets, vec2(1, 1)),
 
             framebuffer_size: vec2(1, 1),
-            last_delta_time: Time::ONE,
-            time: Time::ZERO,
+            last_delta_time: FloatTime::ONE,
+            time: FloatTime::ZERO,
 
             ui: MenuUI::new(context.clone()),
             ui_focused: false,
@@ -295,7 +295,7 @@ impl LevelMenu {
 
         self.context.music.stop();
         self.ui_context.cursor.reset();
-        self.play_button.hover_time.set(Time::ZERO);
+        self.play_button.hover_time.set(FloatTime::ZERO);
 
         let future = {
             let context = self.context.clone();
@@ -325,7 +325,7 @@ impl LevelMenu {
         self.state.leaderboard.status = LeaderboardStatus::None;
     }
 
-    fn update_active_music(&mut self, delta_time: Time) {
+    fn update_active_music(&mut self, delta_time: FloatTime) {
         let delta_time = delta_time.as_f32();
         if let Some(current_music) = &mut self.state.selected_music {
             if let Some(switch_music) = self.state.switch_music {
@@ -362,7 +362,7 @@ impl LevelMenu {
         }
     }
 
-    fn update_active_group(&mut self, delta_time: Time) {
+    fn update_active_group(&mut self, delta_time: FloatTime) {
         let delta_time = delta_time.as_f32();
         if let Some(current_group) = &mut self.state.selected_group {
             if let Some(switch_group) = self.state.switch_group {
@@ -405,7 +405,7 @@ impl LevelMenu {
         }
     }
 
-    fn update_active_level(&mut self, delta_time: Time) {
+    fn update_active_level(&mut self, delta_time: FloatTime) {
         let delta_time = delta_time.as_f32();
         if let Some(current_level) = &mut self.state.selected_level {
             if let Some(switch_level) = self.state.switch_level {
@@ -604,12 +604,12 @@ impl geng::State for LevelMenu {
     }
 
     fn fixed_update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as _);
+        let delta_time = FloatTime::new(delta_time as _);
         self.state.player.update_tail(delta_time);
     }
 
     fn update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as f32);
+        let delta_time = FloatTime::new(delta_time as f32);
         self.time += delta_time;
 
         self.context
diff --git a/src/menu/main.rs b/src/menu/main.rs
index a0d94c21..cd9aafc9 100644
--- a/src/menu/main.rs
+++ b/src/menu/main.rs
@@ -24,7 +24,7 @@ pub struct MainMenu {
     cursor_world_pos: vec2<Coord>,
     camera: Camera2d,
 
-    time: Time,
+    time: FloatTime,
     play_button: HoverButton,
     player: Player,
 
@@ -60,7 +60,7 @@ impl MainMenu {
                 fov: 10.0,
             },
 
-            time: Time::ZERO,
+            time: FloatTime::ZERO,
             play_button: HoverButton::new(
                 Collider {
                     position: vec2(0.0, 0.0).as_r32(),
@@ -105,7 +105,7 @@ impl geng::State for MainMenu {
     }
 
     fn update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as f32);
+        let delta_time = FloatTime::new(delta_time as f32);
         self.time += delta_time;
 
         self.context
@@ -140,7 +140,7 @@ impl geng::State for MainMenu {
         self.player
             .update_distance_simple(&self.play_button.base_collider);
         if self.play_button.hover_time.is_max() {
-            self.play_button.hover_time.set_ratio(Time::ZERO);
+            self.play_button.hover_time.set_ratio(FloatTime::ZERO);
             self.play();
         }
 
@@ -148,7 +148,7 @@ impl geng::State for MainMenu {
     }
 
     fn fixed_update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as _);
+        let delta_time = FloatTime::new(delta_time as _);
         self.player.update_tail(delta_time);
     }
 
diff --git a/src/menu/splash.rs b/src/menu/splash.rs
index 8b009364..7310f3fc 100644
--- a/src/menu/splash.rs
+++ b/src/menu/splash.rs
@@ -9,7 +9,7 @@ pub struct SplashScreen {
 
     util: UtilRender,
 
-    time: Time,
+    time: FloatTime,
 }
 
 impl SplashScreen {
@@ -17,7 +17,7 @@ impl SplashScreen {
         Self {
             util: UtilRender::new(context.clone()),
 
-            time: Time::ZERO,
+            time: FloatTime::ZERO,
 
             context,
             client: client.cloned(),
@@ -72,7 +72,7 @@ trigger seizures for people with photosensitive epilepsy
     }
 
     fn update(&mut self, delta_time: f64) {
-        let delta_time = Time::new(delta_time as f32);
+        let delta_time = FloatTime::new(delta_time as f32);
         self.time += delta_time;
 
         if self.time.as_f32() > TRANSITION_TIME {
diff --git a/src/model/level/config.rs b/src/model/level/config.rs
index a64bff27..f6621365 100644
--- a/src/model/level/config.rs
+++ b/src/model/level/config.rs
@@ -18,22 +18,22 @@ pub struct PlayerConfig {
 #[serde(default)]
 pub struct HealthConfig {
     /// Max health value.
-    pub max: Time,
+    pub max: FloatTime,
     /// How fast health decreases per second in darkness.
-    pub dark_decrease_rate: Time,
+    pub dark_decrease_rate: FloatTime,
     /// How fast health decreases per second in danger.
-    pub danger_decrease_rate: Time,
+    pub danger_decrease_rate: FloatTime,
     /// How much health restores per second while in light.
-    pub restore_rate: Time,
+    pub restore_rate: FloatTime,
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
 #[serde(default)]
 pub struct WaypointsConfig {
     pub show: bool,
-    pub sustain_time: Time,
-    pub fade_time: Time,
-    pub sustain_scale: Time,
+    pub sustain_time: FloatTime,
+    pub fade_time: FloatTime,
+    pub sustain_scale: Coord,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
diff --git a/src/model/level/state.rs b/src/model/level/state.rs
index 03ac634f..dd67ad32 100644
--- a/src/model/level/state.rs
+++ b/src/model/level/state.rs
@@ -4,7 +4,7 @@ use super::*;
 #[derive(Debug)]
 pub struct LevelState {
     /// The time at which the render has been done.
-    beat_time: Time,
+    time: Time,
     /// The time after which events are not rendered.
     ignore_after: Option<Time>,
     /// Whether the palette should be swapped.
@@ -17,7 +17,7 @@ pub struct LevelState {
 impl Default for LevelState {
     fn default() -> Self {
         Self {
-            beat_time: Time::ZERO,
+            time: Time::ZERO,
             ignore_after: None,
             swap_palette: false,
             lights: Vec::new(),
@@ -31,11 +31,11 @@ impl LevelState {
     pub fn render(
         level: &Level,
         config: &LevelConfig,
-        beat_time: Time,
+        time: Time,
         ignore_after: Option<Time>,
     ) -> Self {
         let mut state = Self {
-            beat_time,
+            time,
             ignore_after,
             swap_palette: false,
             lights: Vec::new(),
@@ -55,18 +55,18 @@ impl LevelState {
         event_id: Option<usize>,
         config: &LevelConfig,
     ) {
-        if self.beat_time < event.beat {
+        if self.time < event.time {
             self.is_finished = false;
             return;
         }
 
         if let Some(time) = self.ignore_after {
-            if event.beat > time {
+            if event.time > time {
                 return;
             }
         }
 
-        let time = self.beat_time - event.beat;
+        let time = self.time - event.time;
 
         match &event.event {
             Event::PaletteSwap => self.swap_palette = !self.swap_palette,
@@ -101,8 +101,8 @@ pub fn render_light(
         main_tele.light.collider = base_light.collider.transformed(transform);
 
         if config.waypoints.show {
-            let sustain_time = config.waypoints.sustain_time;
-            let fade_time = config.waypoints.fade_time;
+            let sustain_time = seconds_to_time(config.waypoints.sustain_time);
+            let fade_time = seconds_to_time(config.waypoints.fade_time);
             let sustain_scale = config.waypoints.sustain_scale;
 
             let mut last_pos = movement.initial.translation;
@@ -116,13 +116,13 @@ pub fn render_light(
                         && (Time::ZERO..sustain_time + fade_time).contains(&relative_time))
                     .then(|| {
                         let scale = if relative_time < sustain_time {
-                            let t = relative_time / sustain_time;
+                            let t = r32(relative_time as f32 / sustain_time as f32);
                             sustain_scale
-                                + crate::util::smoothstep(Time::ONE - t)
+                                + crate::util::smoothstep(FloatTime::ONE - t)
                                     * (Coord::ONE - sustain_scale)
                         } else {
-                            let t = (relative_time - sustain_time) / fade_time;
-                            sustain_scale * crate::util::smoothstep(Time::ONE - t)
+                            let t = r32((relative_time - sustain_time) as f32 / fade_time as f32);
+                            sustain_scale * crate::util::smoothstep(FloatTime::ONE - t)
                         };
                         transform.scale *= scale;
                         let mut tele = base_tele.clone();
diff --git a/src/model/logic/event.rs b/src/model/logic/event.rs
index a40283eb..638f1635 100644
--- a/src/model/logic/event.rs
+++ b/src/model/logic/event.rs
@@ -18,7 +18,7 @@ impl Model {
                 let position = self.player.collider.position;
                 self.rhythms.push(Rhythm {
                     position,
-                    time: Bounded::new_zero(self.level.group.music.meta.beat_time()),
+                    time: Bounded::new_zero(TIME_IN_FLOAT_TIME / 2),
                     perfect,
                 });
             }
diff --git a/src/model/logic/mod.rs b/src/model/logic/mod.rs
index a74ba348..4dc3984f 100644
--- a/src/model/logic/mod.rs
+++ b/src/model/logic/mod.rs
@@ -5,26 +5,27 @@ use super::*;
 impl Model {
     /// Initialize the level by playing the events from the negative time.
     pub fn init(&mut self, target_time: Time) {
-        log::info!("Starting at the requested time {:.2}...", target_time);
-        self.beat_time = target_time / self.level.group.music.meta.beat_time();
-        self.player.health.set_ratio(Time::ONE);
+        log::info!("Starting at the requested time {}...", target_time);
+        self.exact_time = target_time;
+        self.player.health.set_ratio(FloatTime::ONE);
         self.state = State::Starting {
             start_timer: r32(1.0),
             music_start_time: target_time,
         };
     }
 
-    pub fn update(&mut self, player_target: vec2<Coord>, delta_time: Time) {
+    pub fn update(&mut self, player_target: vec2<Coord>, delta_time: FloatTime) {
         self.context.music.set_volume(self.options.volume.music());
 
-        self.update_rhythm(delta_time);
+        let exact_delta = seconds_to_time(delta_time);
+        self.update_rhythm(exact_delta);
 
         // Move
         self.player.collider.position = player_target;
 
         if let State::Starting { .. } = self.state {
         } else {
-            self.beat_time += delta_time / self.level.group.music.meta.beat_time();
+            self.exact_time += exact_delta;
         }
 
         self.real_time += delta_time;
@@ -45,13 +46,15 @@ impl Model {
 
         // Update level state
         let ignore_time = match self.state {
-            State::Lost { death_beat_time } => Some(death_beat_time),
+            State::Lost {
+                death_exact_time: death_beat_time,
+            } => Some(death_beat_time),
             _ => None,
         };
         self.level_state = LevelState::render(
             &self.level.level.data,
             &self.level.config,
-            self.beat_time,
+            self.exact_time,
             ignore_time,
         );
 
@@ -74,8 +77,8 @@ impl Model {
                         // because otherwise we cannot detect a miss
                         // as both will get set to `None` at the same frame
                         // (allows for unpunished late entrance)
-                        let time = light.closest_waypoint.0.as_f32();
-                        time < 0.0 && (time > -COYOTE_TIME || pass && time > -COYOTE_TIME * 2.0)
+                        let time = light.closest_waypoint.0;
+                        time < 0 && (time > -COYOTE_TIME || pass && time > -COYOTE_TIME * 2)
                     })
                     .map(|light| (id, light.closest_waypoint.1))
             })
@@ -103,7 +106,7 @@ impl Model {
             } => {
                 let music_start_time = *music_start_time;
                 *start_timer -= delta_time;
-                if *start_timer <= Time::ZERO && self.player.is_perfect {
+                if *start_timer <= FloatTime::ZERO && self.player.is_perfect {
                     self.start(music_start_time);
                 }
             }
@@ -144,7 +147,7 @@ impl Model {
                     }
                 }
             }
-            _ if self.switch_time > Time::ONE => {
+            _ if self.switch_time > FloatTime::ONE => {
                 // 1 second before the UI is active
                 let hovering = self
                     .restart_button
@@ -208,7 +211,7 @@ impl Model {
         self.state = State::Playing;
         self.context.music.play_from(
             &self.level.group.music,
-            time::Duration::from_secs_f64(music_start_time.as_f32() as f64),
+            time::Duration::from_secs_f64(time_to_seconds(music_start_time).as_f32().into()),
         );
     }
 
@@ -216,16 +219,16 @@ impl Model {
         self.save_highscore();
         self.state = State::Finished;
         self.context.music.stop();
-        self.switch_time = Time::ZERO;
+        self.switch_time = FloatTime::ZERO;
         self.get_leaderboard(true);
     }
 
     pub fn lose(&mut self) {
         self.save_highscore();
         self.state = State::Lost {
-            death_beat_time: self.beat_time,
+            death_exact_time: self.exact_time,
         };
-        self.switch_time = Time::ZERO;
+        self.switch_time = FloatTime::ZERO;
         self.get_leaderboard(false);
     }
 
diff --git a/src/model/mod.rs b/src/model/mod.rs
index 8568bb21..02f4da45 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -8,10 +8,10 @@ pub use self::{level::*, options::*, player::*, score::*};
 
 use crate::{game::PlayLevel, leaderboard::Leaderboard, prelude::*};
 
-const COYOTE_TIME: f32 = 0.1;
-const BUFFER_TIME: f32 = 0.1;
+const COYOTE_TIME: Time = TIME_IN_FLOAT_TIME / 10; // 0.1s
+const BUFFER_TIME: Time = TIME_IN_FLOAT_TIME / 10; // 0.1s
 
-pub type Lifetime = Bounded<Time>;
+pub type Lifetime = Bounded<FloatTime>;
 
 #[derive(Debug, Clone)]
 pub enum GameEvent {
@@ -32,12 +32,12 @@ impl HoverButton {
             base_collider: collider,
             hover_time: Lifetime::new_zero(hover_time.as_r32()),
             animation: Movement {
-                fade_in: r32(0.0),
+                fade_in: seconds_to_time(r32(0.0)),
                 initial: Transform::scale(2.25),
-                key_frames: vec![MoveFrame::scale(0.5, 5.0), MoveFrame::scale(0.25, 75.0)].into(),
+                key_frames: vec![MoveFrame::scale(0.2, 5.0), MoveFrame::scale(0.1, 75.0)].into(),
                 interpolation: MoveInterpolation::Smoothstep,
                 curve: TrajectoryInterpolation::Linear,
-                fade_out: r32(0.2),
+                fade_out: seconds_to_time(r32(0.1)),
             },
             clicked: false,
         }
@@ -49,7 +49,7 @@ impl HoverButton {
         self.hover_time.get_ratio().as_f32() > 0.6
     }
 
-    pub fn update(&mut self, hovering: bool, delta_time: Time) {
+    pub fn update(&mut self, hovering: bool, delta_time: FloatTime) {
         let scale = if self.is_fading() {
             self.clicked = false;
             1.0
@@ -70,14 +70,14 @@ pub enum State {
     /// Wait for the player to hover the light and some additional time.
     Starting {
         /// Time until we can start the game.
-        start_timer: Time,
+        start_timer: FloatTime,
         /// Time to start playing music from.
         music_start_time: Time,
     },
     Playing,
     Lost {
         /// The time of death.
-        death_beat_time: Time,
+        death_exact_time: Time,
     },
     Finished,
 }
@@ -121,11 +121,11 @@ pub struct Model {
     /// Waypoint rhythms.
     pub rhythms: Vec<Rhythm>,
 
-    pub real_time: Time,
+    pub real_time: FloatTime,
     /// Time since the last state change.
-    pub switch_time: Time,
-    /// Current time with beats as measure.
-    pub beat_time: Time,
+    pub switch_time: FloatTime,
+    /// Current exact time in milliseconds.
+    pub exact_time: Time,
 
     // for Lost/Finished state
     pub restart_button: HoverButton,
@@ -180,7 +180,7 @@ impl Model {
 
             level_state: LevelState::default(),
             state: State::Starting {
-                start_timer: Time::ZERO, // reset during init
+                start_timer: FloatTime::ZERO, // reset during init
                 music_start_time: Time::ZERO,
             },
             score: Score::new(level.config.modifiers.multiplier()),
@@ -188,9 +188,9 @@ impl Model {
             last_rhythm: (999, WaypointId::Frame(999)), // Should be never the first one
             rhythms: Vec::new(),
 
-            beat_time: Time::ZERO,
-            real_time: Time::ZERO,
-            switch_time: Time::ZERO,
+            exact_time: Time::ZERO,
+            real_time: FloatTime::ZERO,
+            switch_time: FloatTime::ZERO,
 
             restart_button: HoverButton::new(
                 Collider::new(vec2(-3.0, 0.0).as_r32(), Shape::Circle { radius: r32(1.0) }),
diff --git a/src/model/player.rs b/src/model/player.rs
index da0ea2e9..4a522b9d 100644
--- a/src/model/player.rs
+++ b/src/model/player.rs
@@ -5,7 +5,7 @@ pub struct Player {
     pub info: UserInfo,
     pub shake: vec2<Coord>,
     pub collider: Collider,
-    pub health: Bounded<Time>,
+    pub health: Bounded<FloatTime>,
 
     /// Whether currently perfectly inside the center of the light.
     /// Controlled by the collider.
@@ -38,7 +38,7 @@ pub enum LitState {
 }
 
 impl Player {
-    pub fn new(collider: Collider, health: Time) -> Self {
+    pub fn new(collider: Collider, health: FloatTime) -> Self {
         Self {
             info: UserInfo {
                 id: 0,
@@ -69,7 +69,7 @@ impl Player {
         }
     }
 
-    pub fn update_tail(&mut self, delta_time: Time) {
+    pub fn update_tail(&mut self, delta_time: FloatTime) {
         for tail in &mut self.tail {
             tail.lifetime.change(-delta_time);
         }
@@ -147,8 +147,8 @@ impl Player {
 
     pub fn update_light_distance(&mut self, light: &Light, last_rhythm: (usize, WaypointId)) {
         let (time, waypoint) = light.closest_waypoint;
-        let at_waypoint = time.as_f32() > -COYOTE_TIME
-            && time.as_f32() < BUFFER_TIME
+        let at_waypoint = time > -COYOTE_TIME
+            && time < BUFFER_TIME
             && light
                 .event_id
                 .map_or(false, |event| last_rhythm != (event, waypoint));
diff --git a/src/model/score.rs b/src/model/score.rs
index 9bca3ee3..dc32f726 100644
--- a/src/model/score.rs
+++ b/src/model/score.rs
@@ -62,7 +62,7 @@ impl Score {
 
     /// Update the score given current player state.
     #[must_use]
-    pub fn update(&mut self, player: &Player, delta_time: Time) -> Vec<GameEvent> {
+    pub fn update(&mut self, player: &Player, delta_time: FloatTime) -> Vec<GameEvent> {
         let events = self.metrics.update(player, delta_time);
         self.calculated = CalculatedScore::from_metrics(&self.metrics, self.multiplier);
         events
@@ -106,7 +106,7 @@ impl ScoreMetrics {
     }
 
     /// Update the metrics given the new player state.
-    pub fn update(&mut self, player: &Player, delta_time: Time) -> Vec<GameEvent> {
+    pub fn update(&mut self, player: &Player, delta_time: FloatTime) -> Vec<GameEvent> {
         let mut events = Vec::new();
         if player.is_keyframe {
             events.extend(self.discrete.update(player));
@@ -156,7 +156,7 @@ impl DynamicMetrics {
     }
 
     /// Update the metrics given the new player state.
-    pub fn update(&mut self, player: &Player, delta_time: Time) -> Vec<GameEvent> {
+    pub fn update(&mut self, player: &Player, delta_time: FloatTime) -> Vec<GameEvent> {
         let events = Vec::new();
 
         self.frames += 1;
diff --git a/src/render/dither.rs b/src/render/dither.rs
index 2d461b48..47be4597 100644
--- a/src/render/dither.rs
+++ b/src/render/dither.rs
@@ -58,7 +58,7 @@ impl DitherRender {
         self.noise = noise;
     }
 
-    pub fn finish(&mut self, time: Time, theme: &Theme) -> ugli::Framebuffer {
+    pub fn finish(&mut self, time: FloatTime, theme: &Theme) -> ugli::Framebuffer {
         let mut other_framebuffer =
             geng_utils::texture::attach_texture(&mut self.double_buffer.1, self.geng.ugli());
 
diff --git a/src/render/editor/game.rs b/src/render/editor/game.rs
index 797feefe..193cb030 100644
--- a/src/render/editor/game.rs
+++ b/src/render/editor/game.rs
@@ -177,35 +177,35 @@ impl EditorRender {
                     };
 
                     // TODO: adapt to movement density
-                    /// How many beats away are the waypoints still visible
-                    const VISIBILITY: f32 = 5.0;
+                    /// How much time away are the waypoints still visible
+                    const VISIBILITY: Time = TIME_IN_FLOAT_TIME * 5;
                     /// The minimum transparency level of waypoints outside visibility
                     const MIN_ALPHA: f32 = 0.2;
                     /// Waypoints past this time-distance are not rendered at all
-                    const MAX_VISIBILITY: f32 = 15.0;
+                    const MAX_VISIBILITY: Time = TIME_IN_FLOAT_TIME * 15;
                     // Calculate the waypoint visibility at the given relative timestamp
                     let visibility = |beat: Time| {
-                        let d = (timed_event.beat + event.telegraph.precede_time + beat
+                        let d = (timed_event.time + event.telegraph.precede_time + beat
                             - level_editor.current_time)
-                            .abs()
-                            .as_f32();
+                            .abs();
                         if d > MAX_VISIBILITY {
                             return 0.0;
                         }
-                        let d = d / VISIBILITY;
+                        let d = d as f32 / VISIBILITY as f32;
                         (1.0 - d.sqr()).clamp(MIN_ALPHA, 1.0)
                     };
 
                     // A dashed line moving through the waypoints to show general direction
                     const NUM_POINTS: usize = 25;
                     let num_points = NUM_POINTS * event.light.movement.key_frames.len();
-                    let period = event.light.movement.movement_duration().max(r32(0.01)); // NOTE: avoid dividing by 0
+                    let period =
+                        time_to_seconds(event.light.movement.movement_duration()).max(r32(0.01)); // NOTE: avoid dividing by 0
                     let speed = r32(4.0).recip();
                     let positions: Vec<draw2d::ColoredVertex> = (0..num_points)
                         .map(|i| {
                             let t = r32(i as f32 / num_points as f32);
                             let t = (level_editor.real_time / period * speed + t).fract() * period;
-                            let t = t + event.light.movement.fade_in;
+                            let t = seconds_to_time(t) + event.light.movement.fade_in;
                             let alpha = visibility(t);
                             draw2d::ColoredVertex {
                                 a_pos: event.light.movement.get(t).translation.as_f32(), // TODO: check performance
@@ -251,7 +251,7 @@ impl EditorRender {
                                         if let Event::Light(light) = &event.event {
                                             let beat = light.light.movement.get_time(i)?;
                                             alpha = visibility(beat);
-                                            return Some((event.beat, light, beat));
+                                            return Some((event.time, light, beat));
                                         }
                                         None
                                     })
diff --git a/src/render/editor/ui.rs b/src/render/editor/ui.rs
index b7db7224..e5469446 100644
--- a/src/render/editor/ui.rs
+++ b/src/render/editor/ui.rs
@@ -92,7 +92,7 @@ impl EditorRender {
 
         self.ui.draw_text(&ui.timing, framebuffer);
         self.ui.draw_value(&ui.bpm, framebuffer);
-        self.ui.draw_value(&ui.offset, framebuffer);
+        // self.ui.draw_value(&ui.offset, framebuffer);
 
         self.ui.draw_text(&ui.music, framebuffer);
         self.ui.draw_text(&ui.level, framebuffer);
@@ -114,9 +114,9 @@ impl EditorRender {
         }
 
         self.ui.draw_text(&ui.timeline, framebuffer);
-        self.ui.draw_value(&ui.scroll_by, framebuffer);
-        self.ui.draw_value(&ui.shift_scroll, framebuffer);
-        self.ui.draw_value(&ui.alt_scroll, framebuffer);
+        // self.ui.draw_value(&ui.scroll_by, framebuffer);
+        // self.ui.draw_value(&ui.shift_scroll, framebuffer);
+        // self.ui.draw_value(&ui.alt_scroll, framebuffer);
     }
 
     fn draw_tab_edit(&mut self, editor: &Editor, ui: &EditorEditWidget) {
diff --git a/src/render/game.rs b/src/render/game.rs
index 646d6468..aaf8011a 100644
--- a/src/render/game.rs
+++ b/src/render/game.rs
@@ -103,7 +103,7 @@ impl GameRender {
             } else {
                 THEME.danger
             };
-            let t = rhythm.time.get_ratio().as_f32();
+            let t = rhythm.time.clone().map(|t| t as f32).get_ratio();
 
             let scale = r32(crate::util::smoothstep(1.0 - t));
             let mut visual = model
diff --git a/src/render/mod.rs b/src/render/mod.rs
index e1af2217..d14536b8 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -15,10 +15,10 @@ pub const THEME: Theme = Theme {
     highlight: Color::BLUE,
 };
 
-pub fn smooth_button(button: &HoverButton, time: Time) -> HoverButton {
+pub fn smooth_button(button: &HoverButton, time: FloatTime) -> HoverButton {
     // Appear at 1.0
     // Fade in until 2.0
-    let t = (time - Time::ONE).clamp(Time::ZERO, Time::ONE);
+    let t = (time - FloatTime::ONE).clamp(FloatTime::ZERO, FloatTime::ONE);
     let t = crate::util::smoothstep(t);
 
     let mut button = button.clone();
diff --git a/src/render/util.rs b/src/render/util.rs
index a0a422f8..d757988e 100644
--- a/src/render/util.rs
+++ b/src/render/util.rs
@@ -258,7 +258,7 @@ impl UtilRender {
         let fade_in = 0.25;
         let fade_out = 0.5;
 
-        let t = light.closest_waypoint.0.as_f32();
+        let t = time_to_seconds(light.closest_waypoint.0).as_f32();
         let t = (t / fade_in + 1.0).min(1.0 - t / fade_out).max(0.0);
         let radius = r32(t * radius_max);
 
@@ -492,7 +492,7 @@ impl UtilRender {
         framebuffer: &mut ugli::Framebuffer,
     ) {
         let t = button.hover_time.get_ratio();
-        let scale = button.animation.get(t).scale;
+        let scale = button.animation.get(seconds_to_time(t)).scale;
         let collider = button
             .base_collider
             .transformed(Transform { scale, ..default() });
diff --git a/src/ui/widget/timeline.rs b/src/ui/widget/timeline.rs
index f981faae..d8779154 100644
--- a/src/ui/widget/timeline.rs
+++ b/src/ui/widget/timeline.rs
@@ -28,9 +28,9 @@ pub struct TimelineWidget {
 
     /// Render scale in pixels per beat.
     scale: f32,
-    /// The scrolloff in beats.
+    /// The scrolloff in exact time.
     scroll: Time,
-    raw_current_beat: Time,
+    raw_current_time: Time,
     raw_left: Option<Time>,
     raw_right: Option<Time>,
     raw_replay: Option<Time>,
@@ -70,7 +70,7 @@ impl TimelineWidget {
 
             scale: 15.0,
             scroll: Time::ZERO,
-            raw_current_beat: Time::ZERO,
+            raw_current_time: Time::ZERO,
             raw_left: None,
             raw_right: None,
             raw_replay: None,
@@ -92,7 +92,7 @@ impl TimelineWidget {
         // scroll so that current beat stays in-place
         let min = self.state.position.min.x;
         let current = self.current_beat.position.center().x;
-        self.scroll = r32(current - min) / r32(new_scale) - self.raw_current_beat;
+        self.scroll = ((current - min) / (new_scale)) as Time - self.raw_current_time;
 
         self.scale = new_scale;
         self.reload(None);
@@ -105,7 +105,7 @@ impl TimelineWidget {
     // }
 
     pub fn visible_scroll(&self) -> Time {
-        r32(self.state.position.width() / self.scale)
+        (self.state.position.width() / self.scale) as Time
     }
 
     pub fn get_scroll(&self) -> Time {
@@ -118,33 +118,33 @@ impl TimelineWidget {
     }
 
     pub fn update_time(&mut self, current_beat: Time, replay: Option<Time>) {
-        self.raw_current_beat = current_beat;
+        self.raw_current_time = current_beat;
         self.raw_replay = replay;
         self.reload(None);
 
-        // Auto scroll if current beat goes off screen
+        // Auto scroll if current time goes off screen
         let margin = 50.0;
-        let margin_beats = r32(margin / self.scale);
+        let margin_time = margin / self.scale;
 
         let min = margin;
         let max = self.state.position.width() - margin;
         let current = self.current_beat.position.center().x - self.state.position.min.x;
-        if current < min && self.raw_current_beat > margin_beats {
-            self.scroll(r32((min - current) / self.scale));
+        if current < min && self.raw_current_time as f32 > margin_time {
+            self.scroll(((min - current) / self.scale) as Time);
         } else if current > max {
-            self.scroll(r32((max - current) / self.scale));
+            self.scroll(((max - current) / self.scale) as Time);
         }
         self.reload(None);
     }
 
     pub fn start_selection(&mut self) {
-        self.raw_left = Some(self.raw_current_beat);
+        self.raw_left = Some(self.raw_current_time);
         self.reload(None);
     }
 
     /// Finishes the selection and returns the left and right boundaries in ascending order.
     pub fn end_selection(&mut self) -> (Time, Time) {
-        let right = self.raw_current_beat;
+        let right = self.raw_current_time;
         self.raw_right = Some(right);
         self.reload(None);
 
@@ -164,7 +164,7 @@ impl TimelineWidget {
 
     fn reload(&mut self, mut editor: Option<(&LevelEditor, &mut Vec<LevelAction>)>) {
         let render_time = |time: Time| {
-            let pos = (time + self.scroll).as_f32() * self.scale;
+            let pos = (time + self.scroll) as f32 * self.scale;
             let pos = vec2(
                 self.state.position.min.x + pos,
                 self.state.position.center().y,
@@ -172,7 +172,7 @@ impl TimelineWidget {
             Aabb2::point(pos).extend_symmetric(vec2(0.1, 0.5) * self.context.font_size / 2.0)
         };
         self.current_beat
-            .update(render_time(self.raw_current_beat), &self.context);
+            .update(render_time(self.raw_current_time), &self.context);
 
         self.lights.clear();
         self.waypoints.clear();
@@ -180,7 +180,7 @@ impl TimelineWidget {
         let height = self.context.font_size * 0.4;
         for (i, event) in self.level.events.iter().enumerate() {
             if let Event::Light(light) = &event.event {
-                let time = event.beat + light.telegraph.precede_time;
+                let time = event.time + light.telegraph.precede_time;
                 let light_id = LightId { event: i };
                 if Some(light_id) == self.selected_light {
                     let from = render_time(time).center();
@@ -243,7 +243,8 @@ impl TimelineWidget {
     }
 
     pub fn get_cursor_time(&self) -> Time {
-        r32((self.context.cursor.position.x - self.state.position.min.x) / self.scale) - self.scroll
+        ((self.context.cursor.position.x - self.state.position.min.x) / self.scale) as Time
+            - self.scroll
     }
 }