/// <summary>
/// Returns the GameObject with the specified ID, giving preference to quest list
/// containers, then quest entities, and finally by GameObject name.
/// </summary>
/// <param name="id">ID to search for.</param>
public static GameObject FindGameObjectWithID(string id)
{
// Try registered quest list containers first (quest givers, quest journal):
var qlc = QuestMachine.GetQuestListContainer(id);
if (qlc != null)
{
return(qlc.gameObject);
}
//// Otherwise try entities:
////--- Replaced by IQuestMachineID below.
//var entities = GameObject.FindObjectsOfType<QuestEntity>();
//for (int i = 0; i < entities.Length; i++)
//{
// var entity = entities[i];
// if (string.Equals(entity.id, id)) return entity.gameObject;
//}
var monobehaviours = GameObject.FindObjectsOfType <MonoBehaviour>();
for (int i = 0; i < monobehaviours.Length; i++)
{
var identifiable = (monobehaviours[i] as IQuestMachineID);
if (identifiable != null && string.Equals(identifiable.id, id))
{
return(monobehaviours[i].gameObject);
}
}
// Otherwise search scene for GameObject name:
return(GameObject.Find(id));
}
private void AdjustCounter(int value, bool set)
{
var quest = QuestMachine.GetQuestInstance(questID);
if (quest == null)
{
if (QuestMachine.debug)
{
Debug.LogWarning("Quest Machine: Can't find quest with ID '" + questID + "' to adjust counter " + counterName + ".", this);
}
return;
}
var counter = quest.GetCounter(counterName);
if (counter == null)
{
if (QuestMachine.debug)
{
Debug.LogWarning("Quest Machine: Can't find counter " + counterName + " in quest '" + questID + "' to adjust its value.", this);
}
return;
}
if (set)
{
counter.currentValue = value;
}
else
{
counter.currentValue += value;;
}
}
public void CopyFrom(Quest quest)
{
if (quest == null)
{
Debug.LogWarning("Quest Machine: QuestProxy.CopyFrom source quest is null.");
return;
}
isInstance = quest.isInstance;
id = StringField.GetStringValue(quest.id);
displayName = StringField.GetStringValue(quest.title);
iconPath = QuestMachine.GetImagePath(quest.icon);
group = StringField.GetStringValue(quest.group);
labels = StringFieldsToStrings(quest.labels);
giver = StringField.GetStringValue(quest.questGiverID);
isTrackable = quest.isTrackable;
track = quest.showInTrackHUD;
isAbandonable = quest.isAbandonable;
rememberIfAbandoned = quest.rememberIfAbandoned;
autostartConditionSet = new QuestConditionSetProxy(quest.autostartConditionSet);
offerConditionSet = new QuestConditionSetProxy(quest.offerConditionSet);
offerUnmetContentList = QuestContentProxy.NewArray(quest.offerConditionsUnmetContentList);
offerContentList = QuestContentProxy.NewArray(quest.offerContentList);
maxTimes = quest.maxTimes;
timesAccepted = quest.timesAccepted;
cooldownSecs = quest.cooldownSeconds;
cooldownSecsRemain = quest.cooldownSecondsRemaining;
state = quest.GetState();
stateInfoList = QuestStateInfoProxy.NewArray(quest.stateInfoList);
counterList = QuestCounterProxy.NewArray(quest.counterList);
nodeList = QuestNodeProxy.NewArray(quest.nodeList);
tags = new TagDictionary(quest.tagDictionary);
indicators = QuestIndicatorStateRecordProxy.NewArray(quest.indicatorStates);
goalEntity = quest.goalEntityTypeName;
}
/// <summary>
/// Registers images with Quest Machine so procedural quests can reattach them when loading saved games.
/// </summary>
public void RegisterImages()
{
for (int i = 0; i < images.Count; i++)
{
QuestMachine.RegisterImage(images[i]);
}
}
private static string ReplaceCounterTag(string s, CounterTagType tagType)
{
if (string.IsNullOrEmpty(s) || currentQuest == null)
{
return(s);
}
var counterName = (tagType == CounterTagType.Current || tagType == CounterTagType.AsTime) ? s.Substring(2, s.Length - 3).Trim()
: s.Substring(3, s.Length - 4).Trim();
// Look for counter in current quest:
var counter = currentQuest.GetCounter(counterName);
if (counter != null)
{
return(GetCounterTagValue(counter, tagType));
}
// Otherwise look for quest by ID:
var index = counterName.IndexOf(CounterTagQuestNameSeparator);
if (index > 0)
{
var questName = counterName.Substring(0, index);
counterName = counterName.Substring(index + 1);
var quest = QuestMachine.GetQuestInstance(questName);
counter = (quest != null) ? quest.GetCounter(counterName) : null;
if (counter != null)
{
return(GetCounterTagValue(counter, tagType));
}
}
return(s);
}
public override void Execute()
{
if (QuestMachine.GetQuestNodeState(questID, questNodeID) != state)
{
QuestMachine.SetQuestNodeState(questID, questNodeID, state);
}
}
public override void Execute()
{
var affectedQuest = StringField.IsNullOrEmpty(questID) ? this.quest : QuestMachine.GetQuestInstance(questID);
if (affectedQuest == null)
{
return;
}
affectedQuest.SetQuestIndicatorState(runtimeEntityID, questIndicatorState);
}
/// <summary>
/// Sets the quest to a state. The quest is specified in the
/// questID property.
/// </summary>
/// <param name="state">New state.</param>
public void SetQuestState(QuestState state)
{
var quest = QuestMachine.GetQuestInstance(questID);
if (quest == null)
{
if (QuestMachine.debug)
{
Debug.LogWarning("Quest Machine: Can't find quest with ID '" + questID + "' to set its state.", this);
}
return;
}
quest.SetState(state);
}
public override void StartChecking(System.Action trueAction)
{
base.StartChecking(trueAction);
if (requiredQuestID == null)
{
return;
}
if (QuestMachine.GetQuestState(requiredQuestID) == requiredState)
{
SetTrue();
}
else
{
MessageSystem.AddListener(this, QuestMachineMessages.QuestStateChangedMessage, requiredQuestID.value);
}
}
private static void ApplyIconQuestContentProxyData(IconQuestContent iconQuestContent, string s)
{
if (iconQuestContent == null || s == null)
{
return;
}
var fields = s.Split(';');
if (fields.Length < 3)
{
return;
}
iconQuestContent.count = SafeConvert.ToInt(fields[0]);
iconQuestContent.image = string.IsNullOrEmpty(fields[1]) ? null : QuestMachine.GetImage(fields[1]);
iconQuestContent.originalText = new StringField(fields[2]);
}
public virtual void DeleteQuest(Quest quest)
{
if (quest == null)
{
return;
}
questList.Remove(quest);
if (!quest.isProcedurallyGenerated)
{
var questID = StringField.GetStringValue(quest.id);
if (!deletedStaticQuests.Contains(questID))
{
deletedStaticQuests.Add(questID);
}
}
UnregisterForQuestEvents(quest);
QuestMachine.UnregisterQuestInstance(quest);
Quest.DestroyInstance(quest);
}
private void OnDestroy()
{
if (isInstance && Application.isPlaying)
{
QuestMachine.UnregisterQuestInstance(this);
SetState(QuestState.Disabled);
if (autostartConditionSet != null)
{
autostartConditionSet.DestroySubassets();
}
if (offerConditionSet != null)
{
offerConditionSet.DestroySubassets();
}
QuestSubasset.DestroyList(offerConditionsUnmetContentList);
QuestSubasset.DestroyList(offerContentList);
QuestStateInfo.DestroyListSubassets(stateInfoList);
QuestNode.DestroyListSubassets(nodeList);
}
}
public virtual Quest AddQuest(Quest quest)
{
if (quest == null)
{
return(null);
}
if (deletedStaticQuests.Contains(StringField.GetStringValue(quest.id)))
{
return(null);
}
var instance = quest.isAsset ? quest.Clone() : quest;
if (instance == null)
{
return(null);
}
questList.Add(instance);
QuestMachine.RegisterQuestInstance(instance);
RegisterForQuestEvents(instance);
instance.RuntimeStartup();
return(instance);
}
public void RegisterQuestDatabases()
{
if (questDatabases == null)
{
return;
}
for (int i = 0; i < questDatabases.Count; i++)
{
var database = questDatabases[i];
if (database == null || database.questAssets == null)
{
continue;
}
for (int j = 0; j < database.questAssets.Count; j++)
{
QuestMachine.RegisterQuestAsset(database.questAssets[j]);
}
for (int j = 0; j < database.images.Count; j++)
{
QuestMachine.RegisterImage(database.images[j]);
}
}
}
public void CopyTo(Quest quest)
{
if (quest == null)
{
Debug.LogWarning("Quest Machine: QuestProxy.CopyTo destination quest is null.");
return;
}
quest.isInstance = isInstance;
quest.id = new StringField(id);
quest.title = new StringField(displayName);
quest.group = new StringField(group);
quest.labels = StringsToStringFields(labels);
quest.icon = QuestMachine.GetImage(iconPath);
quest.questGiverID = new StringField(giver);
quest.isTrackable = isTrackable;
quest.showInTrackHUD = track;
quest.isAbandonable = isAbandonable;
quest.rememberIfAbandoned = rememberIfAbandoned;
quest.autostartConditionSet = autostartConditionSet.CreateConditionSet();
quest.offerConditionSet = offerConditionSet.CreateConditionSet();
quest.offerConditionsUnmetContentList = QuestContentProxy.CreateList(offerUnmetContentList);
quest.offerContentList = QuestContentProxy.CreateList(offerContentList);
quest.maxTimes = maxTimes;
quest.timesAccepted = timesAccepted;
quest.UpdateCooldown();
quest.cooldownSeconds = cooldownSecs;
quest.cooldownSecondsRemaining = cooldownSecsRemain;
quest.stateInfoList = QuestStateInfoProxy.CreateList(stateInfoList);
quest.counterList = QuestCounterProxy.CreateList(counterList);
quest.nodeList = QuestNodeProxy.CreateList(nodeList);
quest.tagDictionary = new TagDictionary(tags);
quest.indicatorStates = QuestIndicatorStateRecordProxy.ArrayToDictionary(indicators);
quest.goalEntityTypeName = goalEntity;
quest.SetRuntimeReferences();
quest.SetState(state, false);
QuestNodeProxy.CopyStatesTo(nodeList, quest);
}
/// <summary>
/// Sets the quest node to a state. The quest and quest node are specified
/// in the questID and questNodeID properties.
/// </summary>
/// <param name="state">New state.</param>
public void SetQuestNodeState(QuestNodeState state)
{
var quest = QuestMachine.GetQuestInstance(questID);
if (quest == null)
{
if (QuestMachine.debug)
{
Debug.LogWarning("Quest Machine: Can't find quest with ID '" + questID + "' to set the state of node with ID '" + questNodeID + "'.", this);
}
return;
}
var questNode = quest.GetNode(questNodeID);
if (questNode == null)
{
if (QuestMachine.debug)
{
Debug.LogWarning("Quest Machine: Can't find node with ID '" + questNodeID + "' in quest '" + questID + "' to set its state.", this);
}
return;
}
questNode.SetState(state);
}
public virtual void RefreshFromAllQuests()
{
InitializeStates();
var allQuests = QuestMachine.GetAllQuestInstances();
foreach (var kvp in allQuests)
{
var quests = kvp.Value;
if (quests == null)
{
continue;
}
for (int i = 0; i < quests.Count; i++)
{
var quest = quests[i];
if (quest == null)
{
continue;
}
var questState = quest.GetState();
if (questState == QuestState.Active && quest.indicatorStates != null && quest.indicatorStates.ContainsKey(myID))
{
// If the quest specifies an indicator for me, record it:
var state = quest.indicatorStates[myID];
states[(int)state].Add(StringField.GetStringValue(quest.id));
}
else if (questState == QuestState.WaitingToStart && StringField.Equals(quest.questGiverID, myID) && string.IsNullOrEmpty(quest.questerID))
{
// Otherwise if it's offerable by me, record it:
var state = quest.canOffer ? hasQuestToOfferState : hasQuestButCannotOfferState;
states[(int)state].Add(StringField.GetStringValue(quest.id));
}
}
}
ShowHighestPriorityIndicator();
}
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>
/// Adds an instance of a quest to a quester's list. If the quest's maxTimes are reached,
/// deletes the quest from the giver. Otherwise starts cooldown timer until it can be
/// given again.
/// </summary>
/// <param name="quest">Quest to give to quester.</param>
/// <param name="questerID">Quester's ID.</param>
public virtual void GiveQuestToQuester(Quest quest, string questerID)
{
GiveQuestToQuester(quest, QuestMachine.GetQuestListContainer(questerID));
}
public override void OnAfterProxyDeserialization()
{
base.OnAfterProxyDeserialization();
m_image = QuestMachine.GetImage(m_imageNameProxy);
m_imageNameProxy = null; // Free memory.
}
public override void OnBeforeProxySerialization()
{
base.OnBeforeProxySerialization();
m_imageNameProxy = QuestMachine.GetImagePath(m_image);
}
public override void OnDisable()
{
base.OnDisable();
QuestMachine.UnregisterQuestListContainer(this);
}
private static void ApplyButtonQuestContentProxyData(ButtonQuestContent buttonQuestContent, string s)
{
if (buttonQuestContent == null || s == null)
{
return;
}
var fields = s.Split(';');
if (fields.Length < 4)
{
return;
}
buttonQuestContent.count = SafeConvert.ToInt(fields[0]);
buttonQuestContent.image = string.IsNullOrEmpty(fields[1]) ? null : QuestMachine.GetImage(fields[1]);
buttonQuestContent.originalText = new StringField(fields[2]);
buttonQuestContent.m_actionsProxy = JsonUtility.FromJson <QuestActionProxyContainer>(fields[3]);
}
/// <summary>
/// Gives all quests to a quester.
/// </summary>
/// <param name="questerID">ID of quester.</param>
public virtual void GiveAllQuestsToQuester(string questerID)
{
GiveAllQuestsToQuester(QuestMachine.GetQuestListContainer(questerID));
}
public override void OnAfterProxyDeserialization()
{
base.OnAfterProxyDeserialization();
m_audioClip = QuestMachine.GetAudioClip(m_audioNameProxy);
m_audioNameProxy = null; // Free memory.
}
public override void OnBeforeProxySerialization()
{
base.OnBeforeProxySerialization();
m_audioNameProxy = QuestMachine.GetAudioClipPath(m_audioClip);
}
