Storage (#30)

* storage helper (save/load data)
* no longer needed to pass modbehaviour to asset helper

OWML.Common/IModAssets.cs

@@ -4,9 +4,9 @@ namespace OWML.Common
 {
     public interface IModAssets
     {
-        IModAsset<GameObject> Load3DObject(IModBehaviour modBehaviour, string objectFilename, string imageFilename);
-        IModAsset<MeshFilter> LoadMesh(IModBehaviour modBehaviour, string objectFilename);
-        IModAsset<MeshRenderer> LoadTexture(IModBehaviour modBehaviour, string imageFilename);
-        IModAsset<AudioSource> LoadAudio(IModBehaviour modBehaviour, string audioFilename);
+        IModAsset<GameObject> Load3DObject(string objectFilename, string imageFilename);
+        IModAsset<MeshFilter> LoadMesh(string objectFilename);
+        IModAsset<MeshRenderer> LoadTexture(string imageFilename);
+        IModAsset<AudioSource> LoadAudio(string audioFilename);
     }
 }

OWML.Common/IModBehaviour.cs

@@ -5,7 +5,6 @@ namespace OWML.Common
 {
     public interface IModBehaviour
     {
-        IModManifest ModManifest { get; set; }
         Coroutine StartCoroutine(IEnumerator routine);
     }
 }

OWML.Common/IModHelper.cs

@@ -8,5 +8,7 @@ public interface IModHelper
         IModEvents Events { get; }
         IHarmonyHelper HarmonyHelper { get; }
         IModAssets Assets { get; }
+        IModStorage Storage { get; }
+        IModManifest Manifest { get; }
     }
 }

OWML.Common/IModStorage.cs

@@ -0,0 +1,8 @@
+namespace OWML.Common
+{
+    public interface IModStorage
+    {
+        T Load<T>(string filename);
+        void Save<T>(T obj, string filename);
+    }
+}

OWML.Common/OWML.Common.csproj

@@ -65,6 +65,7 @@
     <Compile Include="IModConsole.cs" />
     <Compile Include="IModLogger.cs" />
     <Compile Include="IModManifest.cs" />
+    <Compile Include="IModStorage.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

OWML.ModHelper.Assets/ModAssets.cs

@@ -8,58 +8,60 @@ namespace OWML.ModHelper.Assets
     public class ModAssets : IModAssets
     {
         private readonly IModConsole _console;
+        private readonly IModManifest _manifest;
         private readonly ObjImporter _objImporter;
 
-        public ModAssets(IModConsole console)
+        public ModAssets(IModConsole console, IModManifest manifest)
         {
             _console = console;
+            _manifest = manifest;
             _objImporter = new ObjImporter();
         }
 
-        public IModAsset<GameObject> Load3DObject(IModBehaviour modBehaviour, string objectFilename, string imageFilename)
+        public IModAsset<GameObject> Load3DObject(string objectFilename, string imageFilename)
         {
-            var objectPath = modBehaviour.ModManifest.FolderPath + objectFilename;
-            var imagePath = modBehaviour.ModManifest.FolderPath + imageFilename;
+            var objectPath = _manifest.FolderPath + objectFilename;
+            var imagePath = _manifest.FolderPath + imageFilename;
             _console.WriteLine("Loading object from " + objectPath);
 
             var go = new GameObject();
             var modAsset = go.AddComponent<ObjectAsset>();
 
-            modBehaviour.StartCoroutine(LoadMesh(modAsset, objectPath));
-            modBehaviour.StartCoroutine(LoadTexture(modAsset, imagePath));
+            modAsset.StartCoroutine(LoadMesh(modAsset, objectPath));
+            modAsset.StartCoroutine(LoadTexture(modAsset, imagePath));
 
             return modAsset;
         }
 
-        public IModAsset<MeshFilter> LoadMesh(IModBehaviour modBehaviour, string objectFilename)
+        public IModAsset<MeshFilter> LoadMesh(string objectFilename)
         {
-            var objectPath = modBehaviour.ModManifest.FolderPath + objectFilename;
+            var objectPath = _manifest.FolderPath + objectFilename;
             _console.WriteLine("Loading mesh from " + objectPath);
 
             var go = new GameObject();
             var modAsset = go.AddComponent<MeshAsset>();
 
-            modBehaviour.StartCoroutine(LoadMesh(modAsset, objectPath));
+            modAsset.StartCoroutine(LoadMesh(modAsset, objectPath));
 
             return modAsset;
         }
 
-        public IModAsset<MeshRenderer> LoadTexture(IModBehaviour modBehaviour, string imageFilename)
+        public IModAsset<MeshRenderer> LoadTexture(string imageFilename)
         {
-            var imagePath = modBehaviour.ModManifest.FolderPath + imageFilename;
+            var imagePath = _manifest.FolderPath + imageFilename;
             _console.WriteLine("Loading texture from " + imagePath);
 
             var go = new GameObject();
             var modAsset = go.AddComponent<TextureAsset>();
 
-            modBehaviour.StartCoroutine(LoadTexture(modAsset, imagePath));
+            modAsset.StartCoroutine(LoadTexture(modAsset, imagePath));
 
             return modAsset;
         }
 
-        public IModAsset<AudioSource> LoadAudio(IModBehaviour modBehaviour, string audioFilename)
+        public IModAsset<AudioSource> LoadAudio(string audioFilename)
         {
-            var audioPath = modBehaviour.ModManifest.FolderPath + audioFilename;
+            var audioPath = _manifest.FolderPath + audioFilename;
             _console.WriteLine("Loading audio from " + audioPath);
 
             var go = new GameObject();
@@ -68,7 +70,7 @@ public IModAsset<AudioSource> LoadAudio(IModBehaviour modBehaviour, string audio
             var loadAudioFrom = audioFilename.EndsWith(".mp3")
                 ? LoadAudioFromMp3(modAsset, audioPath)
                 : LoadAudioFromWav(modAsset, audioPath);
-            modBehaviour.StartCoroutine(loadAudioFrom);
+            modAsset.StartCoroutine(loadAudioFrom);
 
             return modAsset;
         }

OWML.ModHelper/ModBehaviour.cs

@@ -6,12 +6,10 @@ namespace OWML.ModHelper
     public class ModBehaviour : MonoBehaviour, IModBehaviour
     {
         public static IModHelper ModHelper;
-        public IModManifest ModManifest { get; set; }
 
-        public void Init(IModHelper modHelper, IModManifest manifest)
+        public void Init(IModHelper modHelper)
         {
             ModHelper = modHelper;
-            ModManifest = manifest;
             DontDestroyOnLoad(gameObject);
         }
 

OWML.ModHelper/ModHelper.cs

@@ -11,15 +11,19 @@ public class ModHelper : IModHelper
         public IModEvents Events { get; }
         public IHarmonyHelper HarmonyHelper { get; }
         public IModAssets Assets { get; }
+        public IModStorage Storage { get; }
+        public IModManifest Manifest { get; }
 
-        public ModHelper(IModConfig config, IModLogger logger, IModConsole console, IModEvents events, IHarmonyHelper harmonyHelper, IModAssets assets)
+        public ModHelper(IModConfig config, IModLogger logger, IModConsole console, IModEvents events, IHarmonyHelper harmonyHelper, IModAssets assets, IModStorage storage, IModManifest manifest)
         {
             Config = config;
             Logger = logger;
             Console = console;
             Events = events;
             HarmonyHelper = harmonyHelper;
             Assets = assets;
+            Storage = storage;
+            Manifest = manifest;
         }
 
     }

OWML.ModHelper/ModStorage.cs

@@ -0,0 +1,30 @@
+using System.IO;
+using Newtonsoft.Json;
+using OWML.Common;
+
+namespace OWML.ModHelper
+{
+    public class ModStorage : IModStorage
+    {
+        private readonly IModManifest _manifest;
+
+        public ModStorage(IModManifest manifest)
+        {
+            _manifest = manifest;
+        }
+
+        public T Load<T>(string filename)
+        {
+            var path = _manifest.FolderPath + filename;
+            var json = File.ReadAllText(path);
+            return JsonConvert.DeserializeObject<T>(json);
+        }
+
+        public void Save<T>(T obj, string filename)
+        {
+            var path = _manifest.FolderPath + filename;
+            var json = JsonConvert.SerializeObject(obj);
+            File.WriteAllText(path, json);
+        }
+    }
+}

OWML.ModHelper/OWML.ModHelper.csproj

@@ -61,6 +61,7 @@
     <Compile Include="ModHelper.cs" />
     <Compile Include="ModLogger.cs" />
     <Compile Include="ModManifest.cs" />
+    <Compile Include="ModStorage.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

OWML.ModLoader/ModLoader.cs

@@ -3,7 +3,6 @@
 using Newtonsoft.Json;
 using OWML.Common;
 using OWML.ModHelper;
-using OWML.ModHelper.Assets;
 using OWML.ModHelper.Events;
 using UnityEngine;
 
@@ -32,10 +31,8 @@ public static void LoadMods()
                 var console = new ModConsole(config);
                 var harmonyHelper = new HarmonyHelper(logger, console);
                 var events = new ModEvents(harmonyHelper);
-                var assets = new ModAssets(console);
-                var helper = new ModHelper.ModHelper(config, logger, console, events, harmonyHelper, assets);
                 var modFinder = new ModFinder(config);
-                var owo = new Owo(helper, modFinder);
+                var owo = new Owo(modFinder, logger, console, config, harmonyHelper, events);
                 owo.LoadMods();
                 SecondaryLog("Loaded mods");
             }

OWML.ModLoader/Owo.cs

@@ -3,80 +3,97 @@
 using System.Reflection;
 using OWML.Common;
 using OWML.ModHelper;
+using OWML.ModHelper.Assets;
 using UnityEngine;
 
 namespace OWML.ModLoader
 {
     internal class Owo
     {
-        private readonly IModHelper _helper;
         private readonly IModFinder _modFinder;
+        private readonly IModLogger _logger;
+        private readonly IModConsole _console;
+        private readonly IModConfig _config;
+        private readonly IHarmonyHelper _harmonyHelper;
+        private readonly IModEvents _events;
 
-        public Owo(IModHelper helper, IModFinder modFinder)
+        public Owo(IModFinder modFinder, IModLogger logger, IModConsole console, IModConfig config, IHarmonyHelper harmonyHelper, IModEvents events)
         {
-            _helper = helper;
             _modFinder = modFinder;
+            _logger = logger;
+            _console = console;
+            _config = config;
+            _harmonyHelper = harmonyHelper;
+            _events = events;
         }
 
         public void LoadMods()
         {
-            _helper.Logger.Log($"{nameof(Owo)}: {nameof(LoadMods)}");
-            if (_helper.Config.Verbose)
+            _logger.Log($"{nameof(Owo)}: {nameof(LoadMods)}");
+            if (_config.Verbose)
             {
                 Application.logMessageReceived += OnLogMessageReceived;
             }
             var manifests = _modFinder.GetManifests();
             foreach (var manifest in manifests)
             {
-                LoadMod(manifest);
+                var helper = CreateModHelper(manifest);
+                LoadMod(helper);
             }
         }
 
+        private IModHelper CreateModHelper(IModManifest manifest)
+        {
+            var assets = new ModAssets(_console, manifest);
+            var storage = new ModStorage(manifest);
+            return new ModHelper.ModHelper(_config, _logger, _console, _events, _harmonyHelper, assets, storage, manifest);
+        }
+
         private void OnLogMessageReceived(string message, string stackTrace, LogType type)
         {
-            _helper.Logger.Log($"{type}: {message}");
+            _logger.Log($"{type}: {message}");
             if (type == LogType.Error || type == LogType.Exception)
             {
-                _helper.Console.WriteLine($"{type}: {message}");
+                _console.WriteLine($"{type}: {message}");
             }
         }
 
-        private void LoadMod(IModManifest manifest)
+        private void LoadMod(IModHelper helper)
         {
-            var modType = LoadModType(manifest);
+            var modType = LoadModType(helper.Manifest);
             if (modType == null)
             {
-                _helper.Logger.Log("Mod type is null, skipping");
+                _logger.Log("Mod type is null, skipping");
                 return;
             }
-            _helper.Logger.Log($"Loading {manifest.UniqueName} ({manifest.Version})...");
-            _helper.Logger.Log("Adding mod behaviour...");
-            var go = new GameObject(manifest.UniqueName);
+            _logger.Log($"Loading {helper.Manifest.UniqueName} ({helper.Manifest.Version})...");
+            _logger.Log("Adding mod behaviour...");
+            var go = new GameObject(helper.Manifest.UniqueName);
             var mod = (ModBehaviour)go.AddComponent(modType);
-            _helper.Logger.Log("Added! Initializing...");
-            mod.Init(_helper, manifest);
-            _helper.Console.WriteLine($"Loaded {manifest.UniqueName} ({manifest.Version}).");
-            _helper.Logger.Log($"Loaded {manifest.UniqueName} ({manifest.Version}).");
+            _logger.Log("Added! Initializing...");
+            mod.Init(helper);
+            _console.WriteLine($"Loaded {helper.Manifest.UniqueName} ({helper.Manifest.Version}).");
+            _logger.Log($"Loaded {helper.Manifest.UniqueName} ({helper.Manifest.Version}).");
         }
 
         private Type LoadModType(IModManifest manifest)
         {
             if (!manifest.Enabled)
             {
-                _helper.Logger.Log($"{manifest.UniqueName} is disabled");
+                _logger.Log($"{manifest.UniqueName} is disabled");
                 return null;
             }
-            _helper.Logger.Log("Loading assembly: " + manifest.AssemblyPath);
+            _logger.Log("Loading assembly: " + manifest.AssemblyPath);
             var assembly = Assembly.LoadFile(manifest.AssemblyPath);
-            _helper.Logger.Log($"Loaded {assembly.FullName}");
+            _logger.Log($"Loaded {assembly.FullName}");
             try
             {
                 return assembly.GetTypes().FirstOrDefault(x => x.IsSubclassOf(typeof(ModBehaviour)));
             }
             catch (Exception ex)
             {
-                _helper.Logger.Log($"Error while trying to get {typeof(ModBehaviour)}: {ex.Message}");
-                _helper.Console.WriteLine($"Error while trying to get {typeof(ModBehaviour)}: {ex.Message}");
+                _logger.Log($"Error while trying to get {typeof(ModBehaviour)}: {ex.Message}");
+                _console.WriteLine($"Error while trying to get {typeof(ModBehaviour)}: {ex.Message}");
                 return null;
             }
         }

OWML.Nuget/OWML.Nuget.csproj

@@ -67,4 +67,8 @@
     <None Include="OWML.Nuget.nuspec" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
 </Project>