#MiniCurso “GODOT” Motor para crear videojuegos

codigo godot

Mini Curso de Desarrollo en Godot con Ejemplos de Código (Texto e Instrucciones Detalladas)

Lección 1: Introducción a Godot y Primeros Pasos

  1. Interfaz y Creación de Proyecto:
  • Abre Godot, selecciona “New Project” en la pantalla de inicio.
  • Elige una ubicación y nombra el proyecto (por ejemplo, Juego_Aventura2D).
  • Selecciona una plantilla de 2D en la configuración inicial. Resultado esperado en la pantalla:
    Una ventana vacía en Godot con una estructura de nodos listos para añadir.
  1. Creación de la Escena Principal:
  • Ve a Scene > New Scene.
  • Selecciona Node2D como nodo raíz de la escena.
  • Haz clic en Scene > Save Scene As..., nombra esta escena Main.tscn, y guarda en una carpeta llamada scenes.

Lección 2: Añadir Colisiones en el TileMap (Paso a Paso con Descripciones Visuales)

  1. Abrir el TileMap en la Escena Principal (Main.tscn):
    • Ubicación en la pantalla: En el panel izquierdo, en la sección de Scene, selecciona el nodo llamado TileMap.
    • Resultado visual: Verás el TileMap seleccionado en el editor de la escena.
  2. Abrir el Editor de TileSet:
    • Con el TileMap seleccionado, ve al panel de Inspector (panel derecho).
    • En la propiedad Tile Set, haz clic en [empty] si aún no tienes un TileSet, y selecciona New TileSet. Luego, haz clic en el botón Edit junto a Tile Set.
    • Resultado visual: Esto abre una nueva ventana en el Viewport llamada Tile Set Editor, donde verás una cuadrícula que representa tus tiles.
  3. Seleccionar el Tile para Añadir Colisiones:
    • En el Tile Set Editor, selecciona un tile específico (como un bloque de pared).
    • Ubicación en la pantalla: Cuando seleccionas un tile, verás una serie de opciones en el lado derecho del editor.
    • Resultado visual: A la derecha, verás opciones como Collision para agregar colisiones.
  4. Añadir el CollisionShape2D al Tile:
    • En el panel derecho, busca la opción Collision y haz clic en el botón +.
    • Esto te permitirá añadir un CollisionShape2D para ese tile.
    • Ubicación en la pantalla: Selecciona la forma de colisión (RectangleShape2D es la más común) y ajusta el tamaño para que cubra el área del tile.
    • Resultado visual: Ahora verás un rectángulo o forma de colisión sobre el tile. Ajusta el tamaño de la colisión para que cubra toda la superficie del tile o solo una parte, según lo que necesites.
  5. Repetir para Otros Tiles que Requieran Colisión:
    • Si tienes otros tiles en el TileMap que también deben actuar como barreras, selecciona cada uno y repite el proceso de añadir una CollisionShape2D.
    • Consejo: Para asegurarte de que todos los tiles están bien configurados, revisa cada tile en el Tile Set Editor y verifica que las colisiones están ajustadas.
  6. Guardar el TileMap:
    • Después de configurar las colisiones en todos los tiles, guarda el TileMap haciendo clic en File > Save o usando el atajo de teclado (Ctrl+S o Cmd+S en Mac).

Resultado esperado en el juego

  1. Prueba las Colisiones:
    • Ve a la escena principal Main.tscn, donde está configurado el TileMap.
    • Ejecuta la escena (presiona F5).
    • Prueba visual: Mueve tu personaje hacia los bloques con colisiones. Si las colisiones están bien configuradas, tu personaje no debería poder atravesar esos bloques.

Lección 3: Creación del Personaje y Movimiento Básico

1. Configuración del Personaje Principal

Este paso se enfoca en configurar al personaje del juego, es decir, el nodo principal que representará al jugador en la pantalla. Para ello, usamos un nodo específico llamado KinematicBody2D, que está diseñado para objetos que se moverán en un espacio 2D y que tienen interacciones con otros objetos, como el personaje.

Paso 1.1: Crear una Nueva Escena con un Nodo KinematicBody2D
  1. Crear una Nueva Escena:
    • Abre Godot y asegúrate de estar trabajando en el proyecto que creaste anteriormente.
    • Crea una nueva escena y selecciona el tipo de nodo KinematicBody2D como el nodo raíz.
    ¿Por qué KinematicBody2D?
    • El nodo KinematicBody2D es ideal para el personaje principal porque permite mover el objeto en 2D con control directo sobre la física y las colisiones.
    • A diferencia de otros nodos como RigidBody2D, KinematicBody2D no tiene una física automática que lo haga caer o moverse por sí solo; todo el movimiento debe ser programado.
    Resultado esperado: Al final de este paso, tendrás una nueva escena con un nodo KinematicBody2D que servirá como el cuerpo del personaje.
Paso 1.2: Añadir un Sprite como Hijo y Cargar la Imagen de Tu Personaje
  1. Añadir el Sprite:
    • Haz clic derecho sobre el nodo KinematicBody2D en la jerarquía de nodos y selecciona Add Child Node.
    • En la ventana que aparece, selecciona Sprite para agregarlo como un hijo del KinematicBody2D. Este será el componente que mostrará la imagen visual de tu personaje en la pantalla.
  2. Cargar la Imagen del Personaje:
    • Con el nodo Sprite seleccionado, en el Inspector, encontrarás una propiedad llamada Texture.
    • Haz clic en el campo Texture y selecciona la imagen que quieres usar para tu personaje. Puedes utilizar una imagen de cualquier personaje en 2D que tengas, o bien descargar una de sitios como OpenGameArt.
    Resultado esperado: Ahora deberías ver una imagen de tu personaje en el editor de Godot, colocada sobre el nodo KinematicBody2D.

2. Código de Movimiento Básico

Ahora que tenemos al personaje visible, necesitamos programar su movimiento para que el jugador pueda controlarlo.

Paso 2.1: Agregar un Script al KinematicBody2D del Personaje
  1. Adjuntar un Script:
    • Selecciona el nodo KinematicBody2D de tu personaje en la jerarquía de la escena.
    • Haz clic en el botón Attach Script en la parte superior del Inspector.
    • En la ventana que aparece, asegúrate de que el lenguaje del script sea GDScript y dale un nombre al script (por ejemplo, Player.gd).
    Resultado esperado: Ahora tendrás un archivo de script asociado al nodo KinematicBody2D donde escribiremos el código que controlará el movimiento.
Paso 2.2: Escribir el Código de Movimiento Básico

Dentro del archivo Player.gd, escribe el siguiente código para que el personaje pueda moverse con las teclas de flecha o WASD.

gdCopiar códigoextends KinematicBody2D

var speed = 200  # Velocidad de movimiento

func _process(delta):
    var velocity = Vector2.ZERO  # Vector para dirección

    # Detectar teclas de movimiento
    if Input.is_action_pressed("ui_right"):
        velocity.x += 1
    if Input.is_action_pressed("ui_left"):
        velocity.x -= 1
    if Input.is_action_pressed("ui_down"):
        velocity.y += 1
    if Input.is_action_pressed("ui_up"):
        velocity.y -= 1

    # Normalizar la dirección y aplicar velocidad
    velocity = velocity.normalized() * speed
    move_and_slide(velocity)  # Mueve al personaje según la dirección y velocidad
Explicación del Código:
  1. velocity = Vector2.ZERO:
    • Aquí estamos creando un vector de velocidad que se inicializa en (0, 0), lo que significa que el personaje no se moverá inicialmente.
  2. Input.is_action_pressed("ui_right"):
    • Esta función detecta si una tecla está siendo presionada. Las acciones predeterminadas de Godot son ui_right, ui_left, ui_up y ui_down, que corresponden a las teclas de dirección o WASD.
    • Si la tecla es presionada, el valor de velocity.x o velocity.y se incrementa o decrementa, lo que permite mover al personaje en la dirección deseada.
  3. velocity.normalized() * speed:
    • La función normalized() asegura que la dirección del movimiento sea siempre la misma sin importar la magnitud (es decir, que el personaje se mueva a la misma velocidad en cualquier dirección).
    • Multiplicamos el vector normalizado por speed para darle una velocidad constante.
  4. move_and_slide(velocity):
    • Esta función es parte de KinematicBody2D y aplica el movimiento calculado al personaje, teniendo en cuenta las colisiones con otros objetos del juego.
    Resultado esperado: Al ejecutar el juego, el personaje debería moverse en la pantalla utilizando las teclas de dirección o WASD.

3. Configuración de Entradas

Antes de que el movimiento funcione correctamente, necesitamos asegurarnos de que las entradas (teclas de dirección o WASD) estén configuradas correctamente en Godot.

Paso 3.1: Configurar las Entradas en el Proyecto
  1. Acceder a la Configuración de Entradas:
    • En el menú superior de Godot, ve a Project > Project Settings.
    • En la ventana que aparece, selecciona la pestaña Input Map.
  2. Agregar Acciones de Entrada:
    • En el campo Action de la parte inferior, escribe las acciones ui_right, ui_left, ui_down y ui_up para las teclas de dirección.
    • Asegúrate de que estén asociadas a las teclas que deseas usar, como las teclas de flecha o las teclas WASD. Para hacerlo, haz clic en el botón Add y asigna la tecla correspondiente.
    Resultado esperado: Cuando hayas configurado las entradas, podrás usar las teclas para mover al personaje de acuerdo con las acciones que configuraste.

Lección 4: Configuración de Colisiones y Física 2D

En esta lección, aprenderemos a configurar colisiones y física para que nuestro personaje pueda interactuar con el mundo del juego de manera realista. Usaremos nodos como CollisionShape2D y las funciones de movimiento de física de Godot para asegurarnos de que el personaje no atraviese los objetos del entorno.

1. Configuración de Colisiones del Personaje

Paso 1.1: Añadir un Nodo CollisionShape2D al Personaje
  1. Agregar una forma de colisión al personaje:
    • Selecciona el nodo KinematicBody2D que representa a tu personaje.
    • Haz clic en Add Child Node y selecciona CollisionShape2D.
    • Esto agregará un nodo CollisionShape2D que definirá el área de colisión del personaje, lo que le permitirá interactuar correctamente con los objetos del entorno.
  2. Configurar la forma de colisión:
    • Con el nodo CollisionShape2D seleccionado, ve al Inspector.
    • En la propiedad Shape, selecciona una forma adecuada, como un RectangleShape2D o CircleShape2D, dependiendo de la forma de tu personaje.
    • Ajusta el tamaño de la forma de colisión para que coincida con el sprite del personaje. Puedes hacer esto moviendo y escalando la forma en el viewport.
    Resultado esperado: Ahora tu personaje tiene una forma de colisión visible que le permitirá interactuar con otros objetos en el juego.
Ejemplo Visual:
  • Imagina que tienes un personaje rectangular. Al agregar el CollisionShape2D con un RectangleShape2D, el área de colisión se ajustará al tamaño del rectángulo del personaje.

2. Configuración de Colisiones en el Entorno

Paso 2.1: Añadir Colisiones al TileMap

El siguiente paso es configurar las colisiones para los bloques que forman el entorno, como las paredes o plataformas. Para ello, se debe editar el TileSet que usa el TileMap.

  1. Editar el TileSet:
    • Selecciona el nodo TileMap en tu escena y ve al Inspector.
    • Haz clic en el Tile Set para abrir el Editor de TileSet.
  2. Configurar colisiones para los tiles:
    • En el Editor de TileSet, selecciona el tile que debe tener colisión (por ejemplo, los bloques de pared).
    • En el panel derecho, bajo la opción Collision, haz clic en + para añadir una forma de colisión.
    • Selecciona una forma como RectangleShape2D o PolygonShape2D, dependiendo de la forma del tile.
    • Ajusta la forma de colisión para que cubra el área deseada del tile.
    Resultado esperado: Los tiles con colisión impedirá que el personaje pase a través de ellos.
Ejemplo Visual:
  • Imagina un tile que representa una pared. Al agregarle un RectangleShape2D, la colisión se ajustará al tamaño del bloque de la pared.

3. Programar la Física y el Movimiento del Personaje con Colisiones

Paso 3.1: Aplicar el Movimiento con move_and_slide()

Para que el personaje interactúe correctamente con las colisiones, debemos usar la función move_and_slide(), que es específica para nodos KinematicBody2D. Esta función permite que el personaje se mueva y se deslice sobre las superficies, respondiendo correctamente a las colisiones con otros objetos.

  1. Escribir el código de movimiento con colisiones:
    • Regresa al archivo de script de tu personaje (Player.gd).
    • Asegúrate de que el código de movimiento esté dentro de la función _process(delta) o _physics_process(delta) (si deseas un movimiento más suave).
  2. Código de movimiento con colisiones: Aquí te muestro el código mejorado para que el personaje se mueva y detecte colisiones correctamente:
gdCopiar códigoextends KinematicBody2D

var speed = 200  # Velocidad de movimiento
var velocity = Vector2.ZERO  # Inicializar la velocidad

func _process(delta):
    velocity = Vector2.ZERO  # Reiniciar velocidad cada fotograma

    # Detectar teclas de movimiento
    if Input.is_action_pressed("ui_right"):
        velocity.x += 1
    if Input.is_action_pressed("ui_left"):
        velocity.x -= 1
    if Input.is_action_pressed("ui_down"):
        velocity.y += 1
    if Input.is_action_pressed("ui_up"):
        velocity.y -= 1

    # Normalizar la dirección y aplicar velocidad
    velocity = velocity.normalized() * speed

    # Mover al personaje con colisiones
    move_and_slide(velocity)
Explicación del código:
  1. velocity = Vector2.ZERO:
    • Aquí reiniciamos la velocidad del personaje a (0,0) al principio de cada fotograma para evitar que el personaje se siga moviendo indefinidamente.
  2. Input.is_action_pressed():
    • Detecta qué tecla se está presionando. Las acciones predeterminadas son ui_right, ui_left, ui_down, y ui_up, pero estas se pueden personalizar en la configuración de entrada.
  3. velocity.normalized() * speed:
    • Normalizamos la dirección del movimiento para que el personaje siempre se mueva a la misma velocidad, sin importar si se mueve diagonalmente o no.
  4. move_and_slide(velocity):
    • La función move_and_slide() es el núcleo del movimiento del personaje. Mueve al personaje en función de su velocidad, y si encuentra una colisión, hará que se deslice sobre el objeto con el que colisiona.

4. Configuración de la Gravedad y Otras Propiedades de Física

Paso 4.1: Añadir Gravedad

En un juego 2D, normalmente necesitamos que la gravedad afecte a los objetos. Para lograr esto, podemos usar la propiedad gravity dentro del nodo KinematicBody2D.

Configurar la gravedad:

var gravity = 400 # Intensidad de la gravedad
var velocity = Vector2.ZERO # Inicializar la velocidad

func _process(delta):
velocity.y += gravity * delta # Aplicar gravedad continuamente

# Movimiento horizontal
if Input.is_action_pressed("ui_right"):
    velocity.x += 1
if Input.is_action_pressed("ui_left"):
    velocity.x -= 1

# Normalizar la velocidad y aplicar
velocity = velocity.normalized() * speed

# Mover al personaje con colisiones
move_and_slide(velocity, Vector2.UP)  # Vector2.UP indica la dirección de la gravedad
Explicación:
  1. velocity.y += gravity * delta:
    • Este código agrega la gravedad al movimiento vertical del personaje, haciendo que el personaje caiga más rápido conforme pasa el tiempo.
  2. move_and_slide(velocity, Vector2.UP):
    • La segunda parte de move_and_slide() indica qué dirección se considera “arriba”, que generalmente es hacia el eje Y positivo (Vector2.UP).

En esta lección, hemos aprendido a configurar las colisiones para el personaje y el entorno utilizando nodos como CollisionShape2D en Godot. Además, hemos mejorado el código de movimiento para que el personaje interactúe correctamente con las colisiones, y también hemos añadido la simulación de la gravedad.

Con estos pasos, tu personaje ya debería moverse de manera realista y reaccionar correctamente cuando choque contra otros objetos o el suelo. La física en Godot es poderosa, y puedes seguir ajustando parámetros como la gravedad y el deslizamiento para lograr el comportamiento deseado.

Lección 5: Animaciones del Personaje

En esta lección, vamos a aprender a agregar animaciones al personaje y a controlar su comportamiento visual en función de su movimiento. Esto implica el uso de un nodo AnimatedSprite, que nos permite reproducir diferentes animaciones para cada acción del personaje, como caminar, saltar o estar detenido. Además, aprenderemos cómo conectar el sistema de animaciones al código para que las animaciones se reproduzcan de manera dinámica según el movimiento del personaje.

1. Agregar un Nodo AnimatedSprite

Paso 1.1: Sustituir el Nodo Sprite por AnimatedSprite

En lugar de usar un nodo Sprite, que solo muestra una imagen estática, usaremos un nodo AnimatedSprite para mostrar animaciones. Esto nos permitirá reproducir múltiples frames de una secuencia de imágenes, lo que hará que el personaje tenga un movimiento visual más dinámico.

  1. Eliminar el nodo Sprite:
  • Si ya has agregado un Sprite para tu personaje, elimínalo.
  • Selecciona el nodo Sprite en la jerarquía de la escena y presiona Delete.
  1. Agregar el nodo AnimatedSprite:
  • Haz clic en Add Child Node y selecciona AnimatedSprite. Este nodo te permitirá manejar animaciones dentro de Godot.
  1. Configurar el AnimatedSprite:
  • Selecciona el nodo AnimatedSprite y, en el Inspector, busca la propiedad Frames.
  • Haz clic en [empty] junto a Frames y selecciona New SpriteFrames. Esto te permitirá cargar y gestionar tus animaciones.
  • Ahora, en el panel de propiedades de SpriteFrames, podrás añadir y gestionar las animaciones.

Paso 1.2: Cargar las Imágenes de Animación

  1. Añadir las animaciones:
  • Abre el panel de SpriteFrames haciendo clic en el campo Frames en el Inspector.
  • En la ventana de edición de SpriteFrames, haz clic en Add Animation para crear una nueva animación. Puedes nombrarla, por ejemplo, “walk”.
  1. Agregar las imágenes de la animación:
  • En la animación “walk”, haz clic en Add Frame y selecciona las imágenes que representan los diferentes frames de la animación de caminar. Estas imágenes deben estar secuenciales, es decir, deben mostrar diferentes posiciones del personaje mientras camina.
  • Puedes agregar otras animaciones como “idle” (para cuando el personaje está detenido) o “jump” (si el personaje puede saltar), de la misma manera. Resultado esperado: El personaje debería tener varias animaciones cargadas, como caminar, estar parado y saltar.

2. Controlar las Animaciones con el Código

Ahora que tenemos las animaciones configuradas, necesitamos escribir el código para controlar cuándo y cómo se reproducen esas animaciones. El objetivo es cambiar la animación según la dirección en la que se mueve el personaje (por ejemplo, caminar hacia la derecha o la izquierda) y detener la animación cuando el personaje no se mueve.

Paso 2.1: Modificar el Código del Movimiento

  1. Actualizar el código para incluir las animaciones:
    En el script del personaje (Player.gd), vamos a modificar el código para que la animación cambie en función de la dirección del movimiento. También haremos que la animación de caminar se detenga cuando el personaje esté quieto.
extends KinematicBody2D

var speed = 200  # Velocidad de movimiento
var velocity = Vector2.ZERO  # Velocidad inicial

func _process(delta):
    velocity = Vector2.ZERO  # Reiniciar la velocidad en cada fotograma

    # Detectar teclas de movimiento
    if Input.is_action_pressed("ui_right"):
        velocity.x += 1
    if Input.is_action_pressed("ui_left"):
        velocity.x -= 1
    if Input.is_action_pressed("ui_down"):
        velocity.y += 1
    if Input.is_action_pressed("ui_up"):
        velocity.y -= 1

    # Normalizar la velocidad y aplicar la velocidad
    velocity = velocity.normalized() * speed

    # Controlar animaciones del personaje
    if velocity.x != 0:
        $AnimatedSprite.flip_h = velocity.x < 0  # Flip horizontal para caminar hacia la izquierda
        $AnimatedSprite.play("walk")  # Reproducir animación de caminar
    else:
        $AnimatedSprite.stop()  # Detener animación si no hay movimiento

    move_and_slide(velocity)  # Mover al personaje con colisiones

Explicación del código:

  1. velocity.x != 0:
  • Verificamos si el personaje se está moviendo horizontalmente (es decir, si su velocidad en el eje X es diferente de cero). Si el personaje se está moviendo, cambiamos la animación a “walk”.
  1. $AnimatedSprite.flip_h = velocity.x < 0:
  • Aquí, el código verifica si el personaje se mueve hacia la izquierda (cuando velocity.x < 0) y, si es así, invierte horizontalmente la animación (gira el sprite para que se vea que camina en la dirección opuesta).
  1. $AnimatedSprite.play("walk"):
  • Reproducimos la animación de caminar solo si el personaje se está moviendo.
  1. $AnimatedSprite.stop():
  • Si la velocidad del personaje en el eje X es cero (es decir, el personaje está quieto), se detiene la animación de caminar.
  1. move_and_slide(velocity):
  • Mueve al personaje usando el sistema de física de Godot, respetando las colisiones y aplicando el movimiento calculado.

3. Controlar las Animaciones de Otras Acciones

Ahora, puedes agregar más animaciones para otras acciones del personaje, como estar quieto (idle) o saltar. A continuación, te explico cómo puedes hacerlo.

Paso 3.1: Agregar la Animación de “Idle” (Quieto)

  1. Crear la animación “idle”:
  • En el editor de SpriteFrames de tu AnimatedSprite, agrega una nueva animación llamada “idle”.
  • Añade los frames correspondientes para la animación de reposo (por ejemplo, la imagen del personaje de pie, sin moverse).
  1. Modificar el código para alternar entre “walk” y “idle”:
extends KinematicBody2D

var speed = 200
var velocity = Vector2.ZERO

func _process(delta):
    velocity = Vector2.ZERO

    if Input.is_action_pressed("ui_right"):
        velocity.x += 1
    if Input.is_action_pressed("ui_left"):
        velocity.x -= 1
    if Input.is_action_pressed("ui_down"):
        velocity.y += 1
    if Input.is_action_pressed("ui_up"):
        velocity.y -= 1

    velocity = velocity.normalized() * speed

    # Cambiar entre las animaciones "walk" y "idle"
    if velocity.x != 0:
        $AnimatedSprite.flip_h = velocity.x < 0
        $AnimatedSprite.play("walk")
    else:
        if $AnimatedSprite.animation != "idle":
            $AnimatedSprite.play("idle")  # Cambiar a "idle" cuando no haya movimiento
        $AnimatedSprite.stop()  # Detener si no se mueve

    move_and_slide(velocity)

Explicación:

  1. $AnimatedSprite.play("idle"):
  • Si el personaje no se está moviendo (es decir, su velocidad es cero en el eje X), cambiamos la animación a “idle” (reposo).
  1. $AnimatedSprite.stop():
  • Detiene cualquier animación si el personaje no está moviéndose. Aunque no es estrictamente necesario en este caso, garantiza que la animación se detenga adecuadamente.

En esta lección, hemos aprendido a trabajar con animaciones en Godot utilizando el nodo AnimatedSprite. Esto nos permite agregar diferentes animaciones a nuestro personaje, como caminar, estar quieto (idle) y otras acciones. También hemos aprendido a controlar estas animaciones a través del código para que el personaje cambie de animación dependiendo de su estado o movimiento.

Ahora tu personaje debería ser capaz de caminar, volverse hacia la izquierda o derecha, y alternar entre estar quieto y moverse, todo con animaciones fluidas. Este es un paso importante para dar vida a tu juego y hacerlo más interactivo visualmente.

Si deseas agregar más animaciones como saltar, caer o correr, el proceso es similar al de las animaciones de caminar y reposo, solo que agregando más animaciones al SpriteFrames y controlándolas en el código.

¡Sigue experimentando y añadiendo más animaciones para hacer tu personaje aún más dinámico!
Este código permite alternar la animación según la dirección de movimiento del personaje y detenerla cuando el personaje no se mueve.

Lección 6: Creación de Enemigos

En esta lección, aprenderemos a crear enemigos en Godot, dándoles movimiento y comportamientos básicos. Usaremos el nodo KinematicBody2D como base para los enemigos, ya que este tipo de nodo es ideal para mover objetos en 2D que interactúan con el mundo, como un personaje o un enemigo. Además, veremos cómo agregar animaciones y cómo escribir un script básico para hacer que el enemigo patrulle de un lado a otro.

1. Crear Escena del Enemigo

Paso 1.1: Crear una Nueva Escena para el Enemigo

Primero, debemos crear la escena que representará al enemigo. Al igual que en el caso del personaje principal, utilizaremos un KinematicBody2D como el nodo principal para que podamos mover al enemigo y manejar las colisiones adecuadamente.

  1. Crear un Nodo Principal:
  • Abre Godot y crea una nueva escena. Selecciona KinematicBody2D como el nodo principal de la escena.
  1. Agregar un Sprite:
  • Al nodo KinematicBody2D, agrega un Sprite que representará la apariencia del enemigo.
  • Carga una imagen que representará al enemigo (puede ser un archivo PNG o cualquier otro formato compatible con Godot).
  1. Configurar una Animación (Opcional):
  • Si deseas que el enemigo tenga animaciones (como caminar o atacar), puedes seguir el proceso similar al que hicimos con el personaje principal. Agrega un nodo AnimatedSprite en lugar de un Sprite y configura las animaciones adecuadas (por ejemplo, “patrullar”, “atacar”, “muerte”).

Resultado esperado: Al final de este paso, deberías tener una escena con un enemigo visualmente representado por un sprite o animación.

2. Script de Movimiento del Enemigo

Ahora vamos a escribir un script que haga que el enemigo patrulle dentro de una zona. Este es uno de los comportamientos más comunes en los enemigos de juegos 2D, en el que el enemigo se mueve de un lado a otro y cambia de dirección cuando alcanza un borde.

Paso 2.1: Crear el Script de Movimiento

Vamos a añadir un script al nodo KinematicBody2D del enemigo. Este script hará que el enemigo se mueva en una dirección y cambie de rumbo cuando llegue al borde de su área de patrullaje.

  1. Añadir un Script:
  • Selecciona el nodo KinematicBody2D de tu enemigo y haz clic en el botón “Attach Script” en el panel superior.
  • En el nuevo script, agregaremos la lógica para mover al enemigo de un lado a otro.
extends KinematicBody2D

var speed = 100  # Velocidad de movimiento del enemigo
var direction = Vector2(1, 0)  # Dirección inicial (1, 0 significa que el enemigo se mueve hacia la derecha)

func _process(delta):
    # Mueve al enemigo en la dirección actual
    move_and_slide(direction * speed)

    # Si el enemigo llega a una posición fuera del área de patrullaje, cambia de dirección
    if position.x > 400 or position.x < 0:  # Ajusta los valores según el área donde quieras que patrulle
        direction.x *= -1  # Invierte la dirección en el eje X

Explicación del Código:

  1. var speed = 100:
  • Esta variable define la velocidad a la que se mueve el enemigo. Puedes ajustarla para hacer que el enemigo se mueva más rápido o más lento.
  1. var direction = Vector2(1, 0):
  • El vector direction se utiliza para definir la dirección del movimiento del enemigo. En este caso, Vector2(1, 0) significa que el enemigo se moverá hacia la derecha (eje X positivo).
  1. move_and_slide(direction * speed):
  • La función move_and_slide() es parte del nodo KinematicBody2D y mueve el enemigo de acuerdo con la dirección y la velocidad proporcionadas. El método también maneja las colisiones, lo que es útil si el enemigo debe interactuar con otros objetos.
  1. if position.x > 400 or position.x < 0::
  • Aquí estamos comprobando si el enemigo ha alcanzado los límites del área de patrullaje. Los valores 400 y 0 se utilizan como límites en el eje X, pero puedes ajustarlos según el tamaño de tu mapa o área de patrullaje.
  1. direction.x *= -1:
  • Si el enemigo llega a los límites establecidos, su dirección en el eje X se invierte (multiplicando direction.x por -1). Esto hace que el enemigo cambie de dirección y empiece a moverse en la dirección opuesta.

3. Mejoras y Personalizaciones

Paso 3.1: Agregar Animaciones de Movimiento

Si deseas que el enemigo tenga animaciones, puedes agregar un nodo AnimatedSprite en lugar de un Sprite para que el enemigo muestre diferentes animaciones durante el patrullaje.

  1. Añadir un nodo AnimatedSprite:
  • Si no lo has hecho ya, agrega un nodo AnimatedSprite como hijo del nodo KinematicBody2D de tu enemigo.
  1. Configurar las animaciones:
  • Carga las animaciones que desees (por ejemplo, “patrullando”, “atacando”, “muerto”) en el SpriteFrames de tu AnimatedSprite.
  1. Actualizar el script para controlar las animaciones:
extends KinematicBody2D

var speed = 100
var direction = Vector2(1, 0)

func _process(delta):
    # Mueve al enemigo y controla las animaciones
    move_and_slide(direction * speed)

    # Cambiar la animación de "patrullando"
    if velocity.length() > 0:
        $AnimatedSprite.play("patrol")
    else:
        $AnimatedSprite.stop()

    # Cambia la dirección si el enemigo llega a los bordes
    if position.x > 400 or position.x < 0:
        direction.x *= -1

Paso 3.2: Mejoras Adicionales

  1. Patrullaje más complejo:
  • Puedes hacer que el enemigo patrulle en una forma más compleja, como siguiendo un patrón o saltando entre diferentes puntos fijos usando Vector2 adicionales.
  1. Agregar interacción con el jugador:
  • El enemigo puede reaccionar a las interacciones con el jugador, como atacarlo cuando se acerque o seguirlo. Puedes usar un sistema de detección como Area2D para esto.

En esta lección, aprendimos cómo crear enemigos en Godot utilizando el nodo KinematicBody2D para manejar el movimiento y las colisiones. Vimos cómo hacer que el enemigo patrulle de un lado a otro, cómo agregar animaciones y cómo controlar la dirección del movimiento. Además, abordamos algunas mejoras y personalizaciones para hacer que los enemigos se comporten de manera más dinámica y realista dentro del juego.

Este es un paso fundamental para agregar vida y desafío a tu juego, ya que los enemigos son una parte esencial de cualquier experiencia interactiva. ¡Sigue experimentando y agrega más comportamientos y animaciones para hacer que tus enemigos sean aún más interesantes y desafiantes!



   func _process(delta):
       move_and_slide(direction * speed)
       if position.x > 400 or position.x < 0:  # Cambia los valores según el área
           direction.x *= -1

Lección 7: Sistema de Salud y Puntos de Vida

En esta lección, aprenderemos a implementar un sistema básico de salud para el personaje en Godot. Este sistema permitirá al personaje recibir daño al tocar a los enemigos y se eliminará cuando la salud llegue a cero. También veremos cómo manejar la detección de colisiones para reducir la salud y cómo configurar el comportamiento del personaje cuando muere.

1. Crear Variable de Salud

Paso 1.1: Añadir una Variable de Salud

Lo primero que debemos hacer es definir una variable para la salud del personaje. Esto nos permitirá realizar un seguimiento de cuánta vida le queda al personaje durante el juego.

  1. Añadir la variable health:
  • En el script de tu personaje (por ejemplo, Player.gd), añade una nueva variable health que representará los puntos de vida del personaje. Vamos a inicializarla con un valor de 100, lo que indica que el personaje comienza con 100 puntos de vida.
var health = 100  # Salud inicial del personaje

Explicación:

  • La variable health es un número que disminuye cada vez que el personaje recibe daño. En este caso, comenzamos con 100 puntos de vida, pero puedes ajustar este valor según lo que desees para tu juego.

2. Reducir Salud al Tocarse con Enemigos

Paso 2.1: Detectar Colisiones con Enemigos

Ahora que tenemos la variable health, necesitamos agregar la lógica para reducirla cuando el personaje entre en contacto con un enemigo. Usaremos señales para detectar las colisiones entre el personaje y los enemigos.

  1. Usar una señal para detectar colisiones:
  • En Godot, las señales nos permiten reaccionar a eventos. En este caso, utilizaremos la señal body_entered para detectar cuando el personaje entra en contacto con un enemigo. Esta señal está disponible en los nodos Area2D, por lo que necesitaremos tener un nodo Area2D en el personaje para manejar las colisiones.
  • Asegúrate de que el personaje tenga un nodo Area2D con un CollisionShape2D adecuado para cubrir su área de impacto.
  1. Crear el script de detección de daño:
  • En el nodo Area2D del personaje, conecta la señal body_entered al script del personaje. Esto permitirá que se ejecute una función cuando el personaje toque cualquier otro cuerpo (por ejemplo, un enemigo).
  • El siguiente código muestra cómo reducir la salud al detectar un enemigo:
func _on_Hurtbox_body_entered(body):
    if body.name == "Enemigo":  # Verifica si el cuerpo con el que colisionó es un enemigo
        health -= 10  # Reduce la salud en 10 puntos
        if health <= 0:
            queue_free()  # Elimina al personaje si la salud es 0 o menor

Explicación del Código:

  • _on_Hurtbox_body_entered(body): Esta es la función que se ejecuta cuando el Area2D del personaje detecta una colisión con otro cuerpo. El parámetro body es el objeto con el que ha colisionado el personaje.
  • if body.name == "Enemigo":: Comprobamos si el objeto con el que el personaje ha colisionado tiene el nombre “Enemigo”. Esto se utiliza para asegurarnos de que solo se reduzca la salud cuando el personaje toque un enemigo.
  • health -= 10: Si el personaje colisiona con un enemigo, se reduce la salud en 10 puntos.
  • if health <= 0:: Si la salud llega a cero o menos, el personaje “muere”.
  • queue_free(): Este comando elimina al personaje de la escena, lo que simula su muerte.

3. Mejoras y Personalizaciones

Paso 3.1: Mostrar la Salud en la Pantalla

Sería útil que el jugador pueda ver su salud mientras juega. Para hacer esto, puedes agregar una interfaz de usuario (UI) que muestre los puntos de vida actuales del personaje.

  1. Crear un Nodo de UI para la Salud:
  • En tu escena principal, crea un nodo Label que se encargará de mostrar la salud del jugador. Puedes colocarlo en una posición en la pantalla donde siempre sea visible.
  1. Actualizar el Texto del Label:
  • En el script de tu personaje, actualiza el texto del Label cada vez que se reduzca la salud.
onready var health_label = get_node("UI/HealthLabel")  # Asume que tienes un nodo Label en la escena UI

func _process(delta):
    health_label.text = "Salud: " + str(health)

Explicación:

  • onready var health_label = get_node("UI/HealthLabel"): Esto obtiene el nodo Label que has creado en la interfaz de usuario para mostrar la salud.
  • health_label.text = "Salud: " + str(health): Cada vez que se actualiza el proceso (es decir, en cada fotograma), el texto del Label se actualiza con el valor actual de la salud.

En esta lección, aprendimos cómo implementar un sistema básico de salud para nuestro personaje en Godot. Usamos una variable health para realizar un seguimiento de los puntos de vida y detectamos colisiones con los enemigos usando la señal body_entered. Cuando el personaje toca a un enemigo, su salud se reduce y, si la salud llega a cero, el personaje es eliminado.

También vimos cómo agregar una interfaz básica para mostrar la salud en pantalla, lo que mejora la experiencia del jugador.

Este sistema de salud es fundamental para cualquier juego que involucre combates o peligros, y puedes seguir expandiéndolo para agregar características como vidas extra, efectos visuales o sonoros cuando el personaje recibe daño, o incluso un sistema de regeneración de salud.

Lección 8: Creación de Objetos Coleccionables

En esta lección, vamos a aprender a crear objetos coleccionables en el juego, como monedas o ítems, que el personaje puede recoger. Al recoger estos objetos, el puntaje del jugador se incrementará, y el objeto desaparecerá de la escena. Para esto, utilizaremos nodos Area2D para detectar las colisiones y Sprite para representar visualmente los objetos.

1. Escena de Objeto Coleccionable

Paso 1.1: Crear un Nodo Area2D para el Objeto

El primer paso es crear una escena para el objeto coleccionable. Usaremos un Area2D como nodo principal, ya que este nodo nos permite detectar las colisiones con otros objetos, como el personaje. Además, necesitarás un Sprite para la imagen del objeto y un CollisionShape2D para que el objeto pueda interactuar con las colisiones.

  1. Crear el nodo Area2D:
  • En la vista de la escena, crea un nuevo nodo Area2D. Este nodo será el que detectará las colisiones con el personaje.
  1. Añadir un Sprite al Area2D:
  • Dentro del nodo Area2D, agrega un nodo Sprite. Este será el objeto visual que aparecerá en el juego, por ejemplo, una moneda, una estrella, o cualquier otro ítem coleccionable. En el Inspector, asigna una imagen al Sprite.
  1. Añadir un CollisionShape2D:
  • Añade un nodo CollisionShape2D dentro del Area2D para que el objeto pueda detectar las colisiones. En el Inspector, configura la forma de colisión según el objeto (por ejemplo, un círculo o un rectángulo, dependiendo de la forma del objeto coleccionable).

Paso 1.2: Crear el Script del Objeto Coleccionable

Una vez que tenemos la escena básica del objeto coleccionable, necesitamos añadir un script que maneje las colisiones y el incremento del puntaje del jugador cuando el objeto es recogido.

  1. Agregar el script al nodo Area2D:
  • Crea un nuevo script y asignalo al nodo Area2D. El script tendrá que manejar el evento de colisión y desaparecer el objeto después de que el personaje lo recoja.
  1. Escribir el código para aumentar el puntaje y eliminar el objeto:
func _on_Area2D_body_entered(body):
    if body.name == "Personaje":  # Verifica si el cuerpo que colisiona es el personaje
        body.score += 1  # Incrementa el puntaje del jugador
        queue_free()  # Elimina el objeto coleccionable de la escena

Explicación del Código:

  • _on_Area2D_body_entered(body): Esta función se ejecuta cuando otro cuerpo entra en el área de colisión del Area2D. El parámetro body es el objeto con el que el área de colisión ha entrado en contacto.
  • if body.name == "Personaje":: Comprobamos si el objeto con el que el objeto coleccionable ha colisionado es el personaje. Esto es útil para asegurarnos de que solo el personaje pueda recoger el objeto. Asegúrate de que el nodo del personaje tenga el nombre "Personaje" o modifica este nombre para que coincida con el nombre de tu nodo de personaje.
  • body.score += 1: Incrementa el puntaje del jugador. Esto asume que tu personaje tiene una variable score que lleva un registro de su puntaje. Si no la tienes, agrega esta variable en el script del personaje.
  • queue_free(): Este comando elimina el objeto coleccionable de la escena, haciendo que desaparezca visualmente cuando el personaje lo recoge.

2. Crear y Gestionar el Puntaje del Jugador

Paso 2.1: Variable de Puntaje en el Personaje

Para que el puntaje se actualice correctamente, necesitamos tener una variable en el script del personaje que lleve la cuenta de cuántos objetos ha recogido.

  1. Añadir la variable score:
  • En el script de tu personaje (por ejemplo, Player.gd), añade una nueva variable score que almacenará el puntaje actual del jugador.
var score = 0  # Puntaje inicial del jugador

Paso 2.2: Mostrar el Puntaje en la Pantalla

Para que el jugador vea su puntaje, puedes agregar una interfaz de usuario (UI) que muestre la cantidad de puntos recogidos.

  1. Crear un Nodo de UI para Mostrar el Puntaje:
  • En la escena principal, crea un nodo Label que se encargue de mostrar el puntaje del jugador. Colócalo en una posición visible en la pantalla.
  1. Actualizar el Puntaje en la UI:
  • En el script del personaje, actualiza el texto del Label cada vez que el puntaje cambie.
onready var score_label = get_node("UI/ScoreLabel")  # Asume que tienes un nodo Label en la escena UI

func _process(delta):
    score_label.text = "Puntaje: " + str(score)

Explicación:

  • onready var score_label = get_node("UI/ScoreLabel"): Esto obtiene el nodo Label que has creado en la interfaz de usuario para mostrar el puntaje.
  • score_label.text = "Puntaje: " + str(score): En cada fotograma, el texto del Label se actualiza con el valor actual de la variable score.

3. Resumen

En esta lección, hemos aprendido cómo crear objetos coleccionables en Godot utilizando nodos Area2D, Sprite y CollisionShape2D para detectar colisiones. Cuando el personaje toca el objeto, el puntaje del jugador se incrementa, y el objeto desaparece de la escena.

También hemos cubierto cómo gestionar el puntaje en el script del personaje y cómo mostrarlo en la pantalla utilizando un nodo Label.

Este sistema de objetos coleccionables es una característica básica en muchos juegos, y puedes ampliarlo añadiendo diferentes tipos de objetos con distintos efectos, como objetos que dan puntos extra o que activan poderes especiales. ¡Experimenta creando más objetos coleccionables para enriquecer tu juego!

Lección 9: Interfaz de Usuario Básica

En esta lección, aprenderemos cómo crear una interfaz de usuario básica en Godot. Nos enfocaremos en la creación de una barra de salud que refleje el valor de la salud del personaje en tiempo real, lo que permitirá al jugador ver cómo disminuye su salud durante el juego.

1. Crear la Barra de Salud

Paso 1.1: Usar un Nodo TextureProgress para la Barra de Salud

Para mostrar la salud del personaje de manera visual, podemos utilizar el nodo TextureProgress. Este nodo es ideal para mostrar barras de progreso, como la salud, la energía o cualquier otro tipo de indicador.

  1. Agregar el Nodo TextureProgress:
  • En la escena principal o en un contenedor de UI, agrega un nodo TextureProgress.
  • Este nodo tiene propiedades que permiten mostrar una barra con un fondo y una “carga” que puede ir aumentando o disminuyendo.
  1. Configurar el TextureProgress:
  • En el Inspector, busca las propiedades Min Value y Max Value. Establece Min Value a 0 (representando la salud mínima) y Max Value a 100 (representando la salud máxima del personaje).
  • Para el fondo de la barra de salud, puedes asignar una textura o color en la propiedad Under Texture. Esto representará la parte de la barra que está vacía.
  • En la propiedad Progress Texture, asigna una textura o color para representar la parte de la barra que está llena, es decir, la cantidad de salud que le queda al personaje.

Paso 1.2: Conectar la Barra de Salud al Código del Personaje

Ahora que tenemos el nodo de barra de salud, debemos conectarlo al script del personaje para que la barra de salud se actualice dinámicamente a medida que la salud del personaje cambie.

  1. Conectar el Nodo TextureProgress al Código:
  • En el script de tu personaje, necesitas hacer que la propiedad value del TextureProgress refleje la variable de salud del personaje.
onready var health_bar = get_node("UI/HealthBar")  # Asumiendo que la barra de salud está en la UI

var health = 100  # Salud inicial

func _process(delta):
    health_bar.value = health  # Actualiza la barra de salud con el valor de la salud del personaje

Explicación del Código:

  • onready var health_bar = get_node("UI/HealthBar"): Esto obtiene el nodo TextureProgress que hemos creado para la barra de salud. Asegúrate de que la ruta del nodo sea correcta (en este caso, se supone que está dentro de un nodo de UI).
  • health_bar.value = health: En cada fotograma, actualizamos el valor de la barra de salud con el valor actual de la variable health del personaje. Esto hace que la barra se actualice visualmente en tiempo real.

En esta lección, hemos aprendido cómo agregar una barra de salud utilizando el nodo TextureProgress en Godot. Hemos configurado el nodo para que refleje la salud del personaje y lo hemos conectado al código del personaje para que la barra de salud se actualice dinámicamente.

Este es solo uno de los muchos elementos que puedes agregar a la interfaz de usuario para mejorar la experiencia del jugador. Puedes extender esto añadiendo otras barras de progreso, como una barra de energía, o creando indicadores visuales para el puntaje, tiempo, o estados del personaje.

Lección 11: Pulido Final y Exportación

En esta última lección, vamos a concentrarnos en los pasos finales de tu proyecto, asegurándonos de que el juego esté listo para ser jugado y distribuido. Cubriremos el proceso de exportación para llevar tu juego a diferentes plataformas, ya sea para compartirlo con otros o subirlo a una tienda en línea.

1. Pulido Final

Antes de exportar tu juego, es importante que pases por una fase de pulido. Esto implica revisar y mejorar diferentes aspectos del juego para asegurarte de que sea lo más fluido y libre de errores posible. Aquí tienes algunas cosas que podrías considerar:

1.1. Revisión de la Jugabilidad

  • Prueba de movimiento y controles: Asegúrate de que los controles sean intuitivos y que el personaje se mueva sin problemas.
  • Balance de dificultad: Verifica que la dificultad del juego sea apropiada. Si los enemigos o las mecánicas están demasiado fáciles o difíciles, ajusta sus parámetros.

1.2. Optimización

  • Reducir la cantidad de recursos: Si el juego contiene muchas imágenes, sonidos o efectos, es recomendable reducir el tamaño de estos archivos para optimizar el rendimiento.
  • Optimizar el código: Revisa que no haya ciclos de código innecesarios o redundantes. Usa las herramientas de depuración de Godot para revisar el rendimiento del juego.

1.3. Pruebas de Bugs

  • Revisar colisiones: Asegúrate de que las colisiones entre el personaje, enemigos y objetos funcionen correctamente.
  • Verificar la interfaz de usuario (UI): La UI debe actualizarse correctamente (por ejemplo, la barra de salud debe reflejar el estado real de la salud).
  • Pruebas generales: Juega el juego de principio a fin y toma nota de cualquier error que pueda surgir, ya sea visual o funcional.

2. Exportación del Juego

Una vez que hayas pulido todos los detalles, es hora de exportar el juego para que otros puedan jugarlo. Godot tiene una herramienta de exportación bastante flexible que permite crear archivos ejecutables para diferentes plataformas, como Windows, macOS, Linux, Android, iOS, HTML5, entre otras.

2.1. Configurar el Proyecto para Exportación

  1. Abrir la ventana de exportación:
  • Ve a Project en la barra de menú superior y selecciona Export.
  1. Seleccionar el sistema operativo de destino:
  • En la ventana de exportación, haz clic en Add… y selecciona la plataforma a la que quieres exportar tu juego. Por ejemplo:
    • Para Windows, selecciona Windows Desktop.
    • Para Android, selecciona Android.
    • Para HTML5, selecciona HTML5.
  1. Configurar las opciones de exportación:
  • En cada plataforma seleccionada, puedes ajustar opciones como el nombre del archivo, la resolución del juego, el icono del juego, entre otras configuraciones específicas para la plataforma de destino.
  • Si exportas a HTML5, asegúrate de que los archivos web estén bien configurados.
  1. Guardar la configuración de exportación:
  • Una vez que hayas ajustado todas las configuraciones necesarias, guarda el archivo de exportación.

2.2. Exportar el Juego

  • Una vez que hayas terminado con las configuraciones, haz clic en el botón Export para generar el archivo ejecutable.
  • Windows: Esto generará un archivo .exe que podrás ejecutar en cualquier PC con Windows.
  • HTML5: Esto generará una carpeta con los archivos HTML y JS que puedes subir a un servidor web o utilizar en una página web.

2.3. Probar el Juego Exportado

  • Después de la exportación, asegúrate de probar el juego en la plataforma de destino. Esto te ayudará a asegurarte de que el juego se ejecute correctamente en un entorno real.
  • Si exportaste a Windows, prueba el archivo .exe en una máquina con Windows.
  • Si exportaste a HTML5, abre el archivo .html en un navegador web para comprobar cómo funciona en línea.

3. Consideraciones Finales

3.1. Preparación para el Lanzamiento

  • Publicidad y promoción: Si planeas compartir tu juego con más personas, prepara materiales de promoción como capturas de pantalla, trailers, y una descripción atractiva.
  • Publicar en tiendas de aplicaciones: Si deseas llevar tu juego a plataformas como Google Play, Steam, o itch.io, revisa las directrices específicas para cada plataforma para asegurarte de que tu juego cumpla con los requisitos.

3.2. Mantenimiento del Juego

  • Después de la exportación, mantén el proyecto y realiza actualizaciones cuando sea necesario, ya sea para corregir errores, mejorar características o agregar contenido.

En esta lección final, hemos cubierto los pasos de pulido y exportación de tu juego en Godot. Asegúrate de revisar y ajustar los detalles de jugabilidad, optimizar los recursos y corregir cualquier error antes de exportar. Luego, sigue los pasos para configurar y exportar el juego a la plataforma de tu elección, ya sea para compartir con amigos, jugadores o distribuirlo en una tienda de aplicaciones.

Con esto, tu juego está listo para ser jugado y compartido con el mundo.

¡Felicidades por completar este curso y buena suerte con tu juego! YEEEEAHHH!

Puntúa este post
[Total: 3 Average: 5]

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *