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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-werewolf
-Version: 1.0.5
+Version: 1.0.7
 Summary: Default template for PDM package
 Author-Email: wyf7685 <wyf7685@163.com>
 License: MIT
@@ -88,10 +88,14 @@ _✨ 简单的狼人杀插件 ✨_
 
 在 nonebot2 项目的`.env`文件中添加下表中的必填配置
 
-|           配置项            | 必填 | 默认值 |                             说明                              |
-| :-------------------------: | :--: | :----: | :-----------------------------------------------------------: |
-|   `werewolf__enable_poke`   |  否  | `True` | 是否使用戳一戳简化操作流程<br/>仅在 `OneBot V11` 适配器下生效 |
-| `werewolf__override_preset` |  否  |   -    |                    覆写插件内置的职业预设                     |
+|             配置项              | 必填 | 默认值 |                             说明                              |
+| :-----------------------------: | :--: | :----: | :-----------------------------------------------------------: |
+|     `werewolf__enable_poke`     |  否  | `True` | 是否使用戳一戳简化操作流程<br/>仅在 `OneBot V11` 适配器下生效 |
+|     `werewolf__role_preset`     |  否  |   -    |                    覆写插件内置的职业预设                     |
+|  `werewolf__werewolf_priority`  |  否  |   -    |                     自定义狼人职业优先级                      |
+| `werewolf__priesthood_proirity` |  否  |   -    |                     自定义神职职业优先级                      |
+
+`werewolf__role_preset`, `werewolf__werewolf_priority`, `werewolf__priesthood_proirity` 的配置格式请参考 [`游戏内容`](#游戏内容) 部分
 
 ## 🎉 使用
 
@@ -149,15 +153,15 @@ _其他交互参考游戏内提示_
 | 11     | 3    | 5    | 3    |
 | 12     | 4    | 5    | 3    |
 
-职业预设可以通过配置项 `werewolf__override_preset` 修改
+职业预设可以通过配置项 `werewolf__role_preset` 修改
 
 <details>
 <summary>示例</summary>
 
-配置项 `werewolf__override_preset`
+配置项 `werewolf__role_preset`
 
 ```env
-werewolf__override_preset='
+werewolf__role_preset='
 [
     [6, 1, 3, 2],
     [7, 2, 3, 2]
@@ -170,16 +174,67 @@ werewolf__override_preset='
 </details>
 <br/>
 
-对于`狼人`和`神职`的职业分配，有如下优先级:
+对于`狼人`和`神职`的职业分配，默认有如下优先级:
 
 - `狼人`: `狼人`, `狼人`, `狼王`, `狼人`
-- `神职`: `预言家`, `女巫`, `猎人`, `守卫`, `白痴`
+- `神职`: `女巫`, `预言家`, `猎人`, `守卫`, `白痴`
+
+职业分配优先级可以通过配置项 `werewolf__werewolf_priority` 和 `werewolf__priesthood_proirity` 修改
+
+<details>
+<summary>示例</summary>
+
+#### 配置项 `werewolf__werewolf_priority`
+
+```env
+werewolf__werewolf_priority=[1, 2, 1, 1]
+```
+
+上述配置中，`[1, 2, 1, 1]` 表示狼人的职业优先级为 `狼人`, `狼王`, `狼人`, `狼人`
+
+#### 配置项 `werewolf__werewolf_priority`
+
+```env
+werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
+```
+
+上述配置中，`[11, 12, 13, 14, 15]` 表示神职的职业优先级为 `预言家`, `女巫`, `猎人`, `守卫`, `白痴`
+
+#### 职业与数字的对应关系
+
+上述配置示例中有大量~~意义不明的~~数字, 其对应的是 [`这里`](./nonebot_plugin_werewolf/constant.py) 的枚举类 `Role` 的值
+
+以下列出目前的枚举值供参考
+
+| 职业     | 枚举值 |
+| -------- | ------ |
+| `狼人`   | `1`    |
+| `狼王`   | `2`    |
+| `预言家` | `11`   |
+| `女巫`   | `12`   |
+| `猎人`   | `13`   |
+| `守卫`   | `14`   |
+| `白痴`   | `15`   |
+| `平民`   | `0`    |
+
+</details>
 
 ## 📝 更新日志
 
 <details>
     <summary>更新日志</summary>
 
+<!-- CHANGELOG -->
+
+- 2024.09.04 v1.0.7
+
+  - 优先使用群名片作为玩家名
+  - 支持通过配置项修改职业分配优先级
+
+- 2024.09.03 v1.0.6
+
+  - 修复预言家查验狼王返回好人的 bug
+
 - 2024.09.03 v1.0.5
 
   - 优化玩家交互体验
@@ -187,7 +242,7 @@ werewolf__override_preset='
 
 - 2024.08.31 v1.0.1
 
-  - 允许通过配置项修改职业预设
+  - 支持通过配置项修改职业预设
 
 - 2024.08.31 v1.0.0
 
@@ -201,3 +256,4 @@ werewolf__override_preset='
 - [`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-waiter`](https://github.com/RF-Tar-Railt/nonebot-plugin-waiter): 灵活获取用户输入
+- `热心群友`: 协助测试插件

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

@@ -75,10 +75,14 @@ _✨ 简单的狼人杀插件 ✨_
 
 在 nonebot2 项目的`.env`文件中添加下表中的必填配置
 
-|           配置项            | 必填 | 默认值 |                             说明                              |
-| :-------------------------: | :--: | :----: | :-----------------------------------------------------------: |
-|   `werewolf__enable_poke`   |  否  | `True` | 是否使用戳一戳简化操作流程<br/>仅在 `OneBot V11` 适配器下生效 |
-| `werewolf__override_preset` |  否  |   -    |                    覆写插件内置的职业预设                     |
+|             配置项              | 必填 | 默认值 |                             说明                              |
+| :-----------------------------: | :--: | :----: | :-----------------------------------------------------------: |
+|     `werewolf__enable_poke`     |  否  | `True` | 是否使用戳一戳简化操作流程<br/>仅在 `OneBot V11` 适配器下生效 |
+|     `werewolf__role_preset`     |  否  |   -    |                    覆写插件内置的职业预设                     |
+|  `werewolf__werewolf_priority`  |  否  |   -    |                     自定义狼人职业优先级                      |
+| `werewolf__priesthood_proirity` |  否  |   -    |                     自定义神职职业优先级                      |
+
+`werewolf__role_preset`, `werewolf__werewolf_priority`, `werewolf__priesthood_proirity` 的配置格式请参考 [`游戏内容`](#游戏内容) 部分
 
 ## 🎉 使用
 
@@ -136,15 +140,15 @@ _其他交互参考游戏内提示_
 | 11     | 3    | 5    | 3    |
 | 12     | 4    | 5    | 3    |
 
-职业预设可以通过配置项 `werewolf__override_preset` 修改
+职业预设可以通过配置项 `werewolf__role_preset` 修改
 
 <details>
 <summary>示例</summary>
 
-配置项 `werewolf__override_preset`
+配置项 `werewolf__role_preset`
 
 ```env
-werewolf__override_preset='
+werewolf__role_preset='
 [
     [6, 1, 3, 2],
     [7, 2, 3, 2]
@@ -157,16 +161,67 @@ werewolf__override_preset='
 </details>
 <br/>
 
-对于`狼人`和`神职`的职业分配，有如下优先级:
+对于`狼人`和`神职`的职业分配，默认有如下优先级:
 
 - `狼人`: `狼人`, `狼人`, `狼王`, `狼人`
-- `神职`: `预言家`, `女巫`, `猎人`, `守卫`, `白痴`
+- `神职`: `女巫`, `预言家`, `猎人`, `守卫`, `白痴`
+
+职业分配优先级可以通过配置项 `werewolf__werewolf_priority` 和 `werewolf__priesthood_proirity` 修改
+
+<details>
+<summary>示例</summary>
+
+#### 配置项 `werewolf__werewolf_priority`
+
+```env
+werewolf__werewolf_priority=[1, 2, 1, 1]
+```
+
+上述配置中，`[1, 2, 1, 1]` 表示狼人的职业优先级为 `狼人`, `狼王`, `狼人`, `狼人`
+
+#### 配置项 `werewolf__werewolf_priority`
+
+```env
+werewolf__priesthood_proirity=[11, 12, 13, 14, 15]
+```
+
+上述配置中，`[11, 12, 13, 14, 15]` 表示神职的职业优先级为 `预言家`, `女巫`, `猎人`, `守卫`, `白痴`
+
+#### 职业与数字的对应关系
+
+上述配置示例中有大量~~意义不明的~~数字, 其对应的是 [`这里`](./nonebot_plugin_werewolf/constant.py) 的枚举类 `Role` 的值
+
+以下列出目前的枚举值供参考
+
+| 职业     | 枚举值 |
+| -------- | ------ |
+| `狼人`   | `1`    |
+| `狼王`   | `2`    |
+| `预言家` | `11`   |
+| `女巫`   | `12`   |
+| `猎人`   | `13`   |
+| `守卫`   | `14`   |
+| `白痴`   | `15`   |
+| `平民`   | `0`    |
+
+</details>
 
 ## 📝 更新日志
 
 <details>
     <summary>更新日志</summary>
 
+<!-- CHANGELOG -->
+
+- 2024.09.04 v1.0.7
+
+  - 优先使用群名片作为玩家名
+  - 支持通过配置项修改职业分配优先级
+
+- 2024.09.03 v1.0.6
+
+  - 修复预言家查验狼王返回好人的 bug
+
 - 2024.09.03 v1.0.5
 
   - 优化玩家交互体验
@@ -174,7 +229,7 @@ werewolf__override_preset='
 
 - 2024.08.31 v1.0.1
 
-  - 允许通过配置项修改职业预设
+  - 支持通过配置项修改职业预设
 
 - 2024.08.31 v1.0.0
 
@@ -188,3 +243,4 @@ werewolf__override_preset='
 - [`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-waiter`](https://github.com/RF-Tar-Railt/nonebot-plugin-waiter): 灵活获取用户输入
+- `热心群友`: 协助测试插件

{nonebot_plugin_werewolf-1.0.5 → nonebot_plugin_werewolf-1.0.7}/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.5"
+__version__ = "1.0.7"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",

{nonebot_plugin_werewolf-1.0.5 → nonebot_plugin_werewolf-1.0.7}/nonebot_plugin_werewolf/config.py

@@ -1,10 +1,14 @@
 from nonebot import get_plugin_config
 from pydantic import BaseModel
 
+from .constant import Role
+
 
 class PluginConfig(BaseModel):
     enable_poke: bool = True
-    override_preset: list[tuple[int, int, int, int]] | None = None
+    role_preset: list[tuple[int, int, int, int]] | None = None
+    werewolf_priority: list[Role] | None = None
+    priesthood_proirity: list[Role] | None = None
 
 
 class Config(BaseModel):

nonebot_plugin_werewolf-1.0.7/nonebot_plugin_werewolf/constant.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .player import Player
+
+
+class Role(Enum):
+    # 狼人
+    Werewolf = 1
+    WolfKing = 2
+
+    # 神职
+    Prophet = 11
+    Witch = 12
+    Hunter = 13
+    Guard = 14
+    Idiot = 15
+
+    # 平民
+    Civilian = 0
+
+
+class RoleGroup(Enum):
+    Werewolf = auto()
+    GoodGuy = auto()
+
+
+class KillReason(Enum):
+    Kill = auto()
+    Poison = auto()
+    Shoot = auto()
+    Vote = auto()
+
+
+class GameStatus(Enum):
+    Good = auto()
+    Bad = auto()
+    Unset = auto()
+
+
+@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))
+
+
+role_name_conv: dict[Role | RoleGroup, str] = {
+    Role.Werewolf: "狼人",
+    Role.WolfKing: "狼王",
+    Role.Prophet: "预言家",
+    Role.Witch: "女巫",
+    Role.Hunter: "猎人",
+    Role.Guard: "守卫",
+    Role.Idiot: "白痴",
+    Role.Civilian: "平民",
+    RoleGroup.Werewolf: "狼人",
+    RoleGroup.GoodGuy: "好人",
+}
+
+role_preset: dict[int, tuple[int, int, int]] = {
+    # 总人数: (狼, 神, 民)
+    6: (1, 2, 3),
+    7: (2, 2, 3),
+    8: (2, 3, 3),
+    9: (2, 4, 3),
+    10: (3, 4, 3),
+    11: (3, 5, 3),
+    12: (4, 5, 3),
+}
+
+werewolf_priority: list[Role] = [
+    Role.Werewolf,
+    Role.Werewolf,
+    Role.WolfKing,
+    Role.Werewolf,
+]
+priesthood_proirity: list[Role] = [
+    Role.Witch,
+    Role.Prophet,
+    Role.Hunter,
+    Role.Guard,
+    Role.Idiot,
+]
+
+
+def __apply_config():
+    from .config import config
+
+    global role_preset, werewolf_priority, priesthood_proirity
+
+    if config.role_preset is not None:
+        for preset in config.role_preset:
+            if preset[0] != preset[1:]:
+                raise RuntimeError(
+                    "配置项 `role_preset` 错误: "
+                    f"预设总人数为 {preset[0]}, 实际总人数为 {sum(preset[1:])}"
+                )
+        role_preset |= {i[0]: i[1:] for i in config.role_preset}
+
+    if (priority := config.werewolf_priority) is not None:
+        min_length = max(i[0] for i in role_preset.values())
+        if len(priority) < min_length:
+            raise RuntimeError(
+                f"配置项 `werewolf_priority` 错误: 应至少为 {min_length} 项"
+            )
+        werewolf_priority = priority
+
+    if (priority := config.priesthood_proirity) is not None:
+        min_length = max(i[1] for i in role_preset.values())
+        if len(priority) < min_length:
+            raise RuntimeError(
+                f"配置项 `priesthood_proirity` 错误: 应至少为 {min_length} 项"
+            )
+        priesthood_proirity = priority
+
+
+__apply_config()

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import asyncio.timeouts
 import contextlib
@@ -8,27 +10,36 @@ 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 .constant import (
+    GameState,
+    GameStatus,
+    KillReason,
+    Role,
+    RoleGroup,
+    priesthood_proirity,
+    role_preset,
+    werewolf_priority,
+)
 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], asyncio.Task[None]]] = {}
+running_games: dict[str, Game] = {}
 
 
-def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
-    preset = player_preset.get(len(players))
+def init_players(bot: Bot, game: Game, players: dict[str, str]) -> PlayerSet:
+    preset = role_preset.get(len(players))
     if preset is None:
         raise ValueError(
             f"玩家人数不符: "
-            f"应为 {', '.join(map(str, player_preset))} 人, 传入{len(players)}人"
+            f"应为 {', '.join(map(str, role_preset))} 人, 传入{len(players)}人"
         )
 
     roles: list[Role] = []
-    roles.extend([Role.狼人, Role.狼人, Role.狼王, Role.狼人][: preset[0]])
-    roles.extend([Role.预言家, Role.女巫, Role.猎人, Role.守卫, Role.白痴][: preset[1]])
-    roles.extend([Role.平民] * preset[2])
+    roles.extend(werewolf_priority[: preset[0]])
+    roles.extend(priesthood_proirity[: preset[1]])
+    roles.extend([Role.Civilian] * preset[2])
 
     r = random.Random(time.time())
     shuffled: list[Role] = []
@@ -82,20 +93,20 @@ class Game:
 
     def at_all(self) -> UniMessage:
         msg = UniMessage()
-        for p in sorted(self.players, key=lambda p: (p.role.name, p.user_id)):
+        for p in sorted(self.players, key=lambda p: (p.role_name, p.user_id)):
             msg.at(p.user_id)
         return msg
 
     def check_game_status(self) -> GameStatus:
         players = self.players.alive()
-        w = players.select(RoleGroup.狼人)
-        p = players.exclude(RoleGroup.狼人)
+        w = players.select(RoleGroup.Werewolf)
+        p = players.exclude(RoleGroup.Werewolf)
 
         if w.size >= p.size:
             return GameStatus.Bad
-        if not p.select(Role.平民):
+        if not p.select(Role.Civilian):
             return GameStatus.Bad
-        if not p.exclude(Role.平民):
+        if not p.exclude(Role.Civilian):
             return GameStatus.Bad
         if not w.size:
             return GameStatus.Good
@@ -126,7 +137,7 @@ class Game:
         return msg.strip()
 
     async def notify_player_role(self) -> None:
-        preset = player_preset[len(self.players)]
+        preset = role_preset[len(self.players)]
         await asyncio.gather(
             self.send(
                 self.at_all()
@@ -162,7 +173,7 @@ class Game:
     ) -> None:
         players = self.players.alive().select(type_)
         text = (
-            type_.role.name  # Player
+            type_.role_name  # Player
             if isinstance(type_, Player)
             else (
                 type_.name  # Role
@@ -181,8 +192,8 @@ class Game:
         players = self.players.alive()
         self.state.killed = None
 
-        w = players.select(RoleGroup.狼人)
-        await self.interact(RoleGroup.狼人, 120)
+        w = players.select(RoleGroup.Werewolf)
+        await self.interact(RoleGroup.Werewolf, 120)
         if (s := w.player_selected()).size == 1:
             self.state.killed = s.pop()
             await w.broadcast(f"今晚选择的目标为: {self.state.killed.name}")
@@ -190,8 +201,8 @@ class Game:
             await w.broadcast("狼人阵营意见未统一，此晚空刀")
 
         # 如果女巫存活，正常交互，限时1分钟
-        if players.include(Role.女巫):
-            await self.interact(Role.女巫, 60)
+        if players.include(Role.Witch):
+            await self.interact(Role.Witch, 60)
         # 否则等待 5-20s
         else:
             await asyncio.sleep(random.uniform(5, 20))
@@ -228,7 +239,7 @@ class Game:
                 await self.send(
                     UniMessage.text("玩家 ")
                     .at(shoot.user_id)
-                    .text(f" 被{shooter.role.name}射杀, 请发表遗言\n")
+                    .text(f" 被{shooter.role_name}射杀, 请发表遗言\n")
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
                 await self.wait_stop(shoot, 60)
@@ -337,10 +348,10 @@ class Game:
             # 狼人、预言家、守卫 同时交互，女巫在狼人后交互
             await asyncio.gather(
                 self.select_killed(),
-                players.select(Role.女巫).broadcast("请等待狼人决定目标..."),
-                players.select(Role.平民).broadcast("请等待其他玩家结束交互..."),
-                self.interact(Role.预言家, 60),
-                self.interact(Role.守卫, 60),
+                players.select(Role.Witch).broadcast("请等待狼人决定目标..."),
+                players.select(Role.Civilian).broadcast("请等待其他玩家结束交互..."),
+                self.interact(Role.Prophet, 60),
+                self.interact(Role.Guard, 60),
             )
 
             # 狼人击杀目标
@@ -354,10 +365,12 @@ class Game:
             if killed is not None:
                 # 除非守卫保护或女巫使用解药，否则狼人正常击杀玩家
                 if not ((killed is protected) or (antidote and potioned is killed)):
-                    await killed.kill(KillReason.Kill, *players.select(RoleGroup.狼人))
+                    await killed.kill(
+                        KillReason.Kill, *players.select(RoleGroup.Werewolf)
+                    )
             # 如果女巫使用毒药且守卫未保护，杀死该玩家
             if poison and (potioned is not None) and (potioned is not protected):
-                await potioned.kill(KillReason.Poison, *players.select(Role.女巫))
+                await potioned.kill(KillReason.Poison, *players.select(Role.Witch))
 
             day_count += 1
             msg = UniMessage.text(f"『第{day_count}天』天亮了...\n")
@@ -401,28 +414,37 @@ class Game:
         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.at(p.user_id).text(f": {p.role_name}\n")
         await self.send(msg)
         await self.send(f"玩家死亡报告:\n\n{self.show_killed_players()}")
 
     def start(self):
-        task = asyncio.create_task(self.run())
+        event = asyncio.Event()
+        game_task = asyncio.create_task(self.run())
+        game_task.add_done_callback(lambda _: event.set())
         dead_channel = asyncio.create_task(self.run_dead_channel())
 
         async def daemon():
-            while not task.done():  # noqa: ASYNC110
-                await asyncio.sleep(1)
+            await event.wait()
 
             try:
-                task.result()
+                game_task.result()
+                logger.info(f"{self.group.id} 的狼人杀游戏进程正常退出")
             except asyncio.CancelledError as err:
-                logger.warning(f"狼人杀游戏进程被取消: {err}")
+                logger.warning(f"{self.group.id} 的狼人杀游戏进程被取消: {err}")
             except Exception as err:
-                msg = f"狼人杀游戏进程出现错误: {err!r}"
+                msg = f"{self.group.id} 的狼人杀游戏进程出现错误: {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()))
+        def daemon_callback(task: asyncio.Task[None]):
+            if err := task.exception():
+                logger.opt(exception=err).error(
+                    f"{self.group.id} 的狼人杀守护进程出现错误: {err!r}"
+                )
+
+        running_games[self.group.id] = self
+        asyncio.create_task(daemon()).add_done_callback(daemon_callback)

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

@@ -4,6 +4,7 @@ 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
@@ -56,6 +57,8 @@ async def handle_start(
     try:
         async with asyncio.timeouts.timeout(5 * 60):
             await prepare_game(event, players)
+    except FinishedException:
+        raise
     except TimeoutError:
         await UniMessage.text("游戏准备超时，已自动结束").finish()
     finally:

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

@@ -3,13 +3,13 @@ from __future__ import annotations
 import asyncio
 import asyncio.timeouts
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, ClassVar, TypeVar
+from typing import TYPE_CHECKING, ClassVar, TypeVar, final
 from typing_extensions import override
 
 from nonebot.adapters import Bot
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
 
-from .constant import KillReason, Role, RoleGroup
+from .constant import KillReason, Role, RoleGroup, role_name_conv
 from .utils import InputStore, check_index
 
 if TYPE_CHECKING:
@@ -21,9 +21,14 @@ P = TypeVar("P", bound=type["Player"])
 PLAYER_CLASS: dict[Role, type[Player]] = {}
 
 
-def register_role(cls: P) -> P:
-    PLAYER_CLASS[cls.role] = cls
-    return cls
+def register_role(role: Role, role_group: RoleGroup, /):
+    def decorator(cls: P, /) -> P:
+        cls.role = role
+        cls.role_group = role_group
+        PLAYER_CLASS[role] = cls
+        return cls
+
+    return decorator
 
 
 @dataclass
@@ -45,12 +50,14 @@ class Player:
     kill_info: KillInfo | None = None
     selected: Player | None = None
 
+    @final
     def __init__(self, bot: Bot, game: Game, user: Target, name: str) -> None:
         self.bot = bot
         self.game = game
         self.user = user
         self.name = name
 
+    @final
     @classmethod
     def new(
         cls,
@@ -66,23 +73,30 @@ class Player:
         return PLAYER_CLASS[role](bot, game, user, name)
 
     def __repr__(self) -> str:
-        return f"<{self.role.name}: user={self.user} alive={self.alive}>"
+        return f"<{self.role_name}: user={self.user} alive={self.alive}>"
 
     @property
     def user_id(self) -> str:
         return self.user.id
 
+    @property
+    def role_name(self) -> str:
+        return role_name_conv[self.role]
+
+    @final
     async def send(self, message: str | UniMessage) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
 
         return await message.send(target=self.user, bot=self.bot)
 
+    @final
     async def receive(self, prompt: str | UniMessage | None = None) -> UniMessage:
         if prompt:
             await self.send(prompt)
         return await InputStore.fetch(self.user.id)
 
+    @final
     async def receive_text(self) -> str:
         return (await self.receive()).extract_plain_text()
 
@@ -90,7 +104,7 @@ class Player:
         return
 
     async def notify_role(self) -> None:
-        await self.send(f"你的身份: {self.role.name}")
+        await self.send(f"你的身份: {self.role_name}")
 
     async def kill(
         self,
@@ -136,9 +150,9 @@ class CanShoot(Player):
             return await super().post_kill()
 
         await self.game.send(
-            UniMessage.text(f"{self.role.name} ")
+            UniMessage.text(f"{self.role_name} ")
             .at(self.user_id)
-            .text(f" 死了\n请{self.role.name}决定击杀目标...")
+            .text(f" 死了\n请{self.role_name}决定击杀目标...")
         )
 
         self.game.state.shoot = (None, None)
@@ -147,14 +161,14 @@ class CanShoot(Player):
         if shoot is not None:
             self.game.state.shoot = (self, shoot)
             await self.send(
-                UniMessage.text(f"{self.role.name} ")
+                UniMessage.text(f"{self.role_name} ")
                 .at(self.user_id)
                 .text(" 射杀了玩家 ")
                 .at(shoot.user_id)
             )
             await shoot.kill(KillReason.Shoot, self)
         else:
-            await self.send(f"{self.role.name}选择了取消技能")
+            await self.send(f"{self.role_name}选择了取消技能")
         return await super().post_kill()
 
     async def shoot(self) -> Player | None:
@@ -181,25 +195,22 @@ class CanShoot(Player):
         return players[selected]
 
 
-@register_role
-class 狼人(Player):
-    role: ClassVar[Role] = Role.狼人
-    role_group: ClassVar[RoleGroup] = RoleGroup.狼人
-
+@register_role(Role.Werewolf, RoleGroup.Werewolf)
+class Werewolf(Player):
     @override
     async def notify_role(self) -> None:
         await super().notify_role()
-        partners = self.game.players.alive().select(RoleGroup.狼人).exclude(self)
+        partners = self.game.players.alive().select(RoleGroup.Werewolf).exclude(self)
         if partners:
             await self.send(
                 "你的队友:\n"
-                + "\n".join(f"  {p.role.name}: {p.name}" for p in partners)
+                + "\n".join(f"  {p.role_name}: {p.name}" for p in partners)
             )
 
     @override
     async def interact(self) -> None:
         players = self.game.players.alive()
-        partners = players.select(RoleGroup.狼人).exclude(self)
+        partners = players.select(RoleGroup.Werewolf).exclude(self)
 
         # 避免阻塞
         def broadcast(msg: str | UniMessage):
@@ -209,7 +220,7 @@ class 狼人(Player):
         if partners:
             msg = (
                 msg.text("你的队友:\n")
-                .text("\n".join(f"  {p.role.name}: {p.name}" for p in partners))
+                .text("\n".join(f"  {p.role_name}: {p.name}" for p in partners))
                 .text("\n所有私聊消息将被转发至队友\n\n")
             )
         await self.send(
@@ -243,17 +254,13 @@ class 狼人(Player):
         self.selected = players[selected]
 
 
-@register_role
-class 狼王(CanShoot, 狼人):
-    role: ClassVar[Role] = Role.狼王
-    role_group: ClassVar[RoleGroup] = RoleGroup.狼人
-
+@register_role(Role.WolfKing, RoleGroup.Werewolf)
+class WolfKing(CanShoot, Werewolf):
+    pass
 
-@register_role
-class 预言家(Player):
-    role: ClassVar[Role] = Role.预言家
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
 
+@register_role(Role.Prophet, RoleGroup.GoodGuy)
+class Prophet(Player):
     @override
     async def interact(self) -> None:
         players = self.game.players.alive().exclude(self)
@@ -272,14 +279,12 @@ class 预言家(Player):
             await self.send("输入错误，请发送编号选择玩家")
 
         player = players[selected]
-        result = "狼人" if player.role == Role.狼人 else "好人"
+        result = role_name_conv[player.role_group]
         await self.send(f"玩家 {player.name} 的阵营是『{result}』")
 
 
-@register_role
-class 女巫(Player):
-    role: ClassVar[Role] = Role.女巫
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+@register_role(Role.Witch, RoleGroup.GoodGuy)
+class Witch(Player):
     antidote: int = 1
     poison: int = 1
 
@@ -365,17 +370,13 @@ class 女巫(Player):
         await self.send(f"当前回合选择对玩家 {player.name} 使用毒药\n回合结束")
 
 
-@register_role
-class 猎人(CanShoot, Player):
-    role: ClassVar[Role] = Role.猎人
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
-
+@register_role(Role.Hunter, RoleGroup.GoodGuy)
+class Hunter(CanShoot, Player):
+    pass
 
-@register_role
-class 守卫(Player):
-    role: ClassVar[Role] = Role.守卫
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
 
+@register_role(Role.Guard, RoleGroup.GoodGuy)
+class Guard(Player):
     @override
     async def interact(self) -> None:
         players = self.game.players.alive().exclude(self)
@@ -403,10 +404,8 @@ class 守卫(Player):
         await self.send(f"本回合保护的玩家: {self.selected.name}")
 
 
-@register_role
-class 白痴(Player):
-    role: ClassVar[Role] = Role.白痴
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+@register_role(Role.Idiot, RoleGroup.GoodGuy)
+class Idiot(Player):
     voted: bool = False
 
     @override
@@ -433,7 +432,6 @@ class 白痴(Player):
         return await super().vote(players)
 
 
-@register_role
-class 平民(Player):
-    role: ClassVar[Role] = Role.平民
-    role_group: ClassVar[RoleGroup] = RoleGroup.好人
+@register_role(Role.Civilian, RoleGroup.GoodGuy)
+class Civilian(Player):
+    pass

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import asyncio.timeouts
 
@@ -12,23 +14,23 @@ class PlayerSet(set[Player]):
     def size(self) -> int:
         return len(self)
 
-    def alive(self) -> "PlayerSet":
+    def alive(self) -> PlayerSet:
         return PlayerSet(p for p in self if p.alive)
 
-    def dead(self) -> "PlayerSet":
+    def dead(self) -> PlayerSet:
         return PlayerSet(p for p in self if not p.alive)
 
-    def include(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
+    def include(self, *types: Player | Role | RoleGroup) -> PlayerSet:
         return PlayerSet(
             player
             for player in self
             if (player in types or player.role in types or player.role_group in types)
         )
 
-    def select(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
+    def select(self, *types: Player | Role | RoleGroup) -> PlayerSet:
         return self.include(*types)
 
-    def exclude(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
+    def exclude(self, *types: Player | Role | RoleGroup) -> PlayerSet:
         return PlayerSet(
             player
             for player in self
@@ -39,7 +41,7 @@ class PlayerSet(set[Player]):
             )
         )
 
-    def player_selected(self) -> "PlayerSet":
+    def player_selected(self) -> PlayerSet:
         return PlayerSet(p.selected for p in self.alive() if p.selected is not None)
 
     def sorted(self) -> list[Player]:

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

@@ -1,5 +1,6 @@
 import asyncio
 import asyncio.timeouts
+import re
 from collections import defaultdict
 from typing import Annotated, Any, ClassVar
 
@@ -9,7 +10,7 @@ from nonebot.rule import to_me
 from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
 from nonebot_plugin_userinfo import EventUserInfo, UserInfo
 
-from .constant import player_preset
+from .constant import role_preset
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -47,7 +48,7 @@ def user_in_game(user_id: str, group_id: str | None) -> bool:
     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
 
@@ -92,13 +93,18 @@ async def _prepare_game_receive(
     ) -> tuple[str, str, str]:
         return (
             event.get_user_id(),
-            info.user_name if info is not None else 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
+        name = re.sub(r"[\u2066-\u2069]", "", name)
         await queue.put((user, name, text))
 
 
@@ -114,19 +120,19 @@ async def _prepare_game_handle(
         match (text, user == admin_id):
             case ("开始游戏", True):
                 player_num = len(players)
-                if player_num < min(player_preset):
+                if player_num < min(role_preset):
                     await (
-                        msg.text(f"游戏至少需要 {min(player_preset)} 人, ")
+                        msg.text(f"游戏至少需要 {min(role_preset)} 人, ")
                         .text(f"当前已有 {player_num} 人")
                         .send()
                     )
-                elif player_num > max(player_preset):
+                elif player_num > max(role_preset):
                     await (
-                        msg.text(f"游戏最多需要 {max(player_preset)} 人, ")
+                        msg.text(f"游戏最多需要 {max(role_preset)} 人, ")
                         .text(f"当前已有 {player_num} 人")
                         .send()
                     )
-                elif player_num not in player_preset:
+                elif player_num not in role_preset:
                     await (
                         msg.text(f"不存在总人数为 {player_num} 的预设, ")
                         .text("无法开始游戏")
@@ -167,8 +173,8 @@ async def _prepare_game_handle(
 
             case ("当前玩家", _):
                 msg.text("\n当前玩家:\n")
-                for name in players.values():
-                    msg.text(f"\n{name}")
+                for idx, name in enumerate(players.values(), 1):
+                    msg.text(f"\n{idx}. {name}")
                 await msg.send()
 
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-werewolf"
-version = "1.0.5"
+version = "1.0.7"
 description = "Default template for PDM package"
 authors = [
     { name = "wyf7685", email = "wyf7685@163.com" },
@@ -26,6 +26,9 @@ build-backend = "pdm.backend"
 [tool.pdm]
 distribution = true
 
+[tool.pdm.scripts]
+updver = "pdm run python ./scripts/update_version.py"
+
 [tool.pdm.scripts.lint]
 composite = [
     "isort .",
@@ -96,3 +99,13 @@ pythonPlatform = "All"
 typeCheckingMode = "standard"
 reportShadowedImports = false
 disableBytesTypePromotions = true
+
+[tool.nonebot]
+adapters = [
+    { name = "OneBot V11", module_name = "nonebot.adapters.onebot.v11" },
+]
+plugins = [
+    "nonebot_plugin_werewolf",
+]
+plugin_dirs = []
+builtin_plugins = []

nonebot_plugin_werewolf-1.0.5/nonebot_plugin_werewolf/constant.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import Enum, auto
-from typing import TYPE_CHECKING
-
-from .config import config
-
-if TYPE_CHECKING:
-    from .player import Player
-
-
-class Role(Enum):
-    # 狼人
-    狼人 = auto()
-    狼王 = auto()
-
-    # 神职
-    预言家 = auto()
-    女巫 = auto()
-    猎人 = auto()
-    守卫 = auto()
-    白痴 = auto()
-
-    # 平民
-    平民 = auto()
-
-
-class RoleGroup(Enum):
-    狼人 = auto()
-    好人 = auto()
-
-
-class KillReason(Enum):
-    Kill = auto()
-    Poison = auto()
-    Shoot = auto()
-    Vote = auto()
-
-
-class GameStatus(Enum):
-    Good = auto()
-    Bad = auto()
-    Unset = auto()
-
-
-@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))
-
-
-player_preset: dict[int, tuple[int, int, int]] = {
-    # 总人数: (狼, 神, 民)
-    6: (1, 2, 3),
-    7: (2, 2, 3),
-    8: (2, 3, 3),
-    9: (2, 4, 3),
-    10: (3, 4, 3),
-    11: (3, 5, 3),
-    12: (4, 5, 3),
-}
-
-if config.override_preset is not None:
-    player_preset |= {i[0]: i[1:] for i in config.override_preset}