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

nonebot_plugin_werewolf/matchers/edit_preset.py

@@ -0,0 +1,263 @@
+from typing import Any, NoReturn
+
+import nonebot_plugin_waiter as waiter
+from arclet.alconna import AllParam
+from nonebot.permission import SUPERUSER
+from nonebot.typing import T_State
+from nonebot_plugin_alconna import (
+    Alconna,
+    Args,
+    CommandMeta,
+    Match,
+    Subcommand,
+    UniMessage,
+    on_alconna,
+)
+
+from ..config import PresetData
+from ..constant import role_name_conv
+from ..models import Role
+
+alc = Alconna(
+    "狼人杀预设",
+    Subcommand(
+        "role",
+        Args["total#总人数", int],
+        Args["werewolf#狼人数量", int],
+        Args["priesthood#神职数量", int],
+        Args["civilian#平民数量", int],
+        alias={"职业"},
+        help_text="设置总人数为 <total> 的职业分配预设",
+    ),
+    Subcommand(
+        "del",
+        Args["total#总人数", int],
+        alias={"删除"},
+        help_text="删除总人数为 <total> 的职业分配预设",
+    ),
+    Subcommand(
+        "werewolf",
+        Args["roles?#职业", AllParam],
+        alias={"狼人"},
+        help_text="设置狼人优先级",
+    ),
+    Subcommand(
+        "priesthood",
+        Args["roles?#职业", AllParam],
+        alias={"神职"},
+        help_text="设置神职优先级",
+    ),
+    Subcommand(
+        "joker",
+        Args["probability?#概率", float],
+        alias={"小丑"},
+        help_text="设置小丑概率",
+    ),
+    Subcommand("reset", alias={"重置"}, help_text="重置为默认预设"),
+    meta=CommandMeta(
+        description="编辑狼人杀游戏预设",
+        usage="狼人杀预设 --help",
+        example=(
+            "狼人杀预设\n"
+            "狼人杀预设 职业 6 1 2 3\n"
+            "狼人杀预设 删除 6\n"
+            "狼人杀预设 狼人 狼 狼 狼王 狼 狼\n"
+            "狼人杀预设 神职 巫 预 猎 守卫 白痴\n"
+            "狼人杀预设 小丑 15\n"
+            "狼人杀预设 重置"
+        ),
+        author="wyf7685",
+    ),
+)
+
+edit_preset = on_alconna(
+    alc,
+    permission=SUPERUSER,
+    use_cmd_start=True,
+)
+
+
+async def finish(text: str) -> NoReturn:
+    await UniMessage.text(text).finish(reply_to=True)
+
+
+def display_roles(roles: list[Role]) -> str:
+    role_name = role_name_conv.__getitem__
+    return ", ".join(map(role_name, roles))
+
+
+@edit_preset.assign("role")
+async def assign_role(
+    total: Match[int],
+    werewolf: Match[int],
+    priesthood: Match[int],
+    civilian: Match[int],
+) -> None:
+    preset = (
+        werewolf.result,
+        priesthood.result,
+        civilian.result,
+    )
+    if sum(preset) != total.result:
+        await finish("总人数与职业数量不匹配")
+
+    data = PresetData.load()
+    if werewolf.result > len(data.werewolf_priority):
+        await finish("狼人数量超出优先级列表长度，请先设置足够多的狼人预设")
+    if priesthood.result > len(data.priesthood_proirity):
+        await finish("神职数量超出优先级列表长度，请先设置足够多的神职预设")
+
+    data.role_preset[total.result] = preset
+    data.save()
+    await finish(
+        f"设置成功\n{total.result} 人: "
+        f"狼人x{werewolf.result}, 神职x{priesthood.result}, 平民x{civilian.result}"
+    )
+
+
+@edit_preset.assign("del")
+async def delete_role(total: Match[int]) -> None:
+    data = PresetData.load()
+    if total.result not in data.role_preset:
+        await finish("未找到对应预设")
+    del data.role_preset[total.result]
+    data.save()
+    await finish("删除成功")
+
+
+@edit_preset.assign("werewolf")
+async def handle_werewolf_input_roles(roles: Match[Any], state: T_State) -> None:
+    if roles.available:
+        state["roles"] = UniMessage(roles.result).extract_plain_text().split(" ")
+        return
+
+    result = await waiter.prompt(
+        "请发送狼人优先级列表，以空格隔开\n发送 “取消” 取消操作"
+    )
+    if result is None:
+        await finish("发送超时，已自动取消")
+
+    text = result.extract_plain_text()
+    if text == "取消":
+        await finish("已取消操作")
+
+    state["roles"] = text.split(" ")
+
+
+@edit_preset.assign("werewolf")
+async def assign_werewolf(state: T_State) -> None:
+    roles: list[str] = state["roles"]
+    result: list[Role] = []
+
+    for role in roles:
+        match role:
+            case "狼人" | "狼":
+                result.append(Role.Werewolf)
+            case "狼王":
+                result.append(Role.WolfKing)
+            case x:
+                await finish(f"未知职业: {x}")
+
+    data = PresetData.load()
+    min_length = max(w for w, _, _ in data.role_preset.values())
+    if len(result) < min_length:
+        await finish(f"狼人数量不足，至少需要 {min_length} 个狼人")
+
+    data.werewolf_priority = result
+    data.save()
+    await finish("设置成功: " + display_roles(result))
+
+
+@edit_preset.assign("priesthood")
+async def handle_priesthood_input_roles(roles: Match[Any], state: T_State) -> None:
+    if roles.available:
+        state["roles"] = UniMessage(roles.result).extract_plain_text().split(" ")
+        return
+
+    result = await waiter.prompt(
+        "请发送神职优先级列表，以空格隔开\n发送 “取消” 取消操作"
+    )
+    if result is None:
+        await finish("发送超时，已自动取消")
+
+    text = result.extract_plain_text()
+    if text == "取消":
+        await finish("已取消操作")
+
+    state["roles"] = text.split(" ")
+
+
+@edit_preset.assign("priesthood")
+async def assign_priesthood(state: T_State) -> None:
+    roles: list[str] = state["roles"]
+    result: list[Role] = []
+
+    for role in roles:
+        match role:
+            case "预言家" | "预言" | "预":
+                result.append(Role.Prophet)
+            case "女巫" | "巫":
+                result.append(Role.Witch)
+            case "猎人" | "猎":
+                result.append(Role.Hunter)
+            case "守卫":
+                result.append(Role.Guard)
+            case "白痴":
+                result.append(Role.Idiot)
+            case x:
+                await finish(f"未知职业: {x}")
+
+    data = PresetData.load()
+    min_length = max(p for _, p, _ in data.role_preset.values())
+    if len(result) < min_length:
+        await finish(f"神职数量不足，至少需要 {min_length} 个神职")
+
+    data.priesthood_proirity = result
+    data.save()
+    await finish("设置成功: " + display_roles(result))
+
+
+@edit_preset.assign("joker")
+async def assign_joker(probability: Match[float]) -> None:
+    if not probability.available:
+        result = await waiter.prompt_until(
+            message="请发送小丑概率，范围 0-100\n发送 “取消” 取消操作",
+            checker=lambda m: (s := m.extract_plain_text()).isdigit() or s == "取消",
+            retry_prompt="输入错误，请重新输入一个正确的数字。\n剩余次数：{count}",
+        )
+        if result is None:
+            await finish("发送超时，已自动取消")
+        text = result.extract_plain_text()
+        if text == "取消":
+            await finish("已取消操作")
+        probability.result = float(text)
+
+    if not 0 <= probability.result <= 100:
+        await finish("输入错误，概率应在 0 到 100 之间")
+
+    data = PresetData.load()
+    data.joker_probability = probability.result / 100
+    data.save()
+    await finish(f"设置成功: 小丑概率 {probability.result:.1f}%")
+
+
+@edit_preset.assign("reset")
+async def reset_preset() -> None:
+    PresetData().save()
+    await finish("已重置为默认预设")
+
+
+@edit_preset.handle()
+async def handle_default() -> None:
+    lines = ["当前游戏预设:", ""]
+    data = PresetData.load()
+
+    for total, (w, p, c) in data.role_preset.items():
+        lines.append(f"{total} 人: 狼人x{w}, 神职x{p}, 平民x{c}")
+    lines.append("")
+
+    lines.append("狼人优先级: " + display_roles(data.werewolf_priority))
+    lines.append("神职优先级: " + display_roles(data.priesthood_proirity))
+    lines.append(f"小丑概率: {data.joker_probability:.0%}")
+
+    await finish("\n".join(lines))

nonebot_plugin_werewolf/matchers/message_in_game.py

@@ -1,6 +1,6 @@
-from nonebot import on_command, on_message
+from nonebot import on_message
 from nonebot.adapters import Event
-from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
+from nonebot_plugin_alconna import Alconna, MsgTarget, UniMessage, UniMsg, on_alconna
 
 from ..constant import STOP_COMMAND
 from ..utils import InputStore
@@ -17,7 +17,12 @@ async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
         InputStore.put(msg, event.get_user_id(), target.id)
 
 
-stopcmd = on_command("stop", rule=rule_in_game, block=True)
+stopcmd = on_alconna(
+    Alconna("stop"),
+    rule=rule_in_game,
+    block=True,
+    use_cmd_start=True,
+)
 
 
 @stopcmd.handle()

nonebot_plugin_werewolf/matchers/start_game.py

@@ -1,73 +1,128 @@
+import json
 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.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 MsgTarget, Target, UniMessage, UniMsg
+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 ..config import config
+from ..config import PresetData, config
 from ..constant import STOP_COMMAND_PROMPT
 from ..game import Game
-from ..utils import extract_session_member_nick
+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("[]")
 
 
-@start_game.handle()
-async def handle_start_warning(target: MsgTarget) -> None:
-    if target.private:
-        await UniMessage("⚠️请在群组中创建新游戏").finish(reply_to=True)
+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: MemoryObjectSendStream[tuple[Event, str, str]],
-    event: Event,
+    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.get_type()],
+        waits=[event_type],
         keep_session=False,
-        rule=to_me() & same_group & rule_not_in_game,
+        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, name)
+        return (event, text, re.sub(r"[\u2066-\u2069]", "", name))
 
-    async for evt, text, name in wait(default=(None, "", "")):
-        if evt is None:
+    async for event, text, name in wait(default=(None, "", "")):
+        if event is None:
             continue
-        await stream.send((evt, text, re.sub(r"[\u2066-\u2069]", "", name)))
+        await stream.send((event, text, name))
 
 
 async def _prepare_handle(
-    stream: MemoryObjectReceiveStream[tuple[Event, str, str]],
+    stream: ObjectStream[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)
+    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 True:
-        event, text, name = await stream.receive()
+    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>)"
 
@@ -80,7 +135,7 @@ async def _prepare_handle(
         match (text, user_id == admin_id):
             case ("开始游戏", True):
                 player_num = len(players)
-                role_preset = config.get_role_preset()
+                role_preset = PresetData.load().role_preset
                 if player_num < min(role_preset):
                     await send(
                         f"⚠️游戏至少需要 {min(role_preset)} 人, "
@@ -96,7 +151,7 @@ async def _prepare_handle(
                 else:
                     await send("✏️游戏即将开始...")
                     logger.info(f"游戏发起者 {colored} 开始游戏")
-                    finished.set()
+                    stream.close()
                     players["#$start_game$#"] = user_id
                     return
 
@@ -105,12 +160,17 @@ async def _prepare_handle(
 
             case ("结束游戏", True):
                 logger.info(f"游戏发起者 {colored} 结束游戏")
-                await send("ℹ️已结束当前游戏")
-                finished.set()
+                await send("ℹ️已结束当前游戏", button=False)
+                stream.close()
                 return
 
             case ("结束游戏", False):
-                await send("⚠️只有游戏发起者可以结束游戏")
+                if await SUPERUSER(current_bot.get(), event):
+                    logger.info(f"超级用户 {colored} 结束游戏")
+                    await send("ℹ️已结束当前游戏", button=False)
+                    stream.close()
+                    return
+                await send("⚠️只有游戏发起者或超级用户可以结束游戏")
 
             case ("加入游戏", True):
                 await send("ℹ️游戏发起者已经加入游戏了")
@@ -149,18 +209,17 @@ async def prepare_game(event: Event, players: dict[str, str]) -> None:
     group = UniMessage.get_target(event)
     Game.starting_games[group] = players
 
-    finished = anyio.Event()
-    send, recv = anyio.create_memory_object_stream[tuple[Event, str, str]]()
+    stream = ObjectStream[tuple[Event, str, str]](16)
 
     async def _handle_cancel() -> None:
-        await finished.wait()
+        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, send, event, group)
-            tg.start_soon(_prepare_handle, recv, players, admin_id, finished)
+            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()
 
@@ -169,6 +228,47 @@ async def prepare_game(event: Event, players: dict[str, str]) -> None:
         await start_game.finish()
 
 
+@start_game.handle()
+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()
 async def handle_start(
     bot: Bot,
@@ -176,21 +276,12 @@ async def handle_start(
     target: MsgTarget,
     session: Uninfo,
     interface: QryItrface,
+    state: T_State,
 ) -> None:
+    players: dict[str, str] = state["players"]
     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}
+    players[admin_id] = admin_name
 
     try:
         with anyio.fail_after(5 * 60):
@@ -198,5 +289,6 @@ async def handle_start(
     except TimeoutError:
         await UniMessage.text("⚠️游戏准备超时，已自动结束").finish()
 
+    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

@@ -3,7 +3,7 @@ import functools
 import anyio
 from nonebot_plugin_alconna.uniseg import UniMessage
 
-from .constant import Role, RoleGroup
+from .models import Role, RoleGroup
 from .players import Player