COM_Diff/Assembly-CSharp/GameUty.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using I2.Loc;
using UnityEngine;
using wf;

public class GameUty
{
	public static AFileSystemBase FileSystem
	{
		get
		{
			return GameUty.m_FileSystem;
		}
	}

	public static AFileSystemBase FileSystemOld
	{
		get
		{
			return GameUty.m_FileSystemOld;
		}
	}

	public static AFileSystemBase FileSystemMod
	{
		get
		{
			return GameUty.m_ModFileSystem;
		}
	}

	public static bool IsEnabledCompatibilityMode
	{
		get
		{
			return 0 < GameUty.PathListOld.Count;
		}
	}

	public static bool supportMultiLanguage
	{
		get
		{
			return false;
		}
	}

	public static HashSet<string> loadArchiveList { get; private set; }

	public static string[] MenuFiles
	{
		get
		{
			return GameUty.m_aryMenuFiles;
		}
	}

	public static string[] ModOnlysMenuFiles
	{
		get
		{
			return GameUty.m_aryModOnlysMenuFiles;
		}
	}

	public static Dictionary<int, string> RidMenuDic
	{
		get
		{
			return GameUty.rid_menu_dic_;
		}
	}

	public static Dictionary<string, AFileSystemBase> BgFiles { get; private set; }

	public static float MillisecondToSecond(int millisecond)
	{
		return (float)millisecond / 1000f;
	}

	public static Material GetSystemMaterial(GameUty.SystemMaterial f_mat)
	{
		Material material = GameUty.m_matSystem[(int)f_mat];
		if (material == null)
		{
			UnityEngine.Object original = Resources.Load(GameUty.m_strSystemMaterialName[(int)f_mat]);
			material = (UnityEngine.Object.Instantiate(original) as Material);
			GameUty.m_matSystem[(int)f_mat] = material;
		}
		return material;
	}

	public static GameObject LoadAssetBundle(string file_name)
	{
		if (GameUty.FileSystem == null || !GameUty.FileSystem.IsExistentFile(file_name))
		{
			return null;
		}
		UnityEngine.Object original = null;
		if (!GameUty.asset_bundle_dic.ContainsKey(file_name))
		{
			using (AFileBase afileBase = GameUty.FileSystem.FileOpen(file_name))
			{
				AssetBundle assetBundle = AssetBundle.LoadFromMemory(afileBase.ReadAll());
				if (assetBundle.mainAsset != null)
				{
					original = assetBundle.mainAsset;
				}
				else
				{
					original = assetBundle.LoadAllAssets<GameObject>()[0];
				}
				GameUty.asset_bundle_dic.Add(file_name, assetBundle);
			}
		}
		else
		{
			original = GameUty.asset_bundle_dic[file_name].mainAsset;
		}
		GameObject gameObject = UnityEngine.Object.Instantiate(original) as GameObject;
		gameObject.name = gameObject.name.Replace("(Clone)", string.Empty);
		return gameObject;
	}

	public static void DeviceInitialize()
	{
	}

	public static void Init()
	{
		GameUty.m_FileSystem = new FileSystemArchive();
		GameUty.m_FileSystemOld = new FileSystemArchive();
		GameUty.loadArchiveList = new HashSet<string>();
		GameUty.PathListOld = new List<string>();
		if (!string.IsNullOrEmpty(GameMain.Instance.CMSystem.CM3D2Path))
		{
			GameUty.PathListOld = GameUty.ReadAutoPathFile("[2.0]", GameMain.Instance.CMSystem.CM3D2Path + "\\GameData\\paths.dat");
			if (GameUty.PathListOld == null)
			{
				GameUty.PathListOld = new List<string>();
			}
		}
		GameUty.UpdateFileSystemPath();
		GameUty.UpdateFileSystemPathOld();
		PluginData.CreateData(GameUty.m_FileSystem, (!GameUty.IsEnabledCompatibilityMode) ? null : GameUty.m_FileSystemOld);
		Debug.Log("■■■■■■■■ Plugin Check ■■■■■■■■");
		foreach (string text in PluginData.GetAllUniqueNames())
		{
			Debug.Log(string.Concat(new string[]
			{
				"[",
				PluginData.uniqueNameToId(text).ToString(),
				"]",
				text,
				" : ",
				(!PluginData.IsEnabled(text)) ? "×" : "○"
			}));
		}
		Debug.Log("■■■■■■■■■■■■■■■■■■■■");
	}

	public static void Finish()
	{
		foreach (KeyValuePair<string, AssetBundle> keyValuePair in GameUty.asset_bundle_dic)
		{
			keyValuePair.Value.Unload(true);
		}
		GameUty.asset_bundle_dic.Clear();
		GameUty.m_FileSystem.Dispose();
		GameUty.m_FileSystem = null;
		if (GameUty.m_FileSystemOld != null)
		{
			GameUty.m_FileSystemOld.Dispose();
			GameUty.m_FileSystemOld = null;
		}
		if (GameUty.m_ModFileSystem != null)
		{
			GameUty.m_ModFileSystem.Dispose();
			GameUty.m_ModFileSystem = null;
		}
	}

	public static Dictionary<string, HashSet<string>> GetGameDataResourceList(string gameDataPath)
	{
		string[] array = new string[]
		{
			"script_cbl",
			"motion_cbl",
			"voice_cbl"
		};
		int length = (gameDataPath + "\\").Length;
		string[] directories = Directory.GetDirectories(gameDataPath);
		Dictionary<string, HashSet<string>> dictionary = new Dictionary<string, HashSet<string>>();
		for (int i = 0; i < directories.Length; i++)
		{
			string text = directories[i].Substring(length, directories[i].Length - length).ToLower();
			int startIndex = 0;
			foreach (string text2 in array)
			{
				if (text.IndexOf(text2) == 0)
				{
					startIndex = text2.Length;
					break;
				}
			}
			int num = text.IndexOf('_', startIndex);
			if (0 <= num)
			{
				string text3 = text.Substring(0, num);
				if (!string.IsNullOrEmpty(text3))
				{
					string text4 = text.Substring(text3.Length + 1, text.Length - (text3.Length + 1));
					if (!string.IsNullOrEmpty(text4))
					{
						if (!dictionary.ContainsKey(text3))
						{
							dictionary.Add(text3, new HashSet<string>());
						}
						if (!dictionary[text3].Contains(text4))
						{
							dictionary[text3].Add(text4);
						}
						else
						{
							Debug.LogWarning(text3 + "_" + text4 + "は既にリストに存在します");
						}
					}
				}
			}
			else if (!dictionary.ContainsKey(text))
			{
				dictionary.Add(text, new HashSet<string>());
			}
			else
			{
				Debug.LogWarning(text + "は既にリストに存在します");
			}
		}
		return dictionary;
	}

	public static List<string> ReadAutoPathFile(string uniqueName, string filePath)
	{
		if (!File.Exists(filePath))
		{
			return null;
		}
		List<string> list = new List<string>();
		using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
		{
			using (BinaryReader binaryReader = new BinaryReader(fileStream))
			{
				string a = binaryReader.ReadString();
				NDebug.Assert(a == "CM3D2_PATHS", "パスファイルのヘッダーが不正です。");
				int num = binaryReader.ReadInt32();
				int num2 = binaryReader.ReadInt32();
				for (int i = 0; i < num2; i++)
				{
					string item = binaryReader.ReadString();
					list.Add(item);
				}
			}
		}
		return list;
	}

	public static void UpdateFileSystemPath()
	{
		string fullPath = Path.GetFullPath(".\\");
		string gameDataPath = "GameData";
		int check_ver_no = 3;
		Func<string, bool> AddFolderOrArchive = delegate(string name)
		{
			bool flag3 = GameUty.m_FileSystem.AddArchive(gameDataPath + "\\" + name + ".arc");
			if (flag3)
			{
				Debug.Log(string.Concat(new string[]
				{
					"[",
					gameDataPath,
					"\\",
					name,
					".arc]を読み込みました"
				}));
			}
			if (flag3)
			{
				GameUty.loadArchiveList.Add(name.ToLower());
			}
			return flag3;
		};
		HashSet<string> addedLegacyArchives = new HashSet<string>();
		Action<string> action = delegate(string name)
		{
			foreach (string text28 in GameUty.PathList)
			{
				string text29 = name + "_" + text28;
				bool flag3 = AddFolderOrArchive(text29);
				if (flag3 && !addedLegacyArchives.Contains(text29))
				{
					addedLegacyArchives.Add(text29);
				}
				if (flag3)
				{
					if (name == "csv")
					{
						GameUty.ExistCsvPathList.Add(text28);
					}
					for (int num14 = 2; num14 <= check_ver_no; num14++)
					{
						AddFolderOrArchive(text29 + "_" + num14);
					}
				}
			}
		};
		Action<string> action2 = delegate(string name)
		{
			foreach (string text28 in GameUty.PathList)
			{
				string text29 = name + "_" + text28;
				bool flag3 = AddFolderOrArchive(text29);
				if (!flag3 && addedLegacyArchives.Contains(text29))
				{
					flag3 = true;
				}
				if (flag3)
				{
					if (name == "csv")
					{
						GameUty.ExistCsvPathList.Add(text28);
					}
					for (int num14 = 2; num14 <= check_ver_no; num14++)
					{
						AddFolderOrArchive(string.Concat(new object[]
						{
							name,
							"_",
							text28,
							"_",
							num14
						}));
					}
				}
			}
		};
		Action<string> action3 = delegate(string name)
		{
			foreach (string text28 in GameUty.PathList)
			{
				if (AddFolderOrArchive(name + "_" + text28))
				{
					if (name == "csv")
					{
						GameUty.ExistCsvPathList.Add(text28);
					}
					for (int num14 = 2; num14 <= check_ver_no; num14++)
					{
						AddFolderOrArchive(string.Concat(new object[]
						{
							name,
							"_",
							text28,
							"_",
							num14
						}));
					}
				}
			}
		};
		string str = string.Empty;
		str = "必用アーカイブがありません。GameData\\";
		StopWatch stopWatch = new StopWatch();
		Debug.Log("IsEnabledCompatibilityMode:" + GameUty.IsEnabledCompatibilityMode.ToString());
		string text = "カスタムオーダーメイド3D 2";
		string str2 = "カスタムメイド3D 2";
		Debug.Log(string.Concat(new string[]
		{
			text,
			" GameVersion ",
			GameUty.GetGameVersionText(),
			"(BuildVersion : ",
			GameUty.GetBuildVersionText(),
			")"
		}));
		if (!string.IsNullOrEmpty(GameMain.Instance.CMSystem.CM3D2Path))
		{
			Debug.Log(str2 + " GameVersion " + GameUty.GetLegacyGameVersionText());
		}
		if (GameUty.IsEnabledCompatibilityMode)
		{
			Debug.Log("■■■■■■■■ Archive Log[2.0] (CM3D2 GameData) ■■■■■■■■");
			GameUty.m_FileSystem.SetBaseDirectory(GameMain.Instance.CMSystem.CM3D2Path);
			GameUty.PathList = GameUty.PathListOld;
			AddFolderOrArchive("material");
			foreach (string text2 in GameUty.PathListOld)
			{
				string str3 = "material";
				if (text2 == "denkigai2015wTowelR")
				{
					AddFolderOrArchive(str3 + "_denkigai2015wTowel");
				}
				string text3 = str3 + "_" + text2;
				bool flag = AddFolderOrArchive(text3);
				if (flag && !addedLegacyArchives.Contains(text3))
				{
					addedLegacyArchives.Add(text3);
				}
				if (flag)
				{
					for (int i2 = 2; i2 <= check_ver_no; i2++)
					{
						AddFolderOrArchive(text3 + "_" + i2);
					}
				}
			}
			AddFolderOrArchive("material2");
			AddFolderOrArchive("menu");
			action("menu");
			AddFolderOrArchive("menu2");
			AddFolderOrArchive("model");
			action("model");
			AddFolderOrArchive("model2");
			AddFolderOrArchive("texture");
			action("texture");
			AddFolderOrArchive("texture2");
			AddFolderOrArchive("texture3");
			AddFolderOrArchive("prioritymaterial");
			Debug.Log("■■■■■■■■■■■■■■■■■■■■");
		}
		Debug.Log("■■■■■■■■ Archive Log[2.1 Compatibility] (GameData_20) ■■■■■■■■");
		gameDataPath = "GameData_20";
		GameUty.m_FileSystem.SetBaseDirectory(fullPath);
		if (GameUty.IsEnabledCompatibilityMode)
		{
			GameUty.m_FileSystem.AddPatchDecryptPreferredSearchDirectory(GameMain.Instance.CMSystem.CM3D2Path + "\\GameData");
		}
		GameUty.PathList = GameUty.ReadAutoPathFile("[2.1Compatibility]", fullPath + gameDataPath + "\\paths.dat");
		if (GameUty.PathList != null && 0 < GameUty.PathList.Count)
		{
			foreach (string text4 in GameUty.PathList)
			{
				string text5 = "material";
				if (text4 == "denkigai2015wTowelR")
				{
					AddFolderOrArchive(text5 + "_denkigai2015wTowel");
				}
				string text6 = text5 + "_" + text4;
				bool flag2 = AddFolderOrArchive(text6);
				if (!flag2 && addedLegacyArchives.Contains(text6))
				{
					flag2 = true;
				}
				if (flag2)
				{
					for (int j = 2; j <= check_ver_no; j++)
					{
						AddFolderOrArchive(string.Concat(new object[]
						{
							text5,
							"_",
							text4,
							"_",
							j
						}));
					}
				}
			}
			action2("menu");
			action2("model");
			action2("texture");
			AddFolderOrArchive("prioritymaterial");
			List<string> pathList = GameUty.PathList;
			GameUty.PathList = new List<string>();
			GameUty.PathList.Add("vp001");
			action2("bg");
			action2("motion");
			GameUty.PathList = pathList;
		}
		GameUty.m_FileSystem.ClearPatchDecryptPreferredSearchDirectory();
		Debug.Log("■■■■■■■■■■■■■■■■■■■■");
		Debug.Log("■■■■■■■■ Archive Log[2.1] (GameData) ■■■■■■■■");
		gameDataPath = "GameData";
		GameUty.PathList = GameUty.ReadAutoPathFile("[2.1]", fullPath + gameDataPath + "\\paths.dat");
		if (GameUty.PathList == null)
		{
			GameUty.PathList = new List<string>();
			NDebug.Assert("paths.datを読み込めませんでした", false);
		}
		AddFolderOrArchive("csv");
		foreach (string text7 in GameUty.PathList)
		{
			string text8 = "csv";
			if (AddFolderOrArchive(text8 + "_" + text7))
			{
				for (int k = 2; k <= check_ver_no; k++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text8,
						"_",
						text7,
						"_",
						k
					}));
				}
			}
		}
		AddFolderOrArchive("prioritymaterial");
		NDebug.Assert(AddFolderOrArchive("motion"), str + "motion");
		foreach (string text9 in GameUty.PathList)
		{
			string text10 = "motion";
			if (AddFolderOrArchive(text10 + "_" + text9))
			{
				for (int l = 2; l <= check_ver_no; l++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text10,
						"_",
						text9,
						"_",
						l
					}));
				}
			}
		}
		AddFolderOrArchive("motion2");
		NDebug.Assert(AddFolderOrArchive("script"), str + "script");
		foreach (string text11 in GameUty.PathList)
		{
			string text12 = "script";
			if (AddFolderOrArchive(text12 + "_" + text11))
			{
				for (int m = 2; m <= check_ver_no; m++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text12,
						"_",
						text11,
						"_",
						m
					}));
				}
			}
		}
		AddFolderOrArchive("script_share");
		foreach (string text13 in GameUty.PathList)
		{
			string text14 = "script_share";
			if (AddFolderOrArchive(text14 + "_" + text13))
			{
				for (int n = 2; n <= check_ver_no; n++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text14,
						"_",
						text13,
						"_",
						n
					}));
				}
			}
		}
		AddFolderOrArchive("script_share2");
		NDebug.Assert(AddFolderOrArchive("sound"), str + "sound");
		foreach (string text15 in GameUty.PathList)
		{
			string text16 = "sound";
			if (AddFolderOrArchive(text16 + "_" + text15))
			{
				for (int num = 2; num <= check_ver_no; num++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text16,
						"_",
						text15,
						"_",
						num
					}));
				}
			}
		}
		AddFolderOrArchive("sound2");
		NDebug.Assert(AddFolderOrArchive("system"), str + "system");
		foreach (string text17 in GameUty.PathList)
		{
			string text18 = "system";
			if (AddFolderOrArchive(text18 + "_" + text17))
			{
				for (int num2 = 2; num2 <= check_ver_no; num2++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text18,
						"_",
						text17,
						"_",
						num2
					}));
				}
			}
		}
		AddFolderOrArchive("system2");
		AddFolderOrArchive("language");
		foreach (string text19 in GameUty.PathList)
		{
			string text20 = "language";
			if (AddFolderOrArchive(text20 + "_" + text19))
			{
				for (int num3 = 2; num3 <= check_ver_no; num3++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text20,
						"_",
						text19,
						"_",
						num3
					}));
				}
			}
		}
		foreach (string text21 in GameUty.PathList)
		{
			string text22 = "bg";
			if (AddFolderOrArchive(text22 + "_" + text21))
			{
				for (int num4 = 2; num4 <= check_ver_no; num4++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text22,
						"_",
						text21,
						"_",
						num4
					}));
				}
			}
		}
		AddFolderOrArchive("voice");
		for (int num5 = 0; num5 < 25; num5++)
		{
			string arg = "voice";
			string arg2 = arg + "_" + (char)(97 + num5);
			AddFolderOrArchive(arg2);
		}
		foreach (string text23 in GameUty.PathList)
		{
			string text24 = "voice";
			if (AddFolderOrArchive(text24 + "_" + text23))
			{
				for (int num6 = 2; num6 <= check_ver_no; num6++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text24,
						"_",
						text23,
						"_",
						num6
					}));
				}
			}
		}
		for (int num7 = 2; num7 <= check_ver_no; num7++)
		{
			string arg3 = "voice";
			AddFolderOrArchive(arg3 + num7);
		}
		string text25 = "parts";
		NDebug.Assert(AddFolderOrArchive(text25), str + text25);
		foreach (string text26 in GameUty.PathList)
		{
			if (AddFolderOrArchive(text25 + "_" + text26))
			{
				for (int num8 = 2; num8 <= check_ver_no; num8++)
				{
					AddFolderOrArchive(string.Concat(new object[]
					{
						text25,
						"_",
						text26,
						"_",
						num8
					}));
				}
			}
		}
		AddFolderOrArchive("parts2");
		Debug.Log("■■■■■■■■■■■■■■■■■■■■" + stopWatch.Stop().ToString() + " ms");
		GameUty.m_FileSystem.AddAutoPathForAllFolder();
		GameUty.BgFiles = new Dictionary<string, AFileSystemBase>();
		string[] list = GameUty.m_FileSystem.GetList("bg", AFileSystemBase.ListType.AllFile);
		if (list != null && 0 < list.Length)
		{
			foreach (string path in list)
			{
				string fileName = Path.GetFileName(path);
				if (!(Path.GetExtension(fileName) != ".asset_bg") && !GameUty.BgFiles.ContainsKey(fileName))
				{
					GameUty.BgFiles.Add(fileName, GameUty.m_FileSystem);
				}
			}
		}
		if (GameUty.supportMultiLanguage)
		{
			list = GameUty.m_FileSystem.GetList("languagesource", AFileSystemBase.ListType.AllFile);
			if (list != null && 0 < list.Length)
			{
				foreach (string path2 in list)
				{
					string fileName2 = Path.GetFileName(path2);
					if (!(Path.GetExtension(fileName2) != ".asset_language"))
					{
						if (GameUty.supportMultiLanguage || (!(fileName2 == "parts.asset_language") && !(fileName2 == "yotogi.asset_language")))
						{
							using (AFileBase afileBase = GameUty.m_FileSystem.FileOpen(fileName2))
							{
								AssetBundle assetBundle = AssetBundle.LoadFromMemory(afileBase.ReadAll());
								LanguageSource languageSource = UnityEngine.Object.Instantiate<LanguageSource>(assetBundle.LoadAllAssets<GameObject>()[0].GetComponent<LanguageSource>());
								if (GameMain.Instance.transform.Find("Language") == null)
								{
									new GameObject("Language").transform.SetParent(GameMain.Instance.transform);
								}
								languageSource.transform.SetParent(GameMain.Instance.transform.Find("Language"));
								assetBundle.Unload(true);
							}
						}
					}
				}
			}
			foreach (LanguageSource languageSource2 in LocalizationManager.Sources)
			{
				languageSource2.LoadAllLanguages(false);
			}
		}
		if (Directory.Exists(fullPath + "Mod"))
		{
			GameUty.m_ModFileSystem = new FileSystemWindows();
			GameUty.m_ModFileSystem.SetBaseDirectory(fullPath);
			GameUty.m_ModFileSystem.AddFolder("Mod");
			string[] list2 = GameUty.m_ModFileSystem.GetList(string.Empty, AFileSystemBase.ListType.AllFolder);
			foreach (string text27 in list2)
			{
				if (!GameUty.m_ModFileSystem.AddAutoPath(text27))
				{
					Debug.Log("m_ModFileSystemのAddAutoPathには既に " + text27 + " がありました。");
				}
			}
		}
		string[] fileListAtExtension = GameUty.m_FileSystem.GetFileListAtExtension(".menu");
		List<string> list3 = new List<string>();
		foreach (string path3 in fileListAtExtension)
		{
			list3.Add(Path.GetFileName(path3));
		}
		GameUty.m_aryMenuFiles = list3.ToArray();
		if (GameUty.m_ModFileSystem != null)
		{
			string[] list4 = GameUty.m_ModFileSystem.GetList(string.Empty, AFileSystemBase.ListType.AllFile);
			GameUty.m_aryModOnlysMenuFiles = Array.FindAll<string>(list4, (string i) => new Regex(".*\\.menu$").IsMatch(i));
			GameUty.m_aryMenuFiles = GameUty.m_aryMenuFiles.Concat(GameUty.m_aryModOnlysMenuFiles).ToArray<string>();
		}
		if (GameUty.m_aryModOnlysMenuFiles != null && GameUty.m_aryModOnlysMenuFiles.Length != 0)
		{
			GameUty.ModPriorityToModFolderInfo = string.Empty;
			Debug.Log(GameUty.ModPriorityToModFolderInfo + "■MOD有り。MODフォルダ優先モード" + GameUty.ModPriorityToModFolder.ToString());
		}
		if (GameUty.rid_menu_dic_.Count == 0)
		{
			string[] menuFiles = GameUty.MenuFiles;
			GameUty.rid_menu_dic_ = new Dictionary<int, string>();
			for (int num13 = 0; num13 < menuFiles.Length; num13++)
			{
				string fileName3 = Path.GetFileName(menuFiles[num13]);
				int hashCode = fileName3.ToLower().GetHashCode();
				if (!GameUty.rid_menu_dic_.ContainsKey(hashCode))
				{
					GameUty.rid_menu_dic_.Add(hashCode, fileName3);
				}
				else
				{
					NDebug.Assert(fileName3 == GameUty.rid_menu_dic_[hashCode], string.Concat(new string[]
					{
						"[",
						fileName3,
						"]と[",
						GameUty.rid_menu_dic_[hashCode],
						"]は同じハッシュキーです"
					}));
				}
			}
		}
	}

	public static void UpdateFileSystemPathOld()
	{
		if (!GameUty.IsEnabledCompatibilityMode)
		{
			return;
		}
		FileSystemArchive fileSystem = GameUty.m_FileSystemOld;
		Debug.Log("■■■■■■■■ Archive Log[Legacy]■■■■■■■■");
		Func<string, bool> AddFolderOrArchive = delegate(string name)
		{
			bool flag = fileSystem.AddArchive("GameData\\" + name + ".arc");
			if (flag)
			{
				Debug.Log("[GameData\\" + name + ".arc]を読み込みました");
			}
			return flag;
		};
		int check_ver_no = 3;
		Action<string> action = delegate(string name)
		{
			foreach (string text2 in GameUty.PathListOld)
			{
				if (AddFolderOrArchive(name + "_" + text2))
				{
					if (name == "csv")
					{
						GameUty.ExistCsvPathListOld.Add(text2);
					}
					for (int m = 2; m <= check_ver_no; m++)
					{
						AddFolderOrArchive(string.Concat(new object[]
						{
							name,
							"_",
							text2,
							"_",
							m
						}));
					}
				}
			}
		};
		fileSystem.SetBaseDirectory(GameMain.Instance.CMSystem.CM3D2Path);
		AddFolderOrArchive("csv");
		action("csv");
		AddFolderOrArchive("motion");
		action("motion");
		AddFolderOrArchive("motion2");
		AddFolderOrArchive("script");
		action("script");
		action("script_share");
		AddFolderOrArchive("script_share2");
		AddFolderOrArchive("sound");
		action("sound");
		AddFolderOrArchive("sound2");
		AddFolderOrArchive("texture");
		action("texture");
		AddFolderOrArchive("texture2");
		AddFolderOrArchive("texture3");
		AddFolderOrArchive("system");
		action("system");
		action("bg");
		AddFolderOrArchive("voice");
		AddFolderOrArchive("voice_a");
		AddFolderOrArchive("voice_b");
		AddFolderOrArchive("voice_c");
		foreach (string str in GameUty.PathListOld)
		{
			string str2 = "voice";
			string text = str2 + "_" + str;
			if (AddFolderOrArchive(text))
			{
				for (int i = 2; i <= check_ver_no; i++)
				{
					AddFolderOrArchive(text + "_" + i);
				}
			}
			text = str2 + "_" + str + "a";
			if (AddFolderOrArchive(text))
			{
				for (int j = 2; j <= check_ver_no; j++)
				{
					AddFolderOrArchive(text + "_" + j);
				}
			}
			text = str2 + "_" + str + "b";
			if (AddFolderOrArchive(text))
			{
				for (int k = 2; k <= check_ver_no; k++)
				{
					AddFolderOrArchive(text + "_" + k);
				}
			}
		}
		AddFolderOrArchive("voice2");
		AddFolderOrArchive("voice3");
		fileSystem.AddAutoPathForAllFolder();
		string[] list = fileSystem.GetList("bg", AFileSystemBase.ListType.AllFile);
		if (list != null && 0 < list.Length)
		{
			foreach (string path in list)
			{
				string fileName = Path.GetFileName(path);
				if (!(Path.GetExtension(fileName) != ".asset_bg") && !GameUty.BgFiles.ContainsKey(fileName))
				{
					GameUty.BgFiles.Add(fileName, fileSystem);
				}
			}
		}
		Debug.Log("■■■■■■■■■■■■■■■■■■■■");
	}

	public static AFileBase FileOpen(string fileName, AFileSystemBase priorityFileSystem = null)
	{
		if (priorityFileSystem == null)
		{
			priorityFileSystem = GameUty.m_FileSystem;
		}
		AFileSystemBase[] array;
		if (GameUty.ModPriorityToModFolder)
		{
			array = new AFileSystemBase[]
			{
				GameUty.m_ModFileSystem,
				priorityFileSystem
			};
		}
		else
		{
			array = new AFileSystemBase[]
			{
				priorityFileSystem,
				GameUty.m_ModFileSystem
			};
		}
		AFileBase result = null;
		foreach (AFileSystemBase afileSystemBase in array)
		{
			if (afileSystemBase != null && afileSystemBase.IsExistentFile(fileName))
			{
				result = afileSystemBase.FileOpen(fileName);
				break;
			}
		}
		return result;
	}

	public static bool IsExistFile(string fileName, AFileSystemBase priorityFileSystem = null)
	{
		if (priorityFileSystem == null)
		{
			priorityFileSystem = GameUty.m_FileSystem;
		}
		AFileSystemBase[] array;
		if (GameUty.ModPriorityToModFolder)
		{
			array = new AFileSystemBase[]
			{
				GameUty.m_ModFileSystem,
				priorityFileSystem
			};
		}
		else
		{
			array = new AFileSystemBase[]
			{
				priorityFileSystem,
				GameUty.m_ModFileSystem
			};
		}
		foreach (AFileSystemBase afileSystemBase in array)
		{
			if (afileSystemBase != null && afileSystemBase.IsExistentFile(fileName))
			{
				return true;
			}
		}
		return false;
	}

	public static string GetBuildVersionText()
	{
		int num = 1260;
		return (num >= 1000) ? ((float)num / 1000f).ToString("F2") : ((float)num / 100f).ToString("F2");
	}

	public static string GetGameVersionText()
	{
		string text = "COM3D2x64.exe";
		int num = 1260;
		string path = Path.GetFullPath(".\\") + "update.lst";
		string[] array = new string[0];
		if (File.Exists(path))
		{
			try
			{
				array = File.ReadAllLines(path, Encoding.GetEncoding("utf-8"));
			}
			catch (Exception ex)
			{
				Debug.LogError(ex.Message);
				array = new string[0];
			}
		}
		foreach (string text2 in array)
		{
			if (!string.IsNullOrEmpty(text2))
			{
				string[] array3 = text2.Split(new char[]
				{
					','
				});
				if (array3 != null && array3.Length == 2 && array3[0].Trim().ToLower() == text.ToLower())
				{
					int.TryParse(array3[1].Trim(), out num);
					break;
				}
			}
		}
		string text3 = (num >= 1000) ? ((float)num / 1000f).ToString("F3") : ((float)num / 100f).ToString("F3");
		if (text3.Length == 5)
		{
			text3 = text3.Insert(4, ".");
		}
		return text3;
	}

	public static string GetLegacyGameVersionText()
	{
		if (!GameUty.IsEnabledCompatibilityMode)
		{
			return "0.0";
		}
		string text = "CM3D2x64.exe";
		string path = GameMain.Instance.CMSystem.CM3D2Path + "\\update.lst";
		string[] array = new string[0];
		if (File.Exists(path))
		{
			try
			{
				array = File.ReadAllLines(path, Encoding.GetEncoding("utf-8"));
			}
			catch (Exception ex)
			{
				Debug.LogError(ex.Message);
				array = new string[0];
			}
		}
		int num = 0;
		foreach (string text2 in array)
		{
			if (!string.IsNullOrEmpty(text2))
			{
				string[] array3 = text2.Split(new char[]
				{
					','
				});
				if (array3 != null && array3.Length == 2 && array3 != null && array3.Length == 2 && array3[0].Trim().ToLower() == text.ToLower())
				{
					int.TryParse(array3[1].Trim(), out num);
					break;
				}
			}
		}
		string text3 = (num >= 1000) ? ((float)num / 1000f).ToString("F3") : ((float)num / 100f).ToString("F3");
		if (text3.Length == 5)
		{
			text3 = text3.Insert(4, ".");
		}
		return text3;
	}

	private static FileSystemArchive m_FileSystem = null;

	private static FileSystemArchive m_FileSystemOld = null;

	private static FileSystemWindows m_ModFileSystem = null;

	public static List<string> PathList = new List<string>();

	public static List<string> ExistCsvPathList = new List<string>();

	public static List<string> PathListOld = new List<string>();

	public static List<string> ExistCsvPathListOld = new List<string>();

	private static string[] m_aryMenuFiles = null;

	private static string[] m_aryModOnlysMenuFiles = new string[0];

	private static Dictionary<int, string> rid_menu_dic_ = new Dictionary<int, string>();

	private static Dictionary<string, AssetBundle> asset_bundle_dic = new Dictionary<string, AssetBundle>();

	private static string ModPriorityToModFolderInfo = "以下のフラグをtrueにするとMODフォルダのファイルが優先されるが、モザイクも安易に外すことが可能になる為に現在はオミット。";

	public static bool ModPriorityToModFolder = false;

	private static string[] m_strSystemMaterialName = new string[]
	{
		"System/Material/2dAlpha",
		"System/Material/2dMultiply",
		"System/Material/InfinityColor",
		"System/Material/TexTo8bitTex"
	};

	private static Material[] m_matSystem = new Material[4];

	public enum SystemMaterial
	{
		Alpha,
		Multiply,
		InfinityColor,
		TexTo8bitTex,
		Max
	}
}