COM_Diff/Assembly-CSharp/MaidExtension/MaidCostumeChangeController.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace MaidExtension
{
	public class MaidCostumeChangeController
	{
		public MaidCostumeChangeController(Maid maid)
		{
			this.manager = new MaidCostumeChangeController.MaidCostumeChangeManager(maid);
		}

		public Maid maid
		{
			get
			{
				return this.manager.maid;
			}
			set
			{
				this.manager.maid = value;
			}
		}

		public MaidCostumeChangeController.MaidCostumeChangeManager manager { get; private set; }

		public bool IsSupportedCostumeType(MaidCostumeChangeController.CostumeType type)
		{
			switch (type)
			{
			case MaidCostumeChangeController.CostumeType.MekureFront:
				return this.manager.IsSupportedCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureFront);
			case MaidCostumeChangeController.CostumeType.MekureBack:
				return this.manager.IsSupportedCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureBack);
			case MaidCostumeChangeController.CostumeType.Zurasi:
				return this.manager.IsSupportedCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Zurasi);
			case MaidCostumeChangeController.CostumeType.Hadake:
				return this.manager.IsSupportedCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Hadake);
			default:
				return false;
			}
		}

		public void SetEnabledCostumeType(MaidCostumeChangeController.CostumeType type, bool enabled, string targetMpnName = null)
		{
			this.SetEnabledCostumeType(new MaidCostumeChangeController.CostumeType[]
			{
				type
			}, enabled, targetMpnName);
		}

		public void SetEnabledCostumeType(MaidCostumeChangeController.CostumeType[] types, bool enabled, string targetMpnName = null)
		{
			if (this.maid == null)
			{
				Debug.LogWarning("MaidCostumeChangeController::SetEnabledCostumeType\n maid is null.");
				return;
			}
			if (types == null || types.Length == 0)
			{
				return;
			}
			HashSet<MaidCostumeChangeController.CostumeType> hashSet = new HashSet<MaidCostumeChangeController.CostumeType>();
			foreach (MaidCostumeChangeController.CostumeType item in types)
			{
				hashSet.Add(item);
			}
			if (enabled && hashSet.Contains(MaidCostumeChangeController.CostumeType.MekureFront) && hashSet.Contains(MaidCostumeChangeController.CostumeType.MekureBack))
			{
				hashSet.Remove(MaidCostumeChangeController.CostumeType.MekureBack);
			}
			bool flag = (!hashSet.Contains(MaidCostumeChangeController.CostumeType.Hadake)) ? this.IsEnabledCostumeType(MaidCostumeChangeController.CostumeType.Hadake) : enabled;
			bool flag2 = (!hashSet.Contains(MaidCostumeChangeController.CostumeType.MekureFront)) ? this.IsEnabledCostumeType(MaidCostumeChangeController.CostumeType.MekureFront) : enabled;
			bool flag3 = (!hashSet.Contains(MaidCostumeChangeController.CostumeType.MekureBack)) ? this.IsEnabledCostumeType(MaidCostumeChangeController.CostumeType.MekureBack) : enabled;
			bool flag4 = (!hashSet.Contains(MaidCostumeChangeController.CostumeType.Zurasi)) ? this.IsEnabledCostumeType(MaidCostumeChangeController.CostumeType.Zurasi) : enabled;
			if (flag2 && flag3)
			{
				if (hashSet.Contains(MaidCostumeChangeController.CostumeType.MekureFront))
				{
					flag3 = !enabled;
				}
				else
				{
					flag2 = !enabled;
				}
			}
			this.Reset(targetMpnName);
			bool flag5 = false;
			if (flag)
			{
				flag5 |= this.manager.SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Hadake, true, false);
			}
			if (flag2)
			{
				flag5 |= this.manager.SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureFront, true, false);
				if (flag)
				{
					flag5 |= this.manager.SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureFront, true, false);
				}
			}
			if (flag3)
			{
				flag5 |= this.manager.SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureBack, true, false);
				if (flag)
				{
					flag5 |= this.manager.SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureBack, true, false);
				}
			}
			if (flag4)
			{
				flag5 |= this.manager.SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Zurasi, true, false);
				if (flag)
				{
					flag5 |= this.manager.SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndZurasi, true, false);
				}
			}
			if (flag5)
			{
				this.maid.AllProcProp();
			}
		}

		public bool IsEnabledCostumeType(MaidCostumeChangeController.CostumeType type)
		{
			switch (type)
			{
			case MaidCostumeChangeController.CostumeType.MekureFront:
				return this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureFront) || this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureFront);
			case MaidCostumeChangeController.CostumeType.MekureBack:
				return this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureBack) || this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureBack);
			case MaidCostumeChangeController.CostumeType.Zurasi:
				return this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Zurasi) || this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndZurasi);
			case MaidCostumeChangeController.CostumeType.Hadake:
				return this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Hadake) || this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureFront) || this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureBack) || this.manager.IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndZurasi);
			default:
				return false;
			}
		}

		public void Reset(string targetMpnName = null)
		{
			this.manager.Reset(targetMpnName);
		}

		public class MaidCostumeChangeManager
		{
			public MaidCostumeChangeManager(Maid maid)
			{
				this.maid = maid;
			}

			public static string[] GetTargetMpnNames(Maid maid, MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType type)
			{
				if (maid == null)
				{
					Debug.LogWarning("MaidCostumeChangeManager::GetTargetMpnNames\n maid is null.");
					return new string[0];
				}
				switch (type)
				{
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureFront:
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureBack:
					return new string[]
					{
						"skirt",
						"onepiece"
					};
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Zurasi:
				{
					string[] result;
					if (maid.IsCrcBody)
					{
						string[] array = new string[4];
						array[0] = "mizugi_buttom";
						array[1] = "mizugi";
						array[2] = "panz";
						result = array;
						array[3] = "slip";
					}
					else
					{
						string[] array2 = new string[2];
						array2[0] = "panz";
						result = array2;
						array2[1] = "mizugi";
					}
					return result;
				}
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Hadake:
				{
					string[] result2;
					if (maid.IsCrcBody)
					{
						string[] array3 = new string[6];
						array3[0] = "wear";
						array3[1] = "onepiece";
						array3[2] = "mizugi_top";
						array3[3] = "mizugi";
						array3[4] = "bra";
						result2 = array3;
						array3[5] = "slip";
					}
					else
					{
						result2 = new string[0];
					}
					return result2;
				}
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureFront:
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureBack:
				{
					string[] result3;
					if (maid.IsCrcBody)
					{
						(result3 = new string[1])[0] = "onepiece";
					}
					else
					{
						result3 = new string[0];
					}
					return result3;
				}
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndZurasi:
				{
					string[] result4;
					if (maid.IsCrcBody)
					{
						(result4 = new string[1])[0] = "mizugi";
					}
					else
					{
						result4 = new string[0];
					}
					return result4;
				}
				default:
					return new string[0];
				}
			}

			public static string GetItemChangeNames(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType type)
			{
				switch (type)
				{
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureFront:
					return "めくれスカート";
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.MekureBack:
					return "めくれスカート後ろ";
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Zurasi:
					return "パンツずらし";
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.Hadake:
					return "はだけ";
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureFront:
					return "めくれスカートはだけ";
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndMekureBack:
					return "めくれスカート後ろはだけ";
				case MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType.HadakeAndZurasi:
					return "パンツずらしはだけ";
				default:
					return string.Empty;
				}
			}

			public bool IsSupportedCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType type)
			{
				if (this.maid == null)
				{
					Debug.LogWarning("MaidCostumeChangeManager::IsSupportedCostumeType\n maid is null.");
					return false;
				}
				if (Product.isPublic)
				{
					return false;
				}
				string itemChangeNames = MaidCostumeChangeController.MaidCostumeChangeManager.GetItemChangeNames(type);
				foreach (string mpn in MaidCostumeChangeController.MaidCostumeChangeManager.GetTargetMpnNames(this.maid, type))
				{
					if (this.maid.IsItemChangeEnabled(mpn, itemChangeNames))
					{
						return true;
					}
				}
				return false;
			}

			public bool SetEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType type, bool enabled, bool runAllProcProp = true)
			{
				if (this.maid == null)
				{
					Debug.LogWarning("MaidCostumeChangeManager::SetEnabledCostumeType\n maid is null.");
					return false;
				}
				bool flag = false;
				string[] targetMpnNames = MaidCostumeChangeController.MaidCostumeChangeManager.GetTargetMpnNames(this.maid, type);
				if (enabled)
				{
					string itemChangeNames = MaidCostumeChangeController.MaidCostumeChangeManager.GetItemChangeNames(type);
					foreach (string mpn in targetMpnNames)
					{
						if (this.maid.IsItemChangeEnabled(mpn, itemChangeNames) && !this.maid.IsItemChange(mpn, itemChangeNames))
						{
							this.maid.ItemChangeTemp(mpn, itemChangeNames);
							flag = true;
						}
					}
				}
				else
				{
					flag = true;
					foreach (string mpn2 in targetMpnNames)
					{
						this.maid.ResetProp(mpn2, true);
					}
				}
				if (!flag)
				{
					return false;
				}
				if (!enabled || runAllProcProp)
				{
					this.maid.AllProcProp();
				}
				return true;
			}

			public bool IsEnabledCostumeType(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType type)
			{
				if (this.maid == null)
				{
					Debug.LogWarning("MaidCostumeChangeManager::IsEnabledCostumeType\n maid is null.");
					return false;
				}
				if (Product.isPublic)
				{
					return false;
				}
				string itemChangeNames = MaidCostumeChangeController.MaidCostumeChangeManager.GetItemChangeNames(type);
				foreach (string mpn in MaidCostumeChangeController.MaidCostumeChangeManager.GetTargetMpnNames(this.maid, type))
				{
					if (this.maid.IsItemChange(mpn, itemChangeNames))
					{
						return true;
					}
				}
				return false;
			}

			public void Reset(string targetMpnName = null)
			{
				if (this.maid == null)
				{
					Debug.LogWarning("MaidCostumeChangeManager::Reset\n maid is null.");
					return;
				}
				if (targetMpnName == null)
				{
					HashSet<string> hashSet = new HashSet<string>();
					IEnumerator enumerator = Enum.GetValues(typeof(MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType)).GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							object obj = enumerator.Current;
							MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType type = (MaidCostumeChangeController.MaidCostumeChangeManager.CostumeType)obj;
							foreach (string item in MaidCostumeChangeController.MaidCostumeChangeManager.GetTargetMpnNames(this.maid, type))
							{
								hashSet.Add(item);
							}
						}
					}
					finally
					{
						IDisposable disposable;
						if ((disposable = (enumerator as IDisposable)) != null)
						{
							disposable.Dispose();
						}
					}
					foreach (string mpn in hashSet)
					{
						this.maid.ResetProp(mpn, false);
					}
				}
				else
				{
					this.maid.ResetProp(targetMpnName, false);
				}
				this.maid.AllProcProp();
			}

			public Maid maid;

			public enum CostumeType
			{
				MekureFront,
				MekureBack,
				Zurasi,
				Hadake,
				HadakeAndMekureFront,
				HadakeAndMekureBack,
				HadakeAndZurasi
			}
		}

		public enum CostumeType
		{
			MekureFront,
			MekureBack,
			Zurasi,
			Hadake
		}
	}
}