nonebot-plugin-werewolf 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

nonebot_plugin_werewolf/matchers/poke/chronocat_poke.py

@@ -0,0 +1,117 @@
+import contextlib
+
+from nonebot import on_message
+from nonebot.internal.matcher import current_event
+from nonebot_plugin_alconna import MsgTarget, UniMessage
+
+from ...config import config
+from ...constant import STOP_COMMAND
+from ...game import Game
+from ...utils import InputStore
+from ..depends import user_in_game
+
+
+def chronocat_poke_enabled() -> bool:
+    return False
+
+
+with contextlib.suppress(ImportError):
+    from nonebot.adapters.satori import Bot
+    from nonebot.adapters.satori.event import (
+        MessageCreatedEvent,
+        PublicMessageCreatedEvent,
+    )
+
+    def extract_poke_tome(event: MessageCreatedEvent) -> str | None:
+        if event.login and event.login.platform and event.login.platform != "chronocat":
+            return None
+
+        poke = event.get_message().include("chronocat:poke")
+        if not poke:
+            return None
+
+        gen = (
+            seg.data["operatorId"]
+            for seg in poke
+            if seg.data["userId"] == event.self_id
+        )
+        return next(gen, None)
+
+    def extract_user_group(event: MessageCreatedEvent) -> tuple[str, str | None]:
+        user_id = event.get_user_id()
+        group_id = None
+        if isinstance(event, PublicMessageCreatedEvent):
+            group_id = (event.guild and event.guild.id) or event.channel.id
+        return user_id, group_id
+
+    # 游戏内戳一戳等效 "stop" 命令
+    async def _rule_poke_stop(bot: Bot, event: MessageCreatedEvent) -> bool:
+        if not config.enable_poke:
+            return False
+        return extract_poke_tome(event) is not None and (
+            user_in_game(bot.self_id, *extract_user_group(event))
+        )
+
+    @on_message(rule=_rule_poke_stop).handle()
+    async def handle_poke_stop(event: MessageCreatedEvent) -> None:
+        InputStore.put(
+            UniMessage.text(STOP_COMMAND),
+            extract_poke_tome(event) or event.get_user_id(),
+            extract_user_group(event)[1],
+        )
+
+    # 准备阶段戳一戳等效加入游戏
+    async def _rule_poke_join(
+        bot: Bot,
+        event: PublicMessageCreatedEvent,
+        target: MsgTarget,
+    ) -> bool:
+        if not config.enable_poke:
+            return False
+
+        return (
+            (user_id := extract_poke_tome(event)) is not None
+            and not user_in_game(
+                self_id=bot.self_id,
+                user_id=user_id,
+                group_id=(event.guild and event.guild.id) or event.channel.id,
+            )
+            and any(target.verify(group) for group in Game.starting_games)
+        )
+
+    @on_message(rule=_rule_poke_join).handle()
+    async def handle_poke_join(
+        bot: Bot,
+        event: PublicMessageCreatedEvent,
+        target: MsgTarget,
+    ) -> None:
+        user_id = extract_poke_tome(event) or event.get_user_id()
+        players = next(p for g, p in Game.starting_games.items() if target.verify(g))
+
+        if user_id not in players:
+            # XXX:
+            #   截止 chronocat v0.2.19
+            #   通过 guild.member.get / user.get 获取的用户信息均不包含用户名
+            #   跳过用户名获取, 使用用户 ID 代替
+            #
+            # member = await bot.guild_member_get(
+            #     guild_id=(event.guild and event.guild.id) or event.channel.id,
+            #     user_id=user_id,
+            # )
+            # name = member.nick or (
+            #     member.user and (member.user.nick or member.user.name)
+            # )
+            # if name is None:
+            #     user = await bot.user_get(user_id=user_id)
+            #     name = user.nick or user.name
+            # players[user_id] = name or user_id
+
+            players[user_id] = user_id
+            await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
+
+    def chronocat_poke_enabled() -> bool:
+        if not config.enable_poke:
+            return False
+
+        event = current_event.get()
+        return isinstance(event, MessageCreatedEvent) and event.platform == "chronocat"

nonebot_plugin_werewolf/matchers/{ob11_ext.py → poke/ob11_poke.py}

@@ -4,12 +4,14 @@ from nonebot import on_notice
 from nonebot.internal.matcher import current_bot
 from nonebot_plugin_alconna import MsgTarget, UniMessage
 
-from ..config import config
-from ..game import Game
-from ..utils import InputStore, user_in_game
+from ...config import config
+from ...constant import STOP_COMMAND
+from ...game import Game
+from ...utils import InputStore
+from ..depends import user_in_game
 
 
-def ob11_ext_enabled() -> bool:
+def ob11_poke_enabled() -> bool:
     return False
 
 
@@ -17,23 +19,21 @@ with contextlib.suppress(ImportError):
     from nonebot.adapters.onebot.v11 import Bot
     from nonebot.adapters.onebot.v11.event import PokeNotifyEvent
 
-    # 游戏内戳一戳等效 "/stop"
+    # 游戏内戳一戳等效 "stop" 命令
     async def _rule_poke_stop(bot: Bot, event: PokeNotifyEvent) -> bool:
         if not config.enable_poke:
             return False
 
         user_id = str(event.user_id)
         group_id = str(event.group_id) if event.group_id is not None else None
-        return (
-            config.enable_poke
-            and (event.target_id == event.self_id)
-            and user_in_game(bot.self_id, user_id, group_id)
+        return (event.target_id == event.self_id) and user_in_game(
+            bot.self_id, user_id, group_id
         )
 
     @on_notice(rule=_rule_poke_stop).handle()
     async def handle_poke_stop(event: PokeNotifyEvent) -> None:
         InputStore.put(
-            msg=UniMessage.text("/stop"),
+            msg=UniMessage.text(STOP_COMMAND),
             user_id=str(event.user_id),
             group_id=str(event.group_id) if event.group_id is not None else None,
         )
@@ -60,18 +60,20 @@ with contextlib.suppress(ImportError):
         target: MsgTarget,
     ) -> None:
         user_id = event.get_user_id()
-        group_id = target.id
         players = next(p for g, p in Game.starting_games.items() if target.verify(g))
 
-        if user_id not in players:
-            res: dict[str, str] = await bot.get_group_member_info(
-                group_id=int(group_id),
-                user_id=int(user_id),
-            )
-            players[user_id] = res.get("card") or res.get("nickname") or user_id
-            await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
+        if event.group_id is None or user_id in players:
+            return
+
+        member_info = await bot.get_group_member_info(
+            group_id=event.group_id,
+            user_id=event.user_id,
+            no_cache=True,
+        )
+        players[user_id] = member_info["card"] or member_info["nickname"] or user_id
+        await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
 
-    def ob11_ext_enabled() -> bool:
+    def ob11_poke_enabled() -> bool:
         if not config.enable_poke:
             return False
 

nonebot_plugin_werewolf/matchers/start_game.py

@@ -1,13 +1,22 @@
+import re
+
+import anyio
+import nonebot
+import nonebot_plugin_waiter as waiter
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from nonebot import on_command
 from nonebot.adapters import Bot, Event
 from nonebot.rule import to_me
-from nonebot_plugin_alconna import MsgTarget, UniMessage
-from nonebot_plugin_uninfo import Uninfo
+from nonebot.utils import escape_tag
+from nonebot_plugin_alconna import MsgTarget, Target, UniMessage, UniMsg
+from nonebot_plugin_uninfo import QryItrface, Uninfo
 
-from .._timeout import timeout
+from ..config import config
+from ..constant import STOP_COMMAND_PROMPT
 from ..game import Game
-from ..utils import prepare_game, rule_not_in_game
-from .ob11_ext import ob11_ext_enabled
+from ..utils import extract_session_member_nick
+from .depends import rule_not_in_game
+from .poke import poke_enabled
 
 start_game = on_command(
     "werewolf",
@@ -22,35 +31,172 @@ async def handle_start_warning(target: MsgTarget) -> None:
         await UniMessage("⚠️请在群组中创建新游戏").finish(reply_to=True)
 
 
+async def _prepare_receive(
+    stream: MemoryObjectSendStream[tuple[Event, str, str]],
+    event: Event,
+    group: Target,
+) -> None:
+    async def same_group(target: MsgTarget) -> bool:
+        return group.verify(target)
+
+    @waiter.waiter(
+        waits=[event.get_type()],
+        keep_session=False,
+        rule=to_me() & 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, name)
+
+    async for evt, text, name in wait(default=(None, "", "")):
+        if evt is None:
+            continue
+        await stream.send((evt, text, re.sub(r"[\u2066-\u2069]", "", name)))
+
+
+async def _prepare_handle(
+    stream: MemoryObjectReceiveStream[tuple[Event, str, str]],
+    players: dict[str, str],
+    admin_id: str,
+    finished: anyio.Event,
+) -> None:
+    logger = nonebot.logger.opt(colors=True)
+
+    async def send(msg: str, /) -> None:
+        await UniMessage.text(msg).send(target=event, reply_to=True)
+
+    while True:
+        event, text, name = await stream.receive()
+        user_id = event.get_user_id()
+        colored = f"<y>{escape_tag(name)}</y>(<c>{escape_tag(user_id)}</c>)"
+
+        # 更新用户名
+        # 当用户通过 chronoca:poke 加入游戏时, 插件无法获取用户名, 原字典值为用户ID
+        if user_id in players and players.get(user_id) != name:
+            logger.debug(f"更新玩家显示名称: {colored}")
+            players[user_id] = name
+
+        match (text, user_id == admin_id):
+            case ("开始游戏", True):
+                player_num = len(players)
+                role_preset = config.get_role_preset()
+                if player_num < min(role_preset):
+                    await send(
+                        f"⚠️游戏至少需要 {min(role_preset)} 人, "
+                        f"当前已有 {player_num} 人"
+                    )
+                elif player_num > max(role_preset):
+                    await send(
+                        f"⚠️游戏最多需要 {max(role_preset)} 人, "
+                        f"当前已有 {player_num} 人"
+                    )
+                elif player_num not in role_preset:
+                    await send(f"⚠️不存在总人数为 {player_num} 的预设, 无法开始游戏")
+                else:
+                    await send("✏️游戏即将开始...")
+                    logger.info(f"游戏发起者 {colored} 开始游戏")
+                    finished.set()
+                    players["#$start_game$#"] = user_id
+                    return
+
+            case ("开始游戏", False):
+                await send("⚠️只有游戏发起者可以开始游戏")
+
+            case ("结束游戏", True):
+                logger.info(f"游戏发起者 {colored} 结束游戏")
+                await send("ℹ️已结束当前游戏")
+                finished.set()
+                return
+
+            case ("结束游戏", False):
+                await send("⚠️只有游戏发起者可以结束游戏")
+
+            case ("加入游戏", True):
+                await send("ℹ️游戏发起者已经加入游戏了")
+
+            case ("加入游戏", False):
+                if user_id not in players:
+                    players[user_id] = name
+                    logger.info(f"玩家 {colored} 加入游戏")
+                    await send("✅成功加入游戏")
+                else:
+                    await send("ℹ️你已经加入游戏了")
+
+            case ("退出游戏", True):
+                await send("ℹ️游戏发起者无法退出游戏")
+
+            case ("退出游戏", False):
+                if user_id in players:
+                    del players[user_id]
+                    logger.info(f"玩家 {colored} 退出游戏")
+                    await send("✅成功退出游戏")
+                else:
+                    await send("ℹ️你还没有加入游戏")
+
+            case ("当前玩家", _):
+                await send(
+                    "✨当前玩家:\n"
+                    + "\n".join(
+                        f"{idx}. {players[user_id]}"
+                        for idx, user_id in enumerate(players, 1)
+                    )
+                )
+
+
+async def prepare_game(event: Event, players: dict[str, str]) -> None:
+    admin_id = event.get_user_id()
+    group = UniMessage.get_target(event)
+    Game.starting_games[group] = players
+
+    finished = anyio.Event()
+    send, recv = anyio.create_memory_object_stream[tuple[Event, str, str]]()
+
+    async def _handle_cancel() -> None:
+        await finished.wait()
+        tg.cancel_scope.cancel()
+
+    try:
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(_handle_cancel)
+            tg.start_soon(_prepare_receive, send, event, group)
+            tg.start_soon(_prepare_handle, recv, players, admin_id, finished)
+    except Exception as err:
+        await UniMessage(f"狼人杀准备阶段出现未知错误: {err!r}").send()
+
+    del Game.starting_games[group]
+    if players.pop("#$start_game$#", None) != admin_id:
+        await start_game.finish()
+
+
 @start_game.handle()
 async def handle_start(
     bot: Bot,
     event: Event,
     target: MsgTarget,
     session: Uninfo,
+    interface: QryItrface,
 ) -> None:
     admin_id = event.get_user_id()
     msg = (
-        UniMessage.at(admin_id)
-        .text("\n🎉成功创建游戏\n\n")
+        UniMessage.text("🎉成功创建游戏\n\n")
         .text("  玩家请 @我 发送 “加入游戏”、“退出游戏”\n")
         .text("  玩家 @我 发送 “当前玩家” 可查看玩家列表\n")
         .text("  游戏发起者 @我 发送 “结束游戏” 可结束当前游戏\n")
         .text("  玩家均加入后，游戏发起者请 @我 发送 “开始游戏”\n")
     )
-    if ob11_ext_enabled():
-        msg.text("\n可使用戳一戳代替游戏交互中的 “/stop” 命令\n")
-    await msg.text("\n游戏准备阶段限时5分钟，超时将自动结束").send()
+    if poke_enabled():
+        msg.text(f"\n可使用戳一戳代替游戏交互中的 “{STOP_COMMAND_PROMPT}” 命令\n")
+    await msg.text("\n游戏准备阶段限时5分钟，超时将自动结束").send(reply_to=True)
 
-    admin_name = session.user.nick or session.user.name or admin_id
-    if session.member:
-        admin_name = session.member.nick or admin_name
+    admin_name = extract_session_member_nick(session) or admin_id
     players = {admin_id: admin_name}
 
     try:
-        async with timeout(5 * 60):
+        with anyio.fail_after(5 * 60):
             await prepare_game(event, players)
     except TimeoutError:
         await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
 
-    Game(bot, target, players).start()
+    game = Game(bot, target, set(players), interface)
+    await game.start()

nonebot_plugin_werewolf/player_set.py

@@ -1,16 +1,10 @@
-from __future__ import annotations
-
-import asyncio
 import functools
-from typing import TYPE_CHECKING
-
-from ._timeout import timeout
-from .players import Player
 
-if TYPE_CHECKING:
-    from nonebot_plugin_alconna.uniseg import UniMessage
+import anyio
+from nonebot_plugin_alconna.uniseg import UniMessage
 
-    from .constant import Role, RoleGroup
+from .constant import Role, RoleGroup
+from .players import Player
 
 
 class PlayerSet(set[Player]):
@@ -18,26 +12,26 @@ class PlayerSet(set[Player]):
     def size(self) -> int:
         return len(self)
 
-    def alive(self) -> PlayerSet:
+    def alive(self) -> "PlayerSet":
         return PlayerSet(p for p in self if p.alive)
 
-    def dead(self) -> PlayerSet:
+    def dead(self) -> "PlayerSet":
         return PlayerSet(p for p in self if not p.alive)
 
-    def killed(self) -> PlayerSet:
+    def killed(self) -> "PlayerSet":
         return PlayerSet(p for p in self if p.killed.is_set())
 
-    def include(self, *types: Player | Role | RoleGroup) -> PlayerSet:
+    def include(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
         return PlayerSet(
             player
             for player in self
             if (player in types or player.role in types or player.role_group in types)
         )
 
-    def select(self, *types: Player | Role | RoleGroup) -> PlayerSet:
+    def select(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
         return self.include(*types)
 
-    def exclude(self, *types: Player | Role | RoleGroup) -> PlayerSet:
+    def exclude(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
         return PlayerSet(
             player
             for player in self
@@ -48,35 +42,40 @@ class PlayerSet(set[Player]):
             )
         )
 
-    def player_selected(self) -> PlayerSet:
+    def player_selected(self) -> "PlayerSet":
         return PlayerSet(p.selected for p in self.alive() if p.selected is not None)
 
     @functools.cached_property
     def sorted(self) -> list[Player]:
         return sorted(self, key=lambda p: p.user_id)
 
-    async def interact(self, timeout_secs: float = 60) -> None:
-        async with timeout(timeout_secs):
-            await asyncio.gather(*[p.interact() for p in self.alive()])
-
-    async def vote(self, timeout_secs: float = 60) -> dict[Player, list[Player]]:
-        async def vote(player: Player) -> tuple[Player, Player] | None:
-            try:
-                async with timeout(timeout_secs):
-                    return await player.vote(self)
-            except TimeoutError:
-                await player.send("⚠️投票超时，将视为弃票")
-                return None
+    async def interact(self) -> None:
+        async with anyio.create_task_group() as tg:
+            for p in self.alive():
+                tg.start_soon(p.interact)
 
+    async def vote(self) -> dict[Player, list[Player]]:
+        players = self.alive()
         result: dict[Player, list[Player]] = {}
-        for item in await asyncio.gather(*[vote(p) for p in self.alive()]):
-            if item is not None:
-                player, voted = item
-                result[voted] = [*result.get(voted, []), player]
+
+        async def _vote(player: Player) -> None:
+            vote = await player.vote(players)
+            if vote is not None:
+                result[vote] = [*result.get(vote, []), player]
+
+        async with anyio.create_task_group() as tg:
+            for p in players:
+                tg.start_soon(_vote, p)
+
         return result
 
     async def broadcast(self, message: str | UniMessage) -> None:
-        await asyncio.gather(*[p.send(message) for p in self])
+        if not self:
+            return
+
+        async with anyio.create_task_group() as tg:
+            for p in self:
+                tg.start_soon(p.send, message)
 
     def show(self) -> str:
         return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted, 1))

nonebot_plugin_werewolf/players/can_shoot.py

@@ -1,8 +1,7 @@
 from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import KillReason
-from ..utils import check_index
+from ..constant import STOP_COMMAND_PROMPT, KillReason
 from .player import Player
 
 
@@ -19,11 +18,11 @@ class CanShoot(Player):
             .text(f" 死了\n请{self.role_name}决定击杀目标...")
         )
 
-        self.game.state.shoot = (None, None)
+        self.game.state.shoot = None
         shoot = await self.shoot()
 
         if shoot is not None:
-            self.game.state.shoot = (self, shoot)
+            self.game.state.shoot = self
             await self.send(
                 UniMessage.text(f"🔫{self.role_name} ")
                 .at(self.user_id)
@@ -31,6 +30,7 @@ class CanShoot(Player):
                 .at(shoot.user_id)
             )
             await shoot.kill(KillReason.Shoot, self)
+            self.selected = shoot
         else:
             await self.send(f"ℹ️{self.role_name}选择了取消技能")
         return await super().post_kill()
@@ -41,19 +41,13 @@ class CanShoot(Player):
             "💫请选择需要射杀的玩家:\n"
             + players.show()
             + "\n\n🔫发送编号选择玩家"
-            + "\n❌发送 “/stop” 取消技能"
+            + f"\n❌发送 “{STOP_COMMAND_PROMPT}” 取消技能"
         )
 
-        while True:
-            text = await self.receive_text()
-            if text == "/stop":
-                await self.send("ℹ️已取消技能")
-                return None
-            index = check_index(text, len(players))
-            if index is not None:
-                selected = index - 1
-                break
-            await self.send("⚠️输入错误: 请发送编号选择玩家")
-
-        await self.send(f"🎯选择射杀的玩家: {players[selected].name}")
-        return players[selected]
+        if selected := await self._select_player(
+            players,
+            on_stop="ℹ️已取消技能，回合结束",
+        ):
+            await self.send(f"🎯选择射杀的玩家: {selected.name}")
+
+        return selected

nonebot_plugin_werewolf/players/civilian.py

@@ -1,7 +1,7 @@
 from ..constant import Role, RoleGroup
-from .player import Player, register_role
+from .player import 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,13 +1,19 @@
 from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import Role, RoleGroup
-from ..utils import check_index
-from .player import Player, register_role
+from ..constant import STOP_COMMAND_PROMPT, Role, RoleGroup
+from .player import 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
+
     @override
     async def interact(self) -> None:
         players = self.game.players.alive()
@@ -15,23 +21,10 @@ class Guard(Player):
             UniMessage.text("💫请选择需要保护的玩家:\n")
             .text(players.show())
             .text("\n\n🛡️发送编号选择玩家")
-            .text("\n❌发送 “/stop” 结束回合")
+            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
         )
 
-        while True:
-            text = await self.receive_text()
-            if text == "/stop":
-                await self.send("ℹ️你选择了取消，回合结束")
-                return
-            index = check_index(text, len(players))
-            if index is not None:
-                selected = index - 1
-                if players[selected] is self.selected:
-                    await self.send("⚠️守卫不能连续两晚保护同一目标，请重新选择")
-                    continue
-                break
-            await self.send("⚠️输入错误: 请发送编号选择玩家")
-
-        self.selected = players[selected]
-        self.game.state.protected.add(self.selected)
-        await self.send(f"✅本回合保护的玩家: {self.selected.name}")
+        self.selected = await self._select_player(players)
+        if self.selected:
+            self.game.state.protected.add(self.selected)
+            await self.send(f"✅本回合保护的玩家: {self.selected.name}")

nonebot_plugin_werewolf/players/hunter.py

@@ -1,8 +1,8 @@
 from ..constant import Role, RoleGroup
 from .can_shoot import CanShoot
-from .player import Player, register_role
+from .player import 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

@@ -6,13 +6,13 @@ from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
 from ..constant import KillReason, Role, RoleGroup
-from .player import Player, register_role
+from .player import Player
 
 if TYPE_CHECKING:
     from ..player_set import PlayerSet
 
 
-@register_role(Role.Idiot, RoleGroup.GoodGuy)
+@Player.register_role(Role.Idiot, RoleGroup.GoodGuy)
 class Idiot(Player):
     voted: bool = False
 
@@ -37,7 +37,7 @@ class Idiot(Player):
         return await super().kill(reason, *killers)
 
     @override
-    async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
+    async def vote(self, players: PlayerSet) -> Player | None:
         if self.voted:
             await self.send("ℹ️你已经发动过白痴身份的技能，无法参与本次投票")
             return None