Transcrições
1. Apresentação: Ei lá e bem-vindo ao meu curso sobre os
conceitos básicos de unidade. Unity é um dos, se não o motor de
jogo mais conhecido lá fora e muitos mundo incrivelmente bem sucedido e os títulos,
incluindo Cupcake, alguns Nonaka, Hollow Knight escaparam do taco
e Ganesha impacto. Somos todos feitos
usando este mecanismo. Escusado será dizer que
aprender a desenvolver jogos especificamente no Unity não é habilidade
incrivelmente útil
para se ter no mundo de hoje. Se você está planejando
trabalhar no desenvolvimento de jogos, criar seus próprios jogos independentes ou apenas aprender uma nova habilidade. Dito isto, você
já pode ser bastante intimidante e
carregá-lo pela primeira vez, você pode ficar um pouco
confuso é como tudo funciona
e o que faz o quê. Neste curso, abordaremos
todos os conceitos básicos do Unity explicados em detalhes para
permitir que você se familiarize muito, muito mais
com o mecanismo do jogo. Quando você
concluir este curso, você ficará confortável o suficiente
no editor Unity para começar a trabalhar em seu primeiro aplicativo de
jogo ou animação. Deve-se notar, no entanto,
que, embora este curso seja um tutorial completo sobre tudo o que você precisa saber para começar. Unity, não ensine todos os
conceitos em um vídeo separado. Isso nos permitirá focar em cada conceito
fora da taxa digerível. Mas, por favor, note que não
estaremos criando um jogo completo completo
no final deste curso. Se isso lhe interessa,
recomendo verificar meu outro curso, como criar sua primeira unidade de jogos para
dispositivos móveis. Como nesse curso, você fará o
jogo do início ao fim. Nós preferimos simplesmente
aprender todas as ferramentas que você precisa para construir seus próprios
jogos no Unity híbrido, você veio ao lugar certo pois depois de concluir este curso, você será capaz de
construir seu primeiro jogo do zero. Os conceitos que abordaremos
incluem como o Unity funciona, os conceitos básicos de unidade, tipos de scripts, conceitos de
feedback, ferramentas de
análise e métodos de
construção. Depois de concluir
todas essas seções, você será um desenvolvedor
Unity completo para dizer o mínimo. Então esse é um resumo básico
do que faremos. Espero que isso soe como um curso interessante e
educacional que vejo você
no próximo vídeo, onde
nos apresentaremos ao Unity Editor. Obrigado pelo seu
interesse e
espero que você tenha um ótimo
descanso do dia.
2. O layout da Unity: Ei lá e bem-vindo
ao meu curso. Muito
obrigado por me dar a oportunidade de
ensinar-lhe o básico da unidade. Como descobri na minha experiência, que saber como
usar esse mecanismo de jogo não é uma habilidade incrivelmente
útil de se ter. Como mencionei no
curso é introdução, esses conceitos básicos serão
divididos em seções diferentes. Este vídeo marca
o início
da primeira seção
como o Unity funciona. Começaremos com o layout da Unity. Se você der uma olhada
na captura de tela que
fiz em um
projeto vazio no Unity, poderá ver todos os compartimentos
básicos
do editor Unity divididos em seções
diferentes e
rotulados na tela. Neste vídeo, vamos dar uma explicação detalhada como cada
um deles funciona e o papel que eles desempenham
no editor Unity, começando pelo menu. Agora, antes de começarmos com todos os diferentes compartimentos
do útero, o layout, primeiro
vamos fazer
um tutorial rápido sobre como baixar Unity e
criar seu primeiro projeto. A primeira coisa que você vai fazer é ir
para este site, unity.com, baixar
barra direta e clicar neste botão de download
Unity Hub para Windows, Mac ou Linux,
dependendo de o que é seu sistema
operacional. A partir disso, basta seguir as instruções básicas de
configuração de instalação que estarão presentes
na tela. Depois disso, você vai
querer configurar um editor de código. Então vá para o seguinte site, Visual Studio.Microsoft.com
encaminhar os
downloads de barra e baixe
a versão mais recente do Visual Studio Community,
pois isso permitirá que você edite seu código e
integre perfeitamente em Unity. Se isso não vier
pré-instalado com o Unity, configurá-lo com o Unity
é incrivelmente fácil. Você simplesmente precisa ir por aqui. Depois de criar seu
primeiro projeto Unity, clique aqui, edite,
selecione Preferências, boas Ferramentas Externas
e certifique-se de que seu editor de script externo
esteja definido para a versão do Microsoft Visual Studio
que você instalou. Depois que isso for concluído, depois de baixar o Unity Hub, vá em frente e clique aqui para
criar seu primeiro projeto. Selecione o modelo do projeto. Normalmente, vou com o nome do projeto
2D, localização e clique em Criar para criar seu primeiro projeto Unity. Depois de baixar
e instalar o Unity e criar
seu primeiro projeto, você deverá receber
o layout a seguir. Se seu layout parecer um pouco
diferente e você gostaria usar o mesmo que estou
demonstrando neste vídeo. Basta ir ao menu aqui, clicar em Janela, selecionar layouts e selecionar o layout padrão. E isso deve
redefinir seu layout para o exato que estou usando. Agora, podemos ver no topo
do layout o menu, que dissemos que
cobriríamos primeiro no útero, a seção de
layout. E vamos fazer isso agora. O menu da unidade se divide em
várias seções diferentes. Arquivo, Editar, Ativos, GameObjects ,
componente, trabalhos,
janela e ajuda. Vamos cobrir cada uma
dessas seções em detalhes
nos próximos minutos, excluindo a seção de trabalho, porque a seção de trabalho não inclui um ponto básico de unidade, mas um pouco ferramentas mais avançadas que são usadas para
melhorar o desempenho do jogo, que não abordaremos. Para nos começar. A seção de arquivo do menu
é bastante simples, assim como qualquer outro arquivo em
qualquer outro aplicativo que tenha. Salve, salve como aberto, novo, Projeto
seguro, Abra o
projeto e saia. No entanto, a seção de arquivos Unity também tem duas outras coisas
que são muito importantes. Crie configurações e
crie e execute. Agora, o
comando build and run é basicamente uma maneira rápida de exportar
seu jogo e executá-lo. As configurações de compilação, no entanto, são muito mais complicadas
e muito mais úteis no editor Unity,
pois é aqui que você
editará todas
as configurações para quando
exportar seu jogo. Obviamente, vamos
abordar isso muito mais detalhes mais
adiante no curso. Mas lembre-se de
que é aqui que você precisa editar
as configurações de exportação para o seu jogo. Passando para a
seção de edição do menu, temos uma lista completa de
diferentes procedimentos e ferramentas que nos permitem editar e navegar
no editor Unity. Mas, para ser honesto,
muitos deles
não são muito úteis
porque podem ser alcançados usando atalhos de
teclado simples como cortar, copiar ou colar. No entanto, na
parte inferior do menu, podemos ver três ferramentas distintas
diferentes, Configurações
do projeto,
Preferências e atalhos. E eles são incrivelmente úteis para ter
no editor Unity. Agora, os atalhos um, como tenho
certeza de que muitos de vocês adivinharam, simplesmente lhe dão uma lista de todos os diferentes atalhos, imunidade, que você pode editar
e C, redefinir ou excluir. Isso é incrivelmente útil
para ver como você precisa editar nossas coisas de navegação
no editor Unity. Mas você pode alcançar a maioria
das coisas que fazemos neste
curso sem usá-las. Para ser totalmente honesto, não
uso muito esses ****, mas é a
morte das Tulherias. Se você precisar. Seguindo em frente, temos
o menu Preferências. Agora, o menu de preferências é
onde você edita coisas sobre o editor Unity que você deseja alterar
especificamente, como as cores que
você está usando aqui. Nas cores, você pode alterar
todas as cores diferentes que se
associam a diferentes ferramentas ou tarefas que estão sendo concluídas. Por exemplo, se
eu quiser mudar a tonalidade para quando
estou jogando meu jogo, posso mudar isso aqui. Além disso, você pode
alterar coisas como ferramentas
externas, como
abordamos anteriormente, ou
coisas lentas e mais complicadas, como sua visualização de cena, criação de objetos na origem e espessura da linha,
coisas como isso, que não estaremos
cobrindo extensivamente , pois eles não formam
componentes básicos da unidade. Só saiba que este menu
é onde você adicionou todas as coisas sobre o editor
Unity que você quer mudar especificamente. Passando para a seção mais
importante, as configurações
do projeto. Isso permite que você edite as
seções do seu projeto, como o nome,
o nome do produto, a versão que ícone o cursor que você
usará onde está o cursor, ponto de acesso e a resolução do
ícone apresentação Splash Image
e outras configurações. Passando para o
menu da terceira sessão, temos os ativos. No entanto, vou
agrupar ativos, GameObject e componentes em
uma seção diferente. Quanto a ser totalmente honesto, essas três seções
do menu Unity, não
acho
incrivelmente útil. Como muitas das ferramentas que
usamos ao longo desses três menus podem simplesmente ser
alcançadas diferentes lugares
no editor Unity, por exemplo, o menu do
ativo se refere a praticamente tudo o que precisamos ao trabalhar com
ativos em unidade. No entanto, a mesma coisa
pode ser alcançada simplesmente indo para
ativos e clicando com o botão direito do mouse. Da mesma forma, o objeto do jogo obviamente nos
permite criar
novos objetos de jogo, que também podemos
fazer aqui
na hierarquia de objetos de forma semelhante e componentes nos permite editar os componentes
que estão atualmente anexados a todo o
nosso objeto de jogo, o que podemos fazer
simplesmente selecionando um objeto de jogo e um componente
arrogante através deste menu aqui. Não se preocupe se tudo isso
parece um pouco confuso agora, pois ainda não cobrimos
essas partes das unidades, mas saiba que esses
três menus de unidade não são os mais úteis. Você
pode usá-los se quiser. E os dois sempre lá, mas eles basicamente permitem que
um espaço diferente faça as mesmas coisas
que você poderia fazer em lugares diferentes
no editor Unity. Finalmente, as duas últimas
seções, janela e ajuda, são um pouco mais úteis,
pois
a janela permite editar todas as diferentes janelas que você tem aberto atualmente. Como você pode ver no Unity, tenho uma janela de cena, novamente Janela e
inspetor, janela hierarquia, janela
do projeto e a janela do console. Mas se eu quisesse adicionar novos, basta clicar
aqui na janela e posso adicionar
galão do Windows nesta seção, renderização
geral,
animação, áudio. Por exemplo, se eu quisesse
abrir uma paleta de mosaico, posso ir aqui para 2D e
selecionar paleta de mosaico, e ela abrirá uma nova janela de
paleta de mosaico para
eu me movimentar. Como alternativa, posso alterar as janelas
clicando com o botão direito do mouse no Windows. Já abri e clique em
Adicionar guia e adicionando-os de forma semelhante. Novamente, isso pode parecer um pouco confuso, pois ainda não
cobrimos tudo isso, mas saiba que esta guia de janela me
permite gerenciar todas
as diferentes janelas
no editor Unity que eu tenho atualmente abrir
ou deseja abrir. Finalmente, o
menu de ajuda é incrivelmente autoexplicativo e simplesmente tem uma referência sobre a unidade. Unity é
referências manuais de script, serviços, fórum, feedback ANSYS, verificação de recursos de atualizações, baixado A-beta, gerenciamento notas de versão de licença, software, licenças, relatando bugs e redefinindo seus
pacotes para o padrão. Para ser honesto, nenhum desses recursos são incrivelmente úteis. Você pode encontrar resultados semelhantes simplesmente pesquisando
Unity no exame. No entanto, se você
quiser acessar rapidamente um desses, você pode fazê-lo através do menu de ajuda. O próximo passo nas coisas que
encontramos quando carregamos editor Unity é
a hierarquia de objetos, que armazena todos os
nossos GameObjects atualmente presentes em nossa cena. Podemos ver agora que só
temos uma câmera
e, obviamente,
realmente não sabemos o que a câmera faz ainda porque não
chegamos a essa parte
do curso. Mas saiba que este é um objeto de jogo que está armazenado em nossa cena e podemos
acessá-lo através da hierarquia de objetos. Também podemos criar
novos objetos de jogo. Aqui Crie objetos 2D vazios, objetos
3D ou podemos afetar,
afetar luz, áudio e vídeo, UI ou UI Toolkit
ou outra câmera. Obviamente, tudo isso é
um pouco complicado agora, mas vamos
cobrir mais tarde, basta saber que todos os nossos objetos que estão
armazenados em nossa cena, que são basicamente
como as pequenas coisas em nosso jogo que
vamos dar CO2 será armazenado aqui. Por exemplo, se eu
quisesse criar um personagem, eu poderia
ir até aqui, clicar, clicar com o botão direito do mouse, Criar vazio
e criar um novo player. Jogador. E, em seguida, adicione diferentes
componentes aqui com base no que eu
queria que eles fizessem. Se eu quisesse adicionar um sprite
ou uma representação visual, eu clicaria em Adicionar renderizador de sprite de
componente e simplesmente selecionaria um
sprite de uma lista. Obviamente, eu não tenho nenhum agora, mas se eu quisesse fazer
uma camada de fundo, eu poderia fazer
assim. Redimensione-os. E podemos ver que
nosso objeto player agora
está armazenado na hierarquia. Seguindo em frente, muitos de vocês podem ter notado que no minuto em que
clicamos em um objeto, abrimos um monte de novos detalhes nesta janela do
inspetor. Este é o
inspetor de objetos onde
inspecionamos nossos diferentes objetos, qualidades e características. Você vê aqui que a transformação é basicamente a
posição do objeto, a rotação e
a escala que todos editamos quando
criamos o objeto. E adicionamos um novo componente, assim como no menu do renderizador sprite para
exibir o sprite, este inspetor de objetos obviamente muda no minuto em que você seleciona
novo objeto e permite que você para inspecionar todas as
diferentes qualidades ou atributos do objeto com o qual você
está trabalhando atualmente. Mais uma vez, tudo isso
será abordado com muito mais detalhes mais tarde. Mas saiba agora, é aqui que os
objetos são armazenados e é aqui que os detalhes
sobre eles são armazenados. Seguindo em frente mais uma vez, temos
nossa cena e o Game Windows. Agora, visto é onde todos
os objetos são representados
visualmente. A visualização da cena é onde
você
passará a maior parte do
tempo trabalhando no Unity. E é basicamente
onde a construção do jogo realmente
acontece. Alternativamente, este
jogo serve, é usado para testar seu jogo e ver se você clica no botão
Jogar aqui, você será capaz de jogar o
jogo é se você planejou, isso obviamente
tudo será coberto em muito mais detalhes mais tarde. Mas saiba que a
cena e o Game Windows cobrem onde o jogo
é construído e testado. Finalmente, temos as janelas do projeto
e do console. Agora, a
janela
do projeto é onde todo o nosso fluxo de trabalho de ativos tem mais
gosto, e vamos
abordar isso muito mais detalhes no próximo vídeo. No entanto, saiba
que todos os arquivos precisamos em nosso jogo são
armazenados neste projeto. Se eu quisesse criar um novo
arquivo ou um arquivo importante, eu poderia clicar com o botão direito do mouse
aqui e importar novos ativos e trazer
qualquer música, arte, arquivos de áudio, efeitos de
partículas, qualquer coisa para o meu jogo. Finalmente, a
janela do console exibe todas as mensagens
de registro ou erro que
recebo ao jogar meu jogo. Se eu clicar em
Jogar agora, não
verei erros porque não fiz nada. No entanto, se eu tivesse um bug
ou falhar meu jogo, ele apareceria aqui
como um erro ou aviso. Ou eu poderia adicionar
minhas próprias mensagens de registro que me permitem testar meu jogo. Então essa foi uma visão geral básica
do layout do editor Unity. Agora, muitas coisas
podem ter visto o pouco intimidante
e algumas coisas podem não fazer sentido
é que ainda não
cobrimos como algo
funciona em unidade. Mas se você tiver uma
breve compreensão de como tudo no
editor funciona em conjunto, isso é tudo o que eu queria
passar neste vídeo. Se você puder entender
que os objetos são as coisas que estamos
manipulando em nosso jogo. O inspetor é onde
vemos esses detalhes. O menu é como navegamos
pela unidade, pelo jogo e visto, ou onde construímos o jogo
e as
janelas do projeto e do console são onde vemos mensagens de
erro e
importamos todos os nossos arquivos. Então você entendeu
tudo o que precisa. Vamos analisar o fluxo de trabalho ácido
no próximo vídeo. E depois disso, comece a trabalhar
em todos os conceitos básicos da unidade, o que espero que faça com que
todas as coisas que
abordamos neste vídeo
façam muito mais sentido. Vejo você no próximo vídeo.
3. Fluxo de trabalho de ativos: Ei lá, e bem-vindo de volta ao meu curso sobre o
básico da unidade. Agora, como mencionamos
neste curso é um vídeo
introdutório, vamos cobrir
todos os conceitos básicos de unidade ao longo deste curso. Mas antes de entrarmos em todas
as especificidades de
cada conceito, primeiro
abordamos o
básico de como o Unity funciona. Em nosso último episódio,
abordamos o layout do Unity, que você deve
ver antes de você
no projeto de amostra que
criei para este episódio. No entanto, neste episódio, vamos
cobrir os conceitos básicos do fluxo de trabalho
de ativos da Unity. Em outras palavras, como Unity
coloca os arquivos que você deseja no seu jogo no projeto para serem
usados no jogo. Neste projeto, você pode
ver que eu tenho dois objetos. Minha câmera principal,
que obviamente está apenas exibindo o que posso ver, e meu objeto player, que criei para o
propósito deste tutorial. Este jogador tem um renderizador de
sprite, um corpo rígido e um componente
colisor de caixa anexado a ele. Você não precisa se
preocupar muito com o que essas três coisas fazem. Como eu disse, isso obviamente
será
abordado mais tarde
no curso. Mas saiba que
juntos eles formam o shell básico de
um personagem de jogador. O sprite nos permite
exibir uma imagem, o corpo rígido como
física para o meu objeto. E o colisor de caixa
garante que quando eu colidir com outro colisor que está preso à câmera principal, eu vou parar de me mover. Se eu for em frente e clicar em Jogar, você pode ver como
isso se parece. Agora, enquanto isso tudo funciona, este não é um personagem de jogador incrivelmente
emocionante pois não há arte para exibir o
jogador e
não há roteiro que
nos permita mover o jogador. Felizmente, tenho dois arquivos no meu computador que posso
importá-lo para o Unity, o que me permitirá
realizar essas duas tarefas. Vou mostrar a vocês
como fazer isso agora,
isso demonstrará o básico do fluxo de trabalho
de ativos da Unity. Então, para importar um arquivo ou
ativo para o seu jogo, basta ir aqui
para o menu Ativos,
clicar com o botão direito do mouse e selecionar
importar novo ativo. Então, na minha pasta de downloads, você pode ver que tenho um arquivo PNG de ponto
noturno, que vou
usar como meu sprite. E um arquivo CSS de ponto de movimento, que vou usar
como meu script de movimento. Obviamente,
criei ambos de antemão e
vou analisar como criar seus próprios scripts e até mesmo o básico de sprites
mais tarde no curso. Mas como estamos apenas
demonstrando o fluxo de trabalho de ativos, vou usar ativos
pré-criados por enquanto. Vou clicar duas vezes
na minha coisa de nitrilo PNG e simplesmente mudar esse modo de
filtro para ponto. Não se preocupe com o porquê disso é só porque estou
usando pixel art. E assim que eu
importei isso, agora, ele me permite
usá-lo no meu jogo. Então, se eu for
aqui para o meu jogador, podemos ver meu renderizador de sprite. O arquivo sprite está
atualmente definido como segundo plano um arquivo PNG padrão
que a unidade fornece. Se eu for para
meus ativos e arrastá-lo para esse local, podemos ver agora que
temos um jogador completo, personagem de jogador
completo, que agora é ocupado o
espaço desse plano de fundo. Acho que ambos concordamos que
parece muito melhor. Agora. A outra coisa que vamos
querer adicionar é um script que nos permitirá
mover esse personagem do jogador. Vamos fazê-lo de uma forma
muito semelhante. Basta clicar com o botão direito novamente e
selecionar importar novo ativo. Vou importar
por script de movimento. E este é um
script de movimento que eu criei. É muito simples,
o que nos permite
mover para a esquerda e para a direita e pular. Basta ir ao meu jogador. Vou arrastar, talvez
seja necessário
recarregar as assemblies de script,
pois é um novo script. Vou arrastar
isso para o meu jogador. E podemos ver aqui que o script de
movimento agora foi adicionado simplesmente adicionando
esses dois arquivos, um deles código e
um deles um arquivo PNG. Se eu bater o jogo novamente, podemos ver agora que vou tocar uma nota e
parece muito melhor, mas agora pode realmente mover para a
esquerda e para a direita e pular, o que é muito, muito legal. Agora, obviamente, eu não
passei por cima de como criar esse
script de movimento ou como fazer o trabalho artístico para criar
spreads como este, eu usei um sprite e se você já sabe como fazer
arte, isso é ótimo. Se você não está planejando fazer
muitos jogos do Albert. Obviamente, você não
precisa se preocupar muito com isso, mas vamos analisar especificamente
como criar o script e os conceitos básicos da nudez do
Sprite Editor mais tarde no curso. Mas espero que o que você
compreende deste episódio seja simplesmente como podemos obter
ativos em nosso jogo. Agora, a última coisa que
quero destacar antes de encerrarmos este vídeo é onde exatamente essa
pasta de ativos está realmente armazenada. Porque tudo o que estamos fazendo quando
dizemos que um
novo ativo importante é que estamos tirando uma cópia de onde quer que seus ativos
sejam importantes no meu caso, a pasta Downloads
e
colocando-a em nossos jogos arquivo de projeto. E você pode encontrar isso com
base em onde você salvou seu projeto. Quando
criamos nosso projeto pela primeira vez, deveria ter havido uma coisa de diretório de
projeto selecionada. Vou mostrar uma imagem e uma
tela agora de onde fizemos quando selecionamos
nosso primeiro projeto. Você só precisa
se lembrar de onde salvou o seu ou,
se não consegue se
lembrar, provavelmente está no local
padrão. Você pode simplesmente ir em frente e criar um novo projeto Unity e ver
onde está esse local. Então, se eu subir aqui para
onde meu projeto está salvo, salvei meus projetos e
E Unity e, em seguida, noções básicas de unidade, podemos ver todas essas pastas
diferentes. E há o pacote é
um e os ativos um, que podem ser visualizados
do editor Unity
aqui e aqui. Há um monte
de outros aqui, registros de biblioteca e configurações de projeto,
configurações de usuário temporário, mas você não precisa
se preocupar muito porque essas são pastas da própria
Unity, que nós não vai
adulterar esses ativos. Um deles é aquele em
que estaremos trabalhando principalmente. Se você clicar duas vezes nele, agora
podemos ver que temos nossos novos ativos importantes como nosso PNG e
eu vou passar para CS. Eles também criaram
esses mesófilos. Agora deixe essas metáforas. Você vai precisar
dessas
metáforas para cada arquivo em unidade e o metarquivo também deve ser criado. Portanto, certifique-se de
não excluí-los. Se você fizer isso, ele
apenas criará um novo. Mas, como regra geral,
se você estiver excluindo ou movendo arquivos, você vai
querer mover ou excluir PNG
e o metarquivo ou o CS e o
metarquivo também. Se eu quisesse adicionar um
novo arquivo ao meu jogo, tudo o que preciso fazer é carregar
nesse local, arrastá-lo e soltá-lo
ou copiá-lo ou cortá-lo. Tudo. Eu posso fazê-lo a partir da
unidade importando-a. É tudo exatamente a mesma coisa. Portanto, espero que isso
lhe dê uma visão geral básica de como o
fluxo de trabalho de ativos da Unity funciona. Precisamos fazer é importar
ativos para esse arquivo de ativos. Obviamente, você pode
organizar isso um pouco melhor se quiser
criar uma pasta de sprites, pasta Scenes, pasta
Animações. Eu geralmente gosto de fazer isso. E então você pode organizar
seu trabalho um pouco mais fácil. Mas tudo o que estamos fazendo é
mover arquivos do meu computador para esta pasta de arquivos do
projeto
e, em seguida, isso nos permite
acessá-los em nosso jogo. Espero que isso
deixe tudo muito mais claro e verei você no próximo
vídeo em que vamos
começar a perfurar o Unity é específico
real e como
o mecanismo do jogo funciona. Vejo você no próximo vídeo.
4. Sprites: Ei lá, e bem-vindo de
volta à unidade. Agora, nos dois últimos vídeos, abordamos o layout da Unity
e o fluxo de trabalho de ativos do Unity ,
o
que significa que
abordamos básico de como ele funciona. E isso nos permite
entrar em mais detalhes sobre como todas as diferentes
ferramentas do Unity operam. Vamos começar
cobrindo sprites,
sprites de bitmaps, que
usamos para representar visualmente
objetos em nosso jogo. Por exemplo, se eu quisesse fazer um personagem de jogador
como fiz da última vez, você pode lembrar que o menonita adicionou
aquela noite pixelada. O jogador parecia muito
melhor do que quando eu tinha aquele sprite de
fundo de espaço reservado. Sprites nos permitem fazê-lo. Eles nos permitem tornar
nosso jogo muito mais imersivo e
agradável de se olhar. Neste vídeo,
vou abordar os dois tipos básicos
de sprites de unidade, como usá-los e o componente renderizador
sprite. Para começar, vou
carregar um sprite, pois essa é a ferramenta que uso para
fazer meus sprites no Unity. Obviamente, você também pode usar o GIMP ou o Photoshop, o Microsoft Paint. A lista continua e continua e continua. Eu prefiro usar um sprite. No entanto, como acho
realmente, muito bom para pixel art, que é o meu meio de escolha. Agora, se você for aqui, você
pode ver que eu tenho um homem de pau, um sprite e um blog. Um sprite. E o blob é
obviamente muito mais simples. O homem do pau é
obviamente muito simples, mas é muito maior. Você pode ver. E
vou usar esses dois para ilustrar os
dois tipos diferentes de sprites em seus dentes,
ou seja, sprites de modos simples e
múltiplos. Vamos começar com sprites de modo
único. Se eu for em frente e
expor meu blog, poderei entrar no Unity. Clique com o botão direito,
assim como fiz da última vez. Importante novo ativo e
importar meu blog dot PNG. E agora esse arquivo está
no meu projeto Unity, o que significa que posso
usá-lo no meu jogo. Se quiséssemos criar
um personagem de jogador, posso atribuir esse blob
e, em seguida, posso ter
esse blob como jogador. Antes de fazer isso,
quero cobrir algumas coisas muito importantes sobre
sprites importantes no Unity. No minuto em que você importar um
espalhando os dentes, você será recebido por
essas configurações de importação. E, na maior parte,
deixá-los como padrões geralmente
é recomendado
com algumas exceções. Primeiro de tudo, o modo sprite, você vai querer mudar
dependendo se você quer um sprite único ou
múltiplo, o que obviamente
vou cobrir no minuto em que importarmos
o próximo sprite. Mas este disse para solteiro, que é exatamente o que eu quero. Então, vou deixar isso por enquanto. A segunda coisa que
você precisa observar é que se você estiver usando pixel art, você precisa alterar esse modo de
filtro e
há compactação. E vou te mostrar o porquê. Se eu for em frente e
criar um novo jogador, vou criar
vazio e chamá-lo de camada. Vamos imaginar
por um segundo que o blob era meu personagem
jogador. Vou querer adicionar um componente
renderizador sprite, renderizador
sprite. Vou seguir em frente e arrastar meu arquivo Blob para o
meu renderizador sprite. E o renderizador sprite me
permite ver o sprite. Obviamente, é muito pequeno, mas vou mostrar
outra ferramenta que podemos usar para alterar o
tamanho da imagem dos meus sprites. Se eu entrar em blob, esses
pixels por unidade me permitem alterar o tamanho ou
o tamanho dos sprites em relação
ao editor Unity. Vou seguir em frente e
fazer isso dez acertar Aplicar. E podemos ver nosso sprite
ficar muito maior. Mas você também pode
ver que o sprite é realmente de baixa qualidade. Está muito desfocado.
E isso me leva à segunda coisa que eu queria
falar com pixel lot. Se você for aqui
e pode ver esse modo de filtro e
essa compressão, estes estão atualmente configurados
para sprites através de muito
mais complicados do que meu pixel, já que estou usando pixel art,
não vou para querer usar um modo de filtro e não
vou querer
usar a compactação. Então, vou até aqui
e vou dizer filtro para
apontar ou nenhum filtro e
redefinir a compactação para nenhum. Agora você não precisa entender exatamente
o que está acontecendo aqui, mas saiba que se você está
usando pixel art, você sempre quer
definir isso como ponto. Você sempre quer definir isso como
nenhum, o que significa que você aperta Aplicar. Você pode ver que eu pulverizei
fica instantaneamente claro. Isso é algo que
eu só aprendi selvagem mais tarde em unidade e
me ajudou muito a saber disso. Então, saiba que se você está
usando pixel art, você precisa defini-los para dois. Eu tenho. Se você não estiver usando
a lei de Fick, no entanto, você pode, obviamente, brincar
com essas duas configurações. Geralmente acho
que quando não estou usando a Pixar, quero configurá-la como
bi-linear, tudo trilinear. Mas apontar o filtro é definitivamente a
configuração que
você deseja se você não quiser nenhum
desfoque entre seus pixels. De qualquer forma, estamos ficando
um pouco confusos por que estamos nos
aprofundando sobre esse sprite específico de
pixel out. Mas é porque, para ser honesto, sprites
únicos não
são tão complicados
além dessa configuração específica
e dos pixels por unidade, tudo o que você precisa saber
é que quando
importamos um pico com Unity, podemos atribuí-lo a
um renderizador sprite, que renderiza ou
exibe o sprite. Este componente de camada de ordenação,
que entraremos mais tarde, obviamente simplesmente
define a ordem em que o sprite aparece
em relação aos outros. Pixels por unidade para exibir o tamanho do
sprite no editor. E podemos mudar
isso como quisermos. Quanto maior o número menor
o sprite apareceria. E esses modos, filtro e compressão alteram o
desfoque entre os pixels. Se eu definir isso como bi-linear, podemos ver que o
fixador não está borrado e se eu definir ponto
eles não estão mais. Da mesma forma, a compactação
faz uma tarefa semelhante. Agora, o segundo tipo de Sprite é um pouco mais
complicado e é porque o segundo tipo de
Sprite funciona de uma forma em que pegamos todos os componentes do nosso sprite que queremos. Por exemplo, se eu
quisesse esse sprite fosse um exemplo muito idiota, mas eu poderia pegar a
metade esquerda e a metade direita. Você os divide,
depois seu chá, você os coloca como sprites
diferentes e os coloca juntos novamente. E vou mostrar
por que isso é útil quando entramos em animação. Porque se você pensar
sobre isso, você tem todas as partes diferentes de um
sprite como objetos diferentes. É muito mais fácil
animar esse objeto. Para começar, entre em qualquer
programa que você esteja usando para editar seus sprites e
dividir cada parte
dos sprites. Vou usar um homem de pau, alguns brotando todos os
membros assim, e o tronco e a cabeça. E ao fazê-lo agora, a
unidade será capaz de
reconhecer que essas
são partes diferentes
do sprite porque estão
distantes umas das outras. Então clique em Exportar e
volte para Unity. E eu vou importar
meu novo homem de pau, que você pode ver está
muito separado. Em primeiro lugar, vou
definir meus pixels por unidade para dez porque quero que ele tenha tamanho
semelhante ao meu blob. E essa é a
coisa exata que usei no meu blog. E vou
definir o modo de filtro para apontar e compactar para nenhum só por causa do
estigma ainda é um tipo de pixel. Então, para definir meu sprite para que unidade saiba que todos esses sprites diferentes que
você pode ver agora, se eu clicar lá, posso ver que é apenas um
sprite e você pode clicar em qualquer sprites
lá para ver quantos é apenas um sprite. Então, se eu for aqui,
vou mudar meu modo sprite para múltiplos, clique em Aplicar e, em seguida,
abrir meu Sprite Editor. E de acordo com o manual Unity, o uso
primário deste
Sprite Editor é dividir diferentes partes
do corpo do sprite, assim como vamos
fazer agora. Não é ótimo. Se você quer obviamente
criar seu próprio lugar, você não pode editar o sprite aqui ou alterar as cores
ou qualquer coisa que, mas se você quiser dividir as partes do corpo de
seus sprites, isso é exatamente
a ferramenta que você precisa. Então vá aqui para cortar. E vamos
querer definir meu tipo para automático, porque isso é
exatamente um que estamos falando, seja muito distante que
você precisa, você não pode. Você pode definir seu
método para excluir inteligente e seguro
existente. Eles são todos incrivelmente semelhantes. Eu gosto de usar inteligente, mas obviamente a diferença entre eles é um
pouco maior, então você não precisa se preocupar
muito com isso. E coloque o pivô para o centro. É fatia. E podemos
ver que ele cortou quase
perfeitamente todos os meus sprites diferentes, mas
há um pequeno erro. É agrupar a cabeça e o tronco juntos por algum motivo. Então, para corrigir isso, tudo
o que preciso fazer, preciso clicar nisso? E vou mover isso para cima. Dê-lhe uma ideia, um
pouco de assistência. E agora esse é o meu Head Start. E então eu vou
em frente e vou
arrastar para fazer meu próprio sprite de uso. E eu fiz minha torradeira,
e lá vamos nós. Agora eu tenho todos os meus sprites
diferentes e clique Aplicar e feche-o. E agora, se eu apertar este botão, você pode ver todas as
diferentes partes do meu estigma e são separadas em
diferentes sprites. E isso ocorre porque meu
modo sprite está definido como múltiplo. Se eu dissesse de volta ao single, todos
eles seriam agrupados como
um, assim como este, mas porque eles são sprites
diferentes
agora, agora vou
mostrar como criar um personagem usando estes e
colocá-los juntos novamente. Então vá em frente e
faça um novo objeto em uma chamada para este
jogador, novamente. Em vez de adicionar um
renderizador sprite aqui, vou criar um monte de aranhas e colocá-las todas
debaixo desses objetos de argila. Vou clicar no player e
clicar com o mouse neles e
dizer Criar vazio. E isso
fará com que um objeto filho ou um objeto que esteja
dentro do meu objeto. E lembre-se dessa cabeça. Então vou adicionar um renderizador de sprite
ao meu objeto de cabeça. E então vou apenas ir
em frente e copiar isso cinco vezes porque quero
cinco objetos diferentes. Eu tive cabeça,
vou mudar o nome
deste à esquerda. Este vai estar
à direita. Este vai ficar
com a perna esquerda. E este
vai estar certo. E então tudo o que preciso
fazer é atribuir as diferentes partes do meu sprite que representam essas coisas. E como nós totalmente
honestos, não posso realmente dizer qual deles é qual. Se eu olhar para trás em minhas coisas, as pernas são
mais longas que o braço. Então eu tenho certeza de que
isso e estas são as pernas e
esses dois são os braços. E quase repentino, é isso mesmo. Então vou colocar minha
perna para a esquerda aqui. Eu passo bem aqui. Meu braço saiu aqui. À direita aqui. E minha cabeça aqui. Obviamente,
todos eles estão juntos. E você pode ver que são
realmente muito grandes. Vou mudar meus pixels por
unidade por algo como 15, e isso deve torná-lo um pouco mais gerenciável, perfeito. Agora, tudo o que preciso fazer
é mover esses objetos para onde eles
querem no jogador. Mova minha cabeça para cá, e eu realmente preciso um tronco que quase
esqueci de alguma coisa. Vá em frente e crie
outro vazio, chame-o de torso. E quase esqueci disso. Vou adicionar um renderizador de
sprite,
assim como os outros
realmente os copiarão. E vou acrescentar isso lá. E podemos ver agora que
tenho meu tronco. Então, desde que me esqueci disso, vamos mover o tronco
pela cabeça. Coloque-o lá para dizer,
eu acho que isso é bom. Meu braço esquerdo e principalmente vai
querer no lado esquerdo, digamos que eles são meu braço, certo? Vou querer do lado direito
ao redor. Deve haver bom. Minha perna esquerda e minha perna direita. Vou querer aqui
me mudar para que
eu possa vê-los. Acho que está tudo bem. Obviamente, isso não
precisa ser um exemplo perfeito, mas provavelmente não será. Mas podemos ver aqui
que agora é um homem de pau. Ele foi reconstruído. E você pode estar pensando, ok, qual era o sentido de tudo isso? Acabamos de colocá-lo, desmontá-lo
e colocá-lo novamente. Mas isso é
realmente muito bom porque agora, porque eu tenho filhos de todos esses objetos para esse jogador, se eu mover o jogador, todos os objetos
vão se mover com ele. Então, todo o meu código e lógica, tudo o que posso mover com este objeto principal do player e todas as pequenas
partes do sprite, posso mudar com isso. Se eu quisesse adicionar,
por exemplo, uma faca, eu poderia simplesmente colocar uma faca
embaixo desse braço direito e então a faca
seria criada à direita com a infância no braço direito. E então, obviamente, se
eu me mover para o
braço direito ou girar para a esquerda, tal a faca se
moveria com ele. E isso é realmente uma coisa
realmente útil quando vem mais tarde quando
começamos a animar um objeto. E eu vou te mostrar
obviamente mais tarde
no curso quando
chegarmos à animação. Porque se eu quisesse
fazer esse pagador funcionar, é muito mais
fácil fazê-los funcionar. Mas eu controle as
pernas e os braços que se eu puder
controlar o único sprite. E, obviamente, há
novamente por esse motivo, dois tipos diferentes
de animação. Mas esses são os fundamentos de
como os sprites funcionam em unidade. Tudo o que você precisa saber é que renderizador
sprite
exibe os sprites. E se você estiver usando
um único sprite, você só precisa adicionar
um renderizador sprite. Se você estiver usando
vários sprites, não criou
um objeto pai, clique com o botão direito do
mouse no objeto pai e criará objetos vazios
abaixo deles. Ou você pode simplesmente arrastá-los para um jogador para torná-los objetos
pais como este. Isso faz com que todos os
objetos filhos desse objeto pai. E então, se eu mover
meu objeto pai, todos os debaixo
dele, movam-se com ele. E é aí que
vou definir todas as minhas diferentes partes do meu sprite. E é exatamente
assim que você vai fazer sprites em unidade. As últimas coisas que você
precisa saber são simplesmente especificidades dos componentes do
renderizador sprite. Se eu for aqui ao meu blob, podemos ver que
tenho algumas coisas. Primeiro de tudo, sprite, é por
isso que
defino o arquivo de uma só vez. Então, obviamente, eu defini
isso para blob agora. Se eu colocasse o pau, diria a
primeira coisa sigma1, que é eu acho que a perna esquerda. Mas eu não quero fazer isso.
Então, voltei ao meu blog. Este flip no x
e escreve bastante autoexplicativo
que você deve usar se quiser virar seu sprite. No modo Desenhar, você não
precisa se preocupar com a interação
da máscara Northern
ou com a propagação. Então, aponte, o material é uma parte bastante complicada
do renderizador sprite. Você não se
preocupa com isso por enquanto. Por enquanto, vamos usar
o padrão sprite para todos os nossos
diferentes sprites. Se você quiser criar
sprites brilhantes ou gráficos de sombreamento, coisas
mais complicadas,
é assim que você faz isso, mas você não precisa
se preocupar com isso por enquanto. E então, logo abaixo de configurações
adicionais, a camada de classificação é simplesmente a camada em que
o sprite está. Eu não me preocuparia
muito com isso, mas a ordem e aquela
área são muito importantes. É basicamente
aqui que o sprite está em comparação com
todos os outros spreads. Então eu costumo deixar a maioria dos meus sprites na
camada de classificação e, em seguida, movo os sprites na frente um
do outro usando essa ordem em S. Se eu
mover esse cara para lá, você pode ver que a corrente está por trás,
mas quer seguir em frente. Eu posso fazer este. E agora o sprite está
à frente do outro sprite, o que é um recurso bastante útil. Portanto, esses são os fundamentos de como sprites na UT são representados. Espero que, se você estiver
tentando fazer um jogo, agora
você sabe se
quer vários sprites ou sprites individuais ou
combinação dos dois. Se você está fazendo pixel
art, geralmente acho que único tempero é muito mais fácil se você não estiver fazendo pixel, eu acho, seria muito difícil fazê-lo sem
usar vários sprites, especialmente quando se
tratava de animação. Mas espero que isso
lhe dê um pouco de fundo de
sprites altos trabalhar em unidade. Obviamente,
teremos retornado a despeito quando chegarmos à animação. Mas espero que tudo faça
muito sentido. E espero que você tenha
achado o vídeo informativo e agradável. Vejo você
no próximo episódio.
5. Física: Ei lá e bem-vindo de
volta à Unidade. Neste episódio,
vamos
cobrir o mecanismo de física do Unity, o que nos permite adicionar
um componente simples a todos os nossos objetos. E adicionar esse componente permite que esses objetos
reajam como fariam na
vida real a muitas
das leis da física
que vemos diante de nós. A forma como esse vídeo será estruturado é que vou
explicar todos os diferentes
atributos desse componente. E, em segundo lugar,
os atributos de outro componente que
usamos em conjunto com
o primeiro componente. Esses dois componentes são o corpo
rígido e o colisor. Você já viu a
cena antes de você, criei uma
cena simples com um objeto, que atribuí
um sprite de haltere simplesmente para fins visuais, se eu clicar nele, posso ver o sprite renderizador e nada mais é
adicionado ao objeto. Mas eu quero adicionar um
segundo componente, um corpo rígido, que vai
lidar com toda a minha física para mim. Se eu clicar em Adicionar componente, posso selecionar o corpo rígido
2D digitando acima. Corpo rígido 2D. Obviamente,
se você estiver em 3D, vai querer
usar o corpo rígido. Mas para este projeto vamos usar o corpo rígido 2D. E se você clicar nele,
você pode ver que ele tem um monte de
atributos ou qualidades diferentes que podemos usar para
editar como esse objeto usa a física e a física que são aplicadas a esse objeto, mais especificamente as
especificações desse objeto. Assim, podemos espelhar
exatamente como ele
agiria no mundo real
em nosso jogo. Então, vou examinar
cada um
desses atributos e
explicar como eles funcionam. Antes de fazer isso, vou mostrar
o que acontece se
simplesmente adicionarmos um corpo rígido a
um componente e apertarmos Play? Podemos ver meu Dumbo cair no chão
acelerando como acontece. Então, assim como na vida real, isso é baseado neste componente de escala de
gravidade, qual vou entrar em um pouco. Mas deixe-me começar
bem no topo com todos os diferentes componentes
deste grande componente, ponto
rígido. No topo temos um tipo de corpo e existem três
tipos diferentes de corpos rígidos, cinemáticos
dinâmicos e estáticos. Corpo rígido dinâmico. O que eu mais uso principalmente
é um corpo rígido que
basicamente está fazendo
tudo automaticamente em termos de gravidade. Se eu acertar o jogo como
você viu que eu fiz. O corpo rígido
envia automaticamente o ar e não colidir com nada e
começou a cair. Se eu usar um corpo rígido cinemático, teria que mudar a posição
desse objeto. O uso de corpo rígido
move a posição ou move rotação em vez de apenas
aplicar forças a ele, como conta dinâmica. E um corpo rígido estático não
é projetado para se mover. É quase como se
fosse um objeto com gravidade 0 e massa
infinita, se algo mais
levar uma luz para ele. Para isso,
vamos nos
concentrar principalmente no corpo rígido
dinâmico. Como este é um que eu uso
com mais frequência e, na minha opinião,
é aquele que a maioria das pessoas precisará na maior parte
do tempo ao criar jogos
baseados em física. Por baixo disso,
temos um material. E este material é
basicamente o material que não é o corpo rígido,
mas o colisor de caixa, que são usados em conjunto
com o Richard Boyd, como mencionei anteriormente.
Esse é o segundo componente. Vamos cobrir os planadores
de caixa que são usados em conjunto com isso que
se refere ao material deles. Então, se eu quisesse
mudar esse material, eu poderia ir aqui para meus ativos e eu poderia clicar com o botão direito do mouse, criar
2D se eu estiver usando 2D ou se você estiver em 3D, bom material
físico e material físico
2D para minha coisa, vou chamar esse material. E podemos ver que posso mudar o atrito e a rejeição. Obviamente, você ainda não
vai conseguir ver isso em ação porque eu não
adicionei um colisor de caixa, mas vamos manter isso
para mais tarde para que eu possa mostrar exatamente como esse
objeto material afeta tudo. Em terceiro lugar, temos o atributo
simulado, que basicamente está ligando e desligando
o corpo rígido. Se eu desligá-lo, podemos
ver agora quando eu pressiono Play, o corpo rígido não age
realmente sobre o objeto e o objeto não se move
como um Switch habilitado. Depois disso, usamos máscara automática, que basicamente estima a massa
do objeto com base no colisor
anexado a ele. Obviamente, não me
apegei a nenhuma colite e posso mudar minha
máscara aqui
deslizando esse valor de
ida e volta ou inserindo valor usando um enorme
é bom para meus propósitos. Depois disso, temos arrasto
linear e arrasto angular, que são o coeficiente de arrasto
é 0 significa que não há amortecimento. Em outras palavras, esta é a
rapidez com que o objeto reagirá e se reestabilizará após a colisão, arrasto
linear obviamente se refere
à posição ou até onde
ele chegará a descansar. E Angular Drag refere-se à sua rotação ou à rapidez com que ele
parará de girar após colisão ou uma
força externa atuando sobre ela. Depois disso, temos
escala de gravidade que afeta a quantidade de gravidade
aplicada ao nosso objeto. Em outras palavras, se
eu definir isso como 2.46, meu objeto será 2,46 vezes mais rápido do
que anteriormente. Se eu bater em jogo, posso ver que em ação caiu um pouco mais rápido. Se eu definir isso como menos um, posso ver que nosso objeto, em vez de cair para baixo, sentiu exatamente a mesma velocidade
originalmente para cima. E, obviamente, isso afeta a
rapidez com que meu objeto também
acelerará. Porque se eu definir para cinco, eles vão acelerar
muito mais rápido à medida que cai. Depois disso, temos detecção de
colisão, aplicando
novamente à colisão ou ao componente collider. Você pode ver por que
precisamos usar
ambos quando estamos trabalhando
com física e unidade. Como a
detecção de colisão se refere a como meu objeto detecta quando está
colidindo com algo. Se eu usar discreto, é uma forma menos completa
de proteger as colisões. No entanto, é menos intensivo
na CPU e contínuo
é uma maneira mais completa, mas obviamente mais intensiva na potência do
seu computador ao
calcular colisões. Depois disso, temos
um modo de dormir, que basicamente se
refere se meu corpo rígido está ativado ou não. Se eu me sentar nunca dormir, sempre será capaz de começar. Um peso significa que
ele será ativado até que eu o desative ou o defina para dormir em Começar a
dormir ou, obviamente,
o oposto. Ele será desativado até que
eu o ative acordado. É. Depois disso, intercalamos, o que basicamente se refere ao
quanto meu corpo rígido está
precisando interpolar. Usar essa função de interpelação é incrivelmente útil quando minha
taxa de atualização de gráficos é muito mais rápida do que minha taxa de atualização
física. Porque se eu estiver
atualizando cada quadro muito mais rápido do que minha
física está sendo atualizada. Vai parecer bastante bloqueado e
grosso enquanto eu estou me movendo. E se eu quisesse fazer isso, eu poderia obviamente
definir inter-relação e isso irá baseá-lo nos quadros anteriores ou
extrapolar,
o que o baseará em uma estimativa
de quadros futuros. E você só se preocupa
demais com isso. Mas, basicamente, saiba se você tem uma taxa de atualização gráfica
muito rápida em seu projeto ou em seu
computador em geral. E você está preocupado que a física não
consiga acompanhá-la, então eu recomendaria usar intercalar ou
escalar para resolver esse problema. Disso, temos
algumas coisas simples. posição de congelamento x e y são
bastante autoexplicativas. Isso foi simplesmente
congelar a exposição ou congelar a posição y e congelar a rotação z
congelará a rotação z
por corpo rígido. Se eu fosse definir a posição da
raiz de congelamento, por quê? Podemos ver que meu
corpo rígido não se move mais porque sua posição em y está obviamente congelada e congelando a rotação z, se eu caísse de
alguma coisa ou tivesse algo
angulado para que ele
girasse como na vida real, ele não
fará mais isso. Se eu estiver bem na borda
de algo aqui, um colisor, não
vai mover isso. Se eu não tiver
isso, será assim. Então, esses são todos os componentes básicos ou
compartimentos do meu corpo rígido, o que é bem legal porque
agora que cobrimos isso, devemos ter uma compreensão muito
melhor de como cada um
um desses trabalhos. Percorra um resumo rápido. Novamente, o tipo de corpo
refere-se ao tipo de material rígido do corpo é
um pouco mais complicado. Vamos entrar nisso em um segundo, mas esse é o material
que é destacado usando a máscara automática de ativação e desativação simulada. Obviamente, os conjuntos são
aqueles que você baseia
a massa no colisor ou na massa
dos colliders anexados. De repente, a massa
faz isso manualmente, arrasto
linear e dr. angular, quão rápido se trata de escala de gravidade de
repouso, a escala de gravidade, detecção de
colisão com cerca dois contínuos ou discretos modo de
dormir
menos ou mais completo. Começar a acordar, nunca
dormir ou começar dormir é basicamente se
referir se o corpo rígido está
sempre ligado ou quando está ligado na lâmina para
suavizar as taxas de
atualização gráfica quando eles não estão em sincronia com as taxas de atualização
física. E então podemos congelar a
rotação do eixo z, toda a posição do eixo x ou y. Ok, nós cobrimos tudo isso. Você pode pensar que tem uma boa compreensão
dos corpos rígidos, e espero que o façam. Mas há
mais uma coisa que precisamos abordar antes de
encerrarmos este vídeo. E isso é colliders. Vá até aqui e
clique em Adicionar componente, selecione um collider de caixa 2D. Podemos ver que você pode se lembrar
disso do nosso
vídeo de sprites porque na verdade
não usamos um antes de explicá-lo. Mas um colisor de caixa
basicamente
me permite especificar qual
área é meu objeto. Eu quero ser. Um colisor. É
como desenhar uma linha ao redor do oceano, pode dizer: Ok, esse é o objeto e é isso
que eu quero colidir
com tudo. Então, obviamente, você não
pode realmente usar um colisor de caixa a menos que
use um corpo rígido 2D, você pode meio que, mas não é
aconselhável. E você, da mesma forma, você realmente deveria estar
usando um corpo rígido a menos que você tenha
pelo menos um planador de caixa porque então você não vai
colidir com nada. Mas se eu for aqui, posso alterar o
tamanho do meu objeto, que faz o servidor. Você pode ver que na verdade
não muda o tamanho do colisor. Então, para perseguir o tamanho do Collider, preciso ir aqui para
este Edit Collider, e isso edita o volume
delimitador de luz. Posso mover esses para a esquerda e para a direita, e posso fazer isso muito mais preciso para o meu haltere
atual, posso ir assim,
isso, isso e isso. Dependendo do seu sprite, seu Collider pode ter
sido perfeito
porque é baseado no
tamanho do seu sprite. Mas como meu haltere
foi claramente cortado, você pode ver lá que
eles estão substituindo o exterior,
onde o Dumbo tem
transparência em torno dele. É por isso que o meu era
bastante impreciso. Em seguida, você pode mudar usando
este colisor de edição. Agora, o material é
muito parecido com isso. Se eu puder defini-los
tarifa apenas essa. Mas dizer que o
corpo rígido mudará o material de toda
a colite anexada, o que substituirá qualquer material físico
global. No entanto, ele não
substituirá o anexado
a este colisor de caixa. Então, se eu estiver usando uma tarifa de física global que é a camada mais baixa,
então, além disso, se eu anexar o
taro ao meu corpo rígido, isso substitui todos os globais e
substitui se não for triste. Mas se eu dissesse um material para o meu colisor de caixa que
substituirá o corpo rígido. Então, é como uma
pirâmide. Você pode desistir. Se eu quiser dizer que isso colidiu algo,
vou colocá-lo lá. Mas se eu quiser todos iguais, posso colocá-lo aqui. Obviamente, porque eu
só tenho um colisor. Posso definir meu
terror físico ali. E isso não vai
mudar muito porque eu ainda não
editei isso. Isso é apenas atrito
e a salsicha. E se eu voltar ao meu boxplot, podemos ver mais algumas configurações. Agora, há gatilho
basicamente
se refere a se meu colisor de caixa
é um gatilho ou não. Em outras palavras, se eu quisesse parar quando está colidindo com algo ou
se eu queria apenas
dizer ao computador depois
colidiu com algo, usaríamos um gatilho, que basicamente significa
que ele só diz o computador colidiu por
algo como uma bala. Porque se você estiver jogando um jogo e quer atirar uma bala, você não quer que o computador
tenha que registrar toda
uma colisão entre
a bala e o adversário. Especialmente em um simples, novamente, talvez em um show de FPS que
você queira manter isso. Mas para a maioria dos ganhos,
você quer definir que isso seja um gatilho porque
você só quer que eles sejam, ei, eu toquei em um Emmy ou inimigo
escondido, você
precisa fazer isso. Obviamente, a tarefa
que acontece quando toma, faz com que o inimigo sofra dano. Mas se eu estiver usando
algo como um jogador, eu gostaria de não definir
como um gatilho porque
quero que o jogador caia e pouse em algo e pare mover menos jaqueta
aqui temos um haltere, queremos que ele pare
quando aterrissar. Então, vou
definir isso como falso. Agora, depois disso, temos mais
duas propriedades usadas pelo efetor e
usadas por composto. Agora, isso pode parecer
um pouco confuso, mas isso fará
muito mais sentido se você estiver usando um efetor ou composto
para seu objeto. Então, se eu for aqui e
digitar o desertor. Podemos ver que tenho
um efeito de plataforma, um vetor de
superfície de vetores queixosos. E estes estão realmente
acostumados a obviamente, se você quiser usar essas
partes em seu jogo, você gostaria de ter
efeito é, por exemplo, se eu quisesse fazer uma plataforma de plataformas e videogames, às vezes você pode
passar e quando sobe, mas não quando você desce, por exemplo, como área interior, você pode viajar plataformas para cima, mas se você quiser
viajar para baixo, você tem para clicar
no botão Para baixo. Da mesma forma, a unidade
realmente criou um componente para nós chamado
efetor de plataforma, que simplifica bastante esse
processo. Não vou entrar
muito nisso nessa visão porque obviamente não será muito útil sem um haltere. Mas saiba que, se você
quiser usar um colisor de caixa, você tem
que definir esse efetor. Por exemplo, você
quer usar um collider. Então você quer ter certeza de que
você marque usado pelo efetor para garantir que eles afetem um nariz com o qual Collider
está trabalhando. Não se preocupe muito com isso se eu não fizer
muito sentido, apenas saiba que se você está
planejando usar plataformas, você pode adicionar um efetor de plataforma. E então, se você quiser
ter certeza de que está usando
o colisor correto, clique em usado por efeito
e isso é enviado. Ok, sim, este é o colisor que deve ser usado
pelo efetivo. Da mesma forma, se você quiser
adicionar um Collider composto, que é basicamente dois
ou mais colliders adicionados. Acho que são principalmente dois. Então isso é a mesma coisa. Está dizendo: Ei, este é um dos polis, ele
precisa ser usado. Então, obviamente, isso vai
mudar algumas
das coisas que você não precisa
se preocupar muito com isso. Eles são coisas muito nicho, mas são basicamente apenas maneiras de identificar o computador. Esta é a
necessidade do colisor para o
efetor ou para o meu Collider composto,
o que é muito legal. Temos ladrilhos automáticos em que
a forma colliders é atualizada com base
no renderizador sprite é pixelado ou nas propriedades de
ladrilhos. Ele diz aqui, com base no renderizador sprite
é propriedades de ladrilhos, a forma do collider será
atualizada automaticamente. Não se preocupe
muito com isso porque não estamos nos preocupando
muito com meu
renderizador de sprite é propriedades de ladrilhos, mas eu deixaria
isso por enquanto. E depois disso,
temos meu deslocamento que basicamente dita o quão
distante à esquerda ou à direita está, compensá-lo e por que também. E então o tamanho, que dissemos anteriormente
com o collider de edição, você pode obviamente fazer isso
usando esses estilos também. Depois disso, temos o raio de borda que
obviamente dita o quão grosso ou o quão
fino é o bobsled. O meu será definido como
0. Mas se você quiser ter um colisor muito grosso
por algum motivo, você pode definir o seu para
algo como dois. E, obviamente,
por baixo disso, assim como tínhamos o corpo rígido, há
muito mais informações sobre nosso componente que não
podemos editar. Podemos ver aqui
se clicarmos em informações, ele anexou um corpo que
é o corpo rígido do objeto 2D. Então você pode ver que eles já
estão trabalhando em conjunto sem nós
nichos ou qualquer coisa. Agora, se atingirmos o jogo,
você pode pensar, ok, eu tenho um controle deslizante de caixa
agora ele vai bater em algo, mas não há nada para esse objeto travar é o único outro componente em
nossa cena é a câmera principal. Olá, onde quer que eu tenha
realmente adicionado escalado para minha
câmera principal já. Só para que eu possa
ilustrar exatamente como essa caixa colidiu funciona. Para ir em frente e acertar o
jogo e aperte Play. Podemos ver que vou cair e depois bater com
aquele colisor. E isso é, na verdade,
o mesmo colisor que usamos em nosso vídeo sprite. Se você se
lembrar do último vídeo, tivemos um colisor
para garantir que nosso suprimento poderia cair
e pular no chão. E este é o mesmo colisor que
usamos o mesmo aqui para
garantir que possamos
cair e cair
no chão, obviamente, com um
pouco mais de compreensão, espero que desta vez, eu também sou realmente vai usar
este colisor para mostrar como esse material pode afetar o objeto ou o corpo rígido ao
qual o objeto está conectado. Podemos ir em frente e
arrastar isso até lá. Eu já disse isso e
clicamos no material e, em seguida podemos alterar as duas propriedades,
atrito e balanças. Se eu acertar o jogo agora, podemos ver I4 e eu
não salto de jeito nenhum. Portanto, o atrito não
será incrivelmente
visual neste exemplo
porque atualmente não estou me
movendo para visual neste exemplo a esquerda ou para a direita, mas vou mostrar isso
inclinando a coisa em um segundo. A primeira coisa que quero
mostrar é a vastidão. Se eu definir isso para
um e eu apertar Play, podemos ver que
devemos ter um
haltere saltitante, o que é bem legal. Obviamente, se eu definir
isso agora para algo como cinco e eu bater Play novamente, podemos ver que
o Dumbo vai subir
para a estratosfera. E se eu definir para 0,2, podemos ver que o Dumbo
tem um pouco mais realista assim,
o que é bem legal. Você pode usar isso para efeitos em seu jogo ou qualquer coisa
desse tipo. Segundo, todo o atrito que
posso ilustrar se eu inclinar minha câmera principal
um pouco assim, o que obviamente não
será ótimo em termos de revisão do jogo, mas vai ficar bem por enquanto. Espero que isso nos
mostre que
podemos deslizar junto com os atritos. Se eu bater em play,
vou deslizar. Se eu clicar na minha cena, não
estou me movendo porque
o atrito é tão alto. Então, se eu fosse definir meu atrito
para 0 e depois acertar o jogo, eu deveria realmente
me ver movendo ao longo da cena assim porque
o atrito está definido como 0, o que é bonito, bem legal. Obviamente, você pode
alterar seu atrito e saliência dependendo do que você deseja que seu personagem ou
objeto se mova com base em. Mas essas são as principais
funções de um colisor de caixa, o material e
o corpo rígido, que compõem o motor de física da
Unity. Obviamente, há
muito mais que você pode ir em unidades profundas física, mas em termos do básico, estes são basicamente
o corpo rígido. Obviamente, atribuímos objeto 2D de
física, e você não
precisa se
preocupar muito com todas as
coisas que mudamos. Geralmente, você pode deixá-los como quiser,
especialmente o arrastar. Você pode alterar a
escala de gravidade para cima e para baixo, se quiser. E, obviamente,
isso estará vendendo. Talvez seja necessário alterar
a detecção de colisão com base em quão rápido ou
lento você vai deixar o tipo de corpo é dinâmico
para seus propósitos se você estiver começando e
unindo, porque isso
provavelmente é o um que você
vai querer usar. E então o material obviamente
é bastante simples, mas você também pode realmente
deixar isso como eu acho que o material físico global
é, por padrão, 0,40, que é exatamente o que
tínhamos definido como. Esse é o básico
da física em unidade. E espero que isso faça
muito mais sentido. E espero que as coisas que
fizemos no último episódio com os sprites onde estava caindo e pulando para cima e para baixo. Isso faz com que seja um pouco mais de
sentido agora porque
explicamos como vagões
e corpos rígidos funcionam. Espero que você tenha gostado do vídeo e eu o vejo no próximo onde abordaremos a animação em Nova Jersey
pela primeira vez.
6. Animação: Ei lá e bem-vindo de
volta à unidade. Agora, dois episódios atrás, passamos por cima dos dois
tipos diferentes de sprites AUG,
ou seja, múltiplos sprites
e sprites únicos. Você pode ver que eu configurei ambos em um projeto de amostra para o
propósito deste vídeo, porque vamos mostrar
a você como
animá-los pela
primeira vez no Unity, o que na verdade pode ser muito
mais simples do que você acha. Agora, muitas pessoas gostam de
usar outras
ferramentas externas para animação, como o blender ou qualquer outro aplicativo
de terceiros. Mas, geralmente,
na verdade, tem um animador de mecanismo muito bom, o que permite
animar seus objetos, tanto objetos únicos quanto animações
baseadas em sprite e
vários objetos. Ou movendo os sprites para
animá-los para fazer
parecer que estão
correndo, pulando ou atacando de várias maneiras
diferentes. Vou mostrar como
fazer as duas coisas neste vídeo. Para começar, dirija-se ao
seu único sprite. No meu caso, estou usando o blob que fizemos
alguns vídeos atrás. E vou querer
animar este blog para que ele tenha uma animação
ociosa. Você pode ver se eu vou
até o meu sprite, na verdade tenho duas bolhas aqui. O primeiro será
o primeiro quadro de animação
ociosa, enquanto o segundo será
o segundo quadro. Então, se eu for aqui, o primeiro quadro e esse é
o segundo quadro, você pode ver se eu tenho assim, ele vai estar balançando para cima e
para baixo, o que é bem legal. Mas, obviamente, preciso
saber como fazer com que
a unidade diga ao objeto para subir e descer
com base em um determinado intervalo. Então, vamos fazer isso. Vou clicar em Adicionar
componente e vou adicionar um tour animate, não
Animation Animator. E isso basicamente
adicionará um animador ao meu objeto, o que me permitirá
fazer exatamente o que acabei de dizer. Mas agora eu realmente
tive uma animação. Então, vou até
o topo aqui e clicarei em Animação de Janela, e vou selecionar
animação aqui. Então diz para começar a
animar single, que é o nome do
meu objeto, crie um clipes de animação que
vou criar. Então vou
nomear minha animação ociosa. E isso vai
criar um arquivo ponto e m. Você pode vê-lo
ali, anime de ponto, e há nosso controlador de
animação. Então, basicamente, a maneira como isso funciona é este é o único clipe. Posso ter muitos
desses. Posso dar salto
ocioso, correr, etc. E então este é o controlador, este basicamente o objeto que
vai executar
essas animações. Portanto, neste caso,
o único objeto, um único sprite, tem esse controle em um
único, o que significa,
ok, estou executando esse
conjunto de animações e seguida, um conjunto de uma imagem
está funcionando corretamente agora é apenas a animação ociosa. Então, vamos começar a
fazer essa animação ociosa. Você pode ver uma vez que eu fiz isso, fui para a Animação de
Animação de Janela e cliquei em Criar porque não
havia animação lá. Ele abriu essa
pequena animação. Sempre que você pode ver
eu tenho minha animação e o nome da minha animação. Se eu quisesse mudar
isso, se eu tiver vários, posso clicar neste
menu suspenso e selecionar vários ou criar
uma nova animação. Mas, obviamente, eu só
quero um por enquanto. Então, para começar a animar isso, o que vou fazer é
clicar
no botão gravar. E basicamente o que esse botão de
gravação faz
é basicamente dizer
que tudo o que eu fizer agora será definido
nesse ponto da animação
é que estou no momento 0. Então, se eu começar a animação
fazendo momentos em que você a
moverá para salvar lá. Em seguida, mova-o até
aqui até o tempo de 1 segundo. Eu não quero
movê-lo todo o caminho até lá. Na verdade
, a animação vai ser essa. E tenho certeza que você pode
imaginar que está apenas espelhando
exatamente o que eu não chateado. Mas como isso é uma animação baseada em
sprite, não
estamos muito preocupados com posições ou qualquer coisa assim. Ficaremos
preocupados com sprites e com a forma como essa
animação funciona, no minuto em que você clicar
neste botão vermelho, quaisquer alterações que você
fizer um editor para esse objeto como mudar seu
posicionar ou alterar sua escala, qualquer coisa assim será definida como um quadro-chave ou qual deve ser
o objeto nesse
ponto da animação. Então, se eu estiver me movendo, posso fazer algumas das
coisas que posso fazer isso menor e
mover isso para lá. E então você pode ver,
obviamente, isso é exatamente como a animação parece ruim, não a melhor animação, como
tenho certeza que você pode descobrir. Mas espero que isso mostre
uma pequena demonstração de como esse botão de gravação
no animador funciona. E você pode ver
aqui, se você clicar nele, poderá desativá-lo. E
agora posso fazer alterações. Na verdade, eles não são
baseados em animação. O que vou fazer é
apertar este botão de
gravação e
vou
falar 50,5 de segundo. Vou aqui para blogar com um clique
no meu sprite, e vou clicar no blog para, e como eu tinha
esse modo de gravação ativado, ele registrou essa alteração. Então agora diz, ok, quero dizer, amado um minuto eu chegar a isso, voltar para o bloco dois. Mas, obviamente,
a animação vai indexar. Não há nada. Se eu jogar isso, ele não
o altera ou muda para um quadro e depois volta
e isso não é ótimo. Então, eu quero
fazê-lo para que ele mude exatamente
pela mesma
quantidade de tempo. Então, tem metade do tempo lá e metade do
tempo lá. Então, vou
realmente ir aqui para meus quadros-chave e depois
clicar na parte superior. Na parte superior, é
como selecionar todos eles. Você pode ver aqui, eu tenho um quadro-chave que está
selecionando um único sprite. Mas se eu clicar no topo, ele seleciona todos os
quadros-chave e os ruins. Se eu tivesse outro, poderia selecionar o topo
e selecioná-los todos também. Obviamente, não sei. De qualquer forma, vou
clicar neste aqui. Vou pressionar Control C
para copiá-lo e passar todo o caminho para a marca de 1 segundo e pressionar Control V para colá-lo. E agora podemos ver que minha animação está
praticamente feita. Tudo o que fiz foi que fiz
duas pequenas alterações. Eu também poderia ter conseguido
a segunda mudança indo aqui e depois mudar meu
blog de volta para Blob um. Obviamente, meu jeito foi um pouco mais simples porque
eu posso simplesmente copiá-lo. E geralmente
acho que copiar suas animações
do início
ao fim é bastante útil
porque você geralmente quer que elas terminem onde
você as iniciou. Muitas vezes, especialmente
com
animações em execução ou coisas assim. Mas com as nações insulares, esta em particular,
eu queria a mesma coisa, então acabei de copiá-la. E agora, se eu bater em jogo, você pode ver que meu blob está animado e está
ocioso para cima e para baixo. E isso é realmente muito
legal porque se eu for
em frente no jogo e eu apertar Play, você pode ver que meu
blob o p é invisível. Isso não é bom. Eu acho que a razão para
isso é, na verdade, porque meu voo de posição Z bloqueado por algum motivo foi definido como
menos nove por padrão. Isso é só
uma coisa estranha. Anos que ele faz. Mas se você se deparar com esse
problema a qualquer momento, você pode simplesmente ir aqui
e você pode definir isso como 0 e isso garantirá que ele esteja visível pela câmera. A razão pela qual isso acontece é
porque a câmera principal por padrão, tem uma
posição z de menos dez e quaisquer objetos que
tenham uma posição z inferior à que
será invisível para a câmera como você
pode veja ali. Se você não conseguir ver objetos, apenas certifique-se de
defini-los como 0. É uma falha um pouco
estranha, mas é bom que eu tenha que te
guiar por isso. E então, se não, dissemos 0, tudo
funcionará perfeitamente. Se eu apertar o botão play. Quando você vê agora, meu objeto está balançando para cima e para baixo,
o que é muito legal. E isso é
exatamente o que eu queria. Mas você pode estar pensando, como o animador sabia
qual clipe de animação tocar? Porque obviamente
só tínhamos uma, mas e se eu tivesse
outra animação, como uma animação de salto? Quero saber quando jogar
essa animação de segundo salto. E a forma como realmente funciona é usar controladores de animação. Então vamos aqui,
animação de janela e clique em animador. E isso realmente
vai abrir essa nova janela do Animator, que é a unidade está animando. Você pode ver que é
composto por um
monte de blocos coloridos. E atualmente tem entrada, qualquer estado, ocioso e saída. E você pode realmente
mover esses blocos apenas clicando neles
e selecionando o nome. Agora, esse
animador em particular é baseado em qualquer objeto que eu
selecionei ou estiver ativo. Então, obviamente, eu estava trabalhando com um único objeto e
com um único controlador. Então este é o único animador. O que estamos vendo aqui é uma representação
desse controlador. E se eu clicar duas vezes nele, eu tenho exatamente o mesmo efeito que fecharia
o Omega e, em seguida, clique duas vezes nele
e você pode ver que ele se
abre assim. E, obviamente,
o que está acontecendo agora é que ele começa
e o modo de entrada e então ele entra em qualquer
estado de animação que quiser. Ou, neste caso
, só há um. Então, ele só pode entrar neste MHC. E você pode ver que as transições de entrada
padrão não
são previsíveis. Então, basicamente, o que isso está
dizendo é que eu não posso mudar qual evento de animação
porque tenho uma animação, vou automaticamente entrar nele. Você pode simplesmente desativar
a animação , a menos
que você diga o que o animador, mas isso é um efeito para
salvar todo esse controlador. Então, o que eu poderia fazer,
na verdade, se eu fosse aqui e quisesse fazer
uma nova animação ou C, eu poderia ir aqui, clicar em Criar
novo clipe embaixo da garrafa. E vou chamar
isso de um chefe ocioso. E, na verdade,
será exatamente o mesmo que o meu anterior, exceto em duas vezes de velocidade. Então vamos aqui para 15, trocamos meu blob e voltamos
para 30 e mudamos meu blob. E você pode ver
agora se eu acertar o jogo, é exatamente a mesma coisa
em duas vezes de velocidade. Meu ídolo um era
obviamente muito mais lento. Mas sim, agora tenho
duas animações. Se eu voltar para esse controlador, você pode ver agora que
há duas animações, ociosas destacadas em amarelo, e minha nova animação, ociosa rapidamente. Mas eu quero fazer a transição
entre esses dois. Bem, há duas
maneiras de fazer isso, e isso está chegando à mesma parte
ou competente
do animador. Mas está tudo bem. Tenho certeza que todos em movimento isso
será capaz de lidar com isso. Então, apenas se concentrar em tudo
fará sentido. Se você ficar preso,
você pode voltar ao vídeo porque vou
explicar tudo em muitos detalhes. Basicamente, a maneira como
posso fazer a transição entre esses dois estados é
usando essa transição. Então, se eu clicar em Fazer transição, posso arrastar ou
arrastar o capítulo, basta mover o mouse e clicar em um para o qual quero
fazer a transição. E podemos ver
aqui em cima agora temos uma transição entre os dois. Se eu clicar nessa transição, poderei editar as propriedades de
transição. Há um monte
de propriedades diferentes aqui e condições. E a maneira como essa transição funciona é que ela pode
fazer a transição com base no fato de
esta animação ser feita, nem todas com base em um
determinado período de tempo ou pode fazer a transição exatamente
quando eu digo a você. Agora, a maneira como você
faria isso é via códigos. Se eu tivesse um script, eu poderia criar um script. E então, em algum
momento do roteiro, eu poderia fazer uma referência ao meu animador obviamente
entrará nisso um pouco mais
quando entrarmos edição de
script ou script. E posso fazer uma
referência ao meu animador. E então posso dizer parâmetros do conjunto de
pontos do animador. Então eu posso torná-lo
parâmetro aqui como um booleano ou em um
flutuador ou gatilho. E eu poderia mudar
esse parâmetro, e isso me permitirá
mudar essa condição. Obviamente, isso pode parecer
um pouco complicado agora. Mas, basicamente, a maneira como
essas condições funcionam é que eu posso mudar meu
estado via código, mas uma
maneira muito mais fácil de fazê-lo, na verdade, vou mostrar a vocês agora é
apenas fazê-lo com base no tempo. Agora podemos ver
que diz Has Exit Time, o que basicamente significa que ele tem um tempo em que
ele vai fazer a transição. Eu desmarque isso. Ele diz que a transição precisa de pelo
menos uma condição ou uma x vez para ser válida,
caso contrário, será ignorada. Em outras palavras, eu não
defini que um tempo deve ser encerrado. Eu não dei
nenhuma condição. Então, não vai fazer a
transição como oh, isso de volta. E eu defini isso para 0. Isso é 0 basicamente significa que ele
sairá no final
da animação. Então também posso alterar a duração da transição e é o tempo
que a
transição leva. Então você geralmente quer que isso seja algo muito pequeno, vamos ouvir de um
ou realmente 0 para nossos propósitos, porque estamos
usando animação baseada em sprite, não
queremos ser
meio em transição de uma
animação baseada em SPI para a outra, vamos defini-la como 0. E então, obviamente, o deslocamento
transitório geralmente só se preocupa nem com a fonte de
interrupção. Mas se eu for aos meus
ídolos rápido agora, vou querer fazer a
transição de volta para este porque senão
eu vou
ficar preso neste para sempre. Quero fazer outra
transmissão, arrastá-la para baixo. Você pode ver que essa seta para baixo
é minha nova transição. Vou fazer minha hora de saída 0. Em outras palavras, o
tempo integral dessa animação, se eu configurá-la para duas transições, ofereça dois segundos,
mas a tendência 0 ficará bem depois que
a animação for concluída. E eu faço a
duração da minha transição 0 novamente. Agora, o que deveria
acontecer se eu apertar Play? Podemos ver que eu
deveria sair da única
animação juntos. Essa é a animação lenta,
que é rápida. Então eu diminuo a animação primeiro. Na verdade, podemos ver
isso na animada. Se formos até aqui,
estamos fazendo a transição entre as duas animações,
o que é muito legal. Basicamente, o que
fizemos aqui em cima é que
fizemos uma transição, definimos para que tudo bem,
tenha um tempo de saída. Em outras palavras, a
razão pela qual ele vai fazer a
transição é baseado no tempo ou na
quantidade de animação feita, não com base no código. E então nosso tempo de saída é 0. Ou, em outras palavras, a
duração total da animação, que geralmente
considero a mais útil para usar. Você pode realmente
definir isso como um valor, se precisar. Mas sim, e então eu tenho
minha duração de transição, 0 segundos porque
quero passar o tempo de transição entre eles. E então isso é basicamente
tudo o que fizemos. E agora
nos permite fazer a transição de e
para essas animações, o que é muito legal. Agora, a segunda coisa que quero
destacar é
simplesmente rapidamente aquela
coisa de condição que eu estava fazendo ou sobre porque é muito útil
e pode ter parecido bastante complicado quando eu
passei pela primeira vez. Então,
vou simplesmente mostrar a você como funciona. Basicamente, se eu passar por
aqui dois parâmetros, posso criar um novo
parâmetro que é como um novo valor que é
armazenado em uma variável. Vamos analisar as variáveis
no próximo episódio porque
vamos ter
introdução à codificação. Mas se você já sabe
o que é uma variável,
é basicamente um
espaço de armazenamento para um valor de dados. Vou definir o
meu para booleano. Vou chamar
meu booleano falso. Agora, quando este booleano é verdade, quero fazer a transição desse para
aquele. Quando for falso, quero traduzir desse para
aquele. Então, o que vamos fazer, vamos passar
para a minha transição. Vamos desativar
o tempo de saída. Em outras palavras,
não quero mudar com base em quanto
da animação é feita. Quero mudar
com base na condição. Vá aqui para minha condição. E eu vou dizer rápido, é automaticamente sexo
é o único que eu tenho. Posso dizer que rápido é verdade
quando falso para verdadeiro. Quero fazer a transição para lá. E aqui, quero exatamente
o oposto. E vou selecionar
Rápido para ser falso. E basicamente agora,
sempre que rápido for verdade, vou fazer
a transição desse para aquele. Sempre que rápido for falso, vou fazer a transição
dessa para aquela não importa o quão longe esteja
minha animação, apenas pretendia desmarcar o tempo de
saída para ambos. Caso contrário, você também fará a
transição automática. Vai ficar um
pouco confuso. E agora podemos ver que irei animação
padrão com base em onde estamos indo da entrada ou o início está realmente
definido para qualquer um deles. Eu poderia mudar isso se quisesse, mas vou
deixá-lo por enquanto. Então, em outras palavras,
se eu jogar meu jogo, podemos ver que estou começando
na minha nação insular lenta. No entanto, se eu for ao meu animador
e clico tão rápido, mas você pode ver que eu
transito automaticamente para o meu ídolo fosfina. Volte aqui e estou
na minha primeira animação definindo-a como false,
nós fizemos a transição de volta. Essas são, na verdade,
toda a unidade básica ou sabe como a unidade
é o animador funciona. Basicamente, temos esses blocos, que são nossos clipes de animação. Temos ocioso, ocioso rápido. A maioria dos jogos você
teria algo como ataque de
salto, ocioso,
coisas assim. Então você usaria suas
transições para ir entre elas. Então, se eu quisesse ir
de ocioso para ocioso rápido, eu faria uma transição. E básico, eu posso
usar tudo bem, uma vez que eu tenha ficado ocioso
uma
vez tudo com base em uma condição que
provavelmente é o que você vai
usar mais do tempo. E então você pode simplesmente definir
essas transições por um código. Vamos rever isso mais
no próximo vídeo. Quando começamos com nossa codificação, acabei de mostrar como
fazer isso no editor. Mas basicamente tudo o que você precisa fazer é quando criar uma
referência ao seu animador, você pode dizer parâmetro de conjunto de
pontos de animação e, em seguida, definir seu parâmetro
como esse código de barras. E isso permite que você
programe
a lógica para mudar entre
as animações. Não se preocupe se isso
soa um pouco intimidante, como eu disse, vamos rever
isso no próximo vídeo. Vou mostrar implementações do animador nos vídeos
de codificação. Então isso tudo vai fazer
muito mais sentido agora. Mas basicamente apenas passando por cima do editor e do animador
no editor. Essas são todas as coisas
que você precisa saber para criar bastante complicados e sistemas de animação
bastante complicados e
intrincados, o que é muito legal. Agora, a última coisa que precisamos
abordar neste vídeo é simplesmente a animação
baseada em múltiplos, que na verdade é muito mais fácil do que o que
acabamos de passar, como se
você tivesse entendido basicamente o que acabamos de fazer
com transições. Como a transição funciona com os dois tipos diferentes
de transição, o tempo de saída e as condições. E a maneira como os clipes de
animação funcionam, então você está muito bem. Eu diria que você ficaria muito bem em entender como
o resto disso funciona. Se você parecer confuso,
basta voltar, talvez assisti-los novamente, coisas. Como eu disse,
vamos rever isso novamente no vídeo de codificação
quando implementarmos o código. E vamos mostrar
a você como implantar animá-lo em código, assim como uma pequena parte
lateral do vídeo. Portanto, não se
preocupe muito com isso. Se a coisa que você
está confuso sobre todas as condições
que eu estava passando. Mas se você entender o
básico de como isso funciona
, tenho certeza que você ficará bem para a próxima parte deste vídeo. Você entendeu
exatamente o que eu queria retratar. Tão ótimo trabalho nisso. Agora, se eu for
para o meu múltiplo, você pode ver que eu não
tenho um animador aqui. Assim como adicionei
um ao último, preciso de um animador para
começar a animar objetos. Vou para Adicionar
componente, criar um novo animador, que criará uma dessas máquinas
de estado. Em outras palavras, uma
daquelas coisas que me permitem fazer a transição. Então vamos animação de janela. Animação, assim como
fiz da última vez. Clique em Criar. E então eu vou até
aqui e vou chamar isso de um jeito porque eu não
faço uma simples animação de ondulação. Agora, aqui vejo que
criamos meu novo
controle e múltiplos. Se eu
clicar duas vezes nele, podemos ver há exatamente o mesmo
que tivemos da última vez. Vai da entrada na minha animação de ondas porque
esse é o padrão. Não é possível
fazer a transição para nada porque não há
outras animações. Mas vou
mostrar a vocês como fazer alguma animação de sprite múltiplos. Outras palavras, animando
as partes reais
do Sprite em vez de
animar o próprio sprite. A primeira coisa que você
faz antes de entrarmos nisso, no entanto, é alterada. O sprite varia
tão ligeiramente para que possamos ver se você se lembra no último vídeo
ou dois dias atrás, em vez disso, definimos nosso
modo sprite para múltiplos, e isso nos permitiu
abrir o Sprite Editor e cortar tudo nossas diferentes
partes do sprite. Mas, para tornar esse
processo de animação muito mais fácil, na verdade também vamos
querer definir pontos de pivô. Você pode ver esse círculo azul
no meio do sprite. Esse é o ponto de pivô
e eu posso movê-lo. No entanto, onde eu quiser e isso
mudará com base nisso. Então, obviamente,
por causa disso, porque este é um corpo, eu quero que o
ponto de pivô do lago esteja por lá
em vez de lá. Em outras palavras, quando
eu escrevi,
ele vai girar a
partir desse centro em vez de
seu Centro real. E vou fazer isso
por todos eles. O braço, obviamente quero
girar a partir daí. A cabeça que eu
gostaria de girar ao redor se o próximo
post seria o tronco. Não vou estar girando, então não preciso me
preocupar com isso. Braço direito. Vou
girar a partir daí. E a perna direita é uma posição
semelhante. E se eu apertar Aplicar agora podemos ver
que isso realmente vai misturar todas as minhas coisas
e separá-las todas, mas tudo bem. Isso é
o que deveria acontecer. Vá em frente e mova todos de volta para onde
eles deveriam estar. Acho que o meu está mais ou menos lá. Lá. E então aqui e aqui, tenho que fazer alguns ajustes. Mas para o homem básico,
acho que isso é muito bom. E mova este para a
direita lentamente e para cima. E esse é o passo básico
nove que reconstruímos. E agora podemos realmente,
se eu for aqui até o meu braço e eu acertar esta
ferramenta Girar e girá-la. Vou girar a
partir dessa posição, o que é realmente
útil para animar. Então volte para o objeto dos meus pais, minha janela múltipla oculta,
animação, animação. E como eu já criei minha onda, ela se abre automaticamente. Não preciso
criar um novo clipe. E agora vamos fazer
exatamente o que fizemos na primeira vez com o sprite. Exceto que desta vez
vamos animar o objeto em vez de todos os sprites,
os mini sprites, em vez do principal grande sprite, podemos ver aqui
que temos o objeto pai, que adicionamos
a animação dois, o que significa que podemos animar todas essas pequenas
coisas por baixo dela. Obviamente, se eu tiver a
animação da cabeça, não
poderei
animar mais nada. Você só pode animar
o objeto em si e os objetos abaixo do
objeto. Portanto, tenha isso em mente. Mas, obviamente, a forma como
estruturamos nosso sprite, isso não será
um problema para nós. Basta ir para múltiplos,
vou apertar o botão vermelho
como fizemos da última vez. E para simplificar a
onda e a animação, vou
levantar a mão direita, acenar e colocá-la de volta. Então eu vou aqui
para o braço direito e vou acertar
esta ferramenta Girar, certo, tínhamos
aqui girá-lo. Na verdade, vou
querer
mudar isso porque eu não quero
escrevê-lo para preferir estar dentro. Quero
escrevê-lo para transportar. Segundo. Alguns são girados
até lá, eu diria. E então eu vou, acho que isso pode
ser um pouco alto, mas é bastante adequado para a direita só
para não parecer estranho. E essa basicamente
será minha primeira parte da animação, talvez
movendo-a para lá. E então, na segunda parte,
eu realmente vou ser uma onda. E então eu estou aqui
um pouco para a frente e vou mover
isso novamente, avançar um pouco e movê-lo, copiá-lo exatamente como
fez da última vez. Então, em outras palavras,
eu vou como essa onda e depois vou
querer colocar meu braço de volta. Então, o jeito que vou fazer isso é ir até
aqui e vou contar este 2.5º e este 47 para ir
outro 2.5º ali. E é assim
que isso vai parecer. O que é bonito, muito legal. Agora, a última coisa que preciso fazer é ter certeza de que o resto
do corpo realmente se
afasta para que ele não pareça tão estático porque agora não
é uma maneira muito boa. Então a primeira coisa que faremos é garantir que o braço esquerdo se mova um
pouco com o braço direito. Então, vou até aqui para o braço esquerdo, um pouco lá. Então ele vai se mover
talvez um pouco lá e um
pouco para lá. E então, obviamente, copiou
o início e o fim. Eles começam a terminar
exatamente o mesmo lugar. Agora eu movo meu braço esquerdo para cima, mas isso é um pouco brusco. Então, na verdade, indo
para cá e, em vez de
se mover muito para baixo, mova-o um pouco menos do que C. Agora, espero que
pareça muito melhor. Ainda é muito brusco lá. Então deixe-me ir em frente
e mudar isso de volta. E isso parece muito
melhor na minha opinião. Posso ir assim
e posso acenar. E então a última
coisa que vou fazer é mover
a cabeça tão ligeiramente girada para a esquerda, assim como fizemos com o pescoço
girando e depois movê-lo ligeiramente para a
direita ali e então copie a mesma coisa
ali assim. E acho que foi uma animação de onda bastante
decente. A única coisa que eu
diria é que talvez a cabeça comece a se mover
um pouco cedo demais. Então eu vou voltar para a minha cabeça e vou girá-lo lá
ainda
para que ele não
se mova tão abruptamente. E podemos ver lá,
essa é a minha animação de ondas. E se eu voltar aqui para o
meu jogo e eu bater em jogo, poderemos ver
ambas as animações em ação. Podemos ver a animação de onda em repetição porque é
a única animação no editor ou
o
rolo do animador clica duas vezes em vários. Podemos ver essa
animação que
foi, não está mostrando tanto. Não sei por que às vezes o Unity tem um pouco de falha
onde não mostra que o inimigo goste jogo de tiro como
era com o outro. Mas, por qualquer motivo
, não é muito importante. Obviamente,
só nos mostraria
percorrendo essa coisa de uma onda. Podemos ver, na verdade, que está
funcionando muito, muito bem. Podemos ver que temos nossas duas
animações agora lado a lado, unidirecional
da animação e
a animação de um sprite. E espero que isso realmente faça muito mais sentido sobre o motivo pelo qual devemos usar sprites múltiplos
ou únicos. Porque, obviamente, se estivermos
fazendo um jogo de pixel art, isso é óleo que
realmente vamos precisar. Parece muito
bom, minha opinião. Mas se você quiser fazer uma equipe
real de pleno direito com designs de
personagens mais intrincados, então ter que fazer beisebol de
animação, você imagina ter
que fazer uma única faixa, cada um desses
quadros, faça backup. Então esse é um breve
resumo da animação no Unity. Espero que tudo faça
muito mais sentido. Nós abordamos como funciona uma animação de
sprite simples, como funciona várias
animações de sprite e como o animador funciona com as transições entre
os diferentes estados. E nós cobrimos
praticamente todas as maneiras de
fazer a transição, exceto via código, que, como eu disse, passam por cima da codificação. Você só se
preocuparia com isso ainda, mas saiba que todas as
outras coisas que cobrimos levantaram
animação e unidade. E isso permitirá que
você comece a animar a anuidade e tornar seus
jogos um pouco mais vivos, o que é muito legal. Obrigado a todos por assistirem,
e te vejo
no próximo vídeo em que
passamos pelo código pela primeira vez. Talvez não cobrimos o código de
animação
no primeiro vídeo de código, apenas
como um código de introdução. Mas definitivamente em um
dos três vídeos de codificação que
planejamos, eu fiz na próxima
parte deste curso, mostrarei como implementar o animador na
codificação como está, se encaixa em um vídeo é muito bom. Então,
obrigado por assistir. Vejo você no próximo vídeo.
7. Introdução aos scripts: Ei lá e bem-vindo de
volta à unidade. Agora, nos últimos episódios,
abordamos sprites, animando a física e um monte de
outros conceitos básicos de unidade. Mas, na verdade, não
cobrimos uma
das partes mais importantes do código
do mecanismo de jogos Unity. E é muito difícil fazer
um jogo para celular ou qualquer jogo
para esse assunto, na verdade, sem saber como
se desenvolver no C-Sharp, obviamente existem alternativas
como scripts visuais em Unity e Unreal Engine
também tem um recurso semelhante. Mas para o propósito
deste curso, vou mostrar
como criar scripts ou arquivos C-Sharp, que você pode realmente
usar em seus jogos. Isso começará neste
episódio em que vamos fazer uma introdução ao
C-sharp no Unity. Agora, antes de começarmos
apenas como um aviso de isenção de responsabilidade, deve-se notar
que este vídeo pode parecer um pouco intimidante
para alguém que nunca,
nunca programado
antes em sua vida. Agora isso não significa que
você não vai
entender tudo
e espero que você ainda ganhe todos os conceitos básicos que estou
tentando explicar este vídeo, mas apenas observe que o
propósito disso
vídeo não é para você entender
cada linha de código
que escrevemos, mas simplesmente para entender
a estrutura básica ou blueprint que usamos
para escrever código no Unity. Vou analisar três conceitos
básicos de codificação. E se você entender
cada um de seus papéis no
editor Unity ou no C-Sharp. Mais importante, então você
entendeu tudo o
que precisa para este vídeo. Não se preocupe muito com
o código específico que estamos escrevendo e com as
palavras-chave específicas que estamos usando. O objetivo principal
deste vídeo não é
rever isso com muitos detalhes, mas simplesmente explicar o esqueleto básico de como funciona a imunidade de
codificação. Com isso dito, espero que você goste e vamos
entrar no vídeo. Então, para começar, você vai clicar com o botão direito do mouse aqui
e o menu deste ativo, vou criar um script
C-sharp. E vou nomear
meu roteiro em espírito. Não importa
o que você o nomeia. A única coisa que você
precisa observar,
você não pode usar um espaço
ou palavras reservadas, então não nomeie seu
script como câmera ou qualquer coisa assim. Não coloque um espaço entre
esses dois porque o nome aqui é para corresponder
com o nome ali, que mostrarei assim que
abrirmos este script. Depois de abrirmos esse script, certifique-se de nomear
uma única palavra que
não seja reservada de
forma alguma ou que não seja reservada. Porque essa coisa
aqui, essa classe pública, esse nome de classe,
eles correspondem ao nome do script, o que obviamente
pode acontecer. Então isso está tudo bem. E quando você abrir,
você ficará um pouco confuso. Tem algumas coisas
aqui usando que tem classe
pública e, em seguida,
anula e anula a atualização. E vou explicar o que são
todas essas coisas. Então você pode pensar
em primeiro lugar, essa classe pública como basicamente apenas um controle de todas
as partes do meu roteiro. Você não precisa se
preocupar muito com exatamente quais são as aulas. Basta pensar nisso como um contêiner para todas as
diferentes partes dos meus scripts. Vou escrever
meu roteiro inteiro entre essas duas
coisas aqui. E isso é tudo o que você realmente
precisa pensar. Você não precisa
pensar em criar mais classe ou qualquer coisa ainda. Códigos e conceitos muito mais complicados. Mas basta usar o seu agora, pense nisso como um contêiner, o início e o
fim do meu script. E aqui, esse uso, isso é basicamente especificar quais partes do meu
mecanismo Unity eu quero usar. Portanto, estou usando coleções de
sistema, coleções sistema,
genérico e mecanismo Unity. Você só se preocupa demais com
isso. Basta observar que, se
você quiser usar, por
exemplo, como elementos de interface do usuário, eu poderia ir para o
topo e acadêmico usando a digitação,
geralmente ponto do motor. E então aqui temos UI e isso vai me permitir usar um monte de mais
recursos ou código no Unity, o que agora reconhecerá. Não se preocupe muito com
isso ainda. Basicamente usando o que
vou
usar e classe pública onde
o script é escrito. Agora, há três coisas principais que vou simplificar
esse tutorial de codificação. Primeiro, vamos
cobrir nossas variáveis, depois abordaremos
métodos
e, em seguida, vamos cobrir
o código real em si. Vamos começar com variáveis. Agora, as variáveis são ineficazes, espaços
de armazenamento para
valores ou dados. Se eu quisesse armazenar, você pode pensar em variáveis como uma caixa. Se eu quisesse armazenar
um número ou uma palavra, ou até mesmo um objeto de jogo. Uma dessas coisas
aqui no Unity, obviamente, eu poderia fazer todas essas
coisas usando variáveis, e é
assim que fazemos isso. E posso declarar
essas variáveis na parte superior do meu script. E isso vai
me permitir usá-los em todo o script com o código conhecido exatamente do que
estou falando. Por exemplo, eu
poderia criar um público. Agora vou precisar
escolher um tipo de dados. Portanto, obviamente, as variáveis podem armazenar todos os tipos de dados
diferentes, mas para torná-lo um pouco
menos intensivo
na CPU ou no
computador em geral, é melhor para nós especificar qual tipo de dados
vamos usar para que o computador
possa saber o que esperar. Então, em outras palavras,
se eu fosse pegar uma variável pública e eu puder armazenar números ou
cadeias de caracteres ou qualquer coisa. Isso torna as coisas
muito mais complicadas. Vou escolher
um tipo de dados. Vou usar números,
palavras ou letras,
coisas assim. E vou
escolher o tipo de dados. E os quatro
tipos de dados principais que vamos cobrir são booleanos,
que são basicamente como variáveis
verdadeiras ou falsas. Eles podem
ser verdadeiros ou falsos. Inteiros, que são
basicamente números. Eles podem ser 1234 ou cinco ou seis. Nome, acho que
meu nome é número, real ou flutuador, que
são basicamente decimais. Então eu posso fazer 0,3 ou
4,5 e depois string. E essas são basicamente
palavras e eu posso instalar e nomear unidade ou coágulos ou
qualquer coisa assim. Você não se preocupa
muito com a declaração. Vou quebrar
isso agora, mas basicamente sei que os
booleanos armazenam verdadeiro ou falso. números inteiros armazenam números,
carros alegóricos , decimais e
strings armazenam palavras. Há também outros
tipos de variáveis, como personagem, que obviamente
armazena um personagem que não é um dos principais. Então vamos entrar em todos os específicos
da Unity. Mas, por enquanto, você pode
pensar nesses quatro primeiros. Esses são os que
são mais usados. Agora, da forma como você
declara uma variável, primeiro
você precisa especificar se deseja que ela
seja pública ou privada. Para nossos propósitos, vou tornar
a maioria das minhas variáveis públicas porque o público basicamente
significaria que ela é visível a
partir do editor Unity. Obviamente, não é tão simples. Public, na verdade, também se
refere se outros scripts podem
acessá-lo a partir do script. Mas só para
facilitar este tutorial, não se preocupe
muito com isso porque esta é uma introdução ao script. Tudo o que vamos fazer
é fazer público para muitas
das minhas variáveis. Então, vou querer criar minha primeira variável
para ser um número. Então eu vou público int, o que significa inteiro, e
eu chamo de meu número. Então vou salvar
meu roteiro e
voltarei para o Unity. E agora podemos ver aqui, meu roteiro tem esse número inteiro
público, mas não há nada para mostrar
que menos roteiro é tocado. Meu script ainda não está
no meu projeto, porque a maneira como eu coloco
scripts no Unity é atribuindo-os como
componentes a objetos. Então vamos para o
personagem principal aqui. Podemos lembrar que, ao longo
dos poucos episódios anteriores, usamos esse componente de
colisor de borda, na verdade,
excluímos
isso por enquanto. Mas, da mesma forma, se eu
quisesse usar meu script, eu poderia anexá-lo ao meu objeto e, obviamente,
vou querer anexar o script ao uso de oxigênio se você estiver fazendo um movimento bíblico jogador, você simplesmente criaria
seu objeto de jogador ou atribuiria se você já tivesse um objeto claro e
arrastaria seu script lunar
para o seu jogador. E isso
permitirá que seu jogador
acesse o script de movimento. Acabei de criar
um script de introdução. Só tenho minha câmera principal como objeto porque não tenho mais
nada na minha cena. Então eu tenho meu script de interesses
e podemos realmente ver meu número aqui
como uma variável pública. E podemos alterar esse número. É um número inteiro, todo o caminho negativo e todo
o caminho positivo. E posso configurá-lo para o
que eu quiser. Eu usaria um número inteiro
se quisesse
manter a pontuação ou a saúde ou
algo assim. E então eu posso mudar esse valor com base no que
está acontecendo no jogo. Mas agora tudo o que você precisa ilustrar é que criamos nossa primeira variável
e podemos editá-la no editor Unity, o
que é muito legal. Agora, se eu voltar
ao meu script, posso criar outra variável. Deixe-me chamar
essa string e
vou chamar esse texto de forma
muito semelhante, se salvarmos, voltamos
para o Unity Editor. Podemos ver agora, depois de
recarregar meus scripts, temos nossos novos textos variáveis
e posso chamar isso. Olá, obrigado esse homem. Mais de três. E então isso realmente
será salvo. E isso é realmente útil se você puder pensar em
um script de movimento, por exemplo, eu quero ir o
quão rápido a placa pode ir. Posso fazer uma variável
chamada velocidade. E então, no
editor Unity, posso alterar a velocidade e isso realmente afetará o
resto do script, que é uma das maneiras
pelas quais eu uso variáveis, variáveis
públicas nos meus scripts, o que é realmente, muito útil. Agora, obviamente, há um monte de mais variáveis
que podemos criar. Como eu disse,
temos um carro e
temos booleano e todos
os outros tipos. Mas, o mais importante, existem especialmente
variáveis específicas do Unity que podemos usar, que são incrivelmente úteis. Então, se você voltar para Unity mais
uma vez,
podemos ver aqui, esta câmera principal tem um
componente de câmera adicionado a ela. E também tem um ouvinte de
áudio. E você não precisa
se preocupar muito com esses componentes específicos, mas apenas saber que seus
componentes e unidade. E podemos realmente criar
referências usando variáveis para esses componentes ou até mesmo
dois objetos. Então, se eu
voltar para o meu roteiro, vou criar
um objeto de jogo público e chamá-lo sozinho
com um S. maiúsculo Alguma razão. Agora, se voltarmos
aqui, podemos ver meu
objeto de jogo público está realmente se referindo a um dos
objetos na hierarquia de objetos. Então eu posso arrastar isso para lá. E agora atribuí outra
referência ao meu objeto. Para tornar as coisas um pouco
mais simples, vou fazer um novo objeto e
chamo esse teste. Só para que não estamos
superlotando a câmera principal. Então, na verdade
, vou seguir em frente e remover esse script de lá e vou
arrastá-lo para minha variável de teste. Ele deveria ter definido esses como 0,
apenas para que fique centralizado
na tela. Então podemos ir até
aqui e podemos definir o teste para mim mesmo, definiria um número para cinco e
podemos definir as caudas altas. E essa é praticamente a extensão do nosso roteiro agora. Não
faz muito mais. Mas podemos ver que
essas três coisas criamos
referências. Então, criamos uma
referência a um número, uma referência a uma palavra e uma referência
a um objeto de jogo. Da mesma forma, podemos realmente
criar uma referência, um monte de outras coisas. Se você se lembrar
no último vídeo, um dos componentes
que cobrimos da última vez foi um corpo rígido. Se eu for a público, estou criando uma
referência 2D de corpo rígido e a mina de carvão RB. Nunca volte para Unity. Podemos ver uma vez que ele
realmente lê o script, agora
tenho um corpo
rígido vazio 2D, que posso adicionar se eu for adicionar um componente Rigid Body 2D
e arrastá-lo para lá, podemos ver que agora temos uma
referência a testa corpo rígido. Agora, criar essas
referências é,
na verdade , a forma básica de codificação no Unity. Porque se você
pensar sobre isso, se eu quiser criar um script de
movimento, posso mudar a velocidade
do meu corpo rígido. Lembre-se disso, isso é
o que afeta a física. Assim, posso alterar a velocidade de um corpo rígido com base em eventos
que acontecem no roteiro, crio um script de
movimento básico. Vamos nos aprofundar mais no
próximo episódio. Por enquanto,
vamos passar por cima de scripts
muito básicos. Em seguida, vamos cobrir
esses métodos chamados vazios. Mas tenha em mente que é assim que vamos criar
scripts ou codificar. Vamos
criar referências e depois manipular
as referências. Agora, como eu disse,
essas coisas aqui por seus joelhos são
chamadas de métodos. E a maneira como esses métodos funcionam é que eles acontecem em
um determinado momento. Porque se você
pensar em codificação, você quer saber quando
executar o código. E você não pode apenas
esperar que o código anote o que acontecer
quando, obviamente, se eu estiver jogando um jogo, eu quero que determinado código seja executado
quando estou pressionando os botões. Mas não criamos nenhuma
referência ou qualquer forma de dizer ao script a que horas
queremos que as coisas aconteçam. Neste momento, os dois únicos métodos
padrão
temos todo o método start, que é basicamente
o método que é chamado uma vez antes
do início do jogo, como logo antes
do primeiro quadro. E o método de atualização, que é chamado de cada quadro, podemos ver que há um
comentário acima aqui. Obviamente, isso estava apenas explicando o que o método de
atualização faz. Mas esse
método de atualização tinha um comentário acima dele, que basicamente
expandi-lo é chamado de cada quadro. Então, se eu for para o meu método de atualização, vou escrever impressão, que é basicamente uma
maneira curta de dizer, ok, imprima algo no console
log unity, você pode vê-lo lá. Vou colocar um suporte
aberto e
vou dizer teste de impressão. Neste momento,
esses testes de impressão que você pode executar cada quadro será bastante barulhento. Na verdade, vou cortar isso e vou colocá-lo na loja. Então, se eu voltar para
Unity e eu apertar Play, podemos ver Tesco
impresso uma vez antes do jogo começar exatamente
em 115930, seja qual for a hora agora, não
sei se o executo novamente. Podemos ver que ele correu novamente em 115914 porque havia
aproximadamente dez segundos de diferença. Exatamente dez segundos, mas é
assim que a
tempestade em todos os lugares. Assim, podemos usar o método estrela para fazer um
monte de coisas. Se você pensar novamente sobre
um script de movimento, podemos usar o método estrela
para definir a posição inicial do nosso personagem se
fizermos a plataforma de TI e jogos dizerem ok,
defina-o aqui, aqui, aqui. Da mesma forma, o método de atualização que
podemos usar para atualizar as coisas a
cada quadro. E esse método de atualização é,
na verdade, um dos lugares ou o local em que você
vai rastrear a entrada do usuário. Então, se você pensar em
um método de atualização, se você estiver verificando
cada quadro, quando um usuário pressiona um botão,
no minuto em
que pressionar um botão, esse amigo ficará bem, eles pressionam o botão
botão para fazer isso. E é assim que
rastreamos a entrada do usuário no Unity, eu poderia realmente
escrever código aqui. E vá ponto de entrada, pegue a tecla para baixo. Posso abrir o colchete novamente e
escrever espaço de ponto do código de chave. Então toda vez
eu pressiono a barra de espaço. E se o frame for
executar esse código, você não precisa
se preocupar muito com exatamente o que
escrevi aqui. Como eu disse, cubra isso cada vez mais à medida que
entramos em scripts. Mas basicamente saiba que esse método de atualização
executa todos os quadros. Então, se eu voltar para aqui,
agora imprimo um teste, cada quadro,
volto para Unity. E eu bati Play. Podemos ver cada quadro que
temos um novo
teste ali mesmo. Oitocentos, mil, dois mil e três mil. E todos eles estão
correndo 1 segundo, 1 segundo, 1 segundo. Se eu desligar esse
agrupamento ou se eu preferir fazê-lo para que eles não colapsem um
no outro. Por aqui, podemos ver
cada um
desses testes sendo
frios, cada quadro. É muito difícil para esse
sistema acompanhar isso. Se eu descer, posso
ver todos eles entrarem. Você pode ver, obviamente,
já existem mais de
mil desses, o que é muito, muito ruim para o computador se eu quisesse
executar coisas a cada atualização. É por isso que usamos
condições para garantir que, tudo bem, somente nesses
quadros específicos não façam coisas como pular ou mover
ou coisas assim. Agora, a última coisa que
eu quero cobrir é o código real em si. Agora escrevemos
aqui o comando print, que é um exemplo de
um comando em unidade. E há um
monte desses e
podemos usá-los para imprimir coisas
diferentes. Ou não só a impressão pode usá-los para fazer
praticamente todo o nosso código. Vamos escrever
nosso código nesses métodos. A terceira coisa que quero cobrir
é que se eu der aqui, posso realmente criar
meu próprio metatag. Vá. Cara, chame-o de MyMethod. Coloque parênteses para
mostrá-lo ao método
e, em seguida, colchetes encaracolados. Mais uma vez, camisas e método. Se eu for aqui
para meu Prentice, posso colocar isso no meu método. E então sempre que meu
método for chamado, o que obviamente nunca é
capturado dentro do roteiro, farei exatamente a mesma coisa. A maneira básica como a codificação
funciona em energia, especialmente é que temos essas
variáveis que
seremos manipuladas para fazer
nosso código funcionar a todos,
temos esses métodos que
basicamente são seremos manipuladas para fazer
nosso código funcionar a todos, temos esses métodos que executados em determinados momentos. Este executa todos os quadros. Este é executado no início, e este é executado
sempre que o chamamos, eu poderia entrar na minha
atualização e eu poderia chamar MyMethod em
cada quadro. Então, na verdade, estes são o mesmo método
porque cada método, este é como,
Ok, legal esse. E é basicamente assim que
vamos usar seu código T2, nossos jogos. E então, dentro desses métodos, vamos escrever
o código real em si. Obviamente, não
nos
aprofundamos muito sobre o código real, qual código precisamos escrever. Mas saiba que a
maior parte do código vem da manipulação
dessas variáveis. Se eu for aqui, eu
poderia escrever meu eu mesmo, que é o objeto do jogo. Eu poderia ir ponto que
poderia se transformar, o que é basicamente como
transformar meu objeto. Ou em termos mais simples,
a posição, a rotação e a escala. Eu vou posição de ponto. Eu poderia ir igual. E então eu posso
defini-lo para um aleatório. Vou para o
novo vetor três, o que basicamente
significa que
vou armazenar três números. E eu disse para 000. Agora, o que está acontecendo é
que toda vez que eu chamo meu método, ele será enviado para o
transplante no centro. Então, obviamente, não
vou fazer
isso a cada quadro. Se eu for para Start, eu
poderia chamar MyMethod. Coloque parênteses para encolher
chamando o método. Se eu voltar ao Unity, minutos terminaram de recarregar
meus assemblies de script. E mudei meu
objeto de teste para lá. E eu me certifico de ter meu grupo de
interesses dessaturado. Posso excluir esse corpo rígido
porque não o estamos usando. E eu me apegei, então posso me
apressar e bater em jogo. E devemos
realmente ser capazes de
ver que no minuto em que
batemos o jogo, não conseguimos ver
nada no jogo porque obviamente
não há sprite para tocar. Podemos ver que realmente
ficamos centrados
no meio da coisa
porque esse método é chamado. Obviamente, isso pode parecer
um pouco confuso e intimidante porque estamos
usando um monte de coisas como oposição
transformada objetos de jogo
e corpos rígidos. Mas, desde que você
entenda que
as variáveis são as coisas que precisamos
manipular e os métodos, todos os lugares em que as
manipulamos, podemos chamar nossos próprios
métodos tudo o que temos esses dois pedra e
métodos que são chamados nos tempos
pré-determinados, uma vez que se reformulam ou
a coisa estrela. E então, basicamente, tudo o que
precisamos fazer é manipular
diferentes variáveis ou propriedades de nossos objetos para fazê-lo para que façamos
o código que queremos fazer. Então você praticamente entendeu tudo o que
queremos fazer. Como eu disse, esta
é apenas uma
introdução básica de como o
script funciona. No próximo vídeo,
onde
mostrarei como escrever roteiro de
movimentos básicos. Espero que você consiga ver esses conceitos com muito mais clareza e como
eles realmente funcionam. E, obviamente, em nosso grupo de
movimentos, se você pensar sobre isso, vamos querer
usar esse método de atualização para verificar quais fundos estão sendo pressionados. E então podemos usar
o método estrela, talvez apenas definir uma posição inicial sempre que o que será
abordado no próximo vídeo. Mas, desde que você tenha
entendido o esqueleto básico de como o roteiro funciona, você entendeu tudo
o que precisa para vê-lo
no próximo vídeo, onde
vamos nos
aprofundar na codificação e no bom trabalho.
8. Scripts de movimento: Ei lá e bem-vindo de
volta à unidade. No último episódio, fizemos uma breve introdução sobre como os
roteiros e a unidade funcionam. Mas neste episódio,
vamos criar nosso primeiro roteiro,
um roteiro de movimento para meu personagem de
jogador aqui, você está pegando a tela de visualização,
você deve ser capaz de ver, eu tenho uma cena bem
simples configuração. Eu tenho meu
objeto de jogador que só tem um sprite nele e
um sprite quadrado. E então, se eu
tiver minha câmera principal, eu só tenho uma colisão
na parte inferior que pode
funcionar como meu andar. Então, a primeira coisa que faço antes de
criar meu script é ter certeza de
que esse objeto se aplica. Estudantes de física. Vou aqui. Vamos adicionar componentes, e vou adicionar
um colisor de caixa 2D, que na verdade
vai
dar exatamente a minha cabeça assim. Perfeito. E a segunda coisa que vou
acrescentar é que vou adicionar um corpo rígido 2D também. Deixe todas essas configurações
praticamente iguais. Portanto, não precisa
mudar nada lá. Agora, se eu bater em jogo,
você deve ver que meu objeto cairá e parará
exatamente como um oriental. Agora, a próxima coisa que
vou fazer é criar meu script de
movimentos para esse objeto e permitir que o
jogador se mova para a esquerda e para a direita. E vou permitir que o
jogador pule também. Então, vou até aqui
para que os ativos vão clicar com o mouse em criar um script
C-sharp. E vou chamar
isso de um movimento. Vou
clicar duas vezes para abri-lo. E devemos ser capazes de ver uma coisa muito familiar
com base a bordo. Da última vez que temos minha
classe de uso e i2 vazios você
começaria? Na verdade,
vou
criar minhas variáveis. Então, como estou fazendo script de
movimento, primeiro vou
querer k variável para velocidade. Então, vou criar um
número inteiro e chamá-lo de velocidade. E então, na verdade, vou
querer outro inteiro, vou chamar
essa altura de salto. E, em terceiro lugar,
vou querer uma
referência rígida do corpo porque
vou mover meu
personagem com base
no corpo rígido é que vou
criar corpo rígido público RB. Agora, essas três coisas
vão
ser tudo o que preciso para criar
meu primeiro roteiro de movimento, o que é muito, muito legal. Então, vou aqui para o meu método de
atualização e vou
criar alguns controles com base no que eu quero que
meu jogador mova. Agora, primeiro, vou
fazer é definir minha velocidade ou meu
corpo rígido com base em se o personagem ou
o jogador prefere pressionar os botões esquerdo
ou direito
no teclado e
usá-lo na verdade, tem uma
coisa embutida muito legal para essa entrada. Dot obtenha acesso. Vou abrir colchetes, horizontais, cobertos
entre aspas. E isso realmente
vai me dar um flutuador a
cada quadro com
base no cada quadro com
base fato de eu estar pressionando para a
esquerda ou para a direita. E vou usar
isso para fazer meu roteiro. Então, do jeito que vou fazer
isso, vou fazer RB, que é o meu ponto rígido do corpo, e vou
mudar a velocidade. Lembre-se de que é um corpo rígido
dinâmico. Vou mudar minha
velocidade é igual a nova. Estou fazendo um novo vetor para o qual base
significa que vou usar dois valores diferentes. Vou abrir meus
colchetes e vou entrar ponto, obter acesso horizontal,
assim como fiz aqui. Vou colocar uma
vírgula entre eles. E então, para minha velocidade y, vou querer
mudar minha velocidade y, não com base no fato de eu estar
indo da esquerda para a direita. Então, na verdade, para fazer com que
isso permaneça inalterado, eu vou apenas para a velocidade do
ponto do RV ponto y. Agora eu fecho meus colchetes
e pressiono a coisa. Basicamente, o
que isso vai fazer é eu vou dizer a
cada quadro, vou definir minha velocidade ou meu corpo rígido para usar
dois valores diferentes. Primeiro, o ponto de entrada
get X é horizontal, que é basicamente
uma maneira extravagante de dizer um valor
que a unidade já determinou com base no fato de
eu estar pressionando as teclas esquerda ou direita e, em seguida, ponto
RB mais T Y. Este é obviamente um
recurso incorporado que basicamente diz, ok, se eu estiver pressionando a tecla
esquerda, faça com que seja menos uma. Se eu estiver pressionando a tecla
direita, torne-a uma, o que obviamente é muito
útil. Eu uso isso o tempo todo. E então nossa velocidade de radar. Mas por que isso está dizendo definir a velocidade para qualquer que seja
a velocidade, então não altere a
velocidade. Se eu for em frente e eu bater volta para Unity e
eles forem atingidos. Antes de fazer isso, vou
me certificar de que
realmente atribuí meu script aqui e arrasto meu
script de movimento até lá. E então vou
me certificar de arrastar meu corpo rígido para que eu saiba de qual corpo rígido
estou falando. Porque na verdade não estamos usando nenhuma dessas variáveis. Vou deixá-los,
eles
não farão diferença alguma. Se eu seguir em frente e clicar em Play, podemos ver que eu sigo
assim. Mas se eu pressionar para a esquerda ou para a direita, eu me movo muito lentamente para
a esquerda ou para a direita com
base na minha entrada, o que
é muito legal. Mas eu não quero estar me
movendo tão devagar. Quero me mover um pouco mais rápido. Então, vou voltar
ao meu script e na verdade,
vou multiplicar qualquer valor que este seja
pela minha variável de velocidade, o que é muito legal se
eu voltar para Unity agora, tenho certeza que muitos de vocês
serão capazes para prever que, uma vez que nossa
variável de velocidade está definida como 0, isso realmente vai
negar o que
acabei de fazer porque
toda vez que a vezes vezes vezes
por 0, em outras palavras, obtendo 0, eu não
vou me mover , mas, em vez disso, vou
mudar isso para um. Então, temos exatamente o que tivemos última vez que o tempo por um. Não, está mantendo
o mesmo número. Agora passamos para a mesma velocidade
exata. Mas se eu mudasse isso para algo até duas vezes mais rápido, você deveria ser capaz de ver
qualquer diferença perceptível, o que é muito legal. E a grande coisa sobre
essas variáveis no Unity, eu posso mudar isso
como gosto de imunidade. Vou fazer isso
cinco, por exemplo. Posso ver exatamente o quão rápido. Acho que é uma boa
velocidade para o meu primeiro manuscrito. Agora posso me mover para a esquerda ou para a direita. Tenha em mente que quaisquer
alterações que
eu fizer enquanto estou testando meu ganho
não serão transferidas. Então, quando eu clicar
nisso novamente, será a caixa de redefinição. Vou definir isso de volta
para cinco na minha coisa de velocidade. E agora toda vez que eu bater em Play, vou me mover
em escravo mais rápido, o que é muito legal. Essa é a parte básica dos meus
movimentos Script concluído. A única outra coisa que
precisamos adicionar é uma mecânica de salto, e vamos usar
nosso próprio vazio personalizado ou método para isso e ir até aqui e criar um vazio,
chamá-lo, encolhido. O código para essas vozes de salto que será
muito semelhante a isso. Mais uma vez,
vamos mudar a velocidade. Vá aqui, copie isso
e coloque-o de volta. E em vez de fazer
deste o eixo de entrada, vou realmente fazer disso o ponto da velocidade do ponto RB x. em outras palavras, não altere minha
velocidade x quando eu pular. Em vez disso, defina minha velocidade y para um valor direto e vou definir esse valor para saltar a altura. Então, a maneira como isso
vai funcionar é que vai para cada quadro. Vou definir a velocidade do
meu ponto RB para qualquer que meu eixo horizontal. Em outras palavras, se eu estiver
pressionando da esquerda para a direita, defina a velocidade
nessa base em ir da esquerda para a direita e não
altere meu valor y. E toda
vez que estou pulando, não altere meu valor x, mas defina meu valor y para uma velocidade direta sobre a minha
altura de salto é. Então, obviamente, esse
garoto não está sendo resfriado. Ele, você pode ver que ele
tem 0 referências, o que significa que esse método não é realmente
chamado de tudo. Então, eu quero chamar esse método
lixo toda
vez que o jogador
pressionar a tecla de espaço. Vou fazer isso
porque vou usar uma corrente de entrada. Vou se for uma declaração if. Então, em outras palavras,
se isso for verdade, execute o código abaixo dele. Ponto de entrada, desça a tecla. Vou abrir colchetes
e espaço de ponto do código de chave direito. Então, por baixo disso,
vou dizer salto, porque é apenas uma linha que eu
posso escrever diretamente por baixo. Se eu quisesse uma declaração
if maior, usaria colchetes encaracolados e , em seguida, tudo abaixo
disso seria executado. Mas como é apenas um,
estou usando apenas uma linha. E isso basicamente significa que toda vez
pressione a barra de espaço. Vou executar esse código. Agora, se eu voltar para Unity, certeza que muitos de vocês serão
novamente capazes de proteger porque eu vou pular para 0
não vai fazer nada. Você pode ver se eu
voltar para o Unity e eu
bati na barra de espaço,
nada acontece, não porque não estamos
fazendo nada, mas porque
não
dissemos a velocidade, podemos realmente ver
se eu voltar aqui, eu o parei de x. estou definindo minha velocidade
é 0 e foi negativo. Então você pode realmente
vê-lo lá. Mas dominós, se eu definir isso
para algo como cinco, podemos ver agora quando eu
pressiono a barra de espaço, eu posso realmente pular. E esse é o grupo de
movimentos básicos que
fizemos completo. Acho que desde que eu disse que
não há limite para saltar, posso quadruplicar ou
até quíntuplo saltar e voltar para Unity e redefinir isso para
algo como sete. Certifique-se de que está salvo
porque estou fora do modo de reprodução e
volto para o modo de reprodução. E agora podemos ver nosso roteiro de
movimento em ação, o que eu acho muito, muito legal para o nosso primeiro roteiro de sempre. Agora, esse tropo básico, que literalmente
conseguimos usando apenas o que, quatro linhas e
três variáveis é tudo o que vamos
precisar para o básico do nosso script de movimento. Obviamente, se você quiser fazer um grupo Moody's um pouco mais
complicado, que eu vou
editar rapidamente. Vamos querer lá
apenas para saltar quando o jogador realmente
tocar o chão. E vamos usar um método
completamente novo, que é novo para nós. Na verdade, é chamado
pela UT, não por nós. Então, vou descer aqui. Sou o direito de anular. Então vou digitar as
palavras em colisão entre 2D. Em outras palavras, toda
vez que eu entro em uma colisão, você pode se lembrar de que
adicionamos um colisor de caixa ao nosso jogador e um colide com carros alegóricos
toda vez que eles tocarem Isso vai ser acionado. Vou até aqui
e vou dizer Crie um novo
booleano em cima aqui. E vou chamar
isso no chão. E toda vez que
eu entrei em uma colisão,
em outras palavras, toda vez que eu pousar, vou dizer que
no chão é igual a verdade. E então, da mesma forma,
sou o direito anular na saída de colisão 2D. Em outras palavras, quando
eu sair do chão, vou colocar na caixa marrom. Então a última coisa que
vamos fazer é aqui na minha declaração de
saltos, vou escrever
outra declaração if. Vou dizer que se
no chão for igual a verdade, então só vou
querer pular. Nem me lembro de dois sinais de
igual porque é
assim que você escreve declarações if. E basicamente o que
ele vai fazer agora é que toda vez
que eu
entrei no chão, eu vou colocar
em terreno, verdade. Em outras palavras, se eu
chamar a coisa do salto, vai funcionar. Toda vez que um local,
não vai funcionar. Vamos para a Unity. Podemos ver devemos ter
uma variável em terra aqui que poderá nos
ajudar a acompanhar isso nos
testes de nossos jogos. Podemos ver agora que é falso porque
aprendemos, é verdade. E se eu pular agora, ele será definido como
falso e depois verdadeiro. Agora, se eu pressionar o
botão de espaço várias vezes, ele só vai
funcionar quando eu estiver no chão,
o que
é muito legal. Este é quase na verdade um roteiro de movimento
completo. E com a adição
de alguns métodos extras, podemos realmente programar lógica em nosso jogo
pela primeira vez. Obviamente, com a adição
de nossa variável no solo, agora
podemos verificar se os jogadores no chão e
se eles podem pular. E este é, na verdade, um
bom script
de saltos pela primeira vez. Como eu disse, você pode pular no chão e somente
quando estiver no chão. E tudo funciona
perfeitamente bem, o que é muito legal. Você pode ver com essas linhas
simples de código, nós realmente criamos um
bom script de saltos
ou script em movimento. E isso nos permite
mover nossa
brincadeira e pular quando estiver
no chão. Espero que tudo tenha feito
muito sentido. E se não acontecer, você pode
simplesmente assistir novamente ao vídeo. Obviamente vou
rever esses conceitos. Eles devem ficar mais familiarizados
à medida que codificamos mais no Unity. Mas todos são ótimos
trabalhos no roteiro. Se você copiou junto, dê algum tempo para
anotar tudo isso. Agora, se você usar
exatamente os mesmos componentes, lembrei do corpo
rígido e
do colisor de caixa e
copiei do colisor de caixa e esse código exatamente
como está na tela. Você deve ter um
código funcionando e espero
que tenha entendido como esse
código funciona muito basicamente, com a variável de velocidade sendo o que estamos
multiplicando isso apenas definindo-o para um
fator diferente, a altura do salto. Da mesma forma, apenas definimos
a velocidade diretamente e , em seguida, essa coisa no chão para verificar no chão
usando uma instrução if. Se eu estiver no chão,
então você pode pular. Caso contrário, ele não
executará esse código. E é basicamente
assim que o código funciona. Espero
que isso faça sentido. E verei você no
próximo vídeo, onde vamos obter mais em codificação no Unity.
9. Scripts ativos: Ei lá, e bem-vindo de
volta à Unity. E então, no último episódio,
criamos nosso
primeiro roteiro e roteiro de
movimento muito lá fora para
mover para a esquerda e para a direita
e pular para cima e para baixo, o que é muito legal. Mas neste episódio
vamos fazer um pouco mais de
uma visão geral sobre
scripts ativos em geral, um ato de roteiros
é uma cidade recusada,
usada para se referir a
scripts que são usados ativamente em um jogo. Então, apenas scripts de movimento estão atacando scripts,
coisas assim. Obviamente, você também pode
ter scripts passivos, como scripts que
estão agindo como, tudo bem, se isso acontecer,
então sofrer danos. Você terá um
script passivo, por exemplo, em um inimigo que diria que
se eu colidir com algo, sofrer dano, mas você
terá um script ativo
e um jogador que diz, se eu pressionar este botão atacar. E hoje
vamos nos concentrar
no antigo ato de scripts e programar esse objeto blob
para ter duas habilidades. Um deles vai
mudar o estado de animação em que está e o outro vai
imprimir coisas. E, obviamente, depois disso, vou
aprofundar um pouco mais sobre como você pode usar o script
desses atores para criar
habilidades usando colliders. Mas vamos começar com coisas
mais simples. Então, vou aqui,
clique com o botão direito do mouse e vou criar um script C-sharp. Agora eu chamo esse roteiro de ator. E antes de esquecer,
vou ao meu blog e
vou adicionar esse ato
de script ao meu blob, para que
isso seja adicionado ao objeto. Em seguida, vou
clicar duas vezes e abri-lo no Visual Studio. Agora, porque este é
um ato de script, obviamente vamos
programar principalmente usando esses métodos. Enquanto o
script passivo se concentraria mais em verificar se as coisas
estavam sendo feitas. Então, por exemplo, caí para
torná-lo roteiro passivo para
garantir que eu sofra dano, eu poderia ter algumas
roupas como com crédito anteriormente que diz em
colisão entrar em 2D. E então, se eu colidir
essa coisa específica, tomar dano e escrever
código para fazer isso. Mas como estou
focando em um script mais ativo, vou criar
meu próprio método e esses métodos serão
usados para fazer isso nos dois sentidos. Em primeiro lugar, eu quero
criar
será chamado de impressão vazia. E isso simplesmente vai
imprimir olá no console. Agora o que vou fazer é
que vou atualizar. E vou escrever outra coisa de entrada
sem fio que
usamos para editá-la e dizer que se o ponto de entrada obter a tecla para baixo, vou abrir colchetes
e usar a mesma coisa que o espaço de pontos focados em grupo
e código. Então vou querer
chamar meu script de impressão. E, na verdade, é muito semelhante
ao que fizemos antes. Este é um exemplo
de que estamos dando esse personagem e habilidade toda vez que você pressiona
a barra de espaço, vamos imprimir
essa coisa aqui. Vou voltar aqui. E vou ao meu blob, e vou clicar em Jogar. E então toda vez
que pressiono a barra de espaço, devemos ser capazes de
ver no console, olá é impresso, o que
é muito, muito legal. Agora, obviamente, esta não é
a avidez mais emocionante. Então, vamos adicionar
outra coisa em que
vou mostrar como
usar esses scripts ativos, assim como
falaremos mais cedo com
a animação. Lembre-se se você se lembrar de alguns
episódios atrás, estávamos fazendo animação e tínhamos esses
parâmetros e
eu lhe disse, vou aprofundar um pouco mais
sobre como você pode mudar isso
usando scripts. Usaremos um princípio
muito semelhante para usá-lo como se você
voltasse ao seu script. Em vez de ter uma impressão Boyd, farei mais dois vazios. Vou chamar isso de animação
de desaceleração. Vou chamar
isso de animação. Então tudo o que vou fazer é entrar nesses
vazios e vou definir
o parâmetro que criei para fazer a transição entre
as animações para o que eu quero. Então, se você se lembra de
alguns episódios atrás, tivemos essas transições
com base em ambos os tempos. E então criamos esse
parâmetro falso e temos
as condições, mas configuramos assim. Vou mostrar
como definir esse mesmo parâmetro usando o código. Então, se formos aqui,
podemos ver que os parâmetros
desse animador são rápidos
no momento. Esse é o único. Então, primeiro tenho que criar uma
referência à animada. E, obviamente, vamos
usar uma variável para fazê-lo. Mas até o topo. E vou digitar em público. E pode ser alto
e chamá-lo de anime. E então aqui, bem,
eu vou fazer é ir
e vou definir pontos Bu, significados definir um parâmetro em sua coisa do
tipo booleano, assim como nós temos. E vou definir
meu capítulo de parâmetro, ir aqui e encontrar o nome. Chama-se rápido e coloca isso
nessas aspas. Rápido. E eu quero configurá-lo para a caixa
verdadeira porque vou diminuir a
animação. Então aqui neste ponto, vamos fazer
exatamente o oposto, defini-lo. Agora, tudo o que precisamos fazer é chamar esses vazios quando coisas
específicas acontecem, sou uma cópia dessa instrução de
entrada, mas em vez de usar a barra
de espaço, use duas chaves diferentes. Vou até aqui e
vou escrever se o
ponto de entrada obter keydown
e código ponto um. E vou usar alfa-1, que é a única tecla na
parte superior do teclado. E então vou chamar
minha animação de vazio lento. E se eu fizer o número dois, vou fazer minha animação
acelerada. Agora você deve ser capaz de ver
se você volta para o Unity. Primeiro, basta atribuir meu animador rapidamente
arrastando-os para lá. E então, se clicarmos em
Play, podemos ver que estamos começando com a animação lenta. E se eu tivesse que entrar
na animação rápida e depois voltar para a animação lenta. Podemos realmente ver
isso no animador se eu for seguir em
frente e arrastar
isso aqui para baixo, então está
na ponta lateral de madeira. Eu tenho um. Obviamente, estou lentamente motivado para
que isso se torne verdade. E então eu tenho que fomentar e
posso mudar isso
no entanto, eu por favor. E isso pode
estar um pouco confuso
quanto ao motivo pelo qual estou focando em coisas tão
arbitrárias como impressão e animação. Mas esse é o básico
de como você
criará scripts de habilidade
ou scripts ativos. Porque se você pensar sobre
isso, se você quiser fazer um roteiro de ataque
e eu vou aprofundar um pouco mais sobre isso
no final deste vídeo. Obviamente, vamos
querer fazer isso chamando um vazio específico. Quando uma tecla é
pressionada, eu criava meu roteiro e
chamava isso de habilidades. E digamos que eu queira dar ao meu personagem três habilidades. Eu programaria para
três chaves diferentes. Eu chamaria diferentes quadros, e então eu só preciso de um passivo
do programa aqui. E, obviamente,
dependendo se uma
das habilidades
talvez pulasse, obviamente
passamos por cima
disso com corpos
rígidos, você
apenas daria um salto. E se uma das
outras habilidades talvez
estivesse avançando, poderíamos fazer a mesma coisa
com a velocidade rígida do corpo. Nós teríamos que definir
a velocidade, o x para algo muito alto. E então eu vou, Neil,
pauso a tela. Então, obviamente, esses
são os conceitos básicos de como vamos fazer
nossos scripts ativos em unidade. E é assim que você deve programar o script se
quiser dar habilidades ao seu
jogador. Obviamente, existem formas
alternativas de fazê-lo. Você pode dar certas
habilidades acontecendo quando você colide com coisas
e coisas assim. Mas, na verdade, eles
iriam focar mais no próximo episódio, que será roteiros
passivos, em vez de quando
iniciarmos as coisas, temos que reagir às
coisas que acontecem conosco. Este será o plano
básico como você constrói o ato de
scripts e unidade. E acho que é uma maneira muito
boa de fazer isso. Você simplesmente tem
motivos pelos quais você chama seus métodos. Então você tem seus
métodos e você pode fazer com que sua mensagem faça coisas
completamente diferentes. E isso realmente deve permitir que
você faça muito no Unity. A última coisa que
faremos é
mostrar rapidamente como isso
pode ser aplicado para criar uma UT de script de
ataque muito simples. Então, vou
aqui de volta ao meu jogo, e vou fazer minha tag
e script usando colliders. Então, se eu for aqui ao meu blob, vou adicionar um colisor de
círculo, muito semelhante ao slide de
caixa 2D que tínhamos anteriormente. É só que este é
um círculo e,
na verdade, vou
torná-lo bem grande e na
frente de uma bolha assim. Então, a segunda coisa que
eu faria, vou criar um novo sprite e
vamos Criar um sprite de objeto 2D. Vou fazer apenas um quadrado. inimigo mais legal. Então mondrian tinha
pontos de tamanho e eu vou adicionar um colisor de caixa ao meu inimigo. E, na verdade, vou
fazer deste um gatilho para que, quando
eu entrar
nele, ele dispara, ele não atue
como uma colisão real. Então o que vou
fazer é
dizer quando eu colocar uma chave específica, se esses dois estiverem
colidindo, em outras palavras, se o inimigo estiver ao alcance, então eu vou querer
acionar algo. Vou mostrar
basicamente como fazer isso agora. Vou só
ir para cá. A primeira coisa que
faço, obviamente, preciso fazer algum tipo
de coisa acontecer quando eles
colidem e estamos anulando eventos de colisão. Este sempre
estará no gatilho em 2D em vez
de em colisão. Isso é só porque
estou usando um gatilho em vez de um colisor normal. E então eu vou
ter uma variável aqui em cima. Vou
chamá-lo de alcance booleano. Vou definir minha variável de
intervalo como true. Então, obviamente, vou
querer defini-lo como falso. Quando eu deixar isso
no trigger exit 2D, vou definir minha variável
enfurecida como false. E depois de ter
feito essas duas coisas, a última coisa que preciso fazer é em vez de ter
esse printf vazio, eu realmente vou
substituir isso. Vou chamar esse ataque. E então aqui,
vou mudar o nome, supervisionar algum ponto
o garoto certo. E então eu vou ter
uma simples declaração if e dizer que se estou enfurecido, outras palavras, se eu tiver colidido com meu
gatilho, que é o inimigo, estávamos fazendo com que ele abra
colchetes no alcance igual a verdadeiro. Então eu vou imprimir. Vou esmagar
a palavra atingida. Espero
que isso nos mostre exatamente como isso funciona em unidade. E então, se eu
voltar para Unity, a última coisa que preciso
fazer é uma maneira de mover o jogador em alcance e Outbrain para que eu possa
realmente fazê-lo. Então eu entro e saio do quarto. Então eu vou fazer isso
usando simplesmente adicionando um corpo rígido aos meus
jogadores para que eu possa arrastá-lo e depois ter
caído na coisa, alguém apenas vai adicionar meus componentes 2D de corpo
rígido, sair tudo o resto como está. Vou me certificar de que tenho
meu andar na minha câmera principal. E então, se eu for em frente
e eu realmente apertar Play, podemos ver que se
eu cair assim, vou parar e então eu bati na barra de espaço e
nada acontece. No entanto, se eu fosse arrastá-lo
para cá e cair, então eu não estou
tocando no jogo de beisebol. Podemos ver
que terei essa variável kid obviamente sendo atingida Implantação do
Comando, obviamente sendo colocada
no log de pontos de depuração, o que
é muito, muito legal. Esta é obviamente
uma maneira muito simples de mostrar um roteiro de ataque. E se tivéssemos o roteiro de
movimento que fizemos anteriormente
no episódio anterior, poderíamos obviamente manter
isso e haverá muito mais fácil de mover sem ter que
arrastar o editor. E se combinarmos
esses dois roteiros e script
lunar que fizemos anteriormente
e esse roteiro de ataque, teremos o básico para
algum tipo de jogo de luta. Obviamente, precisamos adicionar mais alguns efeitos,
como
em vez de apenas imprimir o
hit, teríamos que dizer,
ok, talvez armazenar
alguma variável
no inimigo chamada Saúde e
depois subtrair esse valor. Obviamente, essa
seria uma boa
maneira de rastrear a saúde dos inimigos
e fazer um jogo real. Espero que isso mostre
o plano básico de como esses scripts ativos
podem ajudá-lo
quando você está criando um
gosto amargo por seus personagens. No próximo episódio,
vamos
criar scrubs passivos de forma semelhante a este, na verdade, onde
podemos acompanhar a
saúde com o inimigo. E então, em vez
de realmente fazer algo que o inimigo reage
às coisas acontecendo, o que obviamente vou aprofundar no próximo vídeo. Mas espero que você tenha gostado
deste e tudo tenha feito um sentido oco e eu te
vejo no próximo vídeo.
10. Scripts passivos: Ei lá e bem-vindo de
volta à unidade. Esta será a segunda
lei do vídeo de script, onde vamos
rever roteiros passivos. Obviamente, no vídeo anterior, analisamos esse ato de
roteiro no qual analisamos o blueprint como você pode criar habilidades para
seus personagens. E a maneira básica de
programar essas habilidades. Neste episódio, vamos
rever scripts passivos, ou como você pode programar reações a essas
habilidades por personagens, especificamente para
inimigos ou objetos, qualquer coisa desse tipo,
até mesmo a peça em si, se eles são atacados por
um inimigo, por exemplo. Agora, o conceito principal que
vamos precisar passar
para criar
essa relação entre dois objetos
e como eles reagem
uns aos outros é referenciar scripts de um script para outro. Antes que eu possa começar a mostrar
como fazer isso, vou mostrar
algumas alterações
rápidas feitas desde o último vídeo, adicionei um script de
movimentos muito básico ao nosso personagem de jogador permite que eles para avançar e para trás. E você pode ver que
em ação aqui, se eu for em frente e apertar Play, agora
posso
avançar e retroceder. E isso obviamente
ilustra a coisa do engate, um pouco mais fácil do que da última vez, o que é bonito, muito legal. Eu vou fazer neste
episódio é fazer esse inimigo reagir a ser atingido. No entanto, vou mostrar
exatamente como faço isso. Primeiro vou começar
criando um script C-sharp, chamá-lo de script passivo. E então vou
clicar duas vezes. E vou excluir
os dois primeiros métodos, o método start e
o superior, os renunciados deixando-os é porque este é um script
passivo. Vai ser
baseado em coisas que reagem a ele, não criando
coisas acontecendo, ou reagindo a eventos nos jogos realmente como
começar ou cada quadro, ele vai reagir a
coisas acontecerem em o jogo, como se fosse atacado. Então, vou criar
um vazio público e vou
chamá-lo de sofrer dano. A maneira como esse garoto
vai trabalhar é quando esse ponto for chamado, vou sofrer danos. Vou ter uma
variável em cima aqui, int e chamá-la de dano. E vou ficar
danificado menos igual a um. Qual caso se o Tim estiver danificado é
igual a danificado menos um. É muito legal. Então eu vou,
Aqui está meu roteiro ativo. E vou dizer
aqui para o meu hit de impressão, na verdade não
quero dizer impresso. Eu queria chamar isso de vazio, mas esse vazio faz parte de scripts
completamente diferentes. Ou como vou chamar
esse garoto do roteiro, você pode ver se eu sofro dano. Não faz ideia do que
estou falando. Ele diz que não existe
no contexto atual, ou seja, nesta classe atual, mas ela existe nessa
classe. Então, como os vinculamos? Vamos usar uma variável. Então eu estou indo até
aqui até o topo e
na verdade é muito fácil.
Vou a público. Vou escrever o
nome do meu roteiro, roteiro passivo, chamá-lo de passivo. E então aqui, em vez
de dizer que tome dano, vou escrever a palavra passada como minha variável é chamada ponto. E então eu realmente
tenho uma lista
de todos os componentes públicos
neste grupo. Então você pode ver aqui
que eu tenho um dano int público e um vazio público sofre dano. Então eu só preciso escurecer. Danos na fita. Você pode
ver que está pronto com ele. Posso chamá-lo
como qualquer outro método. E tudo o que preciso fazer para que isso funcione é que preciso
voltar ao meu jogo. Eu, isso garante que eu
atribuí um
script para o outro. Então deixe-me primeiro ir em frente e adicionar meu
roteiro passivo ao meu inimigo. Então tudo o que
preciso fazer é ir ao meu blog. E aqui onde
diz roteiro passivo, preciso arrastar meu
inimigo porque eles têm o roteiro passado e você pode
ver que realmente funciona bem. Agora, se eu for para o meu
inimigo e eu fizer meu dano começar às dez. Ou saúde em vez de se eu
jogar o jogo como Não mais, você pode ver quando eu for atingido,
ele vai para baixo, para baixo, para baixo. E se eu me afastar,
ele não vai cair. E isso é muito legal
porque esse é, na verdade o básico de como podemos fazer com que
um sistema de saúde funcione. Obviamente, podemos melhorar
isso um pouco. Poderíamos fazer alguma animação
em que sofremos danos. Então, vamos mostrar como isso
ficaria rapidamente. Se eu for animação pública, vou criar uma animação
inimiga
na qualidade ociosa. E isso já existe em ambas as bochechas,
os antigos são para ociosos. Na verdade, isso só vai ser uma animação
em branco e
vai acontecer porque é a animação
normal eu não quero
reproduzir o tempo todo. Vou traçar
uma animação infantil. A animação Hit só terá uma mudança de cor do vermelho e voltará para o branco. E assim ficou assim. Talvez faça isso um pouco rápido. Só recebo metade do tempo. E isso é um
bom efeito de dica em mente livro, tudo o que eu
preciso fazer agora é fazer essas transições sobre as quais
estávamos falando anteriormente entre o
ocioso para e os sucessos. Então, o que vou fazer é criar um novo parâmetro. Vou chamar isso de gatilho e curiosidades. É como um botão. Se você consegue pensar
em um booleano como um switch ou gatilhos
como Ok aconteceu quando eu chamo o
parâmetro chamado Hit. A maneira como vai
funcionar, assim como fizemos antes com o booleano, onde
nos estabelecemos como verdadeiro ou falso. Este gatilho acabamos de dizer, ok, funciona e depois trabalharemos uma vez
e depois não funcionaremos novamente. O que é perfeito para nós
porque queremos que isso aconteça quando eu for em frente e
chamar essa coisa de quadril. Então, toda vez que eu chamo
esse parâmetro hip, ele mudará
para esse estado. Obviamente, desabilitou o tempo de saída e faça esta
transição duração 0. E então aqui
queremos basear um tempo de saída porque
assim que terminarmos nossa animação, queremos voltar
para a outra. Então, vou mudar isso. Não tem condições lá. E espero que isso
seja um pouco mais familiar porque
todo o episódio de animação, estamos usando um
parâmetro para chegar lá, mas usamos a transição normal baseada em tempo
para sair dela. Bem, isso vai parecer
que tudo o preciso fazer agora é
ter certeza de que eu chamo esse
parâmetro no script inimigo. Vou aqui, criar um animador público, assim
como fizemos da última vez. E então aqui embaixo
vou adicionar alguns pontos. Trigger, vou
chamar o gatilho acertos. Agora isso vai fazer
toda vez que eu receber dano, ele vai definir essa coisa de
sucesso e vai fazer com que ela vá para a animação Hit e, em seguida, faça a transição de volta quando eles
atingirem a animação estiver concluída. Esta é apenas uma representação
visual bem legal do que já fizemos, só para que fique um pouco mais claro. Então eu quero arrastar o meu
e o MH de volta para cá. Eu poderia fazer o mesmo
fazendo isso. Agora, o que devemos ver se começarmos o
jogo não acontece. Mas no minuto em que eu sofro
dano, podemos ver, eu realmente posso ver um
efeito visual disso acontecendo. Você pode ver que
no animador para se eu arrastá-lo para cá, você pode ver que eu tenho que
bater e depois voltar. E isso
realmente é muito legal porque isso nos mostra exatamente como faríamos um script de saúde ainda
mais legal. Você pode ver meu danificado e
eu vou entrar em números negativos, o que obviamente não
gostaríamos seu roteiro de saúde normal. Mas espero que isso
lhe dê uma ideia melhor de
como esses
scripts passivos devem funcionar. Obviamente, esse
roteiro passivo depende de nós
chamarmos esse vazio
de outro vazio, o que é uma coisa bem legal que só fizemos
neste episódio. Mas também poderíamos ter uma
coisa semelhante com, por exemplo, de laranja para sofrer
dano total ou eles são anulados na colisão entrar em 2D, assim como fizemos da última vez e chamamos meu dano de tomada
por isso a partir daí. Então tudo o que preciso fazer é
realmente voltar ao meu jogo. E então eu preciso arrastar esse
jogador até o topo. Vou desabilitar isso para não
seja nenhum outro gatilho para que detecção de
colisão
aconteça e , em seguida, adicione um corpo rígido para que
ele caia no chão. Agora, o que acontecerá? Você deve ser capaz de ver no minuto em que
caímos no chão, na verdade vamos
sofrer dano de queda
como qualquer outro jogo, o que
é muito, muito legal. Esse é outro exemplo de um script
passivo porque estamos usando eventos acontecendo fora do nosso controle e
reagindo a esses eventos. A maneira como este funciona é
simplesmente chamando esse vazio. Então, espero que você tenha uma compreensão um pouco
melhor
dos planos que estavam usando para criar os scripts
para nossos jogos. Ato de scripts, obviamente, você pode não entender exatamente todas as linhas
de código aqui, mas isso é
muito fácil de pegar quando você apenas programa
cada vez mais no Unity. Obviamente, tentei
usar conceitos que
farão muito mais sentido e
explicarão os que fizemos, como animadores e simplesmente usando outros scripts ou corpos
rígidos, por exemplo. Mas se você quiser
fazer coisas um pouco mais complicadas, como controladores de
personagens, coisas assim, que você deve ser capaz de
aprender com bastante facilidade. Então você não precisa
se preocupar muito. Se tudo isso parecer um
pouco intimidante, ficará mais fácil
quanto mais você fizer isso. O que eu quero
passar é, na verdade,
na minha opinião, muito mais valioso para saber. Simples blueprint que usamos para criar os scripts que
agem de scripts que são baseados em métodos que estamos chamando base em coisas que acontecem com nosso usuário e os scripts
passivos baseados em scripts em métodos que estamos
chamando com base em coisas que têm um ambiente
ocular. E espero que se
você acompanhar é tudo o que
fizemos neste vídeo, isso fará muito sentido e
você será capaz de aplicar
esse conhecimento aos seus próprios jogos quando você
os fizer ponte de todos, o roteiro final e
o
vídeo estarão no próximo, onde vamos
simplesmente analisar rapidamente como salvar valores para que você
possa
garantir que o progresso dos seus jogos seja salvo, pois na verdade é realmente um coisa muito simples de se fazer. Mas tudo deveria
ter
feito sentido para você e eu te
vejo no próximo vídeo.
11. Salvar dados: Ei lá e bem-vindo de
volta à unidade. Neste vídeo,
mostraremos rapidamente como economizar valores e unidade e
recuperá-los para a próxima vez
que você jogar seu jogo. Obviamente, essa é
uma habilidade muito útil para ter em sua caixa de ferramentas. E espero que você tenha adquirido
alguns desses até
agora com esses vídeos. E você tem uma melhor
compreensão de como tudo
no editor Unity funciona em conjunto. Mas neste vídeo
vamos adicionar mais
uma coisa simples
e é
rapidamente como salvar
coisas no Unity. E vamos fazer tudo
isso dentro de um script C-sharp. Então, primeiro vou fazer é ir
clicar com o botão direito do mouse e
criaremos um script C-sharp
chamado de salvamento. E vou abrir
o roteiro agora mesmo. E então você só precisa criar uma variável que deseja salvar. Então, eu quero salvar um
número inteiro na chamada public int e chamá-lo de valor. Então tudo o que preciso fazer
é, na verdade, preciso ter um vazio toda
vez que eu quero salvá-lo, preciso chamar esse
vazio agora que vejo. Ok, salve-o então. E então eu vou
querer outro garoto quando eu quiser recuperá-lo. Então, vou querer
recuperá-lo durante o vazio da equipe, mas quero salvá-lo
durante minha própria voz. Vou fazer
uma voz, chamá-lo de
salvar isso obviamente um método. E então eu vou
chamar esse método toda vez que eles
pressionarem a barra de espaço. Então, se a tecla de entrada para baixo espaço de ponto do
código de chave, então eu vou
querer chamar o cofre. E espero que isso
funcione perfeitamente. Agora, tudo o que preciso fazer, e essa é a única linha de código necessária
para salvar um valor. Vou ir para o jogador
prefs dot set int. E este jogador
prefs é basicamente maneira muito simples do
Unity de salvar o jogo uma preferência
entre as sessões do jogo. Ele diz que pode armazenar cordas, flutuadores ou números inteiros.
Portanto, tenha isso em mente. Você não pode armazenar valores corporais obviamente
rígidos, ou mesmo, você não pode
nem armazenar booleanos, mas você pode ter uma loja os três tipos de dados que
foram listados lá, flutuadores, números inteiros e strings, o que é muito legal
porque você pode realmente usá-los para salvar
praticamente qualquer coisa. Vou usar as configurações de ponto
prefs do jogador. E,
antes de tudo, vou precisar
criar um nome para
o que eu quero salvá-lo. Vou chamar
isso de um valor. E então eu
vou ter que
inserir um valor que
queira dizer que é obviamente meu valor
será minha variável de valor. Então a única coisa que
precisamos fazer agora e eu quero isso é que vou voltar a começar. Vou dizer valor. Então, a variável
que eu quero dizer, oh, eu salvei é igual a, e depois reproduzir um material de preparação, obtê-lo e, em seguida, valor. Mais uma vez. Isso pode ser um pouco
confuso porque usei o mesmo
nome todas as vezes. Vou mudar
isso para o valor local. Então, as coisas podem ser um pouco
mais fáceis de diferenciar. Portanto, obviamente,
o valor local é a variável que você deseja salvar. E então toda vez
que pressionamos a barra de espaço, vamos salvar esse
valor em outro arquivo com nome de código ou valor de chave
no computador em algum lugar. Então, quando
clicarmos em iniciar, vamos
recuperar esse valor pelos mesmos sabores de obter valor, e esse é
o valor local. E essa é uma maneira muito boa
de economizar para jogos móveis. Existem outras formas de economizar. Por exemplo, se
você estiver criando especificamente para desktop, pode
haver uma maneira um pouco
mais completa de salvar, mas quando você começa no YouTube, isso pode funcionar perfeitamente bem como um bom método de salvar
seus dados no Unity. Agora, se tudo isso
funcionar perfeitamente, você deve ver quando eu
entrar no meu jogo, bem, não muito de um jogo, mas na minha cena e ir para
minha câmera principal. É a única coisa que tenho
na cena e quero adicionar esse script de salvamento arrastando para
baixo. E agora eu só tenho minha variável de valor
local. E toda vez que eu
salvo, vou querer recuperá-lo. Então, vou definir isso
para algo como 0. Obviamente, não vou
mudá-lo no editor agora, mas isso não vai
demonstrar nada. Então eu erronei isso
para dez, por exemplo. Agora vá em frente e
coloque este beisebol e isso realmente
vai salvá-lo. Vou fechar
o editor Unity. Agora você pode ver que ele está definido como 0. Mas se eu parar o jogo novamente, ele deve realmente ser definido para dez porque foi o que
dissemos da última vez. E você pode ver mesmo se eu disse algo totalmente
diferente no editor,
como, por exemplo, 50, e isso deve
substituir o modo de reprodução. Agora podemos ver quando começamos o jogo é como
eu realmente defini para dez porque ele está sendo
redefinido para o que salvamos como. Essas são, na verdade, todas as
linhas de código que você precisa. Se você quiser salvar
algo, você deve ter um bom jogador prefs dot set int, uma chave desejada e o
valor de tentar salvar. E então você precisa
atribuir esse valor, que você vê quando
inicia o jogo ao que
quiser armazenar. Obviamente, geralmente você quer que esses dois sejam a mesma
coisa se você quiser salvar o mesmo valor e
colocá-lo de volta na mesma variável, então obviamente vai
querer usar a mesma coisa. Mas, por exemplo, se
eu tivesse uma pontuação alta, posso salvar minha variável escolar e então eu posso
configurá-la, salvá-la lá. E então toda vez que
começo o jogo de novo, quero tratar minha escola. O ensino médio é que, basicamente,
é o básico
da poupança e da unidade. Essas são todas as linhas
de código que você precisa. E espero que essa seja
outra habilidade legal que o ajude a
fazer seus jogos. No próximo vídeo, vamos começar
com o design de som
e, na verdade,
abordamos o básico de como os roteiros eram comunitários. Agora, como resultado disso, espero que você tenha aprendido algumas ferramentas
legais para usar em unidade, e espero
que isso o ajude muito quando você estiver fazendo
seus próprios jogos. Se há algumas coisas que ainda podem parecer
um pouco embaçadas, como especificamente quais são os prefs
do jogador. Você só se preocupa
demais com isso porque, como eu disse, este curso é apenas sobre
o básico da unidade. Tudo o que você precisa estar obtendo é uma compreensão básica de como todas essas coisas
funcionam juntas. E eu prometo a você
que vai tornar aprendizado de coisas extras em cima disso muito mais fácil quando você entender
esses fundamentos. E espero que, sim,
há outra ferramenta para adicionar e você entendeu
tudo no vídeo. Vejo você no
próximo vídeo, onde
ficamos assim no design de som. E obrigado por assistir.
12. Projeto de som: Ei lá e seja bem-vindo de
volta à Unity. E nos últimos episódios enfraquecem cobrindo
muitos dos conceitos básicos, mas passamos os últimos
quatro na unidade de scripts. Felizmente, no entanto,
passar por isso para fazer algo um pouco
mais emocionante, e vamos
trabalhar no design de som, que é uma das partes
mais legais da unidade, na minha opinião, como permite que você adicione muita vida, seus jogos. Então, se você quiser olhar antes de você, eu tenho uma
cena muito chata com
praticamente nada nela. A única coisa que tenho
é essa câmera principal, que não tem nada de
importância, altitude e esse objeto sonoro
onde eu criei, que tem um
monte de componentes, mas todos estão desativados. Eu os adicionei porque esses são os quatro componentes em que
vamos focar quando passarmos
por cima do design de som UT, que é o tópico
do vídeo de hoje. Antes de eu começar
com o primeiro componente, que é a Fonte de Áudio, primeiro
vou reproduzir o som
com o qual vamos trabalhar para que você possa ouvi-lo sem
qualquer edição. Vou clicar duas vezes
no som que
baixei de sites
livres de direitos autorais. E parece assim. Você pode ver que é um desses efeitos de morte
retrô de videogames antigos. Agora, a maneira como usamos
o som e o UT é primeiro usando um componente de fonte de
áudio. Você pode encontrar isso simplesmente
clicando Adicionar componente e ele
é o inferior. Se você pesquisar áudio, ao abri-lo,
você será recebido com o
seguinte layout. Você pode ter um
clipe de áudio que ainda não terá nada atribuído
a ele, uma saída e, em seguida, um
monte de configurações diferentes. Agora, na maior parte, muitos deles são bem mais altos e você só
trabalharia com eles. Por exemplo, essas configurações de som
3D aqui são obviamente bastante complicadas e você
não se preocupa
muito com elas em nosso ambiente 2D. Eles são úteis se
você estiver planejando aprofundar um pouco mais
com seu design de som. Mas como esse é
o básico do Unity, não
vou
entrar demais em algumas dessas configurações. Só vou me concentrar
no primeiro é que
você precisa se preocupar. Se você for aqui
e puder ver este clipe de áudio atualmente não tem nada
atribuído a ele. Vou arrastar meu ativo, que joguei
há um segundo, efeito sonoro antigo. E se eu começar meu jogo, você pode ver porque
eu joguei em acordado verificado e verificado loop, o que não é verificado por padrão, mas eu verifiquei para
o propósito deste vídeo. Só preciso habilitá-lo. E então, se eu bater em play, você poderá ouvir o
som repetidamente, assim. Agora, obviamente, essa é a principal característica
dessa fonte de áudio, é quem age como um dispositivo
para reproduzir sons. E há algumas coisas
importantes que você precisa observar aqui. Em primeiro lugar, é o volume, o que obviamente é
muito autoexplicativo. Você pode alterar o volume
com base no que quiser. Vou ir em frente e bater o jogo, e então vou
mostrar como todas essas configurações diferentes
afetam uma coisa pois estamos em plaquetas e
atingimos volume ligeiramente menor
para que eu possa falar sobre isso. Vou recusar isso
ainda mais. E agora você deve ser
capaz de ouvir tanto eu
quanto o som que
tem muito melhor. Agora, a primeira coisa em que
vou focar é o mudo, que vou tomar agora só poder falar sobre a coisa. O mudo é ineficaz.
Envie o volume para 0. Ambos
são exatamente a mesma coisa, mas eu só vou tomar
o mudo por enquanto para poder falar antes
de tocar o som. Agora, esse tom afeta tanto a velocidade do
som quanto seu tom. Em outras palavras, quão alta
ou baixa é a nota, e também quão rápido ou lento. Vou te mostrar como isso
parece em um segundo. Obviamente, simplesmente
alterando esse valor e depois ajustando o volume
ligeiramente para que possamos ouvi-lo. Você pode ver que há uma diferença muito drástica no som. E, na verdade, muitas vezes gosto de
usar meu tom mudando. É algo como
0,9 abrandar minhas músicas para fazê-las soar
um pouco diferentes. Você pode até usar isso e
repetir a mesma música e novamente, várias vezes apenas mudando o tom ligeiramente para que
pareça um pouco
mais interessante. Agora, fora dessas
todas essas configurações, essas são as principais
e você está preocupado com o clipe de áudio é que o
som está sendo reproduzido, o mudo liga e desliga esse
som. prioridade também afeta a
importância do som. Você só se preocupa demais com
isso, apenas se você tiver vários
sons tocando de uma só vez. Você quer definir alta prioridade
para aqueles que são mais importantes e baixa prioridade para aqueles que
são menos importantes. E o volume, obviamente, passamos
por cima, bem como pitch e depois pan estéreo e
mistura de zona espacial e reverb. Não vamos nos
preocupar com as configurações de som 3D demais , pois essas são todas bastante complicadas apenas para os
conceitos básicos do design de som. A próxima coisa que vamos
rever, no entanto, é o filtro de distorção de áudio. E isso realmente funciona
como um filtro de distorção, como você deve ter adivinhado sobre como armazenar que
queremos que nosso som seja reproduzido. Em primeiro lugar, vou fazer
é definir o
volume backup 0.5 para que você possa ouvi-lo e certificar-se de que o muco
desligado, Jogue, acordado está ligado. Em outras palavras, pare de
jogar assim que
parei de jogar o
jogo e o lúpus. E assim podemos ouvir repetidamente agora no
nível de semi-distorção para 0. Então eu posso mostrar
exatamente o que
parece à medida que aumentamos. Agora vou aumentar
todo o caminho, mas vou diminuir
o volume, pois isso pode ser incrivelmente alto quando a
fobia social for máxima. Obviamente, não é o recurso
mais útil e você realmente não
quer usar para classificar e filtrar essa
altura, a menos que você esteja tentando fazer algum
tipo de jogo cômico. Mas esse é basicamente
o filtro de distorção. Você sempre pode usar isso novamente para afetar o som
que você está reproduzindo. E da mesma forma, as
microfilarias são um
pouco menos óbvias
e muito mais úteis porque você pode
realmente usar isso para ter
efeitos de ambiente legal em seu jogo. Se seguirmos em frente e nos
certivermos de que meu mudo desligado e todas as minhas
configurações e de volta. Vou seguir em frente
e mostrar como
esse filtro de eco
soa no jogo. Obviamente, você não quer muito essa
camada e pode afetar esse atraso
e a taxa de decaimento, que obviamente
afetará o som do eco. Vou mostrar exatamente
o que
parece quando alterarmos isso. Se eu apertar play agora, tende a atrasar a anotação. Obviamente, com dez, é
quase imperceptível. E se eu defini-lo ao máximo, é uma cópia muito óbvia
que é muito, muito tarde. Podemos ver, na verdade,
se eu mudo o som, ele continua por um tempo,
então a taxa de decaimento é semelhante, pois se
eu recusar, você pode ver o efeito agora. Minha perna e então, se eu a aumentar, isso afeta a rapidez com
que o
som decai ao longo do tempo. Em outras palavras, quão rápido ele
morre por baixo deles, você realmente não
precisa se preocupar
muito com a mistura seca e a mistura úmida pois elas afetam
quantos anos você tem passado para um dispositivo de saída. Então isso é muito, como eu disse, não é muito importante
para a comunidade. Mas tudo o que você sabe é
que o atraso está apoiado. Como os atrasos e
a decadência afetam, a rapidez com que o ecoo desaparece. Depois de passar esses
dois, distorção e eco, você pode realmente fazer
alguns efeitos
sonoros bem legais em seus videogames. Mas o mais importante e
mais impressionante do que ambos. Os outros dois são realmente
esse filtro de reverberação, que muda todas essas coisas,
todas essas diferentes salas
de nível seco, sala, HF, LLF, tempo de
decaimento, todos os tipos de coisas
diferentes que
afetam o som. E você pode realmente usar
predefinições para defini-las para você. Se você disse ao usuário, isso
é como o modo manual. E posso mudar
isso quem eu quiser. Ou você pode usar um
monte de predefinições diferentes Unity realmente criou para você dar efeitos
diferentes. Por exemplo, tenha uma sala de estar oferecendo uma célula acolchoada. Vou passar por
alguns desses efeitos e eu realmente
recomendo que você use esses efeitos quando começar essa imunidade. Se você não sabe o que são todas
essas coisas diferentes, eu gosto de usar esses efeitos
como eles realmente são. Acho, na minha opinião, bastante úteis e muito efeitos
bastante úteis e muito
bons para
ter em seus jogos. Mas se você for em frente
e bater o jogo, eu vou te mostrar como eu os
faria funcionar. Certifique-se de que o filtro
de reverberação de áudio esteja definido como ativado para que você possa
realmente ouvir os efeitos. E eu o desliguei por
enquanto, então
não ouviremos nenhum som. E célula acolchoada. Você pode ter sido uma
pequena diferença, mas não é muito óbvio. Vou então
virar para o quarto. Um leve eco lá
como você pode aqui. Mas se você for para os
mais óbvios, temos aqueles como
drogas subaquáticas e psicóticos, que são muito óbvios se
eu mudar para debaixo d'água, você está aqui agora,
psicótico e drogado. Agora, obviamente, eles têm muitos aplicativos
legais em seus jogos. Por exemplo, se você
quisesse ilustrar cair por algum
tipo de portal, você poderia usar o efeito psicótico
ou droga, ou mesmo subaquático
até certo ponto, esses grandes criam realmente
efeitos legais para seus jogos. E com esses três componentes
básicos, obviamente há mais alguns compostos de
áudio aqui, como o filtro de núcleos de áudio e os filtros passa-baixa e
passa-alta dele. Em termos básicos,
esses três vão te levar em muitos efeitos
legais diferentes que você precisa, especialmente o reverb
para seus jogos. Você não
precisa de muito mais. Se você também pode ajustar
esses controles de tom e volume para obter
os sons desejados, que é muito, muito legal. O último que quero mostrar
é como realmente usar essas todas as suas fontes para
tocar sons quando você quer, não apenas acordado, em loop. Então eu geralmente acho que o plano acordado alaúde é
um bom ambiente se você quer música porque
você quer que a música esteja
sempre tocando e
você quer estar em loop. Mas já que isso não é música nem algo que queremos estar
sempre pagando ou fazendo loop. Vou desligar as duas
configurações. E então, se eu for em frente
e eu apertar Play it, nós não vamos
ouvir o som porque
não há plano acordado definido. Então, na verdade, eu tenho que chamar
o som de um script e depois ir em frente e criar um
novo script chamado som. E então aqui,
sob meu começo Boyd, vou simplesmente
chamar o som da reprodução. Primeiro de tudo,
vou criar
uma fonte de áudio pública,
que funcionará como
minha fonte que funcionará como de
áudio de formato variável notochord. Como se importe se você o
nomear AIS
assim, são palavras reservadas e certifique-se de adicionar uma maiúscula F. Eu vou apenas
ir a um médico. E isso é o mesmo
que dizer: Ok, toque meu som uma vez. E devemos ser capazes de ver que, se simplesmente
adicionarmos esse script ao nosso objeto de som
arrastando e atribuindo a fonte de
áudio ali, poderemos
ver isso em ação. O som deve tocar
assim que pararmos. No entanto, não entrará em loop, pois definimos isso como false. Mas, obviamente, se você
quiser que ele faça loop, basta marcar essa caixa. Espero que isso lhe dê um pouco
de uma compreensão de como áudio pode ser usado em unidade
para aprimorar seus jogos. Eu não recomendaria o uso excessivo desses filtros no início porque eles podem fazer seu jogo parecer um pouco oh, dramático. E isso não é algo
que você necessariamente queira ter com o
jogo, especialmente na Índia. No entanto, eles não são recursos
incrivelmente úteis e,
se usados no momento certo podem tornar seu jogo muito mais imersivo. Obviamente em termos
de sons reais. Para obter os sons,
existem muitos sites
ótimos, como
misturá-lo online, que
permitem que você obtenha sons
livres
de royalties da internet que
você pode usar em seus jogos. E foi aí que
consegui este aqui. Então, espero que você possa
baixar alguns sons novos e experimentar como esses
sensores de áudio funcionam em unidade. Mas fonte de áudio e esses três campos como eu
mostrei como usar. E, obviamente, você
pode simplesmente ligar
a partir dos scripts criando uma
referência à sua fonte de áudio. E, em seguida, basta chamar esse método de reprodução que
fará o clipe de som. Espero que isso lhe dê uma melhor visão geral
do som em unidade. E verei você
no próximo vídeo em que
começaremos com outro
recurso de feedback legal, sistemas de partículas. Vejo você no próximo vídeo.
13. Efeitos de partícula: Ei lá, e bem-vindo de
volta à unidade. Nos últimos vídeos, especialmente com nossos vídeos de
animação, design de som e spray, mostramos algumas maneiras de mostrar
visualmente o feedback
sobre a peça. Especificamente, até agora um exemplo em que
estávamos mostrando a
detecção de acertos e
mudamos
a cor do quadrado de vermelho para branco. Esse foi um ótimo exemplo
de feedback para o jogador. E o feedback é uma parte
incrivelmente importante do design do jogo, pois ajuda
o jogador a se sentir engajado. Uma das melhores maneiras de
adicionar feedback a um jogo é usando
um efeito de partícula. E vou
mostrar a vocês exatamente como imunidade dos efeitos de
partículas funciona, pois acho que eles
são uma unidade, são ferramentas mais úteis e versáteis para
exibir partículas,
explosões, animações de
coleta ou qualquer coisa do tipo. Você pode até usá-los para
algo como chuva ou neve. Agora, para começar,
tenho uma cena em branco com um objeto vazio que criei
chamado efeito de partícula, que não tem absolutamente
nenhum componente. O único componente
que vou adicionar
para este tutorial é simplesmente um sistema de partículas
que você pode encontrar
digitando partícula e você a
encontrará ali. Você pode vê-los e
eu só clico nisso. De repente, quadrados cor-de-rosa sendo
emitidos do centro
sem sinais de parar
e tudo
acontecendo por cerca de cinco segundos,
pessoas, eles desapareceriam. E esse não é o efeito de partícula
exato. Quero, quero
criar uma explosão, e isso não
parece uma explosão. Então, vou seguir em frente e mostrar
exatamente como mudar todas as coisas que você
precisa mudar para fazer um efeito de
partícula de explosão. Como acho que este é um dos mais comuns que
as pessoas querem fazer. Um dos que eu uso
com mais frequência, pois você pode usar isso se quiser
fazer uma explosão ou coletar animação, ou mesmo uma animação de salto
quando você deixa partículas para trás
depois de um salto duplo, algo assim. Todos eles são muito
semelhantes e
usarão conceitos e ferramentas muito semelhantes. No
efeito de partícula. Vamos usar todos os menus a seguir. Obviamente, o
efeito de partícula, emissão, forma, vamos usar
cor ao longo da vida, tamanho de uma vida e ruído. Também usaremos animação de folha de
textura para garantir que estamos
animando o sprite certo. Todos os outros, incluindo esses sobre velocidade, esses sobre rotação, tamanho e cor por velocidade, colisões, gatilhos, luzes, trilhas
e dados personalizados são efeitos muito legais e muito útil
no sistema político. Mas com esses que
eu selecionei, você pode criar uma grande variedade de efeitos de partículas
incrivelmente legais e você não precisa
usar nenhum dos outros. E isso, na verdade
, torna muito mais simples. Então, usando apenas esses
sete menus diferentes, você pode realmente criar toda uma
variedade de efeitos de partículas. Nunca precisei
ficar mais joelhos e fiz
alguns reflexos parcialmente. Então, se você pode dominar
esses, você deve ficar bem. Antes de começarmos,
vou desligar
esse ruído para que minhas partículas não
estejam se movendo tanto. Vou transformar meu tamanho ao longo da vida de volta ao
topo para que pareça normal. E isso é tudo o que
vou fazer por enquanto. Não se preocupe com o que eu fiz. Vou explicar tudo à medida que
passar pelo vídeo. A primeira coisa que eu quero
fazer é ter certeza de que estamos animando o sprite
certo porque neste momento este quadrado rosa é realmente a
textura padrão que o unix usa, porque eu não atribui
uma textura para ainda. Então, vou
até o meu renderizador, e vou seguir em
frente e escolher Sprites Default como meu material. Podemos ver agora que estamos
usando quadrados brancos porque esses sprites padrão. Mas eu quero usar meu próprio sprite
personalizado na verdade. E muitas vezes
acho que as pessoas querem fazer isso tão bem na Texture
Sheet Animation. Certifique-se de verificá-lo. Se não estiver marcado,
clique nele e selecione o
modo a ser sprites. Depois disso, basta arrastar sua coluna
cervical para lá como o sprite selecionado
e agora você será animado com um sprite
de sua escolha. Estou usando um círculo, mas você
pode usar o que quiser. Acho que as formas
geralmente funcionam melhor. Triângulos, círculos ou quadrados, mas você quer animar
com outra coisa. Depende completamente de você. Vou parar
meu sistema de partículas,
então, na verdade, veja o que está acontecendo. E vou
explicar cada uma dessas propriedades
a seguir. Aqueles que vamos
usar de qualquer maneira no sistema de partículas e
como vamos usá-los? Então, já que estamos fazendo
um efeito de explosão, obviamente todas as coisas que
vou mudar, você vai ser
centrado nisso,
mas vou explicar como
cada um funciona para mas vou explicar como
cada um funciona você
seja capaz de mude para
o que você quiser fazer. Agora, começando com a duração, duração refere-se a quanto tempo o sistema de partículas
emite partículas. Obviamente, eu queria estar em loop. Então, nunca havia terminado. Mas se eu for em frente
e desmarcar o loop, podemos ver que agora isso
continua por cinco segundos, o que é bastante tempo, especialmente para um efeito de
partícula. E então ele vai parar. E esse é o fim
do efeito de partícula. Mas porque eu quero
fazer uma explosão, quero fazer isso algo
muito menor como 0,4. Obviamente, como eu expliquei, loop é referido se o espelho continua em loop ou não. E então começar a colocar
refere-se a se eu quero atrasar para que o sistema de
partículas comece, o que
significa que eu não
inicio a vida útil refere-se a quanto tempo as partículas estão vivas antes de se dissipar. Então isso é obviamente cinco segundos e então
eles vão desaparecer. Eles saem da tela
porque é muito longo, mas eu não quero isso porque
estou fazendo explosões. Vou fazer isso
algo como 1 segundo. Você pode ver tudo em 1 segundo
e depois eles desaparecem. Começar a velocidade refere-se à
rapidez com que eles só começam a se mover. Acho que cinco é bem decente, mas quero fazer o meu algo
como seis só porque eu quero que eles sejam bastante rápidos
porque uma explosão. E, em seguida, o tamanho inicial refere-se a quão grandes eles são
quando estão começando. Você também pode definir um tamanho inicial
3D se
quiser que os
valores X e Y e Z sejam diferentes. Mas como eu não,
vou usar o tamanho padrão
normal. Eu disse que
é algo como 0,4. Em seguida, comece a rotação.
Obviamente, não é importante para mim
porque estou usando círculos, mas se você quiser
girar suas coisas, você pode fazer assim. Ou, se você quiser, obviamente, você também pode usar a rotação de
estrelas 3D e você pode alterar cada um dos aspectos de forma diferente. Depois disso, temos uma
rotação de flip que fará algumas partículas sejam viradas e giram
na outra direção, é basicamente como uma coisa
aleatória. Então temos a cor inicial. Obviamente, não
quero ter uma grande explosão porque acho que a maioria das explosões ,
vermelho
ou laranja ou algo vai fazer minha
cor inicial algo assim. E podemos ver agora nossas
partículas estão todas vermelhas, na verdade vão
torná-las amarelas porque eu sinto que isso ficará
melhor no final. E agora podemos ver que temos uma explosão amarela,
o que é bem legal. Então, obviamente, o
modificador de gravidade se refere a onde você quer que seja a gravidade e
faça isso algo como 0,2. Então você pode ver
isso um pouco. Mas, obviamente, se você
enviou este analito cinco, você pode vê-lo muito claramente
porque eu faço uma explosão. Não vou ficar muito
preocupado com isso. Vou defini-lo para 0,1. Em seguida, o espaço de simulação local ou mundo
basicamente
se refere se eu quero que as
partículas sejam afetadas pelo
espaço local ou pelo espaço mundial. Em outras palavras, se eu estiver movendo esse efeito de partícula
e eu disse para
o local, as partículas serão emitidas com
base em onde a partícula
desce. Vou te mostrar exatamente
o que isso parece. Se eu fizer a bisbilhotagem, vá em frente e aperte Play. Podemos ver agora que as partículas estão sendo emitidas do meu espaço. E se eu fosse mover isso,
partículas, mover-se com ele. Em outras palavras, eles
não parecem leis muito normais da física. No entanto, se eu mudar
isso para o mundo, você pode ver que quando eu o movo, as partículas realmente permanecem
exatamente onde estão. E obviamente eu uso o mundo com
bastante frequência porque
acho que é muito útil, especialmente se você criar
um efeito emissor como um foguete subindo para o espaço
ou algo assim. Mas para o propósito
deste vídeo, porque não
vou me mover na AMD porque
é uma explosão. Vou usar o local. Em seguida, a
velocidade das simulações refere-se à
rapidez com que o sistema de partículas
basicamente toca tudo. Documentos, edite a ferramenta se
você for muito mais rápido e se eu configurá-lo para algo como
0,45, será muito mais lento. Vou deixar
isso de volta para um só porque não
quero mudar nada. Depois disso. As próximas coisas
são as mais úteis. Vamos pular o
delta, o tempo e o
humor de escala porque eles não são
incrivelmente úteis. Play on awake refere-se apenas se eu quero
o sistema do parque, mas começo quando eu
começo, o que eu faço. Depois disso, você
não precisa se preocupar
muito com a equipe de perda
emissiva ou com uma ação aleatória de chamada de
ação de parada de semente ou modo de buffer de toque. E então a última coisa
são partículas de massa, o que é basicamente
dizer, ok, se eu tiver que muitas partículas
pararam de fazer outras, o que é bom para o desempenho, vou deixar
isso em um mil. Então, aqui,
temos emissão, que basicamente
se refere à rapidez minhas partículas estão sendo emitidas e quantas estão sendo emitidas. Vou ir em frente e desligar loop porque
vou voltar para torná-lo meu efeito de explosão, porque estou fazendo uma explosão. Não quero que
seja algo como um pouco mais parecido com um 100. Podemos ver agora que temos um monte de partículas
saindo de
uma só vez . Não preciso de
um pouco mais. De repente, eles recebem 150. E acho que isso
parece certo. Você pode ver lá
escravidão de fato, por gravidade, podemos até
fazer parecer 200. Ficará muito melhor
quando realmente
usarmos o
sistema de partículas corretamente. Mas isso é basicamente
o que a emissão se refere a
quantas partículas são feitas ao longo do tempo. Você não precisa se preocupar muito com a taxa
sobre a distância, porque isso é basicamente
baseado na distância e não no tempo. Obviamente, estou usando o tempo
e a maioria das pessoas geralmente, o
tempo é o recurso mais
usado altamente, se você quiser fazer
algo como um emissor, você também pode usar a taxa
ou a distância. Depois disso, temos
a forma e isso se refere à forma a partir da qual as partículas
estão sendo emitidas. Então podemos ver agora mesmo
se eu clicar em Reiniciar, você pode ver
claramente que está sendo emitido
do círculo menor e
para o círculo grande. E isso porque é um cone. Se eu fosse mudar isso
algo como uma esfera, você pode ver que
é bem semelhante. Mas se eu mudar
para algo como um donut, será bem diferente. Eles vão entrar e sair. Obviamente, você pode
brincar com eles. São todos bem
autoexplicativos. Eu evitaria
aqueles como malhas, Mesh Renderer são
os que estão
focados naqueles muito úteis ou esfera, que obviamente é
apenas uma esfera normal, hemisfério, que
é muito semelhante. Então temos cone, que é o que tínhamos originalmente. E, novamente, é muito parecido. Esses três você pode usar
de forma intercambiável. No entanto, eu recomendaria usar esfera ou hemisfério
em vez de atual, pois acho que é um pouco menos
intensivo no computador. E depois disso,
você também pode usar a caixa, mas não é a mais
útil para meus propósitos. Seguindo todos os outros. O único outro
que acho super
útil é o círculo, que na verdade é o
mais simples de todos na minha opinião. E eu realmente ia
usar isso para meus propósitos. E então Edge, que
obviamente é emitido de uma única linha. Você também pode
se concentrar no retângulo, que é semelhante à caixa. Claro que é uma
colheita retangular, pode mudar essa posição ou escala de x para ser um pouco
mais assim. E então podemos ver que
temos um retângulo. Agora, vou usar um círculo
como mencionei anteriormente. Então vou seguir em frente e
mudar minha escala de volta. Nesta escala, na verdade, refere-se a aumentar o que estou emitindo. Então, vou alterar a
escala de x e y de 0,4. Portanto, é muito pequeno,
na verdade, até 0,2 vai ficar bem. Vou manter o z em um só porque
realmente não faz diferença. E nós veríamos todas as minhas
partículas agora sendo emitidas do mesmo pote,
o que é bonito, muito legal. Depois disso, também podemos alterar a propagação, que não
será muito perceptível
minha porque se refere a quanto
dessas partículas estão
espalhadas e essas configurações do tórax
serão mudar com base na forma
que você
obviamente selecionou. O raio também
afeta o tamanho. Eu poderia
reduzir isso e, em seguida,
todos eles seriam emitidos
do mesmo lugar, mas você não pode realmente usá-lo
na escala,
não é muito diferente. E a espessura do raio
também é bastante útil, pois você pode ampliar e ver como isso muda a
forma com a qual estamos trabalhando. Se eu movê-lo assim, podemos mudar exatamente
qual parte do raio, quão grosso é o raio
em torno dele. No entanto, vou
manter isso em 0 porque acho que, para meus propósitos, isso
funcionará melhor. Depois disso, temos um modo. Podemos fazer aleatório ou loop, caso em
que ele vai fazer um
loop em torno de ping pong, que vai avançar
e depois voltar para os latinos por enquanto. Mas se eu
ativasse o modo de loop, você veria exatamente
como isso parece. Obviamente, estes não
serão muito úteis para meus propósitos, mas também podemos ter uma
propagação de explosão onde tudo está espalhado simultaneamente ao
mesmo tempo. Mas, obviamente, vou usar
aleatoriamente, já que quero ter uma explosão e as explosões
são aleatórias por sua natureza. Então, vou reiniciar e
isso vai explodir. E todas as outras configurações
por aqui são semi-úteis. Você pode usar isso para alterar
a posição do emissor, se quiser, ou a
rotação de x ou y ou z. Obviamente, se eu
girá-lo pelo z, isso não fará
diferença para um círculo. Mas se você estivesse usando
algo como uma caixa, você, será muito
mais perceptível. E então, aqui, a
montagem das linhas alinhará as partículas com base em sua direção
original de viagem. A aleatoriedade da direção
substituirá qualquer
direção que esteja atualmente e meio randomizada um pouco e
verá se eu aumentar isso. Parece um pouco
mais de vida de explosão, mas eu não quero isso. Quero que o meu seja
bastante simplista. E então a direção dos esferoides. Da mesma forma, se você passar o mouse
sobre ele, você pode ver que diz que substitui a
direção inicial da viagem com a direção que
projeta partículas fora do centro
da transformação de forma. Então, obviamente, isso é muito
parecido com o que temos agora, se eu clicar em Reiniciar
mesa de madeira
e definir para 0, e quando estiver definido para o
máximo, é muito semelhante. Você não pode ver a diferença. Portanto, esse não é o maior e
mais útil recurso para nós, mas pode ser útil com
base no fato de você usá-lo. Você pode simplesmente brincar
e ver o que parece. Depois dessa
posição aleatória obviamente,
será aleatorizar de
onde as partículas começam. Se eu virar para cima, você deve ser capaz de ver
isso um pouco mais claramente, mas eu não quero isso,
então eu coloquei o meu de volta para 0. Agora, obviamente,
mudamos três coisas até agora. Alteramos o efeito de
partícula, que são apenas as
partículas básicas e o emissor, as configurações básicas,
a emissão, quantas partículas existem e a forma em que as partículas
estão sendo emitido de. Mas ainda não parece
uma explosão muito boa. São
bolhas amarelas conscientes sendo disparadas. Então, precisamos adicionar mais
algumas coisas para que pareça um pouco melhor. A primeira coisa que
vamos fazer é ir para
essa cor ao longo da vida. E se clicarmos nisso,
podemos realmente fazê-lo. Portanto, é mais um gradiente. Se você clicar
nessas partes inferiores, poderá alterar a cor. E se você
clicar nestes principais, você pode mudar o escritório. Quero definir isso
para 0 no final. Em outras palavras,
no final da vida, ele estará desaparecendo
completamente. Então, parece
isso, que parece muito mais explosão
como na minha opinião. Mas também vou mudá-lo
para ter um pouco mais de
intenção vermelha no final. E você pode ver como
isso parece aqui, o que parece muito
legal na minha opinião, parece uma
explosão desaparecendo. Na verdade, vou
aumentar isso um pouco mais para que você possa ver os efeitos um pouco mais exagerados, bonitos,
bem legais. Agora, depois disso, quero fazer uma coisa semelhante com o
tamanho de uma vida. Lembre-se, nós mudamos esse gráfico, mas na verdade é uma coisa muito
simples mudou. Basta clicar em seu gráfico e agora você pode escolher entre vários gráficos pré-determinados ou
pré-selecionados. Ou você pode fazer o seu
próprio simplesmente adicionando pontos e
depois movendo-os. Mas para meus propósitos, esse gráfico aqui se encaixa muito
bem como uma explosão legal. Eu também poderia ter usado este, o que eu acho
bem legal também, ou mesmo este. Embora isso possa ser
um pouco dramático demais, mas vou ficar
com o meu aqui pois acho que esse é um efeito de exposição bastante
decente. Depois disso, podemos adicionar
ruído e ruído que você pode pensar como uma
turbulência para as partículas. Vou mostrar exatamente o
que isso parece se eu
ativar meu efeito de loop novamente,
então ele está sempre tocando. E então vou aumentar a força do
meu ruído. Você pode ver as partículas
começarem a tremer e girar um pouco, que é exatamente o que queremos. Há um monte
de configurações aqui. Eles ficam um
pouco complicados. Por exemplo, se você
olhar para a pré-visualização aqui, parece um pouco com
o ruído Perlin. Você aumenta a frequência. É meio que quão nervoso o
parque foi perguntado se eu o
levasse para o máximo de artigos
são como tremer. E se eu virar para 0,
lá, obviamente mal se movendo. Mas vou
transformá-lo em algo assim. E você pode ver que
a partícula é boa. Eu disse para 0 que,
na verdade, sobrepor sua velocidade é
baseado no ruído. Então não é isso que
queremos. Também. Vire de cabeça para baixo. Você pode ver como isso o altera. Se eu disse algo
como 0,5, por exemplo, podemos ver que temos partículas
bastante agitadas, mas elas são bastante lisas. E então a
velocidade de rolagem basicamente vai rolar
pelo ruído. E assim as partículas
vão mudar mudar e
mudar à medida que vão. Em seguida, habilitar ou desabilitar, amortecer permite ou desabilita
o fato de que
a força do ruído é proporcional à frequência do
ruído e oitavas, criaremos várias
camadas de ruído, essa camada sobre a
outra para criar um ruído final. Tudo isso pode parecer
um pouco complicado. Você pode pensar
nisso como camadas de ruído. Turbulência que
faz com que a partícula seja agitada dessa certa maneira. Você não precisa se preocupar
muito com o resto
dos outros. Obviamente, a qualidade
afetará o ruído na verdade. E qual é a qualidade
desse ruído. Obviamente, transformá-lo em 3D fará o
barulho que eu queria. Mas, na verdade, não vou
usar isso demais. Vou usá-lo um pouco na minha coisa se eu
desligar o looping pode ver que é um pouco mais de
explosão assim. Eu só não quero que seja
com muita frequência em uma curva para baixo
a frequência um pouco. E então espero que isso
pareça um pouco melhor. Está um pouco baixo demais agora. Vou recusar a
força também. E isso parece muito legal. Talvez diminua a força
um pouco mais para que eles não estejam tremendo
demais no final. E acho que isso
parece certo. Agora, depois disso, praticamente
fizemos tudo o que
podemos para fazer nosso efeito de
explosão. Mas podemos ver que ainda
não acharia que é muito brilhante, então vou fazer
algumas mudanças finais. A primeira coisa que vou
fazer é
voltar a aumentar o tamanho inicial para ver se volto para um que seja um
pouco caricatura demais. Então eu farei meu
algo como 0,7. E espero que isso
pareça um pouco melhor. Também vou querer
aleatorizar o tamanho inicial. Em vez disso, eu posso realmente
subir aqui e
posso clicar aleatoriamente
entre duas constantes. Vou escolher meu
entre 0,40,7. Agora você pode ver que temos um
pouco mais de variação, o que é bem legal. E vou deixar a cor do
meu estoque um
pouco mais escura para que você possa
vê-la assim. Parece um pouco mais
explosão na minha opinião, backup
alternativo minúsculo. E depois disso, quero aumentar
a emissão lentamente então talvez sejam 300 partículas. Parece um pouco
mais realista. Então a última coisa que vou
fazer é que vou baixar
a vida um
pouco para algo como 0,8. E eu tentei aumentar o tamanho
inicial um pouco de 0,6 para 0,9. Acho que é um
efeito de partícula bastante convincente para uma explosão. Se formos em frente e colocarmos o jogo aqui embaixo
e
apertarmos Restart, podemos ver como ele parece ganho. Acho que parece tudo bem. É um pouco pixelado. Nós ampliamos agora, mas
se eu for em frente e eu configurá-lo para que ele jogue acordado e depois eu bater em
jogo, você será capaz de
vê-lo em plena ação. Um pouco congelado lá. Então deixe-me tentar jogar
mais uma vez. Você deve ser capaz de ver
pelo menos brevemente a partícula, ok, bem, está
tremendo um pouco, mas se você pode
ver isso no editor, acho que é um efeito de partícula bastante
decente. E as ferramentas que
usamos neste tutorial são na verdade, duas que
você pode usar para criar efeitos de
partículas
completamente diferentes. Como por exemplo, se
você quiser criar chuva, mostrarei tudo o que você
precisa fazer para mudar isso. Primeiro de tudo, precisamos mudar nossa forma para ser
algo como uma vantagem. Então, tudo é emitido
do mesmo lugar. E quero aumentar a
escala da minha vantagem. Então, é algo assim. Então eu vou realmente girar a rotação assim, é exatamente 180 ou melhor,
menos 180 graus. Ou eu posso realmente
apenas escrever 180, não faz nenhuma diferença
e saídas e descer, então tudo o que
preciso fazer é ativar o loop. Vou transformar a cor do
meu traço algo como azul claro. Vou virar minha cor ao longo da
vida ao invés de ler, vou para
um azul ainda mais escuro. Então eu vou olhar, não parece
muito com alcance. Eu vou diminuir
a balança sempre tão pouco começar considerável, na verdade, desculpe. Vai ser de 0.20.3 C. Vou desligar meu ruído completamente, então é um
pouco mais reto. E então, em um turno,
minha frequência para 500. E sim,
não é a melhor chuva, mas você pode ver meio
que parece chuva. Obviamente, ainda
existem esferas, então não é o mais
convincente se eu virar acima para o topo
da tela e virar minha forma para cima para que seja escalas
um pouco mais altas, está
indo até o fim. Você vê que parece um
pouco convincente. Se eu aumentar a vida para ser de dois segundos
em vez de 0,8, podemos ver a
chuva caindo. Quero dizer, como eu disse,
obviamente não é o melhor efeito, mas você pode dizer como é
fácil mudar
essas coisas ao redor. E você realmente não
precisa usar nenhum
dos outros recursos
do efeito
de partícula além daqueles que
mostramos aqui. Obviamente, o principal e
, em seguida, a forma de emissão você definitivamente
precisará de cor
e tamanho da vida. Acho incrivelmente útil, especialmente alterando
esses componentes alfa para que eles possam desaparecer. E depois dessa
animação sensível, você pode se lembrar do
renderizador para
garantir que sua RAM renderize
seus sprites e usando seus picos reais em vez da textura
padrão predeterminada. E usando essas ferramentas, você deve ser capaz de criar alguns efeitos de
partículas bem legais. Espero que isso faça
muito sentido, e espero que você possa usar
isso em seus jogos para fazer muito mais feedback para
seus jogadores fazerem um jogo muito mais envolvente, o que é realmente, muito legal. Então, espero que você goste. Vejo você no próximo
vídeo. Obrigado por assistir.
14. Interface do usuário: Ei lá, e bem-vindo de
volta à unidade. Agora, nos últimos vídeos, abordamos muitos
dos conceitos de unidade,
mas há uma coisa que
temos negligenciado até agora,
e isso é interface de usuário ou interface de usuário. Sempre que você joga um jogo, há quase
todos os jogos lá fora têm algum tipo de menu
ou componente de interface do usuário. Na verdade, eu saio para dizer, praticamente todos os
jogos lá fora têm isso. Quando você não tem
o jogo, o enorme botão de jogo
grande no meio, todas as configurações, tudo isso. são compostos
de componentes de interface do usuário e o Unity tem uma ótima
ferramenta para adicioná-los. Vou explicar
essa ferramenta,
este vídeo e
mostrar três formas ou
três componentes em vez
da interface do usuário e unidade, que irão ilustrar exatamente como isso vai funcionar ou como a interface do usuário no
Unity funciona de forma geral. Então, para começar, vou aqui,
vou clicar com o botão direito do mouse. Vou criar os sapatos de um
proprietário aqui, uma interface do usuário. Agora, o primeiro que vou
fazer é criar uma tela. Porque se eu criar uma tela, isso realmente me permite. Não posso simplesmente colocar
elementos da interface do usuário em qualquer lugar. Eles precisam estar
dentro do Canvas. Na verdade, se eu fosse
criar um elemento de interface do usuário, você pode ver que ele cria
automaticamente uma tela e um
sistema de eventos para mim automaticamente. Mas porque para o
propósito deste tutorial, vou criar
tudo manualmente. Então, vou para Create UI. Vou criar uma tela e isso automaticamente cria
eventos para mim agora um sistema de eventos
não exclui isso. Isso basicamente
lida com eventos como pressionamentos de
botões ou
slides ou slides ou qualquer coisa
desse tipo e unidade. Portanto, certifique-se de incluir isso em seu projeto ao
criar um Canvas, ele criará um
nome automaticamente de minha interface de usuário de tela. Então você pode ver minha tela
se eu rolar para fora, é muito, muito maior do que minha câmera principal, essa é minha câmera principal lá embaixo e minha tela aqui em cima. E isso é por causa
dos modos aleatórios. Então, atualmente, ele está configurado para sobreposição de espaço na
tela. E para ser honesto,
quase sempre uso câmeras espaciais na
tela porque é muito mais fácil na minha opinião, você pode usar a
sobreposição de espaço na tela, se quiser, ou câmeras espaciais na tela. Eles são muito semelhantes. A principal diferença é
a tela diz sobreposição. A interface do usuário é sobreposta sobre a câmera e
roteiros da câmera. É tratado como se fosse parte
da câmera em termos simples, mas vou usar a
câmera para meus propósitos. Vou arrastar minha câmera
principal e podemos ver agora ela vai e
redimensioná-la todo o caminho para baixo. É exatamente o mesmo tamanho agora da minha câmera principal, o que
é bem legal. Tudo o que fiz lá foi
mudar o humor e
arrastar minha câmera como
a câmera de renderização. Agora, eu iria em frente e deixaria todas as outras
configurações
como elas são, pois há
muito sentido aqui. E mudar isso não é
exatamente o
uso mais construtivo do seu tempo, pois quando você está trabalhando no
Unity pela primeira vez, todos os padrões são praticamente o que você vai
querer usar o tempo todo. A única coisa que eu consideraria mudar é esse modo de escala de interface do usuário. E eu alteraria isso
para dimensionar com o tamanho da tela e, em seguida, escolheria uma resolução de
referência e, em seguida, escolheria uma resolução de
referência
com base na sua resolução
atual. O meu está atualmente
definido como um aspecto livre, mas se eu mudá-lo para
algo como 69, por exemplo, eu usaria uma
resolução de referência semelhante a essa ou de preferência a essa. Então eu gostaria de
combinar a largura ou a altura ou uma
combinação de ambos. Eu recomendaria ir
para um ou outro. Eles veem o que isso
fará é se eu redimensionar minha tela ou redimensionar a resolução, tudo
vai funcionar e combinar com ela ou adicionar o
melhor de sua habilidade. Mas não vamos
nos preocupar muito com isso agora porque
obviamente não vamos construir nosso jogo ainda, eu apenas manteria isso
um
tamanho de pixel constante ou constante
tamanho físico, se você quiser, não
faz diferença para nós agora, como eu disse, mas quando você está realmente
construindo seu jogo e se preparando para
diferentes tamanhos de tela, eu recomendaria
tentando dimensionar com tamanho
da tela e
brincar com esses valores
diferentes. Como eu acho que isso
poderia ser bastante útil em termos
de re-dimensionamento da interface do usuário. Como eu disse, no entanto,
não vamos mudar isso agora. No entanto, na verdade, apenas
começamos a adicionar
alguns elementos da interface do usuário. Então, neste momento, temos uma
tela de interface do usuário que basicamente gosta da coisa principal que tudo na interface do usuário precisa estar dentro. E temos um
sistema de eventos que
precisa estar lá fora debaixo de você. Não vou diretamente por baixo, mas preciso ser seu próprio
objeto fora da interface do usuário. E basicamente tratará de
todos os nossos eventos para. Então, a primeira coisa
que vou fazer é
criar uma imagem simples. Se eu for clicar com o botão direito do mouse aqui, vou para a interface do usuário e
vou, crio uma imagem e
podemos ver isso porque já crio uma tela,
então só vai lá. Se eu não tivesse criado uma tela, ela criaria uma tela
e um sistema de eventos para mim. Mas desde que eu fiz,
vou criar uma imagem, vou nomear essa imagem como ela já foi nomeada. E você pode ver já
logo de cara, parece muito semelhante
a como um sprite faria, e na
verdade é a mesma coisa. A principal diferença
é que uma imagem é um componente de interface do usuário, então a usamos para menus
e coisas assim. E um sprite é um tipo de representação visual
para nossos jogos. Então eu uso isso para personagens. Então, obviamente, para minha imagem, eu posso até atribuir, preciso atribuir um sprite
como minha imagem de origem. Então você pode estar pensando, ok, bem, qual é
a diferença? Mas confie em mim neste, há uma diferença muito
distinta entre imagens e sprites. Você não quer usar imagens
onde você precisa de sprites. Você nunca gostaria de
usar uma imagem para representar um personagem de jogador,
a menos que esteja criando um jogo abstrato incrivelmente
estranho. Por causa de como as imagens funcionam,
por causa de suas propriedades, devido ao
fato de que elas são renderizadas de
maneira diferente no Unity Editor. E por causa do fato de que você nunca
gostaria de
adicionar algo como um colisor de caixa a um
elemento de interface do usuário em primeiro lugar. Então, confie em mim nessa. Você quer usar imagens na interface do usuário e deseja usar
sprites em seu jogo. Se parecer assim agora, basta tomar isso como garantido. Mas de qualquer forma, estou arrastando
meu blog para o meu sprite. E isso realmente não ajuda
nosso caso na medida em que parece quase idêntico
agora a um sprite. Mas isso é basicamente
a forma como as imagens são. Você pode ver que está realmente bem embaçado porque eu esqueci de
definir esse modo de filtro
quando o importei, assim como abordamos
no primeiro episódio, mas corrija isso rapidamente. Não se preocupe com
isso se você
esqueceu disso,
lembre-se com pixelate, você quer que o modo
de filtro não seja um ponto de filtro e a compactação não
seja nenhuma para que ele não se desfoque. E então, se eu for em frente
e clicar em Definir lados nativos, na verdade
será muito menor por causa do
tamanho da OTAN dos pixels. Se eu fosse alterar
esses pixels por unidade de ativação como dez, e então o tamanho nativo
será redimensionado de acordo. Então, esses são os conceitos básicos
das imagens em unidade. E uma das principais
diferenças entre
imagens e sprites é que,
se eu jogar meu jogo agora, podemos ver que a imagem
está no canto superior esquerdo. E se eu
mover minha câmera principal, a imagem vai se
mover com as câmeras. Esta é outra
razão pela qual, obviamente você não
gostaria de usar uma imagem como objeto de jogo ou jogador porque você não gostaria que ela
se mova exatamente assim. Você pode ver, como eu disse, está sobreposto sobre o jogo. Então, obviamente, é muito
bom para elementos de interface do usuário, e é por isso que
ele é elemento de interface do usuário. Esse é um dos recursos.
Se eu fosse fazer isso, por exemplo, um botão de reprodução e dissesse que não tinha um plano
para usar, estou usando meu blob. Mas se isso fosse um violino de brincadeira apenas por
causa deste curso, finja como se
fosse um botão de reprodução. Se pudermos construir o jogo, então você pode imaginar isso
como um grande botão que eu posso jogar meu jogo. E se eu mover minha câmera, desculpe, movo minha câmera e podemos
ver que ela se move de acordo, o que é muito, muito legal. Mas há alguns componentes de interface do usuário mais
interessantes que vou
abordar neste vídeo. E um deles realmente
vai ser um botão. Então, se eu voltar à minha interface do usuário, mostrarei o primeiro elemento de interface do usuário
realmente utilizável, que tem um botão. Obviamente, uma imagem é útil,
mas você não pode, na
verdade, ela não tem
tanta funcionalidade porque é apenas uma imagem. Mas queria fazer um
botão, no entanto, ele faz. Se eu for clicar com o botão direito do mouse
aqui, posso ir UI e criar um botão. E você pode ver aqui, dependendo da sua
versão, a única opção tenho é o botão text mesh Pro, o que basicamente
significa que é um botão com mais
opções de texto para o texto, o que é bom para mim. Vou seguir em frente
e clicar no botão. Aqui Nós próprios, você pode ser recebido com
este menu pop-up. Este é um nicho de texto Pro
é um pacote UT que
permite que você faça muito mais quando você está editando textos. Então, basta clicar em Importar. Tudo vai funcionar. Os incêndios podem importar
isso para seu projeto. É feito por unidades, não se preocupe, você não precisa importar os
extras se não quiser. E isso
vai durar e nosso botão,
desculpe pelo soluço, mas se você correu para ele, basta pressionar importante e tudo
funcionará perfeitamente. Você não precisa se
preocupar com isso por enquanto. Isso vai criar
um botão para nós. Assim, podemos ver imediatamente se clicamos em nosso botão,
temos esse botão, que é o
componente botão, e embaixo dele temos os textos, que é um objeto filho. Então, a primeira coisa que
vou fazer é mudar esse texto. Se eu for ao meu texto T e P, vou mudar isso para mim. Então podemos ver, se
voltarmos ao meu botão, posso alterar os componentes
reais. O botão realmente tem
uma imagem anexada a ele, que é o que estamos vendo
aqui, este quadrado branco. Se eu arrastasse em um blog de interface do usuário, veríamos que o botão agora
é muito, mas eu não
quero fazer isso. Então, vou mudar
a cor para
torná-la um pouco mais fria,
torná-la amarela. E vou
mudar a cor
do texto para ser branco. Então eu posso ir aqui para a cor
do vértice e
mudar isso para ser branco. Podemos ver agora que temos um botão um
pouco mais personalizado. E isso é tudo bom e tudo. Obviamente, também podemos alterar
a qualidade do botão. Posso mudar a cor
do botão
aqui e alterar a tonalidade, que é muito semelhante
à imagem, mas está substituindo todo
o botão. Mas há algumas coisas que
você não notou aqui. Os componentes da imagem são
todos autoexplicativos. É por isso que eu não passei muito
sobre eles. É apenas a
imagem de origem e a cor. Você não precisa se
preocupar com nenhum dos outros. No entanto, o botão tem algumas coisas nas quais
precisamos nos concentrar. Primeiro de tudo, o fato de ser interactável basicamente liga e desliga
o botão. A transição é
basicamente o que se refere quando eu jogo
o jogo agora. Se eu passar o mouse sobre ele
e clicar nele,
isso é o que significa quando
a transição para a mente é baseada
no tom de cor. Em outras palavras, o
botão vai matizar cores
diferentes
com base no fato de eu estar passando o mouse sobre ele ou clicando nele. Mas se eu quisesse
fazer outra coisa como uma animação, por exemplo, queríamos ficar maiores
quando eu passei por cima, eu poderia configurar isso aqui. E então a maneira como isso
funciona é com gatilhos, como abordamos o episódio de
animação há algum tempo. Os gatilhos, o que usamos
para mudar a animação. Era apenas um tipo de
parâmetro aqui. Você poderia adicioná-lo
aqui como um booleano e você pode
usá-lo como condição para suas
transições entre eles, mas eu não me
preocuparia muito com isso. Agora a tonalidade de cor é um recurso de botão muito
útil e, na verdade, geralmente
usamos esse em geral de qualquer maneira. Então você pode
usar isso por enquanto. A cor normal
refere-se à cor quando o botão
não está em uso. A cor realçada é a cor quando o
botão passa o mouse sobre. Tudo realçado e pressionado
é o botão que a cor do botão ou a tonalidade quando o
botão é pressionado. E, em seguida, apenas a
cor selecionada obviamente alterou a tonalidade da cor
quando o botão está sendo selecionado e desativado. Podemos ver lá,
na verdade, que é quando o botão está
desativado ou ativado. Essas são as cores até eu
fazer isso algo como vermelho. Agora desative-o, podemos
ver o botão ficar vermelho. Então isso é muito legal.
Na verdade, esses são todos os tons diferentes
do botão. E esses realmente
serão o que é usado quando eu passar o mouse
sobre o botão. Então vá aqui no meu jogo. E podemos ver que temos
nossa imagem e nosso botão. Se eu passar o mouse sobre ele,
podemos ver a tonalidade da cor. Se eu clicar nele, não
veria uma tonalidade colorida. Mais uma vez. Obviamente, não faz nada quando
clico nele, no entanto, e vou mostrar como
consertar isso em um segundo. Agora, a maneira como
vamos programar esse botão para fazer as coisas
quando ele é clicado, é usar este evento onclick. E se você se lembra
durante todo o curso, como estamos trabalhando com
scripts, tivemos métodos. Criamos um método de salvamento e um método de salto e todos esses
diferentes tipos de métodos, e os chamamos via código. Agora, esse botão é muito semelhante exceto em vez de chamar
um método via código, esse botão chama um método
sempre que for pressionado. Vou mostrar
exatamente como isso funciona. Vou criar
um novo script. Primeiro de tudo, chame o botão. E então vou clicar
duas vezes nele. Abra-o no Visual Studio. E uma vez que ele for carregado, vou seguir em frente
e excluir minha atualização vazia e paradas de voz. Então você usa e cria um novo vazio
público e o chama pressionado. Então tudo o que vou
escrever aqui é impresso. botão foi pressionado. E podemos ver agora, se
eu voltar ao Unity, ele vai compilar
meus scripts juntos. E então vou
até minha câmera principal e vou adicionar esse código
à minha câmera principal
só
para poder ilustrar como você
faz esse tutorial. Às vezes, é útil
ter um script de menu que
você adiciona à sua interface do usuário. Isso geralmente é o que
eu gosto de fazer, mas câmera
principal funciona tão bem. Isso realmente não faz
diferença. Em seguida, voltamos ao meu botão e vou
querer adicionar um evento ao clicar. Então, vou clicar em Adicionar. Então ele precisa de um objeto. Portanto, ele precisa saber
onde o script
que eu quero acessar está localizado, obviamente a mente
da câmera principal. Então, vou arrastar isso para dentro. Agora, quando clico na função
do nó e vou escolher entre as
diferentes coisas. Obviamente, tenho um monte de funções de objeto de
jogo e
transformação e câmera. Você não precisa se
preocupar muito com isso. Basta focar no
nome dos seus scripts. Meu script é chamado
botão e podemos ver meu script de nome ali. Na verdade, podemos encontrar
meu método personalizado que criei chamado
pressionado aqui. Todos os outros são métodos
padrão no Unity. Eu não me
preocuparia muito com eles. Geralmente, quando
você está fazendo menus, você quer usar sua própria voz qualquer maneira porque você quer
fazer suas próprias coisas específicas. Mas agora, se tudo isso funcionar, sempre que esse botão for pressionado, ele chamará esse
evento de clique da câmera principal. E vai dizer, ok, imprima aquela coisa que dissemos. O que você disse
botão foi pressionado. E eu realmente vou
mostrar que na vida real, se eu for em frente e bater o jogo,
podemos ver se eu clico nele. Ele diz que o botão foi pressionado e
eu clico nele várias vezes. Diz que o botão foi pressionado todas essas vezes, o que é
bonito, bem legal. E é basicamente assim que
vamos usar botões e unidade. Obviamente, se eu quisesse
fazer um menu principal, eu teria que dizer, ok, sempre que eu pressionar o botão, iniciar o jogo e eu
teria que escrever código
para estilizar o ganho. Eu geralmente
gostaria de fazer é que eu gosto de ter estados diferentes. Então, talvez, se eu
quiser iniciar o jogo, eu gostaria de desativar essa interface do usuário. Então, todos os elementos da interface do usuário
desaparecem e, em seguida, o jogo começa. Essa é uma maneira de fazer isso. Ou você vai para cada imagem ou
botão e talvez mova-os para cima. A maneira, geralmente
o que eu gosto de fazer é, na verdade, quando estou
fazendo o menu principal, faço com que esses componentes
se movam do caminho. Então, por exemplo, se
esse fosse o meu Claiborne, se eu puder mover minha outra
imagem do caminho. Este é o meu enorme botão
Play aqui. E eu fiz isso um pouco maior para que todos vocês
possam vê-lo. Então esse sabor e
eles clicaram nele. O que eu poderia fazer é
fazer alguma animação onde eu deslize isso do caminho
e então o jogo começa. Então esse é um exemplo de como você começaria a criar
seu menu principal. O que é muito legal. Tudo isso será feito
apenas por esse evento onclick. Agora, o último componente de interface
do usuário
quer mostrar apenas um pouco mais de nicho
que será um controle deslizante. Então, se eu colocar o autoconsciente,
crie mais um. Então eu clico aqui
para me certificar de que é um objeto filho da minha tela porque eu
sempre não vou trabalhar. Vou fazer a interface do usuário. Vou escolher um controle deslizante. E o slide será
muito parecido com um botão. Você pode ver que há
essas setas se formando. Não se preocupe
muito com eles. É assim
que o Unity lida com
a forma como os componentes da interface do usuário estão funcionando em coalizão uns
com os outros. Mas vou usar o
controle deslizante como o controle deslizante de nome. E então aqui você pode
ver coisas muito parecidas com o botão e outras
cores e coisas e todas as cores diferentes
e como elas se parecem. Eles estão desativados de perto. Podemos ver lá. E então podemos ver que ele tem um retângulo completo ou uma transformação de
preenchimento, que basicamente se refere a onde o controle deslizante
se move de e para. E temos uma alça
retângulos PC refere-se a onde está a alça. Temos uma direção da
esquerda para a direita. Também podemos fazer da direita para a
esquerda ou de baixo para cima, etc. Eu deixaria a maioria
deles por enquanto. Obviamente, você vai
querer mudar, se você for aqui lentamente, você vai querer mudar
o plano de fundo porque macrons de
retina são simplesmente padrão. Unity, a área de preenchimento
na mesma coisa, você tem que escolher uma
cor para o preenchimento. Então, se eu fizer a minha leitura, você realmente será capaz de
ver exatamente o que isso
parece quando eu deslizar
esse slide. E então o
controle deslizante da alça, eu congelei para onde a alça desliza. E o identificador apenas
se refere ao que estou usando. Então eu poderia realmente usar
uma bolha como minha alça. E isso seria um slide bem
legal se eu talvez escalá-lo um pouco,
fazendo a escala 1.2. E eu quero começar o jogo. Podemos ver aqui, enquanto
eu deslizo meu salário, podemos ver que
vermelho cheio dissemos, e a cabeça de blob é
usada como slide. Se eu fizer essa área de preenchimento exatamente
no mesmo lado para
usar esta ferramenta conta-gotas, você pode ver
que ela fica ainda melhor. E agora temos nossos blobs
personalizados mais tarde. Veja que parece muito
legal na minha opinião. E esses são todos os conceitos básicos
de como a interface do usuário funciona em unidade. A última coisa que
vamos cobrir apenas é o evento alterado de valor, que é muito semelhante
ao evento button. Vou clicar aqui,
adicionar uma coisa que estou querendo. Vou arrastar
o que quiser, assim como no botão e
vou realmente
chamar o mesmo evento. Exceto em vez de chamar isso, vou mudar
esse vazio agora. Então, em vez de dizer Ok, basta imprimir o
botão foi pressionado, vou imprimir o
valor do controle deslizante. Então eu preciso começar criando uma referência, o
slide como público. E é aqui que você
realmente usará isso usando Unity UI coisa que mencionei
anteriormente no curso. Vá para o topo aqui e escreva
usando a interface do usuário do mecanismo Unity. E se não escrevermos isso, se escrevermos slide,
mostrarei o que acontece agora. Ele preenche
automaticamente. Se nós removêssemos isso. Podemos ver agora que ela não
tem ideia do que este é um slide como não existe
no contexto atual. Mas com o uso da interface do usuário, podemos nos referir
a componentes da interface do usuário. Essa é a outra coisa
que eu quero abordar neste vídeo. E então vamos
chamar isso de um controle deslizante. E então, quando estamos deprimidos, queremos dizer impressão. Em vez de imprimir que
o botão é pressionado, o que imprimirá o valor do ponto
deslizante. Isso imprimirá o valor
atual do nosso slide. Vou te mostrar exatamente
como isso parece agora. Basta voltar para o Unity quando
os scripts que fizeram recarregamento vão para minha câmera principal e primeiro preciso criar
uma referência ao controle deslizante. Então, vou
arrastar isso para o outro lado. E então toda vez que vamos
mudar o valor, ele nos dará uma atualização
sobre o que é esse valor. Você pode ver que
na parte inferior aqui, ou valores
atualmente é um, 0,40.7. Na verdade, está atualizando
cada quadro que esse valor é alterado ou toda vez que o
valor mudou. Em vez disso, podemos alterar o que o valor varia a partir
daí que vemos aqui, Valor
mínimo e valor máximo. Queremos definir os números
inteiros. Posso fazer disso um
100 e isso é 0. E então você poderá
vê-lo um pouco mais claramente. Espero que possamos ver
aqui 0123456075109900. Sim, essa é uma visão geral básica
de como a interface do usuário funciona em unidade. Obviamente, você só
precisa se concentrar principalmente nesses eventos, porque é assim
que você
realmente
vai programar seus jogos. Se você tiver um botão aqui, você obviamente construiria toda sua lógica neste botão
ou desprezaria alguém, você gostaria de construir coisas
no evento alterado de valor. E então, aqui,
a imagem sempre não tem nenhum código
associado a ela que você apenas a usa para tornar seu jogo um
pouco mais atraente. Você pode usar imagens para
talvez exibir quente como a saúde do jogador ou
algo assim e depois desativá-las quando você
paga se perder. Ser bom exemplo de imagem. Mas sim, esses são os
fundamentos da UI de unidade. E espero que isso deixe
as coisas muito mais claras. Acho que o sistema de interface do usuário do Unity é muito bom
e
completo em geral, e não tenho nenhum
problema com ele normalmente. Então, se você puder se
familiarizar com esse sistema, você deve ser muito
bom para começar a construir seu primeiro
sistema de menus, o que é ótimo. Mas tudo
o que é muito mais sentido e te vejo
no próximo vídeo.
15. Ferramentas de análise: Ei lá, e bem-vindo de
volta à unidade. Agora, abordamos
quase todos vocês nesses conceitos básicos sobre
essas 0,1
das principais coisas que restam, no entanto, é
como analisamos o desempenho do nosso jogo. Então, neste momento, criamos cenas
bem simples e minijogos e basicamente
apenas cenários onde podemos ilustrar
os conceitos básicos da unidade. Mas se você estiver usando isso para aplicá-lo
a um jogo real, você vai querer
esperar e ver e como analisar seu jogo
e garantir que ele esteja construindo para a plataforma certa e usando a quantidade mínima de recursos de
qualquer sistema que você esteja gravando para isso quanto possível. Como se você estivesse usando muitos,
excluirá muito do seu mercado ou menor NPCs ou telefones lentos, o que quer que você esteja construindo. A maneira como vamos
analisar isso é usando uma ferramenta integrada
chamada perfil. O perfil que você pode realmente
encontrar um par se você for para Análise de
Janelas e,
em seguida, clicar em Perfil que isso realmente
abrirá o perfil que
espero
que você tenha todas as coisas padrão que
eu tenho aqui em cima. Você deve ter vários gráficos pelos quais você pode
percorrer. E então, por baixo, você
deve ter essa linha do tempo. Agora vamos ignorar
esse tempo como batidas,
essa linha do tempo é bastante
complicada e requer um conhecimento bastante extenso sobre hardware de
computador e
como esses roteadores funcionam. Eu não entendo
totalmente tudo nesta linha do tempo para
ser totalmente honesto, e há
muitos detalhes extras. Não é o recurso mais
útil. Na minha opinião,
especialmente se você está construindo jogos bem pequenos. Mas essas cinco
coisas são realmente bastante úteis, pois
permitem que você
possa analisar como
seus jogos estão sendo usados e para garantir que você esteja
usando os mesmos modelos de mim, basta ir até aqui e você
pode certifique-se de verificar CPU, GPU, memória e física 2D. Não sei quais são definidos como padrão ou segundo restaurados, mas parece diferente. Basta ir em frente e
desmarcar os
que você quiser ou não quiser. Vou usá-los para porque essas pessoas serão melhor ilustradas com base no minigame de amostra que
criei para
mostrar como isso funciona. E, na verdade, também
vou selecionar renderização apenas para que eu
possa mostrar o que é isso também. Mas esses serão basicamente como
vai funcionar. Temos CPU, GPU, memória de
renderização
e, em seguida, física. Vou mostrar a vocês como
isso realmente vai permitir que você
analise os jogos uma forma clara que, por
enquanto, e podemos ver tudo está sendo executado no que faz isso 10
mil FES, eu acredito. Então. Vamos seguir em frente e mover esse perfil e, na verdade
,
arrastá-lo um pouco para que
possamos ver mais e querer movê-lo para baixo. Também vou subir um pouco para que
possamos ver tudo de uma só vez. E isso se nós
realmente pudermos fazer isso
um pouco assim. Então esta
será nossa cena até agora. Então eu realmente criei um emissor de
partículas que usa um monte de partículas
e um monte de cores, apenas para ser incrivelmente intensivo em
GPU. E então eu também criei um
monte de blobs que estão usando o mecanismo de física do Unity para ser um pouco
intensivo em física também. Se eu for aqui e apertar jogo agora eu
desabilitei os dois. Então você deve ver alguns gráficos
bastante padrão. Você pode ver
agora, tudo está funcionando em um confortável
1 mil FPS. A CPU está atualmente, você
pode ver que está aqui embaixo,
está sendo executada em mil
FPS e desce para a GPU. Também está usando
absolutamente nada. E então
não há nada acontecendo na renderização
porque agora está sendo renderizado. Memórias usando um
pouco de OC e física também estão usando praticamente vontade, na verdade nada
porque não há física e você pode ver que não
há nada acontecendo lá. Obviamente, a chave para o que cada uma
dessas coisas significa está
à esquerda aqui que a renderização
é verde, v sync é amarelo. Outros são uma espécie de azeitona. E então, como por
exemplo,
a física é laranja e não
há física. Então você pode ver que pode ser laranja
muito fraco lá, mas praticamente
não está lá. Iluminação global, da mesma forma, uma animação, todos
esses tipos de coisas. Especialmente você pode
ver que não há roxo porque não
temos nenhum elemento de interface do usuário. Agora e mostre
o que acontece se eu ligar esse emissor de partículas. Então, se eu bater e coisas que você pode ver meu emissor de
partículas, Saltzman, partículas inteiras. E imediatamente
vamos cair para 200 FPS. E podemos ver, na verdade,
o uso principal foi outros. Mas se formos até essa GPU, podemos ver que, de repente
, todo esse azul não tinha antes
se eu desligar isso, modo que imediatamente
cai e eles costumavam ser muito azuis. Agora não há nenhum. Então, se eu voltar a ligar,
podemos ver que o
azul claro começa a ficar, o que obviamente
podemos ver aqui se refere ao pré-passe diferido. E podemos ver que ele
tem esses pequenos picos, mas está correndo em torno de duzentos e
cinquenta, duzentos FES. Como resultado de todas
essas cores e luzes, podemos ver obviamente que não há pós-processamento porque não
há amarelo na
coisa, mas não há sombras. Podemos ver que esse pré-passe
diferido e o outro está
sendo usado bastante. Agora, se passarmos à renderização, podemos realmente ver essas linhas
no topo significando que meu programa está realmente renderizando bastante com
esse efeito de partícula. Talvez você tenha
conseguido vê-los
subir quando iniciamos um efeito de
partícula. Mas, obviamente, eles
não estão se movendo demais agora, mas isso significa que a
renderização está acontecendo. Então você pode ver memórias também ter esses
pequenos picos. E a física é mais uma vez definida para nada porque
não há física acontecendo. Mas você pode usar isso para
analisar o quão intensivo
você ganhará é o OC. Quer que estejamos correndo? Meu computador é bastante rápido e especialmente no
Butão e no jogo móvel, quero que isso seja executado
por volta de 200 anos, pelo
menos no meu computador se eu
for bom
o suficiente para dispositivos móveis, obviamente, não tome
essa escala muito específica. Leve-o com um pouco
de grão de sal porque difere para cada computador
e cada dispositivo. Mas isso deve lhe dar um pouco de um marco sobre o
desempenho do seu jogo. É muito legal
se eu realmente desabilitar isso e ver
tudo caiu de volta para baixo mil
quadros e a GPU não é mais
usada tanto. E, na verdade,
vou ligar minhas bolhas e elas vão
começar a saltar assim. Isso não tem
muita coisa. Nós caímos um pouco
da taxa de quadros talvez para cerca de 800 ou 500 até mesmo. Mas se formos para a Física, podemos realmente
ver
que a física vai parar de ser usada. Você pode ver
aqui que temos picos. Você vê aqueles
blocos vermelhos que surgem. Isso porque os
contatos estão acontecendo. Podemos realmente
verificá-lo na chave e toda vez que eles aterrissam, temos um novo contato
que acontece. Você pode ver a caixa vermelha aparecer. Isso é realmente muito
legal porque isso
nos permite rastrear nossa física. Por exemplo, se você estiver
usando
um jogo onde não há muitos contextos e até mesmo perceber muitas dessas caixas vermelhas, talvez
você tenha algo que você precisa verificar. Este é um exemplo de por que o perfil é tão útil
para analisar suas VMs. Volte aqui para a GPU. Obviamente, estamos usando quase nenhum porque não estamos mais, geralmente
estamos renderizando
esses cinco blobs. Você pode ver que há uma pequena linha azul
fraca lá em
cima e
certamente uma CPU. Há poucas especiarias
aqui e ali. Eles não parecem ser muito baseados em onde os
blocos estão saltando, não mas principalmente apenas importante, essas colisões
são um bom exemplo. E então, se eu
ligar os dois de uma vez e agora temos as bolhas
e as partículas. Devemos ser capazes de ver
que agora estamos caindo para lá cerca de 200 FPS, acho que antes
era em torno de 250. Portanto, pode ser um pouco
menos desempenho com esses blobs saltando. E então nosso uso de GPU obviamente
está aumentando. Muitos animais realmente
legais é se eu mudar essa vida inicial
para algo como 50, as partículas não desaparecem. Em outras palavras,
continua
saindo e que estão agora em andamento. Podemos ver que devemos
ficar cada vez menos. Você pode ver que está
subindo e subindo e subindo. E agora por mais tempo estávamos em
200 e agora estamos indo, na verdade, estamos quase nos
aproximando de 60 quadros por segundo. Da mesma forma, aqui
vamos de 60 a 30 porque há
muita coisa acontecendo de uma só vez. E podemos até ver que uma renderização agora
está tendo todos os tipos de picos por causa de
quantas coisas você pode ver, na verdade você pode notar que esse quadro
cai acontecendo agora. E as memórias também ficam
um pouco loucas. A física é agora, isso é quase
idêntico ao que era. É apenas mais
desse quadro porque tudo agora
foi ampliado. Mas, na verdade, há
um bom exemplo. Agora, se seus gráficos assim, seu jogo pode ser
um pouco intensivo em sua GPU ou CPU e
definitivamente mente demais
na minha CPU e GPU. Mas sim, podemos
ver que a taxa de quadros
caiu consideravelmente
depois que eu mudei isso. E se eu mudasse a vida de
início para ser 500, eventualmente minha coisa começaria a congelar e podemos
realmente sair aqui. Podemos ver o
quanto está sendo renderizado. E isso realmente
vai parar essa pirâmide enquanto ela
vai começar a subir, mas aumente a velocidade
algo como 50. Agora devemos realmente
deixar cair minha CPU, anotar. Podemos ver agora que estou rodando
bem perto de 30 quadros, quase 15 quadros por segundo. E podemos ver agora
que isso é muito bom, mas com essas bolhas
subindo e descendo, a GPU está sendo
usada consideravelmente menos porque há partículas
máximas, acredito que realmente
foram alcançadas até pararmos de
renderizar coisas. Mas a renderização que você pode
ver ainda está acontecendo. A memória está sendo
usada mais e a física ainda tem essas colisões
de vez em quando. Portanto, este é obviamente um exemplo muito
exagerado quando seu jogo pode não ser tão
claro quanto o que está acontecendo. Mas se você simplesmente
olhar para
a chave à esquerda e puder analisar o que está
acontecendo no gráfico, poderá ter
uma ideia decente do que está diminuindo seu jogo
ou apenas pelos menus. Se sua GPU é muito,
muito alta e
sua CPU é muito,
muito baixa, então eu
recomendaria obviamente com
base nas especificações dos seus computadores, mas eu recomendo talvez
usar efeitos menos extravagantes ou menos sistemas políticos ou sprites
menos complicados, por exemplo, esse
tipo de coisa. Ou se sua CPU for muito, muito alta e suas GPUs baixas, talvez haja muita coisa acontecendo, há muitos
cálculos físicos ou há muitos scripts
que estão sendo executados de uma só vez, qualquer coisa assim. Espero que isso dê
uma visão geral de como o perfil funciona e eu ajude
você a analisar o desempenho do seu
jogo. Espero que você possa entender praticamente tudo o
que passamos com esse exemplo porque
senti que era uma boa maneira
de ilustrar como o profiler pode ser
usado para analisar seu jogo. E você obviamente poderia
usar isso em
várias instâncias,
especialmente em testá-lo com um
monte de jogos diferentes. E especialmente com
aqueles jogos que são mais exigentes
de seus recursos, é mais importante
saber exatamente o que
está acontecendo quando você realmente não ganha que os computadores não podem ser executados. Mas sim, espero que isso
faça muito sentido. Verei você no próximo
vídeo, onde vamos rever o aspecto final da unidade,
que vai ser construído. Obrigado por assistir.
16. Construindo seu jogo: Ei lá e bem-vindo de volta
ao aspecto final da unidade estará cobrindo
neste curso, construindo. Agora, construir é a forma de escrever
Unity que você está
exportando seu jogo. Depois de terminar o jogo, você pode querer
construí-lo para que ele
possa ser jogado em
vários dispositivos. Obviamente, não é possível jogar
o jogo como arquivo Unity. Você precisa construí-lo em qualquer formato de arquivo necessário para que ele possa
ser reproduzido
seja executável ou se um Android ou Apple usar
algo assim. Você vai querer
basicamente construir seus jogos que você pode
distribuí-los para sua base de jogadores. E você vai
fazer isso
acessando Arquivo e crie configurações. Então, neste vídeo,
vou mostrar todas as
configurações diferentes que você precisa tomar nota ao
criar um novo jogo. E, finalmente, como construir seu jogo
para que ele possa ser jogado por quem você
quiser jogar seu jogo. canto superior esquerdo aqui,
você vai começar indo para o arquivo, assim como fizemos logo no
início do curso. Você vai querer
selecionar Configurações de compilação. E construir senso vai
levá-lo a este menu. É óbvio que
você é capaz mudar a plataforma,
você inicializa e cai. Para este tutorial,
vou
mostrar a você como
construir para um computador. À medida que saio, essa
é a
plataforma mais comum para o desenvolvimento do Unity. No entanto, todas as plataformas que
você estará disposto para oral serão bastante semelhantes na forma como
você constrói. Haverá apenas
algumas diferenças distintas. Como por exemplo, aqui, especifiquei minha
plataforma de destino sendo windows, e preciso verificar se minha
arquitetura é de 64, 32 bits. Para Android, eu teria que obviamente, selecionar a compressão de
textura. E o que eu quero que você crie
um pacote de aplicativos que é o formato de reprodução do
Google,
todo esse tipo de coisa. Mas não se preocupe, tudo isso
é bastante autoexplicativo. A principal coisa que
você vai se concentrar em todas essas configurações de
jogadores. Então, em termos de adulteração
com as configurações de compilação, eu não o faria quando
você começar uma anuidade, você provavelmente
precisará apenas das padrão. Há algumas que você pode ter mudado nas configurações do lugar, e eu sou uma garota de todas elas. Mas aqui, essas configurações de compilação
normais, você vai
querer sair, como elas são. Obviamente, certifique-se de que
sua arquitetura esteja configurada para a correta se
você tiver escrito para um
computador Windows ou Mac ou Linux. Mas sim, isso é basicamente que
você não quer fazer. Eu mudei qualquer
um dos outros. Agora, a última coisa que é
muito importante, no entanto, antes de seguirmos
para tocar
a frase ou as cenas e você construirá e a ordem dessas cenas. Então, obviamente,
ao longo do nosso curso, não
fomos queimados no jogo. Então, não tenho
mais de uma cena. Mas se eu tivesse que ir até
aqui e eu pudesse criar, digamos que eu queira
criar uma nova cena. Eu vou criar visto e vou
chamar este tutorial. Quando eu construo meu
jogo, eu gostaria que meu tutorial visse arbusto
antes de minhas outras cenas. Se eu fechar isso e
abrir minha cena tutorial, que é como uma
nova cena diferente. Obviamente, eles parecem
muito parecidos porque eu não mudei
nada em nenhum dos dois. Mas depois vou
aqui, Configurações de compilação de arquivos. Vou clicar em Adicionar CDS aberto. Isso vai adicionar meu tutorial. Por causa das cenas que
constroem todas as cenas,
atualmente tenho meu
solvente vendo no meu principal visto antes da minha loja, mas eu posso arrastar isso e colocar o tutorial em
primeiro lugar, se eu quisesse. Esta será a ordem em
que as cenas aparecerão. Então, obviamente, se você
tiver um menu principal da CPU, um nível de CPU selecione
e, em seguida, uma cena para o seu jogo
principal e o carregador de níveis. Em seguida, você vai
colocar isso nessa ordem, no menu
principal, na seleção de nível
e, em seguida, no carregador de nível. Na verdade, será exatamente como você
constrói seu jogo. E isso lhe diz qual
ver você primeiro, é praticamente todas as
outras configurações, como eu disse, apenas deixe-as como
estão e você só quer editar o resto
nas configurações do jogador. Então vá aqui
para jogar as configurações, e essas serão
todas as configurações do seu jogo, certo? No topo, você quer definir o nome da
sua empresa para qualquer empresa ou marca você esteja usando para
desenvolver seus jogos. Eu poderia chamar o meu dev de jogo
Unity. Por exemplo. Obviamente, esse não é
o melhor nome, mas seja lá o que você nomeou o seu, basta colocá-lo lá.
Em seguida, o nome do produto. Obviamente, não estou criando
um produto, mas se estivesse, poderia fazer um jogo, por
exemplo, carro flappy. E então eu mudaria
o nome com base nisso. E então você deseja definir
o número da versão. Tudo isso será
refletido no arquivo Build do jogo. Portanto, certifique-se de
defini-lo para o que você quer. E isso obviamente
não vai
mudar demais com
base no que são. Mas, como eu disse, se
você for para o arquivo, poderá encontrar
a soma da propriedade, então certifique-se de defini-los onde
quiser. E então você só deseja selecionar o ícone padrão
no cursor padrão. Alterá-los apenas mudará qualquer ícone ou qualquer
cursor que seu jogo use. Obviamente, muito autoexplicativo. Obviamente, ambos
estão usando a textura 2D. Então, se eu tivesse mais tensão
aqui, eu poderia, por exemplo, usar essa textura de fonte
como ID para ícones que
não vão carregar muito bem ou poder usar uma partícula padrão. E então meu ícone
será essa partícula. E então, quero dizer, não
é o pior que eu
estive no mundo, então não é a
maior precisão. Selecione também uma maldição. Eu poderia fazer esse
botão meu cursor. E então sempre que eu
joguei, vou ter esse
nojo, minha maldição. Você pode ver na parte inferior que
diz textura inválida usada. Precursor não significa
necessariamente que não vai funcionar, mas significa que
não funcionará completamente. Portanto, certifique-se de
ler esses avisos e ver o que você precisa mudar. Obviamente, a Unity tem algumas especificações para
seus cursores. Eles devem ser RGBA 32 têm transparência
alfa deve ser razoável e não
ter cadeia MIB. Portanto, certifique-se de que
você tenha todas essas coisas sendo cumpridas. Depois de
criar o cursor. Depois disso, faça com que um
ponto de acesso se refira a onde seu T replay ou define o cursor em referência
ao ponteiro do mouse. Então você pode adulterar
isso se quiser. Obviamente, eu não recomendo apenas mudar essas
duas coisas aleatórias. Mas se você puder entender
que você quer ter um cursor deslizante para a direita ou
o que quer que seja. Obviamente, você pode alterar isso acordo e
torná-lo algum valor x. Então, por baixo disso,
eu iria em frente e ignoraria essas duas configurações já que não estamos
construindo para o Android. E, obviamente, se você for
aqui, você muda. Você pode ver, na verdade,
a plataforma está mudando com base no que
estamos selecionando. Então, como estamos
selecionando para o Windows, eu deixaria isso como janelas. E vermelho aqui temos nosso ícone. Neste ícone, podemos ver nosso ícone selecionado em todos
os diferentes formatos. Parece tudo bem, eu diria que você obviamente também seleciona essa
substituição e, em seguida, você
pode escolher novos ícones que substituirão o
AC atual quando você tiver. Então, você pode alterá-los
para diferentes resoluções. E, por baixo disso,
temos resolução e apresentação onde
você pode
editar todas as configurações de
resolução. Então, obviamente, você pode tornar o
modo de
tela cheia exclusivo em tela cheia maximizar
janela, janela, janela de
tela cheia,
qualquer coisa que você quiser como sua coisa padrão, você pode habilitar se quiser seu jogo para poder
rodar em segundo plano. E então você pode alterar
algumas outras configurações. Como eu disse, eu não
recomendaria adulterar nenhum desses, mas todos eles são
bastante autoexplicativos. Eu deixaria
todos eles como padrões a menos que você queira
alterá-lo de janela para janela de tela cheia
para maximizar a
janela, etc., coisas assim. Por baixo disso, no entanto, este é que você está errado
com uma imagem inicial. É basicamente o que,
eu não sei se você já jogou
um jogo antes, mas já o tem antes. Mas se você clicar em Visualizar,
você pode ver aqui tem um feito com símbolos
Unity como esse. E você pode realmente alterar isso e adicionar sua própria
tela inicial sobre isso. Se eu for aqui e
quiser adicionar meu próprio pequeno
aqui,
e posso selecionar, por exemplo, essa marca de seleção para ser meu logotipo. Eu poderia ir até
aqui. E se eu clicar pré-visualização para me ver com pureza
e minha marca de seleção no topo, ela não ficará muito boa. Mas se eu quisesse que eles
saíssem ou outro, eu só tenho que encontrar
as configurações corretas. Se eu for aqui,
vou todo sequencial e depois tenho a coisa Unity e depois meu logotipo. E isso se
parecerá com isso. E então terei meu logotipo. Obviamente, não vou
usar isso como meu logotipo real. Mas, como eu disse, todas
essas configurações são bastante fáceis de
descobrir depois de as ler. Mas a imagem inicial é basicamente
aquela coisa que aparecerá quando você construir seu jogo
pela primeira vez e seu lugar novamente para vê-lo quando o
abrirem pela primeira vez. Então você também pode alterar
a cor de fundo se quiser torná-la talvez
mais clara, por exemplo. E então veja como isso parece. Se eu for em frente e apertar a prévia, podemos ver aqui
que é muito mais leve e quero dizer, não
parece ótimo,
mas como eu disse, estamos apenas brincando por aqui. E então por baixo
aqui você pode ter uma imagem de fundo,
se preferir, você pode verificar ou desmarcar
para desfocar essa imagem. Como eu disse, não
vamos ver isso agora, mas se eu tivesse
uma imagem que eu possa usar e você só tem
que selecionar isso lá. E, obviamente, todas essas outras configurações são
bastante autoexplicativas, a
maioria explicando
exatamente o que fazem. Depois disso, temos
outras configurações e elas ficam um pouco
mais complicadas. Podemos ver que temos
configurações específicas sobre renderização de configurações
Vulcan, Mac, App Store, opções, configuração e figuração de
macro. Eu recomendaria deixar
praticamente todos esses, especialmente se você não tiver
certeza do que eles fazem. Porque se você mudá-los, você pode realmente bagunçar
seu jogo com bastante facilidade. E se você não sabe
o que mudou, então você teria que
procurá-los
e tentar encontrar a coisa que
você precisa mudar de volta. Então eu recomendo
apenas deixar estes. Eu não mexeria muito
com isso. Mas as duas coisas que
eu não saberia quando você está passando por
isso é antes de tudo, você precisa
ter certeza de que sabe qual nível de compatibilidade de API você está puxando força
atualmente estamos boon para rede sanitária 0,1. Você não precisa
necessariamente mudar isso, mas isso é bom
saber onde encontrar
suas outras configurações. Você vai até aqui
e pode encontrar seu nível de compatibilidade de API. E então, se você também
for direto para o topo, você também pode ver que
estamos no meio, você pode ver que temos
esse identificador de pacote. Isso é outra
coisa boa a se notar. Se você estiver criando para, por
exemplo, para a App Store, esse identificador de pacote,
descobri que uso muitas vezes vou
ter que me referir a ele. Portanto, lembre-se novamente, é aí
que está o identificador do
pacote. E você também pode alterar a
compilação e a categoria. Como você disse, se você não está construindo para a Mac App Store, isso não é muito importante, mas isso é outra coisa
boa de se notar. Então, apenas nessas outras configurações, o
nível de compatibilidade da API está aqui, também seu back-end de script. Isso é outra
coisa boa a ser observada com back-end de
script seu nível de compatibilidade de
API e também sua compilação
e maxed ou categoria. Essas são quatro coisas que eu anotaria nessas
outras configurações, mas além disso, eu
não me preocuparia
muito com elas e também não
mexeria muito com elas. Depois de fazer tudo isso, você praticamente
editou o jogo Who quiser e agora
você pode jogá-lo. Se eu for em frente, vou
acertar construir e correr. Isso realmente
vai
me levar a escolher um lugar. Então este é o arquivo
onde meus agradecimentos às ajudas. Vou apenas ir em frente e
escolher a compilação do meu jogo na nova pasta e
chamar essa pasta Builds. E, na verdade, vou
construir meu jogo lá dentro. Este é um processo bastante demorado. Levará algum tempo,
especialmente pela primeira vez, se você construí-lo e
quiser reconstruir novamente, levará muito, mas a segunda vez
por causa da memória. Portanto, não se preocupe muito com
isso. Mas, como eu disse, há um processo bastante longo. E, obviamente, não temos
o jogo mais complicado, então não deve demorar muito. Mas, no entanto, em
outras palavras, na verdade, nosso jogo não será
nada. São cenas vazias demais. Mas ainda é bom mostrar exatamente como essa pessoa
boom funciona. Para deixar isso passar. E depois de
terminar a construção, você poderá ver
nosso jogo carregar muito bem. E temos nossas duas
telas iniciais e, em seguida,
tudo funciona. Eu só vou pressionar
lá fora e podemos ver
que foi o jogo para
construir cabeça e correr novamente, vai ser muito
mais rápido desta vez. Vá para campos de batalha. E deveria, tudo
deve estar perfeitamente bem. Vou até aqui
e clique na guia alt. Na verdade, posso ver meu
jogo ali com o ícone certo e o
nome deles, o canto. E isso é realmente muito
legal porque esse é o seu jogo em conclusão e
foi exportado corretamente, então tudo está funcionando bem. Se você executar algum erro de construção, poderá ter alguma falha no seu jogo que você
ainda não corrigiu. Eu recomendaria apenas ler. Eles estão pesquisando
na Internet e você deve encontrar alguém
que tenha a mesma área que você tem. Eu tive alguns avisos aqui quando estou viajando meu jogo. Obviamente, parece que o meu principalmente só porque
estou tentando usar uma textura inválida
para o meu cursor, o que obviamente
esperamos que isso aconteça. modo geral,
você não deve um modo geral,
você não deve
ter muitos desses
quando está construindo, mas às vezes você os obtém e não é culpa sua. Então, pode ser uma falha na Unity que já tive que
aconteceu comigo antes, mas fique de olho
em seus avisos. Obviamente, se você
tiver erros, não vai permitir que você
crie corretamente, então certifique-se de
corrigir qualquer um desses. E como eu disse, você
pode apenas pesquisá-los se não conseguir encontrar nenhuma solução. Mas esses são todos os conceitos básicos. Como você vai
construir sua comunidade? Obviamente, você pode ignorar
todas essas configurações
de inicialização clicando em construir e executar se não
for mudar. Então, é só para
testar seu jogo. E isso é tudo o
que você precisa saber sobre a construção de jogos no Unity. Isso realmente marca o fim do nosso último conceito básico de unidade. Espero que tudo
nos dentes faça um pouco mais de sentido. Agora, obviamente, não
fomos super aprofundados com nenhuma coisa específica, como física, animação ou sprites. Mas espero que o plano de fundo ou a base que
fornecemos com
todas as constantes que
cobrimos permitam que você crie anuidade de jogos
com muito mais facilidade. Como eu disse, muita
anuidade é apenas se familiarizar
com o motor e se acostumar com as coisas. E você deve ser capaz de
descobrir muito mais,
muito mais rápido agora que
você assistiu a este curso,
obviamente, há mais um vídeo de
conclusão depois disso. Vejo você
naquela esperançosamente. Mas quero agradecer
muito por fazer este curso e espero que
você tenha aprendido muito. Vejo você no próximo vídeo.
17. Conclusão: Ei lá, e bem-vindo de volta
ao vídeo final do meu curso. Muito obrigado
por me
permitir fornecer
o que eu esperava ser um guia útil centrado no básico do mecanismo de jogo
Unity. Aprender a usar um
mecanismo de jogo não é uma tarefa difícil, mas pode parecer
intimidante no início. Ao fazer este
curso, você construiu uma base para sua jornada de
desenvolvimento de jogos que lhe permitirá expandir seu
conhecimento de unidade e desenvolvimento de
jogos em geral
a um ritmo muito maior. Ao dedicar um tempo para
aprender o básico da unidade e como
todos eles trabalham juntos, você adquiriu o
conhecimento necessário para
começar a criar seu
primeiro jogo. Quero aproveitar esta
oportunidade para mais uma vez, obrigado por participar desta aula e vê-la
até o fim. Espero que você tenha achado
informativo e agradável. E tenho certeza de que as
habilidades que você aprende serão incrivelmente benéficas durante sua jornada de
desenvolvimento de jogos. Você ganhou conhecimentos e
habilidades incrivelmente
valiosos ao dedicar um tempo para
aprender o básico da unidade. Se você tiver algum
comentário ou dúvida, não hesite em postar um
comentário nesta página de cursos, e eu entrarei em contato com
você assim que puder. Além disso, se você
gostou deste curso, deixe um comentário, pois seu feedback permite que outras pessoas
obtenham uma
perspectiva mais aprofundada do que é abordado
neste curso e
me apoia muito também. Por favor, sinta-se
à vontade para me enviar qualquer comentário que você possa ter diretamente. De qualquer forma. Obrigado novamente por se
inscrever no meu curso. E não tenho dúvidas de que as habilidades que você aprende
serão incrivelmente valiosas
durante sua jornada de se tornar um desenvolvedor de jogos. Tenha um ótimo dia
e obrigado novamente.