nonebot-plugin-werewolf 1.1.11__py3-none-any.whl → 1.1.13__py3-none-any.whl

nonebot_plugin_werewolf/matchers/start_game.py

@@ -1,42 +1,28 @@
 import json
-import re
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
 
 import anyio
-import nonebot
-import nonebot_plugin_waiter.unimsg as waiter
 from nonebot.adapters import Bot, Event
-from nonebot.internal.matcher import current_bot
-from nonebot.permission import SuperUser
-from nonebot.rule import Rule, to_me
+from nonebot.rule import to_me
 from nonebot.typing import T_State
-from nonebot.utils import escape_tag
 from nonebot_plugin_alconna import (
     Alconna,
-    Button,
     FallbackStrategy,
     MsgTarget,
     Option,
     Target,
     UniMessage,
-    UniMsg,
-    get_target,
     on_alconna,
 )
 from nonebot_plugin_localstore import get_plugin_data_file
-from nonebot_plugin_uninfo import QryItrface, Uninfo
+from nonebot_plugin_uninfo import Uninfo
 
-from ..config import GameBehavior, PresetData, config
-from ..constant import stop_command_prompt
-from ..game import Game, get_running_games, get_starting_games
-from ..utils import ObjectStream, SendHandler, extract_session_member_nick
+from ..config import GameBehavior, config, stop_command_prompt
+from ..game import Game, get_running_games
+from ..utils import extract_session_member_nick
+from ._prepare_game import PrepareGame, solve_button
 from .depends import rule_not_in_game
 from .poke import poke_enabled
 
-if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable
-
 start_game = on_alconna(
     Alconna(
         "werewolf",
@@ -46,6 +32,7 @@ start_game = on_alconna(
     if config.get_require_at("start")
     else rule_not_in_game,
     aliases={"狼人杀"},
+    use_cmd_start=config.use_cmd_start,
     priority=config.matcher_priority.start,
 )
 player_data_file = get_plugin_data_file("players.json")
@@ -73,210 +60,11 @@ def load_players(target: Target) -> dict[str, str] | None:
     return None
 
 
-def solve_button(msg: UniMessage) -> UniMessage:
-    def btn(text: str) -> Button:
-        return Button("input", label=text, text=text)
-
-    return (
-        msg.keyboard(btn("当前玩家"))
-        .keyboard(btn("加入游戏"), btn("退出游戏"))
-        .keyboard(btn("开始游戏"), btn("结束游戏"))
-    )
-
-
-class PrepareGame:
-    @dataclass
-    class _Current:
-        id: str
-        name: str
-        colored: str
-        is_admin: bool
-        is_super_user: bool
-
-    class _SendHandler(SendHandler):
-        def __init__(self) -> None:
-            self.reply_to = True
-
-        def solve_msg(self, msg: UniMessage) -> UniMessage:
-            return solve_button(msg)
-
-        async def send_finished(self) -> None:
-            btn_start = Button("input", label="发起游戏", text="werewolf")
-            btn_restart = Button("input", label="重开上次游戏", text="werewolf restart")
-            msg = (
-                UniMessage.text("ℹ️已结束当前游戏")
-                .keyboard(btn_start)
-                .keyboard(btn_restart)
-            )
-            async with anyio.create_task_group() as tg:
-                tg.start_soon(self._edit)
-                tg.start_soon(self._send, msg)
-
-    def __init__(self, event: Event, players: dict[str, str]) -> None:
-        self.event = event
-        self.admin_id = event.get_user_id()
-        self.group = get_target(event)
-        self.stream = ObjectStream[tuple[Event, str, str]](16)
-        self.players = players
-        self.send_handler = self._SendHandler()
-        self.logger = nonebot.logger.opt(colors=True)
-        self.shoud_start_game = False
-        get_starting_games()[self.group] = self.players
-
-        self._handlers: dict[str, Callable[[], Awaitable[bool | None]]] = {
-            "开始游戏": self._handle_start,
-            "结束游戏": self._handle_end,
-            "加入游戏": self._handle_join,
-            "退出游戏": self._handle_quit,
-            "当前玩家": self._handle_list,
-        }
-
-    async def run(self) -> None:
-        try:
-            async with anyio.create_task_group() as tg:
-                self.task_group = tg
-                tg.start_soon(self._wait_cancel)
-                tg.start_soon(self._receive)
-                tg.start_soon(self._handle)
-        except Exception as err:
-            await UniMessage(f"狼人杀准备阶段出现未知错误: {err!r}").finish()
-
-        del get_starting_games()[self.group]
-        if not self.shoud_start_game:
-            await start_game.finish()
-
-    async def _wait_cancel(self) -> None:
-        await self.stream.wait_closed()
-        self.task_group.cancel_scope.cancel()
-
-    async def _receive(self) -> None:
-        async def same_group(target: MsgTarget) -> bool:
-            return self.group.verify(target)
-
-        @waiter.waiter(
-            waits=[self.event.get_type()],
-            keep_session=False,
-            rule=Rule(same_group) & rule_not_in_game,
-        )
-        def wait(event: Event, msg: UniMsg, session: Uninfo) -> tuple[Event, str, str]:
-            text = msg.extract_plain_text().strip()
-            name = extract_session_member_nick(session) or event.get_user_id()
-            return (event, text, re.sub(r"[\u2066-\u2069]", "", name))
-
-        async for event, text, name in wait(default=(None, "", "")):
-            if event is not None:
-                await self.stream.send((event, text, name))
-
-    async def _handle(self) -> None:
-        bot = current_bot.get()
-        superuser = SuperUser()
-
-        while not self.stream.closed:
-            event, text, name = await self.stream.recv()
-            user_id = event.get_user_id()
-            colored = f"<y>{escape_tag(name)}</y>(<c>{escape_tag(user_id)}</c>)"
-            self.current = self._Current(
-                id=user_id,
-                name=name,
-                colored=colored,
-                is_admin=user_id == self.admin_id,
-                is_super_user=await superuser(bot, event),
-            )
-            self.send_handler.update(event)
-
-            # 更新用户名
-            # 当用户通过 chronoca:poke 加入游戏时, 插件无法获取用户名, 原字典值为用户ID
-            if user_id in self.players and self.players.get(user_id) != name:
-                self.logger.debug(f"更新玩家显示名称: {self.current.colored}")
-                self.players[user_id] = name
-
-            handler = self._handlers.get(text)
-            if handler is not None and await handler():
-                return
-
-    async def _send(self, msg: str | UniMessage) -> None:
-        await self.send_handler.send(msg)
-
-    async def _send_finished(self) -> None:
-        await self.send_handler.send_finished()
-
-    async def _handle_start(self) -> bool:
-        if not self.current.is_admin:
-            await self._send("⚠️只有游戏发起者可以开始游戏")
-            return False
-
-        player_num = len(self.players)
-        role_preset = PresetData.get().role_preset
-        if player_num < min(role_preset):
-            await self._send(
-                f"⚠️游戏至少需要 {min(role_preset)} 人, 当前已有 {player_num} 人"
-            )
-        elif player_num > max(role_preset):
-            await self._send(
-                f"⚠️游戏最多需要 {max(role_preset)} 人, 当前已有 {player_num} 人"
-            )
-        elif player_num not in role_preset:
-            await self._send(
-                f"⚠️不存在总人数为 {player_num} 的预设, 无法开始游戏\n"
-                f"可用的预设总人数: {', '.join(map(str, role_preset))}"
-            )
-        else:
-            await self._send("✏️游戏即将开始...")
-            self.logger.info(f"游戏发起者 {self.current.colored} 开始游戏")
-            self.stream.close()
-            self.shoud_start_game = True
-            return True
-
-        return False
-
-    async def _handle_end(self) -> bool:
-        if self.current.is_admin or self.current.is_super_user:
-            prefix = "游戏发起者" if self.current.is_admin else "超级用户"
-            self.logger.info(f"{prefix} {self.current.colored} 结束游戏")
-            await self._send_finished()
-            self.stream.close()
-            return True
-
-        await self._send("⚠️只有游戏发起者或超级用户可以结束游戏")
-        return False
-
-    async def _handle_join(self) -> None:
-        if self.current.is_admin:
-            await self._send("⚠️只有游戏发起者可以开始游戏")
-            return
-
-        if self.current.id not in self.players:
-            self.players[self.current.id] = self.current.name
-            self.logger.info(f"玩家 {self.current.colored} 加入游戏")
-            await self._send("✅成功加入游戏")
-        else:
-            await self._send("ℹ️你已经加入游戏了")
-
-    async def _handle_quit(self) -> None:
-        if self.current.is_admin:
-            await self._send("ℹ️游戏发起者无法退出游戏")
-            return
-
-        if self.current.id in self.players:
-            del self.players[self.current.id]
-            self.logger.info(f"玩家 {self.current.colored} 退出游戏")
-            await self._send("✅成功退出游戏")
-        else:
-            await self._send("ℹ️你还没有加入游戏")
-
-    async def _handle_list(self) -> None:
-        lines = (
-            f"{idx}. {self.players[user_id]}"
-            for idx, user_id in enumerate(self.players, 1)
-        )
-        await self._send("✨当前玩家:\n" + "\n".join(lines))
-
-
 @start_game.handle()
 async def handle_notice(target: MsgTarget) -> None:
     if target.private:
         await UniMessage("⚠️请在群组中创建新游戏").finish(reply_to=True)
-    if any(target.verify(game.group) for game in get_running_games()):
+    if target in get_running_games():
         await (
             UniMessage.text("⚠️当前群组内有正在进行的游戏\n")
             .text("无法开始新游戏")
@@ -291,8 +79,10 @@ async def handle_notice(target: MsgTarget) -> None:
         "  玩家均加入后，游戏发起者请发送 “开始游戏”\n"
     )
     if poke_enabled():
-        msg.text(f"\n💫可使用戳一戳代替游戏交互中的 “{stop_command_prompt()}” 命令\n")
-    msg.text("\nℹ️游戏准备阶段限时5分钟，超时将自动结束")
+        msg.text(f"\n💫可使用戳一戳代替游戏交互中的 “{stop_command_prompt}” 命令\n")
+
+    prepare_timeout = GameBehavior.get().timeout.prepare
+    msg.text(f"\nℹ️游戏准备阶段限时{prepare_timeout / 60:.1f}分钟，超时将自动结束")
     await solve_button(msg).send(reply_to=True, fallback=FallbackStrategy.ignore)
 
 
@@ -315,22 +105,20 @@ async def handle_restart(target: MsgTarget, state: T_State) -> None:
 async def handle_start(
     bot: Bot,
     event: Event,
-    target: MsgTarget,
-    session: Uninfo,
-    interface: QryItrface,
     state: T_State,
+    session: Uninfo,
+    target: MsgTarget,
 ) -> None:
     players: dict[str, str] = state.get("players", {})
     admin_id = event.get_user_id()
     admin_name = extract_session_member_nick(session) or admin_id
     players[admin_id] = admin_name
 
-    try:
-        with anyio.fail_after(GameBehavior.get().timeout.prepare):
-            await PrepareGame(event, players).run()
-    except TimeoutError:
-        await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
+    with anyio.move_on_after(GameBehavior.get().timeout.prepare) as scope:
+        await PrepareGame(event, players).run()
+    if scope.cancelled_caught:
+        await UniMessage.text("⚠️游戏准备超时，已自动结束").finish(reply_to=True)
 
     dump_players(target, players)
-    game = await Game.new(bot, target, set(players), interface)
-    await game.start()
+    game = await Game.new(bot, target, set(players))
+    game.start()

nonebot_plugin_werewolf/matchers/superuser_ops.py

@@ -12,21 +12,18 @@ terminate = on_alconna(
     Alconna("中止游戏"),
     rule=to_me() if config.get_require_at("terminate") else None,
     permission=SUPERUSER,
+    use_cmd_start=config.use_cmd_start,
     priority=config.matcher_priority.terminate,
 )
 
 
 async def running_game(target: MsgTarget) -> Game:
-    for game in get_running_games():
-        if target.verify(game.group):
-            return game
-    return terminate.skip()
-
-
-RunningGame = Annotated[Game, Depends(running_game)]
+    if (game := get_running_games().get(target)) is None:
+        terminate.skip()
+    return game
 
 
 @terminate.handle()
-async def _(game: RunningGame) -> None:
+async def _(game: Annotated[Game, Depends(running_game)]) -> None:
     game.terminate()
     await UniMessage.text("已中止当前群组的游戏进程").finish(reply_to=True)

nonebot_plugin_werewolf/models.py

@@ -1,4 +1,5 @@
 import dataclasses
+import functools
 from enum import Enum, auto
 from typing import TYPE_CHECKING
 
@@ -26,12 +27,30 @@ class Role(int, Enum):
     # 平民
     CIVILIAN = 0
 
+    @functools.cached_property
+    def emoji(self) -> str:
+        from .constant import ROLE_EMOJI
+
+        return ROLE_EMOJI[self]
+
+    @functools.cached_property
+    def display(self) -> str:
+        from .constant import ROLE_NAME_CONV
+
+        return ROLE_NAME_CONV[self]
+
 
 class RoleGroup(Enum):
     WEREWOLF = auto()
     GOODGUY = auto()
     OTHERS = auto()
 
+    @functools.cached_property
+    def display(self) -> str:
+        from .constant import ROLE_NAME_CONV
+
+        return ROLE_NAME_CONV[self]
+
 
 class KillReason(Enum):
     WEREWOLF = auto()

nonebot_plugin_werewolf/player.py

@@ -9,9 +9,10 @@ import nonebot
 from nonebot.adapters import Bot
 from nonebot.utils import escape_tag
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
-from nonebot_plugin_uninfo import Interface, SceneType
+from nonebot_plugin_uninfo import Interface, SceneType, get_interface
 
-from .constant import ROLE_EMOJI, ROLE_NAME_CONV, STOP_COMMAND, stop_command_prompt
+from .config import stop_command_prompt
+from .constant import STOP_COMMAND
 from .models import KillInfo, KillReason, Role, RoleGroup
 from .utils import (
     InputStore,
@@ -92,7 +93,7 @@ class NotifyProvider(ActionProvider[_P], Generic[_P]):
         return message
 
     async def notify(self) -> None:
-        msg = UniMessage.text(f"⚙️你的身份: {ROLE_EMOJI[self.role]}{self.role_name}\n")
+        msg = UniMessage.text(f"⚙️你的身份: {self.role.emoji}{self.role_name}\n")
         await self.p.send(self.message(msg))
 
 
@@ -135,14 +136,18 @@ class Player:
     @override
     def __init_subclass__(cls) -> None:
         super().__init_subclass__()
-        if hasattr(cls, "role") and hasattr(cls, "role_group"):
-            cls._player_class[cls.role] = cls
-        if not hasattr(cls, "interact_provider"):
-            cls.interact_provider = None
-        if not hasattr(cls, "kill_provider"):
-            cls.kill_provider = KillProvider
-        if not hasattr(cls, "notify_provider"):
-            cls.notify_provider = NotifyProvider
+        if not (hasattr(cls, "role") and hasattr(cls, "role_group")):
+            return
+
+        assert cls.role not in cls._player_class  # noqa: S101
+        cls._player_class[cls.role] = cls
+        for k, v in {
+            "interact_provider": None,
+            "kill_provider": KillProvider,
+            "notify_provider": NotifyProvider,
+        }.items():
+            if not hasattr(cls, k):
+                setattr(cls, k, v)
 
     @final
     @classmethod
@@ -152,7 +157,6 @@ class Player:
         bot: Bot,
         game: "Game",
         user_id: str,
-        interface: Interface,
     ) -> "Player":
         if role not in cls._player_class:
             raise ValueError(f"Unexpected role: {role!r}")
@@ -166,7 +170,9 @@ class Player:
             extra=game.group.extra,
         )
         self = cls._player_class[role](bot, game, user)
-        await self._fetch_member(interface)
+
+        if interface := get_interface(bot):
+            await self._fetch_member(interface)
         return self
 
     def __repr__(self) -> str:
@@ -187,7 +193,7 @@ class Player:
     @final
     @functools.cached_property
     def role_name(self) -> str:
-        return ROLE_NAME_CONV[self.role]
+        return self.role.display
 
     @final
     async def _fetch_member(self, interface: Interface) -> None:
@@ -278,14 +284,12 @@ class Player:
         provider = self.interact_provider(self)
 
         await provider.before()
-
         timeout = self.interact_timeout
         await self.send(f"✏️{self.role_name}交互开始，限时 {timeout / 60:.2f} 分钟")
 
-        try:
-            with anyio.fail_after(timeout):
-                await provider.interact()
-        except TimeoutError:
+        with anyio.move_on_after(timeout) as scope:
+            await provider.interact()
+        if scope.cancelled_caught:
             logger.debug(f"{self.role_name}交互超时 (<y>{timeout}</y>s)")
             await self.send(f"⚠️{self.role_name}交互超时")
 
@@ -304,25 +308,25 @@ class Player:
         self.killed.set()
 
     async def vote(self, players: "PlayerSet") -> "Player | None":
+        vote_timeout = self.game.behavior.timeout.vote
         await self.send(
             f"💫请选择需要投票的玩家:\n"
             f"{players.show()}\n\n"
             "🗳️发送编号选择玩家\n"
-            f"❌发送 “{stop_command_prompt()}” 弃票\n\n"
-            "限时1分钟，超时将视为弃票",
+            f"❌发送 “{stop_command_prompt}” 弃票\n\n"
+            f"限时{vote_timeout / 60:.1f}分钟，超时将视为弃票",
             stop_btn_label="弃票",
             select_players=players,
         )
 
-        try:
-            with anyio.fail_after(self.game.behavior.timeout.vote):
-                selected = await self.select_player(
-                    players,
-                    on_stop="⚠️你选择了弃票",
-                    on_index_error="⚠️输入错误: 请发送编号选择玩家",
-                )
-        except TimeoutError:
-            selected = None
+        selected = None
+        with anyio.move_on_after(vote_timeout) as scope:
+            selected = await self.select_player(
+                players,
+                on_stop="⚠️你选择了弃票",
+                on_index_error="⚠️输入错误: 请发送编号选择玩家",
+            )
+        if scope.cancelled_caught:
             await self.send("⚠️投票超时，将视为弃票")
 
         if selected is not None:
@@ -343,7 +347,7 @@ class Player:
     ) -> "Player | None":
         on_stop = on_stop if on_stop is not None else "ℹ️你选择了取消，回合结束"
         on_index_error = (
-            on_index_error or f"⚠️输入错误: 请发送玩家编号或 “{stop_command_prompt()}”"
+            on_index_error or f"⚠️输入错误: 请发送玩家编号或 “{stop_command_prompt}”"
         )
         selected = None
 

nonebot_plugin_werewolf/players/guard.py

@@ -1,6 +1,6 @@
 from typing_extensions import override
 
-from ..constant import stop_command_prompt
+from ..config import stop_command_prompt
 from ..models import GameState, Role, RoleGroup
 from ..player import InteractProvider, Player
 
@@ -13,7 +13,7 @@ class GuardInteractProvider(InteractProvider["Guard"]):
             "💫请选择需要保护的玩家:\n"
             f"{players.show()}\n\n"
             "🛡️发送编号选择玩家\n"
-            f"❌发送 “{stop_command_prompt()}” 结束回合",
+            f"❌发送 “{stop_command_prompt}” 结束回合",
             stop_btn_label="结束回合",
             select_players=players,
         )

nonebot_plugin_werewolf/players/prophet.py

@@ -1,6 +1,6 @@
 from typing_extensions import override
 
-from ..constant import stop_command_prompt
+from ..config import stop_command_prompt
 from ..models import Role, RoleGroup
 from ..player import InteractProvider, Player
 
@@ -13,7 +13,7 @@ class ProphetInteractProvider(InteractProvider["Prophet"]):
             "💫请选择需要查验身份的玩家:\n"
             f"{players.show()}\n\n"
             "🔮发送编号选择玩家\n"
-            f"❌发送 “{stop_command_prompt()}” 结束回合(不查验身份)",
+            f"❌发送 “{stop_command_prompt}” 结束回合(不查验身份)",
             stop_btn_label="结束回合",
             select_players=players,
         )

nonebot_plugin_werewolf/players/shooter.py

@@ -2,7 +2,7 @@ from typing_extensions import override
 
 from nonebot_plugin_alconna.uniseg import UniMessage
 
-from ..constant import stop_command_prompt
+from ..config import stop_command_prompt
 from ..models import KillReason
 from ..player import KillProvider, Player
 
@@ -39,7 +39,7 @@ class ShooterKillProvider(KillProvider["Player"]):
             "💫请选择需要射杀的玩家:\n"
             f"{players.show()}\n\n"
             "🔫发送编号选择玩家\n"
-            f"❌发送 “{stop_command_prompt()}” 取消技能",
+            f"❌发送 “{stop_command_prompt}” 取消技能",
             stop_btn_label="取消技能",
             select_players=players,
         )

nonebot_plugin_werewolf/players/werewolf.py

@@ -5,23 +5,23 @@ from typing_extensions import override
 import anyio
 from nonebot_plugin_alconna.uniseg import UniMessage
 
-from ..constant import STOP_COMMAND, stop_command_prompt
+from ..config import stop_command_prompt
+from ..constant import STOP_COMMAND
 from ..models import Role, RoleGroup
 from ..player import InteractProvider, NotifyProvider, Player
-from ..utils import ObjectStream, as_player_set, check_index
+from ..utils import as_player_set, check_index
 
 if TYPE_CHECKING:
     from ..player_set import PlayerSet
 
 
 class WerewolfInteractProvider(InteractProvider["Werewolf"]):
-    stream: ObjectStream[str | UniMessage]
-
     @override
     async def before(self) -> None:
         self.game.state.werewolf_start()
 
     async def handle_interact(self, players: "PlayerSet") -> None:
+        stream = self.stream[0]
         self.selected = None
 
         while True:
@@ -32,30 +32,31 @@ class WerewolfInteractProvider(InteractProvider["Werewolf"]):
                 self.selected = players[index - 1]
                 msg = f"当前选择玩家: {self.selected.name}"
                 await self.p.send(
-                    f"🎯{msg}\n发送 “{stop_command_prompt()}” 结束回合",
+                    f"🎯{msg}\n发送 “{stop_command_prompt}” 结束回合",
                     stop_btn_label="结束回合",
                     select_players=players,
                 )
-                await self.stream.send(f"📝队友 {self.p.name} {msg}")
+                await stream.send(f"📝队友 {self.p.name} {msg}")
             if text == STOP_COMMAND:
                 if self.selected is not None:
                     await self.p.send("✅你已结束当前回合")
-                    await self.stream.send(f"📝队友 {self.p.name} 结束当前回合")
-                    self.stream.close()
+                    await stream.send(f"📝队友 {self.p.name} 结束当前回合")
+                    stream.close()
                     return
                 await self.p.send(
                     "⚠️当前未选择玩家，无法结束回合",
                     select_players=players,
                 )
             else:
-                await self.stream.send(
+                await stream.send(
                     UniMessage.text(f"💬队友 {self.p.name}:\n") + input_msg
                 )
 
     async def handle_broadcast(self, partners: "PlayerSet") -> None:
-        while not self.stream.closed:
+        stream = self.stream[1]
+        while True:
             try:
-                message = await self.stream.recv()
+                message = await stream.receive()
             except anyio.EndOfStream:
                 return
 
@@ -77,19 +78,17 @@ class WerewolfInteractProvider(InteractProvider["Werewolf"]):
             msg.text("💫请选择今晚的目标:\n")
             .text(players.show())
             .text("\n\n🔪发送编号选择玩家")
-            .text(f"\n❌发送 “{stop_command_prompt()}” 结束回合")
+            .text(f"\n❌发送 “{stop_command_prompt}” 结束回合")
             .text("\n\n⚠️意见未统一将空刀"),
             select_players=players,
         )
 
-        self.stream = ObjectStream[str | UniMessage](8)
+        self.stream = anyio.create_memory_object_stream[str | UniMessage](8)
+        send, recv = self.stream
 
-        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
+        async with send, recv, anyio.create_task_group() as tg:
+            tg.start_soon(self.handle_interact, players)
+            tg.start_soon(self.handle_broadcast, partners)
 
     async def finalize(self) -> None:
         w = self.game.players.alive().select(RoleGroup.WEREWOLF)