@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,214 @@
+/**
+ * @file AssetBrowser.ts
+ * @description Advanced Asset Browser with thumbnails, search, tags, favorites
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Thumbnail generation for all asset types
+ * - Advanced search with filters
+ * - Tag management and filtering
+ * - Favorites system
+ * - Recent assets tracking
+ * - Collections/folders
+ * - Asset metadata editing
+ * - Drag & drop support
+ * - Import/export
+ * - Asset dependencies
+ * - Quick preview
+ */
+export type AssetBrowserViewMode = 'grid' | 'list' | 'details' | 'tree';
+export type AssetSortMode = 'name-asc' | 'name-desc' | 'date-asc' | 'date-desc' | 'size-asc' | 'size-desc' | 'type';
+export type BrowserAssetType = 'image' | 'sprite' | 'spritesheet' | 'tilemap' | 'audio' | 'music' | 'sfx' | 'model' | 'material' | 'shader' | 'script' | 'scene' | 'prefab' | 'animation' | 'font' | 'particle' | 'terrain' | 'video' | 'json' | 'other';
+export interface AssetThumbnail {
+    dataUrl: string;
+    width: number;
+    height: number;
+    generated: number;
+}
+export interface AssetDependency {
+    assetId: string;
+    type: 'reference' | 'embedded' | 'linked';
+}
+export interface BrowserAsset {
+    id: string;
+    name: string;
+    type: BrowserAssetType;
+    path: string;
+    size: number;
+    mimeType: string;
+    tags: string[];
+    description: string;
+    author: string;
+    license: string;
+    version: string;
+    customProperties: Record<string, unknown>;
+    createdAt: number;
+    modifiedAt: number;
+    importedAt: number;
+    thumbnail?: AssetThumbnail;
+    thumbnailGenerating?: boolean;
+    usageCount: number;
+    lastUsedAt: number | null;
+    folderId: string;
+    dependencies: AssetDependency[];
+    dependents: string[];
+    isFavorite: boolean;
+    color?: string;
+    notes?: string;
+    importSettings?: Record<string, unknown>;
+}
+export interface AssetFolder {
+    id: string;
+    name: string;
+    path: string;
+    parentId: string | null;
+    color?: string;
+    icon?: string;
+    expanded: boolean;
+    children: string[];
+    assets: string[];
+    createdAt: number;
+    isSystem?: boolean;
+}
+export interface AssetCollection {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    color: string;
+    assetIds: string[];
+    createdAt: number;
+    isSmartCollection: boolean;
+    smartFilter?: AssetFilter;
+}
+export interface AssetFilter {
+    types?: BrowserAssetType[];
+    tags?: string[];
+    tagsMode?: 'any' | 'all';
+    search?: string;
+    searchFields?: ('name' | 'tags' | 'description' | 'path')[];
+    dateRange?: {
+        from: number;
+        to: number;
+    };
+    sizeRange?: {
+        min: number;
+        max: number;
+    };
+    favorites?: boolean;
+    recent?: boolean;
+    unused?: boolean;
+    folderId?: string;
+    includeSubfolders?: boolean;
+}
+export interface ImportOptions {
+    folder?: string;
+    generateThumbnail?: boolean;
+    thumbnailSize?: number;
+    autoTag?: boolean;
+    preserveStructure?: boolean;
+    overwriteExisting?: boolean;
+    optimize?: boolean;
+    maxImageSize?: number;
+    imageQuality?: number;
+}
+export declare const DEFAULT_IMPORT_OPTIONS: ImportOptions;
+export interface AssetBrowserConfig {
+    viewMode: AssetBrowserViewMode;
+    sortMode: AssetSortMode;
+    showHiddenFiles: boolean;
+    showSystemFolders: boolean;
+    thumbnailSize: 'small' | 'medium' | 'large';
+    showDetails: boolean;
+    groupByType: boolean;
+    recentCount: number;
+    importOptions: ImportOptions;
+}
+export declare const DEFAULT_BROWSER_CONFIG: AssetBrowserConfig;
+export declare class ThumbnailGenerator {
+    private canvas;
+    private ctx;
+    private audioContext;
+    constructor();
+    generateThumbnail(file: File | Blob, type: BrowserAssetType, size?: number): Promise<AssetThumbnail | null>;
+    private generateImageThumbnail;
+    private generateAudioThumbnail;
+    private generateVideoThumbnail;
+    private generateModelThumbnail;
+    private generateMaterialThumbnail;
+    private generateShaderThumbnail;
+    private generateScriptThumbnail;
+    private generateSceneThumbnail;
+    private generatePrefabThumbnail;
+    private generateFontThumbnail;
+    private generateParticleThumbnail;
+    private generateJsonThumbnail;
+    private generateGenericThumbnail;
+    private drawCheckerboard;
+    private drawPlayIcon;
+    private formatDuration;
+}
+export declare class AssetBrowser {
+    private config;
+    private assets;
+    private folders;
+    private collections;
+    private blobStore;
+    private thumbnailGenerator;
+    private currentFolderId;
+    private selectedIds;
+    private recentAssetIds;
+    private allTags;
+    private onChange?;
+    private onSelectionChange?;
+    private onAssetOpen?;
+    constructor(config?: Partial<AssetBrowserConfig>);
+    private createDefaultCollections;
+    setConfig(config: Partial<AssetBrowserConfig>): void;
+    getConfig(): AssetBrowserConfig;
+    importFiles(files: FileList | File[], options?: ImportOptions): Promise<BrowserAsset[]>;
+    importFile(file: File, options?: ImportOptions): Promise<BrowserAsset | null>;
+    private inferAssetType;
+    private autoGenerateTags;
+    private findOrCreateFolder;
+    private getFolderPath;
+    getAsset(id: string): BrowserAsset | undefined;
+    getAssetBlob(id: string): Blob | undefined;
+    getAllAssets(): BrowserAsset[];
+    getFilteredAssets(filter: AssetFilter): BrowserAsset[];
+    private matchesFilter;
+    getSortedAssets(assets: BrowserAsset[], sortMode?: AssetSortMode): BrowserAsset[];
+    toggleFavorite(assetId: string): void;
+    getFavorites(): BrowserAsset[];
+    markAsUsed(assetId: string): void;
+    getRecentAssets(): BrowserAsset[];
+    getAllTags(): string[];
+    addTag(assetId: string, tag: string): void;
+    removeTag(assetId: string, tag: string): void;
+    getFolder(id: string): AssetFolder | undefined;
+    getRootFolder(): AssetFolder;
+    createFolder(name: string, parentId?: string): AssetFolder;
+    setCurrentFolder(folderId: string): void;
+    getCurrentFolder(): AssetFolder;
+    getCollection(id: string): AssetCollection | undefined;
+    getAllCollections(): AssetCollection[];
+    createCollection(name: string, description?: string): AssetCollection;
+    addToCollection(collectionId: string, assetId: string): void;
+    removeFromCollection(collectionId: string, assetId: string): void;
+    select(assetId: string, addToSelection?: boolean): void;
+    deselect(assetId: string): void;
+    clearSelection(): void;
+    getSelectedAssets(): BrowserAsset[];
+    updateAsset(assetId: string, updates: Partial<BrowserAsset>): void;
+    deleteAsset(assetId: string): void;
+    exportAssetMetadata(): string;
+    importAssetMetadata(json: string): void;
+    setOnChange(callback: () => void): void;
+    setOnSelectionChange(callback: (ids: string[]) => void): void;
+    setOnAssetOpen(callback: (asset: BrowserAsset) => void): void;
+    openAsset(assetId: string): void;
+    formatFileSize(bytes: number): string;
+    getAssetTypeIcon(type: BrowserAssetType): string;
+}
+export declare function createAssetBrowser(config?: Partial<AssetBrowserConfig>): AssetBrowser;
+export declare function createThumbnailGenerator(): ThumbnailGenerator;

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

@@ -1,5 +1,5 @@
-import type { AssetType, AssetManifest } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { AssetType, AssetManifest } from '../core/types';
 import type { World } from '../ecs/World';
 export interface AssetMetadata {
     id: string;

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

@@ -0,0 +1,190 @@
+/**
+ * @file ConsolePro.ts
+ * @description Advanced Console System with filtering and object inspection
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Log levels (info, warn, error, debug, verbose, custom)
+ * - Stack trace capture
+ * - Object inspection/serialization
+ * - Filtering by level, tag, regex
+ * - Search within logs
+ * - Log groups (collapsible)
+ * - Console commands with auto-complete
+ * - Expression evaluation
+ * - Watch expressions
+ * - Export logs
+ * - Log persistence
+ */
+export type LogLevel = 'verbose' | 'debug' | 'info' | 'warn' | 'error' | 'assert' | 'custom';
+export type LogIcon = 'none' | 'info' | 'warn' | 'error' | 'debug' | 'success' | 'failure' | 'network' | 'system';
+export interface StackFrame {
+    functionName: string;
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+    source: string;
+}
+export interface InspectedValue {
+    type: 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'object' | 'array' | 'function' | 'symbol' | 'bigint' | 'date' | 'regexp' | 'error' | 'map' | 'set' | 'promise' | 'dom';
+    preview: string;
+    value?: unknown;
+    expandable: boolean;
+    children?: InspectedProperty[];
+    className?: string;
+}
+export interface InspectedProperty {
+    name: string;
+    value: InspectedValue;
+    enumerable: boolean;
+    configurable: boolean;
+    writable: boolean;
+    isGetter: boolean;
+    isSetter: boolean;
+}
+export interface LogEntry {
+    id: string;
+    level: LogLevel;
+    icon: LogIcon;
+    timestamp: number;
+    message: string;
+    formattedMessage?: string;
+    values: InspectedValue[];
+    tags: string[];
+    source?: string;
+    stackTrace?: StackFrame[];
+    count: number;
+    groupId?: string;
+    isGroupStart?: boolean;
+    isGroupEnd?: boolean;
+    isGroupCollapsed?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface LogGroup {
+    id: string;
+    label: string;
+    collapsed: boolean;
+    entries: LogEntry[];
+    parent?: string;
+    depth: number;
+}
+export interface ConsoleCommand {
+    name: string;
+    description: string;
+    usage: string;
+    examples: string[];
+    execute: (args: string[], console: ConsolePro) => string | void | Promise<string | void>;
+    autocomplete?: (partial: string, args: string[]) => string[];
+}
+export interface WatchExpression {
+    id: string;
+    expression: string;
+    lastValue: InspectedValue | null;
+    lastError: string | null;
+    breakOnChange: boolean;
+}
+export interface ConsoleProConfig {
+    maxEntries: number;
+    showTimestamps: boolean;
+    showSource: boolean;
+    captureStackTrace: boolean;
+    stackTraceDepth: number;
+    collapseRepeated: boolean;
+    preserveLog: boolean;
+    autoScroll: boolean;
+    wordWrap: boolean;
+    showIcons: boolean;
+    timestampFormat: 'absolute' | 'relative' | 'both';
+    defaultLevelFilter: LogLevel[];
+    defaultTagFilter: string[];
+    enableCommands: boolean;
+    commandPrefix: string;
+}
+export declare const DEFAULT_CONSOLE_CONFIG: ConsoleProConfig;
+export declare function inspectValue(value: unknown, depth?: number, maxDepth?: number): InspectedValue;
+export declare function captureStackTrace(depth?: number): StackFrame[];
+export declare class ConsolePro {
+    private config;
+    private entries;
+    private groups;
+    private currentGroupId;
+    private groupStack;
+    private commands;
+    private watchExpressions;
+    private lastEntryHash;
+    private onEntryAdded?;
+    private onChange?;
+    private onClear?;
+    private levelFilter;
+    private tagFilter;
+    private searchFilter;
+    private regexFilter;
+    private evalContext;
+    constructor(config?: Partial<ConsoleProConfig>);
+    setConfig(config: Partial<ConsoleProConfig>): void;
+    getConfig(): ConsoleProConfig;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    verbose(...args: unknown[]): void;
+    assert(condition: boolean, ...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    network(...args: unknown[]): void;
+    system(...args: unknown[]): void;
+    /**
+     * Log with tags for filtering
+     */
+    tagged(tags: string[], ...args: unknown[]): void;
+    group(label: string): void;
+    groupCollapsed(label: string): void;
+    groupEnd(): void;
+    toggleGroupCollapse(groupId: string): void;
+    table(data: unknown, columns?: string[]): void;
+    private timers;
+    time(label?: string): void;
+    timeLog(label?: string, ...args: unknown[]): void;
+    timeEnd(label?: string): void;
+    private counters;
+    count(label?: string): void;
+    countReset(label?: string): void;
+    clear(): void;
+    private addEntry;
+    private createEntry;
+    private pushEntry;
+    private computeEntryHash;
+    setLevelFilter(levels: LogLevel[]): void;
+    toggleLevelFilter(level: LogLevel): void;
+    setTagFilter(tags: string[]): void;
+    setSearchFilter(search: string): void;
+    setRegexFilter(pattern: string | null): void;
+    getFilteredEntries(): LogEntry[];
+    getAllEntries(): ReadonlyArray<LogEntry>;
+    getEntry(id: string): LogEntry | undefined;
+    getStats(): {
+        total: number;
+        byLevel: Record<LogLevel, number>;
+    };
+    registerCommand(command: ConsoleCommand): void;
+    unregisterCommand(name: string): void;
+    getCommands(): Map<string, ConsoleCommand>;
+    executeCommand(input: string): Promise<string | void>;
+    getAutocomplete(input: string): string[];
+    private registerBuiltInCommands;
+    setEvalContext(context: Record<string, unknown>): void;
+    addToEvalContext(key: string, value: unknown): void;
+    evaluate(expression: string): string | void;
+    addWatchExpression(expression: string, breakOnChange?: boolean): void;
+    removeWatchExpression(expression: string): void;
+    getWatchExpressions(): WatchExpression[];
+    updateWatchExpressions(): void;
+    exportLogs(): string;
+    importLogs(json: string): void;
+    setOnEntryAdded(callback: (entry: LogEntry) => void): void;
+    setOnChange(callback: () => void): void;
+    setOnClear(callback: () => void): void;
+    formatTimestamp(timestamp: number): string;
+}
+export declare function createConsolePro(config?: Partial<ConsoleProConfig>): ConsolePro;
+export declare function createGlobalConsole(config?: Partial<ConsoleProConfig>): ConsolePro;

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

@@ -0,0 +1,222 @@
+/**
+ * @file CraftingEditor.ts
+ * @description Visual Crafting Recipe Editor system
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Recipe definition with ingredients
+ * - Crafting stations/workbenches
+ * - Recipe categories and discovery
+ * - Skill requirements
+ * - Recipe variants and tiers
+ * - Crafting time and progress
+ * - By-products and waste
+ * - Recipe chains
+ * - Salvaging/recycling
+ * - Quality system
+ */
+export type CraftingCategory = 'smithing' | 'alchemy' | 'cooking' | 'tailoring' | 'woodworking' | 'engineering' | 'enchanting' | 'jewelcrafting' | 'inscription' | 'brewing' | 'construction' | 'custom';
+export type RecipeQuality = 'poor' | 'normal' | 'fine' | 'superior' | 'masterwork' | 'legendary';
+export type DiscoveryMethod = 'known' | 'purchased' | 'found' | 'taught' | 'researched' | 'achievement' | 'quest' | 'reputation';
+export interface CraftingIngredient {
+    itemId: string;
+    amount: number;
+    isConsumed: boolean;
+    quality?: RecipeQuality;
+    alternativeIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface CraftingOutput {
+    itemId: string;
+    minAmount: number;
+    maxAmount: number;
+    chance: number;
+    quality?: RecipeQuality;
+    bonusFromSkill?: number;
+}
+export interface CraftingRequirement {
+    type: 'skill' | 'level' | 'station' | 'tool' | 'buff' | 'time' | 'location' | 'custom';
+    target: string;
+    value: number | string;
+    description?: string;
+}
+export interface CraftingStation {
+    id: string;
+    name: string;
+    description: string;
+    categories: CraftingCategory[];
+    tier: number;
+    upgradeFrom?: string;
+    icon?: string;
+    modelId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface Recipe {
+    id: string;
+    name: string;
+    description: string;
+    category: CraftingCategory;
+    ingredients: CraftingIngredient[];
+    outputs: CraftingOutput[];
+    byproducts?: CraftingOutput[];
+    waste?: CraftingOutput[];
+    requirements: CraftingRequirement[];
+    stationId?: string;
+    skillId?: string;
+    skillRequired: number;
+    craftingTime: number;
+    experienceGained: number;
+    isStackable: boolean;
+    maxBatch: number;
+    discoveryMethod: DiscoveryMethod;
+    discoveredBy: Set<string>;
+    tier: number;
+    previousTier?: string;
+    nextTier?: string;
+    variants?: string[];
+    baseQuality: RecipeQuality;
+    qualityFactors: QualityFactor[];
+    icon?: string;
+    color?: string;
+    tags: string[];
+    isFavorite: boolean;
+    createdAt: number;
+    modifiedAt: number;
+    version: number;
+}
+export interface QualityFactor {
+    type: 'skill' | 'tool' | 'ingredient' | 'station' | 'buff' | 'random';
+    weight: number;
+    description?: string;
+}
+export interface RecipeChain {
+    id: string;
+    name: string;
+    description: string;
+    recipeIds: string[];
+    automatable: boolean;
+}
+export interface SalvageRule {
+    sourceItemId: string;
+    outputs: CraftingOutput[];
+    skillRequired?: number;
+    toolRequired?: string;
+    preserveEnchantments: boolean;
+}
+export interface CraftingProgress {
+    id: string;
+    recipeId: string;
+    playerId: string;
+    startedAt: number;
+    completesAt: number;
+    quantity: number;
+    isPaused: boolean;
+    pausedAt?: number;
+    accumulatedTime: number;
+    stationId?: string;
+    cancelled: boolean;
+}
+export interface CraftingQueueItem {
+    recipeId: string;
+    quantity: number;
+    priority: number;
+}
+export declare class CraftingEditor {
+    private recipes;
+    private stations;
+    private chains;
+    private salvageRules;
+    private activeProgress;
+    private craftingQueues;
+    private playerSkills;
+    private playerInventory;
+    private discoveredRecipes;
+    private onRecipeDiscovered?;
+    private onCraftingStarted?;
+    private onCraftingProgress?;
+    private onCraftingCompleted?;
+    private onCraftingFailed?;
+    private onQualityDetermined?;
+    private onExperienceGained?;
+    createRecipe(name: string, category: CraftingCategory): Recipe;
+    getRecipe(id: string): Recipe | undefined;
+    updateRecipe(id: string, updates: Partial<Recipe>): boolean;
+    deleteRecipe(id: string): boolean;
+    getAllRecipes(): Recipe[];
+    getRecipesByCategory(category: CraftingCategory): Recipe[];
+    addIngredient(recipeId: string, itemId: string, amount: number, isConsumed?: boolean): boolean;
+    removeIngredient(recipeId: string, index: number): boolean;
+    setIngredientAlternatives(recipeId: string, ingredientIndex: number, alternativeIds: string[]): boolean;
+    addOutput(recipeId: string, itemId: string, minAmount: number, maxAmount?: number, chance?: number): boolean;
+    addByproduct(recipeId: string, itemId: string, chance: number, amount?: number): boolean;
+    addRequirement(recipeId: string, type: CraftingRequirement['type'], target: string, value: number | string, description?: string): boolean;
+    createStation(name: string, categories: CraftingCategory[]): CraftingStation;
+    getStation(id: string): CraftingStation | undefined;
+    getAllStations(): CraftingStation[];
+    getStationsForCategory(category: CraftingCategory): CraftingStation[];
+    createChain(name: string): RecipeChain;
+    addRecipeToChain(chainId: string, recipeId: string): boolean;
+    createSalvageRule(sourceItemId: string): SalvageRule;
+    addSalvageOutput(sourceItemId: string, outputItemId: string, chance: number, amount?: number): boolean;
+    getAvailableRecipes(playerId: string, stationId?: string): Recipe[];
+    canCraft(recipeId: string, playerId: string, quantity?: number): {
+        canCraft: boolean;
+        reason?: string;
+    };
+    private checkRequirement;
+    startCrafting(recipeId: string, playerId: string, quantity?: number): CraftingProgress | null;
+    updateCraftingProgress(_deltaTime: number): void;
+    private completeCrafting;
+    private determineQuality;
+    pauseCrafting(progressId: string): boolean;
+    resumeCrafting(progressId: string): boolean;
+    cancelCrafting(progressId: string, refundIngredients?: boolean): boolean;
+    addToQueue(playerId: string, recipeId: string, quantity: number, priority?: number): boolean;
+    getQueue(playerId: string): CraftingQueueItem[];
+    processQueueItem(playerId: string): CraftingProgress | null;
+    discoverRecipe(recipeId: string, playerId: string): boolean;
+    isRecipeDiscovered(recipeId: string): boolean;
+    canSalvage(itemId: string, playerId: string): boolean;
+    salvageItem(itemId: string, _playerId: string, quantity?: number): CraftingOutput[] | null;
+    setPlayerSkill(skillId: string, level: number): void;
+    setPlayerItem(itemId: string, count: number): void;
+    getPlayerInventory(): Map<string, number>;
+    setOnRecipeDiscovered(callback: (recipe: Recipe, playerId: string) => void): void;
+    setOnCraftingStarted(callback: (progress: CraftingProgress) => void): void;
+    setOnCraftingProgress(callback: (progress: CraftingProgress, percent: number) => void): void;
+    setOnCraftingCompleted(callback: (recipe: Recipe, outputs: CraftingOutput[], quality: RecipeQuality) => void): void;
+    setOnCraftingFailed(callback: (recipe: Recipe, reason: string) => void): void;
+    setOnQualityDetermined(callback: (recipe: Recipe, quality: RecipeQuality, factors: string[]) => void): void;
+    setOnExperienceGained(callback: (skillId: string, amount: number) => void): void;
+    getActiveProgress(): CraftingProgress[];
+    getProgressForPlayer(playerId: string): CraftingProgress[];
+    searchRecipes(query: string): Recipe[];
+    getRecipesByTags(tags: string[]): Recipe[];
+    exportRecipes(): string;
+    importRecipes(json: string): boolean;
+    exportProgress(): string;
+    importProgress(json: string): boolean;
+    getRecipeGraph(recipeId: string): RecipeGraph | null;
+}
+export interface RecipeGraph {
+    nodes: RecipeGraphNode[];
+    edges: RecipeGraphEdge[];
+}
+export interface RecipeGraphNode {
+    id: string;
+    type: 'recipe' | 'ingredient' | 'output' | 'station';
+    name: string;
+    amount?: number | string;
+    x: number;
+    y: number;
+}
+export interface RecipeGraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: 'consumed' | 'catalyst' | 'produces' | 'requires';
+    chance?: number;
+}
+export declare function createCraftingEditor(): CraftingEditor;
+export declare function createIngredient(itemId: string, amount: number, isConsumed?: boolean): CraftingIngredient;
+export declare function createOutput(itemId: string, amount: number, chance?: number): CraftingOutput;