def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande."""
if dic_masques["cle"]:
cle = dic_masques["cle"].cle
if cle not in importeur.scripting.structures:
personnage << "|err|Groupe {} inconnu.|ff|".format(repr(cle))
return
groupe = importeur.scripting.structures[cle]
tableau = Tableau("Structures du groupe " + cle)
tableau.ajouter_colonne("Groupe")
tableau.ajouter_colonne("ID", DROITE)
tableau.ajouter_colonne("Champs", DROITE)
structures = sorted(list(groupe.values()), key=lambda s: s.id)
for structure in structures:
tableau.ajouter_ligne(cle, structure.id,
len(structure.donnees))
personnage << tableau.afficher()
else:
groupes = importeur.scripting.structures.items()
tableau = Tableau("Groupes de structure actuels")
tableau.ajouter_colonne("Groupe")
tableau.ajouter_colonne("Nombre", DROITE)
for cle, structures in sorted(tuple(groupes)):
tableau.ajouter_ligne(cle, len(structures))
personnage << tableau.afficher()
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, personnage, dic_masques):
"""Méthode d'interprétation de commande."""
if dic_masques["cle"]:
cle = dic_masques["cle"].cle
if cle not in importeur.scripting.structures:
personnage << "|err|Groupe {} inconnu.|ff|".format(
repr(cle))
return
groupe = importeur.scripting.structures[cle]
tableau = Tableau("Structures du groupe " + cle)
tableau.ajouter_colonne("Groupe")
tableau.ajouter_colonne("ID", DROITE)
tableau.ajouter_colonne("Champs", DROITE)
structures = sorted(list(groupe.values()), key=lambda s: s.id)
for structure in structures:
tableau.ajouter_ligne(cle, structure.id,
len(structure.donnees))
personnage << tableau.afficher()
else:
groupes = importeur.scripting.structures.items()
tableau = Tableau("Groupes de structure actuels")
tableau.ajouter_colonne("Groupe")
tableau.ajouter_colonne("Nombre", DROITE)
for cle, structures in sorted(tuple(groupes)):
tableau.ajouter_ligne(cle, len(structures))
personnage << tableau.afficher()
def afficher_resume(self, personnage):
"""Affiche le résumé par groupe de module."""
noms = list(importeur.__dict__.keys())
noms.sort()
tableau = Tableau("Collections par module")
tableau.ajouter_colonne("Module")
tableau.ajouter_colonne("Collections", DROITE)
for nom in noms:
classes = [classe for classe in importeur.supenr.mongo_objets if \
classe.split(".")[1] == nom]
tableau.ajouter_ligne(nom, len(classes))
personnage << tableau.afficher()
def afficher_resume(self, personnage):
"""Affiche le résumé par groupe de module."""
noms = list(importeur.__dict__.keys())
noms.sort()
tableau = Tableau("Collections par module")
tableau.ajouter_colonne("Module")
tableau.ajouter_colonne("Collections", DROITE)
for nom in noms:
classes = [classe for classe in importeur.supenr.mongo_objets if \
classe.split(".")[1] == nom]
tableau.ajouter_ligne(nom, len(classes))
personnage << tableau.afficher()
def afficher(self, personnage):
"""Affichage du magasin en jeu"""
services = sorted(self.inventaire, key=lambda s: s[0].m_valeur)
tableau = Tableau("|cy|" + self.nom + "|ff|")
tableau.ajouter_colonne("|tit|ID|ff|")
tableau.ajouter_colonne("|tit|Nom|ff|")
tableau.ajouter_colonne("|tit|Prix|ff|")
tableau.ajouter_colonne("|tit|Quantité|ff|")
if services:
i = 1
for ligne in services:
service, quantite = ligne
nom = service.nom_achat
prix = service.m_valeur
tableau.ajouter_ligne("#" + str(i), nom, prix, quantite)
i += 1
else:
msg = str(tableau)
lignes = msg.splitlines()
largeur = tableau.calculer_largeur()
lignes.insert(-2, "| |att|" + "Aucun produit n'est en " \
"vente actuellement.".ljust(largeur - 4) + "|ff| |")
return "\n".join(lignes)
return tableau.afficher()
def afficher(self, personnage):
"""Affichage du magasin en jeu"""
services = sorted(self.inventaire, key=lambda s: s[0].m_valeur)
tableau = Tableau("|cy|" + self.nom + "|ff|")
tableau.ajouter_colonne("|tit|ID|ff|")
tableau.ajouter_colonne("|tit|Nom|ff|")
tableau.ajouter_colonne("|tit|Prix|ff|")
tableau.ajouter_colonne("|tit|Quantité|ff|")
if services:
i = 1
for ligne in services:
service, quantite = ligne
nom = service.nom_achat
prix = service.m_valeur
tableau.ajouter_ligne("#" + str(i), nom, prix, quantite)
i += 1
else:
msg = str(tableau)
lignes = msg.splitlines()
largeur = tableau.calculer_largeur()
lignes.insert(-2, "| |att|" + "Aucun produit n'est en " \
"vente actuellement.".ljust(largeur - 4) + "|ff| |")
return "\n".join(lignes)
return tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
cle = dic_masques["cle"].cle
if cle not in importeur.auberge.auberges:
personnage << "|err|L'auberge {} n'existe pas.|ff|".format(cle)
return
auberge = importeur.auberge.auberges[cle]
# Créqation du tableau
msg = "Informations sur l'auberge {} :".format(auberge.cle)
msg += "\n Nom : {}".format(auberge.titre)
msg += "\n Comptoir : {}".format(auberge.comptoir)
msg += "\n Aubergiste : {}".format(auberge.cle_aubergiste)
if auberge.aubergiste:
msg += " (présent)"
else:
msg += " |att|(absent)|ff|"
msg += "\n Nombre de chambres : {} ({} salles)".format(
len(auberge.chambres), len(auberge.salles))
msg += "\n Pourcentage d'occupation : {}%".format(
auberge.pct_occupation)
# Tableau des chambres
tableau = Tableau("Chambres de l'auberge")
tableau.ajouter_colonne("Numéro")
tableau.ajouter_colonne("Salle")
tableau.ajouter_colonne("Prix", DROITE)
tableau.ajouter_colonne("Propriétaire")
tableau.ajouter_colonne("Expire")
chambres = sorted(list(auberge.chambres.values()),
key=lambda c: c.numero)
for chambre in chambres:
numero = chambre.numero
salle = chambre.salle
prix = chambre.prix_par_jour
if chambre.proprietaire:
proprietaire = chambre.proprietaire.nom
date = chambre.expire_a
annee = date.year
mois = date.month
jour = date.day
heure = date.hour
minute = date.minute
expire = "{}-{:>02}-{:>02} {:>02}:{:>02}".format(
annee, mois, jour, heure, minute)
else:
proprietaire = "Aucun"
expire = ""
tableau.ajouter_ligne(numero, salle, prix, proprietaire, expire)
msg += "\n\n" + tableau.afficher()
personnage << msg
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
cle = dic_masques["cle"].cle
if cle not in importeur.auberge.auberges:
personnage << "|err|L'auberge {} n'existe pas.|ff|".format(cle)
return
auberge = importeur.auberge.auberges[cle]
# Créqation du tableau
msg = "Informations sur l'auberge {} :".format(auberge.cle)
msg += "\n Nom : {}".format(auberge.titre)
msg += "\n Comptoir : {}".format(auberge.comptoir)
msg += "\n Aubergiste : {}".format(auberge.cle_aubergiste)
if auberge.aubergiste:
msg += " (présent)"
else:
msg += " |att|(absent)|ff|"
msg += "\n Nombre de chambres : {} ({} salles)".format(
len(auberge.chambres), len(auberge.salles))
msg += "\n Pourcentage d'occupation : {}%".format(
auberge.pct_occupation)
# Tableau des chambres
tableau = Tableau("Chambres de l'auberge")
tableau.ajouter_colonne("Numéro")
tableau.ajouter_colonne("Salle")
tableau.ajouter_colonne("Prix", DROITE)
tableau.ajouter_colonne("Propriétaire")
tableau.ajouter_colonne("Expire")
chambres = sorted(list(auberge.chambres.values()),
key=lambda c: c.numero)
for chambre in chambres:
numero = chambre.numero
salle = chambre.salle
prix = chambre.prix_par_jour
if chambre.proprietaire:
proprietaire = chambre.proprietaire.nom
date = chambre.expire_a
annee = date.year
mois = date.month
jour = date.day
heure = date.hour
minute = date.minute
expire = "{}-{:>02}-{:>02} {:>02}:{:>02}".format(
annee, mois, jour, heure, minute)
else:
proprietaire = "Aucun"
expire = ""
tableau.ajouter_ligne(numero, salle, prix, proprietaire, expire)
msg += "\n\n" + tableau.afficher()
personnage << msg
def afficher_table(self, personnage, nb):
"""Affiche la table des enregistrements."""
mtn = time.time()
if nb < 1 or nb > 100:
personnage << "|err|Le nombre entré est invalide, " \
"trop grand ou trop petit.|ff|"
return
# Affichage du tableau
tableau = Tableau("Table d'enregistrement")
tableau.ajouter_colonne("Il y a")
tableau.ajouter_colonne("Classe")
tableau.ajouter_colonne("Objet")
for temps, classe, _id in importeur.supenr.mongo_table[-nb:]:
temps = round((mtn - temps), 3)
temps = str(temps).replace(".", ",") + "s"
tableau.ajouter_ligne(temps, classe, str(_id))
personnage << tableau.afficher()
def afficher_table(self, personnage, nb):
"""Affiche la table des enregistrements."""
mtn = time.time()
if nb < 1 or nb > 100:
personnage << "|err|Le nombre entré est invalide, " \
"trop grand ou trop petit.|ff|"
return
# Affichage du tableau
tableau = Tableau("Table d'enregistrement")
tableau.ajouter_colonne("Il y a")
tableau.ajouter_colonne("Classe")
tableau.ajouter_colonne("Objet")
for temps, classe, _id in importeur.supenr.mongo_table[-nb:]:
temps = round((mtn - temps), 3)
temps = str(temps).replace(".", ",") + "s"
tableau.ajouter_ligne(temps, classe, str(_id))
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
fiches = tuple(importeur.familier.fiches.values())
fiches = sorted(fiches, key=lambda f: f.cle)
if len(fiches) == 0:
personnage << "|att|Aucune fiche de familier définie.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Nombre", DROITE)
for fiche in fiches:
if fiche.prototype:
nom = fiche.prototype.nom_singulier
else:
nom = "aucun prototype"
tableau.ajouter_ligne(fiche.cle, nom, len(fiche.familiers))
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
fiches = tuple(importeur.familier.fiches.values())
fiches = sorted(fiches, key=lambda f: f.cle)
if len(fiches) == 0:
personnage << "|att|Aucune fiche de familier définie.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Nombre", DROITE)
for fiche in fiches:
if fiche.prototype:
nom = fiche.prototype.nom_singulier
else:
nom = "aucun prototype"
tableau.ajouter_ligne(fiche.cle, nom, len(fiche.familiers))
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
cle = dic_masques["cle"].cle
if cle not in importeur.crafting.guildes:
personnage << "|err|La guilde {} n'existe " \
"pas.|ff|".format(cle)
return
guilde = importeur.crafting.guildes[cle]
membres = []
for rang in guilde.rangs:
membres_du_rang = []
progressions = [
p for p in guilde.membres.values()
if p.rang is rang and not hasattr(p.membre, "prototype")
]
for progression in progressions:
membres_du_rang.append((progression.membre.nom, rang.nom,
progression.progression))
membres_du_rang.sort(key=lambda c: c[2])
membres.extend(membres_du_rang)
tableau = Tableau()
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Rang")
tableau.ajouter_colonne("Avancement", DROITE)
for nom, rang, avancement in membres:
tableau.ajouter_ligne(nom, rang, "{}%".format(avancement))
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande."""
if dic_masques["cle"]:
cle = dic_masques["cle"].cle
if cle not in importeur.evt.evenements:
personnage << "|err|Évènement {} inconnu.|ff|".format(
repr(cle))
return
evt = importeur.evt.evenements[cle]
if personnage in evt.inscrits:
evt.inscrits.remove(personnage)
personnage << "Vous êtes désinscrit de l'évènement {}.".format(
cle)
else:
evt.inscrits.append(personnage)
personnage << "Vous êtes inscrit à l'évènement {}.".format(
cle)
return
tableau = Tableau()
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Aide")
tableau.ajouter_colonne("Inscrit")
for evt in sorted(importeur.evt.evenements.values(),
key=lambda e: e.cle):
inscrit = oui_ou_non(personnage in evt.inscrits)
tableau.ajouter_ligne(evt.cle, evt.aide, inscrit)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
if dic_masques["cle"]:
cle = dic_masques["cle"].cle
classe = None
for t_classe in importeur.meteo.perturbations:
if t_classe.nom_pertu == cle and t_classe.origine:
classe = t_classe
break
if classe is None:
personnage << "|err|Cette perturbation n'existe pas.|ff|"
return
if not personnage.salle.coords.valide:
personnage << "|err|Vous vous trouvez dans une salle sans " \
"coordonnées.|ff|"
return
n_pertu = classe(personnage.salle.coords.get_copie())
for pertu in importeur.meteo.perturbations_actuelles:
if n_pertu.va_recouvrir(pertu):
personnage << "|err|Une autre perturbation est trop " \
"proche de vous.|ff|"
n_pertu.detruire()
return
personnage << "Vous avez bien créé une nouvelle perturbation " \
"{}.".format(n_pertu.nom_pertu)
importeur.meteo.perturbations_actuelles.append(n_pertu)
n_pertu.envoyer_message_debut()
else:
tableau = Tableau("Perturbations existantes")
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Attributs")
for perturbation in sorted(importeur.meteo.perturbations,
key=lambda p: p.nom_pertu):
attributs = ", ".join(perturbation.attributs)
tableau.ajouter_ligne(perturbation.nom_pertu, attributs)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
if dic_masques["cle"]:
cle = dic_masques["cle"].cle
classe = None
for t_classe in importeur.meteo.perturbations:
if t_classe.nom_pertu == cle and t_classe.origine:
classe = t_classe
break
if classe is None:
personnage << "|err|Cette perturbation n'existe pas.|ff|"
return
if not personnage.salle.coords.valide:
personnage << "|err|Vous vous trouvez dans une salle sans " \
"coordonnées.|ff|"
return
n_pertu = classe(personnage.salle.coords.get_copie())
for pertu in importeur.meteo.perturbations_actuelles:
if n_pertu.va_recouvrir(pertu):
personnage << "|err|Une autre perturbation est trop " \
"proche de vous.|ff|"
n_pertu.detruire()
return
personnage << "Vous avez bien créé une nouvelle perturbation " \
"{}.".format(n_pertu.nom_pertu)
importeur.meteo.perturbations_actuelles.append(n_pertu)
n_pertu.envoyer_message_debut()
else:
tableau = Tableau("Perturbations existantes")
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Attributs")
for perturbation in sorted(importeur.meteo.perturbations,
key=lambda p: p.nom_pertu):
attributs = ", ".join(perturbation.attributs)
tableau.ajouter_ligne(perturbation.nom_pertu, attributs)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
tags = tuple(importeur.tags.tags.values())
groupes = {}
for tag in tags:
if tag.type not in groupes:
groupes[tag.type] = []
groupe = groupes[tag.type]
groupe.append(tag)
groupe.sort(key=lambda t: t.cle)
if len(tags) == 0:
personnage << "|att|Aucun tag défini.|ff|"
return
tableau = Tableau("Tags définis")
tableau.ajouter_colonne("Type")
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Lignes", DROITE)
for cle, groupe in sorted(groupes.items()):
for tag in groupe:
nb_lignes = sum(e.nb_lignes for e in \
tag.script.evenements.values())
tableau.ajouter_ligne(tag.type, tag.cle, nb_lignes)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
cle = dic_masques["cle"].cle
if cle not in importeur.crafting.guildes:
personnage << "|err|La guilde {} n'existe " \
"pas.|ff|".format(cle)
return
guilde = importeur.crafting.guildes[cle]
membres = []
for rang in guilde.rangs:
membres_du_rang = []
progressions = [p for p in guilde.membres.values()
if p.rang is rang and not hasattr(p.membre,
"prototype")]
for progression in progressions:
membres_du_rang.append((progression.membre.nom, rang.nom,
progression.progression))
membres_du_rang.sort(key=lambda c: c[2])
membres.extend(membres_du_rang)
tableau = Tableau()
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Rang")
tableau.ajouter_colonne("Avancement", DROITE)
for nom, rang, avancement in membres:
tableau.ajouter_ligne(nom, rang, "{}%".format(avancement))
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande."""
cle = dic_masques["cle"].cle
nombre = dic_masques["nombre"].nombre
if cle not in importeur.scripting.structures:
personnage << "|err|Groupe {} inconnu.|ff|".format(
repr(cle))
return
groupe = importeur.scripting.structures[cle]
structure = groupe.get(nombre)
if structure is None:
personnage << "|err|La structure de groupe {} et d'ID " \
"{} n'existe pas.|ff|".format(repr(cle), nombre)
return
tableau = Tableau("Détail de la structure {} {} :".format(cle, nombre))
tableau.ajouter_colonne("Case")
tableau.ajouter_colonne("Valeur")
donnees = sorted(tuple(structure.donnees.items()))
for champ, valeur in donnees:
if isinstance(valeur, StructureComplete):
valeur = valeur.structure + " " + str(valeur.id)
elif isinstance(valeur, bool):
valeur = "vrai" if valeur else "faux"
elif isinstance(valeur, list):
liste = []
for element in valeur:
if isinstance(element, StructureComplete):
element = element.structure + " " + str(element.id)
liste.append(element)
valeur = liste
tableau.ajouter_ligne(champ, valeur)
personnage << tableau.afficher()
def afficher_module(self, personnage, nom):
"""Affiche les classes du module indiqué."""
mtn = time.time()
classes = [classe for classe in importeur.supenr.mongo_objets if \
classe.split(".")[1] == nom]
classes.sort()
if classes:
tableau = Tableau("Collections du module {}".format(nom))
tableau.ajouter_colonne("Collection")
tableau.ajouter_colonne("Objets", DROITE)
tableau.ajouter_colonne("Enregistrement")
for classe in classes:
objets = []
o_classe = classes_base[classe]
noms_classe = []
for nom, cls in classes_base.items():
if issubclass(cls, o_classe):
noms_classe.append(nom)
objets.extend(
list(
importeur.supenr.mongo_objets.get(
nom, {}).values()))
objets = len(objets)
print(noms_classe)
dernieres = [l for l in importeur.supenr.mongo_table if \
l[1] in noms_classe]
if dernieres:
derniere = dernieres[-1]
temps = derniere[0]
temps = round((mtn - temps), 3)
temps = "{} secondes".format(str(temps).replace(".", ","))
else:
temps = "inconnu"
tableau.ajouter_ligne(classe, objets, temps)
personnage << tableau.afficher()
else:
personnage << "Il n'y a aucun objet enregistré dans ce module."
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande."""
cle = dic_masques["cle"].cle
nombre = dic_masques["nombre"].nombre
if cle not in importeur.scripting.structures:
personnage << "|err|Groupe {} inconnu.|ff|".format(repr(cle))
return
groupe = importeur.scripting.structures[cle]
structure = groupe.get(nombre)
if structure is None:
personnage << "|err|La structure de groupe {} et d'ID " \
"{} n'existe pas.|ff|".format(repr(cle), nombre)
return
tableau = Tableau("Détail de la structure {} {} :".format(cle, nombre))
tableau.ajouter_colonne("Case")
tableau.ajouter_colonne("Valeur")
donnees = sorted(tuple(structure.donnees.items()))
for champ, valeur in donnees:
if isinstance(valeur, StructureComplete):
valeur = valeur.structure + " " + str(valeur.id)
elif isinstance(valeur, bool):
valeur = "vrai" if valeur else "faux"
elif isinstance(valeur, list):
liste = []
for element in valeur:
if isinstance(element, StructureComplete):
element = element.structure + " " + str(element.id)
liste.append(element)
valeur = liste
tableau.ajouter_ligne(champ, valeur)
personnage << tableau.afficher()
def afficher_module(self, personnage, nom):
"""Affiche les classes du module indiqué."""
mtn = time.time()
classes = [classe for classe in importeur.supenr.mongo_objets if \
classe.split(".")[1] == nom]
classes.sort()
if classes:
tableau = Tableau("Collections du module {}".format(nom))
tableau.ajouter_colonne("Collection")
tableau.ajouter_colonne("Objets", DROITE)
tableau.ajouter_colonne("Enregistrement")
for classe in classes:
objets = []
o_classe = classes_base[classe]
noms_classe = []
for nom, cls in classes_base.items():
if issubclass(cls, o_classe):
noms_classe.append(nom)
objets.extend(list(importeur.supenr.mongo_objets.get(
nom, {}).values()))
objets = len(objets)
print(noms_classe)
dernieres = [l for l in importeur.supenr.mongo_table if \
l[1] in noms_classe]
if dernieres:
derniere = dernieres[-1]
temps = derniere[0]
temps = round((mtn - temps), 3)
temps = "{} secondes".format(str(temps).replace(".", ","))
else:
temps = "inconnu"
tableau.ajouter_ligne(classe, objets, temps)
personnage << tableau.afficher()
else:
personnage << "Il n'y a aucun objet enregistré dans ce module."
def accueil(self):
"""Retourne l'aide courte"""
objet = getattr(self.objet, self.attribut)
objet = objet or self.nouveau
if isinstance(objet, dict):
lignes = []
for cle, valeur in objet.items():
if isinstance(valeur, (tuple, list)):
lignes.append([cle] + list(valeur))
else:
lignes.append([cle, valeur])
else:
lignes = list(objet)
if lignes:
# Constitution du tableau
tableau = AffTableau()
for nom, n_type in self.colonnes:
alignement = GAUCHE
if n_type in ("entier", "flottant"):
alignement = DROITE
tableau.ajouter_colonne(nom.capitalize(),
alignement=alignement)
# Parcourt des lignes
for ligne in lignes:
# Transformation de l'affichage
for indice, rempl in self.affichage.items():
ligne[indice] = rempl.get(ligne[indice], "")
tableau.ajouter_ligne(*ligne)
valeur = "\n" + tableau.afficher()
else:
valeur = "|att|\nAucune donnée à afficher pour l'instant|ff|"
return self.aide_courte.format(objet=objet, valeur=valeur)
def accueil(self):
"""Retourne l'aide courte"""
objet = getattr(self.objet, self.attribut)
objet = objet or self.nouveau
if isinstance(objet, dict):
lignes = []
for cle, valeur in objet.items():
if isinstance(valeur, (tuple, list)):
lignes.append([cle] + list(valeur))
else:
lignes.append([cle, valeur])
else:
lignes = list(objet)
if lignes:
# Constitution du tableau
tableau = AffTableau()
for nom, n_type in self.colonnes:
alignement = GAUCHE
if n_type in ("entier", "flottant"):
alignement = DROITE
tableau.ajouter_colonne(nom.capitalize(),
alignement=alignement)
# Parcourt des lignes
for ligne in lignes:
# Transformation de l'affichage
for indice, rempl in self.affichage.items():
ligne[indice] = rempl.get(ligne[indice], "")
tableau.ajouter_ligne(*ligne)
valeur = "\n" + tableau.afficher()
else:
valeur = "|att|\nAucune donnée à afficher pour l'instant|ff|"
return self.aide_courte.format(objet=objet, valeur=valeur)
def extraire_historique(self, personnage, lignes=10, titre=None):
"""Extrait l'historique pour le joueur."""
titre = titre or "Vos dernières conversations"
messages = self.messages.get(personnage, [])
if len(messages) == 0:
raise ValueError(
"Il n'y a aucun message pour {}".format(personnage))
messages = messages[-lignes:]
tableau = Tableau("|tit|" + titre + "|ff|", CENTRE)
tableau.ajouter_colonne("|tit|Il y a|ff|")
tableau.ajouter_colonne("|tit|Canal|ff|")
tableau.ajouter_colonne("|tit|Nom|ff|")
tableau.ajouter_colonne("|tit|Message|ff|")
for date, auteur, canal, message in messages:
delta = datetime.datetime.now() - date
secondes = delta.total_seconds()
duree = 0
unite = "seconde"
msg_duree = None
if secondes < 5:
msg_duree = "quelques secondes"
elif secondes < 60:
duree = secondes // 5 * 5
elif secondes < 300:
duree = secondes // 60
unite = "minute"
elif secondes < 3600:
duree = secondes / 60 // 5 * 5
unite = "minute"
elif secondes < 86400:
duree = secondes // 3600
unite = "heure"
else:
duree = secondes // 86400
unite = "jour"
s = "s" if duree > 1 else ""
if msg_duree is None:
msg_duree = "{} {}{s}".format(int(duree), unite, s=s)
tableau.ajouter_ligne(msg_duree, canal, auteur.nom, message)
return tableau
def extraire_historique(self, personnage, lignes=10, titre=None):
"""Extrait l'historique pour le joueur."""
titre = titre or "Vos dernières conversations"
messages = self.messages.get(personnage, [])
if len(messages) == 0:
raise ValueError("Il n'y a aucun message pour {}".format(
personnage))
messages = messages[-lignes:]
tableau = Tableau("|tit|" + titre + "|ff|", CENTRE)
tableau.ajouter_colonne("|tit|Il y a|ff|")
tableau.ajouter_colonne("|tit|Canal|ff|")
tableau.ajouter_colonne("|tit|Nom|ff|")
tableau.ajouter_colonne("|tit|Message|ff|")
for date, auteur, canal, message in messages:
delta = datetime.datetime.now() - date
secondes = delta.total_seconds()
duree = 0
unite = "seconde"
msg_duree = None
if secondes < 5:
msg_duree = "quelques secondes"
elif secondes < 60:
duree = secondes // 5 * 5
elif secondes < 300:
duree = secondes // 60
unite = "minute"
elif secondes < 3600:
duree = secondes / 60 // 5 * 5
unite = "minute"
elif secondes < 86400:
duree = secondes // 3600
unite = "heure"
else:
duree = secondes // 86400
unite = "jour"
s = "s" if duree > 1 else ""
if msg_duree is None:
msg_duree = "{} {}{s}".format(int(duree), unite, s=s)
tableau.ajouter_ligne(msg_duree, canal, auteur.nom, message)
return tableau
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
diligences = list(importeur.diligence.diligences.values())
diligences = sorted(diligences, key=lambda d: d.cle)
if len(diligences) == 0:
personnage << "|att|Aucune diligence maudite définie.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Ouverte")
tableau.ajouter_colonne("Salles", DROITE)
tableau.ajouter_colonne("Nombre en jeu", DROITE)
for diligence in diligences:
zones = [z for z in importeur.salle.zones.values() if \
z.cle.startswith(diligence.cle + "_")]
nb = len(zones)
tableau.ajouter_ligne(diligence.cle, oui_ou_non(
diligence.ouverte), len(diligence.salles), nb)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
diligences = list(importeur.diligence.diligences.values())
diligences = sorted(diligences, key=lambda d: d.cle)
if len(diligences) == 0:
personnage << "|att|Aucune diligence maudite définie.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Ouverte")
tableau.ajouter_colonne("Salles", DROITE)
tableau.ajouter_colonne("Nombre en jeu", DROITE)
for diligence in diligences:
zones = [z for z in importeur.salle.zones.values() if \
z.cle.startswith(diligence.cle + "_")]
nb = len(zones)
tableau.ajouter_ligne(diligence.cle, oui_ou_non(diligence.ouverte),
len(diligence.salles), nb)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande."""
routes = list(importeur.route.routes.values())
routes.sort(key=lambda t: t.ident)
if not routes:
personnage << "|att|Aucune route n'a été créée.|ff|"
return
tableau = Tableau("Routes existantes")
tableau.ajouter_colonne("ID", DROITE)
tableau.ajouter_colonne("Origine")
tableau.ajouter_colonne("Destination")
tableau.ajouter_colonne("Taille", DROITE)
for i, route in enumerate(routes):
origine = route.origine
origine = origine.ident if origine else "|att|inconnue|ff|"
destination = route.destination
destination = destination.ident if destination else \
"|att|inconnue|ff|"
tableau.ajouter_ligne(i + 1, origine, destination,
str(len(route.salles)))
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
familiers = importeur.familier.familiers_de(personnage)
familiers = sorted(familiers, key=lambda familier: familier.nom)
if len(familiers) == 0:
personnage << "Vous ne possédez aucun familier."
return
tableau = Tableau()
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Lieu")
tableau.ajouter_colonne("Faim")
tableau.ajouter_colonne("Soif")
for familier in familiers:
tableau.ajouter_ligne(familier.nom, familier.titre_salle,
familier.str_faim, familier.str_soif)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
familiers = importeur.familier.familiers_de(personnage)
familiers = sorted(familiers, key=lambda familier: familier.nom)
if len(familiers) == 0:
personnage << "Vous ne possédez aucun familier."
return
tableau = Tableau()
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Lieu")
tableau.ajouter_colonne("Faim")
tableau.ajouter_colonne("Soif")
for familier in familiers:
tableau.ajouter_ligne(familier.nom, familier.titre_salle,
familier.str_faim, familier.str_soif)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
guildes = tuple(importeur.crafting.guildes.values())
guildes = sorted([g for g in guildes], key=lambda g: g.cle)
if len(guildes) == 0:
personnage << "|att|Aucune guilde définie.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Ateliers", DROITE)
tableau.ajouter_colonne("Membres", DROITE)
for guilde in guildes:
tableau.ajouter_ligne(guilde.cle, guilde.nom, len(guilde.ateliers),
len(guilde.membres))
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
guildes = tuple(importeur.crafting.guildes.values())
guildes = sorted([g for g in guildes], key=lambda g: g.cle)
if len(guildes) == 0:
personnage << "|att|Aucune guilde définie.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Clé")
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Ateliers", DROITE)
tableau.ajouter_colonne("Membres", DROITE)
for guilde in guildes:
tableau.ajouter_ligne(guilde.cle, guilde.nom,
len(guilde.ateliers), len(guilde.membres))
personnage << tableau.afficher()
def afficher_collection(self, personnage, nom):
"""Affiche la collection indiquée."""
tableau = Tableau("Détail de la collection {}".format(nom))
tableau.ajouter_colonne("Collection")
tableau.ajouter_colonne("Objet")
tableau.ajouter_colonne("Champs", DROITE)
objets = []
noms_objet = []
o_classe = classes_base[nom]
for nom, cls in classes_base.items():
if issubclass(cls, o_classe):
for _id, objet in importeur.supenr.mongo_objets.get(
nom, {}).items():
if objet.e_existe:
noms_objet.append((nom, str(_id), len(objet.__dict__)))
noms_objet.sort()
for nom, _id, attributs in noms_objet:
tableau.ajouter_ligne(nom, _id, attributs)
personnage << tableau.afficher()
def afficher_collection(self, personnage, nom):
"""Affiche la collection indiquée."""
tableau = Tableau("Détail de la collection {}".format(nom))
tableau.ajouter_colonne("Collection")
tableau.ajouter_colonne("Objet")
tableau.ajouter_colonne("Champs", DROITE)
objets = []
noms_objet = []
o_classe = classes_base[nom]
for nom, cls in classes_base.items():
if issubclass(cls, o_classe):
for _id, objet in importeur.supenr.mongo_objets.get(
nom, {}).items():
if objet.e_existe:
noms_objet.append((nom, str(_id), len(
objet.__dict__)))
noms_objet.sort()
for nom, _id, attributs in noms_objet:
tableau.ajouter_ligne(nom, _id, attributs)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
salle = personnage.salle
if not hasattr(salle, "navire"):
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
equipage = navire.equipage
if not navire.a_le_droit(personnage, "officier"):
personnage << "|err|Vous ne pouvez donner d'ordre sur ce " \
"navire.|ff|"
return
matelots = tuple((m, m.nom_poste) for m in \
equipage.matelots.values())
matelots += tuple(equipage.joueurs.items())
matelots = sorted(matelots, \
key=lambda couple: ORDRE.index(couple[1]), reverse=True)
if len(matelots) == 0:
personnage << "|err|Votre équipage ne comprend aucun matelot.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Poste")
tableau.ajouter_colonne("Affectation")
for matelot, nom_poste in matelots:
nom = matelot.nom
nom_poste = nom_poste.capitalize()
titre = "Aucune"
if hasattr(matelot, "personnage"):
titre = matelot.personnage.salle.titre_court.capitalize()
tableau.ajouter_ligne(nom, nom_poste, titre)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
salle = personnage.salle
if not hasattr(salle, "navire"):
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
equipage = navire.equipage
if not navire.a_le_droit(personnage, "officier"):
personnage << "|err|Vous ne pouvez donner d'ordre sur ce " \
"navire.|ff|"
return
matelots = tuple((m, m.nom_poste) for m in \
equipage.matelots.values())
matelots += tuple(equipage.joueurs.items())
matelots = sorted(matelots, \
key=lambda couple: ORDRE.index(couple[1]), reverse=True)
if len(matelots) == 0:
personnage << "|err|Votre équipage ne comprend aucun matelot.|ff|"
return
tableau = Tableau()
tableau.ajouter_colonne("Nom")
tableau.ajouter_colonne("Poste")
tableau.ajouter_colonne("Affectation")
for matelot, nom_poste in matelots:
nom = matelot.nom
nom_poste = nom_poste.capitalize()
titre = "Aucune"
if hasattr(matelot, "personnage"):
titre = matelot.personnage.salle.titre_court.capitalize()
tableau.ajouter_ligne(nom, nom_poste, titre)
personnage << tableau.afficher()
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
def n_exit(code, msg):
"""Ne quitte pas Python."""
raise ValueError(msg)
cle = dic_masques["cle"].cle
try:
tag = importeur.tags.tags[cle]
except KeyError:
personnage << "|err|Ce tag n'existe pas.|ff|"
return
if not dic_masques["texte_libre"]:
tableau = Tableau("Évènements du tag {} de type {}".format(
tag.cle, tag.type))
tableau.ajouter_colonne("Évènement")
tableau.ajouter_colonne("Lignes")
for evt in tag.script.evenements.values():
tableau.ajouter_ligne(evt.nom, evt.nb_lignes)
personnage << tableau.afficher()
return
texte = dic_masques["texte_libre"].texte
parser = argparse.ArgumentParser(conflict_handler='resolve')
parser.exit = n_exit
# Ajout des options
parser.add_argument("objet")
parser.add_argument("evenement")
try:
args = parser.parse_args(shlex.split(texte))
except ValueError as err:
personnage << "|err|Les options n'ont pas été interprétées " \
"correctement : {}.|ff|".format(err)
return
# Lecture des options
objet = args.objet
evenement = args.evenement
# Récupération de l'objet du bon type
try:
objet = importeur.tags.cles[tag.type][objet]
except KeyError:
personnage << "|err|Clé de type {} {} introuvable.|ff|".format(
tag.type, repr(objet))
return
# Copie des évènements
evenements = objet.script.evenements
if evenement is "*":
evenements = [e for e in evenements.values() if e.nb_lignes]
else:
morceaux = evenement.split(".")
for morceau in morceaux:
try:
evt = evenements[morceau]
except KeyError:
personnage << "L'évènement {} dans {} ne peut " \
"être trouvé.|ff|".format(repr(morceau),
repr(evenement))
return
else:
evenements = evt.evenements
evenements = [evt]
# Copie des évènements sélectionnés
for evenement in evenements:
personnage << "Copie de l'évènement {} ({} lignes).".format(
evenement.nom, evenement.nb_lignes)
if evenement.nb_lignes == 0:
continue
tag.copier_evenement(evenement)
def trouver_depuis_chaine(cls, chaine):
"""Retourne un message en fonction de la chaîne passée en paramètre."""
def n_exit(code, msg):
"""Ne quitte pas Python."""
raise ValueError(msg)
t1 = time.time()
cherchable = cls()
# On crée les listes d'options
parser = argparse.ArgumentParser()
parser.exit = n_exit
# Ajout des options par défaut
parser.add_argument("defaut", nargs='*')
parser.add_argument("-a", "--aide", action="store_true")
parser.add_argument("-o", "--ordre")
parser.add_argument("-c", "--colonnes", nargs='+')
# Ajout des options du cherchable
for filtre in cherchable.filtres:
options = []
if filtre.opt_courte:
options.append("-" + filtre.opt_courte)
if filtre.opt_longue:
options.append("--" + filtre.opt_longue)
parser.add_argument(*options, nargs='*')
retour = []
tri = ""
colonnes = []
if not chaine.strip():
retour = cherchable.items
else:
try:
args = parser.parse_args(shlex.split(chaine))
except ValueError as err:
return "|err|Une option n'a pas été reconnue ou bien " \
"interprétée.|ff|\n" + str(err)
# On récupère les options génériques
if args.aide:
return cherchable.aide
if args.ordre:
arg = args.ordre
if arg in cherchable.attributs_tri:
tri = arg
else:
return "|err|Vous ne pouvez trier ainsi.|ff|"
if args.colonnes:
arg = " ".join(args.colonnes)
try:
colonnes = arg.split(",")
colonnes = [c.strip() for c in colonnes]
for c in colonnes:
assert c in cherchable.colonnes
except AssertionError:
return "|err|Les colonnes spécifiées sont " \
"invalides.|ff|"
# Interprétation des autres options
try:
retour = cherchable.tester(args, cherchable.items)
except TypeError as err:
return "|err|Les options n'ont pas été bien " \
"interprétées : " + str(err) + "|ff|"
# Post-traitement et affichage
if not retour:
return "|att|Aucun retour pour ces paramètres de " \
"recherche.|ff|"
else:
# On trie la liste de retour
if not tri:
tri = cherchable.tri_par_defaut()
retour = sorted(retour, key=lambda obj: getattr(obj, tri))
retour_aff = Tableau()
if not colonnes:
colonnes = cherchable.colonnes_par_defaut()
for colonne in colonnes:
if colonne in cherchable.noms_colonnes:
colonne = cherchable.noms_colonnes[colonne]
retour_aff.ajouter_colonne(colonne.capitalize())
for i, o in enumerate(retour):
ligne = []
for l, c in enumerate(colonnes):
c = c.strip()
if callable(cherchable.colonnes[c]):
aff = cherchable.colonnes[c](o)
else:
aff = getattr(o, cherchable.colonnes[c])
ligne.append(aff)
retour_aff.ajouter_ligne(*ligne)
t2 = time.time()
temps = str(round(t2 - t1, 3)).replace(".", ",")
s = "s" if len(retour) > 1 else ""
res = retour_aff.afficher()
return res + "\n {} résultat{s}, recherche en {}s".format(
len(retour), temps, s=s)
def trouver_depuis_chaine(cls, chaine):
"""Retourne un message en fonction de la chaîne passée en paramètre."""
def n_exit(code, msg):
"""Ne quitte pas Python."""
raise ValueError(msg)
cherchable = cls()
# On crée les listes d'options
parser = argparse.ArgumentParser()
parser.exit = n_exit
# Ajout des options par défaut
parser.add_argument("defaut", nargs='*')
parser.add_argument("-a", "--aide", action="store_true")
parser.add_argument("-o", "--ordre")
parser.add_argument("-c", "--colonnes", nargs='+')
# Ajout des options du cherchable
for filtre in cherchable.filtres:
options = ["-" + filtre.opt_courte]
if filtre.opt_longue:
options.append("--" + filtre.opt_longue)
parser.add_argument(*options, nargs='*')
retour = []
tri = ""
colonnes = []
if not chaine.strip():
retour = cherchable.items
else:
try:
args = parser.parse_args(shlex.split(chaine))
except ValueError as err:
return "|err|Une option n'a pas été reconnue ou bien " \
"interprétée.|ff|\n" + str(err)
# On récupère les options génériques
if args.aide:
return cherchable.aide
if args.ordre:
arg = args.ordre
if arg in cherchable.attributs_tri:
tri = arg
else:
return "|err|Vous ne pouvez trier ainsi.|ff|"
if args.colonnes:
arg = " ".join(args.colonnes)
try:
colonnes = arg.split(",")
colonnes = [c.strip() for c in colonnes]
for c in colonnes:
assert c in cherchable.colonnes
except AssertionError:
return "|err|Les colonnes spécifiées sont " \
"invalides.|ff|"
# Interprétation des autres options
try:
retour = cherchable.tester(args, cherchable.items)
except TypeError as err:
return "|err|Les options n'ont pas été bien " \
"interprétées : " + str(err) + "|ff|"
# Post-traitement et affichage
if not retour:
return "|att|Aucun retour pour ces paramètres de " \
"recherche.|ff|"
else:
# On trie la liste de retour
if not tri:
tri = cherchable.tri_par_defaut()
retour = sorted(retour, key=lambda obj: getattr(obj, tri))
retour_aff = Tableau()
if not colonnes:
colonnes = cherchable.colonnes_par_defaut()
for colonne in colonnes:
if colonne in cherchable.noms_colonnes:
colonne = cherchable.noms_colonnes[colonne]
retour_aff.ajouter_colonne(colonne.capitalize())
for i, o in enumerate(retour):
ligne = []
for l, c in enumerate(colonnes):
c = c.strip()
if callable(cherchable.colonnes[c]):
aff = cherchable.colonnes[c](o)
else:
aff = getattr(o, cherchable.colonnes[c])
ligne.append(aff)
retour_aff.ajouter_ligne(*ligne)
return retour_aff.afficher()