src/engine.py

@@ -12,6 +12,10 @@ class Engine:
     def __init__(self):
         # L'initialisation de Pygame est nécessaire pour tous les modules
         pygame.init()
+
+        # Debug mode utilisé pour tricher (voir les collisions, etc...) WOW ! n'utilisez pas ça pour jouer !
+        self.DEBUG_MODE = True
+
         self.clock = pygame.time.Clock()
 
         self.running = False

src/entity.py

@@ -1,9 +1,14 @@
+from src.map_manager import MapManager
+
+
 class Entity:
     """Classe permettant de gérer les entités. Créée automatiquement par `EntityManager.register_entity()`"""
     def __init__(self, name: str):
         self.x = 8
         self.y = 8
 
+        self.collision_rect = [-7, -7, 7, 7]  # x1, y1, x2, y2
+
         # Time utilisé pour les IA
         self.time = 0
 
@@ -17,5 +22,14 @@ class Entity:
 
         self.time += delta
 
+    def move(self, x: float, y: float, map_manager: MapManager):
+        """Fait bouger l'entité en tenant compte des collisions."""
+
+        # Pour les collisions, on utilise le layer 1 (le deuxième)
+
+        top_left_corner_tile = map_manager.get_tile_at(self.x+x-self.collision_rect[0], self.y+y-self.collision_rect[1])
+
+
+
     def link_animation(self, name: str):
         self.animation_name = name

src/renderer.py

@@ -1,6 +1,6 @@
 import math
 
-from pygame import display, image, surface, transform
+from pygame import display, image, surface, transform, draw
 from pygame.locals import RESIZABLE
 
 import src.engine as engine
@@ -9,6 +9,7 @@ from src.animation import Anim
 
 class Renderer:
     """Classe contenant le moteur de rendu. On utilise, pour cela la bibliothèque Pygame."""
+
     def __init__(self, core: 'engine.Engine'):
         self.engine = core
         self.window = display.set_mode((600, 600), RESIZABLE)
@@ -23,9 +24,9 @@ class Renderer:
         self.tile_size = tile_size
 
         # Scan tout le tile set et le découpe pour créer des tiles de {tile_size} px de hauteur et de largeur
-        for y in range(tile_set.get_height()//tile_size):
+        for y in range(tile_set.get_height() // tile_size):
-            for x in range(tile_set.get_width()//tile_size):
+            for x in range(tile_set.get_width() // tile_size):
-                tile = tile_set.subsurface((x*tile_size, y*tile_size, tile_size, tile_size))
+                tile = tile_set.subsurface((x * tile_size, y * tile_size, tile_size, tile_size))
                 self.tiles.append(tile)
 
     def update(self):
@@ -43,9 +44,10 @@ class Renderer:
         self.renderer_layer(2, rendered_surface)
 
         # Enfin, on redimensionne notre surface et on la colle sur la fenêtre principale
-        self.window.blit(transform.scale(rendered_surface, (math.ceil(rendered_surface_size[0] * self.engine.camera.zoom),
+        self.window.blit(
-                                                            math.ceil(rendered_surface_size[1] * self.engine.camera.zoom))),
+            transform.scale(rendered_surface, (math.ceil(rendered_surface_size[0] * self.engine.camera.zoom),
-                         (0, 0))
+                                               math.ceil(rendered_surface_size[1] * self.engine.camera.zoom))),
+            (0, 0))
 
         # Apres avoir tout rendu, on met à jour l'écran
         display.update()
@@ -65,9 +67,23 @@ class Renderer:
             anim: Anim = self.animations[entity.animation_name]
             frame = anim.get_frame(0.01666667)
 
+            # On calcule les coordonnées de rendu de l'entité
+            player_dest = (entity.x - self.engine.camera.x + x_middle_offset - frame.get_width() / 2,
+                           entity.y - self.engine.camera.y + y_middle_offset - frame.get_height() / 2)
+
             # On affiche l'image
-            rendered_surface.blit(frame, (entity.x-self.engine.camera.x+x_middle_offset-frame.get_width()/2,
+            rendered_surface.blit(frame, player_dest)
-                                          entity.y-self.engine.camera.y+y_middle_offset-frame.get_height()/2))
+
+            if self.engine.DEBUG_MODE:
+                top_let_corner_x = entity.x - self.engine.camera.x + x_middle_offset
+                top_let_corner_y = entity.y - self.engine.camera.y + y_middle_offset
+
+                draw.rect(rendered_surface, (255, 0, 0),
+                          (top_let_corner_x + entity.collision_rect[0],
+                           top_let_corner_y + entity.collision_rect[1],
+                           entity.collision_rect[2] - entity.collision_rect[0],
+                           entity.collision_rect[3] - entity.collision_rect[1]),
+                          width=1)
 
     def renderer_layer(self, layer_id: int, rendered_surface: surface.Surface):
         """Rend la map."""
@@ -95,7 +111,6 @@ class Renderer:
                     continue
 
                 # Puis, on cherche à quelle image elle correspond et on la colle sur notre surface
-                rendered_surface.blit(self.tiles[tile_id-1],
+                rendered_surface.blit(self.tiles[tile_id - 1],
-                                      ((x*self.tile_size-self.engine.camera.x+x_middle_offset),
+                                      ((x * self.tile_size - self.engine.camera.x + x_middle_offset),
-                                       (y*self.tile_size-self.engine.camera.y+y_middle_offset)))
+                                       (y * self.tile_size - self.engine.camera.y + y_middle_offset)))
-