Programación de Ataques y Animaciones en Videojuegos

Clase 29 de 60 • Curso Avanzado de Creación de RPGs con Unity

Resumen

Controla con precisión el cambio entre movimiento y ataque en Unity combinando el Animator y el PlayerController. Aquí verás cómo activar un estado booleado de attacking, usar un contador de tiempo para la duración del ataque y evitar que el personaje se mueva mientras ataca. Todo con C# claro, directo y fácil de depurar.

¿Cómo alternar entre ataque y movimiento con animator y controlador?

Para conmutar entre animaciones, se utiliza un parámetro booleano en el Animator llamado exactamente attacking. Este parámetro gobierna las transiciones desde movimiento e idle hacia la animación de ataque en el blend tree. La lógica se programa en Update para leer la entrada del ratón y actualizar el contador de ataque.

¿Qué variables y constantes necesitas?

Constante para el nombre del estado del Animator: attacking.
Booleana de control: attacking en tiempo de ejecución.
Duración del ataque: attackTime pública para ajustarla en el Inspector.
Contador interno: attackTimeCounter privado para decrementar en cada frame.

Ejemplo en C#:

// Nombre exacto del parámetro en Animator
private const string attackingState = "attacking";

// Control del ataque
public float attackTime = 0.5f;      // ajustable en el Inspector
private bool attacking = false;      // estado actual
private float attackTimeCounter;     // contador interno

¿Cómo gestionar el ciclo de ataque en update?

La clave es decrementar el contador mientras se ataca y apagar el estado cuando llegue a cero. Así evitas mezclar movimiento y ataque.

void Update()
{
    // Mientras se ataca, cuenta hacia atrás y bloquea el movimiento.
    if (attacking)
    {
        attackTimeCounter -= Time.deltaTime;
        if (attackTimeCounter < 0f)
        {
            attacking = false;
            animator.SetBool(attackingState, false);
        }
    }
    else
    {
        // Aquí iría la lógica de movimiento horizontal/vertical.
        // Ejemplo: animator.SetFloat("moveX", inputX); animator.SetFloat("moveY", inputY);
        // El cálculo de walking es común.
    }

    // Resto de Update...
}

¿Cómo detectar la entrada del ratón para iniciar el ataque?

Se usa el clic izquierdo con Input.GetMouseButtonDown(0). Al iniciar, se reinicia el contador, se pone la velocidad a cero y se activa el parámetro del Animator.

if (Input.GetMouseButtonDown(0))
{
    attacking = true;
    attackTimeCounter = attackTime;           // copia desde la pública
    playerRigidBody.velocity = Vector2.zero;  // detener por completo
    animator.SetBool(attackingState, true);   // activar animación de ataque
}

¿Qué errores comunes debes evitar?

Un fallo típico es un desajuste de nombres entre código y Animator. El parámetro debe llamarse exactamente "attacking". Otro error frecuente es invertir los modificadores: hacer pública la variable del contador y privada la duración. El comportamiento que revela este error es claro: el parámetro nunca pasa a true en el Animator y no aparece ningún error en la consola. La corrección consiste en dejar attackTime pública (se edita en el Inspector) y attackTimeCounter privada (uso interno), y asignar correctamente el valor del contador desde la pública al iniciar el ataque.

Consejos rápidos:

Verifica en tiempo de ejecución el parámetro attacking en el Animator.
Revisa la consola por si hay errores silenciosos.
Asegúrate de que las transiciones en el grafo usan la booleana correcta.

¿Cómo ajustar la experiencia de ataque?

El ajuste fino mejora la sensación del combate y evita inconsistencias entre animación y lógica.

Configura attackTime en el Inspector: por ejemplo, 0,5 s para pruebas rápidas.
Sincroniza la duración con la animación: si es más larga, pueden salir dos blandidas; si quieres una sola, iguala tiempos.
Durante el ataque, el grafo del Animator bloquea el movimiento: es intencional para evitar deslizamientos.
Si el alcance es corto, considera hacer el arma un poco más grande: aumenta la accesibilidad sin cambiar la lógica.
Reutiliza Animator.SetFloat y Animator.SetBool para mantener consistencia entre estados.

¿Tienes dudas sobre la configuración del Animator o el manejo del contador? Comparte tu caso y comenta qué resultado buscas, así se puede afinar el flujo de ataque y movimiento.

Wandy Rafael Santana Evangelista

student•

Excelente clase, es muy bueno que en todo el curso ir saltando de programar a animar, porque así vamos viendo como es que realmente es que se desarrollo un videojuego en la vida real, y ademas hace las clases mas dinámicas. Además de que el profesor es increíble.💚😄

Yone Moreno Jiménez

student•

Atacando a diestro y sinistro:

Gabriel Silva

student•

He logrado hacer que el bastón lance una bolita que hace daño, y solo cuando se tiene el bastón equipado

Ikal Esteban Fernández Galván

student•

no se ve

Luis José Leopardi Velásquez

student•

Tengo un problema que no he podido resolver, al agregar el blend tree de la animación de ataque, mi jugador deja de moverse, solo ataca y hace la animación de movimiento, pero no se desplaza.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float speed = 120.0f;
    private bool walking = false;
    public Vector2 lastMovement = Vector2.zero;

    private const string horizontal = "Horizontal";
    private const string vertical = "Vertical";
    private const string lastVertical = "LastVertical";
    private const string lastHorizontal = "LastHorizontal";
    private const string walkingState = "Walking";
    private const string attackingState = "Attacking";  

    private Animator animator;
    private Rigidbody2D playerRigidbody;

    public static bool playerCreated;
    public string nextPlaceName;
    private bool attacking = false;
    public float attackTime;
    private float attackTimeCounter;

    // Start is called before the first frame update
    void Start()
    {
        animator = GetComponent<Animator>();
        playerRigidbody = GetComponent<Rigidbody2D>();
        if(!playerCreated)
        {
            playerCreated = true;
            DontDestroyOnLoad(this.transform.gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    // Update is called once per frame
    void Update()
    {
        walking = false;

        if (Input.GetMouseButtonDown(0))
        {
            attacking = true;
            attackTimeCounter = attackTime;
            playerRigidbody.velocity = Vector2.zero;
            animator.SetBool(attackingState, true);
        }

        if (attacking)
        {
            attackTimeCounter -= Time.deltaTime;
            if (attackTimeCounter < 0)
            {
                attacking = false;
                animator.SetBool(attackingState, false);
            }
        }
        else
        {

            if (Mathf.Abs(Input.GetAxisRaw(horizontal)) > 0.5f)
            {
                //this.transform.Translate(new Vector3(Input.GetAxisRaw(horizontal)
                //    * speed
                //    * Time.deltaTime, 0, 0));
                playerRigidbody.velocity = new Vector2(Input.GetAxisRaw(horizontal)
                    * speed
                    * Time.deltaTime, playerRigidbody.velocity.y);
                lastMovement = new Vector2(Input.GetAxisRaw(horizontal), 0);
                walking = true;

                Debug.Log(playerRigidbody.velocity.x);
            }

            if (Mathf.Abs(Input.GetAxisRaw(vertical)) > 0.5f)
            {
                //this.transform.Translate(new Vector3(0, Input.GetAxisRaw(vertical) * speed * Time.deltaTime, 0));
                playerRigidbody.velocity = new Vector2(playerRigidbody.velocity.x, Input.GetAxisRaw(vertical)
                   * speed
                   * Time.deltaTime);
                lastMovement = new Vector2(0, Input.GetAxisRaw(vertical));
                walking = true;
            }
        }


        if (!walking)
        {
            playerRigidbody.velocity = Vector2.zero;
        }

        animator.SetFloat(horizontal, Input.GetAxisRaw(horizontal));
        animator.SetFloat(vertical, Input.GetAxisRaw(vertical));

        animator.SetFloat(lastHorizontal, lastMovement.x);
        animator.SetFloat(lastVertical, lastMovement.y);
        animator.SetBool(walkingState, walking);
    }
}

Ricardo Rito Anguiano

student•

Por lo que comentas, parece que tu animación es la que esta dando el problema, si es asi, esta debe tener algun parametro en el cual modifique el transform del personaje, o eso es lo que por ahora podria pensar.

No se si esto te ayude, Igual tu pregunta tiene 3 meses, espero lo hayas podido solucionar :D

Milton Leonardo Cubillos

student•

asi explicado el codigo es mas facil de entender

Leonardo Gutierrez

student•

Genial

IVÁN ROMERO RODRÍGUEZ

student•

Yo puse las funciones después de invocar la función de caminar para poder moverme después de atacar y quite el playerRigidbody.velocity.zero, para que no se frene y la verdad es que es muy útil.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{

    public float speed = 2.5f;
    private bool IsWalking = false;
    public Vector2 lastMovement = Vector2.zero;

    private const string horizontal = "Horizontal";
    private const string vertical = "Vertical";
    private const string lastHorizontal = "LastHorizontal";
    private const string lastVertical = "LastVertical";
    private const string isWalkingState = "IsWalking";
    private const string attackingState = "Attacking";

    private Animator animator;
    private Rigidbody2D playerRb;

    public static bool playerCreated;

    public string nextPlaceName;

    private bool attacking = false;
    public float attackTime;
    private float attackTimeCounter;

    // Start is called before the first frame update
    void Start()
    {
        animator = GetComponent<Animator>();
        playerRb = GetComponent<Rigidbody2D>();
        if (!playerCreated)
        {
            playerCreated = true;
            DontDestroyOnLoad(this.transform.gameObject);
        }else
        {
            Destroy(gameObject);
        }
    }

    // Update is called once per frame
    void Update()
    {
        // s = v*t;
        IsWalking = false;

            if (Mathf.Abs(Input.GetAxisRaw(horizontal)) > 0.5f)
            {
                /* this.transform.Translate(new Vector3(Input.GetAxisRaw(horizontal) * speed * Time.deltaTime, 0, 0)); */
                playerRb.velocity = new Vector2(Input.GetAxisRaw(horizontal) * speed * Time.deltaTime, playerRb.velocity.y);
                IsWalking = true;
                lastMovement = new Vector2(Input.GetAxisRaw(horizontal), 0);
            }
            else
            {
                playerRb.velocity = new Vector2(0f, playerRb.velocity.y);
            }

            if (Mathf.Abs(Input.GetAxisRaw(vertical)) > 0.5f)
            {
                /* this.transform.Translate(new Vector3( 0, Input.GetAxisRaw(vertical) * speed * Time.deltaTime, 0)); */
                playerRb.velocity = new Vector2(playerRb.velocity.x, Input.GetAxisRaw(vertical) * speed * Time.deltaTime);
                IsWalking = true;
                lastMovement = new Vector2(0, Input.GetAxisRaw(vertical));
            }
            else
            {
                playerRb.velocity = new Vector2(playerRb.velocity.x, 0f);
            }

        if (!IsWalking)
        {
            playerRb.velocity = Vector2.zero;
        }

        if (Input.GetKey(KeyCode.Z))
        {
            attacking = true;
            attackTimeCounter = attackTime;
            animator.SetBool(attackingState, true);
        }

        if (attacking)
        {
            attackTimeCounter -= Time.deltaTime;
            if (attackTimeCounter < 0)
            {
                attacking = false;
                animator.SetBool(attackingState, false);
            }
        }

        animator.SetFloat(horizontal, Input.GetAxisRaw(horizontal));
        animator.SetFloat(vertical, Input.GetAxisRaw(vertical));

        animator.SetBool(isWalkingState, IsWalking);

        animator.SetFloat(lastHorizontal, lastMovement.x);
        animator.SetFloat(lastVertical, lastMovement.y);
    }
}

Líam Ayelén Acosta Muñoz

student•

Hola tengo un bug y es que cuando intento de atacar hacia la izquierda ataca hacia la derecha alguien sabe como corregir esto?

Programación de Ataques y Animaciones en Videojuegos

Introducción

Game design rápido de RPG en Unity

Creación de un Roguelike en 2D con Unity

Sprite Editor: cómo cortar assets 32x32 y 16x16

Creación de Paletas y Capas en Unity para Diseñar Escenarios 2D

Capas de Ordenación y Colisiones en Unity para Videojuegos 2D

Uso de Gráficos en Proyectos de Unity

Personaje principal: Movimiento y Animaciones

Controlador de jugador básico en Unity

Animación de Personajes en Unity: Creación de Clips y Timelines

Creación y gestión de animaciones en Unity con Animator

Blend tree para animaciones 2D en Unity

Controlador y Animador de Personajes en Unity

Programación de cámara que sigue al jugador en Unity 2D

Arreglar rayas negras en Unity 2D

Colisiones y Movimiento en Unity con Rigidbody 2D

Cómo diseñar interior y exterior de casa 2D

Escenarios Avanzados

Transiciones entre escenas en Unity con C#

Uso de Don'tDestroyOnLoad en Unity para Gestión de Objetos Persistentes

Spawn Zone: sincronizar entrada entre escenas

Transiciones y Gestión de Escenarios en Videojuegos RPG

Enemigos Avanzados

Configuración de Enemigos en Videojuegos: Animaciones y Física

Programación de Movimiento Aleatorio para Enemigos en Juegos de Rol

Aleatoriedad en el Movimiento de Enemigos en Videojuegos

Detección de Colisiones y Reinicio en Unity

Gestión de Vida en Videojuegos: Creación de un Manager de Vida

Configuración de Armas y Colisiones en Unity para Videojuegos 2D

Configurar vida del enemigo y daño del arma

Mejora de animación de espada en Unity

Blend Tree 2D para ataques direccionales en Unity

Programación de Ataques y Animaciones en Videojuegos

Normalización de velocidad diagonal en Unity

Optimización de Código en Controladores de Juego

Efectos Visuales y Colisiones en Ataques de Videojuegos

Sistema de partículas de sangre en Unity

Crear un Canvas de Daño en Unity para Videojuegos

Crear textos de daño flotantes en Unity

Creación de un HUD para mostrar la barra de vida en videojuegos

Sincronización de UI y datos en Unity

Personaje principal avanzado

Efectos Visuales de Daño en Unity: Parpadeo y Color de Texto

Cómo funciona el sistema de experiencia y nivel en Unity

Unity RPG: stats por nivel con arrays

Sistema de Defensa y Niveles en RPG: Implementación y Ajustes

Cómo crear NPCs con movimiento aleatorio

Fronteras para NPCs: evita que se pierdan

Diseño de Interfaz de Diálogo en Videojuegos con Unity

Programación de diálogos interactivos para NPCs en videojuegos

Arrays de diálogo en Unity con C#

Cómo pausar NPCs durante diálogos en Unity

Control de Diálogos y Movimiento en Videojuegos con Unity

Quests

QuestManager para misiones de RPG en Unity

Quests por triggers en Unity

Creación de Misiones de Recolección en Videojuegos

Creación de Misiones para Derrotar Enemigos en Videojuegos

Corregir bugs de diálogo y animación en Unity

Límites de cámara con MathF.Clamp

Ajuste Dinámico de Límites de Cámara en Unity

Audio

Efectos de sonido en Unity: método fácil

Gestión de Música de Fondo en Videojuegos con Unity

Control de Volumen de Audio en Videojuegos con Unity

Gestión de Volumen Global en Videojuegos

Creación de un Sistema de Economía Virtual en Videojuegos