using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("Microsoft.Bcl.AsyncInterfaces")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("Provides the IAsyncEnumerable<T> and IAsyncDisposable interfaces and helper types for .NET Standard 2.0. This package is not required starting with .NET Standard 2.1 and .NET Core 3.0.\r\n\r\nCommonly Used Types:\r\nSystem.IAsyncDisposable\r\nSystem.Collections.Generic.IAsyncEnumerable\r\nSystem.Collections.Generic.IAsyncEnumerator")]
[assembly: AssemblyFileVersion("8.0.23.53103")]
[assembly: AssemblyInformationalVersion("8.0.0+5535e31a712343a63f5d7d796cd874e563e5ac14")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("Microsoft.Bcl.AsyncInterfaces")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: AssemblyVersion("8.0.0.0")]
[module: RefSafetyRules(11)]
[module: System.Runtime.CompilerServices.NullablePublicOnly(false)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace System
{
	public interface IAsyncDisposable
	{
		ValueTask DisposeAsync();
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
namespace System.Collections.Generic
{
	public interface IAsyncEnumerable<out T>
	{
		IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken));
	}
	public interface IAsyncEnumerator<out T> : IAsyncDisposable
	{
		T Current { get; }

		ValueTask<bool> MoveNextAsync();
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class LibraryImportAttribute : Attribute
	{
		public string LibraryName { get; }

		public string EntryPoint { get; set; }

		public StringMarshalling StringMarshalling { get; set; }

		public Type StringMarshallingCustomType { get; set; }

		public bool SetLastError { get; set; }

		public LibraryImportAttribute(string libraryName)
		{
			LibraryName = libraryName;
		}
	}
	internal enum StringMarshalling
	{
		Custom,
		Utf8,
		Utf16
	}
}
namespace System.Runtime.CompilerServices
{
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncIteratorMethodBuilder
	{
		private AsyncTaskMethodBuilder _methodBuilder;

		private object _id;

		internal object ObjectIdForDebugger => _id ?? Interlocked.CompareExchange(ref _id, new object(), null) ?? _id;

		public static AsyncIteratorMethodBuilder Create()
		{
			AsyncIteratorMethodBuilder result = default(AsyncIteratorMethodBuilder);
			result._methodBuilder = AsyncTaskMethodBuilder.Create();
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			_methodBuilder.Start(ref stateMachine);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			_methodBuilder.AwaitOnCompleted(ref awaiter, ref stateMachine);
		}

		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			_methodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
		}

		public void Complete()
		{
			_methodBuilder.SetResult();
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
	public sealed class AsyncIteratorStateMachineAttribute : StateMachineAttribute
	{
		public AsyncIteratorStateMachineAttribute(Type stateMachineType)
			: base(stateMachineType)
		{
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredAsyncDisposable
	{
		private readonly IAsyncDisposable _source;

		private readonly bool _continueOnCapturedContext;

		internal ConfiguredAsyncDisposable(IAsyncDisposable source, bool continueOnCapturedContext)
		{
			_source = source;
			_continueOnCapturedContext = continueOnCapturedContext;
		}

		public ConfiguredValueTaskAwaitable DisposeAsync()
		{
			return _source.DisposeAsync().ConfigureAwait(_continueOnCapturedContext);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredCancelableAsyncEnumerable<T>
	{
		[StructLayout(LayoutKind.Auto)]
		public readonly struct Enumerator
		{
			private readonly IAsyncEnumerator<T> _enumerator;

			private readonly bool _continueOnCapturedContext;

			public T Current => _enumerator.Current;

			internal Enumerator(IAsyncEnumerator<T> enumerator, bool continueOnCapturedContext)
			{
				_enumerator = enumerator;
				_continueOnCapturedContext = continueOnCapturedContext;
			}

			public ConfiguredValueTaskAwaitable<bool> MoveNextAsync()
			{
				return _enumerator.MoveNextAsync().ConfigureAwait(_continueOnCapturedContext);
			}

			public ConfiguredValueTaskAwaitable DisposeAsync()
			{
				return _enumerator.DisposeAsync().ConfigureAwait(_continueOnCapturedContext);
			}
		}

		private readonly IAsyncEnumerable<T> _enumerable;

		private readonly CancellationToken _cancellationToken;

		private readonly bool _continueOnCapturedContext;

		internal ConfiguredCancelableAsyncEnumerable(IAsyncEnumerable<T> enumerable, bool continueOnCapturedContext, CancellationToken cancellationToken)
		{
			_enumerable = enumerable;
			_continueOnCapturedContext = continueOnCapturedContext;
			_cancellationToken = cancellationToken;
		}

		public ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait(bool continueOnCapturedContext)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(_enumerable, continueOnCapturedContext, _cancellationToken);
		}

		public ConfiguredCancelableAsyncEnumerable<T> WithCancellation(CancellationToken cancellationToken)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(_enumerable, _continueOnCapturedContext, cancellationToken);
		}

		public Enumerator GetAsyncEnumerator()
		{
			return new Enumerator(_enumerable.GetAsyncEnumerator(_cancellationToken), _continueOnCapturedContext);
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class EnumeratorCancellationAttribute : Attribute
	{
	}
}
namespace System.Threading.Tasks
{
	public static class TaskAsyncEnumerableExtensions
	{
		public static ConfiguredAsyncDisposable ConfigureAwait(this IAsyncDisposable source, bool continueOnCapturedContext)
		{
			return new ConfiguredAsyncDisposable(source, continueOnCapturedContext);
		}

		public static ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait<T>(this IAsyncEnumerable<T> source, bool continueOnCapturedContext)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(source, continueOnCapturedContext, default(CancellationToken));
		}

		public static ConfiguredCancelableAsyncEnumerable<T> WithCancellation<T>(this IAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(source, continueOnCapturedContext: true, cancellationToken);
		}
	}
}
namespace System.Threading.Tasks.Sources
{
	[StructLayout(LayoutKind.Auto)]
	public struct ManualResetValueTaskSourceCore<TResult>
	{
		private Action<object> _continuation;

		private object _continuationState;

		private ExecutionContext _executionContext;

		private object _capturedContext;

		private bool _completed;

		private TResult _result;

		private ExceptionDispatchInfo _error;

		private short _version;

		public bool RunContinuationsAsynchronously { get; set; }

		public short Version => _version;

		public void Reset()
		{
			_version++;
			_completed = false;
			_result = default(TResult);
			_error = null;
			_executionContext = null;
			_capturedContext = null;
			_continuation = null;
			_continuationState = null;
		}

		public void SetResult(TResult result)
		{
			_result = result;
			SignalCompletion();
		}

		public void SetException(Exception error)
		{
			_error = ExceptionDispatchInfo.Capture(error);
			SignalCompletion();
		}

		public ValueTaskSourceStatus GetStatus(short token)
		{
			ValidateToken(token);
			if (_continuation != null && _completed)
			{
				if (_error != null)
				{
					if (!(_error.SourceException is OperationCanceledException))
					{
						return ValueTaskSourceStatus.Faulted;
					}
					return ValueTaskSourceStatus.Canceled;
				}
				return ValueTaskSourceStatus.Succeeded;
			}
			return ValueTaskSourceStatus.Pending;
		}

		public TResult GetResult(short token)
		{
			ValidateToken(token);
			if (!_completed)
			{
				throw new InvalidOperationException();
			}
			_error?.Throw();
			return _result;
		}

		public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags)
		{
			if (continuation == null)
			{
				throw new ArgumentNullException("continuation");
			}
			ValidateToken(token);
			if ((flags & ValueTaskSourceOnCompletedFlags.FlowExecutionContext) != 0)
			{
				_executionContext = ExecutionContext.Capture();
			}
			if ((flags & ValueTaskSourceOnCompletedFlags.UseSchedulingContext) != 0)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					_capturedContext = current;
				}
				else
				{
					TaskScheduler current2 = TaskScheduler.Current;
					if (current2 != TaskScheduler.Default)
					{
						_capturedContext = current2;
					}
				}
			}
			object obj = _continuation;
			if (obj == null)
			{
				_continuationState = state;
				obj = Interlocked.CompareExchange(ref _continuation, continuation, null);
			}
			if (obj == null)
			{
				return;
			}
			if (obj != System.Threading.Tasks.Sources.ManualResetValueTaskSourceCoreShared.s_sentinel)
			{
				throw new InvalidOperationException();
			}
			object capturedContext = _capturedContext;
			if (capturedContext != null)
			{
				if (!(capturedContext is SynchronizationContext synchronizationContext))
				{
					if (capturedContext is TaskScheduler scheduler)
					{
						Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler);
					}
				}
				else
				{
					synchronizationContext.Post(delegate(object s)
					{
						Tuple<Action<object>, object> tuple = (Tuple<Action<object>, object>)s;
						tuple.Item1(tuple.Item2);
					}, Tuple.Create(continuation, state));
				}
			}
			else
			{
				Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			}
		}

		private void ValidateToken(short token)
		{
			if (token != _version)
			{
				throw new InvalidOperationException();
			}
		}

		private void SignalCompletion()
		{
			if (_completed)
			{
				throw new InvalidOperationException();
			}
			_completed = true;
			if (_continuation == null && Interlocked.CompareExchange(ref _continuation, System.Threading.Tasks.Sources.ManualResetValueTaskSourceCoreShared.s_sentinel, null) == null)
			{
				return;
			}
			if (_executionContext != null)
			{
				ExecutionContext.Run(_executionContext, delegate(object s)
				{
					((ManualResetValueTaskSourceCore<TResult>)s).InvokeContinuation();
				}, this);
			}
			else
			{
				InvokeContinuation();
			}
		}

		private void InvokeContinuation()
		{
			object capturedContext = _capturedContext;
			if (capturedContext != null)
			{
				if (!(capturedContext is SynchronizationContext synchronizationContext))
				{
					if (capturedContext is TaskScheduler scheduler)
					{
						Task.Factory.StartNew(_continuation, _continuationState, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler);
					}
				}
				else
				{
					synchronizationContext.Post(delegate(object s)
					{
						Tuple<Action<object>, object> tuple = (Tuple<Action<object>, object>)s;
						tuple.Item1(tuple.Item2);
					}, Tuple.Create(_continuation, _continuationState));
				}
			}
			else if (RunContinuationsAsynchronously)
			{
				Task.Factory.StartNew(_continuation, _continuationState, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			}
			else
			{
				_continuation(_continuationState);
			}
		}
	}
	internal static class ManualResetValueTaskSourceCoreShared
	{
		internal static readonly Action<object> s_sentinel = CompletionSentinel;

		private static void CompletionSentinel(object _)
		{
			throw new InvalidOperationException();
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Serialization;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MyEmotions.Emotions.Chat;
using MyEmotions.Emotions.Configuration;
using MyEmotions.Emotions.Detection;
using MyEmotions.Emotions.Phrases;
using MyEmotions.Emotions.Situations;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("MyEmotions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.5.0")]
[assembly: AssemblyInformationalVersion("0.1.5+35063d586e906a07cbe135cf3ecb585fbe69a3ce")]
[assembly: AssemblyProduct("MyEmotions")]
[assembly: AssemblyTitle("MyEmotions")]
[assembly: AssemblyVersion("0.1.5.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace MyEmotions.Emotions
{
	[BepInPlugin("salatrek.MyEmotions", "MyEmotions", "0.1.5")]
	public sealed class MyEmotionsPlugin : BaseUnityPlugin
	{
		private const string PluginGuid = "salatrek.MyEmotions";

		private const string PluginName = "MyEmotions";

		private const string PluginVersion = "0.1.5";

		private readonly Harmony _harmony = new Harmony("salatrek.MyEmotions");

		private EmotionPhraseProvider? _phraseProvider;

		private EmotionSituationHandler? _situationHandler;

		private void Awake()
		{
			try
			{
				MyEmotionsOptionsFile.EnsureLocalizedFiles(Paths.ConfigPath, ((BaseUnityPlugin)this).Logger);
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Could not create language configurations: {arg}");
				return;
			}
			MyEmotionsOptions myEmotionsOptions = MyEmotionsOptionsFile.Load(Path.Combine(Paths.ConfigPath, "emotionsConfigs.RU.json"), ((BaseUnityPlugin)this).Logger);
			MyEmotionsOptions myEmotionsOptions2 = MyEmotionsOptionsFile.Load(Path.Combine(Paths.ConfigPath, "emotionsConfigs.EN.json"), ((BaseUnityPlugin)this).Logger);
			MyEmotionsConfigEntries.Bind(((BaseUnityPlugin)this).Config, myEmotionsOptions, ((BaseUnityPlugin)this).Logger);
			MyEmotionsConfigEntries.Bind(((BaseUnityPlugin)this).Config, myEmotionsOptions2, ((BaseUnityPlugin)this).Logger, "EN");
			_phraseProvider = new EmotionPhraseProvider(myEmotionsOptions, myEmotionsOptions2);
			_situationHandler = new EmotionSituationHandler(_phraseProvider, new ValheimChatService(((BaseUnityPlugin)this).Logger));
			SituationDetectionPatches.Initialize(_situationHandler, ((BaseUnityPlugin)this).Logger);
			SituationDetectionPatches.ApplyPatches(_harmony);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"MyEmotions initialized.");
		}

		private void OnDestroy()
		{
			SituationDetectionPatches.Shutdown();
			_harmony.UnpatchSelf();
		}
	}
}
namespace MyEmotions.Emotions.Detection
{
	internal static class SituationDetectionPatches
	{
		private const float FogDensityThreshold = 0.01f;

		private const float FogStateStabilizationSeconds = 1f;

		private static EmotionSituationHandler? _situationHandler;

		private static ManualLogSource? _logger;

		private static bool _wasRaining;

		private static bool _wasFoggy;

		private static bool _hasFogCandidate;

		private static bool _fogCandidate;

		private static float _fogCandidateSince;

		private static bool _wasSailing;

		private static bool _wasOnShip;

		private static bool _wasBowEquipped;

		private static bool _wasWeaponDrawn;

		private static bool _hadArrowsWhileBow;

		private static bool _wasCauldronCrafting;

		private static bool _wasCrafting;

		private static bool _wasCraftingAtCauldron;

		private static bool _hasBiome;

		private static Biome _lastBiome;

		private static bool _wasEncumbered;

		private static bool _wasLowHealth;

		private static bool _wasWeaponBroken;

		private static bool _hasShelterState;

		private static bool _wasUnderRoof;

		private static bool _hasRestedState;

		private static bool _wasRested;

		public static void Initialize(EmotionSituationHandler situationHandler, ManualLogSource logger)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			_situationHandler = situationHandler ?? throw new ArgumentNullException("situationHandler");
			_logger = logger ?? throw new ArgumentNullException("logger");
			_wasRaining = false;
			_wasFoggy = false;
			_hasFogCandidate = false;
			_fogCandidate = false;
			_fogCandidateSince = 0f;
			_wasSailing = false;
			_wasOnShip = false;
			_wasBowEquipped = false;
			_wasWeaponDrawn = false;
			_hadArrowsWhileBow = false;
			_wasCauldronCrafting = false;
			_wasCrafting = false;
			_wasCraftingAtCauldron = false;
			_hasBiome = false;
			_lastBiome = (Biome)0;
			_wasEncumbered = false;
			_wasLowHealth = false;
			_wasWeaponBroken = false;
			_hasShelterState = false;
			_wasUnderRoof = false;
			_hasRestedState = false;
			_wasRested = false;
		}

		public static void Shutdown()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			_situationHandler = null;
			_logger = null;
			_wasRaining = false;
			_wasFoggy = false;
			_hasFogCandidate = false;
			_fogCandidate = false;
			_fogCandidateSince = 0f;
			_wasSailing = false;
			_wasOnShip = false;
			_wasBowEquipped = false;
			_wasWeaponDrawn = false;
			_hadArrowsWhileBow = false;
			_wasCauldronCrafting = false;
			_wasCrafting = false;
			_wasCraftingAtCauldron = false;
			_hasBiome = false;
			_lastBiome = (Biome)0;
			_wasEncumbered = false;
			_wasLowHealth = false;
			_wasWeaponBroken = false;
			_hasShelterState = false;
			_wasUnderRoof = false;
			_hasRestedState = false;
			_wasRested = false;
		}

		public static void ApplyPatches(Harmony harmony)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Expected O, but got Unknown
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Expected O, but got Unknown
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Expected O, but got Unknown
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Expected O, but got Unknown
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Expected O, but got Unknown
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Expected O, but got Unknown
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c4: Expected O, but got Unknown
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Expected O, but got Unknown
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Expected O, but got Unknown
			if (harmony == null)
			{
				throw new ArgumentNullException("harmony");
			}
			harmony.Patch((MethodBase)AccessTools.Method(typeof(EnvMan), "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "EnvManUpdatePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PlayerUpdatePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Character), "Damage", new Type[1] { typeof(HitData) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "CharacterDamagePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "TeleportTo", new Type[3]
			{
				typeof(Vector3),
				typeof(Quaternion),
				typeof(bool)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PlayerTeleportToPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(CraftingStation), "Interact", new Type[3]
			{
				typeof(Humanoid),
				typeof(bool),
				typeof(bool)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "CraftingStationInteractPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "SetCraftingStation", new Type[1] { typeof(CraftingStation) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PlayerSetCraftingStationPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(InventoryGui), "DoCrafting", new Type[1] { typeof(Player) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "InventoryGuiDoCraftingPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(InventoryGui), "OnCraftPressed", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "InventoryGuiOnCraftPressedPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(InventoryGui), "UpdateRecipe", new Type[2]
			{
				typeof(Player),
				typeof(float)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "InventoryGuiUpdateRecipePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "EatFood", new Type[1] { typeof(ItemData) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PlayerEatFoodPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "OnDeath", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PlayerDeathPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "OnRespawn", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PlayerRespawnPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Fish), "Pickup", new Type[1] { typeof(Humanoid) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "FishPickupPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Tameable), "Tame", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "TameableTamePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(RandEventSystem), "SetActiveEvent", new Type[2]
			{
				typeof(RandomEvent),
				typeof(bool)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "RandomEventSetActivePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(TreeBase), "Damage", new Type[1] { typeof(HitData) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "TreeBaseDamagePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Pickable), "UseItem", new Type[2]
			{
				typeof(Humanoid),
				typeof(ItemData)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PickableUseItemPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(Pickable), "Interact", new Type[3]
			{
				typeof(Humanoid),
				typeof(bool),
				typeof(bool)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "PickableInteractPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ItemStand), "UseItem", new Type[2]
			{
				typeof(Humanoid),
				typeof(ItemData)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SituationDetectionPatches), "ItemStandUseItemPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void EnvManUpdatePostfix()
		{
			if (_situationHandler == null)
			{
				return;
			}
			EnvMan instance = EnvMan.instance;
			bool flag = ((instance != null) ? instance.GetCurrentEnvironment() : null)?.m_isWet ?? false;
			if (flag != _wasRaining)
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"Rain detector state changed: {flag}.");
				}
			}
			if (flag)
			{
				bool flag2 = _situationHandler.TryHandle(EmotionSituation.RainStarted);
				if (flag2)
				{
					ManualLogSource? logger2 = _logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)$"RainStarted detected. Phrase handled: {flag2}.");
					}
				}
			}
			_wasRaining = flag;
		}

		private static void PlayerUpdatePostfix(Player __instance)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Invalid comparison between Unknown and I4
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (_situationHandler == null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			bool flag = __instance.GetControlledShip() != null;
			bool stableFogState = GetStableFogState(RenderSettings.fog && RenderSettings.fogDensity >= 0.01f);
			bool flag2 = ((Character)__instance).GetStandingOnShip() != null;
			ItemData rightItem = ((Humanoid)__instance).RightItem;
			ItemData leftItem = ((Humanoid)__instance).LeftItem;
			ItemData val = (IsWeapon(rightItem) ? rightItem : leftItem);
			bool flag3 = val != null && (int)(val.m_shared?.m_itemType).GetValueOrDefault() == 4;
			bool flag4 = IsWeapon(val) && !flag3;
			bool flag5 = ((Character)__instance).IsEncumbered();
			bool flag6 = ((Character)__instance).GetHealthPercentage() <= 0.25f;
			bool flag7 = IsUnderRoof((Character)(object)__instance);
			bool flag8 = HasRestedEffect(__instance);
			bool flag9 = HasStatusEffect(__instance, "Wet");
			bool flag10 = HasStatusEffect(__instance, "Cold");
			bool flag11 = val != null && IsWeapon(val) && val.m_shared != null && val.m_shared.m_useDurability && val.GetDurabilityPercentage() <= 0.01f;
			DetectBiomeTransition(__instance.GetCurrentBiome());
			if (stableFogState)
			{
				bool flag12 = _situationHandler.TryHandle(EmotionSituation.FogStarted);
				if (flag12)
				{
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"FogStarted detected. Phrase handled: {flag12}.");
					}
				}
			}
			if (flag && !_wasSailing)
			{
				bool flag13 = _situationHandler.TryHandle(EmotionSituation.SailingStarted);
				ManualLogSource? logger2 = _logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"SailingStarted detected. Phrase handled: {flag13}.");
				}
			}
			if (flag2 && !_wasOnShip && !flag)
			{
				bool flag14 = _situationHandler.TryHandle(EmotionSituation.BoardedShip);
				ManualLogSource? logger3 = _logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)$"BoardedShip detected. Phrase handled: {flag14}.");
				}
			}
			if (flag3 && !_wasBowEquipped)
			{
				bool flag15 = _situationHandler.TryHandle(EmotionSituation.BowEquipped);
				ManualLogSource? logger4 = _logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)$"BowEquipped detected. Phrase handled: {flag15}.");
				}
			}
			if (flag4 && !_wasWeaponDrawn)
			{
				bool flag16 = _situationHandler.TryHandle(EmotionSituation.WeaponDrawn);
				ManualLogSource? logger5 = _logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)$"WeaponDrawn detected. Phrase handled: {flag16}.");
				}
			}
			if (flag5 && !_wasEncumbered)
			{
				bool flag17 = _situationHandler.TryHandle(EmotionSituation.EncumberedStarted);
				ManualLogSource? logger6 = _logger;
				if (logger6 != null)
				{
					logger6.LogInfo((object)$"EncumberedStarted detected. Phrase handled: {flag17}.");
				}
			}
			if (flag6 && !_wasLowHealth)
			{
				bool flag18 = _situationHandler.TryHandle(EmotionSituation.LowHealthStarted);
				ManualLogSource? logger7 = _logger;
				if (logger7 != null)
				{
					logger7.LogInfo((object)$"LowHealthStarted detected. Phrase handled: {flag18}.");
				}
			}
			if (flag11 && !_wasWeaponBroken)
			{
				bool flag19 = _situationHandler.TryHandle(EmotionSituation.WeaponBroken);
				ManualLogSource? logger8 = _logger;
				if (logger8 != null)
				{
					logger8.LogInfo((object)$"WeaponBroken detected. Phrase handled: {flag19}.");
				}
			}
			if (flag9)
			{
				bool flag20 = _situationHandler.TryHandle(EmotionSituation.WetStarted);
				if (flag20)
				{
					ManualLogSource? logger9 = _logger;
					if (logger9 != null)
					{
						logger9.LogInfo((object)$"WetStarted detected. Phrase handled: {flag20}.");
					}
				}
			}
			if (flag10)
			{
				bool flag21 = _situationHandler.TryHandle(EmotionSituation.ColdStarted);
				if (flag21)
				{
					ManualLogSource? logger10 = _logger;
					if (logger10 != null)
					{
						logger10.LogInfo((object)$"ColdStarted detected. Phrase handled: {flag21}.");
					}
				}
			}
			if (_hasShelterState && flag7 && !_wasUnderRoof)
			{
				bool flag22 = _situationHandler.TryHandle(EmotionSituation.ShelterEntered);
				ManualLogSource? logger11 = _logger;
				if (logger11 != null)
				{
					logger11.LogInfo((object)$"ShelterEntered detected. Phrase handled: {flag22}.");
				}
			}
			if (_hasRestedState && flag8 != _wasRested)
			{
				EmotionSituation emotionSituation = (flag8 ? EmotionSituation.RestedBuffStarted : EmotionSituation.RestedBuffExpired);
				bool flag23 = _situationHandler.TryHandle(emotionSituation);
				ManualLogSource? logger12 = _logger;
				if (logger12 != null)
				{
					logger12.LogInfo((object)$"{emotionSituation} detected. Phrase handled: {flag23}.");
				}
			}
			if (flag3)
			{
				ItemData ammoItem = ((Humanoid)__instance).GetAmmoItem();
				if (ammoItem != null && ammoItem.m_stack > 0)
				{
					_hadArrowsWhileBow = true;
				}
				else if (_hadArrowsWhileBow)
				{
					bool flag24 = _situationHandler.TryHandle(EmotionSituation.ArrowsDepleted);
					ManualLogSource? logger13 = _logger;
					if (logger13 != null)
					{
						logger13.LogInfo((object)$"ArrowsDepleted detected. Phrase handled: {flag24}.");
					}
					_hadArrowsWhileBow = false;
				}
			}
			else
			{
				_hadArrowsWhileBow = false;
			}
			_wasFoggy = stableFogState;
			_wasSailing = flag;
			_wasOnShip = flag2;
			_wasBowEquipped = flag3;
			_wasWeaponDrawn = flag4;
			_wasEncumbered = flag5;
			_wasLowHealth = flag6;
			_wasWeaponBroken = flag11;
			_wasUnderRoof = flag7;
			_hasShelterState = true;
			_wasRested = flag8;
			_hasRestedState = true;
		}

		private static void DetectBiomeTransition(Biome currentBiome)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			if (!_hasBiome)
			{
				_lastBiome = currentBiome;
				_hasBiome = true;
				return;
			}
			if (currentBiome == _lastBiome)
			{
				return;
			}
			_lastBiome = currentBiome;
			EmotionSituation? emotionSituation;
			if ((int)currentBiome <= 4)
			{
				if ((int)currentBiome != 2)
				{
					if ((int)currentBiome != 4)
					{
						goto IL_0068;
					}
					emotionSituation = EmotionSituation.MountainsEntered;
				}
				else
				{
					emotionSituation = EmotionSituation.SwampEntered;
				}
			}
			else if ((int)currentBiome != 16)
			{
				if ((int)currentBiome != 512)
				{
					goto IL_0068;
				}
				emotionSituation = EmotionSituation.MistlandsEntered;
			}
			else
			{
				emotionSituation = EmotionSituation.PlainsEntered;
			}
			goto IL_0072;
			IL_0072:
			EmotionSituation? emotionSituation2 = emotionSituation;
			if (emotionSituation2.HasValue && _situationHandler != null)
			{
				bool flag = _situationHandler.TryHandle(emotionSituation2.Value);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"{emotionSituation2.Value} detected. Phrase handled: {flag}.");
				}
			}
			return;
			IL_0068:
			emotionSituation = null;
			goto IL_0072;
		}

		private static bool IsWeapon(ItemData? item)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			if (item?.m_shared == null)
			{
				return false;
			}
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType <= 14)
			{
				if (itemType - 3 <= 1 || (int)itemType == 14)
				{
					goto IL_0038;
				}
			}
			else if ((int)itemType == 20 || (int)itemType == 22)
			{
				goto IL_0038;
			}
			return false;
			IL_0038:
			return true;
		}

		private static bool GetStableFogState(bool rawFoggy)
		{
			if (!_hasFogCandidate || rawFoggy != _fogCandidate)
			{
				_hasFogCandidate = true;
				_fogCandidate = rawFoggy;
				_fogCandidateSince = Time.unscaledTime;
			}
			if (rawFoggy == _wasFoggy)
			{
				return rawFoggy;
			}
			if (!(Time.unscaledTime - _fogCandidateSince >= 1f))
			{
				return _wasFoggy;
			}
			return _fogCandidate;
		}

		private static bool HasRestedEffect(Player player)
		{
			return HasStatusEffect(player, "Rested");
		}

		private static bool IsUnderRoof(Character character)
		{
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null)
			{
				return HasStatusEffect(val, "Shelter");
			}
			return false;
		}

		private static bool HasStatusEffect(Player player, string effectName)
		{
			SEMan sEMan = ((Character)player).GetSEMan();
			return ((sEMan != null) ? sEMan.GetStatusEffects() : null)?.Any((StatusEffect statusEffect) => IsMatchingStatusEffect(statusEffect, effectName)) ?? false;
		}

		private static bool IsMatchingStatusEffect(StatusEffect statusEffect, string effectName)
		{
			if ((statusEffect.m_name ?? string.Empty).IndexOf(effectName, StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			string text = effectName switch
			{
				"Wet" => "s_statusEffectWet", 
				"Cold" => "s_statusEffectCold", 
				"Rested" => "s_statusEffectRested", 
				"Shelter" => "s_statusEffectShelter", 
				_ => null, 
			};
			if (text == null)
			{
				return false;
			}
			object obj = AccessTools.Field(typeof(SEMan), text)?.GetValue(null);
			object obj2 = AccessTools.Field(typeof(StatusEffect), "m_nameHash")?.GetValue(statusEffect);
			if (obj != null && obj2 != null)
			{
				return Convert.ToInt32(obj) == Convert.ToInt32(obj2);
			}
			return false;
		}

		private static void CharacterDamagePostfix(Character __instance, HitData hit)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			if (_situationHandler == null || Player.m_localPlayer == null || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			if ((int)hit.m_hitType == 3)
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.FallDamageTaken);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"FallDamageTaken detected. Phrase handled: {flag}.");
				}
				return;
			}
			Character attacker = hit.GetAttacker();
			if (attacker == null || attacker.IsPlayer())
			{
				return;
			}
			string text = LocalizeGameText(attacker.GetHoverName());
			int num;
			int num2;
			if (((Object)attacker).name.IndexOf("deathsquito", StringComparison.OrdinalIgnoreCase) < 0)
			{
				num = ((text.IndexOf("deathsquito", StringComparison.OrdinalIgnoreCase) >= 0) ? 1 : 0);
				if (num == 0)
				{
					num2 = 13;
					goto IL_00a6;
				}
			}
			else
			{
				num = 1;
			}
			num2 = 19;
			goto IL_00a6;
			IL_00a6:
			EmotionSituation emotionSituation = (EmotionSituation)num2;
			Dictionary<string, string> context = ((num != 0) ? null : new Dictionary<string, string> { ["enemy"] = text });
			bool flag2 = _situationHandler.TryHandle(emotionSituation, context);
			ManualLogSource? logger2 = _logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)$"{emotionSituation} detected from '{text}'. Phrase handled: {flag2}.");
			}
		}

		private static void PlayerTeleportToPostfix(Player __instance, bool __result)
		{
			if (_situationHandler != null && __result && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.PortalUsed);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"Player teleport detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void CraftingStationInteractPostfix(CraftingStation __instance, Humanoid user, bool __result)
		{
			if (_situationHandler != null && __result && !((Object)(object)user != (Object)(object)Player.m_localPlayer) && IsCauldron(__instance))
			{
				HandleCauldronOpened("CraftingStation.Interact");
			}
		}

		private static void PlayerSetCraftingStationPostfix(Player __instance, CraftingStation station)
		{
			if (_situationHandler != null && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && IsCauldron(station))
			{
				HandleCauldronOpened("Player.SetCraftingStation");
			}
		}

		private static void HandleCauldronOpened(string detector)
		{
			bool flag = _situationHandler?.TryHandle(EmotionSituation.CauldronOpened) ?? false;
			ManualLogSource? logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)$"CauldronOpened detected by {detector}. Phrase handled: {flag}.");
			}
		}

		private static void InventoryGuiDoCraftingPostfix(Player player)
		{
			if (_situationHandler != null && !((Object)(object)player != (Object)(object)Player.m_localPlayer) && IsCauldron(player.GetCurrentCraftingStation()))
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.CauldronCookingStarted);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"CauldronCookingStarted detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void InventoryGuiOnCraftPressedPostfix()
		{
			Player localPlayer = Player.m_localPlayer;
			if (_situationHandler != null && localPlayer != null && IsCauldron(localPlayer.GetCurrentCraftingStation()))
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.CauldronCookingStarted);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"CauldronCookingStarted detected by InventoryGui.OnCraftPressed. Phrase handled: {flag}.");
				}
			}
		}

		private static void InventoryGuiUpdateRecipePostfix(InventoryGui __instance, Player player)
		{
			if (_situationHandler == null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			bool flag = IsCauldron(player.GetCurrentCraftingStation());
			bool flag2 = Convert.ToSingle(AccessTools.Field(typeof(InventoryGui), "m_craftTimer")?.GetValue(__instance) ?? ((object)0f)) > 0f;
			if (_wasCrafting && !flag2)
			{
				EmotionSituation emotionSituation = (_wasCraftingAtCauldron ? EmotionSituation.CauldronCookingFinished : EmotionSituation.CraftingCompleted);
				bool flag3 = _situationHandler.TryHandle(emotionSituation);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"{emotionSituation} detected. Phrase handled: {flag3}.");
				}
			}
			_wasCrafting = flag2;
			_wasCraftingAtCauldron = flag2 && flag;
			_wasCauldronCrafting = _wasCraftingAtCauldron;
		}

		private static bool IsCauldron(CraftingStation? station)
		{
			if (station == null)
			{
				return false;
			}
			if (!ContainsCauldron(station.m_name) && !ContainsCauldron(((Object)station).name))
			{
				return ContainsCauldron(((Object)((Component)station).gameObject).name);
			}
			return true;
		}

		private static bool ContainsCauldron(string? value)
		{
			if (value == null)
			{
				return false;
			}
			return value.IndexOf("cauldron", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static void PlayerEatFoodPostfix(Player __instance, bool __result)
		{
			if (_situationHandler != null && __result && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.FoodEaten);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"FoodEaten detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void PlayerDeathPostfix(Player __instance)
		{
			if (_situationHandler != null && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.PlayerDeath);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"PlayerDeath detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void PlayerRespawnPostfix(Player __instance)
		{
			if (_situationHandler != null && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.PlayerRespawned);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"PlayerRespawned detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void FishPickupPostfix(Fish __instance, Humanoid character, bool __result)
		{
			if (_situationHandler != null && __result && !((Object)(object)character != (Object)(object)Player.m_localPlayer))
			{
				string value = LocalizeGameText(__instance.GetHoverName().Replace("(Clone)", string.Empty));
				bool flag = _situationHandler.TryHandle(EmotionSituation.FishingCatch, new Dictionary<string, string> { ["fish"] = value });
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"FishingCatch detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void TameableTamePostfix(Tameable __instance)
		{
			if (_situationHandler != null)
			{
				Character component = ((Component)__instance).GetComponent<Character>();
				string value = ((component == null) ? LocalizeGameText(((Object)__instance).name.Replace("(Clone)", string.Empty)) : LocalizeGameText(component.GetHoverName()));
				bool flag = _situationHandler.TryHandle(EmotionSituation.TamedCreature, new Dictionary<string, string> { ["creature"] = value });
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"TamedCreature detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void RandomEventSetActivePostfix(RandomEvent ev, bool end)
		{
			if (_situationHandler == null || end || ev == null)
			{
				return;
			}
			string text = ev.m_name ?? string.Empty;
			if (text.IndexOf("army", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("raid", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.RaidStarted);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"RaidStarted detected for '{text}'. Phrase handled: {flag}.");
				}
			}
		}

		private static void TreeBaseDamagePostfix(TreeBase __instance, HitData hit)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			if (_situationHandler != null && Player.m_localPlayer != null && (int)hit.m_hitType == 13 && !(__instance.m_health > 0f))
			{
				bool flag = _situationHandler.TryHandle(EmotionSituation.TreeFelled);
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"TreeFelled detected. Phrase handled: {flag}.");
				}
			}
		}

		private static void PickableUseItemPostfix(Pickable __instance, Humanoid user, ItemData item, bool __result)
		{
			HandlePickableGathered(__instance, user, __result);
		}

		private static void PickableInteractPostfix(Pickable __instance, Humanoid character, bool __result)
		{
			HandlePickableGathered(__instance, character, __result);
		}

		private static void HandlePickableGathered(Pickable pickable, Humanoid user, bool wasPicked)
		{
			if (_situationHandler != null && wasPicked && !((Object)(object)user != (Object)(object)Player.m_localPlayer))
			{
				EmotionSituation emotionSituation = (((((Component)pickable).GetComponent<Plant>() ?? ((Component)pickable).GetComponentInParent<Plant>()) == null) ? EmotionSituation.WildPlantGathered : EmotionSituation.PlantHarvested);
				string text = LocalizeGameText(pickable.GetHoverName());
				bool flag = _situationHandler.TryHandle(emotionSituation, new Dictionary<string, string> { ["plant"] = text });
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"{emotionSituation} detected for '{text}'. Phrase handled: {flag}.");
				}
			}
		}

		private static string LocalizeGameText(string text)
		{
			if (string.IsNullOrWhiteSpace(text) || Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		private static void ItemStandUseItemPostfix(ItemStand __instance, Humanoid user, ItemData item, bool __result)
		{
			if (_situationHandler != null && __result && !((Object)(object)user != (Object)(object)Player.m_localPlayer) && ((Component)__instance).GetComponentInParent<BossStone>() != null)
			{
				BossStone componentInParent = ((Component)__instance).GetComponentInParent<BossStone>();
				string value = LocalizeGameText(((componentInParent != null) ? ((Object)componentInParent).name.Replace("(Clone)", string.Empty) : null) ?? (EmotionLanguage.IsRussian(EmotionLanguage.GetSelectedGameLanguage()) ? "босс" : "boss"));
				bool flag = _situationHandler.TryHandle(EmotionSituation.BossSummoned, new Dictionary<string, string> { ["boss"] = value });
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"BossSummoned detected. Phrase handled: {flag}.");
				}
			}
		}
	}
}
namespace MyEmotions.Emotions.Situations
{
	public enum EmotionSituation
	{
		RainStarted,
		WetStarted,
		ColdStarted,
		FogStarted,
		SailingStarted,
		BoardedShip,
		BowEquipped,
		ArrowsDepleted,
		WeaponDrawn,
		CauldronOpened,
		CauldronCookingStarted,
		CauldronCookingFinished,
		FoodEaten,
		HostileCreatureAttack,
		PortalUsed,
		SwampEntered,
		PlainsEntered,
		MountainsEntered,
		MistlandsEntered,
		DeathsquitoAttack,
		RaidStarted,
		BossSummoned,
		PlayerDeath,
		PlayerRespawned,
		EncumberedStarted,
		LowHealthStarted,
		WeaponBroken,
		FallDamageTaken,
		FishingCatch,
		TreeFelled,
		TamedCreature,
		RestedBuffStarted,
		RestedBuffExpired,
		CraftingCompleted,
		ShelterEntered,
		PlantHarvested,
		WildPlantGathered
	}
	public sealed class EmotionSituationHandler
	{
		private readonly EmotionPhraseProvider _phraseProvider;

		private readonly IChatService _chatService;

		public EmotionSituationHandler(EmotionPhraseProvider phraseProvider, IChatService chatService)
		{
			_phraseProvider = phraseProvider ?? throw new ArgumentNullException("phraseProvider");
			_chatService = chatService ?? throw new ArgumentNullException("chatService");
		}

		public bool TryHandle(EmotionSituation situation, IReadOnlyDictionary<string, string>? context = null)
		{
			string phrase = _phraseProvider.GetPhrase(situation, context);
			if (phrase == null)
			{
				return false;
			}
			_chatService.Send(phrase);
			return true;
		}
	}
}
namespace MyEmotions.Emotions.Phrases
{
	public static class EmotionLanguage
	{
		public static string? GetSelectedGameLanguage()
		{
			Localization instance = Localization.instance;
			if (instance == null)
			{
				return null;
			}
			return instance.GetSelectedLanguage();
		}

		public static bool IsRussian(string? language)
		{
			return string.Equals(language, "Russian", StringComparison.OrdinalIgnoreCase);
		}
	}
	public sealed class EmotionPhraseProvider
	{
		private readonly MyEmotionsOptions _russianOptions;

		private readonly MyEmotionsOptions _englishOptions;

		private readonly Random _random;

		private readonly Func<string?> _getGameLanguage;

		private readonly Dictionary<EmotionSituation, string> _previousPhrases = new Dictionary<EmotionSituation, string>();

		private readonly Dictionary<string, DateTimeOffset> _nextPhraseAvailableAt = new Dictionary<string, DateTimeOffset>(StringComparer.OrdinalIgnoreCase);

		private DateTimeOffset _nextGlobalPhraseAvailableAt = DateTimeOffset.MinValue;

		public EmotionPhraseProvider(MyEmotionsOptions russianOptions, MyEmotionsOptions englishOptions, Random? random = null, Func<string?>? getGameLanguage = null)
		{
			_russianOptions = russianOptions ?? throw new ArgumentNullException("russianOptions");
			_englishOptions = englishOptions ?? throw new ArgumentNullException("englishOptions");
			_random = random ?? new Random();
			_getGameLanguage = getGameLanguage ?? new Func<string>(EmotionLanguage.GetSelectedGameLanguage);
		}

		public string? GetPhrase(EmotionSituation situation, IReadOnlyDictionary<string, string>? context = null)
		{
			MyEmotionsOptions myEmotionsOptions = (EmotionLanguage.IsRussian(_getGameLanguage()) ? _russianOptions : _englishOptions);
			if (!myEmotionsOptions.Enabled)
			{
				return null;
			}
			DateTimeOffset utcNow = DateTimeOffset.UtcNow;
			if (utcNow < _nextGlobalPhraseAvailableAt)
			{
				return null;
			}
			if (!TryGetUsablePhrases(myEmotionsOptions, situation, out PhraseOption option, out string[] phrases))
			{
				return null;
			}
			string cooldownKey = GetCooldownKey(situation);
			if (_nextPhraseAvailableAt.TryGetValue(cooldownKey, out var value) && utcNow < value)
			{
				return null;
			}
			string[] array = phrases;
			if (phrases.Length > 1 && _previousPhrases.TryGetValue(situation, out string previousPhrase))
			{
				array = phrases.Where((string phrase) => !string.Equals(phrase, previousPhrase, StringComparison.Ordinal)).ToArray();
				if (array.Length == 0)
				{
					array = phrases;
				}
			}
			string text = array[_random.Next(array.Length)];
			_previousPhrases[situation] = text;
			_nextGlobalPhraseAvailableAt = utcNow.AddSeconds(myEmotionsOptions.GlobalPhraseCooldownSeconds);
			_nextPhraseAvailableAt[cooldownKey] = utcNow.AddSeconds(option.CooldownSeconds);
			return RenderTemplate(text, context);
		}

		private static string GetCooldownKey(EmotionSituation situation)
		{
			if ((uint)(situation - 9) > 2u)
			{
				return situation.ToString();
			}
			return "CauldronCooking";
		}

		private static bool TryGetUsablePhrases(MyEmotionsOptions options, EmotionSituation situation, out PhraseOption option, out string[] phrases)
		{
			if (options.Phrases.TryGetValue(situation, out option) && option != null && option.Enabled)
			{
				phrases = (from phrase in option.Phrases
					where !string.IsNullOrWhiteSpace(phrase)
					select phrase.Trim()).ToArray();
				return phrases.Length != 0;
			}
			option = new PhraseOption();
			phrases = Array.Empty<string>();
			return false;
		}

		private static string RenderTemplate(string template, IReadOnlyDictionary<string, string>? context)
		{
			if (context == null || context.Count == 0)
			{
				return template;
			}
			foreach (KeyValuePair<string, string> item in context)
			{
				template = template.Replace("{" + item.Key + "}", item.Value);
			}
			return template;
		}
	}
}
namespace MyEmotions.Emotions.Configuration
{
	internal sealed class ConfigurationManagerAttributes
	{
		public Action<ConfigEntryBase>? CustomDrawer;
	}
	public static class MyEmotionsConfigEntries
	{
		private const float MaximumCooldownSeconds = 3600f;

		public static MyEmotionsOptions Bind(ConfigFile config, MyEmotionsOptions options, ManualLogSource logger, string language = "RU")
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			if (config == null)
			{
				throw new ArgumentNullException("config");
			}
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			if (logger == null)
			{
				throw new ArgumentNullException("logger");
			}
			string text = ((language == "RU") ? string.Empty : (language + "."));
			ConfigEntry<bool> enabled = config.Bind<bool>(text + "General", "Enabled", options.Enabled, "Enables or disables all emotion phrases.");
			enabled.SettingChanged += delegate
			{
				options.Enabled = enabled.Value;
			};
			options.Enabled = enabled.Value;
			ConfigEntry<float> globalCooldown = config.Bind<float>(text + "General", "GlobalPhraseCooldownSeconds", (float)Math.Max(0.0, options.GlobalPhraseCooldownSeconds), new ConfigDescription("Minimum delay between any two emotion phrases, in seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3600f), Array.Empty<object>()));
			globalCooldown.SettingChanged += delegate
			{
				options.GlobalPhraseCooldownSeconds = Math.Max(0f, globalCooldown.Value);
			};
			options.GlobalPhraseCooldownSeconds = Math.Max(0f, globalCooldown.Value);
			foreach (EmotionSituation item in Enum.GetValues(typeof(EmotionSituation)).Cast<EmotionSituation>())
			{
				PhraseOption value;
				PhraseOption defaults = (options.Phrases.TryGetValue(item, out value) ? value : new PhraseOption());
				string text2 = $"{text}Situations.{item}";
				ConfigEntry<bool> situationEnabled = config.Bind<bool>(text2, "Enabled", defaults.Enabled, $"Enables the {item} trigger.");
				situationEnabled.SettingChanged += delegate
				{
					defaults.Enabled = situationEnabled.Value;
				};
				defaults.Enabled = situationEnabled.Value;
				ConfigEntry<float> cooldown = config.Bind<float>(text2, "CooldownSeconds", (float)Math.Max(0.0, defaults.CooldownSeconds), new ConfigDescription("Minimum delay for this trigger, in seconds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3600f), Array.Empty<object>()));
				cooldown.SettingChanged += delegate
				{
					defaults.CooldownSeconds = Math.Max(0f, cooldown.Value);
				};
				defaults.CooldownSeconds = Math.Max(0f, cooldown.Value);
				ConfigEntry<string> phrases = config.Bind<string>(text2, "Phrases", SerializePhrases(defaults.Phrases), new ConfigDescription(language + " phrase templates. One phrase per line. Empty lines are ignored.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						CustomDrawer = DrawPhraseList
					}
				}));
				phrases.SettingChanged += delegate
				{
					defaults.Phrases = ParsePhrases(phrases.Value);
				};
				defaults.Phrases = ParsePhrases(phrases.Value);
				options.Phrases[item] = defaults;
			}
			string sailingPhrase = ((language == "RU") ? "Если сейчас врежемся в берег — скажу, что так и задумано, блядь." : "If we hit the shore, I'll say it was all part of the bloody plan.");
			List<string> phrases2 = options.Phrases[EmotionSituation.FogStarted].Phrases;
			if (phrases2.RemoveAll((string phrase) => string.Equals(phrase, sailingPhrase, StringComparison.Ordinal)) > 0)
			{
				List<string> phrases3 = options.Phrases[EmotionSituation.SailingStarted].Phrases;
				if (!phrases3.Contains(sailingPhrase))
				{
					phrases3.Add(sailingPhrase);
				}
				config[text + "Situations.FogStarted", "Phrases"].BoxedValue = SerializePhrases(phrases2);
				config[text + "Situations.SailingStarted", "Phrases"].BoxedValue = SerializePhrases(phrases3);
				logger.LogInfo((object)("Moved a legacy " + language + " sailing phrase from FogStarted to SailingStarted."));
			}
			logger.LogInfo((object)$"Registered {Enum.GetValues(typeof(EmotionSituation)).Length} {language} situations in BepInEx Configuration Manager.");
			return options;
		}

		private static string SerializePhrases(IEnumerable<string> phrases)
		{
			return string.Join("\\n", phrases);
		}

		private static List<string> ParsePhrases(string value)
		{
			return (from phrase in DecodePhraseText(value).Split(new string[2] { "\r\n", "\n" }, StringSplitOptions.None)
				select phrase.Trim() into phrase
				where !string.IsNullOrWhiteSpace(phrase)
				select phrase).ToList();
		}

		private static string DecodePhraseText(string value)
		{
			return value.Replace("\\n", "\n");
		}

		private static void DrawPhraseList(ConfigEntryBase setting)
		{
			if (setting is ConfigEntry<string> val)
			{
				string text = GUILayout.TextArea(DecodePhraseText(val.Value), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MinHeight(90f) }).Replace("\r\n", "\n").Replace("\n", "\\n");
				if (!string.Equals(text, val.Value, StringComparison.Ordinal))
				{
					val.Value = text;
				}
			}
		}
	}
	public sealed class MyEmotionsOptions
	{
		public bool Enabled { get; set; } = true;

		public double GlobalPhraseCooldownSeconds { get; set; } = 7.0;

		public Dictionary<EmotionSituation, PhraseOption> Phrases { get; set; } = new Dictionary<EmotionSituation, PhraseOption>();
	}
	public static class MyEmotionsOptionsFile
	{
		public const string RussianFileName = "emotionsConfigs.RU.json";

		public const string EnglishFileName = "emotionsConfigs.EN.json";

		private static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
		{
			PropertyNameCaseInsensitive = true,
			ReadCommentHandling = (JsonCommentHandling)1,
			AllowTrailingCommas = true,
			Converters = { (JsonConverter)new JsonStringEnumConverter() }
		};

		public static MyEmotionsOptions Load(string path, ManualLogSource logger)
		{
			if (string.IsNullOrWhiteSpace(path))
			{
				throw new ArgumentException("A configuration path is required.", "path");
			}
			if (logger == null)
			{
				throw new ArgumentNullException("logger");
			}
			MyEmotionsOptions myEmotionsOptions = JsonSerializer.Deserialize<MyEmotionsOptions>(File.ReadAllText(path), SerializerOptions);
			if (myEmotionsOptions == null)
			{
				throw new InvalidDataException("Configuration file '" + path + "' is empty.");
			}
			if (myEmotionsOptions.GlobalPhraseCooldownSeconds < 0.0)
			{
				logger.LogWarning((object)("Negative GlobalPhraseCooldownSeconds in '" + Path.GetFileName(path) + "' was replaced with 0."));
				myEmotionsOptions.GlobalPhraseCooldownSeconds = 0.0;
			}
			MyEmotionsOptions myEmotionsOptions2 = myEmotionsOptions;
			if (myEmotionsOptions2.Phrases == null)
			{
				Dictionary<EmotionSituation, PhraseOption> dictionary = (myEmotionsOptions2.Phrases = new Dictionary<EmotionSituation, PhraseOption>());
			}
			myEmotionsOptions.Phrases = myEmotionsOptions.Phrases.ToDictionary<KeyValuePair<EmotionSituation, PhraseOption>, EmotionSituation, PhraseOption>((KeyValuePair<EmotionSituation, PhraseOption> pair) => pair.Key, (KeyValuePair<EmotionSituation, PhraseOption> pair) => NormalizePhraseOption(pair.Key, pair.Value, logger, path));
			if (!myEmotionsOptions.Phrases.Values.SelectMany((PhraseOption option) => option.Phrases).Any())
			{
				logger.LogWarning((object)("No non-empty phrase options configured for any situation in '" + Path.GetFileName(path) + "'. EmotionPhraseProvider cannot provide phrases."));
			}
			return myEmotionsOptions;
		}

		public static void EnsureLocalizedFiles(string directory, ManualLogSource logger)
		{
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: 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_0218: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Invalid comparison between Unknown and I4
			Directory.CreateDirectory(directory);
			string[] array = new string[2] { "emotionsConfigs.RU.json", "emotionsConfigs.EN.json" };
			foreach (string text in array)
			{
				string text2 = Path.Combine(directory, text);
				if (File.Exists(text2))
				{
					continue;
				}
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("MyEmotions." + text) ?? throw new InvalidDataException("Embedded '" + text + "' was not found.");
				MyEmotionsOptions myEmotionsOptions = JsonSerializer.Deserialize<MyEmotionsOptions>(stream, SerializerOptions) ?? throw new InvalidDataException("Embedded '" + text + "' is empty.");
				string path = Path.Combine(directory, "emotionsConfigs.json");
				if (File.Exists(path))
				{
					MyEmotionsOptions myEmotionsOptions2 = Load(path, logger);
					if (text == "emotionsConfigs.RU.json")
					{
						myEmotionsOptions = myEmotionsOptions2;
					}
					else
					{
						myEmotionsOptions.Enabled = myEmotionsOptions2.Enabled;
						myEmotionsOptions.GlobalPhraseCooldownSeconds = myEmotionsOptions2.GlobalPhraseCooldownSeconds;
						string text3 = File.ReadAllText(path);
						JsonDocumentOptions val = default(JsonDocumentOptions);
						((JsonDocumentOptions)(ref val)).AllowTrailingCommas = true;
						((JsonDocumentOptions)(ref val)).CommentHandling = (JsonCommentHandling)1;
						JsonDocument val2 = JsonDocument.Parse(text3, val);
						try
						{
							JsonElement element = FindProperty(val2.RootElement, "Phrases");
							foreach (KeyValuePair<EmotionSituation, PhraseOption> phrase in myEmotionsOptions2.Phrases)
							{
								if (myEmotionsOptions.Phrases.TryGetValue(phrase.Key, out PhraseOption value))
								{
									value.Enabled = phrase.Value.Enabled;
									value.CooldownSeconds = phrase.Value.CooldownSeconds;
									JsonElement val3 = FindProperty(FindProperty(element, phrase.Key.ToString()), "EnglishPhrases");
									if ((int)((JsonElement)(ref val3)).ValueKind == 2)
									{
										value.Phrases = JsonSerializer.Deserialize<List<string>>(((JsonElement)(ref val3)).GetRawText(), SerializerOptions) ?? new List<string>();
									}
								}
							}
						}
						finally
						{
							((IDisposable)val2)?.Dispose();
						}
					}
				}
				JsonSerializerOptions val4 = new JsonSerializerOptions(SerializerOptions)
				{
					WriteIndented = true,
					Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
				};
				File.WriteAllText(text2, JsonSerializer.Serialize<MyEmotionsOptions>(myEmotionsOptions, val4));
				logger.LogInfo((object)("Created configuration at '" + text2 + "'."));
			}
		}

		private static JsonElement FindProperty(JsonElement element, string name)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0023: 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)
			//IL_003e: 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_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)
			if ((int)((JsonElement)(ref element)).ValueKind != 1)
			{
				return default(JsonElement);
			}
			JsonProperty val = ((IEnumerable<JsonProperty>)(object)((JsonElement)(ref element)).EnumerateObject()).FirstOrDefault((Func<JsonProperty, bool>)((JsonProperty property) => string.Equals(((JsonProperty)(ref property)).Name, name, StringComparison.OrdinalIgnoreCase)));
			return ((JsonProperty)(ref val)).Value;
		}

		private static PhraseOption NormalizePhraseOption(EmotionSituation situation, PhraseOption? option, ManualLogSource logger, string path)
		{
			if (option == null)
			{
				option = new PhraseOption();
			}
			if (option.CooldownSeconds < 0.0)
			{
				logger.LogWarning((object)$"Negative cooldown for situation '{situation}' in '{Path.GetFileName(path)}' was replaced with 0.");
				option.CooldownSeconds = 0.0;
			}
			option.Phrases = (from phrase in option.Phrases?.Where((string phrase) => !string.IsNullOrWhiteSpace(phrase))
				select phrase.Trim()).ToList() ?? new List<string>();
			return option;
		}
	}
	public sealed class PhraseOption
	{
		public bool Enabled { get; set; } = true;

		public List<string> Phrases { get; set; } = new List<string>();

		public double CooldownSeconds { get; set; }
	}
}
namespace MyEmotions.Emotions.Chat
{
	public interface IChatService
	{
		void Send(string message);
	}
	public sealed class ValheimChatService : IChatService
	{
		private readonly ManualLogSource _logger;

		public ValheimChatService(ManualLogSource logger)
		{
			_logger = logger ?? throw new ArgumentNullException("logger");
		}

		public void Send(string message)
		{
			//IL_00b5: 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_00bd: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(message))
			{
				throw new ArgumentException("A chat message is required.", "message");
			}
			Chat instance = Chat.instance;
			Player localPlayer = Player.m_localPlayer;
			if (instance == null || localPlayer == null)
			{
				_logger.LogWarning((object)"Valheim world text is not available; the emotion phrase was not displayed.");
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(Chat), "AddInworldText", (Type[])null, (Type[])null);
			if ((object)methodInfo == null)
			{
				_logger.LogError((object)"Valheim Chat.AddInworldText was not found; the emotion phrase was not displayed to avoid adding it to the chat window.");
				return;
			}
			try
			{
				ParameterInfo[] parameters = methodInfo.GetParameters();
				if (parameters.Length != 6)
				{
					_logger.LogError((object)("Valheim Chat.AddInworldText has an unexpected signature with " + $"{parameters.Length} parameters; the emotion phrase was not displayed."));
					return;
				}
				object obj = Activator.CreateInstance(parameters[4].ParameterType);
				Vector3 position = ((Component)localPlayer).transform.position;
				ZDOID zDOID = ((Character)localPlayer).GetZDOID();
				long userID = ((ZDOID)(ref zDOID)).UserID;
				methodInfo.Invoke(instance, new object[6]
				{
					((Component)localPlayer).gameObject,
					userID,
					position,
					(object)(Type)1,
					obj,
					message
				});
				_logger.LogInfo((object)("Displayed emotion phrase above the player: '" + message + "'."));
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"Could not display emotion phrase above the player: {arg}");
			}
		}
	}
}