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.
227 lines
8.0 KiB
227 lines
8.0 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) |
|
|
|
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) |
|
|
|
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 = None |
|
|
|
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 |
|
|
|
|
|
|
|
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" |
|
|
|
|
|
def set_occupant(self:'Lieu', occupant:'None|Monstre|Personnage') -> bool: |
|
pass |
|
|
|
|
|
# Déclaration de Fonctions |
|
|
|
|
|
|
|
|
|
|
|
|
|
# Le corps du module en lui-même |
|
|
|
|
|
if __name__ == '__main__': |
|
# personnage |
|
h = Personnage("Alice") |
|
# monstre |
|
p = Monstre("Squelette", "bonsoir") |
|
# 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") |
|
cuisine = Lieu("Cuisine", "Tout est très bien rangé dans cette cuisine. Un étrange plat mijote sur le feu. Une porte mène à l'ouest.") |
|
|
|
|
|
|
|
|