You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
442 lines
16 KiB
442 lines
16 KiB
# 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)
|
|
|