def creer_structure(groupe): """Crée une structure du groupe indiqué. Paramètres à entrer : * groupe : le nom du groupe de la structure Toutes les structures sont identiques au début : elles sont toutes créées absolument vides. Vous pouvez mettre les cases que vous souhaitez dedans, ou bien les transmettre à un éditeur pour les remplir manuellement. Le groupe détermine comment les structures seront groupées. Le groupe et l'ID forme une combinaison unique représentant chaque structure. Exemple d'utilisation : # Crée une structure dans le groupe 'journal' journal1 = creer-structure("journal") id1 = recuperer(journal1, "id") # 'id1' vaut 1 journal2 = creer-structure("journal") id2 = recuperer(journal2, "id") # 'id2' vaut 2 # Crée une structure vide de groupe 'poeme' poeme = creer-structure("poeme") id3 = recuperer(poeme, "id") # 'id3' vaut 1 """ valider_cle(groupe) return importeur.scripting.creer_structure(groupe)
def interpreter(self, msg): """Interprétation du contexte""" msg = msg.strip() try: msg = self.type(msg) except ValueError: self.pere << "|err|Cette valeur est invalide.|ff|" else: # Vérification verification = self.verification if verification & CLE: try: valider_cle(msg) except ValueError as err: self.pere << "|err|" + str(err) + ".|ff|" return # Modification modification = self.modification if modification & CAPITALIZE: msg = msg[0].upper() + msg[1:] elif modification & LOWER: msg = msg.lower() setattr(self.objet, self.attribut, msg) self.actualiser()
def recuperer_structure(structure, cle): """Récupère la valeur contenue dans la case de clé indiquée. Paramètres à préciser : * structure : la structure qui nous occupe ici * cle : la clé de la case d'information à retrouver Exemple d'utilisation : # Sur une structure enregistrée dans un groupe, on pourrait faire : id = recuperer(structure, "id") # Pour récupérer son ID. Ou bien une autre case : message = recuperer(structure, "message") # Si la case de la clé indiquée n'existe pas, retourne # une valeur nulle qu'on peut donc tester. si message: # ... """ valider_cle(cle) objet = getattr(structure, cle, None) if isinstance(objet, (int, float, bool)): objet = Fraction(objet) return objet
def __init__(self, cle=""): """Constructeur du prototype.""" BaseObj.__init__(self) self.n_id = 1 if cle: valider_cle(cle) self.cle = cle self.cycles = [] self.plantes = []
def ajouter_rang(self, cle): """Ajoute le rang indiqué.""" valider_cle(cle) if self.get_rang(cle, exception=False): raise ValueError("Le rang de clé {} existe déjà".format(repr(cle))) rang = Rang(self, cle) self.rangs.append(rang) return rang
def __init__(self, niveaux, cle, nom, niveau, difficulte, liberer_points=True): """Constructeur du talent.""" valider_cle(cle) self.cle = cle self.nom = nom self.cle_niveau = niveau self.niveau = niveaux[niveau] self.difficulte = difficulte self.liberer_points = liberer_points
def creer_guilde(self, cle): """Crée une guilde.""" valider_cle(cle) if cle in self.guildes: raise ValueError("la guilde {} existe déjà".format(repr(cle))) guilde = Guilde(cle) self.ajouter_guilde(guilde) return guilde
def ajouter_rang(self, cle): """Ajoute le rang indiqué.""" valider_cle(cle) if self.get_rang(cle, exception=False): raise ValueError("Le rang de clé {} existe déjà".format( repr(cle))) rang = Rang(self, cle) self.rangs.append(rang) return rang
def creer_prototype_objet(prototype, type): """Crée un prototype d'objet du type précisé. Cette fonction permet de créer un prototype d'objet du type indiqué. Le prototype d'objet est retourné et peut être manipulé pour d'avantage de configuration (voire les exemples ci-dessous). La clé précisée est utilisée telle quelle. Si un prototype d'objet de cette clé existe déjà, cependant, le système va essayer de créer la clé ${cle}_2, ${cle}_3 et ainsi de suite, jusqu'à en trouver une libre. Si la clé de prototype précisée finit par "_X", (le signe souligné suivi de la lettre X), le système cherchera le prototype correspondant en remplaçant X par un nombre (ce qui est souvent un comportement plus logique quand on veut créer des prototypes en série). Paramètres à préciser : * prototype : la clé du prototype à créer (une chaîne de caractères) ; * type : le nom du type (une chaîne de caractères). Exemples d'utilisation : prototype = creer_prototype_objet("pomme_rouge", "fruit") # Si un prototype d'objet de la clé 'pomme_rouge' existe # déjà, le système créra le prototype 'pomme_rouge_2' journal = creer_prototype_objet("journal_X", "livre") # Le système cherchera à créer le prototype d'objet 'journal_1'. # Si la clé existe, alors 'journal_2', 'journal_3' et ainsi # de suite. changer_nom journal "un journal" "journaux" changer_etat journal "est posé là" "sont posés là" changer_description journal "C'est un journal." changer_poids journal 0.2 changer_prix journal 50 ajouter_chapitre journal "Chapitre 1" "C'est le chapitre 1." ... """ type = importeur.objet.get_type(type).nom_type cles = tuple(importeur.objet.prototypes.keys()) prototype = prototype.lower() nb = 1 cle = prototype if prototype.endswith("_x"): prototype = prototype[:-2] cle = prototype + "_1" valider_cle(prototype) while cle in cles: nb += 1 cle = "{}_{}".format(prototype, nb) return importeur.objet.creer_prototype(cle, type)
def creer_guilde(self, cle): """Crée une guilde.""" valider_cle(cle) if cle in self.guildes: raise ValueError("la guilde {} existe déjà".format( repr(cle))) guilde = Guilde(cle) self.ajouter_guilde(guilde) return guilde
def __init__(self, cle=""): """Constructeur d'un type""" if cle: valider_cle(cle) BaseObj.__init__(self) self.cle = cle self._attributs = {} self.nom = "un élément inconnu" self.description = Description(parent=self) # Editeur self._extensions_editeur = []
def creer_tag(self, cle, type): """Crée un nouveau tag.""" valider_cle(cle) if type not in self.types: raise ValueError("le type de tag {} n'existe pas".format( repr(type))) if cle in self.tags: raise ValueError("le tag {} existe déjà".format( repr(cle))) tag = Tag(cle, type) self.ajouter_tag(tag) return tag
def creer_banc(self, cle): """Crée un banc de poisson et l'ajoute dans le dictionnaire. Retourne le banc créé. Lève une exception KeyError si le banc existe déjà. """ valider_cle(cle) if cle in self.bancs: raise KeyError("le banc de poisson '{}' existe déjà".format(cle)) banc = Banc(cle) self.ajouter_banc(banc) return banc
def creer_modele(self, cle): """Crée un modèle de navire et l'ajoute dans le dictionnaire. Retourne le modèle créé. Lève une exception KeyError si le modèle existe déjà. """ valider_cle(cle) if cle in self.modeles: raise KeyError("le modèle de navire {} existe déjà".format(cle)) modele = ModeleNavire(cle) self.ajouter_modele(modele) return modele
def ajouter_talent(self, cle, nom="un talent inconnu", ouvert_a_tous=False): """Ajoute un talent à la guilde.""" valider_cle(cle) if cle in importeur.perso.talents: raise ValueError("la clé de talent {} est déjà utilisée".format( repr(cle))) if cle in self.talents: raise ValueError("la clé de talent {} existe déjà dans " \ "cette guilde".format(repr(cle))) talent = Talent(self, cle) talent.nom = nom talent.ouvert_a_tous = ouvert_a_tous self.talents[cle] = talent return talent
def valider(self, personnage, dic_masques): """Validation du masque""" Masque.valider(self, personnage, dic_masques) cle = self.a_interpreter if self.regex: res = re.search(self.regex, cle) if res is None: raise ErreurValidation( "|err|Cette clé identifiante est invalide.|ff|") else: try: valider_cle(cle) except ValueError: raise ErreurValidation( "|err|Cette clé identifiante est invalide.|ff|") self.cle = cle return True
def __init__(self, cle): if cle: valider_cle(cle) BaseObj.__init__(self) self.tick_actif = True self.resume = "non spécifié" self.visible = True self.cle = cle self.force_max = 50 self.duree_max = -1 self.infinie = False self.variation = -1 self.duree_tick = 60 # durée du tick en secondes self.flags = 0 # Liste de tuple (force, message) self.messages_visibles = [] self._construire()
def ecrire(structure, cle, valeur): """Écrit l'information dans la structure indiquée. Paramètres à préciser : * structure : la structure à modifier * cle : la clé de la case à modifier * valeur : la valeur de la case à écrire (tous types acceptés) Exemple d'utilisation : ecrire structure "nom" "Quelque chose" ecrire structure "numero" 5 ecrire structure "elements" liste(1, 2, 3, 8) ecrire structure "coupable" joueur("Kredh") **ATTENTION** : la clé de case doit être une clé (sans majuscules ni accents, ne comprenant que des lettres et des chiffres, ainsi que le signe souligné _, si il n'est pas en début de mot). Les noms suivants sont par ailleurs interdits : "e_existe", "get_nom_pour", "id", "structure" """ valider_cle(cle) if cle.startswith("_"): raise ErreurExecution("la clé précisée {} commence par " \ "un signe souligné".format(repr(cle))) interdits = ("e_existe", "get_nom_pour", "id", "structure") if cle in interdits: raise ErreurExecution("Ce nom de clé est interdit. Clés " \ "interdites : {}.".format(repr(interdits))) setattr(structure, cle, valeur)
def interpreter(self, msg): """Interprétation du contexte""" msg = msg.strip() try: msg = self.type(msg) except ValueError: self.pere << "|err|Cette valeur est invalide.|ff|" else: # Vérification verification = self.verification if verification & CLE: try: valider_cle(msg) except ValueError as err: self.pere << "|err|" + str(err) + ".|ff|" return # Modification modification = self.modification if modification & CAPITALIZE: msg = msg.capitalize() setattr(self.objet, self.attribut, msg) self.actualiser()
def interpreter(self, msg): """Interprétation du contexte""" objet = getattr(self.objet, self.attribut) if objet is None: objet = self.nouveau setattr(self.objet, self.attribut, objet) msgs = msg.split(" / ") colonnes = self.colonnes if len(msgs) != len(colonnes): self.pere << "|err|Le nombre d'informations précisées " \ "est invalide.\n{} colonnes attendues contre " \ "{} renseignées.|ff|".format(len(colonnes), len(msgs)) return # On transforme maintenant chaque colonnes i = 0 for nom, n_type in self.colonnes: valeur = msgs[i] valeur_sa = supprimer_accents(valeur).lower() if isinstance(n_type, str): if n_type == "chaîne": pass elif n_type == "clé": try: valider_cle(valeur) except ValueError: self.pere << "|err|Colonne {} : {} n'est " \ "pas ue clé valide.".format(i + 1, valeur) return elif n_type == "entier": try: valeur = int(valeur) except ValueError: self.pere << "|err|Colonne {} : {} n'est " \ "pas un nombre.".format(i + 1, valeur) return else: msgs[i] = valeur elif n_type == "flottant": try: valeur = float(valeur.replace(",", ".")) except ValueError: self.pere << "|err|Colonne {} : {} n'est " \ "pas un flottant.".format(i + 1, valeur) return else: msgs[i] = valeur else: raise ValueError("Type inconnu {}".format(n_type)) elif isinstance(n_type, list): liste = [supprimer_accents(c).lower() for c in n_type] if liste and valeur_sa not in liste: self.pere << "|err|Colonne {} : valeur {} " \ "invalide.|ff|".format(i + 1, valeur) return else: msgs[i] = n_type[liste.index(valeur_sa)] elif isinstance(n_type, dict): cles = list(n_type.keys()) liste = [supprimer_accents(c).lower() for c in cles] if liste and valeur_sa not in liste: self.pere << "|err|Colonne {} : valeur {} " \ "invalide.|ff|".format(i + 1, valeur) return else: msgs[i] = n_type[cles[liste.index(valeur_sa)]] else: raise ValueError("Type inconnu : {}".format(type(n_type))) i += 1 if isinstance(objet, dict): cle = msgs[0] args = msgs[1:] if len(args) == 1: args = args[0] objet[cle] = args else: objet.append(msgs) if self.callback: methode = getattr(self.objet, self.callback) methode() self.actualiser()
def __init__(self, cle, etat_m, etat_f): """Constructeur du talent.""" valider_cle(cle) self.cle = cle self.etat_m = etat_m self.etat_f = etat_f
def __init__(self, cle, nom): """Constructeur du niveau.""" valider_cle(cle) self.cle = cle self.nom = nom
def opt_ajouter(self, arguments): """Ajout d'un élément. Syntaxe : /a <paramètres> """ valeur = getattr(self.objet, self.attribut) objet = self.callback or self.objet colonnes = self.colonnes ajout = self.ajout arguments = arguments.strip().split(" / ") if len(arguments) != len(colonnes): self.pere << "|err|Nombre invalide d'arguments : {} " \ "attendus contre {} reçus.\nSyntaxe : |ent|".format( len(colonnes), len(arguments)) + " / ".join( [c[0] for c in colonnes]) + "|ff|" return for i, arg in enumerate(list(arguments)): colonne = colonnes[i] n_type = colonne[1] if n_type == "chaîne": pass elif n_type == "entier": try: arg = int(arg) except ValueError: self.pere << "|err|Colonne {} ({}) : nombre entier {} " \ "invalide.|ff|".format(i + 1, colonne[0], arg) return else: arguments[i] = arg elif n_type == "flottant": try: arg = float(arg.replace(",", ".")) except ValueError: self.pere << "|err|Colonne {} ({}) : nombre flottant {} " \ "invalide.|ff|".format(i + 1, colonne[0], arg) return else: arguments[i] = arg elif n_type == "clé": try: valider_cle(arg) except ValueError: self.pere << "|err|Colonne {} ({}) : clé invalide " \ "{}|ff|".format(i + 1, colonne[0], repr(arg)) return else: arguments[i] = arg else: raise ValueError("colonne {} : type inconnu ({})".format( i + 1, repr(n_type))) # On essaye d'ajouter l'élément methode = getattr(objet, ajout) try: if self.callback: methode(self.objet, valeur, *arguments) else: methode(*arguments) except Exception as err: self.pere << "|err|" + str(err) + ".|ff|" return self.actualiser()