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

nonebot_plugin_werewolf/__init__.py

@@ -10,7 +10,7 @@ from . import matchers as matchers
 from . import players as players
 from .config import Config
 
-__version__ = "1.1.8"
+__version__ = "1.1.10"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",

nonebot_plugin_werewolf/config.py

@@ -56,6 +56,7 @@ class GameBehavior(ConfigFile):
     show_roles_list_on_start: bool = False
     speak_in_turn: bool = False
     dead_channel_rate_limit: int = 8  # per minute
+    werewolf_multi_select: bool = False
 
     class _Timeout(BaseModel):
         prepare: int = Field(default=5 * 60, ge=5 * 60)

nonebot_plugin_werewolf/constant.py

@@ -1,4 +1,5 @@
 import functools
+from typing import TYPE_CHECKING
 
 import nonebot
 
@@ -10,13 +11,17 @@ COMMAND_START = next(
 )
 
 
-@functools.cache
 def stop_command_prompt() -> str:
     from .config import config  # circular import
 
     return COMMAND_START + config.get_stop_command()[0]
 
 
+if not TYPE_CHECKING:
+    stop_command_prompt = functools.cache(stop_command_prompt)
+del TYPE_CHECKING
+
+
 ROLE_NAME_CONV: dict[Role | RoleGroup, str] = {
     Role.WEREWOLF: "狼人",
     Role.WOLFKING: "狼王",

nonebot_plugin_werewolf/game.py

@@ -1,8 +1,9 @@
 import contextlib
 import functools
 import secrets
-from collections import defaultdict
-from typing import NoReturn
+from collections import Counter
+from typing import NoReturn, final
+from typing_extensions import Self
 
 import anyio
 import nonebot
@@ -16,8 +17,8 @@ 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 import Player
 from .player_set import PlayerSet
-from .players import Player
 from .utils import InputStore, ObjectStream, SendHandler, add_stop_button, link
 
 logger = nonebot.logger.opt(colors=True)
@@ -33,9 +34,13 @@ def get_running_games() -> set["Game"]:
     return running_games
 
 
-def init_players(bot: Bot, game: "Game", players: set[str]) -> PlayerSet:
-    # group.colored_name not available yet
-    logger.debug(f"初始化 <c>{game.group_id}</c> 的玩家职业")
+async def init_players(
+    bot: Bot,
+    game: "Game",
+    players: set[str],
+    interface: Interface,
+) -> PlayerSet:
+    logger.debug(f"初始化 {game.colored_name} 的玩家职业")
 
     preset_data = PresetData.get()
     if (preset := preset_data.role_preset.get(len(players))) is None:
@@ -58,11 +63,11 @@ def init_players(bot: Bot, game: "Game", players: set[str]) -> PlayerSet:
     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"职业分配完成: <e>{escape_tag(str(player_set))}</e>")
+    player_set = PlayerSet()
+    for user_id in players:
+        player_set.add(await Player.new(_select_role(), bot, game, user_id, interface))
 
+    logger.debug(f"职业分配完成: <e>{escape_tag(str(player_set))}</e>")
     return player_set
 
 
@@ -135,7 +140,7 @@ class DeadChannel:
             # 推送消息
             await self.stream.send((player, msg))
 
-    async def run(self) -> NoReturn:
+    async def run(self) -> None:
         async with anyio.create_task_group() as tg:
             self._task_group = tg
             tg.start_soon(self._wait_finished)
@@ -148,36 +153,40 @@ class Game:
     bot: Bot
     group: Target
     players: PlayerSet
-    interface: Interface
     state: GameState
     killed_players: list[tuple[str, KillInfo]]
 
-    def __init__(
-        self,
-        bot: Bot,
-        group: Target,
-        players: set[str],
-        interface: Interface,
-    ) -> None:
+    def __init__(self, bot: Bot, group: Target) -> None:
         self.bot = bot
         self.group = group
-        self.players = init_players(bot, 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._player_map: dict[str, Player] = {}
+        self._shuffled: list[Player] = []
         self._scene = None
-        self._finished = None
-        self._task_group = None
-        self._send_handler = _SendHandler()
-        self._send_handler.update(group)
+        self._finished = self._task_group = None
+        self._send_handler = _SendHandler(group, bot)
 
-    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)
+    @final
+    @classmethod
+    async def new(
+        cls,
+        bot: Bot,
+        group: Target,
+        players: set[str],
+        interface: Interface,
+    ) -> Self:
+        self = cls(bot, group)
+
+        self._scene = await interface.get_scene(SceneType.GROUP, self.group_id)
+        if self._scene is None:
+            self._scene = await interface.get_scene(SceneType.GUILD, self.group_id)
+
+        self.players = await init_players(bot, self, players, interface)
+        self._player_map |= {p.user_id: p for p in self.players}
+        self._shuffled = self.players.shuffled
 
-        self._scene = scene
+        return self
 
     @functools.cached_property
     def group_id(self) -> str:
@@ -232,6 +241,10 @@ class Game:
         if not w.size:
             raise GameFinished(GameStatus.GOODGUY)
 
+    @property
+    def behavior(self) -> GameBehavior:
+        return GameBehavior.get()
+
     async def notify_player_role(self) -> None:
         msg = UniMessage()
         for p in sorted(self.players, key=lambda p: p.user_id):
@@ -244,13 +257,10 @@ class Game:
             .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
-
+        if self.behavior.show_roles_list_on_start:
             msg.text("\n\n📚职业列表:\n")
-            for role, cnt in role_cnt.items():
+            counter = Counter(p.role for p in self.players)
+            for role, cnt in sorted(counter.items(), key=lambda x: x[0].value):
                 msg.text(f"- {ROLE_EMOJI[role]}{ROLE_NAME_CONV[role]}x{cnt}\n")
 
         async with anyio.create_task_group() as tg:
@@ -264,7 +274,7 @@ class Game:
         timeout_secs: float | None = None,
     ) -> None:
         if timeout_secs is None:
-            timeout_secs = GameBehavior.get().timeout.speak
+            timeout_secs = self.behavior.timeout.speak
         with anyio.move_on_after(timeout_secs):
             async with anyio.create_task_group() as tg:
                 for p in players:
@@ -280,18 +290,18 @@ class Game:
             await player.post_kill()
             if player.kill_info is None:
                 continue
-
             self.killed_players.append((player.name, player.kill_info))
-            shooter = self.state.shoot
+
+            shooter = self.state.shooter
             if shooter is not None and (shoot := shooter.selected) is not None:
                 await self.send(
                     UniMessage.text("🔫玩家 ")
                     .at(shoot.user_id)
                     .text(f" 被{shooter.name}射杀, 请发表遗言\n")
-                    .text(GameBehavior.get().timeout.speak_timeout_prompt)
+                    .text(self.behavior.timeout.speak_timeout_prompt)
                 )
                 await self.wait_stop(shoot)
-                self.state.shoot = shooter.selected = None
+                self.state.shooter = shooter.selected = None
                 await self.post_kill(shoot)
 
     async def run_night(self, players: PlayerSet) -> Player | None:
@@ -324,25 +334,27 @@ class Game:
         return killed
 
     async def run_discussion(self) -> None:
-        behavior = GameBehavior.get()
-        timeout = behavior.timeout
+        timeout = self.behavior.timeout
 
-        if not behavior.speak_in_turn:
-            speak_timeout = timeout.group_speak
+        if not self.behavior.speak_in_turn:
             await self.send(
                 f"💬接下来开始自由讨论\n{timeout.group_speak_timeout_prompt}",
                 stop_btn_label="结束发言",
             )
-            await self.wait_stop(*self.players.alive(), timeout_secs=speak_timeout)
+            await self.wait_stop(
+                *self.players.alive(),
+                timeout_secs=timeout.group_speak,
+            )
         else:
-            await self.send("💬接下来开始自由讨论")
-            speak_timeout = timeout.speak
-            for player in self.players.alive().sorted:
+            await self.send("💬接下来开始轮流发言")
+            for player in filter(lambda p: p.alive, self._shuffled):
                 await self.send(
-                    f"💬轮到你发言\n{timeout.speak_timeout_prompt}",
+                    UniMessage.text("💬")
+                    .at(player.user_id)
+                    .text(f"\n轮到你发言\n{timeout.speak_timeout_prompt}"),
                     stop_btn_label="结束发言",
                 )
-                await self.wait_stop(player, timeout_secs=speak_timeout)
+                await self.wait_stop(player, timeout_secs=timeout.speak)
             await self.send("💬所有玩家发言结束")
 
     async def run_vote(self) -> None:
@@ -395,7 +407,7 @@ class Game:
 
         # 仅有一名玩家票数最高
         voted = vs.pop()
-        if not await voted.kill(KillReason.VOTE, *vote_result[voted]):
+        if await voted.kill(KillReason.VOTE, *vote_result[voted]) is None:
             # 投票放逐失败 (例: 白痴)
             return
 
@@ -404,7 +416,7 @@ class Game:
             UniMessage.text("🔨玩家 ")
             .at(voted.user_id)
             .text(" 被投票放逐, 请发表遗言\n")
-            .text(GameBehavior.get().timeout.speak_timeout_prompt),
+            .text(self.behavior.timeout.speak_timeout_prompt),
             stop_btn_label="结束发言",
         )
         await self.wait_stop(voted)
@@ -445,7 +457,7 @@ class Game:
                     UniMessage.text("⚙️当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
                     .text(" 发表遗言\n")
-                    .text(GameBehavior.get().timeout.speak_timeout_prompt),
+                    .text(self.behavior.timeout.speak_timeout_prompt),
                     stop_btn_label="结束发言",
                 )
                 await self.wait_stop(killed)
@@ -476,7 +488,7 @@ class Game:
             msg.at(p.user_id).text(f": {p.role_name}\n")
         await self.send(msg)
 
-        report: list[str] = ["📌玩家死亡报告:"]
+        report = ["📌玩家死亡报告:"]
         for name, info in self.killed_players:
             emoji, action = REPORT_TEXT[info.reason]
             report.append(f"{emoji} {name} 被 {', '.join(info.killers)} {action}")
@@ -491,24 +503,21 @@ class Game:
             await self.handle_game_finish(result.status)
             logger.info(f"{self.colored_name} 的狼人杀游戏进程正常退出")
         except Exception as err:
-            msg = f"{self.colored_name} 的狼人杀游戏进程出现未知错误: {err!r}"
-            logger.exception(msg)
+            logger.exception(f"{self.colored_name} 的狼人杀游戏进程出现未知错误")
             await self.send(f"❌狼人杀游戏进程出现未知错误: {err!r}")
         finally:
             if self._finished is not None:
                 self._finished.set()
 
     async def start(self) -> None:
-        await self._fetch_group_scene()
         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.run_daemon)
-                tg.start_soon(dead_channel.run)
+            async with anyio.create_task_group() as self._task_group:
+                self._task_group.start_soon(self.run_daemon)
+                self._task_group.start_soon(dead_channel.run)
         except anyio.get_cancelled_exc_class():
             logger.warning(f"{self.colored_name} 的狼人杀游戏进程被取消")
         except Exception as err:
@@ -518,7 +527,7 @@ class Game:
             self._finished = None
             self._task_group = None
             get_running_games().discard(self)
-            InputStore.cleanup(list(self._player_map), self.group_id)
+            InputStore.cleanup(self._player_map.keys(), self.group_id)
 
     def terminate(self) -> None:
         if self._task_group is not None:

nonebot_plugin_werewolf/matchers/edit_behavior.py

@@ -44,7 +44,7 @@ alc = Alconna(
         help_text="设置游戏开始时是否显示职业列表",
     ),
     Subcommand(
-        "speak_order",
+        "speak_in_turn",
         Args["enabled#是否启用", bool],
         alias={"发言顺序"},
         help_text="设置是否按顺序发言",
@@ -55,6 +55,12 @@ alc = Alconna(
         alias={"死亡聊天"},
         help_text="设置死亡玩家发言频率限制",
     ),
+    Subcommand(
+        "werewolf_multi_select",
+        Args["enabled#是否启用", bool],
+        alias={"狼人多选"},
+        help_text="设置狼人多选时是否从已选玩家中随机选择目标, 为否时将视为空刀",
+    ),
     Subcommand(
         "timeout",
         Subcommand(
@@ -122,7 +128,7 @@ async def set_show_roles(behavior: Behavior, enabled: bool) -> None:
     await finish(f"已{'启用' if enabled else '禁用'}游戏开始时显示职业列表")
 
 
-@edit_behavior.assign("speak_order")
+@edit_behavior.assign("speak_in_turn")
 async def set_speak_order(behavior: Behavior, enabled: bool) -> None:
     behavior.speak_in_turn = enabled
     await finish(f"已{'启用' if enabled else '禁用'}按顺序发言")
@@ -136,6 +142,15 @@ async def set_dead_chat(behavior: Behavior, limit: int) -> None:
     await finish(f"已设置死亡玩家发言限制为 {limit} 次/分钟")
 
 
+@edit_behavior.assign("werewolf_multi_select")
+async def set_werewolf_multi_select(behavior: Behavior, enabled: bool) -> None:
+    behavior.werewolf_multi_select = enabled
+    await finish(
+        f"已{'启用' if enabled else '禁用'}狼人多选\n"
+        "注: 狼人意见未统一时随机选择已选玩家"
+    )
+
+
 @edit_behavior.assign("timeout.prepare")
 async def set_prepare_timeout(behavior: Behavior, time: int) -> None:
     if time < 300:
@@ -193,13 +208,14 @@ async def handle_default(behavior: Behavior) -> None:
         f"游戏开始发送职业列表: {'是' if behavior.show_roles_list_on_start else '否'}",
         f"白天讨论按顺序发言: {'是' if behavior.speak_in_turn else '否'}",
         f"死亡玩家发言转发限制: {behavior.dead_channel_rate_limit} 次/分钟",
+        f"狼人多选(意见未统一时随机选择已选玩家): {'是' if behavior.werewolf_multi_select else '否'}",  # noqa: E501
         "",
         "超时时间设置:",
         f"准备阶段: {timeout.prepare} 秒",
         f"个人发言: {timeout.speak} 秒",
         f"集体发言: {timeout.group_speak} 秒",
-        f"交互阶段: {timeout.interact} 秒",
         f"投票阶段: {timeout.vote} 秒",
+        f"交互阶段: {timeout.interact} 秒",
         f"狼人交互: {timeout.werewolf} 秒",
     ]
     await finish("\n".join(lines))

nonebot_plugin_werewolf/matchers/poke/chronocat_poke.py

@@ -76,7 +76,7 @@ with contextlib.suppress(ImportError):
                 user_id=user_id,
                 group_id=(event.guild and event.guild.id) or event.channel.id,
             )
-            and any(target.verify(group) for group in get_starting_games())
+            and target in get_starting_games()
         )
 
     @on_message(rule=_rule_poke_join).handle()
@@ -86,7 +86,7 @@ with contextlib.suppress(ImportError):
         target: MsgTarget,
     ) -> None:
         user_id = extract_poke_tome(event) or event.get_user_id()
-        players = next(p for g, p in get_starting_games().items() if target.verify(g))
+        players = get_starting_games()[target]
 
         if user_id not in players:
             # XXX:

nonebot_plugin_werewolf/matchers/poke/ob11_poke.py

@@ -50,7 +50,7 @@ with contextlib.suppress(ImportError):
         return (
             (event.target_id == event.self_id)
             and not user_in_game(bot.self_id, user_id, group_id)
-            and any(target.verify(group) for group in get_starting_games())
+            and target in get_starting_games()
         )
 
     @on_notice(rule=_rule_poke_join).handle()
@@ -60,7 +60,7 @@ with contextlib.suppress(ImportError):
         target: MsgTarget,
     ) -> None:
         user_id = event.get_user_id()
-        players = next(p for g, p in get_starting_games().items() if target.verify(g))
+        players = get_starting_games()[target]
 
         if event.group_id is None or user_id in players:
             return

nonebot_plugin_werewolf/matchers/start_game.py

@@ -118,14 +118,15 @@ class PrepareGame:
         self.send_handler = self._SendHandler()
         self.logger = nonebot.logger.opt(colors=True)
         self.shoud_start_game = False
-        self._msg_handler: dict[str, Callable[[], Awaitable[bool | None]]] = {
+        get_starting_games()[self.group] = self.players
+
+        self._handlers: dict[str, Callable[[], Awaitable[bool | None]]] = {
             "开始游戏": self._handle_start,
             "结束游戏": self._handle_end,
             "加入游戏": self._handle_join,
             "退出游戏": self._handle_quit,
             "当前玩家": self._handle_list,
         }
-        get_starting_games()[self.group] = self.players
 
     async def run(self) -> None:
         try:
@@ -163,6 +164,33 @@ class PrepareGame:
             if event is not None:
                 await self.stream.send((event, text, name))
 
+    async def _handle(self) -> None:
+        bot = current_bot.get()
+        superuser = SuperUser()
+
+        while not self.stream.closed:
+            event, text, name = await self.stream.recv()
+            user_id = event.get_user_id()
+            colored = f"<y>{escape_tag(name)}</y>(<c>{escape_tag(user_id)}</c>)"
+            self.current = self._Current(
+                id=user_id,
+                name=name,
+                colored=colored,
+                is_admin=user_id == self.admin_id,
+                is_super_user=await superuser(bot, event),
+            )
+            self.send_handler.update(event)
+
+            # 更新用户名
+            # 当用户通过 chronoca:poke 加入游戏时, 插件无法获取用户名, 原字典值为用户ID
+            if user_id in self.players and self.players.get(user_id) != name:
+                self.logger.debug(f"更新玩家显示名称: {self.current.colored}")
+                self.players[user_id] = name
+
+            handler = self._handlers.get(text)
+            if handler is not None and await handler():
+                return
+
     async def _send(self, msg: str | UniMessage) -> None:
         await self.send_handler.send(msg)
 
@@ -240,33 +268,6 @@ class PrepareGame:
         )
         await self._send("✨当前玩家:\n" + "\n".join(lines))
 
-    async def _handle(self) -> None:
-        bot = current_bot.get()
-        superuser = SuperUser()
-
-        while not self.stream.closed:
-            event, text, name = await self.stream.recv()
-            user_id = event.get_user_id()
-            colored = f"<y>{escape_tag(name)}</y>(<c>{escape_tag(user_id)}</c>)"
-            self.current = self._Current(
-                id=user_id,
-                name=name,
-                colored=colored,
-                is_admin=user_id == self.admin_id,
-                is_super_user=await superuser(bot, event),
-            )
-            self.send_handler.update(event)
-
-            # 更新用户名
-            # 当用户通过 chronoca:poke 加入游戏时, 插件无法获取用户名, 原字典值为用户ID
-            if user_id in self.players and self.players.get(user_id) != name:
-                self.logger.debug(f"更新玩家显示名称: {self.current.colored}")
-                self.players[user_id] = name
-
-            handler = self._msg_handler.get(text)
-            if handler is not None and await handler():
-                return
-
 
 @start_game.handle()
 async def handle_notice(target: MsgTarget) -> None:
@@ -328,5 +329,5 @@ async def handle_start(
         await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
 
     dump_players(target, players)
-    game = Game(bot, target, set(players), interface)
+    game = await Game.new(bot, target, set(players), interface)
     await game.start()

nonebot_plugin_werewolf/models.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 import anyio
 
 if TYPE_CHECKING:
-    from .players import Player
+    from .player import Player
 
 
 class Role(int, Enum):
@@ -57,11 +57,13 @@ class GameState:
     """当前天数记录, 不会被 `reset()` 重置"""
     state: State = State.NIGHT
     """当前游戏状态, 不会被 `reset()` 重置"""
+    _werewolf_interact_count: int = 0
+    """内部属性, 记录当晚狼人交互状态"""
     werewolf_finished: anyio.Event = dataclasses.field(default_factory=anyio.Event)
     """狼人交互是否结束"""
     killed: "Player | None" = None
     """当晚狼人击杀目标, `None` 则为空刀"""
-    shoot: "Player | None" = None
+    shooter: "Player | None" = None
     """当前执行射杀操作的玩家"""
     antidote: set["Player"] = dataclasses.field(default_factory=set)
     """当晚女巫使用解药的目标"""
@@ -72,12 +74,22 @@ class GameState:
 
     def reset(self) -> None:
         self.werewolf_finished = anyio.Event()
+        self._werewolf_interact_count = 0
         self.killed = None
-        self.shoot = None
+        self.shooter = None
         self.antidote = set()
         self.poison = set()
         self.protected = set()
 
+    def werewolf_start(self) -> None:
+        self._werewolf_interact_count += 1
+
+    def werewolf_end(self) -> bool:
+        self._werewolf_interact_count -= 1
+        if self._werewolf_interact_count == 0:
+            self.werewolf_finished.set()
+        return self.werewolf_finished.is_set()
+
 
 @dataclasses.dataclass
 class KillInfo: