working on clientController : register POC

src/controller/__init__.py

@@ -1,2 +1,5 @@
-from controller.client import Client
+"""controller handles the translation between
+netcode messages and model functions"""
+
 from controller.game import GameController
+from controller.client import ClientController

src/controller/client.py

@@ -1,15 +1,89 @@
+from pydantic import ValidationError
+
+from controller import GameController
 from websockets.server import WebSocketServerProtocol
+from netcode.models import Message, LoginMessage, MessageData
+
+from game import Player
 
 
-class Client:
+def vibe_check(t):
+    """Enforces the selected type for the message"""
+
+    def decorator(func):
+        async def new_f(self, message):
+            try:
+                message = t.model_validate_json(message)
+                return await func(self, message)
+            except ValidationError as e:
+                await self.send_error(e.errors())
+
+        return new_f
+
+    return decorator
+
+
+class ClientController:
     websocket: WebSocketServerProtocol
 
-    def __init__(self, websocket: WebSocketServerProtocol):
+    game_controller: GameController
+
+    player: Player
+
+    def __init__(
+        self, game_controller: GameController, websocket: WebSocketServerProtocol
+    ):
         self.websocket = websocket
+        self.on_message = self.login_context
+
+        self.game_controller = game_controller
 
     async def listen(self):
+        """Initializes the client controller"""
+        await self.send(Message(type="context", data=MessageData(message="login")))
+
         async for message in self.websocket:
             await self.on_message(message)
 
-    async def on_message(self, message):
+    async def send(self, message: Message):
+        await self.websocket.send(message.model_dump_json())
+
+    async def send_error(self, error: str):
+        await self.send(Message(type="error", data=MessageData(message=error)))
+
+    @vibe_check(Message)
+    async def game_context(self, message: Message):
+        """Handles messages when the client is logged in"""
         print(message)
+
+    @vibe_check(LoginMessage)
+    async def login_context(self, message: LoginMessage):
+        """Handles messages when the client isn't logged in"""
+        if message.type == "register":
+            username = message.data.username
+
+            if len(username) < 3:
+                await self.send_error("username must be longer than 3 characters")
+                return
+
+            if self.game_controller.get_player(username) is not None:
+                await self.send_error("username already exists")
+                return
+
+            player = self.game_controller.create_player(username)
+        elif message.type == "login":
+            username = message.data.username
+            player = self.game_controller.get_player(username)
+
+            if player is None:
+                await self.send_error("player doesn't exists")
+                return
+
+        else:
+            await self.send_error("invalid message type for context")
+            return
+
+        self.player = player
+        self.on_message = self.game_context
+        print("user logged in : " + username)
+        await self.send(Message(type="context", data=MessageData(message="game")))

src/controller/game.py

@@ -1,11 +1,24 @@
+from typing import Optional
 from netcode import WSServer
+from game import Game, Player
 
 
 class GameController:
     server: WSServer
+    game: Game
 
-    def __init__(self, server: WSServer):
+    def __init__(self, game: Game, server: WSServer):
         self.server = server
+        self.game = game
+
+    def get_player(self, username: str) -> Optional[Player]:
+        players = [p for p in self.game.players if p.username == username]
+        if players and len(players) > 0:
+            return players[0]
+        return None
+
+    def create_player(self, username: str) -> Player:
+        return self.game.create_player(username)
 
     def start_game(self):
         pass