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

nonebot_plugin_werewolf/matchers/depends.py

@@ -0,0 +1,38 @@
+import itertools
+
+from nonebot.adapters import Bot, Event
+from nonebot_plugin_alconna import MsgTarget
+
+from ..game import Game
+
+
+def user_in_game(self_id: str, user_id: str, group_id: str | None) -> bool:
+    if group_id is None:
+        return any(
+            self_id == p.bot.self_id and user_id == p.user_id
+            for p in itertools.chain(*[g.players for g in Game.running_games])
+        )
+
+    def check(game: Game) -> bool:
+        return self_id == game.group.self_id and group_id == game.group.id
+
+    if game := next(filter(check, Game.running_games), None):
+        return any(user_id == player.user_id for player in game.players)
+
+    return False
+
+
+async def rule_in_game(bot: Bot, event: Event, target: MsgTarget) -> bool:
+    if not Game.running_games:
+        return False
+    if target.private:
+        return user_in_game(bot.self_id, target.id, None)
+    return user_in_game(bot.self_id, event.get_user_id(), target.id)
+
+
+async def rule_not_in_game(bot: Bot, event: Event, target: MsgTarget) -> bool:
+    return not await rule_in_game(bot, event, target)
+
+
+async def is_group(target: MsgTarget) -> bool:
+    return not target.private

nonebot_plugin_werewolf/matchers/message_in_game.py

@@ -0,0 +1,25 @@
+from nonebot import on_command, on_message
+from nonebot.adapters import Event
+from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
+
+from ..constant import STOP_COMMAND
+from ..utils import InputStore
+from .depends import rule_in_game
+
+message_in_game = on_message(rule=rule_in_game, priority=10)
+
+
+@message_in_game.handle()
+async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
+    if target.private:
+        InputStore.put(msg, target.id)
+    else:
+        InputStore.put(msg, event.get_user_id(), target.id)
+
+
+stopcmd = on_command("stop", rule=rule_in_game, block=True)
+
+
+@stopcmd.handle()
+async def handle_stopcmd(event: Event, target: MsgTarget) -> None:
+    await handle_input(event=event, target=target, msg=UniMessage.text(STOP_COMMAND))

nonebot_plugin_werewolf/matchers/poke/__init__.py

@@ -0,0 +1,8 @@
+from .chronocat_poke import chronocat_poke_enabled
+from .ob11_poke import ob11_poke_enabled
+
+checks = [chronocat_poke_enabled, ob11_poke_enabled]
+
+
+def poke_enabled() -> bool:
+    return any(check() for check in checks)

nonebot_plugin_werewolf/matchers/poke/chronocat_poke.py

@@ -0,0 +1,117 @@
+import contextlib
+
+from nonebot import on_message
+from nonebot.internal.matcher import current_event
+from nonebot_plugin_alconna import MsgTarget, UniMessage
+
+from ...config import config
+from ...constant import STOP_COMMAND
+from ...game import Game
+from ...utils import InputStore
+from ..depends import user_in_game
+
+
+def chronocat_poke_enabled() -> bool:
+    return False
+
+
+with contextlib.suppress(ImportError):
+    from nonebot.adapters.satori import Bot
+    from nonebot.adapters.satori.event import (
+        MessageCreatedEvent,
+        PublicMessageCreatedEvent,
+    )
+
+    def extract_poke_tome(event: MessageCreatedEvent) -> str | None:
+        if event.login and event.login.platform and event.login.platform != "chronocat":
+            return None
+
+        poke = event.get_message().include("chronocat:poke")
+        if not poke:
+            return None
+
+        gen = (
+            seg.data["operatorId"]
+            for seg in poke
+            if seg.data["userId"] == event.self_id
+        )
+        return next(gen, None)
+
+    def extract_user_group(event: MessageCreatedEvent) -> tuple[str, str | None]:
+        user_id = event.get_user_id()
+        group_id = None
+        if isinstance(event, PublicMessageCreatedEvent):
+            group_id = (event.guild and event.guild.id) or event.channel.id
+        return user_id, group_id
+
+    # 游戏内戳一戳等效 "stop" 命令
+    async def _rule_poke_stop(bot: Bot, event: MessageCreatedEvent) -> bool:
+        if not config.enable_poke:
+            return False
+        return extract_poke_tome(event) is not None and (
+            user_in_game(bot.self_id, *extract_user_group(event))
+        )
+
+    @on_message(rule=_rule_poke_stop).handle()
+    async def handle_poke_stop(event: MessageCreatedEvent) -> None:
+        InputStore.put(
+            UniMessage.text(STOP_COMMAND),
+            extract_poke_tome(event) or event.get_user_id(),
+            extract_user_group(event)[1],
+        )
+
+    # 准备阶段戳一戳等效加入游戏
+    async def _rule_poke_join(
+        bot: Bot,
+        event: PublicMessageCreatedEvent,
+        target: MsgTarget,
+    ) -> bool:
+        if not config.enable_poke:
+            return False
+
+        return (
+            (user_id := extract_poke_tome(event)) is not None
+            and not user_in_game(
+                self_id=bot.self_id,
+                user_id=user_id,
+                group_id=(event.guild and event.guild.id) or event.channel.id,
+            )
+            and any(target.verify(group) for group in Game.starting_games)
+        )
+
+    @on_message(rule=_rule_poke_join).handle()
+    async def handle_poke_join(
+        bot: Bot,
+        event: PublicMessageCreatedEvent,
+        target: MsgTarget,
+    ) -> None:
+        user_id = extract_poke_tome(event) or event.get_user_id()
+        players = next(p for g, p in Game.starting_games.items() if target.verify(g))
+
+        if user_id not in players:
+            # XXX:
+            #   截止 chronocat v0.2.19
+            #   通过 guild.member.get / user.get 获取的用户信息均不包含用户名
+            #   跳过用户名获取, 使用用户 ID 代替
+            #
+            # member = await bot.guild_member_get(
+            #     guild_id=(event.guild and event.guild.id) or event.channel.id,
+            #     user_id=user_id,
+            # )
+            # name = member.nick or (
+            #     member.user and (member.user.nick or member.user.name)
+            # )
+            # if name is None:
+            #     user = await bot.user_get(user_id=user_id)
+            #     name = user.nick or user.name
+            # players[user_id] = name or user_id
+
+            players[user_id] = user_id
+            await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
+
+    def chronocat_poke_enabled() -> bool:
+        if not config.enable_poke:
+            return False
+
+        event = current_event.get()
+        return isinstance(event, MessageCreatedEvent) and event.platform == "chronocat"

nonebot_plugin_werewolf/matchers/poke/ob11_poke.py

@@ -0,0 +1,80 @@
+import contextlib
+
+from nonebot import on_notice
+from nonebot.internal.matcher import current_bot
+from nonebot_plugin_alconna import MsgTarget, UniMessage
+
+from ...config import config
+from ...constant import STOP_COMMAND
+from ...game import Game
+from ...utils import InputStore
+from ..depends import user_in_game
+
+
+def ob11_poke_enabled() -> bool:
+    return False
+
+
+with contextlib.suppress(ImportError):
+    from nonebot.adapters.onebot.v11 import Bot
+    from nonebot.adapters.onebot.v11.event import PokeNotifyEvent
+
+    # 游戏内戳一戳等效 "stop" 命令
+    async def _rule_poke_stop(bot: Bot, event: PokeNotifyEvent) -> bool:
+        if not config.enable_poke:
+            return False
+
+        user_id = str(event.user_id)
+        group_id = str(event.group_id) if event.group_id is not None else None
+        return (event.target_id == event.self_id) and user_in_game(
+            bot.self_id, user_id, group_id
+        )
+
+    @on_notice(rule=_rule_poke_stop).handle()
+    async def handle_poke_stop(event: PokeNotifyEvent) -> None:
+        InputStore.put(
+            msg=UniMessage.text(STOP_COMMAND),
+            user_id=str(event.user_id),
+            group_id=str(event.group_id) if event.group_id is not None else None,
+        )
+
+    # 准备阶段戳一戳等效加入游戏
+    async def _rule_poke_join(
+        bot: Bot, event: PokeNotifyEvent, target: MsgTarget
+    ) -> bool:
+        if not config.enable_poke or event.group_id is None:
+            return False
+
+        user_id = str(event.user_id)
+        group_id = str(event.group_id)
+        return (
+            (event.target_id == event.self_id)
+            and not user_in_game(bot.self_id, user_id, group_id)
+            and any(target.verify(group) for group in Game.starting_games)
+        )
+
+    @on_notice(rule=_rule_poke_join).handle()
+    async def handle_poke_join(
+        bot: Bot,
+        event: PokeNotifyEvent,
+        target: MsgTarget,
+    ) -> None:
+        user_id = event.get_user_id()
+        players = next(p for g, p in Game.starting_games.items() if target.verify(g))
+
+        if event.group_id is None or user_id in players:
+            return
+
+        member_info = await bot.get_group_member_info(
+            group_id=event.group_id,
+            user_id=event.user_id,
+            no_cache=True,
+        )
+        players[user_id] = member_info["card"] or member_info["nickname"] or user_id
+        await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
+
+    def ob11_poke_enabled() -> bool:
+        if not config.enable_poke:
+            return False
+
+        return isinstance(current_bot.get(), Bot)

nonebot_plugin_werewolf/matchers/start_game.py

@@ -0,0 +1,202 @@
+import re
+
+import anyio
+import nonebot
+import nonebot_plugin_waiter as waiter
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from nonebot import on_command
+from nonebot.adapters import Bot, Event
+from nonebot.rule import to_me
+from nonebot.utils import escape_tag
+from nonebot_plugin_alconna import MsgTarget, Target, UniMessage, UniMsg
+from nonebot_plugin_uninfo import QryItrface, Uninfo
+
+from ..config import config
+from ..constant import STOP_COMMAND_PROMPT
+from ..game import Game
+from ..utils import extract_session_member_nick
+from .depends import rule_not_in_game
+from .poke import poke_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)
+
+
+async def _prepare_receive(
+    stream: MemoryObjectSendStream[tuple[Event, str, str]],
+    event: Event,
+    group: Target,
+) -> None:
+    async def same_group(target: MsgTarget) -> bool:
+        return group.verify(target)
+
+    @waiter.waiter(
+        waits=[event.get_type()],
+        keep_session=False,
+        rule=to_me() & same_group & rule_not_in_game,
+    )
+    def wait(event: Event, msg: UniMsg, session: Uninfo) -> tuple[Event, str, str]:
+        text = msg.extract_plain_text().strip()
+        name = extract_session_member_nick(session) or event.get_user_id()
+        return (event, text, name)
+
+    async for evt, text, name in wait(default=(None, "", "")):
+        if evt is None:
+            continue
+        await stream.send((evt, text, re.sub(r"[\u2066-\u2069]", "", name)))
+
+
+async def _prepare_handle(
+    stream: MemoryObjectReceiveStream[tuple[Event, str, str]],
+    players: dict[str, str],
+    admin_id: str,
+    finished: anyio.Event,
+) -> None:
+    logger = nonebot.logger.opt(colors=True)
+
+    async def send(msg: str, /) -> None:
+        await UniMessage.text(msg).send(target=event, reply_to=True)
+
+    while True:
+        event, text, name = await stream.receive()
+        user_id = event.get_user_id()
+        colored = f"<y>{escape_tag(name)}</y>(<c>{escape_tag(user_id)}</c>)"
+
+        # 更新用户名
+        # 当用户通过 chronoca:poke 加入游戏时, 插件无法获取用户名, 原字典值为用户ID
+        if user_id in players and players.get(user_id) != name:
+            logger.debug(f"更新玩家显示名称: {colored}")
+            players[user_id] = name
+
+        match (text, user_id == admin_id):
+            case ("开始游戏", True):
+                player_num = len(players)
+                role_preset = config.get_role_preset()
+                if player_num < min(role_preset):
+                    await send(
+                        f"⚠️游戏至少需要 {min(role_preset)} 人, "
+                        f"当前已有 {player_num} 人"
+                    )
+                elif player_num > max(role_preset):
+                    await send(
+                        f"⚠️游戏最多需要 {max(role_preset)} 人, "
+                        f"当前已有 {player_num} 人"
+                    )
+                elif player_num not in role_preset:
+                    await send(f"⚠️不存在总人数为 {player_num} 的预设, 无法开始游戏")
+                else:
+                    await send("✏️游戏即将开始...")
+                    logger.info(f"游戏发起者 {colored} 开始游戏")
+                    finished.set()
+                    players["#$start_game$#"] = user_id
+                    return
+
+            case ("开始游戏", False):
+                await send("⚠️只有游戏发起者可以开始游戏")
+
+            case ("结束游戏", True):
+                logger.info(f"游戏发起者 {colored} 结束游戏")
+                await send("ℹ️已结束当前游戏")
+                finished.set()
+                return
+
+            case ("结束游戏", False):
+                await send("⚠️只有游戏发起者可以结束游戏")
+
+            case ("加入游戏", True):
+                await send("ℹ️游戏发起者已经加入游戏了")
+
+            case ("加入游戏", False):
+                if user_id not in players:
+                    players[user_id] = name
+                    logger.info(f"玩家 {colored} 加入游戏")
+                    await send("✅成功加入游戏")
+                else:
+                    await send("ℹ️你已经加入游戏了")
+
+            case ("退出游戏", True):
+                await send("ℹ️游戏发起者无法退出游戏")
+
+            case ("退出游戏", False):
+                if user_id in players:
+                    del players[user_id]
+                    logger.info(f"玩家 {colored} 退出游戏")
+                    await send("✅成功退出游戏")
+                else:
+                    await send("ℹ️你还没有加入游戏")
+
+            case ("当前玩家", _):
+                await send(
+                    "✨当前玩家:\n"
+                    + "\n".join(
+                        f"{idx}. {players[user_id]}"
+                        for idx, user_id in enumerate(players, 1)
+                    )
+                )
+
+
+async def prepare_game(event: Event, players: dict[str, str]) -> None:
+    admin_id = event.get_user_id()
+    group = UniMessage.get_target(event)
+    Game.starting_games[group] = players
+
+    finished = anyio.Event()
+    send, recv = anyio.create_memory_object_stream[tuple[Event, str, str]]()
+
+    async def _handle_cancel() -> None:
+        await finished.wait()
+        tg.cancel_scope.cancel()
+
+    try:
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(_handle_cancel)
+            tg.start_soon(_prepare_receive, send, event, group)
+            tg.start_soon(_prepare_handle, recv, players, admin_id, finished)
+    except Exception as err:
+        await UniMessage(f"狼人杀准备阶段出现未知错误: {err!r}").send()
+
+    del Game.starting_games[group]
+    if players.pop("#$start_game$#", None) != admin_id:
+        await start_game.finish()
+
+
+@start_game.handle()
+async def handle_start(
+    bot: Bot,
+    event: Event,
+    target: MsgTarget,
+    session: Uninfo,
+    interface: QryItrface,
+) -> None:
+    admin_id = event.get_user_id()
+    msg = (
+        UniMessage.text("🎉成功创建游戏\n\n")
+        .text("  玩家请 @我 发送 “加入游戏”、“退出游戏”\n")
+        .text("  玩家 @我 发送 “当前玩家” 可查看玩家列表\n")
+        .text("  游戏发起者 @我 发送 “结束游戏” 可结束当前游戏\n")
+        .text("  玩家均加入后，游戏发起者请 @我 发送 “开始游戏”\n")
+    )
+    if poke_enabled():
+        msg.text(f"\n可使用戳一戳代替游戏交互中的 “{STOP_COMMAND_PROMPT}” 命令\n")
+    await msg.text("\n游戏准备阶段限时5分钟，超时将自动结束").send(reply_to=True)
+
+    admin_name = extract_session_member_nick(session) or admin_id
+    players = {admin_id: admin_name}
+
+    try:
+        with anyio.fail_after(5 * 60):
+            await prepare_game(event, players)
+    except TimeoutError:
+        await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
+
+    game = Game(bot, target, set(players), interface)
+    await game.start()

nonebot_plugin_werewolf/player_set.py

@@ -1,15 +1,10 @@
-from __future__ import annotations
+import functools
 
-import asyncio
-from typing import TYPE_CHECKING
+import anyio
+from nonebot_plugin_alconna.uniseg import UniMessage
 
-from ._timeout import timeout
-from .player import Player
-
-if TYPE_CHECKING:
-    from nonebot_plugin_alconna.uniseg import UniMessage
-
-    from .constant import Role, RoleGroup
+from .constant import Role, RoleGroup
+from .players import Player
 
 
 class PlayerSet(set[Player]):
@@ -17,26 +12,26 @@ class PlayerSet(set[Player]):
     def size(self) -> int:
         return len(self)
 
-    def alive(self) -> PlayerSet:
+    def alive(self) -> "PlayerSet":
         return PlayerSet(p for p in self if p.alive)
 
-    def dead(self) -> PlayerSet:
+    def dead(self) -> "PlayerSet":
         return PlayerSet(p for p in self if not p.alive)
 
-    def killed(self) -> PlayerSet:
+    def killed(self) -> "PlayerSet":
         return PlayerSet(p for p in self if p.killed.is_set())
 
-    def include(self, *types: Player | Role | RoleGroup) -> PlayerSet:
+    def include(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
         return PlayerSet(
             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) -> "PlayerSet":
         return self.include(*types)
 
-    def exclude(self, *types: Player | Role | RoleGroup) -> PlayerSet:
+    def exclude(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
         return PlayerSet(
             player
             for player in self
@@ -47,37 +42,43 @@ class PlayerSet(set[Player]):
             )
         )
 
-    def player_selected(self) -> PlayerSet:
+    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)
 
-    async def interact(self, timeout_secs: float = 60) -> None:
-        async with timeout(timeout_secs):
-            await asyncio.gather(*[p.interact() for p in self.alive()])
-
-    async def vote(self, timeout_secs: float = 60) -> dict[Player, list[Player]]:
-        async def vote(player: Player) -> tuple[Player, Player] | None:
-            try:
-                async with timeout(timeout_secs):
-                    return await player.vote(self)
-            except TimeoutError:
-                await player.send("投票超时，将视为弃票")
-                return None
+    async def interact(self) -> None:
+        async with anyio.create_task_group() as tg:
+            for p in self.alive():
+                tg.start_soon(p.interact)
 
+    async def vote(self) -> dict[Player, list[Player]]:
+        players = self.alive()
         result: dict[Player, list[Player]] = {}
-        for item in await asyncio.gather(*[vote(p) for p in self.alive()]):
-            if item is not None:
-                player, voted = item
-                result[voted] = [*result.get(voted, []), player]
+
+        async def _vote(player: Player) -> None:
+            vote = await player.vote(players)
+            if vote is not None:
+                result[vote] = [*result.get(vote, []), player]
+
+        async with anyio.create_task_group() as tg:
+            for p in players:
+                tg.start_soon(_vote, p)
+
         return result
 
     async def broadcast(self, message: str | UniMessage) -> None:
-        await asyncio.gather(*[p.send(message) for p in self])
+        if not self:
+            return
+
+        async with anyio.create_task_group() as tg:
+            for p in self:
+                tg.start_soon(p.send, message)
 
     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,53 @@
+from nonebot_plugin_alconna.uniseg import UniMessage
+from typing_extensions import override
+
+from ..constant import STOP_COMMAND_PROMPT, KillReason
+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
+        shoot = await self.shoot()
+
+        if shoot is not None:
+            self.game.state.shoot = self
+            await self.send(
+                UniMessage.text(f"🔫{self.role_name} ")
+                .at(self.user_id)
+                .text(" 射杀了玩家 ")
+                .at(shoot.user_id)
+            )
+            await shoot.kill(KillReason.Shoot, self)
+            self.selected = shoot
+        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🔫发送编号选择玩家"
+            + f"\n❌发送 “{STOP_COMMAND_PROMPT}” 取消技能"
+        )
+
+        if selected := await self._select_player(
+            players,
+            on_stop="ℹ️已取消技能，回合结束",
+        ):
+            await self.send(f"🎯选择射杀的玩家: {selected.name}")
+
+        return selected

nonebot_plugin_werewolf/players/civilian.py

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