@nice2dev/game-engine 1.0.4 → 1.0.10

package/dist/cjs/editor/DialogueSystem.js

@@ -0,0 +1,924 @@
+'use strict';
+
+/**
+ * @file DialogueSystem.ts
+ * @description Branching Dialogue System with localization support
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Dialogue nodes and connections
+ * - Branching conversations
+ * - Conditions for dialogue options
+ * - Variables and state tracking
+ * - Localization support (multiple languages)
+ * - Character/speaker definitions
+ * - Emotions/expressions
+ * - Voice line references
+ * - Custom commands/events
+ * - Import/Export (JSON, Ink, Yarn)
+ * - Dialogue preview/testing
+ */
+// ============================================================
+// Dialogue Manager
+// ============================================================
+class DialogueManager {
+    constructor() {
+        this.trees = new Map();
+        this.speakers = new Map();
+        this.emotions = new Map();
+        this.currentState = null;
+        this.currentLanguage = 'en';
+    }
+    // ─── Tree Management ───────────────────────────────────
+    createTree(name, defaultLanguage = 'en') {
+        const startNode = {
+            id: 'start',
+            type: 'start',
+            name: 'Start',
+            position: { x: 100, y: 100 },
+        };
+        const tree = {
+            id: `dialogue_${Date.now()}`,
+            name,
+            description: '',
+            version: 1,
+            nodes: new Map([['start', startNode]]),
+            startNodeId: 'start',
+            speakers: new Map(),
+            variables: new Map(),
+            flags: new Set(),
+            defaultLanguage,
+            supportedLanguages: [defaultLanguage],
+            tags: [],
+            createdAt: Date.now(),
+            modifiedAt: Date.now(),
+        };
+        this.trees.set(tree.id, tree);
+        return tree;
+    }
+    getTree(id) {
+        return this.trees.get(id);
+    }
+    deleteTree(id) {
+        return this.trees.delete(id);
+    }
+    // ─── Node Management ───────────────────────────────────
+    addNode(treeId, node) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return null;
+        }
+        const fullNode = {
+            id: `node_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            type: node.type ?? 'dialogue',
+            name: node.name ?? 'New Node',
+            position: node.position ?? { x: 200, y: 200 },
+            lines: node.lines,
+            choices: node.choices,
+            nextNodeId: node.nextNodeId,
+            condition: node.condition,
+            randomWeights: node.randomWeights,
+            entryActions: node.entryActions,
+            exitActions: node.exitActions,
+            tags: node.tags,
+            notes: node.notes,
+            color: node.color,
+        };
+        tree.nodes.set(fullNode.id, fullNode);
+        tree.modifiedAt = Date.now();
+        return fullNode;
+    }
+    updateNode(treeId, nodeId, updates) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return false;
+        }
+        const node = tree.nodes.get(nodeId);
+        if (!node) {
+            return false;
+        }
+        Object.assign(node, updates);
+        tree.modifiedAt = Date.now();
+        return true;
+    }
+    deleteNode(treeId, nodeId) {
+        const tree = this.trees.get(treeId);
+        if (!tree || nodeId === tree.startNodeId) {
+            return false;
+        }
+        // Remove references to this node
+        for (const node of tree.nodes.values()) {
+            if (node.nextNodeId === nodeId) {
+                node.nextNodeId = undefined;
+            }
+            if (node.choices) {
+                node.choices = node.choices.filter((c) => c.targetNodeId !== nodeId);
+            }
+        }
+        tree.nodes.delete(nodeId);
+        tree.modifiedAt = Date.now();
+        return true;
+    }
+    connectNodes(treeId, fromNodeId, toNodeId, choiceId) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return false;
+        }
+        const fromNode = tree.nodes.get(fromNodeId);
+        const toNode = tree.nodes.get(toNodeId);
+        if (!fromNode || !toNode) {
+            return false;
+        }
+        if (choiceId && fromNode.choices) {
+            const choice = fromNode.choices.find((c) => c.id === choiceId);
+            if (choice) {
+                choice.targetNodeId = toNodeId;
+            }
+        }
+        else {
+            fromNode.nextNodeId = toNodeId;
+        }
+        tree.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Dialogue Line Management ──────────────────────────
+    addLine(treeId, nodeId, line) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return null;
+        }
+        const node = tree.nodes.get(nodeId);
+        if (!node) {
+            return null;
+        }
+        const fullLine = {
+            speakerId: line.speakerId ?? '',
+            text: line.text ?? this.createLocalizedText('', tree.defaultLanguage),
+            emotion: line.emotion,
+            voiceLine: line.voiceLine,
+            duration: line.duration,
+            animation: line.animation,
+            effects: line.effects,
+        };
+        if (!node.lines) {
+            node.lines = [];
+        }
+        node.lines.push(fullLine);
+        tree.modifiedAt = Date.now();
+        return fullLine;
+    }
+    addChoice(treeId, nodeId, choice) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return null;
+        }
+        const node = tree.nodes.get(nodeId);
+        if (!node) {
+            return null;
+        }
+        const fullChoice = {
+            id: `choice_${Date.now()}`,
+            text: choice.text ?? this.createLocalizedText('Choice', tree.defaultLanguage),
+            targetNodeId: choice.targetNodeId ?? '',
+            condition: choice.condition,
+            actions: choice.actions,
+            isDefault: choice.isDefault,
+            isHidden: choice.isHidden,
+            once: choice.once,
+            priority: choice.priority,
+            shortcut: choice.shortcut,
+        };
+        if (!node.choices) {
+            node.choices = [];
+        }
+        node.choices.push(fullChoice);
+        tree.modifiedAt = Date.now();
+        return fullChoice;
+    }
+    // ─── Speaker Management ────────────────────────────────
+    addSpeaker(treeId, speaker) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return null;
+        }
+        const fullSpeaker = {
+            id: speaker.id ?? `speaker_${Date.now()}`,
+            name: speaker.name ?? this.createLocalizedText('Speaker', tree.defaultLanguage),
+            displayName: speaker.displayName,
+            portrait: speaker.portrait,
+            color: speaker.color,
+            voiceId: speaker.voiceId,
+            tags: speaker.tags,
+        };
+        tree.speakers.set(fullSpeaker.id, fullSpeaker);
+        this.speakers.set(fullSpeaker.id, fullSpeaker);
+        tree.modifiedAt = Date.now();
+        return fullSpeaker;
+    }
+    getSpeaker(id) {
+        return this.speakers.get(id);
+    }
+    addEmotion(emotion) {
+        this.emotions.set(emotion.id, emotion);
+    }
+    getEmotion(id) {
+        return this.emotions.get(id);
+    }
+    // ─── Variable Management ───────────────────────────────
+    addVariable(treeId, variable) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return false;
+        }
+        tree.variables.set(variable.name, variable);
+        tree.modifiedAt = Date.now();
+        return true;
+    }
+    setFlag(treeId, flag, value = true) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return;
+        }
+        if (value) {
+            tree.flags.add(flag);
+        }
+        else {
+            tree.flags.delete(flag);
+        }
+        tree.modifiedAt = Date.now();
+    }
+    // ─── Localization ──────────────────────────────────────
+    createLocalizedText(defaultText, language) {
+        return {
+            key: `text_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            default: defaultText,
+            translations: new Map([[language, defaultText]]),
+        };
+    }
+    setTranslation(text, language, translation) {
+        text.translations.set(language, translation);
+    }
+    getText(text, language) {
+        const lang = language ?? this.currentLanguage;
+        return text.translations.get(lang) ?? text.default;
+    }
+    setLanguage(language) {
+        this.currentLanguage = language;
+    }
+    addLanguageSupport(treeId, language) {
+        const tree = this.trees.get(treeId);
+        if (!tree || tree.supportedLanguages.includes(language)) {
+            return false;
+        }
+        tree.supportedLanguages.push(language);
+        tree.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Runtime Dialogue ──────────────────────────────────
+    startDialogue(treeId) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return false;
+        }
+        // Initialize state
+        this.currentState = {
+            treeId,
+            currentNodeId: tree.startNodeId,
+            currentLineIndex: 0,
+            variables: new Map(),
+            flags: new Set(),
+            visitedNodes: new Set(),
+            selectedChoices: new Set(),
+            history: [],
+        };
+        // Set default variable values
+        for (const [name, variable] of tree.variables) {
+            this.currentState.variables.set(name, variable.defaultValue);
+        }
+        // Copy flags
+        for (const flag of tree.flags) {
+            this.currentState.flags.add(flag);
+        }
+        this.onDialogueStart?.(tree);
+        this.processCurrentNode();
+        return true;
+    }
+    endDialogue() {
+        if (!this.currentState) {
+            return;
+        }
+        const tree = this.trees.get(this.currentState.treeId);
+        this.currentState = null;
+        if (tree) {
+            this.onDialogueEnd?.(tree);
+        }
+    }
+    processCurrentNode() {
+        if (!this.currentState) {
+            return;
+        }
+        const tree = this.trees.get(this.currentState.treeId);
+        if (!tree) {
+            return;
+        }
+        const node = tree.nodes.get(this.currentState.currentNodeId);
+        if (!node) {
+            return;
+        }
+        // Mark as visited
+        this.currentState.visitedNodes.add(node.id);
+        // Record history
+        this.currentState.history.push({
+            nodeId: node.id,
+            timestamp: Date.now(),
+        });
+        // Execute entry actions
+        if (node.entryActions) {
+            for (const action of node.entryActions) {
+                this.executeAction(action);
+            }
+        }
+        this.onNodeEnter?.(node);
+        // Handle node by type
+        switch (node.type) {
+            case 'start':
+                this.advanceToNextNode(node);
+                break;
+            case 'dialogue':
+                this.displayDialogueLine(node);
+                break;
+            case 'choice':
+                this.displayChoices(node);
+                break;
+            case 'condition':
+                this.evaluateConditionNode(node);
+                break;
+            case 'action':
+                this.executeNodeActions(node);
+                break;
+            case 'random':
+                this.selectRandomPath(node);
+                break;
+            case 'hub':
+                this.displayChoices(node);
+                break;
+            case 'end':
+                this.endDialogue();
+                break;
+        }
+    }
+    displayDialogueLine(node) {
+        if (!this.currentState || !node.lines || node.lines.length === 0) {
+            this.advanceToNextNode(node);
+            return;
+        }
+        const line = node.lines[this.currentState.currentLineIndex];
+        if (!line) {
+            this.advanceToNextNode(node);
+            return;
+        }
+        const speaker = this.speakers.get(line.speakerId);
+        const emotion = line.emotion ? this.emotions.get(line.emotion) : undefined;
+        const renderData = {
+            speaker,
+            emotion,
+            text: this.getText(line.text),
+            isEnd: false,
+            autoAdvance: line.duration,
+        };
+        // Check if this is the last line and there are choices
+        if (this.currentState.currentLineIndex === node.lines.length - 1 &&
+            node.choices &&
+            node.choices.length > 0) {
+            renderData.choices = this.getAvailableChoices(node);
+        }
+        this.onLineDisplay?.(renderData);
+    }
+    displayChoices(node) {
+        if (!node.choices || node.choices.length === 0) {
+            this.advanceToNextNode(node);
+            return;
+        }
+        const choices = this.getAvailableChoices(node);
+        if (choices.length === 0) {
+            // No available choices, try default or end
+            const defaultChoice = node.choices.find((c) => c.isDefault);
+            if (defaultChoice) {
+                this.selectChoice(defaultChoice.id);
+            }
+            else {
+                this.endDialogue();
+            }
+            return;
+        }
+        this.onChoicesDisplay?.(choices);
+    }
+    getAvailableChoices(node) {
+        if (!node.choices || !this.currentState) {
+            return [];
+        }
+        return node.choices
+            .filter((choice) => {
+            // Check if already selected (for once choices)
+            if (choice.once && this.currentState.selectedChoices.has(choice.id)) {
+                return false;
+            }
+            // Check if hidden
+            if (choice.isHidden) {
+                return false;
+            }
+            return true;
+        })
+            .map((choice) => ({
+            id: choice.id,
+            text: this.getText(choice.text),
+            available: this.evaluateConditions(choice.condition),
+            shortcut: choice.shortcut,
+        }))
+            .sort((a, b) => {
+            const choiceA = node.choices.find((c) => c.id === a.id);
+            const choiceB = node.choices.find((c) => c.id === b.id);
+            return (choiceB?.priority ?? 0) - (choiceA?.priority ?? 0);
+        });
+    }
+    advanceLine() {
+        if (!this.currentState) {
+            return;
+        }
+        const tree = this.trees.get(this.currentState.treeId);
+        if (!tree) {
+            return;
+        }
+        const node = tree.nodes.get(this.currentState.currentNodeId);
+        if (!node || !node.lines) {
+            return;
+        }
+        this.currentState.currentLineIndex++;
+        if (this.currentState.currentLineIndex >= node.lines.length) {
+            // All lines shown, check for choices or advance
+            if (node.choices && node.choices.length > 0) {
+                this.displayChoices(node);
+            }
+            else {
+                this.advanceToNextNode(node);
+            }
+        }
+        else {
+            this.displayDialogueLine(node);
+        }
+    }
+    selectChoice(choiceId) {
+        if (!this.currentState) {
+            return;
+        }
+        const tree = this.trees.get(this.currentState.treeId);
+        if (!tree) {
+            return;
+        }
+        const node = tree.nodes.get(this.currentState.currentNodeId);
+        if (!node || !node.choices) {
+            return;
+        }
+        const choice = node.choices.find((c) => c.id === choiceId);
+        if (!choice) {
+            return;
+        }
+        // Check if choice is available
+        if (!this.evaluateConditions(choice.condition)) {
+            return;
+        }
+        // Mark as selected
+        this.currentState.selectedChoices.add(choiceId);
+        // Record in history
+        this.currentState.history.push({
+            nodeId: node.id,
+            choiceId,
+            timestamp: Date.now(),
+        });
+        // Execute choice actions
+        if (choice.actions) {
+            for (const action of choice.actions) {
+                this.executeAction(action);
+            }
+        }
+        // Navigate to target
+        if (choice.targetNodeId) {
+            this.gotoNode(choice.targetNodeId);
+        }
+    }
+    advanceToNextNode(node) {
+        // Execute exit actions
+        if (node.exitActions) {
+            for (const action of node.exitActions) {
+                this.executeAction(action);
+            }
+        }
+        if (node.nextNodeId) {
+            this.gotoNode(node.nextNodeId);
+        }
+        else {
+            this.endDialogue();
+        }
+    }
+    gotoNode(nodeId) {
+        if (!this.currentState) {
+            return;
+        }
+        this.currentState.currentNodeId = nodeId;
+        this.currentState.currentLineIndex = 0;
+        this.processCurrentNode();
+    }
+    evaluateConditionNode(node) {
+        const result = this.evaluateConditions(node.condition);
+        // For condition nodes, we need two outputs
+        // We'll use choices with conditions for this
+        if (node.choices && node.choices.length >= 2) {
+            const targetChoice = result ? node.choices[0] : node.choices[1];
+            if (targetChoice.targetNodeId) {
+                this.gotoNode(targetChoice.targetNodeId);
+                return;
+            }
+        }
+        this.advanceToNextNode(node);
+    }
+    executeNodeActions(node) {
+        // Entry actions already executed
+        this.advanceToNextNode(node);
+    }
+    selectRandomPath(node) {
+        if (!node.choices || node.choices.length === 0) {
+            this.advanceToNextNode(node);
+            return;
+        }
+        const weights = node.randomWeights ?? node.choices.map(() => 1);
+        const totalWeight = weights.reduce((sum, w) => sum + w, 0);
+        let random = Math.random() * totalWeight;
+        for (let i = 0; i < node.choices.length; i++) {
+            random -= weights[i] ?? 1;
+            if (random <= 0) {
+                if (node.choices[i].targetNodeId) {
+                    this.gotoNode(node.choices[i].targetNodeId);
+                    return;
+                }
+            }
+        }
+        this.advanceToNextNode(node);
+    }
+    // ─── Condition Evaluation ──────────────────────────────
+    evaluateConditions(group) {
+        if (!group) {
+            return true;
+        }
+        if (!this.currentState) {
+            return false;
+        }
+        const results = group.conditions.map((item) => {
+            if ('logic' in item) {
+                return this.evaluateConditions(item);
+            }
+            return this.evaluateCondition(item);
+        });
+        switch (group.logic) {
+            case 'and':
+                return results.every(Boolean);
+            case 'or':
+                return results.some(Boolean);
+            case 'not':
+                return !results[0];
+            default:
+                return true;
+        }
+    }
+    evaluateCondition(condition) {
+        if (!this.currentState) {
+            return false;
+        }
+        let value;
+        switch (condition.type) {
+            case 'variable':
+                value = this.currentState.variables.get(condition.variable);
+                break;
+            case 'flag':
+                value = this.currentState.flags.has(condition.variable);
+                break;
+            case 'custom':
+                if (this.customConditionEvaluator) {
+                    return this.customConditionEvaluator(condition);
+                }
+                return false;
+            default:
+                return false;
+        }
+        let result;
+        const target = condition.value;
+        switch (condition.operator) {
+            case 'eq':
+                result = value === target;
+                break;
+            case 'ne':
+                result = value !== target;
+                break;
+            case 'gt':
+                result = value > target;
+                break;
+            case 'gte':
+                result = value >= target;
+                break;
+            case 'lt':
+                result = value < target;
+                break;
+            case 'lte':
+                result = value <= target;
+                break;
+            case 'contains':
+                result = String(value).includes(String(target));
+                break;
+            case 'startsWith':
+                result = String(value).startsWith(String(target));
+                break;
+            case 'endsWith':
+                result = String(value).endsWith(String(target));
+                break;
+            default:
+                result = false;
+        }
+        return condition.negate ? !result : result;
+    }
+    // ─── Action Execution ──────────────────────────────────
+    executeAction(action) {
+        if (!this.currentState) {
+            return;
+        }
+        switch (action.type) {
+            case 'setVariable':
+                this.currentState.variables.set(action.target, action.value);
+                break;
+            case 'setFlag':
+                if (action.value) {
+                    this.currentState.flags.add(action.target);
+                }
+                else {
+                    this.currentState.flags.delete(action.target);
+                }
+                break;
+            case 'addItem':
+            case 'removeItem':
+            case 'startQuest':
+            case 'completeQuest':
+            case 'playSound':
+            case 'playAnimation':
+            case 'custom':
+                this.onAction?.(action);
+                break;
+        }
+    }
+    // ─── State Access ──────────────────────────────────────
+    getVariable(name) {
+        return this.currentState?.variables.get(name);
+    }
+    setVariable(name, value) {
+        if (this.currentState) {
+            this.currentState.variables.set(name, value);
+        }
+    }
+    hasFlag(name) {
+        return this.currentState?.flags.has(name) ?? false;
+    }
+    isNodeVisited(nodeId) {
+        return this.currentState?.visitedNodes.has(nodeId) ?? false;
+    }
+    getCurrentState() {
+        return this.currentState;
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setOnDialogueStart(callback) {
+        this.onDialogueStart = callback;
+    }
+    setOnDialogueEnd(callback) {
+        this.onDialogueEnd = callback;
+    }
+    setOnNodeEnter(callback) {
+        this.onNodeEnter = callback;
+    }
+    setOnLineDisplay(callback) {
+        this.onLineDisplay = callback;
+    }
+    setOnChoicesDisplay(callback) {
+        this.onChoicesDisplay = callback;
+    }
+    setOnAction(callback) {
+        this.onAction = callback;
+    }
+    setCustomConditionEvaluator(evaluator) {
+        this.customConditionEvaluator = evaluator;
+    }
+    // ─── Import/Export ─────────────────────────────────────
+    exportToJson(treeId) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return null;
+        }
+        const data = {
+            ...tree,
+            nodes: Object.fromEntries(tree.nodes),
+            speakers: Object.fromEntries(tree.speakers),
+            variables: Object.fromEntries(tree.variables),
+            flags: Array.from(tree.flags),
+        };
+        // Convert LocalizedText.translations Maps to objects
+        const convertLocalizedText = (lt) => ({
+            ...lt,
+            translations: Object.fromEntries(lt.translations),
+        });
+        for (const node of Object.values(data.nodes)) {
+            if (node.lines) {
+                for (const line of node.lines) {
+                    line.text = convertLocalizedText(line.text);
+                }
+            }
+            if (node.choices) {
+                for (const choice of node.choices) {
+                    choice.text = convertLocalizedText(choice.text);
+                }
+            }
+        }
+        for (const speaker of Object.values(data.speakers)) {
+            speaker.name = convertLocalizedText(speaker.name);
+            if (speaker.displayName) {
+                speaker.displayName = convertLocalizedText(speaker.displayName);
+            }
+        }
+        return JSON.stringify(data, null, 2);
+    }
+    importFromJson(json) {
+        try {
+            const data = JSON.parse(json);
+            // Convert objects back to Maps
+            const tree = {
+                ...data,
+                nodes: new Map(Object.entries(data.nodes)),
+                speakers: new Map(Object.entries(data.speakers)),
+                variables: new Map(Object.entries(data.variables)),
+                flags: new Set(data.flags),
+            };
+            // Convert translation objects back to Maps
+            const convertTranslations = (lt) => ({
+                ...lt,
+                translations: new Map(Object.entries(lt.translations)),
+            });
+            for (const node of tree.nodes.values()) {
+                if (node.lines) {
+                    for (const line of node.lines) {
+                        line.text = convertTranslations(line.text);
+                    }
+                }
+                if (node.choices) {
+                    for (const choice of node.choices) {
+                        choice.text = convertTranslations(choice.text);
+                    }
+                }
+            }
+            for (const speaker of tree.speakers.values()) {
+                speaker.name = convertTranslations(speaker.name);
+                if (speaker.displayName) {
+                    speaker.displayName = convertTranslations(speaker.displayName);
+                }
+            }
+            this.trees.set(tree.id, tree);
+            // Register speakers globally
+            for (const [id, speaker] of tree.speakers) {
+                this.speakers.set(id, speaker);
+            }
+            return tree;
+        }
+        catch (error) {
+            console.error('Failed to import dialogue from JSON:', error);
+            return null;
+        }
+    }
+    exportStringsForLocalization(treeId) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return new Map();
+        }
+        const strings = new Map();
+        for (const node of tree.nodes.values()) {
+            if (node.lines) {
+                for (const line of node.lines) {
+                    strings.set(line.text.key, line.text.default);
+                }
+            }
+            if (node.choices) {
+                for (const choice of node.choices) {
+                    strings.set(choice.text.key, choice.text.default);
+                }
+            }
+        }
+        for (const speaker of tree.speakers.values()) {
+            strings.set(speaker.name.key, speaker.name.default);
+        }
+        return strings;
+    }
+    importTranslations(treeId, language, translations) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return false;
+        }
+        for (const node of tree.nodes.values()) {
+            if (node.lines) {
+                for (const line of node.lines) {
+                    const translation = translations.get(line.text.key);
+                    if (translation) {
+                        line.text.translations.set(language, translation);
+                    }
+                }
+            }
+            if (node.choices) {
+                for (const choice of node.choices) {
+                    const translation = translations.get(choice.text.key);
+                    if (translation) {
+                        choice.text.translations.set(language, translation);
+                    }
+                }
+            }
+        }
+        for (const speaker of tree.speakers.values()) {
+            const translation = translations.get(speaker.name.key);
+            if (translation) {
+                speaker.name.translations.set(language, translation);
+            }
+        }
+        if (!tree.supportedLanguages.includes(language)) {
+            tree.supportedLanguages.push(language);
+        }
+        tree.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Graph Visualization ───────────────────────────────
+    getGraphData(treeId) {
+        const tree = this.trees.get(treeId);
+        if (!tree) {
+            return null;
+        }
+        const nodes = [];
+        const edges = [];
+        for (const node of tree.nodes.values()) {
+            nodes.push({
+                id: node.id,
+                type: node.type,
+                name: node.name,
+                position: node.position,
+                color: node.color,
+                hasLines: (node.lines?.length ?? 0) > 0,
+                hasChoices: (node.choices?.length ?? 0) > 0,
+                hasCondition: !!node.condition,
+            });
+            // Create edges
+            if (node.nextNodeId) {
+                edges.push({
+                    id: `edge_${node.id}_${node.nextNodeId}`,
+                    from: node.id,
+                    to: node.nextNodeId,
+                    type: 'default',
+                });
+            }
+            if (node.choices) {
+                for (const choice of node.choices) {
+                    if (choice.targetNodeId) {
+                        edges.push({
+                            id: `edge_${node.id}_${choice.id}`,
+                            from: node.id,
+                            to: choice.targetNodeId,
+                            type: 'choice',
+                            label: this.getText(choice.text).substring(0, 20),
+                            hasCondition: !!choice.condition,
+                        });
+                    }
+                }
+            }
+        }
+        return { nodes, edges };
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createDialogueManager() {
+    return new DialogueManager();
+}
+function createDialogueNode(type, name, position) {
+    return { type, name, position };
+}
+function createConditionGroup(logic, conditions) {
+    return { logic, conditions };
+}
+function createCondition(type, variable, operator, value) {
+    return { type, variable, operator, value };
+}
+
+exports.DialogueManager = DialogueManager;
+exports.createCondition = createCondition;
+exports.createConditionGroup = createConditionGroup;
+exports.createDialogueManager = createDialogueManager;
+exports.createDialogueNode = createDialogueNode;
+//# sourceMappingURL=DialogueSystem.js.map