import { Graphics, Ticker } from 'pixi.js'; import { SpeedProfile, SymbolData } from '../config/types.js'; import { SymbolRegistry } from '../symbols/SymbolRegistry.js'; import { HoldAndWinBoard } from './HoldAndWinBoard.js'; import { Direction, Orientation } from '../core/ReelAxis.js'; import { HwCellSizeOptions } from './HwTypes.js'; /** * Fluent builder for {@link HoldAndWinBoard}. * * A Hold & Win board is a W×H grid of cells that spin **independently** - the * mechanic's atomic unit is the cell, the engine's is the column, so each cell * is its own 1×1 ReelSet. This builder wires that grid plus the round * choreography; everything value-shaped stays in the game layer (see * {@link HoldAndWinBoard}). * * `TData` types the opaque payload carried on each coin's `data`. */ export declare class HoldAndWinBuilder { private _cols; private _rows; private _cell; private _gap; private _emptyId; private _respins; private _configurator; private _weights; private _symbolData; private _baseProfile; private _stagger; private _anticipateWhen; private _chrome; private _orientation; private _direction; private _ticker; private _rng; grid(cols: number, rows: number): this; cellSize(size: number, opts?: HwCellSizeOptions): this; /** * Register coin symbol classes, exactly like `ReelSetBuilder.symbols`. Applied * to every cell. An {@link EmptySymbol} is auto-registered under {@link emptyId} * unless the configurator registers one itself. */ symbols(configurator: (registry: SymbolRegistry) => void): this; /** Strip weights during the spin (how often coins flash past empties). */ weights(weights: Record): this; /** Symbol id a cell shows when it holds no coin. Default `'empty'`. */ emptyId(id: string): this; /** * Per-symbol engine overrides, exactly like `ReelSetBuilder.symbolData`. The * headline use is `{ unmask: true }` for coins whose lock/reveal animations * expand past the cell. Safe only for server-placed ids (weight 0): unmasked * strip symbols mis-track vertically while the reel spins. */ symbolData(overrides: Record>): this; /** Respins granted on enter and restored on every hit. Default 3. */ respins(count: number): this; /** Base spin feel for every cell. Default: NORMAL with a 320ms floor. */ speedProfile(profile: SpeedProfile): this; /** * Extra milliseconds of spin per cell on top of the base minimum spin time. * Default `(reel + cell) * 70` - the diagonal landing wave. Return 0 for * simultaneous landings. */ stagger(fn: (reel: number, cell: number) => number): this; /** * When the predicate returns true for a wave, **every** spinning cell uses a * drawn-out tension profile - the "one cell left for Grand" moment. Evaluated * once per wave for the whole board (not per cell), against the pre-wave state. */ anticipateWhen(fn: (state: { locked: number; capacity: number; respinsLeft: number; }) => boolean): this; /** Per-cell background, drawn behind each mini reel. */ cellChrome(draw: (g: Graphics, size: number) => void): this; /** * Which way each cell's strip travels while it spins. Cells are 1x1 reel * sets, so this picks the edge a coin scrolls in from; the board's own * `cols` x `rows` layout is unaffected. Defaults to vertical / forward. */ axis(orientation: Orientation, direction?: Direction): this; ticker(ticker: Ticker): this; /** Injected RNG for the spin strips (deterministic demos / tests). */ rng(fn: () => number): this; build(): HoldAndWinBoard; } //# sourceMappingURL=HoldAndWinBuilder.d.ts.map