migration from new repo

Assets/_/Features/Quests/Runtime.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a0afb1d6605e45e3a767caf56a1cf976
+timeCreated: 1754242121

Assets/_/Features/Quests/Runtime/Events.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 48eed2b36d1940d1a0773982975294ec
+timeCreated: 1754468334

Assets/_/Features/Quests/Runtime/Events/EnemyTag.cs

@@ -0,0 +1,14 @@
+namespace Quests.Runtime
+{
+    public enum EnemyTag
+    {
+        Orc,
+        Troll,
+        Rats,
+        Wolves,
+        Gobelins,
+        Bandits,
+        Dragon,
+        Skeleton,
+    }
+}

Assets/_/Features/Quests/Runtime/Events/EnemyTag.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 139a5d5fdd68466bbef3d9f7da5594e8
+timeCreated: 1754469899

Assets/_/Features/Quests/Runtime/Events/EnvironmentTag.cs

@@ -0,0 +1,12 @@
+namespace Quests.Runtime
+{
+    public enum EnvironmentTag
+    {
+        Plain,
+        Cave,
+        Forest,
+        Mountain,
+        Town,
+        Hamlett
+    }
+}

Assets/_/Features/Quests/Runtime/Events/EnvironmentTag.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 823fcc8915904618b4f5a7ce5ed7904b
+timeCreated: 1754469713

Assets/_/Features/Quests/Runtime/Events/EventEffect.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace Quests.Runtime
+{
+    public enum EffectType
+    {
+        Damage,
+        Heal,
+        Gold,
+        Buff,
+        Debuff,
+        ItemLoss,
+        Custom
+    }
+    
+    public enum TargetingType
+    {
+        RandomHero,
+        AllHeroes,
+        LowestHp,
+        HighestHp,
+        LowestMana,
+        HighestMana,
+        LowestDefense,
+        HighestDefense,
+        LowestXp,
+        HighestXp,
+        SpecificClass,
+        None
+    }
+    
+    [Serializable]
+    public struct EventEffect
+    {
+        public EffectType Type;
+        public int Value;
+        public TargetingType Target;
+        public string ExtraData;
+    }
+
+}

Assets/_/Features/Quests/Runtime/Events/EventEffect.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 67a2bafafa7b4f0386e42266a80b84fc
+timeCreated: 1754470856

Assets/_/Features/Quests/Runtime/Events/QuestEvent.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Adventurer.Runtime;
+using Core.Runtime;
+using Newtonsoft.Json;
+using UnityEngine;
+
+namespace Quests.Runtime
+{
+    [Serializable]
+    public class QuestEvent
+    {
+        #region Parameters
+        
+        Guid _id;
+        [SerializeField] string _descriptionKey;
+
+        [SerializeField] QuestEventType _type;
+        [SerializeField] List<EnvironmentTag> _environments;
+        [SerializeField] List<EnemyTag> _enemyTags;
+
+        [SerializeField] int _minLevel;
+        [SerializeField] int _minTimeTrigger;
+        [SerializeField] int _maxTimeTrigger;
+        [SerializeField]  float _percentTrigger;
+
+        [SerializeField] List<EventEffect> _effects;
+        [SerializeField] TargetingType _targetingTypes;
+
+        int _time;
+
+        #endregion
+
+        // Optionnel : getters publics si tu veux exposer ça sans accès direct à la modif
+        public Guid Id => _id;
+        [JsonIgnore] public string DescriptionKey => _descriptionKey;
+        [JsonIgnore] public QuestEventType Type => _type;
+        [JsonIgnore] public List<EnvironmentTag> Environments => _environments;
+        [JsonIgnore] public List<EnemyTag> EnemyTags => _enemyTags;
+        [JsonIgnore]public int MinLevel => _minLevel;
+        [JsonIgnore]public int MinTimeTrigger => _minTimeTrigger;
+        [JsonIgnore]public int MaxTimeTrigger => _maxTimeTrigger;
+        [JsonIgnore]public float PercentTrigger => _percentTrigger;
+        [JsonIgnore] public List<EventEffect> Effects => _effects;
+        [JsonIgnore] public TargetingType TargetingTypes => _targetingTypes;
+
+        public int Time
+        {
+            get { return _time; }
+            set { _time = value; }
+        }
+
+        public QuestEvent(Guid id, QuestEventSO data, int time)
+        {
+            _id = id;
+            _descriptionKey = data.m_data.DescriptionKey;
+            _environments = data.m_data.Environments;
+            _enemyTags = data.m_data.EnemyTags;
+            _minLevel = data.m_data.MinLevel;
+            _minTimeTrigger = data.m_data.MinTimeTrigger;
+            _maxTimeTrigger = data.m_data.MaxTimeTrigger;
+            _percentTrigger = data.m_data.PercentTrigger;
+            _effects = data.m_data.Effects;
+            _targetingTypes = data.m_data.TargetingTypes;
+            _time = time;
+        }
+        
+        public List<AdventurerClass> GetTargets(List<Guid> assignedAdventurersById)
+        {
+            List<AdventurerClass> assignedAdventurers = QuestClass.GetAdventurersFromId(assignedAdventurersById);
+            switch (_targetingTypes)
+            {
+                case TargetingType.AllHeroes:
+                    return assignedAdventurers;
+                case TargetingType.RandomHero:
+                    return new List<AdventurerClass> { assignedAdventurers[UnityEngine.Random.Range(0, assignedAdventurers.Count)] };
+                case TargetingType.LowestHp:
+                    return assignedAdventurers
+                        .OrderBy(adventurer => adventurer.Health)
+                        .Take(1)
+                        .ToList();
+                case TargetingType.None:
+                default:
+                    return new List<AdventurerClass>();
+            }
+        }
+    }
+}

Assets/_/Features/Quests/Runtime/Events/QuestEvent.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ed74403db8734b009db10b835931a998
+timeCreated: 1754468616

Assets/_/Features/Quests/Runtime/Events/QuestEventLog.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+namespace Quests.Runtime
+{
+    [Serializable]
+    public class QuestEventLog
+    {
+        public int Time;
+        public Guid EventId;
+        public QuestEventLog(int time, Guid eventId)
+        {
+            Time = time;
+            EventId = eventId;
+        }
+    }
+}

Assets/_/Features/Quests/Runtime/Events/QuestEventLog.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1a935b81171d40728387513eabf54a0b
+timeCreated: 1754733198

Assets/_/Features/Quests/Runtime/Events/QuestEventPackSO.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Quests.Runtime
+{
+    [CreateAssetMenu(fileName = "QuestEventPack", menuName = "Guild Tycoon/Quests/EventPack", order = 0)]
+    public class QuestEventPackSO : ScriptableObject
+    {
+        
+        public List<QuestEventSO> availableEvents;
+        public int maxEventsToPick = 2;
+    }
+}

Assets/_/Features/Quests/Runtime/Events/QuestEventPackSO.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fd9a61ac0c734fa49cf904db67dc4644
+timeCreated: 1754473539

Assets/_/Features/Quests/Runtime/Events/QuestEventSO.cs

@@ -0,0 +1,32 @@
+using System;
+using UnityEngine;
+
+namespace Quests.Runtime
+{
+    [CreateAssetMenu(fileName = "QuestEventSO", menuName = "Guild Tycoon/Quests/Event", order = 0)]
+    public class QuestEventSO : ScriptableObject
+    {
+        [SerializeField] string m_assetGuid;
+        public QuestEvent m_data;
+        public Guid AssetGuid => Guid.Parse(m_assetGuid);
+
+        public QuestEvent ToQuestEventClass(int time, Guid? id = null)
+        {
+            QuestEvent eventQuest = new QuestEvent(AssetGuid, this, time);
+            
+            return eventQuest;
+        }
+        
+        #if UNITY_EDITOR
+        private void OnValidate()
+        {
+            Guid tempGuid;
+            if (string.IsNullOrEmpty(m_assetGuid) || !Guid.TryParse(m_assetGuid, out tempGuid))
+            {
+                m_assetGuid = Guid.NewGuid().ToString();
+                UnityEditor.EditorUtility.SetDirty(this);
+            }
+        }
+        #endif
+    }
+}

Assets/_/Features/Quests/Runtime/Events/QuestEventSO.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e985bf205d4d456cac619ec3ff4104e1
+timeCreated: 1754468370

Assets/_/Features/Quests/Runtime/Events/QuestEventType.cs

@@ -0,0 +1,14 @@
+namespace Quests.Runtime
+{
+    public enum QuestEventType
+    {
+        Fight,
+        Narrative,
+        Hazard,
+        Reward,
+        Curse,
+        Buff,
+        Interaction,
+        Special
+    }
+}

Assets/_/Features/Quests/Runtime/Events/QuestEventType.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5f8715462e744f8e81cd0a880ec265a9
+timeCreated: 1754469608

Assets/_/Features/Quests/Runtime/QuestClass.cs

@@ -0,0 +1,230 @@
+using System;
+using System.Collections.Generic;
+using Adventurer.Runtime;
+using Core.Runtime;
+using Item.Runtime;
+using Newtonsoft.Json;
+using UnityEngine;
+
+namespace Quests.Runtime
+{
+    [Serializable]
+    public class QuestClass
+    {
+        #region Getters and Setters
+
+        public Guid ID
+        {
+            get { return _id; }
+        }
+
+        public string Name
+        {
+            get { return _name; }
+            set { _name = value; }
+        }
+        
+        [JsonIgnore]
+        public string Description
+        {
+            get { return _description; }
+            set { _description = value; }
+        }
+        
+        [JsonIgnore]
+        public string Objective
+        {
+            get { return _objective; }
+            set { _objective = value; }
+        }
+        
+        [JsonIgnore]
+        public int Duration
+        {
+            get { return _duration; }
+            set { _duration = value; }
+        }
+        
+        [JsonIgnore]
+        public QuestDifficultyEnum Difficulty
+        {
+            get { return _difficulty; }
+            set { _difficulty = value; }
+        }
+        
+        [JsonIgnore]
+        public List<ItemReward> Rewards
+        {
+            get { return _rewards; }
+            set { _rewards = new List<ItemReward>(); }
+        }
+        
+        public QuestStateEnum State
+        {
+            get { return _state; }
+            set { _state = value; }
+        }
+        
+        [JsonIgnore]
+        public int MinLevel
+        {
+            get { return _minLevel; }
+            set { _minLevel = value; }
+        }
+        
+        public List<Guid> AssignedAdventurersID
+        {
+            get
+            {
+                return _assignedAdventurersID;
+            }
+            set
+            {
+                _assignedAdventurersID = value;
+            }
+        }
+        
+        public int StartSeconds
+        {
+            get
+            {
+                return _StartSeconds;
+            }
+            set
+            {
+                _StartSeconds = value;
+            }
+        }
+
+        public int EndSeconds
+        {
+            get
+            {
+                return _endSeconds;
+            }
+            set
+            {
+                _endSeconds = value;
+            }
+        }
+        
+        [JsonIgnore]
+        public QuestEventPackSO EventPack
+        {
+            get
+            {
+                return _eventPack;
+            }
+            set
+            {
+                _eventPack = value;
+            }
+        }
+
+        [JsonIgnore] public List<QuestEvent> ActiveEvents => _activeEvents;
+        [JsonIgnore] public List<string> TriggeredEventsDescriptionKeys = new List<string>();
+        
+        #endregion
+        
+        #region Parameters
+
+        [SerializeField]  string _name;
+        [SerializeField]  string _description;
+        [SerializeField]  string _objective;
+        [SerializeField]  int _duration;
+        [SerializeField]  QuestDifficultyEnum _difficulty;
+        [SerializeField]  List<ItemReward> _rewards;
+        [SerializeField]  int _minLevel; 
+        [SerializeField]  QuestEventPackSO _eventPack;
+        
+        Guid _id;
+        QuestStateEnum _state;
+        int _StartSeconds;
+        int _endSeconds;
+        List<Guid> _assignedAdventurersID = new List<Guid>();
+        List<QuestEvent> _activeEvents = new List<QuestEvent>();
+        
+        #endregion
+        
+        #region Constructor
+
+        public QuestClass(Guid id, string name, string description, string objective, int duration, QuestDifficultyEnum difficulty, List<ItemReward> reward, int minLevel = 1)
+        {
+            _id = id;
+            _name = name;
+            _description = description;
+            _objective = objective;
+            _duration = duration;
+            _difficulty = difficulty;
+            _rewards = reward;
+            _minLevel = minLevel;
+            _state = QuestStateEnum.Disponible;
+        }
+
+        #endregion
+        
+        #region Methods
+
+        public void InitializeEvents(QuestEventPackSO pack)
+        {
+            ActiveEvents.Clear();
+            
+            var pool = new List<QuestEventSO>(pack.availableEvents);
+            int toPick = Mathf.Min(pack.maxEventsToPick, pool.Count);
+
+            for (int i = 0; i < toPick; i++)
+            {
+                int index = UnityEngine.Random.Range(0, pool.Count);
+                var pickedSO = pool[index];
+                pool.RemoveAt(index);
+
+                ActiveEvents.Add(pickedSO.ToQuestEventClass(QuestManager.Instance.currentTimeInQuest)); 
+            }
+        }
+        
+        public static List<AdventurerClass> GetAdventurersFromId(List<Guid> adventurersId)
+        {
+            var adventurers = new List<AdventurerClass>();
+
+            if (adventurersId == null || GameManager.Instance == null || GameManager.Instance.Fact == null)
+                return adventurers;
+
+            foreach (var adventurerId in adventurersId)
+            {
+                var adventurer = GetOneAdventurerFromId(adventurerId);
+                if (adventurer != null)
+                    adventurers.Add(adventurer);
+            }
+
+            return adventurers;
+        }
+
+        public static AdventurerClass GetOneAdventurerFromId(Guid adventurerId)
+        {
+            if (GameManager.Instance.Fact.GetFact<List<AdventurerClass>>("my_adventurers") == null)
+            {
+                return null;
+            }
+            List<AdventurerClass> currentAdventurers = GameManager.Instance.Fact.GetFact<List<AdventurerClass>>("my_adventurers");
+            return currentAdventurers.Find(adventurer => adventurer.ID == adventurerId);
+        }
+
+        public static List<Guid> GetIdFromAdventurers(List<AdventurerClass> adventurers)
+        {
+            List<Guid> adventurersId = new List<Guid>();
+            foreach (var adventurer in adventurers)
+            {
+                adventurersId.Add(adventurer.ID);
+            }
+            return adventurersId;
+        }
+
+        public static Guid GetOneIdFromAdventurer(AdventurerClass adventurer)
+        {
+            List<AdventurerClass> currentAdventurers = GameManager.Instance.Fact.GetFact<List<AdventurerClass>>("my_adventurers");
+            return currentAdventurers.Find(adv => adv.ID == adventurer.ID).ID;
+        }
+        
+        #endregion
+    }
+}

Assets/_/Features/Quests/Runtime/QuestClass.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f2d4a625d9b94e2eacb533bb30c2b2df
+timeCreated: 1754243791

Assets/_/Features/Quests/Runtime/QuestDifficultyEnum.cs

@@ -0,0 +1,11 @@
+namespace Quests.Runtime
+{
+    public enum QuestDifficultyEnum
+    {
+        Easy,
+        Medium,
+        Hard,
+        Extrem,
+        Impossible
+    }
+}

Assets/_/Features/Quests/Runtime/QuestDifficultyEnum.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0e731bc101374d41965d7c246c68bf96
+timeCreated: 1754244214

Assets/_/Features/Quests/Runtime/QuestFactoryDatabase.cs

@@ -0,0 +1,46 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Quests.Runtime;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Quest.Runtime
+{
+    [CreateAssetMenu(fileName = "Database", menuName = "Guild Tycoon/Quests/FactoryDatabase", order = 0)]
+    public class QuestFactoryDatabase : ScriptableObject
+    {
+        [FormerlySerializedAs("factories")]
+        public List<QuestFactorySO> m_factories;
+
+        public QuestFactorySO GetFactoryForLevel(int guildLevel)
+        {
+            QuestFactorySO factory = m_factories
+                .Where(factory => factory.questTemplates.Any(template => template.data.MinLevel <= guildLevel))
+                .OrderBy(f => Random.value)
+                .FirstOrDefault();
+            
+            return factory;
+        }
+
+        public QuestTemplate GetTemplatesByName(string name)
+        {
+            foreach (var factory in m_factories)
+            {
+                foreach (var template in factory.questTemplates)
+                {
+                    if (template.data.Name == name)
+                    {
+                        return template;
+                    }
+                }
+            }
+            return null;
+        }
+
+        public List<QuestFactorySO> GetAll()
+        {
+            return m_factories;
+        }
+    }
+}

Assets/_/Features/Quests/Runtime/QuestFactoryDatabase.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4c5f7d83b0e9412da65dc3826f0d0185
+timeCreated: 1754251952

Assets/_/Features/Quests/Runtime/QuestFactorySO.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Quests.Runtime
+{
+    [CreateAssetMenu(fileName = "Quest Factory", menuName = "Guild Tycoon/Quests/Factory", order = 0)]
+    public class QuestFactorySO : ScriptableObject
+    {
+        public List<QuestTemplate> questTemplates;
+
+        public QuestClass GenerateRandomQuest()
+        {
+            var randomTemplate = questTemplates[Random.Range(0, questTemplates.Count)];
+            return randomTemplate.ToQuestClass(QuestStateEnum.Disponible);
+        }
+    }
+}

Assets/_/Features/Quests/Runtime/QuestFactorySO.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b32e9044bca3400e9418e2d66fe73b49
+timeCreated: 1754247510

Assets/_/Features/Quests/Runtime/QuestInitializer.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using Core.Runtime;
+using Quest.Runtime;
+using UnityEngine;
+
+namespace Quests.Runtime._.Features.Quests
+{
+    public class QuestInitializer : BaseMonobehaviour
+    {
+        void Awake()
+        {
+            var _ = QuestManager.Instance;
+            QuestManager.Instance.QuestDatabase = _questFactoryDatabase;
+        }
+
+        void Start()
+        {
+            if (!FactExists<List<QuestClass>>("active_quests", out var _))
+            {
+                SetFact<List<QuestClass>>("active_quests", new List<QuestClass>(), FactPersistence.Persistent);
+            }
+            QuestManager.Instance.ActiveQuests = GetFact<List<QuestClass>>("active_quests");
+            if (!FactExists<List<QuestClass>>("active_quests", out var _))
+            {
+                SetFact<List<QuestClass>>("completed_quests", new List<QuestClass>(), FactPersistence.Persistent);
+            }
+            QuestManager.Instance.CompletedQuests = GetFact<List<QuestClass>>("completed_quests");
+            Invoke(nameof(NotifyLater), 0.1f);
+        }
+
+        void NotifyLater()
+        {
+            QuestManager.Instance.NotifyCompletedQuests();
+        }
+        
+        [SerializeField] QuestFactoryDatabase _questFactoryDatabase;
+    }
+}
+

Assets/_/Features/Quests/Runtime/QuestInitializer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e8c934d099ac44d6ba1e06e7233c2be1
+timeCreated: 1754424577

Assets/_/Features/Quests/Runtime/QuestManager.cs

@@ -0,0 +1,395 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Adventurer.Runtime;
+using Core.Runtime;
+using Quest.Runtime;
+using UnityEngine;
+using Random = UnityEngine.Random;
+
+namespace Quests.Runtime
+{
+    public class QuestManager : BaseMonobehaviour
+    {
+        #region Singleton
+
+        static QuestManager _instance;
+        public static QuestManager Instance => _instance ??= new QuestManager();
+
+        #endregion
+
+        #region Events
+
+        public static event Action<QuestClass> OnQuestCompleted;
+        public static event Action<QuestEvent> OnEventReceived;
+        public static event Action<QuestClass> OnEventFromQuest;
+
+        #endregion
+
+        #region Properties
+
+         QuestClass _currentQuest;
+        public QuestClass CurrentQuest
+        {
+            get => _currentQuest;
+            set => _currentQuest = value;
+        }
+
+         List<QuestClass> _activeQuests;
+        public List<QuestClass> ActiveQuests
+        {
+            get => _activeQuests;
+            set => _activeQuests = value;
+        }
+
+         List<QuestClass> _completedQuests;
+        public List<QuestClass> CompletedQuests
+        {
+            get => _completedQuests;
+            set => _completedQuests = value;
+        }
+
+        public List<Guid> AssignedAdventurers => _currentQuest?.AssignedAdventurersID;
+
+        [SerializeField]  QuestFactoryDatabase _questDatabase;
+        public QuestFactoryDatabase QuestDatabase
+        {
+            get => _questDatabase;
+            set => _questDatabase = value;
+        }
+
+        public int currentTimeInQuest => _snapTime;
+        int _snapTime = 0;
+        List<QuestEvent> _activeEvents;
+
+        // Champ inutilisé - conservé pour référence future
+         List<QuestEvent> inActiveEvents;
+
+        #endregion
+
+        #region Initialization
+
+        public QuestManager()
+        {
+            GameManager.OnTimeAdvanced += CheckMissionsProgress;
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Démarre une quête avec une équipe d'aventuriers
+        /// </summary>
+        public void StartQuest(QuestClass quest, List<AdventurerClass> team, GameTime gameTime)
+        {
+            AssignAdventurersToQuest(quest, team);
+            SetQuestTimings(quest, gameTime);
+            UpdateQuestStatus(quest);
+        }
+
+        /// <summary>
+        /// Complète une quête et libère les aventuriers assignés
+        /// </summary>
+        public void CompleteQuest(QuestClass quest, List<Guid> team)
+        {
+            if (quest.State != QuestStateEnum.Active) return;
+
+            ReleaseAdventurers(team);
+            UpdateQuestCompletionStatus(quest);
+            SaveQuestProgress();
+        }
+
+        /// <summary>
+        /// Notifie les observateurs des quêtes complétées
+        /// </summary>
+        public void NotifyCompletedQuests()
+        {
+            foreach (var quest in _completedQuests)
+            {
+                OnQuestCompleted?.Invoke(quest);
+            }
+        }
+
+        /// <summary>
+        /// Récupère l'historique des events lié à une quête
+        /// </summary>
+        public QuestSummary GetQuestHistory(Guid questId)
+        {
+            QuestClass quest = GetQuestById(questId);
+
+            List<QuestEventLog> events = GetFact<Dictionary<Guid, List<QuestEventLog>>>("events_quests_history")[questId];
+            
+            return new QuestSummary(quest, events);
+        }
+
+        /// <summary>
+        /// Vérifie si des aventuriers peuvent être sélectionnés pour la quête courante
+        /// </summary>
+        public bool CanSelectedAdventurers()
+        {
+            return _currentQuest != null && _currentQuest.State == QuestStateEnum.Disponible;
+        }
+
+        /// <summary>
+        /// Vérifie si une quête est complétée par son nom
+        /// </summary>
+        public bool IsQuestCompleted(string questName)
+        {
+            return ActiveQuests != null 
+                   && ActiveQuests.Any(q => q.Name == questName && q.State == QuestStateEnum.Completed);
+        }
+
+        /// <summary>
+        /// Résout une liste de quêtes à partir des données sauvegardées
+        /// </summary>
+        public List<QuestClass> ResolveQuestsList(List<QuestClass> questsFromSave)
+        {
+            List<QuestClass> quests = new List<QuestClass>();
+            foreach (var quest in questsFromSave)
+            {
+                QuestTemplate template = _questDatabase.GetTemplatesByName(quest.Name);
+                if (template == null) continue;
+                quests.Add(template.ToQuestClass(quest.State, quest.ID));
+            }
+            return quests;
+        }
+
+        #endregion
+
+        #region  Methods
+
+        /// <summary>
+        /// Assigne des aventuriers à une quête
+        /// </summary>
+       void AssignAdventurersToQuest(QuestClass quest, List<AdventurerClass> team)
+        {
+            foreach (var adventurer in team)
+            {
+                adventurer.IsAvailable = false;
+                if (quest.AssignedAdventurersID == null)
+                    quest.AssignedAdventurersID = new List<Guid>();
+                quest.AssignedAdventurersID.Add(adventurer.ID);
+            }
+        }
+
+        /// <summary>
+        /// Configure les temps de début et de fin d'une quête
+        /// </summary>
+       void SetQuestTimings(QuestClass quest, GameTime gameTime)
+        {
+            quest.State = QuestStateEnum.Active;
+            quest.StartSeconds = gameTime.TotalSeconds;
+            quest.EndSeconds = gameTime.TotalSeconds + (quest.Duration * 60);
+        }
+
+        /// <summary>
+        /// Met à jour le statut d'une quête dans les listes actives et sauvegardées
+        /// </summary>
+       void UpdateQuestStatus(QuestClass quest)
+        {
+            _activeQuests.Add(quest);
+            List<QuestClass> saveQuests = GetFact<List<QuestClass>>("quests");
+            foreach (var saveQuest in saveQuests)
+            {
+                if (saveQuest.Name == quest.Name)
+                {
+                    saveQuest.State = QuestStateEnum.Active;
+                    saveQuest.StartSeconds = quest.StartSeconds;
+                    saveQuest.EndSeconds = quest.EndSeconds;
+                }
+            }
+            SaveFacts();
+        }
+
+        /// <summary>
+        /// Libère les aventuriers assignés à une quête
+        /// </summary>
+       void ReleaseAdventurers(List<Guid> team)
+        {
+            foreach (var adventurerId in team)
+            {
+                AdventurerClass adventurer = QuestClass.GetOneAdventurerFromId(adventurerId);
+                if (adventurer != null)
+                    adventurer.IsAvailable = true;
+            }
+        }
+
+        /// <summary>
+        /// Met à jour le statut de complétion d'une quête
+        /// </summary>
+       void UpdateQuestCompletionStatus(QuestClass quest)
+        {
+            quest.State = QuestStateEnum.Completed;
+            _activeQuests.RemoveAll(q => q.Name == quest.Name);
+            _completedQuests.Add(quest);
+
+            List<QuestClass> quests = GetFact<List<QuestClass>>("quests");
+            QuestClass questToUpdate = quests.FirstOrDefault(q => q.ID == quest.ID);
+            if (questToUpdate != null)
+            {
+                questToUpdate.State = QuestStateEnum.Completed;
+            }
+
+            NotifyCompletedQuests();
+        }
+
+        /// <summary>
+        /// Sauvegarde les progrès des quêtes
+        /// </summary>
+       void SaveQuestProgress()
+        {
+            SaveFacts();
+        }
+
+        /// <summary>
+        /// Vérifie la progression des missions actives
+        /// </summary>
+       void CheckMissionsProgress(int currentSeconds)
+        {
+            if(_activeQuests == null) return;
+
+            var questsToComplete = new List<QuestClass>();
+            var activeQuests = _activeQuests.Where(q => q.State == QuestStateEnum.Active).ToList();
+
+            foreach (var quest in activeQuests)
+            { 
+                _snapTime = currentSeconds - quest.StartSeconds;
+                CheckQuestEvents(quest, currentSeconds);
+
+                if (quest.State == QuestStateEnum.Active && currentSeconds >= quest.EndSeconds)
+                {
+                    questsToComplete.Add(quest);
+                }
+            }
+
+            foreach (var quest in questsToComplete)
+            {
+                CompleteQuest(quest, quest.AssignedAdventurersID);
+            }
+        }
+
+        /// <summary>
+        /// Vérifie et déclenche les événements de quête lorsque les conditions sont remplies
+        /// </summary>
+       void CheckQuestEvents(QuestClass quest, int currentSeconds)
+        {
+            foreach (var questEvent in quest.ActiveEvents)
+            {
+                if (quest.TriggeredEventsDescriptionKeys.Contains(questEvent.DescriptionKey)) 
+                    continue;
+
+                if (_snapTime >= questEvent.MinTimeTrigger && _snapTime <= questEvent.MaxTimeTrigger)
+                {
+                    if (Random.Range(0f, 100f) <= questEvent.PercentTrigger)
+                    {
+                        TriggerEvent(questEvent, quest);
+                        quest.TriggeredEventsDescriptionKeys.Add(questEvent.DescriptionKey);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Déclenche un événement de quête
+        /// </summary>
+       void TriggerEvent(QuestEvent questEvent, QuestClass quest)
+        {
+            questEvent.Time = _snapTime;
+            OnEventReceived?.Invoke(questEvent);
+            OnEventFromQuest?.Invoke(quest);
+
+            var targets = questEvent.GetTargets(quest.AssignedAdventurersID);
+            ApplyEffect(questEvent.Effects, targets);
+            Dictionary<Guid, List<QuestEventLog>> events = GetFact<Dictionary<Guid, List<QuestEventLog>>>("events_quests_history");
+            
+            if(!events.ContainsKey(quest.ID))
+            {
+                events.Add(quest.ID, new List<QuestEventLog>());
+            }
+
+            QuestEventLog questEventLog = new QuestEventLog(_snapTime,  questEvent.Id);
+            
+            events[quest.ID].Add(questEventLog);
+            _activeEvents.Add(questEvent);
+            SaveFacts();
+        }
+
+        /// <summary>
+        /// Applique les effets aux aventuriers ciblés
+        /// </summary>
+       void ApplyEffect(List<EventEffect> effects, List<AdventurerClass> targets)
+        {
+            foreach (var effect in effects)
+            {
+                foreach (var target in targets)
+                {
+                    ApplyEffectToTarget(effect, target);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Applique un effet spécifique à un aventurier cible
+        /// </summary>
+      void ApplyEffectToTarget(EventEffect effect, AdventurerClass target)
+        {
+            switch (effect.Type)
+            {
+                case EffectType.Damage:
+                    target.TakeDamage(effect.Value);
+                    break;
+                case EffectType.Heal:
+                    target.Heal(effect.Value);
+                    break;
+                case EffectType.Buff:
+                    target.ApplyBuff(effect.Value);
+                    break;
+            }
+        }
+        
+        /// <summary>
+        /// Récupère une quête via son ID
+        /// </summary>
+        /// <param name="questId"></param>
+        /// <returns></returns>
+        QuestClass GetQuestById(Guid questId)
+        {
+            QuestClass quest = _activeQuests.FirstOrDefault(q => q.ID == questId);
+            
+            if(quest != null)
+                return quest;
+            
+            quest = _completedQuests.FirstOrDefault(q => q.ID == questId);
+            
+            if(quest != null)
+                return quest;
+
+            foreach (var factory in _questDatabase.GetAll())
+            {
+                foreach (var template in factory.questTemplates)
+                {
+                    if (Guid.TryParse(template.m_assetGuid, out Guid guid) && guid == questId)
+                    {
+                        return template.ToQuestClass(QuestStateEnum.Disponible, questId);
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Récupère un event via son ID
+        /// </summary>
+        /// <param name="eventId"></param>
+        /// <returns>QuestEvent</returns>
+        public QuestEvent GetEventById(Guid eventId)
+        {
+            if (_activeEvents == null) return null;
+            return _activeEvents.FirstOrDefault(e => e.Id == eventId);
+        }
+
+        #endregion
+    }
+}

Assets/_/Features/Quests/Runtime/QuestManager.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ae1758b45e06411c99b6177d9b402a19
+timeCreated: 1754340350

Assets/_/Features/Quests/Runtime/QuestStateEnum.cs

@@ -0,0 +1,9 @@
+namespace Quests.Runtime
+{
+    public enum QuestStateEnum
+    {
+        Disponible,
+        Active,
+        Completed,
+    }
+}

Assets/_/Features/Quests/Runtime/QuestStateEnum.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 616ecf7cb80e49f4863c3e98a67d2e67
+timeCreated: 1754244323

Assets/_/Features/Quests/Runtime/QuestSummary.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+
+namespace Quests.Runtime
+{
+    [Serializable]
+    public class QuestSummary
+    {
+        QuestClass _quest;
+        List<QuestEventLog> _events;
+
+        public QuestClass Quest
+        {
+            get { return _quest; }
+            set { _quest = value; }
+        }
+
+        public List<QuestEventLog> Events
+        {
+            get { return _events; }
+            set { _events = value; }
+        }
+
+        public QuestSummary(QuestClass quest, List<QuestEventLog> events)
+        {
+            _quest = quest;
+            _events = events;
+        }
+    }
+}
+

Assets/_/Features/Quests/Runtime/QuestSummary.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7999947deebe42fc9dc0c13b539e3b75
+timeCreated: 1754732796

Assets/_/Features/Quests/Runtime/QuestTemplate.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using Core.Runtime;
+using UnityEngine;
+
+namespace Quests.Runtime
+{
+    [CreateAssetMenu(fileName = "Quest Template", menuName = "Guild Tycoon/Quests/Template", order = 0)]
+    public class QuestTemplate : ScriptableObject
+    {
+        public string m_assetGuid;
+        public QuestClass data;
+        public QuestClass ToQuestClass(QuestStateEnum stateQuest, Guid? id = null)
+        {
+            List<string> rewardsName = new List<string>();
+            Guid questId = id.HasValue ? id.Value : Guid.NewGuid();
+            foreach (var reward in data.Rewards)
+            {
+                if (reward == null)
+                {
+                    continue;
+                }
+                if (reward.m_itemDefinition == null)
+                {
+                    continue;
+                }
+                string reward_name_amount =
+                    $"{LocalizationSystem.Instance.GetLocalizedText(reward.m_itemDefinition.name)}";
+                rewardsName.Add($"{reward_name_amount} x{reward.m_quantity}");
+            }
+            QuestClass quest = new QuestClass(questId, data.Name, data.Description, data.Objective, data.Duration, data.Difficulty, data.Rewards, data.MinLevel);
+            quest.State = stateQuest;
+            
+            quest.EventPack = data.EventPack;
+            quest.InitializeEvents(data.EventPack);
+            return quest;
+        }
+        
+        #if UNITY_EDITOR
+        private void OnValidate()
+        {
+            Guid tempGuid;
+            if (string.IsNullOrEmpty(m_assetGuid) || !Guid.TryParse(m_assetGuid, out tempGuid))
+            {
+                m_assetGuid = Guid.NewGuid().ToString();
+                UnityEditor.EditorUtility.SetDirty(this);
+            }
+        }
+        #endif
+    }
+}

Assets/_/Features/Quests/Runtime/QuestTemplate.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 521b71060d404540bd5b9baaf3a74cf4
+timeCreated: 1754247875

Assets/_/Features/Quests/Runtime/Quests.Runtime.asmdef

@@ -0,0 +1,19 @@
+{
+    "name": "Quests.Runtime",
+    "rootNamespace": "Quests.Runtime",
+    "references": [
+        "GUID:2ca720bbf8aa349608caa5ce4acaa603",
+        "GUID:18d0f817c4b724b5780374cf971d0724",
+        "GUID:7a6677577d78940c08105c0284857640",
+        "GUID:d01b71ecbce444a299cc1623f29e9d35"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/_/Features/Quests/Runtime/Quests.Runtime.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 239153993e9574192a1980e14075369e
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: