yolkbot 1.4.8 → 1.5.0

package/dist/bot.d.ts

@@ -1,41 +1,44 @@
-type intents = {
-    CHALLENGES: 1,
-    BOT_STATS: 2,
-    PATHFINDING: 3,
-    PING: 5,
-    COSMETIC_DATA: 6,
-    PLAYER_HEALTH: 7,
-    PACKET_HOOK: 8,
-    LOG_PACKETS: 10,
-    NO_LOGIN: 11,
-    DEBUG_BUFFER: 12,
-    NO_AFK_KICK: 16,
-    LOAD_MAP: 17,
-    OBSERVE_GAME: 18,
-    NO_REGION_CHECK: 19,
-    NO_EXIT_ON_ERROR: 20,
-    RENEW_SESSION: 21,
-    VIP_HIDE_BADGE: 22
-}
-
 import { Character, GamePlayer, Position, View } from './bot/GamePlayer';
+
 import { Challenge } from './constants/challenges';
-import { AnyGun } from './constants/guns';
+import { CreatedGun } from './constants/guns';
 import { MapJSON } from './constants/maps';
 import { Item } from './constants/items';
-import { ADispatch } from './dispatches/index';
+import { Region } from './constants/regions';
+
+import { ADispatch, DispatchParams } from './dispatches/index';
+
+import AStar from './pathing/astar';
 import { NodeList } from './pathing/mapnode';
-import { AnonError, API, LoginError, QueryServicesError } from './api';
-import { Matchmaker } from './matchmaker';
+
+import { API, AuthResponse, RawFirebase, ReturnError } from './api';
 import yolkws from './socket';
 
+import {
+    APIError,
+    BuyItemError,
+    ChallengeRerollError,
+    ChicknWinnerError,
+    ClaimSocialError,
+    ClaimURLError,
+    CleanupLevel,
+    GameFindError,
+    GameJoinError,
+    Intents,
+    LoginError,
+    MatchmakerError,
+    PathfindError,
+    RedeemCodeError,
+    ZoneLeaveReason
+} from './enums';
+
 export interface BotParams {
-    intents?: number[];
     proxy?: string;
     instance?: string;
     protocol?: string;
-    apiMaxRetries?: number;
+    intents?: number[];
     connectionTimeout?: number;
+    errorLogger?: (...args: any[]) => void;
 }
 
 export interface ChiknWinnerStatus {
@@ -152,7 +155,7 @@ export interface RawLoginData {
     dateModified: string;
     accountAge: number;
     statsLifetime: Stats;
-    statsMonthly: Stats;
+    statsCurrent: Stats;
     eggsSpent: number | null;
     eggsSpentMonthly: number | null;
     challenges: RawChallenge[];
@@ -181,21 +184,17 @@ export interface RawLoginData {
         limit?: number;
         reset?: number;
     }
-}
-
-export interface AccountFirebase {
-    idToken: string;
-    refeshToken: string;
-    expiresIn: string;
-    localId: string;
+    cgAccountStatus: {
+        hasAccount: boolean;
+    }
 }
 
 export interface Account {
     id: number;
-    firebase: AccountFirebase;
+    firebase: RawFirebase;
     firebaseId: string;
     sessionId: string;
-    session: string;
+    session: number;
     email: string;
     password: string;
     cw: ChiknWinnerStatus;
@@ -203,6 +202,7 @@ export interface Account {
     ownedItemIds: number[];
     vip: boolean;
     isAged: boolean;
+    isCG: boolean;
     emailVerified: boolean;
     eggBalance: number;
     stats: {
@@ -212,7 +212,6 @@ export interface Account {
     challenges: Challenges[];
     adminRoles: number;
     rawLoginData: RawLoginData;
-    isDoubleEggWeeknd: () => boolean;
 }
 
 export interface GameOptions {
@@ -226,7 +225,7 @@ export interface GameOptions {
     mustUseSecondary: boolean;
 }
 
-export interface Collectable {
+export interface Collectible {
     id: number;
     x: number;
     y: number;
@@ -262,6 +261,16 @@ export interface GameSpatula {
     controlledByTeam: number;
 }
 
+export interface GameKOTC {
+    stage: number;
+    zoneIdx: number;
+    activeZone: Zone[];
+    capturing: number;
+    captureProgress: number;
+    numCapturing: number;
+    capturePercent: number;
+}
+
 export interface RawGameData {
     command: 'gameFound';
     region: string;
@@ -272,6 +281,16 @@ export interface RawGameData {
     noobLobby: boolean;
 }
 
+export interface FindGameResponse {
+    ok: true;
+    raw: RawGameData;
+    id: string;
+    uuid: string;
+    region: string;
+    private: boolean;
+    subdomain: string;
+}
+
 export interface Game {
     raw: RawGameData;
     code: string;
@@ -284,21 +303,15 @@ export interface Game {
     isGameOwner: boolean;
     isPrivate: boolean;
     options: GameOptions;
-    collectables: Collectable[][];
+    collectibles: Collectible[][];
     teamScore: number[];
     spatula: GameSpatula;
-    stage: number;
-    zoneNumber: number;
-    activeZone: Zone[];
-    capturing: number;
-    captureProgress: number;
-    numCapturing: number;
-    capturePercent: number;
+    kotc: GameKOTC;
 }
 
 export interface Pathing {
     nodeList: NodeList | null;
-    followingPath: boolean;
+    astar: AStar | null;
     activePath: any;
     activeNode: any;
     activeNodeIdx: number;
@@ -319,6 +332,10 @@ export interface BotState {
     yaw: number;
     pitch: number;
     controlKeys: number;
+    onGround: number;
+    dx: number;
+    dy: number;
+    dz: number;
     reloading: boolean;
     swappingGun: boolean;
     usingMelee: boolean;
@@ -329,6 +346,7 @@ export interface BotState {
 }
 
 export interface ChiknWinnerResponse {
+    ok: true;
     eggsGiven: number;
     itemIds: number[];
     rewardTier: number;
@@ -343,15 +361,24 @@ export interface FireBullet {
     dirZ: number;
 }
 
-type FindPublicErrors = 'no_region_passed' | 'invalid_region_passed' | 'no_mode_passed' | 'invalid_mode_passed' | 'matchmaker_init_fail' | 'internal_session_error';
-type CreatePrivateErrors = FindPublicErrors | 'invalid_map_passed';
-type BotLoginError = 'account_banned';
+export interface LoginResponse {
+    ok: true;
+    account: Account;
+}
+
+export interface GameStateChanges {
+    teamScore: { before: number[], after: number[] };
+    kotc?: { before: GameKOTC, after: GameKOTC };
+    spatula?: { before: GameSpatula, after: GameSpatula };
+    playersOnZone?: { before: GamePlayer[] };
+}
 
 export class Bot {
-    static Intents: intents;
-    Intents: intents;
     intents: number[];
 
+    regionList: Region[];
+    matchmakerListeners: Function[];
+
     proxy: string;
     instance: string;
     protocol: string;
@@ -372,27 +399,27 @@ export class Bot {
     hasQuit: boolean;
 
     api: API;
-    matchmaker: Matchmaker | null;
+    matchmaker: yolkws | null;
 
     constructor(params?: BotParams);
 
-    loginAnonymously(): Promise<Account | BotLoginError | AnonError>;
-    loginWithRefreshToken(refreshToken: string): Promise<Account | BotLoginError | LoginError>;
-    login(email: string, pass: string): Promise<Account | BotLoginError | LoginError>;
-    createAccount(email: string, pass: string): Promise<Account | BotLoginError | LoginError>;
+    loginAnonymously(): Promise<LoginResponse | LoginError>;
+    loginWithRefreshToken(refreshToken: string): Promise<LoginResponse | LoginError>;
+    login(email: string, pass: string): Promise<LoginResponse | LoginError>;
+    createAccount(email: string, pass: string): Promise<LoginResponse | LoginError>;
+    processLoginData: (data: AuthResponse | ReturnError) => LoginResponse | LoginError;
 
-    initMatchmaker(): Promise<true | BotLoginError | AnonError | 'matchmaker_tryconnect_failed'>;
+    createMatchmaker(): Promise<{ ok: true } | MatchmakerError>;
+    getRegions(): Promise<{ ok: true, regionList: Region[] } | MatchmakerError>;
 
-    createPrivateGame(region: string, mode: number, map: string): Promise<RawGameData | FindPublicErrors>;
-    findPublicGame(region: string, mode: number): Promise<RawGameData | CreatePrivateErrors>;
+    initSession(): Promise<{ ok: true } | LoginError | MatchmakerError>;
 
-    join(botName: string, data: string | RawGameData): Promise<true | 'matchmaker_init_fail' | 'game_not_found' | 'websocket_tryconnect_fail' | 'invalid_game_object'>;
+    findPublicGame(region: string, mode: string | number): Promise<FindGameResponse | GameFindError | LoginError | MatchmakerError>;
+    createPrivateGame(region: string, mode: string | number, map: string): Promise<FindGameResponse | GameFindError | LoginError | MatchmakerError>;
 
-    processPacket(data: number[]): void;
-    dispatch(disp: ADispatch): boolean;
-    update(): void;
+    join(botName: string, data: string | FindGameResponse | RawGameData): Promise<{ ok: true } | LoginError | MatchmakerError | GameJoinError>;
 
-    canSee(player: GamePlayer): boolean;
+    update(): void;
 
     onAny(cb: Function): void;
     off(event: string, cb: Function): void;
@@ -405,37 +432,39 @@ export class Bot {
     on(event: 'challengeComplete', cb: (player: GamePlayer, challengeId: number) => 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: 'error', cb: (error: string) => 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, oldPlayersOnZone: GamePlayer[]) => void): void;
+    on(event: 'gameStateChange', cb: (changes: GameStateChanges) => void): void;
     on(event: 'grenadeExplode', cb: (item: Item | number, pos: Position, damage: number, radius: number) => void): void;
     on(event: 'leave', cb: (closeCode: number) => void): void;
     on(event: 'mapLoad', cb: (map: MapJSON) => void): void;
     on(event: 'packet', cb: (packet: ArrayBuffer) => void): void;
+    on(event: 'pathfindComplete', cb: () => void): void;
+    on(event: 'pathfindError', cb: (error: PathfindError) => void): void;
     on(event: 'pingUpdate', cb: (oldPing: number, newPing: number) => void): void;
     on(event: 'playerBeginStreak', cb: (player: GamePlayer, streakType: number) => void): void;
     on(event: 'playerChangeCharacter', cb: (player: GamePlayer, oldCharacter: Character, newCharacter: Character) => void): void;
     on(event: 'playerChangeGun', cb: (player: GamePlayer, oldGunId: number, newGunId: number) => void): void;
-    on(event: 'playerCollectAmmo', cb: (player: GamePlayer, weapon: AnyGun, itemId: number) => void): void;
+    on(event: 'playerCollectAmmo', cb: (player: GamePlayer, weapon: CreatedGun, itemId: number) => void): void;
     on(event: 'playerCollectGrenade', cb: (player: GamePlayer, itemId: number) => void): void;
     on(event: 'playerDamage', cb: (player: GamePlayer, oldHp: number, newHp: number) => void): void;
     on(event: 'playerDeath', cb: (killed: GamePlayer, killer: GamePlayer, oldKilled: GamePlayer, damageInt: number) => void): void;
+    on(event: 'playerEndReload', cb: (player: GamePlayer, weapon: CreatedGun) => void): void;
     on(event: 'playerEndStreak', cb: (player: GamePlayer, streakType: number) => void): void;
     on(event: 'playerEnterZone', cb: (player: GamePlayer) => void): void;
-    on(event: 'playerFire', cb: (player: GamePlayer, weapon: AnyGun, bullet: FireBullet) => void): void;
+    on(event: 'playerFire', cb: (player: GamePlayer, weapon: CreatedGun, bullet: FireBullet) => void): void;
     on(event: 'playerJoin', cb: (player: GamePlayer) => void): void;
     on(event: 'playerInfo', cb: (player: GamePlayer, playerIP: string, playerDBId: string) => void): void;
     on(event: 'playerLeave', cb: (player: GamePlayer) => void): void;
-    on(event: 'playerLeaveZone', cb: (player: GamePlayer) => void): void;
+    on(event: 'playerLeaveZone', cb: (player: GamePlayer, leaveReason: ZoneLeaveReason) => void): void;
     on(event: 'playerMelee', cb: (player: GamePlayer) => void): void;
     on(event: 'playerMove', cb: (player: GamePlayer, oldPosition: Position, newPosition: Position) => 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: 'playerRotate', cb: (player: GamePlayer, oldView: View, newView: View) => void): void;
+    on(event: 'playerStartReload', cb: (player: GamePlayer, weapon: CreatedGun) => 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: 'playerThrowGrenade', cb: (player: GamePlayer, position: Position, dPosition: Position) => void): void;
@@ -447,23 +476,32 @@ export class Bot {
     on(event: 'spawnItem', cb: (itemType: number, itemPosition: Position, itemId: number) => void): void;
     on(event: 'tick', cb: () => void): void;
 
-    checkChiknWinner(): Promise<ChiknWinnerStatus | QueryServicesError>;
-    playChiknWinner(doPrematureCooldownCheck: boolean): Promise<ChiknWinnerResponse | QueryServicesError | 'hit_daily_limit' | 'on_cooldown' | 'session_expired' | 'unknown_error'>;
-    resetChiknWinner(): Promise<ChiknWinnerStatus | QueryServicesError | 'not_enough_eggs' | 'not_at_limit' | 'unknown_error'>;
+    dispatch(disp: ADispatch): boolean;
+    emit<K extends keyof DispatchParams>(type: K, ...args: DispatchParams[K]): boolean;
+
+    packetHandlers: Record<number, () => void>;
+    processPacket(data: ArrayBuffer): void;
+
+    checkChiknWinner(): Promise<{ ok: true, cw: ChiknWinnerStatus } | APIError>;
+    playChiknWinner(doPrematureCooldownCheck: boolean): Promise<ChiknWinnerResponse | APIError | ChicknWinnerError>;
+    resetChiknWinner(): Promise<{ ok: true, cw: ChiknWinnerStatus } | APIError | ChicknWinnerError>;
+
+    canSee(player: GamePlayer): boolean;
+    getBestTarget(): GamePlayer | null;
 
-    refreshChallenges(): Promise<Challenges[] | QueryServicesError>;
-    claimChallenge(challengeId: number): Promise<{ eggReward: number, updatedChallenges: Challenges[] } | QueryServicesError>;
-    rerollChallenge(challengeId: number): Promise<Challenges[] | QueryServicesError>;
+    refreshChallenges(): Promise<{ ok: true, challenges: Challenges[] } | APIError>;
+    rerollChallenge(challengeId: number): Promise<{ ok: true, challenges: Challenges[] } | APIError | ChallengeRerollError>;
+    claimChallenge(challengeId: number): Promise<{ ok: true, eggReward: number, updatedChallenges: Challenges[] } | APIError>;
 
-    refreshBalance(): Promise<number | QueryServicesError>;
-    redeemCode(code: string): Promise<{ result: string; eggsGiven: number; itemIds: number[]; } | QueryServicesError>;
-    claimURLReward(reward: string): Promise<{ result: string; eggsGiven: number; itemIds: number[]; } | QueryServicesError>;
-    claimSocialReward(rewardTag: string): Promise<{ result: string; eggsGiven: number; itemIds: number[]; } | QueryServicesError>;
-    buyItem(itemId: number): Promise<{ result: string; currentBalance: number; itemId: number; } | QueryServicesError>;
+    refreshBalance(): Promise<{ ok: true, currentBalance: number } | APIError>;
+    redeemCode(code: string): Promise<{ ok: true; eggsGiven: number; itemIds: number[]; } | APIError | RedeemCodeError>;
+    claimURLReward(reward: string): Promise<{ ok: true; eggsGiven: number; itemIds: number[]; } | APIError | ClaimURLError>;
+    claimSocialReward(rewardTag: string): Promise<{ ok: true; eggsGiven: number; itemIds: number[]; } | APIError | ClaimSocialError>;
+    buyItem(itemId: number): Promise<{ ok: true; currentBalance: number; itemId: number; } | APIError | BuyItemError>;
 
     leave(code?: number): void;
     logout(): void;
-    quit(noCleanup?: boolean): void;
+    quit(cleanupLevel?: CleanupLevel): void;
 }
 
 export default Bot;