using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using HeatCooking.Core;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;
[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("HeatCooking")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+fbc75cb5c10e1fc8becd1288c3855066536c08fd")]
[assembly: AssemblyProduct("HeatCooking")]
[assembly: AssemblyTitle("HeatCooking")]
[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 HeatCooking
{
[BepInPlugin("jill920.heatcooking", "Heat Cooking", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
public static Plugin Instance;
public static ManualLogSource Log;
public static ConfigEntry<bool> DebugLogging;
public static ConfigEntry<float> CookSpeedMultiplier;
public static ConfigEntry<bool> CookHeldItems;
public static ConfigEntry<bool> CookBackpackItems;
public static ConfigEntry<float> MinimumCookSpeed;
private Harmony _harmony;
private bool _managerCreated = false;
private void Awake()
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Expected O, but got Unknown
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e7: Expected O, but got Unknown
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
DebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DebugLogging", false, "Enable detailed debug logging");
CookSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("General", "CookSpeedMultiplier", 10f, new ConfigDescription("Multiplier for cooking speed", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 100f), Array.Empty<object>()));
CookHeldItems = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "CookHeldItems", false, "Whether held items should also be cooked");
CookBackpackItems = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "CookBackpackItems", false, "Whether items inside backpacks should also be cooked");
MinimumCookSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("General", "MinimumCookSpeed", 0.01f, new ConfigDescription("Minimum cooking speed", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.001f, 1f), Array.Empty<object>()));
_harmony = new Harmony("jill920.heatcooking");
_harmony.PatchAll();
Log.LogInfo((object)"========================================");
Log.LogInfo((object)"[HeatCooking] LOADED v1.0.0");
Log.LogInfo((object)$" CookSpeedMultiplier: {CookSpeedMultiplier.Value}");
Log.LogInfo((object)$" CookHeldItems: {CookHeldItems.Value}");
Log.LogInfo((object)$" CookBackpackItems: {CookBackpackItems.Value}");
Log.LogInfo((object)$" MinimumCookSpeed: {MinimumCookSpeed.Value}");
Log.LogInfo((object)"========================================");
}
private void Update()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
if (_managerCreated || !PhotonNetwork.IsConnected)
{
return;
}
Scene activeScene = SceneManager.GetActiveScene();
string name = ((Scene)(ref activeScene)).name;
if (name.StartsWith("Level"))
{
_managerCreated = true;
if (PhotonNetwork.IsMasterClient)
{
GameObject val = new GameObject("HeatCookingManager");
val.AddComponent<HeatCookingManager>();
LogDebug("HeatCookingManager created (host)");
}
else
{
LogDebug("HeatCookingManager: Not host");
}
}
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
internal static void LogDebug(string message)
{
if (DebugLogging.Value && Log != null)
{
Log.LogInfo((object)("[DEBUG] " + message));
}
}
internal static void LogInfo(string message)
{
if (Log != null)
{
Log.LogInfo((object)("[INFO] " + message));
}
}
internal static void LogWarning(string message)
{
if (Log != null)
{
Log.LogWarning((object)("[WARN] " + message));
}
}
}
}
namespace HeatCooking.Patches
{
[HarmonyPatch]
internal static class Campfire_CookPatch
{
[HarmonyPatch(typeof(ItemCooking), "FinishCooking")]
[HarmonyPrefix]
private static void Prefix_FinishCooking(ItemCooking __instance)
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
Item val = ((ItemComponent)(__instance?)).item;
if (!((Object)(object)val == (Object)null))
{
Character trueHolderCharacter = val.trueHolderCharacter;
string text = (((Object)(object)trueHolderCharacter != (Object)null) ? trueHolderCharacter.characterName : "None");
object[] obj = new object[4]
{
val.UIData?.itemName ?? "Unknown",
text,
val.itemState,
null
};
PhotonView photonView = ((MonoBehaviourPun)val).photonView;
obj[3] = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
Plugin.LogDebug(string.Format("\ud83d\udd25\ud83d\udd25\ud83d\udd25 FinishCooking called on {0} (holder: {1}, state: {2}, photonView: {3})", obj));
}
}
[HarmonyPatch(typeof(ItemCooking), "EnableCookingSmokeRPC")]
[HarmonyPrefix]
private static void Prefix_EnableCookingSmokeRPC(ItemCooking __instance, bool active)
{
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
Item val = ((ItemComponent)(__instance?)).item;
if (!((Object)(object)val == (Object)null))
{
Character trueHolderCharacter = val.trueHolderCharacter;
string text = (((Object)(object)trueHolderCharacter != (Object)null) ? trueHolderCharacter.characterName : "None");
Plugin.LogDebug(string.Format("\ud83d\udca8\ud83d\udca8\ud83d\udca8 EnableCookingSmokeRPC called: active={0} on {1} (holder: {2}, state: {3})", active, val.UIData?.itemName ?? "Unknown", text, val.itemState));
}
}
[HarmonyPatch(typeof(ItemCooking), "FinishCookingRPC")]
[HarmonyPrefix]
private static void Prefix_FinishCookingRPC(ItemCooking __instance)
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
Item val = ((ItemComponent)(__instance?)).item;
if (!((Object)(object)val == (Object)null))
{
Character trueHolderCharacter = val.trueHolderCharacter;
string text = (((Object)(object)trueHolderCharacter != (Object)null) ? trueHolderCharacter.characterName : "None");
object[] obj = new object[4]
{
val.UIData?.itemName ?? "Unknown",
text,
val.itemState,
null
};
PhotonView photonView = ((MonoBehaviourPun)val).photonView;
obj[3] = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
Plugin.LogDebug(string.Format("\ud83d\udce1\ud83d\udce1\ud83d\udce1 FinishCookingRPC called on {0} (holder: {1}, state: {2}, photonView: {3})", obj));
}
}
[HarmonyPatch(typeof(Item), "SetCookedAmountRPC")]
[HarmonyPrefix]
private static void Prefix_SetCookedAmountRPC(Item __instance, int amount)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)__instance == (Object)null))
{
Character trueHolderCharacter = __instance.trueHolderCharacter;
string text = (((Object)(object)trueHolderCharacter != (Object)null) ? trueHolderCharacter.characterName : "None");
object[] obj = new object[5]
{
amount,
__instance.UIData?.itemName ?? "Unknown",
text,
__instance.itemState,
null
};
PhotonView photonView = ((MonoBehaviourPun)__instance).photonView;
obj[4] = ((photonView != null) ? new int?(photonView.ViewID) : ((int?)null));
Plugin.LogDebug(string.Format("\ud83c\udf73\ud83c\udf73\ud83c\udf73 SetCookedAmountRPC called: amount={0} on {1} (holder: {2}, state: {3}, photonView: {4})", obj));
}
}
[HarmonyPatch(typeof(ItemCooking), "UpdateCookedBehavior")]
[HarmonyPostfix]
private static void Postfix_UpdateCookedBehavior(ItemCooking __instance)
{
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
Item val = ((ItemComponent)(__instance?)).item;
if (!((Object)(object)val == (Object)null))
{
IntItemData data = val.GetData<IntItemData>((DataEntryKey)1);
if (data != null && data.Value > 0)
{
Character trueHolderCharacter = val.trueHolderCharacter;
string text = (((Object)(object)trueHolderCharacter != (Object)null) ? trueHolderCharacter.characterName : "None");
Plugin.LogDebug(string.Format("\ud83d\udd04 UpdateCookedBehavior: {0} now cooked to level {1} (holder: {2}, state: {3})", val.UIData?.itemName ?? "Unknown", data.Value, text, val.itemState));
}
}
}
}
[HarmonyPatch(typeof(CharacterItems), "EquipSlotRpc")]
internal static class EquipSlotRpcPatch
{
private static FieldInfo _characterField;
private static FieldInfo _currentSelectedSlotField;
static EquipSlotRpcPatch()
{
_characterField = typeof(CharacterItems).GetField("character", BindingFlags.Instance | BindingFlags.NonPublic);
_currentSelectedSlotField = typeof(CharacterItems).GetField("currentSelectedSlot", BindingFlags.Instance | BindingFlags.NonPublic);
}
[HarmonyPostfix]
private static void Postfix(CharacterItems __instance, int slotID, int objectViewID)
{
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Invalid comparison between Unknown and I4
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
if (!PhotonNetwork.IsMasterClient)
{
return;
}
Character val = null;
if (_characterField != null)
{
object? value = _characterField.GetValue(__instance);
val = (Character)((value is Character) ? value : null);
}
if ((Object)(object)val == (Object)null)
{
return;
}
Optionable<byte> val2 = Optionable<byte>.None;
if (_currentSelectedSlotField != null)
{
val2 = (Optionable<byte>)_currentSelectedSlotField.GetValue(__instance);
}
Item val3 = null;
foreach (Item aLL_ACTIVE_ITEM in Item.ALL_ACTIVE_ITEMS)
{
if ((Object)(object)aLL_ACTIVE_ITEM != (Object)null && ClassExtensionsMethods.UnityObjectExists<Item>(aLL_ACTIVE_ITEM) && (Object)(object)aLL_ACTIVE_ITEM.trueHolderCharacter == (Object)(object)val && (int)aLL_ACTIVE_ITEM.itemState == 1)
{
val3 = aLL_ACTIVE_ITEM;
break;
}
}
if ((Object)(object)val3 != (Object)null)
{
HeldItemTracker.SetHeldItem(val, val3);
Item heldItem = HeldItemTracker.GetHeldItem(val);
if ((Object)(object)heldItem != (Object)(object)val3)
{
Plugin.LogDebug(string.Format("\ud83d\udce6 Held item: {0} -> {1} (slot: {2})", val.characterName, val3.UIData?.itemName ?? "Unknown", val2));
}
}
else
{
HeldItemTracker.SetHeldItem(val, null);
Plugin.LogDebug($"\ud83d\udc50 {val.characterName} has empty hands (slot: {val2})");
}
}
}
[HarmonyPatch(typeof(StatusEmitter), "Update")]
internal static class StatusEmitter_UpdatePatch
{
private static HashSet<int> _loggedEmitters = new HashSet<int>();
[HarmonyPostfix]
private static void Postfix(StatusEmitter __instance)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Invalid comparison between Unknown and I4
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.DebugLogging.Value || (int)__instance.statusType != 8)
{
return;
}
int instanceID = ((Object)__instance).GetInstanceID();
if (_loggedEmitters.Contains(instanceID))
{
return;
}
bool flag = false;
MethodInfo method = typeof(StatusEmitter).GetMethod("InRange", BindingFlags.Instance | BindingFlags.NonPublic);
if (method != null)
{
try
{
flag = (bool)method.Invoke(__instance, null);
}
catch
{
}
}
if (flag)
{
_loggedEmitters.Add(instanceID);
Plugin.LogDebug($"Hot emitter active: {((Object)__instance).name}, amount: {__instance.amount}, radius: {__instance.radius}, pos: {((Component)__instance).transform.position:F2}");
}
}
}
}
namespace HeatCooking.Core
{
public class CookingTracker
{
private Dictionary<Item, float> _itemCookTime = new Dictionary<Item, float>();
private List<Item> _itemsToRemove = new List<Item>();
private HashSet<Item> _cookingItems = new HashSet<Item>();
private Dictionary<int, float> _savedProgress = new Dictionary<int, float>();
public int Count => _itemCookTime.Count;
public void Update(float deltaTime)
{
Cleanup();
}
public void Cleanup()
{
_itemsToRemove.Clear();
foreach (KeyValuePair<Item, float> item in _itemCookTime)
{
if ((Object)(object)item.Key == (Object)null || !ClassExtensionsMethods.UnityObjectExists<Item>(item.Key))
{
_itemsToRemove.Add(item.Key);
_cookingItems.Remove(item.Key);
}
}
foreach (Item item2 in _itemsToRemove)
{
_itemCookTime.Remove(item2);
}
}
public bool IsTracking(Item item)
{
return _itemCookTime.ContainsKey(item);
}
public float GetProgress(Item item)
{
float value;
return _itemCookTime.TryGetValue(item, out value) ? value : 0f;
}
public void AddTime(Item item, float time)
{
if ((Object)(object)item == (Object)null)
{
return;
}
float num = 0f;
if (_savedProgress.TryGetValue(((Object)item).GetInstanceID(), out var value))
{
num = value;
if (!_itemCookTime.ContainsKey(item))
{
_itemCookTime[item] = value;
Plugin.LogDebug(string.Format("\ud83d\udd04 Restored cooking progress for {0}: {1:F2}", item.UIData?.itemName ?? "Unknown", value));
}
}
if (!_itemCookTime.ContainsKey(item))
{
_itemCookTime[item] = 0f;
}
num = _itemCookTime[item];
_itemCookTime[item] += time;
_savedProgress[((Object)item).GetInstanceID()] = _itemCookTime[item];
if (num <= 0f && _itemCookTime[item] > 0f)
{
_cookingItems.Add(item);
StartCookingSmoke(item);
}
}
public bool IsComplete(Item item)
{
float value;
return _itemCookTime.TryGetValue(item, out value) && value >= 1f;
}
public void Reset(Item item)
{
if (!((Object)(object)item == (Object)null))
{
_itemCookTime.Remove(item);
_cookingItems.Remove(item);
_savedProgress.Remove(((Object)item).GetInstanceID());
StopCookingSmoke(item);
}
}
public void Remove(Item item)
{
if (!((Object)(object)item == (Object)null))
{
if (_itemCookTime.TryGetValue(item, out var value))
{
_savedProgress[((Object)item).GetInstanceID()] = value;
Plugin.LogDebug(string.Format("\ud83d\udcbe Saved cooking progress for {0}: {1:F2}", item.UIData?.itemName ?? "Unknown", value));
}
_itemCookTime.Remove(item);
_cookingItems.Remove(item);
StopCookingSmoke(item);
}
}
public bool TryGet(Item item, out float time)
{
return _itemCookTime.TryGetValue(item, out time);
}
public bool IsCooking(Item item)
{
return _cookingItems.Contains(item);
}
private void StartCookingSmoke(Item item)
{
if (!((Object)(object)item == (Object)null))
{
ItemCooking component = ((Component)item).GetComponent<ItemCooking>();
if ((Object)(object)component != (Object)null && (Object)(object)((MonoBehaviourPun)component).photonView != (Object)null)
{
((MonoBehaviourPun)component).photonView.RPC("EnableCookingSmokeRPC", (RpcTarget)0, new object[1] { true });
Plugin.LogDebug("\ud83d\udca8 Started cooking smoke for " + (item.UIData?.itemName ?? "Unknown"));
}
}
}
private void StopCookingSmoke(Item item)
{
if (!((Object)(object)item == (Object)null))
{
ItemCooking component = ((Component)item).GetComponent<ItemCooking>();
if ((Object)(object)component != (Object)null && (Object)(object)((MonoBehaviourPun)component).photonView != (Object)null)
{
((MonoBehaviourPun)component).photonView.RPC("EnableCookingSmokeRPC", (RpcTarget)0, new object[1] { false });
Plugin.LogDebug("\ud83d\udca8 Stopped cooking smoke for " + (item.UIData?.itemName ?? "Unknown"));
}
}
}
public void StopAllSmoke()
{
foreach (Item cookingItem in _cookingItems)
{
if ((Object)(object)cookingItem != (Object)null && ClassExtensionsMethods.UnityObjectExists<Item>(cookingItem))
{
ItemCooking component = ((Component)cookingItem).GetComponent<ItemCooking>();
if ((Object)(object)component != (Object)null && (Object)(object)((MonoBehaviourPun)component).photonView != (Object)null)
{
((MonoBehaviourPun)component).photonView.RPC("EnableCookingSmokeRPC", (RpcTarget)0, new object[1] { false });
}
}
}
_cookingItems.Clear();
}
public void UpdateSmokeForItem(Item item)
{
if (!((Object)(object)item == (Object)null))
{
bool flag = IsCooking(item);
float progress = GetProgress(item);
bool flag2 = progress > 0f && progress < 1f;
if (flag2 && !flag)
{
_cookingItems.Add(item);
StartCookingSmoke(item);
}
else if (!flag2 && flag)
{
_cookingItems.Remove(item);
StopCookingSmoke(item);
}
}
}
}
public class EmitterScanner
{
private List<StatusEmitter> _cachedEmitters = new List<StatusEmitter>();
private HashSet<string> _loggedEmitterIds = new HashSet<string>();
private bool _initialScanDone = false;
private List<StatusEmitter> _allFoundEmitters = new List<StatusEmitter>();
public int TotalCached => _cachedEmitters.Count;
public int ActiveCount => GetActiveEmitters().Count;
public List<StatusEmitter> GetActiveEmitters()
{
List<StatusEmitter> list = new List<StatusEmitter>();
foreach (StatusEmitter cachedEmitter in _cachedEmitters)
{
if ((Object)(object)cachedEmitter != (Object)null && ((Component)cachedEmitter).gameObject.activeInHierarchy)
{
list.Add(cachedEmitter);
}
}
return list;
}
public void Scan()
{
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Invalid comparison between Unknown and I4
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
//IL_0461: Unknown result type (might be due to invalid IL or missing references)
//IL_0467: Invalid comparison between Unknown and I4
//IL_0494: Unknown result type (might be due to invalid IL or missing references)
//IL_0499: Unknown result type (might be due to invalid IL or missing references)
//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
StatusEmitter[] array = Object.FindObjectsOfType<StatusEmitter>();
StatusEmitter[] array2 = Resources.FindObjectsOfTypeAll<StatusEmitter>();
List<StatusEmitter> list = new List<StatusEmitter>();
HashSet<int> hashSet = new HashSet<int>();
StatusEmitter[] array3 = array;
foreach (StatusEmitter val in array3)
{
if ((Object)(object)val != (Object)null && !hashSet.Contains(((Object)val).GetInstanceID()))
{
hashSet.Add(((Object)val).GetInstanceID());
list.Add(val);
}
}
StatusEmitter[] array4 = array2;
foreach (StatusEmitter val2 in array4)
{
if ((Object)(object)val2 != (Object)null && !hashSet.Contains(((Object)val2).GetInstanceID()))
{
hashSet.Add(((Object)val2).GetInstanceID());
list.Add(val2);
}
}
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
bool flag = !_initialScanDone;
Scene scene;
foreach (StatusEmitter item in list)
{
if ((Object)(object)item == (Object)null || (int)item.statusType != 8)
{
continue;
}
num++;
scene = ((Component)item).gameObject.scene;
string name = ((Scene)(ref scene)).name;
bool activeInHierarchy = ((Component)item).gameObject.activeInHierarchy;
float amount = item.amount;
Vector3 position = ((Component)item).transform.position;
string name2 = ((Object)item).name;
bool flag2 = activeInHierarchy || amount > 0.1f || name.StartsWith("Level");
if (flag && flag2)
{
Plugin.LogDebug($"FOUND: {name2} | pos: {position:F2} | active: {activeInHierarchy} | amount: {amount:F2} | scene: '{name}'");
}
if (!name.StartsWith("Level") && !string.IsNullOrEmpty(name))
{
num3++;
continue;
}
if (string.IsNullOrEmpty(name) && !activeInHierarchy)
{
num3++;
continue;
}
if (amount <= 0f)
{
num4++;
continue;
}
bool flag3 = false;
foreach (StatusEmitter cachedEmitter in _cachedEmitters)
{
if ((Object)(object)cachedEmitter == (Object)(object)item)
{
flag3 = true;
break;
}
}
if (!flag3)
{
_cachedEmitters.Add(item);
num2++;
Plugin.LogDebug($"✅ ADDED: {name2} at {position:F2}, active: {activeInHierarchy}, amount: {amount:F2}, scene: '{name}'");
}
}
if (!_initialScanDone)
{
_initialScanDone = true;
int activeCount = ActiveCount;
Plugin.LogInfo($"First scan: found {num} hot emitters, added {num2}, cached: {_cachedEmitters.Count}, active: {activeCount}");
Plugin.LogInfo($" Skipped: scene={num3}, amount={num4}");
}
else if (num2 > 0)
{
Plugin.LogInfo($"Scan: added {num2} new emitters, cached: {_cachedEmitters.Count}, active: {ActiveCount}");
}
if (num <= 0 || _cachedEmitters.Count != 0 || Time.frameCount % 120 != 0)
{
return;
}
Plugin.LogWarning($"Found {num} emitters but none were cached! Check scene names and amounts.");
int num5 = 0;
foreach (StatusEmitter item2 in list)
{
if (!((Object)(object)item2 == (Object)null))
{
if (num5 >= 5)
{
break;
}
if ((int)item2.statusType == 8)
{
num5++;
object[] obj = new object[4]
{
((Object)item2).name,
null,
null,
null
};
scene = ((Component)item2).gameObject.scene;
obj[1] = ((Scene)(ref scene)).name;
obj[2] = ((Component)item2).gameObject.activeInHierarchy;
obj[3] = item2.amount;
Plugin.LogDebug(string.Format(" Example: {0} | scene: '{1}' | active: {2} | amount: {3}", obj));
}
}
}
}
public void LogActiveEmitters()
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
List<StatusEmitter> activeEmitters = GetActiveEmitters();
if (activeEmitters.Count <= 0 || Time.frameCount % 60 != 0)
{
return;
}
Plugin.LogDebug($"Active emitters ({activeEmitters.Count}):");
foreach (StatusEmitter item in activeEmitters)
{
Plugin.LogDebug($" - {((Object)item).name} at {((Component)item).transform.position:F2}, radius: {item.radius}, amount: {item.amount}");
}
}
public void Clear()
{
_cachedEmitters.Clear();
_loggedEmitterIds.Clear();
_allFoundEmitters.Clear();
_initialScanDone = false;
}
}
public class HeatCookingManager : MonoBehaviour
{
private EmitterScanner _scanner;
private CookingTracker _tracker;
private ItemCooker _cooker;
private float _cookTimer = 0f;
private float _scanTimer = 0f;
private const float COOK_INTERVAL = 0.5f;
private const float SCAN_INTERVAL = 1f;
private int _logCounter = 0;
private void Start()
{
_scanner = new EmitterScanner();
_tracker = new CookingTracker();
_cooker = new ItemCooker(_tracker);
_scanner.Scan();
}
private void Update()
{
if (PhotonNetwork.IsMasterClient)
{
_scanTimer += Time.deltaTime;
if (_scanTimer > 1f)
{
_scanTimer = 0f;
_scanner.Scan();
}
_cookTimer += Time.deltaTime;
if (_cookTimer > 0.5f)
{
_cookTimer = 0f;
CookItems();
}
}
}
private void CookItems()
{
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Invalid comparison between Unknown and I4
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01a7: Invalid comparison between Unknown and I4
_tracker.Cleanup();
List<StatusEmitter> activeEmitters = _scanner.GetActiveEmitters();
HashSet<Item> processedItems = new HashSet<Item>();
if (Time.frameCount % 60 == 0)
{
_scanner.LogActiveEmitters();
}
if (Time.frameCount % 30 == 0)
{
int count = Item.ALL_ACTIVE_ITEMS.Count;
Plugin.LogDebug($"=== ALL_ACTIVE_ITEMS ({count} items), Active emitters: {activeEmitters.Count}/{_scanner.TotalCached} ===");
}
if (activeEmitters.Count == 0)
{
return;
}
int itemsInHeat = 0;
int itemsCooking = 0;
int itemsCompleted = 0;
foreach (Item aLL_ACTIVE_ITEM in Item.ALL_ACTIVE_ITEMS)
{
if (!((Object)(object)aLL_ACTIVE_ITEM == (Object)null) && ClassExtensionsMethods.UnityObjectExists<Item>(aLL_ACTIVE_ITEM) && (int)aLL_ACTIVE_ITEM.itemState == 0 && _cooker.ShouldCookItem(aLL_ACTIVE_ITEM))
{
float num = ProcessItemInHeatZone(aLL_ACTIVE_ITEM, activeEmitters, ref itemsInHeat, ref itemsCooking, processedItems);
if (num >= 1f)
{
itemsCompleted++;
}
}
}
if (Plugin.CookBackpackItems.Value)
{
foreach (Item aLL_ACTIVE_ITEM2 in Item.ALL_ACTIVE_ITEMS)
{
if (!((Object)(object)aLL_ACTIVE_ITEM2 == (Object)null) && ClassExtensionsMethods.UnityObjectExists<Item>(aLL_ACTIVE_ITEM2) && (int)aLL_ACTIVE_ITEM2.itemState == 2 && _cooker.ShouldCookItem(aLL_ACTIVE_ITEM2))
{
float num2 = ProcessItemInHeatZone(aLL_ACTIVE_ITEM2, activeEmitters, ref itemsInHeat, ref itemsCooking, processedItems);
if (num2 >= 1f)
{
itemsCompleted++;
}
}
}
}
if (Plugin.CookHeldItems.Value)
{
CookHeldItems(activeEmitters, processedItems, ref itemsCompleted);
}
_logCounter++;
if (_logCounter % 10 == 0 && (itemsInHeat > 0 || itemsCooking > 0))
{
Plugin.LogDebug($"Cooking summary: {itemsCooking} cooking, {itemsInHeat} in heat, {itemsCompleted} completed, {_tracker.Count} tracked");
}
}
private void CookHeldItems(List<StatusEmitter> activeEmitters, HashSet<Item> processedItems, ref int itemsCompleted)
{
//IL_00bd: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.CookHeldItems.Value || activeEmitters.Count == 0)
{
return;
}
HeldItemTracker.Cleanup();
int num = 0;
int num2 = 0;
foreach (KeyValuePair<Character, Item> allHeldItem in HeldItemTracker.GetAllHeldItems())
{
Character key = allHeldItem.Key;
Item value = allHeldItem.Value;
if ((Object)(object)key == (Object)null || (Object)(object)value == (Object)null || !ClassExtensionsMethods.UnityObjectExists<Item>(value) || !_cooker.ShouldCookItem(value) || processedItems.Contains(value))
{
continue;
}
Vector3 center = key.Center;
bool flag = false;
float num3 = float.MaxValue;
float num4 = 0f;
foreach (StatusEmitter activeEmitter in activeEmitters)
{
if ((Object)(object)activeEmitter == (Object)null)
{
continue;
}
float num5 = Vector3.Distance(center, ((Component)activeEmitter).transform.position);
float num6 = activeEmitter.radius + activeEmitter.outerFade;
if (num5 <= num6)
{
flag = true;
if (num5 < num3)
{
num3 = num5;
num4 = _cooker.GetCookSpeed(value, activeEmitter);
}
}
}
if (flag)
{
processedItems.Add(value);
num++;
if (num4 > 0.0001f)
{
float num7 = _cooker.CookItem(value, num4, 0.5f);
if (num7 >= 1f)
{
itemsCompleted++;
Plugin.LogDebug("✅ Client held item completed: " + (value.UIData?.itemName ?? "Unknown") + " held by " + key.characterName);
}
num2++;
}
}
else if (_tracker.IsTracking(value))
{
_tracker.Remove(value);
}
}
if (num > 0 || num2 > 0)
{
Plugin.LogDebug($"\ud83c\udf73 Client held items: {num2} cooking, {num} in heat");
}
}
private float ProcessItemInHeatZone(Item item, List<StatusEmitter> activeEmitters, ref int itemsInHeat, ref int itemsCooking, HashSet<Item> processedItems)
{
//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_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
if (processedItems.Contains(item))
{
return 0f;
}
bool flag = false;
float num = float.MaxValue;
float num2 = 0f;
Vector3 itemPosition = _cooker.GetItemPosition(item);
foreach (StatusEmitter activeEmitter in activeEmitters)
{
if (!((Object)(object)activeEmitter == (Object)null) && _cooker.IsItemInHeatZone(item, activeEmitter))
{
flag = true;
float num3 = Vector3.Distance(itemPosition, ((Component)activeEmitter).transform.position);
if (num3 < num)
{
num = num3;
num2 = _cooker.GetCookSpeed(item, activeEmitter);
}
}
}
if (flag)
{
processedItems.Add(item);
itemsInHeat++;
if (num2 > 0.0001f)
{
float num4 = _cooker.CookItem(item, num2, 0.5f);
if (num4 >= 1f)
{
itemsCooking++;
}
return num4;
}
}
else if (_tracker.IsTracking(item))
{
_tracker.Remove(item);
}
return 0f;
}
private void OnDestroy()
{
_scanner?.Clear();
_tracker?.StopAllSmoke();
}
}
public static class HeldItemTracker
{
private static Dictionary<int, Item> _heldItems = new Dictionary<int, Item>();
private static Dictionary<int, int> _heldItemViewIDs = new Dictionary<int, int>();
private static Dictionary<int, bool> _hasEmptyHands = new Dictionary<int, bool>();
public static int Count => _heldItems.Count;
public static void SetHeldItem(Character character, Item item)
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Invalid comparison between Unknown and I4
if ((Object)(object)character == (Object)null)
{
return;
}
int instanceID = ((Object)character).GetInstanceID();
Item value;
if ((Object)(object)item == (Object)null || !ClassExtensionsMethods.UnityObjectExists<Item>(item))
{
bool flag = false;
foreach (Item aLL_ACTIVE_ITEM in Item.ALL_ACTIVE_ITEMS)
{
if ((Object)(object)aLL_ACTIVE_ITEM != (Object)null && ClassExtensionsMethods.UnityObjectExists<Item>(aLL_ACTIVE_ITEM) && (Object)(object)aLL_ACTIVE_ITEM.trueHolderCharacter == (Object)(object)character && (int)aLL_ACTIVE_ITEM.itemState == 1)
{
flag = true;
_heldItems[instanceID] = aLL_ACTIVE_ITEM;
Dictionary<int, int> heldItemViewIDs = _heldItemViewIDs;
PhotonView photonView = ((MonoBehaviourPun)aLL_ACTIVE_ITEM).photonView;
heldItemViewIDs[instanceID] = ((photonView != null) ? photonView.ViewID : (-1));
_hasEmptyHands[instanceID] = false;
Plugin.LogDebug("\ud83d\udd0d Corrected held item for " + character.characterName + ": " + (aLL_ACTIVE_ITEM.UIData?.itemName ?? "Unknown"));
return;
}
}
if (!flag)
{
_heldItems.Remove(instanceID);
_heldItemViewIDs.Remove(instanceID);
_hasEmptyHands[instanceID] = true;
}
}
else if (_heldItems.TryGetValue(instanceID, out value) && (Object)(object)value != (Object)null && ((Object)value).GetInstanceID() == ((Object)item).GetInstanceID())
{
if ((Object)(object)((MonoBehaviourPun)item).photonView != (Object)null)
{
_heldItemViewIDs[instanceID] = ((MonoBehaviourPun)item).photonView.ViewID;
}
_hasEmptyHands[instanceID] = false;
}
else
{
_heldItems[instanceID] = item;
Dictionary<int, int> heldItemViewIDs2 = _heldItemViewIDs;
PhotonView photonView2 = ((MonoBehaviourPun)item).photonView;
heldItemViewIDs2[instanceID] = ((photonView2 != null) ? photonView2.ViewID : (-1));
_hasEmptyHands[instanceID] = false;
Plugin.LogDebug(string.Format("\ud83d\udce6 Held item tracked: {0} -> {1} (ViewID: {2})", character.characterName, item.UIData?.itemName ?? "Unknown", _heldItemViewIDs[instanceID]));
}
}
public static Item GetHeldItem(Character character)
{
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Invalid comparison between Unknown and I4
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Invalid comparison between Unknown and I4
if ((Object)(object)character == (Object)null)
{
return null;
}
int instanceID = ((Object)character).GetInstanceID();
if (_hasEmptyHands.TryGetValue(instanceID, out var value) && value)
{
foreach (Item aLL_ACTIVE_ITEM in Item.ALL_ACTIVE_ITEMS)
{
if ((Object)(object)aLL_ACTIVE_ITEM != (Object)null && ClassExtensionsMethods.UnityObjectExists<Item>(aLL_ACTIVE_ITEM) && (Object)(object)aLL_ACTIVE_ITEM.trueHolderCharacter == (Object)(object)character && (int)aLL_ACTIVE_ITEM.itemState == 1)
{
_heldItems[instanceID] = aLL_ACTIVE_ITEM;
Dictionary<int, int> heldItemViewIDs = _heldItemViewIDs;
PhotonView photonView = ((MonoBehaviourPun)aLL_ACTIVE_ITEM).photonView;
heldItemViewIDs[instanceID] = ((photonView != null) ? photonView.ViewID : (-1));
_hasEmptyHands[instanceID] = false;
return aLL_ACTIVE_ITEM;
}
}
return null;
}
if (_heldItems.TryGetValue(instanceID, out var value2))
{
if ((Object)(object)value2 == (Object)null || !ClassExtensionsMethods.UnityObjectExists<Item>(value2) || (Object)(object)value2.trueHolderCharacter != (Object)(object)character || (int)value2.itemState != 1)
{
_heldItems.Remove(instanceID);
_heldItemViewIDs.Remove(instanceID);
_hasEmptyHands[instanceID] = true;
return null;
}
return value2;
}
return null;
}
public static bool HasHeldItem(Character character)
{
if ((Object)(object)character == (Object)null)
{
return false;
}
return (Object)(object)GetHeldItem(character) != (Object)null;
}
public static IEnumerable<KeyValuePair<Character, Item>> GetAllHeldItems()
{
Cleanup();
foreach (KeyValuePair<int, Item> kvp in _heldItems)
{
Character character = null;
foreach (Character c in Character.AllCharacters)
{
if ((Object)(object)c != (Object)null && ((Object)c).GetInstanceID() == kvp.Key)
{
character = c;
break;
}
}
if ((Object)(object)character != (Object)null && (Object)(object)kvp.Value != (Object)null && ClassExtensionsMethods.UnityObjectExists<Item>(kvp.Value) && (Object)(object)kvp.Value.trueHolderCharacter == (Object)(object)character && (int)kvp.Value.itemState == 1)
{
yield return new KeyValuePair<Character, Item>(character, kvp.Value);
}
}
}
public static void Cleanup()
{
List<int> list = new List<int>();
foreach (KeyValuePair<int, Item> heldItem in _heldItems)
{
if ((Object)(object)heldItem.Value == (Object)null || !ClassExtensionsMethods.UnityObjectExists<Item>(heldItem.Value))
{
list.Add(heldItem.Key);
continue;
}
bool flag = false;
foreach (Character allCharacter in Character.AllCharacters)
{
if ((Object)(object)allCharacter != (Object)null && ((Object)allCharacter).GetInstanceID() == heldItem.Key)
{
flag = true;
break;
}
}
if (!flag)
{
list.Add(heldItem.Key);
}
}
foreach (int item in list)
{
_heldItems.Remove(item);
_heldItemViewIDs.Remove(item);
_hasEmptyHands.Remove(item);
}
}
public static void Clear()
{
_heldItems.Clear();
_heldItemViewIDs.Clear();
_hasEmptyHands.Clear();
Plugin.LogDebug("\ud83e\uddf9 All held items cleared");
}
}
public class ItemCooker
{
private CookingTracker _tracker;
public ItemCooker(CookingTracker tracker)
{
_tracker = tracker;
}
public bool ShouldCookItem(Item item)
{
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Invalid comparison between Unknown and I4
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Invalid comparison between Unknown and I4
if ((Object)(object)item == (Object)null)
{
return false;
}
ItemCooking component = ((Component)item).GetComponent<ItemCooking>();
if ((Object)(object)component == (Object)null)
{
return false;
}
if (!component.canBeCooked)
{
return false;
}
IntItemData data = item.GetData<IntItemData>((DataEntryKey)1);
if (data != null && data.Value >= 12)
{
return false;
}
if (!Plugin.CookHeldItems.Value && (int)item.itemState == 1)
{
return false;
}
if (!Plugin.CookBackpackItems.Value && (int)item.itemState == 2)
{
return false;
}
return true;
}
public List<Item> GetBackpackItems()
{
//IL_0169: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Invalid comparison between Unknown and I4
List<Item> list = new List<Item>();
if (!Plugin.CookBackpackItems.Value)
{
return list;
}
Backpack[] array = Object.FindObjectsByType<Backpack>((FindObjectsInactive)0, (FindObjectsSortMode)1);
Backpack[] array2 = array;
foreach (Backpack val in array2)
{
if ((Object)(object)val == (Object)null || !ClassExtensionsMethods.UnityObjectExists<Backpack>(val))
{
continue;
}
BackpackData data = ((Item)val).GetData<BackpackData>((DataEntryKey)7);
if (data == null)
{
continue;
}
for (int j = 0; j < data.itemSlots.Length; j++)
{
ItemSlot val2 = data.itemSlots[j];
if (val2 == null || val2.IsEmpty())
{
continue;
}
Item prefab = val2.prefab;
if ((Object)(object)prefab == (Object)null)
{
continue;
}
ItemCooking component = ((Component)prefab).GetComponent<ItemCooking>();
if ((Object)(object)component == (Object)null || !component.canBeCooked)
{
continue;
}
IntItemData data2 = prefab.GetData<IntItemData>((DataEntryKey)1);
if (data2 != null && data2.Value >= 12)
{
continue;
}
Item val3 = null;
foreach (Item aLL_ACTIVE_ITEM in Item.ALL_ACTIVE_ITEMS)
{
if ((Object)(object)aLL_ACTIVE_ITEM == (Object)null || !ClassExtensionsMethods.UnityObjectExists<Item>(aLL_ACTIVE_ITEM) || aLL_ACTIVE_ITEM.itemID != prefab.itemID || (int)aLL_ACTIVE_ITEM.itemState != 2)
{
continue;
}
FieldInfo field = typeof(Item).GetField("backpackReference", BindingFlags.Instance | BindingFlags.NonPublic);
if (!(field != null))
{
continue;
}
object value = field.GetValue(aLL_ACTIVE_ITEM);
if (value == null)
{
continue;
}
Type type = value.GetType();
FieldInfo field2 = type.GetField("view");
if (field2 != null)
{
object? value2 = field2.GetValue(value);
PhotonView val4 = (PhotonView)((value2 is PhotonView) ? value2 : null);
if ((Object)(object)val4 != (Object)null && (Object)(object)((Component)val4).GetComponent<Backpack>() == (Object)(object)val)
{
val3 = aLL_ACTIVE_ITEM;
break;
}
}
}
if ((Object)(object)val3 != (Object)null)
{
list.Add(val3);
}
}
}
return list;
}
public float GetCookSpeed(Item item, StatusEmitter emitter)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)emitter == (Object)null)
{
return 0f;
}
Vector3 itemPosition = GetItemPosition(item);
Vector3 position = ((Component)emitter).transform.position;
float num = Vector3.Distance(itemPosition, position);
float num2 = emitter.radius + emitter.outerFade;
float num3 = 1f - Mathf.Clamp01(num / num2);
if (emitter.innerFade > 0f && num < emitter.radius - emitter.innerFade)
{
num3 = 1f;
}
float num4 = Mathf.Abs(emitter.amount) * 2f;
float num5 = num4 * num3 * Plugin.CookSpeedMultiplier.Value;
if (num5 < Plugin.MinimumCookSpeed.Value)
{
num5 = Plugin.MinimumCookSpeed.Value;
}
return num5;
}
public Vector3 GetItemPosition(Item item)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: 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_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)item == (Object)null)
{
return Vector3.zero;
}
return item.Center();
}
public bool IsItemInHeatZone(Item item, StatusEmitter emitter)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: 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_0028: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)emitter == (Object)null)
{
return false;
}
Vector3 itemPosition = GetItemPosition(item);
Vector3 position = ((Component)emitter).transform.position;
float num = Vector3.Distance(itemPosition, position);
float num2 = emitter.radius + emitter.outerFade;
return num <= num2;
}
public float CookItem(Item item, float cookSpeed, float deltaTime)
{
if (!ShouldCookItem(item))
{
return 0f;
}
if (!_tracker.IsTracking(item))
{
_tracker.AddTime(item, 0f);
Plugin.LogDebug(string.Format("✅ Started cooking {0} (speed: {1:F4})", item.UIData?.itemName ?? "Unknown", cookSpeed));
}
_tracker.AddTime(item, cookSpeed * deltaTime);
_tracker.UpdateSmokeForItem(item);
float progress = _tracker.GetProgress(item);
if (progress >= 1f)
{
ApplyCookedState(item);
_tracker.Reset(item);
int cookedLevel = GetCookedLevel(item);
Plugin.LogInfo(string.Format("\ud83d\udd25 Item cooked: {0} (level: {1}/12)", item.UIData?.itemName ?? "Unknown", cookedLevel));
return 1f;
}
return progress;
}
private int GetCookedLevel(Item item)
{
return item.GetData<IntItemData>((DataEntryKey)1)?.Value ?? 0;
}
private void ApplyCookedState(Item item)
{
if ((Object)(object)item == (Object)null)
{
return;
}
ItemCooking component = ((Component)item).GetComponent<ItemCooking>();
if ((Object)(object)component == (Object)null)
{
return;
}
PhotonView photonView = ((MonoBehaviourPun)item).photonView;
if (!((Object)(object)photonView == (Object)null))
{
int num = item.GetData<IntItemData>((DataEntryKey)1)?.Value ?? 0;
if (num >= 12)
{
Plugin.LogDebug(string.Format("\ud83d\udcdd Item {0} already at max cooked amount ({1})", item.UIData?.itemName ?? "Unknown", num));
return;
}
photonView.RPC("FinishCookingRPC", (RpcTarget)0, Array.Empty<object>());
Plugin.LogDebug(string.Format("\ud83d\udce1 FinishCookingRPC called for {0} (level {1} -> {2})", item.UIData?.itemName ?? "Unknown", num, num + 1));
component.CancelCookingVisuals();
component.UpdateCookedBehavior();
}
}
}
}
