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

nonebot_plugin_werewolf/config.py

@@ -1,14 +1,80 @@
-from nonebot import get_plugin_config
-from pydantic import BaseModel
+from typing import Literal, Self, overload
 
-from .constant import Role
+from nonebot import get_plugin_config, logger
+from nonebot.compat import PYDANTIC_V2
+from pydantic import BaseModel, Field
+
+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
-    role_preset: list[tuple[int, int, int, int]] | None = None
-    werewolf_priority: list[Role] | None = None
-    priesthood_proirity: list[Role] | 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):
@@ -16,3 +82,4 @@ class Config(BaseModel):
 
 
 config = get_plugin_config(Config).werewolf
+logger.debug(f"加载插件配置: {config}")

nonebot_plugin_werewolf/constant.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+import dataclasses
 from enum import Enum, auto
 from typing import TYPE_CHECKING
 
@@ -20,6 +20,9 @@ class Role(Enum):
     Guard = 14
     Idiot = 15
 
+    # 其他
+    Joker = 51
+
     # 平民
     Civilian = 0
 
@@ -27,28 +30,30 @@ class Role(Enum):
 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()
-    Unset = auto()
+    GoodGuy = auto()
+    Werewolf = auto()
+    Joker = auto()
 
 
-@dataclass
+@dataclasses.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))
+    antidote: set[Player] = dataclasses.field(default_factory=set)
+    poison: set[tuple[Player, Player]] = dataclasses.field(default_factory=set)
+    protected: set[Player] = dataclasses.field(default_factory=set)
 
 
 role_name_conv: dict[Role | RoleGroup, str] = {
@@ -59,12 +64,14 @@ role_name_conv: dict[Role | RoleGroup, str] = {
     Role.Hunter: "猎人",
     Role.Guard: "守卫",
     Role.Idiot: "白痴",
+    Role.Joker: "小丑",
     Role.Civilian: "平民",
     RoleGroup.Werewolf: "狼人",
     RoleGroup.GoodGuy: "好人",
+    RoleGroup.Others: "其他",
 }
 
-role_preset: dict[int, tuple[int, int, int]] = {
+default_role_preset: dict[int, tuple[int, int, int]] = {
     # 总人数: (狼, 神, 民)
     6: (1, 2, 3),
     7: (2, 2, 3),
@@ -75,50 +82,16 @@ role_preset: dict[int, tuple[int, int, int]] = {
     12: (4, 5, 3),
 }
 
-werewolf_priority: list[Role] = [
+default_werewolf_priority: list[Role] = [
     Role.Werewolf,
     Role.Werewolf,
     Role.WolfKing,
     Role.Werewolf,
 ]
-priesthood_proirity: list[Role] = [
+default_priesthood_proirity: list[Role] = [
     Role.Witch,
     Role.Prophet,
     Role.Hunter,
     Role.Guard,
     Role.Idiot,
 ]
-
-
-def __apply_config():
-    from .config import config
-
-    global role_preset, werewolf_priority, priesthood_proirity
-
-    if config.role_preset is not None:
-        for preset in config.role_preset:
-            if preset[0] != preset[1:]:
-                raise RuntimeError(
-                    "配置项 `role_preset` 错误: "
-                    f"预设总人数为 {preset[0]}, 实际总人数为 {sum(preset[1:])}"
-                )
-        role_preset |= {i[0]: i[1:] for i in config.role_preset}
-
-    if (priority := config.werewolf_priority) is not None:
-        min_length = max(i[0] for i in role_preset.values())
-        if len(priority) < min_length:
-            raise RuntimeError(
-                f"配置项 `werewolf_priority` 错误: 应至少为 {min_length} 项"
-            )
-        werewolf_priority = priority
-
-    if (priority := config.priesthood_proirity) is not None:
-        min_length = max(i[1] for i in role_preset.values())
-        if len(priority) < min_length:
-            raise RuntimeError(
-                f"配置项 `priesthood_proirity` 错误: 应至少为 {min_length} 项"
-            )
-        priesthood_proirity = priority
-
-
-__apply_config()

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

@@ -3,32 +3,30 @@ from __future__ import annotations
 import asyncio
 import asyncio.timeouts
 import contextlib
-import random
-import time
+import secrets
+from typing import TYPE_CHECKING, NoReturn
 
-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,
-    priesthood_proirity,
-    role_preset,
-    werewolf_priority,
-)
+from nonebot_plugin_alconna import At, Target, UniMessage
+
+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, Game] = {}
 
 
 def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
+    logger.opt(colors=True).debug(f"初始化 <c>{game.group.id}</c> 的玩家职业")
+    role_preset = config.get_role_preset()
     preset = role_preset.get(len(players))
     if preset is None:
         raise ValueError(
@@ -36,18 +34,24 @@ def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
             f"应为 {', '.join(map(str, role_preset))} 人, 传入{len(players)}人"
         )
 
+    w, p, c = preset
     roles: list[Role] = []
-    roles.extend(werewolf_priority[: preset[0]])
-    roles.extend(priesthood_proirity[: preset[1]])
-    roles.extend([Role.Civilian] * preset[2])
+    roles.extend(config.werewolf_priority[:w])
+    roles.extend(config.priesthood_proirity[:p])
+    roles.extend([Role.Civilian] * c)
+
+    if c >= 2 and secrets.randbelow(100) <= config.joker_probability * 100:
+        roles.remove(Role.Civilian)
+        roles.append(Role.Joker)
 
-    r = random.Random(time.time())
     shuffled: list[Role] = []
-    for _ in range(len(players)):
-        idx = r.randint(0, len(roles) - 1)
+    while roles:
+        idx = secrets.randbelow(len(roles))
         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(
@@ -63,7 +67,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)
     )
 
 
@@ -71,24 +75,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:
@@ -97,21 +105,23 @@ class Game:
             msg.at(p.user_id)
         return msg
 
-    def check_game_status(self) -> GameStatus:
+    def check_game_status(self) -> None:
         players = self.players.alive()
         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
-
-        return GameStatus.Unset
+            raise GameFinishedError(GameStatus.GoodGuy)
 
     def show_killed_players(self) -> str:
         msg = ""
@@ -124,7 +134,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 += " 毒死"
@@ -137,7 +147,7 @@ class Game:
         return msg.strip()
 
     async def notify_player_role(self) -> None:
-        preset = role_preset[len(self.players)]
+        preset = config.get_role_preset()[len(self.players)]
         await asyncio.gather(
             self.send(
                 self.at_all()
@@ -156,7 +166,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":
@@ -176,9 +186,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
             )
         )
 
@@ -186,6 +196,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:
@@ -205,7 +216,7 @@ class Game:
             await self.interact(Role.Witch, 60)
         # 否则等待 5-20s
         else:
-            await asyncio.sleep(random.uniform(5, 20))
+            await asyncio.sleep(5 + secrets.randbelow(15))
 
     async def handle_new_dead(self, players: Player | PlayerSet) -> None:
         if isinstance(players, Player):
@@ -257,6 +268,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):
@@ -306,23 +319,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:
@@ -333,13 +346,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()
@@ -348,29 +362,31 @@ 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.exclude(
+                    RoleGroup.Werewolf, Role.Prophet, Role.Witch, Role.Guard
+                ).broadcast("请等待其他玩家结束交互..."),
             )
 
             # 狼人击杀目标
-            killed = self.state.killed
-            # 守卫保护目标
-            protected = self.state.protected
-            # 女巫的操作目标和内容
-            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 poison and (potioned is not None) and (potioned is not protected):
-                await potioned.kill(KillReason.Poison, *players.select(Role.Witch))
+            if (
+                (killed := self.state.killed)  # 狼人未空刀
+                and killed not in self.state.protected  # 守卫保护
+                and killed not in self.state.antidote  # 女巫使用解药
+            ):
+                # 狼人正常击杀玩家
+                await killed.kill(
+                    KillReason.Werewolf,
+                    *players.select(RoleGroup.Werewolf),
+                )
+
+            # 女巫操作目标
+            for witch, potioned in self.state.poison:
+                if potioned not in self.state.protected:  # 守卫未保护
+                    # 女巫毒杀玩家
+                    await potioned.kill(KillReason.Poison, witch)
 
             day_count += 1
             msg = UniMessage.text(f"『第{day_count}天』天亮了...\n")
@@ -396,8 +412,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()}")
@@ -410,37 +425,49 @@ 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 = "小丑"
+
         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):
-        event = asyncio.Event()
+    def start(self) -> None:
+        finished = asyncio.Event()
         game_task = asyncio.create_task(self.run())
-        game_task.add_done_callback(lambda _: event.set())
+        game_task.add_done_callback(lambda _: finished.set())
         dead_channel = asyncio.create_task(self.run_dead_channel())
 
-        async def daemon():
-            await event.wait()
+        async def daemon() -> None:
+            await finished.wait()
 
             try:
                 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 asyncio.CancelledError as err:
-                logger.warning(f"{self.group.id} 的狼人杀游戏进程被取消: {err}")
             except Exception as err:
-                msg = f"{self.group.id} 的狼人杀游戏进程出现错误: {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)
 
-        def daemon_callback(task: asyncio.Task[None]):
+        def daemon_callback(task: asyncio.Task[None]) -> None:
             if err := task.exception():
                 logger.opt(exception=err).error(
                     f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"

nonebot_plugin_werewolf/matchers.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 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
 
@@ -36,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)
@@ -52,7 +49,7 @@ 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):
@@ -61,8 +58,6 @@ async def handle_start(
         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:

nonebot_plugin_werewolf/player.py

@@ -4,15 +4,20 @@ import asyncio
 import asyncio.timeouts
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, ClassVar, TypeVar, final
-from typing_extensions import override
 
-from nonebot.adapters import Bot
+from nonebot.log import logger
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
+from typing_extensions import override
 
-from .constant import KillReason, Role, RoleGroup, role_name_conv
+from .constant import GameStatus, KillReason, Role, RoleGroup, role_name_conv
+from .exception import GameFinishedError
 from .utils import InputStore, check_index
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from nonebot.adapters import Bot
+
     from .game import Game
     from .player_set import PlayerSet
 
@@ -21,7 +26,7 @@ P = TypeVar("P", bound=type["Player"])
 PLAYER_CLASS: dict[Role, type[Player]] = {}
 
 
-def register_role(role: Role, role_group: RoleGroup, /):
+def register_role(role: Role, role_group: RoleGroup, /) -> Callable[[P], P]:
     def decorator(cls: P, /) -> P:
         cls.role = role
         cls.role_group = role_group
@@ -46,7 +51,7 @@ class Player:
     user: Target
     name: str
     alive: bool = True
-    killed: bool = False
+    killed: asyncio.Event
     kill_info: KillInfo | None = None
     selected: Player | None = None
 
@@ -56,6 +61,7 @@ class Player:
         self.game = game
         self.user = user
         self.name = name
+        self.killed = asyncio.Event()
 
     @final
     @classmethod
@@ -73,7 +79,7 @@ class Player:
         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.name!r} alive={self.alive}>"
 
     @property
     def user_id(self) -> str:
@@ -83,18 +89,32 @@ class Player:
     def role_name(self) -> str:
         return role_name_conv[self.role]
 
+    @final
+    def _log(self, text: str) -> None:
+        text = text.replace("\n", "\\n")
+        logger.opt(colors=True).info(
+            f"<b><e>{self.game.group.id}</e></b> | "
+            f"[<b><m>{self.role_name}</m></b>] "
+            f"<y>{self.name}</y>(<e>{self.user_id}</e>) | "
+            f"{text}",
+        )
+
     @final
     async def send(self, message: str | UniMessage) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
 
+        self._log(f"<g>Send</g> | {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)
+
+        result = await InputStore.fetch(self.user.id)
+        self._log(f"<y>Recv</y> | {result}")
+        return result
 
     @final
     async def receive_text(self) -> str:
@@ -106,11 +126,7 @@ class Player:
     async def notify_role(self) -> None:
         await self.send(f"你的身份: {self.role_name}")
 
-    async def kill(
-        self,
-        reason: KillReason,
-        *killers: Player,
-    ) -> bool:
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
         from .player_set import PlayerSet
 
         self.alive = False
@@ -118,7 +134,7 @@ class Player:
         return True
 
     async def post_kill(self) -> None:
-        self.killed = True
+        self.killed.set()
 
     async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
         await self.send(
@@ -184,7 +200,7 @@ class CanShoot(Player):
             text = await self.receive_text()
             if text == "/stop":
                 await self.send("已取消技能")
-                return
+                return None
             index = check_index(text, len(players))
             if index is not None:
                 selected = index - 1
@@ -213,7 +229,7 @@ class Werewolf(Player):
         partners = players.select(RoleGroup.Werewolf).exclude(self)
 
         # 避免阻塞
-        def broadcast(msg: str | UniMessage):
+        def broadcast(msg: str | UniMessage) -> asyncio.Task[None]:
             return asyncio.create_task(partners.broadcast(msg))
 
         msg = UniMessage()
@@ -234,8 +250,8 @@ class Werewolf(Player):
         selected = None
         finished = False
         while selected is None or not finished:
-            input = await self.receive()
-            text = input.extract_plain_text()
+            input_msg = await self.receive()
+            text = input_msg.extract_plain_text()
             index = check_index(text, len(players))
             if index is not None:
                 selected = index - 1
@@ -249,14 +265,17 @@ class Werewolf(Player):
                     broadcast(f"队友 {self.name} 结束当前回合")
                 else:
                     await self.send("当前未选择玩家，无法结束回合")
-            broadcast(UniMessage.text(f"队友 {self.name}:\n") + input)
+            broadcast(UniMessage.text(f"队友 {self.name}:\n") + input_msg)
 
         self.selected = players[selected]
 
 
 @register_role(Role.WolfKing, RoleGroup.Werewolf)
 class WolfKing(CanShoot, Werewolf):
-    pass
+    @override
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send("作为狼王，你可以在死后射杀一名玩家")
 
 
 @register_role(Role.Prophet, RoleGroup.GoodGuy)
@@ -279,7 +298,7 @@ class Prophet(Player):
             await self.send("输入错误，请发送编号选择玩家")
 
         player = players[selected]
-        result = role_name_conv[player.role_group]
+        result = "狼人" if player.role_group == RoleGroup.Werewolf else "好人"
         await self.send(f"玩家 {player.name} 的阵营是『{result}』")
 
 
@@ -288,24 +307,6 @@ class Witch(Player):
     antidote: int = 1
     poison: int = 1
 
-    def set_state(
-        self,
-        *,
-        antidote: Player | None = None,
-        posion: Player | None = None,
-    ):
-        if antidote is not None:
-            self.antidote = 0
-            self.selected = antidote
-            self.game.state.potion = (antidote, (True, False))
-        elif posion is not None:
-            self.poison = 0
-            self.selected = posion
-            self.game.state.potion = (posion, (False, True))
-        else:
-            self.selected = None
-            self.game.state.potion = (None, (False, False))
-
     async def handle_killed(self) -> bool:
         msg = UniMessage()
         if (killed := self.game.state.killed) is not None:
@@ -324,13 +325,12 @@ class Witch(Player):
             text = await self.receive_text()
             if text == "1":
                 self.antidote = 0
-                self.set_state(antidote=killed)
+                self.game.state.antidote.add(killed)
                 await self.send(f"你对 {killed.name} 使用了解药，回合结束")
                 return True
-            elif text == "/stop":
+            if text == "/stop":
                 return False
-            else:
-                await self.send("输入错误: 请输入 “1” 或 “/stop”")
+            await self.send("输入错误: 请输入 “1” 或 “/stop”")
 
     @override
     async def interact(self) -> None:
@@ -339,7 +339,6 @@ class Witch(Player):
 
         if not self.poison:
             await self.send("你没有可以使用的药水，回合结束")
-            self.set_state()
             return
 
         players = self.game.players.alive()
@@ -357,16 +356,14 @@ class Witch(Player):
             if index is not None:
                 selected = index - 1
                 break
-            elif text == "/stop":
+            if text == "/stop":
                 await self.send("你选择不使用毒药，回合结束")
-                self.set_state()
                 return
-            else:
-                await self.send("输入错误: 请发送玩家编号或 “/stop”")
+            await self.send("输入错误: 请发送玩家编号或 “/stop”")
 
         self.poison = 0
-        self.selected = player = players[selected]
-        self.set_state(posion=player)
+        player = players[selected]
+        self.game.state.poison.add((self, player))
         await self.send(f"当前回合选择对玩家 {player.name} 使用毒药\n回合结束")
 
 
@@ -379,9 +376,10 @@ class Hunter(CanShoot, Player):
 class Guard(Player):
     @override
     async def interact(self) -> None:
-        players = self.game.players.alive().exclude(self)
+        players = self.game.players.alive()
         await self.send(
-            UniMessage.text(f"请选择需要保护的玩家:\n{players.show()}")
+            UniMessage.text("请选择需要保护的玩家:\n")
+            .text(players.show())
             .text("\n\n发送编号选择玩家")
             .text("\n发送 “/stop” 结束回合")
         )
@@ -400,7 +398,8 @@ class Guard(Player):
                 break
             await self.send("输入错误，请发送编号选择玩家")
 
-        self.game.state.protected = self.selected = players[selected]
+        self.selected = players[selected]
+        self.game.state.protected.add(self.selected)
         await self.send(f"本回合保护的玩家: {self.selected.name}")
 
 
@@ -409,17 +408,20 @@ class Idiot(Player):
     voted: bool = False
 
     @override
-    async def kill(
-        self,
-        reason: KillReason,
-        *killers: Player,
-    ) -> bool:
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send(
+            "作为白痴，你可以在首次被投票放逐时免疫放逐，但在之后的投票中无法继续投票"
+        )
+
+    @override
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
         if reason == KillReason.Vote and not self.voted:
             self.voted = True
             await self.game.send(
                 UniMessage.at(self.user_id)
                 .text(" 的身份是白痴\n")
-                .text("免疫本次投票放逐，且接下来无法参与投票")
+                .text("免疫本次投票放逐，且接下来无法参与投票"),
             )
             return False
         return await super().kill(reason, *killers)
@@ -432,6 +434,22 @@ class Idiot(Player):
         return await super().vote(players)
 
 
+@register_role(Role.Joker, RoleGroup.Others)
+class Joker(Player):
+    @override
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send("你的胜利条件: 被投票放逐")
+
+    @override
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
+        await super().kill(reason, *killers)
+        if reason == KillReason.Vote:
+            self.game.killed_players.append(self)
+            raise GameFinishedError(GameStatus.Joker)
+        return True
+
+
 @register_role(Role.Civilian, RoleGroup.GoodGuy)
 class Civilian(Player):
     pass

nonebot_plugin_werewolf/player_set.py

@@ -2,12 +2,15 @@ from __future__ import annotations
 
 import asyncio
 import asyncio.timeouts
+from typing import TYPE_CHECKING
 
-from nonebot_plugin_alconna.uniseg import UniMessage
-
-from .constant import Role, RoleGroup
 from .player import Player
 
+if TYPE_CHECKING:
+    from nonebot_plugin_alconna.uniseg import UniMessage
+
+    from .constant import Role, RoleGroup
+
 
 class PlayerSet(set[Player]):
     @property
@@ -20,6 +23,9 @@ class PlayerSet(set[Player]):
     def dead(self) -> PlayerSet:
         return PlayerSet(p for p in self if not p.alive)
 
+    def killed(self) -> PlayerSet:
+        return PlayerSet(p for p in self if p.killed.is_set())
+
     def include(self, *types: Player | Role | RoleGroup) -> PlayerSet:
         return PlayerSet(
             player

nonebot_plugin_werewolf/utils.py

@@ -6,11 +6,12 @@ from typing import Annotated, Any, ClassVar
 
 import nonebot_plugin_waiter as waiter
 from nonebot.adapters import Event
+from nonebot.log import logger
 from nonebot.rule import to_me
 from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
 from nonebot_plugin_userinfo import EventUserInfo, UserInfo
 
-from .constant import role_preset
+from .config import config
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -60,7 +61,7 @@ async def rule_in_game(event: Event, target: MsgTarget) -> bool:
         return False
     if target.private:
         return user_in_game(target.id, None)
-    elif target.id in running_games:
+    if target.id in running_games:
         return user_in_game(event.get_user_id(), target.id)
     return False
 
@@ -104,8 +105,7 @@ async def _prepare_game_receive(
     async for user, name, text in wait(default=(None, "", "")):
         if user is None:
             continue
-        name = re.sub(r"[\u2066-\u2069]", "", name)
-        await queue.put((user, name, text))
+        await queue.put((user, re.sub(r"[\u2066-\u2069]", "", name), text))
 
 
 async def _prepare_game_handle(
@@ -113,13 +113,17 @@ async def _prepare_game_handle(
     players: dict[str, str],
     admin_id: str,
 ) -> None:
+    log = logger.opt(colors=True)
+
     while True:
         user, name, text = await queue.get()
         msg = UniMessage.at(user)
+        colored = f"<y>{name}</y>(<c>{user}</c>)"
 
         match (text, user == admin_id):
             case ("开始游戏", True):
                 player_num = len(players)
+                role_preset = config.get_role_preset()
                 if player_num < min(role_preset):
                     await (
                         msg.text(f"游戏至少需要 {min(role_preset)} 人, ")
@@ -140,12 +144,14 @@ async def _prepare_game_handle(
                     )
                 else:
                     await msg.text("游戏即将开始...").send()
+                    log.info(f"游戏发起者 {colored} 开始游戏")
                     return
 
             case ("开始游戏", False):
                 await msg.text("只有游戏发起者可以开始游戏").send()
 
             case ("结束游戏", True):
+                log.info(f"游戏发起者 {colored} 结束游戏")
                 await msg.text("已结束当前游戏").finish()
 
             case ("结束游戏", False):
@@ -157,6 +163,7 @@ async def _prepare_game_handle(
             case ("加入游戏", False):
                 if user not in players:
                     players[user] = name
+                    log.info(f"玩家 {colored} 加入游戏")
                     await msg.text("成功加入游戏").send()
                 else:
                     await msg.text("你已经加入游戏了").send()
@@ -167,6 +174,7 @@ async def _prepare_game_handle(
             case ("退出游戏", False):
                 if user in players:
                     del players[user]
+                    log.info(f"玩家 {colored} 退出游戏")
                     await msg.text("成功退出游戏").send()
                 else:
                     await msg.text("你还没有加入游戏").send()
@@ -179,20 +187,16 @@ async def _prepare_game_handle(
 
 
 async def prepare_game(event: Event, players: dict[str, str]) -> None:
+    from .game import starting_games
+
+    group_id = UniMessage.get_target(event).id
+    starting_games[group_id] = players
+
     queue: asyncio.Queue[tuple[str, str, str]] = asyncio.Queue()
-    task_receive = asyncio.create_task(
-        _prepare_game_receive(
-            queue,
-            event,
-            UniMessage.get_target(event).id,
-        )
-    )
+    task_receive = asyncio.create_task(_prepare_game_receive(queue, event, group_id))
 
     try:
-        await _prepare_game_handle(
-            queue,
-            players,
-            event.get_user_id(),
-        )
+        await _prepare_game_handle(queue, players, event.get_user_id())
     finally:
         task_receive.cancel()
+        del starting_games[group_id]

{nonebot_plugin_werewolf-1.0.7.dist-info → nonebot_plugin_werewolf-1.1.1.dist-info}/METADATA

@@ -1,15 +1,16 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-werewolf
-Version: 1.0.7
-Summary: Default template for PDM package
-Author-Email: wyf7685 <wyf7685@163.com>
+Version: 1.1.1
+Summary: 适用于 Nonebot2 的狼人杀插件
+Author-email: wyf7685 <wyf7685@163.com>
 License: MIT
-Requires-Python: >=3.10
-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-Python: >=3.11
 Description-Content-Type: text/markdown
+License-File: LICENSE
+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
 
 <div align="center">
   <a href="https://v2.nonebot.dev/store">
@@ -25,13 +26,21 @@ _✨ 简单的狼人杀插件 ✨_
 
 [![license](https://img.shields.io/github/license/wyf7685/nonebot-plugin-werewolf.svg)](./LICENSE)
 [![pypi](https://img.shields.io/pypi/v/nonebot-plugin-werewolf?logo=python&logoColor=edb641)](https://pypi.python.org/pypi/nonebot-plugin-werewolf)
-[![python](https://img.shields.io/badge/python-3.10+-blue?logo=python&logoColor=edb641)](https://www.python.org/)
-
-[![pdm-managed](https://img.shields.io/endpoint?url=https%3A%2F%2Fcdn.jsdelivr.net%2Fgh%2Fpdm-project%2F.github%2Fbadge.json)](https://pdm-project.org)
+[![python](https://img.shields.io/badge/python-3.11+-blue?logo=python&logoColor=edb641)](https://www.python.org/)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![isort](https://img.shields.io/badge/%20imports-isort-%231674b1)](https://pycqa.github.io/isort/)
 [![black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![pyright](https://img.shields.io/badge/types-pyright-797952.svg?logo=python&logoColor=edb641)](https://github.com/Microsoft/pyright)
-[![ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+[![commits](https://img.shields.io/github/commit-activity/w/wyf7685/nonebot-plugin-werewolf)](https://github.com/wyf7685/nonebot-plugin-werewolf/commits)
+[![wakatime](https://wakatime.com/badge/user/b097681b-c224-44ec-8e04-e1cf71744655/project/70a7f68d-5625-4989-9476-be6877408332.svg)](https://wakatime.com/badge/user/b097681b-c224-44ec-8e04-e1cf71744655/project/70a7f68d-5625-4989-9476-be6877408332)
+[![pre-commit](https://results.pre-commit.ci/badge/github/wyf7685/nonebot-plugin-werewolf/master.svg)](https://results.pre-commit.ci/latest/github/wyf7685/nonebot-plugin-werewolf/master)
+[![pyright](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pyright.yml/badge.svg?branch=master&event=push)](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pyright.yml)
+[![publish](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pypi-publish.yml/badge.svg)](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pypi-publish.yml)
+
+[![NoneBot Registry](https://img.shields.io/endpoint?url=https%3A%2F%2Fnbbdg.lgc2333.top%2Fplugin%2Fnonebot-plugin-werewolf)](https://registry.nonebot.dev/plugin/nonebot-plugin-werewolf:nonebot_plugin_werewolf)
+[![Supported Adapters](https://img.shields.io/endpoint?url=https%3A%2F%2Fnbbdg.lgc2333.top%2Fplugin-adapters%2Fnonebot-plugin-werewolf)](https://registry.nonebot.dev/plugin/nonebot-plugin-werewolf:nonebot_plugin_werewolf)
 
 </div>
 
@@ -41,6 +50,10 @@ _✨ 简单的狼人杀插件 ✨_
 
 ## 💿 安装
 
+> [!note]
+> 
+> 请确保 NoneBot2 使用的 Python 解释器版本 >=3.11
+
 <details open>
 <summary>使用 nb-cli 安装</summary>
 在 nonebot2 项目的根目录下打开命令行, 输入以下指令即可安装
@@ -86,7 +99,7 @@ _✨ 简单的狼人杀插件 ✨_
 
 ## ⚙️ 配置
 
-在 nonebot2 项目的`.env`文件中添加下表中的必填配置
+在 nonebot2 项目的 `.env` 文件中添加如下配置
 
 |             配置项              | 必填 | 默认值 |                             说明                              |
 | :-----------------------------: | :--: | :----: | :-----------------------------------------------------------: |
@@ -94,6 +107,7 @@ _✨ 简单的狼人杀插件 ✨_
 |     `werewolf__role_preset`     |  否  |   -    |                    覆写插件内置的职业预设                     |
 |  `werewolf__werewolf_priority`  |  否  |   -    |                     自定义狼人职业优先级                      |
 | `werewolf__priesthood_proirity` |  否  |   -    |                     自定义神职职业优先级                      |
+|  `werewolf__joker_probability`  |  否  | `0.0`  |              小丑职业替换平民的概率, 范围`[0,1]`              |
 
 `werewolf__role_preset`, `werewolf__werewolf_priority`, `werewolf__priesthood_proirity` 的配置格式请参考 [`游戏内容`](#游戏内容) 部分
 
@@ -192,7 +206,7 @@ werewolf__werewolf_priority=[1, 2, 1, 1]
 
 上述配置中，`[1, 2, 1, 1]` 表示狼人的职业优先级为 `狼人`, `狼王`, `狼人`, `狼人`
 
-#### 配置项 `werewolf__werewolf_priority`
+#### 配置项 `werewolf__priesthood_proirity`
 
 ```env
 werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
@@ -226,6 +240,18 @@ werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
 
 <!-- CHANGELOG -->
 
+- 2024.09.11 v1.1.1
+
+  - 修改 Python 需求为 `>=3.11`
+  - 优化交互结果处理 ~~_可以在一局游戏中加入多个女巫了_~~
+
+- 2024.09.09 v1.1.0
+
+  - 新增职业 `小丑`
+  - 修复守卫无法保护自己的 bug
+  - 添加部分特殊职业的说明
+  - 添加游戏过程中的日志输出
+
 - 2024.09.04 v1.0.7
 
   - 优先使用群名片作为玩家名

nonebot_plugin_werewolf-1.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+nonebot_plugin_werewolf/__init__.py,sha256=I6lFyJgJ4Tz4t8gS2lrsx-7paN2h_PNoGjGR8ryvSeU,734
+nonebot_plugin_werewolf/config.py,sha256=gl_ujiY-8fxQ5hN9_gjL1WpJJR5UOBIRBGofbLcQzaE,2900
+nonebot_plugin_werewolf/constant.py,sha256=1XNTcTicil90WSviI2e33FX0LstWXl1aV2ugbhsDlIk,1909
+nonebot_plugin_werewolf/exception.py,sha256=Ui8rB1sBg6_p8JHSvrjCpUaXJlgrM_9XsLJ09k8F1bg,391
+nonebot_plugin_werewolf/game.py,sha256=Y9MQASaNdm2uuNw37IjdQEQzikWmbql_PWLHaL7lcB8,17414
+nonebot_plugin_werewolf/matchers.py,sha256=5FioDfARlxTEibGL1JMKUMzmTzOwljjWKAJxBnyzaYs,2106
+nonebot_plugin_werewolf/ob11_ext.py,sha256=P8uc3AdN5K5MzJaK80WDK85VKFg_CK5avDHu7ueMkho,2418
+nonebot_plugin_werewolf/player.py,sha256=ifqTBfNepQY5FCY7hZoUA6DcObkcFEiNmKEeRkitJqY,14749
+nonebot_plugin_werewolf/player_set.py,sha256=AI8v6KjH9ACtP4lvrd5IJfayan0qALmpTRLC3s_3DFw,2754
+nonebot_plugin_werewolf/utils.py,sha256=l7oNSK471SV5CaB1eEVyZm10XSBFf_TwNotvb30U6vE,6835
+nonebot_plugin_werewolf-1.1.1.dist-info/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
+nonebot_plugin_werewolf-1.1.1.dist-info/METADATA,sha256=5ikh-mdZTIObaFs9w7qgzrgsx31lCxB5Ag--C8stl0g,10447
+nonebot_plugin_werewolf-1.1.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+nonebot_plugin_werewolf-1.1.1.dist-info/top_level.txt,sha256=wLTfg8sTKbH9lLT9LtU118C9cTspEBJareLsrYM52YA,24
+nonebot_plugin_werewolf-1.1.1.dist-info/RECORD,,

{nonebot_plugin_werewolf-1.0.7.dist-info → nonebot_plugin_werewolf-1.1.1.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.3.3)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

nonebot_plugin_werewolf-1.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+nonebot_plugin_werewolf

nonebot_plugin_werewolf-1.0.7.dist-info/RECORD

@@ -1,13 +0,0 @@
-nonebot_plugin_werewolf-1.0.7.dist-info/METADATA,sha256=6Zjo-smpLFf6SX6TLAefU4OFCamMLTZmIKsI5QgzXOs,8479
-nonebot_plugin_werewolf-1.0.7.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
-nonebot_plugin_werewolf-1.0.7.dist-info/licenses/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
-nonebot_plugin_werewolf/__init__.py,sha256=sO1RtjlQkMIdgMEhS8bVwhJpCo8dd36Z_Fc5y-YpEoY,734
-nonebot_plugin_werewolf/config.py,sha256=VSXAWZa3u6_ehXzS0q_qYpPYr5GRqHzs-WR0zHEJiRI,437
-nonebot_plugin_werewolf/constant.py,sha256=w-KWhLTq1_uAVy0ALER-yCn0J1r5Wr07xYvSYyHNHsw,2859
-nonebot_plugin_werewolf/game.py,sha256=ZBOM_yK8Dux0nu6om7_PruH4Kr82-JVOPfpD5JcOFdA,15909
-nonebot_plugin_werewolf/matchers.py,sha256=nRnXYNjwM_Pp-Z1tBoMwd2TrxCPCB5du_qMHbXlZw3w,2373
-nonebot_plugin_werewolf/ob11_ext.py,sha256=I6bPCv5SgAStTJuvBl5F7wqgiksWeFkb4R7n06jXprA,2399
-nonebot_plugin_werewolf/player.py,sha256=sAT8qI-zGLgjQJqWwwq-ow0vaWFdFlpMP0sWEOj-ujg,13817
-nonebot_plugin_werewolf/player_set.py,sha256=WXmJtL3jbfkFCcKbzLCLu70elhBJE5DJwPA3ENNoKJM,2595
-nonebot_plugin_werewolf/utils.py,sha256=EhrlYgDLyNZbpRCGDgpcUnpp8RWJBiZ6l8rDdC5hHvM,6396
-nonebot_plugin_werewolf-1.0.7.dist-info/RECORD,,