def get_description_pour(self, personnage):
"""Retourne la description textuelle pour le personnage."""
createur = self.createur.nom if self.createur else "personne"
ret = "Rapport #" + str(self.id) + " : " + echapper_accolades(self.titre)
ret += "\nCatégorie : " + self.type + " (" + \
self.categorie + ")"
ret += "\nStatut : " + self.statut + ", avancement : " + \
str(self.avancement) + "%"
ret += "\nCe rapport est classé en priorité " + \
self.priorite + "."
ret += "\nDétail :\n"
ret += echapper_accolades(str(self.description))
ret += "\nRapport envoyé par " + createur + " " +\
get_date(self.date.timetuple()) + "\n"
if personnage.est_immortel():
ret += "Depuis " + str(self.salle) + "\n"
ret += "Assigné à " + self.aff_assigne_a + "."
# Commentaires
if self.commentaires:
ret += "\n\nCommentaires du rapport:"
for i, commentaire in enumerate(self.commentaires):
auteur = commentaire.auteur and commentaire.auteur.nom or \
"inconnu"
ret += "\n {:> 2} - par {}, {}".format(i + 1, auteur,
get_date(commentaire.date.timetuple()))
ret += "\n " + ("\n ").join(wrap(
echapper_accolades(commentaire.texte), 69))
return ret
def afficher(self):
"""Affiche le mail"""
ret = "Expéditeur : " + self.expediteur.nom + "\n"
ret += "Destinataire(s) : " + self.aff_dest + "\n"
ret += "Sujet : " + echapper_accolades(self.sujet) + "\n"
ret += echapper_accolades(str(self.contenu))
ret += "\n" + get_date(self.date.timetuple()).capitalize() + "."
return ret
def afficher(self):
"""Affiche le mail"""
ret = "Expéditeur : " + self.expediteur.nom + "\n"
ret += "Destinataire(s) : " + self.aff_dest + "\n"
ret += "Sujet : " + echapper_accolades(self.sujet) + "\n"
ret += echapper_accolades(str(self.contenu))
ret += "\n" + get_date(self.date.timetuple()).capitalize() + "."
return ret
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
personnage.agir("parler")
message = dic_masques["message"].message
message = echapper_accolades(message)
if "alcool" in personnage.affections:
affection = personnage.affections["alcool"]
message = affection.affection.deformer_message(affection, message)
salle = personnage.salle
moi = "Vous dites : " + message
autre = "{} dit : " + message
personnage.envoyer(moi)
salle.envoyer(autre, personnage)
importeur.communication.rapporter_conversation("dire", personnage,
message)
for autre in salle.joueurs:
if autre is not personnage and autre.peut_voir(
personnage):
importeur.communication.enregistrer_conversation("dire",
autre, personnage, message)
autre.envoyer_tip("Utilisez la commande %dire% pour " \
"parler en RP dans la salle.", "dire", True)
# Appel de l'évènement 'dit' de la salle
salle.script["dit"].executer(personnage=personnage,
salle=salle, message=message)
# Appel de l'évènement 'dit' des PNJ présents
for pnj in salle.PNJ:
if pnj is personnage:
continue
pnj.script["dit"].executer(personnage=personnage,
message=message, pnj=pnj, salle=salle)
def envoyer(self, joueur, message):
"""Envoie un message au canal"""
message = echapper_accolades(message)
if self.flags & MUET:
joueur << "|err|Vous ne pouvez parler dans ce canal.|ff|"
return
type(self).importeur.communication. \
derniers_canaux[joueur.nom] = self.nom
ex_moi = self.clr + "[" + self.nom + "] Vous dites : "
ex_moi += message + "|ff|"
ex_autre = self.clr + "[" + self.nom + "] " + joueur.nom
ex_autre += " dit : " + message + "|ff|"
im = self.clr + "<" + joueur.nom + "> " + message + "|ff|"
if joueur in self.immerges:
joueur << im
else:
joueur << ex_moi
importeur.communication.rapporter_conversation("[" + self.nom + "]",
joueur, message)
for connecte in self.actuellement_connectes:
if connecte is not joueur:
importeur.communication.enregistrer_conversation(
self.clr + self.nom + "|ff|", connecte, joueur, message)
if connecte in self.immerges:
connecte << im
else:
connecte << ex_autre
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
cible = dic_masques["nom_joueur"].joueur
message = dic_masques["message"].message
message = echapper_accolades(message)
if cible is personnage:
personnage << "Vous parlez tout seul... Hum."
elif cible not in type(self).importeur.connex.joueurs_connectes:
personnage << "|err|Le joueur passé en paramètre n'a pu être " \
"trouvé.|ff|"
else:
clr = type(self).importeur.anaconf. \
get_config("config_com").couleur_tell
personnage << clr + "Vous dites à {} : {}|ff|".format(cible.nom,
message)
cible << clr + "{} vous dit : {}|ff|".format(personnage.nom,
message)
importeur.communication.rapporter_conversation("parler",
personnage, message)
importeur.communication.enregistrer_conversation("parler",
cible, personnage, message)
cible.envoyer_tip("Utilisez la commande %repondre% pour " \
"répondre.", "repondre", True)
type(self).importeur.communication.conversations. \
ajouter_ou_remplacer(cible, personnage, message)
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
cible = dic_masques["nom_joueur"].joueur
message = dic_masques["message"].message
message = echapper_accolades(message)
if cible is personnage:
personnage << "Vous parlez tout seul... Hum."
elif cible not in type(self).importeur.connex.joueurs_connectes:
personnage << "|err|Le joueur passé en paramètre n'a pu être " \
"trouvé.|ff|"
else:
clr = type(self).importeur.anaconf. \
get_config("config_com").couleur_tell
personnage << clr + "Vous dites à {} : {}|ff|".format(
cible.nom, message)
cible << clr + "{} vous dit : {}|ff|".format(
personnage.nom, message)
importeur.communication.rapporter_conversation(
"parler", personnage, message)
importeur.communication.enregistrer_conversation(
"parler", cible, personnage, message)
cible.envoyer_tip("Utilisez la commande %repondre% pour " \
"répondre.", "repondre", True)
type(self).importeur.communication.conversations. \
ajouter_ou_remplacer(cible, personnage, message)
def envoyer(self, joueur, message):
"""Envoie un message au canal"""
message = echapper_accolades(message)
if self.flags & MUET:
joueur << "|err|Vous ne pouvez parler dans ce canal.|ff|"
return
type(self).importeur.communication. \
derniers_canaux[joueur.nom] = self.nom
ex_moi = self.clr + "[" + self.nom + "] Vous dites : "
ex_moi += message + "|ff|"
ex_autre = self.clr + "[" + self.nom + "] " + joueur.nom
ex_autre += " dit : " + message + "|ff|"
im = self.clr + "<" + joueur.nom + "> " + message + "|ff|"
if joueur in self.immerges:
joueur << im
else:
joueur << ex_moi
importeur.communication.rapporter_conversation("[" + self.nom + "]",
joueur, message)
for connecte in self.actuellement_connectes:
if connecte is not joueur:
importeur.communication.enregistrer_conversation(
self.clr + self.nom + "|ff|", connecte,
joueur, message)
if connecte in self.immerges:
connecte << im
else:
connecte << ex_autre
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
personnage.agir("parler")
message = dic_masques["message"].message
message = echapper_accolades(message)
if "alcool" in personnage.affections:
affection = personnage.affections["alcool"]
message = affection.affection.deformer_message(affection, message)
salle = personnage.salle
moi = "Vous dites : " + message
autre = "{} dit : " + message
personnage.envoyer(moi)
salle.envoyer(autre, personnage)
importeur.communication.rapporter_conversation("dire", personnage,
message)
for autre in salle.joueurs:
if autre is not personnage and autre.peut_voir(
personnage):
importeur.communication.enregistrer_conversation("dire",
autre, personnage, message)
autre.envoyer_tip("Utilisez la commande %dire% pour " \
"parler en RP dans la salle.", "dire", True)
# Appel de l'évènement 'dit' de la salle
salle.script["dit"].executer(personnage=personnage,
salle=salle, message=message)
# Appel de l'évènement 'dit' des PNJ présents
for pnj in salle.PNJ:
if pnj is personnage:
continue
pnj.script["dit"].executer(personnage=personnage,
message=message, pnj=pnj, salle=salle)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
messages = type(self).importeur.man_logs.messages
messages = messages[-20:]
msg = "\n".join([m.message for m in messages])
msg = echapper_accolades(msg)
personnage << msg
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
rapports = [r for r in list(importeur.rapport.rapports.values()) if \
r.ouvert and r.assigne_a is personnage]
rapports = sorted(rapports, key=lambda r: r.int_priorite)
if not rapports:
personnage << "|err|Aucun rapport ne vous est assigné.|ff|"
return
l_id = max([len(str(r.id)) for r in rapports] + [2])
l_createur = max([len(r.createur.nom) if r.createur else 7 \
for r in rapports] + [8])
l_titre = max([len(r.titre) for r in rapports] + [5])
l_titre_max = 70 - l_createur - l_id # longueur max d'un titre
ljust_titre = min(l_titre_max, l_titre)
lignes = [
"+" + "-" * (l_id + l_createur + ljust_titre + 8) + "+",
"| |tit|" + "ID".ljust(l_id) + "|ff| | |tit|" \
+ "Créateur".ljust(l_createur) + "|ff| | |tit|" \
+ "Titre".ljust(ljust_titre) + "|ff| |",
"+" + "-" * (l_id + l_createur + ljust_titre + 8) + "+",
]
for rapport in rapports:
if l_titre_max < l_titre:
titre = couper_phrase(rapport.titre, l_titre_max)
else:
titre = rapport.titre
createur = rapport.createur and rapport.createur.nom or \
"inconnu"
lignes.append("| |vrc|" + str(rapport.id).ljust(l_id) \
+ "|ff| | " + createur.ljust(l_createur) + " | " \
+ titre.ljust(ljust_titre) + " |")
lignes.append(
"+" + "-" * (l_id + l_createur + ljust_titre + 8) + "+")
personnage << echapper_accolades("\n".join(lignes))
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
message = dic_masques["message"].message
personnage.agir("parler")
message = echapper_accolades(message)
if "alcool" in personnage.affections:
affection = personnage.affections["alcool"]
message = affection.affection.deformer_message(affection, message)
personnage.crier(message)
def envoyer_imp(self, message):
"""Envoie un message impersonnel (annonce)"""
message = echapper_accolades(message)
ex = self.clr + "[" + self.nom + "] " + message + "|ff|"
im = self.clr + "<" + message + ">"
for connecte in self.actuellement_connectes:
if connecte in type(self).importeur.connex.joueurs_connectes:
if connecte in self.immerges:
connecte << im
else:
connecte << ex
def envoyer_imp(self, message):
"""Envoie un message impersonnel (annonce)"""
message = echapper_accolades(message)
ex = self.clr + "[" + self.nom + "] " + message + "|ff|"
im = self.clr + "<" + message + ">"
for connecte in self.actuellement_connectes:
if connecte in type(self).importeur.connex.joueurs_connectes:
if connecte in self.immerges:
connecte << im
else:
connecte << ex
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
personnage.agir("geste")
message = dic_masques["message"].message
message = message.rstrip(" \n")
message = echapper_accolades(message)
# On vérifie la présence d'un / (barre oblique), qui signifie que
# le joueur souhaite entrer un état pour son personnage
if "/" in message:
message, etat = message.split("/", 1)
message = message.rstrip()
etat = etat.rstrip(" .,?!").lstrip()
personnage.etat_personnalise = etat
# On traite les détails
observable = importeur.interpreteur.masques["element_observable"]()
elements = []
for mot in list(message.split(" ")):
if mot.startswith("$"):
nom = mot[1:].rstrip(".,?; ")
observable.init()
masques = []
try:
observable.repartir(personnage, masques, list(nom))
except ErreurValidation as err:
personnage << str(err) + "."
return
try:
observable.valider(personnage, {})
except ErreurValidation as err:
personnage << str(err) + "."
return
elements.append(observable.element)
message = message.replace("$" + nom, "{}")
if not message[-1] in ponctuations_finales:
message += "."
personnage.salle.envoyer("{{}} {}".format(message),
personnage,
*elements,
ignore=False,
lisser=True)
if personnage.etat_personnalise:
personnage.envoyer("{{}} {}".format(personnage.etat_personnalise),
personnage)
importeur.communication.rapporter_conversation("emote", personnage,
message)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
# On récupère le familier et le message
familier = dic_masques["nom_familier"].familier
message = dic_masques["message"].message
pnj = familier.pnj
message = message.rstrip(" \n")
pnj.agir("geste")
if not message[-1] in ponctuations_finales:
message += "."
message = echapper_accolades(message)
personnage << "Vous donnez un ordre à {}.".format(familier.nom)
personnage.salle.envoyer("{{}} {}".format(message), pnj)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
nombre = dic_masques["nombre"].nombre
try:
alerte = type(self).importeur.scripting.alertes[nombre]
except KeyError:
personnage << "|err|Ce numéro d'alerte est invalide.|ff|"
else:
msg = "Informations sur l'alerte {} :".format(alerte.no)
msg += "\n S'est produit sur {} {}".format(alerte.type,
alerte.objet) + " " + get_date(alerte.date.timetuple())
msg += "\n Evenement {}, test {}, ligne {}".format(
alerte.evenement, echapper_accolades(alerte.test),
alerte.no_ligne)
msg += "\n {}\n".format(echapper_accolades(alerte.ligne))
msg += "\n Message d'erreur : |err|{}|ff|".format(
echapper_accolades(alerte.message))
if personnage.nom_groupe == "administrateur":
msg += "\n Traceback Python :\n {}".format(
echapper_accolades(alerte.traceback))
personnage << msg
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
# On récupère le familier et le message
familier = dic_masques["nom_familier"].familier
message = dic_masques["message"].message
pnj = familier.pnj
message = message.rstrip(" \n")
pnj.agir("geste")
if not message[-1] in ponctuations_finales:
message += "."
message = echapper_accolades(message)
personnage << "Vous donnez un ordre à {}.".format(familier.nom)
personnage.salle.envoyer("{{}} {}".format(message), pnj)
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
personnage.agir("geste")
message = dic_masques["message"].message
message = message.rstrip(" \n")
message = echapper_accolades(message)
# On vérifie la présence d'un / (barre oblique), qui signifie que
# le joueur souhaite entrer un état pour son personnage
if "/" in message:
message, etat = message.split("/", 1)
message = message.rstrip()
etat = etat.rstrip(" .,?!").lstrip()
personnage.etat_personnalise = etat
# On traite les détails
observable = importeur.interpreteur.masques["element_observable"]()
elements = []
for mot in list(message.split(" ")):
if mot.startswith("$"):
nom = mot[1:].rstrip(".,?; ")
observable.init()
masques = []
try:
observable.repartir(personnage, masques, list(nom))
except ErreurValidation as err:
personnage << str(err) + "."
return
try:
observable.valider(personnage, {})
except ErreurValidation as err:
personnage << str(err) + "."
return
elements.append(observable.element)
message = message.replace("$" + nom, "{}")
if not message[-1] in ponctuations_finales:
message += "."
personnage.salle.envoyer("{{}} {}".format(message), personnage,
*elements, ignore=False, lisser=True)
if personnage.etat_personnalise:
personnage.envoyer("{{}} {}".format(personnage.etat_personnalise),
personnage)
importeur.communication.rapporter_conversation("emote",
personnage, message)
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
personnage.agir("parler")
if dic_masques["message"] is None:
message = ""
ret = "Vous engagez la discussion avec {}."
else:
message = echapper_accolades(dic_masques["message"].message)
ret = "Vous engagez la discussion avec {} à propos de \"{}\"."
pnj = dic_masques["nom_pnj"].pnj
personnage << ret.format(pnj.get_nom_pour(personnage), message)
# Appel de l'évènement 'discute' du PNJ
pnj.script["discute"].executer(sujet=message, personnage=personnage,
pnj=pnj)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
alertes = []
for alerte in sorted(importeur.scripting.alertes.values(),
key=lambda alerte: alerte.no):
message = alerte.message
if len(message) > 30:
message = message[:30] + "..."
message = echapper_accolades(message)
msg = str(alerte.no).rjust(3) + " "
msg += alerte.objet + "[" + alerte.evenement + "]"
msg += " " + str(alerte.date.date())
msg += " " + message
alertes.append(msg)
if alertes:
personnage << "Liste des alertes non résolues :\n\n " + \
"\n ".join(alertes)
else:
personnage << "|att|Aucune alerte non résolue n'est conservée.|ff|"
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
alertes = []
for alerte in sorted(importeur.scripting.alertes.values(),
key=lambda alerte: alerte.no):
message = alerte.message
if len(message) > 30:
message = message[:30] + "..."
message = echapper_accolades(message)
msg = str(alerte.no).rjust(3) + " "
msg += alerte.objet + "[" + alerte.evenement + "]"
msg += " " + str(alerte.date.date())
msg += " " + message
alertes.append(msg)
if alertes:
personnage << "Liste des alertes non résolues :\n\n " + \
"\n ".join(alertes)
else:
personnage << "|att|Aucune alerte non résolue n'est conservée.|ff|"
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
personnage.agir("parler")
cible = dic_masques["personnage_present"].personnage
message = dic_masques["message"].message
message = echapper_accolades(message)
if personnage is cible:
personnage << "|att|Hem... Vous parlez tout seul.|ff|"
return
if "alcool" in personnage.affections:
affection = personnage.affections["alcool"]
message = affection.affection.deformer_message(affection, message)
personnage.envoyer("Vous chuchotez à {{}} : {}".format(message), cible)
cible.envoyer("{{}} vous chuchote : {}".format(message), personnage)
personnage.salle.envoyer("{} chuchote quelque chose à " \
"l'oreille de {}.", personnage, cible)
importeur.communication.rapporter_conversation("chuchoter", personnage,
message)
importeur.communication.enregistrer_conversation(
"chuchoter", cible, personnage, message)
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
personnage.agir("parler")
cible = dic_masques["personnage_present"].personnage
message = dic_masques["message"].message
message = echapper_accolades(message)
if personnage is cible:
personnage << "|att|Hem... Vous parlez tout seul.|ff|"
return
if "alcool" in personnage.affections:
affection = personnage.affections["alcool"]
message = affection.affection.deformer_message(affection, message)
personnage.envoyer("Vous chuchotez à {{}} : {}".format(
message), cible)
cible.envoyer("{{}} vous chuchote : {}".format(message),
personnage)
personnage.salle.envoyer("{} chuchote quelque chose à " \
"l'oreille de {}.", personnage, cible)
importeur.communication.rapporter_conversation("chuchoter",
personnage, message)
importeur.communication.enregistrer_conversation("chuchoter",
cible, personnage, message)
def aff_titre(self):
"""Retourne le titre échappé."""
return echapper_accolades(self.titre)
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
conversations = type(self).importeur.communication.conversations
p_conversations = conversations.get_conversations_pour(personnage)
clr = type(self).importeur.anaconf.get_config("config_com").couleur_tell
# Si on n'a pas envoyé de message
if dic_masques["message"] is None:
if dic_masques["id_conversation"] is None:
# On liste les correspondants
res = ""
for conversation in p_conversations:
res += "\n "
res += str(conversation.id)
res += ". Avec "
if conversation.focus:
res += "|grf|[c] " + conversation.cible.nom + "|ff|"
else:
res += conversation.cible.nom
if conversation.cible not in \
type(self).importeur.connex.joueurs_connectes:
res += " (|rgc|déconnecté|ff|)"
res += " : '" + clr + conversation.phrase + "|ff|'"
if not res:
personnage << "|err|Personne ne vous a parlé pour le " \
"moment.|ff|"
else:
personnage << "Vos conversations en cours :\n" + res
else:
if dic_masques["id_conversation"].perte_focus:
for conversation in conversations.iter():
if conversation in p_conversations:
if conversation.focus:
conversation.ch_focus()
personnage << "|att|La réponse automatique a bien été " \
"remise à zéro.|ff|"
else:
# On place le focus sur le correspondant indiqué
id = dic_masques["id_conversation"].id_conversation
cible = dic_masques["id_conversation"].cible
for conversation in conversations.iter():
if conversation.id == id and \
conversation.emetteur is personnage and \
conversation.cible is cible:
if not conversation.focus:
conversation.ch_focus()
personnage << "|att|La réponse automatique a " \
"bien été bloquée sur {}.|ff|".format(
cible.nom)
else:
personnage << "|err|Le focus est déjà sur " \
"{}.|ff|".format(cible.nom)
# Sinon
else:
message = dic_masques["message"].message
message = echapper_accolades(message)
cible = None
# On récupère la cible du reply
if dic_masques["id_conversation"] is not None:
cible = dic_masques["id_conversation"].cible
# Si le masque id n'a rien donné
if cible is None:
for conversation in p_conversations:
cible = conversation.cible
if conversation.focus:
break
# On envoie le message
if cible is None:
personnage << "|err|Personne ne vous a parlé pour le " \
"moment.|ff|"
else:
if cible not in type(self).importeur.connex.joueurs_connectes:
personnage << "|err|Le joueur {} n'a pu être " \
"trouvé.|ff|".format(cible.nom)
else:
type(self).importeur.communication.conversations. \
ajouter_ou_remplacer(cible, personnage, message)
personnage << clr + "Vous répondez à {} : {}|ff|".format(
cible.nom, message)
cible << clr + "{} vous répond : {}|ff|".format(
personnage.nom, message)
importeur.communication.rapporter_conversation(
"parler", personnage, message)
importeur.communication.enregistrer_conversation(
"parler", cible, personnage, message)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
flags = {"non assignes": False, "fermes": False}
if dic_masques["message"] is not None:
t_flags = dic_masques["message"].message
t_flags = [f.strip() for f in t_flags.split(",")]
for f in flags.keys():
if f in t_flags:
flags[f] = True
rapports = list(importeur.rapport.rapports.values())
if not flags["fermes"]:
rapports = [r for r in rapports if r.ouvert]
if flags["non assignes"]:
rapports = [r for r in rapports if r.assigne_a is None]
if not personnage.est_immortel():
# On récupère les rapports envoyés par le joueur mortel
rapports = [r for r in rapports if r.createur is personnage or \
r.public]
if not rapports:
personnage << "|att|Vous n'avez envoyé aucun rapport.|ff|"
else:
l_id = max([len(str(r.id)) for r in rapports] + [2])
l_createur = 15
l_titre = max([len(r.titre) for r in rapports] + [5])
l_titre_max = 34 - l_id # longueur max possible d'un titre
ljust_titre = min(l_titre_max, l_titre)
lignes = [
"+" + "-" * (l_id + l_createur + ljust_titre + 32) + "+",
"| |tit|" + "ID".ljust(l_id) + "|ff| | |tit|" + \
"Créateur".ljust(l_createur) + "|ff| | |tit|" + "Titre".ljust(ljust_titre) + "|ff| | " \
"|tit|Statut|ff| | |tit|Avancement|ff| |",
"+" + "-" * (l_id + l_createur + ljust_titre + 32) + "+",
]
for rapport in rapports:
id = "|vrc|" + str(rapport.id).ljust(l_id) + "|ff|"
createur = rapport.createur.nom if rapport.createur else \
"inconnu"
createur = createur.ljust(l_createur)
if l_titre_max < l_titre:
titre = couper_phrase(rapport.titre, l_titre_max)
else:
titre = rapport.titre
titre = titre.ljust(ljust_titre)
stat = CLR_STATUTS[rapport.statut]
stat += rapport.statut.ljust(8) + "|ff|"
clr = CLR_AVC[floor(rapport.avancement / 12.5)]
avc = clr + str(rapport.avancement).rjust(9)
lignes.append(
"| {id} | {createur} | {titre} | {stat} | " \
"{avc}%|ff| |".format(id=id,
createur=createur, titre=titre, stat=stat,
avc=avc))
lignes.append("+" + "-" * (l_id + l_createur + ljust_titre + \
32) + "+")
personnage << echapper_accolades("\n".join(lignes))
else:
if not rapports:
personnage << "|err|Aucun rapport n'a été envoyé.|ff|"
return
l_id = max([len(str(r.id)) for r in rapports] + [2])
l_createur = max([len(r.createur.nom) if r.createur else 7 \
for r in rapports] + [8])
l_titre = max([len(r.titre) for r in rapports] + [5])
l_titre_max = 70 - l_createur - l_id # longueur max d'un titre
ljust_titre = min(l_titre_max, l_titre)
lignes = [
"+" + "-" * (l_id + l_createur + ljust_titre + 8) + "+",
"| |tit|" + "ID".ljust(l_id) + "|ff| | |tit|" \
+ "Créateur".ljust(l_createur) + "|ff| | |tit|" \
+ "Titre".ljust(ljust_titre) + "|ff| |",
"+" + "-" * (l_id + l_createur + ljust_titre + 8) + "+",
]
for rapport in rapports:
if l_titre_max < l_titre:
titre = couper_phrase(rapport.titre, l_titre_max)
else:
titre = rapport.titre
createur = rapport.createur and rapport.createur.nom or \
"inconnu"
lignes.append("| |vrc|" + str(rapport.id).ljust(l_id) \
+ "|ff| | " + createur.ljust(l_createur) + " | " \
+ titre.ljust(ljust_titre) + " |")
lignes.append(
"+" + "-" * (l_id + l_createur + ljust_titre + 8) + "+")
personnage << echapper_accolades("\n".join(lignes))
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
conversations = type(self).importeur.communication.conversations
p_conversations = conversations.get_conversations_pour(personnage)
clr = type(self).importeur.anaconf.get_config(
"config_com").couleur_tell
# Si on n'a pas envoyé de message
if dic_masques["message"] is None:
if dic_masques["id_conversation"] is None:
# On liste les correspondants
res = ""
for conversation in p_conversations:
res += "\n "
res += str(conversation.id)
res += ". Avec "
if conversation.focus:
res += "|grf|[c] " + conversation.cible.nom + "|ff|"
else:
res += conversation.cible.nom
if conversation.cible not in \
type(self).importeur.connex.joueurs_connectes:
res += " (|rgc|déconnecté|ff|)"
res += " : '" + clr + conversation.phrase + "|ff|'"
if not res:
personnage << "|err|Personne ne vous a parlé pour le " \
"moment.|ff|"
else:
personnage << "Vos conversations en cours :\n" + res
else:
if dic_masques["id_conversation"].perte_focus:
for conversation in conversations.iter():
if conversation in p_conversations:
if conversation.focus:
conversation.ch_focus()
personnage << "|att|La réponse automatique a bien été " \
"remise à zéro.|ff|"
else:
# On place le focus sur le correspondant indiqué
id = dic_masques["id_conversation"].id_conversation
cible = dic_masques["id_conversation"].cible
for conversation in conversations.iter():
if conversation.id == id and \
conversation.emetteur is personnage and \
conversation.cible is cible:
if not conversation.focus:
conversation.ch_focus()
personnage << "|att|La réponse automatique a " \
"bien été bloquée sur {}.|ff|".format(
cible.nom)
else:
personnage << "|err|Le focus est déjà sur " \
"{}.|ff|".format(cible.nom)
# Sinon
else:
message = dic_masques["message"].message
message = echapper_accolades(message)
cible = None
# On récupère la cible du reply
if dic_masques["id_conversation"] is not None:
cible = dic_masques["id_conversation"].cible
# Si le masque id n'a rien donné
if cible is None:
for conversation in p_conversations:
cible = conversation.cible
if conversation.focus:
break
# On envoie le message
if cible is None:
personnage << "|err|Personne ne vous a parlé pour le " \
"moment.|ff|"
else:
if cible not in type(self).importeur.connex.joueurs_connectes:
personnage << "|err|Le joueur {} n'a pu être " \
"trouvé.|ff|".format(cible.nom)
else:
type(self).importeur.communication.conversations. \
ajouter_ou_remplacer(cible, personnage, message)
personnage << clr + "Vous répondez à {} : {}|ff|".format(
cible.nom, message)
cible << clr + "{} vous répond : {}|ff|".format(
personnage.nom, message)
importeur.communication.rapporter_conversation(
"parler", personnage, message)
importeur.communication.enregistrer_conversation(
"parler", cible, personnage, message)