using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("LimitBypassMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Bypasses integer limits using BigInteger shadow state.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LimitBypassMod")]
[assembly: AssemblyTitle("LimitBypassMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace LimitBypassMod
{
[HarmonyPatch]
public static class HudMagazineViewController_RenderMagazine_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("HudMagazineViewController"), "RenderMagazine", (Type[])null, (Type[])null);
}
private static void Postfix(object __instance)
{
if (__instance == null)
{
return;
}
object value = Traverse.Create(__instance).Field("view").GetValue();
if (value == null)
{
return;
}
GameObject value2 = Traverse.Create(value).Field("visibilityRoot").GetValue<GameObject>();
string bulletType = "Normal";
TMP_Text value3 = Traverse.Create(value).Field("bulletTypeText").GetValue<TMP_Text>();
if ((Object)(object)value3 != (Object)null && !string.IsNullOrEmpty(value3.text))
{
string text = value3.text.ToUpper();
if (text.Contains("RAINBOW"))
{
bulletType = "Rainbow";
}
else if (text.Contains("SHINY"))
{
bulletType = "Shiny";
}
else if (text.Contains("SILVER"))
{
bulletType = "Silver";
}
else if (text.Contains("EXPLOSIVE"))
{
bulletType = "Explosive";
}
else if (text.Contains("RICOCHET"))
{
bulletType = "Ricochet";
}
else if (text.Contains("CLONE"))
{
bulletType = "Clone";
}
else if (text.Contains("GUARDIAN"))
{
bulletType = "Guardian";
}
}
if (!((Object)(object)value2 != (Object)null))
{
return;
}
TMP_Text[] componentsInChildren = value2.GetComponentsInChildren<TMP_Text>(true);
foreach (TMP_Text val in componentsInChildren)
{
if (long.TryParse(val.text.Replace(" ", "").Replace(".", ""), out var _))
{
val.text = StringFormatter.Instance.GetAmmoString(bulletType);
}
}
}
}
public static class LimitBypassDecisionAPI
{
public static bool CanAffordCurrency(int basePrice, int multiplier = 1)
{
BigInteger bigInteger = new BigInteger(basePrice) * new BigInteger(multiplier);
return ShadowState.Currency >= bigInteger;
}
public static void ConsumeCurrency(int basePrice, int multiplier = 1)
{
BigInteger bigInteger = new BigInteger(basePrice) * new BigInteger(multiplier);
if (ShadowState.Currency >= bigInteger)
{
ShadowState.Currency -= bigInteger;
}
}
}
[BepInPlugin("com.luckyshot.limitbypass", "Limit Bypass Mod", "1.3.0")]
public class LimitBypassPlugin : BaseUnityPlugin
{
public const string PluginGuid = "com.luckyshot.limitbypass";
public const string PluginName = "Limit Bypass Mod";
public const string PluginVersion = "1.3.0";
private void Awake()
{
//IL_0015: 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)
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin com.luckyshot.limitbypass is loaded!");
new GameObject("LimitBypass_StringFormatter").AddComponent<StringFormatter>();
new Harmony("com.luckyshot.limitbypass").PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Harmony patches applied successfully.");
}
}
[HarmonyPatch]
public static class GameManager_HandleShotFired_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("GameManager"), "HandleShotFired", (Type[])null, (Type[])null);
}
private static void Prefix(object __instance, out int __state)
{
__state = 0;
if (__instance != null)
{
__state = Traverse.Create(__instance).Property("TotalBulletsFired", (object[])null).GetValue<int>();
}
}
private static void Postfix(object __instance, int __state)
{
if (__instance == null)
{
return;
}
int num = Traverse.Create(__instance).Property("TotalBulletsFired", (object[])null).GetValue<int>() - __state;
if (num > 0)
{
ShadowState.TotalBulletsFired += (BigInteger)num;
if (ShadowState.CurrentAmmo.ContainsKey("Rainbow") && ShadowState.CurrentAmmo["Rainbow"] >= num)
{
ShadowState.CurrentAmmo["Rainbow"] -= (BigInteger)num;
ShadowState.IsAmmoDirty = true;
}
else if (ShadowState.CurrentAmmo.ContainsKey("Normal") && ShadowState.CurrentAmmo["Normal"] >= num)
{
ShadowState.CurrentAmmo["Normal"] -= (BigInteger)num;
ShadowState.IsAmmoDirty = true;
}
}
}
}
[HarmonyPatch]
public static class ShopManager_TryBuy_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("ShopManager"), "TryBuy", (Type[])null, (Type[])null);
}
private static bool Prefix(int cost, ref bool __result)
{
if (cost > 1000000)
{
__result = LimitBypassDecisionAPI.CanAffordCurrency(cost);
return false;
}
return true;
}
}
[HarmonyPatch]
public static class Weapon_HasInfiniteAmmo_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("Weapon"), "get_HasInfiniteAmmo", (Type[])null, (Type[])null);
}
private static bool Prefix(ref bool __result)
{
__result = true;
return false;
}
}
public static class ShadowState
{
private static BigInteger _totalTargetsDestroyed = 0;
private static BigInteger _totalBulletsFired = 0;
private static BigInteger _totalScore = 0;
private static BigInteger _currency = 0;
public static bool IsTargetsDirty { get; private set; } = true;
public static bool IsBulletsDirty { get; private set; } = true;
public static bool IsScoreDirty { get; private set; } = true;
public static bool IsCurrencyDirty { get; private set; } = true;
public static BigInteger TotalTargetsDestroyed
{
get
{
return _totalTargetsDestroyed;
}
set
{
_totalTargetsDestroyed = value;
IsTargetsDirty = true;
}
}
public static BigInteger TotalBulletsFired
{
get
{
return _totalBulletsFired;
}
set
{
_totalBulletsFired = value;
IsBulletsDirty = true;
}
}
public static BigInteger TotalScore
{
get
{
return _totalScore;
}
set
{
_totalScore = value;
IsScoreDirty = true;
}
}
public static BigInteger Currency
{
get
{
return _currency;
}
set
{
_currency = value;
IsCurrencyDirty = true;
}
}
public static Dictionary<string, BigInteger> AmmoPools { get; } = new Dictionary<string, BigInteger>();
public static Dictionary<string, BigInteger> CurrentAmmo { get; } = new Dictionary<string, BigInteger>();
public static bool IsAmmoDirty { get; set; } = true;
public static void ClearTargetsDirty()
{
IsTargetsDirty = false;
}
public static void ClearBulletsDirty()
{
IsBulletsDirty = false;
}
public static void ClearScoreDirty()
{
IsScoreDirty = false;
}
public static void ClearCurrencyDirty()
{
IsCurrencyDirty = false;
}
public static void ResetState()
{
TotalTargetsDestroyed = 0;
TotalBulletsFired = 0;
TotalScore = 0;
Currency = 0;
AmmoPools.Clear();
CurrentAmmo.Clear();
IsAmmoDirty = true;
}
}
public class StringFormatter : MonoBehaviour
{
public static StringFormatter Instance { get; private set; }
public string CachedTargetsString { get; private set; } = "0";
public string CachedBulletsString { get; private set; } = "0";
public string CachedScoreString { get; private set; } = "0";
public string CachedCurrencyString { get; private set; } = "0";
public Dictionary<string, string> CachedAmmoStrings { get; } = new Dictionary<string, string>();
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
return;
}
Instance = this;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
FormatAll();
}
private void LateUpdate()
{
if (ShadowState.IsTargetsDirty)
{
CachedTargetsString = FormatBigInt(ShadowState.TotalTargetsDestroyed);
ShadowState.ClearTargetsDirty();
}
if (ShadowState.IsBulletsDirty)
{
CachedBulletsString = FormatBigInt(ShadowState.TotalBulletsFired);
ShadowState.ClearBulletsDirty();
}
if (ShadowState.IsScoreDirty)
{
CachedScoreString = FormatBigInt(ShadowState.TotalScore);
ShadowState.ClearScoreDirty();
}
if (ShadowState.IsCurrencyDirty)
{
CachedCurrencyString = FormatBigInt(ShadowState.Currency);
ShadowState.ClearCurrencyDirty();
}
if (!ShadowState.IsAmmoDirty)
{
return;
}
CachedAmmoStrings.Clear();
foreach (KeyValuePair<string, BigInteger> item in ShadowState.CurrentAmmo)
{
CachedAmmoStrings[item.Key] = FormatBigInt(item.Value);
}
ShadowState.IsAmmoDirty = false;
}
public void FormatAll()
{
CachedTargetsString = FormatBigInt(ShadowState.TotalTargetsDestroyed);
CachedBulletsString = FormatBigInt(ShadowState.TotalBulletsFired);
CachedScoreString = FormatBigInt(ShadowState.TotalScore);
CachedCurrencyString = FormatBigInt(ShadowState.Currency);
CachedAmmoStrings.Clear();
foreach (KeyValuePair<string, BigInteger> item in ShadowState.CurrentAmmo)
{
CachedAmmoStrings[item.Key] = FormatBigInt(item.Value);
}
ShadowState.IsAmmoDirty = false;
}
public string GetAmmoString(string bulletType)
{
if (CachedAmmoStrings.TryGetValue(bulletType, out var value))
{
return value;
}
return "0";
}
private string FormatBigInt(BigInteger value)
{
if (value > new BigInteger(1000000000000000000L))
{
return value.ToString("E3");
}
return value.ToString("N0");
}
}
[HarmonyPatch]
public static class TMP_Text_set_text_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.PropertySetter(typeof(TMP_Text), "text");
}
private static void Postfix(TMP_Text __instance)
{
if ((Object)(object)__instance != (Object)null && !string.IsNullOrEmpty(__instance.text) && __instance.text.Length > 9 && (__instance.text.Contains("B") || __instance.text.Contains("E") || __instance.text.Length > 12))
{
__instance.enableAutoSizing = true;
if (__instance.fontSizeMin > 10f)
{
__instance.fontSizeMin = 5f;
}
__instance.textWrappingMode = (TextWrappingModes)0;
__instance.overflowMode = (TextOverflowModes)3;
}
}
}
[HarmonyPatch]
public static class ShopMoneyView_SetDisplayedAmount_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("ShopMoneyViewController"), "SetDisplayedAmount", (Type[])null, (Type[])null);
}
[HarmonyPostfix]
private static void Postfix(object __instance)
{
if (__instance == null || !((Object)(object)StringFormatter.Instance != (Object)null))
{
return;
}
object value = Traverse.Create(__instance).Field("view").GetValue();
Component val = (Component)((value is Component) ? value : null);
if (val != null)
{
TMP_Text componentInChildren = val.GetComponentInChildren<TMP_Text>();
if ((Object)(object)componentInChildren != (Object)null)
{
componentInChildren.text = StringFormatter.Instance.CachedCurrencyString;
}
}
}
}
[HarmonyPatch]
public static class TicketView_SetDisplayedAmount_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("TicketViewController"), "SetDisplayedAmount", (Type[])null, (Type[])null);
}
[HarmonyPostfix]
private static void Postfix(object __instance)
{
if (__instance == null || !((Object)(object)StringFormatter.Instance != (Object)null))
{
return;
}
object value = Traverse.Create(__instance).Field("barView").GetValue();
Component val = (Component)((value is Component) ? value : null);
if (val != null)
{
TMP_Text componentInChildren = val.GetComponentInChildren<TMP_Text>();
if ((Object)(object)componentInChildren != (Object)null)
{
componentInChildren.text = StringFormatter.Instance.CachedTargetsString;
}
}
}
}
[HarmonyPatch]
public static class HudMagazineView_SetCountText_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("HudMagazineView"), "SetCountText", (Type[])null, (Type[])null);
}
[HarmonyPostfix]
private static void Postfix(object __instance)
{
if (__instance == null || !((Object)(object)StringFormatter.Instance != (Object)null))
{
return;
}
object value = Traverse.Create(__instance).Field("bulletTypeText").GetValue();
object value2 = Traverse.Create(__instance).Field("bulletCountText").GetValue();
TMP_Text val = (TMP_Text)((value is TMP_Text) ? value : null);
if (val == null)
{
return;
}
TMP_Text val2 = (TMP_Text)((value2 is TMP_Text) ? value2 : null);
if (val2 != null)
{
string bulletType = "Normal";
if (val.text != null && val.text.Contains("Rainbow"))
{
bulletType = "Rainbow";
}
val2.text = StringFormatter.Instance.GetAmmoString(bulletType);
}
}
}
[HarmonyPatch]
public static class Weapon_AddNormalBullets_Patch
{
public static bool IsModRefilling;
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("Weapon"), "AddNormalBulletsToMagazine", (Type[])null, (Type[])null);
}
private static void Prefix(object __instance, int amount)
{
if (IsModRefilling || __instance == null)
{
return;
}
Traverse obj = Traverse.Create(__instance);
int value = obj.Property("CurrentAmmo", (object[])null).GetValue<int>();
int num = obj.Property("MaxAmmo", (object[])null).GetValue<int>() - value;
if (amount >= num && num > 0)
{
foreach (KeyValuePair<string, BigInteger> ammoPool in ShadowState.AmmoPools)
{
ShadowState.CurrentAmmo[ammoPool.Key] = ammoPool.Value;
}
}
else
{
if (ShadowState.CurrentAmmo.ContainsKey("Normal"))
{
ShadowState.CurrentAmmo["Normal"] += (BigInteger)amount;
if (ShadowState.CurrentAmmo["Normal"] > ShadowState.AmmoPools["Normal"])
{
ShadowState.CurrentAmmo["Normal"] = ShadowState.AmmoPools["Normal"];
}
}
foreach (KeyValuePair<string, BigInteger> ammoPool2 in ShadowState.AmmoPools)
{
if (ammoPool2.Key != "Normal")
{
ShadowState.CurrentAmmo[ammoPool2.Key] = ammoPool2.Value;
}
}
}
ShadowState.IsAmmoDirty = true;
}
}
[HarmonyPatch]
public static class Weapon_Update_Patch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(AccessTools.TypeByName("Weapon"), "Update", (Type[])null, (Type[])null);
}
private static void Postfix(object __instance)
{
if (__instance == null)
{
return;
}
Traverse val = Traverse.Create(__instance);
int value = val.Property("CurrentAmmo", (object[])null).GetValue<int>();
int value2 = val.Property("MaxAmmo", (object[])null).GetValue<int>();
if (value >= value2)
{
return;
}
bool flag = false;
foreach (BigInteger value3 in ShadowState.CurrentAmmo.Values)
{
if (value3 > 0L)
{
flag = true;
break;
}
}
if (flag)
{
int num = value2 - value;
Weapon_AddNormalBullets_Patch.IsModRefilling = true;
try
{
val.Method("AddNormalBulletsToMagazine", new object[1] { num }).GetValue();
}
finally
{
Weapon_AddNormalBullets_Patch.IsModRefilling = false;
}
}
}
}
}
