O melhor guia para iniciantes no desenvolvimento de jogos no Unity

O Unity é uma ótima ferramenta para criar protótipos de tudo, desde jogos até visualizações interativas. Neste artigo, veremos tudo que você precisa saber para começar a usar o Unity.

Primeiro, um pouco sobre mim: sou um desenvolvedor de unidade hobbyist, modelador 3D e designer gráfico que trabalhou com Unity e Blender por mais de 5 anos. Agora sou um estudante de matemática financeira na University College Dublin e, ocasionalmente, faço design gráfico freelance, prototipagem web e prototipagem de jogos.

Introdução

Este artigo é direcionado a qualquer pessoa que nunca tenha usado o Unity antes, mas tenha alguma experiência anterior em programação ou em web design / desenvolvimento. Ao final deste artigo, você terá uma boa visão geral do mecanismo, bem como todas as funções e códigos necessários para começar a fazer um jogo básico.

Por que unidade?

Se você quer fazer jogos

Existem realmente poucas opções quando se trata de desenvolvimento de jogos indie. As três opções principais se você deseja criar jogos são Unreal, Unity ou GameMaker.

O Unity é provavelmente o menos opinativo das 3 plataformas. Ele oferece um produto bem cru pronto para uso, mas é altamente flexível, bem documentado e altamente extensível para construir praticamente qualquer gênero de jogo que você possa imaginar.

Existem muitos jogos de grande sucesso, como Escape from Tarkov (FPS), Monument Valley (Puzzler) e This War of Mine (Estratégia / Sobrevivência), todos construídos em Unity.

Na realidade, o motor no qual você construiu seu primeiro jogo provavelmente não é crítico, então meu conselho é apenas escolher um e seguir em frente.

Se você quiser fazer um protótipo de experiências do usuário

Uma vez que a unidade é apenas um mecanismo com um monte de física, animação e renderização 3D em tempo real, também é um ótimo espaço para fazer protótipos interativos completos para estudos de UX.

O Unity tem suporte total para VR e AR e, portanto, pode ser uma ótima ferramenta para explorar arquitetura, automações e simulações com clientes.

Seções deste artigo

  • Por que unidade?
  • Janela do Editor do Unity
  • Objetos de jogo Unity
  • Componentes integrados do Unity
  • Criação de componentes personalizados
  • Estrutura de um MonoBehaviour
  • Manipulando GameObjects
  • Raycasting
  • Detecção de colisão
  • Características avançadas
  • Conselhos para iniciantes
  • Recursos e comunidades agradáveis
  • Conclusão

Janela do editor do Unity

A janela do editor é dividida em algumas seções. Abordaremos isso muito brevemente, pois nos referiremos a ele constantemente ao longo do artigo. Se você já está familiarizado com isso, basta pular!

Scene View: Permite o posicionamento e movimento de GameObjects no Scene Game View: Visualiza como o jogador verá a cena da câmera Inspetor: Fornece detalhes sobre o GameObject selecionado na cena. Ativos / Projeto: Todos os pré-fabricados, texturas, modelos, scripts, etc., são armazenados aqui. Hierarquia: Permite aninhamento e estruturação de GameObjects dentro da cena

Agora estamos prontos para começar!

Objetos de jogo Unity

O que são GameObjects

GameObjects são o bloco de construção central de tudo no motor de jogos Unity. O nome quase denuncia:

Qualquer coisa que você colocar dentro de uma cena no Unity deve ser embrulhado em um 'objeto de jogo'.

Se você tem experiência em web design, pode pensar em GameObjects como sendo muito parecidos com elementos! Recipientes extremamente enfadonhos, mas são altamente extensíveis para criar funcionalidades ou visuais complexos.

Literalmente, tudo, desde efeitos de partículas, câmeras, jogadores, elementos de interface do usuário, ... (a lista continua) é um GameObject.

Criando Hierarquia

Como em desenvolvimento web, um GameObject também é um contêiner. Assim como você aninha s para criar layouts ou abstrações variadas e desejáveis, você pode desejar fazer o mesmo com objetos de jogos.

A lógica por trás do aninhamento de objetos do jogo é muito semelhante à do desenvolvimento web, darei alguns exemplos ...

Desordem e eficiência

Analogia da Web: você tem muitos elementos semelhantes que podem ser gerados dinamicamente em tempo real em resposta à interação do usuário e deseja mantê-los organizados. Tradução da unidade: Você está construindo um clone do Minecraft e tem muitos blocos na cena, você precisa adicionar e remover 'pedaços' de blocos da cena por motivos de desempenho. Portanto, faz sentido tê-los como pai para um GameObject vazio para cada bloco, pois a exclusão do bloco pai remove todos os blocos filhos.

Posicionamento

Analogia da Web: você deseja manter a posição do conteúdo contido 'em relação' ao contêiner e não à página da web. Tradução do Unity: Você criou um monte de drones auxiliares que pairam ao redor do jogador. Você realmente não preferiria escrever um código para dizer a eles para perseguir o jogador, então, em vez disso, instancie-os como filhos do objeto de jogo do jogador.

Componentes integrados do Unity

O modelo de componente do ator

Os GameObjects por si só são bastante inúteis - como vimos, eles são praticamente apenas contêineres. Para adicionar funcionalidade a eles, temos que adicionar componentes, que são essencialmente scripts escritos em C # ou Javascript.

O Unity funciona a partir de um modelo de componente de ator. Simplificando, os GameObjects são os atores e os componentes são seus scripts.

Se você já escreveu algum aplicativo da web antes, estará familiarizado com a ideia de criar pequenos componentes reutilizáveis, como botões, elementos de formulário, layouts flexíveis que têm várias diretivas diferentes e propriedades personalizáveis. Em seguida, reunir esses pequenos componentes em páginas da web maiores.

A grande vantagem dessa abordagem é o nível de reutilização e canais de comunicação claramente definidos entre os elementos. Da mesma forma, no desenvolvimento de jogos, queremos minimizar o risco de efeitos colaterais indesejados. Pequenos bugs tendem a ficar fora de controle se você não tomar cuidado e são extremamente difíceis de depurar. Assim, a criação de componentes pequenos, robustos e reutilizáveis ​​é crítica.

Principais componentes integrados

Acho que é hora de alguns exemplos dos componentes integrados fornecidos pelo motor Unity Games.

  • MeshFilter: Permite atribuir materiais a uma malha 3D para um GameObject
  • MeshRender: permite atribuir materiais a uma malha 3D
  • [Box | Mesh] Collider: Ativa a detecção de GameObject durante as colisões
  • Rigidbody: Habilita simulação física realista para agir em GameObjects com Malhas 3D e será o gatilho de eventos de detecção em aceleradores de caixa
  • Luz: ilumina partes de sua cena
  • Câmera: define a janela de visualização do jogador a ser anexada a um GameObject
  • Vários componentes da tela de interface do usuário para exibir GUIs

Há muito mais, mas esses são os principais com os quais você precisa se familiarizar. Uma dica é que você pode acessar todos os documentos por meio do manual do Unity e da referência de script off-line onde quer que esteja:

Criação de componentes personalizados

Os componentes internos controlam a física e os visuais principalmente, mas para realmente fazer um jogo, você precisará aceitar a entrada do usuário e manipular esses componentes padrão, bem como os próprios GameObjects.

Para começar a criar componentes, vá para o GameObject desejado> Adicionar componente> digite o nome do seu novo componente na barra de pesquisa> novo script (c #).

Como recomendação geral, desaconselho o uso de Javascript no Unity. Ele não foi mantido atualizado com todas as ótimas coisas que vieram com o ES6, e a maioria das coisas mais avançadas dependem de coisas C # portadas para Javascript ... Na minha experiência, tornou-se apenas uma solução alternativa.

Estrutura de um MonoBehaviour

Principais funções

Todos os componentes são herdados da classe MonoBehaviour. Inclui vários métodos padrão, o mais importante:

  • void Start () que é chamado sempre que um objeto contendo o script é instanciado na cena. Isso é útil sempre que quisermos executar algum código de inicialização, por exemplo. definir o equipamento de um jogador após eles aparecerem em uma partida.
  • void Update () que é chamado de cada quadro. É para onde vai a maior parte do código que envolve a entrada do usuário, atualizando várias propriedades, como o movimento do jogador na cena.

Variáveis ​​de inspetor

Freqüentemente, queremos tornar os componentes o mais flexíveis possível. Por exemplo, todas as armas podem ter um dano, taxa de tiro, has_sight diferente, etc. Embora todas as armas sejam essencialmente iguais, podemos querer ser capazes de criar variações diferentes rapidamente através do editor de unidade.

Outro exemplo em que podemos desejar fazer isso é ao criar um componente de IU que rastreia os movimentos do mouse do usuário e coloca um cursor na janela de visualização. Aqui, podemos querer controlar a sensibilidade do cursor aos movimentos (se o usuário estiver usando um joystick ou gamepad em vez de um mouse de computador). Portanto, faria sentido ter essas variáveis ​​fáceis de alterar no modo de edição e também experimentá-las durante o tempo de execução.

Podemos fazer isso facilmente, simplesmente declarando-os como variáveis ​​públicas no corpo do componente.

Aceitando entrada do usuário

Claro, queremos que nosso jogo responda à entrada do usuário. As maneiras mais comuns de fazer isso são usando os seguintes métodos na função Update () de um componente (ou em qualquer outro lugar que você desejar):

  • Input.GetKey (KeyCode.W) Retorna True W; a tecla está sendo mantida pressionada
  • Input.GetKeyDown (KeyCode.W) Retorna True quando a tecla W é pressionada pela primeira vez
  • Input.GetAxis (“Vertical”), Input.GetAxis (“Horizontal”) Retorna entre -1,1 movimento de entrada do mouse

Manipulando GameObjects

Assim que tivermos a entrada do usuário, queremos que GameObjects em nossa cena respondam. Existem vários tipos de respostas que podemos considerar:

  • Translação, rotação, escala
  • Crie novos GameObjects
  • Enviar mensagens para GameObjects / componentes existentes

Transformações

Todos os GameObjects têm uma propriedade de transformação que permite que várias manipulações úteis no objeto do jogo atual sejam realizadas.

Os métodos acima são bastante autoexplicativos, apenas observe que usamos gameObject em minúsculas para nos referirmos ao GameObject que possui esta instância específica do componente.

Em geral, é uma boa prática usar local [Posição, Rotação] em vez da posição / rotação global de um objeto. Isso geralmente torna mais fácil mover objetos de uma maneira que faça sentido, já que o eixo do espaço local será orientado e centralizado no objeto pai em vez da origem do mundo e nas direções x, y, z.

Se precisar converter entre o espaço local e mundial (o que geralmente é o caso), você pode usar o seguinte:

Como você pode imaginar, existe uma álgebra linear bastante simples por trás disso, sugerida pelo 'Inverse' no nome do método.

Criação de novos GameObjects

Já que GameObjects são basicamente tudo em sua cena, você pode querer ser capaz de gerá-los na hora. Por exemplo, se o seu jogador tem algum tipo de lançador de projéteis, você pode querer ser capaz de criar projéteis durante o voo, que tenham sua própria lógica encapsulada para voar, lidar com danos, etc ...

Primeiro, precisamos apresentar a noção de um Prefab . Podemos criá-los simplesmente arrastando qualquer GameObject na hierarquia da cena para a pasta de ativos.

Isso basicamente armazena um modelo do objeto que acabamos de ter em nossa cena com todas as mesmas configurações.

Assim que tivermos esses componentes pré-fabricados, podemos atribuí-los às variáveis ​​do inspetor (como falamos anteriormente) em qualquer componente da cena, para que possamos criar novos GameObjects conforme especificado pelo pré-fabricado a qualquer momento.

Podemos então executar a 'instanciação' do pré-fabricado e manipulá-lo para o local desejado na cena e estabelecer as relações parentais necessárias.

Acessando outros GameObjects e componentes

Freqüentemente, precisamos nos comunicar com outros GameObjects, bem como com seus componentes associados. Depois de ter uma referência a um objeto do jogo, isso é muito simples.

ComponentName comp = some_game_object.GetComponent ();

Depois disso, você pode acessar qualquer um dos métodos / variáveis ​​públicos do componente para manipular o GameObject. Esta é a parte direta, no entanto, obter a referência para o GameObject pode ser feito de várias maneiras ...

Acesso via variável inspetor

Este é o mais simples. Simplesmente crie uma variável pública para o GameObject, como demonstramos anteriormente com os prefabs, e arraste e solte-a manualmente no componente por meio do inspetor. Em seguida, acesse a variável como acima.

Acesso por meio de marcação

Podemos marcar GameObjects ou prefabs por meio do inspetor e, em seguida, usar as funções de localização de objetos do jogo para localizar referências a eles.

Isso é feito simplesmente conforme abaixo.

GameObject some_game_object = GameObject.FindGameObjectWithTag (“Brick”);

Acesso via transformação

Se desejarmos acessar componentes em algum objeto pai, podemos fazer isso facilmente por meio do atributo transform.

ComponentName comp = gameObject.transform.parent.GetComponent ();

Acesso via SendMessage

Alternativamente, se quisermos enviar uma mensagem para muitos outros componentes ou desejarmos enviar uma mensagem para um objeto que está muito acima em uma hierarquia aninhada, podemos usar as funções de envio de mensagem, que aceitam o nome da função seguido pelos argumentos.

gameObject.SendMessage (“MethodName”, params); // Transmitir messagegameObject.SendMessageUpwards (“MethodName”, params); // Recebido apenas por componentes aninhados acima.

Raycasting

Você pode ter ouvido falar disso antes, quando as pessoas comparam jogos FPS que são 'baseados na física' ou 'baseados em raios'. Raycasting é essencialmente como ter um apontador laser que, ao entrar em contato com um 'colisor' ou 'corpo rígido', retorna um 'golpe' e devolve os detalhes do objeto.

Existem dois cenários em que isso é útil (provavelmente há muitos outros):

  1. Se você estivesse projetando um sistema de armas para um jogo, você poderia usar raycasting para detecção de acerto e até mesmo personalizar o comprimento do raio para que os itens corpo a corpo 'acertem' apenas em curtas distâncias
  2. Crie um raio do ponteiro do mouse para um ponto no espaço 3D, ou seja, se você deseja que o usuário seja capaz de selecionar unidades com o mouse em um jogo de estratégia.

Como você pode ver, o código para isso é um pouco mais complexo. O principal a ser entendido é que lançar um raio para onde o mouse está apontando no espaço 3d requer a transformação ScreenPointToRay. A razão para isso é que a câmera está renderizando um espaço 3D como uma janela de visualização 2d na tela do seu laptop, então, naturalmente, há uma projeção envolvida para transferir de volta para 3D.

Detecção de colisão

Anteriormente, mencionamos os componentes Collider e Rigidbody, que podem ser adicionados a um objeto. A regra para colisões é que um objeto na colisão deve ter um corpo rígido e o outro um colisor (ou ambos têm ambos os componentes). Observe que ao usar o raycasting, os raios irão interagir apenas com objetos com componentes de colisor anexados.

Após a configuração em qualquer componente personalizado anexado ao objeto, podemos usar os métodos OnCollisionEnter, OnCollisionStay e OnCollisionExit para responder às colisões. Assim que tivermos as informações de colisão, podemos responsabilizar o GameObject e usar o que aprendemos anteriormente para interagir com os componentes anexados a ele.

Uma coisa a notar é que os corpos rígidos fornecem física, como gravidade para objetos, então se você quiser que isso seja desligado, você precisará marcar is_kinematic ligado.

Características avançadas

Não entraremos em nada disso agora, mas talvez em um artigo futuro - apenas para alertá-lo de que eles existem.

Criando GUI's

O Unity possui um mecanismo de interface do usuário totalmente desenvolvido para definir a GUI do seu jogo. Em geral, esses componentes funcionam de forma bastante semelhante ao resto do motor.

Estendendo o Editor do Unity

O Unity permite que você adicione botões personalizados aos seus inspetores para que você possa afetar o mundo durante o modo de edição. Por exemplo, para ajudar na construção de mundos, você pode desenvolver uma janela de ferramenta personalizada para a construção de casas modulares.

Animação

O Unity possui um sistema de animação baseado em gráficos que permite a você combinar e controlar animações em vários objetos, como jogadores implementando um sistema de animação baseado em ossos.

Materiais e PBR

O Unity funciona com um mecanismo de renderização baseado em física que permite iluminação em tempo real e materiais realistas. A realidade é que você precisará aprender a modelagem 3D primeiro ou usar modelos feitos e otimizados por outra pessoa antes de começar a fazer isso, a fim de fazer coisas que realmente parecem boas.

Conselhos para iniciantes

Se você está planejando escrever seu primeiro jogo, não subestime a complexidade e o tempo que leva para escrever até mesmo o mais trivial dos jogos. Lembre-se de que a maioria dos jogos lançados no Steam tem equipes trabalhando neles por anos em tempo integral!

Escolha um conceito simples e divida-o em pequenos marcos alcançáveis. É altamente recomendável separar o jogo nos menores componentes independentes possíveis, pois é muito menos provável que você encontre bugs se manter os componentes simples em vez de blocos de código monolíticos.

Antes de escrever qualquer código para qualquer parte do seu jogo, pesquise o que outra pessoa fez antes para resolver o mesmo problema - é provável que eles tenham uma solução muito mais engenhosa.

Recursos e comunidades agradáveis

O design de jogos tem uma das melhores comunidades do mundo, e há muitos profissionais altamente qualificados na indústria que colocam conteúdo de graça ou quase sem pagar. É um campo que requer modeladores 3D, artistas conceituais, designers de jogos, programadores e assim por diante. Vinculei alguns excelentes recursos gerais que encontrei para cada um desses campos abaixo:

Arte conceitual

  • Feng Zhu Design School (tutoriais de arte conceitual com mais de 90 horas de duração)
  • Tyler Edlin Art (ótima comunidade de arte BST com feedback dos profissionais sobre os desafios mensais)
  • Art Cafe (entrevistas e workshops com artistas conceituais famosos)
  • Trent Kaniuga (ilustrador e artista 2D que também está fazendo seu próprio jogo)

Modelagem 3D

  • CG Cookie (O melhor básico de modelagem de malha no Blender de todos os tempos, eles têm muitos outros conteúdos excelentes para o blender)
  • Tor Frick (modeladores e escultores de superfícies duras no Blender)
  • Gleb Alexandrov (tutoriais curtos e poderosos de renderização no Blender)

Design de jogo

  • DoubleFine Amnesia Fortnight (GameDevs que fazem um hackathon de 2 semanas e registram todo o seu processo de design)
  • GameMakers Toolkit (examina os princípios de design de jogos)

Programação

  • Handmade Hero (escrevendo um jogo e um motor do zero em C)
  • Jonathan Blow (dev Indie que transmite ao vivo o desenvolvimento de seu jogo)
  • Chaves (bons tutoriais do Unity)

Conclusão

Espero que tenham gostado deste tutorial! Eu faço um pouco de trabalho de design gráfico, bem como protótipos de jogos e UI, então confira meu portfólio ! Também estou ligado em .

Portfólio| LinkedIn