init

Author: AuthentiCuber

.gitignore

@@ -0,0 +1 @@
+__pycache__/

example/main.py

@@ -0,0 +1,71 @@
+import time
+import pygame
+from pygame.locals import *
+import timestep
+
+pgvec2 = pygame.math.Vector2
+
+pygame.init()
+
+RESOLUTION = pygame.math.Vector2(1000, 600)
+screen = pygame.display.set_mode(RESOLUTION)
+pygame.display.set_caption("Timestep Test")
+SCREEN_WIDTH, SCREEN_HEIGHT = screen.get_size()
+
+font = pygame.font.SysFont("Calibri", 40)
+start = False
+start_time = 0
+
+
+class Player(timestep.Character):
+    def __init__(self, x: int, y: int) -> None:
+        self.image = pygame.Surface((100, 100))
+        self.image.fill("red")
+        super().__init__(x, y, self.image)
+        self.gravity = pgvec2(0, 0.1)
+
+    def update(self) -> None:
+        super().update()
+
+        self.vel.y += self.gravity.y
+        self.rect.y += round(self.vel.y)
+
+
+player = Player(500, 0)
+
+
+class game_loop(timestep.Timestep):
+    def update(self):
+        global game_running, start_time, start
+        for event in pygame.event.get():
+            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
+                game_running = False
+            if event.type == KEYDOWN:
+                if event.key == K_SPACE and not start:
+                    start = True
+                    start_time = time.time()
+
+        if start:
+            player.update()
+
+    def render(self, alpha):
+        global game_running
+
+        screen.fill((0, 0, 0))
+
+        player.draw(screen, alpha)
+
+        if player.rect.y >= SCREEN_HEIGHT:
+            finish = time.time() - start_time
+            print(finish)
+            game_running = False
+
+        pygame.display.flip()
+
+
+game = game_loop(1/60)
+
+game_running = True
+while game_running:
+    game.run_game()
+pygame.quit()

timestep.py

@@ -0,0 +1,64 @@
+"""Timestep is a module based on Pygame that implements a decoupled update and rendering to make any code framerate independant. Based on https://gafferongames.com/post/fix_your_timestep/#the-final-touch. Created so you never have to worry about multiplying by deltatime again."""
+
+import pygame
+import time
+
+
+class Character:
+    """Base class for any sprites or objects"""
+
+    def __init__(self, x: int, y: int, image: pygame.Surface) -> None:
+        self.image = image
+        self.rect = self.image.get_rect()
+        self.rect.topleft = x, y
+        self.vel = pygame.math.Vector2(0, 0)
+        self.prev_pos = pygame.math.Vector2(self.rect.topleft)
+
+    def update(self) -> None:
+        """Update """
+        self.prev_pos = self.__get_rect_pos()
+
+    def draw(self, surface: pygame.Surface, alpha: float) -> None:
+        pos = self.prev_pos.lerp(self.__get_rect_pos(), alpha)
+        surface.blit(self.image, pos)
+
+    def __get_rect_pos(self) -> pygame.math.Vector2:
+        """Return the position of the Charater's rect as a Vec2"""
+        return pygame.math.Vector2(self.rect.topleft)
+
+
+class Timestep:
+    """Class that does all the calculations to make the game framerate independant"""
+
+    def __init__(self, step: float) -> None:
+        self.__step = step
+        self.__accumulator = 0
+        self.__last_time = time.time()
+
+    def __calc_dt(self) -> float:
+        now = time.time()
+        dt = now - self.__last_time
+        self.__last_time = now
+        return dt
+
+    def update(self) -> None:
+        """Override this function with event loop and movement"""
+        pass
+
+    def render(self, alpha: float) -> None:
+        """Override this function with blits and drawing of sprites"""
+        pass
+
+    def run_game(self) -> None:
+        """Updates and renders the game framerate independantly. Should only be called within a while loop."""
+        dt = self.__calc_dt()
+        self.__accumulator += dt
+
+        while self.__accumulator >= self.__step:
+            self.update()
+
+            self.__accumulator -= self.__step
+
+        alpha = self.__accumulator / self.__step
+
+        self.render(alpha)