Pular para o conteúdo
BrasaBrasa
Baixar
DownloadNovidadesRoadmapDocumentação

Novidades

  1. Brasa 0.6.0

    Mais nova

    Brasa 0.6.0

    O jogo roda dentro do editor, as listas da interface rolam, o jogo salva dados, toca música em OGG e MP3, e o editor e o instalador ganharam inglês.

    O que há de novo

    • Painel Jogo. O Play roda o jogo numa aba ao lado do Editor, sem abrir outra janela. Clique no jogo para ele receber o teclado. No topo do painel dá para escolher Neste painel ou Numa janela.

    • Listas que rolam. No Inspetor de um Painel, Rolar esconde o que passa da borda e a roda do mouse rola a lista. O código tem setScroll e scroll, e mouseWheel() devolve a roda do mouse para o jogo usar.

    • Mouse entrou e saiu. Além do clique, os elementos da interface avisam quando o mouse entra e sai:

      linha.onMouseEnter(this, [linha] { linha.setColor(Color{58, 68, 102, 220}); });
linha.onMouseLeave(this, [linha] { linha.setColor(Color{30, 34, 54, 220}); });

    • Salvar dados do jogo. brasa::Save guarda números, textos e sim/não entre uma execução e outra (o recorde, o que foi comprado, as opções):

      Save::set("recorde", pontos);
int recorde = Save::getInt("recorde");

      O arquivo fica em %APPDATA%\Brasa\Jogos\<nome do jogo>\save.json.

    • Música e sons comprimidos. O projeto aceita .ogg e .mp3 além do .wav. Audio::playMusic("tema") toca a música de fundo lendo o arquivo aos poucos (não ocupa a memória toda), com stopMusic, setMusicVolume e musicPlaying. Os efeitos curtos continuam com Audio::play.

    • Editor e instalador em inglês. O instalador pergunta o idioma na primeira tela (começa no do Windows) e o editor abre nele. Para trocar depois: Projeto › Preferências › Idioma; vale na hora.

    • Excluir projeto pelo hub. No menu do projeto, Excluir projeto... manda a pasta inteira para a Lixeira do Windows (dá para recuperar de lá). Remover da lista continua só tirando da lista.

    • Modelo Zumbis atualizado. A loja rola, as linhas acendem com o mouse, o recorde fica salvo e o jogo tem música de fundo.

    Também nesta versão

    • A câmera com zoom anda suave na diagonal (sem tremer de pixel em pixel).
    • Sem frestas entre os tiles quando a tela do jogo é ampliada por um número quebrado (no painel Jogo, ou numa janela com "Manter proporção" ou "Esticar").
    • Ao perder o foco (Alt+Tab, clique fora), o jogo solta as teclas que estavam apertadas.

    Para quem atualiza

    Nenhum projeto muda: o formato continua o da 0.3. O arranjo dos painéis do editor é mantido, e o painel Jogo aparece como uma aba ao lado do Editor.

    Limites desta versão

    • As mensagens da engine e do brasa_cli (o que aparece na Saída vindo do jogo) continuam em português.
    • Os nomes que fazem parte do projeto (camadas, ações de entrada) não mudam com o idioma do editor.
    • No painel Jogo, a imagem passa por um filtro suave quando o painel não tem um tamanho múltiplo da resolução do jogo; em janela ou tela cheia ela continua "seca".
    • A lógica do jogo roda a 60 passos por segundo; num monitor de 120 Hz ou mais o movimento não usa a taxa toda.
    • Só uma música toca por vez.
    • Sem caixa de digitar texto, slider nem caixa de marcar na interface.
    Baixar 0.6.0

  2. Brasa 0.5.0

    Brasa 0.5.0

    A interface do jogo (menus, HUD, telas, lojas) agora é montada no editor, com o mouse, e comandada pelo código.

    O que há de novo

    • Recurso Interface. Em Recursos, + › Nova interface... cria um arquivo nome.ui.json e abre a aba dele: a tela do jogo, onde você põe e arrasta Painéis, Textos, Imagens, Botões e Barras. O que aparece na aba é desenhado pelo mesmo código do jogo.

    • Aparência no Inspetor. Âncora (o elemento acompanha a tela em qualquer resolução), posição, tamanho, cores com transparência, borda, sprite de fundo em 9 fatias (os cantos não deformam), texto, alinhamento, quebra de linha e as cores do botão com o mouse em cima e apertado.

    • A lógica é do código. O editor cuida da aparência; o que cada botão faz e o que cada texto mostra você decide no código, com um endereço para a interface e os elementos dela:

      Ui::Element loja = Ui::get("Loja");
loja["Moedas"].setText("Moedas: 12");
loja["Fechar"].onClick(this, [] { Ui::hide("Loja"); });
loja.show();

      Dá para mudar texto, valor da barra, sprite, cores, fonte, posição, tamanho, esconder e desativar um botão.

    • Listas. Um Painel pode organizar os filhos em coluna, linha ou grade. O código copia um item montado no editor com clone (um por item da loja, do inventário, da seleção de fase) e tira com remove.

    • Fontes. + › Importar fonte (TTF)... traz uma fonte para o projeto. Textos e botões escolhem a Fonte e o Tamanho em pixels. O texto com fonte é desenhado na resolução da janela: fica nítido mesmo num jogo de pixel art ampliado.

    • Texto com acentos. A fonte embutida agora escreve ação, coração e año, e tem tamanhos (8, 16, 24...). drawText ganhou as formas com tamanho e com fonte.

    • Pausar o jogo. setPaused(true) para as instâncias (temporizadores, onUpdate, movimento e colisões); o desenho e a interface continuam. Enquanto pausado, as instâncias recebem onPausedUpdate(). Trocar de room tira a pausa.

    • Zoom da câmera. No Inspetor da room, Zoom amplia o mundo sem ampliar a interface: dá para fazer um jogo de pixel art (sprites de 16 pixels) em 1920×1080, com menus e textos em alta resolução. O mouse (mouseX, mouseY) já vem em coordenadas do mundo.

    • Cada room abre as interfaces dela. No Inspetor da room, a seção Interfaces marca quais aparecem junto (o HUD nas fases, o menu na room do menu).

    • O clique na interface não vaza para o jogo. Com o mouse em cima de um botão ou painel, mousePressed e companhia devolvem false para o jogo. Ui::mouseOver() diz se o mouse está na interface.

    • Edição confortável. A tela do jogo se ajusta à aba (roda do mouse: zoom; botão do meio: arrastar). Mover e redimensionar pelas alças, setas para mover de 1 em 1 pixel (Shift: 8), guias que grudam nas bordas e no meio do pai e dos irmãos (Alt desliga), copiar, recortar, colar, duplicar, desfazer e refazer.

    • Modelo novo: Zumbis. Um jogo de tiro visto de cima em 1920×1080: ondas de zumbis, dinheiro, loja com armas e munição, HUD, pausa, fim de jogo e sons. Mostra o zoom da câmera, a interface com listas e a pausa pelo código. A arte e os sons são próprios da Brasa.

    • Modelo Plataforma atualizado. O placar, a tela de pausa (Esc) e a de fim de fase são interfaces, ligadas pelo código da Fase.

    Também nesta versão

    • As imagens de pixel art ampliadas no editor (a folha do sprite, os tiles, a paleta da camada) deixaram de sair borradas.

    Para quem atualiza

    Nenhum projeto muda: o formato continua o da 0.3, e a interface é um recurso a mais. Os jogos que desenham o placar com drawText continuam funcionando.

    Limites desta versão

    • Sem rolagem: uma lista maior que o painel passa da borda.
    • O único evento é o clique do botão; ainda não há "mouse entrou" e "mouse saiu".
    • Sem caixa de digitar texto, slider nem caixa de marcar.
    • As posições e os tamanhos são em pixels do jogo, sem tamanho relativo à tela (as âncoras cobrem o caso comum).
    • A fonte embutida só tem múltiplos de 8 pixels; para outros tamanhos, importe um .ttf.
    • As fontes cobrem o inglês, o português e o espanhol (Latin-1).
    • Ainda não há como salvar dados do jogo (o que foi comprado, o recorde) entre uma execução e outra.
    Baixar 0.5.0

  3. Brasa 0.4.0

    Brasa 0.4.0

    Agora dá para exportar o jogo e mandar para outra pessoa.

    O que há de novo

    • Exportar jogo. Em Projeto › Exportar jogo..., escolha uma pasta. A Brasa compila o jogo e monta uma pasta com o nome do projeto, com o executável e uma pasta data (as rooms, os objetos, os sprites, os tilesets e os sons). Quem recebe só precisa abrir o .exe: não precisa da Brasa, do Visual Studio nem de nenhum arquivo a mais.
    • Zip pronto para enviar. A opção Gerar também o .zip cria um arquivo só, com a pasta do jogo dentro.
    • O código-fonte não vai junto. Só o que o jogo lê é copiado. Os .cpp, os .hpp, a lixeira e os arquivos de trabalho ficam de fora.
    • Pela linha de comando: brasa_cli export <pasta do projeto> <pasta de saída> faz o mesmo (--no-zip pula o zip).

    Por dentro

    • O código do editor foi reorganizado em arquivos menores, por assunto (configurações, diálogos, Play, Inspetor, Recursos...). Nada muda no uso: é para a Brasa continuar fácil de manter e de receber recursos novos.

    Para quem atualiza

    Nenhum projeto muda. O formato continua o da 0.3.

    Limites desta versão

    • Só exporta para Windows.
    • O jogo exportado usa o ícone da Brasa; ícone próprio vem depois.
    • Os dados ficam numa pasta ao lado do executável, em arquivos comuns: não são empacotados nem protegidos.
    • Não há instalador para o jogo: o que se envia é a pasta ou o zip.
    Baixar 0.4.0

  4. Brasa 0.3.0

    Brasa 0.3.0

    A room ganhou camadas, como no GameMaker, e com elas veio o tilemap: dá para pintar o cenário com tiles, com colisão, sem criar um objeto para cada bloco.

    O que há de novo

    • Camadas na room. Um painel novo, Camadas (à esquerda, embaixo de Recursos; pode ser arrastado para outro lugar), lista as camadas da room: a de cima fica na frente. Dá para criar, renomear, reordenar, esconder e travar. A camada clicada é a ativa, e é nela que o mouse mexe. São quatro tipos:
      • Instâncias: os objetos, como antes.
      • Fundo: uma cor ou uma imagem (um sprite), que pode repetir, esticar e andar sozinha.
      • Sprites: sprites soltos, só de enfeite, sem objeto e sem código.
      • Tiles: uma grade de tiles de um tileset.
    • O depth é da camada. Objeto e instância não têm mais Depth: quem está numa camada é desenhado na ordem dela. No Inspetor da instância, a linha Camada troca a instância de camada.
    • Tileset. Em Recursos, + › Novo tileset... cria um tileset. Ele aponta para um sprite: cada frame do sprite é um tile (importe a imagem como sprite e fatie no tamanho do tile). Na aba do tileset, clique nos tiles para marcar os sólidos.
    • Pintar tiles. Com uma camada de Tiles ativa, o Inspetor mostra a paleta. Clique num tile (ou arraste para pegar um bloco) e pinte na room. Ferramentas: Pincel (B), Borracha (E; o botão direito sempre apaga), Balde (G) e conta-gotas (Alt + clique). Cada traço é um passo do desfazer.
    • Colisão pelos tiles. Tile sólido barra o movimento como um objeto sólido: vale em placeFree, moveAndStop, onGround, hitFloor, hitWall e hitCeiling. Uma camada de enfeite desliga isso em Colide.
    • Colisão na forma do tile. Na aba do tileset, cada tile pode ser Nada, Célula (barra na célula inteira) ou Forma (barra só onde o tile tem desenho: uma plataforma fina fica com a colisão fina). A caixa de cada tile pode ser ajustada à mão, arrastando no tile ampliado.
    • Pincel de terreno. No tileset, marque um terreno: um bloco de 3×3 tiles (cantos, bordas e miolo). Na room, com o terreno escolhido, você pinta "tem chão aqui" e o editor escolhe o tile certo pelos vizinhos.
    • No código:
      • spawn<Tiro>(x, y, "Tiros"): quem nasce pelo código diz em qual camada entra;
      • setLayer("Frente") e layerName(): mudar e ler a camada de uma instância;
      • setLayerVisible("Chao", false) e layerVisible("Chao");
      • setLayerPosition("Montanhas", x, y), layerX e layerY: mover uma camada de fundo (é assim que se faz parallax);
      • tileAt("Chao", x, y): o tile naquele ponto (ou -1), e solidAt(x, y): tem algo sólido ali?
    • Tela cheia e ampliação. Em Configurações do projeto, Abrir em tela cheia e Ampliar para a tela: Inteira (como antes: pixels perfeitos, com borda no que sobra), Manter proporção (o maior tamanho que cabe sem distorcer) ou Esticar. Durante o jogo, Alt+Enter ou F11 alternam entre a janela e a tela cheia. No código, Window::setFullscreen(true), Window::fullscreen(), Window::setScale(WindowScale::Fit) e Window::scale() mudam isso com o jogo rodando, para um menu de opções de vídeo. Window::setSize(1280, 720) muda o tamanho da janela, e Window::width(), height(), screenWidth() e screenHeight() dizem o tamanho dela e do monitor.
    • Câmera sem tremor. O personagem seguido pela câmera não treme mais 1 pixel ao andar: a câmera passa a virar de pixel junto com ele, com qualquer suavização. O movimento também ficou mais regular em monitores de 60 Hz.
    • Modelo "Plataforma". Em Novo projeto, um jogo pequeno de plataforma que usa tudo isso: fase pintada com tiles, enfeites, moedas, câmera seguindo e montanhas com parallax.

    Para quem atualiza

    • O projeto é convertido ao abrir. O formato passou para a versão 3. O editor avisa e, com o seu OK, converte os arquivos: as instâncias de cada room são separadas por depth, cada depth vira uma camada de Instâncias (Instancias, Instancias_2...), e a cor de fundo vira a camada Fundo. O desenho das rooms fica igual. O brasa_cli migrate faz o mesmo pela linha de comando. Vale guardar uma cópia do projeto antes (ou usar o git).
    • spawn agora pede a camada. spawn<T>(x, y) dentro de um objeto não compila mais: passe o nome da camada, spawn<T>(x, y, "Camada"). O erro de compilação mostra o que fazer. Para criar num depth sem camada, use spawnAtDepth<T>(x, y, depth).
    • O depth do objeto saiu do .obj.json. Código que lê ou escreve depth continua compilando; para mudar a ordem de desenho pelo código, prefira setLayer.
    • Um editor 0.2 não abre projetos da 0.3. Depois de salvar na 0.3, o projeto só abre na 0.3 em diante.

    Correções

    • A aba do tileset e a do sprite não travam mais com centenas de tiles ou frames (um tileset de 575 tiles rodava a 17 quadros por segundo).

    Limites desta versão

    • Os tiles não mudam com o jogo rodando, e não há tiles animados, espelhados nem girados.
    • Plataforma que se atravessa por baixo não é um tipo de tile: faz-se com um objeto e código.
    • O pincel de terreno usa 9 tiles (sem os cantos internos).
    Baixar 0.3.0

  5. Brasa 0.2.1

    Brasa 0.2.1

    Uma versão de arrumação do editor: as mesmas funções, em telas mais compactas e mais fáceis de ler.

    O que mudou

    • Inspetor em grade. As propriedades agora ficam em linhas finas e alinhadas, com o nome à esquerda e o valor à direita, sem espaço sobrando. Um objeto que antes precisava de rolagem cabe inteiro na tela, e nenhum nome fica mais cortado: passe o mouse sobre o nome para ver a explicação.
    • Valores que andam juntos ficam na mesma linha. Posição e escala mostram X e Y lado a lado; tamanhos mostram largura × altura.
    • Números de arrastar. Os campos com as setinhas ◂▸ na borda são de arrastar: clique e arraste para mudar; dê dois cliques para digitar.
    • Variáveis em uma linha. Cada variável do objeto ocupa uma linha só: o nome (clique para renomear), o valor padrão e o botão ⋮, com Tipo, Subir, Descer e Excluir. O + Variável já pergunta o tipo.
    • Valores próprios da instância. O Depth e as variáveis de uma instância ficam juntos em Valores próprios: marque a caixinha para a instância ter um valor só dela; desmarcada, vale o do objeto.
    • Editor de sprite. O painel da esquerda usa a mesma grade. Fatiar (por colunas ou por tamanho) e o tipo da caixa de colisão (Auto, Inteira, Manual) viraram seletores lado a lado.
    • Configurações do projeto. As ações de entrada ficam em uma tabela alinhada: o nome, as teclas e os botões (um clique remove) e o + para adicionar, com a opção de apertar a tecla. Salvar e Cancelar ficam sempre à vista.
    • Diálogos. Em todas as janelas o botão principal é o amarelo, à direita.

    Para quem atualiza

    Nenhum projeto muda: é só a aparência do editor. Uma diferença para notar: na instância, a caixinha ao lado do Depth agora significa "valor próprio" (antes ela significava "usar o do objeto").

    Baixar 0.2.1

  6. Brasa 0.2.0

    Brasa 0.2.0

    A 0.2 nasceu de um jogo de plataforma feito na 0.1: tudo o que deu trabalho nele virou recurso. Agora você ajusta valores no editor sem recompilar, configura teclas e controle num lugar só, guarda vidas e moedas em objetos que passam de uma fase para a outra, e cria caixas, espinhos e decoração sem escrever nenhuma linha de código.

    O que há de novo

    • Variáveis de objeto e de instância no editor, como as Variable Definitions do GameMaker. Você cria a variável no Inspetor do objeto e muda o valor de cada instância na room.
    • Objetos com .hpp e .cpp. O Novo objeto cria os dois arquivos. Todo objeto enxerga todos os outros sem #include.
    • Objetos sem código. O Novo objeto (sem código) cria só o .obj.json. O objeto aparece na room com o sprite, o depth, o solid e o resto dos dados, e os outros objetos o acham pelo nome: touching("obj_spike").
    • Física no Inspetor. Gravidade, direção da gravidade, atrito e queda máxima ficam no objeto, na seção Física. Não precisa mais copiar gravity = ... no onSpawn.
    • instance<T>() acha o controlador do jogo de qualquer objeto: instance<obj_controle>()->moedas++;.
    • Ações de entrada e controle. Dê nome a uma ação ("pular") e escolha as teclas e os botões do controle dela. No código, use pressed("pular") ou axis("esquerda", "direita"). Um projeto novo já vem com esquerda, direita, cima, baixo, pular e acao.
    • Máscara de colisão e espelho. A caixa de colisão pode vir de um sprite fixo (a máscara), e não do sprite da animação atual. O flipX espelha o desenho e a caixa sem mexer na escala.
    • Ajudas de plataforma: onGround(), maxFallSpeed, hitFloor(), hitCeiling(), hitWall(), hitWallLeft(), hitWallRight(), onTouchStart<T> e onTouchEnd<T>.
    • Objetos persistentes e globais. Uma instância persistente sobrevive à troca de room e ao restart(). Objetos globais (um HUD, um controlador de vidas) são criados uma vez, na primeira room, e ficam vivos até o jogo fechar.
    • Renomear um objeto troca o nome no código, se você quiser. O editor mostra quantos lugares mudam no .hpp e no .cpp e pergunta antes. Só o .hpp e o .cpp do próprio objeto são reescritos, comentários e textos entre aspas inclusive. Quem cita o objeto em outros arquivos (outros objetos, src/) você corrige à mão.
    • Renomear uma variável também oferece trocar o nome no código. Depois de renomear no Inspetor, o editor conta quantos lugares do .hpp e do .cpp do objeto usam o nome antigo (palavra inteira) e pergunta se troca. Excluir uma variável avisa que o código que a usa deixará de compilar.
    • O modelo "Primeiro jogo" foi refeito com .hpp + .cpp, ações (atirar, confirmar e sair, além das de direção) e variáveis.

    Variáveis

    1. Abra o objeto e, no Inspetor, procure a seção Variáveis. Clique em +.
    2. Dê um nome (por exemplo velocidade), escolha o tipo e o valor padrão. Os tipos são:
      • número com vírgula (number), inteiro (int), sim/não (bool), texto (string) e cor (color);
      • room, object, sprite e sound: uma lista com os recursos do projeto.
    3. Na classe do objeto, no .hpp, a linha BRASA_VARS(obj_player) logo depois de public: cria os campos. No código, a variável é um campo comum: 
      hspeed = axis("esquerda", "direita") * velocidade;
    4. Para dar um valor diferente a uma instância, selecione-a na room. Na seção Variáveis do Inspetor da instância, marque a caixa ao lado do nome da variável (valor próprio) e mude o valor. Isso entra no desfazer da room.

    Os valores chegam antes do onSpawn. Mudar um valor no editor não recompila nada: é só apertar Play. Já criar, renomear ou mudar o tipo de uma variável recompila o jogo.

    Renomear ou excluir uma variável atualiza as instâncias de todas as rooms (o código do objeto só muda se você aceitar a troca; outros objetos que usam a variável ficam por sua conta). Renomear uma room, um objeto, um sprite ou um som atualiza as variáveis que apontam para ele.

    Exemplo: uma bandeira com a variável destino do tipo room. Cada bandeira escolhe a própria fase, e o código fica assim:

    onTouchStart<obj_player>([this](obj_player&) { goTo(destino); });

    Ações e controle

    Em Projeto > Configurações do projeto, a tabela de Ações tem:

    • + Ação para criar uma ação;
    • + tecla e + botão para escolher da lista;
    • Capturar para apertar a tecla direto (Esc cancela).

    Um projeto novo (modelo Vazio) já vem com seis ações:

    ação teclado controle
    esquerda ←, A cruz ←, analógico ←
    direita →, D cruz →, analógico →
    cima ↑, W cruz ↑, analógico ↑
    baixo ↓, S cruz ↓, analógico ↓
    pular Espaço A
    acao X, Enter X

    O modelo Primeiro jogo traz esquerda, direita, cima e baixo e mais três ações: atirar, confirmar e sair.

    Os botões do controle são Pad:A, Pad:B, Pad:X, Pad:Y, Pad:Start, Pad:Back, Pad:LB, Pad:RB e as setas (Pad:Up, Pad:Down, Pad:Left, Pad:Right). Os eixos do analógico esquerdo são Pad:LeftX-, Pad:LeftX+, Pad:LeftY- e Pad:LeftY+.

    No código:

    • held("pular") vale enquanto a ação está segurada;
    • pressed("pular") vale no step em que ela foi apertada;
    • released("pular") vale no step em que ela foi solta;
    • axis("esquerda", "direita") vai de -1 a 1 (o analógico tem zona morta de 0,25).

    Vale o primeiro controle conectado, e dá para ligar e desligar com o jogo rodando. Uma ação com nome errado aparece uma vez como erro na Saída.

    As funções com tecla (held(Key::Space)) continuam funcionando.

    Máscara, espelho e plataforma

    • Máscara: no Inspetor do objeto, escolha um sprite em Máscara. A colisão passa a usar o bbox desse sprite, qualquer que seja a animação. Trocar spr_player_idle por spr_player_run não mexe mais na caixa.
    • Espelhado (flipX): marque a caixa ao lado do nome Espelhado no Inspetor para o objeto começar virado, ou use flipX = hspeed < 0; no código.
    • Plataforma:
      • onGround() diz se há chão 1 pixel abaixo;
      • na seção Física do Inspetor do objeto, Gravidade (por exemplo 0,25) puxa para baixo a cada step e Queda máxima (por exemplo 4,5) limita a queda. Também há Direção da gravidade e Atrito. Os valores chegam antes do onSpawn, e no código continuam sendo gravity, gravityDirection, friction e maxFallSpeed;
      • depois de moveAndStop(), hitWall() diz se bateu numa parede (bom para o inimigo virar) e hitFloor() diz se acabou de pousar.
    • onTouchStart<T>: roda uma vez quando o contato começa. Serve para a bandeira e para a moeda, sem a variável "já usei". O onCollide continua rodando a cada step.

    Objetos persistentes e globais

    • Persistente: marque a caixa ao lado do nome Persistente no Inspetor do objeto. A instância passa para a próxima room com tudo o que tinha (vidas, moedas, temporizadores), e o restart() não a recria.
    • Globais: em Configurações do projeto > Objetos globais, adicione, por exemplo, obj_hud e obj_controle. Eles nascem uma vez, na primeira room, e existem em todas as rooms, sem precisar colocar uma instância em cada fase.

    Cuidados com objetos persistentes:

    • eles guardam os valores também no restart(): se o jogo recomeça no game over, zere você mesmo as vidas e as moedas;
    • guardam também o x e o y: a instância não volta para o lugar em que a room a colocou;
    • guarde referências a outros objetos como Handle<obj_x> (você o obtém com handle<obj_x>() na própria instância e usa .get(), que devolve nullptr se ela sumiu), nunca como ponteiro simples: o ponteiro fica solto quando a instância some na troca de room.

    Para achar o controlador de qualquer objeto, use instance<obj_controle>(). Ele devolve a primeira instância viva (ou nullptr, se não houver nenhuma):

    instance<obj_controle>()->moedas += valor;

    Objetos sem código

    Em Recursos, clique com o botão direito numa pasta e escolha Novo objeto (sem código).... Só o .obj.json é criado. O objeto vira uma instância comum, com sprite, depth, solid, máscara, física e o resto do que estiver no Inspetor. Caixas, chão, espinhos e decoração não precisam mais de uma classe vazia.

    Um objeto sem classe não tem eventos nem variáveis no código. Para outro objeto reagir a ele, use o nome do objeto entre aspas:

    • touching("obj_spike"), collidesAt("obj_spike", x, y + 1) e findAt("obj_spike", x, y);
    • onTouchStart("obj_spike", [this](Entity& espinho) { ... }), onTouchEnd(...) e onCollide(...);
    • count("obj_spike"), any("obj_spike"), each("obj_ground", [](Entity& pedaco) { ... }) e destroyAll("obj_spike").

    Essas formas com nome também valem para objetos com classe.

    Meu projeto da 0.1 continua funcionando?

    Sim. Você não precisa mudar nada para abrir e rodar um projeto da 0.1:

    • objetos com a classe dentro do .cpp continuam compilando;
    • held(Key::...) e os seus próprios headers em src/ continuam valendo, inclusive funções suas como a jogo() do modelo antigo, que devolve o estado do jogo guardado numa variável static;
    • objetos sem classe que já estavam colocados nas rooms agora são criados e desenhados (na 0.1 eram ignorados com um erro na Saída). Se o seu jogo tinha um desses, ele passa a aparecer;
    • o primeiro Play na 0.2 recompila o projeto do zero, porque a engine mudou. Isso é normal.

    Para usar variáveis num objeto antigo:

    1. Crie o obj_x.hpp ao lado do .cpp e mova a classe para ele (no .cpp, troque a classe por #include "obj_x.hpp").
    2. Escreva BRASA_VARS(obj_x) logo depois de public:. Se preferir, crie as variáveis no Inspetor e clique em Inserir BRASA_VARS no .hpp: o editor insere a linha para você.

    Enquanto a classe não tiver BRASA_VARS, o editor mostra um aviso amarelo. As variáveis ficam guardadas no projeto e não quebram a compilação, mas os valores não chegam ao objeto.

    Com o .hpp, você também pode apagar os #include entre objetos e headers como src/objetos.hpp: todo objeto já enxerga todos os outros.

    Mais uma coisa: as classes dos objetos precisam ficar fora de namespace para as variáveis funcionarem. O modelo antigo "Primeiro jogo" usava namespace jogo. Um projeto criado com ele continua compilando, mas para usar variáveis nele, tire a classe do namespace.

    Baixar 0.2.0

  7. Brasa 0.1.1

    Brasa 0.1.1

    Uma versão pequena, com uma correção importante para quem joga em monitor de alta taxa de atualização e um jeito mais fácil de controlar a velocidade das animações.

    O que mudou

    • Câmera sem tremor em monitores de 120, 144 Hz ou mais. Com a suavização ligada, a câmera podia tremer porque se movia uma vez por quadro desenhado, enquanto o jogo anda 60 vezes por segundo. Agora a câmera se move no mesmo ritmo do jogo (60 vezes por segundo, qualquer que seja o monitor) e é desenhada sempre em pixels inteiros, então personagem e cenário trocam de pixel juntos. Você não precisa mudar nada no seu projeto: a suavização que você escolheu continua valendo, e fica bem melhor.
    • Velocidade da animação no sprite. No editor de sprite, a linha do tempo agora tem o campo fps (de 1 a 60; se ainda não houver valor, a prévia usa 10). O valor é salvo no arquivo .sprite.json (como "fps") e dá para desfazer. Pronto: o sprite já anda na velocidade certa em qualquer objeto que o use.
    • animSpeed virou um multiplicador. Em um sprite que tem fps, animSpeed = 1 toca na velocidade do sprite, 2 toca no dobro e 0.5 na metade. Sprites sem fps continuam como sempre: animSpeed é quantos frames avançam por step. Nenhum projeto antigo quebra.
    • Trocar de sprite volta ao primeiro frame. Quando você muda sprite de um objeto, a animação nova começa no frame 0, sem precisar escrever frame = 0 na mão. Se você também mudar o frame no mesmo step, o valor que você escolheu é respeitado.

    Como usar o fps no editor

    1. Abra o sprite e vá até a linha do tempo, embaixo.
    2. Ajuste o campo fps. A prévia toca na velocidade escolhida.
    3. Salve. No jogo, o sprite anima nessa velocidade; use animSpeed só se quiser acelerar ou frear um objeto específico.
    Baixar 0.1.1

  8. Brasa 0.1.0

    Brasa 0.1.0

    A primeira versão da Brasa: uma engine de jogos 2D em C++ para quem está começando. Você cria o jogo num editor visual, escreve a lógica em C++ com uma API pensada para ser fácil, aperta Play e joga.

    O que tem nesta versão

    • Hub. A tela inicial mostra seus projetos recentes com miniatura, os modelos de novo projeto e os links de documentação.
    • Projetos em pastas. Cada jogo é uma pasta. Dentro dela você organiza objetos, rooms e assets em subpastas como quiser. A Brasa migra projetos do formato antigo.
    • Editor. Recursos, room, inspetor e saída lado a lado, com abas para rooms e sprites, desfazer e refazer, e o Play, que compila e abre o jogo sem janela de console. Erros do compilador são clicáveis.
    • Sprites. Editor de sprites com quadros, origem e animação.
    • Sons. Os sons do projeto aparecem no editor, com pré-escuta.
    • Câmera. Defina a visão, o objeto seguido, o limite, a suavização e a zona morta direto no inspetor da room.
    • API fácil de C++. after, every, spawn, held, pressed, random e companhia, em ângulos em graus. O editor gera a configuração do VS Code para ter autocomplete no seu projeto.
    • Instalador com atualizações. Um só .exe, sem administrador, que instala só para o seu usuário, cria atalhos, associa os arquivos .brasa e confere se o compilador C++ e o CMake estão instalados. O editor avisa quando sai uma versão nova e atualiza com um clique.

    Requisitos

    • Windows 10 ou 11, 64 bits.
    • Para o Play compilar o seu jogo: o compilador C++ e o CMake do Visual Studio. O instalador confere e oferece baixar e instalar o Build Tools da Microsoft. Esse passo é opcional: sem ele o editor abre, mas o Play só funciona depois de instalar as ferramentas.

    Mudança de comportamento

    • Rooms limitam a câmera ao seguir. Antes, a câmera que seguia um objeto podia mostrar o que está fora da room. Agora o limite da room vale também quando a câmera segue (opção "limitar" da câmera, ligada por padrão). Se o seu jogo dependia de ver além das bordas, desligue o limite na seção Câmera do inspetor da room.

    Limitações conhecidas

    • Ainda não há exportação. O jogo roda pelo Play; gerar um executável para distribuir fica para uma próxima versão.
    • Sons só em WAV.
    • O instalador não é assinado. O Windows SmartScreen pode mostrar "O Windows protegeu o seu computador". Clique em Mais informações e depois em Executar assim mesmo. A integridade do que o editor baixa nas atualizações é conferida por SHA-256.
    • A atualização pelo hub só funciona na versão instalada pelo instalador (não numa pasta copiada à mão).

    Como instalar

    Baixe Brasa-0.1.0-setup.exe abaixo, rode e siga as telas. O arquivo Brasa-0.1.0-setup.exe.sha256 traz o SHA-256 para conferir o download.

    Baixar 0.1.0

Todas as versões também ficam na página de releases no GitHub.