nonebot-plugin-werewolf 1.0.3__tar.gz → 1.0.5__tar.gz

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-werewolf
-Version: 1.0.3
+Version: 1.0.5
 Summary: Default template for PDM package
 Author-Email: wyf7685 <wyf7685@163.com>
 License: MIT
@@ -116,9 +116,18 @@ _✨ 简单的狼人杀插件 ✨_
 
 ### 指令表
 
-|        指令         | 权限 | 需要@ | 范围 |   说明   |
-| :-----------------: | :--: | :---: | :--: | :------: |
-| `werewolf`/`狼人杀` | 群员 |  是   | 群聊 | 发起游戏 |
+|        指令         |    权限    | 需要@ | 范围 |                说明                 |
+| :-----------------: | :--------: | :---: | :--: | :---------------------------------: |
+| `werewolf`/`狼人杀` |    群员    |  是   | 群聊 |       发起游戏 (进入准备阶段)       |
+|     `开始游戏`      | 游戏发起者 |  是   | 群聊 |   _[准备阶段]_ 游戏发起者开始游戏   |
+|     `结束游戏`      | 游戏发起者 |  是   | 群聊 |   _[准备阶段]_ 游戏发起者结束游戏   |
+|     `当前玩家`      |    群员    |  是   | 群聊 | _[准备阶段]_ 列出参与游戏的玩家列表 |
+|     `加入游戏`      |    群员    |  是   | 群聊 |      _[准备阶段]_ 玩家加入游戏      |
+|     `退出游戏`      |    群员    |  是   | 群聊 |      _[准备阶段]_ 玩家退出游戏      |
+
+_其他交互参考游戏内提示_
+
+对于 `OneBot V11` 适配器, 启用配置项 `werewolf__enable_poke` 后, 可以使用戳一戳代替 _准备阶段_ 的 `加入游戏` 操作 和 游戏内的 `/stop` 命令
 
 ### 游戏内容
 
@@ -132,8 +141,8 @@ _✨ 简单的狼人杀插件 ✨_
 
 | 总人数 | 狼人 | 神职 | 平民 |
 | ------ | ---- | ---- | ---- |
-| 6      | 1    | 3    | 2    |
-| 7      | 2    | 3    | 2    |
+| 6      | 1    | 2    | 3    |
+| 7      | 2    | 2    | 3    |
 | 8      | 2    | 3    | 3    |
 | 9      | 2    | 4    | 3    |
 | 10     | 3    | 4    | 3    |
@@ -171,9 +180,10 @@ werewolf__override_preset='
 <details>
     <summary>更新日志</summary>
 
-- 2024.09.01 v1.0.3
+- 2024.09.03 v1.0.5
 
   - 优化玩家交互体验
+  - 添加游戏结束后死亡报告
 
 - 2024.08.31 v1.0.1
 

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/README.md

@@ -103,9 +103,18 @@ _✨ 简单的狼人杀插件 ✨_
 
 ### 指令表
 
-|        指令         | 权限 | 需要@ | 范围 |   说明   |
-| :-----------------: | :--: | :---: | :--: | :------: |
-| `werewolf`/`狼人杀` | 群员 |  是   | 群聊 | 发起游戏 |
+|        指令         |    权限    | 需要@ | 范围 |                说明                 |
+| :-----------------: | :--------: | :---: | :--: | :---------------------------------: |
+| `werewolf`/`狼人杀` |    群员    |  是   | 群聊 |       发起游戏 (进入准备阶段)       |
+|     `开始游戏`      | 游戏发起者 |  是   | 群聊 |   _[准备阶段]_ 游戏发起者开始游戏   |
+|     `结束游戏`      | 游戏发起者 |  是   | 群聊 |   _[准备阶段]_ 游戏发起者结束游戏   |
+|     `当前玩家`      |    群员    |  是   | 群聊 | _[准备阶段]_ 列出参与游戏的玩家列表 |
+|     `加入游戏`      |    群员    |  是   | 群聊 |      _[准备阶段]_ 玩家加入游戏      |
+|     `退出游戏`      |    群员    |  是   | 群聊 |      _[准备阶段]_ 玩家退出游戏      |
+
+_其他交互参考游戏内提示_
+
+对于 `OneBot V11` 适配器, 启用配置项 `werewolf__enable_poke` 后, 可以使用戳一戳代替 _准备阶段_ 的 `加入游戏` 操作 和 游戏内的 `/stop` 命令
 
 ### 游戏内容
 
@@ -119,8 +128,8 @@ _✨ 简单的狼人杀插件 ✨_
 
 | 总人数 | 狼人 | 神职 | 平民 |
 | ------ | ---- | ---- | ---- |
-| 6      | 1    | 3    | 2    |
-| 7      | 2    | 3    | 2    |
+| 6      | 1    | 2    | 3    |
+| 7      | 2    | 2    | 3    |
 | 8      | 2    | 3    | 3    |
 | 9      | 2    | 4    | 3    |
 | 10     | 3    | 4    | 3    |
@@ -158,9 +167,10 @@ werewolf__override_preset='
 <details>
     <summary>更新日志</summary>
 
-- 2024.09.01 v1.0.3
+- 2024.09.03 v1.0.5
 
   - 优化玩家交互体验
+  - 添加游戏结束后死亡报告
 
 - 2024.08.31 v1.0.1
 

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/nonebot_plugin_werewolf/__init__.py

@@ -8,7 +8,7 @@ require("nonebot_plugin_waiter")
 from . import matchers as matchers
 from .config import Config
 
-__version__ = "1.0.3"
+__version__ = "1.0.5"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/nonebot_plugin_werewolf/constant.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from enum import Enum, auto
 from typing import TYPE_CHECKING
@@ -45,16 +47,16 @@ class GameStatus(Enum):
 @dataclass
 class GameState:
     day: int
-    killed: "Player | None" = None
-    shoot: tuple["Player", "Player"] | tuple[None, None] = (None, None)
-    protected: "Player | None" = None
-    potion: tuple["Player | None", tuple[bool, bool]] = (None, (False, False))
+    killed: Player | None = None
+    shoot: tuple[Player, Player] | tuple[None, None] = (None, None)
+    protected: Player | None = None
+    potion: tuple[Player | None, tuple[bool, bool]] = (None, (False, False))
 
 
 player_preset: dict[int, tuple[int, int, int]] = {
     # 总人数: (狼, 神, 民)
-    6: (1, 3, 2),
-    7: (2, 3, 2),
+    6: (1, 2, 3),
+    7: (2, 2, 3),
     8: (2, 3, 3),
     9: (2, 4, 3),
     10: (3, 4, 3),

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/nonebot_plugin_werewolf/game.py

@@ -1,16 +1,20 @@
 import asyncio
 import asyncio.timeouts
+import contextlib
 import random
+import time
 
 from nonebot.adapters import Bot
+from nonebot.log import logger
 from nonebot_plugin_alconna import Target, UniMessage
 
 from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, player_preset
 from .player import Player
 from .player_set import PlayerSet
+from .utils import InputStore
 
 starting_games: dict[str, dict[str, str]] = {}
-running_games: dict[str, tuple["Game", asyncio.Task[None]]] = {}
+running_games: dict[str, tuple["Game", asyncio.Task[None], asyncio.Task[None]]] = {}
 
 
 def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
@@ -26,7 +30,11 @@ def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
     roles.extend([Role.预言家, Role.女巫, Role.猎人, Role.守卫, Role.白痴][: preset[1]])
     roles.extend([Role.平民] * preset[2])
 
-    random.shuffle(roles)
+    r = random.Random(time.time())
+    shuffled: list[Role] = []
+    for _ in range(len(players)):
+        idx = r.randint(0, len(roles) - 1)
+        shuffled.append(roles.pop(idx))
 
     async def selector(target_: Target, b: Bot):
         return target_.self_id == bot.self_id and b is bot
@@ -44,7 +52,7 @@ def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
             ),
             players[user_id],
         )
-        for user_id, role in zip(players, roles)
+        for user_id, role in zip(players, shuffled)
     )
 
 
@@ -65,6 +73,7 @@ class Game:
         self.group = group
         self.players = init_players(bot, self, players)
         self.state = GameState(0)
+        self.killed_players = []
 
     async def send(self, message: str | UniMessage):
         if isinstance(message, str):
@@ -111,7 +120,7 @@ class Game:
                 case KillReason.Shoot:
                     msg += " 射杀"
                 case KillReason.Vote:
-                    msg += " 投票放逐"
+                    msg += " 票出"
             msg += "\n\n"
 
         return msg.strip()
@@ -136,7 +145,15 @@ class Game:
         if isinstance(players, Player):
             players = PlayerSet([players])
 
-        await players.wait_group_stop(self.group.id, timeout_secs)
+        async def wait(p: Player):
+            while True:
+                msg = await InputStore.fetch(p.user_id, self.group.id)
+                if msg.extract_plain_text() == "/stop":
+                    break
+
+        with contextlib.suppress(TimeoutError):
+            async with asyncio.timeouts.timeout(timeout_secs):
+                await asyncio.gather(*[wait(p) for p in players])
 
     async def interact(
         self,
@@ -215,11 +232,11 @@ class Game:
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
                 await self.wait_stop(shoot, 60)
+                self.state.shoot = (None, None)
                 await self.post_kill(shoot)
-            self.state.shoot = (None, None)
 
     async def run_vote(self) -> None:
-        # 统计投票结果
+        # 筛选当前存活玩家
         players = self.players.alive()
 
         # 被票玩家: [投票玩家]
@@ -231,9 +248,9 @@ class Game:
 
         # 投票结果公示
         msg = UniMessage.text("投票结果:\n")
-        for p, v in sorted(vote_result.items(), key=lambda x: x[1], reverse=True):
+        for p, v in sorted(vote_result.items(), key=lambda x: len(x[1]), reverse=True):
             if p is not None:
-                msg.at(p.user_id).text(f": {v} 票\n")
+                msg.at(p.user_id).text(f": {len(v)} 票\n")
                 vote_reversed[len(v)] = [*vote_reversed.get(len(v), []), p]
         if v := (len(players) - total_votes):
             msg.text(f"弃票: {v} 票\n")
@@ -244,6 +261,11 @@ class Game:
             await self.send("没有人被票出")
             return
 
+        # 弃票大于最高票
+        if (len(players) - total_votes) >= max(vote_reversed.keys()):
+            await self.send("弃票数大于最高票数, 没有人被票出")
+            return
+
         # 平票
         if len(vs := vote_reversed[max(vote_reversed.keys())]) != 1:
             await self.send(
@@ -270,6 +292,7 @@ class Game:
         await self.post_kill(voted)
 
     async def run_dead_channel(self) -> None:
+        loop = asyncio.get_event_loop()
         queue: asyncio.Queue[tuple[Player, UniMessage]] = asyncio.Queue()
 
         async def send():
@@ -279,20 +302,29 @@ class Game:
                 await self.players.dead().exclude(player).broadcast(msg)
 
         async def recv(player: Player):
+            counter = 0
+
+            def decrease():
+                nonlocal counter
+                counter -= 1
+
             while True:
                 if not player.killed:
                     await asyncio.sleep(1)
                     continue
                 msg = await player.receive()
-                await queue.put((player, msg))
+                counter += 1
+                if counter <= 10:
+                    await queue.put((player, msg))
+                    loop.call_later(60, decrease)
+                else:
+                    await player.send("发言频率超过限制, 该消息被屏蔽")
 
         await asyncio.gather(send(), *[recv(p) for p in self.players])
 
     async def run(self) -> None:
         # 告知玩家角色信息
         await self.notify_player_role()
-        # 死者频道
-        dead_channel = asyncio.create_task(self.run_dead_channel())
         # 天数记录 主要用于第一晚狼人击杀的遗言
         day_count = 0
 
@@ -306,6 +338,7 @@ class Game:
             await asyncio.gather(
                 self.select_killed(),
                 players.select(Role.女巫).broadcast("请等待狼人决定目标..."),
+                players.select(Role.平民).broadcast("请等待其他玩家结束交互..."),
                 self.interact(Role.预言家, 60),
                 self.interact(Role.守卫, 60),
             )
@@ -331,30 +364,30 @@ class Game:
             # 没有玩家死亡，平安夜
             if not (dead := players.dead()):
                 await self.send(msg.text("昨晚是平安夜"))
-            # 有玩家死亡，执行死亡流程
+            # 有玩家死亡，公布死者名单
             else:
-                # 公布死者名单
                 msg.text("昨晚的死者是:")
                 for p in dead.sorted():
                     msg.text("\n").at(p.user_id)
                 await self.send(msg)
-                await self.post_kill(dead)
-
-            # 判断游戏状态
-            if self.check_game_status() != GameStatus.Unset:
-                break
-
-            # 公示存活玩家
-            await self.send(f"当前存活玩家: \n\n{self.players.alive().show()}")
 
             # 第一晚被狼人杀死的玩家发表遗言
             if day_count == 1 and killed is not None and not killed.alive:
                 await self.send(
                     UniMessage.text("当前为第一天\n请被狼人杀死的 ")
                     .at(killed.user_id)
-                    .text(" 发表遗言\n限时1分钟, 发送 “/stop” 结束发言")
+                    .text(" 发表遗言\n")
+                    .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
                 await self.wait_stop(killed, 60)
+            await self.post_kill(dead)
+
+            # 判断游戏状态
+            if self.check_game_status() != GameStatus.Unset:
+                break
+
+            # 公示存活玩家
+            await self.send(f"当前存活玩家: \n\n{self.players.alive().show()}")
 
             # 开始自由讨论
             await self.send("接下来开始自由讨论\n限时2分钟, 全员发送 “/stop” 结束发言")
@@ -365,11 +398,31 @@ class Game:
             await self.run_vote()
 
         # 游戏结束
-        dead_channel.cancel()
         winner = "好人" if self.check_game_status() == GameStatus.Good else "狼人"
         msg = UniMessage.text(f"🎉游戏结束，{winner}获胜\n\n")
         for p in sorted(self.players, key=lambda p: (p.role.value, p.user_id)):
             msg.at(p.user_id).text(f": {p.role.name}\n")
-        msg.text(f"\n{self.show_killed_players()}")
         await self.send(msg)
-        running_games.pop(self.group.id, None)
+        await self.send(f"玩家死亡报告:\n\n{self.show_killed_players()}")
+
+    def start(self):
+        task = asyncio.create_task(self.run())
+        dead_channel = asyncio.create_task(self.run_dead_channel())
+
+        async def daemon():
+            while not task.done():  # noqa: ASYNC110
+                await asyncio.sleep(1)
+
+            try:
+                task.result()
+            except asyncio.CancelledError as err:
+                logger.warning(f"狼人杀游戏进程被取消: {err}")
+            except Exception as err:
+                msg = f"狼人杀游戏进程出现错误: {err!r}"
+                logger.opt(exception=err).error(msg)
+                await self.send(msg)
+            finally:
+                dead_channel.cancel()
+                running_games.pop(self.group.id, None)
+
+        running_games[self.group.id] = (self, task, asyncio.create_task(daemon()))

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/nonebot_plugin_werewolf/matchers.py

@@ -62,5 +62,4 @@ async def handle_start(
         del starting_games[target.id]
 
     game = Game(bot=bot, group=target, players=players)
-    task = asyncio.create_task(game.run())
-    running_games[target.id] = (game, task)
+    game.start()

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/nonebot_plugin_werewolf/player.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import asyncio.timeouts
 from dataclasses import dataclass
@@ -16,7 +18,7 @@ if TYPE_CHECKING:
 
 
 P = TypeVar("P", bound=type["Player"])
-PLAYER_CLASS: dict[Role, type["Player"]] = {}
+PLAYER_CLASS: dict[Role, type[Player]] = {}
 
 
 def register_role(cls: P) -> P:
@@ -27,7 +29,7 @@ def register_role(cls: P) -> P:
 @dataclass
 class KillInfo:
     reason: KillReason
-    killers: "PlayerSet"
+    killers: PlayerSet
 
 
 class Player:
@@ -35,15 +37,15 @@ class Player:
     role_group: ClassVar[RoleGroup]
 
     bot: Bot
-    game: "Game"
+    game: Game
     user: Target
     name: str
     alive: bool = True
     killed: bool = False
     kill_info: KillInfo | None = None
-    selected: "Player | None" = None
+    selected: Player | None = None
 
-    def __init__(self, bot: Bot, game: "Game", user: Target, name: str) -> None:
+    def __init__(self, bot: Bot, game: Game, user: Target, name: str) -> None:
         self.bot = bot
         self.game = game
         self.user = user
@@ -54,10 +56,10 @@ class Player:
         cls,
         role: Role,
         bot: Bot,
-        game: "Game",
+        game: Game,
         user: Target,
         name: str,
-    ) -> "Player":
+    ) -> Player:
         if role not in PLAYER_CLASS:
             raise ValueError(f"Unexpected role: {role!r}")
 
@@ -93,8 +95,10 @@ class Player:
     async def kill(
         self,
         reason: KillReason,
-        *killers: "Player",
+        *killers: Player,
     ) -> bool:
+        from .player_set import PlayerSet
+
         self.alive = False
         self.kill_info = KillInfo(reason, PlayerSet(killers))
         return True
@@ -102,15 +106,16 @@ class Player:
     async def post_kill(self) -> None:
         self.killed = True
 
-    async def vote(self, players: "PlayerSet") -> "tuple[Player, Player] | None":
+    async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
         await self.send(
             f"请选择需要投票的玩家:\n{players.show()}"
             "\n\n发送编号选择玩家\n发送 “/stop” 弃票"
         )
 
         while True:
-            text = (await self.receive()).extract_plain_text()
+            text = await self.receive_text()
             if text == "/stop":
+                await self.send("你选择了弃票")
                 return None
             index = check_index(text, len(players))
             if index is not None:
@@ -185,8 +190,11 @@ class 狼人(Player):
     async def notify_role(self) -> None:
         await super().notify_role()
         partners = self.game.players.alive().select(RoleGroup.狼人).exclude(self)
-        msg = "你的队友:\n" + "\n".join(f"  {p.role.name}: {p.name}" for p in partners)
-        await self.send(msg)
+        if partners:
+            await self.send(
+                "你的队友:\n"
+                + "\n".join(f"  {p.role.name}: {p.name}" for p in partners)
+            )
 
     @override
     async def interact(self) -> None:
@@ -221,7 +229,7 @@ class 狼人(Player):
             if index is not None:
                 selected = index - 1
                 msg = f"当前选择玩家: {players[selected].name}"
-                await self.send(msg)
+                await self.send(f"{msg}\n发送 “/stop” 结束回合")
                 broadcast(f"队友 {self.name} {msg}")
             if text == "/stop":
                 if selected is not None:
@@ -296,7 +304,7 @@ class 女巫(Player):
     async def handle_killed(self) -> bool:
         msg = UniMessage()
         if (killed := self.game.state.killed) is not None:
-            msg.text(f"今晚 {killed} 被刀了\n\n")
+            msg.text(f"今晚 {killed.name} 被刀了\n\n")
         else:
             await self.send("今晚没有人被刀")
             return False
@@ -418,7 +426,7 @@ class 白痴(Player):
         return await super().kill(reason, *killers)
 
     @override
-    async def vote(self, players: "PlayerSet") -> "tuple[Player, Player] | None":
+    async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
         if self.voted:
             await self.send("你已经发动过白痴身份的技能，无法参与本次投票")
             return None

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/nonebot_plugin_werewolf/player_set.py

@@ -1,12 +1,10 @@
 import asyncio
 import asyncio.timeouts
-import contextlib
 
 from nonebot_plugin_alconna.uniseg import UniMessage
 
 from .constant import Role, RoleGroup
 from .player import Player
-from .utils import InputStore
 
 
 class PlayerSet(set[Player]):
@@ -52,12 +50,13 @@ class PlayerSet(set[Player]):
             await asyncio.gather(*[p.interact() for p in self.alive()])
 
     async def vote(self, timeout_secs: float = 60) -> dict[Player, list[Player]]:
-        async def vote(player: Player) -> "tuple[Player, Player] | None":
+        async def vote(player: Player) -> tuple[Player, Player] | None:
             try:
                 async with asyncio.timeouts.timeout(timeout_secs):
                     return await player.vote(self)
             except TimeoutError:
                 await player.send("投票超时，将视为弃票")
+                return None
 
         result: dict[Player, list[Player]] = {}
         for item in await asyncio.gather(*[vote(p) for p in self.alive()]):
@@ -69,17 +68,6 @@ class PlayerSet(set[Player]):
     async def broadcast(self, message: str | UniMessage) -> None:
         await asyncio.gather(*[p.send(message) for p in self])
 
-    async def wait_group_stop(self, group_id: str, timeout_secs: float) -> None:
-        async def wait(p: Player):
-            while True:
-                msg = await InputStore.fetch(p.user_id, group_id)
-                if msg.extract_plain_text() == "/stop":
-                    break
-
-        with contextlib.suppress(TimeoutError):
-            async with asyncio.timeouts.timeout(timeout_secs):
-                await asyncio.gather(*[wait(p) for p in self])
-
     def show(self) -> str:
         return "\n".join(f"{i}. {p.name}" for i, p in enumerate(self.sorted(), 1))
 

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/nonebot_plugin_werewolf/utils.py

@@ -9,7 +9,7 @@ from nonebot.rule import to_me
 from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
 from nonebot_plugin_userinfo import EventUserInfo, UserInfo
 
-from .game import player_preset, running_games
+from .constant import player_preset
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -42,15 +42,19 @@ class InputStore:
 
 
 def user_in_game(user_id: str, group_id: str | None) -> bool:
+    from .game import running_games
+
     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:
+    for game, *_ in games:
         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
+
     if not running_games:
         return False
     if target.private:
@@ -169,12 +173,12 @@ async def _prepare_game_handle(
 
 
 async def prepare_game(event: Event, players: dict[str, str]) -> None:
-    queue = asyncio.Queue()
+    queue: asyncio.Queue[tuple[str, str, str]] = asyncio.Queue()
     task_receive = asyncio.create_task(
         _prepare_game_receive(
             queue,
             event,
-            UniMessage.get_target().id,
+            UniMessage.get_target(event).id,
         )
     )
 

{nonebot_plugin_werewolf-1.0.3 → nonebot_plugin_werewolf-1.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-werewolf"
-version = "1.0.3"
+version = "1.0.5"
 description = "Default template for PDM package"
 authors = [
     { name = "wyf7685", email = "wyf7685@163.com" },