using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Networking;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("CookingBellTimer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.3.12.0")]
[assembly: AssemblyInformationalVersion("0.3.12")]
[assembly: AssemblyProduct("CookingBellTimer")]
[assembly: AssemblyTitle("CookingBellTimer")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.3.12.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 CookingBellTimer
{
internal static class BellAudio
{
internal static AudioClip? Bell;
private static AudioSource? _source;
private static bool _paused;
private static bool _playedForCurrentItem;
internal static bool PlayedForCurrentItem => _playedForCurrentItem;
internal static void Initialize(MonoBehaviour host)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
GameObject val = new GameObject("CookingBellTimer_Audio");
Object.DontDestroyOnLoad((Object)val);
_source = val.AddComponent<AudioSource>();
_source.spatialBlend = 0f;
_source.dopplerLevel = 0f;
_source.bypassReverbZones = true;
_source.playOnAwake = false;
_source.loop = false;
host.StartCoroutine(LoadBell());
}
private static IEnumerator LoadBell()
{
string text = Path.Combine(Path.GetDirectoryName(typeof(Plugin).Assembly.Location), "sounds", "ding.ogg");
if (!File.Exists(text))
{
Plugin.Log.LogError((object)("Missing bell sound: " + text));
yield break;
}
UnityWebRequest req = UnityWebRequestMultimedia.GetAudioClip(new Uri(text).AbsoluteUri, (AudioType)14);
try
{
yield return req.SendWebRequest();
if ((int)req.result != 1)
{
Plugin.Log.LogError((object)("Failed loading bell: " + req.error));
yield break;
}
Bell = DownloadHandlerAudioClip.GetContent(req);
Plugin.Log.LogInfo((object)$"Loaded bell ({Bell.length:0.00}s)");
}
finally
{
((IDisposable)req)?.Dispose();
}
}
internal static void PlayOnce()
{
if ((Object)(object)_source != (Object)null && (Object)(object)Bell != (Object)null && !_playedForCurrentItem)
{
_source.Stop();
_source.clip = Bell;
_source.loop = false;
_source.volume = Plugin.BellVolume.Value;
_source.time = 0f;
_source.Play();
_paused = false;
_playedForCurrentItem = true;
Plugin.Log.LogDebug((object)"Bell triggered.");
}
}
internal static void Pause()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
if (!((Object)_source == (Object)null) && _source.isPlaying)
{
_source.Pause();
_paused = true;
}
}
internal static void Resume()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
if (!((Object)_source == (Object)null) && _paused)
{
_source.UnPause();
_paused = false;
}
}
internal static void Tick()
{
}
internal static void ResetForNewItem()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
if ((Object)_source != (Object)null)
{
_source.Stop();
_source.clip = null;
}
_paused = false;
_playedForCurrentItem = false;
}
internal static void StopForBurnt()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
if ((Object)_source != (Object)null)
{
_source.Stop();
}
_paused = false;
}
}
internal static class CookingHook
{
public static void Postfix(object __instance, float prev, float next, bool asServer)
{
try
{
if (!(next <= prev) && RuntimeTargets.WasCookedByLocalPlayer(__instance))
{
CookingTracker.Track(__instance);
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Cooking hook failed: " + ex.Message));
}
}
}
internal static class CookingOverlay
{
private const float MinCook = 1f;
private const float MaxCook = 1.5f;
private const float Marker = 1.45f;
private static float _displayMultiplier = 1f;
private static float _burnProgress;
private static float _lastUpdate = -999f;
private static bool _visible;
private static bool _burning;
private static Texture2D? _pixel;
private static GUIStyle? _titleStyle;
private static GUIStyle? _markerStyle;
private static GUIStyle? _burningStyle;
internal static void Initialize()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Expected O, but got Unknown
_pixel = new Texture2D(1, 1);
_pixel.SetPixel(0, 0, Color.white);
_pixel.Apply();
GUIStyle val = new GUIStyle
{
alignment = (TextAnchor)4,
fontSize = 20,
fontStyle = (FontStyle)1
};
val.normal.textColor = Color.white;
_titleStyle = val;
GUIStyle val2 = new GUIStyle
{
alignment = (TextAnchor)1,
fontSize = 12,
fontStyle = (FontStyle)1
};
val2.normal.textColor = Color.white;
_markerStyle = val2;
GUIStyle val3 = new GUIStyle
{
alignment = (TextAnchor)4,
fontSize = 22,
fontStyle = (FontStyle)1
};
val3.normal.textColor = new Color(1f, 0.86f, 0.12f, 1f);
_burningStyle = val3;
}
internal static void ReportCook(float displayedMultiplier, bool burning, float burnProgress)
{
_displayMultiplier = Mathf.Max(0f, displayedMultiplier);
_burning = burning;
_burnProgress = Mathf.Clamp01(burnProgress);
_lastUpdate = Time.unscaledTime;
_visible = true;
}
internal static void HideImmediately()
{
_visible = false;
_displayMultiplier = 1f;
_burning = false;
_burnProgress = 0f;
_lastUpdate = -999f;
}
internal static void Tick()
{
if (_visible && Time.unscaledTime - _lastUpdate > Plugin.OverlayHideDelay.Value)
{
_visible = false;
}
}
internal static void Draw()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_0190: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Unknown result type (might be due to invalid IL or missing references)
//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
if (_visible && !((Object)_pixel == (Object)null) && _titleStyle != null && _markerStyle != null && _burningStyle != null)
{
float value = Plugin.OverlayWidth.Value;
float value2 = Plugin.OverlayHeight.Value;
float num = ((float)Screen.width - value) * 0.5f;
float num2 = (float)Screen.height - Plugin.OverlayBottomOffset.Value - value2;
Rect rect = new Rect(num - 3f, num2 - 3f, value + 6f, value2 + 6f);
Rect val = default(Rect);
((Rect)(ref val))..ctor(num, num2, value, value2);
DrawRect(rect, new Color(0f, 0f, 0f, 0.92f));
if (_burning)
{
Color val2 = new Color(0.34f, 0.16f, 0.055f, 0.98f);
Color val3 = default(Color);
((Color)(ref val3))..ctor(0.015f, 0.008f, 0.004f, 0.99f);
Color color = Color.Lerp(val2, val3, _burnProgress);
DrawRect(val, color);
GUI.Label(new Rect(num, num2 - 34f, value, 30f), $"BURNING {_displayMultiplier:0.00}x", _burningStyle);
}
else
{
DrawRect(val, new Color(0.08f, 0.08f, 0.08f, 0.94f));
float num3 = Mathf.InverseLerp(1f, 1.5f, Mathf.Clamp(_displayMultiplier, 1f, 1.5f));
DrawRect(new Rect(num, num2, value * num3, value2), GetCookingGradient(_displayMultiplier));
DrawMarker(1.45f, val, "1.45x");
GUI.Label(new Rect(num, num2 - 32f, value, 28f), $"COOKING {_displayMultiplier:0.00}x", _titleStyle);
}
}
}
private static Color GetCookingGradient(float multiplier)
{
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: 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_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
Color val = default(Color);
((Color)(ref val))..ctor(0.18f, 0.82f, 0.28f, 0.98f);
Color val2 = default(Color);
((Color)(ref val2))..ctor(1f, 0.9f, 0.12f, 0.98f);
Color val3 = default(Color);
((Color)(ref val3))..ctor(1f, 0.52f, 0.08f, 0.98f);
Color val4 = default(Color);
((Color)(ref val4))..ctor(0.95f, 0.12f, 0.08f, 0.98f);
if (multiplier <= 1.25f)
{
return Color.Lerp(val, val2, Mathf.InverseLerp(1f, 1.25f, multiplier));
}
if (multiplier <= 1.4f)
{
return Color.Lerp(val2, val3, Mathf.InverseLerp(1.25f, 1.4f, multiplier));
}
return Color.Lerp(val3, val4, Mathf.InverseLerp(1.4f, 1.5f, multiplier));
}
private static void DrawMarker(float value, Rect bar, string label)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
float num = Mathf.InverseLerp(1f, 1.5f, value);
float num2 = ((Rect)(ref bar)).x + ((Rect)(ref bar)).width * num;
DrawRect(new Rect(num2 - 1.5f, ((Rect)(ref bar)).y - 4f, 3f, ((Rect)(ref bar)).height + 8f), Color.white);
GUI.Label(new Rect(num2 - 38f, ((Rect)(ref bar)).y + ((Rect)(ref bar)).height + 4f, 76f, 20f), label, _markerStyle);
}
private static void DrawRect(Rect rect, Color color)
{
//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)
//IL_000b: 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_001b: Expected O, but got Unknown
Color color2 = GUI.color;
GUI.color = color;
GUI.DrawTexture(rect, (Texture)_pixel);
GUI.color = color2;
}
}
internal static class CookingTracker
{
private static WeakReference? _trackedItem;
private static CooknessAccessor? _accessor;
private static DisplayedMultiplierAccessor? _displayAccessor;
private static object? _currentIdentity;
private const float RawPerfect = 1f;
private static float _lastRawCookness = 0f;
private static float _lastDisplayedMultiplier = 1f;
private static float _lastCookCallTime = -999f;
private static bool _sessionActive;
internal static void Track(object item)
{
if (item != null)
{
if (_currentIdentity == null || _currentIdentity != item)
{
_currentIdentity = item;
_trackedItem = new WeakReference(item);
_accessor = CooknessAccessor.Resolve(item.GetType());
_displayAccessor = DisplayedMultiplierAccessor.Resolve(item.GetType());
_sessionActive = false;
_lastRawCookness = 0f;
_lastDisplayedMultiplier = 1f;
BellAudio.ResetForNewItem();
}
if (_accessor != null)
{
_sessionActive = true;
_lastCookCallTime = Time.unscaledTime;
float rawCookness = _accessor.Read(item);
Sample(item, rawCookness);
}
}
}
internal static void Tick()
{
if (_sessionActive && Time.unscaledTime - _lastCookCallTime > 0.3f)
{
_sessionActive = false;
BellAudio.Pause();
}
else
{
if (!_sessionActive || _trackedItem == null || !_trackedItem.IsAlive || _accessor == null)
{
return;
}
object target = _trackedItem.Target;
if (target != null)
{
Object val = (Object)((target is Object) ? target : null);
if (val == null || !(val == (Object)null))
{
float rawCookness = _accessor.Read(target);
Sample(target, rawCookness);
}
}
}
}
private static void Sample(object item, float rawCookness)
{
rawCookness = Mathf.Max(0f, rawCookness);
bool flag = rawCookness > 1.0005f;
float displayedMultiplier = GetDisplayedMultiplier(item, rawCookness, flag);
if (rawCookness > 5E-05f)
{
CookingOverlay.ReportCook(displayedMultiplier, flag, GetBurnProgress(rawCookness));
}
if (!flag && !BellAudio.PlayedForCurrentItem && _lastDisplayedMultiplier < Plugin.BellThreshold.Value && displayedMultiplier >= Plugin.BellThreshold.Value)
{
BellAudio.PlayOnce();
}
else if (BellAudio.PlayedForCurrentItem)
{
BellAudio.Resume();
}
_lastRawCookness = rawCookness;
_lastDisplayedMultiplier = displayedMultiplier;
}
private static float GetDisplayedMultiplier(object item, float rawCookness, bool burning)
{
if (_displayAccessor != null && _displayAccessor.TryRead(item, out var value) && value >= 0f && value <= 2f)
{
return value;
}
if (!burning)
{
return 1f + Mathf.Clamp01(rawCookness) * 0.5f;
}
float num = Mathf.Max(0f, rawCookness - 1f);
return Mathf.Max(0f, 1.5f - num * 0.5f);
}
private static float GetBurnProgress(float rawCookness)
{
if (rawCookness <= 1f)
{
return 0f;
}
return Mathf.Clamp01(rawCookness - 1f);
}
}
internal sealed class CooknessAccessor
{
internal readonly Type TargetType;
private readonly PropertyInfo? _cooknessProperty;
private readonly FieldInfo? _syncField;
private readonly PropertyInfo? _syncValueProperty;
private CooknessAccessor(Type type, PropertyInfo property)
{
TargetType = type;
_cooknessProperty = property;
}
private CooknessAccessor(Type type, FieldInfo field, PropertyInfo valueProperty)
{
TargetType = type;
_syncField = field;
_syncValueProperty = valueProperty;
}
internal static CooknessAccessor? Resolve(Type type)
{
PropertyInfo property = type.GetProperty("Cookness", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanRead && IsNumeric(property.PropertyType))
{
Plugin.Log.LogInfo((object)("Using exact public cookness property: " + type.Name + ".Cookness"));
return new CooknessAccessor(type, property);
}
FieldInfo field = type.GetField("_cookness", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
PropertyInfo property2 = field.FieldType.GetProperty("Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property2 != null && property2.CanRead && IsNumeric(property2.PropertyType))
{
Plugin.Log.LogWarning((object)"Public Cookness property missing; falling back to _cookness.Value");
return new CooknessAccessor(type, field, property2);
}
}
Plugin.Log.LogError((object)("Could not resolve Cookness on " + type.FullName));
return null;
}
internal float Read(object target)
{
try
{
object obj = null;
if (_cooknessProperty != null)
{
obj = _cooknessProperty.GetValue(target);
}
else if (_syncField != null && _syncValueProperty != null)
{
object value = _syncField.GetValue(target);
if (value != null)
{
obj = _syncValueProperty.GetValue(value);
}
}
if (obj is float result)
{
return result;
}
if (obj is double num)
{
return (float)num;
}
if (obj is int num2)
{
return num2;
}
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Cookness read failed: " + ex.Message));
}
return 1f;
}
private static bool IsNumeric(Type type)
{
if (!(type == typeof(float)) && !(type == typeof(double)))
{
return type == typeof(int);
}
return true;
}
}
internal sealed class DisplayedMultiplierAccessor
{
internal readonly Type TargetType;
private readonly PropertyInfo? _property;
private readonly FieldInfo? _field;
private readonly MethodInfo? _method;
private DisplayedMultiplierAccessor(Type type, PropertyInfo property)
{
TargetType = type;
_property = property;
}
private DisplayedMultiplierAccessor(Type type, FieldInfo field)
{
TargetType = type;
_field = field;
}
private DisplayedMultiplierAccessor(Type type, MethodInfo method)
{
TargetType = type;
_method = method;
}
internal static DisplayedMultiplierAccessor? Resolve(Type type)
{
string[] array = new string[6] { "CookingMultiplier", "CookMultiplier", "CookedMultiplier", "CookingValueMultiplier", "CookValueMultiplier", "CookWorthMultiplier" };
foreach (string name in array)
{
PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanRead && IsNumeric(property.PropertyType))
{
Plugin.Log.LogInfo((object)("Using direct displayed cooking multiplier property: " + type.Name + "." + property.Name));
return new DisplayedMultiplierAccessor(type, property);
}
FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null && IsNumeric(field.FieldType))
{
Plugin.Log.LogInfo((object)("Using direct displayed cooking multiplier field: " + type.Name + "." + field.Name));
return new DisplayedMultiplierAccessor(type, field);
}
}
array = new string[3] { "GetCookingMultiplier", "GetCookMultiplier", "GetCookedMultiplier" };
foreach (string name2 in array)
{
MethodInfo method = type.GetMethod(name2, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
if (method != null && IsNumeric(method.ReturnType))
{
Plugin.Log.LogInfo((object)("Using direct displayed cooking multiplier method: " + type.Name + "." + method.Name + "()"));
return new DisplayedMultiplierAccessor(type, method);
}
}
Plugin.Log.LogInfo((object)"No direct displayed cooking multiplier member found; using cookness mapping fallback.");
return null;
}
internal bool TryRead(object target, out float value)
{
value = 0f;
try
{
object obj = null;
if (_property != null)
{
obj = _property.GetValue(target);
}
else if (_field != null)
{
obj = _field.GetValue(target);
}
else if (_method != null)
{
obj = _method.Invoke(target, null);
}
if (obj is float num)
{
value = num;
return true;
}
if (obj is double num2)
{
value = (float)num2;
return true;
}
if (obj is int num3)
{
value = num3;
return true;
}
}
catch (Exception ex)
{
Plugin.Log.LogDebug((object)("Direct multiplier read failed; fallback mapping used: " + ex.Message));
}
return false;
}
private static bool IsNumeric(Type t)
{
if (!(t == typeof(float)) && !(t == typeof(double)))
{
return t == typeof(int);
}
return true;
}
}
[BepInPlugin("ponyfisher.howtofish.cookingbelltimer", "Cooking Bell Timer", "0.3.12")]
[BepInProcess("How to Fish.exe")]
public sealed class Plugin : BaseUnityPlugin
{
public const string Guid = "ponyfisher.howtofish.cookingbelltimer";
public const string Name = "Cooking Bell Timer";
public const string Version = "0.3.12";
internal static Plugin Instance;
internal static ManualLogSource Log;
internal static ConfigEntry<float> BellThreshold;
internal static ConfigEntry<float> BellVolume;
internal static ConfigEntry<bool> OverlayEnabled;
internal static ConfigEntry<float> OverlayWidth;
internal static ConfigEntry<float> OverlayHeight;
internal static ConfigEntry<float> OverlayBottomOffset;
internal static ConfigEntry<float> OverlayHideDelay;
private Harmony _harmony;
private void Awake()
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Expected O, but got Unknown
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Expected O, but got Unknown
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Expected O, but got Unknown
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Expected O, but got Unknown
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Expected O, but got Unknown
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Expected O, but got Unknown
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Expected O, but got Unknown
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Expected O, but got Unknown
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Expected O, but got Unknown
//IL_0190: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Expected O, but got Unknown
//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
//IL_01aa: Expected O, but got Unknown
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Expected O, but got Unknown
//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
//IL_01f3: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
BellThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("Timing", "BellThreshold", 1.48f, "Displayed cookness multiplier where the bell plays once.");
BellVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "BellVolume", 0.27f, new ConfigDescription("Bell volume. Default is 0.27, which is 30% of the previous 0.90 playback level.", (AcceptableValueBase)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
OverlayEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Overlay", "Enabled", true, "Show the horizontal cooking progress bar.");
OverlayWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "Width", 560f, new ConfigDescription("Cooking bar width in pixels.", (AcceptableValueBase)new AcceptableValueRange<float>(280f, 1100f), Array.Empty<object>()));
OverlayHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "Height", 32f, new ConfigDescription("Cooking bar height in pixels.", (AcceptableValueBase)new AcceptableValueRange<float>(16f, 70f), Array.Empty<object>()));
OverlayBottomOffset = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "BottomOffset", 235f, new ConfigDescription("Distance from bottom of screen.", (AcceptableValueBase)new AcceptableValueRange<float>(30f, 600f), Array.Empty<object>()));
OverlayHideDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "HideDelay", 0.9f, new ConfigDescription("Seconds before the bar hides after cooking stops.", (AcceptableValueBase)new AcceptableValueRange<float>(0.2f, 4f), Array.Empty<object>()));
BellAudio.Initialize((MonoBehaviour)this);
CookingOverlay.Initialize();
_harmony = new Harmony("ponyfisher.howtofish.cookingbelltimer");
MethodInfo methodInfo = RuntimeTargets.ResolveCooknessChangedMethod();
if (methodInfo != null)
{
_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(CookingHook), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
((BaseUnityPlugin)this).Logger.LogInfo((object)("Patched synchronized cooking update: " + methodInfo.DeclaringType?.FullName + "." + methodInfo.Name));
}
else
{
((BaseUnityPlugin)this).Logger.LogError((object)"Could not find Item.OnCooknessChange.");
}
((BaseUnityPlugin)this).Logger.LogInfo((object)"Cooking Bell Timer 0.3.12 loaded.");
}
private void Update()
{
CookingTracker.Tick();
CookingOverlay.Tick();
BellAudio.Tick();
}
private void OnGUI()
{
if (OverlayEnabled.Value)
{
CookingOverlay.Draw();
}
}
private void OnDestroy()
{
try
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
catch
{
}
}
}
internal static class RuntimeTargets
{
internal static Type? ItemType;
private static PropertyInfo? _lastHolderProperty;
private static PropertyInfo? _localPlayerProperty;
private static FieldInfo? _localPlayerField;
internal static MethodInfo? ResolveCooknessChangedMethod()
{
ItemType = AccessTools.TypeByName("Item");
if (ItemType == null)
{
return null;
}
_lastHolderProperty = AccessTools.Property(ItemType, "LastHolder");
Type type = AccessTools.TypeByName("Player");
if (type != null)
{
_localPlayerProperty = type.GetProperty("LocalPlayer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
_localPlayerField = type.GetField("LocalPlayer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
if (_lastHolderProperty == null)
{
Plugin.Log.LogError((object)"Could not resolve Item.LastHolder.");
}
if (_localPlayerProperty == null && _localPlayerField == null)
{
Plugin.Log.LogError((object)"Could not resolve Player.LocalPlayer.");
}
else
{
Plugin.Log.LogInfo((object)"Resolved local player identity for per-player cooking timers.");
}
return AccessTools.Method(ItemType, "OnCooknessChange", new Type[3]
{
typeof(float),
typeof(float),
typeof(bool)
}, (Type[])null);
}
internal static bool WasCookedByLocalPlayer(object item)
{
if (item == null || _lastHolderProperty == null || (_localPlayerProperty == null && _localPlayerField == null))
{
return false;
}
object value = _lastHolderProperty.GetValue(item);
object obj = _localPlayerProperty?.GetValue(null) ?? _localPlayerField?.GetValue(null);
if (value != null && obj != null)
{
return value == obj;
}
return false;
}
}
}
