Assignment 1 commit: Moon & Apollo - code quality improvements and implementation of .env file

apollo/apollo.py

@@ -0,0 +1,40 @@
+import os
+
+import pygame
+
+from moon.moon import Moon
+from numeric.compute import rot_2D, matmul
+
+
+class Apollo(Moon):
+    def __init__(self, orbiter_size: int=None, orbiter_distance:int=None, orbiter_speed:float=None):
+        super().__init__()
+
+        if orbiter_size is None:
+            self.orbiter_size = int(os.getenv("ORBITER_SIZE", "4"))
+        else:
+            self.orbiter_size = orbiter_size
+        if orbiter_distance is None:
+            self.orbiter_distance = int(os.getenv("ORBITER_DISTANCE", "50"))
+        else:
+            self.orbiter_distance = orbiter_distance
+        if orbiter_speed is None:
+            self.orbiter_speed = float(os.getenv("ORBITER_SPEED", "1"))
+        else:
+            self.orbiter_speed = orbiter_speed
+
+        self.orbiter_position = None
+
+    def update_game(self):
+        super().update_game()
+        self.orbiter_position = self.get_orbit_position(
+            self.orbiter_distance,
+            bary_center=self.moon_position,
+            angle=-self.angle
+        )
+        return True
+
+    def draw_game(self):
+        super().draw_game()
+        pygame.draw.circle(self.screen, (255,0,0), self.orbiter_position, self.orbiter_size)
+        pygame.display.flip()

apollo/main.py

@@ -0,0 +1,5 @@
+from apollo import Apollo
+
+if __name__ == '__main__':
+    game = Apollo()
+    game.run()

game/Moon.py

@@ -1,29 +0,0 @@
-import pygame
-
-from game.game import Game
-from numeric.compute import rot_2D, matmul
-
-
-class Moon(Game):
-    def __init__(self):
-        super().__init__("Moon")
-        self.moon_position = None
-        self.center = (540, 355)
-        self.moon_distance  = [[200], [0]]
-        self.angle = 0
-
-    def update_game(self):
-        self.angle = pygame.time.get_ticks() / 1000  # Zeit = Winkel
-        rot = rot_2D(self.angle)
-        rotated = matmul(rot, self.moon_distance)
-        self.moon_position = (
-            int(self.center[0] + rotated[0][0]),
-            int(self.center[1] + rotated[1][0])
-        )
-        return True
-
-    def draw_game(self):
-        self.screen.fill((30,30,30))
-        pygame.draw.circle(self.screen, (0,0,255), self.center, 12)
-        pygame.draw.circle(self.screen, (255,255,255), self.moon_position, 8)
-        pygame.display.flip()

game/apollo.py

@@ -1,26 +0,0 @@
-import pygame
-
-from game.Moon import Moon
-from numeric.compute import rot_2D, matmul
-
-
-class Apollo(Moon):
-    def __init__(self):
-        super().__init__()
-        self.orbiter_position = None
-        self.orbiter_distance = [[50], [0]]
-
-    def update_game(self):
-        super().update_game()
-        rot = rot_2D(-self.angle)
-        rotated = matmul(rot, self.orbiter_distance)
-        self.orbiter_position = (
-            int(self.moon_position[0] + rotated[0][0]),
-            int(self.moon_position[1] + rotated[1][0])
-        )
-        return True
-
-    def draw_game(self):
-        super().draw_game()
-        pygame.draw.circle(self.screen, (255,0,0), self.orbiter_position, 4)
-        pygame.display.flip()

game/game.py

@@ -1,11 +1,28 @@
+import os
+from pathlib import Path
+
 import pygame
+from dotenv import load_dotenv
+
 
 class Game:
 
-    def __init__(self, title, fps=60, size=(1080, 720)):
-        self.title = title
-        self.fps = fps
-        self.size = size
+    def __init__(self, title=None, fps=None, size=None):
+        load_dotenv(Path(__file__).resolve().parent.parent / 'config.env')
+
+        if size is None:
+            self.size = tuple(map(int, os.getenv("SIZE", "1080, 720").split(",")))
+        else:
+            self.size = size
+        if fps is None:
+            self.fps = int(os.getenv("FPS", "60"))
+        else:
+            self.fps = fps
+        if title is None:
+            self.title = os.getenv("TITLE", "Apollo")
+        else:
+            self.title = title
+
         self.clock = pygame.time.Clock()
         self.dt = 0
         self.screen = None
@@ -15,14 +32,13 @@ class Game:
         pygame.display.set_caption(self.title)
         self.screen = pygame.display.set_mode(self.size)
 
-
     def game_loop(self):
         while True:
             # Berechnung der Zeitdifferenz seit dem letzten Frame
             self.dt = self.clock.tick(self.fps) / 1000
-            if self.event_handling() == False:
+            if not self.event_handling():
                 break
-            if self.update_game() == False:
+            if not self.update_game():
                 break
             self.draw_game()
 

main.py

@@ -1,7 +0,0 @@
-from game.Moon import Moon
-from game.apollo import Apollo
-from game.game import Game
-
-if __name__ == '__main__':
-    game = Apollo()
-    game.run()

moon/main.py

@@ -0,0 +1,5 @@
+from moon import Moon
+
+if __name__ == '__main__':
+    game = Moon()
+    game.run()

moon/moon.py

@@ -0,0 +1,76 @@
+import os
+
+import pygame
+
+from game.game import Game
+from numeric.compute import rot_2D, matmul
+
+
+class Moon(Game):
+    def __init__(self,
+                 earth_position:tuple[int, int]=None,
+                 earth_size:int=None,
+                 moon_size:int=None,
+                 moon_distance:int=None,
+                 moon_speed:int=None):
+        super().__init__()
+
+        if earth_position is None:
+            self.bary_center = \
+                (tuple(map(int, os.getenv("BARY_CENTER", "{0},{1}".format((self.size[0] // 2), (self.size[1] // 2)).split(",")))))
+        else:
+            self.bary_center = earth_position
+        if earth_size is None:
+            self.earth_size = int(os.getenv("EARTH_SIZE", "12"))
+        else:
+            self.earth_size = earth_size
+        if moon_size is None:
+            self.moon_size = int(os.getenv("MOON_SIZE", "8"))
+        else:
+            self.moon_size = moon_size
+        if moon_distance is None:
+            self.moon_distance = int(os.getenv("MOON_DISTANCE", "200"))
+        else:
+            self.moon_distance = moon_distance
+        if moon_speed is None:
+            self.moon_speed = float(os.getenv("MOON_SPEED", "1"))
+        else:
+            self.moon_speed = moon_speed
+
+        self.angle = 0
+        self.moon_position = None
+
+    def update_game(self):
+        self.angle = pygame.time.get_ticks() / 1000
+        self.moon_position = self.get_orbit_position(self.moon_distance)
+        return True
+
+    def get_orbit_position(self,
+                           distance:int,
+                           bary_center:tuple[int, int]=None,
+                           angle:float=None) \
+            -> tuple[int, int]:
+        """
+        Calculates the absolute position of the satellite on the orbit.
+        :param distance: Relative distance from the primary body (radius).
+        :param bary_center: The bary center of the orbit (in this simplified simulation a point).
+        :param angle: Numeric value used to calculate the rotation matrix.
+        :return: The absolute position of the satellite.
+        """
+        if bary_center is None:
+            bary_center = self.bary_center
+        if angle is None:
+            angle = self.angle
+
+        rot = rot_2D(angle * self.moon_speed)
+        rotated = matmul(rot, [[distance], [0]])
+        return (
+            int(bary_center[0] + rotated[0][0]),
+            int(bary_center[1] + rotated[1][0])
+        )
+
+    def draw_game(self):
+        self.screen.fill((30,30,30))
+        pygame.draw.circle(self.screen, (0,0,255), self.bary_center, self.earth_size)
+        pygame.draw.circle(self.screen, (255,255,255), self.moon_position, self.moon_size)
+        pygame.display.flip()