Delete Yunzai/plugins/miao-plugin

Yunzai/plugins/miao-plugin/.gitignore

@@ -1,20 +0,0 @@
-*.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

@@ -1,377 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-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

@@ -1,106 +0,0 @@
-# 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

@@ -1,204 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,188 +0,0 @@
-// #老婆
-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

@@ -1,258 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,444 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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

@@ -1,96 +0,0 @@
-/*
-* 角色圣遗物评分详情
-*
-* */
-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

@@ -1,299 +0,0 @@
-/**
- * 面板数据替换相关逻辑
- */
-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

@@ -1,77 +0,0 @@
-/*
-* 面板公共方法及处理
-* */
-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

@@ -1,299 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,280 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,37 +0,0 @@
-/*
-* 胡桃数据库的统计
-*
-* */
-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

@@ -1,164 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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

@@ -1,73 +0,0 @@
-/*
-* 胡桃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

@@ -1,29 +0,0 @@
-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

@@ -1,414 +0,0 @@
-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

@@ -1,303 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,292 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,103 +0,0 @@
-/*
-* 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]
-    }
-  }
-}

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

@@ -1,42 +0,0 @@
-import { Version, Cfg } from '#miao'
-
-const Render = {
-  async render (path, params, cfg) {
-    let { e } = cfg
-    if (!e.runtime) {
-      console.log('未找到e.runtime，请升级至最新版Yunzai')
-    }
-    return e.runtime.render('miao-plugin', path, params, {
-      retType: cfg.retMsgId ? 'msgId' : 'default',
-      beforeRender ({ data }) {
-        let pluginName = ''
-        if (data.pluginName !== false) {
-          pluginName = ` & ${data.pluginName || 'Miao-Plugin'}`
-          if (data.pluginVersion !== false) {
-            pluginName += `<span class="version">${data.pluginVersion || Version.version}`
-          }
-        }
-        let resPath = data.pluResPath
-        const layoutPath = process.cwd() + '/plugins/miao-plugin/resources/common/layout/'
-        return {
-          ...data,
-          _res_path: resPath,
-          _miao_path: resPath,
-          _layout_path: layoutPath,
-          _tpl_path: process.cwd() + '/plugins/miao-plugin/resources/common/tpl/',
-          defaultLayout: layoutPath + 'default.html',
-          elemLayout: layoutPath + 'elem.html',
-          sys: {
-            scale: Cfg.scale(cfg.scale || 1)
-          },
-          copyright: `Created By ${Version.name}<span class="version">${Version.yunzai}</span>${pluginName}</span>`,
-          pageGotoParams: {
-            waitUntil: 'networkidle2'
-          }
-        }
-      }
-    })
-  }
-}
-
-export default Render