@baipiaodajun/mcbots 1.0.4 → 1.0.6

package/README.md

@@ -1,6 +1,16 @@
 # 🛡️ Minecraft 保活机器人及监控面板 - @baipiaodajun/mcbots
 
+## 特性
+
+- 多服务器配置：支持通过 SERVERS_JSON 文件一次性定义多个 MC 服务器，并为每个服务器自动创建对应的机器人连接。
+- 智能网络检测：支持连接超时监控，自动在 30 秒后尝试重连。
+- 实时监控面板：机器人运行状态即时更新，便于统一管理与观察。
+- 多实例支持：同一服务器可同时连接并管理多个机器人。
+- 可配置行为变量：通过设置 CHAT 与 MOVE 环境变量，灵活控制机器人聊天或移动行为。
+
+
 ## 用法
+
 ### nodejs
 新建一个 index.js 文件，内容如下：
 其中内容替换成你自己的MC服务器地址和端口，其他可以根据情况改变，可以添加多台服务器。
@@ -30,7 +40,7 @@ process.on('SIGTERM', shutdown);
     "start": "node index.js"
   },
   "dependencies": {
-    "@baipiaodajun/mcbots": "^1.0.4"
+    "@baipiaodajun/mcbots": "latest"
   }
 }
 ```

package/package.json

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

package/server.js

@@ -1,7 +1,9 @@
 const mineflayer = require('mineflayer');
 const express = require('express');
+const net = require('net');
 const PORT = process.env.SERVER_PORT || process.env.PORT || 3000 ; 
-const CHAT = process.env.CHAT || false
+const CHAT = process.env.CHAT || false ; 
+const MOVE = process.env.MOVE || false ;
 // Minecraft服务器配置
 const SERVERS = [
   {
@@ -25,24 +27,58 @@ if (process && process.env && process.env.SERVERS_JSON) {
     console.error('原因:', error.message);
     console.error('原始内容:\n', process.env.SERVERS_JSON);
     console.error('请检查 JSON 格式是否正确，例如引号、逗号是否缺失');
-    console.error('容器即将退出...');
+    console.error('即将退出...');
     process.exit(1);
   }
 }
+/**
+ * 测试 IP 和端口是否可达
+ * @param {string} host - IP 或域名
+ * @param {number} port - 端口号
+ * @param {number} timeoutMs - 超时时间（毫秒）
+ * @returns {Promise<boolean>}
+ */
+function testConnection(host, port, timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+
+    // 成功连接
+    socket.once('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+
+    // 出错或拒绝连接
+    socket.once('error', () => {
+      socket.destroy();
+      resolve(false);
+    });
 
+    // 超时
+    socket.setTimeout(timeoutMs, () => {
+      socket.destroy();
+      resolve(false);
+    });
+
+    // 尝试连接
+    socket.connect(port, host);
+  });
+}
 // 配置常量
 const BOT_CONFIG = {
   reconnectDelay: 5000,
   maxReconnectAttempts: 5,
   healthCheckInterval: 60000,
   viewDistance: 4,
-  chat: CHAT
+  connectTimeout: 2000,
+  chat: CHAT,
+  move: MOVE
 };
 
 const SERVER_CONFIG = {
   statusCheckInterval: 30000,
-  maxFailedAttempts: 5,
-  resetTimeout: 180000
+  maxFailedAttempts: 3,
+  resetTimeout: 30000
 };
 
 // 全局状态存储
@@ -56,15 +92,13 @@ function generateUsername() {
   ];
   
   const animals = [
-      'Fox', 'Wolf', 'Bear', 'Panda', 'Tiger', 'Eagle', 'Shark',
-      'Mole', 'Badger', 'Otter', 'Raccoon', 'Frog', 'Hedgehog'
+    'Fox', 'Wolf', 'Bear', 'Panda', 'Tiger', 'Eagle', 'Shark',
+    'Mole', 'Badger', 'Otter', 'Cat', 'Frog', 'Dog'
   ];
   
   const adjective = adjectives[Math.floor(Math.random() * adjectives.length)];
   const animal = animals[Math.floor(Math.random() * animals.length)];
-  const number = Math.random() > 0.5 ? Math.floor(Math.random() * 99) : ''; // 50% 加数字
-  
-  return `${adjective}${animal}${number}`;
+  return `${adjective}${animal}`;
 }
 // Minecraft机器人管理器
 class MinecraftBotManager {
@@ -80,13 +114,11 @@ class MinecraftBotManager {
     this.lastUpdate = Date.now();
     this.status = 'initializing';
     this.monitoringInterval = null;
-    
+    this.timeout= null;
+    this.reachable=false;
+    this.lastReachable = null;
     // 机器人名称池
-    this.botNames = [
-      generateUsername(),
-      generateUsername(),
-      generateUsername()
-    ];
+    this.botNames = Array.from({ length: 20 }, () => generateUsername());
     
     // 注册到全局状态
     globalServerStatus.servers.set(`${host}:${port}`, {
@@ -107,41 +139,62 @@ class MinecraftBotManager {
     const randomNum = Math.floor(Math.random() * 1000);
     return `${baseName}${randomNum}`;
   }
-
+  async testmc() {
+    const reachable = await testConnection(this.host, this.port, 3000);
+    this.reachable = reachable;
+
+    // 只有状态发生变化时才通知
+    if (this.reachable !== this.lastReachable) {
+      if (!this.reachable) {
+        console.log(`[${this.host}:${this.port}] MC服务器网络不可达`);
+      } else {
+        console.log(`[${this.host}:${this.port}] MC服务器恢复可达`);
+      }
+      this.lastReachable = this.reachable; 
+    }
+  }
   // 创建Minecraft机器人
-  async createBot() {
+  async createBot(botName) {
     if (this.currentBots >= this.maxBots) {
       console.log(`[${this.host}:${this.port}] 已达到最大机器人限制: ${this.maxBots}`);
       return null;
     }
-
-    const botName = this.generateBotName();
-    
+    await this.testmc();
+    if (!this.reachable) {
+      return null;
+    }
+    if(!botName){
+      botName = this.generateBotName();
+    }
     try {
       console.log(`[${this.host}:${this.port}] 创建机器人: ${botName}`);
-      
-      const bot = mineflayer.createBot({
-        host: this.host,
-        port: this.port,
-        username: botName,
-        version: this.version,
-        viewDistance: BOT_CONFIG.viewDistance,
-        auth: 'offline'
-      });
-
-      // 设置机器人事件处理
-      this.setupBotEvents(bot, botName);
-
-      this.activeBots.set(botName, bot);
-      this.currentBots++;
-      this.failedAttempts = 0;
-      this.updateStatus();
-
-      return bot;
-
+        const bot = mineflayer.createBot({
+          host: this.host,
+          port: this.port,
+          username: botName,
+          version: this.version,
+          viewDistance: BOT_CONFIG.viewDistance,
+          auth: 'offline'
+        });
+
+        this.timeout = setTimeout(() => {
+          console.error(`[${this.host}:${this.port}] ${botName}连接超时，放弃等待`);
+          if (typeof bot.end === 'function') {
+            bot.end(); 
+          }
+        }, BOT_CONFIG.connectTimeout);
+
+        // 设置机器人事件处理
+        this.setupBotEvents(bot, botName);
+
+        this.activeBots.set(botName, bot);
+        this.currentBots++;
+        // this.failedAttempts = 0;
+        this.updateStatus();
+        return bot;
     } catch (error) {
       console.log(`[${this.host}:${this.port}] 创建机器人 ${botName} 失败:`, error.message);
-      this.handleBotFailure();
+      this.handleBotFailure(botName);
       return null;
     }
   }
@@ -150,6 +203,10 @@ class MinecraftBotManager {
   setupBotEvents(bot, botName) {
     bot.on('login', () => {
       console.log(`[${this.host}:${this.port}] 机器人 ${botName} 登录成功`);
+      if (this.timeout) {
+        clearTimeout(this.timeout);
+        this.timeout = null;
+      }
       this.updateStatus();
     });
 
@@ -167,25 +224,21 @@ class MinecraftBotManager {
 
     bot.on('error', (error) => {
       console.log(`[${this.host}:${this.port}] 机器人 ${botName} 错误:`, error.message);
-      
-      // 重要修复：在错误事件中也处理断开连接
-      if (error.message.includes('timed out') || error.message.includes('keepAlive')) {
-        console.log(`[${this.host}:${this.port}] 检测到超时错误，强制断开机器人: ${botName}`);
+      if (this.activeBots.has(botName) && this.failedAttempts <= SERVER_CONFIG.maxFailedAttempts) {
         this.handleBotDisconnect(botName);
-        // 强制结束连接
-        try {
-          bot.end();
-        } catch (e) {
-          // 忽略结束时的错误
-        }
       } else {
-        this.handleBotFailure();
+        this.handleBotFailure(botName);
       }
     });
 
     bot.on('end', (reason) => {
       console.log(`[${this.host}:${this.port}] 机器人 ${botName} 断开连接:`, reason);
-      this.handleBotDisconnect(botName);
+      console.log(`[${this.host}:${this.port}] ${botName}:失败次数${this.failedAttempts}`);
+      if (this.failedAttempts < SERVER_CONFIG.maxFailedAttempts) {
+        this.handleBotDisconnect(botName);
+      } else {
+        this.handleBotFailure(botName);
+      }
     });
 
     bot.on('kicked', (reason) => {
@@ -197,21 +250,22 @@ class MinecraftBotManager {
   // 设置机器人行为
   setupBotBehavior(bot, botName) {
     // 随机移动
-    setInterval(() => {
-      if (bot.entity && Math.random() < 0.3) {
-        const yaw = Math.random() * Math.PI * 2;
-        const pitch = Math.random() * Math.PI - Math.PI / 2;
-        bot.look(yaw, pitch, false);
-        
-        if (Math.random() < 0.2) {
-          bot.setControlState('forward', true);
-          setTimeout(() => {
-            bot.setControlState('forward', false);
-          }, 1000);
+    if (BOT_CONFIG.move){
+      setInterval(() => {
+        if (bot.entity && Math.random() < 0.3) {
+          const yaw = Math.random() * Math.PI * 2;
+          const pitch = Math.random() * Math.PI - Math.PI / 2;
+          bot.look(yaw, pitch, false);
+          
+          if (Math.random() < 0.2) {
+            bot.setControlState('forward', true);
+            setTimeout(() => {
+              bot.setControlState('forward', false);
+            }, 1000);
+          }
         }
-      }
-    }, 5000);
-
+      }, 5000);
+    }
     // 随机聊天（如果启用）
     if (BOT_CONFIG.chat && Math.random() < 0.1) {
       setInterval(() => {
@@ -233,25 +287,33 @@ class MinecraftBotManager {
       // 记录断开连接时间，用于调试
       console.log(`[${this.host}:${this.port}] 当前活跃机器人数量: ${this.currentBots}, 目标: ${this.minBots}`);
       
+      if(this.failedAttempts > SERVER_CONFIG.maxFailedAttempts){
+        console.log(`[${this.host}:${this.port}] 机器人 ${botName} 重连次数太多，跳过`);
+        return;
+      }
       // 延迟重连，避免频繁重连
       setTimeout(() => {
-        this.maintainBots();
+        this.reconnect(botName);
       }, BOT_CONFIG.reconnectDelay);
     } else {
       console.log(`[${this.host}:${this.port}] 机器人 ${botName} 不在活跃列表中，无需处理`);
     }
   }
-
+  
   // 处理机器人失败
-  handleBotFailure() {
+  handleBotFailure(botName) {
     this.failedAttempts++;
     this.updateStatus();
-
     if (this.failedAttempts >= SERVER_CONFIG.maxFailedAttempts) {
-      console.log(`[${this.host}:${this.port}] 失败次数过多，暂停连接尝试`);
+      console.log(`[${this.host}:${this.port}] 失败次数过多，${SERVER_CONFIG.resetTimeout / 1000}秒后再次尝试`);
       setTimeout(() => {
         this.failedAttempts = 0;
-        this.maintainBots();
+        if(botName){
+          this.reconnect(botName);
+        }
+        else{
+          this.maintainBots();
+        }
       }, SERVER_CONFIG.resetTimeout);
       return;
     }
@@ -262,7 +324,7 @@ class MinecraftBotManager {
   }
 
   // 维护机器人数目 - 增强版本
-  maintainBots() {
+  maintainBots(botName) {
     const neededBots = this.minBots - this.currentBots;
     
     // console.log(`[${this.host}:${this.port}] 当前机器人: ${this.currentBots}, 需要: ${neededBots}, 失败次数: ${this.failedAttempts}`);
@@ -272,16 +334,27 @@ class MinecraftBotManager {
       
       for (let i = 0; i < neededBots; i++) {
         setTimeout(() => {
-          this.createBot();
-        }, i * 2000); // 每隔2秒启动一个
+          this.createBot(botName);
+        }, i * 8000); // 每隔8秒启动一个
       }
-    } else if (neededBots > 0) {
+    } 
+    // else if (neededBots > 0) {
+    //   console.log(`[${this.host}:${this.port}] 由于失败次数过多，暂停创建新机器人`);
+    // }
+    this.updateStatus();
+  }
+  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{
       console.log(`[${this.host}:${this.port}] 由于失败次数过多，暂停创建新机器人`);
     }
-    
     this.updateStatus();
   }
-
   // 更新状态
   updateStatus() {
     const serverInfo = globalServerStatus.servers.get(`${this.host}:${this.port}`);