Leaky mess rn...

src/main.zig

@@ -4,8 +4,13 @@ const gs = @import("./game_state.zig");
 const assert = std.debug.assert;
 const SCREEN_WIDTH = 640;
 const SCREEN_HEIGHT = 480;
-const SCREEN_FPS: f64 = 60.0;
+const SCREEN_FPS: f64 = 30.0;
 const SCREEN_TICKS_PER_FRAME: f64 = 1000 / SCREEN_FPS;
+const PHYS_UPS: f64 = 310.0;
+const PHYS_TICKS_PER_UPDATE: f64 = 1000 / PHYS_UPS;
+const PHYS_UPDATES_PER_RENDER: f64 = PHYS_UPS / SCREEN_FPS;
+const phys_updates_per_render: u32 = @intFromFloat(PHYS_UPDATES_PER_RENDER);
+
 const log = sdl.SDL_Log;
 const GameText = @import("./text.zig").GameText;
 const RGBAColor = @import("./utils/rgb_color.zig").RGBAColor;
@@ -28,36 +33,20 @@ pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();
 
-    try GameText.initFont();
-    defer GameText.deinitFont();
-
-    var game_state = try gs.GameState.init(allocator, renderer);
-    defer game_state.deinit();
+    var game_state_controller = try gs.GameStateController.init(allocator, renderer);
+    defer game_state_controller.deinit();
 
     var quit = false;
-    var fps_timer = Timer{};
-    fps_timer.start();
+
     var frame_time = Timer{};
+    frame_time.start();
+
     var prev_frame_ms: f64 = 16.0;
     var accumulator: f64 = 0.0;
+    var prev_game_state: ?*const gs.GameState = null;
+    var current_game_state: ?*const gs.GameState = undefined;
 
     while (!quit) {
-        frame_time.reset();
-        var event: sdl.SDL_Event = undefined;
-        while (sdl.SDL_PollEvent(&event) != 0) {
-            switch (event.type) {
-                sdl.SDL_QUIT => {
-                    quit = true;
-                },
-                sdl.SDL_KEYDOWN => {
-                    switch (event.key.keysym.sym) {
-                        else => {},
-                    }
-                    log("Got key event: %i\n", event.key.keysym.sym);
-                },
-                else => {},
-            }
-        }
 
         // double newTime = time();
         // double frameTime = newTime - currentTime;
@@ -80,17 +69,60 @@ pub fn main() !void {
         // State state = currentState * alpha +
         //     previousState * ( 1.0 - alpha );
 
-        // render( state );
-        accumulator = accumulator + prev_frame_ms;
-        while (accumulator >= SCREEN_TICKS_PER_FRAME) {
-            try game_state.update_tick();
-            accumulator = accumulator - SCREEN_TICKS_PER_FRAME;
-            std.debug.print("Tick update done. Acc: {d}\n", .{accumulator});
+        // Wait for time to render screen, keep running physics
+        accumulator = accumulator + SCREEN_TICKS_PER_FRAME;
+        const total_phys_ticks: u32 = @intFromFloat(PHYS_TICKS_PER_UPDATE * PHYS_UPDATES_PER_RENDER);
+        const phys_done_at_ticks: u32 = sdl.SDL_GetTicks() + total_phys_ticks;
+        var phys_ticks_used: f64 = 0;
+        std.debug.print("phys ticks/upd: {d}, Acc: {d}\nTotal phys ticks {d}ms\nPhys done at {d}ms\n", .{ PHYS_TICKS_PER_UPDATE, accumulator, total_phys_ticks, phys_done_at_ticks });
+        // Run a physics update
+        while (accumulator >= PHYS_TICKS_PER_UPDATE) {
+            // Control loop here
+            var event: sdl.SDL_Event = undefined;
+            while (sdl.SDL_PollEvent(&event) != 0) {
+                switch (event.type) {
+                    sdl.SDL_QUIT => {
+                        quit = true;
+                    },
+                    sdl.SDL_KEYDOWN => {
+                        switch (event.key.keysym.sym) {
+                            else => {},
+                        }
+                        log("Got key event: %i\n", event.key.keysym.sym);
+                    },
+                    else => {},
+                }
+            }
+            prev_game_state = current_game_state;
+            current_game_state = try game_state_controller.update_tick();
+            const phys_ticks_this_update: f64 = current_game_state.?.phys_ticks - phys_ticks_used;
+
+            std.debug.print(" PU in {d}ms ", .{phys_ticks_this_update});
+            std.debug.print(" Acc:{d} - ", .{accumulator});
+
+            // TODO dont turn it into an int, take the extra phys_frames and do a partial render
+            if (phys_ticks_this_update < PHYS_TICKS_PER_UPDATE) {
+                const ticks: u32 = @intFromFloat(PHYS_TICKS_PER_UPDATE - phys_ticks_this_update);
+                sdl.SDL_Delay(ticks);
+                accumulator -= PHYS_TICKS_PER_UPDATE;
+            } else {
+                std.debug.print("\nPHYSICS JANK\nPhysics Update took {d}ms, target: {d}ms\n", .{ phys_ticks_this_update, PHYS_TICKS_PER_UPDATE });
+                accumulator -= phys_ticks_this_update;
+            }
+            phys_ticks_used = current_game_state.?.phys_ticks;
+            std.debug.print(" PhyTicks this render: {d} ", .{current_game_state.?.phys_ticks});
         }
 
-        game_state.render();
+        // TODO lerp together prev and current states
+        // Otherwise will have physics jank
+
+        // Update screen frame
+        std.debug.print("Took {d} phys frames\n", .{current_game_state.?.phys_updates_since_render});
+        try game_state_controller.render(current_game_state.?);
 
         prev_frame_ms = @floatFromInt(frame_time.getTicks());
+        std.debug.print("Rendered to screen in {d}ms\n***\n***\n", .{prev_frame_ms});
+        frame_time.reset();
         // const frame_time_ticks = frame_time.getTicks();
         // if (frame_time_ticks < SCREEN_TICKS_PER_FRAME) {
         //     sdl.SDL_Delay(SCREEN_TICKS_PER_FRAME - frame_time_ticks);