Introducción

1

Game Design del juego

2

La estructura y assets de un proyecto en Unity

3

Convirtiendo nuestros assets en Tiles

4

Tilemaps y creación del escenario

5

Bonus: FastForward de la creación del escenario, sorting layers y creación de colliders

6

Acá encontrarás los archivos de este curso

Personaje principal: Movimiento y Animaciones

7

El jugador y el movimiento

8

Creando nuestra primera animación

9

Creando el grafo de animaciones

10

Usando un árbol de animaciones

11

Mostrando la solución del desafío e implementando transición entre blended trees

12

Programando una cámara que siga al jugador

13

Corrección del bug gráfico

14

límites del escenario, rigid bodies

15

Ejercicio: diseño de interiores

Escenarios Avanzados

16

Transiciones entre escenas

17

Mantener Player y Camera entre escenas

18

Spawning Points: programando que el jugador y la cámara aparezcan en el lugar correcto al cambiar de escena

19

Agregando Identificadores a nuestros Spawning Points para controlar mejor el flujo de nuestro juego

Enemigos Avanzados

20

Creando nuestro enemigo

21

Programando las físicas y el patrullaje del enemigo

22

Generando movimiento completamente aleatorio

23

Programando el ataque del enemigo

24

Crear Manager de Health del Player

25

Crear armas

26

Programando el ataque del Player con arma

27

Mover la espada al caminar

28

Creando el ataque con espada

29

Ejecutando el ataque con un botón

30

Movimiento en diagonal

31

Optimizando nuestro player controller

32

Ataque mejorado

33

Uso de partículas

34

Añadir el daño del enemigo en batalla

35

Programando los contadores de vida del enemigo

36

Colocando más info de UI en pantalla

37

Script de la vida

Personaje principal avanzado

38

Añadir el daño del personaje (ejercicio)

39

Sistema de puntos de experiencia para nuestro personaje principal

40

Level Up!

41

Level Up! Defensa y Reto Final del Módulo: Stats de los enemigos

42

Creando un NPC

43

Limitar el movimiento de nuestro NPC

44

Creando una pantalla de diálogos para nuestro RPG

45

El diálogo del NPC

46

Múltiples líneas de diálogo

47

Parar el NPC durante el diálogo

48

Parar el personaje durante el diálogo

Quests

49

La estructura de una quest

50

Quest 1: Ir a un lugar

51

Quest 2: Encontrar un objeto

52

Quest 3: Matar enemigos

53

Revisión de bugs

54

Mantener la cámara dentro del escenario

55

El problema al cambiar de escena

Audio

56

Agregando SFX a nuestro videojuego

57

Agregando música a nuestro videojuego

58

Ajustar volúmen del audio de cada uno de los efectos de sonido

59

Creando un VolumeManager

60

Agregando economía a nuestro juego y cierre

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Creando una pantalla de diálogos para nuestro RPG

44/60
Recursos

¿Cómo incorporar diálogo en un videojuego?

Crear una interfaz de diálogo convincente en un videojuego es esencial para ofrecer a los jugadores una experiencia inmersiva y fluida. Este proceso requiere una cuidadosa atención al detalle en términos de diseño de interfaces gráficas y UX. Aquí, compartimos los pasos fundamentales, desde la detección de proximidad entre el jugador y el NPC hasta la implementación visual y lógica en Unity.

¿Cómo diseñar la interfaz de diálogo?

Para crear una interfaz efectiva, se recomienda un diseño simple y funcional. Uno de los enfoques más eficaces es tener una zona en la parte inferior de la pantalla donde el texto del diálogo sea claramente visible. A continuación, describimos cómo lograrlo:

  1. Creación del 'DialogManager':
  • Dentro del canvas que ya se ha utilizado para otros HUDs como nivel de vida, crea un nuevo GameObject vacío. Este será el 'DialogManager'.
  • Añade como hijo del 'DialogManager' una nueva imagen UI, que servirá de base visual para el texto.
  1. Ajustes Visuales:
  • Modifica el color de la imagen hacia un tono gris oscuro, permitiendo así un buen contraste con el texto en blanco.
  • Ajusta la transparencia de la imagen para dejar entrever ligeramente el fondo, logrando una estética menos agresiva.
  1. Ajuste y Ubicación:
  • Coloca la imagen ajustando sus límites precisamente a la parte inferior de la pantalla usando Alt y Shift.
  • Extiende o reduce la imagen según las necesidades del diseño y el espacio disponible, garantizando que ocupe todo el espacio de su contenedor padre.
  1. Incorporación de texto:
  • Crea un nuevo objeto de texto como hijo del 'DialogManager', eligiendo un color de fuente claro para asegurar su visibilidad.
  • Utiliza la fuente seleccionada previamente en el proyecto, adaptando el tamaño del texto y su posición dentro del cuadro previamente definido.
  • Ajusta las margenes para dejar espacio para la información adicional, como un aviso para avanzar en el diálogo (Ej: "pulsa espacio para continuar").

¿Qué aspectos considerar al programar la lógica del diálogo?

La lógica detrás del manejo de diálogos es crucial para tener una experiencia de usuario fluida. Aquí resumimos el proceso de implementación de esta lógica usando Unity y C#:

  1. Creación del Script 'DialogManager':
  • Asigna un script de C# llamado 'DialogManager' al objeto ya configurado para la gestión de diálogos.
  1. Configuración de Variables:
  • Usa la librería UnityEngine.UI para manejar elementos UI.

  • Declara variables públicas para la caja del diálogo (DialogBox), el texto (DialogText) y un booleano (DialogActive) para gestionar el estado del diálogo.

    using UnityEngine; using UnityEngine.UI;

    public class DialogManager : MonoBehaviour { public GameObject DialogBox; public Text DialogText; public bool DialogActive; }

  1. Programación de la Interacción:
  • En el método Update(), verifica si el diálogo está activo y si se presiona la tecla de espacio para ocultarlo.

  • Implementa el método ShowDialog que recibe un texto y lo muestra en pantalla, controlando las propiedades de visibilidad y contenido de los elementos UI.

    void Update() { if (DialogActive && Input.GetKeyDown(KeyCode.Space)) { DialogActive = false; DialogBox.SetActive(false); } }

    public void ShowDialog(string text) { DialogActive = true; DialogBox.SetActive(true); DialogText.text = text; }

¿Cómo se sincroniza la parte visual y la lógica?

La coordinación entre la interfaz gráfica y el código es esencial para asegurar que las interacciones son percibidas por los jugadores de manera consistente y predecible. Es importante:

  • configurar correctamente los componentes del UI y sus vínculos en Unity para evitar desajustes.
  • sincronizar el estado visual y lógico (por ejemplo, si el diálogo debe mostrarse, asegurar que está activo tanto visual como lógicamente).
  • encajar el diálogo dentro de la narrativa del juego, ofreciendo un rango de acciones al jugador de forma intuitiva.

Este enfoque garantiza que los jugadores se sientan parte del universo que estamos creando, manteniendo el interés y la curiosidad por la historia que queremos contarles. ¡Continúa aprendiendo, creando e innovando en el desarrollo de videojuegos!

Aportes 6

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

pues yo para que no movieran al npc le puse de masa 1000

En versiones recientes de Unity parece que no funciona la asignación con un TextMeshPro, solo me ha funcionado el Text (legado)

Muy buenas gente, a todo lo aprendido en esta clase le añadí un tiempo de carga a las letras del diálogo para que en lugar de aparecer de golpe aparezcan de a poco. Y también puse que si el usuario da click en la pantalla mientras se estan cargando las letras aparezcan todas así no tiene que esperar si no quiere. Así quedaría:

    private void Update()
    {
        if(dialogActive && (Input.GetButtonDown("Fire1") || Input.GetKeyDown(KeyCode.Space)))
        {
            // Finalizar la sección de dialogo
            dialogActive = false;
            dialogZone.SetActive(false);
            nextDialog.gameObject.SetActive(false);
        }
        if(inMove && (Input.GetButtonDown("Fire1") || Input.GetKeyDown(KeyCode.Space)))
        {
            inMove = false;
            StopCoroutine(ShowText());
            dialog.text = textDialog;
            nextDialog.gameObject.SetActive(true);
        }
    }
    public void ShowDialog(string text)
    {
        textDialog = text;
        dialogActive = true;
        dialogZone.SetActive(true);

        StartCoroutine(ShowText());
    }
    private IEnumerator ShowText()
    {
        // Vaciar texto para comenzar de nuevo
        dialog.text = "";
        // Activar movimiento de texto
        inMove = true;
        // Espera inicial antes de cargar el texto
        yield return new WaitForSeconds(timeToDialog);

        for (int i = 0; i < textDialog.Length; i++)
        {
            // Rompe el bucle si se desactiva su movimiento
            if (!inMove)
                break;

            dialog.text += textDialog[i];
            yield return new WaitForSeconds(timeToDialog);
        }
        inMove = false;
        nextDialog.gameObject.SetActive(true);
    }

Genial

Hola ya se unity

Aquí el código:

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

public class DialogManager : MonoBehaviour
{
    /**** Variables. ****/
    public GameObject dialogBox;
    public Text dialogText;
    public bool dialogActive;


    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        if (dialogActive && Input.GetKeyDown(KeyCode.Space))
        {
            dialogActive = false;
            dialogBox.SetActive(false);
        }
    }

    public void ShowDialog(string text)
    {
        dialogActive = true;
        dialogBox.SetActive(true);
        dialogText.text = text;
    }
}