fr.jeanf.questsystem 0.1.9 → 1.0.0

package/.github/workflows/publish.yml

@@ -3,21 +3,23 @@ name: "🚀 publish"
 on:
     push:
         branches:
-          - main
+            - main
+
+permissions:
+    id-token: write  # Required for OIDC
+    contents: read
 
 jobs:
     release:
         name: 🚀 publish
         runs-on: ubuntu-latest
         steps:
-            - name: 📚 checkout
-              uses: actions/checkout@v3
-            - name: 🟢 node
-              uses: actions/setup-node@v3
-              with:
-                  node-version: 16
-                  registry-url: https://registry.npmjs.org
-            - name: 🚀 publish
-              run: npm publish --access public
-              env:
-                  NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}
+            -   name: 📚 checkout
+                uses: actions/checkout@v6
+            -   name: 🟢 node
+                uses: actions/setup-node@v6
+                with:
+                    node-version: 24
+                    registry-url: https://registry.npmjs.org
+            -   name: 🚀 publish
+                run: npm publish --access public

package/Runtime/Scripts/Core/QuestCatalogue.cs

@@ -0,0 +1,63 @@
+using System;
+using UnityEngine;
+
+namespace jeanf.questsystem
+{
+    /// <summary>
+    /// Tracks when <see cref="QuestManager"/> has finished loading addressable quest definitions.
+    /// Consumers should await <see cref="WhenReadyAsync"/> before driving quest lifecycle (start/finish/init).
+    /// </summary>
+    public static class QuestCatalogue
+    {
+        public static bool IsReady { get; private set; }
+        public static bool HasFailed { get; private set; }
+        public static Exception LoadFailure { get; private set; }
+
+        public static event Action Ready;
+        public static event Action<Exception> Failed;
+
+        public static async Awaitable WhenReadyAsync()
+        {
+            while (!IsReady && !HasFailed)
+                await Awaitable.NextFrameAsync();
+
+            if (HasFailed)
+                throw new InvalidOperationException(
+                    "Quest catalog failed to load addressable quests.",
+                    LoadFailure);
+        }
+
+        internal static void BeginLoad()
+        {
+            IsReady = false;
+            HasFailed = false;
+            LoadFailure = null;
+        }
+
+        internal static void MarkReady()
+        {
+            if (IsReady)
+                return;
+
+            IsReady = true;
+            Ready?.Invoke();
+        }
+
+        internal static void MarkFailed(Exception exception)
+        {
+            if (HasFailed)
+                return;
+
+            HasFailed = true;
+            LoadFailure = exception;
+            Failed?.Invoke(exception);
+        }
+
+        internal static void Reset()
+        {
+            IsReady = false;
+            HasFailed = false;
+            LoadFailure = null;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1c256a40528c4f68be69ed7c2fbd8dc1
+timeCreated: 1780444664

package/Runtime/Scripts/Core/QuestItem.cs

@@ -41,6 +41,7 @@ namespace jeanf.questsystem
         [ReadOnly]
         private bool clearToStart = false;
         private string questId;
+        private int _initRequestVersion;
         private QuestState currentQuestState;
         [ReadOnly]
         [Range(0, 1)]
@@ -87,15 +88,14 @@ namespace jeanf.questsystem
         private void OnEnable()
         {
             Subscribe();
-
-            Init(questId);
+            RunInitWhenCatalogueReady(questId);
         }
         private void OnDisable() => Unsubscribe();
         private void OnDestroy() => Unsubscribe();
         private void Subscribe()
         {
             resetChannel.OnEventRaised += Reset;
-            QuestInitialCheck.OnEventRaised += Init;
+            QuestInitialCheck.OnEventRaised += OnQuestInitialCheck;
             QuestProgress.OnEventRaised += UpdateProgress;
             GameEventsManager.instance.questEvents.onQuestStateChange += QuestStateChange;
             GameEventsManager.instance.inputEvents.onSubmitPressed += UpdateState;
@@ -108,7 +108,7 @@ namespace jeanf.questsystem
         private void Unsubscribe()
         {
             resetChannel.OnEventRaised -= Reset;
-            QuestInitialCheck.OnEventRaised -= Init;
+            QuestInitialCheck.OnEventRaised -= OnQuestInitialCheck;
             QuestProgress.OnEventRaised -= UpdateProgress;
             GameEventsManager.instance.questEvents.onQuestStateChange -= QuestStateChange;
             GameEventsManager.instance.inputEvents.onSubmitPressed -= UpdateState;
@@ -170,6 +170,27 @@ namespace jeanf.questsystem
         #endregion
 
         #region quest process
+        private void OnQuestInitialCheck(string id) => RunInitWhenCatalogueReady(id);
+
+        private async void RunInitWhenCatalogueReady(string id)
+        {
+            var requestVersion = ++_initRequestVersion;
+            try
+            {
+                await QuestCatalogue.WhenReadyAsync();
+            }
+            catch (InvalidOperationException e)
+            {
+                Debug.LogError($"[QuestItem] Cannot initialize quest '{id}': {e.Message}", this);
+                return;
+            }
+
+            if (requestVersion != _initRequestVersion || !isActiveAndEnabled)
+                return;
+
+            Init(id);
+        }
+
         private void Init(string id)
         {
             if (transform.childCount > 0)

package/Runtime/Scripts/Core/QuestManager.cs

@@ -4,6 +4,8 @@ using System.Collections.Generic;
 using jeanf.EventSystem;
 using jeanf.validationTools;
 using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.ResourceManagement.AsyncOperations;
 using UnityEngine.Serialization;
 
 namespace jeanf.questsystem
@@ -34,28 +36,29 @@ namespace jeanf.questsystem
         [FormerlySerializedAs("loadQuestState")] [Header("Config")] [SerializeField]
         private bool loadSavedQuestState = true;
         private Dictionary<string, Quest> questMap;
+        private readonly Queue<string> _pendingStartQuestIds = new Queue<string>();
+        private readonly Queue<string> _pendingFinishQuestIds = new Queue<string>();
         private int currentPlayerLevel;
+        
+        // Label strings to load for scriptable objects
+        [Header("Addressables group to load:")]
+        [Tooltip("This group should contain all the scriptable objects that define your quests.")]
+        public List<string> _keys = new List<string>() { "Quests" };
+        private AsyncOperationHandle<IList<QuestSO>> _questAssetsHandle;
+
         #endregion
         #endregion
 
         #region Methods
         #region Standard Unity Methods
-        private void Awake()
-        {
-            questMap = CreateQuestMap();
-
-            foreach (var quest in questMap)
-            {
-                CheckIfQuestIsAlreadyLoaded(quest.Key);
-            }
-        }
+       
         private void OnEnable()
         {
             GameEventsManager.instance.questEvents.onStartQuest += StartQuest;
             GameEventsManager.instance.questEvents.onFinishQuest += FinishQuest;       
-            //GameEventsManager.instance.questEvents.onQuestStepStateChange += QuestStepStateChange;
             GameEventsManager.instance.playerEvents.onPlayerLevelChange += PlayerLevelChange;
-            questStatusUpdateRequested.OnEventRaised += ctx => CheckRequirementsMet(questMap[ctx]);
+            questStatusUpdateRequested.OnEventRaised += OnQuestStatusUpdateRequested;
+            //GameEventsManager.instance.questEvents.onQuestStepStateChange += QuestStepStateChange;
         }
         private void OnDisable() => Unsubscribe();
         private void OnDestroy() => Unsubscribe();
@@ -63,22 +66,50 @@ namespace jeanf.questsystem
         {
             GameEventsManager.instance.questEvents.onStartQuest -= StartQuest;
             GameEventsManager.instance.questEvents.onFinishQuest -= FinishQuest;
-
-            //GameEventsManager.instance.questEvents.onQuestStepStateChange -= QuestStepStateChange;
-
             GameEventsManager.instance.playerEvents.onPlayerLevelChange -= PlayerLevelChange;
+            questStatusUpdateRequested.OnEventRaised -= OnQuestStatusUpdateRequested;
+            if (_questAssetsHandle.IsValid())
+                Addressables.Release(_questAssetsHandle);
+            QuestCatalogue.Reset();
+            _pendingStartQuestIds.Clear();
+            _pendingFinishQuestIds.Clear();
+            //GameEventsManager.instance.questEvents.onQuestStepStateChange -= QuestStepStateChange;
+        }
 
+        private void OnQuestStatusUpdateRequested(string questId)
+        {
+            if (questMap == null || !questMap.TryGetValue(questId, out var quest))
+                return;
+            CheckRequirementsMet(quest);
         }
-        private void Start()
+     
+        private async Awaitable Start()
         {
-            foreach (Quest quest in questMap.Values)
+            QuestCatalogue.BeginLoad();
+            try
             {
-                // broadcast the initial state of all quests on startup
-                GameEventsManager.instance.questEvents.QuestStateChange(quest);
+                questMap = await CreateQuestMap();
+                QuestCatalogue.MarkReady();
+                FlushPendingQuestOperations();
+
+                foreach (var quest in questMap)
+                {
+                    CheckIfQuestIsAlreadyLoaded(quest.Key);
+                    GameEventsManager.instance.questEvents.QuestStateChange(quest.Value);
+                }
+            }
+            catch (Exception e)
+            {
+                QuestCatalogue.MarkFailed(e);
+                Debug.LogError($"[QuestManager] Error loading quest catalogue: {e.Message}");
             }
         }
+        
         private void Update()
         {
+            if (!QuestCatalogue.IsReady || questMap == null)
+                return;
+
             // loop through ALL quests
             foreach (Quest quest in questMap.Values)
             {
@@ -91,6 +122,8 @@ namespace jeanf.questsystem
         }
         private void OnApplicationQuit()
         {
+            if (questMap == null)
+                return;
             foreach (Quest quest in questMap.Values)
             {
                 SaveQuest(quest);
@@ -99,10 +132,47 @@ namespace jeanf.questsystem
         #endregion
 
         #region Quest Checks and getters
-        private Dictionary<string, Quest> CreateQuestMap()
+
+        private static async Awaitable AwaitAsyncOperation<T>(AsyncOperationHandle<T> handle)
+        {
+            while (!handle.IsDone)
+                await Awaitable.NextFrameAsync();
+
+            if (handle.Status != AsyncOperationStatus.Succeeded)
+                throw new Exception("QuestManager failed to load Addressable assets.");
+        }
+
+        private async Awaitable<IList<QuestSO>> LoadQuestAssets(List<string> labels)
         {
-            // loads all QuestInfoSO Scriptable Objects under the Assets/Resources/Quests folder
-            QuestSO[] allQuests = Resources.LoadAll<QuestSO>("Quests");
+            _questAssetsHandle = Addressables.LoadAssetsAsync<QuestSO>(
+                labels,
+                addressable =>
+                {
+                    if (isDebug) Debug.Log($"[QuestManager] Loaded quest SO: {addressable.name}");
+                },
+                Addressables.MergeMode.Union,
+                true);
+
+            await AwaitAsyncOperation(_questAssetsHandle);
+            return _questAssetsHandle.Result;
+        }
+      
+        private async Awaitable<Dictionary<string, Quest>> CreateQuestMap()
+        {
+            // loads all QuestInfoSO Scriptable Objects under the Assets/Quests folder
+            Debug.Log("[QuestManager] Creating quest map");
+            IList<QuestSO> allQuests =  new List<QuestSO>();
+            try
+            {
+                allQuests = await LoadQuestAssets(_keys);
+                if (isDebug) Debug.Log($"[QuestManager] Successfully loaded {allQuests.Count} assets!");
+            }
+            catch (Exception e)
+            {
+                Debug.LogError($"[QuestManager] Error loading assets: {e.Message}");
+                throw;
+            }
+            
             // Create the quest map
             Dictionary<string, Quest> questMap = new Dictionary<string, Quest>();
             foreach (QuestSO questSO in allQuests)
@@ -110,13 +180,13 @@ namespace jeanf.questsystem
                 var id = questSO.id;
                 if (questMap.ContainsKey(id))
                 {
-                    Debug.LogWarning("Duplicate ID found when creating quest map: " + questSO.id);
+                    Debug.LogWarning($"[QuestManager] Duplicate ID found when creating quest map: {questSO.id}");
                 }
                 else
                 {
                     questMap.Add(id, LoadQuest(questSO));
                 }
-                if (isDebug) Debug.Log($"Adding {questSO.name} to the questmap, its id is: {questSO.id}");
+                if (isDebug) Debug.Log($"[QuestManager] Adding {questSO.name} to the questmap, its id is: {questSO.id}");
             }
             return questMap;
         }
@@ -126,14 +196,35 @@ namespace jeanf.questsystem
         }
         public Quest GetQuestById(string id)
         {
-            Quest quest = questMap[id];
-            if (quest == null)
+            if (questMap == null || !questMap.TryGetValue(id, out var quest))
             {
-                Debug.LogError("ID not found in the Quest Map: " + id);
+                Debug.LogError($"[QuestManager] ID not found in the quest map: {id}");
+                return null;
             }
 
             return quest;
         }
+
+        private void FlushPendingQuestOperations()
+        {
+            while (_pendingStartQuestIds.Count > 0)
+                StartQuestCore(_pendingStartQuestIds.Dequeue());
+
+            while (_pendingFinishQuestIds.Count > 0)
+                FinishQuestCore(_pendingFinishQuestIds.Dequeue());
+        }
+
+        private static bool EnqueueUnique(Queue<string> queue, string id)
+        {
+            foreach (var pending in queue)
+            {
+                if (pending == id)
+                    return false;
+            }
+
+            queue.Enqueue(id);
+            return true;
+        }
         private bool CheckRequirementsMet(Quest quest)
         {
             // check player level requirements
@@ -142,19 +233,21 @@ namespace jeanf.questsystem
             // check quest prerequisites for completion
             foreach (QuestSO prerequisiteQuestInfo in quest.questSO.questPrerequisites)
             {
-                if (GetQuestById(prerequisiteQuestInfo.id).state != QuestState.FINISHED)
-                {
+                var prerequisite = GetQuestById(prerequisiteQuestInfo.id);
+                if (prerequisite == null || prerequisite.state != QuestState.FINISHED)
                     meetsRequirements = false;
-                }
             }
 
-            if (isDebug) Debug.Log($"checking requirements for quest: {quest.questSO.name}, [{quest.questSO.id}], meetsRequirements: {meetsRequirements}");
+            if (isDebug) Debug.Log($"[QuestManager] checking requirements for quest: {quest.questSO.name}, [{quest.questSO.id}], meetsRequirements: {meetsRequirements}");
 
             return meetsRequirements;
         }
         private void ChangeQuestState(string id, QuestState state)
         {
-            Quest quest = GetQuestById(id);
+            var quest = GetQuestById(id);
+            if (quest == null)
+                return;
+
             quest.state = state;
             GameEventsManager.instance.questEvents.QuestStateChange(quest);
         }
@@ -163,30 +256,60 @@ namespace jeanf.questsystem
         #region main process
         private void StartQuest(string id)
         {
-            Quest quest = GetQuestById(id);
+            if (!QuestCatalogue.IsReady || questMap == null)
+            {
+                if (EnqueueUnique(_pendingStartQuestIds, id) && isDebug)
+                    Debug.Log($"[QuestManager] StartQuest deferred until catalogue is ready: {id}");
+                return;
+            }
+
+            StartQuestCore(id);
+        }
+
+        private void StartQuestCore(string id)
+        {
+            var quest = GetQuestById(id);
+            if (quest == null)
+                return;
+
             ChangeQuestState(quest.questSO.id, QuestState.IN_PROGRESS);
             SaveQuest(quest);
             if (!quest.sendMessageOnInitialization) return;
             quest.messageChannel.RaiseEvent(quest.messageToSendOnInit);
-            if(isDebug) Debug.Log($"quest id:{id}  started, a message was attatched to the initialization: {quest.messageToSendOnInit}");
+            if (isDebug)
+                Debug.Log($"[QuestManager] quest id:{id} started, message on init: {quest.messageToSendOnInit}");
         }
         private void UpdateProgress(Quest quest)
         {
             var progress = 0;
-            if (quest.questSO.id == null) Debug.Log("C'est null");;
-            if (isDebug) Debug.Log($"[{quest.questSO.id}] progress: {progress * 100}%", this);
+            if (quest.questSO.id == null) Debug.LogError("[QuestManager] quest.questSO.id is null");
+            if (isDebug) Debug.Log($"[QuestManager] [{quest.questSO.id}] progress: {progress * 100}%", this);
             questProgress.RaiseEvent(quest.questSO.id, progress);
         }
         private void FinishQuest(string id)
         {
-            Quest quest = GetQuestById(id);
+            if (!QuestCatalogue.IsReady || questMap == null)
+            {
+                if (EnqueueUnique(_pendingFinishQuestIds, id) && isDebug)
+                    Debug.Log($"[QuestManager] FinishQuest deferred until catalogue is ready: {id}");
+                return;
+            }
+
+            FinishQuestCore(id);
+        }
+
+        private void FinishQuestCore(string id)
+        {
+            var quest = GetQuestById(id);
+            if (quest == null)
+                return;
+
             UpdateProgress(quest);
             ClaimRewards(quest);
             ChangeQuestState(quest.questSO.id, QuestState.FINISHED);
             questStatusUpdateChannel.RaiseEvent(quest.questSO.id);
             questProgress.RaiseEvent(quest.questSO.id, 1);
             SaveQuest(quest);
-            if (!quest.sendMessageOnFinish) return;
         }
         #endregion
 
@@ -225,7 +348,7 @@ namespace jeanf.questsystem
         }
         private Quest LoadQuest(QuestSO questSO)
         {
-            //Debug.Log($"attempting to load quest with id: [{questSO.id}]");
+            if (isDebug) Debug.Log($"[QuestManager] attempting to load quest with id: [{questSO.id}]");
             var quest = new Quest(questSO);
             try
             {
@@ -235,18 +358,18 @@ namespace jeanf.questsystem
                     var serializedData = PlayerPrefs.GetString(questSO.id);
                     var questData = JsonUtility.FromJson<QuestData>(serializedData);
                     quest = new Quest(questSO, questData.state, questData.questStepIndex, questData.questStepStates); 
-                    //Debug.Log($"loaded previously saved quest with id: [{quest.questSO.id}]");
+                    if (isDebug) Debug.Log($"[QuestManager] loaded previously saved quest with id: [{quest.questSO.id}]");
                 }
                 // otherwise, initialize a new quest
                 else
                 {
                     quest = new Quest(questSO);
-                    //Debug.Log($"loaded a fresh instance of quest with id: [{quest.questSO.id}]");
+                    if (isDebug) Debug.Log($"[QuestManager] loaded a fresh instance of quest with id: [{quest.questSO.id}]");
                 }
             }
-            catch (System.Exception e)
+            catch (Exception e)
             {
-                //Debug.LogError($"Failed to load quest with id: [{quest.questSO.id}] - exception: {e}");
+                Debug.LogError($"[QuestManager] Failed to load quest with id: [{quest.questSO.id}] - exception: {e}");
             }
 
             return quest;
@@ -268,7 +391,7 @@ namespace jeanf.questsystem
             
             if (QuestInitialCheck == null)
             {
-                if (isDebug) Debug.Log($"{searching} {_}/QuestInitialCheck in {searchLocation}", this);
+                if (isDebug) Debug.Log($"[QuestManager] {searching} {_}/QuestInitialCheck in {searchLocation}", this);
                 QuestInitialCheck = Resources.Load<StringEventChannelSO>($"{_}/QuestInitialCheck");
                 if (QuestInitialCheck == null)
                 {
@@ -280,7 +403,7 @@ namespace jeanf.questsystem
             
             if (questStatusUpdateChannel == null)
             {
-                if (isDebug) Debug.Log($"{searching} {_}/QuestStatusUpdate in {searchLocation}", this);
+                if (isDebug) Debug.Log($"[QuestManager] {searching} {_}/QuestStatusUpdate in {searchLocation}", this);
                 questStatusUpdateChannel = Resources.Load<StringEventChannelSO>($"{_}/QuestStatusUpdate");
                 if (questStatusUpdateChannel == null)
                 {
@@ -292,7 +415,7 @@ namespace jeanf.questsystem
             
             if (questProgress == null)
             {
-                if (isDebug) Debug.Log($"{searching} {_}/QuestsProgressChannel in {searchLocation}", this);
+                if (isDebug) Debug.Log($"[QuestManager] {searching} {_}/QuestsProgressChannel in {searchLocation}", this);
                 questProgress = Resources.Load<StringFloatEventChannelSO>($"{_}/QuestsProgressChannel");
                 if (questProgress == null)
                 {
@@ -304,7 +427,7 @@ namespace jeanf.questsystem
             
             if (questStatusUpdateRequested == null)
             {
-                if (isDebug) Debug.Log($"{searching} {_}/QuestRequirementCheck in {searchLocation}", this);
+                if (isDebug) Debug.Log($"[QuestManager] {searching} {_}/QuestRequirementCheck in {searchLocation}", this);
                 questStatusUpdateRequested = Resources.Load<StringEventChannelSO>($"{_}/QuestRequirementCheck");
                 if (questStatusUpdateRequested == null)
                 {
@@ -320,7 +443,7 @@ namespace jeanf.questsystem
             if (IsValid && !Application.isPlaying) return;
             for(var i = 0 ; i < invalidObjects.Count ; i++)
             {
-                Debug.LogError($"Error: {errorMessages[i]} " , this.gameObject);
+                Debug.LogError($"[QuestManager] Error: {errorMessages[i]} " , this.gameObject);
             }
         }
         public void OnValidate()

package/Runtime/Scripts/Events/QuestEvents.cs

@@ -11,22 +11,22 @@ namespace jeanf.questsystem
 
         public void StartQuest(string id)
         {
-            if (onStartQuest != null)
-            {
-                Debug.Log($"starting quest: {id}");
-                onStartQuest(id);
-            }
+            if (onStartQuest == null)
+                return;
+
+            Debug.Log($"starting quest: {id}");
+            onStartQuest(id);
         }
 
         public event Action<string> onFinishQuest;
 
         public void FinishQuest(string id)
         {
-            if (onFinishQuest != null)
-            {
-                Debug.Log($"finishing quest: {id}");
-                onFinishQuest(id);
-            }
+            if (onFinishQuest == null)
+                return;
+
+            Debug.Log($"finishing quest: {id}");
+            onFinishQuest(id);
         }
 
         public event Action<Quest> onQuestStateChange;

package/Runtime/Scripts/jeanf.QuestSystem.asmdef

@@ -5,7 +5,9 @@
         "GUID:75469ad4d38634e559750d17036d5f7c",
         "GUID:e134609276952144282613c65d798616",
         "GUID:e8958e6939af7314a97769de4be4ce25",
-        "GUID:db1b0a3157155ad47996061dbcc07bbb"
+        "GUID:db1b0a3157155ad47996061dbcc07bbb",
+        "GUID:84651a3751eca9349aac36a66bba901b",
+        "GUID:9e24947de15b9834991c9d8411ea37cf"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fr.jeanf.questsystem",
-  "version": "0.1.9",
+  "version": "1.0.0",
   "displayName": "Quest system",
   "description": "This package uses Scriptable Objects to define quests.",
   "unity": "2021.3",
@@ -8,6 +8,10 @@
     "jeanf",
     "quest system"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lejeanf/QuestSystem"
+  },
   "author": {
     "name": "Jean-François Robin",
     "email": "robin.jeanfrancois@gmail.com",