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

nonebot_plugin_werewolf/matchers/start_game.py

@@ -1,12 +1,14 @@
 import json
 import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 import anyio
 import nonebot
 import nonebot_plugin_waiter as waiter
 from nonebot.adapters import Bot, Event
 from nonebot.internal.matcher import current_bot
-from nonebot.permission import SUPERUSER
+from nonebot.permission import SuperUser
 from nonebot.rule import Rule, to_me
 from nonebot.typing import T_State
 from nonebot.utils import escape_tag
@@ -24,17 +26,20 @@ from nonebot_plugin_alconna import (
 from nonebot_plugin_localstore import get_plugin_data_file
 from nonebot_plugin_uninfo import QryItrface, Uninfo
 
-from ..config import PresetData, config
-from ..constant import STOP_COMMAND_PROMPT
-from ..game import Game
-from ..utils import ObjectStream, extract_session_member_nick
+from ..config import GameBehavior, PresetData
+from ..constant import stop_command_prompt
+from ..game import Game, get_running_games, get_starting_games
+from ..utils import ObjectStream, SendHandler, extract_session_member_nick
 from .depends import rule_not_in_game
 from .poke import poke_enabled
 
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
 start_game = on_alconna(
     Alconna(
         "werewolf",
-        Option("restart|--restart|重开", dest="restart"),
+        Option("restart|-r|--restart|重开", dest="restart"),
     ),
     rule=to_me() & rule_not_in_game,
     aliases={"狼人杀"},
@@ -59,200 +64,234 @@ def dump_players(target: Target, players: dict[str, str]) -> None:
 
 
 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:
+    for item in json.loads(player_data_file.read_text(encoding="utf-8")):
         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
+    def btn(text: str) -> Button:
+        return Button("input", label=text, text=text)
 
-
-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,
+    return (
+        msg.keyboard(btn("当前玩家"))
+        .keyboard(btn("加入游戏"), btn("退出游戏"))
+        .keyboard(btn("开始游戏"), btn("结束游戏"))
     )
-    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,
+class PrepareGame:
+    @dataclass
+    class _Current:
+        id: str
+        name: str
+        colored: str
+        is_admin: bool
+        is_super_user: bool
+
+    class _SendHandler(SendHandler):
+        def __init__(self) -> None:
+            self.reply_to = True
+
+        def solve_msg(self, msg: UniMessage) -> UniMessage:
+            return solve_button(msg)
+
+        async def send_finished(self) -> None:
+            btn_start = Button("input", label="发起游戏", text="werewolf")
+            btn_restart = Button("input", label="重开上次游戏", text="werewolf restart")
+            msg = (
+                UniMessage.text("ℹ️已结束当前游戏")
+                .keyboard(btn_start)
+                .keyboard(btn_restart)
+            )
+            async with anyio.create_task_group() as tg:
+                tg.start_soon(self._edit)
+                tg.start_soon(self._send, msg)
+
+    def __init__(self, event: Event, players: dict[str, str]) -> None:
+        self.event = event
+        self.admin_id = event.get_user_id()
+        self.group = UniMessage.get_target(event)
+        self.stream = ObjectStream[tuple[Event, str, str]](16)
+        self.players = players
+        self.send_handler = self._SendHandler()
+        self.logger = nonebot.logger.opt(colors=True)
+        self.shoud_start_game = False
+        get_starting_games()[self.group] = self.players
+
+        self._handlers: dict[str, Callable[[], Awaitable[bool | None]]] = {
+            "开始游戏": self._handle_start,
+            "结束游戏": self._handle_end,
+            "加入游戏": self._handle_join,
+            "退出游戏": self._handle_quit,
+            "当前玩家": self._handle_list,
+        }
+
+    async def run(self) -> None:
+        try:
+            async with anyio.create_task_group() as tg:
+                self.task_group = tg
+                tg.start_soon(self._wait_cancel)
+                tg.start_soon(self._receive)
+                tg.start_soon(self._handle)
+        except Exception as err:
+            await UniMessage(f"狼人杀准备阶段出现未知错误: {err!r}").finish()
+
+        del get_starting_games()[self.group]
+        if not self.shoud_start_game:
+            await start_game.finish()
+
+    async def _wait_cancel(self) -> None:
+        await self.stream.wait_closed()
+        self.task_group.cancel_scope.cancel()
+
+    async def _receive(self) -> None:
+        async def same_group(target: MsgTarget) -> bool:
+            return self.group.verify(target)
+
+        @waiter.waiter(
+            waits=[self.event.get_type()],
+            keep_session=False,
+            rule=Rule(same_group) & rule_not_in_game,
         )
-
-    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()
+        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 not None:
+                await self.stream.send((event, text, name))
+
+    async def _handle(self) -> None:
+        bot = current_bot.get()
+        superuser = SuperUser()
+
+        while not self.stream.closed:
+            event, text, name = await self.stream.recv()
+            user_id = event.get_user_id()
+            colored = f"<y>{escape_tag(name)}</y>(<c>{escape_tag(user_id)}</c>)"
+            self.current = self._Current(
+                id=user_id,
+                name=name,
+                colored=colored,
+                is_admin=user_id == self.admin_id,
+                is_super_user=await superuser(bot, event),
+            )
+            self.send_handler.update(event)
+
+            # 更新用户名
+            # 当用户通过 chronoca:poke 加入游戏时, 插件无法获取用户名, 原字典值为用户ID
+            if user_id in self.players and self.players.get(user_id) != name:
+                self.logger.debug(f"更新玩家显示名称: {self.current.colored}")
+                self.players[user_id] = name
+
+            handler = self._handlers.get(text)
+            if handler is not None and await handler():
                 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()
+    async def _send(self, msg: str | UniMessage) -> None:
+        await self.send_handler.send(msg)
+
+    async def _send_finished(self) -> None:
+        await self.send_handler.send_finished()
+
+    async def _handle_start(self) -> bool:
+        if not self.current.is_admin:
+            await self._send("⚠️只有游戏发起者可以开始游戏")
+            return False
+
+        player_num = len(self.players)
+        role_preset = PresetData.get().role_preset
+        if player_num < min(role_preset):
+            await self._send(
+                f"⚠️游戏至少需要 {min(role_preset)} 人, 当前已有 {player_num} 人"
+            )
+        elif player_num > max(role_preset):
+            await self._send(
+                f"⚠️游戏最多需要 {max(role_preset)} 人, 当前已有 {player_num} 人"
+            )
+        elif player_num not in role_preset:
+            await self._send(
+                f"⚠️不存在总人数为 {player_num} 的预设, 无法开始游戏\n"
+                f"可用的预设总人数: {', '.join(map(str, role_preset))}"
+            )
+        else:
+            await self._send("✏️游戏即将开始...")
+            self.logger.info(f"游戏发起者 {self.current.colored} 开始游戏")
+            self.stream.close()
+            self.shoud_start_game = True
+            return True
+
+        return False
+
+    async def _handle_end(self) -> bool:
+        if self.current.is_admin or self.current.is_super_user:
+            prefix = "游戏发起者" if self.current.is_admin else "超级用户"
+            self.logger.info(f"{prefix} {self.current.colored} 结束游戏")
+            await self._send_finished()
+            self.stream.close()
+            return True
+
+        await self._send("⚠️只有游戏发起者或超级用户可以结束游戏")
+        return False
+
+    async def _handle_join(self) -> None:
+        if self.current.is_admin:
+            await self._send("⚠️只有游戏发起者可以开始游戏")
+            return
+
+        if self.current.id not in self.players:
+            self.players[self.current.id] = self.current.name
+            self.logger.info(f"玩家 {self.current.colored} 加入游戏")
+            await self._send("✅成功加入游戏")
+        else:
+            await self._send("ℹ️你已经加入游戏了")
+
+    async def _handle_quit(self) -> None:
+        if self.current.is_admin:
+            await self._send("ℹ️游戏发起者无法退出游戏")
+            return
+
+        if self.current.id in self.players:
+            del self.players[self.current.id]
+            self.logger.info(f"玩家 {self.current.colored} 退出游戏")
+            await self._send("✅成功退出游戏")
+        else:
+            await self._send("ℹ️你还没有加入游戏")
+
+    async def _handle_list(self) -> None:
+        lines = (
+            f"{idx}. {self.players[user_id]}"
+            for idx, user_id in enumerate(self.players, 1)
+        )
+        await self._send("✨当前玩家:\n" + "\n".join(lines))
 
 
 @start_game.handle()
-async def handle_notice(target: MsgTarget, state: T_State) -> None:
+async def handle_notice(target: MsgTarget) -> None:
     if target.private:
         await UniMessage("⚠️请在群组中创建新游戏").finish(reply_to=True)
-    if any(target.verify(g.group) for g in Game.running_games):
+    if any(target.verify(game.group) for game in get_running_games()):
         await (
             UniMessage.text("⚠️当前群组内有正在进行的游戏\n")
             .text("无法开始新游戏")
             .finish(reply_to=True)
         )
 
-    msg = (
-        UniMessage.text("🎉成功创建游戏\n\n")
-        .text("  玩家请发送 “加入游戏”、“退出游戏”\n")
-        .text("  玩家发送 “当前玩家” 可查看玩家列表\n")
-        .text("  游戏发起者发送 “结束游戏” 可结束当前游戏\n")
-        .text("  玩家均加入后，游戏发起者请发送 “开始游戏”\n")
+    msg = UniMessage.text(
+        "🎉成功创建游戏\n\n"
+        "  玩家请发送 “加入游戏”、“退出游戏”\n"
+        "  玩家发送 “当前玩家” 可查看玩家列表\n"
+        "  游戏发起者发送 “结束游戏” 可结束当前游戏\n"
+        "  玩家均加入后，游戏发起者请发送 “开始游戏”\n"
     )
     if poke_enabled():
-        msg.text(f"\n💫可使用戳一戳代替游戏交互中的 “{STOP_COMMAND_PROMPT}” 命令\n")
+        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:
@@ -278,17 +317,17 @@ async def handle_start(
     interface: QryItrface,
     state: T_State,
 ) -> None:
-    players: dict[str, str] = state["players"]
+    players: dict[str, str] = state.get("players", {})
     admin_id = event.get_user_id()
     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)
+        with anyio.fail_after(GameBehavior.get().timeout.prepare):
+            await PrepareGame(event, players).run()
     except TimeoutError:
         await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
 
     dump_players(target, players)
-    game = Game(bot, target, set(players), interface)
+    game = await Game.new(bot, target, set(players), interface)
     await game.start()

nonebot_plugin_werewolf/matchers/superuser_ops.py

@@ -2,11 +2,11 @@ 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
+from ..game import get_running_games
 
 
 def rule_game_running(target: MsgTarget) -> bool:
-    return any(target.verify(g.group) for g in Game.running_games)
+    return any(target.verify(g.group) for g in get_running_games())
 
 
 force_stop = on_alconna(
@@ -19,6 +19,6 @@ force_stop = on_alconna(
 
 @force_stop.handle()
 async def _(target: MsgTarget) -> None:
-    game = next(g for g in Game.running_games if target.verify(g.group))
+    game = next(g for g in get_running_games() if target.verify(g.group))
     game.terminate()
     await UniMessage.text("已中止当前群组的游戏进程").finish(reply_to=True)

nonebot_plugin_werewolf/models.py

@@ -2,55 +2,68 @@ import dataclasses
 from enum import Enum, auto
 from typing import TYPE_CHECKING
 
+import anyio
+
 if TYPE_CHECKING:
-    from .players import Player
+    from .player import Player
 
 
 class Role(int, Enum):
     # 狼人
-    Werewolf = 1
-    WolfKing = 2
+    WEREWOLF = 1
+    WOLFKING = 2
 
     # 神职
-    Prophet = 11
-    Witch = 12
-    Hunter = 13
-    Guard = 14
-    Idiot = 15
+    PROPHET = 11
+    WITCH = 12
+    HUNTER = 13
+    GUARD = 14
+    IDIOT = 15
 
     # 其他
-    Joker = 51
+    JESTER = 51
 
     # 平民
-    Civilian = 0
+    CIVILIAN = 0
 
 
 class RoleGroup(Enum):
-    Werewolf = auto()
-    GoodGuy = auto()
-    Others = auto()
+    WEREWOLF = auto()
+    GOODGUY = auto()
+    OTHERS = auto()
 
 
 class KillReason(Enum):
-    Werewolf = auto()
-    Poison = auto()
-    Shoot = auto()
-    Vote = auto()
+    WEREWOLF = auto()
+    POISON = auto()
+    SHOOT = auto()
+    VOTE = auto()
 
 
 class GameStatus(Enum):
-    GoodGuy = auto()
-    Werewolf = auto()
-    Joker = auto()
+    GOODGUY = auto()
+    WEREWOLF = auto()
+    JESTER = auto()
 
 
 @dataclasses.dataclass
 class GameState:
+    class State(Enum):
+        DAY = auto()
+        VOTE = auto()
+        NIGHT = auto()
+
     day: int
     """当前天数记录, 不会被 `reset()` 重置"""
+    state: State = State.NIGHT
+    """当前游戏状态, 不会被 `reset()` 重置"""
+    _werewolf_interact_count: int = 0
+    """内部属性, 记录当晚狼人交互状态"""
+    werewolf_finished: anyio.Event = dataclasses.field(default_factory=anyio.Event)
+    """狼人交互是否结束"""
     killed: "Player | None" = None
     """当晚狼人击杀目标, `None` 则为空刀"""
-    shoot: "Player | None" = None
+    shooter: "Player | None" = None
     """当前执行射杀操作的玩家"""
     antidote: set["Player"] = dataclasses.field(default_factory=set)
     """当晚女巫使用解药的目标"""
@@ -60,12 +73,23 @@ class GameState:
     """当晚守卫保护的目标"""
 
     def reset(self) -> None:
+        self.werewolf_finished = anyio.Event()
+        self._werewolf_interact_count = 0
         self.killed = None
-        self.shoot = None
+        self.shooter = None
         self.antidote = set()
         self.poison = set()
         self.protected = set()
 
+    def werewolf_start(self) -> None:
+        self._werewolf_interact_count += 1
+
+    def werewolf_end(self) -> bool:
+        self._werewolf_interact_count -= 1
+        if self._werewolf_interact_count == 0:
+            self.werewolf_finished.set()
+        return self.werewolf_finished.is_set()
+
 
 @dataclasses.dataclass
 class KillInfo: