def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_cible = self.a_interpreter
persos = personnage.salle.personnages
objets = []
cibles = []
for o in personnage.salle.objets_sol:
objets.append(o)
for o in personnage.equipement.tenus:
objets.append(o)
for p in persos:
if p is not personnage and contient(
p.get_nom_pour(personnage), nom_cible):
cibles.append(p)
for o in objets:
if contient(o.nom_singulier, nom_cible):
cibles.append(o)
if not cibles:
raise ErreurValidation("|err|Cette cible est introuvable.|ff|")
self.cibles = cibles
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_cible = self.a_interpreter
persos = personnage.salle.personnages
objets = []
cibles = []
for o in personnage.salle.objets_sol:
objets.append(o)
for o in personnage.equipement.tenus:
objets.append(o)
for p in persos:
if p is not personnage and contient(p.get_nom_pour(personnage),
nom_cible):
cibles.append(p)
for o in objets:
if contient(o.nom_singulier, nom_cible):
cibles.append(o)
if not cibles:
raise ErreurValidation("|err|Cette cible est introuvable.|ff|")
self.cibles = cibles
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
cale = salle.navire.cale
for objet, nombre in cale.conteneur.iter_nombres():
if contient(objet.get_nom(nombre), nom):
self.objets.append(objet)
for conteneur in cale.conteneurs.values():
for cle in conteneur.keys():
try:
prototype = importeur.objet.prototypes[cle]
except KeyError:
continue
if contient(prototype.nom_singulier, nom) or contient(
prototype.nom_pluriel, nom):
self.prototype = prototype
return True
if not self.objets:
raise ErreurValidation("Cet objet n'est pas trouvable dans la " \
"cale de ce navire.")
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
salle = personnage.salle
if not importeur.commerce.questeur_existe(salle):
personnage << "|err|Aucun questeur n'est présent là où " \
"vous vous trouvez.|ff|"
return
questeur = importeur.commerce.questeurs[salle]
nombre = dic_masques["nombre"].nombre
nom_type = dic_masques["type_piece"].nom_type
prototype = None
for t_prototype in questeur.monnaies:
if contient(t_prototype.nom_singulier, nom_type):
prototype = t_prototype
break
if prototype is None:
personnage << "|err|Vous ne pouvez retirer cela.|ff|"
return
if questeur.servant is None:
personnage << "|err|Personne n'est présent pour s'en charger.|ff|"
return
total = nombre * prototype.m_valeur
if questeur.comptes.get(personnage, 0) < total:
personnage << "|err|Vous ne possédez pas assez sur ce compte.|ff|"
return
personnage.envoyer("{{}} prend {} de ses coffres et vous les " \
"donne.".format(prototype.get_nom(nombre)), questeur.servant)
questeur.prelever(personnage, prototype, nombre)
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
if msg == "q":
return self.opt_quitter("")
if len(msg) < 3:
self.pere << "|err|Ce nom de race est trop court.|ff|"
return
race = None
races = sorted(type(self).importeur.perso.races, key=str)
for t_race in races:
if contient(t_race.nom, msg):
race = t_race
break
if not race:
race = type(self).importeur.perso.creer_race(msg)
enveloppe = EnveloppeObjet(EdtPresentation, race, "")
enveloppe.parent = self
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre."""
salle = personnage.salle
personnage.agir("manip_canot")
texte = dic_masques["texte_libre"].texte
if not getattr(salle, "navire", None):
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
if not navire.etendue:
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
if not salle.get_element("bossoir"):
personnage << "|err|Il n'y a pas de bossoir ici.|ff|"
return
# Recherche du canot
canot = None
for t_canot in navire.canots:
if contient(t_canot.nom, texte):
canot = t_canot
break
if canot is None:
personnage << "|err|Impossible de trouver ce canot.|ff|"
return
navire.descendre_canot(canot)
personnage << "Vous mettez {} à l'eau.".format(canot.nom)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
salle = personnage.salle
if not importeur.commerce.questeur_existe(salle):
personnage << "|err|Aucun questeur n'est présent là où " \
"vous vous trouvez.|ff|"
return
questeur = importeur.commerce.questeurs[salle]
nombre = dic_masques["nombre"].nombre
nom_type = dic_masques["type_piece"].nom_type
prototype = None
for t_prototype in questeur.monnaies:
if contient(t_prototype.nom_singulier, nom_type):
prototype = t_prototype
break
if prototype is None:
personnage << "|err|Vous ne pouvez retirer cela.|ff|"
return
if questeur.servant is None:
personnage << "|err|Personne n'est présent pour s'en charger.|ff|"
return
total = nombre * prototype.m_valeur
if questeur.comptes.get(personnage, 0) < total:
personnage << "|err|Vous ne possédez pas assez sur ce compte.|ff|"
return
personnage.envoyer("{{}} prend {} de ses coffres et vous les " \
"donne.".format(prototype.get_nom(nombre)), questeur.servant)
questeur.prelever(personnage, prototype, nombre)
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
if msg == "q":
return self.opt_quitter("")
if len(msg) < 3:
self.pere << "|err|Ce nom de race est trop court.|ff|"
return
race = None
races = sorted(type(self).importeur.perso.races, key=str)
for t_race in races:
if contient(t_race.nom, msg):
race = t_race
break
if not race:
race = type(self).importeur.perso.creer_race(msg)
enveloppe = EnveloppeObjet(EdtPresentation, race, "")
enveloppe.parent = self
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation du message"""
try:
nom_stat, valeur = msg.split(" / ")
except ValueError:
self.pere << "|err|Syntaxe invalide.|ff|"
else:
# On cherche la stat
stat = None
for t_stat in self.objet:
if not t_stat.max and contient(t_stat.nom, nom_stat):
stat = t_stat
break
if not stat:
self.pere << "|err|Cette stat est introuvable.|ff|"
else:
# Convertion
try:
valeur = int(valeur)
assert valeur > 0
assert valeur >= stat.marge_min
assert valeur <= stat.marge_max
except (ValueError, AssertionError):
self.pere << "|err|Valeur invalide.|ff|"
else:
stat.defaut = valeur
self.actualiser()
def interpreter(self, msg):
"""Interprétation du message"""
try:
nom_stat, valeur = msg.split(" / ")
except ValueError:
self.pere << "|err|Syntaxe invalide.|ff|"
else:
# On cherche la stat
stat = None
for t_stat in self.objet:
if not t_stat.max and contient(t_stat.nom, nom_stat):
stat = t_stat
break
if not stat:
self.pere << "|err|Cette stat est introuvable.|ff|"
else:
# Convertion
try:
valeur = int(valeur)
assert valeur > 0
assert valeur >= stat.marge_min
assert valeur <= stat.marge_max
except (ValueError, AssertionError):
self.pere << "|err|Valeur invalide.|ff|"
else:
stat.defaut = valeur
self.actualiser()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre."""
salle = personnage.salle
personnage.agir("manip_canot")
texte = dic_masques["texte_libre"].texte
if not getattr(salle, "navire", None):
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
if not navire.etendue:
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
if not salle.get_element("bossoir"):
personnage << "|err|Il n'y a pas de bossoir ici.|ff|"
return
# Recherche du canot
canot = None
for t_canot in navire.canots:
if contient(t_canot.nom, texte):
canot = t_canot
break
if canot is None:
personnage << "|err|Impossible de trouver ce canot.|ff|"
return
navire.descendre_canot(canot)
personnage << "Vous mettez {} à l'eau.".format(canot.nom)
def get_nombre_option(nom):
"""Retourne le nombre lié à un nom d'option, même abrégé."""
for nombre, t_nom in NOMS_OPTIONS.items():
if contient(t_nom, nom):
return nombre
raise ValueError("l'option {} est introuvable".format(repr(nom)))
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
x, y, z = salle.coords.tuple()
etendue = salle.etendue
if not etendue:
raise ErreurValidation(
"Il n'y a pas de navires suffisamment proches.")
navires = list(importeur.navigation.navires.values())
navires = [n for n in navires if n.etendue is etendue and \
contient(n.desc_survol, nom)]
navires = [n for n in navires if mag(n.position.x, n.position.y,
n.position.z, x, y, z) < 15]
if not navires:
raise ErreurValidation(
"Ce navire est introuvable.")
navire = navires[0]
self.nom_navire = navire.nom
self.navire = navire
return True
def get_nombre_option(nom):
"""Retourne le nombre lié à un nom d'option, même abrégé."""
for nombre, t_nom in NOMS_OPTIONS.items():
if contient(t_nom, nom):
return nombre
raise ValueError("l'option {} est introuvable".format(repr(nom)))
def extraire_arguments(cls, navire, nom_navire):
"""Extrait les arguments de la volonté."""
for navire in cls.trouver_navires(navire):
if contient(navire.desc_survol, nom_navire):
return (navire, )
raise ValueError("Le navire {} n'est pas en vue.".format(nom_navire))
def extraire_arguments(cls, navire, nom_navire):
"""Extrait les arguments de la volonté."""
for navire in Tirer.trouver_navires(navire):
if contient(navire.desc_survol, nom_navire):
return (navire, )
raise ValueError("Le navire {} n'est pas en vue.".format(
nom_navire))
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_flag = self.a_interpreter
for flag in self.liste_flags:
if contient(flag, nom_flag):
self.flag = flag
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_flag = self.a_interpreter
for flag in self.liste_flags:
if contient(flag, nom_flag):
self.flag = flag
return True
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
nom_talent = dic_masques["message"].message
for sort in importeur.magie.sorts.values():
if contient(sort.nom, nom_talent) and sort.cle in personnage.sorts:
del personnage.sorts[sort.cle]
personnage << "Vous avez oublié le sort {}.".format(sort.nom)
return
for tal in importeur.perso.talents.values():
if contient(tal.nom, nom_talent) and tal.cle in personnage.talents:
oubli = personnage.talents[tal.cle]
malus = int(oubli / 100 * 5) + 1 if oubli > 10 else 0
personnage.malus += malus
if personnage.malus > 60:
personnage.malus = 60
personnage.points_malus += int(personnage.malus / 100 * oubli)
del personnage.talents[tal.cle]
personnage << "Vous avez oublié le talent {}.".format(tal.nom)
return
personnage << "|err|'{}' n'est ni un sort, ni un talent.|ff|".format(nom_talent)
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_sort = self.a_interpreter
sorts = type(self).importeur.magie.sorts
sorts_connus = [sorts.get(cle) for cle in personnage.sorts.keys() if \
cle in sorts]
for sort in sorts_connus:
if contient(sort.nom, nom_sort):
self.sort = sort
return True
for objet in personnage.equipement.inventaire:
if objet.nom_type == "parchemin" and contient(objet.sort.nom,
nom_sort) and objet.charges > 0:
self.sort = objet.sort
self.parchemin = objet
return True
raise ErreurValidation(
"|err|Vous ne connaissez pas ce sort ni ne possédez de " \
"parchemin fonctionnel.|ff|")
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
prototype = self.objet
race = None
for t_race in type(self).importeur.perso.races:
if contient(t_race.nom, msg):
race = t_race
if race is None:
self.pere << "|err|Cette race n'existe pas.|ff|"
else:
prototype.race = race
self.actualiser()
def interpreter(self, msg):
"""Interprétation du message"""
operateur = "="
if "+" in msg:
operateur = "+"
msg = msg.replace("+", "")
elif "-" in msg:
operateur = "-"
msg = msg.replace("-", "")
while " " in msg:
msg = msg.replace(" ", " ")
try:
nom_stat, valeur = msg.split(" ")
except ValueError:
self.pere << "|err|Syntaxe invalide.|ff|"
else:
# On cherche la stat
stat = None
for t_stat in self.objet:
if not t_stat.max and contient(t_stat.nom, nom_stat):
stat = t_stat
break
if not stat:
self.pere << "|err|Cette stat est introuvable.|ff|"
else:
# Convertion
try:
valeur = int(valeur)
except ValueError:
self.pere << "|err|Valeur invalide.|ff|"
else:
if operateur == "+":
valeur = stat.courante + valeur
elif operateur == "-":
valeur = stat.courante - valeur
try:
assert valeur > 0
assert valeur >= stat.marge_min
assert valeur <= stat.marge_max
except ValueError:
self.pere << "|err|Valeur invalide.|ff|"
else:
stat.defaut = valeur
stat.courante = valeur
self.actualiser()
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
prototype = self.objet
race = None
for t_race in type(self).importeur.perso.races:
if contient(t_race.nom, msg):
race = t_race
if race is None:
self.pere << "|err|Cette race n'existe pas.|ff|"
else:
prototype.race = race
self.actualiser()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
nom_talent = dic_masques["message"].message
for tal in importeur.perso.talents.values():
if contient(tal.nom, nom_talent) and tal.cle in personnage.talents:
oubli = personnage.talents[tal.cle]
malus = int(oubli / 100 * 5) + 1 if oubli > 10 else 0
#personnage.malus += malus
#if personnage.malus > 60:
#personnage.malus = 60
del personnage.talents[tal.cle]
personnage << "Vous avez oublié le talent {}.".format(tal.nom)
return
personnage << "|err|Le talent '{}' est introuvable.|ff|".format(
nom_talent)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
nom_talent = dic_masques["message"].message
for tal in importeur.perso.talents.values():
if contient(tal.nom, nom_talent) and tal.cle in personnage.talents:
oubli = personnage.talents[tal.cle]
malus = int(oubli / 100 * 5) + 1 if oubli > 10 else 0
#personnage.malus += malus
#if personnage.malus > 60:
#personnage.malus = 60
del personnage.talents[tal.cle]
personnage << "Vous avez oublié le talent {}.".format(tal.nom)
return
personnage << "|err|Le talent '{}' est introuvable.|ff|".format(
nom_talent)
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_personnage = self.a_interpreter
for p in personnage.salle.personnages:
if p is not personnage and personnage.peut_voir(p) and \
contient(p.get_nom_pour(personnage), nom_personnage):
self.personnage = p
break
if self.personnage is None:
raise ErreurValidation(
"|err|Ce personnage est introuvable.|ff|".format(nom_personnage))
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_pnj = self.a_interpreter
for p in personnage.salle.personnages:
if p is not personnage and hasattr(p, "prototype") \
and contient(p.get_nom_pour(personnage), nom_pnj):
self.pnj = p
break
if self.pnj is None:
raise ErreurValidation(
"|err|Ce PNJ est introuvable.|ff|")
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_personnage = self.a_interpreter
for p in personnage.salle.personnages:
if p is not personnage and personnage.peut_voir(p) and \
contient(p.get_nom_pour(personnage), nom_personnage):
self.personnage = p
break
if self.personnage is None:
raise ErreurValidation(
"|err|Ce personnage est introuvable.|ff|".format(nom_personnage))
return True
def contient(chaine_complete, expression):
"""Retourne vrai si la chaine_complete contient expression.
Le test ne tient ni compte des majuscules ni des accents.
Une expression est contenue dans une chaîne si l'expression
est le début d'un des mots de la chaîne complète.
Par exemple :
"chien" est contenue dans "un chien de ferme"
Ou :
"po" est contenue dans "une pomme rouge"
Mais :
"table" n'est pas contenue dans "une étable"
Car "table" n'est pas le début d'un des mots de "une étable".
"""
return contient(chaine_complete, expression)
def contient(chaine_complete, expression):
"""Retourne vrai si la chaine_complete contient expression.
Le test ne tient ni compte des majuscules ni des accents.
Une expression est contenue dans une chaîne si l'expression
est le début d'un des mots de la chaîne complète.
Par exemple :
"chien" est contenue dans "un chien de ferme"
Ou :
"po" est contenue dans "une pomme rouge"
Mais :
"table" n'est pas contenue dans "une étable"
Car "table" n'est pas le début d'un des mots de "une étable".
"""
return contient(chaine_complete, expression)
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_objet = self.a_interpreter
magasin = personnage.salle.magasin
service = None
for i, (t_service, quantite) in enumerate(magasin.inventaire):
if contient(t_service.nom_achat, nom_objet):
service = t_service
break
if service is None:
raise ErreurValidation( \
"|err|L'objet demandé n'est pas en vente.|ff|")
else:
self.service = service
self.no_ligne = i
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_objet = self.a_interpreter
magasin = personnage.salle.magasin
service = None
for i, (t_service, quantite) in enumerate(magasin.inventaire):
if contient(t_service.nom_achat, nom_objet):
service = t_service
break
if service is None:
raise ErreurValidation( \
"|err|L'objet demandé n'est pas en vente.|ff|")
else:
self.service = service
self.no_ligne = i
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
nom_flag = liste_vers_chaine(commande)
if not nom_flag:
raise ErreurValidation("Précisez un flag de filtre.", False)
nom_flag = nom_flag.split(" ")[0]
if not contient("".join(self.liste_flags),
supprimer_accents(nom_flag.lower())):
raise ErreurValidation("|err|Le flag précisé n'existe pas.|ff|",
False)
else:
self.a_interpreter = nom_flag
commande[:] = commande[len(nom_flag):]
masques.append(self)
return True
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
if dic_masques["message"] is not None:
nom_talent = dic_masques["message"].message
try:
limite = dic_masques["nombre"].nombre
limite = int(limite)
assert 0 <= limite <= 100
except (AttributeError, ValueError, AssertionError):
personnage << "|err|Vous devez préciser un nombre positif " \
"inférieur ou égal à 100.|ff|"
else:
for talent in importeur.perso.talents.values():
if contient(talent.nom, nom_talent) \
and talent.cle in personnage.talents:
if limite < personnage.get_talent(talent.cle):
personnage << "|err|Votre connaissance de ce " \
"talent est déjà supérieure à " \
"{}%.|ff|".format(limite)
return
personnage.l_talents[talent.cle] = limite
if limite == 100:
del personnage.l_talents[talent.cle]
personnage << "Le talent {} est débloqué.".format(
talent.nom)
else:
personnage << "Vous avez bloqué le talent " \
"{} à {}%.".format(talent.nom, limite)
return
personnage << "|err|Le talent '{}' est introuvable.|ff|".format(
nom_talent)
else:
if not personnage.l_talents:
personnage << "|att|Vous n'avez aucun seuil défini.|ff|"
return
ret = "Vos talents bloqués :"
lignes = []
for cle, limite in personnage.l_talents.items():
talent = importeur.perso.talents[cle]
ligne = talent.nom[0].upper() + talent.nom[1:]
ligne += " (" + str(limite) + "%)"
lignes.append(ligne)
ret += "\n- " + "\n- ".join(lignes)
personnage << ret
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
if dic_masques["message"] is not None:
nom_talent = dic_masques["message"].message
try:
limite = dic_masques["nombre"].nombre
limite = int(limite)
assert 0 <= limite <= 100
except (AttributeError, ValueError, AssertionError):
personnage << "|err|Vous devez préciser un nombre positif " \
"inférieur ou égal à 100.|ff|"
else:
for talent in importeur.perso.talents.values():
if contient(talent.nom, nom_talent) \
and talent.cle in personnage.talents:
if limite < personnage.get_talent(talent.cle):
personnage << "|err|Votre connaissance de ce " \
"talent est déjà supérieure à " \
"{}%.|ff|".format(limite)
return
personnage.l_talents[talent.cle] = limite
if limite == 100:
del personnage.l_talents[talent.cle]
personnage << "Le talent {} est débloqué.".format(
talent.nom)
else:
personnage << "Vous avez bloqué le talent " \
"{} à {}%.".format(talent.nom, limite)
return
personnage << "|err|Le talent '{}' est introuvable.|ff|".format(
nom_talent)
else:
if not personnage.l_talents:
personnage << "|att|Vous n'avez aucun seuil défini.|ff|"
return
ret = "Vos talents bloqués :"
lignes = []
for cle, limite in personnage.l_talents.items():
talent = importeur.perso.talents[cle]
ligne = talent.nom[0].upper() + talent.nom[1:]
ligne += " (" + str(limite) + "%)"
lignes.append(ligne)
ret += "\n- " + "\n- ".join(lignes)
personnage << ret
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
vit = self.a_interpreter
trouve = False
for cle in VIT_RAMES.keys():
if contient(cle, vit):
vit = cle
trouve = True
break
if not trouve:
vitesses = ", ".join(VIT_RAMES.keys())
raise ErreurValidation(
"|err|Vitesse invalide. Vitesse disponibles : {}.|ff|".format(
vitesses))
self.vitesse = vit
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
vit = self.a_interpreter
trouve = False
for cle in VIT_RAMES.keys():
if contient(cle, vit):
vit = cle
trouve = True
break
if not trouve:
vitesses = ", ".join(VIT_RAMES.keys())
raise ErreurValidation(
"|err|Vitesse invalide. Vitesse disponibles : {}.|ff|".format(
vitesses))
self.vitesse = vit
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
nom_flag = liste_vers_chaine(commande)
if not nom_flag:
raise ErreurValidation(
"Précisez un flag de filtre.", False)
nom_flag = nom_flag.split(" ")[0]
if not contient("".join(self.liste_flags),
supprimer_accents(nom_flag.lower())):
raise ErreurValidation(
"|err|Le flag précisé n'existe pas.|ff|", False)
else:
self.a_interpreter = nom_flag
commande[:] = commande[len(nom_flag):]
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
nombre = self.nombre
nb = 0
salle = personnage.salle
vegetal = None
for plante in importeur.botanique.salles.get(salle, []):
if contient(plante.nom, nom):
nb += 1
if nb == nombre:
vegetal = plante
break
if vegetal is None:
raise ErreurValidation("Vous ne voyez pas ce végétal ici.", True)
self.vegetal = vegetal
return True
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
if msg == "a":
self.pere.joueur.contextes.retirer()
self.pere.envoyer("Opération annulée.")
else:
type_choisi = ""
p_types = type(self).importeur.navigation.types_elements
for nom in p_types.keys():
if contient(nom, msg):
type_choisi = nom
if not type_choisi:
self.pere << "|err|Ce type est inconnu.|ff|"
else:
choix = types[type_choisi]
self.element = type(self).importeur.navigation.creer_element(
self.identifiant, choix)
enveloppe = EnveloppeObjet(EdtPresentation, self.element, "")
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
if msg == "a":
self.pere.joueur.contextes.retirer()
self.pere.envoyer("Opération annulée.")
else:
type_choisi = ""
p_types = type(self).importeur.navigation.types_elements
for nom in p_types.keys():
if contient(nom, msg):
type_choisi = nom
if not type_choisi:
self.pere << "|err|Ce type est inconnu.|ff|"
else:
choix = types[type_choisi]
self.element = type(self).importeur.navigation.creer_element(
self.identifiant, choix)
enveloppe = EnveloppeObjet(EdtPresentation, self.element, "")
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
nombre = self.nombre
nb = 0
salle = personnage.salle
vegetal = None
for plante in importeur.botanique.salles.get(salle, []):
if contient(plante.nom, nom):
nb += 1
if nb == nombre:
vegetal = plante
break
if vegetal is None:
raise ErreurValidation(
"Vous ne voyez pas ce végétal ici.", True)
self.vegetal = vegetal
return True
def opt_egaliser(self, arguments):
"""Égalise les stats.
Syntaxe :
/e (<modificateurs de stat>)
"""
# Restore les stats à leur valeur par défaut
modele = importeur.perso.modele_stats
for stat in self.objet:
defaut = getattr(modele, "_{}".format(stat.nom)).defaut
stat.defaut = defaut
stat.courante = defaut
dispo = importeur.perso.gen_niveaux.points_entrainement_disponibles(
self.objet.parent.niveau)
consommes = importeur.perso.gen_niveaux.points_entrainement_consommes(
self.objet.parent)
nb = dispo - consommes
stats = list(importeur.perso.gen_niveaux.stats_entrainables.keys())
if not arguments.strip():
arguments = " ".join(stats)
# Traitement des modificateurs
modificateurs = arguments.split(" ")
poids = {}
for modificateur in modificateurs:
nombre = 1
try:
modificateur, nombre = modificateur.split("=")
except ValueError:
pass
# On recherche la stat
stat = None
for nom in stats:
if contient(nom, modificateur):
stat = nom
break
if stat is None:
self.pere << "|err|Stat {} inconnue.|ff|".format(
repr(modificateur))
return
# Conversion du nombre
try:
nombre = int(nombre)
assert nombre >= 0
except (ValueError, AssertionError):
self.pere << "Nombre {} invalide.|ff|".format(nombre)
return
# Modification du poids
ancien = poids.get(stat)
if nombre == 0:
if ancien:
del poids[stat]
else:
ancien = ancien if ancien else 0
nombre = ancien + nombre
poids[stat] = nombre
print("Poids de modification", poids)
i = 0
while i < nb:
i += 1
selections = []
for nom in list(poids.keys()):
stat = self.objet[nom]
if stat.base >= stat.marge_max:
del poids[stat.nom]
if not poids:
self.pere << "|err|Impossible de répartir les stats.|ff|"
return
noms = list(poids.keys())
probas = list(poids.values())
stat = choix_probable_liste(noms, probas)
stat = self.objet[stat]
courante = stat.courante + 1
stat.courante = courante
stat.defaut = courante
# On entraîne la stat liée
liee = importeur.perso.cfg_stats.entrainement_liees.get(stat.nom)
if liee:
stat_liee = self.objet[liee]
stat_liee.courante = stat_liee.courante + stat.courante
stat_liee.defaut = stat_liee.courante + stat.courante
self.actualiser()
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
nombre = self.nombre
nb = 0
salle = personnage.salle
if not salle.voit_ici(personnage):
raise ErreurValidation(
"Il n'y a rien qui ressemble à cela par ici...", True)
elt = None
# On cherche dans les personnages
for perso in salle.personnages:
if personnage.peut_voir(perso) and \
contient(perso.get_nom_pour(personnage), nom):
nb += 1
if nb == nombre:
elt = perso
break
if elt is None:
for objet in personnage.equipement.inventaire:
if contient(objet.get_nom(), nom):
nb += 1
if nb == nombre:
elt = objet
break
if elt is None:
# On cherche dans les décors
for decor in salle.decors:
nom_decor = decor.get_nom()
if contient(nom_decor, nom):
nb += 1
if nb == nombre:
elt = decor
if elt is None:
# On cherche dans les objets
for objet in salle.objets_sol:
nom_objet = objet.get_nom()
if contient(nom_objet, nom):
nb += 1
if nb == nombre:
elt = objet
if not elt:
# On cherche dans les autres éléments observables
elts = salle.get_elements_observables(personnage)
for t_elt in elts:
nom_elt = t_elt.get_nom_pour(personnage)
if contient(nom_elt, nom):
nb += 1
if nb == nombre:
elt = t_elt
break
if not elt:
nom = supprimer_accents(nom).lower()
if salle.details.detail_existe(nom, flottants=True):
detail = salle.details.get_detail(nom, flottants=True)
nb += 1
if nb == nombre:
elt = detail
if elt is None:
raise ErreurValidation(
"Il n'y a rien qui ressemble à cela par ici...", True)
self.element = elt
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
nombre = self.nombre
nb = 0
salle = personnage.salle
if not salle.voit_ici(personnage):
raise ErreurValidation(
"Il n'y a rien qui ressemble à cela par ici...", True)
elt = None
# On cherche dans les personnages
for perso in salle.personnages:
if personnage.peut_voir(perso) and \
contient(perso.get_nom_pour(personnage), nom):
nb += 1
if nb == nombre:
elt = perso
break
if elt is None:
for objet in personnage.equipement.inventaire:
if contient(objet.get_nom(), nom):
nb += 1
if nb == nombre:
elt = objet
break
if elt is None:
# On cherche dans les décors
for decor in salle.decors:
nom_decor = decor.get_nom()
if contient(nom_decor, nom):
nb += 1
if nb == nombre:
elt = decor
if elt is None:
# On cherche dans les objets
for objet in salle.objets_sol:
nom_objet = objet.get_nom()
if contient(nom_objet, nom):
nb += 1
if nb == nombre:
elt = objet
if not elt:
# On cherche dans les autres éléments observables
elts = salle.get_elements_observables(personnage)
for t_elt in elts:
nom_elt = t_elt.get_nom_pour(personnage)
if contient(nom_elt, nom):
nb += 1
if nb == nombre:
elt = t_elt
break
if not elt:
nom = supprimer_accents(nom).lower()
if salle.details.detail_existe(nom, flottants=True):
detail = salle.details.get_detail(nom, flottants=True)
nb += 1
if nb == nombre:
elt = detail
if elt is None:
raise ErreurValidation(
"Il n'y a rien qui ressemble à cela par ici...", True)
self.element = elt
return True
