Reprodução de animação personalizada do animador

O Animator é uma ferramenta de controle de animação muito poderosa, e há muitos tutoriais online básicos.
Na maioria dos casos, principalmente para a edição de ações de personagens, costumamos usar o método de conexão do Animator para realizar a reprodução da ação ao editar a animação, assim:
Espero compartilhar outra forma muito prática aqui. Seu layout pode ser Desta forma:

não há muitas linhas e excessos entre os clipes de animação, em alguns casos nossas animações são para um determinado objeto. Mas os clipes de animação não precisam de muita associação / continuidade. Neste momento, recomendo usar este método de reprodução direta e conexão.
Os benefícios são os seguintes:
1. Você pode pular diretamente para o segmento que deseja jogar como quiser.
2. Não controle muitos estados e ramos.
3. Com a combinação de salto e conexão, a modificação de ação e a inserção também são muito flexíveis.
As desvantagens são as seguintes:
1. A relação entre as animações na visualização não é óbvia.
2. A combinação de clipes de animação complexos não pode ser realizada
3. A animação está excessivamente ausente.

Eu pessoalmente acho que esse método não é um método fortemente recomendado, então é apenas outra maneira de escolher. Aqui estão algumas operações de código para sua referência:
reproduzir animação:

protected void _PlayAnim(Animator anim, string animName)
{
    
    
	if (anim != null)
	{
    
    
    	anim.enabled = true;
    	anim.Play(animName);
    }
    else
    {
    
    
	    Debug.Log("StepHandleBase PlayAnim is error");
    }
}

Variáveis ​​de monitoramento de progresso :

private Dictionary<string, AnimPragressStruct> m_dicAnimMonitoring;
protected int m_step;
protected AnimatorStateInfo m_animatorInfo;

estrutura:

	/// <summary>
    /// 监控动画结构
    /// </summary>
    public class AnimPragressStruct
    {
    
    
        public Animator aminator;
        public string name;
        public string keyName;
        public int step;
        public float finish;
        public Action callback;
    }

Monitoramento de registro:

 	protected virtual void _RegisterAnimPragress(Animator anim, string name, int step, float finish, Action action)
    {
    
    
        if (anim != null && m_dicAnimMonitoring != null)
        {
    
    
            string keyName = anim.name + name;

            if (!m_dicAnimMonitoring.ContainsKey(keyName))
            {
    
    
                AnimPragressStruct s = new AnimPragressStruct();
                s.aminator = anim;
                s.name = name;
                s.keyName = keyName;
                s.step = step;
                s.finish = finish;
                s.callback = action;

                m_dicAnimMonitoring.Add(keyName, s);
            }
        }
        else
        {
    
    
            Debug.Log("StepHandleBase _RegasterAnimMonitoring is null");
        }
    }

Monitoramento colocado em Update :
É monitorado principalmente por meio desta frase: aminator.GetCurrentAnimatorStateInfo (0);

 	private void __AnimPragressHandle()
    {
    
    
        if (m_dicAnimMonitoring != null && m_dicAnimMonitoring.Values.Count > 0)
        {
    
    
            Action a = null;
            foreach (AnimPragressStruct s in m_dicAnimMonitoring.Values)
            {
    
    
                if (m_step == s.step && s.aminator != null && s.aminator.enabled)
                {
    
    
                    m_animatorInfo = s.aminator.GetCurrentAnimatorStateInfo(0);
                    if ((m_animatorInfo.normalizedTime >= s.finish) && m_animatorInfo.IsName(s.name) && s.callback != null)
                    {
    
    
                        a = s.callback;
                        break;
                    }
                }
            }
            if (a != null) a();
        }
    }

O método de chamada é o seguinte:
1._PlayAnim (animE3, “GB143_Step3”);
reproduz clipes de animação em animE3 GB143_Step3

2._RegisterAnimMonitoring (animE3, “GB143_Step3”, 31, 1f, __Step32Over); o
progresso de monitoramento de registro é clipes de animação: GB143_Step3 31 (Alunos que não precisam usar podem ser removidos), o progresso é 1 (0 ~ 1), o método __Step32Over é chamado quando o método
é compartilhado. !

Minha jornada mental:
recentemente fui para uma empresa de jogos. As férias de verão também são a alta temporada para jogos, então tenho estado ocupado trabalhando horas extras recentemente. Encontrei muitas dicas e não vim para escrever um blog. Fiquei muito animado para postar uma foto antes e esperei até esses dias antes de ter tempo para postá-la no blog.

Resumo:
Na verdade, acredito que, como todo mundo, usei o método de conexão para controlar cada animação no início. Um ou mais estados podem ser usados ​​para controlar a mudança de animação e a animação de transição entre animações. No entanto, a associação entre animações em outros momentos não é necessariamente importante ao saltar para fora do jogo. Com a alternância entre 20 e 30 animações, a tela inteira fica cheia de linhas, e a estrutura da animação não é clara naquele momento. É todo tipo de redundância e difícil de modificar, que afetará todo o corpo, quando você quiser inserir uma animação no meio deve ter um cuidado extra, por isso tentei usar este método para controlá-la.
Há também o monitoramento da conclusão de uma animação. Usar esse método para monitorar a animação também pode travar melhor o andamento da animação. Coopere com a lógica para saber com flexibilidade em qual porcentagem mudar para outro estado ou chamar outros eventos.
De modo geral, compartilhar esse método não é a solução ideal para controle e espero dar a você uma referência.