net.dreditor.core 0.1.5 → 0.1.7

package/Scripts/SaveManaging/GameSaver.cs

@@ -0,0 +1,105 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Saving;
+using DREditor.Services;
+using UnityEngine;
+
+namespace DREditor.SaveManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class GameSaver : MonoBehaviour, IToTitleScreen
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent hasLoadedSaveData = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent firstTimeLoaded = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        DRESaveData currentDRESaveData = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        public DRESaveData CurrentDRESaveData
+        {
+            get
+            {
+                return currentDRESaveData;
+            }
+
+            set
+            {
+                currentDRESaveData = value;
+
+                hasLoadedSaveData.SetValue(currentDRESaveData != null);
+            }
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Start() => CurrentDRESaveData = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="o"></param>
+        public abstract void SaveGameFile(object o = null);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="o"></param>
+        public virtual void LoadGameFile(object o = null)
+        {
+            UnityEngine.Debug.Log("File Data is on variable");
+
+            string slotNum = (string)o;
+
+            CurrentDRESaveData = GetData(slotNum);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="o"></param>
+        public abstract void UpdateGameFromData(object o = null);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="slotNum"></param>
+        /// <returns></returns>
+        public abstract DRESaveData GetData(string slotNum);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="o"></param>
+        /// <remarks></remarks>
+        public abstract void ApplyCurrentData(object o = null);
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void ClearCurrentData() => CurrentDRESaveData = null;
+
+
+        /// <inheritdoc/>
+        public virtual void ToTitleScreen() => firstTimeLoaded.SetValue(true);
+    }
+}

package/Scripts/SaveManaging/GameSaver.cs.meta

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

package/Scripts/SaveManaging/JsonHelper.cs

@@ -0,0 +1,57 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using UnityEngine;
+
+namespace DREditor.SaveManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class JsonHelper
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="json"></param>
+        /// <returns></returns>
+        public static T[] FromJson<T>(string json)
+        {
+            Wrapper<T> wrapper = JsonUtility.FromJson<Wrapper<T>>(json);
+
+            return wrapper.Items;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="array"></param>
+        /// <param name="prettyPrint"></param>
+        /// <returns></returns>
+        public static string ToJson<T>(T[] array, bool prettyPrint = true)
+        {
+            Wrapper<T> wrapper = new(array);
+
+            return JsonUtility.ToJson(wrapper, prettyPrint);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        [Serializable]
+        sealed class Wrapper<T>
+        {
+            /// <summary>
+            ///
+            /// </summary>
+            internal T[] Items;
+
+            internal Wrapper(T[] values)
+            {
+                Items = values;
+            }
+        }
+    }
+}

package/Scripts/SaveManaging/JsonHelper.cs.meta

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

package/Scripts/SaveManaging/SaveSystem.cs

@@ -0,0 +1,246 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Characters;
+using DREditor.Dialogues;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+#if NEWTONSOFT_JSON
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+#endif
+using UnityEngine;
+using DREditor.Saving;
+
+namespace DREditor.SaveManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class SaveSystem
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="toSave"></param>
+        /// <param name="filename"></param>
+        public static void SaveToJSON<T>(List<T> toSave, string filename)
+        {
+            UnityEngine.Debug.Log(GetFilePath(filename));
+
+            string content = JsonHelper.ToJson(toSave.ToArray());
+
+            WriteFile(GetFilePath(filename), content);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="toSave"></param>
+        /// <param name="filename"></param>
+        public static void SaveToJSON<T>(T toSave, string filename)
+        {
+            string content = JsonUtility.ToJson(toSave, true);
+
+            WriteFile(GetFilePath(filename), content);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="filename"></param>
+        /// <returns></returns>
+        public static List<T> ReadListFromJSON<T>(string filename)
+        {
+            string content = ReadFile(GetFilePath(filename));
+
+            if (string.IsNullOrEmpty(content) || content == "{}")
+                return new List<T>();
+
+            List<T> res = JsonHelper.FromJson<T>(content).ToList();
+
+            return res;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="filename"></param>
+        /// <returns></returns>
+        public static T ReadFromJSON<T>(string filename)
+        {
+            string content = ReadFile(GetFilePath(filename));
+            
+            if (string.IsNullOrEmpty(content) || content == "{}")
+                return default;
+
+            content = content.Replace("\"Info\":", "\"Infos\":");
+
+            content = content.Replace("\"DataList\":", "\"dataSets\":");
+
+            content = content.Replace("\"iData\":", "\"itemDialogues\":");
+
+            content = content.Replace("\"aData\":", "\"actorDialogues\":");
+
+            content = content.Replace("\"actorList\":", "\"actorDatas\":");
+
+            content = content.Replace("\"itemList\":", "\"itemDatas\":");
+
+            content = content.Replace("\"spawnList\":", "\"spawnDatas\":");
+
+            content = content.Replace("DREditor.Progression", "DREditor.Progressing");
+
+            T res;
+
+            if (typeof(T) == typeof(SerializableDictionary))
+            {
+                res = JsonUtility.FromJson<T>(content);
+
+                if (res == null)
+                    UnityEngine.Debug.LogWarning("Issue with ReadingFromJSON on file: " + filename);
+            }
+            else
+            {
+#if NEWTONSOFT_JSON
+                // We needed to use the newtonsoft json because when Converting old save file data to the new one,
+                // that way, the system can attempt to salvage corrupted or outdated save data.
+
+                // Load as JObject
+                JObject jObject = JObject.Parse(content);
+
+                var settings = new JsonSerializerSettings
+                {
+                    MissingMemberHandling = MissingMemberHandling.Ignore,
+                    NullValueHandling = NullValueHandling.Ignore,
+                    ContractResolver = new IgnoreTypesResolver(),
+                };
+
+                // Now deserialize
+                res = jObject.ToObject<T>(JsonSerializer.Create(settings));
+#else
+                UnityEngine.Debug.LogError("ALERT: Failed to Load Save file.");
+
+                UnityEngine.Debug.LogWarning("HYPOTHESIS: Since the user does not have the NEWTONSOFT dependency. " +
+                    "It is likely that the data attempting to be loaded is paradoxically outdated. " +
+                    "Which was originally the purpose for the dependency.");
+
+                UnityEngine.Debug.LogWarning("PROPOSAL: Download the NEWTONSOFT dependency.");
+
+                return default;
+#endif
+            }
+
+            return res;
+        }
+#if NEWTONSOFT_JSON
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks></remarks>
+        sealed class IgnoreTypesResolver : DefaultContractResolver
+        {
+            private static readonly HashSet<Type> IgnoredTypes = new()
+            {
+                typeof(Material),
+                typeof(Texture),
+                typeof(GameObject),
+                typeof(AudioClip),
+                typeof(Transform),
+                typeof(ScriptableObject),
+                typeof(Dialogue),
+                typeof(Character)
+            };
+
+            /// <summary>
+            ///
+            /// </summary>
+            /// <param name="member"></param>
+            /// <param name="serialization"></param>
+            /// <returns></returns>
+            protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization serialization)
+            {
+                var prop = base.CreateProperty(member, serialization);
+
+                if (IgnoredTypes.Contains(prop.PropertyType))
+                    prop.Ignored = true;
+
+                return prop;
+            }
+        }
+#endif
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="filename"></param>
+        /// <returns></returns>
+        public static bool SaveFileExists(string filename)
+        {
+            string path = GetFilePath(filename);
+
+            if (File.Exists(path))
+                return IsFileContentValid(path);
+
+            return false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="path"></param>
+        /// <returns></returns>
+        private static bool IsFileContentValid(string path)
+        {
+            string content = ReadFile(path);
+
+            bool contentValid = !(string.IsNullOrEmpty(content) || content == "{}");
+
+            return contentValid;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="filename"></param>
+        /// <returns></returns>
+        private static string GetFilePath(string filename) => Application.persistentDataPath + "/" + filename;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="content"></param>
+        private static void WriteFile(string path, string content)
+        {
+            FileStream fileStream = new(path, FileMode.Create);
+
+            using StreamWriter writer = new(fileStream);
+
+            writer.Write(content);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="path"></param>
+        /// <returns></returns>
+        private static string ReadFile(string path)
+        {
+            if (File.Exists(path))
+            {
+                using StreamReader reader = new(path);
+
+                string content = reader.ReadToEnd();
+
+                return content;
+            }
+
+            return "";
+        }
+    }
+}

package/Scripts/SaveManaging/SaveSystem.cs.meta

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

package/Scripts/SaveManaging.meta

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

package/Scripts/Saving/CacheSerializableDictionaryEntry.cs

@@ -0,0 +1,14 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using UnityEngine;
+
+namespace DREditor.Saving
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class CacheSerializableDictionaryEntry
+    {
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
+        static void CacheTypesFromRegisteredAsseblies() => SerializableDictionaryEntry.CacheTypesFromRegisteredAsseblies();
+    }
+}

package/Scripts/Saving/CacheSerializableDictionaryEntry.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3d26dda6df11758409fc1da2f16d4321

package/Scripts/Saving/CameraPositionSaver.cs

@@ -0,0 +1,60 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DREditor.Saving
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(IDRESaveable) + ", " + nameof(IDRELoadable) +
+        "\n\n")]
+    public class CameraPositionSaver : MonoBehaviour, IDRESaveable, IDRELoadable
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected UnityEngine.Camera trackedCamera = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string saveKeyPosition = "MainPosition";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string saveKeyRotation = "MainRotation";
+
+
+        /// <inheritdoc/>
+        public virtual void Save(Dictionary<string, object> saveData)
+        {
+            saveData.Set(saveKeyPosition, trackedCamera.transform.position);
+
+            saveData.Set(saveKeyRotation, trackedCamera.transform.eulerAngles);
+        }
+
+        /// <inheritdoc/>
+        public virtual void Load(Dictionary<string, object> saveDatas)
+        {
+            if (!saveDatas.ContainsKey(saveKeyPosition))
+                return;
+
+            try
+            {
+                trackedCamera.transform.position = saveDatas.Get<Vector3>(saveKeyPosition);
+
+                trackedCamera.transform.eulerAngles = saveDatas.Get<Vector3>(saveKeyRotation);
+            }
+            catch
+            {
+                UnityEngine.Debug.Log($"{ToString()}: Skipping loading position for tracked camera: " + trackedCamera.gameObject.name);
+            }
+        }
+    }
+}

package/Scripts/Saving/CameraPositionSaver.cs.meta

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

package/Scripts/Saving/DRESaveData.cs

@@ -0,0 +1,34 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using System.Collections.Generic;
+
+namespace DREditor.Saving
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [Serializable]
+    public class DRESaveData
+    {
+        public DRESaveData()
+        {
+            saveDataEntries = new();
+        }
+
+        public DRESaveData(Dictionary<string, object> d)
+        {
+            saveDataEntries = d;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public int version;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks></remarks>
+        public Dictionary<string, object> saveDataEntries = new();
+    }
+}

package/Scripts/Saving/DRESaveData.cs.meta

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

package/Scripts/Saving/DRESaveDictionaryExtention.cs

@@ -0,0 +1,91 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using System.Collections.Generic;
+
+namespace DREditor.Saving
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class DRESaveDictionaryExtension
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="data"></param>
+        /// <param name="key"></param>
+        /// <param name="defaultValue"></param>
+        /// <returns></returns>
+        public static T Get<T>(this Dictionary<string, object> data, string key, T defaultValue = default)
+        {
+            try
+            {
+                if (data.TryGetValue(key, out object value))
+                    return (T)Convert.ChangeType(value, typeof(T));
+            }
+            catch (InvalidCastException invalidCast)
+            {
+                UnityEngine.Debug.Log($"ANALYSIS: Save key: {key} was not of type {typeof(T).Name}" +
+                    $"\nHYPOTHESIS: The system may be attempting to check for an older save data type first " +
+                    $"before converting the proper type. In this event, this log can be ignored." +
+                    $"\n{invalidCast}");
+            }
+            catch (Exception e)
+            {
+                UnityEngine.Debug.LogWarning($"ANALYSIS: Something's wrong with converting data for key: {key}");
+
+                UnityEngine.Debug.LogWarning(e.ToString());
+            }
+
+            return defaultValue;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="key"></param>
+        /// <param name="type"></param>
+        /// <param name="defaultValue"></param>
+        /// <returns></returns>
+        public static object GetGeneric(this Dictionary<string, object> data, string key, Type type, object defaultValue = null)
+        {
+            try
+            {
+                if (data.TryGetValue(key, out object value))
+                    return Convert.ChangeType(value, type);
+            }
+            catch (InvalidCastException invalidCast)
+            {
+                UnityEngine.Debug.Log($"ANALYSIS: Save key: {key} was not of type {type.Name}" +
+                    $"\nHYPOTHESIS: The system may be attempting to check for an older save data type first " +
+                    $"before converting the proper type. In this event, this log can be ignored." +
+                    $"\n{invalidCast}");
+            }
+            catch (Exception e)
+            {
+                UnityEngine.Debug.LogWarning($"ANALYSIS: Something's wrong with converting data for key: {key}");
+
+                UnityEngine.Debug.LogWarning(e.ToString());
+            }
+
+            return defaultValue;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="data"></param>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        public static void Set<T>(this Dictionary<string, object> data, string key, T value)
+        {
+            if (data.ContainsKey(key))
+                UnityEngine.Debug.LogWarning($"DATA KEY: {key} is being REPLACED!");
+
+            data[key] = value;
+        }
+    }
+}