Class Bot

me

• get me(): Player

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

  Returns Player

players

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

  The players, refers to the players field in any game class (BaseGameMode.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

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
          | AccountBanned
          | 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
          | AccountBanned
          | MatchmakerError
          | GameFindError,
      >,
  >

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

dispatch

• dispatch(
      dispatch:
          | LookAtPosDispatch
          | MovementDispatch
          | BanPlayerDispatch
          | BootPlayerDispatch
          | ChatDispatch
          | FireDispatch
          | GameOptionsDispatch
          | GoToAmmoDispatch
          | GoToCoopDispatch
          | GoToGrenadeDispatch
          | GoToPlayerDispatch
          | GoToSpatulaDispatch
          | LookAtDispatch
          | MeleeDispatch
          | PauseDispatch
          | ReloadDispatch
          | ReportPlayerDispatch
          | ResetGameDispatch
          | SaveLoadoutDispatch
          | SpawnDispatch
          | SwapWeaponDispatch
          | SwitchTeamDispatch
          | ThrowGrenadeDispatch,
  ): boolean

  Dispatches

  Parameters

  • dispatch:
        | LookAtPosDispatch
        | MovementDispatch
        | BanPlayerDispatch
        | BootPlayerDispatch
        | ChatDispatch
        | FireDispatch
        | GameOptionsDispatch
        | GoToAmmoDispatch
        | GoToCoopDispatch
        | GoToGrenadeDispatch
        | GoToPlayerDispatch
        | GoToSpatulaDispatch
        | LookAtDispatch
        | MeleeDispatch
        | PauseDispatch
        | ReloadDispatch
        | ReportPlayerDispatch
        | ResetGameDispatch
        | SaveLoadoutDispatch
        | SpawnDispatch
        | SwapWeaponDispatch
        | SwitchTeamDispatch
        | ThrowGrenadeDispatch

    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"
          | "banPlayer"
          | "bootPlayer"
          | "fire"
          | "gameOptions"
          | "goToAmmo"
          | "goToCoop"
          | "goToGrenade"
          | "goToPlayer"
          | "goToSpatula"
          | "lookAt"
          | "lookAtPos"
          | "melee"
          | "move"
          | "reload"
          | "reportPlayer"
          | "resetGame"
          | "saveLoadout"
          | "spawn"
          | "swapWeapon"
          | "switchTeam"
          | "throwGrenade",
  >(
      eventName: E,
      ...args: DispatchParams[E],
  ): void

  The easier way to dispatch something.

  Type Parameters

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

  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
          | AccountBanned
          | 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
          | AccountBanned
          | MatchmakerError
          | GameFindError,
      >,
  >

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

initSession

• initSession(): Promise<
      | { ok: true }
      | ErrorEnum<
          FirebaseError
          | QueryServicesError
          | AccountBanned
          | 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
          | AccountBanned
          | MatchmakerError,
      >,
  >

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

join

• join(
      name: string,
      data: string | GameFindResult,
      defaultWeapon?: GunIds,
  ): Promise<
      | { ok: true }
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | AccountBanned
          | 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)

  • OptionaldefaultWeapon: GunIds

    The default weapon to use when joining the game; this can be changed later with a packet or a dispatch (defaults to egg-k)

  Returns Promise<
      | { ok: true }
      | ErrorEnum<
          | FirebaseError
          | QueryServicesError
          | AccountBanned
          | 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

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

  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

Optionalmatchmaker

matchmakerListeners

packetHandlers

regionList