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

nonebot_plugin_werewolf/players/prophet.py

@@ -1,23 +1,29 @@
-from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import STOP_COMMAND_PROMPT
+from ..constant import stop_command_prompt
 from ..models import Role, RoleGroup
-from .player import Player
+from ..player import InteractProvider, Player
 
 
-@Player.register_role(Role.Prophet, RoleGroup.GoodGuy)
-class Prophet(Player):
+class ProphetInteractProvider(InteractProvider["Prophet"]):
     @override
     async def interact(self) -> None:
-        players = self.game.players.alive().exclude(self)
-        await self.send(
-            UniMessage.text("💫请选择需要查验身份的玩家:\n")
-            .text(players.show())
-            .text("\n\n🔮发送编号选择玩家")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合(不查验身份)")
+        players = self.game.players.alive().exclude(self.p)
+        await self.p.send(
+            "💫请选择需要查验身份的玩家:\n"
+            f"{players.show()}\n\n"
+            "🔮发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 结束回合(不查验身份)",
+            stop_btn_label="结束回合",
+            select_players=players,
         )
 
-        if selected := await self._select_player(players):
-            result = "狼人" if selected.role_group == RoleGroup.Werewolf else "好人"
-            await self.send(f"✏️玩家 {selected.name} 的阵营是『{result}』")
+        if selected := await self.p.select_player(players, stop_btn_label="结束回合"):
+            result = "狼人" if selected.role_group == RoleGroup.WEREWOLF else "好人"
+            await self.p.send(f"✏️玩家 {selected.name} 的阵营是『{result}』")
+
+
+class Prophet(Player):
+    role = Role.PROPHET
+    role_group = RoleGroup.GOODGUY
+    interact_provider = ProphetInteractProvider

nonebot_plugin_werewolf/players/shooter.py

@@ -0,0 +1,54 @@
+from typing_extensions import override
+
+from nonebot_plugin_alconna.uniseg import UniMessage
+
+from ..constant import stop_command_prompt
+from ..models import KillReason
+from ..player import KillProvider, Player
+
+
+class ShooterKillProvider(KillProvider["Player"]):
+    @override
+    async def post_kill(self) -> None:
+        if self.kill_info and self.kill_info.reason == KillReason.POISON:
+            await self.p.send("⚠️你昨晚被女巫毒杀，无法使用技能")
+            return await super().post_kill()
+
+        await self.game.send(
+            UniMessage.text("🕵️玩家 ")
+            .at(self.user_id)
+            .text(" 死了\n请在私聊决定射杀目标...")
+        )
+
+        self.game.state.shooter = None
+        shoot = await self.shoot()
+        msg = UniMessage.text("玩家 ").at(self.user_id).text(" ")
+        if shoot is not None:
+            self.game.state.shooter = self.p
+            await self.game.send("🔫" + msg.text("射杀了玩家 ").at(shoot.user_id))
+            await shoot.kill(KillReason.SHOOT, self.p)
+            self.selected = shoot
+        else:
+            await self.game.send("ℹ️" + msg.text("选择了取消技能"))
+
+        return await super().post_kill()
+
+    async def shoot(self) -> Player | None:
+        players = self.game.players.alive().exclude(self.p)
+        await self.p.send(
+            "💫请选择需要射杀的玩家:\n"
+            f"{players.show()}\n\n"
+            "🔫发送编号选择玩家\n"
+            f"❌发送 “{stop_command_prompt()}” 取消技能",
+            stop_btn_label="取消技能",
+            select_players=players,
+        )
+
+        if selected := await self.p.select_player(
+            players,
+            on_stop="ℹ️已取消技能，回合结束",
+            stop_btn_label="取消技能",
+        ):
+            await self.p.send(f"🎯选择射杀的玩家: {selected.name}")
+
+        return selected

nonebot_plugin_werewolf/players/werewolf.py

@@ -1,55 +1,58 @@
+import secrets
 from typing import TYPE_CHECKING
+from typing_extensions import override
 
 import anyio
 from nonebot_plugin_alconna.uniseg import UniMessage
-from typing_extensions import override
 
-from ..constant import STOP_COMMAND, STOP_COMMAND_PROMPT
+from ..constant import STOP_COMMAND, stop_command_prompt
 from ..models import Role, RoleGroup
-from ..utils import ObjectStream, check_index
-from .player import Player
+from ..player import InteractProvider, NotifyProvider, Player
+from ..utils import ObjectStream, as_player_set, check_index
 
 if TYPE_CHECKING:
     from ..player_set import PlayerSet
 
 
-@Player.register_role(Role.Werewolf, RoleGroup.Werewolf)
-class Werewolf(Player):
+class WerewolfInteractProvider(InteractProvider["Werewolf"]):
     stream: ObjectStream[str | UniMessage]
 
     @override
-    async def notify_role(self) -> None:
-        await super().notify_role()
-        partners = self.game.players.alive().select(RoleGroup.Werewolf).exclude(self)
-        if partners:
-            await self.send(
-                "🐺你的队友:\n"
-                + "\n".join(f"  {p.role_name}: {p.name}" for p in partners)
-            )
+    async def before(self) -> None:
+        self.game.state.werewolf_start()
 
-    async def _handle_interact(self, players: "PlayerSet") -> None:
+    async def handle_interact(self, players: "PlayerSet") -> None:
         self.selected = None
 
         while True:
-            input_msg = await self.receive()
+            input_msg = await self.p.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 self.stream.send(f"📝队友 {self.name} {msg}")
+                await self.p.send(
+                    f"🎯{msg}\n发送 “{stop_command_prompt()}” 结束回合",
+                    stop_btn_label="结束回合",
+                    select_players=players,
+                )
+                await self.stream.send(f"📝队友 {self.p.name} {msg}")
             if text == STOP_COMMAND:
                 if self.selected is not None:
-                    await self.send("✅你已结束当前回合")
-                    await self.stream.send(f"📝队友 {self.name} 结束当前回合")
+                    await self.p.send("✅你已结束当前回合")
+                    await self.stream.send(f"📝队友 {self.p.name} 结束当前回合")
                     self.stream.close()
                     return
-                await self.send("⚠️当前未选择玩家，无法结束回合")
+                await self.p.send(
+                    "⚠️当前未选择玩家，无法结束回合",
+                    select_players=players,
+                )
             else:
-                await self.stream.send(UniMessage(f"💬队友 {self.name}:\n") + input_msg)
+                await self.stream.send(
+                    UniMessage.text(f"💬队友 {self.p.name}:\n") + input_msg
+                )
 
-    async def _handle_broadcast(self, partners: "PlayerSet") -> None:
+    async def handle_broadcast(self, partners: "PlayerSet") -> None:
         while not self.stream.closed:
             try:
                 message = await self.stream.recv()
@@ -61,7 +64,7 @@ class Werewolf(Player):
     @override
     async def interact(self) -> None:
         players = self.game.players.alive()
-        partners = players.select(RoleGroup.Werewolf).exclude(self)
+        partners = players.select(RoleGroup.WEREWOLF).exclude(self.p)
 
         msg = UniMessage()
         if partners:
@@ -70,19 +73,75 @@ class Werewolf(Player):
                 .text("\n".join(f"  {p.role_name}: {p.name}" for p in partners))
                 .text("\n所有私聊消息将被转发至队友\n\n")
             )
-        await self.send(
+        await self.p.send(
             msg.text("💫请选择今晚的目标:\n")
             .text(players.show())
             .text("\n\n🔪发送编号选择玩家")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
-            .text("\n\n⚠️意见未统一将空刀")
+            .text(f"\n❌发送 “{stop_command_prompt()}” 结束回合")
+            .text("\n\n⚠️意见未统一将空刀"),
+            select_players=players,
         )
 
         self.stream = ObjectStream[str | UniMessage](8)
 
         try:
             async with anyio.create_task_group() as tg:
-                tg.start_soon(self._handle_interact, players)
-                tg.start_soon(self._handle_broadcast, partners)
+                tg.start_soon(self.handle_interact, players)
+                tg.start_soon(self.handle_broadcast, partners)
         finally:
             del self.stream
+
+    async def finalize(self) -> None:
+        w = self.game.players.alive().select(RoleGroup.WEREWOLF)
+        match w.player_selected().shuffled:
+            case []:
+                await w.broadcast("⚠️狼人未选择目标，此晚空刀")
+            case [killed]:
+                self.game.state.killed = killed
+                await w.broadcast(f"🔪今晚选择的目标为: {killed.name}")
+            case [killed, *_] if self.game.behavior.werewolf_multi_select:
+                self.game.state.killed = killed
+                await w.broadcast(
+                    "⚠️狼人阵营意见未统一，随机选择目标\n\n"
+                    f"🔪今晚选择的目标为: {killed.name}"
+                )
+            case players:
+                await w.broadcast(
+                    f"⚠️狼人阵营意见未统一，此晚空刀\n\n"
+                    f"📝选择的玩家:\n{as_player_set(*players).show()}"
+                )
+
+    @override
+    async def after(self) -> None:
+        if self.game.state.werewolf_end():
+            await self.finalize()
+
+        if not self.game.players.alive().select(Role.WITCH):
+            await anyio.sleep(5 + secrets.randbelow(15))
+
+
+class WerewolfNotifyProvider(NotifyProvider["Werewolf"]):
+    @override
+    def message(self, message: UniMessage) -> UniMessage:
+        if (
+            partners := self.game.players.alive()
+            .select(RoleGroup.WEREWOLF)
+            .exclude(self.p)
+        ):
+            message = message.text(
+                "\n🐺你的队友:\n\n"
+                + "".join(f"  {p.role_name}: {p.name}\n" for p in partners)
+            )
+        return message
+
+
+class Werewolf(Player):
+    role = Role.WEREWOLF
+    role_group = RoleGroup.WEREWOLF
+    interact_provider = WerewolfInteractProvider
+    notify_provider = WerewolfNotifyProvider
+
+    @property
+    @override
+    def interact_timeout(self) -> float:
+        return self.game.behavior.timeout.werewolf

nonebot_plugin_werewolf/players/witch.py

@@ -1,42 +1,52 @@
-from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import STOP_COMMAND_PROMPT
+from nonebot_plugin_alconna.uniseg import UniMessage
+
+from ..constant import stop_command_prompt
 from ..models import Role, RoleGroup
+from ..player import InteractProvider, Player
 from ..utils import as_player_set
-from .player import Player
 
 
-@Player.register_role(Role.Witch, RoleGroup.GoodGuy)
-class Witch(Player):
-    antidote: bool = True
-    poison: bool = True
+class WitchInteractProvider(InteractProvider["Witch"]):
+    antidote = InteractProvider.proxy(bool)
+    poison = InteractProvider.proxy(bool)
+
+    @override
+    async def before(self) -> None:
+        await self.p.send("ℹ️请等待狼人决定目标...")
+        await self.game.state.werewolf_finished.wait()
 
     async def handle_killed(self) -> bool:
         if (killed := self.game.state.killed) is None:
-            await self.send("ℹ️今晚没有人被刀")
+            await self.p.send("ℹ️今晚没有人被刀")
             return False
 
         msg = UniMessage.text(f"🔪今晚 {killed.name} 被刀了\n\n")
 
         if not self.antidote:
-            await self.send(msg.text("⚙️你已经用过解药了"))
+            await self.p.send(msg.text("⚙️你已经用过解药了"))
             return False
 
-        msg.text(f"✏️使用解药请发送 “1”\n❌不使用解药请发送 “{STOP_COMMAND_PROMPT}”")
-        await self.send(msg)
+        msg.text(f"✏️使用解药请发送 “1”\n❌不使用解药请发送 “{stop_command_prompt()}”")
+        await self.p.send(
+            msg,
+            stop_btn_label="不使用解药",
+            select_players=as_player_set(killed),
+        )
 
-        if not await self._select_player(
+        if not await self.p.select_player(
             as_player_set(killed),
             on_stop=f"ℹ️你选择不对 {killed.name} 使用解药",
-            on_index_error=f"⚠️输入错误: 请输入 “1” 或 “{STOP_COMMAND_PROMPT}”",
+            on_index_error=f"⚠️输入错误: 请输入 “1” 或 “{stop_command_prompt()}”",
+            stop_btn_label="不使用解药",
         ):
             return False
 
         self.antidote = False
         self.selected = killed
         self.game.state.antidote.add(killed)
-        await self.send(f"✅你对 {killed.name} 使用了解药，回合结束")
+        await self.p.send(f"✅你对 {killed.name} 使用了解药，回合结束")
         return True
 
     @override
@@ -45,23 +55,37 @@ class Witch(Player):
             return
 
         if not self.poison:
-            await self.send("⚙️你没有可以使用的药水，回合结束")
+            await self.p.send("⚙️你没有可以使用的药水，回合结束")
             return
 
         players = self.game.players.alive()
-        await self.send(
-            UniMessage.text("💫你有一瓶毒药\n")
-            .text("玩家列表:\n")
-            .text(players.show())
-            .text("\n\n🧪发送玩家编号使用毒药")
-            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合(不使用药水)")
+        await self.p.send(
+            "💫你有一瓶毒药\n"
+            "玩家列表:\n"
+            f"{players.show()}\n\n"
+            "🧪发送玩家编号使用毒药\n"
+            f"❌发送 “{stop_command_prompt()}” 结束回合(不使用药水)",
+            stop_btn_label="结束回合",
+            select_players=players,
         )
 
-        if selected := await self._select_player(
+        if selected := await self.p.select_player(
             players,
             on_stop="ℹ️你选择不使用毒药，回合结束",
+            stop_btn_label="结束回合",
         ):
             self.poison = False
             self.selected = selected
-            self.game.state.poison.add(self)
-            await self.send(f"✅当前回合选择对玩家 {selected.name} 使用毒药\n回合结束")
+            self.game.state.poison.add(self.p)
+            await self.p.send(
+                f"✅当前回合选择对玩家 {selected.name} 使用毒药\n回合结束"
+            )
+
+
+class Witch(Player):
+    role = Role.WITCH
+    role_group = RoleGroup.GOODGUY
+    interact_provider = WitchInteractProvider
+
+    antidote: bool = True
+    poison: bool = True

nonebot_plugin_werewolf/players/wolfking.py

@@ -1,14 +1,20 @@
 from typing_extensions import override
 
+from nonebot_plugin_alconna import UniMessage
+
 from ..models import Role, RoleGroup
-from .can_shoot import CanShoot
-from .player import Player
-from .werewolf import Werewolf
+from .shooter import ShooterKillProvider
+from .werewolf import Werewolf, WerewolfNotifyProvider
 
 
-@Player.register_role(Role.WolfKing, RoleGroup.Werewolf)
-class WolfKing(CanShoot, Werewolf):
+class WolfKingNotifyProvider(WerewolfNotifyProvider):
     @override
-    async def notify_role(self) -> None:
-        await super().notify_role()
-        await self.send("⚙️作为狼王，你可以在死后射杀一名玩家")
+    def message(self, message: UniMessage) -> UniMessage:
+        return super().message(message).text("⚙️作为狼王，你可以在死后射杀一名玩家")
+
+
+class WolfKing(Werewolf):
+    role = Role.WOLFKING
+    role_group = RoleGroup.WEREWOLF
+    kill_provider = ShooterKillProvider
+    notify_provider = WolfKingNotifyProvider

nonebot_plugin_werewolf/utils.py

@@ -1,20 +1,33 @@
+import abc
 import functools
 import itertools
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, ParamSpec, TypeVar
 
 import anyio
 import anyio.streams.memory
-from nonebot_plugin_alconna import UniMessage
+from nonebot.adapters import Bot, Event
+from nonebot.internal.matcher import current_bot
+from nonebot_plugin_alconna.uniseg import (
+    Button,
+    FallbackStrategy,
+    Keyboard,
+    Receipt,
+    Target,
+    UniMessage,
+)
 from nonebot_plugin_uninfo import Session
 
-from .constant import STOP_COMMAND
+from .config import config
+from .constant import STOP_COMMAND, stop_command_prompt
 
 if TYPE_CHECKING:
+    from .player import Player
     from .player_set import PlayerSet
-    from .players import Player
 
 T = TypeVar("T")
+P = ParamSpec("P")
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -85,7 +98,7 @@ class InputStore:
             task.set(msg)
 
     @classmethod
-    def cleanup(cls, players: list[str], group_id: str) -> None:
+    def cleanup(cls, players: Iterable[str], group_id: str) -> None:
         for p, g in itertools.product(players, (group_id, None)):
             key = cls._key(p, g)
             if key in cls.locks:
@@ -106,7 +119,10 @@ def as_player_set(*player: "Player") -> "PlayerSet":
 
 
 class ObjectStream(Generic[T]):
-    __unset: Any = object()
+    class Unset: ...
+
+    __UNSET: ClassVar[Unset] = Unset()
+
     _send: anyio.streams.memory.MemoryObjectSendStream[T]
     _recv: anyio.streams.memory.MemoryObjectReceiveStream[T]
     _closed: anyio.Event
@@ -119,7 +135,7 @@ class ObjectStream(Generic[T]):
         await self._send.send(obj)
 
     async def recv(self) -> T:
-        result = self.__unset
+        result: Any = self.__UNSET
 
         async def _recv() -> None:
             nonlocal result
@@ -134,7 +150,7 @@ class ObjectStream(Generic[T]):
             tg.start_soon(_recv)
             tg.start_soon(_cancel)
 
-        if result is self.__unset:
+        if result is self.__UNSET:
             raise anyio.EndOfStream
 
         return result
@@ -148,3 +164,86 @@ class ObjectStream(Generic[T]):
 
     async def wait_closed(self) -> None:
         await self._closed.wait()
+
+
+def _btn(label: str, text: str, /) -> Button:
+    return Button(flag="input", label=label, text=text)
+
+
+def add_stop_button(msg: str | UniMessage, label: str | None = None) -> UniMessage:
+    if isinstance(msg, str):
+        msg = UniMessage.text(msg)
+
+    stop = stop_command_prompt()
+    return msg.keyboard(_btn(label or stop, stop))
+
+
+def add_players_button(msg: str | UniMessage, players: "PlayerSet") -> UniMessage:
+    if isinstance(msg, str):
+        msg = UniMessage.text(msg)
+
+    it = enumerate(players, 1)
+    while line := tuple(itertools.islice(it, 3)):
+        msg.keyboard(*(_btn(p.name, str(i)) for i, p in line))
+    return msg
+
+
+class SendHandler(abc.ABC, Generic[P]):
+    bot: Bot
+    target: Event | Target
+    reply_to: bool | None = None
+    last_msg: UniMessage | None = None
+    last_receipt: Receipt | None = None
+
+    def update(self, target: Event | Target, bot: Bot | None = None) -> None:
+        self.bot = bot or current_bot.get()
+        self.target = target
+
+    async def _edit(self) -> None:
+        last = self.last_receipt
+        if (
+            config.enable_button
+            and self.last_msg is not None
+            and last is not None
+            and last.editable
+        ):
+            await last.edit(self.last_msg.exclude(Keyboard))
+
+    async def _send(self, message: UniMessage) -> None:
+        if not config.enable_button:
+            message = message.exclude(Keyboard)
+        receipt = await message.send(
+            target=self.target,
+            bot=self.bot,
+            reply_to=self.reply_to,
+            fallback=FallbackStrategy.ignore,
+        )
+        self.last_msg = message
+        self.last_receipt = receipt
+
+    @abc.abstractmethod
+    def solve_msg(
+        self,
+        msg: UniMessage,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> UniMessage:
+        raise NotImplementedError
+
+    async def send(
+        self,
+        msg: str | UniMessage,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Receipt:
+        msg = UniMessage.text(msg) if isinstance(msg, str) else msg
+        msg = self.solve_msg(msg, *args, **kwargs)
+
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(self._edit)
+            tg.start_soon(self._send, msg)
+
+        if TYPE_CHECKING:
+            assert self.last_receipt is not None
+
+        return self.last_receipt