def opt_copier(self, arguments):
"""Option copier"""
if not arguments or arguments.isspace():
self.pere.joueur << "|err|Vous devez préciser le numéro d'un " \
"message.|ff|"
return
mails = type(self).importeur.communication.mails.get_mails_pour(
self.pere.joueur, ENVOYE)
try:
num = int(arguments.split(" ")[0])
except ValueError:
self.pere.joueur << "|err|Vous devez spécifier un nombre entier " \
"valide.|ff|"
else:
i = 1
c_mail = None
for mail in mails:
if num == i:
c_mail = mail
break
i += 1
if c_mail is None:
self.pere.joueur << "|err|Le numéro spécifié ne correspond à " \
"aucun message.|ff|"
return
mail = type(self).importeur.communication.mails.creer_mail(
self.pere.joueur)
mail.sujet = "CC:" + c_mail.sujet
mail.liste_dest = c_mail.liste_dest
mail.contenu.ajouter_paragraphe(str(c_mail.contenu))
enveloppe = EnveloppeObjet(EdtMedit, mail, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
self.pere.joueur.contextes.ajouter(contexte)
contexte.actualiser()
def interpreter(self, msg):
"""Interprétation du message"""
msg = supprimer_accents(msg).lower()
if msg == "a":
self.fermer()
self.pere.envoyer("Opération annulée.")
else:
type_choisi = ""
if self.choisi:
p_types = types[self.choisi].types
else:
p_types = type(self).importeur.objet.types_premier_niveau
for nom, p_type in p_types.items():
if supprimer_accents(nom) == msg and p_type.selectable:
type_choisi = nom
break
if not type_choisi:
self.pere << "|err|Ce type est inconnu.|ff|"
else:
choix = types[type_choisi]
# Si aucun type enfant n'existe
if not choix.types:
self.objet = type(self).importeur.objet.creer_prototype(
self.identifiant, type_choisi)
enveloppe = EnveloppeObjet(EdtPresentation, self.objet, "")
else:
enveloppe = EnveloppeObjet(EdtOedit, self.identifiant,
"", type_choisi)
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def opt_copier(self, arguments):
"""Option copier"""
if not arguments or arguments.isspace():
self.pere.joueur << "|err|Vous devez préciser le numéro d'un " \
"message.|ff|"
return
mails = type(self).importeur.communication.mails.get_mails_pour(
self.pere.joueur, ENVOYE)
try:
num = int(arguments.split(" ")[0])
except ValueError:
self.pere.joueur << "|err|Vous devez spécifier un nombre entier " \
"valide.|ff|"
else:
i = 1
c_mail = None
for mail in mails:
if num == i:
c_mail = mail
break
i += 1
if c_mail is None:
self.pere.joueur << "|err|Le numéro spécifié ne correspond à " \
"aucun message.|ff|"
return
mail = type(self).importeur.communication.mails.creer_mail(
self.pere.joueur)
mail.sujet = "CC:" + c_mail.sujet
mail.liste_dest = c_mail.liste_dest
mail.contenu.ajouter_paragraphe(str(c_mail.contenu))
enveloppe = EnveloppeObjet(EdtMedit, mail, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
self.pere.joueur.contextes.ajouter(contexte)
contexte.actualiser()
def opt_editer_evt(self, arguments):
"""Edite ou affiche les éléments de la description."""
description = self.description
if not description.scriptable:
self.pere << "|err|Option inconnue.|ff|"
return
evenements = description.script["regarde"].evenements
evt = supprimer_accents(arguments).strip()
if not evt:
msg = \
"Ci-dessous se trouve la liste des éléments observables " \
"dans cette description :\n"
for nom in sorted(evenements.keys()):
msg += "\n {}".format(nom)
if not evenements:
msg += "\n |att|Aucun|ff|"
self.pere << msg
else:
if evt in evenements.keys():
evenement = evenements[evt]
else:
evenement = description.script["regarde"].creer_evenement(evt)
description.script.init()
evenement.creer_sinon()
enveloppe = EnveloppeObjet(EdtInstructions, evenement.sinon)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de la présentation"""
salle = self.objet
sorties = salle.sorties
try:
sortie = sorties[msg]
if not sortie:
raise AttributeError
except (KeyError, AttributeError):
self.pere << "|err|La sortie spécifiée n'existe pas.|ff|"
else:
enveloppe = EnveloppeObjet(EdtSortie, sortie, None)
enveloppe.parent = self
enveloppe.aide_courte = \
"Entrez |ent|/|ff| pour revenir à la fenêtre parente.\n" \
"Options :\n" \
" - |cmd|/r <nouveau nom> (/ <préfixe>)|ff| : renomme la " \
"sortie\n" \
" - |cmd|/s <identifiant d'une salle>|ff| : fait pointer la " \
"sortie vers la salle\n" \
" spécifiée\n" \
" - |cmd|/dq|ff| : détruit la sortie réciproque (permet de " \
"créer des sorties à sens\n unique)\n" \
" - |cmd|/c|ff| : bascule l'état caché de la sortie\n" \
" - |cmd|/p (<clef>)|ff| : ajoute ou supprime une porte à " \
"la sortie ; vous pouvez\n" \
" préciser l'identifiant d'un objet de type clef"
if sortie.direction in ("bas", "haut"):
enveloppe.aide_courte += \
"\n - |cmd|/e <difficulté à escalader entre 1 et 10|ff|"
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def opt_editer(self, arguments):
"""Option éditer"""
if not arguments or arguments.isspace():
self.pere.joueur << "|err|Vous devez préciser le numéro d'un " \
"message.|ff|"
return
mails = type(self).importeur.communication.mails.get_mails_pour(
self.pere.joueur, BROUILLON)
try:
num = int(arguments.split(" ")[0])
except ValueError:
self.pere.joueur << "|err|Vous devez spécifier un nombre entier " \
"valide.|ff|"
else:
i = 1
e_mail = None
for mail in mails:
if num == i:
e_mail = mail
break
i += 1
if e_mail is None:
self.pere.joueur << "|err|Le numéro spécifié ne correspond " \
"à aucun message.|ff|"
return
brouillon = type(self).importeur.communication.mails.creer_mail( \
e_mail.expediteur, source=e_mail)
enveloppe = EnveloppeObjet(EdtMedit, brouillon, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
contexte.opts.rci_ctx_prec = ""
self.pere.joueur.contextes.ajouter(contexte)
contexte.actualiser()
def interpreter(self, msg):
"""Interprétation du message"""
msg = supprimer_accents(msg).lower()
if msg == "a":
self.fermer()
self.pere.envoyer("Opération annulée.")
else:
type_choisi = ""
if self.choisi:
p_types = types[self.choisi].types
else:
p_types = type(self).importeur.objet.types_premier_niveau
for nom, p_type in p_types.items():
if supprimer_accents(nom) == msg and p_type.selectable:
type_choisi = nom
break
if not type_choisi:
self.pere << "|err|Ce type est inconnu.|ff|"
else:
choix = types[type_choisi]
# Si aucun type enfant n'existe
if not choix.types:
self.objet = type(self).importeur.objet.creer_prototype(
self.identifiant, type_choisi)
enveloppe = EnveloppeObjet(EdtPresentation, self.objet, "")
else:
enveloppe = EnveloppeObjet(EdtOedit, self.identifiant, "",
type_choisi)
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
if not dic_masques["ident"]:
# Affichage des éléments
tableau = Tableau("Éléments actuels")
tableau.ajouter_colonne("Type")
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Nom")
elements = list(importeur.navigation.elements.values())
elements.sort(key=lambda e: e.cle)
elements.sort(key=lambda e: e.nom_type)
for element in elements:
tableau.ajouter_ligne(element.nom_type, element.cle,
element.nom)
personnage << tableau.afficher()
return
ident = dic_masques["ident"].ident
if ident in type(self).importeur.navigation.elements:
element = type(self).importeur.navigation.elements[ident]
enveloppe = EnveloppeObjet(EdtPresentation, element, "")
contexte = enveloppe.construire(personnage)
personnage.contextes.ajouter(contexte)
contexte.actualiser()
else:
editeur = type(self).importeur.interpreteur.construire_editeur(
"eltedit", personnage, ident)
personnage.contextes.ajouter(editeur)
editeur.actualiser()
def interpreter(self, msg):
"""Interprétation de l'éditeur."""
objet = self.callback or self.objet
liste = getattr(self.objet, self.attribut)
methode = getattr(objet, self.recuperation)
try:
if self.callback:
element = methode(liste, msg)
else:
element = methode(msg)
except Exception as err:
print(traceback.format_exc())
self.pere << "|err|" + str(err) + ".|ff|"
return
if self.callback:
self.callback.editer_element(self, self.objet, liste, element)
else:
TypeEditeur = importeur.interpreteur.contextes[
self.editeur_suivant]
enveloppe = EnveloppeObjet(TypeEditeur, element, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de la présentation"""
squelette = self.objet
membres = squelette.membres
nom = supprimer_accents(msg).lower()
try:
membre = squelette.get_membre(nom)
except KeyError:
try:
membre = squelette.ajouter_membre(msg)
except ValueError:
self.pere << "|err|Ce nom de membre est invalide.|ff|"
return
enveloppe = EnveloppeObjet(EdtMembre, membre, None)
enveloppe.parent = self
enveloppe.aide_courte = \
"Entrez |ent|/|ff| pour revenir à la fenêtre parente.\n" \
"Options :\n" \
" - |ent|/n <nouveau nom>|ff| : modifie le nom du membre\n" \
" - |ent|/g <groupe>|ff| : permet de regrouper plusieurs " \
"membres\n" \
" - |ent|/p <probabilité>|ff| : change la probabilité de " \
"toucher le membre en combat\n" \
" - |ent|/f <flag>|ff| : change l'état d'un flag\n"
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de la présentation"""
salle = self.objet
sorties = salle.sorties
try:
sortie = sorties[msg]
if not sortie:
raise AttributeError
except (KeyError, AttributeError):
self.pere << "|err|La sortie spécifiée n'existe pas.|ff|"
else:
enveloppe = EnveloppeObjet(EdtSortie, sortie, None)
enveloppe.parent = self
enveloppe.aide_courte = \
"Entrez |ent|/|ff| pour revenir à la fenêtre parente.\n" \
"Options :\n" \
" - |cmd|/r <nouveau nom> (/ <préfixe>)|ff| : renomme la " \
"sortie\n" \
" - |cmd|/s <identifiant d'une salle>|ff| : fait pointer la " \
"sortie vers la salle\n" \
" spécifiée\n" \
" - |cmd|/dq|ff| : détruit la sortie réciproque (permet de " \
"créer des sorties à sens\n unique)\n" \
" - |cmd|/c|ff| : bascule l'état caché de la sortie\n" \
" - |cmd|/p (<clef>)|ff| : ajoute ou supprime une porte à " \
"la sortie ; vous pouvez\n" \
" préciser l'identifiant d'un objet de type clef"
if sortie.direction in ("bas", "haut"):
enveloppe.aide_courte += \
"\n - |cmd|/e <difficulté à escalader entre 1 et 10|ff|"
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def opt_editer(self, arguments):
"""Option éditer"""
if not arguments or arguments.isspace():
self.pere.joueur << "|err|Vous devez préciser le numéro d'un " \
"message.|ff|"
return
mails = type(self).importeur.communication.mails.get_mails_pour(
self.pere.joueur, BROUILLON)
try:
num = int(arguments.split(" ")[0])
except ValueError:
self.pere.joueur << "|err|Vous devez spécifier un nombre entier " \
"valide.|ff|"
else:
i = 1
e_mail = None
for mail in mails:
if num == i:
e_mail = mail
break
i += 1
if e_mail is None:
self.pere.joueur << "|err|Le numéro spécifié ne correspond " \
"à aucun message.|ff|"
return
brouillon = type(self).importeur.communication.mails.creer_mail( \
e_mail.expediteur, source=e_mail)
enveloppe = EnveloppeObjet(EdtMedit, brouillon, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
contexte.opts.rci_ctx_prec = ""
self.pere.joueur.contextes.ajouter(contexte)
contexte.actualiser()
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"""
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 de l'éditeur"""
evenement = self.objet
if evenement.evenements:
nom_evt = supprimer_accents(msg).lower()
if nom_evt in evenement.evenements:
evenement = evenement.evenements[nom_evt]
enveloppe = EnveloppeObjet(EdtEvenement, evenement)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
else:
self.pere << "|err|Cet évènement n'existe pas.|ff|"
return
if msg == "*":
if evenement.sinon is None:
evenement.creer_sinon()
enveloppe = EnveloppeObjet(EdtInstructions, evenement.sinon)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
elif msg.isdigit():
no_tests = int(msg) - 1
try:
tests = evenement.tests[no_tests]
except IndexError:
self.pere << "|err|Ce test n'existe pas.|ff|"
else:
enveloppe = EnveloppeObjet(EdtInstructions, tests)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
elif not msg:
self.pere << "|err|Précisez un test.|ff|"
else:
try:
evenement.ajouter_test(msg)
except ValueError as err:
self.pere << "|err|Erreur lors du parsage du test.|ff|"
else:
self.actualiser()
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
evenement = self.objet
if evenement.evenements:
nom_evt = supprimer_accents(msg).lower()
if nom_evt in evenement.evenements:
evenement = evenement.evenements[nom_evt]
enveloppe = EnveloppeObjet(EdtEvenement, evenement)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
else:
self.pere << "|err|Cet évènement n'existe pas.|ff|"
return
if msg == "*":
if evenement.sinon is None:
evenement.creer_sinon()
enveloppe = EnveloppeObjet(EdtInstructions, evenement.sinon)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
elif msg.isdigit():
no_tests = int(msg) - 1
try:
tests = evenement.tests[no_tests]
except IndexError:
self.pere << "|err|Ce test n'existe pas.|ff|"
else:
enveloppe = EnveloppeObjet(EdtInstructions, tests)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
elif not msg:
self.pere << "|err|Précisez un test.|ff|"
else:
try:
evenement.ajouter_test(msg)
except ValueError as err:
self.pere << "|err|Erreur lors du parsage du test.|ff|"
else:
self.actualiser()
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
script = self.objet
nom_evt = supprimer_accents(msg).lower()
if nom_evt in script.evenements or script.creer_evenement_dynamique(
msg):
evenement = script.evenements[nom_evt]
enveloppe = EnveloppeObjet(EdtEvenement, evenement)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
elif nom_evt in script.blocs:
bloc = script.blocs[nom_evt]
enveloppe = EnveloppeObjet(EdtInstructions, bloc.test)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
else:
self.pere << "|err|Ce bloc ou évènement n'existe pas.|ff|"
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
auberge = self.objet
chambre = auberge.get_chambre_avec_numero(msg)
if chambre:
enveloppe = EnveloppeObjet(EdtChambre, chambre)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
else:
self.pere << "|err|Chambre {} introuvable.|ff|".format(repr(msg))
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
auberge = self.objet
chambre = auberge.get_chambre_avec_numero(msg)
if chambre:
enveloppe = EnveloppeObjet(EdtChambre, chambre)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
else:
self.pere << "|err|Chambre {} introuvable.|ff|".format(repr(msg))
def interpreter(self, msg):
"""Interprélémention de l'éditeur."""
prototype = self.objet
element = prototype.get_element(msg)
if element is None:
self.pere << "|err|Cet élément est introuvable.|ff|"
return
enveloppe = EnveloppeObjet(EdtElement, element, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
script = self.objet
nom_evt = supprimer_accents(msg).lower()
if nom_evt in script.evenements or script.creer_evenement_dynamique(
msg):
evenement = script.evenements[nom_evt]
enveloppe = EnveloppeObjet(EdtEvenement, evenement)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
elif nom_evt in script.blocs:
bloc = script.blocs[nom_evt]
enveloppe = EnveloppeObjet(EdtInstructions, bloc.test)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
else:
self.pere << "|err|Ce bloc ou évènement n'existe pas.|ff|"
def editer_element(self, editeur, structure, liste, element):
"""Édite un élément de la liste."""
EdtEditeur = __import__("primaires.scripting.editeurs.personnalise") \
.scripting.editeurs.personnalise.EdtEditeur
pere = editeur.pere
personnage = pere.joueur
obj_editeur = importeur.scripting.editeurs[self.structure_externe]
enveloppe = EnveloppeObjet(EdtEditeur, obj_editeur,
element, False)
enveloppe.parent = editeur
contexte = enveloppe.construire(pere)
editeur.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprélémention de l'éditeur."""
prototype = self.objet
element = prototype.get_element(msg)
if element is None:
self.pere << "|err|Cet élément est introuvable.|ff|"
return
enveloppe = EnveloppeObjet(EdtElement, element, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur."""
prototype = self.objet
try:
cycle = prototype.get_cycle(msg.strip())
except ValueError:
self.pere << "|err|Cycle introuvable.|ff|"
return
enveloppe = EnveloppeObjet(EdtCycle, cycle, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation du message."""
modele = self.objet
try:
coords, salle = modele.get_salle(msg)
except ValueError:
self.pere << "|err|Ce mnémonique n'existe pas.|ff|"
else:
enveloppe = EnveloppeObjet(EdtSalle, salle)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation du message."""
modele = self.objet
try:
coords, salle = modele.get_salle(msg)
except ValueError:
self.pere << "|err|Ce mnémonique n'existe pas.|ff|"
else:
enveloppe = EnveloppeObjet(EdtSalle, salle)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur."""
prototype = self.objet
try:
cycle = prototype.get_cycle(msg.strip())
except ValueError:
self.pere << "|err|Cycle introuvable.|ff|"
return
enveloppe = EnveloppeObjet(EdtCycle, cycle, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
salle = self.objet
details = salle.details
msg = supprimer_accents(msg)
detail = details.get_detail(msg)
if detail is None:
detail = details.ajouter_detail(msg)
enveloppe = EnveloppeObjet(EdtDetail, detail, "description")
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
salle = self.objet
details = salle.details
msg = supprimer_accents(msg)
detail = details.get_detail(msg)
if detail is None:
detail = details.ajouter_detail(msg)
enveloppe = EnveloppeObjet(EdtDetail, detail, "description")
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
ident_objet = dic_masques["ident"].ident
if ident_objet in type(self).importeur.objet.prototypes:
prototype = type(self).importeur.objet.prototypes[ident_objet]
enveloppe = EnveloppeObjet(EdtPresentation, prototype, "")
contexte = enveloppe.construire(personnage)
personnage.contextes.ajouter(contexte)
contexte.actualiser()
else:
editeur = type(self).importeur.interpreteur.construire_editeur(
"oedit", personnage, ident_objet)
personnage.contextes.ajouter(editeur)
editeur.actualiser()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
ident_objet = dic_masques["ident"].ident
if ident_objet in type(self).importeur.objet.prototypes:
prototype = type(self).importeur.objet.prototypes[ident_objet]
enveloppe = EnveloppeObjet(EdtPresentation, prototype, "")
contexte = enveloppe.construire(personnage)
personnage.contextes.ajouter(contexte)
contexte.actualiser()
else:
editeur = type(self).importeur.interpreteur.construire_editeur(
"oedit", personnage, ident_objet)
personnage.contextes.ajouter(editeur)
editeur.actualiser()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
ident = dic_masques["ident"].ident
if ident in type(self).importeur.navigation.elements:
element = type(self).importeur.navigation.elements[ident]
enveloppe = EnveloppeObjet(EdtPresentation, element, "")
contexte = enveloppe.construire(personnage)
personnage.contextes.ajouter(contexte)
contexte.actualiser()
else:
editeur = type(self).importeur.interpreteur.construire_editeur(
"eltedit", personnage, ident)
personnage.contextes.ajouter(editeur)
editeur.actualiser()
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
prototype = self.objet
try:
no = int(msg)
assert 0 < no <= len(prototype.chapitres)
except (ValueError, AssertionError):
self.pere << "|err|Numéro invalide.|ff|"
return
chapitre = prototype.chapitres[no - 1]
enveloppe = EnveloppeObjet(EdtChapitre, chapitre, "")
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur"""
prototype = self.objet
try:
no = int(msg)
assert 0 < no <= len(prototype.chapitres)
except (ValueError, AssertionError):
self.pere << "|err|Numéro invalide.|ff|"
return
chapitre = prototype.chapitres[no - 1]
enveloppe = EnveloppeObjet(EdtChapitre, chapitre, "")
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur."""
liste = getattr(self.objet, self.attribut)
methode = getattr(self.objet, self.recuperation)
try:
element = methode(msg)
except Exception as err:
print(traceback.format_exc())
self.pere << "|err|" + str(err) + ".|ff|"
return
TypeEditeur = importeur.interpreteur.contextes[self.editeur_suivant]
enveloppe = EnveloppeObjet(TypeEditeur, element, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur."""
prototype = self.objet
etats = prototype.etats
try:
no = int(msg)
assert no > 0
assert no <= len(etats)
except ValueError:
self.pere << "|err|Nombre invalide.|ff|"
return
etat = etats[no - 1]
enveloppe = EnveloppeObjet(EdtEtat, etat, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation de l'éditeur."""
prototype = self.objet
etats = prototype.etats
try:
no = int(msg)
assert no > 0
assert no <= len(etats)
except ValueError:
self.pere << "|err|Nombre invalide.|ff|"
return
etat = etats[no - 1]
enveloppe = EnveloppeObjet(EdtEtat, etat, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere)
self.migrer_contexte(contexte)
def autre_interpretation(self, msg):
"""On peut aussi interpréter des niveaux d'étapes."""
try:
etape = self.objet.etapes[msg]
except KeyError:
self.pere << "|err|L'étape {} n'existe pas.|ff|".format(msg)
else:
if etape.type == "etape":
enveloppe = EnveloppeObjet(EdtEtape, etape)
elif etape.type == "quete":
enveloppe = EnveloppeObjet(EdtPresentation, etape)
else:
raise TypeError("type d'étape inconnu {}".format(type(etape)))
enveloppe.parent = self
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def autre_interpretation(self, msg):
"""On peut aussi interpréter des niveaux d'étapes."""
try:
etape = self.objet.etapes[msg]
except KeyError:
self.pere << "|err|L'étape {} n'existe pas.|ff|".format(msg)
else:
if etape.type == "etape":
enveloppe = EnveloppeObjet(EdtEtape, etape)
elif etape.type == "quete":
enveloppe = EnveloppeObjet(EdtPresentation, etape)
else:
raise TypeError("type d'étape inconnu {}".format(type(etape)))
enveloppe.parent = self
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def opt_repondre(self, arguments):
"""Option répondre"""
if not arguments or arguments.isspace():
self.pere.joueur << "|err|Vous devez préciser le numéro d'un " \
"message.|ff|"
return
mails = type(self).importeur.communication.mails.get_mails_pour(
self.pere.joueur, RECU)
try:
num = int(arguments.split(" ")[0])
except ValueError:
self.pere.joueur << "|err|Vous devez spécifier un nombre entier " \
"valide.|ff|"
else:
i = 1
r_mail = None
for mail in mails:
if num == i:
r_mail = mail
break
i += 1
if r_mail is None:
self.pere.joueur << "|err|Le numéro spécifié ne correspond à " \
"aucun message.|ff|"
return
mail = type(self).importeur.communication.mails.creer_mail(
self.pere.joueur)
mail.sujet = "RE:" + r_mail.sujet
mail.liste_dest.append(r_mail.expediteur)
mail.liste_dest = list(mail.liste_dest) + \
[d for d in r_mail.copies_a if not hasattr(d, "nom_alias")]
mail.aliases = list(mail.aliases) + \
[a for a in r_mail.copies_a if hasattr(a, "nom_alias")]
mail.contenu.ajouter_paragraphe(
r_mail.nom_expediteur + " a écrit :\n")
mail.contenu.ajouter_paragraphe(str(r_mail.contenu))
mail.contenu.ajouter_paragraphe("+------------------------------+")
enveloppe = EnveloppeObjet(EdtMedit, mail, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
contexte.opts.rci_ctx_prec = ""
self.pere.joueur.contextes.ajouter(contexte)
contexte.actualiser()
def opt_repondre(self, arguments):
"""Option répondre"""
if not arguments or arguments.isspace():
self.pere.joueur << "|err|Vous devez préciser le numéro d'un " \
"message.|ff|"
return
mails = type(self).importeur.communication.mails.get_mails_pour(
self.pere.joueur, RECU)
try:
num = int(arguments.split(" ")[0])
except ValueError:
self.pere.joueur << "|err|Vous devez spécifier un nombre entier " \
"valide.|ff|"
else:
i = 1
r_mail = None
for mail in mails:
if num == i:
r_mail = mail
break
i += 1
if r_mail is None:
self.pere.joueur << "|err|Le numéro spécifié ne correspond à " \
"aucun message.|ff|"
return
mail = type(self).importeur.communication.mails.creer_mail(
self.pere.joueur)
mail.sujet = "RE:" + r_mail.sujet
mail.liste_dest.append(r_mail.expediteur)
mail.liste_dest = list(mail.liste_dest) + \
[d for d in r_mail.copies_a if not hasattr(d, "nom_alias")]
mail.aliases = list(mail.aliases) + \
[a for a in r_mail.copies_a if hasattr(a, "nom_alias")]
mail.contenu.ajouter_paragraphe(r_mail.nom_expediteur +
" a écrit :\n")
mail.contenu.ajouter_paragraphe(str(r_mail.contenu))
mail.contenu.ajouter_paragraphe("+------------------------------+")
enveloppe = EnveloppeObjet(EdtMedit, mail, None)
enveloppe.parent = self
contexte = enveloppe.construire(self.pere.joueur)
contexte.opts.rci_ctx_prec = ""
self.pere.joueur.contextes.ajouter(contexte)
contexte.actualiser()
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
if msg == "q":
self.fermer()
self.pere.envoyer("Fermeture de l'éditeur de quêtes.")
else:
if msg in type(self).importeur.scripting.quetes.keys():
quete = type(self).importeur.scripting.quetes[msg]
elif RE_QUETE_VALIDE.search(msg) is None:
self.pere << "|err|Cette clé de quête est invalide.|ff|"
return
else:
quete = Quete(msg, self.personnage)
type(self).importeur.scripting.quetes[msg] = quete
enveloppe = EnveloppeObjet(EdtPresentation, quete, "")
enveloppe.parent = self
contexte = enveloppe.construire(self.personnage)
self.migrer_contexte(contexte)
def interpreter(self, msg):
"""Interprétation du message"""
msg = msg.lower()
if msg == "q":
self.fermer()
self.pere.envoyer("Fermeture de l'éditeur de quêtes.")
else:
if msg in type(self).importeur.scripting.quetes.keys():
quete = type(self).importeur.scripting.quetes[msg]
elif RE_QUETE_VALIDE.search(msg) is None:
self.pere << "|err|Cette clé de quête est invalide.|ff|"
return
else:
quete = Quete(msg, self.personnage)
type(self).importeur.scripting.quetes[msg] = quete
enveloppe = EnveloppeObjet(EdtPresentation, quete, "")
enveloppe.parent = self
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 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)