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

nonebot_plugin_werewolf/players/guard.py

@@ -0,0 +1,30 @@
+from nonebot_plugin_alconna.uniseg import UniMessage
+from typing_extensions import override
+
+from ..constant import STOP_COMMAND_PROMPT, Role, RoleGroup
+from .player import 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
+
+    @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}” 结束回合")
+        )
+
+        self.selected = await self._select_player(players)
+        if self.selected:
+            self.game.state.protected.add(self.selected)
+            await self.send(f"✅本回合保护的玩家: {self.selected.name}")

nonebot_plugin_werewolf/players/hunter.py

@@ -0,0 +1,8 @@
+from ..constant import Role, RoleGroup
+from .can_shoot import CanShoot
+from .player import Player
+
+
+@Player.register_role(Role.Hunter, RoleGroup.GoodGuy)
+class Hunter(CanShoot, Player):
+    pass

nonebot_plugin_werewolf/players/idiot.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from nonebot_plugin_alconna.uniseg import UniMessage
+from typing_extensions import override
+
+from ..constant import KillReason, Role, RoleGroup
+from .player import 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(
+            "作为白痴，你可以在首次被投票放逐时免疫放逐，但在之后的投票中无法继续投票"
+        )
+
+    @override
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
+        if reason == KillReason.Vote and not self.voted:
+            self.voted = True
+            await self.game.send(
+                UniMessage.text("⚙️玩家")
+                .at(self.user_id)
+                .text(" 的身份是白痴\n")
+                .text("免疫本次投票放逐，且接下来无法参与投票"),
+            )
+            return False
+        return await super().kill(reason, *killers)
+
+    @override
+    async def vote(self, players: PlayerSet) -> Player | None:
+        if self.voted:
+            await self.send("ℹ️你已经发动过白痴身份的技能，无法参与本次投票")
+            return None
+        return await super().vote(players)

nonebot_plugin_werewolf/players/joker.py

@@ -0,0 +1,21 @@
+from typing_extensions import override
+
+from ..constant import GameStatus, KillReason, Role, RoleGroup
+from ..exception import GameFinished
+from .player import Player
+
+
+@Player.register_role(Role.Joker, RoleGroup.Others)
+class Joker(Player):
+    @override
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send("⚙️你的胜利条件: 被投票放逐")
+
+    @override
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
+        await super().kill(reason, *killers)
+        if reason == KillReason.Vote:
+            self.game.killed_players.append(self)
+            raise GameFinished(GameStatus.Joker)
+        return True

nonebot_plugin_werewolf/players/player.py

@@ -0,0 +1,233 @@
+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 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 ..game import Game
+    from ..player_set import PlayerSet
+
+
+_P = TypeVar("_P", bound=type["Player"])
+
+
+@dataclass
+class KillInfo:
+    reason: KillReason
+    killers: "PlayerSet"
+
+
+class Player:
+    __player_class: ClassVar[dict[Role, type["Player"]]] = {}
+    role: ClassVar[Role]
+    role_group: ClassVar[RoleGroup]
+
+    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_id: str) -> None:
+        self.__user = Target(
+            user_id,
+            private=True,
+            self_id=bot.self_id,
+            adapter=bot.adapter.get_name(),
+        )
+        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) -> "Player":
+        if role not in cls.__player_class:
+            raise ValueError(f"Unexpected role: {role!r}")
+
+        return cls.__player_class[role](bot, game, user_id)
+
+    def __repr__(self) -> str:
+        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():
+            return game
+        raise ValueError("Game not exist")
+
+    @functools.cached_property
+    def user_id(self) -> str:
+        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
+    @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"{self.game.colored_name} | "
+            f"[<b><m>{self.role_name}</m></b>] "
+            f"{self.colored_name} | {text}",
+        )
+
+    @final
+    async def send(self, message: str | UniMessage) -> Receipt:
+        if isinstance(message, str):
+            message = UniMessage.text(message)
+
+        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)
+        await 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()
+
+    async def interact(self) -> None:
+        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:
+        self.alive = False
+        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") -> "Player | None":
+        await self.send(
+            f"💫请选择需要投票的玩家:\n{players.show()}"
+            f"\n\n🗳️发送编号选择玩家\n❌发送 “{STOP_COMMAND_PROMPT}” 弃票"
+            f"\n\n限时1分钟，超时将视为弃票"
+        )
+
+        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_COMMAND:
+                if on_stop is not None:
+                    await self.send(on_stop)
+                return None
+            index = check_index(text, len(players))
+            if index is None:
+                await self.send(on_index_error)
+                continue
+            selected = await self._check_selected(players[index - 1])
+
+        return selected

nonebot_plugin_werewolf/players/prophet.py

@@ -0,0 +1,22 @@
+from nonebot_plugin_alconna.uniseg import UniMessage
+from typing_extensions import override
+
+from ..constant import STOP_COMMAND_PROMPT, Role, RoleGroup
+from .player import Player
+
+
+@Player.register_role(Role.Prophet, RoleGroup.GoodGuy)
+class Prophet(Player):
+    @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}” 结束回合(不查验身份)")
+        )
+
+        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

@@ -0,0 +1,89 @@
+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 STOP_COMMAND, STOP_COMMAND_PROMPT, Role, RoleGroup
+from ..utils import check_index
+from .player import Player
+
+if TYPE_CHECKING:
+    from ..player_set import PlayerSet
+
+
+@Player.register_role(Role.Werewolf, RoleGroup.Werewolf)
+class Werewolf(Player):
+    @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 _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)
+
+        msg = UniMessage()
+        if partners:
+            msg = (
+                msg.text("🐺你的队友:\n")
+                .text("\n".join(f"  {p.role_name}: {p.name}" for p in partners))
+                .text("\n所有私聊消息将被转发至队友\n\n")
+            )
+        await self.send(
+            msg.text("💫请选择今晚的目标:\n")
+            .text(players.show())
+            .text("\n\n🔪发送编号选择玩家")
+            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
+            .text("\n\n⚠️意见未统一将空刀")
+        )
+
+        send, recv = anyio.create_memory_object_stream[str | UniMessage]()
+        finished = anyio.Event()
+
+        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

@@ -0,0 +1,66 @@
+from nonebot_plugin_alconna.uniseg import UniMessage
+from typing_extensions import override
+
+from ..constant import STOP_COMMAND_PROMPT, Role, RoleGroup
+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
+
+    async def handle_killed(self) -> bool:
+        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
+
+        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
+
+        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:
+        if await self.handle_killed():
+            return
+
+        if not self.poison:
+            await self.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}” 结束回合(不使用药水)")
+        )
+
+        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

@@ -0,0 +1,14 @@
+from typing_extensions import override
+
+from ..constant import Role, RoleGroup
+from .can_shoot import CanShoot
+from .player import Player
+from .werewolf import Werewolf
+
+
+@Player.register_role(Role.WolfKing, RoleGroup.Werewolf)
+class WolfKing(CanShoot, Werewolf):
+    @override
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send("⚙️作为狼王，你可以在死后射杀一名玩家")