@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/editor/ReplaySystem.d.ts

@@ -0,0 +1,231 @@
+/**
+ * @file ReplaySystem.ts
+ * @description Replay System for recording and playback of gameplay
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Input recording
+ * - State snapshots
+ * - Replay playback with speed control
+ * - Seek functionality
+ * - Keyframe system
+ * - Compression
+ * - Export/import formats
+ * - Spectator mode
+ * - Highlight markers
+ * - Replay validation
+ */
+export type ReplayState = 'idle' | 'recording' | 'playing' | 'paused' | 'seeking';
+export type PlaybackSpeed = 0.25 | 0.5 | 1 | 1.5 | 2 | 4 | 8;
+export interface InputFrame {
+    frameNumber: number;
+    timestamp: number;
+    inputs: Map<string, InputData>;
+}
+export interface InputData {
+    playerId: string;
+    keys: Set<string>;
+    mouseX: number;
+    mouseY: number;
+    mouseButtons: number;
+    gamepadAxes?: number[];
+    gamepadButtons?: boolean[];
+    customData?: Record<string, unknown>;
+}
+export interface StateSnapshot {
+    frameNumber: number;
+    timestamp: number;
+    gameState: unknown;
+    entityStates: Map<string, EntityState>;
+    checksum: string;
+}
+export interface EntityState {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    rotation: number;
+    velocity?: {
+        x: number;
+        y: number;
+    };
+    health?: number;
+    customState?: Record<string, unknown>;
+}
+export interface ReplayMarker {
+    id: string;
+    frameNumber: number;
+    timestamp: number;
+    type: 'highlight' | 'kill' | 'death' | 'objective' | 'custom';
+    label: string;
+    description?: string;
+    thumbnailUrl?: string;
+    playerId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ReplayMetadata {
+    id: string;
+    name: string;
+    description?: string;
+    gameId: string;
+    gameVersion: string;
+    mapId?: string;
+    gameMode?: string;
+    players: ReplayParticipant[];
+    recordedAt: number;
+    duration: number;
+    totalFrames: number;
+    frameRate: number;
+    markers: ReplayMarker[];
+    keyframeCount: number;
+    compressionType: 'none' | 'lz4' | 'zstd' | 'custom';
+    fileSize: number;
+    checksum: string;
+    tags: string[];
+    isPublic: boolean;
+    thumbnailUrl?: string;
+}
+export interface ReplayParticipant {
+    playerId: string;
+    playerName: string;
+    team?: string | number;
+    character?: string;
+    finalScore?: number;
+    finalStats?: Record<string, number>;
+}
+export interface ReplayData {
+    metadata: ReplayMetadata;
+    inputFrames: InputFrame[];
+    snapshots: StateSnapshot[];
+}
+export declare class ReplayRecorder {
+    private isRecording;
+    private startTime;
+    private frameNumber;
+    private inputFrames;
+    private snapshots;
+    private markers;
+    private frameRate;
+    private keyframeInterval;
+    private maxDuration;
+    private gameId;
+    private gameVersion;
+    private players;
+    private mapId?;
+    private gameMode?;
+    private getGameState?;
+    private getEntityStates?;
+    private onRecordingStarted?;
+    private onRecordingStopped?;
+    private onMarkerAdded?;
+    setGameInfo(gameId: string, version: string, mapId?: string, gameMode?: string): void;
+    setPlayers(players: ReplayParticipant[]): void;
+    setFrameRate(fps: number): void;
+    setKeyframeInterval(interval: number): void;
+    setMaxDuration(ms: number): void;
+    setStateGetters(getGameState: () => unknown, getEntityStates: () => Map<string, EntityState>): void;
+    startRecording(): void;
+    stopRecording(): ReplayData | null;
+    recordFrame(inputs: Map<string, InputData>): void;
+    private captureSnapshot;
+    addMarker(type: ReplayMarker['type'], label: string, description?: string, playerId?: string): ReplayMarker | null;
+    getRecordingState(): {
+        isRecording: boolean;
+        duration: number;
+        frameCount: number;
+    };
+    private generateChecksum;
+    private generateSnapshotChecksum;
+    private hashString;
+    setOnRecordingStarted(callback: () => void): void;
+    setOnRecordingStopped(callback: (data: ReplayData) => void): void;
+    setOnMarkerAdded(callback: (marker: ReplayMarker) => void): void;
+}
+export declare class ReplayPlayer {
+    private state;
+    private replayData;
+    private currentFrame;
+    private currentTime;
+    private playbackSpeed;
+    private lastUpdateTime;
+    private frameTime;
+    private accumulatedTime;
+    private onStateChanged?;
+    private onFrameChanged?;
+    private onInputFrame?;
+    private onSnapshotReached?;
+    private onMarkerReached?;
+    private onPlaybackComplete?;
+    private applyGameState?;
+    private applyEntityStates?;
+    loadReplay(data: ReplayData): boolean;
+    unloadReplay(): void;
+    private validateReplay;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    togglePlayPause(): void;
+    setSpeed(speed: PlaybackSpeed): void;
+    seekToFrame(frame: number): void;
+    seekToTime(ms: number): void;
+    seekToMarker(markerId: string): void;
+    stepForward(frames?: number): void;
+    stepBackward(frames?: number): void;
+    private findNearestSnapshot;
+    update(): void;
+    private processFrame;
+    private reset;
+    getState(): ReplayState;
+    getCurrentFrame(): number;
+    getCurrentTime(): number;
+    getTotalFrames(): number;
+    getDuration(): number;
+    getProgress(): number;
+    getPlaybackSpeed(): PlaybackSpeed;
+    getMetadata(): ReplayMetadata | null;
+    getMarkers(): ReplayMarker[];
+    setApplyGameState(callback: (state: unknown) => void): void;
+    setApplyEntityStates(callback: (states: Map<string, EntityState>) => void): void;
+    setOnStateChanged(callback: (state: ReplayState) => void): void;
+    setOnFrameChanged(callback: (frame: number, timestamp: number) => void): void;
+    setOnInputFrame(callback: (inputs: Map<string, InputData>) => void): void;
+    setOnSnapshotReached(callback: (snapshot: StateSnapshot) => void): void;
+    setOnMarkerReached(callback: (marker: ReplayMarker) => void): void;
+    setOnPlaybackComplete(callback: () => void): void;
+}
+export declare class ReplayManager {
+    private recorder;
+    private player;
+    private savedReplays;
+    private onReplaySaved?;
+    private onReplayDeleted?;
+    private onReplayExported?;
+    getRecorder(): ReplayRecorder;
+    getPlayer(): ReplayPlayer;
+    saveReplay(data: ReplayData, name?: string): string;
+    loadReplayById(id: string): boolean;
+    deleteReplay(id: string): boolean;
+    getSavedReplays(): ReplayMetadata[];
+    getReplayById(id: string): ReplayData | undefined;
+    exportReplay(id: string, format?: 'json' | 'binary'): string | ArrayBuffer | null;
+    importReplay(data: string | ArrayBuffer): ReplayData | null;
+    startRecording(): void;
+    stopRecordingAndSave(name?: string): string | null;
+    playLatestReplay(): boolean;
+    searchReplays(query: string): ReplayMetadata[];
+    getReplaysByPlayer(playerId: string): ReplayMetadata[];
+    getReplaysByGameMode(gameMode: string): ReplayMetadata[];
+    getTotalStorageUsed(): number;
+    getReplayCount(): number;
+    setOnReplaySaved(callback: (replay: ReplayData) => void): void;
+    setOnReplayDeleted(callback: (id: string) => void): void;
+    setOnReplayExported(callback: (id: string, format: string) => void): void;
+    exportAllReplays(): string;
+    importAllReplays(json: string): number;
+}
+export declare function createReplayManager(): ReplayManager;
+export declare function createReplayRecorder(): ReplayRecorder;
+export declare function createReplayPlayer(): ReplayPlayer;

package/dist/types/editor/ScreenshotMode.d.ts

@@ -0,0 +1,203 @@
+/**
+ * @file ScreenshotMode.ts
+ * @description Screenshot/Photo Mode system with free camera and filters
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Free camera movement
+ * - Hide UI elements
+ * - Image filters and effects
+ * - Resolution settings
+ * - Depth of field
+ * - Frame composition guides
+ * - Screenshot capture and save
+ * - Animation/pose freeze
+ * - Focus points
+ * - Watermarks and overlays
+ */
+export type FilterType = 'none' | 'grayscale' | 'sepia' | 'vintage' | 'noir' | 'vibrant' | 'warm' | 'cool' | 'dramatic' | 'soft' | 'hdr' | 'cinematic' | 'custom';
+export type CompositionGuide = 'none' | 'rule_of_thirds' | 'golden_ratio' | 'diagonal' | 'center' | 'triangle' | 'symmetry';
+export type OutputFormat = 'png' | 'jpg' | 'webp';
+export type AspectRatio = '16:9' | '4:3' | '1:1' | '21:9' | '9:16' | 'custom';
+export interface CameraState {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    fov: number;
+    near: number;
+    far: number;
+}
+export interface FilterSettings {
+    type: FilterType;
+    intensity: number;
+    customSettings?: CustomFilterSettings;
+}
+export interface CustomFilterSettings {
+    brightness: number;
+    contrast: number;
+    saturation: number;
+    hue: number;
+    gamma: number;
+    exposure: number;
+    temperature: number;
+    tint: number;
+    shadows: number;
+    highlights: number;
+    vignette: number;
+    vignetteColor: string;
+    grain: number;
+    blur: number;
+    sharpen: number;
+}
+export interface DepthOfFieldSettings {
+    enabled: boolean;
+    focusDistance: number;
+    aperture: number;
+    focalLength: number;
+    bokehSize: number;
+    bokehShape: 'circle' | 'hexagon' | 'octagon';
+    autoFocus: boolean;
+    focusPoint?: {
+        x: number;
+        y: number;
+    };
+}
+export interface ResolutionSettings {
+    width: number;
+    height: number;
+    aspectRatio: AspectRatio;
+    supersampling: 1 | 2 | 4;
+}
+export interface WatermarkSettings {
+    enabled: boolean;
+    text?: string;
+    imageUrl?: string;
+    position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
+    opacity: number;
+    scale: number;
+    padding: number;
+}
+export interface ScreenshotSettings {
+    format: OutputFormat;
+    quality: number;
+    resolution: ResolutionSettings;
+    filter: FilterSettings;
+    dof: DepthOfFieldSettings;
+    compositionGuide: CompositionGuide;
+    watermark: WatermarkSettings;
+    includeTimestamp: boolean;
+    includeMetadata: boolean;
+}
+export interface ScreenshotResult {
+    id: string;
+    dataUrl: string;
+    blob?: Blob;
+    width: number;
+    height: number;
+    format: OutputFormat;
+    takenAt: number;
+    cameraState: CameraState;
+    settings: ScreenshotSettings;
+    metadata?: Record<string, unknown>;
+}
+export declare const DEFAULT_CUSTOM_FILTER: CustomFilterSettings;
+export declare const DEFAULT_DOF_SETTINGS: DepthOfFieldSettings;
+export declare const DEFAULT_RESOLUTION: ResolutionSettings;
+export declare const DEFAULT_WATERMARK: WatermarkSettings;
+export declare const FILTER_PRESETS: Record<FilterType, Partial<CustomFilterSettings>>;
+export declare class ScreenshotMode {
+    private isActive;
+    private isPaused;
+    private originalCamera;
+    private freeCamera;
+    private moveSpeed;
+    private rotateSpeed;
+    private smoothing;
+    private settings;
+    private hiddenUIElements;
+    private screenshots;
+    private savedCameraPositions;
+    private onModeActivated?;
+    private onModeDeactivated?;
+    private onCameraChanged?;
+    private onSettingsChanged?;
+    private onScreenshotTaken?;
+    private captureCanvas?;
+    private setRenderFilter?;
+    private setUIVisibility?;
+    private pauseGame?;
+    private resumeGame?;
+    activate(initialCamera?: CameraState): void;
+    deactivate(): void;
+    toggle(initialCamera?: CameraState): void;
+    isActivated(): boolean;
+    moveCamera(deltaX: number, deltaY: number, deltaZ: number): void;
+    rotateCamera(deltaPitch: number, deltaYaw: number, deltaRoll?: number): void;
+    setFOV(fov: number): void;
+    adjustFOV(delta: number): void;
+    resetCamera(): void;
+    getCameraState(): CameraState;
+    setCameraState(state: CameraState): void;
+    saveCameraPosition(name: string): void;
+    loadCameraPosition(name: string): boolean;
+    deleteCameraPosition(name: string): boolean;
+    getSavedPositions(): string[];
+    setMoveSpeed(speed: number): void;
+    setRotateSpeed(speed: number): void;
+    setSmoothing(smoothing: number): void;
+    setFilter(type: FilterType, intensity?: number): void;
+    setCustomFilter(settings: Partial<CustomFilterSettings>): void;
+    private applyFilter;
+    private lerp;
+    getFilter(): FilterSettings;
+    setDOF(settings: Partial<DepthOfFieldSettings>): void;
+    setFocusPoint(x: number, y: number): void;
+    enableAutoFocus(): void;
+    setResolution(width: number, height: number): void;
+    setAspectRatio(ratio: AspectRatio): void;
+    setSupersampling(factor: 1 | 2 | 4): void;
+    setCompositionGuide(guide: CompositionGuide): void;
+    setWatermark(settings: Partial<WatermarkSettings>): void;
+    hideUIElement(elementId: string): void;
+    showUIElement(elementId: string): void;
+    hideAllUI(): void;
+    showAllUI(): void;
+    takeScreenshot(metadata?: Record<string, unknown>): Promise<ScreenshotResult | null>;
+    private getMimeType;
+    private applyWatermark;
+    private loadImage;
+    getScreenshots(): ScreenshotResult[];
+    getScreenshotById(id: string): ScreenshotResult | undefined;
+    deleteScreenshot(id: string): boolean;
+    clearScreenshots(): void;
+    downloadScreenshot(id: string, filename?: string): Promise<boolean>;
+    getSettings(): ScreenshotSettings;
+    setSettings(settings: Partial<ScreenshotSettings>): void;
+    resetSettings(): void;
+    private getDefaultSettings;
+    renderCompositionGuide(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    private drawThirdsGrid;
+    private drawGoldenRatio;
+    private drawDiagonals;
+    private drawCenterGuides;
+    private drawTriangle;
+    private drawSymmetry;
+    setOnModeActivated(callback: () => void): void;
+    setOnModeDeactivated(callback: () => void): void;
+    setOnCameraChanged(callback: (camera: CameraState) => void): void;
+    setOnSettingsChanged(callback: (settings: ScreenshotSettings) => void): void;
+    setOnScreenshotTaken(callback: (result: ScreenshotResult) => void): void;
+    setCaptureCanvas(fn: () => HTMLCanvasElement | null): void;
+    setRenderFilterCallback(fn: (filter: CustomFilterSettings) => void): void;
+    setUIVisibilityCallback(fn: (visible: boolean) => void): void;
+    setPauseGame(fn: () => void): void;
+    setResumeGame(fn: () => void): void;
+}
+export declare function createScreenshotMode(): ScreenshotMode;

package/dist/types/editor/UndoRedoPro.d.ts

@@ -0,0 +1,228 @@
+/**
+ * @file UndoRedoPro.ts
+ * @description Advanced Undo/Redo system with selective undo, branch history, snapshots
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Command-based undo/redo
+ * - Selective undo (undo specific actions without undoing newer ones)
+ * - Branch history (fork history at any point)
+ * - Automatic snapshots
+ * - Manual snapshots (named save points)
+ * - Action grouping (combine multiple actions)
+ * - Action filtering by category/target
+ * - History visualization data
+ * - Memory management (limit history size)
+ * - Serialization for persistence
+ */
+export type ActionCategory = 'transform' | 'component' | 'entity' | 'scene' | 'asset' | 'selection' | 'property' | 'hierarchy' | 'material' | 'animation' | 'physics' | 'audio' | 'script' | 'prefab' | 'other';
+export interface UndoableAction {
+    id: string;
+    name: string;
+    description: string;
+    category: ActionCategory;
+    timestamp: number;
+    targetId?: string;
+    targetType?: string;
+    doData: unknown;
+    undoData: unknown;
+    actionType: string;
+    groupId?: string;
+    isGroupStart?: boolean;
+    isGroupEnd?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ActionGroup {
+    id: string;
+    name: string;
+    description: string;
+    actionIds: string[];
+    timestamp: number;
+    isCollapsed: boolean;
+}
+export interface HistorySnapshot {
+    id: string;
+    name: string;
+    description: string;
+    timestamp: number;
+    actionIndex: number;
+    stateData: string;
+    isAutoSnapshot: boolean;
+    thumbnail?: string;
+}
+export interface HistoryBranch {
+    id: string;
+    name: string;
+    parentBranchId: string | null;
+    forkActionIndex: number;
+    actions: UndoableAction[];
+    currentIndex: number;
+    createdAt: number;
+    isActive: boolean;
+}
+export interface ActionExecutor {
+    execute(data: unknown): void;
+    undo(data: unknown): void;
+    validate?(data: unknown): boolean;
+    merge?(oldData: unknown, newData: unknown): unknown | null;
+}
+export interface UndoRedoConfig {
+    maxHistorySize: number;
+    maxBranches: number;
+    autoSnapshotInterval: number;
+    autoSnapshotOnBranch: boolean;
+    mergeConsecutiveActions: boolean;
+    mergeTimeWindow: number;
+    enableSelectiveUndo: boolean;
+    enableBranches: boolean;
+}
+export declare const DEFAULT_UNDO_REDO_CONFIG: UndoRedoConfig;
+export declare class UndoRedoManager {
+    private config;
+    private executors;
+    private branches;
+    private activeBranchId;
+    private groups;
+    private snapshots;
+    private currentGroupId;
+    private actionsSinceSnapshot;
+    private isExecuting;
+    private lastActionTime;
+    private onHistoryChange?;
+    private onActionExecuted?;
+    private onSnapshotCreated?;
+    private getStateSnapshot?;
+    private restoreStateSnapshot?;
+    constructor(config?: Partial<UndoRedoConfig>);
+    registerExecutor(actionType: string, executor: ActionExecutor): void;
+    unregisterExecutor(actionType: string): void;
+    execute(action: Omit<UndoableAction, 'id' | 'timestamp'>): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    private undoSingleAction;
+    private redoSingleAction;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undoAction(actionId: string): boolean;
+    redoSelectiveAction(actionId: string): boolean;
+    beginGroup(name: string, description?: string): string;
+    endGroup(): void;
+    cancelGroup(): void;
+    private undoGroup;
+    private redoGroup;
+    createSnapshot(name: string, description?: string): HistorySnapshot | null;
+    private createAutoSnapshot;
+    restoreSnapshot(snapshotId: string): boolean;
+    getSnapshots(): HistorySnapshot[];
+    deleteSnapshot(snapshotId: string): boolean;
+    createBranch(name: string): HistoryBranch | null;
+    private createBranchFromCurrent;
+    switchBranch(branchId: string): boolean;
+    getBranches(): HistoryBranch[];
+    getActiveBranch(): HistoryBranch | null;
+    deleteBranch(branchId: string): boolean;
+    mergeBranch(branchId: string): boolean;
+    getHistory(): UndoableAction[];
+    getUndoHistory(): UndoableAction[];
+    getRedoHistory(): UndoableAction[];
+    getCurrentAction(): UndoableAction | null;
+    getActionsByCategory(category: ActionCategory): UndoableAction[];
+    getActionsByTarget(targetId: string): UndoableAction[];
+    getGroup(groupId: string): ActionGroup | undefined;
+    getHistoryTree(): HistoryTreeNode[];
+    private buildHistoryNodes;
+    setOnHistoryChange(callback: () => void): void;
+    setOnActionExecuted(callback: (action: UndoableAction, isUndo: boolean) => void): void;
+    setOnSnapshotCreated(callback: (snapshot: HistorySnapshot) => void): void;
+    setStateSnapshotFunctions(getSnapshot: () => string, restoreSnapshot: (data: string) => void): void;
+    private generateId;
+    private enforceHistoryLimit;
+    jumpToAction(actionId: string): boolean;
+    clear(): void;
+    serialize(): string;
+    deserialize(json: string): boolean;
+}
+export interface HistoryTreeNode {
+    id: string;
+    type: 'action' | 'group' | 'branch' | 'snapshot';
+    name: string;
+    children: HistoryTreeNode[];
+    isActive: boolean;
+    isCurrent: boolean;
+    isCollapsed?: boolean;
+    category?: ActionCategory;
+    timestamp?: number;
+    selectivelyUndone?: boolean;
+    parentId?: string;
+    forkIndex?: number;
+}
+export declare const CommonExecutors: {
+    setProperty: {
+        execute(data: {
+            target: Record<string, unknown>;
+            property: string;
+            value: unknown;
+        }): void;
+        undo(data: {
+            target: Record<string, unknown>;
+            property: string;
+            oldValue: unknown;
+        }): void;
+        merge(oldData: {
+            property: string;
+            value: unknown;
+        }, newData: {
+            property: string;
+            value: unknown;
+        }): {
+            value: unknown;
+            property: string;
+        } | null;
+    };
+    arrayPush: {
+        execute(data: {
+            array: unknown[];
+            value: unknown;
+        }): void;
+        undo(data: {
+            array: unknown[];
+        }): void;
+    };
+    arrayRemove: {
+        execute(data: {
+            array: unknown[];
+            index: number;
+        }): void;
+        undo(data: {
+            array: unknown[];
+            index: number;
+            value: unknown;
+        }): void;
+    };
+    mapSet: {
+        execute(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+            value: unknown;
+        }): void;
+        undo(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+            hadValue: boolean;
+            oldValue: unknown;
+        }): void;
+    };
+    mapDelete: {
+        execute(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+        }): void;
+        undo(data: {
+            map: Map<unknown, unknown>;
+            key: unknown;
+            value: unknown;
+        }): void;
+    };
+};
+export declare function createUndoRedoManager(config?: Partial<UndoRedoConfig>): UndoRedoManager;
+export declare function createAction(name: string, actionType: string, category: ActionCategory, doData: unknown, undoData: unknown, options?: Partial<Omit<UndoableAction, 'id' | 'name' | 'actionType' | 'category' | 'timestamp' | 'doData' | 'undoData'>>): Omit<UndoableAction, 'id' | 'timestamp'>;