diff options
Diffstat (limited to 'Client/Assembly-CSharp/PowerTools')
5 files changed, 689 insertions, 0 deletions
diff --git a/Client/Assembly-CSharp/PowerTools/SpriteAnim.cs b/Client/Assembly-CSharp/PowerTools/SpriteAnim.cs new file mode 100644 index 0000000..863854e --- /dev/null +++ b/Client/Assembly-CSharp/PowerTools/SpriteAnim.cs @@ -0,0 +1,255 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; + +namespace PowerTools +{ + [RequireComponent(typeof(Animator))] + [DisallowMultipleComponent] + public class SpriteAnim : SpriteAnimEventHandler + { + public bool Playing + { + get + { + return this.IsPlaying(null); + } + } + + public bool Paused + { + get + { + return this.IsPaused(); + } + set + { + if (value) + { + this.Pause(); + return; + } + this.Resume(); + } + } + + public float Speed + { + get + { + return this.m_speed; + } + set + { + this.SetSpeed(value); + } + } + + public float Time + { + get + { + return this.GetTime(); + } + set + { + this.SetTime(value); + } + } + + public float NormalizedTime + { + get + { + return this.GetNormalisedTime(); + } + set + { + this.SetNormalizedTime(value); + } + } + + public AnimationClip Clip + { + get + { + return this.m_currAnim; + } + } + + public string ClipName + { + get + { + if (!(this.m_currAnim != null)) + { + return string.Empty; + } + return this.m_currAnim.name; + } + } + + private static readonly string STATE_NAME = "a"; + + private static readonly string CONTROLLER_PATH = "SpriteAnimController"; + + [SerializeField] + private AnimationClip m_defaultAnim; + + private static RuntimeAnimatorController m_sharedAnimatorController = null; + + private Animator m_animator; + + private AnimatorOverrideController m_controller; + + private SpriteAnimNodes m_nodes; + + private List<KeyValuePair<AnimationClip, AnimationClip>> m_clipPairList = new List<KeyValuePair<AnimationClip, AnimationClip>>(1); + + private AnimationClip m_currAnim; + + private float m_speed = 1f; + + public void Play(AnimationClip anim = null, float speed = 1f) + { + if (anim == null) + { + anim = (this.m_currAnim ? this.m_currAnim : this.m_defaultAnim); + if (anim == null) + { + return; + } + } + if (!this.m_animator.enabled) + { + this.m_animator.enabled = true; + } + if (this.m_nodes != null) + { + this.m_nodes.Reset(); + } + this.m_clipPairList[0] = new KeyValuePair<AnimationClip, AnimationClip>(this.m_clipPairList[0].Key, anim); + this.m_controller.ApplyOverrides(this.m_clipPairList); + this.m_animator.Update(0f); + this.m_animator.Play(SpriteAnim.STATE_NAME, 0, 0f); + this.m_speed = Mathf.Max(0f, speed); + this.m_animator.speed = this.m_speed; + this.m_currAnim = anim; + this.m_animator.Update(0f); + } + + public void Stop() + { + this.m_animator.enabled = false; + } + + public void Pause() + { + this.m_animator.speed = 0f; + } + + public void Resume() + { + this.m_animator.speed = this.m_speed; + } + + public AnimationClip GetCurrentAnimation() + { + return this.m_currAnim; + } + + public bool IsPlaying(AnimationClip clip = null) + { + return (clip == null || this.m_currAnim == clip) && this.m_animator.GetCurrentAnimatorStateInfo(0).normalizedTime < 1f; + } + + public bool IsPlaying(string animName) + { + return !(this.m_currAnim == null) && this.m_currAnim.name == animName && this.m_animator.GetCurrentAnimatorStateInfo(0).normalizedTime < 1f; + } + + public bool IsPaused() + { + return !(this.m_currAnim == null) && this.m_animator.speed == 0f; + } + + public void SetSpeed(float speed) + { + this.m_speed = Mathf.Max(0f, speed); + this.m_animator.speed = this.m_speed; + } + + public float GetSpeed() + { + return this.m_speed; + } + + public float GetTime() + { + if (this.m_currAnim != null) + { + return this.m_animator.GetCurrentAnimatorStateInfo(0).normalizedTime * this.m_currAnim.length; + } + return 0f; + } + + public void SetTime(float time) + { + if (this.m_currAnim == null || this.m_currAnim.length <= 0f) + { + return; + } + this.SetNormalizedTime(time / this.m_currAnim.length); + } + + public float GetNormalisedTime() + { + if (this.m_currAnim != null) + { + return this.m_animator.GetCurrentAnimatorStateInfo(0).normalizedTime; + } + return 0f; + } + + public void SetNormalizedTime(float ratio) + { + if (this.m_currAnim == null) + { + return; + } + this.m_animator.Play(SpriteAnim.STATE_NAME, 0, this.m_currAnim.isLooping ? Mathf.Repeat(ratio, 1f) : Mathf.Clamp01(ratio)); + } + + private void Awake() + { + this.m_controller = new AnimatorOverrideController(); + if (SpriteAnim.m_sharedAnimatorController == null) + { + SpriteAnim.m_sharedAnimatorController = Resources.Load<RuntimeAnimatorController>(SpriteAnim.CONTROLLER_PATH); + } + this.m_controller.runtimeAnimatorController = SpriteAnim.m_sharedAnimatorController; + this.m_animator = base.GetComponent<Animator>(); + this.m_animator.runtimeAnimatorController = this.m_controller; + this.m_controller.GetOverrides(this.m_clipPairList); + this.Play(this.m_defaultAnim, 1f); + this.m_nodes = base.GetComponent<SpriteAnimNodes>(); + } + + private void Reset() + { + if (base.GetComponent<RectTransform>() == null) + { + if (base.GetComponent<Sprite>() == null) + { + base.gameObject.AddComponent<SpriteRenderer>(); + return; + } + } + else if (base.GetComponent<Image>() == null) + { + base.gameObject.AddComponent<Image>(); + } + } + } +} diff --git a/Client/Assembly-CSharp/PowerTools/SpriteAnimEventHandler.cs b/Client/Assembly-CSharp/PowerTools/SpriteAnimEventHandler.cs new file mode 100644 index 0000000..b97b8c2 --- /dev/null +++ b/Client/Assembly-CSharp/PowerTools/SpriteAnimEventHandler.cs @@ -0,0 +1,111 @@ +using System; +using UnityEngine; + +namespace PowerTools +{ + [DisallowMultipleComponent] + public class SpriteAnimEventHandler : MonoBehaviour + { + private string m_eventWithObjectMessage; + + private object m_eventWithObjectData; + + public static class EventParser + { + public static readonly char MESSAGE_DELIMITER = '\t'; + + public static readonly string MESSAGE_NOPARAM = "_Anim"; + + public static readonly string MESSAGE_INT = "_AnimInt"; + + public static readonly string MESSAGE_FLOAT = "_AnimFloat"; + + public static readonly string MESSAGE_STRING = "_AnimString"; + + public static readonly string MESSAGE_OBJECT_FUNCNAME = "_AnimObjectFunc"; + + public static readonly string MESSAGE_OBJECT_DATA = "_AnimObjectData"; + + public static int ParseInt(ref string messageString) + { + int num = messageString.IndexOf(SpriteAnimEventHandler.EventParser.MESSAGE_DELIMITER); + int result = 0; + int.TryParse(messageString.Substring(num + 1), out result); + messageString = messageString.Substring(0, num); + return result; + } + + public static float ParseFloat(ref string messageString) + { + int num = messageString.IndexOf(SpriteAnimEventHandler.EventParser.MESSAGE_DELIMITER); + float result = 0f; + float.TryParse(messageString.Substring(num + 1), out result); + messageString = messageString.Substring(0, num); + return result; + } + + public static string ParseString(ref string messageString) + { + int num = messageString.IndexOf(SpriteAnimEventHandler.EventParser.MESSAGE_DELIMITER); + string result = messageString.Substring(num + 1); + messageString = messageString.Substring(0, num); + return result; + } + } + + private void _Anim(string function) + { + base.SendMessageUpwards(function, SendMessageOptions.DontRequireReceiver); + } + + private void _AnimInt(string messageString) + { + int num = SpriteAnimEventHandler.EventParser.ParseInt(ref messageString); + base.SendMessageUpwards(messageString, num, SendMessageOptions.DontRequireReceiver); + } + + private void _AnimFloat(string messageString) + { + float num = SpriteAnimEventHandler.EventParser.ParseFloat(ref messageString); + base.SendMessageUpwards(messageString, num, SendMessageOptions.DontRequireReceiver); + } + + private void _AnimString(string messageString) + { + string value = SpriteAnimEventHandler.EventParser.ParseString(ref messageString); + base.SendMessageUpwards(messageString, value, SendMessageOptions.DontRequireReceiver); + } + + private void _AnimObjectFunc(string funcName) + { + if (this.m_eventWithObjectData != null) + { + base.SendMessageUpwards(funcName, this.m_eventWithObjectData, SendMessageOptions.DontRequireReceiver); + this.m_eventWithObjectMessage = null; + this.m_eventWithObjectData = null; + return; + } + if (!string.IsNullOrEmpty(this.m_eventWithObjectMessage)) + { + Debug.LogError("Animation event with object parameter had no object"); + } + this.m_eventWithObjectMessage = funcName; + } + + private void _AnimObjectData(UnityEngine.Object data) + { + if (!string.IsNullOrEmpty(this.m_eventWithObjectMessage)) + { + base.SendMessageUpwards(this.m_eventWithObjectMessage, data, SendMessageOptions.DontRequireReceiver); + this.m_eventWithObjectMessage = null; + this.m_eventWithObjectData = null; + return; + } + if (this.m_eventWithObjectData != null) + { + Debug.LogError("Animation event with object parameter had no object"); + } + this.m_eventWithObjectData = data; + } + } +} diff --git a/Client/Assembly-CSharp/PowerTools/SpriteAnimNodeSync.cs b/Client/Assembly-CSharp/PowerTools/SpriteAnimNodeSync.cs new file mode 100644 index 0000000..e5fad22 --- /dev/null +++ b/Client/Assembly-CSharp/PowerTools/SpriteAnimNodeSync.cs @@ -0,0 +1,36 @@ +using System; +using UnityEngine; + +namespace PowerTools +{ + public class SpriteAnimNodeSync : MonoBehaviour + { + public int NodeId; + + public SpriteAnimNodes Parent; + + public SpriteRenderer ParentRenderer; + + public SpriteRenderer Renderer; + + public void LateUpdate() + { + if (this.Renderer && this.ParentRenderer) + { + this.Renderer.flipX = this.ParentRenderer.flipX; + } + Vector3 localPosition = base.transform.localPosition; + Vector3 localPosition2 = this.Parent.GetLocalPosition(this.NodeId, false); + localPosition.x = localPosition2.x; + localPosition.y = localPosition2.y; + base.transform.localPosition = localPosition; + float angle = this.Parent.GetAngle(this.NodeId); + if (!this.Renderer || !this.Renderer.flipX) + { + base.transform.eulerAngles = new Vector3(0f, 0f, angle); + return; + } + base.transform.eulerAngles = new Vector3(0f, 0f, -angle); + } + } +} diff --git a/Client/Assembly-CSharp/PowerTools/SpriteAnimNodes.cs b/Client/Assembly-CSharp/PowerTools/SpriteAnimNodes.cs new file mode 100644 index 0000000..2669ac1 --- /dev/null +++ b/Client/Assembly-CSharp/PowerTools/SpriteAnimNodes.cs @@ -0,0 +1,232 @@ +using System; +using UnityEngine; + +namespace PowerTools +{ + public class SpriteAnimNodes : MonoBehaviour + { + public static readonly int NUM_NODES = 10; + + [SerializeField] + [HideInInspector] + private Vector2 m_node0 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node1 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node2 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node3 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node4 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node5 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node6 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node7 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node8 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private Vector2 m_node9 = Vector2.zero; + + [SerializeField] + [HideInInspector] + private float m_ang0; + + [SerializeField] + [HideInInspector] + private float m_ang1; + + [SerializeField] + [HideInInspector] + private float m_ang2; + + [SerializeField] + [HideInInspector] + private float m_ang3; + + [SerializeField] + [HideInInspector] + private float m_ang4; + + [SerializeField] + [HideInInspector] + private float m_ang5; + + [SerializeField] + [HideInInspector] + private float m_ang6; + + [SerializeField] + [HideInInspector] + private float m_ang7; + + [SerializeField] + [HideInInspector] + private float m_ang8; + + [SerializeField] + [HideInInspector] + private float m_ang9; + + private SpriteRenderer m_spriteRenderer; + + public Vector3 GetPosition(int nodeId, bool ignoredPivot = false) + { + if (this.m_spriteRenderer == null) + { + this.m_spriteRenderer = base.GetComponent<SpriteRenderer>(); + } + if (this.m_spriteRenderer == null || this.m_spriteRenderer.sprite == null) + { + return Vector2.zero; + } + Vector3 vector = this.GetLocalPosition(nodeId, ignoredPivot); + vector = base.transform.rotation * vector; + vector.Scale(base.transform.lossyScale); + return vector + base.transform.position; + } + + public Vector3 GetLocalPosition(int nodeId, bool ignoredPivot = false) + { + if (this.m_spriteRenderer == null) + { + this.m_spriteRenderer = base.GetComponent<SpriteRenderer>(); + } + if (this.m_spriteRenderer == null || this.m_spriteRenderer.sprite == null) + { + return Vector2.zero; + } + Vector3 vector = this.GetPositionRaw(nodeId); + vector.y = -vector.y; + if (ignoredPivot) + { + vector += this.m_spriteRenderer.sprite.rect.size * 0.5f - this.m_spriteRenderer.sprite.pivot; + } + vector *= 1f / this.m_spriteRenderer.sprite.pixelsPerUnit; + if (this.m_spriteRenderer.flipX) + { + vector.x = -vector.x; + } + if (this.m_spriteRenderer.flipY) + { + vector.y = -vector.y; + } + return vector; + } + + public float GetAngle(int nodeId) + { + float angleRaw = this.GetAngleRaw(nodeId); + if (this.m_spriteRenderer == null) + { + this.m_spriteRenderer = base.GetComponent<SpriteRenderer>(); + } + if (this.m_spriteRenderer == null || this.m_spriteRenderer.sprite == null) + { + return 0f; + } + return angleRaw + base.transform.eulerAngles.z; + } + + public Vector2 GetPositionRaw(int nodeId) + { + switch (nodeId) + { + case 0: + return this.m_node0; + case 1: + return this.m_node1; + case 2: + return this.m_node2; + case 3: + return this.m_node3; + case 4: + return this.m_node4; + case 5: + return this.m_node5; + case 6: + return this.m_node6; + case 7: + return this.m_node7; + case 8: + return this.m_node8; + case 9: + return this.m_node9; + default: + return Vector2.zero; + } + } + + public float GetAngleRaw(int nodeId) + { + switch (nodeId) + { + case 0: + return this.m_ang0; + case 1: + return this.m_ang1; + case 2: + return this.m_ang2; + case 3: + return this.m_ang3; + case 4: + return this.m_ang4; + case 5: + return this.m_ang5; + case 6: + return this.m_ang6; + case 7: + return this.m_ang7; + case 8: + return this.m_ang8; + case 9: + return this.m_ang9; + default: + return 0f; + } + } + + public void Reset() + { + this.m_node0 = Vector2.zero; + this.m_node1 = Vector2.zero; + this.m_node2 = Vector2.zero; + this.m_node3 = Vector2.zero; + this.m_node4 = Vector2.zero; + this.m_node5 = Vector2.zero; + this.m_node6 = Vector2.zero; + this.m_node7 = Vector2.zero; + this.m_node8 = Vector2.zero; + this.m_node9 = Vector2.zero; + this.m_ang0 = 0f; + this.m_ang1 = 0f; + this.m_ang2 = 0f; + this.m_ang3 = 0f; + this.m_ang4 = 0f; + this.m_ang5 = 0f; + this.m_ang6 = 0f; + this.m_ang7 = 0f; + this.m_ang8 = 0f; + this.m_ang9 = 0f; + } + } +} diff --git a/Client/Assembly-CSharp/PowerTools/WaitForAnimationFinish.cs b/Client/Assembly-CSharp/PowerTools/WaitForAnimationFinish.cs new file mode 100644 index 0000000..f4f083c --- /dev/null +++ b/Client/Assembly-CSharp/PowerTools/WaitForAnimationFinish.cs @@ -0,0 +1,55 @@ +using System; +using System.Collections; +using UnityEngine; + +namespace PowerTools +{ + public class WaitForAnimationFinish : IEnumerator + { + public object Current + { + get + { + return null; + } + } + + private SpriteAnim animator; + + private AnimationClip clip; + + private bool first = true; + + public WaitForAnimationFinish(SpriteAnim animator, AnimationClip clip) + { + this.animator = animator; + this.clip = clip; + this.animator.Play(this.clip, 1f); + } + + public bool MoveNext() + { + if (this.first) + { + this.first = false; + return true; + } + bool result; + try + { + result = this.animator.IsPlaying(this.clip); + } + catch + { + result = false; + } + return result; + } + + public void Reset() + { + this.first = true; + this.animator.Play(this.clip, 1f); + } + } +} |