using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
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.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("VikingMessages")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyDescription("Elden Ring-inspired message system for Valheim")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Viking Messages")]
[assembly: AssemblyTitle("Viking Messages")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 VikingMessages
{
	[Serializable]
	public class VikingMessage
	{
		public string Id;

		public Vector3 Position;

		public Quaternion Rotation;

		public string Template;

		public string Words;

		public int EmoteIndex;

		public long AuthorId;

		public string AuthorName;

		public int Reputation;

		public List<long> VotedPlayers = new List<long>();

		public DateTime CreatedTime;

		public string[] EquippedItems = new string[0];

		public Vector3 LookDirection;
	}
	[Serializable]
	public class PlayerReputation
	{
		public long PlayerId;

		public string PlayerName;

		public int TotalReputation;

		public int MessageCount;

		public PlayerReputation()
		{
		}

		public PlayerReputation(long id, string name)
		{
			PlayerId = id;
			PlayerName = name;
			TotalReputation = 0;
			MessageCount = 0;
		}
	}
	[Serializable]
	public class LeaderboardData
	{
		public List<PlayerReputation> Players = new List<PlayerReputation>();
	}
	public class GhostPhantom : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <PlayEmoteDelayed>d__21 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string emoteName;

			public GhostPhantom <>4__this;

			private string <triggerName>5__1;

			private Exception <ex>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PlayEmoteDelayed>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<triggerName>5__1 = null;
				<ex>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)<>4__this._animator != (Object)null)
					{
						try
						{
							((Behaviour)<>4__this._animator).enabled = true;
							<>4__this._animator.speed = 0.7f;
							<triggerName>5__1 = "emote_" + emoteName.ToLower();
							ManualLogSource log = VikingMessagesPlugin.Log;
							if (log != null)
							{
								log.LogInfo((object)("Attempting to play emote trigger: " + <triggerName>5__1));
							}
							<>4__this._animator.SetTrigger(<triggerName>5__1);
							<triggerName>5__1 = null;
						}
						catch (Exception ex)
						{
							<ex>5__2 = ex;
							ManualLogSource log2 = VikingMessagesPlugin.Log;
							if (log2 != null)
							{
								log2.LogWarning((object)("Failed to play emote " + emoteName + ": " + <ex>5__2.Message));
							}
						}
					}
					else
					{
						ManualLogSource log3 = VikingMessagesPlugin.Log;
						if (log3 != null)
						{
							log3.LogWarning((object)"No animator available for ghost emote");
						}
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SetupGhostCoroutine>d__13 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GhostPhantom <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SetupGhostCoroutine>d__13(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						ManualLogSource log = VikingMessagesPlugin.Log;
						if (log != null)
						{
							log.LogWarning((object)"No local player for ghost clone");
						}
						<>4__this.CreateFallbackGhost();
					}
					else
					{
						<>4__this.CreatePlayerClone();
					}
					<>4__this.CreateGlowLight();
					<>4__this.Show();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private float _displayDuration = 5f;

		private float _currentTimer;

		private float _fadeInTime = 0.5f;

		private bool _isVisible;

		private List<Renderer> _renderers = new List<Renderer>();

		private static readonly Color GhostColor = new Color(0.85f, 0.9f, 1f, 0.7f);

		private GameObject _visualClone;

		private Animator _animator;

		private Light _glowLight;

		private string _pendingEmote;

		private VikingMessage _message;

		public void Initialize(VikingMessage message, float duration = 5f)
		{
			_message = message;
			_displayDuration = duration;
			_pendingEmote = GetEmoteName(message.EmoteIndex);
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"GhostPhantom.Initialize: emote={_pendingEmote}, emoteIndex={message.EmoteIndex}");
			}
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(SetupGhostCoroutine());
		}

		[IteratorStateMachine(typeof(<SetupGhostCoroutine>d__13))]
		private IEnumerator SetupGhostCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetupGhostCoroutine>d__13(0)
			{
				<>4__this = this
			};
		}

		private void CreatePlayerClone()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Player localPlayer = Player.m_localPlayer;
				Transform val = ((Component)localPlayer).transform.Find("Visual");
				if ((Object)(object)val == (Object)null)
				{
					ManualLogSource log = VikingMessagesPlugin.Log;
					if (log != null)
					{
						log.LogWarning((object)"Could not find Visual transform on player");
					}
					CreateFallbackGhost();
					return;
				}
				_visualClone = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)this).transform);
				((Object)_visualClone).name = "GhostVisual";
				_visualClone.transform.localPosition = Vector3.zero;
				_visualClone.transform.localRotation = Quaternion.identity;
				_visualClone.transform.localScale = Vector3.one;
				_animator = _visualClone.GetComponent<Animator>();
				if ((Object)(object)_animator == (Object)null)
				{
					_animator = _visualClone.GetComponentInChildren<Animator>();
				}
				DisableComponents(_visualClone);
				Renderer[] componentsInChildren = _visualClone.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val2 in componentsInChildren)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						val2.enabled = true;
						SkinnedMeshRenderer val3 = (SkinnedMeshRenderer)(object)((val2 is SkinnedMeshRenderer) ? val2 : null);
						if (val3 != null)
						{
							val3.updateWhenOffscreen = true;
						}
					}
				}
				Transform[] componentsInChildren2 = _visualClone.GetComponentsInChildren<Transform>(true);
				foreach (Transform val4 in componentsInChildren2)
				{
					if ((Object)(object)val4 != (Object)null && (Object)(object)((Component)val4).gameObject != (Object)null)
					{
						((Component)val4).gameObject.SetActive(true);
					}
				}
				ApplyGhostMaterials(_visualClone);
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"Ghost clone created successfully with {_renderers.Count} renderers");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log3 = VikingMessagesPlugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)$"Failed to create player clone: {arg}");
				}
				CreateFallbackGhost();
			}
		}

		private void DisableComponents(GameObject obj)
		{
			MonoBehaviour[] componentsInChildren = obj.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)this)
				{
					((Behaviour)val).enabled = false;
				}
			}
			ZNetView[] componentsInChildren2 = obj.GetComponentsInChildren<ZNetView>(true);
			foreach (ZNetView val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Destroy((Object)(object)val2);
				}
			}
			ZSyncTransform[] componentsInChildren3 = obj.GetComponentsInChildren<ZSyncTransform>(true);
			foreach (ZSyncTransform val3 in componentsInChildren3)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					Object.Destroy((Object)(object)val3);
				}
			}
			ZSyncAnimation[] componentsInChildren4 = obj.GetComponentsInChildren<ZSyncAnimation>(true);
			foreach (ZSyncAnimation val4 in componentsInChildren4)
			{
				if ((Object)(object)val4 != (Object)null)
				{
					Object.Destroy((Object)(object)val4);
				}
			}
			VisEquipment[] componentsInChildren5 = obj.GetComponentsInChildren<VisEquipment>(true);
			foreach (VisEquipment val5 in componentsInChildren5)
			{
				if ((Object)(object)val5 != (Object)null)
				{
					Object.Destroy((Object)(object)val5);
				}
			}
			Collider[] componentsInChildren6 = obj.GetComponentsInChildren<Collider>(true);
			foreach (Collider val6 in componentsInChildren6)
			{
				if ((Object)(object)val6 != (Object)null)
				{
					val6.enabled = false;
				}
			}
			ParticleSystem[] componentsInChildren7 = obj.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val7 in componentsInChildren7)
			{
				if ((Object)(object)val7 != (Object)null)
				{
					val7.Stop();
				}
			}
			AudioSource[] componentsInChildren8 = obj.GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val8 in componentsInChildren8)
			{
				if ((Object)(object)val8 != (Object)null)
				{
					((Behaviour)val8).enabled = false;
				}
			}
		}

		private void ApplyGhostMaterials(GameObject obj)
		{
			_renderers.Clear();
			Renderer[] componentsInChildren = obj.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					_renderers.Add(val);
					Material[] array = (Material[])(object)new Material[val.sharedMaterials.Length];
					for (int j = 0; j < val.sharedMaterials.Length; j++)
					{
						Material val2 = CreateGhostMaterial(val.sharedMaterials[j]);
						array[j] = val2;
					}
					val.materials = array;
				}
			}
		}

		private Material CreateGhostMaterial(Material sourceMat)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0056: 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)
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Sprites/Default");
			}
			Material val2 = new Material(val);
			if ((Object)(object)sourceMat != (Object)null && sourceMat.HasProperty("_MainTex"))
			{
				val2.mainTexture = sourceMat.mainTexture;
			}
			val2.color = GhostColor;
			val2.SetFloat("_Mode", 3f);
			val2.SetInt("_SrcBlend", 5);
			val2.SetInt("_DstBlend", 10);
			val2.SetInt("_ZWrite", 0);
			val2.DisableKeyword("_ALPHATEST_ON");
			val2.EnableKeyword("_ALPHABLEND_ON");
			val2.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			val2.renderQueue = 3000;
			val2.EnableKeyword("_EMISSION");
			val2.SetColor("_EmissionColor", new Color(0.3f, 0.4f, 0.5f));
			return val2;
		}

		private void CreateFallbackGhost()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"Creating fallback ghost (primitive shapes)");
			}
			Material val = CreateGhostMaterial(null);
			GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)1);
			((Object)val2).name = "GhostBody";
			val2.transform.SetParent(((Component)this).transform);
			val2.transform.localPosition = new Vector3(0f, 1f, 0f);
			val2.transform.localScale = new Vector3(0.5f, 0.7f, 0.35f);
			Object.Destroy((Object)(object)val2.GetComponent<Collider>());
			Renderer component = val2.GetComponent<Renderer>();
			component.material = val;
			_renderers.Add(component);
			GameObject val3 = GameObject.CreatePrimitive((PrimitiveType)0);
			((Object)val3).name = "GhostHead";
			val3.transform.SetParent(((Component)this).transform);
			val3.transform.localPosition = new Vector3(0f, 1.85f, 0f);
			val3.transform.localScale = new Vector3(0.35f, 0.35f, 0.35f);
			Object.Destroy((Object)(object)val3.GetComponent<Collider>());
			Renderer component2 = val3.GetComponent<Renderer>();
			component2.material = Object.Instantiate<Material>(val);
			_renderers.Add(component2);
			GameObject val4 = GameObject.CreatePrimitive((PrimitiveType)1);
			val4.transform.SetParent(((Component)this).transform);
			val4.transform.localPosition = new Vector3(-0.4f, 1.2f, 0f);
			val4.transform.localRotation = Quaternion.Euler(0f, 0f, 30f);
			val4.transform.localScale = new Vector3(0.12f, 0.35f, 0.12f);
			Object.Destroy((Object)(object)val4.GetComponent<Collider>());
			val4.GetComponent<Renderer>().material = Object.Instantiate<Material>(val);
			_renderers.Add(val4.GetComponent<Renderer>());
			GameObject val5 = GameObject.CreatePrimitive((PrimitiveType)1);
			val5.transform.SetParent(((Component)this).transform);
			val5.transform.localPosition = new Vector3(0.4f, 1.2f, 0f);
			val5.transform.localRotation = Quaternion.Euler(0f, 0f, -30f);
			val5.transform.localScale = new Vector3(0.12f, 0.35f, 0.12f);
			Object.Destroy((Object)(object)val5.GetComponent<Collider>());
			val5.GetComponent<Renderer>().material = Object.Instantiate<Material>(val);
			_renderers.Add(val5.GetComponent<Renderer>());
		}

		private void CreateGlowLight()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0033: 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)
			GameObject val = new GameObject("GhostLight");
			val.transform.SetParent(((Component)this).transform);
			val.transform.localPosition = new Vector3(0f, 1.2f, 0f);
			_glowLight = val.AddComponent<Light>();
			_glowLight.type = (LightType)2;
			_glowLight.color = new Color(0.7f, 0.8f, 1f);
			_glowLight.intensity = 0.8f;
			_glowLight.range = 3f;
			_glowLight.shadows = (LightShadows)0;
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
			_isVisible = true;
			_currentTimer = _displayDuration;
			if (!string.IsNullOrEmpty(_pendingEmote))
			{
				((MonoBehaviour)this).StartCoroutine(PlayEmoteDelayed(_pendingEmote));
			}
			UpdateAlpha(0f);
		}

		[IteratorStateMachine(typeof(<PlayEmoteDelayed>d__21))]
		private IEnumerator PlayEmoteDelayed(string emoteName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayEmoteDelayed>d__21(0)
			{
				<>4__this = this,
				emoteName = emoteName
			};
		}

		public void Hide()
		{
			_isVisible = false;
			((Component)this).gameObject.SetActive(false);
			foreach (Renderer renderer in _renderers)
			{
				if (!((Object)(object)renderer != (Object)null))
				{
					continue;
				}
				Material[] materials = renderer.materials;
				foreach (Material val in materials)
				{
					if ((Object)(object)val != (Object)null)
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
			Object.Destroy((Object)(object)((Component)this).gameObject, 0.1f);
		}

		private void Update()
		{
			if (_isVisible)
			{
				_currentTimer -= Time.deltaTime;
				EnsureRenderersEnabled();
				float num = _displayDuration - _currentTimer;
				float num2 = 2f;
				float alpha = ((num < _fadeInTime) ? (num / _fadeInTime * 0.7f) : ((!(_currentTimer < num2)) ? 0.7f : (_currentTimer / num2 * 0.7f)));
				UpdateAlpha(alpha);
				if ((Object)(object)_glowLight != (Object)null)
				{
					_glowLight.intensity = 0.6f + Mathf.Sin(Time.time * 3f) * 0.2f;
				}
				if (_currentTimer <= 0f)
				{
					Hide();
				}
			}
		}

		private void EnsureRenderersEnabled()
		{
			if ((Object)(object)_visualClone == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = _visualClone.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && !val.enabled)
				{
					val.enabled = true;
				}
			}
			Transform[] componentsInChildren2 = _visualClone.GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)null && !((Component)val2).gameObject.activeSelf && ((Object)(object)((Component)val2).GetComponent<Renderer>() != (Object)null || (Object)(object)((Component)val2).GetComponent<SkinnedMeshRenderer>() != (Object)null))
				{
					((Component)val2).gameObject.SetActive(true);
				}
			}
		}

		private void UpdateAlpha(float alpha)
		{
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			Color ghostColor = GhostColor;
			ghostColor.a = alpha;
			foreach (Renderer renderer in _renderers)
			{
				if ((Object)(object)renderer == (Object)null)
				{
					continue;
				}
				Material[] materials = renderer.materials;
				foreach (Material val in materials)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.color = ghostColor;
					}
				}
			}
		}

		private string GetEmoteName(int emoteIndex)
		{
			List<string> availableEmotes = MessageTemplates.AvailableEmotes;
			if (availableEmotes != null && emoteIndex >= 0 && emoteIndex < availableEmotes.Count)
			{
				return availableEmotes[emoteIndex];
			}
			return "wave";
		}

		private void OnDestroy()
		{
			foreach (Renderer renderer in _renderers)
			{
				if (!((Object)(object)renderer != (Object)null))
				{
					continue;
				}
				Material[] materials = renderer.materials;
				foreach (Material val in materials)
				{
					if ((Object)(object)val != (Object)null)
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
			_renderers.Clear();
		}
	}
	public static class GhostPhantomManager
	{
		private static GhostPhantom _currentGhost;

		public static void ShowGhost(Vector3 position, Quaternion rotation, VikingMessage message, float duration = 5f)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0035: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_currentGhost != (Object)null)
				{
					_currentGhost.Hide();
					_currentGhost = null;
				}
				GameObject val = new GameObject("VikingMessageGhost");
				val.transform.position = position;
				val.transform.rotation = rotation;
				_currentGhost = val.AddComponent<GhostPhantom>();
				_currentGhost.Initialize(message, duration);
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Ghost spawned at {position} with rotation {((Quaternion)(ref rotation)).eulerAngles}");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Failed to spawn ghost: {arg}");
				}
			}
		}

		public static void HideCurrentGhost()
		{
			if ((Object)(object)_currentGhost != (Object)null)
			{
				_currentGhost.Hide();
				_currentGhost = null;
			}
		}

		public static void Cleanup()
		{
			HideCurrentGhost();
		}
	}
	public static class LeaderboardManager
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__CloseLeaderboard;
		}

		private static GameObject _leaderboardUI;

		private static bool _isVisible;

		private static bool _hasStealthBuff;

		private static bool _hasCarryBuff;

		public const float CARRY_WEIGHT_BONUS = 500f;

		private static SE_Stats _reputationBuff;

		private const string BUFF_NAME = "SE_ReputationTop3";

		public static bool IsVisible => _isVisible;

		public static void ShowLeaderboard()
		{
			if ((Object)(object)_leaderboardUI != (Object)null)
			{
				CloseLeaderboard();
				return;
			}
			CreateLeaderboardUI();
			_isVisible = true;
			GUIManager.BlockInput(true);
		}

		public static void CloseLeaderboard()
		{
			if ((Object)(object)_leaderboardUI != (Object)null)
			{
				Object.Destroy((Object)(object)_leaderboardUI);
				_leaderboardUI = null;
			}
			_isVisible = false;
			GUIManager.BlockInput(false);
		}

		private static void CreateLeaderboardUI()
		{
			//IL_0044: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			if (GUIManager.Instance == null)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"GUIManager not ready");
				}
				return;
			}
			try
			{
				_leaderboardUI = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 500f, 550f, false);
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("CreateWoodpanel failed: " + ex.Message));
				}
			}
			if ((Object)(object)_leaderboardUI == (Object)null)
			{
				_leaderboardUI = CreateFallbackPanel();
			}
			if ((Object)(object)_leaderboardUI == (Object)null)
			{
				ManualLogSource log3 = VikingMessagesPlugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)"Failed to create leaderboard UI");
				}
			}
			else
			{
				PopulateLeaderboardContent();
			}
		}

		private static GameObject CreateFallbackPanel()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VikingMessages_LeaderboardCanvas");
			Canvas val2 = val.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)0;
			val2.sortingOrder = 100;
			CanvasScaler val3 = val.AddComponent<CanvasScaler>();
			val3.uiScaleMode = (ScaleMode)1;
			val3.referenceResolution = new Vector2(1920f, 1080f);
			val.AddComponent<GraphicRaycaster>();
			GameObject val4 = new GameObject("Panel");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.sizeDelta = new Vector2(500f, 550f);
			val5.anchorMin = new Vector2(0.5f, 0.5f);
			val5.anchorMax = new Vector2(0.5f, 0.5f);
			val5.anchoredPosition = Vector2.zero;
			Image val6 = val4.AddComponent<Image>();
			((Graphic)val6).color = new Color(0.18f, 0.12f, 0.08f, 0.97f);
			CreateBorderFrame(val4.transform, new Vector2(500f, 550f));
			return val4;
		}

		private static void CreateBorderFrame(Transform parent, Vector2 size)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0031: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00b1: 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_00d2: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0138: 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)
			//IL_015f: 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_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("OuterBorder");
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(0.6f, 0.45f, 0.2f);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(size.x + 8f, size.y + 8f);
			component.anchoredPosition = Vector2.zero;
			val.transform.SetAsFirstSibling();
			GameObject val3 = new GameObject("InnerBorder");
			val3.transform.SetParent(parent, false);
			Image val4 = val3.AddComponent<Image>();
			((Graphic)val4).color = new Color(0.1f, 0.07f, 0.04f);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.sizeDelta = new Vector2(size.x + 4f, size.y + 4f);
			component2.anchoredPosition = Vector2.zero;
			val3.transform.SetSiblingIndex(1);
			GameObject val5 = new GameObject("TopBar");
			val5.transform.SetParent(parent, false);
			Image val6 = val5.AddComponent<Image>();
			((Graphic)val6).color = new Color(0.5f, 0.38f, 0.18f);
			RectTransform component3 = val5.GetComponent<RectTransform>();
			component3.sizeDelta = new Vector2(size.x - 40f, 4f);
			component3.anchorMin = new Vector2(0.5f, 1f);
			component3.anchorMax = new Vector2(0.5f, 1f);
			component3.anchoredPosition = new Vector2(0f, -25f);
			GameObject val7 = new GameObject("BottomBar");
			val7.transform.SetParent(parent, false);
			Image val8 = val7.AddComponent<Image>();
			((Graphic)val8).color = new Color(0.5f, 0.38f, 0.18f);
			RectTransform component4 = val7.GetComponent<RectTransform>();
			component4.sizeDelta = new Vector2(size.x - 40f, 4f);
			component4.anchorMin = new Vector2(0.5f, 0f);
			component4.anchorMax = new Vector2(0.5f, 0f);
			component4.anchoredPosition = new Vector2(0f, 25f);
		}

		private static void PopulateLeaderboardContent()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.Instance;
			Font font = ((instance != null) ? instance.AveriaSerifBold : null);
			Font font2 = ((instance != null) ? instance.AveriaSerif : null);
			Color color = (Color)(((??)instance?.ValheimOrange) ?? new Color(1f, 0.64f, 0.1f));
			CreateStyledText(_leaderboardUI.transform, "Reputation Leaderboard", new Vector2(0f, -40f), 28, color, font, (TextAnchor)4, outline: true);
			CreateStyledText(_leaderboardUI.transform, "Top 3 players gain +100% Stamina Regen & +500 Carry Weight", new Vector2(0f, -75f), 14, new Color(0.85f, 0.8f, 0.65f), font2, (TextAnchor)4, outline: true);
			CreateStyledText(_leaderboardUI.transform, "[F7] Toggle", new Vector2(0f, -95f), 12, new Color(0.6f, 0.55f, 0.4f), font2, (TextAnchor)4, outline: false);
			CreateStyledText(_leaderboardUI.transform, "Rank", new Vector2(-180f, -130f), 16, color, font, (TextAnchor)4, outline: true, bottomAnchor: false, 60f);
			CreateStyledText(_leaderboardUI.transform, "Player", new Vector2(-50f, -130f), 16, color, font, (TextAnchor)3, outline: true, bottomAnchor: false, 150f);
			CreateStyledText(_leaderboardUI.transform, "Reputation", new Vector2(140f, -130f), 16, color, font, (TextAnchor)4, outline: true, bottomAnchor: false, 100f);
			CreateDividerLine(_leaderboardUI.transform, new Vector2(0f, -150f), 420f);
			List<PlayerReputation> leaderboard = MessageManagerAlt.GetLeaderboard();
			float num = -175f;
			int num2 = 1;
			foreach (PlayerReputation item in leaderboard.Take(12))
			{
				bool flag = num2 <= 3;
				Color val = (Color)(flag ? GetRankColor(num2) : new Color(0.9f, 0.85f, 0.7f));
				if (flag)
				{
					CreateRowHighlight(_leaderboardUI.transform, new Vector2(0f, num), val);
				}
				string rankDisplay = GetRankDisplay(num2);
				CreateStyledText(_leaderboardUI.transform, rankDisplay, new Vector2(-180f, num), 16, val, font, (TextAnchor)4, outline: true, bottomAnchor: false, 60f);
				string text = item.PlayerName ?? "Unknown";
				if (string.IsNullOrEmpty(text) || string.IsNullOrWhiteSpace(text))
				{
					text = "Anonymous";
				}
				if (text.Length > 18)
				{
					text = text.Substring(0, 15) + "...";
				}
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Leaderboard display: rank={num2}, name='{text}', rep={item.TotalReputation}");
				}
				CreateStyledText(_leaderboardUI.transform, text, new Vector2(-50f, num), 15, val, font2, (TextAnchor)3, outline: true, bottomAnchor: false, 150f);
				CreateStyledText(_leaderboardUI.transform, item.TotalReputation.ToString(), new Vector2(140f, num), 16, val, font, (TextAnchor)4, outline: true, bottomAnchor: false, 100f);
				num -= 32f;
				num2++;
			}
			if (leaderboard.Count == 0)
			{
				CreateStyledText(_leaderboardUI.transform, "No reputation data yet!", new Vector2(0f, -220f), 18, new Color(0.75f, 0.7f, 0.55f), font, (TextAnchor)4, outline: true);
				CreateStyledText(_leaderboardUI.transform, "Place messages and earn votes to appear here.", new Vector2(0f, -255f), 14, new Color(0.6f, 0.55f, 0.45f), font2, (TextAnchor)4, outline: true);
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				long playerID = Player.m_localPlayer.GetPlayerID();
				if (MessageManagerAlt.IsPlayerInTop3(playerID))
				{
					CreateStyledText(_leaderboardUI.transform, "★ You are in the Top 3! Buffs Active ★", new Vector2(0f, 80f), 16, new Color(0.4f, 1f, 0.4f), font, (TextAnchor)4, outline: true, bottomAnchor: true);
				}
			}
			CreateCloseButton(_leaderboardUI.transform);
		}

		private static void CreateStyledText(Transform parent, string text, Vector2 position, int fontSize, Color color, Font font, TextAnchor alignment, bool outline, bool bottomAnchor = false, float width = 400f)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0062: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text_" + text.Substring(0, Math.Min(10, text.Length)));
			val.transform.SetParent(parent, false);
			Text val2 = val.AddComponent<Text>();
			val2.text = text;
			val2.font = font ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			val2.fontSize = fontSize;
			((Graphic)val2).color = color;
			val2.alignment = alignment;
			val2.horizontalOverflow = (HorizontalWrapMode)1;
			val2.verticalOverflow = (VerticalWrapMode)1;
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(width, 30f);
			if (bottomAnchor)
			{
				component.anchorMin = new Vector2(0.5f, 0f);
				component.anchorMax = new Vector2(0.5f, 0f);
			}
			else
			{
				component.anchorMin = new Vector2(0.5f, 1f);
				component.anchorMax = new Vector2(0.5f, 1f);
			}
			component.anchoredPosition = position;
			if (outline)
			{
				Outline val3 = val.AddComponent<Outline>();
				((Shadow)val3).effectColor = Color.black;
				((Shadow)val3).effectDistance = new Vector2(1f, -1f);
			}
		}

		private static void CreateDividerLine(Transform parent, Vector2 position, float width)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Divider");
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(0.5f, 0.4f, 0.25f);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(width, 2f);
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.anchoredPosition = position;
		}

		private static void CreateRowHighlight(Transform parent, Vector2 position, Color baseColor)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0068: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("RowHighlight");
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(baseColor.r * 0.25f, baseColor.g * 0.25f, baseColor.b * 0.15f, 0.4f);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(420f, 28f);
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.anchoredPosition = position;
			val.transform.SetSiblingIndex(3);
		}

		private static void CreateCloseButton(Transform parent)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_01f1: Expected O, but got Unknown
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_0027: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			GUIManager instance = GUIManager.Instance;
			if (instance != null)
			{
				try
				{
					GameObject val = instance.CreateButton("Close", parent, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 45f), 140f, 45f);
					if ((Object)(object)val != (Object)null)
					{
						Button component = val.GetComponent<Button>();
						if (component != null)
						{
							ButtonClickedEvent onClick = component.onClick;
							object obj = <>O.<0>__CloseLeaderboard;
							if (obj == null)
							{
								UnityAction val2 = CloseLeaderboard;
								<>O.<0>__CloseLeaderboard = val2;
								obj = (object)val2;
							}
							((UnityEvent)onClick).AddListener((UnityAction)obj);
						}
						return;
					}
				}
				catch
				{
				}
			}
			GameObject val3 = new GameObject("CloseButton");
			val3.transform.SetParent(parent, false);
			Image val4 = val3.AddComponent<Image>();
			((Graphic)val4).color = new Color(0.35f, 0.25f, 0.15f);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.sizeDelta = new Vector2(140f, 45f);
			component2.anchorMin = new Vector2(0.5f, 0f);
			component2.anchorMax = new Vector2(0.5f, 0f);
			component2.anchoredPosition = new Vector2(0f, 45f);
			Button val5 = val3.AddComponent<Button>();
			((Selectable)val5).targetGraphic = (Graphic)(object)val4;
			ColorBlock colors = ((Selectable)val5).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.35f, 0.25f, 0.15f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.45f, 0.35f, 0.2f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.25f, 0.18f, 0.1f);
			((Selectable)val5).colors = colors;
			ButtonClickedEvent onClick2 = val5.onClick;
			object obj3 = <>O.<0>__CloseLeaderboard;
			if (obj3 == null)
			{
				UnityAction val6 = CloseLeaderboard;
				<>O.<0>__CloseLeaderboard = val6;
				obj3 = (object)val6;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj3);
			GameObject val7 = new GameObject("Border");
			val7.transform.SetParent(val3.transform, false);
			Image val8 = val7.AddComponent<Image>();
			((Graphic)val8).color = new Color(0.55f, 0.42f, 0.22f);
			RectTransform component3 = val7.GetComponent<RectTransform>();
			component3.sizeDelta = new Vector2(144f, 49f);
			component3.anchoredPosition = Vector2.zero;
			val7.transform.SetAsFirstSibling();
			GameObject val9 = new GameObject("Text");
			val9.transform.SetParent(val3.transform, false);
			Text val10 = val9.AddComponent<Text>();
			val10.text = "Close";
			val10.font = ((instance != null) ? instance.AveriaSerifBold : null) ?? Resources.GetBuiltinResource<Font>("Arial.ttf");
			val10.fontSize = 18;
			((Graphic)val10).color = new Color(1f, 0.9f, 0.7f);
			val10.alignment = (TextAnchor)4;
			RectTransform component4 = val9.GetComponent<RectTransform>();
			component4.sizeDelta = new Vector2(140f, 45f);
			component4.anchoredPosition = Vector2.zero;
			Outline val11 = val9.AddComponent<Outline>();
			((Shadow)val11).effectColor = Color.black;
			((Shadow)val11).effectDistance = new Vector2(1f, -1f);
		}

		private static string GetRankDisplay(int rank)
		{
			return rank switch
			{
				1 => "1st", 
				2 => "2nd", 
				3 => "3rd", 
				_ => rank.ToString(), 
			};
		}

		private static Color GetRankColor(int rank)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(rank switch
			{
				1 => new Color(1f, 0.84f, 0f), 
				2 => new Color(0.78f, 0.78f, 0.8f), 
				3 => new Color(0.85f, 0.55f, 0.25f), 
				_ => Color.white, 
			});
		}

		public static void CheckAndApplyBuffs()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				long playerID = Player.m_localPlayer.GetPlayerID();
				bool flag = MessageManagerAlt.IsPlayerInTop3(playerID);
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"CheckAndApplyBuffs: localId={playerID}, shouldHave={flag}, hasCarry={_hasCarryBuff}");
				}
				if (flag && !_hasCarryBuff)
				{
					ApplyBuffs();
				}
				else if (!flag && _hasCarryBuff)
				{
					RemoveBuffs();
				}
			}
		}

		private static void ApplyBuffs()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			_hasCarryBuff = true;
			_hasStealthBuff = true;
			try
			{
				SEMan sEMan = ((Character)Player.m_localPlayer).GetSEMan();
				if (sEMan != null)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode("SE_ReputationTop3");
					StatusEffect statusEffect = sEMan.GetStatusEffect(stableHashCode);
					if ((Object)(object)statusEffect != (Object)null)
					{
						sEMan.RemoveStatusEffect(statusEffect, false);
					}
					SE_Stats val = ScriptableObject.CreateInstance<SE_Stats>();
					((Object)val).name = "SE_ReputationTop3";
					((StatusEffect)val).m_name = "Reputation Champion";
					((StatusEffect)val).m_tooltip = "Top 3 Reputation Bonus:\n• +500 Carry Weight\n• +100% Stamina Regeneration";
					try
					{
						string[] array = new string[5] { "Thunderstone", "DragonTear", "SurtlingCore", "Coins", "Ruby" };
						string[] array2 = array;
						foreach (string text in array2)
						{
							ObjectDB instance = ObjectDB.instance;
							GameObject val2 = ((instance != null) ? instance.GetItemPrefab(text) : null);
							if (!((Object)(object)val2 != (Object)null))
							{
								continue;
							}
							ItemDrop component = val2.GetComponent<ItemDrop>();
							if ((Object)(object)component != (Object)null && component.m_itemData?.m_shared?.m_icons != null && component.m_itemData.m_shared.m_icons.Length != 0)
							{
								((StatusEffect)val).m_icon = component.m_itemData.m_shared.m_icons[0];
								ManualLogSource log = VikingMessagesPlugin.Log;
								if (log != null)
								{
									log.LogInfo((object)("Using icon from " + text));
								}
								break;
							}
						}
						if ((Object)(object)((StatusEffect)val).m_icon == (Object)null)
						{
							ObjectDB instance2 = ObjectDB.instance;
							StatusEffect val3 = ((instance2 != null) ? instance2.GetStatusEffect(StringExtensionMethods.GetStableHashCode("Rested")) : null);
							if ((Object)(object)val3 != (Object)null && (Object)(object)val3.m_icon != (Object)null)
							{
								((StatusEffect)val).m_icon = val3.m_icon;
							}
						}
					}
					catch
					{
					}
					val.m_addMaxCarryWeight = 500f;
					val.m_staminaRegenMultiplier = 2f;
					((StatusEffect)val).m_ttl = 0f;
					sEMan.AddStatusEffect((StatusEffect)(object)val, false, 0, 0f);
					_reputationBuff = val;
					ManualLogSource log2 = VikingMessagesPlugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"Top 3 buffs applied via StatusEffect (hash={stableHashCode}): +500 carry, +100% stamina regen");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = VikingMessagesPlugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("Failed to apply StatusEffect buff: " + ex.Message));
				}
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, "<color=yellow>Top 3 Reputation Bonus Active!</color>\n+500 Carry Weight & +100% Stamina Regen", 0, (Sprite)null);
			}
		}

		private static void RemoveBuffs()
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			try
			{
				SEMan sEMan = ((Character)Player.m_localPlayer).GetSEMan();
				if (sEMan != null)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode("SE_ReputationTop3");
					StatusEffect statusEffect = sEMan.GetStatusEffect(stableHashCode);
					if ((Object)(object)statusEffect != (Object)null)
					{
						sEMan.RemoveStatusEffect(statusEffect, false);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Failed to remove buff: " + ex.Message));
				}
			}
			_hasCarryBuff = false;
			_hasStealthBuff = false;
			_reputationBuff = null;
			ManualLogSource log2 = VikingMessagesPlugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)"Top 3 buffs removed");
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, "<color=#888888>Reputation Bonus Removed</color>", 0, (Sprite)null);
			}
		}

		public static bool HasStealthBuff()
		{
			return _hasStealthBuff;
		}

		public static float GetCarryWeightBonus()
		{
			return _hasCarryBuff ? 500f : 0f;
		}

		public static void Update()
		{
			if (_isVisible && Input.GetKeyDown((KeyCode)27))
			{
				CloseLeaderboard();
			}
			else if (Input.GetKeyDown((KeyCode)288))
			{
				if (_isVisible)
				{
					CloseLeaderboard();
				}
				else if ((Object)(object)Player.m_localPlayer != (Object)null && !InventoryGui.IsVisible() && !Menu.IsVisible() && !Console.IsVisible())
				{
					ShowLeaderboard();
				}
			}
		}
	}
	[HarmonyPatch]
	public static class LeaderboardPatches
	{
	}
	public class MessageGlyphItem : MonoBehaviour, Hoverable
	{
		private ItemDrop _itemDrop;

		private void Awake()
		{
			_itemDrop = ((Component)this).GetComponent<ItemDrop>();
		}

		public string GetHoverText()
		{
			return "Message Glyph\n[<color=yellow><b>E</b></color>] Place Message";
		}

		public string GetHoverName()
		{
			return "Message Glyph";
		}
	}
	public class MessagePlacementHandler : MonoBehaviour
	{
		private static MessagePlacementHandler _instance;

		private bool _isPlacing;

		private float _placementTimer;

		private const float PlacementDuration = 2f;

		private Vector3 _placementPosition;

		private Quaternion _placementRotation;

		public static MessagePlacementHandler Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("MessagePlacementHandler");
					_instance = val.AddComponent<MessagePlacementHandler>();
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				return _instance;
			}
		}

		public bool IsPlacing => _isPlacing;

		private void Update()
		{
			if (_isPlacing)
			{
				_placementTimer -= Time.deltaTime;
				if (_placementTimer <= 0f)
				{
					FinishPlacement();
				}
				if ((Object)(object)Player.m_localPlayer != (Object)null && !((Character)Player.m_localPlayer).IsEncumbered() && !((Character)Player.m_localPlayer).InAttack() && !(((Character)Player.m_localPlayer).GetHealth() < ((Character)Player.m_localPlayer).GetMaxHealth() * 0.9f))
				{
				}
			}
		}

		public void StartPlacement(Player player)
		{
			//IL_0029: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_00c8: 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)
			if (!_isPlacing)
			{
				_isPlacing = true;
				_placementTimer = 2f;
				_placementPosition = ((Component)player).transform.position + ((Component)player).transform.forward * 1.5f;
				_placementRotation = Quaternion.Euler(0f, ((Component)player).transform.eulerAngles.y, 0f);
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(_placementPosition + Vector3.up * 5f, Vector3.down, ref val, 10f, LayerMask.GetMask(new string[3] { "Default", "static_solid", "terrain" })))
				{
					_placementPosition = ((RaycastHit)(ref val)).point;
				}
				player.StartEmote("kneel", true);
				((Character)player).Message((MessageType)2, "Placing message...", 0, (Sprite)null);
				VikingMessagesPlugin.Log.LogInfo((object)"Started message placement");
			}
		}

		private void FinishPlacement()
		{
			//IL_000e: 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)
			_isPlacing = false;
			MessageUIManager.UI.ShowCreateUI(_placementPosition, _placementRotation);
			VikingMessagesPlugin.Log.LogInfo((object)"Finished placement, opening UI");
		}

		public void CancelPlacement()
		{
			if (_isPlacing)
			{
				_isPlacing = false;
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					((Character)Player.m_localPlayer).Message((MessageType)1, "Placement cancelled", 0, (Sprite)null);
				}
			}
		}
	}
	[HarmonyPatch]
	public static class MessageGlyphPatches
	{
		[HarmonyPatch(typeof(Player), "ConsumeItem")]
		[HarmonyPrefix]
		public static bool ConsumeItem_Prefix(Player __instance, ItemData item, ref bool __result)
		{
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			if ((string?)obj != "MessageGlyph")
			{
				return true;
			}
			if (!CanPlaceMessage(__instance))
			{
				((Character)__instance).Message((MessageType)2, "Cannot place message here!", 0, (Sprite)null);
				__result = false;
				return false;
			}
			MessagePlacementHandler.Instance.StartPlacement(__instance);
			((Humanoid)__instance).GetInventory().RemoveItem(item, 1);
			__result = true;
			return false;
		}

		[HarmonyPatch(typeof(Humanoid), "UseItem")]
		[HarmonyPrefix]
		public static bool UseItem_Prefix(Humanoid __instance, ItemData item)
		{
			object obj;
			if (item == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			if ((string?)obj != "MessageGlyph")
			{
				return true;
			}
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (val != null)
			{
				((Humanoid)val).ConsumeItem(((Humanoid)val).GetInventory(), item, false);
				return false;
			}
			return true;
		}

		private static bool CanPlaceMessage(Player player)
		{
			if (((Character)player).InInterior())
			{
				return false;
			}
			if (((Character)player).IsSwimming())
			{
				return false;
			}
			if (((Character)player).IsAttached())
			{
				return false;
			}
			if (((Character)player).IsDead())
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		[HarmonyPostfix]
		public static void Character_Damage_Postfix(Character __instance, HitData hit)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && MessagePlacementHandler.Instance.IsPlacing)
			{
				MessagePlacementHandler.Instance.CancelPlacement();
			}
		}
	}
	public static class MessageManagerAlt
	{
		private static Dictionary<string, VikingMessage> _messages = new Dictionary<string, VikingMessage>();

		private static Dictionary<long, PlayerReputation> _playerReputations = new Dictionary<long, PlayerReputation>();

		private static string _saveFilePath;

		private static string _leaderboardFilePath;

		private static string _currentWorldName;

		public const string RPC_PlaceMessage = "VikingMessages_PlaceMessage";

		public const string RPC_VoteMessage = "VikingMessages_VoteMessage";

		public const string RPC_RequestSync = "VikingMessages_RequestSync";

		public const string RPC_SyncMessages = "VikingMessages_SyncMessages";

		public const string RPC_RemoveMessage = "VikingMessages_RemoveMessage";

		public const string RPC_SyncTemplates = "VikingMessages_SyncTemplates";

		public const string RPC_SyncLeaderboard = "VikingMessages_SyncLeaderboard";

		public const string RPC_NotifyAppraise = "VikingMessages_NotifyAppraise";

		private static bool _rpcsRegistered = false;

		public static void Initialize()
		{
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"MessageManagerAlt initialized");
			}
		}

		public static void RegisterRPCs()
		{
			if (_rpcsRegistered || ZRoutedRpc.instance == null)
			{
				return;
			}
			try
			{
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_PlaceMessage", (Action<long, ZPackage>)RPC_OnPlaceMessage);
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_VoteMessage", (Action<long, ZPackage>)RPC_OnVoteMessage);
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_RequestSync", (Action<long, ZPackage>)RPC_OnRequestSync);
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_SyncMessages", (Action<long, ZPackage>)RPC_OnSyncMessages);
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_RemoveMessage", (Action<long, ZPackage>)RPC_OnRemoveMessage);
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_SyncTemplates", (Action<long, ZPackage>)RPC_OnSyncTemplates);
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_SyncLeaderboard", (Action<long, ZPackage>)RPC_OnSyncLeaderboard);
				ZRoutedRpc.instance.Register<ZPackage>("VikingMessages_NotifyAppraise", (Action<long, ZPackage>)RPC_OnNotifyAppraise);
				_rpcsRegistered = true;
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"RPCs registered successfully");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Failed to register RPCs: {arg}");
				}
			}
		}

		private static void RPC_OnPlaceMessage(long sender, ZPackage pkg)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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)
			//IL_0016: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string text = pkg.ReadString();
				Vector3 position = pkg.ReadVector3();
				Quaternion rotation = pkg.ReadQuaternion();
				string template = pkg.ReadString();
				string words = pkg.ReadString();
				int num = pkg.ReadInt();
				string text2 = pkg.ReadString();
				Vector3 lookDirection = pkg.ReadVector3();
				int num2 = pkg.ReadInt();
				string[] array = new string[num2];
				for (int i = 0; i < num2; i++)
				{
					array[i] = pkg.ReadString();
				}
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"RPC_OnPlaceMessage: id={text}, author={text2}, emote={num}");
				}
				VikingMessage value = new VikingMessage
				{
					Id = text,
					Position = position,
					Rotation = rotation,
					Template = template,
					Words = words,
					EmoteIndex = num,
					AuthorId = sender,
					AuthorName = text2,
					Reputation = 0,
					CreatedTime = DateTime.UtcNow,
					VotedPlayers = new List<long>(),
					EquippedItems = array,
					LookDirection = lookDirection
				};
				_messages[text] = value;
				UpdatePlayerMessageCount(sender, text2);
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					SaveMessages();
					SaveLeaderboard();
				}
				BroadcastMessageSync();
				BroadcastLeaderboard();
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Error processing PlaceMessage: {arg}");
				}
			}
		}

		private static void RPC_OnVoteMessage(long sender, ZPackage pkg)
		{
			try
			{
				string text = pkg.ReadString();
				bool flag = pkg.ReadBool();
				if (!_messages.TryGetValue(text, out var value) || value.VotedPlayers.Contains(sender) || value.AuthorId == sender)
				{
					return;
				}
				value.VotedPlayers.Add(sender);
				value.Reputation += (flag ? 1 : (-1));
				UpdatePlayerReputation(value.AuthorId, value.AuthorName, flag ? 1 : (-1));
				if (flag && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					NotifyAuthorOfAppraise(value.AuthorId);
				}
				if (value.Reputation <= VikingMessagesPlugin.MinReputation.Value)
				{
					_messages.Remove(text);
					ManualLogSource log = VikingMessagesPlugin.Log;
					if (log != null)
					{
						log.LogInfo((object)("Message " + text + " removed due to low reputation"));
					}
				}
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					SaveMessages();
					SaveLeaderboard();
				}
				BroadcastMessageSync();
				BroadcastLeaderboard();
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Error processing VoteMessage: {arg}");
				}
			}
		}

		private static void NotifyAuthorOfAppraise(long authorId)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			try
			{
				ZPackage val = new ZPackage();
				val.Write("appraise");
				List<ZNetPeer> peers = ZNet.instance.GetPeers();
				foreach (ZNetPeer item in peers)
				{
					if (((ZDOID)(ref item.m_characterID)).UserID == authorId)
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(item.m_uid, "VikingMessages_NotifyAppraise", new object[1] { val });
						ManualLogSource log = VikingMessagesPlugin.Log;
						if (log != null)
						{
							log.LogInfo((object)$"Sent appraise notification to {authorId}");
						}
						break;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Failed to notify author: " + ex.Message));
				}
			}
		}

		private static void RPC_OnNotifyAppraise(long sender, ZPackage pkg)
		{
			try
			{
				string text = pkg.ReadString();
				if (text == "appraise")
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, "<color=#FFD700>Your message was appraised!</color>", 0, (Sprite)null);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Error processing notification: " + ex.Message));
				}
			}
		}

		private static void RPC_OnRequestSync(long sender, ZPackage pkg)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Sync requested by {sender}");
				}
				SendMessagesToClient(sender);
				SendTemplatesToClient(sender);
				SendLeaderboardToClient(sender);
			}
		}

		private static void RPC_OnSyncMessages(long sender, ZPackage pkg)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_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)
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				int num = pkg.ReadInt();
				Dictionary<string, VikingMessage> dictionary = new Dictionary<string, VikingMessage>();
				for (int i = 0; i < num; i++)
				{
					VikingMessage vikingMessage = new VikingMessage
					{
						Id = pkg.ReadString(),
						Position = pkg.ReadVector3(),
						Rotation = pkg.ReadQuaternion(),
						Template = pkg.ReadString(),
						Words = pkg.ReadString(),
						EmoteIndex = pkg.ReadInt(),
						AuthorId = pkg.ReadLong(),
						AuthorName = pkg.ReadString(),
						Reputation = pkg.ReadInt(),
						LookDirection = pkg.ReadVector3()
					};
					int num2 = pkg.ReadInt();
					vikingMessage.EquippedItems = new string[num2];
					for (int j = 0; j < num2; j++)
					{
						vikingMessage.EquippedItems[j] = pkg.ReadString();
					}
					int num3 = pkg.ReadInt();
					vikingMessage.VotedPlayers = new List<long>();
					for (int k = 0; k < num3; k++)
					{
						vikingMessage.VotedPlayers.Add(pkg.ReadLong());
					}
					dictionary[vikingMessage.Id] = vikingMessage;
				}
				_messages = dictionary;
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Synced {num} messages from server");
				}
				RefreshAllMessageStones();
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Error processing SyncMessages: {arg}");
				}
			}
		}

		private static void RPC_OnRemoveMessage(long sender, ZPackage pkg)
		{
			try
			{
				string key = pkg.ReadString();
				if (_messages.ContainsKey(key))
				{
					_messages.Remove(key);
					if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
					{
						SaveMessages();
					}
					BroadcastMessageSync();
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Error processing RemoveMessage: {arg}");
				}
			}
		}

		private static void RPC_OnSyncTemplates(long sender, ZPackage pkg)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				string json = pkg.ReadString();
				MessageTemplates.LoadFromServerJson(json);
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"Templates synced from server");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Error processing SyncTemplates: {arg}");
				}
			}
		}

		private static void RPC_OnSyncLeaderboard(long sender, ZPackage pkg)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				int num = pkg.ReadInt();
				_playerReputations.Clear();
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"RPC_OnSyncLeaderboard: Receiving {num} players");
				}
				for (int i = 0; i < num; i++)
				{
					PlayerReputation playerReputation = new PlayerReputation
					{
						PlayerId = pkg.ReadLong(),
						PlayerName = pkg.ReadString(),
						TotalReputation = pkg.ReadInt(),
						MessageCount = pkg.ReadInt()
					};
					_playerReputations[playerReputation.PlayerId] = playerReputation;
					ManualLogSource log2 = VikingMessagesPlugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"  Player {i}: id={playerReputation.PlayerId}, name='{playerReputation.PlayerName}', rep={playerReputation.TotalReputation}");
					}
				}
				ManualLogSource log3 = VikingMessagesPlugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)$"Synced leaderboard: {num} players");
				}
				LeaderboardManager.CheckAndApplyBuffs();
			}
			catch (Exception arg)
			{
				ManualLogSource log4 = VikingMessagesPlugin.Log;
				if (log4 != null)
				{
					log4.LogError((object)$"Error processing SyncLeaderboard: {arg}");
				}
			}
		}

		public static void PlaceMessage(Vector3 position, Quaternion rotation, string template, string words, int emoteIndex)
		{
			//IL_0041: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0083: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				string text = Guid.NewGuid().ToString();
				string playerName = Player.m_localPlayer.GetPlayerName();
				Vector3 forward = ((Component)Player.m_localPlayer).transform.forward;
				string[] array = CapturePlayerEquipment();
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"PlaceMessage: id={text}, author='{playerName}', emote={emoteIndex}");
				}
				ZPackage val = new ZPackage();
				val.Write(text);
				val.Write(position);
				val.Write(rotation);
				val.Write(template);
				val.Write(words);
				val.Write(emoteIndex);
				val.Write(playerName ?? "Unknown");
				val.Write(forward);
				val.Write(array.Length);
				string[] array2 = array;
				foreach (string text2 in array2)
				{
					val.Write(text2 ?? "");
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "VikingMessages_PlaceMessage", new object[1] { val });
			}
		}

		private static string[] CapturePlayerEquipment()
		{
			List<string> list = new List<string>();
			try
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return list.ToArray();
				}
				VisEquipment component = ((Component)Player.m_localPlayer).GetComponent<VisEquipment>();
				if ((Object)(object)component == (Object)null)
				{
					return list.ToArray();
				}
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (inventory == null)
				{
					return list.ToArray();
				}
				foreach (ItemData allItem in inventory.GetAllItems())
				{
					if (allItem.m_equipped && (Object)(object)allItem.m_dropPrefab != (Object)null)
					{
						list.Add(((Object)allItem.m_dropPrefab).name);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Failed to capture equipment: " + ex.Message));
				}
			}
			return list.ToArray();
		}

		public static bool VoteMessage(string messageId, bool isLike)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			if (!_messages.TryGetValue(messageId, out var value))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Message not found!", 0, (Sprite)null);
				}
				return false;
			}
			Player localPlayer2 = Player.m_localPlayer;
			long num = ((localPlayer2 != null) ? localPlayer2.GetPlayerID() : 0);
			Player localPlayer3 = Player.m_localPlayer;
			string value2 = ((localPlayer3 != null) ? localPlayer3.GetPlayerName() : null) ?? "";
			if (value.AuthorId == num || (!string.IsNullOrEmpty(value2) && !string.IsNullOrEmpty(value.AuthorName) && value.AuthorName.Equals(value2, StringComparison.OrdinalIgnoreCase)))
			{
				Player localPlayer4 = Player.m_localPlayer;
				if (localPlayer4 != null)
				{
					((Character)localPlayer4).Message((MessageType)2, "You cannot appraise your own message!", 0, (Sprite)null);
				}
				return false;
			}
			if (value.VotedPlayers.Contains(num))
			{
				Player localPlayer5 = Player.m_localPlayer;
				if (localPlayer5 != null)
				{
					((Character)localPlayer5).Message((MessageType)2, "You have already rated this message!", 0, (Sprite)null);
				}
				return false;
			}
			ZPackage val = new ZPackage();
			val.Write(messageId);
			val.Write(isLike);
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "VikingMessages_VoteMessage", new object[1] { val });
			return true;
		}

		public static void RequestMessages()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"Requesting sync from server");
				}
				ZPackage val = new ZPackage();
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "VikingMessages_RequestSync", new object[1] { val });
			}
		}

		public static VikingMessage GetMessage(string messageId)
		{
			VikingMessage value;
			return _messages.TryGetValue(messageId, out value) ? value : null;
		}

		public static IEnumerable<VikingMessage> GetAllMessages()
		{
			return _messages.Values;
		}

		public static int GetMessageCount()
		{
			return _messages.Count;
		}

		private static void UpdatePlayerMessageCount(long playerId, string playerName)
		{
			if (!_playerReputations.TryGetValue(playerId, out var value))
			{
				value = new PlayerReputation(playerId, playerName);
				_playerReputations[playerId] = value;
			}
			value.MessageCount++;
			value.PlayerName = playerName;
		}

		private static void UpdatePlayerReputation(long playerId, string playerName, int delta)
		{
			if (!_playerReputations.TryGetValue(playerId, out var value))
			{
				value = new PlayerReputation(playerId, playerName);
				_playerReputations[playerId] = value;
			}
			value.TotalReputation += delta;
			value.PlayerName = playerName;
		}

		public static List<PlayerReputation> GetLeaderboard()
		{
			Dictionary<string, PlayerReputation> dictionary = new Dictionary<string, PlayerReputation>();
			foreach (PlayerReputation value2 in _playerReputations.Values)
			{
				string key = (string.IsNullOrEmpty(value2.PlayerName) ? $"id_{value2.PlayerId}" : value2.PlayerName.ToLower());
				if (dictionary.TryGetValue(key, out var value))
				{
					value.TotalReputation += value2.TotalReputation;
					value.MessageCount += value2.MessageCount;
					if (string.IsNullOrEmpty(value.PlayerName) && !string.IsNullOrEmpty(value2.PlayerName))
					{
						value.PlayerName = value2.PlayerName;
					}
				}
				else
				{
					dictionary[key] = new PlayerReputation
					{
						PlayerId = value2.PlayerId,
						PlayerName = value2.PlayerName,
						TotalReputation = value2.TotalReputation,
						MessageCount = value2.MessageCount
					};
				}
			}
			return dictionary.Values.OrderByDescending((PlayerReputation p) => p.TotalReputation).ToList();
		}

		public static bool IsPlayerInTop3(long playerId)
		{
			Player localPlayer = Player.m_localPlayer;
			string localPlayerName = ((localPlayer != null) ? localPlayer.GetPlayerName() : null) ?? "";
			List<PlayerReputation> list = GetLeaderboard().Take(3).ToList();
			bool flag = list.Any((PlayerReputation p) => p.PlayerId == playerId || (!string.IsNullOrEmpty(localPlayerName) && !string.IsNullOrEmpty(p.PlayerName) && p.PlayerName.Equals(localPlayerName, StringComparison.OrdinalIgnoreCase)));
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"IsPlayerInTop3: playerId={playerId}, name={localPlayerName}, top3Count={list.Count}, result={flag}");
			}
			if (list.Count > 0)
			{
				foreach (PlayerReputation item in list)
				{
					ManualLogSource log2 = VikingMessagesPlugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"  Top3 player: id={item.PlayerId}, name='{item.PlayerName}', rep={item.TotalReputation}");
					}
				}
			}
			return flag;
		}

		private static void SendMessagesToClient(long clientId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0046: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(_messages.Count);
			foreach (VikingMessage value in _messages.Values)
			{
				val.Write(value.Id);
				val.Write(value.Position);
				val.Write(value.Rotation);
				val.Write(value.Template ?? "");
				val.Write(value.Words ?? "");
				val.Write(value.EmoteIndex);
				val.Write(value.AuthorId);
				val.Write(value.AuthorName ?? "Unknown");
				val.Write(value.Reputation);
				val.Write(value.LookDirection);
				string[] array = value.EquippedItems ?? new string[0];
				val.Write(array.Length);
				string[] array2 = array;
				foreach (string text in array2)
				{
					val.Write(text ?? "");
				}
				val.Write(value.VotedPlayers?.Count ?? 0);
				if (value.VotedPlayers == null)
				{
					continue;
				}
				foreach (long votedPlayer in value.VotedPlayers)
				{
					val.Write(votedPlayer);
				}
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(clientId, "VikingMessages_SyncMessages", new object[1] { val });
		}

		private static void BroadcastMessageSync()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0046: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(_messages.Count);
			foreach (VikingMessage value in _messages.Values)
			{
				val.Write(value.Id);
				val.Write(value.Position);
				val.Write(value.Rotation);
				val.Write(value.Template ?? "");
				val.Write(value.Words ?? "");
				val.Write(value.EmoteIndex);
				val.Write(value.AuthorId);
				val.Write(value.AuthorName ?? "Unknown");
				val.Write(value.Reputation);
				val.Write(value.LookDirection);
				string[] array = value.EquippedItems ?? new string[0];
				val.Write(array.Length);
				string[] array2 = array;
				foreach (string text in array2)
				{
					val.Write(text ?? "");
				}
				val.Write(value.VotedPlayers?.Count ?? 0);
				if (value.VotedPlayers == null)
				{
					continue;
				}
				foreach (long votedPlayer in value.VotedPlayers)
				{
					val.Write(votedPlayer);
				}
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "VikingMessages_SyncMessages", new object[1] { val });
		}

		private static void SendTemplatesToClient(long clientId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			string serverTemplatesJson = MessageTemplates.GetServerTemplatesJson();
			ZPackage val = new ZPackage();
			val.Write(serverTemplatesJson);
			ZRoutedRpc.instance.InvokeRoutedRPC(clientId, "VikingMessages_SyncTemplates", new object[1] { val });
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"Sent templates to client {clientId}");
			}
		}

		private static void SendLeaderboardToClient(long clientId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			List<PlayerReputation> list = _playerReputations.Values.ToList();
			val.Write(list.Count);
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"SendLeaderboardToClient: Sending {list.Count} players to {clientId}");
			}
			foreach (PlayerReputation item in list)
			{
				val.Write(item.PlayerId);
				val.Write(item.PlayerName ?? "Unknown");
				val.Write(item.TotalReputation);
				val.Write(item.MessageCount);
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"  Sending player: id={item.PlayerId}, name='{item.PlayerName}', rep={item.TotalReputation}");
				}
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(clientId, "VikingMessages_SyncLeaderboard", new object[1] { val });
		}

		private static void BroadcastLeaderboard()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			List<PlayerReputation> list = _playerReputations.Values.ToList();
			val.Write(list.Count);
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"BroadcastLeaderboard: Broadcasting {list.Count} players");
			}
			foreach (PlayerReputation item in list)
			{
				val.Write(item.PlayerId);
				val.Write(item.PlayerName ?? "Unknown");
				val.Write(item.TotalReputation);
				val.Write(item.MessageCount);
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "VikingMessages_SyncLeaderboard", new object[1] { val });
		}

		public static void SpawnMessageStone(VikingMessage msg)
		{
			//IL_0018: 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)
			if (!((Object)(object)VikingMessagesPlugin.MessageStonePrefab == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(VikingMessagesPlugin.MessageStonePrefab, msg.Position, msg.Rotation);
				val.SetActive(true);
				MessageStone component = val.GetComponent<MessageStone>();
				if ((Object)(object)component != (Object)null)
				{
					component.Initialize(msg);
				}
			}
		}

		private static void RefreshAllMessageStones()
		{
			MessageStone[] array = Object.FindObjectsOfType<MessageStone>();
			MessageStone[] array2 = array;
			foreach (MessageStone messageStone in array2)
			{
				Object.Destroy((Object)(object)((Component)messageStone).gameObject);
			}
			foreach (VikingMessage value in _messages.Values)
			{
				SpawnMessageStone(value);
			}
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"Refreshed {_messages.Count} message stones");
			}
		}

		private static void SetupSavePath(string worldName)
		{
			if (string.IsNullOrEmpty(worldName))
			{
				worldName = "Unknown";
			}
			_currentWorldName = worldName;
			string text = Path.Combine(Paths.ConfigPath, "VikingMessages");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			string text2 = string.Join("_", worldName.Split(Path.GetInvalidFileNameChars()));
			_saveFilePath = Path.Combine(text, "messages_" + text2 + ".json");
			_leaderboardFilePath = Path.Combine(text, "leaderboard_" + text2 + ".json");
		}

		public static void SaveMessages()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (string.IsNullOrEmpty(_saveFilePath))
			{
				SetupSavePath(ZNet.instance.GetWorldName());
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("{");
				stringBuilder.AppendLine("  \"Messages\": [");
				List<VikingMessage> list = _messages.Values.ToList();
				for (int i = 0; i < list.Count; i++)
				{
					VikingMessage vikingMessage = list[i];
					stringBuilder.AppendLine("    {");
					stringBuilder.AppendLine("      \"Id\": \"" + Escape(vikingMessage.Id) + "\",");
					stringBuilder.AppendLine("      \"PosX\": " + F(vikingMessage.Position.x) + ", \"PosY\": " + F(vikingMessage.Position.y) + ", \"PosZ\": " + F(vikingMessage.Position.z) + ",");
					stringBuilder.AppendLine("      \"RotX\": " + F(vikingMessage.Rotation.x) + ", \"RotY\": " + F(vikingMessage.Rotation.y) + ", \"RotZ\": " + F(vikingMessage.Rotation.z) + ", \"RotW\": " + F(vikingMessage.Rotation.w) + ",");
					stringBuilder.AppendLine("      \"Template\": \"" + Escape(vikingMessage.Template) + "\",");
					stringBuilder.AppendLine("      \"Words\": \"" + Escape(vikingMessage.Words) + "\",");
					stringBuilder.AppendLine($"      \"EmoteIndex\": {vikingMessage.EmoteIndex},");
					stringBuilder.AppendLine($"      \"AuthorId\": {vikingMessage.AuthorId},");
					stringBuilder.AppendLine("      \"AuthorName\": \"" + Escape(vikingMessage.AuthorName) + "\",");
					stringBuilder.AppendLine($"      \"Reputation\": {vikingMessage.Reputation},");
					stringBuilder.AppendLine("      \"LookDirX\": " + F(vikingMessage.LookDirection.x) + ", \"LookDirY\": " + F(vikingMessage.LookDirection.y) + ", \"LookDirZ\": " + F(vikingMessage.LookDirection.z) + ",");
					stringBuilder.Append("      \"Equipment\": [");
					if (vikingMessage.EquippedItems != null && vikingMessage.EquippedItems.Length != 0)
					{
						stringBuilder.Append(string.Join(", ", vikingMessage.EquippedItems.Select((string e) => "\"" + Escape(e) + "\"")));
					}
					stringBuilder.AppendLine("],");
					stringBuilder.Append("      \"VotedPlayers\": [");
					if (vikingMessage.VotedPlayers != null && vikingMessage.VotedPlayers.Count > 0)
					{
						stringBuilder.Append(string.Join(", ", vikingMessage.VotedPlayers));
					}
					stringBuilder.AppendLine("]");
					stringBuilder.AppendLine((i < list.Count - 1) ? "    }," : "    }");
				}
				stringBuilder.AppendLine("  ]");
				stringBuilder.AppendLine("}");
				File.WriteAllText(_saveFilePath, stringBuilder.ToString());
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Saved {_messages.Count} messages");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Failed to save messages: {arg}");
				}
			}
		}

		public static void SaveLeaderboard()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			if (string.IsNullOrEmpty(_leaderboardFilePath))
			{
				SetupSavePath(ZNet.instance.GetWorldName());
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("{");
				stringBuilder.AppendLine("  \"Players\": [");
				List<PlayerReputation> list = _playerReputations.Values.ToList();
				for (int i = 0; i < list.Count; i++)
				{
					PlayerReputation playerReputation = list[i];
					stringBuilder.AppendLine("    {");
					stringBuilder.AppendLine($"      \"PlayerId\": {playerReputation.PlayerId},");
					stringBuilder.AppendLine("      \"PlayerName\": \"" + Escape(playerReputation.PlayerName) + "\",");
					stringBuilder.AppendLine($"      \"TotalReputation\": {playerReputation.TotalReputation},");
					stringBuilder.AppendLine($"      \"MessageCount\": {playerReputation.MessageCount}");
					stringBuilder.AppendLine((i < list.Count - 1) ? "    }," : "    }");
				}
				stringBuilder.AppendLine("  ]");
				stringBuilder.AppendLine("}");
				File.WriteAllText(_leaderboardFilePath, stringBuilder.ToString());
			}
			catch (Exception arg)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Failed to save leaderboard: {arg}");
				}
			}
		}

		public static void LoadMessages()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			SetupSavePath(ZNet.instance.GetWorldName());
			try
			{
				if (File.Exists(_saveFilePath))
				{
					string json = File.ReadAllText(_saveFilePath);
					ParseMessagesJson(json);
					ManualLogSource log = VikingMessagesPlugin.Log;
					if (log != null)
					{
						log.LogInfo((object)$"Loaded {_messages.Count} messages");
					}
				}
				if (File.Exists(_leaderboardFilePath))
				{
					string json2 = File.ReadAllText(_leaderboardFilePath);
					ParseLeaderboardJson(json2);
					ManualLogSource log2 = VikingMessagesPlugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"Loaded {_playerReputations.Count} player reputations");
					}
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log3 = VikingMessagesPlugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)$"Failed to load data: {arg}");
				}
			}
		}

		private static void ParseMessagesJson(string json)
		{
			//IL_0052: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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)
			_messages.Clear();
			int startIndex = 0;
			while ((startIndex = json.IndexOf("\"Id\":", startIndex)) >= 0)
			{
				try
				{
					VikingMessage vikingMessage = new VikingMessage();
					vikingMessage.Id = ExtractString(json, "Id", startIndex);
					vikingMessage.Position = new Vector3(ExtractFloat(json, "PosX", startIndex), ExtractFloat(json, "PosY", startIndex), ExtractFloat(json, "PosZ", startIndex));
					vikingMessage.Rotation = new Quaternion(ExtractFloat(json, "RotX", startIndex), ExtractFloat(json, "RotY", startIndex), ExtractFloat(json, "RotZ", startIndex), ExtractFloat(json, "RotW", startIndex));
					vikingMessage.Template = ExtractString(json, "Template", startIndex);
					vikingMessage.Words = ExtractString(json, "Words", startIndex);
					vikingMessage.EmoteIndex = (int)ExtractFloat(json, "EmoteIndex", startIndex);
					vikingMessage.AuthorId = (long)ExtractFloat(json, "AuthorId", startIndex);
					vikingMessage.AuthorName = ExtractString(json, "AuthorName", startIndex);
					vikingMessage.Reputation = (int)ExtractFloat(json, "Reputation", startIndex);
					vikingMessage.LookDirection = new Vector3(ExtractFloat(json, "LookDirX", startIndex), ExtractFloat(json, "LookDirY", startIndex), ExtractFloat(json, "LookDirZ", startIndex));
					vikingMessage.EquippedItems = ExtractStringArray(json, "Equipment", startIndex);
					vikingMessage.VotedPlayers = ExtractLongArray(json, "VotedPlayers", startIndex);
					if (!string.IsNullOrEmpty(vikingMessage.Id))
					{
						_messages[vikingMessage.Id] = vikingMessage;
					}
				}
				catch
				{
				}
				startIndex++;
			}
		}

		private static void ParseLeaderboardJson(string json)
		{
			_playerReputations.Clear();
			int startIndex = 0;
			while ((startIndex = json.IndexOf("\"PlayerId\":", startIndex)) >= 0)
			{
				try
				{
					PlayerReputation playerReputation = new PlayerReputation();
					playerReputation.PlayerId = (long)ExtractFloat(json, "PlayerId", startIndex);
					playerReputation.PlayerName = ExtractString(json, "PlayerName", startIndex);
					playerReputation.TotalReputation = (int)ExtractFloat(json, "TotalReputation", startIndex);
					playerReputation.MessageCount = (int)ExtractFloat(json, "MessageCount", startIndex);
					if (playerReputation.PlayerId != 0)
					{
						_playerReputations[playerReputation.PlayerId] = playerReputation;
					}
				}
				catch
				{
				}
				startIndex++;
			}
		}

		private static string F(float v)
		{
			return v.ToString(CultureInfo.InvariantCulture);
		}

		private static string Escape(string s)
		{
			return s?.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n") ?? "";
		}

		private static string ExtractString(string json, string field, int startIdx)
		{
			string text = "\"" + field + "\": \"";
			int num = json.IndexOf(text, startIdx);
			if (num < 0 || num > startIdx + 2000)
			{
				return "";
			}
			num += text.Length;
			int num2 = json.IndexOf("\"", num);
			if (num2 < 0)
			{
				return "";
			}
			return json.Substring(num, num2 - num).Replace("\\n", "\n").Replace("\\\"", "\"");
		}

		private static float ExtractFloat(string json, string field, int startIdx)
		{
			string text = "\"" + field + "\": ";
			int num = json.IndexOf(text, startIdx);
			if (num < 0 || num > startIdx + 2000)
			{
				return 0f;
			}
			num += text.Length;
			int i;
			for (i = num; i < json.Length && (char.IsDigit(json[i]) || json[i] == '.' || json[i] == '-' || json[i] == 'E' || json[i] == 'e' || json[i] == '+'); i++)
			{
			}
			float.TryParse(json.Substring(num, i - num), NumberStyles.Float, CultureInfo.InvariantCulture, out var result);
			return result;
		}

		private static string[] ExtractStringArray(string json, string field, int startIdx)
		{
			List<string> list = new List<string>();
			string text = "\"" + field + "\": [";
			int num = json.IndexOf(text, startIdx);
			if (num < 0 || num > startIdx + 2000)
			{
				return list.ToArray();
			}
			num += text.Length;
			int num2 = json.IndexOf("]", num);
			if (num2 < 0)
			{
				return list.ToArray();
			}
			string text2 = json.Substring(num, num2 - num);
			int startIndex = 0;
			while ((startIndex = text2.IndexOf("\"", startIndex)) >= 0)
			{
				int num3 = startIndex + 1;
				int num4 = text2.IndexOf("\"", num3);
				if (num4 > num3)
				{
					list.Add(text2.Substring(num3, num4 - num3));
				}
				startIndex = num4 + 1;
			}
			return list.ToArray();
		}

		private static List<long> ExtractLongArray(string json, string field, int startIdx)
		{
			List<long> list = new List<long>();
			string text = "\"" + field + "\": [";
			int num = json.IndexOf(text, startIdx);
			if (num < 0 || num > startIdx + 2000)
			{
				return list;
			}
			num += text.Length;
			int num2 = json.IndexOf("]", num);
			if (num2 < 0)
			{
				return list;
			}
			string text2 = json.Substring(num, num2 - num);
			string[] array = text2.Split(new char[1] { ',' });
			foreach (string text3 in array)
			{
				if (long.TryParse(text3.Trim(), out var result))
				{
					list.Add(result);
				}
			}
			return list;
		}
	}
	[HarmonyPatch]
	public static class NetworkingPatches
	{
		[CompilerGenerated]
		private sealed class <DelayedLoad>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedLoad>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					MessageManagerAlt.LoadMessages();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedRequestSync>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedRequestSync>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					MessageManagerAlt.RequestMessages();
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (MessageManagerAlt.GetMessageCount() == 0)
					{
						MessageManagerAlt.RequestMessages();
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPatch(typeof(ZRoutedRpc), "AddPeer")]
		[HarmonyPostfix]
		public static void ZRoutedRpc_AddPeer_Postfix(ZRoutedRpc __instance)
		{
			if (__instance != null)
			{
				MessageManagerAlt.RegisterRPCs();
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		[HarmonyPostfix]
		public static void ZNet_Awake_Postfix(ZNet __instance)
		{
			if (__instance.IsServer())
			{
				((MonoBehaviour)__instance).StartCoroutine(DelayedLoad());
			}
		}

		[IteratorStateMachine(typeof(<DelayedLoad>d__2))]
		private static IEnumerator DelayedLoad()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedLoad>d__2(0);
		}

		[HarmonyPatch(typeof(ZNet), "SaveWorld")]
		[HarmonyPostfix]
		public static void ZNet_Save_Postfix(ZNet __instance)
		{
			if (__instance.IsServer())
			{
				MessageManagerAlt.SaveMessages();
				MessageManagerAlt.SaveLeaderboard();
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		public static void Player_OnSpawned_Postfix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				((MonoBehaviour)__instance).StartCoroutine(DelayedRequestSync());
			}
		}

		[IteratorStateMachine(typeof(<DelayedRequestSync>d__5))]
		private static IEnumerator DelayedRequestSync()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedRequestSync>d__5(0);
		}
	}
	public class MessageStone : MonoBehaviour, Hoverable, Interactable
	{
		private VikingMessage _message;

		private bool _isInitialized;

		private Light _glowLight;

		private float _pulseTimer;

		private float _baseIntensity = 1.5f;

		public string MessageId => _message?.Id;

		public string Template => _message?.Template;

		public string Words => _message?.Words;

		public int EmoteIndex => _message?.EmoteIndex ?? 0;

		public int Reputation => _message?.Reputation ?? 0;

		public long AuthorId => _message?.AuthorId ?? 0;

		public string AuthorName => _message?.AuthorName ?? "Unknown";

		private void Awake()
		{
			_glowLight = ((Component)this).GetComponentInChildren<Light>();
		}

		private void Update()
		{
			if (_isInitialized && (Object)(object)_glowLight != (Object)null)
			{
				_pulseTimer += Time.deltaTime * 2f;
				float num = 1f + Mathf.Sin(_pulseTimer) * 0.25f;
				_glowLight.intensity = _baseIntensity * num;
			}
		}

		public void Initialize(VikingMessage message)
		{
			_message = message;
			_isInitialized = true;
			UpdateVisuals();
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("MessageStone initialized: " + message.Id + " by " + message.AuthorName));
			}
		}

		private void UpdateVisuals()
		{
			//IL_004e: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_glowLight == (Object)null) && _message != null)
			{
				int reputation = _message.Reputation;
				if (reputation > 5)
				{
					_glowLight.color = new Color(1f, 0.9f, 0.5f);
					_baseIntensity = 2.3f;
				}
				else if (reputation > 0)
				{
					_glowLight.color = new Color(0.8f, 0.9f, 1f);
					_baseIntensity = 1.73f;
				}
				else if (reputation < -3)
				{
					_glowLight.color = new Color(0.6f, 0.3f, 0.3f);
					_baseIntensity = 0.58f;
				}
				else if (reputation < 0)
				{
					_glowLight.color = new Color(0.8f, 0.6f, 0.6f);
					_baseIntensity = 0.92f;
				}
				else
				{
					_glowLight.color = new Color(0.7f, 0.85f, 1f);
					_baseIntensity = 1.38f;
				}
				_glowLight.range = 4.4f;
			}
		}

		public string GetHoverText()
		{
			if (_message == null)
			{
				return "";
			}
			string text = MessageTemplates.FormatMessage(_message.Template, _message.Words);
			string text2 = ((text.Length > 50) ? (text.Substring(0, 47) + "...") : text);
			return "[<color=yellow><b>E</b></color>] View Player\n[<color=yellow><b>Shift+E</b></color>] Rate Message\n\"" + text2 + "\"\n" + $"<color=#AAA>Reputation: {Reputation}</color>";
		}

		public string GetHoverName()
		{
			return "Message Stone";
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			if (hold)
			{
				return false;
			}
			if (_message == null)
			{
				return false;
			}
			VikingMessage message = MessageManagerAlt.GetMessage(MessageId);
			VikingMessage vikingMessage = message ?? _message;
			string text = MessageTemplates.FormatMessage(vikingMessage.Template, vikingMessage.Words);
			if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
			{
				MessageUIManager.ShowReadUI(MessageId, text, vikingMessage.Reputation);
			}
			else
			{
				SpawnGhostPhantom(vikingMessage);
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
				}
			}
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		private void SpawnGhostPhantom(VikingMessage message)
		{
			//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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (message == null)
			{
				return;
			}
			try
			{
				Vector3 position = ((Component)this).transform.position + ((Component)this).transform.forward * 0.5f;
				Quaternion rotation = Quaternion.LookRotation((((Vector3)(ref message.LookDirection)).sqrMagnitude > 0.01f) ? message.LookDirection : ((Component)this).transform.forward, Vector3.up);
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Spawning ghost: emote={message.EmoteIndex}, lookDir={message.LookDirection}");
				}
				GhostPhantomManager.ShowGhost(position, rotation, message);
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Failed to spawn ghost: " + ex.Message));
				}
			}
		}
	}
	public static class MessageTemplates
	{
		[Serializable]
		private class TemplateConfig
		{
			public CategoryData[] Categories = null;

			public WordCategoryData[] WordCategories = null;

			public string[] Emotes = null;
		}

		[Serializable]
		private class CategoryData
		{
			public string Name = null;

			public string[] Templates = null;
		}

		[Serializable]
		private class WordCategoryData
		{
			public string Name = null;

			public string[] Words = null;
		}

		private static string _configPath;

		private static bool _initialized;

		public static Dictionary<string, List<string>> Categories { get; private set; }

		public static Dictionary<string, List<string>> WordCategories { get; private set; }

		public static List<string> AvailableEmotes { get; private set; }

		public static void Initialize()
		{
			if (_initialized)
			{
				return;
			}
			string text = Path.Combine(Paths.ConfigPath, "VikingMessages");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			_configPath = Path.Combine(text, "templates.json");
			LoadDefaults();
			if (File.Exists(_configPath))
			{
				LoadFromFile();
			}
			else
			{
				SaveToFile();
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Created default template config at: " + _configPath));
				}
			}
			_initialized = true;
			ManualLogSource log2 = VikingMessagesPlugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"Templates initialized: {Categories.Count} categories, {WordCategories.Count} word types, {AvailableEmotes.Count} emotes");
			}
		}

		public static void ReloadTemplates()
		{
			if (File.Exists(_configPath))
			{
				LoadFromFile();
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"Templates reloaded from config file");
				}
			}
		}

		private static void LoadFromFile()
		{
			try
			{
				string text = File.ReadAllText(_configPath);
				TemplateConfig templateConfig = JsonUtility.FromJson<TemplateConfig>(text);
				if (templateConfig != null)
				{
					if (templateConfig.Categories != null && templateConfig.Categories.Length != 0)
					{
						Categories = new Dictionary<string, List<string>>();
						CategoryData[] categories = templateConfig.Categories;
						foreach (CategoryData categoryData in categories)
						{
							if (!string.IsNullOrEmpty(categoryData.Name) && categoryData.Templates != null)
							{
								Categories[categoryData.Name] = categoryData.Templates.ToList();
							}
						}
					}
					if (templateConfig.WordCategories != null && templateConfig.WordCategories.Length != 0)
					{
						WordCategories = new Dictionary<string, List<string>>();
						WordCategoryData[] wordCategories = templateConfig.WordCategories;
						foreach (WordCategoryData wordCategoryData in wordCategories)
						{
							if (!string.IsNullOrEmpty(wordCategoryData.Name) && wordCategoryData.Words != null)
							{
								WordCategories[wordCategoryData.Name] = wordCategoryData.Words.ToList();
							}
						}
					}
					if (templateConfig.Emotes != null && templateConfig.Emotes.Length != 0)
					{
						AvailableEmotes = templateConfig.Emotes.ToList();
					}
				}
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Loaded templates from " + _configPath));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)("Failed to load templates from file: " + ex.Message));
				}
			}
		}

		private static void SaveToFile()
		{
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("{");
				stringBuilder.AppendLine("  \"Categories\": [");
				List<KeyValuePair<string, List<string>>> list = Categories.ToList();
				for (int i = 0; i < list.Count; i++)
				{
					KeyValuePair<string, List<string>> keyValuePair = list[i];
					stringBuilder.AppendLine("    {");
					stringBuilder.AppendLine("      \"Name\": \"" + EscapeJson(keyValuePair.Key) + "\",");
					stringBuilder.AppendLine("      \"Templates\": [");
					for (int j = 0; j < keyValuePair.Value.Count; j++)
					{
						string text = ((j < keyValuePair.Value.Count - 1) ? "," : "");
						stringBuilder.AppendLine("        \"" + EscapeJson(keyValuePair.Value[j]) + "\"" + text);
					}
					stringBuilder.AppendLine("      ]");
					string text2 = ((i < list.Count - 1) ? "," : "");
					stringBuilder.AppendLine("    }" + text2);
				}
				stringBuilder.AppendLine("  ],");
				stringBuilder.AppendLine("  \"WordCategories\": [");
				List<KeyValuePair<string, List<string>>> list2 = WordCategories.ToList();
				for (int k = 0; k < list2.Count; k++)
				{
					KeyValuePair<string, List<string>> keyValuePair2 = list2[k];
					stringBuilder.AppendLine("    {");
					stringBuilder.AppendLine("      \"Name\": \"" + EscapeJson(keyValuePair2.Key) + "\",");
					stringBuilder.AppendLine("      \"Words\": [");
					for (int l = 0; l < keyValuePair2.Value.Count; l++)
					{
						string text3 = ((l < keyValuePair2.Value.Count - 1) ? "," : "");
						stringBuilder.AppendLine("        \"" + EscapeJson(keyValuePair2.Value[l]) + "\"" + text3);
					}
					stringBuilder.AppendLine("      ]");
					string text4 = ((k < list2.Count - 1) ? "," : "");
					stringBuilder.AppendLine("    }" + text4);
				}
				stringBuilder.AppendLine("  ],");
				stringBuilder.AppendLine("  \"Emotes\": [");
				for (int m = 0; m < AvailableEmotes.Count; m++)
				{
					string text5 = ((m < AvailableEmotes.Count - 1) ? "," : "");
					stringBuilder.AppendLine("    \"" + EscapeJson(AvailableEmotes[m]) + "\"" + text5);
				}
				stringBuilder.AppendLine("  ]");
				stringBuilder.AppendLine("}");
				File.WriteAllText(_configPath, stringBuilder.ToString());
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)("Saved templates to " + _configPath));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)("Failed to save templates to file: " + ex.Message));
				}
			}
		}

		private static string EscapeJson(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			return s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n")
				.Replace("\r", "\\r");
		}

		public static string GetServerTemplatesJson()
		{
			if (!_initialized)
			{
				Initialize();
			}
			try
			{
				if (File.Exists(_configPath))
				{
					return File.ReadAllText(_configPath);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Failed to read server templates file: " + ex.Message));
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("{");
			stringBuilder.AppendLine("  \"Categories\": [");
			List<KeyValuePair<string, List<string>>> list = Categories.ToList();
			for (int i = 0; i < list.Count; i++)
			{
				KeyValuePair<string, List<string>> keyValuePair = list[i];
				stringBuilder.AppendLine("    {");
				stringBuilder.AppendLine("      \"Name\": \"" + EscapeJson(keyValuePair.Key) + "\",");
				stringBuilder.AppendLine("      \"Templates\": [");
				for (int j = 0; j < keyValuePair.Value.Count; j++)
				{
					string text = ((j < keyValuePair.Value.Count - 1) ? "," : "");
					stringBuilder.AppendLine("        \"" + EscapeJson(keyValuePair.Value[j]) + "\"" + text);
				}
				stringBuilder.AppendLine("      ]");
				string text2 = ((i < list.Count - 1) ? "," : "");
				stringBuilder.AppendLine("    }" + text2);
			}
			stringBuilder.AppendLine("  ],");
			stringBuilder.AppendLine("  \"WordCategories\": [");
			List<KeyValuePair<string, List<string>>> list2 = WordCategories.ToList();
			for (int k = 0; k < list2.Count; k++)
			{
				KeyValuePair<string, List<string>> keyValuePair2 = list2[k];
				stringBuilder.AppendLine("    {");
				stringBuilder.AppendLine("      \"Name\": \"" + EscapeJson(keyValuePair2.Key) + "\",");
				stringBuilder.AppendLine("      \"Words\": [");
				for (int l = 0; l < keyValuePair2.Value.Count; l++)
				{
					string text3 = ((l < keyValuePair2.Value.Count - 1) ? "," : "");
					stringBuilder.AppendLine("        \"" + EscapeJson(keyValuePair2.Value[l]) + "\"" + text3);
				}
				stringBuilder.AppendLine("      ]");
				string text4 = ((k < list2.Count - 1) ? "," : "");
				stringBuilder.AppendLine("    }" + text4);
			}
			stringBuilder.AppendLine("  ],");
			stringBuilder.AppendLine("  \"Emotes\": [");
			for (int m = 0; m < AvailableEmotes.Count; m++)
			{
				string text5 = ((m < AvailableEmotes.Count - 1) ? "," : "");
				stringBuilder.AppendLine("    \"" + EscapeJson(AvailableEmotes[m]) + "\"" + text5);
			}
			stringBuilder.AppendLine("  ]");
			stringBuilder.AppendLine("}");
			return stringBuilder.ToString();
		}

		public static void LoadFromServerJson(string json)
		{
			if (string.IsNullOrEmpty(json))
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Received empty templates from server");
				}
				return;
			}
			ManualLogSource log2 = VikingMessagesPlugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"LoadFromServerJson received {json.Length} characters");
			}
			try
			{
				Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>();
				Dictionary<string, List<string>> dictionary2 = new Dictionary<string, List<string>>();
				List<string> list = new List<string>();
				int num = json.IndexOf("\"Categories\"");
				if (num >= 0)
				{
					int num2 = json.IndexOf("[", num);
					int num3 = FindMatchingBracket(json, num2);
					if (num2 >= 0 && num3 > num2)
					{
						string json2 = json.Substring(num2, num3 - num2 + 1);
						ParseCategoryArray(json2, dictionary, "Templates");
					}
				}
				int num4 = json.IndexOf("\"WordCategories\"");
				if (num4 >= 0)
				{
					int num5 = json.IndexOf("[", num4);
					int num6 = FindMatchingBracket(json, num5);
					if (num5 >= 0 && num6 > num5)
					{
						string json3 = json.Substring(num5, num6 - num5 + 1);
						ParseCategoryArray(json3, dictionary2, "Words");
					}
				}
				int num7 = json.IndexOf("\"Emotes\"");
				if (num7 >= 0)
				{
					int num8 = json.IndexOf("[", num7);
					int num9 = FindMatchingBracket(json, num8);
					if (num8 >= 0 && num9 > num8)
					{
						string text = json.Substring(num8 + 1, num9 - num8 - 1);
						int num10 = 0;
						while (num10 < text.Length)
						{
							int num11 = text.IndexOf("\"", num10);
							if (num11 < 0)
							{
								break;
							}
							int num12 = text.IndexOf("\"", num11 + 1);
							if (num12 < 0)
							{
								break;
							}
							list.Add(text.Substring(num11 + 1, num12 - num11 - 1));
							num10 = num12 + 1;
						}
					}
				}
				if (dictionary.Count > 0)
				{
					Categories = dictionary;
					ManualLogSource log3 = VikingMessagesPlugin.Log;
					if (log3 != null)
					{
						log3.LogInfo((object)$"Loaded {Categories.Count} categories from server");
					}
				}
				if (dictionary2.Count > 0)
				{
					WordCategories = dictionary2;
					ManualLogSource log4 = VikingMessagesPlugin.Log;
					if (log4 != null)
					{
						log4.LogInfo((object)$"Loaded {WordCategories.Count} word categories from server");
					}
				}
				if (list.Count > 0)
				{
					AvailableEmotes = list;
					ManualLogSource log5 = VikingMessagesPlugin.Log;
					if (log5 != null)
					{
						log5.LogInfo((object)$"Loaded {AvailableEmotes.Count} emotes from server");
					}
				}
				ManualLogSource log6 = VikingMessagesPlugin.Log;
				if (log6 != null)
				{
					log6.LogInfo((object)$"Final server templates: {Categories.Count} categories, {WordCategories.Count} word types, {AvailableEmotes.Count} emotes");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log7 = VikingMessagesPlugin.Log;
				if (log7 != null)
				{
					log7.LogError((object)("Failed to load templates from server: " + ex.Message));
				}
			}
		}

		private static void ParseCategoryArray(string json, Dictionary<string, List<string>> output, string itemsField)
		{
			int num = 0;
			while (num < json.Length)
			{
				int num2 = json.IndexOf("{", num);
				if (num2 < 0)
				{
					break;
				}
				int num3 = FindMatchingBrace(json, num2);
				if (num3 < 0)
				{
					break;
				}
				string text = json.Substring(num2, num3 - num2 + 1);
				string text2 = ExtractJsonString(text, "Name");
				if (!string.IsNullOrEmpty(text2))
				{
					List<string> list = new List<string>();
					int num4 = text.IndexOf("\"" + itemsField + "\"");
					if (num4 >= 0)
					{
						int num5 = text.IndexOf("[", num4);
						int num6 = FindMatchingBracket(text, num5);
						if (num5 >= 0 && num6 > num5)
						{
							string text3 = text.Substring(num5 + 1, num6 - num5 - 1);
							int num7 = 0;
							while (num7 < text3.Length)
							{
								int num8 = text3.IndexOf("\"", num7);
								if (num8 < 0)
								{
									break;
								}
								int num9 = text3.IndexOf("\"", num8 + 1);
								if (num9 < 0)
								{
									break;
								}
								list.Add(text3.Substring(num8 + 1, num9 - num8 - 1));
								num7 = num9 + 1;
							}
						}
					}
					if (list.Count > 0)
					{
						output[text2] = list;
						ManualLogSource log = VikingMessagesPlugin.Log;
						if (log != null)
						{
							log.LogInfo((object)$"  Parsed '{text2}' with {list.Count} items");
						}
					}
				}
				num = num3 + 1;
			}
		}

		private static int FindMatchingBracket(string json, int start)
		{
			if (start < 0 || start >= json.Length || json[start] != '[')
			{
				return -1;
			}
			int num = 1;
			for (int i = start + 1; i < json.Length; i++)
			{
				if (json[i] == '[')
				{
					num++;
				}
				else if (json[i] == ']')
				{
					num--;
				}
				if (num == 0)
				{
					return i;
				}
			}
			return -1;
		}

		private static int FindMatchingBrace(string json, int start)
		{
			if (start < 0 || start >= json.Length || json[start] != '{')
			{
				return -1;
			}
			int num = 1;
			for (int i = start + 1; i < json.Length; i++)
			{
				if (json[i] == '{')
				{
					num++;
				}
				else if (json[i] == '}')
				{
					num--;
				}
				if (num == 0)
				{
					return i;
				}
			}
			return -1;
		}

		private static string ExtractJsonString(string json, string field)
		{
			string value = "\"" + field + "\"";
			int num = json.IndexOf(value);
			if (num < 0)
			{
				return null;
			}
			int num2 = json.IndexOf(":", num);
			if (num2 < 0)
			{
				return null;
			}
			int num3 = json.IndexOf("\"", num2);
			if (num3 < 0)
			{
				return null;
			}
			int num4 = json.IndexOf("\"", num3 + 1);
			if (num4 < 0)
			{
				return null;
			}
			return json.Substring(num3 + 1, num4 - num3 - 1);
		}

		private static void LoadDefaults()
		{
			Categories = new Dictionary<string, List<string>>
			{
				["Battle"] = new List<string> { "Beware of {0}", "Be wary of {0}", "{0} ahead", "Weak foe ahead", "Strong foe ahead", "Time for {0}", "Prepare for battle", "Ambush ahead!", "Retreat!", "Charge!" },
				["Guidance"] = new List<string> { "Try {0}", "Don't give up!", "Keep going", "Turn back", "Hidden path ahead", "Treasure ahead", "Trap ahead!", "Seek {0}", "Shortcut ahead" },
				["Location"] = new List<string> { "Boss ahead", "Dungeon ahead", "Village ahead", "Water ahead", "Mountain ahead", "Forest ahead", "Swamp ahead", "Cave ahead", "Shelter here", "Danger zone" },
				["Resources"] = new List<string> { "Ore vein nearby", "Rich in {0}", "Mining spot", "Hunting ground", "Good fishing", "Mushrooms ahead", "Food required" },
				["Emotion"] = new List<string> { "Praise Odin!", "Valhalla awaits!", "By Thor's hammer!", "Fear not", "Courage required", "Celebrate!", "Rest here", "Ah, {0}...", "O, {0}!" },
				["Multiplayer"] = new List<string> { "Need ally", "Seek friend", "Cooperation required", "Follow me", "Wait here", "Rally point", "Help needed!", "Offering help" },
				["Humor"] = new List<string> { "Liar ahead", "Message ahead", "Could this be {0}?", "Why is it always {0}?", "Behold, {0}!", "I did it!", "Gorgeous view ahead", "Time for sleep" }
			};
			WordCategories = new Dictionary<string, List<string>>
			{
				["Enemies"] = new List<string>
				{
					"Greylings", "Necks", "Boars", "Deer", "Greydwarfs", "Greydwarf Brutes", "Greydwarf Shamans", "Trolls", "Skeletons", "Draugr",
					"Draugr Elites", "Blobs", "Oozers", "Wraiths", "Leeches", "Surtlings", "Wolves", "Drakes", "Fenrings", "Stone Golems",
					"Ulvs", "Cultists", "Fulings", "Fuling Berserkers", "Fuling Shamans", "Deathsquitos", "Lox", "Growth", "Serpents", "Leviathans",
					"Seekers", "Seeker Soldiers", "Ticks", "Gjall", "Dvergr", "Dvergr Mages", "Charred", "Charred Archers", "Charred Warriors", "Morgens",
					"Fallen Valkyries", "Voltures", "Rancid Remains", "Body Piles", "Spawners"
				},
				["Bosses"] = new List<string> { "Eikthyr", "The Elder", "Bonemass", "Moder", "Yagluth", "The Queen", "Fader" },
				["Biomes"] = new List<string> { "Meadows", "Black Forest", "Swamp", "Mountains", "Plains", "Ocean", "Mistlands", "Ashlands", "Deep North" },
				["Materials"] = new List<string>
				{
					"Wood", "Stone", "Copper", "Tin", "Bronze", "Iron", "Silver", "Black Metal", "Leather", "Bone",
					"Flametal", "Eitr"
				},
				["Actions"] = new List<string> { "attacking", "blocking", "dodging", "jumping", "running", "sneaking", "swimming", "building", "crafting", "mining" },
				["Equipment"] = new List<string>
				{
					"sword", "axe", "mace", "spear", "bow", "shield", "armor", "pickaxe", "hammer", "torch",
					"staff", "crossbow"
				},
				["Concepts"] = new List<string> { "death", "victory", "glory", "honor", "courage", "strength", "Valhalla", "Odin", "Thor", "adventure" }
			};
			AvailableEmotes = new List<string>
			{
				"wave", "sit", "challenge", "cheer", "nonono", "thumbsup", "point", "bow", "cower", "cry",
				"despair", "flex", "kneel", "laugh", "roar", "shrug"
			};
		}

		public static string GetEmoteName(int index)
		{
			if (!_initialized)
			{
				Initialize();
			}
			if (index >= 0 && index < AvailableEmotes.Count)
			{
				return AvailableEmotes[index];
			}
			return "wave";
		}

		public static int GetEmoteIndex(string emoteName)
		{
			if (!_initialized)
			{
				Initialize();
			}
			int num = AvailableEmotes.IndexOf(emoteName.ToLower());
			return (num >= 0) ? num : 0;
		}

		public static string FormatMessage(string template, string words)
		{
			if (string.IsNullOrEmpty(template))
			{
				return "...";
			}
			if (template.Contains("{0}") && !string.IsNullOrEmpty(words))
			{
				return string.Format(template, words);
			}
			return template;
		}

		public static List<string> GetTemplatesByCategory(string category)
		{
			if (!_initialized)
			{
				Initialize();
			}
			List<string> value;
			return Categories.TryGetValue(category, out value) ? value : new List<string>();
		}

		public static List<string> GetWordsByCategory(string category)
		{
			if (!_initialized)
			{
				Initialize();
			}
			List<string> value;
			return WordCategories.TryGetValue(category, out value) ? value : new List<string>();
		}

		public static bool TemplateRequiresWord(string template)
		{
			return template?.Contains("{0}") ?? false;
		}
	}
	public class MessageUI : MonoBehaviour
	{
		private static MessageUI _instance;

		private bool _isCreatingMessage;

		private bool _isReadingMessage;

		private Vector3 _pendingPosition;

		private Quaternion _pendingRotation;

		private string _currentMessageId;

		private GameObject _createPanel;

		private GameObject _readPanel;

		private GameObject _backgroundOverlay;

		private Canvas _canvas;

		private int _categoryIndex;

		private int _templateIndex;

		private int _wordCategoryIndex;

		private int _wordIndex;

		private int _emoteIndex;

		private int _currentRow;

		private bool _isProlonging;

		private int _conjunctionIndex;

		private int _secondCategoryIndex;

		private int _secondTemplateIndex;

		private List<string> _secondTemplates;

		private static readonly List<string> Conjunctions = new List<string> { "and then,", "or,", "but,", "therefore,", "in short,", "by the way,", "so to speak,", "all the more,", "," };

		private List<string> _categories;

		private List<string> _templates;

		private List<string> _wordCategories;

		private List<string> _words;

		private List<string> _emotes;

		private Text _categoryText;

		private Text _templateText;

		private Text _wordCategoryText;

		private Text _wordText;

		private Text _emoteText;

		private Text _prolongText;

		private Text _conjunctionText;

		private Text _secondCategoryText;

		private Text _secondTemplateText;

		private Text _previewText;

		private Image[] _rowBackgrounds;

		private GameObject _conjunctionRow;

		private GameObject _secondCategoryRow;

		private GameObject _secondTemplateRow;

		private Text _messageText;

		private Text _reputationText;

		private static readonly Color PanelColor = new Color(0.15f, 0.12f, 0.08f, 0.95f);

		private static readonly Color BorderColor = new Color(0.55f, 0.45f, 0.3f, 1f);

		private static readonly Color TextColor = new Color(0.95f, 0.9f, 0.8f, 1f);

		private static readonly Color HighlightColor = new Color(0.8f, 0.65f, 0.35f, 1f);

		private static readonly Color SelectedBg = new Color(0.5f, 0.4f, 0.25f, 0.9f);

		private static readonly Color UnselectedBg = new Color(0.2f, 0.17f, 0.12f, 0.7f);

		private float _inputDelayTimer;

		private const float INPUT_DELAY = 0.3f;

		public static MessageUI Instance => _instance;

		public bool IsUIOpen => _isCreatingMessage || _isReadingMessage;

		private void Awake()
		{
			_instance = this;
			_categories = MessageTemplates.Categories.Keys.ToList();
			_wordCategories = MessageTemplates.WordCategories.Keys.ToList();
			_emotes = MessageTemplates.AvailableEmotes.ToList();
			_templates = ((_categories.Count > 0) ? MessageTemplates.GetTemplatesByCategory(_categories[0]).ToList() : new List<string>());
			_words = ((_wordCategories.Count > 0) ? MessageTemplates.GetWordsByCategory(_wordCategories[0]).ToList() : new List<string>());
			_secondTemplates = _templates.ToList();
			CreateUIElements();
			HideAllUI();
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"MessageUI initialized - {_categories.Count} categories, {_templates.Count} templates");
			}
		}

		private void Update()
		{
			if (_isCreatingMessage)
			{
				HandleCreateInput();
			}
			else if (_isReadingMessage)
			{
				HandleReadInput();
			}
		}

		private void HandleCreateInput()
		{
			bool flag = false;
			if (Input.GetKeyDown((KeyCode)273) || Input.GetKeyDown((KeyCode)119))
			{
				ChangeRow(-1);
				flag = true;
			}
			else if (Input.GetKeyDown((KeyCode)274) || Input.GetKeyDown((KeyCode)115))
			{
				ChangeRow(1);
				flag = true;
			}
			else if (Input.GetKeyDown((KeyCode)276) || Input.GetKeyDown((KeyCode)97))
			{
				ChangeOption(-1);
				flag = true;
			}
			else if (Input.GetKeyDown((KeyCode)275) || Input.GetKeyDown((KeyCode)100))
			{
				ChangeOption(1);
				flag = true;
			}
			else if (Input.GetKeyDown((KeyCode)101))
			{
				ConfirmMessage();
				flag = true;
			}
			else if (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)9))
			{
				CancelMessage();
				flag = true;
			}
			if (flag)
			{
				Input.ResetInputAxes();
			}
		}

		private void HandleReadInput()
		{
			if (_inputDelayTimer > 0f)
			{
				_inputDelayTimer -= Time.deltaTime;
			}
			else if (Input.GetMouseButtonDown(0))
			{
				VoteOnCurrentMessage(isPositive: true);
			}
			else if (Input.GetMouseButtonDown(1))
			{
				VoteOnCurrentMessage(isPositive: false);
			}
			else if (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)101) || Input.GetKeyDown((KeyCode)13))
			{
				CloseReadUI();
			}
		}

		private void ChangeRow(int direction)
		{
			int num = (_isProlonging ? 8 : 5);
			_currentRow += direction;
			if (_currentRow < 0)
			{
				_currentRow = num;
			}
			if (_currentRow > num)
			{
				_currentRow = 0;
			}
			if (!_isProlonging && _currentRow > 5)
			{
				_currentRow = ((direction <= 0) ? 5 : 0);
			}
			UpdateRowHighlights();
		}

		private void ChangeOption(int direction)
		{
			switch (_currentRow)
			{
			case 0:
				_categoryIndex = WrapIndex(_categoryIndex + direction, _categories.Count);
				_templates = MessageTemplates.GetTemplatesByCategory(_categories[_categoryIndex]).ToList();
				_templateIndex = 0;
				UpdateCategoryDisplay();
				UpdateTemplateDisplay();
				break;
			case 1:
				_templateIndex = WrapIndex(_templateIndex + direction, _templates.Count);
				UpdateTemplateDisplay();
				break;
			case 2:
				_wordCategoryIndex = WrapIndex(_wordCategoryIndex + direction, _wordCategories.Count);
				_words = MessageTemplates.GetWordsByCategory(_wordCategories[_wordCategoryIndex]).ToList();
				_wordIndex = 0;
				UpdateWordCategoryDisplay();
				UpdateWordDisplay();
				break;
			case 3:
				_wordIndex = WrapIndex(_wordIndex + direction, _words.Count);
				UpdateWordDisplay();
				break;
			case 4:
				_emoteIndex = WrapIndex(_emoteIndex + direction, _emotes.Count);
				UpdateEmoteDisplay();
				break;
			case 5:
				_isProlonging = !_isProlonging;
				UpdateProlongDisplay();
				UpdateProlongRowsVisibility();
				break;
			case 6:
				_conjunctionIndex = WrapIndex(_conjunctionIndex + direction, Conjunctions.Count);
				UpdateConjunctionDisplay();
				break;
			case 7:
				_secondCategoryIndex = WrapIndex(_secondCategoryIndex + direction, _categories.Count);
				_secondTemplates = MessageTemplates.GetTemplatesByCategory(_categories[_secondCategoryIndex]).ToList();
				_secondTemplateIndex = 0;
				UpdateSecondCategoryDisplay();
				UpdateSecondTemplateDisplay();
				break;
			case 8:
				_secondTemplateIndex = WrapIndex(_secondTemplateIndex + direction, _secondTemplates.Count);
				UpdateSecondTemplateDisplay();
				break;
			}
			UpdatePreview();
		}

		private int WrapIndex(int index, int count)
		{
			if (count == 0)
			{
				return 0;
			}
			if (index < 0)
			{
				return count - 1;
			}
			if (index >= count)
			{
				return 0;
			}
			return index;
		}

		private void UpdateRowHighlights()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (_rowBackgrounds == null)
			{
				return;
			}
			for (int i = 0; i < _rowBackgrounds.Length; i++)
			{
				if ((Object)(object)_rowBackgrounds[i] != (Object)null)
				{
					((Graphic)_rowBackgrounds[i]).color = ((i == _currentRow) ? SelectedBg : UnselectedBg);
				}
			}
		}

		private void UpdateCategoryDisplay()
		{
			if ((Object)(object)_categoryText != (Object)null && _categories.Count > 0)
			{
				_categoryText.text = "◄ " + _categories[_categoryIndex] + " ►";
			}
		}

		private void UpdateTemplateDisplay()
		{
			if ((Object)(object)_templateText != (Object)null && _templates.Count > 0)
			{
				_templateText.text = "◄ " + _templates[_templateIndex] + " ►";
			}
		}

		private void UpdateWordCategoryDisplay()
		{
			if ((Object)(object)_wordCategoryText != (Object)null && _wordCategories.Count > 0)
			{
				_wordCategoryText.text = "◄ " + _wordCategories[_wordCategoryIndex] + " ►";
			}
		}

		private void UpdateWordDisplay()
		{
			if ((Object)(object)_wordText != (Object)null && _words.Count > 0)
			{
				_wordText.text = "◄ " + _words[_wordIndex] + " ►";
			}
		}

		private void UpdateEmoteDisplay()
		{
			if ((Object)(object)_emoteText != (Object)null && _emotes.Count > 0)
			{
				_emoteText.text = "◄ " + _emotes[_emoteIndex] + " ►";
			}
		}

		private void UpdateProlongDisplay()
		{
			if ((Object)(object)_prolongText != (Object)null)
			{
				_prolongText.text = (_isProlonging ? "◄ Yes ►" : "◄ No ►");
			}
		}

		private void UpdateProlongRowsVisibility()
		{
			if ((Object)(object)_conjunctionRow != (Object)null)
			{
				_conjunctionRow.SetActive(_isProlonging);
			}
			if ((Object)(object)_secondCategoryRow != (Object)null)
			{
				_secondCategoryRow.SetActive(_isProlonging);
			}
			if ((Object)(object)_secondTemplateRow != (Object)null)
			{
				_secondTemplateRow.SetActive(_isProlonging);
			}
			UpdateRowHighlights();
		}

		private void UpdateConjunctionDisplay()
		{
			if ((Object)(object)_conjunctionText != (Object)null && Conjunctions.Count > 0)
			{
				_conjunctionText.text = "◄ " + Conjunctions[_conjunctionIndex] + " ►";
			}
		}

		private void UpdateSecondCategoryDisplay()
		{
			if ((Object)(object)_secondCategoryText != (Object)null && _categories.Count > 0)
			{
				_secondCategoryText.text = "◄ " + _categories[_secondCategoryIndex] + " ►";
			}
		}

		private void UpdateSecondTemplateDisplay()
		{
			if ((Object)(object)_secondTemplateText != (Object)null && _secondTemplates != null && _secondTemplates.Count > 0)
			{
				_secondTemplateText.text = "◄ " + _secondTemplates[_secondTemplateIndex] + " ►";
			}
		}

		private void UpdatePreview()
		{
			if (!((Object)(object)_previewText == (Object)null))
			{
				string template = ((_templates.Count > _templateIndex) ? _templates[_templateIndex] : "");
				string words = ((_words.Count > _wordIndex) ? _words[_wordIndex] : "");
				string text = MessageTemplates.FormatMessage(template, words);
				if (_isProlonging && _secondTemplates != null && _secondTemplates.Count > _secondTemplateIndex)
				{
					string text2 = ((Conjunctions.Count > _conjunctionIndex) ? Conjunctions[_conjunctionIndex] : ",");
					string template2 = _secondTemplates[_secondTemplateIndex];
					string text3 = MessageTemplates.FormatMessage(template2, words);
					text3 = text3.ToLower();
					text = text + "\n" + text2 + " " + text3;
				}
				_previewText.text = "\"" + text + "\"";
			}
		}

		private void UpdateAllDisplays()
		{
			UpdateCategoryDisplay();
			UpdateTemplateDisplay();
			UpdateWordCategoryDisplay();
			UpdateWordDisplay();
			UpdateEmoteDisplay();
			UpdateProlongDisplay();
			UpdateConjunctionDisplay();
			UpdateSecondCategoryDisplay();
			UpdateSecondTemplateDisplay();
			UpdatePreview();
			UpdateRowHighlights();
			UpdateProlongRowsVisibility();
		}

		private void CreateUIElements()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0062: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("VikingMessagesCanvas");
			val.transform.SetParent(((Component)this).transform);
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 200;
			CanvasScaler val2 = val.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val.AddComponent<GraphicRaycaster>();
			_backgroundOverlay = CreatePanel("BackgroundOverlay", val.transform, Vector2.zero, new Vector2(4000f, 4000f));
			((Graphic)_backgroundOverlay.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.5f);
			CreateMessageCreateUI(val.transform);
			CreateMessageReadUI(val.transform);
		}

		private void CreateMessageCreateUI(Transform parent)
		{
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_0741: Unknown result type (might be due to invalid IL or missing references)
			//IL_075b: Unknown result type (might be due to invalid IL or missing references)
			//IL_078e: Unknown result type (might be due to invalid IL or missing references)
			//IL_079d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_080d: Unknown result type (might be due to invalid IL or missing references)
			//IL_081a: Unknown result type (might be due to invalid IL or missing references)
			//IL_083d: Unknown result type (might be due to invalid IL or missing references)
			//IL_084c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0859: Unknown result type (might be due to invalid IL or missing references)
			//IL_089d: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_08eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_093c: Unknown result type (might be due to invalid IL or missing references)
			//IL_094b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0958: Unknown result type (might be due to invalid IL or missing references)
			//IL_097b: Unknown result type (might be due to invalid IL or missing references)
			//IL_098a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0997: Unknown result type (might be due to invalid IL or missing references)
			//IL_09db: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a89: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b05: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b21: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b92: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bbd: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00c9: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0509: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_0580: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_0621: Unknown result type (might be due to invalid IL or missing references)
			//IL_062a: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_0688: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06af: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.Instance;
			if (instance != null)
			{
				try
				{
					_createPanel = instance.CreateWoodpanel(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 600f, 620f, false);
					if ((Object)(object)_createPanel != (Object)null)
					{
						Font averiaSerifBold = instance.AveriaSerifBold;
						Font averiaSerif = instance.AveriaSerif;
						Color valheimOrange = instance.ValheimOrange;
						GameObject val = instance.CreateText("Inscribe Message", _createPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -35f), averiaSerifBold, 24, valheimOrange, true, Color.black, 560f, 40f, false);
						Text component = val.GetComponent<Text>();
						if ((Object)(object)component != (Object)null)
						{
							component.alignment = (TextAnchor)4;
						}
						_rowBackgrounds = (Image[])(object)new Image[9];
						float num = -75f;
						float num2 = 38f;
						_rowBackgrounds[0] = CreateNativeRow(_createPanel.transform, num, instance);
						CreateNativeLabel(_createPanel.transform, "Category:", new Vector2(-80f, num), averiaSerif, valheimOrange);
						_categoryText = CreateNativeValue(_createPanel.transform, new Vector2(80f, num), averiaSerif);
						num -= num2;
						_rowBackgrounds[1] = CreateNativeRow(_createPanel.transform, num, instance);
						CreateNativeLabel(_createPanel.transform, "Template:", new Vector2(-80f, num), averiaSerif, valheimOrange);
						_templateText = CreateNativeValue(_createPanel.transform, new Vector2(80f, num), averiaSerif);
						num -= num2;
						_rowBackgrounds[2] = CreateNativeRow(_createPanel.transform, num, instance);
						CreateNativeLabel(_createPanel.transform, "Word Type:", new Vector2(-80f, num), averiaSerif, valheimOrange);
						_wordCategoryText = CreateNativeValue(_createPanel.transform, new Vector2(80f, num), averiaSerif);
						num -= num2;
						_rowBackgrounds[3] = CreateNativeRow(_createPanel.transform, num, instance);
						CreateNativeLabel(_createPanel.transform, "Word:", new Vector2(-80f, num), averiaSerif, valheimOrange);
						_wordText = CreateNativeValue(_createPanel.transform, new Vector2(80f, num), averiaSerif);
						num -= num2;
						_rowBackgrounds[4] = CreateNativeRow(_createPanel.transform, num, instance);
						CreateNativeLabel(_createPanel.transform, "Gesture:", new Vector2(-80f, num), averiaSerif, valheimOrange);
						_emoteText = CreateNativeValue(_createPanel.transform, new Vector2(80f, num), averiaSerif);
						num -= num2;
						_rowBackgrounds[5] = CreateNativeRow(_createPanel.transform, num, instance);
						CreateNativeLabel(_createPanel.transform, "Prolong:", new Vector2(-80f, num), averiaSerif, valheimOrange);
						_prolongText = CreateNativeValue(_createPanel.transform, new Vector2(80f, num), averiaSerif);
						num -= num2;
						GameObject val2 = (_conjunctionRow = CreateNativeRowWithParent(_createPanel.transform, num, instance, out _rowBackgrounds[6]));
						CreateNativeLabelInParent(val2.transform, "Conjunction:", new Vector2(-80f, 0f), averiaSerif, valheimOrange);
						_conjunctionText = CreateNativeValueInParent(val2.transform, new Vector2(80f, 0f), averiaSerif);
						_conjunctionRow.SetActive(false);
						num -= num2;
						GameObject val3 = (_secondCategoryRow = CreateNativeRowWithParent(_createPanel.transform, num, instance, out _rowBackgrounds[7]));
						CreateNativeLabelInParent(val3.transform, "2nd Category:", new Vector2(-80f, 0f), averiaSerif, valheimOrange);
						_secondCategoryText = CreateNativeValueInParent(val3.transform, new Vector2(80f, 0f), averiaSerif);
						_secondCategoryRow.SetActive(false);
						num -= num2;
						GameObject val4 = (_secondTemplateRow = CreateNativeRowWithParent(_createPanel.transform, num, instance, out _rowBackgrounds[8]));
						CreateNativeLabelInParent(val4.transform, "2nd Template:", new Vector2(-80f, 0f), averiaSerif, valheimOrange);
						_secondTemplateText = CreateNativeValueInParent(val4.transform, new Vector2(80f, 0f), averiaSerif);
						_secondTemplateRow.SetActive(false);
						num -= num2 + 10f;
						GameObject val5 = instance.CreateText("─── Preview ───", _createPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num), averiaSerif, 14, new Color(0.7f, 0.65f, 0.5f), true, Color.black, 560f, 25f, false);
						Text component2 = val5.GetComponent<Text>();
						if ((Object)(object)component2 != (Object)null)
						{
							component2.alignment = (TextAnchor)4;
						}
						num -= 55f;
						GameObject val6 = instance.CreateText("", _createPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, num), averiaSerifBold, 18, valheimOrange, true, Color.black, 560f, 65f, false);
						_previewText = val6.GetComponent<Text>();
						_previewText.alignment = (TextAnchor)4;
						GameObject val7 = instance.CreateText("[↑↓] Row    [←→] Option    [E] Confirm    [Esc] Cancel", _createPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 35f), averiaSerif, 13, new Color(0.7f, 0.65f, 0.5f), true, Color.black, 560f, 30f, false);
						Text component3 = val7.GetComponent<Text>();
						if ((Object)(object)component3 != (Object)null)
						{
							component3.alignment = (TextAnchor)4;
						}
						_createPanel.SetActive(false);
						return;
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log = VikingMessagesPlugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Failed to create Valheim-style create panel: " + ex.Message));
					}
				}
			}
			_createPanel = CreatePanel("CreateMessagePanel", parent, Vector2.zero, new Vector2(520f, 440f));
			((Graphic)_createPanel.GetComponent<Image>()).color = PanelColor;
			AddBorder(_createPanel);
			CreateText("Title", _createPanel.transform, new Vector2(0f, 185f), new Vector2(480f, 40f), "═══ INSCRIBE MESSAGE ═══", 22, (TextAnchor)4, HighlightColor);
			_rowBackgrounds = (Image[])(object)new Image[5];
			float num3 = 125f;
			float num4 = 42f;
			_rowBackgrounds[0] = CreateRowBackground(_createPanel.transform, num3);
			CreateText("CategoryLabel", _createPanel.transform, new Vector2(-160f, num3), new Vector2(120f, 35f), "Category:", 15, (TextAnchor)5, TextColor);
			_categoryText = CreateText("CategoryValue", _createPanel.transform, new Vector2(60f, num3), new Vector2(240f, 35f), "", 14, (TextAnchor)4, TextColor);
			num3 -= num4;
			_rowBackgrounds[1] = CreateRowBackground(_createPanel.transform, num3);
			CreateText("TemplateLabel", _createPanel.transform, new Vector2(-160f, num3), new Vector2(120f, 35f), "Template:", 15, (TextAnchor)5, TextColor);
			_templateText = CreateText("TemplateValue", _createPanel.transform, new Vector2(60f, num3), new Vector2(240f, 35f), "", 14, (TextAnchor)4, TextColor);
			num3 -= num4;
			_rowBackgrounds[2] = CreateRowBackground(_createPanel.transform, num3);
			CreateText("WordCatLabel", _createPanel.transform, new Vector2(-160f, num3), new Vector2(120f, 35f), "Word Type:", 15, (TextAnchor)5, TextColor);
			_wordCategoryText = CreateText("WordCatValue", _createPanel.transform, new Vector2(60f, num3), new Vector2(240f, 35f), "", 14, (TextAnchor)4, TextColor);
			num3 -= num4;
			_rowBackgrounds[3] = CreateRowBackground(_createPanel.transform, num3);
			CreateText("WordLabel", _createPanel.transform, new Vector2(-160f, num3), new Vector2(120f, 35f), "Word:", 15, (TextAnchor)5, TextColor);
			_wordText = CreateText("WordValue", _createPanel.transform, new Vector2(60f, num3), new Vector2(240f, 35f), "", 14, (TextAnchor)4, TextColor);
			num3 -= num4;
			_rowBackgrounds[4] = CreateRowBackground(_createPanel.transform, num3);
			CreateText("EmoteLabel", _createPanel.transform, new Vector2(-160f, num3), new Vector2(120f, 35f), "Gesture:", 15, (TextAnchor)5, TextColor);
			_emoteText = CreateText("EmoteValue", _createPanel.transform, new Vector2(60f, num3), new Vector2(240f, 35f), "", 14, (TextAnchor)4, TextColor);
			num3 -= num4 + 10f;
			CreateText("PreviewLabel", _createPanel.transform, new Vector2(0f, num3), new Vector2(480f, 25f), "── Preview ──", 14, (TextAnchor)4, TextColor);
			num3 -= 35f;
			_previewText = CreateText("Preview", _createPanel.transform, new Vector2(0f, num3), new Vector2(480f, 40f), "", 18, (TextAnchor)4, HighlightColor);
			CreateText("Controls", _createPanel.transform, new Vector2(0f, -190f), new Vector2(480f, 40f), "[↑↓] Row    [←→] Option    [E] Confirm    [Esc] Cancel", 12, (TextAnchor)4, new Color(0.6f, 0.55f, 0.45f));
			_createPanel.SetActive(false);
		}

		private Image CreateNativeRow(Transform parent, float yPos, GUIManager guiMgr)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("RowBg");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.anchoredPosition = new Vector2(0f, yPos);
			val2.sizeDelta = new Vector2(500f, 38f);
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.2f, 0.15f, 0.1f, 0.5f);
			return val3;
		}

		private void CreateNativeLabel(Transform parent, string text, Vector2 position, Font font, Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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_0074: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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)
			GameObject val = new GameObject("Label");
			val.transform.SetParent(parent, false);
			Text val2 = val.AddComponent<Text>();
			val2.text = text;
			val2.font = font;
			val2.fontSize = 16;
			((Graphic)val2).color = color;
			val2.alignment = (TextAnchor)5;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(180f, 35f);
			component.anchoredPosition = position;
			Outline val3 = val.AddComponent<Outline>();
			((Shadow)val3).effectColor = Color.black;
			((Shadow)val3).effectDistance = new Vector2(1f, -1f);
		}

		private Text CreateNativeValue(Transform parent, Vector2 position, Font font)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_004e: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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)
			GameObject val = new GameObject("Value");
			val.transform.SetParent(parent, false);
			Text val2 = val.AddComponent<Text>();
			val2.text = "";
			val2.font = font;
			val2.fontSize = 15;
			((Graphic)val2).color = new Color(0.95f, 0.9f, 0.8f);
			val2.alignment = (TextAnchor)4;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(280f, 35f);
			component.anchoredPosition = position;
			Outline val3 = val.AddComponent<Outline>();
			((Shadow)val3).effectColor = Color.black;
			((Shadow)val3).effectDistance = new Vector2(1f, -1f);
			return val2;
		}

		private GameObject CreateNativeRowWithParent(Transform parent, float yPos, GUIManager guiMgr, out Image bgImage)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Row");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.anchoredPosition = new Vector2(0f, yPos);
			val2.sizeDelta = new Vector2(560f, 38f);
			GameObject val3 = new GameObject("RowBg");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.sizeDelta = Vector2.zero;
			bgImage = val3.AddComponent<Image>();
			((Graphic)bgImage).color = new Color(0.2f, 0.15f, 0.1f, 0.5f);
			return val;
		}

		private void CreateNativeLabelInParent(Transform parent, string text, Vector2 position, Font font, Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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_0074: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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)
			GameObject val = new GameObject("Label");
			val.transform.SetParent(parent, false);
			Text val2 = val.AddComponent<Text>();
			val2.text = text;
			val2.font = font;
			val2.fontSize = 16;
			((Graphic)val2).color = color;
			val2.alignment = (TextAnchor)5;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(180f, 35f);
			component.anchoredPosition = position;
			Outline val3 = val.AddComponent<Outline>();
			((Shadow)val3).effectColor = Color.black;
			((Shadow)val3).effectDistance = new Vector2(1f, -1f);
		}

		private Text CreateNativeValueInParent(Transform parent, Vector2 position, Font font)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_004e: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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)
			GameObject val = new GameObject("Value");
			val.transform.SetParent(parent, false);
			Text val2 = val.AddComponent<Text>();
			val2.text = "";
			val2.font = font;
			val2.fontSize = 15;
			((Graphic)val2).color = new Color(0.95f, 0.9f, 0.8f);
			val2.alignment = (TextAnchor)4;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(280f, 35f);
			component.anchoredPosition = position;
			Outline val3 = val.AddComponent<Outline>();
			((Shadow)val3).effectColor = Color.black;
			((Shadow)val3).effectDistance = new Vector2(1f, -1f);
			return val2;
		}

		private Image CreateRowBackground(Transform parent, float yPos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002c: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			GameObject val = new GameObject("RowBg");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.5f, 0.5f);
			val2.anchorMax = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = new Vector2(0f, yPos);
			val2.sizeDelta = new Vector2(480f, 38f);
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = UnselectedBg;
			return val3;
		}

		private void CreateMessageReadUI(Transform parent)
		{
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_0121: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			GUIManager instance = GUIManager.Instance;
			if (instance != null)
			{
				try
				{
					_readPanel = instance.CreateWoodpanel(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 100f), 550f, 220f, false);
					if ((Object)(object)_readPanel != (Object)null)
					{
						GameObject val = instance.CreateText("", _readPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -50f), instance.AveriaSerifBold, 22, new Color(1f, 0.95f, 0.8f), true, Color.black, 500f, 60f, false);
						_messageText = val.GetComponent<Text>();
						_messageText.alignment = (TextAnchor)4;
						GameObject val2 = instance.CreateText("Reputation: 0", _readPanel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -110f), instance.AveriaSerif, 18, GUIManager.Instance.ValheimOrange, true, Color.black, 500f, 35f, false);
						_reputationText = val2.GetComponent<Text>();
						_reputationText.alignment = (TextAnchor)4;
						GameObject val3 = instance.CreateText("[Left Click] Appraise    [Right Click] Disparage    [E/Esc] Close", _readPanel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 40f), instance.AveriaSerif, 14, new Color(0.7f, 0.65f, 0.5f), true, Color.black, 520f, 35f, false);
						val3.GetComponent<Text>().alignment = (TextAnchor)4;
						_readPanel.SetActive(false);
						return;
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log = VikingMessagesPlugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Failed to create Valheim-style read panel: " + ex.Message));
					}
				}
			}
			_readPanel = CreatePanel("ReadMessagePanel", parent, new Vector2(0f, 100f), new Vector2(550f, 220f));
			((Graphic)_readPanel.GetComponent<Image>()).color = PanelColor;
			AddBorder(_readPanel);
			_messageText = CreateText("MessageText", _readPanel.transform, new Vector2(0f, 50f), new Vector2(500f, 60f), "", 22, (TextAnchor)4, TextColor);
			_reputationText = CreateText("ReputationText", _readPanel.transform, new Vector2(0f, -10f), new Vector2(500f, 35f), "Reputation: 0", 18, (TextAnchor)4, HighlightColor);
			CreateText("ControlsHint", _readPanel.transform, new Vector2(0f, -70f), new Vector2(520f, 35f), "[Left Click] Appraise    [Right Click] Disparage    [E/Esc] Close", 14, (TextAnchor)4, new Color(0.6f, 0.55f, 0.45f));
			_readPanel.SetActive(false);
		}

		private GameObject CreatePanel(string name, Transform parent, Vector2 position, Vector2 size)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0028: 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_004a: 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)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.5f, 0.5f);
			val2.anchorMax = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = position;
			val2.sizeDelta = size;
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = PanelColor;
			return val;
		}

		private void AddBorder(GameObject panel)
		{
			//IL_0009: 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)
			Outline val = panel.AddComponent<Outline>();
			((Shadow)val).effectColor = BorderColor;
			((Shadow)val).effectDistance = new Vector2(2f, 2f);
		}

		private Text CreateText(string name, Transform parent, Vector2 position, Vector2 size, string content, int fontSize, TextAnchor alignment, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0028: 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_004a: 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)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.5f, 0.5f);
			val2.anchorMax = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = position;
			val2.sizeDelta = size;
			Text val3 = val.AddComponent<Text>();
			val3.text = content;
			val3.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			val3.fontSize = fontSize;
			((Graphic)val3).color = color;
			val3.alignment = alignment;
			return val3;
		}

		public void ShowCreateUI(Vector3 position, Quaternion rotation)
		{
			//IL_0018: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"ShowCreateUI called");
			}
			_pendingPosition = position;
			_pendingRotation = rotation;
			_categoryIndex = 0;
			_templateIndex = 0;
			_wordCategoryIndex = 0;
			_wordIndex = 0;
			_emoteIndex = 0;
			_currentRow = 0;
			_isProlonging = false;
			_conjunctionIndex = 0;
			_secondCategoryIndex = 0;
			_secondTemplateIndex = 0;
			_categories = MessageTemplates.Categories.Keys.ToList();
			_wordCategories = MessageTemplates.WordCategories.Keys.ToList();
			_emotes = MessageTemplates.AvailableEmotes.ToList();
			if (_categories.Count > 0)
			{
				_templates = MessageTemplates.GetTemplatesByCategory(_categories[0]).ToList();
				_secondTemplates = _templates.ToList();
			}
			if (_wordCategories.Count > 0)
			{
				_words = MessageTemplates.GetWordsByCategory(_wordCategories[0]).ToList();
			}
			UpdateAllDisplays();
			GameObject backgroundOverlay = _backgroundOverlay;
			if (backgroundOverlay != null)
			{
				backgroundOverlay.SetActive(true);
			}
			GameObject createPanel = _createPanel;
			if (createPanel != null)
			{
				createPanel.SetActive(true);
			}
			_isCreatingMessage = true;
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			ManualLogSource log2 = VikingMessagesPlugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"Create UI shown - templates: {_templates.Count}, words: {_words.Count}");
			}
		}

		public void ShowReadUI(string messageId, string messageText, int reputation)
		{
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"ShowReadUI called: id={messageId}, rep={reputation}");
			}
			_currentMessageId = messageId;
			if ((Object)(object)_messageText != (Object)null)
			{
				_messageText.text = "\"" + messageText + "\"";
			}
			if ((Object)(object)_reputationText != (Object)null)
			{
				_reputationText.text = $"Reputation: {reputation}";
			}
			GameObject backgroundOverlay = _backgroundOverlay;
			if (backgroundOverlay != null)
			{
				backgroundOverlay.SetActive(true);
			}
			GameObject readPanel = _readPanel;
			if (readPanel != null)
			{
				readPanel.SetActive(true);
			}
			_isReadingMessage = true;
			_inputDelayTimer = 0.3f;
			GUIManager.BlockInput(true);
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}

		private void ConfirmMessage()
		{
			//IL_0167: 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)
			string text = ((_templates.Count > _templateIndex) ? _templates[_templateIndex] : "");
			string text2 = ((_words.Count > _wordIndex) ? _words[_wordIndex] : "");
			int emoteIndex = _emoteIndex;
			string text3 = text;
			if (_isProlonging && _secondTemplates != null && _secondTemplates.Count > _secondTemplateIndex)
			{
				string text4 = ((Conjunctions.Count > _conjunctionIndex) ? Conjunctions[_conjunctionIndex] : ",");
				string text5 = _secondTemplates[_secondTemplateIndex];
				text5 = text5.ToLower();
				text3 = text + "\n" + text4 + " " + text5;
			}
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"ConfirmMessage: template='{text3}', word='{text2}', emote={emoteIndex}, prolonged={_isProlonging}");
			}
			if (string.IsNullOrEmpty(text))
			{
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"No template selected!");
				}
			}
			else
			{
				MessageManagerAlt.PlaceMessage(_pendingPosition, _pendingRotation, text3, text2, emoteIndex);
				SoundManager.PlayMessagePlaced();
				HideAllUI();
				RelockCursor();
			}
		}

		private void CancelMessage()
		{
			HideAllUI();
			RelockCursor();
			try
			{
				if (!((Object)(object)Player.m_localPlayer != (Object)null))
				{
					return;
				}
				GameObject prefab = PrefabManager.Instance.GetPrefab("MessageGlyph");
				if ((Object)(object)prefab != (Object)null)
				{
					ItemDrop component = prefab.GetComponent<ItemDrop>();
					if ((Object)(object)component != (Object)null)
					{
						ItemData val = component.m_itemData.Clone();
						val.m_stack = 1;
						((Humanoid)Player.m_localPlayer).GetInventory().AddItem(val);
						((Character)Player.m_localPlayer).Message((MessageType)1, "Message cancelled, glyph returned", 0, (Sprite)null);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not refund glyph: " + ex.Message));
				}
			}
		}

		private void VoteOnCurrentMessage(bool isPositive)
		{
			if (string.IsNullOrEmpty(_currentMessageId))
			{
				return;
			}
			ManualLogSource log = VikingMessagesPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Voting on " + _currentMessageId + ": " + (isPositive ? "Appraise" : "Disparage")));
			}
			if (MessageManagerAlt.VoteMessage(_currentMessageId, isPositive))
			{
				VikingMessage message = MessageManagerAlt.GetMessage(_currentMessageId);
				if (message != null && (Object)(object)_reputationText != (Object)null)
				{
					_reputationText.text = $"Reputation: {message.Reputation}";
				}
				string text = (isPositive ? "Appraised!" : "Disparaged!");
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
				}
			}
		}

		private void CloseReadUI()
		{
			_currentMessageId = null;
			HideAllUI();
			RelockCursor();
		}

		private void HideAllUI()
		{
			GameObject createPanel = _createPanel;
			if (createPanel != null)
			{
				createPanel.SetActive(false);
			}
			GameObject readPanel = _readPanel;
			if (readPanel != null)
			{
				readPanel.SetActive(false);
			}
			GameObject backgroundOverlay = _backgroundOverlay;
			if (backgroundOverlay != null)
			{
				backgroundOverlay.SetActive(false);
			}
			_isCreatingMessage = false;
			_isReadingMessage = false;
		}

		private void RelockCursor()
		{
			GUIManager.BlockInput(false);
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
		}
	}
	public static class MessageUIManager
	{
		private static MessageUI _ui;

		public static MessageUI UI
		{
			get
			{
				if ((Object)(object)_ui == (Object)null)
				{
					CreateUI();
				}
				return _ui;
			}
		}

		public static bool IsUIOpen => UI?.IsUIOpen ?? false;

		private static void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("VikingMessagesUI");
			Object.DontDestroyOnLoad((Object)(object)val);
			_ui = val.AddComponent<MessageUI>();
		}

		public static void ShowCreateUI(Vector3 position, Quaternion rotation)
		{
			//IL_000c: 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)
			UI?.ShowCreateUI(position, rotation);
		}

		public static void ShowReadUI(string messageId, string messageText, int reputation)
		{
			UI?.ShowReadUI(messageId, messageText, reputation);
		}
	}
	public class SoundManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <LoadAudioClip>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public SoundManager <>4__this;

			private string <pluginPath>5__1;

			private string <pluginDir>5__2;

			private string <audioPath>5__3;

			private string <fileUrl>5__4;

			private UnityWebRequest <www>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadAudioClip>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<pluginPath>5__1 = null;
				<pluginDir>5__2 = null;
				<audioPath>5__3 = null;
				<fileUrl>5__4 = null;
				<www>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						<pluginPath>5__1 = Assembly.GetExecutingAssembly().Location;
						<pluginDir>5__2 = Path.GetDirectoryName(<pluginPath>5__1);
						<audioPath>5__3 = Path.Combine(<pluginDir>5__2, "placement_audio.mp3");
						ManualLogSource log3 = VikingMessagesPlugin.Log;
						if (log3 != null)
						{
							log3.LogInfo((object)("Looking for audio at: " + <audioPath>5__3));
						}
						if (!File.Exists(<audioPath>5__3))
						{
							ManualLogSource log4 = VikingMessagesPlugin.Log;
							if (log4 != null)
							{
								log4.LogWarning((object)("Audio file not found: " + <audioPath>5__3));
							}
							return false;
						}
						<fileUrl>5__4 = "file://" + <audioPath>5__3.Replace("\\", "/");
						<www>5__5 = UnityWebRequestMultimedia.GetAudioClip(<fileUrl>5__4, (AudioType)13);
						<>1__state = -3;
						<>2__current = <www>5__5.SendWebRequest();
						<>1__state = 1;
						return true;
					}
					case 1:
						<>1__state = -3;
						if ((int)<www>5__5.result == 1)
						{
							<>4__this._placementSound = DownloadHandlerAudioClip.GetContent(<www>5__5);
							<>4__this._audioLoaded = true;
							ManualLogSource log = VikingMessagesPlugin.Log;
							if (log != null)
							{
								log.LogInfo((object)"Placement sound loaded successfully");
							}
						}
						else
						{
							ManualLogSource log2 = VikingMessagesPlugin.Log;
							if (log2 != null)
							{
								log2.LogWarning((object)("Failed to load audio: " + <www>5__5.error));
							}
						}
						<>m__Finally1();
						<www>5__5 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<www>5__5 != null)
				{
					((IDisposable)<www>5__5).Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static SoundManager _instance;

		private AudioSource _audioSource;

		private AudioClip _placementSound;

		private bool _audioLoaded;

		public static SoundManager Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("VikingMessages_SoundManager");
					Object.DontDestroyOnLoad((Object)(object)val);
					_instance = val.AddComponent<SoundManager>();
				}
				return _instance;
			}
		}

		private void Awake()
		{
			_audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			_audioSource.playOnAwake = false;
			_audioSource.spatialBlend = 0f;
			_audioSource.volume = 0.7f;
		}

		public void Initialize()
		{
			((MonoBehaviour)this).StartCoroutine(LoadAudioClip());
		}

		[IteratorStateMachine(typeof(<LoadAudioClip>d__8))]
		private IEnumerator LoadAudioClip()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAudioClip>d__8(0)
			{
				<>4__this = this
			};
		}

		public void PlayPlacementSound()
		{
			if (!_audioLoaded || (Object)(object)_placementSound == (Object)null)
			{
				ManualLogSource log = VikingMessagesPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Placement sound not loaded");
				}
			}
			else if ((Object)(object)_audioSource != (Object)null)
			{
				_audioSource.PlayOneShot(_placementSound);
				ManualLogSource log2 = VikingMessagesPlugin.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)"Playing placement sound");
				}
			}
		}

		public static void PlayMessagePlaced()
		{
			Instance?.PlayPlacementSound();
		}
	}
	[BepInPlugin("com.vikings.messages", "Viking Messages", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class VikingMessagesPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.vikings.messages";

		public const string PluginName = "Viking Messages";

		public const string PluginVersion = "1.0.0";

		private Harmony _harmony;

		public static GameObject MessageStonePrefab;

		public static GameObject GhostPhantomPrefab;

		public static ConfigEntry<int> MinReputation;

		public static ConfigEntry<float> MessageInteractDistance;

		public static ConfigEntry<float> GhostDisplayDuration;

		public static ConfigEntry<string> ServerPassword;

		public static VikingMessagesPlugin Instance { get; private set; }

		public static ManualLogSource Log => ((BaseUnityPlugin)Instance).Logger;

		private void Awake()
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			Instance = this;
			MinReputation = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MinReputation", -5, "Minimum reputation before a message is removed");
			MessageInteractDistance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "InteractDistance", 3f, "Distance at which players can interact with messages");
			GhostDisplayDuration = ((BaseUnityPlugin)this).Config.Bind<float>("General", "GhostDuration", 5f, "Duration in seconds the ghost phantom is displayed");
			ServerPassword = ((BaseUnityPlugin)this).Config.Bind<string>("Security", "Password", "ashatasthvbahs", "Server authentication password (only checked on dedicated servers)");
			if (Application.isBatchMode && !VerifyPassword(ServerPassword.Value))
			{
				Log.LogError((object)"Viking Messages: Invalid server password. Mod will not load.");
				return;
			}
			_harmony = new Harmony("com.vikings.messages");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			MessageTemplates.Initialize();
			PrefabManager.OnVanillaPrefabsAvailable += RegisterPrefabsAndItems;
			MessageManagerAlt.Initialize();
			SoundManager.Instance.Initialize();
			Log.LogInfo((object)"Viking Messages v1.0.0 loaded!");
			Log.LogMessage((object)"═══════════════════════════════════════════════════════");
			Log.LogMessage((object)"         Made by Freyja - Viking Messages");
			Log.LogMessage((object)"         https://tinyurl.com/ValheimFreyja");
			Log.LogMessage((object)"═══════════════════════════════════════════════════════");
		}

		private bool VerifyPassword(string password)
		{
			if (string.IsNullOrEmpty(password))
			{
				return false;
			}
			int num = 0;
			foreach (char c in password)
			{
				num = num * 31 + c;
			}
			return num == -694624545;
		}

		private void Update()
		{
			LeaderboardManager.Update();
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			GhostPhantomManager.Cleanup();
		}

		private void RegisterPrefabsAndItems()
		{
			try
			{
				CreateMessageStonePrefab();
				CreateGhostPhantomPrefab();
				Log.LogInfo((object)"Prefabs registered successfully");
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Failed to register prefabs: {arg}");
			}
			try
			{
				CreateMessageGlyphItem();
				Log.LogInfo((object)"Items registered successfully");
			}
			catch (Exception arg2)
			{
				Log.LogError((object)$"Failed to register items: {arg2}");
			}
		}

		private void CreateMessageStonePrefab()
		{
			//IL_01f7: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_0075: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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)
			if ((Object)(object)MessageStonePrefab != (Object)null)
			{
				return;
			}
			MessageStonePrefab = new GameObject("VikingMessageStone");
			try
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab("stone_wall_2x1");
				if ((Object)(object)prefab != (Object)null)
				{
					MeshFilter[] componentsInChildren = prefab.GetComponentsInChildren<MeshFilter>();
					MeshRenderer[] componentsInChildren2 = prefab.GetComponentsInChildren<MeshRenderer>();
					for (int i = 0; i < componentsInChildren.Length && i < componentsInChildren2.Length; i++)
					{
						GameObject val = new GameObject("Mesh_" + i);
						val.transform.SetParent(MessageStonePrefab.transform);
						val.transform.localPosition = Vector3.zero;
						val.transform.localRotation = Quaternion.identity;
						val.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
						MeshFilter val2 = val.AddComponent<MeshFilter>();
						val2.sharedMesh = componentsInChildren[i].sharedMesh;
						MeshRenderer val3 = val.AddComponent<MeshRenderer>();
						((Renderer)val3).sharedMaterials = ((Renderer)componentsInChildren2[i]).sharedMaterials;
					}
				}
				else
				{
					GameObject val4 = GameObject.CreatePrimitive((PrimitiveType)3);
					val4.transform.SetParent(MessageStonePrefab.transform);
					val4.transform.localPosition = new Vector3(0f, 0.25f, 0f);
					val4.transform.localScale = new Vector3(0.5f, 0.5f, 0.3f);
					Object.Destroy((Object)(object)val4.GetComponent<Collider>());
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Could not copy stone mesh: " + ex.Message));
				GameObject val5 = GameObject.CreatePrimitive((PrimitiveType)3);
				val5.transform.SetParent(MessageStonePrefab.transform);
				val5.transform.localPosition = new Vector3(0f, 0.25f, 0f);
				val5.transform.localScale = new Vector3(0.5f, 0.5f, 0.3f);
				Object.Destroy((Object)(object)val5.GetComponent<Collider>());
			}
			BoxCollider val6 = MessageStonePrefab.AddComponent<BoxCollider>();
			val6.size = new Vector3(0.6f, 0.6f, 0.4f);
			val6.center = new Vector3(0f, 0.3f, 0f);
			MessageStonePrefab.AddComponent<MessageStone>();
			AddGlowLight(MessageStonePrefab);
			MessageStonePrefab.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)MessageStonePrefab);
			Log.LogInfo((object)"MessageStone prefab created (no ZNetView, no particles)");
		}

		private void AddGlowLight(GameObject obj)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0033: 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)
			GameObject val = new GameObject("GlowLight");
			val.transform.SetParent(obj.transform);
			val.transform.localPosition = new Vector3(0f, 0.5f, 0f);
			Light val2 = val.AddComponent<Light>();
			val2.type = (LightType)2;
			val2.color = new Color(0.7f, 0.85f, 1f);
			val2.intensity = 1.38f;
			val2.range = 4f;
			val2.shadows = (LightShadows)0;
		}

		private void CreateGhostPhantomPrefab()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (!((Object)(object)GhostPhantomPrefab != (Object)null))
			{
				GhostPhantomPrefab = new GameObject("VikingGhostPhantom");
				GhostPhantomPrefab.AddComponent<GhostPhantom>();
				GhostPhantomPrefab.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)GhostPhantomPrefab);
			}
		}

		private void CreateMessageGlyphItem()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)PrefabManager.Instance.GetPrefab("MessageGlyph") != (Object)null)
			{
				Log.LogInfo((object)"MessageGlyph already registered, skipping.");
				return;
			}
			Log.LogInfo((object)"Creating Message Glyph item...");
			GameObject prefab = PrefabManager.Instance.GetPrefab("Stone");
			if ((Object)(object)prefab == (Object)null)
			{
				Log.LogError((object)"Could not find Stone prefab for item creation!");
				return;
			}
			ItemConfig val = new ItemConfig();
			val.Name = "Message Glyph";
			val.Description = "A mystical stone used to inscribe messages for other travelers. Use to place a message.";
			val.CraftingStation = "";
			val.MinStationLevel = 0;
			val.Amount = 1;
			val.Requirements = (RequirementConfig[])(object)new RequirementConfig[2]
			{
				new RequirementConfig
				{
					Item = "Stone",
					Amount = 5
				},
				new RequirementConfig
				{
					Item = "GreydwarfEye",
					Amount = 1
				}
			};
			Log.LogInfo((object)"Item config created, creating CustomItem...");
			CustomItem val2 = new CustomItem("MessageGlyph", "Stone", val);
			Log.LogInfo((object)("CustomItem created: " + ((Object)val2.ItemPrefab).name));
			ItemDrop component = val2.ItemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component != (Object)null)
			{
				component.m_itemData.m_shared.m_name = "Message Glyph";
				component.m_itemData.m_shared.m_description = "A mystical stone used to inscribe messages for other travelers. Use to place a message.";
				component.m_itemData.m_shared.m_itemType = (ItemType)2;
				component.m_itemData.m_shared.m_maxStackSize = 50;
				component.m_itemData.m_shared.m_weight = 1f;
				Log.LogInfo((object)$"ItemDrop modified - Name: {component.m_itemData.m_shared.m_name}, Type: {component.m_itemData.m_shared.m_itemType}");
			}
			val2.ItemPrefab.AddComponent<MessageGlyphItem>();
			Log.LogInfo((object)"Added MessageGlyphItem component");
			ItemManager.Instance.AddItem(val2);
			Log.LogInfo((object)("Item added to ItemManager: " + ((Object)val2.ItemPrefab).name));
		}
	}
	public class GlowPulse : MonoBehaviour
	{
		private Light _light;

		private float _baseIntensity;

		private float _timer;

		private void Awake()
		{
			_light = ((Component)this).GetComponent<Light>();
			if ((Object)(object)_light != (Object)null)
			{
				_baseIntensity = _light.intensity;
			}
		}

		private void Update()
		{
			if ((Object)(object)_light != (Object)null)
			{
				_timer += Time.deltaTime * 2f;
				float num = 1f + Mathf.Sin(_timer) * 0.25f;
				_light.intensity = _baseIntensity * num;
			}
		}
	}
}