using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BoneLib.BoneMenu;
using GoldenPan;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.Pool;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSystem;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(GoldenPanMod), "Golden Pan", "1.1.0", "Wakey", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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 GoldenPan
{
internal static class Gilding
{
public static readonly Color Gold = new Color(1f, 0.78f, 0.16f);
public static float Tiling = 2f;
private static bool _loaded;
private static Texture2D _albedo;
private static Texture2D _normal;
private static Texture2D _metal;
private static Texture2D _ao;
private static void EnsureTextures()
{
if (_loaded)
{
return;
}
_loaded = true;
try
{
string dir = Path.Combine(Path.GetDirectoryName(Application.dataPath), "UserData", "GoldenPan");
_albedo = LoadPng(dir, "gold_albedo.png");
_normal = LoadPng(dir, "gold_normal.png");
_metal = LoadPng(dir, "gold_metallic.png");
_ao = LoadPng(dir, "gold_ao.png");
MelonLogger.Msg("[GoldenPan] gold textures: albedo=" + ((Object)(object)_albedo != (Object)null) + " normal=" + ((Object)(object)_normal != (Object)null) + " metal=" + ((Object)(object)_metal != (Object)null) + " ao=" + ((Object)(object)_ao != (Object)null));
}
catch (Exception ex)
{
MelonLogger.Warning("[GoldenPan] texture load: " + ex.Message);
}
}
private static Texture2D LoadPng(string dir, string file)
{
//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)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_0035: 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_0042: Expected O, but got Unknown
//IL_0043: Expected O, but got Unknown
string path = Path.Combine(dir, file);
if (!File.Exists(path))
{
return null;
}
Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true)
{
hideFlags = (HideFlags)61
};
ImageConversion.LoadImage(val, new Il2CppStructArray<byte>(File.ReadAllBytes(path)));
((Texture)val).wrapMode = (TextureWrapMode)0;
Object.DontDestroyOnLoad((Object)val);
return val;
}
public static void Goldify(GameObject go)
{
if ((Object)(object)go == (Object)null)
{
return;
}
EnsureTextures();
foreach (Renderer componentsInChild in go.GetComponentsInChildren<Renderer>(true))
{
if ((Object)(object)componentsInChild == (Object)null)
{
continue;
}
try
{
Il2CppReferenceArray<Material> materials = componentsInChild.materials;
int num = ((Il2CppArrayBase<Material>)(object)materials)?.Length ?? 0;
for (int i = 0; i < num; i++)
{
Material val = ((Il2CppArrayBase<Material>)(object)materials)[i];
if ((Object)(object)val != (Object)null)
{
Gild(val);
}
}
}
catch
{
}
}
}
private static void Gild(Material m)
{
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01c6: 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_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_01d1: 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_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_albedo != (Object)null)
{
SetTex(m, "_BaseMap", (Texture)(object)_albedo);
SetTex(m, "_MainTex", (Texture)(object)_albedo);
SetColor(m, "_BaseColor", Color.white);
SetColor(m, "_Color", Color.white);
try
{
m.color = Color.white;
}
catch
{
}
try
{
m.SetTextureScale("_BaseMap", new Vector2(Tiling, Tiling));
}
catch
{
}
if ((Object)(object)_normal != (Object)null)
{
SetTex(m, "_BumpMap", (Texture)(object)_normal);
TryKeyword(m, "_NORMALMAP");
SetFloat(m, "_BumpScale", 1f);
}
if ((Object)(object)_metal != (Object)null)
{
SetTex(m, "_MetallicGlossMap", (Texture)(object)_metal);
TryKeyword(m, "_METALLICSPECGLOSSMAP");
SetFloat(m, "_Metallic", 1f);
SetFloat(m, "_Smoothness", 1f);
SetFloat(m, "_GlossMapScale", 1f);
}
else
{
SetFloat(m, "_Metallic", 1f);
SetFloat(m, "_Smoothness", 0.9f);
}
if ((Object)(object)_ao != (Object)null)
{
SetTex(m, "_OcclusionMap", (Texture)(object)_ao);
TryKeyword(m, "_OCCLUSIONMAP");
SetFloat(m, "_OcclusionStrength", 1f);
}
SetColor(m, "_EmissionColor", Gold * 0.12f);
TryKeyword(m, "_EMISSION");
}
else
{
SetTex(m, "_BaseMap", (Texture)(object)Texture2D.whiteTexture);
SetTex(m, "_MainTex", (Texture)(object)Texture2D.whiteTexture);
SetColor(m, "_BaseColor", Gold);
SetColor(m, "_Color", Gold);
try
{
m.color = Gold;
}
catch
{
}
SetFloat(m, "_Metallic", 1f);
SetFloat(m, "_Smoothness", 0.9f);
SetFloat(m, "_Glossiness", 0.9f);
}
}
public static void Freeze(GameObject go)
{
if ((Object)(object)go == (Object)null)
{
return;
}
try
{
foreach (Animator componentsInChild in go.GetComponentsInChildren<Animator>(true))
{
if ((Object)(object)componentsInChild != (Object)null)
{
try
{
((Behaviour)componentsInChild).enabled = false;
}
catch
{
}
}
}
foreach (Joint componentsInChild2 in go.GetComponentsInChildren<Joint>(true))
{
if ((Object)(object)componentsInChild2 != (Object)null)
{
try
{
Object.Destroy((Object)(object)componentsInChild2);
}
catch
{
}
}
}
Rigidbody val = go.GetComponent<Rigidbody>();
foreach (Rigidbody componentsInChild3 in go.GetComponentsInChildren<Rigidbody>(true))
{
if (!((Object)(object)componentsInChild3 == (Object)null) && (!((Object)(object)val != (Object)null) || !(((Il2CppObjectBase)componentsInChild3).Pointer == ((Il2CppObjectBase)val).Pointer)))
{
try
{
Object.Destroy((Object)(object)componentsInChild3);
}
catch
{
}
}
}
if ((Object)(object)val == (Object)null)
{
val = go.AddComponent<Rigidbody>();
}
val.isKinematic = false;
val.useGravity = true;
val.mass = 60f;
try
{
val.collisionDetectionMode = (CollisionDetectionMode)2;
}
catch
{
}
try
{
val.interpolation = (RigidbodyInterpolation)1;
}
catch
{
}
}
catch (Exception ex)
{
MelonLogger.Warning("[GoldenPan] petrify: " + ex.Message);
}
}
private static void TryKeyword(Material m, string k)
{
try
{
m.EnableKeyword(k);
}
catch
{
}
}
private static void SetColor(Material m, string p, Color c)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
try
{
if (m.HasProperty(p))
{
m.SetColor(p, c);
}
}
catch
{
}
}
private static void SetFloat(Material m, string p, float f)
{
try
{
if (m.HasProperty(p))
{
m.SetFloat(p, f);
}
}
catch
{
}
}
private static void SetTex(Material m, string p, Texture t)
{
try
{
if (m.HasProperty(p))
{
m.SetTexture(p, t);
}
}
catch
{
}
}
}
public class GoldenPanBehavior : MonoBehaviour
{
public static AudioClip GoldSound;
public static float MinSpeed = 1.2f;
public static float Volume = 1f;
private Transform _panRoot;
private float _lastHit;
public GoldenPanBehavior(IntPtr ptr)
: base(ptr)
{
}
public GoldenPanBehavior()
: base(ClassInjector.DerivedConstructorPointer<GoldenPanBehavior>())
{
ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
}
private void Start()
{
_panRoot = ((Component)this).transform.root;
}
private void OnCollisionEnter(Collision c)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: 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)
try
{
if (Time.time - _lastHit < 0.1f)
{
return;
}
Vector3 relativeVelocity = c.relativeVelocity;
if (((Vector3)(ref relativeVelocity)).magnitude < MinSpeed)
{
return;
}
Rigidbody rigidbody = c.rigidbody;
if ((Object)(object)rigidbody == (Object)null || rigidbody.isKinematic)
{
return;
}
Transform root = ((Component)rigidbody).transform.root;
if ((Object)(object)root == (Object)null || ((Object)(object)_panRoot != (Object)null && ((Il2CppObjectBase)root).Pointer == ((Il2CppObjectBase)_panRoot).Pointer))
{
return;
}
string name = ((Object)root).name;
if (name != null)
{
string text = name.ToLower();
if (text.Contains("rigmanager") || text.Contains("player"))
{
return;
}
}
Gilding.Goldify(((Component)root).gameObject);
Gilding.Freeze(((Component)root).gameObject);
_lastHit = Time.time;
if ((Object)(object)GoldSound != (Object)null)
{
AudioClip goldSound = GoldSound;
ContactPoint contact = c.GetContact(0);
AudioSource.PlayClipAtPoint(goldSound, ((ContactPoint)(ref contact)).point, Volume);
}
}
catch (Exception ex)
{
MelonLogger.Warning("[GoldenPan] impact: " + ex.Message);
}
}
}
public class GoldenPanMod : MelonMod
{
public const string FryingPanBarcode = "c1534c5a-d0e9-4d53-9218-e76446727969";
public static bool AutoGild = true;
private static string _wavPath;
private static bool _ready;
public override void OnInitializeMelon()
{
//IL_0038: 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_0066: Unknown result type (might be due to invalid IL or missing references)
ClassInjector.RegisterTypeInIl2Cpp<GoldenPanBehavior>();
_wavPath = Path.Combine(Path.GetDirectoryName(Application.dataPath), "UserData", "GoldenPan", "Goldered.wav");
_ready = true;
Page obj = Page.Root.CreatePage("Golden Pan", Gilding.Gold, 0, true);
obj.CreateFunction("Spawn Golden Pan", Color.yellow, (Action)SpawnPan);
obj.CreateBool("Auto-gild all frying pans", Color.white, AutoGild, (Action<bool>)delegate(bool v)
{
AutoGild = v;
});
((MelonBase)this).LoggerInstance.Msg("Golden Pan v1.1 loaded. Spawn a frying pan (menu or spawn gun) and it's golden.");
}
private static void EnsureSound()
{
if ((Object)(object)GoldenPanBehavior.GoldSound != (Object)null)
{
return;
}
if (!File.Exists(_wavPath))
{
MelonLogger.Warning("[GoldenPan] Goldered.wav missing at " + _wavPath);
return;
}
AudioClip val = WavLoader.Load(_wavPath, "Goldered");
if ((Object)(object)val != (Object)null)
{
Object.DontDestroyOnLoad((Object)(object)val);
GoldenPanBehavior.GoldSound = val;
}
}
public static void MakeGolden(GameObject go)
{
if ((Object)(object)go == (Object)null)
{
return;
}
try
{
EnsureSound();
Rigidbody componentInChildren = go.GetComponentInChildren<Rigidbody>(true);
GameObject val = (((Object)(object)componentInChildren != (Object)null) ? ((Component)componentInChildren).gameObject : go);
if (!((Object)(object)val.GetComponent<GoldenPanBehavior>() != (Object)null))
{
Gilding.Goldify(go);
val.AddComponent<GoldenPanBehavior>();
MelonLogger.Msg("[GoldenPan] gilded '" + ((Object)go).name + "'.");
}
}
catch (Exception ex)
{
MelonLogger.Warning("[GoldenPan] MakeGolden: " + ex.Message);
}
}
private void SpawnPan()
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: 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_0031: 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_0040: 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_004f: 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_0059: 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_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Expected O, but got Unknown
//IL_00bc: 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_00d1: Expected O, but got Unknown
try
{
if (_ready)
{
EnsureSound();
Camera val = FindCam();
Vector3 val2 = default(Vector3);
Quaternion val3;
if ((Object)(object)val != (Object)null)
{
Transform transform = ((Component)val).transform;
val2 = transform.position + transform.forward * 0.7f - Vector3.up * 0.15f;
val3 = transform.rotation;
}
else
{
((Vector3)(ref val2))..ctor(0f, 1.5f, 0f);
val3 = Quaternion.identity;
}
Spawnable val4 = new Spawnable
{
crateRef = new SpawnableCrateReference("c1534c5a-d0e9-4d53-9218-e76446727969")
};
AssetSpawner.Register(val4);
Action<GameObject> val5 = DelegateSupport.ConvertDelegate<Action<GameObject>>((Delegate)new Action<GameObject>(MakeGolden));
AssetSpawner.Spawn(val4, val2, val3, new Nullable<Vector3>(), (Transform)null, false, new Nullable<int>(), val5, (Action<GameObject>)null);
MelonLogger.Msg("[GoldenPan] spawning golden pan...");
}
}
catch (Exception ex)
{
MelonLogger.Error("[GoldenPan] spawn failed: " + ex);
}
}
private static Camera FindCam()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Invalid comparison between Unknown and I4
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Invalid comparison between Unknown and I4
Camera main = Camera.main;
if ((Object)(object)main != (Object)null)
{
return main;
}
Il2CppReferenceArray<Camera> allCameras = Camera.allCameras;
foreach (Camera item in (Il2CppArrayBase<Camera>)(object)allCameras)
{
if ((Object)(object)item != (Object)null && (int)item.cameraType == 1 && item.stereoEnabled)
{
return item;
}
}
foreach (Camera item2 in (Il2CppArrayBase<Camera>)(object)allCameras)
{
if ((Object)(object)item2 != (Object)null && (int)item2.cameraType == 1)
{
return item2;
}
}
return null;
}
}
[HarmonyPatch(typeof(Poolee), "OnSpawn")]
internal static class Poolee_OnSpawn_Patch
{
private static void Postfix(Poolee __instance)
{
try
{
if (!GoldenPanMod.AutoGild || (Object)(object)__instance == (Object)null)
{
return;
}
SpawnableCrate spawnableCrate = __instance.SpawnableCrate;
if (!((Object)(object)spawnableCrate == (Object)null))
{
Barcode barcode = ((Scannable)spawnableCrate).Barcode;
if (!(barcode == (Barcode)null) && !(barcode.ID != "c1534c5a-d0e9-4d53-9218-e76446727969"))
{
GoldenPanMod.MakeGolden(((Component)__instance).gameObject);
}
}
}
catch (Exception ex)
{
MelonLogger.Warning("[GoldenPan] OnSpawn hook: " + ex.Message);
}
}
}
internal static class WavLoader
{
public static AudioClip Load(string path, string name)
{
try
{
byte[] array = File.ReadAllBytes(path);
if (array.Length < 44 || Encoding.ASCII.GetString(array, 0, 4) != "RIFF")
{
return null;
}
int num = BitConverter.ToInt16(array, 22);
int num2 = BitConverter.ToInt32(array, 24);
int num3 = BitConverter.ToInt16(array, 34);
int i = 12;
int num4 = -1;
int num5 = 0;
int num6;
for (; i + 8 <= array.Length; i += 8 + num6 + (num6 & 1))
{
string text = Encoding.ASCII.GetString(array, i, 4);
num6 = BitConverter.ToInt32(array, i + 4);
if (text == "data")
{
num4 = i + 8;
num5 = num6;
break;
}
}
if (num4 < 0 || num <= 0 || num2 <= 0)
{
return null;
}
if (num4 + num5 > array.Length)
{
num5 = array.Length - num4;
}
int num7 = num3 / 8;
int num8 = num5 / num7;
float[] array2 = new float[num8];
for (int j = 0; j < num8; j++)
{
int num9 = num4 + j * num7;
switch (num3)
{
case 16:
array2[j] = (float)BitConverter.ToInt16(array, num9) / 32768f;
break;
case 32:
array2[j] = (float)BitConverter.ToInt32(array, num9) / 2.1474836E+09f;
break;
case 8:
array2[j] = (float)(array[num9] - 128) / 128f;
break;
}
}
AudioClip val = AudioClip.Create(name, num8 / num, num, num2, false);
val.SetData(new Il2CppStructArray<float>(array2), 0);
MelonLogger.Msg("[GoldenPan] loaded sound '" + name + "' (" + num + "ch " + num2 + "Hz " + num3 + "bit).");
return val;
}
catch (Exception ex)
{
MelonLogger.Warning("[GoldenPan] WAV load failed: " + ex.Message);
return null;
}
}
}
}
