ajout personnage, du nid, et des graines. Certaines fonctions a revoir cependant (perso, nid)

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:system"
+}

main.py

@@ -2,6 +2,9 @@ import pygame, sys
 from pygame.locals import * # Import des constantes de pygame
 from world import *
 from variables import *
+from player import *
+from nest import *
+
 
 def main():
     """La fonction pricipale"""
@@ -18,6 +21,12 @@ def main():
     world = World(display, NB_COL, NB_ROW, GAP)
     world.draw()
 
+    player = Player(0, 0, display)
+    player.draw(world.pos_list[1])              #Le choix de la tuile a été arbitraire
+
+    nest = Nest(0, display)
+    nest.draw(world.pos_list[0], 0)
+
     ### Boucle principale ###
     while True:
         

nest.py

@@ -0,0 +1,43 @@
+import pygame
+from tiles import *
+from variables import *
+
+
+class Nest:
+    def __init__(self, eggs: int, display: pygame.display):
+        """Un joueur, avec ses coordonnées (x, y)"""
+        self.display = display
+        self.eggs: int = eggs
+
+
+    def draw(self, tile: dict, eggs: int):
+        """Affiche le nid"""
+        image = pygame.transform.scale(NEST, (self.nest_size(), self.nest_size()))
+        tile_size = self.tile_size()
+        self.display.blit(image, (tile['x'] - tile_size // 3.7, tile['y'] - tile_size // 3.7))  #la valeur ici est arbitraire mais marche. elle est la pour centrer l'affichage du joueur sur une tuile, a changer dans le futur
+
+    def nest_size(self):
+        """Renvoie la taille que fera le joueur (sa hauteur et sa largeur sont similaires)"""
+        width = (WINDOW_WIDTH - NB_COL * GAP) // NB_COL
+        height = (WINDOW_HEIGHT - NB_ROW * GAP) // NB_ROW
+
+        #Réutilisation du calcul de la taille des tuilles pour calculer la taille du joueur
+        if height < 0.86 * width:
+            width = height // 0.86
+        else:
+            height = round(width * 0.86)
+        return int(width) // 1.8
+
+
+
+    def tile_size(self):
+        """Renvoie la taille d'une tuille                       CECI EST UNE FONCTION TEST QUI POURRAS SUREMENT ETRE ENLEVEE"""
+        width = (WINDOW_WIDTH - NB_COL * GAP) // NB_COL
+        height = (WINDOW_HEIGHT - NB_ROW * GAP) // NB_ROW
+
+        #Réutilisation du calcul de la taille des tuilles pour calculer la taille du joueur
+        if height < 0.86 * width:
+            width = height // 0.86
+        else:
+            height = round(width * 0.86)
+        return int(width)

player.py

@@ -0,0 +1,47 @@
+import pygame
+from tiles import *
+from variables import *
+
+
+class Player:
+    def __init__(self, x: int, y: int, display: pygame.display):
+        """Un joueur, avec ses coordonnées (x, y)"""
+        self.display = display
+        self.x: int = x
+        self.y: int = y
+        self.width: int = self.player_size()
+        self.height: int = self.player_size()
+        self.picture: str = "player"
+
+    def draw(self, tile: dict):
+        """Affiche le joueur"""
+        image = pygame.transform.scale(PLAYER, (self.player_size(), self.player_size()))
+        tile_size = self.tile_size()
+        self.display.blit(image, (tile['x'] - tile_size // 3.7, tile['y'] - tile_size // 3.7))  #la valeur ici est arbitraire mais marche. elle est la pour centrer l'affichage du joueur sur une tuile, a changer dans le futur
+
+    def player_size(self):
+        """Renvoie la taille que fera le joueur (sa hauteur et sa largeur sont similaires)"""
+        width = (WINDOW_WIDTH - NB_COL * GAP) // NB_COL
+        height = (WINDOW_HEIGHT - NB_ROW * GAP) // NB_ROW
+
+        #Réutilisation du calcul de la taille des tuilles pour calculer la taille du joueur
+        if height < 0.86 * width:
+            width = height // 0.86
+        else:
+            height = round(width * 0.86)
+        return int(width) // 1.8
+
+    def tile_size(self):
+        """Renvoie la taille d'une tuille                       CECI EST UNE FONCTION TEST QUI POURRAS SUREMENT ETRE ENLEVEE"""
+        width = (WINDOW_WIDTH - NB_COL * GAP) // NB_COL
+        height = (WINDOW_HEIGHT - NB_ROW * GAP) // NB_ROW
+
+        #Réutilisation du calcul de la taille des tuilles pour calculer la taille du joueur
+        if height < 0.86 * width:
+            width = height // 0.86
+        else:
+            height = round(width * 0.86)
+        return int(width)
+
+    
+    

tiles.py

@@ -14,7 +14,11 @@ class Tile:
 
     def draw(self):
         """Affiche la tuile"""
-        image = pygame.transform.scale(HEXA, (self.width, self.height))
+        if self.tiletype == "seed" :
+            image = pygame.transform.scale(SEED, (self.width, self.height))
+        else :
+            image = pygame.transform.scale(HEXA, (self.width, self.height))
         self.display.blit(image, (self.x - self.width // 2, self.y - self.height // 2))
+
         
         

variables.py

@@ -15,6 +15,14 @@ GAP = 8
 
 # images
 HEXA = image.load(path.join("images/hexa.png"))
+SEED = image.load(path.join("images/seed.png"))
+
+PLAYER = image.load(path.join("images/player.png"))
+
+NEST = image.load(path.join("images/nest.png"))
+
+# tuile de base pour le personnage
+ORIGIN = 0
 
 # couleurs
 BACKGROUND_COLOR = (24, 40, 69)

world.py

@@ -1,5 +1,6 @@
 from tiles import *
 from variables import *
+from random import randint
 
 
 class World:
@@ -16,10 +17,16 @@ class World:
     def draw(self):
         """Dessine les tuiles du monde"""
         for pos in self.pos_list:
-            tile = Tile(pos["x"], pos["y"], self.tile_width, self.tile_height, "green", self.display)
+            tile = Tile(pos["x"], pos["y"], self.tile_width, self.tile_height, self.tile_type(), self.display)
             tile.draw()
 
 
+    def tile_type(self) -> str:
+        """Renvoie une chaine de caractère contenant 'green' ou 'seed' avec une probabilité respective de 80% et 20%"""
+        t_type = ["green", "green", "green", "green", "seed"]
+        return t_type[randint(0, 4)]
+            
+
     def tile_size(self) -> tuple:
         """Renvoie un tuple contenant la largeur et la hauteur d'une tuile en fonction du nombre de lignes, de colonnes, et de l'espacement entre le tuiles"""
         width = (WINDOW_WIDTH - self.nb_col * self.gap) // self.nb_col