Se esta for a primeira vez que você lê conteúdos de nossa série, considere-se especialmente convidado(a) a mergulhar conosco em um oceano de experiências e de aprendizados sobre o universo do desenvolvimento de jogos digitais.
Por meio do uso da plataforma Unity, estamos desenvolvendo projetos práticos de programação de games, que estão nos permitindo aprender sobre diferentes aspectos do processo de criação dos jogos, tais como a concepção das fases e dos desafios de uma aventura virtual, a configuração dos elementos pertencentes ao cenário, a codificação das interações entre objetos e personagens, e o desenvolvimento dos códigos que permitirão ao jogo aplicar as regras que forem definidas.
Após o desenvolvimento de dois jogos completos, estamos trabalhando atualmente em nosso terceiro desafio, que consiste na elaboração do game Consultório do Dr. Tratanildo. Trata-se de um jogo tridimensional, ambientado em um consultório médico, cujas características de gameplay remetem a clássicos dos arcades e videogames dos anos 1980 e 1990, tais como Pac-Man (Namco, 1980) e Dr. Mario (Nintendo, 1990).
Nossa série é elaborada para permitir que todos possam desenvolver os jogos que sempre sonharam em ver tornarem-se realidade, mesmo àqueles que não tiveram oportunidades prévias de aprender sobre programação de jogos ou de sistemas. Para tal, a partir do primeiro texto, ensinamos desde os passos mais básicos, como a instalação da ferramenta Unity em nossos computadores, até as etapas consideradas mais desafiadoras, como as que envolvem a elaboração dos cenários dos jogos e a codificação de comportamentos por intermédio de scripts controladores.
Se você curtiu a ideia de criar seus próprios jogos, não perca mais tempo: aperte bem os cintos e vamos seguir juntos nessa estrada, repleta de novos conhecimentos e de muita diversão!
Modificando o controlador do labirinto
Após designarmos um local no cenário para que Doutor Tratanildo possa fornecer as pílulas coletadas pelo cenário ao paciente que está sendo tratado no momento, precisamos realizar ajustes em códigos do script controlador do labirinto e do script controlador da barra inferior do Canvas, visando permitir que os medicamentos sejam introduzidos na estrutura que representa o interior dos corpos dos pacientes apenas ao acionarmos um comando específico.
Para iniciarmos nossas intervenções, 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.
Durante a concepção inicial do script, realizávamos a inserção de todos os elementos pertencentes ao “quadro clínico” e ao tratamento de uma vez, já durante a montagem do labirinto. Isso incluía, dentre outros, o posicionamento das pílulas que tratariam o paciente dentro de seu corpo desde o princípio da jogatina.
Essa decisão prévia fez sentido durante o período em que estávamos testando elementos importantes do labirinto, como a interação física entre agentes de doenças, pílulas e obstáculos; porém, como um dos novos desafios impostos ao jogador é a de coletar os tratamentos adequados pelo cenário e iniciar o tratamento em tempo hábil, a ideia agora é a de não posicionar previamente as pílulas dentro do labirinto; somente após a concessão dos medicamentos ao paciente pelo médico.
Pensando nessa nova situação, realizaremos alterações no corpo de MontaLabirinto para bloquear o comportamento anterior (a concessão prévia de pílulas ao se montar o ambiente) e codificar a forma adequada de se introduzir os elementos no labirinto após sua montagem prévia.
Substitua as seguintes linhas dentro da estrutura da função Montar():
- De: // Posicionar no labirinto as novas pílulas e agentes de doenças
- Para: // Posicionar no labirinto os agentes de doenças
- De: pilulasCriadas = new GameObject[posicoesPilulas.Length];
- Para: pilulasCriadas = new GameObject[0];
Comente o bloco de códigos que vem logo após a linha de código doencasCriadas = new GameObject[posicoesDoencas.Length], inserindo os caracteres /* antes e */ depois do referido bloco.
As alterações deixarão o código conforme exemplificado pela imagem a seguir:
private void ColocarPilulaNoLab(string pilula)
{
System.Array.Resize(ref pilulasCriadas, pilulasCriadas.Length + 1);
int pos = pilulasCriadas.Length - 1;
switch (pilula)
{
case "Pilula_amarela":
pilulasCriadas[pos] = Instantiate(pilulaRef_amarela, grupoMedicamentos);
break;
case "Pilula_azul":
pilulasCriadas[pos] = Instantiate(pilulaRef_azul, grupoMedicamentos);
break;
case "Pilula_roxa":
pilulasCriadas[pos] = Instantiate(pilulaRef_roxa, grupoMedicamentos);
break;
case "Pilula_verde":
pilulasCriadas[pos] = Instantiate(pilulaRef_verde, grupoMedicamentos);
break;
case "Pilula_vermelha":
pilulasCriadas[pos] = Instantiate(pilulaRef_vermelha, grupoMedicamentos);
break;
}
pilulasCriadas[pos].name = "PilulaSaude_" + pos;
pilulasCriadas[pos].transform.localPosition = posicoesPilulas[pos % posicoesPilulas.Length];
pilulasCriadas[pos].SetActive(true);
}
A função ColocarPilulaNoLab será a responsável por introduzir, dentro da estrutura do labirinto, as pílulas após a montagem do labirinto. Para tal, a seguinte sequência de ações é realizada:
- Verifica-se o tipo de medicamento a ser introduzido, por intermédio do parâmetro pilula;
- O tamanho do vetor de controle pilulasCriadas é ampliado, visando armazenar uma referência adicional à pílula no ambiente;
- Instancia-se um novo elemento, subordinado a grupoMedicamentos, armazenando sua referência em pilulasCriadas;
- O novo elemento é posicionado fisicamente dentro do labirinto, respeitando os valores apresentados no vetor posicoesPilulas.
A função criada só poderá ser chamada por estruturas internas do script MontaLabirinto, devido a ter sido declarado com visibilidade private. Isso deve-se ao fato de que, antes de solicitarmos a inclusão de uma pílula no labirinto, teremos de realizar algumas verificações prévias, por exemplo, relacionadas a quais tipos de pílulas temos em cada mão de Doutor Tratanildo.
Para permitir a comunicação entre o código recém-introduzido e outros scripts do projeto, adicione o seguinte trecho de código antes da declaração de ColocarPilulaNoLab:
public void InserirPilulas(string pilula_1, string pilula_2)
{
if (pilula_1 != "N/A")
ColocarPilulaNoLab(pilula_1);
if (pilula_2 != "N/A")
ColocarPilulaNoLab(pilula_2);
}
Para facilitar a interpretação do código, utilizamos a expressão “N/A” para representar que não há pílula em uma das duas mãos do doutor, impedindo uma introdução incorreta de medicamento dentro do labirinto.
Intervenções no controlador da barra inferior
Salve o script e volte ao editor do Unity. Novamente na aba Project, ainda com a pasta Scripts em evidência, clique duas vezes sobre o ícone que representa o script ControllerBarraInferior para editarmos seu conteúdo no Visual Studio.
Inicialmente, adicionaremos a seguinte linha de código no final da área dedicada à declaração de variáveis:
internal string pilulaAConceder_1, pilulaAConceder_2;
Agora, dentro da estrutura de Update(), insira o seguinte bloco de códigos imediatamente antes do comando responsável pelo desligamento da barra inferior ao se pressionar a tecla “X”:
// Caso a opção informada no texto da barra inferior seja para conceder a(s) pílula(s),
// as pílulas sairão das mãos do médico, sendo limpas as respectivas variáveis,
// e MontaLabirinto será informado de que precisa introduzir as pílulas
// no labirinto já montado.
else if (TextoBarraInferior.text.StartsWith("Conceder pílula(s)"))
{
for (int i = 0; i < grupoPilulasMaoDireita.childCount; i++)
grupoPilulasMaoDireita.GetChild(i).gameObject.SetActive(false);
for (int i = 0; i < grupoPilulasMaoEsquerda.childCount; i++)
grupoPilulasMaoEsquerda.GetChild(i).gameObject.SetActive(false);
controladorFase.pilulaMaoDireita = "";
controladorFase.pilulaMaoEsquerda = "";
controladorFase.controladorLabirinto.InserirPilulas(pilulaAConceder_1, pilulaAConceder_2);
}
- Os elementos presentes em ambas as mãos de Doutor Tratanildo serão ocultados;
- Os valores das variáveis de controle referentes às pílulas em controladorFase serão limpos;
- Será solicitada a controladorLabirinto a inserção das pílulas dentro da estrutura dos labirintos, a partir dos valores armazenados em pilulaAConceder_1 e pilulaAConceder_2.
Salve o script e feche o Visual Studio. 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
Embora haja uma clara ligação lógica entre os comandos introduzidos ou modificados durante o encontro de hoje, para que todas as ações planejadas funcionem de forma adequada, ainda precisamos definir alguns pontos essenciais:
- Como serão concedidos valores para as variáveis pilulaAConceder_1 e pilulaAConceder_2;
- Quem será o responsável por exibir a barra inferior do Canvas assim que Tratanildo se aproximar do ponto determinado no cenário, além de alterar seu texto para “Conceder pílula(s)”;
- Sob quais condições as variáveis pilulaAConceder_1 e pilulaAConceder_2 receberão o valor de controle negativo “N/A”, presente na lógica de controle da função InserirPilulas de MontaLabirinto.
Além das modificações realizadas em comportamentos dos métodos de MontaLabirinto e de ControllerBarraInferior, precisaremos criar um novo script auxiliar que será responsável por controlar efetivamente todas essas condições elencadas.
Em nosso próximo encontro, realizaremos o desenvolvimento desse novo script controlador, configurando, também, sua atuação sobre determinados GameObjects por intermédio de alterações no projeto via editor do Unity.
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
