nonebot-plugin-werewolf 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

nonebot_plugin_werewolf/players/can_shoot.py

@@ -1,7 +1,8 @@
-from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import STOP_COMMAND_PROMPT
+from nonebot_plugin_alconna.uniseg import UniMessage
+
+from ..constant import stop_command_prompt
 from ..models import KillReason
 from .player import Player
 
@@ -9,7 +10,7 @@ from .player import Player
 class CanShoot(Player):
     @override
     async def post_kill(self) -> None:
-        if self.kill_info and self.kill_info.reason == KillReason.Poison:
+        if self.kill_info and self.kill_info.reason == KillReason.POISON:
             await self.send("⚠️你昨晚被女巫毒杀，无法使用技能")
             return await super().post_kill()
 
@@ -21,33 +22,32 @@ class CanShoot(Player):
 
         self.game.state.shoot = None
         shoot = await self.shoot()
-
+        msg = UniMessage.text("玩家 ").at(self.user_id).text(" ")
         if shoot is not None:
             self.game.state.shoot = self
-            await self.send(
-                UniMessage.text(f"🔫{self.role_name} ")
-                .at(self.user_id)
-                .text(" 射杀了玩家 ")
-                .at(shoot.user_id)
-            )
-            await shoot.kill(KillReason.Shoot, self)
+            await self.game.send("🔫" + msg.text("射杀了玩家 ").at(shoot.user_id))
+            await shoot.kill(KillReason.SHOOT, self)
             self.selected = shoot
         else:
-            await self.send(f"ℹ️{self.role_name}选择了取消技能")
+            await self.game.send("ℹ️" + msg.text("选择了取消技能"))
+
         return await super().post_kill()
 
     async def shoot(self) -> Player | None:
         players = self.game.players.alive().exclude(self)
         await self.send(
             "💫请选择需要射杀的玩家:\n"
-            + players.show()
-            + "\n\n🔫发送编号选择玩家"
-            + f"\n❌发送 “{STOP_COMMAND_PROMPT}” 取消技能"
+            f"{players.show()}\n\n"
+            "🔫发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 取消技能",
+            stop_btn_label="取消技能",
+            select_players=players,
         )
 
         if selected := await self._select_player(
             players,
             on_stop="ℹ️已取消技能，回合结束",
+            stop_btn_label="取消技能",
         ):
             await self.send(f"🎯选择射杀的玩家: {selected.name}")
 

nonebot_plugin_werewolf/players/civilian.py

@@ -2,6 +2,6 @@ from ..models import Role, RoleGroup
 from .player import Player
 
 
-@Player.register_role(Role.Civilian, RoleGroup.GoodGuy)
+@Player.register_role(Role.CIVILIAN, RoleGroup.GOODGUY)
 class Civilian(Player):
     pass

nonebot_plugin_werewolf/players/guard.py

@@ -1,31 +1,33 @@
-from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import STOP_COMMAND_PROMPT
-from ..models import Role, RoleGroup
+from ..constant import stop_command_prompt
+from ..models import GameState, Role, RoleGroup
 from .player import Player
 
 
-@Player.register_role(Role.Guard, RoleGroup.GoodGuy)
+@Player.register_role(Role.GUARD, RoleGroup.GOODGUY)
 class Guard(Player):
     @override
     async def _check_selected(self, player: Player) -> Player | None:
-        if player is not self.selected:
-            return player
-        await self.send("⚠️守卫不能连续两晚保护同一目标，请重新选择")
-        return None
+        if self.game.state.state == GameState.State.NIGHT and player is self.selected:
+            await self.send("⚠️守卫不能连续两晚保护同一目标，请重新选择")
+            return None
+
+        return player
 
     @override
-    async def interact(self) -> None:
+    async def _interact(self) -> None:
         players = self.game.players.alive()
         await self.send(
-            UniMessage.text("💫请选择需要保护的玩家:\n")
-            .text(players.show())
-            .text("\n\n🛡️发送编号选择玩家")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
+            "💫请选择需要保护的玩家:\n"
+            f"{players.show()}\n\n"
+            "🛡️发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 结束回合",
+            stop_btn_label="结束回合",
+            select_players=players,
         )
 
-        self.selected = await self._select_player(players)
+        self.selected = await self._select_player(players, stop_btn_label="结束回合")
         if self.selected:
             self.game.state.protected.add(self.selected)
             await self.send(f"✅本回合保护的玩家: {self.selected.name}")

nonebot_plugin_werewolf/players/hunter.py

@@ -3,6 +3,6 @@ from .can_shoot import CanShoot
 from .player import Player
 
 
-@Player.register_role(Role.Hunter, RoleGroup.GoodGuy)
+@Player.register_role(Role.HUNTER, RoleGroup.GOODGUY)
 class Hunter(CanShoot, Player):
     pass

nonebot_plugin_werewolf/players/idiot.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+from typing_extensions import override
 
 from nonebot_plugin_alconna.uniseg import UniMessage
-from typing_extensions import override
 
 from ..models import KillReason, Role, RoleGroup
 from .player import Player
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
     from ..player_set import PlayerSet
 
 
-@Player.register_role(Role.Idiot, RoleGroup.GoodGuy)
+@Player.register_role(Role.IDIOT, RoleGroup.GOODGUY)
 class Idiot(Player):
     voted: bool = False
 
@@ -25,7 +25,7 @@ class Idiot(Player):
 
     @override
     async def kill(self, reason: KillReason, *killers: Player) -> bool:
-        if reason == KillReason.Vote and not self.voted:
+        if reason == KillReason.VOTE and not self.voted:
             self.voted = True
             await self.game.send(
                 UniMessage.text("⚙️玩家")

nonebot_plugin_werewolf/players/{joker.py → jester.py}

@@ -1,5 +1,4 @@
 from typing import TYPE_CHECKING
-
 from typing_extensions import override
 
 from ..exception import GameFinished
@@ -7,8 +6,8 @@ from ..models import GameStatus, KillReason, Role, RoleGroup
 from .player import Player
 
 
-@Player.register_role(Role.Joker, RoleGroup.Others)
-class Joker(Player):
+@Player.register_role(Role.JESTER, RoleGroup.OTHERS)
+class Jester(Player):
     @override
     async def notify_role(self) -> None:
         await super().notify_role()
@@ -17,9 +16,9 @@ class Joker(Player):
     @override
     async def kill(self, reason: KillReason, *killers: Player) -> bool:
         await super().kill(reason, *killers)
-        if reason == KillReason.Vote:
+        if reason == KillReason.VOTE:
             if TYPE_CHECKING:
                 assert self.kill_info is not None
             self.game.killed_players.append((self.name, self.kill_info))
-            raise GameFinished(GameStatus.Joker)
+            raise GameFinished(GameStatus.JESTER)
         return True

nonebot_plugin_werewolf/players/player.py

@@ -4,15 +4,23 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, ClassVar, Final, TypeVar, final
 
 import anyio
+import nonebot
 from nonebot.adapters import Bot
-from nonebot.log import logger
 from nonebot.utils import escape_tag
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
 from nonebot_plugin_uninfo import SceneType
 
-from ..constant import STOP_COMMAND, STOP_COMMAND_PROMPT, role_emoji, role_name_conv
+from ..config import GameBehavior
+from ..constant import ROLE_EMOJI, ROLE_NAME_CONV, STOP_COMMAND, stop_command_prompt
 from ..models import KillInfo, KillReason, Role, RoleGroup
-from ..utils import InputStore, check_index, link
+from ..utils import (
+    InputStore,
+    SendHandler,
+    add_players_button,
+    add_stop_button,
+    check_index,
+    link,
+)
 
 if TYPE_CHECKING:
     from ..game import Game
@@ -21,6 +29,19 @@ if TYPE_CHECKING:
 
 _P = TypeVar("_P", bound=type["Player"])
 
+logger = nonebot.logger.opt(colors=True)
+
+
+class _SendHandler(SendHandler[str | None]):
+    def solve_msg(
+        self,
+        msg: UniMessage,
+        stop_btn_label: str | None = None,
+    ) -> UniMessage:
+        if stop_btn_label is not None:
+            msg = add_stop_button(msg, stop_btn_label)
+        return msg
+
 
 class Player:
     __player_class: ClassVar[dict[Role, type["Player"]]] = {}
@@ -45,6 +66,8 @@ class Player:
         self.bot = bot
         self.killed = anyio.Event()
         self._member = None
+        self._send_handler = _SendHandler()
+        self._send_handler.update(self.__user, bot)
 
     @classmethod
     def register_role(cls, role: Role, role_group: RoleGroup, /) -> Callable[[_P], _P]:
@@ -65,9 +88,7 @@ class Player:
         return cls.__player_class[role](bot, game, user_id)
 
     def __repr__(self) -> str:
-        return (
-            f"<Player {self.role_name}: user={self.user_id!r} " f"alive={self.alive}>"
-        )
+        return f"<Player {self.role_name}: user={self.user_id!r} alive={self.alive}>"
 
     @property
     def game(self) -> "Game":
@@ -81,7 +102,7 @@ class Player:
 
     @functools.cached_property
     def role_name(self) -> str:
-        return role_name_conv[self.role]
+        return ROLE_NAME_CONV[self.role]
 
     async def _fetch_member(self) -> None:
         member = await self.game.interface.get_member(
@@ -126,41 +147,75 @@ class Player:
         return name
 
     @final
-    def _log(self, text: str) -> None:
+    def log(self, text: str) -> None:
         text = text.replace("\n", "\\n")
-        logger.opt(colors=True).info(
-            f"{self.game.colored_name} | "
-            f"[<b><m>{self.role_name}</m></b>] "
-            f"{self.colored_name} | {text}",
-        )
+        self.game.log(f"[<b><m>{self.role_name}</m></b>] {self.colored_name} | {text}")
 
     @final
-    async def send(self, message: str | UniMessage) -> Receipt:
+    async def send(
+        self,
+        message: str | UniMessage,
+        *,
+        stop_btn_label: str | None = None,
+        select_players: "PlayerSet | None" = None,
+        skip_handler: bool = False,
+    ) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
 
-        self._log(f"<g>Send</g> | {escape_tag(str(message))}")
-        return await message.send(target=self.__user, bot=self.bot)
+        self.log(f"<g>Send</g> | {escape_tag(str(message))}")
 
-    @final
-    async def receive(self, prompt: str | UniMessage | None = None) -> UniMessage:
-        if prompt:
-            await self.send(prompt)
+        if select_players:
+            message = add_players_button(message, select_players)
+        if skip_handler:
+            return await message.send(self.__user, self.bot)
+        return await self._send_handler.send(message, stop_btn_label)
 
+    @final
+    async def receive(self) -> UniMessage:
         result = await InputStore.fetch(self.user_id)
-        self._log(f"<y>Recv</y> | {escape_tag(str(result))}")
+        self.log(f"<y>Recv</y> | {escape_tag(str(result))}")
         return result
 
     @final
     async def receive_text(self) -> str:
         return (await self.receive()).extract_plain_text()
 
-    async def interact(self) -> None:
+    @property
+    def interact_timeout(self) -> float:
+        return GameBehavior.get().timeout.interact
+
+    async def _before_interact(self) -> None:
         return
 
+    async def _interact(self) -> None:
+        return
+
+    async def _after_interact(self) -> None:
+        return
+
+    async def interact(self) -> None:
+        if not getattr(self._interact, "__override__", False):
+            await self.send("ℹ️请等待其他玩家结束交互...")
+            return
+
+        await self._before_interact()
+
+        timeout = self.interact_timeout
+        await self.send(f"✏️{self.role_name}交互开始，限时 {timeout / 60:.2f} 分钟")
+
+        try:
+            with anyio.fail_after(timeout):
+                await self._interact()
+        except TimeoutError:
+            logger.debug(f"{self.role_name}交互超时 (<y>{timeout}</y>s)")
+            await self.send(f"⚠️{self.role_name}交互超时")
+
+        await self._after_interact()
+
     async def notify_role(self) -> None:
         await self._fetch_member()
-        await self.send(f"⚙️你的身份: {role_emoji[self.role]}{self.role_name}")
+        await self.send(f"⚙️你的身份: {ROLE_EMOJI[self.role]}{self.role_name}")
 
     async def kill(self, reason: KillReason, *killers: "Player") -> bool:
         if self.alive:
@@ -173,13 +228,17 @@ class Player:
 
     async def vote(self, players: "PlayerSet") -> "Player | None":
         await self.send(
-            f"💫请选择需要投票的玩家:\n{players.show()}"
-            f"\n\n🗳️发送编号选择玩家\n❌发送 “{STOP_COMMAND_PROMPT}” 弃票"
-            f"\n\n限时1分钟，超时将视为弃票"
+            f"💫请选择需要投票的玩家:\n"
+            f"{players.show()}\n\n"
+            "🗳️发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 弃票\n\n"
+            "限时1分钟，超时将视为弃票",
+            stop_btn_label="弃票",
+            select_players=players,
         )
 
         try:
-            with anyio.fail_after(60):
+            with anyio.fail_after(GameBehavior.get().timeout.vote):
                 selected = await self._select_player(
                     players,
                     on_stop="⚠️你选择了弃票",
@@ -202,10 +261,11 @@ class Player:
         *,
         on_stop: str | None = None,
         on_index_error: str | None = None,
+        stop_btn_label: str | None = None,
     ) -> "Player | None":
         on_stop = on_stop or "ℹ️你选择了取消，回合结束"
         on_index_error = (
-            on_index_error or f"⚠️输入错误: 请发送玩家编号或 “{STOP_COMMAND_PROMPT}”"
+            on_index_error or f"⚠️输入错误: 请发送玩家编号或 “{stop_command_prompt()}”"
         )
         selected = None
 
@@ -217,7 +277,11 @@ class Player:
                 return None
             index = check_index(text, len(players))
             if index is None:
-                await self.send(on_index_error)
+                await self.send(
+                    on_index_error,
+                    stop_btn_label=stop_btn_label,
+                    select_players=players,
+                )
                 continue
             selected = await self._check_selected(players[index - 1])
 

nonebot_plugin_werewolf/players/prophet.py

@@ -1,23 +1,24 @@
-from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import STOP_COMMAND_PROMPT
+from ..constant import stop_command_prompt
 from ..models import Role, RoleGroup
 from .player import Player
 
 
-@Player.register_role(Role.Prophet, RoleGroup.GoodGuy)
+@Player.register_role(Role.PROPHET, RoleGroup.GOODGUY)
 class Prophet(Player):
     @override
-    async def interact(self) -> None:
+    async def _interact(self) -> None:
         players = self.game.players.alive().exclude(self)
         await self.send(
-            UniMessage.text("💫请选择需要查验身份的玩家:\n")
-            .text(players.show())
-            .text("\n\n🔮发送编号选择玩家")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合(不查验身份)")
+            "💫请选择需要查验身份的玩家:\n"
+            f"{players.show()}\n\n"
+            "🔮发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 结束回合(不查验身份)",
+            stop_btn_label="结束回合",
+            select_players=players,
         )
 
-        if selected := await self._select_player(players):
-            result = "狼人" if selected.role_group == RoleGroup.Werewolf else "好人"
+        if selected := await self._select_player(players, stop_btn_label="结束回合"):
+            result = "狼人" if selected.role_group == RoleGroup.WEREWOLF else "好人"
             await self.send(f"✏️玩家 {selected.name} 的阵营是『{result}』")

nonebot_plugin_werewolf/players/werewolf.py

@@ -1,10 +1,13 @@
+import secrets
 from typing import TYPE_CHECKING
+from typing_extensions import override
 
 import anyio
+import nonebot
 from nonebot_plugin_alconna.uniseg import UniMessage
-from typing_extensions import override
 
-from ..constant import STOP_COMMAND, STOP_COMMAND_PROMPT
+from ..config import GameBehavior
+from ..constant import STOP_COMMAND, stop_command_prompt
 from ..models import Role, RoleGroup
 from ..utils import ObjectStream, check_index
 from .player import Player
@@ -12,24 +15,29 @@ from .player import Player
 if TYPE_CHECKING:
     from ..player_set import PlayerSet
 
+logger = nonebot.logger.opt(colors=True)
+
 
-@Player.register_role(Role.Werewolf, RoleGroup.Werewolf)
+@Player.register_role(Role.WEREWOLF, RoleGroup.WEREWOLF)
 class Werewolf(Player):
+    stream: ObjectStream[str | UniMessage]
+
+    @property
+    @override
+    def interact_timeout(self) -> float:
+        return GameBehavior.get().timeout.werewolf
+
     @override
     async def notify_role(self) -> None:
         await super().notify_role()
-        partners = self.game.players.alive().select(RoleGroup.Werewolf).exclude(self)
+        partners = self.game.players.alive().select(RoleGroup.WEREWOLF).exclude(self)
         if partners:
             await self.send(
                 "🐺你的队友:\n"
                 + "\n".join(f"  {p.role_name}: {p.name}" for p in partners)
             )
 
-    async def _handle_interact(
-        self,
-        players: "PlayerSet",
-        stream: ObjectStream[str | UniMessage],
-    ) -> None:
+    async def _handle_interact(self, players: "PlayerSet") -> None:
         self.selected = None
 
         while True:
@@ -39,35 +47,40 @@ class Werewolf(Player):
             if index is not None:
                 self.selected = players[index - 1]
                 msg = f"当前选择玩家: {self.selected.name}"
-                await self.send(f"🎯{msg}\n发送 “{STOP_COMMAND_PROMPT}” 结束回合")
-                await stream.send(f"📝队友 {self.name} {msg}")
+                await self.send(
+                    f"🎯{msg}\n发送 “{stop_command_prompt()}” 结束回合",
+                    stop_btn_label="结束回合",
+                    select_players=players,
+                )
+                await self.stream.send(f"📝队友 {self.name} {msg}")
             if text == STOP_COMMAND:
                 if self.selected is not None:
                     await self.send("✅你已结束当前回合")
-                    await stream.send(f"📝队友 {self.name} 结束当前回合")
-                    stream.close()
+                    await self.stream.send(f"📝队友 {self.name} 结束当前回合")
+                    self.stream.close()
                     return
-                await self.send("⚠️当前未选择玩家，无法结束回合")
+                await self.send(
+                    "⚠️当前未选择玩家，无法结束回合",
+                    select_players=players,
+                )
             else:
-                await stream.send(UniMessage.text(f"💬队友 {self.name}:\n") + input_msg)
-
-    async def _handle_broadcast(
-        self,
-        partners: "PlayerSet",
-        stream: ObjectStream[str | UniMessage],
-    ) -> None:
-        while not stream.closed:
+                await self.stream.send(
+                    UniMessage.text(f"💬队友 {self.name}:\n") + input_msg
+                )
+
+    async def _handle_broadcast(self, partners: "PlayerSet") -> None:
+        while not self.stream.closed:
             try:
-                message = await stream.recv()
+                message = await self.stream.recv()
             except anyio.EndOfStream:
                 return
 
             await partners.broadcast(message)
 
     @override
-    async def interact(self) -> None:
+    async def _interact(self) -> None:
         players = self.game.players.alive()
-        partners = players.select(RoleGroup.Werewolf).exclude(self)
+        partners = players.select(RoleGroup.WEREWOLF).exclude(self)
 
         msg = UniMessage()
         if partners:
@@ -80,12 +93,31 @@ class Werewolf(Player):
             msg.text("💫请选择今晚的目标:\n")
             .text(players.show())
             .text("\n\n🔪发送编号选择玩家")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
-            .text("\n\n⚠️意见未统一将空刀")
+            .text(f"\n❌发送 “{stop_command_prompt()}” 结束回合")
+            .text("\n\n⚠️意见未统一将空刀"),
+            select_players=players,
         )
 
-        stream = ObjectStream[str | UniMessage](8)
+        self.stream = ObjectStream[str | UniMessage](8)
+
+        try:
+            async with anyio.create_task_group() as tg:
+                tg.start_soon(self._handle_interact, players)
+                tg.start_soon(self._handle_broadcast, partners)
+        finally:
+            del self.stream
+
+    @override
+    async def _after_interact(self) -> None:
+        state = self.game.state
+        if not state.werewolf_finished.is_set():
+            state.werewolf_finished.set()
+            w = self.game.players.alive().select(RoleGroup.WEREWOLF)
+            if (s := w.player_selected()).size == 1:
+                state.killed = s.pop()
+                await w.broadcast(f"🔪今晚选择的目标为: {state.killed.name}")
+            else:
+                await w.broadcast("⚠️狼人阵营意见未统一，此晚空刀")
 
-        async with anyio.create_task_group() as tg:
-            tg.start_soon(self._handle_interact, players, stream)
-            tg.start_soon(self._handle_broadcast, partners, stream)
+        if not self.game.players.alive().select(Role.WITCH):
+            await anyio.sleep(5 + secrets.randbelow(15))

nonebot_plugin_werewolf/players/witch.py

@@ -1,13 +1,17 @@
-from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import STOP_COMMAND_PROMPT
+import nonebot
+from nonebot_plugin_alconna.uniseg import UniMessage
+
+from ..constant import stop_command_prompt
 from ..models import Role, RoleGroup
 from ..utils import as_player_set
 from .player import Player
 
+logger = nonebot.logger.opt(colors=True)
+
 
-@Player.register_role(Role.Witch, RoleGroup.GoodGuy)
+@Player.register_role(Role.WITCH, RoleGroup.GOODGUY)
 class Witch(Player):
     antidote: bool = True
     poison: bool = True
@@ -23,13 +27,18 @@ class Witch(Player):
             await self.send(msg.text("⚙️你已经用过解药了"))
             return False
 
-        msg.text(f"✏️使用解药请发送 “1”\n❌不使用解药请发送 “{STOP_COMMAND_PROMPT}”")
-        await self.send(msg)
+        msg.text(f"✏️使用解药请发送 “1”\n❌不使用解药请发送 “{stop_command_prompt()}”")
+        await self.send(
+            msg,
+            stop_btn_label="不使用解药",
+            select_players=as_player_set(killed),
+        )
 
         if not await self._select_player(
             as_player_set(killed),
             on_stop=f"ℹ️你选择不对 {killed.name} 使用解药",
-            on_index_error=f"⚠️输入错误: 请输入 “1” 或 “{STOP_COMMAND_PROMPT}”",
+            on_index_error=f"⚠️输入错误: 请输入 “1” 或 “{stop_command_prompt()}”",
+            stop_btn_label="不使用解药",
         ):
             return False
 
@@ -40,7 +49,12 @@ class Witch(Player):
         return True
 
     @override
-    async def interact(self) -> None:
+    async def _before_interact(self) -> None:
+        await self.send("ℹ️请等待狼人决定目标...")
+        await self.game.state.werewolf_finished.wait()
+
+    @override
+    async def _interact(self) -> None:
         if await self.handle_killed():
             return
 
@@ -50,16 +64,19 @@ class Witch(Player):
 
         players = self.game.players.alive()
         await self.send(
-            UniMessage.text("💫你有一瓶毒药\n")
-            .text("玩家列表:\n")
-            .text(players.show())
-            .text("\n\n🧪发送玩家编号使用毒药")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合(不使用药水)")
+            "💫你有一瓶毒药\n"
+            "玩家列表:\n"
+            f"{players.show()}\n\n"
+            "🧪发送玩家编号使用毒药\n"
+            f"❌发送 “{stop_command_prompt()}” 结束回合(不使用药水)",
+            stop_btn_label="结束回合",
+            select_players=players,
         )
 
         if selected := await self._select_player(
             players,
             on_stop="ℹ️你选择不使用毒药，回合结束",
+            stop_btn_label="结束回合",
         ):
             self.poison = False
             self.selected = selected