/// <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 <ScribanInventoryConditionData> GetExportObject(InventoryConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
KortistoNpc npc = await ConditionRenderingUtil.GetExportNpc(_cachedDbAccess, project, flexFieldObject, errorCollection, _isPlayer);
if (npc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(null);
}
StyrItem item = await _cachedDbAccess.GetItemById(parsedData.ItemId);
if (item == null)
{
errorCollection.AddDialogItemNotFoundError();
return(null);
}
ScribanInventoryConditionData conditionData = new ScribanInventoryConditionData();
ScribanExportNpc convertedNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
convertedNpc.IsPlayer = npc.IsPlayerNpc;
conditionData.Npc = convertedNpc;
conditionData.SelectedItem = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportItem>(null, null, item, exportSettings, errorCollection);
conditionData.OriginalOperator = parsedData.Operator == InventoryConditionData.CompareOperator_AtLeast ? "AtLeast" : "AtMaximum";
conditionData.Operator = await ConditionRenderingUtil.GetItemCompareOperatorFromTemplate(_defaultTemplateProvider, project, parsedData.Operator, errorCollection);
conditionData.Quantity = parsedData.Quantity;
return(conditionData);
}
/// <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 <ScribanDailyRoutineEventStateConditionData> GetExportObject(DailyRoutineEventStateConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
KortistoNpc eventNpc = await _cachedDbAccess.GetNpcById(parsedData.NpcId);
if (eventNpc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(null);
}
KortistoNpcDailyRoutineEvent exportEvent = null;
if (eventNpc.DailyRoutine != null)
{
exportEvent = eventNpc.DailyRoutine.FirstOrDefault(e => e.EventId == parsedData.EventId);
}
if (exportEvent == null)
{
errorCollection.AddDialogDailyRoutineEventNotFoundError(eventNpc.Name);
return(null);
}
MiscProjectConfig projectConfig = await _cachedDbAccess.GetMiscProjectConfig();
ScribanDailyRoutineEventStateConditionData conditionData = new ScribanDailyRoutineEventStateConditionData();
conditionData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, eventNpc, exportSettings, errorCollection);
conditionData.DailyRoutineEvent = await ScribanDailyRoutineEventUtil.ConvertDailyRoutineEvent(_dailyRoutineFunctionNameGenerator, eventNpc, exportEvent, project, projectConfig, exportSettings);
return(conditionData);
}
/// <summary>
/// Loads the inventory
/// </summary>
/// <param name="parsedTemplate">Parsed scriban template</param>
/// <param name="inputNpc">Input npc</param>
/// <returns>List of items</returns>
private async Task<List<ScribanExportInventoryItem>> LoadInventory(Template parsedTemplate, KortistoNpc inputNpc)
{
if(inputNpc.Inventory == null || !inputNpc.Inventory.Any())
{
return new List<ScribanExportInventoryItem>();
}
GoNorthProject project = await _exportCachedDbAccess.GetUserProject();
ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id);
List<ScribanExportInventoryItem> inventoryItems = new List<ScribanExportInventoryItem>();
List<StyrItem> items = await _exportCachedDbAccess.GetItemsById(inputNpc.Inventory.Select(i => i.ItemId).ToList());
foreach(KortistoInventoryItem curItem in inputNpc.Inventory)
{
StyrItem loadedItem = items.FirstOrDefault(i => i.Id == curItem.ItemId);
if(loadedItem == null)
{
continue;
}
ScribanExportInventoryItem exportItem = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject<ScribanExportInventoryItem>(null, parsedTemplate, loadedItem, exportSettings, _errorCollection);
exportItem.Quantity = curItem.Quantity;
exportItem.IsEquipped = curItem.IsEquipped;
inventoryItems.Add(exportItem);
}
return inventoryItems;
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="npc">Npc to move</param>
/// <param name="targetNpc">Target npc</param>
/// <param name="directContinueFunction">Direct continue function</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="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, MoveNpcToNpcActionData parsedData, KortistoNpc npc, KortistoNpc targetNpc, string directContinueFunction,
FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
ScribanMoveNpcToNpcActionBaseData actionData;
if (_isTeleport)
{
actionData = new ScribanMoveNpcToNpcActionBaseData();
}
else
{
ScribanMoveNpcToNpcActionData walkData = new ScribanMoveNpcToNpcActionData();
walkData.MovementState = !string.IsNullOrEmpty(parsedData.MovementState) ? ExportUtil.EscapeCharacters(parsedData.MovementState, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter) : null;
walkData.UnescapedMovementState = parsedData.MovementState;
walkData.DirectContinueFunction = !string.IsNullOrEmpty(directContinueFunction) ? directContinueFunction : null;
actionData = walkData;
}
actionData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
actionData.Npc.IsPlayer = npc.IsPlayerNpc;
actionData.TargetNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, targetNpc, exportSettings, errorCollection);
actionData.TargetNpc.IsPlayer = targetNpc.IsPlayerNpc;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, actionData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <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>
/// 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 <ScribanLearnedSkillConditionData> GetExportObject(LearnedSkillConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
KortistoNpc npc = await ConditionRenderingUtil.GetExportNpc(_cachedDbAccess, project, flexFieldObject, errorCollection, _isPlayer);
if (npc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(null);
}
EvneSkill skill = await _cachedDbAccess.GetSkillById(parsedData.SelectedSkillId);
if (skill == null)
{
errorCollection.AddDialogSkillNotFoundError();
return(null);
}
ScribanLearnedSkillConditionData conditionData = new ScribanLearnedSkillConditionData();
ScribanExportNpc convertedNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
convertedNpc.IsPlayer = npc.IsPlayerNpc;
conditionData.Npc = convertedNpc;
conditionData.SelectedSkill = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, null, skill, exportSettings, errorCollection);
return(conditionData);
}
/// <summary>
/// Builds an export object from an input object
/// </summary>
/// <param name="parsedTemplate">Parsed scriban template</param>
/// <param name="inputObject">Input object</param>
/// <param name="exportSettings">Export settings</param>
/// <returns>Export object</returns>
private ExportClass BuildExportObject(Template parsedTemplate, InputObject inputObject, ExportSettings exportSettings)
{
ExportClass exportObject = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ExportClass>(GetObjectKey(), parsedTemplate, inputObject, exportSettings, _errorCollection);
SetAdditionalExportValues(exportObject, inputObject);
return(exportObject);
}
/// <summary>
/// Converts a scriban flex field list to a flex field list
/// </summary>
/// <param name="fieldList">Field list</param>
/// <returns>Flex field list</returns>
private List <FlexField> ConvertListToFlexFieldList(List <ScribanFlexFieldField> fieldList)
{
return(fieldList.Select(f => new FlexField {
Id = f.Id,
Name = f.Name,
FieldType = FlexFieldValueCollectorUtil.ConvertScribanFieldTypeToFlexFieldType(f.Type),
Value = f.UnescapedValue.ToString()
}).ToList());
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="valueObject">Value object to export</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="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, LearnForgetSkillActionData parsedData, IFlexFieldExportable valueObject, FlexFieldObject flexFieldObject,
ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
ScribanLearnForgetSkillActionData actionData = new ScribanLearnForgetSkillActionData();
actionData.Skill = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, null, valueObject, exportSettings, errorCollection);
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, actionData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="valueObject">Value object to export</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="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, InventoryActionData parsedData, IFlexFieldExportable valueObject, FlexFieldObject flexFieldObject, ExportDialogData curStep,
ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
ScribanInventoryActionData codeActionData = new ScribanInventoryActionData();
codeActionData.SelectedItem = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportItem>(null, null, valueObject, exportSettings, errorCollection);
codeActionData.Quantity = parsedData.Quantity.HasValue ? parsedData.Quantity.Value : 1;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, codeActionData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Builds an action from parsed data
/// </summary>
/// <param name="template">Template to export</param>
/// <param name="parsedData">Parsed data</param>
/// <param name="data">Dialog data</param>
/// <param name="nextStep">Next step in the dialog</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>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Action string</returns>
public override async Task <string> BuildActionFromParsedData(ExportTemplate template, ChangeTargetNpcStateActionData parsedData, ExportDialogData data, ExportDialogData nextStep, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection,
FlexFieldObject flexFieldObject, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
ScribanChangeTargetNpcStateActionData changeTargetNpcStateData = new ScribanChangeTargetNpcStateActionData();
changeTargetNpcStateData.Skill = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, null, flexFieldObject, exportSettings, errorCollection);
changeTargetNpcStateData.TargetState = ExportUtil.EscapeCharacters(parsedData.ObjectState, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter);
changeTargetNpcStateData.UnescapedTargetState = parsedData.ObjectState;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, changeTargetNpcStateData, flexFieldObject, data, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Returns the scriban flex field object for the export
/// </summary>
/// <param name="parsedData">Parsed condition</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>Scriban export object</returns>
protected override async Task <ScribanFlexFieldObject> GetScribanFlexFieldObject(ValueFieldConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
EvneSkill skill = await _cachedDbAccess.GetSkillById(parsedData.SelectedObjectId);
if (skill == null)
{
errorCollection.AddDialogSkillNotFoundError();
return(null);
}
return(FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, null, skill, exportSettings, errorCollection));
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="eventNpc">Npc to which the event belongs</param>
/// <param name="exportEvent">Event to export</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="project">Project</param>
/// <param name="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, SetDailyRoutineEventStateData parsedData, KortistoNpc eventNpc, KortistoNpcDailyRoutineEvent exportEvent,
FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, GoNorthProject project, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
MiscProjectConfig projectConfig = await _cachedDbAccess.GetMiscProjectConfig();
ScribanSetDailyRoutineEventStateActionData setDailyRoutineEventStateData = new ScribanSetDailyRoutineEventStateActionData();
setDailyRoutineEventStateData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, eventNpc, exportSettings, errorCollection);
setDailyRoutineEventStateData.Npc.IsPlayer = eventNpc.IsPlayerNpc;
setDailyRoutineEventStateData.DailyRoutineEvent = await ScribanDailyRoutineEventUtil.ConvertDailyRoutineEvent(_dailyRoutineFunctionNameGenerator, eventNpc, exportEvent, project, projectConfig, exportSettings);
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, setDailyRoutineEventStateData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Returns the scriban flex field object for the export
/// </summary>
/// <param name="parsedData">Parsed condition</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>Scriban export object</returns>
protected override async Task <ScribanFlexFieldObject> GetScribanFlexFieldObject(ValueFieldConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
AikaQuest quest = await _cachedDbAccess.GetQuestById(parsedData.SelectedObjectId);
if (quest == null)
{
errorCollection.AddDialogQuestNotFoundError();
return(null);
}
ScribanExportQuest convertedQuest = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportQuest>(null, null, quest, exportSettings, errorCollection);
return(convertedQuest);
}
/// <summary>
/// Renders a dialog step
/// </summary>
/// <param name="curStep">Current Step</param>
/// <param name="nextStep">Next step</param>
/// <param name="flexFieldObject">Flexfield object to which the dialog belongs</param>
/// <returns>Updated code</returns>
public T BuildDialogRenderObject<T>(ExportDialogData curStep, ExportDialogData nextStep, FlexFieldObject flexFieldObject) where T : ScribanDialogStepBaseDataWithNextNode, new()
{
ScribanExportNpc exportNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject<ScribanExportNpc>(null, null, flexFieldObject, _exportSettings, _errorCollection);
T renderObject = new T();
SetRenderObjectBaseData(renderObject, curStep, exportNpc);
renderObject.ChildNode = null;
if (nextStep != null)
{
renderObject.ChildNode = new ScribanDialogStepBaseData();
SetRenderObjectBaseData(renderObject.ChildNode, nextStep, exportNpc);
}
return renderObject;
}
/// <summary>
/// Returns the scriban flex field object for the export
/// </summary>
/// <param name="parsedData">Parsed condition</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>Scriban export object</returns>
protected override async Task <ScribanFlexFieldObject> GetScribanFlexFieldObject(ValueFieldConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
KortistoNpc npc = await ConditionRenderingUtil.GetExportNpc(_cachedDbAccess, project, flexFieldObject, errorCollection, _isPlayer);
if (npc == null)
{
return(null);
}
ScribanExportNpc convertedNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
convertedNpc.IsPlayer = npc.IsPlayerNpc;
return(convertedNpc);
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="valueObject">Value object</param>
/// <param name="marker">Marker at which to spawn the object</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="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, SpawnObjectActionData parsedData, IFlexFieldExportable valueObject, KartaMapNamedMarkerQueryResult marker,
FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
ScribanSpawnObjectActionData spawnActionData = new ScribanSpawnObjectActionData();
spawnActionData.Object = FlexFieldValueCollectorUtil.ConvertScribanFlexFieldObject(valueObject, exportSettings, errorCollection);
spawnActionData.TargetMarkerName = ExportUtil.EscapeCharacters(marker.MarkerName, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter);
spawnActionData.UnescapedTargetMarkerName = marker.MarkerName;
spawnActionData.Pitch = parsedData.Pitch;
spawnActionData.Yaw = parsedData.Yaw;
spawnActionData.Roll = parsedData.Roll;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, spawnActionData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <param name="valueObject">Value object to export</param>
/// <param name="curStep">Current step that is rendered</param>
/// <param name="nextStep">Next step that is being rendered</param>
/// <param name="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, AddQuestTextData parsedData, IFlexFieldExportable valueObject, FlexFieldObject flexFieldObject,
ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
ScribanAddQuestTextActionData actionData = new ScribanAddQuestTextActionData();
actionData.Quest = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportQuest>(null, null, valueObject, exportSettings, errorCollection);
actionData.Text = ExportUtil.EscapeCharacters(parsedData.QuestText, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter);
actionData.UnescapedText = parsedData.QuestText;
actionData.TextPreview = ExportUtil.BuildTextPreview(parsedData.QuestText);
actionData.FlexFieldObject = flexFieldObject;
actionData.NodeStep = curStep;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, actionData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Loads the skills
/// </summary>
/// <param name="parsedTemplate">Parsed scriban template</param>
/// <param name="inputNpc">Input npc</param>
/// <returns>List of skills</returns>
private async Task <List <ScribanExportSkill> > LoadSkills(Template parsedTemplate, KortistoNpc inputNpc)
{
if (inputNpc.Skills == null || !inputNpc.Skills.Any())
{
return(new List <ScribanExportSkill>());
}
GoNorthProject project = await _exportCachedDbAccess.GetUserProject();
ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id);
List <EvneSkill> skills = await _exportCachedDbAccess.GetSkillsById(inputNpc.Skills.Select(i => i.SkillId).ToList());
return(skills.Select(s => FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, parsedTemplate, s, exportSettings, _errorCollection)).ToList());
}
/// <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 <ScribanNpcAliveStateConditionData> GetExportObject(NpvAliveStateConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
KortistoNpc npc = await _cachedDbAccess.GetNpcById(parsedData.NpcId);
if (npc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(null);
}
ScribanNpcAliveStateConditionData conditionData = new ScribanNpcAliveStateConditionData();
conditionData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
conditionData.NpcAliveState = ConvertNpcAliveState(parsedData.State);
return(conditionData);
}
/// <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>
/// Collects the values for an export
/// </summary>
/// <param name="templateType">Template type</param>
/// <param name="parsedTemplate">Parsed scriban template</param>
/// <param name="scriptObject">Scriban script object to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Task</returns>
public override async Task CollectValues(TemplateType templateType, Template parsedTemplate, ScriptObject scriptObject, ExportObjectData data)
{
IFlexFieldExportable exportable = data.ExportData[ExportConstants.ExportDataObject] as IFlexFieldExportable;
if (exportable == null)
{
return;
}
_languageKeyGenerator.SetErrorCollection(_errorCollection);
GoNorthProject project = await _cachedDbAccess.GetUserProject();
ExportSettings exportSettings = await _cachedDbAccess.GetExportSettings(project.Id);
scriptObject.AddOrUpdate(ObjectKey, FlexFieldValueCollectorUtil.ExtractScribanFields(exportable, exportSettings, _errorCollection));
scriptObject.AddOrUpdate(ExportConstants.ScribanLanguageKeyName, _languageKeyGenerator);
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="valueObject">Value object to use</param>
/// <param name="actionOperator">Action operator 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="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, ValueFieldActionData parsedData, IFlexFieldExportable valueObject, string actionOperator,
FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
ScribanValueActionData valueData = new ScribanValueActionData();
valueData.ValueObject = FlexFieldValueCollectorUtil.ConvertScribanFlexFieldObject(valueObject, exportSettings, errorCollection);
valueData.TargetField = FlexFieldValueCollectorUtil.GetFlexField(valueData.ValueObject.Fields.Values, parsedData.FieldId, parsedData.FieldName);
if (valueData.TargetField == null)
{
errorCollection.AddErrorFlexField(parsedData.FieldName, valueObject.Name);
return(string.Empty);
}
valueData.Operator = actionOperator;
valueData.OriginalOperator = parsedData.Operator;
valueData.ValueChange = FlexFieldValueCollectorUtil.MapValueToFieldValue(valueData.TargetField, parsedData.ValueChange, exportSettings);
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, valueData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="itemObject">Item that was selected</param>
/// <param name="npcObject">Npc that was selected</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="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, InventoryChooseNpcActionData parsedData, IFlexFieldExportable itemObject, IFlexFieldExportable npcObject,
FlexFieldObject flexFieldObject, ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
KortistoNpc npc = npcObject as KortistoNpc;
if (npc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(string.Empty);
}
ScribanInventoryChooseNpcActionData codeActionData = new ScribanInventoryChooseNpcActionData();
codeActionData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
codeActionData.Npc.IsPlayer = npc.IsPlayerNpc;
codeActionData.SelectedItem = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportItem>(null, null, itemObject, exportSettings, errorCollection);
codeActionData.Quantity = parsedData.Quantity.HasValue ? parsedData.Quantity.Value : 1;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, codeActionData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Fills the placeholders
/// </summary>
/// <param name="template">Template to use</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="parsedData">Parsed config data</param>
/// <param name="valueObject">Value object to export</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="exportSettings">Export Settings</param>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Filled placeholders</returns>
protected override async Task <string> FillPlaceholders(ExportTemplate template, ExportPlaceholderErrorCollection errorCollection, ChangeNpcStateActionData parsedData, IFlexFieldExportable valueObject, FlexFieldObject flexFieldObject,
ExportDialogData curStep, ExportDialogData nextStep, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
KortistoNpc npc = valueObject as KortistoNpc;
if (npc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(string.Empty);
}
ScribanChangeNpcStateActionData changeNpcStateData = new ScribanChangeNpcStateActionData();
changeNpcStateData.Npc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, npc, exportSettings, errorCollection);
changeNpcStateData.Npc.IsPlayer = npc.IsPlayerNpc;
changeNpcStateData.TargetState = ExportUtil.EscapeCharacters(parsedData.ObjectState, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter);
changeNpcStateData.UnescapedTargetState = parsedData.ObjectState;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, changeNpcStateData, flexFieldObject, curStep, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Builds an action from parsed data
/// </summary>
/// <param name="template">Export template</param>
/// <param name="parsedData">Parsed data</param>
/// <param name="data">Dialog data</param>
/// <param name="nextStep">Next step in the dialog</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>
/// <param name="stepRenderer">Action Step renderer</param>
/// <returns>Action string</returns>
public override async Task <string> BuildActionFromParsedData(ExportTemplate template, FloatingTextActionData parsedData, ExportDialogData data, ExportDialogData nextStep, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection,
FlexFieldObject flexFieldObject, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
KortistoNpc targetNpc = await GetValueObject(project, parsedData, flexFieldObject);
if (targetNpc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(string.Empty);
}
ScribanShowFloatingTextActionData actionData = new ScribanShowFloatingTextActionData();
actionData.TargetNpc = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportNpc>(null, null, targetNpc, exportSettings, errorCollection);
actionData.TargetNpc.IsPlayer = targetNpc.IsPlayerNpc;
actionData.Text = ExportUtil.EscapeCharacters(parsedData.FloatingText, exportSettings.EscapeCharacter, exportSettings.CharactersNeedingEscaping, exportSettings.NewlineCharacter);
actionData.UnescapedText = parsedData.FloatingText;
actionData.TextPreview = ExportUtil.BuildTextPreview(parsedData.FloatingText);
actionData.FlexFieldObject = flexFieldObject;
actionData.NodeStep = data;
return(await ScribanActionRenderingUtil.FillPlaceholders(_cachedDbAccess, errorCollection, template.Code, actionData, flexFieldObject, data, nextStep, _scribanLanguageKeyGenerator, stepRenderer));
}
/// <summary>
/// Collects the values for an export
/// </summary>
/// <param name="templateType">Template type</param>
/// <param name="parsedTemplate">Parsed scriban template</param>
/// <param name="scriptObject">Scriban script object to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Task</returns>
public override async Task CollectValues(TemplateType templateType, Template parsedTemplate, ScriptObject scriptObject, ExportObjectData data)
{
IFlexFieldExportable flexFieldObject = data.ExportData[ExportConstants.ExportDataObject] as IFlexFieldExportable;
if (flexFieldObject == null)
{
return;
}
List <LanguageKey> referencedLanguageKeys = null;
if (data.ExportData.ContainsKey(ExportConstants.ExportDataReferencedLanguageIds))
{
referencedLanguageKeys = data.ExportData[ExportConstants.ExportDataReferencedLanguageIds] as List <LanguageKey>;
}
if (referencedLanguageKeys == null)
{
referencedLanguageKeys = new List <LanguageKey>();
}
GoNorthProject project = await _exportCachedDbAccess.GetUserProject();
List <LanguageKey> languageKeys = await _languageKeyDbAccess.GetLanguageKeysByGroupId(project.Id, flexFieldObject.Id);
ExportSettings exportSettings = await _exportCachedDbAccess.GetExportSettings(project.Id);
languageKeys = languageKeys.OrderBy(l => GetLanguageKeySortOrder(l, flexFieldObject)).ToList();
ScribanExportLanguageFile languageFileData = new ScribanExportLanguageFile();
languageFileData.Object = FlexFieldValueCollectorUtil.ConvertScribanFlexFieldObject(flexFieldObject, exportSettings, _errorCollection);
languageFileData.LanguageKeys = ConvertLanguageKeysToScriban(languageKeys, exportSettings);
languageFileData.ReferencedLanguageKeys = ConvertLanguageKeysToScriban(referencedLanguageKeys, exportSettings);
scriptObject.AddOrUpdate(LanguageObjectKey, languageFileData);
}
/// <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);
}
/// <summary>
/// Returns the scriban flex field object for the export
/// </summary>
/// <param name="parsedData">Parsed condition</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>Scriban export object</returns>
protected override Task <ScribanFlexFieldObject> GetScribanFlexFieldObject(ValueFieldConditionData parsedData, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
ScribanExportSkill convertedSkill = FlexFieldValueCollectorUtil.BuildFlexFieldValueObject <ScribanExportSkill>(null, null, flexFieldObject, exportSettings, errorCollection);
return(Task.FromResult <ScribanFlexFieldObject>(convertedSkill));
}
