C++ para Brasa

C++ tiene fama de difícil, pero para hacer juegos en Brasa usas una parte pequeña de él. Esta página explica esa parte, con ejemplos sacados del tutorial.

Cuando pulsas Play, Brasa compila tu código: convierte el texto de los archivos .cpp en un programa. Si algo está mal escrito, el compilador avisa en la Saída (Salida) antes de que el juego se abra.

Variables y tipos

Una variable guarda un valor. En C++, dices su tipo:

int lives = 3;          // número entero
float speed = 2.0f;     // número con decimales (la f al final marca un float)
bool canShoot = true;   // verdadero o falso
auto dx = 0.0f;         // auto: el compilador descubre el tipo (aquí, float)

• Usa float para posiciones y velocidades, e int para conteos, como vidas y puntos.
• const marca algo que no cambia después de creado: const float margin = 16.0f;.

Las instancias ya vienen con varias variables listas, como x, y, hspeed y vspeed. Mira Objetos y eventos.

Cuentas

x = x + 2;      // suma 2 a x
x += 2;         // lo mismo, más corto
--invincible;   // resta 1
++spawned;      // suma 1

if, else, && y ||

if (held(Key::Space) && canShoot_) {
    // espacio pulsado Y puede disparar
}

if (state().lives <= 0) {
    goTo("GameOver");
} else {
    invincible_ = 90;
}

• && es y, || es o, ! es no.
• Para comparar: == (igual), != (distinto), <, >, <=, >=.

Precaución

= guarda un valor y == compara. if (lives = 0) es un error clásico: lo correcto es if (lives == 0).

Funciones

Una función es un bloque de código con nombre. Puede recibir valores y devolver un resultado:

float centeredX(std::string_view text, float screenWidth) {
    return (screenWidth - text.size() * 8.0f) / 2.0f;
}

La mayor parte del tiempo, llamas a funciones de Brasa: spawn<Bullet>(x, y, "Instancias"), random(0.8f, 1.6f), Audio::play("tiro").

Clases, Entity y override

Cada objeto del juego es una clase que hereda de brasa::Entity:

class Player : public brasa::Entity {
public:
    void onSpawn() override;
    void onUpdate() override;

private:
    bool canShoot_ = true;
};

• : public brasa::Entity quiere decir que el Player es una Entity: recibe posición, sprite, velocidad y todas las funciones de Brasa.
• onSpawn y onUpdate son eventos. La Entity ya tiene esos eventos, vacíos. El override dice que estás cambiando su comportamiento.
• Lo que queda en private: solo lo usa la propia clase. Es común terminar esos nombres con _, como en canShoot_.

El código de cada función va en el .cpp, con el nombre de la clase delante:

void Player::onUpdate() {
    // se ejecuta en cada paso
}

El Player:: dice “esta es la función onUpdate del Player”.

Lambdas: código para después

Algunas funciones de Brasa reciben un trozo de código para ejecutar más tarde. Ese trozo es una lambda:

after(10, [this] { canShoot_ = true; });

onCollide<Enemy>([this](Enemy& enemy) {
    if (hurt()) enemy.destroy();
});

• [this] permite que la lambda use las cosas de la instancia, como canShoot_ y hurt().
• (Enemy& enemy) es lo que la lambda recibe: en el onCollide, el enemigo que la tocó.
• El & quiere decir que recibes al propio enemigo, no una copia, así que enemy.destroy() destruye al enemigo de verdad.

Templates: el <Tipo>

En spawn<Bullet>(x, y, "Instancias"), count<Enemy>() y onCollide<Enemy>(...), lo que va entre < > es qué objeto. Así es como Brasa sabe qué crear, contar o detectar.

#include, namespace y using

#include "Player.hpp"      // trae la clase de este objeto
#include "src/game.hpp"    // trae lo que es de todo el juego (puntos y vidas)
#include <algorithm>       // trae std::clamp y std::max de la biblioteca estándar

using namespace brasa;     // permite escribir Audio::play en vez de brasa::Audio::play

• #include copia el contenido de otro archivo en este. Usa comillas para tus archivos y < > para bibliotecas.
• Un namespace es una “carpeta” de nombres. Brasa usa brasa. Las clases de tus objetos quedan fuera de namespace.
• std:: es el namespace de la biblioteca estándar de C++: std::clamp, std::max, std::format.

Leer los errores del compilador

Cuando el Play falla, la Saída muestra el error con el archivo y la línea, por ejemplo:

Player.cpp(23,5): error C2143: error de sintaxis: falta ';' delante de 'if'

Eso quiere decir: en el Player.cpp, línea 23, columna 5, faltó un ;. Haz clic en el error y tu editor de código se abre en esa línea. Los errores más comunes (el compilador los escribe en el idioma de tus Visual Studio Build Tools):

Mensaje (parecido a)	Qué suele ser
falta ';'	Faltó el ; al final de la línea anterior.
identificador no declarado	Nombre mal escrito, o falta un #include (por ejemplo el src/game.hpp).
no se puede convertir	Tipos distintos, como int y float. Un static_cast<float>(...) lo resuelve.
se esperaba '}'	Una llave { quedó sin cerrar.

Mira también Play y errores.

Para aprender más

• Documentación de C++ de Microsoft, en español: la referencia del lenguaje y de la biblioteca estándar.
• La plantilla Primeiro Jogo: todo el código tiene comentarios (en portugués) que explican lo que hace cada línea.