bonktools 2.0.1 → 3.0.0

package/dist/connection/BonkConnection.js

@@ -1,482 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BonkConnection = void 0;
-const events_1 = require("events");
-const constants_1 = require("../utils/constants");
-const validation_1 = require("../utils/validation");
-const PacketBuilder_1 = require("./PacketBuilder");
-const PacketParser_1 = require("./PacketParser");
-const socket_io_client_1 = __importDefault(require("socket.io-client"));
-const axios_1 = __importDefault(require("axios"));
-/**
- * Gerencia a conexão WebSocket com o servidor Bonk.io e o estado do jogo.
- */
-class BonkConnection extends events_1.EventEmitter {
-    constructor(account, server = constants_1.DEFAULT_SERVER) {
-        super();
-        this.socket = null;
-        this.connected = false;
-        this.keepAliveTimer = null;
-        this.PROTOCOL_VERSION = 7; // Versão do protocolo Bonk.io (pode precisar de atualização)
-        this.players = new Map();
-        this.token = null;
-        this.peerID = this.generatePeerID();
-        this.avatar = { layers: [], bc: 0 }; // Avatar padrão
-        this.location = {}; // Informações de localização (lat, long, country)
-        this.account = (0, validation_1.validateAccount)(account);
-        this.server = server;
-        this.room = {
-            address: null,
-            name: null,
-            server: this.server,
-            bypass: '',
-            id: null,
-            dbid: null,
-            teamsLocked: false,
-            map: null,
-            inGame: false,
-        };
-        this.game = {
-            id: null,
-            host: null,
-            banned: false,
-        };
-    }
-    /**
-     * Gera um ID de par (peerID) aleatório.
-     * @returns {string} O peerID gerado.
-     */
-    generatePeerID() {
-        // Implementação de geração de peerID (pode ser simplificada por enquanto)
-        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-    }
-    /**
-     * Obtém o token de autenticação do usuário.
-     * (Implementação baseada no bonkbot original, usando axios)
-     * @param {string} username - Nome de usuário.
-     * @param {string} password - Senha.
-     * @returns {Promise<string>} O token de autenticação.
-     */
-    async getToken(username, password) {
-        // TODO: Implementar a lógica de obtenção de token
-        // Por enquanto, retorna um token falso se não for convidado
-        if (!password) {
-            throw new Error('Password is required for non-guest accounts.');
-        }
-        // Lógica de requisição HTTP para login
-        // const response = await axios.post(API.LOGIN, { username, password });
-        // return response.data.token;
-        return 'FAKE_TOKEN_12345';
-    }
-    /**
-     * Obtém informações do servidor (localização, etc.).
-     * (Implementação baseada no bonkbot original)
-     * @returns {Promise<any>} Informações do servidor.
-     */
-    async getServerInfo() {
-        // TODO: Implementar a lógica de obtenção de informações do servidor
-        // Por enquanto, retorna um objeto mock
-        return {
-            server: constants_1.DEFAULT_SERVER,
-            lat: 0,
-            long: 0,
-            country: 'BR',
-        };
-    }
-    /**
-     * Inicializa a conexão (autenticação, obtenção de info do servidor).
-     * @returns {Promise<BonkConnection>} Esta instância.
-     */
-    async init() {
-        // Lógica de inicialização (getToken, getServerInfo)
-        if (!this.account.guest && !this.token) {
-            this.token = await this.getToken(this.account.username, this.account.password);
-        }
-        if (!this.server || this.server === constants_1.DEFAULT_SERVER) {
-            const serverInfo = await this.getServerInfo();
-            this.server = serverInfo.server;
-            this.location = serverInfo;
-            this.room.server = this.server;
-        }
-        this.emit('ready');
-        return this;
-    }
-    /**
-     * Inicia o temporizador de keep-alive.
-     */
-    startKeepAlive() {
-        this.keepAliveTimer = setInterval(() => {
-            if (this.connected && this.socket && this.socket.connected) {
-                this.sendTimesync();
-            }
-            else if (this.connected) {
-                this.stopBot();
-                this.emit('disconnect');
-            }
-        }, 5000);
-    }
-    /**
-     * Para o bot (limpa timers, etc.).
-     */
-    stopBot() {
-        if (this.keepAliveTimer) {
-            clearInterval(this.keepAliveTimer);
-            this.keepAliveTimer = null;
-        }
-        this.connected = false;
-    }
-    /**
-     * Configura os ouvintes de eventos do Socket.IO.
-     */
-    setupSocketEvents() {
-        if (!this.socket)
-            return;
-        // O Bonk.io usa o evento 'message' para a maioria dos pacotes
-        this.socket.on('message', (data) => {
-            const packet = PacketParser_1.PacketParser.parse(data);
-            this.handlePacket(packet);
-        });
-        // Evento de desconexão
-        this.socket.on('disconnect', (reason) => {
-            this.stopBot();
-            this.emit('disconnect', reason);
-        });
-        // Evento de erro
-        this.socket.on('error', (error) => {
-            this.emit('error', error);
-        });
-    }
-    /**
-     * Conecta-se ao servidor Bonk.io.
-     * @returns {Promise<BonkConnection>} Esta instância.
-     */
-    async connect() {
-        if (this.connected) {
-            this.disconnect();
-        }
-        // Desabilitar verificação de certificado TLS (necessário para bonk.io)
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-        const socketAddr = `https://${this.server}.bonk.io`;
-        return new Promise((resolve, reject) => {
-            try {
-                const socketOptions = {
-                    transports: ['websocket'],
-                    reconnection: false,
-                    timeout: 10000,
-                    forceNew: true,
-                    path: '/socket.io',
-                    rejectUnauthorized: false // Necessário para bonk.io
-                };
-                this.socket = (0, socket_io_client_1.default)(socketAddr, socketOptions);
-                const timeout = setTimeout(() => {
-                    if (!this.connected) {
-                        reject(new Error(`Connection timeout to server: ${this.server}`));
-                        this.stopBot();
-                    }
-                }, 10000);
-                this.socket.on('connect', () => {
-                    clearTimeout(timeout);
-                    this.connected = true;
-                    this.setupSocketEvents();
-                    this.startKeepAlive();
-                    this.emit('connect');
-                    resolve(this);
-                });
-                this.socket.on('connect_error', (error) => {
-                    if (!this.connected) {
-                        clearTimeout(timeout);
-                        reject(new Error(`Failed to connect to server: ${error.message}`));
-                    }
-                    this.emit('error', error);
-                });
-                this.socket.on('disconnect', (reason) => {
-                    if (!this.connected) {
-                        clearTimeout(timeout);
-                        reject(new Error(`Connection closed before fully established: ${reason}`));
-                    }
-                    this.stopBot();
-                    this.emit('disconnect', reason);
-                });
-            }
-            catch (error) {
-                reject(new Error(`Failed to create Socket.IO connection: ${error.message}`));
-            }
-        });
-    }
-    /**
-     * Desconecta do servidor.
-     */
-    disconnect() {
-        if (!this.connected)
-            return;
-        this.stopBot();
-        if (this.socket) {
-            this.socket.disconnect();
-            this.socket = null;
-        }
-    }
-    /**
-     * Envia uma mensagem (pacote) para o servidor.
-     * @param {number} type - Tipo da mensagem (CLIENT_MESSAGE_TYPES).
-     * @param {any} data - Dados da mensagem.
-     */
-    sendMessage(type, data) {
-        if (!this.socket || !this.connected) {
-            throw new Error('Not connected to server.');
-        }
-        const packet = PacketBuilder_1.PacketBuilder.build(type, data);
-        this.socket.emit('message', packet);
-    }
-    /**
-     * Envia o pacote TIMESYNC (keep-alive).
-     */
-    sendTimesync() {
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.TIMESYNC, { time: Date.now() });
-    }
-    /**
-     * Envia uma mensagem de chat para a sala.
-     * @param {string} message - A mensagem a ser enviada.
-     */
-    sendChat(message) {
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.CHAT_MESSAGE, { message });
-    }
-    /**
-     * Envia um comando de input do jogador (movimento).
-     * @param {number} input - O valor do input (ex: 1 para esquerda, 2 para direita, etc.).
-     * @param {number} frame - O frame atual do jogo.
-     * @param {number} sequence - O número de sequência do input.
-     */
-    sendInput(input, frame, sequence) {
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.SEND_INPUTS, {
-            input,
-            frame,
-            sequence,
-        });
-    }
-    /**
-     * Envia o comando para iniciar o jogo.
-     */
-    startGame() {
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.TRIGGER_START, {});
-    }
-    /**
-     * Envia o comando para mudar de time.
-     * @param {number} team - O ID do time (1 a 5, ou 0 para espectador).
-     */
-    changeTeam(team) {
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.CHANGE_OWN_TEAM, { team });
-    }
-    /**
-     * Envia o comando para definir o status de pronto/não pronto.
-     * @param {boolean} ready - True para pronto, False para não pronto.
-     */
-    setReady(ready) {
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.SET_READY, { ready });
-    }
-    /**
-     * Envia o comando para chutar/banir um jogador.
-     * @param {number} id - O ID do jogador.
-     * @param {boolean} ban - Se deve banir (true) ou apenas chutar (false).
-     */
-    kickBanPlayer(id, ban = false) {
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.KICK_BAN_PLAYER, { id, ban });
-    }
-    // Outras funcionalidades podem ser adicionadas aqui, como:
-    // - setMap(mapData: any)
-    // - setGameMode(mode: string)
-    // - setRounds(rounds: number)
-    // - sendMapSuggest(mapID: number)
-    // - etc.
-    /**
-     * Cria uma nova sala.
-     * @param {CreateRoomOptions} options - Opções de criação de sala.
-     * @returns {Promise<RoomInfo>} Informações da sala criada.
-     */
-    async createRoom(options = {}) {
-        if (!this.connected) {
-            throw new Error('Not connected to server.');
-        }
-        // A validação será implementada em src/utils/validation.ts
-        // const validatedOptions = validateRoomOptions(options);
-        const validatedOptions = options; // Temporário
-        this.room.name = validatedOptions.roomname || `BonkBot Room ${Math.floor(Math.random() * 1000)}`;
-        this.room.server = this.server; // Garante que o servidor está correto
-        const createData = {
-            peerID: this.peerID,
-            roomName: this.room.name,
-            maxPlayers: validatedOptions.maxplayers || 8,
-            password: validatedOptions.password || '',
-            dbid: 11822936, // Valor padrão do bonkbot
-            guest: this.account.guest,
-            minLevel: 0,
-            maxLevel: 999,
-            latitude: this.location.lat || 0,
-            longitude: this.location.long || 0,
-            country: this.location.country || 'BR',
-            version: this.PROTOCOL_VERSION,
-            hidden: validatedOptions.hidden ? 1 : 0,
-            quick: validatedOptions.quick || false,
-            mode: validatedOptions.mode || 'custom',
-            token: this.token || '',
-            avatar: this.avatar,
-        };
-        if (this.account.guest) {
-            createData.guestName = this.account.username;
-        }
-        // O bonkbot original não espera uma resposta aqui, apenas envia a mensagem
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.CREATE_ROOM, createData);
-        // O endereço da sala (roomID e bypass) é recebido posteriormente via pacote 'ROOM_SHARE_LINK'
-        // Por enquanto, retornamos o que sabemos
-        return this.room;
-    }
-    /**
-     * Entra em uma sala existente.
-     * @param {string} roomAddress - Endereço da sala (ex: '123456' ou '123456abcde').
-     * @param {JoinOptions} options - Opções de entrada.
-     * @returns {Promise<void>}
-     */
-    async joinRoom(roomAddress, options = {}) {
-        if (!this.connected) {
-            throw new Error('Not connected to server.');
-        }
-        // A validação será implementada em src/utils/validation.ts
-        // const validatedOptions = validateJoinOptions(options);
-        const validatedOptions = options; // Temporário
-        // 1. Obter endereço completo (server, bypass) se necessário
-        const addressInfo = await this.getAddressFromUrl(`https://bonk.io/game.html?${roomAddress}`);
-        if (!addressInfo || addressInfo.r !== 'success') {
-            throw new Error('Failed to get room address information.');
-        }
-        this.setAddress(addressInfo);
-        // 2. Enviar mensagem de JOIN_ROOM
-        const joinData = {
-            joinID: this.room.address,
-            roomPassword: validatedOptions.password || '',
-            guest: this.account.guest,
-            dbid: 2, // Valor padrão
-            version: this.PROTOCOL_VERSION,
-            peerID: validatedOptions.peerID || this.peerID,
-            bypass: this.room.bypass || '',
-            avatar: this.avatar
-        };
-        if (this.account.guest) {
-            joinData.guestName = this.account.username;
-        }
-        else {
-            joinData.token = this.token;
-        }
-        this.sendMessage(constants_1.CLIENT_MESSAGE_TYPES.JOIN_ROOM, joinData);
-    }
-    /**
-     * Define o endereço da sala.
-     * @param {any} addressInfo - Informações de endereço da sala.
-     */
-    setAddress(addressInfo) {
-        if (!addressInfo.address || !addressInfo.roomname || !addressInfo.server) {
-            throw new Error('Invalid room address information');
-        }
-        this.room.address = addressInfo.address;
-        this.room.name = addressInfo.roomname;
-        this.room.server = addressInfo.server;
-        this.room.bypass = addressInfo.bypass || '';
-        if (this.server !== addressInfo.server) {
-            this.server = addressInfo.server;
-        }
-    }
-    /**
-     * Obtém informações de endereço da sala a partir de uma URL/ID.
-     * (Implementação baseada no bonkbot original)
-     * @param {string} url - URL ou ID da sala.
-     * @returns {Promise<any>} Informações de endereço.
-     */
-    async getAddressFromUrl(url) {
-        // Lógica de regex para extrair ID e bypass
-        const regex = /\/(\d{6})([a-zA-Z0-9]{5})?$/;
-        const match = url.match(regex);
-        if (!match) {
-            return null;
-        }
-        const id = match[1];
-        const bypass = match[2] || '';
-        const data = new URLSearchParams();
-        data.append('joinID', id);
-        try {
-            // TODO: Implementar httpsAgent se necessário para ignorar certificados
-            const response = await axios_1.default.post(constants_1.API.AUTOJOIN, data.toString(), {
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded'
-                },
-                // httpsAgent: httpsAgent // Necessário importar e configurar
-            });
-            const result = response.data;
-            if (result.r === 'success') {
-                result.bypass = bypass;
-            }
-            return result;
-        }
-        catch (error) {
-            // console.error('Error getting join link:', error);
-            throw error;
-        }
-    }
-    /**
-     * Manipula os pacotes recebidos do servidor.
-     * @param {any} packet - Pacote analisado.
-     */
-    handlePacket(packet) {
-        // TODO: Implementar a lógica de autoHandlePacket do bonkbot
-        // Por enquanto, apenas emite o evento
-        this.emit('packet', packet);
-        switch (packet.type) {
-            case constants_1.SERVER_MESSAGE_TYPES.ROOM_SHARE_LINK:
-                // O servidor responde com o ID da sala e o bypass após a criação
-                this.room.dbid = packet.data.roomId;
-                this.room.bypass = packet.data.roomBypass;
-                this.emit('ROOM_SHARE_LINK', { roomId: this.room.dbid, bypass: this.room.bypass });
-                break;
-            case constants_1.SERVER_MESSAGE_TYPES.JOIN_ROOM:
-                // Lógica de JOIN_ROOM (configurar game.id, game.host, room.id, players)
-                this.game.id = packet.data.myid;
-                this.game.host = packet.data.hostid;
-                this.room.id = packet.data.roomid;
-                this.room.bypass = packet.data.roombypass;
-                this.room.teamsLocked = packet.data.teamsLocked;
-                // Adicionar jogadores (playerdata)
-                if (packet.data.playerdata && Array.isArray(packet.data.playerdata)) {
-                    for (let i = 0; i < packet.data.playerdata.length; i++) {
-                        const playerData = packet.data.playerdata[i];
-                        if (playerData) {
-                            // Mapear e adicionar jogador (simplificado)
-                            this.players.set(i, {
-                                id: i,
-                                username: playerData.userName,
-                                guest: playerData.guest,
-                                peerID: playerData.peerID,
-                                // ... outros campos
-                            });
-                        }
-                    }
-                }
-                this.emit('JOIN', { game: this.game, room: this.room, players: this.players });
-                break;
-            case constants_1.SERVER_MESSAGE_TYPES.CHAT_MESSAGE:
-                // Lógica de CHAT_MESSAGE
-                const player = this.players.get(packet.id);
-                this.emit('CHAT_MESSAGE', { player, message: packet.message });
-                break;
-            case constants_1.SERVER_MESSAGE_TYPES.TIMESYNC:
-                // Lógica de TIMESYNC (opcional, apenas para rastrear latência)
-                // this.timeSync.last_sync = packet.time;
-                // this.timeSync.latency = Date.now() - this.timeSync.last_sync;
-                break;
-            // TODO: Adicionar outros casos importantes (PLAYER_JOIN, PLAYER_LEAVE, GAME_START, etc.)
-            default:
-                // console.log(`Unhandled packet type: ${packet.type}`);
-                break;
-        }
-    }
-}
-exports.BonkConnection = BonkConnection;

package/dist/connection/PacketBuilder.d.ts

@@ -1,13 +0,0 @@
-/**
- * Classe utilitária para construir pacotes a serem enviados ao servidor Bonk.io.
- * O Bonk.io usa o formato PSON (Protocol-Specific Object Notation) para a maioria dos pacotes.
- */
-export declare class PacketBuilder {
-    /**
-     * Constrói um pacote para envio.
-     * @param {number} type - O tipo de mensagem (do CLIENT_MESSAGE_TYPES).
-     * @param {any} data - Os dados a serem serializados.
-     * @returns {any} O pacote serializado (geralmente um array).
-     */
-    static build(type: number, data: any): any;
-}

package/dist/connection/PacketBuilder.js

@@ -1,25 +0,0 @@
-"use strict";
-// src/connection/PacketBuilder.ts
-// Lógica de serialização de pacotes (baseada no bonkbot original)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PacketBuilder = void 0;
-/**
- * Classe utilitária para construir pacotes a serem enviados ao servidor Bonk.io.
- * O Bonk.io usa o formato PSON (Protocol-Specific Object Notation) para a maioria dos pacotes.
- */
-class PacketBuilder {
-    /**
-     * Constrói um pacote para envio.
-     * @param {number} type - O tipo de mensagem (do CLIENT_MESSAGE_TYPES).
-     * @param {any} data - Os dados a serem serializados.
-     * @returns {any} O pacote serializado (geralmente um array).
-     */
-    static build(type, data) {
-        // O bonkbot original usa um array onde o primeiro elemento é o tipo
-        // e o segundo é o objeto de dados. A serialização PSON é feita
-        // automaticamente pelo socket.io-client v2.x, que era a versão usada no bonkbot.
-        // Vamos manter essa estrutura.
-        return [type, data];
-    }
-}
-exports.PacketBuilder = PacketBuilder;

package/dist/connection/PacketParser.d.ts

@@ -1,14 +0,0 @@
-/**
- * Classe utilitária para analisar pacotes recebidos do servidor Bonk.io.
- */
-export declare class PacketParser {
-    /**
-     * Analisa um pacote PSON recebido.
-     * @param {any} data - O pacote bruto recebido do socket.
-     * @returns {{type: number, data: any}} Um objeto contendo o tipo e os dados do pacote.
-     */
-    static parse(data: any): {
-        type: number;
-        data: any;
-    };
-}

package/dist/connection/PacketParser.js

@@ -1,26 +0,0 @@
-"use strict";
-// src/connection/PacketParser.ts
-// Lógica de desserialização de pacotes (baseada no bonkbot original)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PacketParser = void 0;
-/**
- * Classe utilitária para analisar pacotes recebidos do servidor Bonk.io.
- */
-class PacketParser {
-    /**
-     * Analisa um pacote PSON recebido.
-     * @param {any} data - O pacote bruto recebido do socket.
-     * @returns {{type: number, data: any}} Um objeto contendo o tipo e os dados do pacote.
-     */
-    static parse(data) {
-        // O bonkbot original recebe um array onde o primeiro elemento é o tipo
-        // e o segundo é o objeto de dados.
-        if (Array.isArray(data) && data.length > 0) {
-            const [type, packetData] = data;
-            return { type, data: packetData };
-        }
-        // Se o pacote não for um array [type, data], retornamos o tipo -1 (desconhecido)
-        return { type: -1, data: data };
-    }
-}
-exports.PacketParser = PacketParser;

package/dist/connection/types.js

@@ -1 +0,0 @@
-"use strict";

package/dist/game/GameLoop.js

@@ -1 +0,0 @@
-"use strict";

package/dist/index.d.ts

@@ -1,48 +0,0 @@
-import { BonkConnection } from './connection/BonkConnection';
-export { BonkConnection };
-export * from './connection/BonkConnection';
-export * from './utils/constants';
-export * from './utils/validation';
-/**
- * A classe principal da biblioteca BonkTools, que estende BonkConnection.
- * Serve como ponto de entrada para todas as funcionalidades da biblioteca.
- */
-/**
- * A classe principal da biblioteca BonkTools, que estende BonkConnection.
- * Serve como ponto de entrada para todas as funcionalidades da biblioteca.
- *
- * @example
- * \`\`\`typescript
- * import BonkTools from 'bonktools';
- *
- * async function runBot() {
- *     const bot = new BonkTools({ username: 'GuestBot', guest: true });
- *     await bot.init();
- *     await bot.connect();
- *
- *     // Criar uma sala
- *     await bot.createRoom({ roomname: 'Minha Sala BonkTools' });
- *
- *     // Ouvir mensagens de chat
- *     bot.on('CHAT_MESSAGE', ({ player, message }) => {
- *         console.log(\`[\${player.username}]: \${message}\`);
- *         if (message === '!start') {
- *             bot.startGame();
- *         }
- *     });
- *
- *     console.log(\`Sala criada! Nome: \${bot.room.name}\`);
- * }
- *
- * runBot().catch(console.error);
- * \`\`\`
- */
-export declare class BonkTools extends BonkConnection {
-    /**
-     * Cria uma nova instância de BonkTools.
-     * @param account - As informações da conta (nome de usuário, senha, se é convidado).
-     * @param server - O servidor Bonk.io para se conectar (opcional, padrão é 'b2ny1').
-     */
-    constructor(account: any, server?: string);
-}
-export default BonkTools;