AvatarAnimationState.cs

Go to the documentation of this file.

using System;
using Microsoft.MixedReality.Toolkit.UI;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
 
[RequireComponent(typeof(Animator))]
public class AvatarAnimationState : MonoBehaviour 
{
        
    private Animator m_Animator;
 
    private SetNoise m_SetNoise;
 
    private NoiseController m_NoiseController;
 
    private int m_NoiseIndex;        
 
    private TextMeshPro m_NoiseDataPanelTitle;
 
    private string m_NoisePatternLbl = "Pink";
 
    private bool m_IsAnimationLocked = false;
 
    private const float m_DefaultAnimationSpeed = 1.0f;
 
    [SerializeField] private GameObject m_DialogPrefabMedium = null;
 
    private bool m_IdleElementFlag = false;
 
    private int m_Counter = 1;
 
    private List<float> m_AnimationLength = null;
 
    private Dictionary<string, float> m_OriginalAnimationLength;
 
    public List<float> AnimationLength { get => m_AnimationLength; }
 
    void Awake() 
    {
        m_Animator = GetComponent<Animator>();       
        m_SetNoise = GameObject.Find("NoiseController").GetComponent<SetNoise>();
        m_NoiseDataPanelTitle = GameObject.FindGameObjectWithTag("NoiseDataPanelTitle").GetComponent<TextMeshPro>();
        m_NoiseController = GameObject.Find("NoiseController").GetComponent<NoiseController>();
        m_AnimationLength = new List<float>();
    }
 
    private void Start()
    {        
        m_OriginalAnimationLength = new Dictionary<string, float>();
        StoreAnimationClipsLength();
        m_NoiseIndex = 0;
    }
 
    private void Update() 
    {
        
        // Check the player is moving or not.
        var playerMoving = CamMovementTracker.m_CamTrackerInstance.IsMoving;       
        m_Animator.SetBool("IsWalking", playerMoving);
        m_Animator.SetInteger("NoiseLvl", (int)m_SetNoise.GetNoisePattern());
 
        if( m_NoiseController.BaseNoise.NoiseAppliedFlag == true )
        {
            ApplyCorrectNoisePattern();            
        }
        else
        {
            m_IsAnimationLocked = false;
            m_Animator.speed = m_DefaultAnimationSpeed;            
        }
 
        // TODO Future work is needed to change the avatar speed.
        // m_Animator.speed = CamMovementTracker.m_CamTrackerInstance.Speed;                
    }
 
    private void ApplyCorrectNoisePattern()
    {
        if( m_Animator.GetCurrentAnimatorStateInfo(0).IsName("Joel_PGN") )
        {
            ResetNoiseAfterEnd( m_NoiseController.BaseNoise.NoiseValueList.Count, "Pink" );
        }
        else if( m_Animator.GetCurrentAnimatorStateInfo(0).IsName("Joel_Iso") )
        {            
            ResetNoiseAfterEnd( m_NoiseController.BaseNoise.NoiseValueList.Count, "ISO" );
        }
        else if( m_Animator.GetCurrentAnimatorStateInfo(0).IsName("Joel_WGN") )
        {
            ResetNoiseAfterEnd( m_NoiseController.BaseNoise.NoiseValueList.Count, "Random" );
        }
        else if( m_Animator.GetCurrentAnimatorStateInfo(0).IsName("Idle") )
        {
            m_NoisePatternLbl = "Idle";            
            m_NoiseDataPanelTitle.text = m_NoisePatternLbl + " Noise = " + m_DefaultAnimationSpeed;
        }
        else
        {
            Debug.Log(" Animation is unknown ");
        }
    }
 
    private void ResetNoiseAfterEnd( int noiseLength, string lbl )
    {
        m_NoisePatternLbl = lbl;
 
        if( m_NoiseIndex >= noiseLength )
        {
            OpenConfirmationDialogMedium();
            m_NoiseIndex = 0;
        }
    }
 
    private void OpenConfirmationDialogMedium()
    {
        Dialog.Open( m_DialogPrefabMedium, DialogButtonType.OK, "Good Job!", "Times Up!" +
                     " You covered required distance.", true);
    }
 
    private void RunGaitCycle()
    {
        float noiseValue = m_DefaultAnimationSpeed;
        float desiredSpeed = m_DefaultAnimationSpeed;
 
        if( String.Equals( m_NoisePatternLbl, "Pink" ) || ( String.Equals( m_NoisePatternLbl, "Random" ) ) ||
            String.Equals( m_NoisePatternLbl, "ISO" ) )
        {
            noiseValue = Mathf.Abs( m_NoiseController.BaseNoise.NoiseValueList[m_NoiseIndex] );
        }
        else if( String.Equals( m_NoisePatternLbl, "Idle" ) )
        {
            m_IdleElementFlag = true;
            return;
        }
        else
        {
            m_NoisePatternLbl = "ERROR!!!";
            noiseValue = m_DefaultAnimationSpeed;
        }
        
        float animationLength = 0.0f;
        bool isValidAnimLength = m_OriginalAnimationLength.TryGetValue( m_NoisePatternLbl, out animationLength );
 
        if( isValidAnimLength && noiseValue != 0 )
        {
            desiredSpeed = ( animationLength / noiseValue );            
        }
 
        m_IsAnimationLocked = true;
        m_Animator.speed = desiredSpeed;
        m_NoiseDataPanelTitle.text = m_NoisePatternLbl + " Noise = " + noiseValue;
 
        float len = m_Animator.GetCurrentAnimatorStateInfo(0).length;
        m_AnimationLength.Add( len );
 
        // Only for debug.
        // Debug.Log( "Number: " + noiseValue + " Time: " + Time.realtimeSinceStartup + " Len: " + len );        
    }
 
    private void StoreAnimationClipsLength()
    {
        AnimationClip[] clips = m_Animator.runtimeAnimatorController.animationClips;
 
        foreach( AnimationClip clip in clips )
        {
            switch( clip.name )
            {
                case "Joel_PGN":
                    m_OriginalAnimationLength.Add( "Pink", clip.length );
                    break;
 
                case "Joel_Iso":
                    m_OriginalAnimationLength.Add( "ISO", clip.length );
                    break;
 
                case "Joel_WGN":
                    m_OriginalAnimationLength.Add( "Random", clip.length );
                    break;
 
                default:
                    break;
            }
        }
    }
 
    private void LockdownAnimation()
    {        
        if( m_IsAnimationLocked == false )
        {
            RunGaitCycle();            
        }
    }
 
    private void UnlockAnimation()
    {
        m_IsAnimationLocked = false;
 
        if ( ( m_IsAnimationLocked == false ) && ( m_IdleElementFlag == false ) )
        {            
            m_NoiseIndex++;            
        }
        else
        {
            m_Counter++;
 
            // Prevent first element from being skipped.
            if( m_NoiseIndex == 0 && m_Counter == 2 )
            {
                m_Counter = 1;
                m_IdleElementFlag = false;
            }
 
            // Prevent element from being skipped after transtion from idle to moving.
            if( m_Counter == 3 )
            {
                m_Counter = 1;
                m_IdleElementFlag = false;
            }
        }
    }
 
    public void ResetAnimationLengthList()
    {
        m_AnimationLength.Clear();
        m_NoiseIndex = 0;
        m_Counter = 1;
    }
}