using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
using Assets.Scripts.Actors;
using Assets.Scripts.Actors.Player;
using Assets.Scripts.Game.Combat;
using Assets.Scripts.Game.Combat.ConstantAttacks;
using Assets.Scripts.Game.MapGeneration;
using Assets.Scripts.Inventory__Items__Pickups;
using Assets.Scripts.Inventory__Items__Pickups.AbilitiesPassive;
using Assets.Scripts.Inventory__Items__Pickups.AbilitiesPassive.Implementations;
using Assets.Scripts.Inventory__Items__Pickups.Chests;
using Assets.Scripts.Inventory__Items__Pickups.Interactables;
using Assets.Scripts.Inventory__Items__Pickups.Items;
using Assets.Scripts.Inventory__Items__Pickups.Items.ItemImplementations;
using Assets.Scripts.Inventory__Items__Pickups.Pickups;
using Assets.Scripts.Inventory__Items__Pickups.Stats;
using Assets.Scripts.Inventory__Items__Pickups.Upgrades;
using Assets.Scripts.Inventory__Items__Pickups.Weapons;
using Assets.Scripts.Managers;
using Assets.Scripts.Menu.Shop;
using Assets.Scripts.Saves___Serialization.Progression.Achievements;
using Assets.Scripts.Saves___Serialization.Progression.Unlocks;
using Assets.Scripts.Steam;
using Assets.Scripts.Steam.LeaderboardsNew;
using Assets.Scripts.UI.HUD;
using Assets.Scripts.UI.InGame.Rewards;
using Assets.Scripts.UI.InGame.Rewards.Effects;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Inventory__Items__Pickups.Xp_and_Levels;
using Steamworks;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("MegaBonkMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MegaBonkMod")]
[assembly: AssemblyTitle("MegaBonkMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace MegaBonkMod;
public class ModGui : MonoBehaviour
{
internal static readonly ConcurrentQueue<Action> MainThread = new ConcurrentQueue<Action>();
private bool _visible;
private bool _authenticated;
private bool _promptVisible;
private string _passwordInput = "";
private const string Password = "kittens";
internal static bool ChartDisabled;
internal static bool NeedVersionPatch;
internal static bool UpdateAvailable;
private GameObject _statsParent;
private GameObject _damageWindow;
private GameObject _statsWindowObj;
private GameObject _questsWindow;
private Vector2 _winPos = new Vector2(20f, 20f);
private bool _dragging;
private Vector2 _dragOffset;
private bool _powerupOpen = true;
private const float FastFallSpeed = 15f;
private const float FastFallRampTime = 0.2f;
private float _fastFallTimer;
private const float WinW = 440f;
private const float PadX = 8f;
private const float LineH = 22f;
public ModGui(IntPtr ptr)
: base(ptr)
{
}//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
private unsafe void Update()
{
//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
//IL_030b: Unknown result type (might be due to invalid IL or missing references)
//IL_0351: Unknown result type (might be due to invalid IL or missing references)
//IL_0361: Unknown result type (might be due to invalid IL or missing references)
//IL_0363: Unknown result type (might be due to invalid IL or missing references)
//IL_0368: Unknown result type (might be due to invalid IL or missing references)
//IL_036d: Unknown result type (might be due to invalid IL or missing references)
//IL_0392: Unknown result type (might be due to invalid IL or missing references)
//IL_0394: Unknown result type (might be due to invalid IL or missing references)
//IL_0399: Unknown result type (might be due to invalid IL or missing references)
//IL_039e: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
Action result;
while (MainThread.TryDequeue(out result))
{
try
{
result();
}
catch
{
}
}
if (NeedVersionPatch)
{
string version = Application.version;
foreach (TextMeshProUGUI item in Object.FindObjectsOfType<TextMeshProUGUI>())
{
if (((TMP_Text)item).text != null && ((TMP_Text)item).text.Contains(version))
{
BepInPlugin val = (BepInPlugin)Attribute.GetCustomAttribute(typeof(Plugin), typeof(BepInPlugin));
string text = (((int)val == 0) ? null : ((object)val.Version)?.ToString()) ?? "?";
((TMP_Text)item).text = "Mod v" + text + " | " + ((TMP_Text)item).text;
NeedVersionPatch = false;
break;
}
}
}
if (Input.GetKeyDown((KeyCode)282))
{
if (_authenticated)
{
_visible = !_visible;
}
else
{
_promptVisible = !_promptVisible;
_passwordInput = "";
}
}
if (_promptVisible && !_authenticated)
{
string inputString = Input.inputString;
for (int i = 0; i < inputString.Length; i++)
{
char c = inputString[i];
switch (c)
{
case '\b':
if (_passwordInput.Length > 0)
{
_passwordInput = _passwordInput.Substring(0, _passwordInput.Length - 1);
}
break;
case '\n':
case '\r':
if (_passwordInput == "kittens")
{
_authenticated = true;
_promptVisible = false;
_visible = true;
}
else
{
_passwordInput = "";
}
break;
default:
_passwordInput += c;
break;
}
}
}
if (Input.GetKeyDown((KeyCode)283) && !ChartDisabled)
{
ToggleDamageChart();
}
try
{
PlayerMovement instance = PlayerMovement.Instance;
if ((Object)(object)instance != (Object)null)
{
if (*(byte*)(void*)(((Il2CppObjectBase)instance).Pointer + 223) == 0 && MyInputManager.GetButton(MyInputManager.Slide))
{
_fastFallTimer = Mathf.Min(_fastFallTimer + Time.deltaTime, 0.2f);
float num = _fastFallTimer / 0.2f;
float num2 = 15f * (num * num);
if (num2 > 0.01f)
{
Rigidbody component = ((Component)instance).GetComponent<Rigidbody>();
if ((Object)(object)component != (Object)null)
{
Vector3 velocity = component.velocity;
if (velocity.y <= 0f)
{
component.velocity = new Vector3(velocity.x, Mathf.Min(velocity.y, 0f - num2), velocity.z);
}
}
}
}
else
{
_fastFallTimer = 0f;
}
}
}
catch
{
}
if (!_visible)
{
return;
}
float x = Input.mousePosition.x;
float num3 = (float)Screen.height - Input.mousePosition.y;
Vector2 val2 = default(Vector2);
((Vector2)(ref val2))..ctor(x, num3);
if (Input.GetMouseButtonDown(0))
{
Rect val3 = default(Rect);
((Rect)(ref val3))..ctor(_winPos.x, _winPos.y, 440f, 26f);
if (((Rect)(ref val3)).Contains(val2))
{
_dragging = true;
_dragOffset = val2 - _winPos;
}
}
if (Input.GetMouseButtonUp(0))
{
_dragging = false;
}
if (_dragging && Input.GetMouseButton(0))
{
_winPos = val2 - _dragOffset;
}
}
internal void ResetChartCache()
{
_statsParent = null;
}
private void ToggleDamageChart()
{
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_018c: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((Object)(object)_statsParent == (Object)null)
{
_statsParent = GameObject.Find("GameUI/GameUI/DeathScreen/StatsWindows");
if ((Object)(object)_statsParent != (Object)null)
{
Transform obj = _statsParent.transform.Find("W_Damage");
_damageWindow = ((obj != null) ? ((Component)obj).gameObject : null);
Transform obj2 = _statsParent.transform.Find("W_Stats");
_statsWindowObj = ((obj2 != null) ? ((Component)obj2).gameObject : null);
Transform obj3 = _statsParent.transform.Find("W_Quests");
_questsWindow = ((obj3 != null) ? ((Component)obj3).gameObject : null);
}
}
if ((Object)(object)_statsParent == (Object)null)
{
return;
}
bool flag = !_statsParent.activeSelf;
_statsParent.SetActive(flag);
if ((Object)(object)_statsWindowObj != (Object)null)
{
_statsWindowObj.SetActive(!flag);
}
if ((Object)(object)_questsWindow != (Object)null)
{
_questsWindow.SetActive(!flag);
}
if (flag)
{
GameOverDamageSourcesUi componentInChildren = _statsParent.GetComponentInChildren<GameOverDamageSourcesUi>();
if ((Object)(object)componentInChildren != (Object)null)
{
componentInChildren.Start();
}
RectTransform component = _statsParent.GetComponent<RectTransform>();
if ((Object)(object)component != (Object)null)
{
component.anchorMin = new Vector2(0f, 0.5f);
component.anchorMax = new Vector2(0f, 0.5f);
component.pivot = new Vector2(0f, 0.5f);
component.anchoredPosition = new Vector2(20f, 0f);
}
}
}
catch
{
}
}
private void OnGUI()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_018b: Unknown result type (might be due to invalid IL or missing references)
//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
//IL_022a: Unknown result type (might be due to invalid IL or missing references)
//IL_034c: Unknown result type (might be due to invalid IL or missing references)
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
//IL_0240: Unknown result type (might be due to invalid IL or missing references)
//IL_0258: Unknown result type (might be due to invalid IL or missing references)
//IL_0270: Unknown result type (might be due to invalid IL or missing references)
//IL_0287: Unknown result type (might be due to invalid IL or missing references)
if (UpdateAvailable)
{
float num = 420f;
float num2 = 36f;
float num3 = ((float)Screen.width - num) / 2f;
float num4 = 8f;
GUI.Box(new Rect(num3, num4, num, num2), "");
GUI.Label(new Rect(num3 + 8f, num4 + 8f, num - 16f, 20f), "!! MegaBonk Mod is outdated — please update to the latest version !!");
}
if (_promptVisible && !_authenticated)
{
float num5 = 240f;
float num6 = 72f;
float num7 = ((float)Screen.width - num5) / 2f;
float num8 = ((float)Screen.height - num6) / 2f;
GUI.Box(new Rect(num7, num8, num5, num6), "Mod Menu Password");
GUI.Label(new Rect(num7 + 8f, num8 + 26f, num5 - 16f, 22f), new string('*', _passwordInput.Length));
GUI.Label(new Rect(num7 + 8f, num8 + 50f, num5 - 16f, 18f), "Type password + Enter");
}
else
{
if (!_visible)
{
return;
}
float x = _winPos.x;
float y = _winPos.y;
float num9 = 424f;
float num10 = x + 8f;
float num11 = 32f;
num11 += 22f;
if (_powerupOpen)
{
num11 += 88f;
}
num11 += 26f;
num11 += 30f;
GUI.Box(new Rect(x, y, 440f, num11), "MegaBonk Mod");
float num12 = y + 22f + 6f;
GUIStyle button = GUI.skin.button;
_ = GUI.skin.toggle;
_powerupOpen = GUI.Toggle(new Rect(num10, num12, num9, 22f), _powerupOpen, (_powerupOpen ? "[-] " : "[+] ") + "Spawn Powerup", button);
num12 += 24f;
if (_powerupOpen)
{
PickupManager instance = PickupManager.Instance;
PlayerMovement instance2 = PlayerMovement.Instance;
Vector3 pos = (((Object)(object)instance2 != (Object)null) ? ((Component)instance2).transform.position : Vector3.zero);
SpawnPowerupRow(instance, pos, num10, ref num12, num9, (EPickup)2, "Health", (EPickup)3, "Nuke");
SpawnPowerupRow(instance, pos, num10, ref num12, num9, (EPickup)4, "Clock", (EPickup)5, "Shield");
SpawnPowerupRow(instance, pos, num10, ref num12, num9, (EPickup)6, "Rage", (EPickup)7, "Haste");
SpawnPowerupRow(instance, pos, num10, ref num12, num9, (EPickup)8, "Stonks", (EPickup)9, "Magnet");
}
float num13 = (num9 - 4f) / 2f;
if (GUI.Button(new Rect(num10, num12, num13, 22f), "+1000 XP"))
{
GameManager instance3 = GameManager.Instance;
PlayerInventory val = ((instance3 != null) ? instance3.GetPlayerInventory() : null);
if (val != null)
{
val.AddXp(1000);
}
}
if (GUI.Button(new Rect(num10 + num13 + 4f, num12, num13, 22f), "+1000 Gold"))
{
GameManager instance4 = GameManager.Instance;
PlayerInventory val2 = ((instance4 != null) ? instance4.GetPlayerInventory() : null);
if (val2 != null)
{
val2.ChangeGold(1000);
}
}
num12 += 26f;
GUI.Label(new Rect(num10, num12 + 4f, num9, 22f), "F1 to toggle | F2 dmg chart | Drag title bar");
}
}
private static void SpawnPowerupRow(PickupManager pm, Vector3 pos, float x, ref float y, float cw, EPickup left, string leftLabel, EPickup right, string rightLabel)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
float num = (cw - 4f) / 2f;
if (GUI.Button(new Rect(x, y, num, 22f), leftLabel) && (Object)(object)pm != (Object)null)
{
pm.SpawnPickup(left, pos, 1, false, 0f);
}
if (GUI.Button(new Rect(x + num + 4f, y, num, 22f), rightLabel) && (Object)(object)pm != (Object)null)
{
pm.SpawnPickup(right, pos, 1, false, 0f);
}
y += 22f;
}
}
[HarmonyPatch(typeof(RunUnlockables), "Init")]
internal static class Patch_RunUnlockables_Init
{
[HarmonyPostfix]
private static void Postfix()
{
RemoveItemCaps();
CacheAndApplyStatBlacklist();
CacheAndApplyShrineStatBlacklist();
}
internal static void RemoveItemCaps()
{
//IL_003f: 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)
Dictionary<EItemRarity, List<ItemData>> availableItems = RunUnlockables.availableItems;
if (availableItems == null)
{
return;
}
Enumerator<EItemRarity, List<ItemData>> enumerator = availableItems.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair<EItemRarity, List<ItemData>> current = enumerator.Current;
if (current.Value == null)
{
continue;
}
Enumerator<ItemData> enumerator2 = current.Value.GetEnumerator();
while (enumerator2.MoveNext())
{
ItemData current2 = enumerator2.Current;
if (Plugin.ActiveUncappedItems.Contains(current2.eItem))
{
current2.maxAmount = Plugin.GetItemCap(current2.eItem);
current2.maxAmountPerRun = 9999;
}
}
}
}
private static void CacheAndApplyStatBlacklist()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected I4, but got Unknown
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
List<EStat> upgradableStatsChaosAndGamble = EncounterUtility.upgradableStatsChaosAndGamble;
if (upgradableStatsChaosAndGamble == null)
{
return;
}
if (Plugin.FullStatPool.Count == 0)
{
Enumerator<EStat> enumerator = upgradableStatsChaosAndGamble.GetEnumerator();
while (enumerator.MoveNext())
{
EStat current = enumerator.Current;
Plugin.FullStatPool.Add((int)current);
}
}
foreach (int blacklistedStat in Plugin.BlacklistedStats)
{
EStat val = (EStat)blacklistedStat;
if (upgradableStatsChaosAndGamble.Contains(val))
{
upgradableStatsChaosAndGamble.Remove(val);
}
}
}
private static void CacheAndApplyShrineStatBlacklist()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected I4, but got Unknown
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
List<EStat> upgradableStatsShrines = EncounterUtility.upgradableStatsShrines;
if (upgradableStatsShrines == null)
{
return;
}
if (Plugin.FullShrineStatPool.Count == 0)
{
Enumerator<EStat> enumerator = upgradableStatsShrines.GetEnumerator();
while (enumerator.MoveNext())
{
EStat current = enumerator.Current;
Plugin.FullShrineStatPool.Add((int)current);
}
}
foreach (int blacklistedShrineStat in Plugin.BlacklistedShrineStats)
{
EStat val = (EStat)blacklistedShrineStat;
if (upgradableStatsShrines.Contains(val))
{
upgradableStatsShrines.Remove(val);
}
}
}
}
[HarmonyPatch(typeof(RunUnlockables), "OnNewRunStarted")]
internal static class Patch_RunUnlockables_OnNewRunStarted
{
[HarmonyPostfix]
private static void Postfix()
{
Patch_RunUnlockables_Init.RemoveItemCaps();
}
}
[HarmonyPatch(typeof(MicrowaveItemButton), "SelectUpgrade")]
internal static class Patch_MicrowaveItemButton_SelectUpgrade
{
[HarmonyPrefix]
private unsafe static void Prefix(MicrowaveItemButton __instance)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
long num = *(long*)(void*)(((Il2CppObjectBase)__instance).Pointer + 104);
if (num == 0L)
{
return;
}
EItem item = (EItem)(*(int*)(num + 84));
if (Plugin.ActiveUncappedItems.Contains(item))
{
int num2 = *(int*)(num + 112);
if (num2 > 0)
{
*(int*)(num + 112) = num2 + 1;
}
}
}
}
[HarmonyPatch(typeof(ItemGrandmasSecretTonic), "OnInitOrAmountChanged")]
internal static class Patch_GrandmasTonic_SizeCap
{
private const float BaseRadius = 4f;
private const float RadiusPerAmount = 2f;
private const float MaxRadius = 16f;
private const int MaxStacks = 6;
[HarmonyPrefix]
private unsafe static void Prefix(ItemGrandmasSecretTonic __instance)
{
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 60) = 16f;
}
[HarmonyPostfix]
private unsafe static void Postfix(ItemGrandmasSecretTonic __instance)
{
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 52) = 4f;
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 56) = 2f;
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 60) = 16f;
int num = *(int*)(void*)(((Il2CppObjectBase)__instance).Pointer + 24);
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 64) = Math.Min(4f + (float)num * 2f, 16f);
DataManager instance = DataManager.Instance;
ItemData val = ((instance != null) ? instance.GetItem((EItem)11) : null);
if (!((Object)(object)val == (Object)null))
{
int maxAmount = (val.maxAmountPerRun = 6);
val.maxAmount = maxAmount;
}
}
}
[HarmonyPatch(typeof(ItemSpicyMeatball), "OnInitOrAmountChanged")]
internal static class Patch_SpicyMeatball_Radius
{
private const float BaseRadius = 8f;
private const float RadiusPerAmount = 4f;
private const float MaxRadius = 32f;
[HarmonyPrefix]
private unsafe static void Prefix(ItemSpicyMeatball __instance)
{
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 56) = 32f;
}
[HarmonyPostfix]
private unsafe static void Postfix(ItemSpicyMeatball __instance)
{
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 48) = 8f;
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 52) = 4f;
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 56) = 32f;
int num = *(int*)(void*)(((Il2CppObjectBase)__instance).Pointer + 24);
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 60) = Math.Min(8f + (float)num * 4f, 32f);
}
}
[HarmonyPatch(typeof(ItemBobLantern), "OnInitOrAmountChanged")]
internal static class Patch_BobLantern_FireRate
{
[HarmonyPostfix]
private unsafe static void Postfix(ItemBobLantern __instance)
{
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 60) /= 2f;
}
}
[HarmonyPatch(typeof(ItemBrassKnuckles), "OnInitOrAmountChanged")]
internal static class Patch_BrassKnuckles_SizeCap
{
[HarmonyPrefix]
private unsafe static void Prefix(ItemBrassKnuckles __instance)
{
*(float*)(void*)(((Il2CppObjectBase)__instance).Pointer + 56) = float.MaxValue;
}
}
[HarmonyPatch(typeof(ItemBackpack), "OnInitOrAmountChanged")]
internal static class Patch_ItemBackpack_Projectiles
{
[HarmonyPrefix]
private unsafe static void Prefix(ItemBackpack __instance)
{
*(int*)(void*)(((Il2CppObjectBase)__instance).Pointer + 24) *= 2;
}
[HarmonyPostfix]
private unsafe static void Postfix(ItemBackpack __instance)
{
*(int*)(void*)(((Il2CppObjectBase)__instance).Pointer + 24) /= 2;
}
}
[HarmonyPatch(typeof(ItemData), "CompareTo", new Type[] { typeof(UnlockableBase) })]
internal static class Patch_ItemData_CompareTo_SuckyMagnet
{
private static readonly HashSet<EItem> SortsFirst = new HashSet<EItem>
{
(EItem)33,
(EItem)40,
(EItem)32,
(EItem)55,
(EItem)56,
(EItem)19,
(EItem)38,
(EItem)82,
(EItem)7,
(EItem)0
};
private static readonly HashSet<EItem> SortsLast = new HashSet<EItem>
{
(EItem)58,
(EItem)1,
(EItem)2,
(EItem)43,
(EItem)72,
(EItem)8,
(EItem)59,
(EItem)4,
(EItem)42,
(EItem)23
};
[HarmonyPrefix]
private static bool Prefix(ItemData __instance, UnlockableBase other, ref int __result)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
ItemData val = (ItemData)(object)((other is ItemData) ? other : null);
if (val == null)
{
return true;
}
if (__instance.rarity != val.rarity)
{
return true;
}
bool flag = SortsFirst.Contains(__instance.eItem);
bool flag2 = SortsFirst.Contains(val.eItem);
bool flag3 = SortsLast.Contains(__instance.eItem);
bool flag4 = SortsLast.Contains(val.eItem);
if (flag && !flag2)
{
__result = -1;
return false;
}
if (flag2 && !flag)
{
__result = 1;
return false;
}
if (flag3 && !flag4)
{
__result = 1;
return false;
}
if (flag4 && !flag3)
{
__result = -1;
return false;
}
if (flag3 && flag4)
{
__result = 0;
return false;
}
return true;
}
}
[HarmonyPatch(typeof(MyAchievements), "CanToggleActivation")]
internal static class Patch_CanToggleActivation_NonToggleable
{
[HarmonyPrefix]
private static bool Prefix(UnlockableBase unlockable, ref bool __result)
{
DataManager instance = DataManager.Instance;
if ((Object)(object)instance == (Object)null)
{
return true;
}
if ((Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)40) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)33) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)32) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)55) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)56) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)19))
{
__result = false;
return false;
}
if ((Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)72) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)8) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)59) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)4) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)42) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)23))
{
__result = true;
return false;
}
if ((Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)38) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)82) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)7) || (Object)(object)unlockable == (Object)(object)instance.GetItem((EItem)0))
{
__result = false;
return false;
}
return true;
}
}
[HarmonyPatch(typeof(MyAchievements), "IsAvailable")]
internal static class Patch_IsAvailable_ForcedItems
{
[HarmonyPrefix]
private static bool Prefix(UnlockableBase unlockable, ref bool __result)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
DataManager instance = DataManager.Instance;
if ((Object)(object)instance == (Object)null)
{
return true;
}
foreach (EItem forcedPoolItem in Plugin.ForcedPoolItems)
{
if ((Object)(object)unlockable == (Object)(object)instance.GetItem(forcedPoolItem))
{
__result = true;
return false;
}
}
return true;
}
}
[HarmonyPatch(typeof(DataManager), "Load")]
internal static class Patch_DataManager_Load
{
[HarmonyPostfix]
private unsafe static void Postfix(DataManager __instance)
{
//IL_0644: Unknown result type (might be due to invalid IL or missing references)
//IL_0649: Unknown result type (might be due to invalid IL or missing references)
//IL_064c: Unknown result type (might be due to invalid IL or missing references)
//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
//IL_0306: Unknown result type (might be due to invalid IL or missing references)
//IL_0309: Unknown result type (might be due to invalid IL or missing references)
//IL_051c: Unknown result type (might be due to invalid IL or missing references)
//IL_051f: Unknown result type (might be due to invalid IL or missing references)
//IL_0567: Unknown result type (might be due to invalid IL or missing references)
//IL_056e: Invalid comparison between Unknown and I4
List<TomeData> allTomes = __instance.GetAllTomes();
if (allTomes != null)
{
for (int i = 0; i < allTomes.Count; i++)
{
((UnlockableBase)allTomes[i]).canAlwaysToggle = true;
}
}
List<WeaponData> allWeapons = __instance.GetAllWeapons();
if (allWeapons != null)
{
for (int j = 0; j < allWeapons.Count; j++)
{
((UnlockableBase)allWeapons[j]).canAlwaysToggle = true;
UpgradeData upgradeData = allWeapons[j].upgradeData;
if (((upgradeData != null) ? upgradeData.upgradeModifiers : null) != null)
{
AddUpgradeStat(upgradeData.upgradeModifiers, (EStat)18, 0.1f);
AddUpgradeStat(upgradeData.upgradeModifiers, (EStat)19, 0.2f);
RemoveStat(upgradeData.upgradeModifiers, 24);
}
}
}
ItemData item = __instance.GetItem((EItem)58);
if ((Object)(object)item != (Object)null)
{
((UnlockableBase)item).canAlwaysToggle = true;
}
ItemData item2 = __instance.GetItem((EItem)85);
ItemData item3 = __instance.GetItem((EItem)44);
if ((Object)(object)item2 != (Object)null)
{
item2.rarity = (EItemRarity)3;
}
if ((Object)(object)item3 != (Object)null)
{
item3.rarity = (EItemRarity)2;
}
ItemData item4 = __instance.GetItem((EItem)45);
ItemData item5 = __instance.GetItem((EItem)2);
if ((Object)(object)item4 != (Object)null)
{
item4.rarity = (EItemRarity)2;
}
if ((Object)(object)item5 != (Object)null)
{
item5.rarity = (EItemRarity)1;
((UnlockableBase)item5).canAlwaysToggle = true;
}
ItemData item6 = __instance.GetItem((EItem)33);
ItemData item7 = __instance.GetItem((EItem)40);
if ((Object)(object)item6 != (Object)null)
{
item6.rarity = (EItemRarity)2;
((UnlockableBase)item6).canAlwaysToggle = false;
((UnlockableBase)item6).sortingPriority = -1000;
}
if ((Object)(object)item7 != (Object)null)
{
item7.rarity = (EItemRarity)1;
((UnlockableBase)item7).canAlwaysToggle = false;
}
ItemData item8 = __instance.GetItem((EItem)34);
ItemData item9 = __instance.GetItem((EItem)43);
if ((Object)(object)item8 != (Object)null)
{
item8.rarity = (EItemRarity)0;
((UnlockableBase)item8).canAlwaysToggle = false;
}
if ((Object)(object)item9 != (Object)null)
{
item9.rarity = (EItemRarity)3;
((UnlockableBase)item9).canAlwaysToggle = true;
}
ItemData item10 = __instance.GetItem((EItem)1);
if ((Object)(object)item10 != (Object)null)
{
((UnlockableBase)item10).canAlwaysToggle = true;
}
ItemData item11 = __instance.GetItem((EItem)32);
ItemData item12 = __instance.GetItem((EItem)55);
ItemData item13 = __instance.GetItem((EItem)56);
ItemData item14 = __instance.GetItem((EItem)19);
if ((Object)(object)item11 != (Object)null)
{
((UnlockableBase)item11).canAlwaysToggle = false;
}
if ((Object)(object)item12 != (Object)null)
{
((UnlockableBase)item12).canAlwaysToggle = false;
}
if ((Object)(object)item13 != (Object)null)
{
((UnlockableBase)item13).canAlwaysToggle = false;
}
if ((Object)(object)item14 != (Object)null)
{
((UnlockableBase)item14).canAlwaysToggle = false;
}
ItemData item15 = __instance.GetItem((EItem)72);
ItemData item16 = __instance.GetItem((EItem)8);
if ((Object)(object)item15 != (Object)null)
{
((UnlockableBase)item15).canAlwaysToggle = true;
}
if ((Object)(object)item16 != (Object)null)
{
item16.rarity = (EItemRarity)1;
((UnlockableBase)item16).canAlwaysToggle = true;
}
EItem[] array = new EItem[4];
RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
EItem[] array2 = (EItem[])(object)array;
foreach (EItem val in array2)
{
ItemData item17 = __instance.GetItem(val);
if ((Object)(object)item17 != (Object)null)
{
((UnlockableBase)item17).canAlwaysToggle = true;
}
}
EItem[] array3 = new EItem[4];
RuntimeHelpers.InitializeArray(array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
array2 = (EItem[])(object)array3;
foreach (EItem val2 in array2)
{
ItemData item18 = __instance.GetItem(val2);
if ((Object)(object)item18 != (Object)null)
{
((UnlockableBase)item18).canAlwaysToggle = false;
}
}
List<CharacterData> unsortedCharacterData = __instance.unsortedCharacterData;
if (unsortedCharacterData != null)
{
for (int l = 0; l < unsortedCharacterData.Count; l++)
{
CharacterData val3 = unsortedCharacterData[l];
if (((val3 != null) ? val3.statModifiers : null) == null)
{
continue;
}
List<StatModifier> statModifiers = val3.statModifiers;
float num = 0f;
float num2 = 0f;
float num3 = 0f;
for (int m = 0; m < statModifiers.Count; m++)
{
StatModifier val4 = statModifiers[m];
if (val4 != null)
{
int num4 = *(int*)(void*)(((Il2CppObjectBase)val4).Pointer + 16);
float num5 = *(float*)(void*)(((Il2CppObjectBase)val4).Pointer + 24);
switch (num4)
{
case 25:
num += num5;
break;
case 26:
num2 += num5;
break;
case 29:
num3 += num5;
break;
}
}
}
float num6 = 0.2f - num;
float value = 3f - num2;
float value2 = 5f - num3;
if (num6 > 0.001f)
{
AppendFlat(val3.statModifiers, (EStat)25, num6);
}
if (Math.Abs(value) > 0.001f)
{
AppendFlat(val3.statModifiers, (EStat)26, value);
}
if (Math.Abs(value2) > 0.001f)
{
AppendFlat(val3.statModifiers, (EStat)29, value2);
}
float num7 = 0f;
for (int n = 0; n < statModifiers.Count; n++)
{
StatModifier val5 = statModifiers[n];
if (val5 != null && *(int*)(void*)(((Il2CppObjectBase)val5).Pointer + 16) == 2)
{
num7 += *(float*)(void*)(((Il2CppObjectBase)val5).Pointer + 24);
}
}
if (num7 < 1f)
{
AppendFlat(val3.statModifiers, (EStat)2, 10f);
}
}
}
EWeapon[] array4 = (EWeapon[])(object)new EWeapon[2]
{
(EWeapon)6,
(EWeapon)3
};
foreach (EWeapon val6 in array4)
{
WeaponData weapon = __instance.GetWeapon(val6);
object obj;
if (weapon == null)
{
obj = null;
}
else
{
UpgradeData upgradeData2 = weapon.upgradeData;
obj = ((upgradeData2 != null) ? upgradeData2.upgradeModifiers : null);
}
if (obj == null)
{
continue;
}
bool flag = false;
for (int num8 = 0; num8 < weapon.upgradeData.upgradeModifiers.Count; num8++)
{
StatModifier val7 = weapon.upgradeData.upgradeModifiers[num8];
if (val7 != null && (int)val7.stat == 16)
{
val7.modification = 2f;
flag = true;
break;
}
}
if (!flag)
{
AddUpgradeStat(weapon.upgradeData.upgradeModifiers, (EStat)16, 2f);
}
}
try
{
IntPtr intPtr = IL2CPP.il2cpp_class_from_name(IL2CPP.il2cpp_class_get_image(IL2CPP.il2cpp_object_get_class(((Il2CppObjectBase)__instance).Pointer)), "Assets.Scripts.Game.Combat", "CombatScaling");
if (intPtr != IntPtr.Zero)
{
IntPtr intPtr2 = *(IntPtr*)(void*)(intPtr + 184);
if (intPtr2 != IntPtr.Zero)
{
*(float*)(void*)(intPtr2 + 12) = 0f;
}
}
}
catch
{
}
foreach (EItem forcedPoolItem in Plugin.ForcedPoolItems)
{
ItemData item19 = __instance.GetItem(forcedPoolItem);
if ((Object)(object)item19 != (Object)null)
{
item19.inItemPool = true;
((UnlockableBase)item19).isEnabled = true;
}
}
}
private unsafe static void RemoveStat(List<StatModifier> mods, int statInt)
{
for (int num = mods.Count - 1; num >= 0; num--)
{
StatModifier val = mods[num];
if (val != null && *(int*)(void*)(((Il2CppObjectBase)val).Pointer + 16) == statInt)
{
mods.RemoveAt(num);
}
}
}
private static void AppendFlat(List<StatModifier> mods, EStat stat, float value)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
StatModifier val = new StatModifier();
val.stat = stat;
val.modifyType = (EStatModifyType)2;
val.modification = value;
mods.Add(val);
}
private static void AddUpgradeStat(List<StatModifier> mods, EStat stat, float modification)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < mods.Count; i++)
{
if (mods[i].stat == stat)
{
return;
}
}
StatModifier val = new StatModifier();
val.stat = stat;
val.modifyType = (EStatModifyType)2;
val.modification = modification;
mods.Add(val);
}
}
[HarmonyPatch(typeof(InteractableChest), "Start")]
internal static class Patch_Chest_MinimapIcon
{
[HarmonyPostfix]
private static void Postfix(InteractableChest __instance)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Invalid comparison between Unknown and I4
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Invalid comparison between Unknown and I4
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
Color color = default(Color);
if ((int)__instance.chestType == 0)
{
((Color)(ref color))..ctor(0.55f, 0.28f, 0.08f);
}
else
{
if ((int)__instance.chestType != 2 && (int)__instance.chestType != 3)
{
return;
}
((Color)(ref color))..ctor(1f, 0.85f, 0.1f);
}
Transform icon = __instance.icon;
if (!((Object)(object)icon == (Object)null))
{
IconColorHelper.ApplyColor(((Component)icon).gameObject, color);
icon.localScale *= 0.5f;
}
}
}
[HarmonyPatch(typeof(InteractableMicrowave), "Start")]
internal static class Patch_Microwave_Start
{
[HarmonyPostfix]
private static void Postfix(InteractableMicrowave __instance)
{
MicrowaveIconHelper.ApplyMicrowaveColor(__instance, scaleDown: true);
}
}
[HarmonyPatch(typeof(InteractableMicrowave), "set_rarity")]
internal static class Patch_Microwave_SetRarity
{
[HarmonyPostfix]
private static void Postfix(InteractableMicrowave __instance)
{
MicrowaveIconHelper.ApplyMicrowaveColor(__instance);
}
}
internal static class MicrowaveIconHelper
{
private const int MinimapIconOffset = 216;
internal unsafe static void ApplyMicrowaveColor(InteractableMicrowave instance, bool scaleDown = false)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
GameObject val = instance.minimapIcon;
if ((Object)(object)val == (Object)null)
{
IntPtr intPtr = *(IntPtr*)(void*)(((Il2CppObjectBase)instance).Pointer + 216);
if (intPtr == IntPtr.Zero)
{
return;
}
val = new GameObject(intPtr);
}
IconColorHelper.ApplyColor(val, IconColorHelper.MicrowaveRarityColor(instance.rarity));
if (scaleDown)
{
Transform transform = val.transform;
transform.localScale *= 0.5f;
}
}
}
internal static class IconColorHelper
{
internal static Color MicrowaveRarityColor(EItemRarity rarity)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Expected I4, but got Unknown
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
return (Color)((rarity - 1) switch
{
0 => new Color(0.5f, 0.75f, 1f),
1 => new Color(0.8f, 0.6f, 1f),
2 => new Color(1f, 0.95f, 0.6f),
_ => Color.white,
});
}
internal static Color ShadyGuyRarityColor(EItemRarity rarity)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Expected I4, but got Unknown
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
return (Color)((rarity - 1) switch
{
0 => new Color(0.1f, 0.25f, 0.7f),
1 => new Color(0.35f, 0.05f, 0.6f),
2 => new Color(0.7f, 0.5f, 0.05f),
_ => new Color(0.6f, 0.6f, 0.6f),
});
}
internal static void ApplyColor(GameObject go, Color color)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
Renderer val = go.GetComponent<Renderer>();
if ((Object)(object)val == (Object)null)
{
val = go.GetComponentInChildren<Renderer>();
}
if (!((Object)(object)val == (Object)null))
{
Material material = val.material;
material.mainTexture = (Texture)(object)Texture2D.whiteTexture;
material.color = color;
}
}
}
[HarmonyPatch(typeof(BaseInteractable), "Start")]
internal static class Patch_BaseInteractable_Start
{
[HarmonyPostfix]
private static void Postfix(BaseInteractable __instance)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
InteractableShrineCursed val = ((Il2CppObjectBase)__instance).TryCast<InteractableShrineCursed>();
if ((Object)(object)val != (Object)null)
{
ApplyShrineColor(val.minimapIcon, 88, ((Il2CppObjectBase)val).Pointer, new Color(1f, 0.4f, 0.4f));
return;
}
InteractableShrineChallenge val2 = ((Il2CppObjectBase)__instance).TryCast<InteractableShrineChallenge>();
if ((Object)(object)val2 != (Object)null)
{
ApplyShrineColor(val2.minimapIcon, 88, ((Il2CppObjectBase)val2).Pointer, new Color(1f, 0.4f, 0.7f));
return;
}
InteractableShrineMagnet val3 = ((Il2CppObjectBase)__instance).TryCast<InteractableShrineMagnet>();
if ((Object)(object)val3 != (Object)null)
{
ApplyShrineColor(val3.minimapIcon, 88, ((Il2CppObjectBase)val3).Pointer, Color.black);
}
}
private unsafe static void ApplyShrineColor(GameObject icon, int offset, IntPtr ptr, Color color)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
if ((Object)(object)icon == (Object)null)
{
IntPtr intPtr = *(IntPtr*)(void*)(ptr + offset);
if (intPtr == IntPtr.Zero)
{
return;
}
icon = new GameObject(intPtr);
}
IconColorHelper.ApplyColor(icon, color);
Transform transform = icon.transform;
transform.localScale *= 0.5f;
}
}
[HarmonyPatch(typeof(InteractableShadyGuy), "Start")]
internal static class Patch_ShadyGuy_Start
{
[HarmonyPostfix]
private static void Postfix(InteractableShadyGuy __instance)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
Transform parent = ((Component)__instance).transform.parent;
if ((Object)(object)parent == (Object)null)
{
return;
}
for (int i = 0; i < parent.childCount; i++)
{
Transform child = parent.GetChild(i);
if (((Component)child).gameObject.layer == 14)
{
IconColorHelper.ApplyColor(((Component)child).gameObject, IconColorHelper.ShadyGuyRarityColor(__instance.rarity));
child.localScale *= 0.5f;
break;
}
}
}
}
[HarmonyPatch]
internal static class Patch_MicrowaveSpawnCount
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(typeof(RandomObjectPlacer), "RandomObjectSpawner", new Type[2]
{
typeof(RandomMapObject),
typeof(float)
}, (Type[])null);
}
[HarmonyPrefix]
private static void Prefix(RandomMapObject randomObject)
{
if (((randomObject != null) ? randomObject.prefabs : null) == null)
{
return;
}
foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)randomObject.prefabs)
{
if (!((Object)(object)item == (Object)null) && ((Object)item).name.IndexOf("Microwave", StringComparison.OrdinalIgnoreCase) >= 0)
{
randomObject.amount = 2;
randomObject.maxAmount = 3;
break;
}
}
}
}
[HarmonyPatch(typeof(InteractableShrineGreed), "Interact")]
internal static class Patch_ShrineGreed_Stats
{
private static readonly ManualLogSource Log = Logger.CreateLogSource("MegaBonkMod.ShrineGreed");
private static bool _wasNotDone;
[HarmonyPrefix]
private static void Prefix(InteractableShrineGreed __instance)
{
_wasNotDone = !__instance.done;
}
[HarmonyPostfix]
private static void Postfix(InteractableShrineGreed __instance)
{
if (_wasNotDone && __instance.done)
{
Apply((EStat)32, 0.05f, (EStatModifyType)0);
Apply((EStat)30, 0.05f, (EStatModifyType)2);
}
}
private static void Apply(EStat stat, float amount, EStatModifyType modType = 2)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
try
{
StatModifier val = new StatModifier();
val.stat = stat;
val.modifyType = modType;
val.modification = amount;
new EffectStat
{
effectType = (EEncounterEffect)0,
statModifier = val,
permanent = true
}.ApplyEffect();
try
{
UiManager instance = UiManager.Instance;
if (instance != null)
{
ScoreUi scoreUi = instance.scoreUi;
if (scoreUi != null)
{
scoreUi.AddScore(val, true, true, 1f);
}
}
}
catch
{
}
}
catch (Exception ex)
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(14, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Apply ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<EStat>(stat);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" threw: ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
}
Log.LogError(val2);
}
}
}
[HarmonyPatch(typeof(InteractablePot), "SpawnStuff")]
internal static class Patch_InteractablePot_SpawnStuff
{
private static readonly EPickup[] Powerups;
[HarmonyPrefix]
private static void Prefix(ref EPickup ePickup)
{
if ((int)ePickup == 2)
{
ePickup = Powerups[Random.Range(0, Powerups.Length)];
}
}
static Patch_InteractablePot_SpawnStuff()
{
EPickup[] array = new EPickup[8];
RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
Powerups = (EPickup[])(object)array;
}
}
[HarmonyPatch(typeof(PlayerHealth), "OnPickup")]
internal static class Patch_PlayerHealth_OnPickup_FullHeal
{
[HarmonyPrefix]
private static bool Prefix(PlayerHealth __instance, Pickup pickup)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
if ((Object)(object)pickup == (Object)null || (int)pickup.ePickup != 2)
{
return true;
}
__instance.Heal((float)__instance.maxHp, false);
return false;
}
}
[HarmonyPatch(typeof(ItemInventory), "AddItem", new Type[]
{
typeof(EItem),
typeof(int)
})]
internal static class Patch_GoldenRing_Add
{
[HarmonyPostfix]
private static void Postfix(EItem eItem, int count)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
if ((int)eItem != 79)
{
return;
}
try
{
PlayerInventory playerInventory = MapController.GetPlayerInventory((CharacterData)null);
if (playerInventory != null)
{
playerInventory.banishes += count;
}
}
catch
{
}
}
}
[HarmonyPatch(typeof(ItemInventory), "RemoveItem", new Type[]
{
typeof(EItem),
typeof(bool)
})]
internal static class Patch_GoldenRing_Remove
{
[HarmonyPostfix]
private static void Postfix(EItem eItem)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
if ((int)eItem != 79)
{
return;
}
try
{
PlayerInventory playerInventory = MapController.GetPlayerInventory((CharacterData)null);
if (playerInventory != null)
{
playerInventory.banishes = Math.Max(0, playerInventory.banishes - 1);
}
}
catch
{
}
}
}
[HarmonyPatch(typeof(ItemEchoShard), "GetExtraShards")]
internal static class Patch_EchoShard_Overflow
{
[HarmonyPostfix]
private static void Postfix(ItemEchoShard __instance, ref int __result)
{
float chance = __instance.chance;
if (!(chance <= 1f))
{
int num = (int)chance;
float num2 = chance - (float)num;
__result = num + ((Random.value < num2) ? 1 : 0);
}
}
}
[HarmonyPatch(typeof(Leaderboards), "UploadScore")]
internal static class Patch_Leaderboard_UploadScore_Entry
{
private static readonly ManualLogSource Log = Logger.CreateLogSource("MegaBonkMod.LbUpload");
private static int _lastScore;
private static float _lastTime = -999f;
[HarmonyPrefix]
private unsafe static bool Prefix(int score)
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Expected O, but got Unknown
try
{
if (score == _lastScore && Time.realtimeSinceStartup - _lastTime < 5f)
{
return false;
}
_lastScore = score;
_lastTime = Time.realtimeSinceStartup;
int character = 0;
PlayerMovement instance = PlayerMovement.Instance;
if ((Object)(object)instance != (Object)null)
{
character = *(int*)(void*)(((Il2CppObjectBase)instance).Pointer + 440);
}
LeaderboardRelay.SendBothBoards(score, character);
}
catch (Exception ex)
{
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(16, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Capture failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
Log.LogWarning(val);
}
return false;
}
}
[HarmonyPatch(typeof(SteamLeaderboardsManagerNew), "QueueLeaderboardUpload")]
internal static class Patch_Leaderboard_Queue
{
[HarmonyPrefix]
private static bool Prefix()
{
return false;
}
}
[HarmonyPatch(typeof(EffectManager), "SpawnTornadoes")]
internal static class Patch_DisableTornadoes
{
[HarmonyPrefix]
private static bool Prefix()
{
return false;
}
}
[HarmonyPatch(typeof(SteamLeaderboardsManagerNew), "UploadLeaderboardScore")]
internal static class Patch_Leaderboard_UploadDirect
{
[HarmonyPrefix]
private static bool Prefix()
{
return false;
}
}
[HarmonyPatch(typeof(Leaderboards), "CanShowScore")]
internal static class Patch_CanShowScore
{
[HarmonyPrefix]
private static bool Prefix(int score, ref string s, ref bool __result)
{
s = score.ToString("N0");
__result = true;
return false;
}
}
[HarmonyPatch(typeof(SteamLeaderboardsManagerNew), "DownloadLeaderboardEntries")]
internal static class Patch_Leaderboard_Download
{
private static readonly ManualLogSource Log = Logger.CreateLogSource("MegaBonkMod.LbDownload");
[HarmonyPrefix]
private static bool Prefix(string lbName)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
if (!LeaderboardRelay.Enabled)
{
return true;
}
SteamLeaderboardNew val = FindBoard(lbName);
if (val != null)
{
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(42, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Starting fetch for board '");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(val.lbName);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("' (requested '");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(lbName);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("')");
}
Log.LogInfo(val2);
LeaderboardInjector.BeginFetch(val);
}
return true;
}
internal static SteamLeaderboardNew FindBoard(string lbName)
{
SteamLeaderboardNew leaderboardKillsAllTime = SteamLeaderboardsManagerNew.leaderboardKillsAllTime;
SteamLeaderboardNew leaderboardKillsWeekly = SteamLeaderboardsManagerNew.leaderboardKillsWeekly;
if (leaderboardKillsAllTime != null && (leaderboardKillsAllTime.lbName == lbName || leaderboardKillsAllTime.lbNameFriends == lbName))
{
return leaderboardKillsAllTime;
}
if (leaderboardKillsWeekly != null && (leaderboardKillsWeekly.lbName == lbName || leaderboardKillsWeekly.lbNameFriends == lbName))
{
return leaderboardKillsWeekly;
}
return null;
}
}
[HarmonyPatch(typeof(SteamLeaderboardNew), "OnDownloadResultsGlobal")]
internal static class Patch_OnDownloadResultsGlobal
{
[HarmonyPostfix]
private static void Postfix(SteamLeaderboardNew __instance)
{
if (LeaderboardRelay.Enabled)
{
LeaderboardInjector.ReplaceEntriesIfReady(__instance);
}
}
}
[HarmonyPatch(typeof(SteamLeaderboardNew), "OnDownloadResultsFriends")]
internal static class Patch_OnDownloadResultsFriends
{
[HarmonyPostfix]
private static void Postfix(SteamLeaderboardNew __instance)
{
if (!LeaderboardRelay.Enabled)
{
return;
}
SteamLeaderboardNew leaderboardKillsAllTime = SteamLeaderboardsManagerNew.leaderboardKillsAllTime;
SteamLeaderboardNew leaderboardKillsWeekly = SteamLeaderboardsManagerNew.leaderboardKillsWeekly;
if (__instance == leaderboardKillsAllTime || __instance == leaderboardKillsWeekly)
{
LeaderboardInjector.ServerEntry[] cachedEntries = LeaderboardInjector.CachedEntries;
if (cachedEntries != null && cachedEntries.Length != 0)
{
__instance.friendsEntries = LeaderboardInjector.BuildFriendsList(cachedEntries);
}
}
}
}
internal static class LeaderboardRelay
{
private static readonly ManualLogSource Log = Logger.CreateLogSource("MegaBonkMod.Leaderboard");
private static string Base => Plugin.LeaderboardServer.TrimEnd('/');
internal static bool Enabled => !string.IsNullOrEmpty(Plugin.LeaderboardServer);
internal static void SendBothBoards(int score, int character)
{
Send("kills", score, character);
}
internal static void Send(string board, int score, int character)
{
if (!Enabled)
{
return;
}
Task.Run<Task>((Func<Task>)async delegate
{
bool flag = default(bool);
try
{
ulong steamID = SteamUser.GetSteamID().m_SteamID;
string name = SteamFriends.GetPersonaName();
string content = $"{{\"board\":\"{board}\",\"score\":{score},\"steamId\":\"{steamID}\",\"name\":{JsonSerializer.Serialize(name)},\"characterIndex\":{character},\"modVersion\":\"{"1.3.10"}\",\"timestamp\":{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}}}";
using HttpClient client = new HttpClient
{
Timeout = TimeSpan.FromSeconds(5.0)
};
StringContent content2 = new StringContent(content, Encoding.UTF8, "application/json");
await client.PostAsync(Base + "/submit", content2);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(33, 4, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Submitted score ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(score);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" char=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(character);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" on '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(board);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' as ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
}
Log.LogInfo(val);
}
catch (Exception ex)
{
BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(32, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Leaderboard server unreachable: ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
}
Log.LogWarning(val2);
}
});
}
internal static async Task<string> FetchEntries(string board, int count = 20)
{
if (!Enabled)
{
return "";
}
try
{
using HttpClient client = new HttpClient
{
Timeout = TimeSpan.FromSeconds(5.0)
};
return await client.GetStringAsync($"{Base}/entries?board={Uri.EscapeDataString(board)}&count={count}");
}
catch
{
return "";
}
}
}
[HarmonyPatch(typeof(ProjectileBluetooth), "HitTarget")]
internal static class Patch_BT_HitTarget_ElementFix
{
internal static bool Active;
[HarmonyPrefix]
private static void Prefix()
{
Active = true;
}
[HarmonyPostfix]
private static void Postfix()
{
Active = false;
}
}
[HarmonyPatch]
internal static class Patch_GetDamageContainer_BluetoothFix
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(typeof(WeaponUtility), "GetDamageContainer", new Type[5]
{
typeof(WeaponBase),
AccessTools.TypeByName("ProjectileBase"),
AccessTools.TypeByName("Enemy"),
typeof(Vector3),
typeof(float)
}, (Type[])null);
}
[HarmonyPostfix]
private static void Postfix(DamageContainer __result)
{
if (Patch_BT_HitTarget_ElementFix.Active && __result != null)
{
__result.element = (EElement)1;
}
}
}
internal static class LeaderboardInjector
{
internal class ServerEntry
{
[JsonPropertyName("score")]
public int Score { get; set; }
[JsonPropertyName("steamId")]
public string SteamId { get; set; } = "";
[JsonPropertyName("name")]
public string Name { get; set; } = "";
[JsonPropertyName("characterIndex")]
public int CharacterIndex { get; set; }
}
private static readonly ManualLogSource Log = Logger.CreateLogSource("MegaBonkMod.LbInject");
private static volatile ServerEntry[] _cache = null;
private static volatile bool _fetching = false;
private static volatile SteamLeaderboardNew _pending = null;
internal static ServerEntry[] CachedEntries => _cache;
internal static bool IsFetching => _fetching;
internal static void BeginFetch(SteamLeaderboardNew lb)
{
if (_fetching)
{
return;
}
_fetching = true;
Task.Run<Task>((Func<Task>)async delegate
{
try
{
ServerEntry[] entries = Parse(await LeaderboardRelay.FetchEntries("kills", 50));
ModGui.MainThread.Enqueue(delegate
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
_cache = entries;
_fetching = false;
bool flag2 = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(32, 1, ref flag2);
if (flag2)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Fetch 'kills' complete: ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(entries.Length);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" entries");
}
Log.LogInfo(val2);
SteamLeaderboardNew pending = _pending;
_pending = null;
if (pending != null && entries.Length != 0)
{
Replace(pending, entries);
}
});
}
catch (Exception ex)
{
_fetching = false;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(21, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Fetch 'kills' error: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
Log.LogError(val);
}
});
}
internal static void ReplaceEntriesIfReady(SteamLeaderboardNew lb)
{
SteamLeaderboardNew leaderboardKillsAllTime = SteamLeaderboardsManagerNew.leaderboardKillsAllTime;
SteamLeaderboardNew leaderboardKillsWeekly = SteamLeaderboardsManagerNew.leaderboardKillsWeekly;
if (lb == leaderboardKillsAllTime || lb == leaderboardKillsWeekly)
{
if (_cache != null)
{
Replace(lb, _cache);
}
else
{
_pending = lb;
}
}
}
private static void Replace(SteamLeaderboardNew lb, ServerEntry[] entries)
{
//IL_0159: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Expected O, but got Unknown
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Expected O, but got Unknown
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Expected O, but got Unknown
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Expected O, but got Unknown
for (int i = 0; i < entries.Length; i++)
{
if (ulong.TryParse(entries[i].SteamId, out var result) && result != 0L)
{
SteamFriends.RequestUserInformation(new CSteamID(result), true);
}
}
lb.globalEntries = BuildList(entries);
lb.friendsEntries = BuildFriendsList(entries);
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(64, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Replaced global(");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(entries.Length);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") + friends(");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(lb.friendsEntries.Count);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") on '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(lb.lbName);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("', invoking A_LeaderboardReady");
}
Log.LogInfo(val);
try
{
Action<SteamLeaderboardNew> a_LeaderboardReady = SteamLeaderboardNew.A_LeaderboardReady;
if ((Delegate)(object)a_LeaderboardReady == (Delegate)null)
{
BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("A_LeaderboardReady is null for '");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(lb.lbName);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("'");
}
Log.LogWarning(val2);
return;
}
a_LeaderboardReady.Invoke(lb);
val = new BepInExInfoLogInterpolatedStringHandler(36, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("A_LeaderboardReady invoked OK for '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(lb.lbName);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
}
Log.LogInfo(val);
}
catch (Exception ex)
{
BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(28, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("A_LeaderboardReady threw ");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.GetType().Name);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\n");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.StackTrace);
}
Log.LogError(val3);
}
}
internal static List<LeaderboardEntry> BuildList(ServerEntry[] entries)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Expected O, but got Unknown
List<LeaderboardEntry> val = new List<LeaderboardEntry>();
if (entries == null)
{
return val;
}
for (int i = 0; i < entries.Length; i++)
{
ServerEntry serverEntry = entries[i];
ulong result;
ulong num = (ulong.TryParse(serverEntry.SteamId, out result) ? result : 0);
int[] array = new int[64];
array[1] = serverEntry.CharacterIndex;
LeaderboardEntry_t val2 = default(LeaderboardEntry_t);
val2.m_steamIDUser = new CSteamID(num);
val2.m_nGlobalRank = i + 1;
val2.m_nScore = serverEntry.Score;
val2.m_cDetails = array.Length;
LeaderboardEntry_t val3 = val2;
val.Add(new LeaderboardEntry(val3, Il2CppStructArray<int>.op_Implicit(array)));
}
return val;
}
private static HashSet<ulong> GetSteamFriendIds()
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
HashSet<ulong> hashSet = new HashSet<ulong>();
try
{
hashSet.Add(SteamUser.GetSteamID().m_SteamID);
int friendCount = SteamFriends.GetFriendCount((EFriendFlags)4);
for (int i = 0; i < friendCount; i++)
{
hashSet.Add(SteamFriends.GetFriendByIndex(i, (EFriendFlags)4).m_SteamID);
}
}
catch (Exception ex)
{
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(19, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("GetSteamFriendIds: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
Log.LogWarning(val);
}
return hashSet;
}
internal static List<LeaderboardEntry> BuildFriendsList(ServerEntry[] entries)
{
HashSet<ulong> steamFriendIds = GetSteamFriendIds();
List<ServerEntry> list = new List<ServerEntry>();
foreach (ServerEntry serverEntry in entries)
{
if (ulong.TryParse(serverEntry.SteamId, out var result) && steamFriendIds.Contains(result))
{
list.Add(serverEntry);
}
}
return BuildList(list.ToArray());
}
private static ServerEntry[] Parse(string json)
{
if (string.IsNullOrEmpty(json) || json == "[]")
{
return new ServerEntry[0];
}
try
{
return JsonSerializer.Deserialize<ServerEntry[]>(json) ?? new ServerEntry[0];
}
catch
{
return new ServerEntry[0];
}
}
}
[HarmonyPatch(typeof(ItemCreditCardGreen), "OnInitOrAmountChanged")]
internal static class Patch_CreditCardGreen_ChestCost
{
[HarmonyPostfix]
private static void Postfix(ItemCreditCardGreen __instance)
{
__instance.chestPriceIncreasePerAmount = 0.02f;
}
}
[HarmonyPatch(typeof(ItemCreditCardGreen), "GetDescription")]
internal static class Patch_CreditCardGreen_Desc
{
[HarmonyPostfix]
private static void Postfix(ref string __result)
{
if (__result != null)
{
__result = __result.Replace("10%", "2%").Replace("10 %", "2%");
}
}
}
[HarmonyPatch(typeof(ItemBase), "GetDescription")]
internal static class Patch_Backpack_Desc
{
[HarmonyPostfix]
private static void Postfix(ref string __result)
{
if (__result != null)
{
__result = __result.Replace("+1 Projectile Count", "+2 Projectile Count").Replace("+1 projectile count", "+2 projectile count");
}
}
}
[HarmonyPatch(typeof(ItemCursedDoll), "OnInitOrAmountChanged")]
internal static class Patch_CursedDoll_Buff
{
[HarmonyPostfix]
private unsafe static void Postfix(ItemCursedDoll __instance)
{
IntPtr pointer = ((Il2CppObjectBase)__instance).Pointer;
int num = *(int*)(void*)(pointer + 24);
*(float*)(void*)(pointer + 52) = 0.5f;
*(int*)(void*)(pointer + 56) = 7;
*(int*)(void*)(pointer + 48) = 7 * num;
}
}
[HarmonyPatch(typeof(ItemCursedDoll), "GetDescription")]
internal static class Patch_CursedDoll_Desc
{
[HarmonyPostfix]
private static void Postfix(ref string __result)
{
if (__result != null)
{
__result = __result.Replace("30%", "50%").Replace("30 %", "50%");
}
}
}
[HarmonyPatch(typeof(SaveManager), "Init")]
internal static class Patch_SaveManager_Init_LockUploadOff
{
[HarmonyPostfix]
private static void Postfix(SaveManager __instance)
{
SteamUploadLocker.ForceOff(__instance);
}
}
[HarmonyPatch(typeof(SaveManager), "SaveConfig")]
internal static class Patch_SaveManager_SaveConfig_LockUploadOff
{
[HarmonyPrefix]
private static void Prefix(SaveManager __instance)
{
SteamUploadLocker.ForceOff(__instance);
}
}
internal static class SteamUploadLocker
{
internal const string FieldName = "upload_score_to_leaderboard";
internal unsafe static void ForceOff(SaveManager sm)
{
if ((Object)(object)sm == (Object)null)
{
return;
}
IntPtr pointer = ((Il2CppObjectBase)sm).Pointer;
if (pointer == IntPtr.Zero)
{
return;
}
IntPtr intPtr = *(IntPtr*)(void*)(pointer + 32);
if (!(intPtr == IntPtr.Zero))
{
IntPtr intPtr2 = *(IntPtr*)(void*)(intPtr + 24);
if (!(intPtr2 == IntPtr.Zero))
{
*(int*)(void*)(intPtr2 + 68) = 0;
}
}
}
}
[HarmonyPatch(typeof(BetterSetting), "SetSetting")]
internal static class Patch_BetterSetting_SetSetting_DisableUpload
{
[HarmonyPostfix]
private static void Postfix(BetterSetting __instance, string settingName)
{
if (!(settingName != "upload_score_to_leaderboard"))
{
TextMeshProUGUI t_disabledText = __instance.t_disabledText;
if ((Object)(object)t_disabledText != (Object)null)
{
((TMP_Text)t_disabledText).text = "Disabled";
}
GameObject disabledOverlay = __instance.disabledOverlay;
if ((Object)(object)disabledOverlay != (Object)null)
{
disabledOverlay.SetActive(true);
}
}
}
}
[HarmonyPatch(typeof(CurrentSettings), "BetterUpdateCfSettings")]
internal static class Patch_CurrentSettings_BetterUpdateCfSettings_BlockUpload
{
[HarmonyPrefix]
private static bool Prefix(string settingName)
{
return settingName != "upload_score_to_leaderboard";
}
}
[HarmonyPatch(typeof(PassiveAbilityZooma), "Init")]
internal static class Patch_Zooma_Init_Projectiles
{
private static readonly MethodInfo _setStat = AccessTools.Method(typeof(PassiveAbility), "SetStat", (Type[])null, (Type[])null);
private static Action<int> _handler;
[HarmonyPostfix]
private static void Postfix(PassiveAbilityZooma __instance)
{
if (_handler != null)
{
PlayerXp.A_LevelUp -= Action<int>.op_Implicit(_handler);
}
_handler = delegate(int level)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
try
{
StatModifier val = new StatModifier();
val.stat = (EStat)16;
val.modifyType = (EStatModifyType)2;
val.modification = 0.25f * (float)level;
_setStat.Invoke(__instance, new object[1] { val });
}
catch
{
}
};
PlayerXp.A_LevelUp += Action<int>.op_Implicit(_handler);
}
}
[HarmonyPatch(typeof(ItemGoldenShield), "OnPlayerTakeDamage")]
internal static class Patch_GoldenShield_NoKevinReduction
{
[HarmonyPrefix]
private static void Prefix(DamageContainer dc)
{
if (dc != null && dc.damageSource == ItemKevin.damageSource)
{
dc.damageSource = "";
}
}
}
[HarmonyPatch(typeof(MainMenu), "Start")]
internal static class Patch_MainMenu_Start_Version
{
private static readonly ManualLogSource Log = Logger.CreateLogSource("MegaBonkMod.Version");
[HarmonyPostfix]
private static void Postfix()
{
ModGui.MainThread.Enqueue(delegate
{
ModGui.NeedVersionPatch = true;
});
CheckVersionAsync();
}
private static void CheckVersionAsync()
{
Task.Run<Task>((Func<Task>)async delegate
{
bool flag = default(bool);
try
{
using HttpClient client = new HttpClient
{
Timeout = TimeSpan.FromSeconds(5.0)
};
using JsonDocument jsonDocument = JsonDocument.Parse(await client.GetStringAsync(Plugin.LeaderboardServer.TrimEnd('/') + "/version"));
if (jsonDocument.RootElement.TryGetProperty("required", out var value))
{
string text = value.GetString() ?? "";
if (!string.IsNullOrEmpty(text) && text != "1.3.10")
{
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(30, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Mod outdated: local=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.3.10");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" required=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
}
Log.LogWarning(val);
ModGui.MainThread.Enqueue(delegate
{
ModGui.UpdateAvailable = true;
});
}
else
{
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(17, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Mod version OK (");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("1.3.10");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(")");
}
Log.LogInfo(val2);
}
}
}
catch (Exception ex)
{
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(22, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Version check failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
Log.LogWarning(val);
}
});
}
}
[HarmonyPatch(typeof(GameOverDamageSourcesUi), "Start")]
internal static class Patch_GameOverDamageSourcesUi_Start
{
[HarmonyPrefix]
private static void Prefix()
{
GameObject val = GameObject.Find("GameUI/GameUI/DeathScreen/StatsWindows/W_Damage/WindowLayers/Content/ScrollRect/ContentEntries");
if (!((Object)(object)val == (Object)null))
{
Transform transform = val.transform;
for (int num = transform.childCount - 1; num >= 3; num--)
{
Object.Destroy((Object)(object)((Component)transform.GetChild(num)).gameObject);
}
}
}
}
[HarmonyPatch(typeof(GameManager), "StartPlaying")]
internal static class Patch_GameManager_StartPlaying_Chart
{
[HarmonyPostfix]
private static void Postfix()
{
ModGui.ChartDisabled = false;
Object.FindObjectOfType<ModGui>()?.ResetChartCache();
}
}
[HarmonyPatch(typeof(GameManager), "OnDied")]
internal static class Patch_GameManager_OnDied_Chart
{
[HarmonyPostfix]
private static void Postfix()
{
ModGui.ChartDisabled = true;
}
}
[HarmonyPatch(typeof(CombatScaling), "GetStageHpMultiplier")]
internal static class Patch_CombatScaling_HpMultiplier
{
[HarmonyPostfix]
private static void Postfix(ref float __result)
{
__result = 2f * __result - 1f;
}
}
[HarmonyPatch(typeof(CombatScaling), "GetStageDamageMultiplier")]
internal static class Patch_CombatScaling_DamageMultiplier
{
[HarmonyPostfix]
private static void Postfix(ref float __result)
{
__result = 2f * __result - 1f;
}
}
[BepInPlugin("com.megabonk.mod", "MegaBonk Mod", "1.3.10")]
public class Plugin : BasePlugin
{
internal static string LeaderboardServer = "http://67.5.111.0:9000";
internal const string ModVersion = "1.3.10";
internal const bool PatchGrandmasTonic = true;
internal static readonly HashSet<EItem> ActiveUncappedItems = new HashSet<EItem>
{
(EItem)41,
(EItem)26,
(EItem)25
};
internal static readonly HashSet<EItem> ForcedPoolItems = new HashSet<EItem>
{
(EItem)7,
(EItem)38,
(EItem)82,
(EItem)55,
(EItem)19,
(EItem)56,
(EItem)33
};
internal static readonly HashSet<int> BlacklistedStats = new HashSet<int>
{
0, 1, 2, 3, 4, 5, 10, 11, 24, 25,
29
};
internal static readonly HashSet<int> BlacklistedShrineStats = new HashSet<int>
{
0, 1, 2, 3, 4, 5, 10, 11, 24, 25,
29
};
internal static readonly List<int> FullStatPool = new List<int>();
internal static readonly List<int> FullShrineStatPool = new List<int>();
internal static ManualLogSource Log { get; private set; }
public override void Load()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
Log = ((BasePlugin)this).Log;
LeaderboardServer = ((BasePlugin)this).Config.Bind<string>("Leaderboard", "ServerUrl", "http://67.5.111.0:9000", "DO NOT CHANGE THIS. Only modify if you are the server host running locally (use http://localhost:9000).").Value;
ClassInjector.RegisterTypeInIl2Cpp<ModGui>();
new Harmony("com.megabonk.mod").PatchAll(typeof(Plugin).Assembly);
((BasePlugin)this).AddComponent<ModGui>();
ManualLogSource log = Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(29, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[MegaBonkMod] Loaded. Server=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(LeaderboardServer);
}
log.LogInfo(val);
}
internal static int GetItemCap(EItem item)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Invalid comparison between Unknown and I4
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Invalid comparison between Unknown and I4
if ((int)item != 25)
{
if ((int)item != 26)
{
if ((int)item == 41)
{
return 2;
}
return 5;
}
return 3;
}
return 10;
}
}
internal static class SpaceNoodleState
{
internal static readonly Dictionary<IntPtr, Vector3[]> ExtraTargetPos = new Dictionary<IntPtr, Vector3[]>();
internal static readonly Dictionary<IntPtr, List<LineRenderer>> ExtraRenderers = new Dictionary<IntPtr, List<LineRenderer>>();
internal static readonly Collider[] Buf = (Collider[])(object)new Collider[64];
internal static MethodInfo HitEnemyMi;
}
[HarmonyPatch(typeof(LaserBeamAttack), "FixedUpdate")]
internal static class Patch_SpaceNoodle_ExtraPhysics
{
private unsafe static void Postfix(LaserBeamAttack __instance)
{
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: 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_017e: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
if (((ConstantAttack)__instance).weaponBase == null)
{
return;
}
int num = WeaponUtility.GetAttackQuantity(((ConstantAttack)__instance).weaponBase) - 1;
IntPtr pointer = ((Il2CppObjectBase)__instance).Pointer;
byte num2 = *(byte*)(void*)(((Il2CppObjectBase)__instance).Pointer + 100);
nint num3 = *(nint*)(void*)(((Il2CppObjectBase)__instance).Pointer + 80);
if (num2 == 0 || num <= 0 || num3 == 0)
{
SpaceNoodleState.ExtraTargetPos[pointer] = Array.Empty<Vector3>();
return;
}
GameManager instance = GameManager.Instance;
if ((Object)(object)((instance != null) ? instance.player : null) == (Object)null)
{
return;
}
HashSet<IntPtr> hashSet = new HashSet<IntPtr>();
if (num3 != ((Il2CppObjectBase)__instance).Pointer)
{
IntPtr intPtr = *(IntPtr*)(num3 + 80);
if (intPtr != (IntPtr)0)
{
hashSet.Add(intPtr);
}
}
int num4 = Physics.OverlapSphereNonAlloc(((Component)instance.player).transform.position, 30f, Il2CppReferenceArray<Collider>.op_Implicit(SpaceNoodleState.Buf), LayerMask.op_Implicit(instance.whatIsEnemy));
if ((object)SpaceNoodleState.HitEnemyMi == null)
{
SpaceNoodleState.HitEnemyMi = AccessTools.Method(typeof(LaserBeamAttack), "HitEnemy", (Type[])null, (Type[])null);
}
List<Vector3> list = new List<Vector3>(num);
*(IntPtr*)(void*)(((Il2CppObjectBase)__instance).Pointer + 80) = ((Il2CppObjectBase)__instance).Pointer;
object[] array = new object[1];
for (int i = 0; i < num4; i++)
{
if (list.Count >= num)
{
break;
}
Collider val = SpaceNoodleState.Buf[i];
if ((Object)(object)val == (Object)null)
{
continue;
}
Rigidbody attachedRigidbody = val.attachedRigidbody;
if (!((Object)(object)attachedRigidbody == (Object)null))
{
IntPtr pointer2 = ((Il2CppObjectBase)attachedRigidbody).Pointer;
if (hashSet.Add(pointer2))
{
array[0] = val;
SpaceNoodleState.HitEnemyMi.Invoke(__instance, array);
Bounds bounds = val.bounds;
list.Add(((Bounds)(ref bounds)).center);
}
}
}
*(nint*)(void*)(((Il2CppObjectBase)__instance).Pointer + 80) = num3;
SpaceNoodleState.ExtraTargetPos[pointer] = list.ToArray();
}
}
[HarmonyPatch(typeof(LaserBeamAttack), "Update")]
internal static class Patch_SpaceNoodle_ExtraVisual
{
private static void Postfix(LaserBeamAttack __instance)
{
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: 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_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
IntPtr pointer = ((Il2CppObjectBase)__instance).Pointer;
SpaceNoodleState.ExtraTargetPos.TryGetValue(pointer, out var value);
int num = ((value != null) ? value.Length : 0);
if (!SpaceNoodleState.ExtraRenderers.TryGetValue(pointer, out var value2))
{
value2 = new List<LineRenderer>();
SpaceNoodleState.ExtraRenderers[pointer] = value2;
}
while (value2.Count < num)
{
LineRenderer val = new GameObject("SpaceNoodleExtraBeam").AddComponent<LineRenderer>();
if ((Object)(object)__instance.linerenderer != (Object)null)
{
((Renderer)val).sharedMaterial = ((Renderer)__instance.linerenderer).sharedMaterial;
val.widthMultiplier = __instance.linerenderer.widthMultiplier;
val.startColor = __instance.linerenderer.startColor;
val.endColor = __instance.linerenderer.endColor;
}
val.positionCount = 2;
val.useWorldSpace = true;
value2.Add(val);
}
Vector3 val2;
if ((Object)(object)__instance.laserStart != (Object)null)
{
val2 = __instance.laserStart.transform.position;
}
else
{
GameManager instance = GameManager.Instance;
MyPlayer val3 = ((instance != null) ? instance.player : null);
val2 = (((Object)(object)val3 != (Object)null) ? (((Component)val3).transform.position + Vector3.up * 1.2f) : ((Component)__instance).transform.position);
}
for (int i = 0; i < value2.Count; i++)
{
LineRenderer val4 = value2[i];
if (!((Object)(object)val4 == (Object)null))
{
if (i < num)
{
((Renderer)val4).enabled = true;
val4.SetPosition(0, val2);
val4.SetPosition(1, value[i]);
}
else
{
((Renderer)val4).enabled = false;
}
}
}
}
}
[HarmonyPatch(typeof(LaserBeamAttack), "OnDestroy")]
internal static class Patch_SpaceNoodle_Cleanup
{
private static void Postfix(LaserBeamAttack __instance)
{
IntPtr pointer = ((Il2CppObjectBase)__instance).Pointer;
SpaceNoodleState.ExtraTargetPos.Remove(pointer);
if (!SpaceNoodleState.ExtraRenderers.TryGetValue(pointer, out var value))
{
return;
}
foreach (LineRenderer item in value)
{
if ((Object)(object)item != (Object)null && (Object)(object)((Component)item).gameObject != (Object)null)
{
Object.Destroy((Object)(object)((Component)item).gameObject);
}
}
SpaceNoodleState.ExtraRenderers.Remove(pointer);
}
}
