Programar um jogo com a unidade: um guia para iniciantes

Uma característica surpreendente da economia da Internet é o surgimento de videogames independentes. Uma vez que o domínio exclusivo de mil pelo homem, vários milhões de dólares estúdios triple-A, uma série de conjuntos de ferramentas foram desenvolvidas que trazem modernos recursos de desenvolvimento de jogos para as mãos de indivíduos ou coleções pequenas, ad-hoc de programadores e designers. Essas equipes de desenvolvimento de jogos indie têm demonstrado uma agilidade e de tolerância ao risco que, em muitos casos, permite-lhes para empurrar a inovação jogabilidade mais rápido do que seus grandes homólogos orçamento. Um número de títulos indie chocantemente bem-sucedidas têm estreou nos últimos anos, incluindo Minecraft, Limbo, e Super Meat Boy.

Na paisagem em rápida evolução do desenvolvimento de jogos indie, Unidade emergiu como uma espécie de padrão de fato: seu baixo custo, facilidade de uso e ampla conjunto de características o tornam ideal para desenvolvimento de jogos rápida. Mesmo grandes estúdios, tais como PCC (de programadores Eve online) Usá-lo para prototipagem rápida conceitos de jogo. Unity fornece um “motor de jogo em uma caixa” - uma física e motor de renderização com ganchos para várias linguagens de script, adaptável a praticamente qualquer gênero de videogame.Unidade - Grandes jogos 3D em múltiplas plataformas & browsersUnidade - Grandes jogos 3D em múltiplas plataformas & browsersconsulte Mais informação

Enquanto Unity fornece um editor visual para manipular o ambiente do jogo, Unidade não é uma ‘programação de zero criador do jogo`Ferramenta. A unidade requer a capacidade de programar a produzir resultados, mas também dá-lhe uma ferramenta muito mais flexível e poderosa do que qualquer programa ‘fabricante do jogo` podia. Unidade não vai fazer o trabalho para você, mas serve para diminuir a barreira de entrada substancialmente. Começando do zero com C ++ e OpenGL, pode levar dias para chegar ao ponto onde há realmente algo prestados na tela. Usando Unity, que leva cerca de dez segundos. Unity coloca os elementos básicos de criação de jogos para as mãos de programadores iniciantes de forma rápida e intuitiva.

2. Versões de Unity

Unidade vem em dois sabores básicos: a versão pro e a versão gratuita. Há uma série de diferenças (você pode ver a lista completa aqui), mas, em termos gerais, a versão Pro suporta uma série de melhorias visuais (como em tempo real sombras suaves e pós-processamento), e um grande número de relativamente menor características que são extremamente úteis para mais jogos complexos. Dito isto, para a maioria dos jogos relativamente simples que você pode querer construir, a versão gratuita do Unity é perfeitamente adequada. Vamos quebrar as principais diferenças abaixo em mais detalhes para os interessados.

2.1 Preço

A versão gratuita do Unity é, naturalmente, livre. No entanto, existem algumas limitações: a versão gratuita da Unidade não pode ser licenciada a qualquer empresa com uma renda anual de mais de US $ 100.000. Embora tais organizações estão além do escopo deste guia, se você suspeitar que você pode tornar-se uma organização deste tipo, é provavelmente sábio para saltar para a versão Pro.

A versão Pro da Unidade é de R $ 75 por mês, ou US $ 1500 para uma licença permanente, e não tem limites sobre o que você pode fazer com os jogos criados com ele. Há também uma versão de avaliação gratuita de 30 dias disponíveis, o que vamos usar para este guia, a fim de dar-lhe uma visão geral mais completa dos recursos disponíveis quanto possível. A licença de estudante de um ano também está disponível através Studica por US $ 129.

2.2 Características

Existem muitas características ausentes na versão gratuita do Unity. No entanto, as diferenças mais importantes são as seguintes: a versão gratuita do Unity não tem um número de opções de renderização que permitam uma melhor aparência, jogos mais rápido em execução (apoio LOD, a tela do espaço pós-processamento, shaders avançados, em tempo real suave sombras e renderização adiada). Ele também não tem o sistema de animação mechanim completo, e algumas ferramentas de IA. Em geral, para complexos projetos de grande escala, ou projetos em que o desempenho gráfico é importante, a versão pro vale a pena. Eu uso a versão pro, porque eu desenvolver jogos de realidade virtual para o Oculus Rift, ea tela-espaço suporte pós-processamento é necessário para interagir corretamente com o fone de ouvido.Tudo que você quer saber sobre o Oculus Rift Dev-KitTudo que você quer saber sobre o Oculus Rift Dev-KitO futuro está aqui - o Oculus Rift foi finalmente começou a entregar. É cedo ainda, mas se você é um dos poucos sortudos que apoiaram ou pré-ordenada do kit dev, aqui está uma coleção de ...consulte Mais informação

Você pode conferir uma versão alfa precoce de um dos meus jogos VR, BeatRunner. Deve dar-lhe um sentido para o que Unity torna possível.

3. Instalando Unity

A unidade é simples de instalar. Você pode baixar o executável aqui (para o instalador OSX, clique no link que diz ‘em desenvolvimento em Mac OS X?`). Deixe-o download, execute-o e siga as instruções do instalador. Quando a instalação estiver concluída, uma janela intitulada ‘ativar sua licença Unity` aparecerá. Marque a caixa ‘ativar uma versão de avaliação gratuita por 30 dias do Unity Pro` e clique em‘OK `.

Parabéns! Você sabe que tem um teste de 30 dias de Unity Pro. Quando o julgamento expira, se você não quiser comprar a versão pro, você pode alternar para a versão gratuita e manter o seu conteúdo existente.

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

Antes de começar com a unidade, é importante que nós vamos sobre o básico um pouco. Unity suporta tanto C # e javascript para Programação- jogo que estará trabalhando com C # para este tutorial. Primeiro, se você nunca tenha programado antes, colocar este tutorial de lado e passar alguns dias de trabalho por meio de linguagem C # Primer da Microsoft até se sentir confortável usando a linguagem para tarefas simples. Se tiver programado antes em uma linguagem imperativa ou orientada a objeto como C ou Java, roçar o primer e se familiarizar com a forma como C # difere de outros idiomas que você usou no passado. De qualquer maneira, não prosseguir com o tutorial até se sentir confortável resolver problemas simples com C # (por exemplo, se eu pedir-lhe para escrever um programa que imprime os primeiros cem números primos, você deve ser capaz de escrever esse programa sem consultoria Google).Top 10 sites Código de exemplo profissional para programadoresTop 10 sites Código de exemplo profissional para programadoresconsulte Mais informação

O conceito mais importante a compreender aqui é a paradigma de orientação a objeto (Abreviado como OOP). Em linguagens orientadas a objeto, os programas são divididos em unidades funcionais chamadas objetos. Cada objeto tem suas próprias variáveis privadas e funções. funções específicas do objeto são chamados métodos. A idéia aqui é a modularidade: fazendo com que cada objeto isolado, e forçando outros objetos para interagir com ele através de seus métodos, você pode reduzir o número de interações possíveis não intencionais - e, por extensão, bugs. Você também pode criar objetos que você pode reutilizar à vontade mais tarde com nenhuma modificação. Na Unidade, você estará construindo esses objetos e anexá-los ao jogo entidades (cujo comportamento eles vão governar).

Os objetos são instanciado a partir de classes: a classe é apenas um arquivo que estabelece a definição de seu objeto. Então, se você quer um objeto ‘Mook` que lida com AI para um inimigo em seu jogo, você escreveria uma classe‘Mook`, e em seguida, anexar o arquivo para cada entidade inimiga. Quando você executar o seu jogo, cada inimigo será equipado com uma cópia do objeto a ‘Mook`.

Colocar um novo script para um objeto parecido com este:

Primeiro, selecione o objeto e vá para o inspetor. Em seguida, clique no botão ‘Adicionar Componente` botão.

Ir para ‘novo script `, digite o nome que deseja e clique em‘criar e adicionar.

Agora você tem um novo script, que você pode editar, clicando duas vezes sobre ele!

Um arquivo de classe é algo como isto:

utilização UnityEngine-público classe Mook : MonoBehaviour {privado flutuador saúde-vazio Começar () {saúde = 100-}vazio Atualizar(){E se (saúde gt; 0){// busca de jogador// se você encontrar o jogador na estrada, matá-lo// se você levar um tiro, remover uma quantidade aleatória de saúde}}}

Vamos decompô-lo:

Video: Programação de Jogos em C++ Modulo 1 / Aula 1 - Tipos Primitivos de Dados e Entrada e Saída

usando UnityEngine- -Essa linha informa C # que nós queremos usar bibliotecas de unidade, que nos permitem conectar-se ao motor de jogo Unity.
classe pública Mook: MonoBehaviour {-Esta linha realmente declarou a classe e seu nome ( “Mook”) -
saúde- flutuador privado -Isto declara uma variável de classe privada (que só pode ser alterado de dentro da classe). A variável é atribuído um valor em Iniciar ().
vazio Iniciar () {-Este declara um método chamado ‘Start `. Iniciar é um método especial que é executado apenas uma vez, quando o jogo inicialmente lança.
vazio Update () {-Update é outro método especial, que é executado em cada frame. A maioria de sua lógica de jogo vai aqui.
// se você encontrar o jogador na estrada, matá-lo -Esta linha é um comentário (qualquer linha que começa com uma barra dupla é ignorado pelo C #). Os comentários são usados para lembrar-se do que pedaços de código específico fazer. Neste caso, este comentário está sendo usado para substituir um bloco mais complicado de código que realmente faz o comentário descreve.

Junto com ‘Start` e‘Update,` você pode instanciar seus próprios métodos com quase qualquer nome. No entanto, os métodos que você cria não será executado, a menos que eles são chamados. Vamos declarar um método para uma classe hipotética chamada myClass que adiciona dois números juntos.

público flutuador AddTwoNumbers(flutuador uma, flutuador b){Retorna uma+b-}

Este declara um público (acessível a outros objetos) que retorna um float, chamados de “AddTwoNumbers”, que leva dois carros alegóricos como entrada (chamada a e b). Em seguida, ele retorna a soma dos dois valores como sua saída.

Chamar esse método de dentro da mesma classe (digamos, de Atualização dentro) se parece com isso:

flutuador resultado = AddTwoNumbers(1,2)-

Chamar o método de outra classe é semelhante:

instância myClass-flutuador resultado = instância.AddTwoNumbers(1, 2)-

Novamente, isso só cria uma instância de nossa classe, acessa o método apropriado e alimenta os números que deseja adicionar, em seguida, armazena o resultado em ‘resultado `. Simples.

Se o seu script está anexado a um objeto que tem 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 jogo usando o método getComponent .

A sintaxe para que se parece com isso:

getComponentlt;ParticleSystemgt;().Toque()-

Se nada disto é estranho para você, voltar e passar pelo C # primer. Ele vai te salvar um monte de frustração à medida que prosseguimos.

5. Basics unidade

Nesta seção, vamos trabalhar o nosso caminho através dos mecanismos básicos do motor Unity. O fluxo de trabalho no Unity é algo como isto: criar uma entidade para servir um papel no jogo (GameObjects em branco pode ser usado para tarefas lógicas abstratas). Em seguida, escrever ou encontrar um arquivo de classe, e adicioná-lo à entidade como um script (usando o botão `adicionar o componente` na vista `inspector`. Em seguida, executar, testar, depurar, repita até que ele funciona e passar para o próximo elemento do jogo.

Unidade vem com uma série de guias de visualização básicas que podem ser definidos de várias maneiras para o gosto do usuário. O big five estão na guia ‘jogo`, na guia‘cena`, na guia ‘inspector`, na guia‘projeto`, eo ‘guia hierarquia. A guia jogo, quando o botão ‘play` está deprimido, exibe uma instância em execução do jogo que o usuário pode interagir com e teste. A guia ‘cena` fornece uma versão estática, editável do gameworld. A guia ‘inspector` permite ao usuário modificar entidades individuais no mundo do jogo, selecionando-os na guia‘editor`. A guia ‘projecto` permite ao usuário navegar através de arquivos do projeto e modelos de arrasto, materiais e outros recursos para o separador‘editor` para colocá-los no mundo do jogo. Finalmente, a guia ‘hierarquia` mostra todos os objetos do mundo, permitindo-lhe encontrar objetos distantes na cena e entidades controladoras um para o outro, clicando e arrastando. Consulte o diagrama abaixo para a localização de todas estas coisas.Começar a criar jogos agora mesmo com Unity3D gratuitoComeçar a criar jogos agora mesmo com Unity3D gratuitoconsulte Mais informação

5.1 Entidades unidade

5.1.1 malhas

Malhas são a maneira geometria 3D é representado na Unidade. O utilizador pode usar objectos incorporados ‘primitivas`(cubos, esferas, cilindros, etc.) da Unidade, ou importação seus próprios modelos 3D a partir de um pacote de modelagem como Blender ou Maya. Unidade suporta uma variedade de formatos, incluindo 3D Collada (.fbx), e .3ds.Criar belas modelos 3D Organic gratuitamente com Sculptris [Windows & Mac]Criar belas modelos 3D Organic gratuitamente com Sculptris [Windows & Mac]Sculptris é uma ferramenta de design 3D por Pixologic, fabricantes de US $ 699 ferramenta 3D profissional ZBrush. Ela vem de uma boa casa, mas ao contrário de seu aplicativo irmã, Sculptris é inteiramente livre. Nós cobrimos Sculptris em ...consulte Mais informação

As ferramentas básicas para manipular malhas são os de escala, rotação e botões de tradução no canto superior esquerdo da interface. Estes botões adicionar ícones de controle para os modelos na visualização do editor, que podem então ser usados para manipulá-los no espaço. Para alterar a textura ou física propriedades de um objeto, selecione-as e use a exibição ‘inspector` para analisar o‘material` e elementos ‘corpo rígido`.

5.1.2 GUI Elements

sprites GUI tradicionais e de texto podem ser exibidos usando o ‘GUI Texto` e GameObjects a‘textura GUI` no editor. No entanto, uma maneira mais robusto e realista para lidar com elementos de interface do usuário é usar o texto 3D e Quad GameObjects (com texturas transparentes e um shader transparente apagado) para colocar elementos do HUD para o gameworld como entidades. Na visão ‘hierarquia`, estes elementos de jogabilidade pode ser arrastado para a câmara principal para torná-los crianças, garantindo que eles mover e girar com a câmera.

elementos GUI (texto e texturas) podem ter seu tamanho e escala ajustada usando os campos relevantes na guia inspetor.

5.1.3 materiais

Materiais são combinações de texturas e shaders, e pode ser arrastado diretamente em objetos do jogo a partir da guia projeto. Um grande número de shaders vêm com Unity Pro, e você pode ajustar a textura ligado a eles usando a guia inspector para um objeto que está aplicado.Cinco PC Gaming Termos importantes ExplicadaCinco PC Gaming Termos importantes ExplicadaSe você jogar um jogo em um console, os detalhes técnicos são tratados para você. Alguns jogadores preferem este, mas os jogadores de PC muitas vezes gozam de maior grau de controle que têm sobre o olho de um jogo ...consulte Mais informação

Para importar uma textura, apenas convertê-lo para um jpg, png ou bmp, e arrastá-lo para a pasta ‘ativos sob o diretório do projeto Unity (que aparece em‘Meus Documentos por padrão). Depois de alguns segundos, uma barra de carregamento irá aparecer no editor. Quando terminar, você será capaz de encontrar a imagem como uma textura no separador ‘projecto`.

5.1.5 luzes

As luzes são GameObjects que projeto brilho para o mundo. Se não há luzes em sua cena, todos os polígonos são desenhados ao mesmo nível de brilho, dando ao mundo um olhar ‘flat`.

As luzes podem ser posicionados, giradas e tem várias características internas que você pode personalizar. O controle deslizante ‘intensidade` controla o brilho da luz, eo‘range` controla o quão rápido ele desaparece. As diretrizes da vista da cena mostrar-lhe o alcance máximo da iluminação. Jogar com ambas as configurações para atingir o efeito desejado. Você também pode ajustar a cor da luz, o padrão ( “cookie” exibido na superfície da luz é apontado para, e que tipo de alargamento aparece na tela quando se olha diretamente para a luz. O cookie pode ser usado para luz mais realista falso padrões, criar dramáticos sombras falsas e simular projetores.

Os três principais tipos de luz são ‘local`,‘ponto`, e ‘direcional.` luzes no local têm uma localização no espaço 3D e luz do projeto em apenas uma direção em um cone de ângulo variável. Estes são bons para lanternas, holofotes, e, em geral, dar-lhe um controle mais preciso da iluminação. luzes no local pode lançar sombras. As luzes de ponto tem uma localização no espaço 3D, e lançar luz uniformemente em todas as direções. As luzes de ponto não lançam sombras. luzes direcionais, finalmente, são utilizados para simular a luz solar: eles projetam luz em uma direção como se de infinitamente distante. luzes direcionais afetar cada objeto na cena, e pode produzir sombras.

5.1.6 Sistemas de partículas

Os sistemas de partículas são a termo para a unidade GameObjects que geram e controlam a centenas ou milhares de partículas simultaneamente. Partículas são pequenas, objetos 2D otimizadas exibidas no espaço 3D. sistemas de partículas usam versão simplificada e física, mas pode exibir milhares de entidades em tempo real, sem gaguejar, tornando-os ideais para o fumo, fogo, chuva, faíscas, efeitos mágicos e muito mais.

Há uma série de parâmetros que você pode tweak para conseguir estes efeitos, e você pode acessá-los por gerar um sistema de partículas sob o editor componente, selecionando o sistema de partículas, e em seguida, abrir a aba ‘inspector`. Você pode mudar o tamanho, velocidade, direção, rotação, cor e textura de cada partícula, e definir a maioria desses parâmetros para alterar ao longo do tempo também. Sob o atributo `colisão`, se você ativá-lo e definir o espaço de simulação para `mundo` você vai ter partículas que colidem com os objetos do mundo, que podem ser usados para uma série de efeitos de partículas realistas, incluindo chuva, movendo de água, e de faíscas.

6. Exemplo: Elementos básicos de um jogo

Para este tutorial, vamos fazer um jogo simples de pong. Nesta seção, nós vamos passar por cima de organizar os elementos centrais - o tutorial scripting virá mais tarde.Como recriar o jogo Pong clássico Usando ArduinoComo recriar o jogo Pong clássico Usando ArduinoPong foi o primeiro videogame que nunca que atingiu o mercado de massa. Pela primeira vez na história, o conceito de um "videogame" foi trazido para a casa da família, graças à Atari 2600 -...consulte Mais informação

Video: Tibia - Como iniciar no jogo - como jogar

Primeiro, vamos quebrar o jogo do Pong em seus componentes básicos. Primeiro, precisamos de duas pás e uma bola. A bola voa fora da tela, por isso vamos querer um mecanismo para redefini-la. Nós também queremos texto para exibir a pontuação atual, e, por uma questão de mostrar-lhe todos os elementos centrais da Unidade, que vai querer um efeito de partícula fantasia quando você bater a bola, e todo o jogo terá de ser drasticamente lit.

Que se decompõe em um objeto bola (uma esfera), um spawner, dois suportes de remo com emissores de partículas unidas, uma entidade de texto 3D, e uma luz do ponto. Para este tutorial, vamos estar usando o material físico default ‘salto `, com salto combinam definido para‘multiplicar`. Aqui está o que a configuração parece, em dez screenshots:

Primeiro, crie um suporte de cubo para o remo.

Escalá-lo de forma adequada, duplicá-lo, e colocar uma esfera entre as pás para a bola.

Video: RPG de Mesa - Dicas para Mestres e Jogadores iniciantes! Escolhendo o Sistema

Em seguida, crie um objeto 3DText e escala e posicioná-lo corretamente, a alteração do ‘tamanho da fonte` atributo para obter uma imagem menos pixelizada.

Em seguida, criar dois sistemas de partículas, escolher as características que você quer, e anexá-las para as pás.

Em seguida, você vai querer posicionar e girar a câmera para que ele enquadra a cena corretamente. Enquanto a câmera é selecionado, você pode ver uma pequena prévia de vista da câmera no canto inferior direito.

Antes de terminar, é preciso criar dois cubos adicionais para ser pára-choques, para evitar que a bola saltando fora da área de jogo. Podemos torná-los invisíveis desmarcando a ‘renderizador mesh` no separador inspetor.

Se você bater em jogo, agora você pode ver os elementos básicos do nosso jogo estabelecidas. Eles não vão fazer nada ainda, mas nós vamos chegar a isso!

Agora que nós temos que setup, vamos falar sobre o que está envolvido no script esses elementos para fazer um jogo.

7. Scripting em Unity

Depois de ter um script anexado a um objeto, você pode revisá-lo clicando duas vezes sobre ele no ‘inspector `. Isso abre MonoDevelop, o ambiente de desenvolvimento padrão para a Unidade. Em essência, Monodevelop é um editor de texto com características especificamente otimizadas para programação. Palavras-chave e comentários são destacadas em valores azuis e verdes, e numéricos e cordas aparecem em vermelho. Se você já usou Eclipse ou outros IDE, MonoDevelop é muito semelhante. Você pode ‘construir` seus scripts de dentro do editor, para verificar se há erros de sintaxe, assim:Os princípios de computador Programação 101 - Variáveis e tipos de dadosOs princípios de computador Programação 101 - Variáveis e tipos de dadosTendo introduzido e falou um pouco sobre Programação Orientada a Objetos antes e onde seu xará vem, eu pensei que é hora de passar os princípios absolutos de programação de uma maneira específica não-linguagem. Este...consulte Mais informação

Em geral, para obter o seu roteiro para interagir com Unity, você vai precisar fazer referência a elementos que o objeto segurando o roteiro possui (você pode ver uma lista destes elementos sob a aba ‘inspector` quando o objeto relevante é selecionado). Você pode então chamar métodos ou definir variáveis para cada um desses elementos para promulgar as alterações desejadas.

Se você quer um script em um objeto para afetar as propriedades de um objeto diferente, você pode criar uma variável GameObject vazio em seu script, e use o inspector para atribuí-la a outro objeto na cena. As imagens abaixo mostram o que parece.

Uma lista dos elementos de um objecto pode ter é como se segue (feita a partir da vista de um inspector de nossos pás no exemplo acima):

Transformar
Cube (Filter Mesh)
box Collider
malha Renderer

Cada um destes aspectos do objeto pode ser influenciada a partir de um script. A seguir, vamos olhar exatamente como.

7.1 Transformar

As funções de transformação para um GameObject em Unidade controlar os parâmetros físicos do que objecto: a sua dimensão, a sua posição e a sua orientação. Você pode acessá-los a partir de um script como este:

transformar.posição = newPositionVector3-transformar.rotação = newRotationQuaternion-transformar.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 seria de esperar, armazenado como Vector3s. Pode aceder x, y, z e componentes de cada um (por exemplo, transform.position.y lhe dá a distância de um objecto acima do plano zero). No entanto, para evitar o bloqueio do cardan, rotações são tratados como Quaternions (vectores de quatro componentes). Porque quatérnions de manipulação de mão é intuitiva, é possível manipular as rotações usando ângulos de Euler usando o método Quaternion.Euler da seguinte forma:

transformar.rotação = quaternião.Euler(breu, guinada, lista)-

Se você deseja mover objetos sem problemas a partir de um lugar para outro, você vai encontrar o método Slerp para quaternions e vector3s votos. Slerp leva em três argumentos - o estado atual, o estado final, e a velocidade da mudança, e sem problemas interpola entre eles na velocidade dada. A sintaxe parecida com esta:

transformar.posição = Vector3.Slerp(startPositionVector3, newDestinationVector3, 1)-

7,2 renderizador

As funções de representante em Unity permitem controlar a forma como as superfícies de adereços são renderizadas na tela. Você pode transferir a textura, mudar a cor, e mudar o shader e visibilidade do objeto. A sintaxe parecida com esta:

renderizador.ativado = falso-renderizador.material.cor = Novo Cor(0, 255, 0)-renderizador.material.mainTexture = myTexture-renderizador.material.shader = newShader-

A maioria destes tem funções muito claras. O primeiro exemplo faz com que o objeto em questão invisível: um truque útil em várias situações. O segundo exemplo atribui uma nova cor RGB (ou seja, verde) para o objecto em questão. O terceiro atribui a textura difusa principal para uma nova variável textura. O último exemplo altera o shader do material do objeto a uma variável shader recém-definido.

7.3 Física

Unidade vem com um sistema integrado motor de física que permite atribuir as propriedades físicas dos objetos e deixar os detalhes de sua simulação ser feita para você. Em geral, ao invés de tentar implementar a sua própria física usando um livro didático eo sistema de transformar, é mais simples e mais robusto para uso motor de física da Unidade na maior medida possível.Quebra, unidade & Constituição: 3 impressionantes Física caixas de areia SimuladoresQuebra, unidade & Constituição: 3 impressionantes Física caixas de areia Simuladoresconsulte Mais informação

Todos os suportes físicos exigem aceleradores. No entanto, a própria simulação real é tratado por um corpo rígido, que pode ser adicionado à vista inspector. Rigidbodies pode ser cinemática ou nonkinematic. adereços física cinemáticas colidir com (e efeito) adereços física nonkinematic ao seu redor, mas não são afetados pela colisão si. adereços cinemáticas estáticos são os objetos immoveable proverbiais, e mover objetos cinemáticos são a força imparável proverbial (para o registro, quando eles colidem, eles simplesmente passar por uns aos outros). Além disso, você pode ajustar o arrasto angular do objeto (quanta energia é preciso para girá-lo), mudar a sua massa, ditar se é ou não é afetada pela gravidade, e aplicar forças a ele.

Exemplos:

corpo rígido.angularDrag = 0.1f-corpo rígido.massa = 100-corpo rígido.isKinematic = falso-corpo rígido.useGravity = verdade-corpo rígido.AddForce(transformar.progressivo * 100)-

Estes são todos bastante auto-explicativo. A única coisa a notar aqui é o uso de ‘transform.forward.` de Vector3 todos têm três componentes (.forward, .Até, e .right) que lhes estão associados, o que pode ser acedido e gira com eles ( “para a frente” é o sentido da seta azul no editor). “Transform.forward” é simplesmente o vetor de frente para o objeto atual com magnitude 1. Ele pode ser multiplicado por um flutuador para criar mais força sobre o objeto. Você também pode fazer referência a “transform.up” e “transform.right”, e negá-los para obter os seus reveses.

7,4 Colisão

Muitas vezes, quando a construção de um jogo, você gostaria de uma colisão para resultar em alguma mudança de estado-of-no seu código, além de apenas simulação de 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ário para detectar colisões na Unidade. Em primeiro lugar, pelo menos, um dos objectos da colisão precisa de um corpo rígido não-cinemático ligado a ele. Ambos os objetos devem ter colliders corretas, previsto para ser não-gatilhos. A velocidade total de ambos os objetos deve ser baixa o suficiente para que eles realmente se chocam, em vez de simplesmente pular através de um outro.

Se você tem tudo o que tomar cuidado, você pode verificar se há colisão, colocando um método de detecção de colisão especial em um script anexado ao objeto que você gostaria de verificar colisão com. O método será parecido com este:

vazio OnCollisionEnter(colisão outra){// fazer as coisas aqui}

Este método será executado automaticamente durante o primeiro quadro que outro objeto toca o seu objeto. A entidade de colisão ‘outro` é uma referência para o objeto que você bateu. Você pode, por exemplo, a referência a sua ‘GameObject,`‘corpo rígido,` e ‘transformar` características para manipulá-lo de várias maneiras. Enquanto `OnCollisionEnter` é provavelmente a função mais comum que você vai usar, você também pode usar `OnCollisionExit` e `OnCollisionStay` (com a sintaxe de outra forma idêntica e uso), que ativam durante o primeiro quadro que você parar de colidir com um objeto e durante cada quadro que você está colidir com um objeto, respectivamente.

Às vezes, também pode ser útil para fazer o que é chamado raycasting. Em raycasting, uma linha infinitamente fina (a ‘ray `) é lançado através do mundo de alguma origem, ao longo de algum vetor, e, quando ela atinge algo, a posição e outros detalhes da primeira colisão são devolvidos. O código para um raycast parece com isso:

hit RaycastHit-E se (Física.Raycast(transformar.posição, -Vector3.acima, Fora acertar)){flutuador distanceToGround = acertar.distância-}

Isto lança um raio a partir da posição do objeto atual ao longo -Vector3.up (para baixo), e liga a variável ‘hit` para o primeiro objeto que colide com. Uma vez que seu raio atingiu alguma coisa, você pode acessar hit.distance para determinar o quão longe ele é, ou hit.GameObject para manipular o objeto que você bateu.

Raycasts como este pode ser usado para atiradores para determinar o que a arma do apontou para, ou para selecionar objetos quando a câmera olha para eles, ou para certos estilos de mecânico movimento.

7,5 Correção tempo

Um factor importante a ter em mente quando você está manipulando objetos desta forma tem a ver com framerate. Não importa quão cuidadosamente você otimizar, framerates será sempre variam, e você não quer que a sua velocidade de jogo para variar de acordo. Se alguém corre o seu jogo em um computador mais rápido do que você desenvolveu-lo, você não quer que o jogo seja executado ao dobro da velocidade.

A maneira como você corrigir isso é através da multiplicação dos valores que você está usando no momento em que tomou para tornar o último quadro. Isso é feito usando ‘Time.deltaTime. Isso efetivamente muda a velocidade de qualquer variável que você está incrementando cada quadro de ‘mudança por frame` a‘mudança por segundo,` e você provavelmente deve fazer essa alteração a qualquer valor que você está aumentando ou diminuindo cada frame.

7,6 Fontes de áudio e ouvintes

Agora que nós cobrimos como criar, renda, e objetos de controle, vamos falar sobre o outro sentido de que os jogos de computador pode servir: ou seja, som. Unity suporta dois tipos de sons: 2D e 3D parece. sons 3D variar o seu volume com base na distância, e distorcer como eles se movem em relação ao câmera- 2D sons não. sons 2D são apropriados para voice-overs e música de fundo e sons 3D aplicam aos sons gerados por eventos no mundo. A fim de mudar ou não de um som é 3D, selecione-o na vista ‘projecto`, alternar para a exibição‘inspector` e selecione a opção apropriada no menu suspenso, em seguida, pressione o botão ‘reimportação`.

A fim de realmente jogar o som, você precisa anexar uma `AudioSource` para um suporte (o suporte que você deseja que o som se originar de, no caso de um som 3D. Então você vai precisar para abrir o `AudioClip `campo e selecione o arquivo de som.

Você pode usar myAudioSource.Pause () e myAudioSource.Play () para controlar esses arquivos de som. Você pode ajustar os comportamentos Falloff, volume e deslocamento doppler dos sons sob a aba ‘inspector` para o AudioSource.

7.7 Entrada

Um jogo que não leva qualquer entrada do usuário não é muito de um jogo. Há um monte de diferentes tipos de entrada que você pode ler, e quase todos eles são acessíveis através dos objetos de entrada e de código. Algumas declarações de entrada de amostra (que têm um valores avaliados cada quadro) são abaixo.

Vector3 mousePos = Entrada.MousePosition-bool isLeftClicking = Entrada.GetMouseButton(0)-bool isPressingSpace = Entrada.GetKey(Código chave.Espaço)-

As funções destas linhas é geralmente auto explicativo. Usando esses três tipos de referência de entrada, você pode reconstruir os sistemas da maioria dos jogos de computador 3D modernos de controle.

7,8 Depurar um script

Digamos que um script não funciona. Como o bom médico diz, bangups e hangups pode acontecer com você. Se houver erros de sintaxe definitivas com o C #, o jogo geralmente se recusam a executar quando você bate o jogo, e algumas mensagens de erro bastante úteis são fornecidos se você ‘construir` os scripts de dentro do editor. Ver abaixo:

Estes erros não são normalmente os mais difíceis de corrigir. O que pode ser mais problemático são erros semânticos sutis, em que você escreveu com êxito um arquivo cheio de válido C # - não apenas aquele que faz o que você pensava que seria. Se você tem um destes erros, e você está tendo problemas para segui-lo para baixo, existem algumas coisas que você pode tentar melhorar a situação.

O primeiro é para pausar a execução do jogo, e verifique o console. Você pode pausar o jogo clicando no ícone ‘pause` na porção média superior do editor, e, em seguida, selecionando‘console` a partir da parte inferior do menu ‘janela`(ou pressionando Ctrl-Shift-C). Mesmo se não há erros, avisos ainda pode ajudar a dar algumas pistas sobre o que pode estar acontecendo de errado.

Se isso não funcionar, você também pode tentar obter uma ideia sobre o estado do seu script, imprimindo o estado de variáveis internas para validar que 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 para o console quando a execução do programa atinge essa linha. Em geral, se você trabalhar para trás a partir do que você acha que deveria estar acontecendo através das coisas que deveria estar fazendo isso acontecer, eventualmente, você vai chegar a um ponto onde seus depuração impressões não fazer o que você espera que eles façam. É aí que o seu erro é.

8. Exemplo: Script Pong

Para construir Pong, vamos quebrar o jogo em seus elementos fundamentais: precisamos de uma bola que ricocheteia frente e para trás entre as pás a uma velocidade crescente, precisamos de um painel de avaliação que sabe quando as bolas passaram as pás, e precisamos de um mecanismo para reiniciando a bola quando isso acontece. Um bom primeiro passo seria adicionar um corpo rígido não-cinemática para a bola, dois rigidbodies cinemáticas para os remos, desativar gravidade para todos eles, e atribuir um material físico apropriado dos ativos padrão ( `salto` com `salto combinar` definido como `multiplicar).

Abaixo, você pode ver o roteiro para a bola com comentários explicativos. A bola precisa realizar algumas metas básicas: deve saltar em um padrão complicado, sempre mantendo o movimento em ambos os eixos, e deve acelerar a um ritmo desafiador, mas não impossível na direção horizontal.

BallHandler.cs

Em seguida, precisamos roteiro nossa pá, que você pode, mais uma vez, ver abaixo. O remo precisa mover para cima e para baixo em resposta ao pressionamento de teclas (mas não fora de certos limites). Ele também precisa acionar o sistema de partículas quando colide com algo.

PaddleHandler.cs

Em seguida, precisamos inimigo AI: algo que fará com pá do inimigo para rastrear para a bola a uma taxa fixa. Para isso, vamos estar usando Vector3.Slerp para a máxima simplicidade. Também gostaríamos o mesmo comportamento de partículas que vemos na nossa própria pá.

EnemyAI.cs

Finalmente, temos um script para atualizar o placar e repor a bola quando ela sai dos limites.

ScoreboardUpdater.cs

Com esses scripts anexados e as referências preenchidos, quando executar o nosso jogo de Pong, nós experiência de jogo!

Você pode baixar a minha demonstração Pong, se você gostaria de ver tudo o que eu esbocei em ação. Ele roda em sistemas Windows, Mac e Linux.

9. Explorando a Documentação / Aprender Mais

A unidade é um mecanismo complexo, com muitos mais recursos do que seria exequível coberto de um guia deste estilo, e isso antes de você incluir a ampla faixa de extensões Unity (livre e comercial) disponíveis na Internet. Este guia vai lhe dar um forte ponto de partida para o desenvolvimento de um jogo, mas a auto-educação é uma habilidade importante em qualquer empreendimento, e duplamente por isso aqui.

Um recurso crucial aqui é a Unidade ScriptReference. O ScriptReference é um banco de dados pesquisável, disponível tanto para C # e javascript, que tem uma lista de todos os comandos Unidade e funcionalidade, com descrições de suas funções e breves exemplos de sintaxe.

Se você está tendo problemas com o editor e interface Unity, ou apenas como vídeo tutoriais como uma questão de preferência, há uma longa lista de alta qualidade de vídeo tutoriais Unidade disponíveis. Mais extensas (mas menos largos) tutoriais de texto para a Unidade também estão disponíveis a partir CatLikeCoding.

Finalmente, se você tiver dúvidas para além do âmbito de documentação ou tutoriais, você pode fazer perguntas específicas em answers.Unity3d.com. Lembre-se que as respostas são fornecidas por voluntários, por isso, respeitar o seu tempo e pesquisar o banco de dados para ter certeza de sua pergunta já não foi respondida.

10. Construindo seu jogo / Compilando a um aplicativo independente

Quando você construiu algo que você está orgulhoso (ou você terminar de clonar o nosso exemplo Pong pouco desertor para a prática), é hora de mover o seu jogo a partir do editor e transformá-lo em algo que você pode postar na Internet e força seus amigos e familiares para jogar. A fim de fazer isso, você vai precisar para construir um aplicativo independente. A boa notícia é que em Unity, isso é muito, muito fácil. Há, no entanto, alguns potenciais hiccoughs que você vai querer ter cuidado.

Para começar, saiba que você só pode construir um projeto livre de erros. Para esse fim, verifique se você tem o console aberto como você construir: existem algumas condições de erro que o jogo irá ignorar no editor, mas ainda irá abortar uma tentativa de construir. Isso só despeja mensagens de erro para o console, sem resultados visíveis na tela, que pode ser frustrante se você se esquecer de verificar. Assim que tiver o seu jogo compilação livre de erros, porém, você pode selecionar ‘Build Configurações no menu‘File`, ou pressione Ctrl-Shift-B. Isso fará com que uma caixa de diálogo simples que permite que você construa o seu jogo para várias plataformas.

O processo de lá é auto-explicativo: selecionar suas opções, e clique em ‘build` o jogo irá solicitar um diretório para instalar, e vai colocar tanto o executável e diretório de dados lá. Esses dois arquivos podem ser compactados juntos e distribuídos (apenas certifique-se que você não está cobrando para um jogo construído no demo Unidade, pois isso viola os termos de serviço).

11. fechando Notes

Como acontece com qualquer ferramenta de desenvolvimento de jogos, a chave para o sucesso com Unity é o desenvolvimento iterativo. Você tem que construir em incrementos gerenciáveis - ser ambicioso, por todos os meios, mas ser ambicioso em pequenos pedaços, e organizar esses pedaços de tal forma que, mesmo se você ficar aquém do seu objectivo final, você vai pelo menos acabar com um produto coerente . Obter os elementos mais cruciais em primeiro: tem uma idéia na mente de seu ‘produto viável mínimo `, a mais simples, mais nu-ossos coisa que você poderia criar e ainda se sentir como se você conseguiu algo de valor. Chegar a esse projeto mínima viável antes de passar para ambições maiores.

Este tutorial dá-lhe um forte ponto de partida, mas a melhor maneira de aprender A unidade é ao construir um jogo. Comece a construir um jogo, preencher lacunas em seu conhecimento como eles vêm para cima, e o fluxo gradual de conhecimento irá corroer afastado as coisas que você não conhece uma rapidez surpreendente. A unidade é uma ferramenta poderosa, e com um pouco de exploração, você pode ser a construção de projetos impressionantes com ele mais rápido do que você poderia esperar. Boa sorte, e desfrutar de Unidade!

Guia Publicado: fevereiro 2014