添加巨大多东西

Reviewed-on: #22

.dockerignore

@@ -1,4 +1,5 @@
 /.env
 /.git
+/data
 
 __pycache__

.drone.yml

@@ -26,6 +26,14 @@ steps:
     volumes:
       - name: docker-socket
         path: /var/run/docker.sock
+  - name: 在容器中测试插件加载
+    image: docker:dind
+    privileged: true
+    volumes:
+      - name: docker-socket
+        path: /var/run/docker.sock
+    commands:
+      - docker run --rm gitea.service.jazzwhom.top/mttu-developers/konabot:nightly-${DRONE_COMMIT_SHA} python scripts/test_plugin_load.py
 
 volumes:
   - name: docker-socket

.env.test

@@ -0,0 +1,4 @@
+ENVIRONMENT=test
+ENABLE_CONSOLE=false
+ENABLE_QQ=false
+ENABLE_DISCORD=false

.gitignore

@@ -1,3 +1,4 @@
 /.env
+/data
 
 __pycache__

Dockerfile

@@ -4,5 +4,11 @@ WORKDIR /app
 COPY requirements.txt ./
 RUN pip install -r requirements.txt --no-deps
 
-COPY . .
+COPY bot.py pyproject.toml .env.prod .env.test ./
+COPY assets ./assets
+COPY scripts ./scripts
+COPY konabot ./konabot
+
+ENV PYTHONPATH=/app
+
 CMD [ "python", "bot.py" ]

konabot/common/nb/extract_image.py

@@ -0,0 +1,135 @@
+from io import BytesIO
+
+import httpx
+import PIL.Image
+from loguru import logger
+from nonebot.adapters import Bot, Event, Message
+from nonebot.adapters.discord import Bot as DiscordBot
+from nonebot.adapters.onebot.v11 import Bot as OnebotV11Bot
+from nonebot.adapters.onebot.v11 import Message as OnebotV11Message
+from nonebot.adapters.onebot.v11 import MessageEvent as OnebotV11MessageEvent
+from nonebot_plugin_alconna import Image, RefNode, Reply, UniMessage
+from PIL import UnidentifiedImageError
+from returns.result import Failure, Result, Success
+
+
+async def download_image_bytes(url: str) -> Result[bytes, str]:
+    # if "/matcha/cache/" in url:
+    #     url = url.replace('127.0.0.1', '10.126.126.101')
+    logger.debug(f"开始从 {url} 下载图片")
+    async with httpx.AsyncClient() as c:
+        try:
+            response = await c.get(url)
+        except (httpx.ConnectError, httpx.RemoteProtocolError) as e:
+            return Failure(f"HTTPX 模块下载图片时出错：{e}")
+        except httpx.ConnectTimeout:
+            return Failure("下载图片失败了，网络超时了qwq")
+        if response.status_code != 200:
+            return Failure("无法下载图片，可能存在网络问题需要排查")
+        return Success(response.content)
+
+
+def bytes_to_pil(raw_data: bytes | BytesIO) -> Result[PIL.Image.Image, str]:
+    try:
+        if not isinstance(raw_data, BytesIO):
+            img_pil = PIL.Image.open(BytesIO(raw_data))
+        else:
+            img_pil = PIL.Image.open(raw_data)
+        img_pil.verify()
+        if not isinstance(raw_data, BytesIO):
+            img = PIL.Image.open(BytesIO(raw_data))
+        else:
+            raw_data.seek(0)
+            img = PIL.Image.open(raw_data)
+        return Success(img)
+    except UnidentifiedImageError:
+        return Failure("图像无法读取，可能是格式不支持orz")
+    except IOError:
+        return Failure("图像无法读取，可能是网络存在问题orz")
+
+
+async def unimsg_img_to_pil(image: Image) -> Result[PIL.Image.Image, str]:
+    if image.url is not None:
+        raw_result = await download_image_bytes(image.url)
+    elif image.raw is not None:
+        raw_result = Success(image.raw)
+    else:
+        return Failure("由于一些内部问题，下载图片失败了orz")
+
+    return raw_result.bind(bytes_to_pil)
+
+
+async def extract_image_from_qq_message(
+    msg: OnebotV11Message,
+    evt: OnebotV11MessageEvent,
+    bot: OnebotV11Bot,
+    allow_reply: bool = True,
+) -> Result[PIL.Image.Image, str]:
+    if allow_reply and (reply := evt.reply) is not None:
+        return await extract_image_from_qq_message(
+            reply.message,
+            evt,
+            bot,
+            False,
+        )
+    for seg in msg:
+        if seg.type == "reply" and allow_reply:
+            msgid = seg.data.get("id")
+            if msgid is None:
+                return Failure("消息可能太久远，无法读取到消息原文")
+            try:
+                msg2 = await bot.get_msg(message_id=msgid)
+            except Exception as e:
+                logger.warning(f"获取消息内容时出错：{e}")
+                return Failure("消息可能太久远，无法读取到消息原文")
+            msg2_data = msg2.get("message")
+            if msg2_data is None:
+                return Failure("消息可能太久远，无法读取到消息原文")
+            logger.debug("发现消息引用，递归一层")
+            return await extract_image_from_qq_message(
+                msg=OnebotV11Message(msg2_data),
+                evt=evt,
+                bot=bot,
+                allow_reply=False,
+            )
+        if seg.type == "image":
+            url = seg.data.get("url")
+            if url is None:
+                return Failure("无法下载图片，可能有一些网络问题")
+            data = await download_image_bytes(url)
+            return data.bind(bytes_to_pil)
+
+    return Failure("请在消息中包含图片，或者引用一个含有图片的消息")
+
+
+async def extract_image_from_message(
+    msg: Message,
+    evt: Event,
+    bot: Bot,
+    allow_reply: bool = True,
+) -> Result[PIL.Image.Image, str]:
+    if (
+        isinstance(bot, OnebotV11Bot) 
+        and isinstance(msg, OnebotV11Message) 
+        and isinstance(evt, OnebotV11MessageEvent)
+    ):
+        # 看起来 UniMessage 在这方面能力似乎不足，因此用 QQ 的
+        logger.debug('获取图片的路径 Fallback 到 QQ 模块')
+        return await extract_image_from_qq_message(msg, evt, bot, allow_reply)
+
+    for seg in UniMessage.of(msg, bot):
+        logger.info(seg)
+        if isinstance(seg, Image):
+            return await unimsg_img_to_pil(seg)
+        elif isinstance(seg, Reply) and allow_reply:
+            msg2 = seg.msg
+            logger.debug(f"深入搜索引用的消息：{msg2}")
+            if msg2 is None or isinstance(msg2, str):
+                continue
+            return await extract_image_from_message(msg2, evt, bot, False)
+        elif isinstance(seg, RefNode) and allow_reply:
+            if isinstance(bot, DiscordBot):
+                return Failure("暂时不支持在 Discord 中通过引用的方式获取图片")
+            else:
+                return Failure("暂时不支持在这里中通过引用的方式获取图片")
+    return Failure("请在消息中包含图片，或者引用一个含有图片的消息")

konabot/common/nb/is_admin.py

@@ -0,0 +1,34 @@
+from nonebot import get_plugin_config
+import nonebot
+import nonebot.adapters
+import nonebot.adapters.console
+import nonebot.adapters.discord
+import nonebot.adapters.onebot
+from pydantic import BaseModel
+
+
+class IsAdminConfig(BaseModel):
+    admin_qq_group: list[int] = []
+    admin_qq_account: list[int] = []
+    admin_discord_channel: list[int] = []
+    admin_discord_account: list[int] = []
+
+cfg = get_plugin_config(IsAdminConfig)
+
+
+def is_admin(event: nonebot.adapters.Event):
+    if isinstance(event, nonebot.adapters.onebot.v11.MessageEvent):
+        if event.user_id in cfg.admin_qq_account:
+            return True
+        if isinstance(event, nonebot.adapters.onebot.v11.GroupMessageEvent):
+            if event.group_id in cfg.admin_qq_group:
+                return True
+    if isinstance(event, nonebot.adapters.discord.event.MessageEvent):
+        if event.channel_id in cfg.admin_discord_channel:
+            return True
+        if event.user_id in cfg.admin_discord_account:
+            return True
+    if isinstance(event, nonebot.adapters.console.event.Event):
+        return True
+
+    return False

konabot/common/path.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+ASSETS_PATH = Path(__file__).resolve().parent.parent.parent / "assets"
+FONTS_PATH = ASSETS_PATH / "fonts"
+
+SRC_PATH = Path(__file__).resolve().parent.parent
+
+DOCS_PATH = SRC_PATH / "docs"
+DOCS_PATH_MAN1 = DOCS_PATH / "user"
+DOCS_PATH_MAN3 = DOCS_PATH / "lib"
+DOCS_PATH_MAN7 = DOCS_PATH / "concepts"
+DOCS_PATH_MAN8 = DOCS_PATH / "sys"

konabot/docs/README.md

@@ -0,0 +1,40 @@
+# 此方 Bot 的文档系统
+
+此方 Bot 使用类 Linux 的 `man` 指令来管理文档。文档一般建议使用纯文本书写，带有相对良好的格式。
+
+## 文件夹摆放规则
+
+`docs` 目录下，有若干文档可以拿来阅读和输出。每个子文件夹里，文档文件使用名字不含空格的 txt 文件书写，其他后缀名的文件将会被忽略。所以，如果你希望有些文件只在代码库中可阅读，你可以使用 `.md` 格式。
+
+### 1 - user
+
+`docs/user` 目录下的文档是直接会给用户进行检索的文档，在直接使用 `man` 指令时，会搜索该文件夹的全部文件，以知晓所有有文档的指令。
+
+### 3 - lib
+
+`docs/lib` 目录下的文档主要给该项目的维护者进行阅读和使用，讲述的是本项目内置的一些函数的功能讲解（一般以便利为主要目的）以及一些项目安排上的要求。一般不会列举，除非用户指定要求列举该范围。
+
+### 7 - concepts
+
+`docs/concepts` 用来摆放任何的概念。任何的。一般不会列举，除非用户指定要求列举该范围。
+
+### 8 - sys
+
+`docs/sys` 用于摆放仅 MTTU 群可以使用的文档集合。在 MTTU 群内，该目录下的文档也会被索引，否则文档将不可阅读。
+
+## 书写规范
+
+无特殊要求，因为当用户进行 `man` 的时候，会将文档内的内容原封不动地展示出来。但是，你仍然可以模仿 Linux 下的 `man` 指令的格式进行书写。
+
+```
+指令介绍
+    man - 用于展示此方 BOT 使用手册的指令
+
+格式
+    man [文档类型] <指令>
+
+示例
+    `man` 查看所有有文档的指令清单
+    `man 喵` 查看指令「喵」的使用说明
+……
+```

konabot/docs/lib/is_admin.txt

@@ -0,0 +1,45 @@
+指令介绍
+    is_admin - 用于判断当前事件是否来自管理员的内部权限校验函数
+
+格式
+    from konabot.common.nb.is_admin import is_admin
+    from nonebot import on
+    from nonebot.adapters import Event
+    from loguru import logger
+
+    @on().handle()
+    async def _(event: Event):
+        if is_admin(event):
+            logger.info("管理员发送了消息")
+
+说明
+    is_admin 是 Bot 内部用于权限控制的核心函数，根据事件来源（QQ、Discord、控制台）及插件配置，判断触发事件的用户或群组是否具有管理员权限。
+
+支持的适配器与判定逻辑：
+    • OneBot V11（QQ）
+        - 若用户 ID 在配置项 admin_qq_account 中，则视为管理员
+        - 若为群聊消息，且群 ID 在配置项 admin_qq_group 中，则视为管理员
+
+    • Discord
+        - 若频道 ID 在配置项 admin_discord_channel 中，则视为管理员
+        - 若用户 ID 在配置项 admin_discord_account 中，则视为管理员
+
+    • Console（控制台）
+        - 所有控制台输入均默认视为管理员操作，自动返回 True
+
+配置项（位于插件配置中）
+    ADMIN_QQ_GROUP: list[int]
+        允许的管理员 QQ 群 ID 列表
+
+    ADMIN_QQ_ACCOUNT: list[int]
+        允许的管理员 QQ 账号 ID 列表
+
+    ADMIN_DISCORD_CHANNEL: list[int]
+        允许的管理员 Discord 频道 ID 列表
+
+    ADMIN_DISCORD_ACCOUNT: list[int]
+        允许的管理员 Discord 用户 ID 列表
+
+注意事项
+    - 若未在配置文件中设置任何管理员 ID，该函数对所有非控制台事件返回 False
+    - 控制台事件始终拥有管理员权限，便于本地调试与运维

konabot/docs/sys/out.txt

@@ -0,0 +1 @@
+MAN what can I say!

konabot/docs/user/man.txt

@@ -0,0 +1,20 @@
+指令介绍
+    man - 用于展示此方 BOT 使用手册的指令
+
+格式
+    man 文档类型
+    man [文档类型] <指令>
+
+示例
+    `man` 查看所有有文档的指令清单
+    `man 3` 列举所有可读文档的库函数清单
+    `man 喵` 查看指令「喵」的使用说明
+    `man 8 out` 查看管理员指令「out」的使用说明
+
+文档类型
+    文档类型用来区分同一指令在不同场景下的情景。你可以使用数字编号进行筛选。分为这些种类：
+
+    - 1 用户态指令，用于日常使用的指令
+    - 3 库函数指令，用于 Bot 开发用的函数查询
+    - 7 概念指令，用于概念解释
+    - 8 系统指令，仅管理员可用

konabot/docs/user/openssl.txt

@@ -0,0 +1,21 @@
+指令介绍
+    openssl - 用于生成指定长度的加密安全随机数据
+
+格式
+    openssl rand <模式> <字节数>
+
+示例
+    `openssl rand -hex 16` 生成 16 字节的十六进制随机数
+    `openssl rand -base64 32` 生成 32 字节并以 Base64 编码输出的随机数据
+
+说明
+    该指令使用 Python 的 secrets 模块生成加密安全的随机字节，并支持以十六进制（-hex）或 Base64（-base64）格式输出。
+
+参数说明
+    模式（mode）
+        - -hex     ：以十六进制字符串形式输出随机数据
+        - -base64  ：以 Base64 编码字符串形式输出随机数据
+
+    字节数（num）
+        - 必须为正整数
+        - 最大支持 256 字节

konabot/docs/user/ytpgif.txt

@@ -0,0 +1,41 @@
+指令介绍
+    ytpgif - 生成来回镜像翻转的仿 YTPMV 动图
+
+格式
+    ytpgif [倍速]
+
+示例
+    `ytpgif`  
+        使用默认倍速（1.0）处理你发送或回复的图片，生成镜像动图。
+
+    `ytpgif 2.5`  
+        以 2.5 倍速处理图片，生成更快节奏的镜像动图。
+
+    回复一张图片并发送 `ytpgif 0.5`  
+        以慢速（0.5 倍）生成镜像动图。
+
+参数说明
+    倍速（可选）
+        - 类型：浮点数
+        - 默认值：1.0
+        - 有效范围：0.1 ～ 20.0
+        - 作用：
+            • 对于静态图：控制镜像切换的快慢（值越大，切换越快）。
+            • 对于动图：控制截取原始动图正向和反向片段的时长（值越大，截取的片段越长）。
+
+使用方式
+    发送指令前，请确保：
+      - 直接在消息中附带一张图片，或
+      - 回复一条包含图片的消息后再发送指令。
+
+    插件会自动：
+      - 下载并识别图片（支持静态图和 GIF 动图）
+      - 自动缩放至最大边长不超过 256 像素（保持宽高比）
+      - 静态图 → 生成“原图↔镜像”循环动图
+      - 动图 → 截取开头一段正向播放 + 同一段镜像翻转播放，拼接成新动图
+      - 保留透明通道（如原图含透明），否则转为 RGB 避免颜色异常
+
+注意事项
+    - 图片过大、格式损坏或网络问题可能导致处理失败。
+    - 动图帧数过多或单帧过短可能无法生成有效输出。
+    - 输出 GIF 最大单段帧数限制为 500 帧，以防资源耗尽。

konabot/docs/user/喵.txt

@@ -0,0 +1,2 @@
+指令介绍
+    喵 - 你发喵，此方就会回复喵

konabot/docs/user/摇数字.txt

@@ -0,0 +1,7 @@
+指令介绍
+    摇数字 - 生成一个随机数字并发送
+
+示例
+    `摇数字` 随机生成一个 1-6 的数字
+
+该指令不接受任何参数，直接调用即可。

konabot/docs/user/摇骰子.txt

@@ -0,0 +1,22 @@
+指令介绍
+    摇骰子 - 用于生成随机数并以骰子图像形式展示的指令
+
+格式
+    摇骰子 [最小值] [最大值]
+
+示例
+    `摇骰子` 随机生成一个 1-6 的数字，并显示对应的骰子图像
+    `摇骰子 10` 生成 1 到 10 之间的随机整数
+    `摇骰子 0.5` 生成 0 到 0.5 之间的随机小数
+    `摇骰子 -5 5` 生成 -5 到 5 之间的随机数
+
+说明
+    该指令支持以下几种调用方式：
+      - 不带参数：使用默认范围生成随机数
+      - 仅指定一个参数 f1：
+          - 若 f1 > 1，则生成 [1, f1] 范围内的随机数
+          - 若 0 < f1 ≤ 1，则生成 [0, f1] 范围内的随机数
+          - 若 f1 ≤ 0，则生成 [f1, 0] 范围内的随机数
+      - 指定两个参数 f1 和 f2：生成 [f1, f2] 范围内的随机数（顺序无关，内部会自动处理大小）
+
+返回结果将以骰子样式的图像形式展示生成的随机数值。

konabot/docs/user/雷达回波.txt

@@ -0,0 +1,13 @@
+指令介绍
+    雷达回波 - 用于获取指定地区的天气雷达回波图像
+
+格式
+    雷达回波 <地区>
+
+示例
+    `雷达回波 华南` 获取华南地区的天气雷达回波图
+    `雷达回波 全国` 获取全国的天气雷达回波图
+
+说明
+    该指令通过查询中国气象局 https://www.nmc.cn/publish/radar/chinaall.html ，获取指定地区的实时天气雷达回波图像。
+    支持的地区有：全国 华北 东北 华东 华中 华南 西南 西北。

konabot/plugins/man/__init__.py

@@ -0,0 +1,104 @@
+from curses.ascii import isdigit
+from pathlib import Path
+
+import nonebot
+import nonebot.adapters
+import nonebot.adapters.discord
+import nonebot.rule
+from nonebot import on_command
+from nonebot_plugin_alconna import Alconna, Args, UniMessage, on_alconna
+
+from konabot.common.nb.is_admin import is_admin
+from konabot.common.path import DOCS_PATH_MAN1, DOCS_PATH_MAN3, DOCS_PATH_MAN7, DOCS_PATH_MAN8
+
+def search_man(section: int) -> dict[tuple[int, str], Path]:
+    base_path = {
+        1: DOCS_PATH_MAN1,
+        3: DOCS_PATH_MAN3,
+        7: DOCS_PATH_MAN7,
+        8: DOCS_PATH_MAN8,
+    }.get(section, DOCS_PATH_MAN1)
+
+    res: dict[tuple[int, str], Path] = {}
+    for fp in base_path.iterdir():
+        if fp.suffix != '.txt':
+            continue
+        name = fp.name.lower().removesuffix('.txt')
+        res[(section, name)] = fp
+    return res
+
+
+man = on_alconna(Alconna(
+    'man',
+    Args['section', int | None],
+    Args['doc', str | None],
+))
+
+@man.handle()
+async def _(
+    section: int | None,
+    doc: str | None,
+    event: nonebot.adapters.Event,
+):
+    if doc is not None and section is None and all(isdigit(c) for c in doc):
+        section = int(doc)
+        doc = None
+
+    if section is not None and section not in {1, 3, 7, 8}:
+        await man.send(
+            UniMessage().text(f"你所指定的文档类型 {section} 不在可用范围内")
+        )
+        return
+
+    if doc is None:
+        # 检索模式
+        if section is None:
+            section_set = {1}
+        else:
+            section_set = {section}
+        if 1 in section_set and is_admin(event):
+            section_set.add(8)
+        mans: list[str] = []
+        for section in section_set:
+            mans += [f"{n}({s})" for s, n in search_man(section).keys()]
+        mans.sort()
+        
+        await man.send(UniMessage().text(
+            (
+                "★此方 BOT 使用帮助★\n"
+                "使用 man <指令名> 查询某个指令的名字\n\n"
+                "可供查询的指令清单："
+            )
+            + ", ".join(mans)
+            + "\n\n例如，使用 man man 来查询 man 指令的使用方法"
+        ))
+    else:
+        # 查阅模式
+        if section is None:
+            section_set = {1}
+        else:
+            section_set = {section}
+        if 1 in section_set and is_admin(event):
+            section_set.add(8)
+        if 8 in section_set and not is_admin(event):
+            await man.send(UniMessage().text("你没有查看该指令类型的权限"))
+            return
+        mans_dict: dict[tuple[int, str], Path] = {}
+        for section in section_set:
+            mans_dict: dict[tuple[int, str], Path] = {**mans_dict, **search_man(section)}
+        mans_dict_2 = {key[1]: val for key, val in mans_dict.items()}
+        mans_fp = mans_dict_2.get(doc.lower())
+        if mans_fp is None:
+            await man.send(UniMessage().text("你所检索的指令不存在"))
+            return
+        mans_msg = mans_fp.read_text('utf-8', 'replace')
+        if isinstance(event, nonebot.adapters.discord.event.MessageEvent):
+            mans_msg = f'```\n{mans_msg}\n```'
+        await man.send(UniMessage().text(mans_msg))
+
+
+help_deprecated = on_command('help', rule=nonebot.rule.to_me())
+
+@help_deprecated.handle()
+async def _():
+    await help_deprecated.send('你可以使用 man 指令来查询此方 BOT 的帮助')

konabot/plugins/memepack/__init__.py

@@ -1,10 +1,19 @@
 from io import BytesIO
+from typing import Iterable, cast
 
-from nonebot_plugin_alconna import (Alconna, Args, Field, MultiVar, UniMessage,
-                                    on_alconna)
+from nonebot import on_message
+from nonebot_plugin_alconna import (Alconna, Args, Field, MultiVar, Text,
+                                    UniMessage, UniMsg, on_alconna)
 
-from konabot.plugins.memepack.drawing.geimao import draw_geimao
-from konabot.plugins.memepack.drawing.pt import draw_pt
+from konabot.common.nb.extract_image import extract_image_from_message
+from konabot.plugins.memepack.drawing.display import draw_cao_display
+from konabot.plugins.memepack.drawing.saying import (draw_cute_ten,
+                                                     draw_geimao, draw_mnk,
+                                                     draw_pt, draw_suan)
+
+from nonebot.adapters import Bot, Event
+
+from returns.result import Success, Failure
 
 geimao = on_alconna(Alconna(
     "给猫说",
@@ -36,3 +45,97 @@ async def _(saying: list[str]):
     img.save(img_bytes, format="PNG")
 
     await pt.send(await UniMessage().image(raw=img_bytes).export())
+
+
+mnk = on_alconna(Alconna(
+    "re:小?黑白子?说",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "你没有写黑白子说了什么"
+    )]
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases={"mnk说"})
+
+@mnk.handle()
+async def _(saying: list[str]):
+    img = await draw_mnk("\n".join(saying))
+    img_bytes = BytesIO()
+    img.save(img_bytes, format="PNG")
+
+    await mnk.send(await UniMessage().image(raw=img_bytes).export())
+
+
+suan = on_alconna(Alconna(
+    "小蒜说",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "你没有写小蒜说了什么"
+    )]
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases=set())
+
+@suan.handle()
+async def _(saying: list[str]):
+    img = await draw_suan("\n".join(saying))
+    img_bytes = BytesIO()
+    img.save(img_bytes, format="PNG")
+
+    await suan.send(await UniMessage().image(raw=img_bytes).export())
+
+
+dsuan = on_alconna(Alconna(
+    "大蒜说",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "你没有写大蒜说了什么"
+    )]
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases=set())
+
+@dsuan.handle()
+async def _(saying: list[str]):
+    img = await draw_suan("\n".join(saying), True)
+    img_bytes = BytesIO()
+    img.save(img_bytes, format="PNG")
+
+    await dsuan.send(await UniMessage().image(raw=img_bytes).export())
+
+
+cutecat = on_alconna(Alconna(
+    "乖猫说",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "你没有写十猫说了什么"
+    )]
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases={"十猫说"})
+
+@cutecat.handle()
+async def _(saying: list[str]):
+    img = await draw_cute_ten("\n".join(saying))
+    img_bytes = BytesIO()
+    img.save(img_bytes, format="PNG")
+
+    await cutecat.send(await UniMessage().image(raw=img_bytes).export())
+
+
+cao_display_cmd = on_message()
+
+@cao_display_cmd.handle()
+async def _(msg: UniMsg, evt: Event, bot: Bot):
+    flag = False
+    for text in cast(Iterable[Text], msg.get(Text)):
+        if text.text.strip() == "小槽展示":
+            flag = True
+        elif text.text.strip() == '':
+            continue
+        else:
+            return
+    if not flag:
+        return
+    match await extract_image_from_message(evt.get_message(), evt, bot):
+        case Success(img):
+            img_handled = await draw_cao_display(img)
+            img_bytes = BytesIO()
+            img_handled.save(img_bytes, format="PNG")
+            await cao_display_cmd.send(await UniMessage().image(raw=img_bytes).export())
+        case Failure(err):
+            await cao_display_cmd.send(
+                await UniMessage()
+                    .at(user_id=evt.get_user_id())
+                    .text(' ')
+                    .text(err)
+                    .export()
+            )

konabot/plugins/memepack/drawing/base/fonts.py

@@ -1,8 +1,8 @@
 from imagetext_py import EmojiOptions, FontDB
 
-from .path import ASSETS
+from konabot.common.path import FONTS_PATH
 
-FontDB.LoadFromDir(str(ASSETS))
+FontDB.LoadFromDir(str(FONTS_PATH))
 
 FontDB.SetDefaultEmojiOptions(EmojiOptions(
     parse_shortcodes=False, 
@@ -10,3 +10,4 @@ FontDB.SetDefaultEmojiOptions(EmojiOptions(
 
 HARMONYOS_SANS_SC_BLACK = FontDB.Query("HarmonyOS_Sans_SC_Black")
 HARMONYOS_SANS_SC_REGULAR = FontDB.Query("HarmonyOS_Sans_SC_Regular")
+LXGWWENKAI_REGULAR = FontDB.Query("LXGWWenKai-Regular")

konabot/plugins/memepack/drawing/base/path.py

@@ -1,3 +0,0 @@
-from pathlib import Path
-
-ASSETS = Path(__file__).parent.parent.parent / "assets"

konabot/plugins/memepack/drawing/display.py

@@ -0,0 +1,45 @@
+import asyncio
+from typing import Any, cast
+
+import cv2
+import numpy as np
+import PIL.Image
+
+from konabot.common.path import ASSETS_PATH
+
+cao_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "caoimg1.png")
+CAO_QUAD_POINTS = np.float32(cast(Any, [
+    [392, 540],
+    [577, 557],
+    [567, 707],
+    [381, 687],
+]))
+
+def _draw_cao_display(image: PIL.Image.Image):
+    src = np.array(image.convert("RGB"))
+    h, w = src.shape[:2]
+    src_points = np.float32(cast(Any, [
+        [0, 0],
+        [w, 0],
+        [w, h],
+        [0, h]
+    ]))
+    dst_points = CAO_QUAD_POINTS
+    M = cv2.getPerspectiveTransform(cast(Any, src_points), cast(Any, dst_points))
+    output_size = cao_image.size
+    output_w, output_h = output_size
+    warped = cv2.warpPerspective(
+        src,
+        M,
+        (output_w, output_h),
+        flags=cv2.INTER_LINEAR,
+        borderMode=cv2.BORDER_CONSTANT,
+        borderValue=(0, 0, 0)
+    )
+    result = PIL.Image.fromarray(warped, 'RGB').convert('RGBA')
+    result = PIL.Image.alpha_composite(result, cao_image)
+    return result
+
+
+async def draw_cao_display(image: PIL.Image.Image):
+    return await asyncio.to_thread(_draw_cao_display, image)

konabot/plugins/memepack/drawing/geimao.py

@@ -1,29 +0,0 @@
-import asyncio
-from typing import Any, cast
-
-import imagetext_py
-import PIL.Image
-
-from .base.fonts import HARMONYOS_SANS_SC_BLACK
-from .base.path import ASSETS
-
-geimao_image = PIL.Image.open(ASSETS / "geimao.jpg").convert("RGBA")
-
-
-def _draw_geimao(saying: str):
-    img = geimao_image.copy()
-    with imagetext_py.Writer(img) as iw:
-        iw.draw_text_wrapped(
-            saying, 960, 50, 00.5, 0, 1920, 240, HARMONYOS_SANS_SC_BLACK,
-            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
-            0.8,
-            imagetext_py.TextAlign.Center,
-            cast(Any, 30.0),
-            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("FFFFFFFF")),
-            draw_emojis=True,
-        )
-    return img
-    
-
-async def draw_geimao(saying: str):
-    return await asyncio.to_thread(_draw_geimao, saying)

konabot/plugins/memepack/drawing/pt.py

@@ -1,26 +0,0 @@
-import asyncio
-
-import imagetext_py
-import PIL.Image
-
-from .base.fonts import HARMONYOS_SANS_SC_REGULAR
-from .base.path import ASSETS
-
-pt_image = PIL.Image.open(ASSETS / "ptsay.png").convert("RGBA")
-
-
-def _draw_pt(saying: str):
-    img = pt_image.copy()
-    with imagetext_py.Writer(img) as iw:
-        iw.draw_text_wrapped(
-            saying, 259, 278, 0.5, 0.5, 360, 48, HARMONYOS_SANS_SC_REGULAR,
-            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
-            1.0,
-            imagetext_py.TextAlign.Center,
-            draw_emojis=True,
-        )
-    return img
-
-
-async def draw_pt(saying: str):
-    return await asyncio.to_thread(_draw_pt, saying)

konabot/plugins/memepack/drawing/saying.py

@@ -0,0 +1,108 @@
+import asyncio
+from typing import Any, cast
+
+import imagetext_py
+import PIL.Image
+
+from konabot.common.path import ASSETS_PATH
+
+from .base.fonts import HARMONYOS_SANS_SC_BLACK, HARMONYOS_SANS_SC_REGULAR, LXGWWENKAI_REGULAR
+
+geimao_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "geimao.jpg").convert("RGBA")
+pt_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "ptsay.png").convert("RGBA")
+mnk_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "mnksay.jpg").convert("RGBA")
+dasuan_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "dss.png").convert("RGBA")
+suan_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "suanleba.png").convert("RGBA")
+cute_ten_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "tententen.png").convert("RGBA")
+
+
+def _draw_geimao(saying: str):
+    img = geimao_image.copy()
+    with imagetext_py.Writer(img) as iw:
+        iw.draw_text_wrapped(
+            saying, 960, 50, 0.5, 0, 1920, 240, HARMONYOS_SANS_SC_BLACK,
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
+            0.8,
+            imagetext_py.TextAlign.Center,
+            cast(Any, 30.0),
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("FFFFFFFF")),
+            draw_emojis=True,
+        )
+    return img
+    
+
+async def draw_geimao(saying: str):
+    return await asyncio.to_thread(_draw_geimao, saying)
+
+
+def _draw_pt(saying: str):
+    img = pt_image.copy()
+    with imagetext_py.Writer(img) as iw:
+        iw.draw_text_wrapped(
+            saying, 259, 278, 0.5, 0.5, 360, 48, HARMONYOS_SANS_SC_REGULAR,
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
+            1.0,
+            imagetext_py.TextAlign.Center,
+            draw_emojis=True,
+        )
+    return img
+
+
+async def draw_pt(saying: str):
+    return await asyncio.to_thread(_draw_pt, saying)
+
+
+def _draw_mnk(saying: str):
+    img = mnk_image.copy()
+    with imagetext_py.Writer(img) as iw:
+        iw.draw_text_wrapped(
+            saying, 540, 25, 0.5, 0, 1080, 120, HARMONYOS_SANS_SC_BLACK,
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
+            0.8,
+            imagetext_py.TextAlign.Center,
+            cast(Any, 15.0),
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("FFFFFFFF")),
+            draw_emojis=True,
+        )
+    return img
+
+
+async def draw_mnk(saying: str):
+    return await asyncio.to_thread(_draw_mnk, saying)
+
+
+def _draw_suan(saying: str, dasuan: bool = False):
+    if dasuan:
+        img = dasuan_image.copy()
+    else:
+        img = suan_image.copy()
+    with imagetext_py.Writer(img) as iw:
+        iw.draw_text_wrapped(
+            saying, 1020, 290, 0.5, 0.5, 400, 48, LXGWWENKAI_REGULAR,
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
+            1.0,
+            imagetext_py.TextAlign.Center,
+            draw_emojis=True,
+        )
+    return img
+
+
+async def draw_suan(saying: str, dasuan: bool = False):
+    return await asyncio.to_thread(_draw_suan, saying, dasuan)
+
+
+def _draw_cute_ten(saying: str):
+    img = cute_ten_image.copy()
+    with imagetext_py.Writer(img) as iw:
+        iw.draw_text_wrapped(
+            saying, 390, 479, 0.5, 0.5, 760, 96, LXGWWENKAI_REGULAR,
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
+            1.0,
+            imagetext_py.TextAlign.Center,
+            draw_emojis=True,
+        )
+    return img
+
+
+async def draw_cute_ten(saying: str):
+    return await asyncio.to_thread(_draw_cute_ten, saying)

konabot/plugins/roll_dice/__init__.py

@@ -1,11 +1,11 @@
-from typing import Optional
+from typing import Optional, Union
 from nonebot.adapters import Event as BaseEvent
 from nonebot.adapters.console.event import MessageEvent as ConsoleMessageEvent
 from nonebot.adapters.discord.event import MessageEvent as DiscordMessageEvent
 from nonebot_plugin_alconna import Alconna, Args, UniMessage, on_alconna
 
 from konabot.plugins.roll_dice.roll_dice import generate_dice_image
-from konabot.plugins.roll_dice.roll_number import get_random_number, roll_number
+from konabot.plugins.roll_dice.roll_number import get_random_number, get_random_number_string, roll_number
 
 evt = on_alconna(Alconna(
     "摇数字"
@@ -22,21 +22,26 @@ async def _(event: BaseEvent):
 
 evt = on_alconna(Alconna(
     "摇骰子",
-    Args["f1?", int]["f2?", int]
+    Args["f1?", str]["f2?", str]
 ), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
 
 @evt.handle()
-async def _(event: BaseEvent, f1: Optional[int] = None, f2: Optional[int] = None):
+async def _(event: BaseEvent, f1: Optional[str] = None, f2: Optional[str] = None):
     # if isinstance(event, DiscordMessageEvent):
     #     await evt.send(await UniMessage().text("```\n" + roll_dice() + "\n```").export())
     # elif isinstance(event, ConsoleMessageEvent):
-    number = 0
+    number = ""
     if(f1 is not None and f2 is not None):
-        number = get_random_number(f1, f2)
+        number = get_random_number_string(f1, f2)
     elif f1 is not None:
-        number = get_random_number(1, f1)
+        if(float(f1) > 1):
+            number = get_random_number_string("1", f1)
+        elif (float(f1) > 0):
+            number = get_random_number_string("0", f1)
+        else:
+            number = get_random_number_string(f1, "0")
     else:
-        number = get_random_number()
+        number = get_random_number_string()
     await evt.send(await UniMessage().image(raw=await generate_dice_image(number)).export())
     # else:
     #     await evt.send(await UniMessage().text(roll_dice(wide=True)).export())

konabot/plugins/roll_dice/roll_dice.py

@@ -1,9 +1,11 @@
 from io import BytesIO
+
 import cv2
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
 
-from konabot.plugins.roll_dice.base.path import ASSETS
+from konabot.common.path import ASSETS_PATH, FONTS_PATH
+
 
 def text_to_transparent_image(text, font_size=40, padding=0, text_color=(0, 0, 0)):
     """
@@ -13,15 +15,7 @@ def text_to_transparent_image(text, font_size=40, padding=0, text_color=(0, 0, 0
     temp_image = Image.new('RGB', (1, 1), (255, 255, 255))
     temp_draw = ImageDraw.Draw(temp_image)
     
-    font = ImageFont.truetype(ASSETS / "montserrat.otf", font_size)
-    # try:
-    #     font = ImageFont.truetype(ASSETS / "montserrat.otf", font_size)
-    # except:
-    #     try:
-    #         font = ImageFont.truetype("arial.ttf", font_size)
-    #     except:
-    #         # 如果系统字体不可用，使用默认字体
-    #         font = ImageFont.load_default()
+    font = ImageFont.truetype(FONTS_PATH / "montserrat.otf", font_size)
     
     # 获取文本边界框
     bbox = temp_draw.textbbox((0, 0), text, font=font)
@@ -158,27 +152,208 @@ def precise_blend_with_perspective(background, foreground, corners):
     
     return result
 
-async def generate_dice_image(number: int) -> BytesIO:
+def draw_line_bresenham(image, x0, y0, x1, y1, color):
+    """使用Bresenham算法画线，避免间隙"""
+    dx = abs(x1 - x0)
+    dy = abs(y1 - y0)
+    sx = 1 if x0 < x1 else -1
+    sy = 1 if y0 < y1 else -1
+    err = dx - dy
+    
+    while True:
+        if 0 <= x0 < image.shape[1] and 0 <= y0 < image.shape[0]:
+            image[y0, x0] = color
+        
+        if x0 == x1 and y0 == y1:
+            break
+            
+        e2 = 2 * err
+        if e2 > -dy:
+            err -= dy
+            x0 += sx
+        if e2 < dx:
+            err += dx
+            y0 += sy
+
+def slice_and_stretch(image, slice_lines, direction):
+    '''
+    image: 图像
+    slice_lines: 切割线（两个点的列表），一般是倾斜45度的直线
+    direction: 移动方向向量（二元数组）
+    '''
+    # 获取图片的尺寸
+    height, width = image.shape[:2]
+    # 创建一个由移动方向扩充后，更大的图片
+    new_width = int(width + abs(direction[0]))
+    new_height = int(height + abs(direction[1]))
+    new_image = np.zeros((new_height, new_width, 4), dtype=image.dtype)
+    # 先把图片放在新图的和方向相反的一侧
+    offset_x = int(abs(min(0, direction[0])))
+    offset_y = int(abs(min(0, direction[1])))
+    new_image[offset_y:offset_y+height, offset_x:offset_x+width] = image
+    # 切割线也跟着偏移
+    slice_lines = [(x + offset_x, y + offset_y) for (x, y) in slice_lines]
+    # 复制切割线经过的像素，沿着方向移动，实现类似拖尾的效果
+    apply_trail_effect_vectorized(new_image, slice_lines, direction)
+    apply_stroke_vectorized(new_image, slice_lines, direction)
+
+
+    return new_image, offset_x, offset_y
+
+def apply_trail_effect_vectorized(new_image, slice_lines, direction):
+    """向量化实现拖尾效果"""
+    height, width = new_image.shape[:2]
+    
+    # 创建坐标网格
+    y_coords, x_coords = np.mgrid[0:height, 0:width]
+    
+    # 向量化计算点到直线的距离
+    line_vec = np.array([slice_lines[1][0] - slice_lines[0][0], 
+                        slice_lines[1][1] - slice_lines[0][1]])
+    point_vecs = np.stack([x_coords - slice_lines[0][0], 
+                          y_coords - slice_lines[0][1]], axis=-1)
+    
+    # 计算叉积（有向距离）
+    cross_products = (line_vec[0] * point_vecs[:, :, 1] - 
+                     line_vec[1] * point_vecs[:, :, 0])
+    
+    # 选择直线右侧的像素 (d1 > 0)
+    mask = cross_products > 0
+    
+    # 计算目标位置
+    target_x = (x_coords + direction[0]).astype(int)
+    target_y = (y_coords + direction[1]).astype(int)
+    
+    # 创建有效位置掩码
+    valid_mask = mask & (target_x >= 0) & (target_x < width) & \
+                (target_y >= 0) & (target_y < height)
+    
+    # 批量复制像素
+    new_image[target_y[valid_mask], target_x[valid_mask]] = \
+        new_image[y_coords[valid_mask], x_coords[valid_mask]]
+
+def apply_stroke_vectorized(new_image, slice_lines, direction):
+    """使用向量化操作优化笔画效果"""
+    height, width = new_image.shape[:2]
+    
+    # 1. 找到所有非透明像素
+    non_transparent = np.where(new_image[:, :, 3] > 0)
+    if len(non_transparent[0]) == 0:
+        return
+    
+    y_coords, x_coords = non_transparent
+    
+    # 2. 向量化计算点到直线的距离
+    line_vec = np.array([slice_lines[1][0] - slice_lines[0][0], 
+                        slice_lines[1][1] - slice_lines[0][1]])
+    point_vecs = np.column_stack([x_coords - slice_lines[0][0], 
+                                 y_coords - slice_lines[0][1]])
+    
+    # 计算叉积（距离）
+    cross_products = (line_vec[0] * point_vecs[:, 1] - 
+                     line_vec[1] * point_vecs[:, 0])
+    
+    # 3. 选择靠近直线的像素
+    mask = np.abs(cross_products) < 1.0
+    selected_y = y_coords[mask]
+    selected_x = x_coords[mask]
+    selected_pixels = new_image[selected_y, selected_x]
+    
+    if len(selected_x) == 0:
+        return
+    
+    # 4. 预计算采样点
+    length = np.sqrt(direction[0]**2 + direction[1]**2)
+    if length == 0:
+        return
+    
+    # 创建采样偏移
+    dx_dy = np.array([(dx, dy) for dx in [-0.5, 0, 0.5] 
+                     for dy in [-0.5, 0, 0.5]])
+    
+    # 5. 批量计算目标位置
+    steps = max(1, int(length * 2))
+    alpha = 0.7
+    
+    for k in range(1, steps + 1):
+        # 对所有选中的像素批量计算新位置
+        scale = k / steps
+        
+        # 为每个像素和每个采样点计算目标位置
+        for dx, dy in dx_dy:
+            target_x = np.round(selected_x + dx + direction[0] * scale).astype(int)
+            target_y = np.round(selected_y + dy + direction[1] * scale).astype(int)
+            
+            # 创建有效位置掩码
+            valid_mask = (target_x >= 0) & (target_x < width) & \
+                        (target_y >= 0) & (target_y < height)
+            
+            if np.any(valid_mask):
+                valid_target_x = target_x[valid_mask]
+                valid_target_y = target_y[valid_mask]
+                valid_source_idx = np.where(valid_mask)[0]
+                
+                # 批量混合像素
+                source_pixels = selected_pixels[valid_source_idx]
+                target_pixels = new_image[valid_target_y, valid_target_x]
+                
+                new_image[valid_target_y, valid_target_x] = (
+                    alpha * source_pixels + (1 - alpha) * target_pixels
+                )
+
+async def generate_dice_image(number: str) -> BytesIO:
     # 将文本转换为带透明背景的图像
-    text = str(number)
+    text = number
+
+    # 如果文本太长，直接返回金箍棒
+    if(len(text) > 50):
+        output = BytesIO()
+        push_image = Image.open(ASSETS_PATH / "img" / "dice" / "stick.png")
+        push_image.save(output,format='PNG')
+        output.seek(0)
+        return output
+
     text_image = text_to_transparent_image(
         text, 
         font_size=60, 
         text_color=(0, 0, 0)  # 黑色文字
     )
-    
+
+    # 获取长宽比
+    height, width = text_image.shape[:2]
+    aspect_ratio = width / height
+
+    # 根据长宽比设置拉伸系数
+    stretch_k = 1
+    if aspect_ratio > 1:
+        stretch_k = aspect_ratio
+
+    # 骰子的方向
+    up_direction = (51 - 16, 5 - 30)  # 右上角点 - 左上角点
+
+    move_distance = (up_direction[0] * (stretch_k - 1), up_direction[1] * (stretch_k - 1))
+
+    # 加载背景图像，保留透明通道
+    background = cv2.imread(str(ASSETS_PATH / "img" / "dice" / "template.png"), cv2.IMREAD_UNCHANGED)
+    assert background is not None
+
+    height, width = background.shape[:2]
+
+    background, offset_x, offset_y = slice_and_stretch(background, 
+                                                       [(10,10),(0,0)], 
+                                                        move_distance)
+
     # 定义3D变换的四个角点（透视效果）
     # 顺序: [左上, 右上, 右下, 左下]
     corners = np.array([
         [16, 30],    # 左上
-        [51, 5],     # 右上（上移，创建透视）
-        [88, 33],    # 右下
+        [51 + move_distance[0], 5 + move_distance[1]],     # 右上（上移，创建透视）
+        [88 + move_distance[0], 33 + move_distance[1]],    # 右下
         [49, 62]     # 左下（下移）
     ], dtype=np.float32)
+    corners[:, 0] += offset_x
+    corners[:, 1] += offset_y
     
-    # 加载背景图像，保留透明通道
-    background = cv2.imread(str(ASSETS / "template.png"), cv2.IMREAD_UNCHANGED)
-
 
     # 对文本图像进行3D变换（保持透明通道）
     transformed_text, transform_matrix = perspective_transform(text_image, background, corners)
@@ -189,9 +364,29 @@ async def generate_dice_image(number: int) -> BytesIO:
 
     pil_final = Image.fromarray(final_image_simple)
     # 导入一系列图像
-    images: list[Image.Image] = [Image.open(ASSETS / f"{i}.png") for i in range(1, 12)]
+    images: list[Image.Image] = [Image.open(ASSETS_PATH / "img" / "dice" / f"{i}.png") for i in range(1, 12)]
     images.append(pil_final)
     frame_durations = [100] * (len(images) - 1) + [100000]
+    # 将导入的图像尺寸扩展为和 pil_final 相同的大小，随帧数进行扩展，然后不放大的情况下放在最中间
+    if(aspect_ratio > 1):
+        target_size = pil_final.size
+        for i in range(len(images) - 1):
+            k = i / (len(images) - 1)
+            now_distance = (move_distance[0] * k, move_distance[1] * k)
+            img = np.array(images[i])
+            img, _, _ = slice_and_stretch(img,
+                            [(10,10),(0,0)], 
+                            now_distance)
+            # 只扩展边界，图像本身不放大
+            img_width, img_height = img.shape[1], img.shape[0]
+            new_img = Image.new("RGBA", target_size, (0, 0, 0, 0))
+            this_offset_x = (target_size[0] - img_width) // 2
+            this_offset_y = (target_size[1] - img_height) // 2
+            # new_img.paste(img, (this_offset_x, this_offset_y))
+            new_img.paste(Image.fromarray(img), (this_offset_x, this_offset_y))
+            images[i] = new_img
+        
+
     # 保存为BytesIO对象
     output = BytesIO()
     images[0].save(output,
@@ -200,4 +395,6 @@ async def generate_dice_image(number: int) -> BytesIO:
                duration=frame_durations,
                format='GIF',
                loop=1)
+    output.seek(0)
+    # pil_final.save(output, format='PNG')
     return output

konabot/plugins/roll_dice/roll_number.py

@@ -42,6 +42,24 @@ def get_random_number(min: int = 1, max: int = 6) -> int:
     import random
     return random.randint(min, max)
 
+def get_random_number_string(min_value: str = "1", max_value: str = "6") -> str:
+    import random
+
+    # 先判断二者是不是整数
+    if (float(min_value).is_integer()
+        and float(max_value).is_integer()
+        and "." not in min_value
+        and "." not in max_value):
+        return str(random.randint(int(float(min_value)), int(float(max_value))))
+    
+    # 根据传入小数的位数，决定保留几位小数
+    if "." in str(min_value) or "." in str(max_value):
+        decimal_places = max(len(str(min_value).split(".")[1]) if "." in str(min_value) else 0,
+                             len(str(max_value).split(".")[1]) if "." in str(max_value) else 0)
+        return str(round(random.uniform(float(min_value), float(max_value)), decimal_places))
+    
+    # 如果没有小数点，很可能二者都是指数表示或均为 inf，直接返回随机小数
+    return str(random.uniform(float(min_value), float(max_value)))
 def roll_number(wide: bool = False) -> str:
     raw = number_arts[get_random_number()]
     if wide:

konabot/plugins/simple_notify/__init__.py

@@ -0,0 +1,215 @@
+import asyncio
+import datetime
+from pathlib import Path
+from typing import Any, Literal, cast
+
+import nonebot
+from loguru import logger
+from nonebot import on_message
+from nonebot.adapters import Event
+from nonebot.adapters.console import Bot as ConsoleBot
+from nonebot.adapters.console.event import MessageEvent as ConsoleMessageEvent
+from nonebot.adapters.discord import Bot as DiscordBot
+from nonebot.adapters.discord.event import MessageEvent as DiscordMessageEvent
+from nonebot.adapters.onebot.v11 import Bot as OnebotV11Bot
+from nonebot.adapters.onebot.v11.event import \
+    GroupMessageEvent as OnebotV11GroupMessageEvent
+from nonebot.adapters.onebot.v11.event import \
+    MessageEvent as OnebotV11MessageEvent
+from nonebot_plugin_alconna import UniMessage, UniMsg
+from pydantic import BaseModel
+
+from konabot.plugins.simple_notify.parse_time import get_target_time
+
+evt = on_message()
+
+(Path(__file__).parent.parent.parent.parent / "data").mkdir(exist_ok=True)
+DATA_FILE_PATH = Path(__file__).parent.parent.parent.parent / "data" / "notify.json"
+DATA_FILE_LOCK = asyncio.Lock()
+
+
+class Notify(BaseModel):
+    platform: Literal["console", "qq", "discord"]
+
+    target: str
+    "需要接受通知的个体"
+
+    target_env: str | None
+    "在哪里进行通知，如果是 None 代表私聊通知"
+
+    notify_time: datetime.datetime
+    notify_msg: str
+
+    def get_str(self):
+        return f"{self.target}-{self.target_env}-{self.platform}-{self.notify_time}"
+
+
+class NotifyConfigFile(BaseModel):
+    version: int = 2
+    notifies: list[Notify] = []
+    unsent: list[Notify] = []
+
+
+def load_notify_config() -> NotifyConfigFile:
+    if not DATA_FILE_PATH.exists():
+        return NotifyConfigFile()
+    try:
+        return NotifyConfigFile.model_validate_json(DATA_FILE_PATH.read_text())
+    except Exception as e:
+        logger.warning(f"在解析 Notify 时遇到问题：{e}")
+        return NotifyConfigFile()
+
+
+def save_notify_config(config: NotifyConfigFile):
+    DATA_FILE_PATH.write_text(config.model_dump_json(indent=4))
+
+
+async def notify_now(notify: Notify):
+    if notify.platform == 'console':
+        bot = [b for b in nonebot.get_bots().values() if isinstance(b, ConsoleBot)]
+        if len(bot) != 1:
+            logger.warning(f"提醒未成功发送出去：{nonebot.get_bots()} {notify}")
+            return False
+        bot = bot[0]
+        await bot.send_private_message(notify.target, f"代办通知：{notify.notify_msg}")
+    elif notify.platform == 'discord':
+        bot = [b for b in nonebot.get_bots().values() if isinstance(b, DiscordBot)]
+        if len(bot) != 1:
+            logger.warning(f"提醒未成功发送出去：{nonebot.get_bots()} {notify}")
+            return False
+        bot = bot[0]
+        channel = await bot.create_DM(recipient_id=int(notify.target))
+        await bot.send_to(channel.id, f"代办通知：{notify.notify_msg}")
+    elif notify.platform == 'qq':
+        bot = [b for b in nonebot.get_bots().values() if isinstance(b, OnebotV11Bot)]
+        if len(bot) != 1:
+            logger.warning(f"提醒未成功发送出去：{nonebot.get_bots()} {notify}")
+            return False
+        bot = bot[0]
+        if notify.target_env is None:
+            await bot.send_private_msg(
+                user_id=int(notify.target),
+                message=cast(Any, await UniMessage.text(f"代办通知：{notify.notify_msg}").export(
+                    bot=bot,
+                )),
+            )
+        else:
+            await bot.send_group_msg(
+                group_id=int(notify.target_env),
+                message=cast(Any,
+                    await UniMessage().at(
+                        notify.target
+                    ).text(f" 代办通知：{notify.notify_msg}").export(bot=bot)
+                ),
+            )
+    else:
+        logger.warning(f"提醒未成功发送出去：{notify}")
+        return False
+    return True
+
+
+async def create_notify_task(notify: Notify, fail2remove: bool = True):
+    async def mission():
+        begin_time = datetime.datetime.now()
+        if begin_time < notify.notify_time:
+            await asyncio.sleep((notify.notify_time - begin_time).total_seconds())
+        res = await notify_now(notify)
+        if fail2remove or res:
+            await DATA_FILE_LOCK.acquire()
+            cfg = load_notify_config()
+            cfg.notifies = [n for n in cfg.notifies if n.get_str() != notify.get_str()]
+            if not res:
+                cfg.unsent.append(notify)
+            save_notify_config(cfg)
+            DATA_FILE_LOCK.release()
+        else:
+            pass
+    return asyncio.create_task(mission())
+
+
+@evt.handle()
+async def _(msg: UniMsg, mEvt: Event):
+    if mEvt.get_user_id() in nonebot.get_bots():
+        return
+
+    text = msg.extract_plain_text()
+    if "提醒我" not in text:
+        return
+
+    segments = text.split("提醒我", maxsplit=1)
+    if len(segments) != 2:
+        return
+
+    notify_time, notify_text = segments
+    target_time = get_target_time(notify_time)
+    if target_time is None:
+        logger.info(f"无法从 {notify_time} 中解析出时间")
+        return
+    if not notify_text:
+        return
+
+    await DATA_FILE_LOCK.acquire()
+    cfg = load_notify_config()
+    
+    if isinstance(mEvt, ConsoleMessageEvent):
+        platform = "console"
+        target = mEvt.get_user_id()
+        target_env = None
+    elif isinstance(mEvt, OnebotV11MessageEvent):
+        platform = "qq"
+        target = mEvt.get_user_id()
+        if isinstance(mEvt, OnebotV11GroupMessageEvent):
+            target_env = str(mEvt.group_id)
+        else:
+            target_env = None
+    elif isinstance(mEvt, DiscordMessageEvent):
+        platform = "discord"
+        target = mEvt.get_user_id()
+        target_env = None
+    else:
+        logger.warning(f"Notify 遇到不支持的平台：{type(mEvt).__name__}")
+        return
+
+    notify = Notify(
+        platform=platform,
+        target=target,
+        target_env=target_env,
+        notify_time=target_time,
+        notify_msg=notify_text,
+    )
+    await create_notify_task(notify)
+
+    cfg.notifies.append(notify)
+    save_notify_config(cfg)
+    DATA_FILE_LOCK.release()
+
+    await evt.send(await UniMessage().at(mEvt.get_user_id()).text(
+        f" 了解啦！将会在 {notify.notify_time} 提醒你哦~").export())
+
+
+driver = nonebot.get_driver()
+
+NOTIFIED_FLAG = {
+    "task_added": False,
+}
+
+
+@driver.on_bot_connect
+async def _():
+    if NOTIFIED_FLAG["task_added"]:
+        return
+
+    NOTIFIED_FLAG["task_added"] = True
+
+    await asyncio.sleep(10)
+    await DATA_FILE_LOCK.acquire()
+    tasks = []
+    cfg = load_notify_config()
+    if cfg.version == 1:
+        cfg.version = 2
+    else:
+        for notify in cfg.notifies:
+            tasks.append(create_notify_task(notify, fail2remove=False))
+    DATA_FILE_LOCK.release()
+
+    await asyncio.gather(*tasks)

konabot/plugins/simple_notify/parse_time.py

@@ -0,0 +1,358 @@
+import datetime
+import re
+from typing import Optional, Dict, List, Callable, Tuple
+
+from loguru import logger
+
+# --- 常量与正则表达式定义 (Constants and Regex Definitions) ---
+
+# 数字模式，兼容中文和阿拉伯数字
+P_NUM = r"(\d+|[零一两二三四五六七八九十]+)"
+
+# 预编译的正则表达式
+PATTERNS = {
+    # 相对时间, e.g., "5分钟后"
+    "DELTA": re.compile(
+        r"^"
+        r"((?P<days>" + P_NUM + r") ?天)?"
+        r"((?P<hours>" + P_NUM + r") ?个?小?时)?"
+        r"((?P<minutes>" + P_NUM + r") ?分钟?)?"
+        r"((?P<seconds>" + P_NUM + r") ?秒钟?)?"
+        r" ?后 ?$"
+    ),
+    # 绝对时间
+    "YEAR": re.compile(r"(" + P_NUM + r") ?年"),
+    "MONTH": re.compile(r"(" + P_NUM + r") ?月"),
+    "DAY": re.compile(r"(" + P_NUM + r") ?[日号]"),
+    "HOUR": re.compile(r"(" + P_NUM + r") ?[点时](半)?钟?"),
+    "MINUTE": re.compile(r"(" + P_NUM + r") ?分(钟)?"),
+    "SECOND": re.compile(r"(" + P_NUM + r") ?秒(钟)?"),
+    "HMS_COLON": re.compile(r"(\d{1,2})[:：](\d{1,2})([:：](\d{1,2}))?"),
+    "PM": re.compile(r"(下午|PM|晚上)"),
+    # 相对日期
+    "TOMORROW": re.compile(r"明天"),
+    "DAY_AFTER_TOMORROW": re.compile(r"后天"),
+    "TODAY": re.compile(r"今天"),
+}
+
+# 中文数字到阿拉伯数字的映射
+CHINESE_TO_ARABIC_MAP: Dict[str, int] = {
+    '零': 0, '一': 1, '二': 2, '三': 3, '四': 4,
+    '五': 5, '六': 6, '七': 7, '八': 8, '九': 9, '十': 10
+}
+
+# --- 核心工具函数 (Core Utility Functions) ---
+
+def parse_number(s: str) -> int:
+    """
+    将包含中文或阿拉伯数字的字符串解析为整数。
+    例如: "五" -> 5, "十五" -> 15, "二十三" -> 23, "12" -> 12。
+    返回 -1 表示解析失败。
+    """
+    if not s:
+        return -1
+        
+    s = s.strip().replace("两", "二")
+
+    if s.isdigit():
+        return int(s)
+
+    if s in CHINESE_TO_ARABIC_MAP:
+        return CHINESE_TO_ARABIC_MAP[s]
+
+    # 处理 "十" 在不同位置的情况
+    if s.startswith('十'):
+        if len(s) == 1:
+            return 10
+        num = CHINESE_TO_ARABIC_MAP.get(s[1])
+        return 10 + num if num is not None else -1
+    
+    if s.endswith('十'):
+        if len(s) == 2:
+            num = CHINESE_TO_ARABIC_MAP.get(s[0])
+            return 10 * num if num is not None else -1
+
+    if '十' in s:
+        parts = s.split('十')
+        if len(parts) == 2:
+            left = CHINESE_TO_ARABIC_MAP.get(parts[0])
+            right = CHINESE_TO_ARABIC_MAP.get(parts[1])
+            if left is not None and right is not None:
+                return left * 10 + right
+    
+    return -1
+
+
+# --- 时间解析器类 (Time Parser Class) ---
+
+class TimeParser:
+    """
+    一个用于解析自然语言时间描述的类。
+    """
+    def __init__(self, content: str):
+        self.original_content: str = content
+        self.content_to_parse: str = self._preprocess(content)
+        self.now: datetime.datetime = datetime.datetime.now()
+        # 将 t 作为结果构建器，初始化为今天的午夜
+        self.t: datetime.datetime = self.now.replace(hour=0, minute=0, second=0, microsecond=0)
+        self.is_pm_specified: bool = False
+        self.is_date_specified: bool = False
+        self.is_time_specified: bool = False
+
+    def _preprocess(self, content: str) -> str:
+        """预处理字符串，移除不相关字符。"""
+        content = re.sub(r"\s+", "", content)
+        content = re.sub(r"[,，\.。:：、]", "", content)
+        return content
+
+    def _consume_match(self, match: re.Match) -> str:
+        """从待解析字符串中移除已匹配的部分。"""
+        self.content_to_parse = self.content_to_parse.replace(match.group(0), "", 1)
+        return match.group(0)
+
+    def parse(self) -> Optional[datetime.datetime]:
+        """
+        主解析方法。
+        首先尝试解析相对时间（如“5分钟后”），失败则尝试解析绝对时间。
+        """
+        logger.debug(f"🎉 开始解析: '{self.original_content}' -> 清洗后: '{self.content_to_parse}'")
+        if not self.content_to_parse:
+            logger.debug("❌ 内容为空，无法解析。")
+            return None
+
+        # 1. 尝试相对时间解析
+        if (target_time := self._parse_relative_time()) is not None:
+            return target_time
+
+        # 2. 尝试绝对时间解析
+        if (target_time := self._parse_absolute_time()) is not None:
+            return target_time
+
+        logger.debug(f"❌ 所有解析模式均未匹配成功。")
+        return None
+
+    def _parse_relative_time(self) -> Optional[datetime.datetime]:
+        """解析 'X天X小时X分钟后' 这种格式。"""
+        if match := PATTERNS["DELTA"].match(self.content_to_parse):
+            logger.debug("⏳ 匹配到相对时间模式 (DELTA)。")
+            try:
+                delta_parts = {
+                    "days": parse_number(match.group("days") or "0"),
+                    "hours": parse_number(match.group("hours") or "0"),
+                    "minutes": parse_number(match.group("minutes") or "0"),
+                    "seconds": parse_number(match.group("seconds") or "0"),
+                }
+                
+                # 检查是否有无效的数字解析
+                if any(v < 0 for v in delta_parts.values()):
+                    logger.debug(f"❌ 解析时间片段为数字时失败: {delta_parts}")
+                    return None
+                
+                delta = datetime.timedelta(**delta_parts)
+                if delta.total_seconds() == 0:
+                    logger.debug("❌ 解析出的时间增量为0。")
+                    return None
+
+                target_time = self.now + delta
+                logger.debug(f"✅ 相对时间解析成功 -> {target_time}")
+                return target_time
+            except (ValueError, TypeError) as e:
+                logger.debug(f"❌ 解析相对时间时出错: {e}", exc_info=True)
+                return None
+        return None
+
+    def _parse_absolute_time(self) -> Optional[datetime.datetime]:
+        """解析一个指定的日期和时间。"""
+        logger.debug(f"🎯 启动绝对时间解析，基准时间: {self.t}")
+        
+        # 定义解析步骤和顺序
+        # (pattern_key, handler_method)
+        parsing_steps: List[Tuple[str, Callable[[re.Match], bool]]] = [
+            ("TOMORROW", self._handle_tomorrow),
+            ("DAY_AFTER_TOMORROW", self._handle_day_after_tomorrow),
+            ("TODAY", self._handle_today),
+            ("YEAR", self._handle_year),
+            ("MONTH", self._handle_month),
+            ("DAY", self._handle_day),
+            ("HMS_COLON", self._handle_hms_colon),
+            ("PM", self._handle_pm),
+            ("HOUR", self._handle_hour),
+            ("MINUTE", self._handle_minute),
+            ("SECOND", self._handle_second),
+        ]
+
+        for key, handler in parsing_steps:
+            if match := PATTERNS[key].search(self.content_to_parse):
+                if not handler(match):
+                    # 如果任何一个处理器返回False，说明解析失败
+                    return None
+        
+        # 移除无意义的上午关键词
+        self.content_to_parse = self.content_to_parse.replace("上午", "").replace("AM", "").replace("凌晨", "")
+
+        # 如果解析后还有剩余字符，说明有无法识别的部分
+        if self.content_to_parse.strip():
+            logger.debug(f"❌ 匹配失败，存在未解析的残留内容: '{self.content_to_parse.strip()}'")
+            return None
+            
+        # 最终调整和检查
+        return self._finalize_datetime()
+
+    # --- Handler Methods for Absolute Time Parsing ---
+
+    def _handle_tomorrow(self, match: re.Match) -> bool:
+        self.t += datetime.timedelta(days=1)
+        self.is_date_specified = True
+        logger.debug(f"📅 匹配到 '明天' -> {self.t.date()}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_day_after_tomorrow(self, match: re.Match) -> bool:
+        self.t += datetime.timedelta(days=2)
+        self.is_date_specified = True
+        logger.debug(f"📅 匹配到 '后天' -> {self.t.date()}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_today(self, match: re.Match) -> bool:
+        self.is_date_specified = True
+        logger.debug(f"📅 匹配到 '今天', 日期基准不变, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_year(self, match: re.Match) -> bool:
+        year = parse_number(match.group(1))
+        if year < 0: return False
+        if year < 100: year += 2000 # 处理 "25年" -> 2025
+        if year < self.now.year:
+            logger.debug(f"❌ 指定的年份 {year} 已过去。")
+            return False
+        self.t = self.t.replace(year=year)
+        self.is_date_specified = True
+        logger.debug(f"Y| 年份更新 -> {self.t.year}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_month(self, match: re.Match) -> bool:
+        month = parse_number(match.group(1))
+        if not (1 <= month <= 12):
+            logger.debug(f"❌ 无效的月份: {month}")
+            return False
+        
+        # 如果设置的月份在当前月份之前，且没有指定年份，则年份加一
+        if month < self.t.month and not self.is_date_specified:
+            self.t = self.t.replace(year=self.t.year + 1)
+            logger.debug(f"💡 月份小于当前月份，年份自动进位 -> {self.t.year}")
+
+        self.t = self.t.replace(month=month)
+        self.is_date_specified = True
+        logger.debug(f"M| 月份更新 -> {self.t.month}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_day(self, match: re.Match) -> bool:
+        day = parse_number(match.group(1))
+        if not (1 <= day <= 31):
+            logger.debug(f"❌ 无效的日期: {day}")
+            return False
+        
+        try:
+            # 如果日期小于当前日期，且只指定了日，则月份加一
+            if day < self.t.day and not self.is_date_specified:
+                if self.t.month == 12:
+                    self.t = self.t.replace(year=self.t.year + 1, month=1)
+                else:
+                    self.t = self.t.replace(month=self.t.month + 1)
+                logger.debug(f"💡 日期小于当前日期，月份自动进位 -> {self.t.year}-{self.t.month}")
+            
+            self.t = self.t.replace(day=day)
+            self.is_date_specified = True
+            logger.debug(f"D| 日期更新 -> {self.t.day}, 消耗: '{self._consume_match(match)}'")
+            return True
+        except ValueError:
+            logger.debug(f"❌ 日期 {day} 对于月份 {self.t.month} 无效 (例如2月30号)。")
+            return False
+
+    def _handle_hms_colon(self, match: re.Match) -> bool:
+        h = int(match.group(1))
+        m = int(match.group(2))
+        s_str = match.group(4) # group(3) is with colon, group(4) is the number
+        s = int(s_str) if s_str else 0
+        if not (0 <= h <= 23 and 0 <= m <= 59 and 0 <= s <= 59):
+            logger.debug(f"❌ 无效的时间格式: H={h}, M={m}, S={s}")
+            return False
+        self.t = self.t.replace(hour=h, minute=m, second=s)
+        self.is_time_specified = True
+        logger.debug(f"T| 时分秒(冒号格式)更新 -> {self.t.time()}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_pm(self, match: re.Match) -> bool:
+        self.is_pm_specified = True
+        logger.debug(f"PM| 匹配到下午/晚上, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_hour(self, match: re.Match) -> bool:
+        hour = parse_number(match.group(1))
+        has_half = match.group(2) == '半'
+        if not (0 <= hour <= 23):
+            logger.debug(f"❌ 无效的小时: {hour}")
+            return False
+        minute = 30 if has_half else self.t.minute
+        self.t = self.t.replace(hour=hour, minute=minute)
+        self.is_time_specified = True
+        logger.debug(f"H| 小时更新 -> {self.t.hour}{':30' if has_half else ''}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_minute(self, match: re.Match) -> bool:
+        minute = parse_number(match.group(1))
+        if not (0 <= minute <= 59):
+            logger.debug(f"❌ 无效的分钟: {minute}")
+            return False
+        self.t = self.t.replace(minute=minute)
+        self.is_time_specified = True
+        logger.debug(f"M| 分钟更新 -> {self.t.minute}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _handle_second(self, match: re.Match) -> bool:
+        second = parse_number(match.group(1))
+        if not (0 <= second <= 59):
+            logger.debug(f"❌ 无效的秒: {second}")
+            return False
+        self.t = self.t.replace(second=second)
+        self.is_time_specified = True
+        logger.debug(f"S| 秒更新 -> {self.t.second}, 消耗: '{self._consume_match(match)}'")
+        return True
+
+    def _finalize_datetime(self) -> Optional[datetime.datetime]:
+        """对解析出的时间进行最后的调整和检查。"""
+        # 处理下午/晚上
+        if self.is_pm_specified and self.t.hour < 12:
+            self.t = self.t.replace(hour=self.t.hour + 12)
+            logger.debug(f"💡 根据 PM 标识，小时调整为 -> {self.t.hour}")
+
+        # 如果没有指定任何时间或日期部分，则认为解析无效
+        if not self.is_date_specified and not self.is_time_specified:
+            logger.debug("❌ 未能从输入中解析出任何有效的日期或时间部分。")
+            return None
+
+        # 如果最终计算出的时间点在当前时间之前，自动往后推
+        # 例如：现在是 15:00，说 "14点"，应该是指明天的14点
+        if self.t < self.now:
+            # 只有在明确指定了时间的情况下，才自动加一天
+            # 如果只指定了一个过去的日期（如“去年5月1号”），则不应该调整
+            if self.is_time_specified:
+                self.t += datetime.timedelta(days=1)
+                logger.debug(f"🔁 目标时间已过，自动调整为明天 -> {self.t}")
+        
+        logger.debug(f"✅ 解析成功，最终时间: {self.t}")
+        return self.t
+
+# --- 公共接口 (Public Interface) ---
+
+def get_target_time(content: str) -> Optional[datetime.datetime]:
+    """
+    高级接口，用于将自然语言时间描述转换为 datetime 对象。
+
+    Args:
+        content: 包含时间信息的字符串。
+
+    Returns:
+        一个 datetime 对象，如果解析失败则返回 None。
+    """
+    parser = TimeParser(content)
+    return parser.parse()

konabot/plugins/ytpgif/__init__.py

@@ -0,0 +1,268 @@
+import os
+import tempfile
+from typing import Optional
+
+from PIL import Image, ImageSequence
+from nonebot.adapters import Event as BaseEvent
+from nonebot.plugin import PluginMetadata
+from nonebot_plugin_alconna import (
+    Alconna,
+    Args,
+    Field,
+    UniMessage,
+    on_alconna,
+)
+
+__plugin_meta__ = PluginMetadata(
+    name="ytpgif",
+    description="生成来回镜像翻转的仿 YTPMV 动图。",
+    usage="ytpgif [倍速=1.0] （倍速范围：0.1～20.0）",
+    type="application",
+    config=None,
+    homepage=None,
+)
+
+# 参数定义
+BASE_SEGMENT_DURATION = 0.25
+BASE_INTERVAL = 0.25
+MAX_SIZE = 256
+MIN_SPEED = 0.1
+MAX_SPEED = 20.0
+MAX_FRAMES_PER_SEGMENT = 500
+
+# 提示语
+SPEED_TIPS = f"倍速必须是 {MIN_SPEED} 到 {MAX_SPEED} 之间的数字"
+
+
+# 定义命令 + 参数校验
+ytpgif_cmd = on_alconna(
+    Alconna(
+        "ytpgif",
+        Args[
+            "speed?",
+            float,
+            Field(
+                default=1.0,
+                unmatch_tips=lambda x: f"“{x}”不是有效数值。{SPEED_TIPS}",
+            ),
+        ],
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=False,
+)
+
+
+async def get_image_url(event: BaseEvent) -> Optional[str]:
+    """从事件中提取图片 URL，支持直接消息和回复"""
+    msg = event.get_message()
+    for seg in msg:
+        if seg.type == "image" and seg.data.get("url"):
+            return str(seg.data["url"])
+
+    if hasattr(event, "reply") and (reply := event.reply):
+        reply_msg = reply.message
+        for seg in reply_msg:
+            if seg.type == "image" and seg.data.get("url"):
+                return str(seg.data["url"])
+    return None
+
+
+async def download_image(url: str) -> bytes:
+    import httpx
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(url, timeout=10)
+        resp.raise_for_status()
+        return resp.content
+
+
+def resize_frame(frame: Image.Image) -> Image.Image:
+    """缩放图像，保持宽高比，不超过 MAX_SIZE"""
+    w, h = frame.size
+    if w <= MAX_SIZE and h <= MAX_SIZE:
+        return frame
+
+    scale = MAX_SIZE / max(w, h)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+    return frame.resize((new_w, new_h), Image.Resampling.LANCZOS)
+
+
+@ytpgif_cmd.handle()
+async def handle_ytpgif(event: BaseEvent, speed: float = 1.0):
+    # === 校验 speed 范围 ===
+    if not (MIN_SPEED <= speed <= MAX_SPEED):
+        await ytpgif_cmd.send(
+            await UniMessage.text(f"❌ {SPEED_TIPS}").export()
+        )
+        return
+
+    img_url = await get_image_url(event)
+    if not img_url:
+        await ytpgif_cmd.send(
+            await UniMessage.text(
+                "请发送一张图片或回复一张图片来生成镜像动图。"
+            ).export()
+        )
+        return
+
+    try:
+        image_data = await download_image(img_url)
+    except Exception as e:
+        print(f"[YTPGIF] 下载失败: {e}")
+        await ytpgif_cmd.send(
+            await UniMessage.text("❌ 图片下载失败，请重试。").export()
+        )
+        return
+
+    input_path = output_path = None
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".gif") as tmp_in:
+            tmp_in.write(image_data)
+            input_path = tmp_in.name
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".gif") as tmp_out:
+            output_path = tmp_out.name
+
+        with Image.open(input_path) as src_img:
+            # === 判断是否为动图 ===
+            try:
+                n_frames = getattr(src_img, "n_frames", 1)
+                is_animated = n_frames > 1
+            except Exception:
+                is_animated = False
+
+            output_frames = []
+            output_durations_ms = []
+
+            if is_animated:
+                # === 动图模式：截取正向 + 镜像两段 ===
+                frames_with_duration = []
+                palette = src_img.getpalette()
+
+                for idx in range(n_frames):
+                    src_img.seek(idx)
+                    frame = src_img.copy()
+                    # 检查是否需要透明通道
+                    has_alpha = (
+                        frame.mode in ("RGBA", "LA")
+                        or (frame.mode == "P" and "transparency" in frame.info)
+                    )
+                    if has_alpha:
+                        frame = frame.convert("RGBA")
+                    else:
+                        frame = frame.convert("RGB")
+                    resized_frame = resize_frame(frame)
+
+                    # 若原图有调色板，尝试保留（可选）
+                    if palette and resized_frame.mode == "P":
+                        try:
+                            resized_frame.putpalette(palette)
+                        except Exception:  # noqa
+                            pass
+
+                    ms = frame.info.get("duration", int(BASE_SEGMENT_DURATION * 1000))
+                    dur_sec = max(0.01, ms / 1000.0)
+                    frames_with_duration.append((resized_frame, dur_sec))
+
+                max_dur = BASE_SEGMENT_DURATION * speed
+                accumulated = 0.0
+                frame_count = 0
+
+                # 正向段
+                for img, dur in frames_with_duration:
+                    if accumulated + dur > max_dur or frame_count >= MAX_FRAMES_PER_SEGMENT:
+                        break
+                    output_frames.append(img)
+                    output_durations_ms.append(int(dur * 1000))
+                    accumulated += dur
+                    frame_count += 1
+
+                if frame_count == 0:
+                    await ytpgif_cmd.send(
+                        await UniMessage.text("动图帧太短，无法生成有效片段。").export()
+                    )
+                    return
+
+                # 镜像段（从头开始）
+                accumulated = 0.0
+                frame_count = 0
+                for img, dur in frames_with_duration:
+                    if accumulated + dur > max_dur or frame_count >= MAX_FRAMES_PER_SEGMENT:
+                        break
+                    flipped = img.transpose(Image.FLIP_LEFT_RIGHT)
+                    output_frames.append(flipped)
+                    output_durations_ms.append(int(dur * 1000))
+                    accumulated += dur
+                    frame_count += 1
+
+            else:
+                # === 静态图模式：制作翻转动画 ===
+                raw_frame = src_img.convert("RGBA")
+                resized_frame = resize_frame(raw_frame)
+
+                interval_sec = max(0.025, min(2.5, BASE_INTERVAL / speed))
+                duration_ms = int(interval_sec * 1000)
+
+                frame1 = resized_frame
+                frame2 = resized_frame.transpose(Image.FLIP_LEFT_RIGHT)
+
+                output_frames = [frame1, frame2]
+                output_durations_ms = [duration_ms, duration_ms]
+
+            if len(output_frames) < 1:
+                await ytpgif_cmd.send(
+                    await UniMessage.text("未能生成任何帧。").export()
+                )
+                return
+
+            # === 🔐 关键修复：防止无透明图的颜色被当成透明 ===
+            need_transparency = False
+            for frame in output_frames:
+                if frame.mode == "RGBA":
+                    alpha_channel = frame.getchannel("A")
+                    if any(pix < 255 for pix in alpha_channel.getdata()):
+                        need_transparency = True
+                        break
+                elif frame.mode == "P" and "transparency" in frame.info:
+                    need_transparency = True
+                    break
+
+            # 如果不需要透明，则统一转为 RGB 避免调色板污染
+            if not need_transparency:
+                output_frames = [f.convert("RGB") for f in output_frames]
+
+            # 构建保存参数
+            save_kwargs = {
+                "save_all": True,
+                "append_images": output_frames[1:],
+                "format": "GIF",
+                "loop": 0,           # 无限循环
+                "duration": output_durations_ms,
+                "disposal": 2,       # 清除到背景色，避免残留
+                "optimize": False,   # 关闭抖动（等效 -dither none）
+            }
+
+            # 只有真正需要透明时才启用 transparency
+            if need_transparency:
+                save_kwargs["transparency"] = 0
+
+            output_frames[0].save(output_path, **save_kwargs)
+
+        # 发送结果
+        with open(output_path, "rb") as f:
+            result_image = UniMessage.image(raw=f.read())
+        await ytpgif_cmd.send(await result_image.export())
+
+    except Exception as e:
+        print(f"[YTPGIF] 处理失败: {e}")
+        await ytpgif_cmd.send(
+            await UniMessage.text("❌ 处理失败，可能是图片格式不支持、文件损坏或过大。").export()
+        )
+    finally:
+        for path in filter(None, [input_path, output_path]):
+            if os.path.exists(path):
+                try:
+                    os.unlink(path)
+                except:  # noqa
+                    pass

poetry.lock

@@ -1793,20 +1793,20 @@ files = [
 ]
 
 [[package]]
-name = "opencv-python"
+name = "opencv-python-headless"
 version = "4.12.0.88"
 description = "Wrapper package for OpenCV python bindings."
 optional = false
 python-versions = ">=3.6"
 groups = ["main"]
 files = [
-    {file = "opencv-python-4.12.0.88.tar.gz", hash = "sha256:8b738389cede219405f6f3880b851efa3415ccd674752219377353f017d2994d"},
-    {file = "opencv_python-4.12.0.88-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:f9a1f08883257b95a5764bf517a32d75aec325319c8ed0f89739a57fae9e92a5"},
-    {file = "opencv_python-4.12.0.88-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:812eb116ad2b4de43ee116fcd8991c3a687f099ada0b04e68f64899c09448e81"},
-    {file = "opencv_python-4.12.0.88-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:51fd981c7df6af3e8f70b1556696b05224c4e6b6777bdd2a46b3d4fb09de1a92"},
-    {file = "opencv_python-4.12.0.88-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:092c16da4c5a163a818f120c22c5e4a2f96e0db4f24e659c701f1fe629a690f9"},
-    {file = "opencv_python-4.12.0.88-cp37-abi3-win32.whl", hash = "sha256:ff554d3f725b39878ac6a2e1fa232ec509c36130927afc18a1719ebf4fbf4357"},
-    {file = "opencv_python-4.12.0.88-cp37-abi3-win_amd64.whl", hash = "sha256:d98edb20aa932fd8ebd276a72627dad9dc097695b3d435a4257557bbb49a79d2"},
+    {file = "opencv-python-headless-4.12.0.88.tar.gz", hash = "sha256:cfdc017ddf2e59b6c2f53bc12d74b6b0be7ded4ec59083ea70763921af2b6c09"},
+    {file = "opencv_python_headless-4.12.0.88-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:1e58d664809b3350c1123484dd441e1667cd7bed3086db1b9ea1b6f6cb20b50e"},
+    {file = "opencv_python_headless-4.12.0.88-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:365bb2e486b50feffc2d07a405b953a8f3e8eaa63865bc650034e5c71e7a5154"},
+    {file = "opencv_python_headless-4.12.0.88-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:aeb4b13ecb8b4a0beb2668ea07928160ea7c2cd2d9b5ef571bbee6bafe9cc8d0"},
+    {file = "opencv_python_headless-4.12.0.88-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:236c8df54a90f4d02076e6f9c1cc763d794542e886c576a6fee46ec8ff75a7a9"},
+    {file = "opencv_python_headless-4.12.0.88-cp37-abi3-win32.whl", hash = "sha256:fde2cf5c51e4def5f2132d78e0c08f9c14783cd67356922182c6845b9af87dbd"},
+    {file = "opencv_python_headless-4.12.0.88-cp37-abi3-win_amd64.whl", hash = "sha256:86b413bdd6c6bf497832e346cd5371995de148e579b9774f8eba686dee3f5528"},
 ]
 
 [package.dependencies]
@@ -2460,6 +2460,25 @@ urllib3 = ">=1.21.1,<3"
 socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
+[[package]]
+name = "returns"
+version = "0.26.0"
+description = "Make your functions return something meaningful, typed, and safe!"
+optional = false
+python-versions = "<4.0,>=3.10"
+groups = ["main"]
+files = [
+    {file = "returns-0.26.0-py3-none-any.whl", hash = "sha256:7cae94c730d6c56ffd9d0f583f7a2c0b32cfe17d141837150c8e6cff3eb30d71"},
+    {file = "returns-0.26.0.tar.gz", hash = "sha256:180320e0f6e9ea9845330ccfc020f542330f05b7250941d9b9b7c00203fcc3da"},
+]
+
+[package.dependencies]
+typing-extensions = ">=4.0,<5.0"
+
+[package.extras]
+check-laws = ["hypothesis (>=6.136,<7.0)", "pytest (>=8.0,<9.0)"]
+compatible-mypy = ["mypy (>=1.12,<1.18)"]
+
 [[package]]
 name = "rich"
 version = "14.1.0"
@@ -3162,4 +3181,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.12,<4.0"
-content-hash = "1968dbf21fc397693f6d77f371cbadecb97e287a5b07918c9ac7d730d09e614a"
+content-hash = "927913b9030d1f6c126bb2d12eab7307dc6297f259c7c62e3033706457d27ce0"

pyproject.toml

@@ -20,7 +20,8 @@ dependencies = [
     "lxml (>=6.0.2,<7.0.0)",
     "pillow (>=11.3.0,<12.0.0)",
     "imagetext-py (>=2.2.0,<3.0.0)",
-    "opencv-python (>=4.12.0.88,<5.0.0.0)",
+    "opencv-python-headless (>=4.12.0.88,<5.0.0.0)",
+    "returns (>=0.26.0,<0.27.0)",
 ]
 
 

scripts/test_plugin_load.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+import nonebot
+from loguru import logger
+
+nonebot.init()
+nonebot.load_plugins("konabot/plugins")
+
+plugins = nonebot.get_loaded_plugins()
+len_requires = len(
+    [f for f in (
+        Path(__file__).parent.parent / "konabot" / "plugins"
+    ).iterdir() if f.is_dir() and (f / "__init__.py").exists()]
+)
+
+plugins = [p for p in plugins if p.module.__name__.startswith("konabot.plugins")]
+
+logger.info(f"已经加载的插件数量 {len(plugins)}")
+logger.info(f"期待加载的插件数量 {len_requires}")
+
+assert len(plugins) == len_requires