ddbot.js-0374 3.2.7 → 4.0.0

package/lib/core/ddutils.js

@@ -0,0 +1,149 @@
+export function DefaultIdentity(name = 'nameless tee') {
+    return {
+        name: name,
+        clan: "",
+        skin: "default",
+        use_custom_color: 0,
+        color_body: 0,
+        color_feet: 0,
+        country: 0
+    };
+}
+export function IsValidIdentity(identity) {
+    if (!identity || typeof identity !== 'object') {
+        return false;
+    }
+    const obj = identity;
+    // Только name обязательно!
+    if (!('name' in obj))
+        return false;
+    if (typeof obj.name !== 'string')
+        return false;
+    if (obj.name.length > 15 || obj.name.length === 0)
+        return false;
+    // Остальные поля опциональны, но если есть - валидируй
+    if ('clan' in obj) {
+        if (typeof obj.clan !== 'string')
+            return false;
+        if (obj.clan.length > 11)
+            return false;
+    }
+    if ('skin' in obj) {
+        if (typeof obj.skin !== 'string')
+            return false;
+        if (obj.skin.length > 23 || obj.skin.length === 0)
+            return false;
+    }
+    if ('use_custom_color' in obj) {
+        if (typeof obj.use_custom_color !== 'number')
+            return false;
+        if (obj.use_custom_color !== 0 && obj.use_custom_color !== 1)
+            return false;
+    }
+    if ('color_body' in obj) {
+        if (typeof obj.color_body !== 'number')
+            return false;
+        if (!Number.isInteger(obj.color_body) || obj.color_body < 0)
+            return false;
+    }
+    if ('color_feet' in obj) {
+        if (typeof obj.color_feet !== 'number')
+            return false;
+        if (!Number.isInteger(obj.color_feet) || obj.color_feet < 0)
+            return false;
+    }
+    if ('country' in obj) {
+        if (typeof obj.country !== 'number')
+            return false;
+        if (!Number.isInteger(obj.country) || obj.country < -1 || obj.country > 999)
+            return false;
+    }
+    return true;
+}
+export function IsValidClient(client) {
+    if (!client || typeof client !== 'object') {
+        return false;
+    }
+    const obj = client;
+    const requiredMethods = ['Flush', 'SendMsgRaw', 'sendInput', 'Disconnect', 'connect'];
+    for (const method of requiredMethods) {
+        if (typeof obj[method] !== 'function') {
+            return false;
+        }
+    }
+    return true;
+}
+export function IsValidInput(input) {
+    if (!input || typeof input !== 'object') {
+        return false;
+    }
+    const obj = input;
+    const requiredFields = ['m_Direction', 'm_TargetX', 'm_TargetY', 'm_Jump', 'm_Fire', 'm_Hook', 'm_PlayerFlags', 'm_WantedWeapon', 'm_NextWeapon', 'm_PrevWeapon'];
+    for (const field of requiredFields) {
+        if (!(field in obj) || typeof obj[field] !== 'number' || !Number.isInteger(obj[field])) {
+            return false;
+        }
+    }
+    if (obj.m_Direction < -1 || obj.m_Direction > 1)
+        return false;
+    if (obj.m_Jump !== 0 && obj.m_Jump !== 1)
+        return false;
+    if (obj.m_Fire !== 0 && obj.m_Fire !== 1)
+        return false;
+    if (obj.m_Hook !== 0 && obj.m_Hook !== 1)
+        return false;
+    if (obj.m_WantedWeapon < 1 || obj.m_WantedWeapon > 6)
+        return false;
+    if (obj.m_NextWeapon !== 0 && obj.m_NextWeapon !== 1)
+        return false;
+    if (obj.m_PrevWeapon !== 0 && obj.m_PrevWeapon !== 1)
+        return false;
+    return true;
+}
+export function random(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+export function connectionInfo() {
+    return {
+        addr: 'string',
+        port: 8303
+    };
+}
+export function reconstructPlayerInput(char, ddnetChar = null, tick = null) {
+    const input = {
+        direction: char.character_core.direction,
+        target_x: 0,
+        target_y: -1,
+        jump: 0,
+        fire: 0,
+        hook: 0,
+        player_flags: char.player_flags || 0,
+        wanted_weapon: char.weapon,
+        next_weapon: 0,
+        prev_weapon: 0
+    };
+    if (ddnetChar && (ddnetChar.m_TargetX !== 0 || ddnetChar.m_TargetY !== 0)) {
+        input.target_x = ddnetChar.m_TargetX;
+        input.target_y = ddnetChar.m_TargetY;
+    }
+    else {
+        const angleRad = (char.character_core.angle / 256.0) * Math.PI / 128.0;
+        input.target_x = Math.cos(angleRad) * 256;
+        input.target_y = Math.sin(angleRad) * 256;
+    }
+    if (input.target_x === 0 && input.target_y === 0) {
+        input.target_y = -1;
+    }
+    const hookActive = char.character_core.hook_state !== 0 ||
+        char.character_core.hooked_player !== -1;
+    input.hook = hookActive ? 1 : 0;
+    const jumped = char.character_core.jumped;
+    const grounded = Math.abs(char.character_core.vel_y) < 1 && jumped === 0;
+    input.jump = jumped > 0 && !grounded ? 1 : 0;
+    const isNinja = ddnetChar != null && (ddnetChar.m_Flags & 0x20) !== 0;
+    input.wanted_weapon = isNinja ? 5 : char.weapon;
+    const isAutofireWeapon = [2, 3, 4].includes(input.wanted_weapon);
+    const isJetpackGun = input.wanted_weapon === 1 && ddnetChar?.m_Flags != null;
+    input.fire = isAutofireWeapon || isJetpackGun ? 0 : 0; // без tick всегда 0
+    return input;
+}

package/lib/core/module.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from 'events';
+import type { Bot } from './core.js';
+interface BaseModuleOptions {
+    moduleName?: string;
+    offonDisconnect?: boolean;
+}
+declare class BaseModule extends EventEmitter {
+    protected readonly bot: Bot;
+    readonly moduleName: string;
+    isRunning: boolean;
+    private readonly _onDisconnect;
+    constructor(bot: Bot, options?: BaseModuleOptions);
+    /**
+     * Запускает модуль, если он ещё не запущен
+     * @param args — аргументы, которые будут переданы в _start
+     */
+    start(...args: unknown[]): void;
+    /**
+     * Останавливает модуль, если он запущен
+     */
+    stop(): void;
+    /**
+     * Метод, который нужно переопределить в наследниках
+     * Здесь происходит основная логика запуска
+     */
+    protected _start(...args: unknown[]): void;
+    /**
+     * Метод, который нужно переопределить в наследниках
+     * Здесь происходит очистка при остановке
+     */
+    protected _stop(): void;
+    /**
+     * Полная очистка модуля:
+     * - останавливает работу
+     * - снимает обработчик disconnect с bot
+     * - удаляет все слушатели событий самого модуля
+     */
+    destroy(): void;
+}
+export default BaseModule;

package/lib/core/module.js

@@ -0,0 +1,65 @@
+import { EventEmitter } from 'events';
+class BaseModule extends EventEmitter {
+    bot;
+    moduleName;
+    isRunning = false;
+    _onDisconnect;
+    constructor(bot, options = {}) {
+        super();
+        const { moduleName = 'Module' } = options;
+        if (!bot) {
+            throw new Error(`${moduleName} requires bot core`);
+        }
+        this.bot = bot;
+        this.moduleName = moduleName;
+        this._onDisconnect = () => this.destroy();
+        if (options.offonDisconnect !== false) {
+            this.bot.on('disconnect', this._onDisconnect);
+        }
+    }
+    /**
+     * Запускает модуль, если он ещё не запущен
+     * @param args — аргументы, которые будут переданы в _start
+     */
+    start(...args) {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this._start(...args);
+    }
+    /**
+     * Останавливает модуль, если он запущен
+     */
+    stop() {
+        if (!this.isRunning)
+            return;
+        this.isRunning = false;
+        this._stop();
+    }
+    /**
+     * Метод, который нужно переопределить в наследниках
+     * Здесь происходит основная логика запуска
+     */
+    _start(...args) {
+        // по умолчанию ничего не делаем
+    }
+    /**
+     * Метод, который нужно переопределить в наследниках
+     * Здесь происходит очистка при остановке
+     */
+    _stop() {
+        // по умолчанию ничего не делаем
+    }
+    /**
+     * Полная очистка модуля:
+     * - останавливает работу
+     * - снимает обработчик disconnect с bot
+     * - удаляет все слушатели событий самого модуля
+     */
+    destroy() {
+        this.stop();
+        this.bot.off('disconnect', this._onDisconnect);
+        this.removeAllListeners();
+    }
+}
+export default BaseModule;

package/lib/index.d.ts

@@ -0,0 +1,16 @@
+import { Bot } from './core/core.js';
+import * as DDUtils from './core/ddutils.js';
+import BaseModule from './core/module.js';
+import BotManager from './manager.js';
+import Chat from './modules/chat.js';
+import PlayerList from './modules/playerlist.js';
+import Reconnect from './modules/reconnect.js';
+import Snap from './modules/snap.js';
+import * as Types from './types.js';
+declare const StandardModules: {
+    Chat: typeof Chat;
+    PlayerList: typeof PlayerList;
+    Reconnect: typeof Reconnect;
+    Snap: typeof Snap;
+};
+export { Bot, Types, DDUtils, BaseModule, BotManager, StandardModules, };

package/lib/index.js

@@ -0,0 +1,16 @@
+import { Bot } from './core/core.js';
+import * as DDUtils from './core/ddutils.js';
+import BaseModule from './core/module.js';
+import BotManager from './manager.js';
+import Chat from './modules/chat.js';
+import PlayerList from './modules/playerlist.js';
+import Reconnect from './modules/reconnect.js';
+import Snap from './modules/snap.js';
+import * as Types from './types.js';
+const StandardModules = {
+    Chat,
+    PlayerList,
+    Reconnect,
+    Snap,
+};
+export { Bot, Types, DDUtils, BaseModule, BotManager, StandardModules, };

package/lib/manager.d.ts

@@ -0,0 +1,17 @@
+import { Bot } from './core/core.js';
+import { EventEmitter } from 'events';
+declare class BotManager extends EventEmitter {
+    private bots;
+    private names;
+    constructor();
+    private botevents;
+    private createUniqueName;
+    createBot(...config: ConstructorParameters<typeof Bot>): string;
+    removeBotById(id: string): Promise<void>;
+    addBot(bot: Bot): string;
+    getBotById(id: string): Bot | undefined;
+    disconnectAllBots(): Promise<void>;
+    removeAllBots(): Promise<void>;
+    sendinputToAllBots(input: any): void;
+}
+export default BotManager;

package/lib/manager.js

@@ -0,0 +1,136 @@
+import { Bot } from './core/core.js';
+import { EventEmitter } from 'events';
+import * as Types from './types.js';
+class BotManager extends EventEmitter {
+    bots = new Map();
+    names = new Set();
+    constructor() {
+        super();
+    }
+    botevents(id, bot) {
+        bot.on('connect', (data) => {
+            this.emit(id + ':connect', data);
+        });
+        bot.on('disconnect', (reason, data) => {
+            this.emit(id + ':disconnect', reason, data);
+        });
+        bot.on('broadcast', (message) => {
+            this.emit(id + ':broadcast', message);
+        });
+        bot.on('capabilities', (message) => {
+            this.emit(id + ':capabilities', message);
+        });
+        bot.on('emote', (message) => {
+            this.emit(id + ':emote', message);
+        });
+        bot.on('kill', (message) => {
+            this.emit(id + ':kill', message);
+        });
+        bot.on('snapshot', (message) => {
+            this.emit(id + ':snapshot', message);
+        });
+        bot.on('map_change', (message) => {
+            this.emit(id + ':map_change', message);
+        });
+        bot.on('motd', (message) => {
+            this.emit(id + ':motd', message);
+        });
+        bot.on('message', (message) => {
+            this.emit(id + ':message', message);
+        });
+        bot.on('teams', (message) => {
+            this.emit(id + ':teams', message);
+        });
+        bot.on('teamkill', (message) => {
+            this.emit(id + ':teamkill', message);
+        });
+        bot.on('spawn', (message) => {
+            this.emit(id + ':spawn', message);
+        });
+        bot.on('death', (message) => {
+            this.emit(id + ':death', message);
+        });
+        bot.on('hammerhit', (message) => {
+            this.emit(id + ':hammerhit', message);
+        });
+        bot.on('sound_world', (message) => {
+            this.emit(id + ':sound_world', message);
+        });
+        bot.on('explosion', (message) => {
+            this.emit(id + ':explosion', message);
+        });
+        bot.on('common', (message) => {
+            this.emit(id + ':common', message);
+        });
+        bot.on('damage_indicator', (message) => {
+            this.emit(id + ':damage_indicator', message);
+        });
+        bot.on('sound_global', (message) => {
+            this.emit(id + ':sound_global', message);
+        });
+    }
+    createUniqueName() {
+        const baseName = 'bot_';
+        let counter = this.names.size + 1;
+        while (this.names.has(baseName + counter)) {
+            counter++;
+        }
+        const uniqueName = baseName + counter;
+        this.names.add(uniqueName);
+        return uniqueName;
+    }
+    createBot(...config) {
+        const bot = new Bot(...config);
+        const id = this.createUniqueName();
+        this.botevents(id, bot);
+        this.bots.set(id, bot);
+        return id;
+    }
+    async removeBotById(id) {
+        const bot = this.bots.get(id);
+        if (bot) {
+            await bot.destroy();
+            this.bots.delete(id);
+        }
+    }
+    addBot(bot) {
+        const id = this.createUniqueName();
+        this.bots.set(id, bot);
+        return id;
+    }
+    getBotById(id) {
+        return this.bots.get(id);
+    }
+    async disconnectAllBots() {
+        for (const bot of this.bots.values()) {
+            try {
+                await bot?.disconnect();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    async removeAllBots() {
+        for (const bot of this.bots.values()) {
+            try {
+                await bot?.destroy();
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        this.bots.clear();
+    }
+    sendinputToAllBots(input) {
+        for (const bot of this.bots.values()) {
+            try {
+                bot?.send_input(input);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+}
+export default BotManager;

package/lib/modules/chat.d.ts

@@ -0,0 +1,46 @@
+import BaseModule from '../core/module.js';
+import type { Bot } from '../core/core.js';
+import * as Types from '../types.js';
+interface ChatEvents {
+    anychat: (msg: Types.SnapshotItemTypes.iMessage, author: string | null, text: string, team: number, client_id: number) => void;
+    chat: (msg: Types.SnapshotItemTypes.iMessage, author: string, text: string, team: number, client_id: number) => void;
+    systemchat: (msg: Types.SnapshotItemTypes.iMessage, text: string) => void;
+    queued: (info: {
+        text: string;
+        team: boolean;
+        queueSize: number;
+    }) => void;
+    sent: (info: {
+        text: string;
+        team: boolean;
+        queueSize: number;
+    }) => void;
+}
+declare class Chat extends BaseModule {
+    private chatinterval;
+    private sendinterval;
+    private readonly chatset;
+    private readonly queue;
+    private lastSentTime;
+    private cooldown;
+    private readonly chatlistener;
+    constructor(bot: Bot);
+    /**
+     * Добавить сообщение в очередь на отправку
+     *
+     * @param text     текст сообщения
+     * @param team     отправить в командный чат? (true = team, false = all)
+     * @param priority добавить в начало очереди (приоритетное сообщение)
+     * @returns true если сообщение добавлено в очередь
+     */
+    send(text: string, team?: boolean, priority?: boolean): boolean;
+    private _processQueue;
+    protected _start(interval?: number, cooldown?: number): void;
+    protected _stop(): void;
+    destroy(): void;
+    on<K extends keyof ChatEvents>(event: K, listener: ChatEvents[K]): this;
+    once<K extends keyof ChatEvents>(event: K, listener: ChatEvents[K]): this;
+    emit<K extends keyof ChatEvents>(event: K, ...args: Parameters<ChatEvents[K]>): boolean;
+    off<K extends keyof ChatEvents>(event: K, listener: ChatEvents[K]): this;
+}
+export default Chat;

package/lib/modules/chat.js

@@ -0,0 +1,120 @@
+import BaseModule from '../core/module.js';
+import * as Types from '../types.js';
+class Chat extends BaseModule {
+    chatinterval = null;
+    sendinterval = null;
+    chatset = new Set();
+    queue = [];
+    lastSentTime = 0;
+    cooldown = 1000;
+    chatlistener = (msg) => {
+        try {
+            const msgraw = msg;
+            const text = String(msgraw?.message ?? '');
+            const client_id = msgraw.client_id ?? -1;
+            const team = msgraw.team ?? 0;
+            const autormsg = msgraw?.author?.ClientInfo?.name ?? null;
+            const key = `${client_id}:${text}:${team}`;
+            if (this.chatset.has(key))
+                return;
+            this.chatset.add(key);
+            this.emit('anychat', msgraw, autormsg, text, team, client_id);
+            if (autormsg) {
+                this.emit('chat', msgraw, autormsg, text, team, client_id);
+            }
+            else {
+                this.emit('systemchat', msgraw, text);
+            }
+        }
+        catch (e) {
+            console.error(`[${this.moduleName}] chat listener error:`, e);
+        }
+    };
+    constructor(bot) {
+        super(bot, { moduleName: 'Chat', offonDisconnect: false });
+    }
+    /**
+     * Добавить сообщение в очередь на отправку
+     *
+     * @param text     текст сообщения
+     * @param team     отправить в командный чат? (true = team, false = all)
+     * @param priority добавить в начало очереди (приоритетное сообщение)
+     * @returns true если сообщение добавлено в очередь
+     */
+    send(text, team = false, priority = false) {
+        if (!text || text.trim().length === 0) {
+            return false;
+        }
+        const item = { text, team };
+        if (priority) {
+            this.queue.unshift(item);
+        }
+        else {
+            this.queue.push(item);
+        }
+        this.emit('queued', {
+            text,
+            team,
+            queueSize: this.queue.length,
+        });
+        return true;
+    }
+    _processQueue() {
+        if (this.queue.length === 0)
+            return;
+        const now = Date.now();
+        if (now - this.lastSentTime < this.cooldown)
+            return;
+        const item = this.queue.shift();
+        if (!item)
+            return;
+        const { text, team } = item;
+        if (this.bot.bot_client?.game) {
+            this.bot.bot_client.game.Say(text, team);
+            this.lastSentTime = now;
+            this.emit('sent', {
+                text,
+                team,
+                queueSize: this.queue.length,
+            });
+        }
+    }
+    _start(interval = 1000, cooldown = 1000) {
+        this.cooldown = cooldown;
+        this.chatinterval = setInterval(() => {
+            this.chatset.clear();
+        }, interval);
+        this.sendinterval = setInterval(() => {
+            this._processQueue();
+        }, 100);
+        this.bot.on('message', this.chatlistener);
+    }
+    _stop() {
+        this.bot.off('message', this.chatlistener);
+        this.chatset.clear();
+        if (this.chatinterval) {
+            clearInterval(this.chatinterval);
+            this.chatinterval = null;
+        }
+        if (this.sendinterval) {
+            clearInterval(this.sendinterval);
+            this.sendinterval = null;
+        }
+    }
+    destroy() {
+        super.destroy();
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+}
+export default Chat;

package/lib/modules/playerlist.d.ts

@@ -0,0 +1,33 @@
+import BaseModule from '../core/module.js';
+import type { Bot } from '../core/core.js';
+import type { Types } from '../index.js';
+interface PlayerData {
+    client_id: number;
+    clientInfo: Types.SnapshotItemTypes.ClientInfo;
+    playerInfo: Types.SnapshotItemTypes.PlayerInfo;
+    character: Types.SnapshotItemTypes.Character | null;
+    DDNetCharacter: Types.SnapshotItemTypes.DDNetCharacter | null;
+}
+declare class PlayerList extends BaseModule {
+    constructor(bot: Bot);
+    private client;
+    private maxclients;
+    private playermap;
+    private previousMap;
+    private readonly snapshotlistener;
+    /**
+     * Get list of all players
+     */
+    get list(): [number, PlayerData][];
+    /**
+     * Get player by ID
+     */
+    getPlayer(client_id: number): PlayerData | null;
+    /**
+     * Get number of online players
+     */
+    getPlayerCount(): number;
+    protected _start(maxclients?: number): void;
+    protected _stop(): void;
+}
+export default PlayerList;