using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.Notifications;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.SceneStreaming;
using Il2CppSLZ.Marrow.Warehouse;
using LabFusion.RPC;
using MelonLoader;
using MelonLoader.Utils;
using MoonSharp.Interpreter;
using MoonSharp.Interpreter.Interop;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.SceneManagement;
using lumod;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Lua modding!!!")]
[assembly: AssemblyDescription("Lua modding!!!")]
[assembly: AssemblyCompany("mc")]
[assembly: AssemblyProduct("Lumod")]
[assembly: AssemblyCopyright("Developed by dc@mei_dot_com")]
[assembly: AssemblyTrademark("mc")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: MelonInfo(typeof(Main), "Lumod", "1.0.0", "dc@mei_dot_com", "Link")]
[assembly: MelonColor(0, 255, 255, 255)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace lumod;

internal class Main : MelonMod
{
	internal static class LumodMenu
	{
		public static void CreateElements()
		{
			//IL_000b: 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_0031: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			Page val = Page.Root.CreatePage("_Lumod", Color.cyan, 0, true);
			Page val2 = val.CreatePage("How do I use this?", Color.white, 0, true);
			val2.CreateFunction("RIGHT MENU + RIGHT A + LEFT MENU to reload lua.", Color.white, (Action)null);
			val2.CreateFunction("If on flatplayer, press L to reload lua.", Color.white, (Action)null);
			string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Lumod");
			Directory.CreateDirectory(text);
			string[] files = Directory.GetFiles(text, "*.lua");
			foreach (string text2 in files)
			{
				scriptPages[text2] = val.CreatePage(text2.Replace(text, ""), Color.white, 0, true);
			}
		}
	}

	public static class Vec
	{
		public static Table ToTable(Script s, Vector3 v)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_000e: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			Table val = new Table(s);
			val[(object)"x"] = v.x;
			val[(object)"y"] = v.y;
			val[(object)"z"] = v.z;
			DynValue val2 = s.Globals.Get("_VEC_MT");
			if ((int)val2.Type == 6)
			{
				val.MetaTable = val2.Table;
			}
			return val;
		}

		public static Vector3 ToVector(Table v)
		{
			//IL_0031: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)v[(object)"x"], (float)v[(object)"y"], (float)v[(object)"z"]);
		}
	}

	[MoonSharpUserData]
	public class RigidBodyApi
	{
		private readonly Script script;

		private readonly Rigidbody rb;

		public bool isKinematic
		{
			get
			{
				return !((Object)(object)rb == (Object)null) && rb.isKinematic;
			}
			set
			{
				if ((Object)(object)rb != (Object)null)
				{
					rb.isKinematic = value;
				}
			}
		}

		public Table Velocity
		{
			get
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)rb == (Object)null)
				{
					return null;
				}
				return ToVecTable(rb.velocity);
			}
			set
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)rb == (Object)null) && value != null)
				{
					rb.velocity = new Vector3((float)value.Get("x").Number, (float)value.Get("y").Number, (float)value.Get("z").Number);
				}
			}
		}

		public Table AngVel
		{
			get
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)rb == (Object)null)
				{
					return null;
				}
				return ToVecTable(rb.angularVelocity);
			}
			set
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)rb == (Object)null) && value != null)
				{
					rb.angularVelocity = new Vector3((float)value.Get("x").Number, (float)value.Get("y").Number, (float)value.Get("z").Number);
				}
			}
		}

		public RigidBodyApi(Script script, Rigidbody rb)
		{
			this.script = script;
			this.rb = rb;
		}

		public void Destroy()
		{
			if (!((Object)(object)rb == (Object)null))
			{
				Object.Destroy((Object)(object)rb);
			}
		}

		private Table ToVecTable(Vector3 v)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Vec.ToTable(script, v);
		}
	}

	[MoonSharpUserData]
	public class ObjectApi
	{
		private readonly Script script;

		private readonly GameObject go;

		public string Name
		{
			get
			{
				return ((Object)(object)go == (Object)null) ? null : ((Object)go).name;
			}
			set
			{
				if ((Object)(object)go != (Object)null)
				{
					((Object)go).name = value;
				}
			}
		}

		public int Layer
		{
			get
			{
				return ((Object)(object)go == (Object)null) ? (-1) : go.layer;
			}
			set
			{
				if ((Object)(object)go != (Object)null)
				{
					go.layer = value;
				}
			}
		}

		public string LayerName => LayerMask.LayerToName(go.layer);

		public RigidBodyApi Rigidbody => ((Object)(object)go.GetComponent<Rigidbody>() == (Object)null) ? null : new RigidBodyApi(script, go.GetComponent<Rigidbody>());

		public Table MatColor
		{
			get
			{
				//IL_0037: 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_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)
				if ((Object)(object)go == (Object)null)
				{
					return null;
				}
				Renderer component = go.GetComponent<Renderer>();
				if ((Object)(object)component == (Object)null)
				{
					return null;
				}
				return ToVecTable(new Vector3(component.material.color.r, component.material.color.g, component.material.color.b));
			}
			set
			{
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)go == (Object)null))
				{
					Renderer component = go.GetComponent<Renderer>();
					if (!((Object)(object)component == (Object)null))
					{
						component.material.color = new Color((float)value.Get("x").Number, (float)value.Get("y").Number, (float)value.Get("z").Number, 1f);
					}
				}
			}
		}

		public ObjectApi Parent
		{
			get
			{
				if ((Object)(object)go == (Object)null || (Object)(object)go.transform.parent == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)go.transform.parent).gameObject);
			}
		}

		public ObjectApi Root
		{
			get
			{
				if ((Object)(object)go == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)go.transform.root).gameObject);
			}
		}

		public Table Children
		{
			get
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Expected O, but got Unknown
				if ((Object)(object)go == (Object)null)
				{
					return null;
				}
				Table val = new Table(script);
				for (int i = 0; i < go.transform.childCount; i++)
				{
					val.Append(DynValue.FromObject(script, (object)new ObjectApi(script, ((Component)go.transform.GetChild(i)).gameObject)));
				}
				return val;
			}
		}

		public Table Forward => ((Object)(object)go == (Object)null) ? null : ToVecTable(go.transform.forward);

		public Table Right => ((Object)(object)go == (Object)null) ? null : ToVecTable(go.transform.right);

		public Table Position
		{
			get
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				return ((Object)(object)go == (Object)null) ? null : ToVecTable(go.transform.position);
			}
			set
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)go == (Object)null) && value != null)
				{
					float num = (float)value.Get("x").Number;
					float num2 = (float)value.Get("y").Number;
					float num3 = (float)value.Get("z").Number;
					go.transform.position = new Vector3(num, num2, num3);
				}
			}
		}

		public Table Rotation
		{
			get
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				return ((Object)(object)go == (Object)null) ? null : ToVecTable(go.transform.eulerAngles);
			}
			set
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)go == (Object)null) && value != null)
				{
					float num = (float)value.Get("x").Number;
					float num2 = (float)value.Get("y").Number;
					float num3 = (float)value.Get("z").Number;
					go.transform.eulerAngles = new Vector3(num, num2, num3);
				}
			}
		}

		public Table LocalScale
		{
			get
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				return ((Object)(object)go == (Object)null) ? null : ToVecTable(go.transform.localScale);
			}
			set
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)go == (Object)null) && value != null)
				{
					float num = (float)value.Get("x").Number;
					float num2 = (float)value.Get("y").Number;
					float num3 = (float)value.Get("z").Number;
					go.transform.localScale = new Vector3(num, num2, num3);
				}
			}
		}

		public override string ToString()
		{
			return ((Object)(object)go == (Object)null) ? "ObjectApi(dead)" : ("ObjectApi(" + ((Object)go).name + ")");
		}

		public ObjectApi(Script script, GameObject go)
		{
			this.script = script;
			this.go = go;
		}

		public void Destroy()
		{
			if (!((Object)(object)go == (Object)null))
			{
				Object.Destroy((Object)(object)go);
			}
		}

		public ObjectApi FindChild(string name)
		{
			return new ObjectApi(script, ((Component)go.transform.Find(name)).gameObject);
		}

		private Table ToVecTable(Vector3 v)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Vec.ToTable(script, v);
		}
	}

	[MoonSharpUserData]
	public class CameraApi
	{
		private readonly Script script;

		private readonly Camera camera;

		public ObjectApi GameObject => new ObjectApi(script, ((Component)camera).gameObject);

		public int CullingMask
		{
			get
			{
				return camera.cullingMask;
			}
			set
			{
				camera.cullingMask = value;
			}
		}

		public Table BackgroundColor
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: 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_0058: 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)
				//IL_0076: Expected O, but got Unknown
				return new Table(script)
				{
					[(object)"x"] = camera.backgroundColor.r,
					[(object)"y"] = camera.backgroundColor.g,
					[(object)"z"] = camera.backgroundColor.b
				};
			}
			set
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				if (value != null)
				{
					float num = (float)value.Get("x").Number;
					float num2 = (float)value.Get("y").Number;
					float num3 = (float)value.Get("z").Number;
					camera.backgroundColor = new Color(num, num2, num3);
				}
			}
		}

		public int ClearFlags
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (int)camera.clearFlags;
			}
			set
			{
				camera.clearFlags = (CameraClearFlags)value;
			}
		}

		public CameraApi(Script script, Camera camera)
		{
			this.script = script;
			this.camera = camera;
		}
	}

	[MoonSharpUserData]
	public class PlayerApi
	{
		private readonly Script script;

		public CameraApi MainCamera
		{
			get
			{
				Camera componentInChildren = ((Component)Player.ControllerRig).gameObject.GetComponentInChildren<Camera>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					return null;
				}
				return new CameraApi(script, componentInChildren);
			}
		}

		public CameraApi SpectatorCamera
		{
			get
			{
				Camera componentInChildren = GameObject.Find("GameplaySystems [0]/DisabledContainer/Spectator Camera/").GetComponentInChildren<Camera>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					return null;
				}
				return new CameraApi(script, componentInChildren);
			}
		}

		public ObjectApi RigManager => new ObjectApi(script, ((Component)Player.RigManager).gameObject);

		public ObjectApi PhysicsRig => new ObjectApi(script, ((Component)Player.PhysicsRig).gameObject);

		public float Health
		{
			get
			{
				if ((Object)(object)Player.RigManager.health == (Object)null)
				{
					return 1f;
				}
				return Player.RigManager.health.curr_Health;
			}
			set
			{
				if (value > 0f)
				{
					Player.RigManager.health.alive = true;
					Player.RigManager.health.deathIsImminent = false;
					Player.RigManager.health.Respawn();
				}
				Player.RigManager.health.curr_Health = value;
			}
		}

		public float MaxHealth
		{
			get
			{
				if ((Object)(object)Player.RigManager.health == (Object)null)
				{
					return 1f;
				}
				return Player.RigManager.health.max_Health;
			}
			set
			{
				Player.RigManager.health.max_Health = value;
			}
		}

		public ObjectApi RightHand
		{
			get
			{
				Hand rightHand = Player.RightHand;
				if ((Object)(object)rightHand == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)rightHand).gameObject);
			}
		}

		public ObjectApi LeftHand
		{
			get
			{
				Hand leftHand = Player.LeftHand;
				if ((Object)(object)leftHand == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)leftHand).gameObject);
			}
		}

		public ObjectApi Head
		{
			get
			{
				Transform head = Player.Head;
				if ((Object)(object)head == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)head).gameObject);
			}
		}

		public ObjectApi Chest
		{
			get
			{
				Transform chest = Player.Chest;
				if ((Object)(object)chest == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)chest).gameObject);
			}
		}

		public ObjectApi Pelvis
		{
			get
			{
				Transform pelvis = ((Rig)Player.PhysicsRig).m_pelvis;
				if ((Object)(object)pelvis == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)pelvis).gameObject);
			}
		}

		public ObjectApi Feet
		{
			get
			{
				GameObject feet = Player.PhysicsRig.feet;
				if ((Object)(object)feet == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, feet.gameObject);
			}
		}

		public ObjectApi LeftShoulder
		{
			get
			{
				Transform shoulderLf = ((Rig)Player.PhysicsRig).m_shoulderLf;
				if ((Object)(object)shoulderLf == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)shoulderLf).gameObject);
			}
		}

		public ObjectApi RightShoulder
		{
			get
			{
				Transform shoulderRt = ((Rig)Player.PhysicsRig).m_shoulderRt;
				if ((Object)(object)shoulderRt == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)shoulderRt).gameObject);
			}
		}

		public ObjectApi LeftElbow
		{
			get
			{
				Transform elbowLf = ((Rig)Player.PhysicsRig).m_elbowLf;
				if ((Object)(object)elbowLf == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)elbowLf).gameObject);
			}
		}

		public ObjectApi RightElbow
		{
			get
			{
				Transform elbowRt = ((Rig)Player.PhysicsRig).m_elbowRt;
				if ((Object)(object)elbowRt == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)elbowRt).gameObject);
			}
		}

		public ObjectApi LeftHip
		{
			get
			{
				Transform hipLf = ((Rig)Player.PhysicsRig).m_hipLf;
				if ((Object)(object)hipLf == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)hipLf).gameObject);
			}
		}

		public ObjectApi RightHip
		{
			get
			{
				Transform hipRt = ((Rig)Player.PhysicsRig).m_hipRt;
				if ((Object)(object)hipRt == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)hipRt).gameObject);
			}
		}

		public ObjectApi LeftKnee
		{
			get
			{
				Transform kneeLf = ((Rig)Player.PhysicsRig).m_kneeLf;
				if ((Object)(object)kneeLf == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)kneeLf).gameObject);
			}
		}

		public ObjectApi RightKnee
		{
			get
			{
				Transform kneeRt = ((Rig)Player.PhysicsRig).m_kneeRt;
				if ((Object)(object)kneeRt == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)kneeRt).gameObject);
			}
		}

		public ObjectApi LeftFoot
		{
			get
			{
				Transform footLf = ((Rig)Player.PhysicsRig).m_footLf;
				if ((Object)(object)footLf == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)footLf).gameObject);
			}
		}

		public ObjectApi RightFoot
		{
			get
			{
				Transform footRt = ((Rig)Player.PhysicsRig).m_footRt;
				if ((Object)(object)footRt == (Object)null)
				{
					return null;
				}
				return new ObjectApi(script, ((Component)footRt).gameObject);
			}
		}

		public PlayerApi(Script script)
		{
			this.script = script;
		}

		public void Revive()
		{
			Player.RigManager.health.Respawn();
		}

		public void Teleport(Table pos)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (pos != null && !((Object)(object)Player.RigManager == (Object)null))
			{
				float num = (float)pos.Get("x").Number;
				float num2 = (float)pos.Get("y").Number;
				float num3 = (float)pos.Get("z").Number;
				Player.RigManager.Teleport(new Vector3(num, num2, num3), true);
			}
		}
	}

	[MoonSharpUserData]
	public class InputApi
	{
		private readonly Script script;

		public InputApi(Script script)
		{
			this.script = script;
		}

		public bool KeyDown(string name)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return false;
			}
			if (!Enum.TryParse<Key>(name, ignoreCase: true, out Key result))
			{
				return false;
			}
			return ((ButtonControl)current[result]).wasPressedThisFrame;
		}

		public bool KeyHeld(string name)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return false;
			}
			if (!Enum.TryParse<Key>(name, ignoreCase: true, out Key result))
			{
				return false;
			}
			return ((ButtonControl)current[result]).isPressed;
		}

		public string CurrentKey()
		{
			//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)
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return null;
			}
			Enumerator<KeyControl> enumerator = current.allKeys.GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyControl current2 = enumerator.Current;
				if (((ButtonControl)current2).isPressed)
				{
					return ((object)current2.keyCode/*cast due to .constrained prefix*/).ToString();
				}
			}
			return null;
		}

		public bool RightMenuDown()
		{
			return (Object)(object)Player.RightHand != (Object)null && Player.RightController.GetBButtonDown();
		}

		public bool RightMenuHeld()
		{
			return (Object)(object)Player.RightController != (Object)null && Player.RightController.GetBButton();
		}

		public bool LeftMenuDown()
		{
			return (Object)(object)Player.LeftController != (Object)null && Player.LeftController.GetBButtonDown();
		}

		public bool LeftMenuHeld()
		{
			return (Object)(object)Player.LeftController != (Object)null && Player.LeftController.GetBButton();
		}

		public bool RightADown()
		{
			return (Object)(object)Player.RightController != (Object)null && Player.RightController.GetAButtonDown();
		}

		public bool RightAHeld()
		{
			return (Object)(object)Player.RightController != (Object)null && Player.RightController.GetAButton();
		}

		public bool LeftADown()
		{
			return (Object)(object)Player.LeftController != (Object)null && Player.LeftController.GetAButtonDown();
		}

		public bool LeftAHeld()
		{
			return (Object)(object)Player.LeftController != (Object)null && Player.LeftController.GetAButton();
		}

		public bool RightStickDown()
		{
			return (Object)(object)Player.RightController != (Object)null && Player.RightController.GetThumbStickDown();
		}

		public bool LeftStickDown()
		{
			return (Object)(object)Player.LeftController != (Object)null && Player.LeftController.GetThumbStickDown();
		}

		public Table RightStickAxis()
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.RightController == (Object)null)
			{
				return null;
			}
			Vector2 thumbStickAxis = Player.RightController.GetThumbStickAxis();
			Table val = new Table(script);
			val[(object)"x"] = thumbStickAxis.x;
			val[(object)"y"] = thumbStickAxis.y;
			return val;
		}

		public Table LeftStickAxis()
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.LeftController == (Object)null)
			{
				return null;
			}
			Vector2 thumbStickAxis = Player.LeftController.GetThumbStickAxis();
			Table val = new Table(script);
			val[(object)"x"] = thumbStickAxis.x;
			val[(object)"y"] = thumbStickAxis.y;
			return val;
		}

		public bool RightTriggerDown()
		{
			return (Object)(object)Player.RightController != (Object)null && Player.RightHand._indexButtonDown;
		}

		public bool LeftTriggerDown()
		{
			return (Object)(object)Player.LeftController != (Object)null && Player.LeftHand._indexButtonDown;
		}

		public float RightTriggerValue()
		{
			return ((Object)(object)Player.RightController != (Object)null) ? Player.RightHand._indexTriggerAxis : 0f;
		}

		public float LeftTriggerValue()
		{
			return ((Object)(object)Player.LeftController != (Object)null) ? Player.LeftHand._indexTriggerAxis : 0f;
		}
	}

	[MoonSharpUserData]
	public class DebugApi
	{
		private readonly Script script;

		public DebugApi(Script script)
		{
			this.script = script;
		}

		public ObjectApi DrawLine(Table fromt, Table tot, Table color, float alpha = 1f, float startWidth = 0.01f, float endWidth = 0.01f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ToVector3(fromt);
			Vector3 val2 = ToVector3(tot);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor((float)color.Get("x").Number, (float)color.Get("y").Number, (float)color.Get("z").Number, alpha);
			GameObject val4 = new GameObject("DebugLine");
			LineRenderer val5 = val4.AddComponent<LineRenderer>();
			val5.positionCount = 2;
			val5.useWorldSpace = true;
			val5.startWidth = startWidth;
			val5.endWidth = endWidth;
			((Renderer)val5).material = new Material(Shader.Find("Sprites/Default"));
			Color startColor = (val5.endColor = val3);
			val5.startColor = startColor;
			val5.SetPosition(0, val);
			val5.SetPosition(1, val2);
			return new ObjectApi(script, val4);
		}

		public ObjectApi DrawSphere(Table pos, Table size, Table color, float alpha = 1f)
		{
			//IL_001c: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
			((Collider)val.GetComponent<SphereCollider>()).enabled = false;
			val.transform.position = ToVector3(pos);
			val.transform.localScale = ToVector3(size);
			Renderer component = val.GetComponent<Renderer>();
			component.material = new Material(Shader.Find("UI/Default"));
			component.material.color = new Color((float)color.Get("x").Number, (float)color.Get("y").Number, (float)color.Get("z").Number, alpha);
			return new ObjectApi(script, val);
		}
	}

	[MoonSharpUserData]
	public class CrateApi
	{
		private readonly Script script;

		public CrateApi(Script script)
		{
			this.script = script;
		}

		public void Spawn(string barcode, Table pos, Table rotation, DynValue spawnCallback = null)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_003b: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_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)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			Action<ObjectApi> onSpawned = delegate(ObjectApi obj)
			{
				//IL_004a: Expected O, but got Unknown
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Invalid comparison between Unknown and I4
				if (spawnCallback == null || (int)spawnCallback.Type != 5)
				{
					return;
				}
				try
				{
					script.Call(spawnCallback, new object[1] { obj });
				}
				catch (ScriptRuntimeException ex)
				{
					ScriptRuntimeException ex2 = ex;
					MelonLogger.Error(((InterpreterException)ex2).DecoratedMessage);
				}
			};
			Spawnable spawnable = new Spawnable
			{
				crateRef = new SpawnableCrateReference(barcode)
			};
			NetworkAssetSpawner.Spawn(new SpawnRequestInfo
			{
				Spawnable = spawnable,
				Position = ToVector3(pos),
				Rotation = Quaternion.Euler(ToVector3(rotation)),
				SpawnCallback = delegate(SpawnCallbackInfo info)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					if (onSpawned != null && (Object)(object)info.Spawned != (Object)null)
					{
						script.Call((object)onSpawned, new object[1] { DynValue.FromObject(script, (object)new ObjectApi(script, info.Spawned)) });
					}
				}
			});
		}
	}

	[MoonSharpUserData]
	public class MelonPageApi
	{
		private readonly Script script;

		private readonly Page page;

		public MelonPageApi(Script script, Page page)
		{
			this.script = script;
			this.page = page;
		}

		public void CreateFunction(string name, Table color, DynValue callback)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (callback == null || (int)callback.Type != 5)
			{
				return;
			}
			Color val = default(Color);
			((Color)(ref val))..ctor((float)color.Get("x").Number, (float)color.Get("y").Number, (float)color.Get("z").Number);
			page.CreateFunction(name, val, (Action)delegate
			{
				//IL_001d: Expected O, but got Unknown
				try
				{
					script.Call(callback);
				}
				catch (ScriptRuntimeException ex)
				{
					ScriptRuntimeException ex2 = ex;
					MelonLogger.Error(((InterpreterException)ex2).DecoratedMessage);
				}
			});
			if (page.Color == Color.white)
			{
				page.Color = Color.cyan;
			}
		}
	}

	internal const string Name = "Lumod";

	internal const string Description = "Lua modding!!!";

	internal const string Author = "dc@mei_dot_com";

	internal const string Company = "mc";

	internal const string Version = "1.0.0";

	internal const string DownloadLink = "Link";

	private List<DynValue> updateHandlers = new List<DynValue>();

	private List<DynValue> fixedUpdateHandlers = new List<DynValue>();

	private List<DynValue> sceneHandlers = new List<DynValue>();

	private List<DynValue> keyHandlers = new List<DynValue>();

	private static Dictionary<string, Page> scriptPages = new Dictionary<string, Page>();

	private bool done = false;

	public static Vector3 ToVector3(Table t)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		return new Vector3((float)t.Get("x").Number, (float)t.Get("y").Number, (float)t.Get("z").Number);
	}

	public override void OnEarlyInitializeMelon()
	{
		((MelonBase)this).OnEarlyInitializeMelon();
	}

	private void LoadScripts()
	{
		//IL_005e: Expected O, but got Unknown
		string path = Path.Combine(MelonEnvironment.UserDataDirectory, "Lumod");
		Directory.CreateDirectory(path);
		string[] files = Directory.GetFiles(path, "*.lua");
		foreach (string text in files)
		{
			MelonLogger.Msg("Loading " + text);
			Script val = MakeScript(text);
			try
			{
				val.DoString(File.ReadAllText(text), (Table)null, text);
			}
			catch (InterpreterException ex)
			{
				InterpreterException ex2 = ex;
				MelonLogger.Error("[" + text + "]\n" + ex2.DecoratedMessage);
			}
		}
	}

	public Table Raycast(Script s, Vector3 origin, Vector3 direction, float distance, int layerMask = -1)
	{
		//IL_0001: 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_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Expected O, but got Unknown
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		RaycastHit val = default(RaycastHit);
		if (Physics.Raycast(origin, direction, ref val, distance, layerMask))
		{
			ObjectApi objectApi = new ObjectApi(s, ((Component)((RaycastHit)(ref val)).collider).gameObject);
			Table val2 = new Table(s);
			val2[(object)"obj"] = objectApi;
			val2[(object)"distance"] = ((RaycastHit)(ref val)).distance;
			val2[(object)"point"] = Vec.ToTable(s, ((RaycastHit)(ref val)).point);
			val2[(object)"layer"] = ((Component)((RaycastHit)(ref val)).collider).gameObject.layer;
			val2[(object)"normal"] = Vec.ToTable(s, ((RaycastHit)(ref val)).normal);
			return val2;
		}
		return null;
	}

	public override void OnInitializeMelon()
	{
		((MelonBase)this).OnInitializeMelon();
	}

	private Script MakeScript(string file)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Expected O, but got Unknown
		Script scr = new Script();
		scr.Globals[(object)"player"] = new PlayerApi(scr);
		scr.Globals[(object)"page"] = new MelonPageApi(scr, scriptPages[file]);
		scr.Globals[(object)"crate"] = new CrateApi(scr);
		scr.Globals[(object)"debug"] = new DebugApi(scr);
		scr.Globals[(object)"input"] = new InputApi(scr);
		scr.Globals[(object)"player"] = new PlayerApi(scr);
		scr.Globals[(object)"onUpdate"] = (Action<DynValue>)delegate(DynValue fn)
		{
			updateHandlers.Add(fn);
		};
		scr.Globals[(object)"onKeyDown"] = (Action<DynValue>)delegate(DynValue fn)
		{
			keyHandlers.Add(fn);
		};
		scr.Globals[(object)"onSceneWasLoaded"] = (Action<DynValue>)delegate(DynValue fn)
		{
			sceneHandlers.Add(fn);
		};
		scr.Globals[(object)"print"] = DynValue.NewCallback((Func<ScriptExecutionContext, CallbackArguments, DynValue>)delegate(ScriptExecutionContext ctx, CallbackArguments args)
		{
			List<string> list = new List<string>();
			string oldValue = Path.Combine(MelonEnvironment.UserDataDirectory, "Lumod");
			for (int i = 0; i < args.Count; i++)
			{
				list.Add(args[i].ToPrintString());
			}
			MelonLogger.Msg("[" + file.Replace(oldValue, "") + "] " + string.Join("\t", list));
			return DynValue.Nil;
		}, (string)null);
		scr.Globals[(object)"error"] = (Action<string>)delegate(string s)
		{
			MelonLogger.Error(s);
		};
		scr.Globals[(object)"warn"] = (Action<string>)delegate(string s)
		{
			MelonLogger.Warning(s);
		};
		scr.Globals[(object)"loadSceneBarcode"] = (Action<string>)delegate(string s)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			SceneStreamer.Load(new Barcode(s), (Barcode)null);
		};
		scr.Globals[(object)"loadSceneDirect"] = (Action<string>)delegate(string s)
		{
			SceneManager.LoadScene(s);
		};
		scr.Globals[(object)"notify"] = (Action<string, string, NotificationType, float>)delegate(string msg, string title, NotificationType type, float len)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Notify(msg, title, type, len);
		};
		scr.Globals[(object)"raycast"] = (Func<Table, Table, float, Table>)delegate(Table originTable, Table directionTable, float distance)
		{
			//IL_0081: 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)
			Vector3 origin = default(Vector3);
			((Vector3)(ref origin))..ctor((float)originTable.Get("x").Number, (float)originTable.Get("y").Number, (float)originTable.Get("z").Number);
			Vector3 direction = default(Vector3);
			((Vector3)(ref direction))..ctor((float)directionTable.Get("x").Number, (float)directionTable.Get("y").Number, (float)directionTable.Get("z").Number);
			return Raycast(scr, origin, direction, distance);
		};
		scr.Globals[(object)"time"] = (Func<long>)(() => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
		scr.Globals[(object)"filepath"] = (Func<string, string>)((string f) => Path.Combine(MelonEnvironment.UserDataDirectory, "Lumod", f));
		scr.Globals[(object)"vec"] = (Func<float, float, float, Table>)delegate(float x, float y, float z)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			Table val = new Table(scr);
			val[(object)"x"] = x;
			val[(object)"y"] = y;
			val[(object)"z"] = z;
			DynValue val2 = scr.Globals.Get("VectorMetatable");
			val.MetaTable = ((val2 != null && (int)val2.Type == 6) ? val2.Table : null);
			return val;
		};
		scr.Globals[(object)"import"] = (Func<string, DynValue>)((string name) => UserData.CreateStatic((from a in AppDomain.CurrentDomain.GetAssemblies()
			select a.GetType(name)).FirstOrDefault((Type t) => t != null)));
		scr.Globals[(object)"getScene"] = (Func<string>)delegate
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			return ((Scene)(ref activeScene)).name;
		};
		scr.Globals[(object)"_NOTIFY_SUCCESS"] = (object)(NotificationType)3;
		scr.Globals[(object)"_NOTIFY_ERROR"] = (object)(NotificationType)2;
		scr.Globals[(object)"_NOTIFY_INFO"] = (object)(NotificationType)0;
		scr.Globals[(object)"_NOTIFY_WARNING"] = (object)(NotificationType)1;
		scr.DoString("\r\n    local mt = {}\r\n    mt.__index = mt\r\n\r\n    function vec(x, y, z)\r\n        return setmetatable({x = x or 0, y = y or 0, z = z or 0}, mt)\r\n    end\r\n\r\n    mt.__add = function(a, b) return vec(a.x + b.x, a.y + b.y, a.z + b.z) end\r\n    mt.__sub = function(a, b) return vec(a.x - b.x, a.y - b.y, a.z - b.z) end\r\n    mt.__unm = function(a) return vec(-a.x, -a.y, -a.z) end\r\n    mt.__mul = function(a, b)\r\n        if type(a) == 'number' then return vec(a * b.x, a * b.y, a * b.z) end\r\n        if type(b) == 'number' then return vec(a.x * b, a.y * b, a.z * b) end\r\n        return vec(a.x * b.x, a.y * b.y, a.z * b.z)\r\n    end\r\n    mt.__eq = function(a, b) return a.x == b.x and a.y == b.y and a.z == b.z end\r\n    mt.__tostring = function(a) return '(' .. a.x .. ', ' .. a.y .. ', ' .. a.z .. ')' end\r\n\r\n    function mt:length() return math.sqrt(self.x^2 + self.y^2 + self.z^2) end\r\n    function mt:dot(b) return self.x * b.x + self.y * b.y + self.z * b.z end\r\n\r\n    _VEC_MT = mt\r\n", (Table)null, (string)null);
		return scr;
	}

	public override void OnLateInitializeMelon()
	{
		((MelonBase)this).OnLateInitializeMelon();
		UserData.RegistrationPolicy = InteropRegistrationPolicy.Automatic;
		UserData.RegisterType<InputApi>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<PlayerApi>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<Vector3>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<ObjectApi>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<CameraApi>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<RigidBodyApi>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<DebugApi>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<CrateApi>((InteropAccessMode)7, (string)null);
		UserData.RegisterType<MelonPageApi>((InteropAccessMode)7, (string)null);
		LumodMenu.CreateElements();
		LoadScripts();
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		//IL_0040: Expected O, but got Unknown
		((MelonMod)this).OnSceneWasLoaded(buildIndex, sceneName);
		foreach (DynValue sceneHandler in sceneHandlers)
		{
			try
			{
				sceneHandler.Function.Call(new object[2] { sceneHandler, sceneName });
			}
			catch (ScriptRuntimeException ex)
			{
				ScriptRuntimeException ex2 = ex;
				MelonLogger.Error(((InterpreterException)ex2).DecoratedMessage);
			}
		}
	}

	private void Notify(string msg, string title, NotificationType type, float len)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//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_001f: 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_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Expected O, but got Unknown
		Notification val = new Notification
		{
			Title = NotificationText.op_Implicit(title),
			Message = NotificationText.op_Implicit(msg),
			Type = type,
			ShowTitleOnPopup = true,
			PopupLength = len
		};
		Notifier.Send(val);
	}

	public override void OnUpdate()
	{
		//IL_00b1: Expected O, but got Unknown
		//IL_028b: Expected O, but got Unknown
		//IL_0238: 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)
		((MelonBase)this).OnUpdate();
		if (!done)
		{
			GameObject val = GameObject.Find("GameplaySystems [0]/DisabledContainer/[UIRig]/PLAYERUI/UI_PREFERENCES/scaleOffset/canvas_UI/group_Options/panel_Preferences/[BoneMenu] - Canvas(Clone)");
			if ((Object)(object)val != (Object)null)
			{
				foreach (Transform componentsInChild in val.GetComponentsInChildren<Transform>(true))
				{
					((Component)componentsInChild).gameObject.layer = 5;
				}
				done = true;
			}
		}
		foreach (DynValue updateHandler in updateHandlers)
		{
			try
			{
				updateHandler.Function.Call((DynValue[])(object)new DynValue[1] { updateHandler });
			}
			catch (ScriptRuntimeException ex)
			{
				ScriptRuntimeException ex2 = ex;
				MelonLogger.Error(((InterpreterException)ex2).DecoratedMessage);
			}
		}
		if ((Keyboard.current != null && ((ButtonControl)Keyboard.current.lKey).wasPressedThisFrame) || (Player.HandsExist && Player.RightController.GetAButton() && Player.RightController.GetBButton() && Player.LeftController.GetBButtonDown()))
		{
			MelonLogger.Msg("Reloading lua");
			for (int i = 0; i < scriptPages.Count; i++)
			{
				Page value = scriptPages.ElementAt(i).Value;
				value.RemoveAll();
			}
			updateHandlers = new List<DynValue>();
			sceneHandlers = new List<DynValue>();
			keyHandlers = new List<DynValue>();
			try
			{
				LoadScripts();
				Notify("Reloaded Lua scripts", "Lumod", (NotificationType)3, 0.55f);
			}
			catch (Exception ex3)
			{
				MelonLogger.Error(ex3.ToString());
				Notify("Error reloading lua: " + ex3.Message, "Lumod", (NotificationType)2, 2f);
			}
		}
		Keyboard current3 = Keyboard.current;
		if (current3 == null)
		{
			return;
		}
		ReadOnlyArray<KeyControl> allKeys = current3.allKeys;
		for (int j = 0; j < allKeys.Count; j++)
		{
			KeyControl val2 = allKeys[j];
			if (!((ButtonControl)val2).wasPressedThisFrame)
			{
				continue;
			}
			string text = ((object)val2.keyCode/*cast due to .constrained prefix*/).ToString();
			foreach (DynValue keyHandler in keyHandlers)
			{
				try
				{
					keyHandler.Function.Call(new object[2] { keyHandler, text });
				}
				catch (ScriptRuntimeException ex4)
				{
					ScriptRuntimeException ex5 = ex4;
					MelonLogger.Error(((InterpreterException)ex5).DecoratedMessage);
				}
			}
		}
	}

	public override void OnFixedUpdate()
	{
		//IL_003a: Expected O, but got Unknown
		((MelonBase)this).OnFixedUpdate();
		foreach (DynValue fixedUpdateHandler in fixedUpdateHandlers)
		{
			try
			{
				fixedUpdateHandler.Function.Call((DynValue[])(object)new DynValue[1] { fixedUpdateHandler });
			}
			catch (ScriptRuntimeException ex)
			{
				ScriptRuntimeException ex2 = ex;
				MelonLogger.Error(((InterpreterException)ex2).DecoratedMessage);
			}
		}
	}

	public override void OnLateUpdate()
	{
		((MelonBase)this).OnLateUpdate();
	}
}