@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,168 @@
+/**
+ * @file PrefabSystem.ts
+ * @description Advanced Prefab System with nested prefabs, variants, override tracking
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Prefab definition and instantiation
+ * - Nested prefabs (prefabs containing other prefabs)
+ * - Prefab variants (inherited modifications)
+ * - Override tracking (property-level changes)
+ * - Apply/revert overrides
+ * - Prefab linking (maintain connection to source)
+ * - Unpack prefab (break connection)
+ * - Auto-update instances when prefab changes
+ * - Serialization/deserialization
+ * - Prefab comparison (diff)
+ */
+export type PropertyPath = string;
+export interface PropertyOverride {
+    path: PropertyPath;
+    originalValue: unknown;
+    overridenValue: unknown;
+    overrideType: 'modify' | 'add' | 'remove';
+    timestamp: number;
+}
+export interface ComponentData {
+    type: string;
+    properties: Record<string, unknown>;
+    enabled: boolean;
+    id: string;
+}
+export interface PrefabEntity {
+    id: string;
+    name: string;
+    parentId: string | null;
+    transform: TransformData;
+    components: ComponentData[];
+    children: string[];
+    tags: string[];
+    layer: string;
+    active: boolean;
+}
+export interface TransformData {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface PrefabData {
+    id: string;
+    name: string;
+    description: string;
+    version: number;
+    createdAt: number;
+    modifiedAt: number;
+    author: string;
+    rootEntity: PrefabEntity;
+    entities: Map<string, PrefabEntity>;
+    nestedPrefabs: NestedPrefabReference[];
+    variantOf?: string;
+    inheritedOverrides?: PropertyOverride[];
+    tags: string[];
+    category: string;
+    thumbnail?: string;
+}
+export interface NestedPrefabReference {
+    instanceId: string;
+    prefabId: string;
+    parentEntityId: string;
+    overrides: PropertyOverride[];
+    transform: TransformData;
+}
+export interface PrefabInstance {
+    id: string;
+    prefabId: string;
+    name: string;
+    overrides: PropertyOverride[];
+    worldTransform: TransformData;
+    nestedInstances: Map<string, PrefabInstance>;
+    isLinked: boolean;
+    unpackedAt?: number;
+    createdAt: number;
+    lastSyncedAt: number;
+}
+export interface PrefabDiff {
+    added: PropertyPath[];
+    removed: PropertyPath[];
+    modified: {
+        path: PropertyPath;
+        oldValue: unknown;
+        newValue: unknown;
+    }[];
+    componentAdded: string[];
+    componentRemoved: string[];
+    entityAdded: string[];
+    entityRemoved: string[];
+}
+export declare const DEFAULT_TRANSFORM: TransformData;
+export declare class PrefabManager {
+    private prefabs;
+    private instances;
+    private prefabVersions;
+    private onPrefabChanged?;
+    private onInstanceChanged?;
+    createPrefab(name: string, rootEntity?: Partial<PrefabEntity>): PrefabData;
+    createPrefabFromEntities(name: string, entities: PrefabEntity[]): PrefabData;
+    createVariant(basePrefabId: string, name: string): PrefabData | null;
+    getBasePrefab(variantId: string): PrefabData | null;
+    applyVariantOverrides(variantId: string): void;
+    addNestedPrefab(parentPrefabId: string, nestedPrefabId: string, parentEntityId: string, transform?: Partial<TransformData>): NestedPrefabReference | null;
+    removeNestedPrefab(parentPrefabId: string, instanceId: string): boolean;
+    private hasCircularReference;
+    instantiate(prefabId: string, worldTransform?: Partial<TransformData>): PrefabInstance | null;
+    destroyInstance(instanceId: string): boolean;
+    setOverride(instanceId: string, path: PropertyPath, value: unknown): void;
+    removeOverride(instanceId: string, path: PropertyPath): void;
+    revertAllOverrides(instanceId: string): void;
+    applyOverridesToPrefab(instanceId: string): void;
+    hasOverrides(instanceId: string): boolean;
+    getOverrides(instanceId: string): PropertyOverride[];
+    private getOriginalValue;
+    private findEntityByPathRoot;
+    private getRelativePropertyPath;
+    unlinkInstance(instanceId: string): void;
+    relinkInstance(instanceId: string): boolean;
+    syncInstance(instanceId: string): void;
+    syncAllInstances(prefabId: string): void;
+    private updatePrefabVersion;
+    addEntity(prefabId: string, entity: Partial<PrefabEntity>, parentId?: string): PrefabEntity | null;
+    removeEntity(prefabId: string, entityId: string): boolean;
+    addComponent(prefabId: string, entityId: string, component: Partial<ComponentData>): ComponentData | null;
+    removeComponent(prefabId: string, entityId: string, componentId: string): boolean;
+    comparePrefabs(prefabIdA: string, prefabIdB: string): PrefabDiff | null;
+    compareInstanceToPrefab(instanceId: string): PrefabDiff | null;
+    private compareEntities;
+    private compareProperty;
+    serializePrefab(prefabId: string): string | null;
+    deserializePrefab(json: string): PrefabData | null;
+    serializeInstance(instanceId: string): string | null;
+    deserializeInstance(json: string): PrefabInstance | null;
+    getPrefab(prefabId: string): PrefabData | undefined;
+    getInstance(instanceId: string): PrefabInstance | undefined;
+    getAllPrefabs(): PrefabData[];
+    getAllInstances(): PrefabInstance[];
+    getInstancesOfPrefab(prefabId: string): PrefabInstance[];
+    searchPrefabs(query: string): PrefabData[];
+    getPrefabsByCategory(category: string): PrefabData[];
+    getCategories(): string[];
+    setOnPrefabChanged(callback: (prefabId: string) => void): void;
+    setOnInstanceChanged(callback: (instanceId: string) => void): void;
+    deletePrefab(prefabId: string): boolean;
+    clear(): void;
+}
+export declare function createPrefabManager(): PrefabManager;
+export declare function createDefaultEntity(name?: string): PrefabEntity;
+export declare function createComponent(type: string, properties?: Record<string, unknown>): ComponentData;

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

@@ -0,0 +1,192 @@
+/**
+ * @file ProfilerPanel.ts
+ * @description Advanced Profiler Panel System for Editor
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - CPU profiling with hierarchical flame graph
+ * - GPU timing (WebGL/WebGPU)
+ * - Memory tracking (JS heap, textures, buffers)
+ * - Frame timeline visualization
+ * - System breakdown
+ * - Custom markers/regions
+ * - Export/import profiler data
+ * - Real-time graphs
+ */
+export type ProfilerCategory = 'scripts' | 'physics' | 'rendering' | 'animation' | 'audio' | 'ai' | 'networking' | 'loading' | 'gc' | 'vsync' | 'other';
+export interface ProfilerMarker {
+    id: string;
+    name: string;
+    category: ProfilerCategory;
+    color: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    depth: number;
+    children: ProfilerMarker[];
+    metadata?: Record<string, unknown>;
+}
+export interface GPUTimerQuery {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+}
+export interface MemorySnapshot {
+    timestamp: number;
+    jsHeapUsed: number;
+    jsHeapTotal: number;
+    jsHeapLimit: number;
+    externalMemory: number;
+    arrayBuffers: number;
+    gpuTextures: number;
+    gpuBuffers: number;
+    gpuShaders: number;
+    gpuRenderTargets: number;
+    allocations: number;
+    deallocations: number;
+    gcCollections: number;
+}
+export interface ProfilerFrame {
+    frameNumber: number;
+    timestamp: number;
+    deltaTime: number;
+    cpuTime: number;
+    gpuTime: number;
+    waitTime: number;
+    markers: ProfilerMarker[];
+    gpuQueries: GPUTimerQuery[];
+    memory: MemorySnapshot;
+    systemTimes: Map<string, number>;
+    drawCalls: number;
+    triangles: number;
+    vertices: number;
+    setPassCalls: number;
+    batchCount: number;
+    shadowCasters: number;
+    visibleObjects: number;
+}
+export interface ProfilerStats {
+    avgFrameTime: number;
+    avgCPUTime: number;
+    avgGPUTime: number;
+    avgFPS: number;
+    minFPS: number;
+    maxFPS: number;
+    frame1Percent: number;
+    frame01Percent: number;
+    avgMemory: number;
+    peakMemory: number;
+    memoryGrowthRate: number;
+    avgDrawCalls: number;
+    avgBatches: number;
+    avgTriangles: number;
+    avgSetPassCalls: number;
+}
+export declare const CATEGORY_COLORS: Record<ProfilerCategory, string>;
+export interface ProfilerConfig {
+    enabled: boolean;
+    deepProfiling: boolean;
+    gpuProfiling: boolean;
+    memoryProfiling: boolean;
+    maxFrames: number;
+    sampleInterval: number;
+    recordAllocations: boolean;
+    categorize: boolean;
+    autoCapture: boolean;
+    captureThreshold: number;
+}
+export declare const DEFAULT_PROFILER_CONFIG: ProfilerConfig;
+export interface GraphPoint {
+    x: number;
+    y: number;
+    label?: string;
+}
+export interface GraphSeries {
+    name: string;
+    color: string;
+    data: GraphPoint[];
+    minValue: number;
+    maxValue: number;
+    avgValue: number;
+}
+export interface ProfilerGraph {
+    title: string;
+    yAxisLabel: string;
+    yAxisUnit: string;
+    series: GraphSeries[];
+    targetLine?: number;
+    warningLine?: number;
+}
+export declare class ProfilerPanel {
+    private config;
+    private frames;
+    private currentFrame;
+    private markerStack;
+    private pendingGPUQueries;
+    private frameNumber;
+    private lastFrameTimestamp;
+    private isRecording;
+    private capturedFrames;
+    private lastMemory;
+    private allocationCounter;
+    private deallocationCounter;
+    private gcCounter;
+    private gl;
+    private gpuTimerExtension;
+    private activeGPUQueries;
+    private renderStats;
+    private onFrameComplete?;
+    private onSlowFrame?;
+    constructor(config?: Partial<ProfilerConfig>);
+    setConfig(config: Partial<ProfilerConfig>): void;
+    getConfig(): ProfilerConfig;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    initializeGPU(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    beginFrame(): void;
+    endFrame(): void;
+    beginMarker(name: string, category?: ProfilerCategory): void;
+    endMarker(): void;
+    /** Convenience method to wrap a function with profiling */
+    profile<T>(name: string, category: ProfilerCategory, fn: () => T): T;
+    /** Async version of profile */
+    profileAsync<T>(name: string, category: ProfilerCategory, fn: () => Promise<T>): Promise<T>;
+    recordSystemTime(systemName: string, time: number): void;
+    addDrawCall(triangles: number, vertices: number): void;
+    addBatch(): void;
+    addSetPassCall(): void;
+    setVisibleObjects(count: number): void;
+    setShadowCasters(count: number): void;
+    beginGPUQuery(name: string): void;
+    endGPUQuery(name: string): void;
+    private collectGPUQueries;
+    private captureMemory;
+    trackAllocation(bytes: number): void;
+    trackDeallocation(bytes: number): void;
+    setGPUMemory(textures: number, buffers: number, shaders: number, renderTargets: number): void;
+    startRecording(): void;
+    stopRecording(): ProfilerFrame[];
+    clearRecording(): void;
+    isRecordingActive(): boolean;
+    getFrames(): ReadonlyArray<ProfilerFrame>;
+    getLastFrame(): ProfilerFrame | null;
+    getFrame(index: number): ProfilerFrame | null;
+    getFrameRange(start: number, end: number): ProfilerFrame[];
+    getCapturedFrames(): ReadonlyArray<ProfilerFrame>;
+    getStats(frameCount?: number): ProfilerStats;
+    getFrameTimeGraph(frameCount?: number): ProfilerGraph;
+    getMemoryGraph(frameCount?: number): ProfilerGraph;
+    getRenderingGraph(frameCount?: number): ProfilerGraph;
+    getFlameGraph(frame: ProfilerFrame): ProfilerMarker[];
+    getSystemBreakdown(frameCount?: number): Map<string, number>;
+    exportData(): string;
+    importData(json: string): void;
+    setOnFrameComplete(callback: (frame: ProfilerFrame) => void): void;
+    setOnSlowFrame(callback: (frame: ProfilerFrame) => void): void;
+    clear(): void;
+}
+export declare function createProfilerPanel(config?: Partial<ProfilerConfig>): ProfilerPanel;
+export declare function generateStatsOverlay(panel: ProfilerPanel): string[];

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

@@ -0,0 +1,252 @@
+/**
+ * @file QuestEditor.ts
+ * @description Quest Editor system with quest graphs, conditions, and rewards
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Quest definition with stages
+ * - Objectives (kill, collect, talk, explore, escort, etc.)
+ * - Conditions and prerequisites
+ * - Rewards (items, experience, reputation, unlocks)
+ * - Quest chains and branching paths
+ * - Time limits and failures
+ * - Quest tracking and progress
+ * - Journal/log system
+ * - Localization support
+ */
+export type QuestStatus = 'locked' | 'available' | 'active' | 'completed' | 'failed' | 'abandoned';
+export type ObjectiveType = 'kill' | 'collect' | 'talk' | 'interact' | 'explore' | 'escort' | 'deliver' | 'craft' | 'survive' | 'reach' | 'protect' | 'use' | 'custom';
+export type RewardType = 'item' | 'currency' | 'experience' | 'reputation' | 'skill' | 'unlock' | 'quest' | 'achievement' | 'custom';
+export type ConditionType = 'level' | 'quest' | 'item' | 'stat' | 'reputation' | 'skill' | 'flag' | 'time' | 'location' | 'custom';
+export interface LocalizedString {
+    key: string;
+    default: string;
+    translations: Map<string, string>;
+}
+export interface QuestCondition {
+    type: ConditionType;
+    target: string;
+    operator: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'has' | 'not_has';
+    value: string | number | boolean;
+    description?: LocalizedString;
+}
+export interface QuestReward {
+    type: RewardType;
+    target: string;
+    amount: number;
+    description?: LocalizedString;
+    chance?: number;
+    isHidden?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface QuestObjective {
+    id: string;
+    type: ObjectiveType;
+    description: LocalizedString;
+    target: string;
+    targetAmount: number;
+    currentAmount: number;
+    isOptional: boolean;
+    isHidden: boolean;
+    isCompleted: boolean;
+    trackingHint?: LocalizedString;
+    markerLocation?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    markerIcon?: string;
+    requiresObjectives?: string[];
+    rewards?: QuestReward[];
+    metadata?: Record<string, unknown>;
+}
+export interface QuestStage {
+    id: string;
+    name: LocalizedString;
+    description: LocalizedString;
+    objectives: QuestObjective[];
+    stageRewards?: QuestReward[];
+    nextStageId?: string;
+    branchConditions?: QuestStageBranch[];
+    onEnterDialogueId?: string;
+    onCompleteDialogueId?: string;
+    onEnterActions?: QuestAction[];
+    onCompleteActions?: QuestAction[];
+    timeLimit?: number;
+    onTimeoutStageId?: string;
+    onTimeoutActions?: QuestAction[];
+}
+export interface QuestStageBranch {
+    condition: QuestCondition;
+    targetStageId: string;
+}
+export interface QuestAction {
+    type: 'setFlag' | 'removeFlag' | 'giveItem' | 'removeItem' | 'teleport' | 'spawn' | 'dialogue' | 'cutscene' | 'custom';
+    target: string;
+    params?: Record<string, unknown>;
+}
+export interface Quest {
+    id: string;
+    name: LocalizedString;
+    description: LocalizedString;
+    shortDescription?: LocalizedString;
+    category: string;
+    tags: string[];
+    icon?: string;
+    color?: string;
+    priority: number;
+    isMainQuest: boolean;
+    isSideQuest: boolean;
+    isDailyQuest: boolean;
+    isRepeatable: boolean;
+    repeatCooldown?: number;
+    recommendedLevel?: number;
+    minLevel?: number;
+    maxLevel?: number;
+    prerequisites: QuestCondition[];
+    stages: Map<string, QuestStage>;
+    startStageId: string;
+    rewards: QuestReward[];
+    chainId?: string;
+    chainOrder?: number;
+    conflictingQuests?: string[];
+    requiredQuests?: string[];
+    questGiverId?: string;
+    questTurnInId?: string;
+    availableFrom?: number;
+    availableUntil?: number;
+    createdAt: number;
+    modifiedAt: number;
+    version: number;
+}
+export interface QuestChain {
+    id: string;
+    name: LocalizedString;
+    description: LocalizedString;
+    questIds: string[];
+    rewards?: QuestReward[];
+}
+export interface QuestProgress {
+    questId: string;
+    status: QuestStatus;
+    currentStageId: string;
+    objectiveProgress: Map<string, number>;
+    startedAt: number;
+    completedAt?: number;
+    failedAt?: number;
+    stageStartedAt: number;
+    flags: Set<string>;
+}
+export interface JournalEntry {
+    id: string;
+    questId: string;
+    stageId?: string;
+    objectiveId?: string;
+    type: 'start' | 'update' | 'complete' | 'fail' | 'reward' | 'note';
+    text: LocalizedString;
+    timestamp: number;
+    isRead: boolean;
+}
+export declare class QuestManager {
+    private quests;
+    private chains;
+    private activeProgress;
+    private completedQuests;
+    private journal;
+    private currentLanguage;
+    private playerLevel;
+    private playerFlags;
+    private playerStats;
+    private playerItems;
+    private playerReputation;
+    private onQuestAvailable?;
+    private onQuestStarted?;
+    private onQuestUpdated?;
+    private onQuestCompleted?;
+    private onQuestFailed?;
+    private onObjectiveUpdated?;
+    private onJournalEntry?;
+    private onReward?;
+    private customConditionEvaluator?;
+    private customActionExecutor?;
+    createQuest(name: string, description: string): Quest;
+    getQuest(id: string): Quest | undefined;
+    deleteQuest(id: string): boolean;
+    getAllQuests(): Quest[];
+    createStage(name: string, description: string): QuestStage;
+    addStage(questId: string, stage: QuestStage): boolean;
+    updateStage(questId: string, stageId: string, updates: Partial<QuestStage>): boolean;
+    connectStages(questId: string, fromStageId: string, toStageId: string, condition?: QuestCondition): boolean;
+    createObjective(type: ObjectiveType, description: string, target: string, amount?: number): QuestObjective;
+    addObjective(questId: string, stageId: string, objective: QuestObjective): boolean;
+    createReward(type: RewardType, target: string, amount: number): QuestReward;
+    addQuestReward(questId: string, reward: QuestReward): boolean;
+    addStageReward(questId: string, stageId: string, reward: QuestReward): boolean;
+    createChain(name: string, description: string): QuestChain;
+    addQuestToChain(chainId: string, questId: string): boolean;
+    getAvailableQuests(): Quest[];
+    isQuestAvailable(quest: Quest): boolean;
+    startQuest(questId: string): boolean;
+    updateObjective(questId: string, objectiveId: string, amount?: number): boolean;
+    private checkStageCompletion;
+    private advanceToStage;
+    completeQuest(questId: string): void;
+    failQuest(questId: string, reason?: string): void;
+    abandonQuest(questId: string): boolean;
+    private checkChainCompletion;
+    private evaluateCondition;
+    private executeAction;
+    private giveReward;
+    private addJournalEntry;
+    getJournal(questId?: string): JournalEntry[];
+    markJournalRead(entryId: string): void;
+    setPlayerLevel(level: number): void;
+    setPlayerFlag(flag: string, value?: boolean): void;
+    setPlayerStat(stat: string, value: number): void;
+    setPlayerItem(item: string, count: number): void;
+    setPlayerReputation(faction: string, value: number): void;
+    createLocalizedString(text: string): LocalizedString;
+    getString(ls: LocalizedString, language?: string): string;
+    setLanguage(language: string): void;
+    setOnQuestAvailable(callback: (quest: Quest) => void): void;
+    setOnQuestStarted(callback: (quest: Quest, progress: QuestProgress) => void): void;
+    setOnQuestUpdated(callback: (quest: Quest, progress: QuestProgress) => void): void;
+    setOnQuestCompleted(callback: (quest: Quest, rewards: QuestReward[]) => void): void;
+    setOnQuestFailed(callback: (quest: Quest) => void): void;
+    setOnObjectiveUpdated(callback: (quest: Quest, objective: QuestObjective) => void): void;
+    setOnJournalEntry(callback: (entry: JournalEntry) => void): void;
+    setOnReward(callback: (reward: QuestReward) => void): void;
+    setCustomConditionEvaluator(evaluator: (condition: QuestCondition) => boolean): void;
+    setCustomActionExecutor(executor: (action: QuestAction) => void): void;
+    getActiveQuests(): Quest[];
+    getQuestProgress(questId: string): QuestProgress | undefined;
+    isQuestActive(questId: string): boolean;
+    isQuestCompleted(questId: string): boolean;
+    getQuestsByCategory(category: string): Quest[];
+    getQuestChain(chainId: string): QuestChain | undefined;
+    exportQuest(questId: string): string | null;
+    importQuest(json: string): Quest | null;
+    exportProgress(): string;
+    importProgress(json: string): boolean;
+    getQuestGraph(questId: string): {
+        nodes: QuestGraphNode[];
+        edges: QuestGraphEdge[];
+    } | null;
+}
+export interface QuestGraphNode {
+    id: string;
+    name: string;
+    type: 'stage';
+    objectiveCount: number;
+    x: number;
+    y: number;
+}
+export interface QuestGraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: 'default' | 'conditional';
+    label?: string;
+}
+export declare function createQuestManager(): QuestManager;
+export declare function createQuestCondition(type: ConditionType, target: string, operator: QuestCondition['operator'], value: string | number | boolean): QuestCondition;