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

nonebot_plugin_werewolf/matchers/start_game.py

@@ -1,25 +1,272 @@
-from nonebot import on_command
+import json
+import re
+
+import anyio
+import nonebot
+import nonebot_plugin_waiter as waiter
 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 nonebot.internal.matcher import current_bot
+from nonebot.permission import SUPERUSER
+from nonebot.rule import Rule, to_me
+from nonebot.typing import T_State
+from nonebot.utils import escape_tag
+from nonebot_plugin_alconna import (
+    Alconna,
+    Button,
+    FallbackStrategy,
+    MsgTarget,
+    Option,
+    Target,
+    UniMessage,
+    UniMsg,
+    on_alconna,
+)
+from nonebot_plugin_localstore import get_plugin_data_file
+from nonebot_plugin_uninfo import QryItrface, Uninfo
 
-from .._timeout import timeout
+from ..config import PresetData, config
+from ..constant import STOP_COMMAND_PROMPT
 from ..game import Game
-from ..utils import prepare_game, rule_not_in_game
-from .ob11_ext import ob11_ext_enabled
+from ..utils import ObjectStream, extract_session_member_nick
+from .depends import rule_not_in_game
+from .poke import poke_enabled
 
-start_game = on_command(
-    "werewolf",
+start_game = on_alconna(
+    Alconna(
+        "werewolf",
+        Option("restart|--restart|重开", dest="restart"),
+    ),
     rule=to_me() & rule_not_in_game,
     aliases={"狼人杀"},
+    use_cmd_start=True,
 )
+player_data_file = get_plugin_data_file("players.json")
+if not player_data_file.exists():
+    player_data_file.write_text("[]")
+
+
+def dump_players(target: Target, players: dict[str, str]) -> None:
+    data: list[dict] = json.loads(player_data_file.read_text(encoding="utf-8"))
+
+    for item in data:
+        if Target.load(item["target"]).verify(target):
+            item["players"] = players
+            break
+    else:
+        data.append({"target": target.dump(), "players": players})
+
+    player_data_file.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+
+
+def load_players(target: Target) -> dict[str, str] | None:
+    data: list[dict] = json.loads(player_data_file.read_text(encoding="utf-8"))
+
+    for item in data:
+        if Target.load(item["target"]).verify(target):
+            return item["players"]
+    return None
+
+
+def solve_button(msg: UniMessage) -> UniMessage:
+    if config.enable_button:
+        msg.keyboard(
+            *[
+                Button("input", i, text=i)
+                for i in ["加入游戏", "退出游戏", "当前玩家", "开始游戏", "结束游戏"]
+            ]
+        )
+    return msg
+
+
+async def _prepare_receive(
+    stream: ObjectStream[tuple[Event, str, str]],
+    event_type: str,
+    group: Target,
+) -> None:
+    @Rule
+    async def same_group(target: MsgTarget) -> bool:
+        return group.verify(target)
+
+    @waiter.waiter(
+        waits=[event_type],
+        keep_session=False,
+        rule=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, re.sub(r"[\u2066-\u2069]", "", name))
+
+    async for event, text, name in wait(default=(None, "", "")):
+        if event is None:
+            continue
+        await stream.send((event, text, name))
+
+
+async def _prepare_handle(
+    stream: ObjectStream[tuple[Event, str, str]],
+    players: dict[str, str],
+    admin_id: str,
+) -> None:
+    logger = nonebot.logger.opt(colors=True)
+
+    async def send(msg: str, /, *, button: bool = True) -> None:
+        message = UniMessage.text(msg)
+        if button:
+            message = solve_button(message)
+
+        await message.send(
+            target=event,
+            reply_to=True,
+            fallback=FallbackStrategy.ignore,
+        )
+
+    while not stream.closed:
+        event, text, name = await stream.recv()
+        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 = PresetData.load().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} 开始游戏")
+                    stream.close()
+                    players["#$start_game$#"] = user_id
+                    return
+
+            case ("开始游戏", False):
+                await send("⚠️只有游戏发起者可以开始游戏")
+
+            case ("结束游戏", True):
+                logger.info(f"游戏发起者 {colored} 结束游戏")
+                await send("ℹ️已结束当前游戏", button=False)
+                stream.close()
+                return
+
+            case ("结束游戏", False):
+                if await SUPERUSER(current_bot.get(), event):
+                    logger.info(f"超级用户 {colored} 结束游戏")
+                    await send("ℹ️已结束当前游戏", button=False)
+                    stream.close()
+                    return
+                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
+
+    stream = ObjectStream[tuple[Event, str, str]](16)
+
+    async def _handle_cancel() -> None:
+        await stream.wait_closed()
+        tg.cancel_scope.cancel()
+
+    try:
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(_handle_cancel)
+            tg.start_soon(_prepare_receive, stream, event.get_type(), group)
+            tg.start_soon(_prepare_handle, stream, players, admin_id)
+    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_warning(target: MsgTarget) -> None:
+async def handle_notice(target: MsgTarget, state: T_State) -> None:
     if target.private:
         await UniMessage("⚠️请在群组中创建新游戏").finish(reply_to=True)
+    if any(target.verify(g.group) for g in Game.running_games):
+        await (
+            UniMessage.text("⚠️当前群组内有正在进行的游戏\n")
+            .text("无法开始新游戏")
+            .finish(reply_to=True)
+        )
+
+    msg = (
+        UniMessage.text("🎉成功创建游戏\n\n")
+        .text("  玩家请发送 “加入游戏”、“退出游戏”\n")
+        .text("  玩家发送 “当前玩家” 可查看玩家列表\n")
+        .text("  游戏发起者发送 “结束游戏” 可结束当前游戏\n")
+        .text("  玩家均加入后，游戏发起者请发送 “开始游戏”\n")
+    )
+    if poke_enabled():
+        msg.text(f"\n💫可使用戳一戳代替游戏交互中的 “{STOP_COMMAND_PROMPT}” 命令\n")
+    msg.text("\nℹ️游戏准备阶段限时5分钟，超时将自动结束")
+    await solve_button(msg).send(reply_to=True, fallback=FallbackStrategy.ignore)
+
+    state["players"] = {}
+
+
+@start_game.assign("restart")
+async def handle_restart(target: MsgTarget, state: T_State) -> None:
+    players = load_players(target)
+    if players is None:
+        await UniMessage.text("ℹ️未找到历史游戏记录，将创建新游戏").send()
+        return
+
+    msg = UniMessage.text("🎉成功加载上次游戏:\n")
+    for user in players:
+        msg.text("\n- ").at(user)
+    await msg.send()
+
+    state["players"] = players
 
 
 @start_game.handle()
@@ -28,29 +275,20 @@ async def handle_start(
     event: Event,
     target: MsgTarget,
     session: Uninfo,
+    interface: QryItrface,
+    state: T_State,
 ) -> None:
+    players: dict[str, str] = state["players"]
     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}
+    admin_name = extract_session_member_nick(session) or admin_id
+    players[admin_id] = admin_name
 
     try:
-        async with timeout(5 * 60):
+        with anyio.fail_after(5 * 60):
             await prepare_game(event, players)
     except TimeoutError:
         await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
 
-    Game(bot, target, players).start()
+    dump_players(target, players)
+    game = Game(bot, target, set(players), interface)
+    await game.start()

nonebot_plugin_werewolf/matchers/superuser_ops.py

@@ -0,0 +1,24 @@
+from nonebot.permission import SUPERUSER
+from nonebot.rule import to_me
+from nonebot_plugin_alconna import Alconna, MsgTarget, UniMessage, on_alconna
+
+from ..game import Game
+
+
+def rule_game_running(target: MsgTarget) -> bool:
+    return any(target.verify(g.group) for g in Game.running_games)
+
+
+force_stop = on_alconna(
+    Alconna("中止游戏"),
+    rule=to_me() & rule_game_running,
+    permission=SUPERUSER,
+    use_cmd_start=True,
+)
+
+
+@force_stop.handle()
+async def _(target: MsgTarget) -> None:
+    game = next(g for g in Game.running_games if target.verify(g.group))
+    game.terminate()
+    await UniMessage.text("已中止当前群组的游戏进程").finish(reply_to=True)

nonebot_plugin_werewolf/models.py

@@ -0,0 +1,73 @@
+import dataclasses
+from enum import Enum, auto
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .players import Player
+
+
+class Role(int, Enum):
+    # 狼人
+    Werewolf = 1
+    WolfKing = 2
+
+    # 神职
+    Prophet = 11
+    Witch = 12
+    Hunter = 13
+    Guard = 14
+    Idiot = 15
+
+    # 其他
+    Joker = 51
+
+    # 平民
+    Civilian = 0
+
+
+class RoleGroup(Enum):
+    Werewolf = auto()
+    GoodGuy = auto()
+    Others = auto()
+
+
+class KillReason(Enum):
+    Werewolf = auto()
+    Poison = auto()
+    Shoot = auto()
+    Vote = auto()
+
+
+class GameStatus(Enum):
+    GoodGuy = auto()
+    Werewolf = auto()
+    Joker = auto()
+
+
+@dataclasses.dataclass
+class GameState:
+    day: int
+    """当前天数记录, 不会被 `reset()` 重置"""
+    killed: "Player | None" = None
+    """当晚狼人击杀目标, `None` 则为空刀"""
+    shoot: "Player | None" = None
+    """当前执行射杀操作的玩家"""
+    antidote: set["Player"] = dataclasses.field(default_factory=set)
+    """当晚女巫使用解药的目标"""
+    poison: set["Player"] = dataclasses.field(default_factory=set)
+    """当晚使用了毒药的女巫"""
+    protected: set["Player"] = dataclasses.field(default_factory=set)
+    """当晚守卫保护的目标"""
+
+    def reset(self) -> None:
+        self.killed = None
+        self.shoot = None
+        self.antidote = set()
+        self.poison = set()
+        self.protected = set()
+
+
+@dataclasses.dataclass
+class KillInfo:
+    reason: KillReason
+    killers: list[str]

nonebot_plugin_werewolf/player_set.py

@@ -1,16 +1,10 @@
-from __future__ import annotations
-
-import asyncio
 import functools
-from typing import TYPE_CHECKING
-
-from ._timeout import timeout
-from .players import Player
 
-if TYPE_CHECKING:
-    from nonebot_plugin_alconna.uniseg import UniMessage
+import anyio
+from nonebot_plugin_alconna.uniseg import UniMessage
 
-    from .constant import Role, RoleGroup
+from .models import Role, RoleGroup
+from .players import Player
 
 
 class PlayerSet(set[Player]):
@@ -18,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
@@ -48,35 +42,40 @@ 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))

nonebot_plugin_werewolf/players/can_shoot.py

@@ -1,8 +1,8 @@
 from nonebot_plugin_alconna.uniseg import UniMessage
 from typing_extensions import override
 
-from ..constant import KillReason
-from ..utils import check_index
+from ..constant import STOP_COMMAND_PROMPT
+from ..models import KillReason
 from .player import Player
 
 
@@ -14,16 +14,16 @@ class CanShoot(Player):
             return await super().post_kill()
 
         await self.game.send(
-            UniMessage.text(f"🕵️{self.role_name} ")
+            UniMessage.text("🕵️玩家 ")
             .at(self.user_id)
-            .text(f" 死了\n请{self.role_name}决定击杀目标...")
+            .text(" 死了\n请在私聊决定射杀目标...")
         )
 
-        self.game.state.shoot = (None, None)
+        self.game.state.shoot = None
         shoot = await self.shoot()
 
         if shoot is not None:
-            self.game.state.shoot = (self, shoot)
+            self.game.state.shoot = self
             await self.send(
                 UniMessage.text(f"🔫{self.role_name} ")
                 .at(self.user_id)
@@ -31,6 +31,7 @@ class CanShoot(Player):
                 .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()
@@ -41,19 +42,13 @@ class CanShoot(Player):
             "💫请选择需要射杀的玩家:\n"
             + players.show()
             + "\n\n🔫发送编号选择玩家"
-            + "\n❌发送 “/stop” 取消技能"
+            + f"\n❌发送 “{STOP_COMMAND_PROMPT}” 取消技能"
         )
 
-        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]
+        if selected := await self._select_player(
+            players,
+            on_stop="ℹ️已取消技能，回合结束",
+        ):
+            await self.send(f"🎯选择射杀的玩家: {selected.name}")
+
+        return selected

nonebot_plugin_werewolf/players/civilian.py

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

nonebot_plugin_werewolf/players/guard.py

@@ -1,13 +1,20 @@
 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
+from ..constant import STOP_COMMAND_PROMPT
+from ..models import Role, RoleGroup
+from .player import Player
 
 
-@register_role(Role.Guard, RoleGroup.GoodGuy)
+@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()
@@ -15,23 +22,10 @@ class Guard(Player):
             UniMessage.text("💫请选择需要保护的玩家:\n")
             .text(players.show())
             .text("\n\n🛡️发送编号选择玩家")
-            .text("\n❌发送 “/stop” 结束回合")
+            .text(f"\n❌发送 “{STOP_COMMAND_PROMPT}” 结束回合")
         )
 
-        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}")
+        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

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