using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using DarkMachine.UI;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("wk_stamina_hsv")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Stamina HSV Slider")]
[assembly: AssemblyTitle("wk_stamina_hsv")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 wk_stamina_hsv
{
[BepInPlugin("wk_stamina_hsv", "Stamina HSV Slider", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
private static Harmony harmony;
public void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("wk_stamina_hsv");
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
try
{
harmony.CreateClassProcessor(type).Patch();
}
catch (Exception ex)
{
Logger.LogError((object)("[Harmony] patch " + type.FullName + " failed: " + ex.Message));
}
}
Logger.LogInfo((object)"wk_stamina_hsv 1.0.0 has loaded!");
}
public void OnDestroy()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
Scene val = ((Component)this).gameObject.scene;
if (((Scene)(ref val)).isLoaded)
{
val = SceneManager.GetActiveScene();
Plugin plugin = ((Scene)(ref val)).GetRootGameObjects()[0].AddComponent<Plugin>();
if ((Object)(object)plugin == (Object)null)
{
Logger.LogFatal((object)"Plugin is being destroyed!");
harmony.UnpatchSelf();
}
}
}
}
[HarmonyPatch(typeof(UI_CosmeticInfoPanel), "UpdateSprite")]
public static class StaminaHSVFlag
{
public static GameObject staminaHSVRoot;
public static SubmitSlider staminaHueSlider;
public static SubmitSlider staminaSaturationSlider;
public static SubmitSlider staminaValueSlider;
public static Cosmetic_HandItem cosmetic_handItem;
public static Vector3 hsv;
private static float HSV_BoundsConvert(float v)
{
return (v + 1f) / 2f;
}
private static void SetStaminaColor()
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
cosmetic_handItem.cosmeticData.customStaminaColor = Color.HSVToRGB(HSV_BoundsConvert(hsv.x), HSV_BoundsConvert(hsv.y), HSV_BoundsConvert(hsv.z));
}
public static void SetHue(float h)
{
ManualLogSource logger = Plugin.Logger;
if (staminaHueSlider == null)
{
if (logger != null)
{
logger.LogFatal((object)"[stamina-hsv-sethue] stamina hue slider is null.");
}
}
else
{
hsv.x = h;
SetStaminaColor();
UpdateCosmeticSaveData();
}
}
public static void SetSaturation(float s)
{
ManualLogSource logger = Plugin.Logger;
if (staminaSaturationSlider == null)
{
if (logger != null)
{
logger.LogFatal((object)"[stamina-hsv-setsaturation] stamina saturation slider is null.");
}
}
else
{
hsv.y = s;
SetStaminaColor();
UpdateCosmeticSaveData();
}
}
public static void SetValue(float v)
{
ManualLogSource logger = Plugin.Logger;
if (staminaValueSlider == null)
{
if (logger != null)
{
logger.LogFatal((object)"[stamina-hsv-setvalue] stamina value slider is null.");
}
}
else
{
hsv.z = v;
SetStaminaColor();
UpdateCosmeticSaveData();
}
}
private static void UpdateCosmeticSaveData()
{
//IL_0016: 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)
StaminaPreferences.SetStaminaHSV(cosmetic_handItem.cosmeticData.cosmeticName, new StaminaPreferences.Entry
{
hsv = hsv
});
}
public static void Postfix(UI_CosmeticInfoPanel __instance)
{
//IL_0256: Unknown result type (might be due to invalid IL or missing references)
//IL_025b: Unknown result type (might be due to invalid IL or missing references)
bool active = false;
if (__instance.selectedCosmetic.cosmeticInfo.flags?.Contains("stamina-hsv") ?? false)
{
Cosmetic_Base selectedCosmetic = __instance.selectedCosmetic;
cosmetic_handItem = (Cosmetic_HandItem)(object)((selectedCosmetic is Cosmetic_HandItem) ? selectedCosmetic : null);
active = true;
if ((Object)(object)staminaHSVRoot == (Object)null)
{
ManualLogSource logger = Plugin.Logger;
SubmitSlider[] componentsInChildren = __instance.settingRoot.GetComponentsInChildren<SubmitSlider>();
GameObject val = null;
val = ((Component)__instance.settingRoot.transform.Find("Slider - Stamina HSV")).gameObject;
if ((Object)(object)val == (Object)null)
{
if (logger != null)
{
logger.LogFatal((object)"[stamina-hsv-flag] couldn't find the stamina HSV slider root object.");
}
return;
}
staminaHueSlider = ((Component)val.transform.Find("Slider-Hue")).GetComponent<SubmitSlider>();
staminaSaturationSlider = ((Component)val.transform.Find("Slider-Saturation")).GetComponent<SubmitSlider>();
staminaValueSlider = ((Component)val.transform.Find("Slider-Value")).GetComponent<SubmitSlider>();
staminaHSVRoot = val;
}
((UnityEventBase)staminaHueSlider.onValueChanged).m_Calls.ClearPersistent();
((UnityEventBase)staminaSaturationSlider.onValueChanged).m_Calls.ClearPersistent();
((UnityEventBase)staminaValueSlider.onValueChanged).m_Calls.ClearPersistent();
((UnityEventBase)staminaHueSlider.onValueChanged).m_PersistentCalls.Clear();
((UnityEventBase)staminaSaturationSlider.onValueChanged).m_PersistentCalls.Clear();
((UnityEventBase)staminaValueSlider.onValueChanged).m_PersistentCalls.Clear();
((UnityEventBase)staminaHueSlider.onValueChanged).RemoveAllListeners();
((UnityEvent<float>)(object)staminaHueSlider.onValueChanged).AddListener((UnityAction<float>)SetHue);
((UnityEventBase)staminaSaturationSlider.onValueChanged).RemoveAllListeners();
((UnityEvent<float>)(object)staminaSaturationSlider.onValueChanged).AddListener((UnityAction<float>)SetSaturation);
((UnityEventBase)staminaValueSlider.onValueChanged).RemoveAllListeners();
((UnityEvent<float>)(object)staminaValueSlider.onValueChanged).AddListener((UnityAction<float>)SetValue);
hsv = GetHSV();
staminaHSVRoot.SetActive(true);
staminaHueSlider.value = hsv.x;
staminaSaturationSlider.value = hsv.y;
staminaValueSlider.value = hsv.z;
}
else
{
staminaHSVRoot.SetActive(false);
}
if (!__instance.settingRoot.gameObject.activeSelf)
{
__instance.settingRoot.gameObject.SetActive(active);
}
}
private static Vector3 GetHSV()
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
if (StaminaPreferences.GetStaminaHSV(cosmetic_handItem.cosmeticData.cosmeticName) == null)
{
float x = default(float);
float y = default(float);
float z = default(float);
Color.RGBToHSV(cosmetic_handItem.GetCustomStaminaColor(), ref x, ref y, ref z);
StaminaPreferences.SetStaminaHSV(cosmetic_handItem.cosmeticData.cosmeticName, new StaminaPreferences.Entry
{
hsv = new Vector3
{
x = x,
y = y,
z = z
}
});
}
if (hsv == default(Vector3))
{
hsv = StaminaPreferences.GetStaminaHSV(cosmetic_handItem.cosmeticData.cosmeticName).hsv;
return hsv;
}
return hsv;
}
}
[HarmonyPatch(typeof(CL_CosmeticManager), "Initialize")]
public static class ApplyAutomatically
{
private static float HSV_BoundsConvert(float v)
{
return (v + 1f) / 2f;
}
public static void Postfix(CL_CosmeticManager __instance, ref List<Cosmetic_HandItem> ___cosmeticHands)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
foreach (Cosmetic_HandItem ___cosmeticHand in ___cosmeticHands)
{
StaminaPreferences.Entry staminaHSV = StaminaPreferences.GetStaminaHSV(___cosmeticHand.cosmeticData.cosmeticName);
if (staminaHSV != null)
{
Vector3 hsv = staminaHSV.hsv;
___cosmeticHand.cosmeticData.customStaminaColor = Color.HSVToRGB(HSV_BoundsConvert(hsv.x), HSV_BoundsConvert(hsv.y), HSV_BoundsConvert(hsv.z));
}
}
}
}
public static class StaminaPreferences
{
public class Entry
{
public Vector3 hsv;
}
private static Dictionary<string, Entry> _staminaPreferences;
private const string fileName = "wk_stamina_hsv_state.json";
private static string PathFor()
{
string configPath = Paths.ConfigPath;
Directory.CreateDirectory(configPath);
return Path.Combine(configPath, "wk_stamina_hsv_state.json");
}
private static void EnsureLoaded()
{
if (_staminaPreferences != null)
{
return;
}
try
{
string path = PathFor();
if (File.Exists(path))
{
_staminaPreferences = JsonConvert.DeserializeObject<Dictionary<string, Entry>>(File.ReadAllText(path)) ?? new Dictionary<string, Entry>();
}
else
{
_staminaPreferences = new Dictionary<string, Entry>();
}
}
catch (Exception ex)
{
ManualLogSource logger = Plugin.Logger;
if (logger != null)
{
logger.LogWarning((object)("[stamina-hsv] load failed: " + ex.Message));
}
_staminaPreferences = new Dictionary<string, Entry>();
}
}
private static void Save()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
try
{
File.WriteAllText(PathFor(), JsonConvert.SerializeObject((object)_staminaPreferences, (Formatting)1, new JsonSerializerSettings
{
ReferenceLoopHandling = (ReferenceLoopHandling)1
}));
}
catch (Exception ex)
{
Plugin.Logger.LogWarning((object)("[stamina-hsv] save failed: " + ex.Message));
}
}
public static void SetStaminaHSV(string key, Entry state)
{
EnsureLoaded();
_staminaPreferences[key] = state;
Save();
}
public static Entry GetStaminaHSV(string key)
{
EnsureLoaded();
if (!_staminaPreferences.TryGetValue(key, out var value))
{
return null;
}
return value;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "wk_stamina_hsv";
public const string PLUGIN_NAME = "Stamina HSV Slider";
public const string PLUGIN_VERSION = "1.0.0";
}
}
