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

nonebot_plugin_werewolf/matchers/__init__.py

@@ -1,2 +1,4 @@
+from . import edit_preset as edit_preset
 from . import message_in_game as message_in_game
 from . import start_game as start_game
+from . import superuser_ops as superuser_ops

nonebot_plugin_werewolf/matchers/depends.py

@@ -0,0 +1,50 @@
+import itertools
+
+from nonebot.adapters import Bot, Event
+from nonebot_plugin_alconna import MsgTarget, UniMessage
+
+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) -> bool:
+    if not Game.running_games:
+        return False
+
+    try:
+        target = UniMessage.get_target(event, bot)
+    except NotImplementedError:
+        return False
+
+    if target.private:
+        return user_in_game(bot.self_id, target.id, None)
+
+    try:
+        user_id = event.get_user_id()
+    except Exception:
+        return False
+
+    return user_in_game(bot.self_id, user_id, target.id)
+
+
+async def rule_not_in_game(bot: Bot, event: Event) -> bool:
+    return not await rule_in_game(bot, event)
+
+
+async def is_group(target: MsgTarget) -> bool:
+    return not target.private

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,10 +1,12 @@
 from nonebot import on_message
 from nonebot.adapters import Event
-from nonebot_plugin_alconna import MsgTarget, UniMsg
+from nonebot_plugin_alconna import Alconna, MsgTarget, UniMessage, UniMsg, on_alconna
 
-from ..utils import InputStore, rule_in_game
+from ..constant import STOP_COMMAND
+from ..utils import InputStore
+from .depends import rule_in_game
 
-message_in_game = on_message(rule=rule_in_game)
+message_in_game = on_message(rule=rule_in_game, priority=10)
 
 
 @message_in_game.handle()
@@ -13,3 +15,16 @@ async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
         InputStore.put(msg, target.id)
     else:
         InputStore.put(msg, event.get_user_id(), target.id)
+
+
+stopcmd = on_alconna(
+    Alconna("stop"),
+    rule=rule_in_game,
+    block=True,
+    use_cmd_start=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/{ob11_ext.py → poke/ob11_poke.py}

@@ -4,12 +4,14 @@ from nonebot import on_notice
 from nonebot.internal.matcher import current_bot
 from nonebot_plugin_alconna import MsgTarget, UniMessage
 
-from ..config import config
-from ..game import Game
-from ..utils import InputStore, user_in_game
+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_ext_enabled() -> bool:
+def ob11_poke_enabled() -> bool:
     return False
 
 
@@ -17,23 +19,21 @@ with contextlib.suppress(ImportError):
     from nonebot.adapters.onebot.v11 import Bot
     from nonebot.adapters.onebot.v11.event import PokeNotifyEvent
 
-    # 游戏内戳一戳等效 "/stop"
+    # 游戏内戳一戳等效 "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 (
-            config.enable_poke
-            and (event.target_id == event.self_id)
-            and user_in_game(bot.self_id, user_id, group_id)
+        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"),
+            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,
         )
@@ -60,18 +60,20 @@ with contextlib.suppress(ImportError):
         target: MsgTarget,
     ) -> None:
         user_id = event.get_user_id()
-        group_id = target.id
         players = next(p for g, p in Game.starting_games.items() if target.verify(g))
 
-        if user_id not in players:
-            res: dict[str, str] = await bot.get_group_member_info(
-                group_id=int(group_id),
-                user_id=int(user_id),
-            )
-            players[user_id] = res.get("card") or res.get("nickname") or user_id
-            await UniMessage.at(user_id).text("\n✅成功加入游戏").send(target, bot)
+        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_ext_enabled() -> bool:
+    def ob11_poke_enabled() -> bool:
         if not config.enable_poke:
             return False