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.Versioning;
using FeeningNPCs;
using FishNet.Connection;
using FishNet.Object;
using MelonLoader;
using MelonLoader.Utils;
using ScheduleOne.DevUtilities;
using ScheduleOne.Economy;
using ScheduleOne.NPCs.Behaviour;
using ScheduleOne.Persistence;
using ScheduleOne.PlayerScripts;
using ScheduleOne.VoiceOver;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::FeeningNPCs.FeeningNPCs), "FeeningNPCs", "1.2.2", "XOWithSauce", null)]
[assembly: MelonColor]
[assembly: MelonOptionalDependencies(new string[] { "FishNet.Runtime" })]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("FeeningNPCs")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FeeningNPCs")]
[assembly: AssemblyTitle("FeeningNPCs")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace FeeningNPCs;

public static class BuildInfo
{
	public const string Name = "FeeningNPCs";

	public const string Description = "Your customers need more... and more.... AND MORE!!! HELP ME BRO YOU GOT SOME MORE??!!";

	public const string Author = "XOWithSauce";

	public const string Company = null;

	public const string Version = "1.2.2";

	public const string DownloadLink = null;
}
[Serializable]
public class ModConfig
{
	public int maxFeensStack = 3;

	public int feeningTreshold = 50;

	public int feensClearThreshold = 1440;

	public int feeningRadius = 30;

	public bool randomEffects = true;

	public bool increaseEconomy = true;
}
public static class ConfigLoader
{
	private static string path = Path.Combine(MelonEnvironment.ModsDirectory, "FeeningNPCs", "config.json");

	public static ModConfig Load()
	{
		ModConfig modConfig;
		if (File.Exists(path))
		{
			try
			{
				string text = File.ReadAllText(path);
				modConfig = JsonUtility.FromJson<ModConfig>(text);
			}
			catch (Exception ex)
			{
				modConfig = new ModConfig();
				MelonLogger.Warning("Failed to read FeeningNPCs config: " + ex);
			}
		}
		else
		{
			modConfig = new ModConfig();
			Save(modConfig);
		}
		return modConfig;
	}

	public static void Save(ModConfig config)
	{
		try
		{
			string contents = JsonUtility.ToJson((object)config, true);
			Directory.CreateDirectory(Path.GetDirectoryName(path));
			File.WriteAllText(path, contents);
		}
		catch (Exception ex)
		{
			MelonLogger.Warning("Failed to save FeeningNPCs config: " + ex);
		}
	}
}
public class FeeningNPCs : MelonMod
{
	[CompilerGenerated]
	private sealed class <ChangeBehv>d__13 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public FeeningNPCs <>4__this;

		private Player[] <players>5__1;

		private Player <randomPlayer>5__2;

		private List<Customer> <nearbyCustomers>5__3;

		private Customer[] <>s__4;

		private int <>s__5;

		private Customer <c>5__6;

		private float <dist>5__7;

		private string <currentBehavior>5__8;

		private Exception <ex>5__9;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<players>5__1 = null;
			<randomPlayer>5__2 = null;
			<nearbyCustomers>5__3 = null;
			<>s__4 = null;
			<c>5__6 = null;
			<currentBehavior>5__8 = null;
			<ex>5__9 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				goto IL_0050;
			case 2:
				{
					<>1__state = -1;
					if (!registered)
					{
						return false;
					}
					try
					{
						<players>5__1 = Object.FindObjectsOfType<Player>(true);
						if (<players>5__1.Length != 0)
						{
							<randomPlayer>5__2 = <players>5__1[Random.Range(0, <players>5__1.Length)];
							<nearbyCustomers>5__3 = new List<Customer>();
							<>s__4 = <>4__this.cmers;
							for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
							{
								<c>5__6 = <>s__4[<>s__5];
								<dist>5__7 = Vector3.Distance(((Component)<c>5__6.NPC).transform.position, ((Component)<randomPlayer>5__2).transform.position);
								<currentBehavior>5__8 = "";
								if ((Object)(object)<c>5__6.NPC.behaviour.activeBehaviour != (Object)null)
								{
									<currentBehavior>5__8 = ((object)<c>5__6.NPC.behaviour.activeBehaviour).ToString();
								}
								if (<dist>5__7 < (float)<>4__this.currentConfig.feeningRadius && !<currentBehavior>5__8.Contains("Request product from player") && !<>4__this.feens.Contains(<c>5__6) && <c>5__6.NPC.RelationData.Unlocked && !<c>5__6.NPC.Health.IsKnockedOut && !<c>5__6.NPC.Health.IsDead)
								{
									<nearbyCustomers>5__3.Add(<c>5__6);
									if (<nearbyCustomers>5__3.Count >= <>4__this.currentConfig.maxFeensStack)
									{
										break;
									}
								}
								<currentBehavior>5__8 = null;
								<c>5__6 = null;
							}
							<>s__4 = null;
							if (<nearbyCustomers>5__3.Count > 0)
							{
								coros.Add(MelonCoroutines.Start(<>4__this.SetFeening(<nearbyCustomers>5__3, <randomPlayer>5__2)));
							}
							<players>5__1 = null;
							<randomPlayer>5__2 = null;
							<nearbyCustomers>5__3 = null;
						}
					}
					catch (Exception ex)
					{
						<ex>5__9 = ex;
						MelonLogger.Error("Feening NPCs caught an error: " + <ex>5__9);
					}
					goto IL_0050;
				}
				IL_0050:
				<>2__current = (object)new WaitForSeconds((float)Random.Range(<>4__this.currentConfig.feeningTreshold, <>4__this.currentConfig.feeningTreshold * 2));
				<>1__state = 2;
				return true;
			}
		}

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

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

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

		private object <>2__current;

		public Customer c;

		private int <roll>5__1;

		private int <>s__2;

		private int <baseMax>5__3;

		private int <current>5__4;

		private int <baseMax>5__5;

		private int <current>5__6;

		private float <baseMax>5__7;

		private float <baseMax>5__8;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				<roll>5__1 = Random.Range(0, 4);
				int num = <roll>5__1;
				<>s__2 = num;
				switch (<>s__2)
				{
				case 0:
					<baseMax>5__3 = 12;
					<current>5__4 = c.CustomerData.MinOrdersPerWeek;
					if (c.CustomerData.MinOrdersPerWeek < <baseMax>5__3)
					{
						c.CustomerData.MinOrdersPerWeek = Mathf.Max(<baseMax>5__3, <current>5__4 + 1);
					}
					break;
				case 1:
					<baseMax>5__5 = 24;
					<current>5__6 = c.CustomerData.MaxOrdersPerWeek;
					if (c.CustomerData.MaxOrdersPerWeek < <baseMax>5__5)
					{
						c.CustomerData.MaxOrdersPerWeek = Mathf.Max(<baseMax>5__5, <current>5__6 + 1);
					}
					break;
				case 2:
					<baseMax>5__7 = 30000f;
					if (!(c.CustomerData.MaxWeeklySpend >= <baseMax>5__7))
					{
						c.CustomerData.MaxWeeklySpend = Mathf.Max(<baseMax>5__7, c.CustomerData.MaxWeeklySpend * 1.01f);
					}
					break;
				case 3:
					<baseMax>5__8 = 10000f;
					if (!(c.CustomerData.MinWeeklySpend >= <baseMax>5__8))
					{
						c.CustomerData.MinWeeklySpend = Mathf.Max(<baseMax>5__8, c.CustomerData.MinWeeklySpend * 1.01f);
					}
					break;
				}
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			case 1:
				<>1__state = -1;
				return false;
			}
		}

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

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

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

		private object <>2__current;

		public FeeningNPCs <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				goto IL_004d;
			case 2:
				{
					<>1__state = -1;
					if (!registered)
					{
						return false;
					}
					<>4__this.feens.Clear();
					goto IL_004d;
				}
				IL_004d:
				<>2__current = (object)new WaitForSeconds((float)<>4__this.currentConfig.feensClearThreshold);
				<>1__state = 2;
				return true;
			}
		}

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

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

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

		private object <>2__current;

		public Customer c;

		private float <num1>5__1;

		private int <maxIter>5__2;

		private int <i>5__3;

		private Player <closest>5__4;

		private float <dist>5__5;

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

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

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

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

		private bool MoveNext()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (!registered || c.NPC.RelationData.RelationDelta > 3.8f)
				{
					return false;
				}
				Player.GetClosestPlayer(((Component)c).transform.position, ref <num1>5__1, (List<Player>)null);
				<maxIter>5__2 = 20;
				<i>5__3 = 0;
				goto IL_0124;
			case 2:
				<>1__state = -1;
				if (!registered)
				{
					return false;
				}
				Player.GetClosestPlayer(((Component)c).transform.position, ref <num1>5__1, (List<Player>)null);
				<i>5__3++;
				goto IL_0124;
			case 3:
				{
					<>1__state = -1;
					if (!registered)
					{
						return false;
					}
					<closest>5__4 = Player.GetClosestPlayer(((Component)c).transform.position, ref <dist>5__5, (List<Player>)null);
					if (<dist>5__5 < 6f && (Object)(object)<closest>5__4 != (Object)null && (Object)(object)((NetworkBehaviour)<closest>5__4).NetworkObject != (Object)null)
					{
						c.NPC.behaviour.CombatBehaviour.SetTarget((NetworkConnection)null, ((NetworkBehaviour)<closest>5__4).NetworkObject);
						((Behaviour)c.NPC.behaviour.CombatBehaviour).SendEnable();
					}
					return false;
				}
				IL_0124:
				if (<num1>5__1 > 6f && <i>5__3 != <maxIter>5__2)
				{
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 3;
				return true;
			}
		}

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

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

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

		private object <>2__current;

		public Customer c;

		private float <num3>5__1;

		private int <maxIter2>5__2;

		private int <j>5__3;

		private float <dist>5__4;

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

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

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

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

		private bool MoveNext()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if (!registered)
				{
					return false;
				}
				Player.GetClosestPlayer(((Component)c).transform.position, ref <num3>5__1, (List<Player>)null);
				<maxIter2>5__2 = 20;
				<j>5__3 = 0;
				goto IL_0106;
			case 2:
				<>1__state = -1;
				if (!registered)
				{
					return false;
				}
				Player.GetClosestPlayer(((Component)c).transform.position, ref <num3>5__1, (List<Player>)null);
				<j>5__3++;
				goto IL_0106;
			case 3:
				{
					<>1__state = -1;
					if (!registered)
					{
						return false;
					}
					Player.GetClosestPlayer(((Component)c).transform.position, ref <dist>5__4, (List<Player>)null);
					if (<dist>5__4 < 6f)
					{
						c.NPC.Movement.ActivateRagdoll(((Component)c.NPC).transform.position, Vector3.forward, 6f);
					}
					return false;
				}
				IL_0106:
				if (<num3>5__1 > 6f && <j>5__3 != <maxIter2>5__2)
				{
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 3;
				return true;
			}
		}

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

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

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

		private object <>2__current;

		public Customer c;

		private int <roll>5__1;

		private int <>s__2;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				<roll>5__1 = Random.Range(0, 14);
				int num = <roll>5__1;
				<>s__2 = num;
				switch (<>s__2)
				{
				case 0:
					c.NPC.OverrideAggression(1f);
					break;
				case 1:
					c.CustomerData.CallPoliceChance = 1f;
					break;
				case 2:
					c.CustomerData.CallPoliceChance = 0.5f;
					break;
				case 3:
					c.NPC.PlayVO((EVOLineType)8);
					c.NPC.Avatar.EmotionManager.AddEmotionOverride("Annoyed", "product_request_fail", 30f, 1);
					break;
				case 4:
					c.NPC.OverrideAggression(0.5f);
					break;
				case 5:
					c.NPC.Avatar.Effects.SetSicklySkinColor(true);
					break;
				case 6:
					coros.Add(MelonCoroutines.Start(NPCAttackEffect(c)));
					break;
				case 7:
					coros.Add(MelonCoroutines.Start(RagdollEffect(c)));
					break;
				}
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			case 1:
				<>1__state = -1;
				return false;
			}
		}

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

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

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

		private object <>2__current;

		public List<Customer> cs;

		public Player randomPlayer;

		public FeeningNPCs <>4__this;

		private List<Customer>.Enumerator <>s__1;

		private Customer <c>5__2;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || (uint)(num - 1) <= 1u)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<>s__1 = default(List<Customer>.Enumerator);
			<c>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			bool result;
			try
			{
				switch (<>1__state)
				{
				default:
					result = false;
					break;
				case 0:
					<>1__state = -1;
					<>s__1 = cs.GetEnumerator();
					<>1__state = -3;
					goto IL_01eb;
				case 1:
					<>1__state = -3;
					if (!registered)
					{
						result = false;
						<>m__Finally1();
						break;
					}
					if (<c>5__2.NPC.isInBuilding)
					{
						<c>5__2.NPC.ExitBuilding("");
					}
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					result = true;
					break;
				case 2:
					<>1__state = -3;
					if (<c>5__2.NPC.Movement.CanGetTo(((Component)randomPlayer).transform.position, (float)<>4__this.currentConfig.feeningRadius))
					{
						if (Random.Range(0f, 1f) > 0.5f)
						{
							if (<>4__this.currentConfig.randomEffects)
							{
								coros.Add(MelonCoroutines.Start(RandomFeenEffect(<c>5__2)));
							}
							else if (<>4__this.currentConfig.increaseEconomy)
							{
								coros.Add(MelonCoroutines.Start(ChangeCustomerEconomy(<c>5__2)));
							}
						}
						<c>5__2.RequestProduct(randomPlayer);
						<>4__this.feens.Add(<c>5__2);
						<c>5__2 = null;
					}
					goto IL_01eb;
				case 3:
					{
						<>1__state = -1;
						result = false;
						break;
					}
					IL_01eb:
					if (<>s__1.MoveNext())
					{
						<c>5__2 = <>s__1.Current;
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 1;
						result = true;
					}
					else
					{
						<>m__Finally1();
						<>s__1 = default(List<Customer>.Enumerator);
						<>2__current = null;
						<>1__state = 3;
						result = true;
					}
					break;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
			return result;
		}

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

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__1).Dispose();
		}

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

	private Customer[] cmers;

	public static List<object> coros = new List<object>();

	private HashSet<Customer> feens = new HashSet<Customer>();

	public static bool registered = false;

	private ModConfig currentConfig;

	public override void OnApplicationStart()
	{
		MelonLogger.Msg("Your customers need more... and more.... AND MORE!!! HELP ME BRO YOU GOT SOME MORE??!!");
	}

	public override void OnSceneWasInitialized(int buildIndex, string sceneName)
	{
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Expected O, but got Unknown
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Expected O, but got Unknown
		if (buildIndex == 1)
		{
			if ((Object)(object)Singleton<LoadManager>.Instance != (Object)null && !registered)
			{
				Singleton<LoadManager>.Instance.onLoadComplete.AddListener(new UnityAction(OnLoadCompleteCb));
			}
			return;
		}
		if ((Object)(object)Singleton<LoadManager>.Instance != (Object)null && registered)
		{
			Singleton<LoadManager>.Instance.onLoadComplete.RemoveListener(new UnityAction(OnLoadCompleteCb));
		}
		registered = false;
		foreach (object coro in coros)
		{
			MelonCoroutines.Stop(coro);
		}
		coros.Clear();
		feens.Clear();
	}

	private void OnLoadCompleteCb()
	{
		if (!registered)
		{
			currentConfig = ConfigLoader.Load();
			cmers = Object.FindObjectsOfType<Customer>(true);
			coros.Add(MelonCoroutines.Start(ChangeBehv()));
			coros.Add(MelonCoroutines.Start(ClearFeens()));
			registered = true;
		}
	}

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

	[IteratorStateMachine(typeof(<ChangeCustomerEconomy>d__9))]
	public static IEnumerator ChangeCustomerEconomy(Customer c)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ChangeCustomerEconomy>d__9(0)
		{
			c = c
		};
	}

	[IteratorStateMachine(typeof(<RandomFeenEffect>d__10))]
	public static IEnumerator RandomFeenEffect(Customer c)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RandomFeenEffect>d__10(0)
		{
			c = c
		};
	}

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

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

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

	[IteratorStateMachine(typeof(<SetFeening>d__14))]
	private IEnumerator SetFeening(List<Customer> cs, Player randomPlayer)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SetFeening>d__14(0)
		{
			<>4__this = this,
			cs = cs,
			randomPlayer = randomPlayer
		};
	}
}