/// <summary>
/// Renders a dialog step
/// </summary>
/// <param name="data">Dialog Step Data</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <returns>Dialog Step Render Result</returns>
public async Task <ExportDialogStepRenderResult> RenderDialogStep(ExportDialogData data, KortistoNpc npc)
{
ConditionNode conditionNode = data.Condition;
if (conditionNode == null)
{
return(null);
}
ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, TemplateType.TaleCondition);
ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult();
renderResult.StepCode = ReplaceNodeId(template.Code, data);
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ConditionsStart, Placeholder_ConditionsEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(BuildConditions(m.Groups[1].Value, data, conditionNode, npc, false), m.Groups[2].Value)));
});
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_AllConditionsStart, Placeholder_AllConditionsEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(BuildConditions(m.Groups[1].Value, data, conditionNode, npc, true), m.Groups[2].Value)));
});
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ElseStart, Placeholder_ElseEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.IndentListTemplate(BuildElsePart(m.Groups[1].Value, data), m.Groups[2].Value));
});
return(renderResult);
}
/// <summary>
/// Fills the daily routine placeholders
/// </summary>
/// <param name="code">Code</param>
/// <param name="npc">Npc</param>
/// <returns>Filled code</returns>
private async Task <string> FillDailyRoutinePlaceholders(string code, KortistoNpc npc)
{
GoNorthProject project = await _cachedDbAccess.GetDefaultProject();
ExportTemplate dailyRoutineEventTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineEventList);
ExportTemplate dailyRoutineFunctionListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunctionList);
ExportTemplate dailyRoutineFunctionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunction);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Events, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.IndentListTemplate(dailyRoutineEventTemplate.Code, m.Groups[1].Value));
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Functions, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.IndentListTemplate(dailyRoutineFunctionListTemplate.Code, m.Groups[1].Value));
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Function, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.IndentListTemplate(dailyRoutineFunctionTemplate.Code, m.Groups[1].Value));
});
code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasDailyRoutine_Start, Placeholder_HasDailyRoutine_End, npc.DailyRoutine != null && npc.DailyRoutine.Count > 0);
code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_DailyRoutine_Events_Start, Placeholder_DailyRoutine_Events_End).Replace(code, m => {
return(ExportUtil.TrimEmptyLines(BuildEventList(m.Groups[1].Value, project, npc)));
});
code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_DailyRoutine_Functions_Start, Placeholder_DailyRoutine_Functions_End).Replace(code, m => {
return(ExportUtil.TrimEmptyLines(BuildFunctionList(m.Groups[1].Value, project, npc)));
});
return(code);
}
/// <summary>
/// Renders the dialog
/// </summary>
/// <param name="project">Current Project</param>
/// <param name="code">Template code</param>
/// <param name="exportDialog">Export dialog data</param>
/// <param name="dialog">Dialog</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <returns>Filled code</returns>
private async Task <string> RenderDialog(GoNorthProject project, string code, ExportDialogData exportDialog, TaleDialog dialog, KortistoNpc npc)
{
if (exportDialog == null)
{
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Start).Replace(code, string.Empty);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Additional_Functions).Replace(code, string.Empty);
return(code);
}
List <ExportDialogFunctionCode> dialogRenderResult = await _dialogRenderer.RenderDialogSteps(exportDialog, npc);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Start, ExportConstants.ListIndentPrefix).Replace(code, m => {
if (dialogRenderResult.Any())
{
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(dialogRenderResult[0].Code, m.Groups[1].Value)));
}
return(string.Empty);
});
code = await ExportUtil.BuildPlaceholderRegex(Placeholder_Additional_Functions, ExportConstants.ListIndentPrefix).ReplaceAsync(code, async m => {
string finalCode = string.Empty;
foreach (ExportDialogFunctionCode curFunction in dialogRenderResult.Skip(1))
{
finalCode += await RenderFunctionForList(project, curFunction);
}
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(finalCode, m.Groups[1].Value)));
});
return(code);
}
/// <summary>
/// Fills the function code for a daily routine
/// </summary>
/// <param name="code">Code to fill</param>
/// <param name="function">Function data</param>
/// <returns>Filled code</returns>
public string FillFunctionCode(string code, DailyRoutineFunction function)
{
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, Placeholder_HasAdditionalScriptFunctions_Start, Placeholder_HasAdditionalScriptFunctions_End, m =>
{
return(false);
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, Placeholder_HasNoAdditionalScriptFunctions_Start, Placeholder_HasNoAdditionalScriptFunctions_End, m =>
{
return(false);
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_ScriptFunctionName).Replace(code, function.FunctionName);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_ScriptContent, ExportConstants.ListIndentPrefix).Replace(code, m =>
{
return(ExportUtil.IndentListTemplate(function.Code, m.Groups[1].Value));
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_AdditionalScriptFunctions, ExportConstants.ListIndentPrefix).Replace(code, m =>
{
return(string.Empty);
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Function_ParentPreview).Replace(code, !string.IsNullOrEmpty(function.ParentPreviewText) ? function.ParentPreviewText : "None");
return(code);
}
/// <summary>
/// Renders a dialog step
/// </summary>
/// <param name="data">Dialog Step 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(ExportDialogData data, FlexFieldObject flexFieldObject)
{
KortistoNpc npc = flexFieldObject as KortistoNpc;
if (npc == null)
{
return(null);
}
TaleChoiceNode choiceNode = data.Choice;
if (choiceNode == null)
{
return(null);
}
ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, TemplateType.TaleChoice);
ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult();
renderResult.StepCode = ReplaceNodeId(template.Code, data);
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ChoicesStart, Placeholder_ChoicesEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(BuildChoices(m.Groups[1].Value, data, choiceNode, npc), m.Groups[2].Value)));
});
return(renderResult);
}
/// <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();
renderResult.StepCode = ReplaceNodeId(template.Code, data);
renderResult.StepCode = await ExportUtil.BuildRangePlaceholderRegex(Placeholder_ChoicesStart, Placeholder_ChoicesEnd).ReplaceAsync(renderResult.StepCode, async m => {
string choices = await BuildChoices(m.Groups[1].Value, data, choiceNode, npc);
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(choices, m.Groups[2].Value)));
});
return(renderResult);
}
/// <summary>
/// Renders a dialog function
/// </summary>
/// <param name="project">Current Project</param>
/// <param name="functionCode">Function code to use</param>
/// <returns>Rendered dialog function</returns>
public async Task <string> RenderDialogFunction(GoNorthProject project, ExportDialogFunctionCode functionCode)
{
string renderedCode = (await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.TaleDialogFunction)).Code;
renderedCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FunctionName).Replace(renderedCode, functionCode.FunctionName);
renderedCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Function_ParentPreview).Replace(renderedCode, functionCode.ParentPreviewText);
renderedCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FunctionContent, ExportConstants.ListIndentPrefix).Replace(renderedCode, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(functionCode.Code, m.Groups[1].Value)));
});
return(renderedCode);
}
/// <summary>
/// Fills the function placeholders
/// </summary>
/// <param name="code">Code to fill</param>
/// <param name="snippetFunction">Snippet function to render</param>
/// <returns>Filled function</returns>
private string FillFunctionPlaceholders(string code, ExportSnippetFunction snippetFunction)
{
string functionContentCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FunctionName).Replace(code, snippetFunction.FunctionName);
functionContentCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Function_ParentPreview).Replace(functionContentCode, snippetFunction.ParentPreviewText);
functionContentCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FunctionContent, ExportConstants.ListIndentPrefix).Replace(functionContentCode, m =>
{
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(snippetFunction.Code, m.Groups[1].Value)));
});
return(functionContentCode);
}
/// <summary>
/// Renders the inventory based on the shared template
/// </summary>
/// <param name="data">Export Data</param>
/// <param name="indent">Indentation</param>
/// <returns>Item List</returns>
private async Task <string> RenderInventory(ExportObjectData data, string indent)
{
GoNorthProject project = await _cachedDbAccess.GetUserProject();
ExportTemplate inventoryTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectInventory);
ExportPlaceholderFillResult fillResult = await _placeholderResolver.FillPlaceholders(TemplateType.ObjectInventory, inventoryTemplate.Code, data, inventoryTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ExportUtil.IndentListTemplate(fillResult.Code, indent));
}
/// <summary>
/// Builds the flex field attribute list
/// </summary>
/// <param name="code">Code</param>
/// <param name="placeholderStart">Placeholder for the start</param>
/// <param name="placeholderEnd">Placeholder for the end</param>
/// <param name="lineIndent">Line Indent</param>
/// <returns>Attribute template list</returns>
private string BuildFlexFieldListTemplate(string code, string placeholderStart, string placeholderEnd, string lineIndent)
{
code = ExportUtil.BuildPlaceholderRegex(ConcatPlaceholder(FlexField_Default_Placeholder_Prefix, Placeholder_Field_List_Start)).Replace(code, ExportUtil.WrapPlaceholderWithBrackets(ConcatPlaceholder(FlexField_Default_Placeholder_Prefix, placeholderStart)));
code = ExportUtil.BuildPlaceholderRegex(ConcatPlaceholder(FlexField_Default_Placeholder_Prefix, Placeholder_Field_List_End)).Replace(code, ExportUtil.WrapPlaceholderWithBrackets(ConcatPlaceholder(FlexField_Default_Placeholder_Prefix, placeholderEnd)));
if (_placeholderPrefix != FlexField_Default_Placeholder_Prefix)
{
Regex placeholderPrefixReplaceRegex = new Regex(ExportConstants.PlaceholderBracketsStart + FlexField_Default_Placeholder_Prefix, RegexOptions.Multiline);
code = placeholderPrefixReplaceRegex.Replace(code, ExportConstants.PlaceholderBracketsStart + _placeholderPrefix);
}
return(ExportUtil.IndentListTemplate(code, lineIndent));
}
/// <summary>
/// Builds the dialog function code
/// </summary>
/// <param name="additionalFunction">Function</param>
/// <param name="additionalFunctionsCode">Additional Function Code to wrap</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <returns>Function Code</returns>
protected override async Task <string> BuildDialogFunctionCode(ExportDialogFunction additionalFunction, string additionalFunctionsCode, KortistoNpc npc)
{
string functionContentCode = (await _defaultTemplateProvider.GetDefaultTemplateByType(_curProject.Id, TemplateType.ObjectDailyRoutineFunction)).Code;
functionContentCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FunctionName).Replace(functionContentCode, additionalFunction.RootNode.DialogStepFunctionName);
functionContentCode = ExportUtil.BuildPlaceholderRegex(Placeholder_Function_ParentPreview).Replace(functionContentCode, await BuildFunctionParentPreview(additionalFunction, npc));
functionContentCode = ExportUtil.BuildPlaceholderRegex(Placeholder_FunctionContent, ExportConstants.ListIndentPrefix).Replace(functionContentCode, m =>
{
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(additionalFunctionsCode, m.Groups[1].Value)));
});
return(functionContentCode);
}
/// <summary>
/// Exports the code snippet additional functions
/// </summary>
/// <param name="objectExportSnippet">Object export snippet to export</param>
/// <param name="flexFieldObject">Flex field object</param>
/// <param name="listIndent">Indent of the code</param>
/// <returns>Result of the snippet render</returns>
private string ExportCodeSnippetAdditionalFunctions(ObjectExportSnippet objectExportSnippet, FlexFieldObject flexFieldObject, string listIndent)
{
if (objectExportSnippet == null)
{
return(string.Empty);
}
if (objectExportSnippet.ScriptType == ExportConstants.ScriptType_NodeGraph)
{
return(ExportUtil.IndentListTemplate(this.RenderNodeGraph(objectExportSnippet, flexFieldObject).AdditionalFunctionsCode, listIndent));
}
return(string.Empty);
}
/// <summary>
/// Indents a multiline code
/// </summary>
/// <param name="context">Template context</param>
/// <param name="code">Code to indent</param>
/// <returns>Indented code</returns>
public static string IndentMultilineCode(TemplateContext context, string code)
{
string indentTemplate = context.Output.ToString();
string[] allLines = indentTemplate.Split(Environment.NewLine);
if (allLines.Length > 0)
{
string indentLine = allLines[allLines.Length - 1].Trim('\n', '\r');
if (string.IsNullOrWhiteSpace(indentLine))
{
return(ExportUtil.IndentListTemplate(code, indentLine).Trim());
}
}
return(code);
}
/// <summary>
/// Fills the inventory placeholders
/// </summary>
/// <param name="code">Code</param>
/// <param name="npc">Npc</param>
/// <returns>Filled code</returns>
private async Task <string> FillInventoryPlaceholders(string code, KortistoNpc npc)
{
GoNorthProject project = await _cachedDbAccess.GetDefaultProject();
ExportTemplate inventoryTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectInventory);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Inventory, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.IndentListTemplate(inventoryTemplate.Code, m.Groups[1].Value));
});
code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_Inventory_Start, Placeholder_Inventory_End).Replace(code, m => {
return(ExportUtil.TrimEmptyLines(BuildInventory(m.Groups[1].Value, npc)));
});
return(code);
}
/// <summary>
/// Exports the code snippet content
/// </summary>
/// <param name="renderedFunctions">Rendered function cache</param>
/// <param name="objectExportSnippet">Object export snippet to export</param>
/// <param name="flexFieldObject">Flex field object</param>
/// <param name="listIndent">Indent of the code</param>
/// <returns>Result of the snippet render</returns>
private async Task <string> ExportCodeSnippetContent(Dictionary <string, List <ExportSnippetFunction> > renderedFunctions, ObjectExportSnippet objectExportSnippet, FlexFieldObject flexFieldObject, string listIndent)
{
if (objectExportSnippet == null)
{
return(string.Empty);
}
List <ExportSnippetFunction> functions = await RenderFunctions(renderedFunctions, objectExportSnippet, flexFieldObject);
if (!functions.Any())
{
return(string.Empty);
}
return(ExportUtil.IndentListTemplate(functions.First().Code, listIndent));
}
/// <summary>
/// Renders an attribute list
/// </summary>
/// <param name="project">Current project</param>
/// <param name="fields">Fields to render</param>
/// <param name="data">Export data</param>
/// <param name="indent">Indentation</param>
/// <returns>Rendered attribute list</returns>
private async Task <string> RenderAttributeList(GoNorthProject project, List <FlexField> fields, ExportObjectData data, string indent)
{
ExportTemplate attributeListTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectAttributeList);
ExportObjectData objectData = data.Clone();
if (objectData.ExportData.ContainsKey(ExportConstants.ExportDataObject) && objectData.ExportData[ExportConstants.ExportDataObject] is IFlexFieldExportable)
{
((IFlexFieldExportable)objectData.ExportData[ExportConstants.ExportDataObject]).Fields = fields;
}
ExportPlaceholderFillResult fillResult = await _placeholderResolver.FillPlaceholders(TemplateType.ObjectAttributeList, attributeListTemplate.Code, objectData, attributeListTemplate.RenderingEngine);
_errorCollection.Merge(fillResult.Errors);
return(ExportUtil.IndentListTemplate(fillResult.Code, indent));
}
/// <summary>
/// Resolved the placeholders for a single daily routine event
/// </summary>
/// <param name="code">Code to resolve the placeholders in</param>
/// <param name="npc">Npc to which the event belongs</param>
/// <param name="dailyRoutineEvent">Daily routine to use for resolving the placeholders</param>
/// <param name="errorCollection">Error collection</param>
/// <returns>Code with resolved placeholders</returns>
public string ResolveDailyRoutineEventContentPlaceholders(string code, KortistoNpc npc, KortistoNpcDailyRoutineEvent dailyRoutineEvent, ExportPlaceholderErrorCollection errorCollection)
{
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, Placeholder_HasAdditionalScriptFunctions_Start, Placeholder_HasAdditionalScriptFunctions_End, m => {
if (dailyRoutineEvent.ScriptType == ScriptType_NodeGraph)
{
return(!string.IsNullOrEmpty(this.RenderNodeGraph(dailyRoutineEvent, npc, errorCollection).AdditionalFunctionsCode));
}
return(false);
});
code = ExportUtil.RenderPlaceholderIfFuncTrue(code, Placeholder_HasNoAdditionalScriptFunctions_Start, Placeholder_HasNoAdditionalScriptFunctions_End, m => {
if (dailyRoutineEvent.ScriptType == ScriptType_NodeGraph)
{
return(string.IsNullOrEmpty(this.RenderNodeGraph(dailyRoutineEvent, npc, errorCollection).AdditionalFunctionsCode));
}
return(true);
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_ScriptContent, ExportConstants.ListIndentPrefix).Replace(code, m => {
if (dailyRoutineEvent.ScriptType == ScriptType_NodeGraph)
{
return(ExportUtil.IndentListTemplate(this.RenderNodeGraph(dailyRoutineEvent, npc, errorCollection).StartStepCode, m.Groups[1].Value));
}
else if (dailyRoutineEvent.ScriptType == ScriptType_Code)
{
return(ExportUtil.IndentListTemplate(dailyRoutineEvent.ScriptCode != null ? dailyRoutineEvent.ScriptCode : string.Empty, m.Groups[1].Value));
}
return(string.Empty);
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_AdditionalScriptFunctions, ExportConstants.ListIndentPrefix).Replace(code, m => {
if (dailyRoutineEvent.ScriptType == ScriptType_NodeGraph)
{
return(ExportUtil.IndentListTemplate(this.RenderNodeGraph(dailyRoutineEvent, npc, errorCollection).AdditionalFunctionsCode, m.Groups[1].Value));
}
return(string.Empty);
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Function_ParentPreview).Replace(code, "None");
return(code);
}
/// <summary>
/// Exports the code snippet content
/// </summary>
/// <param name="objectExportSnippet">Object export snippet to export</param>
/// <param name="flexFieldObject">Flex field object</param>
/// <param name="listIndent">Indent of the code</param>
/// <returns>Result of the snippet render</returns>
private string ExportCodeSnippetContent(ObjectExportSnippet objectExportSnippet, FlexFieldObject flexFieldObject, string listIndent)
{
if (objectExportSnippet == null)
{
return(string.Empty);
}
if (objectExportSnippet.ScriptType == ExportConstants.ScriptType_NodeGraph)
{
return(ExportUtil.IndentListTemplate(this.RenderNodeGraph(objectExportSnippet, flexFieldObject).StartStepCode, listIndent));
}
else if (objectExportSnippet.ScriptType == ExportConstants.ScriptType_Code)
{
return(ExportUtil.IndentListTemplate(objectExportSnippet.ScriptCode != null ? objectExportSnippet.ScriptCode : string.Empty, listIndent));
}
return(string.Empty);
}
/// <summary>
/// Fills the skill placeholders
/// </summary>
/// <param name="code">Code</param>
/// <param name="npc">Npc</param>
/// <returns>Filled code</returns>
private async Task <string> FillSkillPlaceholders(string code, KortistoNpc npc)
{
GoNorthProject project = await _cachedDbAccess.GetDefaultProject();
ExportTemplate skillTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectSkillList);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Skills, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.IndentListTemplate(skillTemplate.Code, m.Groups[1].Value));
});
code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasSkills_Start, Placeholder_HasSkills_End, npc.Skills != null && npc.Skills.Count > 0);
code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_Skill_Start, Placeholder_Skill_End).Replace(code, m => {
return(ExportUtil.TrimEmptyLines(BuildSkills(m.Groups[1].Value, npc)));
});
return(code);
}
/// <summary>
/// Renders the dialog
/// </summary>
/// <param name="project">Current Project</param>
/// <param name="code">Template code</param>
/// <param name="exportDialog">Export dialog data</param>
/// <param name="dialog">Dialog</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <returns>Filled code</returns>
private async Task <string> RenderDialog(GoNorthProject project, string code, ExportDialogData exportDialog, TaleDialog dialog, KortistoNpc npc)
{
if (exportDialog == null)
{
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Start).Replace(code, string.Empty);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Additional_Functions).Replace(code, string.Empty);
return(code);
}
ExportDialogRenderResult dialogRenderResult = await _dialogRenderer.RenderDialog(exportDialog, npc);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Start, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(dialogRenderResult.StartStepCode, m.Groups[1].Value)));
});
code = ExportUtil.BuildPlaceholderRegex(Placeholder_Additional_Functions, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(dialogRenderResult.AdditionalFunctionsCode, m.Groups[1].Value)));
});
return(code);
}
/// <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();
renderResult.StepCode = ReplaceNodeId(template.Code, data);
renderResult.StepCode = await ExportUtil.BuildRangePlaceholderRegex(Placeholder_ConditionsStart, Placeholder_ConditionsEnd).ReplaceAsync(renderResult.StepCode, async m => {
string conditionData = await BuildConditions(m.Groups[1].Value, data, conditionNode, flexFieldObject, false);
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(conditionData, m.Groups[2].Value)));
});
renderResult.StepCode = await ExportUtil.BuildRangePlaceholderRegex(Placeholder_AllConditionsStart, Placeholder_AllConditionsEnd).ReplaceAsync(renderResult.StepCode, async m => {
string conditionData = await BuildConditions(m.Groups[1].Value, data, conditionNode, flexFieldObject, true);
return(ExportUtil.TrimEmptyLines(ExportUtil.IndentListTemplate(conditionData, m.Groups[2].Value)));
});
renderResult.StepCode = ExportUtil.BuildRangePlaceholderRegex(Placeholder_ElseStart, Placeholder_ElseEnd).Replace(renderResult.StepCode, m => {
return(ExportUtil.IndentListTemplate(BuildElsePart(m.Groups[1].Value, data), m.Groups[2].Value));
});
return(renderResult);
}
/// <summary>
/// Exports the code snippet additional functions
/// </summary>
/// <param name="renderedFunctions">Rendered function cache</param>
/// <param name="objectExportSnippet">Object export snippet to export</param>
/// <param name="flexFieldObject">Flex field object</param>
/// <param name="listIndent">Indent of the code</param>
/// <returns>Result of the snippet render</returns>
private async Task <string> ExportCodeSnippetAdditionalFunctions(Dictionary <string, List <ExportSnippetFunction> > renderedFunctions, ObjectExportSnippet objectExportSnippet, FlexFieldObject flexFieldObject, string listIndent)
{
if (objectExportSnippet == null)
{
return(string.Empty);
}
GoNorthProject project = await _cachedDbAccess.GetUserProject();
ExportTemplate functionContentTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectExportSnippetFunction);
List <ExportSnippetFunction> functions = await RenderFunctions(renderedFunctions, objectExportSnippet, flexFieldObject);
List <ExportSnippetFunction> additionalFunctions = functions.Skip(1).ToList();
string functionList = string.Empty;
foreach (ExportSnippetFunction curFunction in additionalFunctions)
{
functionList += await RenderExportSnippetFunction(functionContentTemplate, curFunction);
}
return(ExportUtil.IndentListTemplate(functionList, listIndent));
}
/// <summary>
/// Renders a list of daily routine functions
/// </summary>
/// <param name="code">Code to use</param>
/// <param name="functions">Function list to render</param>
/// <returns>Filled code</returns>
private async Task <string> FillDailyRoutineFunctionListPlaceholders(string code, List <DailyRoutineFunction> functions)
{
GoNorthProject project = await _cachedDbAccess.GetUserProject();
ExportTemplate dailyRoutineFunctionTemplate = await _defaultTemplateProvider.GetDefaultTemplateByType(project.Id, TemplateType.ObjectDailyRoutineFunction);
code = ExportUtil.BuildPlaceholderRegex(Placeholder_DailyRoutine_Function, ExportConstants.ListIndentPrefix).Replace(code, m => {
return(ExportUtil.IndentListTemplate(dailyRoutineFunctionTemplate.Code, m.Groups[1].Value));
});
code = await ExportUtil.BuildRangePlaceholderRegex(Placeholder_DailyRoutine_Functions_Start, Placeholder_DailyRoutine_Functions_End).ReplaceAsync(code, async m => {
string functionCode = m.Groups[1].Value;
string filledCode = string.Empty;
foreach (DailyRoutineFunction curFunction in functions)
{
string curFunctionCode = _eventPlaceholderResolver.ResolveDailyRoutineEventHasScript(functionCode, true);
curFunctionCode = _eventContentPlaceholderResolver.FillFunctionCode(curFunctionCode, curFunction);
filledCode += await _eventContentPlaceholderResolver.ReplaceEventFunction(curFunctionCode, curFunction, _errorCollection);
}
return(filledCode);
});
return(code);
}
