2. A nave

Nesta parte

Você vai criar o objeto da nave, colocá-lo na room e escrever o código que faz a nave andar com as setas do teclado, com WASD ou com um controle. No fim, você aperta Play e pilota a nave.

Criar o objeto Player

Um objeto é um tipo de coisa do jogo. O objeto Player é a nave do jogador.

1. No painel Recursos, clique com o botão direito na pasta objects e escolha Novo objeto…. Dê o nome Player.

2. Selecione Player. No Inspetor, em Aparência, escolha o sprite nave.

3. Na seção Variáveis, clique em + Variável e escolha número. Clique no nome, troque para velocidade, e coloque o valor 2. É a velocidade da nave, em pixels por passo.

   

Uma variável é um valor com nome que você ajusta aqui, no editor, e usa no código. Para deixar a nave mais rápida depois, é só mudar esse número: não precisa mexer no código. Veja Variáveis.

Colocar a nave na room

1. Abra a room Main (dois cliques em Main, na pasta rooms).

2. Arraste o Player do painel Recursos para a room, perto do meio da parte de baixo.

3. Com a nave selecionada, o Inspetor mostra a posição dela. Em Posição, coloque X = 160 e Y = 150. Arraste o número ou dê dois cliques para digitar.

Os dois arquivos do objeto

Cada objeto do jogo vira uma classe em C++. Ao criar o Player, a Brasa criou dois arquivos para ela, na pasta objects:

• Player.hpp diz o que a nave tem: os eventos que ela usa e os dados que ela guarda;
• Player.cpp diz o que ela faz em cada evento.

Abra a setinha ao lado do Player, em Recursos, e dê dois cliques no Player.hpp. Ele abre no seu editor de código, com alguns exemplos. Apague tudo e escreva:

objects/Player.hpp

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

// A nave. velocidade é uma variável do objeto: mude no Inspetor, sem mexer no código.
class Player : public brasa::Entity {
public:
    BRASA_VARS(Player)

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

C++ rapidinho: o que é isso tudo?

• #pragma once evita que o arquivo seja incluído duas vezes.
• #include <brasa/brasa.hpp> traz tudo da Brasa para o seu código.
• class Player : public brasa::Entity cria a classe Player a partir de Entity, a base de todo objeto da Brasa. O Player herda posição, sprite, velocidade e tudo mais.
• BRASA_VARS(Player) traz para a classe as variáveis que você criou no Inspetor. É por causa dessa linha que o código pode usar velocidade.
• onSpawn e onUpdate são eventos: funções que a Brasa chama sozinha. O override diz “estou trocando o comportamento padrão deste evento”.

Mais em C++ para a Brasa.

Fazer a nave andar

Agora abra o Player.cpp (no Inspetor do objeto, { } Abrir código). Apague tudo e escreva:

objects/Player.cpp

#include "Player.hpp"

#include <algorithm>

using namespace brasa;

void Player::onSpawn() {
    animSpeed = 0.2f;  // a chama do motor alterna entre os 2 frames
}

void Player::onUpdate() {
    // As ações ficam em Configurações do projeto (teclado e controle).
    // axis devolve de -1 a 1: -1 = a primeira ação, 1 = a segunda.
    float dx = axis("esquerda", "direita");
    float dy = axis("cima", "baixo");
    if (dx != 0.0f && dy != 0.0f) {  // na diagonal, anda com a mesma velocidade
        dx *= 0.7071f;
        dy *= 0.7071f;
    }

    // clamp mantém a nave dentro da tela (a nave tem 16 px, então a margem é 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);

O que cada parte faz:

• #include "Player.hpp" traz a classe que você acabou de escrever.
• Player::onSpawn roda uma vez, quando a nave nasce. animSpeed = 0.2f faz a animação avançar 0,2 quadro por passo, ou seja, troca de quadro a cada 5 passos. (Se o sprite tiver um fps definido no editor, o animSpeed passa a multiplicar esse fps: veja Animar um sprite.)
• Player::onUpdate roda a cada passo, 60 vezes por segundo. Ele lê os comandos e move a nave.
• axis("esquerda", "direita") devolve -1 com a ação esquerda, 1 com a direita e 0 com nenhuma. dx e dy guardam para onde a nave quer ir.
• Na diagonal, a nave andaria mais rápido (as duas direções somam). Multiplicar por 0.7071 corrige isso.
• x e y são a posição da nave. velocidade é a variável que você criou no Inspetor. std::clamp(valor, mínimo, máximo) segura o valor dentro dos limites, e roomWidth() e roomHeight() dão o tamanho da room. Assim a nave não sai da tela.
• BRASA_ENTITY(Player); registra a classe na Brasa. É assim que o objeto Player do editor encontra o seu código.

O que são as ações

esquerda, direita, cima e baixo são ações: nomes ligados a teclas e a botões do controle. Um projeto novo já vem com elas, valendo para as setas, para WASD e para o direcional e o analógico de um controle.

Para ver ou mudar, abra Projeto › Configurações do projeto… e procure Ações de entrada. Como o código pergunta pela ação, e não pela tecla, dá para trocar as teclas sem mexer nele. Veja Teclado e controle com ações.

Teste agora

Aperte Play (ou F5). Da primeira vez, a compilação demora um pouco mais. A janela do jogo abre com a nave embaixo. Ande com as setas ou com WASD e veja a chama do motor tremulando.

Agora feche o jogo, mude a velocidade no Inspetor do Player para 4 e aperte Play de novo: a nave fica mais rápida, sem você tocar no código. Volte para 2 antes de continuar.

Se aparecer um erro na Saída, clique nele: o seu editor de código abre na linha do problema. Confira se o código está igual ao de cima. Veja também Play e erros.

O que você aprendeu

• Cada objeto tem um sprite e dois arquivos de código: o .hpp (a classe) e o .cpp (o que ela faz).
• onSpawn roda uma vez, quando o objeto nasce; onUpdate roda a cada passo.
• Uma variável criada no Inspetor vira um valor que o código usa pelo nome.
• axis lê duas ações e diz para que lado ir. Veja Mover com o teclado.
• x e y são a posição do objeto, e roomWidth()/roomHeight() o tamanho da room.

Próxima parte: 3. Tiros →