From 2468d6d81244944b74cb2a52d5922b950d0addd4 Mon Sep 17 00:00:00 2001
From: amazingalek <alek.ntnu@gmail.com>
Date: Mon, 3 Feb 2020 21:20:26 +0100
Subject: [PATCH] Mods menu (#67)

* mods menu
* mod config UI
* menu controller support
---
 OWML.Common/IModConfig.cs                     |  13 +-
 OWML.Common/IModData.cs                       |   3 +
 OWML.Common/Menus/IModButton.cs               |   2 +
 OWML.Common/Menus/IModConfigMenu.cs           |  10 +
 OWML.Common/Menus/IModInput.cs                |  17 ++
 OWML.Common/Menus/IModInputMenu.cs            |  12 +
 OWML.Common/Menus/IModMenu.cs                 |  31 ++-
 OWML.Common/Menus/IModMenus.cs                |   2 +
 OWML.Common/Menus/IModNumberInput.cs          |   8 +
 OWML.Common/Menus/IModPopupMenu.cs            |   2 +
 OWML.Common/Menus/IModSliderInput.cs          |  11 +
 OWML.Common/Menus/IModTabMenu.cs              |   4 +
 OWML.Common/Menus/IModTabbedMenu.cs           |   1 +
 OWML.Common/Menus/IModTextInput.cs            |   8 +
 OWML.Common/Menus/IModToggleInput.cs          |  11 +
 OWML.Common/Menus/IModsMenu.cs                |  10 +
 OWML.Common/Menus/InputType.cs                |   9 +
 OWML.Common/OWML.Common.csproj                |   9 +
 OWML.Launcher/App.cs                          |   2 +-
 OWML.ModHelper.Menus/ModButton.cs             |  14 +-
 OWML.ModHelper.Menus/ModConfigMenu.cs         | 210 ++++++++++++++++++
 OWML.ModHelper.Menus/ModInput.cs              |  62 ++++++
 OWML.ModHelper.Menus/ModInputField.cs         |  35 +++
 OWML.ModHelper.Menus/ModInputMenu.cs          |  94 ++++++++
 OWML.ModHelper.Menus/ModMainMenu.cs           |   5 +-
 OWML.ModHelper.Menus/ModMenu.cs               | 199 ++++++++++++++++-
 OWML.ModHelper.Menus/ModMenus.cs              |  16 +-
 OWML.ModHelper.Menus/ModNumberInput.cs        |  60 +++++
 OWML.ModHelper.Menus/ModOptionsMenu.cs        |  62 ++++--
 OWML.ModHelper.Menus/ModPopupMenu.cs          |   7 +-
 OWML.ModHelper.Menus/ModSliderInput.cs        |  51 +++++
 OWML.ModHelper.Menus/ModTabMenu.cs            |  35 ++-
 OWML.ModHelper.Menus/ModTextInput.cs          |  59 +++++
 OWML.ModHelper.Menus/ModToggleInput.cs        |  49 ++++
 OWML.ModHelper.Menus/ModsMenu.cs              | 104 +++++++--
 .../OWML.ModHelper.Menus.csproj               |  11 +
 OWML.ModHelper.Menus/packages.config          |   1 +
 OWML.ModHelper/ControllerButton.cs            |  34 +++
 OWML.ModHelper/DontDestroyOnLoad.cs           |  12 +
 OWML.ModHelper/ModConfig.cs                   |  38 +++-
 OWML.ModHelper/OWML.ModHelper.csproj          |  12 +-
 OWML.ModLoader/ModData.cs                     |  17 +-
 OWML.ModLoader/ModFinder.cs                   |   9 +-
 OWML.ModLoader/Owo.cs                         |  26 +--
 .../OWML.EnableDebugMode/manifest.json        |   2 +-
 .../OWML.LoadCustomAssets/LoadCustomAssets.cs |  33 +--
 .../OWML.LoadCustomAssets/default-config.json |  29 ++-
 .../OWML.LoadCustomAssets/manifest.json       |   2 +-
 OWML.sln.DotSettings                          |   1 +
 Readme.md                                     |   1 +
 50 files changed, 1321 insertions(+), 134 deletions(-)
 create mode 100644 OWML.Common/Menus/IModConfigMenu.cs
 create mode 100644 OWML.Common/Menus/IModInput.cs
 create mode 100644 OWML.Common/Menus/IModInputMenu.cs
 create mode 100644 OWML.Common/Menus/IModNumberInput.cs
 create mode 100644 OWML.Common/Menus/IModSliderInput.cs
 create mode 100644 OWML.Common/Menus/IModTextInput.cs
 create mode 100644 OWML.Common/Menus/IModToggleInput.cs
 create mode 100644 OWML.Common/Menus/IModsMenu.cs
 create mode 100644 OWML.Common/Menus/InputType.cs
 create mode 100644 OWML.ModHelper.Menus/ModConfigMenu.cs
 create mode 100644 OWML.ModHelper.Menus/ModInput.cs
 create mode 100644 OWML.ModHelper.Menus/ModInputField.cs
 create mode 100644 OWML.ModHelper.Menus/ModInputMenu.cs
 create mode 100644 OWML.ModHelper.Menus/ModNumberInput.cs
 create mode 100644 OWML.ModHelper.Menus/ModSliderInput.cs
 create mode 100644 OWML.ModHelper.Menus/ModTextInput.cs
 create mode 100644 OWML.ModHelper.Menus/ModToggleInput.cs
 create mode 100644 OWML.ModHelper/ControllerButton.cs
 create mode 100644 OWML.ModHelper/DontDestroyOnLoad.cs

diff --git a/OWML.Common/IModConfig.cs b/OWML.Common/IModConfig.cs
index e0c894e4..6cf4b734 100644
--- a/OWML.Common/IModConfig.cs
+++ b/OWML.Common/IModConfig.cs
@@ -1,12 +1,17 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace OWML.Common
 {
     public interface IModConfig
     {
-        bool Enabled { get; }
-        bool RequireVR { get; }
-        Dictionary<string, object> Settings { get; }
+        bool Enabled { get; set; }
+        bool RequireVR { get; set; }
+        Dictionary<string, object> Settings { get; set; }
+        T GetSettingsValue<T>(string key);
+        void SetSettingsValue(string key, object value);
+
+        [Obsolete("Use GetSettingsValue instead")]
         T GetSetting<T>(string key);
     }
 }
diff --git a/OWML.Common/IModData.cs b/OWML.Common/IModData.cs
index 86aeeecb..cbf14944 100644
--- a/OWML.Common/IModData.cs
+++ b/OWML.Common/IModData.cs
@@ -4,5 +4,8 @@ public interface IModData
     {
         IModManifest Manifest { get; }
         IModConfig Config { get; }
+        IModConfig DefaultConfig { get; }
+
+        void ResetConfig();
     }
 }
\ No newline at end of file
diff --git a/OWML.Common/Menus/IModButton.cs b/OWML.Common/Menus/IModButton.cs
index 41eff159..7a65931e 100644
--- a/OWML.Common/Menus/IModButton.cs
+++ b/OWML.Common/Menus/IModButton.cs
@@ -28,5 +28,7 @@ public interface IModButton
 
         void Show();
         void Hide();
+
+        void SetControllerCommand(SingleAxisCommand inputCommand);
     }
 }
\ No newline at end of file
diff --git a/OWML.Common/Menus/IModConfigMenu.cs b/OWML.Common/Menus/IModConfigMenu.cs
new file mode 100644
index 00000000..2718a63c
--- /dev/null
+++ b/OWML.Common/Menus/IModConfigMenu.cs
@@ -0,0 +1,10 @@
+namespace OWML.Common.Menus
+{
+    public interface IModConfigMenu : IModPopupMenu
+    {
+        IModData ModData { get; }
+        IModBehaviour Mod { get; }
+
+        void Initialize(Menu modMenuCopy, IModToggleInput toggleTemplate, IModSliderInput sliderTemplate, IModTextInput textInputTemplate, IModNumberInput numberInputTemplate);
+    }
+}
diff --git a/OWML.Common/Menus/IModInput.cs b/OWML.Common/Menus/IModInput.cs
new file mode 100644
index 00000000..57639f06
--- /dev/null
+++ b/OWML.Common/Menus/IModInput.cs
@@ -0,0 +1,17 @@
+using System;
+using UnityEngine;
+
+namespace OWML.Common.Menus
+{
+    public interface IModInput<T>
+    {
+        event Action<T> OnChange;
+        T Value { get; set; }
+        MonoBehaviour Element { get; }
+        string Title { get; set; }
+        int Index { get; set; }
+        void Show();
+        void Hide();
+        void Initialize(IModMenu menu);
+    }
+}
\ No newline at end of file
diff --git a/OWML.Common/Menus/IModInputMenu.cs b/OWML.Common/Menus/IModInputMenu.cs
new file mode 100644
index 00000000..4d81e1b8
--- /dev/null
+++ b/OWML.Common/Menus/IModInputMenu.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace OWML.Common.Menus
+{
+    public interface IModInputMenu : IModMenu
+    {
+        event Action<string> OnConfirm;
+        event Action OnCancel;
+        void Initialize(PopupInputMenu inputMenu);
+        void Open(InputType inputType, string value);
+    }
+}
diff --git a/OWML.Common/Menus/IModMenu.cs b/OWML.Common/Menus/IModMenu.cs
index d7b065b5..a747b07d 100644
--- a/OWML.Common/Menus/IModMenu.cs
+++ b/OWML.Common/Menus/IModMenu.cs
@@ -9,10 +9,37 @@ public interface IModMenu
         event Action OnInit;
 
         Menu Menu { get; }
+
         List<IModButton> Buttons { get; }
         IModButton GetButton(string title);
-        void AddButton(IModButton button);
-        void AddButton(IModButton button, int index);
+        IModButton AddButton(IModButton button);
+        IModButton AddButton(IModButton button, int index);
+
+        List<IModToggleInput> ToggleInputs { get; }
+        IModToggleInput GetToggleInput(string title);
+        IModToggleInput AddToggleInput(IModToggleInput input);
+        IModToggleInput AddToggleInput(IModToggleInput input, int index);
+
+        List<IModSliderInput> SliderInputs { get; }
+        IModSliderInput GetSliderInput(string title);
+        IModSliderInput AddSliderInput(IModSliderInput input);
+        IModSliderInput AddSliderInput(IModSliderInput input, int index);
+
+        List<IModTextInput> TextInputs { get; }
+        IModTextInput GetTextInput(string title);
+        IModTextInput AddTextInput(IModTextInput input);
+        IModTextInput AddTextInput(IModTextInput input, int index);
+
+        List<IModNumberInput> NumberInputs { get; }
+        IModNumberInput GetNumberInput(string title);
+        IModNumberInput AddNumberInput(IModNumberInput input);
+        IModNumberInput AddNumberInput(IModNumberInput input, int index);
+
+        object GetInputValue(string key);
+        void SetInputValue(string key, object value);
+
+        void SelectFirst();
+        void UpdateNavigation();
 
         [Obsolete("Use Buttons instead")]
         List<Button> GetButtons();
diff --git a/OWML.Common/Menus/IModMenus.cs b/OWML.Common/Menus/IModMenus.cs
index 90698be5..4ab4206f 100644
--- a/OWML.Common/Menus/IModMenus.cs
+++ b/OWML.Common/Menus/IModMenus.cs
@@ -4,5 +4,7 @@ public interface IModMenus
     {
         IModMainMenu MainMenu { get; }
         IModPauseMenu PauseMenu { get; }
+        IModsMenu ModsMenu { get; }
+        IModInputMenu InputMenu { get; }
     }
 }
diff --git a/OWML.Common/Menus/IModNumberInput.cs b/OWML.Common/Menus/IModNumberInput.cs
new file mode 100644
index 00000000..aa3dba6e
--- /dev/null
+++ b/OWML.Common/Menus/IModNumberInput.cs
@@ -0,0 +1,8 @@
+namespace OWML.Common.Menus
+{
+    public interface IModNumberInput : IModInput<float>
+    {
+        IModNumberInput Copy();
+        IModNumberInput Copy(string key);
+    }
+}
diff --git a/OWML.Common/Menus/IModPopupMenu.cs b/OWML.Common/Menus/IModPopupMenu.cs
index ab82e221..81e6cc0c 100644
--- a/OWML.Common/Menus/IModPopupMenu.cs
+++ b/OWML.Common/Menus/IModPopupMenu.cs
@@ -1,4 +1,5 @@
 using System;
+using UnityEngine.UI;
 
 namespace OWML.Common.Menus
 {
@@ -17,6 +18,7 @@ public interface IModPopupMenu : IModMenu
         IModPopupMenu Copy();
         IModPopupMenu Copy(string title);
         void Initialize(Menu menu);
+        void Initialize(Menu menu, LayoutGroup layoutGroup);
 
         [Obsolete("Use Copy instead")]
         IModPopupMenu CreateCopy(string name);
diff --git a/OWML.Common/Menus/IModSliderInput.cs b/OWML.Common/Menus/IModSliderInput.cs
new file mode 100644
index 00000000..9fa3949f
--- /dev/null
+++ b/OWML.Common/Menus/IModSliderInput.cs
@@ -0,0 +1,11 @@
+namespace OWML.Common.Menus
+{
+    public interface IModSliderInput : IModInput<float>
+    {
+        float Min { get; set; }
+        float Max { get; set; }
+
+        IModSliderInput Copy();
+        IModSliderInput Copy(string title);
+    }
+}
diff --git a/OWML.Common/Menus/IModTabMenu.cs b/OWML.Common/Menus/IModTabMenu.cs
index a65ffab1..67ff6aa7 100644
--- a/OWML.Common/Menus/IModTabMenu.cs
+++ b/OWML.Common/Menus/IModTabMenu.cs
@@ -3,5 +3,9 @@
     public interface IModTabMenu : IModPopupMenu
     {
         void Initialize(TabButton tabButton);
+        TabButton TabButton { get; }
+        new IModTabMenu Copy();
+        new IModTabMenu Copy(string title);
+        new string Title { get; set; }
     }
 }
\ No newline at end of file
diff --git a/OWML.Common/Menus/IModTabbedMenu.cs b/OWML.Common/Menus/IModTabbedMenu.cs
index a007de92..85acf770 100644
--- a/OWML.Common/Menus/IModTabbedMenu.cs
+++ b/OWML.Common/Menus/IModTabbedMenu.cs
@@ -11,5 +11,6 @@ public interface IModTabbedMenu : IModPopupMenu
 
         void Initialize(TabbedMenu menu);
         new TabbedMenu Menu { get; }
+        void AddTab(IModTabMenu tab);
     }
 }
diff --git a/OWML.Common/Menus/IModTextInput.cs b/OWML.Common/Menus/IModTextInput.cs
new file mode 100644
index 00000000..b254970b
--- /dev/null
+++ b/OWML.Common/Menus/IModTextInput.cs
@@ -0,0 +1,8 @@
+namespace OWML.Common.Menus
+{
+    public interface IModTextInput : IModInput<string>
+    {
+        IModTextInput Copy();
+        IModTextInput Copy(string key);
+    }
+}
diff --git a/OWML.Common/Menus/IModToggleInput.cs b/OWML.Common/Menus/IModToggleInput.cs
new file mode 100644
index 00000000..de528386
--- /dev/null
+++ b/OWML.Common/Menus/IModToggleInput.cs
@@ -0,0 +1,11 @@
+namespace OWML.Common.Menus
+{
+    public interface IModToggleInput : IModInput<bool>
+    {
+        TwoButtonToggleElement Toggle { get; }
+        IModButton YesButton { get; }
+        IModButton NoButton { get; }
+        IModToggleInput Copy();
+        IModToggleInput Copy(string key);
+    }
+}
diff --git a/OWML.Common/Menus/IModsMenu.cs b/OWML.Common/Menus/IModsMenu.cs
new file mode 100644
index 00000000..28ebc8de
--- /dev/null
+++ b/OWML.Common/Menus/IModsMenu.cs
@@ -0,0 +1,10 @@
+namespace OWML.Common.Menus
+{
+    public interface IModsMenu : IModPopupMenu
+    {
+        void AddMod(IModData modData, IModBehaviour mod);
+        IModConfigMenu GetModMenu(IModBehaviour modBehaviour);
+        void Initialize(IModMainMenu mainMenu);
+        void Initialize(IModPauseMenu pauseMenu);
+    }
+}
diff --git a/OWML.Common/Menus/InputType.cs b/OWML.Common/Menus/InputType.cs
new file mode 100644
index 00000000..64bc09cb
--- /dev/null
+++ b/OWML.Common/Menus/InputType.cs
@@ -0,0 +1,9 @@
+namespace OWML.Common.Menus
+{
+    public enum InputType
+    {
+        Text = 0,
+        Number = 1
+    };
+
+}
diff --git a/OWML.Common/OWML.Common.csproj b/OWML.Common/OWML.Common.csproj
index e5c74119..c4ad6867 100644
--- a/OWML.Common/OWML.Common.csproj
+++ b/OWML.Common/OWML.Common.csproj
@@ -67,11 +67,16 @@
     <Compile Include="IHarmonyHelper.cs" />
     <Compile Include="IModAssets.cs" />
     <Compile Include="IModAsset.cs" />
+    <Compile Include="Menus\InputType.cs" />
     <Compile Include="Menus\IModButton.cs" />
     <Compile Include="IModConfig.cs" />
     <Compile Include="IModData.cs" />
+    <Compile Include="Menus\IModConfigMenu.cs" />
+    <Compile Include="Menus\IModInput.cs" />
+    <Compile Include="Menus\IModInputMenu.cs" />
     <Compile Include="Menus\IModMainMenu.cs" />
     <Compile Include="Menus\IModPauseMenu.cs" />
+    <Compile Include="Menus\IModsMenu.cs" />
     <Compile Include="Menus\IModTabbedMenu.cs" />
     <Compile Include="Menus\IModPopupMenu.cs" />
     <Compile Include="Menus\IModTabMenu.cs" />
@@ -86,6 +91,10 @@
     <Compile Include="IModLogger.cs" />
     <Compile Include="IModManifest.cs" />
     <Compile Include="IModStorage.cs" />
+    <Compile Include="Menus\IModSliderInput.cs" />
+    <Compile Include="Menus\IModNumberInput.cs" />
+    <Compile Include="Menus\IModTextInput.cs" />
+    <Compile Include="Menus\IModToggleInput.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/OWML.Launcher/App.cs b/OWML.Launcher/App.cs
index ece1159c..422a390f 100644
--- a/OWML.Launcher/App.cs
+++ b/OWML.Launcher/App.cs
@@ -12,7 +12,7 @@ namespace OWML.Launcher
 {
     public class App
     {
-        private const string Version = "0.3.31";
+        private const string Version = "0.3.32";
 
         private readonly IOwmlConfig _owmlConfig;
         private readonly IModConsole _writer;
diff --git a/OWML.ModHelper.Menus/ModButton.cs b/OWML.ModHelper.Menus/ModButton.cs
index 5cd16571..c9bd9d92 100644
--- a/OWML.ModHelper.Menus/ModButton.cs
+++ b/OWML.ModHelper.Menus/ModButton.cs
@@ -15,8 +15,12 @@ public class ModButton : IModButton
         private readonly Text _text;
         public string Title
         {
-            get => _text.text;
-            set => _text.text = value;
+            get => _text != null ? _text.text : "";
+            set
+            {
+                GameObject.Destroy(Button.GetComponentInChildren<LocalizedText>());
+                _text.text = value;
+            }
         }
 
         private int _index;
@@ -47,7 +51,6 @@ public IModButton Copy()
         {
             var button = GameObject.Instantiate(Button);
             GameObject.Destroy(button.GetComponent<SubmitAction>());
-            GameObject.Destroy(button.GetComponentInChildren<LocalizedText>());
             return new ModButton(button, Menu)
             {
                 Index = Index + 1
@@ -141,5 +144,10 @@ public void Hide()
             Button.gameObject.SetActive(false);
         }
 
+        public void SetControllerCommand(SingleAxisCommand inputCommand)
+        {
+            Button.gameObject.AddComponent<ControllerButton>().Init(inputCommand);
+        }
+
     }
 }
diff --git a/OWML.ModHelper.Menus/ModConfigMenu.cs b/OWML.ModHelper.Menus/ModConfigMenu.cs
new file mode 100644
index 00000000..dd9a1ddb
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModConfigMenu.cs
@@ -0,0 +1,210 @@
+using Newtonsoft.Json.Linq;
+using OWML.Common;
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+using System;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModConfigMenu : ModPopupMenu, IModConfigMenu
+    {
+        public IModData ModData { get; }
+        public IModBehaviour Mod { get; }
+
+        private IModLogger _logger;
+        private IModConsole _console;
+        private IModStorage _storage;
+
+        private IModToggleInput _toggleTemplate;
+        private IModSliderInput _sliderTemplate;
+        private IModTextInput _textInputTemplate;
+        private IModNumberInput _numberInputTemplate;
+
+        public ModConfigMenu(IModLogger logger, IModConsole console, IModData modData, IModBehaviour mod) : base(logger, console)
+        {
+            _logger = logger;
+            _console = console;
+            ModData = modData;
+            Mod = mod;
+            _storage = new ModStorage(console, modData.Manifest);
+        }
+
+        public void Initialize(Menu menu, IModToggleInput toggleTemplate, IModSliderInput sliderTemplate, IModTextInput textInputTemplate, IModNumberInput numberInputTemplate)
+        {
+            _toggleTemplate = toggleTemplate;
+            _sliderTemplate = sliderTemplate;
+            _textInputTemplate = textInputTemplate;
+            _numberInputTemplate = numberInputTemplate;
+
+            var layoutGroup = menu.GetComponentsInChildren<VerticalLayoutGroup>().Single(x => x.name == "Content");
+            Initialize(menu, layoutGroup);
+
+            var blocker = menu.GetComponentsInChildren<GraphicRaycaster>().Single(x => x.name == "RebindingModeBlocker");
+            blocker.gameObject.SetActive(false);
+
+            var labelPanel = menu.GetValue<GameObject>("_selectableItemsRoot").GetComponentInChildren<HorizontalLayoutGroup>();
+            labelPanel.gameObject.SetActive(false);
+
+            Title = ModData.Manifest.Name;
+
+            var saveButton = GetButton("UIElement-SaveAndExit");
+            var resetButton = GetButton("UIElement-ResetToDefaultsButton");
+            var cancelButton = GetButton("UIElement-DiscardChangesButton");
+
+            saveButton.OnClick += OnSave;
+            resetButton.OnClick += OnReset;
+            cancelButton.OnClick += Close;
+
+            saveButton.SetControllerCommand(InputLibrary.confirm);
+            resetButton.SetControllerCommand(InputLibrary.setDefaults);
+            cancelButton.SetControllerCommand(InputLibrary.cancel);
+
+            GetButton("UIElement-CancelOutOfRebinding").Hide();
+            GetButton("UIElement-KeyRebinder").Hide();
+
+            AddInputs();
+        }
+
+        public override void Open()
+        {
+            base.Open();
+            UpdateUIValues();
+        }
+
+        private void AddInputs()
+        {
+            var index = 2;
+            AddConfigInput("Enabled", ModData.Config.Enabled, index++);
+            AddConfigInput("Requires VR", ModData.Config.RequireVR, index++);
+            foreach (var setting in ModData.Config.Settings)
+            {
+                AddConfigInput(setting.Key, setting.Value, index++);
+            }
+            SelectFirst();
+            UpdateNavigation();
+        }
+
+        private void UpdateUIValues()
+        {
+            GetToggleInput("Enabled").Value = ModData.Config.Enabled;
+            GetToggleInput("Requires VR").Value = ModData.Config.RequireVR;
+            foreach (var setting in ModData.Config.Settings)
+            {
+                SetInputValue(setting.Key, setting.Value);
+            }
+        }
+
+        private void AddConfigInput(string key, object value, int index)
+        {
+            if (value is bool)
+            {
+                AddToggleInput(key, index);
+                return;
+            }
+
+            if (value is string)
+            {
+                AddTextInput(key, index);
+                return;
+            }
+
+            if (new[] { typeof(long), typeof(int), typeof(float), typeof(double) }.Contains(value.GetType()))
+            {
+                AddNumberInput(key, index);
+                return;
+            }
+
+            if (value is JObject obj)
+            {
+                var type = (string)obj["type"];
+                if (type == "slider")
+                {
+                    AddSliderInput(key, obj, index);
+                    return;
+                }
+                if (type == "toggle")
+                {
+                    AddToggleInput(key, obj, index);
+                    return;
+                }
+
+                _console.WriteLine("Error: unrecognized complex setting: " + value);
+                return;
+            }
+
+            _console.WriteLine("Error: unrecognized setting type: " + value.GetType());
+        }
+
+        private void AddToggleInput(string key, int index)
+        {
+            var toggle = AddToggleInput(_toggleTemplate.Copy(key), index);
+            toggle.YesButton.Title = "Yes";
+            toggle.NoButton.Title = "No";
+            toggle.Element.name = key;
+            toggle.Title = key;
+            toggle.Show();
+        }
+
+        private void AddToggleInput(string key, JObject obj, int index)
+        {
+            var toggle = AddToggleInput(_toggleTemplate.Copy(key), index);
+            toggle.YesButton.Title = (string)obj["yes"];
+            toggle.NoButton.Title = (string)obj["no"];
+            toggle.Element.name = key;
+            toggle.Title = (string)obj["title"] ?? key;
+            toggle.Show();
+        }
+
+        private void AddSliderInput(string key, JObject obj, int index)
+        {
+            var slider = AddSliderInput(_sliderTemplate.Copy(key), index);
+            slider.Min = (float)obj["min"];
+            slider.Max = (float)obj["max"];
+            slider.Element.name = key;
+            slider.Title = (string)obj["title"] ?? key;
+            slider.Show();
+        }
+
+        private void AddTextInput(string key, int index)
+        {
+            var textInput = AddTextInput(_textInputTemplate.Copy(key), index);
+            textInput.Element.name = key;
+            textInput.Show();
+        }
+
+        private void AddNumberInput(string key, int index)
+        {
+            var numberInput = AddNumberInput(_numberInputTemplate.Copy(key), index);
+            numberInput.Element.name = key;
+            numberInput.Show();
+        }
+
+        private void OnSave()
+        {
+            ModData.Config.Enabled = (bool)GetInputValue("Enabled");
+            ModData.Config.RequireVR = (bool)GetInputValue("Requires VR");
+            var keys = ModData.Config.Settings.Select(x => x.Key).ToList();
+            foreach (var key in keys)
+            {
+                var value = GetInputValue(key);
+                ModData.Config.SetSettingsValue(key, value);
+            }
+            _storage.Save(ModData.Config, "config.json");
+            if (Mod != null)
+            {
+                Mod.Configure(ModData.Config);
+            }
+            Close();
+        }
+
+        private void OnReset()
+        {
+            ModData.ResetConfig();
+            UpdateUIValues();
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModInput.cs b/OWML.ModHelper.Menus/ModInput.cs
new file mode 100644
index 00000000..689bd98b
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModInput.cs
@@ -0,0 +1,62 @@
+using System;
+using OWML.Common.Menus;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public abstract class ModInput<T> : IModInput<T>
+    {
+        public event Action<T> OnChange;
+        public abstract T Value { get; set; }
+        public MonoBehaviour Element { get; }
+
+        private int _index;
+        public int Index
+        {
+            get => Element.transform.parent == null ? _index : Element.transform.GetSiblingIndex();
+            set
+            {
+                _index = value;
+                Element.transform.SetSiblingIndex(value);
+            }
+        }
+
+        private readonly Text _text;
+        public string Title
+        {
+            get => _text.text;
+            set => _text.text = value;
+        }
+
+        protected IModMenu Menu;
+
+        protected ModInput(MonoBehaviour element, IModMenu menu)
+        {
+            Element = element;
+            Menu = menu;
+            _text = element.GetComponentInChildren<Text>();
+        }
+
+        protected void InvokeOnChange(T value)
+        {
+            OnChange?.Invoke(value);
+        }
+
+        public void Show()
+        {
+            Element.gameObject.SetActive(true);
+        }
+
+        public void Hide()
+        {
+            Element.gameObject.SetActive(false);
+        }
+
+        public virtual void Initialize(IModMenu menu)
+        {
+            Menu = menu;
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModInputField.cs b/OWML.ModHelper.Menus/ModInputField.cs
new file mode 100644
index 00000000..de015c5c
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModInputField.cs
@@ -0,0 +1,35 @@
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public abstract class ModInputField<T> : ModInput<T>
+    {
+        public IModButton Button { get; }
+
+        protected readonly IModInputMenu InputMenu;
+        protected readonly TwoButtonToggleElement ToggleElement;
+
+        public ModInputField(TwoButtonToggleElement toggle, IModMenu menu, IModInputMenu inputMenu) : base(toggle, menu)
+        {
+            ToggleElement = toggle;
+            InputMenu = inputMenu;
+
+            Button = new ModButton(toggle.GetValue<Button>("_buttonTrue"), menu);
+            Button.OnClick += Open;
+
+            var noButton = ToggleElement.GetValue<Button>("_buttonFalse");
+            noButton.transform.parent.gameObject.SetActive(false);
+
+            var layoutGroup = Button.Button.transform.parent.parent.GetComponent<HorizontalLayoutGroup>();
+            layoutGroup.childControlWidth = true;
+            layoutGroup.childForceExpandWidth = true;
+
+            Button.Button.transform.parent.GetComponent<LayoutElement>().preferredWidth = 100;
+        }
+
+        protected abstract void Open();
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModInputMenu.cs b/OWML.ModHelper.Menus/ModInputMenu.cs
new file mode 100644
index 00000000..08878dc2
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModInputMenu.cs
@@ -0,0 +1,94 @@
+using System;
+using OWML.Common;
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModInputMenu : ModMenu, IModInputMenu
+    {
+        public event Action<string> OnConfirm;
+        public event Action OnCancel;
+
+        private PopupInputMenu _inputMenu;
+
+        private IModLogger _logger;
+        private IModConsole _console;
+
+        public ModInputMenu(IModLogger logger, IModConsole console) : base(logger, console)
+        {
+            _logger = logger;
+            _console = console;
+        }
+
+        public void Initialize(PopupInputMenu menu)
+        {
+            if (Menu != null)
+            {
+                return;
+            }
+            var parent = menu.transform.parent.gameObject;
+            var parentCopy = GameObject.Instantiate(parent);
+            parentCopy.AddComponent<DontDestroyOnLoad>();
+            _inputMenu = parentCopy.transform.GetComponentInChildren<PopupInputMenu>(true);
+            GameObject.Destroy(_inputMenu.GetValue<Text>("_labelText").GetComponent<LocalizedText>());
+            Initialize((Menu)_inputMenu);
+        }
+
+        public void Open(InputType inputType, string value)
+        {
+            _inputMenu.OnPopupConfirm += OnPopupConfirm;
+            _inputMenu.OnPopupCancel += OnPopupCancel;
+
+            if (inputType == InputType.Number)
+            {
+                _inputMenu.OnInputPopupValidateChar += OnValidateCharNumber;
+                _inputMenu.OnPopupValidate += OnValidateNumber;
+            }
+            var message = inputType == InputType.Number ? "Write a number" : "Write some text";
+
+            _inputMenu.EnableMenu(true);
+
+            var okPrompt = new ScreenPrompt(InputLibrary.confirm2, "OK");
+            var cancelCommand = OWInput.UsingGamepad() ? InputLibrary.cancel : InputLibrary.escape;
+            var cancelPrompt = new ScreenPrompt(cancelCommand, "Cancel");
+            _inputMenu.SetUpPopup(message, InputLibrary.confirm2, cancelCommand, okPrompt, cancelPrompt, true, true);
+            _inputMenu.SetInputFieldPlaceholderText("");
+            _inputMenu.GetInputField().text = value;
+            _inputMenu.GetValue<Text>("_labelText").text = message;
+        }
+
+        private bool OnValidateNumber()
+        {
+            return float.TryParse(_inputMenu.GetInputText(), out _);
+        }
+
+        private bool OnValidateCharNumber(char c)
+        {
+            return "0123456789.".Contains("" + c);
+        }
+
+        private void OnPopupConfirm()
+        {
+            UnregisterEvents();
+            OnConfirm?.Invoke(_inputMenu.GetInputText());
+        }
+
+        private void OnPopupCancel()
+        {
+            UnregisterEvents();
+            OnCancel?.Invoke();
+        }
+
+        private void UnregisterEvents()
+        {
+            _inputMenu.OnPopupValidate -= OnValidateNumber;
+            _inputMenu.OnInputPopupValidateChar -= OnValidateCharNumber;
+            _inputMenu.OnPopupConfirm -= OnPopupConfirm;
+            _inputMenu.OnPopupCancel -= OnPopupCancel;
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModMainMenu.cs b/OWML.ModHelper.Menus/ModMainMenu.cs
index b3522258..c6791543 100644
--- a/OWML.ModHelper.Menus/ModMainMenu.cs
+++ b/OWML.ModHelper.Menus/ModMainMenu.cs
@@ -47,14 +47,15 @@ public void Initialize(TitleScreenManager titleScreenManager)
             InvokeOnInit();
         }
 
-        public override void AddButton(IModButton button, int index)
+        public override IModButton AddButton(IModButton button, int index)
         {
-            base.AddButton(button, index);
+            var modButton = base.AddButton(button, index);
             var fadeControllers = Buttons.OrderBy(x => x.Index).Select(x => new CanvasGroupFadeController
             {
                 group = x.Button.GetComponent<CanvasGroup>()
             });
             _anim.SetValue("_buttonFadeControllers", fadeControllers.ToArray());
+            return modButton;
         }
 
     }
diff --git a/OWML.ModHelper.Menus/ModMenu.cs b/OWML.ModHelper.Menus/ModMenu.cs
index 0aad876b..078a3d29 100644
--- a/OWML.ModHelper.Menus/ModMenu.cs
+++ b/OWML.ModHelper.Menus/ModMenu.cs
@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Newtonsoft.Json.Linq;
 using OWML.Common;
 using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+using UnityEngine;
 using UnityEngine.UI;
 
 namespace OWML.ModHelper.Menus
@@ -11,8 +14,12 @@ public class ModMenu : IModMenu
     {
         public event Action OnInit;
 
-        public Menu Menu { get; private set; }
+        public Menu Menu { get; protected set; }
         public List<IModButton> Buttons { get; private set; }
+        public List<IModToggleInput> ToggleInputs { get; private set; }
+        public List<IModSliderInput> SliderInputs { get; private set; }
+        public List<IModTextInput> TextInputs { get; private set; }
+        public List<IModNumberInput> NumberInputs { get; private set; }
 
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
@@ -25,11 +32,31 @@ public ModMenu(IModLogger logger, IModConsole console)
         }
 
         public virtual void Initialize(Menu menu)
+        {
+            var root = menu.GetValue<GameObject>("_selectableItemsRoot") ?? menu.GetValue<GameObject>("_menuActivationRoot");
+            var layoutGroup = root.GetComponent<LayoutGroup>() ?? root.GetComponentInChildren<LayoutGroup>();
+            Initialize(menu, layoutGroup);
+        }
+
+        public virtual void Initialize(Menu menu, LayoutGroup layoutGroup)
         {
             Menu = menu;
-            _layoutGroup = Menu.GetComponent<LayoutGroup>() ?? Menu.GetComponentInChildren<LayoutGroup>();
-            Buttons = new List<IModButton>();
-            Buttons.AddRange(Menu.GetComponentsInChildren<Button>().Select(x => new ModButton(x, this)).Cast<IModButton>());
+            _layoutGroup = layoutGroup;
+            Buttons = Menu.GetComponentsInChildren<Button>().Select(x => new ModButton(x, this)).Cast<IModButton>().ToList();
+            ToggleInputs = Menu.GetComponentsInChildren<TwoButtonToggleElement>().Select(x => new ModToggleInput(x, this)).Cast<IModToggleInput>().ToList();
+            SliderInputs = Menu.GetComponentsInChildren<SliderElement>().Select(x => new ModSliderInput(x, this)).Cast<IModSliderInput>().ToList();
+            TextInputs = new List<IModTextInput>();
+            NumberInputs = new List<IModNumberInput>();
+        }
+
+        public IModButton GetButton(string title)
+        {
+            var button = Buttons.FirstOrDefault(x => x.Title == title || x.Button.name == title);
+            if (button == null)
+            {
+                _console.WriteLine("Warning: no button found with title or name: " + title);
+            }
+            return button;
         }
 
         [Obsolete("Use Buttons instead")]
@@ -56,27 +83,152 @@ public Button AddButton(string title, int index)
             return copy.Button;
         }
 
-        public void AddButton(IModButton button)
+        public IModButton AddButton(IModButton button)
         {
-            AddButton(button, button.Index);
+            return AddButton(button, button.Index);
         }
 
-        public virtual void AddButton(IModButton button, int index)
+        public virtual IModButton AddButton(IModButton button, int index)
         {
             button.Button.transform.parent = _layoutGroup.transform;
             button.Index = index;
             button.Initialize(this);
             Buttons.Add(button);
+            return button;
         }
 
-        public IModButton GetButton(string title)
+        public IModToggleInput GetToggleInput(string title)
         {
-            var button = Buttons.FirstOrDefault(x => x.Title == title || x.Button.name == title);
-            if (button == null)
+            return ToggleInputs.FirstOrDefault(x => x.Title == title || x.Element.name == title);
+        }
+
+        public IModToggleInput AddToggleInput(IModToggleInput input)
+        {
+            return AddToggleInput(input, input.Index);
+        }
+
+        public IModToggleInput AddToggleInput(IModToggleInput input, int index)
+        {
+            ToggleInputs.Add(input);
+            AddInput(input, index);
+            return input;
+        }
+
+        public IModSliderInput GetSliderInput(string title)
+        {
+            return SliderInputs.FirstOrDefault(x => x.Title == title || x.Element.name == title);
+        }
+
+        public IModSliderInput AddSliderInput(IModSliderInput input)
+        {
+            return AddSliderInput(input, input.Index);
+        }
+
+        public IModSliderInput AddSliderInput(IModSliderInput input, int index)
+        {
+            SliderInputs.Add(input);
+            AddInput(input, index);
+            return input;
+        }
+
+        public IModTextInput GetTextInput(string title)
+        {
+            return TextInputs.FirstOrDefault(x => x.Title == title || x.Element.name == title);
+        }
+
+        public IModTextInput AddTextInput(IModTextInput input)
+        {
+            return AddTextInput(input, input.Index);
+        }
+
+        public IModTextInput AddTextInput(IModTextInput input, int index)
+        {
+            TextInputs.Add(input);
+            AddInput(input, index);
+            return input;
+        }
+
+        public IModNumberInput GetNumberInput(string title)
+        {
+            return NumberInputs.FirstOrDefault(x => x.Title == title || x.Element.name == title);
+        }
+
+        public IModNumberInput AddNumberInput(IModNumberInput input)
+        {
+            return AddNumberInput(input, input.Index);
+        }
+
+        public IModNumberInput AddNumberInput(IModNumberInput input, int index)
+        {
+            NumberInputs.Add(input);
+            AddInput(input, index);
+            return input;
+        }
+
+        private void AddInput<T>(IModInput<T> input, int index)
+        {
+            input.Element.transform.parent = _layoutGroup.transform;
+            input.Index = index;
+            input.Initialize(this);
+        }
+
+        public object GetInputValue(string key)
+        {
+            var slider = GetSliderInput(key);
+            if (slider != null)
             {
-                _console.WriteLine("Warning: no button found with title or name: " + title);
+                return slider.Value;
             }
-            return button;
+            var toggle = GetToggleInput(key);
+            if (toggle != null)
+            {
+                return toggle.Value;
+            }
+            var textInput = GetTextInput(key);
+            if (textInput != null)
+            {
+                return textInput.Value;
+            }
+            var numberInput = GetNumberInput(key);
+            if (numberInput != null)
+            {
+                return numberInput.Value;
+            }
+            _console.WriteLine("Error: no input found with name " + key);
+            return null;
+        }
+
+        public void SetInputValue(string key, object value)
+        {
+            var slider = GetSliderInput(key);
+            if (slider != null)
+            {
+                var val = value is JObject obj ? obj["value"] : value;
+                slider.Value = Convert.ToSingle(val);
+                return;
+            }
+            var toggle = GetToggleInput(key);
+            if (toggle != null)
+            {
+                var val = value is JObject obj ? obj["value"] : value;
+                toggle.Value = Convert.ToBoolean(val);
+                return;
+            }
+            var textInput = GetTextInput(key);
+            if (textInput != null)
+            {
+                var val = value is JObject obj ? obj["value"] : value;
+                textInput.Value = Convert.ToString(val);
+                return;
+            }
+            var numberInput = GetNumberInput(key);
+            if (numberInput != null)
+            {
+                var val = value is JObject obj ? obj["value"] : value;
+                numberInput.Value = Convert.ToSingle(val);
+                return;
+            }
+            _console.WriteLine("Error: no input found with name " + key);
         }
 
         protected void InvokeOnInit()
@@ -84,5 +236,28 @@ protected void InvokeOnInit()
             OnInit?.Invoke();
         }
 
+        public void SelectFirst()
+        {
+            var firstSelectable = Menu.GetComponentInChildren<Selectable>();
+            Locator.GetMenuInputModule().SelectOnNextUpdate(firstSelectable);
+            Menu.SetSelectOnActivate(firstSelectable);
+        }
+
+        public void UpdateNavigation()
+        {
+            var selectables = Menu.GetComponentsInChildren<TooltipSelectable>()
+                .Select(x => x.GetComponent<Selectable>())
+                .Where(x => x != null).ToList();
+            for (var i = 0; i < selectables.Count; i++)
+            {
+                var upIndex = (i - 1 + selectables.Count) % selectables.Count;
+                var downIndex = (i + 1) % selectables.Count;
+                var navigation = selectables[i].navigation;
+                navigation.selectOnUp = selectables[upIndex];
+                navigation.selectOnDown = selectables[downIndex];
+                selectables[i].navigation = navigation;
+            }
+        }
+
     }
 }
diff --git a/OWML.ModHelper.Menus/ModMenus.cs b/OWML.ModHelper.Menus/ModMenus.cs
index 2b5749c2..b0e7deb8 100644
--- a/OWML.ModHelper.Menus/ModMenus.cs
+++ b/OWML.ModHelper.Menus/ModMenus.cs
@@ -1,5 +1,6 @@
 using OWML.Common;
 using OWML.Common.Menus;
+using OWML.ModHelper.Events;
 using UnityEngine;
 
 namespace OWML.ModHelper.Menus
@@ -8,6 +9,8 @@ public class ModMenus : IModMenus
     {
         public IModMainMenu MainMenu { get; }
         public IModPauseMenu PauseMenu { get; }
+        public IModsMenu ModsMenu { get; }
+        public IModInputMenu InputMenu { get; }
 
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
@@ -18,13 +21,12 @@ public ModMenus(IModLogger logger, IModConsole console, IModEvents events)
             _console = console;
 
             MainMenu = new ModMainMenu(logger, console);
-            var titleScreenManager = GameObject.FindObjectOfType<TitleScreenManager>();
-            MainMenu.Initialize(titleScreenManager);
-
             PauseMenu = new ModPauseMenu(logger, console);
+            ModsMenu = new ModsMenu(logger, console, this);
+            InputMenu = new ModInputMenu(logger, console);
 
             events.Subscribe<SettingsManager>(Common.Events.AfterStart);
-            events.Subscribe<TitleScreenManager>(Common.Events.AfterAwake);
+            events.Subscribe<TitleScreenManager>(Common.Events.AfterStart);
             events.OnEvent += OnEvent;
         }
 
@@ -34,11 +36,15 @@ private void OnEvent(MonoBehaviour behaviour, Common.Events ev)
             {
                 var settingsManager = (SettingsManager)behaviour;
                 PauseMenu.Initialize(settingsManager);
+                ModsMenu.Initialize(PauseMenu);
             }
-            else if (behaviour.GetType() == typeof(TitleScreenManager) && ev == Common.Events.AfterAwake)
+            else if (behaviour.GetType() == typeof(TitleScreenManager) && ev == Common.Events.AfterStart)
             {
                 var titleScreenManager = (TitleScreenManager)behaviour;
                 MainMenu.Initialize(titleScreenManager);
+                var inputMenu = titleScreenManager.GetComponent<ProfileMenuManager>().GetValue<PopupInputMenu>("_createProfileConfirmPopup");
+                InputMenu.Initialize(inputMenu);
+                ModsMenu.Initialize(MainMenu);
             }
         }
 
diff --git a/OWML.ModHelper.Menus/ModNumberInput.cs b/OWML.ModHelper.Menus/ModNumberInput.cs
new file mode 100644
index 00000000..654d4f10
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModNumberInput.cs
@@ -0,0 +1,60 @@
+using OWML.Common.Menus;
+using System;
+using UnityEngine;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModNumberInput : ModInputField<float>, IModNumberInput
+    {
+        private float _value;
+
+        public ModNumberInput(TwoButtonToggleElement element, IModMenu menu, IModInputMenu inputMenu) : base(element, menu, inputMenu)
+        {
+        }
+
+        protected override void Open()
+        {
+            InputMenu.OnConfirm += OnConfirm;
+            InputMenu.OnCancel += OnCancel;
+            InputMenu.Open(InputType.Number, Value.ToString());
+        }
+
+        private void OnConfirm(string text)
+        {
+            OnCancel();
+            Value = Convert.ToSingle(text);
+        }
+
+        private void OnCancel()
+        {
+            InputMenu.OnConfirm -= OnConfirm;
+            InputMenu.OnCancel -= OnCancel;
+        }
+
+        public override float Value
+        {
+            get => _value;
+            set
+            {
+                _value = value;
+                Button.Title = value.ToString();
+                InvokeOnChange(value);
+            }
+        }
+
+        public IModNumberInput Copy()
+        {
+            var copy = GameObject.Instantiate(ToggleElement);
+            GameObject.Destroy(copy.GetComponentInChildren<LocalizedText>());
+            return new ModNumberInput(copy, Menu, InputMenu);
+        }
+
+        public IModNumberInput Copy(string title)
+        {
+            var copy = Copy();
+            copy.Title = title;
+            return copy;
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModOptionsMenu.cs b/OWML.ModHelper.Menus/ModOptionsMenu.cs
index 2de7c18f..04984baa 100644
--- a/OWML.ModHelper.Menus/ModOptionsMenu.cs
+++ b/OWML.ModHelper.Menus/ModOptionsMenu.cs
@@ -1,32 +1,30 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using OWML.Common;
 using OWML.Common.Menus;
 using OWML.ModHelper.Events;
+using UnityEngine.UI;
 
 namespace OWML.ModHelper.Menus
 {
     public class ModOptionsMenu : ModPopupMenu, IModTabbedMenu
     {
-        public IModTabMenu GameplayTab { get; }
-        public IModTabMenu AudioTab { get; }
-        public IModTabMenu InputTab { get; }
-        public IModTabMenu GraphicsTab { get; }
+        public IModTabMenu GameplayTab { get; private set; }
+        public IModTabMenu AudioTab { get; private set; }
+        public IModTabMenu InputTab { get; private set; }
+        public IModTabMenu GraphicsTab { get; private set; }
 
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
 
         public new TabbedMenu Menu { get; private set; }
 
-        private TabButton[] _tabButtons;
+        private List<IModTabMenu> _tabMenus;
 
         public ModOptionsMenu(IModLogger logger, IModConsole console) : base(logger, console)
         {
             _logger = logger;
             _console = console;
-            GameplayTab = new ModTabMenu(logger, console, this);
-            AudioTab = new ModTabMenu(logger, console, this);
-            InputTab = new ModTabMenu(logger, console, this);
-            GraphicsTab = new ModTabMenu(logger, console, this);
         }
 
         public void Initialize(TabbedMenu menu)
@@ -34,24 +32,46 @@ public void Initialize(TabbedMenu menu)
             base.Initialize(menu);
             Menu = menu;
 
-            _tabButtons = menu.GetValue<TabButton[]>("_menuTabs");
-            GameplayTab.Initialize(GetTabButton("Button-GamePlay"));
-            AudioTab.Initialize(GetTabButton("Button-Audio"));
-            InputTab.Initialize(GetTabButton("Button-Input"));
-            GraphicsTab.Initialize(GetTabButton("Button-Graphics"));
+            var tabButtons = Menu.GetValue<TabButton[]>("_menuTabs");
+            _tabMenus = new List<IModTabMenu>();
+            foreach (var tabButton in tabButtons)
+            {
+                var tabMenu = new ModTabMenu(_logger, _console, this);
+                tabMenu.Initialize(tabButton);
+                _tabMenus.Add(tabMenu);
+            }
+
+            GameplayTab = _tabMenus.Single(x => x.TabButton.name == "Button-GamePlay");
+            AudioTab = _tabMenus.Single(x => x.TabButton.name == "Button-Audio");
+            InputTab = _tabMenus.Single(x => x.TabButton.name == "Button-Input");
+            GraphicsTab = _tabMenus.Single(x => x.TabButton.name == "Button-Graphics");
 
             InvokeOnInit();
         }
 
-        public TabButton GetTabButton(string name)
+        public void AddTab(IModTabMenu tabMenu)
+        {
+            _tabMenus.Add(tabMenu);
+            var tabs = _tabMenus.Select(x => x.TabButton).ToArray();
+            Menu.SetValue("_menuTabs", tabs);
+            var parent = tabs[0].transform.parent;
+            tabMenu.TabButton.transform.parent = parent;
+            UpdateTabNavigation();
+        }
+
+        private void UpdateTabNavigation()
         {
-            var tabButton = _tabButtons.FirstOrDefault(x => x.name == name);
-            if (tabButton == null)
+            for (var i = 0; i < _tabMenus.Count; i++)
             {
-                _console.WriteLine("Error: could not find tab for " + name);
-                return null;
+                var leftIndex = (i - 1 + _tabMenus.Count) % _tabMenus.Count;
+                var rightIndex = (i + 1) % _tabMenus.Count;
+                _tabMenus[i].TabButton.GetComponent<Button>().navigation = new Navigation
+                {
+                    selectOnLeft = _tabMenus[leftIndex].TabButton.GetComponent<Button>(),
+                    selectOnRight = _tabMenus[rightIndex].TabButton.GetComponent<Button>(),
+                    mode = Navigation.Mode.Explicit
+                };
             }
-            return tabButton;
         }
 
         public new IModTabbedMenu Copy()
diff --git a/OWML.ModHelper.Menus/ModPopupMenu.cs b/OWML.ModHelper.Menus/ModPopupMenu.cs
index ac0e5102..6536cf0e 100644
--- a/OWML.ModHelper.Menus/ModPopupMenu.cs
+++ b/OWML.ModHelper.Menus/ModPopupMenu.cs
@@ -30,9 +30,9 @@ public ModPopupMenu(IModLogger logger, IModConsole console) : base(logger, conso
             _console = console;
         }
 
-        public override void Initialize(Menu menu)
+        public override void Initialize(Menu menu, LayoutGroup layoutGroup)
         {
-            base.Initialize(menu);
+            base.Initialize(menu, layoutGroup);
             _title = Menu.GetComponentInChildren<Text>();
             var localizedText = _title.GetComponent<LocalizedText>();
             if (localizedText != null)
@@ -63,6 +63,7 @@ public virtual void Open()
                 _console.WriteLine("Warning: can't open menu, it doesn't exist.");
                 return;
             }
+            SelectFirst();
             Menu.EnableMenu(true);
         }
 
@@ -73,7 +74,7 @@ public void Close()
                 _console.WriteLine("Warning: can't close menu, it doesn't exist.");
                 return;
             }
-            Menu.Deactivate();
+            Menu.EnableMenu(false);
         }
 
         public void Toggle()
diff --git a/OWML.ModHelper.Menus/ModSliderInput.cs b/OWML.ModHelper.Menus/ModSliderInput.cs
new file mode 100644
index 00000000..dbbcba9c
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModSliderInput.cs
@@ -0,0 +1,51 @@
+using OWML.Common.Menus;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModSliderInput : ModInput<float>, IModSliderInput
+    {
+        public float Min { get; set; }
+        public float Max { get; set; }
+
+        private readonly SliderElement _element;
+
+        public ModSliderInput(SliderElement element, IModMenu menu) : base(element, menu)
+        {
+            _element = element;
+            element.OnValueChanged += () => InvokeOnChange(Value);
+        }
+
+        public override float Value
+        {
+            get => ToRealNumber(_element.GetValue());
+            set => _element.Initialize((int)ToFakeNumber(value));
+        }
+
+        public IModSliderInput Copy()
+        {
+            var copy = GameObject.Instantiate(_element);
+            GameObject.Destroy(copy.GetComponentInChildren<LocalizedText>());
+            return new ModSliderInput(copy, Menu);
+        }
+
+        public IModSliderInput Copy(string title)
+        {
+            var copy = Copy();
+            copy.Title = title;
+            return copy;
+        }
+
+        private float ToRealNumber(float fakeNumber)
+        {
+            return fakeNumber * (Max - Min) / 10;
+        }
+
+        private float ToFakeNumber(float realNumber)
+        {
+            return realNumber * 10 / (Max - Min);
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModTabMenu.cs b/OWML.ModHelper.Menus/ModTabMenu.cs
index e4c06338..bf60f78e 100644
--- a/OWML.ModHelper.Menus/ModTabMenu.cs
+++ b/OWML.ModHelper.Menus/ModTabMenu.cs
@@ -1,6 +1,8 @@
 using OWML.Common;
 using OWML.Common.Menus;
 using OWML.ModHelper.Events;
+using UnityEngine;
+using UnityEngine.UI;
 
 namespace OWML.ModHelper.Menus
 {
@@ -10,7 +12,14 @@ public class ModTabMenu : ModPopupMenu, IModTabMenu
         private readonly IModConsole _console;
         private readonly IModTabbedMenu _optionsMenu;
 
-        private TabButton _tabButton;
+        public TabButton TabButton { get; private set; }
+
+        private Text _text;
+        public new string Title
+        {
+            get => _text.text;
+            set => _text.text = value;
+        }
 
         public ModTabMenu(IModLogger logger, IModConsole console, IModTabbedMenu optionsMenu) : base(logger, console)
         {
@@ -21,7 +30,8 @@ public ModTabMenu(IModLogger logger, IModConsole console, IModTabbedMenu options
 
         public void Initialize(TabButton tabButton)
         {
-            _tabButton = tabButton;
+            TabButton = tabButton;
+            TabButton.OnTabSelect += t => SelectFirst();
             var menu = tabButton.GetValue<Menu>("_tabbedMenu");
             Initialize(menu);
             InvokeOnInit();
@@ -33,7 +43,26 @@ public override void Open()
             {
                 _optionsMenu.Open();
             }
-            _optionsMenu.Menu.Invoke("SelectTabButton", _tabButton);
+            _optionsMenu.Menu.Invoke("SelectTabButton", TabButton);
+        }
+
+        public new IModTabMenu Copy()
+        {
+            var tabButton = GameObject.Instantiate(TabButton, TabButton.transform.parent);
+            GameObject.Destroy(tabButton.GetComponentInChildren<LocalizedText>());
+            _text = tabButton.GetComponentInChildren<Text>();
+            var menu = GameObject.Instantiate(Menu, Menu.transform.parent);
+            tabButton.SetValue("_tabbedMenu", menu);
+            var modMenu = new ModTabMenu(_logger, _console, _optionsMenu);
+            modMenu.Initialize(tabButton);
+            return modMenu;
+        }
+
+        public new IModTabMenu Copy(string title)
+        {
+            var copy = Copy();
+            Title = title;
+            return copy;
         }
 
     }
diff --git a/OWML.ModHelper.Menus/ModTextInput.cs b/OWML.ModHelper.Menus/ModTextInput.cs
new file mode 100644
index 00000000..ae81a5d6
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModTextInput.cs
@@ -0,0 +1,59 @@
+using OWML.Common.Menus;
+using UnityEngine;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModTextInput : ModInputField<string>, IModTextInput
+    {
+        private string _value;
+
+        public ModTextInput(TwoButtonToggleElement element, IModMenu menu, IModInputMenu inputMenu) : base(element, menu, inputMenu)
+        {
+        }
+
+        protected override void Open()
+        {
+            InputMenu.OnConfirm += OnConfirm;
+            InputMenu.OnCancel += OnCancel;
+            InputMenu.Open(InputType.Text, Value);
+        }
+
+        private void OnConfirm(string text)
+        {
+            OnCancel();
+            Value = text;
+        }
+
+        private void OnCancel()
+        {
+            InputMenu.OnConfirm -= OnConfirm;
+            InputMenu.OnCancel -= OnCancel;
+        }
+
+        public override string Value
+        {
+            get => _value;
+            set
+            {
+                _value = value;
+                Button.Title = value;
+                InvokeOnChange(value);
+            }
+        }
+
+        public IModTextInput Copy()
+        {
+            var copy = GameObject.Instantiate(ToggleElement);
+            GameObject.Destroy(copy.GetComponentInChildren<LocalizedText>());
+            return new ModTextInput(copy, Menu, InputMenu);
+        }
+
+        public IModTextInput Copy(string title)
+        {
+            var copy = Copy();
+            copy.Title = title;
+            return copy;
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModToggleInput.cs b/OWML.ModHelper.Menus/ModToggleInput.cs
new file mode 100644
index 00000000..abfeb896
--- /dev/null
+++ b/OWML.ModHelper.Menus/ModToggleInput.cs
@@ -0,0 +1,49 @@
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper.Menus
+{
+    public class ModToggleInput : ModInput<bool>, IModToggleInput
+    {
+        public IModButton YesButton { get; }
+        public IModButton NoButton { get; }
+
+        public TwoButtonToggleElement Toggle { get; }
+
+        public ModToggleInput(TwoButtonToggleElement toggle, IModMenu menu) : base(toggle, menu)
+        {
+            Toggle = toggle;
+            YesButton = new ModButton(Toggle.GetValue<Button>("_buttonTrue"), menu);
+            YesButton.OnClick += () => InvokeOnChange(true);
+            NoButton = new ModButton(Toggle.GetValue<Button>("_buttonFalse"), menu);
+            NoButton.OnClick += () => InvokeOnChange(false);
+        }
+
+        public override bool Value
+        {
+            get => Toggle.GetValue();
+            set
+            {
+                Toggle.Initialize(value);
+                InvokeOnChange(value);
+            }
+        }
+
+        public IModToggleInput Copy()
+        {
+            var copy = GameObject.Instantiate(Toggle);
+            GameObject.Destroy(copy.GetComponentInChildren<LocalizedText>());
+            return new ModToggleInput(copy, Menu);
+        }
+
+        public IModToggleInput Copy(string title)
+        {
+            var copy = Copy();
+            copy.Title = title;
+            return copy;
+        }
+
+    }
+}
diff --git a/OWML.ModHelper.Menus/ModsMenu.cs b/OWML.ModHelper.Menus/ModsMenu.cs
index a01e222f..0d6f58c1 100644
--- a/OWML.ModHelper.Menus/ModsMenu.cs
+++ b/OWML.ModHelper.Menus/ModsMenu.cs
@@ -1,40 +1,112 @@
 using System.Collections.Generic;
+using System.Linq;
 using OWML.Common;
+using OWML.Common.Menus;
+using OWML.ModHelper.Events;
+using UnityEngine;
 using UnityEngine.UI;
 
 namespace OWML.ModHelper.Menus
 {
-    public class ModsMenu : ModPopupMenu
+    public class ModsMenu : ModPopupMenu, IModsMenu
     {
         private readonly IModLogger _logger;
         private readonly IModConsole _console;
-        private readonly List<IModBehaviour> _registeredMods;
+        private readonly IModMenus _menus;
+        private readonly List<IModConfigMenu> _modConfigMenus;
 
-        public ModsMenu(IModLogger logger, IModConsole console) : base(logger, console)
+        private Transform _modMenuTemplate;
+        private IModButton _modButtonTemplate;
+
+        public ModsMenu(IModLogger logger, IModConsole console, IModMenus menus) : base(logger, console)
         {
             _logger = logger;
             _console = console;
-            _registeredMods = new List<IModBehaviour>();
+            _menus = menus;
+            _modConfigMenus = new List<IModConfigMenu>();
         }
 
-        public void Register(IModBehaviour modBehaviour)
+        public void AddMod(IModData modData, IModBehaviour mod)
+        {
+            _modConfigMenus.Add(new ModConfigMenu(_logger, _console, modData, mod));
+        }
+
+        public IModConfigMenu GetModMenu(IModBehaviour modBehaviour)
         {
             _console.WriteLine("Registering " + modBehaviour.ModHelper.Manifest.UniqueName);
-            _registeredMods.Add(modBehaviour);
-            var button = AddButton(modBehaviour.ModHelper.Manifest.UniqueName, 0);
-            button.onClick.AddListener(() =>
+            var modConfigMenu = _modConfigMenus.FirstOrDefault(x => x.Mod == modBehaviour);
+            if (modConfigMenu == null)
             {
-                var config = ParseConfig(button);
-                modBehaviour.ModHelper.Storage.Save(config, "config.json");
-                modBehaviour.Configure(config);
-            });
+                _console.WriteLine($"Error: {modBehaviour.ModHelper.Manifest.UniqueName} isn't added.");
+                return null;
+            }
+            return modConfigMenu;
         }
 
-        private IModConfig ParseConfig(Button button)
+        public void Initialize(IModMainMenu mainMenu)
         {
-            _console.WriteLine("todo: implement ModsMenu.ParseConfig");
-            return new ModConfig();
+            if (_modMenuTemplate == null)
+            {
+                CreateModMenuTemplate(mainMenu);
+            }
+            var modsButton = mainMenu.OptionsButton.Duplicate("MODS");
+            var optionsMenu = mainMenu.OptionsMenu;
+            var modsMenu = CreateModsMenu(optionsMenu);
+            modsButton.OnClick += () => modsMenu.Open();
+            Menu = mainMenu.Menu;
         }
-        
+
+        public void Initialize(IModPauseMenu pauseMenu)
+        {
+            var modsButton = pauseMenu.OptionsButton.Duplicate("MODS");
+            var optionsMenu = pauseMenu.OptionsMenu;
+            var modsMenu = CreateModsMenu(optionsMenu);
+            modsButton.OnClick += () => modsMenu.Open();
+            Menu = pauseMenu.Menu;
+        }
+
+        private void CreateModMenuTemplate(IModMainMenu mainMenu)
+        {
+            var remapControlsButton = mainMenu.OptionsMenu.InputTab.GetButton("UIElement-RemapControls");
+            var buttonTemplate = GameObject.Instantiate(remapControlsButton.Button);
+            buttonTemplate.gameObject.AddComponent<DontDestroyOnLoad>();
+            _modButtonTemplate = new ModButton(buttonTemplate, mainMenu);
+            _modButtonTemplate.Button.enabled = false;
+
+            var submitActionMenu = remapControlsButton.Button.GetComponent<SubmitActionMenu>();
+            var rebindingMenu = submitActionMenu.GetValue<Menu>("_menuToOpen");
+            var rebindingCanvas = rebindingMenu.transform.parent;
+            _modMenuTemplate = GameObject.Instantiate(rebindingCanvas);
+            _modMenuTemplate.gameObject.AddComponent<DontDestroyOnLoad>();
+        }
+
+        private IModPopupMenu CreateModsMenu(IModTabbedMenu options)
+        {
+            var toggleTemplate = options.InputTab.ToggleInputs[0];
+            var sliderTemplate = options.InputTab.SliderInputs[0];
+            var modsTab = options.InputTab.Copy("MODS");
+            modsTab.Buttons.ForEach(x => x.Hide());
+            modsTab.Menu.GetComponentsInChildren<Selectable>().ToList().ForEach(x => x.gameObject.SetActive(false));
+            modsTab.Menu.GetValue<TooltipDisplay>("_tooltipDisplay").GetComponent<Text>().color = Color.clear;
+            options.AddTab(modsTab);
+            foreach (var modConfigMenu in _modConfigMenus)
+            {
+                var modButton = _modButtonTemplate.Copy(modConfigMenu.ModData.Manifest.Name);
+                modButton.Button.enabled = true;
+                var modMenuTemplate = _modMenuTemplate.GetComponentInChildren<Menu>(true);
+                var modMenuCopy = GameObject.Instantiate(modMenuTemplate, _modMenuTemplate.transform);
+                var textInputTemplate = new ModTextInput(toggleTemplate.Copy().Toggle, modConfigMenu, _menus.InputMenu);
+                textInputTemplate.Hide();
+                var numberInputTemplate = new ModNumberInput(toggleTemplate.Copy().Toggle, modConfigMenu, _menus.InputMenu);
+                numberInputTemplate.Hide();
+                modConfigMenu.Initialize(modMenuCopy, toggleTemplate, sliderTemplate, textInputTemplate, numberInputTemplate);
+                modButton.OnClick += () => modConfigMenu.Open();
+                modsTab.AddButton(modButton);
+            }
+            modsTab.UpdateNavigation();
+            modsTab.SelectFirst();
+            return modsTab;
+        }
+
     }
 }
diff --git a/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj b/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj
index 4a5ee129..944907bf 100644
--- a/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj
+++ b/OWML.ModHelper.Menus/OWML.ModHelper.Menus.csproj
@@ -34,6 +34,9 @@
     <Reference Include="Assembly-CSharp, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\OW.Unity.Dlls.1.0.2\lib\net35\Assembly-CSharp.dll</HintPath>
     </Reference>
+    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\Json.Net.Unity3D.9.0.1\lib\net35\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="OW.Unity.Dlls, Version=1.0.2.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\OW.Unity.Dlls.1.0.2\lib\net35\OW.Unity.Dlls.dll</HintPath>
     </Reference>
@@ -67,6 +70,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ModButton.cs" />
+    <Compile Include="ModConfigMenu.cs" />
+    <Compile Include="ModInput.cs" />
+    <Compile Include="ModInputMenu.cs" />
     <Compile Include="ModMenu.cs" />
     <Compile Include="ModOptionsMenu.cs" />
     <Compile Include="ModPauseMenu.cs" />
@@ -75,6 +81,11 @@
     <Compile Include="ModMenus.cs" />
     <Compile Include="ModMainMenu.cs" />
     <Compile Include="ModTabMenu.cs" />
+    <Compile Include="ModSliderInput.cs" />
+    <Compile Include="ModNumberInput.cs" />
+    <Compile Include="ModInputField.cs" />
+    <Compile Include="ModTextInput.cs" />
+    <Compile Include="ModToggleInput.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/OWML.ModHelper.Menus/packages.config b/OWML.ModHelper.Menus/packages.config
index bfe552eb..9cdd28f3 100644
--- a/OWML.ModHelper.Menus/packages.config
+++ b/OWML.ModHelper.Menus/packages.config
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="Json.Net.Unity3D" version="9.0.1" targetFramework="net35" />
   <package id="OW.Unity.Dlls" version="1.0.2" targetFramework="net35" />
 </packages>
\ No newline at end of file
diff --git a/OWML.ModHelper/ControllerButton.cs b/OWML.ModHelper/ControllerButton.cs
new file mode 100644
index 00000000..b3244c5f
--- /dev/null
+++ b/OWML.ModHelper/ControllerButton.cs
@@ -0,0 +1,34 @@
+using OWML.ModHelper.Events;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace OWML.ModHelper
+{
+    public class ControllerButton : MonoBehaviour
+    {
+        private Button _button;
+        private SingleAxisCommand _inputCommand;
+
+        public void Init(SingleAxisCommand inputCommand)
+        {
+            _button = GetComponent<Button>();
+            _inputCommand = inputCommand;
+            var imageElement = GetComponent<ButtonWithHotkeyImageElement>();
+            if (imageElement != null)
+            {
+                var textId = GetComponentInChildren<LocalizedText>().GetValue<UITextType>("_textID");
+                var title = UITextLibrary.GetString(textId);
+                imageElement.SetPrompt(new ScreenPrompt(inputCommand, title), InputMode.Menu);
+            }
+        }
+
+        private void Update()
+        {
+            if (_inputCommand != null && _button != null && OWInput.IsPressed(_inputCommand, InputMode.Menu))
+            {
+                _button.onClick.Invoke();
+            }
+        }
+
+    }
+}
diff --git a/OWML.ModHelper/DontDestroyOnLoad.cs b/OWML.ModHelper/DontDestroyOnLoad.cs
new file mode 100644
index 00000000..c6912bcc
--- /dev/null
+++ b/OWML.ModHelper/DontDestroyOnLoad.cs
@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace OWML.ModHelper
+{
+    public class DontDestroyOnLoad : MonoBehaviour
+    {
+        private void Start()
+        {
+            DontDestroyOnLoad(gameObject);
+        }
+    }
+}
diff --git a/OWML.ModHelper/ModConfig.cs b/OWML.ModHelper/ModConfig.cs
index 8c2ce42c..ad32da16 100644
--- a/OWML.ModHelper/ModConfig.cs
+++ b/OWML.ModHelper/ModConfig.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using OWML.Common;
 
 namespace OWML.ModHelper
@@ -16,24 +17,53 @@ public class ModConfig : IModConfig
         [JsonProperty("settings")]
         public Dictionary<string, object> Settings { get; set; } = new Dictionary<string, object>();
 
-        public T GetSetting<T>(string key)
+        public T GetSettingsValue<T>(string key)
         {
             if (!Settings.ContainsKey(key))
             {
                 ModConsole.Instance.WriteLine("Error: setting not found: " + key);
                 return default;
             }
-            var setting = Settings[key];
+
+            var value = Settings[key];
+
             try
             {
-                return (T)setting;
+                var val = value is JObject obj ? obj["value"] : value;
+                return (T)Convert.ChangeType(val, typeof(T));
             }
             catch (InvalidCastException)
             {
-                ModConsole.Instance.WriteLine($"Error when getting setting '{key}': can't cast {setting.GetType()} to {typeof(T)}");
+                ModConsole.Instance.WriteLine($"Error when converting setting {key} of type {value.GetType()} to type {typeof(T)}");
                 return default;
             }
         }
 
+        public void SetSettingsValue(string key, object val)
+        {
+            if (!Settings.ContainsKey(key))
+            {
+                ModConsole.Instance.WriteLine("Error: setting not found: " + key);
+                return;
+            }
+
+            var value = Settings[key];
+
+            if (value is JObject obj)
+            {
+                obj["value"] = "" + val;
+            } 
+            else
+            {
+                Settings[key] = val;
+            }
+        }
+
+        [Obsolete("Use GetSettingsValue instead")]
+        public T GetSetting<T>(string key)
+        {
+            return GetSettingsValue<T>(key);
+        }
+
     }
 }
diff --git a/OWML.ModHelper/OWML.ModHelper.csproj b/OWML.ModHelper/OWML.ModHelper.csproj
index a12d7df7..97293f4e 100644
--- a/OWML.ModHelper/OWML.ModHelper.csproj
+++ b/OWML.ModHelper/OWML.ModHelper.csproj
@@ -65,6 +65,8 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ControllerButton.cs" />
+    <Compile Include="DontDestroyOnLoad.cs" />
     <Compile Include="ModBehaviour.cs" />
     <Compile Include="ModConfig.cs" />
     <Compile Include="OwmlBehaviour.cs" />
@@ -76,14 +78,18 @@
     <Compile Include="ModStorage.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\OWML.Common\OWML.Common.csproj">
       <Project>{3C00626F-B688-4F32-B493-5B7EC1C879A0}</Project>
       <Name>OWML.Common</Name>
     </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
+    <ProjectReference Include="..\OWML.ModHelper.Events\OWML.ModHelper.Events.csproj">
+      <Project>{B771615E-6B51-44F8-B862-D7543C12C0FF}</Project>
+      <Name>OWML.ModHelper.Events</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>
\ No newline at end of file
diff --git a/OWML.ModLoader/ModData.cs b/OWML.ModLoader/ModData.cs
index 0129d72a..6de650e7 100644
--- a/OWML.ModLoader/ModData.cs
+++ b/OWML.ModLoader/ModData.cs
@@ -1,17 +1,30 @@
 using OWML.Common;
 using OWML.ModHelper;
+using System.Collections.Generic;
 
 namespace OWML.ModLoader
 {
     public class ModData : IModData
     {
         public IModManifest Manifest { get; }
-        public IModConfig Config { get; }
+        public IModConfig Config { get; private set; }
+        public IModConfig DefaultConfig { get; }
 
-        public ModData(IModManifest manifest, IModConfig config)
+        public ModData(IModManifest manifest, IModConfig config, IModConfig defaultConfig)
         {
             Manifest = manifest;
             Config = config;
+            DefaultConfig = defaultConfig;
+        }
+
+        public void ResetConfig()
+        {
+            Config = new ModConfig
+            {
+                Enabled = DefaultConfig.Enabled,
+                RequireVR = DefaultConfig.RequireVR,
+                Settings = new Dictionary<string, object>(DefaultConfig.Settings)
+            };
         }
 
     }
diff --git a/OWML.ModLoader/ModFinder.cs b/OWML.ModLoader/ModFinder.cs
index 0db9934b..e625b455 100644
--- a/OWML.ModLoader/ModFinder.cs
+++ b/OWML.ModLoader/ModFinder.cs
@@ -31,13 +31,13 @@ public IList<IModData> GetMods()
                 var json = File.ReadAllText(manifestFilename);
                 var manifest = JsonConvert.DeserializeObject<ModManifest>(json);
                 manifest.ModFolderPath = manifestFilename.Substring(0, manifestFilename.IndexOf("manifest.json"));
-                var config = GetModConfig(manifest);
-                mods.Add(new ModData(manifest, config));
+                var modData = GetModData(manifest);
+                mods.Add(modData);
             }
             return mods;
         }
 
-        private IModConfig GetModConfig(IModManifest manifest)
+        private IModData GetModData(IModManifest manifest)
         {
             var storage = new ModStorage(_console, manifest);
             var config = storage.Load<ModConfig>("config.json");
@@ -45,6 +45,7 @@ private IModConfig GetModConfig(IModManifest manifest)
             if (config == null && defaultConfig == null)
             {
                 config = new ModConfig();
+                defaultConfig = new ModConfig();
             }
             else if (defaultConfig != null && config == null)
             {
@@ -61,7 +62,7 @@ private IModConfig GetModConfig(IModManifest manifest)
                 }
             }
             storage.Save(config, "config.json");
-            return config;
+            return new ModData(manifest, config, defaultConfig);
         }
 
     }
diff --git a/OWML.ModLoader/Owo.cs b/OWML.ModLoader/Owo.cs
index ed8a28c7..39dec54c 100644
--- a/OWML.ModLoader/Owo.cs
+++ b/OWML.ModLoader/Owo.cs
@@ -6,7 +6,6 @@
 using OWML.ModHelper;
 using OWML.ModHelper.Assets;
 using OWML.ModHelper.Events;
-using OWML.ModHelper.Menus;
 using UnityEngine;
 
 namespace OWML.ModLoader
@@ -45,10 +44,12 @@ public void LoadMods()
                 if (modType == null)
                 {
                     _logger.Log("Mod type is null, skipping");
+                    _menus.ModsMenu.AddMod(modData, null);
                     continue;
                 }
                 var helper = CreateModHelper(modData);
-                InitializeMod(modType, helper);
+                var mod = InitializeMod(modType, helper);
+                _menus.ModsMenu.AddMod(modData, mod);
             }
         }
 
@@ -60,22 +61,9 @@ private void OnLogMessageReceived(string message, string stackTrace, LogType typ
             }
         }
 
-        private ModsMenu CreateModMenu()
-        {
-            _console.WriteLine("Creating mod menu");
-            var modsMenu = new ModsMenu(_logger, _console);
-            var modMenuButton = _menus.MainMenu.AddButton("MODS", 3);
-            modMenuButton.onClick.AddListener(() =>
-            {
-                modsMenu.Open();
-            });
-            return modsMenu;
-        }
-
         private Type LoadMod(IModData modData)
         {
-            var enabled = modData.Config.Enabled && modData.Manifest.Enabled;
-            if (!enabled)
+            if (!modData.Config.Enabled)
             {
                 _logger.Log($"{modData.Manifest.UniqueName} is disabled");
                 return null;
@@ -103,7 +91,7 @@ private IModHelper CreateModHelper(IModData modData)
                 events, assets, storage, _menus, modData.Manifest, modData.Config, _owmlConfig);
         }
 
-        private void InitializeMod(Type modType, IModHelper helper)
+        private IModBehaviour InitializeMod(Type modType, IModHelper helper)
         {
             _logger.Log($"Initializing {helper.Manifest.UniqueName} ({helper.Manifest.Version})...");
             _logger.Log("Adding mod behaviour...");
@@ -113,13 +101,13 @@ private void InitializeMod(Type modType, IModHelper helper)
                 var mod = (ModBehaviour)go.AddComponent(modType);
                 _logger.Log("Added! Initializing...");
                 mod.Init(helper);
+                return mod;
             }
             catch (Exception ex)
             {
                 _console.WriteLine($"Error while adding/initializing {helper.Manifest.UniqueName}: {ex}");
-                return;
+                return null;
             }
-            _console.WriteLine($"Loaded {helper.Manifest.UniqueName} ({helper.Manifest.Version}).");
         }
 
     }
diff --git a/OWML.SampleMods/OWML.EnableDebugMode/manifest.json b/OWML.SampleMods/OWML.EnableDebugMode/manifest.json
index d06a5d70..bec9429e 100644
--- a/OWML.SampleMods/OWML.EnableDebugMode/manifest.json
+++ b/OWML.SampleMods/OWML.EnableDebugMode/manifest.json
@@ -4,5 +4,5 @@
   "name": "EnableDebugMode",
   "uniqueName": "Alek.EnableDebugMode",
   "version": "0.2",
-  "owmlVersion": "0.3.31"
+  "owmlVersion": "0.3.32"
 }
\ No newline at end of file
diff --git a/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs b/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs
index 33c2a4fe..abeefa60 100644
--- a/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs
+++ b/OWML.SampleMods/OWML.LoadCustomAssets/LoadCustomAssets.cs
@@ -37,33 +37,17 @@ private void Start()
             ModHelper.Events.Subscribe<PlayerBody>(Events.AfterAwake);
             ModHelper.Events.OnEvent += OnEvent;
 
-            ModHelper.Menus.MainMenu.OnInit += DoMainMenuStuff;
-            DoMainMenuStuff();
-
-            ModHelper.Menus.PauseMenu.OnInit += DoPauseMenuStuff;
-        }
-
-        private void DoMainMenuStuff()
-        {
-            ModHelper.Console.WriteLine(nameof(DoMainMenuStuff));
-            var resumeDupe = ModHelper.Menus.MainMenu.ResumeExpeditionButton.Duplicate();
-            resumeDupe.Title = "OPEN INPUT MENU";
-            resumeDupe.OnClick += () => ModHelper.Menus.MainMenu.OptionsMenu.InputTab.Open();
-        }
-
-        private void DoPauseMenuStuff()
-        {
-            ModHelper.Console.WriteLine(nameof(DoPauseMenuStuff));
-            var openInputButton = ModHelper.Menus.PauseMenu.ResumeButton.Duplicate();
-            openInputButton.Title = "OPEN INPUT MENU";
-            openInputButton.OnClick += () => ModHelper.Menus.PauseMenu.OptionsMenu.InputTab.Open();
+            var modMenu = ModHelper.Menus.ModsMenu.GetModMenu(this);
         }
 
         public override void Configure(IModConfig config)
         {
-            ToggleMusic(config.GetSetting<bool>("enableMusic"));
-            _isDucksEnabled = config.GetSetting<bool>("enableDucks");
-            _isCubesEnabled = config.GetSetting<bool>("enableCubes");
+            ToggleMusic(config.GetSettingsValue<bool>("enableMusic"));
+            _isDucksEnabled = config.GetSettingsValue<bool>("enableDucks");
+            _isCubesEnabled = config.GetSettingsValue<bool>("enableCubes");
+            var speed = config.GetSettingsValue<float>("speed");
+            var power = config.GetSettingsValue<float>("power");
+            var enableSuperMode = config.GetSettingsValue<bool>("enableSuperMode");
         }
 
         private void OnMusicLoaded(AudioSource audio)
@@ -93,7 +77,7 @@ private void OnEvent(MonoBehaviour behaviour, Events ev)
                 _playerBody = (PlayerBody)behaviour;
                 _playerTransform = behaviour.transform;
                 _isStarted = true;
-                ToggleMusic(ModHelper.Config.GetSetting<bool>("enableMusic"));
+                ToggleMusic(ModHelper.Config.GetSettingsValue<bool>("enableMusic"));
             }
         }
 
@@ -134,6 +118,7 @@ private void CreateCube()
 
         private void ToggleMusic(bool enable)
         {
+            ModHelper.Console.WriteLine("ToggleMusic: " + enable);
             if (_music == null)
             {
                 return;
diff --git a/OWML.SampleMods/OWML.LoadCustomAssets/default-config.json b/OWML.SampleMods/OWML.LoadCustomAssets/default-config.json
index bed650f7..e74e224b 100644
--- a/OWML.SampleMods/OWML.LoadCustomAssets/default-config.json
+++ b/OWML.SampleMods/OWML.LoadCustomAssets/default-config.json
@@ -1,9 +1,30 @@
 {
-  "enabled": false,
-  "requireVR": false, 
+  "enabled": true,
+  "requireVR": false,
   "settings": {
     "enableMusic": true,
-    "enableDucks": true,
-    "enableCubes": false
+    "enableDucks": {
+      "type": "toggle",
+      "value": true,
+      "yes": "Quack",
+      "no": "Queck",
+      "title": "Enable Ducks"
+    },
+    "enableCubes": false,
+    "alphabet": "abc",
+    "speed": 10,
+    "power": {
+      "type": "slider",
+      "value": 10,
+      "min": 0,
+      "max": 20
+    },
+    "enableSuperMode": {
+      "type": "toggle",
+      "value": true,
+      "yes": "Absolutely",
+      "no": "Na-ah!",
+      "title": "Enable Super Mode"
+    }
   }
 }
\ No newline at end of file
diff --git a/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json b/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json
index 3c94a688..1270df5c 100644
--- a/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json
+++ b/OWML.SampleMods/OWML.LoadCustomAssets/manifest.json
@@ -4,5 +4,5 @@
   "name": "LoadCustomAssets",
   "uniqueName": "Alek.LoadCustomAssets",
   "version": "0.5",
-  "owmlVersion": "0.3.31"
+  "owmlVersion": "0.3.32"
 }
\ No newline at end of file
diff --git a/OWML.sln.DotSettings b/OWML.sln.DotSettings
index d17558b7..9ef71118 100644
--- a/OWML.sln.DotSettings
+++ b/OWML.sln.DotSettings
@@ -1,4 +1,5 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=GO/@EntryIndexedValue">GO</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IO/@EntryIndexedValue">IO</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=OW/@EntryIndexedValue">OW</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=OWML/@EntryIndexedValue">OWML</s:String>
diff --git a/Readme.md b/Readme.md
index 939fd4b2..0fb0f2c2 100644
--- a/Readme.md
+++ b/Readme.md
@@ -110,6 +110,7 @@ Feature requests, bug reports and PRs are welcome on GitHub.
 * [Outer Wilds on Reddit](https://www.reddit.com/r/outerwilds)
 * [SMAPI](https://smapi.io)
 * Texture_Turtle for graphics on [Nexus page](https://www.nexusmods.com/outerwilds/mods/1)
+* TAImatem and Raicuparta for research
 
 Dependencies:
 * [dnpatch](https://github.com/ioncodes/dnpatch)