game: core: change player to player.isconnected

befort: if a player is disconnected he doesn't have an object
after: he have un object with a socket == None

games/objects/Game.py

@@ -3,6 +3,8 @@ from transcendence.abstract.AbstractRoomMember import AbstractRoomMember
 
 from channels.generic.websocket import WebsocketConsumer
 
+from asgiref.sync import async_to_sync
+
 from .Ball import Ball
 from .Player import Player
 from .Spectator import Spectator
@@ -14,20 +16,25 @@ from .. import config
 
 from ..models import GameModel
 
+from ..routine import routine
+
+import threading
+
 class Game(AbstractRoom):
 
     def __init__(self, game_id):
         super().__init__(None)
         
         self.ball: Ball = Ball()
-        game_model: GameModel = GameModel.objects.get(pk = game_id)
-        self.players_id: list[int] = game_model.get_players_id()
+        self.model: GameModel = GameModel.objects.get(pk = game_id)
         
         self.started = False
         
         radius: float = min(config.MAP_SIZE_X, config.MAP_SIZE_Y) / 2 - 10 
 
-        self.nb_sides = len(self.players_id) * 2
+        players_id: list[int] = self.model.get_players_id()
+
+        self.nb_sides = len(players_id) * 2
         
         self.polygon: list[tuple[float, float]] = []
         
@@ -41,6 +48,10 @@ class Game(AbstractRoom):
             self.polygon.append((x, y))
 
         self.players: list[Player] = []
+        for i, player_id in enumerate(players_id):
+            player = Player(self, player_id, None, *self.polygon[i * 2], *self.polygon[(i * 2 + 1) % self.nb_sides])
+            self.players.append(player)
+    
         self.spectators: list[Spectator] = []
         
         self.walls: list[Wall] = []
@@ -48,14 +59,27 @@ class Game(AbstractRoom):
         for i in range(1, self.nb_sides, 2):
             self.walls.append(Wall(*self.polygon[i], *self.polygon[(i + 1) % self.nb_sides]))
 
+        self._updated_players: list[Player] = []
+
         self.game_id: int = game_id
+
+        self.thread = threading.Thread(target = routine, args=(self,))
+        
+        self.thread.start()
+    
+    def get_players_id(self):
+        return [player.user_id for player in self.players]
+    
+    def get_players_connected(self) -> list[Player]:
+        return [player for player in self.players if player.is_connected()]
     
     def broadcast(self, detail: str, data: dict = {}, excludeds: list[Spectator | Player] = []):
         
-        members: list[Player | Spectator] = self.players + self.spectators
+        members: list[Player | Spectator] = self.get_players_connected() + self.spectators
         
         for excluded in excludeds:
-            members.remove(excluded)
+            if (excluded in members):
+                members.remove(excluded)
         
         for member in members:
             member.send(detail, data)      
@@ -70,40 +94,39 @@ class Game(AbstractRoom):
     def _send_game_data(self, member: AbstractRoomMember):
         member.send("init_game", self.to_dict())
     
-    def append(self, member: AbstractRoomMember):
-        super().append(member)
-        member.send("init_game", self.to_dict())
+    def everbody_is_here(self):
+        for player in self.players:
+            if not player.is_connected():
+                return False
+        return True
     
     def _player_join(self, user_id: int, socket: WebsocketConsumer):
         
-        #check if member is a player
-        if (user_id not in self.players_id):
-            return None
-        
         # check if player is already connected
         player = self.get_player_by_user_id(user_id)
-        if (player is not None):
+        if (player is None):
+            return None
+        
+        if (player.is_connected()):
             player.disconnect(1001)
         
-        index: int = self.players_id.index(user_id) * 2
-        
-        player = Player(self, user_id, socket, *self.polygon[index], *self.polygon[(index + 1) % self.nb_sides])
-        
-        self.players.append(player)
+        player.connect(socket)
 
-        player.accept()
-        
-        self.broadcast("player_join", player.to_dict(), [player])
+        if (self.everbody_is_here()):
+            print("start")
+            self.start()
         
         return player
     
+    def _update_player(self, player: Player):
+        self._updated_players.append(player)
+    
     def _player_leave(self, player: Player):
-        self.broadcast("player_leave", player.to_dict(), [player])
-        self.players.remove(player)
+        self._updated_players.append(player)
     
     def _spectator_join(self, user_id: int, socket: WebsocketConsumer):
         
-        spectator: Spectator = Spectator(user_id, socket)
+        spectator: Spectator = Spectator(user_id, socket, self)
         
         self.spectators.append(spectator)
         
@@ -115,19 +138,20 @@ class Game(AbstractRoom):
         self.spectators.remove(spectator)        
     
     def join(self, user_id: int, socket: WebsocketConsumer) -> Spectator | Player:
-        if (user_id in self.players_id):
-            member: Player = self._player_join(user_id, socket)
-            print("yo")
-        else:
+        member: Player = self._player_join(user_id, socket)
+        if (member is None):
             member: Spectator = self._spectator_join(user_id, socket)
         self._send_game_data(member)
         return member    
                     
     
     def start(self):
+        if (self.started == True):
+            return
         self.started = True
+        self.model.start()
         
-    def remove(self, member: AbstractRoomMember):
+    def leave(self, member: AbstractRoomMember):
         if (isinstance(member, Player)):
             self._player_leave(member)
         elif (isinstance(member, Spectator)):
@@ -140,6 +164,4 @@ class Game(AbstractRoom):
                       "walls": [wall.to_dict() for wall in self.walls],
                       }
         
-        print(self.players  )
-        
         return data