core: fix: matchmaking and game

matchmaking/consumers.py

@@ -6,15 +6,10 @@ from games.models import GameModel
 
 import json
 
-from .models import Waiter, WaitingRoom, WaitingRoomManager, normal
+from .models import Waiter, WaitingRoom, waiting_room_manager
 
 class MatchMaking(WebsocketConsumer):
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.channel_name = "matchmaking"
-        self.group_name = "matchmaking"
-
     def connect(self):
 
         user: User = self.scope["user"]
@@ -22,14 +17,12 @@ class MatchMaking(WebsocketConsumer):
         if (user.is_anonymous or not user.is_authenticated):
             return
 
-        self.channel_layer.group_add(self.group_name, self.channel_name)
-
         self.mode: int = int(self.scope['url_route']['kwargs']['mode'])
-        self.gamemode: str = self.scope['url_route']['kwargs']['gamemode']
+        self.game_type: str = self.scope['url_route']['kwargs']['game_type']
         self.group_name = self.mode
         
-        waiting_room: WaitingRoom = normal.get(self.gamemode, self.mode)
-        waiting_room.append(Waiter(user.pk, self))
+        self.waiting_room: WaitingRoom = waiting_room_manager.get(self.game_type, self.mode)
+        self.waiting_room.append(Waiter(user, self))
 
         if (self.mode < 2 or self.mode > 4):
             data: dict = {
@@ -39,23 +32,22 @@ class MatchMaking(WebsocketConsumer):
             self.disconnect(1000)
             return
         
-        if (self.gamemode not in ["tictactoe", "pong"]):
+        if (self.game_type not in ["tictactoe", "pong"]):
             data: dict = {
-                "detail": "The gamemode must 'pong' or 'tictactoe'.",
+                "detail": "The game_type must 'pong' or 'tictactoe'.",
             }
             self.send(json.dumps(data))
             self.disconnect(1000)
             return
         
-        waiting_room.broadcast(f"{len(waiting_room)} / {waiting_room.mode}")
-        if (len(waiting_room) == waiting_room.mode):
-            game_id: int = GameModel().create(self.gamemode, waiting_room.get_users_id())
-            waiting_room.broadcast("game_found", {"game_id": game_id, "gamemode": self.gamemode})
-            waiting_room.clear()
+        self.waiting_room.broadcast(f"{len(self.waiting_room)} / {self.waiting_room.mode}")
+        if (len(self.waiting_room) == self.waiting_room.mode):
+            game_id: int = GameModel(game_type=self.game_type).create(self.waiting_room.get_members())
+            self.waiting_room.broadcast("game_found", {"game_id": game_id, "game_type": self.game_type})
 
     def disconnect(self, close_code):
-        super().close(close_code)
-        waiting_room: WaitingRoom = normal.get(self.gamemode, self.mode)
+        super().disconnect(close_code)
+        waiting_room: WaitingRoom = waiting_room_manager.get(self.game_type, self.mode)
         waiter: Waiter = waiting_room.get_member_by_socket(self)
         if (waiter is not None):
-            waiting_room.remove(waiter, close_code)
+            waiting_room.remove(waiter)

matchmaking/models.py

@@ -13,29 +13,44 @@ class Waiter(AbstractRoomMember):
 
 class WaitingRoom(AbstractRoom):
     
-    def __init__(self, room_manager, gamemode: str, mode: int):
+    def __init__(self, room_manager, game_type: str, mode: int):
+        
         super().__init__(room_manager)
-        self.mode = mode
-        self.gamemode = gamemode
+        self._member_list: set[Waiter]
+
+        self.mode: int = mode
+        self.game_type: str = game_type
 
     def append(self, waiter: Waiter):
-        tmp: Waiter = self.get_member_by_user_id(waiter.user_id)
+
+        tmp: Waiter = self.get_member_by_user(waiter.user)
         if (tmp is not None):
             tmp.send("Connection close: Another connection open with the same user id.")
             self.remove(tmp)
+
         waiter.socket.accept()
-        self._member_list.append(waiter)
+
+        super().append(waiter)
 
 class WaitingRoomManager(AbstractRoomManager):
 
-    def get(self, gamemode: str, mode: int):
+    def __init__(self):
+        super().__init__()
         
+        self._room_list: set[WaitingRoom]
+
+
+    def get(self, game_type: str, mode: int) -> WaitingRoom:
+
         for waiting_room in self._room_list:
             waiting_room: WaitingRoom
-            if (waiting_room.mode == mode and waiting_room.gamemode == gamemode):
+            if (waiting_room.mode == mode and waiting_room.game_type == game_type):
                 return waiting_room
-        tmp: WaitingRoom = WaitingRoom(self, gamemode, mode)
+        
+        tmp: WaitingRoom = WaitingRoom(self, game_type, mode)
+        
         super().append(tmp)
+        
         return tmp
 
-normal: WaitingRoomManager = WaitingRoomManager()
+waiting_room_manager: WaitingRoomManager = WaitingRoomManager()

matchmaking/routing.py

@@ -2,5 +2,5 @@ from django.urls import re_path
 from . import consumers
 
 websocket_urlpatterns = [
-    re_path(r'ws/matchmaking/(?P<gamemode>\w+)/(?P<mode>\d+)$', consumers.MatchMaking.as_asgi())
+    re_path(r'ws/matchmaking/(?P<game_type>\w+)/(?P<mode>\d+)$', consumers.MatchMaking.as_asgi())
 ]