ddbot.js-0374 3.2.7 → 4.0.0

package/lib/modules/playerlist.js

@@ -0,0 +1,78 @@
+import BaseModule from '../core/module.js';
+class PlayerList extends BaseModule {
+    constructor(bot) {
+        super(bot, { moduleName: 'PlayerList', offonDisconnect: false });
+        this.client = this.bot.bot_client;
+    }
+    client;
+    maxclients = 64;
+    playermap = new Map();
+    previousMap = new Map();
+    snapshotlistener = () => {
+        this.previousMap = new Map(this.playermap);
+        this.playermap.clear();
+        if (!this.client)
+            return;
+        for (let client_id = 0; client_id < this.maxclients; client_id++) {
+            const clientInfo = this.client.SnapshotUnpacker.getObjClientInfo(client_id);
+            const playerInfo = this.client.SnapshotUnpacker.getObjPlayerInfo(client_id);
+            const character = this.client.SnapshotUnpacker.getObjCharacter(client_id);
+            const DDNetCharacter = this.client.SnapshotUnpacker.getObjExDDNetCharacter(client_id);
+            if (clientInfo && playerInfo) {
+                const playerData = {
+                    client_id,
+                    clientInfo,
+                    playerInfo,
+                    character: character || null,
+                    DDNetCharacter: DDNetCharacter || null,
+                };
+                this.playermap.set(client_id, playerData);
+                if (!this.previousMap.has(client_id)) {
+                    this.emit('player_joined', {
+                        client_id,
+                        name: clientInfo.name,
+                        playerData,
+                    });
+                }
+            }
+        }
+        for (const [client_id, oldData] of this.previousMap) {
+            if (!this.playermap.has(client_id)) {
+                this.emit('player_left', {
+                    client_id,
+                    name: oldData.clientInfo.name,
+                    playerData: oldData,
+                });
+            }
+        }
+        this.previousMap.clear();
+    };
+    /**
+     * Get list of all players
+     */
+    get list() {
+        return [...this.playermap];
+    }
+    /**
+     * Get player by ID
+     */
+    getPlayer(client_id) {
+        return this.playermap.get(client_id) || null;
+    }
+    /**
+     * Get number of online players
+     */
+    getPlayerCount() {
+        return this.playermap.size;
+    }
+    _start(maxclients = 64) {
+        this.maxclients = maxclients;
+        this.bot.on('snapshot', this.snapshotlistener);
+    }
+    _stop() {
+        this.bot.off('snapshot', this.snapshotlistener);
+        this.playermap.clear();
+        this.previousMap.clear();
+    }
+}
+export default PlayerList;

package/lib/modules/reconnect.d.ts

@@ -0,0 +1,14 @@
+import BaseModule from '../core/module.js';
+import type { Bot } from '../core/core.js';
+declare class Reconnect extends BaseModule {
+    private maxAttempts;
+    private randomDelay;
+    private currentAttempts;
+    private reconnecting;
+    constructor(bot: Bot);
+    protected _start(maxAttempts?: number, randomDelay?: boolean): void;
+    private handleDisconnect;
+    private calculateDelay;
+    protected _stop(): void;
+}
+export default Reconnect;

package/lib/modules/reconnect.js

@@ -0,0 +1,81 @@
+import BaseModule from '../core/module.js';
+import * as Types from '../types.js';
+class Reconnect extends BaseModule {
+    maxAttempts = -1;
+    randomDelay = true;
+    currentAttempts = 0;
+    reconnecting = false;
+    constructor(bot) {
+        super(bot, { moduleName: 'Reconnect', offonDisconnect: false });
+    }
+    _start(maxAttempts = -1, randomDelay = true) {
+        this.maxAttempts = maxAttempts;
+        this.randomDelay = randomDelay;
+        this.bot.on('disconnect', this.handleDisconnect);
+    }
+    handleDisconnect = (reason, connectionInfo) => {
+        if (reason === null)
+            return;
+        if (this.reconnecting)
+            return;
+        if (!connectionInfo.addr || !connectionInfo.port) {
+            this.emit('reconnect_failed', 'No connection info');
+            return;
+        }
+        if (this.maxAttempts !== -1 && this.currentAttempts >= this.maxAttempts) {
+            this.emit('reconnect_failed', this.currentAttempts);
+            return;
+        }
+        const delay = this.calculateDelay(reason);
+        this.reconnecting = true;
+        this.currentAttempts++;
+        this.emit('reconnecting', {
+            attempt: this.currentAttempts,
+            delay,
+            reason,
+            addr: connectionInfo.addr,
+            port: connectionInfo.port,
+        });
+        setTimeout(async () => {
+            try {
+                await this.bot.connect(connectionInfo.addr, connectionInfo.port);
+                this.currentAttempts = 0;
+                this.emit('reconnected', {
+                    addr: connectionInfo.addr,
+                    port: connectionInfo.port
+                });
+            }
+            catch (err) {
+                this.emit('reconnect_failed', err);
+            }
+            finally {
+                this.reconnecting = false;
+            }
+        }, delay);
+    };
+    calculateDelay(reason) {
+        let baseDelay = 10000;
+        if (reason.startsWith('You have been banned for 5 minutes')) {
+            baseDelay = 300000;
+        }
+        else if (reason.startsWith('You have been banned')) {
+            baseDelay = 1000000;
+        }
+        else if (reason.startsWith('Too many connections')) {
+            baseDelay = 20000;
+        }
+        else if (reason.startsWith('Timed Out')) {
+            baseDelay = 500;
+        }
+        if (this.randomDelay) {
+            return baseDelay + Math.random() * 1000;
+        }
+        return baseDelay;
+    }
+    _stop() {
+        this.bot.off('disconnect', this.handleDisconnect);
+        this.reconnecting = false;
+        this.currentAttempts = 0;
+    }
+}
+export default Reconnect;

package/lib/modules/snap.d.ts

@@ -0,0 +1,17 @@
+import BaseModule from '../core/module.js';
+import type { Bot } from '../core/core.js';
+import * as Types from '../types.js';
+declare class Snap extends BaseModule {
+    private readonly hammerHitlistener;
+    private readonly firelistener;
+    constructor(bot: Bot);
+    private static areWithinTile;
+    private static whoareWithinTile;
+    static angleshot(character: Types.SnapshotItemTypes.Character): {
+        x: number;
+        y: number;
+    } | null;
+    protected _start(): void;
+    protected _stop(): void;
+}
+export default Snap;

package/lib/modules/snap.js

@@ -0,0 +1,61 @@
+import BaseModule from '../core/module.js';
+import * as Types from '../types.js';
+class Snap extends BaseModule {
+    hammerHitlistener = (hit) => {
+        if (this.bot.OwnID === undefined)
+            return;
+        const ownCharacter = this.bot.bot_client?.SnapshotUnpacker.getObjCharacter(this.bot.OwnID);
+        if (!ownCharacter)
+            return;
+        if (Snap.areWithinTile(hit.common.x, hit.common.y, ownCharacter.character_core.x, ownCharacter.character_core.y)) {
+            this.emit('hammerhitme', hit, Snap.whoareWithinTile(hit.common.x, hit.common.y, this.bot.bot_client?.SnapshotUnpacker.AllObjCharacter || [], [this.bot.OwnID]));
+        }
+    };
+    firelistener = (sound) => {
+        const list = this.bot.bot_client?.SnapshotUnpacker?.AllObjCharacter || [];
+        if (sound.sound_id === 0) {
+            this.emit('fire', { common: sound.common }, Snap.whoareWithinTile(sound.common.x, sound.common.y, list));
+        }
+    };
+    constructor(bot) {
+        super(bot, { moduleName: 'Snap', offonDisconnect: false });
+    }
+    static areWithinTile(x1, y1, x2, y2) {
+        const TILE = 32 * 1.1;
+        const distanceX = Math.abs(x1 - x2);
+        const distanceY = Math.abs(y1 - y2);
+        return distanceX <= TILE && distanceY <= TILE;
+    }
+    static whoareWithinTile(x, y, list, ignoreClients = []) {
+        for (const character of list) {
+            const character_core = character?.character_core;
+            if (!character_core)
+                continue;
+            if (Snap.areWithinTile(x, y, character_core.x, character_core.y)) {
+                if (!ignoreClients.includes(character.client_id)) {
+                    return character.client_id;
+                }
+            }
+        }
+        return null;
+    }
+    static angleshot(character) {
+        if (!character || !character.character_core)
+            return null;
+        const client_angle = character.character_core.angle;
+        const angleRad = (client_angle / 256.0) * (Math.PI / 128.0);
+        return {
+            x: Math.cos(angleRad) * 256,
+            y: Math.sin(angleRad) * 256,
+        };
+    }
+    _start() {
+        this.bot.on('hammerhit', this.hammerHitlistener);
+        this.bot.on('sound_world', this.firelistener);
+    }
+    _stop() {
+        this.bot.off('hammerhit', this.hammerHitlistener);
+        this.bot.off('sound_world', this.firelistener);
+    }
+}
+export default Snap;

package/lib/types.d.ts

@@ -0,0 +1,255 @@
+/**
+ * Типы из библиотеки teeworlds
+ */
+export declare namespace SnapshotItemTypes {
+    interface PlayerInput {
+        direction: number;
+        target_x: number;
+        target_y: number;
+        jump: number;
+        fire: number;
+        hook: number;
+        player_flags: number;
+        wanted_weapon: number;
+        next_weapon: number;
+        prev_weapon: number;
+    }
+    interface iOptions {
+        identity?: Identity;
+        password?: string;
+        ddnet_version?: {
+            version: number;
+            release_version: string;
+        };
+        timeout?: number;
+        NET_VERSION?: string;
+        lightweight?: boolean;
+        timeout_on_connecting?: boolean;
+    }
+    interface Projectile {
+        x: number;
+        y: number;
+        vel_x: number;
+        vel_y: number;
+        type_: number;
+        start_tick: number;
+    }
+    interface Laser {
+        x: number;
+        y: number;
+        from_x: number;
+        from_y: number;
+        start_tick: number;
+    }
+    interface Pickup {
+        x: number;
+        y: number;
+        type_: number;
+        subtype: number;
+    }
+    interface Flag {
+        x: number;
+        y: number;
+        team: number;
+    }
+    interface GameInfo {
+        game_flags: number;
+        game_state_flags: number;
+        round_start_tick: number;
+        warmup_timer: number;
+        score_limit: number;
+        time_limit: number;
+        round_num: number;
+        round_current: number;
+    }
+    interface GameData {
+        teamscore_red: number;
+        teamscore_blue: number;
+        flag_carrier_red: number;
+        flag_carrier_blue: number;
+    }
+    interface CharacterCore {
+        tick: number;
+        x: number;
+        y: number;
+        vel_x: number;
+        vel_y: number;
+        angle: number;
+        direction: number;
+        jumped: number;
+        hooked_player: number;
+        hook_state: number;
+        hook_tick: number;
+        hook_x: number;
+        hook_y: number;
+        hook_dx: number;
+        hook_dy: number;
+    }
+    interface Character {
+        character_core: CharacterCore;
+        player_flags: number;
+        health: number;
+        armor: number;
+        ammo_count: number;
+        weapon: number;
+        emote: number;
+        attack_tick: number;
+        client_id: number;
+    }
+    interface iMessage {
+        team: number;
+        client_id: number;
+        author?: {
+            ClientInfo?: ClientInfo;
+            PlayerInfo?: PlayerInfo;
+        };
+        message: string;
+    }
+    interface iEmoticon {
+        client_id: number;
+        emoticon: number;
+        author?: {
+            ClientInfo?: ClientInfo;
+            PlayerInfo?: PlayerInfo;
+        };
+    }
+    interface iKillMsg {
+        killer_id: number;
+        killer?: {
+            ClientInfo?: ClientInfo;
+            PlayerInfo?: PlayerInfo;
+        };
+        victim_id: number;
+        victim?: {
+            ClientInfo?: ClientInfo;
+            PlayerInfo?: PlayerInfo;
+        };
+        weapon: number;
+        special_mode: number;
+    }
+    interface iKillMsgTeam {
+        team: number;
+        first: number;
+    }
+    interface iMapChange {
+        map_name: string;
+        crc: number;
+        size: number;
+    }
+    interface PlayerInfo {
+        local: number;
+        client_id: number;
+        team: number;
+        score: number;
+        latency: number;
+    }
+    interface ClientInfo {
+        name: string;
+        clan: string;
+        country: number;
+        skin: string;
+        use_custom_color: number;
+        color_body: number;
+        color_feet: number;
+        id: number;
+    }
+    interface Identity {
+        name: string;
+        clan: string;
+        country: number;
+        skin: string;
+        use_custom_color: number;
+        color_body: number;
+        color_feet: number;
+    }
+    interface SpectatorInfo {
+        spectator_id: number;
+        x: number;
+        y: number;
+    }
+    interface Common {
+        x: number;
+        y: number;
+    }
+    interface Explosion {
+        common: Common;
+    }
+    interface Spawn {
+        common: Common;
+    }
+    interface HammerHit {
+        common: Common;
+    }
+    interface Death {
+        common: Common;
+        client_id: number;
+    }
+    interface SoundGlobal {
+        common: Common;
+        sound_id: number;
+    }
+    interface SoundWorld {
+        common: Common;
+        sound_id: number;
+    }
+    interface DamageInd {
+        common: Common;
+        angle: number;
+    }
+    interface MyOwnObject {
+        m_Test: number;
+    }
+    interface DDNetCharacter {
+        m_Flags: number;
+        m_FreezeEnd: number;
+        m_Jumps: number;
+        m_TeleCheckpoint: number;
+        m_StrongWeakID: number;
+        m_JumpedTotal?: number;
+        m_NinjaActivationTick?: number;
+        m_FreezeStart?: number;
+        m_TargetX?: number;
+        m_TargetY?: number;
+        id: number;
+    }
+    interface DDNetPlayer {
+        m_Flags: number;
+        m_AuthLevel: number;
+        id: number;
+    }
+    interface GameInfoEx {
+        m_Flags: number;
+        m_Version: number;
+        m_Flags2: number;
+    }
+    interface DDNetProjectile {
+        m_X: number;
+        m_Y: number;
+        m_Angle: number;
+        m_Data: number;
+        m_Type: number;
+        m_StartTick: number;
+    }
+    interface DDNetLaser {
+        m_ToX: number;
+        m_ToY: number;
+        m_FromX: number;
+        m_FromY: number;
+        m_StartTick: number;
+        m_Owner: number;
+        m_Type: number;
+    }
+}
+export type Item = SnapshotItemTypes.PlayerInput | SnapshotItemTypes.PlayerInfo | SnapshotItemTypes.Projectile | SnapshotItemTypes.Laser | SnapshotItemTypes.Pickup | SnapshotItemTypes.Flag | SnapshotItemTypes.GameInfo | SnapshotItemTypes.GameData | SnapshotItemTypes.CharacterCore | SnapshotItemTypes.Character | SnapshotItemTypes.ClientInfo | SnapshotItemTypes.SpectatorInfo | SnapshotItemTypes.Common | SnapshotItemTypes.Explosion | SnapshotItemTypes.Spawn | SnapshotItemTypes.HammerHit | SnapshotItemTypes.Death | SnapshotItemTypes.SoundGlobal | SnapshotItemTypes.SoundWorld | SnapshotItemTypes.DamageInd;
+export type DDNetItem = SnapshotItemTypes.MyOwnObject | SnapshotItemTypes.DDNetCharacter | SnapshotItemTypes.DDNetPlayer | SnapshotItemTypes.GameInfoEx | SnapshotItemTypes.DDNetProjectile | SnapshotItemTypes.DDNetLaser;
+export type DeltaItem = {
+    data: number[];
+    parsed: Item | DDNetItem;
+    type_id: number;
+    id: number;
+    key: number;
+};
+export interface ConnectionInfo {
+    addr: string;
+    port: number;
+}

package/lib/types.js

@@ -0,0 +1,4 @@
+/**
+ * Типы из библиотеки teeworlds
+ */
+export {};

package/package.json

@@ -1,17 +1,12 @@
 {
   "dependencies": {
-    "chalk": "^4.1.2",
-    "loger0374": "^0.4.1",
     "teeworlds": "^2.5.11"
   },
   "name": "ddbot.js-0374",
-  "version": "3.2.7",
+  "version": "4.0.0",
   "description": "ddbot.js — это Node.js проект для автоматизации и управления ботами.",
   "main": "./index.js",
-  "scripts": {
-    "start": "node ./docs/examples/main.js",
-    "test": "node ./docs/examples/echo-bot.js"
-  },
+  "scripts": {},
   "repository": {
     "type": "git",
     "url": "git+https://github.com/0374flop/ddbot.js.git"
@@ -26,10 +21,12 @@
   ],
   "author": "0374flop",
   "license": "MIT",
-  "type": "commonjs",
+  "type": "module",
   "bugs": {
     "url": "https://github.com/0374flop/ddbot.js/issues"
   },
   "homepage": "https://github.com/0374flop/ddbot.js#readme",
-  "types": "ddbot.js-0374.d.ts"
+  "devDependencies": {
+    "@types/node": "^25.2.3"
+  }
 }