game controller cleanup

src/controller/client.py

@@ -73,13 +73,13 @@ class ClientController:
                 await self.send_error("username must be longer than 3 characters")
                 return
 
-            if self.game_controller.get_player(username) is not None:
+            if self.game_controller.game.get_player(username) is not None:
                 await self.send_error("username already exists")
                 return
 
-            player = await self.game_controller.create_player(username)
+            player = await self.game_controller.game.create_player(username)
         elif message.type == "login":
-            player = self.game_controller.get_player(username)
+            player = self.game_controller.game.get_player(username)
 
             if player is None:
                 await self.send_error("player doesn't exists")

src/controller/game.py

@@ -1,7 +1,7 @@
 from netcode import WSServer
 from netcode.ws_server import WebSocketServerProtocol
 from netcode.models import Message
-from model import Game, Player, Team
+from model import Game
 
 
 class GameController:
@@ -12,82 +12,68 @@ class GameController:
         self.server = server
         self.game = game
         self.server.message_callbacks.append(self.guest_handler)
+        self.game.listeners.append(self.broadcast_announce_dict)
+
+    async def send(self, message: Message, websocket: WebSocketServerProtocol):
+        await websocket.send(message.model_dump_json())
 
     async def broadcast(self, message: Message):
         await self.server.broadcast(message.model_dump_json())
 
+    async def broadcast_announce_dict(self, notification_type: str, data: dict):
+        await self.broadcast(
+            Message(
+                type=notification_type,
+                data_type="object",
+                data=data,
+            )
+        )
+
+    async def announce_dict(
+        self,
+        notification_type: str,
+        data: dict,
+        websocket: WebSocketServerProtocol,
+    ):
+        await self.send(
+            Message(
+                type=notification_type,
+                data_type="object",
+                data=data,
+            ),
+            websocket,
+        )
+
     async def announce_game(self, websocket: WebSocketServerProtocol):
         for card in self.game.cards:
-            await websocket.send(
-                Message(
-                    type="create",
-                    data_type="object",
-                    data=card.serialize(),
-                ).model_dump_json()
+            await self.announce_dict(
+                "create",
+                card.serialize(),
+                websocket,
             )
 
         for team in self.game.teams:
-            await websocket.send(
-                Message(
-                    type="create",
-                    data_type="object",
-                    data=team.serialize(),
-                ).model_dump_json()
+            await self.announce_dict(
+                "create",
+                team.serialize(),
+                websocket,
             )
 
         for player in self.game.players:
-            await websocket.send(
-                Message(
-                    type="create",
-                    data_type="object",
-                    data=player.serialize_guest(),
-                ).model_dump_json()
+            await self.announce_dict(
+                "create",
+                player.serialize_guest(),
+                websocket,
             )
 
-        await websocket.send(
-            Message(
-                type="create",
-                data_type="object",
-                data=self.game.serialize_guest(),
-            ).model_dump_json()
+        await self.announce_dict(
+            "create",
+            self.game.serialize_guest(),
+            websocket,
         )
 
     async def guest_handler(self, websocket: WebSocketServerProtocol):
         await self.announce_game(websocket)
 
-    def get_player(self, username: str) -> Player | None:
-        players = [p for p in self.game.players if p.username == username]
-        if players and len(players) > 0:
-            return players[0]
-        return None
-
-    async def create_player(self, username: str, team: Team | None = None) -> Player:
-        if team is None:
-            team = await self.create_team()
-        player = self.game.create_player(username, team)
-
-        await self.broadcast(
-            Message(
-                type="create",
-                data_type="object",
-                data=player.serialize_guest(),
-            )
-        )
-        return player
-
-    async def create_team(self):
-        team = self.game.create_team()
-        await self.broadcast(
-            Message(type="create", data_type="object", data=team.serialize())
-        )
-        return team
-
-    async def create_card(self):
-        card = self.game.create_card()
-        await self.broadcast(
-            Message(type="create", data_type="object", data=card.serialize())
-        )
-        return card
-
     def start_game(self):
         pass