@hiddentao/clockwork-engine/dist/GameCanvas.d.ts

A TypeScript/PIXI.js game engine for deterministic, replayable games with built-in rendering

import { EventEmitter } from "./EventEmitter";
import type { GameEngine } from "./GameEngine";
import { Vector2D } from "./geometry/Vector2D";
import type { AudioLayer, InputEvent, InputLayer, NodeId, PlatformLayer, RenderingLayer } from "./platform";
import { DisplayNode } from "./platform/DisplayNode";
import type { AbstractRenderer } from "./rendering/AbstractRenderer";
import { GameState } from "./types";
/**
 * Events emitted by the game canvas for user interactions and viewport changes.
 */
export declare enum GameCanvasEvent {
    POINTER_MOVE = "pointerMove",
    POINTER_CLICK = "pointerClick",
    VIEWPORT_MOVED = "viewportMoved",
    VIEWPORT_ZOOMED = "viewportZoomed"
}
/**
 * Type definitions for canvas event callbacks.
 */
export interface GameCanvasEventMap extends Record<string, (...args: any[]) => void> {
    [GameCanvasEvent.POINTER_MOVE]: (worldPosition: Vector2D) => void;
    [GameCanvasEvent.POINTER_CLICK]: (worldPosition: Vector2D) => void;
    [GameCanvasEvent.VIEWPORT_MOVED]: (center: Vector2D) => void;
    [GameCanvasEvent.VIEWPORT_ZOOMED]: (zoom: number) => void;
}
/**
 * Configuration options for initializing a game canvas.
 */
export interface GameCanvasOptions {
    width: number;
    height: number;
    worldWidth: number;
    worldHeight: number;
    backgroundColor?: number;
    resolution?: number;
    antialias?: boolean;
    minZoom?: number;
    maxZoom?: number;
    initialZoom?: number;
    clampBuffer?: number;
    enableDrag?: boolean;
    enablePinch?: boolean;
    enableWheel?: boolean;
    enableDecelerate?: boolean;
    scaleWithResize?: boolean;
    preference?: "webgl" | "webgpu";
}
/**
 * Abstract base class for creating interactive game canvases using platform abstraction.
 * Platform-agnostic: works with Web (PIXI.js) or Memory (headless) platforms.
 */
export declare abstract class GameCanvas extends EventEmitter<GameCanvasEventMap> {
    protected options: GameCanvasOptions;
    protected rendering: RenderingLayer;
    protected audio: AudioLayer;
    protected input: InputLayer;
    protected viewportNode: DisplayNode;
    protected gameNode: DisplayNode;
    protected hudNode: DisplayNode;
    protected viewportNodeId: NodeId;
    protected gameEngine: GameEngine | null;
    protected readonly initialWidth: number;
    protected readonly initialHeight: number;
    protected renderers: Map<string, AbstractRenderer<any>>;
    protected updateCallback: ((deltaTicks: number) => void) | null;
    protected static readonly DEFAULT_OPTIONS: Partial<GameCanvasOptions>;
    constructor(options: GameCanvasOptions, platform: PlatformLayer);
    /**
     * Initialize the canvas - platform-agnostic (no container parameter).
     */
    initialize(): Promise<void>;
    /**
     * Set up input event listeners via platform.input
     */
    protected setupEventListeners(): void;
    /**
     * Start the update loop using platform.rendering.onTick()
     */
    protected setupUpdateLoop(): void;
    protected handlePointerMove: (event: InputEvent) => void;
    protected handleClick: (event: InputEvent) => void;
    /**
     * Register a renderer
     */
    protected registerRenderer(name: string, renderer: AbstractRenderer<any>): void;
    /**
     * Unregister a renderer
     */
    protected unregisterRenderer(name: string): void;
    /**
     * Set up game-specific renderers
     */
    protected abstract setupRenderers(): void;
    /**
     * Clear all renderers
     */
    protected clearRenderers(): void;
    /**
     * Get the game engine
     */
    getGameEngine(): GameEngine | null;
    /**
     * Set the game engine
     */
    setGameEngine(gameEngine: GameEngine | null): void;
    /**
     * Render frame - implemented by subclasses
     */
    protected abstract render(deltaTicks: number): void;
    /**
     * Update game state and render
     */
    protected update(deltaTicks: number): void;
    protected handleGameStateChange: (newState: GameState, _oldState: GameState) => void;
    /**
     * Move viewport to position
     */
    moveViewportTo(x: number, y: number, _animate?: boolean): void;
    /**
     * Set viewport zoom
     */
    setZoom(zoom: number, _animate?: boolean): void;
    /**
     * Get viewport center
     */
    getViewportCenter(): Vector2D;
    /**
     * Get viewport zoom
     */
    getZoom(): number;
    /**
     * Convert world coordinates to screen coordinates
     */
    worldToScreen(worldPos: Vector2D): Vector2D;
    /**
     * Convert screen coordinates to world coordinates
     */
    screenToWorld(screenPos: Vector2D): Vector2D;
    /**
     * Resize canvas
     */
    resize(width: number, height: number): void;
    /**
     * Destroy canvas
     */
    destroy(): void;
    /**
     * Get the game node (DisplayNode)
     */
    getGameNode(): DisplayNode;
    /**
     * Get the HUD node (DisplayNode)
     */
    getHudNode(): DisplayNode;
    /**
     * Get canvas options
     */
    getOptions(): GameCanvasOptions;
}
//# sourceMappingURL=GameCanvas.d.ts.map