internal static GameObject AddBindingOptionWithCallback(uGUI_OptionsPanel panel, int tab, string label, KeyCode key, GameInput.Device device, UnityAction <KeyCode> callback)
{
// Add item
GameObject gameObject = panel.AddItem(tab, panel.bindingOptionPrefab);
// Update text
Text text = gameObject.GetComponentInChildren <Text>();
if (text != null)
{
gameObject.GetComponentInChildren <TranslationLiveUpdate>().translationKey = label;
text.text = Language.main.Get(label);
//text.text = label;
}
// Create bindings
uGUI_Bindings bindings = gameObject.GetComponentInChildren <uGUI_Bindings>();
uGUI_Binding binding = bindings.bindings.First();
// Destroy secondary bindings
UnityEngine.Object.Destroy(bindings.bindings.Last().gameObject);
UnityEngine.Object.Destroy(bindings);
// Update bindings
binding.device = device;
binding.value = KeyCodeUtils.KeyCodeToString(key);
binding.onValueChanged.RemoveAllListeners();
binding.onValueChanged.AddListener(new UnityAction <string>((string s) => callback?.Invoke(KeyCodeUtils.StringToKeyCode(s))));
return(gameObject);
}
public static void Postfix(uGUI_OptionsPanel __instance)
{
nitroxSettingsManager ??= Resolve <NitroxSettingsManager>(true);
int tabIndex = __instance.AddTab("Nitrox");
foreach (KeyValuePair <string, List <NitroxSettingsManager.Setting> > settingEntries in nitroxSettingsManager.NitroxSettings)
{
__instance.AddHeading(tabIndex, settingEntries.Key);
foreach (NitroxSettingsManager.Setting setting in settingEntries.Value)
{
switch (setting.SettingType)
{
case NitroxSettingsManager.SettingType.TOGGLE:
__instance.AddToggleOption(tabIndex, setting.Label, setting.GetValue <bool>(), (UnityAction <bool>)setting.Callback);
break;
case NitroxSettingsManager.SettingType.SLIDER:
__instance.AddSliderOption(tabIndex, setting.Label, setting.GetValue <float>(), setting.SliderMinValue, setting.SliderMaxValue, setting.SliderDefaultValue, (UnityAction <float>)setting.Callback);
break;
case NitroxSettingsManager.SettingType.LIST:
__instance.AddChoiceOption(tabIndex, setting.Label, setting.ListItems, setting.GetValue <int>(), (UnityAction <int>)setting.Callback);
break;
}
}
}
}
internal static void Postfix(uGUI_OptionsPanel __instance)
{
int modsTab = __instance.AddTab("Mods");
__instance.AddHeading(modsTab, "QModManager");
bool enableDebugLogs = PlayerPrefsExtra.GetBool("QModManager_EnableDebugLogs", false);
__instance.AddToggleOption(modsTab, "Enable debug logs", enableDebugLogs,
new UnityAction <bool>(toggleVal => PlayerPrefsExtra.SetBool("QModManager_EnableDebugLogs", toggleVal)));
bool updateCheck = PlayerPrefsExtra.GetBool("QModManager_EnableUpdateCheck", true);
__instance.AddToggleOption(modsTab, "Check for updates", updateCheck,
new UnityAction <bool>(toggleVal => PlayerPrefsExtra.SetBool("QModManager_EnableUpdateCheck", toggleVal)));
bool enableDebugger = PlayerPrefsExtra.GetBool("QModManager_PrefabDebugger_EnableExperimental", false);
__instance.AddToggleOption(modsTab, "Enable prefab debugger (experimental)", enableDebugger,
new UnityAction <bool>(toggleVal => PlayerPrefsExtra.SetBool("QModManager_PrefabDebugger_EnableExperimental", toggleVal)));
/*bool enableDebugger = PlayerPrefsExtra.GetBool("QModManager_PrefabDebugger_Enable", true);
* __instance.AddToggleOption(modsTab, "Enable prefab debugger", enableDebugger,
* new UnityAction<bool>(toggleVal => PlayerPrefsExtra.SetBool("QModManager_PrefabDebugger_Enable", toggleVal)));*/
}
public static void AddGeneralTab_Postfix(uGUI_OptionsPanel __instance)
{
__instance.AddHeading(MainPatcher.tabIndex, "Additional VR Options");
__instance.AddToggleOption(MainPatcher.tabIndex, "Enable VR Animations", GameOptions.enableVrAnimations, delegate(bool v)
{
GameOptions.enableVrAnimations = v;
if (Player.main != null)
{
Player.main.playerAnimator.SetBool("vr_active", !v);
}
});
__instance.AddToggleOption(MainPatcher.tabIndex, "Look Down for HUD", MainPatcher.lookDownHUD, delegate(bool v)
{
MainPatcher.lookDownHUD = v;
if (!v && MainPatcher.quickSlots != null && MainPatcher.barsPanel != null)
{
MainPatcher.quickSlots.transform.localScale = Vector3.one;
MainPatcher.barsPanel.transform.localScale = Vector3.one;
}
});
#if SN1
__instance.AddSliderOption(MainPatcher.tabIndex, "Walk Speed(Default: 60%)", VROptions.groundMoveScale * 100f, 50f, 100f, 60f, delegate(float v)
{
VROptions.groundMoveScale = v / 100f;
});
#elif BZ
__instance.AddSliderOption(MainPatcher.tabIndex, "Walk Speed(Default: 60%)", VROptions.groundMoveScale * 100f, 50f, 100f, 60f, 1f, delegate(float v)
{
VROptions.groundMoveScale = v / 100f;
}, SliderLabelMode.Int, "0");
#endif
}
public void OnEnable()
{
Config.Load();
optionsPanel = GetComponent <uGUI_OptionsPanel>();
bindings = Traverse.Create(optionsPanel).Field("bindings").GetValue <List <uGUI_Bindings> >();
isOpened = true;
}
static void _addTab(uGUI_OptionsPanel __instance, string label, int __result)
{
if (label == "Mods")
{
modsTabIndex = __result;
}
isMainMenu = (__instance.GetComponent <MainMenuOptions>() != null);
}
public static void AddGeneralTab_Postfix(uGUI_OptionsPanel __instance)
{
__instance.AddHeading(_tabIndex, "Snap Turning");//add new heading under the General Tab
__instance.AddToggleOption(_tabIndex, "Enable Snap Turning", SnapTurningOptions.EnableSnapTurning, (bool v) => SnapTurningOptions.EnableSnapTurning = v);
__instance.AddChoiceOption(_tabIndex, "Snap Angle", SnapTurningOptions.SnapAngleChoices, SnapTurningOptions.SnapAngleChoiceIndex, (int index) => SnapTurningOptions.SnapAngleChoiceIndex = index);
__instance.AddBindingOption(_tabIndex, "Keyboard Turn Left", GameInput.Device.Keyboard, GameInput.Button.LookLeft);
__instance.AddBindingOption(_tabIndex, "Keyboard Turn Right", GameInput.Device.Keyboard, GameInput.Button.LookRight);
__instance.AddToggleOption(_tabIndex, "Disable Mouse Look", SnapTurningOptions.DisableMouseLook, (bool v) => SnapTurningOptions.DisableMouseLook = v);
}
//TODO: Create a new tab instead of using general for all the additional VR options and if possible move existing VR to the same tab
static void Postfix(uGUI_OptionsPanel __instance)
{
__instance.AddHeading(generalTabIndex, "Additional VR Options");//add new heading under the General Tab
__instance.AddToggleOption(generalTabIndex, "Enable VR Animations", GameOptions.enableVrAnimations, delegate(bool v)
{
GameOptions.enableVrAnimations = v;
//playerAnimator vr_active is normally set in the Start function of Player so we need to update it if option changed during gameplay
if (Player.main != null)
{
Player.main.playerAnimator.SetBool("vr_active", !v);
}
});
__instance.AddSliderOption(generalTabIndex, "Walk Speed(Default: 60%)", VROptions.groundMoveScale * 100, 50, 100, 60, delegate(float v)
{
VROptions.groundMoveScale = v / 100f;
});
__instance.AddSliderOption(generalTabIndex, "Subtitle Height", subtitleYPos, 20, 75, 50, delegate(float v)
{
subtitleYPos = v;
UIElementsFixes.SetSubtitleHeight(subtitleYPos);
});
__instance.AddSliderOption(generalTabIndex, "Subtitle Scale", subtitleScale * 100, 50, 150, 100, delegate(float v)
{
subtitleScale = v / 100;
UIElementsFixes.SetSubtitleScale(subtitleScale);
});
__instance.AddSliderOption(generalTabIndex, "PDA Distance", PDA_Distance * 100f, 25, 40, 40, delegate(float v)
{
PDA_Distance = v / 100f;
});
__instance.AddHeading(generalTabIndex, "VR HUD Options");//add new heading under the General Tab
__instance.AddToggleOption(generalTabIndex, "Dynamic HUD", DynamicHUD, delegate(bool v)
{
DynamicHUD = v;
if (!DynamicHUD)
{
VRHUD.UpdateHUDOpacity(HUDAlpha);
}
});
__instance.AddSliderOption(generalTabIndex, "HUD Opacity", HUDAlpha * 100f, 20, 100, 100, delegate(float v)
{
HUDAlpha = v / 100f;
VRHUD.UpdateHUDOpacity(HUDAlpha);
});
__instance.AddSliderOption(generalTabIndex, "HUD Distance", HUD_Distance / 0.5f, 1, 4, 2, delegate(float v)
{
HUD_Distance = v * 0.5f;
VRHUD.UpdateHUDDistance(HUD_Distance);
});
__instance.AddSliderOption(generalTabIndex, "HUD Scale", HUD_Scale / 0.5f, 1, 4, 2, delegate(float v)
{
HUD_Scale = v * 0.5f;
VRHUD.UpdateHUDScale(HUD_Scale);
});
}
public static void AddGraphicsTab_Prefix(uGUI_OptionsPanel __instance)
{
var t = __instance;
var idx = t.AddTab("ExtraOptions");
t.AddSliderOption(idx, "Murkiness", currentConfig.Murkiness, 0, 200, 100, new UnityAction <float>(v => { currentConfig.Murkiness = v; Reload(); }));
t.AddChoiceOption(idx, "Texture Quality", new int[] { 0, 1, 2, 3, 4 }, currentConfig.TextureQuality, new UnityAction <int>(v => { currentConfig.TextureQuality = v; Reload(); }));
t.AddToggleOption(idx, "Console", currentConfig.Console, new UnityAction <bool>(v => { currentConfig.Console = v; Reload(); }));
t.AddToggleOption(idx, "LightShaft", currentConfig.LightShafts, new UnityAction <bool>(v => { currentConfig.LightShafts = v; Reload(); }));
t.AddToggleOption(idx, "Variable Physics Step", currentConfig.VariablePhysicsStep, new UnityAction <bool>(v => { currentConfig.VariablePhysicsStep = v; Reload(); }));
t.AddToggleOption(idx, "Fog \"Fix\"", currentConfig.FogFix, new UnityAction <bool>(v => { currentConfig.FogFix = v; Reload(); }));
}
public static void Postfix(uGUI_OptionsPanel __instance, int tabIndex, GameInput.Device device)
{
KeyBindingManager keyBindingManager = new KeyBindingManager();
if (device == GameInput.Device.Keyboard)
{
foreach (KeyBinding keyBinding in keyBindingManager.KeyboardKeyBindings)
{
ReflectionHelper.ReflectionCall(__instance, "AddBindingOption", new Type[] { typeof(int), typeof(string), typeof(GameInput.Device), typeof(GameInput.Button) }, true, false, tabIndex, keyBinding.Label, keyBinding.Device, keyBinding.Button);
}
}
}
public static void Postfix(uGUI_OptionsPanel __instance, int tabIndex, GameInput.Device device)
{
KeyBindingManager keyBindingManager = new();
if (device == GameInput.Device.Keyboard)
{
foreach (KeyBinding keyBinding in keyBindingManager.KeyboardKeyBindings)
{
__instance.AddBindingOption(tabIndex, keyBinding.Label, keyBinding.Device, keyBinding.Button);
}
}
}
public static void Postfix(uGUI_OptionsPanel __instance)
{
if (nullableModsTabIndex.HasValue)
{
var modsTabIndex = nullableModsTabIndex.Value;
// If at Mods tab...
if (__instance.currentTab == modsTabIndex)
{
Config.Save();
}
}
}
static void Postfix(uGUI_OptionsPanel __instance)
{
__instance.AddHeading(generalTabIndex, "Misc VR Options");
__instance.AddToggleOption(generalTabIndex, "Disable Y-Axis Input", VROptions.disableInputPitch, (bool v) => VROptions.disableInputPitch = v);
__instance.AddSliderOption(generalTabIndex, "Ground Speed Scale", VROptions.groundMoveScale, 0.6f, (float v) => {
if (v <= 0f)
{
// Never allow 0 scale speed (immobile)
v = .05f;
}
VROptions.groundMoveScale = v;
}
);
}
internal static void Postfix(uGUI_OptionsPanel __instance)
{
ModsTab = __instance.AddTab("Mods");
__instance.AddHeading(ModsTab, "QModManager");
bool enableDebugLogs = PlayerPrefsExtra.GetBool("QModManager_EnableDebugLogs", false);
__instance.AddToggleOption(ModsTab, "Enable debug logs", enableDebugLogs,
new UnityAction <bool>(toggleVal => PlayerPrefsExtra.SetBool("QModManager_EnableDebugLogs", toggleVal)));
bool updateCheck = PlayerPrefsExtra.GetBool("QModManager_EnableUpdateCheck", true);
__instance.AddToggleOption(ModsTab, "Check for updates", updateCheck,
new UnityAction <bool>(toggleVal => PlayerPrefsExtra.SetBool("QModManager_EnableUpdateCheck", toggleVal)));
}
public static void AddJukeBoxTab(uGUI_OptionsPanel oPanel)
{
if (oPanel != null)
{
int tabIndex = oPanel.AddTab("Jukebox");
oPanel.AddHeading(tabIndex, "Jukebox Colors");
oPanel.AddToggleOption(tabIndex, "Toggle Jukebox Colors", JukeboxConfig.JBColor, (bool v) => JukeboxConfig.JBColor = ToggleColorChange(v), "Allows you to change the colors of the jukebox lights");
MainStoppedColor = oPanel.AddColorOption(tabIndex, "Color 1", JukeboxConfig.FlashColor0, (Color Color0) => JukeboxConfig.FlashColor0 = Color0);
MainColor = oPanel.AddColorOption(tabIndex, "Color 2", JukeboxConfig.FlashColor2, (Color Color2) => JukeboxConfig.FlashColor2 = Color2);
BeatColor = oPanel.AddColorOption(tabIndex, "Color 3", JukeboxConfig.FlashColor1, (Color Color1) => JukeboxConfig.FlashColor1 = Color1);
oPanel.AddHeading(tabIndex, "Jukebox Options");
oPanel.AddToggleOption(tabIndex, "Toggle Party Mode", JukeboxConfig.PartyMode, (bool partyMode) => JukeboxConfig.PartyMode = partyMode, "Turns the rooms lights off the jukebox is in while playing");
ToggleColorChange(JukeboxConfig.JBColor);
}
}
private void Run()
{
uGUI_OptionsPanel uGUI_OptionsPanel = IngameMenu.main.GetComponentsInChildren <uGUI_OptionsPanel>(includeInactive: true).Where(x => x.name == "Options").FirstOrDefault();
//if ((bool)uGUI_OptionsPanel)
//{
// if (uGUI_TabbedControlsPanel_SelectItem_Patch.kbTabIndex > -1)
// {
// if (uGUI_OptionsPanel.gameObject.GetComponent<uGUI_QuickSlots_ConfigTab>() == null)
// {
// var qsCongfig = uGUI_OptionsPanel.gameObject.AddComponent<uGUI_QuickSlots_ConfigTab>();
// qsCongfig.SetIndex(uGUI_TabbedControlsPanel_SelectItem_Patch.kbTabIndex);
// }
// }
//}
}
void Awake()
{
var inputs = (IList)(typeof(GameInput).GetField("inputs", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null));
foreach (var kk in inputs)
{
var key = kk.GetType().GetField("name").GetValue(kk).ToString();
var value = (KeyCode)Enum.Parse(typeof(KeyCode), kk.GetType().GetField("keyCode").GetValue(kk).ToString());
if (!inputsMapping.ContainsKey(key))
{
inputsMapping.Add(key, value);
}
}
optionsPanel = GetComponent <uGUI_OptionsPanel>();
bindings = Traverse.Create(optionsPanel).Field("bindings").GetValue <List <uGUI_Bindings> >();
}
internal static void Postfix(uGUI_OptionsPanel __instance)
{
ModsTab = __instance.AddTab("Mods");
__instance.AddHeading(ModsTab, "QModManager");
__instance.AddToggleOption(ModsTab, "Check for updates", Config.CheckForUpdates, new UnityAction <bool>(value => Config.CheckForUpdates = value));
__instance.AddToggleOption(ModsTab, "Enable console", Config.EnableConsole, new UnityAction <bool>(value =>
{
Config.EnableConsole = value;
DevConsole.disableConsole = !value;
UnityEngine.PlayerPrefs.SetInt("UWE.DisableConsole", value ? 0 : 1);
}));
__instance.AddToggleOption(ModsTab, "Enable debug logs", Config.EnableDebugLogs, new UnityAction <bool>(value => Config.EnableDebugLogs = value));
__instance.AddToggleOption(ModsTab, "Enable developer mode", Config.EnableDevMode, new UnityAction <bool>(value => Config.EnableDevMode = value));
}
internal static void AddTabs_Postfix(uGUI_OptionsPanel __instance)
{
var optionsPanel = __instance;
var modsTab = optionsPanel.AddTab("Mods");
foreach (ModOptions modOption in modOptions)
{
optionsPanel.AddHeading(modsTab, modOption.Name);
foreach (ModOption option in modOption.Options)
{
if (option.Type == ModOptionType.Slider)
{
var slider = (ModSliderOption)option;
optionsPanel.AddSliderOption(modsTab, slider.Label, slider.Value, slider.MinValue, slider.MaxValue, slider.Value,
callback: new UnityEngine.Events.UnityAction <float>((float sliderVal) =>
modOption.OnSliderChange(slider.Id, sliderVal)));
}
else if (option.Type == ModOptionType.Toggle)
{
var toggle = (ModToggleOption)option;
optionsPanel.AddToggleOption(modsTab, toggle.Label, toggle.Value,
callback: new UnityEngine.Events.UnityAction <bool>((bool toggleVal) =>
modOption.OnToggleChange(toggle.Id, toggleVal)));
}
else if (option.Type == ModOptionType.Choice)
{
var choice = (ModChoiceOption)option;
optionsPanel.AddChoiceOption(modsTab, choice.Label, choice.Options, choice.Index,
callback: new UnityEngine.Events.UnityAction <int>((int index) =>
modOption.OnChoiceChange(choice.Id, index)));
}
else
{
//V2.Logger.Log($"Invalid ModOptionType detected for option: {option.Id}");
}
}
}
}
//legacy mod options loader
private void LoadModMenu()
{
try
{
uGUI_OptionsPanel optPanel = FindAllOfType <uGUI_OptionsPanel>().FirstOrDefault() ?? throw new System.Exception("Failed to retrieve options panel."); //get subnautica options panel
if (!optPanel)
{
return;
}
var menu = new GameObject("cyclops_strafe_menu_control").AddComponent <UIModMenu>();
menu.transform.SetParent(optPanel.transform);
menu.Load(optPanel);
}
catch (System.Exception _e)
{
Util.LogE("Error occurred while loading mod UI: " + _e.Message);
Util.LogE("\n" + _e.StackTrace);
ModErrorOccurred = true;
}
}
internal static void AddTabs_Postfix(uGUI_OptionsPanel __instance)
{
uGUI_OptionsPanel optionsPanel = __instance;
// Start the modsTab index at a value of -1
int modsTab = -1;
// Loop through all of the tabs
for (int i = 0; i < optionsPanel.tabsContainer.childCount; i++)
{
// Check if they are named "Mods"
var text = optionsPanel.tabsContainer.GetChild(i).GetComponentInChildren <Text>(true);
if (text != null && text.text == "Mods")
{
// Set the tab index to the found one and break
modsTab = i;
break;
}
}
// If no tab was found, create one
if (modsTab == -1)
{
modsTab = optionsPanel.AddTab("Mods");
}
// Maybe this could be split into its own file to handle smlhelper options, or maybe it could be removed alltogether
optionsPanel.AddHeading(modsTab, "SMLHelper");
optionsPanel.AddToggleOption(modsTab, "Enable debug logs", V2.Logger.EnableDebugging, V2.Logger.SetDebugging);
optionsPanel.AddChoiceOption(modsTab, "Extra item info", new string[]
{
"Mod name (default)",
"Mod name and item ID",
"Nothing"
}, (int)TooltipPatcher.ExtraItemInfoOption, (i) => TooltipPatcher.SetExtraItemInfo((TooltipPatcher.ExtraItemInfo)i));
// adding all other options here
modOptions.Values.ForEach(options => options.AddOptionsToPanel(optionsPanel, modsTab));
}
internal static void Postfix(uGUI_OptionsPanel __instance)
{
ModsTab = __instance.AddTab("Mods");
__instance.AddHeading(ModsTab, "QModManager");
__instance.AddToggleOption(ModsTab, "Check for updates", Config.CheckForUpdates, new UnityAction <bool>(value => Config.CheckForUpdates = value));
__instance.AddToggleOption(ModsTab, "Enable console", Config.EnableConsole, new UnityAction <bool>(value =>
{
Config.EnableConsole = value;
#if SUBNAUTICA_STABLE
DevConsole.disableConsole = !value;
UnityEngine.PlayerPrefs.SetInt("UWE.DisableConsole", value ? 0 : 1);
#elif BELOWZERO || SUBNAUTICA_EXP
PlatformUtils.SetDevToolsEnabled(value);
#endif
}));
__instance.AddToggleOption(ModsTab, "Enable debug logs", Config.EnableDebugLogs, new UnityAction <bool>(value => Config.EnableDebugLogs = value));
__instance.AddToggleOption(ModsTab, "Enable developer mode", Config.EnableDevMode, new UnityAction <bool>(value => Config.EnableDevMode = value));
}
public override void BuildModOptions()
{
Color color = BaseClocksConfig.ClockFaceColor;
AddChoiceOption(k_DigitalClockFormatChoiceId, "Digital Clock Time Format", m_DigitalFormatChoiceStrings, (int)BaseClocksConfig.DigitalClockFormat);
int presetIndex = Array.FindIndex(m_Presets, x => x.Color == color);
if (presetIndex == -1)
{
presetIndex = m_ColorPresetsChoiceStrings.Length - 1;
}
AddChoiceOption(k_ColorPresetChoiceId, "Clock Face Colour Preset", m_ColorPresetsChoiceStrings, presetIndex);
AddSliderOption(k_ColorSliderRedId, "Red", 0, 1f, color.r);
AddSliderOption(k_ColorSliderGreenId, "Green", 0, 1f, color.g);
AddSliderOption(k_ColorSliderBlueId, "Blue", 0, 1f, color.b);
uGUI_OptionsPanel optionsPanel = GameObject.FindObjectOfType <uGUI_OptionsPanel>();
Transform pane = optionsPanel.panesContainer.GetChild(FindChildWithText(optionsPanel.tabsContainer, "Mods").parent.GetSiblingIndex());
m_BaseClocksHeaderTransform = FindChildWithText(pane.Find("Viewport").GetChild(0), this.Name).parent;
}
static bool Prefix(uGUI_OptionsPanel __instance)
{
__instance.AddGeneralTab();
__instance.AddGraphicsTab();
if (GameInput.IsKeyboardAvailable())
{
__instance.AddKeyboardTab();
}
if (GameInput.IsControllerAvailable())
{
__instance.AddControllerTab();
}
__instance.AddAccessibilityTab();
if (!PlatformUtils.isConsolePlatform)
{
__instance.AddTroubleshootingTab();
}
if (__instance != null)
{
AddJukeBoxTab(__instance);
}
return(false);
}
public static void Postfix(uGUI_OptionsPanel __instance)
{
if (nullableModsTabIndex.HasValue)
{
var modsTabIndex = nullableModsTabIndex.Value;
__instance.AddHeading(modsTabIndex, $"Terraforming");
#if BelowZero
__instance.AddToggleOption(modsTabIndex, $"Rebuilding messages", Config.Instance.rebuildMessages,
new UnityAction <bool>(value => Config.Instance.rebuildMessages = value),
$"Shows terrain rebuilding message while terrain rebuilding is in progress. Enabled by default."
);
__instance.AddToggleOption(modsTabIndex, $"Habitant modules burying", Config.Instance.habitantModulesPartialBurying,
new UnityAction <bool>(value => Config.Instance.habitantModulesPartialBurying = value),
$"Allows habitat burying into terrain and adjusts overlapping terrain around them. Enabled by default."
);
__instance.AddSliderOption(modsTabIndex, $"Space between terrain and module", Config.Instance.spaceBetweenTerrainHabitantModule,
0.0f, 10.0f,
DefaultConfig.spaceBetweenTerrainHabitantModule,
0.5f,
new UnityAction <float>(value => Config.Instance.spaceBetweenTerrainHabitantModule = value),
SliderLabelMode.Float,
"0.0"
);
__instance.AddToggleOption(modsTabIndex, $"Propulsion cannon terrain impact", Config.Instance.terrainImpactWithPropulsionCannon,
new UnityAction <bool>(value => Config.Instance.terrainImpactWithPropulsionCannon = value),
$"Causes the repulsion cannon to remove small portion of terrain after \"shooting\" pulse to spot. Enabled by default."
);
__instance.AddToggleOption(modsTabIndex, $"Destroy obstacles on construction", Config.Instance.destroyLargerObstaclesOnConstruction,
new UnityAction <bool>(value => Config.Instance.destroyLargerObstaclesOnConstruction = value),
$"Disables restrictions of overlapping larger objects with placable habitat module. Destroys them when construction of module finishes. Enabled by default."
);
#else
__instance.AddToggleOption(modsTabIndex, $"Rebuilding messages", Config.Instance.rebuildMessages,
new UnityAction <bool>(value => Config.Instance.rebuildMessages = value)
);
__instance.AddToggleOption(modsTabIndex, $"Habitant modules burying", Config.Instance.habitantModulesPartialBurying,
new UnityAction <bool>(value => Config.Instance.habitantModulesPartialBurying = value)
);
__instance.AddSliderOption(modsTabIndex, $"Terrain vs module space", Config.Instance.spaceBetweenTerrainHabitantModule,
0.0f, 10.0f,
DefaultConfig.spaceBetweenTerrainHabitantModule,
new UnityAction <float>(value => Config.Instance.spaceBetweenTerrainHabitantModule = value)
);
__instance.AddToggleOption(modsTabIndex, $"Repulsion terrain impact", Config.Instance.terrainImpactWithPropulsionCannon,
new UnityAction <bool>(value => Config.Instance.terrainImpactWithPropulsionCannon = value)
);
__instance.AddToggleOption(modsTabIndex, $"Destroy obstacles", Config.Instance.destroyLargerObstaclesOnConstruction,
new UnityAction <bool>(value => Config.Instance.destroyLargerObstaclesOnConstruction = value)
);
#endif
}
}
public void Load(uGUI_OptionsPanel _optionsPanel)
{
m_optionsPanel = _optionsPanel;
m_config = CyclopsStrafeMod.ModConfig;
}
internal static void AddTabs_Postfix(uGUI_OptionsPanel __instance)
{
uGUI_OptionsPanel optionsPanel = __instance;
// Start the modsTab index at a value of -1
var modsTab = -1;
// Loop through all of the tabs
for (int i = 0; i < optionsPanel.tabsContainer.childCount; i++)
{
// Check if they are named "Mods"
var text = optionsPanel.tabsContainer.GetChild(i).GetComponentInChildren <Text>(true);
if (text != null && text.text == "Mods")
{
// Set the tab index to the found one and break
modsTab = i;
break;
}
}
// If no tab was found, create one
if (modsTab == -1)
{
modsTab = optionsPanel.AddTab("Mods");
}
// Maybe this could be split into its own file to handle smlhelper options, or maybe it could be removed alltogether
optionsPanel.AddHeading(modsTab, "SMLHelper");
optionsPanel.AddToggleOption(modsTab, "Enable debug logs", V2.Logger.EnableDebugging, V2.Logger.SetDebugging);
foreach (ModOptions modOption in modOptions.Values)
{
optionsPanel.AddHeading(modsTab, modOption.Name);
foreach (ModOption option in modOption.Options)
{
switch (option.Type)
{
case ModOptionType.Slider:
var slider = (ModSliderOption)option;
optionsPanel.AddSliderOption(modsTab, slider.Label, slider.Value, slider.MinValue, slider.MaxValue, slider.Value,
new UnityAction <float>((float sliderVal) =>
modOption.OnSliderChange(slider.Id, sliderVal)));
break;
case ModOptionType.Toggle:
var toggle = (ModToggleOption)option;
optionsPanel.AddToggleOption(modsTab, toggle.Label, toggle.Value,
new UnityAction <bool>((bool toggleVal) =>
modOption.OnToggleChange(toggle.Id, toggleVal)));
break;
case ModOptionType.Choice:
var choice = (ModChoiceOption)option;
optionsPanel.AddChoiceOption(modsTab, choice.Label, choice.Options, choice.Index,
new UnityAction <int>((int index) =>
modOption.OnChoiceChange(choice.Id, index, choice.Options[index])));
break;
case ModOptionType.Keybind:
var keybind = (ModKeybindOption)option;
ModKeybindOption.AddBindingOptionWithCallback(optionsPanel, modsTab, keybind.Label, keybind.Key, keybind.Device,
new UnityAction <KeyCode>((KeyCode key) =>
modOption.OnKeybindChange(keybind.Id, key)));
break;
default:
V2.Logger.Log($"Invalid ModOptionType detected for option: {option.Id} ({option.Type.ToString()})", LogLevel.Error);
break;
}
}
}
}
public static void Postfix(uGUI_OptionsPanel __instance)
{
Main.optionsPanel = __instance;
}
public static void Postfix(uGUI_OptionsPanel __instance, int __result, string label)
{
if (label == "Mods")
{
try
{
WaterBiomeManager.BiomeSettings biome = Main.GetBiome();
if (biome != null)
{
var t = __instance;
var idx = __result;
var name = biome.name ?? "???";
t.AddHeading(idx, $"Biome Config ({name})");
Dictionary <string, WaterscapeVolume.Settings> themes;
try
{
if (File.Exists(Main.themesPath))
{
themes = JsonConvert.DeserializeObject <Dictionary <string, WaterscapeVolume.Settings> >(File.ReadAllText(Main.themesPath), Main.themeJSS);
}
else
{
themes = new Dictionary <string, WaterscapeVolume.Settings>();
}
}
catch (Exception)
{
themes = new Dictionary <string, WaterscapeVolume.Settings>();
}
if (themes.ContainsKey(name))
{
biome.settings = themes[name];
}
else
{
themes[name] = biome.settings;
}
Vector("absorption", 0, 200);
Range("scattering", 0, 2);
Color("scatteringColor");
Range("murkiness", 0.01568f, 1.0f);
Color("emissive");
Range("emissiveScale", 0, 1);
Range("startDistance", 0, 100);
Range("sunlightScale", 0, 1);
Range("ambientScale", 0, 1);
void Apply()
{
Logger.Log(Logger.Level.Debug, "Reloading");
Main.ApplyOptions();
Logger.Log(Logger.Level.Debug, "Reloaded");
var json = JsonConvert.SerializeObject(themes
, Formatting.Indented
, Main.themeJSS);
Logger.Log(Logger.Level.Debug, "serialized");
File.WriteAllText(Main.themesPath, json);
Logger.Log(Logger.Level.Debug, "Written");
}
void AddVectorRawOption <T>(string fieldName, float min, float max, Func <T, Vector3> from, Func <Vector3, T> to)
{
float scale = 255f / (max - min);
float nmin = min * scale;
float nmax = max * scale;
var fld = Traverse.Create(biome.settings).Field(fieldName);
Func <Vector3> get = () => from(fld.GetValue <T>()) * scale;
Action <Vector3> set = (iv) => fld.SetValue(to(iv / scale));
#if SUBNAUTICA
t.AddSliderOption(idx, $"{fieldName}.x/r", get().x, nmin, nmax, get().x, new UnityAction <float>(v => { set(new Vector3(v, get().y, get().z)); Apply(); }));
t.AddSliderOption(idx, $"{fieldName}.y/g", get().y, nmin, nmax, get().y, new UnityAction <float>(v => { set(new Vector3(get().x, v, get().z)); Apply(); }));
t.AddSliderOption(idx, $"{fieldName}.z/b", get().z, nmin, nmax, get().z, new UnityAction <float>(v => { set(new Vector3(get().x, get().y, v)); Apply(); }));
#elif BELOWZERO
t.AddSliderOption(idx, $"{fieldName}.x/r", get().x, nmin, nmax, get().x, Mathf.Clamp(nmin / nmax, 0.01f, 100f), new UnityAction <float>(v => { set(new Vector3(v, get().y, get().z)); Apply(); }));
t.AddSliderOption(idx, $"{fieldName}.y/g", get().y, nmin, nmax, get().y, Mathf.Clamp(nmin / nmax, 0.01f, 100f), new UnityAction <float>(v => { set(new Vector3(get().x, v, get().z)); Apply(); }));
t.AddSliderOption(idx, $"{fieldName}.z/b", get().z, nmin, nmax, get().z, Mathf.Clamp(nmin / nmax, 0.01f, 100f), new UnityAction <float>(v => { set(new Vector3(get().x, get().y, v)); Apply(); }));
#endif
}
void Vector(string fieldName, float min, float max)
{
AddVectorRawOption(fieldName, min, max, x => x, y => y);
}
void Color(string fieldName)
{
AddVectorRawOption <Color>(fieldName, 0, 1, xx => new Vector3(xx.r, xx.g, xx.b), yy => new Color(yy.x, yy.y, yy.z));
}
void Range(string fieldName, float min, float max)
{
float scale = 255f / (max - min);
float nmin = min * scale;
float nmax = max * scale;
var fld = Traverse.Create(biome.settings).Field(fieldName);
Func <float> get = () => fld.GetValue <float>() * scale;
Action <float> set = (iv) => fld.SetValue(iv / scale);
#if SUBNAUTICA
t.AddSliderOption(idx, $"{fieldName}", get(), nmin, nmax, get(), new UnityAction <float>(v => { set(v); Apply(); }));
#elif BELOWZERO
t.AddSliderOption(idx, $"{fieldName}", get(), nmin, nmax, get(), Mathf.Clamp(nmin / nmax, 0.01f, 100f), new UnityAction <float>(v => { set(v); Apply(); }));
#endif
}
}
}
catch (Exception e)
{
Logger.Log(Logger.Level.Error, "Failed to add Biome Options Panel", e);
}
}
}
public static void AddGeneralTab_Postfix(uGUI_OptionsPanel __instance)
{
__instance.AddHeading(tabIndex, "Snap Turning");//add new heading under the General Tab
__instance.AddToggleOption(tabIndex, "Enable Snap Turning", SnapTurningOptions.EnableSnapTurning, (bool v) => SnapTurningOptions.EnableSnapTurning = v);
__instance.AddChoiceOption(tabIndex, "Snap Angle", SnapTurningOptions.SnapAngleChoices, SnapTurningOptions.SnapAngleChoiceIndex, (int index) => SnapTurningOptions.SnapAngleChoiceIndex = index);
}
