init base cards

src/controller/client.py

@@ -17,6 +17,7 @@ def vibe_check(t):
                 message = t.model_validate_json(message)
                 return await func(self, message)
             except ValidationError as e:
+                print(e)
                 await self.send_error(e.errors())
 
         return new_f
@@ -59,13 +60,7 @@ class ClientController:
         await self.send(Message(type="error", data_type="error", data=error))
 
     async def send_announce_dict(self, notification_type: str, data: dict):
-        await self.send(
+        await self.send(Message(type=notification_type, data_type="object", data=data))
-            Message(
-                type=notification_type,
-                data_type="object",
-                data=data,
-            )
-        )
 
     @vibe_check(Message)
     async def game_context(self, message: Message):
@@ -100,7 +95,7 @@ class ClientController:
 
         self.player = player
         self.player.team.listeners.append(self.send_announce_dict)
-        self.on_message = self.game_context
+        self.on_message = self.pregame_context
         print("user logged in : " + username)
 
         await self.game_controller.announce_game(self.websocket)
@@ -120,3 +115,11 @@ class ClientController:
             await self.send(
                 Message(type="update", data_type="object", data=player.serialize_team())
             )
+
+    @vibe_check(Message)
+    async def pregame_context(self, message: Message):
+        """Waits for players"""
+        if message.type == "ready":
+            self.player.ready = bool(message.data)
+            if all(p.ready for p in self.game_controller.game.players):
+                self.game_controller.start_game()

src/main.py

@@ -22,16 +22,9 @@ async def handler(websocket: WebSocketServerProtocol):
 playerServer.message_callbacks.append(handler)
 
 
-async def game_init():
-    for _ in range(15):
-        card = await hero_game.create_card()
-        hero_game.market_stack.append(card)
-
-    await hero_game.distribute_market_cards()
-
-
 async def main():
-    await asyncio.gather(gameServer.serve(), playerServer.serve(port=8766), game_init())
+    await hero_game.init_game()
+    await asyncio.gather(gameServer.serve(), playerServer.serve(port=8766))
 
 
 asyncio.run(main())

src/model/game.py

@@ -1,9 +1,9 @@
-#!/usr/bin/env python
 from typing import List
-
+import random
 from model import (
     Card,
     CardType,
+    CardRole,
     CardFaction,
     CardParser,
     Player,
@@ -41,33 +41,82 @@ class Game(Serializable):
 
         self.started = False
 
-    def start_game(self):
+    async def init_game(self):
-        pass
+        await self.init_cards()
+        await self.distribute_market_cards()
+        self.started = True
 
-    async def create_card(self) -> Card:
+    async def init_cards(self):
-        card = Card(
+        """Creates market cards and fire gem cards from previously loaded cards"""
+        market_only = [c for c in self.loaded_cards if c.role == CardRole.MARKET]
+        for c in market_only:
+            for _ in range(c.init_amount):
+                self.market_stack.append(
+                    await self.create_card(
+                        Card(
+                            sprite="spritetest",
+                            name=c.name,
+                            cost=c.cost,
+                            card_type=c.card_type,
+                            faction=c.faction,
+                        )
+                    )
+                )
+        random.shuffle(self.market)
+        fire_gems = [c for c in self.loaded_cards if c.role == CardRole.FIRE_GEM]
+        for c in fire_gems:
+            for _ in range(c.init_amount):
+                self.gem_stack.append(
+                    await self.create_card(
+                        Card(
+                            sprite="spritetest",
+                            name=c.name,
+                            cost=c.cost,
+                            card_type=c.card_type,
+                            faction=c.faction,
+                        )
+                    )
+                )
+
+    async def create_card(
+        self,
+        card: Card = Card(
             card_type=CardType.ACTION,
             faction=CardFaction.BLUE,
             cost=1,
             name="test",
             sprite="testsprite",
-        )
+        ),
+    ) -> Card:
         self.cards.append(card)
         await self.notify_controller("create", card.serialize_guest())
 
         return card
 
-    def create_base_deck(self) -> List[Card]:
+    async def create_base_deck(self, base_deck_name: str = "base") -> List[Card]:
-        return [
+        """Creates the starting base deck for a player.
-            Card(
+        Use base_deck_name to choose extensions characters"""
-                card_type=CardType.ACTION,
+        base_deck_loaded = [
-                faction=CardFaction.BLUE,
+            c
-                cost=1,
+            for c in self.loaded_cards
-                name="test",
+            if c.role == CardRole.PERSONAL and c.faction == base_deck_name
-                sprite="testsprite",
-            )
-            for _ in range(10)
         ]
+        base_deck = []
+        for c in base_deck_loaded:
+            for _ in range(c.init_amount):
+                base_deck.append(
+                    await self.create_card(
+                        Card(
+                            sprite="spritetest",
+                            name=c.name,
+                            cost=c.cost,
+                            card_type=c.card_type,
+                            faction=c.faction,
+                        )
+                    )
+                )
+        random.shuffle(base_deck)
+        return base_deck
 
     async def create_player(self, username: str, team: Team | None = None) -> Player:
         if team is None:
@@ -76,9 +125,8 @@ class Game(Serializable):
         player = Player(username, team)
         self.players.append(player)
 
-        player.stack_pile = self.create_base_deck()
+        player.stack_pile = await self.create_base_deck("base")
         await self.notify_controller("create", player.serialize_guest())
-
         return player
 
     async def create_team(self) -> Team:

src/model/player.py

@@ -17,6 +17,20 @@ class Player(Serializable):
     hand: List[Card]
     board: List[Card]
 
+    _ready: bool = False
+
+    @property
+    def ready(self):
+        return self._ready
+
+    @ready.setter
+    def ready(self, value):
+        self._ready = value
+
+    @ready.deleter
+    def ready(self):
+        del self._ready
+
     def __init__(self, username: str, team: Team):
         super().__init__()
         self.stack_pile = []
@@ -67,4 +81,6 @@ class Player(Serializable):
                     self.hand.append(self.stack_pile.pop())
                     return self.draw(amount - 1)
         finally:
-            self.team.notify_controller("update", self.serialize_team())
+            await self.team.notify_controller(
+                "update", {"uuid": self.uuid, "hand": self.serialize_team()["hand"]}
+            )