Add Ball class and integrate with Game and Player classes; update Player size and fix Velocity attributes

src/ball.py

@@ -0,0 +1,60 @@
+import pygame
+import random
+import math
+from typing import Tuple
+from entity import Entity
+from screen import Screen
+from player import Player
+
+class Ball(Entity):
+    def __init__(self, screen_manager: Screen, player:Player):
+        self.player = player
+
+        self.size = 30
+        color_ball = (255, 200, 200, 255)
+
+        image:pygame.Surface = pygame.Surface((self.size, self.size), pygame.SRCALPHA)
+        pygame.draw.circle(image, color_ball, (round(self.size / 2), round(self.size / 2)), self.size / 2)
+
+        origin: Tuple[int, int] = (round(screen_manager.get_screen().get_size()[0] / 2) - round(self.size / 2), round(screen_manager.get_screen().get_size()[1] / 2) - round(self.size / 2))
+
+        super().__init__("Ball", origin, image, screen_manager)
+
+        self.speed: int = 25
+        self.friction.x = 1    # le vrai speed est la différence entre friction.x et speed
+        self.velocity.max = 4 ** 2  # Mettre au carré pour économiser des calcules plus tard (sur la normalisation du mouvement)
+        self.velocity.min = 2
+
+    def draw(self):
+        self.screen.blit(self.image, (self.pos.x, self.pos.y))
+
+    def speed_up(self):
+        self.velocity.x += .5
+        self.velocity.y += .5
+
+    def move(self, deltatime: float):
+        if (self.velocity.x == 0 and self.velocity.y == 0):  # si la balle est a l'arret lui donner un mouvement aléatoire
+            self.velocity.x = random.randint(1, int(self.velocity.max))
+            self.velocity.y = random.randint(1, int(self.velocity.max))
+
+
+        norm: float = self.velocity.x ** 2 + self.velocity.y ** 2  # norme du vecteur mouvement
+        scale: float = 1
+        if (norm > self.velocity.max):
+            scale = math.sqrt(self.velocity.max / norm)
+        elif(norm < self.velocity.min):
+            scale = math.sqrt(self.velocity.min / norm)  
+
+        self.velocity.x *= scale
+        self.velocity.y *= scale
+
+        if (self.pos.x < 0 or (self.pos.x + round(self.size / 2)) > self.screen.get_size()[0]): self.velocity.x = -self.velocity.x  # Collision avec le mur
+
+        if ((self.pos.y + self.size / 2) >= self.player.pos.y - self.player.size[1] and self.pos.y <= self.player.pos.y): 
+            if (self.pos.x + self.size >= self.player.pos.x and self.pos.x - self.size <= self.player.pos.x + self.player.size[0]):
+                self.velocity.y = -self.velocity.y
+                self.speed_up()
+
+
+        self.pos.x += round(self.velocity.x)
+        self.pos.y += round(self.velocity.y)

src/entity.py

@@ -13,7 +13,8 @@ class Pos:
 class Velocity:
     x: float
     y: float
-    max: float = 50
+    max: float = 50.0
+    min: float = 0.0
 
 @dataclass
 class Friction:  # les forces de frottement

src/game.py

@@ -1,6 +1,7 @@
 import pygame
 from screen import Screen
 from player import Player
+from ball import Ball
 
 class Game:
     def __init__(self):
@@ -12,7 +13,8 @@ class Game:
 
         self.running = True
 
-        self.player = Player(self.screen_manager)
+        self.player: Player = Player(self.screen_manager)
+        self.ball: Ball = Ball(self.screen_manager, self.player)
 
     def run(self):
         while (self.running):
@@ -27,5 +29,7 @@ class Game:
             dt: float = dt_ms / 1000.0 
 
             self.player.move(dt)
+            self.ball.move(dt)
             self.player.draw()
+            self.ball.draw()
             pygame.display.flip()

src/player.py

@@ -5,7 +5,7 @@ from screen import Screen
 
 class Player(Entity):
     def __init__(self, screen_manager: Screen):
-        self.size = (150, 5)
+        self.size = (150, 15)
         color_player = (255, 255, 255, 255)
 
         image:pygame.Surface = pygame.Surface(self.size)