/// <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); }