async def infos(self, 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...)
"""
member = ctx.author
joueur = Joueur.from_member(member)
r = ""
r += f"Ton rôle actuel : {tools.bold(joueur.role.nom_complet)}\n"
r += tools.ital(f"({tools.code(f'!roles {joueur.role.slug}')} "
"pour tout savoir sur ce rôle)")
if joueur.actions_actives:
r += "\n\nActions :"
r += tools.code_bloc("\n".join((
f" - {action.base.slug.ljust(20)} "
+ (f"Cooldown : {action.cooldown}" if action.cooldown
else action.base.temporalite).ljust(22)
+ (f" {action.charges} charge(s)"
+ (" pour cette semaine"
if (action.refill and "weekends" in action.refill)
else "")
if isinstance(action.charges, int) else "Illimitée")
) for action in joueur.actions_actives))
# Vraiment désolé pour cette immondice j'ai la flemme
else:
r += "\n\nAucune action disponible."
await ctx.send(
f"{r}\n{tools.code('!menu')} pour voir les votes et "
f"actions en cours, {tools.code('@MJ')} en cas de problème"
)
async def voteloups(self, ctx, *, cible=None):
"""Vote pour la victime de l'attaque des loups
Args:
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.
"""
joueur = Joueur.from_member(ctx.author)
try:
vaction = joueur.action_vote(Vote.loups)
except RuntimeError:
await ctx.send("Minute papillon, le jeu n'est pas encore lancé !")
return
# Vérification vote en cours
if not joueur.votant_loups:
await ctx.send("Tu n'as pas le droit de participer à ce vote.")
return
if not vaction.is_open:
await ctx.send("Pas de vote pour le nouveau maire en cours !")
return
util = vaction.derniere_utilisation
# Choix de la cible
pseudo_bc = _BaseCiblageForVote(
"Qui veux-tu manger ? (vote actuel : "
f"{tools.bold(util.cible.nom if util.cible else 'aucun')})")
cible = await get_cible(ctx, vaction, pseudo_bc, cible)
if not vaction.is_open:
# On revérifie, si ça a fermé entre temps !!
await ctx.send("Le vote pour la victime des loups a "
"fermé entre temps, pas de chance !")
return
# Modification en base
if util.ciblages: # ancien ciblage
Ciblage.delete(*util.ciblages)
Ciblage(utilisation=util, joueur=cible).add()
util.ts_decision = datetime.datetime.now()
util.etat = UtilEtat.remplie
util.update()
async with ctx.typing():
# Écriture dans sheet Données brutes
export_vote(Vote.loups, util)
await ctx.send(
f"Vote contre {tools.bold(cible.nom)} bien pris en compte.")
def _mention_repl(mtch):
"""Remplace @(Prénom Nom) par la mention du joueur, si possible"""
nearest = Joueur.find_nearest(mtch.group(1), col=Joueur.nom, sensi=0.8)
if nearest:
joueur = nearest[0][0]
try:
return joueur.member.mention
except ValueError:
pass
return mtch.group(1)
async def create(self, ctx, *, nom=None):
"""Crée un nouveau boudoir dont tu es gérant"""
member = ctx.author
joueur = Joueur.from_member(member)
if not nom:
await ctx.send("Comment veux-tu nommer ton boudoir ?\n" +
tools.ital("(`stop` pour annuler)"))
mess = await tools.wait_for_message_here(ctx)
nom = mess.content
if len(nom) > 32:
await ctx.send("Le nom des boudoirs est limité à 32 caractères.")
return
await ctx.send("Création du boudoir...")
async with ctx.typing():
now = datetime.datetime.now()
categ = tools.channel(config.boudoirs_category_name)
if len(categ.channels) >= 50:
# Limitation Discord : 50 channels par catégorie
ok = False
N = 2
while not ok:
nom_nouv_cat = f"{config.boudoirs_category_name} {N}"
categ_new = tools.channel(nom_nouv_cat,
must_be_found=False)
if not categ_new:
categ = await categ.clone(name=nom_nouv_cat)
ok = True
elif len(categ_new.channels) < 50:
# Catégorie N pas pleine
categ = categ_new
ok = True
N += 1
chan = await config.guild.create_text_channel(
nom,
topic=f"Boudoir crée le {now:%d/%m à %H:%M}. "
f"Gérant(e) : {joueur.nom}",
category=categ,
)
boudoir = Boudoir(chan_id=chan.id, nom=nom, ts_created=now)
boudoir.add()
await boudoir.add_joueur(joueur, gerant=True)
await chan.send(
f"{member.mention}, voici ton boudoir ! "
"Tu peux maintenant y inviter des gens avec la commande "
"`!boudoir invite`.")
await ctx.send(f"Ton boudoir a bien été créé : {chan.mention} !")
await tools.log(f"Boudoir {chan.mention} créé par {joueur.nom}.")
async def candid(self, ctx):
"""Candidate à l'élection du nouveau maire.
Cette commande n'est utilisable que lorsqu'un vote pour le
nouveau maire est en cours.
"""
auteur = ctx.author
joueur = Joueur.from_member(auteur)
try:
vaction = joueur.action_vote(Vote.maire)
except RuntimeError:
await ctx.send("Minute papillon, le jeu n'est pas encore lancé !")
return
if not vaction.is_open:
await ctx.send("Pas de vote pour le nouveau maire en cours !")
return
if CandidHaro.query.filter_by(joueur=joueur,
type=CandidHaroType.candidature).all():
await ctx.send(
"Hola collègue, tout doux, tu t'es déjà présenté(e) !")
return
await tools.send_blocs(ctx, "Quel est ton programme politique ?")
motif = await tools.wait_for_message_here(ctx)
emb = discord.Embed(title=(f"**{config.Emoji.maire} {joueur.nom} "
"candidate à la Mairie !**"),
description=("Voici son programme politique :\n" +
tools.bold(motif.content)),
color=0xf1c40f)
emb.set_author(name=f"{joueur.nom} vous a compris !")
emb.set_thumbnail(url=config.Emoji.maire.url)
emb.set_footer(text=(f"Utilise !votemaire {auteur.display_name} "
"pour voter pour cette personne."))
mess = await ctx.send("C'est tout bon ?", embed=emb)
if await tools.yes_no(mess):
ch = CandidHaro(joueur=joueur, type=CandidHaroType.candidature)
config.session.add(ch)
config.session.commit()
await config.Channel.haros.send("Here comes a new challenger !",
embed=emb)
await config.Channel.debats.send(
f"{auteur.mention} se présente à la Mairie ! "
"Vous en pensez quoi vous ?\n"
f"(détails sur {config.Channel.haros.mention})")
await ctx.send(
f"Allez, c'est parti ! ({config.Channel.haros.mention})")
else:
await ctx.send("Mission aborted.")
async def menu(self, ctx):
"""Affiche des informations et boutons sur les votes / actions en cours
Le menu a une place beaucoup moins importante ici que sur
Messenger, vu que tout est accessible par commandes.
"""
member = ctx.author
joueur = Joueur.from_member(member)
reacts = []
r = "––– MENU –––\n\n"
try:
vaction = joueur.action_vote(Vote.cond)
except RuntimeError:
await ctx.send("Minute papillon, le jeu n'est pas encore lancé !")
return
if vaction.is_open:
r += (f" - {config.Emoji.bucher} Vote pour le bûcher en cours – "
f"vote actuel : {tools.code(vaction.decision)}\n")
reacts.append(config.Emoji.bucher)
vaction = joueur.action_vote(Vote.maire)
if vaction.is_open:
r += (f" - {config.Emoji.maire} Vote pour le maire en cours – "
f"vote actuel : {tools.code(vaction.decision)}\n")
reacts.append(config.Emoji.maire)
vaction = joueur.action_vote(Vote.loups)
if vaction.is_open:
r += (f" - {config.Emoji.lune} Vote des loups en cours – "
f"vote actuel : {tools.code(vaction.decision)}\n")
reacts.append(config.Emoji.lune)
if not reacts:
r += "Aucun vote en cours.\n"
actions = [ac for ac in joueur.actions_actives if ac.is_open]
if actions:
for action in actions:
r += (f" - {config.Emoji.action} Action en cours : "
f"{tools.code(action.base.slug)} (id {action.id}) – "
f"décision : {tools.code(action.decision)}\n")
reacts.append(config.Emoji.action)
else:
r += "Aucune action en cours.\n"
message = await ctx.send(
r + f"\n{tools.code('!infos')} pour voir ton rôle et tes "
f"actions, {tools.code('@MJ')} en cas de problème"
)
for react in reacts:
await message.add_reaction(react)
async def invite(self, ctx, *, cible):
"""Invite un joueur à rejoindre ce boudoir"""
boudoir = Boudoir.from_channel(ctx.channel)
gerant = Joueur.from_member(ctx.author)
if boudoir.gerant != gerant:
await ctx.reply("Seul le gérant du boudoir peut y inviter "
"de nouvelles personnes.")
return
joueur = await tools.boucle_query_joueur(
ctx, cible=cible, message="Qui souhaites-tu inviter ?")
if joueur in boudoir.joueurs:
await ctx.send(f"{joueur.nom} est déjà dans ce boudoir !")
return
mess = await ctx.send(f"Invitation envoyée à {joueur.nom}.")
asyncio.create_task(_invite(joueur, boudoir, mess))
async def action(self, ctx, *, decision=None):
"""Utilise l'action de ton rôle / une des actions associées
Args:
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.
"""
joueur = Joueur.from_member(ctx.author)
# Vérification rôle actif
if not joueur.role_actif:
await ctx.send(
"Tu ne peux pas utiliser tes pouvoirs pour le moment !")
return
# Détermine la/les actions en cours pour le joueur
actions = [ac for ac in joueur.actions_actives if ac.is_open]
if not actions:
await ctx.send("Aucune action en cours pour toi.")
return
elif (N := len(actions)) > 1:
decision = None
# Évite de lancer une décision en blind
# si le joueur a plusieurs actions
txt = "Tu as plusieurs actions actuellement ouvertes :\n"
for i in range(N):
txt += (f" {tools.emoji_chiffre(i+1)} - "
f"{tools.code(actions[i].base.slug)}\n")
message = await ctx.send(txt + "\nPour laquelle veux-tu agir ?")
i = await tools.choice(message, N)
action = actions[i - 1]
async def expulse(self, ctx, *, cible):
"""Expulse un membre de ce boudoir"""
boudoir = Boudoir.from_channel(ctx.channel)
gerant = Joueur.from_member(ctx.author)
if boudoir.gerant != gerant:
await ctx.reply("Seul le gérant du boudoir peut en expulser "
"des membres.")
return
joueur = await tools.boucle_query_joueur(
ctx, cible=cible, message="Qui souhaites-tu expulser ?")
if joueur not in boudoir.joueurs:
await ctx.send(f"{joueur.nom} n'est pas membre du boudoir !")
return
await boudoir.remove_joueur(joueur)
await joueur.private_chan.send(f"Tu as été expulsé(e) du boudoir "
f"« {boudoir.nom} ».")
await ctx.send(f"{joueur.nom} a bien été expulsé de ce boudoir.")
async def leave(self, ctx):
"""Quitte ce boudoir"""
joueur = Joueur.from_member(ctx.author)
boudoir = Boudoir.from_channel(ctx.channel)
if boudoir.gerant == joueur:
await ctx.send(
"Tu ne peux pas quitter un boudoir que tu gères. "
"Utilise `!boudoir transfer` pour passer les droits "
"de gestion ou `!boudoir delete` pour le supprimer.")
return
mess = await ctx.reply("Veux-tu vraiment quitter ce boudoir ? Tu ne "
"pourras pas y retourner sans invitation.")
if not await tools.yes_no(mess):
await ctx.send("Mission aborted.")
return
await boudoir.remove_joueur(joueur)
await ctx.send(tools.ital(f"{joueur.nom} a quitté ce boudoir."))
async def list(self, ctx):
"""Liste les boudoirs dans lesquels tu es"""
joueur = Joueur.from_member(ctx.author)
bouderies = joueur.bouderies
if not bouderies:
await ctx.reply(
"Tu n'es dans aucun boudoir pour le moment.\n"
f"{tools.code('!boudoir create')} pour en créer un.")
return
rep = "Tu es dans les boudoirs suivants :"
for bouderie in bouderies:
rep += f"\n - {bouderie.boudoir.chan.mention}"
if bouderie.gerant:
rep += " (gérant)"
rep += "\n\nUtilise `!boudoir leave` dans un boudoir pour le quitter."
await ctx.send(rep)
async def rename(self, ctx, *, nom):
"""Renomme ce boudoir"""
boudoir = Boudoir.from_channel(ctx.channel)
gerant = Joueur.from_member(ctx.author)
if boudoir.gerant != gerant:
await ctx.reply("Seul le gérant du boudoir peut le renommer.")
return
if not nom:
await ctx.send("Comment veux-tu renommer ce boudoir ?\n" +
tools.ital("(`stop` pour annuler)"))
mess = await tools.wait_for_message_here(ctx)
nom = mess.content
if len(nom) > 32:
await ctx.send("Le nom des boudoirs est limité à 32 caractères.")
return
boudoir.nom = nom
boudoir.update()
await boudoir.chan.edit(name=nom)
await ctx.send("Boudoir renommé avec succès.")
async def main(member):
"""Routine d'inscription complète d'un joueur.
Args:
member (:class:`~discord.Member`): joueur à inscrire.
Crée et paramètre le salon privé du joueur, lui pose des questions
et l'inscrit en base.
Personalisation : voir :obj:`.config.demande_chambre`,
:obj:`.config.chambre_mj`, :func:`.config.additional_inscription_step`
et :obj:`.config.debut_saison`.
Commande appellée à l'arrivée sur le serveur, utiliser
:meth:`\!co <.bot.Special.Special.co.callback>` pour trigger cette
commande depuis Discord.
"""
try:
joueur = Joueur.from_member(member)
except ValueError: # Joueur pas encore inscrit en base
pass
else: # Joueur dans la bdd = déjà inscrit
chan = joueur.private_chan
await chan.set_permissions(member,
read_messages=True,
send_messages=True)
await chan.send(f"Saloww ! {member.mention} tu es déjà inscrit, "
"viens un peu ici !")
return
if (chan := tools.get(config.guild.text_channels, topic=str(member.id))):
# Inscription en cours (topic du chan = ID du membre)
await chan.set_permissions(member,
read_messages=True,
send_messages=True)
await chan.send(
f"Tu as déjà un channel à ton nom, {member.mention}, par ici !")
async def transfer(self, ctx, cible=None):
"""Transfère les droits de gestion de ce boudoir"""
boudoir = Boudoir.from_channel(ctx.channel)
gerant = Joueur.from_member(ctx.author)
if boudoir.gerant != gerant:
await ctx.reply("Seul le gérant du boudoir peut en transférer "
"les droits de gestion.")
return
joueur = await tools.boucle_query_joueur(
ctx,
cible=cible,
message=("À qui souhaites-tu confier "
"la gestion de ce boudoir ?"))
if joueur not in boudoir.joueurs:
await ctx.send(f"{joueur.nom} n'est pas membre de ce boudoir !")
return
mess = await ctx.reply(
"Veux-tu vraiment transférer les droits de ce boudoir ? "
"Tu ne pourras pas les récupérer par toi-même.")
if not await tools.yes_no(mess):
await ctx.send("Mission aborted.")
return
bd_gerant = next(bd for bd in boudoir.bouderies if bd.joueur == gerant)
bd_nouv = next(bd for bd in boudoir.bouderies if bd.joueur == joueur)
bd_gerant.gerant = False
bd_nouv.gerant = True
bd_nouv.ts_promu = datetime.datetime.now()
Bouderie.update()
await boudoir.chan.edit(
topic=f"Boudoir crée le {boudoir.ts_created:%d/%m à %H:%M}. "
f"Gérant(e) : {joueur.nom}")
await ctx.send(f"Boudoir transféré à {joueur.nom}.")
async def delete(self, ctx):
"""Supprime ce boudoir"""
boudoir = Boudoir.from_channel(ctx.channel)
gerant = Joueur.from_member(ctx.author)
if boudoir.gerant != gerant:
await ctx.reply("Seul le gérant du boudoir peut le supprimer.")
return
mess = await ctx.reply("Veux-tu vraiment supprimer ce boudoir ? "
"Cette action est irréversible.")
if not await tools.yes_no(mess):
await ctx.send("Mission aborted.")
return
await ctx.send("Suppression...")
for joueur in boudoir.joueurs:
await boudoir.remove_joueur(joueur)
await joueur.private_chan.send(
f"Le boudoir « {boudoir.nom } » a été supprimé.")
await boudoir.chan.edit(name=f"\N{CROSS MARK} {boudoir.nom}")
await ctx.send(
tools.ital("[Tous les joueurs ont été exclus de ce boudoir ; "
"le channel reste présent pour archive.]"))
async def haro(self, ctx, *, cible=None):
"""Lance publiquement un haro contre un autre joueur.
Args:
cible: nom du joueur à accuser
Cette commande n'est utilisable que lorsqu'un vote pour le
condamné est en cours.
"""
auteur = ctx.author
joueur = Joueur.from_member(auteur)
try:
vaction = joueur.action_vote(Vote.cond)
except RuntimeError:
await ctx.send("Minute papillon, le jeu n'est pas encore lancé !")
return
if not vaction.is_open:
await ctx.send("Pas de vote pour le condamné du jour en cours !")
return
cible = await tools.boucle_query_joueur(
ctx, cible, "Contre qui souhaites-tu déverser ta haine ?")
if cible.statut == Statut.mort:
await ctx.send("Nan mais oh, tu crois qu'il a pas assez "
"souffert en mourant lui ?")
return
elif cible.statut == Statut.immortel:
await ctx.send("Comment oses-tu t'en prendre à ceux qui te sont "
f"supérieurs ? {config.Role.mj.mention}, regardez "
"un peu ce qu'il se passe là...")
return
await tools.send_blocs(
ctx, "Et quelle est la raison de cette haine, d'ailleurs ?")
motif = await tools.wait_for_message_here(ctx)
emb = discord.Embed(title=(f"**{config.Emoji.ha}{config.Emoji.ro} "
f"contre {cible.nom} !**"),
description=f"**« {motif.content} »\n**",
color=0xff0000)
emb.set_author(name=f"{joueur.nom} en a gros 😡😡")
emb.set_thumbnail(url=config.Emoji.bucher.url)
emb.set_footer(
text=f"Utilise !vote {cible.nom} pour voter contre cette personne."
)
mess = await ctx.send("C'est tout bon ?", embed=emb)
if await tools.yes_no(mess):
if not CandidHaro.query.filter_by(joueur=cible,
type=CandidHaroType.haro).all():
# Inscription haroté
config.session.add(
CandidHaro(joueur=cible, type=CandidHaroType.haro))
if not CandidHaro.query.filter_by(joueur=joueur,
type=CandidHaroType.haro).all():
# Inscription haroteur
config.session.add(
CandidHaro(joueur=joueur, type=CandidHaroType.haro))
config.session.commit()
await config.Channel.haros.send(
f"(Psst, {cible.member.mention} :3)", embed=emb)
await config.Channel.debats.send(
f"{config.Emoji.ha}{config.Emoji.ro} de {auteur.mention} "
f"sur {cible.member.mention} ! Vous en pensez quoi vous ? "
f"(détails sur {config.Channel.haros.mention})")
await ctx.send(
f"Allez, c'est parti ! ({config.Channel.haros.mention})")
else:
await ctx.send("Mission aborted.")
async def votemaire(self, ctx, *, cible=None):
"""Vote pour le nouveau maire
Args:
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.
"""
joueur = Joueur.from_member(ctx.author)
try:
vaction = joueur.action_vote(Vote.maire)
except RuntimeError:
await ctx.send("Minute papillon, le jeu n'est pas encore lancé !")
return
# Vérification vote en cours
if not joueur.votant_village:
await ctx.send("Tu n'as pas le droit de participer à ce vote.")
return
if not vaction.is_open:
await ctx.send("Pas de vote pour le nouveau maire en cours !")
return
util = vaction.derniere_utilisation
# Choix de la cible
candids = CandidHaro.query.filter_by(
type=CandidHaroType.candidature).all()
candidats = [candid.joueur.nom for candid in candids]
pseudo_bc = _BaseCiblageForVote(
"Pour qui veux-tu voter ? (vote actuel : "
f"{tools.bold(util.cible.nom if util.cible else 'aucun')})\n"
f"(candidats : {', '.join(candidats) or 'aucun :pensive:'})")
cible = await get_cible(ctx, vaction, pseudo_bc, cible)
# Test si la cible s'est présentée
cible_ds_candid = CandidHaro.query.filter_by(
joueur=cible, type=CandidHaroType.candidature).all()
if not cible_ds_candid:
mess = await ctx.send(
f"{cible.nom} ne s'est pas (encore) présenté(e) ! "
"Si c'est toujours le cas à la fin de l'élection, ton vote "
"sera compté comme blanc... \n Veux-tu continuer ?")
if not await tools.yes_no(mess):
await ctx.send("Compris, mission aborted.")
return
if not vaction.is_open:
# On revérifie, si ça a fermé entre temps !!
await ctx.send("Le vote pour le nouveau maire a fermé "
"entre temps, pas de chance !")
return
# Modification en base
if util.ciblages: # ancien ciblage
Ciblage.delete(*util.ciblages)
Ciblage(utilisation=util, joueur=cible).add()
util.ts_decision = datetime.datetime.now()
util.etat = UtilEtat.remplie
util.update()
async with ctx.typing():
# Écriture dans sheet Données brutes
export_vote(Vote.maire, util)
await ctx.send(
f"Vote pour {tools.bold(cible.nom)} bien pris en compte.\n" +
tools.ital("Tu peux modifier ton vote autant "
"que nécessaire avant sa fermeture."))
if config.demande_chambre:
await chan.send(
f"{nom}, en chambre {chambre}... Je t'inscris en base !")
else:
await chan.send(f"{nom}... Je t'inscris en base !")
# Indicateur d'écriture pour informer le joueur que le bot fait des trucs
async with chan.typing():
# Enregistrement en base
joueur = Joueur(
discord_id=member.id,
chan_id_=chan.id,
nom=member.display_name,
chambre=chambre,
statut=Statut.vivant,
role=Role.default(),
camp=Camp.default(),
votant_village=True,
votant_loups=False,
role_actif=False,
)
joueur.add()
# Ajout sur le TDB
register_on_tdb(joueur)
# Grant accès aux channels joueurs et information
await member.add_roles(config.Role.joueur_en_vie)
await chan.edit(topic="Ta conversation privée avec le bot, "