Decompiled source of Property Upgrades v1.0.5

Mods/PropertyUpgrades_Mono.dll

Decompiled 2 months ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using FluffyUnderware.DevTools.Extensions;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using PropertyUpgrades;
using PropertyUpgrades.BuilderNPC;
using S1API.Entities;
using S1API.Messaging;
using ScheduleOne.Delivery;
using ScheduleOne.DevUtilities;
using ScheduleOne.EntityFramework;
using ScheduleOne.Money;
using ScheduleOne.NPCs;
using ScheduleOne.ObjectScripts;
using ScheduleOne.Persistence;
using ScheduleOne.PlayerScripts;
using ScheduleOne.Property;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Core), "PropertyUpgrades", "1.0.4", "weedeej", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("PropertyUpgrades")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.4")]
[assembly: AssemblyInformationalVersion("1.0.0+e007300a0b716f453436826d262fb203eaf6eac9")]
[assembly: AssemblyProduct("PropertyUpgrades")]
[assembly: AssemblyTitle("PropertyUpgrades")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.4.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;
		}
	}
}
public class GroundDetector : MonoBehaviour
{
	[Header("Detection Settings")]
	[Tooltip("How far down from the origin point to check.")]
	[SerializeField]
	private float detectionDistance = 1.1f;

	[Tooltip("Which physics layers should be considered 'ground' or 'interactable below'?")]
	[SerializeField]
	private LayerMask groundLayerMask;

	[Tooltip("Optional offset from the player's transform position to start the raycast.")]
	[SerializeField]
	private Vector3 originOffset = Vector3.zero;

	[Tooltip("Should the detection ignore trigger colliders? Usually true for ground checks.")]
	[SerializeField]
	private QueryTriggerInteraction triggerInteraction = (QueryTriggerInteraction)1;

	private GameObject _objectCurrentlyUnderneath;

	public GameObject ObjectCurrentlyUnderneath => _objectCurrentlyUnderneath;

	private void Start()
	{
		//IL_000b: 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)
		groundLayerMask = LayerMask.op_Implicit(LayerMask.NameToLayer("Invisible"));
	}

	private void Update()
	{
		_objectCurrentlyUnderneath = FindObjectUnderneathRaycast();
	}

	public GameObject FindObjectUnderneathRaycast()
	{
		//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		RaycastHit val = default(RaycastHit);
		if (Physics.Raycast(((Component)this).transform.position + originOffset, Vector3.down, ref val, detectionDistance, LayerMask.op_Implicit(groundLayerMask), triggerInteraction))
		{
			if ((Object)(object)((Component)((RaycastHit)(ref val)).collider).transform == (Object)(object)((Component)this).transform && (Object)(object)((Component)((RaycastHit)(ref val)).collider).gameObject == (Object)(object)((Component)this).gameObject)
			{
				return null;
			}
			return ((Component)((RaycastHit)(ref val)).collider).gameObject;
		}
		return null;
	}

	public static GameObject GetObjectUnderneath(Transform originTransform, float distance, LayerMask layers, Vector3 offset = default(Vector3), QueryTriggerInteraction queryTriggers = 1)
	{
		//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_0007: 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_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		RaycastHit val = default(RaycastHit);
		if (Physics.Raycast(originTransform.position + offset, Vector3.down, ref val, distance, LayerMask.op_Implicit(layers), queryTriggers))
		{
			if ((Object)(object)((Component)((RaycastHit)(ref val)).collider).transform == (Object)(object)originTransform)
			{
				return null;
			}
			return ((Component)((RaycastHit)(ref val)).collider).gameObject;
		}
		return null;
	}
}
namespace PropertyUpgrades
{
	[HarmonyPatch(typeof(Property), "Awake")]
	public static class PropertyAwakePatch
	{
		public static void Postfix(Property __instance)
		{
			if (!(__instance.PropertyName == "RV"))
			{
				ModSaveManager modSaveManager = new ModSaveManager().Load();
				if (modSaveManager.saveData.ContainsKey(__instance.PropertyName))
				{
					PropertyData propertyData = modSaveManager.saveData[__instance.PropertyName];
					ModUtilities.ApplyPropertyData(__instance, propertyData);
				}
			}
		}
	}
	[HarmonyPatch(typeof(MixingStation), "Start")]
	public static class MixtimePatch
	{
		public static void Postfix(MixingStation __instance)
		{
			string propertyName = ((BuildableItem)__instance).ParentProperty.PropertyName;
			if (!(propertyName == "RV"))
			{
				ModSaveManager modSaveManager = new ModSaveManager().LoadTemp();
				int mixTimePerItemReduction = modSaveManager.saveData[propertyName].MixTimePerItemReduction;
				if (modSaveManager.saveData.ContainsKey(propertyName) && mixTimePerItemReduction > 0)
				{
					ModUtilities.ApplyMixingUpgrade(__instance, mixTimePerItemReduction);
				}
			}
		}
	}
	public class Core : MelonMod
	{
		[CompilerGenerated]
		private sealed class <DelayedStart>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					ModSaveManager modSaveManager = new ModSaveManager();
					Singleton<SaveManager>.Instance.onSaveStart.AddListener(new UnityAction(modSaveManager.Save));
					Builder.InitBuilder(modSaveManager);
					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();
			}
		}

		public override void OnInitializeMelon()
		{
			MelonPreferences.Load();
			MelonPreferences.CreateCategory("PropertyUpgrades", "Property Upgrades");
			MelonPreferences.CreateEntry<int>("PropertyUpgrades", "MaxEmployeeCount", 15, "Max Employee Count", "Maximum employee count a property can have", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<int>("PropertyUpgrades", "MaxLoadingDocks", 5, "Max Loading Docks", "Maximum loading docks a player can buy for a property", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<double>("PropertyUpgrades", "MaxAdditionalGrowthRate", 5.0, "Max Add Growth Rate", "Maximum additional growth rate a player can get", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<int>("PropertyUpgrades", "MaxMixTimeReduction", 4, "Max Mix Time Reduction", "Maximum time(seconds) PER ITEM reduction a mixer can have (mk1 & 2)", false, false, (ValueValidator)null);
			MelonPreferences.CreateCategory("PropertyUpgrades_Translation", "Property Upgrades Translation").SetFilePath(Path.Combine(MelonEnvironment.UserDataDirectory, "PropertyUpgrades_Translation.cfg"));
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "BuilderNPC_Name", "Builder", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "ResetMessage", "Hello! I'm the Builder. I can help you with property upgrades.", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "WhatElse", "What else do you want to do?", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "EmployeeUpgrade", "Employee upgrade at ({{PropertyName}}) completed", "EmployeeUpgrade", "Do not remove '{{PropertyName}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "PotUpgrade", "Plant Growth upgrade at ({{PropertyName}}) completed", "PotUpgrade", "Do not remove '{{PropertyName}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "MixerUpgrade", "Mixing time upgrade at ({{PropertyName}}) completed", "MixerUpgrade", "Do not remove '{PropertyName}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "LoadingDockUpgrade", "Loading Dock upgrade at ({{PropertyName}}) completed", "LoadingDockUpgrade", "Do not remove '{{PropertyName}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "NoBankBalance", "You don't have enough money in the bank for this upgrade.", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "GoBack", "Go back", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "AddEmployee", "+1 Employee (${{Price}})", "AddEmployee", "Do not remove '{{Price}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "AddPlantGrowth", "+0.25 Plant Growth (${{Price}})", "AddPlantGrowth", "Do not remove '{{Price}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "AddLoadingDock", "+1 Loading Dock (${{Price}})", "AddLoadingDock", "Do not remove '{{Price}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "ReduceMixTime", "-1s MixTime Per Item (${{Price}})", "ReduceMixTime", "Do not remove '{{Price}}'", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "NoUpgrades", "{{PropertyName}} no longer have available upgrades.", "Do not remove '{{PropertyName}}'", (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "PropertyStats", "{{PropertyName}} Stats:\nEmployee Capacity: {{employeeCap}}\nAddtional Growth Rate: {{ExtraGrowSpeedMultiplier}}\nMix time reduction: -{{MixTimePerItemReduction}}s\nExtra Docks: {{ExtraLoadingDocksCount}}\n\nWhat would you like to do?", "PropertyStats", "Do not remove/change strings enclosed in {{}}", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "StandOnTopOfDock", "You need to stand on top of the of the extra loading dock.", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "DockRemoved", "Loading dock removed.", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "InPlace", "I'm in place", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "WhichProperty", "I can help you with that. Which property would you like to upgrade?", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "IdkWhichProperty", "I don't know which property you want to upgrade.", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "MoveToWhere", "Move to the location you want {{entity}} placed.", "MoveToWhere", "Do not remove/change strings enclosed in {{}}", false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "UpgradeProperty", "Upgrade Property", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.CreateEntry<string>("PropertyUpgrades_Translation", "RemoveDock", "Remove Loading Dock", (string)null, (string)null, false, false, (ValueValidator)null);
			MelonPreferences.Save();
			ModSaveManager.ClearTemp();
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			((MelonMod)this).OnSceneWasLoaded(buildIndex, sceneName);
			if (!(sceneName != "Main"))
			{
				MelonCoroutines.Start(DelayedStart());
			}
		}

		[IteratorStateMachine(typeof(<DelayedStart>d__2))]
		private IEnumerator DelayedStart()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedStart>d__2(0);
		}
	}
	public class ExtraLoadingDock
	{
		[JsonProperty("Position")]
		[JsonConverter(typeof(Vector3Converter))]
		public Vector3 Position { get; set; }

		[JsonProperty("Rotation")]
		[JsonConverter(typeof(Vector3Converter))]
		public Vector3 Rotation { get; set; }
	}
	public class PropertyData
	{
		[JsonProperty("EmployeeCapacity")]
		public int EmployeeCapacity { get; set; }

		[JsonProperty("MixTimePerItemReduction")]
		public int MixTimePerItemReduction { get; set; }

		[JsonProperty("ExtraGrowSpeedMultiplier")]
		public float ExtraGrowSpeedMultiplier { get; set; }

		[JsonProperty("ExtraLoadingDocks")]
		public ExtraLoadingDock[] ExtraLoadingDocks { get; set; }
	}
	public class ModSaveManager
	{
		private string saveFilePath;

		private string tempSaveFilePath;

		public Dictionary<string, PropertyData> saveData = new Dictionary<string, PropertyData>();

		public ModSaveManager()
		{
			string loadedGameFolderPath = Singleton<LoadManager>.Instance.LoadedGameFolderPath;
			int startIndex = loadedGameFolderPath.IndexOf("Saves\\") + 5;
			string[] array = loadedGameFolderPath.Substring(startIndex).Split(new char[1] { '\\' }, StringSplitOptions.RemoveEmptyEntries);
			saveFilePath = Path.Combine(MelonEnvironment.UserDataDirectory, "Property Upgrades", array[0] + "_" + array[1] + ".json");
			tempSaveFilePath = Path.Combine(MelonEnvironment.UserDataDirectory, "Property Upgrades", "_temp_" + array[0] + "_" + array[1] + ".json");
			if (!Directory.Exists(Path.Combine(MelonEnvironment.UserDataDirectory, "Property Upgrades")))
			{
				Directory.CreateDirectory(Path.Combine(MelonEnvironment.UserDataDirectory, "Property Upgrades"));
			}
		}

		public void Save()
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)saveData, (Formatting)1);
				File.WriteAllText(saveFilePath, contents);
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Failed to save data: " + ex.Message);
			}
		}

		public void SaveTemp()
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)saveData, (Formatting)1);
				File.WriteAllText(tempSaveFilePath, contents);
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Failed to save data: " + ex.Message);
			}
		}

		public ModSaveManager Load()
		{
			if (!File.Exists(saveFilePath))
			{
				return this;
			}
			string text = File.ReadAllText(saveFilePath);
			saveData = JsonConvert.DeserializeObject<Dictionary<string, PropertyData>>(text);
			return this;
		}

		public ModSaveManager LoadTemp()
		{
			if (!File.Exists(tempSaveFilePath) && !File.Exists(saveFilePath))
			{
				return this;
			}
			string text = File.ReadAllText(File.Exists(tempSaveFilePath) ? tempSaveFilePath : saveFilePath);
			saveData = JsonConvert.DeserializeObject<Dictionary<string, PropertyData>>(text);
			return this;
		}

		public static void ClearTemp()
		{
			if (!Directory.Exists(Path.Combine(MelonEnvironment.UserDataDirectory, "Property Upgrades")))
			{
				Directory.CreateDirectory(Path.Combine(MelonEnvironment.UserDataDirectory, "Property Upgrades"));
			}
			string[] files = Directory.GetFiles(Path.Combine(MelonEnvironment.UserDataDirectory, "Property Upgrades"), "_temp_*.json");
			foreach (string path in files)
			{
				try
				{
					File.Delete(path);
				}
				catch (Exception ex)
				{
					MelonLogger.Error("Failed to delete temp file: " + ex.Message);
				}
			}
		}
	}
	public class Limits
	{
		public int MaxEmployeeCount;

		public int MaxLoadingDocks;

		public float MaxAdditionalGrowthRate;

		public int MaxMixTimeReduction;

		public Limits()
		{
			try
			{
				MaxEmployeeCount = MelonPreferences.GetEntryValue<int>("PropertyUpgrades", "MaxEmployeeCount");
				MaxLoadingDocks = MelonPreferences.GetEntryValue<int>("PropertyUpgrades", "MaxLoadingDocks");
				MaxAdditionalGrowthRate = Convert.ToSingle(MelonPreferences.GetEntryValue<double>("PropertyUpgrades", "MaxAdditionalGrowthRate"));
				MaxMixTimeReduction = MelonPreferences.GetEntryValue<int>("PropertyUpgrades", "MaxMixTimeReduction");
			}
			catch (Exception arg)
			{
				MelonLogger.Error($"Failed to load limits: {arg}");
				MaxEmployeeCount = 15;
				MaxLoadingDocks = 5;
				MaxAdditionalGrowthRate = 5f;
				MaxMixTimeReduction = 4;
			}
		}
	}
	public class ModUtilities
	{
		public static float PlayerYDistanceToSubtractForDecal = 0.9762f;

		public static T[] GetBuildableItemScriptsFromProperty<T>(Property property) where T : class
		{
			return (from x in property.BuildableItems
				where x is T
				select x as T).ToArray();
		}

		public static Texture2D LoadCustomImage(string fileName, int width = 2, int height = 2)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_002d: Expected O, but got Unknown
			string path = Path.Combine(MelonEnvironment.UserDataDirectory, fileName);
			if (!File.Exists(path))
			{
				return null;
			}
			byte[] array = File.ReadAllBytes(path);
			Texture2D val = new Texture2D(width, height);
			ImageConversion.LoadImage(val, array);
			return val;
		}

		public static void AddExtraDock(Property targetProperty, Vector3 playerPos, Quaternion playerRot, bool addToSaveManager = false, ModSaveManager saveManager = null)
		{
			//IL_0002: 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_0014: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = default(Vector3);
			((Vector3)(ref position))..ctor(playerPos.x, playerPos.y - PlayerYDistanceToSubtractForDecal, playerPos.z);
			ExtraLoadingDock extraLoadingDock = new ExtraLoadingDock
			{
				Position = position,
				Rotation = ((Quaternion)(ref playerRot)).eulerAngles
			};
			AddExtraDock(targetProperty, extraLoadingDock);
			if (addToSaveManager && saveManager != null)
			{
				PropertyData propertyData = saveManager.saveData[targetProperty.PropertyName];
				propertyData.ExtraLoadingDocks = propertyData.ExtraLoadingDocks.Append(extraLoadingDock).ToArray();
			}
		}

		public static void AddExtraDock(Property targetProperty, ExtraLoadingDock loadingDock)
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (targetProperty.LoadingDockCount < 1)
			{
				MelonLogger.Msg((object)1);
				Property val = Property.Properties.Find((Property property) => property.PropertyName == "Barn");
				MelonLogger.Msg((object)2);
				if ((Object)(object)val == (Object)null)
				{
					MelonLogger.Msg((object)3);
					MelonLogger.Error("Failed to find base property for loading dock: Barn");
					return;
				}
				MelonLogger.Msg((object)4);
				GameObject gameObject = ((Component)val.LoadingDocks[0]).gameObject;
				MelonLogger.Msg((object)5);
				GameObject val2 = Object.Instantiate<GameObject>(gameObject, loadingDock.Position, Quaternion.Euler(loadingDock.Rotation));
				MelonLogger.Msg((object)6);
				LoadingDock component = val2.GetComponent<LoadingDock>();
				MelonLogger.Msg((object)7);
				component.ParentProperty = targetProperty;
				MelonLogger.Msg((object)8);
				targetProperty.LoadingDocks = targetProperty.LoadingDocks.Append(val2.GetComponent<LoadingDock>()).ToArray();
				MelonLogger.Msg((object)9);
			}
			else
			{
				MelonLogger.Msg((object)10);
				MelonLogger.Msg($"Adding extra loading dock to {targetProperty.LoadingDockCount} at {loadingDock.Position}");
				GameObject val3 = Object.Instantiate<GameObject>(((Component)targetProperty.LoadingDocks[0]).gameObject, loadingDock.Position, Quaternion.Euler(loadingDock.Rotation));
				targetProperty.LoadingDocks = targetProperty.LoadingDocks.Append(val3.GetComponent<LoadingDock>()).ToArray();
			}
		}

		public static void ApplyPropertyData(Property property, PropertyData propertyData)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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)
			if (property.EmployeeCapacity < propertyData.EmployeeCapacity)
			{
				int num = propertyData.EmployeeCapacity - property.EmployeeCapacity;
				for (int i = 0; i < num; i++)
				{
					Transform obj = property.EmployeeIdlePoints[0];
					Vector3 val = obj.position + new Vector3(Random.Range(0f, 2f), 0f, Random.Range(0f, 2f));
					Transform element = Object.Instantiate<Transform>(obj, val, Quaternion.identity);
					property.EmployeeIdlePoints = property.EmployeeIdlePoints.Append(element).ToArray();
				}
			}
			property.EmployeeCapacity = propertyData.EmployeeCapacity;
			ExtraLoadingDock[] extraLoadingDocks = propertyData.ExtraLoadingDocks;
			foreach (ExtraLoadingDock loadingDock in extraLoadingDocks)
			{
				AddExtraDock(property, loadingDock);
			}
		}

		public static void ApplyMixingUpgrade(MixingStation mixingStation, int mixTimeReduction)
		{
			if (mixingStation.MixTimePerItem - mixTimeReduction <= 1)
			{
				mixingStation.MixTimePerItem = 1;
			}
			else
			{
				mixingStation.MixTimePerItem -= mixTimeReduction;
			}
		}
	}
	public class Vector3Converter : JsonConverter<Vector3>
	{
		public override void WriteJson(JsonWriter writer, Vector3 value, JsonSerializer serializer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			writer.WriteStartObject();
			writer.WritePropertyName("x");
			writer.WriteValue(value.x);
			writer.WritePropertyName("y");
			writer.WriteValue(value.y);
			writer.WritePropertyName("z");
			writer.WriteValue(value.z);
			writer.WriteEndObject();
		}

		public override Vector3 ReadJson(JsonReader reader, Type objectType, Vector3 existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			JObject obj = JObject.Load(reader);
			JToken obj2 = obj["x"];
			float num = ((obj2 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj2) : 0f);
			JToken obj3 = obj["y"];
			float num2 = ((obj3 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj3) : 0f);
			JToken obj4 = obj["z"];
			float num3 = ((obj4 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj4) : 0f);
			return new Vector3(num, num2, num3);
		}
	}
}
namespace PropertyUpgrades.BuilderNPC
{
	public class Builder : NPC
	{
		[CompilerGenerated]
		private sealed class <ResetCoro>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ModSaveManager saveManager;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => NPC.Get<Builder>() != null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					new ResponsesLogic(NPC.Get<Builder>(), saveManager);
					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();
			}
		}

		public Builder()
			: base("builder_npc", MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "BuilderNPC_Name"), "", (Sprite)null)
		{
		}

		public static Builder InitBuilder(ModSaveManager saveManager)
		{
			Builder builder = GetBuilder();
			NPCManager.GetNPC("builder_npc").ConversationCanBeHidden = false;
			ResetConversation(saveManager);
			return builder;
		}

		public static Builder GetBuilder()
		{
			return (Builder)(object)NPC.Get<Builder>();
		}

		public static void ResetConversation(ModSaveManager saveManager)
		{
			MelonCoroutines.Start(ResetCoro(saveManager));
		}

		[IteratorStateMachine(typeof(<ResetCoro>d__4))]
		private static IEnumerator ResetCoro(ModSaveManager saveManager)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResetCoro>d__4(0)
			{
				saveManager = saveManager
			};
		}
	}
	public class ResponsesLogic
	{
		public enum Action
		{
			UpgradeProperty,
			SetTargetProperty,
			PositionLoadingBay,
			RemoveLoadingDock
		}

		public enum PropertyUpgrade
		{
			AddEmployee,
			AddPlantGrowthMultipler,
			ReduceMixingTime,
			AddLoadingDock
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public ResponsesLogic <>4__this;

			public float addLoadingBayPrice;

			internal void <ShowPositionLoadingBayResponse>b__0()
			{
				MelonCoroutines.Start(<>4__this.UpgradeProperty(PropertyUpgrade.AddLoadingDock, addLoadingBayPrice));
			}

			internal void <ShowPositionLoadingBayResponse>b__1()
			{
				<>4__this.Reset();
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass11_0
		{
			public Property property;

			public ResponsesLogic <>4__this;

			internal void <ShowPropertiesResponse>b__0()
			{
				<>4__this.SendAction(Action.SetTargetProperty, property);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			public GroundDetector groundDetector;

			public LoadingDock loadingDock;

			internal bool <RemoveLoadingBay>b__0()
			{
				return (Object)(object)groundDetector.ObjectCurrentlyUnderneath != (Object)null;
			}

			internal bool <RemoveLoadingBay>b__1()
			{
				return (Object)(object)loadingDock != (Object)null;
			}

			internal bool <RemoveLoadingBay>b__2(ExtraLoadingDock dock)
			{
				//IL_0001: 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)
				return dock.Position != ((Component)loadingDock).transform.position;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass15_0
		{
			public ResponsesLogic <>4__this;

			public float addEmployeePrice;

			public float extraGrowSpeedPrice;

			public float mixTimeReductionPrice;

			internal void <ShowAvailableUpgradesResponse>b__0()
			{
				<>4__this.Reset();
			}

			internal void <ShowAvailableUpgradesResponse>b__1()
			{
				MelonCoroutines.Start(<>4__this.UpgradeProperty(PropertyUpgrade.AddEmployee, addEmployeePrice));
			}

			internal void <ShowAvailableUpgradesResponse>b__2()
			{
				<>4__this.SendAction(Action.PositionLoadingBay);
			}

			internal void <ShowAvailableUpgradesResponse>b__3()
			{
				MelonCoroutines.Start(<>4__this.UpgradeProperty(PropertyUpgrade.AddPlantGrowthMultipler, extraGrowSpeedPrice));
			}

			internal void <ShowAvailableUpgradesResponse>b__4()
			{
				MelonCoroutines.Start(<>4__this.UpgradeProperty(PropertyUpgrade.ReduceMixingTime, mixTimeReductionPrice));
			}
		}

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

			private object <>2__current;

			public ResponsesLogic <>4__this;

			private <>c__DisplayClass14_0 <>8__1;

			private MoneyManager <moneyManager>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Expected O, but got Unknown
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Expected O, but got Unknown
				int num = <>1__state;
				ResponsesLogic responsesLogic = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass14_0();
					<>8__1.groundDetector = ((Component)responsesLogic.player).GetComponent<GroundDetector>();
					if ((Object)(object)<>8__1.groundDetector == (Object)null)
					{
						<>8__1.groundDetector = ((Component)responsesLogic.player).gameObject.AddComponent<GroundDetector>();
					}
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.groundDetector.ObjectCurrentlyUnderneath != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((Object)<>8__1.groundDetector.ObjectCurrentlyUnderneath).name != "Collider")
					{
						responsesLogic.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "StandOnTopOfDock"));
						MelonCoroutines.Start(responsesLogic.RemoveLoadingBay());
						return false;
					}
					<moneyManager>5__2 = NetworkSingleton<MoneyManager>.Instance;
					if (<moneyManager>5__2.onlineBalance < 1000f)
					{
						responsesLogic.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "NoBankBalance"));
						return false;
					}
					<>8__1.loadingDock = <>8__1.groundDetector.ObjectCurrentlyUnderneath.GetComponentInParent<LoadingDock>();
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.loadingDock != (Object)null));
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					string text = <>8__1.loadingDock.ParentProperty.PropertyName.Trim();
					PropertyData propertyData = responsesLogic.saveManager.saveData[text];
					propertyData.ExtraLoadingDocks = propertyData.ExtraLoadingDocks.Where((ExtraLoadingDock dock) => dock.Position != ((Component)<>8__1.loadingDock).transform.position).ToArray();
					<>8__1.loadingDock.ParentProperty.LoadingDocks = ArrayExt.Remove<LoadingDock>(<>8__1.loadingDock.ParentProperty.LoadingDocks, <>8__1.loadingDock);
					responsesLogic.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "DockRemoved"));
					Object.Destroy((Object)(object)((Component)<>8__1.loadingDock).gameObject);
					<moneyManager>5__2.CreateOnlineTransaction("Remove Loading Dock", -1000f, 1f, "Loading dock removal (" + text + ")");
					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 <ShowAvailableUpgradesResponse>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ResponsesLogic <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Expected O, but got Unknown
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Expected O, but got Unknown
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Expected O, but got Unknown
				//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0226: Expected O, but got Unknown
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0266: Unknown result type (might be due to invalid IL or missing references)
				//IL_027d: Expected O, but got Unknown
				int num = <>1__state;
				ResponsesLogic responsesLogic = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>c__DisplayClass15_0 CS$<>8__locals0 = new <>c__DisplayClass15_0
				{
					<>4__this = <>4__this
				};
				PropertyData propertyData = responsesLogic.saveManager.saveData[responsesLogic.targetProperty.PropertyName];
				int employeeCapacity = propertyData.EmployeeCapacity;
				CS$<>8__locals0.addEmployeePrice = employeeCapacity * 1250;
				CS$<>8__locals0.mixTimeReductionPrice = (((float)propertyData.MixTimePerItemReduction == 0f) ? 5000f : ((float)propertyData.MixTimePerItemReduction * 5000f));
				CS$<>8__locals0.extraGrowSpeedPrice = propertyData.ExtraGrowSpeedMultiplier * 5000f;
				float num2 = (((float)propertyData.ExtraLoadingDocks.Length == 0f) ? 10000f : ((float)propertyData.ExtraLoadingDocks.Length * 10000f));
				List<Response> list = new List<Response>
				{
					new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "GoBack"),
						OnTriggered = delegate
						{
							CS$<>8__locals0.<>4__this.Reset();
						}
					}
				};
				Limits limits = new Limits();
				if (responsesLogic.targetProperty.EmployeeCapacity < limits.MaxEmployeeCount && responsesLogic.targetProperty.PropertyName != "Motel Room")
				{
					list.Add(new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "AddEmployee").Replace("{{Price}}", CS$<>8__locals0.addEmployeePrice.ToString()),
						OnTriggered = delegate
						{
							MelonCoroutines.Start(CS$<>8__locals0.<>4__this.UpgradeProperty(PropertyUpgrade.AddEmployee, CS$<>8__locals0.addEmployeePrice));
						}
					});
				}
				if (responsesLogic.targetProperty.LoadingDocks.Length < limits.MaxLoadingDocks)
				{
					list.Add(new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "AddLoadingDock").Replace("{{Price}}", num2.ToString()),
						OnTriggered = delegate
						{
							CS$<>8__locals0.<>4__this.SendAction(Action.PositionLoadingBay);
						}
					});
				}
				if (propertyData.ExtraGrowSpeedMultiplier < limits.MaxAdditionalGrowthRate)
				{
					list.Add(new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "AddPlantGrowth").Replace("{{Price}}", CS$<>8__locals0.extraGrowSpeedPrice.ToString()),
						OnTriggered = delegate
						{
							MelonCoroutines.Start(CS$<>8__locals0.<>4__this.UpgradeProperty(PropertyUpgrade.AddPlantGrowthMultipler, CS$<>8__locals0.extraGrowSpeedPrice));
						}
					});
				}
				if (propertyData.MixTimePerItemReduction < limits.MaxMixTimeReduction)
				{
					list.Add(new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "ReduceMixTime").Replace("{{Price}}", CS$<>8__locals0.mixTimeReductionPrice.ToString()),
						OnTriggered = delegate
						{
							MelonCoroutines.Start(CS$<>8__locals0.<>4__this.UpgradeProperty(PropertyUpgrade.ReduceMixingTime, CS$<>8__locals0.mixTimeReductionPrice));
						}
					});
				}
				if (list.Count == 1)
				{
					responsesLogic.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "NoUpgrades").Replace("{{PropertyName}}", responsesLogic.targetProperty.PropertyName));
					return false;
				}
				string message = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "PropertyStats").Replace("{{PropertyName}}", responsesLogic.targetProperty.PropertyName).Replace("{{employeeCap}}", employeeCapacity.ToString())
					.Replace("{{ExtraGrowSpeedMultiplier}}", propertyData.ExtraGrowSpeedMultiplier.ToString())
					.Replace("{{MixTimePerItemReduction}}", propertyData.MixTimePerItemReduction.ToString())
					.Replace("{{ExtraLoadingDocksCount}}", propertyData.ExtraLoadingDocks.Length.ToString());
				responsesLogic.ShowResponses(list, message);
				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 <ShowPositionLoadingBayResponse>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ResponsesLogic <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Expected O, but got Unknown
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				int num = <>1__state;
				ResponsesLogic responsesLogic = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>c__DisplayClass10_0 CS$<>8__locals0 = new <>c__DisplayClass10_0
				{
					<>4__this = <>4__this
				};
				if ((Object)(object)responsesLogic.targetProperty == (Object)null)
				{
					responsesLogic.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "IdkWhichProperty"));
					return false;
				}
				PropertyData propertyData = responsesLogic.saveManager.saveData[responsesLogic.targetProperty.PropertyName];
				CS$<>8__locals0.addLoadingBayPrice = (((float)propertyData.ExtraLoadingDocks.Length == 0f) ? 10000f : ((float)propertyData.ExtraLoadingDocks.Length * 10000f));
				List<Response> responses = new List<Response>
				{
					new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "InPlace"),
						OnTriggered = delegate
						{
							MelonCoroutines.Start(CS$<>8__locals0.<>4__this.UpgradeProperty(PropertyUpgrade.AddLoadingDock, CS$<>8__locals0.addLoadingBayPrice));
						}
					},
					new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "GoBack"),
						OnTriggered = delegate
						{
							CS$<>8__locals0.<>4__this.Reset();
						}
					}
				};
				responsesLogic.ShowResponses(responses, MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "MoveToWhere").Replace("{{entity}}", "loading bay"));
				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 <ShowPropertiesResponse>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ResponsesLogic <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				int num = <>1__state;
				ResponsesLogic responsesLogic = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				MelonCoroutines.Start(responsesLogic.UpdateProperties());
				List<Response> list = new List<Response>();
				using (List<Property>.Enumerator enumerator = responsesLogic.ownedProperties.GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						<>c__DisplayClass11_0 CS$<>8__locals0 = new <>c__DisplayClass11_0
						{
							<>4__this = responsesLogic,
							property = enumerator.Current
						};
						if ((Object)(object)CS$<>8__locals0.property != (Object)null)
						{
							Response item = new Response
							{
								Text = CS$<>8__locals0.property.PropertyName,
								OnTriggered = delegate
								{
									CS$<>8__locals0.<>4__this.SendAction(Action.SetTargetProperty, CS$<>8__locals0.property);
								}
							};
							list.Add(item);
						}
					}
				}
				responsesLogic.ShowResponses(list, MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "WhichProperty"));
				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 <ShowRemoveBayResponses>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ResponsesLogic <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0020: 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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				int num = <>1__state;
				ResponsesLogic CS$<>8__locals0 = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				List<Response> responses = new List<Response>
				{
					new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "GoBack"),
						OnTriggered = delegate
						{
							CS$<>8__locals0.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "WhatElse"));
						}
					},
					new Response
					{
						Text = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "InPlace") + "($1000)",
						OnTriggered = delegate
						{
							MelonCoroutines.Start(CS$<>8__locals0.RemoveLoadingBay());
						}
					}
				};
				CS$<>8__locals0.ShowResponses(responses, MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "StandOnTopOfDock"));
				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 <UpdateProperties>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ResponsesLogic <>4__this;

			public bool save;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ResponsesLogic CS$<>8__locals0 = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				CS$<>8__locals0.ownedProperties = Property.OwnedProperties.Where(delegate(Property property)
				{
					if (property.PropertyName == "RV")
					{
						return false;
					}
					if (CS$<>8__locals0.saveManager.saveData.ContainsKey(property.PropertyName))
					{
						return true;
					}
					PropertyData value = new PropertyData
					{
						EmployeeCapacity = property.EmployeeCapacity,
						MixTimePerItemReduction = 0,
						ExtraGrowSpeedMultiplier = 1f,
						ExtraLoadingDocks = Array.Empty<ExtraLoadingDock>()
					};
					CS$<>8__locals0.saveManager.saveData.Add(property.PropertyName, value);
					return true;
				}).ToList();
				if (!save)
				{
					return false;
				}
				CS$<>8__locals0.saveManager.Save();
				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 <UpgradeProperty>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float price;

			public ResponsesLogic <>4__this;

			public PropertyUpgrade upgrade;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0321: Unknown result type (might be due to invalid IL or missing references)
				//IL_0326: Unknown result type (might be due to invalid IL or missing references)
				//IL_0333: Unknown result type (might be due to invalid IL or missing references)
				//IL_0338: Unknown result type (might be due to invalid IL or missing references)
				//IL_0340: Unknown result type (might be due to invalid IL or missing references)
				//IL_0342: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ResponsesLogic responsesLogic = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				MoneyManager instance = NetworkSingleton<MoneyManager>.Instance;
				if (instance.onlineBalance < price)
				{
					responsesLogic.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "NoBankBalance"));
					return false;
				}
				PropertyData propertyData = responsesLogic.saveManager.saveData[responsesLogic.targetProperty.PropertyName];
				switch (upgrade)
				{
				case PropertyUpgrade.AddEmployee:
				{
					instance.CreateOnlineTransaction("Property Upgrade", 0f - price, 1f, "Employee upgrade (" + responsesLogic.targetProperty.PropertyName + ")");
					Property targetProperty = responsesLogic.targetProperty;
					targetProperty.EmployeeCapacity++;
					Transform obj2 = responsesLogic.targetProperty.EmployeeIdlePoints[0];
					Vector3 val = obj2.position + new Vector3(Random.Range(0f, 2f), 0f, Random.Range(0f, 2f));
					Transform element = Object.Instantiate<Transform>(obj2, val, Quaternion.identity);
					responsesLogic.targetProperty.EmployeeIdlePoints = responsesLogic.targetProperty.EmployeeIdlePoints.Append(element).ToArray();
					propertyData.EmployeeCapacity = responsesLogic.targetProperty.EmployeeCapacity;
					responsesLogic.npc.SendTextMessage(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "EmployeeUpgrade").Replace("{{PropertyName}}", responsesLogic.targetProperty.PropertyName), (Response[])null, 1f, true);
					break;
				}
				case PropertyUpgrade.AddPlantGrowthMultipler:
				{
					instance.CreateOnlineTransaction("Property Upgrade", 0f - price, 1f, "Plant growth upgrade (" + responsesLogic.targetProperty.PropertyName + ")");
					Pot[] buildableItemScriptsFromProperty2 = ModUtilities.GetBuildableItemScriptsFromProperty<Pot>(responsesLogic.targetProperty);
					foreach (Pot obj in buildableItemScriptsFromProperty2)
					{
						obj.GrowSpeedMultiplier += 0.25f;
					}
					propertyData.ExtraGrowSpeedMultiplier += 0.25f;
					responsesLogic.npc.SendTextMessage(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "PotUpgrade").Replace("{{PropertyName}}", responsesLogic.targetProperty.PropertyName), (Response[])null, 1f, true);
					break;
				}
				case PropertyUpgrade.ReduceMixingTime:
				{
					instance.CreateOnlineTransaction("Property Upgrade", 0f - price, 1f, "Mixing time upgrade (" + responsesLogic.targetProperty.PropertyName + ")");
					MixingStation[] buildableItemScriptsFromProperty = ModUtilities.GetBuildableItemScriptsFromProperty<MixingStation>(responsesLogic.targetProperty);
					propertyData.MixTimePerItemReduction++;
					MixingStation[] array = buildableItemScriptsFromProperty;
					for (int i = 0; i < array.Length; i++)
					{
						ModUtilities.ApplyMixingUpgrade(array[i], propertyData.MixTimePerItemReduction);
					}
					responsesLogic.npc.SendTextMessage(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "MixerUpgrade").Replace("{{PropertyName}}", responsesLogic.targetProperty.PropertyName), (Response[])null, 1f, true);
					break;
				}
				case PropertyUpgrade.AddLoadingDock:
				{
					instance.CreateOnlineTransaction("Property Upgrade", 0f - price, 1f, "Loading dock upgrade (" + responsesLogic.targetProperty.PropertyName + ")");
					Vector3 position = ((Component)responsesLogic.player).transform.position;
					Quaternion rotation = ((Component)responsesLogic.player).transform.rotation;
					ModUtilities.AddExtraDock(responsesLogic.targetProperty, position, rotation, addToSaveManager: true, responsesLogic.saveManager);
					responsesLogic.npc.SendTextMessage(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "LoadingDockUpgrade").Replace("{{PropertyName}}", responsesLogic.targetProperty.PropertyName), (Response[])null, 1f, true);
					break;
				}
				}
				responsesLogic.saveManager.SaveTemp();
				responsesLogic.Reset(MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "WhatElse"));
				return false;
			}

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

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

		private NPC npc;

		private NPC s1npc;

		private Property targetProperty;

		private List<Property> ownedProperties;

		private ModSaveManager saveManager;

		private Player player;

		public ResponsesLogic(NPC npc, ModSaveManager saveManager)
		{
			this.npc = npc;
			this.saveManager = saveManager;
			try
			{
				saveManager.Load();
				MelonCoroutines.Start(UpdateProperties(save: true));
			}
			catch (Exception ex)
			{
				MelonLogger.Error((object)ex);
			}
			s1npc = NPCManager.GetNPC(npc.ID);
			player = Player.Local;
			Reset();
		}

		public ResponsesLogic SendAction(Action action, Property newTargetProperty = null, bool isRemoveLoadingDock = false)
		{
			switch (action)
			{
			case Action.UpgradeProperty:
				MelonCoroutines.Start(ShowPropertiesResponse());
				break;
			case Action.SetTargetProperty:
				targetProperty = newTargetProperty;
				if (!isRemoveLoadingDock)
				{
					MelonCoroutines.Start(ShowAvailableUpgradesResponse());
				}
				break;
			case Action.PositionLoadingBay:
				MelonCoroutines.Start(ShowPositionLoadingBayResponse());
				break;
			case Action.RemoveLoadingDock:
				MelonCoroutines.Start(ShowRemoveBayResponses());
				break;
			}
			return this;
		}

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

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

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

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

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

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

		[IteratorStateMachine(typeof(<UpgradeProperty>d__16))]
		private IEnumerator UpgradeProperty(PropertyUpgrade upgrade, float price)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpgradeProperty>d__16(0)
			{
				<>4__this = this,
				upgrade = upgrade,
				price = price
			};
		}

		private void ShowResponses(List<Response> responses, string message)
		{
			npc.SendTextMessage(message, responses.ToArray(), 1f, true);
		}

		private void Reset(string message = null)
		{
			if (message == null)
			{
				message = MelonPreferences.GetEntryValue<string>("PropertyUpgrades_Translation", "ResetMessage");
			}
			targetProperty = null;
			ShowResponses(GenerateResponses(), message);
		}

		private List<Response> GenerateResponses()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			return new List<Response>
			{
				new Response
				{
					Text = "Upgrade Property",
					OnTriggered = delegate
					{
						SendAction(Action.UpgradeProperty);
					}
				},
				new Response
				{
					Text = "Remove Loading Dock",
					OnTriggered = delegate
					{
						SendAction(Action.RemoveLoadingDock);
					}
				}
			};
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}