glasshouse/src/dialogue/DialogueManager.hx

package dialogue;

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.dialogue.markup.MarkupParseResult;
import hxyarn.compiler.Compiler;
import hxyarn.compiler.CompilationJob;

import event.EventBus;
import dialogue.command.ICommandHandler;
import dialogue.event.LineShown;
import dialogue.event.OptionsShown;
import dialogue.event.OptionsShown.OptionChoice;
import dialogue.event.OptionSelected;
import dialogue.event.NextLine;
import dialogue.event.StartDialogueNode;
import dialogue.event.DialogueComplete;

class DialogueManager {
    public var eventBus:EventBus;

    var storage = new MemoryVariableStore();
    var dialogue:Dialogue;
    var stringTable:Map<String, StringInfo>;
    var commandHandlers = new Map<String, ICommandHandler>();

    public var waitingForOption:Bool = false;

    public function new(eventBus:EventBus) {
	this.eventBus = eventBus;
        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;

	eventBus.subscribe(NextLine, this.nextLine);
	eventBus.subscribe(OptionSelected, this.optionSelected);
	eventBus.subscribe(StartDialogueNode, function(event) {
	    this.runNode(event.node);
	});
    }

    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 nextLine(event:NextLine) {
	if ((dialogue.isActive()) && (!waitingForOption))
	    dialogue.resume();
    }

    public function lineHandler(line:Line):Void {
        var text = getComposedTextForLine(line);
	eventBus.publishEvent(new LineShown(text));
    }

    public function optionSelected(event:OptionSelected) {
	dialogue.setSelectedOption(event.index);
	dialogue.resume();
	waitingForOption = false;
    }

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

        for (i => option in options.options) {
          var markup = getComposedTextForLine(option.line);
          optionChoices.push({
            text: markup.text,
	    index: i,
	    enabled: option.enabled,
	    markup: markup
          });
        }

	eventBus.publishEvent(new OptionsShown(optionChoices));

	waitingForOption = true;
    }

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

        return dialogue.parseMarkup(substitutedText);
    }

    public function commandHandler(command:Command) {
	var parts = command.text.split(' ');
	var key = parts.shift();
	if (commandHandlers.exists(key)) {
	    if (commandHandlers.get(key).handleCommand(parts)) {
		resume();
		return;
	    }
	}

	resume();
    }

    public function addCommandHandler(handler:ICommandHandler) {
	if (handler.commandName == null || handler.commandName == "") {
	    trace("Command handler has no command name");
	    return;
	}

	commandHandlers.set(handler.commandName, handler);
    }

    public function nodeCompleteHandler(nodeName:String) {}

    public function nodeStartHandler(nodeName:String) {}

    public function dialogueCompleteHandler() {
	eventBus.publishEvent(new DialogueComplete(""));
    }

    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;
    }
}