@magicborn/dialogue-forge 0.1.0

package/dist/esm/lib/yarn-runner/node-processor.js

@@ -0,0 +1,129 @@
+import { evaluateConditions } from './condition-evaluator';
+/**
+ * Processes a dialogue node and returns the result
+ */
+export function processNode(node, variableManager) {
+    // Player nodes - return choices
+    if (node.type === 'player') {
+        const availableChoices = node.choices?.filter(choice => {
+            if (!choice.conditions)
+                return true;
+            return evaluateConditions(choice.conditions, variableManager.getAllVariables(), variableManager.getAllMemoryFlags());
+        }) || [];
+        return {
+            content: '',
+            speaker: undefined,
+            nextNodeId: undefined,
+            isEnd: false,
+            isPlayerChoice: true,
+            choices: availableChoices
+        };
+    }
+    // Conditional nodes - evaluate blocks
+    if (node.type === 'conditional' && node.conditionalBlocks) {
+        const matchedBlock = findMatchingConditionalBlock(node.conditionalBlocks, variableManager);
+        if (matchedBlock) {
+            // Interpolate variables in content
+            const interpolatedContent = interpolateVariables(matchedBlock.content, variableManager);
+            return {
+                content: interpolatedContent,
+                speaker: matchedBlock.speaker,
+                nextNodeId: matchedBlock.nextNodeId || node.nextNodeId,
+                isEnd: !matchedBlock.nextNodeId && !node.nextNodeId,
+                isPlayerChoice: false,
+                choices: undefined
+            };
+        }
+        // No block matched - end dialogue
+        return {
+            content: '',
+            speaker: undefined,
+            nextNodeId: undefined,
+            isEnd: true,
+            isPlayerChoice: false,
+            choices: undefined
+        };
+    }
+    // NPC nodes - handle conditional blocks if present
+    if (node.type === 'npc') {
+        let content = node.content;
+        let speaker = node.speaker;
+        let nextNodeId = node.nextNodeId;
+        // Check for conditional blocks
+        if (node.conditionalBlocks && node.conditionalBlocks.length > 0) {
+            const matchedBlock = findMatchingConditionalBlock(node.conditionalBlocks, variableManager);
+            if (matchedBlock) {
+                content = matchedBlock.content;
+                speaker = matchedBlock.speaker || node.speaker;
+                // Conditional blocks can override nextNodeId
+                if (matchedBlock.nextNodeId) {
+                    nextNodeId = matchedBlock.nextNodeId;
+                }
+            }
+        }
+        // Interpolate variables in content (e.g., "Hello {$name}")
+        content = interpolateVariables(content, variableManager);
+        return {
+            content,
+            speaker,
+            nextNodeId,
+            isEnd: !nextNodeId,
+            isPlayerChoice: false,
+            choices: undefined
+        };
+    }
+    // Default: end dialogue
+    return {
+        content: '',
+        speaker: undefined,
+        nextNodeId: undefined,
+        isEnd: true,
+        isPlayerChoice: false,
+        choices: undefined
+    };
+}
+/**
+ * Finds the first matching conditional block (if/elseif/else logic)
+ */
+function findMatchingConditionalBlock(blocks, variableManager) {
+    let matchedBlock = null;
+    for (const block of blocks) {
+        if (block.type === 'else') {
+            // Only match else if no previous block matched
+            if (!matchedBlock) {
+                matchedBlock = block;
+            }
+        }
+        else if (block.condition && block.condition.length > 0) {
+            // Check if all conditions in this block are true
+            const allMatch = evaluateConditions(block.condition, variableManager.getAllVariables(), variableManager.getAllMemoryFlags());
+            if (allMatch) {
+                matchedBlock = block;
+                break; // Found a match, stop checking (if/elseif matched)
+            }
+        }
+    }
+    return matchedBlock;
+}
+/**
+ * Interpolates variables in text (e.g., "Hello {$name}" becomes "Hello John")
+ */
+function interpolateVariables(text, variableManager) {
+    // Match {$variable} patterns
+    return text.replace(/\{\$(\w+)\}/g, (match, varName) => {
+        const value = variableManager.get(varName);
+        if (value === undefined) {
+            return match; // Keep original if variable not found
+        }
+        return String(value);
+    });
+}
+/**
+ * Validates that a nextNodeId exists and is valid
+ */
+export function isValidNextNode(nextNodeId, availableNodes) {
+    if (!nextNodeId || !nextNodeId.trim()) {
+        return false;
+    }
+    return !!availableNodes[nextNodeId];
+}

package/dist/esm/lib/yarn-runner/variable-manager.d.ts

@@ -0,0 +1,51 @@
+import { VariableState } from './condition-evaluator';
+/**
+ * Manages variable state for Yarn Spinner execution
+ * Handles both game flags (persistent) and dialogue flags (temporary)
+ */
+export declare class VariableManager {
+    private variables;
+    private memoryFlags;
+    constructor(initialVariables?: VariableState, initialMemoryFlags?: Set<string>);
+    /**
+     * Get a variable value
+     */
+    get(name: string): boolean | number | string | undefined;
+    /**
+     * Set a variable value
+     */
+    set(name: string, value: boolean | number | string): void;
+    /**
+     * Apply an operation to a variable (e.g., +=, -=, *=, /=)
+     * If the variable doesn't exist, it's initialized to 0 for numeric operations
+     */
+    applyOperation(name: string, operator: '+' | '-' | '*' | '/', value: number): void;
+    /**
+     * Add a memory flag (dialogue flag - temporary)
+     */
+    addMemoryFlag(name: string): void;
+    /**
+     * Remove a memory flag
+     */
+    removeMemoryFlag(name: string): void;
+    /**
+     * Check if a memory flag exists
+     */
+    hasMemoryFlag(name: string): boolean;
+    /**
+     * Get all variables (persistent)
+     */
+    getAllVariables(): VariableState;
+    /**
+     * Get all memory flags
+     */
+    getAllMemoryFlags(): Set<string>;
+    /**
+     * Clear all memory flags (for dialogue reset)
+     */
+    clearMemoryFlags(): void;
+    /**
+     * Reset to initial state
+     */
+    reset(initialVariables?: VariableState, initialMemoryFlags?: Set<string>): void;
+}

package/dist/esm/lib/yarn-runner/variable-manager.js

@@ -0,0 +1,120 @@
+/**
+ * Manages variable state for Yarn Spinner execution
+ * Handles both game flags (persistent) and dialogue flags (temporary)
+ */
+export class VariableManager {
+    constructor(initialVariables, initialMemoryFlags) {
+        this.variables = {};
+        this.memoryFlags = new Set();
+        if (initialVariables) {
+            this.variables = { ...initialVariables };
+        }
+        if (initialMemoryFlags) {
+            this.memoryFlags = new Set(initialMemoryFlags);
+        }
+    }
+    /**
+     * Get a variable value
+     */
+    get(name) {
+        // Check persistent variables first
+        if (this.variables[name] !== undefined) {
+            return this.variables[name];
+        }
+        // Check memory flags (dialogue flags)
+        if (this.memoryFlags.has(name)) {
+            return true;
+        }
+        return undefined;
+    }
+    /**
+     * Set a variable value
+     */
+    set(name, value) {
+        this.variables[name] = value;
+    }
+    /**
+     * Apply an operation to a variable (e.g., +=, -=, *=, /=)
+     * If the variable doesn't exist, it's initialized to 0 for numeric operations
+     */
+    applyOperation(name, operator, value) {
+        const current = this.get(name);
+        let currentNum;
+        if (current === undefined) {
+            currentNum = 0;
+        }
+        else if (typeof current === 'number') {
+            currentNum = current;
+        }
+        else if (typeof current === 'string') {
+            // Try to parse string as number
+            const parsed = parseFloat(current);
+            currentNum = isNaN(parsed) ? 0 : parsed;
+        }
+        else {
+            // Boolean: treat true as 1, false as 0
+            currentNum = current ? 1 : 0;
+        }
+        let result;
+        switch (operator) {
+            case '+':
+                result = currentNum + value;
+                break;
+            case '-':
+                result = currentNum - value;
+                break;
+            case '*':
+                result = currentNum * value;
+                break;
+            case '/':
+                result = value !== 0 ? currentNum / value : currentNum;
+                break;
+            default:
+                result = currentNum;
+        }
+        this.variables[name] = result;
+    }
+    /**
+     * Add a memory flag (dialogue flag - temporary)
+     */
+    addMemoryFlag(name) {
+        this.memoryFlags.add(name);
+    }
+    /**
+     * Remove a memory flag
+     */
+    removeMemoryFlag(name) {
+        this.memoryFlags.delete(name);
+    }
+    /**
+     * Check if a memory flag exists
+     */
+    hasMemoryFlag(name) {
+        return this.memoryFlags.has(name);
+    }
+    /**
+     * Get all variables (persistent)
+     */
+    getAllVariables() {
+        return { ...this.variables };
+    }
+    /**
+     * Get all memory flags
+     */
+    getAllMemoryFlags() {
+        return new Set(this.memoryFlags);
+    }
+    /**
+     * Clear all memory flags (for dialogue reset)
+     */
+    clearMemoryFlags() {
+        this.memoryFlags.clear();
+    }
+    /**
+     * Reset to initial state
+     */
+    reset(initialVariables, initialMemoryFlags) {
+        this.variables = initialVariables ? { ...initialVariables } : {};
+        this.memoryFlags = initialMemoryFlags ? new Set(initialMemoryFlags) : new Set();
+    }
+}

package/dist/esm/lib/yarn-runner/variable-operations.d.ts

@@ -0,0 +1,16 @@
+import { VariableManager } from './variable-manager';
+/**
+ * Parses and executes a Yarn variable operation command
+ * Supports:
+ * - <<set $var = value>> (assignment)
+ * - <<set $var += value>> (addition)
+ * - <<set $var -= value>> (subtraction)
+ * - <<set $var *= value>> (multiplication)
+ * - <<set $var /= value>> (division)
+ */
+export declare function executeVariableOperation(command: string, variableManager: VariableManager): void;
+/**
+ * Extracts and executes all variable operations from a node's content
+ * This processes any <<set>> commands embedded in the dialogue text
+ */
+export declare function processVariableOperationsInContent(content: string, variableManager: VariableManager): string;

package/dist/esm/lib/yarn-runner/variable-operations.js

@@ -0,0 +1,88 @@
+/**
+ * Parses and executes a Yarn variable operation command
+ * Supports:
+ * - <<set $var = value>> (assignment)
+ * - <<set $var += value>> (addition)
+ * - <<set $var -= value>> (subtraction)
+ * - <<set $var *= value>> (multiplication)
+ * - <<set $var /= value>> (division)
+ */
+export function executeVariableOperation(command, variableManager) {
+    // Match: <<set $var = value>> or <<set $var += value>> etc.
+    const setMatch = command.match(/<<set\s+\$(\w+)\s*([+\-*/=]+)\s*(.+?)>>/);
+    if (!setMatch) {
+        return; // Invalid command, skip
+    }
+    const varName = setMatch[1];
+    const operator = setMatch[2].trim();
+    const valueStr = setMatch[3].trim();
+    // Parse the value
+    let value;
+    // Try to parse as number first
+    const numValue = parseFloat(valueStr);
+    if (!isNaN(numValue) && valueStr === String(numValue)) {
+        value = numValue;
+    }
+    else if (valueStr === 'true') {
+        value = true;
+    }
+    else if (valueStr === 'false') {
+        value = false;
+    }
+    else {
+        // Remove quotes if present
+        value = valueStr.replace(/^["']|["']$/g, '');
+    }
+    // Handle operations
+    if (operator === '=') {
+        // Simple assignment
+        variableManager.set(varName, value);
+    }
+    else if (operator === '+=') {
+        // Addition
+        if (typeof value === 'number') {
+            variableManager.applyOperation(varName, '+', value);
+        }
+        else {
+            // String concatenation
+            const current = variableManager.get(varName);
+            const currentStr = current !== undefined ? String(current) : '';
+            variableManager.set(varName, currentStr + String(value));
+        }
+    }
+    else if (operator === '-=') {
+        // Subtraction (numeric only)
+        if (typeof value === 'number') {
+            variableManager.applyOperation(varName, '-', value);
+        }
+    }
+    else if (operator === '*=') {
+        // Multiplication (numeric only)
+        if (typeof value === 'number') {
+            variableManager.applyOperation(varName, '*', value);
+        }
+    }
+    else if (operator === '/=') {
+        // Division (numeric only)
+        if (typeof value === 'number') {
+            variableManager.applyOperation(varName, '/', value);
+        }
+    }
+}
+/**
+ * Extracts and executes all variable operations from a node's content
+ * This processes any <<set>> commands embedded in the dialogue text
+ */
+export function processVariableOperationsInContent(content, variableManager) {
+    // Find all <<set>> commands
+    const setCommandRegex = /<<set\s+\$(\w+)\s*([+\-*/=]+)\s*(.+?)>>/g;
+    let processedContent = content;
+    let match;
+    while ((match = setCommandRegex.exec(content)) !== null) {
+        // Execute the command
+        executeVariableOperation(match[0], variableManager);
+        // Remove the command from content (it's executed, not displayed)
+        processedContent = processedContent.replace(match[0], '');
+    }
+    return processedContent.trim();
+}

package/dist/esm/types/conditionals.d.ts

@@ -0,0 +1,29 @@
+import { ConditionOperator } from './constants';
+/**
+ * Conditional block for Yarn Spinner if/elseif/else/endif
+ */
+export interface ConditionalBlock {
+    type: 'if' | 'elseif' | 'else';
+    condition?: {
+        flag: string;
+        operator: ConditionOperator | 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_equal' | 'less_equal';
+        value?: boolean | number | string;
+    };
+    content: string;
+    nextNodeId?: string;
+}
+/**
+ * Extended DialogueNode with conditional support
+ */
+export interface ConditionalDialogueNode {
+    id: string;
+    type: 'npc' | 'player' | 'conditional';
+    speaker?: string;
+    content: string;
+    choices?: any[];
+    nextNodeId?: string;
+    setFlags?: string[];
+    conditionals?: ConditionalBlock[];
+    x: number;
+    y: number;
+}

package/dist/esm/types/conditionals.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/constants.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Type-safe constants for Dialogue Forge
+ * Use these instead of string literals for better type safety and IDE support
+ */
+/**
+ * Node types in a dialogue tree
+ */
+export declare const NODE_TYPE: {
+    readonly NPC: "npc";
+    readonly PLAYER: "player";
+    readonly CONDITIONAL: "conditional";
+};
+export type NodeType = typeof NODE_TYPE[keyof typeof NODE_TYPE];
+/**
+ * Flag types for game state management
+ */
+export declare const FLAG_TYPE: {
+    readonly DIALOGUE: "dialogue";
+    readonly QUEST: "quest";
+    readonly ACHIEVEMENT: "achievement";
+    readonly ITEM: "item";
+    readonly STAT: "stat";
+    readonly TITLE: "title";
+    readonly GLOBAL: "global";
+};
+/**
+ * Condition operators for choice visibility
+ */
+export declare const CONDITION_OPERATOR: {
+    readonly IS_SET: "is_set";
+    readonly IS_NOT_SET: "is_not_set";
+    readonly EQUALS: "equals";
+    readonly NOT_EQUALS: "not_equals";
+    readonly GREATER_THAN: "greater_than";
+    readonly LESS_THAN: "less_than";
+    readonly GREATER_EQUAL: "greater_equal";
+    readonly LESS_EQUAL: "less_equal";
+};
+export type ConditionOperator = typeof CONDITION_OPERATOR[keyof typeof CONDITION_OPERATOR];
+/**
+ * Flag value types
+ */
+export declare const FLAG_VALUE_TYPE: {
+    readonly BOOLEAN: "boolean";
+    readonly NUMBER: "number";
+    readonly STRING: "string";
+};
+export type FlagValueType = typeof FLAG_VALUE_TYPE[keyof typeof FLAG_VALUE_TYPE];
+/**
+ * Quest state values (common states for quest flags)
+ */
+export declare const QUEST_STATE: {
+    readonly NOT_STARTED: "not_started";
+    readonly STARTED: "started";
+    readonly IN_PROGRESS: "in_progress";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+};
+export type QuestState = typeof QUEST_STATE[keyof typeof QUEST_STATE];

package/dist/esm/types/constants.js

@@ -0,0 +1,55 @@
+/**
+ * Type-safe constants for Dialogue Forge
+ * Use these instead of string literals for better type safety and IDE support
+ */
+/**
+ * Node types in a dialogue tree
+ */
+export const NODE_TYPE = {
+    NPC: 'npc',
+    PLAYER: 'player',
+    CONDITIONAL: 'conditional',
+};
+/**
+ * Flag types for game state management
+ */
+export const FLAG_TYPE = {
+    DIALOGUE: 'dialogue',
+    QUEST: 'quest',
+    ACHIEVEMENT: 'achievement',
+    ITEM: 'item',
+    STAT: 'stat',
+    TITLE: 'title',
+    GLOBAL: 'global',
+};
+/**
+ * Condition operators for choice visibility
+ */
+export const CONDITION_OPERATOR = {
+    IS_SET: 'is_set',
+    IS_NOT_SET: 'is_not_set',
+    EQUALS: 'equals',
+    NOT_EQUALS: 'not_equals',
+    GREATER_THAN: 'greater_than',
+    LESS_THAN: 'less_than',
+    GREATER_EQUAL: 'greater_equal',
+    LESS_EQUAL: 'less_equal',
+};
+/**
+ * Flag value types
+ */
+export const FLAG_VALUE_TYPE = {
+    BOOLEAN: 'boolean',
+    NUMBER: 'number',
+    STRING: 'string',
+};
+/**
+ * Quest state values (common states for quest flags)
+ */
+export const QUEST_STATE = {
+    NOT_STARTED: 'not_started',
+    STARTED: 'started',
+    IN_PROGRESS: 'in_progress',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+};

package/dist/esm/types/flags.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Flag System for Dialogue Forge
+ *
+ * Flags represent game state that can be checked and modified by dialogues.
+ * Different flag types serve different purposes in the game.
+ *
+ * @example
+ * ```typescript
+ * import { FLAG_TYPE, FlagSchema } from '@magicborn/dialogue-forge';
+ *
+ * const mySchema: FlagSchema = {
+ *   flags: [
+ *     {
+ *       id: 'quest_main',
+ *       name: 'Main Quest',
+ *       type: FLAG_TYPE.QUEST,
+ *       category: 'quests'
+ *     }
+ *   ]
+ * };
+ * ```
+ */
+import { FLAG_TYPE, FlagValueType } from './constants';
+export type FlagType = typeof FLAG_TYPE[keyof typeof FLAG_TYPE];
+export interface FlagDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    type: FlagType;
+    category?: string;
+    defaultValue?: boolean | number | string;
+    valueType?: FlagValueType;
+}
+export interface FlagSchema {
+    flags: FlagDefinition[];
+    categories?: string[];
+}
+/**
+ * Flag Reference - used in dialogue nodes
+ */
+export interface FlagReference {
+    flagId: string;
+    operator?: 'is_set' | 'is_not_set' | 'equals' | 'greater_than' | 'less_than';
+    value?: boolean | number | string;
+}
+/**
+ * Example flag schema for a game
+ */
+export declare const exampleFlagSchema: FlagSchema;

package/dist/esm/types/flags.js

@@ -0,0 +1,49 @@
+/**
+ * Flag System for Dialogue Forge
+ *
+ * Flags represent game state that can be checked and modified by dialogues.
+ * Different flag types serve different purposes in the game.
+ *
+ * @example
+ * ```typescript
+ * import { FLAG_TYPE, FlagSchema } from '@magicborn/dialogue-forge';
+ *
+ * const mySchema: FlagSchema = {
+ *   flags: [
+ *     {
+ *       id: 'quest_main',
+ *       name: 'Main Quest',
+ *       type: FLAG_TYPE.QUEST,
+ *       category: 'quests'
+ *     }
+ *   ]
+ * };
+ * ```
+ */
+import { FLAG_TYPE, FLAG_VALUE_TYPE } from './constants';
+/**
+ * Example flag schema for a game
+ */
+export const exampleFlagSchema = {
+    categories: ['quests', 'achievements', 'items', 'stats', 'titles'],
+    flags: [
+        // Quest flags
+        { id: 'quest_dragon_slayer', name: 'Dragon Slayer Quest', type: FLAG_TYPE.QUEST, category: 'quests', valueType: FLAG_VALUE_TYPE.STRING },
+        { id: 'quest_dragon_slayer_complete', name: 'Dragon Slayer Complete', type: FLAG_TYPE.QUEST, category: 'quests' },
+        // Achievement flags
+        { id: 'achievement_first_quest', name: 'First Quest', type: FLAG_TYPE.ACHIEVEMENT, category: 'achievements' },
+        { id: 'achievement_dragon_slayer', name: 'Dragon Slayer', type: FLAG_TYPE.ACHIEVEMENT, category: 'achievements' },
+        // Item flags
+        { id: 'item_ancient_key', name: 'Ancient Key', type: FLAG_TYPE.ITEM, category: 'items' },
+        { id: 'item_gold', name: 'Gold', type: FLAG_TYPE.STAT, category: 'stats', valueType: FLAG_VALUE_TYPE.NUMBER, defaultValue: 0 },
+        // Stat flags
+        { id: 'stat_reputation', name: 'Reputation', type: FLAG_TYPE.STAT, category: 'stats', valueType: FLAG_VALUE_TYPE.NUMBER, defaultValue: 0 },
+        { id: 'stat_charisma', name: 'Charisma', type: FLAG_TYPE.STAT, category: 'stats', valueType: FLAG_VALUE_TYPE.NUMBER, defaultValue: 10 },
+        // Title flags
+        { id: 'title_hero', name: 'Hero', type: FLAG_TYPE.TITLE, category: 'titles' },
+        // Dialogue flags (temporary, dialogue-scoped)
+        { id: 'dialogue_met_stranger', name: 'Met Stranger', type: FLAG_TYPE.DIALOGUE, category: 'dialogue' },
+        { id: 'dialogue_seeks_knowledge', name: 'Seeks Knowledge', type: FLAG_TYPE.DIALOGUE, category: 'dialogue' },
+        { id: 'dialogue_hostile', name: 'Hostile Response', type: FLAG_TYPE.DIALOGUE, category: 'dialogue' },
+    ]
+};