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

nonebot_plugin_werewolf/utils.py

@@ -1,14 +1,16 @@
 import asyncio
+import itertools
 import re
 from collections import defaultdict
-from typing import Annotated, Any, ClassVar
+from typing import Any, ClassVar
 
+import nonebot
 import nonebot_plugin_waiter as waiter
-from nonebot.adapters import Event
-from nonebot.log import logger
+from nonebot.adapters import Bot, Event
 from nonebot.rule import to_me
-from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
-from nonebot_plugin_userinfo import EventUserInfo, UserInfo
+from nonebot.utils import escape_tag
+from nonebot_plugin_alconna import MsgTarget, Target, UniMessage, UniMsg
+from nonebot_plugin_uninfo import Uninfo
 
 from .config import config
 
@@ -24,49 +26,66 @@ def check_index(text: str, arrlen: int) -> int | None:
 class InputStore:
     locks: ClassVar[dict[str, asyncio.Lock]] = defaultdict(asyncio.Lock)
     futures: ClassVar[dict[str, asyncio.Future[UniMessage]]] = {}
+    clear_handle: ClassVar[dict[str, asyncio.Handle]] = {}
+
+    @classmethod
+    def clear_lock(cls, key: str) -> None:
+        if key in cls.locks and not cls.locks[key].locked():
+            del cls.locks[key]
+        if key in cls.clear_handle:
+            del cls.clear_handle[key]
 
     @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()
+            cls.futures[key] = fut = asyncio.get_event_loop().create_future()
             try:
-                return await cls.futures[key]
+                return await fut
             finally:
                 del cls.futures[key]
+                if key in cls.clear_handle:
+                    cls.clear_handle[key].cancel()
+                loop = asyncio.get_event_loop()
+                cls.clear_handle[key] = loop.call_later(120, cls.clear_lock, key)
 
     @classmethod
-    def put(cls, user_id: str, group_id: str | None, msg: UniMessage) -> None:
+    def put(cls, msg: UniMessage, user_id: str, group_id: str | None = None) -> None:
         key = f"{group_id}_{user_id}"
-        if future := cls.futures.get(key):
+        if (future := cls.futures.get(key)) and not future.cancelled():
             future.set_result(msg)
 
 
-def user_in_game(user_id: str, group_id: str | None) -> bool:
-    from .game import running_games
+def user_in_game(self_id: str, user_id: str, group_id: str | None) -> bool:
+    from .game import Game
 
-    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:
+    if group_id is None:
+        return any(
+            self_id == p.user.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(event: Event, target: MsgTarget) -> bool:
-    from .game import running_games
+async def rule_in_game(bot: Bot, event: Event, target: MsgTarget) -> bool:
+    from .game import Game
 
-    if not running_games:
+    if not Game.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
+        return user_in_game(bot.self_id, target.id, None)
+    return user_in_game(bot.self_id, event.get_user_id(), target.id)
 
 
-async def rule_not_in_game(event: Event, target: MsgTarget) -> bool:
-    return not await rule_in_game(event, target)
+async def rule_not_in_game(bot: Bot, event: Event, target: MsgTarget) -> bool:
+    return not await rule_in_game(bot, event, target)
 
 
 async def is_group(target: MsgTarget) -> bool:
@@ -76,35 +95,35 @@ async def is_group(target: MsgTarget) -> bool:
 async def _prepare_game_receive(
     queue: asyncio.Queue[tuple[str, str, str]],
     event: Event,
-    group_id: str,
+    group: Target,
 ) -> None:
-    async def rule(target_: MsgTarget) -> bool:
-        return not target_.private and target_.id == group_id
+    async def same_group(target: MsgTarget) -> bool:
+        return group.verify(target)
 
     @waiter.waiter(
         waits=[event.get_type()],
         keep_session=False,
-        rule=to_me() & rule & rule_not_in_game,
+        rule=to_me() & same_group & rule_not_in_game,
     )
     def wait(
         event: Event,
-        info: Annotated[UserInfo | None, EventUserInfo()],
         msg: UniMsg,
+        session: Uninfo,
     ) -> tuple[str, str, str]:
+        user_id = event.get_user_id()
+        name = session.user.nick or session.user.name or user_id
+        if session.member:
+            name = session.member.nick or name
         return (
-            event.get_user_id(),
-            (
-                (info.user_displayname or info.user_name)
-                if info is not None
-                else event.get_user_id()
-            ),
+            user_id,
             msg.extract_plain_text().strip(),
+            name,
         )
 
-    async for user, name, text in wait(default=(None, "", "")):
+    async for user, text, name in wait(default=(None, "", "")):
         if user is None:
             continue
-        await queue.put((user, re.sub(r"[\u2066-\u2069]", "", name), text))
+        await queue.put((user, text, re.sub(r"[\u2066-\u2069]", "", name)))
 
 
 async def _prepare_game_handle(
@@ -112,12 +131,12 @@ async def _prepare_game_handle(
     players: dict[str, str],
     admin_id: str,
 ) -> None:
-    log = logger.opt(colors=True)
+    logger = nonebot.logger.opt(colors=True)
 
     while True:
-        user, name, text = await queue.get()
-        msg = UniMessage.at(user)
-        colored = f"<y>{name}</y>(<c>{user}</c>)"
+        user, text, name = await queue.get()
+        msg = UniMessage.at(user).text("\n")
+        colored = f"<y>{escape_tag(name)}</y>(<c>{escape_tag(user)}</c>)"
 
         match (text, user == admin_id):
             case ("开始游戏", True):
@@ -125,77 +144,77 @@ async def _prepare_game_handle(
                 role_preset = config.get_role_preset()
                 if player_num < min(role_preset):
                     await (
-                        msg.text(f"游戏至少需要 {min(role_preset)} 人, ")
+                        msg.text(f"⚠️游戏至少需要 {min(role_preset)} 人, ")
                         .text(f"当前已有 {player_num} 人")
                         .send()
                     )
                 elif player_num > max(role_preset):
                     await (
-                        msg.text(f"游戏最多需要 {max(role_preset)} 人, ")
+                        msg.text(f"⚠️游戏最多需要 {max(role_preset)} 人, ")
                         .text(f"当前已有 {player_num} 人")
                         .send()
                     )
                 elif player_num not in role_preset:
                     await (
-                        msg.text(f"不存在总人数为 {player_num} 的预设, ")
+                        msg.text(f"⚠️不存在总人数为 {player_num} 的预设, ")
                         .text("无法开始游戏")
                         .send()
                     )
                 else:
-                    await msg.text("游戏即将开始...").send()
-                    log.info(f"游戏发起者 {colored} 开始游戏")
+                    await msg.text("✏️游戏即将开始...").send()
+                    logger.info(f"游戏发起者 {colored} 开始游戏")
                     return
 
             case ("开始游戏", False):
-                await msg.text("只有游戏发起者可以开始游戏").send()
+                await msg.text("⚠️只有游戏发起者可以开始游戏").send()
 
             case ("结束游戏", True):
-                log.info(f"游戏发起者 {colored} 结束游戏")
-                await msg.text("已结束当前游戏").finish()
+                logger.info(f"游戏发起者 {colored} 结束游戏")
+                await msg.text("ℹ️已结束当前游戏").finish()
 
             case ("结束游戏", False):
-                await msg.text("只有游戏发起者可以结束游戏").send()
+                await msg.text("⚠️只有游戏发起者可以结束游戏").send()
 
             case ("加入游戏", True):
-                await msg.text("游戏发起者已经加入游戏了").send()
+                await msg.text("ℹ️游戏发起者已经加入游戏了").send()
 
             case ("加入游戏", False):
                 if user not in players:
                     players[user] = name
-                    log.info(f"玩家 {colored} 加入游戏")
-                    await msg.text("成功加入游戏").send()
+                    logger.info(f"玩家 {colored} 加入游戏")
+                    await msg.text("✅成功加入游戏").send()
                 else:
-                    await msg.text("你已经加入游戏了").send()
+                    await msg.text("ℹ️你已经加入游戏了").send()
 
             case ("退出游戏", True):
-                await msg.text("游戏发起者无法退出游戏").send()
+                await msg.text("ℹ️游戏发起者无法退出游戏").send()
 
             case ("退出游戏", False):
                 if user in players:
                     del players[user]
-                    log.info(f"玩家 {colored} 退出游戏")
-                    await msg.text("成功退出游戏").send()
+                    logger.info(f"玩家 {colored} 退出游戏")
+                    await msg.text("✅成功退出游戏").send()
                 else:
-                    await msg.text("你还没有加入游戏").send()
+                    await msg.text("ℹ️你还没有加入游戏").send()
 
             case ("当前玩家", _):
-                msg.text("\n当前玩家:\n")
+                msg.text("✨当前玩家:\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
+    from .game import Game
 
-    group_id = UniMessage.get_target(event).id
-    starting_games[group_id] = players
+    group = UniMessage.get_target(event)
+    Game.starting_games[group] = players
 
     queue: asyncio.Queue[tuple[str, str, str]] = asyncio.Queue()
-    task_receive = asyncio.create_task(_prepare_game_receive(queue, event, group_id))
+    task_receive = asyncio.create_task(_prepare_game_receive(queue, event, group))
 
     try:
         await _prepare_game_handle(queue, players, event.get_user_id())
     finally:
         task_receive.cancel()
-        del starting_games[group_id]
+        del Game.starting_games[group]

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

@@ -1,15 +1,18 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-werewolf
-Version: 1.1.2
+Version: 1.1.3
 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
 
 <div align="center">
@@ -240,6 +243,11 @@ werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
 
 <!-- CHANGELOG -->
 
+- 2024.10.06 v1.1.3
+
+  - 使用 `RF-Tar-Railt/nonebot-plugin-uninfo` 获取用户数据
+  - 优化交互文本
+
 - 2024.09.18 v1.1.2
 
   - 修改 Python 需求为 `>=3.10`
@@ -284,6 +292,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.3.dist-info/RECORD

@@ -0,0 +1,29 @@
+nonebot_plugin_werewolf/__init__.py,sha256=Im_u8hP6N6qA2SwnNSGu1MsewLoyHUa3v0Paj1yC3T0,862
+nonebot_plugin_werewolf/_timeout.py,sha256=MVkA5oMoxOTV8Luc0BH2QPP8wwz4Tr9CJjeYgiPu_O4,3649
+nonebot_plugin_werewolf/config.py,sha256=FKQDkb57ujcBYJZX-sLgxWmTVqSeR7T1ywphp7GOCcE,2803
+nonebot_plugin_werewolf/constant.py,sha256=-S-KjlrSc_wJwsXCkQOMFVqyu4RwR4GLXIRZEp_0mlI,2300
+nonebot_plugin_werewolf/exception.py,sha256=YSwxeogIB0YJqH9MP1bgxojiu-I_xQE44XnSk5bC1AQ,400
+nonebot_plugin_werewolf/game.py,sha256=LWxn2OCnkTAF8NdLt1BQzyAtyUfk477xisCf5mbfK_E,17376
+nonebot_plugin_werewolf/player_set.py,sha256=BlK7wHv_9YrCINMAPWL36TLkRjAiI_GXSHlZySVemoo,2777
+nonebot_plugin_werewolf/utils.py,sha256=50bJGhJU7b9kQEqmc2V8-5wYkukilDtchZBSBKcwwq4,7633
+nonebot_plugin_werewolf/matchers/__init__.py,sha256=_MwAZsXlpBLXyzHWqNLTQdMWw9z_O01L5Yo02dzGC9I,88
+nonebot_plugin_werewolf/matchers/message_in_game.py,sha256=hpQCaNaxCikma8DJTJLCttP5B1vBWlqMDEukSqfPlRk,452
+nonebot_plugin_werewolf/matchers/ob11_ext.py,sha256=TGhI4yWfb5N3K9hXkI8k8Rs6cMVXDwp05cXtu3a-_jU,2597
+nonebot_plugin_werewolf/matchers/start_game.py,sha256=DZPQ88hiobuJejIbKsIc8ZcoKDw7wcjawWfTC3wjIto,1884
+nonebot_plugin_werewolf/players/__init__.py,sha256=djAI5XxR2I-XvnH-lVqX_YCHB_AiT-6jdmwFE1ffN_0,379
+nonebot_plugin_werewolf/players/can_shoot.py,sha256=6u_luXfNOWO0svTpb78h74HcG65kh1GZyFPJFYNuOG0,2068
+nonebot_plugin_werewolf/players/civilian.py,sha256=6iKEWRRWDGq1qgVZZZ9pX7kBVpMN-yfxeLq9hIp17hU,165
+nonebot_plugin_werewolf/players/guard.py,sha256=pDH66q-KoU5oRD-tn542x3siXv9BM824-KRxsVb0Gvk,1408
+nonebot_plugin_werewolf/players/hunter.py,sha256=nqYGCVppd4mdCPhFHZbjbbNvZfyCNT0bZ3raQFXmELA,203
+nonebot_plugin_werewolf/players/idiot.py,sha256=7-BTsYUSOcs5rPOJx1hsHPOWcmGcv2rSO8IfUGPdqEE,1456
+nonebot_plugin_werewolf/players/joker.py,sha256=uUK6EuoOWd8_35yvBTkM14XCplOFwFCRsbhR7bjeiD8,699
+nonebot_plugin_werewolf/players/player.py,sha256=ejEjbsrIKpUJql3-qLMFsZY_jGFtQ3OTjcN1lFZ4yKo,4697
+nonebot_plugin_werewolf/players/prophet.py,sha256=nh8eB9T9LMBiqNgnqE-ygAFiYvTZS8bGUKYsNBPm8F0,1078
+nonebot_plugin_werewolf/players/werewolf.py,sha256=kyZjwijEGG0EkP80VOlu8HFzReg33v8a-o670fZN_xI,2560
+nonebot_plugin_werewolf/players/witch.py,sha256=P1odgjFc9kAIUxmlz9aV69aYzl76OVcsQQGhigmRTgc,2571
+nonebot_plugin_werewolf/players/wolfking.py,sha256=hgxOugrIOF6wC5wKcjflPuQ2K4d99eWpF9E69ishbsg,440
+nonebot_plugin_werewolf-1.1.3.dist-info/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
+nonebot_plugin_werewolf-1.1.3.dist-info/METADATA,sha256=uLZxheMxeLRL70cOrpZtr1Nqy2gP1sAIFNiiNtkEwi4,10707
+nonebot_plugin_werewolf-1.1.3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+nonebot_plugin_werewolf-1.1.3.dist-info/top_level.txt,sha256=wLTfg8sTKbH9lLT9LtU118C9cTspEBJareLsrYM52YA,24
+nonebot_plugin_werewolf-1.1.3.dist-info/RECORD,,

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()