nonebot-plugin-werewolf 1.1.11__py3-none-any.whl → 1.1.13__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.11"
+__version__ = "1.1.13"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",

nonebot_plugin_werewolf/config.py

@@ -1,10 +1,11 @@
 import json
+import warnings
 from pathlib import Path
 from typing import Any, ClassVar, Final, Literal
 from typing_extensions import Self
 
 import nonebot
-from nonebot.compat import model_dump, type_validate_json
+from nonebot.compat import model_dump, model_validator, type_validate_json
 from nonebot_plugin_localstore import get_plugin_data_file
 from pydantic import BaseModel, Field
 
@@ -12,37 +13,36 @@ from .constant import (
     DEFAULT_PRIESTHOOD_PRIORITY,
     DEFAULT_ROLE_PRESET,
     DEFAULT_WEREWOLF_PRIORITY,
-    stop_command_prompt,
 )
 from .models import Role
 
 
 class ConfigFile(BaseModel):
-    FILE: ClassVar[Path]
-    _cache: ClassVar[Self | None] = None
+    _file_: ClassVar[Path]
+    _cache_: ClassVar[Self | None] = None
 
     def __init_subclass__(cls, **kwargs: Any) -> None:  # noqa: ANN401
         super().__init_subclass__(**kwargs)
-        if not cls.FILE.exists():
+        if not cls._file_.exists():
             cls().save()
 
     @classmethod
     def load(cls) -> Self:
-        return type_validate_json(cls, cls.FILE.read_text())
+        return type_validate_json(cls, cls._file_.read_text())
 
     @classmethod
     def get(cls, *, use_cache: bool = True) -> Self:
-        if cls._cache is None or not use_cache:
-            cls._cache = cls.load()
-        return cls._cache
+        if cls._cache_ is None or not use_cache:
+            cls._cache_ = cls.load()
+        return cls._cache_
 
     def save(self) -> None:
-        self.FILE.write_text(json.dumps(model_dump(self)))
-        type(self)._cache = self  # noqa: SLF001
+        self._file_.write_text(json.dumps(model_dump(self)))
+        type(self)._cache_ = self
 
 
 class PresetData(ConfigFile):
-    FILE: ClassVar[Path] = get_plugin_data_file("preset.json")
+    _file_: ClassVar[Path] = get_plugin_data_file("preset.json")
 
     role_preset: dict[int, tuple[int, int, int]] = DEFAULT_ROLE_PRESET.copy()
     werewolf_priority: list[Role] = DEFAULT_WEREWOLF_PRIORITY.copy()
@@ -50,36 +50,33 @@ class PresetData(ConfigFile):
     jester_probability: float = Field(default=0.0, ge=0.0, le=1.0)
 
 
+class _Timeout(BaseModel):
+    prepare: int = Field(default=5 * 60, ge=5 * 60)
+    speak: int = Field(default=60, ge=60)
+    group_speak: int = Field(default=120, ge=120)
+    interact: int = Field(default=60, ge=60)
+    vote: int = Field(default=60, ge=60)
+    werewolf: int = Field(default=120, ge=120)
+
+    @property
+    def speak_timeout_prompt(self) -> str:
+        return f"限时{self.speak / 60:.1f}分钟, 发送 “{stop_command_prompt}” 结束发言"
+
+    @property
+    def group_speak_timeout_prompt(self) -> str:
+        return (
+            f"限时{self.group_speak / 60:.1f}分钟, "
+            f"全员发送 “{stop_command_prompt}” 结束发言"
+        )
+
+
 class GameBehavior(ConfigFile):
-    FILE: ClassVar[Path] = get_plugin_data_file("behavior.json")
+    _file_: ClassVar[Path] = get_plugin_data_file("behavior.json")
 
     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)
-        speak: int = Field(default=60, ge=60)
-        group_speak: int = Field(default=120, ge=120)
-        interact: int = Field(default=60, ge=60)
-        vote: int = Field(default=60, ge=60)
-        werewolf: int = Field(default=120, ge=120)
-
-        @property
-        def speak_timeout_prompt(self) -> str:
-            return (
-                f"限时{self.speak / 60:.1f}分钟, "
-                f"发送 “{stop_command_prompt()}” 结束发言"
-            )
-
-        @property
-        def group_speak_timeout_prompt(self) -> str:
-            return (
-                f"限时{self.group_speak / 60:.1f}分钟, "
-                f"全员发送 “{stop_command_prompt()}” 结束发言"
-            )
-
     timeout: Final[_Timeout] = _Timeout()
 
 
@@ -94,7 +91,18 @@ class MatcherPriorityConfig(BaseModel):
     preset: int = 1
     behavior: int = 1
     in_game: int = 10
-    stop: int = 10
+    stop: int = 9
+
+    @model_validator(mode="after")
+    @classmethod
+    def _validate(cls, model: Self) -> Self:
+        if model.in_game <= model.stop:
+            model.in_game = model.stop + 1
+            warnings.warn(
+                "in_game 的优先级必须低于 stop，已自动调整为 stop + 1",
+                stacklevel=2,
+            )
+        return model
 
 
 class PluginConfig(BaseModel):
@@ -103,6 +111,7 @@ class PluginConfig(BaseModel):
     stop_command: str | set[str] = "stop"
     require_at: bool | RequireAtConfig = True
     matcher_priority: MatcherPriorityConfig = MatcherPriorityConfig()
+    use_cmd_start: bool | None = None
 
     def get_stop_command(self) -> list[str]:
         return (
@@ -123,3 +132,8 @@ class Config(BaseModel):
 
 config = nonebot.get_plugin_config(Config).werewolf
 nonebot.logger.debug(f"加载插件配置: {config}")
+
+stop_command_prompt = (
+    next(iter(sorted(nonebot.get_driver().config.command_start, key=len)), "")
+    + config.get_stop_command()[0]
+)

nonebot_plugin_werewolf/constant.py

@@ -1,25 +1,8 @@
-import functools
-from typing import TYPE_CHECKING
-
 from .models import GameStatus, KillReason, Role, RoleGroup
 
 STOP_COMMAND = "{{stop}}"
 
 
-def stop_command_prompt() -> str:
-    import nonebot
-
-    from .config import config  # circular import
-
-    cmd_starts = sorted(nonebot.get_driver().config.command_start, key=len)
-    return next(iter(cmd_starts), "") + 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/dead_channel.py

@@ -0,0 +1,79 @@
+import contextlib
+from typing import NoReturn
+
+import anyio
+import anyio.lowlevel
+from nonebot_plugin_alconna import UniMessage
+
+from .config import GameBehavior
+from .player import Player
+from .player_set import PlayerSet
+
+
+class DeadChannel:
+    players: PlayerSet
+    finished: anyio.Event
+    counter: dict[str, int]
+
+    def __init__(self, players: PlayerSet, finished: anyio.Event) -> None:
+        self.players = players
+        self.finished = finished
+        self.counter = {p.user_id: 0 for p in players}
+
+    async def _decrease(self, user_id: str) -> None:
+        await anyio.sleep(60)
+        self.counter[user_id] -= 1
+
+    async def _wait_finished(self) -> None:
+        await self.finished.wait()
+        self._task_group.cancel_scope.cancel()
+
+    async def _broadcast(self) -> NoReturn:
+        stream = self.stream[1]
+        while True:
+            player, msg = await stream.receive()
+            msg = UniMessage.text(f"玩家 {player.name}:\n") + msg
+            target = self.players.killed().exclude(player)
+            try:
+                await target.broadcast(msg)
+            except Exception as err:
+                with contextlib.suppress(Exception):
+                    await player.send(f"消息转发失败: {err!r}")
+
+    async def _receive(self, player: Player) -> NoReturn:
+        await player.killed.wait()
+        await anyio.lowlevel.checkpoint()
+        user_id = player.user_id
+        stream = self.stream[0]
+
+        await player.send(
+            "ℹ️你已加入死者频道，请勿在群组内继续发言\n"
+            "私聊发送消息将转发至其他已死亡玩家",
+        )
+        await (
+            self.players.killed()
+            .exclude(player)
+            .broadcast(f"ℹ️玩家 {player.name} 加入了死者频道")
+        )
+
+        while True:
+            msg = await player.receive()
+            self.counter[user_id] += 1
+            self._task_group.start_soon(self._decrease, user_id)
+
+            # 发言频率限制
+            if self.counter[user_id] > GameBehavior.get().dead_channel_rate_limit:
+                await player.send("❌发言频率超过限制, 该消息被屏蔽")
+                continue
+
+            # 推送消息
+            await stream.send((player, msg))
+
+    async def run(self) -> None:
+        self.stream = anyio.create_memory_object_stream[tuple[Player, UniMessage]](16)
+        send, recv = self.stream
+        async with send, recv, anyio.create_task_group() as self._task_group:
+            self._task_group.start_soon(self._wait_finished)
+            self._task_group.start_soon(self._broadcast)
+            for p in self.players:
+                self._task_group.start_soon(self._receive, p)

nonebot_plugin_werewolf/game.py

@@ -1,4 +1,3 @@
-import contextlib
 import functools
 import secrets
 from collections import Counter
@@ -11,35 +10,26 @@ from nonebot.adapters import Bot
 from nonebot.utils import escape_tag
 from nonebot_plugin_alconna import At, Target, UniMessage
 from nonebot_plugin_alconna.uniseg.receipt import Receipt
-from nonebot_plugin_uninfo import Interface, Scene, SceneType
+from nonebot_plugin_uninfo import Scene, SceneType, get_interface
 
 from .config import GameBehavior, PresetData
-from .constant import GAME_STATUS_CONV, REPORT_TEXT, ROLE_EMOJI, ROLE_NAME_CONV
+from .constant import GAME_STATUS_CONV, REPORT_TEXT
+from .dead_channel import DeadChannel
 from .exception import GameFinished
 from .models import GameState, GameStatus, KillInfo, KillReason, Role, RoleGroup
 from .player import Player
 from .player_set import PlayerSet
-from .utils import InputStore, ObjectStream, SendHandler, add_stop_button, link
+from .utils import InputStore, SendHandler, add_stop_button, link
 
 logger = nonebot.logger.opt(colors=True)
-starting_games: dict[Target, dict[str, str]] = {}
-running_games: set["Game"] = set()
+running_games: dict[Target, "Game"] = {}
 
 
-def get_starting_games() -> dict[Target, dict[str, str]]:
-    return starting_games
-
-
-def get_running_games() -> set["Game"]:
+def get_running_games() -> dict[Target, "Game"]:
     return running_games
 
 
-async def init_players(
-    bot: Bot,
-    game: "Game",
-    players: set[str],
-    interface: Interface,
-) -> PlayerSet:
+async def init_players(bot: Bot, game: "Game", players: set[str]) -> PlayerSet:
     logger.debug(f"初始化 {game.colored_name} 的玩家职业")
 
     preset_data = PresetData.get()
@@ -51,21 +41,20 @@ async def init_players(
         )
 
     w, p, c = preset
-    roles: list[Role] = []
-    roles.extend(preset_data.werewolf_priority[:w])
-    roles.extend(preset_data.priesthood_proirity[:p])
-    roles.extend([Role.CIVILIAN] * c)
+    roles = [
+        *preset_data.werewolf_priority[:w],
+        *preset_data.priesthood_proirity[:p],
+        *([Role.CIVILIAN] * c),
+    ]
 
     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)))
-
     player_set = PlayerSet()
     for user_id in players:
-        player_set.add(await Player.new(_select_role(), bot, game, user_id, interface))
+        role = roles.pop(secrets.randbelow(len(roles)))
+        player_set.add(await Player.new(role, bot, game, user_id))
 
     logger.debug(f"职业分配完成: <e>{escape_tag(str(player_set))}</e>")
     return player_set
@@ -82,73 +71,6 @@ class _SendHandler(SendHandler[str | None]):
         return msg
 
 
-class DeadChannel:
-    players: PlayerSet
-    finished: anyio.Event
-    counter: dict[str, int]
-    stream: ObjectStream[tuple[Player, UniMessage]]
-
-    def __init__(self, players: PlayerSet, finished: anyio.Event) -> None:
-        self.players = players
-        self.finished = finished
-        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 _wait_finished(self) -> None:
-        await self.finished.wait()
-        self._task_group.cancel_scope.cancel()
-
-    async def _broadcast(self) -> NoReturn:
-        while True:
-            player, msg = await self.stream.recv()
-            msg = f"玩家 {player.name}:\n" + msg
-            target = self.players.killed().exclude(player)
-            try:
-                await target.broadcast(msg)
-            except Exception as err:
-                with contextlib.suppress(Exception):
-                    await player.send(f"消息转发失败: {err!r}")
-
-    async def _receive(self, player: Player) -> NoReturn:
-        await player.killed.wait()
-        user_id = player.user_id
-
-        await player.send(
-            "ℹ️你已加入死者频道，请勿在群组内继续发言\n"
-            "私聊发送消息将转发至其他已死亡玩家",
-        )
-        await (
-            self.players.killed()
-            .exclude(player)
-            .broadcast(f"ℹ️玩家 {player.name} 加入了死者频道")
-        )
-
-        while True:
-            msg = await player.receive()
-            self.counter[user_id] += 1
-            self._task_group.start_soon(self._decrease, user_id)
-
-            # 发言频率限制
-            if self.counter[user_id] > GameBehavior.get().dead_channel_rate_limit:
-                await player.send("❌发言频率超过限制, 该消息被屏蔽")
-                continue
-
-            # 推送消息
-            await self.stream.send((player, msg))
-
-    async def run(self) -> None:
-        async with anyio.create_task_group() as tg:
-            self._task_group = tg
-            tg.start_soon(self._wait_finished)
-            tg.start_soon(self._broadcast)
-            for p in self.players:
-                tg.start_soon(self._receive, p)
-
-
 class Game:
     bot: Bot
     group: Target
@@ -174,15 +96,15 @@ class Game:
         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)
+        if interface := get_interface(bot):
+            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.players = await init_players(bot, self, players)
         self._player_map |= {p.user_id: p for p in self.players}
         self._shuffled = self.players.shuffled
 
@@ -261,7 +183,7 @@ class Game:
             msg.text("\n\n📚职业列表:\n")
             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")
+                msg.text(f"- {role.emoji}{role.display}x{cnt}\n")
 
         async with anyio.create_task_group() as tg:
             tg.start_soon(self.send, msg)
@@ -304,7 +226,7 @@ class Game:
                 self.state.shooter = shooter.selected = None
                 await self.post_kill(shoot)
 
-    async def run_night(self, players: PlayerSet) -> Player | None:
+    async def run_night(self, players: PlayerSet) -> None:
         async with anyio.create_task_group() as tg:
             for p in players:
                 tg.start_soon(p.interact)
@@ -321,17 +243,18 @@ class Game:
                 *players.select(RoleGroup.WEREWOLF),
             )
         else:
-            killed = None
+            self.state.killed = None
 
         # 女巫操作目标
         for witch in self.state.poison:
-            if witch.selected is None:
-                continue
-            if witch.selected not in self.state.protected:  # 守卫未保护
+            if (
+                (selected := witch.selected) is not None  # 理论上不会是 None (
+                and selected not in self.state.protected  # 守卫保护
+                # 虽然应该没什么人会加多个女巫玩...但还是加上判断比较好
+                and selected not in self.state.antidote  # 女巫使用解药
+            ):
                 # 女巫毒杀玩家
-                await witch.selected.kill(KillReason.POISON, witch)
-
-        return killed
+                await selected.kill(KillReason.POISON, witch)
 
     async def run_discussion(self) -> None:
         timeout = self.behavior.timeout
@@ -434,8 +357,8 @@ class Game:
             await self.send("🌙天黑请闭眼...")
             players = self.players.alive()
 
-            # 夜间交互，返回狼人目标
-            killed = await self.run_night(players)
+            # 夜间交互
+            await self.run_night(players)
 
             # 公告
             self.state.day += 1
@@ -452,7 +375,11 @@ class Game:
                 await self.send(msg)
 
             # 第一晚被狼人杀死的玩家发表遗言
-            if self.state.day == 1 and killed is not None and not killed.alive:
+            if (
+                self.state.day == 1  # 仅第一晚
+                and (killed := self.state.killed) is not None  # 狼人未空刀且未保护
+                and not killed.alive  # kill 成功
+            ):
                 await self.send(
                     UniMessage.text("⚙️当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
@@ -474,7 +401,9 @@ class Game:
 
             # 开始投票
             await self.send(
-                "🗳️讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互"
+                "🗳️讨论结束, 进入投票环节, "
+                f"限时{self.behavior.timeout.vote / 60:.1f}分钟\n"
+                "请在私聊中进行投票交互"
             )
             self.state.state = GameState.State.VOTE
             await self.run_vote()
@@ -499,6 +428,7 @@ class Game:
             await self.mainloop()
         except anyio.get_cancelled_exc_class():
             logger.warning(f"{self.colored_name} 的狼人杀游戏进程被取消")
+            raise
         except GameFinished as result:
             await self.handle_game_finish(result.status)
             logger.info(f"{self.colored_name} 的狼人杀游戏进程正常退出")
@@ -509,26 +439,27 @@ class Game:
             if self._finished is not None:
                 self._finished.set()
 
-    async def start(self) -> None:
+    async def run(self) -> None:
         self._finished = anyio.Event()
         dead_channel = DeadChannel(self.players, self._finished)
-        get_running_games().add(self)
+        get_running_games()[self.group] = self
 
         try:
             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:
             msg = f"{self.colored_name} 的狼人杀守护进程出现错误: {err!r}"
             logger.opt(exception=err).error(msg)
         finally:
             self._finished = None
             self._task_group = None
-            get_running_games().discard(self)
+            get_running_games().pop(self.group, None)
             InputStore.cleanup(self._player_map.keys(), self.group_id)
 
+    def start(self) -> None:
+        nonebot.get_driver().task_group.start_soon(self.run)
+
     def terminate(self) -> None:
         if self._task_group is not None:
             logger.warning(f"中止 {self.colored_name} 的狼人杀游戏进程")