Programando um jogo com unidade: um guia para iniciantes

Propaganda

Uma característica surpreendente da economia da Internet é a ascensão dos videogames independentes. Uma vez que o domínio exclusivo de estúdios A de mil milhões e milhões de dólares, vários conjuntos de ferramentas foram desenvolvidos leve recursos modernos de desenvolvimento de jogos para as mãos de indivíduos ou pequenas coleções ad-hoc de programadores e designers. Nós discutimos anteriormente o melhores jogos indie 10 jogos independentes tão bons que você esquecerá que eles são independentesPode haver momentos, no entanto, em que você deseja algo diferente da norma indie. Um jogo que segue valores independentes, mas é feito com a qualidade pela qual os jogos AAA de primeira linha são conhecidos. Títulos como ... consulte Mais informação , verifique se há alguma inspiração sobre o que pode ser alcançado com ferramentas como o Unity.

Essas equipes de desenvolvimento de jogos independentes demonstraram uma agilidade e tolerância a riscos que, em muitos casos, lhes permitem impulsionar a inovação de jogo mais rapidamente do que seus grandes parceiros de orçamento. Uma série de títulos indie surpreendentemente bem-sucedidos estreou nos últimos anos, incluindo Minecraft, Limboe Super Meat Boy, e mesmo se você não tiver habilidades para criar jogos como esse, poderá faça um jogo usando o Buildbox Como criar um videogame em uma semana usando o BuildboxExiste um programa que torna o desenvolvimento de jogos incrivelmente fácil, mesmo para aqueles que não têm absolutamente nenhuma experiência em projetar videogames. Chama-se Buildbox. Aqui está o porquê você deve tentar. consulte Mais informação .

No cenário em rápida evolução do desenvolvimento de jogos independentes, Unidade surgiu como um padrão de fato: seu baixo custo, facilidade de uso e amplo conjunto de recursos o tornam ideal para o desenvolvimento rápido de jogos. A unidade é tão flexível que você pode até crie seus próprios controladores de jogo personalizados Como criar um controlador de jogo personalizado com o Arduino e o UnityVocê já quis projetar seu próprio controlador de jogo? É mais fácil do que você pensa! consulte Mais informação com um pouco de DIY sabe como!

Até grandes estúdios como o CCP (Developers of Eve Online) use-o para prototipar rapidamente os conceitos de jogos. O Unity fornece um “mecanismo de jogo em uma caixa” - um mecanismo de física e renderização com ganchos para várias linguagens de script, adaptável a praticamente qualquer gênero de videogame.

Embora o Unity forneça um editor visual para manipular o ambiente do jogo, o Unity não é uma ferramenta de criação de jogos de 'programação zero'. Ele exige que você programe para produzir resultados, mas também oferece uma ferramenta muito mais flexível e poderosa do que qualquer programa de "criador de jogos" poderia.

O Unity não fará o trabalho para você, mas reduz substancialmente a barreira à entrada. Começando completamente do zero com C ++ e OpenGL, pode levar dias para chegar ao ponto em que realmente há algo renderizado na tela. Usando o Unity, leva cerca de dez segundos. O Unity coloca os elementos básicos da criação de jogos nas mãos de programadores iniciantes de maneira rápida e intuitiva.

Hoje vou orientá-lo em tudo o que você precisa saber para criar um jogo no Unity, dividido em dez capítulos principais:

§1 - Versões de unidade

§2 - Instalando a unidade

§3 - Uma Breve Introdução ao Paradigma Orientado a Objetos

§4 - Fundamentos da unidade

§5 - Exemplo: Elementos básicos de um jogo

§6 - Script no Unity

§7 - Exemplo: Script Pong

§8 - Explorando a documentação / aprendendo mais

§9 - Criando seu jogo / compilando em um aplicativo independente

§10-Notas de encerramento

1. Versões do Unity

Unidade vem em dois sabores básicos: a versão pro e a versão gratuita. Há um número de diferenças, mas, em termos gerais, a versão pro suporta várias melhorias visuais (como sombras suaves em tempo real e pós-processamento) e um grande número de recursos relativamente menores que são extremamente úteis para jogos

Dito isto, para a maioria dos jogos relativamente simples que você pode querer criar, a versão gratuita do Unity é perfeitamente adequada. Vamos detalhar as principais diferenças abaixo com mais detalhes para os interessados.

1.1 Preços

A versão gratuita do Unity é, é claro, gratuita. No entanto, existem algumas limitações: a versão gratuita do Unity não pode ser licenciada para nenhuma empresa com uma renda anual superior a $100,000. Embora essas organizações estejam além do escopo deste guia, se você suspeitar que possa se tornar uma organização, provavelmente é aconselhável optar pela versão Pro.

A versão Pro do Unity é $75 um mês ou $1500 para uma licença permanente e não tem limites para o que você pode fazer com os jogos criados com ela. Há também uma avaliação gratuita de 30 dias, que usaremos neste guia, para fornecer a você uma visão geral mais completa dos recursos disponíveis. Uma licença de estudante de um ano também está disponível através do Studica para $129.

1.2 Recursos

Existem muitos recursos ausentes na versão gratuita do Unity. No entanto, as diferenças mais importantes são as seguintes: a versão gratuita do Unity carece de várias opções de renderização que permitem jogos com melhor aparência e execução mais rápida (suporte a LOD, pós-processamento no espaço na tela, shaders avançados, sombras suaves em tempo real e diferido Renderização). Também não possui o total sistema de animação mechanime algumas ferramentas de IA.

Em geral, para projetos complexos e de larga escala, ou projetos em que o desempenho gráfico é importante, a versão pro vale a pena. Eu uso a versão pro, porque desenvolvo jogos de realidade virtual para o Oculus Rift Revisão de Oculus RiftA realidade virtual não é nova, mas é finalmente acessível e ao nosso alcance. Após quatro anos e dois protótipos de desenvolvimento, chegou a edição final do consumidor do Oculus Rift. consulte Mais informação , e o suporte ao pós-processamento do espaço na tela é necessário para interagir corretamente com o fone de ouvido.

2. Instalando o Unity

A unidade é simples de instalar. Você pode baixar o executável em unity3d.com/get-unity/download.

Depois de baixado, execute-o e siga as instruções do instalador. Quando a instalação terminar, uma janela intitulada 'ativar sua licença do Unity' será exibida. Marque a caixa marcada "ativar uma avaliação gratuita de 30 dias do Unity Pro" e, em seguida, "OK".

Parabéns! Agora você tem uma avaliação de 30 dias do Unity Pro. Quando a avaliação expirar, se você não quiser comprar a versão pro, poderá mudar para a versão gratuita e manter o conteúdo existente.

3. Uma Breve Introdução ao Paradigma Orientado a Objetos

Antes de começar o Unity, é importante que repassemos um pouco o básico. Unity suporta ambos C # e Javascript para programação de jogos 7 idiomas de desenvolvimento de jogos da Unity para aprender: qual é o melhor?Deseja iniciar o desenvolvimento de jogos no Unity? Você precisará familiarizar-se com um desses idiomas compatíveis com o Unity. consulte Mais informação ; trabalharemos com C # para este tutorial.

Primeiro, se você nunca programou antes, deixe este tutorial de lado e passe alguns dias trabalhando nos programas da Microsoft. Primer de linguagem C # até você se sentir confortável usando o idioma para tarefas simples.

Se você quiser algo um pouco diferente de C # (mas não necessariamente um idioma que possa usar no Unity), consulte nosso guia para o seis linguagens de programação mais fáceis para iniciantes 6 idiomas de programação mais fáceis de aprender para iniciantesAprender a programar é encontrar o idioma certo tanto quanto o processo de edificação. Aqui estão as seis principais linguagens de programação mais fáceis para iniciantes. consulte Mais informação .

Se você programou anteriormente em uma linguagem imperativa ou orientada a objetos, como C ou Java, passe o primer e familiarize-se com o modo como o C # difere de outras linguagens que você usou no passado. De qualquer forma, não prossiga com o tutorial até que você se sinta à vontade para resolver problemas simples com C # (por exemplo, se eu perguntar para escrever um programa que imprima os primeiros cem números primos, você poderá escrever esse programa sem consultar Google).

O conceito mais importante para entender aqui é o paradigma orientado a objetos De onde veio a programação "orientada a objetos"?Orientado a objetos não é apenas uma palavra-chave aleatória que você ouve nos círculos de programação. Há uma razão por trás do nome - mas o que? Junte-se a mim enquanto eu exploro alguns dos fundamentos dos conceitos de programação e explico ... consulte Mais informação (abreviado como OOP). Em linguagens orientadas a objetos, os programas são divididos em unidades funcionais chamadas Objetos. Cada objeto tem suas próprias variáveis ​​e funções privadas. Funções específicas de objetos são chamadas métodos.

A idéia aqui é modularidade: isolando cada objeto e forçando outros objetos a interagir com ele através de seus métodos, você pode reduzir o número de possíveis interações não intencionais - e, por extensão, insetos. Você também pode criar objetos que podem ser reutilizados posteriormente sem nenhuma modificação. No Unity, você criará esses objetos e os anexará a entidades de jogo (cujo comportamento eles governarão).

Objetos são instanciados de Aulas: uma classe é apenas um arquivo que define a definição do seu objeto. Então, se você quer um Mook objeto que lida com IA para um inimigo em seu jogo, você escreveria uma classe 'Mook' e anexaria esse arquivo a todas as entidades inimigas. Quando você executa seu jogo, cada inimigo será equipado com uma cópia do objeto 'Mook'.

Anexar um novo script a um objeto fica assim:

Primeiro, selecione o objeto e vá para o Inspetor. Clique no Adicionar componente botão.

Vamos para novo script, digite o nome desejado e clique em criar e adicionar.

Agora você tem um novo script que pode ser editado clicando duas vezes nele!

Um arquivo de classe é mais ou menos assim:

using UnityEngine; classe pública Mook: MonoBehaviour {saúde do flutuador privado; void Start () {saúde = 100; } void Update () {if (health> 0) {/ * Procure o jogador se encontrar o jogador na estrada, mate-o se levar um tiro, remova uma quantidade aleatória de pontos de vida * /}} }

Vamos dividir isso:

• Usando o UnityEngine: Essa linha informa ao C # que queremos usar as bibliotecas do Unity, o que nos permite conectar ao mecanismo de jogo do Unity.
• Classe pública Mook: MonoBehaviour:Esta linha declara a classe e seu nome - Mook.
• Integridade do flutuador privado: Isso declara uma variável de classe privada (que só pode ser alterada de dentro da classe). A variável recebe um valor em Começar.
• Início nulo (): Isso declara um método chamado Começar. Iniciar é um método especial que é executado apenas uma vez, quando o jogo é iniciado inicialmente.
• Atualização de cancelamento (): A atualização é outro método especial, executado em todos os quadros. A maior parte da lógica do seu jogo vai aqui.
• // se você encontrar o jogador na estrada, mate-o: Esta linha é um comentário (qualquer linha que comece com uma barra dupla é ignorada pelo C #). Os comentários são usados ​​para lembrar o que partes específicas do código fazem. Nesse caso, esse comentário está sendo usado para substituir um bloco de código mais complicado que realmente faz o que o comentário descreve.

Junto com Começar e Atualizar, você pode instanciar seus próprios métodos com quase qualquer nome. No entanto, os métodos que você cria não serão executados, a menos que sejam chamados. Vamos declarar um método para uma classe hipotética chamada addTwoNumbers que adiciona dois números:

public float addTwoNumbers (float a, float b) {retorna a + b; }

Isso declara um método público (acessível a outros objetos) que retorna um float, chamado addTwoNumbers, que recebe dois flutuadores como entrada (chamada uma e b). Em seguida, ele retorna a soma dos dois valores como saída.

Chamar esse método de dentro da mesma classe (digamos, de dentro Atualizar) se parece com isso:

resultado flutuante = addTwoNumbers (1, 2);

Chamar o método de outra classe é semelhante:

instância addTwoNumbers; resultado flutuante = instance.addTwoNumbers (1, 2);

Novamente, isso apenas cria uma instância da nossa classe, acessa o método apropriado e alimenta os números que queremos adicionar e, em seguida, armazena o resultado em resultado. Simples.

Se o seu script estiver anexado a um objeto que possui propriedades especiais (como um emissor de partículas) que não podem ser acessadas sob o conjunto normal de parâmetros GameObject, você pode tratá-lo como um tipo diferente de entidade do jogo usando a GetComponent método.

A sintaxe para isso é assim:

GetComponent().Jogar();

Se algo disso não lhe é familiar, volte e passe pelo iniciador C #. Isso poupará muita frustração à medida que prosseguimos.

4. Unity Basics

Nesta seção, vamos trabalhar o caminho através da mecânica básica do mecanismo Unity. O fluxo de trabalho no Unity é mais ou menos assim:

1. Crie uma entidade para desempenhar um papel no jogo (em branco GameObjects pode ser usado para tarefas lógicas abstratas).
2. Escreva ou encontre um arquivo de classe e adicione-o à entidade como um script (usando o Adicionar componente botão no inspetor Visão.
3. Corre > teste > depurar > repetir até que funcione e passe para o próximo elemento do jogo.

O Unity vem com várias guias de exibição básicas que podem ser dispostas de várias maneiras, conforme o gosto do usuário. Os cinco grandes são:

1. Jogos: exibe uma instância em execução do jogo com a qual você pode interagir e testar.
2. Cena: fornece uma versão estática e editável do mundo dos jogos.
3. Inspetor: permite modificar entidades individuais no mundo do jogo, selecionando-as no editor aba.
4. Projeto: permite navegar pelos arquivos do projeto e arrastar modelos, materiais e outros recursos para o diretório editor guia para colocá-los no mundo do jogo.
5. Hierarquia: essa guia mostra todos os objetos no mundo, permitindo encontrar objetos distantes na cena e entidades-mãe entre si, clicando e arrastando.

Veja o diagrama abaixo para os locais de todas essas coisas:

4.1 Entidades da unidade

4.1.1 Malhas

Malhas são o caminho Geometria 3D é representado na unidade. Você pode usar o built-in do Unity primitivo objetos (cubos, esferas, cilindros etc.) ou importe seus próprios modelos 3D de um pacote de modelagem como Liquidificador Introdução ao Blender: 7 tutoriais fantásticos para iniciantesA modelagem 3D é uma excelente maneira de exercitar a criatividade, mantendo contato com seu lado técnico. Aqui estão alguns tutoriais gratuitos impressionantes. consulte Mais informação ou Maya Aprendendo o Maya 2016: por onde começarO Maya é uma ferramenta usada para animação 3D, mas vem com uma curva de aprendizado incrivelmente íngreme. Que bom material de ensino existe? consulte Mais informação . O Unity suporta uma variedade de formatos 3D, incluindo .fbxe .3ds.

As ferramentas básicas para manipulação de malhas são os botões de escala, rotação e conversão no canto superior esquerdo da interface. Esses botões adicionam ícones de controle aos modelos na visualização do editor, que podem ser usados ​​para manipulá-los no espaço. Para alterar as propriedades de textura ou física de um objeto, selecione-as e use o inspetor vista para analisar o material e corpo rígido elementos.

4.1.2 Elementos da GUI

Sprites e texto da GUI tradicional podem ser exibidos usando o Texto da GUI e a Textura da GUI GameObjects no editor. No entanto, uma maneira mais robusta e realista de lidar com elementos da interface do usuário é usar o Texto 3D e Quad GameObjects (com texturas transparentes e um sombreador transparente apagado) para colocar elementos HUD no mundo do jogo como entidades.

No hierarquia vista, esses elementos de jogabilidade podem ser arrastados para a câmera principal para torná-los filhos, garantindo que eles se movam e girem com a câmera.

Os elementos da GUI (texto e texturas) podem ter seu tamanho e escala ajustados usando os campos relevantes na guia Inspetor.

4.1.3 Materiais

Materiais são combinações de texturas e shaders Cinco importantes termos de jogos para PC explicadosSe você joga um jogo em um console, os detalhes técnicos são tratados por você. Alguns jogadores preferem isso, mas os jogadores de PC geralmente desfrutam do maior grau de controle que têm sobre os olhos de um jogo ... consulte Mais informação , e pode ser arrastado diretamente para os objetos do jogo na guia Projeto. Um grande número de shaders vem com o Unity Pro, e você pode ajustar a textura anexada a eles usando a guia Inspetor para um objeto ao qual eles são aplicados.

Para importar uma textura, converta-a em um .jpg, .pngou .bmpe arraste-o para o ativos pasta no diretório do projeto do Unity (que aparece em Meus documentos por padrão). Após alguns segundos, uma barra de carregamento aparecerá no editor. Quando terminar, você poderá encontrar a imagem como uma textura sob o projeto aba.

4.1.5 Luzes

Luzes são GameObjects que projetam brilho para o mundo. Se não houver luzes em sua cena, todos os polígonos são desenhados no mesmo nível de brilho, dando ao mundo uma aparência plana e desbotada.

As luzes podem ser posicionadas, giradas e têm várias características internas que você pode personalizar. o intensidade O controle deslizante controla o brilho da luz e o alcance controla a rapidez com que desaparece.

As diretrizes no vista da cena mostra o alcance máximo da iluminação. Jogue com as duas configurações para obter o efeito desejado. Você também pode ajustar a cor da luz, o padrão (bolacha exibido na superfície para a qual a luz é apontada e que tipo de reflexo aparece na tela ao olhar diretamente para a luz. O cookie pode ser usado para falsificar padrões de luz mais realistas, criar sombras falsas dramáticas e simular projetores.

Os três principais tipos de luz são local, pontoe direcional.

Luzes do ponto tenha uma localização no espaço 3D e projete a luz apenas em uma direção em um cone de ângulo variável. Eles são bons para lanternas, holofotes e, em geral, oferecem um controle mais preciso da iluminação. As luzes do ponto podem projetar sombras.

Luzes pontuais tenha uma localização no espaço 3D e projete luz uniformemente em todas as direções. As luzes pontuais não projetam sombras.

Luzes direcionais, finalmente, são usados ​​para simular a luz solar: projetam a luz em uma direção como se fosse infinitamente distante. As luzes direcionais afetam todos os objetos da cena e podem produzir sombras.

4.1.6 Sistemas de partículas

UMA Sistema de partículas é um GameObject que gera e controla centenas ou milhares de partículas simultaneamente. Partículas são pequenos objetos 2D otimizados exibidos no espaço 3D. Os sistemas de partículas usam renderização e física simplificadas, mas podem exibir milhares de entidades em tempo real sem gaguejar, tornando-as ideais para fumaça, fogo, chuva, faíscas, efeitos mágicos e muito mais.

Há muitos parâmetros que você pode ajustar para obter esses efeitos e pode acessá-los gerando um sistema de partículas sob o editor de componentes > selecionando o sistema de partículas > abrindo a guia do inspetor. Você pode alterar o tamanho, a velocidade, a direção, a rotação, a cor e a textura de cada partícula e definir a maioria desses parâmetros para mudar com o tempo.

Debaixo de colisão atributo, se você ativá-lo e configurar o espaço de simulação para mundo você receberá partículas que colidirão com objetos no mundo, que podem ser usadas para vários efeitos realistas, incluindo chuva, água em movimento e faíscas.

5. Exemplo: Elementos Básicos de um Jogo

Neste tutorial, vamos fazer um jogo simples de Pong - algo que abordamos várias vezes no DIY antes:

• Arduino Classic Pong Como recriar o jogo Pong clássico usando o ArduinoPong foi o primeiro videogame que chegou ao mercado de massa. Pela primeira vez na história, o conceito de "videogame" foi trazido para a casa da família, graças ao Atari 2600 -... consulte Mais informação
• Arduino OLED Pong Arduino Retro Gaming com um display OLEDJá imaginou quanto trabalho é necessário para escrever seus próprios jogos retrô? Quão fácil é Pong codificar para o Arduino? consulte Mais informação

Nesta seção, discutiremos a organização dos elementos principais - o tutorial sobre scripts será publicado mais tarde.

Primeiro, vamos dividir o jogo de Pong em seus componentes básicos. Primeiro, precisamos de duas raquetes e uma bola. A bola voa para fora da tela, então queremos um mecanismo para redefini-la. Também queremos que o texto exiba a pontuação atual e, com o objetivo de mostrar todos os elementos principais do Unity, queremos um efeito de partícula sofisticado quando você bater na bola. O jogo inteiro precisará ser dramaticamente iluminado.

Que se divide em um objeto de bola (uma esfera), um criador, dois suportes de remo com emissores de partículas anexado um Entidade de texto 3De um Holofote. Neste tutorial, usaremos o material físico padrão pulocom combinar salto definido como multiplicar. Veja como é a configuração em dez capturas de tela:

Primeiro, crie um suporte de cubo para a raquete.

Escale-o adequadamente, duplicá-loe coloque um esfera entre os remos para a bola.

Em seguida, crie um Objeto 3DText e escala e posição corretamente, alterando o tamanho da fonte atributo para obter uma imagem menos pixelizada.

Em seguida, crie dois sistemas de partículas, escolha as características desejadas e prenda-as nas pás.

Em seguida, você deseja posicione e gire a câmera para enquadrar a cena corretamente. Enquanto a câmera está selecionada, você pode ver uma pequena visualização da visualização da câmera no canto inferior direito.

Antes de terminarmos, precisamos criar dois cubos adicionais para serem amortecedores, para impedir que a bola salte para fora da área de jogo. Podemos torná-los invisíveis desmarcando o renderizador de malha no guia inspetor.

Se você jogar, agora pode ver os elementos básicos do nosso jogo. Eles ainda não fizeram nada, mas vamos conseguir!

Agora que temos essa configuração, falaremos sobre o que está envolvido no script desses elementos para criar um jogo.

6. Script no Unity

Depois de anexar um script a um objeto, você pode revisá-lo clicando duas vezes nele inspetor. Isso abre MonoDevelop, o ambiente de desenvolvimento padrão para o Unity. Em essência, o Monodevelop é um editor de texto com recursos especificamente otimizados para a programação.

Palavras-chave e comentários são destacados em azul e verde, e valores e seqüências numéricos aparecem em vermelho. Se você já usou Eclipse ou outros IDEs, o MonoDevelop é muito semelhante. Você pode Construir seus scripts de dentro do editor, para verificar se há erros de sintaxe, da seguinte maneira:

Em geral, para que seu script interaja com o Unity, é necessário fazer referência aos elementos que o objeto que contém o script (você pode ver uma lista desses elementos sob o inspetor guia quando o objeto relevante for selecionado). Você pode chamar métodos ou definir variáveis ​​para cada um desses elementos para executar as alterações desejadas.

Se você deseja que um script em um objeto afete as propriedades de um objeto diferente, é possível criar um GameObject variável em seu script e use o inspetor para atribuí-lo a outro objeto na cena.

Uma lista dos elementos que um objeto pode ter é a seguinte (extraída da visualização do inspetor de um de nossos remos no exemplo acima):

1. Transformar
2. Cubo (filtro de malha)
3. Box Collider
4. Renderizador de malha

Cada um desses aspectos do objeto pode ser influenciado de dentro de um script. A seguir, veremos exatamente como.

6.1 Transformação

As funções de transformação para um GameObject no Unity controlam os parâmetros físicos desse objeto: seu escala, Está posição, e os seus orientação. Você pode acessá-los a partir de um script como este:

transform.position = newPositionVector3; transform.rotation = newRotationQuaternion; transform.localScale = newScaleVector3;

Nos exemplos acima, as variáveis ​​nomeadas são dos tipos especificados nos nomes. Existem alguns detalhes importantes aqui: posição e escala são, como você esperava, armazenadas como Vector3s. Você pode acessar o X, Ye Z componentes de cada um (por exemplo, transform.position.y fornece a distância de um objeto acima do plano zero).

No entanto, para evitar fechadura de cardan, as rotações são tratadas como Quaternions (vetores de quatro componentes). Como os quaternions de manipulação manual não são intuitivos, você pode manipular rotações usando ângulos eulerianos usando o Quaternion. Euler método da seguinte maneira:

transform.rotation = Quaternion. Euler (pitch, yaw, roll);

Se você deseja mover objetos sem problemas de um lugar para outro, encontrará o Slerp método para quaternions e vector3s útil. Slerp usa três argumentos - o estado atual, o estado final e a velocidade da mudança, e interpola suavemente entre eles na velocidade especificada. A sintaxe é assim:

transform.position = Vector3.Slerp (startPositionVector3, newDestinationVector3, 1);

6.2 Renderer

As funções de renderizador no Unity permitem controlar a maneira como as superfícies dos acessórios são renderizadas na tela. Você pode reatribuir a textura, alterar a cor e alterar o sombreamento e a visibilidade do objeto. A sintaxe é assim:

renderer.enabled = false; renderer.material.color = new Color (0, 255, 0); renderer.material.mainTexture = minhaTextura; renderer.material.shader = newShader;

A maioria destes possui funções bastante claras. O primeiro exemplo torna o objeto em questão invisível: um truque útil em várias situações. O segundo exemplo atribui um novo Cor RGB (ou seja, verde) para o objeto em questão. O terceiro atribui a textura difusa principal a uma nova variável de textura. O último exemplo altera o sombreador do material do objeto para uma variável de sombreamento recém-definida.

6.3 Física

O Unity vem com um mecanismo de física integrado - algo que jogos de sandbox física Smash, Drive & Build: 3 simuladores impressionantes de sandboxes de física consulte Mais informação todos usam. Isso permite atribuir as propriedades físicas dos objetos e permitir que os detalhes de suas simulações sejam manipulados por você. Em geral, em vez de tentar implementar sua própria física usando um livro didático e o sistema de transformação, é mais simples e robusto usar o mecanismo de física da Unity na maior extensão possível.

Todos os adereços de física exigem colisores. No entanto, a própria simulação real é manipulada por um corpo rígido, que pode ser adicionado no inspetor Visão. Os corpos rígidos podem ser cinemático ou não cinemático.

Os adereços de física cinemática colidem com (e afetam) adereços de física não cinemática ao seu redor, mas não são afetados pela colisão. Os adereços cinemáticos estáticos são os objetos imóveis proverbiais e os objetos cinemáticos em movimento são os proverbial força imparável (para constar, quando colidem, simplesmente passam por cada de outros).

Além disso, você pode ajustar o arrasto angular do objeto (quanta energia é necessária para girá-lo), alterar sua massa, determinar se é ou não afetado pela gravidade e aplicar forças a ele.

Exemplos:

rigidbody.angularDrag = 0.1f; rigidbody.mass = 100; rigidbody.isKinematic = false; rigidbody.useGravity = true; corpo rígido. AddForce (transform.forward * 100);

Tudo isso é bastante auto-explicativo. A única coisa a observar aqui é o uso de transform.forward. Os vetores 3 têm três componentes (.frente, .acimae .direita) associado a eles, que pode ser acessado e alternado com eles (frente é a direção da seta azul no editor). o transform.forward A palavra-chave é simplesmente o vetor de avanço do objeto atual com magnitude 1. Pode ser multiplicado por um flutuador para criar mais força no objeto. Você também pode fazer referência transform.up e transform.right, e negue-os a obter seus reveses.

6.4 Colisão

Muitas vezes, ao criar um jogo, você deseja que uma colisão resulte em uma mudança de estado no seu código, além da simulação de física. Para isso, você precisará de um método de detecção de colisão.

Existe uma certa quantidade de trabalho de preparação necessário para detectar colisões no Unity. Primeiro, pelo menos um dos objetos na colisão precisa de um corpo rígido não cinemático anexado a ele. Ambos os objetos devem ter coletores corretos, configurados para não-gatilhos. A velocidade total de ambos os objetos deve ser baixa o suficiente para que eles colidam de fato, em vez de simplesmente passar um pelo outro.

Se você já cuidou de tudo isso, pode verificar a colisão colocando um método especial de detecção de colisão em um script anexado ao objeto com o qual deseja verificar a colisão. O método ficará assim:

void OnCollisionEnter (Colisão outro) {// faça as coisas aqui. }

Este método será executado automaticamente durante o primeiro quadro em que outro objeto tocar no seu objeto. A entidade de colisão de outros é uma referência ao objeto que você atingiu. Você pode, por exemplo, referenciar sua gameobject, corpo rígidoe transformar características para manipulá-lo de várias maneiras. Enquanto OnCollisionEnter é provavelmente a função mais comum que você usará, você também pode usar OnCollisionExit e OnCollisionStay (com sintaxe e uso idênticos), que são ativados durante o primeiro quadro que você para de colidir com um objeto e durante cada quadro que você colide com um objeto, respectivamente.

Às vezes, também pode ser útil fazer o que é chamado radiodifusão. Em radiodifusão, uma linha infinitamente fina (uma raio) é transmitido pelo mundo de alguma origem, ao longo de algum vetor e, quando atinge algo, a posição e outros detalhes da primeira colisão são retornados. O código para um raycast fica assim:

RaycastHit hit; if (Física. Raycast (transform.position, -Vector3.up, out hit)) {float distanceToGround = hit.distance; }

Isso lança um raio da posição do objeto atual ao longo de -Vector3.up (diretamente para baixo) e vincula a variável bater para o primeiro objeto com o qual ele colide. Depois que seu raio atingir algo, você poderá acessar hit.distance para determinar a que distância está, ou bater. GameObject para manipular o objeto atingido.

Raycasts como esse podem ser usados ​​por atiradores para determinar o que a arma apontou, ou para selecionar objetos quando a câmera os olha, ou para certos estilos de movimento mecânico.

6.5 Correção de tempo

Um fator importante a ser lembrado quando você manipula objetos dessa maneira tem a ver com taxa de quadros. Não importa quão cuidadosamente você otimize, as taxas de quadros sempre variarão e você não deseja que a velocidade do jogo varie de acordo. Se alguém executar seu jogo em um computador mais rápido do que você o desenvolveu, não deseje que o jogo seja executado em velocidade dupla.

A maneira como você corrige isso é multiplicando os valores que está usando pelo tempo que levou para renderizar o último quadro. Isso é feito usando Time.deltaTime. Isso altera efetivamente a velocidade de qualquer variável da qual você incrementa todos os quadros mudar por quadro para mudar por segundo, e você provavelmente deve fazer essa alteração em qualquer valor que esteja aumentando ou diminuindo a cada quadro.

6.6 Fontes de áudio e ouvintes

Agora que falamos sobre como criar, renderizar e controlar objetos, vamos falar sobre o outro sentido que os jogos de computador podem servir: a saber, som. O Unity suporta dois tipos de sons: 2D e 3D sons. Os sons 3D variam seu volume com base na distância e distorcem à medida que se movem em relação à câmera; Sons 2D não.

Os sons 2D são apropriados para dublagens e música de fundo, e os sons 3D se aplicam aos sons gerados por eventos no mundo. Para alterar se um som é ou não 3D, selecione-o no projeto vista, mude para o inspetor visualizar e selecione a opção apropriada no menu suspenso e pressione o botão reimportar botão.

Para realmente reproduzir o som, você precisa anexar um audiosource a um suporte (o suporte do qual você deseja que o som se origine, no caso de um som 3D). Então você precisará abrir o audioclip campo e selecione seu arquivo de som.

Você pode usar myAudioSource. Pausa() e myAudioSource. Jogar() para controlar esses arquivos de som. Você pode ajustar os comportamentos de queda, volume e deslocamento doppler dos sons sob o inspetor guia para a fonte de áudio.

6.7 Entrada

Um jogo que não recebe nenhuma contribuição do usuário não é muito importante. Existem muitos tipos diferentes de entradas que você pode ler e quase todas são acessíveis através do Entrada e Código chave objetos. Algumas instruções de entrada de amostra (que têm valores avaliados a cada quadro) estão abaixo.

Vector3 mousePos = Input.mousePosition; bool isLeftClicking = Entrada. GetMouseButton (0); bool isPressingSpace = Entrada. GetKey (KeyCode. Espaço);

As funções dessas linhas são principalmente auto-explicativas. Usando esses três tipos de referência de entrada, você pode reconstruir os esquemas de controle da maioria dos modernos jogos de computador em 3D.

6.8 Depurando um script

Digamos que um script não funcione. Como o bom médico diz, bangups e hangups podem acontecer com você. Se houver erros de sintaxe definitivos no seu C #, o jogo geralmente se recusará a executar quando você pressionar o play, e algumas mensagens de erro bastante úteis serão fornecidas se você Construir os scripts de dentro do editor. Ver abaixo:

Esses erros geralmente não são os mais difíceis de corrigir. O que pode ser mais problemático são os erros semânticos sutis, nos quais você escreveu com êxito um arquivo cheio de C # válido - mas não aquele que faz o que você pensava. Se você tiver um desses erros e estiver tendo problemas para encontrá-lo, há algumas coisas que você pode tentar para melhorar a situação.

O primeiro é pausar a execução do jogo e verificar o console. Você pode pausar o jogo clicando no pausa ícone na parte superior central do editor e, em seguida, selecione console do fundo do janela menu (ou pressionando Ctrl > Mudança > C). Mesmo se não houver erros, os avisos ainda podem ajudar a fornecer algumas pistas sobre o que pode estar errado.

Se isso não funcionar, você também pode tentar ter uma idéia do estado do seu script imprimindo o estado das variáveis ​​internas para validar que o programa está fazendo o que você pensa que está fazendo. Você pode usar Depurar. Log (String) para imprimir o conteúdo de uma sequência no console quando a execução do programa atingir essa linha. Em geral, se você trabalhar para trás a partir do que acha que deveria estar acontecendo através das coisas que deveriam ser fazendo isso acontecer, você chegará a um ponto em que suas impressões de depuração não farão o que você espera que elas façam Faz. É aí que está o seu erro.

7. Exemplo: Script Pong

Para construir o Pong, vamos dividir o jogo em seus elementos principais: precisamos de uma bola que ricocheteia entre as raquetes para aumentar velocidade, precisamos de um placar que saiba quando as bolas passaram nos remos e precisamos de um mecanismo para reiniciar a bola quando acontece. Um bom primeiro passo seria adicionar um corpo rígido não cinemático à bola, dois corpos rígidos cinemáticos ao remos, desative a gravidade para todos eles e atribua um material físico apropriado a partir dos ativos padrão (pulo com combinar salto definido como multiplicar).

Abaixo, você pode ver o script da bola com comentários explicativos. A bola precisa atingir alguns objetivos básicos: deve saltar em um padrão complicado, sempre mantendo movimento nos dois eixos, e deve acelerar em um ritmo desafiador, mas não impossível, na horizontal direção.

BallHandler.cs

Em seguida, precisamos criar um script para o nosso remo, que você pode ver abaixo. A raquete precisa se mover para cima e para baixo em resposta a pressionamentos de teclas (mas não fora de certos limites). Ele também precisa acionar o sistema de partículas quando colide com alguma coisa.

PaddleHandler.cs

Em seguida, precisamos da IA ​​do inimigo: algo que fará com que a raquete do inimigo rastreie em direção à bola a uma taxa fixa. Para isso, usaremos o Vector3.Slerp para máxima simplicidade. Também gostaríamos do mesmo comportamento de partículas que vemos em nosso próprio remo.

EnemyAI.cs

Finalmente, precisamos de um script para atualizar o placar e redefinir a bola quando ela sair dos limites.

ScoreboardUpdater.cs

Com esses scripts anexados e as referências preenchidas, quando executamos nosso jogo de Pong, experimentamos a jogabilidade!

Você pode baixe minha demonstração do Pong, se você quiser ver tudo o que descrevi em ação. Ele roda em sistemas Windows, Mac e Linux.

8. Explorando a documentação / aprendendo mais

O Unity é um mecanismo complexo com muito mais recursos do que seria possível abordar em um guia desse estilo, e isso é antes de você incluir a ampla variedade de extensões Unity (gratuitas e comerciais) disponíveis no Internet. Este guia lhe dará um forte ponto de partida para o desenvolvimento de um jogo, mas a autoeducação é uma habilidade importante em qualquer empreendimento, e duplamente aqui.

Um recurso crucial aqui é o Unity ScriptReference. O ScriptReference é um banco de dados pesquisável, disponível para C # e Javascript, que possui uma lista de cada comando e recurso do Unity, com descrições de suas funções e breves exemplos de sintaxe.

Se você está tendo problemas com o editor e a interface do Unity, ou apenas como tutoriais em vídeo, por uma questão de preferência, há uma longa lista de artigos de alta qualidade. Tutoriais em vídeo do Unity Os melhores tutoriais do Unity 3D para iniciantesDeseja desenvolver jogos com o Unity, mas não sabe por onde começar? Experimente um desses incríveis tutoriais do Unity 3D hoje. consulte Mais informação acessível. Mais extenso (mas menos amplo) tutoriais em texto para o Unity também estão disponíveis no CatLikeCoding.

Por fim, se você tiver perguntas além do escopo da documentação ou dos tutoriais, poderá fazer perguntas específicas em respostas. Unity3d.com. Lembre-se de que as respostas são fornecidas por voluntários. Portanto, respeite seu tempo e pesquise no banco de dados primeiro para garantir que sua pergunta ainda não tenha sido respondida.

9. Construindo seu jogo / compilando em um aplicativo independente

Quando você cria algo de que se orgulha (ou termina de clonar nosso exemplo de Pong, um pouco desonesto para a prática), é hora de mova seu jogo do editor e transforme-o em algo que você pode postar na internet e forçar seus amigos e familiares a Toque. Para fazer isso, você precisará criar um aplicativo independente. A boa notícia é que, no Unity, isso é muito, muito fácil. No entanto, existem alguns possíveis soluços que você deseja tomar cuidado.

Para iniciantes, saiba que você só pode criar um projeto sem erros. Para esse fim, verifique se o console está aberto enquanto você constrói: existem algumas condições de erro que o jogo ignorará no editor, mas ainda abortará uma tentativa de compilação. Isso apenas envia mensagens de erro ao console, sem resultados visíveis na tela, o que pode ser frustrante se você esquecer de verificar. Depois de compilar o jogo sem erros, você pode selecionar Configurações de compilação debaixo de Arquivo menu ou pressione Ctrl > Mudança
> B. Isso abrirá um diálogo simples que permite que você construa seu jogo para várias plataformas.

O processo a partir daí é auto-explicativo: selecione suas opções e pressione Construir; o jogo solicitará a instalação de um diretório e colocará o diretório executável e de dados nele. Esses dois arquivos podem ser compactados e distribuídos (verifique se você não está cobrando por um jogo criado na demonstração do Unity, pois isso viola os termos de serviço).

10. Notas de encerramento

Como em qualquer ferramenta de desenvolvimento de jogos, a chave para o sucesso com o Unity é o desenvolvimento iterativo. Você precisa criar incrementos administráveis ​​- seja ambicioso, por todos os meios, mas seja ambicioso em pequenos pedaços e organize aqueles pedaços de tal forma que, mesmo que você não atinja sua ambição final, ao menos acabará com uma coerência produtos.

Obtenha os elementos mais cruciais em primeiro lugar: tenha uma ideia de sua produto com minima viabilidade, a coisa mais simples e básica que você poderia criar e ainda sentir como se tivesse conseguido algo que valesse a pena. Chegue ao projeto mínimo viável antes de avançar para ambições maiores.

Este tutorial fornece um ponto de partida forte, mas a melhor maneira de aprender o Unity é criando um jogo. Comece a criar um jogo, preencha lacunas de conhecimento à medida que elas surgirem, e o fluxo gradual de conhecimento corroerá as coisas que você não conhece surpreendentemente rapidamente.

Se você leu tudo isso e está um pouco impressionado com a codificação necessária com o Unity, verifique como Aprenda o desenvolvimento de jogos com o Unity Learn O Unity Learn é a maneira mais fácil de dominar o desenvolvimento de jogosDeseja começar a desenvolver seus próprios jogos? O Unity Learn é a melhor e mais fácil maneira de aprender e dominar o que você precisa saber. consulte Mais informação e também leia nosso guia sobre como fazer video games sem nenhuma programação Como criar videogames sem qualquer programaçãoQuer fazer um videogame, mas não pode codificar? Em seguida, use um kit de construção de videogame que permite criar jogos sem necessidade de codificação! consulte Mais informação .

O Unity é uma ferramenta poderosa e, com um pouco de exploração, você pode construir projetos impressionantes com mais rapidez do que você poderia esperar. Conte-nos o que você criou nos comentários abaixo. Gostaríamos de ver!