koishi-plugin-toram 0.3.4 → 0.3.6

package/lib/index.js

@@ -9,7 +9,7 @@ exports.Config = koishi_1.Schema.object({
     升级_定点王数量: koishi_1.Schema.number().default(6),
     升级_野王数量: koishi_1.Schema.number().default(4),
     组队_未来天数: koishi_1.Schema.number().default(7),
-    料理_最低返回数量要求: koishi_1.Schema.number().default(15),
+    料理_最低返回数量要求: koishi_1.Schema.number().default(15)
 });
 async function apply(ctx, config) {
     ctx.model.extend('toram_boss', {
@@ -27,7 +27,8 @@ async function apply(ctx, config) {
         id: 'number',
         name: 'string',
         type: 'string',
-        level: 'number'
+        level: 'number',
+        effect: 'string'
     }, {
         primary: 'id'
     });
@@ -38,6 +39,13 @@ async function apply(ctx, config) {
     }, {
         primary: 'id'
     });
+    ctx.model.extend('toram_dishes_effect', {
+        id: 'number',
+        type: 'string',
+        effect: 'string'
+    }, {
+        primary: 'id'
+    });
     ctx.model.extend('toram_team', {
         id: 'string',
         form: 'number',
@@ -49,140 +57,159 @@ async function apply(ctx, config) {
         primary: 'id'
     });
     let n;
+    let i;
     let x;
+    let xx;
     let text;
     let 等级差倍率 = [11, 11, 11, 11, 11, 10, 9, 7, 3];
     let 时间戳增加对应 = {
         '上午': 12 * 60 * 60 * 1000,
         '下午': 18 * 60 * 60 * 1000,
     };
+    ctx.middleware(async (session, next) => {
+        let { elements, messageId, userId, content } = session;
+        let isAt = {};
+        for (const element of elements) {
+            if (element.type == "at") {
+                if (element.attrs.id == config.机器人qq) {
+                    return '魔法书现有功能：\n①升级 等级数：查询该等级升级头目\n②天气预报：查看本次大更新的覆盖内容\n③料理 料理名称 [料理等级]：查询高级料理名单(结果通常用拼音排序)\n④料理 玩家名称：查询该玩家的料理信息';
+                }
+            }
+        }
+        return next();
+    });
+    ctx.middleware((session, next) => {
+        if (session.content === '天气预报') {
+            return '【托拉姆物语3.24大更一览-哔哩哔哩】 https://b23.tv/cWX9yjU';
+        }
+        else {
+            return next;
+        }
+    });
     ctx.command('料理 <料理种类> <料理等级>').action(async ({ session }, ...args) => {
         {
-            let 料理名称 = args[0], 等级筛选 = args[1];
-            if (料理名称 == undefined) {
-                return '如果你要查询料理，请输入"料理 料理种类 [料理等级]"来进行查询哦';
+            let DishesName = args[0], DishesLevelChoice = args[1];
+            if (DishesName == undefined) {
+                return '如果你要查询料理，请输入"料理 料理种类 [料理等级]"或"料理 玩家名称"来进行查询哦';
             }
-            const rows1 = await ctx.database.get('toram_dishes_name', { name: [料理名称] });
-            const 料理类型 = rows1[0]?.type || '不存在';
-            if (料理类型 == '不存在') {
-                return '这是能吃的吗？';
+            const GetDishesType = await ctx.database.get('toram_dishes_name', { name: [DishesName] });
+            const DishesType = GetDishesType[0]?.type || 'none';
+            if (DishesType == 'none') {
+                const OnesName = DishesName;
+                const GetOnesDishes = await ctx.database.get('toram_dishes', { name: [OnesName] });
+                n = GetOnesDishes.length;
+                if (n != 0) {
+                    GetOnesDishes.sort(function (a, b) {
+                        let alv = a.level;
+                        let blv = b.level;
+                        return b - a;
+                    });
+                    let OnesDishes = GetOnesDishes.map((Dishes) => {
+                        return `${Dishes?.type}(${Dishes?.effect}${Dishes?.level}级)`;
+                    }).join('，');
+                    text = OnesName + '的料理信息如下：\n' + OnesDishes;
+                    return text;
+                }
+                return '还没有记录有这个人制作的料理呢——';
             }
-            if (等级筛选 == undefined) {
-                let 十级料理信息结果;
-                let 九级料理信息结果;
-                let 八级料理信息结果;
-                const rows2 = await ctx.database.get('toram_dishes', { $and: [{ type: [料理类型] }, { level: [10] }] });
-                if (rows2.length != 0) {
-                    十级料理信息结果 = rows2.map((player) => {
+            const DishesEffectArr = await ctx.database.get('toram_dishes_effect', { type: [DishesType] });
+            const DishesEffect = DishesEffectArr[0]?.effect;
+            if (DishesLevelChoice == undefined) {
+                let Level10Dishes, Level9Dishes, Level8Dishes;
+                const GetLevel10Dishes = await ctx.database.get('toram_dishes', { $and: [{ type: [DishesType] }, { level: [10] }] });
+                if (GetLevel10Dishes.length != 0) {
+                    Level10Dishes = GetLevel10Dishes.map((player) => {
                         return `${player?.name}`;
                     })
                         .sort(function compareFunction(item1, item2) {
                         return item1.localeCompare(item2);
                     });
                 }
-                const rows3 = await ctx.database.get('toram_dishes', { $and: [{ type: [料理类型] }, { level: [9] }] });
-                if (rows3.length != 0 && rows2.length < config.料理_最低返回数量要求) {
-                    九级料理信息结果 = rows3.map((player) => {
+                const GetLevel9Dishes = await ctx.database.get('toram_dishes', { $and: [{ type: [DishesType] }, { level: [9] }] });
+                if (GetLevel9Dishes.length != 0 && GetLevel10Dishes.length < config.料理_最低返回数量要求) {
+                    Level9Dishes = GetLevel9Dishes.map((player) => {
                         return `${player?.name}`;
                     })
                         .sort(function compareFunction(item1, item2) {
                         return item1.localeCompare(item2);
                     });
                 }
-                if (rows2.length == 0 && rows3.length == 0) {
-                    let rows4 = await ctx.database.get('toram_dishes', { type: [料理类型] });
-                    if (rows4.length != 0) {
-                        rows4.sort(function (a, b) {
+                if (GetLevel10Dishes.length == 0 && GetLevel9Dishes.length == 0) {
+                    let GetAllLevelDishes = await ctx.database.get('toram_dishes', { type: [DishesType] });
+                    if (GetAllLevelDishes.length != 0) {
+                        GetAllLevelDishes.sort(function (a, b) {
                             let alv = a.level;
                             let blv = b.level;
                             return b - a;
                         });
-                        const 八级以下料理信息结果 = rows4.map((player) => {
+                        const LevelUnder8Dishes = GetAllLevelDishes.map((player) => {
                             return `${player?.name}(${player?.level}级)`;
-                        })
-                            .sort(function compareFunction(item1, item2) {
-                            return item1.localeCompare(item2);
                         });
-                        text = 料理类型;
-                        if (料理类型 != 料理名称) {
-                            text += '(' + 料理名称 + ')';
-                        }
-                        text += '名单如下：\n' + 八级以下料理信息结果;
+                        text = DishesType + '(' + DishesEffect + ')名单如下：\n' + LevelUnder8Dishes;
                         text = text.replace(/,/g, '，');
                         return text;
                     }
                     return '还没有记录有这种料理呢——';
                 }
-                text = 料理类型;
-                if (料理类型 != 料理名称) {
-                    text += '(' + 料理名称 + ')';
+                text = DishesType + '(' + DishesEffect + ')名单如下：';
+                if (GetLevel10Dishes.length != 0) {
+                    text += '\n10级：\n' + Level10Dishes;
                 }
-                text += '名单如下：';
-                if (rows2.length != 0) {
-                    text += '\n10级：\n' + 十级料理信息结果;
+                if (GetLevel9Dishes.length != 0 && GetLevel10Dishes.length < config.料理_最低返回数量要求) {
+                    text += '\n9级：\n' + Level9Dishes;
                 }
-                if (rows3.length != 0 && rows2.length < config.料理_最低返回数量要求) {
-                    text += '\n9级：\n' + 九级料理信息结果;
-                }
-                if (rows2.length + rows3.length < config.料理_最低返回数量要求 && rows2.length + rows3.length > 0) {
-                    const rows5 = await ctx.database.get('toram_dishes', { $and: [{ type: [料理类型] }, { level: [8] }] });
-                    if (rows5.length != 0) {
-                        八级料理信息结果 = rows5.map((player) => {
+                if (GetLevel10Dishes.length + GetLevel9Dishes.length < config.料理_最低返回数量要求 && GetLevel10Dishes.length + GetLevel9Dishes.length > 0) {
+                    const GetLevel8Dishes = await ctx.database.get('toram_dishes', { $and: [{ type: [DishesType] }, { level: [8] }] });
+                    if (GetLevel8Dishes.length != 0) {
+                        Level8Dishes = GetLevel8Dishes.map((player) => {
                             return `${player?.name}`;
                         })
                             .sort();
-                        text += '\n8级：\n' + 八级料理信息结果;
+                        text += '\n8级：\n' + Level8Dishes;
                     }
                 }
                 text = text.replace(/,/g, '，');
                 return text;
             }
-            if (isNaN(Number(等级筛选)) || Number.isInteger(Number(等级筛选)) == false || 等级筛选 <= 0 || 等级筛选 > 10) {
+            if (isNaN(Number(DishesLevelChoice)) || Number.isInteger(Number(DishesLevelChoice)) == false || DishesLevelChoice <= 0 || DishesLevelChoice > 10) {
                 return '找不到！怎么想都找不到吧！';
             }
-            let 目标等级料理信息结果;
-            const rows2 = await ctx.database.get('toram_dishes', { $and: [{ type: [料理类型] }, { level: [等级筛选] }] });
+            let LevelChoiceDishes;
+            const rows2 = await ctx.database.get('toram_dishes', { $and: [{ type: [DishesType] }, { level: [DishesLevelChoice] }] });
             if (rows2.length != 0) {
-                目标等级料理信息结果 = rows2.map((player) => {
+                LevelChoiceDishes = rows2.map((player) => {
                     return `${player?.name}`;
                 })
                     .sort(function compareFunction(item1, item2) {
                     return item1.localeCompare(item2);
                 });
-                text = 料理类型;
-                if (料理类型 != 料理名称) {
-                    text += '(' + 料理名称 + ')';
-                }
-                text += 等级筛选 + '级名单如下：\n' + 目标等级料理信息结果;
+                text = DishesType + '(' + DishesEffect + ')' + DishesLevelChoice + '级名单如下：\n' + LevelChoiceDishes;
                 text = text.replace(/,/g, '，');
                 return text;
             }
             return '还没有记录有这个等级的这种料理呢——';
         }
     });
-    ctx.command('升级 <等级数>').action(async ({ session }, 等级) => {
+    ctx.command('升级 <等级数>').action(async ({ session }, PlayerLevel) => {
         {
-            const 经验 = Math.floor(等级 ** 4 / 40) + 等级 * 2;
-            if (等级 != undefined) {
-                if (isNaN(Number(等级)) || Number.isInteger(Number(等级)) == false || 等级 <= 0 || 等级 >= config.版本等级) {
+            const LevelUpExp = Math.floor(PlayerLevel ** 4 / 40) + PlayerLevel * 2;
+            if (PlayerLevel != undefined) {
+                if (isNaN(Number(PlayerLevel)) || Number.isInteger(Number(PlayerLevel)) == false || PlayerLevel <= 0 || PlayerLevel >= config.版本等级) {
                     return '没救了，别练了，埋了罢【无慈悲】';
                 }
-                ;
-                if (等级 < 38) {
-                    return 等级 + '级升级所需经验为' + 经验 + '\n亲亲，建议去尼山砍柴哦？';
+                if (PlayerLevel < 38) {
+                    return PlayerLevel + '级升级所需经验为' + LevelUpExp + '\n亲亲，建议去尼山砍柴哦？';
                 }
-                ;
-                if (等级 < 55) {
-                    return 等级 + '级升级所需经验为' + 经验 + '\n去女帝陵墓打只因骨龙吧~';
+                if (PlayerLevel < 55) {
+                    return PlayerLevel + '级升级所需经验为' + LevelUpExp + '\n去女帝陵墓打只因骨龙吧~';
                 }
-                ;
-                if (等级 >= 55) {
-                    const rows1 = await ctx.database.get('toram_boss', { level: { $gte: 等级 - 8, $lte: Math.min(等级 + 8, config.版本等级 + 3) } });
+                if (PlayerLevel >= 55) {
+                    const rows1 = await ctx.database.get('toram_boss', { level: { $gte: PlayerLevel - 8, $lte: Math.min(PlayerLevel + 8, config.版本等级 + 3) } });
                     const 等级符合定点王 = rows1.filter(row => row.type === '定点王');
                     n = 等级符合定点王.length - 1;
-                    text = 等级 + '级升级所需经验为' + 经验 + '\n\n定点王：\n';
+                    text = PlayerLevel + '级升级所需经验为' + LevelUpExp + '\n\n定点王：\n';
                     const 等级符合定点王经验 = 等级符合定点王.map((boss) => {
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        x = 等级差倍率[Math.abs(PlayerLevel - boss.level)] || 0;
                         return boss.baseEXP * x;
                     });
                     const 经验最大定点王索引 = 等级符合定点王经验.map((exp, i) => [exp, i])
@@ -191,7 +218,7 @@ async function apply(ctx, config) {
                         .map(([, i]) => i);
                     const 定点王信息结果 = 经验最大定点王索引.map(index => {
                         const boss = 等级符合定点王[index];
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        x = 等级差倍率[Math.abs(PlayerLevel - boss.level)] || 0;
                         return `${boss?.name} 等级${boss?.level} ${boss?.map} 经验值${boss?.baseEXP * x} ${boss?.element}属性`;
                     }).join('\n');
                     text += 定点王信息结果;
@@ -199,7 +226,7 @@ async function apply(ctx, config) {
                     n = 等级符合野王.length - 1;
                     text += '\n\n野王：\n';
                     const 等级符合野王经验 = 等级符合野王.map((boss) => {
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        x = 等级差倍率[Math.abs(PlayerLevel - boss.level)] || 0;
                         return boss.baseEXP * x;
                     });
                     const 经验最大野王索引 = 等级符合野王经验.map((exp, i) => [exp, i])
@@ -208,7 +235,7 @@ async function apply(ctx, config) {
                         .map(([, i]) => i);
                     const 野王信息结果 = 经验最大野王索引.map(index => {
                         const boss = 等级符合野王[index];
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        x = 等级差倍率[Math.abs(PlayerLevel - boss.level)] || 0;
                         return `${boss?.name} 等级${boss?.level} ${boss?.map} 经验值${boss?.baseEXP * x} ${boss?.element}属性`;
                     }).join('\n');
                     text += 野王信息结果;
@@ -300,25 +327,5 @@ async function apply(ctx, config) {
             return '你没有正在进行的组队';
         }
     });
-    ctx.middleware(async (session, next) => {
-        let { elements, messageId, userId, content } = session;
-        let isAt = {};
-        for (const element of elements) {
-            if (element.type == "at") {
-                if (element.attrs.id == config.机器人qq) {
-                    return '魔法书现有功能：\n①升级 等级数：查询该等级升级头目\n②天气预报：查看本次大更新的覆盖内容\n③料理 料理名称 [料理等级]：查询高级料理名单';
-                }
-            }
-        }
-        return next();
-    });
-    ctx.middleware((session, next) => {
-        if (session.content === '天气预报') {
-            return '【托拉姆物语3.24大更一览-哔哩哔哩】 https://b23.tv/cWX9yjU';
-        }
-        else {
-            return next;
-        }
-    });
 }
 exports.apply = apply;

package/package.json

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

package/readme.md

@@ -10,6 +10,18 @@ QQ：1874053520
 
 ————————————
 
+0.3.6
+
+料理查询功能优化【需要更新数据表】
+
+————————————
+
+0.3.5
+
+料理查询支持输入玩家昵称【需要数据表toram_dishes_effect】
+
+————————————
+
 0.3.4
 
 料理查询功能优化