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

nonebot_plugin_werewolf/players/joker.py

@@ -2,10 +2,10 @@ from typing_extensions import override
 
 from ..constant import GameStatus, KillReason, Role, RoleGroup
 from ..exception import GameFinished
-from .player import Player, register_role
+from .player import Player
 
 
-@register_role(Role.Joker, RoleGroup.Others)
+@Player.register_role(Role.Joker, RoleGroup.Others)
 class Joker(Player):
     @override
     async def notify_role(self) -> None:

nonebot_plugin_werewolf/players/player.py

@@ -1,95 +1,151 @@
-from __future__ import annotations
-
-import asyncio
 import functools
 import weakref
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, ClassVar, Final, TypeVar, final
 
+import anyio
+from nonebot.adapters import Bot
 from nonebot.log import logger
+from nonebot.utils import escape_tag
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
-
-from ..constant import KillReason, Role, RoleGroup, role_emoji, role_name_conv
-from ..utils import InputStore, check_index
+from nonebot_plugin_uninfo import SceneType
+
+from ..constant import (
+    STOP_COMMAND,
+    STOP_COMMAND_PROMPT,
+    KillReason,
+    Role,
+    RoleGroup,
+    role_emoji,
+    role_name_conv,
+)
+from ..utils import InputStore, as_player_set, check_index, link
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from nonebot.adapters import Bot
-
     from ..game import Game
     from ..player_set import PlayerSet
 
 
-P = TypeVar("P", bound=type["Player"])
-PLAYER_CLASS: dict[Role, type[Player]] = {}
+_P = TypeVar("_P", bound=type["Player"])
 
 
 @dataclass
 class KillInfo:
     reason: KillReason
-    killers: PlayerSet
+    killers: "PlayerSet"
 
 
 class Player:
+    __player_class: ClassVar[dict[Role, type["Player"]]] = {}
     role: ClassVar[Role]
     role_group: ClassVar[RoleGroup]
 
     bot: Final[Bot]
-    _game_ref: Final[weakref.ReferenceType[Game]]
-    user: Final[Target]
-    name: Final[str]
     alive: bool = True
-    killed: Final[asyncio.Event]
+    killed: Final[anyio.Event]
     kill_info: KillInfo | None = None
-    selected: Player | None = None
+    selected: "Player | None" = None
 
     @final
-    def __init__(self, bot: Bot, game: Game, user_id: str, name: str) -> None:
-        self.bot = bot
-        self._game_ref = weakref.ref(game)
-        self.user = Target(
+    def __init__(self, bot: Bot, game: "Game", user_id: str) -> None:
+        self.__user = Target(
             user_id,
             private=True,
             self_id=bot.self_id,
             adapter=bot.adapter.get_name(),
         )
-        self.name = name
-        self.killed = asyncio.Event()
+        self.__game_ref = weakref.ref(game)
+        self.bot = bot
+        self.killed = anyio.Event()
+        self._member = None
+
+    @classmethod
+    def register_role(cls, role: Role, role_group: RoleGroup, /) -> Callable[[_P], _P]:
+        def decorator(c: _P, /) -> _P:
+            c.role = role
+            c.role_group = role_group
+            cls.__player_class[role] = c
+            return c
+
+        return decorator
 
     @final
     @classmethod
-    def new(cls, role: Role, bot: Bot, game: Game, user_id: str, name: str) -> Player:
-        if role not in PLAYER_CLASS:
+    def new(cls, role: Role, bot: Bot, game: "Game", user_id: str) -> "Player":
+        if role not in cls.__player_class:
             raise ValueError(f"Unexpected role: {role!r}")
 
-        return PLAYER_CLASS[role](bot, game, user_id, name)
+        return cls.__player_class[role](bot, game, user_id)
 
     def __repr__(self) -> str:
-        return f"<Player {self.role_name}: user={self.name!r} alive={self.alive}>"
+        return (
+            f"<Player {self.role_name}: user={self.user_id!r} " f"alive={self.alive}>"
+        )
 
     @property
-    def game(self) -> Game:
-        if game := self._game_ref():
+    def game(self) -> "Game":
+        if game := self.__game_ref():
             return game
         raise ValueError("Game not exist")
 
     @functools.cached_property
     def user_id(self) -> str:
-        return self.user.id
+        return self.__user.id
 
     @functools.cached_property
     def role_name(self) -> str:
         return role_name_conv[self.role]
 
+    async def _fetch_member(self) -> None:
+        member = await self.game.interface.get_member(
+            SceneType.GROUP,
+            self.game.group.id,
+            self.user_id,
+        )
+        if member is None:
+            member = await self.game.interface.get_member(
+                SceneType.GUILD,
+                self.game.group.id,
+                self.user_id,
+            )
+
+        self._member = member
+
+    @final
+    @property
+    def _member_nick(self) -> str | None:
+        return self._member and (
+            self._member.nick or self._member.user.nick or self._member.user.name
+        )
+
+    @final
+    @property
+    def name(self) -> str:
+        return self._member_nick or self.user_id
+
     @final
-    def _log(self, text: str) -> None:
+    @property
+    def colored_name(self) -> str:
+        name = escape_tag(self.user_id)
+
+        if self._member is None or (nick := self._member_nick) is None:
+            name = f"<b><e>{name}</e></b>"
+        else:
+            name = f"<y>{nick}</y>(<b><e>{name}</e></b>)"
+
+        if self._member is not None and self._member.user.avatar is not None:
+            name = link(name, self._member.user.avatar)
+
+        return name
+
+    @final
+    async 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"{self.game.colored_name} | "
             f"[<b><m>{self.role_name}</m></b>] "
-            f"<y>{self.name}</y>(<b><e>{self.user_id}</e></b>) | "
-            f"{text}",
+            f"{self.colored_name} | {text}",
         )
 
     @final
@@ -97,16 +153,16 @@ class Player:
         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)
+        await self._log(f"<g>Send</g> | {escape_tag(str(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)
 
-        result = await InputStore.fetch(self.user.id)
-        self._log(f"<y>Recv</y> | {result}")
+        result = await InputStore.fetch(self.user_id)
+        await self._log(f"<y>Recv</y> | {escape_tag(str(result))}")
         return result
 
     @final
@@ -117,45 +173,61 @@ class Player:
         return
 
     async def notify_role(self) -> None:
+        await self._fetch_member()
         await self.send(f"⚙️你的身份: {role_emoji[self.role]}{self.role_name}")
 
-    async def kill(self, reason: KillReason, *killers: Player) -> bool:
-        from ..player_set import PlayerSet
-
+    async def kill(self, reason: KillReason, *killers: "Player") -> bool:
         self.alive = False
-        self.kill_info = KillInfo(reason=reason, killers=PlayerSet(killers))
+        self.kill_info = KillInfo(reason=reason, killers=as_player_set(*killers))
         return True
 
     async def post_kill(self) -> None:
         self.killed.set()
 
-    async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
+    async def vote(self, players: "PlayerSet") -> "Player | None":
         await self.send(
             f"💫请选择需要投票的玩家:\n{players.show()}"
-            "\n\n🗳️发送编号选择玩家\n❌发送 “/stop” 弃票"
+            f"\n\n🗳️发送编号选择玩家\n❌发送 “{STOP_COMMAND_PROMPT}” 弃票"
+            f"\n\n限时1分钟，超时将视为弃票"
         )
 
-        while True:
+        try:
+            with anyio.fail_after(60):
+                selected = await self._select_player(
+                    players,
+                    on_stop="⚠️你选择了弃票",
+                    on_index_error="⚠️输入错误: 请发送编号选择玩家",
+                )
+        except TimeoutError:
+            selected = None
+            await self.send("⚠️投票超时，将视为弃票")
+
+        if selected is not None:
+            await self.send(f"🔨投票的玩家: {selected.name}")
+        return selected
+
+    async def _check_selected(self, player: "Player") -> "Player | None":
+        return player
+
+    async def _select_player(
+        self,
+        players: "PlayerSet",
+        *,
+        on_stop: str | None = "ℹ️你选择了取消，回合结束",
+        on_index_error: str = f"⚠️输入错误: 请发送玩家编号或 “{STOP_COMMAND_PROMPT}”",
+    ) -> "Player | None":
+        selected = None
+
+        while selected is None:
             text = await self.receive_text()
-            if text == "/stop":
-                await self.send("⚠️你选择了弃票")
+            if text == STOP_COMMAND:
+                if on_stop is not None:
+                    await self.send(on_stop)
                 return None
             index = check_index(text, len(players))
-            if index is not None:
-                selected = index - 1
-                break
-            await self.send("⚠️输入错误: 请发送编号选择玩家")
-
-        player = players[selected]
-        await self.send(f"🔨投票的玩家: {player.name}")
-        return self, player
-
-
-def register_role(role: Role, role_group: RoleGroup, /) -> Callable[[P], P]:
-    def decorator(cls: P, /) -> P:
-        cls.role = role
-        cls.role_group = role_group
-        PLAYER_CLASS[role] = cls
-        return cls
+            if index is None:
+                await self.send(on_index_error)
+                continue
+            selected = await self._check_selected(players[index - 1])
 
-    return decorator
+        return selected

nonebot_plugin_werewolf/players/prophet.py

@@ -1,12 +1,11 @@
 from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import Role, RoleGroup
-from ..utils import check_index
-from .player import Player, register_role
+from ..constant import STOP_COMMAND_PROMPT, Role, RoleGroup
+from .player import Player
 
 
-@register_role(Role.Prophet, RoleGroup.GoodGuy)
+@Player.register_role(Role.Prophet, RoleGroup.GoodGuy)
 class Prophet(Player):
     @override
     async def interact(self) -> None:
@@ -15,16 +14,9 @@ class Prophet(Player):
             UniMessage.text("💫请选择需要查验身份的玩家:\n")
             .text(players.show())
             .text("\n\n🔮发送编号选择玩家")
+            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合(不查验身份)")
         )
 
-        while True:
-            text = await self.receive_text()
-            index = check_index(text, len(players))
-            if index is not None:
-                selected = index - 1
-                break
-            await self.send("⚠️输入错误: 请发送编号选择玩家")
-
-        player = players[selected]
-        result = "狼人" if player.role_group == RoleGroup.Werewolf else "好人"
-        await self.send(f"✏️玩家 {player.name} 的阵营是『{result}』")
+        if selected := await self._select_player(players):
+            result = "狼人" if selected.role_group == RoleGroup.Werewolf else "好人"
+            await self.send(f"✏️玩家 {selected.name} 的阵营是『{result}』")

nonebot_plugin_werewolf/players/werewolf.py

@@ -1,14 +1,19 @@
-import asyncio
+from typing import TYPE_CHECKING
 
+import anyio
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import Role, RoleGroup
+from ..constant import STOP_COMMAND, STOP_COMMAND_PROMPT, Role, RoleGroup
 from ..utils import check_index
-from .player import Player, register_role
+from .player import Player
 
+if TYPE_CHECKING:
+    from ..player_set import PlayerSet
 
-@register_role(Role.Werewolf, RoleGroup.Werewolf)
+
+@Player.register_role(Role.Werewolf, RoleGroup.Werewolf)
 class Werewolf(Player):
     @override
     async def notify_role(self) -> None:
@@ -20,15 +25,47 @@ class Werewolf(Player):
                 + "\n".join(f"  {p.role_name}: {p.name}" for p in partners)
             )
 
+    async def _handle_interact(
+        self,
+        players: "PlayerSet",
+        stream: MemoryObjectSendStream[str | UniMessage],
+        finished: anyio.Event,
+    ) -> None:
+        self.selected = None
+
+        while True:
+            input_msg = await self.receive()
+            text = input_msg.extract_plain_text()
+            index = check_index(text, len(players))
+            if index is not None:
+                self.selected = players[index - 1]
+                msg = f"当前选择玩家: {self.selected.name}"
+                await self.send(f"🎯{msg}\n发送 “{STOP_COMMAND_PROMPT}” 结束回合")
+                await stream.send(f"📝队友 {self.name} {msg}")
+            if text == STOP_COMMAND:
+                if self.selected is not None:
+                    await self.send("✅你已结束当前回合")
+                    await stream.send(f"📝队友 {self.name} 结束当前回合")
+                    finished.set()
+                    return
+                await self.send("⚠️当前未选择玩家，无法结束回合")
+            else:
+                await stream.send(UniMessage.text(f"💬队友 {self.name}:\n") + input_msg)
+
+    async def _handle_broadcast(
+        self,
+        partners: "PlayerSet",
+        stream: MemoryObjectReceiveStream[str | UniMessage],
+        finished: anyio.Event,
+    ) -> None:
+        while not finished.is_set() or stream.statistics().tasks_waiting_receive:
+            await partners.broadcast(await stream.receive())
+
     @override
     async def interact(self) -> None:
         players = self.game.players.alive()
         partners = players.select(RoleGroup.Werewolf).exclude(self)
 
-        # 避免阻塞
-        def broadcast(msg: str | UniMessage) -> asyncio.Task[None]:
-            return asyncio.create_task(partners.broadcast(msg))
-
         msg = UniMessage()
         if partners:
             msg = (
@@ -40,28 +77,13 @@ class Werewolf(Player):
             msg.text("💫请选择今晚的目标:\n")
             .text(players.show())
             .text("\n\n🔪发送编号选择玩家")
-            .text("\n❌发送 “/stop” 结束回合")
+            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
             .text("\n\n⚠️意见未统一将空刀")
         )
 
-        selected = None
-        finished = False
-        while selected is None or not finished:
-            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
-                msg = f"当前选择玩家: {players[selected].name}"
-                await self.send(f"🎯{msg}\n发送 “/stop” 结束回合")
-                broadcast(f"📝队友 {self.name} {msg}")
-            if text == "/stop":
-                if selected is not None:
-                    finished = True
-                    await self.send("✅你已结束当前回合")
-                    broadcast(f"📝队友 {self.name} 结束当前回合")
-                else:
-                    await self.send("⚠️当前未选择玩家，无法结束回合")
-            broadcast(UniMessage.text(f"💬队友 {self.name}:\n") + input_msg)
+        send, recv = anyio.create_memory_object_stream[str | UniMessage]()
+        finished = anyio.Event()
 
-        self.selected = players[selected]
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(self._handle_interact, players, send, finished)
+            tg.start_soon(self._handle_broadcast, partners, recv, finished)

nonebot_plugin_werewolf/players/witch.py

@@ -1,41 +1,42 @@
 from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import Role, RoleGroup
-from ..utils import check_index
-from .player import Player, register_role
+from ..constant import STOP_COMMAND_PROMPT, Role, RoleGroup
+from ..utils import as_player_set
+from .player import Player
 
 
-@register_role(Role.Witch, RoleGroup.GoodGuy)
+@Player.register_role(Role.Witch, RoleGroup.GoodGuy)
 class Witch(Player):
-    antidote: int = 1
-    poison: int = 1
+    antidote: bool = True
+    poison: bool = True
 
     async def handle_killed(self) -> bool:
-        msg = UniMessage()
-        if (killed := self.game.state.killed) is not None:
-            msg.text(f"🔪今晚 {killed.name} 被刀了\n\n")
-        else:
+        if (killed := self.game.state.killed) is None:
             await self.send("ℹ️今晚没有人被刀")
             return False
 
+        msg = UniMessage.text(f"🔪今晚 {killed.name} 被刀了\n\n")
+
         if not self.antidote:
             await self.send(msg.text("⚙️你已经用过解药了"))
             return False
 
-        await self.send(msg.text("✏️使用解药请发送 “1”\n❌不使用解药请发送 “/stop”"))
+        msg.text(f"✏️使用解药请发送 “1”\n❌不使用解药请发送 “{STOP_COMMAND_PROMPT}”")
+        await self.send(msg)
+
+        if not await self._select_player(
+            as_player_set(killed),
+            on_stop=f"ℹ️你选择不对 {killed.name} 使用解药",
+            on_index_error=f"⚠️输入错误: 请输入 “1” 或 “{STOP_COMMAND_PROMPT}”",
+        ):
+            return False
 
-        while True:
-            text = await self.receive_text()
-            if text == "1":
-                self.antidote = 0
-                self.selected = killed
-                self.game.state.antidote.add(killed)
-                await self.send(f"✅你对 {killed.name} 使用了解药，回合结束")
-                return True
-            if text == "/stop":
-                return False
-            await self.send("⚠️输入错误: 请输入 “1” 或 “/stop”")
+        self.antidote = False
+        self.selected = killed
+        self.game.state.antidote.add(killed)
+        await self.send(f"✅你对 {killed.name} 使用了解药，回合结束")
+        return True
 
     @override
     async def interact(self) -> None:
@@ -52,21 +53,14 @@ class Witch(Player):
             .text("玩家列表:\n")
             .text(players.show())
             .text("\n\n🧪发送玩家编号使用毒药")
-            .text("\n❌发送 “/stop” 结束回合(不使用药水)")
+            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合(不使用药水)")
         )
 
-        while True:
-            text = await self.receive_text()
-            index = check_index(text, len(players))
-            if index is not None:
-                selected = index - 1
-                break
-            if text == "/stop":
-                await self.send("ℹ️你选择不使用毒药，回合结束")
-                return
-            await self.send("⚠️输入错误: 请发送玩家编号或 “/stop”")
-
-        self.poison = 0
-        self.selected = players[selected]
-        self.game.state.poison.add(self)
-        await self.send(f"✅当前回合选择对玩家 {self.selected.name} 使用毒药\n回合结束")
+        if selected := await self._select_player(
+            players,
+            on_stop="ℹ️你选择不使用毒药，回合结束",
+        ):
+            self.poison = False
+            self.selected = selected
+            self.game.state.poison.add(self)
+            await self.send(f"✅当前回合选择对玩家 {selected.name} 使用毒药\n回合结束")

nonebot_plugin_werewolf/players/wolfking.py

@@ -2,11 +2,11 @@ from typing_extensions import override
 
 from ..constant import Role, RoleGroup
 from .can_shoot import CanShoot
-from .player import register_role
+from .player import Player
 from .werewolf import Werewolf
 
 
-@register_role(Role.WolfKing, RoleGroup.Werewolf)
+@Player.register_role(Role.WolfKing, RoleGroup.Werewolf)
 class WolfKing(CanShoot, Werewolf):
     @override
     async def notify_role(self) -> None: