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 repartir(self, personnage, masques, commande):
"""Répartition du masque"""
lstrip(commande)
if not commande:
raise ErreurValidation("Entrez une date au format JJ-MM-AAAA")
str_commande = liste_vers_chaine(commande).split(" ")[0]
try:
jour, mois, annee = str_commande.split("-")
except ValueError:
raise ErreurValidation("syntaxe invalide", True)
try:
jour = int(jour)
assert 0 < jour <= 31
except (ValueError, AssertionError):
raise ErreurValidation("Jour invalide", True)
try:
mois = int(mois)
assert 0 < mois <= 12
except (ValueError, AssertionError):
raise ErreurValidation("Mois invalide", True)
try:
annee = int(annee)
assert 0 < annee
except ValueError:
raise ErreurValidation("Année invalide", True)
self.jour = jour
self.mois = mois
self.annee = annee
commande[:] = commande[len(str_commande) + 1:]
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
salle = personnage.salle
nom = self.a_interpreter
t_nom = supprimer_accents(nom).lower()
familiers = importeur.familier.familiers_de(personnage)
familiers = [f for f in familiers if f.pnj]
if self.salle_identique:
familiers = [f for f in familiers if f.pnj.salle is salle]
familier = None
for t_familier in familiers:
if supprimer_accents(t_familier.nom).lower() == t_nom:
familier = t_familier
break
if not self.nouveau and familier is None:
raise ErreurValidation(
"|err|Le familier {} ne peut être trouvé.|ff|".format(nom))
elif self.nouveau and familier:
raise ErreurValidation(
"|err|Le familier {} existe déjà.|ff|".format(nom))
self.nom_familier = nom
self.familier = familier
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
duree = self.a_interpreter
res = RE_DUREE.search(duree)
if not res:
raise ErreurValidation("Durée invalide.")
nb, mesure = res.groups()
nb = int(nb)
mesure = mesure.lower()
if mesure in ("s", "sec", "seconde", "secondes"):
mult = 1
nom_complet = "seconde"
elif mesure in ("m", "mn", "min", "minute", "minutes"):
mult = 60
nom_complet = "minute"
elif mesure in ("h", "hr", "heure", "heures"):
mult = 3600
nom_complet = "heure"
elif mesure in ("j", "jr", "jour", "jours"):
mult = 86400
nom_complet = "jour"
else:
raise ErreurValidation("Mesure {} inconnue.".format(mesure))
self.secondes = mult * nb
s = ""
if nb > 1:
s = "s"
self.temps = "{} {}{s}".format(nb, nom_complet, s=s)
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
lstrip(commande)
nom = liste_vers_chaine(commande)
re_nb = RE_NB.search(nom)
if re_nb:
nb = re_nb.groups()[0]
nom = nom[len(nb) + 1:]
try:
nb = int(nb)
assert nb > 0
except (ValueError, AssertionError):
raise ErreurValidation( \
"Ce nombre est invalide.", False)
else:
self.nombre = nb
if not nom:
raise ErreurValidation( \
"Précisez un élément observable.", False)
commande[:] = []
self.a_interpreter = nom
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
if not hasattr(salle, "navire"):
raise ErreurValidation("|err|Vous n'êtes pas sur un navire.|ff|")
navire = salle.navire
equipage = navire.equipage
matelot = None
try:
matelot = equipage.get_matelot(nom)
except KeyError:
pass
if not self.nouveau and matelot is None:
raise ErreurValidation(
"|err|Le matelot {} ne peut être trouvé.|ff|".format(nom))
elif self.nouveau and matelot:
raise ErreurValidation(
"|err|Le matelot {} existe déjà.|ff|".format(nom))
self.nom_matelot = nom
self.matelot = matelot
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
nom_objet = liste_vers_chaine(commande)
if not nom_objet:
raise ErreurValidation( \
"Vous devez préciser le nom d'un objet.", False)
elif personnage.salle.magasin is None:
raise ErreurValidation( \
"Il n'y a pas de magasin ici.")
else:
self.a_interpreter = nom_objet
commande[:] = []
masques.append(self)
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
id_conversation = liste_vers_chaine(commande)
if not id_conversation:
raise ErreurValidation( \
"Vous devez préciser le numéro d'un correspondant.", False)
id_conversation = id_conversation.split(" ")[0]
if not id_conversation.isdigit() and not id_conversation == "-":
raise ErreurValidation( \
"L'ID {} n'est pas valide.".format(id_conversation), False)
self.a_interpreter = id_conversation
commande[:] = commande[len(id_conversation):]
masques.append(self)
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 repartir(self, personnage, masques, commande):
"""Répartition du masque."""
str_coordonnees = liste_vers_chaine(commande).lstrip()
str_coordonnees = str_coordonnees.split(" ")[0]
if not str_coordonnees:
raise ErreurValidation("Précisez des coordonnées.", False)
if not RE_COORDS.search(str_coordonnees):
raise ErreurValidation("Ceci ne sont pas des coordonnées valides.",
False)
self.a_interpreter = str_coordonnees
commande[:] = commande[len(str_coordonnees):]
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
chemin_commande = self.a_interpreter
trans_param = True # doit-on transmettre les sous-commandes ?
if chemin_commande.endswith("."):
chemin_commande = chemin_commande[:-1]
trans_param = False
# On cherche dans les chemins des commandes, dans interpreteur.groupes
chemins = type(self).importeur.interpreteur.groupes.commandes.keys()
commandes = []
for chemin in chemins:
if chemin == chemin_commande:
commandes.append(chemin)
elif trans_param and chemin.startswith(chemin_commande + SEP):
commandes.append(chemin)
if not commandes:
raise ErreurValidation(
"|err|Aucune commande correspondant au chemin n'a pu être " \
"trouvée.|ff|")
self.chemins = commandes
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
id_conversation = self.a_interpreter
conversations = type(self).importeur.communication.conversations
p_conversations = conversations.get_conversations_pour(personnage)
cible = None
if id_conversation == "-":
self.perte_focus = True
return True
try:
id_conversation = int(id_conversation)
except ValueError:
return False
for conversation in p_conversations:
if conversation.id == id_conversation:
cible = conversation.cible
break
if cible is None:
raise ErreurValidation(
"|err|Le numéro spécifié ne correspond à aucun personnage.|ff|"
)
else:
self.id_conversation = id_conversation
self.cible = cible
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
no = self.a_interpreter
try:
auberge = importeur.auberge.get_auberge(personnage.salle)
except KeyError:
raise ErreurValidation("|err|Il n'y a pas d'auberge ici.|ff|")
chambre = auberge.get_chambre_avec_numero(no)
if chambre is None:
raise ErreurValidation(
"|err|Aucune chambre ne porte ce numéro.|ff|")
self.chambre = chambre
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
str_nombre = liste_vers_chaine(commande).lstrip()
str_nombre = str_nombre.split(" ")[0]
if not str_nombre:
raise ErreurValidation("Précisez un nombre.", False)
self.a_interpreter = str_nombre
if str_nombre.startswith("-"):
str_nombre = str_nombre[1:]
if not str_nombre.isdigit():
raise ErreurValidation("|err|Ceci n'est pas un nombre.|ff|", False)
commande[:] = commande[len(str_nombre):]
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_groupe = self.a_interpreter
if not re.match(NOM_VALIDE, nom_groupe):
raise ErreurValidation(
"|err|Ce nom de groupe est invalide.|ff|")
noms_groupes = [groupe.nom for groupe in \
type(self).importeur.interpreteur.groupes._groupes.values()]
if nom_groupe in noms_groupes:
raise ErreurValidation(
"|err|Ce nom de groupe est déjà utilisé.|ff|")
self.nom_groupe = nom_groupe.lower()
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)
stat_ent = supprimer_accents(self.a_interpreter).lower()
if not stat_ent in importeur.perso.cfg_stats.entrainables:
raise ErreurValidation( \
"Stat inconnue.")
self.stat_ent = stat_ent
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom = self.a_interpreter
salle = personnage.salle
vegetal = self.vegetal
if vegetal is None:
raise ErreurValidation("|err|Aucun végétal n'est précisé.|ff|")
try:
element = vegetal.periode.get_element(nom)
except ValueError:
raise ErreurValidation(
"|err|L'élément récoltable {} est introuvable.|ff|".format(
nom))
self.element = element
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
lstrip(commande)
nom = liste_vers_chaine(commande)
if not nom:
raise ErreurValidation( \
"Précisez une commande dynamique.")
if nom.count("/") != 1 or " " in nom:
raise ErreurValidation( \
"Précisez le nom français, un signe |cmd|/|ff| puis " \
"le nom anglais.")
nom = nom.split(" ")[0].lower()
self.a_interpreter = nom
commande[:] = commande[len(nom):]
masques.append(self)
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
ident = liste_vers_chaine(commande)
if not ident:
raise ErreurValidation( \
"Précisez un identifiant de salle.")
if ident.count(":") != 1:
if self.force:
raise ErreurValidation(
"Format de l'identifiant inconnu.")
return False
ident = ident.split(" ")[0].lower()
self.a_interpreter = ident
commande[:] = commande[len(ident):]
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
cle = self.a_interpreter
if self.regex:
res = re.search(self.regex, cle)
if res is None:
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
else:
try:
valider_cle(cle)
except ValueError:
raise ErreurValidation(
"|err|Cette clé identifiante est invalide.|ff|")
self.cle = cle
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
ident = self.a_interpreter
try:
zone, mnemonic = ident.split(":")
except ValueError:
raise ErreurValidation(
"|err|L'identifiant '{}' n'est pas valide.|ff|".format(ident))
if ident in type(self).importeur.salle:
raise ErreurValidation(
"|err|Cet identifiant est déjà utilisé.|ff|")
self.identifiant = ident
self.zone = zone
self.mnemonic = mnemonic
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
message = liste_vers_chaine(commande).lstrip()
self.a_interpreter = message
commande[:] = []
if not message:
raise ErreurValidation("Précisez une durée.")
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_cherchable = self.a_interpreter
cherchables = importeur.recherche.cherchables
if nom_cherchable in cherchables:
self.cherchable = cherchables[nom_cherchable]
return True
else:
raise ErreurValidation("|err|Vous ne pouvez rechercher cela.|ff|")
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_stat = self.a_interpreter
# nom_stat ne peut commencer par un signe souligné
if nom_stat.startswith("_"):
raise ErreurValidation( \
"Cette stat n'existe pas.")
# On se base sur les stats du personnage appelant
try:
stat = getattr(personnage.stats, "_{}".format(nom_stat))
except AttributeError:
raise ErreurValidation( \
"Cette stat n'existe pas.")
else:
self.nom_stat = stat.nom
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
nom_groupe = liste_vers_chaine(commande)
if not nom_groupe:
raise ErreurValidation(
"Précisez un nom pour le nouveau groupe.")
self.a_interpreter = nom_groupe
commande[:] = []
masques.append(self)
return True
def repartir(self, personnage, masques, commande):
"""Répartition du masque."""
nom_groupe = liste_vers_chaine(commande)
if not nom_groupe:
raise ErreurValidation("Précisez un nom de groupe existant.")
nom_groupe = nom_groupe.split(" ")[0]
self.a_interpreter = nom_groupe
commande[:] = commande[len(nom_groupe):]
masques.append(self)
return True
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
nom_groupe = self.a_interpreter
noms_groupes = [groupe.nom for groupe in \
type(self).importeur.interpreteur.groupes._groupes.values()]
if nom_groupe not in noms_groupes:
raise ErreurValidation("|err|Ce groupe est inconnu.|ff|")
self.nom_groupe = nom_groupe.lower()
return True
def repartir(self, personnage, masques, lst_commande):
"""Commande de validation"""
str_commande = liste_vers_chaine(lst_commande)
trouve = False
commandes = self.lister_commandes_pour_personnage(personnage)
if personnage.langue_cmd == "francais":
commandes.sort(key=lambda c: c.commande.nom_francais)
elif personnage.langue_cmd == "anglais":
commandes.sort(key=lambda c: c.commande.nom_anglais)
for cmd in commandes:
if cmd.repartir(personnage, masques, lst_commande):
trouve = True
break
if not trouve:
if lst_commande:
raise ErreurValidation("|err|Commande inconnue.|ff|")
else:
raise ErreurValidation()
def valider(self, personnage, dic_masques):
"""Validation du masque"""
Masque.valider(self, personnage, dic_masques)
cle = self.a_interpreter
attitudes = type(self).importeur.communication.attitudes
if cle not in attitudes:
raise ErreurValidation( \
"|err|Cette attitude n'existe pas.|ff|")
self.attitude = attitudes[cle]
return True