easterobot 1.1.2__py3-none-any.whl → 1.3.2__py3-none-any.whl

easterobot/games/game.py

@@ -1,8 +1,6 @@
 """Base class for game."""
 
 import asyncio
-import contextlib
-import datetime
 import logging
 from collections.abc import Coroutine
 from dataclasses import dataclass
@@ -12,11 +10,11 @@ from uuid import uuid4
 import discord
 from discord.ext import commands
 from discord.message import convert_emoji_reaction
-from discord.utils import format_dt
 
 from easterobot.bot import Easterobot
 from easterobot.commands.base import Context, Interaction, InteractionChannel
 from easterobot.config import RAND
+from easterobot.utils import in_seconds
 
 logger = logging.getLogger(__name__)
 AsyncCallback = Callable[[], Coroutine[Any, Any, None]]
@@ -59,8 +57,11 @@ class Game:
         self._cleanup: Optional[AsyncCallback] = None
         self._completion: Optional[AsyncCallback] = None
         self._end_event = asyncio.Event()
+
+        # timeout
         self._reset_countdown_event = asyncio.Event()
         self._timeout_task: Optional[asyncio.Task[None]] = None
+        self._timeout_lock: asyncio.Lock = asyncio.Lock()
 
     async def set_completion(self, callback: AsyncCallback) -> None:
         """Get the current state for a player."""
@@ -94,20 +95,33 @@ class Game:
             await self._completion()
         self._end_event.set()
 
-    def start_timer(self, seconds: float) -> str:
+    async def start_timer(self, seconds: float) -> str:
         """Start the timer for turn."""
-        now = datetime.datetime.now() + datetime.timedelta(seconds=seconds)  # noqa: DTZ005
-        dt = format_dt(now, style="R")
-        self._timeout_task = asyncio.create_task(self._timeout_worker(seconds))
-        return dt
+        async with self._timeout_lock:
+            logger.info(
+                "Start timer of %s seconds for %s",
+                seconds,
+                self,
+            )
+            self._timeout_task = asyncio.create_task(
+                self._timeout_worker(seconds)
+            )
+            return in_seconds(seconds)
 
     async def stop_timer(self) -> None:
         """Stop the timer and wait it end."""
-        if self._timeout_task:
-            self._reset_countdown_event.set()
-            await self._timeout_task
-            self._timeout_task = None
-            self._reset_countdown_event = asyncio.Event()
+        async with self._timeout_lock:
+            logger.info("Stop timer for %s", self)
+            if (
+                self._timeout_task
+                and not self._timeout_task.done()
+                and not self._timeout_task.cancelled()
+            ):
+                self._reset_countdown_event.set()
+                await self._timeout_task
+                self._timeout_task = None
+                self._reset_countdown_event = asyncio.Event()
+            logger.info("Timer stopped for %s", self)
 
     async def _timeout_worker(self, seconds: float) -> None:
         """Timeout action."""
@@ -117,13 +131,14 @@ class Game:
         except asyncio.TimeoutError:
             if not event.is_set():
                 async with self.lock:
+                    logger.info("Timeout for %s", self)
                     await self.on_timeout()
 
     def __repr__(self) -> str:
         """Get game representation."""
         return (
             f"<{self.__class__.__qualname__} "
-            f"id={self.id!r} message={self.message!r} "
+            f"id={str(self.id)!r} message={self.message.id!r} "
             f"terminate={self.terminate!r} winner={self.winner!r}"
             ">"
         )
@@ -152,13 +167,12 @@ class GameCog(commands.Cog):
         from easterobot.games.tic_tac_toe import TicTacToe
 
         cls = RAND.choice([Connect4, TicTacToe, RockPaperScissor])
-        now = datetime.datetime.now() + datetime.timedelta(seconds=63)  # noqa: DTZ005
-        dt = format_dt(now, style="R")
         msg = await channel.send(
-            f"{user1.mention} et {user2.mention} vont s'affronter {dt} ...",
+            f"{user1.mention} et {user2.mention} "
+            f"vont s'affronter {in_seconds(121)} ...",
             reference=reference,
         )
-        await asyncio.sleep(63)
+        await asyncio.sleep(121)
         game: Game = cls(user1, user2, msg)  # type: ignore[operator]
         await self.run(game)
         return await game.wait_winner()
@@ -172,7 +186,13 @@ class GameCog(commands.Cog):
                 del self._games[message_id]
             else:
                 logger.warning("Missing game: %s", game)
-            await game.message.clear_reactions()
+            try:
+                await game.message.clear_reactions()
+            except discord.Forbidden:
+                logger.warning(
+                    "Missing permission for remove all reactions from %s",
+                    message_id,
+                )
 
         self._games[message_id] = game
         game._cleanup = _cleanup  # noqa: SLF001
@@ -186,8 +206,8 @@ class GameCog(commands.Cog):
         bet: int,
     ) -> Optional[discord.Message]:
         """Send basic message for initialization."""
-        future: asyncio.Future[bool] = asyncio.Future()
-        accept = False
+        future: asyncio.Future[Optional[bool]] = asyncio.Future()
+        accept: Optional[bool] = None
 
         view = discord.ui.View()
         yes_btn: Button = discord.ui.Button(
@@ -198,44 +218,74 @@ class GameCog(commands.Cog):
         )
 
         async def yes(interaction: Interaction) -> Any:
-            if interaction.user.id == member.id:
-                future.set_result(True)
             await interaction.response.defer()
+            if not future.done() and interaction.user.id == member.id:
+                future.set_result(True)
 
         async def no(interaction: Interaction) -> Any:
-            if interaction.user.id == member.id:
-                future.set_result(False)
             await interaction.response.defer()
+            if not future.done():
+                if interaction.user.id == member.id:
+                    future.set_result(False)
+                if interaction.user.id == ctx.user.id:
+                    future.set_result(None)
 
         yes_btn.callback = yes  # type: ignore[method-assign,assignment]
         no_btn.callback = no  # type: ignore[method-assign,assignment]
         view.add_item(yes_btn)
         view.add_item(no_btn)
-        now = datetime.datetime.now() + datetime.timedelta(seconds=180)  # noqa: DTZ005
-        dt = format_dt(now, style="R")
+        seconds = 600
         result = await ctx.response.send_message(
             f"{member.mention}, {ctx.user.mention} "
             f"vous demande en duel pour `{bet}` œufs ⚔️"
-            f"\nVous devez repondre {dt} !",
+            f"\nVous devez repondre {in_seconds(seconds)} !",
             view=view,
         )
         message = result.resource
         if not isinstance(message, discord.Message):
             error_message = f"Invalid kind of message: {message!r}"
             raise TypeError(error_message)
-        with contextlib.suppress(asyncio.TimeoutError):
-            accept = await asyncio.wait_for(future, timeout=180)
+        try:
+            accept = await asyncio.wait_for(future, timeout=seconds)
+        except asyncio.TimeoutError:
+            await message.edit(
+                content=(
+                    f"{ctx.user.mention}, "
+                    f"{member.mention} n'a pas accepté le duel 🛡️"
+                    f"\n-# Ce message disparaîtra {in_seconds(30)}"
+                ),
+                delete_after=30,
+                view=None,
+            )
+            return None
+        if accept is None:
+            await message.edit(
+                content=(
+                    f"{member.mention}, {ctx.user.mention} a annulé le duel 🛡️"
+                    f"\n-# Ce message disparaîtra {in_seconds(30)}"
+                ),
+                delete_after=30,
+                view=None,
+            )
+            return None
         if not accept:
             await message.edit(
                 content=(
-                    f"{member.mention}, {ctx.user.mention} a refusé le duel 🛡️"
+                    f"{ctx.user.mention}, {member.mention} a refusé le duel 🛡️"
+                    f"\n-# Ce message disparaîtra {in_seconds(30)}"
                 ),
+                delete_after=30,
                 view=None,
             )
             return None
         if not isinstance(result.resource, discord.Message):
             error_message = f"Invalid kind of message: {result.resource!r}"
             raise TypeError(error_message)
+        await result.resource.reply(
+            f"{ctx.user.mention}, {member.mention} a accepté le duel ⚔️"
+            f"\n-# Ce message disparaîtra {in_seconds(30)}",
+            delete_after=30,
+        )
         return result.resource
 
     @commands.Cog.listener()
@@ -249,14 +299,35 @@ class GameCog(commands.Cog):
             return
         if payload.message_id in self._games:
             # Use connection for faster remove
-            emoji = convert_emoji_reaction(payload.emoji)
             game = self._games[payload.message_id]
             await asyncio.gather(
-                self.bot._connection.http.remove_reaction(  # noqa: SLF001
+                self.silent_reaction_remove(
                     payload.channel_id,
                     payload.message_id,
-                    emoji,
+                    payload.emoji,
                     payload.user_id,
                 ),
                 game.on_reaction(payload.user_id, payload.emoji),
             )
+
+    async def silent_reaction_remove(
+        self,
+        channel_id: int,
+        message_id: int,
+        emoji: discord.PartialEmoji,
+        user_id: int,
+    ) -> None:
+        """Handle reaction."""
+        try:
+            reaction = convert_emoji_reaction(emoji)
+            await self.bot._connection.http.remove_reaction(  # noqa: SLF001
+                channel_id,
+                message_id,
+                reaction,
+                user_id,
+            )
+        except discord.Forbidden:
+            logger.warning(
+                "Missing permission for remove reaction from %s",
+                message_id,
+            )

easterobot/games/rock_paper_scissor.py

@@ -1,5 +1,6 @@
 """TicTacToe."""
 
+import asyncio
 from functools import partial
 from typing import Optional
 
@@ -44,7 +45,7 @@ class RockPaperScissor(Game):
         embed.set_author(
             name="Partie en cours", icon_url=self.bot.app_emojis["wait"].url
         )
-        self.view = discord.ui.View()
+        self.view = discord.ui.View(timeout=1800)
         rock_btn: Button = discord.ui.Button(
             style=discord.ButtonStyle.gray,
             emoji=ROCK,
@@ -76,7 +77,10 @@ class RockPaperScissor(Game):
 
             # One button has been pressed
             if update:
-                await interaction.response.defer()
+                await asyncio.gather(
+                    self.stop_timer(),
+                    interaction.response.defer(),
+                )
                 await self.update()
             else:
                 await interaction.response.send_message(
@@ -93,12 +97,18 @@ class RockPaperScissor(Game):
         self.view.add_item(scissor_btn)
         await self.update()
 
-    async def update(self) -> None:  # noqa: PLR0912, PLR0915
+    async def update(self) -> None:  # noqa: C901, PLR0912, PLR0915
         """Update the current display."""
         embed = discord.Embed(color=0xF2BC32)
         # Both player have played
         header = "Partie en cours"
-        if self.play1 is None:
+        if self.play1 is None and self.play2 is None:
+            icon_url = self.bot.app_emojis["wait"].url
+            info = (
+                f"En attente de {self.player1.mention} "
+                f"et {self.player2.mention} ..."
+            )
+        elif self.play1 is None:
             icon_url = self.player1.display_avatar.url
             info = f"En attente de {self.player1.mention} ..."
         elif self.play2 is None:
@@ -120,10 +130,10 @@ class RockPaperScissor(Game):
         for play1, play2 in self.history:
             i1 = EMOJIS.index(play1)
             i2 = EMOJIS.index(play2)
-            if i1 == (i2 + 1) % 3:
+            if i1 == (i2 - 1) % 3:
                 pt1 += 1
                 text = self.player1.mention
-            elif i1 == (i2 - 1) % 3:
+            elif i1 == (i2 + 1) % 3:
                 pt2 += 1
                 text = self.player2.mention
             else:
@@ -166,10 +176,14 @@ class RockPaperScissor(Game):
             if not self.timeout:
                 await self.set_winner(final_winner)
         else:
-            dt = self.start_timer(32)
+            dt = await self.start_timer(31)
             embed.description += f"\n\n{info}\n\nFin du tour {dt}"
         embed.set_author(name=header, icon_url=icon_url)
-        await self.message.edit(embed=embed, view=self.view, content="")
+        await self.message.edit(
+            embed=embed,
+            view=self.view,
+            content=(f"-# {self.player1.mention} {self.player2.mention}"),
+        )
 
     def compute_winner(
         self, play1: str, play2: str

easterobot/games/tic_tac_toe.py

@@ -1,13 +1,12 @@
 """TicTacToe."""
 
-import datetime
 from typing import Optional
 
 import discord
-from discord.utils import format_dt
 from typing_extensions import override
 
 from easterobot.games.game import Game, Player
+from easterobot.utils import in_seconds
 
 EMOJIS_MAPPER = {
     "1️⃣": 0,
@@ -44,7 +43,7 @@ class TicTacToe(Game):
         await self.update()
         for emoji in EMOJIS:
             await self.message.add_reaction(emoji)
-        self.start_timer(60)
+        await self.start_timer(31)
 
     async def update(self) -> None:
         """Update the message."""
@@ -85,8 +84,7 @@ class TicTacToe(Game):
         content += footer
 
         if not self.terminate:
-            now = datetime.datetime.now() + datetime.timedelta(seconds=32)  # noqa: DTZ005
-            content += f"\n\nFin du tour {format_dt(now, style='R')}"
+            content += f"\n\nFin du tour {in_seconds(31)}"
 
         embed = discord.Embed(description=content, color=self.color(user))
         embed.set_author(
@@ -99,7 +97,10 @@ class TicTacToe(Game):
         )
         self.message = await self.message.edit(
             embed=embed,
-            content="",
+            content=(
+                f"-# {self.player1.member.mention} "
+                f"{self.player2.member.mention}"
+            ),
             view=None,
         )
 
@@ -142,7 +143,7 @@ class TicTacToe(Game):
                 await self.set_winner(None)
             else:
                 self.turn += 1
-                self.start_timer(30)
+                await self.start_timer(31)
             await self.update()
 
     @override