using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Landfall.TABS;
using LevelCreator;
using TFBGames;
using UnboundTerrain;
using UnboundTerrainScripts;
using UnityEngine;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("UnboundTerrain")]
[assembly: AssemblyDescription("UnboundTerrain")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("GeeztJeez")]
[assembly: AssemblyProduct("UnboundTerrain")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7acfaef0-7669-4401-8bff-5a9a02e18c75")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
namespace UnboundTerrain
{
	[BepInPlugin("GeeztJeez.UnboundTerrain", "UnboundTerrain", "1.0.2")]
	internal class Loader : BaseUnityPlugin
	{
		public AssetBundle assetsBundle;

		public static ConfigEntry<float> multiplyMapSize;

		public static ConfigEntry<float> waterLevel;

		public PostProcessProfile waterPostProcessProfile;

		private SoundPlayer SoundPlayer => ServiceLocator.GetService<SoundPlayer>();

		public static float GetMultiplyMapSize => multiplyMapSize.Value;

		public static float GetWaterLevel => waterLevel.Value;

		public static event Action<float> OnMultiplyMapSizeChanged;

		public static event Action<float> OnWaterLevelChanged;

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			assetsBundle = GetBundle("unboundterrainbundle");
			waterPostProcessProfile = (PostProcessProfile)assetsBundle.LoadAsset("WaterPostDefault");
			ApplyHarmony();
			((MonoBehaviour)this).StartCoroutine(Call());
		}

		private IEnumerator Call()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)Object.FindObjectOfType<ServiceLocator>() != (Object)null));
			yield return (object)new WaitUntil((Func<bool>)(() => ServiceLocator.GetService<ISaveLoaderService>() != null));
			CreateSettings();
			yield return ((MonoBehaviour)this).StartCoroutine(GenerateSettings());
			Debug.Log((object)"[UnboundTerrain] Loading...");
			SLMALoader.GetInstance();
			new Harmony("UnboundTerrain").PatchAll();
			SceneManager.sceneLoaded += SceneLoaded;
			Debug.Log((object)"[UnboundTerrain] Loaded Successfully!");
		}

		private void SceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			float num = 100000f;
			if (((Scene)(ref scene)).name == "Editor Scene")
			{
				MeshCollider[] array = Object.FindObjectsOfType<MeshCollider>();
				foreach (MeshCollider val in array)
				{
					if (((Object)((Component)val).gameObject).name == "Water")
					{
						Transform transform = ((Component)val).transform;
						transform.localScale = new Vector3(num, transform.localScale.y, num);
						Debug.Log((object)"[UnboundTerrain] Scaled Water MeshCollider");
					}
				}
			}
			if (!(((Scene)(ref scene)).name == "LevelScene"))
			{
				return;
			}
			float getMultiplyMapSize = GetMultiplyMapSize;
			GameObject val2 = GameObject.Find("WeatherEffects");
			if ((Object)(object)val2 != (Object)null)
			{
				ParticleSystemRenderer[] componentsInChildren = val2.GetComponentsInChildren<ParticleSystemRenderer>(true);
				foreach (ParticleSystemRenderer val3 in componentsInChildren)
				{
					if ((Object)(object)val3 != (Object)null)
					{
						Transform transform2 = ((Component)val3).transform;
						transform2.localScale *= getMultiplyMapSize;
					}
				}
			}
			else
			{
				Debug.LogWarning((object)"[UnboundTerrain] WeatherEffects not found.");
			}
			PostProcessVolume val4 = Object.FindObjectOfType<PostProcessVolume>();
			if ((Object)(object)val4 != (Object)null)
			{
				if ((Object)(object)((Component)val4).gameObject.GetComponent<UnboundWaterPost>() == (Object)null)
				{
					((Component)val4).gameObject.AddComponent<UnboundWaterPost>().waterPost = waterPostProcessProfile;
				}
			}
			else
			{
				Debug.LogWarning((object)"[UnboundTerrain] PostProcessVolume not found.");
			}
			WaterPost val5 = Object.FindObjectOfType<WaterPost>();
			if ((Object)(object)val5 != (Object)null)
			{
				Object.Destroy((Object)(object)val5);
			}
			SpawnLevel val6 = Object.FindObjectOfType<SpawnLevel>();
			if ((Object)(object)val6 != (Object)null)
			{
				Transform transform3 = ((Component)val6).transform;
				transform3.localScale *= getMultiplyMapSize;
				Vector3 position = transform3.position;
				position.x *= getMultiplyMapSize;
				position.y = -10f * getMultiplyMapSize;
				position.z *= getMultiplyMapSize;
				transform3.position = position;
			}
			else
			{
				Debug.LogWarning((object)"[UnboundTerrain] SpawnLevel not found.");
			}
			Water val7 = Object.FindObjectOfType<Water>();
			if ((Object)(object)val7 != (Object)null)
			{
				Transform transform4 = ((Component)val7).transform;
				transform4.localScale = new Vector3(num, transform4.localScale.y, num);
				Transform parent = transform4.parent;
				if ((Object)(object)parent != (Object)null && (Object)(object)((Component)parent).GetComponent<GoToYBehaviour>() == (Object)null)
				{
					((Component)parent).gameObject.AddComponent<GoToYBehaviour>();
				}
			}
			else
			{
				Debug.LogWarning((object)"[UnboundTerrain] Water not found.");
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= SceneLoaded;
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)MapSettings.Instance) && MapSettings.Instance.m_mapRadius != float.MaxValue)
			{
				MapSettings.Instance.m_mapRadius = float.MaxValue;
				Debug.Log((object)"Set Map Settings to infinite.");
			}
		}

		public static AssetBundle GetBundle(string assetBundleName)
		{
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(assetBundleName);
			if (manifestResourceStream == null)
			{
				Debug.LogError((object)("[LoadBundle] Failed to find resource: " + assetBundleName));
				return null;
			}
			if (!manifestResourceStream.CanRead)
			{
				Debug.LogError((object)("[LoadBundle] Resource stream is not readable: " + assetBundleName));
				return null;
			}
			return AssetBundle.LoadFromStream(manifestResourceStream);
		}

		private void ApplyHarmony()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				new Harmony("UnboundTerrain").PatchAll(Assembly.GetExecutingAssembly());
				Debug.Log((object)"[UnboundTerrain] Harmony patched successfully!");
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[UnboundTerrain] Harmony patch failed: " + ex));
				Debug.Log((object)"Please contact Geezt Jeez or try reloading the game for proper installation...");
			}
		}

		private void CreateSettings()
		{
			multiplyMapSize = ((BaseUnityPlugin)this).Config.Bind<float>("UnboundTerrain", "Multiply Map Size", 5f, "Amount of scale the custom map getting multiplied.");
			AttachFloatSettingChangedHandler(multiplyMapSize, Loader.OnMultiplyMapSizeChanged);
			waterLevel = ((BaseUnityPlugin)this).Config.Bind<float>("UnboundTerrain", "WaterSize", 0f, "Amount of height the water would be on custom map.");
			AttachFloatSettingChangedHandler(waterLevel, Loader.OnWaterLevelChanged);
		}

		private void AttachFloatSettingChangedHandler(ConfigEntry<float> entry, Action<float> targetEvent)
		{
			entry.SettingChanged += delegate
			{
				targetEvent?.Invoke(entry.Value);
			};
		}

		private IEnumerator GenerateSettings()
		{
			GlobalSettingsHandler service = null;
			yield return (object)new WaitUntil((Func<bool>)(() => Object.op_Implicit((Object)(object)(service = ServiceLocator.GetService<GlobalSettingsHandler>()))));
			List<SettingsInstance> list = service.GameplaySettings.ToList();
			list.Add(CreateSliderSettingInstance(multiplyMapSize, "Multiply Map Size", "Amount of scale the custom map getting multiplied", 1f, 30f, (float)((ConfigEntryBase)multiplyMapSize).DefaultValue));
			list.Add(CreateSliderSettingInstance(waterLevel, "Water Level", "Amount of height the water would be on custom map", -60f, 600f, (float)((ConfigEntryBase)waterLevel).DefaultValue));
			((object)service).GetType().GetField("m_gameplaySettings", (BindingFlags)(-1)).SetValue(service, list.ToArray());
		}

		private SettingsInstance CreateSliderSettingInstance(ConfigEntry<float> configEntry, string key, string toolTip, float min, float max, float defaultValue)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0063: Expected O, but got Unknown
			SettingsInstance val = new SettingsInstance
			{
				settingsType = (SettingsType)1,
				currentSliderValue = configEntry.Value,
				defaultSliderValue = defaultValue,
				min = min,
				max = max,
				m_settingsKey = key,
				toolTip = toolTip
			};
			val.OnSliderValueChanged += delegate(float value)
			{
				configEntry.Value = value;
			};
			return val;
		}
	}
}
namespace UnboundTerrainHarmonyPatch
{
	[HarmonyPatch(typeof(CameraMovement), "Start")]
	internal class CameraMovementPatch
	{
		private static void Postfix(CameraMovement __instance)
		{
			((object)__instance).GetType().GetField("m_mapRadius", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(__instance, 99999f);
			((object)__instance).GetType().GetField("m_mapRadiusSqr", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(__instance, 9.9998E+09f);
		}
	}
}
namespace UnboundTerrain
{
	public class UnboundWaterPost : MonoBehaviour
	{
		public PostProcessProfile waterPost;

		private PostProcessProfile defaultPost;

		private PostProcessVolume volume;

		private Transform mainCamTransform;

		private PostProcessProfile defaultPostProfile;

		private void Start()
		{
			volume = ((Component)this).GetComponent<PostProcessVolume>();
			defaultPost = volume.sharedProfile;
			defaultPostProfile = volume.profile;
			GetMainCamera();
		}

		private void GetMainCamera()
		{
			PlayerCamerasManager service = ServiceLocator.GetService<PlayerCamerasManager>();
			MainCam val = ((service != null) ? service.GetMainCam((Player)0) : null);
			mainCamTransform = (((Object)(object)val != (Object)null) ? ((Component)val).transform : null);
		}

		private void Update()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mainCamTransform == (Object)null)
			{
				GetMainCamera();
				return;
			}
			float getWaterLevel = Loader.GetWaterLevel;
			if (mainCamTransform.position.y < getWaterLevel)
			{
				volume.profile = waterPost;
				volume.sharedProfile = waterPost;
			}
			else
			{
				volume.profile = defaultPostProfile;
				volume.sharedProfile = defaultPost;
			}
		}
	}
}
namespace UnboundTerrainScripts
{
	public class GoToYBehaviour : MonoBehaviour
	{
		private Transform mainCamTransform;

		private void Update()
		{
			//IL_0006: 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)
			float y = ((Component)this).transform.position.y;
			float getWaterLevel = Loader.GetWaterLevel;
			if (y != getWaterLevel)
			{
				((Component)this).transform.position = new Vector3(0f, getWaterLevel, 0f);
			}
		}
	}
}