tournament: use tournamentGameModel instead gameModel

tournament/consumers.py

@@ -6,12 +6,13 @@ from django.contrib.auth.models import User
 from django.db.models import QuerySet
 from django.utils.translation import gettext as _
 
-from games.models import GameModel
-from games.serializers import GameSerializer
 from profiles.models import ProfileModel
 from profiles.serializers import ProfileSerializer
 from .models import TournamentModel
 
+from .models import TournamentGameModel
+from .serializers import TournamentGameSerializer
+
 import json
 
 class TournamentMember:
@@ -33,7 +34,7 @@ class TournamentMember:
 
         self.send("error", data_to_send)
     
-    def send_goto(self, game: GameModel):
+    def send_goto(self, game: TournamentGameModel):
         self.send("go_to", {"game_id": game.pk})
 
     def _receive_participating(self, data: dict) -> None:
@@ -84,7 +85,7 @@ class TournamentRoom:
         self._room_manager: TournamentRoomManager = room_manager
         self._member_list: set[TournamentMember] = set()
         self._model: TournamentModel = tournament
-        self._game_in_progress_list: set[GameModel] = set()
+        self._game_in_progress_list: set[TournamentGameModel] = set()
         self._current_round = 0
 
     def join(self, socket: TournamentWebConsumer) -> TournamentMember:
@@ -94,25 +95,28 @@ class TournamentRoom:
 
         return member
     
-    def set_game_as_finished(self, game: GameModel):
+    def set_game_as_finished(self, game: TournamentGameModel):
+
         self._game_in_progress_list.remove(game)
 
-        data: dict = GameSerializer(game).data
+        self.broadcast("game_update", TournamentGameSerializer(game).data)
-
-        data.update({"round": self._current_round})
-
-        self.broadcast("game_update", data)
 
         if len(self._game_in_progress_list) == 0:
             self._round_finished()
     
+    def set_game_as_started(self, game: TournamentGameModel):
+
+        self._game_in_progress_list.add(game)
+
+        self.broadcast("game_update", TournamentGameSerializer(game).data)
+
     def _finish(self, winner: User):
         self._model.finish(winner)
 
     def _round_finished(self):
         
         if self._current_round == self._model.round:
-            last_game: GameModel = self._model.get_games_by_round(self._current_round)[0]
+            last_game: TournamentGameSerializer = self._model.get_games_by_round(self._current_round)[0]
             self._finish(last_game.winner)
             return
         
@@ -124,9 +128,9 @@ class TournamentRoom:
 
         participant_list: set[User] = self._model.get_participants_by_round(self._current_round)
 
-        self._game_in_progress_list = self._model.create_round(participant_list, self._current_round)
+        game_list = self._model.create_round(participant_list, self._current_round)
 
-        for game in self._game_in_progress_list:
+        for game in game_list:
             for player in game.get_players():
                 participant: TournamentMember = self.get_participant_by_profile(player)
                 participant.send_goto(game)

tournament/models.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from typing import Any
 
 from games.models import GameModel
 
@@ -96,10 +97,20 @@ class TournamentGameModel(GameModel):
     round = models.IntegerField()
     pos = models.IntegerField()
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        from .consumers import tournament_manager
+        self.room = tournament_manager.get(self.tournament)
+
+
+    def start(self):
+        super().start()
+
+        self.room.set_game_as_started(self)
+        
+
     def finish(self, winner_id):
         super().finish(winner_id)
 
-        from .consumers import tournament_manager
+        self.room.set_game_as_finished(self)
-
-        room = tournament_manager.get(self.tournament)
-        room.set_game_as_finished(self)

tournament/serializers.py

@@ -45,10 +45,12 @@ class TournamentGameSerializer(serializers.ModelSerializer):
     start_timestamp = serializers.ReadOnlyField()
     stop_timestamp = serializers.ReadOnlyField()
     gamemode = serializers.ReadOnlyField()
+    round = serializers.ReadOnlyField()
+    pos = serializers.ReadOnlyField()
 
     class Meta:
         model = TournamentGameModel
-        fields = ["id", "winner_id", "state", "started", "finished", "players", "start_timestamp", "stop_timestamp", "game_type"]
+        fields = ["id", "winner_id", "state", "started", "finished", "players", "start_timestamp", "stop_timestamp", "game_type", "round", "pos"]
     
     def get_state(self, instance: TournamentGameModel):
         if (instance.finished):