@vlad-yakovlev/poker/dist/classes/Room.d.ts

Texas Hold'em poker library

import { EventEmitter } from 'eventemitter3';
import { ROUND, RoomData, RoomStorage } from '../types/state.js';
import { Player } from './Player.js';
export type RoomParams<RoomPayload = any, PlayerPayload = any> = {
    storage: RoomStorage<RoomPayload, PlayerPayload>;
    startingBaseBetAmount: number;
};
export type RoomEvents<RoomPayload, PlayerPayload> = {
    /**
     * Emitted when deal starts
     */
    nextDeal: (data: {
        players: Player<PlayerPayload>[];
        dealer: Player<PlayerPayload>;
        smallBlind: Player<PlayerPayload>;
        bigBlind: Player<PlayerPayload>;
    }) => void;
    /**
     * Emitted when deal ends
     */
    dealEnded: (data: {
        tableCards: number[];
        players: {
            player: Player<PlayerPayload>;
            wonAmount: number;
        }[];
    }) => void;
    /**
     * Emitted when player's turn starts
     */
    nextTurn: (data: {
        player: Player<PlayerPayload>;
    }) => void;
    /**
     * Emitted when game ends
     */
    gameEnded: () => void;
    /**
     * Emitted when player folds
     */
    fold: (data: {
        player: Player<PlayerPayload>;
    }) => void;
    /**
     * Emitted when player checks
     */
    check: (data: {
        player: Player<PlayerPayload>;
    }) => void;
    /**
     * Emitted when player calls
     */
    call: (data: {
        player: Player<PlayerPayload>;
    }) => void;
    /**
     * Emitted when player raises
     */
    raise: (data: {
        player: Player<PlayerPayload>;
        amount: number;
    }) => void;
    /**
     * Emitted when player goes all-in
     */
    allIn: (data: {
        player: Player<PlayerPayload>;
    }) => void;
};
export declare class Room<RoomPayload = any, PlayerPayload = any> extends EventEmitter<RoomEvents<RoomPayload, PlayerPayload>> {
    storage: RoomStorage;
    startingBaseBetAmount: number;
    id: string;
    cards: number[];
    round: ROUND;
    dealsCount: number;
    dealerIndex: number;
    currentPlayerIndex: number;
    players: Player<PlayerPayload>[];
    payload: RoomPayload;
    constructor(params: RoomParams, roomData: RoomData<RoomPayload, PlayerPayload>);
    /**
     * Create a new room
     */
    static create<RoomPayload = any, PlayerPayload = any>(id: string, params: RoomParams<RoomPayload, PlayerPayload>, payload: RoomPayload): Promise<Room<RoomPayload, PlayerPayload>>;
    /**
     * Load room from storage
     */
    static load<RoomPayload = any, PlayerPayload = any>(id: string, params: RoomParams<RoomPayload, PlayerPayload>): Promise<Room<RoomPayload, PlayerPayload> | undefined>;
    save(): Promise<void>;
    get potAmount(): number;
    /**
     * Bet amount for current deal
     */
    get baseBetAmount(): number;
    /**
     * Amount that each player should have bet in order to continue playing
     */
    get requiredBetAmount(): number;
    get currentPlayer(): Player<PlayerPayload>;
    /**
     * Add player to room
     */
    addPlayer(id: string, balance: number, payload: PlayerPayload): Promise<void>;
    /**
     * Deal cards. Used to start a game
     */
    dealCards(): Promise<void>;
    /**
     * End game. Used to stop a game early
     */
    endGame(): Promise<void>;
    /**
     * Perform a fold action for a given player
     */
    fold(playerId: string): Promise<void>;
    /**
     * Perform a check action for a given player
     */
    check(playerId: string): Promise<void>;
    /**
     * Perform a call action for a given player
     */
    call(playerId: string): Promise<void>;
    /**
     * Perform a raise action for a given player with a given amount
     */
    raise(playerId: string, amount: number): Promise<void>;
    /**
     * Perform an all-in action for a given player
     */
    allIn(playerId: string): Promise<void>;
    nextTurn(): Promise<void>;
    endDeal(): Promise<void>;
    getNextPlayerIndex(index: number): number;
    getNextRound(round: ROUND): ROUND;
}