@baipiaodajun/mcbots 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@baipiaodajun/mcbots",
-    "version": "1.2.1",
+    "version": "1.2.3",
     "description": "Minecraft bot and status dashboard for multi-server management",
     "main": "server.js",
     "scripts": {

package/server.js

@@ -10,6 +10,13 @@ const fs   = require('fs');
 const PORT = process.env.SERVER_PORT || process.env.PORT || 3000 ; 
 const CHAT = process.env.CHAT || false ; 
 const MOVE = process.env.MOVE || false ;
+//debug模式，只有开启时才会有很多日志。
+const DEBUG = (process.env.DEBUG || '').toLowerCase() === 'true';
+function debugPrint(...args) {
+  if (DEBUG) {
+    console.log(...args);
+  }
+}
 // Minecraft服务器配置
 const SERVERS = [
   {
@@ -124,7 +131,7 @@ const BOT_CONFIG = {
 
 const SERVER_CONFIG = {
   statusCheckInterval: 30000,
-  maxFailedAttempts: 3,
+  maxFailedAttempts: 1,
   resetTimeout: 30000
 };
 
@@ -207,6 +214,7 @@ class MinecraftBotManager {
     this.version = version || "1.20.1";
     this.currentBots = 0;
     this.activeBots = new Map();
+    this.pendingReconnect = new Set();   // 等待重连的机器人名字（已断开但优先重用名字）
     this.failedAttempts = 0;
     this.lastUpdate = Date.now();
     this.status = 'initializing';
@@ -300,19 +308,69 @@ class MinecraftBotManager {
       this.notice=true;
     }
   }
+  async handleBottimeout(bot,botName){
+    this.timeout = setTimeout(() => {
+      debugPrint(`[${this.host}:${this.port}] ${botName} 连接超时，强制终止`);
+    
+      // 第一步：尝试正常结束（推荐方式）
+      if (typeof bot.end === 'function') {
+        try {
+          bot.end();
+          debugPrint(`[${this.host}:${this.port}] ${botName} 调用 bot.end() 成功`);
+          return; // 如果正常结束，就不需要进一步操作
+        } catch (err) {
+          debugPrint(`[${this.host}:${this.port}] ${botName} bot.end() 抛出异常:`, err.message);
+          // 继续尝试强杀底层 socket
+        }
+      }
+    
+      // 第二步：bot.end 失败或不存在，强制关闭底层 client socket
+      if (bot._client?.socket) {
+        try {
+          bot._client.socket.destroy(); // 最彻底：直接 destroy socket
+          debugPrint(`[${this.host}:${this.port}] ${botName} 强制 destroy 底层 socket`);
+        } catch (err) {
+          debugPrint(`[${this.host}:${this.port}] ${botName} destroy socket 失败:`, err.message);
+        }
+      } else if (bot._client?.end) {
+        try {
+          bot._client.end();
+          debugPrint(`[${this.host}:${this.port}] ${botName} 调用 bot._client.end()`);
+        } catch (err) {
+          debugPrint(`[${this.host}:${this.port}] ${botName} bot._client.end() 失败:`, err.message);
+        }
+      } else {
+        debugPrint(`[${this.host}:${this.port}] ${botName} 无可用 client socket，无法强制关闭`);
+      }
+    
+      // 可选：触发断开处理（确保进入重连逻辑）
+      this.handleBotDisconnect(botName);
+    
+    }, BOT_CONFIG.connectTimeout);
+  }
   // 创建Minecraft机器人
   async createBot(botName) {
     if (this.currentBots >= this.maxBots) {
       console.log(`[${this.host}:${this.port}] 已达到最大机器人限制: ${this.maxBots}`);
       return null;
     }
-    await this.testmc();
-    if (!this.reachable) {
-      return null;
-    }
-    if(!botName){
-      botName = this.generateBotName();
+
+    if (!botName) {
+      if (this.pendingReconnect.size > 0) {
+        botName = this.pendingReconnect.keys().next().value;
+        this.pendingReconnect.delete(botName);  // 用完就移除，避免重复分配
+        debugPrint(`[${this.host}:${this.port}] 优先重用待重连名字: ${botName} (剩余待重连: ${this.pendingReconnect.size})`);
+      } else {
+        botName = this.generateBotName();
+        debugPrint(`[${this.host}:${this.port}] 无待重连名字，生成新名字: ${botName}`);
+      }
+    } else {
+      if (this.pendingReconnect.has(botName)) {
+        this.pendingReconnect.delete(botName);
+        debugPrint(`[${this.host}:${this.port}] 使用指定的重连名字: ${botName} (已从待重连名单移除)`);
+      }
     }
+
     try {
       console.log(`[${this.host}:${this.port}] 创建机器人: ${botName}`);
         const bot = mineflayer.createBot({
@@ -324,12 +382,7 @@ class MinecraftBotManager {
           auth: 'offline'
         });
 
-        this.timeout = setTimeout(() => {
-          console.error(`[${this.host}:${this.port}] ${botName}连接超时，放弃等待`);
-          if (typeof bot.end === 'function') {
-            bot.end(); 
-          }
-        }, BOT_CONFIG.connectTimeout);
+        this.handleBottimeout(bot,botName);
 
         // 设置机器人事件处理
         this.setupBotEvents(bot, botName);
@@ -340,7 +393,7 @@ class MinecraftBotManager {
         this.updateStatus();
         return bot;
     } catch (error) {
-      console.log(`[${this.host}:${this.port}] 创建机器人 ${botName} 失败:`, error.message);
+      debugPrint(`[${this.host}:${this.port}] 创建机器人 ${botName} 失败:`, error.message);
       this.handleBotFailure(botName);
       return null;
     }
@@ -354,19 +407,20 @@ class MinecraftBotManager {
         clearTimeout(this.timeout);
         this.timeout = null;
       }
+      this.failedAttempts = 0;
+      this.pendingReconnect.delete(botName);
       this.updateStatus();
     });
 
     bot.on('spawn', () => {
-      console.log(`[${this.host}:${this.port}] 机器人 ${botName} 生成在世界中`);
-      
+      debugPrint(`[${this.host}:${this.port}] 机器人 ${botName} 生成在世界中`);
       // 机器人基础行为
       this.setupBotBehavior(bot, botName);
     });
 
     bot.on('message', (message) => {
       const text = message.toString();
-      console.log(`[${this.host}:${this.port}] ${botName} 收到消息: ${text}`);
+      debugPrint(`[${this.host}:${this.port}] ${botName} 收到消息: ${text}`);
     });
 
     bot.on('error', (error) => {
@@ -380,7 +434,7 @@ class MinecraftBotManager {
 
     bot.on('end', (reason) => {
       console.log(`[${this.host}:${this.port}] 机器人 ${botName} 断开连接:`, reason);
-      console.log(`[${this.host}:${this.port}] ${botName}:失败次数${this.failedAttempts}`);
+      // console.log(`[${this.host}:${this.port}] ${botName}:失败次数${this.failedAttempts}`);
       this.handleBotDisconnect(botName);
     });
 
@@ -419,27 +473,21 @@ class MinecraftBotManager {
     }
   }
 
-  // 处理机器人断开连接 - 增强版本
   handleBotDisconnect(botName) {
     if (this.activeBots.has(botName)) {
-      console.log(`[${this.host}:${this.port}] 从活跃列表中移除机器人: ${botName}`);
+      debugPrint(`[${this.host}:${this.port}] 从活跃列表中移除机器人: ${botName}`);
       this.activeBots.delete(botName);
       this.currentBots = Math.max(0, this.currentBots - 1);
       this.updateStatus();
-      
-      // 记录断开连接时间，用于调试
-      console.log(`[${this.host}:${this.port}] 当前活跃机器人数量: ${this.currentBots}, 目标: ${this.minBots}`);
-      
-      if(this.failedAttempts > SERVER_CONFIG.maxFailedAttempts){
-        console.log(`[${this.host}:${this.port}] 机器人 ${botName} 重连次数太多，跳过`);
-        return;
-      }
-      // 延迟重连，避免频繁重连
+      this.pendingReconnect.add(botName);
+      debugPrint(`[${this.host}:${this.port}] 当前活跃机器人数量: ${this.currentBots}, 目标: ${this.minBots}`);
+  
       setTimeout(() => {
         this.reconnect(botName);
       }, BOT_CONFIG.reconnectDelay);
+  
     } else {
-      console.log(`[${this.host}:${this.port}] 机器人 ${botName} 不在活跃列表中，无需处理`);
+      debugPrint(`[${this.host}:${this.port}] 机器人 ${botName} 不在活跃列表中，无需处理`);
     }
   }
   
@@ -447,62 +495,63 @@ class MinecraftBotManager {
   handleBotFailure(botName) {
     this.failedAttempts++;
     this.updateStatus();
-    if (this.failedAttempts >= SERVER_CONFIG.maxFailedAttempts) {
-      console.log(`[${this.host}:${this.port}] 失败次数过多，${SERVER_CONFIG.resetTimeout / 1000}秒后再次尝试`);
-      setTimeout(() => {
-        this.failedAttempts = 0;
-        this.reconnect(botName);
-      }, SERVER_CONFIG.resetTimeout);
-      return;
-    }
-    setTimeout(() => {
-      this.reconnect(botName);
-    }, BOT_CONFIG.reconnectDelay);
+    this.reconnect(botName);
   }
 
   // 维护机器人数目 - 增强版本
-  maintainBots() {
-    const neededBots = this.minBots - this.currentBots;
-    
-    // console.log(`[${this.host}:${this.port}] 当前机器人: ${this.currentBots}, 需要: ${neededBots}, 失败次数: ${this.failedAttempts}`);
-    if (neededBots > 0 && this.failedAttempts < SERVER_CONFIG.maxFailedAttempts) {
-      if (this.notice) {
-        console.log(`[${this.host}:${this.port}] 需要启动 ${neededBots} 个机器人`);
-        this.notice=false;
-      }
-      for (let i = 0; i < neededBots; i++) {
-        setTimeout(() => {
-          this.createBot();
-        }, i * 8000); // 每隔8秒启动一个
+  async maintainBots() {
+    const neededBots =  this.minBots -this.currentBots;
+    try {
+      debugPrint(`[${this.host}:${this.port}] 当前机器人: ${this.currentBots}, 需要: ${neededBots}, 失败次数: ${this.failedAttempts}`);
+      await this.testmc();
+      if (!this.reachable) {
+        return null;
       }
-    } 
-    // else if (neededBots > 0) {
-    //   console.log(`[${this.host}:${this.port}] 由于失败次数过多，暂停创建新机器人`);
-    // }
-    this.updateStatus();
+      if (neededBots > 0 && this.failedAttempts < SERVER_CONFIG.maxFailedAttempts) {
+        if (this.notice) {
+          console.log(`[${this.host}:${this.port}] 需要启动 ${neededBots} 个机器人`);
+          this.notice=false;
+        }
+        for (let i = 0; i < neededBots; i++) {
+          setTimeout(() => {
+            this.createBot();
+          }, i * 8000); // 每隔8秒启动一个
+        }
+      } 
+      this.updateStatus();
+    }
+    catch (err) {
+      console.error(`[${this.host}:${this.port}] maintainBots 异常:`, err);
+    }
   }
-  reconnect(botName){
-    if (this.failedAttempts < SERVER_CONFIG.maxFailedAttempts) {
-      console.log(`[${this.host}:${this.port}] 第${this.failedAttempts}次重连 ${botName} 机器人`);
-      this.failedAttempts++;
-        setTimeout(() => {
-          this.createBot(botName);
-        }, 5000); 
-    } else{
-      // 如果还没有设置过 resetTimer，就设置一次
+
+  reconnect(botName) {
+    if (this.failedAttempts >= SERVER_CONFIG.maxFailedAttempts) {
       if (!this.resetTimer) {
         this.resetTimer = setTimeout(() => {
           this.failedAttempts = 0;
-          this.resetTimer = null; // 清理标记，允许下次再设置
-          console.log(
-            `[${this.host}:${this.port}] 失败次数已重置，可以重新尝试创建机器人`
-          );
+          this.resetTimer = null;
+          debugPrint(`[${this.host}:${this.port}] 冷却期结束，恢复维护`);
+          this.maintainBots();
         }, SERVER_CONFIG.resetTimeout);
+        debugPrint(`[${this.host}:${this.port}] 失败过多，进入冷却 ${ SERVER_CONFIG.resetTimeout/ 1000}s`);
       }
-      console.log(`[${this.host}:${this.port}] 由于失败次数过多，暂停创建新机器人`);
+      return;
     }
-    this.updateStatus();
+
+    this.failedAttempts++;
+
+    // 如果传入 botName（来自断开重连），且它还在待重连名单中 → 优先用原名字
+    if (botName && this.pendingReconnect.has(botName)) {
+      debugPrint(`[${this.host}:${this.port}] 第 ${this.failedAttempts} 次尝试重连原机器人: ${botName}`);
+      this.createBot(botName);  // 传名字，保持固定
+      return;
+    }
+    // 否则（新补人或名字已被放弃）→ 不传名字，生成新的
+    debugPrint(`[${this.host}:${this.port}] 第 ${this.failedAttempts} 次连接失败，触发维护补人`);
+    this.maintainBots();
   }
+
   // 更新状态
   updateStatus() {
     const serverInfo = globalServerStatus.servers.get(`${this.host}:${this.port}`);
@@ -1638,6 +1687,16 @@ function shutdown() {
 
 // 启动
 if (require.main === module) {
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('未处理的 Promise Rejection:', reason);
+    // 不退出进程，但至少能看到问题
+  });
+
+  process.on('uncaughtException', (error) => {
+    console.error('未捕获的异常:', error);
+    // process.exit(1);
+  });
+  
   initialize().catch(error => {
     console.error('初始化失败:', error);
     process.exit(1);