Removed the leak, but still lost on the game update loop

src/utils/timer.zig

@@ -1,57 +1,62 @@
 const sdl = @import("./../sdl.zig").c;
+const std = @import("std");
 
 pub const TimerStatus = enum { started, stopped, paused };
 
 pub const Timer = struct {
-    start_ticks_ms: u32 = 0,
-    pause_ticks_ms: u32 = 0,
+    start_ticks_ns: f64 = 0.0,
+    pause_ticks_ns: f64 = 0.0,
     status: TimerStatus = TimerStatus.stopped,
 
     pub fn start(self: *Timer) void {
         if (self.status == .started) return;
         self.status = .started;
-        self.start_ticks_ms = sdl.SDL_GetTicks();
-        self.pause_ticks_ms = 0;
+        self.start_ticks_ns = @floatFromInt(std.time.nanoTimestamp());
+        self.pause_ticks_ns = 0;
     }
 
     pub fn stop(self: *Timer) void {
         if (self.status == .stopped) return;
         self.status = .stopped;
-        self.start_ticks_ms = 0;
-        self.pause_ticks_ms = 0;
+        self.start_ticks_ns = 0;
+        self.pause_ticks_ns = 0;
     }
 
     // Resets the timer to 0 and starts it
     pub fn reset(self: *Timer) void {
         self.status = .started;
-        self.start_ticks_ms = sdl.SDL_GetTicks();
-        self.pause_ticks_ms = 0;
+        self.start_ticks_ns = @floatFromInt(std.time.nanoTimestamp());
+        self.pause_ticks_ns = 0;
     }
 
     pub fn pause(self: *Timer) void {
         if (self.status == .paused or self.status == .stopped) return;
         self.status = .paused;
-        self.pause_ticks_ms = sdl.SDL_GetTicks();
+        const ns_stampf: f64 = @floatFromInt(std.time.nanoTimestamp());
+        self.pause_ticks_ns = (ns_stampf - self.start_ticks_ns) / 1_000_000;
     }
 
     pub fn unpause(self: *Timer) void {
         if (self.status == .started or self.status == .stopped) return;
         self.status = .started;
-        self.start_ticks_ms = sdl.SDL_GetTicks() - self.pause_ticks_ms;
-        self.pause_ticks_ms = 0;
+        const ns_stampf: f64 = @floatFromInt(std.time.nanoTimestamp());
+        const diff_ns: f64 = ns_stampf - self.pause_ticks_ns;
+        self.start_ticks_ns = self.start_ticks_ns + diff_ns;
+        self.pause_ticks_ns = 0;
     }
 
     // Gets the current tick/ms of the timer
-    pub fn getTicks(self: *Timer) u32 {
+    pub fn getTicks(self: *Timer) f64 {
         switch (self.status) {
             .stopped => {
                 return 0;
             },
             .paused => {
-                return self.pause_ticks_ms;
+                return self.pause_ticks_ns / 1_000_000;
             },
             .started => {
-                return sdl.SDL_GetTicks() - self.start_ticks_ms;
+                const ns_stampf: f64 = @floatFromInt(std.time.nanoTimestamp());
+                return (ns_stampf - self.start_ticks_ns) / 1_000_000;
             },
         }
     }