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

nonebot_plugin_werewolf/game.py

@@ -1,34 +1,36 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
 import secrets
-from typing import TYPE_CHECKING, 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 import Player
 from .player_set import PlayerSet
-from .utils import InputStore
-
-if TYPE_CHECKING:
-    from nonebot.adapters import Bot
-    from nonebot_plugin_alconna.uniseg.message import Receipt
+from .players import Player
+from .utils import InputStore, link
 
-starting_games: dict[str, dict[str, str]] = {}
-running_games: dict[str, Game] = {}
 
-
-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()
-    preset = role_preset.get(len(players))
-    if preset is None:
+    if (preset := role_preset.get(len(players))) is None:
         raise ValueError(
             f"玩家人数不符: "
             f"应为 {', '.join(map(str, role_preset))} 人, 传入{len(players)}人"
@@ -44,59 +46,77 @@ def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
         roles.remove(Role.Civilian)
         roles.append(Role.Joker)
 
-    shuffled: list[Role] = []
-    while roles:
-        idx = secrets.randbelow(len(roles))
-        shuffled.append(roles.pop(idx))
-
-    logger.debug(f"职业分配: {shuffled}")
-
-    async def selector(target_: Target, b: Bot) -> bool:
-        return target_.self_id == bot.self_id and b is bot
-
-    return PlayerSet(
-        Player.new(
-            role,
-            bot,
-            game,
-            Target(
-                user_id,
-                private=True,
-                self_id=bot.self_id,
-                selector=selector,
-            ),
-            players[user_id],
-        )
-        for user_id, role in zip(players, shuffled, strict=True)
+    def _select_role() -> Role:
+        return roles.pop(secrets.randbelow(len(roles)))
+
+    player_set = PlayerSet(
+        Player.new(_select_role(), bot, game, user_id) for user_id in players
     )
+    logger.debug(f"职业分配完成: {player_set}")
+
+    return player_set
 
 
 class Game:
+    starting_games: ClassVar[dict[Target, dict[str, str]]] = {}
+    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:
@@ -124,80 +144,79 @@ class Game:
             raise GameFinished(GameStatus.GoodGuy)
 
     def show_killed_players(self) -> str:
-        msg = ""
+        result: list[str] = []
 
         for player in self.killed_players:
             if player.kill_info is None:
                 continue
 
-            msg += f"{player.name} 被 " + ", ".join(
+            line = f"{player.name} 被 " + ", ".join(
                 p.name for p in player.kill_info.killers
             )
             match player.kill_info.reason:
                 case KillReason.Werewolf:
-                    msg += " 刀了"
+                    line = f"🔪 {line} 刀了"
                 case KillReason.Poison:
-                    msg += " 毒死"
+                    line = f"🧪 {line} 毒死"
                 case KillReason.Shoot:
-                    msg += " 射杀"
+                    line = f"🔫 {line} 射杀"
                 case KillReason.Vote:
-                    msg += " 票出"
-            msg += "\n\n"
+                    line = f"🗳️ {line} 票出"
+                case x:
+                    assert_never(x)
+            result.append(line)
 
-        return msg.strip()
+        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 def wait_stop(
-        self,
-        players: Player | PlayerSet,
-        timeout_secs: float,
-    ) -> None:
-        if isinstance(players, Player):
-            players = PlayerSet([players])
+        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() == "/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,
-        type_: Player | Role | RoleGroup,
+        player_type: Player | Role | RoleGroup,
         timeout_secs: float,
     ) -> None:
-        players = self.players.alive().select(type_)
-        text = (
-            type_.role_name  # Player
-            if isinstance(type_, Player)
-            else (
-                role_name_conv[type_]  # Role
-                if isinstance(type_, Role)
-                else f"{role_name_conv[type_]}阵营"  # RoleGroup
-            )
-        )
-
-        await players.broadcast(f"{text}交互开始，限时 {timeout_secs/60:.2f} 分钟")
+        players = self.players.alive().select(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}交互时间结束")
+            await players.broadcast(f"⚠️{text}交互超时")
 
     async def select_killed(self) -> None:
         players = self.players.alive()
@@ -207,16 +226,16 @@ class Game:
         await self.interact(RoleGroup.Werewolf, 120)
         if (s := w.player_selected()).size == 1:
             self.state.killed = s.pop()
-            await w.broadcast(f"今晚选择的目标为: {self.state.killed.name}")
+            await w.broadcast(f"🔪今晚选择的目标为: {self.state.killed.name}")
         else:
-            await w.broadcast("狼人阵营意见未统一，此晚空刀")
+            await w.broadcast("⚠️狼人阵营意见未统一，此晚空刀")
 
         # 如果女巫存活，正常交互，限时1分钟
         if players.include(Role.Witch):
             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):
@@ -224,15 +243,16 @@ class Game:
         if not players:
             return
 
-        await asyncio.gather(
-            players.broadcast(
-                "你已加入死者频道，请勿在群内继续发言\n"
-                "私聊发送消息将转发至其他已死亡玩家"
-            ),
-            self.players.dead()
-            .exclude(*players)
-            .broadcast(f"玩家 {', '.join(p.name for p in players)} 加入了死者频道"),
-        )
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(
+                players.broadcast,
+                "ℹ️你已加入死者频道，请勿在群内继续发言\n"
+                "私聊发送消息将转发至其他已死亡玩家",
+            )
+            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):
@@ -245,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, 60)
-                self.state.shoot = (None, None)
+                await self.wait_stop(shoot, timeout_secs=60)
+                self.state.shoot = shooter.selected = None
                 await self.post_kill(shoot)
 
     async def run_vote(self) -> None:
@@ -262,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]] = {}
         # 收集到的总票数
@@ -271,34 +291,35 @@ class Game:
         logger.debug(f"投票结果: {vote_result}")
 
         # 投票结果公示
-        msg = UniMessage.text("投票结果:\n")
+        msg = UniMessage.text("📊投票结果:\n")
         for p, v in sorted(vote_result.items(), key=lambda x: len(x[1]), reverse=True):
             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):
-            msg.text(f"弃票: {v} 票\n")
-        await self.send(msg)
+        if (v := (len(players) - total_votes)) > 0:
+            msg.text(f"弃票: {v} 票\n\n")
 
         # 全员弃票  # 不是哥们？
         if total_votes == 0:
-            await self.send("没有人被票出")
+            await self.send(msg.text("🔨没有人被投票放逐"))
             return
 
         # 弃票大于最高票
         if (len(players) - total_votes) >= max(vote_reversed.keys()):
-            await self.send("弃票数大于最高票数, 没有人被票出")
+            await self.send(msg.text("🔨弃票数大于最高票数, 没有人被投票放逐"))
             return
 
         # 平票
         if len(vs := vote_reversed[max(vote_reversed.keys())]) != 1:
             await self.send(
-                UniMessage.text("玩家 ")
+                msg.text("🔨玩家 ")
                 .text(", ".join(p.name for p in vs))
-                .text(" 平票, 没有人被票出")
+                .text(" 平票, 没有人被投票放逐")
             )
             return
 
+        await self.send(msg.rstrip("\n"))
+
         # 仅有一名玩家票数最高
         voted = vs.pop()
         if not await voted.kill(KillReason.Vote, *vote_result[voted]):
@@ -307,68 +328,82 @@ class Game:
 
         # 遗言
         await self.send(
-            UniMessage.text("玩家 ")
+            UniMessage.text("🔨玩家 ")
             .at(voted.user_id)
             .text(" 被投票放逐, 请发表遗言\n")
-            .text("限时1分钟, 发送 “/stop” 结束发言")
+            .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
         )
-        await self.wait_stop(voted, 60)
+        await self.wait_stop(voted, timeout_secs=60)
         await self.post_kill(voted)
 
-    async def run_dead_channel(self) -> None:
-        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 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 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 (
@@ -390,41 +425,46 @@ 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("昨晚是平安夜"))
             # 有玩家死亡，公布死者名单
             else:
-                msg.text("昨晚的死者是:")
-                for p in dead.sorted():
+                msg.text("☠️昨晚的死者是:")
+                for p in dead.sorted:
                     msg.text("\n").at(p.user_id)
                 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请被狼人杀死的 ")
+                    UniMessage.text("⚙️当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
                     .text(" 发表遗言\n")
-                    .text("限时1分钟, 发送 “/stop” 结束发言")
+                    .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
                 )
-                await self.wait_stop(killed, 60)
+                await self.wait_stop(killed, timeout_secs=60)
             await self.post_kill(dead)
 
             # 判断游戏状态
             self.check_game_status()
 
             # 公示存活玩家
-            await self.send(f"当前存活玩家: \n\n{self.players.alive().show()}")
+            await self.send(f"📝当前存活玩家: \n\n{self.players.alive().show()}")
 
             # 开始自由讨论
-            await self.send("接下来开始自由讨论\n限时2分钟, 全员发送 “/stop” 结束发言")
-            await self.wait_stop(self.players.alive(), 120)
+            await self.send(
+                "💬接下来开始自由讨论\n限时2分钟, "
+                f"全员发送 “{STOP_COMMAND_PROMPT}” 结束发言"
+            )
+            await self.wait_stop(*self.players.alive(), timeout_secs=120)
 
             # 开始投票
-            await self.send("讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互")
+            await self.send(
+                "🗳️讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互"
+            )
             await self.run_vote()
 
             # 判断游戏状态
@@ -438,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)):
@@ -445,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)
-                await self.send(msg)
+                logger.exception(msg)
+                await self.send(f"❌狼人杀游戏进程出现未知错误: {err!r}")
             finally:
-                dead_channel.cancel()
-                running_games.pop(self.group.id, None)
+                finished.set()
 
-        def daemon_callback(task: asyncio.Task[None]) -> None:
-            if err := task.exception():
-                logger.opt(exception=err).error(
-                    f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
-                )
-
-        running_games[self.group.id] = self
-        asyncio.create_task(daemon()).add_done_callback(daemon_callback)
+        finished = anyio.Event()
+        self.running_games.add(self)
+        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/__init__.py

@@ -0,0 +1,2 @@
+from . import message_in_game as message_in_game
+from . import start_game as start_game