/// <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>
/// Fills the placeholders of a code
/// </summary>
/// <param name="code">Code to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Filled Code</returns>
public async Task <string> FillPlaceholders(string code, ExportObjectData data)
{
// Check Data
if (!data.ExportData.ContainsKey(ExportConstants.ExportDataObject))
{
return(code);
}
if (data.ExportData[ExportConstants.ExportDataObject] is KortistoNpc)
{
// Replace daily routine Placeholders
KortistoNpc npc = (KortistoNpc)data.ExportData[ExportConstants.ExportDataObject];
return(await FillDailyRoutinePlaceholders(code, npc, data));
}
else if (data.ExportData[ExportConstants.ExportDataObject] is DailyRoutineFunction)
{
// Replace daily routine function
DailyRoutineFunction function = (DailyRoutineFunction)data.ExportData[ExportConstants.ExportDataObject];
return(_eventContentPlaceholderResolver.FillFunctionCode(code, function));
}
else if (data.ExportData[ExportConstants.ExportDataObject] is List <DailyRoutineFunction> )
{
// Replace daily routine function
List <DailyRoutineFunction> functions = (List <DailyRoutineFunction>)data.ExportData[ExportConstants.ExportDataObject];
return(await FillDailyRoutineFunctionListPlaceholders(code, functions));
}
else
{
return(code);
}
}
/// <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, MoveNpcActionData parsedData, ExportDialogData data, ExportDialogData nextStep, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection,
FlexFieldObject flexFieldObject, ExportSettings exportSettings, IActionStepRenderer stepRenderer)
{
KortistoNpc foundNpc = await GetNpc(parsedData, flexFieldObject);
if (foundNpc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(string.Empty);
}
KartaMapNamedMarkerQueryResult markerResult = await GetMarker(parsedData);
if (markerResult == null)
{
errorCollection.AddDialogMarkerNotFoundError();
return(string.Empty);
}
string directContinueFunction = string.Empty;
if (data.Children != null)
{
ExportDialogDataChild directStep = data.Children.FirstOrDefault(c => c.NodeChildId == DirectContinueFunctionNodeId);
directContinueFunction = directStep != null ? directStep.Child.DialogStepFunctionName : string.Empty;
}
return(await FillPlaceholders(template, errorCollection, parsedData, foundNpc, markerResult.MarkerName, directContinueFunction, flexFieldObject, data, nextStep, exportSettings, stepRenderer));
}
/// <summary>
/// Builds a preview text from parsed data
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="child">Child node</param>
/// <param name="parent">Parent</param>
/// <returns>Preview text</returns>
public override async Task <string> BuildPreviewTextFromParsedData(SetDailyRoutineEventStateData parsedData, FlexFieldObject flexFieldObject, ExportPlaceholderErrorCollection errorCollection, ExportDialogData child, ExportDialogData parent)
{
KortistoNpc eventNpc = await _cachedDbAccess.GetNpcById(parsedData.NpcId);
if (eventNpc == null)
{
return(string.Empty);
}
KortistoNpcDailyRoutineEvent exportEvent = null;
if (eventNpc.DailyRoutine != null)
{
exportEvent = eventNpc.DailyRoutine.FirstOrDefault(e => e.EventId == parsedData.EventId);
}
if (exportEvent == null)
{
errorCollection.AddDialogDailyRoutineEventNotFoundError(eventNpc.Name);
return(string.Empty);
}
string timeDisplay = FormatDailyRoutineEventTime(exportEvent.EarliestTime);
if (exportEvent.EarliestTime != null && exportEvent.LatestTime != null && (exportEvent.EarliestTime.Hours != exportEvent.LatestTime.Hours || exportEvent.EarliestTime.Minutes != exportEvent.LatestTime.Minutes))
{
if (!string.IsNullOrEmpty(timeDisplay))
{
timeDisplay += " - ";
}
timeDisplay += FormatDailyRoutineEventTime(exportEvent.LatestTime);
}
return(GetPreviewPrefix() + " (" + eventNpc.Name + ", " + timeDisplay + ")");
}
/// <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);
}
TextNode textNode = GetValidTextNode(data);
if (textNode == null)
{
return(null);
}
ExportTemplate template = await _defaultTemplateProvider.GetDefaultTemplateByType(_project.Id, _isPlayerLine?TemplateType.TalePlayerTextLine : TemplateType.TaleNpcTextLine);
ExportDialogStepRenderResult renderResult = new ExportDialogStepRenderResult();
renderResult.StepCode = ReplaceBaseStepPlaceholders(template.Code, data, data.Children.FirstOrDefault() != null ? data.Children.FirstOrDefault().Child : null);
renderResult.StepCode = ExportUtil.BuildPlaceholderRegex(Placeholder_TextLine).Replace(renderResult.StepCode, ExportUtil.EscapeCharacters(textNode.Text, _exportSettings.EscapeCharacter, _exportSettings.CharactersNeedingEscaping, _exportSettings.NewlineCharacter));
renderResult.StepCode = ExportUtil.BuildPlaceholderRegex(Placeholder_TextLine_Preview).Replace(renderResult.StepCode, ExportUtil.BuildTextPreview(textNode.Text));
renderResult.StepCode = ExportUtil.BuildPlaceholderRegex(Placeholder_TextLine_LangKey).Replace(renderResult.StepCode, m => {
return(_languageKeyGenerator.GetDialogTextLineKey(npc.Id, npc.Name, _isPlayerLine ? ExportConstants.LanguageKeyTypePlayer : ExportConstants.LanguageKeyTypeNpc, textNode.Id, textNode.Text).Result);
});
return(renderResult);
}
/// <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>
/// Generates the state functions
/// </summary>
/// <param name="exportState">Export state to fill</param>
/// <param name="inputNpc">Input npcs</param>
/// <param name="state">State</param>
/// <returns>Task</returns>
private async Task GenerateStateFunctions(ScribanExportState exportState, KortistoNpc inputNpc, StateMachineState state)
{
List <ScribanExportStateFunction> functions = (await _stateMachineFunctionRenderer.RenderStateFunctions(state, inputNpc)).Select(f => new ScribanExportStateFunction(f)).ToList();
exportState.InitialFunction = functions.FirstOrDefault();
exportState.AdditionalFunctions = functions.Skip(1).ToList();
exportState.AllFunctions = functions;
}
/// <summary>
/// Builds a condition string
/// </summary>
/// <param name="condition">Condition</param>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <returns>Condition string</returns>
private string BuildCondition(Condition condition, KortistoNpc npc)
{
if (condition == null || string.IsNullOrEmpty(condition.ConditionElements))
{
_errorCollection.AddDialogConditionMissing();
return(string.Empty);
}
return(_conditionRenderer.RenderCondition(_project, condition, _errorCollection, npc, _exportSettings).Result);
}
/// <summary>
/// Compares an npc
/// </summary>
/// <param name="npcId">Id of the npc</param>
/// <param name="currentNpc">Current npc, if null the npc will be loaded</param>
/// <returns>Compare Result</returns>
public async Task <CompareResult> CompareNpc(string npcId, KortistoNpc currentNpc = null)
{
if (currentNpc == null)
{
currentNpc = await _npcDbAccess.GetFlexFieldObjectById(npcId);
}
KortistoNpc oldNpc = await _npcSnapshotDbAccess.GetSnapshotById(npcId);
return(CompareObjects(currentNpc, oldNpc));
}
/// <summary>
/// Returns the player npc
/// </summary>
/// <param name="projectId">Project Id</param>
/// <returns>Player npc</returns>
public async Task <KortistoNpc> GetPlayerNpc(string projectId)
{
if (_cachedPlayerNpcs.ContainsKey(projectId))
{
return(_cachedPlayerNpcs[projectId]);
}
KortistoNpc playerNpc = await _npcDbAccess.GetPlayerNpc(projectId);
_cachedPlayerNpcs.Add(projectId, playerNpc);
return(playerNpc);
}
/// <summary>
/// Returns an npc by its id
/// </summary>
/// <param name="npcId">Id of the npc</param>
/// <returns>Npc</returns>
public async Task <KortistoNpc> GetNpcById(string npcId)
{
if (_cachedNpcs.ContainsKey(npcId))
{
return(_cachedNpcs[npcId]);
}
KortistoNpc npc = await _npcDbAccess.GetFlexFieldObjectById(npcId);
_cachedNpcs.Add(npcId, npc);
return(npc);
}
/// <summary>
/// Returns the value object to use
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="flexFieldObject">Flex field object</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Value Object</returns>
protected override async Task <IFlexFieldExportable> GetValueObject(SpawnObjectActionData parsedData, FlexFieldObject flexFieldObject, ExportPlaceholderErrorCollection errorCollection)
{
KortistoNpc foundNpc = await _cachedDbAccess.GetNpcById(parsedData.ObjectId);
if (foundNpc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(null);
}
return(foundNpc);
}
/// <summary>
/// Returns the npc to use
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Value Object</returns>
private async Task <IFlexFieldExportable> GetNpc(InventoryChooseNpcActionData parsedData, ExportPlaceholderErrorCollection errorCollection)
{
KortistoNpc npc = await _cachedDbAccess.GetNpcById(parsedData.NpcId);
if (npc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(null);
}
return(npc);
}
/// <summary>
/// Copy Constructor from Base Npc
/// </summary>
/// <param name="baseNpc">Base Npc</param>
public NpcJsonExportObject(KortistoNpc baseNpc)
{
PropertyInfo[] properties = baseNpc.GetType().GetProperties();
foreach (PropertyInfo curProperty in properties)
{
PropertyInfo derivedProperty = this.GetType().GetProperty(curProperty.Name);
if (derivedProperty != null)
{
object value = curProperty.GetValue(baseNpc);
derivedProperty.SetValue(this, value);
}
}
}
/// <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>
/// 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)
{
KortistoNpc inputNpc = data.ExportData[ExportConstants.ExportDataObject] as KortistoNpc;
if(inputNpc == null)
{
return;
}
_languageKeyGenerator.SetErrorCollection(_errorCollection);
List<ScribanExportInventoryItem> items = await LoadInventory(parsedTemplate, inputNpc);
scriptObject.AddOrUpdate(ExportConstants.ScribanNpcInventoryObjectKey, items);
scriptObject.AddOrUpdate(ExportConstants.ScribanLanguageKeyName, _languageKeyGenerator);
}
/// <summary>
/// Fills the inventory placeholders
/// </summary>
/// <param name="code">Code</param>
/// <param name="npc">Npc</param>
/// <param name="data">Export Data</param>
/// <returns>Filled code</returns>
private async Task <string> FillInventoryPlaceholders(string code, KortistoNpc npc, ExportObjectData data)
{
code = await ExportUtil.BuildPlaceholderRegex(Placeholder_Inventory, ExportConstants.ListIndentPrefix).ReplaceAsync(code, async m => {
return(await RenderInventory(data, m.Groups[1].Value));
});
code = ExportUtil.RenderPlaceholderIfTrue(code, Placeholder_HasItems_Start, Placeholder_HasItems_End, npc.Inventory != null && npc.Inventory.Count > 0);
code = ExportUtil.BuildRangePlaceholderRegex(Placeholder_Inventory_Start, Placeholder_Inventory_End).Replace(code, m => {
return(ExportUtil.TrimEmptyLines(BuildInventory(m.Groups[1].Value, npc)));
});
return(code);
}
/// <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)
{
KortistoNpc inputNpc = data.ExportData[ExportConstants.ExportDataObject] as KortistoNpc;
if (inputNpc == null)
{
return;
}
SharedDailyRoutineExportUtil.SortDailyRoutine(inputNpc.DailyRoutine);
List <ScribanExportDailyRoutineEvent> events = await ScribanDailyRoutineEventUtil.MapNpcDailyRoutineEvents(_cachedDbAccess, _dailyRoutineFunctionNameGenerator, inputNpc, inputNpc.DailyRoutine);
scriptObject.AddOrUpdate(ExportConstants.ScribanDailyRoutineEventsObjectKey, events);
}
/// <summary>
/// Compares an npc
/// </summary>
/// <param name="npcId">Id of the npc</param>
/// <param name="currentNpc">Current npc, if null the npc will be loaded</param>
/// <returns>Compare Result</returns>
public async Task <CompareResult> CompareNpc(string npcId, KortistoNpc currentNpc = null)
{
if (currentNpc == null)
{
currentNpc = await _npcDbAccess.GetFlexFieldObjectById(npcId);
}
KortistoNpc oldNpc = await _npcSnapshotDbAccess.GetSnapshotById(npcId);
CompareResult result = CompareObjects(currentNpc, oldNpc);
await CompareExportSnippets(npcId, result);
await CompareStateMachines(npcId, result);
return(result);
}
/// <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>
/// 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>
/// 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>
/// Sets the implementation status of the related object
/// </summary>
/// <param name="stateMachine">State machine</param>
/// <returns>Task</returns>
private async Task SetImplementationStatusOfRelatedObject(StateMachine stateMachine)
{
KortistoNpc relatedObject = await _npcDbAccess.GetFlexFieldObjectById(stateMachine.RelatedObjectId);
if (relatedObject == null || !relatedObject.IsImplemented)
{
return;
}
CompareResult result = await _implementationStatusComparer.CompareStateMachine(stateMachine.Id, stateMachine);
if (result.CompareDifference != null && (result.CompareDifference.Count > 0 || !result.DoesSnapshotExist))
{
relatedObject.IsImplemented = false;
await _npcDbAccess.UpdateFlexFieldObject(relatedObject);
}
}
/// <summary>
/// Returns the npc to use
/// </summary>
/// <param name="npc">Npc to which the dialog belongs</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Value Object</returns>
private async Task <IFlexFieldExportable> GetNpc(KortistoNpc npc, ExportPlaceholderErrorCollection errorCollection)
{
if (_isPlayer)
{
GoNorthProject curProject = await _cachedDbAccess.GetDefaultProject();
npc = await _cachedDbAccess.GetPlayerNpc(curProject.Id);
if (npc == null)
{
errorCollection.AddNoPlayerNpcExistsError();
return(null);
}
}
return(npc);
}
/// <summary>
/// Fills the placeholders of a code
/// </summary>
/// <param name="code">Code to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Filled Code</returns>
public async Task <string> FillPlaceholders(string code, ExportObjectData data)
{
// Check Data
if (!data.ExportData.ContainsKey(ExportConstants.ExportDataObject))
{
return(code);
}
KortistoNpc npc = data.ExportData[ExportConstants.ExportDataObject] as KortistoNpc;
if (npc == null)
{
return(code);
}
// Replace Dialog Placeholders
return(await FillDialogPlaceholders(code, npc));
}
/// <summary>
/// Builds a parent text preview for the a dialog step
/// </summary>
/// <param name="child">Child node</param>
/// <param name="parent">Parent</param>
/// <param name="flexFieldObject">Flex field to which the dialog belongs</param>
/// <param name="errorCollection">Error Collection</param>
/// <returns>Parent text preview for the dialog step</returns>
public Task <string> BuildParentTextPreview(ExportDialogData child, ExportDialogData parent, FlexFieldObject flexFieldObject, ExportPlaceholderErrorCollection errorCollection)
{
KortistoNpc npc = flexFieldObject as KortistoNpc;
if (npc == null)
{
return(Task.FromResult <string>(null));
}
TextNode textNode = GetValidTextNode(parent);
if (textNode == null)
{
return(Task.FromResult <string>(null));
}
return(Task.FromResult(ExportUtil.BuildTextPreview(textNode.Text)));
}
/// <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>
/// Builds an action from parsed data
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="data">Dialog 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>Action string</returns>
public override async Task <string> BuildActionFromParsedData(MoveNpcToNpcActionRenderer.MoveNpcToNpcActionData parsedData, ExportDialogData data, GoNorthProject project, ExportPlaceholderErrorCollection errorCollection, FlexFieldObject flexFieldObject, ExportSettings exportSettings)
{
ExportTemplate actionTemplate = await GetExportTemplate(project);
KortistoNpc foundNpc = await GetNpc(parsedData, flexFieldObject);
if (foundNpc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(string.Empty);
}
KortistoNpc targetResult = await GetTargetNpc(parsedData);
if (targetResult == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(string.Empty);
}
ExportObjectData flexFieldExportData = new ExportObjectData();
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObject, foundNpc);
flexFieldExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc);
_flexFieldPlaceholderResolver.SetErrorMessageCollection(errorCollection);
string actionCode = _flexFieldPlaceholderResolver.FillPlaceholders(actionTemplate.Code, flexFieldExportData).Result;
if (!_isTeleport)
{
actionCode = BuildDirectContinueFunction(data, actionCode);
actionCode = BuildMovementState(parsedData, actionCode);
}
ExportObjectData flexFieldTargetExportData = new ExportObjectData();
flexFieldTargetExportData.ExportData.Add(ExportConstants.ExportDataObject, targetResult);
flexFieldTargetExportData.ExportData.Add(ExportConstants.ExportDataObjectType, ExportConstants.ExportObjectTypeNpc);
_flexFieldTargetPlaceholderResolver.SetErrorMessageCollection(errorCollection);
actionCode = _flexFieldTargetPlaceholderResolver.FillPlaceholders(actionCode, flexFieldTargetExportData).Result;
return(actionCode);
}
/// <summary>
/// Fills the placeholders of a code
/// </summary>
/// <param name="code">Code to fill</param>
/// <param name="data">Export Data</param>
/// <returns>Filled Code</returns>
public async Task <string> FillPlaceholders(string code, ExportObjectData data)
{
// Check Data
if (!data.ExportData.ContainsKey(ExportConstants.ExportDataObject))
{
return(code);
}
KortistoNpc npc = data.ExportData[ExportConstants.ExportDataObject] as KortistoNpc;
if (npc == null)
{
return(code);
}
// Replace Inventory Placeholders
_itemPlaceholderResolver.SetErrorMessageCollection(_errorCollection);
return(await FillInventoryPlaceholders(code, npc));
}
/// <summary>
/// Builds a preview text from parsed data
/// </summary>
/// <param name="parsedData">Parsed data</param>
/// <param name="flexFieldObject">Flex field object to which the dialog belongs</param>
/// <param name="errorCollection">Error Collection</param>
/// <param name="child">Child node</param>
/// <param name="parent">Parent</param>
/// <returns>Preview text</returns>
public override async Task <string> BuildPreviewTextFromParsedData(MoveNpcActionRenderer.MoveNpcActionData parsedData, FlexFieldObject flexFieldObject, ExportPlaceholderErrorCollection errorCollection, ExportDialogData child, ExportDialogData parent)
{
string verb = "Move";
if (_isTeleport)
{
verb = "Teleport";
}
if (!_isTeleport && parent != null && parent.Children != null && child != null)
{
ExportDialogDataChild actionChild = parent.Children.FirstOrDefault(c => c.Child.Id == child.Id);
if (actionChild != null && actionChild.NodeChildId == DirectContinueFunctionNodeId)
{
verb = "Direct Continue On Move";
}
}
string npcName = "npc";
if (_isPickedNpc)
{
KortistoNpc foundNpc = await GetNpc(parsedData, flexFieldObject);
if (foundNpc == null)
{
errorCollection.AddDialogNpcNotFoundError();
return(string.Empty);
}
npcName = foundNpc.Name;
}
else if (_isPlayer)
{
npcName = "player";
}
KartaMapNamedMarkerQueryResult queryResult = await GetMarker(parsedData);
string target = queryResult.MarkerName != null ? queryResult.MarkerName : string.Empty;
return(string.Format("{0} {1} to {2}", verb, npcName, target));
}
