Introdução Bem-vindo Como Começar Meu Primeiro Programa     Resolvendo Problemas e Distribuindo Tranformando Dados Programas Interativos     Exercícios de Programação     Fazendo Games
Documentação Declarações     Procedimentos     Variáveis Construtores     Controle de Fluxo Expressões Bibliotecas     Print     IO     Random     Game Engine
Tutoriais Tutoriais Completos     Introdução à Programação     Guia Rápido     Exercícios de Programação     Programando Games

TUTORIAL: PROGRAMANDO JOGOS


Vamos aplicar tudo que você aprendeu para programar jogos incríveis!





Sobre os Tutoriais

Os tutoriais de Programação de Jogos foram criados para elevar tudo que você aprendeu para o próximo nível, aplicando seu conhecimento em desenvolvimento de jogos! Os jogos são um dos tipos mais complexos de software para criar, mas também um dos mais recompensadores. Ver seu código ganhar vida com imagens em movimento, sons, partículas e muito mais; enquanto o usuário interage com esse mundo imaginário é simplesmente incrível .


Os tutoriais foram criados numa sequência, de forma a começar te ensinando os fundamentos de programação de jogos, te levando para os diferentes desafios que você vai precisar encarar ao criar esses mundos interativos, até o polimento desses jogos e adicionando técnicas profissionais aos seus jogos.

Para te ajudar nessa jornada incrível, nós criamos a biblioteca Game Engine ou “Motor de Jogos” para tornar o seu caminho de aprendizado em programação de jogos super produtivo. Você pode ler tudo sobre a Game Engine nessa página.
Para começar, tudo que você precisa fazer é baixar o Vizzcode e selecionar os tutoriais na página de Boas Vindas.
Cada tutorial está estruturado da seguinte forma:

No tutorial Invasores: Básico você vai criar um jogo simples do estilo shoot’ em’ up. Você será capaz de usar esse conhecimento para dar vida à suas próprias ideais de jogos! Fazer jogos pode ser difícil, então é importante que você já esteja familiar com programação no Vizzcode, pelo menos até Loops. Você pode sempre rever os tutoriais anteriores e voltar nesse ponto mais para frente.

Em seguida temos o tutorial Tappy Aviões: Básico onde vamos construir a partir dos fundamentos que aprendemos no último tutorial para fazer um novo jogo – Tappy Aviões ou Tappy Planes.
Você vai aprender mais sobre programação de gameplay e como organizar seu programa para criar comportamentos mais complicados!

O tutorial de Jogo da Velha: Básico vai levar suas habilidades de programação de gameplay para o próximo nível te ensinando como programar o gameplay sem precisar contar com uma game engine. Vamos utilizar a biblioteca Game Engine apenas para mostrar imagens e rodar o áudio.
Essa vai ser uma ótima oportunidade para aprender mais sobre lógica de programação de jogos e transformação de dados!

Quando você acostumar com suas novas habilidades, o tutorial Galeria de Tiro: Básico vai te mostrar um mundo totalmente diferente: programar um sistema de objetos customizado! Você vai especificar os dados do objeto, animar objetos, aprender sobre uma equação importante de interpolação e muito mais!
No final você vai ter a base de um jogo de Galeria de Tiro e o conhecimento para expandir e criar jogos mais complexos com objetos customizados.

Por fim, chegamos no tutorial final da série: o Invasores: Avançado. Você vai aprender como programar alguns elementos mais avançados nos seus jogos, levando eles para o próximo nível.
Nesse tutorial, você vai criar naves inimigas que atiram de volta, melhorar o movimento do jogador, adicionar efeitos de paralax para o fundo, mostrar a pontuação com uma fonte customizada, implementar efeitos sonoros avançados e muito mais!


As próximas seções dessa página vão te acompanhar na sua jornada com esses tutoriais: você vai seguir o tutorial dentro do Vizzcode, em seguida você pode vir aqui para ter a direção de partes específicas da documentação que mencionam o que você está programando com mais detalhes.
O que você está esperando? Vamos nessa!





Invasores: Básico

Aprenda o básico sobre fazer jogos! Tudo que você precisa fazer é selecionar o tutorial na Tela de Boas Vindas do Vizzcode!


Invasores: Básico - Tela de Gameplay

Introdução e o que vamos construir
Essa página prepara o palco para você começar a criar jogos digitais incríveis.
Vá em frente para começar!


Como Jogos são Programados
Os tópicos discutidos nessa página vão aparecer por todos os tutoriais de programação de jogos.
É importante manter eles em mente, mas não se preocupe muito se for muita coisa de uma vez.
Se você precisar, releia a página do tutorial ou vá para a página da documentação sobre Fazendo Jogos e principalmente a seção de Como Jogos são Programados.

Em seguida, a página começa a usar a Biblioteca Game Engine para configurar um Loop do Jogo básico para o jogo. Você pode ler uma seção sobre como usar a biblioteca se você quiser mais exemplos.
Você pode ler mais sobre o procedimento game_is_running aqui. Ele sempre vai ser usado quando for fazer jogos no Vizzcode.
Você pode baixar os assets que você vai precisar para criar esse projeto aqui, bem como aprender mais sobre como distribuir seu jogo aqui.


Programming the player's ship
Não esqueça de testar seu jogo em todos os passos do tutorial. Não deixe que várias coisas novas apareçam antes de conferir!
Você pode acessar mais informações sobre desenhar imagens com o draw_bitmap aqui.
Se você não ver a imagem, garanta que o caminho que você inseriu conduz corretamente para a imagem PNG a partir do executável. Por exemplo, se pedirmos para desenhar o arquivo assets/background.png, começando a partir de onde o executável está localizado (dentro da pasta do projeto) o programa vai mover para dentro da pasta dos assets e abrir o background.png. Garanta que seu caminho está correto!
Se você quiser aprender mais sobre como o sistema de objetos da biblioteca Game Engine funciona, você pode ir para sua especificação da API aqui e ler a descrição e os exemplos de cada procedimento usado nessa página do tutorial. Mas não se preocupe muito com cada detalhe ainda; quanto mais você programar usando esses elementos, mais você vai entender como eles funcionam.


Fazendo o Jogador Atirar
Essa página usa o que você aprendeu na página anterior junto com o spawnar (criar) objetos de forma dinâmica.
Se você precisar, volte e reveja a página anterior ou releia essa página cuidadosamente.
É importante que você esteja seguindo cada passo do caminho.
Você pode sempre utilizar a referência da API da Game Engine para aprender mais sobre certos procedimentos que o jogo está usando, por exemplo os procedimentos button_pressed ou get_first_instance.
Outra ótima forma de te ajudar no seu entendimento é brincar com seu código. Não tenha medo de quebrar ele! Tente definir valores diferentes e mudar a estrutura do programa. Quanto mais você programar, mais você vai entender!
Também leia o nome de cada procedimento, seus parâmetros e valores de retorno. Eles podem te ajudar bastante a entender como eles devem ser encaixados.


Criando os Asteroides
Essa página te introduzir a uma ferramenta muito importante no desenvolvimento de jogos: cronômetros.
A ideia é muito simples, nós temos uma variável que está incrementando seu valor a medida que o tempo for passando (cronometro_asteroide += get_delta_seconds). Com o valor do cronômetro ou “timer” incrementando, nós podemos trabalhar com ele exatamente como um cronômetro mesmo, e testar se tempo é maior que algum valor (se cronometro_asteroide > .5). Se verdadeiro, precisamos reiniciar o cronômetro voltando ele para o valor que queremos (cronometro_asteroide -= .5).

A parte final dessa página te mostra como calcular o vetor de direção entre o asteroide e o jogador. Isso vai nos ajudar a encontrar a direção que precisamos “empurrar” o asteroide para que ele mova em direto para o jogador (usando o procedimento set_instance_velocity).
Eu sugiro que você realmente brinque com o código – mudando os valores e nós antes de seguir em frente. Isso vai garantir que você entenda como o sistema inteiro funciona antes de adicionar novos elementos. Você pode sempre voltar e reler a página com mais calma.


Fim de Jogo
Você pode encontrar uma ótima descrição de como o procedimento objects_collided funciona na especificação da API da Engine.
O sistema de estados que o tutorial te introduzir nessa página é uma ferramenta muito útil na programação de jogos, e uma que vamos usar e expandir no próximo tutorial também.
A ideia é muito simples: se o jogo acabar for verdadeiro, nós vamos executar um código, senão, vamos executar outra parte do código. Nós temos usado essa ideia base por um bom tempo, a única diferença é que agora nós aplicamos ela no loop do jogo - que está constantemente sendo testado.
Tente ter em mente o valor da variável em todos os momentos quando você está testando o jogo. Se você precisar, utilize a técnica que discutimos na seção de ajuda da série de Introdução à Programação para executar o código manualmente. Você pode aprender tudo sobre isso aqui.


Destrua os Asteroides e Ganhe Pontos
Como de costume, essa página constrói em cima do que você aprendeu anteriormente. Então se você precisar, volte e releia partes do tutorial para garantir que você entenda o sistema base antes de expandir ele.
É importante estar familiar com recursos do Vizzcode como retorno de múltiplos valores e declarações compostas.
O sistema de pontuação é bem fácil, é apenas uma variável que incrementa baseado em uma certa condição! Lembre de “executar o programa na sua cabeça” para garantir que você saiba como ele está se comportando em cada ponto.


Polimento: Música, Efeitos Sonoros e Partículas
Essa página introduz conceitos muito importantes de desenvolvimento de jogos. Um bom feedback para o jogador (também conhecido como game feel (sensação do jogo) é uma das diferenças principais entre jogos de nível amador e profissional.
Uma das ótimas coisas sobre a sensação do jogo é que você pode aprender jogando e analisando outros jogos, pense sobre todas as coisas que acontecem quando você atira no seu jogo de tiro favorito. Tem um efeito sonoro poderoso? Uma animação rápida? A tela balança? Tem um efeito de particular? Quais outros elementos que você percebeu nas ações principais que você faz quando está jogando seus jogos favoritos?
Com isso em mente, você terá a introdução de vários procedimentos disponíveis na biblioteca Game Engine onde todos estão detalhados na página da API completa. Apenas procure lá pelo nome do procedimento que você quer conhecer mais a respeito!
Lembre de experimentar com valores diferentes – se você tiver uma ideia, tente ela! Veja como você pode mudar a forma como o jogo é jogado baseado no que você aprendeu nessa página.


Desafios Extras
Você chegou ao fim do primeiro tutorial de jogos!
Espero que você tenha aprendido muito com ele!
Você está no controle da sua jornada de aprendizado, então se precisar, não tenha medo de recomeçar esse tutorial e refazer todos os passos do seu caminho. Eu te garanto que vai ficando mais fácil a cada vez!
Se você quiser um desafio, tente resolver os problemas propostos nesse tutorial. Eles começam bem fáceis – para que você consiga fazer com o que você aprendeu até agora, e vai aumentando a complexidade!
  • Implemente um sistema de pontuação máxima: Abaixo da pontuação, tem a pontuação máxima (high score), que mostra a maior pontuação que o jogador conseguiu nessa execução do jogo ;
  • Dificuldade incremental: Quanto maior a pontuação, mais difícil fica o jogo (mais rápido e com meteoros mais frequentes, por exemplo);
  • Segure para atirar: Faça com que seja possível para o jogador segurar o botão de atirar. Lembre-se de não adicionar diretamente todo frame, mas adicionar um cronômetro, como o sistema dos asteroides;
  • Mais vidas: Faça com que o jogador tenha três vidas, quando ele colidir com o asteroide, ele perde uma vida e o jogo acaba apenas quando o jogador perder todas as vidas;
  • Jogue e melhore: Jogue o jogo várias vezes e escreva tudo que você pode fazer para melhorar o que já tem no jogo ou novas ideias para expandir ele. Depois resolva esses problemas da mesma forma que você fez nos Exercícios de Programação!
  • Experimente com os procedimentos: A biblioteca Game Engine possui dezenas de procedimentos para criar coisas interessantes nos seus jogos. Não tenha medo de experimentar com eles e pesquisar sobre os que você não tiver entendido o funcionamento;
  • Novos jogos: Crie jogos do zero! Pode ser muito importante começar a experimentar com os recursos que você aprendeu com um objeto em aberto: deixe a ideia do jogo emergir enquanto você tiver programando, brinque com as ideias que você tiver e vai polindo o jogo para deixar ele o mais engajante possível.
Depois que você já tiver com mais confiança em tudo que aprendeu nesse tutorial, e se desafiou com os exercícios propostos, vá para o próximo tutorial!






Tappy Plane: Básico

Vamos criar outro jogo!
Esse tutorial reforça o que você aprendeu no último tutorial e expande para elementos novos bem interessantes para criar um jogo mais elaborado!
Então abra o Vizzcode e escolha esse tutorial na Tela de Boas Vindas!

Tappy Plane: Básico - Tela de Gameplay

Introdução e o que Vamos Construir
Se prepare para mais uma bomba de aprendizado!
Lembre de ir para a página da documentação da Game Engine sempre que você quiser saber mais sobre um certo procedimento ou sistema dentro da game engine! Você também precisa baixar os assets com esse link e extrair eles na sua página do projeto. Então vamos nessa!


Movimento do Jogador
Essa página começa fazendo os mesmos passos que você fez no tutorial anterior: criando o loop do jogo (game loop), desenhando o fundo, e criando e colocando o jogador no jogo. Você pode voltar ao tutorial e revisar esses elementos se precisar.
Os novos elementos introduzidos são simplesmente novos procedimentos da game engine. Você pode procurar por seus nomes na página da API da Game Engine e ler tudo sobre eles lá.
Uma pequena observação sobre o sistema de aceleração vs velocidade. Por conta da aceleração ser um derivativo da velocidade, ele simplesmente muda a velocidade do objeto! É por isso que quando você define a velocidade para um certo valor, todo o momentum construído pela aceleração vai embora, por conta da velocidade ter sido definida para um valor específico!


Se você Cair, Pode Levantar
No tutorial passado, nós usamos o procedimento objects_collided para verificar a colisão no nosso jogo.
Nós vamos começar esse jogo fazendo um teste de colisão na mão: confira a posição do objeto em relação a uma linha horizontal infinita, na posição y -35.
Pela razão de ser um comportamento bem simples (conferir se a posição está abaixo de uma certa linha), nós podemos fazer facilmente nós mesmos e mudar o jogo de acordo. Nesse jogo, vamos definir a variável de fim de jogo (game_over). Assim como fizemos anteriormente, essa variável vai ser a base do sistema de estados do jogo (o jogo acabou ou ainda está rodando?) e ser usada para realizar certas opções de interação para o jogador ou elementos visuais na tela.
Leia e analise o código do tutorial para garantir que o seu está similar e que você entende ele.


Pontuação
Essa página combina dois sistemas diferentes que criamos no tutorial passado: o sistema de pontuação (uma variável que incrementa em certas condições) e um cronômetro (uma variável que incrementa de forma continua a medida que o tempo for passando e quando ela chegar a um certo ponto, alguma ação é realizada).
Leia com cuida a explicação na página e veja como o problema foi quebrado em tarefas: Criando as variáveis, Implementando o cronômetro e a pontuação, Reiniciando a pontuação e Desenhando a pontuação.
Se você precisar, você pode voltar e reler as páginas específicas do tutorial sobre cronômetros and a pontuação.


Obstáculos Pedregosos
Essa página explica e implementa vários passos para resultar no sistemas de obstáculos no jogo.
É importante ler a página inteira com muita atenção pois cada parágrafo é construído a partir do anterior.
Você já sabe como criar e colocar em jogo obstáculos por conta das páginas e tutoriais anteriores (como essa aqui) e colisões também (como essa aqui).
Um ponto interessante ensinado nessa página é o uso de procedimentos para refatorar o código. Temos um tutorial completo sobre procedimentos caso você não esteja familiar com eles. Você pode acessar ele aqui.
Quanto mais complicado o programa fica (e estamos começando a criar programas mais complexos) mais importante se torna a necessidade de mover o código e mais você aprende sobre o programa. Sempre que você tiver criando um programa não trivial, você tem alguma ideia de onde está indo mas os detalhes de implementar o que você deseja costumam ser obscuros. É por isso que é muito importante ser capaz de experimentar criando uma solução (como simplesmente implementar a morte do jogador) e quando você encontrar uma oportunidade de organizar o seu código melhor baseado na forma que ele tiver ganhando forma, você pode refatorar o código – organizando ele de uma forma mais otimizada. Outra forma de pensar sobre esse processo é que uma vez que você entender melhor o que o código significa, você pode mudar ele para uma representação melhor que significa: que o código faz a mesma coisa, mas ele faz isso de uma forma melhorar agora que você expandiu ele ainda mais e aprendeu mais sobre os detalhes da sua solução. Por conta disso, esse processo também é conhecido como compressão semântica.
Essa página também vai mais a fundo no sistema de cenas da game engine. A melhor forma de aprender sobre ele é acessando a API da Game Engine e lendo a descrição e os exemplos dos procedimentos do sistema de cenas.


Pedras Ilimitadas
Essa página te desafia a criar um cronômetro (conforme fizemos antes) para fazer as pedras serem criadas de forma continua.
O resto da página discute sobre como testar o jogo para encontrar bugs e resolver eles.
Na documentação nós já discutimos sobre resolver problemas de compilação mas bugs no programa são uma besta diferente.
Você realmente precisa entender o programa e o que ele está fazendo para perceber a razão de certos comportamentos inesperados estarem acontecendo para resolver eles. Quanto mais complicado o programa, mais difícil fica encontrar bugs, por isso testar é muito importante. O teste funciona melhor quando é capaz de replicar um bug com uma simples conjunto de passos. Se você souber quais são os passos para vero bug, você pode analisar o código e entender o estado do programa naquele ponto (você pode até executar o programa em um pedaço de papel (ou na sua cabeça) conforme falamos aqui).
Uma outra forma bem interessante que você pode usar para procurar por bugs e entender cada valor do programa é desenhar variáveis chaves na tela, para você comparar seus valores reais com os que você tinha assumido. Você pode usar todos os procedimentos para desenhar da game engine para te ajudar com isso.


Música, Efeitos Sonoros e Partículas
Esse tutorial simplesmente usa o que você aprendeu antes para dar os toques finais no jogo.
Se você não tiver certeza sobre como um certo procedimento funciona, apenas procure por ele na referência da API da Game Engine.
Você também pode voltar no último tutorial onde falamos sobre polir o jogo.


Tela de Começo
Essa página faz uma abordagem incremental em programar uma nova funcionalidade.
Primeiramente, discutimos as possibilidades de implementar a tela de começo (start), e depois escolhemos uma das possíveis abordagens.
Uma vez que a ideia básica for implementada, nós testamos o jogo e procuramos por formas de implementar, e depois melhorar ele. Em seguida, nós testamos novamente e procuramos por mais formas, e assim por diante...
Essa abordagem interativa é muito valiosa quando você está programando novas funcionalidades, descobrindo novas formas de implementar soluções que você ainda não se acostumou.
Garanta que você tenha lido cada parágrafo prestando bastante atenção e implemente ele de acordo. Cada funcionalidade vai ser construída a partir da anterior.
Você também pode tentar implementar a solução de maneiras diferentes, da sua própria forma. Isso é muito importante para sua jornada de aprendizado.

Tente levar essa abordagem para o próprio jogo. Onde você quer melhorar ele? Teste ele, encontre uma forma de deixar ele melhor, e depois pesquise uma forma de implementar os pontos de melhora.
Se o programa tiver saindo do seu controle por conta da complexidade, comece um novo projeto; um que seja bem pequeno, para você conseguir gerenciar sua complexidade e aprender ao longo do caminho. A habilidade de gerenciar a complexidade do programa pode ser desenvolvida como qualquer outra. Então pratique, pratique, pratique! :)

Quando você tiver sentido que já pode absolver mais informação, comece o próximo tutorial.






Jogo da Velha: Básico

Nesse tutorial, você vai aprender muito sobre lógica de jogos e como estruturar ela. Você vai aprender formas diferentes de transformar dados e programar o código de gameplay.
Tudo que você precisa para começar é abrir o Vizzcode e clicar nesse tutorial!


Jogo da Velha: Básico - Tela de Gameplay

Introdução e o que Vamos Construir
O Jogo da Velha que vamos criar pode parecer simples, mas essa que é a beleza de fazer jogos: você pode começar com o sistema mais simples e explorar ele de várias formas interessantes; em termos de programação, design, arte, som e qualquer outra disciplina envolvida. Nós vamos focar em criar a lógica do jogo usando a game engine apenas para mostrar imagens e tocar os sons.


O Tabuleiro na Memória vs o Tabuleiro Visual
Da mesma forma como antes, você pode baixar os assets aqui e extrair eles na pasta do projeto.
Para conseguir resolver um problema com sucesso, nós precisamos entender as ferramentas que temos e escolher elas de acordo. Se você resolveu o último Exercícios de Programação de array você já usou o array como uma estrutura de dados para representar um grid 2D. Se você ainda não resolveu, eu recomendo fortemente que você pare esse tutorial e tente resolver aquele exercício. As dicas do exercício também vão te ajudar a entender a estrutura de dados que vamos usar para armazenar e operar no tabuleiro nesse jogo.
Se você resolver o exercício e reler a página e ainda não tiver certeza como o sistema vai funcionar, apenas passe para as próximas páginas que ele vai começar a fazer sentido. Em seguida, você pode voltar e analisar a explicação base depois de ter visto como ele funciona na prática.


Desenhando o Tabuleiro
Essa página mostra o método bem útil de escrever o código usado primeiro.
Quando você resolve um problema dessa forma, você vai criar uma interface bem legal entre o código que quer uma certa funcionalidade e o código que implementa ela. Tem um bocado de pensamento envolvido na resolução desses problemas, então garanta que você conheça as ferramentas que você tem a disposição. Por exemplo, se você não tiver muito confiante usando procedimentos, você pode conferir a documentação ou até mesmo o tutorial inteiro de introdução.
O último Exercício de Programação de array também ajuda a consolidar algum dos problemas mais práticos nessa página.
As imagens estão lá para te ajudar, invista algum tempo para entender cada imagem. Se você precisar, escreva outros exemplos ou transformações que estão acontecendo entre os diferentes elementos da imagem. Por exemplo: como esses diagramas funcionariam em um grid 4x5. Tente resolver esse problema bem devagar e você vai compreender muito melhor.


Transformando o Clique do Mouse
Essa página foca na transformação de volta para o formato do índice.
Se você tiver dificuldade em algumas partes da explicação, tente voltar alguns parágrafos e testar com valores diferentes, como uma grid 4x5.
Pode ser bem útil desenhar um tabuleiro e brincar como ele com seus valores para garantir que a fórmula funciona e você entende ela.
Esse método de usar um int onde cada número significa alguma coisa (como um código de erro) é um método muito comum e você vai ver muito ele quando tiver usando o código de outras pessoas. É muito importante se acostumar com essa forma mais abstrata de se referir aos dados.


Lógica Baseada em Turno
De forma similar ao que já fizemos, você pode criar variáveis para armazenar informação sobre o estado do jogo (como "Qual jogador deve fazer a marcação agora?"). Essas variáveis podem em seguida movimentar certas partes do código ou simplesmente serem usadas diretamente como um valor.
De novo, a abordagem incremental de resolver problemas está presente, onde você implementa uma solução simples e avalia a resolução, melhorando até que esteja completo.


Condição de Vitória
Nessa página nós criamos um procedimento para testar o tabuleiro. Ele reforça o uso de variáveis globais e inteiros como estados. Nesse caso, nós especificamos o significado do valor (1 se o jogador 1 ganhar, 2 se o jogador 2 ganhar, 3 se empatar, e 0 para continuar jogando) para facilitar pra gente no programa. Por exemplo, não vamos precisar de saber qual jogador ganhou: se a marca não tiver vazia e for igual numa coluna, linha ou diagonal inteira, nós simplesmente retornamos o valor daquela peça do tabuleiro pois vai coincidir como nosso dado do valor retornado (1 se o jogador 1 ganhar e 2 se o jogador 2 ganhar).
Os testes são provavelmente mais fáceis que você pensou! Na maioria das vezes a solução mais simples é a melhor: apenas teste cada linha, coluna e diagonal!
Em seguida, usar o valor de retorno como um estado para o jogo já deve ser bem familiar para você.


Polindo e Distribuindo
Essa página te convida a adicionar um tanto de efeitos bacanas de feedback, conforme vimos antes. Você também pode explorar a Game Engine docs para descobrir novas formas interessantes de melhorar seu jogo.
Fazer as marcas realçarem a linha, coluna ou diagonal que ganhou é mais fácil que você pensa. Tudo que você precisa fazer é criar outro estado possível para o quadrado (tile) do tabuleiro (como 3 = realçar X, 4 = realçar O) e quando você testar a linha, coluna ou diagonal, você também muda seu valor!
A IA (Inteligência Artificial) para o jogo pode começar bem simples, apenas selecionando um quadrado aleatório disponível no tabuleiro. Isso seria principalmente sobre estruturar o código para fazer com que apenas o jogador interaja com o jogo e o “outro jogador” seja simplesmente um procedimento onde a peça da IA deve ficar.
Por fim, você pode distribuir os jogos na internet! Você pode até publicar ele numa loja de jogo para que outros jogadores encontrem seu jogo e talvez até fazer você ganhar algum dinheiro!
Lembre-se de colocar essas habilidades em prática. Uma boa técnica pode ser voltar e passar pelos tutoriais passados procurando por oportunidades de melhorar o jogo e o código.
Depois disso, um outro tutorial vai estar te esperando para expandir ainda mais seus conhecimentos!






Galeria de Tiro: Básico

Até agora, nós estamos tanto usando o sistema de objetos da Game Engine (como nos Invasores e Tappy Aviões) ou nenhum (como no Jogo da Velha). Nesse tutorial, você vai aprender como fazer um sistema de objetos customizado. Isso vai expandir muito as possibilidades dos jogos que você pode fazer. Você vai especificar quais dados cada objeto vai armazenar e como ele vai usar durante a parte da simulação do jogo. Você vai aprender maneiras bem legais de animar um objeto e renderizar um objetos com várias partes!
Tudo que você precisa para começar é baixar o Vizzcode e selecionar esse tutorial na Tela de Boas Vindas!


Galeria de Tiro: Básico - Tela de Gameplay

Introdução e o que Vamos Construir
Essa página revisa conceitos importantes que já aprendemos sobre Entrada->Simulação->Renderização bem como usar arrays paralelos para armazenar múltiplos dados diferentes de um único "objeto".
Se você precisar, você pode revisar essa página de Fazendo Jogos para relembrar a estrutura fundamental de jogos em código.
O conceito de arrays paralelos foi introduzido na parte 8 da série de tutoriais de Introdução à Programação (que você pode revisar aqui) e solidificado em vários dos Exercícios de Programação de arrays.
Garanta que você esteja bem confiante com esses conceitos antes de começar.
Baixe os assets aqui, extraia eles na sua pasta do projeto, e vá em frente!


Criando o Sistema de Objetos
Assim como na última vez, nós começamos criando uma estrutura de dados para os dados do jogo. Mas dessa vez, por conta de precisarmos de várias variáveis de vários objetos diferentes, nós criamos arrays diferentes: um para cada elemento do objeto inteiro.
É importante analisar os diagramas de forma bem cuidadosa para entender a disposição (layout) dos dados. Você também pode rever o tutorial de arrays que possui diversos exemplos do uso de múltiplos arrays para referir ao mesmo objeto de dados. Nos Exercícios de Programação tem vários exemplos do uso de arrays paralelos para resolver problemas. Cada um desses exercícios possui várias dicas que explicam ainda mais o conceito.
Se você tiver tendo dificuldade para entender no tutorial, tente gastar um tempo estudando os outros tutoriais que implementar ele aqui vai ficar bem mais fácil.
É claro, você também pode optar por seguir em frente. A medida que os resultados forem aparecendo, fica mais fácil de entender algumas das decisões.


Animando os Alvos
Algumas áreas da programação de jogos pode conter um pouco de matemática.
Você pode tentar entender cada aspecto dele, provavelmente pesquisando online por mais detalhes da função de interpolação linear. Você também pode focar no entendimento de como usar ela na prática.
Independente do ritmo, é fundamental saber os recursos da programação para implementar o lerp (interpolação linear) no Vizzcode, como as expressões aritméticas e procedimentos.
Os diagramas na página vão explicar como a função funciona no código, então preste bastante atenção.
Você também pode experimentar com a função depois de copiar ela do tutorial para ver os resultados na prática, tente definir um exemplo simples com uma única chamada de draw_rectangle no qual a posição x é definida por uma função lerp. Tente chamar o lerp com t = 0, t = 1, e com valores entre eles. Depois (igual o tutorial), adicione um cronômetro nele e tente controlar ele ainda mais.


O Comportamento do Tempo de Vida do Alvo
Anteriormente, nós estávamos usando uma variável do tipo bool ou int para definir algum estado. Baseado no valor, nós executaríamos algum código
Nesse caso, nós fazemos exatamente a mesma coisa, mas usando uma variável do tipo float. Então vamos adicionar condições para operar partes do código (por exemplo, definindo a variável render_y) para trabalhar de uma certa forma caso o cronômetro esteja entre alguns valores ou trabalhar de alguma outra forma se tiver dentro de outro intervalo.
Entender ele e ser capaz de manipular o cronômetro é muito importante.
Para te ajudar a visualizar isso, tente chamar o draw_float e draw_text para que você saiba o valor do cronômetro bem como o que ele está executando no programa. A melhor forma de entender isso é lendo a página do tutorial de forma bem atenciosa e experimentar mudar os valores e brincar com o código em cada passo do caminho.


Fazendo o Jogador Atirar no Alvo
Nós já utilizamos o procedimento objects_collided que a Game Engine oferece bem como implementamos uma simples colisão de ponto vs linha.
Nessa página, esse conhecimento é expandido ainda mais quando nós implementamos uma colisão de ponto vs circulo.
A ideia é simples, nós precisamos saber se o usuário clicou no alvo. O cursor do mouse é um ponto no mundo, o alvo é um circulo. Nós precisamos ver se o ponto está dentro do alvo quando o usuário clicar o botão esquerdo do mouse.
Para fazer isso, nós precisamos checar a distância entre o ponto e o centro da esfera e conferir se é menor que o raio.
Assim como os outros problemas de programação carregados de matemática, você pode escolher em focar em apenas aplicar a matemática no seu programa ou você pode ir para o próximo nível e tentar entender o por que dele funcionar da forma como funciona.
Os diagramas foram feitos para te ajudar, lembre de prestar bastante atenção em cada parágrafo.
Você também pode apenas copiar o código e aplicar ele em um programa mais simples pra brincar e entender essa única coisa. Simplificar para ganhar entendimento é sempre uma ótima forma de aprender!


Objetivo do Jogador
Uma das coisas mais incríveis sobre programação é que ela te ajuda a experimentar rapidamente com ideias malucas e testar os resultados de verdade. Em outras áreas, por exemplo, é necessário muito planejamento e você não pode iterar muito. Por exemplo, depois de construir uma casa, você não pode virar ela em 45 graus para ter uma melhor posição do sol sem ter que refazer ela inteira! A programação é muito mais flexível que isso, e sempre nos permite experimentar com ideias e ver os resultados para avaliar eles. Muitos game designers (especialmente em times menores) possuem essa abordagem experimental. Até mesmo em times maiores, programadores podem sempre experimentar com os problemas que precisam resolver e voltar para refazer a solução se precisar
Essa página te encoraja a experimentar com objetos de jogadores diferentes nesse jogo, enquanto está mostrando como criar um sistema simples de pontuação.


Polindo o Jogo
Você já se acostumou de adicionar esses toques finais nos seus jogos. É apenas uma questão de saber quais procedimentos estão a sua disposição quando está usando a biblioteca Game Engine e usar eles de formas criativas. Acessar a API da engine é uma ótima forma de aprender isso, mas brincar e testar ideias malucas é a melhor forma de descobrir efeitos e resultados legais!

Com o que você aprendeu até agora você está certamente capaz de criar vários jogos bem legais e interessantes! Você também pode polir eles de uma forma bem legal e publicar eles!
Lembre que quanto mais jogos você lançar, melhor você vai ficar em fazer eles! Então comece de forma simples e crie com muita frequência.
Quando quiser dar outro passo no seu conhecimento de desenvolvimento de jogos, confira esse último tutorial!






Invasores: Avançado

Esse tutorial vai te mostrar como elevar seus jogos para o próximo nível.
Você vai aprender mais sobre sensação do jogo (game feel), organização do seu código, programação de elementos do gameplay, fazer o som e os visuais do jogo ficarem ainda melhor e mais!
Você deve estar confortável com todos os recursos da programação bem como as técnicas que você aprendeu nos últimos tutoriais.
Vamos nessa!?


Invadores: Avançado - Tela de Gameplay

Introdução e o que Vamos Construir
É muito importante celebrar seu progresso, especialmente se você tiver fazendo alguma coisa difícil como programar jogos!
Você já deve ter o código do Invasores: Básico funcionando. Então apenas copie o código em um novo projeto (você também deve copiar os assets, ou baixar eles de novo aqui).


Adicionando a Nave Inimiga
Essa página realmente te mostra a essência da programação, agora que você já passou pelo básico: combinar o que você já sabe de formas interessantes para criar resultados únicos.
Essa página usa objetos, colisões, compressão semântica, cronômetros e outros incontáveis elementos.
É por essa razão que é importante voltar nos tutoriais que você não tenha entendido completamente para você usufruir de todo conhecimento que tem a disposição.
Os “novos” elementos introduzidos são simplesmente procedimentos ou parâmetros específicos da biblioteca Game Engine que você ainda não usou. Se você explorar sua página da documentação, você vai encontrar diversas outras ferramentas que você pode usar, e sua criatividade vai combinar elas com o que você já sabe para criar comportamentos bem legais.
Se a quantidade de coisas ficar muito grande, lembre de quebrar o problema em partes menores até que eles fiquem fácil o suficiente para você resolver eles. Tem uma seção na documentação para te ajudar a entrar no mindset de resolução de problemas aqui.


Movimento e Limpeza do Código
"Assim como construímos, nós também devemos limpar", um filósofo da antiguidade falou.... Eu acho...
O importante de entender é que quanto mais funcionalidades nós adicionamos, mais oportunidades vamos ter de melhorar o código e resolver bugs. Um erro como entre programadores é ficar apenas construindo e construindo até seus programas ficarem tão grandes a ponto de não conseguirem entender e trabalhar neles. Eles ficam infestados de bugs e o custo de manutenção fica gigante. Eles ficam interconectados de forma tão complexa que você não consegue nem refatorar ele nesse ponto.
Isso pode parecer um absurdo, mas é muito comum!
Coisas pequenas como remover código duplicado, revisar como você resolveu o problema depois de terminar de resolver ele corretamente e resolver bugs são cruciais para criar sistemas complexos mas saudáveis. Sempre avalie seu código e seu entendimento dele!


Destrua os Objetos Fora da Tela
Um outro ótimo benefício de entender como seu programa funciona em um nível mais profundo é que você percebe as oportunidades de otimização.
Mesmo os computadores sendo super rápidos, você já deve ter se frustrado com programas que pareceram demorar anos para fazer alguma coisa. Bem provavelmente, é por conta de seus programadores não terem um entendimento profundo de seus programas, apenas um entendimento superficial.
Por exemplo, no caso do nosso jogo, nós estávamos criando objetos infinitamente, e mesmo que nós reiniciamos a cena (deletando todos os objetos) quando o jogador reinicia o jogo, durante o gameplay os objetos ficam empilhando, mesmo não sendo mais necessários.
Com isso em mente, nós criamos um objeto invisível (definindo o valor da sua cor alpha (opacidade) para zero) e destruindo as instâncias que colidem com ele.


Fundo com Parallax
Essa página introduz um conceito que você com certeza vai ver em jogos profissionais: animações secundárias. Elas ajudam dar vida para o mundo do jogo e imergir os jogadores nele.
Usando o mesmo sistema de colisão ponto vs linha que aprendemos um tempo atrás, nós implementamos um ciclo infinito de planetas em movimento no fundo, com diversos elementos aleatórios para evitar parecer repetitivo.
Se você precisar, você pode sempre criar um projeto vazio e criar essa funcionalidade com mais nada poluindo o código do jogo. Isso vai te ajudar a brincar com ela e entender como o sistema funciona completamente.


Renderização de Fonte Customizada
Outro aspecto importante que você vai ver em jogos de qualidade profissional é uma coerência visual.
Isso significa que eles não vão usar uma fonte aleatória para mostrar a pontuação só porque ela é a fonte padrão que a game engine usa para mostrar números inteiros. Eles vão considerar a fonte mais adequada para imergir o jogador no mundo que eles criaram e como ela pode ser usada para aumentar a sensação e a imersão.
Uma ótima técnica a ser usada quando tiver melhorando algum elemento no programa é evitar mudar a API (ou a interface entre o código que usa uma funcionalidade e o código que implementa ele).
Por exemplo, nós não sabemos como o procedimento draw_int funciona, mas sabemos que chamamos ele passando o valor para desenhar e as posições x e y. Então se criarmos um outro procedimento que possui a mesma interface, nós não precisamos mudar o código que está chamando – apenas o procedimento que ele está chamando!

Com isso em mente, o desafio se torna implementar a nova rotina.
Se você fez os exercícios de Entrada, Processamento, Saída na página de Exercícios de Programação, especificamente os exercícios Segundos e Minutos e o Dias, Horas, Segundos e Minutos, você já usou os operadores de divisão e módulo para decompor um número.
Isso é precisamente o que está acontecendo aqui.
Se você precisar, você pode criar um programa simples de console e imprimir o resultado dos operadores para garantir que você entenda o que está acontecendo. Você também pode ler mais sobre expressões aritméticas e especialmente o operador módulo.


Design de Som Avançado
Você já sabe como tocar um som e você usou isso de forma eficiente para fazer a sensação do jogo ficar melhor.
Mas você pode sempre melhorar!

Como você pode ver os elementos base que foram usados para criar esses efeitos bacanas agora são novos ou malucos (mesmo com nós termos usado o button_pressed, button_is_down bem do lado dele na documentação ;) )
O ponto interessante é a forma que eles foram usados: criando um construtor if com todas as teclas possíveis que o jogador pode apertar para mover a nave, nós criamos um pedaço de código que é executado apenas quando o jogador está se movendo. E, conforme aprendemos, adicionar feedback para fazer a percepção do jogador ficar mais conectada a suas ações é uma ótima forma de fazer a sensação do jogo ficar melhor.
Salvando o id do som e mudar seu volume é bem fácil quando você usa o que já sabe para criar uma boa estrutura de código.


Polimento Final
Novamente, usar o que você aprendeu de forma criativa pode resultar em elementos bem interessante no jogo!
Chamar o spawn_particles todo frame criou um efeito bem legal que reforça o efeito sonoro que criamos, quando você entende suas armadilhas (como ser dependente do frame rate) é ainda melhor, porque você pode conscientemente usar de uma forma que vai fazer o jogo ficar melhor e evite usar quando ele puder apresentar alguns problemas.
Existem vários tesouros escondidos na API da Game Engine como os procedimento set_object_particle_trail e set_window_options, então não deixe de ler a documentação e até mesmo experimentar tentando chamar esses procedimentos em um projeto teste de jogo!


Celebre e Continue Sua Jornada
Parabéns! É muito legal que você terminou todos os tutoriais e esperamos que você realmente esteja curtindo seus novos super poderes! :)
Uma coisa muito legal dos super poderes da programação é que quanto mais você usar eles, mais poderosos eles ficam! Te fazendo ser capaz de criar projetos cada vez melhores!
As sugestões que eu dei nessa página são ótimos pontos para continuar sua jornada, sempre que você sentir dificuldade na sua jornada de programação, comece um novo projeto que você queira muito fazer e deixe as ideias evoluírem enquanto você desenvolve o programa!
Bom, é isso! Até logo!