using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Speech.AudioFormat;
using System.Speech.Synthesis;
using System.Text;
using Babbler.Implementation.Characteristics;
using Babbler.Implementation.Common;
using Babbler.Implementation.Config;
using Babbler.Implementation.Hosts;
using Babbler.Implementation.Phonetic;
using Babbler.Implementation.Speakers;
using Babbler.Implementation.Synthesis;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FMOD;
using FMODUnity;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.IO;
using Microsoft.CodeAnalysis;
using SOD.Common.BepInEx;
using UnityEngine;
using UniverseLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Arsonide")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyCopyright("Arsonide")]
[assembly: AssemblyDescription("Plugin that makes citizens audibly speak in Shadows of Doubt.")]
[assembly: AssemblyFileVersion("0.9.5")]
[assembly: AssemblyInformationalVersion("0.9.5")]
[assembly: AssemblyProduct("Babbler")]
[assembly: AssemblyTitle("Babbler")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Arsonide/Babbler")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.5.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 Babbler
{
	[BepInPlugin("AAAA_Babbler", "Babbler", "0.9.5")]
	public class BabblerPlugin : PluginController<BabblerPlugin>
	{
		private bool _hasInitializedImmediate;

		private bool _hasInitializedDeferred;

		public override void Load()
		{
			((PluginController<BabblerPlugin, IEmptyBindings>)(object)this).Load();
			_hasInitializedImmediate = false;
			_hasInitializedDeferred = false;
			BabblerConfig.Initialize(base.Config);
			if (!BabblerConfig.Enabled.Value)
			{
				Utilities.Log("Plugin Babbler is disabled.", (LogLevel)16);
				return;
			}
			Utilities.Log("Plugin Babbler is loaded!", (LogLevel)16);
			((PluginController<BabblerPlugin, IEmptyBindings>)(object)this).Harmony.PatchAll();
			Utilities.Log("Plugin Babbler is patched!", (LogLevel)16);
			ClassInjector.RegisterTypeInIl2Cpp<SpeakerHost>();
			Utilities.Log("Plugin Babbler has added custom types!", (LogLevel)16);
			InitializeImmediate();
		}

		public override bool Unload()
		{
			UninitializeImmediate();
			UninitializeDeferred();
			return ((PluginController<BabblerPlugin, IEmptyBindings>)(object)this).Unload();
		}

		private void InitializeImmediate()
		{
			if (!_hasInitializedImmediate)
			{
				_hasInitializedImmediate = true;
				Utilities.Log("Plugin is running immediate initialization.", (LogLevel)32);
				if (BabblerConfig.Mode.Value == SpeechMode.Synthesis)
				{
					SynthesisVoiceRegistry.Initialize();
				}
			}
		}

		public void InitializeDeferred()
		{
			if (!_hasInitializedDeferred)
			{
				_hasInitializedDeferred = true;
				Utilities.Log("Plugin is running deferred initialization.", (LogLevel)32);
				FMODRegistry.Initialize();
				SpeechMode value = BabblerConfig.Mode.Value;
				SpeechMode speechMode = value;
				if (speechMode == SpeechMode.Phonetic || speechMode == SpeechMode.Droning)
				{
					PhoneticVoiceRegistry.Initialize();
				}
			}
		}

		private void UninitializeImmediate()
		{
			if (_hasInitializedImmediate)
			{
				Utilities.Log("Plugin is running immediate uninitialization.", (LogLevel)32);
				SpeakerHostPool.CleanupSpeakerHosts();
			}
		}

		private void UninitializeDeferred()
		{
			if (_hasInitializedDeferred)
			{
				Utilities.Log("Plugin is running deferred uninitialization.", (LogLevel)32);
				SpeechMode value = BabblerConfig.Mode.Value;
				SpeechMode speechMode = value;
				if (speechMode == SpeechMode.Phonetic || speechMode == SpeechMode.Droning)
				{
					PhoneticVoiceRegistry.Uninitialize();
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Babbler";

		public const string PLUGIN_NAME = "Babbler";

		public const string PLUGIN_VERSION = "0.9.5";
	}
}
namespace Babbler.Implementation.Synthesis
{
	public static class SynthesisExtensions
	{
		public static List<InstalledVoice> GetOneCoreVoices(this SpeechSynthesizer synthesizer)
		{
			List<InstalledVoice> list = new List<InstalledVoice>();
			Type typeFromHandle = typeof(SpeechSynthesizer);
			object obj = typeFromHandle.GetProperty("VoiceSynthesizer", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(synthesizer);
			if (obj == null)
			{
				return list;
			}
			Assembly assembly = typeFromHandle.Assembly;
			Type type = assembly.GetType("System.Speech.Internal.ObjectTokens.ObjectTokenCategory");
			if (type == null)
			{
				return list;
			}
			Type typeFromHandle2 = typeof(VoiceInfo);
			Type typeFromHandle3 = typeof(InstalledVoice);
			string fullName = typeFromHandle2.FullName;
			string fullName2 = typeFromHandle3.FullName;
			if (string.IsNullOrEmpty(fullName) || string.IsNullOrEmpty(fullName2))
			{
				return list;
			}
			if (!(type.GetMethod("Create", BindingFlags.Static | BindingFlags.NonPublic)?.Invoke(null, new object[1] { "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech_OneCore\\Voices" }) is IDisposable disposable))
			{
				return list;
			}
			using (disposable)
			{
				if (!(type.GetMethod("FindMatchingTokens", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(disposable, new object[2]) is IList list2))
				{
					return list;
				}
				foreach (object item in list2)
				{
					if (item == null || item.GetType().GetProperty("Attributes", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(item) == null)
					{
						continue;
					}
					object obj2 = assembly.CreateInstance(fullName, ignoreCase: true, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[1] { item }, null, null);
					if (obj2 != null)
					{
						object obj3 = assembly.CreateInstance(fullName2, ignoreCase: true, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[2] { obj, obj2 }, null, null);
						InstalledVoice val = (InstalledVoice)((obj3 is InstalledVoice) ? obj3 : null);
						if (val != null)
						{
							list.Add(val);
						}
					}
				}
			}
			return list;
		}

		public static void AddVoices(this SpeechSynthesizer synthesizer, List<InstalledVoice> voices)
		{
			Type type = ((object)synthesizer).GetType();
			object obj = type.GetProperty("VoiceSynthesizer", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(synthesizer);
			if (obj == null)
			{
				return;
			}
			Type type2 = obj.GetType();
			if (!(type2.GetField("_installedVoices", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj) is IList list))
			{
				return;
			}
			foreach (InstalledVoice voice in voices)
			{
				list.Add(voice);
			}
		}
	}
	public enum SynthesisVoiceFilterType
	{
		Everything,
		Blacklist,
		Whitelist
	}
	public static class SynthesisVoiceRegistry
	{
		public static List<InstalledVoice> OneCoreVoices = null;

		private const int PRIME_VOICE = 37;

		private static List<string> MaleVoices = new List<string>();

		private static List<string> FemaleVoices = new List<string>();

		private static List<string> NonBinaryVoices = new List<string>();

		private static List<string> AllVoices = new List<string>();

		private static List<string> VoiceFilterInput = new List<string>();

		private static bool HasMaleVoices;

		private static bool HasFemaleVoices;

		private static bool HasNonBinaryVoices;

		private static bool HasAnyVoices;

		public static void Initialize()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_00c1: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected I4, but got Unknown
			MaleVoices.Clear();
			FemaleVoices.Clear();
			NonBinaryVoices.Clear();
			AllVoices.Clear();
			SetupVoiceFilterInput();
			SpeechSynthesizer val = new SpeechSynthesizer();
			try
			{
				OneCoreVoices = val.GetOneCoreVoices();
				if (OneCoreVoices != null)
				{
					val.AddVoices(OneCoreVoices);
				}
			}
			catch (Exception ex)
			{
				Utilities.Log("Exception encountered while SynthesisVoiceRegistry tried to get OneCore voices: " + ex.Message, (LogLevel)32);
			}
			foreach (InstalledVoice installedVoice in val.GetInstalledVoices())
			{
				if (PassesVoiceFilterInput(installedVoice))
				{
					VoiceInfo voiceInfo = installedVoice.VoiceInfo;
					string name = voiceInfo.Name;
					VoiceGender gender = voiceInfo.Gender;
					AllVoices.Add(name);
					VoiceGender val2 = gender;
					VoiceGender val3 = val2;
					switch ((int)val3)
					{
					case 1:
						MaleVoices.Add(name);
						break;
					case 2:
						FemaleVoices.Add(name);
						break;
					default:
						NonBinaryVoices.Add(name);
						break;
					}
				}
			}
			HasMaleVoices = MaleVoices.Count > 0;
			HasFemaleVoices = FemaleVoices.Count > 0;
			HasNonBinaryVoices = NonBinaryVoices.Count > 0;
			HasAnyVoices = AllVoices.Count > 0;
			val.SpeakCompleted -= OnSpeakCompleted;
			val.SpeakCompleted += OnSpeakCompleted;
			val.SetOutputToNull();
			val.SpeakAsync("Initialize");
			Utilities.Log($"SynthesisVoiceRegistry has initialized! Male Voices: {MaleVoices.Count}, Female Voices: {FemaleVoices.Count}, Non-Binary Voices: {NonBinaryVoices.Count}", (LogLevel)32);
			if (AllVoices.Count <= 0 && BabblerConfig.Mode.Value == SpeechMode.Synthesis)
			{
				BabblerConfig.Mode.Value = SpeechMode.Phonetic;
				Utilities.Log("The plugin is configured for Synthesis but no voices are installed, reverting to Phonetic mode!", (LogLevel)2);
			}
		}

		private static void OnSpeakCompleted(object sender, SpeakCompletedEventArgs e)
		{
			SpeechSynthesizer val = (SpeechSynthesizer)((sender is SpeechSynthesizer) ? sender : null);
			if (val != null)
			{
				val.SpeakCompleted -= OnSpeakCompleted;
				val.Dispose();
			}
		}

		public static string GetVoice(Human human, out VoiceCharacteristics characteristics)
		{
			characteristics = VoiceCharacteristics.Create(human, HasMaleVoices, HasFemaleVoices, HasNonBinaryVoices);
			List<string> list = characteristics.Category switch
			{
				VoiceCategory.Male => MaleVoices, 
				VoiceCategory.Female => FemaleVoices, 
				VoiceCategory.NonBinary => NonBinaryVoices, 
				_ => AllVoices, 
			};
			return list[Utilities.GetDeterministicInteger(characteristics.Hash, 37, 0, list.Count)];
		}

		private static void SetupVoiceFilterInput()
		{
			VoiceFilterInput.Clear();
			string text = BabblerConfig.SynthesisVoiceFilterInput.Value.ToLowerInvariant();
			VoiceFilterInput.AddRange(text.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries));
		}

		private static bool PassesVoiceFilterInput(InstalledVoice voice)
		{
			switch (BabblerConfig.SynthesisVoiceFilter.Value)
			{
			case SynthesisVoiceFilterType.Blacklist:
				foreach (string item in VoiceFilterInput)
				{
					if (voice.VoiceInfo.Name.ToLowerInvariant().Contains(item))
					{
						return false;
					}
				}
				return true;
			case SynthesisVoiceFilterType.Whitelist:
				foreach (string item2 in VoiceFilterInput)
				{
					if (voice.VoiceInfo.Name.ToLowerInvariant().Contains(item2))
					{
						return true;
					}
				}
				return false;
			default:
				return true;
			}
		}
	}
}
namespace Babbler.Implementation.Speakers
{
	public abstract class BaseSpeaker
	{
		public Action OnFinishedSpeaking;

		protected readonly List<Channel> ActiveChannels = new List<Channel>();

		protected SpeechContext SpeechContext { get; private set; }

		protected Human SpeechPerson { get; private set; }

		protected Transform SpeechSource { get; private set; }

		protected float SpeechPitch { get; private set; }

		public virtual void InitializeSpeaker()
		{
		}

		public virtual void UninitializeSpeaker()
		{
		}

		public virtual void StopSpeaker()
		{
			ActiveChannels.Clear();
		}

		public virtual void StartSpeaker(string speechInput, SpeechContext speechContext, Human speechPerson)
		{
			StopSpeaker();
			SpeechContext = speechContext;
			SpeechPerson = speechPerson;
			SpeechSource = CacheSpeechSource(speechContext, speechPerson);
			SpeechPitch = CacheSpeechPitch(speechPerson);
		}

		public virtual void UpdateSpeaker()
		{
			//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_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_0050: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = Vector3.zero;
			if ((Object)(object)SpeechSource != (Object)null)
			{
				position = SpeechSource.position;
			}
			else
			{
				Utilities.Log("Babbler speaker had a null SpeechSource, which should not happen!", (LogLevel)32);
			}
			bool flag = false;
			bool flag2 = default(bool);
			for (int num = ActiveChannels.Count - 1; num >= 0; num--)
			{
				Channel channel = ActiveChannels[num];
				if ((int)((Channel)(ref channel)).isPlaying(ref flag2) == 0 && flag2)
				{
					SetChannelPosition(position, channel);
					flag = true;
				}
				else
				{
					ActiveChannels.RemoveAt(num);
					if (ActiveChannels.Count <= 0)
					{
						OnLastChannelFinished();
					}
				}
			}
			if (flag)
			{
				FMODRegistry.TryUpdate();
			}
		}

		protected virtual float CacheSpeechPitch(Human speechPerson)
		{
			return 1f;
		}

		private Transform CacheSpeechSource(SpeechContext speechContext, Human speechPerson)
		{
			Transform val2;
			if (speechContext == SpeechContext.PhoneSpeech || speechContext == SpeechContext.PhoneShout)
			{
				Interactable interactingWith = ((Actor)Player.Instance).interactingWith;
				object obj;
				if (interactingWith == null)
				{
					obj = null;
				}
				else
				{
					InteractableController controller = interactingWith.controller;
					obj = ((controller != null) ? controller.phoneReciever : null);
				}
				if (obj == null)
				{
					Interactable phoneInteractable = Player.Instance.phoneInteractable;
					if (phoneInteractable == null)
					{
						obj = null;
					}
					else
					{
						InteractableController controller2 = phoneInteractable.controller;
						obj = ((controller2 != null) ? controller2.phoneReciever : null);
					}
					if (obj == null)
					{
						Telephone answeringPhone = Player.Instance.answeringPhone;
						if (answeringPhone == null)
						{
							obj = null;
						}
						else
						{
							Interactable interactable = answeringPhone.interactable;
							if (interactable == null)
							{
								obj = null;
							}
							else
							{
								InteractableController controller3 = interactable.controller;
								obj = ((controller3 != null) ? controller3.phoneReciever : null);
							}
						}
					}
				}
				GameObject val = (GameObject)obj;
				val2 = ((val != null) ? val.transform : null);
			}
			else
			{
				val2 = ((speechPerson != null) ? ((Actor)speechPerson).lookAtThisTransform : null);
			}
			if ((Object)(object)val2 == (Object)null)
			{
				Player instance = Player.Instance;
				val2 = ((instance != null) ? ((Component)instance).transform : null);
			}
			return val2;
		}

		protected void SetChannelPosition(Vector3 position, Channel channel)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0031: 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_005e: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			VECTOR val = default(VECTOR);
			val.x = position.x;
			val.y = position.y;
			val.z = position.z;
			VECTOR val2 = val;
			val = default(VECTOR);
			val.x = 0f;
			val.y = 0f;
			val.z = 0f;
			VECTOR val3 = val;
			((Channel)(ref channel)).set3DAttributes(ref val2, ref val3);
		}

		protected virtual void OnLastChannelFinished()
		{
		}
	}
	public class DroningSpeaker : PhoneticSpeaker
	{
		private const int PRIME_PHONEME = 97;

		protected override void ProcessSpeechInput(Human speechPerson, ref string speechInput)
		{
			base.ProcessSpeechInput(speechPerson, ref speechInput);
			char c = PickPhoneme(speechPerson);
			Utilities.GlobalStringBuilder.Clear();
			string text = speechInput;
			foreach (char c2 in text)
			{
				Utilities.GlobalStringBuilder.Append((c2 != ' ') ? c : c2);
			}
			speechInput = Utilities.GlobalStringBuilder.ToString();
		}

		private char PickPhoneme(Human human)
		{
			return BabblerConfig.DroningValidPhonemes.Value[Utilities.GetDeterministicInteger(CurrentHash, 97, 0, BabblerConfig.DroningValidPhonemes.Value.Length)];
		}

		protected override void CacheSpeechVarianceFactors()
		{
			if (Utilities.GetDeterministicFloat(CurrentHash, 401, 0f, 1f) <= BabblerConfig.DroningChanceDelayVariance.Value)
			{
				CurrentDelayVarianceFactor = Utilities.GetDeterministicFloat(CurrentHash, 419, 0f, 1f);
			}
			else
			{
				CurrentDelayVarianceFactor = -1f;
			}
			if (Utilities.GetDeterministicFloat(CurrentHash, 409, 0f, 1f) <= BabblerConfig.DroningChancePitchVariance.Value)
			{
				CurrentPitchVarianceFactor = Utilities.GetDeterministicFloat(CurrentHash, 421, 0f, 1f);
			}
			else
			{
				CurrentPitchVarianceFactor = -1f;
			}
		}

		protected override float GetPhonemeDelay()
		{
			float value = BabblerConfig.DroningSpeechDelay.Value;
			if (CurrentDelayVarianceFactor < 0f)
			{
				return value;
			}
			float num = BabblerConfig.DroningSpeechDelay.Value + Utilities.GetRandomFloat(BabblerConfig.DroningMinDelayVariance.Value, BabblerConfig.DroningMaxDelayVariance.Value);
			return Mathf.Lerp(value, num, CurrentDelayVarianceFactor);
		}

		protected override float GetPhonemePitch()
		{
			float speechPitch = base.SpeechPitch;
			if (CurrentPitchVarianceFactor < 0f)
			{
				return speechPitch;
			}
			float num = speechPitch * Utilities.GetRandomFloat(BabblerConfig.DroningMinPitchVariance.Value, BabblerConfig.DroningMaxPitchVariance.Value);
			return Mathf.Lerp(speechPitch, num, CurrentPitchVarianceFactor);
		}
	}
	public class PhoneticSpeaker : BaseSpeaker
	{
		protected const int PRIME_DELAY_CHANCE = 401;

		protected const int PRIME_PITCH_CHANCE = 409;

		protected const int PRIME_DELAY_FACTOR = 419;

		protected const int PRIME_PITCH_FACTOR = 421;

		private readonly List<PhoneticSound> _phoneticsToSpeak = new List<PhoneticSound>();

		private Coroutine _phoneticCoroutine;

		private PhoneticVoice _currentVoice;

		protected int CurrentHash;

		protected float CurrentDelayVarianceFactor;

		protected float CurrentPitchVarianceFactor;

		public override void StopSpeaker()
		{
			base.StopSpeaker();
			if (_phoneticCoroutine != null)
			{
				RuntimeHelper.StopCoroutine(_phoneticCoroutine);
				_phoneticCoroutine = null;
			}
		}

		public override void StartSpeaker(string speechInput, SpeechContext speechContext, Human speechPerson)
		{
			base.StartSpeaker(speechInput, speechContext, speechPerson);
			CurrentHash = Utilities.GetDeterministicStringHash(speechPerson.seed);
			CacheSpeechVarianceFactors();
			ProcessSpeechInput(speechPerson, ref speechInput);
			PopulatePhoneticSounds(speechInput);
			_phoneticCoroutine = RuntimeHelper.StartCoroutine(PhoneticRoutine());
		}

		private IEnumerator PhoneticRoutine()
		{
			foreach (PhoneticSound phoneme in _phoneticsToSpeak)
			{
				if (FMODRegistry.TryPlaySound(phoneme.Sound, FMODRegistry.GetChannelGroup(base.SpeechContext), out var channel))
				{
					((Channel)(ref channel)).setPitch(GetPhonemePitch());
					SetChannelPosition(base.SpeechSource.position, channel);
					FMODRegistry.TryUpdate();
					ActiveChannels.Add(channel);
					float delay = GetPhonemeDelay();
					float syllableExpiration = Time.realtimeSinceStartup + phoneme.Length + delay;
					while (Time.realtimeSinceStartup < syllableExpiration)
					{
						yield return null;
					}
					channel = default(Channel);
				}
			}
			OnFinishedSpeaking?.Invoke();
		}

		protected virtual void ProcessSpeechInput(Human speechPerson, ref string speechInput)
		{
		}

		private void PopulatePhoneticSounds(string speechInput)
		{
			_phoneticsToSpeak.Clear();
			ReadOnlySpan<char> readOnlySpan = speechInput.ToLowerInvariant().AsSpan();
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(i, Math.Min(2, readOnlySpan.Length - i));
				string text = readOnlySpan2.ToString();
				if (readOnlySpan2.Length > 1 && _currentVoice.TryGetPhoneticSound(text, out var result))
				{
					_phoneticsToSpeak.Add(result);
					i++;
				}
				else if (_currentVoice.TryGetPhoneticSound(text[0].ToString(), out result))
				{
					_phoneticsToSpeak.Add(result);
				}
			}
		}

		protected override float CacheSpeechPitch(Human speechPerson)
		{
			_currentVoice = PhoneticVoiceRegistry.GetVoice(speechPerson, out var characteristics);
			float value;
			float value2;
			switch (characteristics.Category)
			{
			case VoiceCategory.Male:
				value = BabblerConfig.PhoneticMinFrequencyMale.Value;
				value2 = BabblerConfig.PhoneticMaxFrequencyMale.Value;
				break;
			case VoiceCategory.Female:
				value = BabblerConfig.PhoneticMinFrequencyFemale.Value;
				value2 = BabblerConfig.PhoneticMaxFrequencyFemale.Value;
				break;
			default:
				value = BabblerConfig.PhoneticMinFrequencyNonBinary.Value;
				value2 = BabblerConfig.PhoneticMaxFrequencyNonBinary.Value;
				break;
			}
			float num = value + characteristics.Pitch * (value2 - value);
			return num / _currentVoice.Frequency;
		}

		protected virtual void CacheSpeechVarianceFactors()
		{
			if (Utilities.GetDeterministicFloat(CurrentHash, 401, 0f, 1f) <= BabblerConfig.PhoneticChanceDelayVariance.Value)
			{
				CurrentDelayVarianceFactor = Utilities.GetDeterministicFloat(CurrentHash, 419, 0f, 1f);
			}
			else
			{
				CurrentDelayVarianceFactor = -1f;
			}
			if (Utilities.GetDeterministicFloat(CurrentHash, 409, 0f, 1f) <= BabblerConfig.PhoneticChancePitchVariance.Value)
			{
				CurrentPitchVarianceFactor = Utilities.GetDeterministicFloat(CurrentHash, 421, 0f, 1f);
			}
			else
			{
				CurrentPitchVarianceFactor = -1f;
			}
		}

		protected virtual float GetPhonemeDelay()
		{
			float value = BabblerConfig.PhoneticSpeechDelay.Value;
			if (CurrentDelayVarianceFactor < 0f)
			{
				return value;
			}
			float num = BabblerConfig.PhoneticSpeechDelay.Value + Utilities.GetRandomFloat(BabblerConfig.PhoneticMinDelayVariance.Value, BabblerConfig.PhoneticMaxDelayVariance.Value);
			return Mathf.Lerp(value, num, CurrentDelayVarianceFactor);
		}

		protected virtual float GetPhonemePitch()
		{
			float speechPitch = base.SpeechPitch;
			if (CurrentPitchVarianceFactor < 0f)
			{
				return speechPitch;
			}
			float num = speechPitch * Utilities.GetRandomFloat(BabblerConfig.PhoneticMinPitchVariance.Value, BabblerConfig.PhoneticMaxPitchVariance.Value);
			return Mathf.Lerp(speechPitch, num, CurrentPitchVarianceFactor);
		}
	}
	public class SynthesisSpeaker : BaseSpeaker
	{
		private SpeechSynthesizer _synthesizer;

		private MemoryStream _memoryStream;

		public override void InitializeSpeaker()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			base.InitializeSpeaker();
			_synthesizer = new SpeechSynthesizer();
			try
			{
				if (SynthesisVoiceRegistry.OneCoreVoices != null)
				{
					_synthesizer.AddVoices(SynthesisVoiceRegistry.OneCoreVoices);
				}
			}
			catch (Exception ex)
			{
				Utilities.Log("Exception encountered while SynthesisSpeaker tried to add OneCore voices: " + ex.Message, (LogLevel)32);
			}
			_memoryStream = new MemoryStream();
			_synthesizer.SetOutputToAudioStream((Stream)_memoryStream, new SpeechAudioFormatInfo(44100, (AudioBitsPerSample)16, (AudioChannel)1));
		}

		public override void UninitializeSpeaker()
		{
			base.UninitializeSpeaker();
			_synthesizer.Dispose();
			_memoryStream.Dispose();
		}

		public override void StopSpeaker()
		{
			base.StopSpeaker();
			_synthesizer.SpeakCompleted -= OnSpeakCompleted;
			_synthesizer.SpeakAsyncCancelAll();
		}

		public override void StartSpeaker(string speechInput, SpeechContext speechContext, Human speechPerson)
		{
			base.StartSpeaker(speechInput, speechContext, speechPerson);
			_synthesizer.SpeakCompleted -= OnSpeakCompleted;
			_synthesizer.SpeakCompleted += OnSpeakCompleted;
			_synthesizer.SpeakAsync(speechInput);
		}

		private void OnSpeakCompleted(object sender, SpeakCompletedEventArgs args)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			SpeechSynthesizer val = (SpeechSynthesizer)((sender is SpeechSynthesizer) ? sender : null);
			if (val != null)
			{
				val.SpeakCompleted -= OnSpeakCompleted;
				_memoryStream.Position = 0L;
				CREATESOUNDEXINFO val2 = default(CREATESOUNDEXINFO);
				val2.cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO));
				val2.length = (uint)_memoryStream.Length;
				val2.format = (SOUND_FORMAT)2;
				val2.defaultfrequency = 44100;
				val2.numchannels = 1;
				CREATESOUNDEXINFO extraInfo = val2;
				if (FMODRegistry.TryCreateSound(_memoryStream.ToArray(), (MODE)6160, ref extraInfo, out var sound) && FMODRegistry.TryPlaySound(sound, FMODRegistry.GetChannelGroup(base.SpeechContext), out var channel))
				{
					((Channel)(ref channel)).setPitch(base.SpeechPitch);
					SetChannelPosition(base.SpeechSource.position, channel);
					FMODRegistry.TryUpdate();
					ActiveChannels.Add(channel);
				}
			}
		}

		protected override float CacheSpeechPitch(Human speechPerson)
		{
			VoiceCharacteristics characteristics;
			string voice = SynthesisVoiceRegistry.GetVoice(speechPerson, out characteristics);
			_synthesizer.SelectVoice(voice);
			_synthesizer.Rate = Mathf.RoundToInt(Mathf.Lerp((float)BabblerConfig.SynthesisMinSpeed.Value, (float)BabblerConfig.SynthesisMaxSpeed.Value, characteristics.Rate));
			return characteristics.Category switch
			{
				VoiceCategory.Male => Mathf.Lerp(BabblerConfig.SynthesisMinPitchMale.Value, BabblerConfig.SynthesisMaxPitchMale.Value, characteristics.Pitch), 
				VoiceCategory.Female => Mathf.Lerp(BabblerConfig.SynthesisMinPitchFemale.Value, BabblerConfig.SynthesisMaxPitchFemale.Value, characteristics.Pitch), 
				_ => Mathf.Lerp(BabblerConfig.SynthesisMinPitchNonBinary.Value, BabblerConfig.SynthesisMaxPitchNonBinary.Value, characteristics.Pitch), 
			};
		}

		protected override void OnLastChannelFinished()
		{
			base.OnLastChannelFinished();
			_memoryStream.Seek(0L, SeekOrigin.Begin);
			_memoryStream.SetLength(0L);
			OnFinishedSpeaking?.Invoke();
		}
	}
}
namespace Babbler.Implementation.Phonetic
{
	public class PhoneticSound
	{
		public string Phonetic;

		public string FilePath;

		public Sound Sound;

		public float Length;

		public bool Released;
	}
	public class PhoneticVoice
	{
		private readonly Dictionary<string, PhoneticSound> _phonemes = new Dictionary<string, PhoneticSound>();

		public string Name { get; private set; }

		public float Frequency { get; private set; }

		public void Initialize(string directory)
		{
			_phonemes.Clear();
			if (!Directory.Exists(directory))
			{
				return;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(directory);
			string[] array = fileNameWithoutExtension.Split('_', StringSplitOptions.RemoveEmptyEntries);
			if (array.Length != 2 || !float.TryParse(array[1], out var result))
			{
				return;
			}
			Frequency = result;
			Name = array[0];
			string[] files = Directory.GetFiles(directory, "*.wav");
			foreach (string text in files)
			{
				string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(text);
				string[] array2 = fileNameWithoutExtension2.Split('_');
				if (array2.Length != 2)
				{
					continue;
				}
				string text2 = array2[1].ToLowerInvariant();
				PhoneticSound value = CreatePhoneticSound(text, text2);
				if (fileNameWithoutExtension2.StartsWith("symbol"))
				{
					if (text2.Contains("space"))
					{
						_phonemes[" "] = value;
						_phonemes[","] = value;
					}
					else if (text2.Contains("exclamation"))
					{
						_phonemes["!"] = value;
					}
					else if (text2.Contains("question"))
					{
						_phonemes["?"] = value;
					}
					else if (text2.Contains("period"))
					{
						_phonemes["."] = value;
					}
				}
				else
				{
					_phonemes[text2] = value;
				}
			}
		}

		public void Uninitialize()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<string, PhoneticSound> phoneme in _phonemes)
			{
				if (!phoneme.Value.Released)
				{
					((Sound)(ref phoneme.Value.Sound)).release();
					phoneme.Value.Released = true;
				}
			}
		}

		private PhoneticSound CreatePhoneticSound(string filePath, string phonetic)
		{
			//IL_001f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!FMODRegistry.TryCreateSound(filePath, (MODE)16, out var sound))
			{
				return null;
			}
			uint num = default(uint);
			((Sound)(ref sound)).getLength(ref num, (TIMEUNIT)1);
			float length = (float)num / 1000f;
			return new PhoneticSound
			{
				Phonetic = phonetic,
				FilePath = filePath,
				Sound = sound,
				Length = length,
				Released = false
			};
		}

		public bool TryGetPhoneticSound(string phonetic, out PhoneticSound result)
		{
			return _phonemes.TryGetValue(phonetic, out result);
		}
	}
	public static class PhoneticVoiceRegistry
	{
		private const int PRIME_VOICE = 211;

		private static readonly List<PhoneticVoice> Voices = new List<PhoneticVoice>();

		public static void Initialize()
		{
			Voices.Clear();
			string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? throw new InvalidOperationException(), "Phonemes");
			string[] directories = Directory.GetDirectories(path);
			foreach (string directory in directories)
			{
				PhoneticVoice phoneticVoice = new PhoneticVoice();
				phoneticVoice.Initialize(directory);
				Voices.Add(phoneticVoice);
			}
			Utilities.Log($"SynthesisVoiceRegistry has initialized! Voices: {Voices.Count}", (LogLevel)32);
		}

		public static void Uninitialize()
		{
			foreach (PhoneticVoice voice in Voices)
			{
				voice.Uninitialize();
			}
		}

		public static PhoneticVoice GetVoice(Human human, out VoiceCharacteristics characteristics)
		{
			characteristics = VoiceCharacteristics.Create(human, maleVoiceAvailable: true, femaleVoiceAvailable: true, nonBinaryVoiceAvailable: true);
			return Voices[Utilities.GetDeterministicInteger(characteristics.Hash, 211, 0, Voices.Count)];
		}
	}
}
namespace Babbler.Implementation.Hosts
{
	public class SpeakerHost : MonoBehaviour
	{
		public BaseSpeaker Speaker;

		private void Awake()
		{
			switch (BabblerConfig.Mode.Value)
			{
			case SpeechMode.Synthesis:
				Speaker = new SynthesisSpeaker();
				break;
			case SpeechMode.Phonetic:
				Speaker = new PhoneticSpeaker();
				break;
			case SpeechMode.Droning:
				Speaker = new DroningSpeaker();
				break;
			default:
				Speaker = new PhoneticSpeaker();
				break;
			}
			BaseSpeaker speaker = Speaker;
			speaker.OnFinishedSpeaking = (Action)Delegate.Remove(speaker.OnFinishedSpeaking, new Action(OnFinishedSpeaking));
			BaseSpeaker speaker2 = Speaker;
			speaker2.OnFinishedSpeaking = (Action)Delegate.Combine(speaker2.OnFinishedSpeaking, new Action(OnFinishedSpeaking));
			Speaker.InitializeSpeaker();
		}

		private void OnDestroy()
		{
			BaseSpeaker speaker = Speaker;
			speaker.OnFinishedSpeaking = (Action)Delegate.Remove(speaker.OnFinishedSpeaking, new Action(OnFinishedSpeaking));
			Speaker.UninitializeSpeaker();
		}

		private void OnEnable()
		{
			Speaker.StopSpeaker();
		}

		private void OnDisable()
		{
			Speaker.StopSpeaker();
		}

		private void Update()
		{
			Speaker.UpdateSpeaker();
		}

		private void OnFinishedSpeaking()
		{
			SpeakerHostPool.ReleaseSpeakerHost(this);
		}
	}
	public static class SpeakerHostPool
	{
		private static List<SpeakerHost> AvailableHosts = new List<SpeakerHost>();

		private static List<SpeakerHost> AllHosts = new List<SpeakerHost>();

		public static void Play(string speechInput, SpeechContext speechContext, Human speechPerson)
		{
			SpeakerHost speakerHost = GetSpeakerHost();
			speakerHost.Speaker.StartSpeaker(speechInput, speechContext, speechPerson);
		}

		private static SpeakerHost GetSpeakerHost()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0057: 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)
			int num = AvailableHosts.Count - 1;
			SpeakerHost speakerHost;
			if (num >= 0)
			{
				speakerHost = AvailableHosts[num];
				AvailableHosts.RemoveAt(num);
				((Component)speakerHost).gameObject.SetActive(true);
			}
			else
			{
				GameObject val = new GameObject("BabblerSpeakerHost");
				val.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
				speakerHost = val.AddComponent<SpeakerHost>();
				Object.DontDestroyOnLoad((Object)(object)val);
				AllHosts.Add(speakerHost);
				Utilities.Log($"Created speaker host, current count is {AllHosts.Count}.", (LogLevel)32);
			}
			return speakerHost;
		}

		public static void ReleaseSpeakerHost(SpeakerHost speakerHost)
		{
			((Component)speakerHost).gameObject.SetActive(false);
			AvailableHosts.Add(speakerHost);
		}

		public static void CleanupSpeakerHosts()
		{
			for (int num = AllHosts.Count - 1; num >= 0; num--)
			{
				SpeakerHost speakerHost = AllHosts[num];
				if (((Component)speakerHost).gameObject.activeSelf)
				{
					((Component)speakerHost).gameObject.SetActive(false);
				}
				Object.DestroyImmediate((Object)(object)((Component)speakerHost).gameObject);
			}
			Utilities.Log("Cleaned up all speaker hosts.", (LogLevel)32);
		}
	}
}
namespace Babbler.Implementation.Config
{
	public static class BabblerConfig
	{
		public static ConfigEntry<string> DroningValidPhonemes;

		public static ConfigEntry<float> DroningSpeechDelay;

		public static ConfigEntry<float> DroningChanceDelayVariance;

		public static ConfigEntry<float> DroningMinDelayVariance;

		public static ConfigEntry<float> DroningMaxDelayVariance;

		public static ConfigEntry<float> DroningChancePitchVariance;

		public static ConfigEntry<float> DroningMinPitchVariance;

		public static ConfigEntry<float> DroningMaxPitchVariance;

		public static ConfigEntry<float> DroningMinFrequencyMale;

		public static ConfigEntry<float> DroningMaxFrequencyMale;

		public static ConfigEntry<float> DroningMinFrequencyFemale;

		public static ConfigEntry<float> DroningMaxFrequencyFemale;

		public static ConfigEntry<float> DroningMinFrequencyNonBinary;

		public static ConfigEntry<float> DroningMaxFrequencyNonBinary;

		private const string ExpectedVersion = "74d012a7e2564fa9badbc23749a9b16c";

		public static ConfigEntry<string> Version;

		public static ConfigEntry<bool> Enabled;

		public static ConfigEntry<SpeechMode> Mode;

		public static ConfigEntry<bool> DistortPhoneSpeech;

		public static ConfigEntry<float> ConversationalVolume;

		public static ConfigEntry<float> OverheardVolume;

		public static ConfigEntry<float> PhoneVolume;

		public static ConfigEntry<float> ConversationalShoutMultiplier;

		public static ConfigEntry<float> OverheardShoutMultiplier;

		public static ConfigEntry<float> PhoneShoutMultiplier;

		public static ConfigEntry<float> FemaleThreshold;

		public static ConfigEntry<float> MaleThreshold;

		public static ConfigEntry<float> GenderDiversity;

		public static ConfigEntry<float> PhoneticSpeechDelay;

		public static ConfigEntry<float> PhoneticChanceDelayVariance;

		public static ConfigEntry<float> PhoneticMinDelayVariance;

		public static ConfigEntry<float> PhoneticMaxDelayVariance;

		public static ConfigEntry<float> PhoneticChancePitchVariance;

		public static ConfigEntry<float> PhoneticMinPitchVariance;

		public static ConfigEntry<float> PhoneticMaxPitchVariance;

		public static ConfigEntry<float> PhoneticMinFrequencyMale;

		public static ConfigEntry<float> PhoneticMaxFrequencyMale;

		public static ConfigEntry<float> PhoneticMinFrequencyFemale;

		public static ConfigEntry<float> PhoneticMaxFrequencyFemale;

		public static ConfigEntry<float> PhoneticMinFrequencyNonBinary;

		public static ConfigEntry<float> PhoneticMaxFrequencyNonBinary;

		public static ConfigEntry<SynthesisVoiceFilterType> SynthesisVoiceFilter;

		public static ConfigEntry<string> SynthesisVoiceFilterInput;

		public static ConfigEntry<int> SynthesisMinSpeed;

		public static ConfigEntry<int> SynthesisMaxSpeed;

		public static ConfigEntry<float> SynthesisMinPitchMale;

		public static ConfigEntry<float> SynthesisMaxPitchMale;

		public static ConfigEntry<float> SynthesisMinPitchFemale;

		public static ConfigEntry<float> SynthesisMaxPitchFemale;

		public static ConfigEntry<float> SynthesisMinPitchNonBinary;

		public static ConfigEntry<float> SynthesisMaxPitchNonBinary;

		private static void InitializeDroning(ConfigFile config)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			DroningValidPhonemes = config.Bind<string>("6. Droning", "Valid Phonemes", "aeiouybdglmptvw", new ConfigDescription("Citizens pick one phoneme to repeat, that is chosen from these phonemes.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningSpeechDelay = config.Bind<float>("6. Droning", "Speech Delay", -0.175f, new ConfigDescription("The delay of each phoneme is its length plus this. Negative numbers cause overlapping phonemes.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningChanceDelayVariance = config.Bind<float>("6. Droning", "Chance Delay Variance", 0.4f, new ConfigDescription("This is the chance for any citizen to speak with variations in their phoneme delay.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			DroningMinDelayVariance = config.Bind<float>("6. Droning", "Min Delay Variance", 0f, new ConfigDescription("A value between the min and max delay variance is chosen to add to the speech delay to create variations in it.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMaxDelayVariance = config.Bind<float>("6. Droning", "Max Delay Variance", 0.3f, new ConfigDescription("A value between the min and max delay variance is chosen to add to the speech delay to create variations in it.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningChancePitchVariance = config.Bind<float>("6. Droning", "Chance Pitch Variance", 0.2f, new ConfigDescription("This is the chance for any citizen to speak with variations in their phoneme pitch.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			DroningMinPitchVariance = config.Bind<float>("6. Droning", "Min Pitch Variance", 0.8f, new ConfigDescription("A value between the min and max pitch variance is chosen to multiply with the phoneme pitch to create variations of it.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMaxPitchVariance = config.Bind<float>("6. Droning", "Max Pitch Variance", 1.2f, new ConfigDescription("A value between the min and max pitch variance is chosen to multiply with the phoneme pitch to create variations of it.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMinFrequencyMale = config.Bind<float>("6. Droning", "Min Frequency Male", 100f, new ConfigDescription("Lowest possible frequency (in hertz) for male voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMaxFrequencyMale = config.Bind<float>("6. Droning", "Max Frequency Male", 180f, new ConfigDescription("Highest possible frequency (in hertz) for male voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMinFrequencyFemale = config.Bind<float>("6. Droning", "Min Frequency Female", 165f, new ConfigDescription("Lowest possible frequency (in hertz) for female voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMaxFrequencyFemale = config.Bind<float>("6. Droning", "Max Frequency Female", 255f, new ConfigDescription("Highest possible frequency (in hertz) for female voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMinFrequencyNonBinary = config.Bind<float>("6. Droning", "Min Frequency Non-Binary", 100f, new ConfigDescription("Lowest possible frequency (in hertz) for non-binary voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			DroningMaxFrequencyNonBinary = config.Bind<float>("6. Droning", "Max Frequency Non-Binary", 255f, new ConfigDescription("Highest possible frequency (in hertz) for non-binary voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			Utilities.EnforceMinMax(ref DroningMinDelayVariance, ref DroningMaxDelayVariance);
			Utilities.EnforceMinMax(ref DroningMinPitchVariance, ref DroningMaxPitchVariance);
			Utilities.EnforceMinMax(ref DroningMinFrequencyMale, ref DroningMaxFrequencyMale);
			Utilities.EnforceMinMax(ref DroningMinFrequencyFemale, ref DroningMaxFrequencyFemale);
			Utilities.EnforceMinMax(ref DroningMinFrequencyNonBinary, ref DroningMaxFrequencyNonBinary);
		}

		public static void ResetDroning()
		{
			DroningValidPhonemes.Value = (string)((ConfigEntryBase)DroningValidPhonemes).DefaultValue;
			DroningSpeechDelay.Value = (float)((ConfigEntryBase)DroningSpeechDelay).DefaultValue;
			DroningChanceDelayVariance.Value = (float)((ConfigEntryBase)DroningChanceDelayVariance).DefaultValue;
			DroningMinDelayVariance.Value = (float)((ConfigEntryBase)DroningMinDelayVariance).DefaultValue;
			DroningMaxDelayVariance.Value = (float)((ConfigEntryBase)DroningMaxDelayVariance).DefaultValue;
			DroningChancePitchVariance.Value = (float)((ConfigEntryBase)DroningChancePitchVariance).DefaultValue;
			DroningMinPitchVariance.Value = (float)((ConfigEntryBase)DroningMinPitchVariance).DefaultValue;
			DroningMaxPitchVariance.Value = (float)((ConfigEntryBase)DroningMaxPitchVariance).DefaultValue;
			DroningMinFrequencyMale.Value = (float)((ConfigEntryBase)DroningMinFrequencyMale).DefaultValue;
			DroningMaxFrequencyMale.Value = (float)((ConfigEntryBase)DroningMaxFrequencyMale).DefaultValue;
			DroningMinFrequencyFemale.Value = (float)((ConfigEntryBase)DroningMinFrequencyFemale).DefaultValue;
			DroningMaxFrequencyFemale.Value = (float)((ConfigEntryBase)DroningMaxFrequencyFemale).DefaultValue;
			DroningMinFrequencyNonBinary.Value = (float)((ConfigEntryBase)DroningMinFrequencyNonBinary).DefaultValue;
			DroningMaxFrequencyNonBinary.Value = (float)((ConfigEntryBase)DroningMaxFrequencyNonBinary).DefaultValue;
		}

		public static void Initialize(ConfigFile config)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Expected O, but got Unknown
			ProcessOldConfigFile(config);
			Enabled = config.Bind<bool>("1. General", "Enabled", true, new ConfigDescription("Another method of enabling and disabling Babbler.", (AcceptableValueBase)null, Array.Empty<object>()));
			Mode = config.Bind<SpeechMode>("1. General", "Mode", SpeechMode.Synthesis, new ConfigDescription("Determines whether citizens will talk with text to speech synthesis, phonetic sounds, or monosyllabic droning.", (AcceptableValueBase)null, Array.Empty<object>()));
			Version = config.Bind<string>("1. General", "Version", string.Empty, new ConfigDescription("Babbler uses this to reset your configuration between major versions. Don't modify it or it will reset your configuration!", (AcceptableValueBase)null, Array.Empty<object>()));
			DistortPhoneSpeech = config.Bind<bool>("1. General", "Distort Phone Speech", true, new ConfigDescription("When enabled, a band pass is applied to phones to make them sound a little tinnier, like phones.", (AcceptableValueBase)null, Array.Empty<object>()));
			FemaleThreshold = config.Bind<float>("2. Gender", "Female Threshold", 0.49f, new ConfigDescription("Increase for more female voices, decrease for less, defaults to what the stock game uses for citizens.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			MaleThreshold = config.Bind<float>("2. Gender", "Male Threshold", 0.51f, new ConfigDescription("Decrease for more male voices, increase for less, defaults to what the stock game uses for citizens.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			GenderDiversity = config.Bind<float>("2. Gender", "Gender Diversity", 0.05f, new ConfigDescription("Adds a random element to voice gender selection, increase for more diverse voices.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ConversationalVolume = config.Bind<float>("3. Volume", "Conversational Volume", 0.7f, new ConfigDescription("How loud voices will be when you are speaking directly to a person.", (AcceptableValueBase)null, Array.Empty<object>()));
			OverheardVolume = config.Bind<float>("3. Volume", "Overheard Volume", 0.3f, new ConfigDescription("How loud voices that you overhear nearby will be when you are not talking directly to them.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneVolume = config.Bind<float>("3. Volume", "Phone Volume", 0.5f, new ConfigDescription("How loud voices will be when you are talking with a person over the phone.", (AcceptableValueBase)null, Array.Empty<object>()));
			ConversationalShoutMultiplier = config.Bind<float>("3. Volume", "Conversational Shout Multiplier", 2.9f, new ConfigDescription("When speaking in all caps, how much to multiply the normal conversational volume.", (AcceptableValueBase)null, Array.Empty<object>()));
			OverheardShoutMultiplier = config.Bind<float>("3. Volume", "Overheard Shout Multiplier", 6.6f, new ConfigDescription("When speaking in all caps, how much to multiply the normal overheard volume.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneShoutMultiplier = config.Bind<float>("3. Volume", "Phone Shout Multiplier", 4f, new ConfigDescription("When speaking in all caps, how much to multiply the normal phone volume.", (AcceptableValueBase)null, Array.Empty<object>()));
			InitializeSynthesis(config);
			InitializePhonetic(config);
			InitializeDroning(config);
			ProcessUpgrades();
			Utilities.Log("BabblerConfig has initialized!", (LogLevel)32);
		}

		private static void ProcessOldConfigFile(ConfigFile newFile)
		{
			string configFilePath = newFile.ConfigFilePath;
			string text = configFilePath.Replace("AAAA_", string.Empty);
			try
			{
				if (File.Exists(text))
				{
					if (File.Exists(configFilePath))
					{
						File.Delete(configFilePath);
					}
					Utilities.Log("Babbler found old config file path, renaming config file!", (LogLevel)16);
					File.Move(text, configFilePath);
					newFile.Reload();
				}
			}
			catch (Exception ex)
			{
				Utilities.Log("Error processing old config file: " + ex.Message, (LogLevel)2);
			}
		}

		private static void ProcessUpgrades()
		{
			if (!(Version.Value == "74d012a7e2564fa9badbc23749a9b16c"))
			{
				Utilities.Log("Detected either a new installation or a major upgrade of Babbler, resetting the configuration file!", (LogLevel)16);
				Version.Value = "74d012a7e2564fa9badbc23749a9b16c";
				Reset();
			}
		}

		private static void Reset()
		{
			Enabled.Value = (bool)((ConfigEntryBase)Enabled).DefaultValue;
			Mode.Value = (SpeechMode)((ConfigEntryBase)Mode).DefaultValue;
			DistortPhoneSpeech.Value = (bool)((ConfigEntryBase)DistortPhoneSpeech).DefaultValue;
			ConversationalVolume.Value = (float)((ConfigEntryBase)ConversationalVolume).DefaultValue;
			OverheardVolume.Value = (float)((ConfigEntryBase)OverheardVolume).DefaultValue;
			PhoneVolume.Value = (float)((ConfigEntryBase)PhoneVolume).DefaultValue;
			ConversationalShoutMultiplier.Value = (float)((ConfigEntryBase)ConversationalShoutMultiplier).DefaultValue;
			OverheardShoutMultiplier.Value = (float)((ConfigEntryBase)OverheardShoutMultiplier).DefaultValue;
			PhoneShoutMultiplier.Value = (float)((ConfigEntryBase)PhoneShoutMultiplier).DefaultValue;
			FemaleThreshold.Value = (float)((ConfigEntryBase)FemaleThreshold).DefaultValue;
			MaleThreshold.Value = (float)((ConfigEntryBase)MaleThreshold).DefaultValue;
			GenderDiversity.Value = (float)((ConfigEntryBase)GenderDiversity).DefaultValue;
			ResetSynthesis();
			ResetPhonetic();
			ResetDroning();
		}

		private static void InitializePhonetic(ConfigFile config)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			PhoneticSpeechDelay = config.Bind<float>("5. Phonetic", "Speech Delay", -0.175f, new ConfigDescription("The delay of each phoneme is its length plus this. Negative numbers cause overlapping phonemes.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticChanceDelayVariance = config.Bind<float>("5. Phonetic", "Chance Delay Variance", 0f, new ConfigDescription("This is the chance for any citizen to speak with variations in their phoneme delay.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			PhoneticMinDelayVariance = config.Bind<float>("5. Phonetic", "Min Delay Variance", 0f, new ConfigDescription("A value between the min and max delay variance is chosen to add to the speech delay to create variations in it.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMaxDelayVariance = config.Bind<float>("5. Phonetic", "Max Delay Variance", 0f, new ConfigDescription("A value between the min and max delay variance is chosen to add to the speech delay to create variations in it.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticChancePitchVariance = config.Bind<float>("5. Phonetic", "Chance Pitch Variance", 0.2f, new ConfigDescription("This is the chance for any citizen to speak with variations in their phoneme pitch.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			PhoneticMinPitchVariance = config.Bind<float>("5. Phonetic", "Min Pitch Variance", 0.9f, new ConfigDescription("A value between the min and max pitch variance is chosen to multiply with the phoneme pitch to create variations of it.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMaxPitchVariance = config.Bind<float>("5. Phonetic", "Max Pitch Variance", 1.1f, new ConfigDescription("A value between the min and max pitch variance is chosen to multiply with the phoneme pitch to create variations of it.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMinFrequencyMale = config.Bind<float>("5. Phonetic", "Min Frequency Male", 100f, new ConfigDescription("Lowest possible frequency (in hertz) for male voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMaxFrequencyMale = config.Bind<float>("5. Phonetic", "Max Frequency Male", 180f, new ConfigDescription("Highest possible frequency (in hertz) for male voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMinFrequencyFemale = config.Bind<float>("5. Phonetic", "Min Frequency Female", 165f, new ConfigDescription("Lowest possible frequency (in hertz) for female voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMaxFrequencyFemale = config.Bind<float>("5. Phonetic", "Max Frequency Female", 255f, new ConfigDescription("Highest possible frequency (in hertz) for female voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMinFrequencyNonBinary = config.Bind<float>("5. Phonetic", "Min Frequency Non-Binary", 100f, new ConfigDescription("Lowest possible frequency (in hertz) for non-binary voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			PhoneticMaxFrequencyNonBinary = config.Bind<float>("5. Phonetic", "Max Frequency Non-Binary", 255f, new ConfigDescription("Highest possible frequency (in hertz) for non-binary voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			Utilities.EnforceMinMax(ref PhoneticMinDelayVariance, ref PhoneticMaxDelayVariance);
			Utilities.EnforceMinMax(ref PhoneticMinPitchVariance, ref PhoneticMaxPitchVariance);
			Utilities.EnforceMinMax(ref PhoneticMinFrequencyMale, ref PhoneticMaxFrequencyMale);
			Utilities.EnforceMinMax(ref PhoneticMinFrequencyFemale, ref PhoneticMaxFrequencyFemale);
			Utilities.EnforceMinMax(ref PhoneticMinFrequencyNonBinary, ref PhoneticMaxFrequencyNonBinary);
		}

		public static void ResetPhonetic()
		{
			PhoneticSpeechDelay.Value = (float)((ConfigEntryBase)PhoneticSpeechDelay).DefaultValue;
			PhoneticChanceDelayVariance.Value = (float)((ConfigEntryBase)PhoneticChanceDelayVariance).DefaultValue;
			PhoneticMinDelayVariance.Value = (float)((ConfigEntryBase)PhoneticMinDelayVariance).DefaultValue;
			PhoneticMaxDelayVariance.Value = (float)((ConfigEntryBase)PhoneticMaxDelayVariance).DefaultValue;
			PhoneticChancePitchVariance.Value = (float)((ConfigEntryBase)PhoneticChancePitchVariance).DefaultValue;
			PhoneticMinPitchVariance.Value = (float)((ConfigEntryBase)PhoneticMinPitchVariance).DefaultValue;
			PhoneticMaxPitchVariance.Value = (float)((ConfigEntryBase)PhoneticMaxPitchVariance).DefaultValue;
			PhoneticMinFrequencyMale.Value = (float)((ConfigEntryBase)PhoneticMinFrequencyMale).DefaultValue;
			PhoneticMaxFrequencyMale.Value = (float)((ConfigEntryBase)PhoneticMaxFrequencyMale).DefaultValue;
			PhoneticMinFrequencyFemale.Value = (float)((ConfigEntryBase)PhoneticMinFrequencyFemale).DefaultValue;
			PhoneticMaxFrequencyFemale.Value = (float)((ConfigEntryBase)PhoneticMaxFrequencyFemale).DefaultValue;
			PhoneticMinFrequencyNonBinary.Value = (float)((ConfigEntryBase)PhoneticMinFrequencyNonBinary).DefaultValue;
			PhoneticMaxFrequencyNonBinary.Value = (float)((ConfigEntryBase)PhoneticMaxFrequencyNonBinary).DefaultValue;
		}

		private static void InitializeSynthesis(ConfigFile config)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			SynthesisVoiceFilter = config.Bind<SynthesisVoiceFilterType>("4. Synthesis", "Voice Filter Type", SynthesisVoiceFilterType.Everything, new ConfigDescription("Determines which installed voices on Windows Babbler will use. Set to \"Everything\" for all installed voices, \"Blacklist\" to block some, or \"Whitelist\" to only allow some.", (AcceptableValueBase)null, Array.Empty<object>()));
			SynthesisVoiceFilterInput = config.Bind<string>("4. Synthesis", "Voice Filter", string.Empty, new ConfigDescription("If filter type is set to blacklist or whitelist, this is where you put the names you want to filter for in, separated by semicolons. The names are case-insensitive and flexible, so \"david\" matches \"Microsoft David\", etc.", (AcceptableValueBase)null, Array.Empty<object>()));
			SynthesisMinSpeed = config.Bind<int>("4. Synthesis", "Min Speed", -2, new ConfigDescription("Lowest possible speed for speech. Zero being the standard speed.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-10, 10), Array.Empty<object>()));
			SynthesisMaxSpeed = config.Bind<int>("4. Synthesis", "Max Speed", 3, new ConfigDescription("Highest possible speed for speech. Zero being the standard speed.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-10, 10), Array.Empty<object>()));
			SynthesisMinPitchMale = config.Bind<float>("4. Synthesis", "Min Pitch Male", 0.75f, new ConfigDescription("Lowest possible pitch (relative percent) for male voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			SynthesisMaxPitchMale = config.Bind<float>("4. Synthesis", "Max Pitch Male", 1.25f, new ConfigDescription("Highest possible pitch (relative percent) for male voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			SynthesisMinPitchFemale = config.Bind<float>("4. Synthesis", "Min Pitch Female", 0.75f, new ConfigDescription("Lowest possible pitch (relative percent) for female voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			SynthesisMaxPitchFemale = config.Bind<float>("4. Synthesis", "Max Pitch Female", 1.25f, new ConfigDescription("Highest possible pitch (relative percent) for female voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			SynthesisMinPitchNonBinary = config.Bind<float>("4. Synthesis", "Min Pitch Non-Binary", 0.75f, new ConfigDescription("Lowest possible pitch (relative percent) for non-binary voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			SynthesisMaxPitchNonBinary = config.Bind<float>("4. Synthesis", "Max Pitch Non-Binary", 1.25f, new ConfigDescription("Highest possible pitch (relative percent) for non-binary voices.", (AcceptableValueBase)null, Array.Empty<object>()));
			Utilities.EnforceMinMax(ref SynthesisMinSpeed, ref SynthesisMaxSpeed);
			Utilities.EnforceMinMax(ref SynthesisMinPitchMale, ref SynthesisMaxPitchMale);
			Utilities.EnforceMinMax(ref SynthesisMinPitchFemale, ref SynthesisMaxPitchFemale);
			Utilities.EnforceMinMax(ref SynthesisMinPitchNonBinary, ref SynthesisMaxPitchNonBinary);
		}

		public static void ResetSynthesis()
		{
			SynthesisVoiceFilter.Value = (SynthesisVoiceFilterType)((ConfigEntryBase)SynthesisVoiceFilter).DefaultValue;
			SynthesisVoiceFilterInput.Value = (string)((ConfigEntryBase)SynthesisVoiceFilterInput).DefaultValue;
			SynthesisMinSpeed.Value = (int)((ConfigEntryBase)SynthesisMinSpeed).DefaultValue;
			SynthesisMaxSpeed.Value = (int)((ConfigEntryBase)SynthesisMaxSpeed).DefaultValue;
			SynthesisMinPitchMale.Value = (float)((ConfigEntryBase)SynthesisMinPitchMale).DefaultValue;
			SynthesisMaxPitchMale.Value = (float)((ConfigEntryBase)SynthesisMaxPitchMale).DefaultValue;
			SynthesisMinPitchFemale.Value = (float)((ConfigEntryBase)SynthesisMinPitchFemale).DefaultValue;
			SynthesisMaxPitchFemale.Value = (float)((ConfigEntryBase)SynthesisMaxPitchFemale).DefaultValue;
			SynthesisMinPitchNonBinary.Value = (float)((ConfigEntryBase)SynthesisMinPitchNonBinary).DefaultValue;
			SynthesisMaxPitchNonBinary.Value = (float)((ConfigEntryBase)SynthesisMaxPitchNonBinary).DefaultValue;
		}
	}
}
namespace Babbler.Implementation.Common
{
	public static class FMODRegistry
	{
		private static System System;

		private static ChannelGroup ConversationalGroup;

		private static ChannelGroup OverheardGroup;

		private static ChannelGroup PhoneGroup;

		private static ChannelGroup ConversationalShoutGroup;

		private static ChannelGroup OverheardShoutGroup;

		private static ChannelGroup PhoneShoutGroup;

		public static void Initialize()
		{
			//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)
			System = RuntimeManager.CoreSystem;
			SetupConversationalGroup();
			SetupOverheardGroup();
			SetupPhoneGroup();
			Utilities.Log("FMODRegistry has initialized!", (LogLevel)32);
		}

		private static void SetupConversationalGroup()
		{
			//IL_0030: 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)
			TryCreateChannelGroup("BabblerConversationalGroup", out ConversationalGroup);
			TryCreateChannelGroup("BabblerConversationalShoutGroup", out ConversationalShoutGroup);
			((ChannelGroup)(ref ConversationalGroup)).setVolume(BabblerConfig.ConversationalVolume.Value);
			((ChannelGroup)(ref ConversationalShoutGroup)).setVolume(BabblerConfig.ConversationalVolume.Value * BabblerConfig.ConversationalShoutMultiplier.Value);
		}

		private static void SetupOverheardGroup()
		{
			//IL_0030: 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)
			TryCreateChannelGroup("BabblerOverheardGroup", out OverheardGroup);
			TryCreateChannelGroup("BabblerOverheardShoutGroup", out OverheardShoutGroup);
			((ChannelGroup)(ref OverheardGroup)).setVolume(BabblerConfig.OverheardVolume.Value);
			((ChannelGroup)(ref OverheardShoutGroup)).setVolume(BabblerConfig.OverheardVolume.Value * BabblerConfig.OverheardShoutMultiplier.Value);
		}

		private static void SetupPhoneGroup()
		{
			//IL_0030: 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_007b: 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_0094: 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_00b0: 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_00c9: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			TryCreateChannelGroup("BabblerPhoneGroup", out PhoneGroup);
			TryCreateChannelGroup("BabblerPhoneShoutGroup", out PhoneShoutGroup);
			((ChannelGroup)(ref PhoneGroup)).setVolume(BabblerConfig.PhoneVolume.Value);
			((ChannelGroup)(ref PhoneShoutGroup)).setVolume(BabblerConfig.PhoneVolume.Value * BabblerConfig.PhoneShoutMultiplier.Value);
			if (BabblerConfig.DistortPhoneSpeech.Value)
			{
				TryCreateDSP((DSP_TYPE)36, out var dsp);
				((DSP)(ref dsp)).setParameterInt(0, 6);
				((DSP)(ref dsp)).setParameterFloat(1, 300f);
				((DSP)(ref dsp)).setParameterInt(4, 9);
				((DSP)(ref dsp)).setParameterFloat(5, 1700f);
				((DSP)(ref dsp)).setParameterFloat(6, 1f);
				((DSP)(ref dsp)).setParameterInt(8, 3);
				((DSP)(ref dsp)).setParameterFloat(9, 3400f);
				((ChannelGroup)(ref PhoneGroup)).addDSP(CHANNELCONTROL_DSP_INDEX.HEAD, dsp);
				TryCreateDSP((DSP_TYPE)36, out var dsp2);
				((DSP)(ref dsp2)).setParameterInt(0, 6);
				((DSP)(ref dsp2)).setParameterFloat(1, 300f);
				((DSP)(ref dsp2)).setParameterInt(4, 9);
				((DSP)(ref dsp2)).setParameterFloat(5, 1700f);
				((DSP)(ref dsp2)).setParameterFloat(6, 1f);
				((DSP)(ref dsp2)).setParameterInt(8, 3);
				((DSP)(ref dsp2)).setParameterFloat(9, 3400f);
				((ChannelGroup)(ref PhoneShoutGroup)).addDSP(CHANNELCONTROL_DSP_INDEX.HEAD, dsp2);
			}
		}

		public static ChannelGroup GetChannelGroup(SpeechContext speechContext)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_003d: 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_0045: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			return (ChannelGroup)(speechContext switch
			{
				SpeechContext.ConversationalSpeech => ConversationalGroup, 
				SpeechContext.OverheardSpeech => OverheardGroup, 
				SpeechContext.PhoneSpeech => PhoneGroup, 
				SpeechContext.ConversationalShout => ConversationalShoutGroup, 
				SpeechContext.OverheardShout => OverheardShoutGroup, 
				SpeechContext.PhoneShout => PhoneShoutGroup, 
				_ => OverheardGroup, 
			});
		}

		private static bool TryCreateChannelGroup(string name, out ChannelGroup channelGroup)
		{
			//IL_000c: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			RESULT val = ((System)(ref System)).createChannelGroup("BabblerSpeechGroup", ref channelGroup);
			if ((int)val == 0)
			{
				return true;
			}
			Utilities.Log($"FMODRegistry failed to create channel group \"{name}\" at {Utilities.GetCallingMethodName()}. Error: {((object)(RESULT)(ref val)).ToString()}", (LogLevel)2);
			return false;
		}

		private static bool TryCreateDSP(DSP_TYPE dspType, out DSP dsp)
		{
			//IL_0006: 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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			RESULT val = ((System)(ref System)).createDSPByType(dspType, ref dsp);
			if ((int)val == 0)
			{
				return true;
			}
			Utilities.Log($"FMODRegistry failed to create DSP \"{((object)(DSP_TYPE)(ref dspType)).ToString()}\" at {Utilities.GetCallingMethodName()}. Error: {((object)(RESULT)(ref val)).ToString()}", (LogLevel)2);
			return false;
		}

		public static bool TryCreateSound(string name, MODE mode, out Sound sound)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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: Invalid comparison between Unknown and I4
			RESULT val = ((System)(ref System)).createSound(name, mode, ref sound);
			if ((int)val == 0)
			{
				return true;
			}
			Utilities.Log($"FMODRegistry failed to create sound \"{name}\" at {Utilities.GetCallingMethodName()}. Error: {((object)(RESULT)(ref val)).ToString()}", (LogLevel)2);
			return false;
		}

		public static bool TryCreateSound(byte[] data, MODE mode, ref CREATESOUNDEXINFO extraInfo, out Sound sound)
		{
			//IL_000c: 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_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_0017: Invalid comparison between Unknown and I4
			RESULT val = ((System)(ref System)).createSound(Il2CppStructArray<byte>.op_Implicit(data), mode, ref extraInfo, ref sound);
			if ((int)val == 0)
			{
				return true;
			}
			Utilities.Log("FMODRegistry failed to create sound \"MemoryStream\" at " + Utilities.GetCallingMethodName() + ". Error: " + ((object)(RESULT)(ref val)).ToString(), (LogLevel)2);
			return false;
		}

		public static bool TryPlaySound(Sound sound, ChannelGroup channelGroup, out Channel channel)
		{
			//IL_0006: 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_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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			RESULT val = ((System)(ref System)).playSound(sound, channelGroup, false, ref channel);
			if ((int)val == 0)
			{
				return true;
			}
			Utilities.Log("FMODRegistry failed to play sound at " + Utilities.GetCallingMethodName() + ". Error: " + ((object)(RESULT)(ref val)).ToString(), (LogLevel)2);
			return false;
		}

		public static bool TryUpdate()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			RESULT val = ((System)(ref System)).update();
			if ((int)val == 0)
			{
				return true;
			}
			Utilities.Log("FMODRegistry failed to update core system at " + Utilities.GetCallingMethodName() + ". Error: " + ((object)(RESULT)(ref val)).ToString(), (LogLevel)2);
			return false;
		}
	}
	public enum SpeechContext
	{
		ConversationalSpeech,
		OverheardSpeech,
		PhoneSpeech,
		ConversationalShout,
		OverheardShout,
		PhoneShout
	}
	public enum SpeechMode
	{
		Phonetic,
		Synthesis,
		Droning
	}
	public static class Utilities
	{
		public const bool DEBUG_BUILD = false;

		public static readonly StringBuilder GlobalStringBuilder = new StringBuilder();

		public static readonly Random GlobalRandom = new Random();

		public static void Log(string message, LogLevel level = 16)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if ((int)level == 32)
			{
				bool flag = false;
			}
			else
			{
				PluginController<BabblerPlugin, IEmptyBindings>.Log.Log(level, (object)message);
			}
		}

		public static string GetCallingMethodName()
		{
			StackTrace stackTrace = new StackTrace();
			StackFrame[] frames = stackTrace.GetFrames();
			if (frames == null || frames.Length <= 2)
			{
				return string.Empty;
			}
			MethodBase method = frames[2].GetMethod();
			if (method == null)
			{
				return string.Empty;
			}
			return method.Name;
		}

		public static float GetRandomFloat(float minimum, float maximum)
		{
			return minimum + GlobalRandom.NextSingle() * (maximum - minimum);
		}

		public static int GetDeterministicInteger(int hash, int prime, int min, int max)
		{
			int num = max - min;
			int num2 = Mathf.Abs(hash * prime);
			return num2 % num + min;
		}

		public static float GetDeterministicFloat(int hash, int prime, float min, float max)
		{
			float num = (float)(Mathf.Abs(hash * prime) % 100000) / 100000f;
			return num * (max - min) + min;
		}

		public static void EnforceMinMax(ref ConfigEntry<float> minimum, ref ConfigEntry<float> maximum)
		{
			float value = Mathf.Min(minimum.Value, maximum.Value);
			float value2 = Mathf.Max(minimum.Value, maximum.Value);
			minimum.Value = value;
			maximum.Value = value2;
		}

		public static void EnforceMinMax(ref ConfigEntry<int> minimum, ref ConfigEntry<int> maximum)
		{
			int value = Mathf.Min(minimum.Value, maximum.Value);
			int value2 = Mathf.Max(minimum.Value, maximum.Value);
			minimum.Value = value;
			maximum.Value = value2;
		}

		public static int GetDeterministicStringHash(string s)
		{
			int num = 352654597;
			int num2 = num;
			for (int i = 0; i < s.Length; i += 2)
			{
				num = ((num << 5) + num) ^ s[i];
				if (i == s.Length - 1)
				{
					break;
				}
				num2 = ((num2 << 5) + num2) ^ s[i + 1];
			}
			return num + num2 * 1566083941;
		}
	}
}
namespace Babbler.Implementation.Characteristics
{
	public enum VoiceCategory
	{
		Male,
		Female,
		NonBinary,
		Any
	}
	public struct VoiceCharacteristics
	{
		private const int PRIME_DIVERSITY = 31;

		private const int PRIME_PITCH = 47;

		private const int PRIME_RATE = 89;

		public VoiceCategory Category;

		public float Pitch;

		public float Rate;

		public int Hash;

		private VoiceCharacteristics(VoiceCategory category, float pitch, float rate, int hash)
		{
			Category = category;
			Pitch = pitch;
			Rate = rate;
			Hash = hash;
		}

		public static VoiceCharacteristics Create(Human human, bool maleVoiceAvailable, bool femaleVoiceAvailable, bool nonBinaryVoiceAvailable)
		{
			int deterministicStringHash = Utilities.GetDeterministicStringHash(human.seed);
			float diverseGenderScale = GetDiverseGenderScale(human, deterministicStringHash);
			float pitchScalar;
			float rateScalar;
			VoiceCategory profileInformation = GetProfileInformation(diverseGenderScale, deterministicStringHash, maleVoiceAvailable, femaleVoiceAvailable, nonBinaryVoiceAvailable, out pitchScalar, out rateScalar);
			return new VoiceCharacteristics(profileInformation, pitchScalar, rateScalar, deterministicStringHash);
		}

		private static float GetDiverseGenderScale(Human human, int hashCode)
		{
			float num = ((float)(hashCode % 31) / 31f - 0.5f) * 2f * BabblerConfig.GenderDiversity.Value;
			return Mathf.Clamp(human.genderScale + num, 0f, 1f);
		}

		private static VoiceCategory GetProfileInformation(float diverseGenderScale, int hashCode, bool hasMaleVoices, bool hasFemaleVoices, bool hasNonBinaryVoices, out float pitchScalar, out float rateScalar)
		{
			rateScalar = Utilities.GetDeterministicFloat(hashCode, 89, 0f, 1f);
			if (diverseGenderScale < BabblerConfig.FemaleThreshold.Value && hasFemaleVoices)
			{
				pitchScalar = Mathf.InverseLerp(0f, BabblerConfig.FemaleThreshold.Value, diverseGenderScale);
				return VoiceCategory.Female;
			}
			if (diverseGenderScale > BabblerConfig.MaleThreshold.Value && hasMaleVoices)
			{
				pitchScalar = Mathf.InverseLerp(BabblerConfig.MaleThreshold.Value, 1f, diverseGenderScale);
				return VoiceCategory.Male;
			}
			if (hasNonBinaryVoices)
			{
				pitchScalar = Mathf.InverseLerp(BabblerConfig.FemaleThreshold.Value, BabblerConfig.MaleThreshold.Value, diverseGenderScale);
				return VoiceCategory.NonBinary;
			}
			pitchScalar = Utilities.GetDeterministicFloat(hashCode, 47, 0f, 1f);
			return VoiceCategory.Any;
		}
	}
}
namespace Babbler.Hooks
{
	[HarmonyPatch(typeof(MainMenuController), "Start")]
	public class MainMenuControllerHook
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			PluginController<BabblerPlugin, IEmptyBindings>.Instance.InitializeDeferred();
		}
	}
	[HarmonyPatch(typeof(SpeechBubbleController), "Setup")]
	public class SpeechBubbleControllerHook
	{
		private static Human LastPhoneHuman;

		[HarmonyPostfix]
		public static void Postfix(SpeechBubbleController __instance, QueueElement newSpeech, SpeechController newSpeechController)
		{
			string text = ((__instance != null) ? __instance.actualString : null);
			if (!string.IsNullOrWhiteSpace(text) && !__instance.isPlayer && !CutSceneController.Instance.cutSceneActive && !IsEmoteSpeech(text) && !HasCharacterRepeated(text, 3))
			{
				BubbleHumanSearch(__instance, out var speakingHuman, out var telephoneHuman, out var anyHuman);
				if ((Object)(object)anyHuman == (Object)null)
				{
					Utilities.Log("Babbler unable to find a human to associate with message \"" + text + "\"!", (LogLevel)32);
					return;
				}
				SpeechContext speechContext = GetSpeechContext(text, speakingHuman, telephoneHuman, newSpeechController);
				SpeakerHostPool.Play(__instance.actualString, speechContext, anyHuman);
			}
		}

		private static SpeechContext GetSpeechContext(string speechInput, Human speakingHuman, Human telephoneHuman, SpeechController speechController)
		{
			bool flag = IsAllCaps(speechInput);
			if ((Object)(object)speakingHuman == (Object)null && (Object)(object)telephoneHuman != (Object)null)
			{
				return flag ? SpeechContext.PhoneShout : SpeechContext.PhoneSpeech;
			}
			if ((Object)(object)speechController.actor != (Object)(object)Player.Instance && InteractionController.Instance.dialogMode && InteractionController.Instance.talkingTo == speechController.interactable)
			{
				return flag ? SpeechContext.ConversationalShout : SpeechContext.ConversationalSpeech;
			}
			return (!flag) ? SpeechContext.OverheardSpeech : SpeechContext.OverheardShout;
		}

		private static bool IsEmoteSpeech(string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				return true;
			}
			return input[0] switch
			{
				'[' => input.EndsWith("]"), 
				'(' => input.EndsWith(")"), 
				'{' => input.EndsWith("}"), 
				'<' => input.EndsWith(">"), 
				_ => false, 
			};
		}

		private static bool HasCharacterRepeated(string input, int times)
		{
			if (string.IsNullOrEmpty(input) || times <= 0)
			{
				return false;
			}
			string text = input.ToLowerInvariant();
			int num = 1;
			for (int i = 1; i < text.Length; i++)
			{
				if (text[i] == text[i - 1])
				{
					num++;
					if (num >= times)
					{
						return true;
					}
				}
				else
				{
					num = 1;
				}
			}
			return false;
		}

		private static bool IsAllCaps(string input)
		{
			foreach (char c in input)
			{
				if (char.IsLetter(c) && !char.IsUpper(c))
				{
					return false;
				}
			}
			return true;
		}

		private static void BubbleHumanSearch(SpeechBubbleController bubbleController, out Human speakingHuman, out Human telephoneHuman, out Human anyHuman)
		{
			SpeechController val = ((bubbleController != null) ? bubbleController.speechController : null);
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				Interactable interactable = val.interactable;
				obj = ((interactable != null) ? interactable.controller : null);
			}
			InteractableController val2 = (InteractableController)obj;
			Actor val3 = ((val != null) ? val.actor : null);
			bool flag = ((val != null) ? val.phoneLine : null) != null || ((Object)(object)val2 != (Object)null && val2.isPhone);
			Human val4 = (Human)(object)((val3 is Human) ? val3 : null);
			object obj2;
			if (val3 == null)
			{
				obj2 = null;
			}
			else
			{
				NewAIController ai = val3.ai;
				obj2 = ((ai != null) ? ai.human : null);
			}
			Human val5 = (Human)obj2;
			speakingHuman = val4 ?? val5;
			telephoneHuman = GetOtherPhoneHuman();
			if (flag)
			{
				if ((Object)(object)telephoneHuman == (Object)null)
				{
					Player instance = Player.Instance;
					PhoneCall val6 = ((instance != null) ? instance.activeCall : null);
					if (val6 != null)
					{
						telephoneHuman = GetOperatorHuman();
						LastPhoneHuman = telephoneHuman;
					}
					else
					{
						telephoneHuman = LastPhoneHuman;
					}
				}
				else
				{
					LastPhoneHuman = telephoneHuman;
				}
			}
			anyHuman = speakingHuman ?? telephoneHuman;
		}

		private static Human GetOtherPhoneHuman()
		{
			Player instance = Player.Instance;
			PhoneCall val = ((instance != null) ? instance.activeCall : null);
			if (val == null)
			{
				return null;
			}
			SideJob val2 = default(SideJob);
			if (val.source.job > -1 && SideJobController.Instance.allJobsDictionary.TryGetValue(val.source.job, ref val2))
			{
				return val2.poster;
			}
			Human val3 = default(Human);
			if (CityData.Instance.GetHuman(val.caller, ref val3, true) && (Object)(object)val3 != (Object)null && !((Actor)val3).isPlayer)
			{
				return val3;
			}
			Human val4 = default(Human);
			if (CityData.Instance.GetHuman(val.receiver, ref val4, true) && (Object)(object)val4 != (Object)null && !((Actor)val4).isPlayer)
			{
				return val4;
			}
			return null;
		}

		private static Human GetOperatorHuman()
		{
			int deterministicStringHash = Utilities.GetDeterministicStringHash(CityData.Instance.seed);
			int num = Mathf.RoundToInt(SessionData.Instance.gameTime / 8f);
			int num2 = deterministicStringHash + num;
			int num3 = num2 * (num2 + 1) / 2 + num;
			int num4 = Mathf.Abs(num3) % CityData.Instance.citizenDirectory.Count;
			return (Human)(object)CityData.Instance.citizenDirectory._items[num4];
		}
	}
}