First commit

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

@@ -0,0 +1,138 @@
+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 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 List<string> GetAllSaves()
+        {
+            return GameFacts.GetAllSaves();
+        }
+
+        protected void SaveFacts(string slotName = "")
+        {
+            string slot = GameManager.Instance.Profile;
+            if (slotName != "")
+            {
+                slot = slotName;
+            }
+            
+            if (GameFacts.SaveFacts(slot))
+            {
+                Info("Données sauvegardées avec succès dans le fichier save.json");
+            }
+            else
+            {
+                Error("Failed to save facts");
+            }
+        }
+
+        protected void LoadFacts(string slotName = "")
+        {
+            string slot = GameManager.Instance.Profile;
+            if (slotName != "")
+            {
+                slot = slotName;
+            }
+            
+            if (GameFacts.LoadFacts(slot))
+            {
+                Info("Données chargées avec succès");
+            }
+            else
+            {
+                Error("Failed to load facts");
+            }
+        }
+
+        protected void DeleteSaveFile()
+        {
+            GameFacts.DeleteSaveFile(GameManager.Instance.Profile);
+        }
+        
+        #endregion
+        
+        #region DEBUG
+        
+        protected void Info(string message)
+        {
+            if (!m_isVerbose) return;
+            Debug.Log(message, this);
+        }
+
+        protected void Error(string message)
+        {
+            if (!m_isVerbose) return;
+            Debug.LogError(message, this);
+        }
+
+        protected void Warning(string message)
+        {
+            if (!m_isVerbose) return;
+            Debug.LogWarning(message, this);
+        }
+        
+        #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,14 @@
+{
+    "name": "Core.Runtime",
+    "rootNamespace": "Core.Runtime",
+    "references": [],
+    "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,3 @@
+fileFormatVersion: 2
+guid: 50fff7e431d747439539a559d25219d3
+timeCreated: 1752140467

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

@@ -0,0 +1,43 @@
+using System;
+using Core.Runtime.Interfaces;
+using Unity.Plastic.Newtonsoft.Json;
+using UnityEngine;
+
+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,198 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Codice.Client.BaseCommands.Merge.Xml;
+using Core.Runtime.Interfaces;
+using Unity.Plastic.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 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"))
+                {
+                    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");
+            if (File.Exists(fileSettings)) nbFiles--; // On retire le fichier nommé GeneralSettings_save.json
+            Debug.Log($"NbFiles => {nbFiles}");
+            if(nbFiles <= 0) return false;
+            
+            return true;
+        }
+
+        public bool SaveFacts(string slotName)
+        {
+            Dictionary<string, IFact> persistentsFacts = GetPersistentsFacts();
+            
+            JsonSerializerSettings settings = new JsonSerializerSettings
+            {
+                Formatting = Formatting.Indented,
+                NullValueHandling = NullValueHandling.Ignore,
+                DateFormatHandling = DateFormatHandling.IsoDateFormat,
+                TypeNameHandling = TypeNameHandling.None
+            };
+            
+            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))
+            {
+                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,153 @@
+using System;
+using System.Collections.Generic;
+using PlasticGui;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Core.Runtime
+{
+    public class GameManager: BaseMonobehaviour
+    {
+        #region Privates and Protected
+
+        bool isOnPause = false;
+        SceneLoader _sceneLoader;
+        FactDictionnary _fact;
+        bool _canPause;
+        string _profile;
+        string _currentLanguage = "en";
+        Dictionary<string, string> _localTexts;
+        
+        #endregion
+        
+        #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;
+            }
+        }
+        
+        #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>();
+
+            if(!FactExists<GeneralSettings>("GeneralSettings", out var _))
+            {
+                Profile = "GeneralSettings";
+                GeneralSettings settings = new GeneralSettings();
+                settings.Language = "en";
+                SetFact<GeneralSettings>("GeneralSettings", settings, FactPersistence.Persistent);
+                SaveFacts();
+            }
+            CurrentLanguage = GetFact<GeneralSettings>("GeneralSettings").Language;
+            
+            LocalizationSystem.Instance.LoadLanguage();
+        }
+
+        #endregion
+
+
+        #region Main Methods
+
+        public void CreateObject(GameObject prefab, Vector3 position)
+        {
+            Instantiate(prefab, position, Quaternion.identity);
+        }
+
+        public void ReloadScene()
+        {
+            string sceneName = SceneManager.GetActiveScene().name;
+            _sceneLoader.LoadScene(sceneName);
+        }
+
+        #endregion
+
+
+        #region Utils
+
+        /* Fonctions privées utiles */
+
+        #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/GeneralSettings.cs

@@ -0,0 +1,22 @@
+namespace Core.Runtime
+{
+    public class GeneralSettings
+    {
+        #region Attributes
+        
+        string _language;
+        
+        #endregion
+
+
+        #region Getters and Setters
+
+        public string Language
+        {
+            get => _language;
+            set => _language = value;
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c9de6ca1160646fcb66e8e896ab4998a
+timeCreated: 1759940361

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c2c2153ca77294f16adf4ecf6b122114
+timeCreated: 1751010258

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,89 @@
+using System.Collections.Generic;
+using System.IO;
+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 string GetLocalizedText(string key)
+        {
+            if (GameManager.Instance.GetLocalTexts.TryGetValue(key, out var value))
+                return value;
+    
+            return $"{key}";
+        }
+
+        public void SaveLanguage(string newLanguage)
+        {
+            //
+        }
+        
+        public void LoadLanguage()
+        {
+            string lang = GetLanguage();
+            GameManager.Instance.CurrentLanguage = lang;
+            
+            string langFile = GetLanguageFile();
+            if (!string.IsNullOrEmpty(langFile))
+            {
+                GameManager.Instance.GetLocalTexts = XmlLoader.LoadDictionary(GetLanguageFile());
+            }
+            else
+            {
+                Error($"[ERROR] Language file not found : {lang} <{langFile}>");
+            }
+        }
+        
+        #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<GeneralSettings>("GeneralSettings").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,101 @@
+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)
+        {
+            Info("On vérifie que la scene Loading est disponible");
+            if (SceneExists("Loading"))
+            {
+                LoadScene("Loading");
+                Info($"level suivant {nextSceneName}");
+                StartCoroutine(WaitingLoading(nextSceneName));
+            }
+        }
+
+        #endregion
+
+
+        #region Utils
+
+        private IEnumerator WaitingLoading(string nextSceneName)
+        {
+            int time = Random.Range(3, 6);
+            Info($"On attend {time} secondes et on charge la scene {nextSceneName}");
+            yield return new WaitForSeconds(time);
+            LoadScene(nextSceneName);
+        }
+
+        private void HandleSceneLoaded(Scene scene, LoadSceneMode mode)
+        {
+            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/XmlLoader.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using UnityEngine;
+
+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