yolkbot 0.0.0-1

package/dist/matchmaker.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+import{loginAnonymously as h}from"./api.js";import{GameModes as r,PlayTypes as c,ProxiesEnabled as d}from"./constants/index.js";import a from"./socket.js";class f{connected=!1;onceConnected=[];proxy=null;sessionId="";onListeners=new Map;onceListeners=new Map;#e=!1;constructor(e={}){if(e.instance||(e.instance="shellshock.io"),e.protocol||(e.protocol="wss"),e.sessionId||e.noLogin?this.sessionId=e.sessionId:this.#o(e.instance),e.proxy&&!d)throw new Error("proxies do not work and hence are not supported in the browser");e.proxy&&(this.proxy=e.proxy),this.#i(e.instance,e.protocol,e.noLogin)}async#i(e,i,s){const t=async()=>{try{this.ws=new a(`${i}://${e}/matchmaker/`,this.proxy),this.ws.onerror=async o=>(console.error(o),await new Promise(n=>setTimeout(n,100)),await t())}catch{await new Promise(o=>setTimeout(o,100)),await t()}};await t(),this.ws.onopen=()=>{this.connected=!0,this.ws.onerror=null,(this.sessionId||s)&&this.onceConnected.forEach(o=>o())},this.ws.onmessage=o=>{const n=JSON.parse(o.data);this.#s("msg",n)},this.ws.onclose=()=>{this.#e||(this.connected=!1,this.#i(e))}}async#o(e){const i=await h(this.proxy,e);(!i||typeof i=="string")&&this.#s("authFail",i),this.sessionId=i.sessionId,this.connected&&this.onceConnected.forEach(s=>s())}send(e){this.ws.send(JSON.stringify(e))}async waitForConnect(){return new Promise(e=>{this.connected?e():this.onceConnected.push(e)})}async getRegions(){return await this.waitForConnect(),new Promise(e=>{const i=s=>{s.command=="regionList"&&(this.regionList=s.regionList,this.off("msg",i),e(s.regionList))};this.on("msg",i),this.ws.onerror=s=>{throw new Error("failed to get regions",s)},this.ws.send(JSON.stringify({command:"regionList"}))})}async findPublicGame(e={}){if(await this.waitForConnect(),!e.region)throw new Error("did not specify a region in findGame, use <Matchmaker>.getRegions() for a list");if(this.regionList&&!this.regionList.find(s=>s.id==e.region))throw new Error("did not find region in regionList, if you are attempting to force a region, avoid calling getRegions()");if(!e.mode)throw new Error("did not specify a mode in findGame");if(r[e.mode]===void 0)throw new Error("invalid mode in findGame, see GameModes for a list");return new Promise(i=>{const s={command:"findGame",region:e.region,playType:c.joinPublic,gameType:r[e.mode],sessionId:this.sessionId},t=o=>{o.command=="gameFound"&&(this.off("msg",t),i(o))};this.on("msg",t),this.ws.send(JSON.stringify(s))})}getRandomRegion(){if(!this.regionList)throw new Error("called getRandomRegion() without region list cached, use <Matchmaker>.getRegions() before getRandomRegion()");return this.regionList[Math.floor(Math.random()*this.regionList.length)].id}getRandomGameMode(){const e=Object.keys(r);return e[Math.floor(Math.random()*e.length)]}close(){this.#e=!0,this.ws.close()}on(e,i){this.onListeners.has(e)||this.onListeners.set(e,[]),this.onListeners.get(e).push(i)}once(e,i){this.onceListeners.has(e)||this.onceListeners.set(e,[]),this.onceListeners.get(e).push(i)}off(e,i){this.onListeners.has(e)&&this.onListeners.set(e,this.onListeners.get(e).filter(s=>s!==i)),this.onceListeners.has(e)&&this.onceListeners.set(e,this.onceListeners.get(e).filter(s=>s!==i))}#s(e,...i){this.onListeners.has(e)&&this.onListeners.get(e).forEach(s=>s(...i)),this.onceListeners.has(e)&&(this.onceListeners.get(e).forEach(s=>s(...i)),this.onceListeners.delete(e))}}var L=f;export{f as Matchmaker,L as default};

package/dist/pathing/astar.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+import{BinaryHeap as u}from"./binaryheap.js";class a{constructor(e){this.list=e}heuristic(e,i){return Math.abs(e.x-i.x)+Math.abs(e.y-i.y)+Math.abs(e.z-i.z)}reversePath(e){const i=[];for(;e.parent;)i.push(e),e=e.parent;return i.reverse(),i}path(e,i){this.list.clean();const r=new u(s=>s.f),n=[];for(e.h=this.heuristic(e,i),e.g=0,e.f=e.g+e.h,r.push(e);r.size()!=0;){const s=r.pop();if(s===i)return this.reversePath(s);n.push(s);const c=s.links;for(let h=0;h<c.length;h++){const t=c[h];if(n.includes(t))continue;const o=s.g+1,l=t.visited;(!l||o<t.g)&&(t.visited=!0,t.parent=s,t.g=o,t.h=this.heuristic(t.position,i.position),t.f=t.g+t.h,l?r.rescoreElement(t):r.push(t))}}return null}}export{a as default};

package/dist/pathing/binaryheap.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+class r{constructor(t){this.content=[],this.scoreFunction=t}push(t){this.content.push(t),this.bubbleUp(this.content.length-1)}rescoreElement(t){this.sinkDown(this.content.indexOf(t))}pop(){const t=this.content[0],e=this.content.pop();return this.content.length>0&&(this.content[0]=e,this.sinkDown(0)),t}remove(t){const e=this.content.length;for(let n=0;n<e;n++){if(this.content[n]!=t)continue;const i=this.content.pop();if(n==e-1)break;this.content[n]=i,this.bubbleUp(n),this.sinkDown(n);break}}size(){return this.content.length}bubbleUp(t){const e=this.content[t],n=this.scoreFunction(e);for(;t>0;){const i=Math.floor((t+1)/2)-1,o=this.content[i];if(n>=this.scoreFunction(o))break;this.content[i]=e,this.content[t]=o,t=i}}includes(t){return this.content.includes(t)}sinkDown(t){const e=this.content.length,n=this.content[t],i=this.scoreFunction(n);for(;;){const o=(t+1)*2,c=o-1;let s=null,h;if(c<e){const l=this.content[c];h=this.scoreFunction(l),h<i&&(s=c)}if(o<e){const l=this.content[o];this.scoreFunction(l)<(s==null?i:h)&&(s=o)}if(s==null)break;this.content[t]=this.content[s],this.content[s]=n,t=s}}}var b=r;export{r as BinaryHeap,b as default};

package/dist/pathing/mapnode.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+class d{list=[];constructor(t){const i={};for(const s of Object.keys(t.data))for(const e of t.data[s])i[e.x<<16|e.y<<8|e.z]=!0,this.list.push(new c(s,e));for(let s=0;s<t.width;s++)for(let e=0;e<t.height;e++)for(let h=0;h<t.depth;h++)i[s<<16|e<<8|h]||this.list.push(new c("SPECIAL.air.none",{x:s,y:e,z:h}));const n=new Map;for(const s of this.list)n.set(s.positionStr,s);for(const s of this.list){const e=[{x:s.x+1,y:s.y,z:s.z},{x:s.x-1,y:s.y,z:s.z},{x:s.x,y:s.y+1,z:s.z},{x:s.x,y:s.y-1,z:s.z},{x:s.x,y:s.y,z:s.z+1},{x:s.x,y:s.y,z:s.z-1}];for(const h of e){const r=`${h.x},${h.y},${h.z}`,a=n.get(r);a&&s.canLink(a,this)&&s.links.push(a)}}}at(t,i,n){if(!this.nodeMap){this.nodeMap=new Map;for(const e of this.list){const h=`${e.x},${e.y},${e.z}`;this.nodeMap.set(h,e)}}const s=`${t},${i},${n}`;return this.nodeMap.get(s)}clean(){for(const t of this.list)t.f=0,t.g=0,t.h=0,t.visited=void 0,t.parent=void 0,t.closed=void 0}hasLineOfSight(t,i){const n=i.x-t.x,s=i.y-t.y,e=i.z-t.z,h=Math.max(Math.abs(n),Math.abs(s),Math.abs(e)),r=n/h,a=s/h,y=e/h;let l=t.x,o=t.y,f=t.z;for(let u=0;u<=h;u++){const x=this.at(Math.round(l),Math.round(o),Math.round(f));if(x&&x.isSolid())return!1;l+=r,o+=a,f+=y}return!0}}class c{constructor(t,i){this.x=i.x,this.y=i.y,this.z=i.z,this.positionStr=`${this.x},${this.y},${this.z}`,this.position={x:this.x,y:this.y,z:this.z},this.meshType=t.split(".").pop(),this.f=0,this.g=0,this.h=0,this.visited=void 0,this.parent=void 0,this.closed=void 0,this.links=[],this.isStair()&&(i.ry?this.ry=i.ry:this.ry=0)}isSolid(){return this.meshType=="full"}canWalkThrough(){return this.meshType=="none"||this.meshType=="ladder"}canWalkOn(){return this.meshType=="full"}isLadder(){return this.meshType=="ladder"}isStair(){return this.meshType=="wedge"}isAir(){return this.meshType=="none"}canLink(t,i){const n=this.x-t.x,s=this.z-t.z,e=this.y-t.y,h=Math.abs(n),r=Math.abs(e),a=Math.abs(s);if(h+r+a===0||h+a>1||this.isSolid()||t.isSolid())return!1;const y=i.at(this.x,this.y-1,this.z),l=i.at(t.x,t.y-1,t.z);if(!y||!l)return!1;const o={0:{x:0,z:-1},1:{x:-1,z:0},2:{x:0,z:1},3:{x:1,z:0}};switch(this.meshType){case"none":return!!(e===1&&t.canWalkThrough()||(y.canWalkOn()||y.isLadder())&&(t.meshType==="none"||t.meshType==="ladder"&&r===0||t.meshType==="wedge"&&e===0&&n===-o[t.ry].x&&s===-o[t.ry].z));case"ladder":return!!(r===1&&t.canWalkThrough()||r===0&&y.canWalkOn()||t.meshType==="ladder"&&(r===1||y.canWalkOn()&&l.canWalkOn()));case"wedge":return this.x+o[this.ry].x===t.x&&this.z+o[this.ry].z===t.z&&this.y+1===t.y||this.x-o[this.ry].x===t.x&&this.z-o[this.ry].z===t.z&&(this.y===t.y||this.y-1===t.y);default:return!1}}flatCenter(){return{x:this.x+.5,y:this.y+0,z:this.z+.5}}flatRadialDistance(t){const i=this.flatCenter();return Math.hypot(i.x-t.x,i.z-t.z)}}var p=c;export{c as MapNode,d as NodeList,p as default};

package/dist/socket.js

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+import r from"./globals.js";import{IsBrowser as t,UserAgent as n}from"./constants/index.js";class o extends r.WebSocket{constructor(e,s){t?super(e):super(e,{agent:s?new r.SocksProxyAgent(s):void 0,headers:{"user-agent":n,"accept-language":"en-US,en;q=0.9"}})}}var l=o;export{l as default};

package/dist/types/api.d.ts

@@ -0,0 +1,14 @@
+export interface QueryRequest {
+    cmd: string;
+    [key: string]: any;
+}
+
+export interface QueryResponse {
+    [key: string]: any;
+}
+
+export function queryServices(request: QueryRequest, proxy?: string, instance?: string): Promise<QueryResponse | string>;
+export function loginWithCredentials(email: string, password: string, proxy?: string, instance?: string): Promise<QueryResponse | string>;
+export function loginWithRefreshToken(refreshToken: string, proxy?: string, instance?: string): Promise<QueryResponse | string>;
+export function loginAnonymously(proxy?: string, instance?: string): Promise<QueryResponse | string>;
+export function createAccount(email: string, password: string, proxy?: string, instance?: string): Promise<QueryResponse | string>;

package/dist/types/bot/GamePlayer.d.ts

@@ -0,0 +1,119 @@
+import { AnyGun, Cluck9mm } from '../constants/guns';
+import { Item } from '../constants/items';
+
+export interface Position {
+    x: number;
+    y: number;
+    z: number;
+}
+
+export interface View {
+    yaw: number;
+    pitch: number;
+}
+
+export interface Character {
+    eggColor: string;
+    primaryGun: Item | number;
+    secondaryGun: Item | number;
+    stamp: Item | number;
+    hat: Item | number;
+    grenade: Item | number;
+    melee: Item | number;
+    stampPos: {
+        x: number;
+        y: number;
+    }
+}
+
+export interface PlayerStats {
+    killsInGame: number;
+    deathsInGame: number;
+    streak: number;
+    totalKills: number;
+    totalDeaths: number;
+    bestGameStreak: number;
+    bestOverallStreak: number;
+}
+
+export interface PlayerData {
+    id: string;
+    uniqueId: string;
+    name: string;
+    safename: string;
+    charClass: number;
+    team: 0 | 1 | 2;
+    primaryWeaponItem: Item | number;
+    secondaryWeaponItem: Item | number;
+    shellColor: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13;
+    hatItem: Item | number;
+    stampItem: Item | number;
+    stampPosX: number;
+    stampPosY: number;
+    grenadeItem: Item | number;
+    meleeItem: Item | number;
+    x: number;
+    y: number;
+    z: number;
+    $dx: number;
+    $dy: number;
+    $dz: number;
+    yaw: number;
+    pitch: number;
+    score: number;
+    kills: number;
+    deaths: number;
+    streak: number;
+    totalKills: number;
+    totalDeaths: number;
+    bestGameStreak: number;
+    bestOverallStreak: number;
+    shield: number;
+    hp: number;
+    playing: boolean;
+    weaponIdx: number;
+    $controlKeys: number;
+    upgradeProductId: number;
+    activeShellStreaks: number;
+    social: string;
+    hideBadge: boolean;
+}
+
+export interface Social {
+    id: number;
+    type: 'Facebook' | 'Instagram' | 'Tiktok' | 'Discord' | 'Youtube' | 'Twitter' | 'Twitch';
+    url: string;
+    active: boolean;
+}
+
+export class GamePlayer {
+    id: string;
+    team: 0 | 1 | 2;
+    raw: PlayerData;
+    name: string;
+    uniqueId: string;
+    playing: boolean;
+    socials: Social[];
+    isVip: boolean;
+    showBadge: boolean;
+    position: Position;
+    jumping: boolean;
+    climbing: boolean;
+    view: View;
+    character: Character;
+    stats: PlayerStats;
+    activeGun: number;
+    selectedGun: number;
+    weapons: [AnyGun, Cluck9mm];
+    grenades: number;
+    streak: number;
+    hp: number;
+    hpShield: number;
+    spawnShield: number;
+    streakRewards: number[];
+    randomSeed: number;
+
+    constructor(playerData: PlayerData);
+}
+
+export default GamePlayer;

package/dist/types/bot.d.ts

@@ -0,0 +1,331 @@
+type intents = {
+    CHALLENGES: 1,
+    STATS: 2,
+    PATHFINDING: 3,
+    PING: 5,
+    COSMETIC_DATA: 6,
+    PLAYER_HEALTH: 7,
+    PACKET_HOOK: 8,
+    LOG_PACKETS: 10,
+    NO_LOGIN: 11,
+    DEBUG_BUFFER: 12,
+    DEBUG_BEST_TARGET: 14
+}
+
+import { NodeList } from '../pathing/mapnode.js';
+
+import { Character, GamePlayer } from './bot/GamePlayer';
+import { Challenge } from './constants/challenges';
+import { AnyGun } from './constants/guns';
+import { Map } from './constants/maps';
+import { ADispatch } from './dispatches/index';
+import { Matchmaker, RawGameData } from './matchmaker';
+import yolkws from './socket';
+
+export interface BotParams {
+    intents?: number[];
+    doUpdate?: boolean;
+    updateInterval?: number;
+    proxy?: string;
+    instance?: string;
+    protocol?: string;
+}
+
+export interface ChiknWinnerStatus {
+    atLimit: boolean;
+    limit: number;
+    secondsUntilPlay: number;
+    canPlayAgain: number;
+}
+
+export interface StatKD {
+    total: number;
+    mode: {
+        public: number;
+        private: number;
+    };
+    dmgType: {
+        pistol: number;
+        grenade: number;
+        rpegg: number;
+        eggk: number;
+        scrambler: number;
+        ranger: number;
+        whpper: number;
+        crackshot: number;
+        trihard: number;
+        melee: number;
+    };
+    gameType: {
+        kotc: number;
+        spatula: number;
+        ffa: number;
+        team: number;
+    }
+}
+
+export interface Stats {
+    streak: number;
+    kills: StatKD;
+    deaths: StatKD;
+    gameType: {
+        kotc: {
+            captured: number;
+            wins: number;
+        }
+    };
+}
+
+export interface Challenges {
+    raw: {
+        challengeInfo: Challenge;
+        challengeData: {
+            period: number;
+            challengeId: number;
+            reset: number;
+            claimed: number;
+            completed: number;
+            data: number;
+        }
+    }
+    id: number;
+    name: string;
+    desc: string;
+    rewardEggs: number;
+    isRerolled: boolean;
+    isClaimed: boolean;
+    isCompleted: boolean;
+    progressNum: number;
+    goalNum: number;
+}
+
+export interface Account {
+    id: number;
+    firebaseId: string;
+    sessionId: string;
+    session: string;
+    email: string;
+    password: string;
+    cw: ChiknWinnerStatus;
+    loadout: {
+        hatId: number | null;
+        meleeId: number;
+        stampId: number | null;
+        classIdx: number;
+        colorIdx: number;
+        grenadeId: number;
+        primaryId: number[];
+        secondaryId: number[];
+        stampPositionX: number;
+        stampPositionY: number;
+    };
+    ownedItemIds: number[];
+    vip: boolean;
+    accountAge: number;
+    emailVerified: boolean;
+    eggBalance: number;
+    stats: {
+        lifetime: Stats;
+        monthly: Stats;
+    }
+    challenges: Challenges[];
+    rawLoginData: any; // someday i'll type it
+}
+
+export interface GameOptions {
+    gravity: number;
+    damage: number;
+    healthRegen: number;
+    locked: boolean;
+    noTeamChange: boolean;
+    noTeamShuffle: boolean;
+    weaponsDisabled: boolean[];
+    mustUseSecondary: boolean;
+}
+
+export interface Collectable {
+    id: number;
+    x: number;
+    y: number;
+    z: number;
+}
+
+export interface Zone {
+    x: number;
+    y: number;
+    z: number;
+    zone: number;
+}
+
+export interface Game {
+    raw: RawGameData;
+    code: string;
+    gameModeId: number;
+    gameMode: string;
+    mapIdx: number;
+    map: {
+        filename: string;
+        hash: string;
+        name: string;
+        modes: {
+            FFA: boolean;
+            Teams: boolean;
+            Spatula: boolean;
+            King: boolean;
+        };
+        availability: string;
+        numPlayers: string;
+        raw: Map;
+        zones: Zone[][];
+    };
+    playerLimit: number;
+    isGameOwner: boolean;
+    isPrivate: boolean;
+    options: GameOptions;
+    collectables: Collectable[][];
+    teamScore: number[];
+    spatula: {
+        coords: { x: number; y: number; z: number };
+        controlledBy: number;
+        controlledByTeam: number;
+    };
+    stage: number;
+    zoneNumber: number;
+    activeZone: Zone[];
+    capturing: number;
+    captureProgress: number;
+    numCapturing: number;
+    stageName: string;
+    capturePercent: number;
+    socket: yolkws | null;
+}
+
+export interface Pathing {
+    nodeList: NodeList | null;
+    followingPath: boolean;
+    activePath: any;
+    activeNode: any;
+    activeNodeIdx: number;
+}
+
+export interface BotState {
+    name: string;
+    weaponIdx: number;
+    reloading: boolean;
+    swappingGun: boolean;
+    usingMelee: boolean;
+    shotsFired: number;
+    quit: boolean;
+}
+
+export interface ChiknWinnerResponse {
+    eggsGiven: number;
+    itemIds: number[];
+    rewardTier: number;
+}
+
+export class Bot {
+    static Intents: intents;
+    Intents: intents;
+
+    proxy: string;
+    autoUpdate: boolean;
+    disablePathing: boolean;
+    updateInterval: number;
+    instance: string;
+    protocol: string;
+    state: BotState;
+    players: Record<string, GamePlayer>;
+    me: GamePlayer;
+    game: Game;
+    account: Account;
+    ping: number;
+    lastPingTime: number;
+    lastDeathTime: number;
+    lastChatTime: number;
+    lastUpdateTime: number;
+    controlKeys: number;
+    pathing: Pathing;
+    matchmaker: Matchmaker | null;
+
+    constructor(params?: BotParams);
+
+    loginAnonymously(): Promise<Account | false>;
+    loginWithRefreshToken(refreshToken: string): Promise<Account | false>;
+    login(email: string, pass: string): Promise<Account | false>;
+    createAccount(email: string, pass: string): Promise<Account | false>;
+
+    initMatchmaker(): Promise<boolean>;
+    createPrivateGame(opts: { region: string; mode: string; map: string }): Promise<RawGameData>;
+    join(botName: string, data: string | RawGameData): Promise<void>;
+
+    processPacket(data: number[]): void;
+    dispatch(disp: ADispatch): void;
+    update(): void;
+
+    canSee(player: GamePlayer): boolean;
+    getBestTarget(customFilter?: (player: GamePlayer) => boolean): { player: GamePlayer, inLoS: boolean } | undefined;
+
+    onAny(cb: Function): void;
+    off(event: string, cb: Function): void;
+
+    on(event: 'authFail', cb: (reason: string) => void): void;
+    on(event: 'authSuccess', cb: (account: Account) => void): void;
+    on(event: 'balanceUpdate', cb: (oldBalance: number, newBalance: number) => void): void;
+    on(event: 'banned', cb: (banRemaining: string) => void): void;
+    on(event: 'chat', cb: (player: GamePlayer | undefined, message: string, flags: number) => void): void;
+    on(event: 'close', cb: (code: number) => void): void;
+    on(event: 'collectAmmo', cb: (player: GamePlayer, weapon: AnyGun) => void): void;
+    on(event: 'collectGrenade', cb: (player: GamePlayer) => void): void;
+    on(event: 'gameForcePause', cb: () => void): void;
+    on(event: 'gameOptionsChange', cb: (oldOptions: GameOptions, newOptions: GameOptions) => void): void;
+    on(event: 'gameReady', cb: () => void): void;
+    on(event: 'gameReset', cb: () => void): void;
+    on(event: 'gameStateChange', cb: (oldState: Game, newState: Game) => void): void;
+    on(event: 'grenadeExploded', cb: (item: Item | number, pos: { x: number; y: number; z: number }, damage: number, radius: number) => void): void;
+    on(event: 'leave', cb: () => void): void;
+    on(event: 'packet', cb: (packet: ArrayBuffer) => void): void;
+    on(event: 'pingUpdate', cb: (oldPing: number, newPing: number) => void): void;
+    on(event: 'playerBeginStreak', cb: (player: GamePlayer, streak: number) => void): void;
+    on(event: 'playerChangeCharacter', cb: (player: GamePlayer, oldCharacter: Character, newCharacter: Character) => void): void;
+    on(event: 'playerChangeGun', cb: (player: GamePlayer, oldGun: number, newGun: number) => void): void;
+    on(event: 'playerDamaged', cb: (player: GamePlayer, oldHp: number, newHp: number) => void): void;
+    on(event: 'playerDeath', cb: (player: GamePlayer, killer: GamePlayer) => void): void;
+    on(event: 'playerFire', cb: (player: GamePlayer, weapon: AnyGun) => void): void;
+    on(event: 'playerJoin', cb: (player: GamePlayer) => void): void;
+    on(event: 'playerLeave', cb: (player: GamePlayer) => void): void;
+    on(event: 'playerMelee', cb: (player: GamePlayer) => void): void;
+    on(event: 'playerPause', cb: (player: GamePlayer) => void): void;
+    on(event: 'playerReload', cb: (player: GamePlayer, weapon: AnyGun) => void): void;
+    on(event: 'playerRespawn', cb: (player: GamePlayer) => void): void;
+    on(event: 'playerSwapWeapon', cb: (player: GamePlayer, nowActive: number) => void): void;
+    on(event: 'playerSwitchTeam', cb: (player: GamePlayer, oldTeam: number, newTeam: number) => void): void;
+    on(event: 'quit', cb: () => void): void;
+    on(event: 'rocketHit', cb: (pos: { x: number; y: number; z: number }, damage: number, radius: number) => void): void;
+    on(event: 'selfDamaged', cb: (oldHp: number, newHp: number) => void): void;
+    on(event: 'selfMoved', cb: (oldPos: { x: number; y: number; z: number }, newPos: { x: number; y: number; z: number }) => void): void;
+    on(event: 'selfRespawnFail', cb: () => void): void;
+    on(event: 'selfShieldHit', cb: (oldShield: number, newShield: number) => void): void;
+    on(event: 'selfShieldLost', cb: () => void): void;
+    on(event: 'spawnItem', cb: (type: number, _id: number, pos: { x: number; y: number; z: number }) => void): void;
+    on(event: 'tick', cb: () => void): void;
+
+    checkChiknWinner(): Promise<ChiknWinnerStatus>;
+    playChiknWinner(doPrematureCooldownCheck: boolean): Promise<ChiknWinnerResponse | string>;
+    resetChiknWinner(): Promise<ChiknWinnerStatus>;
+
+    refreshChallenges(): Promise<Challenges[]>;
+    claimChallenge(challengeId: number): Promise<{ eggReward: number, updatedChallenges: Challenges[] }>;
+    rerollChallenge(challengeId: number): Promise<Challenges[]>;
+
+    refreshBalance(): Promise<number>;
+    redeemCode(code: string): Promise<{ result: string; eggsGiven: number; itemIds: number[]; }>;
+    claimURLReward(reward: string): Promise<{ result: string; eggsGiven: number; itemIds: number[]; }>;
+    claimSocialReward(rewardTag: string): Promise<{ result: string; eggsGiven: number; itemIds: number[]; }>;
+    buyItem(itemId: number): Promise<{ result: string; currentBalance: number; itemId: number; }>;
+
+    leave(code?: number): void;
+    quit(noCleanup?: boolean): void;
+}
+
+export default Bot;

package/dist/types/comm/Codes.d.ts

@@ -0,0 +1,21 @@
+export declare const CloseCode: {
+    gameNotFound: number;
+    gameFull: number;
+    badName: number;
+    mainMenu: number;
+    gameIdleExceeded: number;
+    corruptedLoginData: number;
+    gameMaxPlayersExceeded: number;
+    gameDestroyUser: number;
+    joinGameOutOfOrder: number;
+    gameShuttingDown: number;
+    readyBeforeReady: number;
+    booted: number;
+    gameErrorOnUserSocket: number;
+    uuidNotFound: number;
+    sessionNotFound: number;
+    clusterFullCpu: number;
+    clusterFullMem: number;
+    noClustersAvailable: number;
+    locked: number;
+};

package/dist/types/comm/CommIn.d.ts

@@ -0,0 +1,22 @@
+declare class CommIn {
+    static buffer: Uint8Array;
+    static idx: number;
+    static init(buf: ArrayBuffer): void;
+    static isMoreDataAvailable(): number;
+    static peekInt8U(): number;
+    static unPackInt8U(): number;
+    static unPackInt8(): number;
+    static unPackInt16U(): number;
+    static unPackInt24U(): number;
+    static unPackInt32U(): number;
+    static unPackInt16(): number;
+    static unPackInt32(): number;
+    static unPackRadU(): number;
+    static unPackRad(): number;
+    static unPackFloat(): number;
+    static unPackDouble(): number;
+    static unPackString(maxLen?: number): string;
+    static unPackLongString(maxLen?: number): string;
+}
+
+export default CommIn;

package/dist/types/comm/CommOut.d.ts

@@ -0,0 +1,10 @@
+import OutBuffer from './OutBuffer';
+import Pool from './Pool';
+
+declare class CommOut {
+    static buffer: OutBuffer | null;
+    static bufferPool: Pool<OutBuffer>;
+    static getBuffer(): OutBuffer;
+}
+
+export default CommOut;

package/dist/types/comm/OutBuffer.d.ts

@@ -0,0 +1,24 @@
+declare class OutBuffer {
+    private idx: number;
+    private arrayBuffer: ArrayBuffer;
+    private buffer: Uint8Array;
+
+    constructor(size: number);
+
+    send(ws2: { send(data: Uint8Array): void }): void;
+
+    packInt8(val: number): void;
+    packInt16(val: number): void;
+    packInt24(val: number): void;
+    packInt32(val: number): void;
+
+    packRadU(val: number): void;
+    packRad(val: number): void;
+    packFloat(val: number): void;
+    packDouble(val: number): void;
+
+    packString(str: string, doMalicious?: boolean): void;
+    packLongString(str: string): void;
+}
+
+export default OutBuffer;

package/dist/types/comm/Pool.d.ts

@@ -0,0 +1,20 @@
+declare class Pool<T> {
+    size: number;
+    originalSize: number;
+    constructorFn: () => T;
+    objects: Array<T & { id: number; active: boolean }>;
+    idx: number;
+    numActive: number;
+
+    constructor(constructorFn: () => T, size: number);
+
+    expand(num: number): void;
+
+    retrieve(id?: number): T & { id: number; active: boolean };
+
+    recycle(obj: T & { id: number; active: boolean }): void;
+
+    forEachActive(fn: (obj: T & { id: number; active: boolean }, index: number) => void): void;
+}
+
+export default Pool;

package/dist/types/comm/index.d.ts

@@ -0,0 +1,16 @@
+import CommIn from './CommIn';
+import CommOut from './CommOut';
+import OutBuffer from './OutBuffer';
+import Pool from './Pool';
+
+import { CommCode } from '../constants/codes';
+import { CloseCode } from './Codes';
+
+export {
+    CommIn,
+    CommOut,
+    OutBuffer,
+    Pool,
+    CommCode,
+    CloseCode
+};

package/dist/types/constants/challenges.d.ts

@@ -0,0 +1,19 @@
+export interface Challenge {
+    id: number;
+    loc_ref: string;
+    type: number;
+    subType: number;
+    period: number;
+    goal: number;
+    reward: number;
+    conditional: number;
+    value: string;
+    valueTwo: string | null;
+    tier: number;
+    loc: {
+        title: string;
+        desc: string;
+    }
+}
+
+export const Challenges: Challenge[];

package/dist/types/constants/changelog.d.ts

@@ -0,0 +1,7 @@
+export interface ChangelogEntry {
+    version: string;
+    date: string;
+    content: string[];
+}
+
+export const Changelog: ChangelogEntry[];