def regarder(self, personnage):
"""Quand on regarde la boussole."""
moi = Instrument.regarder(self, personnage)
salle = personnage.salle
if not hasattr(salle, "navire") or salle.navire is None or \
salle.navire.etendue is None:
return moi
navire = salle.navire
vent = navire.vent
vent = Vecteur(vent.x, vent.y, vent.z)
vent.tourner_autour_z(180)
ven_dir = (vent.direction + 90) % 360
ven_dir = round(ven_dir / self.precision) * self.precision
nav_dir = (navire.direction.direction + 90) % 360
nav_dir = round(nav_dir / self.precision) * self.precision
navire.donnees["direction"] = nav_dir
navire.donnees["nom_direction"] = navire.direction.nom_direction
navire.donnees["direction_vent"] = ven_dir
navire.donnees["nom_direction_vent"] = vent.nom_direction
msg_vent = lisser("Le vent souffle de le {} ({}°).".format(
vent.nom_direction, ven_dir))
msg_navire = lisser("Le navire se dirige vers le {} ({}°).".format(
navire.direction.nom_direction, nav_dir))
moi += "\n\n" + msg_vent + "\n" + msg_navire
return moi
def crier_ordres(self, personnage):
"""On fait crier l'ordre au personnage."""
direction = self.direction
if direction < 23 or direction > 337:
nom_dir = "l'est"
elif direction < 67:
nom_dir = "le sud-est"
elif direction < 112:
nom_dir = "le sud"
elif direction < 157:
nom_dir = "le sud-ouest"
elif direction < 202:
nom_dir = "l'ouest"
elif direction < 247:
nom_dir = "le nord-ouest"
elif direction < 292:
nom_dir = "le nord"
else:
nom_dir = "le nord-est"
direction = (direction + 90) % 360
nom_dir = lisser("virez à " + nom_dir)
msg = "{} s'écrie : {}, {}° !".format(
personnage.distinction_audible, nom_dir, direction)
self.navire.envoyer(msg)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
personnage.agir("poser")
salle = personnage.salle
if not hasattr(salle, "navire") or salle.navire is None or \
salle.navire.etendue is None:
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
pavillon = navire.pavillon
if pavillon:
personnage << "|err|Il y a déjà un pavillon hissé.|ff|"
return
objets = list(dic_masques["nom_objet"].objets_qtt_conteneurs)
objets = [c[0] for c in objets]
pavillon = objets[0]
if not pavillon.est_de_type("pavillon"):
personnage << "|err|{} n'est pas un pavillon.|ff|".format(
pavillon.get_nom().capitalize())
return
navire.pavillon = pavillon.prototype
navire.envoyer("{} est hissé en tête de mât.".format(
pavillon.get_nom().capitalize()))
navire.envoyer_autour(lisser("{} est hissé en tête de mat de " \
"{}.".format(pavillon.get_nom().capitalize(),
navire.desc_survol)), 35)
importeur.objet.supprimer_objet(pavillon.identifiant)
def executer(self, matelot):
"""Exécute la volonté."""
# Vérifie que l'initiateur a le droit de commander à la cible
cible = self.cible
personnage = self.initiateur
if personnage is None:
print("Aucun initiateur")
return
if (self.navire.opt_position - cible.opt_position).mag > 20:
personnage << "|err|Ce navire se trouve trop loin.|ff|"
return
if not cible.a_le_droit(personnage, "officier"):
personnage << "|err|Vous ne pouvez donner d'ordre sur ce " \
"navire.|ff|"
return
if cible.equipage.a_objectif("suivre_navire", self.navire):
personnage << "|err|Ce semble être déjà le cas.|ff|"
return
cible.equipage.ajouter_objectif("suivre_navire", self.navire)
if cible.equipage.matelots:
self.navire.envoyer(lisser("L'équipage de {} fait signe " \
"en réponse.".format(cible.desc_survol)))
def regarder(self, personnage):
"""Le personnage regarde l'objet"""
msg = BaseType.regarder(self, personnage)
if not getattr(self, "conteneur", False):
return msg
objets = []
for o, nb in self.conteneur.get_objets_par_nom():
if o.est_de_type("potion"):
article = str(nb) if nb > 1 else "une"
s = "s" if nb > 1 else ""
objets.append(
lisser("{} mesure{s} de {}".format(article,
o.nom_singulier,
s=s)))
else:
objets.append(o.get_nom(nb))
if objets:
msg += self.message_contenu
msg += "\n " + "\n ".join(objets)
else:
msg += self.message_vide
return msg
def get_nom(self, nombre=1):
"""Retourne le nom complet en fonction du nombre.
Par exemple :
Si nombre == 1 : retourne le nom singulier
Sinon : retourne le nombre et le nom pluriel
"""
ajout = ""
if self.potion is not None:
s = "s" if nombre > 1 else ""
if self.potion == "eau":
nom = "eau"
else:
nom = self.potion.get_nom()
ajout = lisser(" " + self.conteneur.connecteur.format(s=s) + " " +
nom)
if nombre <= 0:
raise ValueError("la fonction get_nom a été appelée " \
"avec un nombre négatif ou nul.")
elif nombre == 1:
return self.conteneur.nom_singulier + ajout
else:
if self.conteneur.noms_sup:
noms_sup = list(self.conteneur.noms_sup)
noms_sup.reverse()
for nom in noms_sup:
if nombre >= nom[0]:
return nom[1] + ajout
return str(nombre) + " " + self.conteneur.nom_pluriel + ajout
def get_nom(self, nombre=1, pluriels=True):
"""Retourne le nom complet en fonction du nombre.
Par exemple :
Si nombre == 1 : retourne le nom singulier
Sinon : retourne le nombre et le nom pluriel
"""
ajout = ""
if hasattr(self, "materiau"):
materiau = self.materiau
quantite = self.quantite
nom = materiau.get_nom(quantite)
regex = NOM.search(nom)
if regex:
mesure, connecteur, nom = regex.groups()
ajout = lisser(" {} {} de {}".format(self.connecteur,
nom, mesure))
if nombre <= 0:
raise ValueError("la fonction get_nom a été appelée " \
"avec un nombre négatif ou nul.")
elif nombre == 1:
return self.nom_singulier + ajout
else:
return "{} {}{}".format(nombre, self.nom_pluriel, ajout)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
personnage.agir("poser")
salle = personnage.salle
if not hasattr(salle, "navire") or salle.navire is None or \
salle.navire.etendue is None:
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
pavillon = navire.pavillon
if pavillon:
personnage << "|err|Il y a déjà un pavillon hissé.|ff|"
return
objets = list(dic_masques["nom_objet"].objets_qtt_conteneurs)
objets = [c[0] for c in objets]
pavillon = objets[0]
if not pavillon.est_de_type("pavillon"):
personnage << "|err|{} n'est pas un pavillon.|ff|".format(
pavillon.get_nom().capitalize())
return
navire.pavillon = pavillon.prototype
navire.envoyer("{} est hissé en tête de mât.".format(
pavillon.get_nom().capitalize()))
navire.envoyer_autour(lisser("{} est hissé en tête de mat de " \
"{}.".format(pavillon.get_nom().capitalize(),
navire.desc_survol)), 35)
importeur.objet.supprimer_objet(pavillon.identifiant)
def get_nom(self, nombre=1):
"""Retourne le nom complet en fonction du nombre.
Par exemple :
Si nombre == 1 : retourne le nom singulier
Sinon : retourne le nombre et le nom pluriel
"""
ajout = ""
if self.potion is not None:
s = "s" if nombre > 1 else ""
if self.potion == "eau":
nom = "eau"
else:
nom = self.potion.get_nom()
ajout = lisser(
" " + self.conteneur.connecteur.format(s=s) + " " + nom)
if nombre <= 0:
raise ValueError("la fonction get_nom a été appelée " \
"avec un nombre négatif ou nul.")
elif nombre == 1:
return self.conteneur.nom_singulier + ajout
else:
if self.conteneur.noms_sup:
noms_sup = list(self.conteneur.noms_sup)
noms_sup.reverse()
for nom in noms_sup:
if nombre >= nom[0]:
return nom[1] + ajout
return str(nombre) + " " + self.conteneur.nom_pluriel + ajout
def crier_ordres(self, personnage):
"""On fait crier l'ordre au personnage."""
direction = self.direction
if direction < 23 or direction > 337:
nom_dir = "l'est"
elif direction < 67:
nom_dir = "le sud-est"
elif direction < 112:
nom_dir = "le sud"
elif direction < 157:
nom_dir = "le sud-ouest"
elif direction < 202:
nom_dir = "l'ouest"
elif direction < 247:
nom_dir = "le nord-ouest"
elif direction < 292:
nom_dir = "le nord"
else:
nom_dir = "le nord-est"
direction = (direction + 90) % 360
nom_dir = lisser("cap à " + nom_dir)
msg = "{} s'écrie : {}, {}° !".format(
personnage.distinction_audible, nom_dir, direction)
self.navire.envoyer(msg)
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
salle = personnage.salle
navire = salle.navire
matelot = dic_masques["nom_matelot"].matelot
nom_poste = dic_masques["message"].message
equipage = navire.equipage
if not navire.a_le_droit(personnage, "maître d'équipage"):
personnage << "|err|Vous ne pouvez donner d'ordre sur ce " \
"navire.|ff|"
return
# On essaye de trouver le nom du poste (sans accents ni majuscules)
nom = None
for t_nom in ORDRE:
if supprimer_accents(t_nom).lower() == supprimer_accents(
nom_poste).lower():
nom = t_nom
break
if nom is None:
personnage << "|err|Impossible de trouver le nom du poste : " \
"{}.|ff|".format(nom_poste)
elif matelot.nom_poste == nom:
personnage << "|err|Ce matelot est déjà à ce poste.|ff|"
else:
matelot.nom_poste = nom
personnage << lisser("{} a bien été mis au poste de {}.".format(
matelot.nom, nom))
def regarder(self, personnage, elt=None, variables=None):
"""Le personnage regarde la description."""
variables = variables or {}
for ajout in importeur.hook["description:ajouter_variables"].executer(
self, personnage, elt):
variables.update(ajout)
description = ""
desc_flottantes = []
elt = elt or self.parent
for paragraphe in self.paragraphes:
paragraphe = paragraphe.replace("|nl|",
"\n").replace("|tab|", " ")
if self.scriptable:
# On charge récursivement les descriptions flottantes
paragraphe, flottantes = self.charger_descriptions_flottantes(
paragraphe)
desc_flottantes += [fl.description for fl in flottantes if \
fl.description not in desc_flottantes]
description += paragraphe + "\n"
description = description.rstrip("\n ")
evts = re.findall(r"(\$[A-Za-z0-9]+)([\n ,.]|$)", description)
evts = [e[0] for e in evts]
desc_flottantes.insert(0, self)
for nom_complet in evts:
nom = nom_complet[1:]
trouve = False
if variables.get(nom):
retour = variables[nom]
description = description.replace(nom_complet, retour)
trouve = True
if self.scriptable:
for desc in desc_flottantes:
if trouve:
break
evt = desc.script["regarde"]
if nom in evt.evenements:
evt = evt.evenements[nom]
evt.executer(True, regarde=elt, personnage=personnage)
retour = evt.espaces.variables["retour"]
retour = retour.replace("_b_nl_b_", "\n")
description = description.replace(nom_complet, retour)
trouve = True
break
if not trouve:
raise ValueError("impossible de trouver la description " \
"dynamique '{}'".format(nom))
paragraphes = []
for paragraphe in description.split("\n"):
paragraphes.append("\n".join(wrap(lisser(paragraphe),
TAILLE_LIGNE)))
return "\n".join(paragraphes)
def traite(chaine, operations):
"""Traite une chaîne de caractères selon plusieurs opérations.
Cette fonction scripting permet de mettre en forme une chaîne
de caractères (la mettre en majuscule, minuscule, retirer
les accents...). Plusieurs opérations peuvent être précisées
en même temps (voir les exemples ci-dessous).
Paramètres à préciser :
* chaine : la chaîne d'origine (à transformer)
* operations : la chaîne contenant les flags de transformation
Les flags d'opération sont à préciser dans une chaîne avec
chaque nom de flag séparé par un espace. Voir les exemples
pour plus d'informations. Les flags disponibles sont :
* minuscule : met la chaîne en minuscule
* majuscule : met la chaîne en majuscule
* capital : met chaque première lettre de chaque mot en majuscule
* sans_accents : retire les accents.
* lisser : change "de un" en "d'un", "le un" en "l'un"...
Exemples d'utilisation :
chaine = "BONNE JOURNÉE"
# Met la chaîne en minuscule
chaine = traite(chaine, "minuscule")
# chaine contient à présent "bonne journée"
chaine = "BONNE JOURNÉE"
# Met la chaîne en capital sans accents
chaine = traite(chaine, "capital sans_accents")
# chaine contient à présent "Bonne Journee"
# Puis met chaine en majuscule
chaine = traite(chaine, "majuscule")
# chaine contient à présent "BONNE JOURNEE"
chaine = "C'est une porte de acier."
chaine = traite(chaine, "lisser")
# chaine contient "C'est une porte d'acier."
"""
operations = operations.lower()
if not operations:
raise ErreurExecution("Précisez au moins une opération")
operations = operations.split(" ")
for operation in operations:
if operation == "minuscule":
chaine = chaine.lower()
elif operation == "majuscule":
chaine = chaine.upper()
elif operation == "capital":
chaine = chaine.title()
elif operation == "sans_accents":
chaine = supprimer_accents(chaine)
elif operation == "lisser":
chaine = lisser(chaine)
return chaine
def nom_achat(self):
if self.potion == "eau":
nom = "eau"
else:
nom = self.potion.nom_singulier
ajout = lisser(" " + self.conteneur.connecteur.format(s="") + " " +
nom)
return self.conteneur.nom_singulier + ajout
def nom_achat(self):
if self.potion == "eau":
nom = "eau"
else:
nom = self.potion.nom_singulier
ajout = lisser(
" " + self.conteneur.connecteur.format(s="") + " " + nom)
return self.conteneur.nom_singulier + ajout
def regarder(self, personnage, notifier=True):
"""personnage regarde self."""
equipement = self.equipement
msg = ""
if notifier:
msg = "Vous regardez {} :".format(self.get_nom_pour(
personnage, retenu=False))
if personnage.est_immortel():
msg += self.ajout_description_pour_imm()
msg += "\n"
if hasattr(self, "description"):
msg += "\n" + self.description.regarder(personnage=personnage,
elt=self) + "\n\n"
# Affections
aff_msg = []
for cle, affection in self.affections.items():
aff_msg.append(lisser(affection.affection.message(
affection)) + ".")
if aff_msg:
msg += "\n".join(aff_msg) + "\n\n"
objets = []
for membre in equipement.membres:
# on affiche l'objet tenu prioritairement, sinon l'objet équipé
objet = membre.tenu or membre.equipe and membre.equipe[-1] or None
if objet:
objets.append("{} [{}]".format(membre.nom.capitalize(),
objet.get_nom()))
if self.est_masculin():
genre = "Il"
genre2 = "lui."
elif self.est_feminin():
genre = "Elle"
genre2 = "elle."
else:
genre = "Il"
genre2 = "lui."
if not objets:
msg += genre + " ne porte rien sur " + genre2
else:
msg += genre + " porte :\n\n " + "\n ".join(objets)
if notifier:
personnage.envoyer(msg, perso=self)
self.envoyer("{} vous regarde.", personnage)
personnage.salle.envoyer("{} regarde {}.", personnage, self)
else:
return msg
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
salle = personnage.salle
if getattr(salle, "navire", None) is None:
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
joueur = dic_masques["nom_joueur"].joueur
nom_poste = dic_masques["message"].message.lower()
equipage = navire.equipage
if not navire.a_le_droit(personnage, "maître d'équipage"):
personnage << "|err|Vous ne pouvez donner d'ordre sur ce " \
"navire.|ff|"
return
if nom_poste == "aucun":
if joueur in equipage.joueurs:
del equipage.joueurs[joueur]
personnage << "{} a bien été retiré de votre " \
"équipage.".format(joueur.nom)
else:
personnage << "|err|Le joueur {} n'est pas dans " \
"votre équipage.|ff|".format(joueur.nom)
return
# On essaye de trouver le nom du poste (sans accents ni majuscules)
nom = None
for t_nom in ORDRE:
if supprimer_accents(t_nom).lower() == supprimer_accents(
nom_poste):
nom = t_nom
break
if nom is None:
personnage << "|err|Impossible de trouver le nom du poste : " \
"{}.|ff|".format(nom_poste)
else:
equipage.changer_poste(joueur, nom)
personnage << lisser("{} a bien été mis au poste de {}.".format(
joueur.nom, nom))
def interpreter(self, personnage, dic_masques):
"""Interprétation du paramètre"""
salle = personnage.salle
if getattr(salle, "navire", None) is None:
personnage << "|err|Vous n'êtes pas sur un navire.|ff|"
return
navire = salle.navire
joueur = dic_masques["nom_joueur"].joueur
nom_poste = dic_masques["message"].message.lower()
equipage = navire.equipage
if not navire.a_le_droit(personnage, "maître d'équipage"):
personnage << "|err|Vous ne pouvez donner d'ordre sur ce " \
"navire.|ff|"
return
if nom_poste == "aucun":
if joueur in equipage.joueurs:
del equipage.joueurs[joueur]
personnage << "{} a bien été retiré de votre " \
"équipage.".format(joueur.nom)
else:
personnage << "|err|Le joueur {} n'est pas dans " \
"votre équipage.|ff|".format(joueur.nom)
return
# On essaye de trouver le nom du poste (sans accents ni majuscules)
nom = None
for t_nom in ORDRE:
if supprimer_accents(t_nom).lower() == supprimer_accents(
nom_poste):
nom = t_nom
break
if nom is None:
personnage << "|err|Impossible de trouver le nom du poste : " \
"{}.|ff|".format(nom_poste)
else:
equipage.changer_poste(joueur, nom)
personnage << lisser("{} a bien été mis au poste de {}.".format(
joueur.nom, nom))
def get_nom(self, nombre=1, pluriels=True):
"""Retourne le nom complet en fonction du nombre.
Par exemple :
Si nombre == 1 : retourne le nom singulier
Sinon : retourne le nombre et le nom pluriel
"""
ajout = ""
diff = 0
if hasattr(self, "apparition"):
diff = (datetime.now() - self.apparition).seconds // 60
if diff < 2:
ajout += " encore chaud"
elif diff < 5:
ajout += " tiède"
elif diff < 8:
ajout += " refroidi"
elif diff < 12:
ajout += " plus très frais"
else:
ajout += " en putréfaction"
if hasattr(self, "pnj") and self.pnj:
ajout += lisser(" de " + self.pnj.nom_singulier)
if nombre <= 0:
raise ValueError("la fonction get_nom a été appelée " \
"avec un nombre négatif ou nul.")
elif nombre == 1:
return self.nom_singulier + ajout
else:
if self.noms_sup:
noms_sup = list(self.noms_sup)
noms_sup.reverse()
for nom in noms_sup:
if nombre >= nom[0]:
return nom[1]
return str(nombre) + " " + self.nom_pluriel + ajout
def get_nom(self, nombre=1, pluriels=True):
"""Retourne le nom complet en fonction du nombre.
Par exemple :
Si nombre == 1 : retourne le nom singulier
Sinon : retourne le nombre et le nom pluriel
"""
ajout = ""
if self.potion is not None:
s = "s" if nombre > 1 else ""
nom = self.potion.get_nom()
connecteurs = LISTE_CONNECTEURS[self.connecteur]
nb_max = self.onces_max
nb = getattr(self, "onces", nb_max)
rempli = nb / nb_max
if rempli <= 0.2:
connecteur = connecteurs[0]
elif rempli <= 0.7:
connecteur = connecteurs[1]
else:
connecteur = connecteurs[2]
e = "e" if not self.masculin else ""
ajout = lisser(" " + connecteur.format(s=s, e=e, liquide=nom))
if nombre <= 0:
raise ValueError("la fonction get_nom a été appelée " \
"avec un nombre négatif ou nul.")
elif nombre == 1:
return self.nom_singulier + ajout
else:
if self.noms_sup:
noms_sup = list(self.noms_sup)
noms_sup.reverse()
for nom in noms_sup:
if nombre >= nom[0]:
return nom[1] + ajout
return str(nombre) + " " + self.nom_pluriel + ajout
def get_nom(self, nombre=1, pluriels=True):
"""Retourne le nom complet en fonction du nombre.
Par exemple :
Si nombre == 1 : retourne le nom singulier
Sinon : retourne le nombre et le nom pluriel
"""
ajout = ""
if self.potion is not None:
s = "s" if nombre > 1 else ""
nom = self.potion.get_nom()
connecteurs = LISTE_CONNECTEURS[self.connecteur]
nb_max = self.onces_max
nb = getattr(self, "onces", nb_max)
rempli = nb / nb_max
if rempli <= 0.2:
connecteur = connecteurs[0]
elif rempli <= 0.7:
connecteur = connecteurs[1]
else:
connecteur = connecteurs[2]
e = "e" if not self.masculin else ""
ajout = lisser(" " + connecteur.format(s=s, e=e, liquide=nom))
if nombre <= 0:
raise ValueError("la fonction get_nom a été appelée " \
"avec un nombre négatif ou nul.")
elif nombre == 1:
return self.nom_singulier + ajout
else:
if self.noms_sup:
noms_sup = list(self.noms_sup)
noms_sup.reverse()
for nom in noms_sup:
if nombre >= nom[0]:
return nom[1] + ajout
return str(nombre) + " " + self.nom_pluriel + ajout
def __str__(self):
"""Méthode d'affichage du feu (fonction de la puissance)"""
cheminee = None
msg_cheminee = (
(1, "{cheminee} ne contient qu'un tas de cendres encore chaudes."),
(5, "{cheminee} contient encore quelques flammes vacillantes."),
(8, "Quelques flammes encore vives brûlent dans {cheminee}."),
(15, "Un feu clair crépite gaiement au coeur de {cheminee}."),
(25, "De hautes flammes dansent au coeur de {cheminee}."),
(40, "Un feu trop ardent emplit littéralement {cheminee}."),
(55, "Un début d'incendie menace, envahissant peu à peu les lieux."),
(70, "Un brasier enthousiaste flamboie ici et vous roussit le " \
"poil."),
(85, "Une fournaise étouffante vous prend à la gorge et menace " \
"de vous consummer."),
(100, "Un véritable bûcher se dresse tout autour de vous, " \
"sans espoir de survie."),
)
for detail in self.salle.details_etendus:
if detail.a_flag("cheminée"):
messages = msg_cheminee
cheminee = detail
if cheminee is None:
cfg_salle = importeur.anaconf.get_config("salle")
messages = cfg_salle.messages_feu
for puissance_max, msg in messages:
if self.puissance <= puissance_max:
retenu = msg
break
if cheminee:
retenu = lisser(retenu.format(cheminee=cheminee.titre))
retenu = retenu.capitalize()
return retenu
def __str__(self):
"""Méthode d'affichage du feu (fonction de la puissance)"""
cheminee = None
msg_cheminee = (
(1, "{cheminee} ne contient qu'un tas de cendres encore chaudes."),
(5, "{cheminee} contient encore quelques flammes vacillantes."),
(8, "Quelques flammes encore vives brûlent dans {cheminee}."),
(15, "Un feu clair crépite gaiement au coeur de {cheminee}."),
(25, "De hautes flammes dansent au coeur de {cheminee}."),
(40, "Un feu trop ardent emplit littéralement {cheminee}."),
(55, "Un début d'incendie menace, envahissant peu à peu les lieux."),
(70, "Un brasier enthousiaste flamboie ici et vous roussit le " \
"poil."),
(85, "Une fournaise étouffante vous prend à la gorge et menace " \
"de vous consummer."),
(100, "Un véritable bûcher se dresse tout autour de vous, " \
"sans espoir de survie."),
)
for detail in self.salle.details_etendus:
if detail.a_flag("cheminée"):
messages = msg_cheminee
cheminee = detail
if cheminee is None:
cfg_salle = importeur.anaconf.get_config("salle")
messages = cfg_salle.messages_feu
for puissance_max, msg in messages:
if self.puissance <= puissance_max:
retenu = msg
break
if cheminee:
retenu = lisser(retenu.format(cheminee=cheminee.titre))
retenu = retenu.capitalize()
return retenu
def regarder(self, personnage):
"""Le personnage regarde l'objet"""
msg = BaseType.regarder(self, personnage)
if not getattr(self, "conteneur", False):
return msg
objets = []
for o, nb in self.conteneur.get_objets_par_nom():
if o.est_de_type("potion"):
article = str(nb) if nb > 1 else "une"
s = "s" if nb > 1 else ""
objets.append(lisser("{} mesure{s} de {}".format(article,
o.nom_singulier, s=s)))
else:
objets.append(o.get_nom(nb))
if objets:
msg += self.message_contenu
msg += "\n " + "\n ".join(objets)
else:
msg += self.message_vide
return msg
def traite(chaine, operations):
"""Traite une chaîne de caractères selon plusieurs opérations.
Cette fonction scripting permet de mettre en forme une chaîne
de caractères (la mettre en majuscule, minuscule, retirer
les accents...). Plusieurs opérations peuvent être précisées
en même temps (voir les exemples ci-dessous).
Paramètres à préciser :
* chaine : la chaîne d'origine (à transformer)
* operations : la chaîne contenant les flags de transformation
Les flags d'opération sont à préciser dans une chaîne avec
chaque nom de flag séparé par un espace. Voir les exemples
pour plus d'informations. Les flags disponibles sont :
* minuscule : met la chaîne en minuscule
* majuscule : met la chaîne en majuscule
* capital : met chaque première lettre de chaque mot en majuscule
* titre : la première lettre de la chaîne est mise en majuscules
* sans_accents : retire les accents.
* lisser : change "de un" en "d'un", "le un" en "l'un"...
* rogner : rogne les espaces au début et à la fin de la chaaîne
Exemples d'utilisation :
chaine = "BONNE JOURNÉE"
# Met la chaîne en minuscule
chaine = traite(chaine, "minuscule")
# chaine contient à présent "bonne journée"
chaine = "BONNE JOURNÉE"
# Met la chaîne en capital sans accents
chaine = traite(chaine, "capital sans_accents")
# chaine contient à présent "Bonne Journee"
# Puis met chaine en majuscule
chaine = traite(chaine, "majuscule")
# chaine contient à présent "BONNE JOURNEE"
chaine = "C'est une porte de acier."
chaine = traite(chaine, "lisser")
# chaine contient "C'est une porte d'acier."
"""
operations = operations.lower()
if not operations:
raise ErreurExecution("Précisez au moins une opération")
operations = operations.split(" ")
for operation in operations:
if operation == "minuscule":
chaine = chaine.lower()
elif operation == "majuscule":
chaine = chaine.upper()
elif operation == "titre":
chaine = chaine[0].upper() + chaine[1:]
elif operation == "capital":
chaine = chaine.title()
elif operation == "rogner":
chaine = chaine.strip(" ")
elif operation == "sans_accents":
chaine = supprimer_accents(chaine)
elif operation == "lisser":
chaine = lisser(chaine)
else:
raise ErreurExecution("Opération {} inconnue.".format(
repr(operation)))
return chaine
def nom_remettre(self):
"""Retourne le nom de la commande quand on remet un navire à l'eau."""
navire = self.navire
return lisser("Remise à l'eau de " + navire.nom)
def nom_acheter(self):
"""Retourne le nom quand un navire est en cours d'achat."""
modele = importeur.navigation.modeles[self.arguments[0]]
return lisser("Achat de " + modele.nom)
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
arme_de_jet = None
for objet in personnage.equipement.equipes:
if objet.est_de_type("arme de jet"):
arme_de_jet = objet
if arme_de_jet is None:
personnage << "|err|Vous n'équipez aucune arme de jet.|ff|"
return
if arme_de_jet.projectile is None:
personnage << "|err|Cette arme n'est pas chargée.|ff|"
return
salle = personnage.salle
if not personnage.est_immortel() and salle.a_flag("anti combat"):
personnage << "|err|Vous ne pouvez combattre ici.|ff|"
return
# Sélection de la cible
if dic_masques["personnage_present"]:
cible = dic_masques["personnage_present"].personnage
else:
cible = importeur.combat.cible.get(personnage)
if cible is None or (hasattr(cible, "connecte") and \
not cible.connecte) or cible.est_mort():
personnage << "|err|Vous ne visez personne actuellement.|ff|"
return
chemin = None
if personnage.salle is not cible.salle:
chemin = personnage.salle.trouver_chemin(cible.salle)
if chemin is None or not chemin.droit:
personnage << "|err|Vous ne disposez pas d'un bon " \
"angle de tir.|ff|"
return
if not personnage.est_immortel() and cible.salle.a_flag("anti combat"):
personnage << "|err|Vous ne pouvez combattre ici.|ff|"
return
projectile = arme_de_jet.projectile
degats = projectile.degats_fixes + projectile.degats_variables
if not personnage.est_immortel() and degats > 0:
if not cible.pk:
personnage << "|err|Vous ne pouvez tirer sur une cible " \
"qui n'a pas le flag PK activé.|ff|"
return
# 1. On fait partir le projectile
personnage << lisser("Vous libérez la tension de {}.".format(
arme_de_jet.get_nom()))
personnage.salle.envoyer(
lisser("{{}} libère la tension de {}.".format(
arme_de_jet.get_nom())), personnage)
arme_de_jet.projectile = None
arme_de_jet.script["décoche"].executer(personnage=personnage,
arme=arme_de_jet,
projectile=projectile,
cible=cible)
# 2. On parcourt les salles adjacentes, si il y en a
if chemin:
for sortie in chemin:
origine = sortie.parent
destination = sortie.salle_dest
direction = sortie.nom_complet
if origine is personnage.salle:
origine.envoyer("{} part en sifflant vers {}.".format(
projectile.get_nom().capitalize(), direction))
else:
origine.envoyer("{} passe en sifflant vers {}.".format(
projectile.get_nom().capitalize(), direction))
if destination is cible.salle:
destination.envoyer("{} arrive en sifflant dans les " \
"airs.".format(projectile.get_nom().capitalize()))
else:
# personnage et ible sont dans la même salle
personnage.salle.envoyer("{} part en sifflant dans l'air.".format(
projectile.get_nom().capitalize()))
# 3. On voit si on atteint on manque la cible
fact_p = varier(personnage.stats.agilite, 20) / 150
fact_p += (1 - personnage.poids / personnage.poids_max) / 4
fact_p += personnage.pratiquer_talent("maniement_arc") / 400
fact_c = varier(cible.stats.agilite, 20) / 150
fact_c += (1 - cible.poids / cible.poids_max) / 3
if fact_p > fact_c:
if projectile.degats_fixes == 0:
degats = 0
else:
degats = varier(projectile.degats_fixes, \
projectile.degats_variables, projectile.degats_fixes)
msg_auteur = "{} atteint {{}}"
msg_cible = "{} vous atteint de plein fouet"
if degats > 0:
msg_auteur += " ({degats} points)."
msg_cible += " ({degats} points) !"
else:
msg_auteur += "."
msg_cible += " !"
if personnage.salle is cible.salle:
personnage.envoyer(
msg_auteur.format(projectile.get_nom().capitalize(),
degats=degats), cible)
cible << msg_cible.format(projectile.get_nom().capitalize(),
degats=degats)
for autre in cible.salle.personnages:
if autre is not personnage and autre is not cible:
autre.envoyer(
"{} atteint {{}} de plein fouet.".format(
projectile.get_nom().capitalize()), cible)
# On appelle le script du projectile
projectile.script["atteint"].executer(auteur=personnage,
cible=cible,
projectile=projectile,
arme=arme_de_jet)
if degats > 0:
try:
cible.stats.vitalite -= degats
except DepassementStat:
cible << "Trop, c'est trop ! Vous perdez conscience."
cible.salle.envoyer("{} s'écroule sur le sol.", cible)
if personnage.salle is not cible.salle:
personnage << "Vous entendez un cri d'agonie non loin."
cible.mourir(adversaire=personnage)
else:
cible.reagir_attaque(personnage)
importeur.objet.supprimer_objet(projectile.identifiant)
else:
cible << "Vous esquivez {} d'un mouvement rapide.".format(
projectile.get_nom())
cible.salle.envoyer("{{}} esquive {} d'un mouvement " \
"rapide.".format(projectile.get_nom()), cible)
personnage.salle.objets_sol.ajouter(projectile)
def nom(self):
nom_piece = self.combinaison[0].nom.rstrip("s")
return lisser("une paire de {}s".format(nom_piece))
def envoyer_lisser(self, chaine, *personnages, **kw_personnages):
"""Méthode redirigeant vers envoyer mais lissant la chaîne."""
self.envoyer(lisser(chaine), *personnages, **kw_personnages)
def nom(self):
nom_1 = self.combinaison[0].nom.rstrip("s")
nom_2 = self.combinaison[2].nom.rstrip("s")
return lisser("une double-paire de {}s et de {}s".format(nom_1, nom_2))
def nom(self):
nom_piece = self.combinaison[0].nom_complet_defini
nom_piece = " ".join(nom_piece.split(" ")[:-2])
return lisser("une couleur à {}".format(nom_piece))
def nom(self):
nom_1 = self.combinaison[0].nom.rstrip("s")
nom_2 = self.combinaison[2].nom.rstrip("s")
return lisser("une double-paire de {}s et de {}s".format(nom_1, nom_2))
def nom_remettre(self):
"""Retourne le nom de la commande quand on remet un navire à l'eau."""
navire = self.navire
return lisser("Remise à l'eau de " + navire.nom)
def nom_renommer(self):
"""Retourne le nom de la commande quand on renomme un navire."""
navire = self.navire
return lisser("Changement de nom de " + navire.nom)
def nom_acheter(self):
"""Retourne le nom quand un navire est en cours d'achat."""
modele = importeur.navigation.modeles[self.arguments[0]]
return lisser("Achat de " + modele.nom)
def nom(self):
nom_piece = self.combinaison[0].nom_complet_defini
nom_piece = " ".join(nom_piece.split(" ")[:-2])
return lisser("une couleur à {}".format(nom_piece))
def nom_renommer(self):
"""Retourne le nom de la commande quand on renomme un navire."""
navire = self.navire
return lisser("Changement de nom de " + navire.nom)
def nom_reparer(self):
"""Retourne le nom de la commande quand on répare un navire."""
navire = self.navire
return lisser("Réparation de " + navire.nom)
def nom(self):
nom_piece = self.combinaison[0].nom.rstrip("s")
return lisser("une paire de {}s".format(nom_piece))
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
arme_de_jet = None
for objet in personnage.equipement.equipes:
if objet.est_de_type("arme de jet"):
arme_de_jet = objet
if arme_de_jet is None:
personnage << "|err|Vous n'équipez aucune arme de jet.|ff|"
return
if arme_de_jet.projectile is None:
personnage << "|err|Cette arme n'est pas chargée.|ff|"
return
salle = personnage.salle
if not personnage.est_immortel() and salle.a_flag("anti combat"):
personnage << "|err|Vous ne pouvez combattre ici.|ff|"
return
# Sélection de la cible
if dic_masques["personnage_present"]:
cible = dic_masques["personnage_present"].personnage
else:
cible = importeur.combat.cible.get(personnage)
if cible is None or (hasattr(cible, "connecte") and \
not cible.connecte) or cible.est_mort():
personnage << "|err|Vous ne visez personne actuellement.|ff|"
return
chemin = None
if personnage.salle is not cible.salle:
chemin = personnage.salle.trouver_chemin(cible.salle)
if chemin is None or not chemin.droit:
personnage << "|err|Vous ne disposez pas d'un bon " \
"angle de tir.|ff|"
return
if not personnage.est_immortel() and cible.salle.a_flag("anti combat"):
personnage << "|err|Vous ne pouvez combattre ici.|ff|"
return
projectile = arme_de_jet.projectile
degats = projectile.degats_fixes + projectile.degats_variables
if not personnage.est_immortel() and degats > 0:
if not cible.pk:
personnage << "|err|Vous ne pouvez tirer sur une cible " \
"qui n'a pas le flag PK activé.|ff|"
return
# 1. On fait partir le projectile
personnage << lisser("Vous libérez la tension de {}.".format(
arme_de_jet.get_nom()))
personnage.salle.envoyer(lisser("{{}} libère la tension de {}.".format(
arme_de_jet.get_nom())), personnage)
arme_de_jet.projectile = None
arme_de_jet.script["décoche"].executer(personnage=personnage,
arme=arme_de_jet, projectile=projectile, cible=cible)
# 2. On parcourt les salles adjacentes, si il y en a
if chemin:
for sortie in chemin:
origine = sortie.parent
destination = sortie.salle_dest
direction = sortie.nom_complet
if origine is personnage.salle:
origine.envoyer("{} part en sifflant vers {}.".format(
projectile.get_nom().capitalize(), direction))
else:
origine.envoyer("{} passe en sifflant vers {}.".format(
projectile.get_nom().capitalize(), direction))
if destination is cible.salle:
destination.envoyer("{} arrive en sifflant dans les " \
"airs.".format(projectile.get_nom().capitalize()))
else:
# personnage et ible sont dans la même salle
personnage.salle.envoyer("{} part en sifflant dans l'air.".format(
projectile.get_nom().capitalize()))
# 3. On voit si on atteint on manque la cible
fact_p = varier(personnage.stats.agilite, 20) / 150
fact_p += (1 - personnage.poids / personnage.poids_max) / 4
fact_p += personnage.pratiquer_talent("maniement_arc") / 400
fact_c = varier(cible.stats.agilite, 20) / 150
fact_c += (1 - cible.poids / cible.poids_max) / 3
if fact_p > fact_c:
if projectile.degats_fixes == 0:
degats = 0
else:
degats = varier(projectile.degats_fixes, \
projectile.degats_variables, projectile.degats_fixes)
msg_auteur = "{} atteint {{}}"
msg_cible = "{} vous atteint de plein fouet"
if degats > 0:
msg_auteur += " ({degats} points)."
msg_cible += " ({degats} points) !"
else:
msg_auteur += "."
msg_cible += " !"
if personnage.salle is cible.salle:
personnage.envoyer(msg_auteur.format(
projectile.get_nom().capitalize(),
degats=degats), cible)
cible << msg_cible.format(projectile.get_nom().capitalize(),
degats=degats)
for autre in cible.salle.personnages:
if autre is not personnage and autre is not cible:
autre.envoyer("{} atteint {{}} de plein fouet.".format(
projectile.get_nom().capitalize()), cible)
# On appelle le script du projectile
projectile.script["atteint"].executer(auteur=personnage,
cible=cible, projectile=projectile, arme=arme_de_jet)
if degats > 0:
try:
cible.stats.vitalite -= degats
except DepassementStat:
cible << "Trop, c'est trop ! Vous perdez conscience."
cible.salle.envoyer("{} s'écroule sur le sol.", cible)
if personnage.salle is not cible.salle:
personnage << "Vous entendez un cri d'agonie non loin."
cible.mourir(adversaire=personnage)
else:
cible.reagir_attaque(personnage)
importeur.objet.supprimer_objet(projectile.identifiant)
else:
cible << "Vous esquivez {} d'un mouvement rapide.".format(
projectile.get_nom())
cible.salle.envoyer("{{}} esquive {} d'un mouvement " \
"rapide.".format(projectile.get_nom()), cible)
personnage.salle.objets_sol.ajouter(projectile)
def nom_reparer(self):
"""Retourne le nom de la commande quand on répare un navire."""
navire = self.navire
return lisser("Réparation de " + navire.nom)
def regarder(self, personnage, elt=None, variables=None):
"""Le personnage regarde la description."""
variables = variables or {}
for ajout in importeur.hook["description:ajouter_variables"].executer(
self, personnage, elt):
variables.update(ajout)
description = ""
desc_flottantes = []
elt = elt or self.parent
for paragraphe in self.paragraphes:
paragraphe = paragraphe.replace("|nl|", "\n").replace(
"|tab|", " ")
if self.scriptable:
# On charge récursivement les descriptions flottantes
paragraphe, flottantes = self.charger_descriptions_flottantes(
paragraphe)
desc_flottantes += [fl.description for fl in flottantes if \
fl.description not in desc_flottantes]
description += paragraphe + "\n"
description = description.rstrip("\n ")
if self.scriptable:
evts = re.findall(r"(\$[a-z0-9]+)([\n ,.]|$)", description)
else:
evts = []
evts = [e[0] for e in evts]
desc_flottantes.insert(0, self)
for nom_complet in evts:
nom = nom_complet[1:]
trouve = False
if variables.get(nom):
retour = variables[nom]
description = description.replace(nom_complet, retour)
trouve = True
for desc in desc_flottantes:
if trouve:
break
evt = desc.script["regarde"]
if nom in evt.evenements:
evt = evt.evenements[nom]
evt.executer(True, regarde=elt, personnage=personnage)
retour = evt.espaces.variables["retour"]
retour = retour.replace("_b_nl_b_", "\n")
description = description.replace(nom_complet, retour)
trouve = True
break
if not trouve:
raise ValueError("impossible de trouver la description " \
"dynamique '{}'".format(nom))
paragraphes = []
for paragraphe in description.split("\n"):
paragraphes.append("\n".join(wrap(lisser(paragraphe),
TAILLE_LIGNE)))
return "\n".join(paragraphes)