/// <summary> /// Renders a condition step /// </summary> /// <param name="template">Export template</param> /// <param name="data">Dialog Step Data</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="conditionNode">Condition node to render</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportTemplate template, ExportDialogData data, FlexFieldObject flexFieldObject, ConditionNode conditionNode) { ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, _errorCollection); if (parsedTemplate == null) { return(renderResult); } ScribanCondition conditionData = new ScribanCondition(); SetRenderObjectBaseDataFromFlexFieldObject(conditionData, data, flexFieldObject); conditionData.AllConditions = await BuildAllConditions(data, flexFieldObject, conditionNode); conditionData.Conditions = conditionData.AllConditions.Where(c => c.ChildNode != null).ToList(); conditionData.Else = BuildElsePart(data, flexFieldObject); TemplateContext context = BuildTemplateContext(conditionData); renderResult.StepCode = await parsedTemplate.RenderAsync(context); return(renderResult); }
/// <summary> /// Fills the placeholders of a code /// </summary> /// <param name="templateType">Template Type</param> /// <param name="code">Code to fill</param> /// <param name="data">Export Data</param> /// <returns>Filled Code</returns> public async Task <ExportPlaceholderFillResult> FillPlaceholders(TemplateType templateType, string code, ExportObjectData data) { ExportPlaceholderErrorCollection errorCollection = new ExportPlaceholderErrorCollection(_localizerFactory); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(code, errorCollection); if (parsedTemplate != null) { ScriptObject exportObject = await BuildScriptObject(templateType, parsedTemplate, data, errorCollection); TemplateContext context = BuildTemplateContext(exportObject, errorCollection); try { code = await parsedTemplate.RenderAsync(context); } catch (Exception ex) { errorCollection.AddException(ex); } } ExportPlaceholderFillResult result = new ExportPlaceholderFillResult(); result.Code = code; result.Errors = errorCollection; return(result); }
/// <summary> /// Renders a dialog step /// </summary> /// <param name="template">Export template</param> /// <param name="data">Dialog Step Data</param> /// <param name="npc">Npc object to which the dialog belongs</param> /// <param name="textNode">Text node to render</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportTemplate template, ExportDialogData data, KortistoNpc npc, TextNode textNode) { ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, _errorCollection); if (parsedTemplate == null) { return(renderResult); } _languageKeyGenerator.SetErrorCollection(_errorCollection); ScribanTextLine textLineData = BuildDialogRenderObject <ScribanTextLine>(data, data.Children.FirstOrDefault() != null ? data.Children.FirstOrDefault().Child : null, npc); textLineData.TextLine = ExportUtil.EscapeCharacters(textNode.Text, _exportSettings.EscapeCharacter, _exportSettings.CharactersNeedingEscaping, _exportSettings.NewlineCharacter); textLineData.UnescapedTextLine = textNode.Text; textLineData.TextLinePreview = ExportUtil.BuildTextPreview(textNode.Text); textLineData.IsPlayerLine = _isPlayerLine; TemplateContext context = BuildTemplateContext(textLineData); renderResult.StepCode = await parsedTemplate.RenderAsync(context); return(renderResult); }
/// <summary> /// Renders an skill List /// </summary> /// <param name="context">Template context</param> /// <param name="callerContext">Caller context</param> /// <param name="arguments">Arguments to render the list with</param> /// <returns>Rendered skill list</returns> private async ValueTask <object> RenderSkillList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments) { if (!_exportObjectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) || !(_exportObjectData.ExportData[ExportConstants.ExportDataObject] is KortistoNpc)) { _errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span)); return("<<NO VALID NPC CONTEXT>>"); } List <ScribanExportSkill> skillList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanExportSkill>(arguments, 0); if (skillList == null) { _errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span)); return("<<DID NOT PROVIDE VALID SKILL LIST>>"); } GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject(); ExportTemplate skillListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectSkillList); ExportObjectData objectData = _exportObjectData.Clone(); ((KortistoNpc)objectData.ExportData[ExportConstants.ExportDataObject]).Skills = ConvertSkillsToKortistoNpcSkill(skillList); ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectSkillList, skillListTemplate.Code, objectData, skillListTemplate.RenderingEngine); _errorCollection.Merge(fillResult.Errors); return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code)); }
/// <summary> /// Builds a condition element from parsed data /// </summary> /// <param name="template">Export template to use</param> /// <param name="parsedData">Parsed data</param> /// <param name="project">Project</param> /// <param name="errorCollection">Error Collection</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="exportSettings">Export Settings</param> /// <returns>Condition string</returns> public override async Task <string> BuildConditionElementFromParsedData(ExportTemplate template, ConfigClass parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings) { Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, errorCollection); if (parsedTemplate == null) { return(string.Empty); } if (_languageKeyGenerator != null) { _languageKeyGenerator.SetErrorCollection(errorCollection); } ScribanRenderingClass renderingObject = await GetExportObject(parsedData, project, errorCollection, flexFieldObject, exportSettings); if (renderingObject == null) { return(string.Empty); } TemplateContext context = BuildTemplateContext(renderingObject, errorCollection); string conditionCode = await parsedTemplate.RenderAsync(context); return(conditionCode); }
/// <summary> /// Renders an daily routine event list /// </summary> /// <param name="context">Template context</param> /// <param name="callerContext">Caller context</param> /// <param name="arguments">Arguments to render the list with</param> /// <returns>Rendered daily routine event list</returns> private async ValueTask <object> RenderDailyRoutineEventList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments) { List <ScribanExportDailyRoutineEvent> eventList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanExportDailyRoutineEvent>(arguments, 0); if (eventList == null) { _errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span)); return("<<DID NOT PROVIDE VALID EVENT LIST>>"); } GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject(); ExportTemplate eventListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectDailyRoutineEventList); ExportObjectData objectData = _exportObjectData.Clone(); if (objectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) && objectData.ExportData[ExportConstants.ExportDataObject] is KortistoNpc) { ((KortistoNpc)objectData.ExportData[ExportConstants.ExportDataObject]).DailyRoutine = eventList.Select(e => e.OriginalEvent).ToList(); } ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectDailyRoutineEventList, eventListTemplate.Code, objectData, eventListTemplate.RenderingEngine); _errorCollection.Merge(fillResult.Errors); return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code)); }
/// <summary> /// Renders an action step /// </summary> /// <param name="template">Export template</param> /// <param name="data">Dialog Step Data</param> /// <param name="nextStep">Next step in the dialog</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="actionContent">Content of the action</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportTemplate template, ExportDialogData data, ExportDialogDataChild nextStep, FlexFieldObject flexFieldObject, string actionContent) { ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, _errorCollection); if (parsedTemplate == null) { return(renderResult); } ScribanAction actionData = BuildDialogRenderObject <ScribanAction>(data, nextStep != null ? nextStep.Child : null, flexFieldObject); actionData.Content = actionContent; if (_nextStepNodeData != null) { actionData.NodeStepFunctionWasUsed = _nextStepNodeData.NodeStepFunctionWasUsed; if (actionData.ChildNode != null && _nextStepNodeData.ChildNode != null) { actionData.ChildNode.NodeStepFunctionWasUsed = _nextStepNodeData.ChildNode.NodeStepFunctionWasUsed; } } TemplateContext context = BuildTemplateContext(actionData); renderResult.StepCode = await parsedTemplate.RenderAsync(context); return(renderResult); }
/// <summary> /// Renders an attribute List /// </summary> /// <param name="context">Template context</param> /// <param name="callerContext">Caller context</param> /// <param name="arguments">Arguments to render the list with</param> /// <returns>Rendered attribute list</returns> private async ValueTask <object> RenderAttributeList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments) { List <ScribanFlexFieldField> fieldList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanFlexFieldField>(arguments, 0); if (fieldList == null) { _errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span)); return("<<DID NOT PROVIDE VALID ATTRIBUTE LIST>>"); } GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject(); ExportTemplate attributeListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectAttributeList); ExportObjectData objectData = _exportObjectData.Clone(); if (objectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) && objectData.ExportData[ExportConstants.ExportDataObject] is IFlexFieldExportable) { ((IFlexFieldExportable)objectData.ExportData[ExportConstants.ExportDataObject]).Fields = ConvertListToFlexFieldList(fieldList); } ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectAttributeList, attributeListTemplate.Code, objectData, attributeListTemplate.RenderingEngine); _errorCollection.Merge(fillResult.Errors); return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code)); }
/// <summary> /// Replaces the base placeholders /// </summary> /// <param name="errorCollection">Error collection</param> /// <param name="code">Code to fill</param> /// <param name="data">Dialog Step Data</param> /// <param name="nextStep">Next step in the dialog</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <returns>Base placeholders</returns> public async Task <string> ReplaceBasePlaceholders(ExportPlaceholderErrorCollection errorCollection, string code, ExportDialogData data, ExportDialogData nextStep, FlexFieldObject flexFieldObject) { Template parsedTemplate = ScribanParsingUtil.ParseTemplate(code, _errorCollection); if (parsedTemplate == null) { return(code); } ScribanDialogStepBaseDataWithNextNode nodeData = GetBaseNodeData(data, nextStep, flexFieldObject); TemplateContext context = BuildTemplateContext(nodeData); return(await parsedTemplate.RenderAsync(context)); }
/// <summary> /// Renders a dialog step /// </summary> /// <param name="template">Export template</param> /// <param name="data">Dialog Step Data</param> /// <param name="project">Project for which the epxort is running</param> /// <param name="referenceNodeData">Reference node data</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportTemplate template, ExportDialogData data, GoNorthProject project, ReferenceNodeData referenceNodeData, FlexFieldObject flexFieldObject) { ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, _errorCollection); if (parsedTemplate == null) { return(renderResult); } MiscProjectConfig projectConfig = await _exportCachedDbAccess.GetMiscProjectConfig(); _languageKeyGenerator.SetErrorCollection(_errorCollection); ScribanReferenceData referenceData = BuildDialogRenderObject <ScribanReferenceData>(data, data.Children.FirstOrDefault() != null ? data.Children.FirstOrDefault().Child : null, flexFieldObject); referenceData.ReferenceText = referenceNodeData.ReferenceText != null ? referenceNodeData.ReferenceText : string.Empty; referenceData.ObjectType = referenceNodeData.ObjectType; if (referenceNodeData.Npc != null) { referenceData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, referenceNodeData.Npc, _exportSettings, _errorCollection); referenceData.Npc.IsPlayer = referenceNodeData.Npc.IsPlayerNpc; } else { referenceData.Npc = null; } referenceData.Item = referenceNodeData.Item != null?FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportItem>(null, null, referenceNodeData.Item, _exportSettings, _errorCollection) : null; referenceData.Skill = referenceNodeData.Skill != null?FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, null, referenceNodeData.Skill, _exportSettings, _errorCollection) : null; referenceData.Quest = referenceNodeData.Quest != null?FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportQuest>(null, null, referenceNodeData.Quest, _exportSettings, _errorCollection) : null; referenceData.WikiPage = referenceNodeData.WikiPage != null ? new ScribanExportWikiPage(referenceNodeData.WikiPage) : null; referenceData.DailyRoutineEvent = referenceNodeData.DailyRoutineEvent != null ? await ScribanDailyRoutineEventUtil.ConvertDailyRoutineEvent(_dailyRoutineFunctionNameGenerator, referenceNodeData.Npc, referenceNodeData.DailyRoutineEvent, project, projectConfig, _exportSettings) : null; referenceData.Marker = referenceNodeData.Marker != null ? new ScribanExportMapMarker(referenceNodeData.Marker) : null; TemplateContext context = BuildTemplateContext(referenceData); renderResult.StepCode = await parsedTemplate.RenderAsync(context); return(renderResult); }
/// <summary> /// Returns a language key /// </summary> /// <param name="templateContext">Template context</param> /// <param name="callerContext">Call context</param> /// <param name="arguments">Arguments</param> /// <returns>Language key</returns> private async ValueTask <object> GetLanguageKey(TemplateContext templateContext, ScriptNode callerContext, ScriptArray arguments) { ScriptFunctionCall functionCall = callerContext as ScriptFunctionCall; if (functionCall == null) { _errorCollection.AddCanNotGenerateLanguageKey(ScribanErrorUtil.FormatScribanSpan(callerContext.Span)); return("<<USE NON PIPE NOTATION FOR LANGKEY>>"); } if (functionCall.Arguments.Count != 1 || arguments.Count != 1) { _errorCollection.AddCanNotGenerateLanguageKey(ScribanErrorUtil.FormatScribanSpan(callerContext.Span)); return("<<PASS IN EXACTLY ONE ARGUMENT FOR LANGKEY>>"); } List <string> callHierarchy = ScribanParsingUtil.GetCallerHierarchy(functionCall.Arguments[0]); return(await GenerateLanguageKeyFromCallHierarchy(templateContext, callerContext, callHierarchy)); }
/// <summary> /// Renders a choice step /// </summary> /// <param name="template">Export template</param> /// <param name="data">Dialog Step Data</param> /// <param name="npc">Npc object to which the dialog belongs</param> /// <param name="choiceNode">Choice node to render</param> /// <returns>Dialog Step Render Result</returns> public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportTemplate template, ExportDialogData data, KortistoNpc npc, TaleChoiceNode choiceNode) { ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult(); Template parsedTemplate = ScribanParsingUtil.ParseTemplate(template.Code, _errorCollection); if (parsedTemplate == null) { return(renderResult); } _languageKeyGenerator.SetErrorCollection(_errorCollection); ScribanChoice choiceData = new ScribanChoice(); SetRenderObjectBaseDataFromFlexFieldObject(choiceData, data, npc); choiceData.Choices = await BuildChoiceOptions(data, choiceNode, npc, choiceData); TemplateContext context = BuildTemplateContext(choiceData); renderResult.StepCode = await parsedTemplate.RenderAsync(context); return(renderResult); }
/// <summary> /// Renders an daily routine function list /// </summary> /// <param name="context">Template context</param> /// <param name="callerContext">Caller context</param> /// <param name="arguments">Arguments to render the list with</param> /// <returns>Rendered daily routine function list</returns> private async ValueTask <object> RenderDailyRoutineFunctionList(TemplateContext context, ScriptNode callerContext, ScriptArray arguments) { List <ScribanExportDailyRoutineFunction> functionList = ScribanParsingUtil.GetArrayFromScribanArgument <ScribanExportDailyRoutineFunction>(arguments, 0); if (functionList == null) { _errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span)); return("<<DID NOT PROVIDE VALID FUNCTION LIST>>"); } GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject(); ExportTemplate functionListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectDailyRoutineFunctionList); ExportObjectData objectData = new ExportObjectData(); objectData.ExportData.Add(ExportConstants.ExportDataObject, functionList.Select(f => f.ToDailyRoutineFunction()).ToList()); ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectDailyRoutineFunctionList, functionListTemplate.Code, objectData, functionListTemplate.RenderingEngine); _errorCollection.Merge(fillResult.Errors); return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code)); }
/// <summary> /// Fills the placeholders /// </summary> /// <param name="cachedDbAccess">Cached database access</param> /// <param name="errorCollection">Error collection</param> /// <param name="code">Code to fill</param> /// <param name="valueObject">Value object to use</param> /// <param name="flexFieldObject">Flex field object to which the dialog belongs</param> /// <param name="curStep">Current step that is rendered</param> /// <param name="nextStep">Next step that is being rendered</param> /// <param name="languageKeyGenerator">Language key generator, null to not use it</param> /// <param name="stepRenderer">Action Step renderer</param> /// <typeparam name="T">Value object type</typeparam> /// <returns>Filled placeholders</returns> public static async Task <string> FillPlaceholders <T>(IExportCachedDbAccess cachedDbAccess, ExportPlaceholderErrorCollection errorCollection, string code, T valueObject, FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, IScribanLanguageKeyGenerator languageKeyGenerator, IActionStepRenderer stepRenderer) where T : class { if (!stepRenderer.UsesValueObject()) { code = await stepRenderer.ReplaceBasePlaceholders(errorCollection, code, curStep, nextStep, flexFieldObject); } Template parsedTemplate = ScribanParsingUtil.ParseTemplate(code, errorCollection); if (parsedTemplate == null) { return(string.Empty); } if (languageKeyGenerator != null) { languageKeyGenerator.SetErrorCollection(errorCollection); } TemplateContext context = BuildTemplateContext(cachedDbAccess, errorCollection, valueObject, languageKeyGenerator, stepRenderer, flexFieldObject, curStep, nextStep); return(await parsedTemplate.RenderAsync(context)); }