COM_Diff/Assembly-CSharp/DynamicBoneMgr.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using kt.Utility;
using UnityEngine;

public class DynamicBoneMgr : IDynamicBone
{
	public DynamicBoneMgr(TBody body, TBodySkin body_skin)
	{
		this.Body = body;
		this.BodySkin = body_skin;
	}

	public void UnInit()
	{
		foreach (IDynamicBone dynamicBone in this.DynamicBoneCompList)
		{
			dynamicBone.UnInit();
		}
		this.Body.RemoveDynamicBone(this);
	}

	public bool SetUpGameObject(GameObject root_object, MPN mpn)
	{
		if (mpn == MPN.body || mpn == MPN.set_body)
		{
			return false;
		}
		if (!this.Body.IsCrcBody)
		{
			return false;
		}
		this.DynamicBoneCompList.Clear();
		string text = root_object.name.Replace("_SM_", string.Empty);
		foreach (KeyValuePair<DynamicBoneMgr.BoneType, string> keyValuePair in DynamicBoneMgr.BoneTypeSearchNameDic)
		{
			DynamicBoneMgr.BoneType key = keyValuePair.Key;
			string value = keyValuePair.Value;
			Transform transform = this.SearchYureBone(root_object.transform, value, key);
			if (transform)
			{
				if (key != DynamicBoneMgr.BoneType.Hair)
				{
					if (key != DynamicBoneMgr.BoneType.Skirt)
					{
						bool flag = mpn.ToString().Contains("acc");
						Transform[] array = this.SearchYureBoneList(transform.parent, "_A_yure_", key).ToArray<Transform>();
						if (array != null && array.Length > 0)
						{
							DynamicYureBone dynamicYureBone = root_object.AddComponent<DynamicYureBone>();
							dynamicYureBone.Init(this.Body, !flag, array);
							this.LoadDynamicYureBoneSetting(dynamicYureBone, text, mpn);
						}
					}
					else
					{
						Transform parent = transform.parent;
						DynamicSkirtBone dynamicSkirtBone = ImportCM.TryLoadDynamicSkirtBone(root_object, parent, text, this.Body);
						if (dynamicSkirtBone == null)
						{
							dynamicSkirtBone = root_object.AddComponent<DynamicSkirtBone>();
							this.LoadDefaultBinary("default_skirt.psk", new Action<BinaryReader>(dynamicSkirtBone.SerializeRead));
						}
						dynamicSkirtBone.InitGameObject(root_object, this.BodySkin, parent);
						this.DynamicBoneCompList.Add(dynamicSkirtBone);
					}
				}
				else
				{
					DynamicYureBone dynamicYureBone2 = root_object.gameObject.AddComponent<DynamicYureBone>();
					Transform[] rootbones = this.SearchRootBoneList(transform.parent, "_yure_", key).ToArray<Transform>();
					dynamicYureBone2.Init(this.Body, true, rootbones);
					this.LoadDynamicYureBoneSetting(dynamicYureBone2, text, mpn);
				}
			}
		}
		if (this.DynamicBoneCompList.Count > 0)
		{
			this.Body.AddDynamicBone(this);
			return true;
		}
		return false;
	}

	private Transform SearchYureBone(Transform bone_parent, string search_name, DynamicBoneMgr.BoneType bone_type)
	{
		return bone_parent.SearchChild((Transform bone) => this.IsBoneTypeNameMatch(bone, search_name, bone_type) && !bone.name.Contains("Mune"));
	}

	private ICollection<Transform> SearchRootBoneList(Transform bone_parent, string search_name, DynamicBoneMgr.BoneType bone_type)
	{
		HashSet<Transform> hashSet = new HashSet<Transform>();
		for (int i = 0; i < bone_parent.childCount; i++)
		{
			Transform child = bone_parent.GetChild(i);
			if (this.IsBoneTypeNameMatch(child, search_name, bone_type))
			{
				hashSet.Add(child);
			}
		}
		return hashSet;
	}

	private ICollection<Transform> SearchYureBoneList(Transform bone_parent, string search_name, DynamicBoneMgr.BoneType bone_type)
	{
		HashSet<Transform> bone_list = new HashSet<Transform>();
		Transform transform = bone_parent.SearchChild((Transform child) => this.IsBoneTypeNameMatch(child, search_name, bone_type) && !bone_list.Contains(child));
		while (transform)
		{
			bone_list.Add(transform);
			transform = bone_parent.SearchChild((Transform child) => this.IsBoneTypeNameMatch(child, search_name, bone_type) && !bone_list.Contains(child));
		}
		return bone_list;
	}

	private bool IsBoneTypeNameMatch(Transform bone, string match_name, DynamicBoneMgr.BoneType bone_type)
	{
		if (!bone.name.Contains(match_name))
		{
			return false;
		}
		if (bone_type == DynamicBoneMgr.BoneType.None)
		{
			return true;
		}
		string name = bone.name;
		bool flag = name.Contains(DynamicBoneMgr.BoneTypeSearchNameDic[bone_type]);
		if (flag)
		{
			string text = DynamicBoneMgr.BoneTypeSearchNameDic[bone_type];
			foreach (KeyValuePair<DynamicBoneMgr.BoneType, string> keyValuePair in DynamicBoneMgr.BoneTypeSearchNameDic)
			{
				if (bone_type != keyValuePair.Key)
				{
					if (!text.Contains(keyValuePair.Value) && name.Contains(keyValuePair.Value))
					{
						return false;
					}
				}
			}
			return flag;
		}
		return flag;
	}

	private void LoadDynamicYureBoneSetting(DynamicYureBone yure_bone, string parts_name, MPN mpn)
	{
		string text = parts_name + ".dbconf";
		string text2 = parts_name + "_col.dbcol";
		if (!GameUty.FileSystem.IsExistentFile(text))
		{
			text = "default_" + mpn.ToString().ToLower() + ".dbconf";
			if (!GameUty.FileSystem.IsExistentFile(text))
			{
				text = "default_yure.dbconf";
			}
			this.LoadDefaultBinary(text, new Action<StreamReader>(yure_bone.Load));
		}
		else
		{
			this.LoadFile(text, new Action<StreamReader>(yure_bone.Load));
		}
		if (!GameUty.FileSystem.IsExistentFile(text2))
		{
			text2 = "default_" + mpn.ToString().ToLower() + "_col.dbcol";
			if (!GameUty.FileSystem.IsExistentFile(text2))
			{
				text2 = "default_yure_col.dbcol";
			}
			this.LoadDefaultBinary(text2, new Action<StreamReader>(yure_bone.LoadCollider));
		}
		else
		{
			this.LoadFile(text2, new Action<StreamReader>(yure_bone.LoadCollider));
		}
		yure_bone.floorPlaneColider = this.Body.crcHitFloorPlane;
		yure_bone.loadConfigFile = text;
		yure_bone.loadColliderFile = text2;
		this.DynamicBoneCompList.Add(yure_bone);
	}

	private void LoadFile(string file_name, Action<StreamReader> on_load)
	{
		using (AFileBase afileBase = GameUty.FileSystem.FileOpen(file_name))
		{
			if (afileBase.IsValid())
			{
				byte[] buffer = afileBase.ReadAll();
				using (MemoryStream memoryStream = new MemoryStream(buffer))
				{
					using (StreamReader streamReader = new StreamReader(memoryStream))
					{
						on_load(streamReader);
					}
				}
			}
			else
			{
				Debug.LogErrorFormat("{0}はありませんでした", new object[]
				{
					file_name
				});
			}
		}
	}

	private byte[] GetChacheBinary(string file_name)
	{
		byte[] array = null;
		if (DynamicBoneMgr.DefaultFileNameBinaryPair.ContainsKey(file_name))
		{
			array = DynamicBoneMgr.DefaultFileNameBinaryPair[file_name];
		}
		else
		{
			using (AFileBase afileBase = GameUty.FileSystem.FileOpen(file_name))
			{
				if (afileBase.IsValid())
				{
					array = afileBase.ReadAll();
				}
			}
			if (array == null || array.Length == 0)
			{
				Debug.LogErrorFormat("{0}は存在しません", new object[]
				{
					file_name
				});
			}
			else
			{
				DynamicBoneMgr.DefaultFileNameBinaryPair[file_name] = array;
			}
		}
		return array;
	}

	private void LoadDefaultBinary(string file_name, Action<StreamReader> on_load)
	{
		byte[] chacheBinary = this.GetChacheBinary(file_name);
		using (MemoryStream memoryStream = new MemoryStream(chacheBinary))
		{
			using (StreamReader streamReader = new StreamReader(memoryStream))
			{
				on_load(streamReader);
			}
		}
	}

	private void LoadDefaultBinary(string file_name, Action<BinaryReader> on_load)
	{
		byte[] chacheBinary = this.GetChacheBinary(file_name);
		using (MemoryStream memoryStream = new MemoryStream(chacheBinary))
		{
			using (BinaryReader binaryReader = new BinaryReader(memoryStream))
			{
				on_load(binaryReader);
			}
		}
	}

	public void PhysicsReset()
	{
		foreach (IDynamicBone dynamicBone in this.DynamicBoneCompList)
		{
			dynamicBone.PhysicsReset();
		}
	}

	public void DynamicUpdate()
	{
		foreach (IDynamicBone dynamicBone in this.DynamicBoneCompList)
		{
			dynamicBone.DynamicUpdate();
		}
	}

	private static readonly Dictionary<DynamicBoneMgr.BoneType, string> BoneTypeSearchNameDic = new Dictionary<DynamicBoneMgr.BoneType, string>
	{
		{
			DynamicBoneMgr.BoneType.Hair,
			"_yure_hair_"
		},
		{
			DynamicBoneMgr.BoneType.Skirt,
			"_yure_skirt_"
		},
		{
			DynamicBoneMgr.BoneType.Other,
			"_yure_"
		}
	};

	private TBody Body;

	private TBodySkin BodySkin;

	private List<IDynamicBone> DynamicBoneCompList = new List<IDynamicBone>();

	private static Dictionary<string, byte[]> DefaultFileNameBinaryPair = new Dictionary<string, byte[]>();

	private enum BoneType
	{
		None,
		Hair,
		Skirt,
		Other
	}
}