GameDev

Aprendendo a programar jogos em Unity: começando a desvendar o mundo dos scripts

Vamos concluir a composição gráfica do jogo e começar a codificar o game utilizando programação em scripts.

Seja bem-vindo(a) ao GameDev: Aprendendo a programar jogos em Unity de hoje! Dando andamento ao que iniciamos no texto anterior, iremos concluir a composição gráfica de nosso jogo e começaremos a implementar o código que irá dar vida e ação aos elementos de Forest Ping Pong.

Caso esteja acessando pela primeira vez nossa série, não se preocupe: no primeiro tópico de nossa jornada aprendemos a instalar e configurar o Unity, e no segundo tópico começamos a colocar a mão na massa, dando início ao desenvolvimento de uma homenagem ao jogo Pong. Fique à vontade para nos acompanhar nesta caminhada rumo a novos conhecimentos!

Bola em jogo (ou quase)

No Unity Hub vamos abrir o projeto Forest Ping Pong. Aguarde a abertura dele e, assim que carregar, vamos acessar a aba Scene, conforme imagem a seguir.

Apesar da bonita composição gráfica, nota-se que está faltando, talvez, o principal elemento de um jogo de ping pong: a bolinha! Então vamos criá-la.

Em Hierarchy, clique com o botão direito do mouse sobre o objeto Canvas, no menu clique em UI e, depois, em Image, conforme imagem a seguir:


Diferentemente de quando inserimos manualmente um componente Image em um objeto preexistente, agora estamos criando um novo GameObject que já virá “de fábrica” com o Image atrelado. Dê o nome de Bolinha para o objeto e pressione Enter.

Por enquanto, nossa bolinha está bem quadrada, não é? Então vamos arredondá-la. Selecione o objeto Bolinha e, em seu componente Image na aba Inspector, troque a Source Image por uma de nome Knob, conforme imagem ilustrativa:

Agora temos uma bola de verdade, porém um pouco grande... Vamos redimensioná-la, indo no RectTransform e alterando os parâmetros Width e Height para 50:

Pronto, todos os elementos gráficos do jogo estão dispostos em nossa cena. Clique na aba Game e pressione o botão Play (botão contendo um triângulo apontando para a direita) para ver o que acontece:

Apesar de já termos a bolinha, as cobras, a floresta e o placar, nada aconteceu, certo? Isso se deve ao fato de que o Unity ainda não sabe as regras do jogo, o que fazer e como fazer. É aí que entra o papel dos scripts: assim como os utilizados na “vida real”, em novelas, filmes e séries, os scripts no Unity servem para ditar o que vai acontecer nas interações entre os jogadores e os elementos do jogo.

Ainda na aba Game, aperte novamente o botão Play para sairmos do modo de execução, pois agora começaremos a codificar de fato o nosso jogo.

Ditando o comportamento

Vamos criar nosso primeiro script, responsável por ditar os comportamentos das cobrinhas neste jogo. Para isso, na aba Project, clique duas vezes sobre a pasta Scripts:

Agora, no espaço vazio da pasta, clique com o botão direito do mouse, selecione no menu a opção Create e, em seguida, C# Script:

Dê o nome de “comportamentoCobrinha” para o script (sem as aspas) e pressione Enter. A extensão do arquivo (.cs) será adicionada automaticamente.

Uma observação importante é que muitas linguagens de programação distinguem nomes e comandos em relação às letras maiúsculas ou minúsculas utilizadas. Em nomenclatura técnica é o que chamamos de case-sensitive. Por exemplo, para a linguagem C# as palavras “José” e “josé” não são consideradas iguais. Como dica, sugiro que, para nossos projetos, busque utilizar os mesmos nomes adotados nos tutoriais, inclusive em relação ao uso ou não de maiúsculas, minúsculas, espaços e acentuação.

Criado o script “comportamentoCobrinha”, clique duas vezes sobre seu ícone para conhecermos como ele é por dentro. O programa Visual Studio será aberto.


Se for a primeira vez que realiza a abertura desse programa em seu computador, pode ser que uma mensagem como essa apareça na tela. Basta clicar em Agora não, escolher um tema de cores de seu agrado e clicar em Iniciar o Visual Studio. Isso ocorrerá apenas uma vez.


Esta é a aparência de um script recém-criado pelo Unity:

Por padrão, são disponibilizados dois métodos vazios que apresentam comportamentos bem específicos: o código que for inserido entre as chaves { } do método void Start() será executado apenas quando o objeto (ou seu componente) for ativado ou carregado pela primeira vez na cena; já o código que for inserido entre as chaves { } do método void Update() será executado repetidamente a cada frame, ou seja, a cada quadro de animação do jogo (em média 60 vezes por segundo para jogos mais simples ou bem otimizados).

O que isso significa na prática? Se precisarmos indicar ao jogo um comportamento que deve acontecer continuamente (como o deslocamento de uma bolinha), iremos inserir o código no método void Update(); já se for algo que deve ocorrer pelo menos na hora que determinado objeto for ativado na cena, colocaremos o código em questão no método void Start().

O primeiro comportamento a ser “ensinado” ao jogo é o de movimentação das cobrinhas. Para isso, entre as chaves { } do método void Update() insira o seguinte código:

    if (Input.GetKeyDown(KeyCode.T))
    {
        gameObject.transform.position = new Vector2(gameObject. transform.position.x, gameObject. transform.position.y + 20);
    }
    else if (Input.GetKeyDown(KeyCode.G))
    {
    gameObject.transform.position = new Vector2(gameObject. transform.position.x, gameObject. transform.position.y - 20);
    }

Clique em Salvar (ícone com o símbolo do disquete) para guardar o conteúdo alterado, conforme indicações da imagem:


O código recém-inserido fará o seguinte: se, durante o game, o jogador pressionar a tecla T de seu teclado, o objeto se deslocará 20 posições para cima (eixo Y); já se apertar a tecla G, o objeto se deslocará 20 posições para baixo.

Mas como o game vai saber qual objeto terá seu posicionamento deslocado, ao se apertar essas teclas? Indicaremos isso agora: minimize o Visual Studio e volte ao Unity; selecione o objeto Personagem01, conforme imagem a seguir.

Na aba Inspector, clique em Add Component, em Scripts e, finalmente, em Comportamento Cobrinha.

Veja que, agora, o objeto Personagem01 tem um componente a mais: o script que você acabou de redigir. Vamos testar? Vá à aba Game e dê um Play. Clique sobre a tela do jogo e pressione algumas vezes as teclas T e G para movimentar o personagem.

Se você conseguiu movimentar a cobra da esquerda, parabéns. Estamos avançando bem em nosso projeto! Se não conseguiu, não fique chateado. Revise os passos anteriores para ver se está tudo OK com o código e a inserção do componente no objeto.

Ao término dos testes, clique novamente no botão Play para encerrar a simulação e irmos para nossa próxima etapa de desenvolvimento.

Dando vez à adversária

Agora, daremos movimentos à cobra “rival”. Volte ao Visual Studio e vamos editar novamente o script comportamentoCobrinha:

Antes do método void Start(), insira o seguinte código:

    public bool Cobrinha01, Cobrinha02;

Estamos, dessa forma, declarando variáveis booleanas (do tipo “verdadeiro ou falso”) de nome Cobrinha01 e Cobrinha02. Elas serão úteis para o que faremos a seguir:

Troque o conteúdo que inserimos dentro das chaves { } do método void Update() pelo conteúdo a seguir:

        //Se for a cobrinha 01
        if (Cobrinha01 == true)
        {
            if (Input.GetKeyDown(KeyCode.T))
            {
                gameObject.transform.position = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y + 20);
            }
            else if (Input.GetKeyDown(KeyCode.G))
            {
                gameObject.transform.position = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y - 20);
            }
        }

        //Se for a cobrinha 02
        if (Cobrinha02 == true)
        {
            if (Input.GetKeyDown(KeyCode.O))
            {
                gameObject.transform.position = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y + 20);
            }
            else if (Input.GetKeyDown(KeyCode.L))
            {
                gameObject.transform.position = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y - 20);
            }
        }


Apesar de o código ter mais do que dobrado de tamanho, o que fizemos foi de certo modo simples:

Se o código for atrelado à cobrinha de número 01, as teclas T e G controlarão a subida e a descida da cobra; já se estiver atrelado à cobrinha de número 02, as teclas O e L é que farão a personagem subir ou descer pelo cenário.

Salve o arquivo, clicando no ícone do disquete, minimize o Visual Studio e vamos voltar ao Unity.


Selecione o objeto Personagem01 e, na aba Inspector, em Comportamento Cobrinha agora são apresentados dois campos a serem selecionados: Cobrinha 01 e Cobrinha 02. Deixe marcada apenas a opção Cobrinha 01 para informar ao jogo que o Personagem01 é a tal cobrinha de número 01 que será controlada pelas teclas T e G do teclado.


Ainda na interface do Unity, selecione o objeto Personagem02. Na aba Inspector, clique em Add Component, em Scripts e em Comportamento Cobrinha. Ao aparecer o componente correspondente, deixe marcada apenas a opção Cobrinha 02. Ela será controlada pelas teclas O e L do teclado.

Experimente esse novo comportamento, indo à aba Game, pressionando Play e clicando sobre a tela do jogo. Para testar a movimentação da cobrinha à direita, utilize as teclas O e L. Não se esqueça de, ao final dos testes, interromper a simulação clicando novamente em Play:

Fluidez de movimentos

Deu para notar que, agora, as cobrinhas se movimentam conforme o comando do jogador; mas também percebe-se facilmente que o controle delas está meio “duro”, pois para deslocar as cobras precisamos pressionar repetidas vezes as teclas relacionadas a cada uma. Isso ocorre pois estamos utilizando, dentro do script comportamentoCobrinha, a função Input.GetKeyDown.

A função Input.GetKeyDown é acionada no momento em que o jogador pressiona determinada tecla, mas apenas nesse momento e não durante o período em que a tecla está sendo pressionada continuamente. Iremos então modificar em nosso código todas as entradas que contêm Input.GetKeyDown por Input.GetKey, pois essa função informa ao jogo se a tecla está pressionada ou não, independentemente se começou naquele momento ou antes:


Após realizar todas as modificações (indicadas pelos trechos de código em laranja na imagem anterior), salve o script, minimize o Visual Studio e experimente o jogo no Unity (aba Game, botão Play):

A movimentação está bem mais fluida agora, porém muito mais acelerada. Pare a simulação e volte ao Visual Studio para corrigirmos isso, modificando no código do script as entradas que movimentam 20 unidades no eixo Y por 1 unidade:


Novamente, após a realização das alterações destacadas em laranja na imagem anterior, salve o script, minimize o Visual Studio e experimente o jogo no Unity. Veja como a velocidade da movimentação melhorou substancialmente!

Da mesma forma que inserimos duas variáveis Cobrinha01 e Cobrinha02 "clicáveis" no editor do Unity, vamos inserir uma variável para podermos controlar a velocidade das cobrinhas também por lá. No código do script, logo abaixo da linha com a declaração das variáveis citadas, insira o seguinte código:

    public float VelocidadeDaCobrinha;

Após isso, vamos trocar no código as velocidades (que alteramos agora há pouco) para VelocidadeDaCobrinha, conforme destaques da imagem a seguir:


Salve o script, volte ao Unity, selecione os objetos Personagem01 e Personagem02 e, na aba Inspector, altere o valor de Velocidade da Cobrinha para 2.5 (dois ponto cinco).

Dica: para selecionar dois objetos simultaneamente na aba Hierarchy, clique no primeiro, pressione a tecla Ctrl e, com ela ainda pressionada, clique no segundo.

Se quiser, experimente e teste a movimentação na aba Game, botão Play, sem esquecer de interromper a execução da simulação no final do processo.

Para finalizar (por enquanto) as alterações comportamentais das nossas colegas peçonhentas, vamos retornar ao Visual Studio para trocar, pela última vez, as quatro entradas de velocidade que contêm a expressão VelocidadeDaCobrinha pelo código a seguir:

    (VelocidadeDaCobrinha * Time.deltaTime * 60)

Faça as alterações como nos campos destacados em laranja da imagem a seguir:


Por que devemos realizar essa alteração? Conforme indicado no texto anteriormente, o código que é inserido dentro do método void Update() é executado a cada frame, em média 60 vezes por segundo; porém, nem sempre isso ocorre, sobretudo em cenas mais pesadas e/ou em máquinas mais lentas — essa taxa de quadros pode cair para 30 fps (frames per second) ou menos.

Para evitar que a velocidade da movimentação das cobrinhas mude, dependendo se a máquina do jogador é veloz ou não ou se a cena for pesada, multiplicamos VelocidadeDaCobrinha por Time.deltaTime (função que nos dá o tempo exato entre um e outro frame no momento) e depois por 60 (para “inteirar” um segundo).

Ao término dessa etapa, salve o script no Visual Studio e feche-o. Se quiser, teste o jogo na aba Game do Unity. Não se esqueça de salvar sua cena (menu File > Save) e, também, seu projeto (menu File > Save Project) antes de fechar o editor.

Próximos passos

Começamos, enfim, a codificar e dar vida aos elementos de nosso game utilizando para isso os scripts. Em breve teremos o jogo completo para que você possa curtir e mostrar aos seus amigos, vizinhos, parentes, etc.

Nos próximos passos iremos programar os elementos invisíveis na tela que delimitam a área de jogo e começar a ensinar nossas cobrinhas a serem boas “goleiras”, rebatendo a bola para o lado oposto.

Nosso próximo texto já encontra-se disponível, continue conosco nessa jornada de conhecimento e fique ligado sempre aqui no GameBlast!

Revisão: Ives Boitano

Entendo videogames como sendo uma expressão de arte e lazer e, também, como uma impactante ferramenta de educação. No momento, doutorando em Sistemas da Informação pela EACH-USP, desenvolvendo jogos e sistemas desde 2020. Se quiser bater um papo comigo, nas redes sociais procure por @RodrigoGPontes.
Este texto não representa a opinião do GameBlast. Somos uma comunidade de gamers aberta às visões e experiências de cada autor. Escrevemos sob a licença Creative Commons BY-SA 3.0 - você pode usar e compartilhar este conteúdo desde que credite o autor e veículo original.