/// <summary>
/// Looks up a node by its ID.
/// </summary>
public QuestNode GetNode(StringField questNodeID)
{
return(GetNode(StringField.GetStringValue(questNodeID)));
}
/// <summary>
/// Records a static tag and its value in the dictionary.
/// </summary>
public void SetTag(string tag, StringField value)
{
SetTag(tag, StringField.GetStringValue(value));
}
public override string GetEditorName()
{
return(StringField.IsNullOrEmpty(message) ? "Message" : "Message: " + message.value + " " + StringField.GetStringValue(parameter) + " " + value.EditorNameValue());
}
public override void Execute()
{
if (prefab == null)
{
return;
}
var location = StringField.IsNullOrEmpty(locationTransform) ? null : GameObjectUtility.GameObjectHardFind(StringField.GetStringValue(locationTransform));
if (location == null)
{
if (QuestMachine.debug)
{
Debug.Log("Quest Machine: Instantiating prefab '" + prefab + "'.", prefab);
}
Instantiate(prefab);
}
else
{
if (QuestMachine.debug)
{
Debug.Log("Quest Machine: Instantiating prefab '" + prefab + "' at " + locationTransform + ".", prefab);
}
Instantiate(prefab, location.transform.position, location.transform.rotation);
}
}
/// <summary>
/// Shows a quest alert.
/// </summary>
/// <param name="stringField">Alert to show.</param>
public void ShowAlert(StringField stringField)
{
ShowAlert(StringField.GetStringValue(stringField));
}
private static string GetHeadingTextQuestContentProxyData(HeadingTextQuestContent headingTextQuestContent)
{
return(headingTextQuestContent.headingLevel + ";" + StringField.GetStringValue(headingTextQuestContent.originalText));
}
private static string GetIconQuestContentProxyData(IconQuestContent iconQuestContent)
{
return(iconQuestContent.count + ";" + ((iconQuestContent.image != null) ? iconQuestContent.image.name : string.Empty) + ";" +
StringField.GetStringValue(iconQuestContent.originalText));
}
/// <summary>
/// Looks up a QuestJournal.
/// </summary>
/// <param name="id">ID of the QuestJournal's owner, or empty for any QuestJournal.</param>
public static QuestJournal GetQuestJournal(StringField id)
{
return(GetQuestJournal(StringField.GetStringValue(id)));
}
private static string GetQuestKey(Quest quest)
{
if (quest == null)
{
return(null);
}
return(StringField.IsNullOrEmpty(quest.id) ? quest.GetInstanceID().ToString() : StringField.GetStringValue(quest.id));
}
private static void ReadQuestNodeDataFromStream(BinaryReader binaryReader, QuestNode node)
{
node.SetState((QuestNodeState)binaryReader.ReadByte(), false);
ReadConditionSetDataFromStream(binaryReader, node.conditionSet);
ReadTagDictionaryFromStream(binaryReader, node.tagDictionary, StringField.GetStringValue(node.internalName));
}
/// <summary>
/// Looks up a registered QuestListContainer.
/// </summary>
/// <param name="id">ID of the QuestListContainer.</param>
public static IdentifiableQuestListContainer GetQuestListContainer(StringField id)
{
return(GetQuestListContainer(StringField.GetStringValue(id)));
}
/// <summary>
/// Adds any tags in the StringField to the tags dictionary.
/// </summary>
/// <param name="stringField"></param>
protected virtual void AddTagsToDictionary(StringField stringField)
{
AddTagsToDictionary(StringField.GetStringValue(stringField));
}
public QuestIndicatorState GetQuestIndicatorState(StringField entityID)
{
return(GetQuestIndicatorState(StringField.GetStringValue(entityID)));
}
public void SetQuestIndicatorState(StringField entityID, QuestIndicatorState questIndicatorState)
{
SetQuestIndicatorState(StringField.GetStringValue(entityID), questIndicatorState);
}
public virtual Quest FindQuest(StringField questID)
{
return(FindQuest(StringField.GetStringValue(questID)));
}
/// <summary>
/// Looks up a quest asset by ID.
/// </summary>
/// <param name="id">Quest ID.</param>
/// <returns>Quest with the matching ID, or null if none is found.</returns>
public static Quest GetQuestAsset(StringField id)
{
return(GetQuestAsset(StringField.GetStringValue(id)));
}
public override void ApplyData(string data)
{
if (!includeInSavedGameData)
{
return;
}
if (string.IsNullOrEmpty(data))
{
return;
}
try
{
QuestMachine.isLoadingGame = true;
var saveData = SaveSystem.Deserialize <SaveData>(data);
if (saveData == null)
{
return;
}
// Clear current quest list:
DestroyQuestInstances(); // Adds them to deletedStaticQuests, but that's OK since we're going to restore deletedStaticQuests.
// Restore dynamic quests:
for (int i = 0; i < saveData.proceduralQuests.Count; i++)
{
try
{
var questProxy = JsonUtility.FromJson <QuestProxy>(saveData.proceduralQuests[i]);
if (questProxy == null)
{
continue;
}
var quest = ScriptableObject.CreateInstance <Quest>();
quest.name = questProxy.displayName;
questProxy.CopyTo(quest);
AddQuest(quest);
}
catch (Exception e)
{
if (Debug.isDebugBuild)
{
Debug.LogWarning("Quest Machine: Unable to restore quest from serialized quest proxy. Message: " + e.Message + "\nData: " + saveData.proceduralQuests[i], this);
}
}
}
// Restore list of deleted static quests:
deletedStaticQuests.Clear();
deletedStaticQuests.AddRange(saveData.deletedStaticQuests);
// Restore static quests:
for (int i = 0; i < Mathf.Min(saveData.staticQuestIds.Count, saveData.staticQuestData.Count); i++)
{
var questID = saveData.staticQuestIds[i];
var questData = saveData.staticQuestData[i];
if (string.IsNullOrEmpty(questID) || questData == null || questData.bytes == null)
{
continue;
}
if (deletedStaticQuests.Contains(questID))
{
continue;
}
var quest = QuestMachine.GetQuestAsset(questID);
if (quest == null)
{
quest = originalQuestList.Find(x => string.Equals(StringField.GetStringValue(x.id), questID));
}
if (quest == null && Debug.isDebugBuild)
{
Debug.LogError("Quest Machine: " + name + " Can't find quest " + saveData.staticQuestIds[i] + ". Is it registered with Quest Machine?", this);
}
if (quest == null)
{
continue;
}
quest = quest.Clone();
try
{
QuestStateSerializer.DeserializeInto(quest, questData.bytes, true);
}
catch (Exception e)
{
try
{
if (Debug.isDebugBuild)
{
Debug.LogWarning("Quest Machine: Unable to restore quest: " + quest.name + ". Message: " + e.Message, this);
}
Destroy(quest);
}
catch (Exception) { }
quest = quest.Clone();
}
AddQuest(quest);
}
QuestMachineMessages.RefreshIndicator(this, QuestMachineMessages.GetID(this));
}
finally
{
QuestMachine.isLoadingGame = false;
}
}
/// <summary>
/// Looks up a quest instance by ID.
/// </summary>
/// <param name="questID">Quest ID.</param>
/// <param name="questerID">ID of quester assigned to quest, or blank or null for any quester.</param>
/// <returns>Quest instance with the specified quest and quester ID, or null if none is found.</returns>
public static Quest GetQuestInstance(StringField id, StringField questerID)
{
return(GetQuestInstance(StringField.GetStringValue(id), StringField.GetStringValue(questerID)));
}
private static string GetBodyTextQuestContentProxyData(BodyTextQuestContent bodyTextQuestContent)
{
return(StringField.GetStringValue(bodyTextQuestContent.originalText));
}
/// <summary>
/// Looks up a quest's counter.
/// </summary>
/// <param name="questID">The quest's ID.</param>
/// <param name="counterName">The counter name.</param>
/// <returns>A quest counter, or null if none matches the questID and counterName.</returns>
public static QuestCounter GetQuestCounter(StringField questID, StringField counterName, StringField questerID = null)
{
return(GetQuestCounter(StringField.GetStringValue(questID), StringField.GetStringValue(counterName), (questerID != null) ? StringField.GetStringValue(questerID) : null));
}
private static string GetButtonQuestContentProxyData(ButtonQuestContent buttonQuestContent)
{
return(buttonQuestContent.count + ";" + ((buttonQuestContent.image != null) ? buttonQuestContent.image.name : string.Empty) + ";" +
StringField.GetStringValue(buttonQuestContent.originalText) + ";" + JsonUtility.ToJson(buttonQuestContent.m_actionsProxy));
}
/// <summary>
/// Looks up a quest's state.
/// </summary>
/// <param name="questID">The quest's ID.</param>
/// <returns>The quest's state, or QuestState.Inactive if no quest with the specified ID has been registered.</returns>
public static QuestState GetQuestState(StringField questID)
{
return(GetQuestState(StringField.GetStringValue(questID)));
}
protected virtual void RefreshNow() //[TODO] Optimize.
{
isDrawingSelectionPanel = true;
selectionPanelContentManager.Clear();
// Set heading:
if (entityImage != null)
{
entityImage.sprite = questJournal.image;
}
if (showDisplayNameInHeading && entityName != null && !StringField.IsNullOrEmpty(questJournal.displayName))
{
entityName.text = questJournal.displayName.value;
}
// Get group names:
var groupNames = new List <string>();
int numGroupless = 0;
foreach (var quest in questJournal.questList)
{
if (quest.GetState() == QuestState.WaitingToStart)
{
continue;
}
var groupName = StringField.GetStringValue(quest.group);
if (string.IsNullOrEmpty(groupName))
{
numGroupless++;
}
if (string.IsNullOrEmpty(groupName) || groupNames.Contains(groupName))
{
continue;
}
groupNames.Add(groupName);
}
// Add quests by group:
foreach (var groupName in groupNames)
{
var groupFoldout = Instantiate <UnityUIFoldoutTemplate>(questGroupTemplate);
selectionPanelContentManager.Add(groupFoldout, questSelectionContentContainer);
groupFoldout.Assign(groupName, IsGroupExpanded(groupName));
if (alwaysExpandAllGroups)
{
groupFoldout.foldoutButton.interactable = false;
}
else
{
groupFoldout.foldoutButton.interactable = true;
groupFoldout.foldoutButton.onClick.AddListener(() => { OnClickGroup(groupName, groupFoldout); });
}
foreach (var quest in questJournal.questList)
{
if (quest.GetState() == QuestState.WaitingToStart)
{
continue;
}
if (string.Equals(quest.group.value, groupName))
{
var questName = Instantiate <UnityUIQuestNameButtonTemplate>(GetQuestNameTemplateForState(quest.GetState()));
questName.Assign(quest, OnToggleTracking);
selectionPanelContentManager.Add(questName, groupFoldout.interiorPanel);
var target = quest;
SetupQuestNameUIEvents(questName.buttonTemplate.button, target);
}
}
}
// Add groupless quests:
foreach (var quest in questJournal.questList)
{
if (quest.GetState() == QuestState.WaitingToStart)
{
continue;
}
var groupName = StringField.GetStringValue(quest.group);
if (!string.IsNullOrEmpty(groupName))
{
continue;
}
var questName = Instantiate <UnityUIQuestNameButtonTemplate>(GetQuestNameTemplateForState(quest.GetState()));
questName.Assign(quest, OnToggleTracking);
selectionPanelContentManager.Add(questName, questSelectionContentContainer);
var target = quest;
SetupQuestNameUIEvents(questName.buttonTemplate.button, target);
}
RepaintSelectedQuest();
RefreshNavigableSelectables();
}
/// <summary>
/// Looks up a quest node's state.
/// </summary>
/// <param name="questID">The quest's ID.</param>
/// <param name="questNodeID">The quest node's ID.</param>
/// <returns>The quest node's state, or QuestNodeState.Inactive if no quest or quest node with the specified IDs has been registered.</returns>
public static QuestNodeState GetQuestNodeState(StringField questID, StringField questNodeID, string questerID = null)
{
return(GetQuestNodeState(StringField.GetStringValue(questID), StringField.GetStringValue(questNodeID), questerID));
}
protected float GetDisplayDuration(StringField stringField)
{
return(GetDisplayDuration(StringField.GetStringValue(stringField)));
}
public static void SetQuestNodeState(StringField questID, StringField questNodeID, QuestNodeState state, string questerID = null)
{
SetQuestNodeState(StringField.GetStringValue(questID), StringField.GetStringValue(questNodeID), state, questerID);
}
public MessageValue(StringField sf)
{
m_valueType = MessageValueType.String;
m_stringValue = StringField.GetStringValue(sf);
}
/// <summary>
/// Adds the plan's steps.
/// </summary>
/// <param name="questBuilder">QuestBuilder.</param>
/// <param name="domainName">Main target's domain.</param>
/// <param name="goal">Goal step.</param>
/// <param name="plan">List of steps that end with goal step.</param>
/// <returns>The last node added.</returns>
protected virtual QuestNode AddSteps(QuestBuilder questBuilder, string domainName, PlanStep goal, Plan plan)
{
var previousNode = questBuilder.GetStartNode();
var counterNames = new HashSet <string>();
for (int i = 0; i < plan.steps.Count; i++)
{
var step = plan.steps[i];
// Create next condition node:
var targetEntity = step.fact.entityType.name;
var targetDescriptor = step.fact.entityType.GetDescriptor(step.requiredCounterValue);
var id = (i + 1).ToString();
var internalName = step.action.displayName + " " + targetDescriptor;
var conditionNode = questBuilder.AddConditionNode(previousNode, id, internalName, ConditionCountMode.All);
previousNode = conditionNode;
// Variables for node text tag replacement:
var counterName = string.Empty;
int requiredCounterValue = 0;
var completion = step.action.completion;
if (completion.mode == ActionCompletion.Mode.Counter)
{
// Setup counter condition:
counterName = goal.fact.entityType.pluralDisplayName.value + completion.baseCounterName.value;
if (!counterNames.Contains(counterName))
{
var counter = questBuilder.AddCounter(counterName, completion.initialValue, completion.minValue, completion.maxValue, false, completion.updateMode);
foreach (var messageEvent in completion.messageEventList)
{
var counterMessageEvent = new QuestCounterMessageEvent(messageEvent.targetID, messageEvent.message,
new StringField(StringField.GetStringValue(messageEvent.parameter).Replace("{TARGETENTITY}", targetEntity)),
messageEvent.operation, messageEvent.literalValue);
counter.messageEventList.Add(counterMessageEvent);
}
}
counterName = goal.fact.entityType.pluralDisplayName.value + completion.baseCounterName.value;
requiredCounterValue = Mathf.Min(step.requiredCounterValue, step.fact.count);
questBuilder.AddCounterCondition(conditionNode, counterName, CounterValueConditionMode.AtLeast, requiredCounterValue);
// Consider: Add action to reset counter to zero in case future nodes repeat the same counter?
}
else
{
// Setup message condition:
questBuilder.AddMessageCondition(conditionNode, QuestMessageParticipant.Any, completion.senderID, QuestMessageParticipant.Any, completion.targetID,
completion.message, new StringField(StringField.GetStringValue(completion.parameter).Replace("{TARGETENTITY}", targetEntity)));
}
var activeState = conditionNode.stateInfoList[(int)QuestNodeState.Active];
AddStepNodeText(questBuilder, conditionNode, activeState, targetEntity, targetDescriptor, domainName, counterName, requiredCounterValue, step);
// Actions when active:
if (!StringField.IsNullOrEmpty(step.action.actionText.activeText.alertText))
{
// Alert action:
var alertAction = questBuilder.CreateAlertAction(ReplaceStepTags(step.action.actionText.activeText.alertText.value, targetEntity, targetDescriptor, domainName, counterName, requiredCounterValue));
activeState.actionList.Add(alertAction);
}
// Send message action:
if (!StringField.IsNullOrEmpty(step.action.sendMessageOnActive))
{
var messageAction = questBuilder.CreateMessageAction(ReplaceStepTags(step.action.sendMessageOnActive.value, targetEntity, targetDescriptor, domainName, counterName, requiredCounterValue));
activeState.actionList.Add(messageAction);
}
// Actions when completed:
if (!StringField.IsNullOrEmpty(step.action.sendMessageOnCompletion))
{
var trueState = conditionNode.stateInfoList[(int)QuestNodeState.True];
var messageAction = questBuilder.CreateMessageAction(ReplaceStepTags(step.action.sendMessageOnCompletion.value, targetEntity, targetDescriptor, domainName, counterName, requiredCounterValue));
trueState.actionList.Add(messageAction);
}
}
return(previousNode);
}
protected virtual bool IsCounterConditionTrue(QuestCounter counter)
{
if (counter == null)
{
return(false);
}
if (requiredCounterValue == null)
{
if (Debug.isDebugBuild)
{
Debug.LogWarning("QuestMachine: QuestCounterCondition.OnCounterChanged(" + StringField.GetStringValue(counter.name) + " = " + counter.currentValue + "): requiredCounterValue field is null. Please contact the developer.", quest);
}
return(false);
}
if (QuestMachine.debug)
{
Debug.Log("QuestMachine: QuestCounterCondition.OnCounterChanged(" + StringField.GetStringValue(counter.name) + " = " + counter.currentValue + ")", quest);
}
switch (counterValueMode)
{
case CounterValueConditionMode.AtLeast:
if (counter.currentValue >= requiredCounterValue.GetValue(quest))
{
return(true);
}
break;
case CounterValueConditionMode.AtMost:
if (counter.currentValue <= requiredCounterValue.GetValue(quest))
{
return(true);
}
break;
}
return(false);
}
public int GetCounterIndex(StringField counterName)
{
return(GetCounterIndex(StringField.GetStringValue(counterName)));
}