nonebot-plugin-werewolf 1.1.8__py3-none-any.whl → 1.1.10__py3-none-any.whl

nonebot_plugin_werewolf/{players/player.py → player.py}

@@ -1,19 +1,19 @@
 import functools
 import weakref
-from collections.abc import Callable
-from typing import TYPE_CHECKING, ClassVar, Final, TypeVar, final
+from types import EllipsisType
+from typing import TYPE_CHECKING, ClassVar, Final, Generic, TypeVar, final
+from typing_extensions import Self, override
 
 import anyio
 import nonebot
 from nonebot.adapters import Bot
 from nonebot.utils import escape_tag
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
-from nonebot_plugin_uninfo import SceneType
+from nonebot_plugin_uninfo import Interface, SceneType
 
-from ..config import GameBehavior
-from ..constant import ROLE_EMOJI, ROLE_NAME_CONV, STOP_COMMAND, stop_command_prompt
-from ..models import KillInfo, KillReason, Role, RoleGroup
-from ..utils import (
+from .constant import ROLE_EMOJI, ROLE_NAME_CONV, STOP_COMMAND, stop_command_prompt
+from .models import KillInfo, KillReason, Role, RoleGroup
+from .utils import (
     InputStore,
     SendHandler,
     add_players_button,
@@ -23,15 +23,79 @@ from ..utils import (
 )
 
 if TYPE_CHECKING:
-    from ..game import Game
-    from ..player_set import PlayerSet
+    from .game import Game
+    from .player_set import PlayerSet
 
 
-_P = TypeVar("_P", bound=type["Player"])
-
 logger = nonebot.logger.opt(colors=True)
 
 
+_P = TypeVar("_P", bound="Player")
+_T = TypeVar("_T")
+
+
+class ActionProvider(Generic[_P]):
+    p: _P
+
+    @final
+    def __init__(self, player: _P, /) -> None:
+        self.p = player
+
+    class proxy(Generic[_T]):  # noqa: N801
+        def __init__(
+            self, _: type[_T] | None = None, /, *, readonly: bool = False
+        ) -> None:
+            self.readonly = readonly
+
+        def __set_name__(self, owner: type["ActionProvider"], name: str) -> None:
+            self.name = name
+
+        def __get__(self, obj: "ActionProvider", objtype: type) -> _T:
+            return getattr(obj.p, self.name)
+
+        def __set__(self, obj: "ActionProvider", value: _T) -> None:
+            if self.readonly:
+                raise AttributeError(f"readonly attribute {self.name}")
+            setattr(obj.p, self.name, value)
+
+    name = proxy[str](readonly=True)
+    user_id = proxy[str](readonly=True)
+    game = proxy["Game"](readonly=True)
+    selected = proxy["Player | None"]()
+
+
+class InteractProvider(ActionProvider[_P], Generic[_P]):
+    async def before(self) -> None: ...
+    async def interact(self) -> None: ...
+    async def after(self) -> None: ...
+
+
+class KillProvider(ActionProvider[_P], Generic[_P]):
+    alive = ActionProvider.proxy[bool]()
+    kill_info = ActionProvider.proxy[KillInfo | None]()
+
+    async def kill(self, reason: KillReason, *killers: "Player") -> KillInfo | None:
+        if self.alive:
+            self.alive = False
+            self.kill_info = KillInfo(reason=reason, killers=[p.name for p in killers])
+        return self.kill_info
+
+    async def post_kill(self) -> None: ...
+
+
+class NotifyProvider(ActionProvider[_P], Generic[_P]):
+    role = ActionProvider.proxy[Role]()
+    role_group = ActionProvider.proxy[RoleGroup]()
+    role_name = ActionProvider.proxy[str]()
+
+    def message(self, message: UniMessage) -> UniMessage:
+        return message
+
+    async def notify(self) -> None:
+        msg = UniMessage.text(f"⚙️你的身份: {ROLE_EMOJI[self.role]}{self.role_name}\n")
+        await self.p.send(self.message(msg))
+
+
 class _SendHandler(SendHandler[str | None]):
     def solve_msg(
         self,
@@ -44,9 +108,13 @@ class _SendHandler(SendHandler[str | None]):
 
 
 class Player:
-    __player_class: ClassVar[dict[Role, type["Player"]]] = {}
+    _player_class: ClassVar[dict[Role, type["Player"]]] = {}
+
     role: ClassVar[Role]
     role_group: ClassVar[RoleGroup]
+    interact_provider: ClassVar[type[InteractProvider[Self]] | None]
+    kill_provider: ClassVar[type[KillProvider[Self]]]
+    notify_provider: ClassVar[type[NotifyProvider[Self]]]
 
     bot: Final[Bot]
     alive: bool = True
@@ -55,65 +123,83 @@ class Player:
     selected: "Player | None" = None
 
     @final
-    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(),
-        )
+    def __init__(self, bot: Bot, game: "Game", user: Target) -> None:
+        self.__user = user
         self.__game_ref = weakref.ref(game)
         self.bot = bot
         self.killed = anyio.Event()
         self._member = None
-        self._send_handler = _SendHandler()
-        self._send_handler.update(self.__user, bot)
+        self._send_handler = _SendHandler(self.__user, bot)
 
-    @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
+    @override
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+        if hasattr(cls, "role") and hasattr(cls, "role_group"):
+            cls._player_class[cls.role] = cls
+        if not hasattr(cls, "interact_provider"):
+            cls.interact_provider = None
+        if not hasattr(cls, "kill_provider"):
+            cls.kill_provider = KillProvider
+        if not hasattr(cls, "notify_provider"):
+            cls.notify_provider = NotifyProvider
 
     @final
     @classmethod
-    def new(cls, role: Role, bot: Bot, game: "Game", user_id: str) -> "Player":
-        if role not in cls.__player_class:
+    async def new(
+        cls,
+        role: Role,
+        bot: Bot,
+        game: "Game",
+        user_id: str,
+        interface: Interface,
+    ) -> "Player":
+        if role not in cls._player_class:
             raise ValueError(f"Unexpected role: {role!r}")
 
-        return cls.__player_class[role](bot, game, user_id)
+        user = Target(
+            user_id,
+            private=True,
+            self_id=game.group.self_id,
+            scope=game.group.scope,
+            adapter=game.group.adapter,
+            extra=game.group.extra,
+        )
+        self = cls._player_class[role](bot, game, user)
+        await self._fetch_member(interface)
+        return self
 
     def __repr__(self) -> str:
         return f"<Player {self.role_name}: user={self.user_id!r} alive={self.alive}>"
 
+    @final
     @property
     def game(self) -> "Game":
         if game := self.__game_ref():
             return game
         raise ValueError("Game not exist")
 
+    @final
     @functools.cached_property
     def user_id(self) -> str:
         return self.__user.id
 
+    @final
     @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(
+    @final
+    async def _fetch_member(self, interface: Interface) -> None:
+        member = await interface.get_member(
             SceneType.GROUP,
-            self.game.group.id,
+            self.game.group_id,
             self.user_id,
         )
         if member is None:
-            member = await self.game.interface.get_member(
+            member = await interface.get_member(
                 SceneType.GUILD,
-                self.game.group.id,
+                self.game.group_id,
                 self.user_id,
             )
 
@@ -134,12 +220,10 @@ class Player:
     @final
     @property
     def colored_name(self) -> str:
-        name = escape_tag(self.user_id)
+        name = f"<b><e>{escape_tag(self.user_id)}</e></b>"
 
-        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 (nick := self._member_nick) is not None:
+            name = f"<y>{nick}</y>({name})"
 
         if self._member is not None and self._member.user.avatar is not None:
             name = link(name, self._member.user.avatar)
@@ -183,47 +267,40 @@ class Player:
 
     @property
     def interact_timeout(self) -> float:
-        return GameBehavior.get().timeout.interact
-
-    async def _before_interact(self) -> None:
-        return
-
-    async def _interact(self) -> None:
-        return
-
-    async def _after_interact(self) -> None:
-        return
+        return self.game.behavior.timeout.interact
 
+    @final
     async def interact(self) -> None:
-        if not getattr(self._interact, "__override__", False):
+        if self.interact_provider is None:
             await self.send("ℹ️请等待其他玩家结束交互...")
             return
 
-        await self._before_interact()
+        provider = self.interact_provider(self)
+
+        await provider.before()
 
         timeout = self.interact_timeout
         await self.send(f"✏️{self.role_name}交互开始，限时 {timeout / 60:.2f} 分钟")
 
         try:
             with anyio.fail_after(timeout):
-                await self._interact()
+                await provider.interact()
         except TimeoutError:
             logger.debug(f"{self.role_name}交互超时 (<y>{timeout}</y>s)")
             await self.send(f"⚠️{self.role_name}交互超时")
 
-        await self._after_interact()
+        await provider.after()
 
     async def notify_role(self) -> None:
-        await self._fetch_member()
-        await self.send(f"⚙️你的身份: {ROLE_EMOJI[self.role]}{self.role_name}")
+        await self.notify_provider(self).notify()
 
-    async def kill(self, reason: KillReason, *killers: "Player") -> bool:
-        if self.alive:
-            self.alive = False
-            self.kill_info = KillInfo(reason=reason, killers=[p.name for p in killers])
-        return True
+    @final
+    async def kill(self, reason: KillReason, *killers: "Player") -> KillInfo | None:
+        return await self.kill_provider(self).kill(reason, *killers)
 
+    @final
     async def post_kill(self) -> None:
+        await self.kill_provider(self).post_kill()
         self.killed.set()
 
     async def vote(self, players: "PlayerSet") -> "Player | None":
@@ -238,8 +315,8 @@ class Player:
         )
 
         try:
-            with anyio.fail_after(GameBehavior.get().timeout.vote):
-                selected = await self._select_player(
+            with anyio.fail_after(self.game.behavior.timeout.vote):
+                selected = await self.select_player(
                     players,
                     on_stop="⚠️你选择了弃票",
                     on_index_error="⚠️输入错误: 请发送编号选择玩家",
@@ -255,15 +332,16 @@ class Player:
     async def _check_selected(self, player: "Player") -> "Player | None":
         return player
 
-    async def _select_player(
+    @final
+    async def select_player(
         self,
         players: "PlayerSet",
         *,
-        on_stop: str | None = None,
+        on_stop: str | EllipsisType | None = ...,
         on_index_error: str | None = None,
         stop_btn_label: str | None = None,
     ) -> "Player | None":
-        on_stop = on_stop or "ℹ️你选择了取消，回合结束"
+        on_stop = on_stop if on_stop is not None else "ℹ️你选择了取消，回合结束"
         on_index_error = (
             on_index_error or f"⚠️输入错误: 请发送玩家编号或 “{stop_command_prompt()}”"
         )
@@ -272,11 +350,10 @@ class Player:
         while selected is None:
             text = await self.receive_text()
             if text == STOP_COMMAND:
-                if on_stop is not None:
+                if on_stop is not ...:
                     await self.send(on_stop)
                 return None
-            index = check_index(text, len(players))
-            if index is None:
+            if (index := check_index(text, players.size)) is None:
                 await self.send(
                     on_index_error,
                     stop_btn_label=stop_btn_label,

nonebot_plugin_werewolf/player_set.py

@@ -1,38 +1,47 @@
 import functools
+import random
+from collections.abc import Iterable
+from typing_extensions import Self
 
 import anyio
 from nonebot_plugin_alconna.uniseg import UniMessage
 
 from .models import Role, RoleGroup
-from .players import Player
+from .player import Player
 
 
 class PlayerSet(set[Player]):
+    __slots__ = ("__dict__",)  # for cached_property `sorted`
+
     @property
     def size(self) -> int:
         return len(self)
 
-    def alive(self) -> "PlayerSet":
-        return PlayerSet(p for p in self if p.alive)
+    @classmethod
+    def from_(cls, iterable: Iterable[Player], /) -> Self:
+        return cls(iterable)
+
+    def alive(self) -> Self:
+        return self.from_(p for p in self if p.alive)
 
-    def dead(self) -> "PlayerSet":
-        return PlayerSet(p for p in self if not p.alive)
+    def dead(self) -> Self:
+        return self.from_(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 killed(self) -> Self:
+        return self.from_(p for p in self if p.killed.is_set())
 
-    def include(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
-        return PlayerSet(
+    def include(self, *types: Player | Role | RoleGroup) -> Self:
+        return self.from_(
             player
             for player in self
             if (player in types or player.role in types or player.role_group in types)
         )
 
-    def select(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
+    def select(self, *types: Player | Role | RoleGroup) -> Self:
         return self.include(*types)
 
-    def exclude(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
-        return PlayerSet(
+    def exclude(self, *types: Player | Role | RoleGroup) -> Self:
+        return self.from_(
             player
             for player in self
             if (
@@ -42,13 +51,19 @@ class PlayerSet(set[Player]):
             )
         )
 
-    def player_selected(self) -> "PlayerSet":
-        return PlayerSet(p.selected for p in self.alive() if p.selected is not None)
+    def player_selected(self) -> Self:
+        return self.from_(p.selected for p in self.alive() if (p.selected is not None))
 
     @functools.cached_property
     def sorted(self) -> list[Player]:
         return sorted(self, key=lambda p: p.user_id)
 
+    @property
+    def shuffled(self) -> list[Player]:
+        players = self.sorted.copy()
+        random.shuffle(players)
+        return players
+
     async def vote(self) -> dict[Player, list[Player]]:
         players = self.alive()
         result: dict[Player, list[Player]] = {}
@@ -56,7 +71,7 @@ class PlayerSet(set[Player]):
         async def _vote(player: Player) -> None:
             vote = await player.vote(players)
             if vote is not None:
-                result[vote] = [*result.get(vote, []), player]
+                result.setdefault(vote, []).append(player)
 
         async with anyio.create_task_group() as tg:
             for p in players:
@@ -68,16 +83,17 @@ class PlayerSet(set[Player]):
         if not self:
             return
 
+        send = functools.partial(
+            Player.send,
+            message=message,
+            stop_btn_label=None,
+            select_players=None,
+            skip_handler=True,
+        )
+
         async with anyio.create_task_group() as tg:
             for p in self:
-                func = functools.partial(
-                    p.send,
-                    message=message,
-                    stop_btn_label=None,
-                    select_players=None,
-                    skip_handler=True,
-                )
-                tg.start_soon(func)
+                tg.start_soon(send, p)
 
     def show(self) -> str:
         return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted, 1))

nonebot_plugin_werewolf/players/__init__.py

@@ -3,7 +3,6 @@ from .guard import Guard as Guard
 from .hunter import Hunter as Hunter
 from .idiot import Idiot as Idiot
 from .jester import Jester as Jester
-from .player import Player as Player
 from .prophet import Prophet as Prophet
 from .werewolf import Werewolf as Werewolf
 from .witch import Witch as Witch

nonebot_plugin_werewolf/players/civilian.py

@@ -1,7 +1,7 @@
 from ..models import Role, RoleGroup
-from .player import Player
+from ..player import Player
 
 
-@Player.register_role(Role.CIVILIAN, RoleGroup.GOODGUY)
 class Civilian(Player):
-    pass
+    role = Role.CIVILIAN
+    role_group = RoleGroup.GOODGUY

nonebot_plugin_werewolf/players/guard.py

@@ -2,23 +2,14 @@ from typing_extensions import override
 
 from ..constant import stop_command_prompt
 from ..models import GameState, Role, RoleGroup
-from .player import Player
+from ..player import InteractProvider, Player
 
 
-@Player.register_role(Role.GUARD, RoleGroup.GOODGUY)
-class Guard(Player):
-    @override
-    async def _check_selected(self, player: Player) -> Player | None:
-        if self.game.state.state == GameState.State.NIGHT and player is self.selected:
-            await self.send("⚠️守卫不能连续两晚保护同一目标，请重新选择")
-            return None
-
-        return player
-
+class GuardInteractProvider(InteractProvider["Guard"]):
     @override
-    async def _interact(self) -> None:
+    async def interact(self) -> None:
         players = self.game.players.alive()
-        await self.send(
+        await self.p.send(
             "💫请选择需要保护的玩家:\n"
             f"{players.show()}\n\n"
             "🛡️发送编号选择玩家\n"
@@ -27,7 +18,21 @@ class Guard(Player):
             select_players=players,
         )
 
-        self.selected = await self._select_player(players, stop_btn_label="结束回合")
+        self.selected = await self.p.select_player(players, stop_btn_label="结束回合")
         if self.selected:
             self.game.state.protected.add(self.selected)
-            await self.send(f"✅本回合保护的玩家: {self.selected.name}")
+            await self.p.send(f"✅本回合保护的玩家: {self.selected.name}")
+
+
+class Guard(Player):
+    role = Role.GUARD
+    role_group = RoleGroup.GOODGUY
+    interact_provider = GuardInteractProvider
+
+    @override
+    async def _check_selected(self, player: Player) -> Player | None:
+        if self.game.state.state == GameState.State.NIGHT and player is self.selected:
+            await self.send("⚠️守卫不能连续两晚保护同一目标，请重新选择")
+            return None
+
+        return player

nonebot_plugin_werewolf/players/hunter.py

@@ -1,8 +1,9 @@
 from ..models import Role, RoleGroup
-from .can_shoot import CanShoot
-from .player import Player
+from ..player import Player
+from .shooter import ShooterKillProvider
 
 
-@Player.register_role(Role.HUNTER, RoleGroup.GOODGUY)
-class Hunter(CanShoot, Player):
-    pass
+class Hunter(Player):
+    role = Role.HUNTER
+    role_group = RoleGroup.GOODGUY
+    kill_provider = ShooterKillProvider

nonebot_plugin_werewolf/players/idiot.py

@@ -1,30 +1,20 @@
-from __future__ import annotations
-
 from typing import TYPE_CHECKING
 from typing_extensions import override
 
 from nonebot_plugin_alconna.uniseg import UniMessage
 
-from ..models import KillReason, Role, RoleGroup
-from .player import Player
+from ..models import KillInfo, KillReason, Role, RoleGroup
+from ..player import KillProvider, NotifyProvider, Player
 
 if TYPE_CHECKING:
     from ..player_set import PlayerSet
 
 
-@Player.register_role(Role.IDIOT, RoleGroup.GOODGUY)
-class Idiot(Player):
-    voted: bool = False
-
-    @override
-    async def notify_role(self) -> None:
-        await super().notify_role()
-        await self.send(
-            "作为白痴，你可以在首次被投票放逐时免疫放逐，但在之后的投票中无法继续投票"
-        )
+class IdiotKillProvider(KillProvider["Idiot"]):
+    voted = KillProvider.proxy(bool)
 
     @override
-    async def kill(self, reason: KillReason, *killers: Player) -> bool:
+    async def kill(self, reason: KillReason, *killers: Player) -> KillInfo | None:
         if reason == KillReason.VOTE and not self.voted:
             self.voted = True
             await self.game.send(
@@ -33,11 +23,29 @@ class Idiot(Player):
                 .text(" 的身份是白痴\n")
                 .text("免疫本次投票放逐，且接下来无法参与投票"),
             )
-            return False
+            return None
+
         return await super().kill(reason, *killers)
 
+
+class IdiotNotifyProvider(NotifyProvider["Idiot"]):
+    @override
+    def message(self, message: UniMessage) -> UniMessage:
+        return message.text(
+            "作为白痴，你可以在首次被投票放逐时免疫放逐，但在之后的投票中无法继续投票"
+        )
+
+
+class Idiot(Player):
+    role = Role.IDIOT
+    role_group = RoleGroup.GOODGUY
+    kill_provider = IdiotKillProvider
+    notify_provider = IdiotNotifyProvider
+
+    voted: bool = False
+
     @override
-    async def vote(self, players: PlayerSet) -> Player | None:
+    async def vote(self, players: "PlayerSet") -> Player | None:
         if self.voted:
             await self.send("ℹ️你已经发动过白痴身份的技能，无法参与本次投票")
             return None

nonebot_plugin_werewolf/players/jester.py

@@ -1,24 +1,29 @@
-from typing import TYPE_CHECKING
 from typing_extensions import override
 
+from nonebot_plugin_alconna import UniMessage
+
 from ..exception import GameFinished
-from ..models import GameStatus, KillReason, Role, RoleGroup
-from .player import Player
+from ..models import GameStatus, KillInfo, KillReason, Role, RoleGroup
+from ..player import KillProvider, NotifyProvider, Player
 
 
-@Player.register_role(Role.JESTER, RoleGroup.OTHERS)
-class Jester(Player):
-    @override
-    async def notify_role(self) -> None:
-        await super().notify_role()
-        await self.send("⚙️你的胜利条件: 被投票放逐")
+class JesterKillProvider(KillProvider["Jester"]):
+    async def kill(self, reason: KillReason, *killers: Player) -> KillInfo | None:
+        kill_info = await super().kill(reason, *killers)
+        if kill_info is not None and reason == KillReason.VOTE:
+            self.game.killed_players.append((self.name, kill_info))
+            raise GameFinished(GameStatus.JESTER)
+        return kill_info
+
 
+class JesterNotifyProvider(NotifyProvider["Jester"]):
     @override
-    async def kill(self, reason: KillReason, *killers: Player) -> bool:
-        await super().kill(reason, *killers)
-        if reason == KillReason.VOTE:
-            if TYPE_CHECKING:
-                assert self.kill_info is not None
-            self.game.killed_players.append((self.name, self.kill_info))
-            raise GameFinished(GameStatus.JESTER)
-        return True
+    def message(self, message: UniMessage) -> UniMessage:
+        return message.text("⚙️你的胜利条件: 被投票放逐")
+
+
+class Jester(Player):
+    role = Role.JESTER
+    role_group = RoleGroup.OTHERS
+    kill_provider = JesterKillProvider
+    notify_provider = JesterNotifyProvider