using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using DG.Tweening;
using HarmonyLib;
using LuaEngine.Alarms;
using LuaEngine.Modules;
using LuaEngine.Mono;
using MapStation.Common;
using MapStation.Plugin;
using Microsoft.CodeAnalysis;
using MoonSharp.Interpreter;
using Reptile;
using TMPro;
using UnityEngine;
using UnityEngine.Playables;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("LuaEngine")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("LuaEngine Plugin for BRC.")]
[assembly: AssemblyFileVersion("0.4.0.0")]
[assembly: AssemblyInformationalVersion("0.4.0+ecb3c4555884938466d8d4a15fc91f2b48fc9b0f")]
[assembly: AssemblyProduct("LuaEngine")]
[assembly: AssemblyTitle("LuaEngine")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.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 LuaEngine
{
	public interface ILuaModule
	{
		void OnRegister(Script script);
	}
	public interface ILuaReloadable
	{
		void OnReload();
	}
	[MoonSharpUserData]
	public class LuaAnimator : LuaBuiltInBehaviour
	{
		public Animator Animator;

		[MoonSharpHidden]
		public LuaAnimator(Animator animator, Script script)
			: base((Behaviour)(object)animator, script)
		{
			Animator = animator;
		}

		internal static LuaAnimator CastMethod(Animator animator)
		{
			return new LuaAnimator(animator, LuaManager.Instance.GlobalScript);
		}

		public void SetTrigger(string name)
		{
			Animator.SetTrigger(name);
		}

		public void SetBool(string name, bool value)
		{
			Animator.SetBool(name, value);
		}

		public bool GetBool(string name)
		{
			return Animator.GetBool(name);
		}

		public void SetInteger(string name, int value)
		{
			Animator.SetInteger(name, value);
		}

		public int GetInteger(string name)
		{
			return Animator.GetInteger(name);
		}

		public void SetFloat(string name, float value)
		{
			Animator.SetFloat(name, value);
		}

		public float GetFloat(string name)
		{
			return Animator.GetFloat(name);
		}
	}
	[MoonSharpUserData]
	public class LuaAudioSource : LuaBuiltInBehaviour
	{
		public AudioSource AudioSource;

		[MoonSharpHidden]
		public LuaAudioSource(AudioSource audio, Script script)
			: base((Behaviour)(object)audio, script)
		{
			AudioSource = audio;
		}

		internal static LuaAudioSource CastMethod(AudioSource audioSource)
		{
			return new LuaAudioSource(audioSource, LuaManager.Instance.GlobalScript);
		}

		public void Play()
		{
			AudioSource.Play();
		}

		public void Stop()
		{
			AudioSource.Stop();
		}

		public void Pause()
		{
			AudioSource.Pause();
		}

		public void SetMixerGroup(int mixerGroup)
		{
			AudioSource.outputAudioMixerGroup = Core.Instance.AudioManager.mixerGroups[mixerGroup];
		}
	}
	[MoonSharpUserData]
	public class LuaBuiltInBehaviour : LuaBuiltInComponent
	{
		public Behaviour Behaviour;

		public bool IsActiveAndEnabled => Behaviour.isActiveAndEnabled;

		public bool Enabled
		{
			get
			{
				return Behaviour.enabled;
			}
			set
			{
				Behaviour.enabled = true;
			}
		}

		[MoonSharpHidden]
		public LuaBuiltInBehaviour(Behaviour behaviour, Script script)
			: base((Component)(object)behaviour, script)
		{
			Behaviour = behaviour;
		}
	}
	[MoonSharpUserData]
	public class LuaBuiltInComponent
	{
		public LuaGameObject GameObject;

		public Component Component;

		[MoonSharpHidden]
		public LuaBuiltInComponent(Component component, Script script)
		{
			Component = component;
			GameObject = new LuaGameObject(component.gameObject);
		}
	}
	public class LuaCast
	{
		public Type CSharpType { get; private set; }

		public Type LuaType { get; private set; }

		public Delegate CastMethod { get; private set; }

		public static LuaCast Create<TLua, TCSharp>(Func<TCSharp, TLua> castMethod) where TLua : class where TCSharp : class
		{
			return new LuaCast
			{
				CastMethod = castMethod,
				LuaType = castMethod.Method.ReturnType,
				CSharpType = castMethod.Method.GetParameters()[0].ParameterType
			};
		}
	}
	public static class LuaCastFactory
	{
		private static Dictionary<Type, LuaCast> CastFromCSharpType = new Dictionary<Type, LuaCast>();

		private static Dictionary<string, LuaCast> CastFromLuaTypeName = new Dictionary<string, LuaCast>();

		internal static void Initialize()
		{
			RegisterCasts(LuaCast.Create<LuaPlayer, Player>(LuaPlayer.CastMethod), LuaCast.Create<LuaScriptBehavior, ScriptBehavior>(LuaScriptBehavior.CastMethod), LuaCast.Create<LuaAnimator, Animator>(LuaAnimator.CastMethod), LuaCast.Create<LuaAudioSource, AudioSource>(LuaAudioSource.CastMethod), LuaCast.Create<LuaScriptStringValue, ScriptStringValue>(LuaScriptStringValue.CastMethod), LuaCast.Create<LuaScriptNumberValue, ScriptNumberValue>(LuaScriptNumberValue.CastMethod), LuaCast.Create<LuaScriptGameObjectValue, ScriptGameObjectValue>(LuaScriptGameObjectValue.CastMethod), LuaCast.Create<LuaScriptComponentValue, ScriptComponentValue>(LuaScriptComponentValue.CastMethod), LuaCast.Create<LuaPlayableDirector, PlayableDirector>(LuaPlayableDirector.CastMethod));
		}

		public static Type GetCSharpTypeFromLuaTypeName(string luaTypeName)
		{
			if (CastFromLuaTypeName.TryGetValue(luaTypeName, out var value))
			{
				return value.CSharpType;
			}
			return null;
		}

		public static T CastCSharpTypeToLuaType<T>(object CSharpObject) where T : class
		{
			if (CastFromCSharpType.TryGetValue(CSharpObject.GetType(), out var value))
			{
				return value.CastMethod.DynamicInvoke(CSharpObject) as T;
			}
			return null;
		}

		public static void RegisterCasts(params LuaCast[] casts)
		{
			foreach (LuaCast luaCast in casts)
			{
				CastFromCSharpType[luaCast.CSharpType] = luaCast;
				CastFromLuaTypeName[luaCast.LuaType.Name] = luaCast;
			}
		}
	}
	public static class LuaDatabase
	{
		public static List<LuaScript> AutoRunScripts;

		public static Dictionary<string, LuaScript> BehaviorScripts;

		private static ManualLogSource LogSource;

		private static bool CheckedMapStationInstalled;

		private static bool CachedMapStationInstalled;

		private static string PluginPath;

		private static bool MapStationInstalled
		{
			get
			{
				if (CheckedMapStationInstalled)
				{
					return CachedMapStationInstalled;
				}
				CachedMapStationInstalled = CheckMapStationInstalled();
				CheckedMapStationInstalled = true;
				return CachedMapStationInstalled;
			}
		}

		private static bool CheckMapStationInstalled()
		{
			return Chainloader.PluginInfos.ContainsKey("MapStation.Plugin");
		}

		internal static void Initialize(string pluginPath)
		{
			PluginPath = pluginPath;
			LogSource = Logger.CreateLogSource("Lua Database");
			InitializeScripts();
		}

		public static void Reload()
		{
			InitializeScripts();
		}

		private static void InitializeScripts()
		{
			AutoRunScripts = new List<LuaScript>();
			BehaviorScripts = new Dictionary<string, LuaScript>();
			LoadPluginScripts();
			if (MapStationInstalled)
			{
				LoadMapScripts();
			}
		}

		private static void LoadPluginScripts()
		{
			string[] files = Directory.GetFiles(PluginPath, "*.luamod", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				LogSource.LogInfo((object)("Loading Lua scripts in " + text));
				LoadPluginZip(text);
			}
		}

		private static void LoadMapScripts()
		{
			foreach (KeyValuePair<Stage, PluginMapDatabaseEntry> map in MapDatabase.Instance.maps)
			{
				ZipArchiveEntry entry = ZipFile.OpenRead(map.Value.zipPath).GetEntry("lua.luamod");
				if (entry != null)
				{
					Stream stream = entry.Open();
					ZipArchive zipArchive = new ZipArchive(stream);
					LoadPluginZip(zipArchive);
					zipArchive.Dispose();
					stream.Dispose();
				}
			}
		}

		public static void LoadPluginZip(ZipArchive archive)
		{
			foreach (ZipArchiveEntry entry in archive.Entries)
			{
				string text = entry.FullName.Replace("\\", "/");
				string text2 = entry.Name.Replace("\\", "/");
				if (!text2.EndsWith(".lua"))
				{
					continue;
				}
				string body = ReadStringZipEntry(entry);
				if (text.StartsWith("autorun/"))
				{
					LuaScript luaScript = LuaScript.FromString(text2, body, usePriority: true);
					if (luaScript != null)
					{
						AutoRunScripts.Add(luaScript);
					}
				}
				else if (text.StartsWith("behavior/"))
				{
					LuaScript luaScript2 = LuaScript.FromString(text2, body, usePriority: true);
					if (luaScript2 != null)
					{
						BehaviorScripts[luaScript2.Name] = luaScript2;
					}
				}
			}
		}

		public static void LoadPluginZip(string zipPath)
		{
			ZipArchive zipArchive = ZipFile.OpenRead(zipPath);
			LoadPluginZip(zipArchive);
			zipArchive.Dispose();
		}

		private static string ReadStringZipEntry(ZipArchiveEntry entry)
		{
			using Stream stream = entry.Open();
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}
	}
	[MoonSharpUserData]
	public class LuaEventHandler : ILuaReloadable
	{
		private Dictionary<string, DynValue> _callbackByGUID = new Dictionary<string, DynValue>();

		private Script _script;

		[MoonSharpHidden]
		public LuaEventHandler(Script script)
		{
			_script = script;
			LuaReloadableManager.Register(this);
		}

		[MoonSharpHidden]
		public void OnReload()
		{
			Clear();
		}

		public void Clear()
		{
			_callbackByGUID = new Dictionary<string, DynValue>();
		}

		public string Add(DynValue callback)
		{
			string text = Guid.NewGuid().ToString();
			_callbackByGUID[text] = callback;
			return text;
		}

		public void Remove(string callbackGUID)
		{
			if (callbackGUID != null && _callbackByGUID.TryGetValue(callbackGUID, out var _))
			{
				_callbackByGUID.Remove(callbackGUID);
			}
		}

		public void Invoke(params object[] args)
		{
			foreach (KeyValuePair<string, DynValue> item in _callbackByGUID)
			{
				if (item.Value != null && !item.Value.IsNilOrNan())
				{
					LuaManager.Instance.Call(item.Value, args);
				}
			}
		}
	}
	[MoonSharpUserData]
	public class LuaGameObject
	{
		[MoonSharpHidden]
		public GameObject Handle;

		public LuaGameObject Parent
		{
			get
			{
				return new LuaGameObject(((Component)Handle.transform.parent).gameObject);
			}
			set
			{
				Handle.transform.SetParent(value.Handle.transform, true);
			}
		}

		public Table Velocity
		{
			get
			{
				//IL_0026: 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)
				Rigidbody component = Handle.gameObject.GetComponent<Rigidbody>();
				if ((Object)(object)component == (Object)null)
				{
					return LuaMathUtils.Vector3ToTable(Vector3.zero);
				}
				return LuaMathUtils.Vector3ToTable(component.velocity);
			}
			set
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				Rigidbody component = Handle.gameObject.GetComponent<Rigidbody>();
				if (!((Object)(object)component == (Object)null))
				{
					component.velocity = LuaMathUtils.TableToVector3(value);
				}
			}
		}

		public bool ActiveInHierarchy => Handle.gameObject.activeInHierarchy;

		public bool Active
		{
			get
			{
				return Handle.gameObject.activeSelf;
			}
			set
			{
				Handle.gameObject.SetActive(value);
			}
		}

		public int InstanceID => ((Object)Handle.gameObject).GetInstanceID();

		public string Name
		{
			get
			{
				return ((Object)Handle.gameObject).name;
			}
			set
			{
				((Object)Handle.gameObject).name = value;
			}
		}

		[MoonSharpHidden]
		public LuaGameObject(GameObject handle)
		{
			Handle = handle;
		}

		public LuaGameObject Find(string name)
		{
			Transform val = Handle.gameObject.transform.Find(name);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return new LuaGameObject(((Component)val).gameObject);
		}

		public LuaGameObject FindRecursive(string name)
		{
			Transform val = TransformExtentions.FindRecursive(Handle.gameObject.transform, name);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return new LuaGameObject(((Component)val).gameObject);
		}

		public Table GetLocalPosition()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LuaMathUtils.Vector3ToTable(Handle.transform.localPosition);
		}

		public void SetLocalPosition(Table position)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Handle.transform.localPosition = LuaMathUtils.TableToVector3(position);
		}

		public Table GetPosition()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LuaMathUtils.Vector3ToTable(Handle.transform.position);
		}

		public void SetPosition(Table position)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Handle.transform.position = LuaMathUtils.TableToVector3(position);
		}

		public void AddPosition(Table offset)
		{
			//IL_000c: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = Handle.transform;
			transform.position += LuaMathUtils.TableToVector3(offset);
		}

		public Table GetLocalEulerAngles()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LuaMathUtils.Vector3ToTable(Handle.transform.localEulerAngles);
		}

		public void SetLocalEulerAngles(Table eulerAngles)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Handle.transform.localRotation = Quaternion.Euler(LuaMathUtils.TableToVector3(eulerAngles));
		}

		public Table GetEulerAngles()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LuaMathUtils.Vector3ToTable(Handle.transform.eulerAngles);
		}

		public void SetEulerAngles(Table eulerAngles)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Handle.transform.rotation = Quaternion.Euler(LuaMathUtils.TableToVector3(eulerAngles));
		}

		public void Rotate(Table axis, float angle)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Handle.transform.Rotate(LuaMathUtils.TableToVector3(axis), angle);
		}

		public Table GetForward()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LuaMathUtils.Vector3ToTable(Handle.transform.forward);
		}

		public Table GetRight()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LuaMathUtils.Vector3ToTable(Handle.transform.right);
		}

		public Table GetUp()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return LuaMathUtils.Vector3ToTable(Handle.transform.up);
		}

		public LuaGameObject Instantiate()
		{
			GameObject obj = Object.Instantiate<GameObject>(Handle.gameObject);
			LuaUtility.OnInstantiate(obj);
			return new LuaGameObject(obj);
		}

		public void Destroy()
		{
			Object.Destroy((Object)(object)Handle.gameObject);
		}

		public LuaScriptBehavior AddScriptBehavior(string scriptFilename)
		{
			ScriptBehavior scriptBehavior = Handle.gameObject.AddComponent<ScriptBehavior>();
			scriptBehavior.LuaScriptName = scriptFilename;
			scriptBehavior.Initialize();
			return new LuaScriptBehavior(scriptBehavior, LuaManager.Instance.GlobalScript);
		}

		public LuaBuiltInComponent GetLuaComponent(string luaComponentName)
		{
			Type cSharpTypeFromLuaTypeName = LuaCastFactory.GetCSharpTypeFromLuaTypeName(luaComponentName);
			if (cSharpTypeFromLuaTypeName == null)
			{
				return null;
			}
			Component component = Handle.gameObject.GetComponent(cSharpTypeFromLuaTypeName);
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			return LuaCastFactory.CastCSharpTypeToLuaType<LuaBuiltInComponent>(component);
		}

		public LuaScriptBehavior GetScriptBehavior(string scriptFilename)
		{
			ScriptBehavior[] components = Handle.GetComponents<ScriptBehavior>();
			foreach (ScriptBehavior scriptBehavior in components)
			{
				if (scriptBehavior.LuaScriptName == scriptFilename)
				{
					return new LuaScriptBehavior(scriptBehavior, LuaManager.Instance.GlobalScript);
				}
			}
			return null;
		}

		public static LuaGameObject New(string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			return new LuaGameObject(new GameObject(name));
		}

		public LuaScriptStringValue GetStringValue(string name)
		{
			return new LuaScriptStringValue((from comp in Handle.GetComponents<ScriptStringValue>()
				where comp.Name == name
				select comp).FirstOrDefault(), LuaManager.Instance.GlobalScript);
		}

		public LuaScriptNumberValue GetNumberValue(string name)
		{
			return new LuaScriptNumberValue((from comp in Handle.GetComponents<ScriptNumberValue>()
				where comp.Name == name
				select comp).FirstOrDefault(), LuaManager.Instance.GlobalScript);
		}

		public LuaScriptGameObjectValue GetGameObjectValue(string name)
		{
			return new LuaScriptGameObjectValue((from comp in Handle.GetComponents<ScriptGameObjectValue>()
				where comp.Name == name
				select comp).FirstOrDefault(), LuaManager.Instance.GlobalScript);
		}

		public LuaScriptComponentValue GetComponentValue(string name)
		{
			return new LuaScriptComponentValue((from comp in Handle.GetComponents<ScriptComponentValue>()
				where comp.Name == name
				select comp).FirstOrDefault(), LuaManager.Instance.GlobalScript);
		}

		public void SetStringValue(string name, string value)
		{
			ScriptStringValue scriptStringValue = GetStringValue(name).ScriptStringValue;
			if ((Object)(object)scriptStringValue == (Object)null)
			{
				scriptStringValue = Handle.AddComponent<ScriptStringValue>();
			}
			scriptStringValue.Value = value;
		}

		public void SetNumberValue(string name, double value)
		{
			ScriptNumberValue scriptNumberValue = GetNumberValue(name).ScriptNumberValue;
			if ((Object)(object)scriptNumberValue == (Object)null)
			{
				scriptNumberValue = Handle.AddComponent<ScriptNumberValue>();
			}
			scriptNumberValue.Value = value;
		}

		public void SetGameObjectValue(string name, LuaGameObject value)
		{
			ScriptGameObjectValue scriptGameObjectValue = GetGameObjectValue(name).ScriptGameObjectValue;
			if ((Object)(object)scriptGameObjectValue == (Object)null)
			{
				scriptGameObjectValue = Handle.AddComponent<ScriptGameObjectValue>();
			}
			scriptGameObjectValue.Value = value.Handle;
		}

		public void SetComponentValue(string name, LuaBuiltInComponent value)
		{
			ScriptComponentValue scriptComponentValue = GetComponentValue(name).ScriptComponentValue;
			if ((Object)(object)scriptComponentValue == (Object)null)
			{
				scriptComponentValue = Handle.AddComponent<ScriptComponentValue>();
			}
			scriptComponentValue.Value = value.Component;
		}
	}
	public class LuaManager : MonoBehaviour
	{
		public Script GlobalScript;

		private ManualLogSource _logSource;

		private ManualLogSource _scriptLogSource;

		public static LuaManager Instance { get; private set; }

		internal static void Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			GameObject val = new GameObject("Lua Manager");
			LuaManager instance = val.AddComponent<LuaManager>();
			Object.DontDestroyOnLoad((Object)val);
			Instance = instance;
		}

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			_logSource = Logger.CreateLogSource("Lua Manager");
			_scriptLogSource = Logger.CreateLogSource("Global Lua");
			GlobalScript = new Script();
			GlobalScript.Options.DebugPrint = delegate(string message)
			{
				_scriptLogSource.LogInfo((object)message);
			};
			RegisterModules();
			RunScripts();
		}

		private void RunScripts()
		{
			LuaDatabase.AutoRunScripts = LuaDatabase.AutoRunScripts.OrderBy((LuaScript script) => script.Priority).ToList();
			foreach (LuaScript autoRunScript in LuaDatabase.AutoRunScripts)
			{
				_logSource.LogInfo((object)$"Running Autorun Script {autoRunScript.Name} with priority {autoRunScript.Priority}");
				autoRunScript.Run(GlobalScript);
			}
		}

		public DynValue Call(DynValue function, params object[] args)
		{
			//IL_0011: Expected O, but got Unknown
			try
			{
				return GlobalScript.Call(function, args);
			}
			catch (InterpreterException val)
			{
				InterpreterException val2 = val;
				Debug.LogError((object)("Error executing lua function!" + Environment.NewLine + val2.DecoratedMessage));
			}
			return null;
		}

		public void Reload()
		{
			LuaReloadableManager.OnReload();
			LuaDatabase.Reload();
			RunScripts();
		}

		private void RegisterModules()
		{
			UserData.RegisterType<LuaAnimator>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaAudioSource>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaBuiltInBehaviour>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaBuiltInComponent>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaEventHandler>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaGameObject>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaPlayableDirector>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaPlayer>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaScriptBehavior>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaScriptComponentValue>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaScriptGameObjectValue>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaScriptNumberValue>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaScriptStringValue>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaScriptValue>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaAlarmManager>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaCore>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaSequenceHandler>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaStageManager>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaUI>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaUnityEngine>((InteropAccessMode)7, (string)null);
			UserData.RegisterType<LuaWorldHandler>((InteropAccessMode)7, (string)null);
			_logSource.LogInfo((object)"Registering Lua modules");
			LuaStageManager module = new LuaStageManager();
			RegisterModule(module);
			LuaCore module2 = new LuaCore();
			RegisterModule(module2);
			LuaUnityEngine module3 = new LuaUnityEngine();
			RegisterModule(module3);
			LuaWorldHandler module4 = new LuaWorldHandler();
			RegisterModule(module4);
			LuaUI module5 = new LuaUI();
			RegisterModule(module5);
			LuaAlarmManager module6 = new LuaAlarmManager();
			RegisterModule(module6);
			LuaSequenceHandler module7 = new LuaSequenceHandler();
			RegisterModule(module7);
		}

		private void RegisterModule(ILuaModule module)
		{
			module.OnRegister(GlobalScript);
		}
	}
	public static class LuaMathUtils
	{
		public static Vector3 TableToVector3(Table table)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)table.Get("x").CastToNumber().Value, (float)table.Get("y").CastToNumber().Value, (float)table.Get("z").CastToNumber().Value);
		}

		public static Table Vector3ToTable(Vector3 vector)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			Script globalScript = LuaManager.Instance.GlobalScript;
			object obj = globalScript.Globals[(object)"Vector3"];
			Table val = (Table)((obj is Table) ? obj : null);
			return globalScript.Call(val.Get("New"), new object[3] { vector.x, vector.y, vector.z }).Table;
		}
	}
	[MoonSharpUserData]
	public class LuaPlayableDirector : LuaBuiltInBehaviour
	{
		public PlayableDirector PlayableDirector;

		public double Time => PlayableDirector.time;

		public double Duration => PlayableDirector.duration;

		[MoonSharpHidden]
		public LuaPlayableDirector(PlayableDirector playableDirector, Script script)
			: base((Behaviour)(object)playableDirector, script)
		{
			PlayableDirector = playableDirector;
		}

		internal static LuaPlayableDirector CastMethod(PlayableDirector playableDirector)
		{
			return new LuaPlayableDirector(playableDirector, LuaManager.Instance.GlobalScript);
		}

		public void SkipTo(double time, bool keepGameplayCamera = true)
		{
			PlayableDirector.time = time;
			PlayableDirector.Evaluate();
			if (keepGameplayCamera && (Object)(object)WorldHandler.instance.CurrentCamera != (Object)(object)WorldHandler.instance.GetCurrentPlayer().cam.cam)
			{
				((Component)WorldHandler.instance.CurrentCamera).gameObject.SetActive(false);
			}
		}

		public void Play()
		{
			PlayableDirector.Play();
		}

		public void Pause()
		{
			PlayableDirector.Pause();
		}

		public void Stop()
		{
			PlayableDirector.Stop();
		}
	}
	[MoonSharpUserData]
	public class LuaPlayer : LuaBuiltInBehaviour
	{
		public Player Player;

		public bool AllowClimb
		{
			get
			{
				return PlayerLuaEngineComponent.Get(Player).AllowClimb;
			}
			set
			{
				PlayerLuaEngineComponent.Get(Player).AllowClimb = value;
			}
		}

		public bool UserInputEnabled
		{
			get
			{
				return Player.userInputEnabled;
			}
			set
			{
				Player.userInputEnabled = value;
			}
		}

		public LuaEventHandler OnLandCombo => PlayerLuaEngineComponent.Get(Player)?.OnLandCombo;

		public LuaEventHandler OnDropCombo => PlayerLuaEngineComponent.Get(Player)?.OnDropCombo;

		public bool IsComboing => Player.IsComboing();

		public float ScoreMultiplier
		{
			get
			{
				return Player.scoreMultiplier;
			}
			set
			{
				Player.scoreMultiplier = value;
			}
		}

		public float BaseScore
		{
			get
			{
				return Player.baseScore;
			}
			set
			{
				Player.baseScore = value;
			}
		}

		public bool Grounded => Player.IsGrounded();

		public int MoveStyleEquipped => (int)Player.moveStyleEquipped;

		public int MoveStyle => (int)Player.moveStyle;

		public float NormalizedHP => Player.GetNormalizedHP();

		public float MaxHP
		{
			get
			{
				return Player.maxHP;
			}
			set
			{
				Player.maxHP = value;
			}
		}

		public float HP
		{
			get
			{
				return Player.HP;
			}
			set
			{
				Player.HP = value;
			}
		}

		public string AbilityName
		{
			get
			{
				if (Player.ability == null)
				{
					return null;
				}
				return ((object)Player.ability).GetType().Name;
			}
		}

		public bool IsTooBusyForSuddenCutscenes => Player.IsTooBusyForSuddenCutscenes();

		public bool IsBusyWithSequence => Player.IsBusyWithSequence();

		public bool IsDead => Player.IsDead();

		public bool IsAI
		{
			get
			{
				return Player.isAI;
			}
			set
			{
				Player.isAI = value;
			}
		}

		public float BoostCharge
		{
			get
			{
				return Player.boostCharge;
			}
			set
			{
				Player.boostCharge = value;
			}
		}

		public float MaxBoostCharge
		{
			get
			{
				return Player.maxBoostCharge;
			}
			set
			{
				Player.maxBoostCharge = value;
			}
		}

		public Table Velocity
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return LuaMathUtils.Vector3ToTable(Player.motor.velocity);
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				Player.motor.velocity = LuaMathUtils.TableToVector3(value);
			}
		}

		[MoonSharpHidden]
		public LuaPlayer(Player player, Script script)
			: base((Behaviour)(object)player, script)
		{
			Player = player;
		}

		internal static LuaPlayer CastMethod(Player player)
		{
			return new LuaPlayer(player, LuaManager.Instance.GlobalScript);
		}

		public void ForceUnground(bool resetVisual)
		{
			Player.ForceUnground(resetVisual);
		}

		public void AddBoostCharge(float amount)
		{
			Player.AddBoostCharge(amount);
		}

		public void SetRotation(Table forward)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Player.SetRotation(LuaMathUtils.TableToVector3(forward));
		}

		public void SetRotationHard(Table forward)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Player.SetRotHard(LuaMathUtils.TableToVector3(forward));
		}

		public void GetHit(int damage, Table damageDirection, string knockbackType)
		{
			//IL_0001: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_005b: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			KnockbackType val = (KnockbackType)5;
			switch (knockbackType)
			{
			case "Stationary":
				val = (KnockbackType)0;
				break;
			case "Far":
				val = (KnockbackType)1;
				break;
			case "Big":
				val = (KnockbackType)2;
				break;
			case "ShieldBash":
				val = (KnockbackType)3;
				break;
			case "Fall":
				val = (KnockbackType)4;
				break;
			case "None":
				val = (KnockbackType)5;
				break;
			}
			Player.GetHit(damage, LuaMathUtils.TableToVector3(damageDirection), val);
		}

		public void ChangeHP(int damage)
		{
			Player.ChangeHP(damage);
		}

		public void SetCurrentMoveStyleEquipped(int moveStyle)
		{
			Player.SetCurrentMoveStyleEquipped((MoveStyle)moveStyle, true, true);
		}

		public void SwitchToEquippedMovestyle(bool set, bool doAirTrick, bool showEffect)
		{
			Player.SwitchToEquippedMovestyle(set, doAirTrick, true, showEffect);
		}

		public void LandCombo()
		{
			Player.LandCombo();
		}

		public void DropCombo()
		{
			Player.DropCombo();
		}

		public void AddScoreMultiplier()
		{
			Player.AddScoreMultiplier();
		}

		public void DoTrick(string trickName, int score)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Player.currentTrickPoints = score;
			Player.currentTrickType = (TrickType)13;
			Player.currentTrickName = trickName;
			Player.currentTrickOnFoot = !Player.usingEquippedMovestyle;
			Player player = Player;
			player.baseScore += (float)(int)((float)Player.currentTrickPoints * Player.scoreFactor);
			if (Player.scoreMultiplier == 0f)
			{
				Player.scoreMultiplier = 1f;
			}
			if (Player.tricksInCombo == 0 && (Object)(object)Player.ui != (Object)null)
			{
				Player.ui.SetTrickingChargeBarActive(true);
			}
			Player player2 = Player;
			player2.tricksInCombo++;
			if (Player.tricksInCombo >= 5)
			{
				float num = Player.gainBoostChargeCurve.Evaluate(Mathf.Min((float)Player.tricksInCombo, 50f) / 50f);
				Player.showAddCharge = num;
				Player.AddBoostCharge(num);
			}
			Player.moveInScoreTimer = 1f;
		}

		public void PlayVoice(int audioClipID, int voicePriority, bool fromPlayer = true)
		{
			Player.PlayVoice((AudioClipID)audioClipID, (VoicePriority)voicePriority, fromPlayer);
		}

		public void RegainAirMobility()
		{
			Player.RegainAirMobility();
		}
	}
	public static class LuaReloadableManager
	{
		private static List<WeakReference> Reloadables = new List<WeakReference>();

		public static void Register(ILuaReloadable reloadable)
		{
			Purge();
			Reloadables.Add(new WeakReference(reloadable));
		}

		internal static void Purge()
		{
			Reloadables = Reloadables.Where((WeakReference reloadable) => reloadable.IsAlive).ToList();
		}

		internal static void OnReload()
		{
			Purge();
			foreach (WeakReference reloadable in Reloadables)
			{
				((ILuaReloadable)reloadable.Target).OnReload();
			}
		}
	}
	public class LuaScript
	{
		private const string InternalVariablePrefix = "_LUAENGINE_INTERNAL_";

		private const string PriorityPrefix = "--PRIORITY:";

		public string Name = "";

		public string Body = "";

		public int Priority;

		public static LuaScript FromString(string name, string body, bool usePriority = false)
		{
			LuaScript luaScript = new LuaScript();
			luaScript.Body = body;
			luaScript.Name = name;
			if (usePriority)
			{
				using StringReader stringReader = new StringReader(luaScript.Body);
				string text;
				while ((text = stringReader.ReadLine()) != null)
				{
					if (text.StartsWith("--PRIORITY:") && int.TryParse(text.Substring("--PRIORITY:".Length), out var result))
					{
						luaScript.Priority = result;
						break;
					}
				}
			}
			return luaScript;
		}

		private DynValue DoString(Script script, string body, string name)
		{
			//IL_000d: Expected O, but got Unknown
			try
			{
				return script.DoString(body, (Table)null, name);
			}
			catch (InterpreterException val)
			{
				InterpreterException val2 = val;
				Debug.LogError((object)("Error executing lua script " + name + "!" + Environment.NewLine + val2.DecoratedMessage));
			}
			return null;
		}

		public void Run(Script script)
		{
			DoString(script, Body, Name);
		}

		public void RunForScriptBehavior(Script script, LuaScriptBehavior scriptBehavior)
		{
			string body = AddLocalContext(script, Body, "script", scriptBehavior);
			DoString(script, body, Name);
			RemoveLocalContext(script, "script");
		}

		private string AddLocalContext(Script script, string body, string variableName, object variableValue)
		{
			script.Globals[(object)("_LUAENGINE_INTERNAL_" + variableName)] = variableValue;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("local " + variableName + " = _LUAENGINE_INTERNAL_" + variableName);
			stringBuilder.AppendLine("_LUAENGINE_INTERNAL_" + variableName + " = nil");
			stringBuilder.AppendLine(body);
			return stringBuilder.ToString();
		}

		private void RemoveLocalContext(Script script, string variableName)
		{
			script.Globals[(object)("_LUAENGINE_INTERNAL_" + variableName)] = DynValue.Nil;
		}
	}
	[MoonSharpUserData]
	public class LuaScriptBehavior : LuaBuiltInBehaviour
	{
		public ScriptBehavior ScriptBehavior;

		public string ScriptName => ScriptBehavior.LuaScriptName;

		public LuaEventHandler OnStart => ScriptBehavior.OnStart;

		public LuaEventHandler OnDestroy => ScriptBehavior.OnDestroyed;

		public LuaEventHandler OnCollisionEnter => ScriptBehavior.OnAnyCollisionEnter;

		public LuaEventHandler OnCollisionStay => ScriptBehavior.OnAnyCollisionStay;

		public LuaEventHandler OnCollisionExit => ScriptBehavior.OnAnyCollisionExit;

		public LuaEventHandler OnPlayerCollisionEnter => ScriptBehavior.OnPlayerCollisionEnter;

		public LuaEventHandler OnPlayerCollisionStay => ScriptBehavior.OnPlayerCollisionStay;

		public LuaEventHandler OnPlayerCollisionExit => ScriptBehavior.OnPlayerCollisionExit;

		public LuaEventHandler OnTriggerEnter => ScriptBehavior.OnAnyTriggerEnter;

		public LuaEventHandler OnTriggerStay => ScriptBehavior.OnAnyTriggerStay;

		public LuaEventHandler OnTriggerExit => ScriptBehavior.OnAnyTriggerExit;

		public LuaEventHandler OnPlayerTriggerEnter => ScriptBehavior.OnPlayerTriggerEnter;

		public LuaEventHandler OnPlayerTriggerStay => ScriptBehavior.OnPlayerTriggerStay;

		public LuaEventHandler OnPlayerTriggerExit => ScriptBehavior.OnPlayerTriggerExit;

		[MoonSharpHidden]
		public LuaScriptBehavior(ScriptBehavior scriptBehavior, Script script)
			: base((Behaviour)(object)scriptBehavior, script)
		{
			ScriptBehavior = scriptBehavior;
		}

		internal static LuaScriptBehavior CastMethod(ScriptBehavior scriptBehavior)
		{
			return new LuaScriptBehavior(scriptBehavior, LuaManager.Instance.GlobalScript);
		}
	}
	[MoonSharpUserData]
	public class LuaScriptComponentValue : LuaScriptValue
	{
		public ScriptComponentValue ScriptComponentValue;

		public LuaBuiltInComponent Value
		{
			get
			{
				return LuaCastFactory.CastCSharpTypeToLuaType<LuaBuiltInComponent>(ScriptComponentValue.Value);
			}
			set
			{
				ScriptComponentValue.Value = value.Component;
			}
		}

		[MoonSharpHidden]
		public LuaScriptComponentValue(ScriptComponentValue value, Script script)
			: base(value, script)
		{
			ScriptComponentValue = value;
		}

		internal static LuaScriptComponentValue CastMethod(ScriptComponentValue componentValue)
		{
			return new LuaScriptComponentValue(componentValue, LuaManager.Instance.GlobalScript);
		}
	}
	[MoonSharpUserData]
	public class LuaScriptGameObjectValue : LuaScriptValue
	{
		public ScriptGameObjectValue ScriptGameObjectValue;

		public LuaGameObject Value
		{
			get
			{
				return new LuaGameObject(ScriptGameObjectValue.Value);
			}
			set
			{
				ScriptGameObjectValue.Value = value.Handle;
			}
		}

		[MoonSharpHidden]
		public LuaScriptGameObjectValue(ScriptGameObjectValue value, Script script)
			: base(value, script)
		{
			ScriptGameObjectValue = value;
		}

		internal static LuaScriptGameObjectValue CastMethod(ScriptGameObjectValue gameObjectValue)
		{
			return new LuaScriptGameObjectValue(gameObjectValue, LuaManager.Instance.GlobalScript);
		}
	}
	[MoonSharpUserData]
	public class LuaScriptNumberValue : LuaScriptValue
	{
		public ScriptNumberValue ScriptNumberValue;

		public double Value
		{
			get
			{
				return ScriptNumberValue.Value;
			}
			set
			{
				ScriptNumberValue.Value = value;
			}
		}

		[MoonSharpHidden]
		public LuaScriptNumberValue(ScriptNumberValue value, Script script)
			: base(value, script)
		{
			ScriptNumberValue = value;
		}

		internal static LuaScriptNumberValue CastMethod(ScriptNumberValue numberValue)
		{
			return new LuaScriptNumberValue(numberValue, LuaManager.Instance.GlobalScript);
		}
	}
	[MoonSharpUserData]
	public class LuaScriptStringValue : LuaScriptValue
	{
		public ScriptStringValue ScriptStringValue;

		public string Value
		{
			get
			{
				return ScriptStringValue.Value;
			}
			set
			{
				ScriptStringValue.Value = value;
			}
		}

		[MoonSharpHidden]
		public LuaScriptStringValue(ScriptStringValue value, Script script)
			: base(value, script)
		{
			ScriptStringValue = value;
		}

		internal static LuaScriptStringValue CastMethod(ScriptStringValue stringValue)
		{
			return new LuaScriptStringValue(stringValue, LuaManager.Instance.GlobalScript);
		}
	}
	[MoonSharpUserData]
	public class LuaScriptValue : LuaBuiltInBehaviour
	{
		public ScriptValue ScriptValue;

		public string Name
		{
			get
			{
				return ScriptValue.Name;
			}
			set
			{
				ScriptValue.Name = value;
			}
		}

		[MoonSharpHidden]
		public LuaScriptValue(ScriptValue value, Script script)
			: base((Behaviour)(object)value, script)
		{
			ScriptValue = value;
		}
	}
	public static class LuaUtility
	{
		public static void OnInstantiate(GameObject gameObject)
		{
			ScriptBehavior[] componentsInChildren = gameObject.GetComponentsInChildren<ScriptBehavior>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].Restart();
			}
		}
	}
	public class PlayerLuaEngineComponent : MonoBehaviour
	{
		public bool AllowClimb = true;

		public LuaEventHandler OnLandCombo;

		public LuaEventHandler OnDropCombo;

		public Player Player;

		private void Awake()
		{
			OnLandCombo = new LuaEventHandler(LuaManager.Instance.GlobalScript);
			OnDropCombo = new LuaEventHandler(LuaManager.Instance.GlobalScript);
		}

		public static PlayerLuaEngineComponent Get(Player player)
		{
			return ((Component)player).gameObject.GetComponent<PlayerLuaEngineComponent>();
		}

		private void OnCollisionEnter(Collision collision)
		{
			ScriptBehavior[] componentsInParent = collision.gameObject.GetComponentsInParent<ScriptBehavior>();
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				componentsInParent[i].OnPlayerCollisionEnter?.Invoke(new LuaPlayer(Player, LuaManager.Instance.GlobalScript));
			}
		}

		private void OnCollisionStay(Collision collision)
		{
			ScriptBehavior[] componentsInParent = collision.gameObject.GetComponentsInParent<ScriptBehavior>();
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				componentsInParent[i].OnPlayerCollisionStay?.Invoke(new LuaPlayer(Player, LuaManager.Instance.GlobalScript));
			}
		}

		private void OnCollisionExit(Collision collision)
		{
			ScriptBehavior[] componentsInParent = collision.gameObject.GetComponentsInParent<ScriptBehavior>();
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				componentsInParent[i].OnPlayerCollisionExit?.Invoke(new LuaPlayer(Player, LuaManager.Instance.GlobalScript));
			}
		}

		private void OnTriggerEnter(Collider other)
		{
			ScriptBehavior[] componentsInParent = ((Component)other).GetComponentsInParent<ScriptBehavior>();
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				componentsInParent[i].OnPlayerTriggerEnter?.Invoke(new LuaPlayer(Player, LuaManager.Instance.GlobalScript));
			}
		}

		private void OnTriggerStay(Collider other)
		{
			ScriptBehavior[] componentsInParent = ((Component)other).GetComponentsInParent<ScriptBehavior>();
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				componentsInParent[i].OnPlayerTriggerStay?.Invoke(new LuaPlayer(Player, LuaManager.Instance.GlobalScript));
			}
		}

		private void OnTriggerExit(Collider other)
		{
			ScriptBehavior[] componentsInParent = ((Component)other).GetComponentsInParent<ScriptBehavior>();
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				componentsInParent[i].OnPlayerTriggerExit?.Invoke(new LuaPlayer(Player, LuaManager.Instance.GlobalScript));
			}
		}
	}
	[BepInPlugin("LuaEngine", "LuaEngine", "0.4.0")]
	public class Plugin : BaseUnityPlugin
	{
		private void Start()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				new Harmony("LuaEngine").PatchAll();
				LuaCastFactory.Initialize();
				LuaDatabase.Initialize(Paths.PluginPath);
				LuaManager.Create();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin LuaEngine 0.4.0 is loaded!");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)string.Format("Plugin {0} {1} failed to load!{2}{3}", "LuaEngine", "0.4.0", Environment.NewLine, ex));
			}
		}
	}
	public class SequenceEvent : GameplayEvent
	{
		public PlayableDirector Director;

		public LuaEventHandler OnSequenceEnd;

		public override void Awake()
		{
			((AProgressable)this).Awake();
			OnSequenceEnd = new LuaEventHandler(LuaManager.Instance.GlobalScript);
		}

		public override void LetPlayerGo()
		{
			((GameplayEvent)this).LetPlayerGo();
			Director.time = Director.duration;
			Director.Evaluate();
			if ((Object)(object)WorldHandler.instance.CurrentCamera != (Object)(object)WorldHandler.instance.GetCurrentPlayer().cam.cam)
			{
				((Component)WorldHandler.instance.CurrentCamera).gameObject.SetActive(false);
			}
			OnSequenceEnd?.Invoke();
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LuaEngine";

		public const string PLUGIN_NAME = "LuaEngine";

		public const string PLUGIN_VERSION = "0.4.0";
	}
}
namespace LuaEngine.Patches
{
	[HarmonyPatch(typeof(LedgeClimbAbility))]
	internal static class LedgeClimbAbilityPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("CheckActivation")]
		private static bool CheckActivation_Prefix(ref bool __result, LedgeClimbAbility __instance)
		{
			PlayerLuaEngineComponent playerLuaEngineComponent = PlayerLuaEngineComponent.Get(((Ability)__instance).p);
			if ((Object)(object)playerLuaEngineComponent == (Object)null)
			{
				return true;
			}
			if (playerLuaEngineComponent.AllowClimb)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Player))]
	internal static class PlayerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Init")]
		private static void Init_Postfix(Player __instance)
		{
			if (!((Object)(object)((Component)__instance).gameObject.GetComponent<PlayerLuaEngineComponent>() != (Object)null))
			{
				((Component)__instance).gameObject.AddComponent<PlayerLuaEngineComponent>().Player = __instance;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("LandCombo")]
		private static void LandCombo_Prefix(Player __instance)
		{
			if (__instance.IsComboing())
			{
				PlayerLuaEngineComponent playerLuaEngineComponent = PlayerLuaEngineComponent.Get(__instance);
				if (!((Object)(object)playerLuaEngineComponent == (Object)null))
				{
					playerLuaEngineComponent.OnLandCombo?.Invoke();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("DropCombo")]
		private static void DropCombo_Prefix(Player __instance)
		{
			if (__instance.IsComboing())
			{
				PlayerLuaEngineComponent playerLuaEngineComponent = PlayerLuaEngineComponent.Get(__instance);
				if (!((Object)(object)playerLuaEngineComponent == (Object)null))
				{
					playerLuaEngineComponent.OnDropCombo?.Invoke();
				}
			}
		}
	}
}
namespace LuaEngine.Mono
{
	public class ScriptBehavior : MonoBehaviour
	{
		public LuaEventHandler OnStart;

		public LuaEventHandler OnDestroyed;

		public LuaEventHandler OnAnyCollisionEnter;

		public LuaEventHandler OnAnyCollisionStay;

		public LuaEventHandler OnAnyCollisionExit;

		public LuaEventHandler OnPlayerCollisionEnter;

		public LuaEventHandler OnPlayerCollisionStay;

		public LuaEventHandler OnPlayerCollisionExit;

		public LuaEventHandler OnAnyTriggerEnter;

		public LuaEventHandler OnAnyTriggerStay;

		public LuaEventHandler OnAnyTriggerExit;

		public LuaEventHandler OnPlayerTriggerEnter;

		public LuaEventHandler OnPlayerTriggerStay;

		public LuaEventHandler OnPlayerTriggerExit;

		public string LuaScriptName;

		private bool _initialized;

		private void OnCollisionEnter(Collision collision)
		{
			OnAnyCollisionEnter?.Invoke(new LuaGameObject(collision.gameObject));
		}

		private void OnCollisionStay(Collision collision)
		{
			OnAnyCollisionStay?.Invoke(new LuaGameObject(collision.gameObject));
		}

		private void OnCollisionExit(Collision collision)
		{
			OnAnyCollisionExit?.Invoke(new LuaGameObject(collision.gameObject));
		}

		private void OnTriggerEnter(Collider other)
		{
			OnAnyTriggerEnter?.Invoke(new LuaGameObject(((Component)other).gameObject));
		}

		private void OnTriggerStay(Collider other)
		{
			OnAnyTriggerStay?.Invoke(new LuaGameObject(((Component)other).gameObject));
		}

		private void OnTriggerExit(Collider other)
		{
			OnAnyTriggerExit?.Invoke(new LuaGameObject(((Component)other).gameObject));
		}

		private void Awake()
		{
			Initialize();
		}

		private void OnEnable()
		{
			Initialize();
		}

		public void Initialize()
		{
			if (LuaScriptName != null && ((Component)this).gameObject.activeInHierarchy && !_initialized)
			{
				_initialized = true;
				Script globalScript = LuaManager.Instance.GlobalScript;
				LuaScript luaScript = LuaDatabase.BehaviorScripts[LuaScriptName];
				OnStart = new LuaEventHandler(globalScript);
				OnDestroyed = new LuaEventHandler(globalScript);
				OnAnyCollisionEnter = new LuaEventHandler(globalScript);
				OnAnyCollisionStay = new LuaEventHandler(globalScript);
				OnAnyCollisionExit = new LuaEventHandler(globalScript);
				OnPlayerCollisionEnter = new LuaEventHandler(globalScript);
				OnPlayerCollisionStay = new LuaEventHandler(globalScript);
				OnPlayerCollisionExit = new LuaEventHandler(globalScript);
				OnAnyTriggerEnter = new LuaEventHandler(globalScript);
				OnAnyTriggerStay = new LuaEventHandler(globalScript);
				OnAnyTriggerExit = new LuaEventHandler(globalScript);
				OnPlayerTriggerEnter = new LuaEventHandler(globalScript);
				OnPlayerTriggerStay = new LuaEventHandler(globalScript);
				OnPlayerTriggerExit = new LuaEventHandler(globalScript);
				luaScript.RunForScriptBehavior(globalScript, new LuaScriptBehavior(this, globalScript));
			}
		}

		public void Restart()
		{
			_initialized = false;
			Initialize();
		}

		private void OnDestroy()
		{
			OnDestroyed?.Invoke();
		}

		private void Start()
		{
			OnStart?.Invoke();
		}
	}
	public class ScriptComponentValue : ScriptValue
	{
		public Component Value;
	}
	public class ScriptGameObjectValue : ScriptValue
	{
		public GameObject Value;
	}
	public class ScriptNumberValue : ScriptValue
	{
		public double Value;
	}
	public class ScriptStringValue : ScriptValue
	{
		public string Value = "";
	}
	public abstract class ScriptValue : MonoBehaviour
	{
		public string Name = "";
	}
}
namespace LuaEngine.Modules
{
	public class LuaAlarmManager : ILuaModule
	{
		[MoonSharpUserData]
		public class LuaBindings
		{
			public string CreateAlarm(LuaGameObject gameObject, float seconds, bool runPaused, DynValue callback)
			{
				Alarm alarm = new Alarm();
				alarm.TimeLeft = seconds;
				alarm.RunPaused = runPaused;
				alarm.Callback.Add(callback);
				AlarmHandler alarmHandler = gameObject.Handle.GetComponent<AlarmHandler>();
				if ((Object)(object)alarmHandler == (Object)null)
				{
					alarmHandler = gameObject.Handle.AddComponent<AlarmHandler>();
				}
				return alarmHandler.Add(alarm);
			}

			public void RemoveAlarm(LuaGameObject gameObject, string guid)
			{
				AlarmHandler component = gameObject.Handle.GetComponent<AlarmHandler>();
				if (!((Object)(object)component == (Object)null))
				{
					component.Remove(guid);
				}
			}
		}

		private LuaBindings _bindings;

		public void OnRegister(Script script)
		{
			_bindings = new LuaBindings();
			script.Globals[(object)"AlarmManager"] = _bindings;
		}
	}
	public class LuaCore : ILuaModule
	{
		[MoonSharpUserData]
		public class LuaBindings
		{
			public LuaEventHandler OnAlwaysUpdate;

			public LuaEventHandler OnFixedUpdate;

			public LuaEventHandler OnUpdate;

			public LuaEventHandler OnLateUpdate;

			public string LuaEngineVersion => "0.4.0";

			public float DeltaTime => Core.dt;

			[MoonSharpHidden]
			public LuaBindings(Script script)
			{
				OnAlwaysUpdate = new LuaEventHandler(script);
				OnFixedUpdate = new LuaEventHandler(script);
				OnUpdate = new LuaEventHandler(script);
				OnLateUpdate = new LuaEventHandler(script);
			}
		}

		private LuaBindings _bindings;

		public void OnRegister(Script script)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			_bindings = new LuaBindings(script);
			Core.OnAlwaysUpdate += new OnUpdateHandler(Core_OnAlwaysUpdate);
			Core.OnFixedUpdate += new OnFixedUpdateHandler(Core_OnFixedUpdate);
			Core.OnUpdate += new OnUpdateHandler(Core_OnUpdate);
			Core.OnLateUpdate += new OnLateUpdateHandler(Core_OnLateUpdate);
			script.Globals[(object)"Core"] = _bindings;
		}

		private void Core_OnAlwaysUpdate()
		{
			_bindings.OnAlwaysUpdate.Invoke();
		}

		private void Core_OnFixedUpdate()
		{
			_bindings.OnFixedUpdate.Invoke();
		}

		private void Core_OnUpdate()
		{
			_bindings.OnUpdate.Invoke();
		}

		private void Core_OnLateUpdate()
		{
			_bindings.OnLateUpdate.Invoke();
		}
	}
	public class LuaSequenceHandler : ILuaModule
	{
		[MoonSharpUserData]
		public class LuaBindings
		{
			private LuaSequenceHandler _luaSequenceHandler;

			[MoonSharpHidden]
			public LuaBindings(LuaSequenceHandler luaSequenceHandler)
			{
				_luaSequenceHandler = luaSequenceHandler;
			}

			public void StartSequence(LuaPlayableDirector director, DynValue OnSequenceEnd = null, bool hidePlayer = true, bool interruptPlayer = true, bool instantly = false, bool pausePlayer = false, bool allowPhoneOnAfterSequence = true, bool skippable = true, bool lowerVolume = true)
			{
				//IL_0005: 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_0026: Invalid comparison between Unknown and I4
				SequenceEvent sequenceEvent = new GameObject("Lua Sequence Event").AddComponent<SequenceEvent>();
				sequenceEvent.Director = director.PlayableDirector;
				if (OnSequenceEnd != null && (int)OnSequenceEnd.Type == 5)
				{
					sequenceEvent.OnSequenceEnd.Add(OnSequenceEnd);
				}
				SequenceHandler.instance.StartEnteringSequence(director.PlayableDirector, (GameplayEvent)(object)sequenceEvent, hidePlayer, interruptPlayer, instantly, pausePlayer, allowPhoneOnAfterSequence, (ProgressObject)null, skippable, lowerVolume, (Battle)null, false);
			}
		}

		private LuaBindings _bindings;

		public void OnRegister(Script script)
		{
			_bindings = new LuaBindings(this);
			script.Globals[(object)"SequenceHandler"] = _bindings;
		}
	}
	public class LuaStageManager : ILuaModule
	{
		[MoonSharpUserData]
		public class LuaBindings
		{
			public LuaEventHandler OnStageInitialized;

			public LuaEventHandler OnStagePostInitialization;

			public int CurrentStage => (int)Utility.GetCurrentStage();

			[MoonSharpHidden]
			public LuaBindings(Script script)
			{
				OnStageInitialized = new LuaEventHandler(script);
				OnStagePostInitialization = new LuaEventHandler(script);
			}

			public void ExitCurrentStage(int targetStageID, int previousStageID)
			{
				Core.Instance.BaseModule.StageManager.ExitCurrentStage((Stage)targetStageID, (Stage)previousStageID);
			}

			public string GetInternalNameForStageID(int stageID)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				Stage val = (Stage)stageID;
				return ((object)(Stage)(ref val)).ToString();
			}

			public string GetLocalizedNameForStageID(int stageID)
			{
				return Core.Instance.Localizer.GetStageName((Stage)stageID);
			}

			public int GetStageIDForInternalName(string stageInternalName)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				if (Enum.TryParse<Stage>(stageInternalName, out Stage result))
				{
					return (int)result;
				}
				return -1;
			}
		}

		private LuaBindings _bindings;

		public void OnRegister(Script script)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			_bindings = new LuaBindings(script);
			StageManager.OnStageInitialized += new OnStageInitializedDelegate(StageManager_OnStageInitialized);
			StageManager.OnStagePostInitialization += new OnStageInitializedDelegate(StageManager_OnStagePostInitialization);
			script.Globals[(object)"StageManager"] = _bindings;
		}

		private void StageManager_OnStageInitialized()
		{
			_bindings.OnStageInitialized.Invoke();
		}

		private void StageManager_OnStagePostInitialization()
		{
			_bindings.OnStagePostInitialization.Invoke();
		}
	}
	public class LuaUI : ILuaModule
	{
		[MoonSharpUserData]
		public class LuaBindings
		{
			private Script _script;

			[MoonSharpHidden]
			public LuaBindings(Script script)
			{
				_script = script;
			}

			public void SetTextMeshProText(LuaGameObject gameObject, string text)
			{
				gameObject.Handle.gameObject.GetComponent<TMP_Text>().text = text;
			}

			public string GetTextMeshProText(LuaGameObject gameObject)
			{
				return gameObject.Handle.gameObject.GetComponent<TMP_Text>().text;
			}

			public void StartScreenShake(string screenShakeType, float duration, bool continuous)
			{
				//IL_0001: 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_0068: 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_005b: 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_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				ScreenShakeType val = (ScreenShakeType)0;
				switch (screenShakeType)
				{
				case "Light":
					val = (ScreenShakeType)0;
					break;
				case "Medium":
					val = (ScreenShakeType)1;
					break;
				case "Heavy":
					val = (ScreenShakeType)2;
					break;
				case "ExtraLight":
					val = (ScreenShakeType)3;
					break;
				case "JustABitLighter":
					val = (ScreenShakeType)4;
					break;
				case "UltraLight":
					val = (ScreenShakeType)5;
					break;
				}
				GameplayCamera.StartScreenShake(val, duration, continuous);
			}

			public void FadeInAndOut(float durationIn, float durationStay, float durationOut)
			{
				Core.Instance.BaseModule.uiManager.effects.FadeInAndOutBlack(durationIn, durationStay, durationOut, (UpdateType)3);
			}

			public void ShowNotification(string text)
			{
				Core.Instance.BaseModule.uiManager.ShowNotification(text, Array.Empty<string>());
			}

			public void ResetCamera()
			{
				GameplayCamera.instance.ResetCameraPositionRotation();
			}
		}

		private LuaBindings _bindings;

		public void OnRegister(Script script)
		{
			_bindings = new LuaBindings(script);
			script.Globals[(object)"UI"] = _bindings;
		}
	}
	public class LuaUnityEngine : ILuaModule
	{
		[MoonSharpUserData]
		public class LuaBindings
		{
			private Script _script;

			[MoonSharpHidden]
			public LuaBindings(Script script)
			{
				_script = script;
			}

			public List<LuaScriptBehavior> FindScriptBehaviors(string scriptName, bool includeInactive)
			{
				IEnumerable<ScriptBehavior> enumerable = from script in Object.FindObjectsOfType<ScriptBehavior>(includeInactive)
					where script.LuaScriptName == scriptName
					select script;
				List<LuaScriptBehavior> list = new List<LuaScriptBehavior>();
				foreach (ScriptBehavior item in enumerable)
				{
					list.Add(new LuaScriptBehavior(item, LuaManager.Instance.GlobalScript));
				}
				return list;
			}

			public List<LuaGameObject> GetGameObjects(bool includeInactive)
			{
				GameObject[] array = Object.FindObjectsOfType<GameObject>(includeInactive);
				List<LuaGameObject> list = new List<LuaGameObject>();
				GameObject[] array2 = array;
				foreach (GameObject handle in array2)
				{
					list.Add(new LuaGameObject(handle));
				}
				return list;
			}

			public LuaGameObject FindGameObjectByName(string name)
			{
				GameObject val = GameObject.Find(name);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				return new LuaGameObject(val);
			}
		}

		private LuaBindings _bindings;

		public void OnRegister(Script script)
		{
			_bindings = new LuaBindings(script);
			script.Globals[(object)"Engine"] = _bindings;
			script.Globals[(object)"LuaGameObject"] = typeof(LuaGameObject);
		}
	}
	public class LuaWorldHandler : ILuaModule
	{
		[MoonSharpUserData]
		public class LuaBindings
		{
			private Script _script;

			public LuaGameObject CurrentCamera
			{
				get
				{
					WorldHandler instance = WorldHandler.instance;
					if ((Object)(object)instance == (Object)null)
					{
						return null;
					}
					return new LuaGameObject(((Component)instance.currentCamera).gameObject);
				}
			}

			public LuaPlayer CurrentPlayer
			{
				get
				{
					WorldHandler instance = WorldHandler.instance;
					if ((Object)(object)instance == (Object)null)
					{
						return null;
					}
					Player currentPlayer = instance.GetCurrentPlayer();
					if ((Object)(object)currentPlayer == (Object)null)
					{
						return null;
					}
					return new LuaPlayer(currentPlayer, _script);
				}
			}

			[MoonSharpHidden]
			public LuaBindings(Script script)
			{
				_script = script;
			}

			public void PlacePlayerAt(LuaPlayer player, Table luaPosition, Table luaEulerAngles, bool stopAbility = true)
			{
				//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_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)
				Vector3 val = LuaMathUtils.TableToVector3(luaPosition);
				Quaternion val2 = Quaternion.Euler(LuaMathUtils.TableToVector3(luaEulerAngles));
				WorldHandler.instance.PlacePlayerAt(player.Player, val, val2, stopAbility);
			}
		}

		private LuaBindings _bindings;

		public void OnRegister(Script script)
		{
			_bindings = new LuaBindings(script);
			script.Globals[(object)"WorldHandler"] = _bindings;
		}
	}
}
namespace LuaEngine.MapStation
{
	public class LuaEngineGameMapStationPlugin : AGameMapStationPlugin
	{
		public override void OnReload()
		{
			LuaManager.Instance.Reload();
		}
	}
}
namespace LuaEngine.Alarms
{
	public class Alarm
	{
		public float TimeLeft;

		public bool RunPaused;

		public LuaEventHandler Callback;

		public Alarm()
		{
			Callback = new LuaEventHandler(LuaManager.Instance.GlobalScript);
		}
	}
	public class AlarmHandler : MonoBehaviour
	{
		public Dictionary<string, Alarm> AlarmByGUID;

		private void Awake()
		{
			AlarmByGUID = new Dictionary<string, Alarm>();
		}

		private void Update()
		{
			Dictionary<string, Alarm> dictionary = new Dictionary<string, Alarm>();
			foreach (KeyValuePair<string, Alarm> item in AlarmByGUID)
			{
				if (Core.Instance.IsCorePaused && !item.Value.RunPaused)
				{
					dictionary[item.Key] = item.Value;
					return;
				}
				item.Value.TimeLeft -= Core.dt;
				if (item.Value.TimeLeft <= 0f)
				{
					item.Value.Callback.Invoke();
					return;
				}
				dictionary[item.Key] = item.Value;
			}
			AlarmByGUID = dictionary;
		}

		public string Add(Alarm alarm)
		{
			string text = Guid.NewGuid().ToString();
			AlarmByGUID[text] = alarm;
			return text;
		}

		public void Remove(string guid)
		{
			if (AlarmByGUID.TryGetValue(guid, out var _))
			{
				AlarmByGUID.Remove(guid);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}