Refactor screen and camera classes

Author: tmaegel

Makefile

@@ -8,7 +8,7 @@ test:
 	coverage report
 
 tox:
-	tox -e py39
+	tox -e py310
 
 lint:
 	python -m flake8

pysurvive/game/core.py

@@ -5,109 +5,75 @@
 from pysurvive.config import SCREEN_RECT
 
 
-class Screen:
+class Singleton(type):
+
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+
+        print(cls._instances[cls])
+        return cls._instances[cls]
+
+
+class Screen(pg.rect.Rect, metaclass=Singleton):
 
     """
     Class that represent the screen and is used to detect
     wheather objects are visible on the screen.
     """
 
-    _screen = None
-
-    def __new__(cls, rect: pg.rect.Rect = None):
-        if cls._screen is None:
-            cls._screen = super().__new__(cls)
-            if rect:
-                cls._screen.image = pg.Surface(rect.size)
-                cls._screen.rect = rect
-            else:
-                cls._screen.image = pg.Surface(SCREEN_RECT.size)
-                cls._screen.rect = SCREEN_RECT
-
-        return cls._screen
-
     def __str__(self) -> str:
         return f"Screen (size={self.width}x{self.height})"
 
     @classmethod
-    def delete(cls):
-        cls._screen = None
-
-    @property
-    def size(self) -> tuple[int, int]:
-        return self.rect.size
-
-    @property
-    def width(self) -> int:
-        return self.rect.width
+    def delete(cls) -> None:
+        """Unset singleton."""
+        cls._instances = {}
 
     @property
-    def height(self) -> int:
-        return self.rect.height
+    def rect(self) -> pg.rect.Rect:
+        """The function spritecollide expects a property rect."""
+        return self
 
-    @property
-    def centerx(self) -> int:
-        return self.rect.centerx
-
-    @property
-    def centery(self) -> int:
-        return self.rect.centery
 
-
-class Camera:
+class Camera(metaclass=Singleton):
 
     """
-    Class that represents the absolute position of the camera (player)
-    in the game world.
+    Class that represents the absolute position of the
+    camera (player) in the game world.
     """
 
-    _camera = None
-
-    def __new__(cls, centerx: int = 0, centery: int = 0):
-        if cls._camera is None:
-            cls._camera = super().__new__(cls)
-            cls._camera.screen = Screen()
-            cls._camera.x = centerx - cls._camera.screen.centerx
-            cls._camera.y = centery - cls._camera.screen.centery
-
-        return cls._camera
+    def __init__(self, x: int = 0, y: int = 0) -> None:
+        self.screen = Screen(SCREEN_RECT)
+        self.x = x
+        self.y = y
 
     def __str__(self) -> str:
-        return f"Camera (x={self.x}, y={self.y}, centerx={self.centerx}, centery={self.centery})"
+        return f"Camera (x={self.x}, y={self.y})"
 
     @classmethod
-    def delete(cls):
-        cls._camera = None
+    def delete(cls) -> None:
+        """Unset singleton."""
+        cls._instances = {}
 
     @property
     def position(self) -> tuple[int, int]:
+        """Returns camera position in a tuple."""
         return (self.x, self.y)
 
-    @position.setter
-    def position(self, delta: tuple[int, int]) -> None:
+    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])
 
-    @property
-    def centerx(self) -> int:
-        """Returns the center cornor x position."""
-        return self.x + self.screen.centerx
-
-    @property
-    def centery(self) -> int:
-        """Returns the center cornor y position."""
-        return self.y + self.screen.centery
-
-    @property
-    def position_center(self) -> tuple[int, int]:
-        return (self.centerx, self.centery)
-
     def get_relative_position(self, x: int, y: int) -> tuple[int, int]:
         """
         Returns the relative position of a coordinate in relation
-        to the camera position.
+        to the global camera position in the center of the screen.
         """
         return (
-            round(x - self.x),
-            round(y - self.y),
+            round(x - self.x + self.screen.centerx),
+            round(y - self.y + self.screen.centery),
         )

tests/test_camera.py

@@ -25,22 +25,24 @@ def test_camera__singleton_without_args(self, singleton, delete):
         camera_1 = singleton()
         camera_2 = singleton()
         assert id(camera_1) == id(camera_2)
+        assert camera_1.position == (0, 0)
+        assert camera_2.position == (0, 0)
         delete()
 
     def test_camera__singleton_with_args_1(self, singleton, delete):
         """Test the camera singleton with arguments."""
         camera_1 = singleton(500, 300)
         camera_2 = singleton(100, 200)
         assert id(camera_1) == id(camera_2)
-        assert camera_1.position_center == (500, 300)
-        assert camera_2.position_center == (500, 300)
+        assert camera_1.position == (500, 300)
+        assert camera_2.position == (500, 300)
         delete()
 
     def test_camera__singleton_with_args_2(self, singleton, delete):
         """Test the camera singleton with arguments."""
         camera_1 = singleton(500, 300)
         camera_2 = singleton()
         assert id(camera_1) == id(camera_2)
-        assert camera_1.position_center == (500, 300)
-        assert camera_2.position_center == (500, 300)
+        assert camera_1.position == (500, 300)
+        assert camera_2.position == (500, 300)
         delete()

tests/test_screen.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 # coding=utf-8
+from typing import Optional
+
 import pygame as pg
 import pytest
 
@@ -10,7 +12,7 @@
 class TestScreen:
     @pytest.fixture()
     def singleton(self):
-        def _wrapper(rect: pg.rect.Rect = None):
+        def _wrapper(rect: Optional[pg.rect.Rect] = SCREEN_RECT):
             return Screen(rect)
 
         return _wrapper
@@ -24,7 +26,7 @@ def _wrapper() -> None:
 
     def test_screen__singleton_without_args(self, singleton, delete):
         """Test the screen singleton without arguments."""
-        screen_1 = singleton()
+        screen_1 = singleton(SCREEN_RECT)
         screen_2 = singleton()
         assert id(screen_1) == id(screen_2)
         assert screen_1.width == SCREEN_RECT.width