COM_Diff/Assembly-CSharp/MyRoomCustom/CreativeRoomUIPlacementMaid.cs

using System;
using System.Collections;
using System.Collections.Specialized;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace MyRoomCustom
{
	public class CreativeRoomUIPlacementMaid : MonoBehaviour
	{
		private Maid targetMaid
		{
			get
			{
				if (this.m_TargetMaid == null)
				{
					this.m_TargetMaid = this.GetMaid(true);
					if (this.m_TargetMaid == null)
					{
						this.m_TargetMaid = this.GetMaid(false);
					}
					if (this.m_TargetMaid)
					{
						this.m_TargetMaid.body0.SetBoneHitHeightY(-1000f);
					}
				}
				return this.m_TargetMaid;
			}
		}

		private Maid GetMaid(bool searchLeader = true)
		{
			if (this.m_CharaMgr == null)
			{
				return null;
			}
			Maid maid = null;
			foreach (Maid maid2 in this.m_CharaMgr.GetStockMaidList())
			{
				if (maid2 != null)
				{
					if (!searchLeader || maid2.status.leader)
					{
						maid = maid2;
						break;
					}
				}
			}
			if (maid == null)
			{
				int maidCount = this.m_CharaMgr.GetMaidCount();
				for (int i = 0; i < maidCount; i++)
				{
					Maid maid3 = this.m_CharaMgr.GetMaid(i);
					if (maid3 != null)
					{
						if (!searchLeader || maid3.status.leader)
						{
							maid = maid3;
							break;
						}
					}
				}
			}
			return maid;
		}

		public float snapValuePosition
		{
			set
			{
				if (this.m_GizmoObject == null)
				{
					return;
				}
				this.m_GizmoObject.snapValuePosition = value;
			}
		}

		private void Awake()
		{
			this.m_CharaMgr = GameMain.Instance.CharacterMgr;
			GameObject gameObject;
			if (!(gameObject = GameObject.Find("[CreativeRoomUI Placement Maid] GizmoControlObject")))
			{
				gameObject = new GameObject("[CreativeRoomUI Placement Maid] GizmoControlObject");
				GizmoObject gizmoObject = gameObject.AddComponent<GizmoObject>();
				gizmoObject.activeAxis = true;
				gizmoObject.activeRot = false;
				gizmoObject.snapValuePosition = 0.5f;
				gizmoObject.snapValueAngles = 15f;
				gizmoObject.snapValueScale = 0.1f;
				gameObject.SetActive(false);
			}
			this.m_GizmoObject = gameObject.GetComponent<GizmoObject>();
			GizmoObject gizmoObject2 = this.m_GizmoObject;
			gizmoObject2.onChangePosition = (Action<Vector3>)Delegate.Combine(gizmoObject2.onChangePosition, new Action<Vector3>(this.OnUpdateGizmoPosition));
			GizmoObject gizmoObject3 = this.m_GizmoObject;
			gizmoObject3.onChangeRotation = (Action<Quaternion>)Delegate.Combine(gizmoObject3.onChangeRotation, new Action<Quaternion>(this.OnUpdateGizmoRotation));
			GizmoObject gizmoObject4 = this.m_GizmoObject;
			gizmoObject4.onChangeScale = (Action<Vector3>)Delegate.Combine(gizmoObject4.onChangeScale, new Action<Vector3>(this.OnUpdateGizmoScale));
			this.SetUpUI();
		}

		private void SetUpUI()
		{
			this.m_CachedTransformDataDic = new StringDictionary();
			this.m_InputFieldPosX.contentType = InputField.ContentType.DecimalNumber;
			this.m_InputFieldPosY.contentType = InputField.ContentType.DecimalNumber;
			this.m_InputFieldPosZ.contentType = InputField.ContentType.DecimalNumber;
			this.m_InputFieldRotX.contentType = InputField.ContentType.DecimalNumber;
			this.m_InputFieldRotY.contentType = InputField.ContentType.DecimalNumber;
			this.m_InputFieldRotZ.contentType = InputField.ContentType.DecimalNumber;
			this.m_InputFieldScale.contentType = InputField.ContentType.DecimalNumber;
			this.m_InputFieldPosX.text = this.m_GizmoObject.position.x.ToString("f3");
			this.m_InputFieldPosY.text = this.m_GizmoObject.position.y.ToString("f3");
			this.m_InputFieldPosZ.text = this.m_GizmoObject.position.z.ToString("f3");
			this.m_InputFieldRotX.text = this.m_GizmoObject.eulerAngles.x.ToString("f3");
			this.m_InputFieldRotY.text = this.m_GizmoObject.eulerAngles.y.ToString("f3");
			this.m_InputFieldRotZ.text = this.m_GizmoObject.eulerAngles.z.ToString("f3");
			this.m_InputFieldScale.text = this.m_GizmoObject.scale.x.ToString("f3");
			this.m_SliderScale.value = this.m_GizmoObject.scale.x;
			Action<InputField, Action<float>, Action> action = delegate(InputField input, Action<float> act_change, Action act_end)
			{
				input.onValueChanged.AddListener(delegate(string str)
				{
					float obj;
					if (float.TryParse(str, out obj))
					{
						act_change(obj);
					}
				});
				input.onEndEdit.AddListener(delegate(string str)
				{
					act_end();
				});
			};
			action(this.m_InputFieldPosX, delegate(float value)
			{
				Vector3 position = this.m_GizmoObject.position;
				position.x = value;
				this.m_GizmoObject.position = position;
			}, delegate
			{
				this.m_InputFieldPosX.text = this.m_GizmoObject.position.x.ToString("f3");
			});
			action(this.m_InputFieldPosY, delegate(float value)
			{
				Vector3 position = this.m_GizmoObject.position;
				position.y = value;
				this.m_GizmoObject.position = position;
			}, delegate
			{
				this.m_InputFieldPosY.text = this.m_GizmoObject.position.y.ToString("f3");
			});
			action(this.m_InputFieldPosZ, delegate(float value)
			{
				Vector3 position = this.m_GizmoObject.position;
				position.z = value;
				this.m_GizmoObject.position = position;
			}, delegate
			{
				this.m_InputFieldPosZ.text = this.m_GizmoObject.position.z.ToString("f3");
			});
			action(this.m_InputFieldRotX, delegate(float value)
			{
				Vector3 eulerAngles = this.m_GizmoObject.eulerAngles;
				eulerAngles.x = value;
				this.m_GizmoObject.eulerAngles = eulerAngles;
			}, delegate
			{
				this.m_InputFieldRotX.text = this.m_GizmoObject.eulerAngles.x.ToString("f3");
			});
			action(this.m_InputFieldRotY, delegate(float value)
			{
				Vector3 eulerAngles = this.m_GizmoObject.eulerAngles;
				eulerAngles.y = value;
				this.m_GizmoObject.eulerAngles = eulerAngles;
			}, delegate
			{
				this.m_InputFieldRotY.text = this.m_GizmoObject.eulerAngles.y.ToString("f3");
			});
			action(this.m_InputFieldRotZ, delegate(float value)
			{
				Vector3 eulerAngles = this.m_GizmoObject.eulerAngles;
				eulerAngles.z = value;
				this.m_GizmoObject.eulerAngles = eulerAngles;
			}, delegate
			{
				this.m_InputFieldRotZ.text = this.m_GizmoObject.eulerAngles.z.ToString("f3");
			});
			action(this.m_InputFieldScale, delegate(float value)
			{
				Vector3 scale = this.m_GizmoObject.scale;
				value = Mathf.Clamp(value, this.m_SliderScale.minValue, this.m_SliderScale.maxValue);
				if (Mathf.Approximately(scale.x, value))
				{
					return;
				}
				scale.x = (scale.y = (scale.z = value));
				this.m_GizmoObject.scale = scale;
				this.m_SliderScale.value = value;
			}, delegate
			{
				this.m_InputFieldScale.text = this.m_GizmoObject.scale.x.ToString("f3");
			});
			this.m_SliderScale.onValueChanged.AddListener(delegate(float value)
			{
				if (Mathf.Approximately(this.m_GizmoObject.cachedSnapScale.x, value))
				{
					return;
				}
				this.m_GizmoObject.nonCallbackScale = Vector3.one * value;
				float x = this.m_GizmoObject.cachedSnapScale.x;
				this.m_SliderScale.value = x;
				if (!this.m_InputFieldScale.isFocused)
				{
					this.m_InputFieldScale.text = x.ToString("f3");
				}
			});
		}

		private void Update()
		{
			if (this.targetMaid == null || !this.targetMaid.Visible)
			{
				this.m_GizmoObject.gameObject.SetActive(false);
				return;
			}
			if (EventSystem.current != null)
			{
				if (NInput.GetMouseButtonDown(0))
				{
					GameObject currentSelectedGameObject = EventSystem.current.currentSelectedGameObject;
					if (EventSystem.current.IsPointerOverGameObject() && currentSelectedGameObject && currentSelectedGameObject.GetComponent<RectTransform>())
					{
						this.m_GizmoObject.gameObject.SetActive(false);
					}
				}
				else if (NInput.GetMouseButtonUp(0))
				{
					this.m_GizmoObject.gameObject.SetActive(true);
				}
			}
		}

		private void OnUpdateGizmoPosition(Vector3 position)
		{
			if (this.targetMaid != null)
			{
				this.targetMaid.transform.position = position;
				if (!this.m_InputFieldPosX.isFocused)
				{
					this.m_InputFieldPosX.text = position.x.ToString("f3");
				}
				if (!this.m_InputFieldPosY.isFocused)
				{
					this.m_InputFieldPosY.text = position.y.ToString("f3");
				}
				if (!this.m_InputFieldPosZ.isFocused)
				{
					this.m_InputFieldPosZ.text = position.z.ToString("f3");
				}
			}
		}

		private void OnUpdateGizmoRotation(Quaternion rotation)
		{
			if (this.targetMaid != null)
			{
				this.targetMaid.transform.rotation = rotation;
				Vector3 eulerAngles = rotation.eulerAngles;
				if (!this.m_InputFieldRotX.isFocused)
				{
					this.m_InputFieldRotX.text = eulerAngles.x.ToString("f3");
				}
				if (!this.m_InputFieldRotY.isFocused)
				{
					this.m_InputFieldRotY.text = eulerAngles.y.ToString("f3");
				}
				if (!this.m_InputFieldRotZ.isFocused)
				{
					this.m_InputFieldRotZ.text = eulerAngles.z.ToString("f3");
				}
			}
		}

		private void OnUpdateGizmoScale(Vector3 scale)
		{
			if (this.targetMaid != null)
			{
				this.targetMaid.transform.localScale = scale;
				if (!this.m_InputFieldScale.isFocused)
				{
					this.m_InputFieldScale.text = scale.x.ToString("f3");
				}
				this.m_SliderScale.value = scale.x;
			}
		}

		public void ButtonEvent_GizmoEnableMove()
		{
			GizmoObject gizmoObject = this.m_GizmoObject;
			gizmoObject.activeAxis = true;
			gizmoObject.activeRot = false;
		}

		public void ButtonEvent_GizmoEnableRot()
		{
			GizmoObject gizmoObject = this.m_GizmoObject;
			gizmoObject.activeAxis = false;
			gizmoObject.activeRot = true;
		}

		public void ButtonEvent_GizmoDisable()
		{
			GizmoObject gizmoObject = this.m_GizmoObject;
			gizmoObject.activeAxis = false;
			gizmoObject.activeRot = false;
		}

		public void ButtonEvent_CopyPosition()
		{
			Vector3 position = this.m_GizmoObject.position;
			string text = string.Format("{0},{1},{2}", position.x, position.y, position.z);
			this.m_CachedTransformDataDic["position"] = text.ToString();
		}

		public void ButtonEvent_PastePosition()
		{
			string text = this.m_CachedTransformDataDic["position"];
			if (string.IsNullOrEmpty(text))
			{
				Debug.Log("座標データはまだない");
				return;
			}
			string[] array = text.Split(new char[]
			{
				','
			});
			if (array.Length != 3)
			{
				Debug.LogError("position の文字数が" + array.Length + "でした");
				return;
			}
			this.m_GizmoObject.position = new Vector3(float.Parse(array[0]), float.Parse(array[1]), float.Parse(array[2]));
		}

		public void ButtonEvent_ResetPosition()
		{
			this.m_GizmoObject.position = Vector3.zero;
		}

		public void ButtonEvent_CopyRotation()
		{
			Quaternion rotation = this.m_GizmoObject.rotation;
			string text = string.Format("{0},{1},{2},{3}", new object[]
			{
				rotation.x,
				rotation.y,
				rotation.z,
				rotation.w
			});
			this.m_CachedTransformDataDic["rotation"] = text.ToString();
		}

		public void ButtonEvent_PasteRotation()
		{
			string text = this.m_CachedTransformDataDic["rotation"];
			if (string.IsNullOrEmpty(text))
			{
				Debug.Log("回転データはまだない");
				return;
			}
			string[] array = text.Split(new char[]
			{
				','
			});
			if (array.Length != 4)
			{
				Debug.LogError("rotation の文字数が" + array.Length + "でした");
				return;
			}
			this.m_GizmoObject.rotation = new Quaternion(float.Parse(array[0]), float.Parse(array[1]), float.Parse(array[2]), float.Parse(array[3]));
		}

		public void ButtonEvent_ResetRotation()
		{
			this.m_GizmoObject.rotation = Quaternion.identity;
		}

		public void ButtonEvent_CopyScale()
		{
			Vector3 scale = this.m_GizmoObject.scale;
			string text = string.Format("{0},{1},{2}", scale.x, scale.y, scale.z);
			this.m_CachedTransformDataDic["scale"] = text.ToString();
		}

		public void ButtonEvent_PasteScale()
		{
			string text = this.m_CachedTransformDataDic["scale"];
			if (string.IsNullOrEmpty(text))
			{
				Debug.Log("スケールデータはまだない");
				return;
			}
			string[] array = text.Split(new char[]
			{
				','
			});
			if (array.Length != 3)
			{
				Debug.LogError("scale の文字数が" + array.Length + "でした");
				return;
			}
			this.m_GizmoObject.scale = new Vector3(float.Parse(array[0]), float.Parse(array[1]), float.Parse(array[2]));
		}

		public void ButtonEvent_ResetScale()
		{
			this.m_GizmoObject.scale = Vector3.one;
		}

		public void ButtonEvent_CameraFocus()
		{
			Maid targetMaid = this.targetMaid;
			if (!targetMaid)
			{
				return;
			}
			if (!targetMaid.Visible)
			{
				return;
			}
			Transform bone = targetMaid.body0.GetBone("Bip01 Head");
			WfCameraMoveSupport wfCameraMoveSupport = base.GetComponent<WfCameraMoveSupport>();
			if (wfCameraMoveSupport == null)
			{
				wfCameraMoveSupport = base.gameObject.AddComponent<WfCameraMoveSupport>();
			}
			Vector3 position = bone.position;
			float distance = Mathf.Sqrt(5f) * 2f;
			Vector2 aroundAngle = new Vector2(-135f, 45f);
			wfCameraMoveSupport.StartCameraPosition(position, distance, aroundAngle);
		}

		public void ButtonEvent_VisibleMaid(bool isVisible)
		{
			if (this.m_CharaMgr.IsBusy())
			{
				return;
			}
			if (this.targetMaid == null)
			{
				return;
			}
			if (this.targetMaid.ActiveSlotNo == -1)
			{
				this.m_CharaMgr.SetActiveMaid(this.targetMaid, 0);
				this.targetMaid.AllProcPropSeqStart();
			}
			this.targetMaid.Visible = isVisible;
			if (isVisible && this.targetMaid.IsBusy)
			{
				uGUIUtility.SetActiveEventSystem(false);
				GameMain.Instance.MainCamera.FadeOut(0f, false, null, true, default(Color));
				base.StartCoroutine(this.CorMaidLoad(this.targetMaid, new Action(this.OnMaidLoadEnd)));
			}
		}

		public void ButtonEvent_ToggleSnap(bool isEnable)
		{
			if (this.m_GizmoObject)
			{
				if (isEnable)
				{
					this.m_GizmoObject.controlType = GizmoObject.ControlType.Snap;
				}
				else
				{
					this.m_GizmoObject.controlType = GizmoObject.ControlType.Default;
				}
			}
		}

		private IEnumerator CorMaidLoad(Maid targetMaid, Action actLoadEnd)
		{
			targetMaid.Visible = true;
			while (targetMaid.IsBusy)
			{
				yield return null;
			}
			actLoadEnd();
			yield break;
		}

		private void OnMaidLoadEnd()
		{
			GameMain.Instance.MainCamera.FadeIn(0.3f, false, null, true, true, default(Color));
			this.targetMaid.CrossFade("maid_stand01.anm", false, true, false, 0.5f, 1f);
			this.targetMaid.FaceAnime("通常", 0f, 0);
			this.targetMaid.EyeToCamera(Maid.EyeMoveType.目と顔を向ける, 0f);
			uGUIUtility.SetActiveEventSystem(true);
		}

		private void OnDisable()
		{
			if (this.m_GizmoObject)
			{
				this.m_GizmoObject.gameObject.SetActive(false);
			}
		}

		private void OnEnable()
		{
			if (this.m_GizmoObject && this.targetMaid != null && this.targetMaid.Visible)
			{
				this.m_GizmoObject.gameObject.SetActive(true);
			}
		}

		private void OnDestroy()
		{
			if (this.m_GizmoObject)
			{
				UnityEngine.Object.Destroy(this.m_GizmoObject);
			}
			if (this.targetMaid)
			{
				this.targetMaid.transform.position = Vector3.zero;
				this.targetMaid.transform.rotation = Quaternion.identity;
				this.targetMaid.transform.localScale = Vector3.one;
				this.targetMaid.ResetAll();
				this.targetMaid.Visible = false;
			}
		}

		[Header("座標入力欄")]
		[SerializeField]
		private InputField m_InputFieldPosX;

		[SerializeField]
		private InputField m_InputFieldPosY;

		[SerializeField]
		private InputField m_InputFieldPosZ;

		[Header("回転入力欄")]
		[SerializeField]
		private InputField m_InputFieldRotX;

		[SerializeField]
		private InputField m_InputFieldRotY;

		[SerializeField]
		private InputField m_InputFieldRotZ;

		[Header("スケール入力欄")]
		[SerializeField]
		private InputField m_InputFieldScale;

		[SerializeField]
		private Slider m_SliderScale;

		private CharacterMgr m_CharaMgr;

		private GizmoObject m_GizmoObject;

		private Maid m_TargetMaid;

		private StringDictionary m_CachedTransformDataDic;
	}
}