Update server.js

server.js

@@ -1,324 +1,268 @@
+// server.js
 const express = require('express');
 const http = require('http');
 const socketIo = require('socket.io');
 const mineflayer = require('mineflayer');
-const fetch = require('node-fetch');
-const { parse } = require('csv-parse/sync');
 const path = require('path');
-const dns = require('dns').promises;
 
 const app = express();
 const server = http.createServer(app);
 const io = socketIo(server);
 
-// Google Sheets configuration
-const SHEET_ID = '109roJQr-Y4YCLTkCqaK6iwShC-Dr2Jb-hB0qE2phNqQ';
-const SHEET_URL = `https://docs.google.com/spreadsheets/d/${SHEET_ID}/export?format=csv`;
+// Configuration
+const SERVER_HOST = 'orbitmc.progamer.me';
+const SERVER_PORT = 40675;
+const SERVER_VERSION = '1.21.8';
+const BOT_NAMES = ['moderator_1', 'moderator_2', 'moderator_3', 'moderator_4', 'moderator_5'];
+const ROTATION_DURATION = 3600; // 1 hour in seconds
 
-// Bot management
-const bots = new Map();
-const serverBotMap = new Map(); // Track one bot per server
+// State
+let currentBotIndex = 0;
+let rotationStartTime = null;
+let activeBot = null;
+let serverStatus = { online: false, players: '0/0', latency: 0 };
+const botStats = {};
 
-// Function to resolve domain to IP
-async function resolveToIP(hostname) {
-    try {
-        // Check if it's already an IP address
-        if (/^(\d{1,3}\.){3}\d{1,3}$/.test(hostname)) {
-            return hostname;
-        }
-        
-        // Resolve domain to IP
-        const addresses = await dns.resolve4(hostname);
-        return addresses[0]; // Return first IP
-    } catch (error) {
-        console.error(`Failed to resolve ${hostname}:`, error.message);
-        return hostname; // Return original if resolution fails
-    }
-}
-
-class BotManager {
-    constructor(botName, ip, port, version) {
-        this.botName = botName;
-        this.ip = ip;
-        this.port = port;
-        this.version = version || '1.20.1';
-        this.bot = null;
-        this.status = 'Disconnected';
-        this.deathCount = 0;
-        this.disconnectTime = null;
-        this.lastReconnectTime = null;
-        this.isManualDisconnect = false;
-        this.startTime = Date.now();
-        this.connectedTime = null;
-        this.inSheet = true;
-        this.resolvedIP = null;
-    }
-
-    async connect() {
-        try {
-            // Resolve domain to IP for comparison
-            this.resolvedIP = await resolveToIP(this.ip);
-            const serverKey = `${this.resolvedIP}:${this.port}`;
-            
-            // Check if server already has a bot
-            const existingBot = serverBotMap.get(serverKey);
-            if (existingBot && existingBot !== this.botName) {
-                this.status = 'Server already has a bot';
-                console.log(`Bot ${this.botName} blocked: Server ${serverKey} already has bot ${existingBot}`);
-                return false;
-            }
+// Initialize bot stats
+BOT_NAMES.forEach(name => {
+    botStats[name] = {
+        name,
+        status: 'offline',
+        deaths: 0,
+        reconnects: 0,
+        uptime: 0,
+        position: { x: 0, y: 0, z: 0 },
+        health: 20,
+        food: 20,
+        isActive: false
+    };
+});
 
-            this.status = 'Connecting...';
-            this.bot = mineflayer.createBot({
-                host: this.ip, // Use original hostname/IP for connection
-                port: parseInt(this.port),
-                username: this.botName,
-                auth: 'offline',
-                version: this.version,
-                hideErrors: true,
-                checkTimeoutInterval: 30000
-            });
+// Bot creation with circular movement
+function createBot(botName) {
+    console.log(`🚀 Starting ${botName}...`);
+    
+    const bot = mineflayer.createBot({
+        host: SERVER_HOST,
+        port: SERVER_PORT,
+        username: botName,
+        auth: 'offline',
+        version: SERVER_VERSION,
+        hideErrors: false,
+        checkTimeoutInterval: 30000,
+        keepAlive: true
+    });
 
-            // Register this bot for the server using resolved IP
-            serverBotMap.set(serverKey, this.botName);
-            console.log(`Registering bot ${this.botName} for server ${serverKey}`);
+    let circleInterval = null;
+    let centerPos = null;
+    let angle = 0;
 
-            this.bot.once('spawn', () => {
-                this.status = 'Connected';
-                this.connectedTime = Date.now();
-                this.disconnectTime = null;
-                console.log(`Bot ${this.botName} spawned on ${this.ip}:${this.port} (resolved: ${this.resolvedIP})`);
+    bot.once('spawn', () => {
+        console.log(`✅ ${botName} connected`);
+        botStats[botName].status = 'online';
+        botStats[botName].uptime = Date.now();
+        
+        // Start circular movement
+        setTimeout(() => {
+            if (!bot.entity) return;
+            
+            centerPos = bot.entity.position.clone();
+            
+            circleInterval = setInterval(() => {
+                if (!bot.entity) return;
                 
-                // Start AFK behavior
-                this.startAFK();
-            });
+                try {
+                    const radius = 4;
+                    angle += 0.03;
+                    
+                    const targetX = centerPos.x + Math.cos(angle) * radius;
+                    const targetZ = centerPos.z + Math.sin(angle) * radius;
+                    
+                    const dx = targetX - bot.entity.position.x;
+                    const dz = targetZ - bot.entity.position.z;
+                    const yaw = Math.atan2(-dx, -dz);
+                    
+                    bot.look(yaw, 0, true);
+                    bot.setControlState('forward', true);
+                    
+                    // Update position
+                    botStats[botName].position = {
+                        x: Math.floor(bot.entity.position.x),
+                        y: Math.floor(bot.entity.position.y),
+                        z: Math.floor(bot.entity.position.z)
+                    };
+                    botStats[botName].health = bot.health || 20;
+                    botStats[botName].food = bot.food || 20;
+                } catch (err) {
+                    console.error(`Movement error for ${botName}:`, err.message);
+                }
+            }, 100);
+        }, 2000);
+    });
 
-            this.bot.on('death', () => {
-                this.deathCount++;
-                this.status = 'Dead';
-                console.log(`Bot ${this.botName} died. Total deaths: ${this.deathCount}`);
-                this.handleDisconnect();
-            });
+    bot.on('death', () => {
+        console.log(`💀 ${botName} died`);
+        botStats[botName].deaths++;
+        if (circleInterval) clearInterval(circleInterval);
+        centerPos = null;
+    });
 
-            this.bot.on('kicked', (reason) => {
-                console.log(`Bot ${this.botName} was kicked: ${reason}`);
-                this.handleDisconnect();
-            });
+    bot.on('respawn', () => {
+        console.log(`🔄 ${botName} respawned`);
+        if (circleInterval) clearInterval(circleInterval);
+        centerPos = null;
+        angle = 0;
+    });
 
-            this.bot.on('error', (err) => {
-                console.error(`Bot ${this.botName} error:`, err.message);
-            });
+    bot.on('kicked', (reason) => {
+        console.log(`⛔ ${botName} kicked: ${reason}`);
+        botStats[botName].status = 'offline';
+        if (circleInterval) clearInterval(circleInterval);
+    });
 
-            this.bot.on('end', () => {
-                this.handleDisconnect();
-            });
+    bot.on('error', (err) => {
+        console.error(`❌ ${botName} error:`, err.message);
+    });
 
-            return true;
-        } catch (error) {
-            console.error(`Failed to connect bot ${this.botName}:`, error);
-            this.status = 'Connection Failed';
-            
-            // Clean up server registration if connection failed
-            if (this.resolvedIP) {
-                const serverKey = `${this.resolvedIP}:${this.port}`;
-                if (serverBotMap.get(serverKey) === this.botName) {
-                    serverBotMap.delete(serverKey);
-                }
+    bot.on('end', () => {
+        console.log(`🔌 ${botName} disconnected`);
+        botStats[botName].status = 'offline';
+        if (circleInterval) clearInterval(circleInterval);
+        
+        // Auto reconnect after 5 seconds if still active
+        setTimeout(() => {
+            if (activeBot && activeBot.username === botName) {
+                console.log(`🔄 Reconnecting ${botName}...`);
+                botStats[botName].reconnects++;
+                activeBot = createBot(botName);
             }
-            
-            return false;
-        }
-    }
+        }, 5000);
+    });
 
-    handleDisconnect() {
-        if (this.resolvedIP) {
-            const serverKey = `${this.resolvedIP}:${this.port}`;
-            if (serverBotMap.get(serverKey) === this.botName) {
-                serverBotMap.delete(serverKey);
-                console.log(`Unregistering bot ${this.botName} from server ${serverKey}`);
-            }
-        }
-        
-        if (this.status !== 'Dead') {
-            this.status = 'Disconnected';
-        }
-        this.disconnectTime = Date.now();
-        this.connectedTime = null;
-        this.bot = null;
-        
-        console.log(`Bot ${this.botName} disconnected from ${this.ip}:${this.port}`);
-    }
+    return bot;
+}
 
-    disconnect() {
-        this.isManualDisconnect = true;
-        if (this.bot) {
-            this.bot.quit();
-        }
-        this.handleDisconnect();
+// Stop bot
+function stopBot(bot) {
+    if (!bot) return;
+    
+    try {
+        bot.quit();
+        console.log(`⏹️ Stopped ${bot.username}`);
+    } catch (err) {
+        console.error('Error stopping bot:', err.message);
     }
+}
 
-    startAFK() {
-        if (!this.bot) return;
+// Rotation manager
+function rotationManager() {
+    setInterval(() => {
+        const currentBot = BOT_NAMES[currentBotIndex];
+        const now = Date.now();
         
-        // Simple AFK movement
-        let direction = 1;
-        const afkInterval = setInterval(() => {
-            if (!this.bot || this.status !== 'Connected') {
-                clearInterval(afkInterval);
-                return;
+        if (!rotationStartTime || (now - rotationStartTime) >= (ROTATION_DURATION * 1000)) {
+            // Stop current bot
+            if (activeBot) {
+                stopBot(activeBot);
+                botStats[activeBot.username].isActive = false;
             }
             
-            // Walk forward and backward
-            this.bot.setControlState('forward', direction > 0);
-            this.bot.setControlState('back', direction < 0);
-            
+            // Start new bot
             setTimeout(() => {
-                if (this.bot) {
-                    this.bot.clearControlStates();
-                }
-            }, 1000);
-            
-            direction *= -1;
-        }, 5000);
-    }
-
-    canReconnect() {
-        if (this.status === 'Connected' || this.status === 'Connecting...') return false;
-        if (!this.inSheet) return false;
-        
-        if (!this.lastReconnectTime) return true;
-        
-        const hourAgo = Date.now() - (60 * 60 * 1000);
-        return this.lastReconnectTime < hourAgo;
-    }
-
-    async reconnect() {
-        if (!this.canReconnect()) {
-            return false;
+                activeBot = createBot(currentBot);
+                botStats[currentBot].isActive = true;
+                rotationStartTime = Date.now();
+                
+                console.log(`🔄 Rotation: ${currentBot} is now active`);
+                
+                // Move to next bot
+                currentBotIndex = (currentBotIndex + 1) % BOT_NAMES.length;
+            }, 2000);
         }
-        
-        this.lastReconnectTime = Date.now();
-        this.isManualDisconnect = false;
-        return await this.connect();
-    }
-
-    getTimeUntilReconnect() {
-        if (!this.lastReconnectTime) return 0;
-        const timeElapsed = Date.now() - this.lastReconnectTime;
-        const hourInMs = 60 * 60 * 1000;
-        const timeRemaining = Math.max(0, hourInMs - timeElapsed);
-        return Math.ceil(timeRemaining / 1000);
-    }
-
-    getConnectedDuration() {
-        if (!this.connectedTime || this.status !== 'Connected') return 0;
-        return Math.floor((Date.now() - this.connectedTime) / 1000);
-    }
-
-    getInfo() {
-        return {
-            botName: this.botName,
-            status: this.status,
-            deathCount: this.deathCount,
-            connectedDuration: this.getConnectedDuration(),
-            canReconnect: this.canReconnect(),
-            disconnectTime: this.disconnectTime,
-            timeUntilReconnect: this.getTimeUntilReconnect(),
-            inSheet: this.inSheet
-        };
-    }
+    }, 5000);
 }
 
-// Fetch and parse Google Sheets data
-async function fetchSheetData() {
+// Check server status
+async function checkServerStatus() {
     try {
-        const response = await fetch(SHEET_URL);
-        const csvText = await response.text();
+        const net = require('net');
+        const client = new net.Socket();
+        const startTime = Date.now();
         
-        const records = parse(csvText, {
-            columns: true,
-            skip_empty_lines: true
-        });
+        client.setTimeout(5000);
         
-        return records;
-    } catch (error) {
-        console.error('Error fetching sheet data:', error);
-        return [];
-    }
-}
-
-// Update bots based on sheet data
-async function updateBots() {
-    const sheetData = await fetchSheetData();
-    const activeBots = new Set();
-    
-    // Mark all existing bots as not in sheet initially
-    for (const [botName, botManager] of bots.entries()) {
-        botManager.inSheet = false;
-    }
-    
-    for (const row of sheetData) {
-        const botName = row['BOT NAME']?.trim();
-        const ip = row['IP']?.trim();
-        const port = row['PORT']?.trim();
-        const version = row['Version']?.trim() || '1.20.1';
-        
-        if (!botName || !ip || !port) continue;
+        client.connect(SERVER_PORT, SERVER_HOST, () => {
+            const latency = Date.now() - startTime;
+            serverStatus = {
+                online: true,
+                latency,
+                players: '?/?'
+            };
+            client.destroy();
+        });
         
-        activeBots.add(botName);
+        client.on('error', () => {
+            serverStatus = { online: false, latency: 0, players: '0/0' };
+            client.destroy();
+        });
         
-        // Add new bot if it doesn't exist
-        if (!bots.has(botName)) {
-            const botManager = new BotManager(botName, ip, port, version);
-            bots.set(botName, botManager);
-            console.log(`Added new bot from sheet: ${botName} for ${ip}:${port}`);
-        } else {
-            // Mark existing bot as still in sheet
-            bots.get(botName).inSheet = true;
-        }
-    }
-    
-    // Remove bots that are no longer in the sheet
-    for (const [botName, botManager] of bots.entries()) {
-        if (!botManager.inSheet) {
-            console.log(`Removing bot ${botName} - no longer in sheet`);
-            botManager.disconnect();
-            bots.delete(botName);
-        }
+        client.on('timeout', () => {
+            serverStatus = { online: false, latency: 0, players: '0/0' };
+            client.destroy();
+        });
+    } catch (err) {
+        serverStatus = { online: false, latency: 0, players: '0/0' };
     }
-    
-    console.log(`Total bots: ${bots.size}, Active servers: ${serverBotMap.size}`);
 }
 
-// Socket.IO events
+// Socket.IO
 io.on('connection', (socket) => {
-    console.log('Client connected');
+    console.log('📱 Client connected');
     
-    // Send initial bot data
-    const sendBotData = () => {
-        const botData = Array.from(bots.values()).map(bot => bot.getInfo());
-        socket.emit('botUpdate', botData);
+    const sendUpdate = () => {
+        const currentBot = BOT_NAMES[(currentBotIndex - 1 + BOT_NAMES.length) % BOT_NAMES.length];
+        const nextBot = BOT_NAMES[currentBotIndex];
+        const elapsed = rotationStartTime ? Math.floor((Date.now() - rotationStartTime) / 1000) : 0;
+        const remaining = Math.max(0, ROTATION_DURATION - elapsed);
+        
+        // Update uptimes
+        Object.keys(botStats).forEach(name => {
+            if (botStats[name].status === 'online' && botStats[name].uptime) {
+                botStats[name].uptimeSeconds = Math.floor((Date.now() - botStats[name].uptime) / 1000);
+            } else {
+                botStats[name].uptimeSeconds = 0;
+            }
+        });
+        
+        socket.emit('update', {
+            server: {
+                host: SERVER_HOST,
+                port: SERVER_PORT,
+                version: SERVER_VERSION,
+                status: serverStatus
+            },
+            rotation: {
+                current: currentBot,
+                next: nextBot,
+                elapsed,
+                remaining,
+                queue: BOT_NAMES
+            },
+            bots: Object.values(botStats)
+        });
     };
     
-    sendBotData();
-    const updateInterval = setInterval(sendBotData, 2000);
-    
-    socket.on('reconnectBot', async (botName) => {
-        const botManager = bots.get(botName);
-        if (botManager) {
-            const success = await botManager.reconnect();
-            socket.emit('reconnectResult', { botName, success });
-        }
-    });
+    const interval = setInterval(sendUpdate, 1000);
+    sendUpdate();
     
-    socket.on('refreshSheet', async () => {
-        await updateBots();
-        sendBotData();
+    socket.on('forceRotation', () => {
+        rotationStartTime = 0;
+        socket.emit('rotationForced', true);
     });
     
     socket.on('disconnect', () => {
-        clearInterval(updateInterval);
-        console.log('Client disconnected');
+        clearInterval(interval);
+        console.log('📴 Client disconnected');
     });
 });
 
@@ -331,9 +275,17 @@ app.get('/', (req, res) => {
 // Start server
 const PORT = process.env.PORT || 7860;
 server.listen(PORT, () => {
-    console.log(`Server running on port ${PORT}`);
+    console.log('═══════════════════════════════════════');
+    console.log('🎮 MINECRAFT BOT MANAGER');
+    console.log('═══════════════════════════════════════');
+    console.log(`📡 Server: ${SERVER_HOST}:${SERVER_PORT}`);
+    console.log(`🤖 Bots: ${BOT_NAMES.join(', ')}`);
+    console.log(`⏱️  Rotation: ${ROTATION_DURATION / 60} minutes`);
+    console.log(`🌐 Dashboard: http://localhost:${PORT}`);
+    console.log('═══════════════════════════════════════');
 });
 
-// Initial load and periodic updates
-updateBots();
-setInterval(updateBots, 30000); // Check sheet every 30 seconds
+// Start systems
+rotationManager();
+setInterval(checkServerStatus, 1000);
+checkServerStatus();