easterobot 1.3.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

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/casino/__init__.py

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

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/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/commands/game.py

@@ -1,152 +1,115 @@
 """Module for disable hunt."""
 
 import asyncio
-from typing import Callable, Optional
+from typing import Optional
 
 import discord
 from discord import app_commands
-from sqlalchemy import and_, func, not_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from easterobot.config import RAND
-from easterobot.games.connect import Connect4
+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.models import Egg
+from easterobot.locker import EggLocker, EggLockerError
 
 from .base import Context, controlled_command, egg_command_group
 
-lock = asyncio.Lock()
-
-
-async def get_unlocked_eggs(
-    session: AsyncSession, member: discord.Member, counter: int
-) -> list[Egg]:
-    """Get the count of unlocked eggs."""
-    return list(
-        (
-            await session.scalars(
-                select(Egg)
-                .where(
-                    and_(
-                        Egg.guild_id == member.guild.id,
-                        Egg.user_id == member.id,
-                        not_(Egg.lock),
-                    )
-                )
-                .order_by(func.random())  # Randomize
-                .limit(counter)
-            )
-        ).all()
-    )
-
 
-async def game_dual(  # noqa: C901, D103, PLR0912
+async def random_members(
     ctx: Context,
-    member: Optional[discord.Member],
     bet: int,
-    cls: Callable[[discord.Member, discord.Member, discord.Message], Game],
-) -> None:
+) -> list[discord.Member]:
+    """Random members."""
     # If no member choose a random play in the guild with enough egg
-    if member is None:
-        if bet == 0:
-            members = [m for m in ctx.guild.members if m.id != ctx.user.id]
-        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)
-            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
-            ]
-        if members:
-            member = RAND.choice(members)
-        else:
-            await ctx.response.send_message(
-                "Aucun utilisateur trouvé !",
-                ephemeral=True,
+    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,
             )
-            return
-
-    # Validate user
-    if (member.bot or member == ctx.user) and not ctx.client.is_super_admin(
-        member
-    ):
+        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(
-            "L'utilisateur n'est pas valide !",
+            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) as session:
-        e1, e2 = await asyncio.gather(
-            get_unlocked_eggs(session, ctx.user, bet),
-            get_unlocked_eggs(session, member, bet),
-        )
-        if len(e1) < bet:
-            await ctx.response.send_message(
-                "Vous n'avez pas assez d'oeufs",
-                ephemeral=True,
-            )
-            return
-        if len(e2) < bet:
-            await ctx.response.send_message(
-                f"{member.mention} n'a pas assez d'oeufs",
-                ephemeral=True,
+    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, member, bet=bet)
-    if msg:
-        # Check if user still have enough eggs and lock them
-        async with AsyncSession(ctx.client.engine) as session:
-            async with lock:
-                e1, e2 = await asyncio.gather(
-                    get_unlocked_eggs(session, ctx.user, bet),
-                    get_unlocked_eggs(session, member, bet),
-                )
-                if len(e1) < bet:
-                    await ctx.response.send_message(
-                        "Vous n'avez plus assez d'oeufs",
-                        ephemeral=True,
-                    )
-                    return
-                for e in e1:
-                    e.lock = True
-                if len(e2) < bet:
-                    await ctx.response.send_message(
-                        f"{member.mention} n'a plus assez d'oeufs",
-                        ephemeral=True,
-                    )
+        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
-                for e in e2:
-                    e.lock = True
-                await session.commit()
 
-            # Play the game
-            winner = None
-            try:
-                game = cls(ctx.user, member, msg)
+                players = [ctx.user, *members]
+                RAND.shuffle(players)
+                game = cls(ctx.client, msg, *players)
                 await ctx.client.game.run(game)
                 winner = await game.wait_winner()
-            finally:
-                # Give eggs to the winner or remove previous one
-                async with lock:
-                    for e in e1:
-                        e.lock = False
-                        if winner:
-                            e.user_id = winner.id
-                    for e in e2:
-                        e.lock = False
-                        if winner:
-                            e.user_id = winner.id
-                    await session.commit()
+                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(
@@ -160,7 +123,10 @@ async def connect4_command(
     bet: app_commands.Range[int, 0] = 0,
 ) -> None:
     """Run a Connect4."""
-    await game_dual(ctx, member, bet, 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(
@@ -174,7 +140,10 @@ async def tictactoe_command(
     bet: app_commands.Range[int, 0] = 0,
 ) -> None:
     """Run a tictactoe."""
-    await game_dual(ctx, member, bet, 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(
@@ -188,4 +157,44 @@ async def rockpaperscissor_command(
     bet: app_commands.Range[int, 0] = 0,
 ) -> None:
     """Run a rockpaperscissor."""
-    await game_dual(ctx, member, bet, 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/commands/info.py

@@ -51,9 +51,9 @@ async def info_command(
                 title=f"Informations sur {hunter.display_name}",
                 description=(
                     f"Classement : {hunter_rank.badge}\n"
-                    f"Nombre d'oeufs : `{hunter_rank.eggs}`\n"
+                    f"Nombre d'œufs : `{hunter_rank.eggs}`\n"
                     f"Chance brute : `{member_luck.luck:.0%}`\n"
-                    f"Chance de trouver un oeuf : `{member_luck.discovered:.0%}`\n"
+                    f"Chance de trouver un œuf : `{member_luck.discovered:.0%}`\n"
                     f"Chance de se faire voler : `{member_luck.spotted:.0%}`"
                 ),
             ),