koishi-plugin-toram 0.6.2-test.4 → 0.6.3

package/lib/data/boss.json

@@ -3428,7 +3428,7 @@
             167,
             "通地塔·关内",
             21073,
-            "无",
+            "光",
             "野王"
         ],
         [

package/lib/data/dishes.json

@@ -301,7 +301,7 @@
             37,
             "白山长下",
             "鲑鱼饭团",
-            9,
+            10,
             "灵巧"
         ],
         [
@@ -362,8 +362,8 @@
         ],
         [
             46,
-            "为君故",
-            "鲑鱼饭团",
+            "暂无",
+            "暂无",
             7,
             "灵巧"
         ],
@@ -742,7 +742,7 @@
             100,
             "林荏苒",
             "烩炒饭",
-            9,
+            10,
             "魔法值上限"
         ],
         [
@@ -761,8 +761,8 @@
         ],
         [
             103,
-            "光阴荏苒【？】",
-            "烩炒饭",
+            "暂无",
+            "暂无",
             10,
             "魔法值上限"
         ],
@@ -1153,8 +1153,8 @@
         ],
         [
             159,
-            "光阴荏苒【？】",
-            "黄金炒饭",
+            "暂无",
+            "暂无",
             10,
             "体力值上限"
         ],
@@ -2133,8 +2133,8 @@
         ],
         [
             299,
-            "下坠ing",
-            "奶油炖菜",
+            "暂无",
+            "暂无",
             9,
             "仇恨值减少"
         ],
@@ -2434,8 +2434,8 @@
         ],
         [
             342,
-            "沐汐墨染",
-            "日式炒面",
+            "暂无",
+            "暂无",
             10,
             "攻击魔法回复"
         ],
@@ -2541,7 +2541,7 @@
             357,
             "默馨",
             "日式炒面",
-            9,
+            10,
             "攻击魔法回复"
         ],
         [
@@ -2646,7 +2646,7 @@
             372,
             "洛塔罗塔",
             "日式炒面",
-            9,
+            10,
             "攻击魔法回复"
         ],
         [
@@ -2828,7 +2828,7 @@
             398,
             "葛沽",
             "日式炒面",
-            9,
+            10,
             "攻击魔法回复"
         ],
         [
@@ -2840,8 +2840,8 @@
         ],
         [
             400,
-            "沐汐玲蝶",
-            "日式炒面",
+            "暂无",
+            "暂无",
             10,
             "攻击魔法回复"
         ],
@@ -3253,8 +3253,8 @@
         ],
         [
             459,
-            "o艾歌o",
-            "鱼排汉堡",
+            "暂无",
+            "暂无",
             9,
             "魔法抗性"
         ],
@@ -3304,7 +3304,7 @@
             466,
             "秋恬",
             "墨鱼意大利面",
-            6,
+            8,
             "对暗属性伤害"
         ],
         [
@@ -3435,7 +3435,7 @@
         ],
         [
             485,
-            "大剑坦不坦",
+            "没有感情的剑萌新",
             "日式炒面",
             10,
             "攻击魔法回复"
@@ -3593,6 +3593,83 @@
             "鲣鱼饭团",
             10,
             "力量"
+        ],
+        [
+            508,
+            "泠雨潋",
+            "牛肉汉堡",
+            10,
+            "物理抗性"
+        ],
+        [
+            509,
+            "泠雨澜",
+            "烩炒饭",
+            10,
+            "魔法值上限"
+        ],
+        [
+            510,
+            "幽森的黑巫女",
+            "梅干饭团",
+            9,
+            "智力"
+        ],
+        [
+            511,
+            "南海十三郎",
+            "鲣鱼饭团",
+            9,
+            "力量"
+        ],
+        [
+            512,
+            "晦朔之行",
+            "鲑鱼饭团",
+            9,
+            "灵巧"
+        ],
+        [
+            513,
+            "RAS",
+            "烩炒饭",
+            9,
+            "魔法值上限"
+        ],
+        [
+            514,
+            "苍雷破八荒",
+            "鱼排汉堡",
+            9,
+            "魔法抗性"
+        ],
+        [
+            515,
+            "零末",
+            "烩炒饭",
+            9,
+            "魔法值上限"
+        ],
+        [
+            516,
+            "您您您的墨弟",
+            "日式炒饭",
+            10,
+            "攻击魔法回复"
+        ],
+        [
+            517,
+            "阿斯托尔福LV",
+            "鱼排汉堡",
+            9,
+            "魔法抗性"
+        ],
+        [
+            518,
+            "孤狼拉普兰德",
+            "章鱼烧",
+            9,
+            "暴击率"
         ]
     ]
 }

package/lib/data/update.json

@@ -33,33 +33,68 @@
     "rows": [
         [
             1,
-            1689318000000,
-            "7周年活动开启，持续6周至8月25日。"
+            1689325200000,
+            "①7周年活动开启，持续6周至8月25日。②免费洗点活动，持续1周至7月21日。"
         ],
         [
             2,
-            1689922800000,
-            "7周年活动追加特殊竞技场与兑换所，兑换所会在7周年活动结束后转移至夏活地图并额外持续2周至9月8日。"
+            1689930000000,
+            "7周年活动追加特殊竞技场与兑换所。"
         ],
         [
             3,
-            1690527600000,
-            "夏日活动开启，持续6周至9月8日，配方与兑换所额外持续1周至9月15日。"
+            1690534800000,
+            "①夏日活动开启，持续6周至9月8日。②高难讨伐活动结束，配方额外持续2周至8月10日。"
         ],
         [
             4,
-            1691650800000,
-            "夏日活动追加章鱼阿健讨伐。"
+            1691658000000,
+            "①夏日活动追加章鱼阿健讨伐。②调整盛夏贝壳Ⅱ、Ⅲ的掉落率【未确认时间】。③撤除高难讨伐活动的配方。"
         ],
         [
             5,
-            1692342000000,
+            1692349200000,
             "7周年活动追加马奇史东挑战。"
         ],
         [
             6,
-            1692946800000,
-            "新剧情任务\/地图\/配方。"
+            1692954000000,
+            "①新剧情任务\/地图\/配方（12章：相克的龙与龙人）。②七周年活动结束，配方额外持续2周至9月8日，兑换所转移至夏活地图并额外持续2周至9月8日。"
+        ],
+        [
+            7,
+            1694163600000,
+            "①赏月活动开启，持续3周至9月29日。②撤除7周年活动配方与交换所。③夏日活动结束，限定地图、配方与兑换所额外持续1周至9月15日。"
+        ],
+        [
+            8,
+            1694768400000,
+            "①秋季美食活动开启，持续3周至10月6日。②撤除夏日活动限定地图、配方与兑换所。"
+        ],
+        [
+            9,
+            1695373200000,
+            "秋季美食活动追加怪物银色苹果【可能提前至21日】。"
+        ],
+        [
+            10,
+            1695978000000,
+            "赏月活动结束，配方额外持续1周至10月6日。"
+        ],
+        [
+            11,
+            1696582800000,
+            "①新剧情任务\/地图\/配方（12章：带孩子的龙人夫妻），等级上限提升至255。②万圣节活动开启，持续5周至11月10日。③秋季美食活动结束，配方额外持续1周至10月13日。④撤除赏月活动配方。"
+        ],
+        [
+            12,
+            1697187600000,
+            "①史东迪的实验开放210级难度。②撤除秋季美食活动的配方。"
+        ],
+        [
+            13,
+            1697792400000,
+            "万圣节活动追加第7章。"
         ]
     ]
 }

package/lib/index.js

@@ -4,7 +4,7 @@ exports.apply = exports.Config = exports.name = void 0;
 const koishi_1 = require("koishi");
 exports.name = 'toram';
 exports.Config = koishi_1.Schema.object({
-    机器人qq: koishi_1.Schema.string().default('机器人使用的QQ号').description('请在此处填写机器人使用的QQ号'),
+    机器人qq: koishi_1.Schema.string().description('请在此处填写机器人使用的QQ号'),
     版本等级: koishi_1.Schema.number().default(250).description('当前游戏等级版本'),
     升级_定点王数量: koishi_1.Schema.number().default(6).description('使用升级指令时返回的定点王数量'),
     升级_野王数量: koishi_1.Schema.number().default(4).description('使用升级指令时返回的野王数量'),
@@ -85,20 +85,23 @@ async function apply(ctx, config) {
     ];
     // 玩家等级差经验倍率
     const PlayerExpRate = [11, 11, 11, 11, 11, 10, 9, 7, 3];
-    // 玩家料理信息数据库
+    // 数字转化
     const NumberReplace = { '一': '1', '二': '2', '三': '3', '四': '4', '五': '5', '六': '6', '七': '7', '八': '8', '九': '9', '十': '10' };
     // 随手用到的变量
-    var n, x, text;
+    var n, x, y, a, b, c, d, e, f, g, text, aa;
+    var arr1 = [], arr2 = [], arr3 = [];
+    // 附魔无参数或参数不对回复
+    const EnchantReply = '输入"武器附魔 附魔正属 初始潜力(可选)"进行附魔推演，附魔正属间用"/"进行分割，额外输入"-a"表示允许退mp自然恢复。\n如："武器附魔 火属/20%对地/10%ma/20暴伤/25暴击 107潜 -a"\n因为青灯没有搞明白附魔就来乱写，所以魔导书有时候会计算出错，才不是因为魔导书笨蛋哦！';
     // 查不到玩家料理信息回复
     const DishesPlayerNotFind = [
         '魔导书里还没有这个人的料理记录哦？去找青灯让她加一下吧~',
         '如果你确定输入了正确的玩家昵称，那大概是还没有收录这个人的料理吧【缩缩】',
-        '【翻翻】嗯……已查阅507条料理记录，找到符合的记录0条【合上书本】'
+        '【翻翻】嗯……已查阅518条料理记录，找到符合的记录0条【合上书本】'
     ];
     // 查不到某种料理信息回复
     const DishesNotFind = [
         '居然！青灯现在还没发现有人做这个料理！怎么回事呢~',
-        '【翻翻】嗯……已查阅507条料理记录，找到符合的记录0条【合上书本】',
+        '【翻翻】嗯……已查阅518条料理记录，找到符合的记录0条【合上书本】',
         '好像还没有人做这种料理呢……你要不要考虑一下？w'
     ];
     // 查询料理的指定等级参数错误回复
@@ -109,7 +112,7 @@ async function apply(ctx, config) {
     ];
     // 查不到指定等级某种料理信息回复
     const DishesLevelNotFind = [
-        '【翻翻】嗯……已查阅507条料理记录，找到符合的记录0条【合上书本】',
+        '【翻翻】嗯……已查阅518条料理记录，找到符合的记录0条【合上书本】',
         '冷门料理或者等级较低的热门料理是不太会主动收录的哦？想加的话要去找青灯呢~',
         '魔导书还没有记录有这个等级的这种料理呢——'
     ];
@@ -146,6 +149,258 @@ async function apply(ctx, config) {
         '蜂蜜吐司': '光属性抗性', '布丁吐司': '土属性抗性', '香草吐司': '无属性抗性', '香蒜吐司': '暗属性抗性', '鲔鱼吐司': '水属性抗性', '煎蛋吐司': '火属性抗性', '起司吐司': '风属性抗性',
         '奶油培根意大利面': '对光属性伤害', '青酱意大利面': '对地属性伤害', '香蒜辣椒意大利面': '对无属性伤害', '墨鱼意大利面': '对暗属性伤害', '蛤蜊意大利面': '对水属性伤害', '肉酱意大利面': '对火属性伤害', '那不勒斯意大利面': '对风属性伤害'
     };
+    // 能力简称对应能力列表
+    const AbilityType = {
+        's': '力量', 'S': '力量', 'str': '力量', 'STR': '力量', '力': '力量', '力量': '力量',
+        's%': '力量%', 'S%': '力量%', 'str%': '力量%', 'STR%': '力量%', '力%': '力量%', '力量%': '力量%', '%s': '力量%', '%S': '力量%', '%str': '力量%', '%STR': '力量%', '%力': '力量%', '%力量': '力量%',
+        'd': '灵巧', 'D': '灵巧', 'dex': '灵巧', 'DEX': '灵巧', '灵': '灵巧', '灵巧': '灵巧', 'd%': '灵巧%', 'D%': '灵巧%', 'dex%': '灵巧%', 'DEX%': '灵巧%', '灵%': '灵巧%', '灵巧%': '灵巧%',
+        '%d': '灵巧%', '%D': '灵巧%', '%dex': '灵巧%', '%DEX': '灵巧%', '%灵': '灵巧%', '%灵巧': '灵巧%',
+        'i': '智力', 'I': '智力', 'int': '智力', 'INT': '智力', '智': '智力', '智力': '智力', 'i%': '智力%', 'I%': '智力%', 'int%': '智力%', 'INT%': '智力%', '智%': '智力%', '智力%': '智力%',
+        '%i': '智力%', '%I': '智力%', '%int': '智力%', '%INT': '智力%', '%智': '智力%', '%智力': '智力%',
+        'ag': '敏捷', 'AG': '敏捷', 'agi': '敏捷', 'AGI': '敏捷', '敏': '敏捷', '敏捷': '敏捷',
+        'ag%': '敏捷%', 'AG%': '敏捷%', 'agi%': '敏捷%', 'AGI%': '敏捷%', '敏%': '敏捷%', '敏捷%': '敏捷%', '%ag': '敏捷%', '%AG': '敏捷%', '%agi': '敏捷%', '%AGI': '敏捷%', '%敏': '敏捷%', '%敏捷': '敏捷%',
+        'v': '耐力', 'V': '耐力', 'vit': '耐力', 'VIT': '耐力', '耐': '耐力', '耐力': '耐力',
+        'v%': '耐力%', 'V%': '耐力%', 'vit%': '耐力%', 'VIT%': '耐力%', '耐%': '耐力%', '耐力%': '耐力%', '%v': '耐力%', '%V': '耐力%', '%vit': '耐力%', '%VIT': '耐力%', '%耐': '耐力%', '%耐力': '耐力%',
+        'a%': '物理攻击%', 'A%': '物理攻击%', 'atk%': '物理攻击%', 'ATK%': '物理攻击%', '物攻%': '物理攻击%', '物理攻击%': '物理攻击%', '%a': '物理攻击%', '%A': '物理攻击%', '%atk': '物理攻击%', '%ATK': '物理攻击%', '%物攻': '物理攻击%', '%物理攻击': '物理攻击%',
+        'ma%': '魔法攻击%', 'MA%': '魔法攻击%', 'matk%': '魔法攻击%', 'MATK%': '魔法攻击%', '魔攻%': '魔法攻击%', '魔法攻击%': '魔法攻击%', '%ma': '魔法攻击%', '%MA': '魔法攻击%', '%matk': '魔法攻击%', '%MATK': '魔法攻击%', '%魔攻': '魔法攻击%', '%魔法攻击': '魔法攻击%',
+        'cd': '暴击伤害', 'CD': '暴击伤害', '暴伤': '暴击伤害', '暴击伤害': '暴击伤害',
+        'cd%': '暴击伤害%', 'CD%': '暴击伤害%', '暴伤%': '暴击伤害%', '暴击伤害%': '暴击伤害%', '%cd': '暴击伤害%', '%CD': '暴击伤害%', '%暴伤': '暴击伤害%', '%暴击伤害': '暴击伤害%',
+        'c': '暴击率', 'C': '暴击率', 'ctr': '暴击率', 'CTR': '暴击率', '暴击': '暴击率', '暴击率': '暴击率',
+        '对火': '对火属性伤害%', '%对火': '对火属性伤害%', '对火%': '对火属性伤害%', '对水': '对水属性伤害%', '%对水': '对水属性伤害%', '对水%': '对水属性伤害%', '对风': '对风属性伤害%', '%对风': '对风属性伤害%', '对风%': '对风属性伤害%', '对地': '对地属性伤害%', '%对地': '对地属性伤害%', '对地%': '对地属性伤害%', '对光': '对光属性伤害%', '%对光': '对光属性伤害%', '对光%': '对光属性伤害%', '对暗': '对暗属性伤害%', '%对暗': '对暗属性伤害%', '对暗%': '对暗属性伤害%',
+        '火属': '火属性', '火属性': '火属性', '火原属': '火原属', '水属': '水属性', '水属性': '水属性', '水原属': '水原属', '风属': '风属性', '风属性': '风属性', '风原属': '风原属', '地属': '地属性', '地属性': '地属性', '地原属': '地原属', '光属': '光属性', '光属性': '光属性', '光原属': '光原属', '暗属': '暗属性', '暗属性': '暗属性', '暗原属': '暗原属'
+    };
+    // 附魔能力列表
+    const EnchantAbilityEffect = {
+        '力量': { "name": "力量", "type": "PlayerAbility", "min": -25, "max": 25, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": null, "MaterialUse": null, "MaterialType": null },
+        '力量%': { "name": "力量%", "type": "PlayerAbility", "min": -10, "max": 10, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '灵巧': { "name": "灵巧", "type": "PlayerAbility", "min": -25, "max": 25, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": null, "MaterialUse": null, "MaterialType": null },
+        '灵巧%': { "name": "灵巧%", "type": "PlayerAbility", "min": -10, "max": 10, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '智力': { "name": "智力", "type": "PlayerAbility", "min": -25, "max": 25, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": null, "MaterialUse": null, "MaterialType": null },
+        '智力%': { "name": "智力%", "type": "PlayerAbility", "min": -10, "max": 10, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '敏捷': { "name": "敏捷", "type": "PlayerAbility", "min": -25, "max": 25, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": null, "MaterialUse": null, "MaterialType": null },
+        '敏捷%': { "name": "敏捷%", "type": "PlayerAbility", "min": -10, "max": 10, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '耐力': { "name": "耐力", "type": "PlayerAbility", "min": -25, "max": 25, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": null, "MaterialUse": null, "MaterialType": null },
+        '耐力%': { "name": "耐力%", "type": "PlayerAbility", "min": -10, "max": 10, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        'hp自然恢复': { "name": "hp自然恢复", "type": "hpmp", "min": -25, "max": 25, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        'hp自然恢复%': { "name": "hp自然恢复%", "type": "hpmp", "min": -10, "max": 10, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        'mp自然恢复': { "name": "mp自然恢复", "type": "hpmp", "min": -12, "max": 12, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        'mp自然恢复%': { "name": "mp自然恢复%", "type": "hpmp", "min": -5, "max": 5, "ExValue": 5, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 20, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        '物理攻击%': { "name": "物理攻击%", "type": "atk", "min": -12, "max": 12, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '魔法攻击%': { "name": "魔法攻击%", "type": "atk", "min": -12, "max": 12, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '物理防御%': { "name": "物理防御%", "type": "def", "min": -11, "max": 11, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        '魔法防御%': { "name": "魔法防御%", "type": "def", "min": -11, "max": 11, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        '回避': { "name": "回避", "type": "flee", "min": -16, "max": 16, "ExValue": 10, "ExBefore": 1, "ExAfter": 2, "PotentialUse": 10, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        '回避%': { "name": "回避%", "type": "flee", "min": -5, "max": 5, "ExValue": 5, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 20, "double": "武器", "MaterialUse": null, "MaterialType": null },
+        '暴击率': { "name": "暴击率", "type": "ctr", "min": -20, "max": 25, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 1, "double": null, "MaterialUse": null, "MaterialType": null },
+        '暴击伤害': { "name": "暴击伤害", "type": "ctr", "min": -20, "max": 21, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 3, "double": null, "MaterialUse": null, "MaterialType": null },
+        '暴击伤害%': { "name": "暴击伤害%", "type": "ctr", "min": -10, "max": 10, "ExValue": 10, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '对火属性伤害%': { "name": "对火属性伤害%", "type": "to", "min": -21, "max": 21, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '对水属性伤害%': { "name": "对水属性伤害%", "type": "to", "min": -21, "max": 21, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '对风属性伤害%': { "name": "对风属性伤害%", "type": "to", "min": -21, "max": 21, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '对地属性伤害%': { "name": "对地属性伤害%", "type": "to", "min": -21, "max": 21, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '对光属性伤害%': { "name": "对光属性伤害%", "type": "to", "min": -21, "max": 21, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '对暗属性伤害%': { "name": "对暗属性伤害%", "type": "to", "min": -21, "max": 21, "ExValue": 20, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 5, "double": "防具", "MaterialUse": null, "MaterialType": null },
+        '火属性': { "name": "火属性", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 100, "double": null, "MaterialUse": null, "MaterialType": null },
+        '水属性': { "name": "水属性", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 100, "double": null, "MaterialUse": null, "MaterialType": null },
+        '风属性': { "name": "风属性", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 100, "double": null, "MaterialUse": null, "MaterialType": null },
+        '地属性': { "name": "地属性", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 100, "double": null, "MaterialUse": null, "MaterialType": null },
+        '光属性': { "name": "光属性", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 100, "double": null, "MaterialUse": null, "MaterialType": null },
+        '暗属性': { "name": "暗属性", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 100, "double": null, "MaterialUse": null, "MaterialType": null },
+        '火原属': { "name": "火原属", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '水原属': { "name": "水原属", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '风原属': { "name": "风原属", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '地原属': { "name": "地原属", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '光原属': { "name": "光原属", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+        '暗原属': { "name": "暗原属", "type": "element", "min": 0, "max": 1, "ExValue": 1, "ExBefore": 1, "ExAfter": 1, "PotentialUse": 10, "double": null, "MaterialUse": null, "MaterialType": null },
+    };
+    // 返回给定长度的组合
+    function combinationsL(elements, k) {
+        const result = [];
+        function combine(start, currentCombination) {
+            if (currentCombination.length === k) {
+                result.push([...currentCombination]);
+                return;
+            }
+            for (let i = start; i < elements.length; i++) {
+                currentCombination.push(elements[i]);
+                combine(i + 1, currentCombination);
+                currentCombination.pop();
+            }
+        }
+        combine(0, []);
+        return result;
+    }
+    // 返回不指定长度的组合
+    function combinations(arr) {
+        const result = [];
+        function generateCombinations(current, remaining) {
+            if (remaining.length === 0) {
+                result.push(current.slice()); // 将当前组合添加到结果数组中
+                return;
+            }
+            const [first, ...rest] = remaining;
+            // 包含第一个元素的情况
+            generateCombinations([...current, first], rest);
+            // 不包含第一个元素的情况
+            generateCombinations(current, rest);
+        }
+        generateCombinations([], arr);
+        return result;
+    }
+    // 模拟一个对象 {NowEnchant:[{type,value},...],potential,type} 进行附魔 [{type,value},...] 返回附魔后的对象
+    function EnchantSimulate(CurrentStatus, AddEnchant) {
+        var NewStatus = CopyObject(CurrentStatus);
+        var NewRatio = Ratio(CurrentStatus, AddEnchant);
+        var AllUse = 0;
+        for (var ES_i1 = 0; ES_i1 < AddEnchant.length; ES_i1++) {
+            var CellBaseUse = EnchantAbilityEffect[AddEnchant[ES_i1].type].PotentialUse;
+            var CellExValue = EnchantAbilityEffect[AddEnchant[ES_i1].type].ExValue;
+            var CellNowValue, had = -1;
+            for (var ES_i2 = 0; ES_i2 < NewStatus.NowEnchant.length; ES_i2++) {
+                if (NewStatus.NowEnchant[ES_i2].type == AddEnchant[ES_i1].type) {
+                    had = ES_i2;
+                    CellNowValue = NewStatus.NowEnchant[ES_i2].value;
+                }
+            }
+            if (had == -1) {
+                CellNowValue = 0;
+            }
+            var CellExBeforeValue, CellExAfterValue, direction, power1, power2;
+            if (AddEnchant[ES_i1].value >= 0) {
+                direction = 1;
+            }
+            else {
+                direction = -1;
+            }
+            if (Math.abs(CellNowValue) >= CellExValue) {
+                CellExBeforeValue = 0;
+                CellExAfterValue = AddEnchant[ES_i1].value;
+            }
+            else {
+                if (Math.abs(CellNowValue + AddEnchant[ES_i1].value) > CellExValue) {
+                    CellExBeforeValue = direction * CellExValue - CellNowValue;
+                    CellExAfterValue = CellNowValue + AddEnchant[ES_i1].value - direction * CellExValue;
+                }
+                else {
+                    CellExBeforeValue = AddEnchant[ES_i1].value;
+                    CellExAfterValue = 0;
+                }
+            }
+            var CellExBefore = EnchantAbilityEffect[AddEnchant[ES_i1].type].ExBefore;
+            var CellExAfter = EnchantAbilityEffect[AddEnchant[ES_i1].type].ExAfter;
+            if (direction > 0) {
+                power1 = 1;
+                power2 = 2;
+            }
+            else {
+                power1 = 0.305;
+                power2 = 0.5;
+            }
+            var CellUse = (CellExBeforeValue / CellExBefore + CellExAfterValue / CellExAfter * power2) * CellBaseUse * power1;
+            if (EnchantAbilityEffect[AddEnchant[ES_i1].type].double == CurrentStatus.type) {
+                CellUse = CellUse * 2;
+            }
+            CellUse = Math.floor(Math.abs(CellUse)) * direction;
+            AllUse += CellUse;
+            if (had == -1) {
+                NewStatus.NowEnchant.push({ "type": AddEnchant[ES_i1].type, "value": CellNowValue + AddEnchant[ES_i1].value });
+            }
+            else {
+                NewStatus.NowEnchant[had].value += AddEnchant[ES_i1].value;
+            }
+        }
+        AllUse = Math.floor(Math.abs(NewRatio * AllUse)) * direction;
+        NewStatus.potential -= AllUse;
+        return NewStatus;
+    }
+    // 计算一个对象 {NowEnchant:[{type,value},...],potential,type} 进行附魔 [{type,value},...] 后的倍率
+    function Ratio(CurrentStatus, AddEnchant) {
+        var ThisRatioList = RatioList(CurrentStatus, AddEnchant);
+        var ThisRatio = 0;
+        var ThisRatioCountListKeys = Object.keys(ThisRatioList);
+        for (var R_i = 0; R_i < ThisRatioCountListKeys.length; R_i++) {
+            if (ThisRatioList[ThisRatioCountListKeys[R_i]] > 1) {
+                ThisRatio += ThisRatioList[ThisRatioCountListKeys[R_i]] ** 2;
+            }
+        }
+        ThisRatio = 1 + 0.05 * ThisRatio;
+        return ThisRatio;
+    }
+    // 统计一个对象 {NowEnchant:[{type,value},...],potential,type} 进行附魔 [{type,value},...] 后的倍率项数组
+    function RatioList(CurrentStatus, AddEnchant) {
+        var ThisRatioList = { "PlayerAbility": 0, "hpmp": 0, "atk": 0, "def": 0, "flee": 0, "ctr": 0, "to": 0 };
+        for (const cell of CurrentStatus.NowEnchant) {
+            ThisRatioList[EnchantAbilityEffect[cell.type].type] += 1;
+        }
+        for (var RL_i = 0; RL_i < AddEnchant.length; RL_i++) {
+            var RatioList_had = -1;
+            for (const cell of CurrentStatus.NowEnchant) {
+                if (cell.type == AddEnchant[RL_i].type) {
+                    RatioList_had = 1;
+                }
+            }
+            if (RatioList_had == -1) {
+                ThisRatioList[EnchantAbilityEffect[AddEnchant[RL_i].type].type] += 1;
+            }
+        }
+        return ThisRatioList;
+    }
+    // 将一个对象 {NowEnchant:[{type,value},...],potential,type} 赋值给新对象
+    function CopyObject(CurrentStatus) {
+        var CE_json = JSON.stringify(CurrentStatus);
+        var NewObject = JSON.parse(CE_json);
+        return NewObject;
+    }
+    // 尝试计算第一步拉潜力数组
+    function MakeFirst(UsePotentialList, CanUse) {
+        var FirstStepList = [], MF_use1, MF_max1, MF_val1, MF_use2;
+        for (var MF_i = 0; MF_i < UsePotentialList.length; MF_i++) {
+            MF_use1 = UsePotentialList[MF_i].PotentialUse;
+            if (MF_use1 == 0) {
+                MF_val1 = 0;
+            }
+            else {
+                MF_max1 = UsePotentialList[MF_i].max;
+                MF_val1 = Math.min(MF_max1, Math.floor(CanUse / MF_use1));
+            }
+            CanUse -= MF_val1 * MF_use1;
+            FirstStepList.push(MF_val1);
+        }
+        if (CanUse != 0) {
+            var SwitchList1 = [], MF_index = 0, MF_Q, MF_mod;
+            for (var MF_i1 = 0; MF_i1 < UsePotentialList.length; MF_i1++) {
+                MF_use1 = UsePotentialList[MF_i1].PotentialUse;
+                for (var MF_i2 = 0; MF_i2 < UsePotentialList.length; MF_i2++) {
+                    if (MF_i1 != MF_i2) {
+                        MF_use2 = UsePotentialList[MF_i2].PotentialUse;
+                        if (MF_use1 != 0 && MF_use2 != 0) {
+                            MF_Q = Math.floor(MF_use1 / MF_use2);
+                            MF_mod = MF_use1 % MF_use2;
+                            SwitchList1.push({ "index": MF_index, "from": MF_i1, "to": MF_i2, "Q": MF_Q, "mod": MF_mod });
+                            MF_index += 1;
+                        }
+                    }
+                }
+            }
+            var MF_ok = -1;
+            for (var MF_i1 = 0; MF_i1 < SwitchList1.length; MF_i1++) {
+                if (SwitchList1[MF_i1].mod + CanUse == UsePotentialList[SwitchList1[MF_i1].to].PotentialUse && FirstStepList[SwitchList1[MF_i1].from] > 0) {
+                    MF_ok = SwitchList1[MF_i1].index;
+                }
+            }
+            if (MF_ok == -1) {
+                for (var MF_i = 0; MF_i < FirstStepList.length; MF_i++) {
+                    FirstStepList[MF_i] = 0;
+                }
+                return FirstStepList;
+            }
+            else {
+                FirstStepList[SwitchList1[MF_ok].from] -= 1;
+                FirstStepList[SwitchList1[MF_ok].to] += SwitchList1[MF_ok].Q + 1;
+                return FirstStepList;
+            }
+        }
+    }
     // 更新数据库指令
     ctx.command('数据文件写入').action(async ({ session }, ...args) => {
         try {
@@ -192,6 +447,7 @@ async function apply(ctx, config) {
                                 ]);
                                 break;
                             default:
+                                ;
                                 break;
                         }
                     }
@@ -220,7 +476,7 @@ async function apply(ctx, config) {
         for (const element of elements) {
             if (element.type == "at") {
                 if (element.attrs.id == config.机器人qq) {
-                    return '魔导书现有功能：\n①升级 等级：查询该等级升级头目\n②天气预报：查看本次大更新的覆盖内容\n③料理 料理名称 [料理等级]：查询高级料理名单(结果通常用拼音排序)\n④料理 玩家名称：查询该玩家的料理信息\n⑤游戏术语 [术语名称]：查询游戏术语';
+                    return '魔导书现有功能：\n①升级 等级：查询该等级升级头目\n②天气预报：查看接下来' + config.天气预报_更新数量 + '次更新的内容\n③料理 料理名称 料理等级(可选)：查询高级料理名单(结果通常用拼音排序)\n④料理 玩家名称：查询该玩家的料理信息\n⑤游戏术语 术语名称：查询游戏术语';
                 }
             }
         }
@@ -447,10 +703,662 @@ async function apply(ctx, config) {
                 const Update_Date = new Date(Update.time);
                 DateString = `${Update_Date.getMonth() + 1}月${Update_Date.getDate()}日`;
                 return `${DateString}更新：${Update?.content}`;
-            }).join('\n');
+            }).join('\n\n');
             return Updates;
         }
         return NextUpdateNotFind[Math.floor(Math.random() * NextUpdateNotFind.length)];
     });
+    // 武器附魔指令
+    ctx.command('武器附魔 <附魔正属> <潜力值>')
+        .option('AllowMinusMPRevert', '-a')
+        .action(async ({ options, session }, ...args) => {
+        let Enchantments = args[0], potential = args[1];
+        // 参数缺失，返回可输入属性列表
+        if (Enchantments == undefined || potential == undefined) {
+            return EnchantReply;
+        }
+        // 参数齐全，尝试解析附魔
+        const EnchantmentsArr = Enchantments.split("/");
+        x = 0;
+        let EnchantAbilityList = [];
+        for (const enchant of EnchantmentsArr) {
+            x += 1;
+            // 附魔的数值不是数字时
+            var EnchantNum = parseFloat(enchant);
+            if (isNaN(EnchantNum)) {
+                if (EnchantAbilityEffect[AbilityType[enchant]]?.type == "element") {
+                    EnchantNum = 1;
+                }
+                else {
+                    return "你这是在附什么奇怪的东西啊！";
+                }
+            }
+            // 附魔的潜力不是整数时
+            if (/潜力$/.test(potential) == true) {
+                potential = potential.replace(/潜力/g, "");
+            }
+            if (/潜$/.test(potential) == true) {
+                potential = potential.replace(/潜/g, "");
+            }
+            if (/^\+?(0|[1-9]\d*)$/.test(potential) != true) {
+                return "你要不要看一眼你的潜力？";
+            }
+            var EnchantName = enchant.replace(EnchantNum, "");
+            // 附魔不在简称列表内
+            var EnchantType = AbilityType[EnchantName] ?? null;
+            if (EnchantType == null) {
+                return "书还不支持这种附魔的计算哦~";
+            }
+            // 写进列表
+            var EnchantAbility = { "id": x, "type": EnchantType, "value": EnchantNum, "PotentialUse": EnchantAbilityEffect[EnchantType].PotentialUse };
+            EnchantAbilityList.push(EnchantAbility);
+        }
+        // 附魔项过多
+        if (x > 8) {
+            return "什么？锻造6阶出了吗？怎么附这么多？";
+        }
+        n = 0;
+        c = 0;
+        g = 0;
+        for (const EnchantAbility of EnchantAbilityList) {
+            x = EnchantAbility.id;
+            aa = EnchantAbility.type;
+            a = EnchantAbility.value;
+            // 检查是否存在重复项
+            if (EnchantAbilityEffect[aa].type == "element") {
+                n += 1;
+            }
+            if (aa == "暴击率") {
+                c = Math.min(a - 1, 19);
+                g += 1;
+            }
+            if (aa == "暴击伤害") {
+                g += 3;
+            }
+            if (aa == "暴击伤害%") {
+                g += 10;
+            }
+            for (const another of EnchantAbilityList) {
+                if (x != another.id && aa == another.type) {
+                    return "你为什么不附一件8个词条都是25暴击的200暴武器呢？";
+                }
+            }
+        }
+        if (n > 1) {
+            return "快进到全属性觉醒！";
+        }
+        n = 0;
+        let RatioList1 = { 'PlayerAbility': 0, 'hpmp': 0, 'atk': 0, 'def': 0, 'flee': 0, 'ctr': 0, 'to': 0, 'element': 0 };
+        for (const EnchantAbility of EnchantAbilityList) {
+            aa = EnchantAbility.type;
+            RatioList1[EnchantAbilityEffect[aa].type] += 1;
+            x = EnchantAbility.value;
+            // 检查附魔数值范围
+            var ThisAbilityMin = EnchantAbilityEffect[aa].min;
+            var ThisAbilityMax = EnchantAbilityEffect[aa].max;
+            if (x < ThisAbilityMin || x > ThisAbilityMax) {
+                return "嗯...好像有点超出现在的版本了呢？";
+            }
+            // 检查附魔数值合法并计算正属总耗潜
+            var ThisAbilityExValue = EnchantAbilityEffect[aa].ExValue;
+            var ThisAbilityExAfter = EnchantAbilityEffect[aa].ExAfter;
+            var ThisAbilityExBefore = EnchantAbilityEffect[aa].ExBefore;
+            if (x > ThisAbilityExValue) {
+                a = x - ThisAbilityExValue;
+                b = ThisAbilityExAfter;
+            }
+            else {
+                a = x;
+                b = ThisAbilityExBefore;
+            }
+            a = a / b;
+            if (a != Math.floor(a)) {
+                return "附不到这个数字吧！";
+            }
+            var ThisAbilityPotentialUse = EnchantAbilityEffect[aa].PotentialUse;
+            if (x > ThisAbilityExValue) {
+                n += (ThisAbilityExValue / ThisAbilityExBefore + (x - ThisAbilityExValue) / ThisAbilityExAfter * 2) * ThisAbilityPotentialUse;
+            }
+            else {
+                n += x / ThisAbilityExBefore * ThisAbilityPotentialUse;
+            }
+        }
+        // 计算退潜列表
+        let ReturnPotentialList = [];
+        for (let ability in EnchantAbilityEffect) {
+            a = 1;
+            for (const EnchantAbility of EnchantAbilityList) {
+                if (EnchantAbilityEffect[ability].name == EnchantAbility.type || EnchantAbilityEffect[ability].type == "element") {
+                    a = 0;
+                }
+            }
+            if (EnchantAbilityEffect[ability].name == "mp自然恢复" && options.AllowMinusMPRevert != true) {
+                a = 0;
+            }
+            if (a == 1) {
+                a = EnchantAbilityEffect[ability].min;
+                b = EnchantAbilityEffect[ability].ExValue;
+                d = EnchantAbilityEffect[ability].ExAfter;
+                e = EnchantAbilityEffect[ability].ExBefore;
+                f = EnchantAbilityEffect[ability].PotentialUse;
+                x = ((Math.abs(a) - b) / d * 0.5 + b / e) * f * 0.305;
+                if (EnchantAbilityEffect[ability].double == "武器") {
+                    x = x * 2;
+                }
+                x = Math.floor(x);
+                var ReturnPotent = { "name": EnchantAbilityEffect[ability].name, "type": EnchantAbilityEffect[ability].type, "value": x };
+                ReturnPotentialList.push(ReturnPotent);
+            }
+        }
+        // 遍历退潜方法
+        let ReturnPotentialSelect1 = ReturnPotentialList
+            .sort(function (a, b) {
+            let aRP = a.value;
+            let bRP = b.value;
+            return bRP - aRP;
+        })
+            .slice(0, 8);
+        a = 8 - EnchantAbilityList.length;
+        const ReturnPotentialSelect2 = combinationsL(ReturnPotentialSelect1, a);
+        // 计算每种退潜方法的倍率
+        let RatioList2 = [];
+        ReturnPotentialSelect2.forEach(function (Select, index) {
+            let RatioCountList = { "PlayerAbility": 0, "hpmp": 0, "atk": 0, "def": 0, "flee": 0, "ctr": 0, "to": 0 };
+            x = 0;
+            for (const Return of Select) {
+                RatioCountList[Return.type] += 1;
+                x += Return.value;
+            }
+            var RatioCountListKeys = Object.keys(RatioCountList);
+            y = 0;
+            for (var i = 0; i < RatioCountListKeys.length; i++) {
+                if (RatioCountList[RatioCountListKeys[i]] > 1) {
+                    y += RatioCountList[RatioCountListKeys[i]] ** 2;
+                }
+            }
+            y *= 0.05;
+            RatioList2.push({ "Ratio": y, "value": x, "index": index });
+        });
+        // 获取每种倍率下最高的退潜方法
+        RatioList2 = RatioList2.sort(function (a, b) {
+            let aRP = a.value;
+            let bRP = b.value;
+            return bRP - aRP;
+        });
+        let RatioList3 = [];
+        let RatioList4 = [];
+        for (const ReturnMethod of RatioList2) {
+            if (RatioList4.indexOf(ReturnMethod.Ratio) == -1) {
+                RatioList4.push(ReturnMethod.Ratio);
+                RatioList3.push(ReturnMethod);
+            }
+        }
+        // 对每种退潜方法计算成功率
+        let SuccessRateList = [];
+        x = 0;
+        var RatioList1Keys = Object.keys(RatioList1);
+        for (var i = 0; i < RatioList1Keys.length; i++) {
+            if (RatioList1[RatioList1Keys[i]] > 1) {
+                x += RatioList1[RatioList1Keys[i]] ** 2;
+            }
+        }
+        x = 1 + 0.05 * x;
+        for (let i = 0; i < RatioList3.length; i++) {
+            let ReturnMethod = RatioList3[i];
+            b = ReturnMethod.value * (x + ReturnMethod.Ratio) - c + 1;
+            a = 160 + 230 / b * (b - (n - potential - c + 1) * (x + ReturnMethod.Ratio));
+            SuccessRateList.push({ "index": ReturnMethod.index, "rate": a, "type": 1, "Ratio": x + ReturnMethod.Ratio });
+            b = potential - g + ReturnMethod.value * (x + ReturnMethod.Ratio);
+            a = 160 + 230 / b * (b - (n - g) * (x + ReturnMethod.Ratio));
+            SuccessRateList.push({ "index": ReturnMethod.index, "rate": a, "type": 2, "Ratio": x + ReturnMethod.Ratio });
+        }
+        // 获取最高成功率的方法并解析
+        SuccessRateList = SuccessRateList.sort(function (a, b) {
+            let aRT = a.rate;
+            let bRT = b.rate;
+            return bRT - aRT;
+        });
+        a = SuccessRateList[0].index;
+        y = SuccessRateList[0].Ratio;
+        arr1 = [];
+        const ChoiceMethod = ReturnPotentialSelect2[a];
+        for (let i = 0; i < ChoiceMethod.length; i++) {
+            arr1.push({ "type": ChoiceMethod[i].name, "value": EnchantAbilityEffect[ChoiceMethod[i].name].min });
+        }
+        // 尝试还原附魔步骤
+        var Equipment = { "NowEnchant": [], "potential": potential, "type": "武器" };
+        let TextList = [], FirstList = [];
+        var RatioCountList = {}, RatioCountList2 = [], RatioCountList3 = [];
+        let EquipmentBefore, EquipmentAfter;
+        switch (SuccessRateList[0].type) {
+            // 分步附
+            case 1:
+                // 计算可用潜力
+                EnchantAbilityList = EnchantAbilityList.sort(function (a, b) {
+                    let aPU = a.PotentialUse;
+                    let bPU = b.PotentialUse;
+                    return bPU - aPU;
+                });
+                RatioCountList = RatioList(Equipment, EnchantAbilityList);
+                for (const Enchant of EnchantAbilityList) {
+                    aa = EnchantAbilityEffect[Enchant.type].type;
+                    if (RatioCountList[aa] > 1) {
+                        RatioCountList2.push({ "type": Enchant.type, "value": Enchant.value, "PotentialUse": Enchant.PotentialUse, "MainType": aa });
+                    }
+                }
+                RatioCountList3 = [];
+                for (const Enchant of RatioCountList2) {
+                    RatioCountList3.push({ "type": Enchant.type, "value": 1, "PotentialUse": Enchant.PotentialUse });
+                }
+                EquipmentBefore = CopyObject(Equipment);
+                for (var i = 0; i < RatioCountList3.length - 1; i++) {
+                    var step = [];
+                    step.push(RatioCountList3[i]);
+                    EquipmentAfter = EnchantSimulate(EquipmentBefore, step);
+                    EquipmentBefore = CopyObject(EquipmentAfter);
+                }
+                EquipmentAfter = EnchantSimulate(EquipmentBefore, [RatioCountList3[RatioCountList3.length - 1]]);
+                var CanUse1 = EquipmentBefore.potential - 1;
+                var CanUse2 = EquipmentAfter.potential - 1;
+                // 判断倍率项数
+                x = 0;
+                for (const Enchant of EnchantAbilityList) {
+                    aa = EnchantAbilityEffect[Enchant.type].type;
+                    if (RatioCountList[aa] > 1) {
+                        x += 1;
+                    }
+                }
+                // 计算第一步消耗潜力方法
+                var GiveLists = [], GiveList = [];
+                EquipmentBefore = CopyObject(Equipment);
+                // 计算仅用无损的倍率项能否消耗完毕
+                a = 0;
+                if (x != 0) {
+                    for (const EnchantAbility of EnchantAbilityList) {
+                        b = 0;
+                        if (RatioCountList[EnchantAbilityEffect[EnchantAbility.type].type] > 1 && EnchantAbilityEffect[EnchantAbility.type].PotentialUse != 1) {
+                            var step = [];
+                            step.push({ "type": EnchantAbility.type, "value": 1, "PotentialUse": EnchantAbility.PotentialUse });
+                            EquipmentAfter = EnchantSimulate(EquipmentBefore, step);
+                            if (EquipmentBefore.potential - EquipmentAfter.potential == EnchantAbilityEffect[EnchantAbility.type].PotentialUse) {
+                                GiveList.push({ "index": a, "type": EnchantAbility.type, "PotentialUse": EnchantAbilityEffect[EnchantAbility.type].PotentialUse, "max": EnchantAbilityEffect[EnchantAbility.type].max });
+                                EquipmentBefore = CopyObject(EquipmentAfter);
+                                b = 1;
+                            }
+                        }
+                        if (b == 0) {
+                            GiveList.push({ "index": a, "type": EnchantAbility.type, "PotentialUse": 0, "max": EnchantAbilityEffect[EnchantAbility.type].max });
+                        }
+                        a += 1;
+                    }
+                }
+                var ReturnFirst1 = [], ReturnFirst2 = [], FirstListNum = [], FirstLists = [];
+                if (GiveList.length != 0) {
+                    GiveLists.push(GiveList);
+                    for (const PotentialUseList of GiveLists) {
+                        ReturnFirst1 = MakeFirst(PotentialUseList, CanUse1);
+                        ReturnFirst2 = MakeFirst(PotentialUseList, CanUse2);
+                        FirstLists.push(ReturnFirst1);
+                        FirstLists.push(ReturnFirst2);
+                    }
+                    a = 0;
+                    for (const ReturnList of FirstLists) {
+                        for (var i = 0; i < ReturnList.length; i++) {
+                            if (ReturnList[i] != 0) {
+                                a = 1;
+                                FirstListNum = ReturnList;
+                                break;
+                            }
+                        }
+                        if (a == 1) {
+                            break;
+                        }
+                    }
+                    for (var i = 0; i < FirstListNum.length; i++) {
+                        if (FirstListNum[i] != 0) {
+                            FirstList.push({ "type": EnchantAbilityList[i].type, "value": FirstListNum[i] + 1 });
+                        }
+                    }
+                }
+                // 若仅用无损倍率无法消耗完毕
+                if (FirstList.length == 0) {
+                    FirstLists = [], GiveLists = [];
+                    var NewGiveList = CopyObject(GiveList);
+                    var EnchantList = [];
+                    for (const EnchantAbility of EnchantAbilityList) {
+                        if (RatioCountList[EnchantAbilityEffect[EnchantAbility.type].type] < 2) {
+                            EnchantList.push(EnchantAbility);
+                        }
+                    }
+                    var APEnchantLists = combinations(EnchantList);
+                    APEnchantLists.sort(function (a, b) {
+                        let aL = a.length;
+                        let bL = b.length;
+                        return aL - bL;
+                    });
+                    for (const APEnchantList of APEnchantLists) {
+                        var NewGiveList = CopyObject(GiveList);
+                        if (APEnchantList.length != 0) {
+                            for (const APEnchant of APEnchantList) {
+                                NewGiveList.push(APEnchant);
+                            }
+                        }
+                        NewGiveList.sort(function (a, b) {
+                            let aPU = EnchantAbilityEffect[a.type].PotentialUse;
+                            let bPU = EnchantAbilityEffect[b.type].PotentialUse;
+                            return bPU - aPU;
+                        });
+                        for (const PotentialUseList of NewGiveList) {
+                            ReturnFirst1 = MakeFirst(PotentialUseList, CanUse1);
+                            ReturnFirst2 = MakeFirst(PotentialUseList, CanUse2);
+                            FirstLists.push(ReturnFirst1);
+                            FirstLists.push(ReturnFirst2);
+                        }
+                        b = 0;
+                        for (const ReturnList of FirstLists) {
+                            for (var i = 0; i < ReturnList.length; i++) {
+                                if (ReturnList[i] != 0) {
+                                    b = 1;
+                                    FirstListNum = ReturnList;
+                                    break;
+                                }
+                            }
+                            if (b == 1) {
+                                break;
+                            }
+                        }
+                        for (var i = 0; i < FirstListNum.length; i++) {
+                            if (FirstListNum[i] != 0) {
+                                FirstList.push({ "type": EnchantAbilityList[i].type, "value": FirstListNum[i] + 1 });
+                            }
+                        }
+                        if (FirstList.length != 0) {
+                            break;
+                        }
+                    }
+                }
+                // 第一步消耗潜力
+                EquipmentBefore = CopyObject(Equipment);
+                if (a == 1) {
+                    for (var i = 0; i < FirstList.length; i++) {
+                        if (i == 0) {
+                            var step = [];
+                            step.push(FirstList[i]);
+                            EquipmentAfter = EnchantSimulate(EquipmentBefore, step);
+                            text = "附" + FirstList[i].value + FirstList[i].type + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                            EquipmentBefore = CopyObject(EquipmentAfter);
+                            TextList.push(text);
+                        }
+                        else {
+                            var step = [];
+                            step.push({ "type": FirstList[i].type, "value": 1 });
+                            for (var j = 0; j < FirstList[i].value; j++) {
+                                EquipmentAfter = EnchantSimulate(EquipmentBefore, step);
+                                EquipmentBefore = CopyObject(EquipmentAfter);
+                            }
+                            text = "分" + FirstList[i].value + "次附，每次附1" + FirstList[i].type + "直到" + FirstList[i].value + FirstList[i].type + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                            TextList.push(text);
+                        }
+                    }
+                    for (const Enchant of EnchantAbilityList) {
+                        if (EnchantAbilityEffect[Enchant.type].type == aa && EnchantAbilityEffect[Enchant.type].PotentialUse == 1) {
+                            var step = [];
+                            step.push({ "type": Enchant.type, "value": 1 });
+                            EquipmentAfter = EnchantSimulate(EquipmentBefore, step);
+                            if (EquipmentAfter.potential != 0) {
+                                EquipmentBefore = CopyObject(EquipmentAfter);
+                                text = "附1" + Enchant.type + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                                TextList.push(text);
+                            }
+                            else {
+                                aa = Enchant.type;
+                            }
+                        }
+                    }
+                }
+                else {
+                    text = "附";
+                    EquipmentAfter = EnchantSimulate(EquipmentBefore, FirstList);
+                    EquipmentBefore = CopyObject(EquipmentAfter);
+                    for (const Enchant of FirstList) {
+                        text += Enchant.value + Enchant.type + "、";
+                    }
+                    text = text.substring(0, text.length - 1) + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                    TextList.push(text);
+                }
+                // 第二步拉倍率
+                if (a == 0) {
+                    for (var i = 0; i < RatioCountList3.length - 1; i++) {
+                        var step = [];
+                        step.push(RatioCountList3[i]);
+                        EquipmentAfter = EnchantSimulate(EquipmentBefore, step);
+                        text = "附" + step[0].value + step[0].type + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                        TextList.push(text);
+                        EquipmentBefore = CopyObject(EquipmentAfter);
+                    }
+                    EquipmentAfter = EnchantSimulate(EquipmentBefore, [RatioCountList3[RatioCountList3.length - 1]]);
+                    if (EquipmentAfter.potential != 0) {
+                        text = "附" + RatioCountList3[RatioCountList3.length - 1].value + RatioCountList3[RatioCountList3.length - 1].type + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                        TextList.push(text);
+                        EquipmentBefore = CopyObject(EquipmentAfter);
+                    }
+                    else {
+                        aa = RatioCountList3[RatioCountList3.length - 1].type;
+                    }
+                }
+                // 第三步退潜
+                if (EquipmentAfter.potential == 0) {
+                    arr1.unshift({ "type": aa, "value": 1 });
+                }
+                EquipmentAfter = EnchantSimulate(EquipmentBefore, arr1);
+                text = "附";
+                for (i = 0; i < arr1.length; i++) {
+                    text += arr1[i].value + arr1[i].type + "、";
+                }
+                text = text.substring(0, text.length - 1) + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                TextList.push(text);
+                EquipmentBefore = CopyObject(EquipmentAfter);
+                // 第四步尝试判断暴击等项目
+                arr1 = [], arr2 = [];
+                for (const EnchantAbility of EnchantAbilityList) {
+                    var had = -1;
+                    for (i = 0; i < EquipmentBefore.NowEnchant.length; i++) {
+                        if (EquipmentBefore.NowEnchant[i].type == EnchantAbility.type) {
+                            had = i;
+                            c = EquipmentBefore.NowEnchant[i].value;
+                        }
+                    }
+                    if (had == -1) {
+                        c = 0;
+                    }
+                    if (c < EnchantAbility.value) {
+                        arr1.push({ "type": EnchantAbility.type, "value": EnchantAbility.value - c, "now": c });
+                    }
+                }
+                var EquipmentAfter1 = EnchantSimulate(EquipmentBefore, arr1);
+                x = Math.max(0, Math.min(100, Math.floor(160 + 230 / EquipmentBefore.potential * EquipmentAfter1.potential)));
+                arr2.push({ "value": 0, "rate": x });
+                // 若倍率满足
+                if (y > 1 && y < 2) {
+                    var i = 0;
+                    var StepList = [];
+                    arr3 = CopyObject(arr1);
+                    for (const Enchant of arr1) {
+                        a = EnchantAbilityEffect[Enchant.type].PotentialUse;
+                        if (a == 1) {
+                            c = Enchant.value;
+                            var index = 0;
+                            do {
+                                i += 1;
+                                index += 1;
+                                EquipmentAfter1 = EnchantSimulate(EquipmentBefore, [{ "type": Enchant.type, "value": 1 }]);
+                                for (const EnchantAbility of arr3) {
+                                    if (EnchantAbility.type == Enchant.type) {
+                                        EnchantAbility.value -= 1;
+                                        EnchantAbility.now += 1;
+                                    }
+                                }
+                                var EquipmentAfter2 = EnchantSimulate(EquipmentAfter1, arr3);
+                                x = Math.max(0, Math.min(100, Math.floor(160 + 230 / EquipmentAfter1.potential * EquipmentAfter2.potential)));
+                                arr2.push({ "value": i, "rate": x });
+                                EquipmentBefore = CopyObject(EquipmentAfter1);
+                            } while (index < c);
+                        }
+                    }
+                    EquipmentBefore = CopyObject(EquipmentAfter);
+                    arr2 = arr2.sort(function (a, b) {
+                        var aRT = a.rate;
+                        var bRT = b.rate;
+                        return bRT - aRT;
+                    });
+                    if (arr2[0].value != 0) {
+                        b = 0, d = 0;
+                        for (const Enchant of arr1) {
+                            a = EnchantAbilityEffect[Enchant.type].PotentialUse;
+                            if (a == 1) {
+                                c = Enchant.value;
+                                b += c;
+                                if (arr2[0].value <= b) {
+                                    d = 1;
+                                    StepList.push({ "type": Enchant.type, "value": arr2[0].value });
+                                }
+                                else {
+                                    arr2[0].value -= b;
+                                    StepList.push({ "type": Enchant.type, "value": b });
+                                }
+                            }
+                            if (d == 1) {
+                                break;
+                            }
+                        }
+                        for (const Enchant of StepList) {
+                            arr3 = [{ "type": Enchant.type, "value": 1 }];
+                            for (i = 0; i < Enchant.value; i++) {
+                                EquipmentAfter = EnchantSimulate(EquipmentBefore, arr3);
+                                EquipmentBefore = CopyObject(EquipmentAfter);
+                            }
+                            for (const EnchantAbility of arr1) {
+                                if (EnchantAbility.type == Enchant.type) {
+                                    EnchantAbility.value -= Enchant.value;
+                                    EnchantAbility.now += Enchant.value;
+                                }
+                            }
+                            for (const EnchantAbility of EquipmentAfter.NowEnchant) {
+                                if (EnchantAbility.type == Enchant.type) {
+                                    a = EnchantAbility.value;
+                                }
+                            }
+                            text = "分" + Enchant.value + "次附，每次附1" + Enchant.type + "直到" + a + Enchant.type + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                            TextList.push(text);
+                        }
+                    }
+                }
+                // 第五步拉满
+                text = "附";
+                EquipmentAfter = EnchantSimulate(EquipmentBefore, arr1);
+                for (i = 0; i < arr1.length; i++) {
+                    text += (arr1[i].now + arr1[i].value) + arr1[i].type + "、";
+                }
+                x = Math.max(0, Math.min(100, Math.floor(160 + 230 / EquipmentBefore.potential * EquipmentAfter.potential)));
+                y = Math.round((0.01 * x) ** EnchantAbilityList.length * 10000) / 100;
+                text = text.substring(0, text.length - 1) + "，剩余" + EquipmentAfter.potential + "潜力。\n单项成功率" + x + "%，总成功率" + y + "%\n";
+                TextList.push(text);
+                break;
+            case 2:
+                // 第一步拉倍率
+                // 获取倍率项
+                var EnchantRatioList = RatioList(Equipment, EnchantAbilityList);
+                for (const Enchant of EnchantAbilityList) {
+                    aa = Enchant.type;
+                    text = EnchantAbilityEffect[aa].type;
+                    if (EnchantRatioList[text] > 1) {
+                        FirstList.push({ "type": aa, "PotentialUse": EnchantAbilityEffect[aa].PotentialUse, "value": 1 });
+                    }
+                }
+                FirstList = FirstList.sort(function (a, b) {
+                    let aPU = a.PotentialUse;
+                    let bPU = b.PotentialUse;
+                    return bPU - aPU;
+                });
+                // 对每个倍率项进行附魔
+                EquipmentBefore = CopyObject(Equipment);
+                for (const Enchant of FirstList) {
+                    var step = [];
+                    step.push(Enchant);
+                    EquipmentAfter = EnchantSimulate(EquipmentBefore, step);
+                    text = "附1" + Enchant.type + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                    EquipmentBefore = CopyObject(EquipmentAfter);
+                    TextList.push(text);
+                }
+                // 退潜
+                EquipmentAfter = EnchantSimulate(EquipmentBefore, arr1);
+                text = "附";
+                for (i = 0; i < arr1.length; i++) {
+                    text += arr1[i].value + arr1[i].type + "、";
+                }
+                text = text.substring(0, text.length - 1) + "，剩余" + EquipmentAfter.potential + "潜力；\n";
+                TextList.push(text);
+                // 拉满
+                arr1 = [];
+                text = "附";
+                EquipmentBefore = CopyObject(EquipmentAfter);
+                for (const EnchantAbility of EnchantAbilityList) {
+                    var had = -1;
+                    for (i = 0; i < EquipmentBefore.NowEnchant.length; i++) {
+                        if (EquipmentBefore.NowEnchant[i].type == EnchantAbility.type) {
+                            had = i;
+                            c = EquipmentBefore.NowEnchant[i].value;
+                        }
+                    }
+                    if (had == -1) {
+                        c = 0;
+                    }
+                    if (c < EnchantAbility.value) {
+                        arr1.push({ "type": EnchantAbility.type, "value": EnchantAbility.value - c, "now": c });
+                    }
+                }
+                EquipmentAfter = EnchantSimulate(EquipmentBefore, arr1);
+                for (i = 0; i < arr1.length; i++) {
+                    text += (arr1[i].now + arr1[i].value) + arr1[i].type + "、";
+                }
+                x = Math.max(0, Math.min(100, Math.floor(160 + 230 / EquipmentBefore.potential * EquipmentAfter.potential)));
+                y = Math.round((0.01 * x) ** EnchantAbilityList.length * 10000) / 100;
+                text = text.substring(0, text.length - 1) + "，剩余" + EquipmentAfter.potential + "潜力。\n单项成功率" + x + "%，总成功率" + y + "%\n";
+                TextList.push(text);
+        }
+        text = "";
+        a = 0;
+        for (i = 0; i < TextList.length; i++) {
+            if (TextList[i] != "") {
+                a += 1;
+                text += " " + a + ". " + TextList[i];
+            }
+        }
+        text = "附魔步骤如下：\n" + text;
+        switch (true) {
+            case y >= 100:
+                text += "稳附呀！";
+                break;
+            case 100 > y && y >= 80:
+                text += "小炸呢~";
+                break;
+            case 80 > y && y >= 50:
+                text += "有可能失败哦？";
+                break;
+            case 50 > y && y >= 20:
+                text += "也许运气好可以成...";
+                break;
+            case 20 > y && y >= 10:
+                text += "要失败很多次才能成一件吧——";
+                break;
+            case 10 > y && y >= 1:
+                text += "你的素材在哭泣啊！！";
+                break;
+            case y < 1:
+                text += "书的建议是去搞负炸正【】";
+                break;
+        }
+        return text;
+    });
 }
 exports.apply = apply;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-toram",
   "description": "托拉姆物语小工具",
-  "version": "0.6.2-test.4",
+  "version": "0.6.3",
   "contributors": [
     "青灯 <1874053520@qq.com>"
   ],