koishi-plugin-dew-bot 1.0.206 → 1.0.208

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.inject = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+const inits_1 = __importDefault(require("./inits"));
+exports.name = 'dew-bot';
+exports.inject = ['puppeteer'];
+exports.Config = koishi_1.Schema.object({
+    // ws://127.0.0.1:3009
+    服务器地址: koishi_1.Schema.string().default('ws://dew-bot.cn:3009').description('游戏服地址'),
+});
+function apply(ctx, config) {
+    ctx.plugin(inits_1.default, config);
+}

package/{lib → dist}/inits.js

@@ -19,25 +19,12 @@ function apply(ctx, config) {
     server_1.default.init(ctx, config);
     // 设置连接成功后的回调
     server_1.default.onConnected(() => {
-        try {
-            server_1.default.lisentMsg('Message', ((data) => {
-                try {
-                    // 使用消息队列处理消息
-                    const success = messageQueue_1.messageQueue.addToQueue(data, ctx);
-                    if (!success) {
-                        console.error('消息队列已满，无法处理新消息');
-                    }
-                }
-                catch (error) {
-                    console.error('添加消息到队列失败:', error);
-                }
-            }), this);
-        }
-        catch (error) {
-            console.error('消息监听设置失败:', error);
-        }
+        server_1.default.lisentMsg('Message', ((data) => {
+            messageQueue_1.messageQueue.addToQueue(data, ctx);
+        }), this);
     });
-    ctx.on('dispose', () => {
-        messageQueue_1.messageQueue.clearQueue();
+    /** 监听消息 上传到服务器 **/
+    ctx.on('message', (session) => {
+        server_1.default.uploadMessage(session);
     });
 }

package/{lib → dist}/plugin/messageQueue.js

@@ -9,7 +9,6 @@ class MessageQueue {
     queue = [];
     isProcessing = false;
     processingTimeout = null;
-    MAX_QUEUE_SIZE = 9999; // 最大队列长度
     PROCESSING_TIMEOUT = 5000; // 5秒处理超时
     initialized = false;
     ctx;
@@ -21,8 +20,13 @@ class MessageQueue {
      */
     init(ctx) {
         this.ctx = ctx;
-        console.log('初始化消息队列');
         this.initialized = true;
+        ctx.on('dispose', () => {
+            this.dispose();
+        });
+    }
+    dispose() {
+        this.clearQueue();
     }
     /**
      * 添加消息到队列
@@ -32,9 +36,6 @@ class MessageQueue {
      */
     addToQueue(data, ctx) {
         // 检查队列是否已满
-        if (this.queue.length >= this.MAX_QUEUE_SIZE) {
-            return false;
-        }
         const queueItem = {
             id: this.generateQueueId(),
             data,
@@ -99,7 +100,8 @@ class MessageQueue {
      */
     async processMessage(item) {
         try {
-            const module = require(`./serverHandel/${item.data.action}`).default;
+            const handleType = item.data.handleType;
+            const module = require(`./serverHandel/${handleType}`).default;
             let handel = new module(item.data);
             handel.set(item.ctx);
             await handel.start(item.data);
@@ -126,7 +128,7 @@ class MessageQueue {
         this.queue = [];
         this.isProcessing = false;
         this.processingTimeout = null;
-        console.log('队列已清空');
+        console.log('messageQueue:clear');
     }
 }
 exports.MessageQueue = MessageQueue;

package/{lib → dist}/plugin/puppeteer.js

@@ -6,16 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const koishi_1 = require("koishi");
 const path = require('path');
-const console_1 = require("./console");
-class puppeteer extends console_1.console {
+class puppeteer {
     commonCss;
     pageContents = new Map();
     ctx;
     tempDir;
     init(ctx, config) {
-        super.init(ctx);
         this.ctx = ctx;
-        this.log('初始化 puppeteer');
+        console.info('初始化 puppeteer');
         const pagesDir = path.resolve(__dirname, '../html/page');
         const files = fs_1.default.readdirSync(pagesDir);
         this.tempDir = path.resolve(path.resolve(__dirname, '../html/'), 'temp');
@@ -63,7 +61,7 @@ class puppeteer extends console_1.console {
             page.close();
             let leaderboardImage;
             // if (sendBuff.length < 200 * 1024) { // 如果小于200kb
-            this.log(`not compress ${sendBuff.length / 1024}KB`);
+            console.info(`not compress ${sendBuff.length / 1024}KB`);
             leaderboardImage = koishi_1.h.image(sendBuff, 'image/jpeg');
             // } else {
             // let req = await server.api('open/CompressImg', { imgBuf: sendBuff });
@@ -74,7 +72,7 @@ class puppeteer extends console_1.console {
         }
         catch (error) {
             page.close();
-            this.log(error);
+            console.error(error);
         }
     }
 }

package/{lib → dist}/plugin/server.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const tsrpc_1 = require("tsrpc");
-const console_1 = require("./console");
-const serviceProto_1 = require("../shared/serviceProto");
-class server extends console_1.console {
+const serviceProto_1 = require("../shared/bot/serviceProto");
+const sessions_1 = __importDefault(require("./sessions"));
+class server {
     httpClient;
     apiUrl;
     wsClient;
@@ -12,10 +15,8 @@ class server extends console_1.console {
     messageListenerSetup = false; // 标记消息监听器是否已设置
     _init = false;
     constructor() {
-        super();
     }
     async init(ctx, config) {
-        super.init(ctx, config);
         this.ctx = ctx;
         // 设置 dispose 事件监听器
         ctx.on('dispose', () => {
@@ -26,22 +27,16 @@ class server extends console_1.console {
         if (this.wsClient) {
             await this.dispose();
         }
-        // 根据服务器环境选择对应的地址
-        const serverUrlMap = {
-            '测试服': 'ws://127.0.0.1:3000',
-            '开发服': 'ws://dew-bot.cn:3000',
-            '正式服': 'ws://dew-bot.cn:3000'
-        };
-        const serverUrl = serverUrlMap[config.服务器环境];
-        if (!serverUrl) {
-            throw new Error(`未知的服务器环境: ${config.服务器环境}`);
+        /** 直接使用配置中的服务器地址 **/
+        const serverUrl = config.服务器地址;
+        if (!serverUrl || serverUrl.trim() === '') {
+            throw new Error('服务器地址不能为空');
         }
-        this.log(`选择环境: ${config.服务器环境}`);
-        this.log(`尝试连接到: ${serverUrl}`);
-        // 异步连接但不阻塞初始化
+        console.log(`尝试连接到: ${serverUrl}`);
+        /** 异步连接但不阻塞初始化 **/
         this.setWsUrl(serverUrl).catch(error => {
-            this.log('初始化连接失败:', error);
-            this.log('请检查服务器地址是否正确，以及服务器是否正在运行');
+            console.log('初始化连接失败:', error);
+            console.log('请检查服务器地址是否正确，以及服务器是否正在运行');
         });
     }
     // 设置连接成功的回调
@@ -55,7 +50,7 @@ class server extends console_1.console {
     }
     // 卸载
     async dispose() {
-        this.log('卸载:server');
+        console.log('卸载:server');
         this._init = false;
         if (this.wsClient) {
             this.wsClient.unlistenMsgAll(/.*/);
@@ -91,13 +86,13 @@ class server extends console_1.console {
     }
     flowsResConnect(client) {
         if (!client || !client.flows) {
-            this.log('客户端无效，无法设置断线重连');
+            console.log('客户端无效，无法设置断线重连');
             return;
         }
         client.flows.postDisconnectFlow.push((v) => {
             if (!v.isManual && this._init) {
                 this.connect();
-                this.log('开始断线重连');
+                console.log('开始断线重连');
             }
             // Bot_client.emit(Emitter_bot.server_off);
             return v;
@@ -105,16 +100,16 @@ class server extends console_1.console {
     }
     async connect() {
         if (!this._init) {
-            this.log('插件已卸载，停止重连');
+            console.log('插件已卸载，停止重连');
             return;
         }
         if (!this.wsClient) {
-            this.log('WebSocket 客户端未初始化，无法重连');
+            console.log('WebSocket 客户端未初始化，无法重连');
             return;
         }
         let res = await this.wsClient.connect();
         if (!res.isSucc) {
-            this.log('重试断线准备重连');
+            console.log('重试断线准备重连');
             if (this._init) {
                 this.ctx.setTimeout(async () => {
                     this.connect();
@@ -122,20 +117,20 @@ class server extends console_1.console {
             }
         }
         else {
-            this.log('断线重连成功');
+            console.log('断线重连成功');
             // 断线重连成功时不需要重新设置监听器
         }
         return res;
     }
     lisentMsg(msgName, handler, self) {
         if (!this._init || !this.wsClient) {
-            this.log('WebSocket 未连接，无法监听消息');
+            console.log('WebSocket 未连接，无法监听消息');
             return;
         }
         return this.wsClient.listenMsg(msgName, ((data) => { handler.call(self, data); }));
     }
     async setWsUrl(link, maxRetries = 99999) {
-        this.log(`server link:${link}`);
+        console.log(`server link:${link}`);
         this._init = true;
         return new Promise(async (resolve, reject) => {
             this.apiUrl = link;
@@ -153,7 +148,7 @@ class server extends console_1.console {
                     if (this.wsClient) {
                         this.flowsResConnect(this.wsClient);
                     }
-                    this.log('connect success');
+                    console.log('connect success');
                     // 调用连接成功的回调（仅第一次连接）
                     if (this.onConnectedCallback && !this.messageListenerSetup) {
                         this.onConnectedCallback();
@@ -164,11 +159,11 @@ class server extends console_1.console {
                 else {
                     retryCount++;
                     if (retryCount < maxRetries) {
-                        this.log(`连接失败，${retryCount}/${maxRetries}，5秒后重试...`);
+                        console.log(`连接失败，${retryCount}/${maxRetries}，5秒后重试...`);
                         this.ctx.setTimeout(attemptConnect, 5000);
                     }
                     else {
-                        this.log('connect failed', connect.errMsg);
+                        console.log('connect failed', connect.errMsg);
                         this._init = false; // 连接失败时设置为未初始化状态
                         reject(connect.errMsg);
                     }
@@ -179,28 +174,46 @@ class server extends console_1.console {
     }
     async api(apiName, posData) {
         if (!this._init) {
-            this.log('插件未初始化，无法调用 API');
+            console.log('插件未初始化，无法调用 API');
             return;
         }
         let client = this.wsClient || this.httpClient;
         if (!client) {
-            this.log('客户端未连接，无法调用 API');
+            console.log('客户端未连接，无法调用 API');
             return;
         }
         try {
             let start = Date.now();
             let req = await client.callApi(apiName, posData);
             if (req.isSucc) {
-                this.log('apiReq', apiName, (Date.now() - start) / 1000, 's');
+                console.log('apiReq', apiName, (Date.now() - start) / 1000, 's');
                 return req.res;
             }
             else {
-                this.log('请求出错', apiName, req.err.message);
+                console.log('请求出错', apiName, req.err.message);
             }
         }
         catch (error) {
-            this.log('API 调用异常:', apiName, error.message);
+            console.log('API 调用异常:', apiName, error.message);
         }
     }
+    /**bot专属业务逻辑 */
+    uploadMessage(session) {
+        /** 存储会话信息 **/
+        sessions_1.default.set(session.author.id, session);
+        /** 发送消息到服务器 **/
+        this.api('Message', {
+            bot: {
+                id: session.bot.userId,
+                platform: session.bot.platform,
+            },
+            user: {
+                id: session.author.id,
+            },
+            content: session.content,
+        }).catch(error => {
+            console.error('发送消息到服务器失败:', error);
+        });
+    }
 }
 exports.default = new server();

package/{lib → dist}/plugin/serverHandel/handel_base.js

@@ -7,21 +7,26 @@ const sessions_1 = __importDefault(require("../sessions"));
 class handel_base {
     ctx;
     constructor(data) {
-        console.log('handel_base:::', data);
+        // console.log('handel_base:::', data)
     }
     set(ctx) {
         this.ctx = ctx;
     }
     async send(data, content) {
-        let sendInfo = data.Message;
-        let session = sessions_1.default.get(sendInfo.userId);
-        if (session.bot.platform) {
-            content = '\n' + content;
+        // console.log('handel_base:::send', data, content)
+        // let sendInfo = data.Message;
+        let session = sessions_1.default.get(data.userId);
+        if (!session) {
+            this.ctx.logger.info('session not found', data.userId);
+            return;
         }
+        // if(session.bot.platform){
+        //     content = '\n' + content;
+        // }
         await session.send(content);
     }
     start(data) {
-        console.log('handel_base:::', data);
+        // console.log('handel_base:::', data)
     }
 }
 exports.default = handel_base;

package/{lib → dist}/plugin/serverHandel/image.js

@@ -3,17 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const puppeteer_1 = __importDefault(require("../puppeteer"));
 const handel_base_1 = __importDefault(require("./handel_base"));
 class handelr_image extends handel_base_1.default {
     constructor(data) {
         super(data);
     }
     async start(data) {
-        let renderName = data.info.render;
-        puppeteer_1.default.render(renderName, data.data || {}).then(async (e) => {
-            await this.send(data, e);
-        });
+        // let renderName = data.info.render;
+        // puppeteer.render(renderName, data.data || {}).then(async (e) => {
+        //     await this.send(data, e)
+        // })
     }
 }
 exports.default = handelr_image;

package/{lib → dist}/plugin/serverHandel/text.js

@@ -3,13 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const analysisMsg_1 = require("../../shared/bot/analysisMsg");
 const handel_base_1 = __importDefault(require("./handel_base"));
 class handelr_text extends handel_base_1.default {
     constructor(data) {
         super(data);
     }
     async start(data) {
-        await this.send(data, data.data);
+        let content = new analysisMsg_1.AnalysisMsg().parse(data);
+        await this.send(data, content);
     }
 }
 exports.default = handelr_text;

package/{lib → dist}/plugin/sessions.js

@@ -7,6 +7,8 @@ class sessions {
     }
     init(ctx) {
         ctx.on('dispose', () => {
+            console.log('sessions clear');
+            this.clear();
         });
     }
     /**

package/dist/shared/bot/AnalysisClass/class_battleLog.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 数据格式： I战斗结束Data
+ * 由于此文件在 shared 文件夹，不能引用服务器类型定义
+ * 以下类型定义仅用于说明数据结构，实际使用时通过 any 接收
+ */
+/** 战斗胜者枚举 */
+var IBattleWinner;
+(function (IBattleWinner) {
+    IBattleWinner[IBattleWinner["\u4E3B\u573A\u80DC\u5229"] = 0] = "\u4E3B\u573A\u80DC\u5229";
+    IBattleWinner[IBattleWinner["\u5BA2\u573A\u80DC\u5229"] = 1] = "\u5BA2\u573A\u80DC\u5229";
+    IBattleWinner[IBattleWinner["\u5E73\u5C40"] = 2] = "\u5E73\u5C40";
+})(IBattleWinner || (IBattleWinner = {}));
+class class_battleLog {
+    constructor() {
+        return this;
+    }
+    /** 格式化战斗日志数据为文本 */
+    analysis(data) {
+        const battleData = data.content;
+        if (!battleData) {
+            return '战斗数据为空\n';
+        }
+        let result = '';
+        /** 战斗结果 */
+        result += this.formatBattleResult(battleData);
+        /** Flarum战斗日志链接 */
+        if (battleData.flarumUrl) {
+            result += `📋战斗日志：${battleData.flarumUrl}\n`;
+        }
+        /** 奖励信息 */
+        result += this.formatRewards(battleData);
+        return result;
+    }
+    /** 格式化战斗结果 */
+    formatBattleResult(battleData) {
+        let result = '';
+        /** 优先使用个性化战斗结果 */
+        const personalResult = battleData.personalResult;
+        if (personalResult?.emoji && personalResult?.text) {
+            result += ` ┄━═${personalResult.emoji}${personalResult.text}═━┄\n`;
+            result += `⏱️ 战斗回合：${battleData.totalRounds}\n`;
+            return result;
+        }
+        /** 战斗结果 */
+        const winner = battleData.winner;
+        let winnerText = '未知';
+        let emoji = '❓';
+        switch (winner) {
+            case IBattleWinner.主场胜利:
+                winnerText = '主场胜利';
+                emoji = '🎉';
+                break;
+            case IBattleWinner.客场胜利:
+                winnerText = '客场胜利';
+                emoji = '💀';
+                break;
+            case IBattleWinner.平局:
+                winnerText = '旗鼓相当';
+                emoji = '🤝';
+                break;
+        }
+        result += ` ┄━═${emoji}${winnerText}═━┄\n`;
+        result += `⏱️ 战斗回合：${battleData.totalRounds}\n`;
+        return result;
+    }
+    /** 格式化奖励信息 */
+    formatRewards(battleData) {
+        let result = '';
+        if (!battleData.rewards) {
+            return result;
+        }
+        /** rewards 是一个 Map<string, I单位奖励> */
+        const rewards = battleData.rewards;
+        /** 检查是否有奖励 */
+        let hasRewards = false;
+        if (rewards instanceof Map && rewards.size > 0) {
+            hasRewards = true;
+        }
+        else if (typeof rewards === 'object' && Object.keys(rewards).length > 0) {
+            hasRewards = true;
+        }
+        if (!hasRewards) {
+            return result;
+        }
+        /** 添加战斗收获分隔线 */
+        result += ` ┄━═🎉战斗收获═━┄\n`;
+        /** 遍历奖励 */
+        const rewardsIterator = rewards instanceof Map ? rewards.entries() : Object.entries(rewards);
+        for (const [unitId, unitReward] of rewardsIterator) {
+            if (!unitReward)
+                continue;
+            /** 显示所有奖励物品 */
+            if (unitReward.items && unitReward.items.length > 0) {
+                unitReward.items.forEach((item) => {
+                    result += `${item.icon}${item.name}+${item.count}\n`;
+                });
+            }
+        }
+        return result;
+    }
+}
+exports.default = new class_battleLog();