Classes

A fluent, chainable configurator. You call .reels(5).visibleSymbols(3)... and end with .build(). It exists so every required piece of setup is forced into one place — forget .ticker(app.ticker) and .build() throws before your game boots.

The thing you app.stage.addChild(reelSet). A PixiJS Container that owns every reel, the spin controller, the speed manager, and the win spotlight. All the public methods you'll reach for live here: spin(), setResult(), skip(), destroy().

One vertical column of symbols. A Reel owns the symbols currently on screen, their vertical position, and the "what do I land on" queue. You rarely touch a Reel directly — you drive the whole ReelSet and let it fan out.

The clipped window you see through. Holds the mask so symbols scrolling above or below the visible area are hidden, plus a "promoted" layer where winning symbols get temporarily lifted above the mask so their celebration animation isn't clipped.

The physics of one reel. Adds a Y delta every tick and wraps symbols that fall off the bottom back to the top. When a symbol wraps, it fires a callback that tells the reel "time to swap identity" — that's how a spinning reel eventually shows the target grid.

A tiny queue that holds the symbols a reel must land on, in order. On every wrap, the sequencer hands out the next target. When the queue is empty the reel stops.

The conductor of a spin. Hands every reel its next phase (Start → Spin → optional Anticipation → Stop), coordinates with setResult(), fires the spin:* events, and resolves the promise you awaited on.

Abstract base for a single stage of a reel's spin. Each stage gets onEnter, update (per-tick), and onSkip. Stock phases: StartPhase (wind-up), SpinPhase (steady-state blur), AnticipationPhase (slow-down for tension), StopPhase (decelerate, snap, bounce).

The top-level "what does a spin even mean" strategy. StandardMode runs every reel through the phase machine. CascadeMode replaces whole columns atomically for tumble mechanics. ImmediateMode snaps straight to the result — useful in tests.

Named bundles of timings (spin speed, stop delay, bounce distance, easings). Ship with normal, turbo, superTurbo presets. Switch at runtime with reelSet.setSpeed('turbo'); add your own with addProfile().

One visible cell on a reel. Abstract base class — subclass it to draw whatever you like. Built-in subclasses: SpriteSymbol (plain texture), AnimatedSpriteSymbol (sprite sheet), SpineSymbol (Spine skeleton, optional peer). Implement onActivate, onDeactivate, playWin, stopAnimation, resize for a new kind.

SymbolRegistry records "symbol id X is rendered by class Y with options Z". SymbolFactory is the cache on top — it pools instances so scrolling a 5x3 reel for five seconds allocates zero new symbol objects.

A middleware pipeline that decides which symbol identity fills each new buffer slot when a reel needs another row. Random fill is priority 0, target-frame placement is priority 10. Register your own middleware to implement rules like "no three-in-a-row" or "inject a mystery symbol every 7th spin".

The win-animation primitive. show(positions) dims the losers and runs playWin() on the winners, promoted above the mask. cycle(lines) iterates through multiple lines with a configurable cadence and emits spotlight:start / spotlight:end events.

Typed pub/sub. Event names are colon-namespaced (spin:start, spin:reelLanded, speed:changed). Every exit path from a spin fires an event — wire audio and HUD to events, not to method calls, so skip() and destroy() stay correct without your HUD knowing about them.

A thin wrapper around PIXI.Ticker that tracks every callback it adds and removes them all on destroy(). Nobody in this codebase calls ticker.add() directly — that's how we keep teardown correct.

The cleanup contract. Anything that allocates implements it. reelSet.destroy() cascades through the whole tree — you never have to chase individual pieces yourself.

The headless harness. A manual ticker you step frame by frame, plus a symbol class that draws nothing. With these you can run an entire spin lifecycle in Node, assert on the final grid, and never load PixiJS's renderer.