tournament: game: finish event

games/consumers.py

@@ -21,7 +21,6 @@ if TYPE_CHECKING:
     from .objects.pong.PongGame import PongGame
     
     from .objects.tictactoe.TicTacToeGame import TicTacToeGame
-    from .objects.tictactoe.TicTacToeSpectator import TicTacToeSpectator
 
 game_manager: GameManager = GameManager()
 

games/models.py

@@ -21,43 +21,28 @@ class GameModel(models.Model):
     stop_timestamp = models.BigIntegerField(null = True, blank = True)
     game_type = models.CharField(max_length = 60, default = "pong")
     
-    def create(self, players: list[User]):
+    def create(self, players: set[User]) -> GameModel:
         self.save()
         for player in players:
             GameMembersModel(game = self, player=player).save()
-        return self.pk
+        return self
 
     def start(self):
         self.start_timestamp = round(time.time() * 1000, 1)
         self.started = True
         self.save()
-
-    def get_tournament(self) -> None | TournamentGameModel:
-
-        from tournament.models import TournamentGameModel
-
-        query = TournamentGameModel.objects.filter(game=self)
-        if (not query.exists()):
-            return None
-        return query[0]
     
-    def finish(self, winner_id):
-        self.winner_id = winner_id
+    def finish(self, winner: User):
+        self.winner = winner
         self.finished = True
         self.stop_timestamp = round(time.time() * 1000, 1)
         self.save()
 
-        tournament = self.get_tournament()
-        if tournament is not None:
-            from tournament.consumers import tournament_manager
-            room = tournament_manager.get(tournament)
-            room.set_game_as_finished(self)
-
-    def get_players(self) -> list[User]:
-        return [game_player.player for game_player in GameMembersModel.objects.filter(game = self)]
+    def get_players(self) -> set[User]:
+        return {game_player.player for game_player in GameMembersModel.objects.filter(game = self)}
     
-    def get_players_profiles(self) -> list[User]:
-        return [game_player.player.profilemodel for game_player in GameMembersModel.objects.filter(game = self)]
+    def get_players_profiles(self) -> set[User]:
+        return {game_player.player.profilemodel for game_player in GameMembersModel.objects.filter(game = self)}
     
     def get_score_by_player_id(self, player_id: int) -> list[int]:
         query: QuerySet = GameGoalModel.objects.filter(game_id = self.pk, player_id = player_id)

games/objects/AGame.py

@@ -6,6 +6,8 @@ from .ASpectator import ASpectator
 
 from ..models import GameModel
 
+from tournament.models import TournamentGameModel
+
 from django.contrib.auth.models import User
 
 class AGame(AbstractRoom):
@@ -16,7 +18,11 @@ class AGame(AbstractRoom):
         
         self.game_manager = game_manager
         
-        self.model: GameModel = GameModel.objects.get(pk = game_id, game_type = game_type)
+        query = TournamentGameModel.objects.filter(pk = game_id, game_type = game_type)
+        if (query.exists()):
+            self.model: TournamentGameModel | GameModel = query[0]
+        else:
+            self.model: TournamentGameModel | GameModel = GameModel.objects.get(pk = game_id, game_type = game_type)
         
         players: list[User] = self.model.get_players()
 

games/objects/GameManager.py

@@ -3,6 +3,8 @@ from ..models import GameModel
 from .pong.PongGame import PongGame
 from .tictactoe.TicTacToeGame import TicTacToeGame
 
+from tournament.models import TournamentGameModel
+
 class GameManager():
     
     def __init__(self) -> None:
@@ -14,7 +16,7 @@ class GameManager():
         self._game_list.remove(game)
     
     def get(self, game_id: int, game_type: str) -> TicTacToeGame | PongGame:
-        
+
         if (not GameModel.objects.filter(pk=game_id, finished=False, game_type=game_type).exists()):
             return None
         

games/serializers.py

@@ -15,11 +15,11 @@ class GameSerializer(serializers.ModelSerializer):
     finished = serializers.ReadOnlyField()
     start_timestamp = serializers.ReadOnlyField()
     stop_timestamp = serializers.ReadOnlyField()
-    gamemode = serializers.ReadOnlyField()
+    game_type = serializers.ReadOnlyField()
 
     class Meta:
         model = GameModel
-        fields = ["id", "winner_id", "state", "started", "finished", "players", "start_timestamp", "stop_timestamp", "gamemode"]
+        fields = ["id", "winner_id", "state", "started", "finished", "players", "start_timestamp", "stop_timestamp", "game_type"]
 
     def get_state(self, instance: GameModel):
         if (instance.finished):