ddbot.js-0374 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 0374flop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+Смотрите за руками
+
+Скажу прямо.
+Коментари с нецензурной лексикой и тут и в коде только потому что я за то чтобы цензура стала слабее. Мне не нравиться что везде слишком сильная цензура.
+Так что да, не плакайте там.
+Простите за орфографические ошибки, писал на скорую руку. (за другие ошибки простите тоже)
+
+Лицензия находиться в файле "LICENSE" там большими буквами для идиотов написано
+
+У нас есть много всякого, например:
+1. bot.js
+	 Начнем с него.
+	 Ето класс, с методами для работы с большим количеством ботов.
+	 Работает с дебагером.
+	 Емитит кастомные емиты
+	 и там всякое которое мне лень разказывать
+2. debug.js
+    Думаю, нужно было начинать с него.
+    Ета хуйня дает кучу возможностей для дебагинга
+    например можно менять режим дебажинга, типа консольный лог или дебаг
+    зделан в виде класса самый лутший по моему мнению ЖСДок из всех остальных файлов тут.
+    зделан даже тест если запущен как node debug.js
+3. maploader.js
+    Первая вещь которая позволяет загружать карты дднет напрямую с дднет сайта. а точнее гита на котором лежат карты, как я выяснил.
+    можно получать тип карты, загружать и автоматически понимать какой тип у карты и по нему загружать.
+    есть возможность получать сырые функции в advanced. ето просто чтобы можно было напрямую все делать.
+    в нем же есть и объект дебагера.
+4. automaploader.js
+    изпользует bot.js чтобы автоматически загружать карту через maploader.js когда он подключиться к серверу.
+    Выгружает свой дебаг логер.
+    также с кастомным емитером.
+5. index'ы.js
+    просто вещи чтобы проще было.
+    что про них сказать?
+    подключают из других файлов все, и выгружают все в один объект.
+
+## Установка.
+    Кароче, клонируем `git clone https://github.com/0374flop/ddbot.js/tree/new-bot`, да новый бот потому что старый он на то и старый что кривой и не работает.
+    После того как клонировали, и все прошло хорошо, ставим зависимости `npm i` или `npm install` и все.
+    После етого вы можете спокойно подключать либу черер `require('./index')` если вы конечно в пвпке проекта подключаете. Иначе другой путь.
+    И все после етого вам доступно все ето : { bot, mapLoader, Automaploader, BotManager, DebugLogger }.
+    Наслаждайтесь етом дерьмом.
+## Техническая документация.
+    смотрите теперь в docs/

package/docs/documentation.md

@@ -0,0 +1,108 @@
+
+# bot/BotManager
+Окей...
+Сейчас я вам разкажу как работает bot/BotManager.
+
+neiky-ddracebot.js
+## Базовые методы
+У нас есть :
+1. bot.createBot()
+	1. fulladdress - Полный адрес сервера (IP:порт)
+	2. botName - Имя бота
+	3. parameter - Параметры бота
+	    1. identity со скином и другими косметическими деталями.
+	    2. reconnect переподключаеться бот или нет
+	    3. reconnectAttempts количество возможных реконектов (-1 для безконечного)
+	    4. randreconnect будет ли бот переключаться с чуть разной задержкой или нет (в районе 0 - 1 сек)
+	- На выходе у нас имя бота по которому можно обращаться. (Уникальное имя бота или null в случае ошибки)
+2. bot.connectBot()
+    1. Принимает уникальное имя бота и подключает нужного.
+    - На выхоте булевое значение (нет точных данных подключился ли бот или нет)
+3. bot.disconnectBot()
+    1. Принимает уникальное имя бота и отключает нужного.
+    - Работает также как и connectBot().
+4. bot.disconnectAllBots()
+    Отключает всех ботов, не принимает аргументов.
+    Под капотом disconnectBot().
+5. bot.getBotInfo()
+    1. Принимает уникальное имя бота и возвращает информацию про него.
+    - Информация о боте или null, если бот не найден
+6. bot.isBotConnected()
+    1. Принимает уникальное имя бота.
+    - Возвращает булевое значение.
+7. bot.isFreezeBot()
+    1. Принимает уникальное имя бота.
+    - Возвращает булевое значение.
+8. bot.setFreezeBot()
+    Просто меняет значение того заморожен ли бот.
+9. bot.getAllActiveBots()
+	Получение всех активных ботов
+	- Массив имен всех активных ботов
+10. bot.getBotClient()
+    1. Принимает уникальное имя бота.
+    - Возвращает клиент neiky-ddracebot.js
+11. bot.removeBot()
+	Удаляет бота полностью.
+    1. Принимает уникальное имя бота.
+    - Возвращает булевое значение.
+12. bot.getBot()
+    1. Принимает уникальное имя бота.
+    - Возвращает прокси-объект бота.
+13. bot.(Тут нижнее подчеркивание, я не могу поставить из-за обсидиана, он ломается)setupBotEvents()
+    Заставляет ивенты работать. Изпользуеться в bot.createBot() чтобы вы могли делать все проще и вам не нужно было получать оригинальный клиент neiky-ddracebot.js
+    1. Принимает уникальное имя бота.
+    2. Принимает клиент neiky-ddracebot.js
+    Ничего не возвращает.
+14. bot.getPlayerList()
+    1. Принимает уникальное имя бота.
+    - Array список игроков.
+15. bot.getPlayerName()
+    1. Принимает уникальное имя бота/Array список игроков.
+    2. clientid нужного игрока.
+    - Имя нужного игрока.
+
+
+# maploader
+Возможно первая вещь которая может загружать карты по официальным названиям ДДНета.
+
+## Самые нужные
+fetchMapType и loadMap.
+
+1. fetchMapType
+    Получает тип карты с ddnet.org
+    1. mapName - Имя карты.
+    - Тип карты (novice тд.).
+2. loadMap
+	Загружает карту по нужному имени в нужную директорию.
+	1. mapName - Имя карты.
+	2. MAP_DIR - Директория куда будет загружена карта.
+	- Возвращает булевое значение.
+
+## Дополнитильные или сырые функции
+Находяться в advanced
+Тут есть сырой downloadMap, tryDownloadMap, logDebuger.
+
+1. downloadMap
+    Загрузка карты по имени и типу.
+    Нет никакого протекшена почти.
+    1. mapName - Имя карты
+    2. type - Тип карты
+    3. MAP_DIR_DM - Папка для загрузки карты
+    - Путь к загруженной карте
+2. tryDownloadMap
+	Принимает все тоже что и downloadMap, только оборачивает его в try.
+	- Возвращает болевое значение.
+
+logDebuger из debug.js
+
+
+# automaploader.js
+Хуйня.
+Не работает не с официальными ДДНет серверами, потому что они уже дают нам mapDetails.map_url а automaploader загружает по имени.
+Мне лень переделывать его. пусть будет.
+
+Если хотите понять как им пользоваться, лутше сами посмотрите его. он очень простой и маленький.
+
+# debug.js
+Главный логер.
+Тоже достаточно простой, проще самому посмотреть.

package/docs/examples/echo-bot.js

@@ -0,0 +1,61 @@
+// Пример писался под комит c453b96f9fd717375f5ff70525603b7e1491c290.
+
+const { bot, botClassAndLoger, DebugLogger } = require('../../index');
+const botdebug = botClassAndLoger.logDebuger;
+botdebug.setDebugMode(true, true, true);
+
+const logDebuger = new DebugLogger('example', true, true, null, true);
+
+async function main() {
+    logDebuger.logDebug('Main started');
+
+    const identitybot = {
+        name: "Towa",
+        clan: "Towa Team",
+        skin: "Astolfofinho",
+        use_custom_color: 1,
+        color_body: 16711680,
+        color_feet: 16711680,
+        country: -1
+    };
+
+    const botName = await bot.createBot('45.141.57.22:8375', 'Towa', {
+        identity: identitybot,
+        reconnect: true,
+        reconnectAttempts: -1,
+        randreconnect: true
+    });
+
+    bot.connectBot(botName); // подкюлчаем
+
+    const botClient = bot.getBotClient(botName); // получаем оригинальный клиент neiky-ddracebot.js
+
+    // Подписка на событие подключения
+    bot.on(`${botName}:connect`, () => {
+        let timemsg = 0; // время
+
+        // подписка на чат
+        bot.on(`${botName}:ChatNoSystem`, (msgraw, autormsg, text, team, client_id) => {
+            logDebuger.logDebug(`${client_id} ${team} '${autormsg}' : ${text}`); // вывод чата в консоль
+            if (text == 'exit') exit(); // выход
+
+            // Эхо-логика
+            if (Date.now() - timemsg > 6000) {
+                timemsg = Date.now(); // устанавливаем текущее время
+                if (text && autormsg) {
+                    botClient.game.Say(`${autormsg}: ${text}`); // отправка сообения (neiky-ddracebot.js)
+                }
+            }
+        });
+    });
+
+    // Выход через Ctrl+C
+    async function exit() {
+        logDebuger.logDebug('Shutting down...');
+        await bot.disconnectAllBots(); // отключаем всех ботов
+        process.exit(0); // завершаем процес
+    }
+    process.on('SIGINT', exit); // Ctrl+C
+}
+
+if (require.main === module) main();

package/docs/examples/main.js

@@ -0,0 +1,139 @@
+const { bot, botClassAndLoger } = require('../../index');
+botClassAndLoger.logDebuger.setDebugMode(true, true);
+
+async function main() {
+    console.log('Main started');
+
+    const identitybot = {
+        name: "Towa",
+        clan: "Towa Team",
+        skin: "Astolfofinho",
+        use_custom_color: 1,
+        color_body: 16711680,
+        color_feet: 16711680,
+        country: -1
+    };
+
+    const botName = await bot.createBot('45.141.57.22:8375', 'Towa', {
+        identity: identitybot,
+        reconnect: true,
+        reconnectAttempts: -1
+    });
+
+    bot.connectBot(botName);
+
+    const botClient = bot.getBotClient(botName);
+
+    bot.on(`${botName}:connect`, () => {
+        function startemote(botClient, Emotenumber) {
+            const intervalemote = setInterval(() => {
+                botClient.game.Emote(Emotenumber);
+            }, 5000);
+            return intervalemote;
+        }
+
+        function startnameset(botClient, bot, identitybot) {
+            const intervalnameset = setInterval(() => {
+                const myclientid = botClient.SnapshotUnpacker.OwnID;
+                const me = bot.getPlayerList(botName).find(p => p.client_id === myclientid);
+
+                if (!me) return;
+
+                 if (me.name !== identitybot.name) {
+                    botClient.game.ChangePlayerInfo({ ...identitybot, name: identitybot.name });
+                }
+            }, 10000);
+            return intervalnameset;
+        }
+        
+        let sync = false;
+        let intervalemote = startemote(botClient, 2);
+        let intervalnameset = startnameset(botClient, bot, identitybot);
+
+        async function startchatlistener(bot, botName) {
+            bot.on(`${botName}:ChatNoSystem`, (msg, autormsg, text, team, client_id) => {
+                console.log(`${client_id} ${team} '${autormsg}' : ${text}`);
+
+                if (text.includes(identitybot.name) && text.includes('%syncE')) {
+                    sync = true;
+                    if (intervalemote) clearInterval(intervalemote);
+                    intervalemote = startemote(botClient, 2);
+                }
+            });
+        }
+
+        startchatlistener(bot, botName);
+
+        bot.on(`${botName}:disconnect`, (reason) => {
+            clearInterval(intervalemote);
+            clearInterval(intervalMove);
+            clearInterval(intervalnameset);
+            console.log(reason)
+        });
+
+        function findbot2(botName, identitybot) {
+            const players = bot.getPlayerList(botName);
+
+            return players.some(player =>
+                player.clan === identitybot.clan &&
+                player.skin === identitybot.skin &&
+                player.name.includes(identitybot.name) &&
+                player.name !== identitybot.name
+            );
+        }
+        
+        setInterval(() => {
+            if (findbot2(botName, identitybot) && !sync) {
+                botClient.game.Say(botName+'%syncE');
+            } if (!findbot2(botName, identitybot)) {
+                sync = false;
+            }
+        }, 60000);
+    });
+
+    let x = 100;
+    let direction = -1;
+    const intervalMove = setInterval(() => {
+        x += direction * 10;
+        if (x <= -100) {
+            direction = 1;
+        } else if (x >= 100) {
+            direction = -1;
+        }
+        if (bot.isBotConnected(botName) && bot.isFreezeBot(botName)) {
+            if (botClient && botClient.movement) {
+                botClient.movement.FlagHookline(true);
+                setTimeout(() => {
+                    botClient.movement.FlagHookline(false);
+                }, Math.random() * 50);
+                botClient.movement.SetAim(x, -100);
+            }
+        }
+    }, Math.random() * 100);
+
+    async function SayChat(message) {
+        botClient.game.Say(message);
+    }
+
+    async function exit() {
+        console.log('Shutting down...');
+        console.log('disconnecting...');
+        await bot.disconnectAllBots();
+        console.log('Main stopped');
+        process.exit(0);
+    }
+
+    process.on('SIGINT', () => {
+        exit();
+    });
+
+    module.exports.exit = exit;
+    module.exports.SayChat = SayChat;
+}
+
+if (require.main === module) main();
+
+module.exports.main = main;
+
+// можете щитать ето примером, ето просто как тест
+// тут нет коментариев но если хотите то сами поймите как работает

package/index.js

@@ -0,0 +1,17 @@
+"use strict";
+const { bot, BotManager, logDebuger } = require('./src/bot'); // Импортируем bot и BotManager из модуля bot/index.js
+const mapLoader = require('./src/map/maploader'); // Импортируем mapLoader из модуля map/maploader.js
+const Automaploader = require('./src/map/Automaploader'); // Импортируем Automaploader из модуля map/Automaploader.js
+const DebugLogger = require('./src/debug'); // Импортируем DebugLogger из модуля debug.js
+
+/**
+ * Зделал так чтобы было меньше експорта.
+ * Тут у нас не активированый BotManager.
+ * И logDebuger который изпользуеться в BotManager, а точнее в bot.
+ */
+const botClassAndLoger = {
+    BotManager,
+    logDebuger
+}
+
+module.exports = { bot, mapLoader, Automaploader, botClassAndLoger, DebugLogger }; // Экспортируем bot, mapLoader, Automaploader, botClassAndLoger и DebugLogger

package/package.json

@@ -0,0 +1,35 @@
+{
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "neiky-ddracebot.js": "^2.4.0"
+  },
+  "name": "ddbot.js-0374",
+  "version": "1.0.0",
+  "description": "ddbot.js — это Node.js проект для автоматизации и управления ботами, а также работы с картами и логами.",
+  "main": "./src/bot/index.js",
+  "scripts": {
+    "electron": "npx electron ./main-electron.js",
+    "start": "node main.js",
+    "test": "node main.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0374flop/ddbot.js.git"
+  },
+  "keywords": [
+    "ddracebot",
+    "DDNet",
+    "DDraceNetwork",
+    "ddbot",
+    "bot",
+    "automation",
+    "maps"
+  ],
+  "author": "0374flop",
+  "license": "MIT",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/0374flop/ddbot.js/issues"
+  },
+  "homepage": "https://github.com/0374flop/ddbot.js#readme"
+}

package/src/bot/bot.js

@@ -0,0 +1,462 @@
+"use strict";
+const DDRaceBot = require('neiky-ddracebot.js');
+const EventEmitter = require('events');
+const DebugLogger = require('../debug');
+const logDebuger = new DebugLogger('BotManager', false, true, null, true);
+const logDebug = ( ...args) => {
+    logDebuger.logDebug(...args);
+}
+
+function random(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+class BotManager extends EventEmitter {
+    /**
+     * Конструктор класса BotManager
+     */
+    constructor() {
+        super();
+        this.activeBots = new Map();
+        this.botCounter = 0;
+        this.botFreezeStates = new Map(); // Хранит состояние заморозки для каждого бота
+        this.playerLists = new Map(); // Хранит список игроков по каждому боту
+    }
+
+    /**
+     * Извлечение IP и порта из полного адреса
+     * @param {string} address - Полный адрес в формате "IP:порт"
+     * @returns {object} IP адрес и порт { address: string, port: number }
+     */
+    getIPsplitPort(address) {
+        const parts = address.split(':');
+        const ip = parts[0];            // IPv4 остаётся строкой
+        const port = parseInt(parts[1], 10); // порт парсим в число
+        return { address: ip, port: port };
+    }
+
+    /**
+     * Генерация уникального имени бота
+     * @param {string} baseName - Базовое имя бота
+     * @returns {string} - Уникальное имя бота
+     */
+    generateUniqueBotName(baseName) {
+        logDebug('generateUniqueBotName called with baseName:', baseName);
+        this.botCounter++;
+        const name = `${baseName}${this.botCounter}`;
+        logDebug('Generated unique bot name:', name);
+        return name;
+    }
+
+    /**
+     * Создание бота
+     * @param {string} fulladdress - Полный адрес сервера (IP:порт)
+     * @param {string} botName - Имя бота
+     * @param {Object} parameter - Параметры бота
+     * parameter может иметь в себе: identity со скином и другими косметическими деталями,
+     * reconnect переподключаеться бот или нет,
+     * reconnectAttempts количество возможных реконектов (-1 для безконечного),
+     * randreconnect будет ли бот переключаться с чуть разной задержкой или нет (в районе 0 - 1 сек)
+     * @returns {Promise<string|null>} - Уникальное имя бота или null в случае ошибки
+     */
+    async createBot(fulladdress, botName, parameter = {}) {
+        logDebug('createBot called with:', fulladdress, botName, parameter); // логируем вызов функции
+        const { address, port } = this.getIPsplitPort(fulladdress); // разбираем адрес
+        const serverIp = address; // айпи
+        const serverPort = port; // порт
+        
+        if (!serverIp || !serverPort) {
+            return new Error('и где мы возьмём айпи или порт? ты можешь нормально ввести адрес?');
+        }
+
+        const uniqueBotName = this.generateUniqueBotName(botName);
+        try {
+            const identity = parameter.identity || { // если нет индентити, создаём дефолтное
+                clan: "",
+                skin: "default",
+                use_custom_color: 0,
+                color_body: 0,
+                color_feet: 0,
+                country: 0
+            };
+            logDebug('creating bot client');
+            // то самое место откуда создаеться клинт бота
+            const client = new DDRaceBot.Client(serverIp, serverPort, botName, { 
+                identity: identity // то самое индентити для скина и тд
+            });
+
+            // Настраиваем события для бота или пиздеи будет
+            this._setupBotEvents(uniqueBotName, client);
+
+            // Сохраняем информацию о боте
+            logDebug('storing bot info');
+            this.activeBots.set(uniqueBotName, {
+                client,
+                fulladdress,
+                originalName: botName,
+                parameter,
+                isConnected: false,
+                createdAt: Date.now()
+            });
+
+            // Инициализируем состояние заморозки
+            logDebug('initializing freeze state');
+            this.botFreezeStates.set(uniqueBotName, false);
+
+            return uniqueBotName;
+        } catch (error) {
+            return null; // пиздеи
+        }
+    }
+
+    /**
+     * Подключение бота к серверу
+     * @param {string} botName
+     * @returns {boolean} (Да если ошибок не возникло)
+     */
+    async connectBot(botName) {
+        logDebug('connectBot called with botName:', botName); // логируем вызов функции
+        const botInfo = this.activeBots.get(botName); // получаем инфу о боте
+        if (!botInfo) {
+            return false; // бот не найден
+        }
+        try {
+            botInfo.client.joinDDRaceServer(); // то самое место подключения
+            return true; // да
+        } catch (error) { // фак
+            logDebug(JSON.stringify(error, null, 2));
+            return false; // нет
+        }
+    }
+
+    /**
+     * Отключение бота от сервера
+     * @param {string} botName 
+     * @returns 
+     */
+    async disconnectBot(botName) {
+        logDebug('disconnectBot called with botName:', botName); // логируем вызов функции
+        const botInfo = this.activeBots.get(botName); // получаем инфу о боте
+        if (!botInfo) {
+            return false; // бот не найден
+        }
+
+        try {
+            botInfo.client.Disconnect(); // отключаемся
+            botInfo.isConnected = false; // обновляем статус
+            logDebug('disconnectedBot', botName)
+            return true; // да
+        } catch (error) { // фак
+            logDebug(error)
+            return false; // нет
+        }
+    }
+
+    /** 
+     * Отключение всех ботов
+     * @return {Promise<Array>} - Результаты отключения каждого бота
+     */
+    async disconnectAllBots() { 
+        logDebug('disconnectAllBots called'); // логируем вызов функции
+        const botNames = Array.from(this.activeBots.keys()); // получаем имена всех ботов
+        const results = await Promise.allSettled( // Проходимся по каждому и даем по жопе и отключаем
+            botNames.map(botName => this.disconnectBot(botName)) // отключаем каждого бота
+        );
+        this.botFreezeStates.clear(); // Очищаем все состояния заморозки
+        this.playerLists.clear(); // Очищаем списки игроков
+        return results; // возвращаем результаты
+    }
+
+    /**
+     * Получение информации о боте
+     * @param {string} botName 
+     * @returns {Object|null} - Информация о боте или null, если бот не найден
+     */
+    getBotInfo(botName) {
+        return this.activeBots.get(botName);
+    }
+
+    /**
+     * Проверка подключения бота
+     * @param {string} botName 
+     * @returns {boolean} - true если бот подключен, иначе false
+     */
+    isBotConnected(botName) {
+        const botInfo = this.activeBots.get(botName); // получаем инфу о боте
+        return botInfo ? botInfo.isConnected : false; // подключен? да или нет
+    }
+
+    /**
+     * Проверка состояния заморозки бота
+     * @param {string} botName 
+     * @returns {boolean} - true если бот заморожен, иначе false
+     */
+    isFreezeBot(botName) {
+        return this.botFreezeStates.get(botName) || false; // возвращаем состояние заморозки
+    }
+
+    /**
+     * Установка состояния заморозки бота (для внутреннего использования)
+     * @param {string} botName - Имя бота
+     * @param {boolean} isFrozen - true для заморозки, false для разморозки
+     */
+    setFreezeBot(botName, isFrozen) {
+        this.botFreezeStates.set(botName, isFrozen);
+    }
+
+    /**
+     * Получение всех активных ботов
+     * @returns {object[]} - Массив имен всех активных ботов
+     */
+    getAllActiveBots() {
+        return Array.from(this.activeBots.keys()); // возвращаем имена всех активных ботов
+    }
+
+    /**
+     * Получение клиента бота по имени
+     * @param {string} botName - Имя бота
+     * @returns {object|null} - Объект клиента бота или null, если бот не найден
+     */
+    getBotClient(botName) {
+        const botInfo = this.activeBots.get(botName); // получаем инфу о боте
+        return botInfo ? botInfo.client : null; // возвращаем клиент или null
+    }
+
+    /** 
+     * Удаление бота из менеджера
+     * @param {string} botName - Имя бота
+     * @returns {boolean} - true если бот был удален, иначе false
+     */
+    removeBot(botName) {
+        logDebug('removeBot called with botName:', botName); // логируем вызов функции
+        const botInfo = this.activeBots.get(botName); // получаем инфу о боте
+        if (botInfo) {
+            // Отключаем если подключен
+            if (botInfo.isConnected) {
+                botInfo.client.disconnect(); // отключаемся
+            }
+            this.activeBots.delete(botName); // удаляем бота
+            this.botFreezeStates.delete(botName); // удаляем состояние заморозки
+            this.playerLists.delete(botName); // удаляем список игроков
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Получение объекта бота с событиями
+     * @param {string} botName - Имя бота
+     * @returns {object|null} - Объект бота с событиями или null, если бот не найден
+     */
+    getBot(botName) {
+        const botInfo = this.activeBots.get(botName); // получаем инфу о боте
+        if (!botInfo) {
+            return null; // бот не найден
+        }
+
+        // Создаем прокси-объект для бота с событиями
+        const bot = {
+            name: botName, // скажи мое имя.
+            client: botInfo.client, // сам клиент бота
+            info: botInfo, // инфа о боте
+            
+            // Методы для работы с событиями
+            on: (event, callback) => {
+                this.on(`${botName}:${event}`, callback);
+            },
+            
+            off: (event, callback) => {
+                this.off(`${botName}:${event}`, callback);
+            },
+            
+            once: (event, callback) => {
+                this.once(`${botName}:${event}`, callback);
+            },
+            
+            // Методы управления
+            connect: () => this.connectBot(botName),
+            disconnect: () => this.disconnectBot(botName),
+            
+            // Проверка статуса
+            isConnected: () => this.isBotConnected(botName)
+        };
+
+        return bot; // ботик <3
+    }
+
+    /**     
+     * Настройка событий бота (для внутреннего использования)
+     * @param {string} botName - Имя бота
+     * @param {object} client - Объект клиента бота
+     */
+    _setupBotEvents(botName, client) {
+        logDebug('_setupBotEvents called for botName:', botName); // логируем вызов функции
+        let chatinterval = null; // интервал для чата
+
+        client.on('connection_au_serveur_ddrace', () => { // Шок контент бот зашел на сервер
+            const botInfo = this.activeBots.get(botName); // получаем инфу о боте
+            if (!botInfo) { 
+                return; // бот не найден фак
+            } else {
+                botInfo.isConnected = true; // обновляем статус
+            }
+            this.emit(`${botName}:connect`); // емитим событие коннекта1
+            this.emit(`${botName}:connected`); // емитим событие коннекта2
+            logDebug(`${botName} connected to server`); // логируем подключение
+        });
+
+        client.on('disconnect', (reason) => { // бот отключился от сервера
+            let botInfo = this.activeBots.get(botName); // получаем инфу о боте
+            if (!botInfo) { 
+                return; // бот не найден фак
+            } else {
+                botInfo.isConnected = false; // обновляем статус
+                clearInterval(chatinterval); // очищаем интервал чата
+            }
+
+            if (botInfo.parameter.reconnect && (botInfo.parameter.reconnectAttempts>0 || botInfo.parameter.reconnectAttempts===-1)) {
+                if (botInfo.parameter.reconnectAttempts!==-1)botInfo.parameter.reconnectAttempts--;
+
+                let reconnectTime = 10000;
+                logDebug('base reconnect time is '+reconnectTime+'ms');
+                logDebug('Calculating reconnect time for botName: ', botName);
+                if (reason.startsWith('You have been banned')) { // бота забанили, фааааааак
+                    if (reason.startsWith('You have been banned for 5 minutes (Banned by vote)')) { // похуй, это всего лишь 5 минут и воутом а не админ
+                        reconnectTime = 300000; // 5 минут
+                    } else {
+                        reconnectTime = 1000000; // ФАК админ забанил, надеемся что не долго
+                    }
+                } else if (reason.startsWith('Too many connections in a short time')) { // ладненько
+                    reconnectTime = 20000; // 20 секунд
+                } else if (reason.startsWith('Timed Out. (no packets received for ')) { // таймаут, если инет есть, просто нужно еще пару раз поконектиться и пройдет
+                    reconnectTime = 500; // 0.5 секунд
+                }
+
+                logDebug('Base reconnect time set to:', reconnectTime);
+                if (botInfo.parameter.randreconnect) { // рандомайзер времени риконнекта
+                    const randomtime = random(reconnectTime, reconnectTime+random(100, 1000)); // рандом от базового времени до базового + 1 секунда
+                    reconnectTime = randomtime; // устанавливаем рандомное время
+                    logDebug('Randomized reconnect time to: ', reconnectTime); // логируем рандомное время
+                }
+
+                this.emit(`${botName}:disconnect`, reason, reconnectTime);
+                this.emit(`${botName}:disconnected`, reason, reconnectTime);
+                logDebug(`${botName} disconnected due to: `, reason, '\nand reconnecting in ', reconnectTime, 'ms');
+                setTimeout(() => {
+                    client.joinDDRaceServer();
+                    this.emit(`${botName}:reconnect`, reconnectTime);
+                    logDebug(`${botName} reconnect now`);
+                }, reconnectTime);
+            } else {
+                this.emit(`${botName}:disconnect`, reason);
+                this.emit(`${botName}:disconnected`, reason);
+                logDebug(`${botName} disconnected due to: `, reason);
+            }
+        });
+
+        client.on('snapshot', (snapshot) => {
+            try {
+                const myDDNetChar = client.SnapshotUnpacker.getObjExDDNetCharacter(client.SnapshotUnpacker.OwnID);
+            if (myDDNetChar) {
+                const isFrozen = myDDNetChar.m_FreezeEnd !== 0;
+                this.botFreezeStates.set(botName, isFrozen);
+            }
+            } catch (error) {
+                logDebug('Error processing snapshot for botName:', botName, error);
+            }
+
+            try {
+                const oldList = this.playerLists.get(botName) || [];
+                const playerMap = new Map(oldList.map(p => [p.client_id, p]));
+
+                for (let client_id = 0; client_id < 64; client_id++) {
+                    const clientInfo = client.SnapshotUnpacker.getObjClientInfo(client_id);
+                    const playerInfo = client.SnapshotUnpacker.getObjPlayerInfo(client_id);
+                    const ddnetChar = client.SnapshotUnpacker.getObjExDDNetCharacter
+                        ? client.SnapshotUnpacker.getObjExDDNetCharacter(client_id)
+                        : null;
+
+                    if (clientInfo && clientInfo.name && playerInfo && playerInfo.m_Team !== -1) {
+                        playerMap.set(client_id, {
+                            client_id,
+                            name: clientInfo.name,
+                            clan: clientInfo.clan || '',
+                            country: clientInfo.country || -1,
+                            team: playerInfo.m_Team,
+                            skin: clientInfo.skin || 'default',
+                            x: ddnetChar ? ddnetChar.m_X : null,
+                            y: ddnetChar ? ddnetChar.m_Y : null
+                        });
+                    }
+                }
+                this.playerLists.set(botName, Array.from(playerMap.values()));
+            } catch (error) {
+                logDebug('Error updating player list for botName:', botName, error);
+            }
+
+            this.emit(`${botName}:snapshot`, snapshot);
+        });
+
+        let s = new Set(); // сет
+        chatinterval = setInterval(() => {
+            s.clear();
+        }, 1000); // чистка
+        client.on('message_au_serveur', (msg) => {
+            this.emit(`${botName}:message`, msg); // Сырое сообщение, без фильтрации
+
+            const msgraw = msg; // ориг для чата на всякий
+            const text = msg.message; // само сообщение
+            const client_id = msg.client_id; // айди отправителя
+            const autormsg = msg.client_id === -1 ? "system" : this.getPlayerName(botName, client_id) || (msg.utilisateur?.InformationDuBot?.name || null) // имя отправителя
+            const team = msg.team; // команда отправителя
+
+            // фильтрация дубликатов сообщений
+            const key = `${client_id}:${text}:${team}`;
+            if (s.has(key)) return;
+            s.add(key);
+
+            // емитим.
+            if (client_id !== -1) this.emit(`${botName}:ChatNoSystem`, msgraw, autormsg, text, team, client_id); // все только без системы или сервера
+            this.emit(`${botName}:ChatRaw`, msgraw, autormsg, text, team, client_id); // все сообщения
+        });
+
+        client.on('error', (error) => {
+            logDebug('error event for botName:', botName, error);
+            this.emit(`${botName}:error`, error);
+        });
+
+        client.on('map_details', (mapDetails) => {
+            logDebug('map_details event for botName:', botName, mapDetails.map_url, mapDetails.map_name);
+            this.emit(`${botName}:map_details`, mapDetails);
+        });
+    }
+    /**
+     * Получение списка игроков подключенных к тому же серверу что и бот
+     * @param {string} botName 
+     * @returns {Array} - Массив объектов игроков
+     */
+    getPlayerList(botName) {
+        return this.playerLists.get(botName) || [];
+    }
+
+    /**
+     * Получение имени игрока по его clientId
+     * @param {string|Array} botName - Имя бота. Или, если конечно нужно, массив игроков.
+     * @param {number} clientId - ID клиента игрока
+     * @returns {string|null} - Имя игрока или null если не найден
+     */
+    getPlayerName(botName, clientId) {
+        if (clientId === -1) return null;
+        if (botName === null || botName === undefined) return null;
+        if (Array.isArray(botName)) {
+            const name = botName.find(bot => bot.client_id === clientId)?.name || null;
+            return name;
+        } else {
+            const playerList = this.getPlayerList(botName);
+            const player = playerList.find(p => p.client_id === clientId);
+            return player ? player.name : null;
+        }
+    }
+}
+
+module.exports = { BotManager, logDebuger }; // экспортируем BotManager и дебагер

package/src/bot/index.js

@@ -0,0 +1,5 @@
+"use strict";
+const { BotManager, logDebuger } = require('./bot'); // Импортируем BotManager из модуля bot.js
+const bot = new BotManager(); // Создаем экземпляр BotManager
+
+module.exports = { bot, BotManager, logDebuger }; // Экспортируем bot, BotManager, logDebuger

package/src/debug.js

@@ -0,0 +1,108 @@
+"use strict";
+
+let hasChalk = false;
+let chalklib;
+try {
+    require.resolve('chalk');
+    chalklib = require('chalk');
+    hasChalk = true;
+} catch {
+    hasChalk = false;
+}
+
+class DebugLogger {
+    /**
+     * Класс DebugLogger.
+     * @param {string} prefix - Префикс для сообщений отладки.
+     * @param {boolean} isDebug - Флаг для включения/выключения режима отладки.
+     * @param {boolean} islog - Флаг для использования console.log вместо console.debug.
+     * @param {object} prefixforprefix - Префикс для префикса. Аррей, Array где 1 айтем для начала, и 2 для конца оригинальноо префикса.
+     * @param {boolean} chalk - Изпользовать красивый цветной текст или нет.
+     */
+    constructor(prefix, isDebug = false, islog = true, prefixforprefix = ['[',']'], chalk = true) {
+        /**
+         * @var {boolean} isDebug - Флаг для включения/выключения режима отладки
+         */
+        if (typeof isDebug === "boolean") this.isDebug = isDebug; else this.isDebug = false;
+        /** 
+         * @var {boolean} islog - Флаг для использования console.log вместо console.debug
+         */
+        if (typeof islog === "boolean") this.islog = islog; else this.islog = true;
+        /**
+         * @var {string} prefix - Префикс для сообщений отладки
+         */
+        if (typeof prefix === "string") this.prefix = prefix; else this.prefix = "null";
+        /**
+         * @var {object} prefixforprefix - Array Массив из двух строк, которые будут по бокам обычного префикса.
+         */
+        if (Array.isArray(prefixforprefix)) this.prefixforprefix = prefixforprefix; else this.prefixforprefix = ['[',']'];    
+        /**
+         * @var {boolean} chalk - Изпользовать ли цветные тексты.
+         */
+        if (typeof chalk === "boolean") this.chalk = chalk; else this.chalk = hasChalk;
+    }
+
+    /**
+     * (Для внутреннего изпользования)
+     * Формат, ПфП1, префикс, ПфП2, Аргументы.
+     * @param {string} prefix - Префикс
+     * @param {object} prefixforprefix - ПфП, то что по бокам префикса.
+     * @param  {...any} args - Данные.
+     * @returns {string} Цветовой текст в формате.
+     */
+    _format(prefix, prefixforprefix, ...args) {
+        if (this.chalk && hasChalk)
+            return [chalklib.grey(prefixforprefix[0]), chalklib.green(prefix), chalklib.grey(prefixforprefix[1]), chalklib.blue(...args)];
+        return [prefixforprefix[0], prefix, prefixforprefix[1], ...args];
+    }
+
+    /**
+     * Функция для логирования отладочной информации
+     * @param {...*} args - Аргументы для логирования
+     */
+    logDebug(...args) {
+        const prefix = this.prefix; // Используем префикс из свойства класса
+        const prefixforprefix = this.prefixforprefix; // префикс для префикса
+        if (this.isDebug) { // Проверяем, включен ли режим отладки
+            if (this.islog) { // Проверяем, использовать ли console.log
+                console.log(...this._format(prefix, prefixforprefix, ...args));
+            } else { // Иначе
+                console.debug(...this._format(prefix, prefixforprefix, ...args));
+            }
+        }
+    }
+
+    /** 
+     * Функция для установки режима отладки и использования console.log
+     * @param {boolean} debugMode - Включить или выключить режим отладки
+     * @param {boolean} useLog - Использовать console.log вместо console.debug
+     * @param {boolean} chalk - Изпользовать ли цветной текст или нет
+     */
+    setDebugMode(debugMode, useLog = true, chalk = this.chalk) { // лог по умолчанию, потому что мне так удобнее
+        this.chalk = chalk
+        this.isDebug = debugMode; // Устанавливаем режим отладки
+        this.islog = useLog; // Устанавливаем использование console.log
+    }
+}
+
+// Экспортируем класс DebugLogger
+module.exports = DebugLogger;
+module.exports.DebugLogger = DebugLogger; // ну чтобы можно было класно короче
+
+
+// Пример использования класса DebugLogger
+if (require.main === module) { // Только если запускаеться напрямую
+    let test = new DebugLogger('test', true, true, ["[","]"], true); // Создаем экземпляр класса с префиксом 'test', режим отладки включен и используем console.log
+    function log() {
+        test.logDebug('cum.'); // Логируем сообщение
+        test.setDebugMode(false); // Выключаем режим отладки
+        test.logDebug('ето не выведется.'); // Это сообщение не будет выведено
+        test.setDebugMode(true, false); // Включаем режим отладки и используем console.debug
+        test.logDebug('ето выведется в console.debug.'); // Логируем сообщение
+    }
+    log(); // тестовая функция
+    test = new DebugLogger('говно', true, true, ['1','Какашечка'], false); // создаем новый екземпляр с другими настройками
+    log(); // тестовая функция 2
+    test = new DebugLogger('кал', true, true, ['Абоба','2'], true); // снова создаем новый екземпляр с другими настройками
+    log(); // тестовая функция 3
+}

package/src/map/automaploader.js

@@ -0,0 +1,60 @@
+"use strict";
+const { bot } = require('../bot');
+const mapLoader = require('./maploader');
+const DebugLogger = require('../debug');
+const logDebuger = new DebugLogger('Automaploader', false, true);
+const logdebug = logDebuger.logDebug;
+
+const EventEmitter = require('events');
+const eventEmitter = new EventEmitter();
+
+const registeredHandlers = new Set(); // чтобы не срать обработчиками
+
+
+/** * Функция для работы с Automaploader
+ * @param {string} botName - Имя бота, для которого будет работать Automaploader
+ * @param {string} dir - Папка, в которую будут загружаться карты
+ * @returns {Promise<void>} Пустой промис после регистрации обработчика
+ */
+async function work(botName, dir) {
+    // Проверяем, не зарегистрирован ли уже обработчик для этого бота
+    const handlerKey = `${botName}:map_details`;
+    if (registeredHandlers.has(handlerKey)) {
+        return; // Обработчик уже зарегистрирован
+    }
+    
+    registeredHandlers.add(handlerKey); // Добавляем обработчик в множество
+
+    // Регистрация обработчика события map_details для данного бота
+    bot.on(`${botName}:map_details`, (mapDetails) => {
+        const mapName = mapDetails.map_name; // Извлекаем имя карты из объекта mapDetails
+        logdebug(`Automaploader`, `Received map details for bot "${botName}":`, mapDetails);
+        // Вызываем загрузку карты с помощью mapLoader
+        mapLoader.loadMap(mapName, dir)
+            .then((loaded) => {
+                eventEmitter.emit(`automaploader:map_loaded`, { loaded, mapDetails, botName, dir});
+                logdebug(`Automaploader`, `Map "${mapName}" loaded: ${loaded}, for bot "${botName}"`);
+            });
+    });
+}
+
+/**
+ * Automaploader — объект для автоматической загрузки карт
+ */
+const Automaploader = {
+    /**
+     * Запускает автомаплоадер для бота
+     * @param {string} botName - Имя бота
+     * @param {string} dir - Папка для загрузки карт
+     */
+    work,
+
+    /**
+     * Подписка на события Automaploader
+     * @param {string} event - Имя события (Пока что только одно, "automaploader:map_loaded")
+     * @param {function(Object): void} callback - Колбэк для события с объектом { loaded, mapDetails, botName, dir }
+     */
+    on: eventEmitter.on.bind(eventEmitter)
+};
+
+module.exports = { Automaploader, logDebuger };

package/src/map/maploader.js

@@ -0,0 +1,135 @@
+"use strict";
+const fs = require("fs"); // фс
+const path = require("path"); // патх
+const https = require("https"); // хттпс
+const DebugLogger = require("../debug"); // дебаглоггер
+const logDebuger = new DebugLogger("MapLoader", false, true); // создаем дебагер
+const logdebug = logDebuger.logDebug.bind(logDebuger); // закидываем сюда чтобы писать короче
+
+/**
+ * Получает тип карты с ddnet.org
+ * @param {string} mapName - Имя карты
+ * @returns {Promise<string>} - Тип карты
+ */
+function fetchMapType(mapName) {
+  logdebug("Fetching map type for:", mapName);
+  const url = `https://ddnet.org/maps/?json=${encodeURIComponent(mapName)}`; // сылОчка1
+  return new Promise((resolve, reject) => {
+    logdebug("Requesting URL:", url);
+    https.get(url, (res) => { // Получаем ответ
+      logdebug("Received response with status code:", res.statusCode);
+      if (res.statusCode !== 200) {
+        reject(new Error(`Failed to fetch map type: ${res.statusCode}`)); // пропердоливаемся1
+        return;
+      }
+
+      let rawData = ""; // не приготовненная дата
+      res.on("data", (chunk) => (rawData += chunk)); // плюсуем чанки
+      res.on("end", () => { // КОНЕЦ
+        logdebug("end of data received");
+        try { // пытаемся, пытаемся...
+          const json = JSON.parse(rawData); // парсим жсон
+          const type = json.type.toLowerCase(); // типа
+          if (json && type) { // если есть жсон и тип
+            logdebug("Fetched map type:", type);
+            resolve(type); // резолвим тип
+          } else { // иначе
+            logdebug("Map type not found in response");
+            reject(new Error("Map type not found in response")); // пропердоливаемся2
+          }
+        } catch (e) { // е
+          reject(new Error("Failed to parse map type JSON")); // пропердоливаемся3
+        }
+      });
+    }).on("error", reject); // еще раз пропердоливаемся4
+  });
+}
+
+/** Загрузка карты по имени и типу
+ * @param {string} mapName - Имя карты
+ * @param {string} type - Тип карты
+ * @param {string} MAP_DIR_DM - Папка для загрузки карты
+ * @returns {Promise<string>} - Путь к загруженной карте
+ */
+function downloadMap(mapName, type, MAP_DIR_DM) {
+  const filePath = path.join(MAP_DIR_DM, `${mapName}.map`); // прикидываем путь
+  logdebug("Downloading map:", mapName, "of type:", type, "to:", filePath);
+  if (fs.existsSync(filePath)) {
+    logdebug("Map already exists at:", filePath);
+    return Promise.resolve(filePath); // если карта уже есть, резолвим путь а точнее отдыхаем и не напрягаемся1
+  }
+
+  const url = `https://raw.githubusercontent.com/ddnet/ddnet-maps/master/types/${type}/maps/${mapName}.map`; // сылОчка2
+  logdebug("Map download URL:", url);
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(MAP_DIR_DM)) {
+      reject(new Error(`Directory does not exist: ${MAP_DIR_DM}`)); // Директории нет, отдыхаем и не напрягаемся2
+      return;
+    }
+    const fileStream = fs.createWriteStream(filePath); // начинаем стримить на твич
+    https.get(url, (res) => { // Получаем ответ
+      logdebug("Received response with status code:", res.statusCode);
+      if (res.statusCode !== 200) {
+        reject(new Error(`Failed to download map: ${res.statusCode}`)); // пропердоливаемся5
+        return;
+      }
+
+      res.pipe(fileStream); // пипе
+      fileStream.on("finish", () => { // финиш
+        logdebug("Map downloaded to:", filePath);
+        fileStream.close(); // завершаем стрим и отдыхаем и не напрягаемся3
+        resolve(filePath); // резолвим путь
+      });
+    }).on("error", (err) => {
+      logdebug("Error downloading map:", err.message);
+      if (fs.existsSync(filePath)) fs.unlinkSync(filePath);// пропердоливаемся6 и удаляем файл, если он есть конечно
+      reject(err); 
+    });
+  });
+}
+
+/** 
+ * Пытается загрузить карту и возвращает успех или неудачу
+ * @param {string} mapName - Имя карты
+ * @param {string} type - Тип карты
+ * @param {string} MAP_DIR - Папка для загрузки карты
+ * @returns {Promise<boolean>} - Успех или неудача загрузки
+ */
+async function tryDownloadMap(mapName, type, MAP_DIR) {
+  logdebug("Trying to download map:", mapName, "of type:", type);
+  try { // пытаемся
+    await downloadMap(mapName, type, MAP_DIR);  // ждемс
+    return true; // да
+  } catch (e) { // фак, провалились
+    logdebug("Failed to download map:", JSON.stringify(e.message, null, 2));
+    return false; // нет
+  }
+}
+
+/**
+ * Загружает карту по имени в указанную папку
+ * @param {string} mapName - Имя карты
+ * @param {string} MAP_DIR - Папка для загрузки карты
+ * @returns {Promise<boolean>} - Успех или неудача загрузки
+ */
+async function loadMap(mapName, MAP_DIR) {
+  logdebug("Loading map:", mapName, "into directory:", MAP_DIR);
+  const type = await fetchMapType(mapName); // получаем тип карты
+  return await tryDownloadMap(mapName, type, MAP_DIR); // пытаемся загрузить карту и возвращаем результат
+}
+
+/**
+ * Расширенные функции для работы с картами
+ */
+const advanced = {
+  downloadMap,
+  tryDownloadMap,
+  logDebuger // экспортируем дебаглоггер
+}
+
+// Экспортируем функции
+module.exports = {
+  fetchMapType, // получитьТипКарты
+  loadMap, // загрузитьКарту
+  advanced // продвинутые или расширенные, или пашёл ты
+};