Interface Client

interface Client {
    client.close: string;
    client.dead: string;
    client.dm: {
        content: string;
        reply: ((message: string) => Promise<DM>);
        user: Classes.Relationship;
    };
    client.error: string;
    client.friended: {
        avatar: number;
        id: string;
        name: string;
    };
    client.game.abort: void;
    client.game.end: {
        duration: number;
        players: {
            id: string;
            lifetime: number;
            name: string;
            points: number;
            raw: Scoreboard;
            won: boolean;
        }[];
        source: "scoreboard";
    } | {
        duration: number;
        players: {
            id: string;
            name: string;
            points: number;
            raw: Leaderboard;
            won: boolean;
        }[];
        source: "leaderboard";
    };
    client.game.over:
        | {
            data: {
                gameoverreason: GameOverReason;
                killer: {
                    gameid: number;
                    type: "sizzle";
                    username: null | string;
                };
            };
            reason: "finish";
        }
        | {
            reason: "abort";
        }
        | {
            reason: "end";
        }
        | {
            reason: "leave";
        };
    client.game.round.end: null | string;
    client.game.round.start: [((cb: Func) => void), Engine, {
        engine: Engine;
        gameid: number;
        name: string;
    }[]];
    client.game.start: {
        ft: number;
        multi: boolean;
        wb: number;
    } & {
        players: {
            id: string;
            name: string;
            points: 0;
        }[];
    };
    client.notify: {
        bgcolor?: `#${string}`;
        buttons?: {
            classes?: string;
            icon?: string;
            label: string;
        }[];
        classes?: string;
        color?: `#${string}`;
        fcolor?: `#${string}`;
        header?: string;
        icon?: string;
        id?: string;
        msg: string;
        subcolor?: `#${string}`;
        subicon?: string;
        timeout?: number;
    };
    client.ready: {
        endpoint: string;
        social: {
            notifications: Notification[];
            presences: {
                [userId: string]: {
                    detail: string;
                    invitable: boolean;
                    status: string;
                };
            };
            relationships: Types.Social.Relationship[];
            total_online: number;
        };
    };
    client.ribbon.error: string;
    client.ribbon.log: string;
    client.ribbon.receive: {
        command: string;
        data?: any;
    };
    client.ribbon.send: {
        command: string;
        data?: any;
    };
    client.ribbon.warn: string;
    client.room.join: Classes.Room;
    client.room.players: Player[];
}

Properties

client.close client.dead client.dm client.error client.friended client.game.abort client.game.end client.game.over client.game.round.end client.game.round.start client.game.start client.notify client.ready client.ribbon.error client.ribbon.log client.ribbon.receive client.ribbon.send client.ribbon.warn client.room.join client.room.players

Properties

client.close

client.close: string

Fires when the websocket closes. Note: the websocket might just be migrating, to check for a fully disconnected client, use client.dead

client.dead

client.dead: string

Fires when the client dies.

client.dm

client.dm: {
    content: string;
    reply: ((message: string) => Promise<DM>);
    user: Classes.Relationship;
}

Fires when a DM (direct message) has been received and AFTER any unknown data has been loaded about the user

client.error

client.error: string

Fires when recieving an "err" notification. Data is the "msg" of the notification

client.friended

client.friended: {
    avatar: number;
    id: string;
    name: string;
}

Fires whenever the client is friended

client.game.abort

client.game.abort: void

Same as game.abort

client.game.end

client.game.end: {
    duration: number;
    players: {
        id: string;
        lifetime: number;
        name: string;
        points: number;
        raw: Scoreboard;
        won: boolean;
    }[];
    source: "scoreboard";
} | {
    duration: number;
    players: {
        id: string;
        name: string;
        points: number;
        raw: Leaderboard;
        won: boolean;
    }[];
    source: "leaderboard";
}

Fires when a game ends. Likely known issue:

See

https://github.com/tetrjs/tetr.js/issues/62

client.game.over

client.game.over:
    | {
        data: {
            gameoverreason: GameOverReason;
            killer: {
                gameid: number;
                type: "sizzle";
                username: null | string;
            };
        };
        reason: "finish";
    }
    | {
        reason: "abort";
    }
    | {
        reason: "end";
    }
    | {
        reason: "leave";
    }

Fires when the client's game ends (topout). Finish = game.replay.end, abort = game.abort, end = game.end or game.advance or game.score

client.game.round.end

client.game.round.end: null | string

Fires when a round is over, sends the user id of the winning player, if there is one.

client.game.round.start

client.game.round.start: [((cb: Func) => void), Engine, {
    engine: Engine;
    gameid: number;
    name: string;
}[]]

Fires when a round starts (this includes 1-round games)

client.game.start

client.game.start: {
    ft: number;
    multi: boolean;
    wb: number;
} & {
    players: {
        id: string;
        name: string;
        points: 0;
    }[];
}

Fires when a game starts

client.notify

client.notify: {
    bgcolor?: `#${string}`;
    buttons?: {
        classes?: string;
        icon?: string;
        label: string;
    }[];
    classes?: string;
    color?: `#${string}`;
    fcolor?: `#${string}`;
    header?: string;
    icon?: string;
    id?: string;
    msg: string;
    subcolor?: `#${string}`;
    subicon?: string;
    timeout?: number;
}

Any notification popup

client.ready

client.ready: {
    endpoint: string;
    social: {
        notifications: Notification[];
        presences: {
            [userId: string]: {
                detail: string;
                invitable: boolean;
                status: string;
            };
        };
        relationships: Types.Social.Relationship[];
        total_online: number;
    };
}

Fires inside Client.create(), will never fire afterwards.

client.ribbon.error

client.ribbon.error: string

Fires whenever Ribbon encounters an error

client.ribbon.log

client.ribbon.log: string

Fires whenever a Ribbon log is outputted

client.ribbon.receive

client.ribbon.receive: {
    command: string;
    data?: any;
}

Fires when a message is recived from the server. Contains the raw data of the server message. Useful for logging, do not use for handling events for functionality. Instead, use client.on(<event>).

client.ribbon.send

client.ribbon.send: {
    command: string;
    data?: any;
}

Fires when a message is sent to the server. Contains the raw data of the server message. Useful for logging.

client.ribbon.warn

client.ribbon.warn: string

Fires whenever a Ribbon warning is outputted

client.room.join

client.room.join: Classes.Room

Fires when the client joins a room

client.room.players

client.room.players: Player[]

Fires whenever the players state changes.

Settings

Member Visibility

On This Page

Properties