Fin du projet (éventuelles améliorations a prévoir)

Lorenzo : - collisions avec les plateformes
                - conditions de victoire/défaite + texte de victoire/défaite
                - fonctions gravite/saut

Ayden : - apparition de plus de plateformes pour rendre le jeu possible avec un minimum de difficulté 
             - dessine les pieges

projetv2/projet.py

@@ -2,52 +2,86 @@
 Module basé sur une architecture MVC (modèle-vue-controleur) globale et également intégrée aux objets.
 '''
 #Importation
-import pyxel 
 import random
+import pyxel 
 #Constantes
 COULEUR_PERE_NOEL = 1 
 COULEUR_TIR = 10 
 COULEUR_ENNEMI = 8
 X1_SAPIN = 25
 Y1_SAPIN = 46
-X2_SAPIN = 38
+X2_SAPIN = 15
 Y2_SAPIN = 19
-X1_CADEAU1 = 14
+POSITION_PLATEFORME = [
-Y1_CADEAU1 = 110
+    [0,2,0,0,0,0,4],
-X2_CADEAU1 = 22
+    [3,1,1,0,4,1,1],
-Y2_CADEAU1 = 115
+    [1,0,0,1,1,3,3],
-POSITION_PLATEFORME = [[1,0,0,0,0,1,0,1,0,1],[1,1,1,0,1,0,1,0,1],[1,1,1,0,1,0,1,0,1]]
+    [1,1,0,1,0,0,0],
+    [3,3,1,0,0,4,0],
+    [0,0,0,1,0,1,3],
+    [0,0,0,0,1,0,0],
+    [4,0,0,1,3,3,0],
+    [1,1,1,3,1,1,1]
+    ]
 #Déclaration des classes
+"""class Projectile:
+    def __init__(self) -> None:
+        self.x = 20
+        self.y = 20
+        self.etat_projectile = 0
+        self.matrice_projectile = [[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0]]
+        self.range = 0
+    
+    def projectile(self) -> None:
+        self.etat_projectile = pyxel.count_frame // 60
+        if self.etat_projectile % 2 == 1 and self.range < 8:
+            print("test")
+            alea = random.randint(0,200)
+            self.range = self.range + 1 
+            self.matrice_projectile[self.range][0] = self.x
+            self.matrice_projectile[self.range][1] = alea
+        
+        if self.etat_projectile > 10:  
+            for i in range (0,self.range):
+                self.matrice_projectile[i][0] = self.matrice_projectile[i][0] + 1
+                pyxel.blt(self.matrice_projectile[i][0],self.matrice_projectile[i][1],0,0,24,7,7)"""
+        
+            
 class Plateforme:
     def __init__(self) -> None:
-        self.x = 14
+        self.x = 20
         self.y = 20
                     
     def afficher(self) -> None:
-        for colonne in range(2):
+        for colonne in range(9):
-            for ligne in range (9):
+            for ligne in range (7):
                 if POSITION_PLATEFORME[colonne][ligne] == 1:
-                    x = (self.x*(ligne+1))
+                    x = (self.x*(ligne))
-                    y = (self.y*(colonne+1))
+                    y = (self.y*(colonne))
-                    pyxel.blt(x,y,0,26,28,14,4)
+                    pyxel.blt(x,y,0,0,0,20,4)
+                elif POSITION_PLATEFORME[colonne][ligne] == 2:
+                    x = (self.x*(ligne))
+                    y = (self.y*(colonne))+4
+                    pyxel.blt(x,y,0,25,46,14,20)
+                elif POSITION_PLATEFORME[colonne][ligne] == 3:
+                    x = (self.x*(ligne))
+                    y = (self.y*(colonne))
+                    pyxel.blt(x,y,0,24,3,20,4)
+                elif POSITION_PLATEFORME[colonne][ligne] == 4:
+                    x = (self.x*(ligne))
+                    y = (self.y*(colonne))+13
+                    pyxel.blt(x,y,0,30,107,6,8)
+                    
         
-class Objet:
+
-    def __init__(self,x,y,x1,y1,x2,y2) -> None:
+    
-        self.x = x             # coordonnée x du coin haut à gauche du carré
-        self.y = y             # coordonnée y du coin haut à gauche du carré
-        self.x1 = x1
-        self.x2 = x2
-        self.y1 = y1
-        self.y2 = y2
-    def afficher(self:'Objet') -> None:
-        """Affichage des objets"""
-        pyxel.blt(self.x, self.y, 0, self.x1, self.y1, self.x2, self.y2)
 """Classe intégrant la gestion du Modèle et de la Vue relative au Perenoel du joueur."""  
 class Perenoel:
-    def __init__(self, couleur:int=COULEUR_PERE_NOEL) -> None:
+    def __init__(self) -> None:
-        self.x = 60             # coordonnée x du coin haut à gauche du carré
+        self.x = 20             # coordonnée x du coin haut à gauche du carré
-        self.y = 60             # coordonnée y du coin haut à gauche du carré
+        self.y = 100            # coordonnée y du coin haut à gauche du carré
-        self.couleur = couleur  # couleur du vaisseau à l'écran
+        self.a_gagner = False
+        self.etat = 0
     
     def set_x(self:'Perenoel', dx:int) -> None:
         """Déplace le Perenoel à gauche si dx positif, à droite si négatif"""
@@ -66,15 +100,26 @@ class Perenoel:
             self.y = 120
           
     def saut(self:'Perenoel'):
-        for i in range (1):
+        if POSITION_PLATEFORME[int((self.y+18)//20)][int((self.x+8)//20)] == 1:
-            if i<5:
+            self.set_y(-15)
-                self.set_y(-1)
-            else:
-                self.set_y(1)
     
     def gravite(self:'Perenoel'):
-        if self.y<80:
+        if POSITION_PLATEFORME[int((self.y+18)//20)][int((self.x+8)//20)] == 0:
-            self.set_y(1)
+            self.y = self.y + 1
+        elif POSITION_PLATEFORME[int((self.y+18)//20)][int((self.x+8)//20)] == 4:
+            self.y = self.y + 1
+        elif POSITION_PLATEFORME[int((self.y+18)//20)][int((self.x+8)//20)] == 3:
+            self.y = self.y + 1
+        
+            
+    def gagner(self:'Perenoel'):
+        if POSITION_PLATEFORME[int((self.y+18)//20)][int((self.x+8)//20)] == 2:
+            self.a_gagner = True
+    
+    def degats(self:'Perenoel',joueur:'Joueur'):
+        if POSITION_PLATEFORME[int((self.y+18)//20)][int((self.x+8)//20)] == 3:
+            degats_gen(joueur)
+            
     
     def get_coord(self:'Perenoel') -> tuple[int, int]:
         """Renvoie le couple (x, y) qui contient les coordonnées (du coin haut gauche) du Perenoel"""
@@ -82,8 +127,18 @@ class Perenoel:
     
     def afficher(self:'Perenoel') -> None:
         """Affiche le Perenoel"""
-        pyxel.blt(self.x, self.y, 0, 23, 68, 16, 25)
+        self.etat = pyxel.frame_count //15
+        if self.etat % 2 == 1:
+            pyxel.blt(self.x, self.y, 0, 23, 72, 16, 18)
+        else:
+            pyxel.blt(self.x, self.y, 0, 39, 72, 18, 17)
+
+            
         # (..., 0, 0, 0, 8, 8) car Image 0 à partir de (0;0) de taille 8*8)
+    
+
+        
+    
 """Classe intégrant la gestion du Modèle relative au joueur."""
 class Joueur: 
     
@@ -105,100 +160,62 @@ class Joueur:
         if self.vies < 0:
             self.vies = 0
             
-"""Classe intégrant la gestion du jeu."""
+    def afficher_vies(self):
-class Monstre:
+        vie = self.get_vies()
-    def __init__(self) -> None:
+        pyxel.text(0,190,"vie : "+str(vie),7)
-        self.x = 100             # coordonnée x du coin haut à gauche du carré
+        
-        self.y = 0             # coordonnée y du coin haut à gauche du carré 
-    
-    """def conditions_mouvements(self):
-        flag = 0
-        while flag == 0:
-            if self.x == 0:
-                flag = 1
-            self.set_x(-1)
-        while flag == 1:
-            if self.x == 50:
-                flag = 0
-            self.set_x(1)"""
             
-    def set_x(self:'Monstre', dx:int) -> None:
+"""Classe intégrant la gestion du jeu."""
-        """Déplace le zombie à gauche si dx positif, à droite si négatif"""
+
-        self.x = self.x + dx
-        if self.x < 0:
-            self.x = 0
-        elif self.x >= 120:
-            self.x = 120
-    
-    def set_y(self:'Monstre', dy:int) -> None:
-        """Déplace le Monstre en bas si dy positif, en haut si négatif"""
-        self.y = self.y + dy
-        if self.y < 0:
-            self.y = 0
-        elif self.y >= 120:
-            self.y = 120
-    
-    def get_coord(self:'Perenoel') -> tuple[int, int]:
-        """Renvoie le couple (x, y) qui contient les coordonnées (du coin haut gauche) du Perenoel"""
-        return (self.x, self.y)
-    
-    def afficher(self:'Perenoel') -> None:
-        """Affiche le Perenoel"""
-        pyxel.blt(self.x, self.y, 0, 10, 5, 21, 22)
-    
-    
-class Ennemi:
-    
-    def __init__(self, monstre:'Monstre', vies:int) -> None:
-        self.vies = vies
-        self.monstre = monstre
-    
-    def est_vivant(self:'Ennemi') -> bool:
-        return self.vies > 0
         
 class Jeu:
     
     def __init__(self) -> None:
     
         # Création de la fenêtre graphique
-        pyxel.init(128, 128, title="Nuit du c0de")
+        pyxel.init(140, 200, title="Pere noel du bled")
         pyxel.load("lorenzoxxxDark.pyxres")
+        pyxel.playm(0)
     
         # Initialisation des données du jeu
+        
         self.perenoel = Perenoel()
-        self.monstre = Monstre()
-        self.objet = Objet(115,0,X1_SAPIN, Y1_SAPIN, X2_SAPIN, Y2_SAPIN)
-        self.objet2 = Objet(80,80,X1_CADEAU1, Y1_CADEAU1, X2_CADEAU1, Y2_CADEAU1)
         self.plateforme = Plateforme()
-        self.joueur   = Joueur(self.perenoel, 4)  
+        self.joueur  = Joueur(self.perenoel, 1)
-        self.ennemi = Ennemi(self.monstre, 1)
+        #self.projectile = Projectile()
-        self.tirs = []        # Tableau des tirs
+    # Lancement de l'alternance 30x par seconde entre controleur et vue
-        self.ennemis = []     # Tableau des ennemis présents
-        self.explosions = []  # Tableau des explosions
-        
-    
-        # Lancement de l'alternance 30x par seconde entre controleur et vue
         pyxel.run(self.controler, self.afficher)
     
     
     
     def controler(self):
-        if pyxel.btn(pyxel.KEY_RIGHT):
+        if  self.joueur.est_vivant():
-            self.perenoel.set_x(1)
+            if pyxel.btn(pyxel.KEY_D):
-        if pyxel.btn(pyxel.KEY_LEFT):
+                self.perenoel.set_x(1)
-            self.perenoel.set_x(-1)
+            if pyxel.btn(pyxel.KEY_Q):
-        if pyxel.btn(pyxel.KEY_UP):
+                self.perenoel.set_x(-1)
-            self.perenoel.saut()
+            if pyxel.btn(pyxel.KEY_Z):
+                self.perenoel.saut()
         
     def afficher(self:'Jeu') -> None:
         pyxel.cls(4)
         self.perenoel.afficher()
-        self.monstre.afficher()
         self.plateforme.afficher()
-        #self.monstre.conditions_mouvements()
+        self.perenoel.gravite()
-        self.objet.afficher()
+        self.perenoel.degats(self.joueur)
-        self.objet2.afficher()
+        self.perenoel.gagner()
-        
+        self.joueur.afficher_vies()
-        
+        #self.projectile.projectile()
+        if self.perenoel.a_gagner:
+            pyxel.text(60,110,"Bravo :)",7)
+        elif not self.joueur.est_vivant():
+            pyxel.text(60,110,"Dommage :(",7)
+            
+            
         
+
+def degats_gen(joueur:'Joueur'):
+    joueur.perd_une_vie()
+    
+
 j = Jeu()