def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "accepter", "accept") self.schema = "<nom_joueur>" self.aide_courte = "Valider la description d'un joueur." self.aide_longue = \ "Valide la description d'un joueur."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "liste", "list") self.aide_courte = "liste les news letters existantes" self.aide_longue = \ "Cette commande liste les news letters existantes ainsi que " \ "leur statut."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "liste", "list") self.schema = "" self.aide_courte = "liste les vents existants" self.aide_longue = \ "Cette commande liste les vents existants."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "editer", "edit") self.schema = "<ident>" self.aide_courte = "ajoute ou modifie une recette" self.aide_longue = \ ""
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "tenir", "hold") self.aide_courte = "saisit les rames" self.aide_longue = \ "Cette commande permet de tenir les rames. Vous ne pouvez " \ "naturellement pas ramer sans tenir les rames auparavant."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "hisser", "up") self.aide_courte = "hisse la voile présente" self.aide_longue = \ "Cette commande hisse la voile présente dans la salle où " \ "vous vous trouvez."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "jeter", "drop") self.aide_courte = "jète l'ancre présente" self.aide_longue = \ "Cette commande jète l'ancre présente dans la salle où " \ "vous vous trouvez."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "script", "script") self.tronquer = True self.schema = "<cle> (<texte_libre>)" self.aide_courte = "modifie les scripts d'un tag" self.aide_longue = AIDE
def __init__(self): """Constructeur de la commande""" Parametre.__init__(self, "list", "list") self.groupe = "administrateur" self.aide_courte = "liste les sorts existants" self.aide_longue = \ "Cette commande permet de lister les sorts existants."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "liste", "list") self.aide_courte = "affiche les descriptions flottantes" self.aide_longue = \ "Cette commande permet d'afficher la liste des " \ "descriptions flottantes actuelles."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "info", "info") self.schema = "<nombre>" self.aide_courte = "affiche des informations sur l'alerte" self.aide_longue = \ "Affiche des informations sur l'alerte permettant de la corriger."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "quitter", "quit") self.schema = "<canal>" self.aide_courte = "quitte le canal spécifié" self.aide_longue = \ "Cette sous-commande vous déconnecte d'un canal."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "replier", "in") self.aide_courte = "replie la passerelle présente" self.aide_longue = \ "Cette commande replie la passerelle présente dans la salle où " \ "vous vous trouvez."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "promouvoir", "promote") self.schema = "<nom_joueur> <message>" self.tronquer = True self.aide_courte = "promeut un joueur dans votre équipage" self.aide_longue = \ "Cette commande est assez identique à %matelot% " \ "%matelot:poste% sauf qu'elle permet de changer le poste " \ "d'un joueur. Les joueurs sont libres de leurs actions " \ ": ils entendent les ordres et, certaines fois, ils " \ "peuvent les accomplir, mais ils n'y sont pas forcés. " \ "L'avantage de cette commande est surtout d'indiquer " \ "d'autres officiers : les postes |ent|officier|ff|, " \ "|ent|maître d'équipage|ff|, |ent|second|ff| et " \ "|ent|capitaine|ff| ont des privilèges particuliers, " \ "comme celui de pouvoir donner des ordres sur le navire. " \ "En outre, seuls le capitaine et son second (il peut y " \ "avoir plusieurs capitaines ou seconds) ont le droit " \ "d'ordonner de larguer les amarres ou de lever l'ancre. " \ "Enfin, si un équipage est placé pour réceptionner un " \ "abordage, les matelots ayant pour tâche de protéger le " \ "navire attaqueront les membres d'un équipage adverse : " \ "ils ne s'attaqueront pas entre eux, faisant parti du " \ "même équipage, et ils n'attaqueront pas les joueurs " \ "définis dans le même équipage, mais tous les autres " \ "(PNJ ou joueurs) seront pris pour cible. Si vous oubliez " \ "d'inclure un joueur dans votre équipage à ce moment, il " \ "sera considéré comme un ennemi. Pour manipuler cette " \ "commande, entrez en premier paramètre le nom du joueur " \ "(celui visible dans la commande %qui%, pas sa " \ "distinction anonyme) et en second paramètre le poste " \ "auquel vous voulez l'assigner, ou |ent|aucun|ff| si " \ "vous voulez retirer ce joueur de votre équipage. Les postes " \ "disponibles sont : " + ", ".join(ORDRE) + "."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "poste", "position") self.schema = "<nom_matelot> <message>" self.tronquer = True self.aide_courte = "change un matelot de poste" self.aide_longue = \ "Cette commande permet de demander à un matelot de changer de " \ "poste. Cette commande est souvent utile au début d'un voyage " \ "(ou juste après avoir recruté un nouveau membre d'équipage). " \ "Certains matelots ont des postes de prédilection mais, par " \ "choix, vous pourriez décider de les mettre à un autre poste. " \ "Les matelots chargés de poste à responsabilité (capitaine, " \ "second, maître d'équipage) doivent être choisis " \ "indépendemment. Notez que le poste n'a pas de rapport direct " \ "avec l'affectation : un voilier peut être affecté dans la " \ "cale, une vigie dans la cabine. Il est préférable de placer " \ "les matelots qui sont chargés de postes relativement statiques " \ "proches des points du navire où ils devront opérer. Quand le " \ "nombre de matelots sur un navire est plus important, il peut " \ "être difficile d'affecter tout le monde et de leur changer " \ "de poste : le maître d'équipage est là pour ça. Grâce à un " \ "ordre (encore à venir), il se charge " \ "d'affecter les matelots en fonction de leur aptitude " \ "et de les mettre aux postes qui leur conviennent mieux. Il est " \ "préférable cependant de choisir au moins le capitaine et " \ "le maître d'équipage avant de donner cet ordre et il vous " \ "appartient de choisir un second parmi les officiers " \ "restants du bord, bien que cela ne soit, à proprement " \ "parlé, pas nécessaire dans tous les cas. Pour utiliser " \ "cette commande, vous devez d'abord préciser son nom (tel " \ "qu'il s'affiche dans le %matelot% %matelot:liste%) et ensuite " \ "le nom du poste, comme |ent|artilleur|ff|. Les postes " \ "disponibles sont : " + ", ".join(ORDRE) + "."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "marcher", "walk") self.aide_courte = "dessine plusieurs routes d'un coup" self.aide_longue = \ "Cette commande permet de tracer rapidement plusieurs " \ "routes en marchant, d'où son nom. L'utiliser est plus " \ "simple que de multiples appels à %route% %route:marquer%, " \ "bien que le principe soit le même. Cette commande est " \ "pratique car elle permet de dessiner un complexe de " \ "routes très facilement. Il suffit de la lancer dans une " \ "des salles de la carte que l'on souhaite créer et se " \ "déplacer dans toutes les salles que l'on souhaite inclure. " \ "Le système s'occupe de créer tout seul les routes, en " \ "se basant sur le nombre de sorties possibles à une " \ "salle. Le comportement de cette commande est de créer " \ "autant de routes que possibles plutôt que des routes " \ "comportant de nombreuses salles. Ce comportement est " \ "logique d'un point de vue d'optimisation (il est plus " \ "facile pour le système de gérer de nombreuses routes " \ "que de longues routes). Entrez cette commande pour " \ "commencer à marquer un ensemble de routes, puis entrez " \ "la de nouveau quand vous avez parcouru toutes les salles " \ "que vous souhaitez mettre dans le complexe de routes. " \ "Le système créera automatiquement les routes pour se " \ "rendre dans chaque salle que vous avez visité."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "liste", "list") self.groupe = "administrateur" self.aide_courte = "liste les questeurs existants" self.aide_longue = \ "Cette commande liste les questeurs existants."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "voir", "view") self.schema = "<cle>" self.aide_courte = "visionne un banc particulier" self.aide_longue = \ "Cette commande offre un affichage détaillé d'un banc de poisson."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "centre", "center") self.aide_courte = "recentre le gouvernail" self.aide_longue = \ "Cette commande replace le gouvernail présent au " \ "centre."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "obstacle", "obstacle") self.aide_courte = "gère les obstacles de l'étendue" self.aide_longue = \ "Cette commande permet de gérer les obstacles d'une étendue (en " \ "ajouter ou en supprimer)."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "détruire", "destroy") self.schema = "<cle_vent>" self.aide_courte = "détruit un vent" self.aide_longue = \ "Cette commande détruit le vent passé en paramètre."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "liste", "list") self.aide_courte = "affiche la liste des chemins" self.aide_longue = \ "Cette commande permet d'afficher la liste des " \ "chemins pour PNJ."
def __init__(self): """Constructeur de la commande""" Parametre.__init__(self, "miens", "mine") self.aide_courte = "liste vos sorts" self.aide_longue = \ "Cette commande vous permet de consulter votre niveau actuel " \ "dans chacun des sorts que vous connaissez."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "immerger", "immerge") self.schema = "<canal>" self.aide_courte = "immerge dans le canal spécifié" self.aide_longue = \ "Cette sous-commande permet de vous immerger dans un canal."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "éditer", "edit") self.schema = "<cle>" self.aide_courte = "ouvre l'éditeur de décor" self.aide_longue = \ "Cette commande permet d'éditer un décor existant."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "commande", "command") self.schema = "<chemin_commande> <groupe_existant>" self.aide_courte = "change une commande de groupe" self.aide_longue = \ "Utilisez cette commande pour changer une commande de " \ "groupe. Si par exemple vous voulez rendre l'écriture de " \ "mudmails accessibles aux joueurs, déplacez la commande " \ "|cmd|messages|ff| dans le groupe |tit|joueur|ff| grâce à la " \ "commande : %chgroupe% %chgroupe:commande% |cmd|messages " \ "joueur|ff|. Il est préférable, quand vous ajoutez " \ "une nouvelle commande au MUD, de la placer d'office " \ "dans un groupe essentiel (|tit|pnj|ff|, |tit|joueur|ff| " \ "ou |tit|administrateur|ff|). Une fois que la commande " \ "a bien été ajoutée, vous pourrez la déplacer dans " \ "le groupe final de destination. " \ "Enfin, sachez qu'en déplaçant une commande, toutes ses " \ "sous-commandes seront déplacées dans le même groupe. Pour "\ "évitez cela, mettez un point (|cmd|.|ff|) après le nom de " \ "votre commande. Si vous faites %chgroupe% %chgroupe:commande% " \ "|cmd|messages. joueur|ff|, la commande |cmd|mail|ff| " \ "sera déplacée mais aucun de ses paramètres. " \ "Libre à vous de les transférer ensuite un à un pour " \ "n'autoriser que certains paramètres aux " \ "joueurs, tout en en laissant certains accessibles qu'aux " \ "administrateurs."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "chambre", "room") self.tronquer = True self.schema = "<chambre_auberge> <nombre>" self.aide_courte = "loue une chambre" self.aide_longue = \ "Cette commande vous permet de louer une chambre. Vous " \ "devez vous trouver auprès d'un aubergiste pour ce faire. " \ "Le premier paramètre à préciser est le numéro de la chambre " \ "à louer (vous pouvez obtenir cette information à l'aide " \ "de la commande %louer% %louer:liste%). Le second paramètre " \ "est le nombre de jours (réels) pour lesquels vous voulez " \ "louer cette chambre. Vous pouvez louer une chambre pour " \ "un jour minimum et dix jours au maximum : vous avez " \ "cependant la possibilité de renouveler une location qui " \ "n'a pas encore expirée à l'aide de la commande %louer% " \ "%louer:renouveler%. Vous disposez également du mode vacance, " \ "qui vous permet de louer pendant 30 jours réels au maximum. " \ "Ce privilège est disponible automatiquement, mais vous " \ "ne pouvez louer qu'une seule chambre pour plus de 10 jours. " \ "Chaque année réelle, le mode vacance est effacé, vous " \ "pouvez donc réserver une chambre pour 30 jours par an, " \ "pour vos vacances. Pour les cas particuliers, contactez " \ "les immortels."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "commenter", "comment") self.tronquer = True self.schema = "<nombre> <texte_libre>" self.aide_courte = "commente un rapport" self.aide_longue = AIDE
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "créer", "create") self.schema = "<etendue> (<coordonnees>)" self.aide_courte = "crée un vent dans une étendue" self.aide_longue = \ "Cette commande crée un vent dans une étendue existante."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "liste", "list") self.aide_courte = "liste les perturbations actuelles" self.aide_longue = \ "Cette commande affiche les perturbations actuelles dans un " \ "tableau récapitulatif."
def __init__(self): """Constructeur de la commande""" Parametre.__init__(self, "oublier", "forget") self.schema = "<nom_sort>" self.aide_courte = "oublie un sort" self.aide_longue = \ "Cette commande vous permet d'oublier un sort. Vous " \ "devez préciser en paramètre le nom du sort. Pour éviter " \ "de sélectionner le mauvais sort, veillez à préciser le " \ "nom le plus complètement possible. |att|ATTENTION|ff| : " \ "vous ne pourrez oublier le même sort qu'une fois. Si " \ "vous apprenez un sort X et que vous oubliez ce sort, " \ "puis que vous le réappreniez pour une raison ou une autre, " \ "vous ne pourrez plus l'oublier de nouveau."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "liste", "list") self.aide_courte = "consulte vos navires" self.aide_longue = \ "Cette commande vous permet de consulter la liste des navires " \ "que vous possédez, si ils se trouvent dans les eaux du chantier " \ "naval dans lequel vous vous trouvez. Si le navire sur " \ "lequel vous souhaitez effectuer une opération (changer son " \ "nom par exemple), il doit se trouver dans le chantier " \ "naval. Cette commande affiche la liste avec chaque navire " \ "numéroté. Ces numéros vous permettront d'effectuer d'autres " \ "actions dans le chantier naval et vous devrez le préciser " \ "lors des autres commandes."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "rejoindre", "join") self.schema = "<cle> (<nom_joueur>)" self.aide_courte = "rejoint une guild" self.aide_longue = \ "Cette commande permet de forcer un joueur à rejoindre " \ "une guilde existante. Vous devez préciser en premier " \ "paramètre obligatoire la clé de la guilde. Le second " \ "paramètre, facultatif, est le nom du joueur. Si ce " \ "second paramètre n'est pas renseigné, cette commande " \ "s'applique automatiquement à vous. Notez que les " \ "contraintes usuelles concernant les points de guilde " \ "disponibles s'appliquent comme d'habitude."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "info", "info") self.schema = "<cle>" self.aide_courte = "affiche des informations sur l'étendue" self.aide_longue = \ "Affiche des informations sur l'étendue d'eau précisée " \ "en paramètre, comme ses obstacles, côtes et liens. Les " \ "obstacles sont des points neutres de l'étendue, pouvant " \ "représenter des rochers, des récifs, des îlots inaccessibles. " \ "Les côtes sont des salles liées à l'étendue (des plages, " \ "des ports, des îles accessibles). Enfin, les liens sont " \ "des points reliant deux étendues entre elles (une rivière " \ "se jette dans la mer)."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "harnacher", "harness") self.tronquer = True self.schema = "<nom_familier> <nom_objet>" self.aide_courte = "harnache un familier" self.aide_longue = \ "Cette commande permet d'harnacher un familier, " \ "c'est-à-dire de l'équiper avec un objet que vous possédez. " \ "Ce peut être une bride, une selle ou autre. Certains " \ "harnachements sont requis pour certaines actions (par " \ "exemple, on ne peut mener un familier sans bride ou " \ "corde). Vous devez préciser en premier paramètre le " \ "nom du familier et en second paramètre un fragment " \ "du nom de l'objet que vous souhaitez utiliser pour l'harnacher."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "voir", "view") self.schema = "<cle> <nombre>" self.aide_courte = "affiche le détail d'une structure" self.aide_longue = \ "Cette commande affiche le détail d'une structure. Vous " \ "devez préciser deux paramètres séparés par un espace : " \ "le premier est la clé du groupe, le second est l'identifiant " \ "de la structure. Pour savoir quels groupes existent, " \ "utilisez la commande %structure% %structure:liste% sans " \ "paramètre. Pour savoir les identifiants des structures de " \ "ce groupe, utilisez de nouveau %structure% %structure:liste% " \ "suivi du nom de groupe à examiner. Par exemple %structure% " \ "%structure:voir%|cmd| journal 1|ff|."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "apparaître", "spawn") self.nom_groupe = "administrateur" self.tronquer = True self.schema = "<cle>" self.aide_courte = "fait apparaître un familier" self.aide_longue = \ "Cette commande permet de faire apparaître un familier " \ "modelé sur la fiche de familier précisée en paramètre. " \ "Souvenez-vous que la fiche de familier a la même clé que " \ "le prototype de PNJ. Vous pouvez donc utliiser cette " \ "commande comme %pspawn%, à ceci près qu'un PNJ sera " \ "effectivement créé, mais qu'il s'agira d'un familier " \ "et que vous en serez le maître."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "carte", "map") self.schema = "<cle>" self.aide_courte = "affiche la carte de l'étendue" self.aide_longue = \ "Cette commande permet d'afficher un contexte représentant " \ "la carte (tronquée) de l'étendue. Les obstacles et les " \ "liens peuvent être édités simplement ici. Le contexte " \ "en lui-même propose beaucoup d'options et peut être " \ "difficile à manipuler pour commencer (certaines étendues " \ "sont bien plus grandes que la carte de base et il faut " \ "apprendre à naviguer dedans) mais de l'aide est mise à " \ "disposition pour vous aider à comprendre les différentes " \ "possibilités d'édition."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "attacher", "tie") self.tronquer = True self.schema = "<nom_familier>" self.aide_courte = "attache un familier" self.aide_longue = \ "Cette commande permet d'attacher un familier à une barre " \ "d'attache disponible dans la salle. Le familier attaché ne " \ "pourra pas bouger. Il doit être harnaché (d'une bride " \ "ou corde) et il doit y avoir une barre d'attache libre " \ "dans la salle. Attention cependant : un familier attaché ne " \ "se nourrira pas. Ne le laissez pas attaché trop " \ "longtemps ou bien surveillez son statut de temps à " \ "autre pour être sûr qu'il ne dépérit pas."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "créer", "create") self.groupe = "administrateur" self.schema = "<message>" self.aide_courte = "étend la feuille de route" self.aide_longue = \ "Cette sous-commande permet de créer un nouvel élément " \ "à ajouter à la feuille de route. Cet élément portera " \ "le numéro actuellement disponible. Vous devez préciser " \ "dans le texte le titre, un signe deux points et le " \ "texte. Par exemple |ent|exploration : 150 salles " \ "ouvrables|ff|. Si cette syntaxe n'est pas respectée, " \ "l'annonce aura un titre sans texte, ce qui veut dire " \ "que vous devrez répéter le texte complet à chaque modification."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "email", "email") self.tronquer = True self.schema = "<etat>" self.aide_courte = "active / désactive l'envoi d'e-mails" self.aide_longue = \ "Cette commande permet d'activer ou désactiver l'envoi " \ "d'e-mails à ce compte en cas de réception d'un UmdMail. " \ "Si cette option est active, un e-mail sera envoyé lors " \ "de l''envoi de MudMails, comme par exemple un commentaire de " \ "rapport. Si cette option est inactive, les MudMails seront " \ "toujours reçus par les joueurs du compte, mais un e-mail " \ "de notification ne sera pas envoyé à la réception de MudMails. " \ "Pour activer l'option, précisez en paramètre |ent|on|ff|. " \ "Pour la désactiver, précisez |ent|off|ff| en paramètre."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "newsletter", "newsletter") self.tronquer = True self.schema = "<etat>" self.aide_courte = "active / désactive la newsletter" self.aide_longue = \ "Cette commande permet d'activer ou désactiver l'envoi de la " \ "newsletter à ce compte. Si cette option est active, les " \ "newsletters envoyées par les administrateurs seront envoyées " \ "à ce compte. Elles ne seront pas envoyées si l'option est " \ "désactivée. " \ "Si la newsletter vous gène ou vous est inutile, " \ "vous pouvez donc la désactiver en entrant %options% " \ "%options:newsletter% |cmd|off|ff|. Remplacez |cmd|off|ff| " \ "par |cmd|on|ff| pour voir de nouveau les newsletters."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "renommer", "rename") self.schema = "<nombre> <message>" self.aide_courte = "renomme un navire" self.aide_longue = \ "Cette commande vous permet de changer le nom d'un navire. " \ "Celui-ci doit être dans le chantier naval où vous vous " \ "trouvez. Vous devez préciser en premier paramètre le " \ "numéro du navire (tel que la commande %chantier% " \ "%chantier:liste% l'affiche) et en second paramètre le " \ "nouveau nom du navire. Cette action n'est pas instantanée " \ ": le navire doit rester dans le chantier naval quelques " \ "minutes le temps que les ouvriers repeignent son nom sur " \ "la coque. Vous pouvez voir le temps restant pour cette " \ "opération en entrant %chantier% %chantier:commandes%."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "exec", "exec") self.aide_courte = "entre dans la console scripting" self.aide_longue = \ "Cette commande permet d'ouvrir la console scripting, " \ "qui permet d'entrer du scripting à la volée et l'exécuter " \ "tout de suite. L'avantage est de pouvoir tester certaines " \ "manipulations, ainsi que faire des modifications à la " \ "volée, comme changer les coordonnées de plusieurs salles, " \ "les passer en intérieur, ou donner une affection à tous " \ "les joueurs dans une zone, etc. C'est une commande " \ "potentiellement aussi puissante que |cmd|système|ff|, et qu'il " \ "faut donc utiliser avec prudence quand il s'agit de " \ "modifications de masse. Les alertes générées par le " \ "script seront affichées directement dans la console."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "creer", "create") self.schema = "(<cle>)" self.aide_courte = "crée une perturbation" self.aide_longue = \ "Cette commande permet de créer une perturbation météorologique " \ "dans la salle où vous vous trouvez (par exemple, faire " \ "apparaître un nuage). La salle où vous vous trouvez est prise "\ "comme point de départ. Notez que vous ne pourrez pas faire " \ "apparaître une perturbation si une autre est présente ou trop " \ "proche. Les perturbations ont en effet des rayons " \ "d'action, et deux perturbations ne doivent pas entrer en " \ "conflit (un nuage ne doit pas en recouvrir un second, " \ "par exemple). Si vous ne savez pas quelles perturbations " \ "sont disponibles, entrez la commande sans paramètre."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "déplacer", "move") self.schema = "<nom_familier> <nom_sortie>" self.tronquer = True self.aide_courte = "demande au familier de se déplacer" self.aide_longue = \ "Cette commande permet d'ordonner à un familier, présent " \ "dans la salle, de se déplacer vers l'une des sorties " \ "disponibles. Vous devez entrer en premier paramètre le " \ "nom du familier et en second paramètre la sortie que doit " \ "prendre le familier. Notez que, si vous pouvez harnacher " \ "le familier avec une bride (ou même une corde), vous " \ "pouvez le diriger avec la commande %familier% " \ "%familier:mener%, ce qui reste malgré tout bien plus " \ "pratique."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "objectif", "objective") self.tronquer = True self.schema = "(<nombre>)" self.aide_courte = "consulte ou modifie les objectifs" self.aide_longue = \ "Les objectifs sont des ordres permanents qui peuvent " \ "rester en sommeil pendant un temps indéfini. Généralement, " \ "seul le premier objectif est actif, les autres sont en " \ "attente, même si ils peuvent influencer la manoeuvre. " \ "Concrètement, un objectif est un but fixé pour un équipage, " \ "comme \"se rendre à un point indiqué\", \"attaquer le " \ "navire que l'on voit à l'horizon\", \"chercher à accoster " \ "dans le port voisin\". La différence avec de simples " \ "ordres, c'est qu'ils sont maintenus pendant toute la durée " \ "de leur accomplissement et sont faits pour évoluer au " \ "cours d la manoeuvre. Par exemple, aller vers une côte " \ "ou un autre navire peut être une combinaison d'ordres " \ "assez simples, mais il faut tenir compte de plusieurs " \ "facteurs qui pourraient modifier la manoeuvre, comme la " \ "position du vent si il tourne, l'apparition d'un autre " \ "navire sur la trajectoire assignée, la modification du " \ "cap si le navire cible se déplace. Un objectif crée " \ "généralement des contrôles : à la différence des objectifs, " \ "les contrôles ne peuvent se contredire. Vous pourriez " \ "avoir deux objectifs actifs : l'un demandant à se rendre " \ "vers une côte située vers l'est, l'autre demandant " \ "d'attaquer un navire à l'ouest. Dans ce cas, le commandant " \ "choisit l'objectif le plus prioritaire (celui en haut " \ "de la liste) et donne les ordres pour atteindre la " \ "côte à l'est. En revanche, si l'objectif pour attaquer " \ "le navire cible est maintenu, pendant l'accomplissement " \ "du premier objectif, une manoeuvre pourrait permettre à " \ "la cible d'être à portée de canon. C'est pour cela que " \ "les objectifs sont maintenus même si ils s'opposent en " \ "apparence. Vous pouvez entrer cette commande sans " \ "paramètre pour voir les objectifs actuellement donnés " \ "à votre équipage. Notez que le premier (numéroté |ent|1|ff|) " \ "est considéré comme l'objectif actif, celui par lequel " \ "les décisions conflictuelles sont tranchées. Les autres " \ "objectifs sont conservés mais ne font pas partie des " \ "décisions du commandant, sauf si il n'y a aucun conflit " \ "dans les objectifs non prioritaires. Vous pouvez " \ "également entrer cette commande en précisant un numéro " \ ": l'objectif du numéro indiqué sera retiré et ne fera " \ "plus parti des décisions prises par le commandant."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "affecter", "affect") self.schema = "<nom_matelot>" self.tronquer = True self.aide_courte = "change l'affectation d'un matelot" self.aide_longue = \ "Cette commande demande à un matelot de changer d'affectation. " \ "Le matelot précisé en paramètre voit la salle où vous " \ "vous trouvez devenir sa nouvelle affectation et il tentera " \ "de s'y rendre dès que sa nouvelle affectation lui sera " \ "parvenue. Après la plupart des ordres que vous émeterez, " \ "les matelots retournent à leur salle d'affectation. Plus " \ "les matelots sont logiquement répartis sur le navire " \ "(en fonction des différents postes et des abilités de " \ "chacun), moins ils se déplacent, plus ils sont réactifs " \ "et moins ils se fatiguent."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "pivoter", "pivot") self.schema = "<nombre>" self.aide_courte = "fait pivoter le canon" self.aide_longue = \ "Cette commande permet de faire pivoter le canon " \ "horizontalement. Tous les canons ne peuvent pas être " \ "réorientés et ceux qui le peuvent disposent généralement " \ "d'angles de tir. Même quand ce n'est pas le cas, n'oubliez " \ "pas que vous devez faire attention à aligner le canon " \ "correctement (si vous le retournez complètement, c'est " \ "votre propre navire qui sera endommagé par l'explosion). " \ "Précisez l'angle en degrés : un nombre positif (par exemple " \ "|ent|90|ff| pour faire pivoter le canon de 90°) fera " \ "pivoter le canon vers tribord, un nombre négatif (par " \ "exemple |ent|-90|ff|) fera pivoter le canon sur bâbord."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "renommer", "rename") self.tronquer = True self.schema = "<ancien:nom_familier> <nouveau:nom_familier>" self.aide_courte = "change le nom d'un familier" self.aide_longue = \ "Cette commande permet de changer le nom d'un familer. Ce " \ "nom est important, puisqu'il s'agit du nom que vous " \ "utiliserez pour manipuler le familier, lui donner des " \ "ordres et celui que vous verrez dans la salle. Ce " \ "nom doit être unique entre vos familiers, c'est-à-dire que " \ "deux familiers que vous possédez ne peuvent pas avoir le " \ "même nom. Précisez en premier paramètre le nom actuel " \ "du familier et en second paramètre son nouveau nom. Vous " \ "pouvez utiliser cette commande même si le familier ne " \ "se trouve pas dans la même salle que vous."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "installer", "install") self.schema = "<nom_objet> sur/on <bh_emplacement> de/of " \ "<element_observable>" self.aide_courte = "installe un élément sur un bonhomme" self.aide_longue = \ "Cette commande permet d'installer un élément sur un bonhomme " \ "de neige. Vous devez préciser le nom de l'objet à installer, " \ "suivi du mot-clé |cmd|sur|ff| (|cmd|on|ff| en anglais), suivi " \ "du nom de l'emplacement, suivi du mot-clé |cmd|de|ff| " \ "(|cmd|of|ff| en anglais), suivi enfin du nom du bonhomme de " \ "neige, dans l'ordre (faites attention à la syntaxe, " \ "les mot-clés sont essentiels). " \ "Les éléments disponibles diffèrent d'un bonhomme de neige " \ "à l'autre et c'est à vous de les trouver, bien que la " \ "description du dit bonhomme peut parfois vous y aider."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "annuler", "cancel") self.nom_groupe = "administrateur" self.schema = "(<cle_navire>)" self.aide_courte = "efface les ordres d'un équipage" self.aide_longue = \ "Cette commande permet de supprimer tous les ordres en " \ "cours d'un équipage. Elle doit être utilisée si un équipage " \ "se voit donner beaucoup trop d'ordres qu'il ne peut " \ "accomplir, ce qui peut se produire dans le cas d'un bug " \ "(même les ordres inopérants ou inefficaces doivent être " \ "normalement gérés par le système). Précisez en paramètre " \ "la clé du navire. Si vous ne précisez aucun paramètre, " \ "la commande opère sur le navire où vous vous trouvez " \ "actuellement. Les volontés sont également retirées de " \ "l'équipage. Les contrôles ne sont cependant pas retirés."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "remettre", "launch") self.schema = "(<nombre>)" self.aide_courte = "remet à l'eau un navire" self.aide_longue = \ "Cette commande demande à un chantier navale vos " \ "navires actuellement en cale sèche. Un navire en cale " \ "sèche n'occupe pas de place dans le port mais vous ne " \ "pourrez l'utiliser sans le remettre à l'eau. Utilisez " \ "donc cette commande sans argument pour connaître la " \ "liste des navires que vous avez en cale sèche. Précisez " \ "le numéro du navire pour demander qu'il soit remis à " \ "l'eau. Notez que votre navire sera, après quelque temps, " \ "remis à l'eau à l'endroit exact qui était le sien avant " \ "d'être mis en cale sèche. Cependant, si un autre navire " \ "occupe l'emplacement, l'opération ne sera pas possible."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "conquérir", "conquer") self.tronquer = True self.aide_courte = "conquit un navire et équipage" self.aide_longue = \ "Cette commande permet de conquérir un navire adverse : " \ "si vous en avez le droit, vous en deviendrez son " \ "propriétaire. Vous aurez également les droits de commander " \ "les matelots de l'équipage. Vous pouvez utiliser cette " \ "commande si vous abordez un navire adverse : il ne vous " \ "sera pas possible de conquérir un navire dont l'équipage " \ "est encore complet ou presque complet, mais si il est " \ "affaibli (des matelots ont été tués), conquérir le navire " \ "aura pour effet de rendre les matelots conquis dociles " \ "et prêts à exécuter vos ordres. Si le navire adverse " \ "a déjà un propriétaire, vous ne pourrez pas le conquérir, " \ "à moins que l'ancien propriétaire ne soit mort."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "poudre", "powder") self.schema = "(<nombre>) <nom_objet>" self.aide_courte = "charge le canon en poudre" self.aide_longue = \ "Cette commande permet de charger le canon en poudre. " \ "Vous devez pour cela posséder un sac de poudre (soit " \ "entre vos mains, soit dans un sac que vous portez). Le " \ "sac de poudre sera prélevé pour charger le canon mais " \ "tout le sac ne sera pas utilisé, sauf si vous le précisez. " \ "Par défaut, une once de poudre est prélevée du sac et sert " \ "à charger le canon, mais vous pouvez préciser, avant " \ "le nom du sac, une valeur plus grande d'onces (par exemple " \ "%canon% %canon:poudre% |ent|5 sac de poudre|ff| pour charger " \ "le canon avec 5 onces de poudre). En fonction de la puissance " \ "et la capacité du canon, la quantité de poudre nécessaire " \ "varie (elle est aussi fonction du poids du boulet utilisé)."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "nourrir", "feed") self.tronquer = True self.schema = "<nom_familier> <nom_objet>" self.aide_courte = "nourrit un familier" self.aide_longue = \ "Cette commande permet de nourrir un familier, en lui " \ "donnant à manger un objet que vous possédez dans votre " \ "inventaire. Les familiers ne mangent pas tous la même " \ "chose, bien entendu. Cette commande est utile pour garder " \ "un familier en vie même quand vous vous trouvez à un " \ "endroit où il ne peut trouver de la nourriture par lui-même. " \ "Le premier paramètre est le nom du familier. Le second " \ "paramètre est un extrait du nom de l'objet à donner " \ "à ce familier, se trouvant dans votre inventaire. Par " \ "exemple, %familier% %familier:nourrir%|cmd| médor pomme " \ "rouge|ff|."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "liste", "list") self.tronquer = True self.aide_courte = "affiche les chambres libres" self.aide_longue = \ "Cette commande permet de lister les chambres libres d'une " \ "auberge ainsi que leur prix au jour. Vous devez vous " \ "trouver auprès d'un aubergiste pour cela. Les chambres " \ "affichées sont celles libres, c'est-à-dire que celles déjà " \ "louées ne seront pas listées. Utilisez la commande %louer% " \ "%louer:chambre% pour louer une chambre libre. Notez que " \ "le prix affiché est celui pour un jour. Mais le prix pour " \ "deux jours ne sera pas tout à fait le double du prix pour " \ "un jour : plus le nombre de jours réservés est élevé, plus " \ "le prix diminue en proportion. En somme, réserver une " \ "chambre pour dix jours coûtera moins cher que de réserver " \ "une chambre pour un jour et la renouveler neuf fois. Si vous " \ "voulez savoir combien coûterai la location d'une chambre " \ "pour une durée précise, utilisez la commande %louer% " \ "%louer:valeur%."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "contrôle", "control") self.tronquer = True self.schema = "(<texte_libre>)" self.aide_courte = "consulte ou modifie les contrôles" self.aide_longue = \ "Les contrôles sont des formes d'ordres prolongés. " \ "Ils nécessitent généralement la présence d'un commandant " \ "(un capitaine ou un second) PNJ. Celui-ci est en charge " \ "du contrôle et vérifie son déroulement au fur et à " \ "mesure. Un exemple de contrôle répandu est celui modifiant " \ "le cap du navire. Contrairement à un ordre simple, le " \ "contrôle va s'assurer que l'ordre est toujours valable " \ "plus tard. Si la direction du navire est modifiée pour " \ "une raison quelconque, le commandant donnera les ordres " \ "appropriés pour rectifier la direction. Côté manipulation, " \ "certains ordres sont justes propres à un contrôle et " \ "vous le verrez clairement indiqué dans l'aide de l'ordre. " \ "Vous pouvez entrer cette commande pour vérifier les " \ "contrôles actuels ou bien entrer en argument optionnel " \ "un contrôle pour le supprimer."
def __init__(self): """Constructeur du paramètre""" Parametre.__init__(self, "brouter", "graze") self.schema = "<nom_familier>" self.aide_courte = "demande au fammilier de brouter" self.aide_longue = \ "Cette commande permet d'ordonner à un familier de brouter " \ "l'herbe ou les plantes qui l'entourent, ou bien de " \ "chercher des fruits autour de lui si cela convient mieux " \ "à ses habitudes alimentaires. C'est utile " \ "et indispensable si vous possédez des familiers " \ "herbivores ou frugivores : si vous ne les nourrissez pas, ils " \ "finissent par mourir du manque d'eau et de nourriture. " \ "Si ils ont l'ordre de brouter et qu'ils se trouvent dans " \ "une plaine ou au bord d'un cours d'eau, ils vont " \ "pouvoir boire et se nourrir, même si vous n'êtes pas " \ "connecté. Notez que les carnivores chassent pour se " \ "nourrir. Pour utiliser cette commande, précisez " \ "simplement le nom du familier : vous devez vous trouver " \ "dans la même salle que lui. Utilisez la même commande " \ "pour demander au familier d'arrêter de brouter ou de " \ "chercher des fruits."
def __init__(self): """Constructeur du paramètre.""" Parametre.__init__(self, "renouveler", "renew") self.tronquer = True self.schema = "<chambre_auberge> <nombre>" self.aide_courte = "renouvelle une location" self.aide_longue = \ "Cette commande vous permet de renouveler le loyer d'une " \ "chambre que vous louez déjà. Si vous arrivez à la fin de " \ "la période d'expiration de la location, vous pouvez " \ "utiliser cette commande pour conserver la chambre plus " \ "longtemps. Vous ne pouvez utiliser cette commande pour " \ "dépasser le nombre de jours maximum (fixée à dix jours). " \ "La syntaxe de cette commande est la même que %louer% " \ "%louer:chambre%, vous devez préciser le numéro de la " \ "chambre en premier paramètre et la durée (en jours réels) " \ "de location souhaitée. La nouvelle durée sera ajoutée à " \ "celle restante et le prix que vous devrez payer sera le " \ "même que si vous vouliez louer cette chambre sans l'avoir " \ "déjà louée auparavant. Vous pouvez donc utiliser la " \ "commande %louer% %louer:valeur% pour estimer le prix " \ "nécessaire à un prolongement de la durée de location."