def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
sortie = dic_masques["nom_sortie"].sortie
salle = personnage.salle
nom_complet = sortie.nom_complet.capitalize()
personnage.agir("fermer")
if not sortie.porte:
raise ErreurInterpretation(
"|err|Cette sortie n'est pas une porte.|ff|")
if not sortie.porte.fermee:
raise ErreurInterpretation("Fermez-la avant de la verrouiller...")
if sortie.porte.verrouillee:
raise ErreurInterpretation("Cette porte est déjà fermée à clef.")
if not sortie.porte.serrure:
raise ErreurInterpretation("Cette porte n'a pas de serrure.")
if not sortie.porte.clef in [o.prototype for o in \
personnage.equipement.equipes] and not personnage.est_immortel():
raise ErreurInterpretation("Vous n'avez pas la clef.")
sortie.porte.verrouiller()
if personnage.est_immortel():
personnage << "Vos doigts étincellent un instant et un déclic " \
"de fermeture se fait entendre."
else:
personnage << "Vous tournez la clef dans la serrure et un pêne " \
"se met en place."
salle.envoyer("{{}} verrouille {}.".format(sortie.nom_complet),
personnage)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
sortie = dic_masques["nom_sortie"].sortie
salle = personnage.salle
nom_complet = sortie.nom_complet.capitalize()
personnage.agir("fermer")
if not sortie.porte:
raise ErreurInterpretation(
"|err|Cette sortie n'est pas une porte.|ff|")
if not sortie.porte.ouverte:
raise ErreurInterpretation(
"Cette porte est déjà fermée.".format(nom_complet))
sortie.porte.fermer()
personnage << "Vous fermez {}.".format(sortie.nom_complet)
salle.envoyer("{{}} ferme {}.".format(sortie.nom_complet), personnage)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
sortie = dic_masques["nom_sortie"].sortie
salle = personnage.salle
nom_complet = sortie.nom_complet.capitalize()
if not sortie.direction in ("bas", "haut") or not sortie.diff_escalade:
raise ErreurInterpretation(
"Vous n'avez pas besoin d'escalader dans cette direction.")
personnage.deplacer_vers(sortie.nom, escalade=True)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
nom_groupe = dic_masques["groupe1"].nom_groupe
groupe = type(self).importeur.interpreteur.groupes[nom_groupe]
nom_a_supprimer = dic_masques["groupe2"].nom_groupe
if nom_a_supprimer not in groupe.groupes_inclus:
raise ErreurInterpretation(
"|err|Le groupe {} n'est pas inclus dans {}.|ff|".format(
nom_a_supprimer, nom_groupe))
groupe.supprimer_groupe_inclus(nom_a_supprimer)
personnage << "Le groupe {} a bien été supprimé de {}.".format(
nom_a_supprimer, nom_groupe)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
sortie = dic_masques["nom_sortie"].sortie
salle = personnage.salle
nom_complet = sortie.nom_complet.capitalize()
personnage.agir("ouvrir")
if not sortie.porte:
raise ErreurInterpretation(
"|err|Cette sortie n'est pas une porte.|ff|")
if not sortie.porte.fermee:
raise ErreurInterpretation(
"Cette porte est déjà ouverte.|ff|".format(nom_complet))
if sortie.porte.verrouillee:
raise ErreurInterpretation(
"Cette porte semble fermée à clef.".format(nom_complet))
if not personnage.est_immortel() and not sortie.salle_dest.peut_entrer(
personnage):
raise ErreurInterpretation("Vous ne pouvez ouvrir cette porte.")
sortie.porte.ouvrir()
personnage << "Vous ouvrez {}.".format(sortie.nom_complet)
salle.envoyer("{{}} ouvre {}.".format(sortie.nom_complet), personnage)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
nom_groupe = dic_masques["groupe1"].nom_groupe
groupe = type(self).importeur.interpreteur.groupes[nom_groupe]
nom_a_inclure = dic_masques["groupe2"].nom_groupe
if nom_a_inclure in groupe.groupes_inclus:
raise ErreurInterpretation(
"|err|Le groupe {} est déjà inclus dans {}.|ff|".format(
nom_a_inclure, nom_groupe))
groupe.ajouter_groupe_inclus(nom_a_inclure)
personnage << "Le groupe {} a bien été ajouté dans {}.".format(
nom_a_inclure, nom_groupe)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
def n_exit(code, msg):
"""Ne quitte pas Python."""
raise ValueError(msg)
direction = dic_masques["direction"].direction
salle = personnage.salle
options = ""
if dic_masques["texte_libre"]:
options = dic_masques["texte_libre"].texte
# Création de l'interpréteur d'option
parser = argparse.ArgumentParser(conflict_handler='resolve')
parser.exit = n_exit
parser.add_argument("-t", "--titre", action="store_true")
parser.add_argument("-d", "--description", action="store_true")
parser.add_argument("-e", "--details", action="store_true")
parser.add_argument("-m", "--mnemonique")
parser.add_argument("-c", "--script", action="store_true")
parser.add_argument("-s", "--sorties", action="store_true")
parser.add_argument("-h", "--horizontales", action="store_true")
parser.add_argument("-v", "--verticales", action="store_true")
parser.add_argument("-r", "--sans-reciproque", action="store_true")
try:
args = parser.parse_args(shlex.split(options))
except ValueError as err:
personnage << "|err|Les options n'ont pas été interprétées " \
"correctement : {}.|ff|".format(err)
return
if args.mnemonique:
try:
zone, mnemonic = args.mnemonique.split(":")
except ValueError:
zone = salle.nom_zone
mnemonic = args.mnemonique
else:
zone = salle.nom_zone
mnemonic = salle.zone.chercher_mnemonic_libre(salle.mnemonic)
dir_opposee = salle.sorties.get_nom_oppose(direction)
if salle.sorties.sortie_existe(direction):
raise ErreurInterpretation(
"|err|Cette direction a déjà été définie dans la salle.|ff|")
nv_coords = getattr(salle.coords, direction.replace("-", ""))
if nv_coords.valide and nv_coords in type(self).importeur.salle:
raise ErreurInterpretation(
"|err|Ces coordonnées sont déjà utilisées.|ff|")
x, y, z, valide = nv_coords.tuple_complet()
try:
nv_salle = importeur.salle.creer_salle(zone, mnemonic, x, y, z,
valide)
except ValueError as err_val:
personnage << str(err_val) + "."
else:
if args.sans_reciproque:
salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=nv_salle,
corresp=None)
nv_salle.sorties.ajouter_sortie(dir_opposee,
dir_opposee,
salle_dest=salle,
corresp=None)
else:
salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=nv_salle,
corresp=dir_opposee)
nv_salle.sorties.ajouter_sortie(dir_opposee,
dir_opposee,
salle_dest=salle,
corresp=direction)
nv_salle.interieur = salle.interieur
nv_salle.illuminee = salle.illuminee
nv_salle.nom_terrain = salle.nom_terrain
if args.titre:
nv_salle.titre = salle.titre
if args.description:
nv_salle.description.copier_depuis(salle.description)
if args.details:
nv_salle.details.copier_depuis(salle.details, True)
if args.script:
nv_salle.script.copier_depuis(salle.script)
personnage << "|att|La salle {} a bien été ajouté vers {}.|ff|". \
format(nv_salle.ident, salle.sorties[direction].nom_complet)
sup = None
if args.sorties:
sup = SORTIES
elif args.horizontales:
sup = HORIZONTALES
elif args.verticales:
sup = VERTICALES
if sup:
if not nv_coords.valide:
personnage << "|err|La salle créée n'a pas de " \
"coordonnées valides.|ff|"
return
nb = 0
for direction, coords in sup.items():
n_x = x + coords[0]
n_y = y + coords[1]
n_z = z + coords[2]
dir_opposee = nv_salle.sorties.get_nom_oppose(direction)
salle = importeur.salle._coords.get((n_x, n_y, n_z))
if salle is None:
continue
if not salle.sorties.sortie_existe(dir_opposee) and not \
nv_salle.sorties.sortie_existe(direction):
nv_salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=salle,
corresp=dir_opposee)
salle.sorties.ajouter_sortie(dir_opposee,
dir_opposee,
salle_dest=nv_salle,
corresp=direction)
nb += 1
if nb > 0:
personnage << format_nb(nb, "{nb} sortie{s} " \
"supplémentaire{s} créée{s}.")
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
def n_exit(code, msg):
"""Ne quitte pas Python."""
raise ValueError(msg)
direction = dic_masques["direction"].direction
salle = personnage.salle
if dic_masques["ident_salle"]:
d_salle = dic_masques["ident_salle"].salle
elif salle.coords.valide:
d_coords = getattr(salle.coords, direction.replace("-", ""))
d_salle = importeur.salle._coords.get(d_coords.tuple())
if d_salle is None:
personnage << "|err|Impossible de trouver la salle " \
"dans la direction {} de coordonnées {}.|ff|".format(
direction, d_coords)
return
else:
personnage << "|err|La salle actuelle n'a pas de coordonnées " \
"valides.|ff|"
return
options = ""
if dic_masques["texte_libre"]:
options = dic_masques["texte_libre"].texte
# Création de l'interpréteur d'option
parser = argparse.ArgumentParser()
parser.exit = n_exit
parser.add_argument("-r", "--sans-reciproque", action="store_true")
try:
args = parser.parse_args(shlex.split(options))
except ValueError as err:
personnage << "|err|Les options n'ont pas été interprétées " \
"correctement : {}.|ff|".format(err)
return
dir_opposee = salle.sorties.get_nom_oppose(direction)
if salle.sorties.sortie_existe(direction):
raise ErreurInterpretation(
"|err|Cette direction a déjà été définie dans la salle " \
"courante.|ff|")
if not args.sans_reciproque and d_salle.sorties.sortie_existe(
dir_opposee):
raise ErreurInterpretation(
"|err|La direction opposée a déjà été définie dans {}.|ff|". \
format(d_salle.ident))
if salle is d_salle:
raise ErreurInterpretation(
"|err|La salle de destination est la même que la salle " \
"d'origine.|ff|")
if args.sans_reciproque:
salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=d_salle)
personnage << "|att|La sortie sans réciproque {} reliant " \
"{} à {} a été créée.|ff|".format(direction,
salle.ident, d_salle.ident)
return
salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=d_salle,
corresp=dir_opposee)
d_salle.sorties.ajouter_sortie(dir_opposee,
dir_opposee,
salle_dest=salle,
corresp=direction)
personnage << "|att|La sortie {} reliant {} à {} a été créée.\n" \
"La réciproque a été créée également (sortie {} dans " \
"{}).|ff|".format(direction, salle.ident, d_salle.ident,
dir_opposee, d_salle.ident)