Add/update camera mechanism, Add collision detection

Author: tmaegel

pyproject.toml

@@ -78,7 +78,7 @@ disallow_any_explicit = false
 # explicit type parameters.
 disallow_any_generics = true
 # Disallows subclassing a value of type Any.
-disallow_subclassing_any = true
+disallow_subclassing_any = false
 
 # Untyped definitions and calls
 # Disallows calling functions without type annotations

pysurvive/game/core.py

@@ -1,92 +1,74 @@
 #!/usr/bin/env python
 # coding=utf-8
-import pygame as pg
-
-from pysurvive.config import SCREEN_RECT
-
 
-class Singleton(type):
-    _instances = {}
+import pygame as pg
 
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+from pysurvive.config import DEBUG_SPRITE, RED
 
-        return cls._instances[cls]
 
+class CameraBoxBorder:
+    left: int = 300
+    right: int = 300
+    top: int = 300
+    bottom: int = 300
 
-class Screen(pg.rect.Rect, metaclass=Singleton):
 
-    """
-    Class that represent the screen and is used to detect
-    wheather objects are visible on the screen.
-    """
+class Camera(pg.sprite.Group):
+    def __init__(self) -> None:
+        super().__init__()
+        self.display_surface = pg.display.get_surface()
+        self.width = self.display_surface.get_size()[0]
+        self.height = self.display_surface.get_size()[1]
+        self.screenx = self.width // 2
+        self.screeny = self.height // 2
+        self.offset = pg.math.Vector2()
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        # Calculate a slightly larger rectangle of the screen.
-        # Otherwise, there will be white flickering at the edges
-        # when drawing the sprites on the screen.
-        rough_w = self.width * 0.01
-        rough_h = self.height * 0.01
-        self.rect_rough = pg.Rect(
-            self.x - rough_w,
-            self.y - rough_w,
-            self.width + rough_w * 2,
-            self.height + rough_h * 2,
+        self.camera_box = pg.Rect(
+            CameraBoxBorder.left,
+            CameraBoxBorder.top,
+            self.width - (CameraBoxBorder.left + CameraBoxBorder.right),
+            self.height - (CameraBoxBorder.top + CameraBoxBorder.bottom),
         )
 
-    def __str__(self) -> str:
-        return f"Screen (size={self.width}x{self.height})"
-
-    @classmethod
-    def delete(cls) -> None:
-        """Unset singleton."""
-        cls._instances = {}
+    def __repr__(self) -> str:
+        return f"Camera(x={self.x} x {self.x})"
 
     @property
-    def rect(self) -> pg.rect.Rect:
-        """
-        The function spritecollide expects a property rect.
-        Returns the rough rect of the screen here.
-        """
-        return self.rect_rough
+    def x(self) -> float:
+        return self.offset.x
 
+    @property
+    def y(self) -> float:
+        return self.offset.y
 
-class Camera(metaclass=Singleton):
-
-    """
-    Class that represents the absolute position of the
-    camera (player) in the game world.
-    """
-
-    def __init__(self, x: int = 0, y: int = 0) -> None:
-        self.screen = Screen(SCREEN_RECT)
-        self.x = x
-        self.y = y
+    @x.setter
+    def x(self, _x: float) -> None:
+        self.offset.x = _x
 
-    def __str__(self) -> str:
-        return f"Camera (x={self.x}, y={self.y})"
+    @y.setter
+    def y(self, _y: float) -> None:
+        self.offset.y = _y
 
-    @classmethod
-    def delete(cls) -> None:
-        """Unset singleton."""
-        cls._instances = {}
+    @property
+    def rect(self) -> pg.FRect:
+        """Returns the camera / screen rect."""
+        return pg.FRect(self.x, self.y, self.width, self.height)
 
     @property
-    def position(self) -> tuple[int, int]:
-        """Returns camera position in a tuple."""
-        return (self.x, self.y)
-
-    def move(self, delta: tuple[int, int]) -> None:
-        """Move the camera by delta x, y."""
-        self.x = round(self.x - delta[0])
-        self.y = round(self.y - delta[1])
-
-    def get_rel_position(self, x: int, y: int) -> tuple[int, int]:
-        """Returns the relative position of a coordinate in relation
-        to the global camera position (center of the screen)."""
-        return (
-            round(x - self.x + self.screen.centerx),
-            round(y - self.y + self.screen.centery),
+    def near_area_rect(self) -> pg.FRect:
+        return pg.FRect(
+            self.x + self.screenx - 75, self.y + self.screeny - 75, 150, 150
         )
+
+    def update(self, target) -> None:
+        if target.x < self.camera_box.left:
+            self.camera_box.left = target.x
+        if target.x > self.camera_box.right:
+            self.camera_box.right = target.x
+        if target.y < self.camera_box.top:
+            self.camera_box.top = target.y
+        if target.y > self.camera_box.bottom:
+            self.camera_box.bottom = target.y
+
+        self.x = self.camera_box.left - CameraBoxBorder.left
+        self.y = self.camera_box.top - CameraBoxBorder.top

pysurvive/game/loop.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 # coding=utf-8
+import time
+
 import pygame as pg
 from pygame.locals import (
     K_ESCAPE,
@@ -10,17 +12,17 @@
     QUIT,
 )
 
-from pysurvive.config import FPS, GRAY_LIGHT2, MAP_DIR, RED_LIGHT, SCREEN_RECT
-from pysurvive.game.core import Camera, Screen
+from pysurvive.config import FPS, GRAY_LIGHT2, MAP_DIR, SCREEN_RECT
+from pysurvive.game.core import Camera
 from pysurvive.logger import Logger
 from pysurvive.map.level import Level
-from pysurvive.player import PlayerGroup
+from pysurvive.player.player import PlayerGroup
+from pysurvive.player.viewpoint import Viewpoint
 
 logger = Logger()
 
 
 class Game:
-
     running = True
 
     def __init__(self) -> None:
@@ -30,11 +32,10 @@ def __init__(self) -> None:
         self.clock = pg.time.Clock()
         self.fps_font = pg.font.SysFont("Arial", 14)
 
-        # Sprite that represent the screen.
-        # Used to determine whether elements are in the viewing area.
-        self.screen = Screen(SCREEN_RECT)
-        # Set the height and width of the screen.
-        self.window_surface = pg.display.set_mode(self.screen.size)
+        # Set the height and width of the camera/screen.
+        self.window_surface = pg.display.set_mode(
+            (SCREEN_RECT.width, SCREEN_RECT.height)
+        )
         # Set the window title.
         pg.display.set_caption("pysurvive")
         pg.transform.set_smoothscale_backend("SSE")
@@ -45,125 +46,59 @@ def __init__(self) -> None:
             [QUIT, KEYDOWN, K_ESCAPE, MOUSEBUTTONDOWN, MOUSEBUTTONUP, MOUSEMOTION]
         )
 
-        # Absolute (start) position of the player (camera) in game world.
-        self.camera = Camera(150, 600)
-
-        # Prepare the shadow surface / screen.
-        # self.screen_shadow = pg.Surface(self.screen.size)
-        # self.screen_shadow = self.screen_shadow.convert()
-        # self.screen_shadow.set_alpha(240)
-        # self.screen_shadow.set_colorkey(COLORKEY)
-
-        #
-        # Prepare game objects
-        #
-
-        # Initialize the navmesh based on the map.
-        # self.navmesh = NavMesh(self)
-
-        # self.enemy_sprites = pg.sprite.RenderPlain(
-        #     Enemy(self, 100, 100),
-        # )
-        # A sprite group that contains all close enemy sprites (render only).
-        # self.enemy_render_sprites = pg.sprite.RenderPlain()
-        # A sprite group that contains all close sprites (collision only).
-        # self.collide_sprites = pg.sprite.RenderPlain()
-
-        # Get all unique points (corners) of block segments.
-        # Prevent duplication of x, y coordinates.
-        # self.unique_block_points = []
-        # for block in self.block_sprites.sprites():
-        #     for block_point in block.get_points():
-        #         point = (block_point[0], block_point[1])
-        #         if point not in self.unique_block_points:
-        #             self.unique_block_points.append(point)
-
-        # Map
+        self.camera = Camera()
+        self.interface = pg.sprite.Group()
+
         self.level = Level(f"{MAP_DIR}/map.json")
-        # Player
-        self.player_sprites = PlayerGroup(self.level)
+        self.viewpoint = Viewpoint(self.interface)
+        self.player_sprites = PlayerGroup(
+            camera=self.camera,
+            viewpoint=self.viewpoint,
+        )
 
     def start(self) -> None:
         """
         This function is called when the program starts. It initializes
         everything it needs, then runs in a loop until the function returns.
         """
 
-        while self.running:
+        prev_time = time.time()
 
+        while self.running:
             # The number of milliseconds that passed between the
             # previous two calls to Clock.tick().
-            dt = self.clock.get_time()
+            dt = time.time() - prev_time
+            prev_time = time.time()
 
-            # @todo: Get keyboard inputs by player object.
             for event in pg.event.get():
                 if event.type == QUIT:
                     self.running = False
                 elif event.type == KEYDOWN and event.key == K_ESCAPE:
                     self.running = False
-                # elif event.type == MOUSEBUTTONDOWN:
-                #     if event.button == 1:
-                #         self.player_sprites.player.shot()
-                #     elif event.button == 3:
-                #         self.player_sprites.player.reload()
                 elif event.type == MOUSEBUTTONUP:
                     pass
 
-            keystate = pg.key.get_pressed()
-            direction_x = keystate[pg.K_d] - keystate[pg.K_a]
-            direction_y = keystate[pg.K_s] - keystate[pg.K_w]
-
-            # Fill the window surface with the default background color.
+            # Default background color.
             self.window_surface.fill(GRAY_LIGHT2)
 
             #
             # Updating
             #
 
-            self.level.update()
-            self.player_sprites.update(dt, (direction_x, direction_y))
+            self.level.update(self.camera)
+            self.player_sprites.update(dt, self.level)
+            self.interface.update()
 
             #
             # Drawing
             #
 
-            self.level.draw(self.window_surface)
-
-            # if FLASHLIGHT_ENABLE:
-            #     # Currently, all vertices within a virtual screen of
-            #     # 3x width and 3x height of the screen are used. Later
-            #     # when the visibility is limited, this can be further reduced.
-            #     self.screen_shadow.fill(BLACK)
-            #     self.player_sprites.light.draw(self.screen_shadow)
-            #     self.window_surface.blit(self.screen_shadow, (0, 0))
-
-            self.player_sprites.draw(self.window_surface)
-
-            # Debugging
-            # Draw navmesh
-            # for tri in self.navmesh.mesh:
-            #     triangle = [(p[0] - self.game_x, p[1] - self.game_y)
-            #                 for p in tri.triangle]
-            #     pg.draw.polygon(self.window_surface, (255, 0, 0), triangle, 1)
-            #     for node in tri.nodes:
-            #         pg.draw.circle(self.window_surface, (0, 255, 0),
-            #                        (node.position[0] - self.game_x,
-            #                         node.position[1] - self.game_y), 2)
-
-            # path = self.enemy_sprites.sprites()[0].path
-            # if path:
-            #     path = [(p[0] - self.game_x, p[1] - self.game_y) for p in path]
-            #     pg.draw.lines(self.window_surface, (0, 0, 255), False, path)
-
-            self.window_surface.blit(self.update_fps(), (5, 5))
+            self.level.draw(self.window_surface, self.camera)
+            self.player_sprites.draw(self.window_surface, self.camera)
+            self.interface.draw(self.window_surface)
 
             # Go ahead and update the window surface with what we've drawn.
             # This MUST happen after all the other drawing commands.
             pg.display.flip()
             # This limits the while loop to a max of FPS times per second.
             self.clock.tick(FPS)
-
-    def update_fps(self):
-        fps = str(int(self.clock.get_fps()))
-        fps_text = self.fps_font.render(fps, 1, RED_LIGHT)
-        return fps_text