nonebot-plugin-werewolf 1.1.2__py3-none-any.whl → 1.1.3__py3-none-any.whl

nonebot_plugin_werewolf/__init__.py

@@ -2,13 +2,14 @@ from nonebot import require
 from nonebot.plugin import PluginMetadata, inherit_supported_adapters
 
 require("nonebot_plugin_alconna")
-require("nonebot_plugin_userinfo")
+require("nonebot_plugin_uninfo")
 require("nonebot_plugin_waiter")
 
 from . import matchers as matchers
+from . import players as players
 from .config import Config
 
-__version__ = "1.1.2"
+__version__ = "1.1.3"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",
@@ -18,8 +19,11 @@ __plugin_meta__ = PluginMetadata(
     config=Config,
     supported_adapters=inherit_supported_adapters(
         "nonebot_plugin_alconna",
-        "nonebot_plugin_userinfo",
+        "nonebot_plugin_uninfo",
         "nonebot_plugin_waiter",
     ),
-    extra={"author": "wyf7685"},
+    extra={
+        "Author": "wyf7685",
+        "Bug Tracker": "https://github.com/wyf7685/nonebot-plugin-werewolf/issues",
+    },
 )

nonebot_plugin_werewolf/config.py

@@ -1,4 +1,4 @@
-from typing import Literal, overload
+from typing import Any, Literal, overload
 
 from nonebot import get_plugin_config, logger
 from nonebot.compat import PYDANTIC_V2
@@ -7,6 +7,8 @@ from typing_extensions import Self
 
 from .constant import (
     Role,
+    RolePresetConfig,
+    RolePresetDict,
     default_priesthood_proirity,
     default_role_preset,
     default_werewolf_priority,
@@ -18,12 +20,12 @@ else:
     from pydantic import root_validator
 
     @overload
-    def model_validator(*, mode: Literal["before"]): ...  # noqa: ANN201
+    def model_validator(*, mode: Literal["before"]) -> Any: ...  # noqa: ANN401
 
     @overload
-    def model_validator(*, mode: Literal["after"]): ...  # noqa: ANN201
+    def model_validator(*, mode: Literal["after"]) -> Any: ...  # noqa: ANN401
 
-    def model_validator(*, mode: Literal["before", "after"]):
+    def model_validator(*, mode: Literal["before", "after"]) -> Any:
         return root_validator(
             pre=mode == "before",  # pyright: ignore[reportArgumentType]
             allow_reuse=True,
@@ -31,16 +33,10 @@ else:
 
 
 class PluginConfig(BaseModel):
-    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
-    )
+    enable_poke: bool = True
+    role_preset: RolePresetConfig = default_role_preset.copy()
+    werewolf_priority: list[Role] = default_werewolf_priority.copy()
+    priesthood_proirity: list[Role] = default_priesthood_proirity.copy()
     joker_probability: float = Field(default=0.0, ge=0.0, le=1.0)
 
     @model_validator(mode="after")
@@ -72,7 +68,7 @@ class PluginConfig(BaseModel):
 
         return self
 
-    def get_role_preset(self) -> dict[int, tuple[int, int, int]]:
+    def get_role_preset(self) -> RolePresetDict:
         if isinstance(self.role_preset, list):
             self.role_preset = {i[0]: i[1:] for i in self.role_preset}
         return self.role_preset

nonebot_plugin_werewolf/constant.py

@@ -5,7 +5,7 @@ from enum import Enum, auto
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .player import Player
+    from .players import Player
 
 
 class Role(Enum):
@@ -71,7 +71,22 @@ role_name_conv: dict[Role | RoleGroup, str] = {
     RoleGroup.Others: "其他",
 }
 
-default_role_preset: dict[int, tuple[int, int, int]] = {
+role_emoji: dict[Role, str] = {
+    Role.Werewolf: "🐺",
+    Role.WolfKing: "🐺👑",
+    Role.Prophet: "🔮",
+    Role.Witch: "🧙‍♀️",
+    Role.Hunter: "🕵️",
+    Role.Guard: "🛡️",
+    Role.Idiot: "👨🏻‍🦲",
+    Role.Joker: "🤡",
+    Role.Civilian: "👨🏻‍🌾",
+}
+
+RolePresetDict = dict[int, tuple[int, int, int]]
+RolePresetConfig = RolePresetDict | list[tuple[int, int, int, int]]
+
+default_role_preset: RolePresetDict = {
     # 总人数: (狼, 神, 民)
     6: (1, 2, 3),
     7: (2, 2, 3),

nonebot_plugin_werewolf/game.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import secrets
-from typing import TYPE_CHECKING, NoReturn
+from typing import TYPE_CHECKING, ClassVar, NoReturn
 
 from nonebot.log import logger
 from nonebot_plugin_alconna import At, Target, UniMessage
@@ -12,23 +12,19 @@ from ._timeout import timeout
 from .config import config
 from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, role_name_conv
 from .exception import GameFinished
-from .player import Player
 from .player_set import PlayerSet
+from .players import Player
 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:
+    if (preset := role_preset.get(len(players))) is None:
         raise ValueError(
             f"玩家人数不符: "
             f"应为 {', '.join(map(str, role_preset))} 人, 传入{len(players)}人"
@@ -44,34 +40,22 @@ def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
         roles.remove(Role.Civilian)
         roles.append(Role.Joker)
 
-    shuffled: list[Role] = []
-    while roles:
-        idx = secrets.randbelow(len(roles))
-        shuffled.append(roles.pop(idx))
-
-    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(
-        Player.new(
-            role,
-            bot,
-            game,
-            Target(
-                user_id,
-                private=True,
-                self_id=bot.self_id,
-                selector=selector,
-            ),
-            players[user_id],
-        )
-        for user_id, role in zip(players, shuffled, strict=True)
+    def _select_role() -> Role:
+        return roles.pop(secrets.randbelow(len(roles)))
+
+    player_set = PlayerSet(
+        Player.new(_select_role(), bot, game, user_id, players[user_id])
+        for user_id in players
     )
+    logger.debug(f"职业分配完成: {player_set}")
+
+    return player_set
 
 
 class Game:
+    starting_games: ClassVar[dict[Target, dict[str, str]]] = {}
+    running_games: ClassVar[set[Game]] = set()
+
     bot: Bot
     group: Target
     players: PlayerSet
@@ -124,52 +108,45 @@ class Game:
             raise GameFinished(GameStatus.GoodGuy)
 
     def show_killed_players(self) -> str:
-        msg = ""
+        result: list[str] = []
 
         for player in self.killed_players:
             if player.kill_info is None:
                 continue
 
-            msg += f"{player.name} 被 " + ", ".join(
+            line = f"{player.name} 被 " + ", ".join(
                 p.name for p in player.kill_info.killers
             )
             match player.kill_info.reason:
                 case KillReason.Werewolf:
-                    msg += " 刀了"
+                    line = f"🔪 {line} 刀了"
                 case KillReason.Poison:
-                    msg += " 毒死"
+                    line = f"🧪 {line} 毒死"
                 case KillReason.Shoot:
-                    msg += " 射杀"
+                    line = f"🔫 {line} 射杀"
                 case KillReason.Vote:
-                    msg += " 票出"
-            msg += "\n\n"
+                    line = f"🗳️ {line} 票出"
+            result.append(line)
 
-        return msg.strip()
+        return "\n\n".join(result)
 
     async def notify_player_role(self) -> None:
         preset = config.get_role_preset()[len(self.players)]
         await asyncio.gather(
             self.send(
                 self.at_all()
-                .text("\n\n正在分配职业，请注意查看私聊消息\n")
+                .text("\n\n📝正在分配职业，请注意查看私聊消息\n")
                 .text(f"当前玩家数: {len(self.players)}\n")
                 .text(f"职业分配: 狼人x{preset[0]}, 神职x{preset[1]}, 平民x{preset[2]}")
             ),
             *[p.notify_role() for p in self.players],
         )
 
-    async def wait_stop(
-        self,
-        players: Player | PlayerSet,
-        timeout_secs: float,
-    ) -> None:
-        if isinstance(players, Player):
-            players = PlayerSet([players])
-
+    async def wait_stop(self, *players: Player, timeout_secs: float) -> None:
         async def wait(p: Player) -> None:
             while True:
                 msg = await InputStore.fetch(p.user_id, self.group.id)
-                if msg.extract_plain_text() == "/stop":
+                if msg.extract_plain_text().strip() == "/stop":
                     break
 
         with contextlib.suppress(TimeoutError):
@@ -178,26 +155,23 @@ class Game:
 
     async def interact(
         self,
-        type_: Player | Role | RoleGroup,
+        player_type: Player | Role | RoleGroup,
         timeout_secs: float,
     ) -> None:
-        players = self.players.alive().select(type_)
-        text = (
-            type_.role_name  # Player
-            if isinstance(type_, Player)
-            else (
-                role_name_conv[type_]  # Role
-                if isinstance(type_, Role)
-                else f"{role_name_conv[type_]}阵营"  # RoleGroup
-            )
-        )
-
-        await players.broadcast(f"{text}交互开始，限时 {timeout_secs/60:.2f} 分钟")
+        players = self.players.alive().select(player_type)
+        if isinstance(player_type, Player):
+            text = player_type.role_name
+        elif isinstance(player_type, Role):
+            text = role_name_conv[player_type]
+        else:  # RoleGroup
+            text = f"{role_name_conv[player_type]}阵营"
+
+        await players.broadcast(f"✏️{text}交互开始，限时 {timeout_secs/60:.2f} 分钟")
         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}交互时间结束")
+            logger.opt(colors=True).debug(f"⚠️{text}交互超时 (<y>{timeout_secs}</y>s)")
+            await players.broadcast(f"ℹ️{text}交互时间结束")
 
     async def select_killed(self) -> None:
         players = self.players.alive()
@@ -207,9 +181,9 @@ class Game:
         await self.interact(RoleGroup.Werewolf, 120)
         if (s := w.player_selected()).size == 1:
             self.state.killed = s.pop()
-            await w.broadcast(f"今晚选择的目标为: {self.state.killed.name}")
+            await w.broadcast(f"🔪今晚选择的目标为: {self.state.killed.name}")
         else:
-            await w.broadcast("狼人阵营意见未统一，此晚空刀")
+            await w.broadcast("⚠️狼人阵营意见未统一，此晚空刀")
 
         # 如果女巫存活，正常交互，限时1分钟
         if players.include(Role.Witch):
@@ -226,12 +200,12 @@ class Game:
 
         await asyncio.gather(
             players.broadcast(
-                "你已加入死者频道，请勿在群内继续发言\n"
+                "ℹ️你已加入死者频道，请勿在群内继续发言\n"
                 "私聊发送消息将转发至其他已死亡玩家"
             ),
             self.players.dead()
             .exclude(*players)
-            .broadcast(f"玩家 {', '.join(p.name for p in players)} 加入了死者频道"),
+            .broadcast(f"ℹ️玩家 {', '.join(p.name for p in players)} 加入了死者频道"),
         )
 
     async def post_kill(self, players: Player | PlayerSet) -> None:
@@ -253,7 +227,7 @@ class Game:
                     .text(f" 被{shooter.role_name}射杀, 请发表遗言\n")
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
-                await self.wait_stop(shoot, 60)
+                await self.wait_stop(shoot, timeout_secs=60)
                 self.state.shoot = (None, None)
                 await self.post_kill(shoot)
 
@@ -271,34 +245,35 @@ class Game:
         logger.debug(f"投票结果: {vote_result}")
 
         # 投票结果公示
-        msg = UniMessage.text("投票结果:\n")
+        msg = UniMessage.text("📊投票结果:\n")
         for p, v in sorted(vote_result.items(), key=lambda x: len(x[1]), reverse=True):
             if p is not None:
                 msg.at(p.user_id).text(f": {len(v)} 票\n")
                 vote_reversed[len(v)] = [*vote_reversed.get(len(v), []), p]
         if v := (len(players) - total_votes):
-            msg.text(f"弃票: {v} 票\n")
-        await self.send(msg)
+            msg.text(f"弃票: {v} 票\n\n")
 
         # 全员弃票  # 不是哥们？
         if total_votes == 0:
-            await self.send("没有人被票出")
+            await self.send(msg.text("🔨没有人被票出"))
             return
 
         # 弃票大于最高票
         if (len(players) - total_votes) >= max(vote_reversed.keys()):
-            await self.send("弃票数大于最高票数, 没有人被票出")
+            await self.send(msg.text("🔨弃票数大于最高票数, 没有人被票出"))
             return
 
         # 平票
         if len(vs := vote_reversed[max(vote_reversed.keys())]) != 1:
             await self.send(
-                UniMessage.text("玩家 ")
+                msg.text("🔨玩家 ")
                 .text(", ".join(p.name for p in vs))
                 .text(" 平票, 没有人被票出")
             )
             return
 
+        await self.send(msg)
+
         # 仅有一名玩家票数最高
         voted = vs.pop()
         if not await voted.kill(KillReason.Vote, *vote_result[voted]):
@@ -307,15 +282,15 @@ class Game:
 
         # 遗言
         await self.send(
-            UniMessage.text("玩家 ")
+            UniMessage.text("🔨玩家 ")
             .at(voted.user_id)
             .text(" 被投票放逐, 请发表遗言\n")
             .text("限时1分钟, 发送 “/stop” 结束发言")
         )
-        await self.wait_stop(voted, 60)
+        await self.wait_stop(voted, timeout_secs=60)
         await self.post_kill(voted)
 
-    async def run_dead_channel(self) -> None:
+    async def run_dead_channel(self) -> NoReturn:
         loop = asyncio.get_event_loop()
         queue: asyncio.Queue[tuple[Player, UniMessage]] = asyncio.Queue()
 
@@ -342,7 +317,7 @@ class Game:
                     await queue.put((player, msg))
                     loop.call_later(60, decrease)
                 else:
-                    await player.send("发言频率超过限制, 该消息被屏蔽")
+                    await player.send("❌发言频率超过限制, 该消息被屏蔽")
 
         await asyncio.gather(send(), *[recv(p) for p in self.players])
 
@@ -357,17 +332,17 @@ class Game:
             # 重置游戏状态，进入下一夜
             self.state = GameState(day_count)
             players = self.players.alive()
-            await self.send("天黑请闭眼...")
+            await self.send("🌙天黑请闭眼...")
 
             # 狼人、预言家、守卫 同时交互，女巫在狼人后交互
             await asyncio.gather(
                 self.select_killed(),
                 self.interact(Role.Prophet, 60),
                 self.interact(Role.Guard, 60),
-                players.select(Role.Witch).broadcast("请等待狼人决定目标..."),
+                players.select(Role.Witch).broadcast("ℹ️请等待狼人决定目标..."),
                 players.exclude(
                     RoleGroup.Werewolf, Role.Prophet, Role.Witch, Role.Guard
-                ).broadcast("请等待其他玩家结束交互..."),
+                ).broadcast("ℹ️请等待其他玩家结束交互..."),
             )
 
             # 狼人击杀目标
@@ -391,40 +366,44 @@ class Game:
                     await witch.selected.kill(KillReason.Poison, witch)
 
             day_count += 1
-            msg = UniMessage.text(f"『第{day_count}天』天亮了...\n")
+            msg = UniMessage.text(f"『第{day_count}天』☀️天亮了...\n")
             # 没有玩家死亡，平安夜
             if not (dead := players.dead()):
                 await self.send(msg.text("昨晚是平安夜"))
             # 有玩家死亡，公布死者名单
             else:
-                msg.text("昨晚的死者是:")
-                for p in dead.sorted():
+                msg.text("☠️昨晚的死者是:")
+                for p in dead.sorted:
                     msg.text("\n").at(p.user_id)
                 await self.send(msg)
 
             # 第一晚被狼人杀死的玩家发表遗言
             if day_count == 1 and killed is not None and not killed.alive:
                 await self.send(
-                    UniMessage.text("当前为第一天\n请被狼人杀死的 ")
+                    UniMessage.text("⚙️当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
                     .text(" 发表遗言\n")
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
-                await self.wait_stop(killed, 60)
+                await self.wait_stop(killed, timeout_secs=60)
             await self.post_kill(dead)
 
             # 判断游戏状态
             self.check_game_status()
 
             # 公示存活玩家
-            await self.send(f"当前存活玩家: \n\n{self.players.alive().show()}")
+            await self.send(f"📝当前存活玩家: \n\n{self.players.alive().show()}")
 
             # 开始自由讨论
-            await self.send("接下来开始自由讨论\n限时2分钟, 全员发送 “/stop” 结束发言")
-            await self.wait_stop(self.players.alive(), 120)
+            await self.send(
+                "💬接下来开始自由讨论\n限时2分钟, 全员发送 “/stop” 结束发言"
+            )
+            await self.wait_stop(*self.players.alive(), timeout_secs=120)
 
             # 开始投票
-            await self.send("讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互")
+            await self.send(
+                "🗳️讨论结束, 进入投票环节，限时1分钟\n请在私聊中进行投票交互"
+            )
             await self.run_vote()
 
             # 判断游戏状态
@@ -464,16 +443,16 @@ class Game:
             except Exception as err:
                 msg = f"{self.group.id} 的狼人杀游戏进程出现未知错误: {err!r}"
                 logger.opt(exception=err).error(msg)
-                await self.send(msg)
+                await self.send(f"❌狼人杀游戏进程出现未知错误: {err!r}")
             finally:
                 dead_channel.cancel()
-                running_games.pop(self.group.id, None)
+                self.running_games.discard(self)
 
         def daemon_callback(task: asyncio.Task[None]) -> None:
             if err := task.exception():
-                logger.opt(exception=err).error(
-                    f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
-                )
+                msg = f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
+                logger.opt(exception=err).error(msg)
 
-        running_games[self.group.id] = self
-        asyncio.create_task(daemon()).add_done_callback(daemon_callback)
+        self.running_games.add(self)
+        daemon_task = asyncio.create_task(daemon())
+        daemon_task.add_done_callback(daemon_callback)

nonebot_plugin_werewolf/matchers/__init__.py

@@ -0,0 +1,2 @@
+from . import message_in_game as message_in_game
+from . import start_game as start_game

nonebot_plugin_werewolf/matchers/message_in_game.py

@@ -0,0 +1,15 @@
+from nonebot import on_message
+from nonebot.adapters import Event
+from nonebot_plugin_alconna import MsgTarget, UniMsg
+
+from ..utils import InputStore, rule_in_game
+
+message_in_game = on_message(rule=rule_in_game)
+
+
+@message_in_game.handle()
+async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
+    if target.private:
+        InputStore.put(msg, target.id)
+    else:
+        InputStore.put(msg, event.get_user_id(), target.id)

nonebot_plugin_werewolf/{ob11_ext.py → matchers/ob11_ext.py}

@@ -1,12 +1,12 @@
 import contextlib
 
-from nonebot import on_type
+from nonebot import on_notice
 from nonebot.internal.matcher import current_bot
-from nonebot_plugin_alconna import UniMessage
+from nonebot_plugin_alconna import MsgTarget, UniMessage
 
-from .config import config
-from .game import starting_games
-from .utils import InputStore, user_in_game
+from ..config import config
+from ..game import Game
+from ..utils import InputStore, user_in_game
 
 
 def ob11_ext_enabled() -> bool:
@@ -14,11 +14,11 @@ def ob11_ext_enabled() -> bool:
 
 
 with contextlib.suppress(ImportError):
-    from nonebot.adapters.onebot.v11 import Bot, MessageSegment
+    from nonebot.adapters.onebot.v11 import Bot
     from nonebot.adapters.onebot.v11.event import PokeNotifyEvent
 
     # 游戏内戳一戳等效 "/stop"
-    async def _rule_poke_1(event: PokeNotifyEvent) -> bool:
+    async def _rule_poke_stop(bot: Bot, event: PokeNotifyEvent) -> bool:
         if not config.enable_poke:
             return False
 
@@ -27,19 +27,21 @@ with contextlib.suppress(ImportError):
         return (
             config.enable_poke
             and (event.target_id == event.self_id)
-            and user_in_game(user_id, group_id)
+            and user_in_game(bot.self_id, user_id, group_id)
         )
 
-    @on_type(PokeNotifyEvent, rule=_rule_poke_1).handle()
-    async def handle_poke_1(event: PokeNotifyEvent) -> None:
+    @on_notice(rule=_rule_poke_stop).handle()
+    async def handle_poke_stop(event: PokeNotifyEvent) -> None:
         InputStore.put(
+            msg=UniMessage.text("/stop"),
             user_id=str(event.user_id),
             group_id=str(event.group_id) if event.group_id is not None else None,
-            msg=UniMessage.text("/stop"),
         )
 
     # 准备阶段戳一戳等效加入游戏
-    async def _rule_poke_2(event: PokeNotifyEvent) -> bool:
+    async def _rule_poke_join(
+        bot: Bot, event: PokeNotifyEvent, target: MsgTarget
+    ) -> bool:
         if not config.enable_poke or event.group_id is None:
             return False
 
@@ -47,15 +49,19 @@ with contextlib.suppress(ImportError):
         group_id = str(event.group_id)
         return (
             (event.target_id == event.self_id)
-            and not user_in_game(user_id, group_id)
-            and group_id in starting_games
+            and not user_in_game(bot.self_id, user_id, group_id)
+            and any(target.verify(group) for group in Game.starting_games)
         )
 
-    @on_type(PokeNotifyEvent, rule=_rule_poke_2).handle()
-    async def handle_poke_2(bot: Bot, event: PokeNotifyEvent) -> None:
-        user_id = str(event.user_id)
-        group_id = str(event.group_id)
-        players = starting_games[group_id]
+    @on_notice(rule=_rule_poke_join).handle()
+    async def handle_poke_join(
+        bot: Bot,
+        event: PokeNotifyEvent,
+        target: MsgTarget,
+    ) -> None:
+        user_id = event.get_user_id()
+        group_id = target.id
+        players = next(p for g, p in Game.starting_games.items() if target.verify(g))
 
         if user_id not in players:
             res: dict[str, str] = await bot.get_group_member_info(
@@ -63,7 +69,7 @@ with contextlib.suppress(ImportError):
                 user_id=int(user_id),
             )
             players[user_id] = res.get("card") or res.get("nickname") or user_id
-            await bot.send(event, MessageSegment.at(user_id) + "成功加入游戏")
+            await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
 
     def ob11_ext_enabled() -> bool:
         if not config.enable_poke: