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.
279 lines
10 KiB
279 lines
10 KiB
# 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 |
|
|
|
|
|
|
|
|