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

nonebot_plugin_werewolf/utils.py

@@ -1,16 +1,16 @@
-import asyncio
-import re
+import functools
 from collections import defaultdict
-from typing import Annotated, Any, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 
-import nonebot_plugin_waiter as waiter
-from nonebot.adapters import Event
-from nonebot.log import logger
-from nonebot.rule import to_me
-from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
-from nonebot_plugin_userinfo import EventUserInfo, UserInfo
+import anyio
+from nonebot_plugin_alconna import UniMessage
+from nonebot_plugin_uninfo import Session
 
-from .config import config
+if TYPE_CHECKING:
+    from .player_set import PlayerSet
+    from .players import Player
+
+T = TypeVar("T")
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -21,181 +21,66 @@ def check_index(text: str, arrlen: int) -> int | None:
     return None
 
 
-class InputStore:
-    locks: ClassVar[dict[str, asyncio.Lock]] = defaultdict(asyncio.Lock)
-    futures: ClassVar[dict[str, asyncio.Future[UniMessage]]] = {}
+def link(text: str, url: str | None) -> str:
+    return text if url is None else f"\u001b]8;;{url}\u0007{text}\u001b]8;;\u0007"
 
-    @classmethod
-    async def fetch(cls, user_id: str, group_id: str | None = None) -> UniMessage[Any]:
-        key = f"{group_id}_{user_id}"
-        async with cls.locks[key]:
-            cls.futures[key] = asyncio.get_event_loop().create_future()
-            try:
-                return await cls.futures[key]
-            finally:
-                del cls.futures[key]
 
-    @classmethod
-    def put(cls, user_id: str, group_id: str | None, msg: UniMessage) -> None:
-        key = f"{group_id}_{user_id}"
-        if future := cls.futures.get(key):
-            future.set_result(msg)
+def extract_session_member_nick(session: Session) -> str | None:
+    return (
+        (session.member and session.member.nick)
+        or session.user.nick
+        or session.user.name
+    )
+
 
+class _InputTask:
+    _event: anyio.Event
+    _msg: UniMessage
 
-def user_in_game(user_id: str, group_id: str | None) -> bool:
-    from .game import running_games
+    def __init__(self) -> None:
+        self._event = anyio.Event()
 
-    if group_id is not None and group_id not in running_games:
-        return False
-    games = running_games.values() if group_id is None else [running_games[group_id]]
-    for game in games:
-        return any(user_id == player.user_id for player in game.players)
-    return False
+    def set(self, msg: UniMessage) -> None:
+        self._msg = msg
+        self._event.set()
 
+    async def wait(self) -> UniMessage:
+        await self._event.wait()
+        return self._msg
 
-async def rule_in_game(event: Event, target: MsgTarget) -> bool:
-    from .game import running_games
 
-    if not running_games:
-        return False
-    if target.private:
-        return user_in_game(target.id, None)
-    if target.id in running_games:
-        return user_in_game(event.get_user_id(), target.id)
-    return False
+class InputStore:
+    locks: ClassVar[dict[str, anyio.Lock]] = defaultdict(anyio.Lock)
+    tasks: ClassVar[dict[str, _InputTask]] = {}
+
+    @classmethod
+    async def fetch(cls, user_id: str, group_id: str | None = None) -> UniMessage[Any]:
+        key = f"{group_id}_{user_id}"
+        async with cls.locks[key]:
+            cls.tasks[key] = task = _InputTask()
+            return await task.wait()
 
+    @classmethod
+    def put(cls, msg: UniMessage, user_id: str, group_id: str | None = None) -> None:
+        key = f"{group_id}_{user_id}"
+        if task := cls.tasks.pop(key, None):
+            task.set(msg)
 
-async def rule_not_in_game(event: Event, target: MsgTarget) -> bool:
-    return not await rule_in_game(event, target)
+    @classmethod
+    def cleanup(cls, players: list[str], group_id: str) -> None:
+        for key in (f"{g}_{p}" for p in players for g in (group_id, None)):
+            if key in cls.locks:
+                del cls.locks[key]
+            if key in cls.tasks:
+                del cls.tasks[key]
 
 
-async def is_group(target: MsgTarget) -> bool:
-    return not target.private
+@functools.cache
+def cached_player_set() -> type["PlayerSet"]:
+    from .player_set import PlayerSet
 
+    return PlayerSet
 
-async def _prepare_game_receive(
-    queue: asyncio.Queue[tuple[str, str, str]],
-    event: Event,
-    group_id: str,
-) -> None:
-    async def rule(target_: MsgTarget) -> bool:
-        return not target_.private and target_.id == group_id
 
-    @waiter.waiter(
-        waits=[event.get_type()],
-        keep_session=False,
-        rule=to_me() & rule & rule_not_in_game,
-    )
-    def wait(
-        event: Event,
-        info: Annotated[UserInfo | None, EventUserInfo()],
-        msg: UniMsg,
-    ) -> tuple[str, str, str]:
-        return (
-            event.get_user_id(),
-            (
-                (info.user_displayname or info.user_name)
-                if info is not None
-                else event.get_user_id()
-            ),
-            msg.extract_plain_text().strip(),
-        )
-
-    async for user, name, text in wait(default=(None, "", "")):
-        if user is None:
-            continue
-        await queue.put((user, re.sub(r"[\u2066-\u2069]", "", name), text))
-
-
-async def _prepare_game_handle(
-    queue: asyncio.Queue[tuple[str, str, str]],
-    players: dict[str, str],
-    admin_id: str,
-) -> None:
-    log = logger.opt(colors=True)
-
-    while True:
-        user, name, text = await queue.get()
-        msg = UniMessage.at(user)
-        colored = f"<y>{name}</y>(<c>{user}</c>)"
-
-        match (text, user == admin_id):
-            case ("开始游戏", True):
-                player_num = len(players)
-                role_preset = config.get_role_preset()
-                if player_num < min(role_preset):
-                    await (
-                        msg.text(f"游戏至少需要 {min(role_preset)} 人, ")
-                        .text(f"当前已有 {player_num} 人")
-                        .send()
-                    )
-                elif player_num > max(role_preset):
-                    await (
-                        msg.text(f"游戏最多需要 {max(role_preset)} 人, ")
-                        .text(f"当前已有 {player_num} 人")
-                        .send()
-                    )
-                elif player_num not in role_preset:
-                    await (
-                        msg.text(f"不存在总人数为 {player_num} 的预设, ")
-                        .text("无法开始游戏")
-                        .send()
-                    )
-                else:
-                    await msg.text("游戏即将开始...").send()
-                    log.info(f"游戏发起者 {colored} 开始游戏")
-                    return
-
-            case ("开始游戏", False):
-                await msg.text("只有游戏发起者可以开始游戏").send()
-
-            case ("结束游戏", True):
-                log.info(f"游戏发起者 {colored} 结束游戏")
-                await msg.text("已结束当前游戏").finish()
-
-            case ("结束游戏", False):
-                await msg.text("只有游戏发起者可以结束游戏").send()
-
-            case ("加入游戏", True):
-                await msg.text("游戏发起者已经加入游戏了").send()
-
-            case ("加入游戏", False):
-                if user not in players:
-                    players[user] = name
-                    log.info(f"玩家 {colored} 加入游戏")
-                    await msg.text("成功加入游戏").send()
-                else:
-                    await msg.text("你已经加入游戏了").send()
-
-            case ("退出游戏", True):
-                await msg.text("游戏发起者无法退出游戏").send()
-
-            case ("退出游戏", False):
-                if user in players:
-                    del players[user]
-                    log.info(f"玩家 {colored} 退出游戏")
-                    await msg.text("成功退出游戏").send()
-                else:
-                    await msg.text("你还没有加入游戏").send()
-
-            case ("当前玩家", _):
-                msg.text("\n当前玩家:\n")
-                for idx, name in enumerate(players.values(), 1):
-                    msg.text(f"\n{idx}. {name}")
-                await msg.send()
-
-
-async def prepare_game(event: Event, players: dict[str, str]) -> None:
-    from .game import starting_games
-
-    group_id = UniMessage.get_target(event).id
-    starting_games[group_id] = players
-
-    queue: asyncio.Queue[tuple[str, str, str]] = asyncio.Queue()
-    task_receive = asyncio.create_task(_prepare_game_receive(queue, event, group_id))
-
-    try:
-        await _prepare_game_handle(queue, players, event.get_user_id())
-    finally:
-        task_receive.cancel()
-        del starting_games[group_id]
+def as_player_set(*player: "Player") -> "PlayerSet":
+    return cached_player_set()(player)

{nonebot_plugin_werewolf-1.1.2.dist-info → nonebot_plugin_werewolf-1.1.5.dist-info}/METADATA

@@ -1,16 +1,20 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-werewolf
-Version: 1.1.2
+Version: 1.1.5
 Summary: 适用于 Nonebot2 的狼人杀插件
 Author-email: wyf7685 <wyf7685@163.com>
 License: MIT
+Project-URL: homepage, https://github.com/wyf7685/nonebot-plugin-werewolf
+Project-URL: repository, https://github.com/wyf7685/nonebot-plugin-werewolf
+Project-URL: bug-tracker, https://github.com/wyf7685/nonebot-plugin-werewolf/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: nonebot2 >=2.3.3
 Requires-Dist: nonebot-plugin-alconna >=0.52.1
-Requires-Dist: nonebot-plugin-userinfo >=0.2.6
+Requires-Dist: nonebot-plugin-uninfo >=0.4.0
 Requires-Dist: nonebot-plugin-waiter >=0.7.1
+Requires-Dist: anyio >=4.6.0
 
 <div align="center">
   <a href="https://v2.nonebot.dev/store">
@@ -39,6 +43,7 @@ _✨ 简单的狼人杀插件 ✨_
 [![pyright](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pyright.yml/badge.svg?branch=master&event=push)](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pyright.yml)
 [![publish](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pypi-publish.yml/badge.svg)](https://github.com/wyf7685/nonebot-plugin-werewolf/actions/workflows/pypi-publish.yml)
 
+<!-- https://github.com/lgc2333/nonebot-registry-badge -->
 [![NoneBot Registry](https://img.shields.io/endpoint?url=https%3A%2F%2Fnbbdg.lgc2333.top%2Fplugin%2Fnonebot-plugin-werewolf)](https://registry.nonebot.dev/plugin/nonebot-plugin-werewolf:nonebot_plugin_werewolf)
 [![Supported Adapters](https://img.shields.io/endpoint?url=https%3A%2F%2Fnbbdg.lgc2333.top%2Fplugin-adapters%2Fnonebot-plugin-werewolf)](https://registry.nonebot.dev/plugin/nonebot-plugin-werewolf:nonebot_plugin_werewolf)
 
@@ -145,7 +150,7 @@ _✨ 简单的狼人杀插件 ✨_
 
 _其他交互参考游戏内提示_
 
-对于 `OneBot V11` 适配器, 启用配置项 `werewolf__enable_poke` 后, 可以使用戳一戳代替 _准备阶段_ 的 `加入游戏` 操作 和 游戏内的 `/stop` 命令
+对于 `OneBot V11` 适配器和 `Satori` 适配器的 `chronocat`, 启用配置项 `werewolf__enable_poke` 后, 可以使用戳一戳代替 _准备阶段_ 的 `加入游戏` 操作 和 游戏内的 `stop` 命令
 
 ### 游戏内容
 
@@ -233,6 +238,10 @@ werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
 
 </details>
 
+### 已知问题
+
+- 截止 chronocat v0.2.19, 调用 [`guild.member.get`](https://github.com/chrononeko/chronocat/blob/8558ad9ff4319395d86abbfda22136939bf66780/packages/engine-chronocat-api/src/api/guild/member/get.ts) / [`user.get`](https://github.com/chrononeko/chronocat/blob/8558ad9ff4319395d86abbfda22136939bf66780/packages/engine-chronocat-api/src/api/user/get.ts) 均无法获取用户名，这将导致在交互过程中的玩家名显示为用户ID
+
 ## 📝 更新日志
 
 <details>
@@ -240,6 +249,17 @@ werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
 
 <!-- CHANGELOG -->
 
+- 2024.10.23 v1.1.5
+
+  - 添加对 chronocat:poke 的支持
+  - 游戏内 stop 命令使用 COMMAND_START
+  - 使用 `anyio` 重写并发逻辑
+
+- 2024.10.06 v1.1.3
+
+  - 使用 `RF-Tar-Railt/nonebot-plugin-uninfo` 获取用户数据
+  - 优化交互文本
+
 - 2024.09.18 v1.1.2
 
   - 修改 Python 需求为 `>=3.10`
@@ -284,6 +304,6 @@ werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
 
 - [`nonebot/nonebot2`](https://github.com/nonebot/nonebot2): 跨平台 Python 异步机器人框架
 - [`nonebot/plugin-alconna`](https://github.com/nonebot/plugin-alconna): 跨平台的消息处理接口
-- [`noneplugin/nonebot-plugin-userinfo`](https://github.com/noneplugin/nonebot-plugin-userinfo): 用户信息获取
+- [`RF-Tar-Railt/nonebot-plugin-uninfo`](https://github.com/RF-Tar-Railt/nonebot-plugin-uninfo): 用户信息获取
 - [`RF-Tar-Railt/nonebot-plugin-waiter`](https://github.com/RF-Tar-Railt/nonebot-plugin-waiter): 灵活获取用户输入
 - `热心群友`: 协助测试插件

nonebot_plugin_werewolf-1.1.5.dist-info/RECORD

@@ -0,0 +1,31 @@
+nonebot_plugin_werewolf/__init__.py,sha256=v65nKZbsbmaJPR0o2ZrXuumUvCuEOvDVtVmw65CyVn8,894
+nonebot_plugin_werewolf/config.py,sha256=FKQDkb57ujcBYJZX-sLgxWmTVqSeR7T1ywphp7GOCcE,2803
+nonebot_plugin_werewolf/constant.py,sha256=d4Awy96YBe_AJoAZyd_6Wojo0qi2BTVM_LW-nDbsxQE,2902
+nonebot_plugin_werewolf/exception.py,sha256=YSwxeogIB0YJqH9MP1bgxojiu-I_xQE44XnSk5bC1AQ,400
+nonebot_plugin_werewolf/game.py,sha256=yUfJtLWH7--TRPnofAGfrUkUvd_3VW1J9j8zhTrN9hc,19106
+nonebot_plugin_werewolf/player_set.py,sha256=J5KFWSugpu1Zd_gToqa-Gweoikj8kppLpckVjl-4XH0,2540
+nonebot_plugin_werewolf/utils.py,sha256=6uFwgf4LAI1SZ_qH6I2ilHt2vbs6NfTj5YhMvC4GacE,2279
+nonebot_plugin_werewolf/matchers/__init__.py,sha256=_MwAZsXlpBLXyzHWqNLTQdMWw9z_O01L5Yo02dzGC9I,88
+nonebot_plugin_werewolf/matchers/depends.py,sha256=6JFLxQDgRjStbMkpoWe1tYZHs0wVfsyn4KikKNpgx0Q,1160
+nonebot_plugin_werewolf/matchers/message_in_game.py,sha256=YkphERN2efaB0VdU3oTCvvYptrqDaKFKUb9moUyqIpY,780
+nonebot_plugin_werewolf/matchers/start_game.py,sha256=ZNO2ypV8kMlImR0fZVhg0ZI8mrOsW3I-eioT6Lhf2Cw,7427
+nonebot_plugin_werewolf/matchers/poke/__init__.py,sha256=gYysvGjztN3iDQpX6v5nkPT195FXnk7fqP9kzByTES0,220
+nonebot_plugin_werewolf/matchers/poke/chronocat_poke.py,sha256=SrFN8dQELFVDR5US9sOcE2gaOnH7AFiRVVK2RNa-Y5o,4023
+nonebot_plugin_werewolf/matchers/poke/ob11_poke.py,sha256=LROxtbauw4xbB8UKglsx6b6hkKWs_17HmgK4NTXW1HY,2640
+nonebot_plugin_werewolf/players/__init__.py,sha256=djAI5XxR2I-XvnH-lVqX_YCHB_AiT-6jdmwFE1ffN_0,379
+nonebot_plugin_werewolf/players/can_shoot.py,sha256=e9QtRUNxNZ9n3MxX7o0bUmQLLPDazTOZky3F_2m6UhM,1813
+nonebot_plugin_werewolf/players/civilian.py,sha256=TbrIxjG4g74C9Cd_F3OskuM-ksKUkOLiE6OgPqmo0pA,157
+nonebot_plugin_werewolf/players/guard.py,sha256=T2L7f0Dcx6jjlOrGcHUQxy9RawszvP6AKaI8Lz9nItI,1112
+nonebot_plugin_werewolf/players/hunter.py,sha256=NaJNjngKCHC8RI1YsYI5XtVyFq9JP5U1ywOTbjjUHq4,195
+nonebot_plugin_werewolf/players/idiot.py,sha256=Tpjf7RPW1dJ3J4ajr5HWcIustHO-h6PNicum4SiofDE,1433
+nonebot_plugin_werewolf/players/joker.py,sha256=J_t-IPKjyHWq8azxFdN_cmJhbgoDcokiMLf-pMXQInE,691
+nonebot_plugin_werewolf/players/player.py,sha256=JUCev-3jnAqApNR-cFaHRHkQVIgBfn5HhHhLq8OGWgw,6954
+nonebot_plugin_werewolf/players/prophet.py,sha256=VQa4RJUbLpG9ntB055ORl09oEAmZ1uOUi4P4q_P_9TY,897
+nonebot_plugin_werewolf/players/werewolf.py,sha256=MZOsHWNnKvh_fxKMEIWqa_yJIYHVjA1fM5W3jkg_CtU,3433
+nonebot_plugin_werewolf/players/witch.py,sha256=XDCVSXhUA9afh0iCdxV8Shfc1YGDkXYhu1h0v1xpbmg,2340
+nonebot_plugin_werewolf/players/wolfking.py,sha256=oBC5JW0UULDkthurDBvHRNo3rqArm-zQ_1jSuyeHpQU,440
+nonebot_plugin_werewolf-1.1.5.dist-info/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
+nonebot_plugin_werewolf-1.1.5.dist-info/METADATA,sha256=j-vwRZiK1lobgZ10-X30Upf6Vuo1ZYMraWgQvStKjvI,11435
+nonebot_plugin_werewolf-1.1.5.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+nonebot_plugin_werewolf-1.1.5.dist-info/top_level.txt,sha256=wLTfg8sTKbH9lLT9LtU118C9cTspEBJareLsrYM52YA,24
+nonebot_plugin_werewolf-1.1.5.dist-info/RECORD,,

{nonebot_plugin_werewolf-1.1.2.dist-info → nonebot_plugin_werewolf-1.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nonebot_plugin_werewolf/_timeout.py

@@ -1,110 +0,0 @@
-import asyncio
-import enum
-import sys
-from types import TracebackType
-from typing import final
-
-if sys.version_info >= (3, 11):
-    from asyncio.timeouts import timeout as timeout
-
-else:
-    # ruff: noqa: S101
-
-    class _State(enum.Enum):
-        CREATED = "created"
-        ENTERED = "active"
-        EXPIRING = "expiring"
-        EXPIRED = "expired"
-        EXITED = "finished"
-
-    @final
-    class Timeout:
-        def __init__(self, when: float | None) -> None:
-            self._state = _State.CREATED
-            self._timeout_handler: asyncio.Handle | None = None
-            self._task: asyncio.Task | None = None
-            if when is not None:
-                when = asyncio.get_running_loop().time() + when
-            self._when = when
-
-        def when(self) -> float | None:
-            return self._when
-
-        def reschedule(self, when: float | None) -> None:
-            if self._state is not _State.ENTERED:
-                if self._state is _State.CREATED:
-                    raise RuntimeError("Timeout has not been entered")
-                raise RuntimeError(
-                    f"Cannot change state of {self._state.value} Timeout",
-                )
-
-            self._when = when
-
-            if self._timeout_handler is not None:
-                self._timeout_handler.cancel()
-
-            if when is None:
-                self._timeout_handler = None
-            else:
-                loop = asyncio.get_running_loop()
-                if when <= loop.time():
-                    self._timeout_handler = loop.call_soon(self._on_timeout)
-                else:
-                    self._timeout_handler = loop.call_at(when, self._on_timeout)
-
-        def expired(self) -> bool:
-            return self._state in (_State.EXPIRING, _State.EXPIRED)
-
-        def __repr__(self) -> str:
-            info = [""]
-            if self._state is _State.ENTERED:
-                when = round(self._when, 3) if self._when is not None else None
-                info.append(f"when={when}")
-            info_str = " ".join(info)
-            return f"<Timeout [{self._state.value}]{info_str}>"
-
-        async def __aenter__(self) -> "Timeout":
-            if self._state is not _State.CREATED:
-                raise RuntimeError("Timeout has already been entered")
-            task = asyncio.current_task()
-            if task is None:
-                raise RuntimeError("Timeout should be used inside a task")
-            self._state = _State.ENTERED
-            self._task = task
-            self.reschedule(self._when)
-            return self
-
-        async def __aexit__(
-            self,
-            exc_type: type[BaseException] | None,
-            exc_val: BaseException | None,
-            exc_tb: TracebackType | None,
-        ) -> bool | None:
-            assert self._state in (_State.ENTERED, _State.EXPIRING)
-
-            if self._timeout_handler is not None:
-                self._timeout_handler.cancel()
-                self._timeout_handler = None
-
-            if self._state is _State.EXPIRING:
-                self._state = _State.EXPIRED
-
-                if exc_type is asyncio.CancelledError:
-                    raise TimeoutError from exc_val
-            elif self._state is _State.ENTERED:
-                self._state = _State.EXITED
-
-            return None
-
-        def _on_timeout(self) -> None:
-            assert self._state is _State.ENTERED
-            assert self._task is not None
-            self._task.cancel()
-            self._state = _State.EXPIRING
-            self._timeout_handler = None
-
-    def timeout(delay: float | None) -> Timeout:
-        return Timeout(delay)
-
-
-__all__ = ["timeout"]

nonebot_plugin_werewolf/matchers.py

@@ -1,62 +0,0 @@
-from typing import Annotated
-
-from nonebot import on_command, on_message
-from nonebot.adapters import Bot, Event
-from nonebot.exception import FinishedException
-from nonebot.rule import to_me
-from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
-from nonebot_plugin_userinfo import EventUserInfo, UserInfo
-
-from ._timeout import timeout
-from .game import Game
-from .ob11_ext import ob11_ext_enabled
-from .utils import InputStore, is_group, prepare_game, rule_in_game, rule_not_in_game
-
-in_game_message = on_message(rule=rule_in_game)
-start_game = on_command(
-    "werewolf",
-    rule=to_me() & is_group & rule_not_in_game,
-    aliases={"狼人杀"},
-)
-
-
-@in_game_message.handle()
-async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
-    if target.private:
-        InputStore.put(target.id, None, msg)
-    else:
-        InputStore.put(event.get_user_id(), target.id, msg)
-
-
-@start_game.handle()
-async def handle_start(
-    bot: Bot,
-    event: Event,
-    target: MsgTarget,
-    admin_info: Annotated[UserInfo, EventUserInfo()],
-) -> None:
-    admin_id = event.get_user_id()
-    msg = (
-        UniMessage.at(admin_id)
-        .text("成功创建游戏\n")
-        .text("玩家请 @我 发送 “加入游戏”、“退出游戏”\n")
-        .text("玩家 @我 发送 “当前玩家” 可查看玩家列表\n")
-        .text("游戏发起者 @我 发送 “结束游戏” 可结束当前游戏\n")
-        .text("玩家均加入后，游戏发起者请 @我 发送 “开始游戏”\n")
-    )
-    if ob11_ext_enabled():
-        msg.text("\n可使用戳一戳代替游戏交互中的 “/stop” 命令")
-    await msg.text("\n\n游戏准备阶段限时5分钟，超时将自动结束").send()
-
-    players = {admin_id: admin_info.user_name}
-
-    try:
-        async with timeout(5 * 60):
-            await prepare_game(event, players)
-    except FinishedException:
-        raise
-    except TimeoutError:
-        await UniMessage.text("游戏准备超时，已自动结束").finish()
-
-    game = Game(bot, target, players)
-    game.start()

nonebot_plugin_werewolf/ob11_ext.py

@@ -1,72 +0,0 @@
-import contextlib
-
-from nonebot import on_type
-from nonebot.internal.matcher import current_bot
-from nonebot_plugin_alconna import UniMessage
-
-from .config import config
-from .game import starting_games
-from .utils import InputStore, user_in_game
-
-
-def ob11_ext_enabled() -> bool:
-    return False
-
-
-with contextlib.suppress(ImportError):
-    from nonebot.adapters.onebot.v11 import Bot, MessageSegment
-    from nonebot.adapters.onebot.v11.event import PokeNotifyEvent
-
-    # 游戏内戳一戳等效 "/stop"
-    async def _rule_poke_1(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(user_id, group_id)
-        )
-
-    @on_type(PokeNotifyEvent, rule=_rule_poke_1).handle()
-    async def handle_poke_1(event: PokeNotifyEvent) -> None:
-        InputStore.put(
-            user_id=str(event.user_id),
-            group_id=str(event.group_id) if event.group_id is not None else None,
-            msg=UniMessage.text("/stop"),
-        )
-
-    # 准备阶段戳一戳等效加入游戏
-    async def _rule_poke_2(event: PokeNotifyEvent) -> 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(user_id, group_id)
-            and group_id in starting_games
-        )
-
-    @on_type(PokeNotifyEvent, rule=_rule_poke_2).handle()
-    async def handle_poke_2(bot: Bot, event: PokeNotifyEvent) -> None:
-        user_id = str(event.user_id)
-        group_id = str(event.group_id)
-        players = starting_games[group_id]
-
-        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 bot.send(event, MessageSegment.at(user_id) + "成功加入游戏")
-
-    def ob11_ext_enabled() -> bool:
-        if not config.enable_poke:
-            return False
-
-        return isinstance(current_bot.get(), Bot)