bonktools 2.0.1 → 3.0.0

package/src/utils/logger.js

@@ -0,0 +1,109 @@
+/**
+ * Logger utility for BonkBot
+ */
+
+// Log levels
+const LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  NONE: 4,
+};
+
+/**
+* Logger class for consistent logging throughout the library
+*/
+class Logger {
+  /**
+   * Create a new logger
+   * @param {string} name - Name of the logger (typically the module name)
+   * @param {number} level - Minimum log level to display (defaults to WARN)
+   */
+  constructor(name, level = LOG_LEVELS.WARN) {
+      this.name = name;
+      this.level = level;
+  }
+
+  /**
+   * Set the log level
+   * @param {number} level - New log level
+   */
+  setLevel(level) {
+      this.level = level;
+  }
+
+  /**
+   * Format a log message
+   * @param {string} level - Log level name
+   * @param {string} message - Log message
+   * @returns {string} Formatted log message
+   * @private
+   */
+  _format(level, message) {
+      return `[${level}] [${this.name}] ${message}`;
+  }
+
+  /**
+   * Log a debug message
+   * @param {string} message - Message to log
+   * @param {any} [data] - Optional data to include
+   */
+  debug(message, data) {
+      if (this.level <= LOG_LEVELS.DEBUG) {
+          const formattedMessage = this._format("DEBUG", message);
+          console.debug(formattedMessage, data !== undefined ? data : "");
+      }
+  }
+
+  /**
+   * Log an info message
+   * @param {string} message - Message to log
+   * @param {any} [data] - Optional data to include
+   */
+  info(message, data) {
+      if (this.level <= LOG_LEVELS.INFO) {
+          const formattedMessage = this._format("INFO", message);
+          console.info(formattedMessage, data !== undefined ? data : "");
+      }
+  }
+
+  /**
+   * Log a warning message
+   * @param {string} message - Message to log
+   * @param {any} [data] - Optional data to include
+   */
+  warn(message, data) {
+      if (this.level <= LOG_LEVELS.WARN) {
+          const formattedMessage = this._format("WARN", message);
+          console.warn(formattedMessage, data !== undefined ? data : "");
+      }
+  }
+
+  /**
+   * Log an error message
+   * @param {string} message - Message to log
+   * @param {Error|any} [error] - Optional error or data to include
+   */
+  error(message, error) {
+      if (this.level <= LOG_LEVELS.ERROR) {
+          const formattedMessage = this._format("ERROR", message);
+          console.error(formattedMessage, error !== undefined ? error : "");
+      }
+  }
+}
+
+/**
+* Create a new logger instance
+* @param {string} name - Name of the logger
+* @param {number} level - Minimum log level
+* @returns {Logger} New logger instance
+*/
+function createLogger(name, level = LOG_LEVELS.INFO) {
+  return new Logger(name, level);
+}
+
+module.exports = {
+  LOG_LEVELS,
+  createLogger,
+};

package/src/utils/validation.js

@@ -0,0 +1,130 @@
+/**
+ * Validation utilities for BonkBot
+ */
+
+/**
+ * Validates account configuration
+ * @param {Object} account - Account configuration object
+ * @returns {Object} Validated account object with defaults applied
+ * @throws {Error} If required fields are missing
+ */
+function validateAccount(account = {}) {
+  // Clone to avoid modifying the original
+  const validatedAccount = { ...account };
+
+  // Set default guest status if not provided
+  if (validatedAccount.guest === undefined) {
+    validatedAccount.guest = true;
+  }
+
+  // If not a guest, username and password are required
+  if (!validatedAccount.guest) {
+    if (!validatedAccount.username) {
+      throw new Error("Username is required for non-guest accounts");
+    }
+    if (!validatedAccount.password) {
+      throw new Error("Password is required for non-guest accounts");
+    }
+  } else {
+    // For guests, generate a random username if not provided
+    if (!validatedAccount.username) {
+      validatedAccount.username = `BonkBot-${Math.random()
+        .toString()
+        .substr(2, 5)}`;
+    }
+  }
+
+  return validatedAccount;
+}
+
+/**
+ * Validates room configuration
+ * @param {Object} options - Room configuration options
+ * @returns {Object} Validated room options with defaults applied
+ */
+function validateRoomOptions(options = {}) {
+  return {
+    roomname:
+      options.roomname ||
+      `BonkBot Room ${Math.random().toString().substr(2, 5)}`,
+    maxplayers: options.maxplayers || 8,
+    roompassword: options.roompassword || "",
+    basecolor: options.basecolor !== undefined ? options.basecolor : 0,
+    skin: options.skin,
+    peerid: options.peerid || generatePeerID(),
+  };
+}
+
+/**
+ * Validates join room options
+ * @param {Object} options - Join room options
+ * @throws {Error} If required fields are missing
+ * @returns {Object} Validated join options
+ */
+function validateJoinOptions(options = {}) {
+  if (!options.address) {
+    throw new Error("Room address is required to join a room");
+  }
+
+  return {
+    address: options.address,
+    roompassword: options.roompassword || "",
+    basecolor: options.basecolor !== undefined ? options.basecolor : 16448250,
+    skin: options.skin,
+    peerid: options.peerid || generatePeerID(),
+  };
+}
+
+/**
+ * Generates a random peer ID
+ * @returns {string} Random peer ID
+ */
+function generatePeerID() {
+  return Math.random().toString(36).substr(2, 10) + "v00000";
+}
+
+/**
+ * Validates that a value is a non-empty string
+ * @param {any} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {Error} If validation fails
+ */
+function validateString(value, name) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${name} must be a non-empty string`);
+  }
+}
+
+/**
+ * Validates that a value is a number
+ * @param {any} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {Error} If validation fails
+ */
+function validateNumber(value, name) {
+  if (typeof value !== "number" || isNaN(value)) {
+    throw new Error(`${name} must be a number`);
+  }
+}
+
+/**
+ * Validates that a value is a boolean
+ * @param {any} value - Value to validate
+ * @param {string} name - Name of the parameter for error messages
+ * @throws {Error} If validation fails
+ */
+function validateBoolean(value, name) {
+  if (typeof value !== "boolean") {
+    throw new Error(`${name} must be a boolean`);
+  }
+}
+
+module.exports = {
+  validateAccount,
+  validateRoomOptions,
+  validateJoinOptions,
+  validateString,
+  validateNumber,
+  validateBoolean,
+  generatePeerID,
+};

package/dist/connection/BonkConnection.d.ts

@@ -1,173 +0,0 @@
-import { EventEmitter } from 'events';
-export type Account = {
-    username: string;
-    password?: string;
-    guest: boolean;
-};
-export type RoomInfo = {
-    address: string | null;
-    name: string | null;
-    server: string;
-    bypass: string;
-    id: number | null;
-    dbid: number | null;
-    teamsLocked: boolean;
-    map: any;
-    inGame: boolean;
-};
-export type GameInfo = {
-    id: number | null;
-    host: number | null;
-    banned: boolean;
-};
-export type Player = {
-    id: number;
-    username: string;
-    guest: boolean;
-    peerID: string;
-};
-export type JoinOptions = {
-    password?: string;
-    peerID?: string;
-};
-export type CreateRoomOptions = {
-    roomname?: string;
-    maxplayers?: number;
-    password?: string;
-};
-/**
- * Gerencia a conexão WebSocket com o servidor Bonk.io e o estado do jogo.
- */
-export declare class BonkConnection extends EventEmitter {
-    private socket;
-    private connected;
-    private keepAliveTimer;
-    private PROTOCOL_VERSION;
-    account: Account;
-    server: string;
-    room: RoomInfo;
-    game: GameInfo;
-    players: Map<number, Player>;
-    token: string | null;
-    peerID: string;
-    avatar: any;
-    location: any;
-    constructor(account: Account, server?: string);
-    /**
-     * Gera um ID de par (peerID) aleatório.
-     * @returns {string} O peerID gerado.
-     */
-    private generatePeerID;
-    /**
-     * 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.
-     */
-    private getToken;
-    /**
-     * Obtém informações do servidor (localização, etc.).
-     * (Implementação baseada no bonkbot original)
-     * @returns {Promise<any>} Informações do servidor.
-     */
-    private getServerInfo;
-    /**
-     * Inicializa a conexão (autenticação, obtenção de info do servidor).
-     * @returns {Promise<BonkConnection>} Esta instância.
-     */
-    init(): Promise<BonkConnection>;
-    /**
-     * Inicia o temporizador de keep-alive.
-     */
-    private startKeepAlive;
-    /**
-     * Para o bot (limpa timers, etc.).
-     */
-    private stopBot;
-    /**
-     * Configura os ouvintes de eventos do Socket.IO.
-     */
-    private setupSocketEvents;
-    /**
-     * Conecta-se ao servidor Bonk.io.
-     * @returns {Promise<BonkConnection>} Esta instância.
-     */
-    connect(): Promise<BonkConnection>;
-    /**
-     * Desconecta do servidor.
-     */
-    disconnect(): void;
-    /**
-     * Envia uma mensagem (pacote) para o servidor.
-     * @param {number} type - Tipo da mensagem (CLIENT_MESSAGE_TYPES).
-     * @param {any} data - Dados da mensagem.
-     */
-    sendMessage(type: number, data: any): void;
-    /**
-     * Envia o pacote TIMESYNC (keep-alive).
-     */
-    private sendTimesync;
-    /**
-     * Envia uma mensagem de chat para a sala.
-     * @param {string} message - A mensagem a ser enviada.
-     */
-    sendChat(message: string): void;
-    /**
-     * 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: number, frame: number, sequence: number): void;
-    /**
-     * Envia o comando para iniciar o jogo.
-     */
-    startGame(): void;
-    /**
-     * Envia o comando para mudar de time.
-     * @param {number} team - O ID do time (1 a 5, ou 0 para espectador).
-     */
-    changeTeam(team: number): void;
-    /**
-     * 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: boolean): void;
-    /**
-     * 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: number, ban?: boolean): void;
-    /**
-     * Cria uma nova sala.
-     * @param {CreateRoomOptions} options - Opções de criação de sala.
-     * @returns {Promise<RoomInfo>} Informações da sala criada.
-     */
-    createRoom(options?: CreateRoomOptions): Promise<RoomInfo>;
-    /**
-     * 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>}
-     */
-    joinRoom(roomAddress: string, options?: JoinOptions): Promise<void>;
-    /**
-     * Define o endereço da sala.
-     * @param {any} addressInfo - Informações de endereço da sala.
-     */
-    private setAddress;
-    /**
-     * 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.
-     */
-    private getAddressFromUrl;
-    /**
-     * Manipula os pacotes recebidos do servidor.
-     * @param {any} packet - Pacote analisado.
-     */
-    private handlePacket;
-}