gameobject annoucing when joining

src/controller/__init__.py

@@ -1,5 +1,7 @@
 """controller handles the translation between
 netcode messages and model functions"""
 
+from controller.object_controller import ObjectController
+from controller.card import Card
 from controller.game import GameController
 from controller.client import ClientController

src/controller/card.py

@@ -0,0 +1,5 @@
+from controller import ObjectController
+
+
+class Card(ObjectController):
+    pass

src/controller/client.py

@@ -5,7 +5,7 @@ from controller import GameController
 
 from netcode.models import Message, LoginMessage
 
-from game import Player
+from model import Player
 
 
 def vibe_check(t):
@@ -93,14 +93,20 @@ class ClientController:
         self.on_message = self.game_context
         print("user logged in : " + username)
 
-        await self.send(
+        await self.game_controller.announce_game(self.websocket)
-            Message(type="context", data_type="game_context_id", data="game")
-        )
 
         await self.send(
             Message(
-                type="create",
+                type="set",
-                data_type="player_self",
+                data_type="self",
-                data=self.player.serialize_team(),
+                data=self.player.uuid,
             )
         )
+
+        for player in self.game_controller.game.players:
+            if player.team != self.player.team:
+                continue
+
+            await self.send(
+                Message(type="update", data_type="object", data=player.serialize_team())
+            )

src/controller/game.py

@@ -1,7 +1,7 @@
-import json
 from netcode import WSServer
+from netcode.ws_server import WebSocketServerProtocol
 from netcode.models import Message
-from game import Game, Player, Team
+from model import Game, Player, Team
 
 
 class GameController:
@@ -11,10 +11,50 @@ class GameController:
     def __init__(self, game: Game, server: WSServer):
         self.server = server
         self.game = game
+        self.server.message_callbacks.append(self.guest_handler)
 
     async def broadcast(self, message: Message):
         await self.server.broadcast(message.model_dump_json())
 
+    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()
+            )
+
+        for team in self.game.teams:
+            await websocket.send(
+                Message(
+                    type="create",
+                    data_type="object",
+                    data=team.serialize(),
+                ).model_dump_json()
+            )
+
+        for player in self.game.players:
+            await websocket.send(
+                Message(
+                    type="create",
+                    data_type="object",
+                    data=player.serialize_guest(),
+                ).model_dump_json()
+            )
+
+        await websocket.send(
+            Message(
+                type="create",
+                data_type="object",
+                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:
@@ -29,7 +69,7 @@ class GameController:
         await self.broadcast(
             Message(
                 type="create",
-                data_type="player",
+                data_type="object",
                 data=player.serialize_guest(),
             )
         )
@@ -38,9 +78,16 @@ class GameController:
     async def create_team(self):
         team = self.game.create_team()
         await self.broadcast(
-            Message(type="create", data_type="team", data=team.serialize())
+            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/controller/object_controller.py

@@ -0,0 +1,2 @@
+class ObjectController:
+    pass

src/game/__init__.py

@@ -1,5 +0,0 @@
-from game.serializable import Serializable
-from game.card import Card
-from game.team import Team
-from game.player import Player
-from game.game import Game

src/game/game.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python
-from typing import List
-
-from game import Card, Player, Team, Serializable
-
-
-class Game(Serializable):
-    """Instance of the game, with players and a market"""
-
-    market_stack: List[Card]
-    market: List[Card]
-    gem_stack: List[Card]
-    _players: List[Player]
-
-    started: bool
-
-    default_health = 80
-
-    def __init__(self):
-        self.market_stack = []
-        self.market = []
-        self.gem_stack = []
-        self.players = []
-        self.started = False
-
-    def start_game(self):
-        pass
-
-    def create_player(self, username: str, team: Team) -> Player:
-        player = Player(username, team)
-        self.players.append(player)
-        return player
-
-    def create_team(self) -> Team:
-        return Team()
-
-    def serialize():
-        return super().serialize()

src/game/player.py

@@ -1,43 +0,0 @@
-from typing import List
-from game import Card, Team, Serializable
-
-
-class Player(Serializable):
-    """Game player, controller by a Client"""
-
-    username: str
-
-    stack_pile: List[Card]
-    discard_pile: List[Card]
-    team: Team
-
-    hand: List[Card]
-    board: List[Card]
-
-    def __init__(self, username: str, team: Team):
-        self.stack_pile = []
-        self.discard_pile = []
-        self.hand = []
-        self.board = []
-        self.team = team
-        self.username = username
-
-    def serialize_guest(self) -> dict:
-        return {
-            "username": self.username,
-            "stack_pile_amount": len(self.stack_pile),
-            "discard_pile": [card.serialize() for card in self.discard_pile],
-            "team": self.team.id,
-            "hand_amount": len(self.hand),
-            "board": [card.serialize() for card in self.board],
-        }
-
-    def serialize_team(self) -> dict:
-        return {
-            "username": self.username,
-            "stack_pile_amount": len(self.stack_pile),
-            "discard_pile": [card.serialize() for card in self.discard_pile],
-            "team": self.team.id,
-            "hand": self.hand,
-            "board": [card.serialize() for card in self.board],
-        }

src/game/serializable.py

@@ -1,3 +0,0 @@
-class Serializable:
-    def serialize(self):
-        return self.__dict__

src/main.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 import asyncio
-from game import Game
+from model import Game
 
 from netcode.ws_server import WebSocketServerProtocol
 from netcode import WSServer
@@ -22,8 +22,13 @@ async def handler(websocket: WebSocketServerProtocol):
 playerServer.message_callbacks.append(handler)
 
 
+async def game_init():
+    for i in range(10):
+        await game_controller.create_card()
+
+
 async def main():
-    await asyncio.gather(gameServer.serve(), playerServer.serve(port=8766))
+    await asyncio.gather(gameServer.serve(), playerServer.serve(port=8766), game_init())
 
 
 asyncio.run(main())

src/model/__init__.py

@@ -0,0 +1,5 @@
+from model.serializable import Serializable
+from model.card import Card, CardType, CardFaction
+from model.team import Team
+from model.player import Player
+from model.game import Game

src/model/card.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from game import Serializable
+from model import Serializable
 
 
 class CardType(str, Enum):
@@ -25,6 +25,7 @@ class CardFaction(str, Enum):
 class Card(Serializable):
     """Represents any playable card"""
 
+    object_type = "card"
     sprite: str
     name: str
     text: str
@@ -32,11 +33,22 @@ class Card(Serializable):
     card_type: CardType
     faction: CardFaction
 
-    def __init__(self):
+    def __init__(
-        pass
+        self,
-
+        sprite: str,
-    def serialize(self) -> dict:
+        name: str,
-        return self.__dict__
+        text: str,
+        cost: int,
+        card_type: CardType,
+        faction: CardFaction,
+    ):
+        super().__init__()
+        self.sprite = sprite
+        self.name = name
+        self.text = text
+        self.cost = cost
+        self.card_type = card_type
+        self.faction = faction
 
 
 class CardChampion(Card):

src/model/game.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+from typing import List
+
+from model import Card, CardType, CardFaction, Player, Team, Serializable
+
+
+class Game(Serializable):
+    """Instance of the game, with players and a market"""
+
+    object_type = "game"
+
+    cards: List[Card]
+    market_stack: List[Card]
+    market: List[Card]
+    gem_stack: List[Card]
+    players: List[Player]
+    teams: List[Team]
+
+    started: bool
+
+    default_health = 80
+
+    def __init__(self):
+        super().__init__()
+        self.market_stack = []
+        self.market = []
+        self.gem_stack = []
+        self.players = []
+        self.cards = []
+        self.teams = []
+        self.started = False
+
+    def start_game(self):
+        pass
+
+    def create_card(self) -> Card:
+        card = Card(
+            card_type=CardType.ACTION,
+            faction=CardFaction.BLUE,
+            cost=1,
+            name="test",
+            text="testtext",
+            sprite="testsprite",
+        )
+        self.cards.append(card)
+        return card
+
+    def create_player(self, username: str, team: Team) -> Player:
+        player = Player(username, team)
+        self.players.append(player)
+        return player
+
+    def create_team(self) -> Team:
+        team = Team(health=self.default_health)
+        self.teams.append(team)
+        return team
+
+    def serialize_guest(self) -> dict:
+        return self.__dict__ | {
+            "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],
+            "gem_stack": [card.uuid for card in self.gem_stack],
+            "players": [player.uuid for player in self.players],
+            "teams": [team.uuid for team in self.teams],
+            "started": self.started,
+            "default_health": self.default_health,
+        }

src/model/player.py

@@ -0,0 +1,46 @@
+from typing import List
+from model import Card, Team, Serializable
+
+
+class Player(Serializable):
+    """Game player, controller by a Client"""
+
+    object_type = "player"
+    username: str
+
+    stack_pile: List[Card]
+    discard_pile: List[Card]
+    team: Team
+
+    hand: List[Card]
+    board: List[Card]
+
+    def __init__(self, username: str, team: Team):
+        super().__init__()
+        self.stack_pile = []
+        self.discard_pile = []
+        self.hand = []
+        self.board = []
+        self.team = team
+        self.username = username
+
+    def serialize_guest(self) -> dict:
+        """Get data available to the public"""
+        return self.__dict__ | {
+            "stack_pile": [None for card in self.stack_pile],
+            "discard_pile": [card.uuid for card in self.discard_pile],
+            "team": self.team.uuid,
+            "hand": [None for card in self.hand],
+            "board": [card.uuid for card in self.board],
+        }
+
+    def serialize_team(self) -> dict:
+        """Get data available to members of the same team"""
+        return self.serialize_guest() | {
+            "hand": [card.uuid for card in self.hand],
+        }
+
+    def serialize(self) -> dict:
+        return self.serialize_team() | {
+            "stack_pile": [card.uuid for card in self.stack_pile]
+        }

src/model/serializable.py

@@ -0,0 +1,14 @@
+from uuid import uuid4, UUID
+
+
+class Serializable:
+    object_type = "generic"
+
+    uuid: UUID
+
+    def __init__(self):
+        self.uuid = uuid4()
+        self.object_type = self.__class__.object_type
+
+    def serialize(self):
+        return self.__dict__

src/model/team.py

@@ -1,18 +1,16 @@
-from game import Serializable
+from model import Serializable
 
 
 class Team(Serializable):
     """Shared object for health storage"""
 
-    id = 1
+    object_type = "team"
-
     health: int
     color: str
     name: str
 
-    def __init__(self, health=80, color="red", name="Team " + str(id)):
+    def __init__(self, health=80, color="red", name="unnamed Team"):
-        self.id = Team.id
+        super().__init__()
-        Team.id += 1
         self.health = health
         self.color = color
         self.name = name