game: add: class: point and segment, add: type docstring

games/objects/Ball.py

@@ -7,10 +7,12 @@ class Ball:
         self.postion_y: float = config.BALL_SPAWN_POS_Y
         self.velocity_x: float = config.BALL_SPEED_START
         self.velocity_y: float = config.BALL_SPEED_START
+        self.size: float = config.BALL_SIZE
     
     def to_dict(self):
         
         data: dict = {
+            "size": self.size,
             "position_x": self.postion_x,
             "position_y": self.postion_y,
             "velocity_x": self.velocity_x,

games/objects/Game.py

@@ -9,6 +9,8 @@ from .Ball import Ball
 from .Player import Player
 from .Spectator import Spectator
 from .Wall import Wall
+from .Point import Point
+from .Segment import Segment
 
 import math
 
@@ -34,30 +36,34 @@ class Game(AbstractRoom):
 
         players_id: list[int] = self.model.get_players_id()
 
-        self.nb_sides = len(players_id) * 2
+        nb_sides = len(players_id) * 2
         
-        self.polygon: list[tuple[float, float]] = []
+        polygon: list[Point] = []
         
-        for i in range(self.nb_sides):
+        for i in range(nb_sides):
 
-            angle: float = (i * 2 * math.pi / self.nb_sides) + (math.pi * 3 / 4)
+            angle: float = (i * 2 * math.pi / nb_sides) + (math.pi * 3 / 4)
 
             x: float = config.MAP_CENTER_X + radius * math.cos(angle)
             y: float = config.MAP_CENTER_Y + radius * math.sin(angle)
             
-            self.polygon.append((x, y))
+            polygon.append(Point(x, y))
+        
+        segments: list[Point] = []
+        for i in range(nb_sides):
+            segments.append(Segment(polygon[i], polygon[(i + 1) % nb_sides]))
 
         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])
+            player = Player(self, player_id, None, segments[i * 2])
             self.players.append(player)
     
         self.spectators: list[Spectator] = []
         
         self.walls: list[Wall] = []
         
-        for i in range(1, self.nb_sides, 2):
-            self.walls.append(Wall(*self.polygon[i], *self.polygon[(i + 1) % self.nb_sides]))
+        for i in range(1, nb_sides, 2):
+            self.walls.append(Wall(segments[i]))
 
         self._updated_players: list[Player] = []
 
@@ -86,12 +92,11 @@ class Game(AbstractRoom):
     
     def get_player_by_user_id(self, user_id: int) -> Player:
         for player in self.players:
-            player: Player
             if (player.user_id == user_id):
                 return player
         return None
     
-    def _send_game_data(self, member: AbstractRoomMember):
+    def _send_game_data(self, member: Spectator | Player):
         member.send("init_game", self.to_dict())
     
     def everbody_is_here(self):
@@ -109,20 +114,24 @@ class Game(AbstractRoom):
         
         if (player.is_connected()):
             player.disconnect(1001)
-        
-        player.connect(socket)
 
+        player.socket = socket
+        
         if (self.everbody_is_here()):
+            print("chie moi dessu")
             print("start")
             self.start()
-        
+
+        self._update_player(player)
+
         return player
     
     def _update_player(self, player: Player):
         self._updated_players.append(player)
     
     def _player_leave(self, player: Player):
-        self._updated_players.append(player)
+        print(player.socket)
+        self._update_player(player)
     
     def _spectator_join(self, user_id: int, socket: WebsocketConsumer):
         
@@ -130,8 +139,6 @@ class Game(AbstractRoom):
         
         self.spectators.append(spectator)
         
-        spectator.accept()
-        
         return spectator
     
     def _spectator_leave(self, spectator: Spectator):

games/objects/GameManager.py

@@ -9,7 +9,7 @@ class GameManager():
     
     def get(self, game_id: int) -> Game:
         
-        if (not GameModel.objects.filter(pk = game_id, started = True, finished = False).exists()):
+        if (not GameModel.objects.filter(pk = game_id, finished = False).exists()):
             return None
         
         for game in self._game_list:

games/objects/Player.py

@@ -6,6 +6,8 @@ from channels.generic.websocket import WebsocketConsumer
 
 from .Position import Position
 from .Spectator import Spectator
+from .Point import Point
+from .Segment import Segment
 
 from typing import TYPE_CHECKING
 
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
 
 class Player(Spectator):
     
-    def __init__(self, game: Game, user_id: int, socket: WebsocketConsumer, rail_start_x: float, rail_start_y: float, rail_stop_x: float, rail_stop_y: float) -> None:
+    def __init__(self, game: Game, user_id: int, socket: WebsocketConsumer, rail: Segment) -> None:
         
         super().__init__(user_id, socket, game)
         
@@ -23,10 +25,7 @@ class Player(Spectator):
         
         self.nb_goal: int = 0
         
-        self.rail_start_x: float = rail_start_x
-        self.rail_start_y: float = rail_start_y
-        self.rail_stop_x: float = rail_stop_x
-        self.rail_stop_y: float = rail_stop_y
+        self.rail: Segment = rail
         
     def receive(self, data: dict):
         
@@ -106,19 +105,17 @@ class Player(Spectator):
     
     def disconnect(self, code: int = 1000):
         self.socket = None
+        print("bozoman")
         self.game.leave(self)
     
-    def to_dict(self):
+    def to_dict(self) -> dict:
         
         data = {
             "user_id": self.user_id,
             "position": self.position.to_dict(),
             "nb_goal": self.nb_goal,
             
-            "rail_start_x": self.rail_start_x,
-            "rail_start_y": self.rail_start_y,
-            "rail_stop_x": self.rail_stop_x,
-            "rail_stop_y": self.rail_stop_y,
+            "rail": self.rail.to_dict(),
             
             "is_connected": self.is_connected(),
         }

games/objects/Point.py

@@ -0,0 +1,16 @@
+
+
+class Point:
+    
+    def __init__(self, x: float, y: float) -> None:
+        self.x = x
+        self.y = y
+        
+    def to_dict(self):
+        
+        data: dict[str: float] = {
+            "x": self.x,
+            "y": self.y,
+        }
+        
+        return data

games/objects/Segment.py

@@ -0,0 +1,17 @@
+
+from .Point import Point
+
+class Segment:
+    
+    def __init__(self, start: Point, stop: Point) -> None:
+        self.start: Point = start
+        self.stop: Point = stop
+        
+    def to_dict(self):
+        
+        data: dict[str: dict] = {
+            "start": self.start.to_dict(),
+            "stop": self.stop.to_dict(),
+        }
+        
+        return data

games/objects/Wall.py

@@ -1,20 +1,15 @@
 
 
+from .Segment import Segment
 class Wall:
     
-    def __init__(self, rail_start_x, rail_start_y, rail_stop_x, rail_stop_y) -> None:
-        self.rail_start_x = rail_start_x
-        self.rail_start_y = rail_start_y
-        self.rail_stop_x = rail_stop_x
-        self.rail_stop_y = rail_stop_y
+    def __init__(self, rail: Segment) -> None:
+        self.rail: Segment = rail
         
-    def to_dict(self):
+    def to_dict(self) -> dict[str: dict]:
         
         data = {
-            "rail_start_x": self.rail_start_x,
-            "rail_start_y": self.rail_start_y,
-            "rail_stop_x": self.rail_stop_x,
-            "rail_stop_y": self.rail_stop_y,
+            "rail": self.rail.to_dict(),
         }
         
         return data