nonebot-plugin-werewolf 1.1.7__py3-none-any.whl → 1.1.9__py3-none-any.whl

nonebot_plugin_werewolf/player.py

@@ -0,0 +1,366 @@
+import functools
+import weakref
+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 Interface, SceneType
+
+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,
+    add_stop_button,
+    check_index,
+    link,
+)
+
+if TYPE_CHECKING:
+    from .game import Game
+    from .player_set import PlayerSet
+
+
+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,
+        msg: UniMessage,
+        stop_btn_label: str | None = None,
+    ) -> UniMessage:
+        if stop_btn_label is not None:
+            msg = add_stop_button(msg, stop_btn_label)
+        return msg
+
+
+class 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
+    killed: Final[anyio.Event]
+    kill_info: KillInfo | None = None
+    selected: "Player | None" = None
+
+    @final
+    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)
+
+    @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
+    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}")
+
+        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]
+
+    @final
+    async def _fetch_member(self, interface: Interface) -> None:
+        member = await interface.get_member(
+            SceneType.GROUP,
+            self.game.group_id,
+            self.user_id,
+        )
+        if member is None:
+            member = await 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
+    @property
+    def colored_name(self) -> str:
+        name = f"<b><e>{escape_tag(self.user_id)}</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)
+
+        return name
+
+    @final
+    def log(self, text: str) -> None:
+        text = text.replace("\n", "\\n")
+        self.game.log(f"[<b><m>{self.role_name}</m></b>] {self.colored_name} | {text}")
+
+    @final
+    async def send(
+        self,
+        message: str | UniMessage,
+        *,
+        stop_btn_label: str | None = None,
+        select_players: "PlayerSet | None" = None,
+        skip_handler: bool = False,
+    ) -> Receipt:
+        if isinstance(message, str):
+            message = UniMessage.text(message)
+
+        self.log(f"<g>Send</g> | {escape_tag(str(message))}")
+
+        if select_players:
+            message = add_players_button(message, select_players)
+        if skip_handler:
+            return await message.send(self.__user, self.bot)
+        return await self._send_handler.send(message, stop_btn_label)
+
+    @final
+    async def receive(self) -> UniMessage:
+        result = await InputStore.fetch(self.user_id)
+        self.log(f"<y>Recv</y> | {escape_tag(str(result))}")
+        return result
+
+    @final
+    async def receive_text(self) -> str:
+        return (await self.receive()).extract_plain_text()
+
+    @property
+    def interact_timeout(self) -> float:
+        return self.game.behavior.timeout.interact
+
+    @final
+    async def interact(self) -> None:
+        if self.interact_provider is None:
+            await self.send("ℹ️请等待其他玩家结束交互...")
+            return
+
+        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 provider.interact()
+        except TimeoutError:
+            logger.debug(f"{self.role_name}交互超时 (<y>{timeout}</y>s)")
+            await self.send(f"⚠️{self.role_name}交互超时")
+
+        await provider.after()
+
+    async def notify_role(self) -> None:
+        await self.notify_provider(self).notify()
+
+    @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":
+        await self.send(
+            f"💫请选择需要投票的玩家:\n"
+            f"{players.show()}\n\n"
+            "🗳️发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 弃票\n\n"
+            "限时1分钟，超时将视为弃票",
+            stop_btn_label="弃票",
+            select_players=players,
+        )
+
+        try:
+            with anyio.fail_after(self.game.behavior.timeout.vote):
+                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
+
+    @final
+    async def select_player(
+        self,
+        players: "PlayerSet",
+        *,
+        on_stop: str | EllipsisType | None = ...,
+        on_index_error: str | None = None,
+        stop_btn_label: str | None = None,
+    ) -> "Player | None":
+        on_stop = on_stop if on_stop is not None else "ℹ️你选择了取消，回合结束"
+        on_index_error = (
+            on_index_error or f"⚠️输入错误: 请发送玩家编号或 “{stop_command_prompt()}”"
+        )
+        selected = None
+
+        while selected is None:
+            text = await self.receive_text()
+            if text == STOP_COMMAND:
+                if on_stop is not ...:
+                    await self.send(on_stop)
+                return None
+            if (index := check_index(text, players.size)) is None:
+                await self.send(
+                    on_index_error,
+                    stop_btn_label=stop_btn_label,
+                    select_players=players,
+                )
+                continue
+            selected = await self._check_selected(players[index - 1])
+
+        return selected

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,17 +51,18 @@ 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)
 
-    async def interact(self) -> None:
-        async with anyio.create_task_group() as tg:
-            for p in self.alive():
-                tg.start_soon(p.interact)
+    @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()
@@ -61,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:
@@ -73,12 +83,20 @@ 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:
-                tg.start_soon(p.send, message)
+                tg.start_soon(send, p)
 
     def show(self) -> str:
         return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted, 1))
 
-    def __getitem__(self, __index: int) -> Player:
-        return self.sorted[__index]
+    def __getitem__(self, index: int, /) -> Player:
+        return self.sorted[index]

nonebot_plugin_werewolf/players/__init__.py

@@ -2,8 +2,7 @@ from .civilian import Civilian as Civilian
 from .guard import Guard as Guard
 from .hunter import Hunter as Hunter
 from .idiot import Idiot as Idiot
-from .joker import Joker as Joker
-from .player import Player as Player
+from .jester import Jester as Jester
 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

@@ -1,31 +1,38 @@
-from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import STOP_COMMAND_PROMPT
-from ..models import Role, RoleGroup
-from .player import Player
+from ..constant import stop_command_prompt
+from ..models import GameState, Role, RoleGroup
+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 player is not self.selected:
-            return player
-        await self.send("⚠️守卫不能连续两晚保护同一目标，请重新选择")
-        return None
-
+class GuardInteractProvider(InteractProvider["Guard"]):
     @override
     async def interact(self) -> None:
         players = self.game.players.alive()
-        await self.send(
-            UniMessage.text("💫请选择需要保护的玩家:\n")
-            .text(players.show())
-            .text("\n\n🛡️发送编号选择玩家")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
+        await self.p.send(
+            "💫请选择需要保护的玩家:\n"
+            f"{players.show()}\n\n"
+            "🛡️发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 结束回合",
+            stop_btn_label="结束回合",
+            select_players=players,
         )
 
-        self.selected = await self._select_player(players)
+        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,31 +1,21 @@
-from __future__ import annotations
-
 from typing import TYPE_CHECKING
+from typing_extensions import override
 
 from nonebot_plugin_alconna.uniseg import UniMessage
-from typing_extensions import override
 
-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
+class IdiotKillProvider(KillProvider["Idiot"]):
+    voted = KillProvider.proxy(bool)
 
     @override
-    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:
+    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(
                 UniMessage.text("⚙️玩家")
@@ -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

@@ -0,0 +1,29 @@
+from typing_extensions import override
+
+from nonebot_plugin_alconna import UniMessage
+
+from ..exception import GameFinished
+from ..models import GameStatus, KillInfo, KillReason, Role, RoleGroup
+from ..player import KillProvider, NotifyProvider, Player
+
+
+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
+    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