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

nonebot_plugin_werewolf/game.py

@@ -1,34 +1,30 @@
 from __future__ import annotations
 
 import asyncio
-import asyncio.timeouts
 import contextlib
 import secrets
-from typing import TYPE_CHECKING, NoReturn
+from typing import TYPE_CHECKING, ClassVar, NoReturn
 
 from nonebot.log import logger
 from nonebot_plugin_alconna import At, Target, UniMessage
 
+from ._timeout import timeout
 from .config import config
 from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, role_name_conv
-from .exception import GameFinishedError
-from .player import Player
+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
 
-starting_games: dict[str, dict[str, str]] = {}
-running_games: dict[str, Game] = {}
-
 
 def init_players(bot: Bot, game: Game, players: dict[str, 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,34 +40,22 @@ 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, players[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[Game]] = set()
+
     bot: Bot
     group: Target
     players: PlayerSet
@@ -112,92 +96,82 @@ class Game:
 
         # 狼人数量大于其他职业数量
         if w.size >= p.size:
-            raise GameFinishedError(GameStatus.Werewolf)
+            raise GameFinished(GameStatus.Werewolf)
         # 屠边-村民/中立全灭
         if not p.select(Role.Civilian, RoleGroup.Others).size:
-            raise GameFinishedError(GameStatus.Werewolf)
+            raise GameFinished(GameStatus.Werewolf)
         # 屠边-神职全灭
         if not p.exclude(Role.Civilian).size:
-            raise GameFinishedError(GameStatus.Werewolf)
+            raise GameFinished(GameStatus.Werewolf)
         # 狼人全灭
         if not w.size:
-            raise GameFinishedError(GameStatus.GoodGuy)
+            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} 票出"
+            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("\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],
         )
 
-    async def wait_stop(
-        self,
-        players: Player | PlayerSet,
-        timeout_secs: float,
-    ) -> None:
-        if isinstance(players, Player):
-            players = PlayerSet([players])
-
+    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":
                     break
 
         with contextlib.suppress(TimeoutError):
-            async with asyncio.timeouts.timeout(timeout_secs):
+            async with timeout(timeout_secs):
                 await asyncio.gather(*[wait(p) for p in players])
 
     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)
+        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]}阵营"
+
+        await players.broadcast(f"✏️{text}交互开始，限时 {timeout_secs/60:.2f} 分钟")
         try:
             await players.interact(timeout_secs)
         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()
@@ -207,9 +181,9 @@ 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):
@@ -226,12 +200,12 @@ class Game:
 
         await asyncio.gather(
             players.broadcast(
-                "你已加入死者频道，请勿在群内继续发言\n"
+                "ℹ️你已加入死者频道，请勿在群内继续发言\n"
                 "私聊发送消息将转发至其他已死亡玩家"
             ),
             self.players.dead()
             .exclude(*players)
-            .broadcast(f"玩家 {', '.join(p.name for p in players)} 加入了死者频道"),
+            .broadcast(f"ℹ️玩家 {', '.join(p.name for p in players)} 加入了死者频道"),
         )
 
     async def post_kill(self, players: Player | PlayerSet) -> None:
@@ -253,7 +227,7 @@ class Game:
                     .text(f" 被{shooter.role_name}射杀, 请发表遗言\n")
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
-                await self.wait_stop(shoot, 60)
+                await self.wait_stop(shoot, timeout_secs=60)
                 self.state.shoot = (None, None)
                 await self.post_kill(shoot)
 
@@ -271,34 +245,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)
+            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(" 平票, 没有人被票出")
             )
             return
 
+        await self.send(msg)
+
         # 仅有一名玩家票数最高
         voted = vs.pop()
         if not await voted.kill(KillReason.Vote, *vote_result[voted]):
@@ -307,15 +282,15 @@ class Game:
 
         # 遗言
         await self.send(
-            UniMessage.text("玩家 ")
+            UniMessage.text("🔨玩家 ")
             .at(voted.user_id)
             .text(" 被投票放逐, 请发表遗言\n")
             .text("限时1分钟, 发送 “/stop” 结束发言")
         )
-        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:
+    async def run_dead_channel(self) -> NoReturn:
         loop = asyncio.get_event_loop()
         queue: asyncio.Queue[tuple[Player, UniMessage]] = asyncio.Queue()
 
@@ -342,7 +317,7 @@ class Game:
                     await queue.put((player, msg))
                     loop.call_later(60, decrease)
                 else:
-                    await player.send("发言频率超过限制, 该消息被屏蔽")
+                    await player.send("❌发言频率超过限制, 该消息被屏蔽")
 
         await asyncio.gather(send(), *[recv(p) for p in self.players])
 
@@ -357,22 +332,22 @@ class Game:
             # 重置游戏状态，进入下一夜
             self.state = GameState(day_count)
             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.select(Role.Witch).broadcast("ℹ️请等待狼人决定目标..."),
                 players.exclude(
                     RoleGroup.Werewolf, Role.Prophet, Role.Witch, Role.Guard
-                ).broadcast("请等待其他玩家结束交互..."),
+                ).broadcast("ℹ️请等待其他玩家结束交互..."),
             )
 
             # 狼人击杀目标
             if (
-                (killed := self.state.killed)  # 狼人未空刀
+                (killed := self.state.killed) is not None  # 狼人未空刀
                 and killed not in self.state.protected  # 守卫保护
                 and killed not in self.state.antidote  # 女巫使用解药
             ):
@@ -383,46 +358,52 @@ class Game:
                 )
 
             # 女巫操作目标
-            for witch, potioned in self.state.poison:
-                if potioned not in self.state.protected:  # 守卫未保护
+            for witch in self.state.poison:
+                if witch.selected is None:
+                    continue
+                if witch.selected not in self.state.protected:  # 守卫未保护
                     # 女巫毒杀玩家
-                    await potioned.kill(KillReason.Poison, witch)
+                    await witch.selected.kill(KillReason.Poison, witch)
 
             day_count += 1
-            msg = UniMessage.text(f"『第{day_count}天』天亮了...\n")
+            msg = UniMessage.text(f"『第{day_count}天』☀️天亮了...\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:
                 await self.send(
-                    UniMessage.text("当前为第一天\n请被狼人杀死的 ")
+                    UniMessage.text("⚙️当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
                     .text(" 发表遗言\n")
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
-                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分钟, 全员发送 “/stop” 结束发言"
+            )
+            await self.wait_stop(*self.players.alive(), timeout_secs=120)
 
             # 开始投票
-            await self.send("讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互")
+            await self.send(
+                "🗳️讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互"
+            )
             await self.run_vote()
 
             # 判断游戏状态
@@ -456,22 +437,22 @@ class Game:
                 game_task.result()
             except asyncio.CancelledError:
                 logger.warning(f"{self.group.id} 的狼人杀游戏进程被取消")
-            except GameFinishedError as result:
+            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)
+                await self.send(f"❌狼人杀游戏进程出现未知错误: {err!r}")
             finally:
                 dead_channel.cancel()
-                running_games.pop(self.group.id, None)
+                self.running_games.discard(self)
 
         def daemon_callback(task: asyncio.Task[None]) -> None:
             if err := task.exception():
-                logger.opt(exception=err).error(
-                    f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
-                )
+                msg = f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
+                logger.opt(exception=err).error(msg)
 
-        running_games[self.group.id] = self
-        asyncio.create_task(daemon()).add_done_callback(daemon_callback)
+        self.running_games.add(self)
+        daemon_task = asyncio.create_task(daemon())
+        daemon_task.add_done_callback(daemon_callback)

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

nonebot_plugin_werewolf/matchers/message_in_game.py

@@ -0,0 +1,15 @@
+from nonebot import on_message
+from nonebot.adapters import Event
+from nonebot_plugin_alconna import MsgTarget, UniMsg
+
+from ..utils import InputStore, rule_in_game
+
+message_in_game = on_message(rule=rule_in_game)
+
+
+@message_in_game.handle()
+async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
+    if target.private:
+        InputStore.put(msg, target.id)
+    else:
+        InputStore.put(msg, event.get_user_id(), target.id)

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

@@ -1,12 +1,12 @@
 import contextlib
 
-from nonebot import on_type
+from nonebot import on_notice
 from nonebot.internal.matcher import current_bot
-from nonebot_plugin_alconna import UniMessage
+from nonebot_plugin_alconna import MsgTarget, UniMessage
 
-from .config import config
-from .game import starting_games
-from .utils import InputStore, user_in_game
+from ..config import config
+from ..game import Game
+from ..utils import InputStore, user_in_game
 
 
 def ob11_ext_enabled() -> bool:
@@ -14,11 +14,11 @@ def ob11_ext_enabled() -> bool:
 
 
 with contextlib.suppress(ImportError):
-    from nonebot.adapters.onebot.v11 import Bot, MessageSegment
+    from nonebot.adapters.onebot.v11 import Bot
     from nonebot.adapters.onebot.v11.event import PokeNotifyEvent
 
     # 游戏内戳一戳等效 "/stop"
-    async def _rule_poke_1(event: PokeNotifyEvent) -> bool:
+    async def _rule_poke_stop(bot: Bot, event: PokeNotifyEvent) -> bool:
         if not config.enable_poke:
             return False
 
@@ -27,19 +27,21 @@ with contextlib.suppress(ImportError):
         return (
             config.enable_poke
             and (event.target_id == event.self_id)
-            and user_in_game(user_id, group_id)
+            and user_in_game(bot.self_id, user_id, group_id)
         )
 
-    @on_type(PokeNotifyEvent, rule=_rule_poke_1).handle()
-    async def handle_poke_1(event: PokeNotifyEvent) -> None:
+    @on_notice(rule=_rule_poke_stop).handle()
+    async def handle_poke_stop(event: PokeNotifyEvent) -> None:
         InputStore.put(
+            msg=UniMessage.text("/stop"),
             user_id=str(event.user_id),
             group_id=str(event.group_id) if event.group_id is not None else None,
-            msg=UniMessage.text("/stop"),
         )
 
     # 准备阶段戳一戳等效加入游戏
-    async def _rule_poke_2(event: PokeNotifyEvent) -> bool:
+    async def _rule_poke_join(
+        bot: Bot, event: PokeNotifyEvent, target: MsgTarget
+    ) -> bool:
         if not config.enable_poke or event.group_id is None:
             return False
 
@@ -47,15 +49,19 @@ with contextlib.suppress(ImportError):
         group_id = str(event.group_id)
         return (
             (event.target_id == event.self_id)
-            and not user_in_game(user_id, group_id)
-            and group_id in starting_games
+            and not user_in_game(bot.self_id, user_id, group_id)
+            and any(target.verify(group) for group in Game.starting_games)
         )
 
-    @on_type(PokeNotifyEvent, rule=_rule_poke_2).handle()
-    async def handle_poke_2(bot: Bot, event: PokeNotifyEvent) -> None:
-        user_id = str(event.user_id)
-        group_id = str(event.group_id)
-        players = starting_games[group_id]
+    @on_notice(rule=_rule_poke_join).handle()
+    async def handle_poke_join(
+        bot: Bot,
+        event: PokeNotifyEvent,
+        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(
@@ -63,7 +69,7 @@ with contextlib.suppress(ImportError):
                 user_id=int(user_id),
             )
             players[user_id] = res.get("card") or res.get("nickname") or user_id
-            await bot.send(event, MessageSegment.at(user_id) + "成功加入游戏")
+            await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
 
     def ob11_ext_enabled() -> bool:
         if not config.enable_poke:

nonebot_plugin_werewolf/matchers/start_game.py

@@ -0,0 +1,56 @@
+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 .._timeout import timeout
+from ..game import Game
+from ..utils import prepare_game, rule_not_in_game
+from .ob11_ext import ob11_ext_enabled
+
+start_game = on_command(
+    "werewolf",
+    rule=to_me() & rule_not_in_game,
+    aliases={"狼人杀"},
+)
+
+
+@start_game.handle()
+async def handle_start_warning(target: MsgTarget) -> None:
+    if target.private:
+        await UniMessage("⚠️请在群组中创建新游戏").finish(reply_to=True)
+
+
+@start_game.handle()
+async def handle_start(
+    bot: Bot,
+    event: Event,
+    target: MsgTarget,
+    session: Uninfo,
+) -> None:
+    admin_id = event.get_user_id()
+    msg = (
+        UniMessage.at(admin_id)
+        .text("\n🎉成功创建游戏\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()
+
+    admin_name = session.user.nick or session.user.name or admin_id
+    if session.member:
+        admin_name = session.member.nick or admin_name
+    players = {admin_id: admin_name}
+
+    try:
+        async with timeout(5 * 60):
+            await prepare_game(event, players)
+    except TimeoutError:
+        await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
+
+    Game(bot, target, players).start()

nonebot_plugin_werewolf/player_set.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import asyncio
-import asyncio.timeouts
+import functools
 from typing import TYPE_CHECKING
 
-from .player import Player
+from ._timeout import timeout
+from .players import Player
 
 if TYPE_CHECKING:
     from nonebot_plugin_alconna.uniseg import UniMessage
@@ -50,20 +51,21 @@ class PlayerSet(set[Player]):
     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 asyncio.timeouts.timeout(timeout_secs):
+        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 asyncio.timeouts.timeout(timeout_secs):
+                async with timeout(timeout_secs):
                     return await player.vote(self)
             except TimeoutError:
-                await player.send("投票超时，将视为弃票")
+                await player.send("⚠️投票超时，将视为弃票")
                 return None
 
         result: dict[Player, list[Player]] = {}
@@ -77,7 +79,7 @@ class PlayerSet(set[Player]):
         await asyncio.gather(*[p.send(message) for p in self])
 
     def show(self) -> str:
-        return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted(), 1))
+        return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted, 1))
 
     def __getitem__(self, __index: int) -> Player:
-        return self.sorted()[__index]
+        return self.sorted[__index]

nonebot_plugin_werewolf/players/__init__.py

@@ -0,0 +1,10 @@
+from .civilian import Civilian as Civilian
+from .guard import Guard as Guard
+from .hunter import Hunter as Hunter
+from .idiot import Idiot as Idiot
+from .joker import Joker as Joker
+from .player import Player as Player
+from .prophet import Prophet as Prophet
+from .werewolf import Werewolf as Werewolf
+from .witch import Witch as Witch
+from .wolfking import WolfKing as WolfKing