ddbot.js-0374 4.4.3 → 4.5.0

package/docs/ideas.md

@@ -0,0 +1,104 @@
+# ddbot.js v5 — идеи и архитектура
+
+## Философия
+
+v4 — стабильный клиент поверх teeworlds. Ядро решает проблему нестабильности.  
+v5 — фреймворк для ботов. Модули становятся полноценными, общаются между собой и не конфликтуют.
+
+---
+
+## Новая архитектура модулей
+
+### InputModule
+
+Базовый класс поверх `BaseModule` для модулей которые отправляют инпут.
+
+Модуль декларирует какие каналы инпута он использует:
+```ts
+channels: ['aim', 'move', 'jump', 'hook', 'fire']
+```
+
+Добавляет метод `pauseInput()` — останавливает только отправку инпута, не останавливая весь модуль. Модуль продолжает слушать события.
+
+---
+
+### InputMixer
+
+Менеджер приоритетов инпута. Знает все активные `InputModule` и их каналы.
+
+- Если два модуля хотят один канал — побеждает тот у кого выше приоритет
+- Если модули не пересекаются по каналам — работают параллельно
+- При смене задачи сам паузит и возобновляет нужные модули
+
+Пример:
+```
+LookAt      → [aim]
+Follow      → [move, hook]
+Pathfinding → [aim, move, jump, hook]
+```
+`LookAt` + `Follow` работают одновременно. `Pathfinding` вытесняет обоих по приоритету.
+
+---
+
+### ModuleContainer
+
+Отдельный класс — реестр модулей бота. Живёт в боте но не является ядром.
+
+- Хранит все зарегистрированные модули
+- Резолвит зависимости между модулями
+- Отвечает за порядок инициализации
+
+```ts
+bot.modules.register(playerList)
+bot.modules.get(PlayerList) // доступно любому модулю
+```
+
+Ядро (Bot) остаётся чистым. Вся сложность графа зависимостей живёт здесь.
+
+---
+
+### EventBus
+
+Шина состояния для общения между модулями. Модули не знают друг о друге напрямую — публикуют и читают через шину.
+
+```ts
+this.publish('target', { client_id: 3, x: 100, y: 200 })
+this.subscribe('target', (data) => { ... })
+```
+
+Решает проблему повторения одной и той же логики в разных модулях. Например `Greeter` подписывается на события `PlayerList` не зная о нём напрямую.
+
+---
+
+### Таймеры в BaseModule
+
+`BaseModule` предоставляет обёртки над таймерами:
+
+```ts
+this.setTimeout(() => { ... }, 3000)
+this.setInterval(() => { ... }, 1000)
+```
+
+При `stop()` или `destroy()` все таймеры чистятся автоматически. Решает утечки состояния при реконнекте — старые таймеры не срабатывают в новой сессии.
+
+---
+
+## Итого — слои v5
+
+| Слой | Класс | Отвечает за |
+|---|---|---|
+| Стабильность | `Bot` | жизненный цикл, реконнект, идентичность |
+| Зависимости | `ModuleContainer` | граф модулей, резолв зависимостей |
+| Инпут | `InputMixer` | каналы, приоритеты, параллельность |
+| Общение | `EventBus` | состояние между модулями |
+| Время | `BaseModule` | чистые таймеры без утечек |
+
+---
+
+## В Ideas (не срочно)
+
+**TickSystem** — таймеры привязанные к тикам снапшота (~25/сек) для высокоточных вещей. Пока не нужно.
+
+**Recorder/Replayer** — запись и воспроизведение инпута. Полезно для отладки.
+
+**Условный запуск модулей** — модуль активируется по условию а не вручную.

package/lib/core/core.d.ts

@@ -98,6 +98,7 @@ export declare class Bot extends EventEmitter {
      * @param input - Partial input object
      */
     send_input(input: Partial<Types.SnapshotItemTypes.PlayerInput>): void;
+    private snapshotUnpackerRef;
     /**
      * Setup all client event listeners and forward them
      */

package/lib/core/core.js

@@ -210,6 +210,7 @@ class Bot extends events_1.EventEmitter {
             return;
         this.client.movement.input = { ...this.client.movement.input, ...input };
     }
+    snapshotUnpackerRef = null;
     /**
      * Setup all client event listeners and forward them
      */
@@ -217,36 +218,34 @@ class Bot extends events_1.EventEmitter {
         this.clean(false);
         if (!this.client)
             return;
-        // Connection events
         this.client.on('connected', () => {
+            this.emit('rawconnect', { addr: this.status.addr, port: this.status.port });
+            this.setup_snapshot_events();
             if (this.status.connect.connected) {
                 this.error('connection received when already connected');
             }
             else {
                 this.status.connect.connected = true;
                 this.emit('connect', { addr: this.status.addr, port: this.status.port });
-                this.setup_snapshot_events();
             }
         });
         this.client.on('disconnect', (reason) => {
+            this.snapshotUnpackerRef = null;
+            this.emit('rawdisconnect', reason, { addr: this.status.addr, port: this.status.port });
             this.status.connect.connected = false;
             this.clean(true);
             if (!!reason) {
                 this.emit('disconnect', reason, { addr: this.status.addr, port: this.status.port });
             }
         });
-        this.client.on('connected', () => {
-            this.emit('rawconnect', { addr: this.status.addr, port: this.status.port });
-        });
-        this.client.on('disconnect', (reason) => {
-            this.emit('rawdisconnect', reason, { addr: this.status.addr, port: this.status.port });
-        });
-        // Game events
         this.client.on('broadcast', (msg) => this.emit('broadcast', msg));
         this.client.on('capabilities', (msg) => this.emit('capabilities', msg));
         this.client.on('emote', (msg) => this.emit('emote', msg));
         this.client.on('kill', (msg) => this.emit('kill', msg));
-        this.client.on('snapshot', (msg) => this.emit('snapshot', msg));
+        this.client.on('snapshot', (msg) => {
+            this.setup_snapshot_events();
+            this.emit('snapshot', msg);
+        });
         this.client.on('map_change', (msg) => this.emit('map_change', msg));
         this.client.on('map_details', (msg) => this.emit('map_details', msg));
         this.client.on('motd', (msg) => this.emit('motd', msg));
@@ -258,10 +257,11 @@ class Bot extends events_1.EventEmitter {
      * Setup snapshot unpacker events
      */
     setup_snapshot_events() {
-        if (!this.client?.SnapshotUnpacker) {
-            this.error('SnapshotUnpacker not available yet');
+        if (!this.client?.SnapshotUnpacker)
             return;
-        }
+        if (this.snapshotUnpackerRef === this.client.SnapshotUnpacker)
+            return;
+        this.snapshotUnpackerRef = this.client.SnapshotUnpacker;
         this.client.SnapshotUnpacker.removeAllListeners();
         this.client.SnapshotUnpacker.on('spawn', (msg) => this.emit('spawn', msg));
         this.client.SnapshotUnpacker.on('death', (msg) => this.emit('death', msg));

package/lib/ddutils.js

@@ -18,39 +18,39 @@ function DefaultIdentity(name = 'nameless tee') {
  */
 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
+        m_Direction: char.character_core.direction,
+        m_TargetX: 0,
+        m_TargetY: -1,
+        m_Jump: 0,
+        m_Fire: 0,
+        m_Hook: 0,
+        m_PlayerFlags: char.player_flags || 0,
+        m_WantedWeapon: char.weapon,
+        m_NextWeapon: 0,
+        m_PrevWeapon: 0
     };
     if (ddnetChar && (ddnetChar.m_TargetX !== 0 || ddnetChar.m_TargetY !== 0)) {
-        input.target_x = ddnetChar.m_TargetX;
-        input.target_y = ddnetChar.m_TargetY;
+        input.m_TargetX = ddnetChar.m_TargetX;
+        input.m_TargetY = 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;
+        input.m_TargetX = Math.cos(angleRad) * 256;
+        input.m_TargetY = Math.sin(angleRad) * 256;
     }
-    if (input.target_x === 0 && input.target_y === 0) {
-        input.target_y = -1;
+    if (input.m_TargetX === 0 && input.m_TargetY === 0) {
+        input.m_TargetY = -1;
     }
     const hookActive = char.character_core.hook_state !== 0 ||
         char.character_core.hooked_player !== -1;
-    input.hook = hookActive ? 1 : 0;
+    input.m_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;
+    input.m_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
+    input.m_WantedWeapon = isNinja ? 5 : char.weapon;
+    const isAutofireWeapon = [2, 3, 4].includes(input.m_WantedWeapon);
+    const isJetpackGun = input.m_WantedWeapon === 1 && ddnetChar?.m_Flags != null;
+    input.m_Fire = isAutofireWeapon || isJetpackGun ? 0 : 0;
     return input;
 }

package/lib/modules/playerlist.d.ts

@@ -30,7 +30,9 @@ declare class PlayerList extends BaseModule<[maxclients?: number]> {
     private maxclients;
     private playermap;
     private previousMap;
+    private isFirstSnapshot;
     private readonly snapshotlistener;
+    private readonly resetState;
     /**
      * Get list of all players
      */

package/lib/modules/playerlist.js

@@ -13,6 +13,7 @@ class PlayerList extends module_js_1.default {
     maxclients = 64;
     playermap = new Map();
     previousMap = new Map();
+    isFirstSnapshot = true;
     snapshotlistener = () => {
         this.previousMap = new Map(this.playermap);
         this.playermap.clear();
@@ -32,25 +33,29 @@ class PlayerList extends module_js_1.default {
                     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,
-                    });
+                if (!this.isFirstSnapshot && !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,
-                });
+        if (!this.isFirstSnapshot) {
+            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.isFirstSnapshot = false;
+        this.previousMap.clear();
+    };
+    resetState = () => {
+        this.playermap.clear();
         this.previousMap.clear();
+        this.isFirstSnapshot = true;
     };
     /**
      * Get list of all players
@@ -72,10 +77,15 @@ class PlayerList extends module_js_1.default {
     }
     _start(maxclients = 64) {
         this.maxclients = maxclients;
+        this.isFirstSnapshot = true;
         this.bot.on('snapshot', this.snapshotlistener);
+        this.bot.on('connect', this.resetState);
+        this.bot.on('disconnect', this.resetState);
     }
     _stop() {
         this.bot.off('snapshot', this.snapshotlistener);
+        this.bot.off('connect', this.resetState);
+        this.bot.off('disconnect', this.resetState);
         this.playermap.clear();
         this.previousMap.clear();
     }

package/lib/modules/reconnect.js

@@ -23,7 +23,9 @@ class Reconnect extends module_js_1.default {
             return;
         if (this.reconnecting)
             return;
-        if (!connectionInfo.addr || !connectionInfo.port) {
+        const addr = connectionInfo.addr;
+        const port = connectionInfo.port;
+        if (!addr || !port) {
             this.emit('reconnect_failed', 'No connection info');
             return;
         }
@@ -42,11 +44,11 @@ class Reconnect extends module_js_1.default {
         });
         this.reconnectTimer = setTimeout(async () => {
             try {
-                await this.bot.connect(connectionInfo.addr, connectionInfo.port);
+                await this.bot.connect(addr, port, 30000);
                 this.currentAttempts = 0;
                 this.emit('reconnected', {
-                    addr: connectionInfo.addr,
-                    port: connectionInfo.port
+                    addr: addr,
+                    port: port
                 });
             }
             catch (err) {

package/lib/modules/snap.d.ts

@@ -22,9 +22,14 @@ interface SnapEvents {
     frozen: () => void;
     /** Персонаж разморожен */
     unfrozen: () => void;
+    /** Другой игрок заморожен */
+    player_frozen: (client_id: number) => void;
+    /** Другой игрок разморожен */
+    player_unfrozen: (client_id: number) => void;
 }
 declare class Snap extends BaseModule {
     private _isFrozen;
+    private _playerFreezeState;
     private readonly hammerHitlistener;
     private readonly firelistener;
     private readonly snapslistener;
@@ -36,6 +41,7 @@ declare class Snap extends BaseModule {
         y: number;
     } | null;
     get isFrozen(): boolean;
+    isPlayerFrozen(client_id: number): boolean;
     lookatplayer(client_id: number): void;
     protected _start(): void;
     protected _stop(): void;

package/lib/modules/snap.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const module_js_1 = __importDefault(require("../core/module.js"));
 class Snap extends module_js_1.default {
     _isFrozen = false;
+    _playerFreezeState = new Map();
     hammerHitlistener = (hit) => {
         if (this.bot.OwnID === undefined)
             return;
@@ -35,16 +36,44 @@ class Snap extends module_js_1.default {
                 }
             }
         };
-        ffs(); // in future snapshot can be biger, so we just make new functions.    блять идите нахуй со своим англиским, я не знаю но я стараюсь идите нахуй
+        const fps = () => {
+            if (!this.bot.bot_client?.SnapshotUnpacker)
+                return;
+            const allChars = this.bot.bot_client.SnapshotUnpacker.AllObjCharacter || [];
+            const currentIds = new Set();
+            for (const char of allChars) {
+                if (char.client_id === this.bot.OwnID)
+                    continue;
+                currentIds.add(char.client_id);
+                const ddnetChar = this.bot.bot_client.SnapshotUnpacker.getObjExDDNetCharacter(char.client_id);
+                if (!ddnetChar)
+                    continue;
+                const isFrozen = ddnetChar.m_FreezeEnd !== 0;
+                const wasFrozen = this._playerFreezeState.get(char.client_id);
+                if (wasFrozen === undefined) {
+                    this._playerFreezeState.set(char.client_id, isFrozen);
+                    continue;
+                }
+                if (wasFrozen !== isFrozen) {
+                    this._playerFreezeState.set(char.client_id, isFrozen);
+                    this.emit(isFrozen ? 'player_frozen' : 'player_unfrozen', char.client_id);
+                }
+            }
+            for (const id of this._playerFreezeState.keys()) {
+                if (!currentIds.has(id)) {
+                    this._playerFreezeState.delete(id);
+                }
+            }
+        };
+        ffs();
+        fps();
     };
     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;
+        return Math.abs(x1 - x2) <= TILE && Math.abs(y1 - y2) <= TILE;
     }
     static whoareWithinTile(x, y, list = [], ignoreClients = []) {
         for (const character of list) {
@@ -72,13 +101,21 @@ class Snap extends module_js_1.default {
     get isFrozen() {
         return this._isFrozen;
     }
+    isPlayerFrozen(client_id) {
+        return this._playerFreezeState.get(client_id) ?? false;
+    }
     lookatplayer(client_id) {
-        const pl_character = this.bot.bot_client?.SnapshotUnpacker.getObjCharacter(client_id);
-        const own_character = this.bot.bot_client?.SnapshotUnpacker.getObjCharacter(this.bot.OwnID);
-        if (!pl_character || !own_character)
+        try {
+            const pl_character = this.bot.bot_client?.SnapshotUnpacker.getObjCharacter(client_id);
+            const own_character = this.bot.bot_client?.SnapshotUnpacker.getObjCharacter(this.bot.OwnID);
+            if (!pl_character || !own_character)
+                return;
+            const angle = Math.atan2(pl_character.character_core.y - own_character.character_core.y, pl_character.character_core.x - own_character.character_core.x);
+            this.bot.send_input({ m_TargetX: Math.cos(angle) * 256, m_TargetY: Math.sin(angle) * 256 });
+        }
+        catch (e) {
             return;
-        const angle = Math.atan2(pl_character.character_core.y - own_character.character_core.y, pl_character.character_core.x - own_character.character_core.x);
-        this.bot.send_input({ target_x: Math.cos(angle) * 256, target_y: Math.sin(angle) * 256 });
+        }
     }
     _start() {
         this.bot.on('snapshot', this.snapslistener);
@@ -89,6 +126,7 @@ class Snap extends module_js_1.default {
         this.bot.off('snapshot', this.snapslistener);
         this.bot.off('hammerhit', this.hammerHitlistener);
         this.bot.off('sound_world', this.firelistener);
+        this._playerFreezeState.clear();
     }
     on(event, listener) {
         return super.on(event, listener);

package/lib/types.d.ts

@@ -3,16 +3,16 @@
  */
 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;
+        m_Direction: number;
+        m_TargetX: number;
+        m_TargetY: number;
+        m_Jump: number;
+        m_Fire: number;
+        m_Hook: number;
+        m_PlayerFlags: number;
+        m_WantedWeapon: number;
+        m_NextWeapon: number;
+        m_PrevWeapon: number;
     }
     interface iOptions {
         identity?: Identity;
@@ -250,6 +250,6 @@ export type DeltaItem = {
     key: number;
 };
 export interface ConnectionInfo {
-    addr: string;
-    port: number;
+    addr: string | null;
+    port: number | null;
 }

package/package.json

@@ -3,7 +3,7 @@
     "teeworlds": "^2.5.11"
   },
   "name": "ddbot.js-0374",
-  "version": "4.4.3",
+  "version": "4.5.0",
   "description": "ddbot.js — это Node.js проект для автоматизации и управления ботами.",
   "main": "./lib/index.js",
   "scripts": {
@@ -30,6 +30,6 @@
   },
   "homepage": "https://github.com/0374flop/ddbot.js#readme",
   "devDependencies": {
-    "@types/node": "^25.2.3"
+    "@types/node": "^25.5.2"
   }
 }