2. La nave

En esta parte

Vas a crear el objeto de la nave, colocarlo en la room y escribir el código que hace que la nave se mueva con las flechas del teclado, con WASD o con un mando. Al final, pulsas Play y pilotas la nave.

Crear el objeto Player

Un objeto es un tipo de cosa del juego. El objeto Player es la nave del jugador.

1. En el panel Recursos, haz clic derecho en la carpeta objects y elige Novo objeto… (nuevo objeto). Ponle el nombre Player.

2. Selecciona Player. En el Inspetor (Inspector), en Aparência (apariencia), elige el sprite nave.

3. En la sección Variáveis (variables), haz clic en + Variável y elige número. Haz clic en el nombre, cámbialo a velocidade (velocidad) y pon el valor 2. Es la velocidad de la nave, en píxeles por paso.

   

Una variable es un valor con nombre que ajustas aquí, en el editor, y usas en el código. Para que la nave sea más rápida después, basta con cambiar ese número: no hace falta tocar el código. Mira Variables.

Colocar la nave en la room

1. Abre la room Main (doble clic en Main, en la carpeta rooms).

2. Arrastra el Player del panel Recursos a la room, cerca del centro de la parte de abajo.

3. Con la nave seleccionada, el Inspetor muestra su posición. En Posição (posición), pon X = 160 e Y = 150. Arrastra el número o haz doble clic para escribir.

Los dos archivos del objeto

Cada objeto del juego se convierte en una clase en C++. Al crear el Player, Brasa creó dos archivos para ella, en la carpeta objects:

• Player.hpp dice qué tiene la nave: los eventos que usa y los datos que guarda;
• Player.cpp dice qué hace en cada evento.

Abre la flechita al lado del Player, en Recursos, y haz doble clic en Player.hpp. Se abre en tu editor de código, con algunos ejemplos. Borra todo y escribe:

objects/Player.hpp

#pragma once
#include <brasa/brasa.hpp>

// La nave. velocidade es una variable del objeto: cámbiala en el Inspector, sin tocar el código.
class Player : public brasa::Entity {
public:
    BRASA_VARS(Player)

    void onSpawn() override;
    void onUpdate() override;
};

C++ en un momento: ¿qué es todo esto?

• #pragma once evita que el archivo se incluya dos veces.
• #include <brasa/brasa.hpp> trae todo lo de Brasa a tu código.
• class Player : public brasa::Entity crea la clase Player a partir de Entity, la base de todo objeto de Brasa. El Player hereda posición, sprite, velocidad y todo lo demás.
• BRASA_VARS(Player) trae a la clase las variables que creaste en el Inspector. Gracias a esa línea el código puede usar velocidade.
• onSpawn y onUpdate son eventos: funciones que Brasa llama sola. El override dice “estoy cambiando el comportamiento por defecto de este evento”.

Más en C++ para Brasa.

Hacer que la nave se mueva

Ahora abre el Player.cpp (en el Inspetor del objeto, { } Abrir código). Borra todo y escribe:

objects/Player.cpp

#include "Player.hpp"

#include <algorithm>

using namespace brasa;

void Player::onSpawn() {
    animSpeed = 0.2f;  // la llama del motor alterna entre los 2 frames
}

void Player::onUpdate() {
    // Las acciones están en la configuración del proyecto (teclado y mando).
    // axis devuelve de -1 a 1: -1 = la primera acción, 1 = la segunda.
    float dx = axis("esquerda", "direita");
    float dy = axis("cima", "baixo");
    if (dx != 0.0f && dy != 0.0f) {  // en diagonal, avanza a la misma velocidad
        dx *= 0.7071f;
        dy *= 0.7071f;
    }

    // clamp mantiene la nave dentro de la pantalla (la nave mide 16 px, así que el margen es 8).
    const float maxX = static_cast<float>(roomWidth()) - 8.0f;
    const float maxY = static_cast<float>(roomHeight()) - 8.0f;
    x = std::clamp(x + dx * velocidade, 8.0f, maxX);
    y = std::clamp(y + dy * velocidade, 8.0f, maxY);
}

BRASA_ENTITY(Player);

Qué hace cada parte:

• #include "Player.hpp" trae la clase que acabas de escribir.
• Player::onSpawn corre una vez, cuando nace la nave. animSpeed = 0.2f hace que la animación avance 0,2 cuadro por paso, es decir, cambia de cuadro cada 5 pasos. (Si el sprite tiene un fps definido en el editor, el animSpeed pasa a multiplicar ese fps: mira Animar un sprite.)
• Player::onUpdate corre en cada paso, 60 veces por segundo. Lee los comandos y mueve la nave.
• axis("esquerda", "direita") devuelve -1 con la acción esquerda (izquierda), 1 con direita (derecha) y 0 con ninguna. dx y dy guardan hacia dónde quiere ir la nave.
• En diagonal, la nave avanzaría más rápido (las dos direcciones se suman). Multiplicar por 0.7071 lo corrige.
• x e y son la posición de la nave. velocidade es la variable que creaste en el Inspector. std::clamp(valor, mínimo, máximo) mantiene el valor dentro de los límites, y roomWidth() y roomHeight() dan el tamaño de la room. Así la nave no sale de la pantalla.
• BRASA_ENTITY(Player); registra la clase en Brasa. Así es como el objeto Player del editor encuentra tu código.

Qué son las acciones

esquerda, direita, cima (arriba) y baixo (abajo) son acciones: nombres unidos a teclas y a botones del mando. Un proyecto nuevo ya viene con ellas, valiendo para las flechas, para WASD y para la cruceta y el stick de un mando.

Para verlas o cambiarlas, abre Projeto › Configurações do projeto… (Proyecto › Configuración del proyecto) y busca Ações de entrada (acciones de entrada). Como el código pregunta por la acción, y no por la tecla, puedes cambiar las teclas sin tocarlo. Mira Teclado y mando con acciones.

Pruébalo ahora

Pulsa Play (o F5). La primera vez, la compilación tarda un poco más. La ventana del juego se abre con la nave abajo. Muévete con las flechas o con WASD y mira la llama del motor ondeando.

Ahora cierra el juego, cambia la velocidade en el Inspector del Player a 4 y pulsa Play de nuevo: la nave se vuelve más rápida, sin que toques el código. Vuelve a 2 antes de continuar.

Si aparece un error en la Saída (Salida), haz clic en él: tu editor de código se abre en la línea del problema. Revisa que el código esté igual al de arriba. Mira también Play y errores.

Lo que aprendiste

• Cada objeto tiene un sprite y dos archivos de código: el .hpp (la clase) y el .cpp (lo que hace).
• onSpawn corre una vez, cuando nace el objeto; onUpdate corre en cada paso.
• Una variable creada en el Inspector se convierte en un valor que el código usa por su nombre.
• axis lee dos acciones y dice hacia qué lado ir. Mira Mover con el teclado.
• x e y son la posición del objeto, y roomWidth()/roomHeight() el tamaño de la room.

Siguiente parte: 3. Disparos →