@nice2dev/game-engine 0.1.0 → 1.0.2

package/dist/types/dialogue/DialogueSystem.d.ts

@@ -0,0 +1,326 @@
+import type { Vec2 } from '../core/types';
+import { EventBus } from '../core/EventBus';
+import React from 'react';
+/** Dialogue node types */
+export type DialogueNodeType = 'start' | 'text' | 'choice' | 'branch' | 'set_variable' | 'check_variable' | 'event' | 'random' | 'end';
+/** Variable types supported in dialogues */
+export type DialogueVarType = 'boolean' | 'number' | 'string';
+/** Comparison operators for conditions */
+export type ComparisonOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'contains' | 'startsWith' | 'endsWith';
+/** Character emotion types */
+export type EmotionType = 'neutral' | 'happy' | 'sad' | 'angry' | 'surprised' | 'scared' | 'disgusted' | 'confused' | 'thoughtful' | 'excited' | 'tired' | 'love' | 'custom';
+/** Text effect types */
+export type TextEffectType = 'none' | 'typewriter' | 'shake' | 'wave' | 'rainbow' | 'fade';
+export interface DialogueVariable {
+    id: string;
+    name: string;
+    type: DialogueVarType;
+    defaultValue: boolean | number | string;
+    description?: string;
+    persistent?: boolean;
+    scope: 'conversation' | 'global';
+}
+export interface VariableCondition {
+    variableId: string;
+    operator: ComparisonOp;
+    value: boolean | number | string;
+}
+export interface DialogueCharacter {
+    id: string;
+    name: string;
+    displayName: string;
+    /** Portrait images per emotion */
+    portraits: Record<EmotionType, string>;
+    voiceId?: string;
+    defaultEmotion: EmotionType;
+    textColor?: string;
+    nameColor?: string;
+    textSpeed?: number;
+}
+export interface DialogueNodeBase {
+    id: string;
+    type: DialogueNodeType;
+    position: Vec2;
+    comment?: string;
+    tags?: string[];
+}
+export interface StartNode extends DialogueNodeBase {
+    type: 'start';
+    label: string;
+    nextNode: string | null;
+}
+export interface TextNode extends DialogueNodeBase {
+    type: 'text';
+    characterId: string;
+    text: string;
+    emotion?: EmotionType;
+    textEffect?: TextEffectType;
+    audioClip?: string;
+    duration?: number;
+    nextNode: string | null;
+}
+export interface ChoiceOption {
+    id: string;
+    text: string;
+    nextNode: string | null;
+    conditions?: VariableCondition[];
+    /** Variables to set when this choice is selected */
+    setVariables?: {
+        variableId: string;
+        value: boolean | number | string;
+    }[];
+    disabled?: boolean;
+    tooltip?: string;
+}
+export interface ChoiceNode extends DialogueNodeBase {
+    type: 'choice';
+    characterId?: string;
+    prompt?: string;
+    options: ChoiceOption[];
+    timeout?: number;
+    defaultOption?: string;
+}
+export interface BranchNode extends DialogueNodeBase {
+    type: 'branch';
+    conditions: VariableCondition[];
+    /** AND or OR logic for multiple conditions */
+    logic: 'and' | 'or';
+    trueNode: string | null;
+    falseNode: string | null;
+}
+export interface SetVariableNode extends DialogueNodeBase {
+    type: 'set_variable';
+    variableId: string;
+    operation: 'set' | 'add' | 'subtract' | 'multiply' | 'toggle' | 'append';
+    value: boolean | number | string;
+    nextNode: string | null;
+}
+export interface CheckVariableNode extends DialogueNodeBase {
+    type: 'check_variable';
+    conditions: VariableCondition[];
+    logic: 'and' | 'or';
+    trueNode: string | null;
+    falseNode: string | null;
+}
+export interface EventNode extends DialogueNodeBase {
+    type: 'event';
+    eventType: string;
+    eventData: Record<string, unknown>;
+    nextNode: string | null;
+}
+export interface RandomNode extends DialogueNodeBase {
+    type: 'random';
+    outputs: {
+        id: string;
+        weight: number;
+        nextNode: string | null;
+    }[];
+}
+export interface EndNode extends DialogueNodeBase {
+    type: 'end';
+    result?: 'success' | 'failure' | 'neutral';
+    setVariables?: {
+        variableId: string;
+        value: boolean | number | string;
+    }[];
+}
+export type DialogueNode = StartNode | TextNode | ChoiceNode | BranchNode | SetVariableNode | CheckVariableNode | EventNode | RandomNode | EndNode;
+export interface DialogueTree {
+    id: string;
+    name: string;
+    description?: string;
+    version: string;
+    characters: DialogueCharacter[];
+    variables: DialogueVariable[];
+    nodes: DialogueNode[];
+    startNodeId: string;
+    metadata: {
+        author?: string;
+        created: string;
+        modified: string;
+        tags?: string[];
+        locale: string;
+    };
+}
+export interface DialogueState {
+    treeId: string;
+    currentNodeId: string | null;
+    variables: Record<string, boolean | number | string>;
+    history: string[];
+    choicesMade: {
+        nodeId: string;
+        optionId: string;
+        timestamp: number;
+    }[];
+    startTime: number;
+    isActive: boolean;
+    isPaused: boolean;
+}
+export type DialogueEventType = 'dialogue:started' | 'dialogue:ended' | 'dialogue:node-entered' | 'dialogue:text-displayed' | 'dialogue:choice-selected' | 'dialogue:variable-changed' | 'dialogue:event-triggered' | 'dialogue:paused' | 'dialogue:resumed';
+export interface DialogueEvent {
+    type: DialogueEventType;
+    treeId: string;
+    nodeId?: string;
+    data?: unknown;
+    timestamp: number;
+}
+export declare class DialogueEngine {
+    private trees;
+    private globalVariables;
+    private currentState;
+    private events;
+    private onTextCallback?;
+    private onChoiceCallback?;
+    private onEndCallback?;
+    constructor(events?: EventBus);
+    registerTree(tree: DialogueTree): void;
+    unregisterTree(treeId: string): void;
+    getTree(treeId: string): DialogueTree | undefined;
+    getAllTrees(): DialogueTree[];
+    setGlobalVariable(name: string, value: boolean | number | string): void;
+    getGlobalVariable(name: string): boolean | number | string | undefined;
+    getVariable(variableId: string): boolean | number | string | undefined;
+    private setVariable;
+    startDialogue(treeId: string, startLabel?: string): boolean;
+    endDialogue(): void;
+    pauseDialogue(): void;
+    resumeDialogue(): void;
+    getState(): DialogueState | null;
+    isActive(): boolean;
+    private goToNode;
+    private processNode;
+    private processTextNode;
+    private processChoiceNode;
+    private processBranchNode;
+    private processSetVariableNode;
+    private processEventNode;
+    private processRandomNode;
+    private processEndNode;
+    selectChoice(optionId: string): boolean;
+    /** Advance to next node (for text nodes) */
+    advance(): boolean;
+    private evaluateConditions;
+    private evaluateCondition;
+    onText(callback: (node: TextNode, character: DialogueCharacter) => void): void;
+    onChoice(callback: (node: ChoiceNode, options: ChoiceOption[]) => void): void;
+    onEnd(callback: (node: EndNode, state: DialogueState) => void): void;
+    private emitEvent;
+    subscribe(eventType: DialogueEventType, handler: (event: DialogueEvent) => void): () => void;
+}
+export declare class DialogueTreeBuilder {
+    private tree;
+    private nodeCounter;
+    constructor(id: string, name: string);
+    private generateId;
+    description(desc: string): this;
+    author(author: string): this;
+    locale(locale: string): this;
+    tags(tags: string[]): this;
+    addCharacter(character: DialogueCharacter): this;
+    addVariable(variable: DialogueVariable): this;
+    boolVar(id: string, name: string, defaultValue?: boolean, scope?: 'conversation' | 'global'): this;
+    numVar(id: string, name: string, defaultValue?: number, scope?: 'conversation' | 'global'): this;
+    strVar(id: string, name: string, defaultValue?: string, scope?: 'conversation' | 'global'): this;
+    addStart(label: string, nextNode?: string | null, position?: Vec2): this;
+    addText(characterId: string, text: string, nextNode?: string | null, options?: Partial<Omit<TextNode, 'id' | 'type' | 'characterId' | 'text' | 'nextNode'>>): this;
+    addChoice(options: ChoiceOption[], settings?: Partial<Omit<ChoiceNode, 'id' | 'type' | 'options'>>): this;
+    addBranch(conditions: VariableCondition[], trueNode: string | null, falseNode: string | null, logic?: 'and' | 'or', position?: Vec2): this;
+    addSetVariable(variableId: string, operation: SetVariableNode['operation'], value: boolean | number | string, nextNode?: string | null, position?: Vec2): this;
+    addEvent(eventType: string, eventData: Record<string, unknown>, nextNode?: string | null, position?: Vec2): this;
+    addRandom(outputs: {
+        weight: number;
+        nextNode: string | null;
+    }[], position?: Vec2): this;
+    addEnd(result?: EndNode['result'], setVariables?: EndNode['setVariables'], position?: Vec2): this;
+    build(): DialogueTree;
+    /** Get the ID of the last added node */
+    lastNodeId(): string;
+    /** Get node by index (1-based for readability) */
+    nodeId(index: number): string;
+}
+export interface DialogueBoxProps {
+    /** The text to display */
+    text: string;
+    /** Character name */
+    characterName?: string;
+    /** Character portrait URL */
+    portrait?: string;
+    /** Emotion for styling */
+    emotion?: EmotionType;
+    /** Text effect */
+    textEffect?: TextEffectType;
+    /** Characters per second for typewriter effect */
+    textSpeed?: number;
+    /** Called when text fully displayed */
+    onComplete?: () => void;
+    /** Called when user clicks to advance */
+    onAdvance?: () => void;
+    /** Custom styles */
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * React hook for typewriter text effect
+ */
+export declare function useTypewriter(text: string, speed?: number, enabled?: boolean): {
+    displayedText: string;
+    isComplete: boolean;
+    skip: () => void;
+};
+/**
+ * DialogueBox component for displaying dialogue text
+ */
+export declare const DialogueBox: React.FC<DialogueBoxProps>;
+export interface ChoiceListProps {
+    /** Available choices */
+    options: ChoiceOption[];
+    /** Prompt text */
+    prompt?: string;
+    /** Called when a choice is selected */
+    onSelect: (optionId: string) => void;
+    /** Timeout in ms (optional) */
+    timeout?: number;
+    /** Custom styles */
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * ChoiceList component for displaying dialogue choices
+ */
+export declare const ChoiceList: React.FC<ChoiceListProps>;
+/**
+ * Serialize dialogue tree to JSON string
+ */
+export declare function serializeDialogueTree(tree: DialogueTree): string;
+/**
+ * Deserialize dialogue tree from JSON string
+ */
+export declare function deserializeDialogueTree(json: string): DialogueTree;
+/**
+ * Validate dialogue tree structure
+ */
+export declare function validateDialogueTree(tree: unknown): DialogueTree;
+/**
+ * Find unreachable nodes in dialogue tree
+ */
+export declare function findUnreachableNodes(tree: DialogueTree): string[];
+export interface DialogueLocalization {
+    treeId: string;
+    locale: string;
+    texts: Record<string, string>;
+    characterNames: Record<string, string>;
+}
+/**
+ * Extract all translatable strings from a dialogue tree
+ */
+export declare function extractTranslatableStrings(tree: DialogueTree): {
+    nodeTexts: Record<string, string>;
+    characterNames: Record<string, string>;
+};
+/**
+ * Apply localization to a dialogue tree (creates a copy)
+ */
+export declare function applyLocalization(tree: DialogueTree, localization: DialogueLocalization): DialogueTree;
+export declare const DEFAULT_TEXT_SPEED = 50;
+export declare const EMOTION_COLORS: Record<EmotionType, string>;
+export declare function createEmptyDialogueTree(id: string, name: string): DialogueTree;

package/dist/types/dialogue/index.d.ts

@@ -0,0 +1,2 @@
+export { DialogueEngine, DialogueTreeBuilder, DialogueBox, ChoiceList, useTypewriter, serializeDialogueTree, deserializeDialogueTree, validateDialogueTree, findUnreachableNodes, extractTranslatableStrings, applyLocalization, DEFAULT_TEXT_SPEED, EMOTION_COLORS, createEmptyDialogueTree, } from './DialogueSystem';
+export type { DialogueNodeType, DialogueNode, DialogueNodeBase, StartNode, TextNode, ChoiceNode, ChoiceOption, BranchNode, SetVariableNode, CheckVariableNode, EventNode, RandomNode, EndNode, DialogueVarType, DialogueVariable, VariableCondition, ComparisonOp, DialogueCharacter, EmotionType, TextEffectType, DialogueTree, DialogueState, DialogueEventType, DialogueEvent, DialogueLocalization, DialogueBoxProps, ChoiceListProps, } from './DialogueSystem';

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

@@ -1,7 +1,7 @@
 import React from 'react';
 import type { GameProject, EntityId } from '../core/types';
 import { EventBus } from '../core/EventBus';
-import { World } from '../ecs/World';
+import { World, type ComponentMap } from '../ecs/World';
 import { SceneManager } from '../scene/SceneManager';
 export interface UndoEntry {
     description: string;
@@ -94,6 +94,12 @@ type EditorAction = {
 } | {
     type: 'MARK_CLEAN';
 };
+export interface ConsoleEntry {
+    id: number;
+    level: 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+}
 export interface EditorContextValue {
     state: EditorState;
     dispatch: React.Dispatch<EditorAction>;
@@ -101,6 +107,11 @@ export interface EditorContextValue {
     undoStack: UndoStack;
     sceneManager: SceneManager;
     events: EventBus;
+    worldVersion: number;
+    refreshWorld: () => void;
+    createNewEntity: (name: string, components?: (keyof ComponentMap)[]) => number;
+    consoleLogs: ConsoleEntry[];
+    addLog: (level: ConsoleEntry['level'], message: string) => void;
 }
 export declare function useEditor(): EditorContextValue;
 export declare function serializeProject(project: GameProject): string;

package/dist/types/engine/SaveSystemV2.d.ts

@@ -0,0 +1,155 @@
+import { EventBus } from '../core/EventBus';
+export type SaveSlotType = 'manual' | 'auto' | 'checkpoint' | 'quick';
+export type SaveConflictStrategy = 'local-wins' | 'remote-wins' | 'newest-wins' | 'merge' | 'prompt-user';
+export type SaveStorageBackend = 'indexeddb' | 'localstorage' | 'filesystem' | 'cloud';
+export type MigrationDirection = 'up' | 'down';
+export interface SaveSlotMeta {
+    slotId: string;
+    type: SaveSlotType;
+    label: string;
+    schemaVersion: number;
+    createdAt: number;
+    updatedAt: number;
+    playtimeMs: number;
+    /** Scene/level the player was in */
+    location: string;
+    /** Preview thumbnail (data URL) */
+    thumbnail?: string;
+    /** Compressed size in bytes */
+    sizeBytes: number;
+    /** CRC32 checksum */
+    checksum: number;
+    /** Cloud sync status */
+    cloudSynced: boolean;
+    cloudTimestamp?: number;
+    /** Custom tags for filtering */
+    tags: string[];
+}
+export interface SaveData {
+    meta: SaveSlotMeta;
+    payload: Record<string, unknown>;
+}
+export interface SaveMigration {
+    fromVersion: number;
+    toVersion: number;
+    description: string;
+    /** Transform the payload from one version to the next */
+    migrate: (payload: Record<string, unknown>) => Record<string, unknown>;
+    /** Optional rollback */
+    rollback?: (payload: Record<string, unknown>) => Record<string, unknown>;
+}
+export interface CloudSyncConfig {
+    enabled: boolean;
+    endpoint?: string;
+    apiKey?: string;
+    conflictStrategy: SaveConflictStrategy;
+    syncIntervalMs: number;
+    maxCloudSlots: number;
+}
+export interface AutoSaveConfig {
+    enabled: boolean;
+    intervalMs: number;
+    maxAutoSaves: number;
+    /** Only auto-save when game state is "safe" (not in combat, etc.) */
+    requireSafeState: boolean;
+}
+export interface SaveSystemConfig {
+    schemaVersion: number;
+    storageBackend: SaveStorageBackend;
+    storageKey: string;
+    maxSlots: number;
+    compressionEnabled: boolean;
+    autoSave: AutoSaveConfig;
+    cloud: CloudSyncConfig;
+}
+export declare const DEFAULT_SAVE_CONFIG: SaveSystemConfig;
+export interface SaveConflict {
+    slotId: string;
+    localMeta: SaveSlotMeta;
+    remoteMeta: SaveSlotMeta;
+    resolvedWith?: SaveConflictStrategy;
+}
+export interface SaveResult {
+    success: boolean;
+    slotId: string;
+    sizeBytes: number;
+    compressed: boolean;
+    error?: string;
+}
+/** Simple compression for JSON save data (dictionary-based) */
+export declare function compressSaveData(json: string): Uint8Array;
+/** Decompress save data */
+export declare function decompressSaveData(data: Uint8Array): string;
+export declare function crc32(data: Uint8Array): number;
+export declare class MigrationEngine {
+    private migrations;
+    register(migration: SaveMigration): void;
+    /** Migrate payload from fromVersion to toVersion */
+    migrate(payload: Record<string, unknown>, fromVersion: number, toVersion: number): {
+        payload: Record<string, unknown>;
+        applied: string[];
+    };
+    getRegistered(): readonly SaveMigration[];
+    canMigrate(from: number, to: number): boolean;
+}
+export declare class SaveSystemV2 {
+    private config;
+    private migrationEngine;
+    private eventBus;
+    private slots;
+    private autoSaveTimer;
+    private autoSaveCounter;
+    private safeToSave;
+    constructor(eventBus: EventBus, config?: Partial<SaveSystemConfig>);
+    private setupEventHandlers;
+    /** Register a schema migration */
+    registerMigration(migration: SaveMigration): void;
+    /** Save game state to a slot */
+    save(slotId: string, payload: Record<string, unknown>, options?: {
+        type?: SaveSlotType;
+        label?: string;
+        location?: string;
+        thumbnail?: string;
+        tags?: string[];
+    }): SaveResult;
+    /** Load game state from a slot */
+    load(slotId: string): {
+        payload: Record<string, unknown>;
+        meta: SaveSlotMeta;
+        migrated: boolean;
+    } | null;
+    /** Delete a save slot */
+    delete(slotId: string): boolean;
+    /** List all save slot metadata (sorted by updatedAt desc) */
+    listSlots(): SaveSlotMeta[];
+    /** Get slot metadata without loading payload */
+    getSlotMeta(slotId: string): SaveSlotMeta | null;
+    /** Check if a slot exists */
+    hasSlot(slotId: string): boolean;
+    /** Start auto-save timer */
+    startAutoSave(getPayload: () => Record<string, unknown>, getLocation: () => string): void;
+    /** Stop auto-save */
+    stopAutoSave(): void;
+    /** Quick save (overwriting the single quick save slot) */
+    quickSave(payload: Record<string, unknown>, location: string): SaveResult;
+    /** Quick load */
+    quickLoad(): ReturnType<SaveSystemV2['load']>;
+    /** Sync local saves to cloud (stub — needs actual endpoint) */
+    syncToCloud(): Promise<{
+        synced: string[];
+        conflicts: SaveConflict[];
+    }>;
+    /** Resolve a cloud sync conflict */
+    resolveConflict(conflict: SaveConflict, strategy: SaveConflictStrategy): SaveSlotMeta;
+    private persistSlot;
+    private removeFromStorage;
+    /** Load all slots from storage backend */
+    loadFromStorage(): Promise<number>;
+    /** Export all saves as a downloadable blob */
+    exportAll(): Blob;
+    /** Import saves from a blob */
+    importAll(blob: Blob): Promise<number>;
+    getConfig(): Readonly<SaveSystemConfig>;
+    getMigrationEngine(): MigrationEngine;
+    destroy(): void;
+}

package/dist/types/index.d.ts

@@ -8,7 +8,7 @@ export { v2 } from './core/math';
 export { World, System, createDefaultComponent, } from './ecs/World';
 export type { Entity, ComponentMap, BuiltInComponent, TransformComponent, SpriteComponent, ShapeComponent, Collider2DComponent, RigidBody2DComponent, TextComponent, AnimatorComponent, ScriptComponent, AudioSourceComponent, ParticleEmitterComponent, CameraTargetComponent, SpriteAnimation, AnimationFrame, } from './ecs/World';
 export { InputManager, PRESET_PLATFORMER, PRESET_TOPDOWN, PRESET_TWIN_STICK } from './input/InputManager';
-export { GamepadNavigationProvider, useGamepadNavigation } from './input/GamepadNavigation';
+export { GamepadNavigationProvider as NiceGamepadNavigationProvider, GamepadNavigationProvider, useGamepadNavigation } from './input/GamepadNavigation';
 export type { FocusableMeta, GamepadNavigationContextType } from './input/GamepadNavigation';
 export { useGamepads, useGamepadEdges } from './input/useGamepads';
 export type { GamepadSnapshot } from './input/useGamepads';
@@ -18,13 +18,13 @@ export { Renderer2D, RenderSystem } from './rendering/Renderer2D';
 export { PhysicsEngine2D, PhysicsSystem } from './physics/PhysicsEngine2D';
 export { SceneManager } from './scene/SceneManager';
 export type { SceneConfig, SceneTransition, TransitionType, PrefabDef } from './scene/SceneManager';
-export { GameUI } from './ui/GameUI';
+export { GameUI as NiceGameUI, GameUI } from './ui/GameUI';
 export type { UIElement, UIStyle, UITheme, UIAnchor, UIElementType } from './ui/GameUI';
 export { PlayerManager, SplitScreenManager, PLAYER_COLORS } from './multiplayer/LocalMultiplayer';
 export type { Player, Viewport } from './multiplayer/LocalMultiplayer';
 export { GameRegistry, gameRegistry, MINI_PLAYER_COLORS, MINI_PLAYER_NAMES, KEYBOARD_GROUPS, DIR_UP, DIR_DOWN, DIR_LEFT, DIR_RIGHT, } from './multiplayer/MiniGameTypes';
 export type { PlayerSlot, InputSource, Dir, KeyboardGroup, MiniGameMeta, MiniGameConfig, } from './multiplayer/MiniGameTypes';
-export { SeededRandom, PerlinNoise, WaveGenerator, LootTable, ProceduralSprite } from './procedural/Procedural';
+export { SeededRandom, PerlinNoise, WaveGenerator, LootTable as ProceduralLootTable, ProceduralSprite } from './procedural/Procedural';
 export type { WaveEntry, WaveConfig, LootDrop } from './procedural/Procedural';
 export { NiceGameEngine } from './engine/NiceGameEngine';
 export type { EngineOptions } from './engine/NiceGameEngine';
@@ -60,6 +60,8 @@ export { DEFAULT_MATCH3_CONFIG, createMatch3Board, findMatches, removeMatches, a
 export type { Match3Config, GemType, Match3Board, BlockPuzzleConfig, BlockPuzzleState, PhysicsPuzzleConfig, PuzzleLevelDef, HiddenObjectConfig, HiddenObjectDef, HiddenObjectLevel, CardDef, DeckConfig, } from './templates/PuzzleTemplates';
 export { DEFAULT_RPG_CONFIG, xpForLevel, createInventory, addItem, DEFAULT_VISUAL_NOVEL_CONFIG, parseVNLabels, createVNState, DEFAULT_POINT_AND_CLICK_CONFIG, DEFAULT_ROGUELIKE_CONFIG, generateDungeon, computeFOV, DEFAULT_DUNGEON_CRAWLER_CONFIG, } from './templates/RPGTemplates';
 export type { RPGConfig, RPGStats, RPGCharacter, StatusEffect, ItemDef, Inventory, VisualNovelConfig, VNCommandType, VNCommand, VNChoice, VNScript, VNState, PointAndClickConfig, Hotspot, RoomDef, RoguelikeConfig, TileType, DungeonRoom, DungeonCrawlerConfig, DungeonFloorDef, } from './templates/RPGTemplates';
+export { InventoryManager, InventoryProvider, useInventoryManager, useContainer, useEquipment, } from './inventory/InventorySystem';
+export type { ItemRarity, ItemCategory, EquipmentSlot, StatType, ContainerType, StatModifier, ItemDefinition, ItemInstance, InventorySlot, Container, EquipmentState, CraftingIngredient, CraftingRecipe, LootEntry, LootTable, ShopListing, Shop, InventoryEventType, InventoryEvent, InventoryManagerConfig, InventorySnapshot, } from './inventory/InventorySystem';
 export { DEFAULT_TOP_DOWN_RACING_CONFIG, createRacerState, updateRacer, DEFAULT_SIDE_SCROLLER_RACING_CONFIG, DEFAULT_SOCCER_CONFIG, DEFAULT_BASKETBALL_CONFIG, createSportsState, DEFAULT_GOLF_CONFIG, DEFAULT_BILLIARDS_CONFIG, updateBilliardsBalls, DEFAULT_RHYTHM_CONFIG, createRhythmState, judgeHit, applyHitResult, } from './templates/SportsTemplates';
 export type { TopDownRacingConfig, RacerState, TrackCheckpoint, SideScrollerRacingConfig, SportType, SportsConfig, SportsState, GolfConfig, BilliardsConfig, BilliardsBall, RhythmConfig, NoteType, RhythmNote, RhythmChart, RhythmState, } from './templates/SportsTemplates';
 export { DEFAULT_TOWER_DEFENSE_CONFIG, createTDState, DEFAULT_RTS_CONFIG, createRTSState, DEFAULT_TACTICS_CONFIG, createTurnOrder, nextUnit, DEFAULT_CITY_BUILDER_CONFIG, createCityState, updateCity, DEFAULT_IDLE_CONFIG, createIdleState, getGeneratorCost, getIdleIncome, formatNumber, } from './templates/StrategyTemplates';
@@ -125,3 +127,17 @@ export { GuidedWizard, BlockEditor, KID_BLOCK_PALETTES, } from './kids/KidTools'
 export type { WizardChoice, WizardStep, WizardResult, BlockShape, DragBlock, BlockPalette, DragDropState, } from './kids/KidTools';
 export { BenchmarkRunner, BUILTIN_BENCHMARKS, } from './performance/BenchmarkSuite';
 export type { BenchmarkScenario, BenchmarkTimings, BenchmarkMemory, BenchmarkResult as BenchmarkScenarioResult, BenchmarkReport, RegressionResult, } from './performance/BenchmarkSuite';
+export { iconToSvgString, svgToDataUrl, loadSvgImage, rasterizeSvg, getIconTextureId, registerIconTexture, registerIconCanvasTexture, createIconEntity, createIconAnimationClip, CHARACTER_ANIMATION_STATES, OBJECT_ANIMATION_STATES, registerIconAnimationSet, createIconAnimator, registerIconCatalog, } from './integration/IconSprite';
+export type { IconComponent, IconComponentProps, IconSpriteOptions, IconEntityOptions, IconAnimationFrame, IconAnimationSheetOptions, IconCatalogEntry, } from './integration/IconSprite';
+export { STANDARD_VERTEX_LAYOUT, INSTANCE_LAYOUT, DEFAULT_PBR, DEFAULT_RENDER_CONFIG, GPUResourceTracker, RenderPipelineManager, WebGPURenderer, PostProcessStack, BLOOM_DEFAULTS, FXAA_DEFAULTS, SSAO_DEFAULTS, DOF_DEFAULTS, COLOR_GRADING_DEFAULTS, QUALITY_PRESET_CONFIGS, applyQualityPreset, } from './rendering/WebGPURenderPipeline';
+export type { GPUTextureFormatType, GPUBlendModeType, ToneMappingMode, MaterialType, RenderPassType, LightCategory, PostEffectType, VertexAttribute, VertexBufferLayout, GPUTextureRef, PBRMaterial, UnlitMaterial, SpriteMaterial, CustomMaterial, RenderMaterial, GPULight, RenderBatch, ClusteredLightConfig, ShadowConfig, PostProcessConfig, PostEffectSettings, WebGPURenderConfig, GPUResourceHandle, GPUStats, RenderPassDescriptor, WebGPURendererState, PostProcessPass, QualityPreset, } from './rendering/WebGPURenderPipeline';
+export { AudioBusMixer, SFXPool, MusicManager, GameAudioBridge, useGameAudio, GameAudioSettings, DEFAULT_SPATIAL, } from './audio/AudioBridge';
+export type { AudioBusType, SpatialModel, AudioPoolStrategy, AudioBusConfig, AudioEffectNode, SpatialAudioConfig, AudioPoolConfig, GameAudioEvent, MusicTrack, MusicCrossfadeConfig, AdaptiveAudioRule, AudioSnapshot, GameAudioSettingsProps, } from './audio/AudioBridge';
+export { DialogueEngine, DialogueTreeBuilder, useTypewriter, DialogueBox, ChoiceList, serializeDialogueTree, deserializeDialogueTree, validateDialogueTree, findUnreachableNodes, extractTranslatableStrings, applyLocalization, DEFAULT_TEXT_SPEED, EMOTION_COLORS, createEmptyDialogueTree, } from './dialogue/DialogueSystem';
+export type { DialogueNodeType, DialogueVarType, ComparisonOp, EmotionType, TextEffectType, DialogueVariable, VariableCondition, DialogueCharacter, DialogueNodeBase, StartNode, TextNode, ChoiceOption, ChoiceNode, BranchNode, SetVariableNode, CheckVariableNode, EventNode, RandomNode, EndNode, DialogueNode, DialogueTree, } from './dialogue/DialogueSystem';
+export { QuestManager, QuestBuilder, QuestList, QuestTracker, createEmptyQuest, DIFFICULTY_COLORS, DIFFICULTY_XP_MULTIPLIERS, } from './quest/QuestSystem';
+export type { QuestType, QuestStatus, QuestDifficulty, QuestPrerequisite, Quest, QuestState as QuestSystemState, QuestJournal as QuestSystemJournal, QuestEventType, QuestEvent, QuestListProps, QuestTrackerProps, RewardType as QuestRewardType, } from './quest/QuestSystem';
+export { compressSaveData, decompressSaveData, crc32, MigrationEngine, SaveSystemV2, DEFAULT_SAVE_CONFIG, } from './engine/SaveSystemV2';
+export type { SaveSlotType, SaveConflictStrategy, SaveStorageBackend, MigrationDirection, SaveSlotMeta, SaveData, SaveMigration, CloudSyncConfig, AutoSaveConfig, SaveSystemConfig, SaveConflict, SaveResult, } from './engine/SaveSystemV2';
+export { TelemetryPipeline, HeatmapGenerator, SessionRecorder, SessionPlayer, FunnelTracker, GameplayAnalytics, useGameplayAnalytics, AnalyticsDashboard, DEFAULT_TELEMETRY_CONFIG, DEFAULT_HEATMAP_CONFIG, DEFAULT_RECORDING_CONFIG, } from './devtools/GameplayAnalytics';
+export type { TelemetryEventCategory, HeatmapType, SessionEventType, TelemetryEvent, TelemetryConfig, HeatmapConfig, HeatmapCell, SessionFrame, SessionRecordedEvent, SessionRecording, SessionRecordingConfig, FunnelStep, FunnelDefinition, AnalyticsDashboardProps, } from './devtools/GameplayAnalytics';