Fix game creation being locked by back

Closes legonzaur/heron-realms-front#56

src/controller/game.py

@@ -17,16 +17,13 @@ class GameController:
     lobby_controller: "LobbyController"
     game: Game
     clients: list[ClientController]
-    owner: str
 
-    def __init__(
-        self, game: Game, lobby_controller: "LobbyController", owner: str
-    ) -> None:
+    def __init__(self, game: Game, lobby_controller: "LobbyController") -> None:
         self.lobby_controller: "LobbyController" = lobby_controller
         self.game: Game = game
-        self.owner = owner
         self.clients: list[ClientController] = []
         self.game.listeners.append(self.broadcast_announce_dict)
+        game.end_game_callback = self.end_game
 
     async def send(self, message: Message, websocket: WebSocketServerProtocol):
         try:
@@ -121,3 +118,6 @@ class GameController:
         await self.broadcast(
             Message(type=MessageType.CONTEXT, data_type="game_context_id", data="game")
         )
+
+    async def end_game(self):
+        self.lobby_controller.game_controllers.remove(self)

src/controller/lobby.py

@@ -12,14 +12,14 @@ class LobbyController:
     server: WSServer
     lobby: Lobby
     clients: List[LobbyClientController]
-    games: list[GameController]
+    game_controllers: List[GameController]
 
     def __init__(self, server: WSServer) -> None:
         self.server: WSServer = server
         self.server.on_new_connection_callback = self.on_new_connection
         self.clients: List[LobbyClientController] = []
+        self.game_controllers = []
         self.lobby = Lobby()
-        self.games: List[GameController] = []
 
     async def on_new_connection(
         self, websocket: WebSocketServerProtocol, callback: Callable
@@ -37,12 +37,12 @@ class LobbyController:
                 await c.send(message)
 
     async def create_game(self, discord_uid: str):
-        if any(g.owner == discord_uid for g in self.games):
+        if any(g.owner == discord_uid for g in self.lobby.games):
             return print(
                 "The number of created games per discord account is currently set to 1"
             )
-        game_ctrler = GameController(self.lobby.create_game(), self, discord_uid)
-        self.games.append(game_ctrler)
+        game_ctrler = GameController(self.lobby.create_game(discord_uid), self)
+        self.game_controllers.append(game_ctrler)
         await game_ctrler.game.init_game()
         await self.broadcast_to_unconnected(
             Message(

src/controller/lobbyClient.py

@@ -42,9 +42,9 @@ class LobbyClientController:
     lobby_controller: "LobbyController"
     track_connection: Callable
 
-    discord_uid: str
-    username: str
-    discord_avatar: str
+    discord_uid: str | None
+    username: str | None
+    discord_avatar: str | None
 
     game_client: Union["ClientController", None]
 
@@ -156,6 +156,8 @@ class LobbyClientController:
     async def lobby_context(self, message: Message) -> None:
         if message.type == MessageType.CREATE:
             if message.data_type == "game":
+                if self.discord_uid is None:
+                    return print("user not logged in : cannot create game")
                 game_ctrler = await self.lobby_controller.create_game(self.discord_uid)
                 if game_ctrler is None:
                     return print("Cannot create game")
@@ -173,7 +175,7 @@ class LobbyClientController:
                 game_ctrler = next(
                     (
                         g
-                        for g in self.lobby_controller.games
+                        for g in self.lobby_controller.game_controllers
                         if str(g.game.uuid) == message.data
                     ),
                     None,

src/model/game.py

@@ -30,13 +30,15 @@ class Game(Serializable):
     started: bool
     ended: bool
 
-    default_health = 50
+    default_health = 1
 
     current_turn: Team | None
 
     lobby: "Lobby"
 
-    def __init__(self, lobby: "Lobby") -> None:
+    owner: str
+
+    def __init__(self, lobby: "Lobby", owner: str) -> None:
         super().__init__()
         self.market_stack: List[Card] = []
         self.market: List[Card | None] = [None for _ in range(5)]
@@ -54,6 +56,11 @@ class Game(Serializable):
         self.lobby = lobby
         self.lobby.games.append(self)
 
+        self.owner = owner
+
+    async def end_game_callback(self):
+        return
+
     async def init_game(self):
         await self.init_cards()
         await self.distribute_market_cards()
@@ -147,7 +154,10 @@ class Game(Serializable):
             "effects": [effect.uuid for effect in self.effects],
         }
 
-        return {k: data[k] for k in data.keys() - ["loaded_cards", "lobby"]}
+        return {
+            k: data[k]
+            for k in data.keys() - ["loaded_cards", "lobby", "end_game_callback"]
+        }
 
     async def start_game(self):
         self.started = True
@@ -187,11 +197,12 @@ class Game(Serializable):
             None,
         )
 
-    def end_game(self):
+    async def end_game(self):
         self.lobby.games.remove(self)
         self.ended = True
+        await self.end_game_callback()
 
-    def kill_team(self, team: Team):
+    async def kill_team(self, team: Team):
 
         if team == self.current_turn:
             self.end_turn()
@@ -205,4 +216,4 @@ class Game(Serializable):
             self.teams.remove(team)
 
         if len(self.teams) <= 1:
-            self.end_game()
+            await self.end_game()

src/model/lobby.py

@@ -27,6 +27,6 @@ class Lobby(Serializable):
 
         return {k: data[k] for k in data.keys() - []}
 
-    def create_game(self) -> Game:
-        game = Game(self)
+    def create_game(self, owner: str) -> Game:
+        game = Game(self, owner)
         return game

src/model/turn.py

@@ -302,7 +302,7 @@ class Turn(Serializable):
             team.health -= 1
 
         if team.health <= 0:
-            self.player.game.kill_team(team)
+            await self.player.game.kill_team(team)
 
         await self.player.game.notify_controller(MessageType.UPDATE, self.serialize())
         await self.player.game.notify_controller(MessageType.UPDATE, team.serialize())