Merge remote-tracking branch 'origin/main' into sliders

# Conflicts:
#	src/engine/event_handler.py

src/engine/camera.py

@@ -5,7 +5,7 @@ class Camera:
     def __init__(self):
         self.x = 0
         self.y = 0
-        self.zoom = 1.
+        self.zoom = 1.75
 
         # Décalage lors du mouvement du joueur
         self.player_moving_offset = 100

src/engine/dialogs_manager.py

@@ -1,14 +1,11 @@
 import json
 from types import FunctionType
-
-from src.engine.event_handler import EventHandler
-
+import src.engine.engine as engine
 
 class DialogsManager:
     """Classe qui gère la lecture des dialogues."""
-    def __init__(self, event_handler: EventHandler):
-        self.event_handler = event_handler
-
+    def __init__(self, engine: 'engine.Engine'):
+        self.engine = engine
         self.current_dialogs = []
         self.current_dialog_id = -1
         self.dialogs = {}
@@ -31,8 +28,6 @@ class DialogsManager:
             else:
                 self.next_dialog()
 
-        print("next")
-
     def next_dialog(self):
         """Passe au dialogue suivant. Appelle le callback si le dialogue est fini."""
         self.current_dialog_id += 1
@@ -43,7 +38,8 @@ class DialogsManager:
             self.current_dialog_id = -1
             self.writing_dialog = False
             self.reading_dialog = False
-            self.event_handler.remove_button_area("next_dialog")
+            self.engine.entity_manager.resume()
+            self.engine.event_handler.remove_button_area("next_dialog")
             if self.dialogue_finished_callback is not None:
                 self.dialogue_finished_callback()
 
@@ -52,7 +48,9 @@ class DialogsManager:
 
         # Si un dialogue n'est pas déja lancé, on lance le dialogue au nom donné
         if not self.reading_dialog:
-            self.event_handler.register_button_area((0, 0, 1, 1), self.next_signal, "next_dialog", 2)
+            self.engine.entity_manager.pause()
+
+            self.engine.event_handler.register_button_area((0, 0, 1, 1), self.next_signal, "next_dialog", 2)
 
             self.current_dialogs = self.dialogs[name]
             self.current_dialog_id = 0

src/engine/engine.py

@@ -36,7 +36,7 @@ class Engine:
         self.entity_manager = EntityManager(self.map_manager)
         self.boss_fight_manager = BossFightManager(self)
         self.event_sheduler = EventSheduler(self)
-        self.dialogs_manager = DialogsManager(self.event_handler)
+        self.dialogs_manager = DialogsManager(self)
         self.menu_manager = MenuManager(self)
         self.sound_manager = SoundManager(60)
 

src/engine/entity.py

@@ -11,6 +11,8 @@ class Entity:
         self.x = 8
         self.y = 8
 
+        self.locked = False # Variable définissant si l'entité est bloqué ou non (.lock() et .unlock())
+
         self.direction = 0  # 0 : tourné vers la droite (ou sens par défaut), 1 : tourné vers la gauche (ou retourné)
 
         # Variables utilisées pour détecter les mouvements
@@ -117,52 +119,64 @@ class Entity:
     def move(self, x: float, y: float, map_manager: MapManager):
         """Fait bouger l'entité en tenant compte des collisions."""
 
-        # On vérifie le sens du mouvement pour changer self.direction
-        if x > 0:
-            self.direction = 0
-        elif x < 0:
-            self.direction = 1
-        # On ne met pas de else car si x = 0, on ne change pas de direction
-
-        # On normalise la vitesse
-        initial_speed = math.sqrt(x**2+y**2)
-
-        x = x/initial_speed*self.max_speed
-        y = y/initial_speed*self.max_speed
-
-        # On simule le mouvement. Si on ne rencontre pas de collision, on applique le mouvement
-        if not self.get_collisions(self.x + x, self.y, map_manager):
-            self.x += x
-        else:
-            # Si on a une collision, on avance pixel par pixel jusqu'à atteindre la collision
-            i = 0
+        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:
-                while not self.get_collisions(self.x + i, self.y, map_manager):
-                    i += 1
-                i -= 1
+                self.direction = 0
+            elif x < 0:
+                self.direction = 1
+            # On ne met pas de else car si x = 0, on ne change pas de direction
+
+            # On normalise la vitesse
+            initial_speed = math.sqrt(x**2+y**2)
+
+            x = x/initial_speed*self.max_speed
+            y = y/initial_speed*self.max_speed
+
+            # On simule le mouvement. Si on ne rencontre pas de collision, on applique le mouvement
+        
+            if not self.get_collisions(self.x + x, self.y, map_manager):
+                self.x += x
             else:
-                while not self.get_collisions(self.x + i, self.y, map_manager):
+                # Si on a une collision, on avance pixel par pixel jusqu'à atteindre la collision
+                i = 0
+                if x > 0:
+                    while not self.get_collisions(self.x + i, self.y, map_manager):
+                        i += 1
                     i -= 1
-                i += 1
-
-            self.x += i
-
-        # On répète le procédé avec l'ordonnée
-        if not self.get_collisions(self.x, self.y + y, map_manager):
-            self.y += y
-        else:
-            i = 0
-            if y > 0:
-                while not self.get_collisions(self.x, self.y + i, map_manager):
+                else:
+                    while not self.get_collisions(self.x + i, self.y, map_manager):
+                        i -= 1
                     i += 1
-                i -= 1
-            else:
-                while not self.get_collisions(self.x, self.y + i, map_manager):
-                    i -= 1
-                i += 1
 
-            self.y += i
+                self.x += i
+
+            # On répète le procédé avec l'ordonnée
+            if not self.get_collisions(self.x, self.y + y, map_manager):
+                self.y += y
+            else:
+                i = 0
+                if y > 0:
+                    while not self.get_collisions(self.x, self.y + i, map_manager):
+                        i += 1
+                    i -= 1
+                else:
+                    while not self.get_collisions(self.x, self.y + i, map_manager):
+                        i -= 1
+                    i += 1
+
+                self.y += i
 
     def link_animation(self, name: str):
-        """Met à jour l'animation en cours de l'entité."""
+        """Met à jour l'animation en cours de l'entitée."""
         self.animation_name = name
+
+
+    def lock(self):
+        """Bloque tout les mouvements de l'entitée"""
+        self.locked = True
+
+    def unlock(self):
+        """Débloque tout les mouvements de l'entitée"""
+        self.locked = False

src/engine/entity_manager.py

@@ -8,6 +8,8 @@ class EntityManager:
         self.entities: dict[str:Entity] = {}
         self.player_entity_name = ""
         self.map_manager = map_manager
+        self.locked_before_pause: list[Entity] = []
+        self.paused = False
 
     def register_entity(self, name: str) -> Entity:
         """Crée une entité et l'enregistre dans un dictionnaire."""
@@ -32,7 +34,7 @@ class EntityManager:
             if entity.life_points == 0:
                 self.entities.pop(entity_name)
 
-            if entity.brain is not None:
+            if entity.brain is not None and not self.paused:
                 entity.brain.update(delta)
 
         if self.player_entity_name:
@@ -49,3 +51,22 @@ class EntityManager:
     def get_by_name(self, name: str) -> Entity:
         """Donne l'entité avec le nom donné."""
         return self.entities[name]
+
+    def pause(self):
+        """Met en pause tout les mouvements de toutes les entitées"""
+        for e in self.get_all_entities():
+            if e.locked:
+                self.locked_before_pause.append(e)
+            else:
+                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():
+            if not e in self.locked_before_pause:
+                e.unlock()
+        
+        self.paused = False
+        self.locked_before_pause = []

src/engine/event_handler.py

@@ -1,7 +1,6 @@
 import math
 from types import FunctionType
 
-import pygame.display
 from pygame import event, display
 from pygame.locals import *
 
@@ -102,7 +101,7 @@ class EventHandler:
     def update(self):
         """Vérifie s'il y a de nouvelles interactions et les traites."""
 
-        window_size = pygame.display.get_window_size()
+        window_size = display.get_window_size()
 
         # Récupère les événements
         for e in event.get():
@@ -120,6 +119,7 @@ class EventHandler:
                         if self.get_click_collision(area[0], e.pos, area[2]):
                             area[1]()
 
+
                     for area in self.sliders_area:
                         if self.get_click_collision(
                                 (area[0][0]-area[0][2]/2, area[0][1]-area[0][3]/2, area[0][2], area[0][3]),
@@ -176,7 +176,7 @@ class EventHandler:
                                 area[0][1] = e.pos[1]/window_size[1]-area[3][1]
                             else:
                                 area[0][1] = e.pos[1]-area[3][1]
-                        
+
                         if area[0][0] < area[5][0]:
                             area[0][0] = area[5][0]
                         if area[0][0] > area[5][0]+area[5][2]:
@@ -226,7 +226,8 @@ class EventHandler:
                     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}")
 
-        if K_x in self.key_pressed:
-            self.engine.camera.target_zoom *= 1.01
-        if K_c in self.key_pressed:
-            self.engine.camera.target_zoom *= 0.99
+                if K_x in self.key_pressed:
+                    self.engine.camera.target_zoom *= 1.01
+                if K_c in self.key_pressed:
+                    self.engine.camera.target_zoom *= 0.99
+

src/engine/renderer.py

@@ -117,7 +117,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())}", True, (255, 0, 0)),
+            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)),
                              (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)}",