REFACTOR to be more modular

controllers/gui_controller.py

@@ -0,0 +1,9 @@
+from render.gui_renderer import GUIRenderer
+
+class GUIController:
+    def __init__(self, gui_renderer: GUIRenderer):
+        self.gui_renderer = gui_renderer
+        self.slider =  gui_renderer.slider
+
+    def update(self, event):
+        self.slider.handle_event(event)

controllers/map_coord_controller.py

@@ -1,18 +1,39 @@
 # Description: This file contains the CoordinateManager class which is responsible for converting coordinates to pixels and vice versa.
 
 import math
+import pygame
 from utils.utils import mapped_value
+from utils.json_object import JSONObject
 
 class MapCoordController:
-    def __init__(self, screen_width: int, screen_height: int, map_min_x: int, map_max_x, map_min_y, map_max_y):
+    def __init__(self, screen_width: int, screen_height, json_file: str, map_image_path: str):
         self.screen_width = screen_width
         self.screen_height = screen_height
-        self.map_min_x = map_min_x
+
-        self.map_max_x = map_max_x
+        # too much for one class, refactor
-        self.map_min_y = map_min_y
+        self.map_image = pygame.image.load(map_image_path)
-        self.map_max_y = map_max_y
+        self.image_width = self.map_image.get_width()
-        self.map_width = map_max_x - map_min_x
+        self.image_height = self.map_image.get_height()
-        self.map_height = map_max_y - map_min_y
+
+        # Load map data from json file
+        self.json_object = self._load_json(json_file)
+        
+        # Load map data from json object
+        self.map_min_x = self.json_object.get("pos_x")
+        self.map_min_y = self.json_object.get("pos_y")
+        self.scale = self.json_object.get("scale")
+        
+        self.map_max_x = self.map_min_x + (self.image_width * self.scale)
+        self.map_max_y = self.map_min_y - (self.image_height * self.scale)
+
+        self.map_width = self.map_max_x - self.map_min_x
+        self.map_height = self.map_max_y - self.map_min_y
+
+    def _load_json(self, path: str):
+        try:
+            return JSONObject(path)
+        except FileNotFoundError:
+            raise NotImplementedError(f"Map not implemented.")
 
     def update_screen_size(self, screen_width: int, screen_height: int):
         self.screen_width = screen_width

render/gui_renderer.py

@@ -1,4 +1,5 @@
 import pygame
+from widgets.slider import HorizontalSlider
 
 class GUIRenderer:
     def __init__(self, screen, match):
@@ -6,6 +7,8 @@ class GUIRenderer:
         self.font = pygame.font.Font(None, 36)
         self.match = match
 
+        self.slider = HorizontalSlider(self.screen, 50, 650, self.screen.get_width()-100, 20, 1, self.match.max_tick)
+
         self.colour = (255, 255, 255)
 
     def _render_current_tick(self, match_tick, max_tick):
@@ -16,6 +19,17 @@ class GUIRenderer:
         text = self.font.render(f"Score: {team_1_score} - {team_2_score}", True, self.colour)
         self.screen.blit(text, (10, 40))
 
+    def _render_slider(self):
+        # Update slider value
+        if self.slider.dragging:
+            # Set match tick if slider is being dragged
+            self.match.set_tick(int(self.slider.value))
+        else:
+            # Set slider value if slider is not being dragged
+            self.slider.set_value(self.match.tick)
+        self.slider.draw()
+
     def render(self):
         self._render_current_tick(self.match.tick, self.match.max_tick)
         self._render_team_scores(self.match.team_1.score, self.match.team_2.score)
+        self._render_slider()

render/map_renderer.py

@@ -0,0 +1,24 @@
+import pygame
+from utils.json_object import JSONObject
+from controllers.map_coord_controller import MapCoordController
+
+class MapRenderer:
+    def __init__(self, screen, map_data_path, map_image_path):
+        self.screen = screen
+        self.map_data_path = map_data_path
+        self.map_image_path = map_image_path
+
+        self.map_image = pygame.image.load(self.map_image_path)
+        
+    def _load_json(self, path: str) -> JSONObject:
+        try:
+            return JSONObject(path)
+        except FileNotFoundError:
+            raise NotImplementedError(f"Map not implemented.")
+
+    def render(self):
+        # Scale and rotate map image
+        self.map_image = pygame.transform.scale(self.map_image, (self.screen.get_width(), self.screen.get_height()))
+
+        # Draw map image
+        self.screen.blit(self.map_image, (0, 0))

render/renderer.py

@@ -1,72 +0,0 @@
-import pygame
-from widgets.slider import HorizontalSlider
-from models.match import Match
-from controllers.map_coord_controller import MapCoordController
-from render.player_renderer import PlayerRenderer
-from render.gui_renderer import GUIRenderer
-from utils.json_object import JSONObject
-
-class Renderer:
-    def __init__(self, match: Match, screen, options: dict):
-        self.screen = screen
-        self.match = match
-        self.options = options
-
-        ## Initialize fonts
-        self.font = pygame.font.Font(None, 36)
-        self.small_font = pygame.font.Font(None, 15)
-
-        # Load map data from json file
-        try:
-            self.json_object = JSONObject(f"maps/{match.map_name}.json")
-        except FileNotFoundError:
-            raise NotImplementedError(f"Map {match.map_name} not implemented.")
-        
-        # Load map data from json object
-        self.top_left_x = self.json_object.get("pos_x")
-        self.top_left_y = self.json_object.get("pos_y")
-        self.scale = self.json_object.get("scale")
-        self.rotation = self.json_object.get("rotate")
-        self.image_path = self.json_object.get("material")
-
-        # Load map image
-        self.map_image = pygame.image.load(self.image_path)
-        self.image_width = self.map_image.get_width()
-        self.image_height = self.map_image.get_height()
-
-        # Calculate bottom right coordinates for map coord controller
-        self.bottom_right_x = self.top_left_x + (self.image_width * self.scale)
-        self.bottom_right_y = self.top_left_y - (self.image_height * self.scale)
-        
-    
-        self.map_coord_controller = MapCoordController(self.screen.get_width(), self.screen.get_height(), 
-                                                       self.top_left_x, self.bottom_right_x, self.top_left_y, self.bottom_right_y)
-        
-        self.slider = HorizontalSlider(self.screen, 50, 650, self.screen.get_width()-100, 20, 1, self.match.max_tick)
-        self.player_render = PlayerRenderer(self.screen, self.match, self.map_coord_controller, self.options)
-        self.text_render = GUIRenderer(self.screen, self.match)
-
-    def render_map(self):
-        # Scale and rotate map image
-        self.map_image = pygame.transform.scale(self.map_image, (self.screen.get_width(), self.screen.get_height()))
-
-        # Draw map image
-        self.screen.blit(self.map_image, (0, 0))
-
-    def render_slider(self):
-        # Update slider value
-        if self.slider.dragging:
-            # Set match tick if slider is being dragged
-            self.match.set_tick(int(self.slider.value))
-        else:
-            # Set slider value if slider is not being dragged
-            self.slider.set_value(self.match.tick)
-        self.slider.draw()
-
-    def render(self):
-        self.screen.fill((30, 30, 30))  # Clear screen
-        self.map_coord_controller.update_screen_size(self.screen.get_width(), self.screen.get_height())
-        self.render_map()
-        self.text_render.render()
-        self.render_slider()
-        self.player_render.render()

states/game.py

@@ -1,22 +1,39 @@
 from states.game_state import GameState
-from render.renderer import Renderer
 from controllers.player_controller import PlayerController
+from render.map_renderer import MapRenderer
+from render.gui_renderer import GUIRenderer
+from render.player_renderer import PlayerRenderer
+from controllers.map_coord_controller import MapCoordController
+from controllers.gui_controller import GUIController
 import pygame
 
 class Game(GameState):
     def __init__(self, switch_state_callback, context):
         super().__init__(switch_state_callback, context)
 
-        self.renderer = Renderer(self.match, self.screen, self.options)
+        match_data_path = "maps/" + self.match.map_name + ".json"
-        self.player_controller = PlayerController(self.renderer.player_render, self.match)
+        match_image_path = "maps/" + self.match.map_name + ".png"
+
+        #self.renderer = Renderer(self.match, self.screen, self.options)
+        self.map_coord_controller = MapCoordController(self.screen.get_width(), self.screen.get_height(), match_data_path, match_image_path)
+
+        # Renderers
+        self.map_renderer = MapRenderer(self.screen, match_data_path, match_image_path)
+        self.player_render = PlayerRenderer(self.screen, self.match, self.map_coord_controller, self.options)
+        self.gui_render = GUIRenderer(self.screen, self.match)
+
+        # Controllers
+        self.player_controller = PlayerController(self.player_render, self.match)
+        self.gui_controller = GUIController(self.gui_render)
+
 
     def handle_events(self, events):
         """Handles user inputs."""
         for event in events:
             if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                 self.switch_state("menu")
-            self.renderer.slider.handle_event(event)
             self.player_controller.update(event)
+            self.gui_controller.update(event)
 
     def update(self):
         """Updates game objects."""
@@ -24,4 +41,7 @@ class Game(GameState):
 
     def draw(self):
         """Draws everything on screen."""
-        self.renderer.render()
+        self.screen.fill((0, 0, 0))
+        self.map_renderer.render()
+        self.player_render.render()
+        self.gui_render.render()