Desenvolvimento de Jogos Digitais - Parte 1

Prévia do material em texto

Desenvolvimento de Jogos Digitais
Aula 1: Desenvolvimento de Jogos Digitais I
Módulo 1: Conhecer o histórico dos jogos digitais ao longo do tempo
Definição
Os jogos digitais estão presentes no cotidiano de muitas pessoas. Veremos o histórico dos ambientes desses jogos desde o seu surgimento, na década de 1970, até os dias atuais. Conheceremos também ferramentas específicas para a criação dos jogos e como aplicá-las no desenvolvimento de um projeto de jogo.
História dos Jogos 2D
Década de 1970
O primeiro exemplo de jogo digital comercial de sucesso na história foi o Pong, criado por Nolan Bushnell e Ted Dabney, disponibilizado em bares na forma de um console ligado a um monitor e com um sistema iniciado a partir da introdução de moedas.
Era uma ideia inovadora e que mostrou aos autores a possibilidade de obter lucro com o produto, o que levou à fundação da Atari em 1972.
Esse modelo de máquina com o uso condicionado à introdução de moedas, normalmente chamada de fliperama ou arcade, ficou muito popular, ao ponto de serem criados locais onde os jogadores se reuniam para competir entre diversos exemplares de jogos digitais.
O jogo Pong em si é muito simples, simulando um jogo de pingue-pongue, e necessita de dois jogadores, onde cada um controla uma raquete, representada por uma barra, através de controle na forma original de dial. Cada jogador deve acertar a bola, um quadrado, enviando para o outro lado.
· Na verdade, o primeiro console de videogame da história foi o Odyssey, da Magnavox, lançado em 1972, mas que já trazia protótipos datados de 1968, o que levou a uma batalha judicial com a Atari por violação de patente, já que o jogo Pong era muito parecido com o jogo de tênis do Odyssey.
· A empresa Atari entrou em concorrência direta com a Odyssey ao lançar o Atari Video Computer Systems (Atari VCS), em 1977.
· O console que seria mais tarde chamado de Atari 2600, foi o primeiro grande sucesso comercial nesta área, e chegou a vender 8 milhões de unidades até 1983, sendo um dos grandes responsáveis pela popularização dos jogos digitais.
Com a possibilidade de utilizar um console para executar diferentes jogos no formato de cartuchos, o mercado começa a se aquecer e surgem diversos exemplares de jogos para o Atari.
Esses jogos apresentavam baixíssima resolução, normalmente com a representação de personagens através de caracteres especiais, contando sempre com a imaginação do jogador, e o que realmente contava era a jogabilidade, ou seja, o nível de satisfação proporcionado pela execução desses jogos.
A tecnologia adotada pelos consoles iniciais permitia apenas o modo 2D, com visão aérea ou frontal, sem rolagem de tela, e eram muito focados em esportes, combates e tabuleiro, podendo ser citados, como exemplo, alguns dos jogos lançados junto ao Atari 2600, como Air Sea Battle, Blackjack, Combat, Video Olympics e Street Racer.
Em 1978 foi lançado o jogo Frogs and Flies, pela SEGA-Gremlin, no modelo arcade, sendo portado posteriormente para o Atari 2600.
A importância histórica deste jogo, para o ambiente 2D, se refere ao uso de superfícies sobre as quais os personagens se apoiam, funcionando como predecessor de toda uma nova família de jogos digitais, os jogos de plataforma.
Uma característica comum aos primeiros jogos de plataforma era a visão frontal em tela única, ainda sem rolagem de tela, mas eles já traziam alguns dos elementos que ainda hoje são utilizados para este tipo de jogo, como o uso de plataformas para deslocamento e o salto sobre obstáculos.
Década de 1980
Podemos considerar o jogo Donkey Kong, de 1981, criado pela Nintendo, como o primeiro grande exemplo de jogo digital com as características de saltos e obstáculos necessários aos jogos de plataforma.
O herói deste jogo é o personagem Jumpman, que deve saltar sobre os obstáculos, o qual obtém muito sucesso e acaba obtendo um jogo próprio, chamado Mario Bros, onde passa a ser conhecido como Mario.
Os jogos com transição de tela surgem em 1982, por meio de exemplos como Pitfall, onde a tela é trocada pela sucessora ou antecessora, na sequência definida para o mundo completo, sempre que as extremidades da tela, direita ou esquerda, são atingidas pelo personagem do jogador. Essa troca de tela ainda não definia uma rolagem suave, técnica que surgiria logo em seguida.
A rolagem de tela foi bastante popularizada pelo jogo arcade Moon Patrol, lançado pela Irem em 1983 e portado para o Atari 2600 na mesma época.
Apesar da baixa resolução, este jogo trouxe a característica de um cenário longo, horizontalmente, que se desloca no sentido contrário ao movimento do jogador, ou seja, a própria definição de rolagem de tela. Também proporcionou a noção de profundidade, com a criação de camadas sobrepostas que se movem em diferentes velocidades, efeito conhecido como paralaxe.
Outros estilos de jogo se beneficiaram da rolagem de tela, como jogos de corrida e combate com visão superior, a exemplo do River Raid, lançado pela Activision em 1982, e o jogo 1942, ambientado na Guerra do Pacífico, lançado pela Capcom em modelo arcade no ano de 1984. Para jogos que se enquadram nestes perfis é mais comum a adoção da rolagem vertical.
Um jogo icônico da história dos jogos, que inicialmente utilizava uma tela fixa e em versões posteriores adotou a rolagem de tela foi o PacMan, o que permitiu a criação de labirintos maiores e melhor definidos para o jogo.
Década de 1990
Vários jogos de plataforma que se sucederam seguiram esse estilo de rolagem da tela, tendo como exemplo o popular Sonic, mascote da SEGA, que surgiu em 1991 para consoles como o Mega Drive, com resolução muito superior ao Atari, deixando a movimentação do cenário mais fluida e os personagens e itens mais realistas.
A década de 1990 foi marcada por consoles como Super NES e Mega Drive, mas os computadores também evoluíram e, em 1993, graças ao jogo Doom, os PCs finalmente superam os consoles em termos tecnológicos e de aceitação por parte do público. Esse jogo é uma evolução do Wolfenstein 3D, com qualidade gráfica muito maior, mas ainda seguindo a ideia de jogo de tiro em primeira pessoa.
Esse foi um momento da história dos jogos em que temos uma busca muito grande por uma maior sensação de realismo, e as tecnologias 3D começaram a evoluir em grande velocidade, fazendo com que os jogos de plataforma perdessem um pouco de sua popularidade.
Ocorreu um movimento no sentido de recriar diversos jogos de plataforma no modelo 3D, como o Sonic Adventure, de 1998, mas a jogabilidade desse modelo era bastante diferente do modelo 2D, não obtendo o mesmo sucesso anterior.
Ficou claro que o ideal não seria um ambiente com movimentação 3D, mas apenas com a ilusão de profundidade gerada pelo sombreado dos modelos 3D, o que levou à adoção de do estilo conhecido como 2.5D, em que temos elementos 3D vistos de forma frontal, com a movimentação efetuada apenas nos eixos do plano de visualização.
Os consoles portáteis ganharam muita relevância com o lançamento do Game Boy Color, em 1998, trazendo a série Pokémon. A ideia de poder jogar em qualquer lugar agradou ao público, de forma geral, e diversas outras iniciativas ocorreram, como o surgimento posterior do PSP, mas este modelo de dispositivo nunca apresentou o mesmo poder gráfico dos consoles.
Os jogos para os portáteis acabavam seguindo o modelo 2D tradicional e variantes, como as ilusões de profundidade simplificadas do 2.5D e da visão isométrica, e esta foi uma tendência que perpetuou mesmo com a evolução destes portáteis.
Século XXI
No século XXI passamos a observar o uso intensivo de SmartPhones e Tablets, passando a constituir um mercado de jogos muito expressivo, com características próximas àquelas apresentadas pelos portáteis, porém com maior poder de influência sobre jogadores não aficionados, e, com a evolução dos sistemas operacionais e hardware desses dispositivos, eles se tornaram uma poderosa plataforma de jogos que executam desde versões dos jogos Atari até Jogos 3D de alta qualidade.
Neste novo ambiente os jogos 2D, particularmenteos de plataforma e runners, em que o personagem corre desviando de obstáculos, obtiveram grande sucesso. Além de jogos já tradicionais que foram portados, como o Sonic, surgem diversos jogos como Angry Birds, que aliam todo o carisma dos jogos 2D aos modernos recursos para cálculo de física das ferramentas atuais.
Nos jogos digitais vemos que a interatividade e a imersividade são fatores determinantes.
Os jogos da atualidade são mais detalhistas, trazendo uma ilusão cada vez mais próxima da realidade física de nosso cotidiano. Contudo, a qualidade gráfica não determina, por si só, uma boa experiência para o jogador.
Esta experiência deve levar em conta outros elementos, como:
1. Qualidade da entrada de comandos por meio dos controles.
2. Nível de desafio.
3. Utilização de sonorização apropriada.
O termo jogabilidade é muito utilizado para denotar a avaliação da qualidade desta experiência proporcionada pelo jogo.
Vamos conhecer algumas dessas tipologias de classificação de jogos digitais:
GRAELLS (2000)
Estabelece uma tipologia para jogos digitais levando em conta a estrutura dos jogos e as principais competências mobilizadas pelo jogador no desenrolar do jogo, ou seja, a psicomotricidade, o raciocínio, a lógica, a estratégia e a memória.
BECTA (2003)
Delineou uma classificação para englobar os vários gêneros de jogos digitais existentes, de acordo com os estilos, narrativas, temáticas e atividades.
Expansão do mercado de jogos para dispositivos móveis
Com a expansão do mercado de jogos para dispositivos móveis, onde jogos casuais se tornam mais rotineiros que aqueles com enredos complexos, os jogos de plataforma se tornaram um grande sucesso, mesmo em uma época onde os consoles buscam realismo cada vez maior e histórias longas e intrincadas.
O uso de jogos de plataforma em um Smartphone permitirá que o jogador pare e continue a partida quando e onde quiser, e isso se torna um grande atrativo, principalmente em instantes ociosos, muito comuns ao utilizar algum meio de transporte público.
Ainda pensando neste mercado, as próprias dimensões do aparelho e recursos de processamento levam à concepção de jogos que se preocupam mais com a jogabilidade do que com o realismo, dando preferência à adoção de gráficos 2D, mesmo que com sombreado, imitando 3D, o que torna a concepção dos projetos mais simples e menos onerosa.
O projeto de um jogo do tipo plataforma deve considerar um cenário onde determinadas áreas são acessíveis a partir de movimentos específicos, como saltos, o acesso às mesmas proporcionará, por meio de determinado ordenamento, o desenrolar do enredo do jogo.
Os jogos do estilo infinite runner podem ser considerados uma interessante variação dos jogos de plataforma, muito aplicável aos dispositivos móveis por definirem ambientes muito casuais, sendo que a movimentação é mais simples para estes casos.
· Basicamente quem se move é o cenário, enquanto o personagem do jogador fica em uma posição horizontal fixa, variando a vertical através de saltos, sob comando de toque de tela ou clique, por exemplo.
· Esses jogos podem envolver a possibilidade de saltos maiores ou menores, ou ainda o agachamento, para o desvio de obstáculos e captura de itens, os quais se aproximam do jogador juntamente com o movimento do cenário.
Embora nas versões tradicionais de jogos runner o personagem do jogador deva se apoiar na superfície, ou plataforma, sobre a qual corre, podemos aproveitar a dinâmica da movimentação do cenário para jogos distintos, como nave em movimentação horizontal (Flappy Bird), com exemplos em que o personagem do jogador deve se manter no ar e perde o jogo se tocar na plataforma.
Alguns jogos são criados utilizando apenas elementos 2D, mesmo que com efeitos de sombra, simulando efeitos 3D, o que tem sido muito comum nos jogos de plataforma.
Um formato muito utilizado para as imagens 2D da atualidade é o PNG, pois apresenta características de transparência, facilitando a sobreposição de camadas.
As imagens 2D podem ser estáticas, normalmente associadas ao cenário e itens do jogo, ou dinâmicas, por meio de animação quadro a quadro, definindo personagens e seus movimentos.
Um cenário que satisfaça a um enredo mais complexo, no entanto, pode envolver uma grande área, e, para menor consumo de memória, é comum a repetição de elementos de imagem, combinados de forma adequada, para composição desse cenário.
Como o acesso ao meio persistente é muito dispendioso em temos de tempo, uma técnica para a redução do delay é a junção dos diversos elementos em uma única grande imagem, reduzindo o número de acessos ao disco.
Essa é a base da técnica conhecida como Tilemap, que divide a imagem fonte em células menores, e aplica estas células em posições específicas do cenário a partir de seus índices. Com isso, temos também menor gasto de memória, pois cada célula é carregada apenas uma vez, sendo reutilizada ao longo de todas as suas ocorrências na área de jogo.
Para a aplicação das células na área definida para o cenário, precisamos dividi-la em quadros com dimensões equivalentes, compondo um grid posicional indexado vertical e horizontalmente.
Ainda podemos trabalhar com dois grids, sendo o Visual Grid, para a definição da imagem completa do cenário, e o Logic Grid, definindo a colisão ao longo do cenário por meio do bloqueio de quadros específicos.
Devido ao uso de rolagem de tela, apenas os componentes da área visível do cenário serão carregados a cada quadro, ao invés de ocupar a memória com uma grande imagem de fundo.
Isso acaba permitindo cenários muito maiores, pois é mantida quase constante carga de memória com imagens, mesmo que o cenário seja dezenas de vezes maior do que a área de visualização.
Outra técnica muito interessante na área de jogos 2D é a simulação de um ambiente 3D por meio de Tilemap Isométrico. Esse tipo de abordagem é muito comum em jogos de RPG e simulação, como no caso do SimCity 2000.
Ainda em termos de cenário, é possível simular a profundidade a partir da visão frontal por meio de paralaxe, um efeito muito interessante, que é obtido dividindo o fundo em camadas sobrepostas agrupando elementos mais próximos ou mais distantes, e quanto mais distante menor a velocidade com a qual a camada se desloca.
As técnicas utilizadas para a criação de imagens 2D podem envolver o simples uso de pixels, de acordo com a técnica denominada pixel art, que deve levar em consideração a resolução do dispositivo para exibição, devido a possíveis distorções, ou trabalhar com elementos vetoriais, os quais mantêm o aspecto visual para as diversas resoluções.
Quando vemos o efeito de distorção, causado pelo redimensionamento de uma imagem baseada em pixels além da sua resolução original, dizemos que a imagem está “pixelada”.
Em termos dinâmicos, as animações 2D podem ser geradas com a utilização de programas como Spriter Pro, Pencil 2D ou Adobe Animation CC, este último com grandes recursos para modelagem vetorial e diversas opções de exportação de arquivos.
Essas ferramentas definem linhas de tempo em que são adicionadas chaves de animação, podendo utilizar até mesmo relações hierárquicas com o uso de bones (ossos), como no caso do Spriter.
Devemos lembrar que alguns jogos, mesmo utilizando apenas elementos 2D, objetivam simular a visão 3D frontal, por meio de efeitos de sombra, técnica que tem sido muito comum em diversos jogos de plataforma.
Uma forma simples de obter este efeito é modelar no 3DS Max, ou outro editor 3D, em que será definida tanto a malha quanto a animação, e utilizar a opção de renderização para arquivo sequencial, ao invés de vídeo, pois, com as imagens geradas, basta copiar o conjunto para um mesmo arquivo, através de um editor de imagens em 2D, e definir a transparência, salvando em seguida como PNG, o que faz surgir, neste processo, um Sprite Sheet.
Módulo 2: Usar o ambiente da Unity 3D para criação de jogos.
Motor de jogo
Game Engine, ou Motor de Jogo, é um programa utilizado para simplificar e abstrair o desenvolvimento de jogos eletrônicos ou outrasaplicações que exijam a criação de gráficos em tempo real.
· Existem várias Game Engines no mercado, e elas podem ser diferenciadas em termos de custo, qualidade gráfica e sonora, praticidade de uso, linguagem de programação utilizada, plataformas abrangidas, entre outros aspectos gerais.
· Nas Game Engines, o processo de personalização da aplicação normalmente é efetuado através de uma ou mais linguagens de programação que sejam suportadas, como o C# na Unity 3D e o C++ na Unreal Engine.
Entre os componentes de uma Game Engines, podemos destacar:
· Motor gráfico para renderizar gráficos 2D e 3D.
· Motor de física para simular forças ou detectar colisão.
· Suporte para animação​, sons, inteligência artificial e redes.
· Controle de diversos dispositivos de entrada
· Gerência de memória, arquivos e linha de execução.
· Controles em geral para cenas e entidades.
Devem estar presentes, também, alguns utilitários, como:
· Editores visuais para os elementos do jogo.
· Gerenciadores de materiais e texturas.
· Construtor de árvores, normalmente por utilização de fractais.
· Construtor de terrenos.
· Sistemas de partículas e efeitos diversos.
· Elementos para a construção de menus e HUD.
· Suporte ao uso de veículos.
Características gerais da Unity 3D
Unity 3D tem grande aceitação no mercado, principalmente devido a sua grande praticidade e sistema de licenciamento. Embora aceite outras linguagens, a programação em C# traz maior dinamismo, sendo amplamente utilizada pela comunidade de desenvolvedores desta plataforma.
· Ela é disponibilizada no site do fabricante, podendo ser baixada e utilizada livremente, porém ressarcindo ao fabricante sob a forma de royalties a partir de determinada quantidade de cópias do jogo comercializada.
· Embora seja possível utilizar o ambiente Mono Develop para a programação, uma opção melhor é o Visual Studio, que pode ser baixado no site da Microsoft. Ambos os sites exigirão o cadastro, que é gratuito, para efetuar download e ativar as ferramentas.
· No site da Unity 3D também podemos obter muitos tutoriais e recursos, denominados Assets, no jargão das Game Engines, constituindo uma ótima fonte de aprendizagem acerca do uso da ferramenta.
· Uma das maiores vantagens dessa ferramenta é a quantidade de plataformas distintas para as quais pode gerar os jogos, como Windows, Linux, Xbox, Play Station e Android.
Da mesma forma, também suporta a importação de arquivos de diversos outros softwares na construção do jogo, como Blender, Zbrush, 3DS Max e Fireworks, entre vários outros.
Em termos de física, além de apresentar um bom suporte à colisão, com diversos tipos de colisores 2D e 3D, traz suporte ao PhysX e permite trabalhar com Soft Body e Ragdoll, além do RigidBody, que trata da opção mais comum nas Game Engines.
Ela também nos oferece um excelente sistema de partículas, sendo possível obter vários Assets com efeitos já configurados no site do fabricante, e um bom suporte ao uso de Shaders personalizados, trazendo uma excelente qualidade gráfica e realismo aos ambientes 3D.
Em termos de jogos cooperativos, a Unity 3D apresenta um conjunto de ferramentas e arquitetura específica para a criação simplificada de jogos em rede (multiplayer).
Os principais componentes voltados para rede são o HLAPI e o Network Manager, mas existem projetos visando a mudança desse sistema em versões futuras da Game Engine.
Já no que se refere à inteligência artificial, esta Engine traz vários sistemas úteis e de fácil aplicação aos jogos, como o Ray Cast, que detecta os inimigos em determinada direção por meio da colisão com um raio traçado virtualmente, ou o Navigation Mesh, que define uma malha de superfície sobre a qual podemos configurar agentes de perseguição e alvos específicos, segundo um algoritmo de Pathfinding.
Para os jogos 2D temos o suporte à criação com uso de camadas, física e colisores, manipulação simplificada de Sprites e controle de animações, permitindo a criação extremamente ágil, particularmente dos jogos de plataforma.
Finalmente, mas ainda não abrangendo todas as diversas funcionalidades da Unity 3D, ela traz boas ferramentas para a criação da interface de usuário, aqui se tratando de menus e avisos, entre outros elementos de interação e HUD.
Os componentes para construção de GUI incluem:
1. PAINÉIS
2. BOTÕES
3. TEXTOS E IMAGENS
4. CAMPOS DE ENTRADA
5. SISTEMA DE EVENTOS
Explorando a Unity
· Na criação de um projeto para Unity 3D deve ser escolhido entre os modelos 2D ou 3D, entre outras opções.
· Também podem ser selecionados os Assets que serão utilizados no novo projeto, mas estes podem ser adicionados posteriormente a partir do ambiente da Game Engine.
Exploraremos aqui as funcionalidades do ambiente 3D por meio de um novo projeto desse tipo, que será chamado de "Exemplo001", sem adicionar Assets durante a criação.
Tendo sido criado o projeto, o ambiente será iniciado, exibindo as diversas ferramentas disponíveis na plataforma.
Na visualização padrão inicial serão observados:
Todo projeto na Unity 3D é dividido em cenas, sendo definida uma cena inicial com o nome SampleScene, a qual pode ser renomeada a qualquer instante. Podem ser criadas múltiplas cenas, onde cada uma corresponde a um ambiente completamente configurado, como as diversas fases de um jogo.
Tendo em mente o objetivo de cada divisão, podemos iniciar a utilização da Unity 3D com um exemplo simples, mostrando potencialidades naturais desta Game Engine para a criação de ambientes 3D.
Todo elemento manipulável visualmente no Unity é um Game Object, incluindo as primitivas 3D disponibilizadas pela Engine.
Por exemplo, o menu Game Object..3D Object..Cube é utilizado para a criação de um cubo, que poderá ser visualizado e manipulado na Scene View ou pelo Inspector.
Tendo adicionado o cubo à nossa cena, podemos definir pela Toolbar o tipo de transformação linear desejada e modificar o objeto com o uso do mouse na Scene View.
Gizmos
Para as operações de translação, rotação e escala são disponibilizados Gizmos, ou, como poderiam ser descritos, eixos de transformação 3D.
Componentes e comportamentos específicos
Ainda falando acerca do Inspector, através da opção Add Component, no nível das propriedades, é possível atribuir componentes e comportamentos específicos, como na utilização de física.
Para testar essa funcionalidade, vamos configurar um corpo rígido em nosso cubo, adicionando um componente do tipo Physics..Rigidbody ao mesmo. Ao executar o jogo, com o botão Play, será possível observar o cubo cair no espaço indefinidamente, sob efeito da gravidade.
Note que a janela Game foi ativada de forma automática durante a execução, a qual é finalizada pressionando novamente o botão Play.
Durante a execução do jogo, qualquer modificação efetuada na Scene View ou no Inspector não será mantida, logo fique atento ao estado atual do ambiente.
Terrenos
Porém, vamos partir para algo mais efetivo na construção de um jogo, por meio do uso de terrenos, que são elementos de grande importância para a construção de cenários 3D, e a opção Game Object..3D Object..Terrain oferece um ferramental muito completo para a criação dos mesmos.
Com o uso das ferramentas para modelagem do terreno, disponibilizadas a partir do Inspector, é possível aumentar, diminuir ou suavizar elevações. Com as elevações definidas, texturas podem ser aplicadas ao relevo por meio da opção de pintura. Também é possível adicionar vegetação e detalhes ao terreno, viabilizando a criação de ambientes muito realísticos.
Após posicionar nosso terreno e definir o tipo correto, vamos criar algumas elevações. Para tal devemos escolher o formato do Brush, além do tamanho e opacidade.
Para aumentar as elevações, utilize o clique e arraste sobre a superfície, enquanto para diminuir basta utilizar SHIFT junto ao clique.
Outras opções disponíveis a partir do botão do pincel são a fixação da altura, como na definição de platôs, e a suavização das elevações, além de Paint Texture, onde podem ser definidas as texturas que serão aplicadas ao nosso terreno.
Agorapodemos aplicar uma textura ao nosso terreno, o que é feito com o uso de uma imagem em algum formato reconhecido, como JPG ou PNG, bastando arrastar o arquivo para sessão Assets do projeto.
Essa imagem será associada a uma camada sobre o terreno, sendo criada com o clique sobre Edit Terrain Layers e a escolha da opção Create Layer, para as atuais versões da Unity 3D, ou com Edit Textures da ferramenta de pincel nas versões antigas.
Em ambos os casos, na janela que se abrirá deverá ser escolhida a figura que foi adicionada ao projeto.
A primeira textura aplicada cobrirá todo o terreno, mas podem ser adicionadas outras, segundo o mesmo processo, para pintar áreas diferenciadas com o uso do Brush.
Asset Store
Além de podermos importar recursos comuns por meio de arraste, o fabricante da Unity 3D mantém um comércio virtual denominado Asset Store, em que podemos obter diversos recursos, sendo acessado pelo navegador ou pela Game Engine por meio da opção Window Asset Store (CTRL+9).
· Muitos componentes são gratuitos, mas também existem Assets pagos, constituindo inclusive um mercado muito interessante para desenvolvedores de jogos.
· Em termos de jogos 3D, as representações mais comuns para o jogador são a primeira e a terceira pessoa, e a Unity 3D fornece Assets prontos para os dois modos, devendo apenas ser acrescentado o pacote correto ao projeto e utilizado o controlador adequado.
· Para a utilização da representação em primeira pessoa no Unity, o caminho mais simples é a utilização de PFPSController, um Prefab presente no pacote Characters.
· Todo pacote, ou Asset Package, pode ser selecionado na criação do projeto ou adicionado por meio do menu Assets..Import Package..[Pacote].
Nas versões mais recentes, é necessário importar o pacote Standard Assets da Asset Store, pois estes recursos foram removidos da instalação padrão.
Sistemas de Partículas
· Outra característica interessante da Unity 3D é o Sistema de Partículas, utilizado na construção dos mais diversos efeitos, como fumaça, fogo, neve, elementos líquidos, e muitos outros.
· Com a utilização da Unity, é bastante simples criar e configurar um sistema de partículas a partir do início. No entanto, existem vários efeitos já configurados, no formato de Prefab, disponíveis para utilização através de Assets..Import Package..ParticleSystems.
Para quem utiliza a versão nova, e importou o pacote Standard Assets, os sistemas de partículas já estarão disponíveis.
Terceira pessoa
Tão simples quanto trabalhar com a primeira pessoa é trabalhar na terceira pessoa.
Certamente a definição de um personagem em terceira pessoa exigirá alguma modelagem 3D, mas o Prefab ThirdPersonController já está disponível no pacote Characters e precisa apenas ser arrastado para a cena, assumindo a malha padrão para testes.
A câmera deve ser posicionada corretamente para visualizar o personagem, e as dimensões corrigidas para a cena, e, ao acionar Game Play, podem ser utilizados os comandos comuns de jogos 3D.
Modelador de árvores
Outra ferramenta muito interessante da Unity 3D é o modelador de árvores, o qual permite criar os mais diversos tipos de árvores e arbustos com grande facilidade.
Uma árvore configurada pode ser reutilizada em toda a cena, e pode conter aspectos aleatórios que denotarão uma individualização de cada instância utilizada.
No pacote Environment, temos acesso a diversos elementos que podem ser utilizados na cena, como exemplos de árvores e elementos líquidos.
· Para adicionar as árvores ao mapa, usa-se a opção Paint Trees do editor de terrenos, sendo selecionada a árvore que será utilizada a partir da opção Edit Trees, Add Trees.
· Na janela que se abrirá, deve-se clicar no seletor para Tree Prefab, selecionando uma árvore da biblioteca, como Conifer Desktop.
· Agora, é só adicionar as árvores no ambiente, da mesma forma que foi feito com as elevações.
· Com um pouco de paciência, nós conseguimos criar ótimos cenários 3D, como pode ser observado a seguir.
Física para jogos
Os cálculos da física são de grande relevância para a criação de jogos.
Efeitos como gravidade, vento e atrito, entre vários outros, mudarão o comportamento de diversos elementos presentes nos jogos 2D e 3D.
Inicialmente, para entender as relações de ordem física entre os elementos de jogo, devemos entender o conceito e utilização da colisão.
Tanto em jogos 2D quanto em jogos 3D, a colisão é quase sempre o principal elemento funcional, pois permite detectar os diversos eventos relacionados ao contato, ou colisão, entre dois ou mais elementos do jogo, trazendo informações acerca do momento e espaço envolvidos.
Veja exemplos de uso da colisão:
1. Impedir que uma parede seja atravessada.
2. Evitar que objetos caiam indefinidamente.
3. Verificar quando um tiro atinge o personagem.
As técnicas para detecção de colisão surgiram ainda nos jogos 2D mais antigos, sendo algumas delas utilizadas até hoje, como a Bounding-Box, que se baseia na determinação de uma área retangular invisível envolvendo cada Sprite, reduzindo o problema ao simples teste da superposição dessas áreas.
Essa técnica apresenta uma performance muito boa devido ao baixo números de contas e de verificações, mas, como ela testa colisões entre retângulos, em figuras muito curvas e disformes, pode não apresentar um resultado satisfatório.
Além da colisão, o principal elemento representativo da física nos jogos é a força. A gravidade, por exemplo, funcionará aplicando uma aceleração negativa de valor constante aos objetos no eixo y.
No entanto, as forças não atuam sobre todos os elementos da cena, sendo normalmente aplicadas apenas aos corpos rígidos relacionados às mesmas, de acordo com os parâmetros adotados pelo jogo.
Corpos rígidos apresentam características como:
· Posição.
· Velocidade.
· Densidade.
· Massa.
· Rotação.
· Velocidade angular.
Força e torque podem ser adicionados a um corpo rígido, modificando algumas de suas características originais.
O ferramental da Unity 3D para aplicação de física nos jogos é muito vasto, a começar pelo suporte à colisão.
Através desta Game Engine, é possível utilizar uma grande gama de estratégias de detecção da colisão sem qualquer tipo de aprofundamento matemático, sendo as áreas (2D) e volumes (3D) para detecção denominadas colisores.
· Embora a metodologia seja sempre a mesma, as fórmulas de cálculo para diferentes áreas ou volumes de colisão podem se tornar bastante complexas. Formatos típicos de colisores podem ser quadrados e círculos, no modelo 2D, ou esferas e cápsulas, no modelo 3D.
· É possível testar a colisão de todos os vértices de um polígono ou de uma malha, mas o gasto computacional envolvido pode não trazer tantos benefícios assim, o que faz com que utilizemos colisores aproximados para a forma predominante no componente.
· Mesmo sem a necessidade de efetuar complexas implementações de colisores, devido ao suporte oferecido pela Unity 3D, é interessante observar os impactos para o jogo na escolha de colisores mais ou menos complexos, pois o aumento da quantidade de cálculos efetuados poderá trazer efeitos catastróficos para a fluidez no momento de execução.
Inicialmente, a Unity 3D apresenta colisores 3D, pela própria natureza da Engine, sendo mais utilizados os colisores Box Collider, Sphere Collider e Capsule Collider. Em situações de maior detalhamento, pode ser utilizado o Mesh Collider. Outro colisor importante é aquele utilizado na criação de terrenos: o Terrain Collider.
Diversos objetos criados no ambiente da Unity 3D já trazem colisores, não sendo necessário que adicionemos os mesmos de forma manual neste primeiro instante.
A criação de um cenário simples, com um box (BoxCollider), quatro esferas posicionadas sobre o box (SphereCollider) e um controlador em terceira pessoa (CapsuleCollider), com o correto posicionamento de câmera, já seria suficiente para observar o efeito da colisão, já que o personagem não consegue atravessar as esferas.
É fundamental que você observe, através do Inspector, a relação entre cada Game Objecte o colisor utilizado. Inclusive, clicando sobre o colisor associado, é possível observar como ele envolve o objeto, além de viabilizar a edição de seus vértices.
Embora a funcionalidade básica dos colisores seja a de efetuar o bloqueio do objeto, nós podemos controlar a resposta às colisões que ocorrem por meio de uma linguagem de programação.
O uso de C# permite a criação de novos Assets e a modificação dos comportamentos da Unity 3D, visando a especificidade para cada jogo. Embora possa ser utilizada também a linguagem Java Script, C# tem obtido a preferência dos desenvolvedores que utilizam esta Game Engine.
A classe básica de comunicação entre Unity 3D e C# é a MonoBehaviour, e devemos estendê-la para adaptar os elementos do projeto às necessidades de um novo jogo.
Por exemplo, se quisermos que as esferas colocadas no cenário desapareçam quando forem tocadas pelo personagem do jogador, devemos criar um Script contendo um descendente de MonoBehaviour que implemente o método OnCollisionEnter, com a codificação adequada, e associá-lo às diversas esferas.
· Vamos escolher uma das esferas e gerar, a partir dela, um novo Script por meio de Add Component..New Script, no Inspector, o nomeando como SelfDestruct.
· Nosso Script poderá ser observado na divisão de projeto, raiz da sessão de Assets, bastando dar um duplo clique sobre ele para abrir o editor de código associado.
Para as demais esferas, podemos associar o Script através do Inspector utilizando Add Component..Scripts..SelfDestruct, ou arrastar o Script, a partir da divisão de projeto, até cada esfera na Hierarchy View.
Com esses passos efetuados, sempre que o personagem tocar em uma das esferas, ela é destruída, tratando de uma ação muito simples, mas que permite demonstrar a utilização de C# para resposta aos eventos de colisão na Unity 3D.
Módulo 3: Conhecer os elementos da Unity 3D e como aplicá-los para a criação de jogos 2D.
Assets para jogos 2D
De forma geral, a grande diferença entre jogos 2D e 3D se refere à forma como a parte gráfica é tratada:​
Existem diversas estratégias para a criação das imagens, sendo comum, na área de jogos, o uso de Pixel Art, onde as imagens são criadas pixel a pixel e o rendering de modelos 3D tem visão frontal ou topo.
Durante muito tempo, a única forma de criação de imagens era através de Pixel Art, o que é refletido em jogos como o clássico PacMan.
Pelo fato de trabalhar diretamente ao nível de pixels, esse tipo de arte fica sujeita à resolução do dispositivo e paleta disponível, o que exigia ótimo conhecimento acerca da teoria das cores e combinações de luminosidade quando estávamos restritos a paletas de até 256 cores, bem diferente do atual padrão RGB, com milhões de opções de cores.
Quanto à resolução, ainda pode ser um problema corrente, pois, com a grande diversidade de dispositivos do mercado atual, a arte deve ser adaptável a diferentes resoluções, levando ao desenvolvimento de técnicas como MipMap, onde a mesma imagem é criada em várias resoluções, sendo utilizada para exibição aquela que melhor se enquadra nas possibilidades do dispositivo.
Sem o uso desse tipo de artifício podem ocorrer dois efeitos adversos:
1. Imagens desproporcionalmente grandes, quando a resolução é inferior.
2. Imagens pixeladas, quando a figura é expandida em uma resolução superior.
Em um jogo 2D, as imagens são utilizadas para definir cenários, objetos e personagens, e, no caso específico de personagens, é comum a necessidade de animações, chamadas de Sprites, baseadas na troca rápida de quadros, como nos desenhos animados, o que é conhecido como animação quadro a quadro.
Quanto ao formato das imagens utilizadas, existe uma preferência atual pelo PNG, podendo ser utilizado também GIF ou JPEG.
No caso do formato JPEG existe a possibilidade de perda de qualidade, devido ao tipo de compactação utilizada.
Renderização de modelos 3D
Outra forma de criar personagens e objetos para jogos 2D é por meio de renderização de modelos 3D para arquivo sequencial, em vez de vídeo, o que permite a junção das imagens geradas em uma ferramenta adequada, como Adobe Photoshop.
Nessa ferramenta, ou em qualquer outra que possibilite a criação de jogos 2D, poderá ser tratada a questão da transparência e montado um SpriteSheet, elemento fundamental para definir a animação de Sprites na Unity 3D.
Um exemplo de ferramenta para modelagem 3D que permite esse tipo de estratégia é o 3DS Max, em que podemos definir um personagem, animá-lo com o uso de Bones, aproveitando todos os recursos para criação de matérias e iluminação, sendo comum o uso de:
· Visão frontal para jogos de plataforma.
· Visão superior para jogos de nave.
· Perspectiva isométrica para jogos de RPG.
Existe diferença na criação de cenários e itens?
Em relação aos personagens, outra estratégia de animação consiste em dividir os elementos constituintes da figura em diversas partes, como cabeça, corpo, braços e pernas, e efetuar a animação independente das partes através de transformações lineares, como rotação e escala.
Os arquivos de som, por sua vez, são os mesmos utilizados em jogos 3D, porém não podemos contar com som espacial, já que estamos em um ambiente 2D. No entanto, é possível trabalhar com som estéreo, distribuído entre os fones ou caixas de som.
Com relação aos recursos específicos da Game Engine, podemos citar os colisores 2D e a física 2D como elementos primordiais na concepção desse tipo de jogo, além da definição de camadas de ordenação para indicar quais elementos ficam sobrepostos a outros. Isso será muito importante para o cenário, permitindo inclusive a ilusão de profundidade segundo o princípio da paralaxe.
Projeto de jogo 2D
Criar um projeto 2D na Unity 3D não é muito diferente de um projeto 3D.
Cenário
Criado o projeto, o primeiro passo é a definição do cenário, podendo ser utilizada qualquer figura, preferencialmente no formato PNG, que deverá ser arrastada para a área de Assets do projeto.
Qualquer imagem adicionada é considerada como uma textura pela Unity 3D, e, para que seja classificada como Sprite, a propriedade Texture Type deve ser escolhida como Sprite (2D and UI).
Se o projeto é do tipo 2D, a imagem adicionada é configurada como textura do tipo Sprite de forma automática.
A opção Pixels Per Unit (PPU) terá influência sobre a resolução utilizada para o Sprite, enquanto o Filter Mode padrão é o Bilinear, que utiliza um valor médio para o desenho, enquanto Trilinear combinaria este valor com níveis de MipMaps.
Neste ponto, é interessante observar a diferença de semântica da Unity 3D, pois o termo Sprite deriva do latim Spiritus, caracterizando um objeto que se move pela tela sem deixar “rastros”, como se fosse um “espírito”, e, no entanto, a Unity 3D classifica como Sprite tanto elementos estáticos quanto animados.
Para adicionar o fundo à cena, basta arrastar o Sprite a partir da área de Assets, ajustando a posição e a escala, mas sempre lembrando de buscar uma resolução adequada.
Quando é adicionado ao cenário, o fundo fica encapsulado por um elemento do tipo Sprite Renderer, componente responsável pelo desenho do Sprite em meio à cena.
Personagens
Agora podemos começar a pensar em termos de personagens, e, para tal, precisamos de um SpriteSheet em formato PNG com transparência, podendo ser encontrados vários exemplos para teste na Internet.
Lembre-se de que essas figuras servem apenas para teste, devendo ser utilizados elementos autorais para a concepção de um jogo comercial.
· Basicamente um personagem 2D trata de uma animação quadro a quadro aplicada a um objeto que pode modificar seu posicionamento.
· A grande dificuldade na criação de Sprites encontra-se na arte gráfica, pois as imagens devem ser criadas de forma que sua alternância represente a direção e a velocidade do movimento atual do objeto.
O formato de arquivo mais indicado para a criação de um SpriteSheet é o PNG, ou Portable Network Graphics.
Este é um formato que veio em substituição ao GIF, pelo fato de incluir algoritmos patenteados, constituindoum padrão livre, recomendado pela W3C.
Ele também possui transparência (canal alfa), além de apresentar grande profundidade de cores e compressão regulável.
A figura com o SpriteSheet, ou atlas, deve ser adicionada ao projeto da mesma forma que o cenário, mas, nesse caso, modificaremos Sprite Mode para Multiple, de forma a permitir a divisão em quadros e posterior criação de animações.
No modo Single, o Sprite é considerado como uma figura única e sem movimentação, enquanto, com o uso de Multiple, o Sprite pode ser dividido em áreas menores, permitindo a típica animação quadro a quadro dos Sprites.
Após a mudança para o modo Multiple, o botão Sprite Editor dará acesso à ferramenta de mesmo nome, permitindo a manipulação do SpriteSheet original. O principal uso desta ferramenta é na divisão da imagem original em figuras parciais de forma a viabilizar a animação.
1. Por meio da opção Slice é muito simples efetuar a divisão, ou fatiamento, do SpriteSheet original, podendo ser utilizado modo automático ou grid.
2. Com o uso de Type Automatic, o próprio editor seleciona as áreas de cada quadro, enquanto, na opção Type Grid, é utilizada uma divisão fixa, sendo informado o tamanho da célula, offset e o espaçamento entre células.
3. Pode ser definido também o posicionamento do Pivot para cada figura parcial gerada, impactando diretamente nas operações de transformação, como a rotação. O posicionamento padrão do Pivot é no centro do quadro, mas podem ser utilizadas outras opções, como Top e Bottom Left.
4. Por fim, o método de divisão, no modo automático, assume valores como Delete Existing, Smart e Safe, sendo adotado como padrão a opção Delete Existing, que anulará quaisquer divisões anteriores e efetuará uma nova divisão, tendo como base as áreas com transparência da figura.
Para nosso exemplo, usaremos o Type Automatic e Delete Existing.
Após efetuar a divisão nos quadros constituintes, estes ficam acessíveis a partir do SpriteSheet, na área dos Assets do projeto.
Basta selecionar os quadros desejados e arrastar para a Scene View, o que causará a criação da animação e do controle de estados de forma automática.
· É fácil observar a associação do Sprite com o surgimento de uma animação, ou Animation, e um controlador de estados, ou Animator. Estes dois elementos devem ser observados para a correta exibição dos movimentos do Sprite em diferentes instantes do jogo.
· No momento em que arrastamos os quadros de um Sprite para a Scene View, é solicitado que seja dado um nome para o Animation, enquanto o Animator é gerado com o mesmo nome do SpriteSheet, podendo ser renomeado a qualquer instante pela janela de projeto ou na visão hierárquica.
· Os estados estarão associados à intenção de movimento ou situação do jogo, como pode ser observado muito claramente no jogo Sonic, em que o personagem pode estar parado, pulando, andando, correndo ou girando, e as animações são alternadas para seguir o sentido e a velocidade do movimento de forma harmoniosa.
A sequência de exibição de quadros pode ser manipulada a partir da janela Animation, que apresenta inicialmente uma linha de tempo, relacionada ao Sprite, indicando os momentos em que ocorre a substituição de cada quadro.
Podem ser adicionados elementos de transformação na sequência com o uso de Add Property, e a escolha do tipo de transformação utilizada, como rotação (Rotation), o que gerará uma linha de tempo paralela, em que são adicionadas chaves com o uso do botão direito e opção Add Key.
Arrastando a sutil linha branca de referência para um instante da animação, pode ser adicionada uma chave e modificada a rotação do quadro, o que levará a uma interpolação linear dos valores a partir da chave anterior até a chave corrente, proporcionando a execução gradativa da rotação durante a animação.
Exemplo prático
Primeiro estado
Para exemplificar o uso dessas técnicas, vamos iniciar um novo projeto, ou uma nova cena no projeto que estiver utilizando para testes, e adicionar o fundo, no formato PNG, que será um Sprite no modo Single.
Após o posicionamento deste Sprite na cena, devemos adicionar um colisor do tipo Box Collider 2D, obtido com o uso de Add Component, Physics 2D, opção Box Collider 2D.
Inicialmente, o colisor envolverá toda a figura, mesmo a parte transparente, e deverá ser editado a partir do clique na opção Edit Collider, ficando restrito à área inferior do cenário.
A envoltória aparecerá como um retângulo verde, sendo editável a partir do arraste de seus limitadores, representados como pequenos quadrados.
Agora precisamos de um SpriteSheet adequado, com mais de uma configuração de movimento e no formato PNG, devido ao uso da transparência. Na Unity 3D, deverá ser configurado o modo Multiple e efetuada a divisão no Sprite Editor com Slice pelo método automático.
Segundo o mesmo processo descrito anteriormente, vamos arrastar a sequência de interesse para a cena, criando a animação (Animation) com o nome “Parado”, e renomeando o Animator como Personagem. Pode ser necessário corrigir a escala nas dimensões X e Y.
Com a animação inicial definida, vamos adicionar um Rigidbody 2D e um Box Collider 2D ao personagem, ambos os componentes acessíveis a partir de Add Component, opção Physics 2D.
Não serão necessários ajustes e, ao executar o projeto, poderemos ver o personagem cair até atingir a base do cenário, sendo impedido de cair indefinidamente devido à interação entre os colisores do personagem e do fundo.
Segundo estado
Agora vamos criar o segundo estado de nosso personagem, mas lembre-se de parar a execução do projeto para que as alterações tenham efeito.
Com o elemento Personagem selecionado na visão hierárquica, abra a janela Animation e crie outra animação, com o clique sobre o nome da atual e escolha de Create New Clip, como pode ser observado a seguir. O nome da animação será “Pulando”.
A nova animação estará inicialmente vazia. Devemos utilizar Add Property, seguido da escolha de Sprite Renderer, opção Sprite, clicando no sinal de adição localizado ao lado da propriedade. Essa operação fará com que seja definida uma linha do tempo com duas chaves iniciais.
Com as animações prontas, podemos configurar a FSM e cuidar das transições entre estados. Para tal, deve ser selecionado Personagem na visão hierárquica e aberta a janela Animator.
Nessa janela, definiremos uma transição indo de Parado para Pulando e outra no sentido inverso. Além disso, precisamos definir um parâmetro do tipo Trigger, com o nome “Pulo”, que será utilizado como indutor da primeira transição, enquanto a segunda transição criada, de Pulando para Parado, estará sem restrições, mas com Exit Time marcado, de forma a voltar ao primeiro estado (Parado) após um tempo definido.
Durante a execução, bastará selecionar o componente Personagem na hierarquia, o que já trará a indicação de qual estado está sendo executado, e clicar na trigger Pulo, o que fará mudar a animação, ao mesmo tempo em que a Máquina de Estados reflete todo o fluxo da mudança.
Contudo, ainda precisamos de algo interativo na execução de um jogo. Logo, é preciso um pouco de programação.
Programação
Vamos adicionar ao objeto Personagem o script necessário com o uso de Add Component, opção New Script, adotando o nome “Pular”.
Em seguida daremos um duplo-clique sobre script criado na janela de projeto, abrindo o editor e modificando para o código seguinte.
Nesse código, é definida uma propriedade Forca, com valor inicial de 30, mas que pode ser ajustada pelo Inspector para a melhoria do movimento.
Quando a tecla de espaço é pressionada, o que é detectado com GetKey, a Trigger “Pulo” do componente Animator é setada, modificando a animação, e é aplicada a força definida ao componente Rigidbody2D na direção Y, contrapondo a gravidade durante um curto período, e causando a elevação do personagem.
Agora, já podemos testar o resultado deste exemplo, executando o projeto e apertando a tecla de espaço.
Aula 2: Linguagem C#, Física e HUD no desenvolvimento dos jogos digitais
Módulo 1: Explicar o usode C# na Unit 3D e aplicar a programação C# na criação de jogos 2D.
Características e Sintaxe do C#
A linguagem C# trata de um ambiente orientado a objetos, onde a estrutura básica é a classe, e traz um conjunto de tipos nativos, que são os únicos elementos que não são tratados como objetos.
Para cada tipo nativo do C#, existe uma classe Wrapper dotNet capaz de registrar os mesmos domínios de valores do elemento nativo relacionado.
Para compreender corretamente a sintaxe, não se pode destinar o uso da linguagem a uma determinada plataforma, como Web, Mobile, ou a própria Unity 3D, logo, você deve criar aplicativos Console no ambiente do Visual Studio dotNet.
Ao escolher esse tipo de aplicativo, você poderá codificar o método Main, onde o programa é iniciado, e mandar executar por meio do botão Start, de forma a efetuar seus testes com a linguagem.
Nesse pequeno programa, podem ser observadas diversas características da linguagem, como a importação de bibliotecas com a palavra using e a definição de um espaço de nomes, ou biblioteca, com o uso de namespace.
Também pode ser observado o uso da classe Console para impressão na tela, através de WriteLine, e leitura de tecla, com ReadKey, sendo que este último comando foi utilizado apenas para evitar que a tela se feche antes que você possa visualizar a saída obtida pelo programa.
Com relação aos comentários, a linguagem C# aceita dois tipos:
As variáveis permitem diferentes formas de declaração e inicialização.
Podemos efetuar diversas operações para cada tipo de variável, como as numéricas, que aceitam os operadores aritméticos.
Os operadores relacionais também podem ser utilizados sobre as variáveis numéricas, permitindo a comparação de valores e sempre retornando um resultado booleano.
Já sobre as variáveis booleanas, são utilizados os operadores lógicos, normalmente definindo condições compostas para determinado fluxo de execução.
A conversão de tipo, ou type cast, é uma operação que causa a reinterpretação do tipo de dado. Esta é uma técnica muito utilizada na orientação a objetos quando é necessário acessar um atributo específico de um descendente utilizado no lugar da classe inicial.
Estruturas de controle
Definidos os tipos básicos e as operações, devemos analisar as diversas estruturas de controle de fluxo existentes, de forma a efetuar tomadas de decisão (estruturas condicionais) e gerência de repetições.  
As estruturas condicionais permitem sair de um caminho sequencial simples para um fluxo com tomadas de decisão, sendo a mais comum SE...ENTÃO...SENÃO.
Porém, nas linguagens derivadas do C, não existe a palavra ENTÃO (then), o que torna obrigatória a utilização de parênteses na condição.
Neste exemplo, é utilizado o comando ReadLine para a leitura de um valor texto a partir do teclado, sendo convertido para inteiro com o uso do método Parse da classe Wrapper.
Obtidos os três valores, a sequência de estruturas de decisão imprimirá a mensagem referente à variável de maior valor.
Quanto ao controle de iterações, a estrutura para gerência de repetições mais simples seria ENQUANTO...FAÇA, com as execuções sucessivas baseadas em uma condição definida no início dessa estrutura.
Este exemplo apresenta um incremento exponencial, imprimindo as potências de base 2 entre 1 (20) e 256 (28).
A estrutura de repetição mais complexa nas linguagens derivadas do C é PARA...FAÇA, apresentando muito mais opções que em linguagens mais próximas do algoritmo, como Pascal e Fortran.
A forma geral seria for (< inicialização > ; < teste > ; < incremento >), sendo que as seções de inicialização e incremento aceitam mais de uma instrução, e qualquer das três seções pode ser omitida.
Este é um exemplo simples, com a impressão dos números de 1 a 10 baseado em um incremento unitário a cada rodada, mas poderíamos trabalhar com incrementos diversos em um exemplo mais complexo, como ilustrado a seguir.
Observando este código, temos a inicialização das variáveis a, b e c, e a cada rodada ocorre o incremento de 1 para a, decremento de 1 para b e multiplicação por 2 para c. As repetições serão encerradas quando o valor de a superar a divisão de b por c.
A cada rodada são impressos os valores das três variáveis, com o uso da saída parametrizada de WriteLine, em que a primeira variável após a vírgula será utilizada no parâmetro {0}, a segunda no parâmetro {1}, e assim sucessivamente.
Quanto ao caractere especial \t, ele serve para efetuar uma tabulação entre os valores.
Orientação a objetos
É importante observar que bibliotecas como as fornecidas pela Unity 3D fazem ampla utilização de programação orientada a objetos, e na sintaxe C# uma classe é definida pela palavra class, devendo ser observado o namespace que foi utilizado.
· Para a definição de atributos e métodos, os níveis de acesso disponíveis são public, private e protected.
· O método construtor deve ter o mesmo nome da classe, enquanto destrutores assumem um til antes do nome.
Uma propriedade define um atributo com acesso controlado, e utiliza escritores e leitores por meio das palavras set e get. Estas palavras especiais permitem uma leitura muito mais limpa do que a criação de setters e getters, presentes em linguagens como Java e C++.
Implementação de herança
Para a implementação de herança, deve ocorrer uma referência ao ascendente através de: Ascendente.
Os construtores herdados, e demais elementos da superclasse são referenciados por meio da palavra base, enquanto a palavra this resolve o conflito de nomes na própria classe.
Poliformismo
Outro conceito de grande relevância é o polimorfismo, pois permite adaptar métodos herdados à realidade enfrentada pelos descendentes.
Por exemplo, a exibição de informações de um objeto da classe Profissional deveria acrescentar o valor do atributo profissão na saída.
Para viabilizar a utilização de polimorfismo na programação C#, o método existente na classe original deve ser assinado como virtual, enquanto a classe descendente deverá utilizar a assinatura override, e ainda pode ser feita a chamada ao método original, a partir da classe descendente, com o uso da palavra base.
Modelagem comportamental
Na programação moderna não basta definir classes, é necessário modelar comportamentos. A modelagem comportamental traz grande sustentação às diversas estruturas de dados e vários padrões de desenvolvimento, e uma das formas de modelar um comportamento é com o uso de classes genéricas.
Um bom exemplo de utilização de classes genéricas é na definição de coleções. Ao contrário da programação estruturada, onde os vetores são a maneira mais comum para utilização de dados contíguos na memória, na orientação a objetos são utilizadas as coleções.
Elas são mais interessantes, pois trabalham como listas encadeadas, permitindo a variação de tamanho após a criação, ao contrário dos vetores, que apresentam dimensão fixada na criação.
Além de se basearem em classes genéricas, as coleções permitem a utilização de comandos específicos, como o foreach.
C# na Unity​ 3D
Quando criamos um Script C#, para uso na Unity 3D, é definido um descendente da classe MonoBehaviour com o mesmo nome do arquivo, devendo ser respeitadas as letras maiúsculas e minúsculas.
Vamos sobrescrever os métodos herdados, de forma a interferir no comportamento padrão dos objetos da cena. Estes métodos funcionam como eventos, sendo acionados em momentos específicos da execução do jogo.
 
Dois métodos de grande relevância são:
Exemplo
Vamos iniciar um exemplo de projeto 2D com a adição de um Sprite modo Single que possa funcionar como canhão, e para o qual serão criados os Scripts Rotaciona e Atirar.
A primeira classe a ser codificada será Rotaciona, em que será modificado o método Update, de forma a permitir a rotação do Sprite a partir de comandos do jogador.
Analisando o código, podemos observar que é testado o pressionamento das teclas "A" e "S", a partir do método GetKey e o uso do código definido em KeyCode.
Na primeira condição, se a tecla "A" foi pressionada e a rotação atual do eixo z formenor do que 0,5 radianos, a figura será girada em um grau no sentido anti-horário, enquanto na segunda, se a tecla "S" for pressionada e a rotação for maior do que -0,5 radianos, ocorrerá o giro de um grau no sentido horário.
Note que a rotação corrente é fornecida em radianos a partir de transform.rotation, enquanto o método Rotate, de transform, gira o eixo escolhido em termos de graus.
Para projetos em duas dimensões, a visão é sempre frontal, em termos do plano XY, o que faz com que toda rotação ocorra no eixo Z.
Antes de iniciar a codificação do segundo Script, devemos criar o Sprite que será utilizado como projétil. Neste exemplo, é representado por uma esfera com animação.
Os quadros da animação devem ser arrastados para a tela, o que levará à criação do Animator e da animação (Animation) de forma automática, sendo adotado o nome "Bomba" para o novo gameObject.
Vamos adicionar um corpo rígido (Rigidbody2D) ao novo objeto, além de um colisor do tipo CircleCollider2D e os Scripts Impulso e Remover.
O colisor deverá ser ajustado para o contorno da esfera, o que é feito com o clique no botão Edit Collider, presente no Inspector, seguido do arraste dos vértices de referência, representados como quadrados verdes.
Agora, vamos codificar a classe Remover, responsável por eliminar o projétil quando ele atingir uma altura específica, fora da área de visualização.
Quando a coordenada Y de transform.position, referente à altura, for menor do que um valor limite, o objeto corrente (gameObject) será removido da memória com o uso de Destroy.
Como o teste é efetuado a cada frame, devido ao uso de Update, tão logo o objeto não seja mais utilizável, o espaço de memória referente ao mesmo é liberado.
Quanto ao código de Impulso, ele será responsável por viabilizar a aplicação de uma força pontual para se contrapor à ação da gravidade.
Aqui foi criado o método AplicarImpulso, pois precisaremos controlar o momento em que o processo será executado, não sendo possível utilizar eventos como Start e Update.
Nesse método, é capturado o Rigidbody2D associado ao componente, e guardado no atributo corpo, através de GetComponent, sendo aplicada uma força de intensidade forcaX e forcaY por meio de AddForce.
O método GetComponent é um excelente exemplo de uso da modelagem comportamental, em que é obtido um componente associado de determinado tipo, seguindo a sintaxe GetComponent < Tipo > ( ).
Com as configurações finalizadas, podemos arrastar Bomba, a partir do painel Hierarchy para a área de Assets, de forma a criar um Prefab, componente configurado e reutilizável. Feito isso, podemos deletar a bomba original e instanciar quantas bombas quisermos, arrastando o Prefab para a cena.
Agora voltaremos à codificação dos Scripts do canhão, implementando a classe Atirar, provavelmente a mais complexa deste exemplo.
Inicialmente são definidos alguns atributos públicos. No caso, o objeto referente ao tiro, distância da base do canhão até a área de lançamento do projétil, e tempo decorrido desde o último tiro.
· O objetivo será lançar o projétil esférico, com impulso inicial e sob efeito da gravidade, na direção apontada pelo canhão, ocorrendo um tempo mínimo de 0,3 segundos entre um disparo e outro.
· O método CalculaPosicao fornecerá a posição para geração do projétil, efetuando o cálculo em termos de seno e cosseno.
· Lembrando que, na rotação de 0°, o canhão aponta para cima, levando a uma transformação de coordenadas, com o cálculo do deslocamento vertical via cosseno e do horizontal pelo negativo do seno.
A rotação pode ser obtida a partir de eulerAngles, sendo oferecida em radianos, o que exige a multiplicação por Mathf.Deg2Rad para a conversão em graus.
Convertido para graus, o seno e o cosseno são calculados com o uso de Sin e Cos, e o valor multiplicado pela distância da base, de forma a obter os deslocamentos em relação à base para geração.
Esse método será utilizado por Update, em que ocorre a geração efetiva do projétil com o pressionamento de "Espaço" e tempo decorrido apropriado.
Para o cálculo do tempo desde o último tiro, é utilizado o acréscimo de Time.deltaTime a cada frame, pois este atributo representa o tempo entre dois quadros consecutivos.
Ocorrendo o disparo, o tempo decorrido é zerado, de forma a reiniciar a contagem do intervalo para o próximo, e o projétil é instanciado e configurado.
O método Instantiate gerará um novo GameObject referente ao Prefab de tiro, tendo como demais parâmetros a posição calculada e o Quaternion representando uma rotação nula.
Com o objeto instanciado, podemos capturar o Script Impulso dele, com o uso de GetComponent, configurando a força que será aplicada em Y e X, variando de acordo com o ângulo do canhão e, ao final, é chamado AplicarImpulso, de forma a adicionar a força pontual ao projétil.
Agora podemos definir o inimigo, sendo aqui utilizado um pássaro, Sprite modo Multiple, com divisão manual no Sprite Editor.
Tomando como base o SpriteSheet utilizado, os quatro primeiros quadros são arrastados para a cena, gerando o componente Animator e a animação, que receberá o nome Pássaro.
Devemos impedir que a animação da explosão ocorra mais de uma vez, o que é feito selecionando Explosao na área de Assets e desmarcando o atributo Loop Time no Inspector.
Também devemos garantir a remoção do pássaro após a explosão, o que será feito com o acréscimo de um Script apropriado ao estado referente no Animator.
A classe ascendente, neste caso, é StateMachineBehaviour, e o método que utilizaremos será OnStateEnter, que ocorre ao ser iniciado o estado.
O código é até bastante simples, chamando o método Destroy com a passagem do detentor do Animator, que é acessado por meio de animator.gameObject, e o tempo até a remoção, que deverá ser equivalente à duração da animação, obtida com stateInfo.length.
O código da classe Movimenta define apenas uma velocidade de translação constante para o pássaro, que, por ser cinemático, irá se mover sem o efeito de forças externas, como a gravidade.
Aqui será utilizado o método Start, muito útil para inicializar as variáveis internas e capturar elementos associados ao objeto corrente por meio do método GetComponent.
Como a velocidade será constante, ocorre a captura do Rigidbody2D e aplicação da velocidade com o atributo velocity.
Também está presente o método Update, mas com a finalidade de remover o pássaro da memória, interrompendo o movimento e deslocando recursos.
A execução da remoção via Destroy está condicionada ao posicionamento do pássaro fora da área de visualização, quando transform.position.x se torna maior do que maxX.
A classe Colisao definirá a reação do pássaro à colisão com um projétil, o que é feito no método OnCollisionEnter2D.
No método Start, é capturado o Animator no atributo estados, e, no método OnCollisionEnter2D, o parâmetro Finalizado do Animator é setado como true, levando à alteração para o estado de Explosao.
Embora esse estado já remova o pássaro da memória, por meio da programação efetuada anteriormente, o projétil não seria removido, obrigando a utilização de Destroy sobre o objeto que colidiu, obtido com o uso de collision.gameObject.
Agora, é só definir um Empty GameObject com o nome Gerador e Script associado Gerar, que ficará responsável por instanciar os pássaros no decorrer do jogo.
· O Prefab Passaro deverá ser associado ao atributo passaro deste Script, de forma similar ao projétil em relação ao canhão.
· No método Update, o tempoDecorrido é contado até que atinja o valor do intervalo de geração, em que será instanciado um novo Passaro e reiniciada a contagem de tempo.
· A posição Y (posy) é um valor aleatório entre os limites definidos pelos atributos minY e MaxY, enquanto a posição X é determinada por xIni, sempre fora da área de visualização.
Com todos os passos completos, o jogo está funcional, mas é claro que podemos adicionar um fundo e trabalhar com Sorting Layers para controlar a ordem de desenho, como pode ser observado na figura a seguir.
Módulo 2: Listar os recursos defísica e colisão na Unity 3D, aplicar física e bibliotecas para GUI na construção de um jogo 2D.
Física na Unity 3D
A física é essencial para os jogos digitais, e o primeiro conceito que deve ser considerado é a colisão, que pode ser resumida na sobreposição de duas áreas, no modelo 2D, ou dois volumes, no modelo 3D, indicando o contato entre dois elementos.
Com a detecção do contato, podemos tomar decisões importantes, como:
1. Remover um objeto atingido por um projétil
2. Coletar um item
3. Impedir que uma parede seja atravessada
É essencial detectar o momento e o local onde ocorreu determinado contato, além de viabilizar meios programados para responder de forma adequada ao evento.
Bounding-Box
As técnicas para detecção de colisão surgiram ainda nos jogos mais antigos, sendo algumas utilizadas até hoje, como a Bounding-Box.
O princípio dessa técnica é a determinação de uma área retangular invisível que envolva cada Sprite, reduzindo o problema ao simples teste da superposição dessas áreas.
 
Essa técnica apresenta uma performance muito boa devido ao baixo números de contas e de verificações, mas, como ela testa colisões entre retângulos, em figuras muito curvas e disformes, pode não apresentar resultado satisfatório.
Colisores
Na Unity 3D, temos ótimo suporte à colisão de áreas (2D) ou volumes (3D) com o uso de colisores.
Exemplos típicos de áreas e volumes de colisão são:
Inclusive, é possível testar todos os vértices de um polígono ou de uma malha, mas o gasto computacional envolvido pode não trazer tantos benefícios assim.
Força
A gravidade, por exemplo, funcionará aplicando uma aceleração negativa de valor constante aos objetos no eixo y.
As forças não atuam sobre todos os elementos da cena, sendo normalmente aplicadas apenas aos corpos rígidos, relacionados a alguns dos objetos de acordo com os parâmetros adotados pelo jogo.
Corpos rígidos
Os Corpos rígidos apresentam características como:
· Posição.
· Massa.
· Densidade.
· Velocidade.
· Rotação.
· Velocidade angular.
Força e torque podem ser adicionados a um corpo rígido, modificando algumas das características originais. Apenas para exemplificar, se um corpo está apoiado em uma superfície sem inclinação e com atrito, sob a ação da gravidade, ele estará inicialmente com velocidade zero, mas, recebendo uma força horizontal capaz de quebrar a resistência desse atrito, irá iniciar uma aceleração, modificando sua velocidade original.
Materiais
O material utilizado também pode impactar no cálculo. Materiais distintos podem ser mais ásperos ou mais lisos, apresentar diferentes densidades, além de outras características capazes de interferir diretamente nos cálculos da física.
· Na Unity 3D, utilizamos um componente do tipo Rigidbody no objeto que sofrerá o efeito de forças, como a gravidade e vetores programados.
· Em termos do ambiente 2D, é utilizado o Rigidbody2D associado ao Sprite, seguindo a mesma metodologia do ambiente 3D.
Controle de colisão
Agora que temos o controle dos elementos físicos, expandiremos a funcionalidade das colisões para além do simples contato entre objetos.
Para a colisão de contato deve ser utilizado o método OnCollisionEnter ou, para o modelo 2D, OnCollisionEnter2D. O grande problema neste ponto é saber o que colidiu com o objeto, onde as Tags se tornam a solução mais simples para essa identificação.
Head Up Display (HUD)
Em qualquer sistema interativo, as informações devem ser apresentadas de uma maneira integrada ao ambiente e de forma que não atrapalhem o campo de visão do usuário.
Elas podem ser textuais, como pontuações e vidas, ou gráficas, como barras de energia e mapas de contexto.
A sigla HUD significa Head Up Display, referindo-se a informações dispostas em algum visor, como o capacete dos pilotos de caças, ou simplesmente na tela de um jogo, como pontuações e contagem de tempo.
Nos jogos digitais, o conceito de HUD é muito antigo, pois mesmo os primeiros jogos necessitavam oferecer informações acerca da evolução do jogador.
Essas informações inicialmente eram apenas textuais, envolvendo elementos como número de vidas e pontuação, mas foi se tornando cada vez mais comum a adição de elementos gráficos complexos no HUD dos jogos.
Os jogos precisam guiar o jogador na superação de desafios previamente estipulados sem, no entanto, eliminar toda a dificuldade sugerida.
Neste contexto, o HUD auxilia o jogador, mas não efetua as tarefas por ele, mantendo a sensação de desafio necessária à boa aceitação do jogo.
Exemplo
Alguns jogos também utilizam HUD para oferecer dicas no decorrer do jogo, como as setas direcionais, indicando o caminho correto em um labirinto mais complexo, ou na indicação de movimentos combinados e temporizados, como ocorre no jogo God of War.
Elementos comuns de HUD
Diversos elementos de HUD se tornaram comuns nos jogos:
1) Barras de progresso para energia (HP), experiência (XP) e evolução de nível, além de opções especiais e requisitos de ativação (MP).
As barras de progresso costumam adotar um padrão de cores, partindo da mais fria para a mais quente, podendo estar integradas ao cenário ou presentes junto ao jogador e aos inimigos.
2) Quantidade de vidas, pontuação e tempo restante (cronômetro).  
A contagem de quantidade de vidas pode ser representada de forma simplesmente numérica, ou de forma gráfica, como ocorria muitas vezes em jogos Arcade, a exemplo do antigo Galaga.
Cronômetros seguem o mesmo tipo de padrão, podendo tratar de elementos gráficos ou não, sendo apresentado de forma numérica no jogo Sonic, por exemplo.
3) Mapas, armas e munições, radares, bússolas e indicadores de ações.  
Esses elementos são encontrados em jogos de tiro e de naves.
A qualidade da informação apresentada é crucial para que o jogador se localize e tome suas decisões, e, por isso, elementos como mapas, bússolas e radares são comuns em jogos do tipo FPS, como Counter Strike.
Nesse mesmo tipo de jogo, é crucial também a apresentação da informação acerca de munições e armas disponíveis para utilização.
Como são elementos auxiliares, é comum a utilização de teclas e controles específicos para ativar e desativar esses recursos visuais.
4) Velocímetros e tacômetros. 
Sempre presentes em jogos de corrida.
Velocímetros eram definidos de forma textual nos primeiros jogos de corrida, mas, com a evolução dos gráficos, passaram a ter uma representação gráfica cada vez mais próxima dos aparelhos reais.
Interface Gráfica de Usuário (GUI)
O conceito de GUI está relacionado à utilização de elementos padronizados de interatividade na forma gráfica, visando aumentar a usabilidade de um sistema e proporcionando grande ganho ergonômico para o usuário.
Os pesquisadores da Xerox foram pioneiros na criação de interfaces gráficas, definindo conceitos que persistem até os dias atuais, como janelas, menus, caixas de opção, caixas de seleção e ícones.
Interfaces consistentes fazem o usuário compreender mais rapidamente as funcionalidades de novos aplicativos, e nos jogos podem ser utilizadas para atividades de configuração ou para a criação de HUD.
Por meio do menu Game Object..UI, você poderá criar os seguintes componentes relacionados à interface de usuário:
· PANEL
· BUTTON
· TEXT
· IMAGE
· RAW IMAGE
· SLIDER
· SCROLLBAR
· TOGGLE
· INPUT FIELD
· CANVAS
· EVENT SYSTEM
Todo componente UI está associado a um Canvas, ou área de desenho, que pode utilizar três referenciais distintos, com o Render Mode.
Utilizando o modo Screen Space – Overlay, a interface fica no topo da tela, ou seja, na camada de topo do ambiente 2D, enquanto a utilização do modo Screen Space - Camera posiciona a interface em relação a uma câmera, de forma fixa, acompanhando a visão do jogador em primeira pessoa. O modo World Space deixa a interface integrada ao cenário do ambiente 3D.
Aula 3: Movimentação de cenário, inteligência artificial, sonorização e partículas
MÓDULO 1
· Descrever a criação de cenários compostos.
MÓDULO 2
· Explicar conceitos e aplicações da Inteligência Artificial.
MÓDULO 3
· Descrever o sistema de controlede áudio na Unity 3D.​
MÓDULO1
Descrever a criação de cenários compostos.
Diversos jogos adotaram o modelo de tela única, como Arkanoid, Tetris, Bubble Shooter e Candy Crush Saga, apenas para citar alguns.
Um exemplo clássico foi o jogo Pitfall, que se tornou uma tendência para jogos de aventura, como Impossible Mission, e Prince of Persia.
Uma evolução deste estilo substituiu a troca súbita da tela em locais específicos pela rolagem da tela.
Agora, ao invés do personagem andar pela tela até atingir o ponto de alternância, ele fica posicionado em um local ou espaço determinado, e a tela se move como um todo no sentido oposto ao da movimentação do jogador.
Em termos práticos, temos um cenário de grandes dimensões e uma janela de visualização para uma área menor deste cenário, e esta janela é movida ao longo do cenário para trazer a sensação de movimento.
Esse modelo de apresentação do cenário pode apresentar diferentes estratégias de implementação, como:
Cinemachine é um conjunto de ferramentas para câmeras dinâmicas, inteligentes e que não precisam de programação, criado para obter os melhores enquadramentos na cena de acordo com a composição e interação, e que permite ajustar, iterar, experimentar e criar comportamentos de câmera em tempo real.
Não é um componente padrão do ambiente da Unity 3D e deve ser adicionado ao projeto por meio da divisão Asset Store, em que clicaremos em Search e procuraremos por Cinemachine.
Após encontrar o Cinemachine, clicaremos em Download e, depois de baixar o pacote, utilizaremos novamente o link, agora com o texto Import, o que abrirá a janela apresentada a seguir. Nesta janela, selecionaremos todos os componentes por meio do botão All e incluiremos com o clique em Import.
Ocorrerão alguns avisos referentes a uma anotação de código obsoleta, mas elas não irão impactar em nada. Portanto, não se preocupe.
Com a importação desse pacote, aparecerá um novo menu com o texto Cinemachine. Colocaremos a câmera principal novamente ao nível da cena, eliminando a dependência da personagem. Utilizaremos a opção de menu Cinemachine..Create 2D Camera.
Nosso objetivo inicial é que a câmera criada, CM vcam1, acompanhe a personagem, e, para conseguir esta configuração, o atributo Follow deverá ser associado a PennyPixel, por arraste ou seleção, enquanto o controle da abertura da câmera será dado pelo atributo Ortographic Size.
Ainda teremos o problema da queda infinita, mas o próximo passo irá resolvê-lo com o confinamento de câmera oferecido pelo Cinemachine.
Com o Inspector, na opção Add Extension da câmera virtual, adicionaremos CinemachineConfiner.
Serialização e persistência
Falando em termos de programação, quando objetos são instanciados, eles são ponteiros para regiões alocadas dinamicamente na memória, e cada atributo que seja um objeto apontará para outras regiões de memória.
Muitas vezes, precisamos guardar os objetos e recuperá-los posteriormente ou transmitir suas informações através de conexões de rede. Para estas operações não seria possível trabalhar com uma representação esparsa, exigindo uma sequencialização da informação.
A serialização é a técnica pela qual transformamos a representação em memória do estado atual do objeto em uma sequência de bytes, permitindo a transmissão via rede ou o armazenamento em meio físico.
O armazenamento em disco, com o objetivo de recuperação posterior, é chamado de persistência, e recebe este nome pelo fato de que a informação pode ser recuperada mesmo após a finalização da execução ou desligamento da máquina
Em nossos jogos é muito comum a necessidade de guardar a evolução do jogador para que ele possa encerrar uma partida e continuar em momento posterior de onde tinha parado, e para isso precisaremos trabalhar com o sistema de persistência da Unity 3D.
Normalmente, um jogador guarda sua evolução por meio de um SaveGame e, ao retornar ao jogo, ele pode recuperar o SaveGame e iniciar do último CheckPoint atingido.
Neste Script, observaremos a classe interna PlayerData, com os dados que serão gravados em disco e que receberão a anotação Serializable para se tornar serializável. Essa classe será utilizada nos métodos Salvar e Carregar para o armazenamento e recuperação da informação.
O atributo bf, do tipo BinaryFormatter, atuará nas ações de transformação do estado do objeto em uma sequência de bytes e na recuperação deste objeto a partir da sequência gerada, enquanto nomeArquivo definirá o nome completo do arquivo, a partir do caminho do jogo (persistentDataPath) e o nome do arquivo em si (playerInfo.dat), sendo ambos os atributos inicializados no método Start.
Já no método Carregar, inicialmente é feito um teste para saber se o arquivo existe e, caso ele exista, o arquivo é aberto para leitura e bf atua no sentido contrário, recuperando a informação serializada no arquivo para um novo objeto PlayerData.
Ao final, o arquivo é fechado e os dados obtidos são utilizados para atualizar o estado atual do jogo.
Construção de inventários
Um inventário é um conjunto de itens colecionáveis que podem ser coletados e utilizados em determinado instante do jogo. Normalmente, apresentam uma interpretação gráfica, com quantitativos para cada tipo de item.
A pontuação de nosso jogo será tratada como um inventário simples, apenas com a quantidade de três tipos de elementos colecionáveis.
Inteligência Artificial
Os modelos de Inteligência Artificial, ou simplesmente IA, são algoritmos que visam simular ações de inteligência, similares às humanas, porém em meio computacional.
As diversas técnicas de IA visam o aprendizado para a tomada de decisão, e um termo comum neste campo é a heurística, que trata de uma regra adotada na busca de soluções ou decisões.
Qualquer jogo que envolva movimentos autônomos deverá adotar regras heurísticas para a ação dos diversos personagens
No contexto da IA, os agentes inteligentes são programas com controle autônomo capazes de perceber o ambiente e se adaptarem às mudanças. Eles devem ser capazes de reconhecer outros agentes e tomar decisões, como fugir ou atacar.
Sistema de Navegação, ou Pathfinding, é uma das aplicações comuns de IA em jogos eletrônicos. De fato, a construção de um mundo virtual habitado por agentes autônomos que se movem com algum objetivo, como a perseguição ao jogador, requer a introdução de mecanismos que suportem essa navegação.
É interessante que naves inimigas saibam quando atirar, ou armadilhas sejam ativadas por proximidade. Nesses contextos, podemos utilizar técnicas de traçado de raios, em que uma linha detectará a presença de colisores em seu trajeto, viabilizando a tomada de decisão.
Com o uso da Unity 3D, temos dois métodos principais para o traçado de raios, que são o Raycast e o Linecast. A programação é muito direta, e pode ser plenamente aproveitada em eventos como Update e FixedUpdate.
Dispositivos de Entrada
Joystick
Os Joysticks foram sempre muito utilizados como padrão de entrada para jogos digitais. Embora tenham sido criados para o controle de aeronaves e elevadores, nos jogos eles evoluíram muito. Temos desde as versões analógicas até as digitais, inicialmente denominadas Gamepads.
Na Unity 3D, é possível capturar os movimentos do Joystick lendo o nível de deslocamento dos eixos vertical e horizontal da alavanca. Os valores capturados variam de -1 a 1, indicando o sentido e a intensidade de movimento em cada eixo.
Por exemplo, podemos implementar um controle simples para um carro no plano XY, em que o movimento vertical do Joystick definiria a velocidade, enquanto o eixo horizontal forneceria a rotação.
Trackball
Outro dispositivo de entrada que fez muito sucesso foi o Trackball. Trata-se de uma esfera sobre uma base, em que o jogador gira esta esfera com a palma da mão.
Mouse
Surgiram os Mouses, invertendo a posição da esfera, que girava sobre uma superfície, sendo posteriormente adotado um modelo ótico, que não precisa mais da esfera.
Captura de botões
A captura de botões em Joysticks e Mouses é feita com GetButton, como no exemplo seguinte,