easterobot 1.3.2__tar.gz → 1.5.1__tar.gz

{easterobot-1.3.2 → easterobot-1.5.1}/.gitignore

@@ -113,3 +113,4 @@ config.yml
 logs
 *.db
 /bot
+/skyjo

{easterobot-1.3.2 → easterobot-1.5.1}/.vscode/settings.json

@@ -88,6 +88,7 @@
     "pyarg",
     "pypi",
     "pyproject",
+    "Skyjo",
     "sourcelink",
     "sphinxcontrib",
     "todos",

{easterobot-1.3.2 → easterobot-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easterobot
-Version: 1.3.2
+Version: 1.5.1
 Summary: Discord bot for Easter.
 Project-URL: Homepage, https://github.com/Dashstrom/easterobot
 Project-URL: Repository, https://github.com/Dashstrom/easterobot

{easterobot-1.3.2 → easterobot-1.5.1}/conftest.py

@@ -8,15 +8,16 @@ import pytest
 import pytest_asyncio
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
 
-from easterobot import __author__
 from easterobot.bot import Easterobot
 from easterobot.config import MConfig
 
 
 @pytest.fixture(autouse=True)
-def _add_author(doctest_namespace: dict[str, Any]) -> None:
+def _add_bot(doctest_namespace: dict[str, Any], bot: Easterobot) -> None:
     """Update doctest namespace."""
-    doctest_namespace["author"] = __author__
+    doctest_namespace["bot"] = bot
+    doctest_namespace["engine"] = bot.engine
+    doctest_namespace["config"] = bot.config
 
 
 @pytest.fixture

{easterobot-1.3.2 → easterobot-1.5.1}/easterobot/bot.py

@@ -1,5 +1,6 @@
 """Main program."""
 
+import asyncio
 import logging
 import pathlib
 import shutil
@@ -17,6 +18,7 @@ import discord.app_commands
 import discord.ext.commands
 from alembic.command import upgrade
 from sqlalchemy.ext.asyncio import create_async_engine
+from typing_extensions import override
 
 if TYPE_CHECKING:
     from easterobot.games.game import GameCog
@@ -44,6 +46,7 @@ class Easterobot(discord.ext.commands.Bot):
     owner: discord.User
     game: "GameCog"
     hunt: "HuntCog"
+    init_finished: asyncio.Event
 
     def __init__(self, config: MConfig) -> None:
         """Initialise Easterbot."""
@@ -167,6 +170,12 @@ class Easterobot(discord.ext.commands.Bot):
         """Run the bot with the given token."""
         self.run(token=self.config.verified_token())
 
+    @override
+    async def start(self, token: str, *, reconnect: bool = True) -> None:
+        """Add event for starting."""
+        self.init_finished = asyncio.Event()
+        await super().start(token=token, reconnect=reconnect)
+
     async def on_ready(self) -> None:
         """Handle ready event, can be trigger many time if disconnected."""
         # Sync bot commands
@@ -196,6 +205,7 @@ class Easterobot(discord.ext.commands.Bot):
             self.user,
             getattr(self.user, "id", "unknown"),
         )
+        self.init_finished.set()
 
     async def _load_emojis(self) -> None:
         emojis = {
@@ -203,6 +213,8 @@ class Easterobot(discord.ext.commands.Bot):
             for emoji in await self.fetch_application_emojis()
         }
         emotes_path = (self.config.resources / "emotes").resolve()
+        # TODO(dashstrom): remove old one !
+        # TODO(dashstrom): cache emoji synced !
         self.app_emojis = {}
         for emote in emotes_path.glob("**/*"):
             if not emote.is_file():
@@ -221,4 +233,5 @@ class Easterobot(discord.ext.commands.Bot):
                 self.app_emojis[name] = emoji
             else:
                 logger.info("Load emoji %s", name)
-                self.app_emojis[name] = emojis[name]
+                emoji = emojis[name]
+                self.app_emojis[name] = emoji

easterobot-1.5.1/easterobot/casino/__init__.py

@@ -0,0 +1 @@
+"""Module for casino events."""

easterobot-1.5.1/easterobot/casino/roulette.py

@@ -0,0 +1,269 @@
+"""Module to play roulette."""
+
+import asyncio
+from asyncio import sleep
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Union
+
+import discord
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.bot import Easterobot
+from easterobot.config import RAND, agree
+from easterobot.locker import EggLocker
+from easterobot.utils import in_seconds
+
+if TYPE_CHECKING:
+    from easterobot.models import Egg
+
+
+@dataclass(frozen=True, order=True)
+class Play:
+    name: str
+    emoji: str
+    bet: int
+    payout: int
+    slots: frozenset[int]
+
+    @property
+    def label(self) -> str:
+        """Returns the label of the bet."""
+        return agree(
+            f"{self.bet} œuf sur {self.name}",
+            f"{self.bet} œufs sur {self.name}",
+            self.bet,
+        )
+
+    @property
+    def probability(self) -> float:
+        """Returns the winning probability."""
+        return len(self.slots) / 37
+
+    @property
+    def eggs(self) -> float:
+        """Returns the number of eggs won."""
+        return self.payout * self.bet
+
+
+# fmt: off
+plays = [
+    Play("noir", "⚫", 1, 2, frozenset({2, 4, 6, 8, 10, 11, 13, 15, 17, 20,
+                                       22, 24, 26, 28, 29, 31, 33, 35})),
+    Play("rouge", "🔴", 1, 2, frozenset({1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21,
+                                        23, 25, 27, 30, 32, 34, 36})),
+    Play("impaire", "1️⃣", 3, 2, frozenset(range(1, 37, 2))),
+    Play("pair", "2️⃣", 3, 2, frozenset(range(2, 37, 2))),
+    Play("manque", "⬅️", 5, 2, frozenset(range(1, 19))),
+    Play("passe", "➡️", 5, 2, frozenset(range(19, 37))),
+    Play("zero", "0️⃣", 1, 36, frozenset({0})),
+]
+play_mapper = {p.label: p for p in plays}
+# fmt: on
+
+
+@dataclass
+class RouletteResult:
+    draw: int
+    winners: dict[discord.Member, Play]
+    losers: dict[discord.Member, Play]
+
+    @property
+    def label(self) -> str:
+        """Returns the name(s) of the winning bet(s)."""
+        winning_plays = sorted(set(self.winners.values()))
+        if len(winning_plays) == 1:
+            return winning_plays[0].name
+        if winning_plays:
+            last = winning_plays[-1]
+            return (
+                ", ".join(p.name for p in winning_plays[:-1])
+                + " et "
+                + last.name
+            )
+        return "rien au numéro"
+
+
+class Roulette:
+    def __init__(self, locker: EggLocker) -> None:
+        """Initialize an empty bet tracker."""
+        self.bets: dict[discord.Member, Play] = {}
+        self.eggs: dict[discord.Member, list[Egg]] = {}
+        self.locker = locker
+
+    async def bet(self, member: discord.Member, play: Play) -> None:
+        """Register a bet from a member."""
+        if member in self.eggs:
+            raise ValueError
+        async with self.locker.transaction():
+            eggs = await self.locker.get(member, play.bet)
+        self.eggs[member] = eggs
+        self.bets[member] = play
+
+    async def sample(self) -> "RouletteResult":
+        """Draw a number and determine winners/losers."""
+        ball = RAND.randint(0, 36)
+        losers = {}
+        winners = {}
+        futures = []
+        async with self.locker.transaction():
+            for member, play in self.bets.items():
+                eggs = self.eggs[member]
+                if ball in play.slots:
+                    added_eggs = [
+                        egg.duplicate()
+                        for egg in eggs
+                        for _ in range(play.payout - 1)
+                    ]
+                    self.locker.update(added_eggs)
+                    winners[member] = play
+                else:
+                    futures.append(self.locker.delete(eggs))
+                    losers[member] = play
+            await asyncio.gather(*futures)
+        return RouletteResult(
+            draw=ball,
+            losers=losers,
+            winners=winners,
+        )
+
+
+class BetView(discord.ui.View):
+    def __init__(self, embed: discord.Embed, roulette: Roulette) -> None:
+        """Create an interactive view for placing bets."""
+        super().__init__()
+        self.embed = embed
+        self.roulette = roulette
+        self.already_interact: set[discord.Member] = set()
+
+    def disable(self) -> None:
+        """Disable the selection UI."""
+        self.select_bet.disabled = True  # type: ignore[attr-defined]
+        self.stop()
+
+    @discord.ui.select(
+        placeholder="Parier",
+        options=[
+            discord.SelectOption(
+                label=f"Parier {play.label}",
+                emoji=play.emoji,
+                value=play.label,
+                description=(
+                    f"{play.probability:.2%} de repartir avec {play.eggs} œufs"
+                ),
+            )
+            for play in plays
+        ],
+    )
+    async def select_bet(
+        self,
+        interaction: discord.Interaction["Easterobot"],
+        select: discord.ui.Select["BetView"],
+    ) -> None:
+        """Handle the player's bet selection."""
+        user = interaction.user
+        if not isinstance(user, discord.Member) or interaction.message is None:
+            await interaction.response.defer()
+            return
+        if user in self.already_interact:
+            await interaction.response.send_message(
+                "Vous avez déjà choisi votre pari !",
+                ephemeral=True,
+            )
+            return
+        self.already_interact.add(user)
+        bet = play_mapper[select.values[0]]
+        await self.roulette.bet(user, bet)
+        embeds = interaction.message.embeds
+        assert self.embed.description is not None  # noqa: S101
+        self.embed.description += (
+            f"\n> {interaction.user.mention} a parié {bet.label} {bet.emoji}"
+        )
+        await interaction.response.edit_message(embeds=[embeds[0], self.embed])
+
+
+class RouletteManager:
+    def __init__(self, bot: Easterobot) -> None:
+        """Main manager for roulette game logic."""
+        self.bot = bot
+
+    async def run(
+        self,
+        source: Union[discord.Message, discord.TextChannel],
+    ) -> None:
+        """Run a full roulette session."""
+        guild = source.guild
+        if guild is None:
+            raise ValueError
+        async with (
+            AsyncSession(
+                self.bot.engine,
+                expire_on_commit=False,
+            ) as session,
+            EggLocker(session, guild.id) as locker,
+        ):
+            timeout = self.bot.config.casino.roulette.duration + 40
+            roulette = Roulette(locker)
+            embed = discord.Embed(
+                description=(
+                    "# Roulette lapinique"
+                    "\nLe Casino vous ouvre exceptionnellement ses portes. "
+                    "Devant vous se trouve un élégant croupier lapin. "
+                    "Il vous fixe droit dans les yeux "
+                    "et prononce de simples mots en langue lapinique. "
+                    "Magiquement, vous semblez comprendre : 'Faites vos jeux'."
+                    "\n\n-# Faites attention, "
+                    f"il annoncera sans doute la fin {in_seconds(timeout)}."
+                ),
+                color=0x00FF00,
+            )
+            text = discord.Embed(
+                description="# Annonces du croupier\n> Faites vos jeux",
+                color=0x00FF00,
+            )
+            assert text.description is not None  # noqa: S101
+            embed.set_image(
+                url="https://i.pinimg.com/originals/32/37/bf/3237bf1e172a6089e0c437ffd3b28010.gif"
+            )
+            view = BetView(text, roulette)
+            if isinstance(source, discord.Message):
+                message = source
+                await message.edit(
+                    embeds=[embed, text],
+                    content="",
+                    view=view,
+                )
+            else:
+                message = await source.send(
+                    embeds=[embed, text],
+                    view=view,
+                )
+            await sleep(timeout)
+            text.description += "\n> Les jeux sont faits"
+            await message.edit(embeds=[embed, text])
+            await sleep(20)
+            view.disable()
+            text.description += "\n> Rien ne va plus"
+            await message.edit(view=view, embeds=[embed, text])
+            await sleep(20)
+            result = await roulette.sample()
+            text.description += "\n> La bille s'arrête "
+            number = f"{result.draw:2d}".replace(" ", "\xa0")
+            text.description += f"sur le ||{number}||"
+            text.description += f"\n> Le lapin annonce ||{result.label}||"
+            await message.edit(view=None, embeds=[embed, text])
+
+        messages = []
+        for member, bet in result.winners.items():
+            egg_text = agree("œuf", "œufs", bet.bet)
+            messages.append(
+                f"{member.mention} repart avec {bet.eggs} {egg_text}"
+            )
+        for member, bet in result.losers.items():
+            egg_text = agree("œuf", "œufs", bet.bet)
+            messages.append(f"{member.mention} perd {bet.bet} {egg_text}")
+        if messages:
+            await sleep(5)
+            await message.reply(  # type: ignore[call-overload]
+                content="\n".join(messages),
+                view=None,
+            )

{easterobot-1.3.2 → easterobot-1.5.1}/easterobot/commands/__init__.py

@@ -14,6 +14,7 @@ from easterobot.commands.game import (
 from easterobot.commands.help import help_command
 from easterobot.commands.info import info_command
 from easterobot.commands.reset import reset_command
+from easterobot.commands.roulette import roulette_command
 from easterobot.commands.search import search_command
 from easterobot.commands.top import top_command
 
@@ -28,6 +29,7 @@ __all__ = [
     "info_command",
     "reset_command",
     "rockpaperscissor_command",
+    "roulette_command",
     "search_command",
     "tictactoe_command",
     "top_command",

easterobot-1.5.1/easterobot/commands/game.py

@@ -0,0 +1,200 @@
+"""Module for disable hunt."""
+
+import asyncio
+from typing import Optional
+
+import discord
+from discord import app_commands
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.config import RAND
+from easterobot.games.connect4 import Connect4
+from easterobot.games.game import Game
+from easterobot.games.rock_paper_scissor import RockPaperScissor
+from easterobot.games.skyjo import Skyjo
+from easterobot.games.tic_tac_toe import TicTacToe
+from easterobot.hunts.rank import Ranking
+from easterobot.locker import EggLocker, EggLockerError
+
+from .base import Context, controlled_command, egg_command_group
+
+
+async def random_members(
+    ctx: Context,
+    bet: int,
+) -> list[discord.Member]:
+    """Random members."""
+    # If no member choose a random play in the guild with enough egg
+    if bet == 0:
+        members = [
+            m for m in ctx.guild.members if m.id != ctx.user.id and not m.bot
+        ]
+    else:
+        # TODO(dashstrom): can chose member with locked eggs
+        async with AsyncSession(ctx.client.engine) as session:
+            ranking = await Ranking.from_guild(
+                session,
+                ctx.guild_id,
+                unlock_only=True,
+            )
+        hunters = ranking.over(bet)
+        mapper_member = {m.id: m for m in ctx.guild.members}
+        members = [
+            mapper_member[h.member_id]
+            for h in hunters
+            if h.member_id != ctx.user.id and h.member_id in mapper_member
+        ]
+    RAND.shuffle(members)
+    return members
+
+
+async def game_dual(  # noqa: D103
+    ctx: Context,
+    bet: int,
+    cls: type[Game],
+    *members: discord.Member,
+) -> None:
+    min_player = cls.minimum_player()
+    max_player = cls.maximum_player()
+    if min_player > len(members) + 1:
+        await ctx.response.send_message(
+            f"Vous devez être au minimum {min_player} joueurs",
+            ephemeral=True,
+        )
+        return
+    if max_player < len(members) + 1:
+        await ctx.response.send_message(
+            f"Vous devez être au maximum {min_player} joueurs",
+            ephemeral=True,
+        )
+        return
+
+    # Check if user has enough eggs for ask
+    async with AsyncSession(
+        ctx.client.engine,
+        expire_on_commit=False,
+    ) as session:
+        locker = EggLocker(session, ctx.guild.id)
+        try:
+            await locker.pre_check(
+                {ctx.user: bet, **{m: bet for m in members}}
+            )
+        except EggLockerError as err:
+            await ctx.response.send_message(str(err), ephemeral=True)
+            return
+
+        msg = await ctx.client.game.ask_dual(ctx, members, bet=bet)
+        if msg:
+            # Unlock all egg at end
+            async with locker:
+                # Lock the egg of player
+                try:
+                    async with locker.transaction():
+                        all_eggs = await asyncio.gather(
+                            locker.get(ctx.user, bet),
+                            *[locker.get(m, bet) for m in members],
+                        )
+                except EggLockerError as err:
+                    await msg.reply(str(err), delete_after=30)
+                    return
+
+                players = [ctx.user, *members]
+                RAND.shuffle(players)
+                game = cls(ctx.client, msg, *players)
+                await ctx.client.game.run(game)
+                winner = await game.wait_winner()
+                if winner:
+                    for eggs in all_eggs:
+                        for egg in eggs:
+                            egg.user_id = winner.member.id
+
+                # Send change
+                await session.commit()
+
+
+@egg_command_group.command(
+    name="connect4",
+    description="Lancer une partie de puissance 4",
+)
+@controlled_command(cooldown=True, channel_permissions={"send_messages": True})
+async def connect4_command(
+    ctx: Context,
+    member: Optional[discord.Member] = None,
+    bet: app_commands.Range[int, 0] = 0,
+) -> None:
+    """Run a Connect4."""
+    members = (
+        (await random_members(ctx, bet))[:1] if member is None else [member]
+    )
+    await game_dual(ctx, bet, Connect4, *members)
+
+
+@egg_command_group.command(
+    name="tictactoe",
+    description="Lancer une partie de morpion",
+)
+@controlled_command(cooldown=True, channel_permissions={"send_messages": True})
+async def tictactoe_command(
+    ctx: Context,
+    member: Optional[discord.Member] = None,
+    bet: app_commands.Range[int, 0] = 0,
+) -> None:
+    """Run a tictactoe."""
+    members = (
+        (await random_members(ctx, bet))[:1] if member is None else [member]
+    )
+    await game_dual(ctx, bet, TicTacToe, *members)
+
+
+@egg_command_group.command(
+    name="rockpaperscissor",
+    description="Lancer une partie de pierre papier ciseaux",
+)
+@controlled_command(cooldown=True, channel_permissions={"send_messages": True})
+async def rockpaperscissor_command(
+    ctx: Context,
+    member: Optional[discord.Member] = None,
+    bet: app_commands.Range[int, 0] = 0,
+) -> None:
+    """Run a rockpaperscissor."""
+    members = (
+        (await random_members(ctx, bet))[:1] if member is None else [member]
+    )
+    await game_dual(ctx, bet, RockPaperScissor, *members)
+
+
+@egg_command_group.command(
+    name="skyjo",
+    description="Lancer une partie de Skyjo",
+)
+@controlled_command(cooldown=True, channel_permissions={"send_messages": True})
+async def skyjo_command(  # noqa: PLR0913
+    ctx: Context,
+    member1: Optional[discord.Member] = None,
+    member2: Optional[discord.Member] = None,
+    member3: Optional[discord.Member] = None,
+    member4: Optional[discord.Member] = None,
+    member5: Optional[discord.Member] = None,
+    member6: Optional[discord.Member] = None,
+    member7: Optional[discord.Member] = None,
+    bet: app_commands.Range[int, 0] = 0,
+) -> None:
+    """Run a skyjo."""
+    members = [
+        m
+        for m in (
+            member1,
+            member2,
+            member3,
+            member4,
+            member5,
+            member6,
+            member7,
+        )
+        if m
+    ]
+    if not members:
+        player_count = RAND.randint(1, 8)
+        rand_members = await random_members(ctx, bet)
+        members = rand_members[:player_count]
+    await game_dual(ctx, bet, Skyjo, *members)

{easterobot-1.3.2 → easterobot-1.5.1}/easterobot/commands/reset.py

@@ -1,7 +1,6 @@
 """Module for reset command."""
 
 import asyncio
-from typing import cast
 
 import discord
 from sqlalchemy import and_, delete
@@ -9,6 +8,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from easterobot.hunts.hunt import embed
 from easterobot.models import Cooldown, Egg, Hunt
+from easterobot.utils import in_seconds
 
 from .base import Context, Interaction, controlled_command, egg_command_group
 
@@ -95,21 +95,18 @@ async def reset_command(ctx: Context) -> None:
 
     cancel.callback = cancel_callback  # type: ignore[assignment]
     confirm.callback = confirm_callback  # type: ignore[assignment]
-    message = cast(
-        discord.WebhookMessage,
-        await ctx.followup.send(
-            embed=embed(
-                title="Demande de réinitialisation",
-                description=(
-                    "L'ensemble des salons, œufs "
-                    "et temps d'attentes vont être réinitialisatiés."
-                ),
-                # TODO(dashstrom): add timer
-                footer="Vous avez 30 secondes pour confirmer",
+    message = await ctx.followup.send(
+        embed=embed(
+            title="Demande de réinitialisation",
+            description=(
+                "L'ensemble des salons, œufs "
+                "et temps d'attentes vont être réinitialisatiés."
+                f"\n\n-# Vous devez confirmer {in_seconds(30)}"
             ),
-            ephemeral=True,
-            view=view,
         ),
+        ephemeral=True,
+        view=view,
+        wait=True,
     )
     await asyncio.sleep(30.0)
     if not done:

easterobot-1.5.1/easterobot/commands/roulette.py

@@ -0,0 +1,34 @@
+"""Command basket."""
+
+import discord
+
+from easterobot.casino.roulette import RouletteManager
+from easterobot.commands.base import (
+    Context,
+    controlled_command,
+    egg_command_group,
+)
+
+
+@egg_command_group.command(
+    name="roulette",
+    description="Lancer la roulette",
+)
+@controlled_command(cooldown=True, manage_channels=True)
+async def roulette_command(
+    ctx: Context,
+) -> None:
+    """Show current user basket."""
+    # Delay the response
+    if not isinstance(ctx.channel, discord.TextChannel):
+        await ctx.response.send_message(
+            "Salon invalide !",
+            ephemeral=True,
+        )
+        return
+    await ctx.response.send_message(
+        "Lancement de la roulette !",
+        ephemeral=True,
+    )
+    roulette = RouletteManager(ctx.client)
+    await roulette.run(ctx.channel)