game: add: vector colision (Not work)

games/routine.py

@@ -9,73 +9,99 @@ if TYPE_CHECKING:
     from .objects.Ball import Ball
 
 from .objects.Point import Point
+from .objects.Vector import Point
 from .objects.Segment import Segment
+from .objects.Vector import Vector
 
 from . import config
 
 import math
+import asyncio
+
+from asgiref.sync import SyncToAsync
+
 from time import sleep
 
-#see the video to understand the algorithme
-#https://www.youtube.com/watch?v=KOYoMYWUTEo
-def determine_director_coefficient(segment: Segment):
-    return ((segment.start.y - segment.stop.y) / (segment.start.x - segment.stop.x))
+def get_sign(num: float):
+    return 1 if num >= 0 else -1
 
-def determine_ordinate_at_origin(point: Point, director_cofficient: float):
-    return point.y - point.x * director_cofficient
+def get_impact_point(segments: list[Segment], ball: Ball):
 
-def determine_intersection(director_coefficient1: float, ordinate_at_origin1: float, director_coefficient2: float, ordinate_at_origin2: float):
-    if (director_coefficient1 == director_coefficient2):
-        return None
-    return (ordinate_at_origin1 + ordinate_at_origin2) / (director_coefficient1 + director_coefficient2)
+    angle_radian: float = ball.angle * math.pi / 180
 
-def determine_intersections(ball: Ball, segments: list[Segment]):
-    
-    intersections: list[Point] = []
+    direction_vector: Vector = Vector(math.cos(angle_radian), math.sin(angle_radian))
+
+    x: float = ball.position.x
+    if (direction_vector.x > 0):
+        x = x + ball.size / 2
+    elif (direction_vector.x < 0):
+        x = x - ball.size / 2
     
+    y: float = ball.position.y
+    if (direction_vector.y > 0):
+        y = y + ball.size / 2
+    elif (direction_vector.y < 0):
+        y = y - ball.size / 2
+
+    position: Point = Point(x, y)
+
     for segment in segments:
         
-        # form m * x + p
-        m: float = determine_director_coefficient(segment)
-        p: float = determine_ordinate_at_origin(segment.start, m)
+        segment_vector: Vector = Vector(segment.start.x - segment.stop.x, segment.start.y - segment.stop.y)
+        segment_vector_unit = segment_vector / segment_vector.norm
         
-        x: float = determine_intersection(m, p, ball.velocity_y, 0)
+        scalar: float = segment_vector_unit.scalar(direction_vector)
         
-        if (x is None):
-            continue      
-        
-        y: float = m * x + p
-        
-        intersections.append(Point(x, y))
+        if (scalar < 0.01):
+            continue
 
-    return intersections
+        print(segment_vector, segment_vector_unit, direction_vector)
+        
+        distance: float = scalar * segment_vector.norm / 2
+        
+        impact_x: float = position.x + distance * direction_vector.x
+        
+        impact_y: float = position.y + distance * direction_vector.y
+        
+        impact: Point = Point(impact_x, impact_y)
+        
+        print("impact", impact)
+        
+        return impact
+    
+async def update_ball(game: Game, impact: Point):
+    
+    distance: float = impact.distance(game.ball.position) - game.ball.size / 2
+    
+    time_before_impact: float = distance / game.ball.speed
+    
+    await asyncio.sleep(time_before_impact)
+    
+    game.ball.angle = game.ball.angle + 180
+    
+    game.ball.position = impact
+
+    await SyncToAsync(game.broadcast)("update_ball", game.ball.to_dict())
+
+async def render(game: Game):
+
+    while True:
+        
+        segments: list[Segment] = [player.rail for player in game.players] + [wall.rail for wall in game.walls]
+
+        impact = get_impact_point(segments, game.ball)
+
+        await update_ball(game, impact)
 
-def determine_distance_between_ball_and_wall(ball: Ball, segments: list[Segment]):
-    
-    intersections: list[Point] = determine_intersections(ball, segments)
-    
-    distances = list(map(math.dist, intersections))
-    
-    return min(distances)
-    
-def render(ball: Ball, game: Game):
-    
-    segments: list[Segment] = [player.rail for player in game.players]
-    
-    print(determine_distance_between_ball_and_wall(ball))
 
 def routine(game: Game):
-    
+
+    asyncio.run(render(game))
+
     while True:
         for player in game._updated_players:
             game.broadcast("update_paddle", player.to_dict(), [player])
-        
+
         game._updated_players.clear()
-        
-        if (game.started):
-            game.ball.postion_x = game.ball.postion_x + game.ball.velocity_x
-            game.ball.postion_y = game.ball.postion_y + game.ball.velocity_y
-            
-            game.broadcast("update_ball", game.ball.to_dict())
-        
+
         sleep(1 / config.SERVER_TPS)