game: add: vector colision (Not work)

games/objects/Ball.py

@@ -1,23 +1,28 @@
+from __future__ import annotations
+
 from .. import config
 
+from .Point import Point
+
+import math
 class Ball:
     
     def __init__(self) -> None:
-        self.postion_x: float = config.BALL_SPAWN_POS_X
-        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
+        self.position: Point = Point(config.BALL_SPAWN_POS_X + self.size / 2, config.BALL_SPAWN_POS_Y + self.size / 2)
+        self.angle: float = math.pi * 0
+        self.speed: float = config.BALL_SPEED_START
     
     def to_dict(self):
         
         data: dict = {
             "size": self.size,
-            "position_x": self.postion_x,
-            "position_y": self.postion_y,
-            "velocity_x": self.velocity_x,
-            "velocity_y": self.velocity_y,
+            "speed": self.speed,
+            "position": self.position.to_dict(),
+            "angle": self.angle,
         }
         
         return data
-        
+    
+    def __str__(self) -> str:
+        return f"Ball(size: {self.size}, speed: {self.speed}, director_coefficient: {self.director_coefficient}, ordinate_at_origin: {self.ordinate_at_origin}, position: {self.position})"

games/objects/Game.py

@@ -44,8 +44,8 @@ class Game(AbstractRoom):
 
             angle: float = (i * 2 * math.pi / nb_sides) + (math.pi * 3 / nb_sides)
 
-            x: float = config.MAP_CENTER_X + radius * math.cos(angle)
-            y: float = config.MAP_CENTER_Y + radius * math.sin(angle)
+            x: float = round(config.MAP_CENTER_X + radius * math.cos(angle))
+            y: float = round(config.MAP_CENTER_Y + radius * math.sin(angle))
             
             polygon.append(Point(x, y))
         

games/objects/Point.py

@@ -1,11 +1,28 @@
+from __future__ import annotations
 
-
+from math import dist
 class Point:
     
     def __init__(self, x: float, y: float) -> None:
         self.x = x
         self.y = y
+    
+    def __str__(self) -> str:
+        return f"Point(x: {self.x}, y: {self.y})"
+    
+    def __repr__(self) -> str:
+        return f"Point(x: {self.x}, y: {self.x})"
+    
+    def __eq__(self, __value: object) -> bool:
+        return (self.x == __value.x and self.y == __value.y)
+    
+    def distance(self, point: Point):
+        return dist((point.x, point.y), (self.x, self.y))
+    
+    def copy(self):
         
+        return Point(self.x, self.y)
+    
     def to_dict(self):
         
         data: dict[str: float] = {

games/objects/Segment.py

@@ -1,12 +1,20 @@
 
 from .Point import Point
 
+import math
 class Segment:
     
     def __init__(self, start: Point, stop: Point) -> None:
         self.start: Point = start
         self.stop: Point = stop
-        
+        self.length: float = math.dist((self.start.x, self.start.y), (self.stop.x, self.stop.y))
+    
+    def __repr__(self) -> str:
+        return f"Segment(start: {self.start}, stop: {self.stop})"
+    
+    def __str__(self) -> str:
+        return f"Segment(start: {self.start}, stop: {self.stop})"
+    
     def to_dict(self):
         
         data: dict[str: dict] = {

games/objects/Vector.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import math
+from .Point import Point
+
+class Vector:
+
+    def __init__(self, x: float, y: float) -> None:
+        self.norm: float = math.dist((0, 0), (x, y))
+        self.x: float = x
+        self.y: float = y
+
+    def __truediv__(self, denominator: float):
+        return Vector(self.x / denominator, self.y / denominator)
+    
+    def angle(self, vector: Vector):
+        scalar_product: float = self.scalar(vector)
+        if (scalar_product is None):
+            return None
+        cos: float = scalar_product / (vector.norm * self.norm)
+        
+        angle: float = math.acos(cos)
+        
+        return angle
+
+    def scalar(self, vector: Vector):
+        return self.x * vector.x + vector.y * self.y
+    
+    def __str__(self) -> str:
+        return f"Vector(x: {self.x}, y: {self.y}, norme: {self.norm})"
+    
+    def __eq__(self, __value: Vector) -> bool:
+        return (self.x == __value.x and
+                self.x == __value.x and 
+                self.norm == __value.norm)