@nice2dev/game-engine 1.0.5 → 1.0.10

package/dist/esm/editor/QuestEditor.js

@@ -0,0 +1,846 @@
+/**
+ * @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
+ */
+// ============================================================
+// Quest Manager
+// ============================================================
+class QuestManager {
+    constructor() {
+        this.quests = new Map();
+        this.chains = new Map();
+        this.activeProgress = new Map();
+        this.completedQuests = new Set();
+        this.journal = [];
+        this.currentLanguage = 'en';
+        // Player state integration
+        this.playerLevel = 1;
+        this.playerFlags = new Set();
+        this.playerStats = new Map();
+        this.playerItems = new Map();
+        this.playerReputation = new Map();
+    }
+    // ─── Quest Definition ──────────────────────────────────
+    createQuest(name, description) {
+        const quest = {
+            id: `quest_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            name: this.createLocalizedString(name),
+            description: this.createLocalizedString(description),
+            category: 'general',
+            tags: [],
+            priority: 0,
+            isMainQuest: false,
+            isSideQuest: true,
+            isDailyQuest: false,
+            isRepeatable: false,
+            prerequisites: [],
+            stages: new Map(),
+            startStageId: '',
+            rewards: [],
+            createdAt: Date.now(),
+            modifiedAt: Date.now(),
+            version: 1,
+        };
+        // Create default start stage
+        const startStage = this.createStage('Start', 'Begin the quest');
+        quest.stages.set(startStage.id, startStage);
+        quest.startStageId = startStage.id;
+        this.quests.set(quest.id, quest);
+        return quest;
+    }
+    getQuest(id) {
+        return this.quests.get(id);
+    }
+    deleteQuest(id) {
+        return this.quests.delete(id);
+    }
+    getAllQuests() {
+        return Array.from(this.quests.values());
+    }
+    // ─── Stage Management ──────────────────────────────────
+    createStage(name, description) {
+        return {
+            id: `stage_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            name: this.createLocalizedString(name),
+            description: this.createLocalizedString(description),
+            objectives: [],
+        };
+    }
+    addStage(questId, stage) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return false;
+        }
+        quest.stages.set(stage.id, stage);
+        quest.modifiedAt = Date.now();
+        return true;
+    }
+    updateStage(questId, stageId, updates) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return false;
+        }
+        const stage = quest.stages.get(stageId);
+        if (!stage) {
+            return false;
+        }
+        Object.assign(stage, updates);
+        quest.modifiedAt = Date.now();
+        return true;
+    }
+    connectStages(questId, fromStageId, toStageId, condition) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return false;
+        }
+        const fromStage = quest.stages.get(fromStageId);
+        if (!fromStage) {
+            return false;
+        }
+        if (condition) {
+            if (!fromStage.branchConditions) {
+                fromStage.branchConditions = [];
+            }
+            fromStage.branchConditions.push({ condition, targetStageId: toStageId });
+        }
+        else {
+            fromStage.nextStageId = toStageId;
+        }
+        quest.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Objective Management ──────────────────────────────
+    createObjective(type, description, target, amount = 1) {
+        return {
+            id: `obj_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            type,
+            description: this.createLocalizedString(description),
+            target,
+            targetAmount: amount,
+            currentAmount: 0,
+            isOptional: false,
+            isHidden: false,
+            isCompleted: false,
+        };
+    }
+    addObjective(questId, stageId, objective) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return false;
+        }
+        const stage = quest.stages.get(stageId);
+        if (!stage) {
+            return false;
+        }
+        stage.objectives.push(objective);
+        quest.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Reward Management ─────────────────────────────────
+    createReward(type, target, amount) {
+        return { type, target, amount };
+    }
+    addQuestReward(questId, reward) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return false;
+        }
+        quest.rewards.push(reward);
+        quest.modifiedAt = Date.now();
+        return true;
+    }
+    addStageReward(questId, stageId, reward) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return false;
+        }
+        const stage = quest.stages.get(stageId);
+        if (!stage) {
+            return false;
+        }
+        if (!stage.stageRewards) {
+            stage.stageRewards = [];
+        }
+        stage.stageRewards.push(reward);
+        quest.modifiedAt = Date.now();
+        return true;
+    }
+    // ─── Quest Chain Management ────────────────────────────
+    createChain(name, description) {
+        const chain = {
+            id: `chain_${Date.now()}`,
+            name: this.createLocalizedString(name),
+            description: this.createLocalizedString(description),
+            questIds: [],
+        };
+        this.chains.set(chain.id, chain);
+        return chain;
+    }
+    addQuestToChain(chainId, questId) {
+        const chain = this.chains.get(chainId);
+        const quest = this.quests.get(questId);
+        if (!chain || !quest) {
+            return false;
+        }
+        chain.questIds.push(questId);
+        quest.chainId = chainId;
+        quest.chainOrder = chain.questIds.length - 1;
+        return true;
+    }
+    // ─── Runtime: Quest Availability ───────────────────────
+    getAvailableQuests() {
+        return this.getAllQuests().filter((quest) => this.isQuestAvailable(quest));
+    }
+    isQuestAvailable(quest) {
+        // Already active or completed
+        if (this.activeProgress.has(quest.id)) {
+            return false;
+        }
+        if (this.completedQuests.has(quest.id) && !quest.isRepeatable) {
+            return false;
+        }
+        // Time restrictions
+        const now = Date.now();
+        if (quest.availableFrom && now < quest.availableFrom) {
+            return false;
+        }
+        if (quest.availableUntil && now > quest.availableUntil) {
+            return false;
+        }
+        // Level requirements
+        if (quest.minLevel && this.playerLevel < quest.minLevel) {
+            return false;
+        }
+        if (quest.maxLevel && this.playerLevel > quest.maxLevel) {
+            return false;
+        }
+        // Prerequisites
+        for (const condition of quest.prerequisites) {
+            if (!this.evaluateCondition(condition)) {
+                return false;
+            }
+        }
+        // Required quests
+        if (quest.requiredQuests) {
+            for (const reqQuestId of quest.requiredQuests) {
+                if (!this.completedQuests.has(reqQuestId)) {
+                    return false;
+                }
+            }
+        }
+        // Conflicting quests
+        if (quest.conflictingQuests) {
+            for (const conflictQuestId of quest.conflictingQuests) {
+                if (this.activeProgress.has(conflictQuestId)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    // ─── Runtime: Quest Progress ───────────────────────────
+    startQuest(questId) {
+        const quest = this.quests.get(questId);
+        if (!quest || !this.isQuestAvailable(quest)) {
+            return false;
+        }
+        const progress = {
+            questId,
+            status: 'active',
+            currentStageId: quest.startStageId,
+            objectiveProgress: new Map(),
+            startedAt: Date.now(),
+            stageStartedAt: Date.now(),
+            flags: new Set(),
+        };
+        // Initialize objective progress
+        const startStage = quest.stages.get(quest.startStageId);
+        if (startStage) {
+            for (const obj of startStage.objectives) {
+                progress.objectiveProgress.set(obj.id, 0);
+            }
+            // Execute entry actions
+            if (startStage.onEnterActions) {
+                for (const action of startStage.onEnterActions) {
+                    this.executeAction(action);
+                }
+            }
+        }
+        this.activeProgress.set(questId, progress);
+        // Journal entry
+        this.addJournalEntry(questId, 'start', quest.startStageId);
+        this.onQuestStarted?.(quest, progress);
+        return true;
+    }
+    updateObjective(questId, objectiveId, amount = 1) {
+        const quest = this.quests.get(questId);
+        const progress = this.activeProgress.get(questId);
+        if (!quest || !progress) {
+            return false;
+        }
+        const stage = quest.stages.get(progress.currentStageId);
+        if (!stage) {
+            return false;
+        }
+        const objective = stage.objectives.find((o) => o.id === objectiveId);
+        if (!objective || objective.isCompleted) {
+            return false;
+        }
+        // Check dependencies
+        if (objective.requiresObjectives) {
+            for (const reqObjId of objective.requiresObjectives) {
+                const reqObj = stage.objectives.find((o) => o.id === reqObjId);
+                if (reqObj && !reqObj.isCompleted) {
+                    return false;
+                }
+            }
+        }
+        // Update progress
+        const newAmount = Math.min((progress.objectiveProgress.get(objectiveId) ?? 0) + amount, objective.targetAmount);
+        progress.objectiveProgress.set(objectiveId, newAmount);
+        objective.currentAmount = newAmount;
+        // Check completion
+        if (newAmount >= objective.targetAmount) {
+            objective.isCompleted = true;
+            // Give objective rewards
+            if (objective.rewards) {
+                for (const reward of objective.rewards) {
+                    this.giveReward(reward);
+                }
+            }
+        }
+        this.onObjectiveUpdated?.(quest, objective);
+        this.onQuestUpdated?.(quest, progress);
+        // Journal entry
+        this.addJournalEntry(questId, 'update', progress.currentStageId, objectiveId);
+        // Check stage completion
+        this.checkStageCompletion(questId);
+        return true;
+    }
+    checkStageCompletion(questId) {
+        const quest = this.quests.get(questId);
+        const progress = this.activeProgress.get(questId);
+        if (!quest || !progress) {
+            return;
+        }
+        const stage = quest.stages.get(progress.currentStageId);
+        if (!stage) {
+            return;
+        }
+        // Check if all required objectives are complete
+        const requiredObjectives = stage.objectives.filter((o) => !o.isOptional);
+        const allComplete = requiredObjectives.every((o) => o.isCompleted);
+        if (!allComplete) {
+            return;
+        }
+        // Execute completion actions
+        if (stage.onCompleteActions) {
+            for (const action of stage.onCompleteActions) {
+                this.executeAction(action);
+            }
+        }
+        // Give stage rewards
+        if (stage.stageRewards) {
+            for (const reward of stage.stageRewards) {
+                this.giveReward(reward);
+            }
+        }
+        // Determine next stage
+        let nextStageId;
+        // Check branch conditions first
+        if (stage.branchConditions) {
+            for (const branch of stage.branchConditions) {
+                if (this.evaluateCondition(branch.condition)) {
+                    nextStageId = branch.targetStageId;
+                    break;
+                }
+            }
+        }
+        // Fall back to default next stage
+        if (!nextStageId) {
+            nextStageId = stage.nextStageId;
+        }
+        if (nextStageId) {
+            this.advanceToStage(questId, nextStageId);
+        }
+        else {
+            // Quest complete
+            this.completeQuest(questId);
+        }
+    }
+    advanceToStage(questId, stageId) {
+        const quest = this.quests.get(questId);
+        const progress = this.activeProgress.get(questId);
+        if (!quest || !progress) {
+            return;
+        }
+        const stage = quest.stages.get(stageId);
+        if (!stage) {
+            return;
+        }
+        progress.currentStageId = stageId;
+        progress.stageStartedAt = Date.now();
+        // Reset objective progress for new stage
+        for (const obj of stage.objectives) {
+            progress.objectiveProgress.set(obj.id, 0);
+            obj.currentAmount = 0;
+            obj.isCompleted = false;
+        }
+        // Execute entry actions
+        if (stage.onEnterActions) {
+            for (const action of stage.onEnterActions) {
+                this.executeAction(action);
+            }
+        }
+        // Journal entry
+        this.addJournalEntry(questId, 'update', stageId);
+        this.onQuestUpdated?.(quest, progress);
+    }
+    completeQuest(questId) {
+        const quest = this.quests.get(questId);
+        const progress = this.activeProgress.get(questId);
+        if (!quest || !progress) {
+            return;
+        }
+        progress.status = 'completed';
+        progress.completedAt = Date.now();
+        // Give quest rewards
+        for (const reward of quest.rewards) {
+            this.giveReward(reward);
+        }
+        // Check chain completion
+        if (quest.chainId) {
+            this.checkChainCompletion(quest.chainId);
+        }
+        // Move to completed
+        this.activeProgress.delete(questId);
+        this.completedQuests.add(questId);
+        // Journal entry
+        this.addJournalEntry(questId, 'complete');
+        this.onQuestCompleted?.(quest, quest.rewards);
+    }
+    failQuest(questId, reason) {
+        const quest = this.quests.get(questId);
+        const progress = this.activeProgress.get(questId);
+        if (!quest || !progress) {
+            return;
+        }
+        progress.status = 'failed';
+        progress.failedAt = Date.now();
+        this.activeProgress.delete(questId);
+        // Journal entry
+        const entry = this.addJournalEntry(questId, 'fail');
+        if (entry && reason) {
+            entry.text.default = reason;
+        }
+        this.onQuestFailed?.(quest);
+    }
+    abandonQuest(questId) {
+        const quest = this.quests.get(questId);
+        const progress = this.activeProgress.get(questId);
+        if (!quest || !progress) {
+            return false;
+        }
+        progress.status = 'abandoned';
+        this.activeProgress.delete(questId);
+        return true;
+    }
+    checkChainCompletion(chainId) {
+        const chain = this.chains.get(chainId);
+        if (!chain) {
+            return;
+        }
+        const allComplete = chain.questIds.every((qId) => this.completedQuests.has(qId));
+        if (!allComplete) {
+            return;
+        }
+        // Give chain rewards
+        if (chain.rewards) {
+            for (const reward of chain.rewards) {
+                this.giveReward(reward);
+            }
+        }
+    }
+    // ─── Condition Evaluation ──────────────────────────────
+    evaluateCondition(condition) {
+        let value;
+        switch (condition.type) {
+            case 'level':
+                value = this.playerLevel;
+                break;
+            case 'quest':
+                value = this.completedQuests.has(condition.target);
+                break;
+            case 'item':
+                value = this.playerItems.get(condition.target) ?? 0;
+                break;
+            case 'stat':
+                value = this.playerStats.get(condition.target) ?? 0;
+                break;
+            case 'reputation':
+                value = this.playerReputation.get(condition.target) ?? 0;
+                break;
+            case 'flag':
+                value = this.playerFlags.has(condition.target);
+                break;
+            case 'custom':
+                if (this.customConditionEvaluator) {
+                    return this.customConditionEvaluator(condition);
+                }
+                return false;
+            default:
+                return false;
+        }
+        const target = condition.value;
+        switch (condition.operator) {
+            case 'eq':
+                return value === target;
+            case 'ne':
+                return value !== target;
+            case 'gt':
+                return value > target;
+            case 'gte':
+                return value >= target;
+            case 'lt':
+                return value < target;
+            case 'lte':
+                return value <= target;
+            case 'has':
+                return Boolean(value);
+            case 'not_has':
+                return !value;
+            default:
+                return false;
+        }
+    }
+    // ─── Action Execution ──────────────────────────────────
+    executeAction(action) {
+        switch (action.type) {
+            case 'setFlag':
+                this.playerFlags.add(action.target);
+                break;
+            case 'removeFlag':
+                this.playerFlags.delete(action.target);
+                break;
+            case 'giveItem':
+                this.playerItems.set(action.target, (this.playerItems.get(action.target) ?? 0) + (action.params?.amount ?? 1));
+                break;
+            case 'removeItem':
+                const current = this.playerItems.get(action.target) ?? 0;
+                const toRemove = action.params?.amount ?? 1;
+                this.playerItems.set(action.target, Math.max(0, current - toRemove));
+                break;
+            case 'custom':
+                this.customActionExecutor?.(action);
+                break;
+            default:
+                this.customActionExecutor?.(action);
+                break;
+        }
+    }
+    // ─── Reward Giving ─────────────────────────────────────
+    giveReward(reward) {
+        // Check chance
+        if (reward.chance !== undefined && Math.random() > reward.chance) {
+            return;
+        }
+        switch (reward.type) {
+            case 'item':
+                this.playerItems.set(reward.target, (this.playerItems.get(reward.target) ?? 0) + reward.amount);
+                break;
+            case 'experience':
+                // Handled externally
+                break;
+            case 'reputation':
+                this.playerReputation.set(reward.target, (this.playerReputation.get(reward.target) ?? 0) + reward.amount);
+                break;
+            case 'quest':
+                this.startQuest(reward.target);
+                break;
+        }
+        this.onReward?.(reward);
+    }
+    // ─── Journal ───────────────────────────────────────────
+    addJournalEntry(questId, type, stageId, objectiveId) {
+        const quest = this.quests.get(questId);
+        let text = '';
+        if (quest) {
+            switch (type) {
+                case 'start':
+                    text = `Started quest: ${this.getString(quest.name)}`;
+                    break;
+                case 'complete':
+                    text = `Completed quest: ${this.getString(quest.name)}`;
+                    break;
+                case 'fail':
+                    text = `Failed quest: ${this.getString(quest.name)}`;
+                    break;
+                case 'update':
+                    if (stageId) {
+                        const stage = quest.stages.get(stageId);
+                        if (stage) {
+                            text = this.getString(stage.description);
+                        }
+                    }
+                    break;
+            }
+        }
+        const entry = {
+            id: `journal_${Date.now()}`,
+            questId,
+            stageId,
+            objectiveId,
+            type,
+            text: this.createLocalizedString(text),
+            timestamp: Date.now(),
+            isRead: false,
+        };
+        this.journal.push(entry);
+        this.onJournalEntry?.(entry);
+        return entry;
+    }
+    getJournal(questId) {
+        if (questId) {
+            return this.journal.filter((e) => e.questId === questId);
+        }
+        return [...this.journal];
+    }
+    markJournalRead(entryId) {
+        const entry = this.journal.find((e) => e.id === entryId);
+        if (entry) {
+            entry.isRead = true;
+        }
+    }
+    // ─── Player State Integration ──────────────────────────
+    setPlayerLevel(level) {
+        this.playerLevel = level;
+    }
+    setPlayerFlag(flag, value = true) {
+        if (value) {
+            this.playerFlags.add(flag);
+        }
+        else {
+            this.playerFlags.delete(flag);
+        }
+    }
+    setPlayerStat(stat, value) {
+        this.playerStats.set(stat, value);
+    }
+    setPlayerItem(item, count) {
+        this.playerItems.set(item, count);
+    }
+    setPlayerReputation(faction, value) {
+        this.playerReputation.set(faction, value);
+    }
+    // ─── Localization ──────────────────────────────────────
+    createLocalizedString(text) {
+        return {
+            key: `str_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            default: text,
+            translations: new Map([[this.currentLanguage, text]]),
+        };
+    }
+    getString(ls, language) {
+        const lang = language ?? this.currentLanguage;
+        return ls.translations.get(lang) ?? ls.default;
+    }
+    setLanguage(language) {
+        this.currentLanguage = language;
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setOnQuestAvailable(callback) {
+        this.onQuestAvailable = callback;
+    }
+    setOnQuestStarted(callback) {
+        this.onQuestStarted = callback;
+    }
+    setOnQuestUpdated(callback) {
+        this.onQuestUpdated = callback;
+    }
+    setOnQuestCompleted(callback) {
+        this.onQuestCompleted = callback;
+    }
+    setOnQuestFailed(callback) {
+        this.onQuestFailed = callback;
+    }
+    setOnObjectiveUpdated(callback) {
+        this.onObjectiveUpdated = callback;
+    }
+    setOnJournalEntry(callback) {
+        this.onJournalEntry = callback;
+    }
+    setOnReward(callback) {
+        this.onReward = callback;
+    }
+    setCustomConditionEvaluator(evaluator) {
+        this.customConditionEvaluator = evaluator;
+    }
+    setCustomActionExecutor(executor) {
+        this.customActionExecutor = executor;
+    }
+    // ─── Queries ───────────────────────────────────────────
+    getActiveQuests() {
+        return Array.from(this.activeProgress.keys())
+            .map((id) => this.quests.get(id))
+            .filter((q) => q !== undefined);
+    }
+    getQuestProgress(questId) {
+        return this.activeProgress.get(questId);
+    }
+    isQuestActive(questId) {
+        return this.activeProgress.has(questId);
+    }
+    isQuestCompleted(questId) {
+        return this.completedQuests.has(questId);
+    }
+    getQuestsByCategory(category) {
+        return this.getAllQuests().filter((q) => q.category === category);
+    }
+    getQuestChain(chainId) {
+        return this.chains.get(chainId);
+    }
+    // ─── Serialization ─────────────────────────────────────
+    exportQuest(questId) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return null;
+        }
+        const data = {
+            ...quest,
+            stages: Object.fromEntries(quest.stages),
+            name: { ...quest.name, translations: Object.fromEntries(quest.name.translations) },
+            description: {
+                ...quest.description,
+                translations: Object.fromEntries(quest.description.translations),
+            },
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    importQuest(json) {
+        try {
+            const data = JSON.parse(json);
+            const quest = {
+                ...data,
+                stages: new Map(Object.entries(data.stages)),
+                name: { ...data.name, translations: new Map(Object.entries(data.name.translations)) },
+                description: {
+                    ...data.description,
+                    translations: new Map(Object.entries(data.description.translations)),
+                },
+            };
+            this.quests.set(quest.id, quest);
+            return quest;
+        }
+        catch {
+            return null;
+        }
+    }
+    exportProgress() {
+        const data = {
+            activeProgress: Object.fromEntries(Array.from(this.activeProgress.entries()).map(([id, progress]) => [
+                id,
+                {
+                    ...progress,
+                    objectiveProgress: Object.fromEntries(progress.objectiveProgress),
+                    flags: Array.from(progress.flags),
+                },
+            ])),
+            completedQuests: Array.from(this.completedQuests),
+            journal: this.journal.map((e) => ({
+                ...e,
+                text: { ...e.text, translations: Object.fromEntries(e.text.translations) },
+            })),
+        };
+        return JSON.stringify(data);
+    }
+    importProgress(json) {
+        try {
+            const data = JSON.parse(json);
+            this.activeProgress = new Map(Object.entries(data.activeProgress).map(([id, progress]) => {
+                const p = progress;
+                return [
+                    id,
+                    {
+                        ...p,
+                        objectiveProgress: new Map(Object.entries(p.objectiveProgress)),
+                        flags: new Set(p.flags),
+                    },
+                ];
+            }));
+            this.completedQuests = new Set(data.completedQuests);
+            this.journal = data.journal.map((e) => ({
+                ...e,
+                text: { ...e.text, translations: new Map(Object.entries(e.text.translations)) },
+            }));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ─── Graph Visualization ───────────────────────────────
+    getQuestGraph(questId) {
+        const quest = this.quests.get(questId);
+        if (!quest) {
+            return null;
+        }
+        const nodes = [];
+        const edges = [];
+        let x = 100;
+        for (const [, stage] of quest.stages) {
+            nodes.push({
+                id: stage.id,
+                name: this.getString(stage.name),
+                type: 'stage',
+                objectiveCount: stage.objectives.length,
+                x,
+                y: 100,
+            });
+            if (stage.nextStageId) {
+                edges.push({
+                    id: `edge_${stage.id}_${stage.nextStageId}`,
+                    from: stage.id,
+                    to: stage.nextStageId,
+                    type: 'default',
+                });
+            }
+            if (stage.branchConditions) {
+                for (const branch of stage.branchConditions) {
+                    edges.push({
+                        id: `edge_${stage.id}_${branch.targetStageId}_branch`,
+                        from: stage.id,
+                        to: branch.targetStageId,
+                        type: 'conditional',
+                        label: `${branch.condition.type}: ${branch.condition.target}`,
+                    });
+                }
+            }
+            x += 200;
+        }
+        return { nodes, edges };
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createQuestManager() {
+    return new QuestManager();
+}
+function createQuestCondition(type, target, operator, value) {
+    return { type, target, operator, value };
+}
+
+export { QuestManager, createQuestCondition, createQuestManager };
+//# sourceMappingURL=QuestEditor.js.map