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

nonebot_plugin_werewolf/game.py

@@ -1,29 +1,43 @@
 import contextlib
+import functools
 import secrets
-from typing import ClassVar, NoReturn
+from collections import defaultdict
+from typing import NoReturn
 
 import anyio
-import anyio.abc
+import nonebot
 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 .config import PresetData
-from .constant import STOP_COMMAND_PROMPT, game_status_conv, report_text, role_name_conv
+from .config import GameBehavior, PresetData
+from .constant import GAME_STATUS_CONV, REPORT_TEXT, ROLE_EMOJI, ROLE_NAME_CONV
 from .exception import GameFinished
 from .models import GameState, GameStatus, KillInfo, KillReason, Role, RoleGroup
 from .player_set import PlayerSet
 from .players import Player
-from .utils import InputStore, ObjectStream, link
+from .utils import InputStore, ObjectStream, SendHandler, add_stop_button, link
+
+logger = nonebot.logger.opt(colors=True)
+starting_games: dict[Target, dict[str, str]] = {}
+running_games: set["Game"] = set()
+
+
+def get_starting_games() -> dict[Target, dict[str, str]]:
+    return starting_games
+
+
+def get_running_games() -> set["Game"]:
+    return running_games
 
 
 def init_players(bot: Bot, game: "Game", players: set[str]) -> PlayerSet:
-    logger.opt(colors=True).debug(f"初始化 <c>{game.group.id}</c> 的玩家职业")
-    preset_data = PresetData.load()
+    # group.colored_name not available yet
+    logger.debug(f"初始化 <c>{game.group_id}</c> 的玩家职业")
+
+    preset_data = PresetData.get()
     if (preset := preset_data.role_preset.get(len(players))) is None:
         raise ValueError(
             f"玩家人数不符: "
@@ -35,11 +49,11 @@ def init_players(bot: Bot, game: "Game", players: set[str]) -> PlayerSet:
     roles: list[Role] = []
     roles.extend(preset_data.werewolf_priority[:w])
     roles.extend(preset_data.priesthood_proirity[:p])
-    roles.extend([Role.Civilian] * c)
+    roles.extend([Role.CIVILIAN] * c)
 
-    if c >= 2 and secrets.randbelow(100) <= preset_data.joker_probability * 100:
-        roles.remove(Role.Civilian)
-        roles.append(Role.Joker)
+    if c >= 2 and secrets.randbelow(100) <= preset_data.jester_probability * 100:
+        roles.remove(Role.CIVILIAN)
+        roles.append(Role.JESTER)
 
     def _select_role() -> Role:
         return roles.pop(secrets.randbelow(len(roles)))
@@ -47,33 +61,43 @@ def init_players(bot: Bot, game: "Game", players: set[str]) -> PlayerSet:
     player_set = PlayerSet(
         Player.new(_select_role(), bot, game, user_id) for user_id in players
     )
-    logger.debug(f"职业分配完成: {player_set}")
+    logger.debug(f"职业分配完成: <e>{escape_tag(str(player_set))}</e>")
 
     return player_set
 
 
+class _SendHandler(SendHandler[str | None]):
+    def solve_msg(
+        self,
+        msg: UniMessage,
+        stop_btn_label: str | None = None,
+    ) -> UniMessage:
+        if stop_btn_label is not None:
+            msg = add_stop_button(msg, stop_btn_label)
+        return msg
+
+
 class DeadChannel:
     players: PlayerSet
     finished: anyio.Event
     counter: dict[str, int]
     stream: ObjectStream[tuple[Player, UniMessage]]
-    task_group: anyio.abc.TaskGroup
 
     def __init__(self, players: PlayerSet, finished: anyio.Event) -> None:
         self.players = players
         self.finished = finished
-        self.counter = {p.user_id: 0 for p in self.players}
+        self.counter = {p.user_id: 0 for p in players}
         self.stream = ObjectStream[tuple[Player, UniMessage]](16)
 
     async def _decrease(self, user_id: str) -> None:
         await anyio.sleep(60)
         self.counter[user_id] -= 1
 
-    async def _handle_finished(self) -> None:
+    async def _wait_finished(self) -> None:
         await self.finished.wait()
-        self.task_group.cancel_scope.cancel()
+        self._task_group.cancel_scope.cancel()
 
-    async def _handle_send(self) -> None:
+    async def _broadcast(self) -> NoReturn:
         while True:
             player, msg = await self.stream.recv()
             msg = f"玩家 {player.name}:\n" + msg
@@ -84,7 +108,7 @@ class DeadChannel:
                 with contextlib.suppress(Exception):
                     await player.send(f"消息转发失败: {err!r}")
 
-    async def _handle_recv(self, player: Player) -> NoReturn:
+    async def _receive(self, player: Player) -> NoReturn:
         await player.killed.wait()
         user_id = player.user_id
 
@@ -100,30 +124,27 @@ class DeadChannel:
 
         while True:
             msg = await player.receive()
+            self.counter[user_id] += 1
+            self._task_group.start_soon(self._decrease, user_id)
 
             # 发言频率限制
-            self.counter[user_id] += 1
-            if self.counter[user_id] > 8:
+            if self.counter[user_id] > GameBehavior.get().dead_channel_rate_limit:
                 await player.send("❌发言频率超过限制, 该消息被屏蔽")
                 continue
 
             # 推送消息
             await self.stream.send((player, msg))
-            self.task_group.start_soon(self._decrease, user_id)
 
     async def run(self) -> NoReturn:
         async with anyio.create_task_group() as tg:
-            self.task_group = tg
-            tg.start_soon(self._handle_finished)
-            tg.start_soon(self._handle_send)
+            self._task_group = tg
+            tg.start_soon(self._wait_finished)
+            tg.start_soon(self._broadcast)
             for p in self.players:
-                tg.start_soon(self._handle_recv, p)
+                tg.start_soon(self._receive, p)
 
 
 class Game:
-    starting_games: ClassVar[dict[Target, dict[str, str]]] = {}
-    running_games: ClassVar[set[Self]] = set()
-
     bot: Bot
     group: Target
     players: PlayerSet
@@ -146,103 +167,108 @@ class Game:
         self.killed_players = []
         self._player_map = {p.user_id: p for p in self.players}
         self._scene = None
+        self._finished = None
         self._task_group = None
+        self._send_handler = _SendHandler()
+        self._send_handler.update(group)
 
     async def _fetch_group_scene(self) -> None:
-        scene = await self.interface.get_scene(SceneType.GROUP, self.group.id)
+        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)
+            scene = await self.interface.get_scene(SceneType.GUILD, self.group_id)
 
         self._scene = scene
 
+    @functools.cached_property
+    def group_id(self) -> str:
+        return self.group.id
+
     @property
     def colored_name(self) -> str:
-        name = f"<b><e>{escape_tag(self.group.id)}</e></b>"
+        name = f"<b><e>{escape_tag(self.group_id)}</e></b>"
         if self._scene and self._scene.name is not None:
             name = f"<y>{escape_tag(self._scene.name)}</y>({name})"
         return link(name, self._scene and self._scene.avatar)
 
-    async def send(self, message: str | UniMessage) -> Receipt:
+    def log(self, text: str) -> None:
+        logger.info(f"{self.colored_name} | {text}")
+
+    async def send(
+        self,
+        message: str | UniMessage,
+        stop_btn_label: str | None = None,
+    ) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
 
-        text = f"{self.colored_name} | <g>Send</g> | "
+        text = ["<g>Send</g> | "]
         for seg in message:
             if isinstance(seg, At):
                 name = seg.target
                 if name in self._player_map:
                     name = self._player_map[name].colored_name
-                text += f"<y>@{name}</y>"
+                text.append(f"<y>@{name}</y>")
             else:
-                text += escape_tag(str(seg)).replace("\n", "\\n")
+                text.append(escape_tag(str(seg)).replace("\n", "\\n"))
 
-        logger.opt(colors=True).info(text)
-        return await message.send(self.group, self.bot)
+        self.log("".join(text))
+        return await self._send_handler.send(message, stop_btn_label)
 
     def raise_for_status(self) -> None:
         players = self.players.alive()
-        w = players.select(RoleGroup.Werewolf)
-        p = players.exclude(RoleGroup.Werewolf)
+        w = players.select(RoleGroup.WEREWOLF)
+        p = players.exclude(RoleGroup.WEREWOLF)
 
         # 狼人数量大于其他职业数量
         if w.size >= p.size:
-            raise GameFinished(GameStatus.Werewolf)
+            raise GameFinished(GameStatus.WEREWOLF)
         # 屠边-村民/中立全灭
-        if not p.select(Role.Civilian, RoleGroup.Others).size:
-            raise GameFinished(GameStatus.Werewolf)
+        if not p.select(Role.CIVILIAN, RoleGroup.OTHERS).size:
+            raise GameFinished(GameStatus.WEREWOLF)
         # 屠边-神职全灭
-        if not p.exclude(Role.Civilian).size:
-            raise GameFinished(GameStatus.Werewolf)
+        if not p.exclude(Role.CIVILIAN, RoleGroup.OTHERS).size:
+            raise GameFinished(GameStatus.WEREWOLF)
         # 狼人全灭
         if not w.size:
-            raise GameFinished(GameStatus.GoodGuy)
+            raise GameFinished(GameStatus.GOODGUY)
 
     async def notify_player_role(self) -> None:
         msg = UniMessage()
         for p in sorted(self.players, key=lambda p: p.user_id):
             msg.at(p.user_id)
 
-        w, p, c = PresetData.load().role_preset[len(self.players)]
+        w, p, c = PresetData.get().role_preset[len(self.players)]
         msg = (
             msg.text("\n\n📝正在分配职业，请注意查看私聊消息\n")
             .text(f"当前玩家数: {len(self.players)}\n")
             .text(f"职业分配: 狼人x{w}, 神职x{p}, 平民x{c}")
         )
 
+        if GameBehavior.get().show_roles_list_on_start:
+            role_cnt: dict[Role, int] = defaultdict(lambda: 0)
+            for role in sorted((p.role for p in self.players), key=lambda r: r.value):
+                role_cnt[role] += 1
+
+            msg.text("\n\n📚职业列表:\n")
+            for role, cnt in role_cnt.items():
+                msg.text(f"- {ROLE_EMOJI[role]}{ROLE_NAME_CONV[role]}x{cnt}\n")
+
         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_stop(
+        self,
+        *players: Player,
+        timeout_secs: float | None = None,
+    ) -> None:
+        if timeout_secs is None:
+            timeout_secs = GameBehavior.get().timeout.speak
         with anyio.move_on_after(timeout_secs):
             async with anyio.create_task_group() as tg:
                 for p in players:
-                    tg.start_soon(InputStore.fetch_until_stop, p.user_id, self.group.id)
-
-    async def interact(
-        self,
-        player_type: Player | Role | RoleGroup,
-        timeout_secs: float,
-    ) -> None:
-        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:
-            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}交互超时")
+                    tg.start_soon(InputStore.fetch_until_stop, p.user_id, self.group_id)
 
     async def post_kill(self, players: Player | PlayerSet) -> None:
         if isinstance(players, Player):
@@ -252,81 +278,72 @@ class Game:
 
         for player in players.dead():
             await player.post_kill()
-            if player.kill_info is not None:
-                self.killed_players.append((player.name, player.kill_info))
+            if player.kill_info is None:
+                continue
 
+            self.killed_players.append((player.name, player.kill_info))
             shooter = self.state.shoot
             if shooter is not None and (shoot := shooter.selected) is not None:
                 await self.send(
                     UniMessage.text("🔫玩家 ")
                     .at(shoot.user_id)
-                    .text(f" 被{shooter.role_name}射杀, 请发表遗言\n")
-                    .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
+                    .text(f" 被{shooter.name}射杀, 请发表遗言\n")
+                    .text(GameBehavior.get().timeout.speak_timeout_prompt)
                 )
-                await self.wait_stop(shoot, timeout_secs=60)
+                await self.wait_stop(shoot)
                 self.state.shoot = shooter.selected = None
                 await self.post_kill(shoot)
 
-    async def select_killed(self) -> None:
-        players = self.players.alive()
-        self.state.killed = None
-
-        w = players.select(RoleGroup.Werewolf)
-        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}")
-        else:
-            await w.broadcast("⚠️狼人阵营意见未统一，此晚空刀")
-
-        # 如果女巫存活，正常交互，限时1分钟
-        if players.include(Role.Witch):
-            await self.interact(Role.Witch, 60)
-        # 否则等待 5-20s
-        else:
-            await anyio.sleep(5 + secrets.randbelow(15))
-
     async def run_night(self, players: PlayerSet) -> Player | None:
-        # 狼人、预言家、守卫 同时交互，女巫在狼人后交互
         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,
-                "ℹ️请等待其他玩家结束交互...",
+            for p in players:
+                tg.start_soon(p.interact)
+
+        # 狼人击杀目标
+        if (
+            (killed := self.state.killed) is not None  # 狼人未空刀
+            and killed not in self.state.protected  # 守卫保护
+            and killed not in self.state.antidote  # 女巫使用解药
+        ):
+            # 狼人正常击杀玩家
+            await killed.kill(
+                KillReason.WEREWOLF,
+                *players.select(RoleGroup.WEREWOLF),
             )
+        else:
+            killed = None
 
-            # 狼人击杀目标
-            if (
-                (killed := self.state.killed) is not None  # 狼人未空刀
-                and killed not in self.state.protected  # 守卫保护
-                and killed not in self.state.antidote  # 女巫使用解药
-            ):
-                # 狼人正常击杀玩家
-                await killed.kill(
-                    KillReason.Werewolf,
-                    *players.select(RoleGroup.Werewolf),
-                )
+        # 女巫操作目标
+        for witch in self.state.poison:
+            if witch.selected is None:
+                continue
+            if witch.selected not in self.state.protected:  # 守卫未保护
+                # 女巫毒杀玩家
+                await witch.selected.kill(KillReason.POISON, witch)
+
+        return killed
 
-            # 女巫操作目标
-            for witch in self.state.poison:
-                if witch.selected is None:
-                    continue
-                if witch.selected not in self.state.protected:  # 守卫未保护
-                    # 女巫毒杀玩家
-                    await witch.selected.kill(KillReason.Poison, witch)
+    async def run_discussion(self) -> None:
+        behavior = GameBehavior.get()
+        timeout = behavior.timeout
 
-            return killed
+        if not behavior.speak_in_turn:
+            speak_timeout = timeout.group_speak
+            await self.send(
+                f"💬接下来开始自由讨论\n{timeout.group_speak_timeout_prompt}",
+                stop_btn_label="结束发言",
+            )
+            await self.wait_stop(*self.players.alive(), timeout_secs=speak_timeout)
+        else:
+            await self.send("💬接下来开始自由讨论")
+            speak_timeout = timeout.speak
+            for player in self.players.alive().sorted:
+                await self.send(
+                    f"💬轮到你发言\n{timeout.speak_timeout_prompt}",
+                    stop_btn_label="结束发言",
+                )
+                await self.wait_stop(player, timeout_secs=speak_timeout)
+            await self.send("💬所有玩家发言结束")
 
     async def run_vote(self) -> None:
         # 筛选当前存活玩家
@@ -339,16 +356,21 @@ class Game:
         # 收集到的总票数
         total_votes = sum(map(len, vote_result.values()))
 
-        logger.debug(f"投票结果: {vote_result}")
+        logger.debug(f"投票结果: {escape_tag(str(vote_result))}")
 
         # 投票结果公示
         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)) > 0:
-            msg.text(f"弃票: {v} 票\n\n")
+        for player, votes in sorted(
+            vote_result.items(),
+            key=lambda x: len(x[1]),
+            reverse=True,
+        ):
+            if player is not None:
+                msg.at(player.user_id).text(f": {len(votes)} 票\n")
+                vote_reversed.setdefault(len(votes), []).append(player)
+        if (discarded_votes := (len(players) - total_votes)) > 0:
+            msg.text(f"弃票: {discarded_votes} 票\n")
+        msg.text("\n")
 
         # 全员弃票  # 不是哥们？
         if total_votes == 0:
@@ -373,7 +395,7 @@ class Game:
 
         # 仅有一名玩家票数最高
         voted = vs.pop()
-        if not await voted.kill(KillReason.Vote, *vote_result[voted]):
+        if not await voted.kill(KillReason.VOTE, *vote_result[voted]):
             # 投票放逐失败 (例: 白痴)
             return
 
@@ -382,9 +404,10 @@ class Game:
             UniMessage.text("🔨玩家 ")
             .at(voted.user_id)
             .text(" 被投票放逐, 请发表遗言\n")
-            .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
+            .text(GameBehavior.get().timeout.speak_timeout_prompt),
+            stop_btn_label="结束发言",
         )
-        await self.wait_stop(voted, timeout_secs=60)
+        await self.wait_stop(voted)
         await self.post_kill(voted)
 
     async def mainloop(self) -> NoReturn:
@@ -395,12 +418,16 @@ class Game:
         while True:
             # 重置游戏状态，进入下一夜
             self.state.reset()
+            self.state.state = GameState.State.NIGHT
             await self.send("🌙天黑请闭眼...")
             players = self.players.alive()
+
+            # 夜间交互，返回狼人目标
             killed = await self.run_night(players)
 
             # 公告
             self.state.day += 1
+            self.state.state = GameState.State.DAY
             msg = UniMessage.text(f"『第{self.state.day}天』☀️天亮了...\n")
             # 没有玩家死亡，平安夜
             if not (dead := players.dead()):
@@ -418,9 +445,10 @@ class Game:
                     UniMessage.text("⚙️当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
                     .text(" 发表遗言\n")
-                    .text(f"限时1分钟, 发送 “{STOP_COMMAND_PROMPT}” 结束发言")
+                    .text(GameBehavior.get().timeout.speak_timeout_prompt),
+                    stop_btn_label="结束发言",
                 )
-                await self.wait_stop(killed, timeout_secs=60)
+                await self.wait_stop(killed)
             await self.post_kill(dead)
 
             # 判断游戏状态
@@ -430,70 +458,69 @@ class Game:
             await self.send(f"📝当前存活玩家: \n\n{self.players.alive().show()}")
 
             # 开始自由讨论
-            await self.send(
-                "💬接下来开始自由讨论\n限时2分钟, "
-                f"全员发送 “{STOP_COMMAND_PROMPT}” 结束发言"
-            )
-            await self.wait_stop(*self.players.alive(), timeout_secs=120)
+            await self.run_discussion()
 
             # 开始投票
             await self.send(
                 "🗳️讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互"
             )
+            self.state.state = GameState.State.VOTE
             await self.run_vote()
 
             # 判断游戏状态
             self.raise_for_status()
 
     async def handle_game_finish(self, status: GameStatus) -> None:
-        msg = UniMessage.text(f"🎉游戏结束，{game_status_conv[status]}获胜\n\n")
+        msg = UniMessage.text(f"🎉游戏结束，{GAME_STATUS_CONV[status]}获胜\n\n")
         for p in sorted(self.players, key=lambda p: (p.role.value, p.user_id)):
             msg.at(p.user_id).text(f": {p.role_name}\n")
         await self.send(msg)
 
         report: list[str] = ["📌玩家死亡报告:"]
         for name, info in self.killed_players:
-            emoji, action = report_text[info.reason]
+            emoji, action = REPORT_TEXT[info.reason]
             report.append(f"{emoji} {name} 被 {', '.join(info.killers)} {action}")
         await self.send("\n\n".join(report))
 
-    async def daemon(self, finished: anyio.Event) -> None:
+    async def run_daemon(self) -> None:
         try:
             await self.mainloop()
         except anyio.get_cancelled_exc_class():
-            logger.warning(f"{self.group.id} 的狼人杀游戏进程被取消")
+            logger.warning(f"{self.colored_name} 的狼人杀游戏进程被取消")
         except GameFinished as result:
             await self.handle_game_finish(result.status)
-            logger.info(f"{self.group.id} 的狼人杀游戏进程正常退出")
+            logger.info(f"{self.colored_name} 的狼人杀游戏进程正常退出")
         except Exception as err:
-            msg = f"{self.group.id} 的狼人杀游戏进程出现未知错误: {err!r}"
+            msg = f"{self.colored_name} 的狼人杀游戏进程出现未知错误: {err!r}"
             logger.exception(msg)
             await self.send(f"❌狼人杀游戏进程出现未知错误: {err!r}")
         finally:
-            finished.set()
+            if self._finished is not None:
+                self._finished.set()
 
     async def start(self) -> None:
         await self._fetch_group_scene()
-        finished = anyio.Event()
-        dead_channel = DeadChannel(self.players, finished)
-        self.running_games.add(self)
+        self._finished = anyio.Event()
+        dead_channel = DeadChannel(self.players, self._finished)
+        get_running_games().add(self)
 
         try:
             async with anyio.create_task_group() as tg:
                 self._task_group = tg
-                tg.start_soon(self.daemon, finished)
+                tg.start_soon(self.run_daemon)
                 tg.start_soon(dead_channel.run)
         except anyio.get_cancelled_exc_class():
-            logger.warning(f"{self.group.id} 的狼人杀游戏进程被取消")
+            logger.warning(f"{self.colored_name} 的狼人杀游戏进程被取消")
         except Exception as err:
-            msg = f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
+            msg = f"{self.colored_name} 的狼人杀守护进程出现错误: {err!r}"
             logger.opt(exception=err).error(msg)
         finally:
+            self._finished = None
             self._task_group = None
-            self.running_games.discard(self)
-            InputStore.cleanup(list(self._player_map), self.group.id)
+            get_running_games().discard(self)
+            InputStore.cleanup(list(self._player_map), self.group_id)
 
     def terminate(self) -> None:
         if self._task_group is not None:
-            logger.warning(f"中止 {self.group.id} 的狼人杀游戏进程")
+            logger.warning(f"中止 {self.colored_name} 的狼人杀游戏进程")
             self._task_group.cancel_scope.cancel()

nonebot_plugin_werewolf/matchers/__init__.py

@@ -1,3 +1,4 @@
+from . import edit_behavior as edit_behavior
 from . import edit_preset as edit_preset
 from . import message_in_game as message_in_game
 from . import start_game as start_game

nonebot_plugin_werewolf/matchers/depends.py

@@ -3,27 +3,27 @@ import itertools
 from nonebot.adapters import Bot, Event
 from nonebot_plugin_alconna import MsgTarget, UniMessage
 
-from ..game import Game
+from ..game import Game, get_running_games
 
 
 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])
+            for p in itertools.chain(*[g.players for g in get_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):
+    if game := next(filter(check, get_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) -> bool:
-    if not Game.running_games:
+    if not get_running_games():
         return False
 
     try: