upload miao-yunzai (#3)

- upload miao-yunzai (3bab65132a3410cf9337180811e8927cd9b3a28f)


Co-authored-by: Erzaozi <[email protected]>

.gitattributes

@@ -39,3 +39,8 @@ Yunzai/plugins/ws-plugin/resources/common/font/NZBZ.ttf filter=lfs diff=lfs merg
 Yunzai/plugins/ws-plugin/resources/help/icon.png filter=lfs diff=lfs merge=lfs -text
 Yunzai/plugins/genshin/resources/font/华文中宋.TTF filter=lfs diff=lfs merge=lfs -text
 Yunzai/plugins/genshin/resources/font/HYWenHei-55W.ttf filter=lfs diff=lfs merge=lfs -text
+Yunzai/plugins/miao-plugin/resources/admin/imgs/bg.png filter=lfs diff=lfs merge=lfs -text
+Yunzai/plugins/miao-plugin/resources/common/font/HYWH-65W.ttf filter=lfs diff=lfs merge=lfs -text
+Yunzai/plugins/miao-plugin/resources/common/font/HYWH-65W.woff filter=lfs diff=lfs merge=lfs -text
+Yunzai/plugins/miao-plugin/resources/common/font/NZBZ.ttf filter=lfs diff=lfs merge=lfs -text
+Yunzai/plugins/miao-plugin/resources/help/icon.png filter=lfs diff=lfs merge=lfs -text

Yunzai/plugins/miao-plugin/.gitignore

@@ -0,0 +1,20 @@
+*.psd
+.idea
+/tools/char-data-sprider.js
+/components/cfg.json
+/resources/miao-res-plus/
+/components/setting.json
+/config.js
+*.css.map
+/resources/character-img/*/upload/
+/resources/help/help-list.js
+/resources/help/help-cfg.js
+/resources/help/theme/*
+!/resources/help/theme/default
+/config/character.js
+/config/profile.js
+/config/help.js
+/config/cfg.js
+/resources/profile/super-character/*
+/resources/profile/normal-character/*
+/node_modules/

Yunzai/plugins/miao-plugin/CHANGELOG.md

@@ -0,0 +1,377 @@
+# 2.4.8
+
+* 星铁面板支持面板变换功能
+* 面板变换支持更换圣遗物套装，例如`#甘雨换乐团`、`#镜流换快枪手封印站`
+* 微调面板页面的部分样式
+
+# 2.4.1 ~ 2.4.7
+
+* 初步支持星铁面板数据获取与展示
+  * 可使用`#星铁更新面板`来获取面板信息，通过`#希儿面板`来进行查看
+  * 星铁面板展示圣遗物评分，评分功能尚未完全完成，分值与样式不为最终版本
+  * 部分角色的伤害计算，以及圣遗物评分功能仍在补全中
+  * 星铁面板天赋展示更新，支持展示行迹信息
+* 请配合使用Miao-Yunzai 3.1.0可达到最佳效果
+  * Miao-Yunzai可使用`*`来代填`#星铁`前缀，能区分游戏使用不同UID
+  * 其他Yunzai版本出现原神与星铁UID混淆情况为正常情况，请手动切换UID或命令后附加UID查询
+* 角色数据及资源更新
+  * 增加原神4.0~4.2的角色信息，可通过`#水神天赋`、`#水神图鉴`查看
+  * 更新星铁1.2~1.3的角色数据与资源
+* 伤害计算更新
+  * 增加林尼、卡夫卡、银狼的伤害计算**@Aluxes**
+  * 增加原神4.0相关的武器计算 **@SmallK111407**
+  * 增加菲米尼、符玄、玲可、三月七、娜塔莎、罗刹、黑塔的伤害计算 **@Aluxes**
+* 初步增加星铁的排名功能 **@Simplxss**
+* 增加`#喵喵api`命令，用于查看喵ApiToken的有效期
+* 增加`#星铁日历`功能 **@Aluxes**
+* 增加`#重载面板`功能，用于手工修改面板数据后主动读取
+* 停用旧面板格式数据，非AttrIDs格式的数据不会展示，部分角色面板数据不展示是正常情况，重新更新面板数据即可
+* 一些已知问题修复
+
+# 2.4.0
+
+* 增加`#角色记录``#抽卡统计`功能，可在`#喵喵设置`中开启
+  * `#角色记录`、`#武器记录`、`#常驻记录` 可查看对应池子的抽卡记录
+  * `#角色统计`、`#武器统计` 可按卡池汇总统计抽卡记录
+  * `#全部统计` 可将所有抽卡信息汇总展示
+  * 其余`#抽卡帮助`等相关功能均为Yunzai原生功能
+* 面板服务增加国内专属面板服务 MiniGG-API
+  * 由小灰灰大佬**@MiniGrayGay**与Enka官方合作部署
+  * 国内节点，免费开放，请求速度会比Enka更快
+* MiaoApi面板服务更新
+  * 使用新版接口获取面板，大幅提高响应速度
+  * 使用statsIds存储圣遗物数据，能够更精确的计算角色属性
+* `#喵喵设置`中可区分国服、B服、外服分别设置面板服务器，具体参见喵喵设置
+* `#面板`、`#角色`等页面使用Q版头像(@QuAn_、Misaaa)，可在#喵喵设置 中关闭
+* 增加白术、卡维的角色信息，可通过`#白术天赋`、`#白术图鉴`等查看
+* 部分已知问题调整或优化
+  * 圣遗物、天赋更新策略及更新逻辑优化
+  * 面板更新的提醒文案逻辑优化
+* `#雷神面板` 属性部分样式调整，增加圣遗物评分权重展示
+* 圣遗物评级的分数上限微调
+* 增加3.6新圣遗物数据及资源
+* 增加绮良良的角色信息，可通过`#绮良良天赋`、`#绮良良图鉴`等查看
+* 面板服务增加由**Snap Hutao**提供的Enka转发代理，可通过`#喵喵设置面板服务4`进行选择
+* 面板详情的圣遗物词条增加词条数展示
+* 角色面板使用平均词条值作为词条数计算基础
+* 部分角色资源文件结构调整
+
+# 2.3.0
+
+* 重写底层面板、角色数据获取与保存逻辑
+  * 底层完全兼容面板及Mys数据，对于miao-plugin的大部分场景可做到数据通用
+  * 角色数据及天赋增加缓存逻辑，有缓存数据情况下可在ck失效/验证码等情况下正常使用大部分功能
+  * 全量使用通过圣遗物属性计算得到的面板数据
+  * 面板底层数据结构及存储逻辑优化，兼容老版本数据
+  * Enka服务下使用statsIds存储圣遗物数据，能够更精确的计算角色属性
+* 增加`#角色`功能，查询并展示Mys角色信息
+  * Yunzai需要跟随游戏版本升级的功能会逐步在miao-plugin中提供，以保障基础功能相对长期可用
+  * 大部分功能目前默认关闭，可在`#喵喵设置`中设置并开启
+* 为`#喵喵设置`增加更多配置项
+  * 允许禁用非实装角色资料，关闭可禁用非实装角色资料及面板替换
+  * 允许禁用面板替换功能
+  * 允许禁用获取角色或面板原图功能
+  * 可选择面板服务，可选喵喵Api优先（需具备Token）或Enka优先
+  * 可设置群排名人数、圣遗物列表展示数 **@SmallK111407**
+* 角色信息及伤害计算更新
+  * 更新迪希雅、米卡的最新天赋与命座数据
+  * 增加瑶瑶伤害计算
+* 其他功能及界面优化，部分已知问题调整
+  * `#上传深渊` 界面与样式调整
+  * `#刷新排名`、`#禁用排名`、`#启用排名`可由群管理员进行管理
+  * 增加`#删除面板`命令，目前限绑定CK用户使用删除自己UID数据，Bot主人可删除任意UID数据
+
+# 2.2.0
+
+* 增加面板替换功能，可通过命令更换面板的圣遗物、武器、天赋命座等，用于伤害计算
+  * `#雷神面板换稻光换90级满命` / `#刻晴面板换雷神圣遗物` 等命令
+  * 更多命令参见 `#面板帮助`，请根据需求吟唱。后续会提供更细致的咒语详解
+* 增加角色面板立绘图相关命令 **@cvs**
+  * 支持`#上传刻晴面板图`上传
+  * 新增`#刻晴面板图列表`
+  * 可通过指令查询当前可看的面板立绘
+  * 立绘支持`#原图`指令
+* 角色立绘支持随机，用于面板场景
+  * 图像支持webp及png格式
+  * 普通立绘：**resources/profile/normal-character/**
+  * 彩蛋立绘（满命/ACE/三皇冠)：**resources/profile/super-character/**
+  * 单张立绘请放置在普通&彩蛋目录下，以**角色全名**为**文件名**，例如**刻晴.webp**
+  * 如需多张随机，请在普通&彩蛋目录下，以**角色全名**为**目录**名，任意文件名为文件名，例如 **刻晴/1.png**
+  * 较低版本的Yunzai可能无法正常使用miao-plugin
+* 部分底层结构升级
+  * 去除插件内自带的V2/V3兼容逻辑，使用runtime进行V2/V3兼容，如使用遇到问题请升级至最新版Yunzai
+  * 底层增加面板计算逻辑， 圣遗物数据底层存储格式与处理逻辑初步升级
+* 圣遗物主词条评分规则微调，可能会影响部分角色评分
+  * 元素杯属性不符会触发主词缀评分惩罚
+  * 充能主词条不再触发主词缀评分惩罚
+* 增加`#启用排名``#禁用排名`命令，可在全局启用排名情况下，在特定群内禁用排名功能
+* 更新迪希雅、米卡、瑶瑶、艾尔海森的信息，可通过`#瑶瑶天赋`、`#瑶瑶图鉴`等查看
+* 增加散兵、艾尔海森 **@panganqi**、珐露珊的伤害计算
+* 增加归终、米卡的角色图像
+* 其他一些已知问题修正与样式优化
+
+# 2.1.0
+
+* 增加群内排名功能
+  * 默认关闭，如需启用可通过 `#喵喵设置排名开启`进行打开
+  * 统计为bot本地统计，只统计在群内主动查看过的面板数据
+  * 可通过 `#面板`、`#心海面板`、`#更新面板`等命令来触发排名数据更新
+  * 增加命令 `#刷新排名`，获取群成员面板数据，刷新当前排名 **@munnks**
+  * `#雷神排名` 使用个人头像作为排行头像展示（首次使用可使用 `#刷新排名`以更新uid信息）
+* 增加排名相关命令
+  * 增加 `#最强雷神`、`#最高分甘雨`命令，查看当前统计中最高练度/最高圣遗物评分的面板数据
+  * 增加 `#雷神排名`、`#甘雨圣遗物排名`命令，查看当前群中角色的排名数据
+  * 增加 `#重置排名`、`#重置刻晴排名`命令，来重置当前群的排名统计
+* 面板及伤害计算升级
+  * `#雷神面板`圣遗物支持展示强化次数
+  * `#面板`会展示角色名命座信息
+  * 底层元素反应计算逻辑更新 **@冷落**
+  * 增加纳西妲的伤害计算
+* `#喵喵设置` 部分配置项及功能改进
+  * 删除一些无效或暂不支持的配置项
+  * 配置存储位置变更为**config/cfg.js**。原设置会自动迁移
+  * 喵喵设置中增加排名限制门槛，支持限制 有16个角色数据/包含御三家角色 才能参与排名，防止被非群成员uid刷榜
+* `#日历` 页面样式微调，功能升级
+  * 日历中会展示角色生日
+  * 日历会展示本日可刷天赋角色列表
+* 增加3.3角色信息及图片，可通过 `#散兵天赋`、`#珐露珊命座`查看
+* 一些样式及功能点优化
+  * 优化character的进入判定逻辑，防止一些额外的log触发
+  * 角色相关命令在V3下会联合V3的角色别名一同查询
+  * `#深渊组队`使用新版胡桃API进行组队信息获取
+* 增加命令 `#最强排行`、`#最高分排行` 查看群排行
+* 增加莱依拉的伤害计算及圣遗物评分权重
+
+# 2.0.0
+
+* 底层架构升级，以V3为主要版本，V2做兼容处理
+* `#深渊配队`、`#戳一戳` 适配V3
+* `#喵喵帮助`配置功能升级
+  * 支持自定义帮助皮肤包，皮肤目录为**resources/help/theme**
+  * 若有多套皮肤包，默认随机使用，可通过**config/help.js**指定
+  * 支持配帮助文字颜色及容器颜色与透明度
+  * 支持图片毛玻璃效果，默认开启，可通过配置关闭
+  * `注意1：` 如之前更改过底图可能会在更新后失效，可将自定义底图放置在新建的皮肤包目录内
+  * `注意2：` 为统一配置目录，帮助配置文件迁移至**config/help.js**，如之前自定义过配置文件，help-cfg.js仍能够识别，但建议移至新配置目录以使用后续更多功能
+* `#面板练度统计` 功能调整，样式重写
+  * 样式由深色调整为浅色方案
+  * 在未绑定CK时，使用本地面板数据展示练度信息
+* 重写 `#刻晴`、`#老婆`的角色卡片
+  * 样式整体升级，展示信息重新排版
+  * 未绑定CK时，会同时使用本地面板数据进行展示
+* `#上传深渊`队伍人数少于4人时展示样式优化
+* MysApi内部逻辑重写
+  * 在未绑定CK时，会使用本地面板数据综合计算，以使信息展示更完备
+  * 优化V3下获取Uid及CK的逻辑，防止一些情况下触发报错
+* 武器、圣遗物 meta数据及图像资源逻辑更新
+  * 重构武器及圣遗物的底层处理逻辑，重构页面引用图像资源的逻辑
+  * 图像资源更新为webp格式
+* 增加多莉的伤害计算
+* 其他已知Bug修复
+
+# 1.11.0
+
+* 面板圣遗物评分初步增加流派判定能力
+  * 实验性，尚未完全稳定，可能会导致一些角色圣遗物评分变化，如遇问题请反馈
+  * 目前实验暴力芭芭拉、血牛钟离的判定
+* `#刻晴面板`、`#芭芭拉圣遗物`支持展示角色时装
+  * 如果角色装备了时装，面板的角色图会展示时装立绘
+  * 需要重新 `#更新面板`以获取时装数据
+* 增加赛诺、妮露、坎蒂丝的角色信息，可以通过 `#妮露天赋`、`#妮露命座`查看角色信息了
+* 角色面板支持旅行者，暂未支持伤害计算及圣遗物评分
+  * 需要重新更新旅行者的面板数据
+* `#雷主天赋`、`#草主命座`功能升级
+  * 页面样式微调，内部处理逻辑升级
+  * 支持旅行者天赋及命座信息查看
+* 增加 `#心海图鉴`功能，可查看突破材料及常用武器
+  * 功能尚未完全稳定，信息还在继续补全中
+  * 如无需使用，master可通过 `#喵喵设置图鉴关闭`关闭，防止覆盖图鉴插件等图鉴功能
+* 框架底层角色相关逻辑重构，角色图像资源迁移为webp格式
+  * 若遇到图像资源无法正常展示，可联系喵喵反馈
+
+# 1.10.0
+
+* 新增 `#面板练度统计`功能
+  * 可展示当前角色天赋及圣遗物练度信息
+  * 需要用户绑定Cookie，圣遗物评分需要本地获取并查看过对应角色面板
+* `#上传深渊`使用图片渲染深渊结果，同时可被 `#喵喵深渊`触发
+  * 可展示本期深渊的全部角色信息，包括组队、天赋及圣遗物
+  * 数据会上传至胡桃Api进行伤害排名，并展示在页面内
+  * 可在 `#喵喵设置`中启用 `#喵喵深渊`作为默认 `#深渊`，默认关闭
+  * 启用后不会覆盖 `#上期深渊`以及 `#深渊12层`具体楼层的命令
+* `#面板`、`#更新面板`命令使用图片渲染结果
+* `#雷神面板`展示数据API及更新时间
+* Enka面板服务支持配置代理 **@永恒的小黑屋**
+  * 如需配置可在**miao-plugin/config/profile.js**文件中配置
+* `#更新面板`支持配置更新API，适配Enka新校验逻辑
+  * B服角色使用Enka服务进行面板信息获取
+  * 感谢Enka官方 **@Algoinde**的官方授权及UA**校**验
+  * 感谢 **@MiniGrayGay**提供的Enka服务中转，若面板更新失败可尝试在**miao-plugin/config/profile.js**文件中配置切换更新API
+  * 更新面板增加单用户更新间隔控制，默认5分钟
+* `#深渊出场率`、`#角色持有率` 增加样本数量展示，增加数据使用授权提示
+* 部分角色的圣遗物评分增加充能的词条评分权重
+* 重构部分components、models逻辑，重构部分伤害计算逻辑
+* 伤害计算支持除旅行者外的全部角色
+* 伤害计算暂未包含3.0新元素反应，后续统一补充
+
+# 1.9.0
+
+* 初步适配Yunzai V3
+  * 部分功能可能无法正常使用，会逐步适配
+  * 部分依赖MysApi查询的功能在V3下暂时只支持查自己
+* 增加提纳里、柯莱、多莉的资料及角色图像
+  * 可通过 `#柯莱天赋`、`#柯莱命座`查看资料
+* 增加 `#深渊使用率`命令，数据源自DGP-Studio胡桃API
+* 新增 `#上传深渊数据`命令
+  * 上传自己角色的深渊挑战数据及角色列表，并展示在本期深渊中伤害与承伤排名
+  * 上传数据用于 `#角色持有率 #深渊出场率`等统计，可使统计更加及时准确
+  * 数据统计及服务来自DGP-Studio胡桃API
+* 增加 `#添加刻晴图像`命令，感谢 **@叶**
+  * 可通过命令上传添加指定角色图片，上传至 **resources/character-img/刻晴/upload**
+  * 请将图像与命令一同发送，后续会支持at图像及命令后发送图像
+* `#刻晴` 角色卡片功能升级
+  * `#老婆设置刻晴，心海`不再检查是否具有角色或展示在米游社展柜
+  * `#刻晴` 角色卡片优先使用面板数据进行展示，无面板数据时使用米游社数据
+  * 在未能获取到角色数据时也会展示角色卡片
+* 支持戳一戳返回喵喵版角色卡片，暂不支持V3 Yunzai
+  * 需要使用喵喵分支Yunzai以支持此能力，如需切换可在Yunzai根目录输入下方命令后更新重启
+  * `git remote set-url origin https://gitee.com/yoimiya-kokomi/Yunzai-Bot`
+  * 可通过 `#喵喵设置` 关闭戳一戳
+* 支持定义新角色及别名
+  * 新增角色 派蒙、瑶瑶、白术、伐难、应达、散兵、女士、萍姥姥、仆人、少女、富人、博士、木偶、丑角、队长、妮露、纳西妲 的角色配置及图片
+  * 自定义角色可使用 `#派蒙` `#派蒙图片`触发图片��看，`#女儿设置派蒙`进行设置。后续会支持更多场景
+  * 如需扩展可在喵喵config/character.js中定义
+* `#喵喵帮助`增加对自定义配置文件的支持
+* 角色伤害计算增加 鹿野院平藏、烟绯
+* `#喵喵日历`现在可通过 `#日历 #日历列表`触发
+
+# 1.8.0
+
+* `#角色面板`、`#圣遗物列表` 使用新的圣遗物评分逻辑计算评分
+  * 新的圣遗物评分规针对不同角色进行了细化，对不同角色的评分进行了拉齐
+  * 不同角色基于不同词条权重进行计算。感谢 **@糖炒栗子 @秋声 @49631073**等的权重梳理
+* 增加 `#雷神圣遗物`命令
+  * 展示指定角色圣遗物及评分计算详情
+  * 展示新版圣遗物评分逻辑与计算规则
+* 增加 `#原图`命令，可获取喵喵角色卡片原图，感谢 **@牧星长** 提供功能
+  * 对由 `#老婆 #刻晴`发出的角色卡片图回复 `#原图`可获取对应图像
+* `#角色面板`现在支持B服角色数据获取
+  * 数据来自喵喵API，目前开放调用无需Token，仅限喵喵插件用户使用
+  * 已知问题：角色天赋的皇冠及命座加成效果显示可能有问题，后期fix
+* `#录入角色面板` 功能恢复
+  * 可对已有面板数据的角色手工输入更改面板属性，用于伤害测算
+  * 例如 `#录入雷神面板 暴击80，暴伤250`
+  * 暂不支持设置武器、圣遗物、命座、天赋。后续会增加支持
+* 部分页面样式调整及功能优化
+  * `#角色持有率` 等增加提示说明
+  * `#圣遗物列表` 展示个数提升至28，且根据新版圣遗物评分规则进行词条高亮
+  * `#喵喵更新` 的自动重启功能适配node app方式启动的Yunzai-Bot，感谢 **@SirlyDreamer**
+* 角色图像增加小清新开关，默认关闭
+  * 对增量包内的角色图像进行分级，较为清凉的图像独立管理
+  * 勇士们可使用 `#喵喵设置小清新开启` 启用
+* 伤害计算增加扩散、感电的计算逻辑，感谢 **@49631073**的逻辑梳理
+* `#角色面板` 伤害计算增加部分角色，目前支持
+  * 长柄武器：雷神、胡桃、魈、钟离、香菱
+  * 法器：神子、心海、可莉、凝光、芭芭拉、莫娜
+  * 弓：甘雨、宵宫、公子，九条，迪奥娜、安柏、皇女、温迪、夜兰
+  * 单手剑：绫人、绫华、刻晴、阿贝多、行秋、班尼特、七七、凯亚、琴、万叶ⁿᵉʷ、久岐忍ⁿᵉʷ
+  * 双手剑：一斗、优菈、迪卢克、诺艾尔、重云
+
+# 1.7.0
+
+* `#更新面板` 功能升级
+  * 该功能可直接使用，不再需要token
+  * 在查询新用户时会自动使用，自动使用的CD 12小时
+  * 支持国际服UID，目前暂不支持2及5开头的UID
+  * 服务来自enka api，部分网络可能无法请求，请科学处理，后续会增加转发服务。
+  * 由于服务逻辑与之前数据不一致，部分角色的属性及伤害计算可能会不准确，如有发现请反馈给喵喵
+* `#面板`、`#更新面板`、`#角色面板`、`#角色伤害`、`#圣遗物列表`不再需要绑定cookie，支持查他人
+  * 使用 `#面板`命令可查看已获取面板数据的角色列表
+  * 默认查询自己UID，同时也可通过命令+uid方式指定查询对象
+  * 由于整体逻辑变化，喵喵1.6.0之前更新的面板数据无法查看，需要重新更新数据
+* 增加 `#喵喵面板设置`命令，可更精细的设置是否允许好友/临时对话/群使用面板功能
+* 由 `#录入xx面板` 录入的数据暂时屏蔽
+* `#角色面板`、`#喵喵日历` 部分细节样式调整
+* `#角色面板` 伤害计算增加部分角色，目前支持
+  * 长柄武器：雷神、胡桃、魈、钟离、香菱
+  * 法器：神子、心海、可莉、凝光、芭芭拉、莫娜ⁿᵉʷ
+  * 弓：甘雨、宵宫、公子，九条，迪奥娜、安柏、皇女ⁿᵉʷ、温迪ⁿᵉʷ、夜兰ⁿᵉʷ
+  * 单手剑：绫人、绫华、刻晴、阿贝多、行秋、班尼特、七七、凯亚、琴ⁿᵉʷ
+  * 双手剑：一斗、优菈、迪卢克、诺艾尔、重云
+
+# 1.6.0
+
+* `#喵喵设置` 支持设置 面板查询 的功能开关
+* `#喵喵版本` 使用图片展示更新信息
+* `#喵喵日历` 升级
+  * 增加 `#喵喵日历列表`命令，以列表形式展示活动信息
+  * 增加从活动详情信息中解析活动日期的逻辑，使一些活动日期更加准确
+* 增加鹿野院平藏的角色信息，可通过 `#平藏天赋`、`#平藏命座`查看信息
+* 其他升级调整
+  * `#深渊出场率`、`#角色持有率` 等页面功能及样式微调
+  * `#角色面板` 伤害计算增加双手剑计算逻辑，增加物伤计算逻辑
+  * 页面版权信息展示Yunzai及喵喵版本号
+* `#角色面板` 伤害计算增加部分角色，目前支持
+  * 长柄武器：雷神、胡桃、魈、钟离、香菱
+  * 法器：神子、心海、可莉ⁿᵉʷ、凝光ⁿᵉʷ、芭芭拉ⁿᵉʷ
+  * 弓：甘雨、宵宫、公子，九条ⁿᵉʷ，迪奥娜ⁿᵉʷ、安柏ⁿᵉʷ
+  * 单手剑：��人、绫华、刻晴、阿贝多、行秋、班尼特、七七ⁿᵉʷ、凯亚ⁿᵉʷ
+  * 双手剑：一斗ⁿᵉʷ、优菈ⁿᵉʷ、迪卢克ⁿᵉʷ、诺艾尔ⁿᵉʷ、重云ⁿᵉʷ
+
+# 1.5.0
+
+* 增加 `#喵喵日历` 功能
+  * 【！请注意！】此功能需要安装moment库，请在Yunzai安装目录下运行 `npm install moment`后再进行升级
+  * 展示当前进行中及即将开始的活动，包括深境螺旋
+* `#角色面板` 伤害计算目前支持
+  * 长柄武器：雷神、胡桃、魈、钟离、香菱ⁿᵉʷ
+  * 法器：神子、心海
+  * 弓：甘雨、宵宫、公子
+  * 单手剑：绫人、绫华、刻晴、阿贝多ⁿᵉʷ、行秋ⁿᵉʷ、班尼特ⁿᵉʷ
+* 底层升级：抽象了部分公共组件为tpl模板以提高复用度，css改为less处理
+
+# 1.4.0
+
+* 增加 `#深渊配队` 功能
+  * 根据当前账号的角色练度及本期深渊出场数据，推荐较匹配的配队方案
+  * 深渊出场数据来自DGP-Studio胡桃API
+  * 配队方案仅供参考
+* `#角色面板` 伤害计算新增部分角色
+  * 目前支持：雷神、胡桃、魈、神子、甘雨、宵宫、公子、绫人、绫华、心海、钟离
+* `#角色面板` 一些功能升级与调整
+  * 支持对治疗量、护盾量的计算与展示
+  * 修复冰融化、少女4等buff等buff遗漏或错误导致的伤害计算偏差
+* `#老婆` 功能支持对jpeg格式的图片格式识别
+
+# 1.3.0
+
+* 增加 `#雷神伤害` 功能
+  * 可计算圣遗物副词条置换带来的伤害变化，可用于圣遗物副词条侧重方向的参考
+  * 可以查看指定角色伤害计算的Buff列表
+* `#角色面板` 伤害计算新增部分角色
+  * 目前支持：雷神、胡桃、魈、神子、甘雨、宵宫、公子、绫人、绫华
+* `#角色面板` 功能升级
+  * 优化无角色面板数据时的引导
+  * 优化返回的图像格式及分辨率，平衡响应速度及显示效果
+* 增加 `#圣遗物列表` 功能，对已经获取面板的所有角色圣遗物进行评分，并展示高评分的圣遗物列表
+* 增加 `#角色面板列表` / `#角色面板帮助` 命令
+* 增加 `#更新胡桃面板` 命令，获取单个角色面板数据，每天可更新5次
+* 更改 `#更新全部面板` 命令，获取角色展柜全部8个角色，每天可更新3次
+
+# 1.2.0
+
+* `#角色面板` 增加伤害计算功能
+  * 目前支持角色：雷神、胡桃、魈、神子、甘雨
+  * 可通过 `#怪物等级85` 命令设定怪物等级，以获得更准确的计算结果
+  * 计算伤害为满Buff情况，后续会出更详细的Buff及计算展示
+* `#获取游戏角色详情`命令在服务侧增加基于UID的天频度限制
+* 增加 `#喵喵更新` 功能
+  * 感谢 @碎月 @清秋 的代码支持
+  * 若更新成功会重启Yunzai，需要Yunzai以 npm run start 模式启动
+  * 尚未经充分测试，请有一定容错能力的勇士尝试
+  * 增加 `#喵喵版本`命令查询版本信息
+
+# 1.1.0
+
+* 增加 `#喵喵帮助`用于查看帮助命令
+* 增加 `#喵喵设置`用于设置喵喵相关功能

Yunzai/plugins/miao-plugin/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Yoimiya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Yunzai/plugins/miao-plugin/README.md

@@ -0,0 +1,106 @@
+# Miao-Plugin 说明
+
+`miao-plugin`是一个`Yunzai-Bot`的升级插件，提供包括角色面板、角色查询等角色相关功能。
+
+具体功能可在安装插件后 通过 `#喵喵帮助` 进行查看。如需进行设置则可通过 `#喵喵设置` 命令进行管理。
+
+---
+
+## 安装与更新
+
+### 使用Git安装（推荐）
+
+请将 miao-plugin 放置在 Yunzai-Bot 的 plugins 目录下，重启 Yunzai-Bot 后即可使用。
+
+请使用 git 进行安装，以方便后续升级。在 Yunzai-Bot 根目录夹打开终端，运行下述指令之一
+
+```
+// 使用gitee
+git clone --depth=1 https://gitee.com/yoimiya-kokomi/miao-plugin.git ./plugins/miao-plugin/
+pnpm install -P
+
+// 使用github
+git clone --depth=1 https://github.com/yoimiya-kokomi/miao-plugin.git ./plugins/miao-plugin/
+pnpm install -P
+```
+
+进行安装。安装完毕后，管理员只需发送 `#喵喵更新` 即可自动更新 miao-plugin。
+
+### 手工下载安装（不推荐）
+
+手工下载安装包，解压后将`miao-plugin-master`更名为`miao-plugin`，然后放置在Yunzai的plugins目录内
+
+虽然此方式能够使用，但无法使用`#喵喵更新`进行更新，不利于后续升级，故不推荐使用
+
+---
+
+## Yunzai版本与支持
+
+`miao-plugin` 支持V3 / V2 版本的Yunzai-Bot
+
+* [Miao-Yunzai](https://github.com/yoimiya-kokomi/Miao-Yunzai) : 喵版Yunzai [Gitee](https://gitee.com/yoimiya-kokomi/Miao-Yunzai)
+  / [Github](https://github.com/yoimiya-kokomi/Miao-Yunzai) ，本体不含签到功能，功能迭代较多，与miao-plugin打通，只建议新部署/迁移
+* [Yunzai-V3](https://github.com/yoimiya-kokomi/Yunzai-Bot) ：Yunzai V3 - 喵喵维护版，icqq版本，与原版Yunza功能基本一致，会保持卡池更新，功能相对稳定，可从原版Yunzai换源直接升级
+* [Yunzai-V3](https://gitee.com/Le-niao/Yunzai-Bot) ：Yunzai V3 - 乐神原版，oicq版本，可能会遇到登录问题
+
+---
+
+## 功能说明
+
+### #雷神面板
+
+使用指令 `#面板帮助` 即可了解如何使用此功能。
+
+#### #更新面板
+
+`#更新面板` 依赖于面板查询API，面板服务由 http://enka.network/ 提供。
+
+> 查询功能经Enka官方授权([issue#63](https://github.com/yoimiya-kokomi/miao-plugin/issues/63#issuecomment-1199348789))，感谢Enka提供的面板查询服务
+>
+> 如果可以的话，也请在Patreon上支持Enka，或提供闲置的原神账户，具体可在[Enka官网](http://enka.network/) Discord联系
+>
+> [issue#63](https://github.com/yoimiya-kokomi/miao-plugin/issues/63#issuecomment-1199734496)
+
+> 可尝试使用`MiniGG-Api`面板服务 [@MiniGrayGay](https://github.com/MiniGrayGay)<br>
+> 发送 `#喵喵设置面板服务332` 修改国服&B服的面板查询由 `MiniGG-Api` 处理
+
+#### #雷神伤害
+
+喵喵面板附带的伤害计算功能由喵喵本地计算。如计算有偏差 #雷神伤害 查看伤害加成信息，如确认伤害计算有误可提供伤害录屏截图及uid进行反馈
+
+#### #雷神圣遗物
+
+圣遗物评分为喵喵版评分规则
+
+---
+
+**在有一定阅读理解能力基础下，建议阅读 [CHANGELOG.md](CHANGELOG.md) 以了解更多内容。**
+
+其余文档咕咕咕中
+
+---
+
+# 免责声明
+
+1. `miao-plugin`自身的UI与代码均开放，无需征得特殊同意，可任意使用。能备注来源最好，但不强求
+2. 以上声明但仅代表`miao-plugin`自身的范畴，请尊重Yunzai本体及其他插件作者的努力，勿将Yunzai及其他插件用于以盈利为目的的场景
+3. miao-plugin的图片与其他素材均来自于网络，仅供交流学习使用，如有侵权请联系，会立即删除
+
+# 资源
+
+* [Miao-Yunzai](https://github.com/yoimiya-kokomi/Miao-Yunzai) : 喵版Yunzai [Gitee](https://gitee.com/yoimiya-kokomi/Miao-Yunzai)
+  / [Github](https://github.com/yoimiya-kokomi/Miao-Yunzai)
+* [Yunzai-V3](https://github.com/yoimiya-kokomi/Yunzai-Bot) ：Yunzai V3 - 喵喵维护版（使用 icqq）
+* [Yunzai-V3](https://gitee.com/Le-niao/Yunzai-Bot) ：Yunzai V3 - 乐神原版（使用 oicq）
+* [miao-plugin](https://github.com/yoimiya-kokomi/miao-plugin) : 喵喵插件 [Gitee](https://gitee.com/yoimiya-kokomi/miao-plugin)
+  / [Github](https://github.com/yoimiya-kokomi/miao-plugin)
+
+# 其他&感谢
+
+* [Enka.Network](https://enka.network/): 感谢Enka提供的面板服务
+* [Snap.Hutao](https://hut.ao/) : 感谢 DGP Studio 开发的 [胡桃 API](https://github.com/DGP-Studio/Snap.Hutao.Server)
+* QQ群（暂时停止新加入，请见谅）
+    * Yunzai-Bot 官方QQ群：213938015
+    * 喵喵Miao-Plugin QQ群：607710456
+* [爱发电](https://afdian.net/@kokomi) :欢迎老板打赏，喵~
+

Yunzai/plugins/miao-plugin/apps/admin.js

@@ -0,0 +1,204 @@
+import fs from 'fs'
+import lodash from 'lodash'
+import { exec } from 'child_process'
+import { Cfg, Common, Data, Version, App } from '#miao'
+import fetch from 'node-fetch'
+
+let keys = lodash.map(Cfg.getCfgSchemaMap(), (i) => i.key)
+let app = App.init({
+  id: 'admin',
+  name: '喵喵设置',
+  desc: '喵喵设置'
+})
+
+let sysCfgReg = new RegExp(`^#喵喵设置\\s*(${keys.join('|')})?\\s*(.*)$`)
+
+app.reg({
+  updateRes: {
+    rule: /^#喵喵(强制)?(更新图像|图像更新)$/,
+    fn: updateRes,
+    desc: '【#管理】更新素材'
+  },
+  update: {
+    rule: /^#喵喵(强制)?更新$/,
+    fn: updateMiaoPlugin,
+    desc: '【#管理】喵喵更新'
+  },
+  sysCfg: {
+    rule: sysCfgReg,
+    fn: sysCfg,
+    desc: '【#管理】系统设置'
+  },
+  miaoApiInfo: {
+    rule: /^#喵喵api$/,
+    fn: miaoApiInfo,
+    desc: '【#管理】喵喵Api'
+  }
+})
+
+export default app
+
+const _path = process.cwd()
+const resPath = `${_path}/plugins/miao-plugin/resources/`
+const plusPath = `${resPath}/miao-res-plus/`
+
+const checkAuth = async function (e) {
+  if (!e.isMaster) {
+    e.reply(`只有主人才能命令喵喵哦~
+    (*/ω＼*)`)
+    return false
+  }
+  return true
+}
+
+async function sysCfg (e) {
+  if (!await checkAuth(e)) {
+    return true
+  }
+
+  let cfgReg = sysCfgReg
+  let regRet = cfgReg.exec(e.msg)
+  let cfgSchemaMap = Cfg.getCfgSchemaMap()
+
+  if (!regRet) {
+    return true
+  }
+
+  if (regRet[1]) {
+    // 设置模式
+    let val = regRet[2] || ''
+
+    let cfgSchema = cfgSchemaMap[regRet[1]]
+    if (cfgSchema.input) {
+      val = cfgSchema.input(val)
+    } else {
+      val = cfgSchema.type === 'num' ? (val * 1 || cfgSchema.def) : !/关闭/.test(val)
+    }
+    Cfg.set(cfgSchema.cfgKey, val)
+  }
+
+  let schema = Cfg.getCfgSchema()
+  let cfg = Cfg.getCfg()
+  let imgPlus = fs.existsSync(plusPath)
+
+  // 渲染图像
+  return await Common.render('admin/index', {
+    schema,
+    cfg,
+    imgPlus,
+    isMiao: Version.isMiao
+  }, { e, scale: 1.4 })
+}
+
+async function updateRes (e) {
+  if (!await checkAuth(e)) {
+    return true
+  }
+  let isForce = e.msg.includes('强制')
+  let command = ''
+  if (fs.existsSync(`${resPath}/miao-res-plus/`)) {
+    e.reply('开始尝试更新，请耐心等待~')
+    command = 'git pull'
+    if (isForce) {
+      command = 'git  checkout . && git  pull'
+    }
+    exec(command, { cwd: `${resPath}/miao-res-plus/` }, function (error, stdout, stderr) {
+      console.log(stdout)
+      if (/(Already up[ -]to[ -]date|已经是最新的)/.test(stdout)) {
+        e.reply('目前所有图片都已经是最新了~')
+        return true
+      }
+      let numRet = /(\d*) files changed,/.exec(stdout)
+      if (numRet && numRet[1]) {
+        e.reply(`报告主人，更新成功，此次更新了${numRet[1]}个图片~`)
+        return true
+      }
+      if (error) {
+        e.reply('更新失败！\nError code: ' + error.code + '\n' + error.stack + '\n 请稍后重试。')
+      } else {
+        e.reply('图片加量包更新成功~')
+      }
+    })
+  } else {
+    command = `git clone https://gitee.com/yoimiya-kokomi/miao-res-plus.git "${resPath}/miao-res-plus/" --depth=1`
+    e.reply('开始尝试安装图片加量包，可能会需要一段时间，请耐心等待~')
+    exec(command, function (error, stdout, stderr) {
+      if (error) {
+        e.reply('角色图片加量包安装失败！\nError code: ' + error.code + '\n' + error.stack + '\n 请稍后重试。')
+      } else {
+        e.reply('角色图片加量包安装成功！您后续也可以通过 #喵喵更新图像 命令来更新图像')
+      }
+    })
+  }
+  return true
+}
+
+let timer
+
+async function updateMiaoPlugin (e) {
+  if (!await checkAuth(e)) {
+    return true
+  }
+  let isForce = e.msg.includes('强制')
+  let command = 'git  pull'
+  if (isForce) {
+    command = 'git  checkout . && git  pull'
+    e.reply('正在执行强制更新操作，请稍等')
+  } else {
+    e.reply('正在执行更新操作，请稍等')
+  }
+  exec(command, { cwd: `${_path}/plugins/miao-plugin/` }, function (error, stdout, stderr) {
+    if (/(Already up[ -]to[ -]date|已经是最新的)/.test(stdout)) {
+      e.reply('目前已经是最新版喵喵了~')
+      return true
+    }
+    if (error) {
+      e.reply('喵喵更新失败！\nError code: ' + error.code + '\n' + error.stack + '\n 请稍后重试。')
+      return true
+    }
+    e.reply('喵喵更新成功，正在尝试重新启动Yunzai以应用更新...')
+    timer && clearTimeout(timer)
+    Data.setCacheJSON('miao:restart-msg', {
+      msg: '重启成功，新版喵喵已经生效',
+      qq: e.user_id
+    }, 30)
+    timer = setTimeout(function () {
+      let command = 'npm run start'
+      if (process.argv[1].includes('pm2')) {
+        command = 'npm run restart'
+      }
+      exec(command, function (error, stdout, stderr) {
+        if (error) {
+          e.reply('自动重启失败，请手动重启以应用新版喵喵。\nError code: ' + error.code + '\n' + error.stack + '\n')
+          Bot.logger.error(`重启失败\n${error.stack}`)
+          return true
+        } else if (stdout) {
+          Bot.logger.mark('重启成功，运行已转为后台，查看日志请用命令：npm run log')
+          Bot.logger.mark('停止后台运行命令：npm stop')
+          process.exit()
+        }
+      })
+    }, 1000)
+  })
+  return true
+}
+
+async function miaoApiInfo (e) {
+  if (!await checkAuth(e)) {
+    return true
+  }
+  let { diyCfg } = await Data.importCfg('profile')
+  let { qq, token } = (diyCfg?.miaoApi || {})
+  if (!qq || !token) {
+    return e.reply('未正确填写miaoApi token，请检查miao-plugin/config/profile.js文件')
+  }
+  if (token.length !== 32) {
+    return e.reply('miaoApi token格式错误')
+  }
+  let req = await fetch(`http://miao.games/api/info?qq=${qq}&token=${token}`)
+  let data = await req.json()
+  if (data.status !== 0) {
+    return e.reply('token检查错误，请求失败')
+  }
+  e.reply(data.msg)
+}

Yunzai/plugins/miao-plugin/apps/character.js

@@ -0,0 +1,36 @@
+import { uploadCharacterImg } from './character/ImgUpload.js'
+import { getOriginalPicture } from './profile/ProfileUtils.js'
+import Avatar from './character/AvatarCard.js'
+import Wife from './character/AvatarWife.js'
+import { App } from '#miao'
+
+let app = App.init({
+  id: 'character',
+  name: '角色查询'
+})
+
+app.reg({
+  character: {
+    rule: /^#喵喵角色卡片$/,
+    fn: Avatar.render,
+    check: Avatar.check,
+    name: '角色卡片'
+  },
+  uploadImg: {
+    rule: /^#*(喵喵)?(上传|添加)(.+)(照片|写真|图片|图像)\s*$/,
+    fn: uploadCharacterImg,
+    name: '上传角色写真'
+  },
+  wife: {
+    rule: Wife.reg,
+    fn: Wife.render,
+    describe: '#老公 #老婆 查询'
+  },
+  originalPic: {
+    rule: /^#?(获取|给我|我要|求|发|发下|发个|发一下)?原图(吧|呗)?$/,
+    fn: getOriginalPicture,
+    describe: '【#原图】 回复角色卡片，可获取原图'
+  }
+})
+
+export default app

Yunzai/plugins/miao-plugin/apps/character/AvatarCard.js

@@ -0,0 +1,132 @@
+import { Character, MysApi, Player } from '#miao.models'
+import { Cfg, Common } from '#miao'
+import lodash from 'lodash'
+import moment from 'moment'
+
+let Avatar = {
+  render (e) {
+    if (!e.char) {
+      return false
+    }
+    return Avatar.renderAvatar(e, e.char?.name)
+  },
+  async renderAvatar (e, avatar, renderType = 'card') {
+    // 如果传递的是名字，则获取
+    if (typeof (avatar) === 'string') {
+      // 检查角色
+      let char = Character.get(avatar)
+      if (!char) {
+        return false
+      }
+      let mys = await MysApi.init(e)
+      if (!mys) return true
+      if (!char.isRelease) {
+        avatar = { id: char.id, name: char.name, detail: false }
+      } else {
+        let player = Player.create(e)
+        await player.refreshMysDetail(1)
+        await player.refreshTalent(char.id, 1)
+        avatar = player.getAvatar(char.id)
+        if (!avatar) {
+          avatar = { id: char.id, name: char.name, detail: false }
+        }
+      }
+    }
+    return await Avatar.renderCard(e, avatar, renderType)
+  },
+
+  async renderCard (e, avatar, renderType = 'card') {
+    let char = Character.get(avatar.id)
+    if (!char) {
+      return false
+    }
+    let bg = char.getCardImg(Cfg.get('charPicSe', false))
+    if (renderType === 'photo') {
+      e.reply(segment.image(`file://${process.cwd()}/plugins/miao-plugin/resources/${bg.img}`))
+      return true
+    }
+    let uid = e.uid || (e.targetUser && e.targetUser.uid)
+    let data = {}
+    let custom = char.isCustom
+    let isRelease = char.isRelease
+    if (isRelease && avatar.hasData) {
+      data = avatar.getDetail()
+      data.imgs = char.imgs
+      data.source = avatar._source
+      data.artis = avatar.getArtisDetail()
+      data.updateTime = moment(new Date(avatar._time)).format('MM-DD HH:mm')
+      if (data.hasTalent) {
+        data.talent = avatar.talent
+        data.talentMap = ['a', 'e', 'q']
+        // 计算皇冠个数
+        data.crownNum = lodash.filter(lodash.map(data.talent, (d) => d.original), (d) => d >= 10).length
+      }
+    } else {
+      data = char.getData('id,name,sName')
+    }
+
+    let width = 600
+    let imgCss = ''
+    let scale = 1.2
+    if (bg.mode === 'left') {
+      const height = 480
+      width = height * bg.width / bg.height
+      imgCss = `img.bg{width:auto;height:${height}px;}`
+      scale = 1.45
+    }
+    // 渲染图像
+    let msgRes = await Common.render('character/character-card', {
+      saveId: uid,
+      uid,
+      bg,
+      widthStyle: `<style>html,body,#container{width:${width}px} ${imgCss}</style>`,
+      mode: bg.mode,
+      custom,
+      isRelease,
+      data
+    }, { e, scale, retMsgId: true })
+    if (msgRes) {
+      // 如果消息发送成功，就将message_id和图片路径存起来，3小时过期
+      const message_id = [e.message_id]
+      if (Array.isArray(msgRes.message_id)) {
+        message_id.push(...msgRes.message_id)
+      } else {
+        message_id.push(msgRes.message_id)
+      }
+      for (const i of message_id) {
+        await redis.set(`miao:original-picture:${i}`, JSON.stringify({ type: 'character', img: bg.img }), { EX: 3600 * 3 })
+      }
+    }
+    return true
+  },
+  check (e) {
+    let msg = e.original_msg || e.msg
+    if (!msg || !/^#/.exec(msg)) {
+      return false
+    }
+    if (!Common.cfg('avatarCard')) {
+      return false
+    }
+    let uidRet = /[0-9]{9}/.exec(msg)
+    if (uidRet) {
+      e.uid = uidRet[0]
+      msg = msg.replace(uidRet[0], '')
+    }
+    let name = msg.replace(/#|老婆|老公|卡片/g, '').trim()
+
+    // cache gsCfg
+    Character.gsCfg = Character.gsCfg || e?.runtime?.gsCfg
+
+    let char = Character.get(name.trim())
+
+    if (!char) {
+      return false
+    }
+
+    e.msg = '#喵喵角色卡片'
+    e.char = char
+    return true
+  }
+
+}
+export default Avatar

Yunzai/plugins/miao-plugin/apps/character/AvatarWife.js

@@ -0,0 +1,188 @@
+// #老婆
+import lodash from 'lodash'
+import { Common } from '#miao'
+import { Character, MysApi, Player } from '#miao.models'
+import Avatar from './AvatarCard.js'
+
+const relationMap = {
+  wife: {
+    keyword: '老婆,媳妇,妻子,娘子,宝贝'.split(','),
+    type: 0
+  },
+  husband: {
+    keyword: '老公,丈夫,夫君,郎君,死鬼'.split(','),
+    type: 1
+  },
+  gf: {
+    keyword: '女朋友,女友,女神,女王,女票'.split(','),
+    type: 0
+  },
+  bf: {
+    keyword: '男朋友,男友,男神,男票'.split(','),
+    type: 1
+  },
+  daughter: {
+    keyword: '女儿,闺女,小宝贝'.split(','),
+    type: 2
+  },
+  son: {
+    keyword: '儿子,犬子'.split(','),
+    type: 3
+  }
+}
+
+const relation = lodash.flatMap(relationMap, (d) => d.keyword)
+const wifeReg = `^#?\\s*(${relation.join('|')})\\s*(设置|选择|指定|列表|查询|列表|是|是谁|照片|相片|图片|写真|图像)?\\s*([^\\d]*)\\s*(\\d*)$`
+
+async function getAvatarList (player, type) {
+  await player.refreshMysDetail()
+  let list = []
+  player.forEachAvatar((avatar) => {
+    if (type !== false) {
+      if (!avatar.char.checkWifeType(type)) {
+        return true
+      }
+    }
+    list.push(avatar)
+  })
+
+  if (list.length <= 0) {
+    return false
+  }
+  let sortKey = 'level,fetter,weapon_level,rarity,weapon_rarity,cons,weapon_affix_level'
+  list = lodash.orderBy(list, sortKey, lodash.repeat('desc,', sortKey.length).split(','))
+  return list
+}
+
+const Wife = {
+  reg: wifeReg,
+  async render (e) {
+    let msg = e.msg || ''
+    if (!msg && !e.isPoke) return false
+
+    if (e.isPoke) {
+      if (!Common.cfg('avatarPoke')) {
+        return false
+      }
+    } else if (!Common.cfg('avatarCard')) {
+      return false
+    }
+
+    let msgRet = (new RegExp(wifeReg)).exec(msg)
+    if (e.isPoke) {
+      msgRet = []
+    } else if (!msgRet) {
+      return false
+    }
+    let target = msgRet[1]
+    let action = msgRet[2] || '卡片'
+    let actionParam = msgRet[3] || ''
+
+    if (!'设置,选择,挑选,指定'.split(',').includes(action) && actionParam) {
+      return false
+    }
+
+    let targetCfg = lodash.find(relationMap, (cfg, key) => {
+      cfg.key = key
+      return cfg.keyword.includes(target)
+    })
+    if (!targetCfg && !e.isPoke) return true
+
+    let avatarList = []
+    let avatar = {}
+    let wifeList = []
+
+    let mys = await MysApi.init(e)
+    if (!mys || !mys.uid) {
+      return true
+    }
+    let player = Player.create(e)
+    let selfUser = mys.selfUser
+    let isSelf = true
+    let renderType = (action === '卡片' ? 'card' : 'photo')
+    let addRet = []
+    switch (action) {
+      case '卡片':
+      case '照片':
+      case '相片':
+      case '图片':
+      case '写真':
+        // 展示老婆卡片
+        // 如果选择过，则进行展示
+        if (!e.isPoke) {
+          wifeList = await selfUser.getCfg(`wife.${targetCfg.key}`, [])
+          // 存在设置
+          if (wifeList && wifeList.length > 0 && isSelf && !e.isPoke) {
+            if (wifeList[0] === '随机') {
+              // 如果选择为全部，则从列表中随机选择一个
+              avatarList = await getAvatarList(player, targetCfg.type, mys)
+              let avatar = lodash.sample(avatarList)
+              return Avatar.renderAvatar(e, avatar, renderType)
+            } else {
+              // 如果指定过，则展示指定角色
+              return Avatar.renderAvatar(e, lodash.sample(wifeList), renderType)
+            }
+          }
+        }
+        // 如果未指定过，则从列表中排序并随机选择
+        avatarList = await getAvatarList(player, e.isPoke ? false : targetCfg.type, mys)
+        if (avatarList && avatarList.length > 0) {
+          avatar = lodash.sample(avatarList)
+          return await Avatar.renderAvatar(e, avatar, renderType)
+        }
+        e.reply('在当前米游社公开展示的角色中未能找到适合展示的角色..')
+        return true
+      case '设置':
+      case '选择':
+      case '挑选':
+      case '指定':
+        if (!isSelf) {
+          e.reply('只能指定自己的哦~')
+          return true
+        }
+        // 选择老婆
+        actionParam = actionParam.replace(/(，|、|;|；)/g, ',')
+        wifeList = actionParam.split(',')
+        if (lodash.intersection(['全部', '任意', '随机', '全都要'], wifeList).length > 0) {
+          addRet = ['随机']
+        } else {
+          wifeList = lodash.map(wifeList, (name) => {
+            let char = Character.get(name)
+            if (char && char.checkWifeType(targetCfg.type)) {
+              return char.name
+            }
+          })
+          wifeList = lodash.filter(lodash.uniq(wifeList), (d) => !!d)
+          addRet = wifeList
+          if (addRet.length === 0) {
+            e.reply(`在可选的${targetCfg.keyword[0]}列表中未能找到 ${actionParam} ~`)
+            return true
+          }
+        }
+        await selfUser.setCfg(`wife.${targetCfg.key}`, addRet)
+        e.reply(`${targetCfg.keyword[0]}已经设置：${addRet.join('，')}`)
+        return true
+      case '列表':
+      case '是':
+      case '是谁':
+        // 查看当前选择老婆
+        if (!isSelf) {
+          e.reply('只能查看自己的哦~')
+          return true
+        }
+        wifeList = await selfUser.getCfg(`wife.${targetCfg.key}`, [])
+        if (wifeList && wifeList.length > 0) {
+          e.reply(`你的${targetCfg.keyword[0]}是：${wifeList.join('，')}`)
+        } else {
+          e.reply(`尚未设置，回复#${targetCfg.keyword[0]}设置+角色名 来设置，如果设置多位请用逗号间隔`)
+        }
+        break
+    }
+    return true
+  },
+  async poke (e) {
+    return await Wife.render(e)
+  }
+}
+
+export default Wife

Yunzai/plugins/miao-plugin/apps/character/ImgUpload.js

@@ -0,0 +1,258 @@
+import fs from 'fs'
+import { promisify } from 'util'
+import { pipeline } from 'stream'
+import MD5 from 'md5'
+import fetch from 'node-fetch'
+import lodash from 'lodash'
+import { Cfg, Data } from '#miao'
+import { Character } from '#miao.models'
+
+const resPath = process.cwd() + '/plugins/miao-plugin/resources/'
+let regex = /^#?\s*(?:喵喵)?(?:上传|添加)(.+)(?:照片|写真|图片|图像)\s*$/
+let profileRegex = /^#?\s*(?:喵喵)?(?:上传|添加)(.+)(?:面板图)\s*$/
+let isProfile = false
+
+export async function uploadCharacterImg (e) {
+  let promise = await isAllowedToUploadCharacterImage(e)
+  if (!promise) {
+    return false
+  }
+
+  let imageMessages = []
+  let msg = e.msg
+  let regRet = regex.exec(msg)
+  if (msg.includes('面板')) {
+    isProfile = true
+    regRet = profileRegex.exec(msg)
+  } else {
+    isProfile = false
+  }
+
+  // 通过解析正则获取消息中的角色名
+  if (!regRet || !regRet[1]) {
+    return false
+  }
+  let char = Character.get(regRet[1])
+  if (!char || !char.name) {
+    return false
+  }
+  let name = char.name
+  for (let val of e.message) {
+    if (val.type === 'image') {
+      imageMessages.push(val)
+    }
+  }
+  if (imageMessages.length === 0) {
+    let source
+    if (e.getReply) {
+      source = await e.getReply()
+    } else if (e.source) {
+      if (e.group?.getChatHistory) {
+        // 支持at图片添加，以及支持后发送
+        source = (await e.group.getChatHistory(e.source?.seq, 1)).pop()
+      } else if (e.friend?.getChatHistory) {
+        source = (await e.friend.getChatHistory((e.source?.time + 1), 1)).pop()
+      }
+    }
+    if (source) {
+      for (let val of source.message) {
+        if (val.type === 'image') {
+          imageMessages.push(val)
+        } else if (val.type === 'xml' || val.type === 'forward') {// 支持合并转发消息内置的图片批量上传，喵喵 喵喵喵？ 喵喵喵喵
+          let resid
+            try {
+              resid = val.data.match(/m_resid="(\d|\w|\/|\+)*"/)[0].replace(/m_resid=|"/g, '')
+            } catch (err) {
+              console.log('Miao合并上传：转换id获取')
+              resid = val.id
+            }
+          if (!resid) break
+          let message = await e.bot.getForwardMsg(resid)
+          for (const item of message) {
+            for (const i of item.message) {
+              if (i.type === 'image') {
+                imageMessages.push(i)
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (imageMessages.length <= 0) {
+    e.reply('消息中未找到图片，请将要发送的图片与消息一同发送或引用要添加的图像..')
+    return true
+  }
+  await saveImages(e, name, imageMessages)
+  return true
+}
+
+async function saveImages (e, name, imageMessages) {
+  let imgMaxSize = e?.groupConfig?.imgMaxSize || 5
+  let pathSuffix = `character-img/${name}/upload`
+  if (isProfile) pathSuffix = `profile/normal-character/${name}`
+  let path = resPath + pathSuffix
+
+  if (!fs.existsSync(path)) {
+    Data.createDir("resources/" + pathSuffix, 'miao')
+  }
+  let senderName = lodash.truncate(e.sender.card, { length: 8 })
+  let imgCount = 0
+  let urlMap = {}
+  for (let val of imageMessages) {
+    if (!val.url || urlMap[val.url]) {
+      continue
+    }
+    urlMap[val.url] = true
+    const response = await fetch(val.url)
+    if (!response.ok) {
+      e.reply('图片下载失败。')
+      return true
+    }
+    if (response.headers.get('size') > 1024 * 1024 * imgMaxSize) {
+      e.reply([segment.at(e.user_id, senderName), '添加失败：图片太大了。'])
+      return true
+    }
+    let fileName = ""
+    let fileType = "png"
+    if (val.file) {
+      fileName = val.file.substring(0, val.file.lastIndexOf('.'))
+      fileType = val.file.substring(val.file.lastIndexOf('.') + 1)
+    }
+    if (response.headers.get('content-type') === 'image/gif') {
+      fileType = 'gif'
+    }
+    if (isProfile) fileType = 'webp'
+    let imgPath = `${path}/${fileName}.${fileType}`
+    const streamPipeline = promisify(pipeline)
+    await streamPipeline(response.body, fs.createWriteStream(imgPath))
+
+    // 使用md5作为文件名
+    let buffers = fs.readFileSync(imgPath)
+    let base64 = Buffer.from(buffers, 'base64').toString()
+    let md5 = MD5(base64)
+    let newImgPath = `${path}/${md5}.${fileType}`
+    if (fs.existsSync(newImgPath)) {
+      fs.unlink(newImgPath, (err) => {
+        console.log('unlink', err)
+      })
+    }
+    fs.rename(imgPath, newImgPath, () => {
+    })
+    imgCount++
+    Bot.logger.mark(`添加成功: ${newImgPath}`)
+  }
+  e.reply([segment.at(e.user_id, senderName), `\n成功添加${imgCount}张${name}${isProfile ? '面板图' : '图片'}。`])
+  return true
+}
+
+async function isAllowedToUploadCharacterImage (e) {
+  let sendMsg = /上传|添加/.test(e.msg) ? '添加' : '删除'
+  if (!e.message) {
+    return false
+  }
+  if (!e.msg) {
+    return false
+  }
+  // master直接返回true
+  if (e.isMaster) {
+    return true
+  }
+  if (e.isPrivate) {
+    e.reply(`只有主人才能${sendMsg}...`)
+    return false
+  }
+  let groupId = e.group_id
+  if (!groupId) {
+    return false
+  }
+  const addLimit = e.groupConfig?.imgAddLimit || 2
+  const isAdmin = ['owner', 'admin'].includes(e.sender.role)
+  if (addLimit === 2) {
+    e.reply(`只有主人才能${sendMsg}...`)
+    return false
+  }
+  if (addLimit === 1 && !isAdmin) {
+    e.reply(`只有管理员才能${sendMsg}...`)
+    return false
+  }
+  return true
+}
+
+// 仅支持面板图删除
+export async function delProfileImg (e) {
+  let promise = await isAllowedToUploadCharacterImage(e)
+  if (!promise) {
+    return false
+  }
+  let char = Character.get(e.msg.replace(/#|面板图|列表|上传|删除|\d+/g, '').trim())
+  if (!char || !char.name) {
+    return false
+  }
+  let name = char.name
+  let pathSuffix = `profile/normal-character/${name}`
+  let path = resPath + pathSuffix
+  let num = e.msg.match(/\d+/)
+  if (!num) {
+    e.reply(`删除哪张捏？请输入数字序列号,可输入【#${name}面板图列表】查看序列号`)
+    return
+  }
+  try {
+    let imgs = fs.readdirSync(`${path}`).filter((file) => {
+      return /\.(png|webp)$/.test(file)
+    })
+    fs.unlinkSync(`${path}/${imgs[num - 1]}`)
+    e.reply('删除成功')
+  } catch (err) {
+    e.reply('删除失败，请检查序列号是否正确')
+  }
+  return true
+}
+
+export async function profileImgList (e) {
+  let msglist = []
+  let char = Character.get(e.msg.replace(/#|面板图列表/g, ''))
+  if (!char || !char.name) {
+    return false
+  }
+  if ([1, 0].includes(Cfg.get('originalPic') * 1)) {
+    e.reply('已禁止获取面板图列表')
+    return true
+  }
+  let name = char.name
+  let pathSuffix = `profile/normal-character/${name}`
+  let path = resPath + pathSuffix
+  if (!fs.existsSync(path)) {
+    e.reply(`暂无${char.name}的角色面板图`)
+    return true
+  }
+  try {
+    let imgs = fs.readdirSync(`${path}`).filter((file) => {
+      return /\.(png|webp)$/.test(file)
+    })
+    msglist.push({
+      message: [`当前查看的是${name}面板图,共${imgs.length}张，可输入【#删除${name}面板图(序列号)】进行删除`],
+    })
+    for (let i = 0; i < imgs.length; i++) {
+      // 合并转发最多99？ 但是我感觉不会有这么多先不做处理
+      console.log(`${path}${imgs[i]}`)
+      msglist.push({
+        message: [`${i + 1}.`, segment.image(`file://${path}/${imgs[i]}`)],
+      })
+    }
+    let msg
+    if (e.group?.makeForwardMsg) {
+      msg = await e.group.makeForwardMsg(msglist)
+    } else if (e.friend?.makeForwardMsg) {
+      msg = await e.friend.makeForwardMsg(msglist)
+    } else {
+      msg = await Bot.makeForwardMsg(msglist)
+    }
+    let msgRsg = await e.reply(msg)
+    if (!msgRsg) e.reply('风控了，可私聊查看', true)
+  } catch (err) {
+    logger.error(err)
+    e.reply(`暂无${char.name}的角色面板图~`)
+  }
+  return true
+}

Yunzai/plugins/miao-plugin/apps/gacha.js

@@ -0,0 +1,26 @@
+import Gacha from './gacha/Gacha.js'
+import { App, Cfg } from '#miao'
+
+let app = App.init({
+  id: 'gacha',
+  name: '抽卡统计'
+})
+app.reg({
+  detail: {
+    name: '抽卡记录',
+    fn: Gacha.detail,
+    rule: /^#*喵喵(抽卡|抽奖|角色|武器|常驻|up)+池?(记录|祈愿|分析)$/,
+    yzRule: /^#*(抽卡|抽奖|角色|武器|常驻|up)+池?(记录|祈愿|分析)$/,
+    yzCheck: () => Cfg.get('gachaStat', false)
+  },
+  stat: {
+    name: '抽卡统计',
+    fn: Gacha.stat,
+    rule: /^#*喵喵(全部|抽卡|抽奖|角色|武器|常驻|up|版本)+池?统计$/,
+    yzRule: /^#*(全部|抽卡|抽奖|角色|武器|常驻|up|版本)+池?统计$/,
+    yzCheck: () => Cfg.get('gachaStat', false)
+
+  }
+})
+
+export default app

Yunzai/plugins/miao-plugin/apps/gacha/Gacha.js

@@ -0,0 +1,90 @@
+import { Common } from '#miao'
+import { getTargetUid } from '../profile/ProfileCommon.js'
+import GachaData from './GachaData.js'
+import { Character, Player } from '#miao.models'
+
+let Gacha = {
+  async detail (e) {
+    let msg = e.msg.replace(/#|抽卡|记录|祈愿|分析|池/g, '')
+    let type = 301
+    switch (msg) {
+      case 'up':
+      case '抽卡':
+      case '角色':
+      case '抽奖':
+        type = 301
+        break
+      case '常驻':
+        type = 200
+        break
+      case '武器':
+        type = 302
+        break
+    }
+    let uid = e.uid || await getTargetUid(e)
+    let qq = e.user_id
+    if (!uid || !qq) {
+      return false
+    }
+
+    let gacha = GachaData.analyse(e.user_id, uid, type)
+    if (!gacha) {
+      e.reply(`UID:${uid} 本地暂无抽卡信息，请通过【#抽卡帮助】获得绑定帮助...`)
+      return true
+    }
+    await Common.render('gacha/gacha-detail', {
+      save_id: uid,
+      uid,
+      gacha,
+      face: Gacha.getFace(uid)
+    }, { e, scale: 1.4, retMsgId: true })
+  },
+  async stat (e) {
+    let msg = e.msg.replace(/#|统计|分析|池/g, '')
+    let type = 'up'
+    if (/武器/.test(msg)) {
+      type = 'weapon'
+    } else if (/角色/.test(msg)) {
+      type = 'char'
+    } else if (/常驻/.test(msg)) {
+      type = 'normal'
+    } else if (/全部/.test(msg)) {
+      type = 'all'
+    }
+    let uid = e.uid || await getTargetUid(e)
+    let qq = e.user_id
+    if (!uid || !qq) {
+      return false
+    }
+    let gacha = GachaData.stat(e.user_id, uid, type)
+    if (!gacha) {
+      e.reply(`UID:${uid} 本地暂无抽卡信息，请通过【#抽卡帮助】获得绑定帮助...`)
+      return true
+    }
+    await Common.render('gacha/gacha-stat', {
+      save_id: uid,
+      uid,
+      gacha,
+      face: Gacha.getFace(uid)
+    }, { e, scale: 1.4 })
+  },
+
+  getFace (uid) {
+    let player = Player.create(uid)
+
+    let faceChar = Character.get(player.face || 10000014)
+    let imgs = faceChar?.imgs
+    if (!imgs?.face) {
+      imgs = Character.get(10000079).imgs
+    }
+    return {
+      banner: imgs?.banner,
+      face: imgs?.face,
+      qFace: imgs?.qFace,
+      name: player.name || '旅行者',
+      sign: player.sign,
+      level: player.level
+    }
+  }
+}
+export default Gacha

Yunzai/plugins/miao-plugin/apps/gacha/GachaData.js

@@ -0,0 +1,444 @@
+import lodash from 'lodash'
+import { Data } from '#miao'
+import { Character, Weapon } from '#miao.models'
+import { poolDetail } from '../../resources/meta/info/index.js'
+import moment from 'moment'
+
+let poolVersion = []
+lodash.forEach(poolDetail, (ds) => {
+  poolVersion.push({
+    ...ds,
+    start: new Date(ds.from),
+    end: new Date(ds.to)
+  })
+})
+let last = poolVersion[poolVersion.length - 1]
+// 为未知卡池做兼容
+poolVersion.push({
+  version: '新版本',
+  half: '?',
+  from: last.to,
+  to: '2025-12-31 23:59:59',
+  start: last.end,
+  end: new Date('2025-12-31 23:59:59')
+})
+
+let GachaData = {
+
+  // 获取JSON数据
+  readJSON (qq, uid, type) {
+    let logJson = []
+    // 获取本地数据 进行数据合并
+    logJson = Data.readJSON(`/data/gachaJson/${qq}/${uid}/${type}.json`, 'root')
+    let itemMap = {}
+    let nameMap = {}
+    let items = []
+    let ids = {}
+    lodash.forEach(logJson, (ds) => {
+      if (!nameMap[ds.name]) {
+        if (ds.item_type === '武器') {
+          let weapon = Weapon.get(ds.name)
+          if (weapon) {
+            nameMap[ds.name] = weapon.id
+            itemMap[weapon.id] = {
+              type: 'weapon',
+              count: 0,
+              ...weapon.getData('star,name,abbr,img')
+            }
+          } else {
+            nameMap[ds.name] = 403
+            itemMap[403] = {
+              type: 'weapon',
+              count: 0,
+              star: 3,
+              name: '未知',
+              abbr: '未知',
+              img: ''
+            }
+          }
+        } else if (ds.item_type === '角色') {
+          let char = Character.get(ds.name)
+          if (char) {
+            nameMap[ds.name] = char.id
+            itemMap[char.id] = {
+              type: 'char',
+              count: 0,
+              ...char.getData('star,name,abbr,img:face')
+            }
+          } else {
+            nameMap[ds.name] = 404
+            itemMap[404] = {
+              type: 'char',
+              count: 0,
+              star: 4,
+              name: '未知',
+              abbr: '未知',
+              img: ''
+            }
+          }
+        }
+      }
+      let id = nameMap[ds.name]
+      if (!id || !itemMap[id] || (ds.id && ids[ds.id])) {
+        return true
+      }
+      ids[ds.id] = true
+      items.push({
+        id,
+        logId: ds.id,
+        time: new Date(ds.time)
+      })
+    })
+    items = items.sort((a, b) => b.time - a.time)
+    return { items, itemMap }
+  },
+
+  // 卡池分析
+  analyse (qq, uid, type) {
+    let logData = GachaData.readJSON(qq, uid, type)
+    let fiveLog = []
+    let fourLog = []
+    let fiveNum = 0
+    let fourNum = 0
+    let fiveLogNum = 0
+    let fourLogNum = 0
+    let noFiveNum = 0
+    let noFourNum = 0
+    let wai = 0 // 歪
+    let weaponNum = 0
+    let weaponFourNum = 0
+    let bigNum = 0
+    let allNum = 0
+
+    let itemMap = logData.itemMap
+    if (logData.items.length === 0) {
+      return false
+    }
+    let currVersion
+    lodash.forEach(logData.items, (item) => {
+      if (!currVersion || (item.time < currVersion.start)) {
+        currVersion = GachaData.getVersion(item.time)
+      }
+
+      allNum++
+      let ds = itemMap[item.id]
+      let { star, type } = ds
+      ds.count++
+      if (star === 4) {
+        fourNum++
+        if (noFourNum === 0) {
+          noFourNum = fourLogNum
+        }
+        fourLogNum = 0
+        if (fourLog[ds.name]) {
+          fourLog[ds.name]++
+        } else {
+          fourLog[ds.name] = 1
+        }
+        if (type === 'weapon') {
+          weaponFourNum++
+        }
+      }
+      fourLogNum++
+
+      if (star === 5) {
+        fiveNum++
+        if (fiveLog.length > 0) {
+          fiveLog[fiveLog.length - 1].count = fiveLogNum
+        } else {
+          noFiveNum = fiveLogNum
+        }
+        fiveLogNum = 0
+        let isUp = false
+        // 歪了多少个
+        if (type === 'char') {
+          if (!currVersion.hasOwnProperty("char5") || currVersion.char5.includes(ds.name)) {
+            isUp = true
+          } else {
+            wai++
+          }
+        } else {
+          if (currVersion.weapon5.includes(ds.name)) {
+            isUp = true
+          } else {
+            wai++
+          }
+        }
+
+        fiveLog.push({
+          id: item.id,
+          isUp,
+          date: moment(item.time).format('MM-DD')
+        })
+      }
+      fiveLogNum++
+    })
+
+    if (fiveLog.length > 0) {
+      fiveLog[fiveLog.length - 1].count = fiveLogNum
+    } else {
+      // 没有五星
+      noFiveNum = allNum
+    }
+
+    // 四星最多
+    let fourItem = lodash.filter(lodash.values(itemMap), (ds) => ds.star === 4)
+    fourItem.push({ name: '无', count: 0 })
+    fourItem = fourItem.sort((a, b) => b.count - a.count)
+
+    // 平均5星
+    let fiveAvg = 0
+    let fourAvg = 0
+    if (fiveNum > 0) {
+      fiveAvg = ((allNum - noFiveNum) / fiveNum).toFixed(2)
+    }
+    // 平均四星
+    if (fourNum > 0) {
+      fourAvg = ((allNum - noFourNum) / fourNum).toFixed(2)
+    }
+
+    // 有效抽卡
+    let isvalidNum = 0
+    if (fiveNum > 0 && fiveNum > wai) {
+      if (fiveLog.length > 0 && !fiveLog[0].isUp) {
+        isvalidNum = (allNum - noFiveNum - fiveLog[0].count) / (fiveNum - wai)
+      } else {
+        isvalidNum = (allNum - noFiveNum) / (fiveNum - wai)
+      }
+      isvalidNum = isvalidNum.toFixed(2)
+    }
+
+    let upYs = isvalidNum * 160
+    if (upYs >= 10000) {
+      upYs = (upYs / 10000).toFixed(2) + 'w'
+    } else {
+      upYs = upYs.toFixed(0)
+    }
+
+    // 小保底不歪概率
+    let noWaiRate = 0
+    if (fiveNum > 0) {
+      noWaiRate = (fiveNum - bigNum - wai) / (fiveNum - bigNum)
+      noWaiRate = (noWaiRate * 100).toFixed(1)
+    }
+
+    if (noFiveNum > 0) {
+      fiveLog.unshift({
+        id: 888,
+        isUp: true,
+        count: noFiveNum,
+        date: moment().format('MM-DD')
+      })
+      itemMap['888'] = {
+        name: '已抽',
+        star: 5,
+        abbr: '已抽',
+        img: 'gacha/imgs/no-avatar.webp'
+      }
+    }
+
+    return {
+      stat: {
+        allNum,
+        noFiveNum,
+        noFourNum,
+        fiveNum,
+        fourNum,
+        fiveAvg,
+        fourAvg,
+        wai,
+        isvalidNum,
+        weaponNum,
+        weaponFourNum,
+        upYs
+      },
+      maxFour: fourItem[0],
+      fiveLog,
+      noWaiRate,
+      items: itemMap
+    }
+  },
+
+  // 卡池统计
+  stat (qq, uid, type) {
+    let items = []
+    let itemMap = {}
+    let hasVersion = true
+    let loadData = function (poolId) {
+      let gachaData = GachaData.readJSON(qq, uid, poolId)
+      items = items.concat(gachaData.items)
+      lodash.extend(itemMap, gachaData.itemMap || {})
+    }
+    if (['up', 'char', 'all'].includes(type)) {
+      loadData(301)
+    }
+    if (['up', 'weapon', 'all'].includes(type)) {
+      loadData(302)
+    }
+    if (['all', 'normal'].includes(type)) {
+      hasVersion = false
+      loadData(200)
+    }
+
+    items = items.sort((a, b) => b.time - a.time)
+
+    let versionData = []
+    let currVersion
+
+    if (lodash.isEmpty(items)) {
+      return false
+    }
+
+    let getCurr = function () {
+      if (currVersion && !lodash.isEmpty(currVersion)) {
+        let cv = currVersion
+        let temp = {
+          version: cv.version,
+          half: cv.half,
+          from: hasVersion ? moment(new Date(cv.from)).format('YY-MM-DD') : '',
+          to: hasVersion ? moment(new Date(cv.to)).format('YY-MM-DD') : '',
+          upIds: {}
+        }
+        let upName = {}
+        let items = []
+        let poolNames = []
+        lodash.forEach(cv.char5, (name) => {
+          upName[name] = true
+          let char = Character.get(name)
+          poolNames.push(char.abbr)
+        })
+        lodash.forEach(cv.weapon5, (name) => {
+          upName[name] = true
+        })
+        let w5Num = 0
+        let w5UpNum = 0
+        let c5Num = 0
+        let c5UpNum = 0
+        let c4Num = 0
+        let w4Num = 0
+        let w3Num = 0
+        lodash.forEach(cv.items, (num, id) => {
+          let item = itemMap[id]
+          let isUp = upName[item.name]
+          let star = item.star
+          if (isUp) {
+            temp.upIds[id] = item.name
+          }
+          items.push({ id, num, star: item.star, isUp: temp.upIds[id] ? 1 : 0 })
+          if (item.type === 'char') {
+            if (star === 5) {
+              c5Num += num
+              isUp && (c5UpNum += num)
+            } else {
+              c4Num += num
+            }
+          }
+          if (item.type === 'weapon') {
+            if (star === 5) {
+              w5Num += num
+              isUp && (w5UpNum += num)
+            } else {
+              star === 4 ? (w4Num += num) : (w3Num += num)
+            }
+          }
+        })
+        temp.name = poolNames.join(' / ')
+        temp.items = lodash.sortBy(items, ['star', 'num', 'isUp']).reverse()
+        temp.stats = {
+          w5Num,
+          w5UpNum,
+          c5Num,
+          c5UpNum,
+          c4Num,
+          w4Num,
+          w3Num,
+          upNum: w5UpNum + c5UpNum,
+          star5Num: w5Num + c5Num,
+          star4Num: w4Num + c4Num,
+          totalNum: w5Num + w4Num + w3Num + c5Num + c4Num
+        }
+        return temp
+      }
+    }
+
+    lodash.forEach(items, (ds) => {
+      if (!currVersion || (ds.time < currVersion.start && hasVersion)) {
+        if (currVersion) {
+          versionData.push(getCurr())
+        }
+        let v = GachaData.getVersion(ds.time, hasVersion)
+        if (!hasVersion) {
+          v.version = type === 'all' ? '全部统计' : '常驻池'
+        }
+        if (!v) {
+          return true
+        }
+        currVersion = {
+          ...v,
+          items: {}
+        }
+      }
+      if (!currVersion.items[ds.id]) {
+        currVersion.items[ds.id] = 1
+      } else {
+        currVersion.items[ds.id]++
+      }
+    })
+    versionData.push(getCurr())
+
+    let stat = {}
+    lodash.forEach(versionData, (ds) => {
+      lodash.forEach(ds.stats, (num, key) => {
+        if (!stat[key]) {
+          stat[key] = num
+        } else {
+          stat[key] += num
+        }
+      })
+    })
+    stat.avgUpNum = stat.upNum === 0 ? 0 : ((stat.totalNum / stat.upNum).toFixed(1))
+
+    return {
+      versionData,
+      itemMap,
+      totalStat: stat
+    }
+  },
+
+  getVersion (time, hasVersion = true) {
+    if (hasVersion) {
+      for (let ds of poolVersion) {
+        if (time > ds.start && time < ds.end) {
+          return ds
+        }
+      }
+    }
+    return {
+      version: hasVersion === false ? '全部' : '未知',
+      half: '',
+      char5: [],
+      char4: [],
+      weapon5: [],
+      weapon4: []
+    }
+  },
+
+  getItem (ds) {
+    if (ds.item_type === '武器') {
+      let weapon = Weapon.get(ds.name)
+      return {
+        type: 'weapon',
+        count: 0,
+        ...weapon.getData('id,star,name,abbr,img')
+      }
+    } else if (ds.item_type === '角色') {
+      let char = Character.get(ds.name)
+      return {
+        type: 'char',
+        count: 0,
+        ...char.getData('id,star,name,abbr,face')
+      }
+    }
+  }
+}
+export default GachaData

Yunzai/plugins/miao-plugin/apps/help.js

@@ -0,0 +1,23 @@
+import Help from './help/Help.js'
+import { App } from '#miao'
+
+let app = App.init({
+  id: 'help',
+  name: '喵喵帮助',
+  desc: '喵喵帮助'
+})
+
+app.reg({
+  help: {
+    rule: /^#?(喵喵)?(命令|帮助|菜单|help|说明|功能|指令|使用说明)$/,
+    fn: Help.render,
+    desc: '【#帮助】 #喵喵帮助'
+  },
+  version: {
+    rule: /^#?喵喵版本$/,
+    fn: Help.version,
+    desc: '【#帮助】 喵喵版本介绍'
+  }
+})
+
+export default app

Yunzai/plugins/miao-plugin/apps/help/Help.js

@@ -0,0 +1,77 @@
+import { Cfg, Common, Data, Version } from '#miao'
+import fs from 'fs'
+import lodash from 'lodash'
+import HelpTheme from './HelpTheme.js'
+
+const _path = process.cwd()
+const helpPath = `${_path}/plugins/miao-plugin/resources/help`
+
+const Help = {
+  async render (e) {
+    if (!/喵喵/.test(e.msg) && !Cfg.get('help', false)) {
+      return false
+    }
+
+    let custom = {}
+    let help = {}
+    if (fs.existsSync(`${helpPath}/help-cfg.js`)) {
+      console.log('miao-plugin: 检测到存在help-cfg.js配置\n建议将help-cfg.js移为config/help.js或重新复制config/help_default.js进行配置~')
+      help = await import(`file://${helpPath}/help-cfg.js?version=${new Date().getTime()}`)
+    } else if (fs.existsSync(`${helpPath}/help-list.js`)) {
+      console.log('miao-plugin: 检测到存在help-list.js配置，建议将help-list.js移为config/help.js或重新复制config/help_default.js进行配置~')
+      help = await import(`file://${helpPath}/help-list.js?version=${new Date().getTime()}`)
+    }
+
+    let { diyCfg, sysCfg } = await Data.importCfg('help')
+
+    // 兼容一下旧字段
+    if (lodash.isArray(help.helpCfg)) {
+      custom = {
+        helpList: help.helpCfg,
+        helpCfg: {}
+      }
+    } else {
+      custom = help
+    }
+
+    let helpConfig = lodash.defaults(diyCfg.helpCfg || {}, custom.helpCfg, sysCfg.helpCfg)
+    let helpList = diyCfg.helpList || custom.helpList || sysCfg.helpList
+
+    let helpGroup = []
+
+    lodash.forEach(helpList, (group) => {
+      if (group.auth && group.auth === 'master' && !e.isMaster) {
+        return true
+      }
+
+      lodash.forEach(group.list, (help) => {
+        let icon = help.icon * 1
+        if (!icon) {
+          help.css = 'display:none'
+        } else {
+          let x = (icon - 1) % 10
+          let y = (icon - x - 1) / 10
+          help.css = `background-position:-${x * 50}px -${y * 50}px`
+        }
+      })
+
+      helpGroup.push(group)
+    })
+    let themeData = await HelpTheme.getThemeData(diyCfg.helpCfg || {}, sysCfg.helpCfg || {})
+    return await Common.render('help/index', {
+      helpCfg: helpConfig,
+      helpGroup,
+      ...themeData,
+      element: 'default'
+    }, { e, scale: 1.2 })
+  },
+
+  async version (e) {
+    return await Common.render('help/version-info', {
+      currentVersion: Version.version,
+      changelogs: Version.changelogs,
+      elem: 'cryo'
+    }, { e, scale: 1.2 })
+  }
+}
+export default Help

Yunzai/plugins/miao-plugin/apps/help/HelpTheme.js

@@ -0,0 +1,68 @@
+import lodash from 'lodash'
+import fs from 'fs'
+import { Data } from '#miao'
+
+let HelpTheme = {
+  async getThemeCfg (theme, exclude) {
+    let dirPath = './plugins/miao-plugin/resources/help/theme/'
+    let ret = []
+    let names = []
+    let dirs = fs.readdirSync(dirPath)
+    lodash.forEach(dirs, (dir) => {
+      if (fs.existsSync(`${dirPath}${dir}/main.png`)) {
+        names.push(dir)
+      }
+    })
+    if (lodash.isArray(theme)) {
+      ret = lodash.intersection(theme, names)
+    } else if (theme === 'all') {
+      ret = names
+    }
+    if (exclude && lodash.isArray(exclude)) {
+      ret = lodash.difference(ret, exclude)
+    }
+    if (ret.length === 0) {
+      ret = ['default']
+    }
+    let name = lodash.sample(ret)
+    let resPath = '{{_res_path}}/help/theme/'
+    return {
+      main: `${resPath}${name}/main.png`,
+      bg: fs.existsSync(`${dirPath}${name}/bg.jpg`) ? `${resPath}${name}/bg.jpg` : `${resPath}default/bg.jpg`,
+      style: (await Data.importModule(`resources/help/theme/${name}/config.js`, 'miao')).style || {}
+    }
+  },
+  async getThemeData (diyStyle, sysStyle) {
+    let helpConfig = lodash.extend({}, sysStyle, diyStyle)
+    let colCount = Math.min(5, Math.max(parseInt(helpConfig?.colCount) || 3, 2))
+    let colWidth = Math.min(500, Math.max(100, parseInt(helpConfig?.colWidth) || 265))
+    let width = Math.min(2500, Math.max(800, colCount * colWidth + 30))
+    let theme = await HelpTheme.getThemeCfg(diyStyle.theme || sysStyle.theme, diyStyle.themeExclude || sysStyle.themeExclude)
+    let themeStyle = theme.style || {}
+    let ret = [`
+    body{background-image:url(${theme.bg});width:${width}px;}
+    .container{background-image:url(${theme.main});width:${width}px;}
+    .help-table .td,.help-table .th{width:${100 / colCount}%}
+    `]
+    let css = function (sel, css, key, def, fn) {
+      let val = Data.def(themeStyle[key], diyStyle[key], sysStyle[key], def)
+      if (fn) {
+        val = fn(val)
+      }
+      ret.push(`${sel}{${css}:${val}}`)
+    }
+    css('.help-title,.help-group', 'color', 'fontColor', '#ceb78b')
+    css('.help-title,.help-group', 'text-shadow', 'fontShadow', 'none')
+    css('.help-desc', 'color', 'descColor', '#eee')
+    css('.cont-box', 'background', 'contBgColor', 'rgba(43, 52, 61, 0.8)')
+    css('.cont-box', 'backdrop-filter', 'contBgBlur', 3, (n) => diyStyle.bgBlur === false ? 'none' : `blur(${n}px)`)
+    css('.help-group', 'background', 'headerBgColor', 'rgba(34, 41, 51, .4)')
+    css('.help-table .tr:nth-child(odd)', 'background', 'rowBgColor1', 'rgba(34, 41, 51, .2)')
+    css('.help-table .tr:nth-child(even)', 'background', 'rowBgColor2', 'rgba(34, 41, 51, .4)')
+    return {
+      style: `<style>${ret.join('\n')}</style>`,
+      colCount
+    }
+  }
+}
+export default HelpTheme

Yunzai/plugins/miao-plugin/apps/index.js

@@ -0,0 +1,16 @@
+import character from './character.js'
+import profile from './profile.js'
+import stat from './stat.js'
+import wiki from './wiki.js'
+import poke from './poke.js'
+import help from './help.js'
+import admin from './admin.js'
+import gacha from './gacha.js'
+
+let apps = { character, poke, profile, stat, wiki, gacha, admin, help }
+let rules = {} // v3
+for (let key in apps) {
+  rules[`${key}`] = apps[key].v3App()
+}
+
+export { rules as apps }

Yunzai/plugins/miao-plugin/apps/poke.js

@@ -0,0 +1,17 @@
+import Wife from './character/AvatarWife.js'
+import { App } from '#miao'
+
+let app = App.init({
+  id: 'poke',
+  name: '戳一戳',
+  event: 'poke'
+})
+
+app.reg({
+  pockWife: {
+    fn: Wife.poke,
+    describe: '#老公 #老婆 查询'
+  }
+})
+
+export default app

Yunzai/plugins/miao-plugin/apps/profile.js

@@ -0,0 +1,143 @@
+import { profileHelp } from './profile/ProfileCommon.js'
+import { profileArtisList } from './profile/ProfileArtis.js'
+import ProfileDetail from './profile/ProfileDetail.js'
+import ProfileStat from './profile/ProfileStat.js'
+import ProfileList from './profile/ProfileList.js'
+import { uploadCharacterImg, delProfileImg, profileImgList } from './character/ImgUpload.js'
+import { enemyLv } from './profile/ProfileUtils.js'
+import { groupRank, resetRank, refreshRank, manageRank } from './profile/ProfileRank.js'
+import { App, Cfg } from '#miao'
+
+let app = App.init({
+  id: 'profile',
+  name: '角色面板'
+})
+
+app.reg({
+  profileList: {
+    name: '面板角色列表',
+    desc: '查看当前已获取面板数据的角色列表',
+    fn: ProfileList.render,
+    rule: /^#(星铁|原神)?(面板角色|角色面板|面板)(列表)?\s*(\d{9})?$/
+  },
+
+  profileDetail: {
+    name: '角色面板',
+    fn: ProfileDetail.detail,
+    rule: /^#*([^#]+)\s*(详细|详情|面板|面版|圣遗物|武器[1-7]?|伤害([1-9]+\d*)?)\s*(\d{9})*(.*[换变改].*)?$/
+  },
+
+  profileChange: {
+    name: '角色面板计算',
+    fn: ProfileDetail.detail,
+    rule: /^#.+换.+$/
+  },
+
+  groupProfile: {
+    name: '群内最强',
+    fn: groupRank,
+    rule: /^#(群|群内)?(排名|排行)?(最强|最高|最高分|最牛|第一|极限)+.+/
+  },
+
+  resetRank: {
+    name: '重置排名',
+    fn: resetRank,
+    rule: /^#(重置|重设)(.*)(排名|排行)$/
+  },
+
+  refreshRank: {
+    name: '重置排名',
+    fn: refreshRank,
+    rule: /^#(刷新|更新|重新加载)(群内|群|全部)*(排名|排行)$/
+  },
+
+  manageRank: {
+    name: '打开关闭',
+    fn: manageRank,
+    rule: /^#(开启|打开|启用|关闭|禁用)(群内|群|全部)*(排名|排行)$/
+  },
+
+  rankList: {
+    name: '面板排名榜',
+    fn: groupRank,
+    rule: /^#(群|群内)?.+(排名|排行)(榜)?$/
+  },
+
+  artisList: {
+    name: '面板圣遗物列表',
+    fn: profileArtisList,
+    rule: /^#圣遗物列表\s*(\d{9})?$/
+  },
+
+  profileStat: {
+    name: '面板练度统计',
+    fn: ProfileStat.stat,
+    rule: /^#(面板|喵喵)练度统计$/,
+    yzRule: /^#*(我的)*(技能|天赋|武器|角色|练度|五|四|5|4|星)+(汇总|统计|列表)(force|五|四|5|4|星)*[ |0-9]*$/,
+    yzCheck: () => Cfg.get('profileStat', false)
+  },
+
+  avatarList: {
+    name: '角色查询',
+    fn: ProfileStat.avatarList,
+    rule: /^#喵喵(角色|查询)[ |0-9]*$/,
+    yzRule: /^(#(角色|查询|查询角色|角色查询|人物)[ |0-9]*$)|(^(#*uid|#*UID)\+*[1|2|5-9][0-9]{8}$)|(^#[\+|＋]*[1|2|5-9][0-9]{8})/,
+    yzCheck: () => Cfg.get('avatarList', false)
+  },
+
+  profileHelp: {
+    name: '角色面板帮助',
+    fn: profileHelp,
+    rule: /^#(角色|换|更换)?面[板版]帮助$/
+  },
+
+  enemyLv: {
+    name: '敌人等级',
+    fn: enemyLv,
+    describe: '【#角色】 设置伤害计算中目标敌人的等级',
+    rule: /^#(敌人|怪物)等级\s*\d{1,3}\s*$/
+  },
+
+  profileRefresh: {
+    name: '面板更新',
+    describe: '【#角色】 获取游戏橱窗详情数据',
+    fn: ProfileList.refresh,
+    rule: /^#(星铁|原神)?(全部面板更新|更新全部面板|获取游戏角色详情|更新面板|面板更新)\s*(\d{9})?$/
+  },
+
+  uploadImg: {
+    name: '上传面板图',
+    describe: '【#上传刻晴面板图】 上传角色面板图',
+    fn: uploadCharacterImg,
+    rule: /^#?\s*(?:上传|添加)(.+)(?:面板图)\s*$/
+  },
+
+  delProfile: {
+    name: '删除面板图',
+    describe: '【#删除刻晴面板图1】 删除指定角色面板图（序号）',
+    fn: delProfileImg,
+    rule: /^#?\s*(?:移除|清除|删除)(.+)(?:面板图)(\d){1,}\s*$/
+  },
+
+  profileImgList: {
+    name: '面板图列表',
+    describe: '【#刻晴面板图列表】 删除指定角色面板图（序号）',
+    fn: profileImgList,
+    rule: /^#?\s*(.+)(?:面板图列表)\s*$/
+  },
+
+  profileDel: {
+    name: '删除面板',
+    describe: '【#角色】 删除游戏橱窗详情数据',
+    fn: ProfileList.del,
+    rule: /^#(删除全部面板|删除面板|删除面板数据)\s*(\d{9})?$/
+  },
+
+  profileReload:{
+    name: '重新加载面板',
+    fn:ProfileList.reload,
+    rule: /^#(星铁|原神)?(加载|重新加载|重载)面板\s*(\d{9})?$/
+  }
+})
+
+export default app

Yunzai/plugins/miao-plugin/apps/profile/ProfileArtis.js

@@ -0,0 +1,96 @@
+/*
+* 角色圣遗物评分详情
+*
+* */
+import lodash from 'lodash'
+import { Cfg, Common } from '#miao'
+import { getTargetUid, profileHelp, getProfileRefresh } from './ProfileCommon.js'
+import { Artifact, Character, ProfileArtis, Player } from '#miao.models'
+
+/*
+* 角色圣遗物面板
+* */
+export async function profileArtis (e) {
+  let { uid, avatar } = e
+  let profile = e._profile || await getProfileRefresh(e, avatar)
+  if (!profile) {
+    return true
+  }
+  if (!profile.hasArtis()) {
+    e.reply('未能获得圣遗物详情，请重新获取面板信息后查看')
+    return true
+  }
+  let char = profile.char
+  let { game } = char
+  let charCfg = profile.artis.getCharCfg()
+
+  let { attrMap } = Artifact.getMeta()
+
+  let artisDetail = profile.getArtisMark()
+  let artisKeyTitle = ProfileArtis.getArtisKeyTitle()
+
+  // 渲染图像
+  return await Common.render('character/artis-mark', {
+    uid,
+    elem: char.elem,
+    splash: profile.costumeSplash,
+    data: profile,
+    costume: profile.costume ? '2' : '',
+    artisDetail,
+    artisKeyTitle,
+    attrMap,
+    charCfg,
+    game,
+    changeProfile: e._profileMsg
+  }, { e, scale: 1.3 })
+}
+
+/*
+* 圣遗物列表
+* */
+export async function profileArtisList (e) {
+  let uid = await getTargetUid(e)
+  if (!uid) {
+    return true
+  }
+
+  let artis = []
+  let player = Player.create(uid)
+  player.forEachAvatar((avatar) => {
+    let profile = avatar.getProfile()
+    if (!profile) {
+      return true
+    }
+    let name = profile.name
+    let char = Character.get(name)
+    if (!profile.hasData || !profile.hasArtis()) {
+      return true
+    }
+    let profileArtis = profile.getArtisMark()
+    lodash.forEach(profileArtis.artis, (arti, idx) => {
+      arti.charWeight = profileArtis.charWeight
+      arti.avatar = name
+      arti.side = char.side
+      artis.push(arti)
+    })
+  })
+
+  if (artis.length === 0) {
+    e.reply('请先获取角色面板数据后再查看圣遗物列表...')
+    await profileHelp(e)
+    return true
+  }
+  artis = lodash.sortBy(artis, '_mark')
+  artis = artis.reverse()
+  let number = Cfg.get('artisNumber', 28)
+  artis = artis.slice(0, `${number}`)
+  let artisKeyTitle = ProfileArtis.getArtisKeyTitle()
+
+  // 渲染图像
+  return await Common.render('character/artis-list', {
+    save_id: uid,
+    uid,
+    artis,
+    artisKeyTitle
+  }, { e, scale: 1.4 })
+}

Yunzai/plugins/miao-plugin/apps/profile/ProfileChange.js

@@ -0,0 +1,299 @@
+/**
+ * 面板数据替换相关逻辑
+ */
+import lodash from 'lodash'
+import { Data } from '#miao'
+import { Character, ArtifactSet, ProfileData, Weapon, Player } from '#miao.models'
+
+// 默认武器
+let defWeapon = {
+  bow: '西风猎弓',
+  catalyst: '西风秘典',
+  claymore: '西风大剑',
+  polearm: '西风长枪',
+  sword: '西风剑'
+}
+
+const ProfileChange = {
+  /**
+   * 匹配消息
+   * @param msg
+   * @returns {{}}
+   */
+  matchMsg (msg) {
+    if (!/(变|改|换)/.test(msg)) {
+      return false
+    }
+    msg = msg.toLowerCase().replace(/uid ?:? ?/, '').replace('', '')
+    let regRet = /^#*(\d{9})?(.+?)(详细|详情|面板|面版|圣遗物|伤害[1-7]?)?\s*(\d{9})?[变换改](.+)/.exec(msg)
+    if (!regRet || !regRet[2]) {
+      return false
+    }
+    let ret = {}
+    let change = {}
+    let char = Character.get(lodash.trim(regRet[2]).replace('星铁', ''))
+    if (!char) {
+      return false
+    }
+    const game = char.game
+    const isGs = game === 'gs'
+    const keyMap = isGs ? {
+      artis: '圣遗物',
+      arti1: '花,生之花',
+      arti2: '毛,羽,羽毛,死之羽',
+      arti3: '沙,沙漏,表,时之沙',
+      arti4: '杯,杯子,空之杯',
+      arti5: '头,冠,理之冠,礼冠,帽子,帽',
+      weapon: '武器'
+    } : {
+      artis: '圣遗物,遗器',
+      arti1: '头,帽子,头部',
+      arti2: '手,手套,手部',
+      arti3: '衣,衣服,甲,躯干,',
+      arti4: '鞋,靴,鞋子,靴子,脚,脚部',
+      arti5: '球,位面球',
+      arti6: '绳,线,链接绳,连接绳',
+      weapon: '武器,光锥'
+    }
+    let keyTitleMap = {}
+    lodash.forEach(keyMap, (val, key) => {
+      lodash.forEach(val.split(','), (v) => {
+        keyTitleMap[v] = key
+      })
+    })
+    const keyReg = new RegExp(`^(\\d{9})?\\s*(.+?)\\s*(\\d{9})?\\s*((?:${lodash.keys(keyTitleMap).join('|')}|\\+)+)$`)
+
+    ret.char = char.id
+    ret.mode = regRet[3] === '换' ? '面板' : regRet[3]
+    ret.uid = regRet[1] || regRet[4] || ''
+    ret.game = char.game
+    msg = regRet[5]
+
+    // 更换匹配
+    msg = msg.replace(/[变改]/g, '换')
+    lodash.forEach(msg.split('换'), (txt) => {
+      txt = lodash.trim(txt)
+      if (!txt) {
+        return true
+      }
+      // 匹配圣遗物
+      let keyRet = keyReg.exec(txt)
+      if (keyRet && keyRet[4]) {
+        let char = Character.get(lodash.trim(keyRet[2]))
+        if (char) {
+          if (char.game !== game) {
+            return true
+          }
+          lodash.forEach(keyRet[4].split('+'), (key) => {
+            key = lodash.trim(key)
+            let type = keyTitleMap[key]
+            change[type] = {
+              char: char.id || '',
+              uid: keyRet[1] || keyRet[3] || '',
+              type
+            }
+          })
+        } else if (keyRet[4].length > 2) {
+          return true
+        }
+      }
+
+      // 匹配圣遗物套装
+      let asMap = ArtifactSet.getAliasMap(game)
+      let asKey = lodash.keys(asMap).sort((a, b) => b.length - a.length).join('|')
+      let asReg = new RegExp(`^(${asKey})套?[2,4]?\\+?(${asKey})?套?[2,4]?\\+?(${asKey})?套?[2,4]?$`)
+      let asRet = asReg.exec(txt)
+      if (asRet && asRet[1] && asMap[asRet[1]]) {
+        if (game === 'gs') {
+          change.artisSet = [asMap[asRet[1]], asMap?.[asRet[2]] || asMap[asRet[1]]]
+        } else if (game === 'sr') {
+          for (let idx = 1; idx <= 3; idx++) {
+            let as = ArtifactSet.get(asMap?.[asRet[idx]])
+            if (as) { // 球&绳
+              change.artisSet = change.artisSet || []
+              let ca = change.artisSet
+              ca[as.sets?.[1] ? (ca[0] ? 1 : 0) : 2] = as.name
+            }
+          }
+          let ca = change.artisSet
+          if (ca && ca[0] && !ca[1]) {
+            ca[1] = ca[0]
+          }
+        }
+        return true
+      }
+
+      // 匹配武器
+      let wRet = /^(?:等?级?([1-9][0-9])?级?)?\s*(?:([1-5一二三四五满])?精炼?([1-5一二三四五])?)?\s*(?:等?级?([1-9][0-9])?级?)?\s*(.*)$/.exec(txt)
+      if (wRet && wRet[5]) {
+        let weaponName = lodash.trim(wRet[5])
+        let weapon = Weapon.get(weaponName, game, ret.char.game)
+        if (weapon || weaponName === '武器' || Weapon.isWeaponSet(weaponName)) {
+          let affix = wRet[2] || wRet[3]
+          affix = { 一: 1, 二: 2, 三: 3, 四: 4, 五: 5, 满: 5 }[affix] || affix * 1
+          let tmp = {
+            weapon: (Weapon.isWeaponSet(weaponName) ? weaponName : weapon?.name) || '',
+            affix: affix || '',
+            level: wRet[1] * 1 || wRet[4] * 1 || ''
+          }
+          if (lodash.values(tmp).join('')) {
+            change.weapon = tmp
+          }
+          return true
+        }
+      }
+      let char = change.char || {}
+      // 命座匹配
+      let consRet = /([0-6零一二三四五六满])(命|魂|星魂)/.exec(txt)
+      if (consRet && consRet[1]) {
+        let cons = consRet[1]
+        char.cons = Math.max(0, Math.min(6, lodash.isNaN(cons * 1) ? '零一二��四五六满'.split('').indexOf(cons) : cons * 1))
+        txt = txt.replace(consRet[0], '')
+      }
+
+      // 天赋匹配
+      let talentRet = (isGs ? /(?:天赋|技能|行迹)((?:[1][0-5]|[1-9])[ ,]?)((?:[1][0-5]|[1-9])[ ,]?)([1][0-5]|[1-9])/ :
+        /(?:天赋|技能|行迹)((?:[1][0-5]|[1-9])[ ,]?)((?:[1][0-5]|[1-9])[ ,]?)((?:[1][0-5]|[1-9])[ ,]?)([1][0-5]|[1-9])/).exec(txt)
+      if (talentRet) {
+        char.talent = {}
+        lodash.forEach((isGs ? 'aeq' : 'aetq').split(''), (key, idx) => {
+          char.talent[key] = talentRet[idx + 1] * 1 || 1
+        })
+        txt = txt.replace(talentRet[0], '')
+      }
+
+      let lvRet = /等级([1-9][0-9]?)|([1-9][0-9]?)级/.exec(txt)
+      if (lvRet && (lvRet[1] || lvRet[2])) {
+        char.level = (lvRet[1] || lvRet[2]) * 1
+        txt = txt.replace(lvRet[0], '')
+      }
+      txt = lodash.trim(txt)
+      if (txt) {
+        let chars = Character.get(txt)
+        if (chars && (chars.game === game)) {
+          char.char = chars.id
+        }
+      }
+      if (!lodash.isEmpty(char)) {
+        change.char = char
+      }
+    })
+    ret.change = lodash.isEmpty(change) ? false : change
+    return ret
+  },
+
+  /**
+   * 获取面板数据
+   * @param uid
+   * @param charid
+   * @param ds
+   * @param game
+   * @returns {ProfileData|boolean}
+   */
+  getProfile (uid, charid, ds, game = 'gs') {
+    if (!charid) {
+      return false
+    }
+
+    const isGs = game === 'gs'
+
+    let player = Player.create(uid, game)
+
+    let source = player.getProfile(charid)
+    let dc = ds.char || {}
+    if (!source || !source.hasData) {
+      source = {}
+    }
+
+    let char = Character.get(dc?.char || source.id || charid)
+    if (!char) {
+      return false
+    }
+    let level = dc.level || source.level || 90
+    let promote = level === source.level ? source.promote : undefined
+
+    let profiles = {}
+    if (source && source.id) {
+      profiles[`${player.uid}:${source.id}`] = source
+    }
+    // 获取source
+    let getSource = function (cfg) {
+      if (!cfg || !cfg.char) {
+        return source
+      }
+      let cuid = cfg.uid || uid
+      let id = cfg.char || source.id
+      let key = cuid + ':' + id
+      if (!profiles[key]) {
+        let cPlayer = Player.create(cuid, game)
+        profiles[key] = cPlayer.getProfile(id) || {}
+      }
+      return profiles[key]?.id ? profiles[key] : source
+    }
+    // 初始化profile
+    let ret = new ProfileData({
+      uid,
+      id: char.id,
+      level,
+      cons: Data.def(dc.cons, source.cons, 0),
+      fetter: source.fetter || 10,
+      elem: char.elem,
+      dataSource: 'change',
+      _source: 'change',
+      promote,
+      trees: lodash.extend([], source.trees)
+    }, char.game, false)
+
+    // 设置武器
+    let wCfg = ds.weapon || {}
+    let wSource = getSource(wCfg).weapon || {}
+    let weapon = Weapon.get(wCfg?.weapon || wSource?.name || defWeapon[char.weaponType], char.game, char.weaponType)
+    if (char.isGs) {
+      if (!weapon || weapon.type !== char.weaponType) {
+        weapon = Weapon.get(defWeapon[char.weaponType], char.game)
+      }
+    }
+
+    let wDs = {
+      name: weapon.name,
+      star: weapon.star,
+      level: Math.min(weapon.maxLv || 90, wCfg.level || wSource.level || 90)
+    }
+    if (wSource.level === wDs.level) {
+      wDs.promote = wSource.promote
+    }
+    wDs.affix = Math.min(weapon.maxAffix || 5, wCfg.affix || ((wDs.star === 5 && wSource.star !== 5) ? 1 : (wSource.affix || 5)))
+    ret.setWeapon(wDs)
+
+    // 设置天赋
+    if (ds?.char?.talent) {
+      ret.setTalent(ds?.char?.talent, 'level')
+    } else {
+      ret.setTalent(source?.originalTalent || (isGs ? { a: 9, e: 9, q: 9 } : { a: 6, e: 8, t: 8, q: 8 }), 'original')
+    }
+
+    // 设置圣遗物
+    let artis = getSource(ds.artis)?.artis?.artis || {}
+    for (let idx = 1; idx <= (isGs ? 5 : 6); idx++) {
+      if (ds['arti' + idx]) {
+        let source = getSource(ds['arti' + idx])
+        if (source && source.artis && source.artis[idx]) {
+          artis[idx] = source.artis[idx]
+        }
+      }
+      let artisIdx = (isGs ? '00111' : '001122')[idx - 1]
+      if (artis[idx] && ds.artisSet && ds.artisSet[artisIdx]) {
+        let as = ArtifactSet.get(ds.artisSet[artisIdx], game)
+        if (as) {
+          artis[idx].id = as.getArti(idx)?.getIdByStar(artis[idx].star || 5)
+          artis[idx]._name = artis[idx].name = as.getArtiName(idx)
+          artis[idx]._set = artis[idx].set = as.name
+        }
+      }
+    }
+    ret.setArtis(artis)
+    ret.calcAttr()
+    return ret
+  }
+}
+export default ProfileChange

Yunzai/plugins/miao-plugin/apps/profile/ProfileCommon.js

@@ -0,0 +1,77 @@
+/*
+* 面板公共方法及处理
+* */
+import { Version } from '#miao'
+import { Character, MysApi, Player } from '#miao.models'
+
+/*
+* 获取面板查询的 目标uid
+* */
+const _getTargetUid = async function (e) {
+  let uidReg = /[1-9][0-9]{8}/
+
+  if (e.uid && uidReg.test(e.uid)) {
+    return e.uid
+  }
+
+  let uidRet = uidReg.exec(e.msg)
+  if (uidRet) {
+    return uidRet[0]
+  }
+  let uid = false
+
+  try {
+    let user = await MysApi.initUser(e)
+
+    if (!user || !user.uid) {
+      return false
+    }
+    uid = user.uid
+    if ((!uid || !uidReg.test(uid)) && !e._replyNeedUid) {
+      e.reply('请先发送【#绑定+你的UID】来绑定查询目标')
+      e._replyNeedUid = true
+      return false
+    }
+  } catch (err) {
+    console.log(err)
+  }
+  return uid || false
+}
+
+export async function getTargetUid (e) {
+  let uid = await _getTargetUid(e)
+  if (uid) {
+    e.uid = uid
+  }
+  return uid
+}
+
+export async function getProfileRefresh (e, avatar) {
+  let char = Character.get(avatar)
+  if (!char) {
+    return false
+  }
+
+  let player = Player.create(e)
+  let profile = player.getProfile(char.id)
+  if (!profile || !profile.hasData) {
+    logger.mark(`本地无UID:${player.uid}的${char.name}面板数据，尝试自动请求...`)
+    await player.refresh({ profile: true })
+    profile = player.getProfile(char.id)
+  }
+  if (!profile || !profile.hasData) {
+    if (!e._isReplyed) {
+      e.reply(`请确认${char.name}已展示在【游戏内】的角色展柜中，并打开了“显示角色详情”。然后请使用 #更新面板\n命令来获取${char.name}的面板详情`)
+    }
+    return false
+  }
+  return profile
+}
+
+/*
+* 面板帮助
+* */
+export async function profileHelp (e) {
+  e.reply(segment.image(`file://${process.cwd()}/plugins/miao-plugin/resources/character/imgs/help.jpg`))
+  return true
+}

Yunzai/plugins/miao-plugin/apps/profile/ProfileDetail.js

@@ -0,0 +1,299 @@
+import lodash from 'lodash'
+import { getTargetUid, getProfileRefresh } from './ProfileCommon.js'
+import ProfileList from './ProfileList.js'
+import { Cfg, Common, Data, Format } from '#miao'
+import { MysApi, ProfileRank, ProfileArtis, Character, Weapon } from '#miao.models'
+import ProfileChange from './ProfileChange.js'
+import { profileArtis } from './ProfileArtis.js'
+import { ProfileWeapon } from './ProfileWeapon.js'
+
+let { diyCfg } = await Data.importCfg('profile')
+
+// 查看当前角色
+let ProfileDetail = {
+  async detail (e) {
+    let msg = e.original_msg || e.msg
+    if (!msg) {
+      return false
+    }
+    if (!/详细|详情|面板|面版|圣遗物|伤害|武器|换/.test(msg)) {
+      return false
+    }
+    let mode = 'profile'
+    let profileChange = false
+    let changeMsg = msg
+    let pc = ProfileChange.matchMsg(msg)
+
+    if (pc && pc.char && pc.change) {
+      if (!Cfg.get('profileChange')) {
+        e.reply('面板替换功能已禁用...')
+        return true
+      }
+      e.game = pc.game
+      e.isSr = e.game === 'sr'
+      e.uid = ''
+      e.msg = '#喵喵面板变换'
+      e.uid = pc.uid || await getTargetUid(e)
+      profileChange = ProfileChange.getProfile(e.uid, pc.char, pc.change, pc.game)
+      if (profileChange && profileChange.char) {
+        msg = `#${profileChange.char?.name}${pc.mode || '面板'}`
+        e._profile = profileChange
+        e._profileMsg = changeMsg
+      }
+    }
+    let uidRet = /[0-9]{9}/.exec(msg)
+    if (uidRet) {
+      e.uid = uidRet[0]
+      msg = msg.replace(uidRet[0], '')
+    }
+
+    let name = msg.replace(/#|老婆|老公|星铁|原神/g, '').trim()
+    msg = msg.replace('面版', '面板')
+    let dmgRet = /(?:伤害|武器)(\d*)$/.exec(name)
+    let dmgIdx = 0, idxIsInput = false
+    if (/(最强|最高|最高分|最牛|第一)/.test(msg)) {
+      mode = /(分|圣遗物|评分|ACE)/.test(msg) ? 'rank-mark' : 'rank-dmg'
+      name = name.replace(/(最强|最高分|第一|最高|最牛|圣遗物|评分|群)/g, '')
+    }
+    if (/(详情|详细|面板|面版)\s*$/.test(msg) && !/更新|录入|输入/.test(msg)) {
+      mode = 'profile'
+      name = name.replace(/(详情|详细|面板)/, '').trim()
+    } else if (dmgRet) {
+      // mode = /武器/.test(msg) ? 'weapon' : 'dmg'
+      mode = 'dmg'
+      name = name.replace(/(伤害|武器)+\d*/, '').trim()
+      if (dmgRet[1]) {
+        dmgIdx = dmgRet[1] * 1
+        // 标识是用户指定的序号
+        idxIsInput = true
+      }
+    } else if (/(详情|详细|面板)更新$/.test(msg) || (/更新/.test(msg) && /(详情|详细|面板)$/.test(msg))) {
+      mode = 'refresh'
+      name = name.replace(/详情|详细|面板|更新/g, '').trim()
+    } else if (/圣遗物/.test(msg)) {
+      mode = 'artis'
+      name = name.replace('圣遗物', '').trim()
+    }
+    if (!Common.cfg('avatarProfile')) {
+      return false // 面板开关关闭
+    }
+    let char = Character.get(name.trim())
+    if (!char) {
+      return false
+    }
+    if (/星铁/.test(msg) || char.isSr) {
+      e.isSr = true
+    }
+
+    let uid = e.uid || await getTargetUid(e)
+    if (!uid) {
+      return true
+    }
+    e.uid = uid
+    e.avatar = char.id
+
+    if (char.isCustom) {
+      e.reply('自定义角色暂不支持此功能')
+      return true
+    }
+    if (!char.isRelease) {
+      // 预设面板支持未实装角色
+      if (!profileChange && Number(e.uid) > 100000006) {
+        e.reply('角色尚未实装')
+        return true
+      }
+      // 但仅在未实装开启时展示
+      if (Cfg.get('notReleasedData') === false) {
+        e.reply('未实装角色面板已禁用...')
+        return true
+      }
+    }
+
+    if (mode === 'profile' || mode === 'dmg' || mode === 'weapon') {
+      return ProfileDetail.render(e, char, mode, { dmgIdx, idxIsInput })
+    } else if (mode === 'refresh') {
+      await ProfileList.refresh(e)
+      return true
+    } else if (mode === 'artis') {
+      return profileArtis(e)
+    }
+    return true
+  },
+
+  async render (e, char, mode = 'profile', params = {}) {
+    let selfUser = await MysApi.initUser(e)
+
+    if (!selfUser) {
+      e.reply('尚未绑定UID')
+      return true
+    }
+
+    let { uid } = e
+
+    if (char.isCustom) {
+      e.reply(`暂不支持自定义角色${char.name}的面板信息查看`)
+      return true
+    }
+
+    let profile = e._profile || await getProfileRefresh(e, char.id)
+    if (!profile) {
+      return true
+    }
+    char = profile.char || char
+    let a = profile.attr
+    let base = profile.base
+    let attr = {}
+    let game = char.game
+    let isGs = game === 'gs'
+    let isSr = !isGs
+
+    lodash.forEach((isGs ? 'hp,def,atk,mastery' : 'hp,def,atk,speed').split(','), (key) => {
+      let fn = (n) => Format.comma(n, key === 'hp' ? 0 : 1)
+      attr[key] = fn(a[key])
+      attr[`${key}Base`] = fn(base[key])
+      attr[`${key}Plus`] = fn(a[key] - base[key])
+    })
+    lodash.forEach((isGs ? 'cpct,cdmg,recharge,dmg' : 'cpct,cdmg,recharge,dmg,effPct,effDef,heal,stance').split(','), (key) => {
+      let fn = Format.pct
+      let key2 = key
+      if (key === 'dmg') {
+        if (isGs) {
+          if (a.phy > a.dmg) {
+            key2 = 'phy'
+          }
+        }
+      }
+      attr[key] = fn(a[key2])
+      attr[`${key}Base`] = fn(base[key2])
+      attr[`${key}Plus`] = fn(a[key2] - base[key2])
+    })
+
+    let weapon = Weapon.get(profile?.weapon?.name, game)
+    let w = profile.weapon
+    let wCfg = {}
+    if (mode === 'weapon') {
+      wCfg = weapon.calcAttr(w.level, w.promote)
+      wCfg.weapons = await ProfileWeapon.calc(profile)
+    }
+
+    let enemyLv = isGs ? (await selfUser.getCfg('char.enemyLv', 91)) : profile.level
+    let dmgCalc = await ProfileDetail.getProfileDmgCalc({ profile, enemyLv, mode, params })
+
+    let rank = false
+    if (e.group_id && !e._profile) {
+      rank = await ProfileRank.create({ group: e.group_id, uid, qq: e.user_id })
+      await rank.getRank(profile, true)
+    }
+
+    let artisDetail = profile.getArtisMark()
+    let artisKeyTitle = ProfileArtis.getArtisKeyTitle(game)
+    let data = profile.getData('name,abbr,cons,level,talent,dataSource,updateTime,imgs,costumeSplash')
+    if (isSr) {
+      let treeData = []
+      let treeMap = {}
+      // 属性
+      lodash.forEach('0113355778'.split(''), (pos, idx) => {
+        treeData[pos] = treeData[pos] || []
+        let tmp = { type: 'tree', img: `/meta-sr/public/icons/tree-cpct.webp` }
+        treeData[pos].push(tmp)
+        treeMap[idx + 201 + ''] = tmp
+      })
+      // 能力
+      lodash.forEach([2, 4, 6], (pos, idx) => {
+        let tmp = { type: 'talent', img: data.imgs[`tree${idx + 1}`] }
+        treeData[pos] = tmp
+        treeMap[idx + 101 + ''] = tmp
+      })
+      lodash.forEach(profile.trees, (id) => {
+        let ret = /([12][01][0-9])$/.exec(id + '')
+        if (ret && ret[1]) {
+          let treeId = ret[1]
+          if (treeMap?.[treeId]) {
+            treeMap[treeId].value = 1
+          }
+          if (treeId[0] === '2') {
+            treeMap[treeId].img = `/meta-sr/public/icons/tree-${char.detail?.tree?.[id]?.key}.webp`
+          }
+        }
+      })
+      data.treeData = treeData
+    }
+    data.weapon = profile.getWeaponDetail()
+    let renderData = {
+      save_id: uid,
+      uid,
+      game,
+      data,
+      attr,
+      elem: char.elem,
+      dmgCalc,
+      artisDetail,
+      artisKeyTitle,
+      bodyClass: `char-${char.name}`,
+      mode,
+      wCfg,
+      changeProfile: e._profileMsg
+    }
+    // 渲染图像
+    let msgRes = await Common.render('character/profile-detail', renderData, { e, scale: 1.6, retMsgId: true })
+    if (msgRes) {
+      // 如果消息发送成功，就将message_id和图片路径存起来，3小时过期
+      const message_id = [e.message_id]
+      if (Array.isArray(msgRes.message_id)) {
+        message_id.push(...msgRes.message_id)
+      } else {
+        message_id.push(msgRes.message_id)
+      }
+      for (const i of message_id) {
+        await redis.set(`miao:original-picture:${i}`, JSON.stringify({
+          type: 'profile',
+          img: renderData?.data?.costumeSplash
+        }), { EX: 3600 * 3 })
+      }
+    }
+    return true
+  },
+
+  async getProfileDmgCalc ({ profile, enemyLv, mode, params }) {
+    let dmgMsg = []
+    let dmgData = []
+    let dmgCalc = await profile.calcDmg({
+      enemyLv,
+      mode,
+      ...params
+    })
+    if (dmgCalc && dmgCalc.ret) {
+      lodash.forEach(dmgCalc.ret, (ds) => {
+        if (ds.type !== 'text') {
+          ds.dmg = Format.comma(ds.dmg, 0)
+          ds.avg = Format.comma(ds.avg, 0)
+        }
+        dmgData.push(ds)
+      })
+      lodash.forEach(dmgCalc.msg, (msg) => {
+        msg.replace(':', '：')
+        dmgMsg.push(msg.split('：'))
+      })
+
+      dmgCalc.dmgMsg = dmgMsg
+      dmgCalc.dmgData = dmgData
+    }
+
+    if (mode === 'dmg' && dmgCalc.dmgRet) {
+      let basic = dmgCalc?.dmgCfg?.basicRet
+      lodash.forEach(dmgCalc.dmgRet, (row) => {
+        lodash.forEach(row, (ds) => {
+          ds.val = (ds.avg > basic.avg ? '+' : '') + Format.comma(ds.avg - basic.avg)
+          ds.dmg = Format.comma(ds.dmg, 0)
+          ds.avg = Format.comma(ds.avg, 0)
+        })
+      })
+      basic.dmg = Format.comma(basic.dmg)
+      basic.avg = Format.comma(basic.avg)
+    }
+
+    return dmgCalc
+  }
+}
+
+export default ProfileDetail

Yunzai/plugins/miao-plugin/apps/profile/ProfileList.js

@@ -0,0 +1,184 @@
+import lodash from 'lodash'
+import { getTargetUid } from './ProfileCommon.js'
+import { Common, Data } from '#miao'
+import { ProfileRank, Player, Character } from '#miao.models'
+
+const ProfileList = {
+  /**
+   * 刷新面板
+   * @param e
+   * @returns {Promise<boolean|*>}
+   */
+  async refresh (e) {
+    let uid = await getTargetUid(e)
+    if (!uid) {
+      e._replyNeedUid || e.reply('请先发送【#绑定+你的UID】来绑定查询目标')
+      return true
+    }
+
+    // 数据更新
+    let player = Player.create(e)
+    await player.refreshProfile(2)
+
+    if (!player?._update?.length) {
+      e._isReplyed || e.reply('获取角色面板数据失败，请确认角色已在游戏内橱窗展示，并开放了查看详情。设置完毕后请5分钟后再进行请求~')
+      e._isReplyed = true
+    } else {
+      let ret = {}
+      lodash.forEach(player._update, (id) => {
+        let char = Character.get(id)
+        if (char) {
+          ret[char.name] = true
+        }
+      })
+      if (lodash.isEmpty(ret)) {
+        e._isReplyed || e.reply('获取角色面板数据失败，未能请求到角色数据。请确认角色已在游戏内橱窗展示，并开放了查看详情。设置完毕后请5分钟后再进行请求~')
+        e._isReplyed = true
+      } else {
+        e.newChar = ret
+        return await ProfileList.render(e)
+      }
+    }
+    return true
+  },
+
+  /**
+   * 渲染面板
+   * @param e
+   * @returns {Promise<boolean|*>}
+   */
+
+  async render (e) {
+    let uid = await getTargetUid(e)
+    if (!uid) {
+      e._replyNeedUid || e.reply('请先发送【#绑定+你的UID】来绑定查询目标')
+      return true
+    }
+
+    let isSelfUid = false
+    if (e.runtime) {
+      let uids = e.runtime?.user?.ckUids || []
+      isSelfUid = uids.join(',').split(',').includes(uid + '')
+    }
+    let rank = false
+
+    let hasNew = false
+    let newCount = 0
+
+    let chars = []
+    let msg = ''
+    let newChar = {}
+    if (e.newChar) {
+      msg = '获取角色面板数据成功'
+      newChar = e.newChar
+    }
+    const cfg = await Data.importCfg('cfg')
+    // 获取面板数据
+    let player = Player.create(e)
+    let servName = Player.getProfileServName(uid, player.game)
+    if (!player.hasProfile) {
+      await player.refresh({ profile: true })
+    }
+    if (!player.hasProfile) {
+      e.reply(`本地暂无uid${uid}[${player.game}]的面板数据...`)
+      return true
+    }
+    let profiles = player.getProfiles()
+
+    // 检测标志位
+    let qq = (e.at && !e.atBot) ? e.at : e.user_id
+    await ProfileRank.setUidInfo({ uid, profiles, qq, uidType: isSelfUid ? 'ck' : 'bind' })
+
+    let groupId = e.group_id
+    if (groupId) {
+      rank = await ProfileRank.create({ groupId, uid, qq: e.user_id })
+    }
+    const rankCfg = await ProfileRank.getGroupCfg(groupId)
+    const groupRank = rank && (cfg?.diyCfg?.groupRank || false) && rankCfg.status !== 1
+    for (let id in profiles) {
+      let profile = profiles[id]
+      let char = profile.char
+      let tmp = char.getData('id,face,name,abbr,element,star')
+      let imgs = char.getImgs(profile.costume)
+      tmp.face = imgs.qFace || imgs.face
+      tmp.level = profile.level || 1
+      tmp.cons = profile.cons
+      tmp.isNew = 0
+      if (newChar[char.name]) {
+        tmp.isNew = 1
+        newCount++
+      }
+      if (rank) {
+        tmp.groupRank = await rank.getRank(profile, !!tmp.isNew)
+      }
+      chars.push(tmp)
+    }
+
+    if (newCount > 0) {
+      hasNew = newCount <= 8
+    }
+
+    chars = lodash.sortBy(chars, ['isNew', 'star', 'level', 'id'])
+    chars = chars.reverse()
+
+    player.save()
+    // 渲染图像
+    return await Common.render('character/profile-list', {
+      save_id: uid,
+      uid,
+      chars,
+      servName,
+      hasNew,
+      msg,
+      groupRank,
+      updateTime: player.getUpdateTime(),
+      allowRank: rank && rank.allowRank,
+      rankCfg
+    }, { e, scale: 1.6 })
+  },
+  /**
+   * 删除面板数据
+   * @param e
+   * @returns {Promise<boolean>}
+   */
+  async del (e) {
+    let ret = /^#(删除全部面板|删除面板|删除面板数据)\s*(\d{9})?$/.exec(e.msg)
+    let uid = await getTargetUid(e)
+    if (!uid) {
+      return true
+    }
+    let targetUid = ret[2]
+
+    let user = e?.runtime?.user || {}
+    if (!user.hasCk && !e.isMaster) {
+      e.reply('为确保数据安全，目前仅允许绑定CK用户删除自己UID的面板数据，请联系Bot主人删除...')
+      return true
+    }
+
+    if (!targetUid) {
+      e.reply(`你确认要删除面板数据吗？ 请回复 #删除面板${uid} 以删除面板数据`)
+      return true
+    }
+
+    let ckUids = (user?.ckUids || []).join(',').split(',')
+    if (!ckUids.includes(targetUid) && !e.isMaster) {
+      e.reply(`仅允许删除自己的UID数据[${ckUids.join(',')}]`)
+      return true
+    }
+
+    Player.delByUid(targetUid)
+    e.reply(`UID${targetUid}的本地数据已删除，排名数据已清除...`)
+    return true
+  },
+
+  async reload (e) {
+    let uid = await getTargetUid(e)
+    if (!uid) {
+      return true
+    }
+    let player = Player.create(e)
+    player.reload()
+    return ProfileList.render(e)
+  }
+}
+export default ProfileList

Yunzai/plugins/miao-plugin/apps/profile/ProfileRank.js

@@ -0,0 +1,280 @@
+import ProfileDetail from './ProfileDetail.js'
+import { Data, Common, Format, Cfg } from '#miao'
+import { Character, ProfileRank, ProfileDmg, Player } from '#miao.models'
+import lodash from 'lodash'
+
+export async function groupRank (e) {
+  const groupRank = Common.cfg('groupRank')
+  let msg = e.original_msg || e.msg
+  let type = ''
+  if (/(排名|排行|列表)/.test(msg)) {
+    type = 'list'
+  } else if (/(最强|最高|最多|最高分|最牛|第一)/.test(msg)) {
+    type = 'detail'
+  } else if (/极限/.test(msg)) {
+    type = 'super'
+  }
+  let groupId = e.group_id
+  if (!type || (!groupId && type !== 'super')) {
+    return false
+  }
+  let mode = /(分|圣遗物|评分|ACE)/.test(msg) ? 'mark' : 'dmg'
+  mode = /(词条)/.test(msg) ? 'valid' : mode
+  mode = /(双爆)/.test(msg) ? 'crit' : mode
+  let name = msg.replace(/(#|星铁|最强|最高分|第一|词条|双爆|极限|最高|最多|最牛|圣遗物|评分|群内|群|排名|排行|面板|面版|详情|榜)/g, '')
+  let char = Character.get(name)
+  if (!char) {
+    // 名字不存在或不为列表模式，则返回false
+    if (name || type !== 'list') {
+      return false
+    }
+  }
+  if (/星铁/.test(msg) || char.isSr) {
+    e.isSr = true
+  }
+  // 对鲸泽佬的极限角色文件增加支持
+  if (type === 'super') {
+    let player = Player.create(100000000)
+    if (player.getProfile(char.id)) {
+      e.uid = 100000000
+      if (Cfg.get('notReleasedData') === false) {
+        e.reply('未实装角色面板已禁用...')
+        return true
+      }
+      return await ProfileDetail.render(e, char)
+    } else {
+      return true
+    }
+  }
+  // 正常群排名
+  let groupCfg = await ProfileRank.getGroupCfg(groupId)
+  if (!groupRank) {
+    e.reply('群面板排名功能已禁用，Bot主人可通过【#喵喵设置】启用...')
+    return true
+  }
+  if (groupCfg.status === 1) {
+    e.reply('本群已关闭群排名，群管理员或Bot主人可通过【#启用排名】启用...')
+    return true
+  }
+  if (type === 'detail') {
+    let uid = await ProfileRank.getGroupMaxUid(groupId, char.id, mode)
+    if (uid) {
+      e.uid = uid
+      return await ProfileDetail.render(e, char)
+    } else {
+      if (mode === 'dmg' && !ProfileDmg.dmgRulePath(char.name, char.game)) {
+        e.reply(`暂无排名：${char.name}暂不支持伤害计算，无法进行排名..`)
+      } else {
+        e.reply('暂无排名：请通过【#面板】查看角色面板以更新排名信息...')
+      }
+    }
+  } else if (type === 'list') {
+    if (mode === 'dmg' && char && !ProfileDmg.dmgRulePath(char.name, char.game)) {
+      e.reply(`暂无排名：${char.name}暂不支持伤害计算，无法进行排名..`)
+    } else {
+      let uids = []
+      if (char) {
+        uids = await ProfileRank.getGroupUidList(groupId, char ? char.id : '', mode)
+      } else {
+        uids = await ProfileRank.getGroupMaxUidList(groupId, mode)
+      }
+      if (uids.length > 0) {
+        return renderCharRankList({ e, uids, char, mode, groupId })
+      } else {
+        if (e.isSr){
+          e.reply('暂无排名：请通过【*面板】查看角色面板以更新排名信息...')
+        } else {
+          e.reply('暂无排名：请通过【#面板】查看角色面板以更新排名信息...')
+        }
+      }
+    }
+    return true
+  }
+}
+
+export async function resetRank (e) {
+  let groupId = e.group_id
+  if (!groupId) {
+    return true
+  }
+  if (!e.isMaster) {
+    e.reply('只有管理员可重置排名')
+    return true
+  }
+  let msg = e.original_msg || e.msg
+  let name = msg.replace(/(#|重置|重设|排名|排行|群|群内|面板|详情|面版)/g, '').trim()
+  let charId = ''
+  let charName = '全部角色'
+  if (name) {
+    let char = Character.get(name)
+    if (!char) {
+      e.reply(`重置排名失败，角色：${name}不存在`)
+      return true
+    }
+    charId = char.id
+    charName = char.name
+  }
+  await ProfileRank.resetRank(groupId, charId)
+  e.reply(`本群${charName}排名已重置...`)
+}
+
+/**
+ * 刷新群排名信息
+ * @param e
+ * @returns {Promise<boolean>}
+ */
+export async function refreshRank (e) {
+  let groupId = e.group_id || ''
+  if (!groupId) {
+    return true
+  }
+  if (!e.isMaster && !this.e.member?.is_admin) {
+    e.reply('只有主人及群管理员可刷新排名...')
+    return true
+  }
+  e.reply('面板数据刷新中，等待时间可能较长，请耐心等待...')
+  let game = e.isSr ? 'sr' : 'gs'
+  await ProfileRank.resetRank(groupId)
+  let uidMap = await ProfileRank.getUserUidMap(e, game)
+  let count = 0
+  for (let uid in uidMap) {
+    let { qq, type } = uidMap[uid]
+    let player = new Player(uid, game)
+    let profiles = player.getProfiles()
+    // 刷新rankLimit
+    await ProfileRank.setUidInfo({ uid, profiles, qq, uidType: type })
+    let rank = await ProfileRank.create({ groupId, uid, qq })
+    for (let id in profiles) {
+      let profile = profiles[id]
+      if (!profile.hasData) {
+        continue
+      }
+      await rank.getRank(profile, true)
+    }
+    if (rank.allowRank) {
+      count++
+    }
+  }
+  e.reply(`本群排名已刷新，共刷新${count}个UID数据...`)
+}
+
+export async function manageRank (e) {
+  let groupId = e.group_id
+  if (!groupId) {
+    return true
+  }
+  let isClose = /(关闭|禁用)/.test(e.msg)
+  if (!e.isMaster && !this.e.member?.is_admin) {
+    e.reply(`只有主人及群管理员可${isClose ? '禁用' : '启用'}排名...`)
+    return true
+  }
+  await ProfileRank.setGroupStatus(groupId, isClose ? 1 : 0)
+  if (isClose) {
+    e.reply('当前群排名功能已禁用...')
+  } else {
+    e.reply('当前群排名功能已启用...\n如数据有问题可通过【#刷新排名】命令来刷新当前群内排名')
+  }
+}
+
+async function renderCharRankList ({ e, uids, char, mode, groupId }) {
+  let list = []
+  for (let ds of uids) {
+    let uid = ds.uid || ds.value
+    let player = Player.create(uid, e.isSr ? 'sr' : 'gs')
+    let avatar = player.getAvatar(ds.charId || char.id)
+    if (!avatar) {
+      continue
+    }
+    let profile = avatar.getProfile()
+
+    if (profile) {
+      let profileRank = await ProfileRank.create({ groupId, uid })
+      let data = await profileRank.getRank(profile, true)
+      let mark = data?.mark?.data
+      let tmp = {
+        uid,
+        isMax: !char,
+        ...avatar.getData('id,star,name,sName,level,fetter,cons,weapon,elem,talent,artisSet,imgs'),
+        artisMark: Data.getData(mark, 'mark,markClass,valid,crit')
+      }
+      let dmg = data?.dmg?.data
+      if (dmg && dmg.avg) {
+        let title = dmg.title
+        // 稍微缩短下title
+        if (title.length > 10) {
+          title = title.replace(/[ ·]*/g, '')
+        }
+        title = title.length > 10 ? title.replace(/伤害$/, '') : title
+        tmp.dmg = {
+          title: title,
+          avg: Format.comma(dmg.avg, 1)
+        }
+      }
+      if (uid) {
+        let userInfo = await ProfileRank.getUidInfo(uid)
+        try {
+          if (userInfo?.qq && e?.group?.pickMember) {
+            let member = e.group.pickMember(userInfo.qq)
+            if (member?.getAvatarUrl) {
+              let img = await member.getAvatarUrl()
+              if (img) {
+                tmp.qqFace = img
+              }
+            }
+          }
+        } catch (e) {
+          // console.log(e)
+        }
+      }
+
+      if (mode === 'crit') {
+        tmp._mark = mark?._crit * 6.6044 || 0
+      } else if (mode === 'valid') {
+        tmp._mark = mark?._valid || 0
+      } else {
+        tmp._mark = mark?._mark || 0
+      }
+      tmp._formatmark = Format.comma(tmp._mark, 1)
+      tmp._dmg = dmg?.avg || 0
+      tmp._star = 5 - tmp.star
+      list.push(tmp)
+    }
+  }
+  let title
+  if (char) {
+    let modeTitleMap = {}
+    if (e.isSr) {
+      modeTitleMap = {
+        dmg: '',
+        mark: '遗器评分',
+        crit: '双爆副词条',
+        valid: '加权有效词条'
+      }
+    } else {
+      modeTitleMap = {
+        dmg: '',
+        mark: '圣遗物评分',
+        crit: '双爆副词条',
+        valid: '加权有效词条'
+      }
+    }
+    title = `${e.isSr ? '*' : '#'}${char.name}${modeTitleMap[mode]}排行`
+    list = lodash.sortBy(list, mode === 'dmg' ? '_dmg' : '_mark').reverse()
+  } else {
+    title = `${e.isSr ? '*' : '#'}${mode === 'mark' ? '最高分' : '最强'}排行`
+    list = lodash.sortBy(list, ['uid', '_star', 'id'])
+  }
+
+  const rankCfg = await ProfileRank.getGroupCfg(groupId)
+  // 渲染图像
+  return await Common.render('character/rank-profile-list', {
+    save_id: char.id,
+    game: e.isSr ? 'sr' : 'gs',
+    list,
+    title,
+    elem: char.elem,
+    bodyClass: `char-${char.name}`,
+    rankCfg,
+    mode
+  }, { e, scale: 1.4 })
+}

Yunzai/plugins/miao-plugin/apps/profile/ProfileStat.js

@@ -0,0 +1,73 @@
+import { Common } from '#miao'
+import { MysApi, Player, Character } from '#miao.models'
+
+const ProfileStat = {
+  async stat (e) {
+    return ProfileStat.render(e, false)
+  },
+
+  async avatarList (e) {
+    return ProfileStat.render(e, true)
+  },
+  async render (e, isAvatarList = false) {
+    // 缓存时间，单位小时
+    let msg = e.msg.replace('#', '').trim()
+    if (msg === '角色统计' || msg === '武器统计') {
+      // 暂时避让一下抽卡分析的关键词
+      return false
+    }
+
+    let mys = await MysApi.init(e)
+    if (!mys || !mys.uid) return false
+
+    const uid = mys.uid
+
+    let player = Player.create(e)
+
+    let avatarRet = await player.refreshAndGetAvatarData({
+      index: 2,
+      detail: 1,
+      talent: isAvatarList ? 0 : 1,
+      rank: true,
+      retType: 'array',
+      sort: true
+    })
+
+    if (avatarRet.length === 0) {
+      e._isReplyed || e.reply(`查询失败，暂未获得#${uid}角色数据，请绑定CK或 #更新面板`)
+      return true
+    }
+
+    let faceChar = Character.get(player.face || avatarRet[0]?.id)
+    let imgs = faceChar.imgs
+    let face = {
+      banner: imgs?.banner,
+      face: imgs?.face,
+      qFace: imgs?.qFace,
+      name: player.name || `#${uid}`,
+      sign: player.sign,
+      level: player.level
+    }
+
+    let info = player.getInfo()
+    info.stats = info.stats || {}
+    info.statMap = {
+      achievement: '成就',
+      wayPoint: '锚点',
+      avatar: '角色',
+      avatar5: '五星角色',
+      goldCount: '金卡总数'
+    }
+
+    return await Common.render(isAvatarList ? 'character/avatar-list' : 'character/profile-stat', {
+      save_id: uid,
+      uid,
+      info,
+      updateTime: player.getUpdateTime(),
+      isSelfCookie: e.isSelfCookie,
+      face,
+      avatars: avatarRet
+    }, { e, scale: 1.4 })
+  }
+}
+export default ProfileStat

Yunzai/plugins/miao-plugin/apps/profile/ProfileUtils.js

@@ -0,0 +1,78 @@
+import { Cfg } from '#miao'
+import { MysApi } from '#miao.models'
+
+/** 获取角色卡片的原图 */
+export async function getOriginalPicture (e) {
+  let source
+  if (e.reply_id) {
+    source = { message_id: e.reply_id }
+  } else {
+    if (!e.hasReply && !e.source) {
+      return false
+    }
+    // 引用的消息不是自己的消息
+    if (e.source.user_id !== e.self_id) {
+      return false
+    }
+    // 引用的消息不是纯图片
+    if (!/^\[图片]$/.test(e.source.message)) {
+      return false
+    }
+    // 获取原消息
+    if (e.group?.getChatHistory) {
+      source = (await e.group.getChatHistory(e.source.seq, 1)).pop()
+    } else if (e.friend?.getChatHistory) {
+      source = (await e.friend.getChatHistory(e.source.time, 1)).pop()
+    }
+  }
+  let originalPic = Cfg.get('originalPic') * 1
+  if (source) {
+    let imgPath = await redis.get(`miao:original-picture:${source.message_id}`)
+    if (imgPath) {
+      try {
+        if (imgPath[0] === '{') {
+          imgPath = JSON.parse(imgPath)
+        } else {
+          imgPath = { img: imgPath, type: '' }
+        }
+      } catch (e) {
+      }
+      if (!e.isMaster) {
+        if (imgPath.type === 'character' && [2, 0].includes(originalPic)) {
+          e.reply('已禁止获取角色原图...')
+          return true
+        }
+        if (imgPath.type === 'profile' && [1, 0].includes(originalPic)) {
+          e.reply('已禁止获取面板原图...')
+          return true
+        }
+      }
+      if (imgPath && imgPath.img) {
+        e.reply(segment.image(`file://${process.cwd()}/plugins/miao-plugin/resources/${decodeURIComponent(imgPath.img)}`), false, { recallMsg: 30 })
+      }
+      return true
+    }
+    // 对at错图像的增加嘲讽...
+    e.reply(segment.image(`file://${process.cwd()}/plugins/miao-plugin/resources/common/face/what.jpg`))
+    return false
+  }
+  e.reply('消息太过久远了，俺也忘了原图是啥了，下次早点来吧~')
+  return false
+}
+
+/* #敌人等级 */
+export async function enemyLv (e) {
+  let selfUser = await MysApi.initUser(e)
+  if (!selfUser || !e.msg) {
+    return true
+  }
+  let ret = /(敌人|怪物)等级\s*(\d{1,3})\s*$/.exec(e.msg)
+  if (ret && ret[2]) {
+    let lv = ret[2] * 1
+    await selfUser.setCfg('char.enemyLv', lv)
+    lv = await selfUser.getCfg('char.enemyLv', 91)
+    e.reply(`敌人等级已经设置为${lv}`)
+    return true
+  }
+  return true
+}

Yunzai/plugins/miao-plugin/apps/profile/ProfileWeapon.js

@@ -0,0 +1,36 @@
+import { ProfileData, Weapon } from '#miao.models'
+
+export const ProfileWeapon = {
+  async calc (profile, game = 'gs') {
+    let ret = []
+    await Weapon.forEach(async (w) => {
+      let weaponRet = w.getData('name,star,abbr,icon')
+      weaponRet.dmgs = []
+      for (let affix of [1, 5]) {
+        if (affix === 5 && w.maxAffix !== 5) {
+          continue
+        }
+        let tempProfile = new ProfileData({
+          ...profile.getData('uid,id,level,cons,fetter,elem,promote,talent,artis'),
+          dataSource: 'change'
+        }, game, false)
+
+        tempProfile.setWeapon({
+          name: w.name,
+          star: w.star,
+          level: w.maxLv,
+          promote: w.maxPromote,
+          affix
+        })
+        tempProfile.calcAttr()
+        weaponRet.dmgs.push({
+          affix,
+          ...await tempProfile.calcDmg({ mode: 'single' })
+        })
+      }
+      ret.push(weaponRet)
+    }, profile?.weapon?.type)
+    return ret
+  }
+
+}

Yunzai/plugins/miao-plugin/apps/stat.js

@@ -0,0 +1,37 @@
+/*
+* 胡桃数据库的统计
+*
+* */
+import { ConsStat, AbyssPct } from './stat/AbyssStat.js'
+import { AbyssTeam } from './stat/AbyssTeam.js'
+import { AbyssSummary } from './stat/AbyssSummary.js'
+import { App } from '#miao'
+
+let app = App.init({
+  id: 'stat',
+  name: '深渊统计'
+})
+
+app.reg({
+  consStat: {
+    rule: /^#(喵喵)?角色(持有|持有率|命座|命之座|.命)(分布|统计|持有|持有率)?$/,
+    fn: ConsStat,
+    desc: '【#统计】 #角色持有率 #角色5命统计'
+  },
+  abyssPct: {
+    rule: /^#(喵喵)?深渊(第?.{1,2}层)?(角色)?(出场|使用)(率|统计)*$/,
+    fn: AbyssPct,
+    desc: '【#统计】 #深渊出场率 #深渊12层出场率'
+  },
+  abyssTeam: {
+    rule: /^#深渊(组队|配队)$/,
+    fn: AbyssTeam,
+    describe: '【#角色】 #深渊组队'
+  },
+  abyssSummary: {
+    rule: /^#*(喵喵|上传|本期)*(深渊|深境|深境螺旋)[ |0-9]*(数据)?$/,
+    fn: AbyssSummary,
+    desc: '上传深渊'
+  }
+})
+export default app

Yunzai/plugins/miao-plugin/apps/stat/AbyssStat.js

@@ -0,0 +1,164 @@
+import HutaoApi from './HutaoApi.js'
+import lodash from 'lodash'
+import { Common } from '#miao'
+import { Character } from '#miao.models'
+
+export async function ConsStat (e) {
+  let consData = await HutaoApi.getCons()
+  let overview = await HutaoApi.getOverview()
+
+  if (!consData) {
+    e.reply('角色持有数据获取失败，请稍后重试~')
+    return true
+  }
+
+  let msg = e.msg
+
+  let mode = /持有/.test(msg) ? 'char' : 'cons'
+
+  let conNum = -1
+  if (mode === 'cons') {
+    lodash.forEach([/0|零/, /1|一/, /2|二/, /3|三/, /4|四/, /5|五/, /6|六|满/], (reg, idx) => {
+      if (reg.test(msg)) {
+        conNum = idx
+        return false
+      }
+    })
+  }
+
+  if (!consData && !consData.data) {
+    return true
+  }
+
+  let data = consData.data
+
+  let Lumine = lodash.filter(data, (ds) => ds.avatar === 10000007)[0] || {}
+  let Aether = lodash.filter(data, (ds) => ds.avatar === 10000005)[0] || {}
+
+  Lumine.holdingRate = (1 - Aether.holdingRate) || Lumine.holdingRate
+
+  let ret = []
+
+  lodash.forEach(data, (ds) => {
+    let char = Character.get(ds.avatar)
+
+    let data = {
+      name: char.name || ds.avatar,
+      abbr: char.abbr,
+      star: char.star || 3,
+      side: char.side,
+      hold: ds.holdingRate
+    }
+
+    if (mode === 'char') {
+      data.cons = lodash.map(ds.rate, (c) => {
+        c.value = c.value * ds.holdingRate
+        return c
+      })
+    } else {
+      data.cons = ds.rate
+    }
+    data.cons = lodash.sortBy(data.cons, ['id'])
+
+    ret.push(data)
+  })
+
+  if (conNum > -1) {
+    ret = lodash.sortBy(ret, [`cons[${conNum}].value`])
+    ret.reverse()
+  } else {
+    ret = lodash.sortBy(ret, ['hold'])
+  }
+  // 渲染图像
+  return await Common.render('stat/character', {
+    chars: ret,
+    mode,
+    conNum,
+    totalCount: overview?.data?.totalPlayerCount || 0,
+    lastUpdate: consData.lastUpdate,
+    pct: function (num) {
+      return (num * 100).toFixed(2)
+    }
+  }, { e, scale: 1.5 })
+}
+
+export async function AbyssPct (e) {
+  let mode = /使用/.test(e.msg) ? 'use' : 'pct'
+  let modeName
+  let abyssData
+  let modeMulti = 1
+
+  if (mode === 'use') {
+    modeName = '使用率'
+    abyssData = await HutaoApi.getAbyssUse()
+  } else {
+    modeName = '出场率'
+    abyssData = await HutaoApi.getAbyssPct()
+    modeMulti = 8
+  }
+  let overview = await HutaoApi.getOverview()
+
+  if (!abyssData) {
+    e.reply(`深渊${modeName}数据获取失败，请稍后重试~`)
+    return true
+  }
+
+  let ret = []
+  let chooseFloor = -1
+  let msg = e.msg
+
+  const floorName = {
+    12: '十二层',
+    11: '十一层',
+    10: '十层',
+    9: '九层'
+  }
+
+  // 匹配深渊楼层信息
+  lodash.forEach(floorName, (cn, num) => {
+    let reg = new RegExp(`${cn}|${num}`)
+    if (reg.test(msg)) {
+      chooseFloor = num
+      return false
+    }
+  })
+
+  let data = abyssData.data
+  data = lodash.sortBy(data, 'floor')
+  data = data.reverse()
+
+  lodash.forEach(data, (floorData) => {
+    let avatars = []
+    lodash.forEach(floorData.avatarUsage, (ds) => {
+      let char = Character.get(ds.id)
+      if (char) {
+        avatars.push({
+          name: char.name,
+          star: char.star,
+          value: ds.value * modeMulti,
+          face: char.face
+        })
+      }
+    })
+    avatars = lodash.sortBy(avatars, 'value', ['asc'])
+    avatars.reverse()
+    if (chooseFloor === -1) {
+      avatars = avatars.slice(0, 14)
+    }
+
+    ret.push({
+      floor: floorData.floor,
+      avatars
+    })
+  })
+
+  return await Common.render('stat/abyss-pct', {
+    abyss: ret,
+    floorName,
+    chooseFloor,
+    mode,
+    modeName,
+    totalCount: overview?.data?.collectedPlayerCount || 0,
+    lastUpdate: abyssData.lastUpdate
+  }, { e, scale: 1.5 })
+}

Yunzai/plugins/miao-plugin/apps/stat/AbyssSummary.js

@@ -0,0 +1,137 @@
+import lodash from 'lodash'
+import HutaoApi from './HutaoApi.js'
+import { Cfg, Common, Data } from '#miao'
+import { Abyss, Character, MysApi, Player } from '#miao.models'
+
+export async function AbyssSummary (e) {
+  let isMatch = /^#(喵喵|上传)深渊(数据)?$/.test(e.original_msg || e.msg || '')
+  if (!Cfg.get('uploadAbyssData', false) && !isMatch) {
+    return false
+  }
+  let mys = await MysApi.init(e, 'all')
+  if (!mys || !mys.uid) {
+    if (isMatch) {
+      e.reply(`请绑定ck后再使用${e.original_msg || e.msg}`)
+    }
+    return false
+  }
+  let ret = {}
+  let uid = mys.uid
+  let player = Player.create(e)
+  let resDetail, resAbyss
+  try {
+    resAbyss = await mys.getSpiralAbyss(1)
+    let lvs = Data.getVal(resAbyss, 'floors.0.levels.0')
+    // 检查是否查询到了深渊信息
+    if (!lvs || !lvs.battles) {
+      e.reply('暂未获得本期深渊挑战数据...')
+      return true
+    } else if (lvs && lvs.battles && lvs.battles.length === 0) {
+      if (!mys.isSelfCookie) {
+        if (isMatch) {
+          e.reply(`请绑定ck后再使用${e.original_msg || e.msg}`)
+        }
+        return false
+      }
+    }
+    resDetail = await mys.getCharacter()
+    if (!resDetail || !resAbyss || !resDetail.avatars || resDetail.avatars.length <= 3) {
+      e.reply('角色信息获取失败')
+      return true
+    }
+    delete resDetail._res
+    delete resAbyss._res
+    ret = await HutaoApi.uploadData({
+      uid,
+      resDetail,
+      resAbyss
+    })
+  } catch (err) {
+    // console.log(err);
+  }
+  // 更新player信息
+  player.setMysCharData(resDetail)
+
+  if (ret && ret.retcode === 0) {
+    let stat = []
+    if (ret.data) {
+      if (resAbyss.floors.length === 0) {
+        e.reply('暂未获得本期深渊挑战数据...')
+        return true
+      }
+      let abyss = new Abyss(resAbyss)
+      let abyssData = abyss.getData()
+      let avatarIds = abyss.getAvatars()
+      let overview = ret.info || (await HutaoApi.getOverview())?.data || {}
+      let addMsg = function (title, ds) {
+        let tmp = {}
+        if (!ds) {
+          return false
+        }
+        if (!ds.avatarId && !ds.id) {
+          return false
+        }
+        let char = Character.get(ds.avatarId || ds.id)
+        tmp.title = title
+        tmp.id = char.id
+        tmp.value = `${(ds.value / 10000).toFixed(1)} W`
+        let msg = []
+        tmp.msg = msg
+        let pct = (percent, name) => {
+          if (percent < 0.2) {
+            msg.push({
+              title: '少于',
+              value: (Math.max(0.1, 100 - percent * 100)).toFixed(1),
+              name: name
+            })
+          } else {
+            msg.push({
+              title: '超过',
+              value: (Math.min(99.9, percent * 100)).toFixed(1),
+              name: name
+            })
+          }
+        }
+        if (ds.percent) {
+          pct(ds.percent, char.abbr)
+          pct(ds.percentTotal, '总记录')
+        } else {
+          msg.push({
+            txt: '暂无统计信息'
+          })
+        }
+        stat.push(tmp)
+      }
+      addMsg('最强一击', ret.data?.damage || abyssData?.stat?.dmg || {})
+      addMsg('最高承伤', ret.data?.takeDamage || abyssData?.stat.takeDmg || {})
+      let abyssStat = abyssData?.stat || {}
+      lodash.forEach({ defeat: '最多击破', e: '元素战技', q: '元素爆发' }, (title, key) => {
+        if (abyssStat[key]) {
+          stat.push({
+            title,
+            id: abyssStat[key]?.id || 0,
+            value: `${abyssStat[key]?.value}次`
+          })
+        } else {
+          stat.push({})
+        }
+      })
+      await player.refreshTalent(avatarIds)
+      let avatarData = player.getAvatarData(avatarIds)
+      return await Common.render('stat/abyss-summary', {
+        abyss: abyssData,
+        avatars: avatarData,
+        stat,
+        save_id: uid,
+        totalCount: overview?.collectedPlayerCount || 0,
+        uid
+      }, { e, scale: 1.2 })
+    } else {
+      e.reply('暂未获得本期深渊挑战数据...')
+      return true
+    }
+  } else {
+    e.reply(`${ret.message || '上传失败'}，请稍后重试...`)
+  }
+  return true
+}

Yunzai/plugins/miao-plugin/apps/stat/AbyssTeam.js

@@ -0,0 +1,190 @@
+import lodash from 'lodash'
+import HutaoApi from './HutaoApi.js'
+import { Common } from '#miao'
+import { Character, MysApi, Player } from '#miao.models'
+
+export async function AbyssTeam (e) {
+  let mys = await MysApi.init(e, 'all')
+  if (!mys || !mys.uid) {
+    e.reply(`请绑定ck后再使用${e.original_msg || e.msg}`)
+    return false
+  }
+  let player = Player.create(e)
+  await player.refreshMysDetail(2)
+  await player.refreshTalent()
+
+  let abyssData = await HutaoApi.getAbyssTeam()
+  if (!abyssData || !abyssData.data) {
+    e.reply('深渊组队数据获取失败，请稍后重试~')
+    return true
+  }
+  abyssData = abyssData.data
+  let avatarData = player.getAvatarData()
+  let avatarRet = {}
+  let data = {}
+  let noAvatar = {}
+  lodash.forEach(avatarData, (avatar) => {
+    let t = avatar.originalTalent || {}
+    avatarRet[avatar.id] = Math.min(avatar.level, (avatar.weapon?.level || 1)) * 100 + Math.max(t?.a || 1, t?.e || 1, t?.q || 1) * 1000
+  })
+
+  let getTeamCfg = (str) => {
+    let teams = str.split(',')
+    teams.sort()
+    let teamMark = 0
+    lodash.forEach(teams, (a) => {
+      if (!avatarRet[a]) {
+        teamMark = -1
+        noAvatar[a] = true
+      }
+      if (teamMark !== -1) {
+        teamMark += avatarRet[a] * 1
+      }
+    })
+    if (teamMark === -1) {
+      teamMark = 1
+    }
+    return {
+      key: teams.join(','),
+      mark: teamMark
+    }
+  }
+
+  let hasSame = function (team1, team2) {
+    for (let idx = 0; idx < team1.length; idx++) {
+      if (team2.includes(team1[idx])) {
+        return true
+      }
+    }
+    return false
+  }
+
+  lodash.forEach(abyssData, (ds) => {
+    let floor = ds.floor
+    if (!data[floor]) {
+      data[floor] = {
+        up: {},
+        down: {},
+        teams: []
+      }
+    }
+    lodash.forEach(['up', 'down'], (halfKey) => {
+      lodash.forEach(ds[halfKey], (ds) => {
+        let teamCfg = getTeamCfg(ds.item)
+        if (teamCfg) {
+          if (!data[floor][halfKey][teamCfg.key]) {
+            data[floor][halfKey][teamCfg.key] = {
+              count: 0,
+              mark: 0,
+              hasTeam: teamCfg.mark > 1
+            }
+          }
+          data[floor][halfKey][teamCfg.key].count += ds.rate
+          data[floor][halfKey][teamCfg.key].mark += ds.rate * teamCfg.mark
+        }
+      })
+    })
+
+    let temp = []
+    lodash.forEach(['up', 'down'], (halfKey) => {
+      lodash.forEach(data[floor][halfKey], (ds, team) => {
+        temp.push({
+          team,
+          teamArr: team.split(','),
+          half: halfKey,
+          count: ds.count,
+          mark: ds.mark,
+          mark2: 1,
+          hasTeam: ds.hasTeam
+        })
+      })
+      temp = lodash.sortBy(temp, 'mark')
+      data[floor].teams = temp.reverse()
+    })
+  })
+
+  let ret = {}
+
+  lodash.forEach(data, (floorData, floor) => {
+    ret[floor] = {}
+    let ds = ret[floor]
+    lodash.forEach(floorData.teams, (t1) => {
+      if (t1.mark2 <= 0) {
+        return true
+      }
+      lodash.forEach(floorData.teams, (t2) => {
+        if (t1.mark2 <= 0) {
+          return true
+        }
+        if (t1.half === t2.half || t2.mark2 <= 0) {
+          return true
+        }
+
+        let teamKey = t1.half === 'up' ? (t1.team + '+' + t2.team) : (t2.team + '+' + t1.team)
+        if (ds[teamKey]) {
+          return true
+        }
+        if (hasSame(t1.teamArr, t2.teamArr)) {
+          return true
+        }
+
+        ds[teamKey] = {
+          up: t1.half === 'up' ? t1 : t2,
+          down: t1.half === 'up' ? t2 : t1,
+          count: Math.min(t1.count, t2.count),
+          mark: t1.hasTeam && t2.hasTeam ? t1.mark + t2.mark : t1.count + t2.count // 如果不存在组队则进行评分惩罚
+        }
+        t1.mark2--
+        t2.mark2--
+        return false
+      })
+      if (lodash.keys(ds).length >= 20) {
+        return false
+      }
+    })
+  })
+
+  lodash.forEach(ret, (ds, floor) => {
+    ds = lodash.sortBy(lodash.values(ds), 'mark')
+    ds = ds.reverse()
+    ds = ds.slice(0, 4)
+
+    lodash.forEach(ds, (team) => {
+      team.up.teamArr = Character.sortIds(team.up.teamArr)
+      team.down.teamArr = Character.sortIds(team.down.teamArr)
+    })
+
+    ret[floor] = ds
+  })
+
+  let avatarMap = {}
+
+  lodash.forEach(avatarData, (ds) => {
+    let char = Character.get(ds.id)
+    avatarMap[ds.id] = {
+      id: ds.id,
+      name: ds.name,
+      star: ds.star,
+      level: ds.level,
+      cons: ds.cons,
+      face: char.face
+    }
+  })
+
+  lodash.forEach(noAvatar, (d, id) => {
+    let char = Character.get(id)
+    avatarMap[id] = {
+      id,
+      name: char.name,
+      face: char.face,
+      star: char.star,
+      level: 0,
+      cons: 0
+    }
+  })
+
+  return await Common.render('stat/abyss-team', {
+    teams: ret,
+    avatars: avatarMap
+  }, { e, scale: 1.5 })
+}

Yunzai/plugins/miao-plugin/apps/stat/HutaoApi.js

@@ -0,0 +1,73 @@
+/*
+* 胡桃API Miao-Plugin 封装
+* https://github.com/DGP-Studio/DGP.Genshin.HutaoAPI
+*
+* */
+
+import fetch from 'node-fetch'
+import { Data } from '#miao'
+
+const host = 'http://miao.games/api/hutao'
+
+function getApi (api) {
+  return `${host}?api=${api}`
+}
+
+let HutaoApi = {
+  async req (url, param = {}, EX = 3600) {
+    let cacheData = await Data.getCacheJSON(`miao:hutao:${url}`)
+    if (cacheData && cacheData.data && param.method !== 'POST') {
+      return cacheData
+    }
+    let response = await fetch(getApi(`${url}`), {
+      ...param,
+      method: param.method || 'GET'
+    })
+    let retData = await response.json()
+    if (retData && retData.data && param.method !== 'POST') {
+      let d = new Date()
+      retData.lastUpdate = `${d.toLocaleDateString()} ${d.toTimeString().substr(0, 5)}`
+      await Data.setCacheJSON(`miao:hutao:${url}`, retData, EX)
+    }
+    return retData
+  },
+
+  // 角色持有及命座分布
+  async getCons () {
+    return await HutaoApi.req('/Statistics/Constellation')
+  },
+
+  async getAbyssPct () {
+    return await HutaoApi.req('/Statistics/AvatarParticipation')
+  },
+
+  async getAbyssUse () {
+    return await HutaoApi.req('/Statistics2/AvatarParticipation')
+  },
+
+  async getAbyssTeam () {
+    return await HutaoApi.req('/Statistics/Team/Combination')
+  },
+
+  async getOverview () {
+    return await HutaoApi.req('/Statistics/Overview')
+  },
+
+  async getUsage () {
+    return await HutaoApi.req('/Statistics/Avatar/AvatarCollocation')
+  },
+
+  async uploadData (data = {}) {
+    let body = JSON.stringify(data)
+    return await HutaoApi.req('/Record/UploadData', {
+      method: 'POST',
+      headers: {
+        'User-Agent': 'Yunzai-Bot/Miao-Plugin',
+        'Content-Type': 'text/json; charset=utf-8'
+      },
+      body
+    })
+  }
+}
+
+export default HutaoApi

Yunzai/plugins/miao-plugin/apps/wiki.js

@@ -0,0 +1,29 @@
+import { App } from '#miao'
+import Calendar from './wiki/Calendar.js'
+import CharWiki from './wiki/CharWiki.js'
+import CalendarSr from './wiki/CalendarSr.js'
+
+let app = App.init({
+  id: 'wiki',
+  name: '角色资料'
+})
+app.reg({
+  wiki: {
+    rule: '^#喵喵WIKI$',
+    check: CharWiki.check,
+    fn: CharWiki.wiki,
+    desc: '【#资料】 #神里天赋 #夜兰命座'
+  },
+  calendar: {
+    rule: /^(#|喵喵)+(日历|日历列表)$/,
+    fn: Calendar.render,
+    desc: '【#日历】 原神活动日历'
+  },
+  calendarSr: {
+    rule: /^#(星铁)+(日历|日历列表)$/,
+    fn: CalendarSr.render,
+    desc: '【#星铁日历】 星铁活动日历'
+  }
+})
+
+export default app

Yunzai/plugins/miao-plugin/apps/wiki/Calendar.js

@@ -0,0 +1,414 @@
+import lodash from 'lodash'
+import fetch from 'node-fetch'
+import moment from 'moment'
+import { Common, Data, Cfg } from '#miao'
+import { Character, Material } from '#miao.models'
+
+const ignoreIds = [495, // 有奖问卷调查开启！
+  1263, // 米游社《原神》专属工具一览
+  423, // 《原神》玩家社区一览
+  422, // 《原神》防沉迷系统说明
+  762 // 《原神》公平运营声明
+]
+
+const ignoreReg = /(内容专题页|版本更新说明|调研|防沉迷|米游社|专项意见|更新修复与优化|问卷调查|版本更新通知|更新时间说明|预下载功能|周边限时|周边上新|角色演示)/
+const fulltimeReg = /(魔神任务)/
+
+let Cal = {
+  async reqCalData () {
+    let listApi = 'https://hk4e-api.mihoyo.com/common/hk4e_cn/announcement/api/getAnnList?game=hk4e&game_biz=hk4e_cn&lang=zh-cn&bundle_id=hk4e_cn&platform=pc&region=cn_gf01&level=55&uid=100000000'
+
+    let request = await fetch(listApi)
+    let listData = await request.json()
+
+    let timeMap
+    let timeMapCache = await redis.get('miao:calendar:detail')
+    if (timeMapCache) {
+      timeMap = JSON.parse(timeMapCache) || {}
+    } else {
+      let detailApi = 'https://hk4e-api.mihoyo.com/common/hk4e_cn/announcement/api/getAnnContent?game=hk4e&game_biz=hk4e_cn&lang=zh-cn&bundle_id=hk4e_cn&platform=pc&region=cn_gf01&level=55&uid=100000000'
+      let request2 = await fetch(detailApi)
+      let detailData = await request2.json()
+      timeMap = {}
+      if (detailData && detailData.data && detailData.data.list) {
+        let versionTime = {
+          2.7: '2022-05-31 11:00:00',
+          2.8: '2022-07-13 11:00:00',
+          3.0: '2022-08-24 11:00:00',
+          3.1: '2022-09-28 11:00:00',
+          3.2: '2022-11-02 11:00:00',
+          3.3: '2022-12-07 11:00:00'
+        }
+        lodash.forEach(detailData.data.list, (ds) => {
+          let vRet = /(\d\.\d)版本更新通知/.exec(ds.title)
+          if (vRet && vRet[1]) {
+            let content = /(?:更新时间)\s*〓([^〓]+)(?:〓|$)/.exec(ds.content)
+            if (content && content[1]) {
+              let tRet = /([0-9\\/\\: ]){9,}/.exec(content[1])
+              if (tRet && tRet[0]) {
+                versionTime[vRet[1]] = versionTime[vRet[1]] || tRet[0].replace('06:00', '11:00')
+              }
+            }
+          }
+        })
+        lodash.forEach(detailData.data.list, (ds) => {
+          let { ann_id: annId, content, title } = ds
+          if (ignoreReg.test(title)) {
+            return true
+          }
+          content = content.replace(/(<|&lt;)[\w "%:;=\-\\/\\(\\),\\.]+(>|&gt;)/g, '')
+          content = /(?:活动时间|祈愿介绍|任务开放时间|冒险....包|折扣时间)\s*〓([^〓]+)(〓|$)/.exec(content)
+          if (!content || !content[1]) {
+            return true
+          }
+          content = content[1]
+          let annTime = []
+
+          // 第一种简单格式
+          let timeRet = /(?:活动时间)?(?:〓|\s)*([0-9\\/\\: ~]{6,})/.exec(content)
+          if (timeRet && timeRet[1]) {
+            annTime = timeRet[1].split('~')
+          } else if (/\d\.\d版本更新后/.test(content)) {
+            let vRet = /(\d\.\d)版本更新后/.exec(content)
+            let vTime = ''
+            if (vRet && vRet[1] && versionTime[vRet[1]]) {
+              vTime = versionTime[vRet[1]]
+            }
+            if (!vTime) {
+              return true
+            }
+            if (/永久开放/.test(content)) {
+              annTime = [vTime, '2099/01/01 00:00:00']
+            } else {
+              timeRet = /([0-9\\/\\: ]){9,}/.exec(content)
+              if (timeRet && timeRet[0]) {
+                annTime = [vTime, timeRet[0]]
+              }
+            }
+          }
+          if (annTime.length === 2) {
+            timeMap[annId] = {
+              start: annTime[0].trim().replace(/\//g, '-'),
+              end: annTime[1].trim().replace(/\//g, '-')
+            }
+          }
+        })
+      }
+      let miaoApi = 'http://miao.games/api/calendar'
+      try {
+        request2 = await fetch(miaoApi)
+        let data = await request2.json()
+        if (data && data.status === 0 && data.data) {
+          lodash.forEach(data.data, (ds, id) => {
+            timeMap[id] = ds
+          })
+        }
+      } catch (e) {
+      }
+      await Data.setCacheJSON('miao:calendar:detail', timeMap, 60 * 10)
+    }
+    return { listData, timeMap }
+  },
+
+  getDateList () {
+    let today = moment()
+    let temp = today.add(-7, 'days')
+    let dateList = []
+    let month = 0
+    let date = []
+    let week = []
+
+    let startDate, endDate
+
+    for (let idx = 0; idx < 13; idx++) {
+      temp = today.add(1, 'days')
+      let m = temp.month() + 1
+      let d = temp.date()
+      if (month === 0) {
+        startDate = temp.format('YYYY-MM-DD')
+        month = m
+      }
+      if (month !== m && date.length > 0) {
+        dateList.push({
+          month,
+          date,
+          week
+        })
+        date = []
+        week = []
+        month = m
+      }
+      date.push(d)
+      week.push(temp.weekday())
+      if (idx === 12) {
+        dateList.push({
+          month,
+          date,
+          week
+        })
+        endDate = temp.format('YYYY-MM-DD')
+      }
+    }
+
+    let startTime = moment(startDate + ' 00:00:00')
+    let endTime = moment(endDate + ' 23:59:59')
+
+    let totalRange = endTime - startTime
+    return {
+      dateList,
+      startTime,
+      endTime,
+      totalRange,
+      nowLeft: (moment() - startTime) / totalRange * 100
+    }
+  },
+
+  // 深渊日历信息
+  getAbyssCal (s1, e1) {
+    let now = moment()
+    let check = []
+    let f = 'YYYY-MM'
+    let last = now.add(-1, 'M').format(f)
+    let lastM = now.format('MMMM')
+    let curr = now.add(1, 'M').format(f)
+    let currM = now.format('MMMM')
+    let next = now.add(1, 'M').format(f)
+    let nextM = now.format('MMMM')
+
+    check.push([moment(`${last}-16 04:00:00`), moment(`${curr}-01 03:59:59`), lastM + '下半'])
+    check.push([moment(`${curr}-01 04:00:00`), moment(`${curr}-16 03:59:59`), currM + '上半'])
+    check.push([moment(`${curr}-16 04:00:00`), moment(`${next}-01 03:59:59`), currM + '下半'])
+    check.push([moment(`${next}-01 04:00:00`), moment(`${next}-16 03:59:59`), nextM + '上半'])
+
+    let ret = []
+    lodash.forEach(check, (ds) => {
+      let [s2, e2] = ds
+      if ((s2 <= s1 && s1 <= e2) || (s2 <= e1 && e1 <= e2)) {
+        ret.push(ds)
+      }
+    })
+    return ret
+  },
+
+  /**
+   * 获取角色数据
+   * @param dateList
+   * @returns {{charBirth: {}, charNum: number, charTalent: (*|{})}}
+   */
+  getCharData (dateList) {
+    let charBirth = {}
+    let charTalent = {}
+    // 初始化生日数据
+    lodash.forEach(dateList, (m) => {
+      lodash.forEach(m.date, (d) => {
+        charBirth[`${m.month}-${d}`] = []
+      })
+    })
+    // 初始化天赋数据
+    let now = moment(new Date())
+    if (now.hour() < 4) {
+      now = now.add(-1, 'days')
+    }
+    let week = now.weekday()
+    Material.forEach('talent', (material) => {
+      let data = material.getData('name,abbr,city,icon,week,cid')
+      data.chars = []
+      charTalent[material.name] = data
+    }, (ds) => ds.star === 4 && (week === 6 || ds.week === week % 3 + 1))
+    // 遍历角色数据
+    Character.forEach((char) => {
+      if (charBirth[char.birth] && (char.isRelease || char.birth !== '1-1')) {
+        charBirth[char.birth].push(char.getData('id,name:sName,star,face'))
+      }
+      let t = char.materials?.talent
+      if (t && charTalent[t] && !char.isTraveler) {
+        let data = char.getData('id,name:sName,star,face')
+        data.weekly = char.getMaterials('weekly')?.icon
+        charTalent[t].chars.push(data)
+      }
+    }, Cfg.get('notReleasedData') ? 'official' : 'release')
+    let charNum = 0
+    lodash.forEach(charBirth, (charList) => {
+      charNum = Math.max(charNum, charList.length)
+    })
+    charTalent = lodash.values(charTalent)
+    charTalent = lodash.sortBy(charTalent, 'cid')
+    lodash.forEach(charTalent, (ds) => {
+      ds.chars = lodash.sortBy(ds.chars, ['star', 'id']).reverse()
+    })
+    return { charBirth, charNum, charTalent }
+  },
+
+  /**
+   * 获取日历列表
+   * @param ds
+   * @param target
+   * @param startTime
+   * @param endTime
+   * @param totalRange
+   * @param now
+   * @param timeMap
+   * @param isAct
+   * @returns {boolean}
+   */
+  getList (ds, target, { startTime, endTime, totalRange, now, timeMap = {} }, isAct = false) {
+    let type = isAct ? 'activity' : 'normal'
+    let id = ds.ann_id
+    let title = ds.title
+    let banner = isAct ? ds.banner : ''
+    let extra = { sort: isAct ? 5 : 10 }
+    let detail = timeMap[id] || {}
+
+    if (ignoreIds.includes(id) || ignoreReg.test(title) || detail.display === false) {
+      return false
+    }
+
+    if (/神铸赋形/.test(title)) {
+      type = 'weapon'
+      title = title.replace(/(单手剑|双手剑|长柄武器|弓|法器|·)/g, '')
+      extra.sort = 2
+    } else if (/祈愿/.test(title)) {
+      type = 'character'
+      let regRet = /·(.*)\(/.exec(title)
+      if (regRet[1]) {
+        let char = Character.get(regRet[1])
+        extra.banner2 = char.getImgs()?.card
+        extra.face = char.face
+        extra.character = regRet[1]
+        extra.elem = char.elem
+        extra.sort = 1
+      }
+    } else if (/纪行/.test(title)) {
+      type = 'pass'
+    }
+
+    let getDate = (d1, d2) => moment(d1 && d1.length > 6 ? d1 : d2)
+    let sDate = getDate(detail.start, ds.start_time)
+    let eDate = getDate(detail.end, ds.end_time)
+    let sTime = moment.max(sDate, startTime)
+    let eTime = moment.min(eDate, endTime)
+
+    let sRange = sTime - startTime
+    let eRange = eTime - startTime
+
+    let left = sRange / totalRange * 100
+    let width = eRange / totalRange * 100 - left
+
+    let label = ''
+    if (fulltimeReg.test(title) || eDate - sDate > 365 * 24 * 3600 * 1000) {
+      if (sDate < now) {
+        label = sDate.format('MM-DD HH:mm') + ' 后永久有效'
+      } else {
+        label = '永久有效'
+      }
+    } else if (now > sDate && eDate > now) {
+      label = eDate.format('MM-DD HH:mm') + ' (' + moment.duration(eDate - now).humanize() + '后结束)'
+      if (width > (isAct ? 38 : 55)) {
+        label = sDate.format('MM-DD HH:mm') + ' ~ ' + label
+      }
+    } else if (sDate > now) {
+      label = sDate.format('MM-DD HH:mm') + ' (' + moment.duration(sDate - now).humanize() + '后开始)'
+    } else if (isAct) {
+      label = sDate.format('MM-DD HH:mm') + ' ~ ' + eDate.format('MM-DD HH:mm')
+    }
+    if (sDate <= endTime && eDate >= startTime) {
+      target.push({
+        ...extra,
+        id,
+        title,
+        type,
+        mergeStatus: ['activity', 'normal'].includes(type) ? 1 : 0,
+        banner,
+        icon: ds.tag_icon,
+        left,
+        width,
+        label,
+        duration: eTime - sTime,
+        start: sDate.format('MM-DD HH:mm'),
+        end: eDate.format('MM-DD HH:mm')
+      })
+    }
+  },
+
+  async get () {
+    moment.locale('zh-cn')
+    let now = moment()
+
+    let { listData, timeMap } = await Cal.reqCalData()
+
+    let dl = Cal.getDateList()
+
+    let list = []
+    let abyss = []
+
+    lodash.forEach(listData.data.list[1].list, (ds) => Cal.getList(ds, list, { ...dl, now, timeMap }, true))
+    lodash.forEach(listData.data.list[0].list, (ds) => Cal.getList(ds, list, { ...dl, now, timeMap }, false))
+
+    let abyssCal = Cal.getAbyssCal(dl.startTime, dl.endTime)
+    lodash.forEach(abyssCal, (t) => {
+      Cal.getList({
+        title: `「深境螺旋」· ${t[2]}`,
+        start_time: t[0].format('YYYY-MM-DD HH:mm'),
+        end_time: t[1].format('YYYY-MM-DD HH:mm')
+      }, abyss, { ...dl, now }, true)
+    })
+
+    list = lodash.sortBy(list, ['sort', 'start', 'duration'])
+
+    let charCount = 0
+    let charOld = 0
+    let weaponCount = 0
+    let ret = []
+    lodash.forEach(list, (li) => {
+      if (li.type === 'character') {
+        charCount++
+        li.left === 0 && charOld++
+        li.idx = charCount
+      }
+      if (li.type === 'weapon') {
+        weaponCount++
+        li.idx = weaponCount
+      }
+      if (li.mergeStatus === 1) {
+        lodash.forEach(list, (li2) => {
+          if (li2.mergeStatus === 1 && li.left + li.width <= li2.left) {
+            li.mergeStatus = 2
+            li2.mergeStatus = 2
+            ret.push([li, li2])
+            return false
+          }
+        })
+      }
+      if (li.mergeStatus !== 2) {
+        li.mergeStatus = 2
+        ret.push([li])
+      }
+    })
+
+    return {
+      game: 'gs',
+      ...dl,
+      ...Cal.getCharData(dl.dateList),
+      list: ret,
+      abyss,
+      charMode: `char-${charCount}-${charOld}`,
+      nowTime: now.format('YYYY-MM-DD HH:mm'),
+      nowDate: now.date()
+    }
+  },
+
+  async render (e) {
+    let calData = await Cal.get()
+    let mode = 'calendar'
+    if (/(日历列表|活动)$/.test(e.msg)) {
+      mode = 'list'
+    }
+
+    return await Common.render('wiki/calendar', {
+      ...calData,
+      displayMode: mode
+    }, { e, scale: 1.1 })
+  }
+}
+
+export default Cal

Yunzai/plugins/miao-plugin/apps/wiki/CalendarSr.js

@@ -0,0 +1,303 @@
+import lodash from 'lodash'
+import fetch from 'node-fetch'
+import moment from 'moment'
+import Calendar from './Calendar.js'
+import { Common, Data } from '#miao'
+import { Character } from '#miao.models'
+
+const ignoreIds = [
+  257, // 保密测试参与意愿调研
+  194, // 有奖问卷
+  203, // 《崩坏：星穹铁道》社媒聚合页上线
+  183, // 官方社群一览
+  187, // 《崩坏：星穹铁道》防沉迷系统公告
+  185, // 《崩坏：星穹铁道》公平运营声明
+  171 // 《崩坏：星穹铁道》社区专属工具一览
+]
+
+const ignoreReg = /(更新概览|游戏优化|优化说明|内容专题页|版本更新说明|循星归程|调研|防沉迷|米游社|专项意见|更新修复与优化|问卷调查|版本更新通知|更新时间说明|预下载功能|周边限时|周边上新|角色演示|角色PV|版本PV|动画短片|bilibili|激励计划|调整说明|攻略征集)/
+
+let CalSr = {
+  async reqCalData () {
+    let listApi = 'https://hkrpg-api.mihoyo.com/common/hkrpg_cn/announcement/api/getAnnList?game=hkrpg&game_biz=hkrpg_cn&lang=zh-cn&auth_appid=announcement&authkey_ver=1&bundle_id=hkrpg_cn&channel_id=1&level=65&platform=pc&region=prod_gf_cn&sdk_presentation_style=fullscreen&sdk_screen_transparent=true&sign_type=2&uid=100000000'
+
+    let request = await fetch(listApi)
+    let listData = await request.json()
+
+    let timeMap
+    let timeMapCache = await redis.get('miao:calendarSr:detail')
+    if (timeMapCache) {
+      timeMap = JSON.parse(timeMapCache) || {}
+    } else {
+      let detailApi = 'https://hkrpg-api-static.mihoyo.com/common/hkrpg_cn/announcement/api/getAnnContent?game=hkrpg&game_biz=hkrpg_cn&lang=zh-cn&bundle_id=hkrpg_cn&platform=pc&region=prod_gf_cn&level=65&channel_id=1'
+      let request2 = await fetch(detailApi)
+      let detailData = await request2.json()
+      timeMap = {}
+      if (detailData && detailData.data && detailData.data.list) {
+        let versionTime = {
+          1.1: '2022-06-07 11:00:00'
+        }
+        lodash.forEach(detailData.data.list, (ds) => {
+          let vRet = /(\d\.\d)版本\S*更新(概览|说明)/.exec(ds.title)
+          if (vRet && vRet[1]) {
+            let content = /■(?:更新时间)\s*([^■]+)(?:■|$)/.exec(ds.content)
+            if (content && content[1]) {
+              let tRet = /([0-9\\/\\: ]){9,}/.exec(content[1])
+              if (tRet && tRet[0]) {
+                versionTime[vRet[1]] = versionTime[vRet[1]] || tRet[0].replace('06:00', '11:00')
+              }
+            }
+          }
+        })
+        let ret = function (ds) {
+          let { ann_id: annId, content, title } = ds
+          if (ignoreReg.test(title)) {
+            return true
+          }
+          content = content.replaceAll('\u003ch1 style=\"\"\u003e', '※')
+          content = content.replaceAll('\u003c/h1\u003e', '※')
+          content = content.replace(/(<|&lt;)[\w "%:;=\-\\/\\(\\),\\.]+(>|&gt;)/g, '')
+          content = /(?:活动时间|活动跃迁|开放时间|开启时间|折扣时间|上架时间)\s*※([^※]+)(※|$)/.exec(content)
+          if (!content || !content[1]) {
+            return true
+          }
+          content = content[1]
+          let annTime = []
+
+          // 第一种简单格式
+          let timeRet = /(?:活动时间)?(?:※|\s)*([0-9\\/\\: -]{6,})/.exec(content)
+          if (/\d\.\d版本更新后/.test(content)) {
+            let vRet = /(\d\.\d)版本更新后/.exec(content)
+            let vTime = ''
+            if (vRet && vRet[1] && versionTime[vRet[1]]) {
+              vTime = versionTime[vRet[1]]
+            }
+            if (!vTime) {
+              return true
+            }
+            if (/永久开放/.test(content)) {
+              annTime = [vTime, '2099/01/01 00:00:00']
+            } else {
+              timeRet = /([0-9\\/\\: ]){9,}/.exec(content)
+              if (timeRet && timeRet[0]) {
+                annTime = [vTime, timeRet[0]]
+              }
+            }
+          } else if (timeRet && timeRet[1]) {
+            annTime = timeRet[1].split('-')
+          }
+
+          if (annTime.length === 2) {
+            timeMap[annId] = {
+              start: annTime[0].trim().replace(/\//g, '-'),
+              end: annTime[1].trim().replace(/\//g, '-')
+            }
+          }
+        }
+        lodash.forEach(detailData.data.list, (ds) => ret(ds))
+        lodash.forEach(detailData.data.pic_list, (ds) => ret(ds))
+      }
+      await Data.setCacheJSON('miao:calendarSr:detail', timeMap, 60 * 10)
+    }
+    return { listData, timeMap }
+  },
+
+  // 深渊日历信息
+  getAbyssCal (s1, e1, versionStartTime) {
+    let check = []
+    let f = 'YYYY-MM-DD HH:mm:ss'
+
+    let abyss1Start = moment(versionStartTime, 'YYYY-MM-DD HH:mm:ss').add(5, 'days').subtract(3, 'hours').format(f)
+    let abyss1End = moment(abyss1Start).add(14, 'days').format(f)
+    let abyss2Start = abyss1End
+    let abyss2End = moment(abyss2Start).add(14, 'days').format(f)
+    let abyss3Start = abyss2End
+    let abyss3End = moment(abyss3Start).add(14, 'days').format(f)
+    let abyss4Start = abyss3End
+    let abyss4End = moment(abyss4Start).add(14, 'days').format(f)
+    let abyss0End = abyss1Start
+    let abyss0Start = moment(abyss0End).subtract(14, 'days').format(f)
+
+    check.push([moment(abyss0Start), moment(abyss0End)])
+    check.push([moment(abyss1Start), moment(abyss1End)])
+    check.push([moment(abyss2Start), moment(abyss2End)])
+    check.push([moment(abyss3Start), moment(abyss3End)])
+    check.push([moment(abyss4Start), moment(abyss4End)])
+
+    let ret = []
+    lodash.forEach(check, (ds) => {
+      let [s2, e2] = ds
+      if ((s2 <= s1 && s1 <= e2) || (s2 <= e1 && e1 <= e2)) {
+        ret.push(ds)
+      }
+    })
+    return ret
+  },
+
+  getList (ds, target, { startTime, endTime, totalRange, now, timeMap = {} }) {
+    let type = 'activity'
+    let id = ds.ann_id
+    let title = ds.title
+    let subTitle = ds.subtitle
+    let banner = ds.banner
+    let extra = { sort: 5 }
+    let detail = timeMap[id] || {}
+
+    if (ignoreIds.includes(id) || ignoreReg.test(title)) {
+      return true
+    }
+
+    if (/流光定影/.test(title)) {
+      type = 'weapon'
+      title = title.replace(/(限定5星光锥)/g, '')
+      extra.sort = 2
+    } else if (/跃迁/.test(subTitle)) {
+      type = 'character'
+      let regRet = /角色「(.*)(（|\()/.exec(title)
+      if (regRet[1]) {
+        let char = Character.get(regRet[1])
+        extra.banner2 = char.getImgs()?.card
+        extra.face = char.face
+        extra.character = regRet[1]
+        extra.elem = char.elem
+        extra.sort = 1
+      }
+    } else if (/无名勋礼/.test(title)) {
+      type = 'pass'
+    }
+
+    let getDate = (d1, d2) => moment(d1 && d1.length > 6 ? d1 : d2)
+    let sDate = getDate(detail.start, ds.start_time)
+    let eDate = getDate(detail.end, ds.end_time)
+    let sTime = moment.max(sDate, startTime)
+    let eTime = moment.min(eDate, endTime)
+
+    let sRange = sTime - startTime
+    let eRange = eTime - startTime
+
+    let left = sRange / totalRange * 100
+    let width = eRange / totalRange * 100 - left
+
+    let label = ''
+    if (eDate - sDate > 365 * 24 * 3600 * 1000) {
+      if (sDate < now) {
+        label = sDate.format('MM-DD HH:mm') + ' 后永久有效'
+      } else {
+        label = '永久有效'
+      }
+    } else if (now > sDate && eDate > now) {
+      label = eDate.format('MM-DD HH:mm') + ' (' + moment.duration(eDate - now).humanize() + '后结束)'
+      if (width > 38) {
+        label = sDate.format('MM-DD HH:mm') + ' ~ ' + label
+      }
+    } else if (sDate > now) {
+      label = sDate.format('MM-DD HH:mm') + ' (' + moment.duration(sDate - now).humanize() + '后开始)'
+    } else {
+      label = sDate.format('MM-DD HH:mm') + ' ~ ' + eDate.format('MM-DD HH:mm')
+    }
+    if (sDate <= endTime && eDate >= startTime) {
+      target.push({
+        ...extra,
+        id,
+        title,
+        type,
+        mergeStatus: ['activity'].includes(type) ? 1 : 0,
+        banner,
+        icon: ds.tag_icon,
+        left,
+        width,
+        label,
+        duration: eTime - sTime,
+        start: sDate.format('MM-DD HH:mm'),
+        end: eDate.format('MM-DD HH:mm')
+      })
+    }
+  },
+
+  async get () {
+    moment.locale('zh-cn')
+    let now = moment()
+
+    let { listData, timeMap } = await CalSr.reqCalData()
+    let dateList = Calendar.getDateList()
+
+    let resultList = []
+    let abyss = []
+
+    lodash.forEach(listData.data.list[0].list, (ds) => CalSr.getList(ds, resultList, { ...dateList, now, timeMap }))
+    lodash.forEach(listData.data.pic_list[0].type_list[0].list, (ds) => CalSr.getList(ds, resultList, { ...dateList, now, timeMap }))
+
+    let versionStartTime
+    lodash.forEach(listData.data.list[0].list, (ds) => {
+      if (/版本更新(概览|说明)/.test(ds.title)) {
+        versionStartTime = ds.start_time
+      }
+    })
+
+    let abyssCal = CalSr.getAbyssCal(dateList.startTime, dateList.endTime, versionStartTime)
+    lodash.forEach(abyssCal, (t) => {
+      CalSr.getList({
+        title: '「混沌回忆」',
+        start_time: t[0].format('YYYY-MM-DD HH:mm'),
+        end_time: t[1].format('YYYY-MM-DD HH:mm')
+      }, abyss, { ...dateList, now })
+    })
+
+    resultList = lodash.sortBy(resultList, ['sort', 'start', 'duration'])
+
+    let charCount = 0
+    let charOld = 0
+    let weaponCount = 0
+    let ret = []
+    lodash.forEach(resultList, (li) => {
+      if (li.type === 'character') {
+        charCount++
+        li.left === 0 && charOld++
+        li.idx = charCount
+      }
+      if (li.type === 'weapon') {
+        weaponCount++
+        li.idx = weaponCount
+      }
+      if (li.mergeStatus === 1) {
+        lodash.forEach(resultList, (li2) => {
+          if (li2.mergeStatus === 1 && li.left + li.width <= li2.left) {
+            li.mergeStatus = 2
+            li2.mergeStatus = 2
+            ret.push([li, li2])
+            return false
+          }
+        })
+      }
+      if (li.mergeStatus !== 2) {
+        li.mergeStatus = 2
+        ret.push([li])
+      }
+    })
+
+    return {
+      game: 'sr',
+      ...dateList,
+      list: ret,
+      abyss,
+      charMode: `char-${charCount}-${charOld}`,
+      nowTime: now.format('YYYY-MM-DD HH:mm'),
+      nowDate: now.date()
+    }
+  },
+
+  async render (e) {
+    let calData = await CalSr.get()
+    let mode = 'calendar'
+    if (/(日历列表|活动)$/.test(e.msg)) {
+      mode = 'list'
+    }
+
+    return await Common.render('wiki/calendar', {
+      ...calData,
+      displayMode: mode
+    }, { e, scale: 1.1 })
+  }
+}
+
+export default CalSr

Yunzai/plugins/miao-plugin/apps/wiki/CharMaterial.js

@@ -0,0 +1,18 @@
+import { Common } from '#miao'
+
+const CharMaterial = {
+  async render ({ e, char }) {
+    let data = char.getData()
+    return await Common.render('wiki/character-material', {
+      // saveId: `info-${char.id}`,
+      data,
+      attr: char.getAttrList(),
+      detail: char.getDetail(),
+      imgs: char.getImgs(),
+      materials: char.getMaterials(),
+      elem: char.elem
+    }, { e, scale: 1.4 })
+  }
+}
+
+export default CharMaterial

Yunzai/plugins/miao-plugin/apps/wiki/CharTalent.js

@@ -0,0 +1,114 @@
+import lodash from 'lodash'
+import { Common, Format } from '#miao'
+
+const CharTalent = {
+  async render (e, mode, char) {
+    let lvs = []
+    for (let i = 1; i <= 15; i++) {
+      lvs.push('Lv' + i)
+    }
+    let detail = lodash.extend({}, char.getDetail())
+    if (char.game === 'sr') {
+      lodash.forEach(['cons', 'talent', 'treeData'], (key) => {
+        lodash.forEach(detail[key], (ds, idx) => {
+          if (ds.desc) {
+            if (key === 'talent' && ds.desc.split) {
+              let desc = CharTalent.getDesc(ds.desc, ds.tables, idx === 'a' || idx === 'a2' ? 5 : 8)
+              ds.desc = desc.desc
+              ds.tables = desc.tables
+            } else if (ds.desc.split) {
+              ds.desc = ds.desc.split('<br>')
+            }
+          }
+        })
+      })
+    }
+    return await Common.render('wiki/character-talent', {
+      saveId: `${mode}-${char.id}`,
+      ...char.getData(),
+      game: char.game,
+      detail: char.getDetail(),
+      imgs: char.getImgs(),
+      mode,
+      lvs,
+      line: CharTalent.getLineData(char)
+    }, { e, scale: 1.1 })
+  },
+  getLineData (char) {
+    let ret = []
+    if (char.isSr) {
+      lodash.forEach({ hp: '基础生命', atk: '基础攻击', def: '基础防御', speed: '速度' }, (label, key) => {
+        ret.push({
+          num: Format.comma(char.getDetail().baseAttr[key], 1),
+          label
+        })
+      })
+      return ret
+    }
+    const attrMap = {
+      atkPct: '大攻击',
+      hpPct: '大生命',
+      defPct: '大防御',
+      cpct: '暴击',
+      cdmg: '爆伤',
+      recharge: '充能',
+      mastery: '精通',
+      heal: '治疗',
+      dmg: char.elemName + '伤',
+      phy: '物伤'
+    }
+    lodash.forEach({ hp: '基础生命', atk: '基础攻击', def: '基础防御' }, (label, key) => {
+      ret.push({
+        num: Format.comma(char.baseAttr[key], 1),
+        label
+      })
+    })
+    let ga = char.growAttr
+    ret.push({
+      num: ga.key === 'mastery' ? Format.comma(ga.value, 1) : ga.value,
+      label: `成长·${attrMap[ga.key]}`
+    })
+    return ret
+  },
+  // 获取精炼描述
+  getDesc (desc, tables, lv = 5) {
+    let reg = /\$(\d)\[[i|f1]\](\%?)/g
+    let ret
+
+    let idxFormat = {}
+    while ((ret = reg.exec(desc)) !== null) {
+      let idx = ret[1]
+      let pct = ret[2]
+      let value = tables?.[idx]?.values[lv - 1]
+      if (value) {
+        if (pct === '%') {
+          idxFormat[idx] = 'percent'
+          value = Format.percent(value)
+        } else {
+          idxFormat[idx] = 'comma'
+          value = Format.comma(value)
+        }
+        value = value + ` (lv${lv})`
+        desc = desc.replaceAll(ret[0], value)
+      }
+    }
+    let tableRet = []
+    lodash.forEach(tables, (ds, idx) => {
+      let values = []
+      lodash.forEach(ds.values, (v) => {
+        values.push(Format[idxFormat[idx] || 'comma'](v))
+      })
+      tableRet.push({
+        name: ds.name,
+        isSame: ds.isSame,
+        values
+      })
+    })
+    return {
+      desc: desc.split('<br>'),
+      tables: tableRet
+    }
+  }
+}
+
+export default CharTalent

Yunzai/plugins/miao-plugin/apps/wiki/CharWiki.js

@@ -0,0 +1,105 @@
+import lodash from 'lodash'
+import CharTalent from './CharTalent.js'
+import CharWikiData from './CharWikiData.js'
+import CharMaterial from './CharMaterial.js'
+import { Cfg, Common } from '#miao'
+import { Character } from '#miao.models'
+
+const wikiReg = /^(?:#|喵喵)?(.*)(天赋|技能|命座|命之座|资料|图鉴|照片|写真|图片|图像)$/
+
+const CharWiki = {
+  check (e) {
+    let msg = e.original_msg || e.msg
+    if (!e.msg) {
+      return false
+    }
+    let ret = wikiReg.exec(msg)
+    if (!ret || !ret[1] || !ret[2]) {
+      return false
+    }
+    let mode = 'talent'
+    if (/命/.test(ret[2])) {
+      mode = 'cons'
+    } else if (/(图鉴|资料)/.test(ret[2])) {
+      mode = 'wiki'
+      if (!Common.cfg('charWiki')) {
+        return false
+      }
+    } else if (/图|画|写真|照片/.test(ret[2])) {
+      mode = 'pic'
+      if (!Common.cfg('charPic')) {
+        return false
+      }
+    } else if (/(材料|养成|成长)/.test(ret[2])) {
+      mode = 'material'
+    }
+    if (['cons', 'talent'].includes(mode) && !Common.cfg('charWikiTalent')) {
+      return false
+    }
+    let char = Character.get(ret[1])
+    if (!char || (char.isCustom && mode !== 'pic')) {
+      return false
+    }
+    e.wikiMode = mode
+    e.msg = '#喵喵WIKI'
+    e.char = char
+    return true
+  },
+
+  async wiki (e) {
+    let mode = e.wikiMode
+    let char = e.char
+
+    if (mode === 'pic') {
+      let img = char.getCardImg(Cfg.get('charPicSe', false), false)
+      if (img && img.img) {
+        e.reply(segment.image(`file://${process.cwd()}/plugins/miao-plugin/resources/${img.img}`))
+      } else {
+        e.reply('暂无图片')
+      }
+      return true
+    }
+    if (char.isCustom) {
+      if (mode === 'wiki') {
+        return false
+      }
+      e.reply('暂不支持自定义角色')
+      return true
+    }
+    if (!char.isRelease && Cfg.get('notReleasedData') === false) {
+      e.reply('未实装角色资料已禁用...')
+      return true
+    }
+
+    if (mode === 'wiki') {
+      if (char.source === 'amber') {
+        e.reply('暂不支持该角色图鉴展示')
+        return true
+      }
+      return await CharWiki.render({ e, char })
+    } else if (mode === 'material') {
+      return CharMaterial.render({ e, char })
+    }
+    return await CharTalent.render(e, mode, char)
+  },
+
+  async render ({ e, char }) {
+    let data = char.getData()
+    lodash.extend(data, char.getData('weaponTypeName,elemName'))
+    // 命座持有
+    let holding = await CharWikiData.getHolding(char.id)
+    let usage = await CharWikiData.getUsage(char.id)
+    return await Common.render('wiki/character-wiki', {
+      data,
+      attr: char.getAttrList(),
+      detail: char.getDetail(),
+      imgs: char.getImgs(),
+      holding,
+      usage,
+      materials: char.getMaterials(),
+      elem: char.elem
+    }, { e, scale: 1.4 })
+  }
+}
+
+export default CharWiki

Yunzai/plugins/miao-plugin/apps/wiki/CharWikiData.js

@@ -0,0 +1,108 @@
+import HutaoApi from '../stat/HutaoApi.js'
+import lodash from 'lodash'
+import { Format } from '#miao'
+import { ArtifactSet, Weapon } from '#miao.models'
+
+let CharWikiData = {
+  /**
+   * 角色命座持有
+   * @param id
+   * @returns {Promise<{}>}
+   */
+  async getHolding (id) {
+    let consData = (await HutaoApi.getCons()).data || {}
+    consData = lodash.find(consData, (ds) => ds.avatar === id)
+    let holding = {}
+    if (consData) {
+      let { holdingRate, rate } = consData
+      rate = lodash.sortBy(rate, 'id')
+      holding.num = Format.percent(holdingRate)
+      holding.cons = []
+      lodash.forEach(rate, (ds) => {
+        holding.cons.push({
+          cons: ds.id,
+          num: Format.percent(ds.value)
+        })
+      })
+    }
+    return holding
+  },
+
+  /**
+   * 角色武器、圣遗物使用
+   * @param id
+   * @returns {Promise<{}|{artis: *[], weapons: *[]}>}
+   */
+  async getUsage (id) {
+    let ud = (await HutaoApi.getUsage()).data || {}
+    if (!ud[id]) {
+      return {}
+    }
+    ud = ud[id]
+    return {
+      weapons: CharWikiData.getWeaponsData(ud.weapons),
+      artis: CharWikiData.getArtisData(ud.artis)
+    }
+  },
+
+  /**
+   * 武器使用
+   * @param data
+   * @returns {*[]}
+   */
+  getWeaponsData (data = []) {
+    let weapons = []
+
+    lodash.forEach(data, (ds) => {
+      let weapon = Weapon.get(ds.item) || {}
+      weapons.push({
+        ...weapon.getData('name,abbr,img,star'),
+        value: ds.rate
+      })
+    })
+
+    weapons = lodash.sortBy(weapons, 'value')
+    weapons = weapons.reverse()
+    lodash.forEach(weapons, (ds) => {
+      ds.value = Format.percent(ds.value, 1)
+    })
+    return weapons
+  },
+
+  /**
+   * 圣遗物使用
+   * @param data
+   * @returns {*[]}
+   */
+  getArtisData (data = []) {
+    let artis = []
+
+    lodash.forEach(data, (ds) => {
+      let imgs = []
+      let abbrs = []
+      let ss = ds.item.split(',')
+      lodash.forEach(ss, (t) => {
+        t = t.split(':')
+        let artiSet = ArtifactSet.get(t[0])
+        if (artiSet) {
+          imgs.push(artiSet.img)
+          abbrs.push(artiSet.abbr + (ss.length === 1 ? t[1] : ''))
+        }
+      })
+
+      artis.push({
+        imgs,
+        title: abbrs.join('+'),
+        value: ds.rate
+      })
+    })
+
+    artis = lodash.sortBy(artis, 'value')
+    artis = artis.reverse()
+    artis.forEach((ds) => {
+      ds.value = Format.percent(ds.value)
+    })
+    return artis
+  }
+}
+export default CharWikiData

Yunzai/plugins/miao-plugin/components/App.js

@@ -0,0 +1,133 @@
+import lodash from 'lodash'
+import Plugin from './common/Plugin.js'
+import { Version, MiaoError } from '#miao'
+
+class App {
+  constructor (cfg) {
+    this.id = cfg.id
+    this.cfg = cfg
+    this.apps = {}
+  }
+
+  reg (key, fn, cfg = {}) {
+    if (lodash.isPlainObject(key)) {
+      lodash.forEach(key, (cfg, k) => {
+        this.reg(k, cfg.fn, cfg)
+      })
+    } else {
+      this.apps[key] = {
+        fn,
+        ...cfg
+      }
+    }
+  }
+
+  // 获取v3执行方法
+  v3App () {
+    let cfg = this.cfg || {}
+    let rules = []
+    let check = []
+    let event = cfg.event
+    let cls = class extends Plugin {
+      constructor () {
+        super({
+          name: `喵喵:${cfg.name || cfg.id}`,
+          dsc: cfg.desc || cfg.name || '喵喵插件',
+          event: event === 'poke' ? 'notice.*.poke' : 'message',
+          priority: cfg.priority || 50,
+          rule: rules
+        })
+      }
+
+      accept (e) {
+        e.original_msg = e.original_msg || e.msg
+        for (let idx = 0; idx < check.length; idx++) {
+          if (check[idx](e, e.original_msg) === true) {
+            return true
+          }
+        }
+      }
+    }
+
+    for (let key in this.apps) {
+      let app = this.apps[key]
+      key = lodash.camelCase(key)
+      let rule = app.rule || app.reg || 'noCheck'
+      if (event !== 'poke') {
+        if (typeof (rule) === 'string') {
+          if (rule === 'noCheck') {
+            rule = '.*'
+          }
+        } else {
+          rule = lodash.trim(rule.toString(), '/')
+        }
+      } else {
+        rule = '.*'
+      }
+
+      rules.push({
+        reg: rule,
+        fnc: key
+      })
+
+      if (app.check) {
+        check.push(app.check)
+      }
+
+      cls.prototype[key] = async function (e) {
+        e = this.e || e
+        const self_id = e.self_id || e.bot?.uin || Bot.uin
+        if (event === 'poke') {
+          if (e.notice_type === 'group') {
+            if (e.target_id !== self_id && !e.isPoke) {
+              return false
+            }
+            // group状态下，戳一戳的发起人是operator
+            if (e.user_id === self_id) {
+              e.user_id = e.operator_id
+            }
+          }
+          e.isPoke = true
+          // 随便指定一个不太常见的msg以触发msg的正则
+          e.msg = '#poke#'
+        }
+        e.original_msg = e.original_msg || e.msg
+        try {
+          return await app.fn.call(this, e)
+        } catch (err) {
+          if (err?.message && (err instanceof MiaoError)) {
+            // 处理 MiaoError
+            return e.reply(err.message)
+          } else {
+            // 其他错误抛出
+            throw err
+          }
+        }
+      }
+
+      if (app.yzRule && app.yzCheck) {
+        let yzKey = `Yz${key}`
+        let yzRule = lodash.trim(app.yzRule.toString(), '/')
+        rules.push({
+          reg: yzRule,
+          fnc: yzKey
+        })
+        cls.prototype[yzKey] = async function (e) {
+          if (!Version.isMiao && !app.yzCheck()) {
+            return false
+          }
+          e = this.e || e
+          e.original_msg = e.original_msg || e.msg
+          return await app.fn.call(this, e)
+        }
+      }
+    }
+    return cls
+  }
+}
+
+App.init = function (cfg) {
+  return new App(cfg)
+}
+
+export default App

Yunzai/plugins/miao-plugin/components/Cfg.js

@@ -0,0 +1,56 @@
+import fs from 'fs'
+import lodash from 'lodash'
+import cfgData from './cfg/CfgData.js'
+import { Version } from '#miao'
+
+const _path = process.cwd()
+const _cfgPath = `${_path}/plugins/miao-plugin/components/`
+let cfg = {}
+let miaoCfg = {}
+
+
+try {
+  cfg = await cfgData.getCfg()
+  cfgData.saveCfg(cfg)
+  lodash.forEach(cfgData.getCfgSchemaMap(), (cm) => {
+    if (cm.miao) {
+      miaoCfg[cm.cfgKey] = true
+    }
+  })
+} catch (e) {
+  // do nth
+}
+
+let Cfg = {
+  get (rote) {
+    if (Version.isMiao && miaoCfg[rote]) {
+      return true
+    }
+    return lodash.get(cfg, rote)
+  },
+  set (rote, val) {
+    cfg[rote] = val
+    cfgData.saveCfg(cfg)
+  },
+  del (rote) {
+    lodash.set(cfg, rote, undefined)
+    fs.writeFileSync(_cfgPath + 'cfg.json', JSON.stringify(cfg, null, '\t'))
+  },
+  getCfg () {
+    return cfg
+  },
+  getCfgSchema () {
+    return cfgData.getCfgSchema()
+  },
+  getCfgSchemaMap () {
+    return cfgData.getCfgSchemaMap()
+  },
+  scale (pct = 1) {
+    let scale = Cfg.get('renderScale', 100)
+    scale = Math.min(2, Math.max(0.5, scale / 100))
+    pct = pct * scale
+    return `style=transform:scale(${pct})`
+  }
+}
+
+export default Cfg

Yunzai/plugins/miao-plugin/components/Common.js

@@ -0,0 +1,17 @@
+import Cfg from './Cfg.js'
+import Render from './common/Render.js'
+
+const Common = {
+  render: Render.render,
+  cfg: Cfg.get,
+  sleep (ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  },
+
+  async downFile () {
+    console.log('down file')
+  }
+
+}
+
+export default Common

Yunzai/plugins/miao-plugin/components/Data.js

@@ -0,0 +1,292 @@
+import lodash from 'lodash'
+import fs from 'fs'
+
+const _path = process.cwd()
+const getRoot = (root = '') => {
+  if (!root) {
+    root = `${_path}/`
+  } else if (root === 'root' || root === 'yunzai') {
+    root = `${_path}/`
+  } else if (root === 'miao') {
+    root = `${_path}/plugins/miao-plugin/`
+  } else {
+    root = `${_path}/plugins/${root}/`
+  }
+  return root
+}
+
+let Data = {
+
+  getRoot,
+
+  /*
+  * 根据指定的path依次检查与创建目录
+  * */
+  createDir (path = '', root = '', includeFile = false) {
+    root = getRoot(root)
+    let pathList = path.split('/')
+    let nowPath = root
+    pathList.forEach((name, idx) => {
+      name = name.trim()
+      if (!includeFile && idx <= pathList.length - 1) {
+        nowPath += name + '/'
+        if (name) {
+          if (!fs.existsSync(nowPath)) {
+            fs.mkdirSync(nowPath)
+          }
+        }
+      }
+    })
+  },
+
+  /*
+  * 读取json
+  * */
+  readJSON (file = '', root = '') {
+    root = getRoot(root)
+    if (fs.existsSync(`${root}/${file}`)) {
+      try {
+        return JSON.parse(fs.readFileSync(`${root}/${file}`, 'utf8'))
+      } catch (e) {
+        console.log(e)
+      }
+    }
+    return {}
+  },
+
+  /*
+  * 写JSON
+  * */
+  writeJSON (cfg, data, root = '', space = 2) {
+    if (arguments.length > 1) {
+      return Data.writeJSON({
+        name: cfg,
+        data,
+        space,
+        root
+      })
+    }
+    // 检查并创建目录
+    let name = cfg.path ? (cfg.path + '/' + cfg.name) : cfg.name
+    Data.createDir(name, cfg.root, true)
+    root = getRoot(cfg.root)
+    data = cfg.data
+    delete data._res
+    data = JSON.stringify(data, null, cfg.space || 2)
+    if (cfg.rn) {
+      data = data.replaceAll('\n', '\r\n')
+    }
+    return fs.writeFileSync(`${root}/${name}`, data)
+  },
+
+  delFile (file, root = '') {
+    root = getRoot(root)
+    try {
+      if (fs.existsSync(`${root}/${file}`)) {
+        fs.unlinkSync(`${root}/${file}`)
+      }
+      return true
+    } catch (error) {
+      logger.error(`文件删除失败：${error}`)
+    }
+    return false
+  },
+
+  async getCacheJSON (key) {
+    try {
+      let txt = await redis.get(key)
+      if (txt) {
+        return JSON.parse(txt)
+      }
+    } catch (e) {
+      console.log(e)
+    }
+    return {}
+  },
+
+  async setCacheJSON (key, data, EX = 3600 * 24 * 90) {
+    await redis.set(key, JSON.stringify(data), { EX })
+  },
+
+  async redisGet (key, def = {}) {
+    try {
+      let txt = await redis.get(key)
+      if (txt) {
+        return JSON.parse(txt)
+      }
+    } catch (e) {
+      console.log(e)
+    }
+    return def
+  },
+
+  async redisSet (key, data, EX = 3600 * 24 * 90) {
+    await redis.set(key, JSON.stringify(data), { EX })
+  },
+
+  async importModule (file, root = '') {
+    root = getRoot(root)
+    if (!/\.js$/.test(file)) {
+      file = file + '.js'
+    }
+    if (fs.existsSync(`${root}/${file}`)) {
+      try {
+        let data = await import(`file://${root}/${file}?t=${new Date() * 1}`)
+        return data || {}
+      } catch (e) {
+        console.log(e)
+      }
+    }
+    return {}
+  },
+
+  async importDefault (file, root) {
+    let ret = await Data.importModule(file, root)
+    return ret.default || {}
+  },
+
+  async importCfg (key) {
+    let sysCfg = await Data.importModule(`config/system/${key}_system.js`, 'miao')
+    let diyCfg = await Data.importModule(`config/${key}.js`, 'miao')
+    if (diyCfg.isSys) {
+      console.error(`miao-plugin: config/${key}.js无效，已忽略`)
+      console.error(`如需配置请复制config/${key}_default.js为config/${key}.js，请勿复制config/system下的系统文件`)
+      diyCfg = {}
+    }
+    return {
+      sysCfg,
+      diyCfg
+    }
+  },
+
+  /*
+  * 返回一个从 target 中选中的属性的对象
+  *
+  * keyList : 获取字段列表，逗号分割字符串
+  *   key1, key2, toKey1:fromKey1, toKey2:fromObj.key
+  *
+  * defaultData: 当某个字段为空时会选取defaultData的对应内容
+  * toKeyPrefix：返回数据的字段前缀，默认为空。defaultData中的键值无需包含toKeyPrefix
+  *
+  * */
+
+  getData (target, keyList = '', cfg = {}) {
+    target = target || {}
+    let defaultData = cfg.defaultData || {}
+    let ret = {}
+    // 分割逗号
+    if (typeof (keyList) === 'string') {
+      keyList = keyList.split(',')
+    }
+
+    lodash.forEach(keyList, (keyCfg) => {
+      // 处理通过:指定 toKey & fromKey
+      let _keyCfg = keyCfg.split(':')
+      let keyTo = _keyCfg[0].trim()
+      let keyFrom = (_keyCfg[1] || _keyCfg[0]).trim()
+      let keyRet = keyTo
+      if (cfg.lowerFirstKey) {
+        keyRet = lodash.lowerFirst(keyRet)
+      }
+      if (cfg.keyPrefix) {
+        keyRet = cfg.keyPrefix + keyRet
+      }
+      // 通过Data.getVal获取数据
+      ret[keyRet] = Data.getVal(target, keyFrom, defaultData[keyTo], cfg)
+    })
+    return ret
+  },
+
+  getVal (target, keyFrom, defaultValue) {
+    return lodash.get(target, keyFrom, defaultValue)
+  },
+
+  // 异步池，聚合请求
+  async asyncPool (poolLimit, array, iteratorFn) {
+    const ret = [] // 存储所有的异步任务
+    const executing = [] // 存储正在执行的异步任务
+    for (const item of array) {
+      // 调用iteratorFn函数创建异步任务
+      const p = Promise.resolve().then(() => iteratorFn(item, array))
+      // 保存新的异步任务
+      ret.push(p)
+
+      // 当poolLimit值小于或等于总任务个数时，进行并发控制
+      if (poolLimit <= array.length) {
+        // 当任务完成后，从正在执行的任务数组中移除已完成的任务
+        const e = p.then(() => executing.splice(executing.indexOf(e), 1))
+        executing.push(e) // 保存正在执行的异步任务
+        if (executing.length >= poolLimit) {
+          // 等待较快的任务执行完成
+          await Promise.race(executing)
+        }
+      }
+    }
+    return Promise.all(ret)
+  },
+
+  // sleep
+  sleep (ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  },
+
+  // 获取默认值
+  def () {
+    for (let idx in arguments) {
+      if (!lodash.isUndefined(arguments[idx])) {
+        return arguments[idx]
+      }
+    }
+  },
+
+  async forEach (data, fn) {
+    if (lodash.isArray(data)) {
+      for (let idx = 0; idx < data.length; idx++) {
+        let ret = fn(data[idx], idx)
+        if (ret instanceof Promise) {
+          ret = await ret
+        }
+        if (ret === false) {
+          break
+        }
+      }
+    } else if (lodash.isPlainObject(data)) {
+      for (const idx in data) {
+        let ret = fn(data[idx], idx)
+        if (ret instanceof Promise) {
+          ret = await ret
+        }
+        if (ret === false) {
+          break
+        }
+      }
+    }
+  },
+
+  // 循环字符串回调
+  eachStr: (arr, fn) => {
+    if (lodash.isString(arr)) {
+      arr = arr.replace(/\s*(;|；|、|，)\s*/, ',')
+      arr = arr.split(',')
+    } else if (lodash.isNumber(arr)) {
+      arr = [arr.toString()]
+    }
+    lodash.forEach(arr, (str, idx) => {
+      if (!lodash.isUndefined(str)) {
+        fn(str.trim ? str.trim() : str, idx)
+      }
+    })
+  },
+
+  regRet (reg, txt, idx) {
+    if (reg && txt) {
+      let ret = reg.exec(txt)
+      if (ret && ret[idx]) {
+        return ret[idx]
+      }
+    }
+    return false
+  }
+}
+
+export default Data

Yunzai/plugins/miao-plugin/components/Format.js

@@ -0,0 +1,25 @@
+import lodash from 'lodash'
+import Elem from './common/Elem.js'
+import { Cfg } from '#miao'
+
+let Format = {
+  ...Elem,
+  int: function (d) {
+    return parseInt(d)
+  },
+  comma: function (num, fix = 0) {
+    num = parseFloat((num * 1).toFixed(fix))
+    let [integer, decimal] = String.prototype.split.call(num, '.')
+    let re = new RegExp(`\\d(?=(\\d{${Cfg.get('commaGroup', 3)}})+$)`, 'g')
+    integer = integer.replace(re, '$&,') // 正则先行断言 = /\d(?=(\d{3})+$)/g
+    return `${integer}${fix > 0 ? '.' + (decimal || lodash.repeat('0', fix)) : ''}`
+  },
+  pct: function (num, fix = 1) {
+    return (num * 1).toFixed(fix) + '%'
+  },
+  percent: function (num, fix = 1) {
+    return Format.pct(num * 100, fix)
+  }
+}
+
+export default Format

Yunzai/plugins/miao-plugin/components/MiaoError.js

@@ -0,0 +1,17 @@
+export default class MiaoError extends Error {
+
+  constructor(message) {
+    // 允许返回特殊消息，需传递数组，例如 [segment.image()]
+    if (Array.isArray(message)) {
+      super()
+      this._message = message
+    } else {
+      super(message);
+    }
+  }
+
+  get message() {
+    return this._message ? this._message : super.message;
+  }
+
+}

Yunzai/plugins/miao-plugin/components/Version.js

@@ -0,0 +1,109 @@
+import fs from 'fs'
+import lodash from 'lodash'
+import { Data } from '#miao'
+
+let packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'))
+
+const getLine = function (line) {
+  line = line.replace(/(^\s*\*|\r)/g, '')
+  line = line.replace(/\s*`([^`]+`)/g, '<span class="cmd">$1')
+  line = line.replace(/`\s*/g, '</span>')
+  line = line.replace(/\s*\*\*([^\*]+\*\*)/g, '<span class="strong">$1')
+  line = line.replace(/\*\*\s*/g, '</span>')
+  line = line.replace(/ⁿᵉʷ/g, '<span class="new"></span>')
+  return line
+}
+
+const readLogFile = function (root, versionCount = 4) {
+  root = Data.getRoot(root)
+  let logPath = `${root}/CHANGELOG.md`
+  let logs = {}
+  let changelogs = []
+  let currentVersion
+
+  try {
+    if (fs.existsSync(logPath)) {
+      logs = fs.readFileSync(logPath, 'utf8') || ''
+      logs = logs.split('\n')
+
+      let temp = {}
+      let lastLine = {}
+      lodash.forEach(logs, (line) => {
+        if (versionCount <= -1) {
+          return false
+        }
+        let versionRet = /^#\s*([0-9a-zA-Z\\.~\s]+?)\s*$/.exec(line)
+        if (versionRet && versionRet[1]) {
+          let v = versionRet[1].trim()
+          if (!currentVersion) {
+            currentVersion = v
+          } else {
+            changelogs.push(temp)
+            if (/0\s*$/.test(v) && versionCount > 0) {
+              versionCount = 0
+            } else {
+              versionCount--
+            }
+          }
+
+          temp = {
+            version: v,
+            logs: []
+          }
+        } else {
+          if (!line.trim()) {
+            return
+          }
+          if (/^\*/.test(line)) {
+            lastLine = {
+              title: getLine(line),
+              logs: []
+            }
+            temp.logs.push(lastLine)
+          } else if (/^\s{2,}\*/.test(line)) {
+            lastLine.logs.push(getLine(line))
+          }
+        }
+      })
+    }
+  } catch (e) {
+    // do nth
+  }
+  return { changelogs, currentVersion }
+}
+
+const { changelogs, currentVersion } = readLogFile('miao')
+
+
+const yunzaiVersion = packageJson.version
+const isV3 = yunzaiVersion[0] === '3'
+let isMiao = false
+let name = "Yunzai-Bot"
+if (packageJson.name === 'miao-yunzai') {
+  isMiao = true
+  name = "Miao-Yunzai"
+} else if (packageJson.name === 'trss-yunzai') {
+  isMiao = true
+  name = "TRSS-Yunzai"
+}
+
+let Version = {
+  isV3,
+  isMiao,
+  name,
+  get version () {
+    return currentVersion
+  },
+  get yunzai () {
+    return yunzaiVersion
+  },
+  get changelogs () {
+    return changelogs
+  },
+  runtime () {
+    console.log(`未能找到e.runtime，请升级至最新版${isV3 ? 'V3' : 'V2'}-Yunzai以使用miao-plugin`)
+  },
+  readLogFile
+}
+
+export default Version

Yunzai/plugins/miao-plugin/components/cfg/CfgData.js

@@ -0,0 +1,47 @@
+import { cfgSchema } from '../../config/system/cfg_system.js'
+import lodash from 'lodash'
+import { Data } from '../index.js'
+import fs from 'node:fs'
+
+let cfgData = {
+  saveCfg (cfg) {
+    let ret = []
+    lodash.forEach(cfgSchema, (cfgGroup) => {
+      ret.push(`/** ************ 【${cfgGroup.title}】 ************* */`)
+      lodash.forEach(cfgGroup.cfg, (cfgItem, cfgKey) => {
+        ret.push(`// ${cfgItem.desc || cfgItem.title}`)
+        let val = Data.def(cfg[cfgKey], cfgItem.def)
+        if (cfgItem.input) {
+          val = cfgItem.input(val)
+        }
+        ret.push(`export const ${cfgKey} = ${val.toString()}`, '')
+      })
+    })
+    fs.writeFileSync(`${process.cwd()}/plugins/miao-plugin/config/cfg.js`, ret.join('\n'), 'utf8')
+  },
+
+  async getCfg () {
+    let ret = lodash.toPlainObject(await Data.importModule('/config/cfg.js', 'miao'))
+    lodash.forEach(cfgSchema, (cfgGroup) => {
+      lodash.forEach(cfgGroup.cfg, (cfgItem, cfgKey) => {
+        ret[cfgKey] = Data.def(ret[cfgKey], cfgItem.def)
+      })
+    })
+    return ret
+  },
+
+  getCfgSchemaMap () {
+    let ret = {}
+    lodash.forEach(cfgSchema, (cfgGroup) => {
+      lodash.forEach(cfgGroup.cfg, (cfgItem, cfgKey) => {
+        ret[cfgItem.key] = cfgItem
+        cfgItem.cfgKey = cfgKey
+      })
+    })
+    return ret
+  },
+  getCfgSchema () {
+    return cfgSchema
+  }
+}
+export default cfgData

Yunzai/plugins/miao-plugin/components/common/Elem.js

@@ -0,0 +1,86 @@
+import { Data } from '../index.js'
+import lodash from 'lodash'
+
+const elemAlias = {
+  anemo: '风,蒙德',
+  geo: '岩,璃月',
+  electro: '雷,电,雷电,稻妻',
+  dendro: '草,须弥',
+  pyro: '火,纳塔',
+  hydro: '水,枫丹',
+  cryo: '冰,至冬'
+}
+
+const elemAliasSR = {
+  fire: '火',
+  ice: '冰',
+  wind: '风',
+  elec: '雷',
+  phy: '物理',
+  quantum: '量子',
+  imaginary: '虚数'
+}
+
+// 元素属性映射, 名称=>elem
+let elemMap = {}
+let elemMapSR = {}
+
+// 标准元素名
+let elemTitleMap = {}
+let elemTitleMapSR = elemAliasSR
+
+lodash.forEach(elemAlias, (txt, key) => {
+  elemMap[key] = key
+  elemTitleMap[key] = txt[0]
+  Data.eachStr(txt, (t) => (elemMap[t] = key))
+})
+lodash.forEach(elemAliasSR, (txt, key) => {
+  elemMapSR[key] = key
+  elemMapSR[txt] = key
+})
+
+const Elem = {
+  // 根据名称获取元素key
+  elem (elem = '', defElem = '', game = 'gs') {
+    elem = elem.toLowerCase()
+    return (game === 'gs' ? elemMap : elemMapSR)[elem] || defElem
+  },
+
+  // 根据key获取元素名
+  elemName (elem = '', defName = '') {
+    return elemTitleMap[Elem.elem(elem)] || defName
+  },
+
+  // 从字符串中匹配元素
+  matchElem (name = '', defElem = '', withName = false) {
+    const elemReg = new RegExp(`^(${lodash.keys(elemMap).join('|')})`)
+    let elemRet = elemReg.exec(name)
+    let elem = (elemRet && elemRet[1]) ? Elem.elem(elemRet[1]) : defElem
+    if (elem) {
+      if (withName) {
+        return {
+          elem,
+          name: name.replace(elemReg, '')
+        }
+      }
+      return elem
+    }
+    return ''
+  },
+
+  eachElem (fn, game = 'gs') {
+    lodash.forEach(game === 'gs' ? elemTitleMap : elemTitleMapSR, (title, key) => {
+      fn(key, title)
+    })
+  },
+
+  isElem (elem = '', game = 'gs') {
+    return !!(game === 'gs' ? elemMap : elemMapSR)[elem]
+  },
+
+  sameElem (key1, key2, game = 'gs') {
+    let map = (game === 'gs' ? elemMap : elemMapSR)
+    return map[key1] === map[key2]
+  }
+}
+export default Elem

Yunzai/plugins/miao-plugin/components/common/Plugin.js

@@ -0,0 +1,103 @@
+/*
+* V3版Yunzai plugin
+* */
+let stateArr = {}
+
+export default class plugin {
+  /**
+   * @param name 插件名称
+   * @param dsc 插件描述
+   * @param event 执行事件，默认message
+   * @param priority 优先级，数字越小优先级越高
+   * @param rule.reg 命令正则
+   * @param rule.fnc 命令执行方法
+   * @param rule.event 执行事件，默认message
+   * @param rule.log  false时不显示执行日志
+   * @param rule.permission 权限 master,owner,admin,all
+   * @param task.name 定时任务名称
+   * @param task.cron 定时任务cron表达式
+   * @param task.fnc 定时任务方法名
+   * @param task.log  false时不显示执行日志
+   */
+  constructor (data) {
+    /** 插件名称 */
+    this.name = data.name
+    /** 插件描述 */
+    this.dsc = data.dsc
+    /** 监听事件，默认message https://oicqjs.github.io/oicq/#events */
+    this.event = data.event || 'message'
+    /** 优先级 */
+    this.priority = data.priority || 5000
+    /** 定时任务，可以是数组 */
+    this.task = {
+      /** 任务名 */
+      name: '',
+      /** 任务方法名 */
+      fnc: data.task?.fnc || '',
+      /** 任务cron表达式 */
+      cron: data.task?.cron || ''
+    }
+
+    /** 命令规则 */
+    this.rule = data.rule || []
+  }
+
+  /**
+   * @param msg 发送的消息
+   * @param quote 是否引用回复
+   * @param data.recallMsg 群聊是否撤回消息，0-120秒，0不撤回
+   * @param data.at 是否at用户
+   */
+  reply (msg = '', quote = false, data = {}) {
+    if (!this.e.reply || !msg) return false
+    return this.e.reply(msg, quote, data)
+  }
+
+  conKey (isGroup = false) {
+    if (isGroup) {
+      return `${this.name}.${this.e.group_id}`
+    } else {
+      return `${this.name}.${this.userId || this.e.user_id}`
+    }
+  }
+
+  /**
+   * @param type 执行方法
+   * @param isGroup 是否群聊
+   * @param time 操作时间，默认120秒
+   */
+  setContext (type, isGroup = false, time = 120) {
+    let key = this.conKey(isGroup)
+    if (!stateArr[key]) stateArr[key] = {}
+    stateArr[key][type] = this.e
+    if (time) {
+      /** 操作时间 */
+      setTimeout(() => {
+        if (stateArr[key][type]) {
+          delete stateArr[key][type]
+          this.e.reply('操作超时已取消', true)
+        }
+      }, time * 1000)
+    }
+  }
+
+  getContext () {
+    let key = this.conKey()
+    return stateArr[key]
+  }
+
+  getContextGroup () {
+    let key = this.conKey(true)
+    return stateArr[key]
+  }
+
+  /**
+   * @param type 执行方法
+   * @param isGroup 是否群聊
+   */
+  finish (type, isGroup = false) {
+    if (stateArr[this.conKey(isGroup)] && stateArr[this.conKey(isGroup)][type]) {
+      delete stateArr[this.conKey(isGroup)][type]
+    }
+  }
+}