koishi-plugin-toram 0.3.2 → 0.3.4

package/lib/index.d.ts

@@ -6,6 +6,7 @@ export interface Config {
     升级_定点王数量: number;
     升级_野王数量: number;
     组队_未来天数: number;
+    料理_最低返回数量要求: number;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: any, config: Config): Promise<void>;

package/lib/index.js

@@ -5,10 +5,11 @@ const koishi_1 = require("koishi");
 exports.name = 'toram';
 exports.Config = koishi_1.Schema.object({
     机器人qq: koishi_1.Schema.string().default('229968046'),
-    版本等级: koishi_1.Schema.number().default(240),
+    版本等级: koishi_1.Schema.number().default(245),
     升级_定点王数量: koishi_1.Schema.number().default(6),
     升级_野王数量: koishi_1.Schema.number().default(4),
     组队_未来天数: koishi_1.Schema.number().default(7),
+    料理_最低返回数量要求: koishi_1.Schema.number().default(15),
 });
 async function apply(ctx, config) {
     ctx.model.extend('toram_boss', {
@@ -22,6 +23,21 @@ async function apply(ctx, config) {
     }, {
         primary: 'id'
     });
+    ctx.model.extend('toram_dishes', {
+        id: 'number',
+        name: 'string',
+        type: 'string',
+        level: 'number'
+    }, {
+        primary: 'id'
+    });
+    ctx.model.extend('toram_dishes_name', {
+        id: 'number',
+        name: 'string',
+        type: 'string'
+    }, {
+        primary: 'id'
+    });
     ctx.model.extend('toram_team', {
         id: 'string',
         form: 'number',
@@ -40,6 +56,170 @@ async function apply(ctx, config) {
         '上午': 12 * 60 * 60 * 1000,
         '下午': 18 * 60 * 60 * 1000,
     };
+    ctx.command('料理 <料理种类> <料理等级>').action(async ({ session }, ...args) => {
+        {
+            let 料理名称 = args[0], 等级筛选 = args[1];
+            if (料理名称 == undefined) {
+                return '如果你要查询料理，请输入"料理 料理种类 [料理等级]"来进行查询哦';
+            }
+            const rows1 = await ctx.database.get('toram_dishes_name', { name: [料理名称] });
+            const 料理类型 = rows1[0]?.type || '不存在';
+            if (料理类型 == '不存在') {
+                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) => {
+                        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) => {
+                        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) {
+                            let alv = a.level;
+                            let blv = b.level;
+                            return b - a;
+                        });
+                        const 八级以下料理信息结果 = rows4.map((player) => {
+                            return `${player?.name}(${player?.level}级)`;
+                        })
+                            .sort(function compareFunction(item1, item2) {
+                            return item1.localeCompare(item2);
+                        });
+                        text = 料理类型;
+                        if (料理类型 != 料理名称) {
+                            text += '(' + 料理名称 + ')';
+                        }
+                        text += '名单如下：\n' + 八级以下料理信息结果;
+                        text = text.replace(/,/g, '，');
+                        return text;
+                    }
+                    return '还没有记录有这种料理呢——';
+                }
+                text = 料理类型;
+                if (料理类型 != 料理名称) {
+                    text += '(' + 料理名称 + ')';
+                }
+                text += '名单如下：';
+                if (rows2.length != 0) {
+                    text += '\n10级：\n' + 十级料理信息结果;
+                }
+                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) => {
+                            return `${player?.name}`;
+                        })
+                            .sort();
+                        text += '\n8级：\n' + 八级料理信息结果;
+                    }
+                }
+                text = text.replace(/,/g, '，');
+                return text;
+            }
+            if (isNaN(Number(等级筛选)) || Number.isInteger(Number(等级筛选)) == false || 等级筛选 <= 0 || 等级筛选 > 10) {
+                return '找不到！怎么想都找不到吧！';
+            }
+            let 目标等级料理信息结果;
+            const rows2 = await ctx.database.get('toram_dishes', { $and: [{ type: [料理类型] }, { level: [等级筛选] }] });
+            if (rows2.length != 0) {
+                目标等级料理信息结果 = rows2.map((player) => {
+                    return `${player?.name}`;
+                })
+                    .sort(function compareFunction(item1, item2) {
+                    return item1.localeCompare(item2);
+                });
+                text = 料理类型;
+                if (料理类型 != 料理名称) {
+                    text += '(' + 料理名称 + ')';
+                }
+                text += 等级筛选 + '级名单如下：\n' + 目标等级料理信息结果;
+                text = text.replace(/,/g, '，');
+                return text;
+            }
+            return '还没有记录有这个等级的这种料理呢——';
+        }
+    });
+    ctx.command('升级 <等级数>').action(async ({ session }, 等级) => {
+        {
+            const 经验 = Math.floor(等级 ** 4 / 40) + 等级 * 2;
+            if (等级 != undefined) {
+                if (isNaN(Number(等级)) || Number.isInteger(Number(等级)) == false || 等级 <= 0 || 等级 >= config.版本等级) {
+                    return '没救了，别练了，埋了罢【无慈悲】';
+                }
+                ;
+                if (等级 < 38) {
+                    return 等级 + '级升级所需经验为' + 经验 + '\n亲亲，建议去尼山砍柴哦？';
+                }
+                ;
+                if (等级 < 55) {
+                    return 等级 + '级升级所需经验为' + 经验 + '\n去女帝陵墓打只因骨龙吧~';
+                }
+                ;
+                if (等级 >= 55) {
+                    const rows1 = await ctx.database.get('toram_boss', { level: { $gte: 等级 - 8, $lte: Math.min(等级 + 8, config.版本等级 + 3) } });
+                    const 等级符合定点王 = rows1.filter(row => row.type === '定点王');
+                    n = 等级符合定点王.length - 1;
+                    text = 等级 + '级升级所需经验为' + 经验 + '\n\n定点王：\n';
+                    const 等级符合定点王经验 = 等级符合定点王.map((boss) => {
+                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        return boss.baseEXP * x;
+                    });
+                    const 经验最大定点王索引 = 等级符合定点王经验.map((exp, i) => [exp, i])
+                        .sort(([a], [b]) => b - a)
+                        .slice(0, Math.min(n + 1, config.升级_定点王数量))
+                        .map(([, i]) => i);
+                    const 定点王信息结果 = 经验最大定点王索引.map(index => {
+                        const boss = 等级符合定点王[index];
+                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        return `${boss?.name} 等级${boss?.level} ${boss?.map} 经验值${boss?.baseEXP * x} ${boss?.element}属性`;
+                    }).join('\n');
+                    text += 定点王信息结果;
+                    const 等级符合野王 = rows1.filter(row => row.type === '野王');
+                    n = 等级符合野王.length - 1;
+                    text += '\n\n野王：\n';
+                    const 等级符合野王经验 = 等级符合野王.map((boss) => {
+                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        return boss.baseEXP * x;
+                    });
+                    const 经验最大野王索引 = 等级符合野王经验.map((exp, i) => [exp, i])
+                        .sort(([a], [b]) => b - a)
+                        .slice(0, Math.min(n + 1, config.升级_野王数量))
+                        .map(([, i]) => i);
+                    const 野王信息结果 = 经验最大野王索引.map(index => {
+                        const boss = 等级符合野王[index];
+                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
+                        return `${boss?.name} 等级${boss?.level} ${boss?.map} 经验值${boss?.baseEXP * x} ${boss?.element}属性`;
+                    }).join('\n');
+                    text += 野王信息结果;
+                    return text;
+                }
+            }
+            else {
+                return '如果你要查询升级头目，请输入"升级 等级数"来进行查询哦';
+            }
+        }
+    });
     ctx.command('组队 <截止时间> <求组内容>').action(async ({ session }, ...args) => {
         const { userId, guildId } = session;
         const 当前时间date = new Date();
@@ -120,77 +300,13 @@ async function apply(ctx, config) {
             return '你没有正在进行的组队';
         }
     });
-    ctx.command('升级 <等级数>').action(async ({ session }, 等级) => {
-        {
-            if (等级 != undefined) {
-                if (isNaN(Number(等级)) || Number.isInteger(Number(等级)) == false || 等级 <= 0 || 等级 >= config.版本等级) {
-                    return '没救了，别练了，埋了罢【无慈悲】';
-                }
-                ;
-                if (等级 < 38) {
-                    const 回复语句数组 = [
-                        '亲亲，建议去尼山砍柴哦？',
-                        '可怜的孩子，快去恰尼木嘞——'
-                    ];
-                    n = 回复语句数组.length;
-                    return 回复语句数组[Math.ceil(Math.random() * n)];
-                }
-                ;
-                if (等级 < 55) {
-                    return '去女帝陵墓打只因骨龙吧~';
-                }
-                ;
-                if (等级 >= 55) {
-                    const rows1 = await ctx.database.get('toram_boss', { level: { $gte: 等级 - 8, $lte: Math.min(等级 + 8, config.版本等级 + 3) } });
-                    const 等级符合定点王 = rows1.filter(row => row.type === '定点王');
-                    n = 等级符合定点王.length - 1;
-                    text = '定点王：\n';
-                    const 等级符合定点王经验 = 等级符合定点王.map((boss) => {
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
-                        return boss.baseEXP * x;
-                    });
-                    const 经验最大定点王索引 = 等级符合定点王经验.map((exp, i) => [exp, i])
-                        .sort(([a], [b]) => b - a)
-                        .slice(0, Math.min(n + 1, config.升级_定点王数量))
-                        .map(([, i]) => i);
-                    const 定点王信息结果 = 经验最大定点王索引.map(index => {
-                        const boss = 等级符合定点王[index];
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
-                        return `${boss?.name} 等级${boss?.level} ${boss?.map} 经验值${boss?.baseEXP * x} ${boss?.element}属性`;
-                    }).join('\n');
-                    text += 定点王信息结果;
-                    const 等级符合野王 = rows1.filter(row => row.type === '野王');
-                    n = 等级符合野王.length - 1;
-                    text += '\n\n野王：\n';
-                    const 等级符合野王经验 = 等级符合野王.map((boss) => {
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
-                        return boss.baseEXP * x;
-                    });
-                    const 经验最大野王索引 = 等级符合野王经验.map((exp, i) => [exp, i])
-                        .sort(([a], [b]) => b - a)
-                        .slice(0, Math.min(n + 1, config.升级_野王数量))
-                        .map(([, i]) => i);
-                    const 野王信息结果 = 经验最大野王索引.map(index => {
-                        const boss = 等级符合野王[index];
-                        x = 等级差倍率[Math.abs(等级 - boss.level)] || 0;
-                        return `${boss?.name} 等级${boss?.level} ${boss?.map} 经验值${boss?.baseEXP * x} ${boss?.element}属性`;
-                    }).join('\n');
-                    text += 野王信息结果;
-                    return text;
-                }
-            }
-            else {
-                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③组队 时间/截止时间 求组内容：发布组队信息到组队大厅\n④组队大厅 页码数：查看组队大厅\n⑤取消组队：取消自己正在发布的组队';
+                    return '魔法书现有功能：\n①升级 等级数：查询该等级升级头目\n②天气预报：查看本次大更新的覆盖内容\n③料理 料理名称 [料理等级]：查询高级料理名单';
                 }
             }
         }

package/package.json

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

package/readme.md

@@ -3,10 +3,29 @@
 [![npm](https://img.shields.io/npm/v/koishi-plugin-toram?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-toram)
 
 基于koishi制作的托拉姆物语qq机器人插件
-code的lib文件夹里附带运行所需数据表，用sqlstudio打开.toram.db和.koishi.db，在.koishi.db中删去.toram.db中有的表并将.toram.db中的表复制到.koishi.db
-.koishi.db一般在Users下的\AppData\Roaming\Koishi\Desktop\data\instances\default
+
+由于技术力原因，运行所需数据表暂存在lib文件夹里(.toram.db)，需要手动导入
+
+QQ：1874053520
+
+————————————
+
+0.3.4
+
+料理查询功能优化
+
+————————————
+
+0.3.3
+
+新增料理查询功能【需要数据表toram_dishes及toram_dishes_name】
+
+————————————
 
 0.3.2
+
 本插件当前具有以下功能：
+
 1.升级查询【需要数据表toram_boss】
+
 2.组队大厅相关