Brasa 0.7.0

Brasa 0.7.0

Jogos em Lua: o Play roda na hora, sem compilar e sem instalar mais nada. O editor ganhou uma aba de código com autocompletar, e o instalador ficou menor, com o suporte a C++ como um componente opcional.

O que há de novo

• Projetos em Lua. No Novo projeto, escolha a linguagem: Lua (o padrão) ou C++. Num projeto em Lua cada objeto tem um script ao lado (objects/Jogador.lua), com os mesmos eventos, campos e funções da API em C++:

  function onSpawn(self)
      self.vidas = 3
  end
  
  function onUpdate(self)
      self.hspeed = axis("esquerda", "direita") * self.velocidade
      if pressed("pular") and self:onGround() then self.vspeed = -4 end
  end

  O que é da instância usa self (self.x, self:destroy()); o resto são funções soltas (spawn, held, drawText, Audio.play, Save.set, Ui.get). As variáveis criadas no Inspetor chegam como campos de self.

• Play instantâneo. Num projeto em Lua não há compilação: o Play abre o jogo direto, e exportar copia o jogo pronto. Um erro no script aparece na Saída com o arquivo e a linha (clicar leva até lá), e o jogo continua rodando.

• Os quatro modelos em Lua. Vazio, Primeiro jogo, Plataforma e Zumbis existem nas duas linguagens.

• Aba de código. Abrir código (ou dois cliques num .lua, .cpp ou .hpp) abre o arquivo dentro do editor, com cores, números de linha, desfazer, busca (Ctrl+F) e Ctrl+S. Com um script aberto, o Inspetor mostra o objeto dono dele, com as variáveis ao lado do código. Quem prefere outro programa escolhe em Preferências › Editor de código.

• Autocompletar em Lua. Ao digitar aparece a lista de sugestões, com a forma de usar ao lado: a API da Brasa, o que cada tabela tem (Audio., Save., Ui....), os campos e métodos de uma instância (self. e self:), as variáveis do objeto e o que já está no arquivo. Setas escolhem, Tab ou Enter aceitam, Esc fecha.

• Sequências com espera (Lua). Uma ação que acontece aos poucos é escrita em linha reta, sem contadores no onUpdate:

  self:run(function()
      wait(2)
      avisar("Onda 1")
      waitUntil(function() return not any("Zumbi") end)
      wait(4)
  end)

• Ordenar por Y. No Inspetor de uma camada de instâncias, Ordenar por Y desenha na frente quem está mais embaixo na tela: o jogador passa atrás da árvore sem mexer no depth de cada objeto.

• Listas e tabelas no Save. Em Lua, Save.set("inventario", { "espada", "escudo" }) e Save.get("inventario", {}), com tabelas dentro de tabelas. Em C++, listas (Save::set com std::vector, getInts, getNumbers, getTexts) e setJson/getJson.

• Movimento suave e efeitos de tela. tween leva um valor de um ponto a outro num tempo, com cinco curvas de suavização (em Lua: self:tween({ y = self.y - 20 }, 0.3, "out")). camera.shake(força, segundos) treme a tela, flash(cor, segundos) dá um clarão e fadeTo(room, segundos) troca de room escurecendo.

• Instalador com componentes. O instalador traz o editor e o suporte a Lua, e ficou com metade do tamanho. O Suporte a C++ é uma caixa na tela de componentes: marcado, o instalador baixa o que falta e confere as ferramentas de compilação da Microsoft. Dá para acrescentar depois, sem reinstalar: em Configurações › Componentes, ou quando um projeto em C++ pedir.

Também nesta versão

• O Zumbis usa as novidades: as ondas são uma sequência com wait, a camada ordena por Y, apanhar treme a tela e pisca de vermelho, e os números do jogo (vida, velocidade, balas, ritmo das ondas) são variáveis do Inspetor.
• A instalação e cada jogo exportado levam o arquivo licencas-de-terceiros.txt, com as licenças das bibliotecas usadas.

Para quem atualiza

• Os projetos em C++ continuam funcionando como antes: o formato é o mesmo, e a linguagem só aparece no project.brasa dos projetos em Lua.
• Quem já tinha a Brasa instalada: a atualização traz o instalador novo, e o suporte a C++ que estava na pasta deixa de vir junto. Ao abrir um projeto em C++ e apertar Play, o editor oferece instalar o suporte a C++ (um download de cerca de 20 MB).

Limites desta versão

• Um projeto é em Lua ou em C++: as duas linguagens não se misturam no mesmo projeto.
• Os scripts em Lua rodam mais devagar que o C++ (cerca de 30 vezes nas contas do próprio script). Com mil objetos com script isso ocupa uns 5% do tempo de um quadro; só com vários milhares passa a pesar.
• As sequências com espera (self:run, wait) só existem em Lua.
• Um jogo em Lua exportado leva os scripts junto, legíveis, na pasta data.
• O autocompletar não entende o código: depois de zumbi. ele sugere os campos de uma instância mesmo que zumbi seja outra coisa. A lista só aceita o teclado, e as dicas ao lado ficam em português.
• Na aba de código, renomear ou excluir um arquivo aberto fecha a aba, e o que não foi salvo nela se perde.
• A opção Ordenar por Y vale no jogo; a vista da room do editor não a mostra.
• Ainda não há animações com nome, recarregar o script com o jogo rodando nem busca de caminho.

Brasa 0.6.0

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.

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.

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.

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).

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").

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 valore...

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.

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.