toine/GuildTycoon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

premier commit

Browse source
This commit is contained in:
mrtoine 2025-10-10 18:04:44 +02:00
parent 4b8d6108b9
commit 5e4b4b6082
32 changed files with 0 additions and 1083 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Assets/_/Features/Core.meta
View file

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

8
Assets/_/Features/Core/Runtime.meta
View file

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

131
Assets/_/Features/Core/Runtime/BaseMonoBehaviour.cs
View file

@ -1,131 +0,0 @@
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
}
}

2
Assets/_/Features/Core/Runtime/BaseMonoBehaviour.cs.meta
View file

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

16
Assets/_/Features/Core/Runtime/Core.Runtime.asmdef
View file

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

7
Assets/_/Features/Core/Runtime/Core.Runtime.asmdef.meta
View file

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

3
Assets/_/Features/Core/Runtime/Enums.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 7aeca2c5510942e5a3c45ff5272bc040
timeCreated: 1759234532

8
Assets/_/Features/Core/Runtime/Enums/EnumLanguage.cs
View file

@ -1,8 +0,0 @@
namespace Core.Runtime.Enums
{
public enum EnumLanguage
{
English,
French,
}
}

3
Assets/_/Features/Core/Runtime/Enums/EnumLanguage.cs.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: a1f020b6f635444c89c9d8b30acec48b
timeCreated: 1759234549

8
Assets/_/Features/Core/Runtime/FactsSystem.meta
View file

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

42
Assets/_/Features/Core/Runtime/FactsSystem/Fact.cs
View file

@ -1,42 +0,0 @@
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
}
}

3
Assets/_/Features/Core/Runtime/FactsSystem/Fact.cs.meta
View file

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

214
Assets/_/Features/Core/Runtime/FactsSystem/FactDictionary.cs
View file

@ -1,214 +0,0 @@
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
}
}

3
Assets/_/Features/Core/Runtime/FactsSystem/FactDictionary.cs.meta
View file

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

217
Assets/_/Features/Core/Runtime/GameManager.cs
View file

@ -1,217 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Core.Runtime.Enums;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace Core.Runtime
{
public class GameManager: BaseMonobehaviour
{
#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 EnumLanguage 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>();
// Chargement ou création des paramètres
if (m_gameFacts.SaveFileExists("GeneralSettings"))
{
LoadFacts("GeneralSettings");
}
else
{
GeneralSettings settings = new GeneralSettings
{
Language = EnumLanguage.English,
};
SetFact("GeneralSettings", settings, FactPersistence.Persistent);
SaveFacts("GeneralSettings");
}
CurrentLanguage = GetFact<GeneralSettings>("GeneralSettings").Language;
LocalizationSystem.Instance.LoadLanguage(CurrentLanguage);
}
void Start()
{
Debug.Log("Chemin des sauvegardes : " + Application.persistentDataPath);
}
#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
bool isOnPause = false;
SceneLoader _sceneLoader;
FactDictionnary _fact;
bool _canPause;
string _profile;
EnumLanguage _currentLanguage;
Dictionary<string, string> _localTexts;
bool _launchedTime;
int _currentGameTime = 0;
GameTime _gameTime;
#endregion
}
}

11
Assets/_/Features/Core/Runtime/GameManager.cs.meta
View file

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

39
Assets/_/Features/Core/Runtime/GameTime.cs
View file

@ -1,39 +0,0 @@
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;
}
}
}

3
Assets/_/Features/Core/Runtime/GameTime.cs.meta
View file

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

8
Assets/_/Features/Core/Runtime/Interfaces.meta
View file

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

12
Assets/_/Features/Core/Runtime/Interfaces/IFact.cs
View file

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

3
Assets/_/Features/Core/Runtime/Interfaces/IFact.cs.meta
View file

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

105
Assets/_/Features/Core/Runtime/LocalizationSystem.cs
View file

@ -1,105 +0,0 @@
using System;
using System.IO;
using Core.Runtime.Enums;
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(EnumLanguage langReceived)
{
string lang = langReceived.ToString();
if (Enum.TryParse(lang, out EnumLanguage parsedLang))
{
GameManager.Instance.GetLocalTexts = XmlLoader.LoadDictionary(GetLanguageFile(parsedLang));
}
else
{
Debug.LogError($"Language {lang} not found");
return;
}
}
#endregion
#region Utils
private string GetLanguage()
{
string file = GetLanguageFile();
return file.Split('/')[file.Split('/').Length - 1].Split('.')[0];
}
private string GetLanguageFile(EnumLanguage lang = EnumLanguage.French)
{
string filename = $"Localization/{lang}.xml";
string filepath = Path.Combine(Application.streamingAssetsPath, filename);
if (File.Exists(filepath))
{
return filepath;
}
return Path.Combine(Application.streamingAssetsPath, "French.xml");
}
#endregion
}
}

3
Assets/_/Features/Core/Runtime/LocalizationSystem.cs.meta
View file

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

111
Assets/_/Features/Core/Runtime/SceneLoader.cs
View file

@ -1,111 +0,0 @@
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
}
}

3
Assets/_/Features/Core/Runtime/SceneLoader.cs.meta
View file

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

53
Assets/_/Features/Core/Runtime/UIManager.cs
View file

@ -1,53 +0,0 @@
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
}
}

3
Assets/_/Features/Core/Runtime/UIManager.cs.meta
View file

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

21
Assets/_/Features/Core/Runtime/XmlLoader.cs
View file

@ -1,21 +0,0 @@
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
);
}
}
}

3
Assets/_/Features/Core/Runtime/XmlLoader.cs.meta
View file

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

3
Assets/_/Features/Core/Runtime/datas.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: c462b8bd55c644cd93431eff1f2da5d2
timeCreated: 1759234811

26
Assets/_/Features/Core/Runtime/datas/GeneralSettings.cs
View file

@ -1,26 +0,0 @@
using Core.Runtime.Enums;
namespace Core.Runtime
{
public class GeneralSettings
{
#region Attributes
EnumLanguage _language;
#endregion
public EnumLanguage Language
{
get
{
return _language;
}
set
{
_language = value;
}
}
}
}

3
Assets/_/Features/Core/Runtime/datas/GeneralSettings.cs.meta
View file

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 45ead23d22c643d8be8bf9c1e34904fc
timeCreated: 1759234823