glasshouse/src/DialogueManager.hx

import hxyarn.dialogue.Dialogue;
import hxyarn.dialogue.VariableStorage.MemoryVariableStore;
import hxyarn.dialogue.StringInfo;
import hxyarn.dialogue.Line;
import hxyarn.dialogue.Command;
import hxyarn.dialogue.Option;
import hxyarn.dialogue.OptionSet;
import hxyarn.compiler.Compiler;
import hxyarn.compiler.CompilationJob;

typedef Option = {
	text:String,
	callback:() -> Void
};

class DialogueManager {
    var storage = new MemoryVariableStore();
    var dialogue:Dialogue;
    var stringTable:Map<String, StringInfo>;
    var dialogueCallback:(DialogueManager, String) -> Void;
    var optionCallback:(DialogueManager, Array<Option>) -> Void;

    public function new(_dialogueCallback:(DialogueManager, String) -> Void, _optionCallback:(DialogueManager, Array<Option>) -> Void) {
        dialogue = new Dialogue(new MemoryVariableStore());

        dialogue.logDebugMessage = this.logDebugMessage;
        dialogue.logErrorMessage = this.logErrorMessage;
        dialogue.lineHandler = this.lineHandler;
        dialogue.optionsHandler = this.optionsHandler;
        dialogue.commandHandler = this.commandHandler;
        dialogue.nodeCompleteHandler = this.nodeCompleteHandler;
        dialogue.nodeStartHandler = this.nodeStartHandler;
        dialogue.dialogueCompleteHandler = this.dialogueCompleteHandler;

        dialogueCallback = _dialogueCallback;
        optionCallback = _optionCallback;
    }

    public function load(text:Array<String>, fileNames:Array<String>) {
        var job = CompilationJob.createFromStrings(text, fileNames, dialogue.library);
        var compiler = Compiler.compile(job);
        stringTable = compiler.stringTable;

        dialogue.addProgram(compiler.program);
    }

    public function runNode(nodeName:String) {
        dialogue.setNode(nodeName);
        dialogue.resume();
    }

    public function unload() {
        dialogue.unloadAll();
    }

    public function resume() {
        dialogue.resume();
    }

    public function logDebugMessage(message:String):Void {
    }

    public function logErrorMessage(message:String):Void {
    }

    public function lineHandler(line:Line):HandlerExecutionType {
        var text = getComposedTextForLine(line);

        dialogueCallback(this, text);

        return HandlerExecutionType.ContinueExecution;
    }

    public function optionsHandler(options:OptionSet) {
        var optionCount = options.options.length;
        var optionChoices = new Array<Option>();

        for (i => option in options.options) {
          var text = getComposedTextForLine(option.line);
          optionChoices.push({
            text: text,
            callback: function() {
                dialogue.setSelectedOption(i);
                dialogue.resume();
            }
          });
        }


        optionCallback(this, optionChoices);
    }

    public function getComposedTextForLine(line:Line):String {
        var substitutedText = Dialogue.expandSubstitutions(stringTable[line.id].text, line.substitutions);

        var markup = dialogue.parseMarkup(substitutedText);

        return markup.text;
    }

    public function commandHandler(command:Command) {
    }

    public function nodeCompleteHandler(nodeName:String) {}

    public function nodeStartHandler(nodeName:String) {}

    public function dialogueCompleteHandler() {
    }

    public function getNodeNames(?includesTag = "") {
        var nodeNames = [];
        for (nodeName in dialogue.allNodes) {
            if (includesTag == "") {
                nodeNames.push(nodeName);
                continue;
            }

            var tags = dialogue.getTagsForNode(nodeName);
            if (tags.contains(includesTag)) {
                nodeNames.push(nodeName);
            }
        }
        return nodeNames;
    }
}