using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using PEAKLib.Core.Extensions;
using PEAKLib.Items.UnityEditor;
using Photon.Pun;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI.Extensions;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.MiiMii1205.LuckyBlocks64")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+a0dbb1c3b7aff7e645d401db55ef16cc00ce6507")]
[assembly: AssemblyProduct("com.github.MiiMii1205.LuckyBlocks64")]
[assembly: AssemblyTitle("LuckyBlocks64")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace LuckyBlocks64
{
	public class Block64MaterialChanger : MonoBehaviour
	{
		public MeshRenderer m_blockRenderer;

		private void Awake()
		{
			Block64Plugin.LuckyBlock64Type.SettingChanged += UpdateMaterial;
		}

		private void UpdateMaterial(object sender, EventArgs e)
		{
			UpdateMaterial();
		}

		private void UpdateMaterial()
		{
			((Renderer)m_blockRenderer).sharedMaterial = Block64Plugin.LuckyBlock64Material;
		}

		private void OnDestroy()
		{
			Block64Plugin.LuckyBlock64Type.SettingChanged -= UpdateMaterial;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.github.MiiMii1205.LuckyBlocks64", "LuckyBlocks64", "1.1.0")]
	public class Block64Plugin : BaseUnityPlugin
	{
		private bool m_isLoaded;

		public static readonly Dictionary<BlockTypes, Texture2D> LuckyBlockTextures = new Dictionary<BlockTypes, Texture2D>();

		public static readonly Dictionary<BlockTypes, Color> LuckyBlockParticleColors = new Dictionary<BlockTypes, Color>();

		private static readonly int BaseTexture = Shader.PropertyToID("_BaseTexture");

		public const string Id = "com.github.MiiMii1205.LuckyBlocks64";

		internal static ManualLogSource Log { get; private set; } = null;


		public static Mesh LuckyBlock64Model
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static Material LuckyBlock64Material
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static GameObject LuckyBlock64BreakVFX
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static SFX_Instance LuckyBlock64BreakSound
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static ConfigEntry<BlockTypes> LuckyBlock64Type
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		private static Texture LuckyBlockTexture
		{
			get
			{
				//IL_0037: 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_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Expected I4, but got Unknown
				switch (LuckyBlock64Type.Value)
				{
				case BlockTypes.PER_BIOMES:
				{
					if ((Object)(object)Singleton<MapHandler>.Instance == (Object)null)
					{
						return (Texture)(object)LuckyBlockTextures[BlockTypes.YELLOW];
					}
					BiomeType currentBiome = Singleton<MapHandler>.Instance.GetCurrentBiome();
					switch ((int)currentBiome)
					{
					case 0:
						return (Texture)(object)LuckyBlockTextures[BlockTypes.WINGED];
					case 1:
					{
						BiomeVariant componentInChildren = MapHandler.CurrentMapSegment._segmentParent.GetComponentInChildren<BiomeVariant>();
						if (((Object)componentInChildren).name == "Ivy")
						{
							return (Texture)(object)LuckyBlockTextures[BlockTypes.YELLOW];
						}
						return (Texture)(object)LuckyBlockTextures[BlockTypes.WINGED];
					}
					case 2:
						return (Texture)(object)LuckyBlockTextures[BlockTypes.YELLOW];
					case 3:
						return (Texture)(object)LuckyBlockTextures[BlockTypes.METAL];
					case 5:
						return (Texture)(object)LuckyBlockTextures[BlockTypes.WINGED];
					case 6:
						return (Texture)(object)LuckyBlockTextures[BlockTypes.VANISH];
					case 7:
						return (Texture)(object)LuckyBlockTextures[BlockTypes.WINGED];
					default:
						throw new ArgumentOutOfRangeException("GetCurrentBiome");
					}
				}
				case BlockTypes.YELLOW:
				case BlockTypes.WINGED:
				case BlockTypes.VANISH:
				case BlockTypes.METAL:
					return (Texture)(object)LuckyBlockTextures[LuckyBlock64Type.Value];
				default:
					throw new ArgumentOutOfRangeException("LuckyBlock64Type");
				}
			}
		}

		private static Color LuckyBlockParticleColor
		{
			get
			{
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: 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_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Expected I4, but got Unknown
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				switch (LuckyBlock64Type.Value)
				{
				case BlockTypes.PER_BIOMES:
				{
					if ((Object)(object)Singleton<MapHandler>.Instance == (Object)null)
					{
						return LuckyBlockParticleColors[BlockTypes.YELLOW];
					}
					BiomeType currentBiome = Singleton<MapHandler>.Instance.GetCurrentBiome();
					switch ((int)currentBiome)
					{
					case 0:
						return LuckyBlockParticleColors[BlockTypes.WINGED];
					case 1:
					{
						BiomeVariant componentInChildren = MapHandler.CurrentMapSegment._segmentParent.GetComponentInChildren<BiomeVariant>();
						if (((Object)componentInChildren).name == "Ivy")
						{
							return LuckyBlockParticleColors[BlockTypes.YELLOW];
						}
						return LuckyBlockParticleColors[BlockTypes.WINGED];
					}
					case 2:
						return LuckyBlockParticleColors[BlockTypes.YELLOW];
					case 3:
						return LuckyBlockParticleColors[BlockTypes.METAL];
					case 5:
						return LuckyBlockParticleColors[BlockTypes.WINGED];
					case 6:
						return LuckyBlockParticleColors[BlockTypes.VANISH];
					case 7:
						return LuckyBlockParticleColors[BlockTypes.WINGED];
					default:
						throw new ArgumentOutOfRangeException("GetCurrentBiome");
					}
				}
				case BlockTypes.YELLOW:
				case BlockTypes.WINGED:
				case BlockTypes.VANISH:
				case BlockTypes.METAL:
					return LuckyBlockParticleColors[LuckyBlock64Type.Value];
				default:
					throw new ArgumentOutOfRangeException("LuckyBlock64Type");
				}
			}
		}

		public static Renderer LuckyBlockRenderer
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set;
		} = null;


		public static string Name => "LuckyBlocks64";

		public static string Version => "1.1.0";

		private void Awake()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)this, "lucky64.peakbundle", (Action<PeakBundle>)LoadBundle);
			LuckyBlock64Type = ((BaseUnityPlugin)this).Config.Bind<BlockTypes>("General", "Block Type", BlockTypes.YELLOW, "Which type of block to use. Visual only: doesn't change the mechanics at all. (YELLOW=yellow, WINGED=red, VANISH=blue, METAL=green, PER_BIOMES=matches the current biome)");
			LuckyBlock64Type.SettingChanged += RefreshBlockGraphics;
			SceneManager.sceneLoaded += RefreshPerBiomeBlocks;
			Harmony val = new Harmony("com.github.MiiMii1205.LuckyBlocks64");
			val.PatchAll(typeof(Patcher));
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}

		private void RefreshPerBiomeBlocks(Scene arg0, LoadSceneMode arg1)
		{
			if (GameHandler.IsOnIsland && LuckyBlock64Type.Value == BlockTypes.PER_BIOMES)
			{
				RefreshBlockGraphics();
			}
		}

		private void RefreshBlockGraphics(object sender, EventArgs e)
		{
			RefreshBlockGraphics();
		}

		public static void RefreshBlockGraphics()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			LuckyBlock64Material.SetTexture(BaseTexture, LuckyBlockTexture);
			ParticleSystem component = ((Component)LuckyBlock64BreakVFX.transform.Find("Particles")).GetComponent<ParticleSystem>();
			MainModule main = component.main;
			ParticleSystemRenderer component2 = LuckyBlock64BreakVFX.GetComponent<ParticleSystemRenderer>();
			((Renderer)component2).sharedMaterial = LuckyBlock64Material;
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(LuckyBlockParticleColor);
			if (Object.op_Implicit((Object)(object)LuckyBlockRenderer))
			{
				LuckyBlockRenderer.sharedMaterial = LuckyBlock64Material;
			}
		}

		private void LoadBundle(PeakBundle bundle)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			LuckyBlock64Model = bundle.LoadAsset<Mesh>("LuckyCube.fbx");
			LuckyBlock64Material = bundle.LoadAsset<Material>("M_LuckyCube64.mat");
			LuckyBlock64BreakVFX = bundle.LoadAsset<GameObject>("Lucky64Break.prefab");
			LuckyBlock64BreakSound = bundle.LoadAsset<SFX_Instance>("SFXI_Lucky64Break.asset");
			LuckyBlockTextures.Add(BlockTypes.YELLOW, bundle.LoadAsset<Texture2D>("block_y_tex.png"));
			LuckyBlockTextures.Add(BlockTypes.VANISH, bundle.LoadAsset<Texture2D>("block_v_tex.png"));
			LuckyBlockTextures.Add(BlockTypes.METAL, bundle.LoadAsset<Texture2D>("block_m_tex.png"));
			LuckyBlockTextures.Add(BlockTypes.WINGED, bundle.LoadAsset<Texture2D>("block_w_tex.png"));
			LuckyBlockParticleColors.Add(BlockTypes.YELLOW, new Color(0.9215686f, 49f / 85f, 0.2745098f, 1f));
			LuckyBlockParticleColors.Add(BlockTypes.WINGED, new Color(46f / 51f, 0.2509804f, 0.1843137f, 1f));
			LuckyBlockParticleColors.Add(BlockTypes.VANISH, new Color(0.2627451f, 0.2470588f, 41f / 51f, 1f));
			LuckyBlockParticleColors.Add(BlockTypes.METAL, new Color(0.4627451f, 0.7960784f, 0.2588235f, 1f));
			ShaderExtensions.ReplaceShaders(LuckyBlock64BreakVFX);
			Shader val = Shader.Find(((Object)LuckyBlock64Material.shader).name);
			if (Object.op_Implicit((Object)(object)val))
			{
				LuckyBlock64Material.shader = val;
			}
			Log.LogInfo((object)"Lucky 64 data is loaded!");
			RefreshBlockGraphics();
			ModDefinition modDefinition = ModDefinition.GetOrCreate(Chainloader.PluginInfos["legocool.LuckyBlocks"]);
			if (modDefinition.Content.Count >= 1)
			{
				Log.LogInfo((object)"Applying Lucky 64 patch immediately!");
				ApplyPatch(modDefinition);
				m_isLoaded = true;
				return;
			}
			Log.LogInfo((object)"Applying Lucky 64 patch later...");
			BundleLoader.OnBundleLoaded += delegate(PeakBundle b)
			{
				if (b.Contains("LuckyBlock.prefab") && b.Mod.Id == modDefinition.Id && !m_isLoaded)
				{
					ApplyPatch(modDefinition);
					m_isLoaded = true;
				}
			};
		}

		private void ApplyPatch(ModDefinition modDefinition)
		{
			Item val2 = default(Item);
			Item val4 = default(Item);
			Breakable val5 = default(Breakable);
			foreach (IContent item in modDefinition.Content)
			{
				UnityItemContent val = (UnityItemContent)(object)((item is UnityItemContent) ? item : null);
				if (val == null || !val.ItemPrefab.TryGetComponent<Item>(ref val2))
				{
					continue;
				}
				Log.LogInfo((object)"Applying Lucky 64 patch...");
				Transform val3 = ((Component)val2).transform.Find("Cube");
				MeshFilter component = ((Component)val3).GetComponent<MeshFilter>();
				MeshRenderer component2 = ((Component)component).gameObject.GetComponent<MeshRenderer>();
				component.sharedMesh = LuckyBlock64Model;
				LuckyBlockRenderer = (Renderer)(object)component2;
				((Renderer)component2).sharedMaterial = LuckyBlock64Material;
				ShaderExtensions.ReplaceShaders(((Component)component).gameObject);
				LuckyBreakable component3 = val.ItemPrefab.GetComponent<LuckyBreakable>();
				LuckyClientBreakable orAddComponent = ExtensionMethods.GetOrAddComponent<LuckyClientBreakable>(val.ItemPrefab);
				orAddComponent.m_minBreakVelocity = component3.minBreakVelocity;
				orAddComponent.item = component3.item;
				orAddComponent.m_breakOnCollision = component3.breakOnCollision;
				orAddComponent.m_instantiateOnBreak = component3.instantiateNonItemOnBreak;
				LuckyClientBreakable luckyClientBreakable = orAddComponent;
				if (luckyClientBreakable.breakSfx == null)
				{
					luckyClientBreakable.breakSfx = new List<SFX_Instance>();
				}
				luckyClientBreakable = orAddComponent;
				if (luckyClientBreakable.m_instantiateOnBreak == null)
				{
					luckyClientBreakable.m_instantiateOnBreak = new List<GameObject>();
				}
				orAddComponent.breakSfx.Add(LuckyBlock64BreakSound);
				orAddComponent.m_instantiateOnBreak.Add(LuckyBlock64BreakVFX);
				Block64MaterialChanger orAddComponent2 = ExtensionMethods.GetOrAddComponent<Block64MaterialChanger>(val.ItemPrefab);
				orAddComponent2.m_blockRenderer = component2;
				if (!ItemDatabase.TryGetItem((ushort)36, ref val4) || !((Component)val4).TryGetComponent<Breakable>(ref val5))
				{
					continue;
				}
				foreach (SFX_Instance item2 in val5.breakSFX)
				{
					if (((Object)item2).name != "SFXI Break Coconut 1")
					{
						orAddComponent.breakSfx.Add(item2);
					}
				}
			}
		}
	}
	public enum BlockTypes
	{
		YELLOW,
		WINGED,
		VANISH,
		METAL,
		PER_BIOMES
	}
	[RequireComponent(typeof(PhotonView))]
	public class LuckyClientBreakable : MonoBehaviour
	{
		public Item item;

		public bool m_breakOnCollision = true;

		public float m_minBreakVelocity = 5f;

		public List<SFX_Instance> breakSfx = new List<SFX_Instance>();

		public List<GameObject> m_instantiateOnBreak = new List<GameObject>();

		private Rigidbody m_rig;

		private bool m_alreadyBroke;

		private void Awake()
		{
			if (item == null)
			{
				item = ((Component)this).GetComponent<Item>();
			}
			if (m_rig == null)
			{
				m_rig = ((Component)this).GetComponent<Rigidbody>();
			}
		}

		private void OnCollisionEnter(Collision collision)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if ((int)item.itemState == 0 && m_breakOnCollision && Object.op_Implicit((Object)(object)item.rig))
			{
				Vector3 relativeVelocity = collision.relativeVelocity;
				if (!(((Vector3)(ref relativeVelocity)).magnitude <= m_minBreakVelocity))
				{
					Break(collision);
				}
			}
		}

		public void Break(Collision coll)
		{
			//IL_0015: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!m_alreadyBroke)
			{
				m_alreadyBroke = true;
				Vector3 position = ((Component)this).transform.position;
				PlayBreakSfx(position);
				PlayBreakVfx(position);
			}
		}

		private void PlayBreakVfx(Vector3 pos)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			int i = 0;
			Rigidbody val2 = default(Rigidbody);
			for (int count = m_instantiateOnBreak.Count; i < count; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(m_instantiateOnBreak[i], pos, ((Component)this).transform.rotation);
				if (val.TryGetComponent<Rigidbody>(ref val2))
				{
					val2.linearVelocity = item.rig.linearVelocity;
					val2.angularVelocity = item.rig.angularVelocity;
				}
			}
		}

		private void PlayBreakSfx(Vector3 pos)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			int i = 0;
			for (int count = breakSfx.Count; i < count; i++)
			{
				breakSfx[i].Play(pos);
			}
		}
	}
	public static class Patcher
	{
		[HarmonyPatch(typeof(MountainProgressHandler), "TriggerReached")]
		[HarmonyPrefix]
		public static void TriggerReachedPost(MountainProgressHandler __instance, ProgressPoint progressPoint, bool isFurthestPoint = true)
		{
			if (Block64Plugin.LuckyBlock64Type.Value == BlockTypes.PER_BIOMES)
			{
				Block64Plugin.RefreshBlockGraphics();
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}