/// <summary>
/// Returns the value object to use for scriban exporting
/// </summary>
/// <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>Value Object</returns>
protected override async Task <ScribanValueConditionData> GetExportObject(ValueFieldConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
ScribanFlexFieldObject exportObject = await GetScribanFlexFieldObject(parsedData, project, errorCollection, flexFieldObject, exportSettings);
if (exportObject == null)
{
return(null);
}
ScribanValueConditionData conditionData = new ScribanValueConditionData();
conditionData.ValueObject = exportObject;
conditionData.SelectedField = null;
if (parsedData.FieldId != null)
{
conditionData.SelectedField = FlexFieldValueCollectorUtil.GetFlexField(conditionData.ValueObject.Fields.Values, parsedData.FieldId, parsedData.FieldName);
}
conditionData.IsOperatorPrimitive = ConditionRenderingUtil.IsConditionOperatorPrimitiveOperator(parsedData.Operator);
conditionData.OriginalOperator = parsedData.Operator;
conditionData.Operator = await ConditionRenderingUtil.GetCompareOperatorFromTemplate(_defaultTemplateProvider, project, parsedData.Operator, errorCollection);
conditionData.CompareValue = FlexFieldValueCollectorUtil.MapValueToFieldValue(conditionData.SelectedField, parsedData.CompareValue, exportSettings);
return(conditionData);
}
/// <summary>
/// Builds a scriban flex field object from a flex field exportable
/// </summary>
/// <param name="exportable">Exportable</param>
/// <param name="exportSettings">Export settings</param>
/// <param name="errorCollection">Error collection</param>
/// <returns>Scriban flex field object</returns>
public static ScribanFlexFieldObject ConvertScribanFlexFieldObject(IFlexFieldExportable exportable, ExportSettings exportSettings, ExportPlaceholderErrorCollection errorCollection)
{
ScribanFlexFieldObject flexFieldObject = null;
if (exportable is StyrItem)
{
flexFieldObject = new ScribanExportItem();
}
else if (exportable is EvneSkill)
{
flexFieldObject = new ScribanExportSkill();
}
else if (exportable is KortistoNpc)
{
flexFieldObject = new ScribanExportNpc();
}
else if (exportable is AikaQuest)
{
flexFieldObject = new ScribanExportQuest();
}
flexFieldObject.Id = exportable.Id;
flexFieldObject.Name = exportable.Name;
flexFieldObject.Fields = new ScribanFlexFieldDictionary(flexFieldObject, errorCollection, exportable.Fields.Where(f => IsFlexFieldValidForExport(f, true)).SelectMany(f => ConvertFieldToExportField(flexFieldObject, f, exportSettings)).DistinctBy(f => f.Name).ToDictionary(f => f.Name));
flexFieldObject.UsedFieldIds = new HashSet <string>();
return(flexFieldObject);
}
/// <summary>
/// Extracts a list of scriban fields
/// </summary>
/// <param name="exportable">Flex field exportable</param>
/// <param name="exportSettings">Export settings</param>
/// <param name="errorCollection">Error collection</param>
/// <returns>Scriban Fields</returns>
public static List <ScribanFlexFieldField> ExtractScribanFields(IFlexFieldExportable exportable, ExportSettings exportSettings, ExportPlaceholderErrorCollection errorCollection)
{
if (exportable == null || exportable.Fields == null)
{
return(new List <ScribanFlexFieldField>());
}
ScribanFlexFieldObject flexFieldObject = ConvertScribanFlexFieldObject(exportable, exportSettings, errorCollection);
return(flexFieldObject.Fields.Values.ToList());
}
/// <summary>
/// Converts a flexfield to an export field
/// </summary>
/// <param name="parentObject">Parent object</param>
/// <param name="field">Field to export</param>
/// <param name="exportSettings">Export settings</param>
/// <returns>Converted fields</returns>
private static IEnumerable <ScribanFlexFieldField> ConvertFieldToExportField(ScribanFlexFieldObject parentObject, FlexField field, ExportSettings exportSettings)
{
if (field.ScriptSettings != null && !string.IsNullOrEmpty(field.ScriptSettings.AdditionalScriptNames))
{
string[] additionalScriptNames = field.ScriptSettings.AdditionalScriptNames.Split(ExportConstants.FlexFieldAdditionalScriptNamesSeperator, StringSplitOptions.RemoveEmptyEntries);
foreach (string curAddtionalName in additionalScriptNames)
{
yield return(ConvertFieldWithName(parentObject, field, curAddtionalName, exportSettings));
}
}
yield return(ConvertFieldWithName(parentObject, field, field.Name, exportSettings));
}
/// <summary>
/// Converts a single field to an export field with a given anme
/// </summary>
/// <param name="parentObject">Parent object</param>
/// <param name="field">Field to convert</param>
/// <param name="fieldName">Field name to use</param>
/// <param name="exportSettings">Export settings</param>
/// <returns>Converted field</returns>
private static ScribanFlexFieldField ConvertFieldWithName(ScribanFlexFieldObject parentObject, FlexField field, string fieldName, ExportSettings exportSettings)
{
ScribanFlexFieldField convertedField = new ScribanFlexFieldField(parentObject);
convertedField.Id = field.Id;
convertedField.Name = fieldName;
convertedField.Type = ConvertFieldTypeToScribanFieldType(field.FieldType);
convertedField.UnescapedValue = ConvertFieldValue(field.FieldType, field.Value);
convertedField.Value = convertedField.UnescapedValue;
if (convertedField.Value is string)
{
convertedField.Value = ExportUtil.EscapeCharacters(convertedField.Value.ToString(), exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter);
}
convertedField.DontExportToScript = field.ScriptSettings != null && field.ScriptSettings.DontExportToScript ? true : false;
convertedField.Exists = true;
return(convertedField);
}
/// <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>>");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="errorValue">Error value</param>
/// <param name="missingFieldName">Missing field name for the error collection</param>
/// <param name="parentObject">Parent scriban object</param>
/// <param name="errorCollection">Error collection</param>
public ScribanMissingFlexFieldField(string errorValue, string missingFieldName, ScribanFlexFieldObject parentObject, ExportPlaceholderErrorCollection errorCollection) : base(parentObject)
{
ErrorValue = errorValue;
_missingFieldName = missingFieldName;
_errorCollection = errorCollection;
Exists = false;
}
/// <summary>
/// Sets the render object base data
/// </summary>
/// <param name="renderObject">Render object to fill</param>
/// <param name="stepData">Step data</param>
/// <param name="exportNpc">Npc to export</param>
public void SetRenderObjectBaseData(ScribanDialogStepBaseData renderObject, ExportDialogData stepData, ScribanFlexFieldObject exportNpc)
{
renderObject.NodeId = stepData.Id;
renderObject.NodeIndex = stepData.NodeIndex;
renderObject.NodeType = stepData.GetNodeType();
renderObject.NodeStepFunctionName = stepData.DialogStepFunctionName;
renderObject.NodeObject = exportNpc;
}
/// <summary>
/// Sets the render object base data
/// </summary>
/// <param name="renderObject">Render object to fill</param>
/// <param name="stepData">Step data</param>
/// <param name="flexFieldObject">Flexfield object to which the dialog belongs</param>
public void SetRenderObjectBaseDataFromFlexFieldObject(ScribanDialogStepBaseData renderObject, ExportDialogData stepData, FlexFieldObject flexFieldObject)
{
ScribanFlexFieldObject exportObject = FlexFieldValueCollectorUtil.ConvertScribanFlexFieldObject(flexFieldObject, _exportSettings, _errorCollection);
SetRenderObjectBaseData(renderObject, stepData, exportObject);
}
