using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
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 BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityStandardAssets.ImageEffects;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ChangeOfScenery")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Azumatt")]
[assembly: AssemblyProduct("ChangeOfScenery")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: AssemblyFileVersion("1.0.6")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.6.0")]
[module: UnverifiableCode]
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;
		}
	}
}
namespace ChangeOfScenery
{
	public class Functions
	{
		public static float scrollSpeed = 50f;

		public static float inactivityDelay = 2f;

		public static float textElementHeight = 30f;

		public static float textElementWidth = 30f;

		private static GameObject scrollingTextElement;

		private static AutoScrollingText autoScrollingText;

		internal static void GatherDefaultCamLocations(FejdStartup startup)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			ChangeOfSceneryPlugin.defaultCharacterCameraMarker_Position = startup.m_cameraMarkerCharacter.position;
			ChangeOfSceneryPlugin.defaultCreditsCameraMarker_Position = startup.m_cameraMarkerCredits.position;
			ChangeOfSceneryPlugin.defaultGameCameraMarker_Position = startup.m_cameraMarkerGame.position;
			ChangeOfSceneryPlugin.defaultMainCameraMarker_Position = startup.m_cameraMarkerMain.position;
			ChangeOfSceneryPlugin.defaultStartCameraMarker_Position = startup.m_cameraMarkerStart.position;
			ChangeOfSceneryPlugin.defaultSavesCameraMarker_Position = startup.m_cameraMarkerSaves.position;
			Quaternion rotation = startup.m_cameraMarkerCharacter.rotation;
			ChangeOfSceneryPlugin.defaultCharacterCameraMarker_Rotation = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerCredits.rotation;
			ChangeOfSceneryPlugin.defaultCreditsCameraMarker_Rotation = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerGame.rotation;
			ChangeOfSceneryPlugin.defaultGameCameraMarker_Rotation = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerMain.rotation;
			ChangeOfSceneryPlugin.defaultMainCameraMarker_Rotation = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerStart.rotation;
			ChangeOfSceneryPlugin.defaultStartCameraMarker_Rotation = ((Quaternion)(ref rotation)).eulerAngles;
			rotation = startup.m_cameraMarkerSaves.rotation;
			ChangeOfSceneryPlugin.defaultSavesCameraMarker_Rotation = ((Quaternion)(ref rotation)).eulerAngles;
		}

		internal static void GatherDefaultPlayerShit(FejdStartup startup)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			ChangeOfSceneryPlugin._defaultPlayerPreviewPoint = startup.m_characterPreviewPoint;
			ChangeOfSceneryPlugin._defaultPlayerPosition = startup.m_characterPreviewPoint.position;
			Quaternion rotation = startup.m_characterPreviewPoint.rotation;
			ChangeOfSceneryPlugin._defaultPlayerRotation = ((Quaternion)(ref rotation)).eulerAngles;
		}

		internal static void SetToCameraDefaults()
		{
			//IL_0005: 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_0023: 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_0041: 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_005f: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			ChangeOfSceneryPlugin.CharacterCameraMarker_Position.Value = ChangeOfSceneryPlugin.defaultCharacterCameraMarker_Position;
			ChangeOfSceneryPlugin.CreditsCameraMarker_Position.Value = ChangeOfSceneryPlugin.defaultCreditsCameraMarker_Position;
			ChangeOfSceneryPlugin.GameCameraMarker_Position.Value = ChangeOfSceneryPlugin.defaultGameCameraMarker_Position;
			ChangeOfSceneryPlugin.MainCameraMarker_Position.Value = ChangeOfSceneryPlugin.defaultMainCameraMarker_Position;
			ChangeOfSceneryPlugin.StartCameraMarker_Position.Value = ChangeOfSceneryPlugin.defaultStartCameraMarker_Position;
			ChangeOfSceneryPlugin.SavesCameraMarker_Position.Value = ChangeOfSceneryPlugin.defaultSavesCameraMarker_Position;
			ChangeOfSceneryPlugin.CharacterCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.defaultCharacterCameraMarker_Rotation;
			ChangeOfSceneryPlugin.CreditsCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.defaultCreditsCameraMarker_Rotation;
			ChangeOfSceneryPlugin.GameCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.defaultGameCameraMarker_Rotation;
			ChangeOfSceneryPlugin.MainCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.defaultMainCameraMarker_Rotation;
			ChangeOfSceneryPlugin.StartCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.defaultStartCameraMarker_Rotation;
			ChangeOfSceneryPlugin.SavesCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.defaultSavesCameraMarker_Rotation;
		}

		internal static void SetToPlayerDefaults()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				FejdStartup.instance.m_characterPreviewPoint = ChangeOfSceneryPlugin._defaultPlayerPreviewPoint;
				if (!((Object)(object)FejdStartup.instance.m_playerInstance == (Object)null))
				{
					FejdStartup.instance.m_playerInstance.transform.position = ChangeOfSceneryPlugin._defaultPlayerPosition;
					FejdStartup.instance.m_playerInstance.transform.rotation = Quaternion.Euler(ChangeOfSceneryPlugin._defaultPlayerRotation);
					ChangeOfSceneryPlugin.MPlayerPosition.Value = ChangeOfSceneryPlugin._defaultPlayerPosition;
					ChangeOfSceneryPlugin.MPlayerRotation.Value = ChangeOfSceneryPlugin._defaultPlayerRotation;
				}
			}
		}

		internal static void SetToCameraPresets()
		{
			//IL_0005: 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_0023: 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_0041: 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_005f: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			ChangeOfSceneryPlugin.CharacterCameraMarker_Position.Value = ChangeOfSceneryPlugin.m_cameraMarkerCharacterPositionPreset1;
			ChangeOfSceneryPlugin.CreditsCameraMarker_Position.Value = ChangeOfSceneryPlugin.m_cameraMarkerCreditsPositionPreset1;
			ChangeOfSceneryPlugin.GameCameraMarker_Position.Value = ChangeOfSceneryPlugin.m_cameraMarkerGamePositionPreset1;
			ChangeOfSceneryPlugin.MainCameraMarker_Position.Value = ChangeOfSceneryPlugin.m_cameraMarkerStartPositionPreset1;
			ChangeOfSceneryPlugin.StartCameraMarker_Position.Value = ChangeOfSceneryPlugin.m_cameraMarkerStartPositionPreset1;
			ChangeOfSceneryPlugin.SavesCameraMarker_Position.Value = ChangeOfSceneryPlugin.m_cameraMarkerSavesPositionPreset1;
			ChangeOfSceneryPlugin.CharacterCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.m_cameraMarkerCharacterRotationPreset1;
			ChangeOfSceneryPlugin.CreditsCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.m_cameraMarkerCreditsRotationPreset1;
			ChangeOfSceneryPlugin.GameCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.m_cameraMarkerGameRotationPreset1;
			ChangeOfSceneryPlugin.MainCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.m_cameraMarkerStartRotationPreset1;
			ChangeOfSceneryPlugin.StartCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.m_cameraMarkerStartRotationPreset1;
			ChangeOfSceneryPlugin.SavesCameraMarker_Rotation.Value = ChangeOfSceneryPlugin.m_cameraMarkerSavesRotationPreset1;
		}

		internal static void SetToPlayerPresets()
		{
			//IL_000a: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			FejdStartup.instance.m_characterPreviewPoint.position = ChangeOfSceneryPlugin.m_characterPreviewPositionPreset1;
			FejdStartup.instance.m_characterPreviewPoint.rotation = Quaternion.Euler(ChangeOfSceneryPlugin._defaultPlayerRotation);
			if (!((Object)(object)FejdStartup.instance.m_playerInstance == (Object)null))
			{
				FejdStartup.instance.m_playerInstance.transform.position = ChangeOfSceneryPlugin.m_characterPreviewPositionPreset1;
				FejdStartup.instance.m_playerInstance.transform.rotation = Quaternion.Euler(ChangeOfSceneryPlugin._defaultPlayerRotation);
				ChangeOfSceneryPlugin.MPlayerPosition.Value = ChangeOfSceneryPlugin.m_characterPreviewPositionPreset1;
				ChangeOfSceneryPlugin.MPlayerRotation.Value = ChangeOfSceneryPlugin._defaultPlayerRotation;
			}
		}

		internal static void UpdateCameraValues()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				FejdStartup.instance.m_cameraMarkerCharacter.position = ChangeOfSceneryPlugin.CharacterCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerCredits.position = ChangeOfSceneryPlugin.CreditsCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerGame.position = ChangeOfSceneryPlugin.GameCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerMain.position = ChangeOfSceneryPlugin.MainCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerStart.position = ChangeOfSceneryPlugin.StartCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerSaves.position = ChangeOfSceneryPlugin.SavesCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerCharacter.rotation = Quaternion.Euler(ChangeOfSceneryPlugin.CharacterCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerCredits.rotation = Quaternion.Euler(ChangeOfSceneryPlugin.CreditsCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerGame.rotation = Quaternion.Euler(ChangeOfSceneryPlugin.GameCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerMain.rotation = Quaternion.Euler(ChangeOfSceneryPlugin.MainCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerStart.rotation = Quaternion.Euler(ChangeOfSceneryPlugin.StartCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerSaves.rotation = Quaternion.Euler(ChangeOfSceneryPlugin.SavesCameraMarker_Rotation.Value);
			}
		}

		internal static void UpdatePlayerValues()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				FejdStartup.instance.m_characterPreviewPoint.position = ChangeOfSceneryPlugin.MPlayerPosition.Value;
				FejdStartup.instance.m_characterPreviewPoint.rotation = Quaternion.Euler(ChangeOfSceneryPlugin.MPlayerRotation.Value);
			}
		}

		internal static void UpdateAndSet()
		{
			if (ChangeOfSceneryPlugin.UsePreset.Value == ChangeOfSceneryPlugin.Toggle.On && ChangeOfSceneryPlugin.UseVanilla.Value == ChangeOfSceneryPlugin.Toggle.Off)
			{
				SetToCameraPresets();
				SetToPlayerPresets();
			}
			else if (ChangeOfSceneryPlugin.UseVanilla.Value == ChangeOfSceneryPlugin.Toggle.On && ChangeOfSceneryPlugin.UsePreset.Value == ChangeOfSceneryPlugin.Toggle.Off)
			{
				SetToCameraDefaults();
				SetToPlayerDefaults();
			}
			UpdateCameraValues();
			UpdatePlayerValues();
		}

		public static void CreateModListUI()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			scrollingTextElement = new GameObject("ModList Scrolling UI");
			scrollingTextElement.transform.SetParent(FejdStartup.instance.m_mainMenu.transform, false);
			ScrollRect val = scrollingTextElement.AddComponent<ScrollRect>();
			val.horizontal = false;
			val.vertical = true;
			val.movementType = (MovementType)2;
			val.elasticity = 0f;
			val.inertia = true;
			val.decelerationRate = 0.135f;
			val.scrollSensitivity = 40f;
			((Graphic)scrollingTextElement.AddComponent<Image>()).color = Color.clear;
			GameObject val2 = new GameObject("Mod List");
			val2.transform.SetParent(((Component)val).transform, false);
			val.content = val2.GetComponent<RectTransform>();
			VerticalLayoutGroup obj = val2.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			ContentSizeFitter obj2 = val2.AddComponent<ContentSizeFitter>();
			obj2.verticalFit = (FitMode)2;
			obj2.horizontalFit = (FitMode)0;
			Text val3 = val2.AddComponent<Text>();
			val3.text = "";
			val3.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			val3.fontSize = 20;
			((Graphic)val3).color = Color.white;
			string[] installedMods = GetInstalledMods();
			foreach (string text in installedMods)
			{
				val3.text = val3.text + text + "\n";
			}
			val3.alignment = (TextAnchor)0;
			RectTransform component = scrollingTextElement.GetComponent<RectTransform>();
			component.SetSizeWithCurrentAnchors((Axis)0, textElementWidth);
			component.SetSizeWithCurrentAnchors((Axis)1, textElementHeight);
			component.anchoredPosition = Vector2.zero;
			val.content = val2.GetComponent<RectTransform>();
			autoScrollingText = scrollingTextElement.AddComponent<AutoScrollingText>();
			autoScrollingText.scrollSpeed = scrollSpeed;
			autoScrollingText.inactivityDelay = inactivityDelay;
			autoScrollingText.scrollRect = val;
			autoScrollingText.textComponent = val3;
		}

		internal static string[] GetInstalledMods()
		{
			return Localization.instance.m_languages.ToArray();
		}
	}
	public class AutoScrollingText : MonoBehaviour
	{
		public float scrollSpeed;

		public float inactivityDelay;

		public ScrollRect scrollRect;

		public Text textComponent;

		private Coroutine scrollingCoroutine;

		private bool isScrolling;

		private void OnEnable()
		{
			StartScrolling();
		}

		private void OnDisable()
		{
			StopScrolling();
		}

		public void StartScrolling()
		{
			if (scrollingCoroutine == null)
			{
				scrollingCoroutine = ((MonoBehaviour)this).StartCoroutine(ScrollText());
			}
		}

		public void StopScrolling()
		{
			if (scrollingCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(scrollingCoroutine);
				scrollingCoroutine = null;
			}
		}

		private IEnumerator ScrollText()
		{
			while (true)
			{
				if (isScrolling)
				{
					scrollRect.verticalNormalizedPosition = Mathf.Max(0f, scrollRect.verticalNormalizedPosition - Time.deltaTime * scrollSpeed);
					yield return null;
				}
				else
				{
					yield return (object)new WaitForSeconds(inactivityDelay);
					isScrolling = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
	internal static class FejdStartupSetupGuiPatch
	{
		private static GameObject _props;

		public static GameObject _mMenuFire;

		public static GameObject clonedFire;

		private static void Postfix(FejdStartup __instance)
		{
			//IL_00c7: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			Functions.GatherDefaultCamLocations(__instance);
			Functions.GatherDefaultPlayerShit(__instance);
			try
			{
				_props = ((Component)Utils.FindChild(GameObject.Find("Static").transform, "props", (IterativeSearchType)0)).gameObject;
				_mMenuFire = GameObject.Find("MenuFire");
			}
			catch (Exception ex)
			{
				ChangeOfSceneryPlugin.ChangeOfSceneryLogger.LogError((object)ex);
			}
			if ((Object)(object)_props != (Object)null)
			{
				_props.gameObject.SetActive(true);
				((Component)Utils.FindChild(_props.transform, "Rocks", (IterativeSearchType)0)).gameObject.SetActive(true);
				((Component)Utils.FindChild(_props.transform, "ships", (IterativeSearchType)0)).gameObject.SetActive(true);
			}
			else
			{
				ChangeOfSceneryPlugin.ChangeOfSceneryLogger.LogError((object)"Props not found");
			}
			clonedFire = Object.Instantiate<GameObject>(_mMenuFire, ChangeOfSceneryPlugin.MFirePosition.Value, Quaternion.identity);
			TerrainModifier obj = clonedFire.AddComponent<TerrainModifier>();
			obj.m_level = true;
			obj.m_levelRadius = 4f;
			obj.m_smoothRadius = 8f;
			obj.m_smoothPower = 2f;
			obj.m_smooth = true;
			obj.m_paintCleared = true;
			obj.m_paintType = (PaintType)2;
			obj.m_paintRadius = 3f;
			Functions.UpdateAndSet();
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "UpdateCamera")]
	internal static class FejdStartupUpdateCameraPatch
	{
		private static void Postfix(FejdStartup __instance)
		{
			Functions.UpdateCameraValues();
			if (__instance.m_characterSelectScreen.activeSelf || __instance.m_creditsPanel.activeSelf)
			{
				((Behaviour)((Component)Utils.GetMainCamera()).GetComponent<DepthOfField>()).enabled = true;
			}
			else
			{
				((Behaviour)((Component)Utils.GetMainCamera()).GetComponent<DepthOfField>()).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "ShowCharacterSelection")]
	internal static class FejdStartupShowCharacterSelectionPatch
	{
		private static void Prefix(FejdStartup __instance)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (ChangeOfSceneryPlugin.UsePreset.Value == ChangeOfSceneryPlugin.Toggle.On)
			{
				Transform characterPreviewPoint = __instance.m_characterPreviewPoint;
				Quaternion rotation = __instance.m_cameraMarkerCharacter.rotation;
				characterPreviewPoint.rotation = Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y - 180f, 0f);
				if (Object.op_Implicit((Object)(object)__instance.m_playerInstance))
				{
					Transform transform = __instance.m_playerInstance.transform;
					rotation = __instance.m_cameraMarkerCharacter.rotation;
					transform.rotation = Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y - 180f, 0f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "OnCharacterStart")]
	internal static class FejdStartupOnCharacterStartPatch
	{
		private static void Prefix(FejdStartup __instance)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (ChangeOfSceneryPlugin.UsePreset.Value == ChangeOfSceneryPlugin.Toggle.On)
			{
				Transform characterPreviewPoint = __instance.m_characterPreviewPoint;
				Quaternion rotation = __instance.m_cameraMarkerCharacter.rotation;
				characterPreviewPoint.rotation = Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y - 40f, 0f);
				if (Object.op_Implicit((Object)(object)__instance.m_playerInstance))
				{
					Transform transform = __instance.m_playerInstance.transform;
					rotation = __instance.m_cameraMarkerCharacter.rotation;
					transform.rotation = Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y - 40f, 0f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(MusicMan), "TriggerMusic")]
	internal static class MusicManTriggerMusicPatch
	{
		public static AudioSource audioSource;

		public static Coroutine? AudioStart;

		private static void Postfix(MusicMan __instance, ref string name)
		{
			if (name == "menu")
			{
				if ((Object)(object)MusicMan.instance != (Object)null)
				{
					MusicMan.instance.Reset();
				}
				StreamAudio(ChangeOfSceneryPlugin.customsong.Value);
			}
		}

		public static void StreamAudio(string url)
		{
			AudioStart = ((MonoBehaviour)ChangeOfSceneryPlugin.instance).StartCoroutine(StreamAudioFromURL(url));
		}

		private static IEnumerator StreamAudioFromURL(string url)
		{
			UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, (AudioType)0);
			try
			{
				yield return www.SendWebRequest();
				while (!www.isDone)
				{
					yield return (object)new WaitForSeconds(0.1f);
				}
				Result result = www.result;
				if (result - 2 <= 2)
				{
					ChangeOfSceneryPlugin.ChangeOfSceneryLogger.LogError((object)www.error);
					yield break;
				}
				AudioClip content = DownloadHandlerAudioClip.GetContent(www);
				MusicMan.instance.FindMusic("menu").m_clips = (AudioClip[])(object)new AudioClip[1] { content };
				if ((Object)(object)MusicMan.instance.m_musicSource.clip != (Object)(object)content && (Object)(object)MusicMan.instance != (Object)null)
				{
					MusicMan.instance.m_musicSource.clip = content;
					((Behaviour)MusicMan.instance.m_musicSource).enabled = true;
					if (MusicMan.instance.m_musicSource.isPlaying)
					{
						MusicMan.instance.m_musicSource.Stop();
					}
					MusicMan.instance.m_musicSource.Play();
					MusicMan.instance.m_musicSource.loop = true;
					MusicMan.instance.m_musicSource.volume = 15f;
					ChangeOfSceneryPlugin.ChangeOfSceneryLogger.LogDebug((object)("Streaming audio from: " + url + "."));
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}
	}
	[HarmonyPatch(typeof(FejdStartup), "LoadMainScene")]
	internal static class LoadMainScenePatch
	{
		private static void Prefix(SceneManager __instance)
		{
			((MonoBehaviour)ChangeOfSceneryPlugin.instance).StopCoroutine(MusicManTriggerMusicPatch.AudioStart);
		}
	}
	[BepInPlugin("Azumatt.ChangeOfScenery", "ChangeOfScenery", "1.0.6")]
	public class ChangeOfSceneryPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public bool? Browsable = false;
		}

		internal const string ModName = "ChangeOfScenery";

		internal const string ModVersion = "1.0.6";

		internal const string Author = "Azumatt";

		private const string ModGUID = "Azumatt.ChangeOfScenery";

		private static string ConfigFileName = "Azumatt.ChangeOfScenery.cfg";

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

		private readonly Harmony _harmony = new Harmony("Azumatt.ChangeOfScenery");

		public static readonly ManualLogSource ChangeOfSceneryLogger;

		public static ChangeOfSceneryPlugin instance;

		public static Vector3 m_cameraMarkerCharacterPositionPreset1;

		public static Vector3 m_cameraMarkerCharacterRotationPreset1;

		public static Vector3 m_cameraMarkerCreditsPositionPreset1;

		public static Vector3 m_cameraMarkerCreditsRotationPreset1;

		public static Vector3 m_cameraMarkerStartPositionPreset1;

		public static Vector3 m_cameraMarkerStartRotationPreset1;

		public static Vector3 m_cameraMarkerGamePositionPreset1;

		public static Vector3 m_cameraMarkerGameRotationPreset1;

		public static Vector3 m_cameraMarkerSavesPositionPreset1;

		public static Vector3 m_cameraMarkerSavesRotationPreset1;

		public static Vector3 m_characterPreviewPositionPreset1;

		public static Vector3 m_characterPreviewRotationPreset1;

		internal static Vector3 defaultCharacterCameraMarker_Position;

		internal static Vector3 defaultCreditsCameraMarker_Position;

		internal static Vector3 defaultGameCameraMarker_Position;

		internal static Vector3 defaultMainCameraMarker_Position;

		internal static Vector3 defaultStartCameraMarker_Position;

		internal static Vector3 defaultSavesCameraMarker_Position;

		internal static Vector3 defaultCharacterCameraMarker_Rotation;

		internal static Vector3 defaultCreditsCameraMarker_Rotation;

		internal static Vector3 defaultGameCameraMarker_Rotation;

		internal static Vector3 defaultMainCameraMarker_Rotation;

		internal static Vector3 defaultStartCameraMarker_Rotation;

		internal static Vector3 defaultSavesCameraMarker_Rotation;

		internal static Transform _defaultPlayerPreviewPoint;

		internal static Vector3 _defaultPlayerPosition;

		internal static Vector3 _defaultPlayerRotation;

		internal static ConfigEntry<Toggle> UsePreset;

		internal static ConfigEntry<Toggle> UseVanilla;

		public static ConfigEntry<Vector3> CharacterCameraMarker_Position;

		public static ConfigEntry<Vector3> CreditsCameraMarker_Position;

		public static ConfigEntry<Vector3> GameCameraMarker_Position;

		public static ConfigEntry<Vector3> MainCameraMarker_Position;

		public static ConfigEntry<Vector3> StartCameraMarker_Position;

		public static ConfigEntry<Vector3> SavesCameraMarker_Position;

		public static ConfigEntry<Vector3> MPlayerPosition;

		public static ConfigEntry<Vector3> MFirePosition;

		public static ConfigEntry<Vector3> CharacterCameraMarker_Rotation;

		public static ConfigEntry<Vector3> CreditsCameraMarker_Rotation;

		public static ConfigEntry<Vector3> GameCameraMarker_Rotation;

		public static ConfigEntry<Vector3> MainCameraMarker_Rotation;

		public static ConfigEntry<Vector3> StartCameraMarker_Rotation;

		public static ConfigEntry<Vector3> SavesCameraMarker_Rotation;

		public static ConfigEntry<Vector3> MPlayerRotation;

		public static ConfigEntry<string> customsong;

		public void Awake()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			instance = this;
			UsePreset = config("1 - Presets", "Use Preset", Toggle.On, "Use the preset camera positions that I have come up with.");
			UseVanilla = config("1 - Presets", "Use Vanilla", Toggle.Off, "Use the preset camera positions the Valheim devs made.");
			UsePreset.SettingChanged += delegate
			{
				if (UsePreset.Value == Toggle.On)
				{
					UseVanilla.Value = Toggle.Off;
				}
				Functions.UpdateAndSet();
			};
			UseVanilla.SettingChanged += delegate
			{
				if (UseVanilla.Value == Toggle.On)
				{
					UsePreset.Value = Toggle.Off;
				}
				Functions.UpdateAndSet();
			};
			CharacterCameraMarker_Position = config<Vector3>("2 - Camera Markers", "Character", new Vector3(-161.89f, 55.97f, 230.13f), "The camera marker to use when in the character screen.");
			CharacterCameraMarker_Rotation = config<Vector3>("2 - Camera Markers", "Character Rotation", new Vector3(13.79f, -84.748f, 0f), "The camera marker to use when in the character screen.");
			CreditsCameraMarker_Position = config<Vector3>("2 - Camera Markers", "Credits", new Vector3(-156.8638f, 78.89107f, 225.6782f), "The camera marker to use when in the credits screen.");
			CreditsCameraMarker_Rotation = config<Vector3>("2 - Camera Markers", "Credits Rotation", new Vector3(-2.197f, -48.48f, 0f), "The camera marker to use when in the credits screen.");
			GameCameraMarker_Position = config<Vector3>("2 - Camera Markers", "Game", new Vector3(-157.8478f, 56.59023f, 229.9292f), "The camera marker to use when in the game screen.");
			GameCameraMarker_Rotation = config<Vector3>("2 - Camera Markers", "Game Rotation", new Vector3(-187.257f, 77.72f, 180f), "The camera marker to use when in the game screen.");
			MainCameraMarker_Position = config<Vector3>("2 - Camera Markers", "Main", new Vector3(-142.532f, 59f, 227.7245f), "The camera marker to use when in the main menu screen.");
			MainCameraMarker_Rotation = config<Vector3>("2 - Camera Markers", "Main Rotation", new Vector3(1.241f, -84.232f, 0f), "The camera marker to use when in the main menu screen.");
			StartCameraMarker_Position = config<Vector3>("2 - Camera Markers", "Start", new Vector3(-137.63f, 54.78f, 227.44f), "The camera marker to use when in the start screen.");
			StartCameraMarker_Rotation = config<Vector3>("2 - Camera Markers", "Start Rotation", new Vector3(41.028f, -84.232f, 0f), "The camera marker to use when in the start screen.");
			SavesCameraMarker_Position = config<Vector3>("2 - Camera Markers", "Saves", new Vector3(-163.02f, 60.34f, 228.74f), "The camera marker to use when in the saves screen.");
			SavesCameraMarker_Rotation = config<Vector3>("2 - Camera Markers", "Saves Rotation", new Vector3(185.79f, 81.743f, -180f), "The camera marker to use when in the saves screen.");
			CharacterCameraMarker_Position.SettingChanged += delegate
			{
				UpdateCameraPositions();
			};
			CreditsCameraMarker_Position.SettingChanged += delegate
			{
				UpdateCameraPositions();
			};
			GameCameraMarker_Position.SettingChanged += delegate
			{
				UpdateCameraPositions();
			};
			MainCameraMarker_Position.SettingChanged += delegate
			{
				UpdateCameraPositions();
			};
			StartCameraMarker_Position.SettingChanged += delegate
			{
				UpdateCameraPositions();
			};
			SavesCameraMarker_Position.SettingChanged += delegate
			{
				UpdateCameraPositions();
			};
			CharacterCameraMarker_Rotation.SettingChanged += delegate
			{
				UpdateCameraRotations();
			};
			CreditsCameraMarker_Rotation.SettingChanged += delegate
			{
				UpdateCameraRotations();
			};
			GameCameraMarker_Rotation.SettingChanged += delegate
			{
				UpdateCameraRotations();
			};
			MainCameraMarker_Rotation.SettingChanged += delegate
			{
				UpdateCameraRotations();
			};
			StartCameraMarker_Rotation.SettingChanged += delegate
			{
				UpdateCameraRotations();
			};
			SavesCameraMarker_Rotation.SettingChanged += delegate
			{
				UpdateCameraRotations();
			};
			MPlayerPosition = config<Vector3>("3 - Player Position", "Player Position", new Vector3(-204.51f, 36.5f, 157.53f), "The position to spawn the player at.");
			MPlayerRotation = config<Vector3>("3 - Player Position", "Player Rotation", new Vector3(13.79f, -84.748f, 0f), "The rotation to spawn the player at.");
			MPlayerPosition.SettingChanged += delegate
			{
				UpdatePlayerPosition();
			};
			MPlayerRotation.SettingChanged += delegate
			{
				UpdatePlayerPosition();
			};
			MFirePosition = config<Vector3>("3 - Fire Position", "Fire Position", new Vector3(-203.51f, 36.5f, 158.53f), "The position to spawn the Fire at.");
			MFirePosition.SettingChanged += delegate
			{
				UpdateFirePosition();
			};
			customsong = config("4 - Custom Song", "Custom Song", "https://cdn.pixabay.com/download/audio/2022/08/17/audio_a52363b467.mp3?filename=the-gift-pagan-norse-background-music-117479.mp3", "The song that will play at the main menu. Must be a direct link to the file, the bigger the file the more likely there is a delay in the song starting.");
			customsong.SettingChanged += delegate
			{
				SongChanged();
			};
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			SetupWatcher();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			customsong.SettingChanged -= delegate
			{
				SongChanged();
			};
			CharacterCameraMarker_Position.SettingChanged -= delegate
			{
				UpdateCameraPositions();
			};
			CreditsCameraMarker_Position.SettingChanged -= delegate
			{
				UpdateCameraPositions();
			};
			GameCameraMarker_Position.SettingChanged -= delegate
			{
				UpdateCameraPositions();
			};
			MainCameraMarker_Position.SettingChanged -= delegate
			{
				UpdateCameraPositions();
			};
			StartCameraMarker_Position.SettingChanged -= delegate
			{
				UpdateCameraPositions();
			};
			SavesCameraMarker_Position.SettingChanged -= delegate
			{
				UpdateCameraPositions();
			};
			CharacterCameraMarker_Rotation.SettingChanged -= delegate
			{
				UpdateCameraRotations();
			};
			CreditsCameraMarker_Rotation.SettingChanged -= delegate
			{
				UpdateCameraRotations();
			};
			GameCameraMarker_Rotation.SettingChanged -= delegate
			{
				UpdateCameraRotations();
			};
			MainCameraMarker_Rotation.SettingChanged -= delegate
			{
				UpdateCameraRotations();
			};
			StartCameraMarker_Rotation.SettingChanged -= delegate
			{
				UpdateCameraRotations();
			};
			SavesCameraMarker_Rotation.SettingChanged -= delegate
			{
				UpdateCameraRotations();
			};
			MPlayerPosition.SettingChanged -= delegate
			{
				UpdatePlayerPosition();
			};
			MPlayerRotation.SettingChanged -= delegate
			{
				UpdatePlayerPosition();
			};
			MFirePosition.SettingChanged -= delegate
			{
				UpdateFirePosition();
			};
		}

		private void UpdateCameraPositions()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				FejdStartup.instance.m_cameraMarkerCharacter.position = CharacterCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerCredits.position = CreditsCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerGame.position = GameCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerMain.position = MainCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerStart.position = StartCameraMarker_Position.Value;
				FejdStartup.instance.m_cameraMarkerSaves.position = SavesCameraMarker_Position.Value;
			}
		}

		private void UpdatePlayerPosition()
		{
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				GameObject val;
				try
				{
					val = GameObject.Find("Backgroundscene");
				}
				catch (Exception)
				{
					return;
				}
				if (!((Object)(object)val == (Object)null))
				{
					Functions.UpdatePlayerValues();
					FejdStartup.instance.UpdateCharacterList();
				}
			}
		}

		private void UpdateFirePosition()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				Transform transform = FejdStartupSetupGuiPatch.clonedFire.transform;
				if (!((Object)(object)transform == (Object)null))
				{
					transform.position = MFirePosition.Value;
				}
			}
		}

		private void UpdateCameraRotations()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FejdStartup.instance == (Object)null))
			{
				FejdStartup.instance.m_cameraMarkerCharacter.rotation = Quaternion.Euler(CharacterCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerCredits.rotation = Quaternion.Euler(CreditsCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerGame.rotation = Quaternion.Euler(GameCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerMain.rotation = Quaternion.Euler(MainCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerStart.rotation = Quaternion.Euler(StartCameraMarker_Rotation.Value);
				FejdStartup.instance.m_cameraMarkerSaves.rotation = Quaternion.Euler(SavesCameraMarker_Rotation.Value);
			}
		}

		internal void SongChanged()
		{
			if (!((Object)(object)FejdStartup.instance == (Object)null) && !((Object)(object)MusicMan.instance == (Object)null))
			{
				MusicMan.instance.Reset();
				MusicManTriggerMusicPatch.StreamAudio(customsong.Value);
			}
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				ChangeOfSceneryLogger.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				ChangeOfSceneryLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				ChangeOfSceneryLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description)
		{
			return ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, string description)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		static ChangeOfSceneryPlugin()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: 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)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			ChangeOfSceneryLogger = Logger.CreateLogSource("ChangeOfScenery");
			m_cameraMarkerCharacterPositionPreset1 = new Vector3(-206.2f, 39.34f, 162.26f);
			m_cameraMarkerCharacterRotationPreset1 = new Vector3(19.6f, -211f, 0f);
			m_cameraMarkerCreditsPositionPreset1 = new Vector3(-205.3f, 34.29f, 132.06f);
			m_cameraMarkerCreditsRotationPreset1 = new Vector3(19.6f, -211f, 0f);
			m_cameraMarkerStartPositionPreset1 = new Vector3(-208.54f, 32.2f, 131.38f);
			m_cameraMarkerStartRotationPreset1 = new Vector3(0.72f, -211f, 0f);
			m_cameraMarkerGamePositionPreset1 = new Vector3(-204.55f, 38f, 158.8f);
			m_cameraMarkerGameRotationPreset1 = new Vector3(-181.447f, -48.532f, -180f);
			m_cameraMarkerSavesPositionPreset1 = new Vector3(-208.45f, 45.76f, 131.23f);
			m_cameraMarkerSavesRotationPreset1 = new Vector3(0.72f, -211f, 131.23f);
			m_characterPreviewPositionPreset1 = new Vector3(-204.51f, 36.5f, 157.53f);
			m_characterPreviewRotationPreset1 = new Vector3(-180f, -75.30915f, 180f);
			defaultCharacterCameraMarker_Position = default(Vector3);
			defaultCreditsCameraMarker_Position = default(Vector3);
			defaultGameCameraMarker_Position = default(Vector3);
			defaultMainCameraMarker_Position = default(Vector3);
			defaultStartCameraMarker_Position = default(Vector3);
			defaultSavesCameraMarker_Position = default(Vector3);
			defaultCharacterCameraMarker_Rotation = default(Vector3);
			defaultCreditsCameraMarker_Rotation = default(Vector3);
			defaultGameCameraMarker_Rotation = default(Vector3);
			defaultMainCameraMarker_Rotation = default(Vector3);
			defaultStartCameraMarker_Rotation = default(Vector3);
			defaultSavesCameraMarker_Rotation = default(Vector3);
			_defaultPlayerPreviewPoint = null;
			_defaultPlayerPosition = default(Vector3);
			_defaultPlayerRotation = default(Vector3);
			UsePreset = null;
			UseVanilla = null;
			CharacterCameraMarker_Position = null;
			CreditsCameraMarker_Position = null;
			GameCameraMarker_Position = null;
			MainCameraMarker_Position = null;
			StartCameraMarker_Position = null;
			SavesCameraMarker_Position = null;
			MPlayerPosition = null;
			MFirePosition = null;
			CharacterCameraMarker_Rotation = null;
			CreditsCameraMarker_Rotation = null;
			GameCameraMarker_Rotation = null;
			MainCameraMarker_Rotation = null;
			StartCameraMarker_Rotation = null;
			SavesCameraMarker_Rotation = null;
			MPlayerRotation = null;
			customsong = null;
		}
	}
}