eliot

manoire_07_12_23_fin-de_cour.py

@@ -0,0 +1,279 @@
+# Importation
+import random as rd
+import time
+# Déclaration des CONSTANTES
+
+# Déclaration Classes
+
+class Monstre :
+    
+    def __init__(self, nom, dsc, img=None, obj=None) -> None:
+        self.nom = nom
+        self.dsc = dsc
+        self.img = img
+        self.obj = obj
+        self.habilite = rd.randint(1,10)
+        self.endurance_max = 5
+        self.endurance = self.endurance_max
+        self.force = 2
+        self.courage = rd.randint(1,10)
+        self.objet = []
+        
+        if "Squelette" in self.nom:
+            self.habilite = rd.randint(1,10)
+            self.endurance = rd.randint(1,10)
+            self.force = rd.randint(1,2)
+            self.courage = rd.randint(1,10)
+        
+        if 'Chauve-souris' in self.nom:
+            self.habilite = rd.randint(1,3)
+            self.endurance = rd.randint(1,3)
+            self.force = 1
+            self.courage = 10
+            self.objet = ['clé cadena']
+            
+    def modifier_endurance(self:'Monstre', modificateur):
+        endurance_modifie = self.endurance + modificateur
+        if endurance_modifie < 0:
+            self.endurance = 0
+        elif endurance_modifie > self.endurance_max:
+            self.endurance = self.endurance_max
+        else:
+            self.endurance = endurance_modifie
+            
+    def subir_degats(self:'Monstre', degats:int) -> None:
+        if degats > 0:
+            self.modifier_endurance(-degats)
+            
+            
+    def get_description(self:'Monstre') -> str:
+        return self.dsc
+        
+    def get_carac(self:'Montres') -> str:
+        return f"{self.nom} H{self.habilite} E{self.endurance} F{self.force} C{self.courage}"
+            
+    def est_hs(self:'Monstre') -> bool:
+        if self.endurance <= 0:
+            return True
+        else:
+            return False
+class Personnage:
+    
+    def __init__(self, nom='Aucun'):
+        
+        self.nom = nom
+        
+        self.habilite = 5 + rd.randint(1,4)
+        self.endurance_max = 7 + rd.randint(1,8)
+        self.endurance = self.endurance_max
+        self.force = 2
+        self.charisme = rd.randint(1,10)
+        self.vigilance = rd.randint(1,10)
+        self.discretion = False
+        self.lieu = None
+        self.lieu_precedents = []
+        self.objet = []
+        
+    def modifier_endurance(self:'Personnage', modificateur):
+        endurance_modifie = self.endurance + modificateur
+        if endurance_modifie < 0:
+            self.endurance = 0
+        elif endurance_modifie > self.endurance_max:
+            self.endurance = self.endurance_max
+        else:
+            self.endurance = endurance_modifie
+            
+    def subir_degats(self:'Personnage', degats:int) -> None:
+        if degats > 0:
+            self.modifier_endurance(-degats)
+            
+    def est_hs(self:'Personnage') -> bool :
+        if self.endurance == 0:
+            return True
+        else:
+            return False
+        
+    def get_carac(self:'Personnage') -> str:
+        return f"{self.nom} H{self.habilite} E{self.endurance} F{self.force} C{self.charisme} V{self.vigilance}"
+        
+    def combattre(self:'Personnage', adversaire:'Monstre') -> tuple:
+        """
+        Effectue un combat entre le personnage et un monstre.
+        Parameters:
+        - self ('Personnage'): L'instance du personnage effectuant l'attaque.
+        - adversaire ('Monstre'): L'instance du monstre contre lequel le personnage se bat.
+        Returns:
+        - tuple: Un tuple contenant le code de résultat et la description du combat.
+        Code de Résultat :
+        - 'x': Le combat n'est pas encore terminé.
+        - 'MP': Les deux participants sont hors combat.
+        - 'P': Le personnage est hors combat.
+        - 'M': Le monstre est hors combat.
+        Description :
+        Le combat consiste en plusieurs étapes, où les scores de combat sont comparés, et des dégâts sont infligés en fonction du résultat.
+        Les participants peuvent également subir des dégâts critiques ou être hors combat.
+        """
+        score_personnage = rd.randint(1, 6) + rd.randint(1, 6) + self.habilite
+        score_monstre = rd.randint(1, 6) + rd.randint(1, 6) + adversaire.habilite
+        result_code = 'x'
+        
+        while result_code == 'x':
+            if score_personnage == score_monstre:
+                self.subir_degats(1)
+                adversaire.subir_degats(1)
+                result_code = "x"
+                result_desc = f"{self.nom} et {adversaire.nom} se blessent mutuellement."
+                time.sleep(1)
+                print(result_desc)
+            elif score_personnage > score_monstre:
+                adversaire.subir_degats(self.force)
+                result_code = "x"
+                result_desc = f"{self.nom} inflige {self.force} points de dégâts au {adversaire.nom}."
+                time.sleep(1)
+                print(result_desc)
+            else:
+                self.subir_degats(adversaire.force)
+                result_code = "x"
+                result_desc = f"{adversaire.nom} inflige {adversaire.force} points de dégâts au {self.nom}."
+                time.sleep(0.5)
+                print(result_desc)
+            if rd.randint(1, 6) == rd.randint(1, 6):
+                double_damage = self.force * 2
+                adversaire.subir_degats(double_damage)
+                result_desc += f" Coup critique ! {self.nom} inflige {double_damage} points de dégâts supplémentaires au {adversaire.nom}."
+                time.sleep(0.5)
+                print(result_desc)
+            elif self.est_hs() and adversaire.est_hs():
+                result_code = "MP"
+                result_desc = f"{self.nom} et {adversaire.nom} sont tous les deux hors combat."
+                time.sleep(0.5)
+                print(result_desc)
+            elif self.est_hs():
+                result_code = "P"
+                result_desc = f"{self.nom} est hors combat."
+            elif adversaire.est_hs():
+                result_code = "M"
+                result_desc = f"{adversaire.nom} est hors combat."
+                time.sleep(0.5)
+                print(result_desc)
+                
+        return result_code, result_desc
+            
+    def observer(self:'Personnage') -> str:
+        if self.lieu:
+            return self.lieu.decrire_lieu()
+        
+        
+    def reflechir(self:'Personnage') -> str:
+        if self.lieu:
+            return self.lieu.decrire_actions_possibles()
+
+
+    def combattre_monstre_actuel(self:'Personnage') -> tuple:
+        if self.lieu and self.lieu.occupant:
+            resultat = self.combattre(self.lieu.occupant)
+            
+
+class Lieu:
+    
+    def __init__(self, nom, dsc, img=None) -> None:
+        self.nom = nom
+        self.dsc = dsc
+        self.image = None
+        self.nord = None
+        self.sud = None
+        self.est = None
+        self.ouest = None
+        self.occupant = None
+        self.objets = []
+        self.action_supp = None          
+            
+            
+    def decrire_lieu(self):
+        """Renvoie une description de la salle et le monstre éventuellement présent
+     
+        :: param self(Lieu) :: une instance de Lieu
+        :: return (str)     :: un string contenant la description globale
+     
+        """
+        reponse = self.dsc
+        
+        if self.occupant:  # cela veut dire si self.occupant existe (n'est pas 0, vide ou None)
+            reponse = reponse + f" \nLa salle contient également un(e) {self.occupant.nom} : {self.occupant.get_description()}"
+        return reponse
+
+    def decrire_actions_possibles(self:'Lieu') -> str:
+        """Renvoie un string de toutes les actions possibles"""
+        actions_possibles = ""
+        if self.occupant:
+            actions_possibles =+ "C : Combattre"
+            actions_possibles =+ "F : Fuire"
+        if self.objets:
+            actions_possibles =+ "R : Ramasser"
+        if self.nord:
+            actions_possibles =+ "Z : Porte Nord"
+        if self.sud:
+            actions_possibles =+ "S : Porte Sud"
+        if self.ouest:
+            actions_possibles =+ "D : Porte Ouest"
+        if self.est:
+            actions_possibles =+ "Q : Porte Est"
+        if self.objet:
+            actions_possibles =+ "U : utiliser objet"
+            
+    def set_occupant(self:'Lieu', occupant:'None|Monstre|Personnage') -> bool:
+        '''Cette méthode permet de mettre en place un occupant dasn un lieu'''
+        if not self.occupant or occupant.est_hs():
+            self.occupant = occupant
+            
+
+    def ouvrir(self:'Personnage', lieu:'Lieu'):
+        '''permet de verifier si on a un objet dans l'inventaire pour ouvrir'''
+        if self.objet == 'clé cadena':
+            entree.nord = couloire_sud
+            couloire_sud.sud = entree
+        
+        
+        
+        
+    
+# Déclaration de Fonctions     
+            
+
+
+# Le corps du module en lui-même
+
+
+if __name__ == '__main__':
+    # personnage
+    h = Personnage("Alice")
+    # monstre
+    S = Monstre("Squelette", "")
+    C = Monstre("Chauve-souris", "")
+    # lieu
+    entree = Lieu("Entrée", "Une entrée délabrée et poussiéreuse. Une porte entrouverte se trouve à l'ouest. Une porte verouillée avec un cadena au nord et une petite salle a l'est.")
+    garage = Lieu("Garage", "Un garage sans dessus-dessous avec une chauve-souris qui a une clé entre ses griffes. Une porte mène à l'est vers l'Entrée")
+    vestibule = Lieu("Vestibule", "Une petite pièce dans la quelle est entreposée une armure rouillée. aller vers l'ouest pour retourner dans l'Entrée.")
+    couloire_sud = Lieu("Couloire Sud","")
+    chambre_du_gardien = Lieu("Chambre du gardien", "")
+    toilette_usagée = Lieu("Toilette usagée", "Peuve toujours servir")
+    Hub = Lieu("Jardin couvert", "")
+    couloire_nord = Lieu("Couloire Nord","")
+    couloire_est = Lieu("Couloire Est","")
+    couloire_ouest = Lieu("Couloire Ouest","")
+    cuisine = Lieu("Cuisine","")
+    picine = Lieu("Picine","Zone de boss")
+    salle_arcade = Lieu("Salle d'arcade","")
+    bureau = Lieu("Bureau","")
+    salle_NSI = Lieu("Salle de NSI","Zone de bossssss... !!!!!")
+    
+    entree.ouest = garage
+    entree.est = vestibule
+    garage.est = entree
+    garage.objet = ['cle cadena']
+    garage.occupant = C
+    vestibule.objet = ['Armure rouillée (+2 EnduranceMax)']
+    vestibule.ouest = entree
+    
+
+