nonebot-plugin-werewolf 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

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.1"
+__version__ = "1.0.3"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",

nonebot_plugin_werewolf/constant.py

@@ -44,6 +44,7 @@ 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

nonebot_plugin_werewolf/game.py

@@ -1,13 +1,16 @@
 import asyncio
 import asyncio.timeouts
 import random
-from collections.abc import Callable
 
 from nonebot.adapters import Bot
 from nonebot_plugin_alconna import Target, UniMessage
 
 from .constant import GameState, GameStatus, KillReason, Role, RoleGroup, player_preset
-from .player import Player, PlayerSet
+from .player import Player
+from .player_set import PlayerSet
+
+starting_games: dict[str, dict[str, str]] = {}
+running_games: dict[str, tuple["Game", asyncio.Task[None]]] = {}
 
 
 def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
@@ -15,7 +18,7 @@ def init_players(bot: Bot, game: "Game", players: dict[str, str]) -> PlayerSet:
     if preset is None:
         raise ValueError(
             f"玩家人数不符: "
-            f"应为{min(player_preset)}-{max(player_preset)}人, 传入{len(players)}人"
+            f"应为 {', '.join(map(str, player_preset))} 人, 传入{len(players)}人"
         )
 
     roles: list[Role] = []
@@ -50,20 +53,18 @@ class Game:
     group: Target
     players: PlayerSet
     state: GameState
-    _on_exit: Callable[[], None]
+    killed_players: list[Player]
 
     def __init__(
         self,
         bot: Bot,
         group: Target,
         players: dict[str, str],
-        on_exit: Callable[[], None],
     ) -> None:
         self.bot = bot
         self.group = group
         self.players = init_players(bot, self, players)
-        self.state = GameState()
-        self._on_exit = on_exit
+        self.state = GameState(0)
 
     async def send(self, message: str | UniMessage):
         if isinstance(message, str):
@@ -78,27 +79,49 @@ class Game:
 
     def check_game_status(self) -> GameStatus:
         players = self.players.alive()
-
         w = players.select(RoleGroup.狼人)
-        if not w.size:
-            return GameStatus.Good
-
         p = players.exclude(RoleGroup.狼人)
+
         if w.size >= p.size:
             return GameStatus.Bad
-        if not players.select(Role.平民):
+        if not p.select(Role.平民):
             return GameStatus.Bad
-        if not players.select(RoleGroup.好人).exclude(Role.平民):
+        if not p.exclude(Role.平民):
             return GameStatus.Bad
+        if not w.size:
+            return GameStatus.Good
 
         return GameStatus.Unset
 
+    def show_killed_players(self) -> str:
+        msg = ""
+
+        for player in self.killed_players:
+            if player.kill_info is None:
+                continue
+
+            msg += f"{player.name} 被 " + ", ".join(
+                p.name for p in player.kill_info.killers
+            )
+            match player.kill_info.reason:
+                case KillReason.Kill:
+                    msg += " 刀了"
+                case KillReason.Poison:
+                    msg += " 毒死"
+                case KillReason.Shoot:
+                    msg += " 射杀"
+                case KillReason.Vote:
+                    msg += " 投票放逐"
+            msg += "\n\n"
+
+        return msg.strip()
+
     async def notify_player_role(self) -> None:
         preset = player_preset[len(self.players)]
         await asyncio.gather(
             self.send(
                 self.at_all()
-                .text("\n正在分配职业，请注意查看私聊消息\n")
+                .text("\n\n正在分配职业，请注意查看私聊消息\n")
                 .text(f"当前玩家数: {len(self.players)}\n")
                 .text(f"职业分配: 狼人x{preset[0]}, 神职x{preset[1]}, 平民x{preset[2]}")
             ),
@@ -125,8 +148,10 @@ class Game:
             type_.role.name  # Player
             if isinstance(type_, Player)
             else (
-                type_.name if isinstance(type_, Role) else f"{type_.name}阵营"  # Role
-            )  # RoleGroup
+                type_.name  # Role
+                if isinstance(type_, Role)
+                else f"{type_.name}阵营"  # RoleGroup
+            )
         )
 
         await players.broadcast(f"{text}交互开始，限时 {timeout_secs/60:.2f} 分钟")
@@ -176,9 +201,10 @@ class Game:
         if not players:
             return
 
-        for player in players:
+        for player in players.dead():
             await player.post_kill()
             await self.handle_new_dead(player)
+            self.killed_players.append(player)
 
             (shooter, shoot) = self.state.shoot
             if shooter is not None and shoot is not None:
@@ -189,27 +215,32 @@ class Game:
                     .text("限时1分钟, 发送 “/stop” 结束发言")
                 )
                 await self.wait_stop(shoot, 60)
+                await self.post_kill(shoot)
             self.state.shoot = (None, None)
 
     async def run_vote(self) -> None:
         # 统计投票结果
-        vote_result: dict[Player | None, int] = {}
+        players = self.players.alive()
+
+        # 被票玩家: [投票玩家]
+        vote_result: dict[Player, list[Player]] = await players.vote(60)
+        # 票数: [被票玩家]
         vote_reversed: dict[int, list[Player]] = {}
-        for p in await self.players.alive().vote(60):
-            vote_result[p] = vote_result.get(p, 0) + 1
+        # 收集到的总票数
+        total_votes = sum(map(len, vote_result.values()))
 
         # 投票结果公示
         msg = UniMessage.text("投票结果:\n")
         for p, v in sorted(vote_result.items(), key=lambda x: x[1], reverse=True):
             if p is not None:
                 msg.at(p.user_id).text(f": {v} 票\n")
-                vote_reversed[v] = [*vote_reversed.get(v, []), p]
-        if v := vote_result.get(None, 0):
+                vote_reversed[len(v)] = [*vote_reversed.get(len(v), []), p]
+        if v := (len(players) - total_votes):
             msg.text(f"弃票: {v} 票\n")
         await self.send(msg)
 
         # 全员弃票  # 不是哥们？
-        if not vote_reversed:
+        if total_votes == 0:
             await self.send("没有人被票出")
             return
 
@@ -224,7 +255,7 @@ class Game:
 
         # 仅有一名玩家票数最高
         voted = vs.pop()
-        if not await voted.kill(KillReason.Vote):
+        if not await voted.kill(KillReason.Vote, *vote_result[voted]):
             # 投票放逐失败 (例: 白痴)
             return
 
@@ -267,7 +298,7 @@ class Game:
 
         while self.check_game_status() == GameStatus.Unset:
             # 重置游戏状态，进入下一夜
-            self.state = GameState()
+            self.state = GameState(day_count)
             players = self.players.alive()
             await self.send("天黑请闭眼...")
 
@@ -290,19 +321,19 @@ class Game:
             if killed is not None:
                 # 除非守卫保护或女巫使用解药，否则狼人正常击杀玩家
                 if not ((killed is protected) or (antidote and potioned is killed)):
-                    await killed.kill(KillReason.Kill)
+                    await killed.kill(KillReason.Kill, *players.select(RoleGroup.狼人))
             # 如果女巫使用毒药且守卫未保护，杀死该玩家
             if poison and (potioned is not None) and (potioned is not protected):
-                await potioned.kill(KillReason.Poison)
+                await potioned.kill(KillReason.Poison, *players.select(Role.女巫))
 
             day_count += 1
-            msg = UniMessage.text(f"【第{day_count}天】天亮了...\n")
+            msg = UniMessage.text(f"『第{day_count}天』天亮了...\n")
             # 没有玩家死亡，平安夜
             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)
@@ -336,8 +367,9 @@ class Game:
         # 游戏结束
         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.name, p.user_id)):
+        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)
-        self._on_exit()
+        running_games.pop(self.group.id, None)

nonebot_plugin_werewolf/matchers.py

@@ -1,47 +1,26 @@
 import asyncio
 import asyncio.timeouts
-import contextlib
 from typing import Annotated
 
-import nonebot_plugin_waiter as waiter
-from nonebot import on_command, on_message, on_type
+from nonebot import on_command, on_message
 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 .config import config
-from .game import Game, player_preset
-from .utils import InputStore
+from .game import Game, running_games, starting_games
+from .ob11_ext import ob11_ext_enabled
+from .utils import InputStore, is_group, prepare_game, rule_in_game, rule_not_in_game
 
-starting_games: dict[str, dict[str, str]] = {}
-running_games: dict[str, tuple[Game, asyncio.Task[None]]] = {}
-
-
-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:
-        return any(user_id == player.user_id for player in game.players)
-    return False
-
-
-async def rule_in_game(event: Event, target: MsgTarget) -> bool:
-    if not running_games:
-        return False
-    if target.private:
-        return user_in_game(target.id, None)
-    elif target.id in running_games:
-        return user_in_game(event.get_user_id(), target.id)
-    return False
-
-
-async def rule_not_in_game(event: Event, target: MsgTarget) -> bool:
-    return not await rule_in_game(event, target)
+in_game_message = on_message(rule=rule_in_game)
+start_game = on_command(
+    "werewolf",
+    rule=to_me() & is_group & rule_not_in_game,
+    aliases={"狼人杀"},
+)
 
 
-@on_message(rule=rule_in_game).handle()
+@in_game_message.handle()
 async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
     if target.private:
         InputStore.put(target.id, None, msg)
@@ -49,87 +28,16 @@ async def handle_input(event: Event, target: MsgTarget, msg: UniMsg) -> None:
         InputStore.put(event.get_user_id(), target.id, msg)
 
 
-async def is_group(target: MsgTarget) -> bool:
-    return not target.private
-
-
-async def prepare_game(
-    wait: waiter.Waiter[tuple[str, str, str]],
-    players: dict[str, str],
-    group_id: str,
-    admin_id: str,
-):
-    async for user, name, text in wait(default=(None, "", "")):
-        if user is None:
-            continue
-        msg = UniMessage.at(user)
-
-        match (text, user == admin_id):
-            case ("开始游戏", True):
-                if len(players) < min(player_preset):
-                    await (
-                        msg.text(f"游戏至少需要 {min(player_preset)} 人, ")
-                        .text(f"当前已有 {len(players)} 人")
-                        .send()
-                    )
-                elif len(players) > max(player_preset):
-                    await (
-                        msg.text(f"游戏最多需要 {max(player_preset)} 人, ")
-                        .text(f"当前已有 {len(players)} 人")
-                        .send()
-                    )
-                else:
-                    await msg.text("游戏即将开始...").send()
-                    return
-
-            case ("开始游戏", False):
-                await msg.text("只有游戏发起者可以开始游戏").send()
-
-            case ("结束游戏", True):
-                del starting_games[group_id]
-                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
-                    await msg.text("成功加入游戏").send()
-                else:
-                    await msg.text("你已经加入游戏了").send()
-
-            case ("退出游戏", True):
-                await msg.text("游戏发起者无法退出游戏").send()
-
-            case ("退出游戏", False):
-                if user in players:
-                    del players[user]
-                    await msg.text("成功退出游戏").send()
-                else:
-                    await msg.text("你还没有加入游戏").send()
-
-            case ("当前玩家", _):
-                msg.text("\n当前玩家:\n")
-                for name in players.values():
-                    msg.text(f"\n{name}")
-                await msg.send()
-
-
-@on_command(
-    "werewolf",
-    rule=to_me() & is_group & rule_not_in_game,
-    aliases={"狼人杀"},
-).handle()
+@start_game.handle()
 async def handle_start(
     bot: Bot,
     event: Event,
     target: MsgTarget,
     admin_info: Annotated[UserInfo, EventUserInfo()],
 ) -> None:
+    if target.id in running_games:
+        await UniMessage.text("当前群聊内有正在进行的游戏，无法创建游戏").finish()
+
     admin_id = event.get_user_id()
     msg = (
         UniMessage.at(admin_id)
@@ -139,102 +47,20 @@ async def handle_start(
         .text("游戏发起者 @我 发送 “结束游戏” 可结束当前游戏\n")
         .text("玩家均加入后，游戏发起者请 @我 发送 “开始游戏”\n")
     )
-    if (
-        config.enable_poke
-        and OneBotV11Available
-        and bot.adapter.get_name() == "OneBot V11"
-    ):
+    if ob11_ext_enabled():
         msg.text("\n可使用戳一戳代替游戏交互中的 “/stop” 命令")
     await msg.text("\n\n游戏准备阶段限时5分钟，超时将自动结束").send()
 
-    async def rule(target_: MsgTarget) -> bool:
-        return not target_.private and target_.id == target.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,
-    ):
-        return (
-            event.get_user_id(),
-            info.user_name if info is not None else event.get_user_id(),
-            msg.extract_plain_text().strip(),
-        )
-
-    starting_games[target.id] = players = {admin_id: admin_info.user_name}
+    players = starting_games[target.id] = {admin_id: admin_info.user_name}
 
     try:
         async with asyncio.timeouts.timeout(5 * 60):
-            await prepare_game(wait, players, target.id, admin_id)
+            await prepare_game(event, players)
     except TimeoutError:
-        del starting_games[target.id]
         await UniMessage.text("游戏准备超时，已自动结束").finish()
+    finally:
+        del starting_games[target.id]
 
-    game = Game(
-        bot=bot,
-        group=target,
-        players=players,
-        on_exit=lambda: running_games.pop(target.id, None) and None,
-    )
+    game = Game(bot=bot, group=target, players=players)
     task = asyncio.create_task(game.run())
     running_games[target.id] = (game, task)
-    del starting_games[target.id]
-
-
-# OneBot V11 扩展
-OneBotV11Available = False
-with contextlib.suppress(ImportError, RuntimeError):
-    if not config.enable_poke:
-        raise RuntimeError
-
-    from nonebot.adapters.onebot.v11 import Bot as V11Bot
-    from nonebot.adapters.onebot.v11 import MessageSegment
-    from nonebot.adapters.onebot.v11.event import PokeNotifyEvent
-
-    OneBotV11Available = True
-
-    # 游戏内戳一戳等效 "/stop"
-    async def _rule_poke_1(event: PokeNotifyEvent) -> bool:
-        user_id = str(event.user_id)
-        group_id = str(event.group_id) if event.group_id is not None else None
-        return (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 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: V11Bot, 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("nickname") or user_id
-            await bot.send(event, MessageSegment.at(user_id) + "成功加入游戏")

nonebot_plugin_werewolf/ob11_ext.py

@@ -0,0 +1,72 @@
+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("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)

nonebot_plugin_werewolf/player.py

@@ -1,7 +1,7 @@
 import asyncio
 import asyncio.timeouts
-import contextlib
-from typing import TYPE_CHECKING, ClassVar, Literal
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar, TypeVar
 from typing_extensions import override
 
 from nonebot.adapters import Bot
@@ -12,15 +12,24 @@ from .utils import InputStore, check_index
 
 if TYPE_CHECKING:
     from .game import Game
+    from .player_set import PlayerSet
 
-PlayerClass: dict[Role, type["Player"]] = {}
 
+P = TypeVar("P", bound=type["Player"])
+PLAYER_CLASS: dict[Role, type["Player"]] = {}
 
-def register_role(cls: type["Player"]) -> type["Player"]:
-    PlayerClass[cls.role] = cls
+
+def register_role(cls: P) -> P:
+    PLAYER_CLASS[cls.role] = cls
     return cls
 
 
+@dataclass
+class KillInfo:
+    reason: KillReason
+    killers: "PlayerSet"
+
+
 class Player:
     role: ClassVar[Role]
     role_group: ClassVar[RoleGroup]
@@ -31,9 +40,15 @@ class Player:
     name: str
     alive: bool = True
     killed: bool = False
-    kill_reason: KillReason | None = None
+    kill_info: KillInfo | None = None
     selected: "Player | None" = None
 
+    def __init__(self, bot: Bot, game: "Game", user: Target, name: str) -> None:
+        self.bot = bot
+        self.game = game
+        self.user = user
+        self.name = name
+
     @classmethod
     def new(
         cls,
@@ -43,20 +58,18 @@ class Player:
         user: Target,
         name: str,
     ) -> "Player":
-        if role not in PlayerClass:
+        if role not in PLAYER_CLASS:
             raise ValueError(f"Unexpected role: {role!r}")
 
-        player = PlayerClass[role]()
-        player.bot = bot
-        player.game = game
-        player.user = user
-        player.name = name
-        player.game = game
-        return player
+        return PLAYER_CLASS[role](bot, game, user, name)
 
     def __repr__(self) -> str:
         return f"<{self.role.name}: user={self.user} alive={self.alive}>"
 
+    @property
+    def user_id(self) -> str:
+        return self.user.id
+
     async def send(self, message: str | UniMessage) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
@@ -68,21 +81,28 @@ class Player:
             await self.send(prompt)
         return await InputStore.fetch(self.user.id)
 
+    async def receive_text(self) -> str:
+        return (await self.receive()).extract_plain_text()
+
     async def interact(self) -> None:
         return
 
     async def notify_role(self) -> None:
         await self.send(f"你的身份: {self.role.name}")
 
-    async def kill(self, reason: KillReason) -> bool:
+    async def kill(
+        self,
+        reason: KillReason,
+        *killers: "Player",
+    ) -> bool:
         self.alive = False
-        self.kill_reason = reason
+        self.kill_info = KillInfo(reason, PlayerSet(killers))
         return True
 
     async def post_kill(self) -> None:
         self.killed = True
 
-    async def vote(self, players: "PlayerSet") -> "Player | None":
+    async def vote(self, players: "PlayerSet") -> "tuple[Player, Player] | None":
         await self.send(
             f"请选择需要投票的玩家:\n{players.show()}"
             "\n\n发送编号选择玩家\n发送 “/stop” 弃票"
@@ -100,17 +120,13 @@ class Player:
 
         player = players[selected]
         await self.send(f"投票的玩家: {player.name}")
-        return player
-
-    @property
-    def user_id(self) -> str:
-        return self.user.id
+        return self, player
 
 
 class CanShoot(Player):
     @override
     async def post_kill(self) -> None:
-        if self.kill_reason == KillReason.Poison:
+        if self.kill_info and self.kill_info.reason == KillReason.Poison:
             await self.send("你昨晚被女巫毒杀，无法使用技能")
             return await super().post_kill()
 
@@ -122,18 +138,16 @@ class CanShoot(Player):
 
         self.game.state.shoot = (None, None)
         shoot = await self.shoot()
-        if shoot is not None:
-            self.game.state.shoot = (self, shoot)
 
         if shoot is not None:
+            self.game.state.shoot = (self, shoot)
             await self.send(
                 UniMessage.text(f"{self.role.name} ")
                 .at(self.user_id)
                 .text(" 射杀了玩家 ")
                 .at(shoot.user_id)
             )
-            await shoot.kill(KillReason.Shoot)
-            await shoot.post_kill()
+            await shoot.kill(KillReason.Shoot, self)
         else:
             await self.send(f"{self.role.name}选择了取消技能")
         return await super().post_kill()
@@ -148,7 +162,7 @@ class CanShoot(Player):
         )
 
         while True:
-            text = (await self.receive()).extract_plain_text()
+            text = await self.receive_text()
             if text == "/stop":
                 await self.send("已取消技能")
                 return
@@ -242,7 +256,7 @@ class 预言家(Player):
         )
 
         while True:
-            text = (await self.receive()).extract_plain_text()
+            text = await self.receive_text()
             index = check_index(text, len(players))
             if index is not None:
                 selected = index - 1
@@ -262,7 +276,10 @@ class 女巫(Player):
     poison: int = 1
 
     def set_state(
-        self, *, antidote: Player | None = None, posion: Player | None = None
+        self,
+        *,
+        antidote: Player | None = None,
+        posion: Player | None = None,
     ):
         if antidote is not None:
             self.antidote = 0
@@ -273,33 +290,29 @@ class 女巫(Player):
             self.selected = posion
             self.game.state.potion = (posion, (False, True))
         else:
+            self.selected = None
             self.game.state.potion = (None, (False, False))
 
-    @staticmethod
-    def potion_str(potion: Literal[1, 2]) -> str:
-        return "解药" if potion == 1 else "毒药"
-
     async def handle_killed(self) -> bool:
-        if self.game.state.killed is not None:
-            await self.send(f"今晚 {self.game.state.killed.name} 被刀了")
+        msg = UniMessage()
+        if (killed := self.game.state.killed) is not None:
+            msg.text(f"今晚 {killed} 被刀了\n\n")
         else:
             await self.send("今晚没有人被刀")
             return False
 
         if not self.antidote:
-            await self.send("你已经用过解药了")
+            await self.send(msg.text("你已经用过解药了"))
             return False
 
-        await self.send("使用解药请发送 “1”\n不使用解药请发送 “/stop”")
+        await self.send(msg.text("使用解药请发送 “1”\n不使用解药请发送 “/stop”"))
 
         while True:
-            text = (await self.receive()).extract_plain_text()
+            text = await self.receive_text()
             if text == "1":
                 self.antidote = 0
-                self.set_state(antidote=self.game.state.killed)
-                await self.send(
-                    f"你对 {self.game.state.killed.name} 使用了解药，回合结束"
-                )
+                self.set_state(antidote=killed)
+                await self.send(f"你对 {killed.name} 使用了解药，回合结束")
                 return True
             elif text == "/stop":
                 return False
@@ -326,7 +339,7 @@ class 女巫(Player):
         )
 
         while True:
-            text = (await self.receive()).extract_plain_text().strip()
+            text = await self.receive_text()
             index = check_index(text, len(players))
             if index is not None:
                 selected = index - 1
@@ -365,7 +378,7 @@ class 守卫(Player):
         )
 
         while True:
-            text = (await self.receive()).extract_plain_text()
+            text = await self.receive_text()
             if text == "/stop":
                 await self.send("你选择了取消，回合结束")
                 return
@@ -389,7 +402,11 @@ class 白痴(Player):
     voted: bool = False
 
     @override
-    async def kill(self, reason: KillReason) -> bool:
+    async def kill(
+        self,
+        reason: KillReason,
+        *killers: Player,
+    ) -> bool:
         if reason == KillReason.Vote and not self.voted:
             self.voted = True
             await self.game.send(
@@ -398,10 +415,10 @@ class 白痴(Player):
                 .text("免疫本次投票放逐，且接下来无法参与投票")
             )
             return False
-        return await super().kill(reason)
+        return await super().kill(reason, *killers)
 
     @override
-    async def vote(self, players: "PlayerSet") -> "Player | None":
+    async def vote(self, players: "PlayerSet") -> "tuple[Player, Player] | None":
         if self.voted:
             await self.send("你已经发动过白痴身份的技能，无法参与本次投票")
             return None
@@ -412,83 +429,3 @@ class 白痴(Player):
 class 平民(Player):
     role: ClassVar[Role] = Role.平民
     role_group: ClassVar[RoleGroup] = RoleGroup.好人
-
-
-class PlayerSet(set[Player]):
-    @property
-    def size(self) -> int:
-        return len(self)
-
-    def alive(self) -> "PlayerSet":
-        return PlayerSet(p for p in self if p.alive)
-
-    def dead(self) -> "PlayerSet":
-        return PlayerSet(p for p in self if not p.alive)
-
-    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":
-        return self.include(*types)
-
-    def exclude(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
-        return PlayerSet(
-            player
-            for player in self
-            if (
-                player not in types
-                and player.role not in types
-                and player.role_group not in types
-            )
-        )
-
-    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]:
-        return sorted(self, key=lambda p: p.user_id)
-
-    async def interact(self, timeout_secs: float = 60) -> None:
-        async with asyncio.timeouts.timeout(timeout_secs):
-            await asyncio.gather(*[p.interact() for p in self.alive()])
-
-    async def vote(self, timeout_secs: float = 60) -> list[Player]:
-        async def vote(player: Player) -> "Player | None":
-            try:
-                async with asyncio.timeouts.timeout(timeout_secs):
-                    return await player.vote(self)
-            except TimeoutError:
-                await player.send("投票超时，将自动弃票")
-
-        return [
-            p
-            for p in await asyncio.gather(*[vote(p) for p in self.alive()])
-            if p is not None
-        ]
-
-    async def post_kill(self) -> None:
-        await asyncio.gather(*[p.post_kill() for p in self])
-
-    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))
-
-    def __getitem__(self, __index: int) -> Player:
-        return self.sorted()[__index]

nonebot_plugin_werewolf/player_set.py

@@ -0,0 +1,87 @@
+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]):
+    @property
+    def size(self) -> int:
+        return len(self)
+
+    def alive(self) -> "PlayerSet":
+        return PlayerSet(p for p in self if p.alive)
+
+    def dead(self) -> "PlayerSet":
+        return PlayerSet(p for p in self if not p.alive)
+
+    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":
+        return self.include(*types)
+
+    def exclude(self, *types: Player | Role | RoleGroup) -> "PlayerSet":
+        return PlayerSet(
+            player
+            for player in self
+            if (
+                player not in types
+                and player.role not in types
+                and player.role_group not in types
+            )
+        )
+
+    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]:
+        return sorted(self, key=lambda p: p.user_id)
+
+    async def interact(self, timeout_secs: float = 60) -> None:
+        async with asyncio.timeouts.timeout(timeout_secs):
+            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":
+            try:
+                async with asyncio.timeouts.timeout(timeout_secs):
+                    return await player.vote(self)
+            except TimeoutError:
+                await player.send("投票超时，将视为弃票")
+
+        result: dict[Player, list[Player]] = {}
+        for item in await asyncio.gather(*[vote(p) for p in self.alive()]):
+            if item is not None:
+                player, voted = item
+                result[voted] = [*result.get(voted, []), player]
+        return result
+
+    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))
+
+    def __getitem__(self, __index: int) -> Player:
+        return self.sorted()[__index]

nonebot_plugin_werewolf/utils.py

@@ -1,8 +1,15 @@
 import asyncio
+import asyncio.timeouts
 from collections import defaultdict
-from typing import ClassVar
+from typing import Annotated, Any, ClassVar
 
-from nonebot_plugin_alconna import UniMessage
+import nonebot_plugin_waiter as waiter
+from nonebot.adapters import Event
+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
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -18,7 +25,7 @@ class InputStore:
     futures: ClassVar[dict[str, asyncio.Future[UniMessage]]] = {}
 
     @classmethod
-    async def fetch(cls, user_id: str, group_id: str | None = None):
+    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()
@@ -28,7 +35,154 @@ class InputStore:
                 del cls.futures[key]
 
     @classmethod
-    def put(cls, user_id: str, group_id: str | None, msg: UniMessage):
+    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 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:
+        return any(user_id == player.user_id for player in game.players)
+    return False
+
+
+async def rule_in_game(event: Event, target: MsgTarget) -> bool:
+    if not running_games:
+        return False
+    if target.private:
+        return user_in_game(target.id, None)
+    elif target.id in running_games:
+        return user_in_game(event.get_user_id(), target.id)
+    return False
+
+
+async def rule_not_in_game(event: Event, target: MsgTarget) -> bool:
+    return not await rule_in_game(event, target)
+
+
+async def is_group(target: MsgTarget) -> bool:
+    return not target.private
+
+
+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_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, name, text))
+
+
+async def _prepare_game_handle(
+    queue: asyncio.Queue[tuple[str, str, str]],
+    players: dict[str, str],
+    admin_id: str,
+) -> None:
+    while True:
+        user, name, text = await queue.get()
+        msg = UniMessage.at(user)
+
+        match (text, user == admin_id):
+            case ("开始游戏", True):
+                player_num = len(players)
+                if player_num < min(player_preset):
+                    await (
+                        msg.text(f"游戏至少需要 {min(player_preset)} 人, ")
+                        .text(f"当前已有 {player_num} 人")
+                        .send()
+                    )
+                elif player_num > max(player_preset):
+                    await (
+                        msg.text(f"游戏最多需要 {max(player_preset)} 人, ")
+                        .text(f"当前已有 {player_num} 人")
+                        .send()
+                    )
+                elif player_num not in player_preset:
+                    await (
+                        msg.text(f"不存在总人数为 {player_num} 的预设, ")
+                        .text("无法开始游戏")
+                        .send()
+                    )
+                else:
+                    await msg.text("游戏即将开始...").send()
+                    return
+
+            case ("开始游戏", False):
+                await msg.text("只有游戏发起者可以开始游戏").send()
+
+            case ("结束游戏", True):
+                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
+                    await msg.text("成功加入游戏").send()
+                else:
+                    await msg.text("你已经加入游戏了").send()
+
+            case ("退出游戏", True):
+                await msg.text("游戏发起者无法退出游戏").send()
+
+            case ("退出游戏", False):
+                if user in players:
+                    del players[user]
+                    await msg.text("成功退出游戏").send()
+                else:
+                    await msg.text("你还没有加入游戏").send()
+
+            case ("当前玩家", _):
+                msg.text("\n当前玩家:\n")
+                for name in players.values():
+                    msg.text(f"\n{name}")
+                await msg.send()
+
+
+async def prepare_game(event: Event, players: dict[str, str]) -> None:
+    queue = asyncio.Queue()
+    task_receive = asyncio.create_task(
+        _prepare_game_receive(
+            queue,
+            event,
+            UniMessage.get_target().id,
+        )
+    )
+
+    try:
+        await _prepare_game_handle(
+            queue,
+            players,
+            event.get_user_id(),
+        )
+    finally:
+        task_receive.cancel()

{nonebot_plugin_werewolf-1.0.1.dist-info → nonebot_plugin_werewolf-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-werewolf
-Version: 1.0.1
+Version: 1.0.3
 Summary: Default template for PDM package
 Author-Email: wyf7685 <wyf7685@163.com>
 License: MIT
@@ -12,9 +12,9 @@ Requires-Dist: nonebot-plugin-waiter>=0.7.1
 Description-Content-Type: text/markdown
 
 <div align="center">
-  <a href="https://v2.nonebot.dev/store"><img src="https://github.com/A-kirami/nonebot-plugin-template/blob/resources/nbp_logo.png" width="180" height="180" alt="NoneBotPluginLogo"></a>
-  <br>
-  <p><img src="https://github.com/A-kirami/nonebot-plugin-template/blob/resources/NoneBotPlugin.svg" width="240" alt="NoneBotPluginText"></p>
+  <a href="https://v2.nonebot.dev/store">
+    <img src="https://github.com/wyf7685/wyf7685/blob/main/assets/NoneBotPlugin.svg" width="300" alt="logo">
+  </a>
 </div>
 
 <div align="center">
@@ -24,7 +24,7 @@ Description-Content-Type: text/markdown
 _✨ 简单的狼人杀插件 ✨_
 
 [![license](https://img.shields.io/github/license/wyf7685/nonebot-plugin-werewolf.svg)](./LICENSE)
-[![pypi](https://img.shields.io/pypi/v/nonebot-plugin-werewolf?logo=python&logoColor=edb641)](https://pypi.python.org/pypi/nonebot-plugin-exe-code)
+[![pypi](https://img.shields.io/pypi/v/nonebot-plugin-werewolf?logo=python&logoColor=edb641)](https://pypi.python.org/pypi/nonebot-plugin-werewolf)
 [![python](https://img.shields.io/badge/python-3.10+-blue?logo=python&logoColor=edb641)](https://www.python.org/)
 
 [![pdm-managed](https://img.shields.io/endpoint?url=https%3A%2F%2Fcdn.jsdelivr.net%2Fgh%2Fpdm-project%2F.github%2Fbadge.json)](https://pdm-project.org)
@@ -143,7 +143,9 @@ _✨ 简单的狼人杀插件 ✨_
 职业预设可以通过配置项 `werewolf__override_preset` 修改
 
 <details>
-    <summary>配置项 `werewolf__override_preset` 示例</summary>
+<summary>示例</summary>
+
+配置项 `werewolf__override_preset`
 
 ```env
 werewolf__override_preset='
@@ -169,6 +171,10 @@ werewolf__override_preset='
 <details>
     <summary>更新日志</summary>
 
+- 2024.09.01 v1.0.3
+
+  - 优化玩家交互体验
+
 - 2024.08.31 v1.0.1
 
   - 允许通过配置项修改职业预设

nonebot_plugin_werewolf-1.0.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+nonebot_plugin_werewolf-1.0.3.dist-info/METADATA,sha256=0co-Cgj6W-98W7ZyDOR8u7phucnJUIstiq0vtwQbLf8,5815
+nonebot_plugin_werewolf-1.0.3.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
+nonebot_plugin_werewolf-1.0.3.dist-info/licenses/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
+nonebot_plugin_werewolf/__init__.py,sha256=CajWxyaRax2kotzc4w5IcJbdmc07ysCbSNGKve5wIvw,734
+nonebot_plugin_werewolf/config.py,sha256=3O63P1pjvJEwgOwxApAHbKQzvCR1zoG5UjTClZ_OJts,315
+nonebot_plugin_werewolf/constant.py,sha256=kMn5DHXdYuOXeGpJjnG_WX9AD-OytLKXSjrww0T5OYg,1234
+nonebot_plugin_werewolf/game.py,sha256=PI6j-T70Logax87fpmf8HBS3LihF7J40nespvoNFyus,13449
+nonebot_plugin_werewolf/matchers.py,sha256=o0LdO7AOUjTPcNaNTHbmw5d0CcnMc7mX8oko0JT8Np4,2351
+nonebot_plugin_werewolf/ob11_ext.py,sha256=I6bPCv5SgAStTJuvBl5F7wqgiksWeFkb4R7n06jXprA,2399
+nonebot_plugin_werewolf/player.py,sha256=z_yVjqfDOxnQlDtDxSbdmvEapIQikkho2hCjb46zqKY,13799
+nonebot_plugin_werewolf/player_set.py,sha256=ptNZb13H8DgcjQ9tm3uT2ISXnnWioQG1W4R506HlaMU,3057
+nonebot_plugin_werewolf/utils.py,sha256=KfCBdiy5pxkOf1k1EOg8NLe5-viiCCm72vPP6lobudQ,6127
+nonebot_plugin_werewolf-1.0.3.dist-info/RECORD,,

nonebot_plugin_werewolf-1.0.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-nonebot_plugin_werewolf-1.0.1.dist-info/METADATA,sha256=tQZAz__0XgsrQTiovdGfV-glhlS6TESEMfwhxvYF1sc,5944
-nonebot_plugin_werewolf-1.0.1.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
-nonebot_plugin_werewolf-1.0.1.dist-info/licenses/LICENSE,sha256=B_WbEqjGr6GYVNfEJPY31T1Opik7OtgOkhRs4Ig3e2M,1064
-nonebot_plugin_werewolf/__init__.py,sha256=dGaXi6VOQUYCjbe2yfwTLWbHvRRRq11xUeDCgPqnjPE,734
-nonebot_plugin_werewolf/config.py,sha256=3O63P1pjvJEwgOwxApAHbKQzvCR1zoG5UjTClZ_OJts,315
-nonebot_plugin_werewolf/constant.py,sha256=Q1MKe5hSzg88jL8LQ5SvC2Pr6QwJ9PHrrj1qpOSYCZg,1221
-nonebot_plugin_werewolf/game.py,sha256=KD57WxN16VcLJbflxxPw4EXGfjEaXvvBAB8DiK4RMwY,12322
-nonebot_plugin_werewolf/matchers.py,sha256=8bGM1gESjL9JMFQRv7611YGM0TZFfg0hQjlOrzS3zRg,8336
-nonebot_plugin_werewolf/player.py,sha256=ckviPuXv9JvgcwzD9xcHSVBj7JdRtqGge7WFpynonVY,16355
-nonebot_plugin_werewolf/utils.py,sha256=mzFVuzkayfY-8wXnFASPqo2dtJkNOhycfoceIyRGuZg,1023
-nonebot_plugin_werewolf-1.0.1.dist-info/RECORD,,