def preparer(self):
"""On ajoute les guildes déjà ouvertes."""
guildes = self.guildes_ouvertes
self.logger.info(
format_nb(len(guildes), "{nb} guilde{s} ouverte{s}", fem=True))
# Ajout des commandes dynamiques
commandes = []
nb_cmd = 0
for guilde in self.guildes.values():
for commande in guilde.commandes:
self.commandes_dynamiques[commande.nom_francais_complet] = \
commande
commandes.append(commande)
for talent in guilde.talents.values():
if talent.ouvert:
talent.ajouter()
commandes.sort(key=lambda c: str(c))
for commande in commandes:
try:
commande.ajouter()
except Exception as err:
self.logger.warning("Erreur lors de l'ajout de " \
"la commande {}".format(commande))
self.logger.warning(traceback.format_exc())
else:
commande.maj()
nb_cmd += 1
self.logger.info(
format_nb(nb_cmd,
"{nb} commande{s} dynamique{s} créée{s}",
fem=True))
def init(self):
"""Méthode d'initialisation du module."""
self.importeur.hook["temps:annee"].ajouter_evenement(
self.actualiser_cycles)
self.importeur.hook["temps:jour"].ajouter_evenement(
self.actualiser_periodes)
# On récupère les prototypes
prototypes = importeur.supenr.charger_groupe(PrototypePlante)
for prototype in prototypes:
self.ajouter_prototype(prototype)
if prototype.plantes:
prototype.n_id = max(p.n_id for p in \
prototype.plantes) + 1
for plante in prototype.plantes:
self.ajouter_plante(plante)
nb_prototypes = len(prototypes)
self.logger.info(format_nb(nb_prototypes, "{nb} prototype{s} " \
"de plante récupéré{s}"))
nb_plantes = len(self.plantes)
self.logger.info(format_nb(nb_plantes, "{nb} plante{s} " \
"récupérée{s}", fem=True))
BaseModule.init(self)
def preparer(self):
"""On ajoute les guildes déjà ouvertes."""
guildes = self.guildes_ouvertes
self.logger.info(format_nb(len(guildes),
"{nb} guilde{s} ouverte{s}", fem=True))
# Ajout des commandes dynamiques
commandes = []
nb_cmd = 0
for guilde in self.guildes.values():
for commande in guilde.commandes:
self.commandes_dynamiques[commande.nom_francais_complet] = \
commande
commandes.append(commande)
for talent in guilde.talents.values():
if talent.ouvert:
talent.ajouter()
commandes.sort(key=lambda c: str(c))
for commande in commandes:
try:
commande.ajouter()
except Exception as err:
self.logger.warning("Erreur lors de l'ajout de " \
"la commande {}".format(commande))
self.logger.warning(traceback.format_exc())
else:
commande.maj()
nb_cmd += 1
self.logger.info(format_nb(nb_cmd,
"{nb} commande{s} dynamique{s} créée{s}", fem=True))
def init(self):
"""Méthode d'initialisation du module."""
self.importeur.hook["temps:annee"].ajouter_evenement(
self.actualiser_cycles)
self.importeur.hook["temps:jour"].ajouter_evenement(
self.actualiser_periodes)
# On récupère les prototypes
prototypes = importeur.supenr.charger_groupe(PrototypePlante)
for prototype in prototypes:
self.ajouter_prototype(prototype)
if prototype.plantes:
prototype.n_id = max(p.n_id for p in \
prototype.plantes) + 1
for plante in prototype.plantes:
self.ajouter_plante(plante)
nb_prototypes = len(prototypes)
self.logger.info(format_nb(nb_prototypes, "{nb} prototype{s} " \
"de plante récupéré{s}"))
nb_plantes = len(self.plantes)
self.logger.info(format_nb(nb_plantes, "{nb} plante{s} " \
"récupérée{s}", fem=True))
BaseModule.init(self)
def init(self):
"""Chargement des objets du module."""
# Ajout du prompt
importeur.perso.ajouter_prompt(PromptMonture)
# Ajout des talents
importeur.perso.ajouter_talent("apprivoisement", "apprivoisement",
"dressage", 0.4)
# On récupère les fiches de familier
fiches = self.importeur.supenr.charger_groupe(FicheFamilier)
for fiche in fiches:
self.ajouter_fiche_familier(fiche)
self.logger.info(
format_nb(len(fiches),
"{nb} fiche{s} de familier récupérée{s}",
fem=True))
# On récupère les familiers
familiers = self.importeur.supenr.charger_groupe(Familier)
for familier in familiers:
if familier.pnj:
self.ajouter_familier(familier)
self.logger.info(
format_nb(len(familiers), "{nb} familier{s} récupéré{s}"))
# Ajout de la catégorie de commande
self.importeur.interpreteur.categories["familier"] = \
"Familiers et montures"
# Abonne le module à plusieurs hooks PNJ
self.importeur.hook["pnj:arrive"].ajouter_evenement(self.arrive_PNJ)
self.importeur.hook["pnj:meurt"].ajouter_evenement(self.meurt_PNJ)
self.importeur.hook["pnj:détruit"].ajouter_evenement(self.detruire_pnj)
self.importeur.hook["pnj:nom"].ajouter_evenement(self.get_nom_familier)
self.importeur.hook["pnj:doit_afficher"].ajouter_evenement(
self.doit_afficher_pnj)
self.importeur.hook["pnj:tick"].ajouter_evenement(self.tick_PNJ)
self.importeur.hook["pnj:gagner_xp"].ajouter_evenement(
self.gagner_xp_PNJ)
self.importeur.hook["pnj:gagner_niveau"].ajouter_evenement(
self.gagner_niveau_PNJ)
importeur.hook["scripting:deplacer_alea_personnage"].ajouter_evenement(
self.peut_deplacer_alea_personnage)
# Abonne le module au déplacement de personnage
self.importeur.hook["personnage:peut_deplacer"].ajouter_evenement(
self.peut_deplacer_personnage)
self.importeur.hook["personnage:deplacer"].ajouter_evenement(
self.deplacer_personnage)
self.importeur.hook["personnage:calculer_endurance"].ajouter_evenement(
self.calculer_endurance)
self.importeur.hook["personnage:verbe_deplacer"].ajouter_evenement(
self.get_verbe_deplacer)
self.importeur.hook["personnage:verbe_arriver"].ajouter_evenement(
self.get_verbe_arriver)
BaseModule.init(self)
def init(self):
"""Chargement des objets du module."""
# Ajout des talents
importeur.perso.ajouter_talent("apprivoisement", "apprivoisement",
"dressage", 0.4)
# On récupère les fiches de familier
fiches = self.importeur.supenr.charger_groupe(FicheFamilier)
for fiche in fiches:
self.ajouter_fiche_familier(fiche)
self.logger.info(format_nb(len(fiches),
"{nb} fiche{s} de familier récupérée{s}", fem=True))
# On récupère les familiers
familiers = self.importeur.supenr.charger_groupe(Familier)
for familier in familiers:
if familier.pnj:
self.ajouter_familier(familier)
self.logger.info(format_nb(len(familiers),
"{nb} familier{s} récupéré{s}"))
# Ajout de la catégorie de commande
self.importeur.interpreteur.categories["familier"] = \
"Familiers et montures"
# Abonne le module à plusieurs hooks PNJ
self.importeur.hook["pnj:arrive"].ajouter_evenement(
self.arrive_PNJ)
self.importeur.hook["pnj:meurt"].ajouter_evenement(
self.meurt_PNJ)
self.importeur.hook["pnj:détruit"].ajouter_evenement(
self.detruire_pnj)
self.importeur.hook["pnj:nom"].ajouter_evenement(
self.get_nom_familier)
self.importeur.hook["pnj:doit_afficher"].ajouter_evenement(
self.doit_afficher_pnj)
self.importeur.hook["pnj:tick"].ajouter_evenement(
self.tick_PNJ)
self.importeur.hook["pnj:gagner_xp"].ajouter_evenement(
self.gagner_xp_PNJ)
importeur.hook["scripting:deplacer_alea_personnage"].ajouter_evenement(
self.peut_deplacer_alea_personnage)
# Abonne le module au déplacement de personnage
self.importeur.hook["personnage:peut_deplacer"].ajouter_evenement(
self.peut_deplacer_personnage)
self.importeur.hook["personnage:deplacer"].ajouter_evenement(
self.deplacer_personnage)
self.importeur.hook["personnage:calculer_endurance"].ajouter_evenement(
self.calculer_endurance)
self.importeur.hook["personnage:verbe_deplacer"].ajouter_evenement(
self.get_verbe_deplacer)
self.importeur.hook["personnage:verbe_arriver"].ajouter_evenement(
self.get_verbe_arriver)
BaseModule.init(self)
def accueil(self):
"""Message d'accueil du contexte"""
detail = self.objet
msg = "| |tit|" + "Edition du détail '{}'".format(detail).ljust(76)
msg += "|ff||\n" + self.opts.separateur + "\n"
msg += self.aide_courte
msg += format_nb(detail.nb_places_assises,
"{nb} place{s} assise{s} ", fem=True)
msg += "(récupération : {}).\n".format(detail.facteur_asseoir)
msg += format_nb(detail.nb_places_allongees,
"{nb} place{s} allongée{s} ", fem=True)
msg += "(récupération : {}).\n".format(detail.facteur_allonger)
msg += "Connecteur : |ent|" + detail.connecteur + "|ff|\n"
return msg
def joueur_connecte(self, joueur):
"""On avertit du nombre de rapports qui lui sont assignés."""
rapports = [r for r in self.rapports.values() if r.ouvert and \
r.assigne_a is joueur]
if rapports:
joueur << format_nb(len(rapports), "{nb} rapport{s} vous " \
"{est} actuellement assigné{s}.")
def entrer(self):
newsletter = self.objet
nb_envoi = newsletter.envoyer()
msg = format_nb(nb_envoi, "{nb} messages envoyés.")
msg = msg.capitalize()
self.fermer()
self.pere << "|att|{}|ff|".format(msg)
def accueil(self):
"""Message d'accueil du contexte"""
detail = self.objet
msg = "| |tit|" + "Edition du détail '{}'".format(detail).ljust(76)
msg += "|ff||\n" + self.opts.separateur + "\n"
msg += self.aide_courte
msg += format_nb(detail.nb_places_assises,
"{nb} place{s} assise{s} ",
fem=True)
msg += "(récupération : {}).\n".format(detail.facteur_asseoir)
msg += format_nb(detail.nb_places_allongees,
"{nb} place{s} allongée{s} ",
fem=True)
msg += "(récupération : {}).\n".format(detail.facteur_allonger)
msg += "Connecteur : |ent|" + detail.connecteur + "|ff|\n"
return msg
def informer_alertes(self, personnage):
"""Informe le personnage si des alertes non résolues sont à lire.
Ce message n'est envoyé que si le personnage est immortel.
"""
if personnage.est_immortel() and self.alertes:
msg = format_nb(len(self.alertes),
"|rg|{nb} alerte{s} non résolue{s}.|ff|", fem=True)
personnage << msg
def init(self):
"""Chargement des objets du module."""
diligences = self.importeur.supenr.charger_groupe(DiligenceMaudite)
for diligence in diligences:
self.ajouter_diligence(diligence)
self.logger.info(format_nb(len(diligences),
"{nb} diligence{s} maudite{s} récupérée{s}", fem=True))
BaseModule.init(self)
def informer_alertes(self, personnage):
"""Informe le personnage si des alertes non résolues sont à lire.
Ce message n'est envoyé que si le personnage est immortel.
"""
if personnage.est_immortel() and self.alertes:
msg = format_nb(len(self.alertes),
"|rg|{nb} alerte{s} non résolue{s}.|ff|",
fem=True)
personnage << msg
def init(self):
"""Initialisation du module"""
prototypes = self.importeur.supenr.charger_groupe(BaseType)
for prototype in prototypes:
self._prototypes[prototype.cle] = prototype
nb_prototypes = len(prototypes)
self.logger.info(format_nb(nb_prototypes, "{nb} prototype{s} " \
"d'objet récupéré{s}"))
objets = self.importeur.supenr.charger_groupe(Objet)
for objet in objets:
if objet.prototype:
self._objets[objet.identifiant] = objet
nb_objets = len(objets)
self.logger.info(format_nb(nb_objets, "{nb} objet{s} récupéré{s}"))
self.cherchable_pry = cherchables.prototype.CherchablePrototypeObjet
BaseModule.init(self)
def init(self):
"""Initialisation du module"""
prototypes = self.importeur.supenr.charger_groupe(BaseType)
for prototype in prototypes:
self._prototypes[prototype.cle] = prototype
nb_prototypes = len(prototypes)
self.logger.info(format_nb(nb_prototypes, "{nb} prototype{s} " \
"d'objet récupéré{s}"))
objets = self.importeur.supenr.charger_groupe(Objet)
for objet in objets:
if objet.prototype:
self._objets[objet.identifiant] = objet
nb_objets = len(objets)
self.logger.info(format_nb(nb_objets, "{nb} objet{s} récupéré{s}"))
self.cherchable_pry = cherchables.prototype.CherchablePrototypeObjet
BaseModule.init(self)
def init(self):
"""Chargement des objets du module."""
# Abonnement aux hooks
self.importeur.hook["editeur:etendre"].ajouter_evenement(
self.ajouter_tags)
# Charge les tags
self.configuration = self.importeur.supenr.charger_unique(Tags)
if self.configuration is None:
self.configuration = Tags()
tags = self.importeur.supenr.charger_groupe(Tag)
groupes = {}
for tag in tags:
self.ajouter_tag(tag)
if tag.type not in groupes:
groupes[tag.type] = []
groupe = groupes[tag.type]
groupe.append(tag)
self.logger.info(format_nb(len(tags),
"{nb} tag{s} récupéré{s}"))
for type, groupe in groupes.items():
self.logger.info(format_nb(len(groupe),
"Dont {nb} tag{s} du type " + type))
# Réferencement des clés
self.cles = {
"objet": importeur.objet._prototypes,
"pnj": importeur.pnj._prototypes,
"salle": importeur.salle._salles,
}
# Abbonnement aux hooks
self.importeur.hook["recherche:filtres"].ajouter_evenement(
self.recherche_tags)
BaseModule.init(self)
def preparer(self):
"""On ajoute les guildes déjà ouvertes."""
guildes = self.guildes_ouvertes
self.logger.info(format_nb(len(guildes),
"{nb} guilde{s} ouverte{s}", fem=True))
# Ajout des commandes dynamiques
nb_cmd = 0
for guilde in self.guildes.values():
for commande in guilde.commandes:
self.commandes_dynamiques[commande.nom_francais_complet] = \
commande
commande.ajouter()
commande.maj()
nb_cmd += 1
for talent in guilde.talents.values():
if talent.ouvert:
talent.ajouter()
self.logger.info(format_nb(nb_cmd,
"{nb} commande{s} dynamique{s} créée{s}", fem=True))
def init(self):
"""Chargement des objets du module."""
routes = self.importeur.supenr.charger_groupe(Route)
for route in routes:
if route.ident:
self.ajouter_route(route)
self.logger.info(format_nb(len(routes),
"{nb} route{s} récupérée{s}", fem=True))
self.importeur.hook["personnage:deplacer"].ajouter_evenement(
self.etendre_route)
BaseModule.init(self)
def init(self):
"""Initialisation du module"""
evenements = self.importeur.supenr.charger_groupe(Evenement)
if self.evenements:
Evenement.id_actuel = max(self.evenements.keys()) + 1
for evenement in evenements:
self.evenements[evenement.id] = evenement
self.logger.info(format_nb(len(self.evenements),
"{nb} évènement{s} récupéré{s}", fem = False))
BaseModule.init(self)
def init(self):
"""Initialisation du module"""
# On récupère les recettes
recettes = self.importeur.supenr.charger_groupe(Recette)
for recette in recettes:
self.recettes[recette.cle] = recette
nb_recettes = len(self.recettes)
self.logger.info(
format_nb(nb_recettes, "{nb} recette{s} récupérée{s}", fem=True))
ajouter_talent = self.importeur.perso.ajouter_talent
ajouter_talent("cuisine", "cuisine", "survie", 0.20)
BaseModule.init(self)
def init(self):
"""Initialisation du module"""
# On récupère les recettes
recettes = self.importeur.supenr.charger_groupe(Recette)
for recette in recettes:
self.recettes[recette.cle] = recette
nb_recettes = len(self.recettes)
self.logger.info(format_nb(nb_recettes,
"{nb} recette{s} récupérée{s}", fem=True))
ajouter_talent = self.importeur.perso.ajouter_talent
ajouter_talent("cuisine", "cuisine", "survie", 0.20)
BaseModule.init(self)
def accueil(self):
"""Message d'accueil du contexte"""
evenement = self.objet
msg = "| |tit|" + "Responsables de {}".format(evenement.id).ljust(76)
msg += "|ff||\n" + self.opts.separateur + "\n"
msg += self.aide_courte
msg += format_nb(len(evenement.responsables), \
"{nb} responsable{s} actuel{s} :\n")
# Parcours des responsables
responsables = evenement.responsables
for resp in responsables:
msg += "\n {}".format(resp.nom)
return msg
def accueil(self):
"""Message d'accueil du contexte"""
evenement = self.objet
msg = "| |tit|" + "Responsables de {}".format(evenement.id).ljust(76)
msg += "|ff||\n" + self.opts.separateur + "\n"
msg += self.aide_courte
msg += format_nb(len(evenement.responsables), \
"{nb} responsable{s} actuel{s} :\n")
# Parcours des responsables
responsables = evenement.responsables
for resp in responsables:
msg += "\n {}".format(resp.nom)
return msg
def init(self):
"""Initialisation du module"""
evenements = self.importeur.supenr.charger_groupe(Evenement)
if self.evenements:
Evenement.id_actuel = max(self.evenements.keys()) + 1
for evenement in evenements:
self.evenements[evenement.id] = evenement
self.logger.info(
format_nb(len(self.evenements),
"{nb} évènement{s} récupéré{s}",
fem=False))
BaseModule.init(self)
def init(self):
"""Chargement des navires et modèles."""
# On récupère les auberges
auberges = self.importeur.supenr.charger_groupe(Auberge)
for auberge in auberges:
self.ajouter_auberge(auberge)
nb_auberges = len(auberges)
self.logger.info(
format_nb(nb_auberges, "{nb} auberge{s} récupérée{s}", fem=True))
Salle.peut_entrer = Module.peut_entrer
self.importeur.hook["joueur:connecte"].ajouter_evenement(
self.expulser_joueur)
BaseModule.init(self)
def init(self):
"""Chargement des navires et modèles."""
# On récupère les auberges
auberges = self.importeur.supenr.charger_groupe(Auberge)
for auberge in auberges:
self.ajouter_auberge(auberge)
nb_auberges = len(auberges)
self.logger.info(format_nb(nb_auberges,
"{nb} auberge{s} récupérée{s}", fem=True))
Salle.peut_entrer = Module.peut_entrer
self.importeur.hook["joueur:connecte"].ajouter_evenement(
self.expulser_joueur)
BaseModule.init(self)
def init(self):
"""Initialisation du module.
On récupère les instances de connexion et on les stocke dans
'self.instances' si elles sont encore connectées.
"""
comptes_a_pas_effacer = []
# On récupère les comptes
comptes = self.importeur.supenr.charger_groupe(Compte)
for compte in comptes:
self.comptes[compte.nom] = compte
# On récupère les instances de connexion
objets = []
comptes_a_pas_effacer = []
for inst in objets:
if inst.client.n_id in type(self.importeur).serveur.clients.keys():
nouv_instance = InstanceConnexion(inst.client, False)
nouv_instance.creer_depuis(inst)
self.instances[inst.client.n_id] = nouv_instance
if (nouv_instance.compte):
comptes_a_pas_effacer.append(nouv_instance.compte.nom)
for compte in comptes:
if (not compte.valide) and (not compte.nom in comptes_a_pas_effacer):
self.supprimer_compte(compte)
nb_comptes = len(self.comptes)
self.cpt_logger.info(
format_nb(nb_comptes, "{nb} compte{s} récupéré{s}"))
# On récupère ou crée la table des bannissements
bannissements = self.importeur.supenr.charger_unique(Bannissements)
if bannissements is None:
bannissements = Bannissements()
else:
self.bannissements_temporaires = bannissements.temporaires
self.joueurs_bannis = bannissements.joueurs
self.bannissements = bannissements
BaseModule.init(self)
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
joueurs = type(self).importeur.connex.joueurs_connectes
if not joueurs:
personnage.envoyer("Aucun joueur ne semble être présent, mais " \
"qui es-tu alors ?")
else:
noms_joueurs = {}
for joueur in joueurs:
imm = 0
if joueur.est_immortel():
nom = "|cyc|~ " + joueur.nom + " ~|ff|"
imm = 9
else:
nom = " " + joueur.nom
if joueur.afk:
raison = ""
if joueur.afk is not "afk":
raison = " '" + joueur.afk + "'"
nom += " (|rgc|AFK" + raison + "|ff|)"
noms_joueurs[joueur] = nom.ljust(48 + imm) + "|"
else:
noms_joueurs[joueur] = nom.ljust(39 + imm) + "|"
res = "+" + "-" * 40 + "+\n"
res += "| |tit|Joueurs présents|ff|".ljust(50) + "|\n"
res += "+" + "-" * 40 + "+"
for j, nom in sorted(noms_joueurs.items(),
key=lambda c: supprimer_accents(c[0].nom)):
res += "\n| " + nom
res += "\n+" + "-" * 40 + "+\n"
nb_joueurs = len(joueurs)
nb_imms = len([j for j in noms_joueurs.keys() if j.est_immortel()])
imms = ""
if nb_imms > 0:
s = "s" if nb_imms > 1 else ""
nb = "un" if nb_imms == 1 else str(nb_imms)
imms = ", dont |jn|{nb} immortel{s}|ff|".format(nb=nb, s=s)
res += format_nb(
nb_joueurs, "{{nb}} joueur{{s}} connecté{{s}}{}.".format(imms))
personnage << res
def interpreter(self, personnage, dic_masques):
"""Interprétation de la commande"""
joueurs = type(self).importeur.connex.joueurs_connectes
if not joueurs:
personnage.envoyer("Aucun joueur ne semble être présent, mais " \
"qui es-tu alors ?")
else:
noms_joueurs = {}
for joueur in joueurs:
imm = 0
if joueur.est_immortel():
nom = "|cyc|~ " + joueur.nom + " ~|ff|"
imm = 9
else:
nom = " " + joueur.nom
if joueur.afk:
raison = ""
if joueur.afk is not "afk":
raison = " '" + joueur.afk + "'"
nom += " (|rgc|AFK" + raison + "|ff|)"
noms_joueurs[joueur] = nom.ljust(48 + imm) + "|"
else:
noms_joueurs[joueur] = nom.ljust(39 + imm) + "|"
res = "+" + "-" * 40 + "+\n"
res += "| |tit|Joueurs présents|ff|".ljust(50) + "|\n"
res += "+" + "-" * 40 + "+"
for j, nom in sorted(noms_joueurs.items(),
key=lambda c: supprimer_accents(c[0].nom)):
res += "\n| " + nom
res += "\n+" + "-" * 40 + "+\n"
nb_joueurs = len(joueurs)
nb_imms = len([j for j in noms_joueurs.keys() if j.est_immortel()])
imms = ""
if nb_imms > 0:
s = "s" if nb_imms > 1 else ""
nb = "un" if nb_imms == 1 else str(nb_imms)
imms = ", dont |jn|{nb} immortel{s}|ff|".format(nb=nb, s=s)
res += format_nb(nb_joueurs,
"{{nb}} joueur{{s}} connecté{{s}}{}.".format(imms))
personnage << res
def init(self):
"""Chargement des objets du module."""
guildes = self.importeur.supenr.charger_groupe(Guilde)
for guilde in guildes:
self.ajouter_guilde(guilde)
self.logger.info(
format_nb(len(guildes), "{nb} guilde{s} récupérée{s}", fem=True))
self.membres = self.importeur.supenr.charger_unique(Membres)
if self.membres is None:
self.membres = Membres()
self.configuration = self.importeur.supenr.charger_unique(
Configuration)
if self.configuration is None:
self.configuration = Configuration()
# Connexion aux hooks
self.importeur.hook["personnage:score"].ajouter_evenement(
self.etendre_score)
self.importeur.hook[
"personnage:points_apprentissage"].ajouter_evenement(
self.ajouter_points_apprentissage)
self.importeur.hook["editeur:etendre"].ajouter_evenement(
self.ajouter_attributs)
self.importeur.hook["editeur:etendre"].ajouter_evenement(
Extension.etendre_editeur)
self.importeur.hook["description:ajouter_variables"].ajouter_evenement(
self.ajouter_variables)
self.importeur.hook["scripting:changer_nom_objet"].ajouter_evenement(
self.get_attributs)
# Ajout de la catégorie de commande
self.importeur.interpreteur.categories["profession"] = \
"Commandes de profession"
BaseModule.init(self)
def init(self):
"""Chargement des objets du module."""
guildes = self.importeur.supenr.charger_groupe(Guilde)
for guilde in guildes:
self.ajouter_guilde(guilde)
self.logger.info(format_nb(len(guildes),
"{nb} guilde{s} récupérée{s}", fem=True))
self.membres = self.importeur.supenr.charger_unique(Membres)
if self.membres is None:
self.membres = Membres()
self.configuration = self.importeur.supenr.charger_unique(
Configuration)
if self.configuration is None:
self.configuration = Configuration()
# Connexion aux hooks
self.importeur.hook["personnage:score"].ajouter_evenement(
self.etendre_score)
self.importeur.hook[
"personnage:points_apprentissage"].ajouter_evenement(
self.ajouter_points_apprentissage)
self.importeur.hook["editeur:etendre"].ajouter_evenement(
self.ajouter_attributs)
self.importeur.hook["editeur:etendre"].ajouter_evenement(
Extension.etendre_editeur)
self.importeur.hook["description:ajouter_variables"].ajouter_evenement(
self.ajouter_variables)
self.importeur.hook["scripting:changer_nom_objet"].ajouter_evenement(
self.get_attributs)
# Ajout de la catégorie de commande
self.importeur.interpreteur.categories["profession"] = \
"Commandes de profession"
BaseModule.init(self)
def init(self):
"""Chargement des navires et modèles."""
self.importeur.scripting.valeurs["navire"] = self.navires
# Ajout du prompt
importeur.perso.ajouter_prompt(PromptNavigation)
self.importeur.hook["salle:regarder"].ajouter_evenement(
self.navire_amarre)
self.importeur.hook["salle:regarder"].ajouter_evenement(
self.navire_accoste)
self.importeur.hook["objet:peut_boire"].ajouter_evenement(
Navire.peut_boire)
self.importeur.interpreteur.categories["navire"] = \
"Commandes de navigation"
self.importeur.hook["pnj:arrive"].ajouter_evenement(
self.combat_matelot)
self.importeur.hook["pnj:attaque"].ajouter_evenement(
self.armer_matelot)
self.importeur.hook["pnj:détruit"].ajouter_evenement(
self.detruire_pnj)
self.importeur.hook["pnj:meurt"].ajouter_evenement(
self.meurt_PNJ)
self.importeur.hook["pnj:nom"].ajouter_evenement(
Equipage.get_nom_matelot)
self.importeur.hook["salle:trouver_chemins_droits"].ajouter_evenement(
self.trouver_chemins_droits)
self.importeur.hook["stats:infos"].ajouter_evenement(
self.stats_navigation)
self.importeur.hook["personnage:deplacer"].ajouter_evenement(
self.modifier_prompt)
self.importeur.hook["objet:doit_garder"].ajouter_evenement(
self.objets_en_cale)
# Ajout des talents
importeur.perso.ajouter_talent("calfeutrage", "calfeutrage",
"navigation", 0.5)
# On récupère les modèles
modeles = self.importeur.supenr.charger_groupe(ModeleNavire)
for modele in modeles:
self.modeles[modele.cle] = modele
nb_modeles = len(modeles)
self.nav_logger.info(format_nb(nb_modeles,
"{nb} modèle{s} de navire récupéré{s}"))
# On récupère les navires
navires = self.importeur.supenr.charger_groupe(Navire)
for navire in navires:
self.ajouter_navire(navire)
nb_navires = len(navires)
self.nav_logger.info(format_nb(nb_navires,
"{nb} navire{s} récupéré{s}"))
# On récupère les navires automatiques
fiches = self.importeur.supenr.charger_groupe(NavireAutomatique)
for fiche in fiches:
self.ajouter_navire_automatique(fiche)
nb_autos = len(fiches)
self.nav_logger.info(format_nb(nb_autos,
"{nb} fiche{s} de navire{s} automatique{s} " \
"récupérée{s}", fem=True))
# On récupère les éléments
elements = self.importeur.supenr.charger_groupe(BaseElement)
for element in elements:
self.elements[element.cle] = element
nb_elements = len(elements)
self.nav_logger.info(format_nb(nb_elements,
"{nb} élément{s} de navire récupéré{s}"))
# On récupère les vents
vents = self.importeur.supenr.charger_groupe(Vent)
for vent in vents:
self.ajouter_vent(vent)
nb_vents = len(self.vents)
self.nav_logger.info(format_nb(nb_vents,
"{nb} vent{s} récupéré{s}"))
# On récupère les fiches
fiches = self.importeur.supenr.charger_groupe(FicheMatelot)
for fiche in fiches:
self.ajouter_fiche_matelot(fiche)
nb_mat = len(self.fiches)
self.nav_logger.info(format_nb(nb_mat,
"{nb} fiche{s} de matelot récupérée{s}", fem=True))
# On récupère les trajets
trajets = self.importeur.supenr.charger_groupe(Trajet)
for trajet in trajets:
self.ajouter_trajet(trajet)
nb_trajets = len(self.trajets)
self.nav_logger.info(format_nb(nb_trajets,
"{nb} trajet{s} maritime{s} récupéré{s}"))
# On récupère les repères
reperes = self.importeur.supenr.charger_groupe(Repere)
for repere in reperes:
self.ajouter_repere(repere)
nb_reperes = len(self.reperes)
self.nav_logger.info(format_nb(nb_reperes,
"{nb} repère{s} récupéré{s}"))
# On récupère les chantiers navals
chantiers = self.importeur.supenr.charger_groupe(ChantierNaval)
for chantier in chantiers:
self.ajouter_chantier_naval(chantier)
nb_chantiers = len(chantiers)
self.nav_logger.info(format_nb(nb_chantiers,
"{nb} chantier{s} naval{s} récupéré{s}"))
# On récupère les monstres marins
# On charge les prototypes
chemin = os.path.join(self.chemin, "monstre", "types")
pychemin = "secondaires.navigation.monstre.types"
for nom_fichier in os.listdir(chemin):
if nom_fichier.startswith("_") or not nom_fichier.endswith(".py"):
continue
nom_fichier = pychemin + "." + nom_fichier[:-3]
__import__(nom_fichier)
# Ajout des actions différées
self.importeur.diffact.ajouter_action("dep_navire", TPS_VIRT,
self.avancer_navires)
self.importeur.diffact.ajouter_action("vir_navire", 3,
self.virer_navires)
self.importeur.diffact.ajouter_action("nauffrages", 5,
self.nauffrages)
self.importeur.diffact.ajouter_action("tick_chantiers", 60,
self.tick_chantiers)
# Ajout des bateaux au module salle
self.importeur.salle.salles_a_cartographier.append(
self.get_navires_presents)
# Ajout d'évènements
importeur.evt.ajouter_evenement("sombre", "Un navire sombre",
"Naufrage de {navire.cle}.", "navire:sombre")
BaseModule.init(self)
def init(self):
"""Méthode d'initialisation du module"""
# On récupère les salles
salles = importeur.supenr.charger_groupe(Salle)
for salle in salles:
self.ajouter_salle(salle)
nb_salles = len(self._salles)
self.logger.info(format_nb(nb_salles, "{nb} salle{s} récupérée{s}", \
fem=True))
# On récupère les étendues
etendues = self.importeur.supenr.charger_groupe(Etendue)
for etendue in etendues:
self.ajouter_etendue(etendue)
nb_etendues = len(self.etendues)
self.logger.info(format_nb(nb_etendues, "{nb} étendue{s} " \
"d'eau{x} récupérée{s}", fem=True))
# On récupère les obstacles
obstacles = self.importeur.supenr.charger_groupe(Obstacle)
for obstacle in obstacles:
self.ajouter_obstacle(obstacle)
# On récupère les décors
decors = importeur.supenr.charger_groupe(PrototypeDecor)
for decor in decors:
self.ajouter_decor(decor)
nb_decors = len(self.decors)
self.logger.info(format_nb(nb_decors, "{nb} décor{s} récupéré{s}"))
# On récupère les bonhommes de neige
bonhommes = importeur.supenr.charger_groupe(PrototypeBonhommeNeige)
for bonhomme in bonhommes:
self.ajouter_bonhomme_neige(bonhomme)
nb_bonhommes = len(self.bonhommes_neige)
self.logger.info(format_nb(nb_bonhommes, "{nb} prototype{s} " \
"de bonhomme de neige récupéré{s}"))
# On récupère les feux
feux = importeur.supenr.charger_groupe(Feu)
for feu in feux:
self.feux[feu.salle.ident] = feu
# On implémente le hook correspondant
self.importeur.hook["salle:regarder"].ajouter_evenement(
self.feu_present)
# On récupère les zones
zones = importeur.supenr.charger_groupe(Zone)
for zone in zones:
self._zones[zone.cle] = zone
nb_zones = len(self._zones)
self.logger.info(format_nb(nb_zones, "{nb} zone{s} récupérée{s}", \
fem=True))
importeur.diffact.ajouter_action("net_salles", 300,
self.nettoyer_salles)
importeur.diffact.ajouter_action("repop_salles", 900,
self.repop_salles)
importeur.diffact.ajouter_action("repop_feux", 5, Feu.repop)
# On ajoute les talents
importeur.perso.ajouter_talent("collecte_bois", "collecte de bois",
"survie", 0.55)
importeur.perso.ajouter_talent("feu_camp", "feu de camp", "survie",
0.23)
# Ajout des actions différées pour chaque tick
intervalle = 60 / NB_TICKS
for no in self.ticks.keys():
self.importeur.diffact.ajouter_action("stick_{}".format(no),
intervalle * no, self.tick, no)
# Ajout des hooks de changement de temps
self.importeur.hook["temps:minute"].ajouter_evenement(
self.changer_minute)
self.importeur.hook["temps:heure"].ajouter_evenement(
self.changer_heure)
self.importeur.hook["temps:jour"].ajouter_evenement(
self.changer_jour)
self.importeur.hook["temps:mois"].ajouter_evenement(
self.changer_mois)
self.importeur.hook["temps:annee"].ajouter_evenement(
self.changer_annee)
BaseModule.init(self)
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
def n_exit(code, msg):
"""Ne quitte pas Python."""
raise ValueError(msg)
direction = dic_masques["direction"].direction
salle = personnage.salle
options = ""
if dic_masques["texte_libre"]:
options = dic_masques["texte_libre"].texte
# Création de l'interpréteur d'option
parser = argparse.ArgumentParser(conflict_handler='resolve')
parser.exit = n_exit
parser.add_argument("-t", "--titre", action="store_true")
parser.add_argument("-d", "--description", action="store_true")
parser.add_argument("-e", "--details", action="store_true")
parser.add_argument("-m", "--mnemonique")
parser.add_argument("-c", "--script", action="store_true")
parser.add_argument("-s", "--sorties", action="store_true")
parser.add_argument("-h", "--horizontales", action="store_true")
parser.add_argument("-v", "--verticales", action="store_true")
parser.add_argument("-r", "--sans-reciproque", action="store_true")
try:
args = parser.parse_args(shlex.split(options))
except ValueError as err:
personnage << "|err|Les options n'ont pas été interprétées " \
"correctement : {}.|ff|".format(err)
return
if args.mnemonique:
try:
zone, mnemonic = args.mnemonique.split(":")
except ValueError:
zone = salle.nom_zone
mnemonic = args.mnemonique
else:
zone = salle.nom_zone
mnemonic = salle.zone.chercher_mnemonic_libre(salle.mnemonic)
dir_opposee = salle.sorties.get_nom_oppose(direction)
if salle.sorties.sortie_existe(direction):
raise ErreurInterpretation(
"|err|Cette direction a déjà été définie dans la salle.|ff|")
nv_coords = getattr(salle.coords, direction.replace("-", ""))
if nv_coords.valide and nv_coords in type(self).importeur.salle:
raise ErreurInterpretation(
"|err|Ces coordonnées sont déjà utilisées.|ff|")
x, y, z, valide = nv_coords.tuple_complet()
try:
nv_salle = importeur.salle.creer_salle(zone, mnemonic, x, y, z,
valide)
except ValueError as err_val:
personnage << str(err_val) + "."
else:
if args.sans_reciproque:
salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=nv_salle,
corresp=None)
nv_salle.sorties.ajouter_sortie(dir_opposee,
dir_opposee,
salle_dest=salle,
corresp=None)
else:
salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=nv_salle,
corresp=dir_opposee)
nv_salle.sorties.ajouter_sortie(dir_opposee,
dir_opposee,
salle_dest=salle,
corresp=direction)
nv_salle.interieur = salle.interieur
nv_salle.illuminee = salle.illuminee
nv_salle.nom_terrain = salle.nom_terrain
if args.titre:
nv_salle.titre = salle.titre
if args.description:
nv_salle.description.copier_depuis(salle.description)
if args.details:
nv_salle.details.copier_depuis(salle.details, True)
if args.script:
nv_salle.script.copier_depuis(salle.script)
personnage << "|att|La salle {} a bien été ajouté vers {}.|ff|". \
format(nv_salle.ident, salle.sorties[direction].nom_complet)
sup = None
if args.sorties:
sup = SORTIES
elif args.horizontales:
sup = HORIZONTALES
elif args.verticales:
sup = VERTICALES
if sup:
if not nv_coords.valide:
personnage << "|err|La salle créée n'a pas de " \
"coordonnées valides.|ff|"
return
nb = 0
for direction, coords in sup.items():
n_x = x + coords[0]
n_y = y + coords[1]
n_z = z + coords[2]
dir_opposee = nv_salle.sorties.get_nom_oppose(direction)
salle = importeur.salle._coords.get((n_x, n_y, n_z))
if salle is None:
continue
if not salle.sorties.sortie_existe(dir_opposee) and not \
nv_salle.sorties.sortie_existe(direction):
nv_salle.sorties.ajouter_sortie(direction,
direction,
salle_dest=salle,
corresp=dir_opposee)
salle.sorties.ajouter_sortie(dir_opposee,
dir_opposee,
salle_dest=nv_salle,
corresp=direction)
nb += 1
if nb > 0:
personnage << format_nb(nb, "{nb} sortie{s} " \
"supplémentaire{s} créée{s}.")
def preparer(self):
"""Préparation du module."""
if "cadavre" not in self._prototypes:
self.creer_prototype("cadavre", "cadavre")
if "boule_neige" not in self._prototypes:
self.creer_prototype("boule_neige", "boule de neige")
if "eau" not in self._prototypes:
eau = self.creer_prototype("eau", "potion")
eau.nom_singulier = "eau"
eau.description.ajouter_paragraphe(
"L'eau est claire et semble fraîche.")
eau.remplissant = 2
eau.message_boit = "Vous buvez une gorgée d'eau qui vous " \
"rafraîchit agréablement le gosier."
eau.poids_unitaire = 0.1
eau.prix = 0
# Nettoyage des objets existants sans lien
existants = []
for joueur in importeur.connex.joueurs:
if joueur.equipement:
existants.extend(joueur.equipement.objets_uniques)
for pnj in importeur.pnj.PNJ.values():
if pnj.equipement:
existants.extend(pnj.equipement.objets_uniques)
for salle in importeur.salle.salles.values():
existants.extend(salle.objets_uniques)
for decor in salle.decors:
if hasattr(decor, "elements"):
existants.extend(list(decor.elements.values()))
a_detruire = []
for objet in importeur.objet.objets.values():
objet.supprimer_inexistants()
if objet not in existants:
a_detruire.append(objet)
a_detruire = [o for o in a_detruire if o and o.prototype]
for a_garder in importeur.hook["objet:doit_garder"].executer():
for objet in a_garder:
if objet in a_detruire:
a_detruire.remove(objet)
self.logger.info(format_nb(len(a_detruire), "{nb} objet{s} à " \
"détruire"))
types = {}
for objet in a_detruire:
type = objet.nom_type
nb = types.get(type, 0)
nb += 1
types[type] = nb
try:
importeur.objet.supprimer_objet(objet.identifiant)
except KeyError:
objet.detruire()
for nom, nombre in sorted(types.items(), key=lambda c: c[1], \
reverse=True):
self.logger.info(" Dont {} de type {}".format(nombre, nom))
# Opérations de nettoyage cycliques
importeur.diffact.ajouter_action("net_boule de neige", 60,
self.nettoyage_cyclique, "boule de neige")
self.nettoyage_lumieres()
# Réinitialisation des scripts des prototypes
for prototype in self._prototypes.values():
prototype.etendre_script()
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
def n_exit(code, msg):
"""Ne quitte pas Python."""
raise ValueError(msg)
direction = dic_masques["direction"].direction
salle = personnage.salle
options = ""
if dic_masques["texte_libre"]:
options = dic_masques["texte_libre"].texte
# Création de l'interpréteur d'option
parser = argparse.ArgumentParser(conflict_handler='resolve')
parser.exit = n_exit
parser.add_argument("-t", "--titre", action="store_true")
parser.add_argument("-d", "--description", action="store_true")
parser.add_argument("-e", "--details", action="store_true")
parser.add_argument("-m", "--mnemonique")
parser.add_argument("-c", "--script", action="store_true")
parser.add_argument("-s", "--sorties", action="store_true")
parser.add_argument("-h", "--horizontales", action="store_true")
parser.add_argument("-v", "--verticales", action="store_true")
parser.add_argument("-r", "--sans-reciproque", action="store_true")
try:
args = parser.parse_args(shlex.split(options))
except ValueError as err:
personnage << "|err|Les options n'ont pas été interprétées " \
"correctement : {}.|ff|".format(err)
return
if args.mnemonique:
try:
zone, mnemonic = args.mnemonique.split(":")
except ValueError:
zone = salle.nom_zone
mnemonic = args.mnemonique
else:
zone = salle.nom_zone
mnemonic = salle.zone.chercher_mnemonic_libre(salle.mnemonic)
dir_opposee = salle.sorties.get_nom_oppose(direction)
if salle.sorties.sortie_existe(direction):
raise ErreurInterpretation(
"|err|Cette direction a déjà été définie dans la salle.|ff|")
nv_coords = getattr(salle.coords, direction.replace("-", ""))
if nv_coords.valide and nv_coords in type(self).importeur.salle:
raise ErreurInterpretation(
"|err|Ces coordonnées sont déjà utilisées.|ff|")
x, y, z, valide = nv_coords.tuple_complet()
try:
nv_salle = importeur.salle.creer_salle(zone, mnemonic,
x, y, z, valide)
except ValueError as err_val:
personnage << str(err_val) + "."
else:
if args.sans_reciproque:
salle.sorties.ajouter_sortie(direction, direction,
salle_dest=nv_salle, corresp=None)
nv_salle.sorties.ajouter_sortie(dir_opposee, dir_opposee,
salle_dest=salle, corresp=None)
else:
salle.sorties.ajouter_sortie(direction, direction,
salle_dest=nv_salle, corresp=dir_opposee)
nv_salle.sorties.ajouter_sortie(dir_opposee, dir_opposee,
salle_dest=salle, corresp=direction)
nv_salle.interieur = salle.interieur
nv_salle.illuminee = salle.illuminee
nv_salle.nom_terrain = salle.nom_terrain
if args.titre:
nv_salle.titre = salle.titre
if args.description:
nv_salle.description.copier_depuis(salle.description)
if args.details:
nv_salle.details.copier_depuis(salle.details, True)
if args.script:
nv_salle.script.copier_depuis(salle.script)
personnage << "|att|La salle {} a bien été ajouté vers {}.|ff|". \
format(nv_salle.ident, salle.sorties[direction].nom_complet)
sup = None
if args.sorties:
sup = SORTIES
elif args.horizontales:
sup = HORIZONTALES
elif args.verticales:
sup = VERTICALES
if sup:
if not nv_coords.valide:
personnage << "|err|La salle créée n'a pas de " \
"coordonnées valides.|ff|"
return
nb = 0
for direction, coords in sup.items():
n_x = x + coords[0]
n_y = y + coords[1]
n_z = z + coords[2]
dir_opposee = nv_salle.sorties.get_nom_oppose(direction)
salle = importeur.salle._coords.get((n_x, n_y, n_z))
if salle is None:
continue
if not salle.sorties.sortie_existe(dir_opposee) and not \
nv_salle.sorties.sortie_existe(direction):
nv_salle.sorties.ajouter_sortie(direction, direction,
salle_dest=salle, corresp=dir_opposee)
salle.sorties.ajouter_sortie(dir_opposee, dir_opposee,
salle_dest=nv_salle, corresp=direction)
nb += 1
if nb > 0:
personnage << format_nb(nb, "{nb} sortie{s} " \
"supplémentaire{s} créée{s}.")
def init(self):
"""Chargement des navires et modèles."""
self.importeur.scripting.valeurs["navire"] = self.navires
# Ajout du prompt
importeur.perso.ajouter_prompt(PromptNavigation)
self.importeur.hook["salle:regarder"].ajouter_evenement(
self.navire_amarre)
self.importeur.hook["salle:regarder"].ajouter_evenement(
self.navire_accoste)
self.importeur.hook["objet:peut_boire"].ajouter_evenement(
Navire.peut_boire)
self.importeur.interpreteur.categories["navire"] = \
"Commandes de navigation"
self.importeur.hook["pnj:arrive"].ajouter_evenement(
self.combat_matelot)
self.importeur.hook["pnj:attaque"].ajouter_evenement(
self.armer_matelot)
self.importeur.hook["pnj:détruit"].ajouter_evenement(self.detruire_pnj)
self.importeur.hook["pnj:meurt"].ajouter_evenement(self.meurt_PNJ)
self.importeur.hook["pnj:nom"].ajouter_evenement(
Equipage.get_nom_matelot)
self.importeur.hook["salle:trouver_chemins_droits"].ajouter_evenement(
self.trouver_chemins_droits)
self.importeur.hook["stats:infos"].ajouter_evenement(
self.stats_navigation)
self.importeur.hook["personnage:deplacer"].ajouter_evenement(
self.modifier_prompt)
self.importeur.hook["objet:doit_garder"].ajouter_evenement(
self.objets_en_cale)
# Ajout des talents
importeur.perso.ajouter_talent("calfeutrage", "calfeutrage",
"navigation", 0.5)
# On récupère les modèles
modeles = self.importeur.supenr.charger_groupe(ModeleNavire)
for modele in modeles:
self.modeles[modele.cle] = modele
nb_modeles = len(modeles)
self.nav_logger.info(
format_nb(nb_modeles, "{nb} modèle{s} de navire récupéré{s}"))
# On récupère les navires
navires = self.importeur.supenr.charger_groupe(Navire)
for navire in navires:
self.ajouter_navire(navire)
nb_navires = len(navires)
self.nav_logger.info(
format_nb(nb_navires, "{nb} navire{s} récupéré{s}"))
# On récupère les navires automatiques
fiches = self.importeur.supenr.charger_groupe(NavireAutomatique)
for fiche in fiches:
self.ajouter_navire_automatique(fiche)
nb_autos = len(fiches)
self.nav_logger.info(format_nb(nb_autos,
"{nb} fiche{s} de navire{s} automatique{s} " \
"récupérée{s}", fem=True))
# On récupère les éléments
elements = self.importeur.supenr.charger_groupe(BaseElement)
for element in elements:
self.elements[element.cle] = element
nb_elements = len(elements)
self.nav_logger.info(
format_nb(nb_elements, "{nb} élément{s} de navire récupéré{s}"))
# On récupère les vents
vents = self.importeur.supenr.charger_groupe(Vent)
for vent in vents:
self.ajouter_vent(vent)
nb_vents = len(self.vents)
self.nav_logger.info(format_nb(nb_vents, "{nb} vent{s} récupéré{s}"))
# On récupère les fiches
fiches = self.importeur.supenr.charger_groupe(FicheMatelot)
for fiche in fiches:
self.ajouter_fiche_matelot(fiche)
nb_mat = len(self.fiches)
self.nav_logger.info(
format_nb(nb_mat,
"{nb} fiche{s} de matelot récupérée{s}",
fem=True))
# On récupère les trajets
trajets = self.importeur.supenr.charger_groupe(Trajet)
for trajet in trajets:
self.ajouter_trajet(trajet)
nb_trajets = len(self.trajets)
self.nav_logger.info(
format_nb(nb_trajets, "{nb} trajet{s} maritime{s} récupéré{s}"))
# On récupère les repères
reperes = self.importeur.supenr.charger_groupe(Repere)
for repere in reperes:
self.ajouter_repere(repere)
nb_reperes = len(self.reperes)
self.nav_logger.info(
format_nb(nb_reperes, "{nb} repère{s} récupéré{s}"))
# On récupère les chantiers navals
chantiers = self.importeur.supenr.charger_groupe(ChantierNaval)
for chantier in chantiers:
self.ajouter_chantier_naval(chantier)
nb_chantiers = len(chantiers)
self.nav_logger.info(
format_nb(nb_chantiers, "{nb} chantier{s} naval{s} récupéré{s}"))
# On récupère les monstres marins
# On charge les prototypes
chemin = os.path.join(self.chemin, "monstre", "types")
pychemin = "secondaires.navigation.monstre.types"
for nom_fichier in os.listdir(chemin):
if nom_fichier.startswith("_") or not nom_fichier.endswith(".py"):
continue
nom_fichier = pychemin + "." + nom_fichier[:-3]
__import__(nom_fichier)
# Ajout des actions différées
self.importeur.diffact.ajouter_action("dep_navire", TPS_VIRT,
self.avancer_navires)
self.importeur.diffact.ajouter_action("vir_navire", 3,
self.virer_navires)
self.importeur.diffact.ajouter_action("nauffrages", 5, self.nauffrages)
self.importeur.diffact.ajouter_action("tick_chantiers", 60,
self.tick_chantiers)
# Ajout des bateaux au module salle
self.importeur.salle.salles_a_cartographier.append(
self.get_navires_presents)
# Ajout d'évènements
importeur.evt.ajouter_evenement("sombre", "Un navire sombre",
"Naufrage de {navire.cle}.",
"navire:sombre")
BaseModule.init(self)
def init(self):
"""Méthode d'initialisation du module"""
# On récupère les salles
salles = importeur.supenr.charger_groupe(Salle)
for salle in salles:
self.ajouter_salle(salle)
nb_salles = len(self._salles)
self.logger.info(format_nb(nb_salles, "{nb} salle{s} récupérée{s}", \
fem=True))
# On récupère les étendues
etendues = self.importeur.supenr.charger_groupe(Etendue)
for etendue in etendues:
self.ajouter_etendue(etendue)
nb_etendues = len(self.etendues)
self.logger.info(format_nb(nb_etendues, "{nb} étendue{s} " \
"d'eau{x} récupérée{s}", fem=True))
# On récupère les obstacles
obstacles = self.importeur.supenr.charger_groupe(Obstacle)
for obstacle in obstacles:
self.ajouter_obstacle(obstacle)
# On récupère les décors
decors = importeur.supenr.charger_groupe(PrototypeDecor)
for decor in decors:
self.ajouter_decor(decor)
nb_decors = len(self.decors)
self.logger.info(format_nb(nb_decors, "{nb} décor{s} récupéré{s}"))
# On récupère les bonhommes de neige
bonhommes = importeur.supenr.charger_groupe(PrototypeBonhommeNeige)
for bonhomme in bonhommes:
self.ajouter_bonhomme_neige(bonhomme)
nb_bonhommes = len(self.bonhommes_neige)
self.logger.info(format_nb(nb_bonhommes, "{nb} prototype{s} " \
"de bonhomme de neige récupéré{s}"))
# On récupère les feux
feux = importeur.supenr.charger_groupe(Feu)
for feu in feux:
self.feux[feu.salle.ident] = feu
# On implémente le hook correspondant
self.importeur.hook["salle:regarder"].ajouter_evenement(
self.feu_present)
# On récupère les zones
zones = importeur.supenr.charger_groupe(Zone)
for zone in zones:
self._zones[zone.cle] = zone
nb_zones = len(self._zones)
self.logger.info(format_nb(nb_zones, "{nb} zone{s} récupérée{s}", \
fem=True))
importeur.diffact.ajouter_action("net_salles", 300,
self.nettoyer_salles)
importeur.diffact.ajouter_action("repop_salles", 900,
self.repop_salles)
importeur.diffact.ajouter_action("repop_feux", 5, Feu.repop)
# On ajoute les talents
importeur.perso.ajouter_talent("collecte_bois", "collecte de bois",
"survie", 0.55)
importeur.perso.ajouter_talent("feu_camp", "feu de camp", "survie",
0.23)
# Ajout des actions différées pour chaque tick
intervalle = 60 / NB_TICKS
for no in self.ticks.keys():
self.importeur.diffact.ajouter_action("stick_{}".format(no),
intervalle * no, self.tick,
no)
# Ajout des hooks de changement de temps
self.importeur.hook["temps:minute"].ajouter_evenement(
self.changer_minute)
self.importeur.hook["temps:heure"].ajouter_evenement(
self.changer_heure)
self.importeur.hook["temps:jour"].ajouter_evenement(self.changer_jour)
self.importeur.hook["temps:mois"].ajouter_evenement(self.changer_mois)
self.importeur.hook["temps:annee"].ajouter_evenement(
self.changer_annee)
BaseModule.init(self)
def preparer(self):
"""Préparation du module."""
if "cadavre" not in self._prototypes:
self.creer_prototype("cadavre", "cadavre")
if "boule_neige" not in self._prototypes:
self.creer_prototype("boule_neige", "boule de neige")
if "eau" not in self._prototypes:
eau = self.creer_prototype("eau", "potion")
eau.nom_singulier = "eau"
eau.description.ajouter_paragraphe(
"L'eau est claire et semble fraîche.")
eau.remplissant = 2
eau.message_boit = "Vous buvez une gorgée d'eau qui vous " \
"rafraîchit agréablement le gosier."
eau.poids_unitaire = 0.1
eau.prix = 0
# Nettoyage des objets existants sans lien
existants = []
for joueur in importeur.connex.joueurs:
if joueur.equipement:
existants.extend(joueur.equipement.objets_uniques)
for pnj in importeur.pnj.PNJ.values():
if pnj.equipement:
existants.extend(pnj.equipement.objets_uniques)
for salle in importeur.salle.salles.values():
existants.extend(salle.objets_uniques)
for decor in salle.decors:
if hasattr(decor, "elements"):
existants.extend(list(decor.elements.values()))
a_detruire = []
for objet in importeur.objet.objets.values():
objet.supprimer_inexistants()
if objet not in existants:
a_detruire.append(objet)
a_detruire = [o for o in a_detruire if o and o.prototype]
for a_garder in importeur.hook["objet:doit_garder"].executer():
for objet in a_garder:
if objet in a_detruire:
a_detruire.remove(objet)
self.logger.info(format_nb(len(a_detruire), "{nb} objet{s} à " \
"détruire"))
types = {}
for objet in a_detruire:
type = objet.nom_type
nb = types.get(type, 0)
nb += 1
types[type] = nb
try:
importeur.objet.supprimer_objet(objet.identifiant)
except KeyError:
objet.detruire()
for nom, nombre in sorted(types.items(), key=lambda c: c[1], \
reverse=True):
self.logger.info(" Dont {} de type {}".format(nombre, nom))
# Opérations de nettoyage cycliques
importeur.diffact.ajouter_action("net_boule de neige", 60,
self.nettoyage_cyclique,
"boule de neige")
self.nettoyage_lumieres()
# Réinitialisation des scripts des prototypes
for prototype in self._prototypes.values():
prototype.etendre_script()