@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/systems/NiceScreenshot.d.ts

@@ -0,0 +1,443 @@
+/**
+ * NiceScreenshot - Screenshot & Media Capture System
+ *
+ * Comprehensive screenshot system for capturing, processing, and sharing
+ * in-game screenshots with various effects and options.
+ *
+ * Features:
+ * - Screenshot capture
+ * - Video recording
+ * - GIF creation
+ * - Image processing/filters
+ * - Watermarking
+ * - Metadata embedding
+ * - Gallery management
+ * - Screenshot mode (hide UI)
+ * - Camera positioning
+ * - Resolution selection
+ * - Format options
+ * - Sharing integration
+ * - Auto-capture (achievements, kills, etc.)
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+/** Unique screenshot ID */
+export type ScreenshotId = string;
+/** Unique recording ID */
+export type RecordingId = string;
+/** Image format */
+export type ImageFormat = 'png' | 'jpg' | 'webp' | 'gif';
+/** Video format */
+export type VideoFormat = 'webm' | 'mp4' | 'gif';
+/** Screenshot state */
+export type CaptureState = 'idle' | 'capturing' | 'processing' | 'saving' | 'error';
+/** Recording state */
+export type RecordingState = 'idle' | 'recording' | 'paused' | 'processing' | 'saved' | 'error';
+/** Filter type */
+export type FilterType = 'none' | 'grayscale' | 'sepia' | 'vintage' | 'blur' | 'sharpen' | 'brightness' | 'contrast' | 'saturate' | 'hue_rotate' | 'invert' | 'custom';
+/** Resolution preset */
+export type ResolutionPreset = 'native' | '720p' | '1080p' | '1440p' | '4k' | 'ultrawide' | 'custom';
+/** Resolution settings */
+export interface Resolution {
+    width: number;
+    height: number;
+    aspectRatio?: string;
+}
+/** Resolution presets map */
+export declare const RESOLUTION_PRESETS: Record<ResolutionPreset, Resolution | null>;
+/** Capture options */
+export interface CaptureOptions {
+    format?: ImageFormat;
+    quality?: number;
+    resolution?: ResolutionPreset | Resolution;
+    hideUI?: boolean;
+    hideHUD?: boolean;
+    hidePlayers?: boolean;
+    hideEffects?: boolean;
+    delay?: number;
+    filters?: FilterSettings[];
+    watermark?: WatermarkSettings;
+    metadata?: ScreenshotMetadata;
+    filename?: string;
+    autoSave?: boolean;
+}
+/** Filter settings */
+export interface FilterSettings {
+    type: FilterType;
+    intensity?: number;
+    params?: Record<string, number>;
+}
+/** Watermark settings */
+export interface WatermarkSettings {
+    enabled: boolean;
+    text?: string;
+    image?: string;
+    position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
+    opacity: number;
+    size: number;
+    margin: number;
+}
+/** Screenshot metadata */
+export interface ScreenshotMetadata {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    location?: string;
+    character?: string;
+    gameMode?: string;
+    timestamp?: number;
+    gameVersion?: string;
+    playerName?: string;
+    customData?: Record<string, unknown>;
+}
+/** Screenshot data */
+export interface Screenshot {
+    id: ScreenshotId;
+    dataUrl: string;
+    blob?: Blob;
+    width: number;
+    height: number;
+    format: ImageFormat;
+    size: number;
+    metadata: ScreenshotMetadata;
+    capturedAt: number;
+    filters: FilterSettings[];
+    isFavorite: boolean;
+    isShared: boolean;
+    filePath?: string;
+}
+/** Recording options */
+export interface RecordingOptions {
+    format?: VideoFormat;
+    quality?: 'low' | 'medium' | 'high' | 'ultra';
+    fps?: number;
+    resolution?: ResolutionPreset | Resolution;
+    maxDuration?: number;
+    includeAudio?: boolean;
+    hideUI?: boolean;
+    bitrate?: number;
+}
+/** Recording data */
+export interface Recording {
+    id: RecordingId;
+    state: RecordingState;
+    format: VideoFormat;
+    duration: number;
+    width: number;
+    height: number;
+    fps: number;
+    size: number;
+    startedAt: number;
+    endedAt?: number;
+    blob?: Blob;
+    dataUrl?: string;
+    filePath?: string;
+    metadata?: ScreenshotMetadata;
+}
+/** Gallery item */
+export interface GalleryItem {
+    id: string;
+    type: 'screenshot' | 'recording' | 'gif';
+    thumbnailUrl: string;
+    fullUrl?: string;
+    width: number;
+    height: number;
+    size: number;
+    createdAt: number;
+    metadata?: ScreenshotMetadata;
+    isFavorite: boolean;
+}
+/** Screenshot mode settings */
+export interface ScreenshotModeSettings {
+    enabled: boolean;
+    hideUI: boolean;
+    hideHUD: boolean;
+    hidePlayers: boolean;
+    hideEffects: boolean;
+    hideNames: boolean;
+    customFOV?: number;
+    depthOfField?: DepthOfFieldSettings;
+    freeCam?: FreeCamSettings;
+}
+/** Depth of field settings */
+export interface DepthOfFieldSettings {
+    enabled: boolean;
+    focusDistance: number;
+    aperture: number;
+    focalLength: number;
+}
+/** Free camera settings */
+export interface FreeCamSettings {
+    enabled: boolean;
+    moveSpeed: number;
+    rotateSpeed: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+}
+/** Auto-capture trigger */
+export interface AutoCaptureTrigger {
+    id: string;
+    name: string;
+    eventType: string;
+    enabled: boolean;
+    delay?: number;
+    options?: Partial<CaptureOptions>;
+}
+/** Share target */
+export interface ShareTarget {
+    id: string;
+    name: string;
+    icon?: string;
+    type: 'social' | 'cloud' | 'local' | 'clipboard';
+}
+/** Share result */
+export interface ShareResult {
+    success: boolean;
+    target: string;
+    url?: string;
+    error?: string;
+}
+/** Screenshot statistics */
+export interface ScreenshotStatistics {
+    totalCaptures: number;
+    totalRecordings: number;
+    totalSize: number;
+    favoriteCount: number;
+    sharedCount: number;
+    averageSize: number;
+    formatCounts: Record<ImageFormat, number>;
+}
+/** Screenshot event types */
+export type ScreenshotEventType = 'capture_started' | 'capture_completed' | 'capture_failed' | 'recording_started' | 'recording_stopped' | 'recording_paused' | 'recording_resumed' | 'recording_completed' | 'recording_failed' | 'screenshot_saved' | 'screenshot_deleted' | 'screenshot_shared' | 'mode_entered' | 'mode_exited' | 'filter_applied' | 'gallery_updated';
+/** Screenshot event data */
+export interface ScreenshotEvent {
+    type: ScreenshotEventType;
+    timestamp: number;
+    screenshotId?: ScreenshotId;
+    recordingId?: RecordingId;
+    data?: unknown;
+    error?: string;
+}
+/** Screenshot event callback */
+export type ScreenshotEventCallback = (event: ScreenshotEvent) => void;
+/** Screenshot system configuration */
+export interface ScreenshotConfig {
+    defaultFormat: ImageFormat;
+    defaultQuality: number;
+    defaultResolution: ResolutionPreset;
+    screenshotsDirectory: string;
+    recordingsDirectory: string;
+    maxGallerySize: number;
+    generateThumbnails: boolean;
+    thumbnailSize: number;
+    autoSaveEnabled: boolean;
+    captureSound: string | null;
+    maxRecordingDuration: number;
+    recordingFps: number;
+    watermarkEnabled: boolean;
+    defaultWatermark: WatermarkSettings;
+}
+/** Default configuration */
+export declare const DEFAULT_SCREENSHOT_CONFIG: ScreenshotConfig;
+/**
+ * Screenshot and media capture system
+ */
+export declare class NiceScreenshot extends EventEmitter {
+    private config;
+    private screenshots;
+    private recordings;
+    private gallery;
+    private captureState;
+    private recordingState;
+    private currentRecording?;
+    private modeSettings;
+    private autoCaptureTriggers;
+    private idCounter;
+    private recordingStartTime;
+    private mediaRecorder?;
+    private recordedChunks;
+    private statistics;
+    constructor(config?: Partial<ScreenshotConfig>);
+    /**
+     * Generate unique ID
+     */
+    private generateId;
+    /**
+     * Emit screenshot event
+     */
+    private emitEvent;
+    /**
+     * Capture screenshot
+     */
+    capture(source: HTMLCanvasElement | HTMLElement | string, options?: CaptureOptions): Promise<Screenshot | undefined>;
+    /**
+     * Apply filters to context
+     */
+    private applyFilters;
+    /**
+     * Apply watermark
+     */
+    private applyWatermark;
+    /**
+     * Load image
+     */
+    private loadImage;
+    /**
+     * Generate thumbnail
+     */
+    private generateThumbnail;
+    /**
+     * Get MIME type for format
+     */
+    private getMimeType;
+    /**
+     * Convert data URL to blob
+     */
+    private dataUrlToBlob;
+    /**
+     * Delay helper
+     */
+    private delay;
+    /**
+     * Start recording
+     */
+    startRecording(source: HTMLCanvasElement | MediaStream, options?: RecordingOptions): Promise<RecordingId | undefined>;
+    /**
+     * Get video MIME type
+     */
+    private getVideoMimeType;
+    /**
+     * Stop recording
+     */
+    stopRecording(): void;
+    /**
+     * Pause recording
+     */
+    pauseRecording(): void;
+    /**
+     * Resume recording
+     */
+    resumeRecording(): void;
+    /**
+     * Process completed recording
+     */
+    private processRecording;
+    /**
+     * Get recording state
+     */
+    getRecordingState(): RecordingState;
+    /**
+     * Get current recording
+     */
+    getCurrentRecording(): Recording | undefined;
+    /**
+     * Get recording duration
+     */
+    getRecordingDuration(): number;
+    /**
+     * Add item to gallery
+     */
+    private addToGallery;
+    /**
+     * Get gallery items
+     */
+    getGallery(type?: 'screenshot' | 'recording' | 'gif', limit?: number): GalleryItem[];
+    /**
+     * Get screenshot by ID
+     */
+    getScreenshot(id: ScreenshotId): Screenshot | undefined;
+    /**
+     * Get recording by ID
+     */
+    getRecording(id: RecordingId): Recording | undefined;
+    /**
+     * Delete screenshot
+     */
+    deleteScreenshot(id: ScreenshotId): boolean;
+    /**
+     * Toggle favorite
+     */
+    toggleFavorite(id: string): boolean;
+    /**
+     * Get favorites
+     */
+    getFavorites(): GalleryItem[];
+    /**
+     * Enter screenshot mode
+     */
+    enterScreenshotMode(settings?: Partial<ScreenshotModeSettings>): void;
+    /**
+     * Exit screenshot mode
+     */
+    exitScreenshotMode(): void;
+    /**
+     * Get mode settings
+     */
+    getModeSettings(): ScreenshotModeSettings;
+    /**
+     * Update mode settings
+     */
+    updateModeSettings(settings: Partial<ScreenshotModeSettings>): void;
+    /**
+     * Is in screenshot mode
+     */
+    isInScreenshotMode(): boolean;
+    /**
+     * Register auto-capture trigger
+     */
+    registerAutoCapture(trigger: AutoCaptureTrigger): void;
+    /**
+     * Unregister auto-capture trigger
+     */
+    unregisterAutoCapture(triggerId: string): boolean;
+    /**
+     * Get auto-capture triggers
+     */
+    getAutoCaptureTriggers(): AutoCaptureTrigger[];
+    /**
+     * Trigger auto-capture
+     */
+    triggerAutoCapture(eventType: string, source: HTMLCanvasElement): Promise<Screenshot | undefined>;
+    /**
+     * Save screenshot to file
+     */
+    saveScreenshot(id: ScreenshotId, filename?: string): Promise<boolean>;
+    /**
+     * Share screenshot
+     */
+    shareScreenshot(id: ScreenshotId, target: ShareTarget): Promise<ShareResult>;
+    /**
+     * Copy to clipboard
+     */
+    copyToClipboard(id: ScreenshotId): Promise<boolean>;
+    /**
+     * Get statistics
+     */
+    getStatistics(): ScreenshotStatistics;
+    /**
+     * Update average size
+     */
+    private updateAverageSize;
+    /**
+     * Clear gallery
+     */
+    clearGallery(): void;
+    /**
+     * Destroy screenshot system
+     */
+    destroy(): void;
+}
+/**
+ * Create screenshot system instance
+ */
+export declare function createScreenshotSystem(config?: Partial<ScreenshotConfig>): NiceScreenshot;
+export default NiceScreenshot;

package/dist/types/systems/NiceScribe.d.ts

@@ -0,0 +1,239 @@
+export type ScrollId = string;
+export type TomeId = string;
+export type LanguageId = string;
+export type InkId = string;
+export type PaperId = string;
+export type ScrollType = 'spell' | 'portal' | 'summon' | 'buff' | 'utility' | 'quest' | 'map' | 'recipe';
+export type TomeType = 'spellbook' | 'lore' | 'skill' | 'bestiary' | 'herbarium' | 'atlas' | 'collection';
+export interface ScrollDefinition {
+    id: ScrollId;
+    name: string;
+    description: string;
+    type: ScrollType;
+    tier: number;
+    languageRequired?: LanguageId;
+    scribeLevelRequired: number;
+    inkRequired: InkId;
+    inkAmount: number;
+    paperRequired: PaperId;
+    craftTime: number;
+    effect: ScrollEffect;
+    charges: number;
+    sellValue: number;
+    tradeable: boolean;
+    icon: string;
+    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+}
+export interface ScrollEffect {
+    type: 'cast_spell' | 'teleport' | 'summon' | 'buff' | 'reveal' | 'learn' | 'custom';
+    spellId?: string;
+    spellPower?: number;
+    destination?: string;
+    creatureId?: string;
+    duration?: number;
+    buffId?: string;
+    buffDuration?: number;
+    recipeId?: string;
+    abilityId?: string;
+    effectData?: Record<string, unknown>;
+}
+export interface TomeDefinition {
+    id: TomeId;
+    name: string;
+    description: string;
+    type: TomeType;
+    pages: TomePage[];
+    maxPages: number;
+    tier: number;
+    languageRequired?: LanguageId;
+    boundToPlayer: boolean;
+    expandable: boolean;
+    passiveBonuses?: TomeBonus[];
+    icon: string;
+    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+}
+export interface TomePage {
+    index: number;
+    title: string;
+    content: string;
+    linkedSpell?: string;
+    linkedLore?: string;
+    linkedCreature?: string;
+    linkedLocation?: string;
+    unlockCondition?: string;
+    unlocked: boolean;
+}
+export interface TomeBonus {
+    stat: string;
+    value: number;
+    isPercentage: boolean;
+    condition?: string;
+}
+export interface LanguageDefinition {
+    id: LanguageId;
+    name: string;
+    description: string;
+    difficulty: number;
+    learningMethod: 'study' | 'immersion' | 'magical' | 'artifact';
+    prerequisiteLanguages?: LanguageId[];
+    scribeLevelRequired: number;
+    unlocksScrolls: ScrollId[];
+    unlocksTomes: TomeId[];
+    origin: string;
+    speakers: string[];
+}
+export interface InkDefinition {
+    id: InkId;
+    name: string;
+    description: string;
+    tier: number;
+    color: string;
+    magical: boolean;
+    ingredients: Record<string, number>;
+    craftTime: number;
+    sellValue: number;
+}
+export interface PaperDefinition {
+    id: PaperId;
+    name: string;
+    description: string;
+    tier: number;
+    material: 'parchment' | 'vellum' | 'papyrus' | 'silk' | 'magical' | 'dragon';
+    durability: number;
+    enchantSlots: number;
+    sellValue: number;
+}
+export interface PlayerScribeData {
+    playerId: string;
+    scribeLevel: number;
+    scribeXP: number;
+    inks: Map<InkId, number>;
+    papers: Map<PaperId, number>;
+    scrolls: Map<ScrollId, PlayerScroll[]>;
+    tomes: Map<TomeId, PlayerTome>;
+    equippedTome?: TomeId;
+    knownLanguages: Set<LanguageId>;
+    languageProgress: Map<LanguageId, number>;
+    scrollsCrafted: number;
+    scrollsUsed: number;
+    tomesCollected: number;
+    pagesUnlocked: number;
+}
+export interface PlayerScroll {
+    id: string;
+    scrollId: ScrollId;
+    charges: number;
+    maxCharges: number;
+    enchantments?: string[];
+    createdAt: number;
+}
+export interface PlayerTome {
+    tomeId: TomeId;
+    unlockedPages: Set<number>;
+    notes: Map<number, string>;
+    bookmarks: Set<number>;
+    completionPercent: number;
+    acquiredAt: number;
+}
+export interface ScribeCraftResult {
+    success: boolean;
+    scroll?: PlayerScroll;
+    xpGained: number;
+    qualityBonus?: number;
+    criticalSuccess?: boolean;
+}
+export type ScribeEventType = 'scroll-crafted' | 'scroll-used' | 'scroll-enchanted' | 'tome-acquired' | 'page-unlocked' | 'tome-equipped' | 'language-learned' | 'language-progress' | 'scribe-level-up' | 'ink-crafted';
+export interface ScribeEvent {
+    type: ScribeEventType;
+    timestamp: number;
+    data?: unknown;
+}
+export type ScribeEventCallback = (event: ScribeEvent) => void;
+export interface ScribeConfig {
+    maxScrollsPerType: number;
+    maxTomes: number;
+    maxLanguages: number;
+    xpPerLevel: number;
+    maxLevel: number;
+    languageXPRequired: number;
+    storageKey: string;
+}
+export declare const DEFAULT_SCRIBE_CONFIG: ScribeConfig;
+export declare class NiceScribe {
+    private config;
+    private scrolls;
+    private tomes;
+    private languages;
+    private inks;
+    private papers;
+    private players;
+    private eventListeners;
+    constructor(config?: Partial<ScribeConfig>);
+    on(event: ScribeEventType, callback: ScribeEventCallback): () => void;
+    private emit;
+    registerScroll(scroll: ScrollDefinition): void;
+    registerTome(tome: TomeDefinition): void;
+    registerLanguage(language: LanguageDefinition): void;
+    registerInk(ink: InkDefinition): void;
+    registerPaper(paper: PaperDefinition): void;
+    getPlayer(playerId: string): PlayerScribeData;
+    private createPlayerData;
+    addInk(playerId: string, inkId: InkId, count?: number): boolean;
+    removeInk(playerId: string, inkId: InkId, count?: number): boolean;
+    addPaper(playerId: string, paperId: PaperId, count?: number): boolean;
+    removePaper(playerId: string, paperId: PaperId, count?: number): boolean;
+    getInkCount(playerId: string, inkId: InkId): number;
+    getPaperCount(playerId: string, paperId: PaperId): number;
+    canCraftScroll(playerId: string, scrollId: ScrollId): boolean;
+    craftScroll(playerId: string, scrollId: ScrollId): ScribeCraftResult;
+    useScroll(playerId: string, scrollInstanceId: string): ScrollEffect | null;
+    getPlayerScrolls(playerId: string, scrollId?: ScrollId): PlayerScroll[];
+    acquireTome(playerId: string, tomeId: TomeId): boolean;
+    private updateTomeCompletion;
+    equipTome(playerId: string, tomeId: TomeId | undefined): boolean;
+    unlockPage(playerId: string, tomeId: TomeId, pageIndex: number): boolean;
+    addBookmark(playerId: string, tomeId: TomeId, pageIndex: number): boolean;
+    removeBookmark(playerId: string, tomeId: TomeId, pageIndex: number): boolean;
+    addNote(playerId: string, tomeId: TomeId, pageIndex: number, note: string): boolean;
+    getPlayerTome(playerId: string, tomeId: TomeId): {
+        playerTome: PlayerTome;
+        definition: TomeDefinition;
+    } | null;
+    getEquippedTomeBonuses(playerId: string): TomeBonus[];
+    knowsLanguage(playerId: string, languageId: LanguageId): boolean;
+    canLearnLanguage(playerId: string, languageId: LanguageId): boolean;
+    addLanguageProgress(playerId: string, languageId: LanguageId, amount: number): boolean;
+    getLanguageProgress(playerId: string, languageId: LanguageId): {
+        progress: number;
+        required: number;
+        percent: number;
+    };
+    getKnownLanguages(playerId: string): LanguageDefinition[];
+    addScribeXP(playerId: string, xp: number): void;
+    getXPForLevel(level: number): number;
+    getScroll(id: ScrollId): ScrollDefinition | undefined;
+    getAllScrolls(): ScrollDefinition[];
+    getAvailableScrolls(playerId: string): ScrollDefinition[];
+    getTome(id: TomeId): TomeDefinition | undefined;
+    getAllTomes(): TomeDefinition[];
+    getLanguage(id: LanguageId): LanguageDefinition | undefined;
+    getAllLanguages(): LanguageDefinition[];
+    getInk(id: InkId): InkDefinition | undefined;
+    getPaper(id: PaperId): PaperDefinition | undefined;
+    getStats(playerId: string): {
+        level: number;
+        xp: number;
+        xpNeeded: number;
+        scrollsCrafted: number;
+        scrollsUsed: number;
+        tomesCollected: number;
+        tomeCompletion: number;
+        languagesKnown: number;
+        pagesUnlocked: number;
+    };
+    save(): void;
+    load(): void;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createScribeSystem(config?: Partial<ScribeConfig>): NiceScribe;