/// <summary>
/// Generates a language key for a flex field
/// </summary>
/// <param name="callerContext">Caller context</param>
/// <param name="flexField">Flex field to generate the language key for</param>
/// <returns>Language key</returns>
private async ValueTask <object> GenerateFlexFieldLanguageKey(ScriptNode callerContext, ScribanFlexFieldField flexField)
{
if (!flexField.Exists)
{
string errorValue;
ScribanMissingFlexFieldField missingField = flexField as ScribanMissingFlexFieldField;
if (missingField != null)
{
errorValue = missingField.ErrorValue;
}
else
{
errorValue = flexField.Value != null?flexField.Value.ToString() : string.Format("MISSING_FIELD_{0}", flexField.Name);
}
_errorCollection.AddCanNotGenerateLanguageKey(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return(errorValue);
}
if (flexField.ParentObject == null)
{
_errorCollection.AddCanNotGenerateLanguageKey(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<INVALID ARGUMENTS FOR LANGKEY>>");
}
return(await _languageKeyGenerator.GetFlexFieldFieldKey(flexField.ParentObject.Id, flexField.ParentObject.Name, flexField.ParentObject.ExportObjectType, flexField.Id, flexField.Name, flexField.UnescapedValue.ToString()));
}
/// <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>
/// 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 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>
/// Loads a template
/// </summary>
/// <param name="templateName">Template name</param>
/// <param name="callerSpan">Caller span</param>
/// <returns>Code of the template</returns>
private async Task <string> LoadTemplate(string templateName, SourceSpan callerSpan)
{
GoNorthProject project = await _cachedDbAccess.GetUserProject();
IncludeExportTemplate includeExportTemplate = await _cachedDbAccess.GetIncludeTemplateByName(project.Id, templateName);
if (includeExportTemplate == null)
{
_errorCollection.AddIncludeTemplateNotFoundError(templateName, ScribanErrorUtil.FormatScribanSpan(callerSpan));
return("<<INCLUDE TEMPLATE NOT FOUND>>");
}
return(includeExportTemplate.Code);
}
/// <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 an state machine function
/// </summary>
/// <param name="context">Template context</param>
/// <param name="callerContext">Caller context</param>
/// <param name="arguments">Arguments to render the function with</param>
/// <returns>Rendered state machine function</returns>
private async ValueTask <object> RenderStateMachineFunction(TemplateContext context, ScriptNode callerContext, ScriptArray arguments)
{
if (arguments.Count != 1 || !(arguments[0] is ScribanExportStateFunction))
{
_errorCollection.AddInvalidParameter(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<DID NOT PROVIDE VALID STATE MACHINE FUNCTION>>");
}
ScribanExportStateFunction exportFunction = (ScribanExportStateFunction)arguments[0];
GoNorthProject curProject = await _exportCachedDbAccess.GetUserProject();
ExportTemplate eventFunctionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(curProject.Id, TemplateType.ObjectStateFunction);
ExportObjectData objectData = new ExportObjectData();
objectData.ExportData.Add(ExportConstants.ExportDataObject, exportFunction.ToStateFunction());
ExportPlaceholderFillResult fillResult = await _templatePlaceholderResolver.FillPlaceholders(TemplateType.ObjectStateFunction, eventFunctionTemplate.Code, objectData, eventFunctionTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ScribanOutputUtil.IndentMultilineCode(context, fillResult.Code));
}
/// <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>
/// Generates a language key from a call hierarchy
/// </summary>
/// <param name="templateContext">Template context</param>
/// <param name="callerContext">Call context</param>
/// <param name="callHierarchy">Call hierarchy</param>
/// <returns>Language key</returns>
private async ValueTask <object> GenerateLanguageKeyFromCallHierarchy(TemplateContext templateContext, ScriptNode callerContext, List <string> callHierarchy)
{
if (callHierarchy.Count < 2)
{
_errorCollection.AddCanNotGenerateLanguageKey(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<INVALID ARGUMENTS FOR LANGKEY>>");
}
string objectNameValue = StandardMemberRenamer.Rename(nameof(ScribanFlexFieldObject.Name));
string fieldValue = StandardMemberRenamer.Rename(nameof(ScribanFlexFieldField.Value));
string unescapedFieldValue = StandardMemberRenamer.Rename(nameof(ScribanFlexFieldField.UnescapedValue));
string textLineValue = StandardMemberRenamer.Rename(nameof(ScribanTextLine.TextLine));
string choiceText = StandardMemberRenamer.Rename(nameof(ScribanChoiceOption.Text));
string addQuestText = StandardMemberRenamer.Rename(nameof(ScribanAddQuestTextActionData.Text));
string floatingTextData = StandardMemberRenamer.Rename(nameof(ScribanShowFloatingTextActionData.Text));
if (callHierarchy[callHierarchy.Count - 1] == objectNameValue || callHierarchy[callHierarchy.Count - 1] == fieldValue || callHierarchy[callHierarchy.Count - 1] == unescapedFieldValue)
{
ScriptNode parentObjectExpression = BuildParentObjectValueScriptExpression(callHierarchy);
object parentObject = templateContext.Evaluate(parentObjectExpression);
if (parentObject == null)
{
_errorCollection.AddCanNotGenerateLanguageKey(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<INVALID ARGUMENTS FOR LANGKEY>>");
}
if (parentObject is ScribanFlexFieldObject)
{
ScribanFlexFieldObject langObject = (ScribanFlexFieldObject)parentObject;
return(await _languageKeyGenerator.GetFlexFieldNameKey(langObject.Id, langObject.Name, langObject.ExportObjectType));
}
else if (parentObject is ScribanFlexFieldField)
{
return(await GenerateFlexFieldLanguageKey(callerContext, (ScribanFlexFieldField)parentObject));
}
}
else if (callHierarchy[callHierarchy.Count - 1] == textLineValue)
{
ScriptNode parentObjectExpression = BuildParentObjectValueScriptExpression(callHierarchy);
object parentObject = templateContext.Evaluate(parentObjectExpression);
if (parentObject is ScribanTextLine)
{
ScribanTextLine textLine = (ScribanTextLine)parentObject;
return(await _languageKeyGenerator.GetDialogTextLineKey(textLine.NodeObject.Id, textLine.NodeObject.Name, textLine.IsPlayerLine?ExportConstants.LanguageKeyTypePlayer : ExportConstants.LanguageKeyTypeNpc,
textLine.NodeId, textLine.UnescapedTextLine));
}
}
else if (callHierarchy[callHierarchy.Count - 1] == choiceText || callHierarchy[callHierarchy.Count - 1] == addQuestText || callHierarchy[callHierarchy.Count - 1] == floatingTextData)
{
ScriptNode parentObjectExpression = BuildParentObjectValueScriptExpression(callHierarchy);
object parentObject = templateContext.Evaluate(parentObjectExpression);
if (parentObject is ScribanChoiceOption)
{
ScribanChoiceOption choiceOption = (ScribanChoiceOption)parentObject;
return(await _languageKeyGenerator.GetDialogTextLineKey(choiceOption.ParentChoice.NodeObject.Id, choiceOption.ParentChoice.NodeObject.Name, ExportConstants.LanguageKeyTypeChoice,
string.Format("{0}_{1}", choiceOption.ParentChoice.NodeId, choiceOption.Id), choiceOption.UnescapedText));
}
else if (parentObject is ScribanAddQuestTextActionData)
{
ScribanAddQuestTextActionData addQuestTextData = (ScribanAddQuestTextActionData)parentObject;
return(await _languageKeyGenerator.GetDialogTextLineKey(addQuestTextData.FlexFieldObject.Id, addQuestTextData.Quest.Name, ExportConstants.LanguageKeyTypeQuest, addQuestTextData.NodeStep.Id,
addQuestTextData.UnescapedText));
}
else if (parentObject is ScribanShowFloatingTextActionData)
{
ScribanShowFloatingTextActionData showFloatingTextData = (ScribanShowFloatingTextActionData)parentObject;
string languageKeyType = ExportConstants.LanguageKeyTypeNpc;
if (showFloatingTextData.TargetNpc != null && showFloatingTextData.TargetNpc.IsPlayer)
{
languageKeyType = ExportConstants.LanguageKeyTypePlayer;
}
return(await _languageKeyGenerator.GetDialogTextLineKey(showFloatingTextData.FlexFieldObject.Id, showFloatingTextData.FlexFieldObject.Name, languageKeyType, showFloatingTextData.NodeStep.Id,
showFloatingTextData.UnescapedText));
}
}
_errorCollection.AddCanNotGenerateLanguageKey(ScribanErrorUtil.FormatScribanSpan(callerContext.Span));
return("<<UNSUPPORTED PROPERTY FOR LANGKEY>>");
}
