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