Home-theater-designers
Uma característica surpreendente da economia da Internet é a ascensão dos videogames independentes. Outrora domínio exclusivo de estúdios triple-A multimilionários com milhares de pessoas, vários conjuntos de ferramentas foram desenvolvidos para levar recursos de desenvolvimento de jogos modernos para as mãos de indivíduos ou pequenas coleções ad-hoc de programadores e designers. Discutimos anteriormente os melhores jogos indie, então certifique-se de conferi-los para se inspirar no que pode ser alcançado com ferramentas como o Unity.
Essas equipes independentes de desenvolvimento de jogos demonstraram uma agilidade e tolerância ao risco que, em muitos casos, permite que eles impulsionem a inovação no jogo mais rápido do que seus colegas de grande orçamento. Uma série de títulos indie de sucesso chocante estreou nos últimos anos, incluindo Minecraft , Limbo , e Super Meat Boy , e mesmo que você não tenha as habilidades necessárias para fazer jogos como este, você pode fazer um jogo usando o Buildbox.
No cenário em rápida evolução do desenvolvimento de jogos independentes, Unidade surgiu como uma espécie de 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. O Unity é tão flexível que você pode até faça seus próprios controladores de jogo personalizados com um pouco de know-how DIY!
Mesmo grandes estúdios, como CCP (Developers of Eve Online ) use-o para criar protótipos de conceitos de jogos rapidamente. 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 com '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 por você, mas reduz substancialmente a barreira de 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 novatos de uma forma rápida e intuitiva.
Hoje irei guiá-lo por tudo que você precisa saber para fazer um jogo no Unity, que está dividido em dez capítulos principais:
§3 - Uma breve introdução ao paradigma orientado a objetos
§5 - Exemplo: elementos básicos de um jogo
§8 - Explorando a documentação / Aprendendo mais
§9 - Construindo seu jogo / Compilando para um aplicativo independente
1. Versões do Unity
O Unity vem em dois sabores básicos: a versão profissional e a versão gratuita. Há um número de diferenças , mas, de modo geral, a versão profissional suporta uma série de 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 mais complexos.
Dito isso, para a maioria dos jogos relativamente simples que você pode querer construir, a versão gratuita do Unity é perfeitamente adequada. Descreveremos as principais diferenças abaixo com mais detalhes para os interessados.
1.1 Preços
A versão gratuita do Unity é, obviamente, gratuita. No entanto, existem algumas limitações: a versão gratuita do Unity não pode ser licenciada para qualquer empresa com uma renda anual superior a $ 100.000 . Embora tais organizações estejam além do escopo deste guia, se você suspeita que pode se tornar tal organização, é provavelmente sábio pular para a 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 ele. Há também um teste gratuito de 30 dias disponível, que usaremos neste guia, a fim de fornecer a você uma visão geral mais completa possível dos recursos disponíveis. Uma licença de estudante de um ano também está disponível através Estude 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 uma série de opções de renderização que permitem jogos com melhor aparência e execução mais rápida (suporte LOD, pós-processamento do espaço da tela, sombreadores avançados, soft em tempo real sombras e renderização diferida). Também carece de toda sistema de animação mecanim e algumas ferramentas de IA.
Em geral, para projetos complexos e de grande escala, ou projetos onde o desempenho gráfico é importante, a versão profissional vale a pena. Eu uso a versão pro, porque desenvolvo jogos de realidade virtual para o Oculus Rift, e o suporte de pós-processamento screen-space é necessário para interagir corretamente com o fone de ouvido.
2. Instalando o Unity
O Unity é simples de instalar. Você pode baixar o executável em Unit3d.com/get-unity/download .
Depois de baixado, execute-o e siga as instruções do instalador. Quando a instalação for concluída, uma janela intitulada 'ative sua licença Unity' aparecerá. Marque a caixa marcada 'ativar um teste gratuito de 30 dias do Unity Pro' e, em seguida, 'OK'.
Parabéns! Agora você tem uma versão de avaliação de 30 dias do Unity Pro. Quando o período de avaliação expirar, se você não quiser comprar a versão profissional, pode mudar para a versão gratuita e manter o conteúdo existente.
como remover o google drive do computador
3. Uma breve introdução ao paradigma orientado a objetos
Antes de começar a usar o Unity, é importante revisar um pouco o básico. Unity suporta ambos C # e JavaScript para programação de jogo ; estaremos trabalhando com C # para este tutorial.
Em primeiro lugar, se você nunca programou antes, coloque este tutorial de lado e passe alguns dias trabalhando no programa da Microsoft C # Language Primer até que você se sinta confortável usando a linguagem para tarefas simples.
Se você quiser algo um pouco diferente do C # (mas não necessariamente uma linguagem que você possa usar no Unity), dê uma olhada em nosso guia com as seis linguagens de programação mais fáceis para iniciantes.
Se você já programou antes em uma linguagem imperativa ou orientada a objetos como C ou Java, dê uma olhada no primer e familiarize-se com como o C # difere de outras linguagens que você usou no passado. De qualquer forma, não prossiga com o tutorial até que se sinta confortável resolvendo problemas simples com C # (por exemplo, se eu pedisse a você para escrever um programa que imprima os primeiros cem números primos, você deveria ser capaz de escrever esse programa sem consultar o Google).
O conceito mais importante para entender aqui é o paradigma orientado a objetos (abreviado como ABRIR ) 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 do objeto são chamadas métodos .
A ideia aqui é modularidade: tendo cada objeto isolado e forçando outros objetos a interagir com ele por meio de seus métodos, você pode reduzir o número de possíveis interações não intencionais - e, por extensão, bugs. Você também pode criar objetos que podem ser reutilizados posteriormente sem modificação. No Unity, você vai construir esses objetos e anexá-los a entidades do jogo (cujo comportamento eles governarão).
Os objetos são instanciados a partir de Aulas : uma classe é apenas um arquivo que apresenta a definição do seu objeto. Então, se você quiser um mook objeto que manipula IA para um inimigo em seu jogo, você escreveria uma classe 'Mook' e, em seguida, anexaria esse arquivo a cada entidade inimiga. Ao executar o jogo, cada inimigo será equipado com uma cópia do objeto 'Mook'.
Anexar um novo script a um objeto tem a seguinte aparência:
Primeiro, selecione o objeto e vá para o Inspetor . Clique no Adicionar Componente botão.
Vamos para novo roteiro , digite o nome que deseja e clique em criar e adicionar .
Agora você tem um novo script que pode editar clicando duas vezes nele!
Um arquivo de classe se parece com isto:
using UnityEngine;
public class Mook : MonoBehaviour {
private float health;
void Start () {
health = 100;
}
void Update(){
if (health > 0) {
/* Search for player
if you encounter the player on the road, kill him
if you get shot, remove a random amount of health */
}
}
}Vamos decompô-lo:
- Usando UnityEngine: Esta linha diz ao C # que queremos usar as bibliotecas do Unity, que nos permitem conectar ao motor de jogo do Unity.
- Classe pública Mook: MonoBehaviour: Esta linha declara a classe e seu nome - mook .
- Saúde 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 anulado (): Isso declara um método chamado Começar . Iniciar é um método especial executado apenas uma vez, quando o jogo é iniciado pela primeira vez.
- Atualização nula (): Atualizar é outro método especial, executado em todos os quadros. A maior parte da lógica do seu jogo irá aqui.
- // se você encontrar o jogador na estrada, mate-o: Esta linha é um comentário (qualquer linha que comece com uma barra dupla é ignorada por C #). Os comentários são usados para lembrar a você o que bits específicos de 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 aula hipotética chamada addTwoNumbers que adiciona dois números juntos:
public float addTwoNumbers(float a, float b) {
return a+b;
}Isso declara um método público (acessível a outros objetos) que retorna um float, chamado addTwoNumbers , que leva dois flutuadores como entrada (chamados para e b ) Em seguida, ele retorna a soma dos dois valores como sua saída.
Chamar este método de dentro da mesma classe (digamos, de dentro Atualizar ) se parece com isso:
float result = addTwoNumbers(1, 2);Chamar o método de outra classe é semelhante:
addTwoNumbers instance;
float result = instance.addTwoNumbers(1, 2);Novamente, isso apenas cria uma instância de nossa classe, acessa o método apropriado e fornece 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 pode ser acessado sob o conjunto normal de parâmetros GameObject, você pode optar por tratá-lo como um tipo diferente de entidade de jogo usando o GetComponent método.
A sintaxe para isso se parece com esta:
GetComponent().Play();Se alguma dessas coisas não for familiar para você, volte e leia a cartilha C #. Isso o poupará de muita frustração à medida que prosseguirmos.
4. Unity Basics
Nesta seção, vamos trabalhar nosso caminho através da mecânica básica do motor Unity. O fluxo de trabalho no Unity é mais ou menos assim:
- Crie uma entidade para desempenhar um papel no jogo (em branco GameObjects pode ser usado para tarefas lógicas abstratas).
- Escreva ou encontre um arquivo de classe e adicione-o à entidade como um script (usando o Adicionar Componente botão no inspetor visualizar.
- Corre > teste > depurar > repetir até que funcione e passe para o próximo elemento do jogo.
O Unity vem com várias guias de visualização básicas que podem ser dispostas de várias maneiras de acordo com o gosto do usuário. Os cinco grandes são:
- Jogo: exibe uma instância em execução do jogo com a qual você pode interagir e testar.
- Cena: fornece uma versão estática e editável do mundo dos jogos .
- Inspetor: permite que você modifique entidades individuais no mundo do jogo, selecionando-as no editor aba.
- Projeto: permite que você navegue pelos arquivos do projeto e arraste modelos, materiais e outros recursos para o editor guia para colocá-los no mundo do jogo.
- Hierarquia: esta guia mostra todos os objetos do mundo, permitindo que você encontre objetos distantes na cena e entidades pai entre si clicando e arrastando.
Veja o diagrama abaixo para a localização 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 integrado do Unity primitivo objetos (cubos, esferas, cilindros, etc), ou importe seus próprios modelos 3D de um pacote de modelagem como Liquidificador ou Maia . O Unity suporta uma variedade de formatos 3D, incluindo .fbx , e .3ds .
As ferramentas básicas para manipular malhas são os botões de escala, rotação e translação no canto superior esquerdo da interface. Esses botões adicionam ícones de controle aos modelos na visualização do editor, que podem então ser usados para manipulá-los no espaço. Para alterar a textura ou propriedades físicas de um objeto, selecione-os e use o inspetor vista para analisar o material e corpo rígido elementos
4.1.2 Elementos da GUI
Sprites GUI tradicionais e texto podem ser exibidos usando o Texto GUI e a Textura GUI GameObjects no editor. No entanto, uma maneira mais robusta e realista de lidar com os elementos da IU é usar o Texto 3D e Quad GameObjects (com texturas transparentes e um sombreador transparente apagado) para colocar elementos de 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 crianças, 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 do inspetor.
4.1.3 Materiais
Os materiais são combinações de texturas e sombreadores e podem ser arrastados diretamente para os objetos do jogo a partir da guia do projeto. Um grande número de sombreadores vem com o Unity Pro, e você pode ajustar a textura anexada a eles usando a guia do inspetor para um objeto ao qual eles são aplicados.
Para importar uma textura, converta-a em um .jpg , .png , ou .bmp , e arraste-o para o ativos pasta sob o diretório do projeto 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 no mundo. Se não houver luzes em sua cena, todos os polígonos serão desenhados com o mesmo nível de brilho, dando ao mundo uma aparência plana e desbotada.
As luzes podem ser posicionadas, giradas e ter várias características internas que você pode personalizar. o intensidade controle deslizante controla o brilho da luz, e o faixa controla a rapidez com que desaparece.
As diretrizes no vista da cena mostrar 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 ( biscoito exibida na superfície para a qual a luz é apontada e que tipo de clarão aparece na tela quando se olha diretamente para a luz. O cookie pode ser usado para simular padrões de luz mais realistas, criar sombras falsas dramáticas e simular projetores.
Os três principais tipos de luz são ver , apontar , e direcional .
Holofotes ter uma localização no espaço 3D e projetar luz apenas em uma direção em um cone de ângulo variável. Eles são bons para lanternas, holofotes e, em geral, fornecem um controle mais preciso da iluminação. Luzes spot podem projetar sombras.
Luzes pontuais ter uma localização no espaço 3D e lançar luz uniformemente em todas as direções. Luzes pontuais não projetam sombras.
Luzes direcionais , finalmente, são usados para simular a luz do sol: eles projetam a luz em uma direção como se estivessem infinitamente longe. Luzes direcionais afetam todos os objetos na cena e podem produzir sombras.
4.1.6 Sistemas de Partículas
PARA Sistema de partículas é um GameObject que gera e controla centenas ou milhares de partículas simultaneamente. As 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-os ideais para fumaça, fogo, chuva, faíscas, efeitos mágicos e muito mais.
Existem muitos parâmetros que você pode ajustar para alcançar esses efeitos, e você pode acessá-los gerando um sistema de partículas sob o editor de componente > selecionando o sistema de partículas > abrindo a guia do inspetor . Você pode alterar o tamanho, velocidade, direção, rotação, cor e textura de cada partícula e definir a maioria desses parâmetros para mudar com o tempo também.
Debaixo de colisão atributo, se você ativá-lo e definir o espaço de simulação para mundo você obterá partículas que irão colidir com objetos no mundo, o que pode ser usado para uma série de efeitos de partículas realistas, incluindo chuva, água em movimento e faíscas.
5. Exemplo: Elementos básicos de um jogo
Para este tutorial, vamos fazer um jogo simples de Pong - algo que já cobrimos várias vezes em DIY antes:
- Arduino Classic Pong
- Arduino OLED Pong
Nesta seção, veremos como organizar os elementos principais - o tutorial de script virá mais tarde.
Primeiro, vamos dividir o jogo de Pong em seus componentes básicos. Primeiro, precisamos de dois remos e uma bola. A bola voa para fora da tela, então vamos querer um mecanismo para reiniciá-la. Também queremos que o texto exiba a pontuação atual e, para mostrar a você todos os elementos principais do Unity, queremos um efeito de partícula extravagante quando você acerta a bola. Todo o jogo precisará ser dramaticamente iluminado.
Isso se divide em um objeto de bola (uma esfera), um reprodutor , dois adereços de remo com emissores de partículas anexado um Entidade de texto 3D , e um Holofote . Para este tutorial, usaremos o material físico padrão quicar , com bounce combine definido como multiplicar . Esta é a aparência da configuração, em dez capturas de tela:
Primeiro, crie um suporte de cubo para o remo.
Dimensione apropriadamente, duplicar , e colocar um esfera entre os remos para a bola.
Em seguida, crie um Objeto 3DText e escala e posição corretamente, mudando 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 às pás.
Em seguida, você vai querer posicionar e girar a câmera para enquadrar a cena corretamente. Enquanto a câmera está selecionada, você pode ver uma pequena amostra da visão da câmera no canto inferior direito.
Antes de terminar, precisamos criar dois cubos adicionais para serem pára-choques, para evitar que a bola quique para fora da área de jogo. Podemos torná-los invisíveis desmarcando o renderizador de malha no guia do inspetor .
Se você clicar em jogar, poderá ver os elementos básicos do nosso jogo dispostos. Eles não farão nada ainda, mas vamos chegar lá!
Agora que temos essa configuração, vamos falar sobre o que está envolvido no script desses elementos para fazer um jogo.
6. Script no Unity
Depois de anexar um script a um objeto, você pode revisá-lo clicando duas vezes nele no inspetor . Isso abre MonoDevelop , o ambiente de desenvolvimento padrão para Unity. Em essência, Monodevelop é um editor de texto com recursos especificamente otimizados para programação.
Palavras-chave e comentários são destacados em azul e verde , e valores numéricos e strings aparecem em internet . Se você já usou Eclipse ou outro IDE, MonoDevelop é muito semelhante. Você pode construir seus scripts de dentro do editor, para verificar se há erros de sintaxe, como:
Em geral, para fazer seu script interagir com o Unity, você precisará fazer referência aos elementos que o objeto que contém o script possui (você pode ver uma lista desses elementos sob o inspetor guia quando o objeto relevante é selecionado). Você pode então chamar métodos ou definir variáveis para cada um desses elementos para efetuar as alterações desejadas.
Se você quiser que um script em um objeto afete as propriedades de um objeto diferente, pode criar um vazio 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 (tirada da visualização do inspetor de uma de nossas pás no exemplo acima):
- Transformar
- Cubo (filtro de malha)
- Box Collider
- Renderizador de malha
Cada um desses aspectos do objeto pode ser influenciado a partir de um script. A seguir, veremos exatamente como.
6.1 Transformar
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: a posição e a escala são, como você esperaria, armazenadas como Vector3s . Você pode acessar o X , E , e COM componentes de cada um (por exemplo, transform.position.y fornece a distância de um objeto acima do plano zero).
No entanto, para evitar bloqueio do cardan , as rotações são tratadas como Quatérnions (vetores de quatro componentes). Como a manipulação manual de quatérnios não é intuitiva, você pode manipular rotações usando ângulos Eulerianos usando o Quaternion.Euler método assim:
transform.rotation = Quaternion.Euler(pitch, yaw, roll);Se você deseja mover objetos suavemente de um lugar para outro, você encontrará o Slerp método para quatérnions 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 dada. A sintaxe é semelhante a esta:
transform.position = Vector3.Slerp(startPositionVector3, newDestinationVector3, 1);6.2 Renderer
As funções de renderizador no Unity permitem que você controle a maneira como as superfícies dos adereços são renderizadas na tela. Você pode reatribuir a textura, alterar a cor e alterar o sombreamento e a visibilidade do objeto. A sintaxe é semelhante a esta:
renderer.enabled = false;
renderer.material.color = new Color(0, 255, 0);
renderer.material.mainTexture = myTexture;
renderer.material.shader = newShader;A maioria deles tem funções bem 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 sombreador recém-definida.
6.3 Física
O Unity vem com um mecanismo de física integrado - algo que todos os jogos sandbox de física usam. Isso permite que você atribua as propriedades físicas dos objetos e deixe que os detalhes de sua simulação sejam tratados para você. Em geral, ao invés de tentar implementar sua própria física usando um livro e o sistema de transformação, é mais simples e mais robusto usar o mecanismo de física do Unity da melhor maneira possível.
Todos os adereços de física exigem colisores . No entanto, a simulação real em si é tratada por um corpo rígido , que pode ser adicionado no inspetor visualizar. Corpos rígidos podem ser cinemático ou não cinemático .
Os adereços da física cinemática colidem com (e afetam) os adereços da física não cinemática ao seu redor, mas não são afetados pela colisão em si. Os adereços cinemáticos estáticos são os proverbiais objetos imóveis, e os objetos cinemáticos em movimento são a proverbial força imparável (para o registro, quando eles colidem, eles simplesmente passam um pelo outro).
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;
rigidbody.AddForce(transform.forward * 100);Tudo isso é bastante autoexplicativo. A única coisa a notar aqui é o uso de transform.forward . Todos os Vector3 têm três componentes ( .frente , .acima , e .direito ) associado a eles, que pode ser acessado e gira com eles ( frente é a direção da seta azul no editor). o transform.forward palavra-chave é simplesmente o vetor direto para o objeto atual com magnitude 1. Ele 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 para obter seus reveses.
6.4 Colisão
Freqüentemente, ao construir um jogo, você gostaria que uma colisão resultasse em alguma mudança de estado em seu código, além de apenas simulação física. Para isso, você precisará de um método de detecção de colisão .
Há uma certa quantidade de trabalho de preparação necessária 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 apegado a ele. Ambos os objetos devem ter aceleradores corretos, configurados para serem não disparadores. A velocidade total de ambos os objetos deve ser baixa o suficiente para que eles realmente colidam, em vez de simplesmente passarem um pelo outro.
Se você já cuidou de tudo isso, pode verificar se há 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 será semelhante a este:
void OnCollisionEnter(Collision other) {
//do things here
}Este método será executado automaticamente durante o primeiro quadro em que outro objeto tocar seu objeto. A entidade de colisão de outros é uma referência ao objeto que você atingiu. Você pode, por exemplo, fazer referência a seu objeto de jogo , corpo rígido , e 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 em que você para de colidir com um objeto e durante cada quadro em que colide com um objeto, respectivamente.
Às vezes, também pode ser útil fazer o que é chamado raycasting . Em raycasting, uma linha infinitamente fina (um raio ) é lançado através do mundo a partir 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 se parece com este:
RaycastHit hit;
if (Physics.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 (direto para baixo) e vincula a variável bater ao primeiro objeto com o qual colide. Assim que seu raio atingir algo, você pode acessar hit.distance para determinar a que distância está, ou hit.GameObject para manipular o objeto que você acertou.
Raycasts como este podem ser usados por atiradores para determinar para onde a arma está apontada, ou para selecionar objetos quando a câmera olha para eles, ou para certos estilos de mecânica de movimento.
6.5 Correção de Tempo
Um fator importante a ter em mente quando você está manipulando objetos desta forma tem a ver com taxa de quadros . Não importa o quão cuidadosamente você otimiza, as taxas de quadros sempre irão variar, e você não quer que a velocidade do jogo varie de acordo. Se outra pessoa executar o seu jogo em um computador mais rápido do que o desenvolvido, você não quer que o jogo rode com o dobro da velocidade.
A maneira de corrigir isso é multiplicar os valores que você está usando pelo tempo que levou para renderizar o último quadro. Isso é feito usando Time.deltaTime . Isso muda efetivamente a velocidade de qualquer variável que você está incrementando a cada quadro mudar por quadro para mudança por segundo , e você provavelmente deve fazer essa alteração em qualquer valor que estiver aumentando ou diminuindo a cada quadro.
6.6 Fontes de áudio e ouvintes
Agora que cobrimos 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 locuções e música de fundo, e os sons 3D se aplicam a sons gerados por eventos no mundo. Para alterar se um som é ou não 3D, selecione-o no projeto vista, mude para o inspetor visualize e selecione a opção apropriada no menu suspenso e pressione o botão reimportar botão.
Para realmente tocar o som, você precisará anexar um fonte de áudio a um suporte (o suporte de onde você deseja que o som se origine, no caso de um som 3D). Então você precisa abrir o audioclip campo e selecione seu arquivo de som.
computador está conectado, mas não está carregando
Você pode usar myAudioSource.Pause () e myAudioSource.Play () 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 entrada do usuário não é exatamente um jogo. Existem muitos tipos diferentes de entrada que você pode ler, e quase todos eles 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 = Input.GetMouseButton(0);
bool isPressingSpace = Input.GetKey(KeyCode.Space);As funções dessas linhas são autoexplicativas. Usando esses três tipos de referência de entrada, você pode reconstruir os esquemas de controle da maioria dos jogos de computador 3D modernos.
6.8 Depurando um Script
Digamos que um script não funcione. Como diz o bom médico, bangups e hangups podem acontecer com você. Se houver erros de sintaxe no seu C #, o jogo geralmente se recusará a rodar quando você clicar em play, e algumas mensagens de erro bastante úteis serão fornecidas se você construir os scripts de dentro do editor. Veja abaixo:
Esses bugs normalmente não são os mais difíceis de corrigir. O que pode ser mais problemático são os erros de semântica sutis, nos quais você escreveu com sucesso um arquivo cheio de C # válido - mas não um que faça o que você pensava que faria. Se você tiver um desses erros e estiver tendo problemas para rastreá-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, selecionando console do fundo do janela menu (ou pressionando Ctrl > Mudança > C ) Mesmo que não haja erros, os avisos ainda podem ajudar a dar algumas pistas sobre o que pode estar errado.
Se isso não funcionar, você também pode tentar ter uma ideia sobre o estado do seu script, imprimindo o estado das variáveis internas para validar se o programa está fazendo o que você pensa que está fazendo. Você pode usar Debug.Log (String) para imprimir o conteúdo de uma string no console quando a execução do programa atingir essa linha. Em geral, se você trabalhar de trás para frente a partir do que você acha que deveria estar acontecendo, passando pelas coisas que deveriam estar fazendo acontecer, eventualmente você chegará a um ponto em que suas impressões de depuração não farão o que você espera que façam. É aí que está o seu erro.
7. Exemplo: Scripting Pong
Para construir o Pong, vamos dividir o jogo em seus elementos principais: precisamos de uma bola que ricocheteia entre as pás em velocidade crescente, precisamos de um placar que saiba quando as bolas passaram pelas pás e precisamos de um mecanismo para reiniciar a bola quando isso acontecer. Um bom primeiro passo seria adicionar um corpo rígido não cinemático à bola, dois corpos rígidos cinemáticos às pás, desativar a gravidade para todos eles e atribuir um material físico apropriado dos ativos padrão ( quicar com bounce combine definido como multiplicar )
Abaixo, você pode ver o roteiro da bola com comentários explicativos. A bola precisa cumprir alguns objetivos básicos: deve quicar em um padrão complicado, sempre mantendo o movimento em ambos os eixos, e deve acelerar em um ritmo desafiador, mas não impossível na direção horizontal.
Em seguida, precisamos fazer o script de nossa raquete, que você pode ver abaixo. A raquete precisa se mover para cima e para baixo em resposta aos pressionamentos de tecla (mas não fora de certos limites). Ele também precisa acionar o sistema de partículas quando colide com algo.
Em seguida, precisamos da IA do inimigo: algo que fará com que a raquete do inimigo siga em direção à bola a uma taxa fixa. Para isso, usaremos Vector3.Slerp para máxima simplicidade. Também gostaríamos do mesmo comportamento de partícula que vemos em nossa própria raquete.
EnemyAI.cs
Finalmente, precisamos de um script para atualizar o placar e zerar a bola quando ela sai da quadra.
Com esses scripts anexados e as referências preenchidas, quando executamos nosso jogo de Pong, experimentamos a jogabilidade!
Você pode baixe minha demonstração Pong , se 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 poderia ser coberto em um guia deste estilo, e isso antes de incluir a ampla gama de extensões Unity (gratuitas e comerciais) disponíveis na Internet. Este guia lhe dará um bom 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 contém uma lista de todos os comandos e recursos 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 gosta de tutoriais em vídeo como uma questão de preferência, há uma longa lista de vídeos de alta qualidade Tutoriais em vídeo do Unity acessível. Mais extenso (mas menos amplo) tutoriais de texto para Unity também estão disponíveis em CatLikeCoding.
Finalmente, se você tiver dúvidas além do escopo da documentação ou tutoriais, você pode fazer perguntas específicas em answers.Unity3d.com . Lembre-se de que as respostas são fornecidas por voluntários, portanto, respeite o tempo deles e pesquise no banco de dados primeiro para ter certeza de que sua pergunta ainda não foi respondida.
9. Construindo Seu Jogo / Compilando para um Aplicativo Independente
Quando você construiu algo de que se orgulha (ou terminou de clonar nosso exemplo ligeiramente duvidoso de Pong para praticar), é hora de mover seu jogo do editor e transformá-lo em algo que você possa postar na internet e forçar seus amigos e familiares para jogar. Para fazer isso, você precisará construir um aplicativo independente. A boa notícia é que no Unity isso é muito, muito fácil. Existem, no entanto, alguns soluços em potencial com os quais você deve ter cuidado.
Para começar, saiba que você só pode construir um projeto sem erros. Para isso, certifique-se de ter o console aberto enquanto constrói: existem algumas condições de erro que o jogo irá ignorar no editor, mas ainda irá abortar uma tentativa de construção. Isso apenas despeja mensagens de erro no console, sem resultados visíveis na tela, o que pode ser frustrante se você se 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á uma caixa de diálogo simples que permite construir seu jogo para várias plataformas.
O processo a partir daí é autoexplicativo: selecione suas opções e clique construir ; o jogo solicitará um diretório para instalação e colocará o diretório executável e de dados nele. Esses dois arquivos podem ser compactados e distribuídos (apenas certifique-se de não cobrar por um jogo criado na demo do Unity, pois isso viola os termos de serviço).
10. Notas de Fechamento
Como acontece com qualquer ferramenta de desenvolvimento de jogos, a chave para o sucesso com o Unity é o desenvolvimento iterativo. Você tem que construir em incrementos gerenciáveis - seja ambicioso, por todos os meios, mas seja ambicioso em pequenos pedaços, e organize esses pedaços de forma que, mesmo se você ficar aquém de sua ambição final, você pelo menos acabará com um coerente produtos.
Obtenha os elementos mais cruciais primeiro: tenha uma ideia em mente de seu produto com minima viabilidade , a coisa mais simples e básica que você poderia criar e ainda sentir que conquistou algo que vale a pena. Chegue ao projeto mínimo viável antes de avançar para ambições maiores.
Este tutorial oferece um bom ponto de partida, mas a melhor maneira de aprender o Unity é construindo um jogo. Comece a construir um jogo, preencha as lacunas em seu conhecimento à medida que elas surgem, e o fluxo gradual de conhecimento irá erodir as coisas que você não conhece com uma rapidez surpreendente.
Se você leu tudo isso e está um pouco sobrecarregado com a codificação necessária com o Unity, certifique-se de verificar como aprenda o desenvolvimento de jogos com Unity Learn e também leia nosso guia sobre como fazer videogames sem nenhuma programação.
O Unity é uma ferramenta poderosa e, com um pouco de exploração, você pode construir projetos impressionantes com ele mais rápido do que poderia esperar. Deixe-nos saber o que você construiu nos comentários abaixo - adoraríamos ver!
Compartilhado Compartilhado Tweet O email 3 maneiras de verificar se um e-mail é verdadeiro ou falsoSe você recebeu um e-mail que parece um pouco duvidoso, é sempre melhor verificar sua autenticidade. Aqui estão três maneiras de saber se um e-mail é real.
Leia a seguir Tópicos relacionados- Programação
- Programação
- Forma longa
- Guia Longform
Um escritor e jornalista que mora no sudoeste, Andre tem garantia de permanecer funcional até 50 graus Celsius e é à prova d'água até uma profundidade de 3,6 metros.
Mais de Andre InfanteAssine a nossa newsletter
Junte-se ao nosso boletim informativo para dicas de tecnologia, análises, e-books grátis e ofertas exclusivas!
Clique aqui para se inscrever