fr.jeanf.questsystem 0.0.1

package/Runtime/Scripts/Core/QuestManager.cs

@@ -0,0 +1,243 @@
+using System.Collections;
+using System.Collections.Generic;
+using jeanf.EventSystem;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+public class QuestManager : MonoBehaviour, IDebugBehaviour
+{
+    public bool isDebug
+    { 
+        get => _isDebug;
+        set => _isDebug = value; 
+    }
+    [SerializeField] private bool _isDebug = false;
+    [FormerlySerializedAs("loadQuestState")]
+    [Header("Config")]
+    [SerializeField] private bool loadSavedQuestState = true;
+    [Header("Broadcasting on:")] [SerializeField] private StringEventChannelSO questStatusUpdateChannel;
+    [Header("Broadcasting on:")] [SerializeField] private StringFloatEventChannelSO questProgress;
+
+    private Dictionary<string, Quest> questMap;
+
+    // quest start requirements
+    private int currentPlayerLevel;
+
+    private void Awake()
+    {
+        questMap = CreateQuestMap();
+    }
+
+    private void OnEnable()
+    {
+        GameEventsManager.instance.questEvents.onStartQuest += StartQuest;
+        GameEventsManager.instance.questEvents.onAdvanceQuest += AdvanceQuest;
+        GameEventsManager.instance.questEvents.onFinishQuest += FinishQuest;
+
+        GameEventsManager.instance.questEvents.onQuestStepStateChange += QuestStepStateChange;
+
+        GameEventsManager.instance.playerEvents.onPlayerLevelChange += PlayerLevelChange;
+    }
+
+    private void OnDisable()
+    {
+        GameEventsManager.instance.questEvents.onStartQuest -= StartQuest;
+        GameEventsManager.instance.questEvents.onAdvanceQuest -= AdvanceQuest;
+        GameEventsManager.instance.questEvents.onFinishQuest -= FinishQuest;
+
+        GameEventsManager.instance.questEvents.onQuestStepStateChange -= QuestStepStateChange;
+
+        GameEventsManager.instance.playerEvents.onPlayerLevelChange -= PlayerLevelChange;
+    }
+
+    private void Start()
+    {
+        
+        foreach (Quest quest in questMap.Values)
+        {
+            // initialize any loaded quest steps
+            if (quest.state == QuestState.IN_PROGRESS)
+            {
+                quest.InstantiateCurrentQuestStep(this.transform);
+            }
+            // broadcast the initial state of all quests on startup
+            GameEventsManager.instance.questEvents.QuestStateChange(quest);
+        }
+    }
+
+    private void ChangeQuestState(string id, QuestState state)
+    {
+        Quest quest = GetQuestById(id);
+        quest.state = state;
+        GameEventsManager.instance.questEvents.QuestStateChange(quest);
+    }
+
+    private void PlayerLevelChange(int level)
+    {
+        currentPlayerLevel = level;
+    }
+
+    private bool CheckRequirementsMet(Quest quest)
+    {
+        // check player level requirements
+        var meetsRequirements = !(currentPlayerLevel < quest.info.levelRequirement);
+
+        // check quest prerequisites for completion
+        foreach (QuestInfoSO prerequisiteQuestInfo in quest.info.questPrerequisites)
+        {
+            if (GetQuestById(prerequisiteQuestInfo.id).state != QuestState.FINISHED)
+            {
+                meetsRequirements = false;
+            }
+        }
+
+        return meetsRequirements;
+    }
+
+    private void Update()
+    {
+        // loop through ALL quests
+        foreach (Quest quest in questMap.Values)
+        {
+            // if we're now meeting the requirements, switch over to the CAN_START state
+            if (quest.state == QuestState.REQUIREMENTS_NOT_MET && CheckRequirementsMet(quest))
+            {
+                ChangeQuestState(quest.info.id, QuestState.CAN_START);
+            }
+        }
+    }
+
+    private void StartQuest(string id) 
+    {
+        Quest quest = GetQuestById(id);
+        quest.InstantiateCurrentQuestStep(this.transform);
+        ChangeQuestState(quest.info.id, QuestState.IN_PROGRESS);
+        SaveQuest(quest);
+    }
+
+    private void AdvanceQuest(string id)
+    {
+        Quest quest = GetQuestById(id);
+
+        // move on to the next step
+        quest.MoveToNextStep();
+        if(isDebug) Debug.Log($"[{quest.info.id}]quest state: {quest.state} - {quest.currentStep} over {quest.info.questStepPrefabs.Length} steps done", this);
+        questStatusUpdateChannel.RaiseEvent($"[{quest.info.id}]quest state: {quest.state} - {quest.currentStep} over {quest.info.questStepPrefabs.Length} steps done");
+        var progress = (float) quest.currentStep / quest.info.questStepPrefabs.Length;
+        if(isDebug) Debug.Log($"[{quest.info.id}] progress: {progress*100}%", this);
+        questProgress.RaiseEvent(quest.info.id, progress);
+
+        // if there are more steps, instantiate the next one
+        if (quest.CurrentStepExists())
+        {
+            quest.InstantiateCurrentQuestStep(this.transform);
+        }
+        // if there are no more steps, then we've finished all of them for this quest
+        else
+        {
+            ChangeQuestState(quest.info.id, QuestState.CAN_FINISH);
+        }
+        SaveQuest(quest);
+    }
+
+    private void FinishQuest(string id)
+    {
+        Quest quest = GetQuestById(id);
+        ClaimRewards(quest);
+        ChangeQuestState(quest.info.id, QuestState.FINISHED);
+        questStatusUpdateChannel.RaiseEvent($"[{quest.info.id}] quest is finished.");
+        questProgress.RaiseEvent(quest.info.id,1);
+        SaveQuest(quest);
+    }
+
+    private void ClaimRewards(Quest quest)
+    {
+        GameEventsManager.instance.scenarioEvents.ScenarioUnlocked(quest.info.unlockedScenario);
+    }
+
+    private void QuestStepStateChange(string id, int stepIndex, QuestStepState questStepState)
+    {
+        Quest quest = GetQuestById(id);
+        quest.StoreQuestStepState(questStepState, stepIndex);
+        ChangeQuestState(id, quest.state);
+    }
+
+    private Dictionary<string, Quest> CreateQuestMap()
+    {
+        // loads all QuestInfoSO Scriptable Objects under the Assets/Resources/Quests folder
+        QuestInfoSO[] allQuests = Resources.LoadAll<QuestInfoSO>("Quests");
+        // Create the quest map
+        Dictionary<string, Quest> idToQuestMap = new Dictionary<string, Quest>();
+        foreach (QuestInfoSO questInfo in allQuests)
+        {
+            if (idToQuestMap.ContainsKey(questInfo.id))
+            {
+                Debug.LogWarning("Duplicate ID found when creating quest map: " + questInfo.id);
+            }
+            idToQuestMap.Add(questInfo.id, LoadQuest(questInfo));
+        }
+        return idToQuestMap;
+    }
+
+    private Quest GetQuestById(string id)
+    {
+        Quest quest = questMap[id];
+        if (quest == null)
+        {
+            Debug.LogError("ID not found in the Quest Map: " + id);
+        }
+        return quest;
+    }
+
+    private void OnApplicationQuit()
+    {
+        foreach (Quest quest in questMap.Values)
+        {
+            SaveQuest(quest);
+        }
+    }
+
+    private void SaveQuest(Quest quest)
+    {
+        try 
+        {
+            QuestData questData = quest.GetQuestData();
+            // serialize using JsonUtility, but use whatever you want here (like JSON.NET)
+            string serializedData = JsonUtility.ToJson(questData);
+            Debug.Log($"saved data {serializedData}");
+            // saving to PlayerPrefs is just a quick example for this tutorial video,
+            // you probably don't want to save this info there long-term.
+            // instead, use an actual Save & Load system and write to a file, the cloud, etc..
+            PlayerPrefs.SetString(quest.info.id, serializedData);
+        }
+        catch (System.Exception e)
+        {
+            Debug.LogError("Failed to save quest with id " + quest.info.id + ": " + e);
+        }
+    }
+
+    private Quest LoadQuest(QuestInfoSO questInfo)
+    {
+        Quest quest = null;
+        try 
+        {
+            // load quest from saved data
+            if (PlayerPrefs.HasKey(questInfo.id) && loadSavedQuestState)
+            {
+                string serializedData = PlayerPrefs.GetString(questInfo.id);
+                QuestData questData = JsonUtility.FromJson<QuestData>(serializedData);
+                quest = new Quest(questInfo, questData.state, questData.questStepIndex, questData.questStepStates);
+            }
+            // otherwise, initialize a new quest
+            else 
+            {
+                quest = new Quest(questInfo);
+            }
+        }
+        catch (System.Exception e)
+        {
+            Debug.LogError("Failed to load quest with id " + quest.info.id + ": " + e);
+        }
+        return quest;
+    }
+}

package/Runtime/Scripts/Core/QuestManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d02fa90f793fbd04e876c5a02753bcbc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Core/QuestState.cs

@@ -0,0 +1,12 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public enum QuestState
+{
+    REQUIREMENTS_NOT_MET,
+    CAN_START,
+    IN_PROGRESS,
+    CAN_FINISH,
+    FINISHED
+}

package/Runtime/Scripts/Core/QuestState.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eff93968abb607d45b86e8b019282186
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Core/QuestStep.cs

@@ -0,0 +1,38 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public abstract class QuestStep : MonoBehaviour
+{
+    private bool isFinished = false;
+    private string questId;
+    private int stepIndex;
+    private float questStepProgress = 0;
+
+    public void InitializeQuestStep(string questId, int stepIndex, string questStepState)
+    {
+        this.questId = questId;
+        this.stepIndex = stepIndex;
+        if (questStepState != null && questStepState != "")
+        {
+            SetQuestStepState(questStepState);
+        }
+    }
+
+    protected void FinishQuestStep()
+    {
+        if (!isFinished)
+        {
+            isFinished = true;
+            GameEventsManager.instance.questEvents.AdvanceQuest(questId);
+            Destroy(this.gameObject);
+        }
+    }
+
+    protected void ChangeState(string newState)
+    {
+        GameEventsManager.instance.questEvents.QuestStepStateChange(questId, stepIndex, new QuestStepState(newState));
+    }
+
+    protected abstract void SetQuestStepState(string state);
+}

package/Runtime/Scripts/Core/QuestStep.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c5332ca0301f0b4c96bd5d094e46e53
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Core/QuestStepState.cs

@@ -0,0 +1,19 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+[System.Serializable]
+public class QuestStepState
+{
+    public string state;
+
+    public QuestStepState(string state)
+    {
+        this.state = state;
+    }
+
+    public QuestStepState()
+    {
+        this.state = "";
+    }
+}

package/Runtime/Scripts/Core/QuestStepState.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 361ad11d06b448c428c62cbfdd5c22ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Core.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d2e587236ade3a84ea55f8612c7fe71e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Events/GameEventsManager.cs

@@ -0,0 +1,29 @@
+using System;
+using UnityEngine;
+
+public class GameEventsManager : MonoBehaviour
+{
+    public static GameEventsManager instance { get; private set; }
+
+    public InputEvents inputEvents;
+    public PlayerEvents playerEvents;
+    public ScenarioEvents scenarioEvents;
+    public MiscEvents miscEvents;
+    public QuestEvents questEvents;
+
+    private void Awake()
+    {
+        if (instance != null)
+        {
+            Debug.LogError("Found more than one Game Events Manager in the scene.");
+        }
+        instance = this;
+
+        // initialize all events
+        inputEvents = new InputEvents();
+        playerEvents = new PlayerEvents();
+        scenarioEvents = new ScenarioEvents();
+        miscEvents = new MiscEvents();
+        questEvents = new QuestEvents();
+    }
+}

package/Runtime/Scripts/Events/GameEventsManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e911054512a703f4ab899299cfcf229e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: -20
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Events/InputEvents.cs

@@ -0,0 +1,32 @@
+using UnityEngine;
+using System;
+
+public class InputEvents
+{
+    public event Action<Vector2> onMovePressed;
+    public void MovePressed(Vector2 moveDir) 
+    {
+        if (onMovePressed != null) 
+        {
+            onMovePressed(moveDir);
+        }
+    }
+
+    public event Action onSubmitPressed;
+    public void SubmitPressed()
+    {
+        if (onSubmitPressed != null) 
+        {
+            onSubmitPressed();
+        }
+    }
+
+    public event Action onQuestLogTogglePressed;
+    public void QuestLogTogglePressed()
+    {
+        if (onQuestLogTogglePressed != null) 
+        {
+            onQuestLogTogglePressed();
+        }
+    }
+}

package/Runtime/Scripts/Events/InputEvents.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 489b7fbcb77df0e498b7eb2756342a5d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Events/MiscEvents.cs

@@ -0,0 +1,22 @@
+using System;
+
+public class MiscEvents
+{
+    public event Action onCoinCollected;
+    public void CoinCollected() 
+    {
+        if (onCoinCollected != null) 
+        {
+            onCoinCollected();
+        }
+    }
+
+    public event Action onGemCollected;
+    public void GemCollected() 
+    {
+        if (onGemCollected != null) 
+        {
+            onGemCollected();
+        }
+    }
+}

package/Runtime/Scripts/Events/MiscEvents.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 47894cdb62664e446b78ef93cb8ee8f0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Events/PlayerEvents.cs

@@ -0,0 +1,49 @@
+using System;
+
+public class PlayerEvents
+{
+    public event Action onDisablePlayerMovement;
+    public void DisablePlayerMovement()
+    {
+        if (onDisablePlayerMovement != null) 
+        {
+            onDisablePlayerMovement();
+        }
+    }
+
+    public event Action onEnablePlayerMovement;
+    public void EnablePlayerMovement()
+    {
+        if (onEnablePlayerMovement != null) 
+        {
+            onEnablePlayerMovement();
+        }
+    }
+
+    public event Action<int> onExperienceGained;
+    public void ExperienceGained(int experience) 
+    {
+        if (onExperienceGained != null) 
+        {
+            onExperienceGained(experience);
+        }
+    }
+
+    public event Action<int> onPlayerLevelChange;
+    public void PlayerLevelChange(int level) 
+    {
+        if (onPlayerLevelChange != null) 
+        {
+            onPlayerLevelChange(level);
+        }
+    }
+
+    public event Action<int> onPlayerExperienceChange;
+    public void PlayerExperienceChange(int experience) 
+    {
+        if (onPlayerExperienceChange != null) 
+        {
+            onPlayerExperienceChange(experience);
+        }
+    }
+}

package/Runtime/Scripts/Events/PlayerEvents.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 05c42289208d5b94da07adea1a6c16fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Events/QuestEvents.cs

@@ -0,0 +1,49 @@
+using System;
+
+public class QuestEvents
+{
+    public event Action<string> onStartQuest;
+    public void StartQuest(string id)
+    {
+        if (onStartQuest != null)
+        {
+            onStartQuest(id);
+        }
+    }
+
+    public event Action<string> onAdvanceQuest;
+    public void AdvanceQuest(string id)
+    {
+        if (onAdvanceQuest != null)
+        {
+            onAdvanceQuest(id);
+        }
+    }
+
+    public event Action<string> onFinishQuest;
+    public void FinishQuest(string id)
+    {
+        if (onFinishQuest != null)
+        {
+            onFinishQuest(id);
+        }
+    }
+
+    public event Action<Quest> onQuestStateChange;
+    public void QuestStateChange(Quest quest)
+    {
+        if (onQuestStateChange != null)
+        {
+            onQuestStateChange(quest);
+        }
+    }
+
+    public event Action<string, int, QuestStepState> onQuestStepStateChange;
+    public void QuestStepStateChange(string id, int stepIndex, QuestStepState questStepState)
+    {
+        if (onQuestStepStateChange != null)
+        {
+            onQuestStepStateChange(id, stepIndex, questStepState);
+        }
+    }
+}

package/Runtime/Scripts/Events/QuestEvents.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 42cf4d17c2e0d77469d63e6c4f6e95e6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Events/ScenarioEvents.cs

@@ -0,0 +1,22 @@
+using System;
+
+public class ScenarioEvents
+{
+    public event Action<string> onScenarioUnlocked;
+    public void ScenarioUnlocked(string id) 
+    {
+        if (onScenarioUnlocked != null) 
+        {
+            onScenarioUnlocked(id);
+        }
+    }
+
+    public event Action<string> onScenarioLocked;
+    public void ScenarioLocked(string id) 
+    {
+        if (onScenarioLocked != null) 
+        {
+            onScenarioLocked(id);
+        }
+    }
+}

package/Runtime/Scripts/Events/ScenarioEvents.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40aa22e174b64d44b8d90da11226d341
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Events.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c0cfd8bf31682f44b8a448b54fd8c779
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: