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

nonebot_plugin_werewolf/matchers/start_game.py

@@ -0,0 +1,56 @@
+from nonebot import on_command
+from nonebot.adapters import Bot, Event
+from nonebot.rule import to_me
+from nonebot_plugin_alconna import MsgTarget, UniMessage
+from nonebot_plugin_uninfo import Uninfo
+
+from .._timeout import timeout
+from ..game import Game
+from ..utils import prepare_game, rule_not_in_game
+from .ob11_ext import ob11_ext_enabled
+
+start_game = on_command(
+    "werewolf",
+    rule=to_me() & rule_not_in_game,
+    aliases={"狼人杀"},
+)
+
+
+@start_game.handle()
+async def handle_start_warning(target: MsgTarget) -> None:
+    if target.private:
+        await UniMessage("⚠️请在群组中创建新游戏").finish(reply_to=True)
+
+
+@start_game.handle()
+async def handle_start(
+    bot: Bot,
+    event: Event,
+    target: MsgTarget,
+    session: Uninfo,
+) -> None:
+    admin_id = event.get_user_id()
+    msg = (
+        UniMessage.at(admin_id)
+        .text("\n🎉成功创建游戏\n\n")
+        .text("  玩家请 @我 发送 “加入游戏”、“退出游戏”\n")
+        .text("  玩家 @我 发送 “当前玩家” 可查看玩家列表\n")
+        .text("  游戏发起者 @我 发送 “结束游戏” 可结束当前游戏\n")
+        .text("  玩家均加入后，游戏发起者请 @我 发送 “开始游戏”\n")
+    )
+    if ob11_ext_enabled():
+        msg.text("\n可使用戳一戳代替游戏交互中的 “/stop” 命令\n")
+    await msg.text("\n游戏准备阶段限时5分钟，超时将自动结束").send()
+
+    admin_name = session.user.nick or session.user.name or admin_id
+    if session.member:
+        admin_name = session.member.nick or admin_name
+    players = {admin_id: admin_name}
+
+    try:
+        async with timeout(5 * 60):
+            await prepare_game(event, players)
+    except TimeoutError:
+        await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
+
+    Game(bot, target, players).start()

nonebot_plugin_werewolf/player_set.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import asyncio
+import functools
 from typing import TYPE_CHECKING
 
 from ._timeout import timeout
-from .player import Player
+from .players import Player
 
 if TYPE_CHECKING:
     from nonebot_plugin_alconna.uniseg import UniMessage
@@ -50,6 +51,7 @@ class PlayerSet(set[Player]):
     def player_selected(self) -> PlayerSet:
         return PlayerSet(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)
 
@@ -63,7 +65,7 @@ class PlayerSet(set[Player]):
                 async with timeout(timeout_secs):
                     return await player.vote(self)
             except TimeoutError:
-                await player.send("投票超时，将视为弃票")
+                await player.send("⚠️投票超时，将视为弃票")
                 return None
 
         result: dict[Player, list[Player]] = {}
@@ -77,7 +79,7 @@ class PlayerSet(set[Player]):
         await asyncio.gather(*[p.send(message) for p in self])
 
     def show(self) -> str:
-        return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted(), 1))
+        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]
+        return self.sorted[__index]

nonebot_plugin_werewolf/players/__init__.py

@@ -0,0 +1,10 @@
+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 .prophet import Prophet as Prophet
+from .werewolf import Werewolf as Werewolf
+from .witch import Witch as Witch
+from .wolfking import WolfKing as WolfKing

nonebot_plugin_werewolf/players/can_shoot.py

@@ -0,0 +1,59 @@
+from nonebot_plugin_alconna.uniseg import UniMessage
+from typing_extensions import override
+
+from ..constant import KillReason
+from ..utils import check_index
+from .player import Player
+
+
+class CanShoot(Player):
+    @override
+    async def post_kill(self) -> None:
+        if self.kill_info and self.kill_info.reason == KillReason.Poison:
+            await self.send("⚠️你昨晚被女巫毒杀，无法使用技能")
+            return await super().post_kill()
+
+        await self.game.send(
+            UniMessage.text(f"🕵️{self.role_name} ")
+            .at(self.user_id)
+            .text(f" 死了\n请{self.role_name}决定击杀目标...")
+        )
+
+        self.game.state.shoot = (None, None)
+        shoot = await self.shoot()
+
+        if shoot is not None:
+            self.game.state.shoot = (self, shoot)
+            await self.send(
+                UniMessage.text(f"🔫{self.role_name} ")
+                .at(self.user_id)
+                .text(" 射杀了玩家 ")
+                .at(shoot.user_id)
+            )
+            await shoot.kill(KillReason.Shoot, self)
+        else:
+            await self.send(f"ℹ️{self.role_name}选择了取消技能")
+        return await super().post_kill()
+
+    async def shoot(self) -> Player | None:
+        players = self.game.players.alive().exclude(self)
+        await self.send(
+            "💫请选择需要射杀的玩家:\n"
+            + players.show()
+            + "\n\n🔫发送编号选择玩家"
+            + "\n❌发送 “/stop” 取消技能"
+        )
+
+        while True:
+            text = await self.receive_text()
+            if text == "/stop":
+                await self.send("ℹ️已取消技能")
+                return None
+            index = check_index(text, len(players))
+            if index is not None:
+                selected = index - 1
+                break
+            await self.send("⚠️输入错误: 请发送编号选择玩家")
+
+        await self.send(f"🎯选择射杀的玩家: {players[selected].name}")
+        return players[selected]

nonebot_plugin_werewolf/players/civilian.py

@@ -0,0 +1,7 @@
+from ..constant import Role, RoleGroup
+from .player import Player, register_role
+
+
+@register_role(Role.Civilian, RoleGroup.GoodGuy)
+class Civilian(Player):
+    pass

nonebot_plugin_werewolf/players/guard.py

@@ -0,0 +1,37 @@
+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
+
+
+@register_role(Role.Guard, RoleGroup.GoodGuy)
+class Guard(Player):
+    @override
+    async def interact(self) -> None:
+        players = self.game.players.alive()
+        await self.send(
+            UniMessage.text("💫请选择需要保护的玩家:\n")
+            .text(players.show())
+            .text("\n\n🛡️发送编号选择玩家")
+            .text("\n❌发送 “/stop” 结束回合")
+        )
+
+        while True:
+            text = await self.receive_text()
+            if text == "/stop":
+                await self.send("ℹ️你选择了取消，回合结束")
+                return
+            index = check_index(text, len(players))
+            if index is not None:
+                selected = index - 1
+                if players[selected] is self.selected:
+                    await self.send("⚠️守卫不能连续两晚保护同一目标，请重新选择")
+                    continue
+                break
+            await self.send("⚠️输入错误: 请发送编号选择玩家")
+
+        self.selected = players[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, register_role
+
+
+@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, register_role
+
+if TYPE_CHECKING:
+    from ..player_set import PlayerSet
+
+
+@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) -> tuple[Player, 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, register_role
+
+
+@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,161 @@
+from __future__ import annotations
+
+import asyncio
+import functools
+import weakref
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar, Final, TypeVar, final
+
+from nonebot.log import logger
+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
+
+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]] = {}
+
+
+@dataclass
+class KillInfo:
+    reason: KillReason
+    killers: PlayerSet
+
+
+class 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]
+    kill_info: KillInfo | 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(
+            user_id,
+            private=True,
+            self_id=bot.self_id,
+            adapter=bot.adapter.get_name(),
+        )
+        self.name = name
+        self.killed = asyncio.Event()
+
+    @final
+    @classmethod
+    def new(cls, role: Role, bot: Bot, game: Game, user_id: str, name: str) -> Player:
+        if role not in PLAYER_CLASS:
+            raise ValueError(f"Unexpected role: {role!r}")
+
+        return PLAYER_CLASS[role](bot, game, user_id, name)
+
+    def __repr__(self) -> str:
+        return f"<Player {self.role_name}: user={self.name!r} 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]
+
+    @final
+    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"[<b><m>{self.role_name}</m></b>] "
+            f"<y>{self.name}</y>(<b><e>{self.user_id}</e></b>) | "
+            f"{text}",
+        )
+
+    @final
+    async def send(self, message: str | UniMessage) -> Receipt:
+        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)
+
+    @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}")
+        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.send(f"⚙️你的身份: {role_emoji[self.role]}{self.role_name}")
+
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
+        from ..player_set import PlayerSet
+
+        self.alive = False
+        self.kill_info = KillInfo(reason=reason, killers=PlayerSet(killers))
+        return True
+
+    async def post_kill(self) -> None:
+        self.killed.set()
+
+    async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
+        await self.send(
+            f"💫请选择需要投票的玩家:\n{players.show()}"
+            "\n\n🗳️发送编号选择玩家\n❌发送 “/stop” 弃票"
+        )
+
+        while True:
+            text = await self.receive_text()
+            if text == "/stop":
+                await self.send("⚠️你选择了弃票")
+                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
+
+    return decorator

nonebot_plugin_werewolf/players/prophet.py

@@ -0,0 +1,30 @@
+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
+
+
+@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🔮发送编号选择玩家")
+        )
+
+        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}』")

nonebot_plugin_werewolf/players/werewolf.py

@@ -0,0 +1,67 @@
+import asyncio
+
+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
+
+
+@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)
+            )
+
+    @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 = (
+                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("\n❌发送 “/stop” 结束回合")
+            .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)
+
+        self.selected = players[selected]

nonebot_plugin_werewolf/players/witch.py

@@ -0,0 +1,72 @@
+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
+
+
+@register_role(Role.Witch, RoleGroup.GoodGuy)
+class Witch(Player):
+    antidote: int = 1
+    poison: int = 1
+
+    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:
+            await self.send("ℹ️今晚没有人被刀")
+            return False
+
+        if not self.antidote:
+            await self.send(msg.text("⚙️你已经用过解药了"))
+            return False
+
+        await self.send(msg.text("✏️使用解药请发送 “1”\n❌不使用解药请发送 “/stop”"))
+
+        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”")
+
+    @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("\n❌发送 “/stop” 结束回合(不使用药水)")
+        )
+
+        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回合结束")

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 register_role
+from .werewolf import Werewolf
+
+
+@register_role(Role.WolfKing, RoleGroup.Werewolf)
+class WolfKing(CanShoot, Werewolf):
+    @override
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send("⚙️作为狼王，你可以在死后射杀一名玩家")