src/custom_AI.py

@@ -32,23 +32,23 @@ class WolfAI(MobAI):
 
         # On vérifie que le loup peut voir le joueur
         if player_distance <= self.ATTACK_DISTANCE:
-            # On rétablit la vitesse du loup à 1
+            # On rétablit la vitesse du loup à 60
-            self.entity.max_speed = 1.
+            self.entity.max_speed = 60.
 
             # Si le loup touche le joueur, il lui inflige des dégats
             if player.get_collisions_with_entity(self.entity):
                 player.take_damages(1)
 
             # Si le loup n'est pas déja sur le joueur, on le fait s'en raprocher
-            if player_distance > self.entity.max_speed:
+            if player_distance > 1.:
                 self.entity.move(x_distance / player_distance*self.entity.max_speed,
-                                 y_distance / player_distance*self.entity.max_speed, self.map_manager)
+                                 y_distance / player_distance*self.entity.max_speed, self.map_manager, delta)
 
         else:
             # Comportement d'attente
 
             # On diminue la vitesse
-            self.entity.max_speed = 0.5
+            self.entity.max_speed = 30.
 
             self.timer -= delta
             # Si le timer est fini et que le loup était en train d'attendre, il commence à marcher
@@ -66,4 +66,4 @@ class WolfAI(MobAI):
 
             # On fait avancer le loup quand il le doit
             if self.comportment == 1:
-                self.entity.move(self.walk_x, self.walk_y, self.map_manager)
+                self.entity.move(self.walk_x, self.walk_y, self.map_manager, delta)

src/engine/camera.py

@@ -15,11 +15,11 @@ class Camera:
         self.target_y = self.y
         self.target_zoom = self.zoom
 
-        self.smoothness = 20.
+        self.smoothness = 0.5
 
         self.followed_entity: Entity | None = None
 
-    def update(self):
+    def update(self, delta: float):
         """Met à jour la caméra. Permet, par exemple, de faire le scrolling."""
 
         # Si on suit une entité, on met à jour les coordonnées de suivi
@@ -29,9 +29,9 @@ class Camera:
             self.target_y = (self.followed_entity.y + self.followed_entity.mouvements[1] *
                              self.player_moving_offset / self.zoom)
 
-        self.x += (self.target_x - self.x) / self.smoothness
+        self.x += (self.target_x - self.x)*delta / self.smoothness
-        self.y += (self.target_y - self.y) / self.smoothness
+        self.y += (self.target_y - self.y)*delta / self.smoothness
-        self.zoom += (self.target_zoom - self.zoom) / self.smoothness
+        self.zoom += (self.target_zoom - self.zoom)*delta / self.smoothness
 
     def follow_entity(self, entity: Entity | None):
         """Active le suivit de l'entité donnée. Mettre `None` pour retirer le suivit."""

src/engine/engine.py

@@ -1,3 +1,5 @@
+import time
+
 from src.engine.boss_fight_manager import BossFightManager
 from src.engine.camera import Camera
 from src.engine.dialogs_manager import DialogsManager
@@ -24,8 +26,6 @@ class Engine:
         # Etat courant du jeu
         self.game_state = GameState.NORMAL
 
-        self.clock = pygame.time.Clock()
-
         self.running = False
 
         # Composants du moteur de jeu
@@ -44,20 +44,26 @@ class Engine:
         """Fonction à lancer au début du programme et qui va lancer les updates dans une boucle.
         Attend jusqu'à la fin du jeu."""
         self.running = True
-        while self.running:
-            self.update()
-            self.clock.tick(60.)
 
-    def update(self):
+        delta = 1.  # Le delta est le temps depuis la dernière image
+        last_time = time.time_ns()/10E8
+        while self.running:
+            self.update(delta)
+
+            new_time = time.time_ns()/10E8
+            delta = new_time-last_time
+            last_time = new_time
+
+    def update(self, delta: float):
         """Fonction qui regroupe toutes les updates des composants. Elle permet de mettre à jour le jeu quand on
         l'appelle."""
-        self.camera.update()
+        self.camera.update(delta)
-        self.entity_manager.update(0.016666666)
+        self.entity_manager.update(delta)
-        self.renderer.update(0.016666666)
+        self.renderer.update(delta)
-        self.event_handler.update()
+        self.event_handler.update(delta)
         self.event_sheduler.update()
-        self.dialogs_manager.update(0.016666666)
+        self.dialogs_manager.update(delta)
-        self.sound_manager.update(1/60)
+        self.sound_manager.update(delta)
 
     def stop(self):
         """Arrête le programme."""

src/engine/entity.py

@@ -65,8 +65,23 @@ class Entity:
 
         # Si les coordonnées ont changé, l'entité a bougé
 
-        self.mouvements[0] = (self.x - self.last_x) / self.max_speed
+        x_motion = (self.x - self.last_x)
-        self.mouvements[1] = (self.y - self.last_y) / self.max_speed
+
+        if x_motion > 0:
+            self.mouvements[0] = 1
+        elif x_motion < 0:
+            self.mouvements[0] = -1
+        else:
+            self.mouvements[0] = 0
+
+        y_motion = (self.y - self.last_y)
+
+        if y_motion > 0:
+            self.mouvements[1] = 1
+        elif y_motion < 0:
+            self.mouvements[1] = -1
+        else:
+            self.mouvements[1] = 0
 
         self.last_x = self.x
         self.last_y = self.y
@@ -116,10 +131,10 @@ class Entity:
 
         return collision
 
-    def move(self, x: float, y: float, map_manager: MapManager):
+    def move(self, x: float, y: float, map_manager: MapManager, delta: float):
         """Fait bouger l'entité en tenant compte des collisions."""
 
-        if not self.locked: # Si l'entité n'est pas verrouillée on calcul le mouvement
+        if not self.locked:  # Si l'entité n'est pas verrouillée on calcul le mouvement
             
             # On vérifie le sens du mouvement pour changer self.direction
             if x > 0:
@@ -131,8 +146,8 @@ class Entity:
             # On normalise la vitesse
             initial_speed = math.sqrt(x**2+y**2)
 
-            x = x/initial_speed*self.max_speed
+            x = x*delta/initial_speed*self.max_speed
-            y = y/initial_speed*self.max_speed
+            y = y*delta/initial_speed*self.max_speed
 
             # On simule le mouvement. Si on ne rencontre pas de collision, on applique le mouvement
         

src/engine/entity_manager.py

@@ -21,10 +21,10 @@ class EntityManager:
         """Définit l'entité donnée comme le joueur. Elle peut donc être controlée."""
         self.player_entity_name = name
 
-    def move_player_controls(self, x: float, y: float):
+    def move_player_controls(self, x: float, y: float, delta: float):
         """Bouge le joueur. X et y doivent être compris entre 0 et 1"""
         player: Entity = self.get_by_name(self.player_entity_name)
-        player.move(x, y, self.map_manager)
+        player.move(x, y, self.map_manager, delta)
 
     def update(self, delta: float):
         """Met à jour toutes les entités enregistrées."""
@@ -61,7 +61,6 @@ class EntityManager:
                 e.lock()
         self.paused = True
 
-    
     def resume(self):
         """Reprend les mouvement de toutes les entitées qui n'étaient pas lock avant l'appel de .pause()"""
         for e in self.get_all_entities():
@@ -69,4 +68,4 @@ class EntityManager:
                 e.unlock()
         
         self.paused = False
-        self.locked_before_pause = []
+        self.locked_before_pause = []

src/engine/event_handler.py

@@ -98,7 +98,7 @@ class EventHandler:
         return x_value, y_value
 
 
-    def update(self):
+    def update(self, delta: float):
         """Vérifie s'il y a de nouvelles interactions et les traites."""
 
         window_size = display.get_window_size()
@@ -203,13 +203,13 @@ class EventHandler:
 
         if self.engine.entity_manager.player_entity_name:
             if K_RIGHT in self.key_pressed:
-                self.engine.entity_manager.move_player_controls(1, 0)
+                self.engine.entity_manager.move_player_controls(1, 0, delta)
             if K_LEFT in self.key_pressed:
-                self.engine.entity_manager.move_player_controls(-1, 0)
+                self.engine.entity_manager.move_player_controls(-1, 0, delta)
             if K_UP in self.key_pressed:
-                self.engine.entity_manager.move_player_controls(0, -1)
+                self.engine.entity_manager.move_player_controls(0, -1, delta)
             if K_DOWN in self.key_pressed:
-                self.engine.entity_manager.move_player_controls(0, 1)
+                self.engine.entity_manager.move_player_controls(0, 1, delta)
 
             if K_SPACE in self.key_pressed:
                 self.engine.dialogs_manager.next_signal()
@@ -221,7 +221,7 @@ class EventHandler:
                 if K_p in self.key_pressed:
                     self.engine.renderer.emit_particles(math.floor(self.engine.entity_manager.get_by_name("player").x),
                                                         math.floor(self.engine.entity_manager.get_by_name("player").y),
-                                                        16, 16, 16, 1, 8, 0, 1, 0.2, 1., (0, 200, 200))
+                                                        16, 16, 16, 1, 8, 0, 60., 0.2, 1., (0, 200, 200))
                 if K_o in self.key_pressed:
                     print(f"Player pos: X = {self.engine.entity_manager.get_by_name('player').x} "
                           f"Y = {self.engine.entity_manager.get_by_name('player').y}")

src/engine/renderer.py

@@ -172,7 +172,7 @@ class Renderer:
 
         # Conteur de FPS en mode DEBUG
         if self.engine.DEBUG_MODE:
-            self.window.blit(font.SysFont("Arial", 20).render(f"FPS: {round(self.engine.clock.get_fps())}, Game Status: {'Paused' if self.engine.entity_manager.paused else 'Playing'}", True, (255, 0, 0)),
+            self.window.blit(font.SysFont("Arial", 20).render(f"FPS: {round(1/delta if delta else 1)}, Game Status: {'Paused' if self.engine.entity_manager.paused else 'Playing'}", True, (255, 0, 0)),
                              (0, 0))
             player = self.engine.entity_manager.get_by_name('player')
             self.window.blit(font.SysFont("Arial", 20).render(f"X: {round(player.x, 2)} Y:{round(player.y, 2)}",
@@ -480,8 +480,8 @@ class Renderer:
 
             draw.rect(rendered_surface, part[7], part_dest + (part[2], part[2]))
             part[5] += delta
-            part[0] += part[3]
+            part[0] += part[3]*delta
-            part[1] += part[4]
+            part[1] += part[4]*delta
             if part[5] > part[6]:
                 self.particles.remove(part)
 

src/main.py

@@ -72,7 +72,7 @@ class Game(Engine):
         player.collision_rect = [-6, -7, 6, 16]
 
         player.set_default_life(15)
-        player.max_speed = 1.1
+        player.max_speed = 64.0
 
         self.entity_manager.set_player_entity("player")
 
@@ -95,7 +95,7 @@ class Game(Engine):
         mob.collision_rect = [-15, -7, 12, 7]
 
         mob.set_default_life(5)
-        mob.max_speed = 1.
+        mob.max_speed = 60.
 
         mob.x, mob.y = 1600, 16