Game Engine un3

Prévia do material em texto

introdução
Introdução
Em um jogo, um bom ambiente 3D mantém um estilo visual consistente. Para isso, é possível utilizar
uma variedade de superfícies: metal, madeira, borracha, plástico, vidro, artefatos luminosos e,
assim, por diante. Para simular essas superfícies, o Unity utiliza, especi�camente, o Standard Shader ,
um conjunto de recursos para criar, manipular e renderizar objetos do mundo real com alta
qualidade, como madeira, pedras, plástico, vidro, metal e papel. O recurso permite combinar vários
tipos de texturas, sombreamento e iluminação em objetos. Nas próximas subseções, será descrito o
GAME ENGINEGAME ENGINE
CRIAÇÃO E MANIPULAÇÃO DECRIAÇÃO E MANIPULAÇÃO DE
SISTEMAS NO SISTEMAS NO UNITY3DUNITY3D
Autor: Me. George Santiago Alves
Revisor : I van Dimitry R Zyr ianof f
IN IC IAR
conceito e o funcionamento da renderização no Unity . Diante disso, estudaremos o relacionamento
entre Materials , Shaders e Textures . Além do mais,   discutiremos o funcionamento do sistema de
partículas no Unity , navegação, criação de níveis e terrenos.
Antes de tudo, o que é renderização? De maneira simpli�cada, a renderização tridimensional é o
processo de gerar uma imagem baseada em dados armazenados em um sistema. Por meio da
computação grá�ca, a renderização transforma dados tridimensionais em imagens bidimensionais,
com efeitos 3D. Para isso, usa-se programas de computador para manipular, editar e criar modelos
com três dimensões.
Na realidade, o objeto �nal produzido pelo processo de renderização não possui três dimensões.
Durante o processo de construção de modelos 3D, o usuário manipula as três dimensões para criar
estruturas especí�cas, como uma cadeira, uma espada, uma personagem, dentre outros. Isso
signi�ca que o objeto �nal de um modelo 3D é, na verdade, uma imagem bidimensional, que foi
desenvolvida por um processo de renderização, com base em um modelo tridimensional.
Simpli�cando, é um processo pelo qual são utilizados programas de computador para converter
modelos 3D (respectivamente, suas texturas, cores, iluminação, posição, dentre outros) em
informações combinadas sobre o valor de cada pixel em uma imagem bidimensional. Assim, com a
visualização daquele jogo em alta de�nição, com paisagens deslumbrantes e efeitos especiais de
última geração, ao �nal, ainda teremos uma sequência de imagens bidimensionais.
Materiais e EfeitosMateriais e Efeitos
Discutimos o conceito básico de renderização. Agora, iremos examinar alguns conceitos sobre
Materials, Shaders e Textures . Vamos lá?
Os materiais de�nem as propriedades da superfície de um objeto informando como esta deve ser
renderizada. Para isso, a engine usa, como referência, as texturas que o objeto utiliza. As texturas
são, basicamente, uma imagem formada por pixels ou bitmap . Para formar essa imagem, a engine
utiliza as propriedades do material como referência, para que o shader possa usá-las para calcular
as informações da superfície de um objeto, por exemplo, a sua cor, re�etividade e rugosidade. Um
pouco confuso? Em outras palavras, uma textura é uma imagem bidimensional que contém
informações sobre os pixels. Isso permite que você possa identi�cá-la e distingui-la de outras
texturas.
Já o material contém informações para mapear e converter uma textura bidimensional em um
modelo tridimensional, ou seja, um material pode ter várias texturas, pois, no Unity , é possível
aplicar texturas de maneiras diferentes. Ademais, é possível criar aparências realistas ou surreais em
um objeto, por exemplo, artefatos brilhantes, foscos, transparentes, luminosos, salientes, dentre
outros. Portanto, em um jogo 3D, você precisa criar a forma geométrica de um objeto, comumente,
utilizando um software de modelagem 3D. Após criá-lo ou utilizar um ativo pronto, é preciso de�nir
as con�gurações desejadas do material, como o sombreamento e as texturas que vão de�nir a
estética da superfície do objeto.
Por �m, aplicamos o material ao componente de renderização do objeto. Um shader é um script
contendo diversos cálculos matemáticos, para criar a visualização da superfície de um objeto. Em
modelos 3D, por padrão, o shader do Unity realiza cálculo de iluminação e sombreamento. Mas, por
suas propriedades, é possível de�nir cores,   texturas, modos de renderização, dentre outros. O
saiba mais
Saiba mais
Os atuais processadores x86-64 suportam os cálculos
necessários para processar, conectar e criar uma imagem
�nal de um objeto tridimensional. Isso signi�ca que
qualquer CPU moderna de um computador pode calcular e
visualizar imagens em alta qualidade. Existem, ainda, partes
dedicadas de sua arquitetura para esse tipo de
processamento. No entanto, o processo de renderização
envolve diversos cálculos matemáticos, o que exige uma
quantidade considerável de processamento paralelo. Diante
disso, foram criados componentes dedicados para esse tipo
de trabalho, os chamados GPUs ou unidades de
processamento grá�co. Para demonstrar isso, o Unity
desenvolveu um curta-metragem, renderizado em tempo
real, para apresentar o poder da engine . O curta é
executado em Quad HD (1440p), utilizando uma GTX980
GeForce. Saiba mais sobre a demonstração do Unity Adam
no link a seguir.
ACESSAR
https://unity3d.com/pages/adam
diagrama a seguir (Figura 3.1) demonstra o relacionamento entre as três entidades discutidas. Cada
uma desempenha um papel no �uxo de trabalho de renderização.
Os modelos 3D são, em sua essência, um conjunto de coordenadas tridimensionais chamadas
vértices. Os vértices são conectados para formar triângulos. Cada conexão pode conter informações,
como a posição, direção e coordenadas, para mapear texturas nos vértices. Para um modelo 3D ser
renderizado, é necessário um material. Os materiais são revestimentos que contém um shader e
valores para suas propriedades. Diferentes tipos de materiais podem compartilhar o mesmo shader ,
porém com valores diferentes. A engine suporta, atualmente, dois tipos diferentes de shaders : de
superfície e de vértice. O shader de superfície é utilizado para simular superfícies afetadas pela luz,
enquanto que o shader de vértice renderiza imagens sem considerar o comportamento da luz.
Para um melhor entendimento sobre os conceitos abordados, criaremos e usaremos um novo
material dentro da engine . Para criar um novo material, com o Unity aberto, acesse o menu superior
> Assets > Create > Material . Após adicionar, é possível de�nir o nome para o material criado, mas,
por enquanto, vamos deixar com o nome padrão ( New Material ). Após a criação do material, é
possível aplicá-lo a um objeto em cena, facilitando a visualização dos ajustes de suas propriedades.
Para esse �m, crie um novo objeto ( Sphere ). Agora, arraste o material para o Mesh renderer do
GameObject criado (Figura 3.2). Por padrão, um novo material recebe um shader com propriedades
vazias ( Standard ).
Após criar o material e anexá-lo a um objeto, vamos de�nir o shader a este. Para isso, basta
selecionar o material criado e, no inspector, expandir a opção shader . Observe que existe um menu
suspenso, contendo vários tipos distintos de shaders .  Cada um desses determinará as propriedades
Figura 3.1 - Fluxo de trabalho de renderização do Unity
Fonte: Elaborada pelo autor.
Figura 3.2 - New Material
Fonte: Elaborada pelo autor.
disponíveis para alterações. As alterações podem ser visualizadas em tempo real no objeto que o
material foi aplicado. Os principais tipos de shaders no Unity são:
mobile : otimizados para dispositivos móveis, por exemplo, tablets e smartphones;
nature : para árvores e terrenos;
UI : para a criação de objetos grá�cos da interface do usuário;
particles : para trabalhar com sistemas de partículas;
skybox : efeitos para renderizar planos de fundo. Ambientes por trás de toda a geometria
do objeto;
unlit : usado para ignorar luz e sombra;
FX : usado para efeitos de iluminação;
sprites : usado em sistemas de sprites 2D.
Observe que o 3D object criado anteriormente( Sphere ) é da cor branca. Por padrão, todos os
objetos criados recebem o material da cor branca. Mesmo após adicionarmos um material ao nosso
objeto, nenhuma mudança visual é notada. Por quê? Para responder a esta pergunta, precisaremos
entender as propriedades do shader (Figura 3.3).
A primeira propriedade é um menu suspenso, com modos de renderização ( Rendering Modes ). O
shader padrão ( standard ) vem com quatro modos distintos de renderização:
opaque : de�ne a opacidade de um objeto, ou seja, sem qualquer claridade. É o valor
padrão para renderizar objetos sólidos, sem qualquer transparência;
cutout : permite de�nir valores para renderizar objetos com partes transparentes ou
totalmente opacas. As áreas de�nidas pelo shaders são 100% opacas. Por exemplo,
materiais contendo furos ou áreas com aberturas;
fade : nesse modo, é possível alterar os valores de transparência para esmaecer ou
desbotar um objeto. Diferente do modo transparent , este altera os re�exos e a iluminação;
transparent : utilizado para renderizar objetos transparentes, como plásticos ou vidro,
automaticamente, serão atribuídos valores transparentes para o material. Entretanto, os
re�exos e efeitos de iluminação permanecerão visíveis.
Agora, altere os modos de renderização previamente apresentados. Você pode observar que as
alterações na esfera (Figura 3.2) não são claramente visíveis. Apenas quando escolhemos Fade e
Transparent podemos notar a opacidade do objeto. Isso ocorre porque o modo de renderização
depende de outras con�gurações, como o parâmetro Albedo . O Albedo de�ne a cor e a
transparência do material.  É possível de�nir a cor de um material utilizando o seletor de cores que,
por consequência, afetará todo o objeto, ou atribuir uma textura ao parâmetro Albedo . A textura
Figura 3.3 - Propriedades do Shader
Fonte: Elaborada pelo autor.
de�nirá os valores de cor e transparência ao material. O próximo parâmetro do shader é o Metallic ,
a propriedade responsável por de�nir a quantidade de luz re�etida pelo material. Observe que é
possível alterar o valor do parâmetro e, quanto mais próximo de 1 (valor máximo), mais o objeto
re�etirá luz. Além disso, é possível atribuir uma textura ao parâmetro metallic . Fazendo isso, os
controles deslizantes desaparecem.
Antes de darmos prosseguimento aos próximos parâmetros, vamos testar o funcionamento
daqueles anteriormente estudados. Para isso, vamos importar, da Asset store , o ativo Free sample
materials e Star�eld Skybox . Após importar, atribuiremos materiais aos parâmetros Albedo e Metallic .
Observe a Figura 3.4.
Essa cena foi criada com os recursos do Unity e implementada com os ativos importados
anteriormente. Em apenas poucos minutos, é possível criar ambientes com alta qualidade e validar
protótipos na engine . Agora, como criamos uma cena assim? Primeiramente, precisamos entender o
conceito de skybox , que é um tipo de shader , o qual pode ser aplicado à cena para mudar a
atmosfera geral do jogo. O funcionamento é similar àqueles estudados anteriormente. É possível
de�nir a opacidade, cor, transparência e modi�car valores para criar efeitos únicos. Para criar um
novo skybox , é preciso criar um novo material. Após isso, de�nir o tipo de tipos de shader para
skybox . Além disso, é possível importar shaders do tipo skybox da loja do Unity . Agora que
importamos os ativos da loja do Unity , vamos modi�car o skybox . Para isso, acesse o menu da
engine > window > rendering > lighting settings . A janela de con�gurações de iluminação será aberta.
Na opção scene , selecione skybox (ativo importado da loja do Unity ). Mudamos a atmosfera do jogo
e, agora, precisamos con�gurar a nosso objeto principal, que chamaremos de earth one (Figura 3.5).
Figura 3.5 - Earth one
Fonte: Elaborada pelo autor.
Figura 3.4 - Recursos do Unity
Fonte: Elaborada pelo autor.
Lembra do material que criamos anteriormente e anexamos a uma esfera? É o mesmo material,
apenas com os parâmetros modi�cados. Para os próximos conceitos abordados, utilize a Figura 3.6
como parâmetro para observar o comportamento das propriedades de um material.
Acesse o material da esfera e, em Albedo , atribua o material wood_1_baseColor a este. Observe que
a superfície da esfera mudou. No exemplo mostrado, foi utilizado um planeta com coloração
azulada. Para isso, acesse o seletor de cores no Albedo . O valor hexadecimal da cor usada foi
#0012FF. Tente testar outras cores e observe o resultado na cena. O próximo passo é atribuir o
material snow_steel_metallic no parâmetro Metallic . O valor usado na propriedade smoothness foi de
0.46. Essa propriedade de�ne a suavidade do material. Apenas com essas con�gurações, foi possível
criar um planeta simples.
A engine permite modi�car parâmetros para criar experiências únicas. Criamos nosso planeta e,
agora, precisamos criar as luas. Podemos criar um novo 3D object ( sphere ) ou selecionar a sphere (
earth one ) criada anteriormente e pressionar, simultaneamente, as teclas Ctrl+D. Esse atalho duplica
os GameObjects selecionados. Para a nossa cena, criaremos duas luas, que chamaremos de MoonOne
e MoonTwo . Selecione a primeira lua e modi�que a escala do objeto. Para isso, é possível editar as
propriedades no Inspector ou usar a ferramenta Rect tool , localizada na barra de ferramentas da
interface da engine . O usuário pode modi�car os valores para criar tamanhos diferentes no objeto. A
escala (XYZ), utilizada para a primeira lua do exemplo, foi de 0.3588144, bem como 0.2534 para a
segunda lua. Feito isso, quais são os próximos passos? Alterar a posição dos objetos! Quando você
duplica um objeto, este estará na mesma posição do objeto original, além de herdar todos os seus
componentes, propriedades e valores. De�na novas posições para as luas criadas. No exemplo, a
posição (XYZ) da primeira lua é: -1.5313, 0.3207 e -1.118; para a segunda, temos 0.926, 1.251 e
-1.118. Contudo, de�na valores diferentes, para criar novos parâmetros à cena. Por �m, precisamos
alterar os parâmetros das luas. Os valores foram:
MoonOne : textura usada no Albedo foi dirt_steel_2_baseColor. Para o metallic , atribuímos
a textura dirt_steel_2_metallic. Para o aspecto amarelado do planeta, de�nimos o valor
hexadecimal em #E8FF00. Observe, na Figura 3.7, como �cou a superfície da primeira lua;
Figura 3.6 - Propriedades de um material
Fonte: Adaptada de Unity... (on-line).
MoonTwo : textura usada no Albedo foi rust_steel_1_baseColor. Para o metallic , atribuímos
a textura rust_steel_1_specularLevel.  Para a cor, utilizamos o branco. O valor hexadecimal
foi #FFFFFF. Observe, na Figura 3.8, como �cou a superfície da segunda lua.
Figura 3.8 - MoonTwo
Fonte: Elaborada pelo autor.
Até agora, trabalhamos com objetos tridimensionais, que são representados por malhas poligonais,
enquanto que, em um jogo bidimensional, são utilizados sprites para a sua representação. Ambos,
malhas e sprites , são utilizados em objetos sólidos, com formas de�nidas; no mundo real, seriam
objetos tangíveis. Porém, existem outros elementos em um jogo que precisam ser representados e
não são objetos sólidos. Você pode imaginar que elementos são esses? São elementos �uidos e
intangíveis por natureza, como líquidos, nuvens, fumaça ou efeitos especiais para representar
áureas, feitiços, poderes, dentre outros.
Para essa �nalidade, o Unity utiliza o sistema de partículas, que são pequenas e numerosas imagens
ou malhas movidas por um sistema especial na engine . Por exemplo, em um líquido, cada partícula
é uma pequena textura de água semelhante a uma gota. Agora, o que acontece se juntarmos
diversas gotas de água em um copo? Um copo cheio de água, pois o volume é de�nido pelo número
de partículas (gotas) em um recipiente.
Para que entendamos a dinâmica das partículas, é peciso implementar, em cena, um Particle System .
Para isso, é possível adicionar um Particle System como um componente em um GameObject
(Inspector > Add component > digitar “ Particle System”) ou colocar um sistema de partículas como um
GameObject pré-fabricado em cena. Para isso, basta acessar o menu do Unity > GameObject > E�ects >
Particle System . Vamos aproveitar o nosso projeto anterior (planetas) e adicionar um sistema de
partículas para gerar um efeito especial na nossa cena. Vamos começar?!
Figura 3.7 - MoonOne
Fonte: Elaborada pelo autor.
Primeiro, adicione um GameObject pré-fabricado do Particle System à nossa cena. Chamaremos o
sistema de “ galaxy ”. Após adicionar, é preciso garantir que a emissão de partículas esteja na mesma
posição do objeto “ EarthOne ”. Os valores do Position para o galaxy são: XYZ (0,0,0). Veja como �cou a
nossa cena (Figura 3.9).
Observe que o Particle System é complexo, pois são diversos componentes divididos em várias
subseções recolhíveis. A versão 2019.2 consta com 22 módulos para o sistema de partículas. Cada
subseção contém propriedades relacionadas à uma área especí�ca, por exemplo, Emission , que é o
módulo responsável por controlar a emissão de partículas. O usuário pode de�nir o número de
partículas emitidas por uma taxa �xa de tempo, a distância máxima para as partículas, o intervalo de
emissão, dentre outros. Para o nosso efeito especial, utilizaremos alguns módulos especí�cos. O
primeiro será o Renderer , módulo responsável pelas propriedades que determinam como a
partícula renderizada é produzida a partir  de uma imagem ou mesh (malha). O usuário pode de�nir
o comportamento geral da partícula. Observe que existe o Min Particle Size (tamanho mínimo de
partícula) e o Max Particle Size (tamanho máximo de partícula). O sistema faz a emissão de partículas
com tamanhos variados. Para o nosso projeto, de�na os valores de 0 para mínimo e 0.1 para
máximo.
Agora, vamos para o módulo shape , que de�ne as dimensões e formas da partícula, como direção,
volume e  superfície. Para cada forma escolhida, as propriedades do módulo variam. Por padrão, a
emissão de partículas utiliza a forma de cone, emitindo partículas da base de um corpo até formar
um cone. Vamos mudar a forma para um circle , ou seja, as partículas movem-se apenas no plano de
um círculo. Ainda no módulo shape , acesse as propriedades Spread e Randomize Position . O spread
controla os intervalos  das partículas com base no arco de emissão. Esse arco é a base que gera as
partículas. Um valor próximo de 0 permite que as partículas sejam geradas em qualquer lugar ao
redor do centro de emissão (arco), e o valor 1 (máximo) permite gerar partículas em apenas uma
direção. Vamos de�nir o valor de 0.5 para o spread . por consequência, as partículas serão geradas
em linha reta (duas direções).  Observe o comportamento das partículas na Figura 3.10.
Figura 3.9 - Particle System
Fonte: Elaborada pelo autor.
Figura 3.10 - Particle system: Spread
Fonte: Elaborada pelo autor.
Após o Spread , temos o Randomize Position , que é responsável pelo movimento aleatório das
partículas. O valor 0 para esta con�guração não tem efeito sobre as partículas, mas qualquer outro
valor de�nirá aleatoriedade às posições de geração das partículas. Para essa propriedade,
de�niremos o valor para 0.1, assim, teremos o mínimo de aleatoriedade na geração dessas
partículas. Como exercício, aumente o valor dessa propriedade para observar o comportamento das
partículas. Um valor próximo a 50 já seria su�ciente para termos um efeito especial em cena.
O próximo módulo será o Particle System Main Module . O primeiro parâmetro a ser alterado é o Start
Lifetime , que de�ne a vida útil das partículas. De�niremos o valor para 10 (segundos), ou seja, a vida
útil de cada partícula será de 10 segundos. O próximo a ser a alterado é o Start Speed , propriedade
responsável pela velocidade inicial de cada partícula (na direção de�nida anteriormente). Por �m,
temos o Start Size e o Max Particles . O Start Size de�ne o tamanho inicial de cada partícula. Vamos
de�nir o valor para 0.2. O Max Particles de�ne o número máximo de partículas no sistema de uma só
vez. Vamos de�nir o valor para 10.000. Agora, acesse o módulo Emission , que foi visto
anteriormente. Vamos alterar o parâmetro Rate Over Time para 200, ou seja, o número de partículas
emitidas por segundo.
O próximo passo é habilitar e acessar o Velocity Over Lifetime Module , que é responsável por
controlar a velocidade das partículas durante a sua vida útil. O primeiro parâmetro a ser alterado é o
Orbital X, Y, Z. O parâmetro de�ne a velocidade orbital das partículas ao redor dos eixos X, Y e Z.
Vamos alterar o valor do eixo Z para 2. Com esse valor, o comportamento das partículas será
próximo a uma rotação orbital. Como a posição do sistema de partículas ( galaxy ) é o mesmo do
nosso GameObject ( EarthOne ), teremos um efeito próximo aos anéis de Saturno (Figura. 3.11), mas
esse não é efeito que queremos.
Ainda, no módulo Velocity Over Lifetime , altere o valor do parâmetro Radial para 3, o qual de�ne a
velocidade radial das partículas, afastando-se da posição central de emissão. Observe, agora, a
Figura 3.12.
Figura 3.12 - Particle System: EarthOne 2
Fonte: Elaborada pelo autor.
Criamos um efeito de galáxia para a nossa cena. Agora, o que podemos melhorar nesta cena? São
diversas as possibilidades, por exemplo, desabilitar o EarthOne , ou criar um novo material para um
objeto que represente o Sol. Nada impede de criarmos um buraco negro, o centro da galáxia, a terra
explodindo, en�m, são diversas as possibilidades. Veja a Figura 3.13 com implementações realizadas
no nosso projeto.
Figura 3.13 - Projeto Galaxy
Fonte: Elaborada pelo autor.
Figura 3.11 - Particle System: EarthOne
Fonte: Elaborada pelo autor.
Todos os efeitos presentes nas cenas da Figura 3.13 foram desenvolvidos utilizando materials,
shaders, textures e Particle System . Agora, utilizando os conceitos estudados ao longo do tópico 1,
tente implementar o sistema solar, que é um conjunto formado por nove planetas (estamos
considerando o  planeta anão, Plutão)   que giram em torno do sol.
praticar
Vamos Praticar
Leia o excerto a seguir.
"O Unity 3D opera baseado em cenas, internamente denominadas Scenes. Dentro das cenas, há os Game
Objects , que são quaisquer objetos inseridos dentro da cena. Câmeras, personagens, terreno, os modelos,
luzes, todos são classi�cados como Game Objects . Os modelos grá�cos são criados utilizando materials ,
textures e shaders . Os materiais são baseados em texturas e shaders . O texture determina o que será
desenhado na superfície do material, enquanto os shaders de�nem como será desenhado" (TORRES, 2015,
p. 32).
TORRES, R. D. Desenvolvendo um jogo para ensinar física com Unity 3D . 2016. Monogra�a (Graduação
em Sistemas de Informação) – Instituto de Ciências Exatas e Aplicadas, Universidade Federal de Ouro Preto,
João Monlevade, 2016.
Com base no texto e nos conhecimentos acerca de materials, textures e shaders , analise as a�rmativas a
seguir.
I. Os materiais de�nem as propriedades da superfície de um objeto, informando como esta deve ser
renderizada.
II. Só é possível anexar um material em um objeto tridimensional.
III. A textura contém informações para mapear e converter um material bidimensional em um modelo
tridimensional.
IV. Um shader é um script contendo diversos cálculos matemáticos para criar a visualização da superfície de
um objeto.
Está correto o que se a�rma em:
a) I e IV, apenas.
b) I e III, apenas.
c) II e III, apenas.
d) III e IV, apenas.
e) IV, apenas.
Path�nding ou, literalmente, a busca de caminhos consiste em uma área amplamente estudada e
implementada em jogos digitais. Praticamente quase todos os jogos utilizam algum sistema de
algoritmos, o qual permite que um agente encontre um determinado caminho no nível do jogo. De
maneira simpli�cada, uma entidade, por exemplo, uma personagem não jogável (NPC), precisa
encontrar um caminho de um ponto A a um ponto B em determinado nível. Para isso, a personagem
precisa contornar obstáculos e calcular a melhor trajetóriapossível. Quando falamos em melhor,
referimo-nos às diversas opções que vão desde o menor caminho até o mais seguro, aquele que
representa um determinado desa�o, a busca por um objeto, en�m, depende do contexto. Durante a
trajetória, a personagem precisa realizar diversos cálculos. Além da busca pelo melhor caminho, a
entidade pode procurar e analisar outras entidades, detectar colisões, analisar o ambiente ou
realizar uma ação especí�ca. Por exemplo, antes de ir ao ponto B, a personagem pode alterar sua
rota e buscar um determinado objeto. Existem diversos algoritmos de busca que podem ser
utilizados na navegação de personagens. Contudo, o algoritmo A* (A-estrela) é, de longe, o mais
utilizado em jogos eletrônicos. Existem inúmeros trabalhos publicados que explicam o
funcionamento do   A*, mas iremos abordar o seu conceito utilizando os fundamentos básicos.
Vamos lá? Primeiramente, precisamos assumir que uma entidade precisa ir do ponto A (azul) ao
ponto B (vermelho) e que existe um obstáculo que separa os dois pontos (Figura 3.14).
O primeiro passo na busca por caminhos ( path�nding ) é de�nir a área de busca. Em nosso exemplo,
a área está dividida por uma grade, facilitando a área de procura a uma matriz bidimensional. Cada
quadrado pode assumir, inicialmente, dois estados (passável ou não-passável, aberto ou fechado).
Isto é, a personagem calcula o melhor caminho entre o ponto A e o ponto B. Para isso, o movimento
é feito entre o centro de um quadrado a outro, até chegar ao objetivo.
Navegação e Navegação e Path�ndingPath�nding
Figura 3.14 - Ponto A ao ponto B
Fonte: Elaborada pelo autor.
O centro de cada quadrado é chamado de nó. Para achar o caminho mais curto, é preciso analisar os
quadrados adjacentes e o custo para movimentar-se até o destino.
Como fazemos isso? Primeiramente, analisamos quais quadrados são passáveis ou não-passáveis.
Em nosso exemplo, quais quadrados adjacentes são passáveis?  Todos, pois a entidade azul pode
movimentar-se para qualquer quadrado adjacente. Observe a Figura 3.15 para visualizar os possíveis
locais de movimento. Lembre-se que a personagem só pode movimentar-se de um centro de um
quadrado para outro. Identi�camos quais são os centros para movimentar a nossa personagem e,
agora, como escolhemos o destino? O centro do quadrado com menor custo de F. A equação básica
do A*  para procurar o melhor caminho é:
Em que:
G: é o custo do movimento para ir do ponto de origem até o quadrado de destino, ou seja,
G + G do nó atual + custo até o nó adjacente;
H: é o custo estimado da distância do quadrado adjacente até o destino. É comum
relacionar o H a uma heurística, pois não sabemos a distância real entre os nós até o
caminho �nal. Por que? Lembre-se que, durante o caminho, podem existir obstáculos e
outros eventos que di�cultam o movimento até o objetivo �nal.
Figura 3.15 - Quadrados adjacentes
Fonte: Elaborada pelo autor.
Para cada movimento realizado entre quadrados, é preciso retirar o nó com o menor F da lista
aberta (passável) e adicionar à lista fechada (não-passável). Para calcular o F, é preciso encontrar o
G. Para o nosso exemplo, vamos atribuir pesos (valores) para cada quadrado adjacente à nossa
F = G+H
personagem (Figura 3.16). O G é um valor baseado na posição atual (valor 0) + o custo de movimento
até o quadrado adjacente. Observe que o valor de movimento, para mover-se a quadrados
diagonais, é 14 e todos os nós ortogonais são 10.
Mas você sabia que esses valores, 10 e 14, não são arbitrários? Em jogos, precisamos calcular o
menor caminho entre dois pontos, por isso, precisamos ter uma noção de distância entre os nós.
Cada movimento entre um nó tem um custo, que depende do contexto, podendo ser qualquer tipo
de medida. Você pode imaginar algum exemplo do mundo real aplicado a jogos? Para um veículo
movimentar-se de um ponto �xo a outro, é necessário calcular o menor caminho, com base no
combustível. Contudo, é possível que a personagem precise chegar a um determinado ponto em um
tempo �xo. Esse é um exemplo do mundo real aplicado a um jogo. Para o nosso exemplo, estamos
utilizando a distância como uma unidade de medida. Cada célula da nossa matriz é quadrada, ou
seja, o custo dos movimentos em diagonal é maior do que os custos dos movimentos ortogonais.
Vamos considerar as nossas células (quadrados) com o valor de 1. Aplicando o Teorema de
Pitágoras, temos que a hipotenusa (diagonal) tem tamanho 1,414213562, que é maior do que as
arestas de tamanho 1. Diante disso, podemos a�rmar que o custo para movimentos em diagonal é
maior do que em movimentos ortogonais.
Figura 3.17 - Teorema de Pitágoras
Fonte: Elaborada pelo autor.
Sabemos que o custo de movimentação ortogonal é mais baixo do que o de movimentação diagonal.
Mas e os valores 10 e 14? Em um algoritmo, quando trabalhamos com cálculos matemáticos
sucessíveis em um loop , é uma boa prática evitar valores de pontos �utuantes. Assim, o
recomendado é trabalhar com números inteiros. Se alterarmos os valores das nossas células para
10, temos que o valor aproximado da nossa diagonal é 14, um número inteiro. Lembre-se que o
custo de movimento ortogonal é 10 e o custo de movimento diagonal é 14. Agora, voltamos para o
Figura 3.16 - Quadrados adjacentes
Fonte: Elaborada pelo autor.
nosso exemplo anterior. Vamos calcular o movimento da nossa entidade. Para calcularmos H,
estimamos a distância até o objetivo �nal utilizando o método de Manhattan, que é a soma das
distâncias entre os nós e suas respectivas posições ou, simplesmente, contamos o número de nós
horizontais e verticais, ignoramos os obstáculos diagonais e multiplicamos o valor encontrado por
10. Se observarmos o nosso exemplo, notaremos que o destino �nal está a 4 quadrados de
distância. Multiplicando por 10, temos que H = 40. Dos 9 quadrados iniciais, temos 8 na lista aberta,
pois o quadrado da personagem foi colocado na lista fechada. E agora, qual o menor caminho?
Vamos observar a Figura 3.18. Para calcular o H, contamos o número de nós até o destino �nal e
multiplicamos por 10. Após isso, calculamos o valor de F. Para isso, basta somar G (custo de
movimento) + H.
Este foi um exemplo simpli�cado do funcionamento do algoritmo A*. Entretanto, estamos ignorando
os obstáculos. Diante disso, não é garantido que o menor caminho seja encontrado em todas as
circunstâncias. O método Manhattan ignora as diagonais.
Mas como funciona o sistema de navegação do Unity ? Quando o usuário deseja mover uma
personagem de forma estratégica no jogo, este precisa levar dois fatores em consideração: como
estabelecer o destino do agente e qual caminho escolher para chegar lá. Para sanar os dois
problemas, é preciso compreender que ambos são conectados, mas de naturezas diferentes. O
primeiro é global e estático, pois o agente precisa analisar toda a cena. Como assim? O
comportamento de uma personagem, geralmente, é baseado em estados. Pode ser um estado
Figura 3.18 - Menor caminho
Fonte: Elaborada pelo autor.
saiba mais
Saiba mais
Os algoritmos de busca são amplamente utilizados em jogos
digitais. É comum usar grades bidimensionais para
representar os níveis. Por exemplo, temos jogos de
estratégia em tempo real (RTS), como Age of Empires , que
usam grades. Cada célula é marcada como aberta ou
fechada. É importante compreender o funcionamento de
algoritmos de busca.
ACESSAR
https://www.researchgate.net/publication/265215573_Algoritmos_de_busca_em_tempo_real_aplicados_a_jogos_digitais
estático, dinâmico ou, dependendo do contexto, ambos. Um agente �xo em um mapa pode ter o
objetivo de apenas informar a personagem principal. Logo, o comportamento da personagem será
estático, pois permanecerá o mesmo na cena.
Contudo, é possível alterar esse comportamento, para que o NPC transite entre certas distâncias.
Além disso, a personagem pode assumir um papel mais ativo no jogo, percorrendo determinado
caminho em busca de um artefato. Independente da situação, a personagem precisade informações
sobre a cena ou de todo o jogo. O segundo problema é local e dinâmico. Digamos que a personagem
precise cumprir determinado objetivo, necessitando calcular o melhor trajeto para alcançar o
destino. Para isso, é preciso que o agente evite colisões com pontos estáticos (casas, portas, arvores,
pedras, etc.) ou dinâmicos (outros agentes) no mapa. O sistema de navegação do Unity representa os
elementos em cena usando a geometria. Os agentes são descritos como cilindros, e as áreas de
movimento são testadas e construídas automaticamente, a partir dos locais onde o agente possa
�car. Após isso, a engine cria uma superfície com as áreas estabelecidas, criando uma conexão entre
estas. A superfície é chamada de NavMesh ou malha de navegação.
reflita
Re�ita
O Algoritmo A* foi descrito, em 1968, pelos
cientistas da computação, Peter Hart, Nils Nilsson, e
Bertram Raphael. Sua aplicação vai desde a busca
por rotas de linhas ferroviárias até a trajetórias de
agentes em videogames . O algoritmo consiste em
buscar o melhor trajeto entre dois pontos. Dentre
os algoritmos de path�nding , o algoritmo A* é um
dos mais utilizados, seja por sua e�ciência ou
mesmo pela facilidade de implementá-lo em
cenários distintos. Levando em consideração os
assuntos abordados ao longo da unidade sobre o
Unity , re�ita como implementar um sistema de
partículas com comportamento baseado no
algoritmo A*.
Observe que é semelhante à movimentação da nossa personagem exempli�cada no algoritmo A*.
Todas as células são conectadas, desde os quadrados que a personagem pode movimentar-se, até
os obstáculos que evitam o movimento. Podemos dizer que as células da Figura 3.15 são conectadas
e formam uma malha.
Para um melhor entendimento do funcionamento do sistema de navegação no Unity , nada melhor
do que implementá-lo em um projeto. Para isso, abra o Unity e crie um 3D object " Plane ". Após isso,
vamos aumentar a escala para torná-lo um pouco maior.  De�na o valor 3 para scale (X, Y e Z) e 0
para position (X, Y e Z). Agora, vamos criar um NavMesh para a nossa superfície. Primeiro, precisamos
habilitar a guia de navegação, contendo propriedades gerais que in�uenciarão o comportamento de
um agente. Vá para o menu > Window > UI > Navigation (Figura 3.19).
Observe que, na janela de navegação, existem quatro guias. Vejamos cada uma destas.
Agents : guia que permite de�nir as propriedades de um tipo especí�co de agente. Por
padrão, o Unity cria o tipo humanoide. Podemos personalizar suas dimensões, bem como
o seu comportamento de movimento;
Áreas : são tags especí�cas para de�nir partes da superfície da nossa cena. É possível
atribuir pesos ou custos para cada tag (area). Isso permite criar um ambiente contendo
partes mais difíceis de atravessar, como a água ou a areia, sendo similar ao sistema de
navegação ortogonal e diagonal no algoritmo A*;
Bake : de�nem-se as con�gurações de mapeamento de navegação do ambiente;
Object : guia importante para o nosso sistema de navegação. Permite con�gurar partes do
ambiente em um sistema de hierarquia, identi�cando áreas do ambiente onde o agente
possa mover-se. Além do mais, de�ne quais são as áreas com obstáculos.
Pronto para criar uma malha de navegação? Então, selecione o nosso plano e acesse o guia object na
janela de navegação. No inspector , habilite a opção navigation static . Estamos dizendo à engine que o
plano não mudará de posição (estático). Na guia bake , deixaremos as propriedades padrões do
Unity . No entanto, é possível de�nir se uma determinada área é mais difícil ou não para um agente
navegar. Contudo, a nossa área de navegação é livre. Clique no botão Bake . Se tudo correu
conforme o passo a passo, será possível notar um quadrado azulado desenhado em nosso plano.
Esse quadrado é um NavMesh (Figura 3.20).
Figura 3.20 - NavMesh
Fonte: Elaborada pelo autor.
Figura 3.19 - Navigation
Fonte: Elaborada pelo autor.
Após criar o NavMesh , precisamos criar o nosso agente. Um agente é um objeto que pode mover-se
pela superfície usando malhas de navegação. Para o nosso exemplo, vamos criar um simples cubo e
transformá-lo em um agente. Então, crie um novo cubo em nossa cena. Após isso, coloque-o no
centro do plano e garanta que o cubo esteja ligeiramente acima do solo (para isso, em position , use
os valores 0, 1, 0 para X, Y e Z ). Vamos renomear o cubo para NPC. Agora, criaremos um material e
anexaremos este ao cubo, o que o diferenciará do nosso plano que, por padrão, tem a mesma cor.
Crie um novo material e renomeie para NPC, anexando ao cubo. Em Albedo , de�na o valor
hexadecimal para 112CF3 (azul-escuro). Se preferir, escolha uma cor diferente. Agora, vamos
adicionar o componente Nav Mesh Agent ao nosso cubo. Para isso, você pode selecionar o cubo,
acessar o Menu > Component > Navigation > Nav Mesh Agent . Ou, no inspector, na barra de pesquisa,
digite Nav Mesh Agent . Pronto, nosso cubo é um agente de navegação. Precisamos apenas de�nir o
comportamento de movimento. Como fazemos isso? É simples, basta chamar o componente Nav
Mesh Agent em um script e dizer para ele fazer alguma coisa. Vamos criar um novo script e chamá-lo
de NPCMovement . Uma vez criado o script , abra o editor de código e escreva o código a seguir.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
public class NPCMovement : MonoBehaviour
{
[SerializeField]
Transform _destination;
NavMeshAgent _navMeshagent;
public void Start()
{
_navMeshagent = this.GetComponent <NavMeshAgent>();
if (_navMeshagent == null )
{
Debug. LogError ("O componente Nav Mesh Agent não foi encontrado em " +
gameObject. name );
}
else
{
SetDestination();
}
}
private void SetDestination()
{
if (_destination != null)
{
Vector3 targetVector = _destination.transform.position;
_navMeshagent.SetDestination(targetVector);
}
}
}
Agora, vamos analisar o código. Primeiro, estamos declarando uma variável transform para o destino
do nosso agente. SerializeField permite editar o valor da nossa variável privada no inspector. O
método Start está pegando, como referência, o componente Nav Mesh Agent em nosso agente. Além
disso, estamos executando uma veri�cação para garantir que o componente encontrado não seja
nulo. Caso o agente seja encontrado com êxito, de�nimos o destino. O destino é baseado na posição
do transform do alvo que estamos buscando. Após de�nido o objetivo, o agente vai até o destino.
Pronto, compile o código e volte para o Unity .
Agora, adicione o script NPCMovement ao nosso agente. O próximo passo é de�nir o seu destino.
Para isso, precisamos criar um novo 3D Object . Em nosso exemplo, utilizaremos um novo cubo,
de�niremos um local no plano para este, criaremos um material e escolheremos uma cor. Na cena
do exemplo, o novo cubo foi renomeado para NPC2, o valor hexadecimal do material do NPC2 foi de
FF2700, a escola em X = 1, Y = 1 e Z = 1 e, por �m, os parâmetros da posição foram X = -10, Y = 1 e  Z=
0. Por �m, clique no NPC e arraste o objeto NPC2 para a variável Destination (Figura 3.21).
Figura 3.21 - Destination
Fonte: Elaborada pelo autor.
Pronto, agora, clique em play . O nosso agente move-se até sobrepor o NPC2. Interessante, não é?
Mas você pode pensar que o movimento linear é fácil. Realmente, precisamos de obstáculos. Não
apenas isso, precisamos de�nir o movimento da personagem para percorrer os obstáculos. Vamos
lá? Então, vamos criar um novo cubo e renomear para obstacle . O objetivo é criar um obstáculo
entre o nosso NPC e o seu destino. Você pode criar um material e anexar ao nosso GameObject
obstacle . A escala para esse novo objeto foi de 5, 5 e 10 (X, Y e Z). Observe como �cou a nossa cena
(Figura 3.22).
Figura 3.22 - Obstacle
Fonte: Elaborada pelo autor.
Agora, se dermos play , o que acontece? A personagem vai mover-se até o destino, passando pelo
nosso obstáculo. Precisamos adicionar um RigidBody ao nosso NPC. Adicione o RigidBody ao NPC e
dê playnovamente. Observe que o cubo colidirá com o obstáculo. Mas o sistema de navegação do
Unity não está reconhecendo o nosso obstáculo como parte de nossa malha. Para contornar essa
situação, precisamos que o NavMesh reconheça o objeto (obstáculo). Selecione o objeto obstáculo e
vá ao painel de navegação, na interface, e acesse a guia Object . Habilite o nosso obstáculo como
estático e not walkable (não pode ser percorrido). Agora, precisamos refazer a nossa malha. Ainda na
interface da janela de navegação, na guia Bake , clique no botão Bake . Pronto, você já pode observar
que a malha de navegação foi quebrada ao redor do nosso obstáculo (Figura 3.23).
Pressione play e observe que o nosso agente está andando ao redor do cubo até chegar ao local de
destino. Podemos personalizar o tamanho da quebra de malha ao redor do nosso obstáculo. Assim,
o agente pode mover-se ao redor deste sem estar muito próximo do obstáculo. Para isso, o Unity
utiliza um componente chamado Nav Mesh Obstacle . Adicione o componente ao nosso obstáculo
(Menu > Component > Navigation > Nav Mesh Obstacle ). Pronto, agora, basta selecionar o obstáculo,
acessar a interface, em NavMeshObstacle , e habilitar " carve ". Assim, o sistema de navegação usa os
limites do obstáculo de�nidos pelo usuário. Você pode alterar os valores de “ size ” para mudar o
tamanho do obstáculo. Para o nosso exemplo, vamos utilizar os valores 2, 1 e 2 (X, Y e Z). Pressione o
play e observe como �cou a nossa cena (Figura 3.24).
Figura 3.23 - Obstacle
Fonte: Elaborada pelo autor.
Figura 3.24 - Nav Mesh Obstacle
Fonte: Elaborada pelo autor.
Agora, brinque com essa cena, crie novos obstáculos e de�na valores diferentes para o seu
tamanho. Não esqueça de refazer a malha toda vez que adicionar um novo objeto à nossa cena.
Como exercício, busque materiais e texturas na loja de ativos e personalize a cena.
Unity permite adicionar, editar e manipular paisagens em um jogo. Para isso, precisamos adicionar
um 3D Object Terrain à nossa cena. Com o Unity aberto, acesse o menu > 3D Object > Terrain . Como
sugestão, você pode utilizar a cena de navegação para criar um terreno ao nosso agente. Selecione
terrain , na janela de hierarquia, e, em inspector , observe que a janela de terrenos fornece diversas
ferramentas e recursos para criar paisagens.
A barra de ferramentas fornece cinco opções para manipular o terreno. A primeira delas é o Create
Neighbor Terrains , uma ferramenta para criar terrenos adjacentes que se conectam
automaticamente. Acesse o inspector e clique no ícone de criar terrenos vizinhos. Quando o usuário
seleciona a ferramenta, automaticamente, a engine destaca as áreas subjacentes do bloco de
terreno selecionado. Clicando sobre um novo quadrado, o mapa é preenchido com um novo terreno
(Figura 3.25).
Outra ferramenta amplamente utilizada é o Raise or Lower Terrain , que permite alterar o relevo do
terreno. Em terrain , na barra de ferramentas, selecione o pincel  ( Raise or Lower Terrain ). Agora, na
janela scene , clique no terreno para aumentar o seu relevo e, para diminuir, mantenha pressionada
a tecla Shift . É possível alterar o tamanho do pincel para criar terrenos variados. Para isso, acesse a
barra de ferramentas e altere o controle deslizante em Brush Size . Veja a alteração no relevo na
Figura 3.26.
TerrenosTerrenos
Figura 3.25 - Terrain
Fonte: Elaborada pelo autor.
Se você observar, não existe textura em nosso relevo. Para isso, vamos adicionar terrain layers , mas,
antes, importaremos, da loja de ativos do Unity , o pacote Yughues Free Ground Materials , produzido
por Nobiax / Yughues. Agora, em terrain , acesse a interface > Terrain Layers > Edit Terrain Layers >
Create Layers . Neste momento, precisamos de�nir a textura para o nosso terreno. Escolha “ Grass ”.
Após isso, você poderá selecionar a textura escolhida e desenhar o mapa diretamente  no terreno. É
possível adicionar várias texturas, criando ambiente únicos. Veja a Figura 3.27 para observar os
detalhes do terreno utilizando a textura Grass e Rock . Além disso, na barra de ferramentas, é
possível de�nir o tamanho, a opacidade e a forma do pincel.
Figura 3.27 - Terrain Editor Paint
Fonte: Elaborada pelo autor.
O Unity possui diversos recursos extras para trabalhar com a construção de elementos em
ambientes. Por exemplo, temos o SpeedTree , um ativo da IDV inc recomendado pelo Unity para a
criação de árvores. O ativo possui diversos modelos pré-fabricados de árvores, além da possibilidade
de criar novos modelos. Outro ativo recomendado pelo Unity é o Polybrush , que permite misturar
texturas para criar novos efeitos para o terreno. A ferramenta oferece um editor de design de
terrenos para esculpir formas complexas diretamente do editor. Além disso, o Polybrush conta com
modelos pré-fabricados de pedras, gramas, detritos, árvores e outros detalhes que podem ser
adicionados em cena. Agora, com a ferramenta terrain aberta, crie um pequeno terreno para a nossa
cena de navegação.
Figura 3.26 - Terrain Editor
Fonte: Elaborada pelo autor.
Antes de falarmos de níveis, precisamos entender o conceito de progressão. Para isso, vamos
analisar o jogo Angry Birds , que é eletrônico de puzzles, ou quebra-cabeças, desenvolvido pela Rovio
Entertainment . A primeira versão do jogo foi lançada em 11 de dezembro de 2009, com uma
estimativa de 732 níveis. Sua continuação tinha, aproximadamente, 2180 níveis. Veja que, em jogos
eletrônicos, é comum propor uma di�culdade crescente, mas como construir níveis progressivos? O
que é progressão? Para responder a essas questões, vamos estudar o básico sobre design de níveis.
Digamos que a cena inicial do nosso jogo seja a mesma da navegação do nosso agente, bem como
que controlamos o cubo 2 (NPC2). O nosso objetivo é buscar uma chave para abrir uma porta e
desbloquear o nível seguinte. Se, durante os próximos 10 ou 15 níveis, os puzzles e elementos do
cenário seguirem inalterados, com as mesmas condições para atravessá-los, então, provavelmente,
esse jogo se tornará monótono. Portanto, cada nível precisa ser trabalhado separadamente, com o
objetivo de criar experiências únicas. Em seguida, é preciso de�nir a progressão, para não criar
repetição. O(a) jogador(a) precisa de um objetivo a longo prazo, por exemplo, em Angry Birds , os
pássaros precisam salvar os ovos roubados pelos porcos verdes. A cada nível, novos elementos são
adicionados e a di�culdade é aumentada.
Outro exemplo seria um jogo que, no primeiro nível, a personagem precisa eliminar três inimigos
com apenas dois acertos, assim como no segundo, terceiro e quarto níveis. No quinto nível, o(a)
jogador(a) é experiente, consegue eliminar monstros com apenas um golpe. Inicialmente, o sistema
pode parecer e�ciente, o(a) jogador(a) evoluiu, mas, na prática, se o jogo não acrescentar elementos
diferentes ao nível, trará apenas repetição. Por consequência, é provável que o(a) jogador(a) não
tenha nenhum prazer com o jogo.
Trabalhar com a complexidade em jogos é um ponto essencial para construir níveis progressivos,
considerando que esta é diretamente ligada à jogabilidade. Se alterarmos, rapidamente, os
primeiros níveis do nosso exemplo anterior, poderíamos implementar um número crescente de
inimigos, personagens com habilidades distintas, exigências de itens, puzzles , inimigos inteligentes,
aleatoriedade, etc. Quando criamos níveis, precisamos de�nir a progressão ou criaremos fases ou
níveis sem nenhum objetivo. Além disso, é preciso levar em consideração o balanceamento e a curva
de aprendizado em um jogo, pois cada nível precisa ser equilibrado, para que o(a) jogador(a) sinta-se
motivado a progredir.
NíveisNíveis
Para criar progressão, é preciso desenvolver presença e imersão em um jogo. Como assim? O(a)
jogador(a) precisa querer progredir, sentir-se motivado e desa�ado constantemente. E como
criamos níveis com desa�os constantes? Para isso, vamos utilizar o estado de Flow , ou �uxo,
proposto pelo psicólogoMihaly Csikszentmihalyi. O conceito de Flow é similar a uma máquina de
estados que, de maneira sucinta, é um modelo matemático usado em softwares ou lógica digital. Os
estados são representados usando um diagrama de estado e cada estado desempenha um papel
distinto em um sistema, em que cada indivíduo passa por estados emocionais ao longo de sua rotina
diária.
O Flow é um estado mental proporcionado por alguma tarefa ou atividade que o indivíduo realiza e
tende a eliminar distrações ao seu redor. Na prática, a atividade realizada gera um grande prazer.
Entrar em um estado de �uxo signi�ca estar completamente envolvido em atividades que trazem
prazer, ignorando o tempo e, até mesmo, suprimindo as necessidades �siológicas. O desenvolvedor
precisa guiar o(a) jogador(a) ao estado de �uxo, por isso, a progressão de níveis é fundamental. A
linha de aprendizado precisa seguir essa progressão. Se a mecânica do jogo é difícil de entender
intuitivamente, é preciso adicionar um tutorial ou treinamento ao longo dos primeiros níveis do jogo.
Angry Birds utiliza tutoriais durante todo o jogo, sempre que uma nova habilidade é demonstrada
para o(a) jogador(a). Em alguns jogos, é comum obrigar o(a) jogador(a) a realizar um treinamento,
explicando os principais recursos para o usuário e introduzindo, brevemente, o universo do jogo.
saiba mais
Saiba mais
A geração automática de conteúdo baseia-se no uso de
algoritmos para criar, dinamicamente, elementos dentro do
jogo, desde os elementos audiovisuais até a arquitetura de
níveis. Esta abordagem é amplamente utilizada há mais de
30 anos, na área de jogos eletrônicos, sendo um recurso
importante para criar níveis diversi�cados.
ACESSAR
http://artefactum.rafrom.com.br/index.php/artefactum/article/view/1772?v=1675036738
O design de níveis é amplamente estudado e discutido na indústria de jogos, mas, como qualquer
conceito, é necessário ser implementado e validado de maneira prática em um jogo. Por isso, iremos
implementar uma transição entre níveis, utilizando a nossa cena de navegação do agente. Para isso,
vamos utilizar o método SceneManager.LoadScene , que permite mudar de Scene , passando o seu
nome ou index no Build do jogo. Mas, antes, com o Unity aberto na janela de projetos, crie uma pasta
chamada Scene . Selecione a nossa Scene atual, renomeie para Level 1 e arraste para a pasta scene .
Agora, crie uma nova Scene e renomeie como Level 2 . Após isso, acesse o menu do Unity > Build
Settings e arraste as Scenes Level 1 e 2 para Scenes in Build (Figura 3.28).
Por padrão, o Unity só compila as cenas que você adicionou ao seu projeto no editor. Após criar as
duas cenas, crie um novo script , chamado Transition . Anexe o script no nosso NPC2.  Abra o editor
de códigos e escreva o código a seguir.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
saiba mais
Saiba mais
A jornada do herói ou monomito é um conceito cíclico
amplamente utilizado em jogos eletrônicos. Esse conceito
foi cunhado pelo antropólogo Joseph Campbell.
Compreender o termo proposto por Campbell é
fundamental para construir níveis progressivos, utilizando-
se de uma narrativa memorável.
ASS IST IR
Figura 3.28 - Scenes in Build
Fonte: Elaborada pelo autor.
public class Transition : MonoBehaviour
{
void OnTriggerEnter(Collider TransitionLevel)
{
if (TransitionLevel.gameObject.tag == "Player")
{
SceneManager.LoadScene(2);
}
}
}
Para usar as funções de transição, precisamos chamar o using UnityEngine.SceneManagement no
início do script . O void OnTriggerEnter é chamado quando um objeto colide com outro. Se o objeto
possuir a tag “ Player ”, é chamada a função SceneManager.LoadScene (2). Isto é, estamos chamando a
nossa scene Leve2 . O index ou número segue a hierarquia de cenas na Scenes in Build . Poderíamos
substituir o SceneManager.LoadScene (2) por SceneManager.LoadScene (" Level2 "). Agora, salve o
código e retorne ao Unity . Dê play e veja o que acontece. Você vai perceber que nada acontece, pois
a personagem apenas percorre a trajetória até o NPC2, mas não muda de cena. Você sabe o porquê
disso? Lembra-se de que utilizamos um método Trigger ? Precisamos habilitar o isTrigger no Box
collider do NPC2. Além disso, garantimos que a transição só ocorra caso o objeto tenha a tag “ Player
”. Basta selecionar o NPC > Inspector > Tag > Player . Execute o jogo novamente. A personagem
percorre a trajetória e, após a colisão com o NPC2, é chamada uma nova scene ( Level2 ).
indicações
Material
Complementar
LIVRO
Introdução ao Desenvolvimento de Games - Volume 3:
Criação e Produção Audiovisual
Editora : Cengage Learning
Autor : Steve Rabin
Ano : 2012
ISBN -10: 8522111456
ISBN -13: 978-8522111459
Comentário : um livro-texto aplicado à área de desenvolvimento de
jogos, que tem, como objetivo, utilizar abordagens práticas para explicar
conceitos de modelagem tridimensional, linguagem audiovisual, efeitos
especiais, sistemas de partículas, design de níveis, dentre outros. A obra
traz informações valiosas sobre elementos fundamentais da estrutura
de um jogo, focando em aspectos práticos do processo de criação.
conclusão
Conclusão
Criar um jogo não é uma tarefa trivial, mesmo utilizando uma game engine para auxiliar no processo
de produção. É preciso, independente da área, conhecer as ferramentas de desenvolvimento. Jogos
são sistemas complexos, formados por conjuntos de outros sistemas complexos. Cada elemento em
um jogo pode, inicialmente, parecer simples, mas, quando agregado a outros elementos, forma o
que chamamos de jogo. São todos os elementos interagindo, formando um grande sistema.
Portanto, um jogo é uma tarefa técnica que exige que o usuário familiarize-se com os recursos do
mecanismo escolhido. O Unity contém inúmeros recursos e, para dominá-los, é preciso de prática.
Por isso, o segredo para criar jogos fantásticos é apenas fazer jogos. Não se esqueça de praticar
sempre. Implemente jogos simples, faça novos níveis para jogos conhecidos, mude as regras, en�m,
use a criatividade para criar experiências fantásticas.
referências
Referências
Bibliográ�cas
POZZEBON, E.; SANTOS, J. P. dos.; JUSTINA, R. F. D. Geração Automática de Conteúdo: Uma Revisão
Sistemática da Literatura Computacional. Artefactum - Revista de Estudos em Linguagem e
Tecnologia , n. 1, 2019. Disponível em:
http://artefactum.rafrom.com.br/index.php/artefactum/article/view/1772?v=1675036738 . Acesso
em: 27 dez. 2019.
TRINDADE, E.; FERREIRA, R. P. M.; FANTINI, E. P. C.; PAULA, H. B. de. Algoritmos de busca em tempo
real aplicados a jogos digitais. VII SBGames , Belo Horizonte, nov., 2008. Disponível em:
https://www.researchgate.net/publication/265215573_Algoritmos_de_busca_em_tempo_real_aplicados_a_jogos_d
. Acesso em: 22 dez. 2019.
TORRES, R. D. Desenvolvendo um jogo para ensinar física com Unity 3D . 2016. Monogra�a
(Graduação em Sistemas de Informação) – Instituto de Ciências Exatas e Aplicadas, Universidade
Federal de Ouro Preto, João Monlevade, 2016.
UNITY User Manual. Unity 3D . Disponível em:
https://docs.unity3d.com/2020.1/Documentation/Manual/ . Acesso em: 06 jan. 2020.
http://artefactum.rafrom.com.br/index.php/artefactum/article/view/1772?v=1675036738
https://www.researchgate.net/publication/265215573_Algoritmos_de_busca_em_tempo_real_aplicados_a_jogos_digitais
https://docs.unity3d.com/2020.1/Documentation/Manual/