nonebot-plugin-werewolf 1.0.6__py3-none-any.whl → 1.1.0__py3-none-any.whl

nonebot_plugin_werewolf/player.py

@@ -4,15 +4,20 @@ import asyncio
 import asyncio.timeouts
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, ClassVar, TypeVar, final
-from typing_extensions import override
 
-from nonebot.adapters import Bot
+from nonebot.log import logger
 from nonebot_plugin_alconna.uniseg import Receipt, Target, UniMessage
+from typing_extensions import override
 
-from .constant import KillReason, Role, RoleGroup, role_name_conv,role_group_name_conv
+from .constant import GameStatus, KillReason, Role, RoleGroup, role_name_conv
+from .exception import GameFinishedError
 from .utils import InputStore, check_index
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from nonebot.adapters import Bot
+
     from .game import Game
     from .player_set import PlayerSet
 
@@ -21,9 +26,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, /) -> Callable[[P], P]:
+    def decorator(cls: P, /) -> P:
+        cls.role = role
+        cls.role_group = role_group
+        PLAYER_CLASS[role] = cls
+        return cls
+
+    return decorator
 
 
 @dataclass
@@ -41,7 +51,7 @@ class Player:
     user: Target
     name: str
     alive: bool = True
-    killed: bool = False
+    killed: asyncio.Event
     kill_info: KillInfo | None = None
     selected: Player | None = None
 
@@ -51,6 +61,7 @@ class Player:
         self.game = game
         self.user = user
         self.name = name
+        self.killed = asyncio.Event()
 
     @final
     @classmethod
@@ -68,7 +79,7 @@ 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.name!r} alive={self.alive}>"
 
     @property
     def user_id(self) -> str:
@@ -78,18 +89,32 @@ class Player:
     def role_name(self) -> str:
         return role_name_conv[self.role]
 
+    @final
+    def _log(self, text: str) -> None:
+        text = text.replace("\n", "\\n")
+        logger.opt(colors=True).info(
+            f"<b><e>{self.game.group.id}</e></b> | "
+            f"[<b><m>{self.role_name}</m></b>] "
+            f"<y>{self.name}</y>(<e>{self.user_id}</e>) | "
+            f"{text}",
+        )
+
     @final
     async def send(self, message: str | UniMessage) -> Receipt:
         if isinstance(message, str):
             message = UniMessage.text(message)
 
+        self._log(f"<g>Send</g> | {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)
+
+        result = await InputStore.fetch(self.user.id)
+        self._log(f"<y>Recv</y> | {result}")
+        return result
 
     @final
     async def receive_text(self) -> str:
@@ -101,11 +126,7 @@ class Player:
     async def notify_role(self) -> None:
         await self.send(f"你的身份: {self.role_name}")
 
-    async def kill(
-        self,
-        reason: KillReason,
-        *killers: Player,
-    ) -> bool:
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
         from .player_set import PlayerSet
 
         self.alive = False
@@ -113,7 +134,7 @@ class Player:
         return True
 
     async def post_kill(self) -> None:
-        self.killed = True
+        self.killed.set()
 
     async def vote(self, players: PlayerSet) -> tuple[Player, Player] | None:
         await self.send(
@@ -179,7 +200,7 @@ class CanShoot(Player):
             text = await self.receive_text()
             if text == "/stop":
                 await self.send("已取消技能")
-                return
+                return None
             index = check_index(text, len(players))
             if index is not None:
                 selected = index - 1
@@ -190,11 +211,8 @@ class CanShoot(Player):
         return players[selected]
 
 
-@register_role
-class 狼人(Player):
-    role: ClassVar[Role] = Role.Werewolf
-    role_group: ClassVar[RoleGroup] = RoleGroup.Werewolf
-
+@register_role(Role.Werewolf, RoleGroup.Werewolf)
+class Werewolf(Player):
     @override
     async def notify_role(self) -> None:
         await super().notify_role()
@@ -211,7 +229,7 @@ class 狼人(Player):
         partners = players.select(RoleGroup.Werewolf).exclude(self)
 
         # 避免阻塞
-        def broadcast(msg: str | UniMessage):
+        def broadcast(msg: str | UniMessage) -> asyncio.Task[None]:
             return asyncio.create_task(partners.broadcast(msg))
 
         msg = UniMessage()
@@ -232,8 +250,8 @@ class 狼人(Player):
         selected = None
         finished = False
         while selected is None or not finished:
-            input = await self.receive()
-            text = input.extract_plain_text()
+            input_msg = await self.receive()
+            text = input_msg.extract_plain_text()
             index = check_index(text, len(players))
             if index is not None:
                 selected = index - 1
@@ -247,22 +265,21 @@ class 狼人(Player):
                     broadcast(f"队友 {self.name} 结束当前回合")
                 else:
                     await self.send("当前未选择玩家，无法结束回合")
-            broadcast(UniMessage.text(f"队友 {self.name}:\n") + input)
+            broadcast(UniMessage.text(f"队友 {self.name}:\n") + input_msg)
 
         self.selected = players[selected]
 
 
-@register_role
-class 狼王(CanShoot, 狼人):
-    role: ClassVar[Role] = Role.WolfKing
-    role_group: ClassVar[RoleGroup] = RoleGroup.Werewolf
-
+@register_role(Role.WolfKing, RoleGroup.Werewolf)
+class WolfKing(CanShoot, Werewolf):
+    @override
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send("作为狼王，你可以在死后射杀一名玩家")
 
-@register_role
-class 预言家(Player):
-    role: ClassVar[Role] = Role.Prophet
-    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
 
+@register_role(Role.Prophet, RoleGroup.GoodGuy)
+class Prophet(Player):
     @override
     async def interact(self) -> None:
         players = self.game.players.alive().exclude(self)
@@ -281,14 +298,12 @@ class 预言家(Player):
             await self.send("输入错误，请发送编号选择玩家")
 
         player = players[selected]
-        result = role_group_name_conv[player.role_group]
+        result = "狼人" if player.role_group == RoleGroup.Werewolf else "好人"
         await self.send(f"玩家 {player.name} 的阵营是『{result}』")
 
 
-@register_role
-class 女巫(Player):
-    role: ClassVar[Role] = Role.Witch
-    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
+@register_role(Role.Witch, RoleGroup.GoodGuy)
+class Witch(Player):
     antidote: int = 1
     poison: int = 1
 
@@ -297,7 +312,7 @@ class 女巫(Player):
         *,
         antidote: Player | None = None,
         posion: Player | None = None,
-    ):
+    ) -> None:
         if antidote is not None:
             self.antidote = 0
             self.selected = antidote
@@ -331,10 +346,9 @@ class 女巫(Player):
                 self.set_state(antidote=killed)
                 await self.send(f"你对 {killed.name} 使用了解药，回合结束")
                 return True
-            elif text == "/stop":
+            if text == "/stop":
                 return False
-            else:
-                await self.send("输入错误: 请输入 “1” 或 “/stop”")
+            await self.send("输入错误: 请输入 “1” 或 “/stop”")
 
     @override
     async def interact(self) -> None:
@@ -361,12 +375,11 @@ class 女巫(Player):
             if index is not None:
                 selected = index - 1
                 break
-            elif text == "/stop":
+            if text == "/stop":
                 await self.send("你选择不使用毒药，回合结束")
                 self.set_state()
                 return
-            else:
-                await self.send("输入错误: 请发送玩家编号或 “/stop”")
+            await self.send("输入错误: 请发送玩家编号或 “/stop”")
 
         self.poison = 0
         self.selected = player = players[selected]
@@ -374,22 +387,19 @@ class 女巫(Player):
         await self.send(f"当前回合选择对玩家 {player.name} 使用毒药\n回合结束")
 
 
-@register_role
-class 猎人(CanShoot, Player):
-    role: ClassVar[Role] = Role.Hunter
-    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
+@register_role(Role.Hunter, RoleGroup.GoodGuy)
+class Hunter(CanShoot, Player):
+    pass
 
 
-@register_role
-class 守卫(Player):
-    role: ClassVar[Role] = Role.Guard
-    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
-
+@register_role(Role.Guard, RoleGroup.GoodGuy)
+class Guard(Player):
     @override
     async def interact(self) -> None:
-        players = self.game.players.alive().exclude(self)
+        players = self.game.players.alive()
         await self.send(
-            UniMessage.text(f"请选择需要保护的玩家:\n{players.show()}")
+            UniMessage.text("请选择需要保护的玩家:\n")
+            .text(players.show())
             .text("\n\n发送编号选择玩家")
             .text("\n发送 “/stop” 结束回合")
         )
@@ -412,24 +422,25 @@ class 守卫(Player):
         await self.send(f"本回合保护的玩家: {self.selected.name}")
 
 
-@register_role
-class 白痴(Player):
-    role: ClassVar[Role] = Role.Idiot
-    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
+@register_role(Role.Idiot, RoleGroup.GoodGuy)
+class Idiot(Player):
     voted: bool = False
 
     @override
-    async def kill(
-        self,
-        reason: KillReason,
-        *killers: Player,
-    ) -> bool:
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send(
+            "作为白痴，你可以在首次被投票放逐时免疫放逐，但在之后的投票中无法继续投票"
+        )
+
+    @override
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
         if reason == KillReason.Vote and not self.voted:
             self.voted = True
             await self.game.send(
                 UniMessage.at(self.user_id)
                 .text(" 的身份是白痴\n")
-                .text("免疫本次投票放逐，且接下来无法参与投票")
+                .text("免疫本次投票放逐，且接下来无法参与投票"),
             )
             return False
         return await super().kill(reason, *killers)
@@ -442,7 +453,22 @@ class 白痴(Player):
         return await super().vote(players)
 
 
-@register_role
-class 平民(Player):
-    role: ClassVar[Role] = Role.Civilian
-    role_group: ClassVar[RoleGroup] = RoleGroup.GoodGuy
+@register_role(Role.Joker, RoleGroup.Others)
+class Joker(Player):
+    @override
+    async def notify_role(self) -> None:
+        await super().notify_role()
+        await self.send("你的胜利条件: 被投票放逐")
+
+    @override
+    async def kill(self, reason: KillReason, *killers: Player) -> bool:
+        result = await super().kill(reason, *killers)
+        if reason == KillReason.Vote:
+            self.game.killed_players.append(self)
+            raise GameFinishedError(GameStatus.Joker)
+        return result
+
+
+@register_role(Role.Civilian, RoleGroup.GoodGuy)
+class Civilian(Player):
+    pass

nonebot_plugin_werewolf/player_set.py

@@ -1,34 +1,42 @@
+from __future__ import annotations
+
 import asyncio
 import asyncio.timeouts
+from typing import TYPE_CHECKING
 
-from nonebot_plugin_alconna.uniseg import UniMessage
-
-from .constant import Role, RoleGroup
 from .player import Player
 
+if TYPE_CHECKING:
+    from nonebot_plugin_alconna.uniseg import UniMessage
+
+    from .constant import Role, RoleGroup
+
 
 class PlayerSet(set[Player]):
     @property
     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 killed(self) -> PlayerSet:
+        return PlayerSet(p for p in self if p.killed.is_set())
+
+    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 +47,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/utils.py

@@ -1,15 +1,17 @@
 import asyncio
 import asyncio.timeouts
+import re
 from collections import defaultdict
 from typing import Annotated, Any, ClassVar
 
 import nonebot_plugin_waiter as waiter
 from nonebot.adapters import Event
+from nonebot.log import logger
 from nonebot.rule import to_me
 from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg
 from nonebot_plugin_userinfo import EventUserInfo, UserInfo
 
-from .constant import player_preset
+from .config import config
 
 
 def check_index(text: str, arrlen: int) -> int | None:
@@ -47,7 +49,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
 
@@ -59,7 +61,7 @@ async def rule_in_game(event: Event, target: MsgTarget) -> bool:
         return False
     if target.private:
         return user_in_game(target.id, None)
-    elif target.id in running_games:
+    if target.id in running_games:
         return user_in_game(event.get_user_id(), target.id)
     return False
 
@@ -92,14 +94,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
-        await queue.put((user, name, text))
+        await queue.put((user, re.sub(r"[\u2066-\u2069]", "", name), text))
 
 
 async def _prepare_game_handle(
@@ -107,26 +113,30 @@ async def _prepare_game_handle(
     players: dict[str, str],
     admin_id: str,
 ) -> None:
+    log = logger.opt(colors=True)
+
     while True:
         user, name, text = await queue.get()
         msg = UniMessage.at(user)
+        colored = f"<y>{name}</y>(<c>{user}</c>)"
 
         match (text, user == admin_id):
             case ("开始游戏", True):
                 player_num = len(players)
-                if player_num < min(player_preset):
+                role_preset = config.get_role_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("无法开始游戏")
@@ -134,12 +144,14 @@ async def _prepare_game_handle(
                     )
                 else:
                     await msg.text("游戏即将开始...").send()
+                    log.info(f"游戏发起者 {colored} 开始游戏")
                     return
 
             case ("开始游戏", False):
                 await msg.text("只有游戏发起者可以开始游戏").send()
 
             case ("结束游戏", True):
+                log.info(f"游戏发起者 {colored} 结束游戏")
                 await msg.text("已结束当前游戏").finish()
 
             case ("结束游戏", False):
@@ -151,6 +163,7 @@ async def _prepare_game_handle(
             case ("加入游戏", False):
                 if user not in players:
                     players[user] = name
+                    log.info(f"玩家 {colored} 加入游戏")
                     await msg.text("成功加入游戏").send()
                 else:
                     await msg.text("你已经加入游戏了").send()
@@ -161,32 +174,29 @@ async def _prepare_game_handle(
             case ("退出游戏", False):
                 if user in players:
                     del players[user]
+                    log.info(f"玩家 {colored} 退出游戏")
                     await msg.text("成功退出游戏").send()
                 else:
                     await msg.text("你还没有加入游戏").send()
 
             case ("当前玩家", _):
                 msg.text("\n当前玩家:\n")
-                for 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()
 
 
 async def prepare_game(event: Event, players: dict[str, str]) -> None:
+    from .game import starting_games
+
+    group_id = UniMessage.get_target(event).id
+    starting_games[group_id] = players
+
     queue: asyncio.Queue[tuple[str, str, str]] = asyncio.Queue()
-    task_receive = asyncio.create_task(
-        _prepare_game_receive(
-            queue,
-            event,
-            UniMessage.get_target(event).id,
-        )
-    )
+    task_receive = asyncio.create_task(_prepare_game_receive(queue, event, group_id))
 
     try:
-        await _prepare_game_handle(
-            queue,
-            players,
-            event.get_user_id(),
-        )
+        await _prepare_game_handle(queue, players, event.get_user_id())
     finally:
         task_receive.cancel()
+        del starting_games[group_id]