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."
