/// <summary>
        /// Renders a list of state functions
        /// </summary>
        /// <param name="state">State to render</param>
        /// <param name="flexFieldObject">Npc to which the events belong</param>
        /// <returns>List of state functions</returns>
        public async Task <List <StateFunction> > RenderStateFunctions(StateMachineState state, FlexFieldObject flexFieldObject)
        {
            if (state == null)
            {
                return(new List <StateFunction>());
            }

            _nodeGraphParser.SetErrorCollection(_errorCollection);

            _curProject = await _cachedDbAccess.GetUserProject();

            _exportSettings = await _cachedDbAccess.GetExportSettings(_curProject.Id);

            SetupStepRenderes();

            List <StateFunction> functions = new List <StateFunction>();

            if (state.ScriptType == ExportConstants.ScriptType_None)
            {
                return(functions);
            }

            StateFunction function = new StateFunction();

            functions.Add(function);

            function.FunctionName = await _stateMachineFunctionNameGenerator.GetNewStateMachineStepFunction(_curProject.Id, flexFieldObject.Id, state.Id);

            function.ParentPreviewText = "";
            if (state.ScriptType == ExportConstants.ScriptType_Code)
            {
                function.Code = state.ScriptCode;
            }
            else
            {
                await RenderStateMachineEventNodeGraph(functions, state.ScriptNodeGraph, flexFieldObject, function);
            }

            return(functions);
        }
        /// <summary>
        /// Renders a state machine event node graph
        /// </summary>
        /// <param name="functions">Functions array to fill</param>
        /// <param name="scriptNodeGraph">Node graph to render</param>
        /// <param name="flexFieldObject">Npc to which the events belong</param>
        /// <param name="rootStateMachineFunction">Root state machine function to fill</param>
        /// <returns>Task</returns>
        private async Task RenderStateMachineEventNodeGraph(List <StateFunction> functions, NodeGraphSnippet scriptNodeGraph, FlexFieldObject flexFieldObject, StateFunction rootStateMachineFunction)
        {
            _nodeGraphParser.SetErrorCollection(_errorCollection);
            ExportDialogData exportData = _nodeGraphParser.ParseNodeGraph(scriptNodeGraph);

            if (exportData == null)
            {
                return;
            }

            exportData = await _nodeGraphFunctionGenerator.GenerateFunctions(flexFieldObject.ProjectId, flexFieldObject.Id, exportData, _errorCollection);

            ExportDialogFunction rootFunction = new ExportDialogFunction(exportData);

            AddNodesToFunction(rootFunction, exportData);
            List <ExportDialogFunction> additionalFunctions = ExtractAdditionalFunctions(exportData);

            rootStateMachineFunction.Code = await RenderDialogStepList(rootFunction.FunctionSteps, flexFieldObject);

            foreach (ExportDialogFunction curAdditionalFunction in additionalFunctions)
            {
                StateFunction additionalFunction = new StateFunction();
                additionalFunction.FunctionName      = curAdditionalFunction.RootNode.DialogStepFunctionName;
                additionalFunction.ParentPreviewText = await BuildFunctionParentPreview(curAdditionalFunction, flexFieldObject);

                string functionContent = await RenderDialogStepList(curAdditionalFunction.FunctionSteps, flexFieldObject);

                additionalFunction.Code = functionContent;

                functions.Add(additionalFunction);
            }
        }