migration from new repo

Assets/_/Features/Core/Runtime.meta

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

Assets/_/Features/Core/Runtime/BaseMonoBehaviour.cs

@@ -0,0 +1,131 @@
+using System.Collections.Generic;
+using Core.Runtime.Interfaces;
+using UnityEngine;
+
+namespace Core.Runtime
+{
+    public class BaseMonobehaviour : MonoBehaviour
+    {
+        #region Publics
+    
+        [Header("Debug")]
+        [SerializeField] protected bool m_isVerbose;
+        
+        public enum FactPersistence
+        {
+            Normal,
+            Persistent,
+        }
+        
+        public GameObject GameObject => _gameObject ? _gameObject : _gameObject = gameObject;
+        public Rigidbody Rigidbody => _rigidbody ? _rigidbody : _rigidbody = GetComponent<Rigidbody>();
+        public Transform Transform => _transform ? _transform : _transform = GetComponent<Transform>();
+        
+        #endregion
+        
+        #region Fact Dictionnary
+
+        protected bool FactExists<T>(string key, out T value)
+        {
+            GameFacts.FactExists<T>(key, out value);
+            return value != null;
+        }
+
+        protected T GetFact<T>(string key)
+        {
+            return GameFacts.GetFact<T>(key);
+        }
+
+        protected Dictionary<string, IFact> GetAllFacts()
+        {
+            return GameFacts.GetAllFacts();
+        }
+        
+        protected List<T> GetAllFactsOfType<T>()
+        {
+            return GameFacts.GetAllFactsOfType<T>();
+        }
+
+        protected void SetFact<T>(string key, T value, FactPersistence persistence = FactPersistence.Normal)
+        {
+            GameFacts.SetFact<T>(key, value, persistence);
+        }
+
+        protected void RemoveFact<T>(string key)
+        {
+            GameFacts.RemoveFact<T>(key);
+        }
+
+        #endregion
+        
+        #region Save System
+
+        protected void GenerateProfile(string profileName)
+        {
+            
+        }
+
+        protected List<string> GetAllSaves()
+        {
+            return GameFacts.GetAllSaves();
+        }
+
+        protected void SaveFacts(string slotName = "")
+        {
+            string slot = GameManager.Instance.Profile;
+            if (slotName != "")
+            {
+                slot = slotName;
+            }
+            
+            GameFacts.SaveFacts(slot);
+        }
+
+        protected void LoadFacts(string slotName = "")
+        {
+            string slot = GameManager.Instance.Profile;
+            if (slotName != "")
+            {
+                slot = slotName;
+            }
+            
+            GameFacts.LoadFacts(slot);
+        }
+
+        protected void DeleteSaveFile()
+        {
+            GameFacts.DeleteSaveFile(GameManager.Instance.Profile);
+        }
+        
+        #endregion
+        
+        #region DEBUG
+        
+        protected void Info(string message)
+        {
+            Debug.Log(message);
+        }
+
+        protected void Error(string message)
+        {
+            Debug.LogError(message);
+        }
+
+        protected void Warning(string message)
+        {
+            Debug.LogWarning(message);
+        }
+        
+        #endregion
+        
+        #region GETTERS
+        
+        private GameObject _gameObject;
+        private Rigidbody _rigidbody;
+        private Transform _transform;
+
+        protected FactDictionnary GameFacts => GameManager.m_gameFacts;
+
+        #endregion
+    }
+}

Assets/_/Features/Core/Runtime/BaseMonoBehaviour.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5a0991893b6c24954afe021de03614ad

Assets/_/Features/Core/Runtime/Core.Runtime.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Core.Runtime",
+    "rootNamespace": "Core.Runtime",
+    "references": [
+        "GUID:6055be8ebefd69e48b49212b09b47b2f"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

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

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

Assets/_/Features/Core/Runtime/FactsSystem.meta

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

Assets/_/Features/Core/Runtime/FactsSystem/Fact.cs

@@ -0,0 +1,42 @@
+using System;
+using Core.Runtime.Interfaces;
+using Newtonsoft.Json;
+
+namespace Core.Runtime
+{
+    public class Fact<T> : IFact
+    {
+
+        #region Publics
+        
+        public T Value;
+
+        public Fact(object value, bool isPersistent)
+        {
+            Value = (T) value;
+            IsPersistent = isPersistent;
+        }
+        
+        public Type ValueType => typeof(T);
+
+        [JsonIgnore]
+        public object GetObjectValue => Value;
+
+        public void SetObjectValue(object value)
+        {
+            if (value is T cast)
+            {
+                Value = cast;
+            }
+            else
+            {
+                throw new InvalidCastException("Cannot asign a value to a fact");           
+            }
+        }
+
+        public bool IsPersistent { get; set; }
+
+        #endregion
+    }
+}
+

Assets/_/Features/Core/Runtime/FactsSystem/Fact.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: dbdaad04e901476ebafb6f2c0d22a257
+timeCreated: 1752132457

Assets/_/Features/Core/Runtime/FactsSystem/FactDictionary.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Core.Runtime.Interfaces;
+using Newtonsoft.Json;
+using UnityEngine;
+
+namespace Core.Runtime
+{
+    public class FactDictionnary
+    {
+        #region Publics
+
+        public Dictionary<string, IFact> AllFacts => _facts;
+
+        #endregion
+        
+        #region Main Methods
+
+        public bool FactExists<T>(string key, out T value)
+        {
+            if (_facts.TryGetValue(key, out var fact) && fact is Fact<T> typedFact)
+            {
+                value = typedFact.Value;
+                return true;
+            }
+            
+            value = default;
+            return false;
+        }
+
+        public void SetFact<T>(string key, T value, BaseMonobehaviour.FactPersistence persistence)
+        {
+            if (_facts.TryGetValue(key, out var existingFact))
+            {
+                if (existingFact is Fact<T> typedFact)
+                {
+                    typedFact.Value = value;
+                    typedFact.IsPersistent = persistence == BaseMonobehaviour.FactPersistence.Persistent;
+                }
+                else
+                {
+                    throw new InvalidCastException("Fact exists but is a wrong type");
+                }
+            }
+            else
+            {
+                bool isPersistent = persistence == BaseMonobehaviour.FactPersistence.Persistent;
+                _facts[key] = new Fact<T>(value, isPersistent);
+            }
+        }
+
+        public T GetFact<T>(string key)
+        {
+            if (!_facts.TryGetValue(key, out var fact))
+            {
+                throw new InvalidCastException($"Fact {key} does not exist");
+            }
+
+            if (_facts[key] is not Fact<T> typedFact)
+            {
+                throw new InvalidCastException($"Fact {key} is not of type {typeof(T)}");
+            }
+
+            return typedFact.Value;
+        }
+
+        public Dictionary<string, IFact> GetAllFacts()
+        {
+            return AllFacts;
+        }
+        
+        public List<T> GetAllFactsOfType<T>()
+        {
+            List<T> list = new();
+            foreach (var fact in _facts.Values)
+            {
+                if (fact is Fact<T> typedFact)
+                {
+                    list.Add(typedFact.Value);
+                }
+            }
+            return list;
+        }
+
+        public void RemoveFact<T>(string key)
+        {
+            _facts.Remove(key);
+        }
+        
+        public List<string> GetAllSaves()
+        {
+            foreach (var slot in Directory.GetFiles(Application.persistentDataPath))
+            {
+                if (slot.Contains("_save.json") && (!slot.Contains("GeneralSettings") || !slot.Contains("continue")))
+                {
+                    string fileName = Path.GetFileNameWithoutExtension(slot);
+                    if (fileName.EndsWith("_save"))
+                    {
+                        string slotName = fileName.Substring(0, fileName.Length - "_save".Length); // "Rom1"
+                        _saves.Add(slotName);
+                    }
+                }
+            }
+            return _saves;
+        }
+
+        public bool SaveFileExists(string slotName= "")
+        {
+            if (slotName != "")
+            {
+                string filename = Path.Combine(Application.persistentDataPath, $"{slotName}_save.json");
+                return File.Exists(filename);
+            }
+
+            int nbFiles = Directory.GetFiles(Application.persistentDataPath, "*.json").Length;
+            string fileSettings = Path.Combine(Application.persistentDataPath, "GeneralSettings_save.json");
+            string fileContinue = Path.Combine(Application.persistentDataPath, "continue_save.json");
+            if (File.Exists(fileSettings)) nbFiles--; // On retire le fichier nommé GeneralSettings_save.json
+            if (File.Exists(fileContinue)) nbFiles--; // On retire le fichier nommé continue_save.json
+            
+            if(nbFiles <= 0) return false;
+            
+            return true;
+        }
+
+        public bool SaveFacts(string slotName)
+        {
+            Dictionary<string, IFact> persistentsFacts = GetPersistentsFacts();
+            
+            // Permet à Newtonsoft de savoir quel type concret sérialiser via le champ $type
+            JsonSerializerSettings settings = new JsonSerializerSettings
+            {
+                Formatting = Formatting.Indented,
+                NullValueHandling = NullValueHandling.Ignore,
+                DateFormatHandling = DateFormatHandling.IsoDateFormat,
+                TypeNameHandling = TypeNameHandling.All // Ajout du type dans le JSON
+            };
+            
+            string json = JsonConvert.SerializeObject(persistentsFacts, settings);
+            string filename = Path.Combine(Application.persistentDataPath, $"{slotName}_save.json");
+            
+            Debug.Log($"Saving to {filename}");
+
+            try
+            {
+                File.WriteAllText(filename, json);
+                _saves.Add(slotName);
+                return true;
+            } 
+            catch (Exception e)
+            {
+                return false;
+            }
+        }
+
+        public bool LoadFacts(string slotName)
+        {
+            string file = Path.Combine(Application.persistentDataPath, $"{slotName}_save.json");
+            if (File.Exists(file))
+            {
+                // Permet à Newtonsoft de savoir quel type concret désérialiser via le champ $type
+                JsonSerializerSettings settings = new JsonSerializerSettings
+                {
+                    TypeNameHandling = TypeNameHandling.All
+                };
+                
+                string json = File.ReadAllText(file);
+                Dictionary<string, IFact> facts = JsonConvert.DeserializeObject<Dictionary<string, IFact>>(json, settings);
+                
+                foreach (var fact in facts)
+                {
+                    _facts[fact.Key] = fact.Value;
+                }
+                return true;
+            }
+            
+            return false;
+        }
+
+        public void DeleteSaveFile(string slotName)
+        {
+            string file = Path.Combine(Application.persistentDataPath, $"{slotName}_save.json");
+            File.Delete(file);
+        }
+        
+        #endregion
+        
+        #region Utils
+        
+        private Dictionary<string, IFact> GetPersistentsFacts()
+        {
+            Dictionary<string, IFact> persistentsFacts = new();
+
+            foreach (var fact in _facts)
+            {
+                if (fact.Value.IsPersistent)
+                {
+                    persistentsFacts.Add(fact.Key, fact.Value);
+                }
+            }
+            return persistentsFacts;
+        }
+
+        #endregion
+        
+        #region private
+        
+        private Dictionary<string, IFact> _facts = new();
+        private List<string> _saves = new List<string>();
+
+        #endregion
+    }
+}

Assets/_/Features/Core/Runtime/FactsSystem/FactDictionary.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bb7f99aca4b5495aaecca229e21225ef
+timeCreated: 1752132416

Assets/_/Features/Core/Runtime/GameManager.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Core.Runtime
+{
+    public class GameManager: BaseMonobehaviour
+    {
+        
+        /*
+         * Appel depuis ici 
+         * Localization => A FAIRE
+         */
+        
+        #region Publics
+        
+        public static GameManager Instance { get; private set; }
+        
+        public static FactDictionnary m_gameFacts;
+        
+        public bool IsOnPause
+        {
+            get => isOnPause;
+            set => isOnPause = value;
+        }
+
+        public FactDictionnary Fact
+        {
+            get
+            {
+                return _fact;
+            }
+            set
+            {
+                _fact = value;
+            }
+        }
+
+        public String Profile
+        {
+            get
+            {
+                return _profile;
+            }
+            set
+            {
+                _profile = value;
+            }
+        }
+
+        public bool SaveFileExist => m_gameFacts.SaveFileExists();
+
+        public bool CanPause
+        {
+            get => _canPause; 
+            set => _canPause = value;
+        }
+
+        public string CurrentLanguage
+        {
+            get
+            {
+                return _currentLanguage;
+            }
+            set
+            {
+                _currentLanguage = value;
+            }
+        }
+
+        public Dictionary<string, string> GetLocalTexts
+        {
+            get
+            {
+                return _localTexts;
+            }
+            set
+            {
+                _localTexts = value;
+            }
+        }
+
+        public int CurrentGameTime
+        {
+            get
+            {
+                return _currentGameTime;
+            }
+            set
+            {
+                _currentGameTime = value;
+            }
+        }
+
+        public bool LaunchedTime
+        {
+            get
+            {
+                return _launchedTime;
+            }
+            set
+            {
+                _launchedTime = value;
+            }
+        }
+        
+        public static event Action<int> OnTimeAdvanced;
+        
+        #endregion
+
+
+        #region Unity API
+
+        private void Awake()
+        {
+            _sceneLoader = GetComponent<SceneLoader>();
+            // Si une instance existe déjà et que ce n’est pas celle-ci, détruire ce GameObject
+            if (Instance != null && Instance != this)
+            {
+                Destroy(gameObject);
+                return;
+            }
+
+            // Sinon, cette instance devient l’instance unique
+            Instance = this;
+            DontDestroyOnLoad(gameObject);
+
+            m_gameFacts = new FactDictionnary();
+            _localTexts = new Dictionary<string, string>();
+
+            LoadFacts("GeneralSettings");
+            _fact = m_gameFacts;
+            CurrentLanguage = m_gameFacts.GetFact<string>("language");
+
+            if (!m_gameFacts.FactExists<string>("language", out _))
+            {
+                m_gameFacts.SetFact("language", "fr", FactPersistence.Persistent);
+            }
+            LocalizationSystem.Instance.LoadLanguage();
+        }
+
+        #endregion
+
+
+        #region Main Methods
+
+        public void ReloadScene()
+        {
+            string sceneName = SceneManager.GetActiveScene().name;
+            _sceneLoader.LoadScene(sceneName);
+        }
+
+        public void UpdateGameTime(GameTime gameTime)
+        {
+            _gameTime = gameTime;
+        }
+        
+        // Time Gestion
+        public void AdvanceTime(int secondes)
+        {
+            _gameTime.Advance(secondes);
+            OnTimeAdvanced?.Invoke(_gameTime.TotalSeconds);
+        }
+
+        public void LaunchGameTime()
+        {
+            if (LaunchedTime) return;
+            LaunchedTime = true;
+            StartCoroutine(TimeTickLoop());
+        }
+
+        #endregion
+
+
+        #region Utils
+
+        /* Fonctions privées utiles */
+        private IEnumerator TimeTickLoop()
+        {
+            while (true)
+            {
+                yield return new WaitForSecondsRealtime(1f);
+                AdvanceTime(1);
+                _currentGameTime++;
+            }
+        }
+
+        #endregion
+
+
+        #region Privates and Protected
+
+        private bool isOnPause = false;
+        private SceneLoader _sceneLoader;
+        private FactDictionnary _fact;
+        private bool _canPause;
+        private string _profile;
+        private string _currentLanguage = "en";
+        private Dictionary<string, string> _localTexts;
+        bool _launchedTime;
+        int _currentGameTime = 0;
+        GameTime _gameTime;
+
+        #endregion
+    }
+}

Assets/_/Features/Core/Runtime/GameManager.cs.meta

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

Assets/_/Features/Core/Runtime/GameTime.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace Core.Runtime
+{
+    [Serializable]
+    public class GameTime
+    {
+        public int Seconds { get; set; }
+        public int Minutes { get; set; }
+        public int Hours { get; set; }
+        public int Days { get; set; }
+
+        public int TotalSeconds => Days * 86400 + Hours * 3600 + Minutes * 60 + Seconds;
+        public int TotalMinutes => Days * 1440 + Hours * 60 + Minutes;
+        public int TotalHours => Days * 24 + Hours;
+        public int TotalDays => Days;
+
+        public GameTime()
+        {
+            Minutes = 0;
+            Hours = 0;
+            Days = 0;
+        }
+
+        public void Advance(int seconds)
+        {
+            Seconds += seconds;
+
+            while (Seconds >= 60) { Seconds -= 60; Minutes++; }
+            while (Minutes >= 60) { Minutes -= 60; Hours++; }
+            while (Hours >= 24) { Hours -= 24; Days++; }
+        }
+
+        public int SnapTime()
+        {
+            return TotalSeconds;
+        }
+    }
+}

Assets/_/Features/Core/Runtime/GameTime.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6afd02148ba241d8ae8592ca5fb38d9f
+timeCreated: 1754390983

Assets/_/Features/Core/Runtime/Interfaces.meta

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

Assets/_/Features/Core/Runtime/Interfaces/IFact.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace Core.Runtime.Interfaces
+{
+    public interface IFact
+    {
+        Type ValueType { get; }
+        object GetObjectValue { get; }
+        void SetObjectValue(object value);
+        bool IsPersistent { get; }
+    }
+}

Assets/_/Features/Core/Runtime/Interfaces/IFact.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 28d823c3a267436eaf00bf170c9669f9
+timeCreated: 1752132484

Assets/_/Features/Core/Runtime/LocalizationSystem.cs

@@ -0,0 +1,107 @@
+using System.IO;
+using TMPro;
+using UnityEngine;
+
+namespace Core.Runtime
+{
+    public class LocalizationSystem : BaseMonobehaviour
+    {
+
+        #region Publics
+
+        public static LocalizationSystem Instance { get; private set; }
+
+        #endregion
+
+
+        #region Unity API
+
+        private void Awake()
+        {
+            if (Instance != null && Instance != this)
+            {
+                Destroy(gameObject);
+                return;
+            }
+            
+            Instance = this;
+            DontDestroyOnLoad(gameObject);
+        }
+
+        #endregion
+
+
+        #region Main Methods
+        
+        public void LocalizeAllTextsIn(Transform root)
+        {
+            foreach (var txt in root.GetComponentsInChildren<TMP_Text>(true))
+            {
+                txt.text = GetLocalizedText(txt.text);
+            }
+        }
+        
+        public string GetLocalizedText(string key)
+        {
+            if (GameManager.Instance.GetLocalTexts.TryGetValue(key, out var value))
+                return value;
+    
+            return $"{key}";
+        }
+
+        public void SaveLanguage(string newLanguage)
+        {
+            if (FactExists<string>("language", out var language))
+            {
+                RemoveFact<string>("language");
+                SetFact<string>("language", newLanguage, FactPersistence.Persistent);
+            }
+            SetFact<string>("language", newLanguage, FactPersistence.Persistent);
+        }
+        
+        public void LoadLanguage()
+        {
+            /*if (!FactExists<string>("language", out var language))
+            {
+                SetFact("language", language, FactPersistence.Persistent);
+            }*/
+            
+            string lang = GetLanguage();
+            GameManager.Instance.CurrentLanguage = lang;
+            
+            string langFile = GetLanguageFile();
+            if (!string.IsNullOrEmpty(langFile))
+            {
+                GameManager.Instance.GetLocalTexts = XmlLoader.LoadDictionary(GetLanguageFile());
+            }
+            else
+            {
+            }
+        }
+        
+        #endregion
+        
+        #region Utils
+
+        private string GetLanguage()
+        {
+            string file = GetLanguageFile();
+            
+            return file.Split('/')[file.Split('/').Length - 1].Split('.')[0];
+        }
+        
+        private string GetLanguageFile()
+        {
+            string filename = Application.dataPath + "/_/Database/Localization/" + GetFact<string>("language") + ".xml";
+
+            if (File.Exists(filename))
+            {
+                return filename;
+            }
+            return "";
+        }
+
+        #endregion
+    }
+}
+

Assets/_/Features/Core/Runtime/LocalizationSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 02c5410883674e91875167d2ef34abe5
+timeCreated: 1752475493

Assets/_/Features/Core/Runtime/SceneLoader.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using Random = UnityEngine.Random;
+
+namespace Core.Runtime
+{
+    public class SceneLoader : BaseMonobehaviour
+    {
+
+        #region Publics
+
+        public static event Action<Scene> OnSceneLoaded;
+        public static string CurrentSceneName => SceneManager.GetActiveScene().name;
+        public static SceneLoader Instance { get; private set; }
+
+        #endregion
+
+
+        #region Unity API
+
+        private void Awake()
+        {
+            if (Instance != null)
+            {
+                Destroy(gameObject);
+                return;
+            }
+            Instance = this;
+            DontDestroyOnLoad(gameObject);
+            
+            SceneManager.sceneLoaded += HandleSceneLoaded;
+        }
+
+        void OnDestroy()
+        {
+            SceneManager.sceneLoaded -= HandleSceneLoaded;
+        }
+
+        #endregion
+
+
+        #region Main Methods
+
+        public void LoadScene(string sceneName)
+        {
+            SceneManager.LoadScene(sceneName);
+        }
+
+        public void FakeLoading(string nextSceneName)
+        {
+            if (SceneExists("Loading"))
+            {
+                LoadScene("Loading");
+                StartCoroutine(WaitingLoading(nextSceneName));
+            }
+        }
+
+        #endregion
+
+
+        #region Utils
+
+        private IEnumerator WaitingLoading(string nextSceneName)
+        {
+            int time = Random.Range(3, 6);
+            yield return new WaitForSeconds(time);
+            LoadScene(nextSceneName);
+        }
+
+        private void HandleSceneLoaded(Scene scene, LoadSceneMode mode)
+        {
+            if (FactExists<GameTime>("game_time", out _))
+            {
+                GameTime gameTime = GetFact<GameTime>("game_time");
+                GameManager.Instance.UpdateGameTime(gameTime);
+                GameManager.Instance.CurrentGameTime = gameTime.TotalSeconds;
+                GameManager.Instance.LaunchGameTime();
+            }
+            else
+            {
+                // Debug supprimé
+            }
+            
+            OnSceneLoaded?.Invoke(scene);
+        }
+        
+        private bool SceneExists(string sceneName)
+        {
+            for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
+            {
+                string path = SceneUtility.GetScenePathByBuildIndex(i);
+                string name = System.IO.Path.GetFileNameWithoutExtension(path);
+                if (name == sceneName)
+                    return true;
+            }
+            return false;
+        }
+        
+        #endregion
+
+
+        #region Privates and Protected
+
+        //
+
+        #endregion
+    }
+}
+

Assets/_/Features/Core/Runtime/SceneLoader.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9a4bd386e20d414fb3e91c510e890143
+timeCreated: 1751130958

Assets/_/Features/Core/Runtime/UIManager.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Core.Runtime
+{
+    public class UIManager : BaseMonobehaviour
+    {
+
+        #region Publics
+
+        public void ShowPanel(GameObject panel)
+        {
+            panel.SetActive(true);
+        }
+
+        public void HideAllPanels()
+        {
+            foreach (var p in panels)
+                p.SetActive(false);
+        }
+
+        #endregion
+
+
+        #region Unity API
+
+        //
+
+        #endregion
+
+
+        #region Main Methods
+
+        // 
+
+        #endregion
+
+
+        #region Utils
+
+        /* Fonctions privées utiles */
+
+        #endregion
+
+
+        #region Privates and Protected
+
+        [SerializeField] private List<GameObject> panels;
+
+        #endregion
+    }
+}
+

Assets/_/Features/Core/Runtime/UIManager.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1ae1264b4c494dc9b3afa715fe5100e0
+timeCreated: 1754230913

Assets/_/Features/Core/Runtime/XmlLoader.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Core.Runtime
+{
+    public class XmlLoader
+    {
+        public static Dictionary<string, string> LoadDictionary(string filepath)
+        {
+            XDocument xmlDoc = XDocument.Load(filepath);
+            return xmlDoc.Root
+                .Elements()
+                .ToDictionary(
+                    e => e.Name.LocalName,
+                    e => e.Value
+                    );
+        }
+    }
+}
+

Assets/_/Features/Core/Runtime/XmlLoader.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f0170f390842426a826731a88149968e
+timeCreated: 1752483882