nonebot-plugin-werewolf 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

nonebot_plugin_werewolf/__init__.py

@@ -8,7 +8,7 @@ require("nonebot_plugin_waiter")
 from . import matchers as matchers
 from .config import Config
 
-__version__ = "1.0.4"
+__version__ = "1.0.6"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",

nonebot_plugin_werewolf/constant.py

@@ -1,32 +1,36 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from enum import Enum, auto
 from typing import TYPE_CHECKING
 
+from strenum import StrEnum
+
 from .config import config
 
 if TYPE_CHECKING:
     from .player import Player
 
 
-class Role(Enum):
+class Role(StrEnum):
     # 狼人
-    狼人 = auto()
-    狼王 = auto()
+    Werewolf = auto()
+    WolfKing = auto()
 
     # 神职
-    预言家 = auto()
-    女巫 = auto()
-    猎人 = auto()
-    守卫 = auto()
-    白痴 = auto()
+    Prophet = auto()
+    Witch = auto()
+    Hunter = auto()
+    Guard = auto()
+    Idiot = auto()
 
     # 平民
-    平民 = auto()
+    Civilian = auto()
 
 
-class RoleGroup(Enum):
-    狼人 = auto()
-    好人 = auto()
+class RoleGroup(StrEnum):
+    Werewolf = auto()
+    GoodGuy = auto()
 
 
 class KillReason(Enum):
@@ -45,16 +49,33 @@ class GameStatus(Enum):
 @dataclass
 class GameState:
     day: int
-    killed: "Player | None" = None
-    shoot: tuple["Player", "Player"] | tuple[None, None] = (None, None)
-    protected: "Player | None" = None
-    potion: tuple["Player | None", tuple[bool, bool]] = (None, (False, False))
+    killed: Player | None = None
+    shoot: tuple[Player, Player] | tuple[None, None] = (None, None)
+    protected: Player | None = None
+    potion: tuple[Player | None, tuple[bool, bool]] = (None, (False, False))
+
+
+role_name_conv: dict[Role, str] = {
+    Role.Werewolf: "狼人",
+    Role.WolfKing: "狼王",
+    Role.Prophet: "预言家",
+    Role.Witch: "女巫",
+    Role.Hunter: "猎人",
+    Role.Guard: "守卫",
+    Role.Idiot: "白痴",
+    Role.Civilian: "平民",
+}
 
 
+role_group_name_conv: dict[RoleGroup, str] = {
+    RoleGroup.Werewolf: "狼人",
+    RoleGroup.GoodGuy: "好人",
+}
+
 player_preset: dict[int, tuple[int, int, int]] = {
     # 总人数: (狼, 神, 民)
-    6: (1, 3, 2),
-    7: (2, 3, 2),
+    6: (1, 2, 3),
+    7: (2, 2, 3),
     8: (2, 3, 3),
     9: (2, 4, 3),
     10: (3, 4, 3),
@@ -64,3 +85,4 @@ player_preset: dict[int, tuple[int, int, int]] = {
 
 if config.override_preset is not None:
     player_preset |= {i[0]: i[1:] for i in config.override_preset}
+    player_preset |= {i[0]: i[1:] for i in config.override_preset}

nonebot_plugin_werewolf/game.py

@@ -1,16 +1,20 @@
 import asyncio
 import asyncio.timeouts
+import contextlib
 import random
+import time
 
 from nonebot.adapters import Bot
+from nonebot.log import logger
 from nonebot_plugin_alconna import Target, UniMessage
 
 from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, player_preset
 from .player import Player
 from .player_set import PlayerSet
+from .utils import InputStore
 
 starting_games: dict[str, dict[str, str]] = {}
-running_games: dict[str, tuple["Game", asyncio.Task[None]]] = {}
+running_games: dict[str, tuple["Game", asyncio.Task[None], asyncio.Task[None]]] = {}
 
 
 def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
@@ -22,11 +26,19 @@ def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
         )
 
     roles: list[Role] = []
-    roles.extend([Role.狼人, Role.狼人, Role.狼王, Role.狼人][: preset[0]])
-    roles.extend([Role.预言家, Role.女巫, Role.猎人, Role.守卫, Role.白痴][: preset[1]])
-    roles.extend([Role.平民] * preset[2])
+    roles.extend(
+        [Role.Werewolf, Role.Werewolf, Role.WolfKing, Role.Werewolf][: preset[0]]
+    )
+    roles.extend(
+        [Role.Prophet, Role.Witch, Role.Hunter, Role.Guard, Role.Idiot][: preset[1]]
+    )
+    roles.extend([Role.Civilian] * preset[2])
 
-    random.shuffle(roles)
+    r = random.Random(time.time())
+    shuffled: list[Role] = []
+    for _ in range(len(players)):
+        idx = r.randint(0, len(roles) - 1)
+        shuffled.append(roles.pop(idx))
 
     async def selector(target_: Target, b: Bot):
         return target_.self_id == bot.self_id and b is bot
@@ -44,7 +56,7 @@ def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
             ),
             players[user_id],
         )
-        for user_id, role in zip(players, roles)
+        for user_id, role in zip(players, shuffled)
     )
 
 
@@ -65,6 +77,7 @@ class Game:
         self.group = group
         self.players = init_players(bot, self, players)
         self.state = GameState(0)
+        self.killed_players = []
 
     async def send(self, message: str | UniMessage):
         if isinstance(message, str):
@@ -73,20 +86,20 @@ class Game:
 
     def at_all(self) -> UniMessage:
         msg = UniMessage()
-        for p in sorted(self.players, key=lambda p: (p.role.name, p.user_id)):
+        for p in sorted(self.players, key=lambda p: (p.role_name, p.user_id)):
             msg.at(p.user_id)
         return msg
 
     def check_game_status(self) -> GameStatus:
         players = self.players.alive()
-        w = players.select(RoleGroup.狼人)
-        p = players.exclude(RoleGroup.狼人)
+        w = players.select(RoleGroup.Werewolf)
+        p = players.exclude(RoleGroup.Werewolf)
 
         if w.size >= p.size:
             return GameStatus.Bad
-        if not p.select(Role.平民):
+        if not p.select(Role.Civilian):
             return GameStatus.Bad
-        if not p.exclude(Role.平民):
+        if not p.exclude(Role.Civilian):
             return GameStatus.Bad
         if not w.size:
             return GameStatus.Good
@@ -111,7 +124,7 @@ class Game:
                 case KillReason.Shoot:
                     msg += " 射杀"
                 case KillReason.Vote:
-                    msg += " 投票放逐"
+                    msg += " 票出"
             msg += "\n\n"
 
         return msg.strip()
@@ -136,7 +149,15 @@ class Game:
         if isinstance(players, Player):
             players = PlayerSet([players])
 
-        await players.wait_group_stop(self.group.id, timeout_secs)
+        async def wait(p: Player):
+            while True:
+                msg = await InputStore.fetch(p.user_id, self.group.id)
+                if msg.extract_plain_text() == "/stop":
+                    break
+
+        with contextlib.suppress(TimeoutError):
+            async with asyncio.timeouts.timeout(timeout_secs):
+                await asyncio.gather(*[wait(p) for p in players])
 
     async def interact(
         self,
@@ -145,7 +166,7 @@ class Game:
     ) -> None:
         players = self.players.alive().select(type_)
         text = (
-            type_.role.name  # Player
+            type_.role_name  # Player
             if isinstance(type_, Player)
             else (
                 type_.name  # Role
@@ -164,8 +185,8 @@ class Game:
         players = self.players.alive()
         self.state.killed = None
 
-        w = players.select(RoleGroup.狼人)
-        await self.interact(RoleGroup.狼人, 120)
+        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}")
@@ -173,8 +194,8 @@ class Game:
             await w.broadcast("狼人阵营意见未统一，此晚空刀")
 
         # 如果女巫存活，正常交互，限时1分钟
-        if players.include(Role.女巫):
-            await self.interact(Role.女巫, 60)
+        if players.include(Role.Witch):
+            await self.interact(Role.Witch, 60)
         # 否则等待 5-20s
         else:
             await asyncio.sleep(random.uniform(5, 20))
@@ -211,15 +232,15 @@ class Game:
                 await self.send(
                     UniMessage.text("玩家 ")
                     .at(shoot.user_id)
-                    .text(f" 被{shooter.role.name}射杀, 请发表遗言\n")
+                    .text(f" 被{shooter.role_name}射杀, 请发表遗言\n")
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
                 await self.wait_stop(shoot, 60)
+                self.state.shoot = (None, None)
                 await self.post_kill(shoot)
-            self.state.shoot = (None, None)
 
     async def run_vote(self) -> None:
-        # 统计投票结果
+        # 筛选当前存活玩家
         players = self.players.alive()
 
         # 被票玩家: [投票玩家]
@@ -231,9 +252,9 @@ class Game:
 
         # 投票结果公示
         msg = UniMessage.text("投票结果:\n")
-        for p, v in sorted(vote_result.items(), key=lambda x: x[1], reverse=True):
+        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": {v} 票\n")
+                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")
@@ -244,6 +265,11 @@ class Game:
             await self.send("没有人被票出")
             return
 
+        # 弃票大于最高票
+        if (len(players) - total_votes) >= max(vote_reversed.keys()):
+            await self.send("弃票数大于最高票数, 没有人被票出")
+            return
+
         # 平票
         if len(vs := vote_reversed[max(vote_reversed.keys())]) != 1:
             await self.send(
@@ -270,6 +296,7 @@ class Game:
         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 send():
@@ -279,20 +306,29 @@ class Game:
                 await self.players.dead().exclude(player).broadcast(msg)
 
         async def recv(player: Player):
+            counter = 0
+
+            def decrease():
+                nonlocal counter
+                counter -= 1
+
             while True:
                 if not player.killed:
                     await asyncio.sleep(1)
                     continue
                 msg = await player.receive()
-                await queue.put((player, msg))
+                counter += 1
+                if counter <= 10:
+                    await queue.put((player, msg))
+                    loop.call_later(60, decrease)
+                else:
+                    await player.send("发言频率超过限制, 该消息被屏蔽")
 
         await asyncio.gather(send(), *[recv(p) for p in self.players])
 
     async def run(self) -> None:
         # 告知玩家角色信息
         await self.notify_player_role()
-        # 死者频道
-        dead_channel = asyncio.create_task(self.run_dead_channel())
         # 天数记录 主要用于第一晚狼人击杀的遗言
         day_count = 0
 
@@ -305,9 +341,10 @@ class Game:
             # 狼人、预言家、守卫 同时交互，女巫在狼人后交互
             await asyncio.gather(
                 self.select_killed(),
-                players.select(Role.女巫).broadcast("请等待狼人决定目标..."),
-                self.interact(Role.预言家, 60),
-                self.interact(Role.守卫, 60),
+                players.select(Role.Witch).broadcast("请等待狼人决定目标..."),
+                players.select(Role.Civilian).broadcast("请等待其他玩家结束交互..."),
+                self.interact(Role.Prophet, 60),
+                self.interact(Role.Guard, 60),
             )
 
             # 狼人击杀目标
@@ -321,40 +358,42 @@ class Game:
             if killed is not None:
                 # 除非守卫保护或女巫使用解药，否则狼人正常击杀玩家
                 if not ((killed is protected) or (antidote and potioned is killed)):
-                    await killed.kill(KillReason.Kill, *players.select(RoleGroup.狼人))
+                    await killed.kill(
+                        KillReason.Kill, *players.select(RoleGroup.Werewolf)
+                    )
             # 如果女巫使用毒药且守卫未保护，杀死该玩家
             if poison and (potioned is not None) and (potioned is not protected):
-                await potioned.kill(KillReason.Poison, *players.select(Role.女巫))
+                await potioned.kill(KillReason.Poison, *players.select(Role.Witch))
 
             day_count += 1
             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("\n").at(p.user_id)
                 await self.send(msg)
-                await self.post_kill(dead)
-
-            # 判断游戏状态
-            if self.check_game_status() != GameStatus.Unset:
-                break
-
-            # 公示存活玩家
-            await self.send(f"当前存活玩家: \n\n{self.players.alive().show()}")
 
             # 第一晚被狼人杀死的玩家发表遗言
             if day_count == 1 and killed is not None and not killed.alive:
                 await self.send(
                     UniMessage.text("当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
-                    .text(" 发表遗言\n限时1分钟, 发送 “/stop” 结束发言")
+                    .text(" 发表遗言\n")
+                    .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
                 await self.wait_stop(killed, 60)
+            await self.post_kill(dead)
+
+            # 判断游戏状态
+            if self.check_game_status() != GameStatus.Unset:
+                break
+
+            # 公示存活玩家
+            await self.send(f"当前存活玩家: \n\n{self.players.alive().show()}")
 
             # 开始自由讨论
             await self.send("接下来开始自由讨论\n限时2分钟, 全员发送 “/stop” 结束发言")
@@ -365,11 +404,31 @@ class Game:
             await self.run_vote()
 
         # 游戏结束
-        dead_channel.cancel()
         winner = "好人" if self.check_game_status() == GameStatus.Good else "狼人"
         msg = UniMessage.text(f"🎉游戏结束，{winner}获胜\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")
-        msg.text(f"\n{self.show_killed_players()}")
+            msg.at(p.user_id).text(f": {p.role_name}\n")
         await self.send(msg)
-        running_games.pop(self.group.id, None)
+        await self.send(f"玩家死亡报告:\n\n{self.show_killed_players()}")
+
+    def start(self):
+        task = asyncio.create_task(self.run())
+        dead_channel = asyncio.create_task(self.run_dead_channel())
+
+        async def daemon():
+            while not task.done():  # noqa: ASYNC110
+                await asyncio.sleep(1)
+
+            try:
+                task.result()
+            except asyncio.CancelledError as err:
+                logger.warning(f"狼人杀游戏进程被取消: {err}")
+            except Exception as err:
+                msg = f"狼人杀游戏进程出现错误: {err!r}"
+                logger.opt(exception=err).error(msg)
+                await self.send(msg)
+            finally:
+                dead_channel.cancel()
+                running_games.pop(self.group.id, None)
+
+        running_games[self.group.id] = (self, task, asyncio.create_task(daemon()))

nonebot_plugin_werewolf/matchers.py

@@ -62,5 +62,4 @@ async def handle_start(
         del starting_games[target.id]
 
     game = Game(bot=bot, group=target, players=players)
-    task = asyncio.create_task(game.run())
-    running_games[target.id] = (game, task)
+    game.start()

nonebot_plugin_werewolf/player.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 import asyncio
 import asyncio.timeouts
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, ClassVar, TypeVar
+from typing import TYPE_CHECKING, ClassVar, TypeVar, final
 from typing_extensions import override
 
 from nonebot.adapters import Bot
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
 
-from .constant import KillReason, Role, RoleGroup
+from .constant import KillReason, Role, RoleGroup, role_name_conv,role_group_name_conv
 from .utils import InputStore, check_index
 
 if TYPE_CHECKING:
@@ -16,7 +18,7 @@ if TYPE_CHECKING:
 
 
 P = TypeVar("P", bound=type["Player"])
-PLAYER_CLASS: dict[Role, type["Player"]] = {}
+PLAYER_CLASS: dict[Role, type[Player]] = {}
 
 
 def register_role(cls: P) -> P:
@@ -27,7 +29,7 @@ def register_role(cls: P) -> P:
 @dataclass
 class KillInfo:
     reason: KillReason
-    killers: "PlayerSet"
+    killers: PlayerSet
 
 
 class Player:
@@ -35,52 +37,61 @@ class Player:
     role_group: ClassVar[RoleGroup]
 
     bot: Bot
-    game: "Game"
+    game: Game
     user: Target
     name: str
     alive: bool = True
     killed: bool = False
     kill_info: KillInfo | None = None
-    selected: "Player | None" = None
+    selected: Player | None = None
 
-    def __init__(self, bot: Bot, game: "Game", user: Target, name: str) -> None:
+    @final
+    def __init__(self, bot: Bot, game: Game, user: Target, name: str) -> None:
         self.bot = bot
         self.game = game
         self.user = user
         self.name = name
 
+    @final
     @classmethod
     def new(
         cls,
         role: Role,
         bot: Bot,
-        game: "Game",
+        game: Game,
         user: Target,
         name: str,
-    ) -> "Player":
+    ) -> Player:
         if role not in PLAYER_CLASS:
             raise ValueError(f"Unexpected role: {role!r}")
 
         return PLAYER_CLASS[role](bot, game, user, name)
 
     def __repr__(self) -> str:
-        return f"<{self.role.name}: user={self.user} alive={self.alive}>"
+        return f"<{self.role_name}: user={self.user} alive={self.alive}>"
 
     @property
     def user_id(self) -> str:
         return self.user.id
 
+    @property
+    def role_name(self) -> str:
+        return role_name_conv[self.role]
+
+    @final
     async def send(self, message: str | UniMessage) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
 
         return await message.send(target=self.user, bot=self.bot)
 
+    @final
     async def receive(self, prompt: str | UniMessage | None = None) -> UniMessage:
         if prompt:
             await self.send(prompt)
         return await InputStore.fetch(self.user.id)
 
+    @final
     async def receive_text(self) -> str:
         return (await self.receive()).extract_plain_text()
 
@@ -88,13 +99,15 @@ class Player:
         return
 
     async def notify_role(self) -> None:
-        await self.send(f"你的身份: {self.role.name}")
+        await self.send(f"你的身份: {self.role_name}")
 
     async def kill(
         self,
         reason: KillReason,
-        *killers: "Player",
+        *killers: Player,
     ) -> bool:
+        from .player_set import PlayerSet
+
         self.alive = False
         self.kill_info = KillInfo(reason, PlayerSet(killers))
         return True
@@ -102,15 +115,16 @@ class Player:
     async def post_kill(self) -> None:
         self.killed = True
 
-    async def vote(self, players: "PlayerSet") -> "tuple[Player, Player] | None":
+    async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
         await self.send(
             f"请选择需要投票的玩家:\n{players.show()}"
             "\n\n发送编号选择玩家\n发送 “/stop” 弃票"
         )
 
         while True:
-            text = (await self.receive()).extract_plain_text()
+            text = await self.receive_text()
             if text == "/stop":
+                await self.send("你选择了弃票")
                 return None
             index = check_index(text, len(players))
             if index is not None:
@@ -131,9 +145,9 @@ class CanShoot(Player):
             return await super().post_kill()
 
         await self.game.send(
-            UniMessage.text(f"{self.role.name} ")
+            UniMessage.text(f"{self.role_name} ")
             .at(self.user_id)
-            .text(f" 死了\n请{self.role.name}决定击杀目标...")
+            .text(f" 死了\n请{self.role_name}决定击杀目标...")
         )
 
         self.game.state.shoot = (None, None)
@@ -142,14 +156,14 @@ class CanShoot(Player):
         if shoot is not None:
             self.game.state.shoot = (self, shoot)
             await self.send(
-                UniMessage.text(f"{self.role.name} ")
+                UniMessage.text(f"{self.role_name} ")
                 .at(self.user_id)
                 .text(" 射杀了玩家 ")
                 .at(shoot.user_id)
             )
             await shoot.kill(KillReason.Shoot, self)
         else:
-            await self.send(f"{self.role.name}选择了取消技能")
+            await self.send(f"{self.role_name}选择了取消技能")
         return await super().post_kill()
 
     async def shoot(self) -> Player | None:
@@ -178,20 +192,23 @@ class CanShoot(Player):
 
 @register_role
 class 狼人(Player):
-    role: ClassVar[Role] = Role.狼人
-    role_group: ClassVar[RoleGroup] = RoleGroup.狼人
+    role: ClassVar[Role] = Role.Werewolf
+    role_group: ClassVar[RoleGroup] = RoleGroup.Werewolf
 
     @override
     async def notify_role(self) -> None:
         await super().notify_role()
-        partners = self.game.players.alive().select(RoleGroup.狼人).exclude(self)
-        msg = "你的队友:\n" + "\n".join(f"  {p.role.name}: {p.name}" for p in partners)
-        await self.send(msg)
+        partners = self.game.players.alive().select(RoleGroup.Werewolf).exclude(self)
+        if partners:
+            await self.send(
+                "你的队友:\n"
+                + "\n".join(f"  {p.role_name}: {p.name}" for p in partners)
+            )
 
     @override
     async def interact(self) -> None:
         players = self.game.players.alive()
-        partners = players.select(RoleGroup.狼人).exclude(self)
+        partners = players.select(RoleGroup.Werewolf).exclude(self)
 
         # 避免阻塞
         def broadcast(msg: str | UniMessage):
@@ -201,7 +218,7 @@ class 狼人(Player):
         if partners:
             msg = (
                 msg.text("你的队友:\n")
-                .text("\n".join(f"  {p.role.name}: {p.name}" for p in partners))
+                .text("\n".join(f"  {p.role_name}: {p.name}" for p in partners))
                 .text("\n所有私聊消息将被转发至队友\n\n")
             )
         await self.send(
@@ -221,7 +238,7 @@ class 狼人(Player):
             if index is not None:
                 selected = index - 1
                 msg = f"当前选择玩家: {players[selected].name}"
-                await self.send(msg)
+                await self.send(f"{msg}\n发送 “/stop” 结束回合")
                 broadcast(f"队友 {self.name} {msg}")
             if text == "/stop":
                 if selected is not None:
@@ -237,14 +254,14 @@ class 狼人(Player):
 
 @register_role
 class 狼王(CanShoot, 狼人):
-    role: ClassVar[Role] = Role.狼王
-    role_group: ClassVar[RoleGroup] = RoleGroup.狼人
+    role: ClassVar[Role] = Role.WolfKing
+    role_group: ClassVar[RoleGroup] = RoleGroup.Werewolf
 
 
 @register_role
 class 预言家(Player):
-    role: ClassVar[Role] = Role.预言家
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+    role: ClassVar[Role] = Role.Prophet
+    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
 
     @override
     async def interact(self) -> None:
@@ -264,14 +281,14 @@ class 预言家(Player):
             await self.send("输入错误，请发送编号选择玩家")
 
         player = players[selected]
-        result = "狼人" if player.role == Role.狼人 else "好人"
+        result = role_group_name_conv[player.role_group]
         await self.send(f"玩家 {player.name} 的阵营是『{result}』")
 
 
 @register_role
 class 女巫(Player):
-    role: ClassVar[Role] = Role.女巫
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+    role: ClassVar[Role] = Role.Witch
+    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
     antidote: int = 1
     poison: int = 1
 
@@ -296,7 +313,7 @@ class 女巫(Player):
     async def handle_killed(self) -> bool:
         msg = UniMessage()
         if (killed := self.game.state.killed) is not None:
-            msg.text(f"今晚 {killed} 被刀了\n\n")
+            msg.text(f"今晚 {killed.name} 被刀了\n\n")
         else:
             await self.send("今晚没有人被刀")
             return False
@@ -359,14 +376,14 @@ class 女巫(Player):
 
 @register_role
 class 猎人(CanShoot, Player):
-    role: ClassVar[Role] = Role.猎人
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+    role: ClassVar[Role] = Role.Hunter
+    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
 
 
 @register_role
 class 守卫(Player):
-    role: ClassVar[Role] = Role.守卫
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+    role: ClassVar[Role] = Role.Guard
+    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
 
     @override
     async def interact(self) -> None:
@@ -397,8 +414,8 @@ class 守卫(Player):
 
 @register_role
 class 白痴(Player):
-    role: ClassVar[Role] = Role.白痴
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+    role: ClassVar[Role] = Role.Idiot
+    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
     voted: bool = False
 
     @override
@@ -418,7 +435,7 @@ class 白痴(Player):
         return await super().kill(reason, *killers)
 
     @override
-    async def vote(self, players: "PlayerSet") -> "tuple[Player, Player] | None":
+    async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
         if self.voted:
             await self.send("你已经发动过白痴身份的技能，无法参与本次投票")
             return None
@@ -427,5 +444,5 @@ class 白痴(Player):
 
 @register_role
 class 平民(Player):
-    role: ClassVar[Role] = Role.平民
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+    role: ClassVar[Role] = Role.Civilian
+    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy

nonebot_plugin_werewolf/player_set.py

@@ -1,12 +1,10 @@
 import asyncio
 import asyncio.timeouts
-import contextlib
 
 from nonebot_plugin_alconna.uniseg import UniMessage
 
 from .constant import Role, RoleGroup
 from .player import Player
-from .utils import InputStore
 
 
 class PlayerSet(set[Player]):
@@ -52,12 +50,13 @@ class PlayerSet(set[Player]):
             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":
+        async def vote(player: Player) -> tuple[Player, Player] | None:
             try:
                 async with asyncio.timeouts.timeout(timeout_secs):
                     return await player.vote(self)
             except TimeoutError:
                 await player.send("投票超时，将视为弃票")
+                return None
 
         result: dict[Player, list[Player]] = {}
         for item in await asyncio.gather(*[vote(p) for p in self.alive()]):
@@ -69,17 +68,6 @@ class PlayerSet(set[Player]):
     async def broadcast(self, message: str | UniMessage) -> None:
         await asyncio.gather(*[p.send(message) for p in self])
 
-    async def wait_group_stop(self, group_id: str, timeout_secs: float) -> None:
-        async def wait(p: Player):
-            while True:
-                msg = await InputStore.fetch(p.user_id, group_id)
-                if msg.extract_plain_text() == "/stop":
-                    break
-
-        with contextlib.suppress(TimeoutError):
-            async with asyncio.timeouts.timeout(timeout_secs):
-                await asyncio.gather(*[wait(p) for p in self])
-
     def show(self) -> str:
         return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted(), 1))
 

nonebot_plugin_werewolf/utils.py

@@ -9,7 +9,7 @@ from nonebot.rule import to_me
 from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
 from nonebot_plugin_userinfo import EventUserInfo, UserInfo
 
-from .game import player_preset
+from .constant import player_preset
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -47,7 +47,7 @@ def user_in_game(user_id: str, group_id: str | None) -> bool:
     if group_id is not None and group_id not in running_games:
         return False
     games = running_games.values() if group_id is None else [running_games[group_id]]
-    for game, _ in games:
+    for game, *_ in games:
         return any(user_id == player.user_id for player in game.players)
     return False
 
@@ -173,12 +173,12 @@ async def _prepare_game_handle(
 
 
 async def prepare_game(event: Event, players: dict[str, str]) -> None:
-    queue = asyncio.Queue()
+    queue: asyncio.Queue[tuple[str, str, str]] = asyncio.Queue()
     task_receive = asyncio.create_task(
         _prepare_game_receive(
             queue,
             event,
-            UniMessage.get_target().id,
+            UniMessage.get_target(event).id,
         )
     )
 

{nonebot_plugin_werewolf-1.0.4.dist-info → nonebot_plugin_werewolf-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-werewolf
-Version: 1.0.4
+Version: 1.0.6
 Summary: Default template for PDM package
 Author-Email: wyf7685 <wyf7685@163.com>
 License: MIT
@@ -9,6 +9,7 @@ Requires-Dist: nonebot2>=2.3.3
 Requires-Dist: nonebot-plugin-alconna>=0.52.1
 Requires-Dist: nonebot-plugin-userinfo>=0.2.6
 Requires-Dist: nonebot-plugin-waiter>=0.7.1
+Requires-Dist: StrEnum>=0.4.15
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -116,9 +117,18 @@ _✨ 简单的狼人杀插件 ✨_
 
 ### 指令表
 
-|        指令         | 权限 | 需要@ | 范围 |   说明   |
-| :-----------------: | :--: | :---: | :--: | :------: |
-| `werewolf`/`狼人杀` | 群员 |  是   | 群聊 | 发起游戏 |
+|        指令         |    权限    | 需要@ | 范围 |                说明                 |
+| :-----------------: | :--------: | :---: | :--: | :---------------------------------: |
+| `werewolf`/`狼人杀` |    群员    |  是   | 群聊 |       发起游戏 (进入准备阶段)       |
+|     `开始游戏`      | 游戏发起者 |  是   | 群聊 |   _[准备阶段]_ 游戏发起者开始游戏   |
+|     `结束游戏`      | 游戏发起者 |  是   | 群聊 |   _[准备阶段]_ 游戏发起者结束游戏   |
+|     `当前玩家`      |    群员    |  是   | 群聊 | _[准备阶段]_ 列出参与游戏的玩家列表 |
+|     `加入游戏`      |    群员    |  是   | 群聊 |      _[准备阶段]_ 玩家加入游戏      |
+|     `退出游戏`      |    群员    |  是   | 群聊 |      _[准备阶段]_ 玩家退出游戏      |
+
+_其他交互参考游戏内提示_
+
+对于 `OneBot V11` 适配器, 启用配置项 `werewolf__enable_poke` 后, 可以使用戳一戳代替 _准备阶段_ 的 `加入游戏` 操作 和 游戏内的 `/stop` 命令
 
 ### 游戏内容
 
@@ -132,8 +142,8 @@ _✨ 简单的狼人杀插件 ✨_
 
 | 总人数 | 狼人 | 神职 | 平民 |
 | ------ | ---- | ---- | ---- |
-| 6      | 1    | 3    | 2    |
-| 7      | 2    | 3    | 2    |
+| 6      | 1    | 2    | 3    |
+| 7      | 2    | 2    | 3    |
 | 8      | 2    | 3    | 3    |
 | 9      | 2    | 4    | 3    |
 | 10     | 3    | 4    | 3    |
@@ -171,9 +181,14 @@ werewolf__override_preset='
 <details>
     <summary>更新日志</summary>
 
-- 2024.09.01 v1.0.4
+- 2024.09.03 v1.0.6
+
+  - 修复预言家查验狼王返回好人的 bug
+
+- 2024.09.03 v1.0.5
 
   - 优化玩家交互体验
+  - 添加游戏结束后死亡报告
 
 - 2024.08.31 v1.0.1
 

nonebot_plugin_werewolf-1.0.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+nonebot_plugin_werewolf-1.0.6.dist-info/METADATA,sha256=VEQ_yjPRs3bB28Khz98EJA5XTlJ6fMrP_YNZBBp9PQc,6839
+nonebot_plugin_werewolf-1.0.6.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
+nonebot_plugin_werewolf-1.0.6.dist-info/licenses/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
+nonebot_plugin_werewolf/__init__.py,sha256=WEwQN8NtEtOfTrH23_MysaaS4OnCjxtGb-_brG9bGTQ,734
+nonebot_plugin_werewolf/config.py,sha256=3O63P1pjvJEwgOwxApAHbKQzvCR1zoG5UjTClZ_OJts,315
+nonebot_plugin_werewolf/constant.py,sha256=k4r0vKYtePDzAqNOdpAlSXnP37YvJSgmJvmGVoJDdeI,1746
+nonebot_plugin_werewolf/game.py,sha256=oGuqV4zmuX95CH7zjtx7wMFzQjzObWXbnnO8PHSnzYk,15525
+nonebot_plugin_werewolf/matchers.py,sha256=D8F2FsV03YhBfXCUeUJmpSFvMk9Z7F0lKeFx-lRN9To,2281
+nonebot_plugin_werewolf/ob11_ext.py,sha256=I6bPCv5SgAStTJuvBl5F7wqgiksWeFkb4R7n06jXprA,2399
+nonebot_plugin_werewolf/player.py,sha256=KjGtfMT7mZG-ACfn5z2z0UJDlLH6t1-6mls_H4UxtWU,14175
+nonebot_plugin_werewolf/player_set.py,sha256=pEXyjmA7INog23i5-TmuJA559y5eKUehrPxHcnzWCTU,2571
+nonebot_plugin_werewolf/utils.py,sha256=8ddVr_PyObxZ8PfWry_-IXnH2dys2bTowKmHfqVbhPE,6233
+nonebot_plugin_werewolf-1.0.6.dist-info/RECORD,,

nonebot_plugin_werewolf-1.0.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-nonebot_plugin_werewolf-1.0.4.dist-info/METADATA,sha256=AkymAo7r7BJckqlRFyjnFBGYCKhpyREppGHPGFowtx8,5815
-nonebot_plugin_werewolf-1.0.4.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
-nonebot_plugin_werewolf-1.0.4.dist-info/licenses/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
-nonebot_plugin_werewolf/__init__.py,sha256=Ia0RlpR6eFLWMI-0OyLGMbBp5W7Oh6s96r45rGWGtDw,734
-nonebot_plugin_werewolf/config.py,sha256=3O63P1pjvJEwgOwxApAHbKQzvCR1zoG5UjTClZ_OJts,315
-nonebot_plugin_werewolf/constant.py,sha256=kMn5DHXdYuOXeGpJjnG_WX9AD-OytLKXSjrww0T5OYg,1234
-nonebot_plugin_werewolf/game.py,sha256=PI6j-T70Logax87fpmf8HBS3LihF7J40nespvoNFyus,13449
-nonebot_plugin_werewolf/matchers.py,sha256=o0LdO7AOUjTPcNaNTHbmw5d0CcnMc7mX8oko0JT8Np4,2351
-nonebot_plugin_werewolf/ob11_ext.py,sha256=I6bPCv5SgAStTJuvBl5F7wqgiksWeFkb4R7n06jXprA,2399
-nonebot_plugin_werewolf/player.py,sha256=z_yVjqfDOxnQlDtDxSbdmvEapIQikkho2hCjb46zqKY,13799
-nonebot_plugin_werewolf/player_set.py,sha256=ptNZb13H8DgcjQ9tm3uT2ISXnnWioQG1W4R506HlaMU,3057
-nonebot_plugin_werewolf/utils.py,sha256=B8YipTx96k2Y-trrCDfzRQnmHs-yAMcU5-g8FUrRQ64,6186
-nonebot_plugin_werewolf-1.0.4.dist-info/RECORD,,