using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.Json;
using HarmonyLib;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(PickupTabOverlay), "Pickup Tab Overlay", "0.1.27", "kp0hyc", null)]
[assembly: MelonGame("Valko Game Studios", "Labyrinthine")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("PickupTabOverlay")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PickupTabOverlay")]
[assembly: AssemblyTitle("PickupTabOverlay")]
[assembly: AssemblyVersion("1.0.0.0")]
public class PickupTabOverlay : MelonMod
{
private readonly struct TmpOverlayModel
{
public readonly string Text;
public readonly float Width;
public readonly float Height;
public readonly int StyleKey;
public TmpOverlayModel(string text, float width, float height, int styleKey)
{
Text = text;
Width = width;
Height = height;
StyleKey = styleKey;
}
}
private readonly struct ObjectiveTextStyle
{
public static readonly ObjectiveTextStyle Fallback = new ObjectiveTextStyle(hasLiveStyle: false, "fallback", 30, 28, 24, null, null, null, null, null);
public readonly bool HasLiveStyle;
public readonly string Source;
public readonly int HeaderFontSize;
public readonly int RowFontSize;
public readonly int FooterFontSize;
public readonly object Color;
public readonly object MutedColor;
public readonly object Font;
public readonly object FontSharedMaterial;
public readonly object SourceText;
public int StyleKey => (((((((HeaderFontSize * 397) ^ RowFontSize) * 397) ^ FooterFontSize) * 397) ^ ((Font != null) ? RuntimeHelpers.GetHashCode(Font) : 0)) * 397) ^ ((FontSharedMaterial != null) ? RuntimeHelpers.GetHashCode(FontSharedMaterial) : 0);
public ObjectiveTextStyle(bool hasLiveStyle, string source, int headerFontSize, int rowFontSize, int footerFontSize, object color, object mutedColor, object font, object fontSharedMaterial, object sourceText)
{
HasLiveStyle = hasLiveStyle;
Source = source;
HeaderFontSize = headerFontSize;
RowFontSize = rowFontSize;
FooterFontSize = footerFontSize;
Color = color;
MutedColor = mutedColor;
Font = font;
FontSharedMaterial = fontSharedMaterial;
SourceText = sourceText;
}
public static ObjectiveTextStyle FromConfig(int headerFontSize, int rowFontSize, int footerFontSize, object color)
{
return new ObjectiveTextStyle(hasLiveStyle: false, "config", headerFontSize, rowFontSize, footerFontSize, color, CopyColorWithAlpha(color, 0.82f), null, null, null);
}
}
private readonly struct PickupEntry
{
public readonly int Id;
public readonly string Name;
public readonly int Count;
public readonly bool LeftHand;
public readonly bool RightHand;
public PickupEntry(int id, string name, int count, bool leftHand, bool rightHand)
{
Id = id;
Name = name;
Count = count;
LeftHand = leftHand;
RightHand = rightHand;
}
}
private readonly struct CollectibleEntry
{
public readonly string Label;
public readonly int Amount;
public CollectibleEntry(string label, int amount)
{
Label = label;
Amount = amount;
}
}
private readonly struct UnlockEntry
{
public readonly string Category;
public readonly string Name;
public readonly int Id;
public readonly string ItemClass;
public readonly int Count;
public UnlockEntry(string category, string name, int id, string itemClass, int count)
{
Category = category;
Name = name;
Id = id;
ItemClass = itemClass;
Count = count;
}
public UnlockEntry WithCount(int count)
{
return new UnlockEntry(Category, Name, Id, ItemClass, count);
}
}
private readonly struct ShandadaItemInfo
{
public readonly string Name;
public readonly string ItemClass;
public ShandadaItemInfo(string name, string itemClass)
{
Name = name;
ItemClass = itemClass;
}
}
private const string HarmonyId = "kp0hyc.pickuptaboverlay";
private const string PrefCategoryName = "PickupTabOverlay";
private const int MinimumReadableRowFontSize = 18;
private const int MinimumReadableFooterFontSize = 16;
private static readonly List<PickupEntry> s_entries = new List<PickupEntry>();
private static readonly Dictionary<string, int> s_collectiblesFound = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
private static readonly HashSet<int> s_countedCollectibles = new HashSet<int>();
private static readonly List<UnlockEntry> s_unlockEntries = new List<UnlockEntry>();
private static readonly Dictionary<string, int> s_unlockEntryIndexes = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
private static readonly HashSet<int> s_countedUnlockPickups = new HashSet<int>();
private static readonly HashSet<int> s_undiscoveredCosmeticItemIds = new HashSet<int>();
private static readonly Dictionary<int, string> s_customizationNameCache = new Dictionary<int, string>();
private static readonly Dictionary<int, string> s_customizationClassCache = new Dictionary<int, string>();
private static readonly Dictionary<int, ShandadaItemInfo> s_shandadaItems = new Dictionary<int, ShandadaItemInfo>();
private static MelonPreferences_Entry<bool> s_enabled;
private static MelonPreferences_Entry<int> s_panelWidth;
private static MelonPreferences_Entry<bool> s_showIds;
private static MelonPreferences_Entry<bool> s_showHandLabels;
private static MelonPreferences_Entry<bool> s_showEmptyMessage;
private static MelonPreferences_Entry<bool> s_showCollectibles;
private static MelonPreferences_Entry<bool> s_showUnlockPickups;
private static MelonPreferences_Entry<bool> s_debugLogging;
private static MelonPreferences_Entry<bool> s_legacyDebugLogging;
private static MelonPreferences_Entry<bool> s_useTextMeshProOverlay;
private static MelonPreferences_Entry<bool> s_useObjectiveTextStyle;
private static MelonPreferences_Entry<int> s_objectiveTextScalePercent;
private static MelonPreferences_Entry<int> s_headerFontSize;
private static MelonPreferences_Entry<int> s_rowFontSize;
private static MelonPreferences_Entry<int> s_footerFontSize;
private static MelonPreferences_Entry<int> s_maxVisibleItems;
private static DateTime s_nextRefreshUtc = DateTime.MinValue;
private static DateTime s_nextWarningUtc = DateTime.MinValue;
private static DateTime s_nextObjectiveStyleRefreshUtc = DateTime.MinValue;
private static DateTime s_nextTmpOverlayRetryUtc = DateTime.MinValue;
private static DateTime s_nextTmpDiagnosticsUtc = DateTime.MinValue;
private static ObjectiveTextStyle s_objectiveTextStyle = ObjectiveTextStyle.Fallback;
private static string s_lastLoggedObjectiveStyleSignature;
private static string s_lastLoggedRendererSignature;
private static string s_lastLoggedTmpSourceSignature;
private static string s_lastLoggedTmpDiagnosticsSignature;
private static string s_lastLoggedTmpLayoutSignature;
private static string s_lastLoggedDirectTmpFailure;
private static bool s_tmpOverlayReady;
private static bool s_tmpOverlayFailed;
private static bool s_tmpOverlayVisible;
private static bool s_loggedTmpOverlayReady;
private static bool s_tmpOverlayUsesDirectUi;
private static bool s_shandadaItemsLoaded;
private static string s_tmpLastText;
private static int s_tmpLastStyleKey;
private static float s_tmpLastWidth;
private static float s_tmpLastHeight;
private static Type s_rectType;
private static Type s_colorType;
private static Type s_vector2Type;
private static Type s_guiType;
private static Type s_screenType;
private static Type s_inputType;
private static Type s_keyCodeType;
private static Type s_labyrinthineInputManagerType;
private static Type s_inputButtonType;
private static Type s_playerNetworkSyncType;
private static Type s_gameManagerType;
private static Type s_objectType;
private static Type s_rndPlayerInventoryType;
private static Type s_rndCollectibleType;
private static Type s_customizationPickupType;
private static Type s_customCaseItemUnlockType;
private static Type s_customizationManagerType;
private static Type s_localisationManagerType;
private static Type s_objectiveUiType;
private static Type s_tmpTextType;
private static Type s_tmpFontAssetType;
private static Type s_canvasType;
private static Type s_componentType;
private static Type s_gameObjectType;
private static Type s_transformType;
private static Type s_rectTransformType;
private static Type s_resourcesType;
private static Type s_textMeshProUguiType;
private static Type s_renderModeType;
private static Type s_textAlignmentOptionsType;
private static Type s_textOverflowModesType;
private static ConstructorInfo s_rectCtor;
private static ConstructorInfo s_colorCtor;
private static ConstructorInfo s_vector2Ctor;
private static ConstructorInfo s_gameObjectCtor;
private static ConstructorInfo s_gameObjectWithComponentsCtor;
private static MethodInfo s_guiLabel;
private static MethodInfo s_inputGetKey;
private static MethodInfo s_gameGetButton;
private static MethodInfo s_findObjectsOfTypeMethod;
private static MethodInfo s_componentGetComponentInParentMethod;
private static MethodInfo s_gameObjectGetComponentMethod;
private static MethodInfo s_gameObjectAddComponentMethod;
private static MethodInfo s_gameObjectSetActiveMethod;
private static MethodInfo s_transformSetParentMethod;
private static MethodInfo s_transformSetAsLastSiblingMethod;
private static MethodInfo s_objectInstantiateMethod;
private static MethodInfo s_objectDestroyMethod;
private static MethodInfo s_objectDontDestroyOnLoadMethod;
private static MethodInfo s_resourcesFindObjectsOfTypeAllMethod;
private static PropertyInfo s_guiColorProperty;
private static PropertyInfo s_screenWidthProperty;
private static PropertyInfo s_screenHeightProperty;
private static PropertyInfo s_guiSkinProperty;
private static PropertyInfo s_guiSkinLabelProperty;
private static PropertyInfo s_styleFontSizeProperty;
private static PropertyInfo s_styleNormalProperty;
private static PropertyInfo s_styleStateTextColorProperty;
private static object s_keyCodeTab;
private static object s_showTabMenuButton;
private static object s_tmpOverlayRoot;
private static object s_tmpOverlayTextObject;
private static object s_tmpOverlayText;
private static object s_tmpOverlayRectTransform;
private static object s_larkeSansFont;
private static bool s_reflectionReady;
public override void OnInitializeMelon()
{
MelonPreferences_Category obj = MelonPreferences.CreateCategory("PickupTabOverlay");
s_enabled = obj.CreateEntry<bool>("Enabled", true, "Show local pickup inventory while the tab menu is open.", (string)null, false, false, (ValueValidator)null, (string)null);
s_panelWidth = obj.CreateEntry<int>("PanelWidth", 320, "Pickup panel width in pixels.", (string)null, false, false, (ValueValidator)null, (string)null);
s_showIds = obj.CreateEntry<bool>("ShowItemIDs", true, "Show random-case item IDs next to pickup names.", (string)null, false, false, (ValueValidator)null, (string)null);
s_showHandLabels = obj.CreateEntry<bool>("ShowHandLabels", true, "Mark currently selected left/right hand pickup items.", (string)null, false, false, (ValueValidator)null, (string)null);
s_showEmptyMessage = obj.CreateEntry<bool>("ShowEmptyMessage", true, "Show a small message when no pickups are held.", (string)null, false, false, (ValueValidator)null, (string)null);
s_showCollectibles = obj.CreateEntry<bool>("ShowCollectibles", true, "Show random-case collectibles picked up during the current run.", (string)null, false, false, (ValueValidator)null, (string)null);
s_showUnlockPickups = obj.CreateEntry<bool>("ShowUnlockPickups", true, "Show cosmetic, blueprint, and stamp pickups during the current run.", (string)null, false, false, (ValueValidator)null, (string)null);
s_legacyDebugLogging = obj.CreateEntry<bool>("DebugLogging", false, "Legacy pickup overlay diagnostics flag.", (string)null, false, false, (ValueValidator)null, (string)null);
s_debugLogging = obj.CreateEntry<bool>("VerboseLogs", false, "Log pickup overlay diagnostics for troubleshooting.", (string)null, false, false, (ValueValidator)null, (string)null);
s_useTextMeshProOverlay = obj.CreateEntry<bool>("UseTextMeshProOverlay", true, "Draw the pickup panel using TextMeshPro instead of IMGUI.", (string)null, false, false, (ValueValidator)null, (string)null);
s_useObjectiveTextStyle = obj.CreateEntry<bool>("UseObjectiveTextStyle", true, "Use the game's live objective text size and color when available.", (string)null, false, false, (ValueValidator)null, (string)null);
s_objectiveTextScalePercent = obj.CreateEntry<int>("ObjectiveTextScalePercent", 100, "Multiplier for objective-derived pickup overlay text size.", (string)null, false, false, (ValueValidator)null, (string)null);
s_headerFontSize = obj.CreateEntry<int>("HeaderFontSize", 30, "Pickup panel header font size.", (string)null, false, false, (ValueValidator)null, (string)null);
s_rowFontSize = obj.CreateEntry<int>("RowFontSize", 28, "Pickup panel row font size.", (string)null, false, false, (ValueValidator)null, (string)null);
s_footerFontSize = obj.CreateEntry<int>("FooterFontSize", 24, "Pickup panel footer font size.", (string)null, false, false, (ValueValidator)null, (string)null);
s_maxVisibleItems = obj.CreateEntry<int>("MaxVisibleItems", 12, "Maximum pickup rows to show before collapsing the rest.", (string)null, false, false, (ValueValidator)null, (string)null);
TryPatchCollectiblePickup();
TryPatchCustomizationPickup();
TryPatchCustomCaseItemUnlock();
LogDebug("PickupTabOverlay initialized.");
}
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
{
DestroyTmpOverlay();
s_entries.Clear();
s_collectiblesFound.Clear();
s_countedCollectibles.Clear();
s_unlockEntries.Clear();
s_unlockEntryIndexes.Clear();
s_countedUnlockPickups.Clear();
s_undiscoveredCosmeticItemIds.Clear();
s_nextRefreshUtc = DateTime.MinValue;
s_nextObjectiveStyleRefreshUtc = DateTime.MinValue;
s_objectiveTextStyle = ObjectiveTextStyle.Fallback;
s_lastLoggedObjectiveStyleSignature = null;
s_lastLoggedRendererSignature = null;
s_lastLoggedTmpSourceSignature = null;
s_lastLoggedTmpDiagnosticsSignature = null;
s_lastLoggedTmpLayoutSignature = null;
s_lastLoggedDirectTmpFailure = null;
s_nextTmpDiagnosticsUtc = DateTime.MinValue;
}
private static void TryPatchCollectiblePickup()
{
//IL_0033: 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_005d: Expected O, but got Unknown
try
{
MethodInfo methodInfo = GetRndCollectibleType()?.GetMethod("Pickup", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (methodInfo == null)
{
MelonLogger.Warning("Could not find RndCollectible.Pickup; random collectibles will not be tracked.");
return;
}
new Harmony("kp0hyc.pickuptaboverlay").Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PickupTabOverlay).GetMethod("RndCollectiblePickupPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
LogDebug("Patched RndCollectible.Pickup for collectible tracking.");
}
catch (Exception ex)
{
MelonLogger.Warning("Could not patch RndCollectible.Pickup: " + ex.GetType().Name + " " + ex.Message);
}
}
private static void TryPatchCustomizationPickup()
{
//IL_0033: 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_005d: Expected O, but got Unknown
try
{
MethodInfo methodInfo = GetCustomizationPickupType()?.GetMethod("Pickup", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (methodInfo == null)
{
MelonLogger.Warning("Could not find CustomizationPickup.Pickup; cosmetic pickups will not be tracked.");
return;
}
new Harmony("kp0hyc.pickuptaboverlay").Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PickupTabOverlay).GetMethod("CustomizationPickupPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
LogDebug("Patched CustomizationPickup.Pickup for cosmetic tracking.");
}
catch (Exception ex)
{
MelonLogger.Warning("Could not patch CustomizationPickup.Pickup: " + ex.GetType().Name + " " + ex.Message);
}
}
private static void TryPatchCustomCaseItemUnlock()
{
//IL_0033: 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_005d: Expected O, but got Unknown
try
{
MethodInfo methodInfo = GetCustomCaseItemUnlockType()?.GetMethod("Pickup", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (methodInfo == null)
{
MelonLogger.Warning("Could not find CustomCaseItemUnlock.Pickup; blueprint/stamp pickups will not be tracked.");
return;
}
new Harmony("kp0hyc.pickuptaboverlay").Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PickupTabOverlay).GetMethod("CustomCaseItemUnlockPrefix", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
LogDebug("Patched CustomCaseItemUnlock.Pickup for blueprint/stamp tracking.");
}
catch (Exception ex)
{
MelonLogger.Warning("Could not patch CustomCaseItemUnlock.Pickup: " + ex.GetType().Name + " " + ex.Message);
}
}
private static void RndCollectiblePickupPrefix(object __instance)
{
try
{
if (__instance == null)
{
return;
}
int hashCode = RuntimeHelpers.GetHashCode(__instance);
if (!s_countedCollectibles.Contains(hashCode) && TryClassifyCollectible(__instance, out var label, out var amount))
{
s_countedCollectibles.Add(hashCode);
if (!s_collectiblesFound.TryGetValue(label, out var value))
{
value = 0;
}
s_collectiblesFound[label] = value + amount;
}
}
catch (Exception ex)
{
LogWarning("collectible pickup tracking failed: " + ex.GetType().Name + " " + ex.Message);
}
}
private static void CustomizationPickupPrefix(object __instance)
{
try
{
if (__instance == null)
{
return;
}
int hashCode = RuntimeHelpers.GetHashCode(__instance);
if (!s_countedUnlockPickups.Contains(hashCode) && TryConvertInt(GetFieldOrProp(__instance, "ItemID") ?? GetFieldOrProp(__instance, "itemID"), out var result))
{
s_countedUnlockPickups.Add(hashCode);
bool flag = IsCustomizationItemAlreadyUnlocked(result);
if (!flag)
{
s_undiscoveredCosmeticItemIds.Add(result);
}
string text = (s_undiscoveredCosmeticItemIds.Contains(result) ? "Undiscovered item" : ResolveCustomizationName(result));
if (string.IsNullOrWhiteSpace(text))
{
text = CleanPickupObjectName(__instance, "Cosmetic");
}
string text2 = ResolveCustomizationClass(result);
AddUnlockEntry("Cosmetic", text, result, text2);
LogDebug("Cosmetic pickup itemID=" + result + " alreadyUnlocked=" + flag + " class=" + (text2 ?? "{unknown}") + " name=" + text);
}
}
catch (Exception ex)
{
LogWarning("cosmetic pickup tracking failed: " + ex.GetType().Name + " " + ex.Message);
}
}
private static void CustomCaseItemUnlockPrefix(object __instance)
{
try
{
if (__instance == null)
{
return;
}
int hashCode = RuntimeHelpers.GetHashCode(__instance);
if (!s_countedUnlockPickups.Contains(hashCode))
{
bool flag = false;
bool flag2 = false;
if (TryConvertBool(GetFieldOrProp(__instance, "unlockMazeType"), out var result) && result)
{
object fieldOrProp = GetFieldOrProp(__instance, "mazeType");
AddUnlockEntry("Map Blueprint", "Picked up", -1);
LogDebug("Map blueprint pickup mazeType=" + FormatEnumValue(fieldOrProp, "Map"));
flag = true;
flag2 = true;
}
if (TryConvertBool(GetFieldOrProp(__instance, "unlockMonsterType"), out var result2) && result2)
{
object fieldOrProp2 = GetFieldOrProp(__instance, "monsterType");
LogDebug("Unexpected monster blueprint pickup monsterType=" + FormatEnumValue(fieldOrProp2, "Monster"));
flag = true;
}
if (TryConvertBool(GetFieldOrProp(__instance, "unlockContractType"), out var result3) && result3)
{
object fieldOrProp3 = GetFieldOrProp(__instance, "contractType");
AddUnlockEntry("Stamps", "Collected", -1);
LogDebug("Stamp pickup contractType=" + FormatEnumValue(fieldOrProp3, "Contract"));
flag = true;
flag2 = true;
}
if (!flag)
{
AddUnlockEntry("Blueprint", CleanPickupObjectName(__instance, "Custom Case Unlock"), -1);
flag2 = true;
LogDebug("Unknown custom-case unlock pickup name=" + CleanPickupObjectName(__instance, "Custom Case Unlock"));
}
else if (!flag2)
{
LogDebug("Custom-case unlock pickup had no visible overlay row.");
}
s_countedUnlockPickups.Add(hashCode);
}
}
catch (Exception ex)
{
LogWarning("blueprint/stamp pickup tracking failed: " + ex.GetType().Name + " " + ex.Message);
}
}
private static bool TryClassifyCollectible(object collectible, out string label, out int amount)
{
label = null;
if (!TryConvertInt(GetFieldOrProp(collectible, "amount"), out amount) || amount <= 0)
{
amount = 1;
}
object fieldOrProp = GetFieldOrProp(collectible, "collectibleType");
string text = ((fieldOrProp == null) ? string.Empty : fieldOrProp.ToString());
string collectibleObjectName = GetCollectibleObjectName(collectible);
string text2 = (text + " " + collectibleObjectName + " " + (GetFieldOrProp(collectible, "pickupMessage") ?? string.Empty)).ToLowerInvariant();
if (text2.Contains("ticket"))
{
label = "Tickets";
return true;
}
if (text.IndexOf("Reroll", StringComparison.OrdinalIgnoreCase) >= 0 || text2.Contains("reroll"))
{
label = "Reroll Coins";
return true;
}
return false;
}
private static string GetCollectibleObjectName(object collectible)
{
string text = GetFieldOrProp(GetFieldOrProp(collectible, "gameObject") ?? collectible, "name") as string;
if (!string.IsNullOrWhiteSpace(text))
{
return text;
}
return string.Empty;
}
private static void AddUnlockEntry(string category, string name, int id, string itemClass = null)
{
if (string.IsNullOrWhiteSpace(category))
{
category = "Unlock";
}
if (string.IsNullOrWhiteSpace(name))
{
name = "Unknown";
}
name = CleanUnityName(name);
itemClass = FormatItemClass(itemClass);
string key = category + "|" + id + "|" + itemClass + "|" + name;
if (s_unlockEntryIndexes.TryGetValue(key, out var value) && value >= 0 && value < s_unlockEntries.Count)
{
s_unlockEntries[value] = s_unlockEntries[value].WithCount(s_unlockEntries[value].Count + 1);
return;
}
s_unlockEntryIndexes[key] = s_unlockEntries.Count;
s_unlockEntries.Add(new UnlockEntry(category, name, id, itemClass, 1));
}
private static string ResolveCustomizationName(int itemId)
{
if (s_customizationNameCache.TryGetValue(itemId, out var value))
{
return value;
}
string text = null;
if (TryGetShandadaItemInfo(itemId, out var info) && !string.IsNullOrWhiteSpace(info.Name))
{
text = info.Name;
}
object obj = TryGetCustomizationItem(itemId);
if (obj != null && string.IsNullOrWhiteSpace(text))
{
text = GetFieldOrProp(obj, "Name") as string;
if (string.IsNullOrWhiteSpace(text))
{
text = GetLocalisation(GetFieldOrProp(obj, "LocalisationKey") as string, null);
}
}
if (!string.IsNullOrWhiteSpace(text))
{
s_customizationNameCache[itemId] = text;
return text;
}
return null;
}
private static object TryGetCustomizationItem(int itemId)
{
try
{
object customizationCollection = GetCustomizationCollection();
if (customizationCollection == null || itemId < 0 || itemId > 65535)
{
return null;
}
MethodInfo methodInfo = customizationCollection.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "TryGetItem" && m.GetParameters().Length == 2);
if (methodInfo == null)
{
return null;
}
object[] array = new object[2]
{
(ushort)itemId,
null
};
if (TryConvertBool(methodInfo.Invoke(customizationCollection, array), out var result) && result)
{
return array[1];
}
}
catch
{
}
return null;
}
private static string ResolveCustomizationClass(int itemId)
{
if (s_customizationClassCache.TryGetValue(itemId, out var value))
{
return value;
}
string text = null;
if (TryGetShandadaItemInfo(itemId, out var info))
{
text = info.ItemClass;
}
if (string.IsNullOrWhiteSpace(text))
{
object obj = TryGetCustomizationItem(itemId);
text = (GetFieldOrProp(obj, "ItemRarity") ?? GetFieldOrProp(obj, "itemRarity"))?.ToString();
}
text = FormatItemClass(text);
if (!string.IsNullOrWhiteSpace(text))
{
s_customizationClassCache[itemId] = text;
}
return text;
}
private static bool TryGetShandadaItemInfo(int itemId, out ShandadaItemInfo info)
{
EnsureShandadaItemsLoaded();
return s_shandadaItems.TryGetValue(itemId, out info);
}
private static void EnsureShandadaItemsLoaded()
{
if (s_shandadaItemsLoaded)
{
return;
}
s_shandadaItemsLoaded = true;
try
{
Assembly assembly = typeof(PickupTabOverlay).Assembly;
string text = assembly.GetManifestResourceNames().FirstOrDefault((string name) => name.EndsWith("shandada_game_item_id_map.json", StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrWhiteSpace(text))
{
LogDebug("Embedded Shandadapanda item map was not found.");
return;
}
using Stream stream = assembly.GetManifestResourceStream(text);
if (stream == null)
{
return;
}
using JsonDocument jsonDocument = JsonDocument.Parse(stream);
if (!jsonDocument.RootElement.TryGetProperty("gameToWebsite", out var value) || value.ValueKind != JsonValueKind.Array)
{
return;
}
foreach (JsonElement item in value.EnumerateArray())
{
if (TryGetJsonInt(item, "gameItemId", out var value2) && value2 >= 0)
{
string jsonString = GetJsonString(item, "websiteName");
string text2 = GetJsonString(item, "class") ?? GetJsonString(item, "websiteMapClass") ?? GetJsonString(item, "websiteEvent");
if (!string.IsNullOrWhiteSpace(jsonString) || !string.IsNullOrWhiteSpace(text2))
{
s_shandadaItems[value2] = new ShandadaItemInfo(jsonString, text2);
}
}
}
LogDebug("Loaded " + s_shandadaItems.Count + " Shandadapanda item names.");
}
catch (Exception ex)
{
LogWarning("Shandadapanda item map load failed: " + ex.GetType().Name + " " + ex.Message);
}
}
private static bool TryGetJsonInt(JsonElement element, string name, out int value)
{
value = 0;
if (!element.TryGetProperty(name, out var value2))
{
return false;
}
if (value2.ValueKind == JsonValueKind.Number)
{
return value2.TryGetInt32(out value);
}
if (value2.ValueKind == JsonValueKind.String)
{
return int.TryParse(value2.GetString(), out value);
}
return false;
}
private static string GetJsonString(JsonElement element, string name)
{
if (!element.TryGetProperty(name, out var value) || value.ValueKind != JsonValueKind.String)
{
return null;
}
return value.GetString();
}
private static string FormatItemClass(string itemClass)
{
if (string.IsNullOrWhiteSpace(itemClass))
{
return null;
}
itemClass = itemClass.Trim();
int num = itemClass.LastIndexOf('.');
if (num >= 0 && num + 1 < itemClass.Length)
{
itemClass = itemClass.Substring(num + 1);
}
itemClass = CleanUnityName(itemClass).Trim();
if (!string.IsNullOrWhiteSpace(itemClass))
{
return itemClass.ToLowerInvariant();
}
return null;
}
private static object GetCustomizationCollection()
{
object customizationManager = GetCustomizationManager();
return GetFieldOrProp(customizationManager, "Collection") ?? GetFieldOrProp(customizationManager, "collection");
}
private static object GetCustomizationManager()
{
Type customizationManagerType = GetCustomizationManagerType();
return GetStaticFieldOrProp(customizationManagerType, "Instance") ?? FindFirstObjectOfType(customizationManagerType);
}
private static bool IsCustomizationItemAlreadyUnlocked(int itemId)
{
if (itemId < 0 || itemId > 65535)
{
return false;
}
if (TryIsCustomizationItemUnlocked(GetCurrentCustomizationSave(), itemId, out var unlocked))
{
return unlocked;
}
if (TryUnlockedItemsListContains(GetFieldOrProp(GetCustomizationManager(), "UnlockedItems"), itemId, out unlocked))
{
return unlocked;
}
LogDebug("Could not determine cosmetic unlock state for itemID=" + itemId + "; hiding name.");
return false;
}
private static bool TryIsCustomizationItemUnlocked(object customizationSave, int itemId, out bool unlocked)
{
unlocked = false;
if (customizationSave == null || itemId < 0 || itemId > 65535)
{
return false;
}
try
{
return TryConvertBool(customizationSave.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "IsItemUnlocked" && m.GetParameters().Length == 1)?.Invoke(customizationSave, new object[1] { (ushort)itemId }), out unlocked);
}
catch
{
unlocked = false;
return false;
}
}
private static bool TryUnlockedItemsListContains(object list, int itemId, out bool unlocked)
{
unlocked = false;
if (list == null)
{
return false;
}
foreach (object item in EnumerateItems(list))
{
if (TryConvertInt(item, out var result) && result == itemId)
{
unlocked = true;
return true;
}
}
return true;
}
private static object GetCurrentCustomizationSave()
{
return GetFieldOrProp(GetCustomizationManager(), "CustomizationSave");
}
private static object LoadCustomizationSave()
{
try
{
return (FindType("CharacterCustomization.CustomizationSave")?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "Load" && m.GetParameters().Length == 0))?.Invoke(null, Array.Empty<object>());
}
catch
{
return null;
}
}
private static string GetLocalisation(string key, string defaultValue)
{
if (string.IsNullOrWhiteSpace(key))
{
return defaultValue;
}
try
{
string text = (GetLocalisationManagerType()?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "GetLocalisation" && m.GetParameters().Length == 2))?.Invoke(null, new object[2] { key, defaultValue }) as string;
return string.IsNullOrWhiteSpace(text) ? defaultValue : text;
}
catch
{
return defaultValue;
}
}
private static string FormatEnumValue(object value, string fallback)
{
if (value == null)
{
return fallback;
}
string text = value.ToString();
if (string.IsNullOrWhiteSpace(text))
{
return fallback;
}
return CleanUnityName(text);
}
private static string CleanPickupObjectName(object pickup, string fallback)
{
string text = GetFieldOrProp(GetFieldOrProp(pickup, "gameObject") ?? pickup, "name") as string;
if (string.IsNullOrWhiteSpace(text))
{
return fallback;
}
string text2 = CleanUnityName(text);
if (text2.StartsWith("CPickup - ", StringComparison.OrdinalIgnoreCase))
{
text2 = text2.Substring("CPickup - ".Length).Trim();
}
if (!string.IsNullOrWhiteSpace(text2))
{
return text2;
}
return fallback;
}
public override void OnUpdate()
{
if (s_enabled == null || !s_enabled.Value)
{
SetTmpOverlayVisible(visible: false);
return;
}
DateTime utcNow = DateTime.UtcNow;
if (utcNow >= s_nextRefreshUtc)
{
s_nextRefreshUtc = utcNow.AddMilliseconds(250.0);
try
{
RefreshPickupEntries();
}
catch (Exception ex)
{
LogWarning("pickup refresh failed: " + ex.GetType().Name + " " + ex.Message);
}
}
try
{
UpdateTmpOverlay();
}
catch (Exception ex2)
{
ResetTmpOverlayState(failed: false);
LogWarning("TextMeshPro pickup overlay update failed: " + ex2.GetType().Name + " " + ex2.Message);
}
}
public override void OnGUI()
{
if (s_enabled == null || !s_enabled.Value || !EnsureReflection() || !IsTabMenuPressed() || (!HasAnyDisplayedPickup() && (s_showEmptyMessage == null || !s_showEmptyMessage.Value)) || (IsTextMeshProOverlayEnabled() && s_tmpOverlayReady))
{
return;
}
try
{
DrawPickupPanel();
}
catch (Exception ex)
{
LogWarning("pickup overlay draw failed: " + ex.GetType().Name + " " + ex.Message);
}
}
private static void RefreshPickupEntries()
{
s_entries.Clear();
}
private static void DrawPickupPanel()
{
int val = Clamp((s_maxVisibleItems == null) ? 12 : s_maxVisibleItems.Value, 1, 40);
ObjectiveTextStyle textStyle = ResolveTextStyle();
LogOverlayRenderer("IMGUI fallback", GetFallbackRendererReason() + " " + DescribeTextStyleForLog(textStyle));
List<CollectibleEntry> collectibleRows = GetCollectibleRows();
List<UnlockEntry> unlockRows = GetUnlockRows();
float width = ResolveOverlayWidth(unlockRows);
int num = Math.Min(s_entries.Count, val);
float singleRowHeight = GetSingleRowHeight(textStyle.RowFontSize);
float num2 = ((s_entries.Count > num) ? Math.Max(20f, (float)textStyle.FooterFontSize + 8f) : 0f);
float num3 = collectibleRows.Sum((CollectibleEntry row) => EstimateDisplayRowHeight(row.Label + ": " + row.Amount, textStyle.RowFontSize, width));
float num4 = unlockRows.Sum((UnlockEntry row) => EstimateDisplayRowHeight(FormatUnlockEntry(row), textStyle.RowFontSize, width));
float num5 = ((!HasAnyDisplayedPickup()) ? singleRowHeight : 0f);
float num6 = num3 + num4 + (float)num * singleRowHeight + num2 + num5 + 8f;
float num7 = 34f;
float x = Math.Max(12f, (float)ScreenWidth() - width - num7);
float num8 = Math.Max(12f, (float)ScreenHeight() - num6 - num7);
foreach (CollectibleEntry item in collectibleRows)
{
string text = item.Label + ": " + item.Amount;
float num9 = EstimateDisplayRowHeight(text, textStyle.RowFontSize, width);
LabelShadowed(x, num8, width, num9, text, textStyle.RowFontSize, textStyle.Color);
num8 += num9;
}
foreach (UnlockEntry item2 in unlockRows)
{
string text2 = FormatUnlockEntry(item2);
float num10 = EstimateDisplayRowHeight(text2, textStyle.RowFontSize, width);
LabelShadowed(x, num8, width, num10, text2, textStyle.RowFontSize, textStyle.Color);
num8 += num10;
}
if (!HasAnyDisplayedPickup())
{
LabelShadowed(x, num8, width, singleRowHeight, "No pickups", textStyle.RowFontSize, textStyle.MutedColor);
return;
}
for (int num11 = 0; num11 < num; num11++)
{
PickupEntry entry = s_entries[num11];
LabelShadowed(x, num8, width, singleRowHeight, FormatEntry(entry), textStyle.RowFontSize, textStyle.Color);
num8 += singleRowHeight;
}
if (s_entries.Count > num)
{
int num12 = s_entries.Count - num;
LabelShadowed(x, num8, width, num2, "+ " + num12 + " more", textStyle.FooterFontSize, textStyle.MutedColor);
}
}
private static void UpdateTmpOverlay()
{
if (!IsTextMeshProOverlayEnabled())
{
SetTmpOverlayVisible(visible: false);
}
else
{
if (!EnsureReflection())
{
return;
}
if (!IsTabMenuPressed() || (!HasAnyDisplayedPickup() && (s_showEmptyMessage == null || !s_showEmptyMessage.Value)))
{
SetTmpOverlayVisible(visible: false);
return;
}
ObjectiveTextStyle objectiveTextStyle = ResolveTextStyle();
TmpOverlayModel model = BuildTmpOverlayModel(objectiveTextStyle);
if (EnsureTmpOverlay())
{
LogOverlayRenderer(s_tmpOverlayUsesDirectUi ? "TextMeshPro direct UI" : "TextMeshPro cloned UI", DescribeTextStyleForLog(objectiveTextStyle));
ApplyTmpTextStyle(objectiveTextStyle);
ApplyTmpLayout(model.Width, model.Height);
ApplyTmpText(model.Text, model.StyleKey);
LogTmpLayoutDiagnostics(objectiveTextStyle, model);
SetTmpOverlayVisible(visible: true);
}
}
}
private static bool IsTextMeshProOverlayEnabled()
{
if (s_useTextMeshProOverlay != null)
{
return s_useTextMeshProOverlay.Value;
}
return true;
}
private static TmpOverlayModel BuildTmpOverlayModel(ObjectiveTextStyle textStyle)
{
int val = Clamp((s_maxVisibleItems == null) ? 12 : s_maxVisibleItems.Value, 1, 40);
List<CollectibleEntry> collectibleRows = GetCollectibleRows();
List<UnlockEntry> unlockRows = GetUnlockRows();
float width = ResolveOverlayWidth(unlockRows);
int num = Math.Min(s_entries.Count, val);
float singleRowHeight = GetSingleRowHeight(textStyle.RowFontSize);
float num2 = ((s_entries.Count > num) ? Math.Max(20f, (float)textStyle.FooterFontSize + 8f) : 0f);
float num3 = ((!HasAnyDisplayedPickup()) ? singleRowHeight : 0f) + (float)num * singleRowHeight + num2 + 10f;
StringBuilder stringBuilder = new StringBuilder();
foreach (CollectibleEntry item in collectibleRows)
{
string text = item.Label + ": " + item.Amount;
num3 += EstimateDisplayRowHeight(text, textStyle.RowFontSize, width);
AppendTmpLine(stringBuilder, text, textStyle.RowFontSize, muted: false);
}
foreach (UnlockEntry item2 in unlockRows)
{
string text2 = FormatUnlockEntry(item2);
num3 += EstimateDisplayRowHeight(text2, textStyle.RowFontSize, width);
AppendTmpLine(stringBuilder, text2, textStyle.RowFontSize, muted: false);
}
if (!HasAnyDisplayedPickup())
{
AppendTmpLine(stringBuilder, "No pickups", textStyle.RowFontSize, muted: true);
}
else
{
for (int i = 0; i < num; i++)
{
AppendTmpLine(stringBuilder, FormatEntry(s_entries[i]), textStyle.RowFontSize, muted: false);
}
}
if (s_entries.Count > num)
{
AppendTmpLine(stringBuilder, "+ " + (s_entries.Count - num) + " more", textStyle.FooterFontSize, muted: true);
}
return new TmpOverlayModel(stringBuilder.ToString().TrimEnd('\n'), width, num3, textStyle.StyleKey);
}
private static float ResolveOverlayWidth(List<UnlockEntry> unlockRows)
{
int num = Clamp((s_panelWidth == null) ? 320 : s_panelWidth.Value, 220, 900);
int value = (unlockRows.Any((UnlockEntry row) => string.Equals(row.Category, "Cosmetic", StringComparison.OrdinalIgnoreCase)) ? Math.Max(num, 680) : num);
int val = Math.Max(220, ScreenWidth() - 80);
return Clamp(value, 220, Math.Min(900, val));
}
private static float GetSingleRowHeight(int fontSize)
{
return Math.Max(30f, (float)fontSize + 10f);
}
private static float EstimateDisplayRowHeight(string text, int fontSize, float width)
{
int num = EstimateWrappedLineCount(text, fontSize, width);
return Math.Max(GetSingleRowHeight(fontSize), (float)num * ((float)fontSize + 8f) + 4f);
}
private static int EstimateWrappedLineCount(string text, int fontSize, float width)
{
if (string.IsNullOrWhiteSpace(text))
{
return 1;
}
float num = Math.Max(80f, width - 8f);
float num2 = Math.Max(7f, (float)fontSize * 0.54f);
int num3 = Math.Max(8, (int)Math.Floor(num / num2));
int num4 = 1;
int num5 = 0;
string[] array = text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string text2 in array)
{
int num6 = Math.Max(1, text2.Length);
if (num5 == 0)
{
num4 += Math.Max(0, (num6 - 1) / num3);
num5 = num6 % num3;
if (num5 == 0)
{
num5 = num3;
}
continue;
}
if (num5 + 1 + num6 <= num3)
{
num5 += 1 + num6;
continue;
}
num4++;
num4 += Math.Max(0, (num6 - 1) / num3);
num5 = num6 % num3;
if (num5 == 0)
{
num5 = num3;
}
}
return Math.Max(1, num4);
}
private static void AppendTmpLine(StringBuilder builder, string text, int fontSize, bool muted)
{
if (builder.Length > 0)
{
builder.Append('\n');
}
builder.Append(text ?? string.Empty);
}
private static string EscapeTmpRichText(string text)
{
if (string.IsNullOrEmpty(text))
{
return string.Empty;
}
return text.Replace("<", "<").Replace(">", ">");
}
private static bool EnsureTmpOverlay()
{
if (s_tmpOverlayReady && s_tmpOverlayRoot != null && s_tmpOverlayText != null && s_tmpOverlayRectTransform != null)
{
return true;
}
if (s_tmpOverlayFailed && DateTime.UtcNow < s_nextTmpOverlayRetryUtc)
{
return false;
}
try
{
if (TryCreateDirectTmpOverlay(out var failureReason))
{
return true;
}
LogDirectTmpFailure(failureReason);
if (s_gameObjectType == null || s_rectTransformType == null || s_canvasType == null || s_textMeshProUguiType == null || s_textAlignmentOptionsType == null || s_vector2Ctor == null || s_objectInstantiateMethod == null)
{
LogTmpOverlayDiagnostics("required Unity/TMP types or methods are missing");
return MarkTmpOverlayFailed("required Unity/TMP types are not available");
}
if (!TryFindTmpOverlaySource(out var sourceText))
{
LogTmpOverlayDiagnostics("source search found no usable active TMP source");
s_nextTmpOverlayRetryUtc = DateTime.UtcNow.AddMilliseconds(500.0);
return false;
}
string text = DescribeTmpTextSource(sourceText);
if (!string.Equals(s_lastLoggedTmpSourceSignature, text, StringComparison.Ordinal))
{
s_lastLoggedTmpSourceSignature = text;
LogDebug("TextMeshPro pickup overlay source " + text + ".");
}
object fieldOrProp = GetFieldOrProp(sourceText, "gameObject");
object fieldOrProp2 = GetFieldOrProp(GetComponentInParent(sourceText, s_canvasType), "transform");
if (fieldOrProp == null || fieldOrProp2 == null)
{
return MarkTmpOverlayFailed("objective TextMeshPro source has no canvas parent");
}
s_tmpOverlayRoot = CloneGameObject(fieldOrProp, fieldOrProp2);
s_tmpOverlayTextObject = s_tmpOverlayRoot;
s_tmpOverlayText = GetComponent(s_tmpOverlayTextObject, s_textMeshProUguiType);
s_tmpOverlayRectTransform = GetComponent(s_tmpOverlayTextObject, s_rectTransformType);
if (s_tmpOverlayText == null || s_tmpOverlayRectTransform == null)
{
return MarkTmpOverlayFailed("could not clone TextMeshProUGUI component");
}
SetFieldOrProp(s_tmpOverlayRoot, "name", "kp0hyc PickupTabOverlay Text");
object fieldOrProp3 = GetFieldOrProp(s_tmpOverlayTextObject, "transform");
s_transformSetAsLastSiblingMethod?.Invoke(fieldOrProp3, Array.Empty<object>());
SetRectTransformAnchors(s_tmpOverlayRectTransform, 1f, 0f, 1f, 0f, 1f, 0f);
SetFieldOrProp(s_tmpOverlayText, "alignment", Enum.Parse(s_textAlignmentOptionsType, "BottomRight"));
SetFieldOrProp(s_tmpOverlayText, "richText", false);
SetFieldOrProp(s_tmpOverlayText, "enableAutoSizing", false);
SetFieldOrProp(s_tmpOverlayText, "enableWordWrapping", true);
if (s_textOverflowModesType != null)
{
SetFieldOrProp(s_tmpOverlayText, "overflowMode", Enum.Parse(s_textOverflowModesType, "Overflow"));
}
SetFieldOrProp(s_tmpOverlayText, "raycastTarget", false);
s_tmpOverlayReady = true;
s_tmpOverlayFailed = false;
s_tmpOverlayVisible = true;
s_tmpOverlayUsesDirectUi = false;
SetTmpOverlayVisible(visible: false);
if (!s_loggedTmpOverlayReady)
{
s_loggedTmpOverlayReady = true;
LogDebug("TextMeshPro pickup overlay created by cloning source UI.");
}
return true;
}
catch (Exception ex)
{
ResetTmpOverlayState(failed: true);
LogWarning("TextMeshPro pickup overlay creation failed: " + ex.GetType().Name + " " + ex.Message);
return false;
}
}
private static bool TryCreateDirectTmpOverlay(out string failureReason)
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Expected O, but got Unknown
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Expected O, but got Unknown
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0179: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
failureReason = null;
GameObject val = null;
GameObject val2 = null;
try
{
if ((object)s_textMeshProUguiType == null)
{
s_textMeshProUguiType = typeof(TextMeshProUGUI);
}
if ((object)s_textAlignmentOptionsType == null)
{
s_textAlignmentOptionsType = typeof(TextAlignmentOptions);
}
if ((object)s_textOverflowModesType == null)
{
s_textOverflowModesType = typeof(TextOverflowModes);
}
RectTransform val3 = ResolveTmpOverlayParentTransform(GameObject.Find("Global/Global Canvas/Player_UI/Tab Menu"));
if ((Object)(object)val3 == (Object)null)
{
failureReason = "game Tab Menu/Player_UI RectTransform is not available";
return false;
}
val = new GameObject("kp0hyc PickupTabOverlay Root");
val.transform.SetParent((Transform)(object)val3, false);
RectTransform val4 = val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
val2 = new GameObject("kp0hyc PickupTabOverlay Text");
val2.transform.SetParent(val.transform, false);
RectTransform val5 = val2.GetComponent<RectTransform>() ?? val2.AddComponent<RectTransform>();
TextMeshProUGUI val6 = val2.AddComponent<TextMeshProUGUI>();
if ((Object)(object)val6 == (Object)null || (Object)(object)val4 == (Object)null || (Object)(object)val5 == (Object)null)
{
failureReason = "created direct GameObjects but TextMeshProUGUI/RectTransform was null";
Object.Destroy((Object)(object)val);
return false;
}
val4.anchorMin = new Vector2(1f, 0f);
val4.anchorMax = new Vector2(1f, 0f);
val4.pivot = new Vector2(1f, 0f);
val4.anchoredPosition = new Vector2(-34f, 34f);
val5.anchorMin = new Vector2(0f, 0f);
val5.anchorMax = new Vector2(1f, 1f);
val5.pivot = new Vector2(1f, 0f);
val5.offsetMin = Vector2.zero;
val5.offsetMax = Vector2.zero;
SetFieldOrProp(val6, "alignment", (object)(TextAlignmentOptions)1028);
SetFieldOrProp(val6, "richText", false);
SetFieldOrProp(val6, "enableAutoSizing", false);
SetFieldOrProp(val6, "enableWordWrapping", true);
SetFieldOrProp(val6, "overflowMode", (object)(TextOverflowModes)0);
SetFieldOrProp(val6, "raycastTarget", false);
SetFieldOrProp(val6, "text", string.Empty);
SetFieldOrProp(val6, "fontSize", (float)Clamp((s_rowFontSize == null) ? 18 : s_rowFontSize.Value, 18, 72));
SetFieldOrProp(val6, "color", ObjectiveColor());
object obj = FindTmpFontByName("Larke Sans Regular SDF");
if (obj != null)
{
SetFieldOrProp(val6, "font", obj);
}
s_tmpOverlayRoot = val;
s_tmpOverlayTextObject = val2;
s_tmpOverlayText = val6;
s_tmpOverlayRectTransform = val4;
s_tmpOverlayReady = true;
s_tmpOverlayFailed = false;
s_tmpOverlayVisible = true;
s_tmpOverlayUsesDirectUi = true;
SetTmpOverlayVisible(visible: false);
if (!s_loggedTmpOverlayReady)
{
s_loggedTmpOverlayReady = true;
LogDebug("TextMeshPro pickup overlay created with TellMeCosmetics-style direct UI setup.");
}
return true;
}
catch (Exception ex)
{
failureReason = ex.GetType().Name + " " + ex.Message;
try
{
if ((Object)(object)val != (Object)null)
{
Object.Destroy((Object)(object)val);
}
}
catch
{
}
return false;
}
}
private static RectTransform ResolveTmpOverlayParentTransform(GameObject tabMenu)
{
RectTransform val = (((Object)(object)tabMenu == (Object)null) ? null : tabMenu.GetComponent<RectTransform>());
if ((Object)(object)val != (Object)null)
{
return val;
}
GameObject val2 = GameObject.Find("Global/Global Canvas/Player_UI");
RectTransform val3 = (((Object)(object)val2 == (Object)null) ? null : val2.GetComponent<RectTransform>());
if ((Object)(object)val3 != (Object)null)
{
return val3;
}
GameObject val4 = GameObject.Find("Global/Global Canvas");
RectTransform val5 = (((Object)(object)val4 == (Object)null) ? null : val4.GetComponent<RectTransform>());
if ((Object)(object)val5 != (Object)null)
{
return val5;
}
return null;
}
private static void LogDirectTmpFailure(string failureReason)
{
if (string.IsNullOrWhiteSpace(failureReason))
{
failureReason = "unknown";
}
if (!string.Equals(s_lastLoggedDirectTmpFailure, failureReason, StringComparison.Ordinal))
{
s_lastLoggedDirectTmpFailure = failureReason;
LogDebug("Direct TextMeshPro pickup overlay failed: " + failureReason);
}
}
private static bool TryFindTmpOverlaySource(out object sourceText)
{
sourceText = null;
if (IsUsableTmpOverlaySource(s_objectiveTextStyle.SourceText))
{
sourceText = s_objectiveTextStyle.SourceText;
return true;
}
if (TryGetObjectiveTextStyleFromObjectiveUi(out var style) && IsUsableTmpOverlaySource(style.SourceText))
{
s_objectiveTextStyle = style;
sourceText = style.SourceText;
return true;
}
if (TryGetObjectiveTextStyleFromTmpScan(out var style2) && IsUsableTmpOverlaySource(style2.SourceText))
{
s_objectiveTextStyle = style2;
sourceText = style2.SourceText;
return true;
}
return false;
}
private static void LogTmpOverlayDiagnostics(string reason)
{
if (!IsDebugLoggingEnabled())
{
return;
}
DateTime utcNow = DateTime.UtcNow;
if (!(utcNow < s_nextTmpDiagnosticsUtc))
{
string text = BuildTmpOverlayDiagnostics(reason);
if (string.Equals(s_lastLoggedTmpDiagnosticsSignature, text, StringComparison.Ordinal))
{
s_nextTmpDiagnosticsUtc = utcNow.AddSeconds(5.0);
return;
}
s_lastLoggedTmpDiagnosticsSignature = text;
s_nextTmpDiagnosticsUtc = utcNow.AddSeconds(2.0);
LogDebug(text);
}
}
private static void LogTmpLayoutDiagnostics(ObjectiveTextStyle textStyle, TmpOverlayModel model)
{
if (IsDebugLoggingEnabled())
{
object rectTransform = ((s_tmpOverlayTextObject == null) ? null : GetComponent(s_tmpOverlayTextObject, s_rectTransformType));
object componentInParent = GetComponentInParent(s_tmpOverlayText, s_canvasType);
string b = (s_tmpOverlayUsesDirectUi ? "direct" : "cloned") + "|" + model.Width.ToString("0.#") + "|" + model.Height.ToString("0.#") + "|" + textStyle.RowFontSize + "|" + DescribeRectTransform(s_tmpOverlayRectTransform) + "|" + DescribeRectTransform(rectTransform) + "|" + GetCanvasScaleFactor(s_tmpOverlayText).ToString("0.##");
if (!string.Equals(s_lastLoggedTmpLayoutSignature, b, StringComparison.Ordinal))
{
s_lastLoggedTmpLayoutSignature = b;
LogDebug("TMP pickup layout renderer=" + (s_tmpOverlayUsesDirectUi ? "direct" : "cloned") + " screen=" + ScreenWidth() + "x" + ScreenHeight() + " model=" + model.Width.ToString("0.#") + "x" + model.Height.ToString("0.#") + " root={" + DescribeRectTransform(s_tmpOverlayRectTransform) + "} text={" + DescribeRectTransform(rectTransform) + "} rootScale=" + DescribeVector(GetFieldOrProp(GetFieldOrProp(s_tmpOverlayRoot, "transform"), "lossyScale")) + " textScale=" + DescribeVector(GetFieldOrProp(GetFieldOrProp(s_tmpOverlayTextObject, "transform"), "lossyScale")) + " canvasScale=" + GetCanvasScaleFactor(s_tmpOverlayText).ToString("0.##") + " canvas='" + TruncateForLog(GetUnityObjectName(componentInParent), 60) + "' " + DescribeTextStyleForLog(textStyle));
}
}
}
private static string BuildTmpOverlayDiagnostics(string reason)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("TMP diagnostics reason=");
stringBuilder.Append(reason);
stringBuilder.Append(" types={");
stringBuilder.Append("GameObject=").Append(TypeNameForLog(s_gameObjectType));
stringBuilder.Append(", RectTransform=").Append(TypeNameForLog(s_rectTransformType));
stringBuilder.Append(", Canvas=").Append(TypeNameForLog(s_canvasType));
stringBuilder.Append(", TMP_Text=").Append(TypeNameForLog(s_tmpTextType));
stringBuilder.Append(", TextMeshProUGUI=").Append(TypeNameForLog(s_textMeshProUguiType));
stringBuilder.Append(", TextAlignmentOptions=").Append(TypeNameForLog(s_textAlignmentOptionsType));
stringBuilder.Append(", TextOverflowModes=").Append(TypeNameForLog(s_textOverflowModesType));
stringBuilder.Append("} methods={");
stringBuilder.Append("FindObjectsOfType=").Append(s_findObjectsOfTypeMethod != null);
stringBuilder.Append(", GetComponentInParent=").Append(s_componentGetComponentInParentMethod != null);
stringBuilder.Append(", GetComponent=").Append(s_gameObjectGetComponentMethod != null);
stringBuilder.Append(", AddComponent=").Append(s_gameObjectAddComponentMethod != null);
stringBuilder.Append(", Instantiate=").Append(s_objectInstantiateMethod != null);
stringBuilder.Append(", SetActive=").Append(s_gameObjectSetActiveMethod != null);
stringBuilder.Append("}");
AppendObjectiveUiDiagnostics(stringBuilder);
AppendTmpScanDiagnostics(stringBuilder, s_textMeshProUguiType, "TextMeshProUGUI");
if (s_tmpTextType != null && (object)s_tmpTextType != s_textMeshProUguiType)
{
AppendTmpScanDiagnostics(stringBuilder, s_tmpTextType, "TMP_Text");
}
return stringBuilder.ToString();
}
private static void AppendObjectiveUiDiagnostics(StringBuilder builder)
{
int num = 0;
int num2 = 0;
int num3 = 0;
List<string> list = new List<string>();
try
{
foreach (object item in FindObjectsOfType(GetObjectiveUiType()))
{
num++;
if (IsActiveInHierarchy(item))
{
num2++;
}
object fieldOrProp = GetFieldOrProp(item, "displayText");
if (fieldOrProp != null)
{
num3++;
if (list.Count < 2)
{
list.Add(DescribeTmpTextSource(fieldOrProp));
}
}
else if (list.Count < 2)
{
list.Add("objectiveUi='" + TruncateForLog(GetUnityObjectName(item), 50) + "' displayText=null");
}
}
}
catch (Exception ex)
{
list.Add("error=" + ex.GetType().Name + ":" + ex.Message);
}
builder.Append(" objectiveUI={total=").Append(num).Append(", active=")
.Append(num2)
.Append(", withDisplayText=")
.Append(num3)
.Append(", samples=[")
.Append(string.Join("; ", list))
.Append("]}");
}
private static void AppendTmpScanDiagnostics(StringBuilder builder, Type type, string label)
{
if (type == null)
{
builder.Append(" ").Append(label).Append("={type=null}");
return;
}
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
int num6 = 0;
List<string> list = new List<string>();
try
{
foreach (object item in FindObjectsOfType(type))
{
num++;
bool flag = IsActiveInHierarchy(item);
if (flag)
{
num2++;
}
if (IsPickupTmpOverlayObject(item))
{
num5++;
continue;
}
if (!TryConvertFloat(GetFieldOrProp(item, "fontSize"), out var result) || result <= 1f)
{
num4++;
if (list.Count < 4)
{
list.Add("noFontSize {" + DescribeTmpTextSource(item) + "}");
}
continue;
}
if (GetComponentInParent(item, s_canvasType) == null)
{
num6++;
if (list.Count < 4)
{
list.Add("noCanvas {" + DescribeTmpTextSource(item) + "}");
}
continue;
}
num3++;
if (list.Count < 4)
{
list.Add("usable active=" + flag + " {" + DescribeTmpTextSource(item) + "}");
}
}
}
catch (Exception ex)
{
list.Add("error=" + ex.GetType().Name + ":" + ex.Message);
}
builder.Append(" ").Append(label).Append("={total=")
.Append(num)
.Append(", active=")
.Append(num2)
.Append(", usable=")
.Append(num3)
.Append(", ownOverlay=")
.Append(num5)
.Append(", noFontSize=")
.Append(num4)
.Append(", noCanvas=")
.Append(num6)
.Append(", samples=[")
.Append(string.Join("; ", list))
.Append("]}");
}
private static bool IsUsableTmpOverlaySource(object sourceText)
{
if (sourceText == null || !IsActiveInHierarchy(sourceText))
{
return false;
}
if (GetFieldOrProp(sourceText, "gameObject") == null)
{
return false;
}
return GetComponentInParent(sourceText, s_canvasType) != null;
}
private static bool MarkTmpOverlayFailed(string reason)
{
ResetTmpOverlayState(failed: true);
LogWarning("TextMeshPro pickup overlay unavailable: " + reason);
return false;
}
private static void ApplyTmpTextStyle(ObjectiveTextStyle textStyle)
{
if (s_tmpOverlayText != null)
{
if (textStyle.Font != null)
{
SetFieldOrProp(s_tmpOverlayText, "font", textStyle.Font);
}
if (textStyle.FontSharedMaterial != null)
{
SetFieldOrProp(s_tmpOverlayText, "fontSharedMaterial", textStyle.FontSharedMaterial);
}
SetFieldOrProp(s_tmpOverlayText, "fontSize", (float)textStyle.RowFontSize);
SetFieldOrProp(s_tmpOverlayText, "color", textStyle.Color ?? ObjectiveColor());
}
}
private static void ApplyTmpLayout(float width, float height)
{
if (s_tmpOverlayRectTransform != null && (!(Math.Abs(width - s_tmpLastWidth) < 0.1f) || !(Math.Abs(height - s_tmpLastHeight) < 0.1f)))
{
s_tmpLastWidth = width;
s_tmpLastHeight = height;
SetFieldOrProp(s_tmpOverlayRectTransform, "sizeDelta", Vector2(width, height));
SetFieldOrProp(s_tmpOverlayRectTransform, "anchoredPosition", Vector2(-34f, 34f));
}
}
private static void ApplyTmpText(string text, int styleKey)
{
if (s_tmpOverlayText != null && (!string.Equals(s_tmpLastText, text, StringComparison.Ordinal) || s_tmpLastStyleKey != styleKey))
{
s_tmpLastText = text;
s_tmpLastStyleKey = styleKey;
SetFieldOrProp(s_tmpOverlayText, "text", text);
}
}
private static void SetTmpOverlayVisible(bool visible)
{
if (s_tmpOverlayRoot == null || s_gameObjectSetActiveMethod == null || s_tmpOverlayVisible == visible)
{
return;
}
try
{
s_gameObjectSetActiveMethod.Invoke(s_tmpOverlayRoot, new object[1] { visible });
s_tmpOverlayVisible = visible;
}
catch
{
ResetTmpOverlayState(failed: false);
}
}
private static void DestroyTmpOverlay()
{
if (s_tmpOverlayRoot != null && s_objectDestroyMethod != null)
{
try
{
s_objectDestroyMethod.Invoke(null, new object[1] { s_tmpOverlayRoot });
}
catch
{
}
}
ResetTmpOverlayState(failed: false);
}
private static void ResetTmpOverlayState(bool failed)
{
s_tmpOverlayRoot = null;
s_tmpOverlayTextObject = null;
s_tmpOverlayText = null;
s_tmpOverlayRectTransform = null;
s_tmpOverlayReady = false;
s_tmpOverlayVisible = false;
s_tmpOverlayFailed = failed;
s_tmpOverlayUsesDirectUi = false;
s_nextTmpOverlayRetryUtc = (failed ? DateTime.UtcNow.AddSeconds(5.0) : DateTime.MinValue);
s_loggedTmpOverlayReady = false;
s_tmpLastText = null;
s_tmpLastStyleKey = 0;
s_tmpLastWidth = 0f;
s_tmpLastHeight = 0f;
}
private static object CreateGameObject(string name, params Type[] components)
{
if (s_gameObjectWithComponentsCtor != null)
{
return s_gameObjectWithComponentsCtor.Invoke(new object[2] { name, components });
}
object obj = s_gameObjectCtor.Invoke(new object[1] { name });
foreach (Type type in components)
{
s_gameObjectAddComponentMethod?.Invoke(obj, new object[1] { type });
}
return obj;
}
private static object CloneGameObject(object sourceGameObject, object parentTransform)
{
if (sourceGameObject == null || parentTransform == null || s_objectInstantiateMethod == null)
{
return null;
}
return s_objectInstantiateMethod.Invoke(null, new object[3] { sourceGameObject, parentTransform, false });
}
private static object GetComponent(object gameObject, Type componentType)
{
if (gameObject == null || componentType == null || s_gameObjectGetComponentMethod == null)
{
return null;
}
try
{
return s_gameObjectGetComponentMethod.Invoke(gameObject, new object[1] { componentType });
}
catch
{
return null;
}
}
private static void SetRectTransformAnchors(object rectTransform, float anchorMinX, float anchorMinY, float anchorMaxX, float anchorMaxY, float pivotX, float pivotY)
{
SetFieldOrProp(rectTransform, "anchorMin", Vector2(anchorMinX, anchorMinY));
SetFieldOrProp(rectTransform, "anchorMax", Vector2(anchorMaxX, anchorMaxY));
SetFieldOrProp(rectTransform, "pivot", Vector2(pivotX, pivotY));
}
private static ObjectiveTextStyle ResolveTextStyle()
{
if (s_useObjectiveTextStyle != null && s_useObjectiveTextStyle.Value)
{
TryRefreshObjectiveTextStyle();
}
if (s_objectiveTextStyle.HasLiveStyle)
{
return s_objectiveTextStyle;
}
return ObjectiveTextStyle.FromConfig(Clamp((s_headerFontSize == null) ? 20 : s_headerFontSize.Value, 20, 76), Clamp((s_rowFontSize == null) ? 18 : s_rowFontSize.Value, 18, 72), Clamp((s_footerFontSize == null) ? 16 : s_footerFontSize.Value, 16, 68), ObjectiveColor());
}
private static void TryRefreshObjectiveTextStyle()
{
DateTime utcNow = DateTime.UtcNow;
if (utcNow < s_nextObjectiveStyleRefreshUtc)
{
return;
}
s_nextObjectiveStyleRefreshUtc = utcNow.AddSeconds((!s_objectiveTextStyle.HasLiveStyle) ? 1 : 2);
try
{
if (TryGetObjectiveTextStyleFromObjectiveUi(out var style) || TryGetObjectiveTextStyleFromTmpScan(out style))
{
s_objectiveTextStyle = style;
string text = DescribeTextStyleForLog(style);
if (!string.Equals(s_lastLoggedObjectiveStyleSignature, text, StringComparison.Ordinal))
{
s_lastLoggedObjectiveStyleSignature = text;
LogDebug("Objective text style " + text);
}
}
}
catch (Exception ex)
{
LogWarning("objective text style refresh failed: " + ex.GetType().Name + " " + ex.Message);
}
}
private static bool TryGetObjectiveTextStyleFromObjectiveUi(out ObjectiveTextStyle style)
{
style = ObjectiveTextStyle.Fallback;
Type objectiveUiType = GetObjectiveUiType();
if (objectiveUiType == null)
{
return false;
}
foreach (object item in FindObjectsOfType(objectiveUiType))
{
if (item != null && IsActiveInHierarchy(item) && TryGetTextStyleFromTmpText(GetFieldOrProp(item, "displayText"), "ObjectiveUI", out style))
{
return true;
}
}
return false;
}
private static bool TryGetObjectiveTextStyleFromTmpScan(out ObjectiveTextStyle style)
{
style = ObjectiveTextStyle.Fallback;
Type type = GetTextMeshProUguiType() ?? GetTmpTextType();
if (type == null)
{
return false;
}
ObjectiveTextStyle objectiveTextStyle = ObjectiveTextStyle.Fallback;
int num = int.MinValue;
foreach (object item in FindObjectsOfType(type))
{
if (item != null && IsActiveInHierarchy(item) && !IsPickupTmpOverlayObject(item) && TryGetTextStyleFromTmpText(item, "TMP scan", out var style2))
{
int num2 = ScoreTmpTextCandidate(item, style2.RowFontSize);
if (num2 > num)
{
num = num2;
objectiveTextStyle = style2;
}
}
}
if (!objectiveTextStyle.HasLiveStyle)
{
return false;
}
style = objectiveTextStyle;
return true;
}
private static int ScoreTmpTextCandidate(object tmpText, int rowFontSize)
{
int num = rowFontSize;
if (TryConvertFloat(GetFieldOrProp(tmpText, "fontSize"), out var result))
{
num += (int)Math.Round(result * 10f);
}
string text = GetFieldOrProp(tmpText, "text") as string;
if (!string.IsNullOrWhiteSpace(text))
{
if (text.Length > 3)
{
num += 100;
}
if (text == text.ToUpperInvariant())
{
num += 200;
}
if (text.IndexOf("Pickups", StringComparison.OrdinalIgnoreCase) >= 0)
{
num -= 500;
}
}
string text2 = (GetFieldOrProp(GetFieldOrProp(tmpText, "gameObject"), "name") as string) ?? string.Empty;
if (text2.IndexOf("objective", StringComparison.OrdinalIgnoreCase) >= 0)
{
num += 10000;
}
if (text2.IndexOf("mission", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("task", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("quest", StringComparison.OrdinalIgnoreCase) >= 0)
{
num += 2000;
}
if (text2.IndexOf("map", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("seed", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("monster", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("pickup", StringComparison.OrdinalIgnoreCase) >= 0)
{
num -= 1000;
}
return num;
}
private static bool TryGetTextStyleFromTmpText(object tmpText, string source, out ObjectiveTextStyle style)
{
style = ObjectiveTextStyle.Fallback;
if (tmpText == null)
{
return false;
}
if (!TryConvertFloat(GetFieldOrProp(tmpText, "fontSize"), out var result) || result <= 1f)
{
return false;
}
int num = Clamp((s_objectiveTextScalePercent == null) ? 100 : s_objectiveTextScalePercent.Value, 50, 200);
int val = Clamp((s_rowFontSize == null) ? 18 : s_rowFontSize.Value, 18, 72);
int val2 = Clamp((s_headerFontSize == null) ? 20 : s_headerFontSize.Value, 20, 76);
int val3 = Clamp((s_footerFontSize == null) ? 16 : s_footerFontSize.Value, 16, 68);
int num2 = Clamp(Math.Max((int)Math.Round(result * (float)num / 100f), val), 18, 84);
int headerFontSize = Clamp(Math.Max(num2 + 2, val2), 20, 88);
int footerFontSize = Clamp(Math.Max(num2 - 4, val3), 16, 76);
object color = NormalizeTextColor(GetFieldOrProp(tmpText, "color"));
object fieldOrProp = GetFieldOrProp(tmpText, "font");
object fieldOrProp2 = GetFieldOrProp(tmpText, "fontSharedMaterial");
style = new ObjectiveTextStyle(hasLiveStyle: true, source, headerFontSize, num2, footerFontSize, color, CopyColorWithAlpha(color, 0.82f), fieldOrProp, fieldOrProp2, tmpText);
return true;
}
private static float GetCanvasScaleFactor(object component)
{
try
{
Type canvasType = GetCanvasType();
if (canvasType == null)
{
return 1f;
}
object componentInParent = GetComponentInParent(component, canvasType);
if (componentInParent == null)
{
return 1f;
}
float result;
return (TryConvertFloat(GetFieldOrProp(componentInParent, "scaleFactor"), out result) && result > 0f) ? Clamp(result, 0.5f, 4f) : 1f;
}
catch
{
return 1f;
}
}
private static object GetComponentInParent(object component, Type requestedType)
{
if (component == null || requestedType == null || s_componentGetComponentInParentMethod == null)
{
return null;
}
try
{
return s_componentGetComponentInParentMethod.Invoke(component, new object[1] { requestedType });
}
catch
{
return null;
}
}
private static IEnumerable<object> FindObjectsOfType(Type type)
{
if (type == null || s_findObjectsOfTypeMethod == null)
{
yield break;
}
object list = null;
try
{
list = s_findObjectsOfTypeMethod.Invoke(null, new object[1] { type });
}
catch
{
}
foreach (object item in EnumerateItems(list))
{
if (item != null)
{
yield return item;
}
}
}
private static IEnumerable<object> FindResourceObjectsOfType(Type type)
{
if (type == null || s_resourcesFindObjectsOfTypeAllMethod == null)
{
yield break;
}
object list = null;
try
{
list = s_resourcesFindObjectsOfTypeAllMethod.Invoke(null, new object[1] { type });
}
catch
{
}
foreach (object item in EnumerateItems(list))
{
if (item != null)
{
yield return item;
}
}
}
private static object FindTmpFontByName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return null;
}
if (s_larkeSansFont != null && string.Equals(GetFieldOrProp(s_larkeSansFont, "name")?.ToString(), name, StringComparison.OrdinalIgnoreCase))
{
return s_larkeSansFont;
}
foreach (object item in FindResourceObjectsOfType(s_tmpFontAssetType))
{
if (string.Equals(GetFieldOrProp(item, "name")?.ToString(), name, StringComparison.OrdinalIgnoreCase))
{
s_larkeSansFont = item;
return item;
}
}
return null;
}
private static bool HasAnyDisplayedPickup()
{
if (s_entries.Count <= 0 && GetCollectibleRows().Count <= 0)
{
return GetUnlockRows().Count > 0;
}
return true;
}
private static List<CollectibleEntry> GetCollectibleRows()
{
List<CollectibleEntry> list = new List<CollectibleEntry>();
if (s_showCollectibles == null || !s_showCollectibles.Value)
{
return list;
}
AddCollectibleRow(list, "Tickets");
AddCollectibleRow(list, "Reroll Coins");
return list;
}
private static void AddCollectibleRow(List<CollectibleEntry> rows, string label)
{
if (s_collectiblesFound.TryGetValue(label, out var value) && value > 0)
{
rows.Add(new CollectibleEntry(label, value));
}
}
private static List<UnlockEntry> GetUnlockRows()
{
if (s_showUnlockPickups == null || !s_showUnlockPickups.Value)
{
return new List<UnlockEntry>();
}
return s_unlockEntries.ToList();
}
private static string FormatEntry(PickupEntry entry)
{
string text = entry.Name;
if (entry.Count > 1)
{
text = text + " x" + entry.Count;
}
if (s_showIds != null && s_showIds.Value && entry.Id >= 0)
{
text = text + " #" + entry.Id;
}
if (s_showHandLabels != null && s_showHandLabels.Value)
{
if (entry.LeftHand && entry.RightHand)
{
text += " L/R";
}
else if (entry.LeftHand)
{
text += " L";
}
else if (entry.RightHand)
{
text += " R";
}
}
return text;
}
private static string FormatUnlockEntry(UnlockEntry entry)
{
if (string.Equals(entry.Category, "Stamps", StringComparison.OrdinalIgnoreCase))
{
return "Stamps: " + entry.Count;
}
string text = entry.Category + ": " + entry.Name;
if (entry.Id >= 0)
{
text = text + " #" + entry.Id;
}
if (string.Equals(entry.Category, "Cosmetic", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(entry.ItemClass))
{
text = text + " (" + entry.ItemClass + ")";
}
if (entry.Count > 1)
{
text = text + " x" + entry.Count;
}
return text;
}
private static object GetLocalRndPlayerInventory()
{
object fieldOrProp = GetFieldOrProp(GetStaticFieldOrProp(GetPlayerNetworkSyncType(), "instance"), "RndPlayerInventory");
if (fieldOrProp != null)
{
return fieldOrProp;
}
fieldOrProp = GetFieldOrProp(GetFieldOrProp(GetStaticFieldOrProp(GetGameManagerType(), "instance"), "mainPlayer"), "RndPlayerInventory");
if (fieldOrProp != null)
{
return fieldOrProp;
}
return FindOwnedRndPlayerInventory();
}
private static object FindOwnedRndPlayerInventory()
{
try
{
if (!EnsureReflection() || s_findObjectsOfTypeMethod == null)
{
return null;
}
Type rndPlayerInventoryType = GetRndPlayerInventoryType();
if (rndPlayerInventoryType == null)
{
return null;
}
object? list = s_findObjectsOfTypeMethod.Invoke(null, new object[1] { rndPlayerInventoryType });
object obj = null;
foreach (object item in EnumerateItems(list))
{
if (item != null)
{
obj = obj ?? item;
if (TryConvertBool(GetFieldOrProp(GetFieldOrProp(item, "playerNetworkSync"), "isOwned"), out var result) && result)
{
return item;
}
}
}
return obj;
}
catch
{
return null;
}
}
private static int GetHandItemId(string propertyName)
{
try
{
if (TryConvertInt(GetFieldOrProp(GetStaticFieldOrProp(FindType("InventoryController"), "Instance"), propertyName), out var result))
{
return result;
}
}
catch
{
}
return -1;
}
private static bool TryGetItemId(object item, out int id)
{
if (TryConvertInt(GetFieldOrProp(item, "SerializedID"), out id))
{
return true;
}
return TryConvertInt(GetFieldOrProp(item, "ID"), out id);
}
private static string GetItemDisplayName(object item)
{
try
{
string text = item.GetType().GetMethod("GetItemName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(item, Array.Empty<object>()) as string;
if (!string.IsNullOrWhiteSpace(text))
{
return text;
}
}
catch
{
}
string text2 = GetFieldOrProp(item, "name") as string;
if (!string.IsNullOrWhiteSpace(text2))
{
return CleanUnityName(text2);
}
text2 = GetFieldOrProp(item, "nameLocalisationKey") as string;
if (!string.IsNullOrWhiteSpace(text2))
{
return text2;
}
return null;
}
private static string CleanUnityName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return name;
}
string text = name.Trim();
if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
{
text = text.Substring(0, text.Length - 7).Trim();
}
if (text.StartsWith("SO_", StringComparison.OrdinalIgnoreCase))
{
text = text.Substring(3);
}
return text.Replace('_', ' ');
}
private static bool IsTabMenuPressed()
{
if (IsTabMenuObjectActive())
{
return true;
}
try
{
if (s_gameGetButton != null && s_showTabMenuButton != null && TryConvertBool(s_gameGetButton.Invoke(null, new object[1] { s_showTabMenuButton }), out var result))
{
return result;
}
}
catch
{
}
try
{
if (s_inputGetKey != null && s_keyCodeTab != null && TryConvertBool(s_inputGetKey.Invoke(null, new object[1] { s_keyCodeTab }), out var result2))
{
return result2;
}
}
catch
{
}
return false;
}
private static bool IsTabMenuObjectActive()
{
try
{
if (IsActiveInHierarchy(GetFieldOrProp(GetStaticFieldOrProp(FindType("UI_Controller"), "instance"), "tabMenu")))
{
return true;
}
GameObject val = GameObject.Find("Global/Global Canvas/Player_UI/Tab Menu");
return (Object)(object)val != (Object)null && val.activeInHierarchy;
}
catch
{
return false;
}
}
private static bool IsActiveInHierarchy(object obj)
{
if (obj == null)
{
return false;
}
bool result;
return TryConvertBool(GetFieldOrProp(GetFieldOrProp(obj, "gameObject") ?? obj, "activeInHierarchy"), out result) && result;
}
private static bool EnsureReflection()
{
if (s_reflectionReady)
{
return true;
}
try
{
s_rectType = FindType("UnityEngine.Rect");
s_colorType = FindType("UnityEngine.Color");
s_vector2Type = FindType("UnityEngine.Vector2");
s_guiType = FindType("UnityEngine.GUI");
s_screenType = FindType("UnityEngine.Screen");
s_inputType = FindType("UnityEngine.Input");
s_keyCodeType = FindType("UnityEngine.KeyCode");
s_objectType = FindType("UnityEngine.Object");
s_componentType = FindType("UnityEngine.Component");
s_gameObjectType = FindType("UnityEngine.GameObject");
s_transformType = FindType("UnityEngine.Transform");
s_rectTransformType = FindType("UnityEngine.RectTransform");
s_objectiveUiType = FindType("Objectives.ObjectiveUI");
s_tmpTextType = FindTmpType("TMP_Text");
s_tmpFontAssetType = FindTmpType("TMP_FontAsset");
s_textMeshProUguiType = FindTmpType("TextMeshProUGUI");
s_canvasType = FindType("UnityEngine.Canvas");
s_renderModeType = FindType("UnityEngine.RenderMode");
s_resourcesType = FindType("UnityEngine.Resources");
s_textAlignmentOptionsType = FindTmpType("TextAlignmentOptions");
s_textOverflowModesType = FindTmpType("TextOverflowModes");
s_labyrinthineInputManagerType = FindType("LabyrinthineInputManager");
s_inputButtonType = FindType("InputButton");
if (s_rectType == null || s_colorType == null || s_guiType == null)
{
return LogReflectionNotReady();
}
s_rectCtor = s_rectType.GetConstructor(new Type[4]
{
typeof(float),
typeof(float),
typeof(float),
typeof(float)
});
s_colorCtor = s_colorType.GetConstructor(new Type[4]
{
typeof(float),
typeof(float),
typeof(float),
typeof(float)
});
s_vector2Ctor = s_vector2Type?.GetConstructor(new Type[2]
{
typeof(float),
typeof(float)
});
s_gameObjectCtor = s_gameObjectType?.GetConstructor(new Type[1] { typeof(string) });
s_gameObjectWithComponentsCtor = s_gameObjectType?.GetConstructor(new Type[2]
{
typeof(string),
typeof(Type[])
});
s_guiColorProperty = s_guiType.GetProperty("color", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
s_screenWidthProperty = s_screenType?.GetProperty("width", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
s_screenHeightProperty = s_screenType?.GetProperty("height", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
s_guiSkinProperty = s_guiType.GetProperty("skin", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
s_guiLabel = s_guiType.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "Label" && m.GetParameters().Length == 2 && m.GetParameters()[0].ParameterType == s_rectType && m.GetParameters()[1].ParameterType == typeof(string));
s_inputGetKey = s_inputType?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "GetKey" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == s_keyCodeType);
if (s_keyCodeType != null)
{
s_keyCodeTab = Enum.Parse(s_keyCodeType, "Tab");
}
if (s_labyrinthineInputManagerType != null && s_inputButtonType != null)
{
s_gameGetButton = s_labyrinthineInputManagerType.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "GetButton" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == s_inputButtonType);
s_showTabMenuButton = Enum.Parse(s_inputButtonType, "ShowTabMenu");
}
s_findObjectsOfTypeMethod = s_objectType?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "FindObjectsOfType" && !m.ContainsGenericParameters && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(Type));
s_componentGetComponentInParentMethod = s_componentType?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "GetComponentInParent" && !m.ContainsGenericParameters && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(Type));
s_gameObjectGetComponentMethod = s_gameObjectType?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "GetComponent" && !m.ContainsGenericParameters && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(Type));
s_gameObjectAddComponentMethod = s_gameObjectType?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "AddComponent" && !m.ContainsGenericParameters && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(Type));
s_gameObjectSetActiveMethod = s_gameObjectType?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "SetActive" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(bool));
s_transformSetParentMethod = s_transformType?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "SetParent" && m.GetParameters().Length == 2 && m.GetParameters()[1].ParameterType == typeof(bool));
s_transformSetAsLastSiblingMethod = s_transformType?.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "SetAsLastSibling" && m.GetParameters().Length == 0);
s_objectInstantiateMethod = s_objectType?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "Instantiate" && !m.ContainsGenericParameters && m.GetParameters().Length == 3 && m.GetParameters()[1].ParameterType == s_transformType && m.GetParameters()[2].ParameterType == typeof(bool));
s_objectDestroyMethod = s_objectType?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "Destroy" && m.GetParameters().Length == 1);
s_objectDontDestroyOnLoadMethod = s_objectType?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "DontDestroyOnLoad" && m.GetParameters().Length == 1);
s_resourcesFindObjectsOfTypeAllMethod = s_resourcesType?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "FindObjectsOfTypeAll" && !m.ContainsGenericParameters && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(Type));
if (s_rectCtor == null || s_colorCtor == null || s_guiLabel == null)
{
return LogReflectionNotReady();
}
InitLabelSkinAccessors();
s_reflectionReady = true;
return true;
}
catch (Exception ex)
{
LogWarning("Unity reflection init failed: " + ex.GetType().Name + " " + ex.Message);
return false;
}
}
private static void InitLabelSkinAccessors()
{
try
{
object obj = s_guiSkinProperty?.GetValue(null);
PropertyInfo propertyInfo = ((s_guiSkinLabelProperty == null && obj != null) ? obj.GetType().GetProperty("label", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : s_guiSkinLabelProperty);
if (propertyInfo != null)
{
s_guiSkinLabelProperty = propertyInfo;
}
object obj2 = s_guiSkinLabelProperty?.GetValue(obj);
if (obj2 != null)
{
Type type = obj2.GetType();
s_styleFontSizeProperty = type.GetProperty("fontSize", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
s_styleNormalProperty = type.GetProperty("normal", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
s_styleStateTextColorProperty = (s_styleNormalProperty?.GetValue(obj2))?.GetType().GetProperty("textColor", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
}
catch
{
}
}
private static bool LogReflectionNotReady()
{
LogWarning("Unity IMGUI reflection is not ready yet.");
return false;
}
private static void LabelShadowed(float x, float y, float width, float height, string text, int fontSize, object color)
{
Label(x + 1f, y + 1f, width, height, text, Color(0f, 0f, 0f, 0.7f), fontSize);
Label(x, y, width, height, text, color, fontSize);
}
private static object ObjectiveColor()
{
return Color(1f, 1f, 1f, 1f);
}
private static object MutedObjectiveColor()
{
return Color(1f, 1f, 1f, 0.82f);
}
private static object NormalizeTextColor(object color)
{
if (TryReadColor(color, out var r, out var g, out var b, out var a))
{
return Color(Clamp01(r), Clamp01(g), Clamp01(b), Clamp01((a <= 0f) ? 1f : a));
}
return ObjectiveColor();
}
private static object CopyColorWithAlpha(object color, float alpha)
{
if (TryReadColor(color, out var r, out var g, out var b, out var _))
{
return Color(Clamp01(r), Clamp01(g), Clamp01(b), Clamp01(alpha));
}
return Color(1f, 1f, 1f, Clamp01(alpha));
}
private static bool TryReadColor(object color, out float r, out float g, out float b, out float a)
{
r = 1f;
g = 1f;
b = 1f;
a = 1f;
if (color == null)
{
return false;
}
if (TryConvertFloat(GetFieldOrProp(color, "r"), out r) && TryConvertFloat(GetFieldOrProp(color, "g"), out g) && TryConvertFloat(GetFieldOrProp(color, "b"), out b))
{
return TryConvertFloat(GetFieldOrProp(color, "a"), out a);
}
return false;
}
private static void Label(float x, float y, float width, float height, string text, object color, int fontSize)
{
SetGuiColor(color);
object oldFontSize = null;
object oldTextColor = null;
object skinLabelStyle = GetSkinLabelStyle();
object obj = ((skinLabelStyle == null) ? null : s_styleNormalProperty?.GetValue(skinLabelStyle));
try
{
if (skinLabelStyle != null && s_styleFontSizeProperty != null)
{
oldFontSize = s_styleFontSizeProperty.GetValue(skinLabelStyle);
}
if (obj != null && s_styleStateTextColorProperty != null)
{
oldTextColor = s_styleStateTextColorProperty.GetValue(obj);
}
SetLabelFontSize(skinLabelStyle, fontSize);
SetLabelTextColor(obj, color);
s_guiLabel.Invoke(null, new object[2]
{
Rect(x, y, width, height),
text
});
}
finally
{
RestoreLabelStyle(skinLabelStyle, obj, oldFontSize, oldTextColor);
SetGuiColor(Color(1f, 1f, 1f, 1f));
}
}
private static object GetSkinLabelStyle()
{
try
{
object obj = s_guiSkinProperty?.GetValue(null);
return (obj == null) ? null : s_guiSkinLabelProperty?.GetValue(obj);
}
catch
{
return null;
}
}
private static void SetLabelFontSize(object style, int fontSize)
{
try
{
s_styleFontSizeProperty?.SetValue(style, fontSize);
}
catch
{
}
}
private static void SetLabelTextColor(object normal, object color)
{
try
{
s_styleStateTextColorProperty?.SetValue(normal, color);
}
catch
{
}
}
private static void RestoreLabelStyle(object style, object normal, object oldFontSize, object oldTextColor)
{
try
{
if (style != null && oldFontSize != null)
{
s_styleFontSizeProperty?.SetValue(style, oldFontSize);
}
if (normal != null && oldTextColor != null)
{
s_styleStateTextColorProperty?.SetValue(normal, oldTextColor);
}
}
catch
{
}
}
private static object Rect(float x, float y, float width, float height)
{
return s_rectCtor.Invoke(new object[4] { x, y, width, height });
}
private static object Color(float r, float g, float b, float a)
{
return s_colorCtor.Invoke(new object[4] { r, g, b, a });
}
private static object Vector2(float x, float y)
{
return s_vector2Ctor.Invoke(new object[2] { x, y });
}
private static void SetGuiColor(object color)
{
try
{
s_guiColorProperty?.SetValue(null, color);
}
catch
{
}
}
private static int ScreenWidth()
{
try
{
return (s_screenWidthProperty == null) ? 1920 : Convert.ToInt32(s_screenWidthProperty.GetValue(null));
}
catch
{
return 1920;
}
}
private static int ScreenHeight()
{
try
{
return (s_screenHeightProperty == null) ? 1080 : Convert.ToInt32(s_screenHeightProperty.GetValue(null));
}
catch
{
return 1080;
}
}
private static Type GetPlayerNetworkSyncType()
{
if (s_playerNetworkSyncType == null)
{
s_playerNetworkSyncType = FindType("PlayerNetworkSync");
}
return s_playerNetworkSyncType;
}
private static Type GetGameManagerType()
{
if (s_gameManagerType == null)
{
s_gameManagerType = FindType("GameManager");
}
return s_gameManagerType;
}
private static Type GetRndPlayerInventoryType()
{
if (s_rndPlayerInventoryType == null)
{
s_rndPlayerInventoryType = FindType("ValkoGames.Labyrinthine.Cases.Inventory.RndPlayerInventory");
}
return s_rndPlayerInventoryType;
}
private static Type GetRndCollectibleType()
{
if (s_rndCollectibleType == null)
{
s_rndCollectibleType = FindType("ValkoGames.Labyrinthine.Cases.Interactions.RndCollectible");
}
return s_rndCollectibleType;
}
private static Type GetCustomizationPickupType()
{
if (s_customizationPickupType == null)
{
s_customizationPickupType = FindType("CharacterCustomization.CustomizationPickup");
}
return s_customizationPickupType;
}
private static Type GetCustomCaseItemUnlockType()
{
if (s_customCaseItemUnlockType == null)
{
s_customCaseItemUnlockType = FindType("ValkoGames.Labyrinthine.Cases.Custom.CustomCaseItemUnlock");
}
return s_customCaseItemUnlockType;
}
private static Type GetCustomizationManagerType()
{
if (s_customizationManagerType == null)
{
s_customizationManagerType = FindType("CharacterCustomization.CustomizationManager");
}
return s_customizationManagerType;
}
private static Type GetLocalisationManagerType()
{
if (s_localisationManagerType == null)
{
s_localisationManagerType = FindType("Localisation.LocalisationManager") ?? FindType("LocalisationManager");
}
return s_localisationManagerType;
}
private static Type GetObjectiveUiType()
{
if (s_objectiveUiType == null)
{
s_objectiveUiType = FindType("Objectives.ObjectiveUI");
}
return s_objectiveUiType;
}
private static Type GetTmpTextType()
{
if (s_tmpTextType == null)
{
s_tmpTextType = FindTmpType("TMP_Text");
}
return s_tmpTextType;
}
private static Type GetTextMeshProUguiType()
{
if (s_textMeshProUguiType == null)
{
s_textMeshProUguiType = FindTmpType("TextMeshProUGUI");
}
return s_textMeshProUguiType;
}
private static Type GetCanvasType()
{
if (s_canvasType == null)
{
s_canvasType = FindType("UnityEngine.Canvas");
}
return s_canvasType;
}
private static Type FindTmpType(string typeName)
{
return FindType("Il2CppTMPro." + typeName) ?? FindType("TMPro." + typeName);
}
private static Type FindType(string fullName)
{
string il2cppName = (fullName.StartsWith("Il2Cpp.", StringComparison.Ordinal) ? fullName : ("Il2Cpp." + fullName));
string shortName = (fullName.Contains(".") ? fullName.Substring(fullName.LastIndexOf('.') + 1) : fullName);
Type type = Type.GetType(fullName) ?? Type.GetType(il2cppName);
if (type != null)
{
return type;
}
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type type2 = assembly.GetType(fullName, throwOnError: false) ?? assembly.GetType(il2cppName, throwOnError: false);
if (type2 != null)
{
return type2;
}
}
assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly2 in assemblies)
{
Type[] source;
try
{
source = assembly2.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
source = ex.Types.Where((Type t) => t != null).ToArray();
}
catch
{
continue;
}
Type type3 = source.FirstOrDefault((Type t) => t.Name == shortName || t.FullName == fullName || t.FullName == il2cppName);
if (type3 != null)
{
return type3;
}
}
return null;
}
private static object GetStaticFieldOrProp(Type type, string name)
{
if (type == null)
{
return null;
}
try
{
PropertyInfo property = type.GetProperty(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null)
{
return property.GetValue(null);
}
}
catch
{
}
try
{
return type.GetField(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null);
}
catch
{
return null;
}
}
private static object GetFieldOrProp(object obj, string name)
{
if (obj == null)
{
return null;
}
Type type = obj.GetType();
try
{
PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null)
{
return property.GetValue(obj);
}
}
catch
{
}
try
{
return type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj);
}
catch
{
return null;
}
}
private static bool SetFieldOrProp(object obj, string name, object value)
{
if (obj == null)
{
return false;
}
Type type = obj.GetType();
try
{
PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanWrite)
{
property.SetValue(obj, value);
return true;
}
}
catch
{
}
try
{
FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(obj, value);
return true;
}
}
catch
{
}
return false;
}
private static object FindFirstObjectOfType(Type type)
{
if (type == null)
{
return null;
}
try
{
foreach (object item in EnumerateItems(((s_objectType ?? FindType("UnityEngine.Object"))?.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "FindObjectsOfType" && !m.ContainsGenericParameters && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(Type)))?.Invoke(null, new object[1] { type })))
{
if (item != null)
{
return item;
}
}
}
catch
{
}
return null;
}
private static void ForEachListItem(object list, Action<object> action)
{
foreach (object item in EnumerateItems(list))
{
action(item);
}
}
private static IEnumerable<object> EnumerateItems(object list)
{
if (list == null)
{
yield break;
}
if (list is Array array)
{
foreach (object item in array)
{
yield return item;
}
yield break;
}
if (list is IEnumerable enumerable)
{
foreach (object item2 in enumerable)
{
yield return item2;
}
yield break;
}
if (!TryConvertInt(GetFieldOrProp(list, "Count"), out var count))
{
TryConvertInt(GetFieldOrProp(list, "Length"), out count);
}
if (count <= 0)
{
yield break;
}
MethodInfo getItem = list.GetType().GetMethod("get_Item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (getItem == null)
{
yield break;
}
for (int i = 0; i < count; i++)
{
object obj = null;
try
{
obj = getItem.Invoke(list, new object[1] { i });
}
catch
{
}
if (obj != null)
{
yield return obj;
}
}
}
private static bool TryConvertInt(object value, out int result)
{
try
{
if (value == null)
{
result = 0;
return false;
}
result = Convert.ToInt32(value);
return true;
}
catch
{
result = 0;
return false;
}
}
private static bool TryConvertFloat(object value, out float result)
{
try
{
if (value == null)
{
result = 0f;
return false;
}
result = Convert.ToSingle(value);
return true;
}
catch
{
result = 0f;
return false;
}
}
private static bool TryConvertBool(object value, out bool result)
{
try
{
if (value == null)
{
result = false;
return false;
}
result = Convert.ToBoolean(value);
return true;
}
catch
{
result = false;
return false;
}
}
private static void LogOverlayRenderer(string renderer, string details)
{
string b = renderer + "|" + details;
if (!string.Equals(s_lastLoggedRendererSignature, b, StringComparison.Ordinal))
{
s_lastLoggedRendererSignature = b;
LogDebug("Pickup overlay renderer=" + renderer + " " + details);
}
}
private static string GetFallbackRendererReason()
{
if (!IsTextMeshProOverlayEnabled())
{
return "reason=TextMeshPro disabled";
}
if (s_tmpOverlayFailed)
{
return "reason=TextMeshPro unavailable/retrying";
}
if (!s_tmpOverlayReady)
{
return "reason=TextMeshPro not ready";
}
return "reason=TextMeshPro ready";
}
private static string DescribeTextStyleForLog(ObjectiveTextStyle style)
{
string text = (string.IsNullOrWhiteSpace(style.Source) ? "unknown" : style.Source);
return "styleSource=" + text + " headerFont=" + style.HeaderFontSize + " rowFont=" + style.RowFontSize + " footerFont=" + style.FooterFontSize + " tmpSource={" + DescribeTmpTextSource(style.SourceText) + "}";
}
private static string DescribeTmpTextSource(object tmpText)
{
if (tmpText == null)
{
return "none";
}
try
{
string text = GetUnityObjectName(GetFieldOrProp(tmpText, "gameObject")) ?? GetUnityObjectName(tmpText) ?? tmpText.GetType().Name;
string text2 = GetFieldOrProp(tmpText, "text") as string;
float result;
string text3 = (TryConvertFloat(GetFieldOrProp(tmpText, "fontSize"), out result) ? result.ToString("0.##") : "?");
string text4 = GetCanvasScaleFactor(tmpText).ToString("0.##");
return "name='" + TruncateForLog(text, 60) + "' fontSize=" + text3 + " canvasScale=" + text4 + " text='" + TruncateForLog(text2, 60) + "'";
}
catch
{
return tmpText.GetType().Name;
}
}
private static string DescribeRectTransform(object rectTransform)
{
if (rectTransform == null)
{
return "none";
}
try
{
object fieldOrProp = GetFieldOrProp(rectTransform, "rect");
return "name='" + TruncateForLog(GetUnityObjectName(rectTransform), 50) + "' anchorMin=" + DescribeVector(GetFieldOrProp(rectTransform, "anchorMin")) + " anchorMax=" + DescribeVector(GetFieldOrProp(rectTransform, "anchorMax")) + " pivot=" + DescribeVector(GetFieldOrProp(rectTransform, "pivot")) + " anchoredPosition=" + DescribeVector(GetFieldOrProp(rectTransform, "anchoredPosition")) + " sizeDelta=" + DescribeVector(GetFieldOrProp(rectTransform, "sizeDelta")) + " rect=" + DescribeRect(fieldOrProp);
}
catch
{
return rectTransform.GetType().Name;
}
}
private static string DescribeRect(object rect)
{
if (rect == null)
{
return "none";
}
float result;
string obj = (TryConvertFloat(GetFieldOrProp(rect, "width"), out result) ? result.ToString("0.#") : "?");
float result2;
string text = (TryConvertFloat(GetFieldOrProp(rect, "height"), out result2) ? result2.ToString("0.#") : "?");
return obj + "x" + text;
}
private static string DescribeVector(object vector)
{
if (vector == null)
{
return "none";
}
float result;
bool num = TryConvertFloat(GetFieldOrProp(vector, "x"), out result);
float result2;
bool flag = TryConvertFloat(GetFieldOrProp(vector, "y"), out result2);
float result3;
bool flag2 = TryConvertFloat(GetFieldOrProp(vector, "z"), out result3);
if (!num && !flag && !flag2)
{
return vector.ToString();
}
if (!flag2)
{
return "(" + result.ToString("0.###") + "," + result2.ToString("0.###") + ")";
}
return "(" + result.ToString("0.###") + "," + result2.ToString("0.###") + "," + result3.ToString("0.###") + ")";
}
private static bool IsPickupTmpOverlayObject(object tmpText)
{
if (tmpText == null)
{
return false;
}
if (tmpText == s_tmpOverlayText)
{
return true;
}
object fieldOrProp = GetFieldOrProp(tmpText, "gameObject");
if (fieldOrProp == s_tmpOverlayTextObject || fieldOrProp == s_tmpOverlayRoot)
{
return true;
}
return (GetUnityObjectName(fieldOrProp) ?? string.Empty).IndexOf("kp0hyc PickupTabOverlay", StringComparison.OrdinalIgnoreCase) >= 0;
}
private static string GetUnityObjectName(object obj)
{
if (obj == null)
{
return null;
}
try
{
string text = GetFieldOrProp(obj, "name") as string;
if (!string.IsNullOrWhiteSpace(text))
{
return text.Trim();
}
object fieldOrProp = GetFieldOrProp(obj, "gameObject");
if (fieldOrProp != null && fieldOrProp != obj)
{
text = GetFieldOrProp(fieldOrProp, "name") as string;
if (!string.IsNullOrWhiteSpace(text))
{
return text.Trim();
}
}
}
catch
{
}
return null;
}
private static string TruncateForLog(string text, int maxLength)
{
if (string.IsNullOrWhiteSpace(text))
{
return string.Empty;
}
string text2 = text.Replace("\r", " ").Replace("\n", " ").Trim();
if (text2.Length <= maxLength)
{
return text2;
}
return text2.Substring(0, Math.Max(0, maxLength - 3)) + "...";
}
private static string TypeNameForLog(Type type)
{
object obj;
if (!(type == null))
{
obj = type.FullName;
if (obj == null)
{
return type.Name;
}
}
else
{
obj = "null";
}
return (string)obj;
}
private static int Clamp(int value, int min, int max)
{
if (value < min)
{
return min;
}
if (value <= max)
{
return value;
}
return max;
}
private static float Clamp(float value, float min, float max)
{
if (value < min)
{
return min;
}
if (!(value > max))
{
return value;
}
return max;
}
private static float Clamp01(float value)
{
if (value < 0f)
{
return 0f;
}
if (!(value > 1f))
{
return value;
}
return 1f;
}
private static void LogWarning(string message)
{
if (!(DateTime.UtcNow < s_nextWarningUtc))
{
s_nextWarningUtc = DateTime.UtcNow.AddSeconds(10.0);
MelonLogger.Warning(message);
}
}
private static void LogDebug(string message)
{
if (IsDebugLoggingEnabled())
{
MelonLogger.Msg("[Debug] " + message);
}
}
private static bool IsDebugLoggingEnabled()
{
if (s_debugLogging == null || !s_debugLogging.Value)
{
if (s_legacyDebugLogging != null)
{
return s_legacyDebugLogging.Value;
}
return false;
}
return true;
}
}
