Haunted_Mansion/Manoir_hanté_données.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:
                controls(self)
                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.occupant :
            action_spe(self)
        elif 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
            controls(self)
            
        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
            controls(self)
            
        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
            controls(self)
            
        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
            controls(self)
            
        return self.lieu.est == None
    
    
    def fuite(self:'Personnage') -> bool :
        if self.lieux_precedents[-2] :
            self.lieu = self.lieux_precedents[-2]
        controls(self)
        return self.lieux_precedents[-2] == None
    
    def infiltration(self:'Personnage') -> bool :
        if self.lieu.occupant == None :
            print("pas de raison se se cacher")
        else :
            hm = self.lieu.occupant.habilite
            hp = self.habilite
            if hm > hp :
                print("il vous a trouvé")
                self.combattre_monstre_actuel()
            else :
                print("le monstre quitte la salle")
                self.lieu.occupant == None
                controls(self)
            
            return hm > hp
            
        
        
            
            
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")
    
    des = "Une grande cuisine délabrée, la nourriture laissée a pourir"
    cuisine = Lieu("Cuisine",des)
    
    des = "Une chambre froide avec de nombreux crochets au plafond, pour la nourriture... certainement"
    frigo = Lieu("Salle_réfrigérée",des)
    
    des = "Un escalier... ce serait dommage de tomber"
    escalier = Lieu("Escalier", des)
    
    des = "Le couloir du 1er étage du manoir"
    couloir = Lieu("Couloir", des)
    
    des = "Une salle de bain mal entretenue"
    bains = Lieu("Bains", des)
    
    des = " Un bureau, une machine à écrire, quelques tableaux aux murs... pas intéressant"
    bureau = Lieu("Bains", des)
    
    des = "Certainement la chambre du maitre des lieux"
    chambre = Lieu("Chambre",des)
    
    
    exterieur.nord = hall
    hall.sud = exterieur
    hall.nord = escalier
    hall.ouest = cuisine
    cuisine.nord = frigo
    escalier.nord = couloir
    couloir.ouest = bains
    couloir.est = bureau
    couloir.nord
    
    
 
    # Création et positionnement des monstres
    squelette_1 = Monstre("Squelette", "Un squelette semblant bouger seul et muni d'une épée.", "squelette.png")
    hall.set_occupant(squelette_1)
    squelette_2 = Monstre("Squelette, encore", "Un squelette a peu prés normal mis a part le fait qu'il bouge et qu'il brandisse une épée", "squelette.png")
    couloir.set_occupant(squelette_2)
    boucher = Monstre("Le Cochon","Un homme énorme avec un masque de cochon et une hachette")
    frigo.set_occupant(boucher)
    # 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.lieux.append(escalier)
    manoir.lieux.append(cuisine)
    manoir.lieux.append(frigo)
    manoir.lieux.append(couloir)
    manoir.lieux.append(bains)
    manoir.lieux.append(bureau)
    manoir.lieux.append(chambre)
    manoir.monstres.append(squelette_1)
    manoir.monstres.append(squelette_2)
    manoir.monstres.append(boucher)
    

    return manoir


    ''' Ce qui suit est une interface improvisée
        afin de rendre le jeu fonctonnel sans tkinter et Pillow '''

def controls(perso : "le personnage joueur") -> None :

    # Dépacement du peronnage joueur
    cap = input("où souhaitez vous aller ?")
    if cap == "N" or cap =="n" :
        perso.aller_nord()
    elif cap == "O" or cap == "o":
        perso.aller_ouest()
    elif cap == "E" or cap == "e":
        perso.aller_est()
    elif cap == "S "or cap == "s" :
        perso.aller_sud()
    elif cap == "x" or cap == "X" :
        print(perso.observer())
        controls(perso)
    elif cap == "r" or cap == "R" :
        action_spe(perso)
        
    # input imprévu du joueur
    else :
        print("cette action est impossible")
        controls(perso)
        
        
        
def action_spe(perso : "le personnage joueur") :
    act = input("que voulez vous faire ?")
    if act == "c" or act == "C" :
        perso.combattre_monstre_actuel()
    if act == "d" or act == "D" :
        perso.infiltration()
    if act == "f" or act == "F" :
        perso.fuite()
        
    # input imprévu du joueur
    else :
        print("cette action est impossible")
        



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