Aprendendo a programar jogos em Unity: transferindo valores entre variáveis de controladores do game

Seja bem-vindo(a) ao GameDev: Aprendendo a programar jogos em Unity de hoje! Após realizarmos, em nosso encontro anterior, extensas alterações no código-fonte do script MontaLabirinto, iremos prosseguir com a construção de nosso game, configurando a interação entre o controlador de fases do jogo e o módulo de montagem dos labirintos.

Se esta for a primeira vez que você interage com conteúdos de nossa série, considere-se convidado(a) a juntar-se a nós em uma jornada repleta de aprendizados interessantes sobre o mundo do desenvolvimento de jogos digitais. Por meio do uso da plataforma Unity, iremos aprender, na prática, diferentes aspectos do processo de criação de games, tanto em relação à codificação de suas regras e comportamentos de personagens, quanto ao processo de inserção, posicionamento e configuração dos elementos multimídia de uma aventura virtual, tais como as imagens, sons e objetos que compõem as fases de um jogo.

No momento, estamos elaborando o game Consultório do Dr. Tratanildo, um puzzle ambientado em um consultório médico tridimensional, cujas características de gameplay prestam homenagem a clássicos dos anos 1980 e 1990, tais como Pac-Man (Namco, 1980) e Dr. Mario (Nintendo, 1990).

Talvez, à primeira vista, nossos conteúdos pareçam ser de difícil compreensão para quem nunca teve a oportunidade prévia de aprender conceitos de programação de jogos ou de sistemas. Caso essa seja sua percepção inicial, fique tranquilo, pois, a partir do primeiro texto da série, abordamos os tópicos que envolvem a criação de um jogo “a partir do zero”, de uma forma didática e bem detalhada, permitindo a todos que tenham interesse em aprender sobre programação de games tirar do papel as aventuras que sempre sonharam ver tornar-se realidade.

Se você gostou dessa ideia, não perca mais tempo e venha conosco em uma divertida trilha, repleta de novos conhecimentos e muita diversão!

Interação entre scripts

Após termos introduzido importantes códigos na estrutura do MontaLabirinto, é importante realizarmos chamadas às novas funções criadas no decorrer do processo de controle do estado atual da fase corrente. Como o controle da sequência de fases é realizado pelo script ControllerFase, nossa primeira intervenção envolverá a edição de um pequeno trecho de seu código, permitindo, assim, que os comandos que elaboramos nos últimos encontros sejam devidamente executados.

Para iniciarmos esse processo, vamos abrir nosso projeto para edição. No Unity Hub, clique duas vezes sobre o item referente ao projeto Consultório do Dr. Tratanildo. Na interface inicial do editor, na aba Project, abra a pasta Assets, Scenes e, por fim, clique duas vezes no ícone da cena ConsultorioScene.

Na aba Project, abra a pasta Assets e, em seguida, Scripts. Clique duas vezes sobre o ícone que representa o script ControllerFase, para que possamos editá-lo no Visual Studio.

Logo após o término da caminhada do paciente pelo cenário, assim que ele chega ao leito hospitalar, é exibida, em tela, durante três segundos, uma visualização aérea do paciente e do labirinto que representa o interior de seu corpo. Nesse momento, é interessante que as posições dos agentes de doenças já tenham sido definidas e que o labirinto esteja configurado.

Como essas ações devem ocorrer antes do momento em que o jogador obtém o controle da movimentação do médico pelo cenário, iremos introduzir as seguintes linhas de código dentro da estrutura do script caminhadaPacienteLeito, imediatamente antes das linhas de código responsáveis pela exibição do paciente e do labirinto na tela:

        // Solicitar ao controlador do labirinto que realize as ações

        // para a devida montagem de seus elementos internos

        controladorLabirinto.LimparValoresVetoresVariaveis();

        controladorLabirinto.ImportarValoresVetoresVariaveis(faseCorrente, PosicaoMonstrosAzuis, PosicaoMonstrosVerdes,

            PosicaoMonstrosRoxos, PosicaoMonstrosAmarelos, PosicaoMonstrosVermelhos, PosicaoObstaculos, DimensaoObstaculos, PosicaoInicialPilulas);

        controladorLabirinto.Montar();

Em resumo, o código recém-introduzido irá realizar as seguintes ações:

• Solicitar ao controlador da montagem do labirinto que limpe o conteúdo interno dos vetores de variáveis que armazenarão as posições de agentes de doenças e obstáculos do labirinto;
• Conceder ao controlador do labirinto as informações de que ele necessita para, posteriormente, montar os elementos que representarão a parte interna do corpo do paciente;
• Ordenar a montagem definitiva do labirinto para aquela fase.

Note que, ao chamarmos a função ImportarValoresVetoresVariaveis, são passados como parâmetros praticamente todos os valores importantes para a construção adequada do labirinto, tais como a fase corrente, o posicionamento de cada agente de doenças e as características dos obstáculos dos labirintos.

Antes de voltarmos ao editor do Unity, vamos realizar outra breve intervenção no código de ControllerFase, desta vez visando permitir ao game saber a quantidade inicial de tempo ao se iniciar o desafio da fase corrente, exibindo, em tela, a informação por meio de barraInfoAcoes. 

Insira o seguinte trecho de código dentro de TransicaoParaTratamento, imediatamente antes do fechamento de chaves da função:

        tempoRestante = TempoMaxTratamento[faseCorrente];

        barraInfoAcoes.SetActive(true);

        Geral.ModoDeJogoCorrente = "BuscaMedicamentos";

Finalizamos as intervenções em código previstas para o encontro de hoje. Salve o script, feche o Visual Studio e retorne ao editor do Unity, para continuarmos a configurar os comportamentos de nosso game.

Referenciando pílulas e agentes de doenças

Em nosso encontro anterior, realizamos a introdução de novas variáveis públicas ao script MontaLabirinto, cujos nomes remetem às diferentes variantes de pílulas e de agentes de doenças que temos à disposição em nosso jogo:

Vamos, agora, indicar ao Unity quais são as variantes de cada tipo de agente de doença e de pílula disponíveis, permitindo que os elementos corretos apareçam no labirinto.

Na aba Hierarchy, selecione o GameObject Labirinto. Em seguida, observe, na aba Inspector, que diversos campos que representam as variáveis do componente Monta Labirinto estão aguardando preenchimento:

Os primeiros a serem alimentados serão os campos referentes às diferentes variantes de pílulas de nosso game. Preencha os campos descritos a seguir com os itens indicados, lembrando que, caso venha a utilizar a janela de seleção de GameObjects para indicar os itens, a aba Assets (destacada em verde) deve estar selecionada:

• Pilula Ref_azul: selecione o objeto de nome “Pilula_azul_lab”.
• Pilula Ref_verde: selecione o objeto de nome “Pilula_verde_lab”.
• Pilula Ref_roxa: selecione o objeto de nome “Pilula_roxa_lab”.
• Pilula Ref_amarela: selecione o objeto de nome “Pilula_amarela_lab”.
• Pilula Ref_vermelha: selecione o objeto de nome “Pilula_vermelha_lab”.

Em relação às variáveis representantes dos agentes de doenças, preencha os campos conforme destacado a seguir:

• Doenca Ref_azul: selecione o objeto de nome “DoencaAzul”.
• Doenca Ref_verde: selecione o objeto de nome “DoencaVerde”.
• Doenca Ref_roxa: selecione o objeto de nome “DoencaRoxa”.
• Doenca Ref_amarela: selecione o objeto de nome “DoencaAmarela”.
• Doenca Ref_vermelha: selecione o objeto de nome “DoencaVermelha”.

Que tal darmos uma olhada em como está ficando o resultado dessa etapa da construção de nossa aventura? Para isso, vamos à aba Game, clicando em seguida sobre o ícone do botão Play:

Está tudo indo muito bem, mas o labirinto que é bom... ainda está bem vazio, não concorda? Para que possamos ver, de fato, o labirinto ser criado dinamicamente, precisaremos preencher alguns dados adicionais em campos específicos do controlador de fases. 

Pause a simulação da execução de nosso game e retorne à visualização da aba Scene. Na aba Hierarchy, selecione o objeto ControladorFase. Inicialmente, via aba Inspector, iremos modificar o tamanho e o conteúdo dos seguintes vetores de variáveis presentes em Controller Fase:

• Posicao Monstros Vermelhos: vetor de tamanho 3.
• Element 0: X = 1; Y = 0; Z = 0.
• Element 1: X = 1; Y = 6; Z = 0.
• Element 2: X = 6; Y = 3; Z = 0.
• Posicao Obstaculos: vetor de tamanho 2.
• Element 0: X = 6; Y = 6; Z = 0.
• Element 1: X = -2; Y = 3; Z = 0.
• Dimensao Obstaculos: vetor de tamanho 2.
• Element 0: X = 2; Y = 2; Z = 0.
• Element 1: X = 12; Y = 1; Z = 0.

Experimente, novamente, simular a execução do game, por meio da aba Game e do botão Play. Note como, de fato, o que programamos até agora para o labirinto tornou-se realidade:

O posicionamento de cada elemento dentro do labirinto respeitou os valores recém-concedidos ao Controller Fase, conforme podemos ver pela imagem a seguir, tomando como exemplo o terceiro agente de doenças inserido no ambiente (AgenteDoencas_2):

Posteriormente, iremos substituir os valores adicionados pelos definitivos para cada fase. Por ora, podemos interromper a simulação, clicando novamente sobre o botão Play e retornando à aba Scene. Não se esqueça de salvar a cena (menu File, opção Save) e o projeto (menu File, opção Save Project) antes de fechar o editor do Unity.

Próximos passos

Após uma extensa bateria de codificações nos principais scripts controladores de nosso game, conseguimos ver “ao vivo” a criação do labirinto, por meio da leitura dos valores que indicamos diretamente em campos disponibilizados pelo editor do Unity. Parabéns por ter chegado a essa etapa do projeto!

Ainda teremos, pela frente, diversos desafios para integrar os demais módulos do jogo, além de ajustes de gameplay a serem realizados e da montagem de menus e outras interfaces de interação entre o jogador e nossa aventura. Mesmo diante de tantos desafios, é sempre bom refletirmos o quanto avançamos durante nossa jornada, para que possamos celebrar as pequenas e grandes conquistas.

Justamente por isso, já adianto que o próximo texto de nossa série será muito especial, pois comemoraremos nosso centésimo encontro analisando todo o caminho que percorremos até hoje, podendo, assim, ter uma melhor noção do quanto progredimos enquanto desenvolvedores de jogos, desde os tempos em que ainda interagíamos com cobrinhas jogadoras de pingue-pongue...

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

Revisão: Mariana Marçal