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(
+            await self.announce_dict(
-                Message(
+                "create",
-                    type="create",
+                card.serialize(),
-                    data_type="object",
+                websocket,
-                    data=card.serialize(),
-                ).model_dump_json()
             )
 
         for team in self.game.teams:
-            await websocket.send(
+            await self.announce_dict(
-                Message(
+                "create",
-                    type="create",
+                team.serialize(),
-                    data_type="object",
+                websocket,
-                    data=team.serialize(),
-                ).model_dump_json()
             )
 
         for player in self.game.players:
-            await websocket.send(
+            await self.announce_dict(
-                Message(
+                "create",
-                    type="create",
+                player.serialize_guest(),
-                    data_type="object",
+                websocket,
-                    data=player.serialize_guest(),
-                ).model_dump_json()
             )
 
-        await websocket.send(
+        await self.announce_dict(
-            Message(
+            "create",
-                type="create",
+            self.game.serialize_guest(),
-                data_type="object",
+            websocket,
-                data=self.game.serialize_guest(),
-            ).model_dump_json()
         )
 
     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

src/main.py

@@ -23,8 +23,8 @@ playerServer.message_callbacks.append(handler)
 
 
 async def game_init():
-    for i in range(10):
+    for _ in range(10):
-        await game_controller.create_card()
+        await hero_game.create_card()
 
 
 async def main():

src/model/game.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-from typing import List
+from typing import List, Callable, Awaitable, Any
 
 from model import Card, CardType, CardFaction, Player, Team, Serializable
 
@@ -20,6 +20,8 @@ class Game(Serializable):
 
     default_health = 80
 
+    listeners: List[Callable[[str, dict], Awaitable[Any]]]
+
     def __init__(self):
         super().__init__()
         self.market_stack = []
@@ -28,12 +30,22 @@ class Game(Serializable):
         self.players = []
         self.cards = []
         self.teams = []
+
+        self.listeners = []
         self.started = False
 
+    async def notify_controller(
+        self,
+        notification_type: str,
+        game_object: dict,
+    ):
+        for l in self.listeners:
+            await l(notification_type, game_object)
+
     def start_game(self):
         pass
 
-    def create_card(self) -> Card:
+    async def create_card(self) -> Card:
         card = Card(
             card_type=CardType.ACTION,
             faction=CardFaction.BLUE,
@@ -43,20 +55,36 @@ class Game(Serializable):
             sprite="testsprite",
         )
         self.cards.append(card)
+        await self.notify_controller("create", card.serialize())
+
         return card
 
-    def create_player(self, username: str, team: Team) -> Player:
+    async def create_player(self, username: str, team: Team | None = None) -> Player:
+        if team is None:
+            team = await self.create_team()
+
         player = Player(username, team)
         self.players.append(player)
+        await self.notify_controller("create", player.serialize_guest())
+
         return player
 
-    def create_team(self) -> Team:
+    async def create_team(self) -> Team:
         team = Team(health=self.default_health)
         self.teams.append(team)
+        await self.notify_controller("create", team.serialize())
+
         return team
 
+    def get_player(self, username: str) -> Player | None:
+        players = [p for p in self.players if p.username == username]
+        if players and len(players) > 0:
+            return players[0]
+        return None
+
     def serialize_guest(self) -> dict:
         return self.__dict__ | {
+            "listeners": None,
             "cards": [card.uuid for card in self.cards],
             "market_stack": [None for card in self.market_stack],
             "market": [card.uuid for card in self.market],