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

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

Resumen

La mejor forma de dar vida a un enemigo en Unity 2D es con una IA simple de movimiento aleatorio. Aquí verás cómo estructurar un EnemyController en C#, conectar Rigidbody2D y Animator, y controlar tiempos de paso con precisión. Todo está preparado para reutilizarlo en distintos tipos de enemigos sin cambiar el script, solo los gráficos.

¿Cómo crear e integrar el enemy controller?

Para empezar, se crea un script de C# llamado EnemyController y se arrastra al objeto enemigo en la jerarquía. Aunque se llame controller, no lo controlará el jugador: gobierna el movimiento autónomo del enemigo.

¿Qué requisitos debe tener el enemigo?

Tag "enemy" aplicada al objeto enemigo.
Sistema de animaciones con blend tree y parámetros "horizontal" y "vertical".
Collider configurado.
Rigidbody2D agregado.

¿Cómo resolver errores del editor?

Si Visual Studio marca todo en rojo sin motivo: guardar, cerrar y reabrir el script desde Unity.

¿Qué variables controlan la IA y el movimiento aleatorio?

La lógica se basa en dos temporizadores: tiempo entre pasos y tiempo de cada paso. Además, se registra si el enemigo está en movimiento y en qué dirección debe desplazarse. Se comunican los ejes al animator mediante constantes.

using UnityEngine;

public class EnemyController : MonoBehaviour
{
    public float enemySpeed = 1f;                  // Velocidad del enemigo.
    private Rigidbody2D enemyRigidBody;            // Referencia al Rigidbody2D.
    private bool isMoving;                         // Estado de movimiento.

    public float timeBetweenSteps = 2f;            // Tiempo en reposo entre pasos.
    private float timeBetweenStepsCounter;         // Contador interno de reposo.

    public float timeToMakeStep = 1.5f;            // Duración de cada paso.
    private float timeToMakeStepCounter;           // Contador interno de paso.

    public Vector2 directionToMakeStep;            // Dirección del movimiento.

    private Animator enemyAnimator;                // Referencia al Animator.
    private const string Horizontal = "horizontal"; // Parámetro del blend tree.
    private const string Vertical = "vertical";     // Parámetro del blend tree.

    void Start()
    {
        enemyRigidBody = GetComponent<Rigidbody2D>();
        enemyAnimator = GetComponent<Animator>();

        // Inicialización de contadores con los valores públicos.
        timeBetweenStepsCounter = timeBetweenSteps;
        timeToMakeStepCounter = timeToMakeStep;
    }

enemySpeed: controla la rapidez del desplazamiento.
isMoving: indica si se está moviendo o está quieto.
timeBetweenSteps/timeBetweenStepsCounter: reposo y su contador interno.
timeToMakeStep/timeToMakeStepCounter: duración del paso y su contador interno.
directionToMakeStep: vector de dirección aleatoria.
enemyRigidBody y enemyAnimator: componentes para movimiento y animación.
"horizontal" y "vertical": nombres exactos de los parámetros del animator.

¿Cómo se programa la lógica en update para moverse y parar?

La mecánica alterna entre reposo y movimiento. En movimiento, se consume el contador del paso y se aplica velocidad en la dirección elegida. En reposo, se espera hasta agotar el contador y se decide una nueva dirección aleatoria.

    void Update()
    {
        if (isMoving)
        {
            // Mientras se mueve.
            timeToMakeStepCounter -= Time.deltaTime;
            enemyRigidBody.velocity = directionToMakeStep * enemySpeed;

            if (timeToMakeStepCounter < 0f)
            {
                // Fin del paso: parar y preparar reposo.
                isMoving = false;
                timeBetweenStepsCounter = timeBetweenSteps; // Ojo con asignar el correcto.
                enemyRigidBody.velocity = Vector2.zero;
            }
        }
        else
        {
            // Mientras está quieto.
            timeBetweenStepsCounter -= Time.deltaTime;

            if (timeBetweenStepsCounter < 0f)
            {
                // Toca iniciar un nuevo paso.
                isMoving = true;
                timeToMakeStepCounter = timeToMakeStep;

                // Dirección aleatoria en X e Y entre -1 y 1.
                directionToMakeStep = new Vector2(
                    Random.Range(-1f, 1f),
                    Random.Range(-1f, 1f)
                );
            }
        }

        // Notificar la dirección al Animator para el blend tree.
        enemyAnimator.SetFloat(Horizontal, directionToMakeStep.x);
        enemyAnimator.SetFloat(Vertical,  directionToMakeStep.y);
    }
}

¿Qué ocurre mientras se mueve?

Se decrementa el contador del paso con Time.deltaTime.
Se aplica velocity al rigidbody según la dirección y la velocidad.
Al agotar el tiempo del paso: se detiene, se pone Vector2.zero y se arma el reposo.

¿Qué ocurre mientras está quieto?

Se decrementa el contador de reposo con Time.deltaTime.
Al agotarse: se activa el movimiento, se reinicia el contador del paso y se elige una dirección aleatoria con Random.Range(-1, 1) en X e Y (puede salir diagonal).

¿Cómo sincronizar animaciones con el movimiento?

Se actualizan los parámetros "horizontal" y "vertical" mediante SetFloat.
El blend tree interpreta estos valores para girar la animación según la dirección.
Valores de ejemplo comprobados: enemySpeed = 1. Tiempo entre pasos = 2 s. Tiempo de paso = 1.5 s.
Consejo práctico: hay mucho código dentro de Update; avanza con cuidado para no mezclar contadores.
Próximo paso: crea un prefab con varios enemigos en pantalla y valida el comportamiento.

¿Tienes dudas o ideas para ampliar esta IA? Comparte tu pregunta y cuéntame cómo la adaptarías a tus enemigos.

victor hugo quintanilla

student•

aquí les dejo código ya comentado


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

public class EnemyController : MonoBehaviour
{
    public float enemySpeed = 1;//velocidad movimiento
    private Rigidbody2D enemyRigidbody;//rigidbody enemigo

    private bool isMoving;//saber si se esta moviendo o no

    public float timeBetweenSteps;//tiempo entre movimientos
    private float timeBetweenStepsCounter;//contador cuanto tiempo a pasado desde el ultimo movimiento

    public float timeToMakeStep;//el tiempo que pasa en hacer el paso de una celda a la siguiente
    private float timeToMakeStepCounter;//el condador de cuanto tiempo a pasado en hacer el paso

    public Vector2 directionToMakeStep;//una direccion de movimiento

    private Animator enemyAnimator;//para transmitir los parametros horizontal y vertical 
    private const string horizontal = "Horizontal";//nombre de los parametros que estan en unity
    private const string vertical = "Vertical";//nombre de los parametros que estan en unity



    // Start is called before the first frame update
    void Start()
    {
        enemyRigidbody = GetComponent<Rigidbody2D>();//inicilisamos las variabes
        enemyAnimator = GetComponent<Animator>();////inicilisamos las variabes

        timeBetweenStepsCounter = timeBetweenSteps;//se inicialice con la informacion que le ponemos en unity
        timeToMakeStepCounter = timeToMakeStep;//se inicialice con la informacion que le ponemos en unity
    }

    // Update is called once per frame
    void Update()
    {
        if (isMoving)
        {
            timeToMakeStepCounter -= Time.deltaTime;//descuenta el tiempo del ultimo renderisado
            enemyRigidbody.velocity = directionToMakeStep;//movemos al enemigo a la direccion

            if (timeToMakeStepCounter < 0)//si se acaba el tiempo de movimiento
            {
                isMoving = false;//pone en falso el movimiento
                timeBetweenStepsCounter = timeBetweenSteps;//reinicia el contador
                enemyRigidbody.velocity = Vector2.zero;//para el movimiento
            }
        }
        else//si no se esta moviendo
        {
            timeBetweenStepsCounter -= Time.deltaTime;//resta tiempo al contador
            if (timeBetweenStepsCounter < 0)//si se acaba el tiempo de espera para el siguiente
            {
                isMoving = true;//ponemos en true para empesar a movernos
                timeToMakeStepCounter = timeToMakeStep;//re iniciamos el contador
                directionToMakeStep = new Vector2(Random.Range(-1, 2), Random.Range(-1, 2)) * enemySpeed;//nos movemos
            }
        }
        
        enemyAnimator.SetFloat(horizontal, directionToMakeStep.x);//lo movemos ya con los valores dados
        enemyAnimator.SetFloat(vertical, directionToMakeStep.y);//lo movemos ya con los valores dados
    }
}

Ronaldo Carbajal Tapahuasco

student•

Muchas gracias por el aporte hermano, me ayudo a comprender mejor! c:

Johnny Vargas Diaz

student•

Hay algo que no se explica con el Random.Range y es que cuando se usan valores --int-- el segundo valor es exclusivo, esa es la razon por la que el personaje siempre baja en la demostracion, entonces deberia ser Random.Range(-1,2) o Random.Range(-1f,1f)

Samar Jaffal

student•

Tienes mucha razón, me di cuenta de eso también. Lo ideal es usarlo así Random.Range(-1,2), para que el personaje pueda subir y bajar

Germán Britez

student•

Excelente aporte!

Hector Alejandro Ramirez Huertas

student•

Siempre es importante establecer y definirle una capa al enemigo.

Luis Rogelio Reyes Hernandez

student•

Hice el codigo del enemigo similar al del jugador que cuando no se esta moviendo se queda parado viendo en la ultima dirrecion que este se movio

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

public class EnemyController : MonoBehaviour
{
    public float enemySpeed = 1;
    private Rigidbody2D enemyRigidbody;

    private bool isMoving = false;

    public float timeBetweenSteps;

    private float timeBetweenStepsCounter;

    public float timeToMakeStep;
    private float timeToMakeStepCounter;

    public Vector2 directionToMakeStep;
    private Vector2 lastMovement = Vector2.zero;

    private Animator enemyAnimator;

    private const string horizontal = "Horizontal";

    private const string vertical = "Vertical";
    private const string moving = "isMoving";

    private const string lastHorizontal = "LastHorizontal";

    private const string lastVertical = "LastVertical";

    // Start is called before the first frame update
    void Start()
    {
        enemyRigidbody = GetComponent<Rigidbody2D>();
        enemyAnimator = GetComponent<Animator>();

        timeBetweenStepsCounter = timeBetweenSteps * Random.Range(0.5f, 1.5f);
        timeToMakeStepCounter = timeToMakeStep * Random.Range(0.5f, 1.5f);
    }

    // Update is called once per frame
    void Update()
    {
        if (isMoving)
        {
            timeToMakeStepCounter -= Time.deltaTime;
            enemyRigidbody.velocity = directionToMakeStep;

            if (timeToMakeStepCounter < 0)
            {
                isMoving = false;
                timeBetweenStepsCounter = timeBetweenSteps;
                enemyRigidbody.velocity = Vector2.zero;
            }
        }
        else
        {
            timeBetweenStepsCounter -= Time.deltaTime;
            if (timeBetweenStepsCounter < 0)
            {
                isMoving = true;
                timeToMakeStepCounter = timeToMakeStep;

                directionToMakeStep = new Vector2(
                    Random.Range(-1, 2), // de esta forma porque el Random.Range no llega al ultimo
                    Random.Range(-1, 2) // de esta forma porque el Random.Range no llega al ultimo
                ) * enemySpeed;

                lastMovement = directionToMakeStep;
            }
        }

        enemyAnimator.SetFloat(horizontal, directionToMakeStep.x);
        enemyAnimator.SetFloat(vertical, directionToMakeStep.y);

        if (lastMovement != Vector2.zero)
        {
            enemyAnimator.SetBool(moving, isMoving);
        }

        enemyAnimator.SetFloat(lastHorizontal, lastMovement.x);

        enemyAnimator.SetFloat(lastVertical, lastMovement.y);
    }
}

Leonel Grisaleña

student•

Dejo mi código mucho mas entendible. Creo que el profesor le erra al poner esos nombres a las variables. La traducción al español no es lo que está queriendo indicar. Dejo mi codigo con nombres más amenos, optimización usando el FixedUpdate para el movimiento y el LateUpdate para las animaciones con un OnTriggerEnter2D para evitar que el personaje colisione con objetos y se quede caminando en el aire. Ademas también sucede que si la velocidad del rigidbody es 0 pero el bool _isMoving = true, el tipo hace el moon walk a lo Michael Jackson. Con este código se soluciona en el IF que puse.

public class EnemyController : MonoBehaviour
{
    [Header("Configuration")]
    public float enemySpeed = 1.0f;
    public float timeBetweenSteps;
    public float timeToMove;

    private Rigidbody2D _rigidbody;
    private bool _isMoving;
    private float _timeWaiting; //Counter that indicates how much time enemy is in Idle until he moves again.
    private float _movingTime; //Counter that indicates how much time enemy moves in the same direction

    public Vector2 directionToMakeStep;
    private Animator _animator;

    private const string _horizontal = "Horizontal";
    private const string _vertical = "Vertical";

    private void Awake()
    {
        _rigidbody= GetComponent<Rigidbody2D>();
        _animator= GetComponent<Animator>();
    }
    // Start is called before the first frame update
    void Start()
    {
        _timeWaiting = timeBetweenSteps;
        _movingTime = timeToMove;
    }

    // Update is called once per frame
    void Update()
    {
        
    }

    private void FixedUpdate()
    {
        if (_isMoving)
        {
            _movingTime -= Time.deltaTime; //Counter starts decreasing
            _rigidbody.velocity = directionToMakeStep; //Enemy start moving in any direction

            if (_movingTime <= 0) //Enemy stop moving and restarts counter to go in another direction
            {
                _isMoving = false;
                _timeWaiting = timeBetweenSteps;
                _rigidbody.velocity = Vector2.zero;

               
            }
        }
        else
        {
            _timeWaiting -= Time.deltaTime;
            if (_timeWaiting < 0)
            {
                //Stop waiting. Time to move
                _isMoving = true;
                _movingTime = timeToMove;

                directionToMakeStep = new Vector2(Random.Range(-1, 2), Random.Range(-1, 2)) * enemySpeed;

                
            }
        }

     }

    private void LateUpdate()
    {
        //If Enemy is moving and velocity is not 0 then execute movement animations
        if (_isMoving && _rigidbody.velocity != Vector2.zero)
        {
            _animator.SetBool("IsMoving", true);
            _animator.SetFloat(_horizontal, directionToMakeStep.x);
            _animator.SetFloat(_vertical, directionToMakeStep.y);
        }
        else 
        {
            //If enemy is not moving. Then Idle animations
            _animator.SetBool("IsMoving", false);
            _animator.SetFloat("LastHorizontal", directionToMakeStep.x);
            _animator.SetFloat("LastVertical", directionToMakeStep.y);
        }
    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
        //If Enemy collision to an object. Then change _isMoving to false. That will make another move to other direction or stops.
        if (!collision.gameObject.CompareTag("Player"))
        {
            _isMoving = false;
        }
    }
}

Martin Mendez

student•

codigo https://github.com/platzi/rpgConUnity/blob/c4a67a8f7d0191e2dfb5231fb95c5ec59afddb67/Assets/Scripts/EnemyController.cs

Ikal Esteban Fernández Galván

student•

Optimice el update para que no sea tan mareante:

//Update
void Update()
    {
        Booleans();

        Move();

        Attack();
        
        CheckVariables();
    }

//Otras funciones
    void Booleans()
    {
        attacking = false;
        walking = false;
    }

    void Move()
    {
        if(Mathf.Abs(Input.GetAxisRaw(hor)) > 0.2f && Mathf.Abs(Input.GetAxisRaw(ver)) > 0.2f)
        {
            prb.velocity = new Vector2(Input.GetAxisRaw(hor) * speed, 
                                       Input.GetAxisRaw(ver) * speed);
            walking = true;
        }
        else if(Mathf.Abs(Input.GetAxisRaw(hor)) > 0.2f)
        {
            //this.transform.Translate(new Vector3(Input.GetAxisRaw(hor) * speed * Time.deltaTime,0,0));
            prb.velocity = new Vector2(Input.GetAxisRaw(hor) * speed,0f);
            walking = true;
            lastMovement = new Vector2(Input.GetAxisRaw(hor), 0);
        }
        else if(Mathf.Abs(Input.GetAxisRaw(ver)) > 0.2f)
        {
            //this.transform.Translate(new Vector3(0,Input.GetAxisRaw(ver) * speed * Time.deltaTime,0));
            prb.velocity = new Vector2(0f, Input.GetAxisRaw(ver) * speed);
            walking = true;
            lastMovement = new Vector2(0, Input.GetAxisRaw(ver));
        }
    }

    void Attack()
    {
        if(Input.GetMouseButtonDown(0))
        {
            attacking = true;
        }
    }

    void CheckVariables()
    {
        if(!walking)
        {
            prb.velocity = Vector2.zero;
        }

        anim.SetFloat(hor, Input.GetAxisRaw(hor));
        anim.SetFloat(ver, Input.GetAxisRaw(ver));
        anim.SetBool(walk, walking);
        anim.SetBool(attack, attacking);
        anim.SetFloat(lastHor, lastMovement.x);
        anim.SetFloat(lastVer, lastMovement.y);
    }

Ikal Esteban Fernández Galván

student•

Lo mismo con el enemy:

//Update
void Update()
    {
        Move();
        
        CheckAnimVars();
    }

//Otras funciones
    void Move()
    {
        if (walking)
        {
            timeToMakeStepCounter -= Time.deltaTime;
            erb.velocity = directionToMakeStep;
            if(timeToMakeStepCounter < 0)
            {
                walking = false;
                timeBetweenStepsCounter = timeBetweenSteps;
                erb.velocity = Vector2.zero;
                lastMovement = directionToMakeStep;
            }
        }
        else
        {
            timeBetweenStepsCounter -= Time.deltaTime;
            if (timeBetweenStepsCounter < 0)
            {
                walking = true;
                timeToMakeStepCounter = timeToMakeStep;

                directionToMakeStep = new Vector2(Random.Range(-1,2), Random.Range(-1,2) * enemySpeed);
            }
        }

        if (directionToMakeStep == Vector2.zero)
        {
            walking = false;
        }
    }

    void CheckAnimVars()
    {
        eAnim.SetFloat(ver, directionToMakeStep.y);
        eAnim.SetFloat(hor, directionToMakeStep.x);
        eAnim.SetBool(walk, walking);
        eAnim.SetBool(attack, attacking);
        eAnim.SetFloat(lastHor, lastMovement.x);
        eAnim.SetFloat(lastVer, lastMovement.y);
    }

Leonardo Gutierrez

student•

Genial

IVÁN ROMERO RODRÍGUEZ

student•

He aqui mi codigo, no me funciona y no se porque, ya lo he revisado varias veces, pido su apoyo Profesor. gracias de antemano.

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

public class EnemyMovement : MonoBehaviour
{
    public float enemySpeed = 1;
    private Rigidbody2D enemyRigidbody;

    private bool isMoving;

    public float timeBetweenSteps;
    private float timeBetweenStepsCounter;

    public float timeToMakeStep;
    private float timeToMakeStepCounter;

    public Vector2 directionToMakeStep;

    private Animator enemyAnimator;
    private const string horizontal = "Horizontal";
    private const string vertical = "Vertical";

    // Start is called before the first frame update
    void Start()
    {
        enemyRigidbody = GetComponent<Rigidbody2D>();
        enemyAnimator = GetComponent<Animator>();

        timeBetweenStepsCounter = timeBetweenSteps;
        timeToMakeStepCounter = timeToMakeStep;
    }

    // Update is called once per frame
    void Update()
    {

        if (isMoving)
        {
            timeToMakeStepCounter -= Time.deltaTime;
            enemyRigidbody.velocity = directionToMakeStep;

            if(timeToMakeStepCounter < 0)
            {
                isMoving = false;
                timeBetweenStepsCounter = timeBetweenSteps;
                enemyRigidbody.velocity = Vector2.zero;
            }
            else
            {
                timeBetweenStepsCounter -= Time.deltaTime;
                if(timeBetweenStepsCounter < 0)
                {
                    isMoving = true;
                    timeToMakeStepCounter = timeToMakeStep;
                    directionToMakeStep = new Vector2(Random.Range(-1, 2), Random.Range(-1, 2)) * enemySpeed;
                }
            }
        }
        enemyAnimator.SetFloat(horizontal, directionToMakeStep.x);
        enemyAnimator.SetFloat(vertical, directionToMakeStep.y);
    }
}```

Luca Cristian Manea

student•

Podriamos realizar una variante de lo visto en esta clase con corrutinas para el movimiento?

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

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