Class Client

Properties

api disconnected emit game? off on once ribbon room? rooms social token user utils

Accessors

handling

Methods

destroy reconnect wait wrap connect

Properties

api

api: API

Useful for connecting to the main game API when none of the client helpers have the request you want to send. You can use client.api.get and client.api.post to easily send GET and POST requests.

disconnected

disconnected: boolean = false

Whether the client has been disconnected. If true, the client needs to be reconnected with .reconnect() or destroyed

emit

emit: (<T>(event: T, ...data: Types.Events.out.all[T] extends void
    ? []
    : [Types.Events.out.all[T]]) => void)

Raw ribbon handler for sending messages.

Optionalgame

game?: Classes.Game

The game the client is currently in if it is in a game.

off

off: (<K>(event: K, cb: ((data: Types.Events.in.all[K]) => void)) => EventEmitter<Types.Events.in.all>)

Raw ribbon handler.

on

on: (<K>(event: K, cb: ((data: Types.Events.in.all[K]) => void)) => EventEmitter<Types.Events.in.all>)

Raw ribbon handler.

Example

client.on('social.dm', () => console.log('DM received!'));

once

once: (<K>(event: K, cb: ((data: Types.Events.in.all[K]) => any)) => EventEmitter<Types.Events.in.all>)

Raw ribbon handler. You likely want to use client.wait instead.

ribbon

ribbon: Classes.Ribbon

Raw ribbon client, the backbone of TETR.IO multiplayer. You probably don't want to touch this unless you know what you are doing.

Optionalroom

room?: Classes.Room

The room the client is in (if it is in a room). You can make it non-nullable with client.room!

rooms

rooms: {
    create(type?: "public" | "private"): Promise<Classes.Room>;
    join(id: string): Promise<Classes.Room>;
    list(): Promise<Utils.APITypes.Rooms.Room[]>;
}

social

social: Classes.Social

A helpful manager for all things social on TETR.IO (friends, dms etc.)

token

token: string

The client's token

user

user: ClientUser

User information

utils

utils: ClientUtils

Utils for the client.

Deprecated

  • functionality has been moved to other sections. This may be removed in the future.

Accessors

handling

  • get handling(): Handling

  • The client's current handling.

    Returns Handling

  • set handling(handling): void

  • Change the client's current handling (do not use while in a room)

    Parameters

    Returns void

Methods

destroy

  • destroy(): Promise<void>

  • Clean up the client

    Returns Promise<void>

reconnect

  • reconnect(): Promise<void>

  • Reconnect the client to TETR.IO.

    Returns Promise<void>

    Throws

    if the client is already connected

wait

  • wait<T>(event): Promise<Types.Events.in.all[T]>

  • Wait for an event to occur. Wraps client.once into a typed Promise.

    Type Parameters

    • T extends
          | (keyof Client)
          | (keyof Game)
          | (keyof Ribbon)
          | (keyof Room)
          | (keyof Social)
          | "staff.xrc"

    Parameters

    • event: T

    Returns Promise<Types.Events.in.all[T]>

    the data from the event

    Example

    // wait for a notification (although you probably want to use `client.on` for this instead)
    console.log(await client.wait('social.notification'));

wrap

  • wrap<O, I>(event, data, listen, error?): Promise<Types.Events.in.all[I]>

  • Send a message and then wait for another message. Throws an error if a 'err' message is received before the response message

    Type Parameters

    • O extends
          | (keyof Client)
          | (keyof Social)
          | (keyof Room)
          | (keyof Game)
          | "config.handling"
    • I extends
          | (keyof Client)
          | (keyof Game)
          | (keyof Ribbon)
          | (keyof Room)
          | (keyof Social)
          | "staff.xrc"

    Parameters

    • event: O

      the command of the event to send

    • data: Types.Events.out.all[O]

      the data to send along with the command. For void (no) data, just pass in undefined

    • listen: I

      the event to wait for before resolving.

    • error: (
          | (keyof Client)
          | (keyof Game)
          | (keyof Ribbon)
          | (keyof Room)
          | (keyof Social)
          | "staff.xrc")[] = ...

      a list of custom error events to listen for. Defaults to [client.error].

    Returns Promise<Types.Events.in.all[I]>

    the data sent by the listen event

    Throws

    an error if the error event provided (or client.error) is received from TETR.IO

    Example

    // This is just for example, use `client.room!.chat` instead
    await client.wrap('room.chat', { content: 'Hello', pinned: false }, 'room.chat');

Staticconnect

  • connect(options): Promise<Client>

  • Create a new client

    Parameters

    Returns Promise<Client>

    Example

    const client = await Client.connect({ token: 'your.jwt.token' });

    Example

    const client = await Client.connect({ username: 'halp', password: 'password' });

    Example

    // If playing games, pass in handling
    const client = await Client.connect({
      // ...login info
      handling: {
        arr: 0,
        cancel: false,
        das: 5,
        dcd: 0,
        safelock: false,
        may20g: true,
        sdf: 41
      };
    });

    Example

    // You can pass in a custom user agent
    const client = await Client.connect({
      // ...login info
      userAgent: "v8/001"
    });

Settings

Member Visibility

On This Page

Properties
Accessors
Methods