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

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

import { EventEmitter } from "./EventEmitter";
import { GameEventManager } from "./GameEventManager";
import type { GameEngineInterface, GameObject } from "./GameObject";
import { GameObjectGroup } from "./GameObjectGroup";
import type { GameRecorder } from "./GameRecorder";
import type { Loader } from "./Loader";
import { PRNG } from "./PRNG";
import { Timer } from "./Timer";
import { AssetLoader } from "./assets/AssetLoader";
import { CollisionGrid } from "./geometry";
import type { PlatformLayer } from "./platform";
import { type GameConfig, GameState } from "./types";
export declare enum GameEngineEventType {
    STATE_CHANGE = "stateChange"
}
export interface GameEngineEvents extends Record<string, (...args: any[]) => void> {
    [GameEngineEventType.STATE_CHANGE]: (newState: GameState, oldState: GameState) => void;
}
export interface GameEngineOptions {
    loader: Loader;
    platform: PlatformLayer;
    assetLoader?: AssetLoader;
}
export declare abstract class GameEngine extends EventEmitter<GameEngineEvents> implements GameEngineInterface {
    protected gameObjectGroups: Map<string, GameObjectGroup>;
    protected totalTicks: number;
    protected state: GameState;
    protected seed: string;
    protected gameConfig: GameConfig;
    protected prng: PRNG;
    protected timer: Timer;
    protected eventManager: GameEventManager;
    protected recorder: GameRecorder | undefined;
    protected collisionTree: CollisionGrid;
    protected loader: Loader;
    protected platform: PlatformLayer;
    protected assetLoader?: AssetLoader;
    constructor(options: GameEngineOptions);
    protected setState(newState: GameState): void;
    /**
     * Reset the game engine to initial state
     * Clears all game objects, resets tick counter, and prepares for new game
     * If assetLoader is configured, preloads all registered assets before setup()
     * @param gameConfig Game configuration containing seed and initial state
     */
    reset(gameConfig: GameConfig): Promise<void>;
    /**
     * Abstract method for game-specific initialization
     * Override in subclasses to create initial game objects and configure game state
     * Called automatically during reset() to set up the game world
     * @param gameConfig Game configuration containing seed and initial state
     */
    abstract setup(gameConfig: GameConfig): Promise<void>;
    /**
     * Start the game by transitioning from READY to PLAYING state
     * Enables game loop processing and begins gameplay
     * @throws Error if engine is not in READY state
     */
    start(): void;
    /**
     * Pause the game by transitioning from PLAYING to PAUSED state
     * Stops game loop processing while maintaining current state
     * @throws Error if engine is not in PLAYING state
     */
    pause(): void;
    /**
     * Resume the game by transitioning from PAUSED to PLAYING state
     * Restarts game loop processing from paused state
     * @throws Error if engine is not in PAUSED state
     */
    resume(): void;
    /**
     * End the game by transitioning to ENDED state
     * Stops all game processing and marks game as finished
     * @throws Error if engine is not in PLAYING or PAUSED state
     */
    end(): void;
    /**
     * Update the game state for the current tick
     * Processes inputs, timers, and game objects in deterministic order
     * @param deltaTicks Number of ticks to advance the simulation
     */
    update(deltaTicks: number): void;
    /**
     * Register a GameObject with the engine
     * Automatically creates and manages groups by type
     * @param gameObject The game object to register
     * @param overrideType Optional type to use instead of gameObject.getType()
     */
    registerGameObject(gameObject: GameObject, overrideType?: string): void;
    /**
     * Get a GameObjectGroup by type
     * Returns undefined if no objects of that type have been registered
     */
    getGameObjectGroup(type: string): GameObjectGroup | undefined;
    /**
     * Get all registered object types
     */
    getRegisteredTypes(): string[];
    /**
     * Get the current game state
     */
    getState(): GameState;
    /**
     * Get the seed used for this game session
     */
    getSeed(): string;
    /**
     * Get the game configuration
     */
    getGameConfig(): GameConfig;
    /**
     * Get the total number of ticks processed
     */
    getTotalTicks(): number;
    /**
     * Get the PRNG instance for deterministic random numbers
     */
    getPRNG(): PRNG;
    /**
     * Clear all destroyed GameObjects from all groups
     * @returns Total number of destroyed objects removed
     */
    clearDestroyedGameObjects(): number;
    /**
     * Schedule a one-time callback to execute after the specified number of ticks
     */
    setTimeout(callback: () => void, ticks: number): number;
    /**
     * Schedule a repeating callback to execute every specified number of ticks
     */
    setInterval(callback: () => void, ticks: number): number;
    /**
     * Cancel a timer
     */
    clearTimer(id: number): boolean;
    /**
     * Get the timer system
     */
    getTimer(): Timer;
    /**
     * Get the event manager
     */
    getEventManager(): GameEventManager;
    /**
     * Set the game recorder for recording gameplay
     * Also sets the recorder on the event manager
     */
    setGameRecorder(recorder: GameRecorder | undefined): void;
    /**
     * Get the collision tree for spatial collision detection
     */
    getCollisionTree(): CollisionGrid;
    /**
     * Get the loader instance for data loading
     */
    getLoader(): Loader;
    /**
     * Get the platform layer
     */
    getPlatform(): PlatformLayer;
    /**
     * Get the asset loader for managing game assets
     */
    getAssetLoader(): AssetLoader | undefined;
}
//# sourceMappingURL=GameEngine.d.ts.map