nonebot-plugin-l4d2-server 1.0.4__py3-none-any.whl → 1.0.8__py3-none-any.whl

nonebot_plugin_l4d2_server/__init__.py

@@ -20,6 +20,7 @@ from nonebot import get_driver, require
 require("nonebot_plugin_htmlrender")
 require("nonebot_plugin_alconna")
 require("nonebot_plugin_tortoise_orm")
+require("nonebot_plugin_datastore")
 
 from nonebot.plugin import PluginMetadata, inherit_supported_adapters  # noqa: E402
 

nonebot_plugin_l4d2_server/__main__.py

@@ -16,7 +16,7 @@
 """
 
 from pathlib import Path
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional
 
 import aiofiles
 import ujson as json
@@ -37,9 +37,12 @@ from .l4_request import (
     get_ip_server,
     get_server_detail,
     reload_ip,
+    server_find,
     tj_request,
 )
 from .utils.api.request import L4API
+from .utils.api.utils import out_msg_out
+from .utils.utils import split_maohao
 
 if TYPE_CHECKING:
     from .utils.api.models import OutServer
@@ -111,10 +114,15 @@ async def _(
         _id = None
     logger.info(f"组:{command} ;数字:{_id}")
     msg = await get_server_detail(command, _id)
-    if msg is not None:
-        await out_msg_out(msg, is_connect=config.l4_image)
-    else:
+    if msg is None:
         await out_msg_out("服务器无响应")
+        return
+    if _id is None:
+        logger.info(f"正在输出组:{command}")
+        await out_msg_out(msg)
+    if _id:
+        logger.info(f"正在输出单服务器:{command} {_id}", is_connect=config.l4_image)
+        await out_msg_out(msg)
 
 
 @l4_find_player.handle()
@@ -127,21 +135,30 @@ async def _(
     if len(tag_list) == 1:
         await UniMessage.text("未设置组，正在全服查找，时间较长").send()
         name = tag_list[0]
-        out: List[OutServer] = await get_server_detail(is_img=False)  # type: ignore
+        out: List[OutServer] = await server_find(is_img=False)  # type: ignore
+        logger.info(out)
+        logger.info(type(out))
         out_msg = "未找到玩家"
         for one in out:
+            logger.info(one)
             for player in one["player"]:
                 if name in player.name:
                     out_msg = await get_ip_server(f"{one['host']}:{one['port']}")
     if len(tag_list) == 2:
         group, name = tag_list
         await UniMessage.text(f"正在查询{group}组").send()
-        out: List[OutServer] = await get_server_detail(group=group, is_img=False)  # type: ignore
+        out: List[OutServer] = await server_find(command=group, is_img=False)  # type: ignore
         out_msg = "未找到玩家"
         for one in out:
             for player in one["player"]:
                 if name in player.name:
                     out_msg = await get_ip_server(f"{one['host']}:{one['port']}")
+                    if config.l4_connect and isinstance(out_msg, bytes):
+                        out_msg = UniMessage.image(raw=out_msg) + UniMessage.text(
+                            f"\nconnect {one['host']}:{one['port']}",
+                        )
+                    else:
+                        out_msg = UniMessage.text(out_msg)
 
     return await out_msg_out(out_msg)
 
@@ -155,17 +172,22 @@ async def _():
 async def _(args: Message = CommandArg()):
     ip: Optional[str] = args.extract_plain_text()
     if ip is not None:
-        await out_msg_out(await get_ip_server(ip), is_connect=config.l4_image)
+        host, port = split_maohao(ip)
+        await out_msg_out(
+            await get_ip_server(ip),
+            is_connect=config.l4_connect,
+            host=host,
+            port=port,
+        )
 
 
 @l4_reload.handle()
 async def _(args: Message = CommandArg()):
     arg = args.extract_plain_text().strip()
-    print(arg)
     if not arg:
         reload_ip()
         logger.success("重载ip完成")
-        with (Path(config.l4_path) / "config.json").open("r", encoding="utf-8") as f:
+        with (Path(config.l4_path) / "l4d2.json").open("r", encoding="utf-8") as f:
             content = f.read().strip()
             ip_json = json.loads(content)
         for tag, url in ip_json.items():
@@ -261,24 +283,6 @@ async def _(matcher: Matcher):
     await matcher.finish(await tj_request("云", "zl"))
 
 
-async def out_msg_out(
-    msg: Union[str, bytes, UniMessage],
-    is_connect: bool = False,
-    host: str = "",
-    port: str = "",
-):
-    if isinstance(msg, UniMessage):
-        return await msg.finish()
-    if isinstance(msg, str):
-        await UniMessage.text(msg).finish()
-    if is_connect:
-        out = UniMessage.image(raw=msg) + UniMessage.text(
-            f"连接到服务器: {host}:{port}",
-        )
-        return await out.finish()
-    return await UniMessage.image(raw=msg).finish()
-
-
 ## 以下为配置修改
 
 img_trung = on_command("l4img", aliases={"l4图片"}, permission=SUPERUSER)

nonebot_plugin_l4d2_server/config.py

@@ -6,10 +6,10 @@ from pydantic import BaseModel
 
 DATAPATH = Path(__file__).parent.joinpath("data")
 DATAOUT = Path("data/L4D2")
+DATAOUT.mkdir(parents=True, exist_ok=True)
 if not Path(DATAOUT / "l4d2.json").exists():
     logger.info("文件 l4d2.json 不存在，已创建并初始化为 {}")
     Path(DATAOUT / "l4d2.json").write_text("{}", encoding="utf-8")
-print(DATAOUT.absolute())
 server_all_path = DATAOUT / "l4d2"
 server_all_path.mkdir(parents=True, exist_ok=True)
 

nonebot_plugin_l4d2_server/l4_help/Help.json

@@ -28,7 +28,7 @@
       },
       {
         "name": "l4全服",
-        "desc": "返回可以查询的所有服务器组(未完成)",
+        "desc": "返回可以查询的所有服务器组",
         "eg": "/l4全服",
         "need_ck": false,
         "need_sk": false,
@@ -36,43 +36,6 @@
       }
     ]
   },
-  "电信服anne服务": {
-    "desc": "电信anne服相关服务",
-    "data": [
-      {
-        "name": "Banne xx",
-        "desc": "绑定昵称/steamid",
-        "eg": "/Banne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      },
-      {
-        "name": "Ranne(玩家)",
-        "desc": "查询anne个人信息,没有参数查自己",
-        "eg": "/Ranne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      },
-      {
-        "name": "Sanne(玩家)",
-        "desc": "按昵称查询anne玩家信息",
-        "eg": "/Sanne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      },
-      {
-        "name": "Danne(玩家)",
-        "desc": "删除anne玩家信息",
-        "eg": "/Danne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      }
-    ]
-  },
   "管理员服务": {
     "desc": "管理可以使用的指令",
     "data": [
@@ -83,7 +46,7 @@
         "need_ck": false,
         "need_sk": false,
         "need_admin": true
-      },      
+      },
       {
         "name": "l4地图上传",
         "desc": "进入交互上传地图文件",

nonebot_plugin_l4d2_server/l4_help/__init__.py

@@ -1,8 +1,8 @@
+import json
 from pathlib import Path
 from typing import Dict, Union
 
 import aiofiles
-from msgspec import json as msgjson
 from PIL import Image
 
 from ..config import ICONPATH
@@ -10,18 +10,16 @@ from ..l4_image.convert import core_font
 from ..l4_image.model import PluginHelp
 from .draw import get_help
 
-__version__ = "1.0.4"
+__version__ = "1.0.8"
 TEXT_PATH = Path(__file__).parent / "texture2d"
 HELP_DATA = Path(__file__).parent / "Help.json"
 
 
 async def get_help_data() -> Union[Dict[str, PluginHelp], None]:
     if HELP_DATA.exists():
-        async with aiofiles.open(HELP_DATA, "rb") as file:
-            return msgjson.decode(
-                await file.read(),
-                type=Dict[str, PluginHelp],
-            )
+        async with aiofiles.open(HELP_DATA, "r", encoding="utf-8") as file:
+            content = await file.read()
+            return json.loads(content)
     return None
 
 

nonebot_plugin_l4d2_server/l4_image/html_img.py

@@ -45,7 +45,7 @@ async def server_ip_pic(server_dict: List[OutServer]):
                 key=lambda x: x.score,
                 reverse=True,
             )[:max_number]
-            print(sorted_players)
+            logger.debug(sorted_players)
             server_info["player"] = sorted_players
         else:
             server_info["player"] = []
@@ -88,18 +88,3 @@ async def get_server_img(plugins: List[OutServer]) -> Optional[bytes]:
     except Exception as e:
         logger.warning(f"Error in get_help_img: {e}")
     return None
-
-
-# async def server_group_ip_pic(msg_list: List[ServerGroup]) -> bytes:
-#     """
-#     输入一个群组字典列表,输出图片
-#     msg_dict:folder/name/map_/players/max_players/Players/[Name]
-#     """
-#     template = env.get_template("group_ip.html")
-#     html = await template.render_async(plugins=msg_list)
-#     return await html_to_pic(
-#         html=html,
-#         wait=0,
-#         viewport={"width": 1100, "height": 800},
-#         template_path=f"file://{template_path.absolute()}",
-#     )

nonebot_plugin_l4d2_server/l4_image/image_tools.py

@@ -155,9 +155,8 @@ def draw_text_by_line(
     y_add = math.ceil(1.3 * h) if line_space is None else math.ceil(h + line_space)
     draw = ImageDraw.Draw(img)
     row = ""  # 存储本行文字
-    length = 0  # 记录本行长度
+    length = 0
     for character in text:
-        # 获取当前字符的宽度
         if hasattr(font, "getsize"):
             w, h = font.getsize(character)  # type: ignore
         else:

nonebot_plugin_l4d2_server/l4_local/__init__.py

@@ -47,7 +47,6 @@ else:
     async def _():
         supath = local_path[map_index] / "addons"
         vpk_list: list[str] = []
-        print(supath)
         if supath.is_dir():
             for sudir in supath.iterdir():
                 logger.info(f"找到文件:{sudir}")

nonebot_plugin_l4d2_server/l4_request/__init__.py

@@ -1,54 +1,61 @@
 import random
-from typing import Dict, List, Optional, Tuple, Union, cast
+from typing import Dict, List, Optional, cast
 
 from nonebot.log import logger
 from nonebot_plugin_alconna import UniMessage
 
-from ..config import server_all_path
-from ..l4_image import msg_to_image
+from ..config import config, server_all_path
 from ..utils.api.models import AllServer, NserverOut
 from ..utils.api.request import L4API
 from ..utils.utils import split_maohao
-from .draw_msg import convert_duration, draw_one_ip, get_much_server
+from .draw_msg import draw_one_ip, get_much_server
+from .utils import (
+    _build_message,
+    _filter_servers,
+    _format_players,
+    _get_server_json,
+    _handle_group_info,
+    _handle_single_server,
+    get_single_server_info,
+)
 
 try:
     import ujson as json
 except ImportError:
     import json
 
-from ..config import config
 
 # 获取全部服务器信息
 ALLHOST: Dict[str, List[NserverOut]] = {}
 COMMAND = set()
 
 
-async def get_all_server_detail():
+async def get_all_server_detail() -> str:
     """
     获取所有服务器的详细信息。
 
-    Args:
-        无
-
     Returns:
         str: 包含所有服务器详细信息的字符串。
-
     """
     out_list: List[AllServer] = []
     for group in ALLHOST:
         msg_list = await get_group_detail(group)
-        if msg_list is None:
+        if not msg_list:
             continue
-        active_server = 0
-        max_server = 0
-        active_player = 0
-        max_player = 0
-        for index, msg in enumerate(msg_list):
-            max_server = index + 1
-            if msg["server"].max_players != 0:
-                active_server += 1
-                active_player += msg["server"].player_count
-                max_player += msg["server"].max_players
+
+        active_server = sum(1 for msg in msg_list if msg["server"].max_players != 0)
+        max_server = len(msg_list)
+        active_player = sum(
+            msg["server"].player_count
+            for msg in msg_list
+            if msg["server"].max_players != 0
+        )
+        max_player = sum(
+            msg["server"].max_players
+            for msg in msg_list
+            if msg["server"].max_players != 0
+        )
+
         data = {
             "command": group,
             "active_server": active_server,
@@ -58,14 +65,12 @@ async def get_all_server_detail():
         }
         out_list.append(cast(AllServer, data))
 
-    # to do作图，先用文字凑合
-    out_msg = ""
-    for one in out_list:
-        if one["max_player"]:
-            out_msg += f"{one['command']} | 服务器{one['active_server']}/{one['max_server']} | 玩家{one['active_player']}/{one['max_player']}\n"
-        else:
-            continue
-    return out_msg
+    # 输出服务器信息文本
+    return "\n".join(
+        f"{one['command']} | 服务器{one['active_server']}/{one['max_server']} | 玩家{one['active_player']}/{one['max_player']}"
+        for one in out_list
+        if one["max_player"]
+    )
 
 
 async def get_server_detail(
@@ -80,20 +85,18 @@ async def get_server_detail(
         command (str): 服务器组名。
         _id (Optional[str], optional): 服务器ID。默认为None。
         is_img (bool, optional): 是否返回图片格式的信息。默认为True。
-        return_host_port (bool, optional): 是否返回host和port值。默认为False。
 
     Returns:
-        Union[bytes, str, None, Tuple[str, int]]:
-            如果return_host_port为True且_id不为None，返回(host, port)元组；
-            否则返回服务器详细信息(图片格式返回bytes，文本格式返回str)；
-            未找到服务器组返回None。
+        Union[UniMessage, None]:
+            返回服务器详细信息（图片或文本格式），未找到服务器组或服务器时返回None。
     """
-    server_json = _get_server_json(command)
+    server_json = _get_server_json(command, ALLHOST)
     logger.info(server_json)
     if server_json is None:
         logger.warning("未找到这个组")
         return None
 
+    # 输出组服务器信息
     if _id is None:
         return await _handle_group_info(server_json, command, is_img)
 
@@ -112,99 +115,10 @@ async def get_server_detail(
     return None
 
 
-def _get_server_json(command: str) -> Optional[list]:
-    """
-    根据命令获取服务器JSON列表
-
-    Args:
-        command (str): 服务器组名
-
-    Returns:
-        Optional[list]: 服务器JSON列表，未找到组时返回None
-    """
-    if command:
-        return ALLHOST.get(command)
-    server_json = []
-    for servers in ALLHOST.values():
-        server_json.extend(servers)
-    return server_json
-
-
-async def _handle_group_info(
-    server_json: list,
-    command: str,
-    is_img: bool,
-) -> Union[bytes, str, None]:
-    """
-    处理服务器组信息请求
-
-    Args:
-        server_json (list): 服务器JSON列表
-        command (str): 服务器组名
-        is_img (bool): 是否返回图片格式
-
-    Returns:
-        Union[bytes, list, None]: 图片格式返回bytes，否则返回服务器列表
-    """
-    logger.info(f"正在请求组服务器信息 {command}")
-    server_dict = await get_much_server(server_json, command)
-    if is_img:
-        return await msg_to_image(server_dict)
-    return str(server_dict)
-
-
-async def get_single_server_info(
-    server_json: list,
-    _id: str,
-) -> Optional[Tuple[str, int]]:
-    """
-    获取单个服务器的host和port信息
-
-    Args:
-        server_json (list): 服务器JSON列表
-        _id (str): 服务器ID
-
-    Returns:
-        Optional[Tuple[str, int]]: 返回(host, port)元组，未找到返回None
-    """
-    logger.info("正在获取单服务器信息")
-    for i in server_json:
-        if str(_id) == str(i["id"]):
-            return i["host"], i["port"]
-    return None
-
-
-async def _handle_single_server(
-    server_json: list,
-    _id: str,
-    is_img: bool,
-) -> Union[bytes, str, None]:
-    """
-    处理单个服务器信息请求
-
-    Args:
-        server_json (list): 服务器JSON列表
-        _id (str): 服务器ID
-        is_img (bool): 是否返回图片格式
-
-    Returns:
-        Union[bytes, str, None]: 找到服务器时返回信息，否则返回None
-    """
-    server_info = await get_single_server_info(server_json, _id)
-    if server_info is None:
-        return None
-
-    host, port = server_info
-    out_msg = await draw_one_ip(host, port)
-    if is_img:
-        return cast(bytes, out_msg)
-    return out_msg
-
-
 async def get_group_detail(
     command: str,
 ):
-    server_json = ALLHOST.get(command)
+    server_json = _get_server_json(command, ALLHOST)
     logger.info(server_json)
     if server_json is None:
         logger.warning("未找到这个组")
@@ -222,7 +136,6 @@ async def get_ip_server(ip: str):
 # 以下是重载ip
 def reload_ip():
     global COMMAND
-    # print("正在读取json文件")
     group_ip = []
     for item in server_all_path.iterdir():
         if item.is_file() and item.name.endswith("json"):
@@ -266,74 +179,8 @@ async def tj_request(command: str = "云", tj="tj"):
     player_msg = ""
     right_ip = []
 
-    async def _filter_servers(servers: list, tj_mode: str) -> list:
-        """筛选符合条件的服务器
-        Args:
-            servers: 服务器列表
-            tj_mode: 筛选模式（'tj'或'zl'）
-        Returns:
-            符合条件的服务器列表
-        """
-        filtered = []
-        for i in servers:
-            ser_list = await L4API.a2s_info([(i["host"], i["port"])], is_player=True)
-            if not ser_list:
-                continue
-
-            srv = ser_list[0][0]
-            players = ser_list[0][1]
-
-            if tj_mode == "tj" and map_type in srv.map_name:
-                score = sum(p.score for p in players[:4])
-                t = srv.map_name.split("[")[-1].split("特")[0]
-                if t.isdigit() and int(t) * 50 < score:
-                    logger.info(
-                        f"符合TJ条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 分数: {score}",
-                    )
-                    filtered.append(i)
-            elif tj_mode == "zl" and map_type in srv.map_name and len(players) <= 4:
-                logger.info(
-                    f"符合ZL条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 玩家数: {len(players)}",
-                )
-                filtered.append(i)
-        return filtered
-
-    async def _format_players(player_list: list) -> str:
-        """格式化玩家信息
-        Args:
-            player_list: 玩家对象列表
-        Returns:
-            格式化后的玩家信息字符串
-        """
-        durations = [await convert_duration(p.duration) for p in player_list]
-        max_duration_len = max(len(str(d)) for d in durations)
-        max_score_len = max(len(str(p.score)) for p in player_list)
-        return "\n".join(
-            f"[{p.score:>{max_score_len}}] | {durations[i]:^{max_duration_len}} | {p.name[0]}***{p.name[-1]}"
-            for i, p in enumerate(player_list)
-        )
-
-    def _build_message(srv_info, players_msg: str, selected_srv: dict) -> str:
-        """构建服务器信息消息
-        Args:
-            srv_info: 服务器信息对象
-            players_msg: 格式化后的玩家信息
-            selected_srv: 选中的服务器信息
-        Returns:
-            完整的消息字符串
-        """
-        msg = f"""*{srv_info.server_name}*
-游戏: {srv_info.folder}
-地图: {srv_info.map_name}
-人数: {srv_info.player_count}/{srv_info.max_players}"""
-        if srv_info.ping is not None:
-            msg += f"\nping: {srv_info.ping * 1000:.0f}ms\n{players_msg}"
-        if config.l4_show_ip:
-            msg += f"\nconnect {selected_srv['host']}:{selected_srv['port']}"
-        return msg
-
     try:
-        right_ip = await _filter_servers(server_json, tj)
+        right_ip = await _filter_servers(server_json, tj, map_type)
 
         if not right_ip:
             logger.warning("没有找到符合条件的服务器")
@@ -356,8 +203,38 @@ async def tj_request(command: str = "云", tj="tj"):
         else:
             player_msg = "服务器感觉很安静啊"
 
-        return _build_message(one_server, player_msg, s)
+        return _build_message(one_server, player_msg, s, config)
 
     except Exception as e:
         logger.error(f"tj_request error: {e}")
         return "获取服务器信息时出错"
+
+
+async def server_find(
+    command: str = "云",
+    _id: Optional[str] = None,
+    is_img: bool = True,
+):
+    server_json = _get_server_json(command, ALLHOST)
+    logger.info(server_json)
+    if server_json is None:
+        logger.warning("未找到这个组")
+        return None
+
+    # 输出组服务器信息
+    if _id is None:
+        return await _handle_group_info(server_json, command, is_img)
+
+    _ip = await get_single_server_info(server_json, _id)
+    if _ip is None:
+        logger.warning("未找到这个服务器")
+        return None
+
+    out_msg = await _handle_single_server(server_json, _id, is_img)
+    if isinstance(out_msg, bytes):
+        return UniMessage.image(raw=out_msg) + UniMessage.text(
+            f"connect {_ip[0]}:{_ip[1]}",
+        )
+    if isinstance(out_msg, str):
+        return UniMessage.text(out_msg)
+    return None

nonebot_plugin_l4d2_server/l4_request/draw_msg.py

@@ -76,7 +76,7 @@ connect {host}:{port}"""
         text: str,
         font: ImageFont.FreeTypeFont,
         draw: ImageDraw.ImageDraw,
-    ) -> Image.Image:
+    ) -> Image.Image:  # type: ignore # 明确返回类型
         """在图片上绘制文本
         Args:
             text: 要绘制的文本

nonebot_plugin_l4d2_server/l4_request/utils.py

@@ -0,0 +1,176 @@
+from typing import Dict, List, Optional, Tuple, Union, cast
+
+from nonebot.log import logger
+
+from ..l4_image import msg_to_image
+from ..utils.api.models import NserverOut
+from ..utils.api.request import L4API
+from .draw_msg import convert_duration, draw_one_ip, get_much_server
+
+
+def _get_server_json(
+    command: str,
+    allhost: Dict[str, List[NserverOut]],
+) -> Optional[list]:
+    """
+    根据命令获取服务器JSON列表
+
+    Args:
+        command (str): 服务器组名
+        ALLHOST (Dict): 全局服务器字典
+
+    Returns:
+        Optional[list]: 服务器JSON列表，未找到组时返回None
+    """
+    if command:
+        return allhost.get(command)
+    server_json = []
+    for servers in allhost.values():
+        server_json.extend(servers)
+    return server_json
+
+
+async def _handle_group_info(
+    server_json: list,
+    command: str,
+    is_img: bool,
+):
+    """
+    处理服务器组信息请求
+
+    Args:
+        server_json (list): 服务器JSON列表
+        command (str): 服务器组名
+        is_img (bool): 是否返回图片格式
+
+    Returns:
+        Union[bytes, list, None]: 图片格式返回bytes，否则返回服务器列表
+    """
+    logger.info(f"正在请求组服务器信息 {command}")
+    server_dict = await get_much_server(server_json, command)
+    if is_img:
+        return await msg_to_image(server_dict)
+    return server_dict
+
+
+async def get_single_server_info(
+    server_json: list,
+    _id: str,
+) -> Optional[Tuple[str, int]]:
+    """
+    获取单个服务器的host和port信息
+
+    Args:
+        server_json (list): 服务器JSON列表
+        _id (str): 服务器ID
+
+    Returns:
+        Optional[Tuple[str, int]]: 返回(host, port)元组，未找到返回None
+    """
+    logger.info("正在获取单服务器信息")
+    for i in server_json:
+        if str(_id) == str(i["id"]):
+            return i["host"], i["port"]
+    return None
+
+
+async def _handle_single_server(
+    server_json: list,
+    _id: str,
+    is_img: bool,
+) -> Union[bytes, str, None]:
+    """
+    处理单个服务器信息请求
+
+    Args:
+        server_json (list): 服务器JSON列表
+        _id (str): 服务器ID
+        is_img (bool): 是否返回图片格式
+
+    Returns:
+        Union[bytes, str, None]: 找到服务器时返回信息，否则返回None
+    """
+    server_info = await get_single_server_info(server_json, _id)
+    if server_info is None:
+        return None
+
+    host, port = server_info
+    out_msg = await draw_one_ip(host, port)
+    if is_img:
+        return cast(bytes, out_msg)
+    return out_msg
+
+
+async def _filter_servers(
+    servers: list,
+    tj_mode: str,
+    map_type: str = "普通药役",
+) -> list:
+    """筛选符合条件的服务器
+    Args:
+        servers: 服务器列表
+        tj_mode: 筛选模式（'tj'或'zl'）
+        map_type: 地图类型筛选条件
+    Returns:
+        符合条件的服务器列表
+    """
+    filtered = []
+    for i in servers:
+        ser_list = await L4API.a2s_info([(i["host"], i["port"])], is_player=True)
+        if not ser_list:
+            continue
+
+        srv = ser_list[0][0]
+        players = ser_list[0][1]
+
+        if tj_mode == "tj" and map_type in srv.map_name:
+            score = sum(p.score for p in players[:4])
+            t = srv.map_name.split("[")[-1].split("特")[0]
+            if t.isdigit() and int(t) * 50 < score:
+                logger.info(
+                    f"符合TJ条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 分数: {score}",
+                )
+                filtered.append(i)
+        elif tj_mode == "zl" and map_type in srv.map_name and len(players) <= 4:
+            logger.info(
+                f"符合ZL条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 玩家数: {len(players)}",
+            )
+            filtered.append(i)
+    return filtered
+
+
+async def _format_players(player_list: list) -> str:
+    """格式化玩家信息
+    Args:
+        player_list: 玩家对象列表
+    Returns:
+        格式化后的玩家信息字符串
+    """
+    durations = [await convert_duration(p.duration) for p in player_list]
+    max_duration_len = max(len(str(d)) for d in durations)
+    max_score_len = max(len(str(p.score)) for p in player_list)
+    return "\n".join(
+        f"[{p.score:>{max_score_len}}] | {durations[i]:^{max_duration_len}} | {p.name[0]}***{p.name[-1]}"
+        for i, p in enumerate(player_list)
+    )
+
+
+def _build_message(srv_info, players_msg: str, selected_srv: dict, config) -> str:
+    """构建服务器信息消息
+    Args:
+        srv_info: 服务器信息对象
+        players_msg: 格式化后的玩家信息
+        selected_srv: 选中的服务器信息
+        config: 配置对象
+    Returns:
+        完整的消息字符串
+    """
+    msg = f"""*{srv_info.server_name}*
+游戏: {srv_info.folder}
+地图: {srv_info.map_name}
+人数: {srv_info.player_count}/{srv_info.max_players}"""
+    if srv_info.ping is not None:
+        msg += f"\nping: {srv_info.ping * 1000:.0f}ms\n{players_msg}"
+    if config.l4_show_ip:
+        msg += f"\nconnect {selected_srv['host']}:{selected_srv['port']}"
+    return msg

nonebot_plugin_l4d2_server/utils/api/request.py

@@ -9,12 +9,11 @@ import a2s
 import aiofiles
 import ujson as js
 import ujson as json
-from bs4 import BeautifulSoup
+from bs4 import BeautifulSoup, Tag
 from httpx import AsyncClient
+from nonebot.log import logger
 
 from ...config import config
-
-# from nonebot.log import logger
 from ..utils import split_maohao
 from .api import AnnePlayerApi, AnneSearchApi, anne_ban
 from .models import (
@@ -42,6 +41,23 @@ class L4D2Api:
         "Content-Type": "application/x-www-form-urlencoded",
     }
 
+    def safe_select(self, element: Optional[Tag], selector: str) -> List[Any]:
+        """安全地调用 select 方法"""
+        if isinstance(element, Tag):
+            return element.select(selector)
+        return []
+
+    def safe_find_all(
+        self,
+        element: Optional[Tag],
+        tag: str,
+        class_: str = "",
+    ) -> List[Any]:
+        """安全地调用 find_all 方法"""
+        if isinstance(element, Tag):
+            return element.find_all(tag, class_=class_)
+        return []
+
     async def a2s_info(
         self,
         ip_list: List[Tuple[str, int]],
@@ -53,28 +69,29 @@ class L4D2Api:
         msg_list: List[
             Tuple[Union[a2s.SourceInfo[str], a2s.GoldSrcInfo[str]], List[a2s.Player]]
         ] = []
-        sorted_msg_list = []
-        tasks = []  # 用来保存异步任务
-        if ip_list != []:
-            for index, i in enumerate(ip_list):
-                try:
-                    tasks.append(
-                        asyncio.create_task(
-                            self.process_message(
-                                i,
-                                index,
-                                is_server,
-                                is_player,
-                            ),
-                        ),
-                    )
-                except ValueError:
-                    continue  # 处理异常情况
 
-            msg_list = await asyncio.gather(*tasks)
-            sorted_msg_list = sorted(msg_list, key=lambda x: x[0].steam_id)
+        if ip_list:
+            tasks = [
+                asyncio.create_task(
+                    self.process_message(ip, index, is_server, is_player),
+                )
+                for index, ip in enumerate(ip_list)
+            ]
 
-        return sorted_msg_list
+            try:
+                results = await asyncio.gather(*tasks)
+                msg_list = [r for r in results if r is not None]
+            except Exception as e:
+                logger.error(f"获取服务器信息时发生错误: {e}")
+
+        # 使用稳定的排序方式，避免服务器频繁变动位置
+        return sorted(
+            msg_list,
+            key=lambda x: (
+                getattr(x[0], "steam_id", float("inf")) is None,
+                getattr(x[0], "steam_id", float("inf")),
+            ),
+        )
 
     async def process_message(
         self,
@@ -235,14 +252,12 @@ class L4D2Api:
         tag_path = Path(Path(config.l4_path) / f"l4d2/{tag}.json")
 
         async with aiofiles.open(tag_path, "w", encoding="utf-8") as f:
-            print(Path(Path(config.l4_path) / f"l4d2/{tag}.json"))
             up_data = {}
             for server in server_list:
                 new_dict = {}
                 new_dict["id"] = int(server.index) + 1
                 new_dict["ip"] = server.host + ":" + str(server.port)
                 up_data.update(new_dict)
-            print(up_data)
             json.dump(up_data, f, ensure_ascii=False, indent=4)
         return server_list
 
@@ -277,7 +292,7 @@ class L4D2Api:
                     "last_time": td_tags,
                 },
             )
-        print(server_list)
+        logger.debug(server_list)
         return cast(List[AnneSearch], server_list)
 
     async def get_anne_playerdetail(self, steamid: str):
@@ -298,98 +313,101 @@ class L4D2Api:
         )
         if tbody is None:
             return None
-        kill_tag = cast(BeautifulSoup, tbody).find(
+
+        def get_table_dict(table, keys):
+            trs = table.select("tr")
+            return {
+                key: trs[i].select("td")[1].text.strip() for i, key in enumerate(keys)
+            }
+
+        kill_tag = cast(Tag, tbody).find(
             "div",
             class_="card-body worldmap d-flex flex-column justify-content-center text-center",
         )
 
-        tbody_tags = tbody.find_all(
-            "table",
-            class_="table content-table-noborder text-left",
-        )
-        print(len(tbody_tags))
-        info_tag = tbody_tags[0]
-        detail_tag = tbody_tags[1]
-        error_tag = tbody_tags[2]
-        inf_avg_tag = tbody_tags[3]
-        sur_tag = tbody_tags[4]
-        inf_tag = tbody_tags[5]
-
-        info_tr = info_tag.select("tr")
-        info_dict = {
-            "name": info_tr[0].select("td")[1].text.strip(),
-            "avatar": info_tr[1].select("td")[1].text.strip(),
-            "steamid": info_tr[2].select("td")[1].text.strip(),
-            "playtime": info_tr[3].select("td")[1].text.strip(),
-            "lasttime": info_tr[4].select("td")[1].text.strip(),
-        }
-        detail_tag = {
-            "rank": detail_tag.select("tr")[0].select("td")[1].text.strip(),
-            "source": detail_tag.select("tr")[1].select("td")[1].text.strip(),
-            "avg_source": detail_tag.select("tr")[2].select("td")[1].text.strip(),
-            "kills": detail_tag.select("tr")[3].select("td")[1].text.strip(),
-            "kills_people": detail_tag.select("tr")[4].select("td")[1].text.strip(),
-            "headshots": detail_tag.select("tr")[5].select("td")[1].text.strip(),
-            "avg_headshots": detail_tag.select("tr")[6].select("td")[1].text.strip(),
-            "map_play": detail_tag.select("tr")[7].select("td")[1].text.strip(),
-        }
-        error_tag = {
-            "mistake_shout": error_tag.select("tr")[0].select("td")[1].text.strip(),
-            "kill_friend": error_tag.select("tr")[1].select("td")[1].text.strip(),
-            "down_friend": error_tag.select("tr")[2].select("td")[1].text.strip(),
-            "abandon_friend": error_tag.select("tr")[3].select("td")[1].text.strip(),
-            "put_into": error_tag.select("tr")[4].select("td")[1].text.strip(),
-            "agitate_witch": error_tag.select("tr")[5].select("td")[1].text.strip(),
-        }
-        inf_avg_dict = {
-            "avg_smoker": inf_avg_tag.select("tr")[0].select("td")[1].text.strip(),
-            "avg_boomer": inf_avg_tag.select("tr")[1].select("td")[1].text.strip(),
-            "avg_hunter": inf_avg_tag.select("tr")[2].select("td")[1].text.strip(),
-            "avg_charger": inf_avg_tag.select("tr")[3].select("td")[1].text.strip(),
-            "avg_spitter": inf_avg_tag.select("tr")[4].select("td")[1].text.strip(),
-            "avg_jockey": inf_avg_tag.select("tr")[5].select("td")[1].text.strip(),
-            "avg_tank": inf_avg_tag.select("tr")[6].select("td")[1].text.strip(),
-        }
-        sur_dict = {
-            "map_clear": sur_tag.select("tr")[0].select("td")[1].text.strip(),
-            "prefect_into": sur_tag.select("tr")[1].select("td")[1].text.strip(),
-            "get_oil": sur_tag.select("tr")[2].select("td")[1].text.strip(),
-            "ammo_arrange": sur_tag.select("tr")[3].select("td")[1].text.strip(),
-            "adrenaline_give": sur_tag.select("tr")[4].select("td")[1].text.strip(),
-            "pills_give": sur_tag.select("tr")[5].select("td")[1].text.strip(),
-            "first_aid_give": sur_tag.select("tr")[6].select("td")[1].text.strip(),
-            "friend_up": sur_tag.select("tr")[7].select("td")[1].text.strip(),
-            "diss_friend": sur_tag.select("tr")[8].select("td")[1].text.strip(),
-            "save_friend": sur_tag.select("tr")[9].select("td")[1].text.strip(),
-            "protect_friend": sur_tag.select("tr")[10].select("td")[1].text.strip(),
-            "pro_from_smoker": sur_tag.select("tr")[11].select("td")[1].text.strip(),
-            "pro_from_hunter": sur_tag.select("tr")[12].select("td")[1].text.strip(),
-            "pro_from_charger": sur_tag.select("tr")[13].select("td")[1].text.strip(),
-            "pro_from_jockey": sur_tag.select("tr")[14].select("td")[1].text.strip(),
-            "melee_charge": sur_tag.select("tr")[15].select("td")[1].text.strip(),
-            "tank_kill": sur_tag.select("tr")[16].select("td")[1].text.strip(),
-            "witch_instantly_kill": sur_tag.select("tr")[17]
-            .select("td")[1]
-            .text.strip(),
-        }
-        inf_dict = {
-            "sur_ace": inf_tag.select("tr")[0].select("td")[1].text.strip(),
-            "sur_down": inf_tag.select("tr")[1].select("td")[1].text.strip(),
-            "boommer_hit": inf_tag.select("tr")[2].select("td")[1].text.strip(),
-            "hunter_prefect": inf_tag.select("tr")[3].select("td")[1].text.strip(),
-            "hunter_success": inf_tag.select("tr")[4].select("td")[1].text.strip(),
-            "tank_damage": inf_tag.select("tr")[5].select("td")[1].text.strip(),
-            "charger_multiple": inf_tag.select("tr")[6].select("td")[1].text.strip(),
-        }
+        tbody_tags = []
+        if isinstance(tbody, Tag):
+            tbody_tags = tbody.find_all(
+                "table",
+                class_="table content-table-noborder text-left",
+            )
+        if len(tbody_tags) < 6:
+            return None
+
+        info_keys = ["name", "avatar", "steamid", "playtime", "lasttime"]
+        detail_keys = [
+            "rank",
+            "source",
+            "avg_source",
+            "kills",
+            "kills_people",
+            "headshots",
+            "avg_headshots",
+            "map_play",
+        ]
+        error_keys = [
+            "mistake_shout",
+            "kill_friend",
+            "down_friend",
+            "abandon_friend",
+            "put_into",
+            "agitate_witch",
+        ]
+        inf_avg_keys = [
+            "avg_smoker",
+            "avg_boomer",
+            "avg_hunter",
+            "avg_charger",
+            "avg_spitter",
+            "avg_jockey",
+            "avg_tank",
+        ]
+        sur_keys = [
+            "map_clear",
+            "prefect_into",
+            "get_oil",
+            "ammo_arrange",
+            "adrenaline_give",
+            "pills_give",
+            "first_aid_give",
+            "friend_up",
+            "diss_friend",
+            "save_friend",
+            "protect_friend",
+            "pro_from_smoker",
+            "pro_from_hunter",
+            "pro_from_charger",
+            "pro_from_jockey",
+            "melee_charge",
+            "tank_kill",
+            "witch_instantly_kill",
+        ]
+        inf_keys = [
+            "sur_ace",
+            "sur_down",
+            "boommer_hit",
+            "hunter_prefect",
+            "hunter_success",
+            "tank_damage",
+            "charger_multiple",
+        ]
+
+        info_dict = get_table_dict(tbody_tags[0], info_keys)
+        detail_dict = get_table_dict(tbody_tags[1], detail_keys)
+        error_dict = get_table_dict(tbody_tags[2], error_keys)
+        inf_avg_dict = get_table_dict(tbody_tags[3], inf_avg_keys)
+        sur_dict = get_table_dict(tbody_tags[4], sur_keys)
+        inf_dict = get_table_dict(tbody_tags[5], inf_keys)
+
         info_dict = cast(AnnePlayerInfo, info_dict)
-        detail_dict = cast(AnnePlayerDetail, detail_tag)
-        error_dict = cast(AnnePlayerError, error_tag)
+        detail_dict = cast(AnnePlayerDetail, detail_dict)
+        error_dict = cast(AnnePlayerError, error_dict)
         inf_avg_dict = cast(AnnePlayerInfAvg, inf_avg_dict)
         sur_dict = cast(AnnePlayerSur, sur_dict)
         inf_dict = cast(AnnePlayerInf, inf_dict)
 
         out_dict = {
-            "kill_msg": kill_tag.text if kill_tag is not None else "",
+            "kill_msg": kill_tag.text.strip() if kill_tag else "",
             "info": info_dict,
             "detail": detail_dict,
             "inf_avg": inf_avg_dict,

nonebot_plugin_l4d2_server/utils/api/utils.py

@@ -0,0 +1,30 @@
+from typing import Union
+
+from nonebot_plugin_alconna import UniMessage
+
+
+async def out_msg_out(
+    msg: Union[str, bytes, UniMessage],
+    is_connect: bool = False,
+    host: str = "",
+    port: str = "",
+):
+    """
+    统一消息输出函数
+
+    Args:
+        msg: 要输出的消息内容
+        is_connect: 是否为连接消息
+        host: 服务器地址
+        port: 服务器端口
+    """
+    if isinstance(msg, UniMessage):
+        return await msg.finish()
+    if isinstance(msg, str):
+        await UniMessage.text(msg).finish()
+    if is_connect:
+        out = UniMessage.image(raw=msg) + UniMessage.text(
+            f"connect: {host}:{port}",
+        )
+        return await out.finish()
+    return await UniMessage.image(raw=msg).finish()

{nonebot_plugin_l4d2_server-1.0.4.dist-info → nonebot_plugin_l4d2_server-1.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-l4d2-server
-Version: 1.0.4
+Version: 1.0.8
 Summary: L4D2 server related operations plugin for NoneBot2
 Keywords: steam,game,l4d2,nonebot2,plugin
 Author-Email: Agnes_Digital <Z735803792@163.com>
@@ -25,13 +25,13 @@ Requires-Dist: nonebot-plugin-tortoise-orm>=0.1.4
 Requires-Dist: aiohttp>=3.8.4
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: srctools>=2.3.9
-Requires-Dist: httpx<0.24.1,>=0.22.0
+Requires-Dist: httpx>=0.22.0
 Requires-Dist: msgspec>=0.18.0
 Requires-Dist: python-a2s>=1.4.1
 Requires-Dist: ujson>=5.10.0
 Requires-Dist: lxml>=5.2.2
 Requires-Dist: rcon>=2.1.0
-Requires-Dist: pillow>10
+Requires-Dist: pillow>10.0.0
 Requires-Dist: bs4>=0.0.2
 Requires-Dist: rarfile>=4.2
 Requires-Dist: pyunpack>=0.3

{nonebot_plugin_l4d2_server-1.0.4.dist-info → nonebot_plugin_l4d2_server-1.0.8.dist-info}/RECORD

@@ -1,13 +1,13 @@
-nonebot_plugin_l4d2_server-1.0.4.dist-info/METADATA,sha256=kZdrFtRaRtfYjXvIapyyUJnulUxQPjtbzRAOHAVyBkA,6763
-nonebot_plugin_l4d2_server-1.0.4.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-nonebot_plugin_l4d2_server-1.0.4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-nonebot_plugin_l4d2_server-1.0.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-nonebot_plugin_l4d2_server/__init__.py,sha256=PIufOk1bxOx-nYqdoinoB7BcntIETNFwfzqKnmu-teE,1624
-nonebot_plugin_l4d2_server/__main__.py,sha256=Z8laU36rLdNq-Qfroj-1t6dbt4rfKLetvJ1cY937oGo,10232
-nonebot_plugin_l4d2_server/config.py,sha256=_UKAn1g5BbykMNc6LXRujKoGhpxIM5JAdh3z301BLHk,2665
+nonebot_plugin_l4d2_server-1.0.8.dist-info/METADATA,sha256=oxEFgnJzb8aG9Ouh5q6sjIMpF8TabEOpauUXAwyPxxU,6759
+nonebot_plugin_l4d2_server-1.0.8.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+nonebot_plugin_l4d2_server-1.0.8.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+nonebot_plugin_l4d2_server-1.0.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+nonebot_plugin_l4d2_server/__init__.py,sha256=xzhXyprPmoTTjpfyqYlMweC4umuLsm8MERA1ZTqCyYc,1661
+nonebot_plugin_l4d2_server/__main__.py,sha256=Ysx4PkR3kIuSsKM6h9kmPBuylxXsuLjtrOdT1LbQT9A,10511
+nonebot_plugin_l4d2_server/config.py,sha256=t4BYygrrLTcsl9oBnyce0-tDhMCCkMrkEPs4DX2t4KI,2682
 nonebot_plugin_l4d2_server/data/font/loli.ttf,sha256=Yrh-RPoCrn1-NG94DR0x20ASXYUt8g3Ep6BCt3CdOFk,11125812
-nonebot_plugin_l4d2_server/l4_help/Help.json,sha256=hz_k-qmGmGJKwCa8wmkHTLzXu6C-G-E_g7xdK-t6fNk,2673
-nonebot_plugin_l4d2_server/l4_help/__init__.py,sha256=sZRp6HJE2hvEcSST7CXJk8eAyv6rj4kLIcOK_7xUTI0,1535
+nonebot_plugin_l4d2_server/l4_help/Help.json,sha256=D0YmZYGW-imC7nVebkQ0_eODiqevQhL9aKj-cyBaqDY,1704
+nonebot_plugin_l4d2_server/l4_help/__init__.py,sha256=BsrZHgZXEZ0rXNb2mQJF7o3kwDeb05vAXoYwl6znMCc,1479
 nonebot_plugin_l4d2_server/l4_help/draw.py,sha256=y6yDPUnoZFvwly8cf7g9HRpT1JXTxyA9DC1TuvUinTM,6448
 nonebot_plugin_l4d2_server/l4_help/icon/介绍.png,sha256=3QC6A38QC-7gDBxmtQSQdbsz7hsefU5LL-oZmJ41zTk,3806
 nonebot_plugin_l4d2_server/l4_help/icon/任务.png,sha256=nyZ4_kM21ZO95nwanCFnUfCGX-PkmJXYQf9OrJVKomY,3782
@@ -51,11 +51,10 @@ nonebot_plugin_l4d2_server/l4_help/texture2d/bg.jpg,sha256=xTyLJLgo3E-ZH-tupsjZC
 nonebot_plugin_l4d2_server/l4_help/texture2d/button.png,sha256=oQKoRBJDaVXz2eVD-lHkaVcV1aw0ehkNBK8TNSjTehI,12711
 nonebot_plugin_l4d2_server/l4_help/texture2d/icon.png,sha256=A2p0r8aBXpNy_b_CtZTZzTrEeHbGRYzO2fNwahyLlQ0,634659
 nonebot_plugin_l4d2_server/l4_image/__init__.py,sha256=-GWXUDv_z_cfJ-wyvx5J3wB9P7ng4NzRHfCq-GZD6XQ,431
-nonebot_plugin_l4d2_server/l4_image/anne_pil.py,sha256=Q_PHRzB_OgPbRbnLg-asVduV477F1rQnau2DhPOzf5k,500
 nonebot_plugin_l4d2_server/l4_image/convert.py,sha256=MISJq2JFcmQJaYZz6dDjQ2UusVORQt7rLSoAY_CyyWY,3894
 nonebot_plugin_l4d2_server/l4_image/download.py,sha256=qRAo0Ggj5KV8RQN3LFJe547__wwC7Ww4QnT-v3pfe6w,3116
-nonebot_plugin_l4d2_server/l4_image/html_img.py,sha256=P4UJO-7Uf77ECePjM6bSWcOvYRrfZ0BBlG7PLARyrF8,3387
-nonebot_plugin_l4d2_server/l4_image/image_tools.py,sha256=rooAmk_3QXSmteORtD-yAvsNXXWcNI9l-b1NBoKlnsI,14513
+nonebot_plugin_l4d2_server/l4_image/html_img.py,sha256=BE_GQ67KRCb-r_iaVOLPAEoloNvOA9bbxhc8o8WhLXc,2882
+nonebot_plugin_l4d2_server/l4_image/image_tools.py,sha256=iHkvG2fYxYCz7B2JV69MSMlH5KXyWftcBs_prmyTyO4,14453
 nonebot_plugin_l4d2_server/l4_image/img/anne/anne.html,sha256=8JOUXoWdulhoP2Axy_omuSDafbduKDZ9Y8Rz2VZWTso,1590
 nonebot_plugin_l4d2_server/l4_image/img/anne/back.png,sha256=jnsYjnvd2BFcdkdsW8HgcSloWF0ZliPkqlWSIDnFUxw,245488
 nonebot_plugin_l4d2_server/l4_image/img/anne/back1.jpg,sha256=hAzPHflbf4db5S3rM5xn-1wnDP8xZExikYmkKW5c4w0,113622
@@ -84,14 +83,15 @@ nonebot_plugin_l4d2_server/l4_image/img/template/vue.css,sha256=2sGjCFrR-3tFMB_x
 nonebot_plugin_l4d2_server/l4_image/img/template/w.svg,sha256=LnctC2mVwjdhRMiS9ffrjUX-9KGwqb6OMmpJXvVXl70,486
 nonebot_plugin_l4d2_server/l4_image/model.py,sha256=FGsCvf_BKbRNJUVy6I5BKnArMY-3JEIdqeX2gs93E5o,231
 nonebot_plugin_l4d2_server/l4_image/vtfs.py,sha256=He_7zzEIOip8MXP55TS7aWPbzo6ac0wPf602nN3GWZM,1461
-nonebot_plugin_l4d2_server/l4_local/__init__.py,sha256=nz9KUxmuvRrryHakQQ4B30oC9jeGWZ3sON1tCKb-lS0,3603
+nonebot_plugin_l4d2_server/l4_local/__init__.py,sha256=B4E30jX4733M4eNCJvIQhsN4M0nlxLezSXMSwUYLRIk,3581
 nonebot_plugin_l4d2_server/l4_local/file.py,sha256=hew1Y8kV3uSZvUGplmi09EGKC89-sUJWsWV7SCEstI8,3067
-nonebot_plugin_l4d2_server/l4_request/__init__.py,sha256=9Yo6mQ_bIBvMwQubC3Ctie6H2Qzx7ScwCQyVS9y25TE,11682
-nonebot_plugin_l4d2_server/l4_request/draw_msg.py,sha256=koAVWrsDoLCTmwXY-NJTi5yjL1y1ND3daFkDWccQjcU,8071
-nonebot_plugin_l4d2_server/l4_request/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nonebot_plugin_l4d2_server/l4_request/__init__.py,sha256=OrwOyucW-DyKVDk8LRA24h0gQIyzmhWbG73DG3O2JgM,7499
+nonebot_plugin_l4d2_server/l4_request/draw_msg.py,sha256=KpSfl6ZLaxPbax0SgO07niJloeMARuQJ2T-F_XeH6uQ,8108
+nonebot_plugin_l4d2_server/l4_request/utils.py,sha256=7E_Cqp4UcKjrnGBn0gbs5nGiC37RAKmUBJx7qEaXi6Q,5166
 nonebot_plugin_l4d2_server/utils/api/api.py,sha256=auvDicCEKwvnm6EJYeCxCtugFby61K-zAmmaRWWEwtM,296
 nonebot_plugin_l4d2_server/utils/api/models.py,sha256=p-hoxPHwadTaMRb2hqwfbaQ3pvJySrV8VbBmhA0Oi-M,2391
-nonebot_plugin_l4d2_server/utils/api/request.py,sha256=aAsXtxvm7erXLfFCbs6NmsZCRGpsg3tsMdWvSn8SkNU,15575
+nonebot_plugin_l4d2_server/utils/api/request.py,sha256=JGAhMgPgmy2Z2w7w3GVlUGKBmxlaTTDD3bq1T2dhHIE,13567
+nonebot_plugin_l4d2_server/utils/api/utils.py,sha256=rdrFK3VKP59KfNX-C8v0Q_IV3tBLm02Wo9axLTQQ87Y,762
 nonebot_plugin_l4d2_server/utils/database/models.py,sha256=SLdcgwsn39r_ZkcBoqf4MLX1EfpCOjGBwWcR16u9Bqo,454
 nonebot_plugin_l4d2_server/utils/utils.py,sha256=TD3cUCxmmj2GPmK1sQwP7NtkIXNO2FpuXjymaUqBDYo,6141
-nonebot_plugin_l4d2_server-1.0.4.dist-info/RECORD,,
+nonebot_plugin_l4d2_server-1.0.8.dist-info/RECORD,,

nonebot_plugin_l4d2_server/l4_image/anne_pil.py

@@ -1,18 +0,0 @@
-from pathlib import Path
-
-from PIL import Image, ImageFont
-
-from nonebot_plugin_l4d2_server.utils.api.models import AnnePlayer2
-
-from ..config import config
-
-font = ImageFont.truetype(config.l4_font)
-
-anne_path = Path(__file__).parent / "img" / "anne"
-
-
-async def anne_player_info(msg: AnnePlayer2):  # noqa: RUF029
-    back_img = Image.open(anne_path / "back1.jpg")
-    base_img = Image.new("RGBA", (back_img.size), (255, 255, 255, 50))
-    back_img.paste(base_img, (0, 0), base_img)
-    return msg