PlayerAnimation.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Timers;
using UnityEngine;
using _Game.Scripts.Scriptable_Object;

public class PlayerAnimation : MonoBehaviour
{
	[Header("Scaling")] public AnimationCurve m_AirScale;
	public bool m_ScalingActive = true;
	public float m_Time = 10f;
	public float m_SizePerCharge = 0.2f;
	private Vector3 m_OriginScale;
	private int m_PreviousAirCharges = 0;
	private int m_CurrentAirCharges = 0;

	[Header("Rotation")] public float m_Speed = 3f;
	public bool m_RotationActive = false;
	public float m_Radius = 1f;
	public float m_RadiusSinDifference = 0.3f;
	public float m_MaxScale = 0.3f;
	public GameObject m_ElementPrefab;
	public Transform m_ElementOrbParent;
	public Transform m_RotationOrigin;
	public Vector2 m_RotationOriginOffset;
	public Sprite m_AirSprite;
	public Sprite m_EarthSprite;
	public Sprite m_FireSprite;
	public Sprite m_WaterSprite;
	private List<GameObject> m_ElementOrbTransforms;
	private List<SpriteRenderer> m_ElementOrbRenderer;
	private float m_TimeCounter = 0;


	[Header("References")] [SerializeField]
	private PlayerState r_State;

	[SerializeField] private MovementController r_Controller;
	[SerializeField] private CapsuleCollider2D r_Collider2D;

	private bool m_isAnimating = false;
	private bool m_isRotating = false;



	// Start is called before the first frame update
	void Start()
	{
		r_Controller = GetComponent<MovementController>();
		r_Collider2D = GetComponent<CapsuleCollider2D>();

		m_OriginScale = transform.localScale;

		m_ElementOrbTransforms = new List<GameObject>();
		m_ElementOrbRenderer = new List<SpriteRenderer>();

		float dis = 360 / 5; //need fix later
		for (int i = 0; i < 5; i++)
		{
			GameObject obj = Instantiate(m_ElementPrefab, transform);
			obj.SetActive(false);
			m_ElementOrbTransforms.Add(obj);
			m_ElementOrbRenderer.Add(obj.GetComponent<SpriteRenderer>());
			float x = Mathf.Cos(i * Mathf.Deg2Rad * dis) * m_Radius;
			float y = Mathf.Sin(i * Mathf.Deg2Rad * dis) * m_Radius;
			Vector3 offset = m_RotationOriginOffset;
			m_ElementOrbTransforms[i].transform.position = (m_RotationOrigin.position + offset + new Vector3(x, y, 0f));
		}
	}

	public void OnChargesChange()
	{
		switch (r_State.GetCurrentElement())
		{
			case InfusedElement.None:
				if(m_ScalingActive)ScaleReset();

				if (m_RotationActive)
				{
					m_isRotating = false;
					SetRotationOrbsActive(false, 5);
				}

				break;
			case InfusedElement.Air:
				m_CurrentAirCharges = r_State.GetCharges();
				if (m_ScalingActive) ScalePlayer();

				/*if(m_isRotating) {
					SetRotationOrbsActive(true, r_State.GetCharges());
					SetRotationOrbSprite(m_AirSprite);
					if (!m_isRotating)
					{
						m_isRotating = true;
						StartCoroutine(RotatingElements());
					}
				}*/
				break;
			case InfusedElement.Fire:
				if(m_ScalingActive)ScaleReset();

				if (m_isRotating)
				{
					SetRotationOrbsActive(true, r_State.GetCharges());
					SetRotationOrbSprite(m_FireSprite);
					if (!m_isRotating)
					{
						m_isRotating = true;
						StartCoroutine(RotatingElements());
					}
				}

				break;
			case InfusedElement.Earth:
				if(m_ScalingActive)ScaleReset();

				if (m_isRotating)
				{
					SetRotationOrbsActive(true, r_State.GetCharges());
					SetRotationOrbSprite(m_EarthSprite);
					if (!m_isRotating)
					{
						m_isRotating = true;
						StartCoroutine(RotatingElements());
					}
				}

				break;
			case InfusedElement.Water:
				if(m_ScalingActive)ScaleReset();

				if (m_isRotating)
				{
					SetRotationOrbsActive(true, r_State.GetCharges());
					SetRotationOrbSprite(m_WaterSprite);
					if (!m_isRotating)
					{
						m_isRotating = true;
						StartCoroutine(RotatingElements());
					}
				}

				break;
		}
	}

	public void ScalePlayer()
	{
		 m_CurrentAirCharges = r_State.GetCharges();
		int diff = m_CurrentAirCharges - m_PreviousAirCharges;
		//Debug.Log("current: " + currentCharges + " previous: " + m_PreviousCharges + " difference: " + diff);
		if (!m_isAnimating || m_isAnimating)
		{
			if (diff > 0)
			{
				StartCoroutine(ScaleUp(m_PreviousAirCharges, m_CurrentAirCharges));
			}
			else
			{
				StartCoroutine(ScaleDown(m_PreviousAirCharges, m_CurrentAirCharges));
			}
		}

		m_PreviousAirCharges = m_CurrentAirCharges;
	}

	private void ScaleReset()
	{
		Vector3 s = m_OriginScale;
		s.x *= Mathf.Sign(transform.localScale.x);
		transform.localScale = s;
	}

	private IEnumerator ScaleUp(int from, int to)
	{
		/*m_isAnimating = true;
		Vector3 s = transform.localScale;
		float step = 1 / m_Time;
		float timer = 0.0f;
		float x = 0f;
		float diff = to - from;
		while (timer <= m_Time)
		{
			x = m_SizePerCharge * Mathf.Abs(diff);
			transform.localScale = Vector3.Lerp(s, s + new Vector3(x * Mathf.Sign(transform.localScale.x), x, x),
				m_AirScale.Evaluate(timer / m_Time));
			timer += Time.deltaTime;
			yield return null;
		}

		transform.localScale = s + new Vector3(x * Mathf.Sign(transform.localScale.x), x, x);
		m_isAnimating = false;*/

		m_isAnimating = true;
		float step = 1 / m_Time;
		float timer = 0.0f;
		while (timer <= m_Time)
		{
			float newSize = m_SizePerCharge * Mathf.Abs((to - from));
			transform.localScale = Vector3.Lerp(transform.localScale, transform.localScale + new Vector3(newSize * Mathf.Sign(transform.localScale.x), newSize, newSize),
				m_AirScale.Evaluate(timer / m_Time));
			timer += Time.deltaTime;
			yield return new WaitForFixedUpdate();
		}

		m_isAnimating = false;
	}

	private IEnumerator ScaleDown(int from, int to)
	{
		/*m_isAnimating = true;
		Vector3 s = transform.localScale;
		float step = 1 / m_Time;
		float timer = 0.0f;
		float x = 0;
		float diff = to - from;
		while (timer <= m_Time)
		{
			x = m_SizePerCharge * Mathf.Abs(diff);
			transform.localScale = Vector3.Lerp(s, s - new Vector3(x * Mathf.Sign(transform.localScale.x), x, x),
				m_AirScale.Evaluate(timer / m_Time));
			timer += Time.deltaTime;
			yield return null;
		}

		if (r_State.GetCharges() > 0)
		{
			transform.localScale = s - new Vector3(x * Mathf.Sign(transform.localScale.x), x, x);
		}
		else
		{
			ScaleReset();
		}

		m_isAnimating = false;*/

		m_isAnimating = true;
		float step = 1 / m_Time;
		float timer = 0.0f;
		while (timer <= m_Time)
		{
			float newSize = m_SizePerCharge * Mathf.Abs((to - from));
			transform.localScale = Vector3.Lerp(transform.localScale, transform.localScale - new Vector3(newSize * Mathf.Sign(transform.localScale.x), newSize, newSize),
				m_AirScale.Evaluate(timer / m_Time));
			timer += Time.deltaTime;
			yield return new WaitForFixedUpdate();
		}

		if (r_State.GetCharges() > 0)
		{
			float  newSize = m_SizePerCharge * Mathf.Abs((to - from));
			transform.localScale = transform.localScale - new Vector3(newSize * Mathf.Sign(transform.localScale.x), newSize, newSize);
		}
		else
		{
			ScaleReset();
		}

		m_isAnimating = false;
	}

	private IEnumerator RotatingElements()
	{
		while (m_isRotating)
		{
			m_TimeCounter += Time.deltaTime * m_Speed;
			float pos = 0;
			for (int i = 0; i < m_ElementOrbTransforms.Count; i++)
			{
				pos = m_TimeCounter;
				if (r_State.GetCharges() > 0)
					pos = m_TimeCounter + i * Mathf.Deg2Rad * (360 / r_State.GetCharges());
				float r = (m_Radius - m_RadiusSinDifference) + (m_RadiusSinDifference * Mathf.Sin(m_TimeCounter));
				float x = Mathf.Cos(pos) * r;
				float y = Mathf.Sin(pos) * r;

				Vector3 offset = m_RotationOriginOffset;
				//Transform elem = m_ElementOrbTransforms[i].transform;
				m_ElementOrbTransforms[i].transform.position =
					m_RotationOrigin.position + offset + new Vector3(x, y, 0f);
				yield return new WaitForFixedUpdate();
			}
		}
	}

	private void SetRotationOrbsActive(bool value, int amount)
	{
		for (int i = 0; i < m_ElementOrbTransforms.Count; i++)
		{
			if (i < amount)
			{
				m_ElementOrbTransforms[i].SetActive(value);
			}
			else
			{
				m_ElementOrbTransforms[i].SetActive(!value);
			}
		}
	}

	private void SetRotationOrbSprite(Sprite s)
	{
		for (int i = 0; i < m_ElementOrbRenderer.Count; i++)
		{
			m_ElementOrbRenderer[i].sprite = s;
		}
	}
}