Class Bot

me

• get me(): Player

  The current bot's player, if it's initialized. Be careful with this and read the warning in Game.me

  Returns Player

players

• get players(): (Player | undefined)[]

  The players, refers to the players field in any game class (Game.players)

  Returns (Player | undefined)[]

constructor

• new Bot(params?: Partial<BotParams>): Bot

  Creates a bot with the parameters. None of them are required, some more recommended than others!

  Parameters

  • params: Partial<BotParams> = {}

    The parameters for the bot

  Returns Bot

checkGameCode

• checkGameCode(
      code: string,
  ): Promise<
      | CheckCodeResult
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameFindError,
      >,
  >

  Checks if a game code exists and returns basic information about it

  Parameters

  • code: string

    The game code to check

  Returns Promise<
      | CheckCodeResult
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameFindError,
      >,
  >

createAccount

• createAccount(email: string, pass: string): Promise<LoginResponse>

  Creates an account with the given email and password and adds it to the current bot

  Parameters

  • email: string

    The email

  • pass: string

    The password

  Returns Promise<LoginResponse>

  The result of the login attempt, including the account if it succeeded

createMatchmaker

• createMatchmaker(): Promise<
      { ok: true; regionList: Region[] }
      | ErrorEnum<MatchmakerError>,
  >

  Connects to the matchmaker for the first time and establishes automatic reconnection

  Returns Promise<{ ok: true; regionList: Region[] } | ErrorEnum<MatchmakerError>>

  The result of the connection attempt, including the region list if it succeeded

createPrivateGame

• createPrivateGame(
      region: string,
      mode: string | GameMode,
      map: string,
  ): Promise<
      | GameFindResult
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameFindError,
      >,
  >

  Creates a private game with the given region, mode, and map. This does NOT join the game.

  Parameters

  • region: string

    The name of the region to create the game in; must be one from Bot.regionList (e.g. 'useast')

  • mode: string | GameMode

    The mode to create, either as a string (e.g. 'ffa') or as a GameMode (e.g. GameMode.FFA)

  • map: string

    The name of the map to create on (e.g. 'warehouse'); must be one from Maps

  Returns Promise<
      | GameFindResult
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameFindError,
      >,
  >

  The result of the create attempt, including the game info if it succeeded

dispatch

• dispatch<D extends ADispatch>(dispatch: D): boolean

  Dispatches

  Type Parameters

  • D extends ADispatch

  Parameters

  • dispatch: D

    The dispatch to send out

  Returns boolean

  Whether the dispatch's initial parameter validation check succeeded; it does NOT contain anything about the results of the constant check that runs in the background

dispose

• dispose(): void

  Disposes a bot instance by clearing timeouts, leaving games, and disconnecting from the matchmaker

  Returns void

emit

• emit<
      E extends
          | "pause"
          | "chat"
          | "gameOptions"
          | "banPlayer"
          | "bootPlayer"
          | "melee"
          | "reload"
          | "reportPlayer"
          | "saveLoadout"
          | "swapWeapon"
          | "switchTeam"
          | "throwGrenade"
          | "fire"
          | "goToAmmo"
          | "goToCoop"
          | "goToGrenade"
          | "goToPlayer"
          | "goToSpatula"
          | "lookAt"
          | "lookAtPos"
          | "move"
          | "resetGame"
          | "spawn",
  >(
      eventName: E,
      ...args: DispatchParams[E],
  ): void

  The easier way to dispatch something.

  Type Parameters

  • E extends
        | "pause"
        | "chat"
        | "gameOptions"
        | "banPlayer"
        | "bootPlayer"
        | "melee"
        | "reload"
        | "reportPlayer"
        | "saveLoadout"
        | "swapWeapon"
        | "switchTeam"
        | "throwGrenade"
        | "fire"
        | "goToAmmo"
        | "goToCoop"
        | "goToGrenade"
        | "goToPlayer"
        | "goToSpatula"
        | "lookAt"
        | "lookAtPos"
        | "move"
        | "resetGame"
        | "spawn"

  Parameters

  • eventName: E

    The event name. You can see a list in the "properties" of DispatchIndex

  • ...args: DispatchParams[E]

    The arguments you can pass. You can find the file link in DispatchIndex and then look at the constructor of the dispatch class to see what arguments it takes.

  Returns void

findPublicGame

• findPublicGame(
      region: string,
      mode: string | GameMode,
  ): Promise<
      | GameFindResult
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameFindError,
      >,
  >

  Finds a public game with the given region and mode. This does NOT join the game.

  Parameters

  • region: string

    The name of the region to find the game in; must be one from Bot.regionList (e.g. 'useast')

  • mode: string | GameMode

    The mode to find, either as a string (e.g. 'ffa') or as a GameMode (e.g. GameMode.FFA)

  Returns Promise<
      | GameFindResult
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameFindError,
      >,
  >

  The result of the find attempt, including the game info if it succeeded

hasHook

• hasHook<K extends keyof BotEvents>(event: K): boolean

  Checks if a hook is attached to the bot

  Type Parameters

  • K extends keyof BotEvents

  Parameters

  • event: K

    The name of the event

  Returns boolean

  Whether any hook is attached for that event

inGame

• inGame(): this is BotWithGame

  Ensures the bot is in game; best used with Typescript

  Returns this is BotWithGame

initSession

• initSession(): Promise<
      | { ok: true }
      | ErrorEnum<
          FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError,
      >,
  >

  Initializes the session for the by logging in (if not already) and connecting to the matchmaker (if not already). This is required before finding, creating, or joining a game and is called automatically if you fail to do so

  Returns Promise<
      | { ok: true }
      | ErrorEnum<
          FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError,
      >,
  >

  Whether the initialization succeeded or the error that caused it to fail

join

• join(
      name: string,
      data: string | GameFindResult,
      joinOptions?: JoinOptions,
  ): Promise<
      | { ok: true }
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameJoinError,
      >,
  >

  Joins a game

  Parameters

  • name: string

    The name to join the game with

  • data: string | GameFindResult

    Either the game ID (the string at the end of the game URL, e.g. 'abc123' from https://shellshock.io/game/abc123) or the full game object returned from the matchmaker (either from Bot.findPublicGame or Bot.createPrivateGame)

  • joinOptions: JoinOptions = {}

    Some extra options for joining documented in JoinOptions

  Returns Promise<
      | { ok: true }
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | LoginError
          | MatchmakerError
          | GameJoinError,
      >,
  >

  The result of the join attempt, including the game info if it succeeded

login

• login(email: string, pass: string): Promise<LoginResponse>

  Logs into an existing account with the given email and password and adds it to the current bot

  Parameters

  • email: string

    The email

  • pass: string

    The password

  Returns Promise<LoginResponse>

  The result of the login attempt, including the account if it succeeded

loginAnonymously

• loginAnonymously(): Promise<LoginResponse>

  Logs in anonymously, which is the recommended way to do a quick login without needing to create an account. You can save these if absolutely needed by saving the Account.firebase's refreshToken and using Bot.loginWithRefreshToken

  Returns Promise<LoginResponse>

  The result of the login attempt, including the account if it succeeded

loginWithGoogle

• loginWithGoogle(requiredEmail?: string): Promise<LoginResponse>

  Logs in using Google (works only on Node and non-headless environments)

  Parameters

  • OptionalrequiredEmail: string

  Returns Promise<LoginResponse>

  The result of the login attempt, including the account if it succeeded

loginWithRefreshToken

• loginWithRefreshToken(refreshToken: string): Promise<LoginResponse>

  Logs in with a refresh token from a previous session; see the link below to copy it from the game

  Parameters

  • refreshToken: string

    The refresh token from the session

  Returns Promise<LoginResponse>

  The result of the login attempt, including the account if it succeeded

  See

  https://gist.github.com/VillainsRule/c159bf64c450c0f0144dfd7c6c300560

off

• off<K extends keyof BotEvents>(
      eventName: K,
      callback?: (...args: BotEvents[K]) => void,
  ): void

  Removes a specific callback hook for a specific event

  Type Parameters

  • K extends keyof BotEvents

  Parameters

  • eventName: K

    The name of the event to stop listening for

  • Optionalcallback: (...args: BotEvents[K]) => void

    The specific callback to remove; if not provided, all hooks for the event will be removed

  Returns void

on

• on<K extends keyof BotEvents>(
      eventName: K,
      callback: (...args: BotEvents[K]) => void,
  ): void

  Registers a callback for a specific event. All events are viewable at BotEvents

  Type Parameters

  • K extends keyof BotEvents

  Parameters

  • eventName: K

    The name of the event to listen for

  • callback: (...args: BotEvents[K]) => void

    The callback to run when the event is emitted, with the parameters for that event as arguments

  Returns void

onAny

• onAny(
      callback: <K extends keyof BotEvents>(
          event: K,
          ...args: BotEvents[K],
      ) => void,
  ): void

  Regisers a global callback for any hooks. This is incredibly resource-intensive and shouldn't be used aside from development (things like finding hook names), as it means that some hooks (such as BotEvents.packet) run intensive data computations that aren't normally performed unless needed.

  Parameters

  • callback: <K extends keyof BotEvents>(event: K, ...args: BotEvents[K]) => void

    The callback to run on any event. The first parameter is the event name and the rest are the parameters for that event

  Returns void

Optionalaccount

firebase

Optionalgame

instance

Optionalmatchmaker

matchmakerListeners

packetHandlers

protocol

proxy

regionList

renewSession