using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using I2.Loc;
using MaidStatus;
using Schedule;
using UnityEngine;

public class Facility : MonoBehaviour
{
	public void Init(int facilityTypeID)
	{
		this.m_Param = new Facility.FacilityStatus();
		Facility.FacilityStatus facilityStatus = FacilityDataTable.GetFacilityStatus(facilityTypeID, true);
		this.param.typeID = facilityStatus.typeID;
		this.param.name = facilityStatus.name;
		if (Product.supportMultiLanguage)
		{
			string translation = LocalizationManager.GetTranslation(facilityStatus.termName, true, 0, true, false, null, null);
			if (!string.IsNullOrEmpty(translation))
			{
				this.param.name = translation;
			}
		}
		this.param.parameter = facilityStatus.parameter;
		if (FacilityDataTable.IsExistFacilityPowerUpRecipe(facilityTypeID, true))
		{
			int[] facilityPowerUpRecipeIDArray = FacilityDataTable.GetFacilityPowerUpRecipeIDArray(facilityTypeID, true);
			this.recipe = new Facility.RecipeData[facilityPowerUpRecipeIDArray.Length];
			for (int i = 0; i < this.recipe.Length; i++)
			{
				this.recipe[i] = new Facility.RecipeData(facilityPowerUpRecipeIDArray[i]);
			}
		}
		this.m_EditCostumeArray = new Dictionary<MPN, KeyValuePair<bool, string>>();
		Dictionary<MPN, KeyValuePair<bool, string>> facilityDefaultCostume = FacilityDataTable.GetFacilityDefaultCostume(facilityTypeID, true, false);
		if (facilityDefaultCostume != null && 0 < facilityDefaultCostume.Count)
		{
			List<MPN> list = new List<MPN>(facilityDefaultCostume.Keys);
			List<KeyValuePair<bool, string>> list2 = new List<KeyValuePair<bool, string>>(facilityDefaultCostume.Values);
			int count = facilityDefaultCostume.Count;
			for (int j = 0; j < count; j++)
			{
				KeyValuePair<bool, string> value = new KeyValuePair<bool, string>(true, list2[j].Value);
				if (Product.isPublic && (list[j] == MPN.panz || list[j] == MPN.bra))
				{
					value = new KeyValuePair<bool, string>(false, list2[j].Value);
				}
				this.m_EditCostumeArray.Add(list[j], value);
			}
		}
		this.m_TypeCostume = Facility.CostumeType.Heroine;
		this.m_AllocationDayTimeMaidGuidList = new List<string>();
		this.m_AllocationNightMaidGuidList = new List<string>();
		this.m_BeforeAllocationDayTimeMaidGuidList = new List<string>();
		this.m_BeforeAllocationNightMaidGuidList = new List<string>();
		this.guid = Guid.NewGuid().ToString();
	}

	public Facility.RecipeData GetRecipeData(int id)
	{
		if (this.m_Recipe == null)
		{
			return null;
		}
		Facility.RecipeData result = null;
		for (int i = 0; i < this.m_Recipe.Length; i++)
		{
			if (this.m_Recipe[i].id == id)
			{
				result = this.m_Recipe[i];
				break;
			}
		}
		return result;
	}

	public bool IsExistRecipeData(int id)
	{
		return this.GetRecipeData(id) != null;
	}

	public void SetRecipeData(Facility.RecipeData recipeData)
	{
		if (this.m_Recipe == null)
		{
			return;
		}
		if (!this.IsExistRecipeData(recipeData.id))
		{
			Debug.LogWarning(string.Concat(new object[]
			{
				"[Facility.cs]施設「",
				this.facilityName,
				"」は強化レシピID:",
				recipeData.id,
				"のレシピに対応していません"
			}));
			return;
		}
		for (int i = 0; i < this.m_Recipe.Length; i++)
		{
			if (this.m_Recipe[i].id == recipeData.id)
			{
				this.m_Recipe[i] = recipeData;
			}
		}
	}

	public Facility.FacilityParameter CalcAllParameter()
	{
		return this.CalcRecipeParameter() + this.m_Param.parameter;
	}

	public Facility.FacilityParameter CalcRecipeParameter()
	{
		Facility.FacilityParameter facilityParameter = new Facility.FacilityParameter();
		if (this.m_Recipe == null)
		{
			return facilityParameter;
		}
		Facility.RecipeData[] recipe = this.m_Recipe;
		for (int i = 0; i < recipe.Length; i++)
		{
			facilityParameter += Facility.RecipeData.CalcFacilityParameter(recipe[i]);
			facilityParameter += FacilityDataTable.GetFacilityPowerUpRecipe(recipe[i].id).parameter;
		}
		return facilityParameter;
	}

	public void SetEditCostume(MPN mpn, string fileName)
	{
		if (!FacilityDataTable.IsEnableFacilityCostumeMPN(mpn))
		{
			Debug.LogWarning(string.Format("[Facility]施設「{0}」：エディットコスチューム「{1}」のキーが存在しない", this.facilityName, mpn));
			return;
		}
		if (fileName.ToLower() == "del")
		{
			if (!CM3.dicDelItem.TryGetValue(mpn, out fileName))
			{
				NDebug.Assert(string.Format("[Facility]MPN「{0}」のdelファイル名の取得に失敗", mpn), false);
			}
		}
		else if (!string.IsNullOrEmpty(fileName))
		{
			if (!Path.HasExtension(fileName))
			{
				fileName += ".menu";
			}
			if (!GameUty.FileSystem.IsExistentFile(fileName))
			{
				Debug.LogWarning(string.Format("[Facility].menuアイテム「{0}」は存在しない", fileName));
				return;
			}
		}
		bool key = false;
		if (this.m_EditCostumeArray.ContainsKey(mpn))
		{
			key = this.m_EditCostumeArray[mpn].Key;
			this.m_EditCostumeArray[mpn] = new KeyValuePair<bool, string>(key, fileName);
		}
		else
		{
			Dictionary<MPN, KeyValuePair<bool, string>> facilityDefaultCostume = FacilityDataTable.GetFacilityDefaultCostume(this.param.typeID, true, false);
			if (facilityDefaultCostume != null)
			{
				key = facilityDefaultCostume[mpn].Key;
			}
			this.m_EditCostumeArray.Add(mpn, new KeyValuePair<bool, string>(key, fileName));
		}
	}

	public Dictionary<MPN, KeyValuePair<bool, string>> GetEditCostume()
	{
		return new Dictionary<MPN, KeyValuePair<bool, string>>(this.m_EditCostumeArray);
	}

	public string GetEditCostume(MPN mpn)
	{
		if (!this.m_EditCostumeArray.ContainsKey(mpn))
		{
			Debug.LogWarning(string.Format("[Facility]施設「{0}」のエディットコスチューム「{1}」のキーが存在しない", this.facilityName, mpn));
			return string.Empty;
		}
		return this.m_EditCostumeArray[mpn].Value;
	}

	public void DeleteEditCostume(MPN mpn)
	{
		if (!this.m_EditCostumeArray.ContainsKey(mpn))
		{
			Debug.LogWarning(string.Format("[Facility]施設「{0}」のエディットコスチューム「{1}」のキーが存在しない", this.facilityName, mpn));
			return;
		}
		KeyValuePair<bool, string> keyValuePair = this.m_EditCostumeArray[mpn];
		this.m_EditCostumeArray[mpn] = new KeyValuePair<bool, string>(keyValuePair.Key, CM3.dicDelItem[mpn]);
	}

	public void SetCostumeForced(MPN mpn, bool isForced)
	{
		if (!this.m_EditCostumeArray.ContainsKey(mpn))
		{
			Debug.LogWarning(string.Format("[Facility]施設「{0}」のエディットコスチューム「{1}」のキーが存在しない", this.facilityName, mpn));
			return;
		}
		KeyValuePair<bool, string> keyValuePair = this.m_EditCostumeArray[mpn];
		this.m_EditCostumeArray[mpn] = new KeyValuePair<bool, string>(isForced, keyValuePair.Value);
	}

	public bool GetCostumeForced(MPN mpn)
	{
		if (!this.m_EditCostumeArray.ContainsKey(mpn))
		{
			Debug.LogWarning(string.Format("[Facility]施設「{0}」のエディットコスチューム「{1}」のキーが存在しない", this.facilityName, mpn));
			return false;
		}
		return this.m_EditCostumeArray[mpn].Key;
	}

	public void Serialize(BinaryWriter bw)
	{
		bw.Write(this.guid);
		bw.Write(this.m_Param.typeID);
		bw.Write(this.m_Param.name);
		bw.Write(this.m_Param.parameter.income);
		bw.Write(this.m_Param.parameter.valuation);
		bw.Write(this.m_Param.parameter.experienceValue);
		if (this.m_Recipe != null)
		{
			bw.Write(this.m_Recipe.Length);
			for (int i = 0; i < this.m_Recipe.Length; i++)
			{
				bw.Write(this.m_Recipe[i].id);
				bw.Write(this.m_Recipe[i].materialIDArray.Length);
				for (int j = 0; j < this.m_Recipe[i].materialIDArray.Length; j++)
				{
					bw.Write(this.m_Recipe[i].materialIDArray[j]);
				}
			}
		}
		else
		{
			bw.Write(0);
		}
		bw.Write((int)this.m_TypeCostume);
		if (this.m_EditCostumeArray != null)
		{
			MPN[] facilityCostumeEnableMPN = FacilityDataTable.GetFacilityCostumeEnableMPN();
			bw.Write(facilityCostumeEnableMPN.Length);
			foreach (MPN mpn in facilityCostumeEnableMPN)
			{
				KeyValuePair<bool, string> keyValuePair = default(KeyValuePair<bool, string>);
				if (this.m_EditCostumeArray.ContainsKey(mpn))
				{
					keyValuePair = this.m_EditCostumeArray[mpn];
				}
				bw.Write(Enum.GetName(typeof(MPN), mpn));
				bw.Write(keyValuePair.Key);
				bw.Write((!string.IsNullOrEmpty(keyValuePair.Value)) ? keyValuePair.Value : string.Empty);
			}
		}
		else
		{
			bw.Write(0);
		}
		if (this.m_AllocationDayTimeMaidGuidList != null)
		{
			bw.Write(this.m_AllocationDayTimeMaidGuidList.Count);
			for (int l = 0; l < this.m_AllocationDayTimeMaidGuidList.Count; l++)
			{
				bw.Write(this.m_AllocationDayTimeMaidGuidList[l]);
			}
		}
		else
		{
			bw.Write(0);
		}
		if (this.m_AllocationNightMaidGuidList != null)
		{
			bw.Write(this.m_AllocationNightMaidGuidList.Count);
			for (int m = 0; m < this.m_AllocationNightMaidGuidList.Count; m++)
			{
				bw.Write(this.m_AllocationNightMaidGuidList[m]);
			}
		}
		else
		{
			bw.Write(0);
		}
		if (this.m_BeforeAllocationDayTimeMaidGuidList != null)
		{
			bw.Write(this.m_BeforeAllocationDayTimeMaidGuidList.Count);
			for (int n = 0; n < this.m_BeforeAllocationDayTimeMaidGuidList.Count; n++)
			{
				bw.Write(this.m_BeforeAllocationDayTimeMaidGuidList[n]);
			}
		}
		else
		{
			bw.Write(0);
		}
		if (this.m_BeforeAllocationNightMaidGuidList != null)
		{
			bw.Write(this.m_BeforeAllocationNightMaidGuidList.Count);
			for (int num = 0; num < this.m_BeforeAllocationNightMaidGuidList.Count; num++)
			{
				bw.Write(this.m_BeforeAllocationNightMaidGuidList[num]);
			}
		}
		else
		{
			bw.Write(0);
		}
		this.FixEditCostumeThumbnail();
	}

	public bool Deserialize(BinaryReader br, int version)
	{
		this.guid = br.ReadString();
		this.m_Param.typeID = br.ReadInt32();
		this.m_Param.name = br.ReadString();
		this.m_Param.parameter.income = br.ReadInt32();
		this.m_Param.parameter.valuation = br.ReadInt32();
		this.m_Param.parameter.experienceValue = br.ReadInt32();
		bool flag = FacilityDataTable.IsExistFacilityData(this.m_Param.typeID, true);
		if (!flag)
		{
			string message = string.Format("施設の種類ID[{0}]の情報は存在しないので、この施設情報は失われます", this.m_Param.typeID);
			NDebug.Warning(message);
			Debug.LogWarning(message);
		}
		if (version < 5)
		{
			int num = br.ReadInt32();
			this.m_Recipe = new Facility.RecipeData[num];
			for (int i = 0; i < num; i++)
			{
				int id_ = br.ReadInt32();
				this.m_Recipe[i] = new Facility.RecipeData(id_);
				for (int j = 0; j < this.m_Recipe[i].materialIDArray.Length; j++)
				{
					this.m_Recipe[i].materialIDArray[j] = br.ReadInt32();
				}
			}
		}
		else
		{
			if (FacilityDataTable.IsExistFacilityPowerUpRecipe(this.param.typeID, flag))
			{
				int[] facilityPowerUpRecipeIDArray = FacilityDataTable.GetFacilityPowerUpRecipeIDArray(this.param.typeID, flag);
				this.m_Recipe = new Facility.RecipeData[facilityPowerUpRecipeIDArray.Length];
				for (int k = 0; k < this.m_Recipe.Length; k++)
				{
					this.m_Recipe[k] = new Facility.RecipeData(facilityPowerUpRecipeIDArray[k]);
				}
			}
			else
			{
				this.m_Recipe = null;
			}
			int num2 = br.ReadInt32();
			Facility.RecipeData[] array = new Facility.RecipeData[num2];
			for (int l = 0; l < num2; l++)
			{
				int id_2 = br.ReadInt32();
				array[l] = new Facility.RecipeData(id_2);
				int num3 = br.ReadInt32();
				bool flag2 = array[l].materialIDArray.Length == num3;
				for (int m = 0; m < num3; m++)
				{
					if (flag2)
					{
						array[l].materialIDArray[m] = br.ReadInt32();
					}
					else
					{
						br.ReadInt32();
					}
				}
			}
			foreach (Facility.RecipeData recipeData in array)
			{
				for (int num4 = 0; num4 < this.m_Recipe.Length; num4++)
				{
					if (this.m_Recipe[num4].id == recipeData.id && this.m_Recipe[num4].materialIDArray.Length == recipeData.materialIDArray.Length)
					{
						this.m_Recipe[num4] = recipeData;
					}
				}
			}
		}
		int num5 = br.ReadInt32();
		this.m_TypeCostume = (Facility.CostumeType)Enum.Parse(typeof(Facility.CostumeType), num5.ToString());
		int num6 = br.ReadInt32();
		this.m_EditCostumeArray = new Dictionary<MPN, KeyValuePair<bool, string>>();
		if (version >= 3)
		{
			for (int num7 = 0; num7 < num6; num7++)
			{
				string value = br.ReadString();
				MPN mpn = MPN.null_mpn;
				try
				{
					mpn = (MPN)Enum.Parse(typeof(MPN), value);
				}
				catch (Exception e)
				{
					NDebug.AssertParseError("MPN", e);
				}
				bool key = br.ReadBoolean();
				string value2 = br.ReadString();
				if (FacilityDataTable.IsEnableFacilityCostumeMPN(mpn))
				{
					this.m_EditCostumeArray.Add(mpn, new KeyValuePair<bool, string>(key, value2));
				}
			}
		}
		else
		{
			for (int num8 = 0; num8 < num6; num8++)
			{
				int num9 = br.ReadInt32();
				bool key2 = br.ReadBoolean();
				string text = br.ReadString();
				MPN mpn2 = MPN.null_mpn;
				if (!string.IsNullOrEmpty(text))
				{
					string[] array2 = text.Split(new char[]
					{
						'_'
					});
					foreach (string value3 in array2)
					{
						try
						{
							mpn2 = (MPN)Enum.Parse(typeof(MPN), value3, true);
							break;
						}
						catch
						{
						}
					}
					if (FacilityDataTable.IsEnableFacilityCostumeMPN(mpn2))
					{
						this.m_EditCostumeArray.Add(mpn2, new KeyValuePair<bool, string>(key2, text));
					}
				}
			}
		}
		int num11 = br.ReadInt32();
		this.m_AllocationDayTimeMaidGuidList = new List<string>();
		for (int num12 = 0; num12 < num11; num12++)
		{
			string item = br.ReadString();
			this.m_AllocationDayTimeMaidGuidList.Add(item);
		}
		num11 = br.ReadInt32();
		this.m_AllocationNightMaidGuidList = new List<string>();
		for (int num13 = 0; num13 < num11; num13++)
		{
			string item2 = br.ReadString();
			this.m_AllocationNightMaidGuidList.Add(item2);
		}
		if (version > 0)
		{
			num11 = br.ReadInt32();
			this.m_BeforeAllocationDayTimeMaidGuidList = new List<string>();
			for (int num14 = 0; num14 < num11; num14++)
			{
				string item3 = br.ReadString();
				this.m_BeforeAllocationDayTimeMaidGuidList.Add(item3);
			}
			num11 = br.ReadInt32();
			this.m_BeforeAllocationNightMaidGuidList = new List<string>();
			for (int num15 = 0; num15 < num11; num15++)
			{
				string item4 = br.ReadString();
				this.m_BeforeAllocationNightMaidGuidList.Add(item4);
			}
		}
		return flag;
	}

	public void UpdateMaidCostumeToDefaultCostume(Maid maid)
	{
		Dictionary<MPN, KeyValuePair<bool, string>> facilityDefaultCostume = FacilityDataTable.GetFacilityDefaultCostume(this.param.typeID, true, maid.IsCrcBody);
		if (facilityDefaultCostume == null)
		{
			Debug.LogWarning(string.Format("[Facility]施設『{0}』のデフォルトコスチュームの取得に失敗しました\n施設の種類ID：{1}", this.facilityName, this.param.typeID));
			return;
		}
		if (facilityDefaultCostume.Count <= 0)
		{
			Debug.LogWarning(string.Format("[Facility]施設『{0}』のデフォルトコスチュームの数が０以下でした\n施設の種類ID：{1}\u3000\u3000データ数：{2}", this.facilityName, this.param.typeID, facilityDefaultCostume.Count));
			return;
		}
		if (maid == null)
		{
			Debug.LogWarning(string.Format("[Facility]施設『{0}』のコスチュームにするメイドにnullが指定されました", this.facilityName));
			return;
		}
		int count = facilityDefaultCostume.Count;
		List<MPN> list = new List<MPN>(facilityDefaultCostume.Keys);
		List<KeyValuePair<bool, string>> list2 = new List<KeyValuePair<bool, string>>(facilityDefaultCostume.Values);
		for (int i = 0; i < count; i++)
		{
			MaidProp prop = maid.GetProp(list[i]);
			prop.strTempFileName = string.Empty;
			prop.nTempFileNameRID = 0;
			if (!list2[i].Key)
			{
				maid.ResetProp(list[i], false);
			}
			else if (list2[i].Value == "del")
			{
				maid.DelProp(list[i], true);
			}
			else
			{
				maid.SetProp(list[i], list2[i].Value, 0, true, false);
			}
		}
	}

	public void UpdateMaidCostumeToEditCostume(Maid maid, bool absoluteChange = false)
	{
		Dictionary<MPN, KeyValuePair<bool, string>> editCostumeArray = this.m_EditCostumeArray;
		if (editCostumeArray == null)
		{
			Debug.LogWarning(string.Format("[Facility]施設『{0}』のエディットコスチュームの取得に失敗しました\n施設の種類ID：{1}", this.facilityName, this.param.typeID));
			return;
		}
		if (editCostumeArray.Count <= 0)
		{
			Debug.LogWarning(string.Format("[Facility]施設『{0}』のエディットコスチュームの数が０以下でした\n施設の種類ID：{1}\u3000\u3000データ数：{2}", this.facilityName, this.param.typeID, editCostumeArray.Count));
			return;
		}
		if (maid == null)
		{
			Debug.LogWarning(string.Format("[Facility]施設『{0}』のコスチュームにするメイドにnullが指定されました", this.facilityName));
			return;
		}
		if (maid.IsCrcBody)
		{
			return;
		}
		int count = editCostumeArray.Count;
		List<MPN> list = new List<MPN>(editCostumeArray.Keys);
		List<KeyValuePair<bool, string>> list2 = new List<KeyValuePair<bool, string>>(editCostumeArray.Values);
		for (int i = 0; i < count; i++)
		{
			MaidProp prop = maid.GetProp(list[i]);
			prop.strTempFileName = string.Empty;
			prop.nTempFileNameRID = 0;
			if (!absoluteChange && !list2[i].Key)
			{
				maid.ResetProp(list[i], false);
			}
			else if (list2[i].Value == "del")
			{
				maid.DelProp(list[i], true);
			}
			else
			{
				maid.SetProp(list[i], list2[i].Value, 0, true, false);
			}
		}
	}

	public void UpdateEditCostumeToMaidCostume(Maid maid)
	{
		if (maid == null)
		{
			Debug.LogWarning(string.Format("[Facility]施設『{0}』のコスチューム設定メイドにnullが指定されました", this.facilityName));
			return;
		}
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.AppendFormat("[Facility]施設『{0}』のコスチューム\n", this.facilityName);
		foreach (MPN mpn in FacilityDataTable.GetFacilityCostumeEnableMPN())
		{
			MaidProp prop = maid.GetProp(mpn);
			string strTempFileName = prop.strTempFileName;
			this.SetEditCostume(mpn, strTempFileName);
			stringBuilder.AppendFormat("＜{0}\t{1}＞\n", mpn, strTempFileName);
		}
	}

	public static string GetFacilityEditCostumeThumbnailPath()
	{
		return Path.Combine(GameMain.Instance.SerializeStorageManager.StoreDirectoryPath, "Thumb") + "\\";
	}

	public string GetFacilityEditCostumeThumbnailName()
	{
		return "f_cos_tmp_" + this.guid + ".png";
	}

	public string GetFacilityEditCostumeThumbnailTrueName()
	{
		return "f_cos_" + this.guid + ".png";
	}

	public Texture2D GetEditCostumeThumbnail()
	{
		Texture2D result = null;
		string facilityEditCostumeThumbnailPath = Facility.GetFacilityEditCostumeThumbnailPath();
		if (!Directory.Exists(facilityEditCostumeThumbnailPath))
		{
			Directory.CreateDirectory(facilityEditCostumeThumbnailPath);
		}
		string text = facilityEditCostumeThumbnailPath + this.GetFacilityEditCostumeThumbnailName();
		if (File.Exists(text))
		{
			result = UTY.LoadTexture(text);
		}
		else
		{
			text = facilityEditCostumeThumbnailPath + this.GetFacilityEditCostumeThumbnailTrueName();
			if (File.Exists(text))
			{
				result = UTY.LoadTexture(text);
			}
		}
		return result;
	}

	public bool IsExistEditCostumeThumbnail()
	{
		string facilityEditCostumeThumbnailPath = Facility.GetFacilityEditCostumeThumbnailPath();
		if (!Directory.Exists(facilityEditCostumeThumbnailPath))
		{
			return false;
		}
		string path = facilityEditCostumeThumbnailPath + this.GetFacilityEditCostumeThumbnailName();
		if (File.Exists(path))
		{
			return true;
		}
		path = facilityEditCostumeThumbnailPath + this.GetFacilityEditCostumeThumbnailTrueName();
		return File.Exists(path);
	}

	public Texture2D GetDefaultCostumeThumbnail()
	{
		if (!string.IsNullOrEmpty(this.defaultCostumeThumbnailName))
		{
			string f_strFileName = this.defaultCostumeThumbnailName + ".tex";
			if (GameUty.FileSystem.IsExistentFile(f_strFileName))
			{
				return ImportCM.CreateTexture(f_strFileName);
			}
			Debug.LogWarningFormat("施設デフォルト衣装サムネイル「{0}」がない", new object[]
			{
				this.defaultCostumeThumbnailName
			});
		}
		else
		{
			Debug.LogWarningFormat("施設「{0}」のデフォルト衣装サムネイル名が空文字だった", new object[]
			{
				this.defaultName
			});
		}
		return null;
	}

	private void FixEditCostumeThumbnail()
	{
		string facilityEditCostumeThumbnailPath = Facility.GetFacilityEditCostumeThumbnailPath();
		if (!Directory.Exists(facilityEditCostumeThumbnailPath))
		{
			return;
		}
		string text = facilityEditCostumeThumbnailPath + this.GetFacilityEditCostumeThumbnailName();
		if (!File.Exists(text))
		{
			return;
		}
		string text2 = facilityEditCostumeThumbnailPath + this.GetFacilityEditCostumeThumbnailTrueName();
		try
		{
			if (File.Exists(text2))
			{
				File.Delete(text2);
			}
			File.Move(text, text2);
		}
		catch
		{
		}
	}

	public static void DeleteTmpEditCostumeThumnails()
	{
		string facilityEditCostumeThumbnailPath = Facility.GetFacilityEditCostumeThumbnailPath();
		if (!Directory.Exists(facilityEditCostumeThumbnailPath))
		{
			return;
		}
		string[] files = Directory.GetFiles(facilityEditCostumeThumbnailPath, "*", SearchOption.TopDirectoryOnly);
		for (int i = 0; i < files.Length; i++)
		{
			string text = string.Empty;
			try
			{
				text = files[i].Substring(facilityEditCostumeThumbnailPath.Length, files[i].Length - facilityEditCostumeThumbnailPath.Length);
			}
			catch
			{
			}
			if (string.IsNullOrEmpty(text))
			{
				files[i] = string.Empty;
			}
			else if (0 > text.IndexOf(".png") || 0 > text.IndexOf("f_cos_tmp_"))
			{
				files[i] = string.Empty;
			}
		}
		for (int j = 0; j < files.Length; j++)
		{
			if (!string.IsNullOrEmpty(files[j]))
			{
				try
				{
					File.Delete(files[j]);
				}
				catch
				{
				}
			}
		}
	}

	public void LoadFacilityBG()
	{
		FacilityDataTable.FacilityDefaultData facilityDefaultData = FacilityDataTable.GetFacilityDefaultData(this.param.typeID, true);
		if (facilityDefaultData == null)
		{
			return;
		}
		string fileName = facilityDefaultData.fileName;
		if (string.IsNullOrEmpty(fileName))
		{
			Debug.LogWarningFormat("[Facility]施設「{0}」の背景プレハブ名が空でした", new object[]
			{
				this.facilityName
			});
			return;
		}
		GameMain.Instance.BgMgr.ChangeBg(fileName);
	}

	public Facility.FacilityStatus param
	{
		get
		{
			return this.m_Param;
		}
	}

	public Facility.RecipeData[] recipe
	{
		get
		{
			return this.m_Recipe;
		}
		set
		{
			this.m_Recipe = value;
		}
	}

	public string facilityName
	{
		get
		{
			return this.m_Param.name;
		}
		set
		{
			this.m_Param.name = value;
		}
	}

	public int facilityIncome
	{
		get
		{
			return this.m_Param.parameter.income;
		}
		set
		{
			this.m_Param.parameter.income = value;
		}
	}

	public int facilityValuation
	{
		get
		{
			return this.m_Param.parameter.valuation;
		}
		set
		{
			this.m_Param.parameter.valuation = value;
		}
	}

	public int facilityExperienceValue
	{
		get
		{
			return this.m_Param.parameter.experienceValue;
		}
		set
		{
			this.m_Param.parameter.experienceValue = value;
		}
	}

	public int facilityLevel
	{
		get
		{
			FacilityManager facilityMgr = GameMain.Instance.FacilityMgr;
			if (!facilityMgr)
			{
				NDebug.Assert("[Facility]施設マネージャクラスが見つかりません", false);
				return -1;
			}
			return facilityMgr.GetFacilityLevel(this.param.typeID);
		}
	}

	public SimpleExperienceSystem expSystem
	{
		get
		{
			FacilityManager facilityMgr = GameMain.Instance.FacilityMgr;
			if (!facilityMgr)
			{
				NDebug.Assert("[Facility]施設マネージャクラスが見つかりません", false);
				return null;
			}
			return facilityMgr.GetFacilityExpSystem(this.param.typeID);
		}
	}

	public int staffRankDayTime
	{
		get
		{
			int[] staffRankArray = this.defaultData.staffRankArray;
			int num = 0;
			CharacterMgr characterMgr = GameMain.Instance.CharacterMgr;
			Maid[] allocationMaidArray = this.GetAllocationMaidArray(ScheduleMgr.ScheduleTime.DayTime);
			foreach (Maid maid in allocationMaidArray)
			{
				num += this.CalcStaffRank(maid);
			}
			int j;
			for (j = 0; j < staffRankArray.Length; j++)
			{
				if (num <= staffRankArray[j])
				{
					break;
				}
			}
			return j + 1;
		}
	}

	public int staffRankNight
	{
		get
		{
			int[] staffRankArray = this.defaultData.staffRankArray;
			int num = 0;
			CharacterMgr characterMgr = GameMain.Instance.CharacterMgr;
			Maid[] allocationMaidArray = this.GetAllocationMaidArray(ScheduleMgr.ScheduleTime.Night);
			foreach (Maid maid in allocationMaidArray)
			{
				num += this.CalcStaffRank(maid);
			}
			int j;
			for (j = 0; j < staffRankArray.Length; j++)
			{
				if (num <= staffRankArray[j])
				{
					break;
				}
			}
			return j + 1;
		}
	}

	public int GetStaffRank(ScheduleMgr.ScheduleTime scheduleTime)
	{
		if (scheduleTime == ScheduleMgr.ScheduleTime.DayTime)
		{
			return this.staffRankDayTime;
		}
		if (scheduleTime == ScheduleMgr.ScheduleTime.Night)
		{
			return this.staffRankNight;
		}
		NDebug.Assert(string.Format("スケジュール時間帯に不正な値が入りました\n時間帯：{0}", scheduleTime), false);
		return -1;
	}

	private int CalcStaffRank(Maid maid)
	{
		return Facility.CalcStaffRank(maid, this.defaultData.businessType);
	}

	private static int CalcStaffRank(Maid maid, FacilityDataTable.BusinessType type)
	{
		Status status = maid.status;
		double num = 0.0;
		if (type != FacilityDataTable.BusinessType.接待系)
		{
			if (type != FacilityDataTable.BusinessType.営業系)
			{
				if (type != FacilityDataTable.BusinessType.アイドル系)
				{
					if (type == FacilityDataTable.BusinessType.無し)
					{
						num += Facility.ConvertRevisionStatus((double)status.lovely);
						num += Facility.ConvertRevisionStatus((double)status.elegance);
						num += Facility.ConvertRevisionStatus((double)status.charm);
						num += Facility.ConvertRevisionStatus((double)status.care);
						num += Facility.ConvertRevisionStatus((double)status.reception);
						num += Facility.ConvertRevisionStatus((double)status.cooking);
						num += Facility.ConvertRevisionStatus((double)status.vocal);
						num += Facility.ConvertRevisionStatus((double)status.dance);
						num += Facility.ConvertRevisionStatus((double)status.inyoku);
						num += Facility.ConvertRevisionStatus((double)status.mvalue);
						num += Facility.ConvertRevisionStatus((double)status.hentai);
						num += Facility.ConvertRevisionStatus((double)status.housi);
						num /= 6.0;
					}
				}
				else
				{
					num += Facility.ConvertRevisionStatus((double)status.lovely);
					num += Facility.ConvertRevisionStatus((double)status.elegance);
					num += Facility.ConvertRevisionStatus((double)status.charm);
					num += Facility.ConvertRevisionStatus((double)status.vocal);
					num += Facility.ConvertRevisionStatus((double)status.dance);
					num /= 3.0;
				}
			}
			else
			{
				num += Facility.ConvertRevisionStatus((double)status.lovely);
				num += Facility.ConvertRevisionStatus((double)status.elegance);
				num += Facility.ConvertRevisionStatus((double)status.charm);
				num += Facility.ConvertRevisionStatus((double)status.reception);
				num += Facility.ConvertRevisionStatus((double)status.inyoku);
				num += Facility.ConvertRevisionStatus((double)status.mvalue);
				num += Facility.ConvertRevisionStatus((double)status.hentai);
				num += Facility.ConvertRevisionStatus((double)status.housi);
				num /= 4.0;
			}
		}
		else
		{
			num += Facility.ConvertRevisionStatus((double)status.lovely);
			num += Facility.ConvertRevisionStatus((double)status.elegance);
			num += Facility.ConvertRevisionStatus((double)status.charm);
			num += Facility.ConvertRevisionStatus((double)status.care);
			num += Facility.ConvertRevisionStatus((double)status.cooking);
			num /= 3.0;
		}
		return (int)num;
	}

	private static double ConvertRevisionStatus(double value)
	{
		double num = (double)Mathf.Clamp((float)value, 0f, 9999f);
		return Math.Ceiling(value / 500.0);
	}

	public bool isOperationDayTime
	{
		get
		{
			return this.nowDayTimeMaidCount >= this.minMaidCount;
		}
	}

	public bool isOperationNight
	{
		get
		{
			return this.nowNightMaidCount >= this.minMaidCount;
		}
	}

	public bool IsOperation(ScheduleMgr.ScheduleTime scheduleTime)
	{
		if (scheduleTime == ScheduleMgr.ScheduleTime.DayTime)
		{
			return this.isOperationDayTime;
		}
		if (scheduleTime == ScheduleMgr.ScheduleTime.Night)
		{
			return this.isOperationNight;
		}
		NDebug.Assert(string.Format("スケジュール時間帯に不正な値が入りました\n時間帯：{0}", scheduleTime), false);
		return false;
	}

	public int minMaidCount
	{
		get
		{
			int result = 0;
			if (FacilityDataTable.IsExistFacilityData(this.param.typeID, true))
			{
				FacilityDataTable.FacilityDefaultData facilityDefaultData = FacilityDataTable.GetFacilityDefaultData(this.param.typeID, true);
				result = facilityDefaultData.minMaidCount;
			}
			else
			{
				Debug.LogErrorFormat("[Facility]施設の種類ID[{0}]の情報は存在しない", new object[]
				{
					this.param.typeID
				});
			}
			return result;
		}
	}

	public int maxMaidCount
	{
		get
		{
			int result = 0;
			if (FacilityDataTable.IsExistFacilityData(this.param.typeID, true))
			{
				FacilityDataTable.FacilityDefaultData facilityDefaultData = FacilityDataTable.GetFacilityDefaultData(this.param.typeID, true);
				result = facilityDefaultData.maxMaidCount;
			}
			else
			{
				Debug.LogErrorFormat("[Facility]施設の種類ID[{0}]の情報は存在しない", new object[]
				{
					this.param.typeID
				});
			}
			return result;
		}
	}

	public int nowDayTimeMaidCount
	{
		get
		{
			return this.m_AllocationDayTimeMaidGuidList.Count;
		}
	}

	public int nowNightMaidCount
	{
		get
		{
			return this.m_AllocationNightMaidGuidList.Count;
		}
	}

	public int NowMaidCount(ScheduleMgr.ScheduleTime scheduleTime)
	{
		if (scheduleTime == ScheduleMgr.ScheduleTime.DayTime)
		{
			return this.nowDayTimeMaidCount;
		}
		if (scheduleTime == ScheduleMgr.ScheduleTime.Night)
		{
			return this.nowNightMaidCount;
		}
		NDebug.Assert(string.Format("スケジュール時間帯に不正な値が入りました\n時間帯：{0}", scheduleTime), false);
		return 0;
	}

	public bool AllocationMaid(Maid maid, ScheduleMgr.ScheduleTime scheduleTime)
	{
		string guid = maid.status.guid;
		Facility maidAssignedFacility = GameMain.Instance.FacilityMgr.GetMaidAssignedFacility(maid, scheduleTime);
		if (maidAssignedFacility && maidAssignedFacility != this)
		{
			maidAssignedFacility.RemoveAllocationMaid(maid, scheduleTime);
		}
		if (scheduleTime == ScheduleMgr.ScheduleTime.DayTime)
		{
			if (this.m_AllocationDayTimeMaidGuidList.Contains(guid))
			{
				Debug.LogWarningFormat("メイド「{0}」は既に割り当てられています", new object[]
				{
					maid.name
				});
				return false;
			}
			if (this.m_BeforeAllocationDayTimeMaidGuidList.Contains(guid))
			{
				this.m_BeforeAllocationDayTimeMaidGuidList.Remove(guid);
			}
			this.m_AllocationDayTimeMaidGuidList.Add(guid);
		}
		else
		{
			if (scheduleTime != ScheduleMgr.ScheduleTime.Night)
			{
				NDebug.Assert(string.Format("スケジュール時間帯に不正な値が入りました\n時間帯：{0}", scheduleTime), false);
				return false;
			}
			if (this.m_AllocationNightMaidGuidList.Contains(guid))
			{
				Debug.LogWarningFormat("メイド「{0}」は既に割り当てられています", new object[]
				{
					maid.name
				});
				return false;
			}
			if (this.m_BeforeAllocationNightMaidGuidList.Contains(guid))
			{
				this.m_BeforeAllocationNightMaidGuidList.Remove(guid);
			}
			this.m_AllocationNightMaidGuidList.Add(guid);
		}
		return true;
	}

	public bool RemoveAllocationMaid(Maid maid, ScheduleMgr.ScheduleTime scheduleTime)
	{
		string guid = maid.status.guid;
		if (scheduleTime == ScheduleMgr.ScheduleTime.DayTime)
		{
			if (!this.m_AllocationDayTimeMaidGuidList.Contains(guid))
			{
				Debug.LogWarningFormat("メイド「{0}」は割り当てられていません", new object[]
				{
					maid.name
				});
				return false;
			}
			this.m_AllocationDayTimeMaidGuidList.Remove(guid);
		}
		else
		{
			if (scheduleTime != ScheduleMgr.ScheduleTime.Night)
			{
				NDebug.Assert(string.Format("スケジュール時間帯に不正な値が入りました\n時間帯：{0}", scheduleTime), false);
				return false;
			}
			if (!this.m_AllocationNightMaidGuidList.Contains(guid))
			{
				Debug.LogWarningFormat("メイド「{0}」は割り当てられていません", new object[]
				{
					maid.name
				});
				return false;
			}
			this.m_AllocationNightMaidGuidList.Remove(guid);
		}
		return true;
	}

	public void UpdateAllocationMaidList()
	{
		this.UpdateAllocationDayTimeMaidList();
		this.UpdateAllocationNightMaidList();
	}

	public void UpdateAllocationDayTimeMaidList()
	{
		CharacterMgr characterMgr = GameMain.Instance.CharacterMgr;
		List<string> list = new List<string>();
		List<string> list2 = new List<string>();
		List<string> list3 = new List<string>();
		Maid[] allocationMaidArray = this.GetAllocationMaidArray(ScheduleMgr.ScheduleTime.DayTime, ref list2);
		for (int i = 0; i < allocationMaidArray.Length; i++)
		{
			list.Add(allocationMaidArray[i].status.guid);
		}
		foreach (string text in this.m_BeforeAllocationDayTimeMaidGuidList)
		{
			if (!string.IsNullOrEmpty(text))
			{
				Maid stockMaid = characterMgr.GetStockMaid(text);
				if (stockMaid)
				{
					if (!GameMain.Instance.FacilityMgr.GetMaidAssignedFacility(stockMaid, ScheduleMgr.ScheduleTime.DayTime))
					{
						if (ScheduleAPI.FacilitySlotActive(text, this, ScheduleMgr.ScheduleTime.DayTime))
						{
							list.Add(text);
						}
						else
						{
							list3.Add(text);
						}
					}
				}
			}
		}
		foreach (string item in list2)
		{
			if (!list3.Contains(item))
			{
				list3.Add(item);
			}
		}
		this.m_AllocationDayTimeMaidGuidList = list;
		this.m_BeforeAllocationDayTimeMaidGuidList = list3;
	}

	public void UpdateAllocationNightMaidList()
	{
		CharacterMgr characterMgr = GameMain.Instance.CharacterMgr;
		List<string> list = new List<string>();
		List<string> list2 = new List<string>();
		List<string> list3 = new List<string>();
		Maid[] allocationMaidArray = this.GetAllocationMaidArray(ScheduleMgr.ScheduleTime.Night, ref list2);
		for (int i = 0; i < allocationMaidArray.Length; i++)
		{
			list.Add(allocationMaidArray[i].status.guid);
		}
		foreach (string text in this.m_BeforeAllocationNightMaidGuidList)
		{
			if (!string.IsNullOrEmpty(text))
			{
				Maid stockMaid = characterMgr.GetStockMaid(text);
				if (stockMaid)
				{
					if (!GameMain.Instance.FacilityMgr.GetMaidAssignedFacility(stockMaid, ScheduleMgr.ScheduleTime.Night))
					{
						if (ScheduleAPI.FacilitySlotActive(text, this, ScheduleMgr.ScheduleTime.Night))
						{
							list.Add(text);
						}
						else
						{
							list3.Add(text);
						}
					}
				}
			}
		}
		foreach (string item in list2)
		{
			if (!list3.Contains(item))
			{
				list3.Add(item);
			}
		}
		this.m_AllocationNightMaidGuidList = list;
		this.m_BeforeAllocationNightMaidGuidList = list3;
	}

	public Maid[] GetAllocationMaidArray(ScheduleMgr.ScheduleTime scheduleTime)
	{
		List<string> list = new List<string>();
		return this.GetAllocationMaidArray(scheduleTime, ref list);
	}

	public Maid[] GetAllocationMaidArray(ScheduleMgr.ScheduleTime scheduleTime, ref List<string> excludeMaidList)
	{
		CharacterMgr characterMgr = GameMain.Instance.CharacterMgr;
		List<Maid> list = new List<Maid>();
		List<string> list2 = new List<string>();
		if (scheduleTime == ScheduleMgr.ScheduleTime.DayTime)
		{
			list2 = this.m_AllocationDayTimeMaidGuidList;
		}
		else
		{
			if (scheduleTime != ScheduleMgr.ScheduleTime.Night)
			{
				NDebug.Assert(string.Format("スケジュール時間帯に不正な値が入りました\n時間帯：{0}", scheduleTime), false);
				return null;
			}
			list2 = this.m_AllocationNightMaidGuidList;
		}
		int count = list2.Count;
		for (int i = 0; i < count; i++)
		{
			string text = list2[i];
			Maid maid = characterMgr.GetMaid(text);
			if (maid == null)
			{
				maid = characterMgr.GetStockMaid(text);
			}
			if (maid != null)
			{
				if (ScheduleAPI.FacilitySlotActive(text, this, scheduleTime))
				{
					list.Add(maid);
				}
				else if (excludeMaidList != null)
				{
					excludeMaidList.Add(text);
				}
			}
			else
			{
				Debug.LogFormat("GUID「{0}」のメイドがいなくなりました。", new object[]
				{
					text
				});
			}
		}
		return list.ToArray();
	}

	public bool IsAllocationMaid(Maid maid, ScheduleMgr.ScheduleTime scheduleTime)
	{
		bool result;
		if (scheduleTime == ScheduleMgr.ScheduleTime.DayTime)
		{
			result = this.m_AllocationDayTimeMaidGuidList.Contains(maid.status.guid);
		}
		else
		{
			if (scheduleTime != ScheduleMgr.ScheduleTime.Night)
			{
				NDebug.Assert(string.Format("スケジュール時間帯に不正な値が入りました\n時間帯：{0}", scheduleTime), false);
				return false;
			}
			result = this.m_AllocationNightMaidGuidList.Contains(maid.status.guid);
		}
		return result;
	}

	public Facility.CostumeType typeCostume
	{
		get
		{
			return this.m_TypeCostume;
		}
		set
		{
			this.m_TypeCostume = value;
		}
	}

	public string defaultName
	{
		get
		{
			return FacilityDataTable.GetFacilityStatus(this.param.typeID, true).name;
		}
	}

	public string defaultTermName
	{
		get
		{
			return FacilityDataTable.GetFacilityStatus(this.param.typeID, true).termName;
		}
	}

	public FacilityDataTable.FacilityDefaultData defaultData
	{
		get
		{
			return FacilityDataTable.GetFacilityDefaultData(this.param.typeID, true);
		}
	}

	public string defaultCostumeThumbnailName
	{
		get
		{
			return FacilityDataTable.GetFacilityDefaultCostumeThumbnailName(this.param.typeID, true);
		}
	}

	public string guid { get; private set; }

	[SerializeField]
	private Facility.FacilityStatus m_Param;

	[SerializeField]
	private Facility.RecipeData[] m_Recipe;

	[SerializeField]
	private Facility.CostumeType m_TypeCostume;

	private Dictionary<MPN, KeyValuePair<bool, string>> m_EditCostumeArray;

	private List<string> m_AllocationDayTimeMaidGuidList;

	private List<string> m_AllocationNightMaidGuidList;

	private List<string> m_BeforeAllocationDayTimeMaidGuidList;

	private List<string> m_BeforeAllocationNightMaidGuidList;

	public enum CostumeType
	{
		Default,
		Edit,
		Heroine
	}

	[Serializable]
	public class FacilityStatus
	{
		public int typeID;

		public string name = string.Empty;

		public string termName = string.Empty;

		public Facility.FacilityParameter parameter = new Facility.FacilityParameter();
	}

	[Serializable]
	public class FacilityParameter
	{
		public FacilityParameter()
		{
			this.dataArray[0] = 0;
			this.dataArray[1] = 0;
			this.dataArray[2] = 0;
		}

		public FacilityParameter(int income_, int valuation_, int experienceValue_)
		{
			this.dataArray[0] = income_;
			this.dataArray[1] = valuation_;
			this.dataArray[2] = experienceValue_;
		}

		public int income
		{
			get
			{
				return this.dataArray[0];
			}
			set
			{
				this.dataArray[0] = value;
			}
		}

		public int valuation
		{
			get
			{
				return this.dataArray[1];
			}
			set
			{
				this.dataArray[1] = value;
			}
		}

		public int experienceValue
		{
			get
			{
				return this.dataArray[2];
			}
			set
			{
				this.dataArray[2] = value;
			}
		}

		public int Length
		{
			get
			{
				return this.dataArray.Length;
			}
		}

		public int this[int i]
		{
			get
			{
				switch (i)
				{
				case 0:
					return this.income;
				case 1:
					return this.valuation;
				case 2:
					return this.experienceValue;
				default:
					Debug.LogError("[FacilityParameter]施設パラメータのインデクサーの添え字が範囲外です");
					return 0;
				}
			}
			set
			{
				switch (i)
				{
				case 0:
					this.income = value;
					break;
				case 1:
					this.valuation = value;
					break;
				case 2:
					this.experienceValue = value;
					break;
				default:
					Debug.LogError("[FacilityParameter]施設パラメータのインデクサーの添え字が範囲外です");
					break;
				}
			}
		}

		public string GetParameterName(int parameterIndex)
		{
			return FacilityDataTable.GetFacilityParameterName(parameterIndex + 1);
		}

		public static Facility.FacilityParameter operator +(Facility.FacilityParameter a, Facility.FacilityParameter b)
		{
			return new Facility.FacilityParameter(a[0] + b[0], a[1] + b[1], a[2] + b[2]);
		}

		public static Facility.FacilityParameter operator -(Facility.FacilityParameter a, Facility.FacilityParameter b)
		{
			return new Facility.FacilityParameter(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
		}

		[SerializeField]
		private int[] dataArray = new int[3];
	}

	public class PowerUpMaterial
	{
		public int id;

		public string name = string.Empty;

		public int categoryID;

		public Facility.FacilityParameter parameter = new Facility.FacilityParameter();
	}

	public class PowerUpRecipe
	{
		public int id;

		public string name = string.Empty;

		public int[] materialCategoryIDArray;

		public Facility.FacilityParameter parameter = new Facility.FacilityParameter();
	}

	[Serializable]
	public class RecipeData
	{
		public RecipeData(int id_)
		{
			this.id = id_;
			Facility.PowerUpRecipe facilityPowerUpRecipe = FacilityDataTable.GetFacilityPowerUpRecipe(id_);
			this.materialIDArray = new int[facilityPowerUpRecipe.materialCategoryIDArray.Length];
		}

		public Facility.FacilityParameter defaultParameter
		{
			get
			{
				return FacilityDataTable.GetFacilityPowerUpRecipe(this.id).parameter;
			}
		}

		public Facility.FacilityParameter additionalParameter
		{
			get
			{
				return Facility.RecipeData.CalcFacilityParameter(this.materialIDArray);
			}
		}

		public Facility.FacilityParameter parameter
		{
			get
			{
				return this.defaultParameter + this.additionalParameter;
			}
		}

		public string name
		{
			get
			{
				return FacilityDataTable.GetFacilityRecipeData(this.id).name;
			}
		}

		public static Facility.FacilityParameter CalcFacilityParameter(Facility.RecipeData recipeData)
		{
			return Facility.RecipeData.CalcFacilityParameter(recipeData.materialIDArray);
		}

		public static Facility.FacilityParameter CalcFacilityParameter(int[] materialIDArray)
		{
			Facility.FacilityParameter facilityParameter = new Facility.FacilityParameter();
			if (materialIDArray != null)
			{
				for (int i = 0; i < materialIDArray.Length; i++)
				{
					if (FacilityDataTable.IsExistPowerUpMaterial(materialIDArray[i]))
					{
						facilityParameter += FacilityDataTable.GetFacilityPowerUpMaterial(materialIDArray[i]).parameter;
					}
				}
			}
			return facilityParameter;
		}

		public static Facility.FacilityParameter CalcFacilityDefaultParameter(int facilityTypeID)
		{
			Facility.FacilityParameter facilityParameter = new Facility.FacilityParameter();
			if (FacilityDataTable.IsExistFacilityData(facilityTypeID, true) && FacilityDataTable.IsExistFacilityPowerUpRecipe(facilityTypeID, true))
			{
				int[] facilityPowerUpRecipeIDArray = FacilityDataTable.GetFacilityPowerUpRecipeIDArray(facilityTypeID, true);
				for (int i = 0; i < facilityPowerUpRecipeIDArray.Length; i++)
				{
					facilityParameter += FacilityDataTable.GetFacilityPowerUpRecipe(facilityPowerUpRecipeIDArray[i]).parameter;
				}
			}
			return facilityParameter;
		}

		public int id;

		public int[] materialIDArray;
	}
}