bonktools 2.3.0 → 3.1.0

package/src/packet.js

@@ -0,0 +1,374 @@
+/**
+ * Packet parser for BonkBot
+ */
+const {
+  SERVER_MESSAGE_TYPES,
+  CLIENT_MESSAGE_TYPES,
+} = require("./utils/constants");
+const {
+  createLogger
+} = require("./utils/logger");
+// Create logger
+const logger = createLogger("PacketParser");
+
+/**
+* Parse a packet array into a normalized object
+* @param {Array} packet - Packet array from socket
+* @returns {Object} Normalized packet object
+*/
+function parsePacket(packet) {
+  if (!Array.isArray(packet) || packet.length < 1) {
+      return {
+          type: "unknown",
+          raw: packet
+      };
+  }
+
+  const messageType = packet[0];
+
+  // Handle server-to-client packets (incoming)
+  switch (messageType) {
+      case SERVER_MESSAGE_TYPES.PLAYER_PINGS:
+          return {
+              type: "PLAYER_PINGS",
+                  pings: packet[1],
+                  pingId: packet[2],
+          };
+
+      case SERVER_MESSAGE_TYPES.ROOM_ADDRESS:
+          return {
+              type: "ROOM_ADDRESS",
+                  address: packet[1],
+          };
+
+      case SERVER_MESSAGE_TYPES.JOIN_ROOM:
+          return {
+              	type: "JOIN_ROOM",
+				myid: packet[1],
+				hostid: packet[2],
+				playerdata: packet[3],
+				timestamp: packet[4],
+				teamslocked: packet[5],
+				roomid: packet[6],
+				roombypass: packet[7],
+          };
+
+      case SERVER_MESSAGE_TYPES.PLAYER_JOIN:
+          const isGuest = packet[4] === true;
+          return {
+              	type: "PLAYER_JOIN",
+				id: packet[1],
+				peerID: packet[2],
+				username: packet[3],
+				guest: isGuest,
+				level: isGuest ? "0" : packet[5],
+				team: packet[6] || 1, // Default to FFA if not provided
+				avatar: packet[packet.length - 1], // Avatar is always the last item
+          };
+
+      case SERVER_MESSAGE_TYPES.PLAYER_LEAVE:
+          return {
+              	type: "PLAYER_LEAVE",
+				id: packet[1],
+				tick: packet[2],
+          };
+
+      case SERVER_MESSAGE_TYPES.HOST_LEAVE:
+          if (packet[2] === -1) {
+				return {
+					type: "HOST_LEAVE",
+					gameclose: true,
+					oldid: packet[1],
+				};
+          } else {
+              return {
+                  type: "HOST_LEAVE",
+                  gameclose: false,
+                  oldid: packet[1],
+                  newid: packet[2],
+                  timestamp: packet[3],
+              };
+          }
+
+	case SERVER_MESSAGE_TYPES.PLAYER_INPUT:
+		let invalid = false
+		if (
+			!packet[2] ||
+			!packet[2].hasOwnProperty("f") ||
+			!packet[2].hasOwnProperty("c") ||
+			!packet[2].hasOwnProperty("i")
+		) {
+			invalid = true
+		}
+
+		return {
+			type: "PLAYER_INPUT",
+			id: packet[1],
+			input: packet[2].i,
+			frame: packet[2].f,
+			sequence: packet[2].c,
+			invalid: invalid,
+		};
+
+	case SERVER_MESSAGE_TYPES.READY_CHANGE:
+		return {
+			type: "READY_CHANGE",
+			id: packet[1],
+			ready: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.GAME_END:
+		return {
+			type: "GAME_END"
+		};
+
+	case SERVER_MESSAGE_TYPES.GAME_START:
+		return {
+			type: "GAME_START",
+			timestamp: packet[1],
+			mapData: packet[2],
+			state: packet[3],
+		};
+
+	case SERVER_MESSAGE_TYPES.STATUS_MESSAGE:
+		return {
+			type: "STATUS_MESSAGE",
+			status: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.TEAM_CHANGE:
+		return {
+			type: "TEAM_CHANGE",
+			id: packet[1],
+			team: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.TEAMLOCK_TOGGLE:
+		return {
+			type: "TEAMLOCK_TOGGLE",
+			locked: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.CHAT_MESSAGE:
+		return {
+			type: "CHAT_MESSAGE",
+			id: packet[1],
+			message: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.INITIAL_DATA:
+		return {
+			type: "INITIAL_DATA",
+			...packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.TIMESYNC:
+		return {
+			type: "TIMESYNC",
+			time: packet[1].result,
+			id: packet[1].id,
+		};
+
+	case SERVER_MESSAGE_TYPES.PLAYER_KICK:
+		return {
+			type: "PLAYER_KICK",
+			id: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.MAP_REORDER:
+		return {
+			type: "MAP_REORDER",
+			start: packet[1],
+			end: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.GAMEMODE_CHANGE:
+		return {
+			type: "GAMEMODE_CHANGE",
+			engine: packet[1],
+			mode: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.CHANGE_ROUNDS:
+		return {
+			type: "CHANGE_ROUNDS",
+			rounds: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.MAP_SWITCH:
+		return {
+			type: "MAP_SWITCH",
+			mapdata: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.TYPING:
+		return {
+			type: "TYPING",
+			id: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.AFK_WARNING:
+		return {
+			type: "AFK_WARNING",
+		};
+
+	case SERVER_MESSAGE_TYPES.MAP_SUGGEST:
+		return {
+			type: "MAP_SUGGEST",
+			mapdata: packet[1],
+			id: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.MAP_SUGGEST:
+		return {
+			type: "MAP_SUGGEST",
+			maptitle: packet[1],
+			mapauthor: packet[2],
+			id: packet[3],
+		};
+
+	case SERVER_MESSAGE_TYPES.BALANCE_SET:
+		return {
+			type: "BALANCE_SET",
+			id: packet[1],
+			balance: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.DEBUG_WINNER:
+		return {
+			type: "DEBUG_WINNER",
+			id: packet[1],
+			data: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.SAVE_REPLAY:
+		return {
+			type: "SAVE_REPLAY",
+			id: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.HOST_TRANSFER:
+		return {
+			type: "HOST_TRANSFER",
+			oldHost: packet[1].oldHost || packet[1],
+			newHost: packet[1].newHost || packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.FRIEND_REQUEST:
+		return {
+			type: "FRIEND_REQUEST",
+			id: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.COUNTDOWN:
+		return {
+			type: "COUNTDOWN",
+			countdown: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.ABORT_COUNTDOWN:
+		return {
+			type: "ABORT_COUNTDOWN",
+		};
+
+	case SERVER_MESSAGE_TYPES.PLAYER_LEVEL_UP:
+		return {
+			type: "PLAYER_LEVEL_UP",
+			sid: packet[1].sid,
+			level: packet[1].lv,
+		};
+
+	case SERVER_MESSAGE_TYPES.LOCAL_GAINED_XP:
+		const xpData = packet[1];
+		if (xpData.newLevel) {
+			return {
+				type: "LOCAL_GAINED_XP",
+				xp: xpData.newXP,
+				level: xpData.newLevel,
+				token: xpData.newToken,
+			};
+		} else {
+			return {
+				type: "LOCAL_GAINED_XP",
+				xp: xpData.newXP,
+			};
+		}
+
+	case SERVER_MESSAGE_TYPES.STATE:
+		return parseStatePacket(packet[1]);
+
+	case SERVER_MESSAGE_TYPES.ROOM_SHARE_LINK:
+		return {
+			type: "ROOM_SHARE_LINK",
+			roomId: packet[1],
+			roomBypass: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.PLAYER_TABBED:
+		return {
+			type: "PLAYER_TABBED",
+			id: packet[1],
+			tabbed: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.CURATE_RESULT:
+		return {
+			type: "CURATE_RESULT",
+			success: packet[1],
+			message: packet[2],
+		};
+
+	case SERVER_MESSAGE_TYPES.ROOM_NAME_UPDATE:
+		return {
+			type: "ROOM_NAME_UPDATE",
+			name: packet[1],
+		};
+
+	case SERVER_MESSAGE_TYPES.ROOM_PASSWORD_UPDATE:
+		return {
+			type: "ROOM_PASSWORD_UPDATE",
+			passwordSet: packet[1] === 1,
+		};
+
+	default:
+		logger.debug("Unknown message type", {
+			type: messageType,
+			packet
+		});
+		return {
+			type: "unknown",
+			messageType,
+			data: packet.slice(1),
+		};
+  }
+}
+
+/**
+* Parse a state packet into a normalized object
+* @param {Object} data - State packet data
+* @returns {Object} Normalized state packet
+*/
+function parseStatePacket(data) {
+	return {
+		type: "STATE",
+		gt: data.gt,
+		rounds: data.wl,
+		quickplay: data.q,
+		teamsLocked: data.tl,
+		teams: data.tea,
+		engine: data.ga,
+		mode: data.mo,
+		balance: data.bal,
+		inputs: data.inputs,
+		framecount: data.fc,
+		stateID: data.stateID,
+		admin: data.admin,
+		map: data.gs ? data.gs.map : null,
+		state: data.state,
+		random: data.random,
+	};
+}
+
+module.exports = {
+  parsePacket
+};

package/src/utils/constants.js

@@ -0,0 +1,153 @@
+/**
+ * Constants used throughout the BonkBot library
+ */
+// Default skin for bots
+const DEFAULT_AVATAR = {
+    layers: [],
+    bc: 16774557,
+};
+// Default server
+const DEFAULT_SERVER = "b2ny1";
+// Socket message types - Server to Client (Incoming)
+const SERVER_MESSAGE_TYPES = {
+    PLAYER_PINGS: 1,
+    ROOM_ADDRESS: 2,
+    JOIN_ROOM: 3,
+    PLAYER_JOIN: 4,
+    PLAYER_LEAVE: 5,
+    HOST_LEAVE: 6,
+    PLAYER_INPUT: 7,
+    READY_CHANGE: 8,
+    GAME_END: 13,
+    GAME_START: 15,
+    STATUS_MESSAGE: 16,
+    TEAM_CHANGE: 18,
+    TEAMLOCK_TOGGLE: 19,
+    CHAT_MESSAGE: 20,
+    INITIAL_DATA: 21,
+    TIMESYNC: 23,
+    PLAYER_KICK: 24,
+    MAP_REORDER: 25,
+    GAMEMODE_CHANGE: 26,
+    CHANGE_ROUNDS: 27,
+    MAP_SWITCH: 29,
+    TYPING: 30,
+    AFK_WARNING: 32,
+    MAP_SUGGEST: 33,
+    MAP_SUGGEST: 34,
+    BALANCE_SET: 36,
+    DEBUG_WINNER: 38,
+    SAVE_REPLAY: 40,
+    HOST_TRANSFER: 41,
+    FRIEND_REQUEST: 42,
+    COUNTDOWN: 43,
+    ABORT_COUNTDOWN: 44,
+    PLAYER_LEVEL_UP: 45,
+    LOCAL_GAINED_XP: 46,
+    STATE: 48,
+    ROOM_SHARE_LINK: 49,
+    PLAYER_TABBED: 52,
+    CURATE_RESULT: 57,
+    ROOM_NAME_UPDATE: 58,
+    ROOM_PASSWORD_UPDATE: 59,
+};
+// Socket message types - Client to Server (Outgoing)
+const CLIENT_MESSAGE_TYPES = {
+    PING_RESPONSE: 1,
+    TEST_PING: 2,
+    GET_DEBUG: 3,
+    SEND_INPUTS: 4,
+    TRIGGER_START: 5,
+    CHANGE_OWN_TEAM: 6,
+    TEAM_LOCK: 7,
+    SILENCE_PLAYER: 8,
+    KICK_BAN_PLAYER: 9,
+    CHAT_MESSAGE: 10,
+    INFORM_IN_LOBBY: 11,
+    CREATE_ROOM: 12,
+    JOIN_ROOM: 13,
+    RETURN_TO_LOBBY: 14,
+    SET_READY: 16,
+    ALL_READY_RESET: 17,
+    TIMESYNC: 18,
+    SEND_MAP_REORDER: 19,
+    SEND_MODE: 20,
+    SEND_ROUNDS: 21,
+    SEND_MAP_DELETE: 22,
+    SEND_MAP_ADD: 23,
+    SEND_TYPING: 24,
+    CHANGE_OTHER_TEAM: 26,
+    SEND_MAP_SUGGEST: 27,
+    SEND_BALANCE: 29,
+    VERSION_CHECK: 30,
+    SEND_DEBUG_WINNER: 31,
+    SEND_TEAM_SETTINGS: 32,
+    SEND_ARM_RECORD: 33,
+    SEND_HOST_CHANGE: 34,
+    SEND_FRIENDED: 35,
+    SEND_START_COUNTDOWN: 36,
+    SEND_ABORT_COUNTDOWN: 37,
+    SEND_REQUEST_XP: 38,
+    SEND_MAP_VOTE: 39,
+    INFORM_IN_GAME: 40,
+    GET_PRE_VOTE: 41,
+    TABBED: 44,
+    DESYNC_TEST: 45,
+    SEND_DESYNC_RESPONSE: 46,
+    SEND_NO_HOST_SWAP: 50,
+    SEND_CURATE: 51,
+};
+// For backward compatibility, keep the old MESSAGE_TYPES object
+// but use the server message types as the default
+const MESSAGE_TYPES = {
+    ...SERVER_MESSAGE_TYPES,
+    ...CLIENT_MESSAGE_TYPES,
+};
+// Team mappings
+const TEAM_NAMES = {
+    0: "spectator",
+    1: "ffa",
+    2: "red",
+    3: "blue",
+    4: "green",
+    5: "yellow",
+};
+// Gamemode names
+const GAMEMODE_NAMES = {
+	"b": "classic",
+	"ar": "arrows",
+	"ard": "death arrrows",
+	"sp": "grapple",
+	"v": "vtol",
+	"f": "football"
+}
+// Engine names
+const ENGINE_NAMES = {
+	"b": "bonk",
+	"f": "football"
+}
+// API endpoints
+const API = {
+    LOGIN: "https://bonk2.io/scripts/login_legacy.php",
+    GET_ROOMS: "https://bonk2.io/scripts/getrooms.php",
+    GET_ROOM_ADDRESS: "https://bonk2.io/scripts/getroomaddress.php",
+	AUTOJOIN: "https://bonk2.io/scripts/autojoin.php"
+};
+// Socket connection settings
+const SOCKET = {
+    KEEP_ALIVE_INTERVAL: 5000,
+    CONNECTION_TIMEOUT: 10000,
+};
+// Export all constants
+module.exports = {
+    DEFAULT_AVATAR,
+    DEFAULT_SERVER,
+    MESSAGE_TYPES,
+	GAMEMODE_NAMES,
+	ENGINE_NAMES,
+    SERVER_MESSAGE_TYPES,
+    CLIENT_MESSAGE_TYPES,
+    TEAM_NAMES,
+    API,
+    SOCKET,
+};

package/src/utils/errors.js

@@ -0,0 +1,137 @@
+/**
+ * Custom error classes for BonkBot
+ */
+
+/**
+ * Base error class for BonkBot errors
+ */
+class BonkBotError extends Error {
+	/**
+	 * Create a new BonkBotError
+	 * @param {string} message - Error message
+	 * @param {Object} [options] - Additional error options
+	 */
+	constructor(message, options = {}) {
+		super(message);
+		this.name = this.constructor.name;
+		this.code = options.code || "UNKNOWN_ERROR";
+		this.details = options.details || {};
+
+		// Capture stack trace
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, this.constructor);
+		}
+	}
+}
+
+/**
+ * Error thrown when there's a connection issue
+ */
+class ConnectionError extends BonkBotError {
+	/**
+	 * Create a new ConnectionError
+	 * @param {string} message - Error message
+	 * @param {Object} [options] - Additional error options
+	 */
+	constructor(message, options = {}) {
+		super(message, {
+			code: options.code || "CONNECTION_ERROR",
+			details: options.details,
+		});
+	}
+}
+
+/**
+ * Error thrown when there's an authentication issue
+ */
+class AuthenticationError extends BonkBotError {
+	/**
+	 * Create a new AuthenticationError
+	 * @param {string} message - Error message
+	 * @param {Object} [options] - Additional error options
+	 */
+	constructor(message, options = {}) {
+		super(message, {
+			code: options.code || "AUTHENTICATION_ERROR",
+			details: options.details,
+		});
+	}
+}
+
+/**
+ * Error thrown when there's an issue with room operations
+ */
+class RoomError extends BonkBotError {
+	/**
+	 * Create a new RoomError
+	 * @param {string} message - Error message
+	 * @param {Object} [options] - Additional error options
+	 */
+	constructor(message, options = {}) {
+		super(message, {
+			code: options.code || "ROOM_ERROR",
+			details: options.details,
+		});
+	}
+}
+
+/**
+ * Error thrown when there's an issue with the game state
+ */
+class GameStateError extends BonkBotError {
+	/**
+	 * Create a new GameStateError
+	 * @param {string} message - Error message
+	 * @param {Object} [options] - Additional error options
+	 */
+	constructor(message, options = {}) {
+		super(message, {
+			code: options.code || "GAME_STATE_ERROR",
+			details: options.details,
+		});
+	}
+}
+
+/**
+ * Error thrown when there's a validation issue
+ */
+class ValidationError extends BonkBotError {
+	/**
+	 * Create a new ValidationError
+	 * @param {string} message - Error message
+	 * @param {Object} [options] - Additional error options
+	 */
+	constructor(message, options = {}) {
+		super(message, {
+			code: options.code || "VALIDATION_ERROR",
+			details: options.details,
+		});
+	}
+}
+
+/**
+ * Error thrown when a rate limit is hit
+ */
+class RateLimitError extends BonkBotError {
+	/**
+	 * Create a new RateLimitError
+	 * @param {string} message - Error message
+	 * @param {Object} [options] - Additional error options
+	 */
+	constructor(message, options = {}) {
+		super(message, {
+			code: options.code || "RATE_LIMIT_ERROR",
+			details: options.details,
+		});
+	}
+}
+
+module.exports = {
+	BonkBotError,
+	ConnectionError,
+	AuthenticationError,
+	RoomError,
+	GameStateError,
+	ValidationError,
+	RateLimitError,
+};