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

nonebot_plugin_l4d2_server/l4_request/__init__.py

@@ -1,11 +1,12 @@
 import random
-from typing import Dict, List, Optional, cast
+from typing import Dict, List, Optional, Tuple, Union, 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 ..utils.api.models import AllServer, NserverOut, OutServer
+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
@@ -23,6 +24,16 @@ COMMAND = set()
 
 
 async def get_all_server_detail():
+    """
+    获取所有服务器的详细信息。
+
+    Args:
+        无
+
+    Returns:
+        str: 包含所有服务器详细信息的字符串。
+
+    """
     out_list: List[AllServer] = []
     for group in ALLHOST:
         msg_list = await get_group_detail(group)
@@ -58,40 +69,138 @@ async def get_all_server_detail():
 
 
 async def get_server_detail(
-    command: str,
+    command: str = "",
     _id: Optional[str] = None,
     is_img: bool = True,
 ):
-    server_json = ALLHOST.get(command)
+    """
+    异步获取服务器详细信息。
+
+    Args:
+        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。
+    """
+    server_json = _get_server_json(command)
     logger.info(server_json)
     if server_json is None:
         logger.warning("未找到这个组")
         return None
 
     if _id is None:
-        # 输出组信息
-        logger.info(f"正在请求组服务器信息 {command}")
-        server_dict = await get_much_server(server_json, command)
-        if is_img:
-            out_msg = await msg_to_image(server_dict)
-        else:
-            out_msg = server_dict
-        return out_msg
+        return await _handle_group_info(server_json, command, is_img)
 
-    # 返回单个
-    logger.info("正在请求单服务器信息")
-    out_msg = ""
+    _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
+
+
+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"]):
-            out_msg = await draw_one_ip(i["host"], i["port"])
-            if is_img:
-                return cast(bytes, out_msg)
-            if not is_img:
-                return cast(List[OutServer], out_msg)
-    # print(out_msg)
+            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,
 ):
@@ -116,98 +225,139 @@ def reload_ip():
     # print("正在读取json文件")
     group_ip = []
     for item in server_all_path.iterdir():
-        if item.is_file():
-            if item.name.endswith("json"):
-                json_data = json.loads(item.read_text(encoding="utf-8"))
-                group_server = cast(Dict[str, List[NserverOut]], json_data)
-
-                for group, group_ip in group_server.items():
-                    # 处理ip,host,port关系
-                    for one_ip in group_ip:
-                        if one_ip.get("ip"):
-                            if one_ip.get("host") and one_ip.get("port"):
-                                pass
-                            if one_ip.get("host") and not one_ip.get("port"):
-                                one_ip["port"] = 20715
-                            if not one_ip.get("host"):
-                                one_ip["host"], one_ip["port"] = split_maohao(
-                                    one_ip.get("ip"),
-                                )
-                        else:
-                            if one_ip.get("host") and one_ip.get("port"):
-                                one_ip["ip"] = f'{one_ip["host"]}:{one_ip["port"]}'
-                            if one_ip.get("host") and not one_ip.get("port"):
-                                one_ip["ip"] = f'{one_ip["host"]}:20715'
-                            else:
-                                logger.warning(f"{one_ip} 没有ip")
+        if item.is_file() and item.name.endswith("json"):
+            json_data = json.loads(item.read_text(encoding="utf-8"))
+            group_server = cast(Dict[str, List[NserverOut]], json_data)
 
-                    ALLHOST.update({group: group_ip})
-                    COMMAND.add(group)
-                logger.success(f"成功加载 {item.name.split('.')[0]} {len(group_ip)}个")
+            for group, group_ip in group_server.items():
+                # 处理ip,host,port关系
+                for one_ip in group_ip:
+                    if one_ip.get("ip"):
+                        if one_ip.get("host") and one_ip.get("port"):
+                            pass
+                        if one_ip.get("host") and not one_ip.get("port"):
+                            one_ip["port"] = 20715
+                        if not one_ip.get("host"):
+                            one_ip["host"], one_ip["port"] = split_maohao(
+                                one_ip.get("ip"),
+                            )
+                    else:
+                        if one_ip.get("host") and one_ip.get("port"):
+                            one_ip["ip"] = f'{one_ip["host"]}:{one_ip["port"]}'
+                        if one_ip.get("host") and not one_ip.get("port"):
+                            one_ip["ip"] = f'{one_ip["host"]}:20715'
+                        else:
+                            logger.warning(f"{one_ip} 没有ip")
 
-            if item.name.endswith("txt"):
-                """to do"""
+                ALLHOST.update({group: group_ip})
+                COMMAND.add(group)
+            logger.success(f"成功加载 {item.name.split('.')[0]} {len(group_ip)}个")
 
 
 async def tj_request(command: str = "云", tj="tj"):
+    map_type = "普通药役"
     server_json = ALLHOST.get(command)
     logger.info(server_json)
     if server_json is None:
         logger.warning("未找到这个组")
         return None
-    # 返回单个
-    logger.info("正在anne电信服务器信息")
+
+    logger.info("正在获取电信服务器信息")
     player_msg = ""
     right_ip = []
-    for i in server_json:
-        ser_list = await L4API.a2s_info([(i["host"], i["port"])], is_player=True)
+
+    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)
+
+        if not right_ip:
+            logger.warning("没有找到符合条件的服务器")
+            return "没有符合条件的服务器"
+
+        logger.info(
+            f"符合条件的服务器列表: {[f'{ip['host']}:{ip['port']}' for ip in right_ip]}",
+        )
+        s = random.choice(right_ip)
+        logger.info(f"最终选择的服务器: {s['host']}:{s['port']}")
+        ser_list = await L4API.a2s_info([(s["host"], s["port"])], is_player=True)
+        if not ser_list:
+            return "获取服务器信息失败"
+
         one_server = ser_list[0][0]
         one_player = ser_list[0][1]
 
-        # 判断坐牢条件
-        if tj == "tj" and "普通药役" in one_server.map_name:
-            score: int = 0
-            for index, player in enumerate(one_player, 1):
-                if index > 4:
-                    break
-                score += player.score
-
-            t = one_server.map_name.split("[")[-1].split("特")[0]
-            if int(t) * 50 < score:
-                right_ip.append(i)
-        if tj == "zl" and "普通药役" in one_server.map_name and len(one_player) <= 4:
-            right_ip.append(i)
-
-    if not right_ip:
-        return "没有符合条件的服务器"
-
-    s = random.choice(right_ip)
-    ser_list = await L4API.a2s_info([(s["host"], s["port"])], is_player=True)
-    one_server = ser_list[0][0]
-    one_player = ser_list[0][1]
-    if len(one_player):
-        max_duration_len = max(
-            [len(str(await convert_duration(i.duration))) for i in one_player],
-        )
-        max_score_len = max(len(str(i.score)) for i in one_player)
-
-        for player in one_player:
-            soc = "[{:>{}}]".format(player.score, max_score_len)
-            chines_dur = await convert_duration(player.duration)
-            dur = "{:^{}}".format(chines_dur, max_duration_len)
-            name = f"{player.name[0]}***{player.name[-1]}"
-            player_msg += f"{soc} | {dur} | {name} \n"
-    else:
-        player_msg = "服务器感觉很安静啊"
-    msg = f"""*{one_server.server_name}*
-游戏: {one_server.folder}
-地图: {one_server.map_name}
-人数: {one_server.player_count}/{one_server.max_players}"""
-    if one_server.ping is not None:
-        msg += f"""
-ping: {one_server.ping * 1000:.0f}ms
-{player_msg}"""
-    if config.l4_show_ip:
-        msg += f"""
-connect {s["host"]}:{s["port"]}"""
-    return msg
+        if one_player:
+            player_msg = await _format_players(one_player)
+        else:
+            player_msg = "服务器感觉很安静啊"
+
+        return _build_message(one_server, player_msg, s)
+
+    except Exception as e:
+        logger.error(f"tj_request error: {e}")
+        return "获取服务器信息时出错"

nonebot_plugin_l4d2_server/l4_request/draw_msg.py

@@ -1,56 +1,193 @@
 import asyncio
 
 # from logging import log
+import io
+from pathlib import Path
 from typing import List, Tuple
 
+from nonebot.log import logger
+from PIL import Image, ImageDraw, ImageFont
+
 from ..config import config
 from ..utils.api.models import NserverOut, OutServer
 from ..utils.api.request import L4API
 
 
-async def draw_one_ip(host: str, port: int):
+async def draw_one_ip(host: str, port: int, is_img: bool = config.l4_image):
     """输出单个ip"""
-    # 先用文字凑合
     try:
         ser_list = await L4API.a2s_info([(host, port)], is_player=True)
     except asyncio.exceptions.TimeoutError:
         return "服务器无响应"
-    player_msg = ""
     one_server = ser_list[0][0]
     one_player = ser_list[0][1]
 
-    if len(one_player):
-        max_duration_len = max(
-            [len(str(await convert_duration(i.duration))) for i in one_player],
-        )
-        max_score_len = max(len(str(i.score)) for i in one_player)
-
-        for player in one_player:
-            soc = "[{:>{}}]".format(player.score, max_score_len)
-            chines_dur = await convert_duration(player.duration)
-            dur = "{:^{}}".format(chines_dur, max_duration_len)
-            name_leg = len(player.name)
-            if name_leg > 2:
-                # xing = "*" * (name_leg - 2)
-                name = f"{player.name[0]}xing{player.name[-1]}"
-            else:
-                name = player.name
-            player_msg += f"{soc} | {dur} | {name} \n"
-    else:
-        player_msg = "服务器感觉很安静啊"
-
-    msg = f"""*{one_server.server_name}*
-游戏: {one_server.folder}
-地图: {one_server.map_name}
-人数: {one_server.player_count}/{one_server.max_players}"""
-    if one_server.ping is not None:
-        msg += f"""
-ping: {one_server.ping * 1000:.0f}ms
-{player_msg}"""
-    if config.l4_show_ip:
-        msg += f"""
+    async def format_player_info(players: list) -> str:
+        """格式化玩家信息
+        Args:
+            players: 玩家对象列表
+        Returns:
+            格式化后的玩家信息字符串
+        """
+        player_msg = ""
+        if len(players):
+            max_duration_len = max(
+                [len(str(await convert_duration(i.duration))) for i in players],
+            )
+            max_score_len = max(len(str(i.score)) for i in players)
+
+            for player in players:
+                soc = "[{:>{}}]".format(player.score, max_score_len)
+                chines_dur = await convert_duration(player.duration)
+                dur = "{:^{}}".format(chines_dur, max_duration_len)
+                name_leg = len(player.name)
+                if name_leg > 2:
+                    xing = ":)" * (name_leg - 2)
+                    name = f"{player.name[0]}{xing}{player.name[-1]}"
+                else:
+                    name = player.name
+                player_msg += f"{soc} | {dur} | {name} \n"
+        else:
+            player_msg = "服务器感觉很安静啊"
+        return player_msg
+
+    def build_server_message(server, player_info: str) -> str:
+        """构建服务器信息消息
+        Args:
+            server: 服务器对象
+            player_info: 格式化后的玩家信息字符串
+        Returns:
+            完整的服务器信息字符串
+        """
+        msg = f"""-{server.server_name}-
+游戏: {server.folder}
+地图: {server.map_name}
+人数: {server.player_count}/{server.max_players}"""
+        if server.ping is not None:
+            msg += f"""
+ping: {server.ping * 1000:.0f}ms
+{player_info}"""
+        if config.l4_show_ip:
+            msg += f"""
 connect {host}:{port}"""
-    return msg
+        return msg
+
+    def draw_text_on_image(
+        text: str,
+        font: ImageFont.FreeTypeFont,
+        draw: ImageDraw.ImageDraw,
+    ) -> Image.Image:
+        """在图片上绘制文本
+        Args:
+            text: 要绘制的文本
+            font: PIL字体对象
+            draw: PIL绘图对象
+        Returns:
+            包含绘制文本的PIL图片对象
+        """
+        try:
+            # 分割文本为标题行和内容行
+            lines = text.split("\n")
+            if not lines:
+                return Image.new("RGB", (600, 400), color=(73, 109, 137))
+
+            title = lines[0]
+            content = "\n".join(lines[1:]) if len(lines) > 1 else ""
+
+            # 计算各部分文字尺寸
+            title_bbox = font.getbbox(title)
+            title_width = title_bbox[2] - title_bbox[0]
+            title_height = title_bbox[3] - title_bbox[1]
+
+            content_width = 0
+            content_height = 0
+            if content:
+                content_lines = content.split("\n")
+                line_height = font.getbbox("A")[3] - font.getbbox("A")[1]
+                content_height = len(content_lines) * line_height
+                content_width = max(
+                    font.getbbox(line)[2] - font.getbbox(line)[0]
+                    for line in content_lines
+                )
+
+            # 计算图片尺寸
+            margin = 20
+            line_spacing = 5
+            img_width = max(title_width, content_width) + 2 * margin
+            content_lines_count = len(content.split("\n")) if content else 0
+            img_height = max(
+                title_height
+                + content_height
+                + (line_spacing + 1) * max(0, content_lines_count - 1)
+                + 2 * margin,
+                300,
+            )
+
+            # 加载背景图片
+            bg_path = (
+                Path(__file__).parent.parent / "l4_image" / "img" / "anne" / "back.png"
+            )
+            try:
+                img = Image.open(bg_path)
+                # 调整背景图尺寸
+                img = img.resize((int(img_width), int(img_height)))
+                logger.info(f"图片像素大小: {img.width}x{img.height}")
+                draw = ImageDraw.Draw(img)
+
+                title_x = (img_width - title_width) // 2
+                title_y = margin
+                draw.text((title_x, title_y), title, font=font, fill=(255, 255, 255))
+
+                if content:
+                    content_x = margin
+                    content_y = title_y + title_height + margin
+                    draw.text(
+                        (content_x, content_y),
+                        content,
+                        font=font,
+                        fill=(255, 255, 255),
+                        spacing=line_spacing,
+                    )
+
+                    return img
+            except Exception as e:
+                logger.error(f"加载背景图片失败: {e}")
+                img = Image.new(
+                    "RGB",
+                    (int(img_width), int(img_height)),
+                    color=(73, 109, 137),
+                )
+                draw = ImageDraw.Draw(img)
+                draw.text((title_x, title_y), title, font=font, fill=(255, 255, 255))
+                if content:
+                    draw.text(
+                        (content_x, content_y),
+                        content,
+                        font=font,
+                        fill=(255, 255, 255),
+                        spacing=line_spacing,
+                    )
+                return img
+        except Exception as e:
+            logger.error(f"绘制图片时出错: {e}")
+            error_img = Image.new("RGB", (600, 400), color=(255, 0, 0))
+            error_draw = ImageDraw.Draw(error_img)
+            error_draw.text((10, 10), "图片生成失败", fill=(255, 255, 255))
+            return error_img
+
+    player_info = await format_player_info(one_player)
+    server_message = build_server_message(one_server, player_info)
+
+    if is_img:
+        # 加载字体
+        font_path = Path(__file__).parent.parent / "data" / "font" / "loli.ttf"
+        font = ImageFont.truetype(str(font_path), 18)
+        draw = ImageDraw.Draw(Image.new("RGB", (600, 400), color=(73, 109, 137)))
+        img = draw_text_on_image(server_message, font, draw)
+        img_byte_arr = io.BytesIO()
+        img.save(img_byte_arr, format="PNG")
+        return img_byte_arr.getvalue()
+    return server_message
 
 
 async def get_much_server(server_json: List[NserverOut], command: str):
@@ -64,7 +201,7 @@ async def get_much_server(server_json: List[NserverOut], command: str):
     for index, i in enumerate(all_server):
         out_server.append(
             {
-                "server": i[0],
+                "server": i[0],  # type: ignore
                 "player": i[1],
                 "host": server_json[index]["host"],
                 "port": server_json[index]["port"],
@@ -77,6 +214,12 @@ async def get_much_server(server_json: List[NserverOut], command: str):
 
 
 async def convert_duration(duration: float) -> str:
+    """Convert duration in seconds to human-readable string format (e.g. '1h 30m 15s')
+    Args:
+        duration: Duration in seconds
+    Returns:
+        Formatted time string
+    """
     minutes, seconds = divmod(duration, 60)
     hours, minutes = divmod(minutes, 60)
     time_str = ""

nonebot_plugin_l4d2_server/utils/api/models.py

@@ -22,7 +22,7 @@ class NserverOut(TypedDict):
 
 
 class OutServer(TypedDict):
-    server: a2s.SourceInfo
+    server: a2s.SourceInfo[str]
     player: List[a2s.Player]
     host: str
     port: int