using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("WaterTweaker")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("WaterTweaker")]
[assembly: AssemblyTitle("WaterTweaker")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace WaterTweaker
{
internal static class Log
{
internal static ManualLogSource _logSource;
internal static void Init(ManualLogSource logSource)
{
_logSource = logSource;
}
internal static void LogDebug(object data)
{
_logSource.LogDebug(data);
}
internal static void LogError(object data)
{
_logSource.LogError(data);
}
internal static void LogFatal(object data)
{
_logSource.LogFatal(data);
}
internal static void LogInfo(object data)
{
_logSource.LogInfo(data);
}
internal static void LogMessage(object data)
{
_logSource.LogMessage(data);
}
internal static void LogWarning(object data)
{
_logSource.LogWarning(data);
}
}
public static class RiskOfOptionsCompat
{
private static bool? _enabled;
public static bool Enabled
{
get
{
if (!_enabled.HasValue)
{
_enabled = Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
}
return _enabled.Value;
}
}
public static void AddOptionStepSlider(ConfigEntry<float> configEntry, float min, float max, float increment, string name)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
ModSettingsManager.AddOption((BaseOption)new StepSliderOption(configEntry, new StepSliderConfig
{
min = min,
max = max,
increment = increment,
name = name
}), "Judgy.WaterTweaker", "WaterTweaker");
}
public static void AddOptionCheckbox(ConfigEntry<bool> configEntry, string name)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(configEntry, new CheckBoxConfig
{
name = name
}), "Judgy.WaterTweaker", "WaterTweaker");
}
public static void SetModDescription(string desc)
{
ModSettingsManager.SetModDescription(desc, "Judgy.WaterTweaker", "WaterTweaker");
}
}
[BepInPlugin("Judgy.WaterTweaker", "WaterTweaker", "1.3.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class WaterTweakerPlugin : BaseUnityPlugin
{
public const string PluginGUID = "Judgy.WaterTweaker";
public const string PluginAuthor = "Judgy";
public const string PluginName = "WaterTweaker";
public const string PluginVersion = "1.3.0";
private const string MapWetlandName = "foggyswamp";
private bool tryApplyTweaks;
private bool loopRunning;
private int applyAttempts;
public static ConfigEntry<float> ConfigWetlandWaterOpacity { get; set; }
public static ConfigEntry<bool> ConfigWetlandWaterPP { get; set; }
public void Awake()
{
Log.Init(((BaseUnityPlugin)this).Logger);
ConfigWetlandWaterOpacity = ((BaseUnityPlugin)this).Config.Bind<float>("WaterTweaker", "WetlandWaterOpacity", 1f, "Sets the Opacity of the water in Wetland Aspect (between 0.0 and 1.0).");
ConfigWetlandWaterOpacity.SettingChanged += OnWaterSettingsChanged;
ConfigWetlandWaterPP = ((BaseUnityPlugin)this).Config.Bind<bool>("WaterTweaker", "WetlandPostProcessing", true, "Enables Post Processing effects when the camera goes underwater in Wetland Aspect.");
ConfigWetlandWaterPP.SettingChanged += OnWaterSettingsChanged;
if (RiskOfOptionsCompat.Enabled)
{
RiskOfOptionsCompat.AddOptionStepSlider(ConfigWetlandWaterOpacity, 0f, 1f, 0.1f, "Wetland Water Opacity");
RiskOfOptionsCompat.AddOptionCheckbox(ConfigWetlandWaterPP, "Wetland Post Processing");
RiskOfOptionsCompat.SetModDescription("Allows you to tweak the graphics settings of Wetland Aspect's water.");
}
SceneManager.activeSceneChanged += OnActiveSceneChanged;
Log.LogInfo("Awake done.");
}
public void Update()
{
if (tryApplyTweaks && !loopRunning)
{
((MonoBehaviour)this).StartCoroutine("ApplyTweaksCoroutine");
}
}
private IEnumerator ApplyTweaksCoroutine()
{
loopRunning = true;
tryApplyTweaks = false;
while (applyAttempts < 10 && !TryApplyTweaksWetland())
{
applyAttempts++;
yield return (object)new WaitForSeconds(0.5f);
}
applyAttempts = 0;
loopRunning = false;
}
private bool TryApplyTweaksWetland()
{
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
IEnumerable<GameObject> enumerable = Resources.FindObjectsOfTypeAll<GameObject>().Where(IsWaterPlaneObject);
Log.LogInfo($"Trying to apply Wetland Water Tweaks to {enumerable.Count()} objects.");
foreach (GameObject item in enumerable)
{
Transform val = item.transform.Find("PP");
if (!Object.op_Implicit((Object)(object)val))
{
return false;
}
((Component)val).gameObject.SetActive(ConfigWetlandWaterPP.Value);
MeshRenderer component = item.GetComponent<MeshRenderer>();
if (!Object.op_Implicit((Object)(object)component))
{
return false;
}
Color color = ((Renderer)component).material.color;
((Renderer)component).material.color = new Color(color.r, color.g, color.b, Mathf.Clamp01(ConfigWetlandWaterOpacity.Value));
}
return true;
}
private static bool IsWaterPlaneObject(GameObject go)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)go == (Object)null))
{
_ = go.scene;
Scene scene = go.scene;
if (((Scene)(ref scene)).name != null && ((Object)go).name != null)
{
scene = go.scene;
if (((Scene)(ref scene)).name.StartsWith("foggyswamp"))
{
return ((Object)go).name.StartsWith("water plane", StringComparison.OrdinalIgnoreCase);
}
return false;
}
}
return false;
}
private void OnWaterSettingsChanged(object sender, EventArgs e)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name.StartsWith("foggyswamp"))
{
tryApplyTweaks = true;
}
}
private void OnActiveSceneChanged(Scene oldScene, Scene newScene)
{
if (((Scene)(ref newScene)).name.StartsWith("foggyswamp"))
{
tryApplyTweaks = true;
}
}
private void DEBUG_GoToWetlandMap()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
IEnumerable<SceneDef> source = ((IEnumerable<SceneDef>)(object)SceneCatalog.allSceneDefs).Where((SceneDef def) => def.cachedName == "foggyswamp");
if (source.Any())
{
Run.instance.AdvanceStage(source.First());
}
}
}
public static class WaterTweaker_Commands
{
[ConCommand(commandName = "watertweaker_opacity", helpText = "Set Opacity of the water in Wetland Aspect. Value must be between 0.0 and 1.0. args[0]=(float)value")]
public static void CommandOpacity(ConCommandArgs args)
{
string text = ((ConCommandArgs)(ref args)).TryGetArgString(0);
if (string.IsNullOrWhiteSpace(text))
{
Debug.Log((object)("Current Water Opacity Value: `" + WaterTweakerPlugin.ConfigWetlandWaterOpacity.Value.ToString(CultureInfo.InvariantCulture) + "`."));
return;
}
text = text.Trim().Replace(',', '.');
if (!float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
Debug.LogError((object)"Couldn't parse new value as float.");
}
else if (result >= 0f && result <= 1f)
{
WaterTweakerPlugin.ConfigWetlandWaterOpacity.Value = result;
Debug.Log((object)("Water Opacity set to " + result.ToString(CultureInfo.InvariantCulture)));
}
else
{
Debug.LogError((object)"Opacity value out of bounds ! Must be between 0.0 and 1.0");
}
}
[ConCommand(commandName = "watertweaker_pp", helpText = "Enables Post processing effects when the camera is under water in Wetland Aspect. Value must be `true`, `false`, `0` or `1`. args[0]=(bool)value")]
public static void CommandPP(ConCommandArgs args)
{
string text = ((ConCommandArgs)(ref args)).TryGetArgString(0);
if (string.IsNullOrWhiteSpace(text))
{
Debug.Log((object)$"Post processing effects enabled : `{WaterTweakerPlugin.ConfigWetlandWaterPP.Value}`.");
return;
}
text = text.Trim().ToLower();
if (!TryParseBool(text, out var result))
{
Debug.LogError((object)"Couldn't parse new value as bool. Value must be `true`, `false`, `0` or `1`");
return;
}
WaterTweakerPlugin.ConfigWetlandWaterPP.Value = result;
Debug.Log((object)("Water Post Processing effects now " + (result ? "enabled." : "disabled.")));
}
private static bool TryParseBool(string input, out bool result)
{
if (bool.TryParse(input, out result))
{
return true;
}
if (int.TryParse(input, out var result2))
{
result = result2 > 0;
return true;
}
return false;
}
}
}
