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): """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 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 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 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 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)