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.
463 lines
18 KiB
463 lines
18 KiB
# Importation |
|
import random as rd |
|
import time |
|
from PIL import Image |
|
# 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 = 15 |
|
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,7) |
|
self.endurance = rd.randint(1,4) |
|
self.force = rd.randint(1,2) |
|
self.courage = rd.randint(1,10) |
|
self.img = "squelette.jpg" |
|
|
|
if 'Chauve-souris' in self.nom: |
|
self.habilite = 1 |
|
self.endurance = 1 |
|
self.force = 1 |
|
self.courage = 1 |
|
self.objet = ['clé cadena'] |
|
self.img = "chauve-souris.jpg" |
|
|
|
if 'Limace-geante' in self.nom: |
|
self.habilite = 1 |
|
self.endurance = 7 |
|
self.force = 1 |
|
self.courage = 10 |
|
self.img = "limace.jpg" |
|
|
|
if 'Zombie' in self.nom: |
|
self.habilite = rd.randint(1,4) |
|
self.endurance = 7 |
|
self.force = 1 |
|
self.courage = 8 |
|
self.img = "zombie.jpg" |
|
|
|
if 'Zombie_sur_poulet'in self.nom: |
|
self.habilite = rd.randint(4,7) |
|
self.endurance = 4 |
|
self.force = 2 |
|
self.courage = 8 |
|
self.img = "zombie-poulet.jpg" |
|
|
|
if 'Hydra' in self.nom: |
|
self.habilite = rd.randint(8,10) |
|
self.endurance = 10 |
|
self.force = 3 |
|
self.courage = 10 |
|
self.img = "hydra.jpg" |
|
|
|
if 'Poutine' in self.nom: |
|
self.habilite = 10 |
|
self.endurance = 12 |
|
self.force = 4 |
|
self.courage = 10 |
|
self.image = "poutine.jpg" |
|
|
|
|
|
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.lieux_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) |
|
if result_code == "M" : |
|
self.objet.append(adversaire.objet[0]) |
|
|
|
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(self) |
|
|
|
|
|
def combattre_monstre_actuel(self): |
|
rep = self.combattre(self.lieu.occupant) |
|
if self.lieu.occupant.est_hs(): |
|
self.lieu.set_occupant(None) |
|
return rep |
|
|
|
def aller_nord(self): |
|
#print("Tentative de déplacement vers le nord...") |
|
#print("Lieu actuel:", self.lieu.nom) |
|
if self.lieu.nord and (not self.lieu.occupant or self.lieu.occupant.est_hs()): |
|
print("Conditions pour le déplacement vers le nord remplies.") |
|
self.lieux_precedents.append(self.lieu) |
|
self.lieu = self.lieu.nord |
|
print("Nouveau lieu:", self.lieu.nom) |
|
return True |
|
else: |
|
#print("Impossible de se déplacer vers le nord.") |
|
return False |
|
|
|
def aller_sud(self): |
|
if self.lieu.sud and (not self.lieu.occupant or self.lieu.occupant.est_hs()): |
|
self.lieux_precedents.append(self.lieu) |
|
self.lieu = self.lieu.sud |
|
return True |
|
else: |
|
return False |
|
|
|
def aller_ouest(self): |
|
if self.lieu.ouest and (not self.lieu.occupant or self.lieu.occupant.est_hs()): |
|
self.lieux_precedents.append(self.lieu) |
|
self.lieu = self.lieu.ouest |
|
return True |
|
else: |
|
return False |
|
|
|
def aller_est(self): |
|
if self.lieu.est and (not self.lieu.occupant or self.lieu.occupant.est_hs()): |
|
self.lieux_precedents.append(self.lieu) |
|
self.lieu = self.lieu.est |
|
return True |
|
else: |
|
return False |
|
|
|
def fuire(self): |
|
self.lieux_precedents.append(self.lieu) |
|
self.lieu = self.lieux_precedents[-2] |
|
return True |
|
|
|
def ouvrir(self, manoir): |
|
if 'clé cadena' in self.objet: |
|
if self.lieu == manoir.depart: |
|
manoir.depart.nord = manoir.lieux[3] |
|
manoir.lieux[3].sud = manoir.depart |
|
self.objet.remove('clé cadena') |
|
print("Vous avez ouvert la porte avec la clé cadena!") |
|
return True |
|
else: |
|
print("Vous ne pouvez pas utiliser la clé cadena ici.") |
|
return False |
|
elif "Croc d'Hydra" in self.objet: |
|
if "Cuisine" in manoir.lieux: |
|
manoir.lieux[10].ouest = manoir.lieux[11] |
|
self.objet.remove("Croc d'Hydra") |
|
print("Vous avez utilisé le Croc d'Hydra pour ouvrir un passage vers la Piscine!") |
|
return True |
|
else: |
|
print("Vous ne pouvez pas utiliser le Croc d'Hydra ici.") |
|
return False |
|
elif 'Bouteille de vodka' in self.objet: |
|
if "Salle NSI" in manoir.lieux: |
|
manoir.lieux[14].ouest = manoir.lieux[12] |
|
self.objet.remove('Bouteille de vodka') |
|
print("Vous avez utilisé la Bouteille de vodka pour ouvrir un passage vers la Salle d'arcade!") |
|
return True |
|
else: |
|
print("Vous ne pouvez pas utiliser la Bouteille de vodka ici.") |
|
return False |
|
else: |
|
print("Vous n'avez pas d'objet pour ouvrir quoi que ce soit.") |
|
return False |
|
|
|
|
|
|
|
|
|
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.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', heros:'Personnage') -> 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 heros.objet: |
|
actions_possibles += "U: utiliser objet " |
|
|
|
return actions_possibles |
|
|
|
def set_occupant(self: 'Lieu', occupant: 'None|Monstre|Personnage') -> bool: |
|
'''Cette méthode permet de mettre en place un occupant dans un lieu''' |
|
if not self.occupant or (occupant and occupant.est_hs()): |
|
self.occupant = occupant |
|
return True |
|
return False |
|
|
|
|
|
|
|
|
|
|
|
class Manoir: |
|
|
|
def __init__(self): |
|
|
|
self.heros = None |
|
self.depart = None |
|
self.lieux = [] |
|
self.monstres = [] |
|
|
|
def peupler_manoir(): |
|
|
|
# Création et agencement des lieux |
|
|
|
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.", "entree.jpg") |
|
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", "garage.jpg") |
|
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.", "vestibule.jpg") |
|
couloire_sud = Lieu("Couloire Sud","Un long couloir sombre et étroit qui s'étend vers le sud. Les murs sont décrépits, et il y a une faible lueur provenant d'une ampoule vacillante au plafond.", "couloir.jpg") |
|
chambre_du_gardien = Lieu("Chambre du gardien", " Une chambre poussiéreuse qui semble avoir appartenu à un gardien. Un lit défait, une vieille chaise et une étagère avec des livres usés occupent l'espace. Une fenêtre cassée laisse filtrer la lumière extérieure.", "chambre_gardien.jpg") |
|
toilette_usagée = Lieu("Toilette usagée", "Peuve toujours servir mais à vos risques", "toilette.jpg") |
|
Hub = Lieu("Jardin couvert", "Un espace central où convergent plusieurs couloirs. Un jardin intérieur avec des plantes négligées, des bancs en bois cassés et un petit bassin. Des portes mènent vers différentes parties de l'endroit.", "hub.jpg") |
|
couloire_nord = Lieu("Couloire Nord","Un couloir obscur qui s'étend vers le nord. Le son lointain de gouttes d'eau résonne, et des portes menant à d'autres zones de l'endroit sont visibles.", "couloir.jpg") |
|
couloire_est = Lieu("Couloire Est","Un couloir délabré orienté vers l'est. Des traces de moisissure s'accrochent aux murs, et des bruits étouffés provenant de salles adjacentes donnent une atmosphère mystérieuse.", "couloir.jpg") |
|
couloire_ouest = Lieu("Couloire Ouest","Un couloir sombre s'étirant vers l'ouest. Des portes fermées jalonnent les côtés, et des murmures indistincts peuvent être entendus au loin.", "couloir.jpg") |
|
cuisine = Lieu("Cuisine"," Une cuisine abandonnée avec des ustensiles rouillés et des étagères vides. Une odeur étrange flotte dans l'air, et une porte menant à une autre pièce est entrebâillée.", "cuisine.jpg") |
|
picine = Lieu("Picine","Zone de boss (hydraaaaaa)", "piscine.jpg") |
|
salle_arcade = Lieu("Salle d'arcade","Une salle remplie de vieux jeux d'arcade. Les lumières clignotent faiblement, et le son lointain des machines crée une atmosphère nostalgique.", "salle_arcade.jpg") |
|
bureau = Lieu("Bureau","Un bureau désordonné avec des piles de papiers et une vieille machine à écrire. Des étagères pleines de livres poussiéreux et des fenêtres sales complètent l'ambiance de cet endroit oublié.", "bureau.jpg") |
|
salle_NSI = Lieu("Salle de NSI","Zone de bossssss... !!!!! Un GRAND Poutine débarque...", "salle NSI.jpg") |
|
|
|
entree.ouest = garage |
|
entree.est = vestibule |
|
garage.est = entree |
|
garage.occupant = Monstre("Chauve-souris", "") |
|
vestibule.ouest = entree |
|
couloire_sud.nord = Hub |
|
couloire_sud.ouest = chambre_du_gardien |
|
couloire_sud.est = toilette_usagée |
|
chambre_du_gardien.est = couloire_sud |
|
chambre_du_gardien.occupant = Monstre("Squelette", "") |
|
toilette_usagée.ouest = couloire_sud |
|
Hub.sud = couloire_sud |
|
Hub.est = couloire_est |
|
Hub.ouest = couloire_ouest |
|
Hub.nord = couloire_nord |
|
couloire_ouest.ouest = cuisine |
|
couloire_ouest.est = Hub |
|
cuisine.est = couloire_ouest |
|
cuisine.ouest = picine |
|
cuisine.occupant = Monstre("Limace-geante","") |
|
picine.occupant = Monstre("Hydra","") |
|
couloire_est.ouest = Hub |
|
couloire_est.est = salle_arcade |
|
couloire_est.occupant = Monstre("Zombie","") |
|
salle_arcade.ouest = couloire_est |
|
salle_arcade.nord = bureau |
|
salle_arcade.est = salle_NSI |
|
salle_arcade.occupant = Monstre("Zombie_sur_poulet","") |
|
bureau.sud = salle_arcade |
|
bureau.occupant = Monstre("Pikachu","") |
|
|
|
# Création du personnage du joueur |
|
aventurier = Personnage("Alice") |
|
aventurier.lieu = entree |
|
|
|
# Création du manoir |
|
manoir = Manoir() |
|
manoir.heros = aventurier |
|
manoir.depart = aventurier.lieu |
|
manoir.lieux.append(entree) |
|
manoir.lieux.append(garage) |
|
manoir.lieux.append(vestibule) |
|
manoir.lieux.append(couloire_sud) |
|
manoir.lieux.append(chambre_du_gardien) |
|
manoir.lieux.append(toilette_usagée) |
|
manoir.lieux.append(Hub) |
|
manoir.lieux.append(couloire_nord) |
|
manoir.lieux.append(couloire_est) |
|
manoir.lieux.append(couloire_ouest) |
|
manoir.lieux.append(cuisine) |
|
manoir.lieux.append(picine) |
|
manoir.lieux.append(salle_arcade) |
|
manoir.lieux.append(bureau) |
|
manoir.lieux.append(salle_NSI) |
|
|
|
manoir.monstres.append("Squelette") |
|
manoir.monstres.append("Chauve-souris") |
|
manoir.monstres.append("Limace-geante") |
|
manoir.monstres.append("Zombie") |
|
manoir.monstres.append("Zombie_sur_poulet") |
|
manoir.monstres.append("Hydra") |
|
manoir.monstres.append("Poutine") |
|
|
|
return manoir |
|
|
|
|
|
|
|
|
|
|
|
# Déclaration de Fonctions |
|
|
|
|
|
|
|
# Le corps du module en lui-même |
|
|
|
|
|
if __name__ == '__main__': |
|
m = peupler_manoir() |