lgrez.features (Commandes et autres fonctionnalités)

lg-rez / Commandes et autres fonctionnalités

Chaque module de lgrez.features implémente une fonctionnalité spécifique des LGBots. La majorité implémentent un Cog (discord.ext.commands.Cog) contenant une ou plusieurs commandes Discord, mais peuvent aussi définir des fonctions pour un usage public.

Note

Les Cogs et leurs commandes peuvent être vus en envoyant !help à un LGBot fonctionnel (en possédant les rôles config.Role.mj et config.Role.joueur_en_vie)

Liste des commandes :

Commande

Description

Autorisations

Restrictions

Joueur en vie

Joueur mort

Rédacteur

MJ

Informations - Commandes pour en savoir plus sur soi et les autres :

!roles

Affiche la liste des rôles / des informations sur un rôle

X

X

X

!rolede

Donne le rôle d’un joueur

X

!quiest

Liste les joueurs ayant un rôle donné

X

!menu

Affiche des informations et boutons sur les votes / actions en cours

X

private

!infos

Affiche tes informations de rôle / actions

X

private

!actions

Affiche et modifie les actions d’un joueur

X

!vivants

Affiche la liste des joueurs vivants

X

X

X

!morts

Affiche la liste des joueurs morts

X

X

X

VoterAgir - Commandes de vote et d’action de rôle :

!vote

Vote pour le condamné du jour

X

private

!votemaire

Vote pour le nouveau maire

X

private

!voteloups

Vote pour la victime de l’attaque des loups

X

private

!action

Utilise l’action de ton rôle / une des actions associées

X

private

ActionsPubliques - Commandes d’actions vous engageant publiquement :

!haro

Lance publiquement un haro contre un autre joueur.

X

private

!candid

Candidate à l’élection du nouveau maire.

X

private

!wipe

Efface les haros / candidatures du jour

X

OpenClose - Commandes de gestion des votes et actions :

!open

Lance un vote / des actions de rôle

X

!close

Ferme un vote / des actions de rôle

X

!remind

Envoi un rappel de vote / actions de rôle

X

!refill

Recharger un/des pouvoirs rechargeables

X

!cparti

Lance le jeu

X

Sync - Commandes de synchronisation des GSheets vers la BDD et les joueurs :

!sync

Récupère et applique les modifs du Tableau de bord

X

!fillroles

Remplit les tables et #roles depuis le GSheet ad hoc

X

GestionTaches - Commandes de planification, exécution, annulation de tâches :

!taches

Liste les tâches en attente

X

!planif

Planifie une tâche au moment voulu

X

!delay

Exécute une commande après XhYmZs

X

!cancel

Annule une ou plusieurs tâche(s) planifiée(s)

X

Communication - Commandes d’envoi de messages, d’embeds, d’annonces… :

!embed

Prépare un embed (message riche) et l’envoie

X

!send

Envoie un message à tous ou certains joueurs

X

!post

Envoie un message dans un salon

X

!plot

Trace le résultat du vote et l’envoie sur #annonces

X

!annoncemort

Annonce un ou plusieur mort(s) hors-vote

X

!lore

Récupère et poste un lore depuis un Google Docs

X

!modif

Modifie un message du bot

X

GestionIA - Commandes relatives à l’IA (réponses automatiques du bot) :

!stfu

Active/désactive la réponse automatique du bot sur ton channel privé

X

X

X

private

!fals

Active/désactive le mode « foire à la saucisse »

X

X

X

!react

Force le bot à réagir à un message

X

X

X

!reactfals

Force le bot à réagir à un message comme en mode Foire à la saucisse

X

X

X

!addIA

Ajoute une règle d’IA

X

X

!listIA

Liste les règles d’IA reconnues par le bot

X

X

!modifIA

Modifie/supprime une règle d’IA

X

X

Annexe - Commandes annexes aux usages divers :

!roll

Lance un ou plusieurs dés

X

X

X

!coinflip

Renvoie le résultat d’un tirage à Pile ou Face (aléatoire)

X

X

X

!ping

Envoie un ping au bot

X

X

X

!akinator

J’ai glissé chef

X

X

X

!xkcd

J’ai aussi glissé chef, mais un peu moins

X

X

X

GestionChans - Gestion des salons :

!boudoir

Gestion des boudoirs

list

X

X

private

create

X

private

invite

X

X

in_boudoir

expulse

X

X

in_boudoir

leave

X

X

in_boudoir

transfer

X

X

in_boudoir

delete

X

X

in_boudoir

rename

X

X

in_boudoir

!addhere

Ajoute les membres au chan courant

X

!purge

Supprime tous les messages de ce chan

X

Special - Commandes spéciales (méta-commandes et expérimentations) :

!panik

Tue instantanément le bot, sans confirmation

X

!do

Exécute du code Python et affiche le résultat

X

!shell

Lance un terminal Python directement dans Discord

X

!co

Lance la procédure d’inscription pour un membre

X

!doas

Exécute une commande en tant qu’un autre joueur

X

!secret

Supprime le message puis exécute la commande

X

!stop

Peut débloquer des situations compliquées (beta)

X

X

X

private

!help

Affiche la liste des commandes utilisables et leur utilisation

X

X

X

!apropos

Informations et mentions légales du projet

X

X

X

.special

lg-rez / features / Commandes spéciales

Commandes spéciales (méta-commandes, imitant ou impactant le déroulement des autres ou le fonctionnement du bot)

class lgrez.features.special.Special(*args, **kwargs)[source]

Commandes spéciales (méta-commandes et expérimentations)

Note

Cette classe est un Cog, i.e. un rassemblements de commandes.

L’ensemble des commandes qu’elle contient, créées par le décorateur @discord.ext.commands.command, sont des objets discord.ext.commands.Command accessibles comme cog.cmd_name.

Pour plus de lisiblité, seules les fonctions appellées lors de l’invoquation des commandes (Command.callback) sont décrites ci-après, mais toutes les méthodes de Command sont évidemment accessibles.

Ces callbacks ont tous comme signature (sans compter self si définies dans un Cog) :

async def command(ctx, [ arg1, [..., argN,] ] [{*args | *, rest}]) -> None

  • ctx (discord.ext.commands.Context) le contexte d’invocation de la commande, construit automatiquement par discord.py à l’appel de Bot.process_commands ou Bot.get_context, puis

  • arg1, ..., argN (str) zéro, un ou plusieurs arguments(s) positionnels parsés à partir du texte entré par l’utilisateur (mots séparés par des espaces) ;

  • args (list[str]) un nombre arbitraire d’arguments, OU

  • rest (str) le texte restant après le traitement des arguments positionnels.

Une exception dérivant de discord.ext.commands.UserInputError est levée en cas d’utilisation incorrecte (puis traitée par LGBot.on_command_error()).

Commandes définies dans ce cog :

  • Commande !panik (alias !kill) 
    async panik.callback(ctx)

    Tue instantanément le bot, sans confirmation (COMMANDE MJ)

    PAAAAANIK

  • Commande !do  
    async do.callback(ctx, *, code)

    Exécute du code Python et affiche le résultat (COMMANDE MJ)

    Paramètres

    code – instructions valides dans le contexte du LGbot (utilisables notemment : ctx, config, blocs, features, bdd, <table>…)

    Si code est une coroutine, elle sera awaited (ne pas inclure await dans code).

    Aussi connue sous le nom de « faille de sécurité », cette commande permet de faire environ tout ce qu’on veut sur le bot (y compris le crasher, importer des modules, exécuter des fichiers .py… même si c’est un peu compliqué) voire d’impacter le serveur sur lequel le bot tourne si on est motivé.

    À utiliser avec parcimonie donc, et QUE pour du développement/debug !

  • Commande !shell  
    async shell.callback(ctx)

    Lance un terminal Python directement dans Discord (COMMANDE MJ)

    Envoyer help dans le pseudo-terminal pour plus d’informations sur son fonctionnement.

    Évidemment, les avertissements dans !do s’appliquent ici : ne pas faire n’imp avec cette commande !! (même si ça peut être très utile, genre pour ajouter des gens en masse à un channel)

  • Commande !co  
    async co.callback(ctx, cible=None)

    Lance la procédure d’inscription pour un membre (COMMANDE MJ)

    Fat comme si on se connectait au serveur pour la première fois.

    Paramètres

    cible – le nom exact ou la mention (@joueur) du joueur à inscrire, par défaut le lançeur de la commande.

    Cette commande est principalement destinée aux tests de développement, mais peut être utile si un joueur chibre son inscription (à utiliser dans son channel, ou #bienvenue (avec !autodestruct) si même le début a chibré).

  • Commande !doas  
    async doas.callback(ctx, *, qui_quoi)

    Exécute une commande en tant qu’un autre joueur (COMMANDE MJ)

    Paramètres

    qui_quoi – nom de la cible (nom/mention d’un joueur INSCRIT) suivi de la commande à exécuter (commençant par un !).

    Exemple

    !doas Vincent Croquette !vote Annie Colin

  • Commande !secret (alias !autodestruct, !ad) 
    async secret.callback(ctx, *, quoi)

    Supprime le message puis exécute la commande (COMMANDE MJ)

    Paramètres

    quoi – commande à exécuter, commençant par un !

    Utile notemment pour faire des commandes dans un channel public, pour que la commande (moche) soit immédiatement supprimée.

  • Commande !stop  
    async stop.callback(ctx)

    Peut débloquer des situations compliquées (beta)

    Ne pas utiliser cette commande sauf en cas de force majeure où plus rien ne marche, et sur demande d’un MJ (après c’est pas dit que ça marche mieux après l’avoir utilisée)

  • Commande !help (alias !aide, !aled, !oskour) 
    async help.callback(ctx, *, command=None)

    Affiche la liste des commandes utilisables et leur utilisation

    Paramètres

    command (optionnel) – nom exact d’une commande à expliquer (ou un de ses alias)

    Si command n’est pas précisée, liste l’ensemble des commandes accessibles à l’utilisateur.

  • Commande !apropos (alias !about, !copyright, !licence, !auteurs) 
    async apropos.callback(ctx)

    Informations et mentions légales du projet

    N’hésitez-pas à nous contacter pour en savoir plus !

  • Commande !setup  
    async setup.callback(ctx)

    ✨ Prépare un serveur nouvellement crée (COMMANDE MJ)

    À n’utiliser que dans un nouveau serveur, pour créer les rôles, catégories, salons et emojis nécessaires.

.actions_publiques

lg-rez / features / Actions publiques

Gestion des haros, candidatures à la mairie, résultats des votes

class lgrez.features.actions_publiques.ActionsPubliques(*args, **kwargs)[source]

Commandes d’actions vous engageant publiquement

Commandes définies dans ce cog :

  • Commande !haro  
    async haro.callback(ctx, *, cible=None)

    Lance publiquement un haro contre un autre joueur.

    Paramètres

    cible – nom du joueur à accuser

    Cette commande n’est utilisable que lorsqu’un vote pour le condamné est en cours.

  • Commande !candid  
    async candid.callback(ctx)

    Candidate à l’élection du nouveau maire.

    Cette commande n’est utilisable que lorsqu’un vote pour le nouveau maire est en cours.

  • Commande !wipe  
    async wipe.callback(ctx, quoi)

    Efface les haros / candidatures du jour (COMMANDE MJ)

    Paramètres

    quoi (str) –

    peut être

    • haros : Supprimer les haros

    • candids : Supprimer les candicatures

    (commande non testée unitairement)

.annexe

lg-rez / features / Commandes annexes

Commandes diverses qu’on ne savait pas où ranger

class lgrez.features.annexe.Annexe(*args, **kwargs)[source]

Commandes annexes aux usages divers

Commandes définies dans ce cog :

  • Commande !roll  
    async roll.callback(ctx, *, XdY)

    Lance un ou plusieurs dés

    Paramètres

    XdY – dés à lancer + modifieurs, au format XdY + XdY + ... + Z - Z ... avec X le nombre de dés, Y le nombre de faces et Z les modifieurs (constants) ; OU roll spécial : joueur / vivant / mort / rôle / camp.

    Exemples

    • !roll 1d6 -> lance un dé à 6 faces

    • !roll 1d20 +3 -> lance un dé à 20 faces, ajoute 3 au résultat

    • !roll 1d20 + 2d6 -8 -> lance un dé 20 plus deux dés 6, enlève 8 au résultat

    • !roll vivant -> choisit un joueur vivant

  • Commande !nextroll  
    async nextroll.callback(ctx, *, next=None)

    ✨ Shhhhhhhhhhhh.

    Ça sent la magouilleuh

  • Commande !coinflip (alias !cf, !pf) 
    async coinflip.callback(ctx)

    Renvoie le résultat d’un tirage à Pile ou Face (aléatoire)

    Pile je gagne, face tu perds.

  • Commande !ping (alias !pong) 
    async ping.callback(ctx)

    Envoie un ping au bot

    Pong

    Avertissement

    Commande en bêta, non couverte par les tests unitaires.

  • Commande !akinator  
    async akinator.callback(ctx)

    J’ai glissé chef

    Implémentation directe de https://pypi.org/project/akinator.py

    Avertissement

    Commande en bêta, non couverte par les tests unitaires.

  • Commande !xkcd  
    async xkcd.callback(ctx, N)

    J’ai aussi glissé chef, mais un peu moins

    Paramètres

    N – numéro du comic

    Avertissement

    Commande en bêta, non couverte par les tests unitaires.

.chans

lg-rez / features / Commandes de gestion des salons

Création, ajout, suppression de membres

lgrez.features.chans.in_boudoir(callback)[source]

Décorateur : commande utilisable dans un boudoir uniquement.

Lors d’une invocation de la commande décorée hors d’un boudoir (enregistré dans bdd.Boudoir), affiche un message d’erreur.

Ce décorateur n’est utilisable que sur une commande définie dans un Cog.

lgrez.features.chans.gerant_only(callback)[source]

Décorateur : commande utilisable par le gérant d’un boudoir uniquement.

Lors d’une invocation de la commande décorée par un membre qui n’est pas gérant du boudoir, affiche un message d’erreur.

Ce décorateur doit toujours être utilisé en combinaison avec in_boudoir() et positionné après lui.

Ce décorateur n’est utilisable que sur une commande définie dans un Cog.

async lgrez.features.chans.add_joueur_to_boudoir(boudoir, joueur, gerant=False)[source]

Ajoute un joueur sur un boudoir.

Crée la Bouderie correspondante et modifie les permissions du salon.

Paramètres

  • boudoir (.Boudoir) – Le boudoir où ajouter un joueur.

  • joueur (.Joueur) – Le joueur à ajouter.

  • gerant (bool) – Si le joueur doit être ajouté avec les permissions de gérant.

Renvoie

bool - True si le joueur a été ajouté,

False si il y était déjà / le boudoir est fermé.

async lgrez.features.chans.remove_joueur_from_boudoir(boudoir, joueur)[source]

Retire un joueur d’un boudoir.

Supprime la Bouderie correspondante et modifie les permissions du salon.

Paramètres

  • boudoir (.Boudoir) – Le boudoir d’où enlever un joueur.

  • joueur (.Joueur) – Le joueur à enlever.

class lgrez.features.chans.GestionChans(*args, **kwargs)[source]

Gestion des salons

Commandes définies dans ce cog :

  • Commande !boudoir (alias !boudoirs) 
    async boudoir.callback(ctx)

    Gestion des boudoirs

    Les options relatives à un boudoir précis ne peuvent être exécutées que dans ce boudoir ; certaines sont réservées au gérant dudit boudoir.

    Note

    Cette commande est un Groupe (discord.ext.commands.Group), i.e. une commande composée de plusieurs sous-commandes (ou options).

    Les sous-commandes, créées par le décorateur @<group>.command (ou @<group>.group pour ajouter un niveau), sont également des objets Command accessibles via <group>.get_command et la note relative aux cogs (callback, signature…) s’applique.

    • Option !boudoir create (alias !new, !creer, !créer) 
      async create.callback(ctx, *, nom=None)

      Crée un nouveau boudoir dont tu es gérant

    • Option !boudoir delete  
      async delete.callback(ctx)

      Supprime ce boudoir

    • Option !boudoir expulse (alias !remove, !kick) 
      async expulse.callback(ctx, *, cible=None)

      Expulse un membre de ce boudoir

    • Option !boudoir find (alias !locate, !whereis) 
      async find.callback(ctx, *cibles)

      ✨ Trouve le(s) boudoir(s) réunissant certains joueurs (COMMANDE MJ)

      Paramètres

      *cibles – noms ou mentions des joueurs qui nous intéressent.

    • Option !boudoir help  
      async help.callback(ctx)

      ✨ Informations sur les sous-commandes disponibles

      Alias pour !help boudoir.

    • Option !boudoir invite (alias !add) 
      async invite.callback(ctx, *, cible=None)

      Invite un joueur à rejoindre ce boudoir

    • Option !boudoir leave (alias !quit) 
      async leave.callback(ctx)

      Quitte ce boudoir

    • Option !boudoir list (alias !liste) 
      async list.callback(ctx)

      Liste les boudoirs dans lesquels tu es

    • Option !boudoir ping (alias !hého) 
      async ping.callback(ctx, *, mess='')

      Mentionne tous les joueurs vivants dans le boudoir.

    • Option !boudoir rename  
      async rename.callback(ctx, *, nom=None)

      Renomme ce boudoir

    • Option !boudoir transfer (alias !transmit) 
      async transfer.callback(ctx, cible=None)

      Transfère les droits de gestion de ce boudoir

  • Commande !mp  
    async mp.callback(ctx, *, cible=None)

    ✨ Raccourci pour créer un boudoir et y ajouter un joueur.

    Si un boudoir existe déjà avec uniquement ce joueur et toi, n’en crée pas un nouveau.

    Paramètres

    cible – la personne avec qui créer un boudoir.

  • Commande !addhere  
    async addhere.callback(ctx, *joueurs)

    Ajoute les membres au chan courant (COMMANDE MJ)

    Paramètres

    *joueurs – membres à ajouter, chacun entouré par des guillemets si nom + prénom

    Si *joueurs est un seul élément, il peut être de la forme <crit>=<filtre> tel que décrit dans l’aide de !send.

  • Commande !purge  
    async purge.callback(ctx, N=None)

    Supprime tous les messages de ce chan (COMMANDE MJ)

    Paramètres

    N – nombre de messages à supprimer (défaut : tous)

.communication

lg-rez / features / Communication

Envoi de messages, d’embeds…

class lgrez.features.communication.Communication(*args, **kwargs)[source]

Commandes d’envoi de messages, d’embeds, d’annonces…

Commandes définies dans ce cog :

  • Commande !embed  
    async embed.callback(ctx, key=None, *, val=None)

    Prépare un embed (message riche) et l’envoie (COMMANDE MJ)

    Avertissement

    Commande en bêta, non couverte par les tests unitaires et souffrant de bugs connus (avec les fields notemment)

    Paramètres

    • key – sous-commande (voir ci-dessous). Si omis, prévisualise le brouillon d’embed actuellement en préparation ;

    • val – valeur associée. Pour les sous-commandes de construction d’élement, supprime ledit élément si omis.

    • Sous-commandes générales :

      • !embed create <titre> : Créer un nouveau brouillon d’embed (un seul brouillon en parallèle, partout)

      • !embed delete : Supprimer le brouillon d’embed

      • !embed preview : Voir l’embed sans les aides

      • !embed post [#channel] : Envoyer l’embed sur #channel (chan courant si omis)

    • Sous-commandes de construction d’éléments :
      • Éléments généraux :

        • !embed title [titre]

        • !embed description [texte]

        • !embed url [url*]

        • !embed color [#ffffff] (barre de gauche, code hexadécimal)

      • Auteur :

        • !embed author [nom]

        • !embed author_url [url*]

        • !embed author_icon [url**]

      • Talon :

        • !embed footer [texte]

        • !embed footer_icon [url**]

      • Images :

        • !embed image [url**] (grande image)

        • !embed thumb [url**] (en haut à droite)

      • Champssyntaxe spéciale
        • !embed field <i> <skey> [val]

          • i : Numéro du champ (commençant à 0). Si premier champ non existant, le crée ;

          • skey :

            • name : Nom du champ

            • value : Valeur du champ

            • delete : Supprime le champ

        Les champs sont (pour l’instant) forcément de type inline (côte à côte).

    * Les URL doivent commencer par http(s):// pour être reconnues comme telles.

    ** Ces URL doivent correspondre à une image.

  • Commande !send (alias !tell) 
    async send.callback(ctx, cible, *, message)

    Envoie un message à tous ou certains joueurs (COMMANDE MJ)

    Paramètres

    • cible – destinataires

    • message – message, éventuellement formaté

    cible peut être :

    • all : Tous les joueurs inscrits, vivants et morts

    • vivants : Les joueurs en vie

    • morts : Les joueurs morts

    • <crit>=<filtre> : Les joueurs répondant au critère Joueur.<crit> == <filtre>. crit peut être "nom", "chambre", "statut", "role", "camp"… L’ensemble doit être entouré de guillements si filtre contient un espace. Les rôles/camps sont cherchés par slug.

    • le nom d’un joueur (raccourci pour nom=X, doit être entouré de guillements si nom + prénom)

    message peut contenir un ou plusieurs bouts de code Python à évaluer, entourés d’accolades.

    L’évaluation est faite séparément pour chaque joueur, ce qui permet de personnaliser le message grâce aux variables particulières dépendant du joueur :

    • joueur : objet BDD du joueur recevant le message ==> joueur.nom, joueur.role…

    • member : objet discord.Member associé ==> member.mention

    • chan : objet discord.TextChannel du chan privé du joueur

    Attention :

    Les différentes tables de données sont accessibles sous leur nom (Joueur, Role…)

    Il est impossible d’appeller des coroutines (await) dans le code à évaluer.

    Exemples

    • !send all Bonsoir à tous c'est Fanta

    • !send vivants Attention {member.mention}, derrière toi c'est affreux !

    • !send "role=servante" Ça va vous ? Vous êtes bien {joueur.role.nom} ?

  • Commande !post  
    async post.callback(ctx, chan, *, message)

    Envoie un message dans un salon (COMMANDE MJ)

    Paramètres

    • chan – nom du salon ou sa mention

    • message – message à envoyer (peut être aussi long que nécessaire, contenir des sauts de lignes…)

  • Commande !plot  
    async plot.callback(ctx, quoi, depuis=None)

    Trace le résultat du vote et l’envoie sur #annonces (COMMANDE MJ)

    Avertissement

    Commande en bêta, non couverte par les tests unitaires

    Paramètres

    • quoi –

      peut être

      • cond pour le vote pour le condamné

      • maire pour l’élection à la Mairie

    • depuis – heure éventuelle à partir de laquelle compter les votes (si plusieurs votes dans la journée), compte tous les votes du jour par défaut. Si plus tard que l’heure actuelle, compte les votes de la veille.

    Trace les votes sous forme d’histogramme à partir du Tableau de bord, en fait un embed en présisant les résultats détaillés et l’envoie sur le chan #annonces.

    Si quoi == "cond", déclenche aussi les actions liées au mot des MJs (bdd.ActionTrigger.mot_mjs).

  • Commande !annoncemort  
    async annoncemort.callback(ctx, *, victime=None)

    Annonce un ou plusieur mort(s) hors-vote (COMMANDE MJ)

    Paramètres

    victime – (premier) mort à annoncer

    Envoie un embed par mort dans #annonces

  • Commande !lore  
    async lore.callback(ctx, doc_id)

    Récupère et poste un lore depuis un Google Docs (COMMANDE MJ)

    Convertit les formats et éléments suivants vers Discord :

    • Gras, italique, souligné, barré;

    • Petites majuscules (-> majuscules);

    • Polices à chasse fixe (Consolas / Courier New) (-> code);

    • Liens hypertextes;

    • Listes à puces;

    • Mentions de joueurs, sous la forme @Prénom Nom;

    • Mentions de rôles, sous la forme @nom_du_role;

    • Emojis, sous la forme :nom:.

    Permet soit de poster directement dans #annonces, soit de récupérer la version formatée du texte (pour copier-coller).

    Paramètres

    doc_id – ID ou URL du document (doit être public ou dans le Drive partagé avec le compte de service)

  • Commande !modif  
    async modif.callback(ctx, ref, *, modifs)

    Modifie un message du bot (COMMANDE MJ)

    Paramètres

    • ref –

      référence vers le message à modifier, peut être

      • le lien du message,

      • son couple d’IDs dans le serveur (salon-message),

      • son ID seul (seulement si message dans ce salon),

      • un nom/mention de salon (si le dernier message est du bot),

      • rien, si on répond au message à modifier.

    • modifs – modifications à faire, sous la forme « avant > après » (ou juste « > après » pour tout remplacer).

    Il n’est pas possible (pour le moment ?) de modifier une image, pièce jointe ou embed.

.gestion_actions

lg-rez / features / Gestion des actions

Liste, création, suppression, ouverture, fermeture d’actions

lgrez.features.gestion_actions.add_action(joueur, base, cooldown=0, charges=None, active=True)[source]

Enregistre une action et programme son ouverture le cas échéant.

Si une action existe déjà pour ce joueur et cette base, la modifie ; sinon, en crée une nouvelle.

Paramètres

  • joueur – Paramètre de l’action

  • base – Paramètre de l’action

  • cooldown – Paramètre de l’action

  • charges – Paramètre de l’action

  • active – Paramètre de l’action

lgrez.features.gestion_actions.delete_action(action)[source]

Archive une action et annule les tâches en cours liées.

Depuis la version 2.1, l’action n’est plus supprimée mais est passée à active = False.

Paramètres

action (.bdd.Action) – l’action à supprimer

async lgrez.features.gestion_actions.open_action(action)[source]

Ouvre l’action.

Paramètres

action (.bdd.Action) – l’action à ouvir

Opérations réalisées :

  • Vérification des conditions (cooldown, charges…) et reprogrammation si nécessaire ;

  • Gestion des tâches planifiées (planifie remind/close si applicable) ;

  • Information du joueur.

async lgrez.features.gestion_actions.close_action(action)[source]

Ferme l’action.

Paramètres

action (.bdd.Action) – l’action à enregistrer

Opérations réalisées :

  • Archivage si nécessaire ;

  • Gestion des tâches planifiées (planifie prochaine ouverture si applicable) ;

  • Information du joueur (si charge– seulement).

lgrez.features.gestion_actions.get_actions(quoi, trigger, heure=None)[source]

Renvoie les actions répondant à un déclencheur donné.

Paramètres

  • quoi (str) –

    Type d’opération en cours :

    • "open" : ouverture, Action.is_open doit être faux;

    • "close" : fermeture, Action.is_open doit être vrai;

    • "remind" : rappel, Action.is_waiting doit être vrai.

  • trigger (bdd.ActionTrigger) – valeur de Action.trigger_debut/fin à détecter.

  • heure (datetime.time) – si trigger == "temporel", ajoute la condition Action.heure_debut/fin == heure.

Renvoie

La liste des actions correspondantes.

Type renvoyé

Sequence[.bdd.Action]

.IA

lg-rez / features / IA des réponses

Tout ce qui concerne la manière dont le bot réagit aux messages : détermination de la meilleure réaction, gestion des réactions, activation/désactivation des modes de chat

lgrez.features.IA.fetch_tenor(trigger)[source]

Renvoie le GIF Tenor le plus « pertinent » pour un texte donné.

Paramètres

trigger (str) – texte auquel réagir.

Renvoie

str (URL du GIF) ou None

async lgrez.features.IA.trigger_at_mj(message)[source]

Règle d’IA : réaction si le message mentionne les MJs.

Paramètres

message (Message) – message auquel réagir.

Renvoie

  • True – si le message mentionne les MJ et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.trigger_roles(message, sensi=0.8)[source]

Règle d’IA : réaction si un nom de rôle est donné.

Paramètres

Trouve l’entrée la plus proche de message.content dans la table bdd.Role.

Renvoie

  • True – si un rôle a été trouvé (sensibilité > sensi) et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.trigger_reactions(message, chain=None, sensi=0.7, debug=False)[source]

Règle d’IA : réaction à partir de la table bdd.Reaction.

Paramètres

Trouve l’entrée la plus proche de chain dans la table bdd.Reaction ; si il contient des accolades, évalue le message selon le contexte de message.

Renvoie

  • True – si une réaction a été trouvé (sensibilité > sensi) et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.trigger_sub_reactions(message, sensi=0.9, debug=False)[source]

Règle d’IA : réaction à partir de la table, mais sur les mots

Appelle trigger_reactions(bot, message, mot, sensi, debug) pour tous les mots mot composant message.content (mots de plus de 4 lettres, testés des plus longs aux plus courts).

Paramètres
Renvoie

  • True – si une réaction a été trouvé (sensibilité > sensi) et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.trigger_di(message)[source]

Règle d’IA : réaction aux messages en di… / cri…

Paramètres

message (Message) – message auquel réagir.

Renvoie

  • True – si le message correspond et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.trigger_gif(message)[source]

Règle d’IA : réaction par GIF en mode Foire à la saucisse.

Paramètres

message (Message) – message auquel réagir

Renvoie

  • True – si le message correspond et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.trigger_mot_unique(message)[source]

Règle d’IA : réaction à un mot unique (le répète).

Paramètres

message (Message) – message auquel réagir.

Renvoie

  • True – si le message correspond et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.trigger_a_ou_b(message)[source]

Règle d’IA : réaction à un motif type « a ou b » (répond « b »).

Paramètres

message (Message) – message auquel réagir.

Renvoie

  • True – si le message correspond et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.default(message)[source]

Règle d’IA : réponse par défaut

Paramètres

message (Message) – message auquel réagir.

Renvoie

  • True – si le message correspond et qu’une réponse a été envoyée

  • False – sinon

async lgrez.features.IA.process_IA(message, debug=False)[source]

Exécute les règles d’IA.

Paramètres

  • message (Message) – message auquel réagir.

  • debug (bool) – si True, affiche les erreurs lors de l’évaluation des messages (voir tools.eval_accols()).

class lgrez.features.IA.GestionIA(*args, **kwargs)[source]

Commandes relatives à l’IA (réponses automatiques du bot)

Commandes définies dans ce cog :

  • Commande !stfu  
    async stfu.callback(ctx, force=None)

    Active/désactive la réponse automatique du bot sur ton channel privé

    Paramètres

    force – "start"/"on" / "stop"/"off" permet de forcer l’activation / la désactivation.

    Sans argument, la commande active les réactions si désactivées et vice-versa ; avec un autre argument, elle le fait silencieusment.

    N’agit que sur les messages classiques envoyés dans le channel : les commandes restent reconnues.

    Si vous ne comprenez pas le nom de la commande, demandez à Google.

  • Commande !fals (alias !cancer, !214) 
    async fals.callback(ctx, force=None)

    Active/désactive le mode « foire à la saucisse »

    Paramètres

    force – "start"/"on" / "stop"/"off" permet de forcer l’activation / la désactivation.

    Sans argument, la commande active le mode si désactivé et vice-versa.

    En mode « foire à la saucisse », le bot réagira à (presque) tous les messages, pas seulement sur les motifs qu’on lui a appris.

    À utiliser à vos risques et périls !

  • Commande !react (alias !r) 
    async react.callback(ctx, *, trigger)

    Force le bot à réagir à un message

    Paramètres

    trigger – texte auquel le bot doit réagir

    Permet de faire appel à l’IA du bot même sur les chans publics, ou en mode STFU, etc.

    Si utilisée par un MJ, active aussi le mode débug des évaluations Python (messages d’erreur).

  • Commande !reactfals (alias !rf) 
    async reactfals.callback(ctx, *, trigger)

    Force le bot à réagir à un message comme en mode Foire à la saucisse

    Paramètres

    trigger – texte auquel le bot doit réagir

    Permet de faire appel directement au mode Foire à la saucisse, même si il n’est pas activé / sur un chan public.

  • Commande !addIA  
    async addIA.callback(ctx, *, triggers=None)

    Ajoute une règle d’IA (COMMANDE MJ/RÉDACTEURS)

    Paramètres

    triggers – mot(s), phrase(s), ou expression(s) séparées par des points-virgules ou sauts de lignes (ne peut pas contenir de « > » ou « ; » hors séparateurs)

    Nouveau système d’ajout rapide :

    !addIA trigger > reponse !addIA trig1 ; trig2 > reponse

    ou, si réponse à un message de contenu « trigger » :

    !addIA > reponse (triggers = [trigger]) !addIA trig2 > reponse (triggers = [trigger, trig2])

    Une sécurité empêche d’ajouter un trigger déjà existant.

    Dans le cas où plusieurs expressions sont spécifiées, toutes déclencheront l’action demandée.

  • Commande !listIA  
    async listIA.callback(ctx, trigger=None, sensi=0.5)

    Liste les règles d’IA reconnues par le bot (COMMANDE MJ/RÉDACTEURS)

    Args
    trigger (optionnel): mot/expression permettant de filter et

    trier les résultats. SI trigger FAIT PLUS D’UN MOT, IL DOIT ÊTRE ENTOURÉ PAR DES GUILLEMETS !

    sensi: sensibilité de détection (ratio des caractères

    correspondants, entre 0 et 1) si trigger est précisé.

  • Commande !modifIA  
    async modifIA.callback(ctx, *, trigger=None)

    Modifie/supprime une règle d’IA (COMMANDE MJ/RÉDACTEURS)

    Paramètres

    trigger – mot/expression déclenchant la réaction à modifier/supprimer

    Permet d’ajouter et supprimer des triggers, de modifier la réaction du bot (construction d’une séquence de réponses successives ou aléatoires) ou de supprimer la réaction.

.informations

lg-rez / features / Commandes informatives

Commandes donnant aux joueurs des informations sur le jeu, leurs actions, les joueurs en vie et morts…

class lgrez.features.informations.Informations(*args, **kwargs)[source]

Commandes pour en savoir plus sur soi et les autres

Commandes définies dans ce cog :

  • Commande !roles (alias !role, !rôles, !rôle) 
    async roles.callback(ctx, *, role=None)

    Affiche la liste des rôles / des informations sur un rôle

    Paramètres

    role – le nom d’un rôle, pour les informations sur ce rôle.

    Sans argument, liste tous les rôles existants. Voir aussi la commande !camps.

  • Commande !camps (alias !camp) 
    async camps.callback(ctx, *, camp=None)

    Affiche la liste des camps / les rôles d’un camp

    Paramètres

    camp – le nom d’un camp, pour les informations sur ce camp.

    Sans argument, liste tous les camps existants. Voir aussi la commande !role.

  • Commande !rolede  
    async rolede.callback(ctx, *, cible=None)

    Donne le rôle d’un joueur (COMMANDE MJ)

    Paramètres

    cible – le joueur dont on veut connaître le rôle

  • Commande !quiest  
    async quiest.callback(ctx, *, nomrole)

    Liste les joueurs ayant un rôle donné (COMMANDE MJ)

    Paramètres

    nomrole – le rôle qu’on cherche (doit être un slug ou un nom de rôle valide)

  • Commande !infos  
    async infos.callback(ctx)

    Affiche tes informations de rôle / actions

    Toutes les actions liées à ton rôle (et parfois d’autres) sont indiquées, même celles que tu ne peux pas utiliser pour l’instant (plus de charges, déclenchées automatiquement…)

  • Commande !actions  
    async actions.callback(ctx, *, cible=None)

    Affiche et modifie les actions d’un joueur (COMMANDE MJ)

    Paramètres

    cible – le joueur dont on veut voir ou modifier les actions

    Avertissement

    Commande expérimentale, non testée.

  • Commande !vivants (alias !joueurs, !vivant) 
    async vivants.callback(ctx)

    Affiche la liste des joueurs vivants

    Aussi dite : « liste des joueurs qui seront bientôt morts »

  • Commande !morts (alias !mort) 
    async morts.callback(ctx)

    Affiche la liste des joueurs morts

    Aussi dite : « liste des joueurs qui mangent leurs morts »

.inscription

lg-rez / features / Process d’inscription

Étapes préliminaires pour les joueurs avant le début de saison

async lgrez.features.inscription.new_channel(member)[source]

Crée et renvoie un nouveau salon privé.

Peut être étendue, mais toujours appeller cette fonction pour créer le chan en lui-même, au risque d’altérer le fonctionnement normal du bot.

Paramètres

member (discord.Member) – le membre pour qui créer le salon.

Renvoie

discord.TextChannel

async lgrez.features.inscription.register_on_tdb(joueur)[source]

Enregistre un joueur dans le Tableau de bord.

Peut être personnalisé à un autre système de gestion des joueurs.

Paramètres

joueur (.bdd.Joueur) – le joueur à enregistrer.

Note

Fonction asynchrone depuis la version 2.2.2.

async lgrez.features.inscription.main(member)[source]

Routine d’inscription complète d’un joueur.

Paramètres

member (Member) – joueur à inscrire.

Crée et paramètre le salon privé du joueur, lui pose des questions et l’inscrit en base.

Personalisation : voir config.demande_chambre, config.chambre_mj, config.additional_inscription_step() et config.debut_saison.

Commande appellée à l’arrivée sur le serveur, utiliser !co pour trigger cette commande depuis Discord.

.open_close

lg-rez / features / Gestion des votes et actions

Ouverture / fermeture / rappels des votes et actions (+ refill)

async lgrez.features.open_close.recup_joueurs(quoi, qui, heure=None)[source]

Renvoie les joueurs concernés par la tâche !quoi <qui> [heure].

Paramètres

  • quoi (str) – évènement, "open" / "close" / "remind".

  • qui (bdd.Vote | str) –

    Vote

    pour le vote correspondant

    action

    pour les actions commençant à heure

    {id}

    pour une action précise (bdd.Action.id)

  • heure (str) – si qui == "action", heure associée (au format HHhMM).

Renvoie

list[bdd.Joueur]

Exemples

!open cond -> joueurs avec droit de vote !close action 17h -> joueurs dont l’action se termine à 17h

class lgrez.features.open_close.OpenClose(*args, **kwargs)[source]

Commandes de gestion des votes et actions

Commandes définies dans ce cog :

  • Commande !open  
    async open.callback(ctx, qui, heure=None, heure_chain=None)

    Lance un vote / des actions de rôle (COMMANDE BOT / MJ)

    Paramètres

    • qui –

      cond

      pour le vote du condamné

      maire

      pour le vote du maire

      loups

      pour le vote des loups

      action

      pour les actions commençant à heure

      {id}

      pour une action spécifique

    • heure –

      • si qui == "cond", "maire" ou "loup", programme en plus la fermeture à heure (et un rappel 30 minutes avant) ;

      • si qui == "action", il est obligatoire : heure des actions à lancer (cf plus haut). Pour les actions, la fermeture est de toute façon programmée le cas échéant (trigger_fin temporel ou delta).

      Dans tous les cas, format HHh ou HHhMM.

    • heure_chain – permet de chaîner des votes : lance le vote immédiatement et programme sa fermeture à heure, en appellant !close de sorte à programmer une nouvelle ouverture le lendemain à heure_chain, et ainsi de suite. Format HHh ou HHhMM.

    Une sécurité empêche de lancer un vote ou une action déjà en cours.

    Cette commande a pour vocation première d’être exécutée automatiquement par des tâches planifiées. Elle peut être utilisée à la main, mais attention à ne pas faire n’importe quoi (penser à envoyer / planifier la fermeture des votes, par exemple).

    Exemples

    • !open maire : lance un vote maire maintenant

    • !open cond 19h : lance un vote condamné maintenant et programme sa fermeture à 19h00 (ex. Juge Bègue)

    • !open cond 18h 10h : lance un vote condamné maintenant, programme sa fermeture à 18h00, et une prochaine ouverture à 10h qui se fermera à 18h, et ainsi de suite

    • !open action 19h : lance toutes les actions commençant à 19h00

    • !open 122 : lance l’action d’ID 122

  • Commande !close  
    async close.callback(ctx, qui, heure=None, heure_chain=None)

    Ferme un vote / des actions de rôle (COMMANDE BOT / MJ)

    Paramètres

    • qui –

      cond

      pour le vote du condamné

      maire

      pour le vote du maire

      loups

      pour le vote des loups

      action

      pour les actions se terminant à heure

      {id}

      pour une action spécifique

    • heure –

      • si qui == "cond", "maire" ou "loup", programme en plus une prochaine ouverture à heure (et un rappel 30 minutes avant) ;

      • si qui == "action", il est obligatoire : heure des actions à lancer (cf plus haut). Pour les actions, la prochaine est de toute façon programmée le cas échéant (cooldown à 0 et reste des charges).

      Dans tous les cas, format HHh ou HHhMM.

    • heure_chain – permet de chaîner des votes : ferme le vote immédiatement et programme une prochaine ouverture à heure, en appellant !close de sorte à programmer une nouvelle fermeture le lendemain à heure_chain, et ainsi de suite. Format HHh ou HHhMM.

    Une sécurité empêche de fermer un vote ou une action qui n’est pas en cours.

    Cette commande a pour vocation première d’être exécutée automatiquement par des tâches planifiées. Elle peut être utilisée à la main, mais attention à ne pas faire n’importe quoi (penser à envoyer / planifier la fermeture des votes, par exemple).

    Exemples

    • !close maire : ferme le vote condamné maintenant

    • !close cond 10h : ferme le vote condamné maintenant et programme une prochaine ouverture à 10h00

    • !close cond 10h 18h : ferme le vote condamné maintenant, programme une prochaine ouverture à 10h00, qui sera fermé à 18h, puis une nouvelle ouverture à 10h, etc

    • !close action 22h : ferme toutes les actions se terminant à 22h00

    • !close 122 : ferme l’action d’ID 122

  • Commande !remind  
    async remind.callback(ctx, qui, heure=None)

    Envoi un rappel de vote / actions de rôle (COMMANDE BOT / MJ)

    Paramètres

    • qui –

      cond

      pour le vote du condamné

      maire

      pour le vote du maire

      loups

      pour le vote des loups

      action

      pour les actions se terminant à heure

      {id}

      pour une action spécifique

    • heure – ne sert que dans le cas où <qui> == « action » (il est alors obligatoire), contrairement à !open et !close. Format HHh ou HHhMM.

    Le bot n’envoie un message qu’aux joueurs n’ayant pas encore voté / agi, si le vote ou l’action est bien en cours.

    Cette commande a pour vocation première d’être exécutée automatiquement par des tâches planifiées. Elle peut être utilisée à la main, mais attention à ne pas faire n’importe quoi !.

    Exemples

    • !remind maire : rappelle le vote maire maintenant

    • !remind action 22h : rappelle toutes les actions se terminant à 22h00

    • !remind 122 : rappelle l’action d’ID 122

  • Commande !refill  
    async refill.callback(ctx, motif, *, cible=None)

    Recharger un/des pouvoirs rechargeables (COMMANDE BOT / MJ)

    Paramètres

    • motif – "weekends", "forgeron", "rebouteux" ou "divin" (forcer le refill car les MJs tout-puissants l’ont décidé)

    • cible – "all" ou le nom d’un joueur

  • Commande !cparti  
    async cparti.callback(ctx)

    Lance le jeu (COMMANDE MJ)

    • Programme les votes condamnés quotidiens (avec chaînage) 10h-18h

    • Programme un vote maire 10h-18h

    • Programme les actions au lancement du jeu (choix de mentor…) et permanentes (forgeron)… à 19h

    • Crée les « actions de vote », sans quoi !open plante

    À utiliser le jour du lancement après 10h (lance les premières actions le soir et les votes le lendemain)

  • Commande !cfini  
    async cfini.callback(ctx)

    ✨ Clôture le jeu (COMMANDE MJ)

    Supprime toutes les tâches planifiées, ce qui stoppe de fait le jeu.

.sync

lg-rez / features / Synchronisation GSheets

Récupération et application des données des GSheets : modifications décidées via le Tableau de bord et rôles

class lgrez.features.sync.TDBModif(id, col, val, row, column)[source]

Modification flag sur le Tableau de bord, à appliquer.

id

ID Discord du joueur concerné.

Type

int

col

Colonne de Joueur à modifier.

Type

str

val

Nouvelle valeur.

Type

Any

row

Numéro de la ligne (0 = ligne 1).

Type

int

column

Numéro de la colonne (0 = colonne A).

Type

int

Sous-classe de gsheets.Modif.

lgrez.features.sync.transtype(value, cst)[source]

Utilitaire : caste une donnée brute d’un GSheet selon sa colonne.

Paramètres

Types pris en charge dans le cas d’une colonne :

Dans le cas d’une table ou d’une relation many-to-one vers une table, value est interprété comme la clé primaire de la table / de la table liée. Les valeurs interprétées None ne sont pas acceptées, même dans le cas d’une relation avec contrainte One-to-many faite nullable.

Renvoie

L’objet Python correspondant au type de la colonne / table liée (str, int, bool, datetime.time, enum.Enum, bdd.base.TableBase) ou None

Lève

  • ValueError – la conversion n’est pas possible (ou value est évaluée None et la colonne n’est pas nullable)

  • TypeError – type de colonne non pris en charge.

async lgrez.features.sync.get_sync()[source]

Récupère les modifications en attente sur le TDB.

Charge les données du Tableau de bord (variable d’environment LGREZ_TDB_SHEET_ID), compare les informations qui y figurent avec celles de la base de données (bdd.Joueur).

Supprime les joueurs en base absents du Tableau de bord, lève une erreur dans le cas inverse, n’applique aucune autre modification.

Renvoie

La liste des modifications à apporter

Type renvoyé

list[.TDBModif]

Note

Fonction asynchrone depuis la version 2.2.2.

async lgrez.features.sync.validate_sync(modifs)[source]

Valide des modificatons sur le Tableau de bord (case plus en rouge).

Paramètres

modifs (list[.TDBModif]) – liste des modifications à apporter.

Modifie sur le Tableau de bord (variable d’environment LGREZ_TDB_SHEET_ID) et applique les modifications contenues dans modifs.

Note

Fonction asynchrone depuis la version 2.2.2.

async lgrez.features.sync.modif_joueur(joueur_id, modifs, silent=False)[source]

Attribue les modifications demandées au joueur

Paramètres

  • joueur_id (int) – id Discord du joueur concerné.

  • modifs (list[.TDBModif]) – liste des modifications à apporter.

  • silent (bool) – si True, ne notifie pas le joueur des modifications.

Renvoie

La liste des modifications appliquées et le changelog textuel associé (pour log global).

Type renvoyé

(list[.TDBModif], str)

Lève

ValueError – pas de joueur d’ID joueur_id en base

Pour chaque modification dans modifs, applique les conséquences adéquates (rôles, nouvelles actions, tâches planifiées…) et informe le joueur si silent vaut False.

async lgrez.features.sync.process_mort(joueur: lgrez.bdd.model_joueurs.Joueur) → None[source]

Applique les conséquences de la mort d’un joueur.

  • Ouverture des actions à la mort (chasseur…)

  • Archivage des boudoirs devenus inutiles.

Paramètres

joueur (.bdd.Joueur) – le joueur qui vient de mourir.

class lgrez.features.sync.Sync(*args, **kwargs)[source]

Commandes de synchronisation des GSheets vers la BDD et les joueurs

Commandes définies dans ce cog :

  • Commande !sync  
    async sync.callback(ctx, silent=False)

    Récupère et applique les modifs du Tableau de bord (COMMANDE MJ)

    Paramètres

    silent – si spécifié (quelque soit sa valeur), les joueurs ne sont pas notifiés des modifications.

    Cette commande va récupérer les modifications en attente sur le Tableau de bord (lignes en rouge), modifer la BDD, et appliquer les modificatons dans Discord le cas échéant : renommage des utilisateurs, modification des rôles…

  • Commande !fillroles  
    async fillroles.callback(ctx)

    Remplit les tables et #roles depuis le GSheet ad hoc (COMMANDE MJ)

    • Remplit les tables bdd.Camp, bdd.Role, bdd.BaseAction et bdd.BaseCiblage avec les informations du Google Sheets « Rôles et actions » (variable d’environnement LGREZ_ROLES_SHEET_ID) ;

    • Vide le chan #roles puis le remplit avec les descriptifs de chaque rôle et camp.

    Utile à chaque début de saison / changement dans les rôles/actions. Met à jour les entrées déjà en base, créé les nouvelles, supprime celles obsolètes.

.taches

lg-rez / features / Tâches planifiées

Planification, liste, annulation, exécution de tâches planifiées

class lgrez.features.taches.GestionTaches(*args, **kwargs)[source]

Commandes de planification, exécution, annulation de tâches

Commandes définies dans ce cog :

  • Commande !taches  
    async taches.callback(ctx)

    Liste les tâches en attente (COMMANDE MJ)

    Affiche les commandes en attente d’exécution (dans la table bdd.Tache) et le timestamp d’exécution associé. Lorsque la tâche est liée à une action, affiche le nom de l’action et du joueur concerné.

  • Commande !planif (alias !doat) 
    async planif.callback(ctx, quand, *, commande)

    Planifie une tâche au moment voulu (COMMANDE MJ)

    Paramètres

    • quand – format [<J>/<M>[/<AAAA>]-]<H>:<M>[:<S>], avec <J>, <M>, <AAAA>, <H> et <M> des entiers et <S> un entier/flottant optionnel. La date est optionnelle (défaut : date du jour). Si elle est précisée, elle doit être séparée de l’heure par un tiret et l’année peut être omise ;

    • commande – commande à exécuter (commençant par un !). La commande sera exécutée PAR UN WEBHOOK dans LE CHAN #logs : toutes les commandes qui sont liées au joueur ou réservées au chan privé sont à proscrire (ou doivent a minima être précédées de !doas cible)

    Cette commande repose sur l’architecture en base de données, ce qui garantit l’exécution de la tâche même si le bot plante entre temps.

    Si le bot est down à l’heure d’exécution prévue, la commande sera exécutée dès le bot de retour en ligne.

    Si la date spécifiée est dans le passé, la commande est planifiée pour le lendemain.

    Exemples

    • !planif 18:00 !close maire

    • !planif 13/06-10:00 !open maire

    • !planif 13/06/2020-10:00 !open maire

    • !planif 23:25:12 !close maire

  • Commande !delay (alias !retard, !doin) 
    async delay.callback(ctx, duree, *, commande)

    Exécute une commande après XhYmZs (COMMANDE MJ)

    Paramètres

    • quand – format [<X>h][<Y>m][<Z>s], avec <X> (heures) et <Y> (minutes) des entiers et <Z> (secondes) un entier ou un flottant. Chacune des trois composantes est optionnelle, mais au moins une doit être présente ;

    • commande – commande à exécuter (commençant par un !). La commande sera exécutée PAR UN WEBHOOK dans LE CHAN #logs : toutes les commandes qui sont liées au joueur ou réservées au chan privé sont à proscrire (ou doivent être précédées d’un !doas <cible>).

    Cette commande repose sur l’architecture en base de données, ce qui garantit l’exécution de la commande même si le bot plante entre temps.

    Si le bot est down à l’heure d’exécution prévue, la commande sera exécutée dès le bot de retour en ligne.

    Exemples

    • !delay 2h !close maire

    • !delay 1h30m !doas @moi !vote Yacine Oussar

  • Commande !cancel  
    async cancel.callback(ctx, *ids)

    Annule une ou plusieurs tâche(s) planifiée(s) (COMMANDE MJ)

    Paramètres

    *ids – IDs des tâches à annuler, séparées par des espaces.

    Utiliser !taches pour voir la liste des IDs.

.voter_agir

lg-rez / features / Tâches planifiées

Planification, liste, annulation, exécution de tâches planifiées

async lgrez.features.voter_agir.export_vote(vote, utilisation)[source]

Enregistre un vote/les actions résolues dans le GSheet ad hoc.

Écrit dans le GSheet LGREZ_DATA_SHEET_ID. Peut être écrasé pour une autre implémentation.

Paramètres

  • vote (.bdd.Vote) – le vote concerné, ou None pour une action.

  • utilisation (.bdd.Utilisation) – l’utilisation qui vient d’être effectuée. Doit être remplie (bdd.Utilisation.is_filled).

Lève

RuntimeError – si la variable d’environnement LGREZ_DATA_SHEET_ID n’est pas définie.

Note

Fonction asynchrone depuis la version 2.2.2.

async lgrez.features.voter_agir.get_cible(ctx, action, base_ciblage, first=None)[source]

Demande une cible à l’utilisateur.

Paramètres

  • ctx (Context) – le contexte de commande.

  • action – (.bdd.Action): action pour laquelle on cherche une cible.

  • base_ciblage (.bdd.BaseCiblage) – ciblage à demander.

  • first (str) – proposition initale du joueur (passée comme argument d’une commande).

Renvoie

La cible sélectionnée, selon le type de ciblage.

Type renvoyé

Union[.bdd.Joueur, .bdd.Role, .bdd.Camp, bool, str]

Réalise les interactions adéquates en fonction du type du base_ciblage, vérifie le changement de cible le cas échéant.

class lgrez.features.voter_agir.VoterAgir(*args, **kwargs)[source]

Commandes de vote et d’action de rôle

Commandes définies dans ce cog :

  • Commande !vote  
    async vote.callback(ctx, *, cible=None)

    Vote pour le condamné du jour

    Paramètres

    cible – nom du joueur contre qui tu veux diriger ton vote.

    Cette commande n’est utilisable que lorsqu’un vote pour le condamné est en cours, pour les joueurs ayant le droit de voter.

    Le bot t’enverra un message à l’ouverture de chaque vote.

    La commande peut être utilisée autant que voulu pour changer de cible tant que le vote est en cours.

  • Commande !votemaire  
    async votemaire.callback(ctx, *, cible=None)

    Vote pour le nouveau maire

    Paramètres

    cible – nom du joueur pour lequel tu souhaites voter.

    Cette commande n’est utilisable que lorsqu’une élection pour le maire est en cours, pour les joueurs ayant le droit de voter.

    Le bot t’enverra un message à l’ouverture de chaque vote.

    La commande peut être utilisée autant que voulu pour changer de cible tant que le vote est en cours.

  • Commande !voteloups  
    async voteloups.callback(ctx, *, cible=None)

    Vote pour la victime de l’attaque des loups

    Paramètres

    cible – nom du joueur que tu souhaites éliminer.

    Cette commande n’est utilisable que lorsqu’une vote pour la victime du soir est en cours, pour les joueurs concernés.

    Le bot t’enverra un message à l’ouverture de chaque vote.

    La commande peut être utilisée autant que voulu pour changer de cible tant que le vote est en cours.

  • Commande !action  
    async action.callback(ctx, *, decision=None)

    Utilise l’action de ton rôle / une des actions associées

    Paramètres

    decision –

    ce que tu souhaites faire.

    Dans le cas où tu as plusieurs actions disponibles, ce paramètre n’est pas pris en compte pour éviter toute ambiguïté.

    Cette commande n’est utilisable que si tu as au moins une action ouverte. Action = pouvoir associé à ton rôle, mais aussi pouvoirs ponctuels (Lame Vorpale, Chat d’argent…) Le bot t’enverra un message à l’ouverture de chaque action.

    La commande peut être utilisée autant que voulu pour changer d’action tant que la fenêtre d’action est en cours, SAUF pour certaines actions (dites « instantanées ») ayant une conséquence immédiate (Barbier, Licorne…). Le bot mettra dans ce cas un message d’avertissement.