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

nonebot_plugin_werewolf/__init__.py

@@ -9,7 +9,7 @@ from . import matchers as matchers
 from . import players as players
 from .config import Config
 
-__version__ = "1.1.3"
+__version__ = "1.1.5"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",
@@ -24,6 +24,7 @@ __plugin_meta__ = PluginMetadata(
     ),
     extra={
         "Author": "wyf7685",
+        "Version": __version__,
         "Bug Tracker": "https://github.com/wyf7685/nonebot-plugin-werewolf/issues",
     },
 )

nonebot_plugin_werewolf/constant.py

@@ -4,10 +4,19 @@ import dataclasses
 from enum import Enum, auto
 from typing import TYPE_CHECKING
 
+import nonebot
+
 if TYPE_CHECKING:
     from .players import Player
 
 
+COMMAND_START = next(
+    iter(sorted(nonebot.get_driver().config.command_start, key=len)), ""
+)
+STOP_COMMAND_PROMPT = f"{COMMAND_START}stop"
+STOP_COMMAND = "{{stop}}"
+
+
 class Role(Enum):
     # 狼人
     Werewolf = 1
@@ -49,11 +58,24 @@ class GameStatus(Enum):
 @dataclasses.dataclass
 class GameState:
     day: int
+    """当前天数记录, 不会被 `reset()` 重置"""
     killed: Player | None = None
-    shoot: tuple[Player, Player] | tuple[None, None] = (None, None)
+    """当晚狼人击杀目标, `None` 则为空刀"""
+    shoot: Player | None = None
+    """当前执行射杀操作的玩家"""
     antidote: set[Player] = dataclasses.field(default_factory=set)
+    """当晚女巫使用解药的目标"""
     poison: set[Player] = dataclasses.field(default_factory=set)
+    """当晚使用了毒药的女巫"""
     protected: set[Player] = dataclasses.field(default_factory=set)
+    """当晚守卫保护的目标"""
+
+    def reset(self) -> None:
+        self.killed = None
+        self.shoot = None
+        self.antidote = set()
+        self.poison = set()
+        self.protected = set()
 
 
 role_name_conv: dict[Role | RoleGroup, str] = {

nonebot_plugin_werewolf/game.py

@@ -1,27 +1,33 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
 import secrets
-from typing import TYPE_CHECKING, ClassVar, NoReturn
+from typing import ClassVar, NoReturn
 
+import anyio
+from nonebot.adapters import Bot
 from nonebot.log import logger
+from nonebot.utils import escape_tag
 from nonebot_plugin_alconna import At, Target, UniMessage
+from nonebot_plugin_alconna.uniseg.message import Receipt
+from nonebot_plugin_uninfo import Interface, SceneType
+from typing_extensions import Self, assert_never
 
-from ._timeout import timeout
 from .config import config
-from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, role_name_conv
+from .constant import (
+    STOP_COMMAND,
+    STOP_COMMAND_PROMPT,
+    GameState,
+    GameStatus,
+    KillReason,
+    Role,
+    RoleGroup,
+    role_name_conv,
+)
 from .exception import GameFinished
 from .player_set import PlayerSet
 from .players import Player
-from .utils import InputStore
-
-if TYPE_CHECKING:
-    from nonebot.adapters import Bot
-    from nonebot_plugin_alconna.uniseg.message import Receipt
+from .utils import InputStore, link
 
 
-def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
+def init_players(bot: Bot, game: "Game", players: set[str]) -> PlayerSet:
     logger.opt(colors=True).debug(f"初始化 <c>{game.group.id}</c> 的玩家职业")
     role_preset = config.get_role_preset()
     if (preset := role_preset.get(len(players))) is None:
@@ -44,8 +50,7 @@ def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
         return roles.pop(secrets.randbelow(len(roles)))
 
     player_set = PlayerSet(
-        Player.new(_select_role(), bot, game, user_id, players[user_id])
-        for user_id in players
+        Player.new(_select_role(), bot, game, user_id) for user_id in players
     )
     logger.debug(f"职业分配完成: {player_set}")
 
@@ -54,33 +59,64 @@ def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
 
 class Game:
     starting_games: ClassVar[dict[Target, dict[str, str]]] = {}
-    running_games: ClassVar[set[Game]] = set()
+    running_games: ClassVar[set[Self]] = set()
 
     bot: Bot
     group: Target
     players: PlayerSet
-    _player_map: dict[str, Player]
+    interface: Interface
     state: GameState
     killed_players: list[Player]
 
-    def __init__(self, bot: Bot, group: Target, players: dict[str, str]) -> None:
+    def __init__(
+        self,
+        bot: Bot,
+        group: Target,
+        players: set[str],
+        interface: Interface,
+    ) -> None:
         self.bot = bot
         self.group = group
         self.players = init_players(bot, self, players)
-        self._player_map = {p.user_id: p for p in self.players}
+        self.interface = interface
         self.state = GameState(0)
         self.killed_players = []
+        self._player_map = {p.user_id: p for p in self.players}
+        self._scene = None
+
+    async def _fetch_group_scene(self) -> None:
+        scene = await self.interface.get_scene(SceneType.GROUP, self.group.id)
+        if scene is None:
+            scene = await self.interface.get_scene(SceneType.GUILD, self.group.id)
+
+        self._scene = scene
+
+    @property
+    def colored_name(self) -> str:
+        name = escape_tag(self.group.id)
+
+        if self._scene is None or self._scene.name is None:
+            name = f"<b><e>{name}</e></b>"
+        else:
+            name = f"<y>{escape_tag(self._scene.name)}</y>(<b><e>{name}</e></b>)"
+
+        if self._scene is not None and self._scene.avatar is not None:
+            name = link(name, self._scene.avatar)
+
+        return name
 
     async def send(self, message: str | UniMessage) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
-        text = f"<b><e>{self.group.id}</e></b> | <g>Send</g> | "
+
+        text = f"{self.colored_name} | <g>Send</g> | "
         for seg in message:
             if isinstance(seg, At):
-                text += f"<y>@{self._player_map[seg.target].name}</y>"
+                text += f"<y>@{self._player_map[seg.target].colored_name}</y>"
             else:
-                text += str(seg)
-        logger.opt(colors=True).info(text.replace("\n", "\\n"))
+                text += escape_tag(str(seg)).replace("\n", "\\n")
+
+        logger.opt(colors=True).info(text)
         return await message.send(self.group, self.bot)
 
     def at_all(self) -> UniMessage:
@@ -126,32 +162,37 @@ class Game:
                     line = f"🔫 {line} 射杀"
                 case KillReason.Vote:
                     line = f"🗳️ {line} 票出"
+                case x:
+                    assert_never(x)
             result.append(line)
 
         return "\n\n".join(result)
 
     async def notify_player_role(self) -> None:
         preset = config.get_role_preset()[len(self.players)]
-        await asyncio.gather(
-            self.send(
-                self.at_all()
-                .text("\n\n📝正在分配职业，请注意查看私聊消息\n")
-                .text(f"当前玩家数: {len(self.players)}\n")
-                .text(f"职业分配: 狼人x{preset[0]}, 神职x{preset[1]}, 平民x{preset[2]}")
-            ),
-            *[p.notify_role() for p in self.players],
+        msg = (
+            self.at_all()
+            .text("\n\n📝正在分配职业，请注意查看私聊消息\n")
+            .text(f"当前玩家数: {len(self.players)}\n")
+            .text(f"职业分配: 狼人x{preset[0]}, 神职x{preset[1]}, 平民x{preset[2]}")
         )
 
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(self.send, msg)
+            for p in self.players:
+                tg.start_soon(p.notify_role)
+
     async def wait_stop(self, *players: Player, timeout_secs: float) -> None:
         async def wait(p: Player) -> None:
             while True:
                 msg = await InputStore.fetch(p.user_id, self.group.id)
-                if msg.extract_plain_text().strip() == "/stop":
+                if msg.extract_plain_text().strip() == STOP_COMMAND:
                     break
 
-        with contextlib.suppress(TimeoutError):
-            async with timeout(timeout_secs):
-                await asyncio.gather(*[wait(p) for p in players])
+        with anyio.move_on_after(timeout_secs):
+            async with anyio.create_task_group() as tg:
+                for p in players:
+                    tg.start_soon(wait, p)
 
     async def interact(
         self,
@@ -159,19 +200,23 @@ class Game:
         timeout_secs: float,
     ) -> None:
         players = self.players.alive().select(player_type)
-        if isinstance(player_type, Player):
-            text = player_type.role_name
-        elif isinstance(player_type, Role):
-            text = role_name_conv[player_type]
-        else:  # RoleGroup
-            text = f"{role_name_conv[player_type]}阵营"
+        match player_type:
+            case Player():
+                text = player_type.role_name
+            case Role():
+                text = role_name_conv[player_type]
+            case RoleGroup():
+                text = f"{role_name_conv[player_type]}阵营"
+            case x:
+                assert_never(x)
 
         await players.broadcast(f"✏️{text}交互开始，限时 {timeout_secs/60:.2f} 分钟")
         try:
-            await players.interact(timeout_secs)
+            with anyio.fail_after(timeout_secs):
+                await players.interact()
         except TimeoutError:
-            logger.opt(colors=True).debug(f"⚠️{text}交互超时 (<y>{timeout_secs}</y>s)")
-            await players.broadcast(f"ℹ️{text}交互时间结束")
+            logger.opt(colors=True).debug(f"{text}交互超时 (<y>{timeout_secs}</y>s)")
+            await players.broadcast(f"⚠️{text}交互超时")
 
     async def select_killed(self) -> None:
         players = self.players.alive()
@@ -190,7 +235,7 @@ class Game:
             await self.interact(Role.Witch, 60)
         # 否则等待 5-20s
         else:
-            await asyncio.sleep(5 + secrets.randbelow(15))
+            await anyio.sleep(5 + secrets.randbelow(15))
 
     async def handle_new_dead(self, players: Player | PlayerSet) -> None:
         if isinstance(players, Player):
@@ -198,15 +243,16 @@ class Game:
         if not players:
             return
 
-        await asyncio.gather(
-            players.broadcast(
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(
+                players.broadcast,
                 "ℹ️你已加入死者频道，请勿在群内继续发言\n"
-                "私聊发送消息将转发至其他已死亡玩家"
-            ),
-            self.players.dead()
-            .exclude(*players)
-            .broadcast(f"ℹ️玩家 {', '.join(p.name for p in players)} 加入了死者频道"),
-        )
+                "私聊发送消息将转发至其他已死亡玩家",
+            )
+            tg.start_soon(
+                self.players.dead().exclude(*players).broadcast,
+                f"ℹ️玩家 {', '.join(p.name for p in players)} 加入了死者频道",
+            )
 
     async def post_kill(self, players: Player | PlayerSet) -> None:
         if isinstance(players, Player):
@@ -219,16 +265,16 @@ class Game:
             await self.handle_new_dead(player)
             self.killed_players.append(player)
 
-            (shooter, shoot) = self.state.shoot
-            if shooter is not None and shoot is not None:
+            shooter = self.state.shoot
+            if shooter is not None and (shoot := shooter.selected) is not None:
                 await self.send(
-                    UniMessage.text("玩家 ")
+                    UniMessage.text("🔫玩家 ")
                     .at(shoot.user_id)
                     .text(f" 被{shooter.role_name}射杀, 请发表遗言\n")
-                    .text("限时1分钟, 发送 “/stop” 结束发言")
+                    .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
                 )
                 await self.wait_stop(shoot, timeout_secs=60)
-                self.state.shoot = (None, None)
+                self.state.shoot = shooter.selected = None
                 await self.post_kill(shoot)
 
     async def run_vote(self) -> None:
@@ -236,7 +282,7 @@ class Game:
         players = self.players.alive()
 
         # 被票玩家: [投票玩家]
-        vote_result: dict[Player, list[Player]] = await players.vote(60)
+        vote_result: dict[Player, list[Player]] = await players.vote()
         # 票数: [被票玩家]
         vote_reversed: dict[int, list[Player]] = {}
         # 收集到的总票数
@@ -250,17 +296,17 @@ class Game:
             if p is not None:
                 msg.at(p.user_id).text(f": {len(v)} 票\n")
                 vote_reversed[len(v)] = [*vote_reversed.get(len(v), []), p]
-        if v := (len(players) - total_votes):
+        if (v := (len(players) - total_votes)) > 0:
             msg.text(f"弃票: {v} 票\n\n")
 
         # 全员弃票  # 不是哥们？
         if total_votes == 0:
-            await self.send(msg.text("🔨没有人被票出"))
+            await self.send(msg.text("🔨没有人被投票放逐"))
             return
 
         # 弃票大于最高票
         if (len(players) - total_votes) >= max(vote_reversed.keys()):
-            await self.send(msg.text("🔨弃票数大于最高票数, 没有人被票出"))
+            await self.send(msg.text("🔨弃票数大于最高票数, 没有人被投票放逐"))
             return
 
         # 平票
@@ -268,11 +314,11 @@ class Game:
             await self.send(
                 msg.text("🔨玩家 ")
                 .text(", ".join(p.name for p in vs))
-                .text(" 平票, 没有人被票出")
+                .text(" 平票, 没有人被投票放逐")
             )
             return
 
-        await self.send(msg)
+        await self.send(msg.rstrip("\n"))
 
         # 仅有一名玩家票数最高
         voted = vs.pop()
@@ -285,65 +331,79 @@ class Game:
             UniMessage.text("🔨玩家 ")
             .at(voted.user_id)
             .text(" 被投票放逐, 请发表遗言\n")
-            .text("限时1分钟, 发送 “/stop” 结束发言")
+            .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
         )
         await self.wait_stop(voted, timeout_secs=60)
         await self.post_kill(voted)
 
-    async def run_dead_channel(self) -> NoReturn:
-        loop = asyncio.get_event_loop()
-        queue: asyncio.Queue[tuple[Player, UniMessage]] = asyncio.Queue()
+    async def run_dead_channel(self, finished: anyio.Event) -> NoReturn:
+        send, recv = anyio.create_memory_object_stream[tuple[Player, UniMessage]](10)
+
+        async def handle_cancel() -> None:
+            await finished.wait()
+            tg.cancel_scope.cancel()
 
-        async def send() -> NoReturn:
+        async def handle_send() -> NoReturn:
             while True:
-                player, msg = await queue.get()
+                player, msg = await recv.receive()
                 msg = f"玩家 {player.name}:\n" + msg
                 await self.players.killed().exclude(player).broadcast(msg)
-                queue.task_done()
 
-        async def recv(player: Player) -> NoReturn:
+        async def handle_recv(player: Player) -> NoReturn:
             await player.killed.wait()
 
             counter = 0
 
-            def decrease() -> None:
+            async def decrease() -> None:
                 nonlocal counter
+                await anyio.sleep(60)
                 counter -= 1
 
             while True:
                 msg = await player.receive()
                 counter += 1
                 if counter <= 10:
-                    await queue.put((player, msg))
-                    loop.call_later(60, decrease)
+                    await send.send((player, msg))
+                    tg.start_soon(decrease)
                 else:
                     await player.send("❌发言频率超过限制, 该消息被屏蔽")
 
-        await asyncio.gather(send(), *[recv(p) for p in self.players])
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(handle_cancel)
+            tg.start_soon(handle_send)
+            for p in self.players:
+                tg.start_soon(handle_recv, p)
 
     async def run(self) -> NoReturn:
+        await self._fetch_group_scene()
         # 告知玩家角色信息
         await self.notify_player_role()
-        # 天数记录 主要用于第一晚狼人击杀的遗言
-        day_count = 0
 
         # 游戏主循环
         while True:
             # 重置游戏状态，进入下一夜
-            self.state = GameState(day_count)
+            self.state.reset()
             players = self.players.alive()
             await self.send("🌙天黑请闭眼...")
 
             # 狼人、预言家、守卫 同时交互，女巫在狼人后交互
-            await asyncio.gather(
-                self.select_killed(),
-                self.interact(Role.Prophet, 60),
-                self.interact(Role.Guard, 60),
-                players.select(Role.Witch).broadcast("ℹ️请等待狼人决定目标..."),
-                players.exclude(
-                    RoleGroup.Werewolf, Role.Prophet, Role.Witch, Role.Guard
-                ).broadcast("ℹ️请等待其他玩家结束交互..."),
-            )
+            async with anyio.create_task_group() as tg:
+                tg.start_soon(self.select_killed)
+                tg.start_soon(
+                    players.select(Role.Witch).broadcast,
+                    "ℹ️请等待狼人决定目标...",
+                )
+                tg.start_soon(self.interact, Role.Prophet, 60)
+                tg.start_soon(self.interact, Role.Guard, 60)
+                tg.start_soon(
+                    players.exclude(
+                        RoleGroup.Werewolf,
+                        Role.Prophet,
+                        Role.Witch,
+                        Role.Guard,
+                    ).broadcast,
+                    "ℹ️请等待其他玩家结束交互...",
+                )
 
             # 狼人击杀目标
             if (
@@ -365,8 +425,8 @@ class Game:
                     # 女巫毒杀玩家
                     await witch.selected.kill(KillReason.Poison, witch)
 
-            day_count += 1
-            msg = UniMessage.text(f"『第{day_count}天』☀️天亮了...\n")
+            self.state.day += 1
+            msg = UniMessage.text(f"『第{self.state.day}天』☀️天亮了...\n")
             # 没有玩家死亡，平安夜
             if not (dead := players.dead()):
                 await self.send(msg.text("昨晚是平安夜"))
@@ -378,12 +438,12 @@ class Game:
                 await self.send(msg)
 
             # 第一晚被狼人杀死的玩家发表遗言
-            if day_count == 1 and killed is not None and not killed.alive:
+            if self.state.day == 1 and killed is not None and not killed.alive:
                 await self.send(
                     UniMessage.text("⚙️当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
                     .text(" 发表遗言\n")
-                    .text("限时1分钟, 发送 “/stop” 结束发言")
+                    .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
                 )
                 await self.wait_stop(killed, timeout_secs=60)
             await self.post_kill(dead)
@@ -396,7 +456,8 @@ class Game:
 
             # 开始自由讨论
             await self.send(
-                "💬接下来开始自由讨论\n限时2分钟, 全员发送 “/stop” 结束发言"
+                "💬接下来开始自由讨论\n限时2分钟, "
+                f"全员发送 “{STOP_COMMAND_PROMPT}” 结束发言"
             )
             await self.wait_stop(*self.players.alive(), timeout_secs=120)
 
@@ -417,6 +478,8 @@ class Game:
                 winner = "狼人"
             case GameStatus.Joker:
                 winner = "小丑"
+            case x:
+                assert_never(x)
 
         msg = UniMessage.text(f"🎉游戏结束，{winner}获胜\n\n")
         for p in sorted(self.players, key=lambda p: (p.role.value, p.user_id)):
@@ -424,35 +487,31 @@ class Game:
         await self.send(msg)
         await self.send(f"📌玩家死亡报告:\n\n{self.show_killed_players()}")
 
-    def start(self) -> None:
-        finished = asyncio.Event()
-        game_task = asyncio.create_task(self.run())
-        game_task.add_done_callback(lambda _: finished.set())
-        dead_channel = asyncio.create_task(self.run_dead_channel())
-
+    async def start(self) -> None:
         async def daemon() -> None:
-            await finished.wait()
-
             try:
-                game_task.result()
-            except asyncio.CancelledError:
+                await self.run()
+            except anyio.get_cancelled_exc_class():
                 logger.warning(f"{self.group.id} 的狼人杀游戏进程被取消")
             except GameFinished as result:
                 await self.handle_game_finish(result.status)
                 logger.info(f"{self.group.id} 的狼人杀游戏进程正常退出")
             except Exception as err:
                 msg = f"{self.group.id} 的狼人杀游戏进程出现未知错误: {err!r}"
-                logger.opt(exception=err).error(msg)
+                logger.exception(msg)
                 await self.send(f"❌狼人杀游戏进程出现未知错误: {err!r}")
             finally:
-                dead_channel.cancel()
-                self.running_games.discard(self)
-
-        def daemon_callback(task: asyncio.Task[None]) -> None:
-            if err := task.exception():
-                msg = f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
-                logger.opt(exception=err).error(msg)
+                finished.set()
 
+        finished = anyio.Event()
         self.running_games.add(self)
-        daemon_task = asyncio.create_task(daemon())
-        daemon_task.add_done_callback(daemon_callback)
+        try:
+            async with anyio.create_task_group() as tg:
+                tg.start_soon(daemon)
+                tg.start_soon(self.run_dead_channel, finished)
+        except Exception as err:
+            msg = f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
+            logger.opt(exception=err).error(msg)
+        finally:
+            self.running_games.discard(self)
+            InputStore.cleanup(list(self._player_map), self.group.id)

nonebot_plugin_werewolf/matchers/depends.py

@@ -0,0 +1,38 @@
+import itertools
+
+from nonebot.adapters import Bot, Event
+from nonebot_plugin_alconna import MsgTarget
+
+from ..game import Game
+
+
+def user_in_game(self_id: str, user_id: str, group_id: str | None) -> bool:
+    if group_id is None:
+        return any(
+            self_id == p.bot.self_id and user_id == p.user_id
+            for p in itertools.chain(*[g.players for g in Game.running_games])
+        )
+
+    def check(game: Game) -> bool:
+        return self_id == game.group.self_id and group_id == game.group.id
+
+    if game := next(filter(check, Game.running_games), None):
+        return any(user_id == player.user_id for player in game.players)
+
+    return False
+
+
+async def rule_in_game(bot: Bot, event: Event, target: MsgTarget) -> bool:
+    if not Game.running_games:
+        return False
+    if target.private:
+        return user_in_game(bot.self_id, target.id, None)
+    return user_in_game(bot.self_id, event.get_user_id(), target.id)
+
+
+async def rule_not_in_game(bot: Bot, event: Event, target: MsgTarget) -> bool:
+    return not await rule_in_game(bot, event, target)
+
+
+async def is_group(target: MsgTarget) -> bool:
+    return not target.private

nonebot_plugin_werewolf/matchers/message_in_game.py

@@ -1,10 +1,12 @@
-from nonebot import on_message
+from nonebot import on_command, on_message
 from nonebot.adapters import Event
-from nonebot_plugin_alconna import MsgTarget, UniMsg
+from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
 
-from ..utils import InputStore, rule_in_game
+from ..constant import STOP_COMMAND
+from ..utils import InputStore
+from .depends import rule_in_game
 
-message_in_game = on_message(rule=rule_in_game)
+message_in_game = on_message(rule=rule_in_game, priority=10)
 
 
 @message_in_game.handle()
@@ -13,3 +15,11 @@ async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
         InputStore.put(msg, target.id)
     else:
         InputStore.put(msg, event.get_user_id(), target.id)
+
+
+stopcmd = on_command("stop", rule=rule_in_game, block=True)
+
+
+@stopcmd.handle()
+async def handle_stopcmd(event: Event, target: MsgTarget) -> None:
+    await handle_input(event=event, target=target, msg=UniMessage.text(STOP_COMMAND))

nonebot_plugin_werewolf/matchers/poke/__init__.py

@@ -0,0 +1,8 @@
+from .chronocat_poke import chronocat_poke_enabled
+from .ob11_poke import ob11_poke_enabled
+
+checks = [chronocat_poke_enabled, ob11_poke_enabled]
+
+
+def poke_enabled() -> bool:
+    return any(check() for check in checks)