using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AmmoLab;
using AmmoLab.Mods;
using AmmoLab.Utils;
using BoneLib.BoneMenu;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Data;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "AmmoLab", "6.6.6", "freakycheesy", "https://github.com/freakycheesy/AmmoLab/")]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AmmoLab")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b73c4ca7b9f0e9b464907525a5486ba977f8df5d")]
[assembly: AssemblyProduct("AmmoLab")]
[assembly: AssemblyTitle("AmmoLab")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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 AmmoLab
{
public class Core : MelonMod
{
public static DefaultMod mod;
public static MelonPreferences_Category PrefsCategory;
public static Color red => Color.HSVToRGB(0f, 0.7f, 1f);
public override void OnInitializeMelon()
{
((MelonBase)this).LoggerInstance.Msg("Initialized.");
((MelonBase)this).HarmonyInstance.PatchAll(typeof(Patches));
mod = new DefaultMod();
}
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
{
((MelonMod)this).OnSceneWasLoaded(buildIndex, sceneName);
MagazineUtils.magazines.Clear();
}
}
}
namespace AmmoLab.Mods
{
public class DefaultMod
{
public static Page mainPage;
public static MelonPreferences_Entry<bool> ActivateMod;
public static MelonPreferences_Entry<bool> EmptyRefill;
public static MelonPreferences_Entry<bool> AutoMagazineRefill;
public static MelonPreferences_Entry<bool> EnableStaticAmmo;
public static MelonPreferences_Entry<bool> MakeMagazinesGold;
private static MelonPreferences_Entry<int> StaticAmmo;
private static MelonPreferences_Entry<Color> gold;
public void AmmoInventoryUpdate()
{
if (ActivateMod.Value)
{
if (AutoMagazineRefill.Value)
{
MagazineUtils.RefillAllMagazines();
}
if (EnableStaticAmmo.Value)
{
AmmoInventoryUtils.AddAmmoToInventory(StaticAmmo.Value);
}
}
}
public DefaultMod()
{
MelonLogger.Msg("Initialized Ammo Lab BoneMenu");
Core.PrefsCategory = MelonPreferences.CreateCategory("AmmoLab");
Menu.Initialize();
InitSettings();
CreateBonemenu();
AmmoInventoryUtils.OnAmmoUpdate = (Action)Delegate.Combine(AmmoInventoryUtils.OnAmmoUpdate, new Action(AmmoInventoryUpdate));
MagazineUtils.OnEject = (Action<Magazine>)Delegate.Combine(MagazineUtils.OnEject, new Action<Magazine>(RefillMagazine));
MagazineUtils.OnSpawn = (Action<Magazine>)Delegate.Combine(MagazineUtils.OnSpawn, new Action<Magazine>(MakeMagsGold));
}
private static void InitSettings()
{
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
ActivateMod = Core.PrefsCategory.CreateEntry<bool>("ActivateMod", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
EmptyRefill = Core.PrefsCategory.CreateEntry<bool>("EmptyRefill", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
AutoMagazineRefill = Core.PrefsCategory.CreateEntry<bool>("AutoMagazineRefill", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
EnableStaticAmmo = Core.PrefsCategory.CreateEntry<bool>("EnableStaticAmmo", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
StaticAmmo = Core.PrefsCategory.CreateEntry<int>("StaticAmmo", 2000, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
MakeMagazinesGold = Core.PrefsCategory.CreateEntry<bool>("MakeMagazinesGold", false, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
gold = Core.PrefsCategory.CreateEntry<Color>("gold", new Color(218f, 165f, 32f), (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
}
private void RefillMagazine(Magazine magazine)
{
if (ActivateMod.Value && EmptyRefill.Value)
{
MagazineUtils.RefillMagazine(magazine);
}
}
private static void MakeMagsGold(Magazine __instance)
{
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
if (!ActivateMod.Value || !MakeMagazinesGold.Value)
{
return;
}
List<Renderer> list = ((IEnumerable<Renderer>)((Component)__instance).GetComponentsInParent<Renderer>()).ToList();
list.AddRange((IEnumerable<Renderer>)((Component)__instance).GetComponentsInChildren<Renderer>());
foreach (Renderer item in list)
{
Material val = new Material(item.material.shader);
val.color = gold.Value;
val.SetFloat("_Metallic", 1f);
val.SetFloat("_Smoothness", 1f);
for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)item.materials).Length; i++)
{
Material[] array = ((IEnumerable<Material>)item.materials).ToArray();
array.SetValue(val, i);
item.materials = Il2CppReferenceArray<Material>.op_Implicit(array);
}
}
}
public static void CreateBonemenu()
{
//IL_000b: 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_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: 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)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: 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)
mainPage = Page.Root.CreatePage("Ammo Lab", Core.red, 0, true);
Page val = mainPage.CreatePage("Refill Settings", Color.cyan, 0, true);
Page val2 = mainPage.CreatePage("Ammo Settings", Core.red, 0, true);
mainPage.CreateBool("Activate Mod", Core.red, ActivateMod.Value, (Action<bool>)delegate(bool a)
{
ActivateMod.Value = a;
Save();
});
val.CreateBool("Refill on Empty", Color.white, EmptyRefill.Value, (Action<bool>)delegate(bool a)
{
EmptyRefill.Value = a;
Save();
});
val.CreateBool("Auto Refill", Color.white, AutoMagazineRefill.Value, (Action<bool>)delegate(bool a)
{
AutoMagazineRefill.Value = a;
Save();
});
val2.CreateBool("Enable Static Ammo", Color.white, EnableStaticAmmo.Value, (Action<bool>)delegate(bool a)
{
EnableStaticAmmo.Value = a;
Save();
});
val2.CreateInt("Static Ammo Count", Color.white, StaticAmmo.Value, 10, 0, 2000, (Action<int>)delegate(int a)
{
StaticAmmo.Value = a;
Save();
});
val2.CreateBool("Gold Magazines", Color.yellow, MakeMagazinesGold.Value, (Action<bool>)delegate(bool a)
{
MakeMagazinesGold.Value = a;
Save();
});
}
private static void Save()
{
MelonPreferences.Save();
}
}
public class GamblingLabMod
{
public enum AmmoGroupEnum
{
light,
medium,
heavy
}
public static int gambleAmount;
public static AmmoGroup ammoGroup;
public AmmoGroupEnum ammoEnum = AmmoGroupEnum.light;
public static Page page;
private static FunctionElement gambleinfo;
public GamblingLabMod()
{
MelonLogger.Msg("Initialized Gambling Lab");
MakeMenu();
}
private void MakeMenu()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
ChangeAmmoGroup(ammoEnum);
page = Page.Root.CreatePage("Gambling Lab", Core.red, 0, true);
page.Name = "Gambling <color=white>Lab";
page.CreateEnum("Change Ammo Group", Color.yellow, (Enum)ammoEnum, (Action<Enum>)ChangeAmmoGroup);
page.CreateInt("Amount", Color.blue, 10, 10, 10, 200, (Action<int>)ChangeAmount);
gambleinfo = page.CreateFunction("the gamble info", Color.white, (Action)null);
page.CreateFunction("Gamble", Core.red, (Action)Gamble);
}
public static void ChangeAmount(int amount)
{
gambleAmount = amount;
}
public static void Gamble()
{
if (!Object.op_Implicit((Object)(object)ammoGroup))
{
Log("No ammo in your dumb pouch");
return;
}
if (AmmoInventory.Instance.GetCartridgeCount(((Il2CppArrayBase<CartridgeData>)(object)ammoGroup.cartridges)[0]) < gambleAmount)
{
Log("Not enough Ammo");
return;
}
AmmoInventoryUtils.RemoveCartridgeToInventory(ammoGroup, gambleAmount);
int num = Random.Range(0, gambleAmount);
if (num <= Mathf.RoundToInt((float)(num / 2)))
{
int num2 = gambleAmount * Random.Range(0, 10);
Log($"You won {num2} ammo\nwoohoo");
AmmoInventoryUtils.AddAmmoToInventory(num2);
}
else
{
Log($"You lost {gambleAmount} ammo lol");
}
}
public static void Log(string context)
{
((Element)gambleinfo).ElementName = "the gamble info:\n";
FunctionElement obj = gambleinfo;
((Element)obj).ElementName = ((Element)obj).ElementName + context;
}
public static void ChangeAmmoGroup(Enum i)
{
if (i is AmmoGroupEnum)
{
switch ((AmmoGroupEnum)(object)i)
{
case AmmoGroupEnum.light:
ammoGroup = AmmoInventory.Instance.lightAmmoGroup;
break;
case AmmoGroupEnum.medium:
ammoGroup = AmmoInventory.Instance.mediumAmmoGroup;
break;
case AmmoGroupEnum.heavy:
ammoGroup = AmmoInventory.Instance.mediumAmmoGroup;
break;
}
}
}
}
}
namespace AmmoLab.Utils
{
public static class MagazineUtils
{
public static List<Magazine> magazines = new List<Magazine>();
public static Action<Magazine> OnSpawn;
public static Action<Magazine> OnDespawn;
public static Action<Magazine> OnInsert;
public static Action<Magazine> OnEject;
public static void RefillAllMagazines()
{
foreach (Magazine magazine in magazines)
{
magazine.magazineState.Refill();
}
}
public static void RefillMagazine(Magazine mag)
{
mag.magazineState.Refill();
}
}
public static class AmmoInventoryUtils
{
public static int defaultammo = 2000;
public static Action OnAmmoUpdate;
public static AmmoInventory AmmoInventory => AmmoInventory.Instance;
public static void AddAmmoToInventory()
{
AmmoInventory.ClearAmmo();
AmmoInventory.AddCartridge(AmmoInventory.lightAmmoGroup, defaultammo);
AmmoInventory.AddCartridge(AmmoInventory.mediumAmmoGroup, defaultammo);
AmmoInventory.AddCartridge(AmmoInventory.heavyAmmoGroup, defaultammo);
}
public static void AddAmmoToInventory(int ammo)
{
AmmoInventory.ClearAmmo();
AmmoInventory.AddCartridge(AmmoInventory.lightAmmoGroup, ammo);
AmmoInventory.AddCartridge(AmmoInventory.mediumAmmoGroup, ammo);
AmmoInventory.AddCartridge(AmmoInventory.heavyAmmoGroup, ammo);
}
public static void AddCartridgeToInventory(AmmoGroup ammoGroup, int ammo)
{
AmmoInventory.AddCartridge(ammoGroup, ammo);
}
public static void RemoveCartridgeToInventory(AmmoGroup ammoGroup, int ammo)
{
foreach (CartridgeData item in (Il2CppArrayBase<CartridgeData>)(object)ammoGroup.cartridges)
{
AmmoInventory.RemoveCartridge(item, ammo);
}
}
}
internal static class Patches
{
[HarmonyPatch(typeof(AmmoInventory))]
internal static class AmmoInventoryPatches
{
[HarmonyPatch("RemoveCartridge")]
[HarmonyPostfix]
private static void RemoveCartridge(CartridgeData cartridge, int count)
{
AmmoInventoryUtils.OnAmmoUpdate?.Invoke();
}
}
[HarmonyPatch(typeof(Magazine))]
internal static class MagazinePatches
{
[HarmonyPatch("OnPoolInitialize")]
[HarmonyPrefix]
private static void _Spawn(Magazine __instance)
{
MagazineUtils.magazines.Add(__instance);
MagazineUtils.OnSpawn?.Invoke(__instance);
}
[HarmonyPatch("OnPoolDeInitialize")]
[HarmonyPrefix]
private static void _Despawn(Magazine __instance)
{
MagazineUtils.magazines.Remove(__instance);
MagazineUtils.OnDespawn?.Invoke(__instance);
}
[HarmonyPatch("OnInsert")]
[HarmonyPostfix]
private static void _OnInsert(Magazine __instance)
{
MagazineUtils.OnInsert?.Invoke(__instance);
}
[HarmonyPatch("OnEject")]
[HarmonyPostfix]
private static void _OnEject(Magazine __instance)
{
MagazineUtils.OnEject?.Invoke(__instance);
}
}
}
}