Haunted_Mansion/donnees.py

# Importations

import random as rd

#Déclaration de constantes

#Déclaration de classe
class Monstre :
    def    __init__(self, nom, dsc = None , img = None, obj = None) -> None :
        self.nom = nom
        self.dsc = dsc
        self.img = img
        self.obj = obj
        if "Squelette" in nom :
            self.habilite = 5
            self.endu = 4   
        else :
            self.habilite = rd.randint(1, 10)
            self.endu = rd.randint(1, 10)
            
        self.force = 2
        self.courage = 7
        
        
    def get_description(self : 'Monstre') -> str :
        return str(self.dsc)
        
    def get_carac(self : 'Monstre') -> str :
         return (f"{self.nom}, H{self.habilite}, E{self.endu},  F{self.force},  C{self.courage}")

    def subir_degats(self:'Monstre', degats : int) -> None :
        if degats > 0 :
            self.endu = self.endu - degats
            if self.endu < 0 :
                self.endu = 0
        return None
    
    def est_hs(self: 'Monstre') -> 'bool' :
        return self.endu <= 0
    
        
    
class Personnage :
    def __init__(self , nom) -> None :
        self.nom = nom
        self.habilite = rd.randint(6, 9) // 5 + rd. randint(1,4)
        self.endu = rd.randint(8,15) // 7 + rd.randint(1,8)
        self.objet = "Rien"
        if "arme" in self.objet :
            self.force = 3
        else :
            self.force = 2
        self.charisme = rd.randint(1,10)
        self.vigilance = rd.randint(1,10)
        self.discretion = rd.randint(1,10)
        self.lieu = None
        self.lieux_precedents = []
    def get_carac(self : 'Personnage') -> str :
        return (f"{self.nom}, H{self.habilite}, E{self.endu},  F{self.force},  C{self.charisme}, V {self.vigilance}, Objet {self.objet}")
        
    def subir_degats(self:'Personnage', degats : int) -> None :
        if degats > 0 :
            self.endu = self.endu - degats
            if self.endu < 0 :
                self.endu = 0
        return None
    
    def est_hs(self: 'Personnage') -> 'bool' :
        return self.endu <= 0
    
    def combattre(self:'Personnage', adversaire : 'Monstre') -> tuple :
        '''Gére le déroulement du combat et la mort d'un des combattants'''
        cbt = [None,None]
        
        if adversaire.est_hs() and self.est_hs():
            cbt[0] = 'MP'
        
        elif self.est_hs() :
            cbt[0] = 'P'
            
            
        elif adversaire.est_hs() :
            cbt[0] = 'M'
            self.lieu.set_occupant(None)
            
            
        elif adversaire.est_hs() and self.est_hs():
            cbt[0] = 'MP'
            self.lieu.set_occupant(None)
        else :
            res = 'X'
        print(f'{cbt[0]} est HS')
        
        sc_att = rd.randint(1,6) + rd.randint(1,6) + self.habilite
        print(f'{self.nom} fait un score de {sc_att}')
        sc_def = rd.randint(1,6) + rd.randint(1,6) + adversaire.habilite
        print(f'{adversaire.nom} fait un score de {sc_def}')
        if sc_att > sc_def :
            adversaire.subir_degats(self.force)
            cbt[1] = f'{adversaire.nom} subit {adversaire.force} points de dégats'
        elif sc_att < sc_def :
            self.subir_degats(adversaire.force)
            cbt[1] = f'{self.nom} subit {adversaire.force} points de dégats'
            print(cbt[1])
        else :
            self.subir_degats(1)
            adversaire.subir_degats(1)
            cbt[1] = f'Pesrsonne ne parviens a prendre le dessus'
            print(cbt[1])
            
        return tuple(cbt)
    
    def combattre_monstre_actuel(self:'Personnage') -> tuple :
        '''lance un combat entre le personnage et l'occupant de la salle'''
            
        if self.lieu.occupant :
            while self.combattre(self.lieu.occupant)[0] == None:
                return self.combattre(self.lieu.occupant)
        
    def soigner(self:'Personnage', soins :'int') -> None :
        if soins > 0 :
            self.endu = self.endu + soins
        else :
            return None
        if self.endu > 24 :
            self.endu = 24
        return None
    
    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 aller_nord(self:'Personnage') -> bool :
        if self.lieu.nord :
            self.lieux_precedents.append(self.lieu.nord)
            self.lieu = self.lieu.nord
            
        return self.lieu.nord == None
    
    def aller_sud(self:'Personnage') -> bool :
        if self.lieu.sud :
            self.lieux_precedents.append(self.lieu.sud)
            self.lieu = self.lieu.sud
            
        return self.lieu.sud == None
    
    
    def aller_ouest(self:'Personnage') -> bool :
        if self.lieu.ouest :
            self.lieux_precedents.append(self.lieu.ouest)
            self.lieu = self.lieu.ouest
            
        return self.lieu.ouest == None
    
    def aller_est(self:'Personnage') -> bool :
        if self.lieu.est :
            self.lieux_precedents.append(self.lieu.est)
            self.lieu = self.lieu.est
            
        return self.lieu.est == None
            
            
class Lieu :
    def __init__(self, nom, dsc, img=None) :
        self.nom = nom
        self.dsc = dsc
        self.img = img
        self.nord = None
        self.sud = None
        self.ouest = None
        self.est = 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 = ""
        reponse = reponse + f'{self.dsc}'	# récupérer la description de la salle "vide"...
     
        # ... et ce code permet d'y rajouter la description du monstre éventuel ...
        if self.occupant:  # cela veut dire si self.occupant existe (n'est pas 0, vide ou None)
            reponse = reponse + f"\n La salle contient également : {self.occupant.get_description()}"
        return reponse
    
    def decrire_actions_possibles(self:'Lieu') -> str :
        if self.occupant != None :
            return(f" vous pouvez attaquer l'ennemi avec C ou fuir avec F " )
        if self.objets != [] :
            print(f'\n appuyez sur E pour ramasser {self.objets}')
        
        
        
        ''' Bloc qui sert uniquement a identifier les issues de la salle
        et déterminer quel message est approprié '''
        
        
        # Cas ou au moins 3 salles sont accessibles
        if self.nord != None and self.ouest != None and self.est != None and self.sud != None :
            return(f'vous pouvez aller dans N {self.nord.nom}  O{self.ouest.nom} E{self.est.nom} S{self.sud.nom}')
        elif self.nord == None and self.ouest != None and self.est != None and self.sud != None :
            return(f'vous pouvez aller dans O{self.ouest.nom} E{self.est.nom} S{self.sud.nom}')
        elif self.nord != None and self.ouest == None and self.est != None and self.sud != None :
            return(f'vous pouvez aller dans N {self.nord.nom} E{self.est.nom} S{self.sud.nom}')
        elif self.nord != None and self.ouest != None and self.est == None and self.sud != None :
            return(f'vous pouvez aller dans N {self.nord.nom}  O{self.ouest.nom} S{self.sud.nom}')
        elif self.nord != None and self.ouest != None and self.est != None and self.sud == None :
            return(f'vous pouvez aller dans N {self.nord.nom}  O{self.ouest.nom} E{self.est.nom} ')
        
        # cas ou seulement deux salles sont accessibles
        
        # Nord + ... bloqué 
        elif self.nord == None and self.ouest == None and self.est != None and self.sud != None :
            return(f'vous pouvez aller dans E {self.est.nom} S {self.sud.nom}')
        elif self.nord == None and self.ouest != None and self.est == None and self.sud != None :
            return(f'vous pouvez aller dans O {self.ouest.nom} S {self.sud.nom}')
        elif self.nord == None and self.ouest != None and self.est != None and self.sud == None :
            return(f'vous pouvez aller dans O {self.ouest.nom} E {self.est.nom} ')
        # Ouest + ... bloqué
        elif self.nord != None and self.ouest == None and self.est == None and self.sud != None :
            return(f'vous pouvez aller dans N {self.nord.nom} S {self.sud.nom}')
        
        elif self.nord != None and self.ouest == None and self.est != None and self.sud == None :
            return(f'vous pouvez aller dans N {self.nord.nom} E {self.est.nom}')
        # Est + ... bloqué
        elif self.nord != None and self.ouest != None and self.est == None and self.sud == None :
            return(f'vous pouvez aller dans N {self.nord.nom} O {self.ouest.nom}')
        
        # cas ou une seule salle est disponible
        elif self.nord != None and self.ouest == None and self.est == None and self.sud == None :
            return(f'vous pouvez aller dans N {self.nord.nom}')
        elif self.nord == None and self.ouest != None and self.est == None and self.sud == None :
            return(f'vous pouvez aller dans O {self.ouest.nom}')        
        elif self.nord == None and self.ouest == None and self.est != None and self.sud == None :
            return(f'vous pouvez aller dans E {self.est.nom}')
        elif self.nord == None and self.ouest == None and self.est == None and self.sud != None :
            return(f'vous pouvez aller dans S {self.sud.nom}')

        
        # cas ou rien n'est accessible
        elif self.nord == None and self.ouest == None and self.est == None and self.sud == None :
            return("vous êtes piégés")
    
    
    
    
    def set_occupant(self:'Lieu', occupant:'None|Monstre|Personnage') -> bool :
        if self.occupant != None and occupant == None :
            self.occupant = None
        elif not self.occupant == None :
            return False
        else :
            self.occupant = occupant
        return True
    
    
class Manoir:
 
    def __init__(self):
 
        self.heros = None
        self.depart = None
        self.lieux = []
        self.monstres = []
 

 
        
    
# Déclaration de fonctions


def peupler_manoir():
 
    # Création du personnage du joueur 
    aventurier = Personnage("Alice")
 
    # Création et agencement des lieux   
    des = '''Vous êtes devant l'entrée qui mène au nord. Une solide porte en bois est entreouverte'''
    exterieur = Lieu("Entrée", des, "manoir.jpg")
 
    des = "Vous êtes dans le hall d'entrée du manoir."
    hall = Lieu("Hall", des, "hall.jpeg")
 
    exterieur.nord = hall
    hall.sud = exterieur
 
    # Création et positionnement d'un monstre
    squelette_1 = Monstre("Squelette", "Un squelette semblant bouger seul et muni d'une épée.", "squelette.png")
    hall.set_occupant(squelette_1)
 
    # Affectation d'un lieu de départ à l'aventurier
    aventurier.lieu = exterieur
 
    # Création du manoir  
    manoir = Manoir()
    manoir.heros = aventurier
    manoir.depart = aventurier.lieu
    manoir.lieux.append(exterieur)
    manoir.lieux.append(hall)
    manoir.monstres.append(squelette_1)
 
    return manoir



# Programme principal
if __name__ == '__main__':
    m = peupler_manoir()