Python masque.Masque类代码示例

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     chemin_commande = self.a_interpreter
     
     trans_param = True # doit-on transmettre les sous-commandes ?
     if chemin_commande.endswith("."):
         chemin_commande = chemin_commande[:-1]
         trans_param = False
     
     # On cherche dans les chemins des commandes, dans interpreteur.groupes
     chemins = type(self).importeur.interpreteur.groupes.commandes.keys()
     commandes = []
     for chemin in chemins:
         if chemin == chemin_commande:
             commandes.append(chemin)
         elif trans_param and chemin.startswith(chemin_commande + SEP):
             commandes.append(chemin)
     
     if not commandes:
         raise ErreurValidation(
             "|err|Aucune commande correspondant au chemin n'a pu être " \
             "trouvée.|ff|")
     
     self.chemins = commandes
     
     return True

    def valider(self, personnage, dic_masques):
        """Validation du masque"""
        Masque.valider(self, personnage, dic_masques)
        nom = self.a_interpreter
        salle = personnage.salle
        cale = salle.navire.cale
        for objet, nombre in cale.conteneur.iter_nombres():
            if contient(objet.get_nom(nombre), nom):
                self.objets.append(objet)

        for conteneur in cale.conteneurs.values():
            for cle in conteneur.keys():
                try:
                    prototype = importeur.objet.prototypes[cle]
                except KeyError:
                    continue

                if contient(prototype.nom_singulier, nom) or contient(
                        prototype.nom_pluriel, nom):
                    self.prototype = prototype
                    return True

        if not self.objets:
            raise ErreurValidation("Cet objet n'est pas trouvable dans la " \
                    "cale de ce navire.")

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     message = self.a_interpreter
     self.message = message
     
     return True

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     duree = self.a_interpreter
     res = RE_DUREE.search(duree)
     if not res:
         raise ErreurValidation("Durée invalide.")
     
     nb, mesure = res.groups()
     nb = int(nb)
     mesure = mesure.lower()
     if mesure in ("s", "sec", "seconde", "secondes"):
         mult = 1
         nom_complet = "seconde"
     elif mesure in ("m", "mn", "min", "minute", "minutes"):
         mult = 60
         nom_complet = "minute"
     elif mesure in ("h", "hr", "heure", "heures"):
         mult = 3600
         nom_complet = "heure"
     elif mesure in ("j", "jr", "jour", "jours"):
         mult = 86400
         nom_complet = "jour"
     else:
         raise ErreurValidation("Mesure {} inconnue.".format(mesure))
     
     self.secondes = mult * nb
     s = ""
     if nb > 1:
         s = "s"
     self.temps = "{} {}{s}".format(nb, nom_complet, s=s)
     return True

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     prompt = self.a_interpreter
     self.prompt = prompt
     
     return True

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     id_conversation = self.a_interpreter
     conversations = type(self).importeur.communication.conversations
     p_conversations = conversations.get_conversations_pour(personnage)
     cible = None
     
     if id_conversation == "-":
         self.perte_focus = True
         return True
     
     try:
         id_conversation = int(id_conversation)
     except ValueError:
         return False
     
     for conversation in p_conversations:
         if conversation.id == id_conversation:
             cible = conversation.cible
             break
     if cible is None:
         raise ErreurValidation(
             "|err|Le numéro spécifié ne correspond à aucun personnage.|ff|")
     else:
         self.id_conversation = id_conversation
         self.cible = cible
         return True

 def __init__(self, francais, anglais):
     """Constructeur du mot-clé"""
     Masque.__init__(self)
     self.francais = francais
     self.anglais = anglais
     self.nom = francais
     self.gauche = False

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     coordonnees = self.a_interpreter
     coordonnees = tuple(int(e) for e in coordonnees.split("."))
     self.coordonnees = coordonnees
     return True

    def valider(self, personnage, dic_masques):
        """Validation du masque"""
        Masque.valider(self, personnage, dic_masques)
        nom_type = self.a_interpreter
        self.nom_type = nom_type

        return True

    def valider(self, personnage, dic_masques):
        """Validation du masque"""
        Masque.valider(self, personnage, dic_masques)
        salle = personnage.salle
        nom = self.a_interpreter
        t_nom = supprimer_accents(nom).lower()
        familiers = importeur.familier.familiers_de(personnage)
        familiers = [f for f in familiers if f.pnj]
        if self.salle_identique:
            familiers = [f for f in familiers if f.pnj.salle is salle]

        familier = None
        for t_familier in familiers:
            if supprimer_accents(t_familier.nom).lower() == t_nom:
                familier = t_familier
                break

        if not self.nouveau and familier is None:
            raise ErreurValidation(
                "|err|Le familier {} ne peut être trouvé.|ff|".format(nom))
        elif self.nouveau and familier:
            raise ErreurValidation(
                "|err|Le familier {} existe déjà.|ff|".format(nom))

        self.nom_familier = nom
        self.familier = familier
        return True

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     nom_cible = self.a_interpreter
     persos = personnage.salle.personnages
     objets = []
     cibles = []
     for o in personnage.salle.objets_sol:
         objets.append(o)
     for o in personnage.equipement.tenus:
         objets.append(o)
     
     for p in persos:
         if p is not personnage and contient(
                 p.get_nom_pour(personnage), nom_cible):
             cibles.append(p)
     for o in objets:
         if contient(o.nom_singulier, nom_cible):
             cibles.append(o)
     
     if not cibles:
         raise ErreurValidation("|err|Cette cible est introuvable.|ff|")
     
     self.cibles = cibles
     return True

 def __init__(self):
     """Constructeur du masque"""
     Masque.__init__(self)
     self.proprietes["conteneurs"] = "(personnage.salle.objets_sol, )"
     self.proprietes["types"] = "None"
     self.proprietes["tout_interpreter"] = "True"
     self.proprietes["quantite"] = "False"
     self.proprietes["conteneur"] = "False"
     self.proprietes["heterogene"] = "False"

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     nom_cherchable = self.a_interpreter
     cherchables = importeur.recherche.cherchables
     if nom_cherchable in cherchables:
         self.cherchable = cherchables[nom_cherchable]
         return True
     else:
         raise ErreurValidation(
             "|err|Vous ne pouvez rechercher cela.|ff|")

 def valider(self, personnage, dic_masques):
     """Validation du masque"""
     Masque.valider(self, personnage, dic_masques)
     ident = self.a_interpreter
     if not ident in type(self).importeur.objet.prototypes:
         raise ErreurValidation(
             "|err|Ce prototype est introuvable.|ff|")
     
     self.prototype = type(self).importeur.objet.prototypes[ident]
     self.ident = ident
     
     return True

    def valider(self, personnage, dic_masques):
        """Validation du masque"""
        Masque.valider(self, personnage, dic_masques)
        langue = self.a_interpreter

        if not langue in LANGUES:
            raise ErreurValidation(
                "|err|La langue précisée n'est pas disponible.|ff|")

        self.langue = langue

        return True