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

nonebot_plugin_werewolf/config.py

@@ -1,10 +1,81 @@
-from nonebot import get_plugin_config
-from pydantic import BaseModel
+from typing import Literal, overload
+
+from nonebot import get_plugin_config, logger
+from nonebot.compat import PYDANTIC_V2
+from pydantic import BaseModel, Field
+from typing_extensions import Self
+
+from .constant import (
+    Role,
+    default_priesthood_proirity,
+    default_role_preset,
+    default_werewolf_priority,
+)
+
+if PYDANTIC_V2:
+    from pydantic import model_validator as model_validator
+else:
+    from pydantic import root_validator
+
+    @overload
+    def model_validator(*, mode: Literal["before"]): ...  # noqa: ANN201
+
+    @overload
+    def model_validator(*, mode: Literal["after"]): ...  # noqa: ANN201
+
+    def model_validator(*, mode: Literal["before", "after"]):
+        return root_validator(
+            pre=mode == "before",  # pyright: ignore[reportArgumentType]
+            allow_reuse=True,
+        )
 
 
 class PluginConfig(BaseModel):
-    enable_poke: bool = True
-    override_preset: list[tuple[int, int, int, int]] | None = None
+    enable_poke: bool = Field(default=True)
+    role_preset: list[tuple[int, int, int, int]] | dict[int, tuple[int, int, int]] = (
+        Field(default_factory=default_role_preset.copy)
+    )
+    werewolf_priority: list[Role] = Field(
+        default_factory=default_werewolf_priority.copy
+    )
+    priesthood_proirity: list[Role] = Field(
+        default_factory=default_priesthood_proirity.copy
+    )
+    joker_probability: float = Field(default=0.0, ge=0.0, le=1.0)
+
+    @model_validator(mode="after")
+    def _validate(self) -> Self:
+        if isinstance(self.role_preset, list):
+            for preset in self.role_preset:
+                if preset[0] != sum(preset[1:]):
+                    raise RuntimeError(
+                        "配置项 `role_preset` 错误: "
+                        f"预设总人数为 {preset[0]}, 实际总人数为 {sum(preset[1:])} "
+                        f"({', '.join(map(str, preset[1:]))})"
+                    )
+            self.role_preset = default_role_preset | {
+                i[0]: i[1:] for i in self.role_preset
+            }
+            logger.debug(f"覆写配置 role_preset: {self.role_preset}")
+
+        min_length = max(i[0] for i in self.role_preset.values())
+        if len(self.werewolf_priority) < min_length:
+            raise RuntimeError(
+                f"配置项 `werewolf_priority` 错误: 应至少为 {min_length} 项"
+            )
+
+        min_length = max(i[1] for i in self.role_preset.values())
+        if len(self.priesthood_proirity) < min_length:
+            raise RuntimeError(
+                f"配置项 `priesthood_proirity` 错误: 应至少为 {min_length} 项"
+            )
+
+        return self
+
+    def get_role_preset(self) -> dict[int, tuple[int, int, int]]:
+        if isinstance(self.role_preset, list):
+            self.role_preset = {i[0]: i[1:] for i in self.role_preset}
+        return self.role_preset
 
 
 class Config(BaseModel):
@@ -12,3 +83,4 @@ class Config(BaseModel):
 
 
 config = get_plugin_config(Config).werewolf
+logger.debug(f"加载插件配置: {config}")

nonebot_plugin_werewolf/constant.py

@@ -4,46 +4,47 @@ 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(StrEnum):
+class Role(Enum):
     # 狼人
-    Werewolf = auto()
-    WolfKing = auto()
+    Werewolf = 1
+    WolfKing = 2
 
     # 神职
-    Prophet = auto()
-    Witch = auto()
-    Hunter = auto()
-    Guard = auto()
-    Idiot = auto()
+    Prophet = 11
+    Witch = 12
+    Hunter = 13
+    Guard = 14
+    Idiot = 15
+
+    # 其他
+    Joker = 51
 
     # 平民
-    Civilian = auto()
+    Civilian = 0
 
 
-class RoleGroup(StrEnum):
+class RoleGroup(Enum):
     Werewolf = auto()
     GoodGuy = auto()
+    Others = auto()
 
 
 class KillReason(Enum):
-    Kill = auto()
+    Werewolf = auto()
     Poison = auto()
     Shoot = auto()
     Vote = auto()
 
 
 class GameStatus(Enum):
-    Good = auto()
-    Bad = auto()
+    GoodGuy = auto()
+    Werewolf = auto()
     Unset = auto()
+    Joker = auto()
 
 
 @dataclass
@@ -55,7 +56,7 @@ class GameState:
     potion: tuple[Player | None, tuple[bool, bool]] = (None, (False, False))
 
 
-role_name_conv: dict[Role, str] = {
+role_name_conv: dict[Role | RoleGroup, str] = {
     Role.Werewolf: "狼人",
     Role.WolfKing: "狼王",
     Role.Prophet: "预言家",
@@ -63,16 +64,14 @@ role_name_conv: dict[Role, str] = {
     Role.Hunter: "猎人",
     Role.Guard: "守卫",
     Role.Idiot: "白痴",
+    Role.Joker: "小丑",
     Role.Civilian: "平民",
-}
-
-
-role_group_name_conv: dict[RoleGroup, str] = {
     RoleGroup.Werewolf: "狼人",
     RoleGroup.GoodGuy: "好人",
+    RoleGroup.Others: "其他",
 }
 
-player_preset: dict[int, tuple[int, int, int]] = {
+default_role_preset: dict[int, tuple[int, int, int]] = {
     # 总人数: (狼, 神, 民)
     6: (1, 2, 3),
     7: (2, 2, 3),
@@ -83,6 +82,16 @@ player_preset: dict[int, tuple[int, int, int]] = {
     12: (4, 5, 3),
 }
 
-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}
+default_werewolf_priority: list[Role] = [
+    Role.Werewolf,
+    Role.Werewolf,
+    Role.WolfKing,
+    Role.Werewolf,
+]
+default_priesthood_proirity: list[Role] = [
+    Role.Witch,
+    Role.Prophet,
+    Role.Hunter,
+    Role.Guard,
+    Role.Idiot,
+]

nonebot_plugin_werewolf/exception.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .constant import GameStatus
+
+
+class Error(Exception):
+    """插件错误类型基类"""
+
+
+class GameFinishedError(Error):
+    """游戏结束时抛出，无视游戏进程进入结算"""
+
+    status: GameStatus
+
+    def __init__(self, status: GameStatus) -> None:
+        self.status = status

nonebot_plugin_werewolf/game.py

@@ -1,46 +1,59 @@
+from __future__ import annotations
+
 import asyncio
 import asyncio.timeouts
 import contextlib
 import random
 import time
+from typing import TYPE_CHECKING, NoReturn
 
-from nonebot.adapters import Bot
 from nonebot.log import logger
-from nonebot_plugin_alconna import Target, UniMessage
+from nonebot_plugin_alconna import At, Target, UniMessage
 
-from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, player_preset
+from .config import config
+from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, role_name_conv
+from .exception import GameFinishedError
 from .player import Player
 from .player_set import PlayerSet
 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, tuple["Game", asyncio.Task[None], asyncio.Task[None]]] = {}
+running_games: dict[str, Game] = {}
 
 
-def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
-    preset = player_preset.get(len(players))
+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:
         raise ValueError(
             f"玩家人数不符: "
-            f"应为 {', '.join(map(str, player_preset))} 人, 传入{len(players)}人"
+            f"应为 {', '.join(map(str, role_preset))} 人, 传入{len(players)}人"
         )
 
     roles: list[Role] = []
-    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(config.werewolf_priority[: preset[0]])
+    roles.extend(config.priesthood_proirity[: preset[1]])
     roles.extend([Role.Civilian] * preset[2])
 
-    r = random.Random(time.time())
+    r = random.Random(time.time())  # noqa: S311
+
+    if roles.count(Role.Civilian) >= 2 and r.random() <= config.joker_probability:
+        roles.remove(Role.Civilian)
+        roles.append(Role.Joker)
+
     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):
+    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(
@@ -56,7 +69,7 @@ def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
             ),
             players[user_id],
         )
-        for user_id, role in zip(players, shuffled)
+        for user_id, role in zip(players, shuffled, strict=True)
     )
 
 
@@ -64,24 +77,28 @@ class Game:
     bot: Bot
     group: Target
     players: PlayerSet
+    _player_map: dict[str, Player]
     state: GameState
     killed_players: list[Player]
 
-    def __init__(
-        self,
-        bot: Bot,
-        group: Target,
-        players: dict[str, str],
-    ) -> None:
+    def __init__(self, bot: Bot, group: Target, players: dict[str, str]) -> None:
         self.bot = bot
         self.group = group
         self.players = init_players(bot, self, players)
+        self._player_map = {p.user_id: p for p in self.players}
         self.state = GameState(0)
         self.killed_players = []
 
-    async def send(self, message: str | UniMessage):
+    async def send(self, message: str | UniMessage) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
+        text = f"<b><e>{self.group.id}</e></b> | <g>Send</g> | "
+        for seg in message:
+            if isinstance(seg, At):
+                text += f"<y>@{self._player_map[seg.target].name}</y>"
+            else:
+                text += str(seg)
+        logger.opt(colors=True).info(text.replace("\n", "\\n"))
         return await message.send(self.group, self.bot)
 
     def at_all(self) -> UniMessage:
@@ -95,14 +112,18 @@ class Game:
         w = players.select(RoleGroup.Werewolf)
         p = players.exclude(RoleGroup.Werewolf)
 
+        # 狼人数量大于其他职业数量
         if w.size >= p.size:
-            return GameStatus.Bad
-        if not p.select(Role.Civilian):
-            return GameStatus.Bad
-        if not p.exclude(Role.Civilian):
-            return GameStatus.Bad
+            raise GameFinishedError(GameStatus.Werewolf)
+        # 屠边-村民/中立全灭
+        if not p.select(Role.Civilian, RoleGroup.Others).size:
+            raise GameFinishedError(GameStatus.Werewolf)
+        # 屠边-神职全灭
+        if not p.exclude(Role.Civilian).size:
+            raise GameFinishedError(GameStatus.Werewolf)
+        # 狼人全灭
         if not w.size:
-            return GameStatus.Good
+            raise GameFinishedError(GameStatus.GoodGuy)
 
         return GameStatus.Unset
 
@@ -117,7 +138,7 @@ class Game:
                 p.name for p in player.kill_info.killers
             )
             match player.kill_info.reason:
-                case KillReason.Kill:
+                case KillReason.Werewolf:
                     msg += " 刀了"
                 case KillReason.Poison:
                     msg += " 毒死"
@@ -130,7 +151,7 @@ class Game:
         return msg.strip()
 
     async def notify_player_role(self) -> None:
-        preset = player_preset[len(self.players)]
+        preset = config.get_role_preset()[len(self.players)]
         await asyncio.gather(
             self.send(
                 self.at_all()
@@ -149,7 +170,7 @@ class Game:
         if isinstance(players, Player):
             players = PlayerSet([players])
 
-        async def wait(p: Player):
+        async def wait(p: Player) -> None:
             while True:
                 msg = await InputStore.fetch(p.user_id, self.group.id)
                 if msg.extract_plain_text() == "/stop":
@@ -169,9 +190,9 @@ class Game:
             type_.role_name  # Player
             if isinstance(type_, Player)
             else (
-                type_.name  # Role
+                role_name_conv[type_]  # Role
                 if isinstance(type_, Role)
-                else f"{type_.name}阵营"  # RoleGroup
+                else f"{role_name_conv[type_]}阵营"  # RoleGroup
             )
         )
 
@@ -179,6 +200,7 @@ class Game:
         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}交互时间结束")
 
     async def select_killed(self) -> None:
@@ -198,7 +220,7 @@ class Game:
             await self.interact(Role.Witch, 60)
         # 否则等待 5-20s
         else:
-            await asyncio.sleep(random.uniform(5, 20))
+            await asyncio.sleep(random.uniform(5, 20))  # noqa: S311
 
     async def handle_new_dead(self, players: Player | PlayerSet) -> None:
         if isinstance(players, Player):
@@ -250,6 +272,8 @@ class Game:
         # 收集到的总票数
         total_votes = sum(map(len, vote_result.values()))
 
+        logger.debug(f"投票结果: {vote_result}")
+
         # 投票结果公示
         msg = UniMessage.text("投票结果:\n")
         for p, v in sorted(vote_result.items(), key=lambda x: len(x[1]), reverse=True):
@@ -299,23 +323,23 @@ class Game:
         loop = asyncio.get_event_loop()
         queue: asyncio.Queue[tuple[Player, UniMessage]] = asyncio.Queue()
 
-        async def send():
+        async def send() -> NoReturn:
             while True:
                 player, msg = await queue.get()
                 msg = f"玩家 {player.name}:\n" + msg
-                await self.players.dead().exclude(player).broadcast(msg)
+                await self.players.killed().exclude(player).broadcast(msg)
+                queue.task_done()
+
+        async def recv(player: Player) -> NoReturn:
+            await player.killed.wait()
 
-        async def recv(player: Player):
             counter = 0
 
-            def decrease():
+            def decrease() -> None:
                 nonlocal counter
                 counter -= 1
 
             while True:
-                if not player.killed:
-                    await asyncio.sleep(1)
-                    continue
                 msg = await player.receive()
                 counter += 1
                 if counter <= 10:
@@ -326,13 +350,14 @@ class Game:
 
         await asyncio.gather(send(), *[recv(p) for p in self.players])
 
-    async def run(self) -> None:
+    async def run(self) -> NoReturn:
         # 告知玩家角色信息
         await self.notify_player_role()
         # 天数记录 主要用于第一晚狼人击杀的遗言
         day_count = 0
 
-        while self.check_game_status() == GameStatus.Unset:
+        # 游戏主循环
+        while True:
             # 重置游戏状态，进入下一夜
             self.state = GameState(day_count)
             players = self.players.alive()
@@ -341,10 +366,12 @@ class Game:
             # 狼人、预言家、守卫 同时交互，女巫在狼人后交互
             await asyncio.gather(
                 self.select_killed(),
-                players.select(Role.Witch).broadcast("请等待狼人决定目标..."),
-                players.select(Role.Civilian).broadcast("请等待其他玩家结束交互..."),
                 self.interact(Role.Prophet, 60),
                 self.interact(Role.Guard, 60),
+                players.select(Role.Witch).broadcast("请等待狼人决定目标..."),
+                players.select(Role.Civilian, RoleGroup.Others).broadcast(
+                    "请等待其他玩家结束交互..."
+                ),
             )
 
             # 狼人击杀目标
@@ -354,13 +381,13 @@ class Game:
             # 女巫的操作目标和内容
             potioned, (antidote, poison) = self.state.potion
 
-            # 狼人未空刀
-            if killed is not None:
-                # 除非守卫保护或女巫使用解药，否则狼人正常击杀玩家
-                if not ((killed is protected) or (antidote and potioned is killed)):
-                    await killed.kill(
-                        KillReason.Kill, *players.select(RoleGroup.Werewolf)
-                    )
+            # 狼人未空刀，除非守卫保护或女巫使用解药，否则狼人正常击杀玩家
+            if killed is not None and (
+                not ((killed is protected) or (antidote and potioned is killed))
+            ):
+                await killed.kill(
+                    KillReason.Werewolf, *players.select(RoleGroup.Werewolf)
+                )
             # 如果女巫使用毒药且守卫未保护，杀死该玩家
             if poison and (potioned is not None) and (potioned is not protected):
                 await potioned.kill(KillReason.Poison, *players.select(Role.Witch))
@@ -389,8 +416,7 @@ class Game:
             await self.post_kill(dead)
 
             # 判断游戏状态
-            if self.check_game_status() != GameStatus.Unset:
-                break
+            self.check_game_status()
 
             # 公示存活玩家
             await self.send(f"当前存活玩家: \n\n{self.players.alive().show()}")
@@ -403,32 +429,55 @@ class Game:
             await self.send("讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互")
             await self.run_vote()
 
-        # 游戏结束
-        winner = "好人" if self.check_game_status() == GameStatus.Good else "狼人"
+            # 判断游戏状态
+            self.check_game_status()
+
+    async def handle_game_finish(self, status: GameStatus) -> None:
+        match status:
+            case GameStatus.GoodGuy:
+                winner = "好人"
+            case GameStatus.Werewolf:
+                winner = "狼人"
+            case GameStatus.Joker:
+                winner = "小丑"
+            case GameStatus.Unset:
+                raise RuntimeError(f"错误的游戏状态: {status!r}")
+
         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")
         await self.send(msg)
-        await self.send(f"玩家死亡报告:\n\n{self.show_killed_players()}")
+        await self.send(f"📌玩家死亡报告:\n\n{self.show_killed_players()}")
 
-    def start(self):
-        task = asyncio.create_task(self.run())
+    def start(self) -> None:
+        finished = asyncio.Event()
+        game_task = asyncio.create_task(self.run())
+        game_task.add_done_callback(lambda _: finished.set())
         dead_channel = asyncio.create_task(self.run_dead_channel())
 
-        async def daemon():
-            while not task.done():  # noqa: ASYNC110
-                await asyncio.sleep(1)
+        async def daemon() -> None:
+            await finished.wait()
 
             try:
-                task.result()
-            except asyncio.CancelledError as err:
-                logger.warning(f"狼人杀游戏进程被取消: {err}")
+                game_task.result()
+            except asyncio.CancelledError:
+                logger.warning(f"{self.group.id} 的狼人杀游戏进程被取消")
+            except GameFinishedError as result:
+                await self.handle_game_finish(result.status)
+                logger.info(f"{self.group.id} 的狼人杀游戏进程正常退出")
             except Exception as err:
-                msg = f"狼人杀游戏进程出现错误: {err!r}"
+                msg = f"{self.group.id} 的狼人杀游戏进程出现未知错误: {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()))
+        def daemon_callback(task: asyncio.Task[None]) -> None:
+            if err := task.exception():
+                logger.opt(exception=err).error(
+                    f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
+                )
+
+        running_games[self.group.id] = self
+        asyncio.create_task(daemon()).add_done_callback(daemon_callback)

nonebot_plugin_werewolf/matchers.py

@@ -4,11 +4,12 @@ from typing import Annotated
 
 from nonebot import on_command, on_message
 from nonebot.adapters import Bot, Event
+from nonebot.exception import FinishedException
 from nonebot.rule import to_me
 from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
 from nonebot_plugin_userinfo import EventUserInfo, UserInfo
 
-from .game import Game, running_games, starting_games
+from .game import Game
 from .ob11_ext import ob11_ext_enabled
 from .utils import InputStore, is_group, prepare_game, rule_in_game, rule_not_in_game
 
@@ -35,9 +36,6 @@ async def handle_start(
     target: MsgTarget,
     admin_info: Annotated[UserInfo, EventUserInfo()],
 ) -> None:
-    if target.id in running_games:
-        await UniMessage.text("当前群聊内有正在进行的游戏，无法创建游戏").finish()
-
     admin_id = event.get_user_id()
     msg = (
         UniMessage.at(admin_id)
@@ -51,15 +49,15 @@ async def handle_start(
         msg.text("\n可使用戳一戳代替游戏交互中的 “/stop” 命令")
     await msg.text("\n\n游戏准备阶段限时5分钟，超时将自动结束").send()
 
-    players = starting_games[target.id] = {admin_id: admin_info.user_name}
+    players = {admin_id: admin_info.user_name}
 
     try:
         async with asyncio.timeouts.timeout(5 * 60):
             await prepare_game(event, players)
+    except FinishedException:
+        raise
     except TimeoutError:
         await UniMessage.text("游戏准备超时，已自动结束").finish()
-    finally:
-        del starting_games[target.id]
 
-    game = Game(bot=bot, group=target, players=players)
+    game = Game(bot, target, players)
     game.start()

nonebot_plugin_werewolf/ob11_ext.py

@@ -62,7 +62,7 @@ with contextlib.suppress(ImportError):
                 group_id=int(group_id),
                 user_id=int(user_id),
             )
-            players[user_id] = res.get("nickname") or user_id
+            players[user_id] = res.get("card") or res.get("nickname") or user_id
             await bot.send(event, MessageSegment.at(user_id) + "成功加入游戏")
 
     def ob11_ext_enabled() -> bool: