Class Room

Properties

allowAnonymous allowBots allowChat allowQueued allowUnranked auto autoStart bgmList chats constants creator forceRequireXPToChat gamebgm gameStart id lobbybg lobbybgm match name name_safe options owner players public replay state type useBestRankAsLimit userLimit userRankLimit

Accessors

isHost self

Methods

abort ban chat clearChat destroy kick leave move setID spectate start switch takeHost transferHost unban unspectate update usePreset

Properties

allowAnonymous

allowAnonymous: boolean

Whether or not the room allows anonymous users

allowBots

allowBots: boolean

Whether or not the room allows bots

allowChat

allowChat: boolean

Whether or not chatting is allowed

allowQueued

allowQueued: boolean

Whether or not the room allows users queued for TL

allowUnranked

allowUnranked: boolean

Whether or not the room allows unranked users

auto

auto: Autostart

The autostart state of the room

autoStart

autoStart: number

The autostart config of the room

bgmList

bgmList: unknown[]

The list of available BGMs

chats

chats: {
    content: string;
    content_safe?: string;
    pinned?: boolean;
    suppressable?: boolean;
    system: boolean;
    user: {
        _id: null | string;
        role?: Role;
        supporter?: boolean;
        supporter_tier?: number;
        username: string;
    };
}[] = []

Room chat history

constants

constants: unknown

The room constants

creator

creator: string

UID of the room creator (this person can reclaim host)

forceRequireXPToChat

forceRequireXPToChat: boolean

Whether or not to force require XP to chat

gamebgm

gamebgm: string

The background music of the game

gameStart

gameStart: null | number = null

The time the last game started

id

id: string

the ID of the room

lobbybg

lobbybg: null | string

The background image of the lobby

lobbybgm

lobbybgm: string

The background music of the lobby

match

match: Match

The match config for the room

name

name: string

Name of the room

name_safe

name_safe: string

Safe Name of the room

options

options: Partial<Options>

The room config. Note that TETR.IO does not send all options when joining a room, and some properties may not be present (hence the Partial)

owner

owner: string

UID of the host

players

players: Types.Room.Player[]

The players in the room

public

public: boolean

Whether or not the room is public

replay

replay: null | ReplayManager = null

The replay data for the last played game

state

state: Types.Room.State

The current state of the room (ingame | lobby)

type

type

The type of the room

useBestRankAsLimit

useBestRankAsLimit: boolean

Whether or not to use best rank as limit

userLimit

userLimit: number

The maxiumum number of players that can play in the room (override by moving as host)

userRankLimit

userRankLimit: Rank

The user rank limit to play in the room

Accessors

isHost

  • get isHost(): boolean

  • Whether or not the client is the host

    Returns boolean

self

Methods

abort

  • abort(): Promise<void>

  • Abort the game

    Returns Promise<void>

ban

  • ban(id): Promise<string>

  • Ban a user from the room (if host) Uses room.kick under the hood, the same way TETR.IO does

    Parameters

    • id: string

      id of user to ban

    Returns Promise<string>

    Example

    await client.room!.ban('646f633d276f42a80ba44304');

chat

  • chat(message, pinned?): Promise<{
        content: string;
        content_safe?: string;
        pinned?: boolean;
        suppressable?: boolean;
        system: boolean;
        user: {
            _id: null | string;
            role?: Role;
            supporter?: boolean;
            supporter_tier?: number;
            username: string;
        };
    }>

  • Send a message to the room's chat. The pinned parameter is the same as using the /announce command in TETR.IO The pinned parameter being true will result in an error if the client is not host.

    Parameters

    • message: string
    • pinned: boolean = false

    Returns Promise<{
        content: string;
        content_safe?: string;
        pinned?: boolean;
        suppressable?: boolean;
        system: boolean;
        user: {
            _id: null | string;
            role?: Role;
            supporter?: boolean;
            supporter_tier?: number;
            username: string;
        };
    }>

    Example

    await client.room!.chat('hi!');

    Example

    await client.room!.chat('Important info:', true);

clearChat

  • clearChat(): Promise<void>

  • Clears the chat

    Returns Promise<void>

destroy

  • destroy(): void

  • For internal use only. Use room.leave() instead.

    Returns void

kick

  • kick(id, duration?): Promise<string>

  • Kick a user from the room for a specified duration (if host)

    Parameters

    • id: string

      id of user to kick

    • duration: number = 900

      duration to kick the user, in seconds

    Returns Promise<string>

    Example

    await client.room!.kick('646f633d276f42a80ba44304', 100);

leave

  • leave(): Promise<void>

  • Leave the current room

    Returns Promise<void>

    Example

    await client.room!.leave();

move

  • move(uid, bracket): Promise<undefined | {
        bracket: Bracket;
        uid: string;
    }>

  • Move someone's bracket

    Parameters

    • uid: string
    • bracket: "player" | "spectator"

    Returns Promise<undefined | {
        bracket: Bracket;
        uid: string;
    }>

    Example

    await client.room!.move('646f633d276f42a80ba44304', 'spectator');

setID

  • setID(id): Promise<{
        allowAnonymous: boolean;
        allowBots: boolean;
        allowChat?: boolean;
        allowQueued: boolean;
        allowUnranked: boolean;
        auto: Autostart;
        autoStart: number;
        bgmList: unknown[];
        constants: unknown;
        creator: string;
        forceRequireXPToChat: boolean;
        gamebgm: string;
        id: string;
        info: Record<string, unknown>;
        lobbybg: null | string;
        lobbybgm: string;
        match: Match;
        name: string;
        name_safe?: string;
        options: Partial<Options>;
        owner: string;
        players: Types.Room.Player[];
        public: boolean;
        state: Types.Room.State;
        topic: Record<string, unknown>;
        type: "custom";
        useBestRankAsLimit: boolean;
        userLimit: number;
        userRankLimit: Rank;
    }>

  • Sets the room id (only works for supporter accounts)

    Parameters

    • id: string

    Returns Promise<{
        allowAnonymous: boolean;
        allowBots: boolean;
        allowChat?: boolean;
        allowQueued: boolean;
        allowUnranked: boolean;
        auto: Autostart;
        autoStart: number;
        bgmList: unknown[];
        constants: unknown;
        creator: string;
        forceRequireXPToChat: boolean;
        gamebgm: string;
        id: string;
        info: Record<string, unknown>;
        lobbybg: null | string;
        lobbybgm: string;
        match: Match;
        name: string;
        name_safe?: string;
        options: Partial<Options>;
        owner: string;
        players: Types.Room.Player[];
        public: boolean;
        state: Types.Room.State;
        topic: Record<string, unknown>;
        type: "custom";
        useBestRankAsLimit: boolean;
        userLimit: number;
        userRankLimit: Rank;
    }>

    Example

    client.room!.setID('TEST');

spectate

  • spectate(): Promise<void | SpectateData>

  • Start spectating a game.

    Returns Promise<void | SpectateData>

    The current state of the game being spectated.

    Example

    const data = await client.room!.spectate();

start

  • start(): Promise<Ready>

  • Start the game

    Returns Promise<Ready>

switch

  • switch(bracket): Promise<undefined | {
        bracket: Bracket;
        uid: string;
    }>

  • Switch bracket

    Parameters

    • bracket: "player" | "spectator"

    Returns Promise<undefined | {
        bracket: Bracket;
        uid: string;
    }>

    Example

    await client.room!.switch('player');

takeHost

  • takeHost(): Promise<string>

  • Take host if you created the room

    Returns Promise<string>

transferHost

  • transferHost(player): Promise<string>

  • Give the host to someone else

    Parameters

    • player: string

    Returns Promise<string>

    Example

    await client.room!.transferHost(await client.social.resolve('halp'));

unban

  • unban(username): void

  • Unban a user from the room

    Parameters

    • username: string

    Returns void

    Example

    client.room!.unban('halp');

unspectate

  • unspectate(): Promise<void>

  • Stop spectating the current game.

    Returns Promise<void>

    Example

    await client.room!.unspectate();

update

  • update(...options): Promise<{
        allowAnonymous: boolean;
        allowBots: boolean;
        allowChat?: boolean;
        allowQueued: boolean;
        allowUnranked: boolean;
        auto: Autostart;
        autoStart: number;
        bgmList: unknown[];
        constants: unknown;
        creator: string;
        forceRequireXPToChat: boolean;
        gamebgm: string;
        id: string;
        info: Record<string, unknown>;
        lobbybg: null | string;
        lobbybgm: string;
        match: Match;
        name: string;
        name_safe?: string;
        options: Partial<Options>;
        owner: string;
        players: Types.Room.Player[];
        public: boolean;
        state: Types.Room.State;
        topic: Record<string, unknown>;
        type: "custom";
        useBestRankAsLimit: boolean;
        userLimit: number;
        userRankLimit: Rank;
    }>

  • Update the room's config, similar to using the /set command in tetr.io await client.room!.update({ index: 'name', value: 'test room'});

    Parameters

    Returns Promise<{
        allowAnonymous: boolean;
        allowBots: boolean;
        allowChat?: boolean;
        allowQueued: boolean;
        allowUnranked: boolean;
        auto: Autostart;
        autoStart: number;
        bgmList: unknown[];
        constants: unknown;
        creator: string;
        forceRequireXPToChat: boolean;
        gamebgm: string;
        id: string;
        info: Record<string, unknown>;
        lobbybg: null | string;
        lobbybgm: string;
        match: Match;
        name: string;
        name_safe?: string;
        options: Partial<Options>;
        owner: string;
        players: Types.Room.Player[];
        public: boolean;
        state: Types.Room.State;
        topic: Record<string, unknown>;
        type: "custom";
        useBestRankAsLimit: boolean;
        userLimit: number;
        userRankLimit: Rank;
    }>

usePreset

  • usePreset(preset): Promise<{
        allowAnonymous: boolean;
        allowBots: boolean;
        allowChat?: boolean;
        allowQueued: boolean;
        allowUnranked: boolean;
        auto: Autostart;
        autoStart: number;
        bgmList: unknown[];
        constants: unknown;
        creator: string;
        forceRequireXPToChat: boolean;
        gamebgm: string;
        id: string;
        info: Record<string, unknown>;
        lobbybg: null | string;
        lobbybgm: string;
        match: Match;
        name: string;
        name_safe?: string;
        options: Partial<Options>;
        owner: string;
        players: Types.Room.Player[];
        public: boolean;
        state: Types.Room.State;
        topic: Record<string, unknown>;
        type: "custom";
        useBestRankAsLimit: boolean;
        userLimit: number;
        userRankLimit: Rank;
    }>

  • Sets the room's preset

    Parameters

    Returns Promise<{
        allowAnonymous: boolean;
        allowBots: boolean;
        allowChat?: boolean;
        allowQueued: boolean;
        allowUnranked: boolean;
        auto: Autostart;
        autoStart: number;
        bgmList: unknown[];
        constants: unknown;
        creator: string;
        forceRequireXPToChat: boolean;
        gamebgm: string;
        id: string;
        info: Record<string, unknown>;
        lobbybg: null | string;
        lobbybgm: string;
        match: Match;
        name: string;
        name_safe?: string;
        options: Partial<Options>;
        owner: string;
        players: Types.Room.Player[];
        public: boolean;
        state: Types.Room.State;
        topic: Record<string, unknown>;
        type: "custom";
        useBestRankAsLimit: boolean;
        userLimit: number;
        userRankLimit: Rank;
    }>

    Example

    await client.room!.usePreset('tetra league (season 1)');

Settings

Member Visibility

On This Page

Properties
Accessors
Methods