Transcrições
1. Desenvolvimento de jogos Unity: esboço de iniciantes para profissionais: Meus amigos, meu nome
é Roan Masud. Bem-vindos a todos à série de tutoriais de jogos
com Unity. Deixe-me explicar quais são
todos os tópicos que abordaremos nesta série de
tutoriais em particular. Então, vamos começar com a instalação
e configuração do
Unity aqui. Além disso, continuaremos criando
o primeiro projeto e configurando o
Visual Studio com o Unity Isso abrangerá a criação de um script
C sharp no Unity, a
compreensão da estrutura
de um script C sharp
e, finalmente, a impressão de Hello
world no console do Unity. Além disso, vamos
continuar com tipos de dados, variáveis e
operadores em C Sharp, onde abordaremos um operador, operador
relacional, operador
lógico
e operador condicional Também estudaremos declarações de fluxo
de controle em CR, que abrangerão declarações de
tomada de decisão, declarações troca e declarações em
loop Também abordaremos um tópico
muito importante em R,
que são coleções em CR,
que incluirão lista, lista ordenada, matriz de
dicionário, lista com tabela e
pilha Posteriormente,
entenderemos a interface do usuário no Unity, que incluirá Canvas, texto, botões de
imagem, Scroll View, Inputfield, controle deslizante
e Anchor Prosseguindo, também
aprenderemos sobre os eventos do Unity, que terão funções de eventos e suas
funções personalizadas Em seguida, teremos delegados na Unity, que também
cobrirão carros individuais, delegados, multicasts delegados e delegados Além disso, vamos
entender o sistema de entrada Unity, que terá entradas de teclado, entradas mouse e entradas de acesso Em seguida, aprenderemos
sobre corpos rígidos e as colisões serão
introduzidas em corpos rígidos Teremos um exemplo
de corpo rígido. Crie um piso em um jogo
e mova uma esfera usando um corpo rígido ou um
corpo rígido preso a uma Novamente, em colisões serão introduzidos colisões
e colisões Teremos o Exemplo 1.2 para entender colisões
e colisões Além disso, vamos
apresentar a animação. Em seguida, teremos a animação de
um sprite, parte um, parte dois, parte três
e parte Mais tarde, entenderemos ou aprenderemos a animar um personagem de três D. Teremos a parte um, a parte dois e a parte três para o mesmo. Finalmente, para concluir a série, vamos criar um jogo chamado Knock the Cans in Unity,
no qual vamos
derrubar as latas usando uma lança
ou um Tudo bem pessoal, essa foi uma
breve visão geral da série. Vamos começar com a instalação do Unity na próxima sessão. Muito obrigado, pessoal. Te vejo na próxima
sessão. Muito obrigado
2. Introdução ao Unity e instatllation: Boa noite, pessoal. Meu nome
é Rohan S. Esta é a segunda sessão na qual vou
falar sobre o motor de jogo Unity e como instalar o Unity Então, o que é Unity? Antes de começarmos,
vamos saber que o Unity é um mecanismo de
jogo multiplataforma usado para criar jogos
2d3D de VR e AR Ok, então é um motor de jogo
multiplataforma. Ele suporta várias
plataformas, como Windows, sistema operacional
Mac,
Android e IOS. Por que Unity? Ok, agora também
existem outras plataformas. Também existem outros IDs
nos quais podemos trabalhar. Mas por que Unity? Por que o Unity
é tão preferido? Por que muitos desenvolvedores estão
usando o Unity Statistics, digamos que, em 2020, aplicativos feitos pela
Unity foram usados basicamente por 2 bilhões de usuários ativos
mensais, com 1,5 milhão de criadores
mensais. Ok, então 2 bilhões de jogadores estavam realmente jogando o
jogo feito usando Unity. Além disso, havia 1,5
milhão de criadores mensais. Então, entre todos os criadores trabalham em diferentes
plataformas para criar jogos, 1,5 milhão de criadores mensais
usaram Unity como ID, ok, como motor de jogo, para criar qualquer tipo de jogo. Seja um jogo de dois dias, pode
ser um jogo de três D, pode
ser um jogo de VR, pode ser um jogo de AR. Além disso, o Unity Engine vem com uma combinação de
vários ativos. Agora, existem alguns ativos
embutidos. Além disso, você pode baixar
ativos da loja de ativos. Como faço para instalar o Unity? De onde eu obtenho esse Unity? Está disponível gratuitamente? Ou o que devo fazer se
quiser começar com o Unity? Ok, basicamente para
começar com o Unity, você precisa simplesmente acessar
a página de download do Unity. Então, há um link
que eu vou colocar dentro
desta apresentação, dentro desta sessão, ok? E você pode ir nesse link
e seguir o procedimento, basicamente, esse é o
link para isso, ok? Então, é
ttpsstoverdtunity.com slash download. Portanto, há um botão
que fará o download do Unity Hub. Antes de baixar o motor Unity, você precisa baixar o Unity Hub. Clique no botão Baixar o
Unity Hub. Qual é o próximo processo? Está bem? Você abre o Unity
Hub e, em seguida, encontra uma guia dentro do
hub Unity que é install Tab. Você clica na instalação e
escolhe Instalado. Depois de clicar
na guia de instalação, você encontrará um botão de anúncio na seção
de instalação
do hub Unity. Está bem? Clique no botão do anúncio e você verá
algo parecido com isso. Ok, é quando você escolhe
instalações no Unity Hub. Ok, aqui eu
cliquei em instalações. E então você pode ver
na extrema direita que há um botão que é um botão de anúncio. Você só precisa clicar nisso. E quando você clica
no botão do anúncio, é
isso que vai abrir. Está bem? Você só precisa
selecionar a versão, qual versão do Unity
você deseja baixar. E então você precisa seguir as etapas para instalar
o editor
Unity ou o Unity Engine em seu laptop ou Dextop É isso aí, pessoal. Muito obrigado pela sessão.
Muito obrigado
3. Crie meu primeiro projeto 3D no Unity: Boa noite, pessoal. Meu
nome é Rohan Vsdev e, nesta sessão,
vou ensinar como
criar três
projetos em D Ok, então eu já
abri meu Unity Hub. Minha versão para o
hub Unity é 2.4 0.5 Ok, então há uma nova versão
disponível que é 3.2 0.0, mas vou usar para fins de demonstração
a versão 2.4 0.5 Então, como criar
um projeto no Unity. Agora, na última
sessão, vimos como
instalar o Unity Engine
e também o Unity Hub. Então, eu já abri meu hub
Unity para criar um projeto. Eu só tenho que ir aqui para
criar um projeto que é novo. Ok, eu só tenho que clicar aqui. Preciso selecionar minha versão. Para fins de
demonstração, vou usar a
versão 2.019.3 do Unity. Ok, eu só preciso clicar aqui No momento, quero
criar um projeto em três D. Ok, aqui vou ter que colocar
o nome do projeto. Ok, vou
mudar o nome aqui. Primeiro, Unity Demo. Esse é o nome do meu projeto. O local no qual meu projeto está sendo
armazenado é o D Drive. Você pode alterar o local se quiser armazenar o projeto no Drive ou em qualquer local em que queira
armazenar seu projeto. Eu só tenho que
clicar neste botão Criar. Ok, agora isso
abrirá seu Unity Engine. Esta é a
cena de amostra que foi criada quando você cria
um projeto Unity Renomear o nome do sênior mudará o
nome da cena Basicamente, como fazer isso. Ok, basta clicar com o botão direito
aqui na cena de amostra. Selecione Salvar cena a partir daqui. Ok, salve essa cena
na pasta de cenas. Ok, então minha primeira cena,
vamos salvá-la. Todos vocês podem ver aqui que o nome da cena
foi alterado agora. É minha primeira cena agora. Vamos entrar nas cenas. E aqui está nossa cena,
minha primeira cena. Ok, é isso aí, pessoal. Muito obrigado
pela sessão. Nos vemos na próxima sessão.
4. Configurar o Visual Studio no Unity e prepare-se para scripts: Boa noite, amigos. Meu
nome é Rohan Asda e vou explicar como
configurar o Visual
Studio com Então, o que é o Visual Studio? É um ambiente de
desenvolvimento integrado, que é o IDE, desenvolvido pela Microsoft, usado para desenvolver interfaces de usuário, aplicativos
web, aplicativos
móveis e aplicativos baseados em nuvem. Além disso, o código pode ser
escrito em C, Sharp, C plus plus, Visual, Basic, Python e muitas
outras No total, o Visual Studio
oferece suporte a 32 idiomas. Visual Studio
também está disponível para os sistemas
operacionais Windows e Mac. Portanto, há três adições
para o Microsoft Visual Studio, e elas são as seguintes,
como podemos ver aqui primeira é a
Community Edition, que é uma versão gratuita. Qualquer
desenvolvedor individual pode basicamente desenvolver
aplicativos gratuitos ou pagos usando isso. Os recursos são mais ou menos semelhantes aos do
Professional Addition. Professional Addition é uma versão
paga e comercial. Você precisa pagar se quiser
baixar ou instalar. Basicamente, eles
oferecem um teste gratuito. Mas quando o teste gratuito terminar, você
precisará pagar pelo Professional,
tanto
para adições profissionais quanto
corporativas Quais são as etapas, basicamente, para instalar o Visual
Studio no Unity? Ok, a primeira etapa
é simplesmente acessar a
página de download do Microsoft Visual
Studio. Eu coloquei um link aqui. Esse é o link para isso. Agora, a seguir, depois de acessar este link, depois de acessar este link, você encontrará um botão que
é Baixar o Visual Studio. Basta
clicar no botão, que o levará
para outra página. Ok, onde você pode
realmente escolher a versão do Visual Studio
que
deseja instalar ou baixar. Depois de clicar no botão
anterior,
você será direcionado para sttpsvisualtudiotmicrosoft.com Ok, e é assim
que a página ficará. Este é o Visual Studio 2022. Também existem outras opções. Se quiser, você pode
baixar o Visual Studio 2019. Além disso, quando você chegar
aqui nesta página, na página
de download do Visual Studio, tudo bem, você precisa clicar
no download gratuito
da versão comunitária, porque vamos
usar uma versão gratuita aqui. Não vamos usar versões
profissionais ou
corporativas por causa de uma versão paga. Então, vamos
clicar no botão, que é um download gratuito. E depois de clicar nesse
botão, o que acontecerá a seguir? É muito simples, vai começar a
instalar o instalador. Portanto, o instalador do Visual Studio basicamente
será instalado, o que será um arquivo EX. Então você só precisa clicar nesse arquivo EX e iniciar
o processo de instalação. Assim que o
processo de instalação for iniciado, você verá algo parecido com
isso, essa tela específica. E nesta tela você
verá uma verificação da carga de trabalho. Aqui, você só precisa
selecionar uma guia de carga de trabalho. Ok, na guia de carga de trabalho, você precisa verificar o
desenvolvimento do jogo com o Unity aqui Ok, essa é uma parte muito
importante ao instalar o dual
studio para Unity. Então você só precisa verificar isso. E então, uma vez
clicado ou marcado, basta clicar no botão de instalação para continuar com o processo de
instalação Crie um novo projeto
usando o Unity Hub. Depois que o projeto for criado, você encontrará a opção de edição. Dentro do editor Unity, basta clicar
na opção Editar e selecionar
a opção Preferências. Então, quando você clicar
na opção Preferências, ela abrirá uma janela pop-up, que será uma ferramenta externa. Aqui, ele abrirá
algo assim. Está bem? Agora, dentro da janela
Preferências, você terá que selecionar ferramentas
externas aqui. Está bem? Então, depois de clicar
nas ferramentas externas, o que você precisará fazer é acessar o editor de script externo, anexar a
versão que acabou de baixar,
que era o studio 2019. Então, uma vez
feito isso daqui em diante, o que precisamos fazer é
acessar a guia do Windows dentro
do editor do Unity e
selecionar Gerenciador de pacotes. Depois de clicar no
Gerenciador de Pacotes na guia da janela, você verá uma tela como essa e
precisará digitar Visual Studio co aqui
na caixa de pesquisa ou apenas
digitando visual, você encontrará o pacote
nomeado pelo editor de código do Visual
Studio Você só precisa verificar isso. E depois que esse
processo estiver concluído, você estará livre para realmente usar Visual Studio ou o C Sharp
dentro do seu editor Unity. Obrigado pessoal pela sessão. Te vejo
na próxima sessão. Muito obrigado, pessoal.
5. Crie meu primeiro roteiro C# no Unity: Boa noite, pessoal.
Meu nome é Roan Estamos na última sessão, todos
vimos como instalamos o
Visual Studio no Unity. Agora, nesta sessão, vou
lhe dizer como realmente
criar um
script C sharp dentro do Unity. Primeiro, temos uma pasta
Assets aqui. Você pode clicar
na pasta Assets e escolher a pasta Assets. Agora, para manter tudo organizado e manter todos os scripts
dentro de uma pasta, o que vamos fazer
aqui é criar uma pasta
dentro dessa pasta. Ok, temos que escrever clique aqui e depois
clique em Criar. Então você precisa escolher a opção de
pasta aqui. Não queremos que seja uma
pasta nova, então vamos apenas
renomeá-la como scripts Ok, agora vamos abrir
a pasta de scripts. Está bem? Clique duas vezes
na pasta de scripts. Como criar um script. Agora, dentro da
pasta de scripts, é muito simples. Basta escrever, clique aqui com o mouse
e depois vá para Criar. Novamente, na última vez que
criamos uma pasta, escolhemos a opção de pasta. OK. Mas desta vez
vamos criar um script. Temos um roteiro preciso. Basta clicar no script C
sharp, ok. Agora você precisa renomeá-lo. Por padrão, o nome
do script será
novo script de comportamento, mas não queremos que seja assim porque queremos
renomear o script Agora vamos renomeá-lo
como meu primeiro script. Ok, seu script
foi criado agora. Agora, basta clicar
no script para abri-lo. Isso é um pessoal, até
a próxima sessão. Muito obrigado, pessoal.
6. Entendendo o fluxo e a estrutura de um roteiro C# - Parte 1: Boa noite, pessoal. Meu
nome é Rohan Dev Na sessão anterior, vimos como criar um script C
sharp no Unity. Como todos podemos ver aqui, essa classe no Unity é o
modelo do seu objeto Agora, todos os scripts no Unity sempre
começarão com
uma declaração de classe. E essa classe é criada
automaticamente quando você cria um
script C sharp dentro do Unity. O nome da classe,
como todos podemos ver aqui, meu primeiro script será sempre igual ao
nome do seu script. Quando criamos um
script pela última vez, o nome do script que
mantivemos foi meu primeiro script, então será o
nome da classe,
então sempre será o mesmo. O que é coleta de pontos do sistema? Coleções de pontos do sistema, ou
Generic And Unity Engine, basicamente
são todos namespaces, que são uma coleção
de classes Unity, a
classe monobehavior aqui, incluindo todos os outros recursos
principais do Unity, está no namespace do mecanismo Unity Ok, então o Unity Engine
basicamente também terá todos os recursos principais
e a classe de monocomportamento do Unity e a classe de monocomportamento Geralmente, quando você
cria um script, há cinco
aspectos importantes no script. Então, quais são esses aspectos? Primeiro, essa palavra-chave pública, depois vem sua classe. O quarto é o
nome do script ou o nome da classe. Depois vem o cólon
e o comportamento mono. Vamos primeiro entender
o que é público aqui. Por exemplo, suponha que
haja dois scripts. E você quer que um script
interaja com outro script. Tornar qualquer coisa pública significa que ela pode ser acessada
por outro script. Além disso, essa
classe específica poderá ser acessada por outra classe ou por outro script do Unity. Agora todos nós podemos ver
o comportamento mono aqui. O que é comportamento mono? O comportamento mono é uma classe base para todos os scripts, basicamente E esses dois pontos significam que
ele herda, simplesmente
significa, ok, todos os scripts
que criamos no Unity C Sharp são herdados
da Aqui na próxima sessão, eu vou te dizer quais
são essas funções,
que são o início vazio
e a atualização nula Ok, eles
também são
criados automaticamente quando criamos
um script nítido do Unity C. Obrigado pela sessão. Te vejo
na próxima sessão. Muito obrigado
7. Entendendo o fluxo e a estrutura de um roteiro C# - Parte 2: Olá pessoal, meu nome
é Rohan Vasudev. Nesta sessão, veremos
o que é início anulado e atualização anulada Vamos ver primeiro o que é vazio. Void é o
tipo de retorno, então, neste caso, a função inicial aqui criada não
está retornando nada A função de início é
basicamente chamada quando o quadro da
cena é criado. Um quadro é apenas
uma imagem estática. Todas essas imagens, juntas
em rápida sucessão, criarão um movimento
para o jogo O início é chamado quando
o primeiro quadro do jogo é criado. Ele só é executado se
o script estiver ativado. Se o script não estiver ativado. Se estiver desativado e a função de início não
for executada de forma alguma. Também é chamado de
ciclo de vida único da calha do eixo. Portanto, há um ciclo de vida para a função de início do script
Unity
seja chamada apenas uma vez
no ciclo de vida. Para que é usada a função de início? A função Start é
usada para inicializar propriedades ou variáveis do
objeto Qualquer variável que você
queira inicializar ou qualquer propriedade de objeto que você
queira inicializar, você sempre pode inicializar
dentro da Vamos falar sobre a função de
atualização aqui. Novamente, temos
void aqui, que é um tipo de retorno para
a função de atualização Portanto, essa função de atualização
não retornará nada. A função de atualização é chamada somente após a execução da
função inicial. A função de atualização executa cada
quadro do jogo ou o visto. Está bem? Portanto, será
chamado de cada quadro A
execução da função de atualização depende da
taxa de quadros do jogo. taxa de quadros
significa simplesmente quantos quadros geralmente
são criados ou chamados a cada
60 segundos ou mais? Geralmente, o que acontece aqui é quanto maior a
taxa de quadros do jogo, o intervalo de tempo entre a função de atualização
será baixo, a chamada de uma
função de atualização
depende completamente da
taxa de quadros do seu jogo. É isso aí, pessoal.
Obrigado pela sessão. Nos vemos na
próxima sessão.
8. Escreva o primeiro código em C# e imprima 'Hello Code': Olá pessoal, meu nome é Rohan Vasudev e nesta
sessão vou
explicar como imprimir o código Hello dentro do console Então, para começar, teremos que criar
um objeto de jogo vazio. Tudo no Unity é
basicamente um objeto de jogo. Então, neste caso, teremos que criar um objeto de
jogo vazio aqui. Então, como criamos um objeto de jogo
vazio aqui? Ok, então para esse propósito, basta clicar com o botão direito na sua cena, que é minha primeira cena. Escolha o objeto do jogo aqui e escolha Criar vazio. Dessa forma, criaremos
um objeto de jogo vazio. O nome do objeto de jogo
vazio por padrão será objeto de jogo. Vamos apenas renomeá-lo como
meu primeiro objeto de jogo. Vamos anexar o script, que é meu primeiro script aqui, que criamos
nas sessões anteriores, a esse objeto do jogo. Não precisamos de uma função de
atualização aqui. Vamos apenas remover essa
função porque
vamos escrever nosso código
dentro da função inicial. Vamos começar
escrevendo um código aqui. Vou usar a função de registro de
depuração no Unity para imprimir o código hello Isso termina com um semicler. Debug dot log basicamente é uma função dentro do Unity
na qual você
terá que passar uma
string aqui e isso imprimirá o código hello
dentro do console do Unity Vamos salvar o script. Basta clicar no meu
primeiro objeto de jogo e escolher o console aqui. Basta clicar em Adicionar componente, botão aqui e adicionar o script
a esse objeto vazio do jogo. Ok, clique em Adicionar componente
e digite meu primeiro. Na busca, você
encontrará o script. Clique no meu primeiro
script e o script será anexado ao seu objeto de jogo
vazio. No nosso caso, é meu
primeiro objeto de jogo. Ok, agora salve a cena e execute clicando
neste botão de reprodução aqui. E aqui imprimimos o
código Hello dentro do console Unity. É isso aí, pessoal. Muito
obrigado pela sessão. Nos vemos na próxima
sessão. Muito obrigado.
9. Entendendo os tipos de dados e as variáveis no Unity C#: Olá amigos, meu nome é Rohan. Claro. E nesta sessão,
vou explicar os tipos e variáveis de dados
em C Sharp e Unity. Um tipo de dados especifica
o tipo de dados. Esses dados podem ser uma string, um número inteiro, um ouro, flutuador
ou um Novamente, dependendo do
valor aceito ou do tipo de dados, várias operações
podem ser executadas
nessa sequência de dados específica. O tipo de dados é usado para armazenar
seqüências de caracteres, números, caracteres na
forma de palavras ou frases. Um valor de um tipo de dados de string é incluído em códigos duplos É sempre colocado
dentro de códigos duplos. O outro tipo de dados
é seu tipo de dados, que é usado para armazenar números inteiros de
32 bits Os números geralmente são números
inteiros,
que também incluem números positivos e
negativos. Novamente, temos um tipo de dados
flutuante, que é usado para armazenar números de ponto
flutuante, também
é usado para armazenar números de ponto
flutuante Mas a única diferença entre um carro alegórico
e duplo é que o
duplo armazena
números de tamanho maiores do que o carro alegórico Novamente, temos um
tipo de dados completo que geralmente é usado para armazenar valores verdadeiros
ou falsos, geralmente usado para Essa informação pode
ser o nome do jogador, um placar ou um inferno. Agora, o valor atribuído a uma
variável sempre pode ser alterado, modificado durante a
execução de um programa Novamente, quando uma
variável é criada, algum espaço na memória
é alocado A declaração de uma variável
sempre começa com um tipo de dados seguido
pelo nome da variável. Aqui está meu editor. Já criamos
um objeto de jogo vazio. Eu renomeei esse objeto de jogo
vazio
para objeto de variáveis Novamente, eu criei um script. Aqui, o nome do
script são minhas variáveis. Vamos abrir o
script e declarar algumas variáveis
dentro do script Primeiro, vamos declarar
uma variável de string. Está bem? O primeiro nome é igual a, vamos atribuir um valor
à variável Ok, Danny, na
declaração de uma variável, string é o tipo de dados, primeiro nome é o
nome da variável e Danny é o valor atribuído à variável, primeiro OK. Agora vamos declarar uma
variável com tipo de dados Ok, vamos
chamá-lo de número um. Vamos atribuir um valor. Vamos declarar uma variável
com tipo de dados flutuante. Vamos chamá-lo de número dois. E vamos atribuir um
valor 10,5 Agora vamos declarar uma variável com
um tipo de dados com o
número duplo três igual a. Por fim, vamos declarar
uma variável com
um tipo de dados bull val Meu val é o nome
da variável. Vamos atribuir o valor verdadeiro
às variáveis variáveis que
declaramos aqui. Vamos imprimir essas
variáveis dentro do console. Vamos começar a imprimir os
valores das variáveis. Ok, só precisamos passar o nome da variável aqui. Vamos salvar o script e anexar esse script ao objeto
do jogo que
criamos aqui, que é o objeto de variáveis. Ok, aqui está.
Então é isso, pessoal. Obrigado pela
sessão. Nos vemos na próxima sessão.
Muito obrigado
10. Introdução aos operadores no Unity C#: Oi pessoal. Meu nome é Rohan
Vasudev e nesta sessão vou explicar para você o
que são operadores Operadores nítidos são simples
especiais ou um caractere que executa
algumas ações em operandos ou variáveis basicamente
representa uma ação ou um processo que fazemos
em variáveis ou operandos Os operadores são a base de
qualquer linguagem de programação. Agora, sem a
existência de operadores, qualquer linguagem de programação estaria
basicamente incompleta. Agora, quais são os tipos de operadores? Quantos tipos de operadores
existem no Unity? Afiado? Vamos ver. O primeiro são seus operadores
aritméticos. Então temos operadores
relacionais,
depois temos operadores lógicos,
depois temos operadores de
atribuição
e operadores condicionais Vamos primeiro ver o que são operadores
aritméticos? O que são operadores aritméticos? Os operadores aritméticos
geralmente são usados para realizar operações
matemáticas
em variáveis Agora, existem alguns tipos
de operadores aritméticos. O primeiro é seu operador de
adição. O operador de adição é usado para calcular adições de dois
operandos Com esse operador, podemos basicamente adicionar dois
operandos ou variáveis Também pode ser usado para concatenação de duas
variáveis de string Por exemplo, se tivermos
um int a igual a cinco e int B
definido com o valor de dez
, a saída para a
adição seria 15 Basicamente, ele calcula
uma adição básica de duas variáveis ou operandos O próximo é seu operador de
subtração. operador de subtração
é usado para subtrair novamente o operando direito do operando
esquerdo O terceiro é seu operador de
multiplicação, onde na verdade calculamos multiplicação de
operandos Temos um
operador de divisão que divide o mão esquerda pelo
operando da mão direita Novamente, é seu
operador de módulo que retorna o restante quando o operando esquerdo é dividido pelo operando direito Portanto, se você realizar a divisão
, o restante
obtido será sua saída
dentro do console Agora vamos entrar no
editor Unity e ver como
realmente realizamos algumas ações
usando operadores aritméticos
11. Entendendo os operadores aritméticos e seu uso: Pessoal, nós gostamos do Unity Editor. Agora, como todos podem ver, eu já criei
um objeto de jogo vazio
que é o objeto do operador. E, novamente, eu criei um script C sharp que
é composto por operadores aritméticos Agora, para realizar algumas
ações ou cálculos, vamos abrir o script
que criamos, que é operadores aritméticos
em A igual a cinco,
em B igual a em Ok, bug dot log A plus, este é o seu operador de adição. Este é um código comentado. Basicamente, ele não
executará o log de depuração. Ok, vamos subtrair a de B menos o log de depuração d aqui, aqui está Vamos continuar com os operadores de
tópicos na próxima sessão.
Muito obrigado
12. Entendendo os operadores relacionais e seu uso: Oi amigos. Meu nome
é Rohan Vase Na última sessão,
vimos operadores aritméticos. Nesta sessão,
aprenderemos sobre operadores
relacionais O que são operadores relacionais? Operadores relacionais
são usados para comparar dois valores ou
variáveis, ou operan Agora, quais são os tipos
de operadores relacionais? O primeiro operador relacional
é igual a igual ao operador é usado para verificar se dois valores
são iguais ou não Se os dois valores forem iguais, ele retornará verdadeiro. Ou, se não forem iguais, ele retornará false. Por exemplo, se
tivermos duas variáveis em A igual a cinco e
em b igual a cinco, o resultado
será bool Estamos armazenando o valor em
uma variável chamada resultado. Está bem? Estamos verificando aqui se as duas variáveis têm os mesmos valores e
como estamos fazendo isso. Estamos fazendo isso usando
igual ao operador, ok? Nesse caso, cinco
é igual a cinco, a saída será verdadeira agora. Em seguida, você não é igual
ao operador, ok? operador Não igual ao é usado para verificar se dois valores
são iguais ou não. Agora, se os dois
valores não forem iguais, ele retornará dois,
caso contrário, cairá, então teremos um operador
maior que. O operador maior que é usado
basicamente para verificar se o operando esquerdo é maior que o operando
direito Por exemplo, se tivermos
uma variável a cujo valor é definido como 50 e uma variável
cujo valor é definido como dez. Então, o resultado em negrito
para um maior que
neste caso será dois porque
50 é maior que dez. Agora vamos passar para
o próximo operador, que é menor que o operador. Menor que o operador é
basicamente usado para verificar se o operando esquerdo é menor que a marca da mão
direita levantada Nesse caso, definimos o valor de A como 50
e um valor de 210. Obviamente, uma
queda menor do que é, porque 50 não é menor do que a saída
deste
exemplo específico, serão Novamente, temos
maior que igual a, maior que igual ao
operador que é usado para verificar se o oprando esquerdo é
maior ou igual à marca da mão
direita Ele verificará, em ambas
as condições, se é maior ou igual
ao operando do lado direito O último operador relacional
será ou menor que, igual a, menor que igual a. O operador é usado para verificar se a marca da mão esquerda é
menor ou igual à marca da mão
direita Neste exemplo, estamos verificando aqui o valor de A
que está definido como dez e o valor de cujo valor
está definido como dez novamente. Ok, estamos verificando aqui se é menor ou igual a b, mas neste caso a não é
menor do que é igual a, obviamente trará
a saída como verdadeira Agora vamos entrar
no editor e
escrever um trecho de código e imprimir os
valores no editor. Ok pessoal, então eu estou
no editor Unity agora e já criei
um objeto do operador aqui. Este é um objeto de jogo vazio. E também criei
um script C sharp,
que é um script de
operadores relacionais Nomeei o script como operadores
relacionais e anexei o script ao objeto do
operador Aqui Vamos abrir o script
e ver o código. Ok, então já
escrevemos um código aqui. Declaramos uma variável
que está em a igual a cinco e uma variável
do tipo de dados inc, e o valor da
variável é definido como dez E declaramos uma
variável bool aqui, result. E não definimos nenhum valor
aqui para a variável bool. Agora, dentro da
função start, primeiramente, estamos verificando se
a é igual a b. Em seguida, o valor
do resultado
será atribuído à Como a saída para
isso será uma saída Bo, estamos atribuindo essa saída ao resultado
da variável bool Por fim, estamos verificando se a é menor ou
igual a B ou não, e o valor é atribuído
à variável de resultado Agora vamos executar esse código e ver a
saída do núcleo. É isso aí pessoal, vamos continuar os operadores
na próxima sessão. Nos vemos na próxima
sessão. Muito obrigada.
13. Entendendo os operadores lógicos e seu uso: Olá amigos, meu nome é Rohan
V. Na última sessão, aprendemos sobre operadores
relacionais Nesta sessão,
aprenderemos sobre operadores lógicos. O que são operadores lógicos? Os operadores lógicos são usados para combinar duas ou mais condições ou declarações
relacionais e
retornam o valor do pullion O operador lógico
sempre extrairá valor. Quais são os tipos de operadores
lógicos? O primeiro é seu operador lógico. operador lógico verificará se todas as condições
são verdadeiras ou não. Ele só retorna verdadeiro se todas
as condições forem verdadeiras e retorna falso
se uma
das declarações
ou condições relacionais for falsa Em seguida, passe para o
próximo operador lógico, que é seu operador lógico. lógica ou o operador
verificam se pelo menos uma das condições é verdadeira
ou não retorna verdadeira. Se uma ou todas as declarações
ou condições
relacionais forem verdadeiras e os retornos cairão somente quando
todas as condições forem falsas Por fim, temos o operador
lógico. operador lógico retorna verdadeiro se a condição não
for satisfeita. Agora vamos entrar
no editor Unity e
escrever um trecho de código. Ok pessoal, eu estou no editor
Unity agora, então eu já criei o objeto do
operador aqui, que é um objeto de jogo vazio. Então eu já criei
um script aqui que é script de operadores
lógicos e já anexei o script ao
objeto do operador. Vamos abrir o script
e ver o núcleo aqui. Pessoal, já declaramos aqui
uma variável bull x, cujo valor está definido como verdadeiro. Já declaramos uma
variável bull y cujo valor
está definido como falso. Já declaramos
novamente um resultado variável de alta. E ainda não atribuímos nenhum
valor ao resultado. Está bem? Agora, dentro
da função de início, este operador e
aqui verificarão se as variáveis
x e y são verdadeiras ou não. Mas, nesse caso, a
variável x é verdadeira, essa variável y é falsa. Portanto, a produção
aqui será de quedas. A saída é então atribuída
ao resultado da variável pool aqui
e, em seguida, impressa
no console. O operador R aqui
verificará se pelo menos um
dos valores das variáveis
x e y é verdadeiro ou não. Nesse caso, o valor
da variável x é verdadeiro,
portanto, a saída
aqui será verdadeira. A saída é então atribuída
novamente
ao resultado da variável bull e é impressa
no console aqui. Ok, agora já
vimos que o resultado
do operador é falso, mas estamos usando um operador de
nó aqui O operador de nó retorna verdadeiro
se a condição for falsa,
portanto, a saída aqui
será verdadeira. Esse valor, Essa saída é então atribuída novamente ao
resultado da variável aqui
e, por fim, impressa no console usando
a função bug
dot log Agora vamos executar esse código e ver a saída dentro do console
do Unity.
Vamos executar o código. Ok, é isso mesmo. E o operador
está me dando uma saída falsa ou o operador
aqui está me dando uma saída verdadeira e
não o operador aqui. Por fim, está me dando
uma saída verdadeira. Então é isso, pessoal. Isso é
tudo para a sessão. Nos vemos na
próxima sessão. Continuaremos com os operadores de
tópicos
na próxima sessão. Muito obrigado, pessoal.
14. Entendendo os operadores condicionais e seu uso: Meus amigos, meu nome
é Rohan Masdev. Na última sessão,
vimos operadores lógicos. Nesta sessão,
aprenderemos sobre operadores
condicionais O que são operadores condicionais? Os operadores condicionais
têm três operandos. A sintaxe dos
operadores condicionais é a seguinte. A primeira será
sua condição. Depois, há uma
primeira expressão e depois vem uma
segunda expressão. Agora, como esse
operador condicional tem três operandos, ele também é chamado de operador
ternário Geralmente, a forma como
funciona é, em primeiro lugar
, avaliar a condição aqui Agora, se a condição for verdadeira, a primeira expressão será avaliada
e se tornará a saída. E se a condição for falsa, a segunda expressão será
avaliada e
se tornará a saída. Vamos entrar no editor Unity e escrever um trecho de código. Ok pessoal, nós gostamos
do Unity Editor. Agora, eu já criei
um objeto de jogo vazio, que é o objeto do operador. E eu já criei um script que é um operador
condicional Vamos abrir o script e ver o código aqui. Agora, já declaramos uma variável a que
é do tipo de dados int e o valor está definido como cinco. Também declaramos a
variável do tipo de dados end e o valor está definido como dez. Também declaramos um resultado
de variável de e não atribuímos
nenhum valor a ela inicialmente. Agora, dentro da função de início, estamos verificando se
a é maior que. Basicamente, aplicamos uma
condição aqui para verificar se é maior do que se
a condição é verdadeira. Então, a primeira expressão
que é verdadeira aqui, que é um bool verdadeiro aqui, será atribuída ao resultado
da variável Se a condição for falsa, a segunda expressão
que é falsa aqui será atribuída ao resultado da
variável aqui. A saída será
então impressa no console
do Unity usando a função
debug dot log Da mesma forma, aqui estamos verificando se a é menor que B, o valor de a é menor que B. E se a condição for verdadeira, a primeira expressão
verdadeira
será atribuída ao resultado
da variável E se a condição for falsa, a segunda
expressão que for falsa será atribuída ao resultado
da variável aqui e será impressa no console
do Unity usando a função
debug dot log Vamos executar o código
no editor e ver
a saída
do código, aqui está, pessoal. A saída do código, a maior que é falsa, menor que B é verdadeira. É isso aí, pessoal.
Obrigado pela sessão. Nos vemos na próxima
sessão. Muito obrigado
15. Introdução à declaração de fluxo de controle no Unity C#: Oi amigos. Meu
nome é Rohan Dev e, nesta sessão,
aprenderemos sobre declarações de fluxo de
controle
em Unity, C Sharp O que são
declarações de fluxo de controle em C Sharp? As declarações de fluxo de controle são
as instruções que alteram alteram ou modificam o fluxo
de um programa ou do código. Ele fornece melhor controle sobre o fluxo de execução de um código. Programas mais complexos também podem ser escritos usando instruções de
fluxo de controle. Agora, o programa é executado de cima para baixo
na ordem em que foi escrito. As instruções de fluxo de controle podem modificar o fluxo da
execução de um programa. O código que é executado
de cima para baixo pode ser modificado usando instruções
de fluxo de controle. Obrigado pela sessão. Te vejo na próxima
sessão. Muito obrigado
16. Entendendo as declarações if-no Unity C#: Oi amigos. Meu nome é Rohan
Dev e, nesta sessão, aprenderemos sobre declarações de fluxo
controlado na loja Unity Agora, quais são os tipos de declarações de fluxo de
controle? A primeira são suas declarações de
tomada de decisão. Temos declarações switch
e, em seguida, temos declarações em
loop. O que são declarações de
tomada de decisão? As declarações de tomada de decisão são semelhantes às da
tomada de decisões. Na sua vida real, ele executará determinado
bloco de código se a condição for verdadeira
ou satisfeita. A declaração if verifica
a condição. Se a condição for verdadeira, o bloco de
código será executado,
caso contrário, não será executado. Vamos entrar no editor
Unity e escrever um trecho de
código para uma declaração if. Pessoal, já declaramos aqui
uma variável de saúde do jogador, que é do tipo de dados end, e o valor está definido como 30. Dentro da função de partida,
há uma condição F, e estamos verificando se saúde do
jogador é
menor que 50 ou não Se a saúde do jogador
for menor que 50, então vamos
imprimir no console: “A saúde do
jogador é para verificar Então, temos nossa saída aqui
dentro do console do Unity. Obrigado pela sessão. Nos vemos na próxima
sessão. Muito obrigado.
17. Entendendo as declarações if-else no Unity C#: Olá amigos, meu nome é Rohan
Dev e nesta sessão
vamos aprender sobre declarações de
fluxo de controle no
Unity. C afiado. Se as declarações
verificarem a condição. E se a condição for verdadeira, o bloco de
código dentro da instrução
if será executado. Mas e se a
condição for falsa? Nesse caso, o código dentro da instrução L
será executado. A declaração L diz ao núcleo o que fazer se
a condição for falsa. Novamente, declaramos uma
variável do tipo de dados int, que é a saúde do jogador, e o valor está definido como 70. Dentro da função de início, estamos verificando se
a saúde do jogador, o valor da saúde do jogador
é menor que 50 ou não Se a condição for verdadeira, vamos imprimir que a saúde
dos jogadores está muito baixa
no console do Unity. E se a condição
aqui for falsa, então a saúde do jogador está boa será impressa dentro
do console Unity. Gente, aqui está.
Aqui está o resultado: A saúde
dos jogadores está boa. Obrigado pela sessão. Nos vemos na próxima
sessão. Muito obrigado
18. Entendendo as declarações de escada if-else-if no Unity C#: Oi amigos. Meu nome é Rohan
Dev e, nesta sessão, aprenderemos sobre declarações de
fluxo de controle no Unity C sharp Se a declaração da escada verificar
cada condição if, todas as declarações serão
verificadas de cima para baixo primeira condição
será verificada primeiro, depois a segunda condição
será verificada, depois ela passa para a terceira
e assim por diante. O código dentro da instrução
if é executado e é
avaliado como verdadeiro Somente o código ou
o bloco de código dentro da instrução if L
será executado, o que será verdadeiro. Se nenhuma das
condições if for verdadeira, o último bloco de L
será executado aqui. Agora, a saúde do jogador está
definida no valor de 50. Dentro da função de início, temos uma condição if. Dentro da condição if, estamos verificando onde a saúde do jogador é
maior que igual a 80 e a saúde do jogador é menor ou
menor que igual a 200 E se a condição for verdadeira, vamos imprimir que a saúde
dos jogadores está ótima. Se a condição estiver aqui, ela passa para
a declaração L aqui. Agora, novamente, ele verifica se a saúde do
jogador é maior do que igual a 60 e saúde do
jogador é
menor do que igual a 79. Agora, se a condição
for verdadeira aqui, esse bloco de
código será executado. Caso contrário, se for falsa, ela passa para
a próxima afirmação, que é a saúde do jogador
maior que igual a 40 e a saúde do jogador
menor que igual a 59 Novamente, se a condição
for verdadeira aqui, o bloco de
código será executado e a saúde do jogador não estiver boa será impressa no console
do Unity. Se a condição for falsa aqui, ela passa para
a declaração L. E, finalmente, se todas as
condições caírem aqui. Por fim, o código
dentro da instrução L, saúde do
jogador está
em mau estado, será impresso no console
do Unity Agora vamos executar o código
e ver a saída. No console Unity, jogadores, saúde não é boa,
então aqui está. Aqui está a saída. Obrigado pela sessão. Nos vemos na próxima
sessão. Muito obrigado
19. Entendendo as declarações de casos de interrupção no Unity C#: Amigos, meu nome é Rohan Dev. Na última sessão, falamos sobre declarações de
tomada de decisão. Nesta sessão,
falaremos sobre as declarações switch. O que são declarações switch? As instruções Switch
são uma alternativa
às declarações FLSA ladder. A declaração Switch case é
uma declaração de seleção. Aqui está a sintaxe de uma declaração switch case
em que temos uma palavra-chave switch e, em seguida, temos que colocar a expressão
dentro do colchete
e, em seguida, temos Agora, o bloco de
código ou instrução é executado se a expressão
corresponder a um dos valores de
maiúsculas e minúsculas ou expressões. Novamente, temos uma palavra-chave
break aqui. Agora, essa instrução de interrupção
é usada para sair
da opção quando a expressão corresponder a um dos casos Quando o valor
da expressão corresponder ao
valor do caso, a instrução de interrupção
será
usada e a opção será encerrada. O switch continuará
verificando todos os casos até que a instrução break seja
encontrada ou o switch termine. Agora, por fim, se nenhum
dos casos corresponder
à expressão
, o último padrão será
executado e o bloco de código dentro do caso padrão será
impresso ou executado Novamente, o switch é encerrado usando a instrução break
no caso padrão. Agora vamos entrar
no editor Unity e
escrever um trecho de código. Agora pessoal, estamos aqui
no editor Unity. Criamos um objeto de jogo
vazio. Também criamos
um script de eixo. E o nome do
script é Switch Case. Vamos abrir o script
Switch Case. E vamos dar uma
olhada no lado do código. No script, já
declaramos uma variável, saúde do
jogador, e
o valor está definido como 20. Dentro da função de início, já
declaramos a saúde dos jogadores em caso de
troca. Aqui está uma expressão que o caso dez verificará se o valor da
saúde do jogo é
igual a dez ou não. Se o valor de plays
health for igual a dez, o bloco do núcleo, que
é o caso dez, será executado, será impresso no console
do Unity e a instrução break
encerrará o switch. Se o valor não
corresponder à expressão
, ele
passará para o caso 20. caso 20 verificará se o valor da saúde dos flares é
igual a 20 ou não Se o valor de flares
health for igual a 20, o bloco do núcleo, que
é o caso 20, será executado, será impresso no console
do Unity e a instrução break
encerrará a troca Se o valor dos jogadores não for igual a 20, ele passará
para o caso padrão. E o caso padrão
executado será impresso
no console do Unity. Por fim, a instrução break
encerrará a troca aqui. Aqui está o
caso de saída, 20 é executado. Muito obrigado
pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
20. Entendendo os loops no Unity C#: Oi amigos, Meu
nome é Rohan Vdv. Na última sessão,
vimos declarações switch. Nesta sessão,
aprenderemos sobre segmentos de controle de loop. Então, o que são declarações
de controle de loop? Ok. Geralmente,
os segmentos de controle de loop são usados quando você deseja que uma instrução
ou um bloco
de código seja executado várias vezes. Novamente, dependendo das
condições a serem avaliadas. A condição a ser avaliada precisa ser verdadeira para
as execuções das instruções ou
do
bloco de código dentro
da aparência, portanto, a condição
deve ser verdadeira se você quiser que essas instruções dentro dos loops sejam executadas
várias vezes Quais são os tipos
de loops que temos? Aqui temos um loop y, um loop
de quatro e um loop de dois y. Vamos dar uma olhada em um loop Y. O que é um loop Y? Ok, a condição é aplicada no início
do loop. inicialização da variável é feita antes e fora do loop Então, a variável que
você vai inicializar estará fora
do loop e não
dentro do loop Agora, o bloco de código
dentro do loop
será executado até que a
condição seja verdadeira. E quando a condição
se tornar falsa
, o loop será
encerrado ou encerrado Aqui está a sintaxe
de um loop amplo. A primeira é a inicialização da
variável de loop. É aqui que você inicializa a variável que está
fora do loop Y. Então, temos um loop Y
e, em seguida, temos uma condição dentro dos colchetes
para um loop largo Agora, dentro do loop Y, temos um bloco de código a ser executado
e, uma vez que o bloco
do núcleo é executado, incrementamos ou diminuímos uma variável
de loop Vamos entrar no editor
Unity e escrever um trecho de código
para executar um loop. Ok pessoal, estou aqui
no editor Unity. Eu já criei
um objeto de jogo vazio, que é um objeto de fluxo de controle. E eu já criei
um script C Sharp. Eu chamei o script de y loop. Além disso, eu já anexei um loop de script ao objeto
vazio do jogo. Vamos abrir o script aqui. Ok, dentro do script, já
declaramos uma variável
de saúde do tipo de dados int, e o valor está definido como cinco. Dentro da função de início, também
declaramos um
loop no qual temos uma condição em que
verificamos se o valor da saúde
é maior que zero. Dentro do loop y, estamos imprimindo o
valor da saúde
e, uma vez impresso o valor da
saúde, estamos diminuindo o
valor da saúde O loop funcionará
aqui até que o valor da saúde se torne um. Quando o valor da
saúde for zero, o loop será
encerrado ou encerrado Vamos executar o script. E vamos ver a saída aqui. Ok, então aqui está a saída. A saúde do jogador é cinco, saúde
dos jogadores é quatro, saúde
dos jogadores é três, saúde dos
jogadores é dois e a saúde dos jogadores é uma. Quando reduzimos o valor
da saúde para um, o loop é encerrado O loop é encerrado aqui. Agora vamos entender o
que são quatro loops. Então, o que é quatro voltas? O loop Four é semelhante ao do loop y com uma
diferença na taxa, inicialização de
uma variável de loop O teste de um
incremento de condição e decréscimo de uma variável de loop ocorre
em uma única linha Aqui, o bloco de código dentro do loop será executado novamente até que a condição seja duas. E quando a condição
se tornar falsa
, o loop será encerrado
dentro do script for loop Dentro da função de início, temos quatro loops declarados
dentro dos colchetes. Para o loop de quatro,
já inicializamos uma variável cujo
valor está definido como um Então, temos uma condição
na qual estamos verificando se o valor de I é
menor que cinco. Por outro lado, o
valor de I está sendo incrementado
em um em cada iteração Dentro do loop, estamos
executando uma instrução. Nesse caso, estamos apenas
imprimindo o valor de no console
do Unity usando a função
debug dot lock Vamos executar o código. Vamos ver a saída
aqui. É isso aí, pessoal. Aqui está a saída para o loop. O jogo marca um, marca dois. Jogar marca três e
jogar quatro é quatro. Quando o valor da pontuação for cinco, o loop é encerrado
ou encerrado aqui Ok, então o que é um loop y? Ok, o loop y é semelhante
ao loop y, exceto que ele verifica a condição somente depois que as instruções
são executadas, executa as instruções pelo menos uma vez antes de verificar
a condição Agora, dentro do script, já
declaramos uma variável, moedas cujo valor está definido como um. Dentro da função de início, declaramos um loop. Dentro do bloco, estamos imprimindo o valor
das moedas. Depois que o valor das moedas é
impresso no console da unidade, o valor das moedas é
incrementado em um O loop Y verificará
a condição aqui se o valor das moedas
é menor que zero Se a condição for verdadeira, ela entrará novamente nos dois blocos e o bloco
de código será executado. Se a condição for falsa, o loop aqui será
encerrado ou encerrado Vamos executar o código
e dar
uma olhada na saída
no console do Unity. Para isso, aqui está o número de moedas do
cara de saída, um. Como a condição era falsa, o loop é encerrado aqui É isso aí, pessoal. Te
vejo na próxima sessão. Muito obrigado, pessoal.
21. Introdução às coleções no Unity C#: Amigos. Meu nome
é Ro e Sudev Nesta sessão, falaremos sobre coleções no Unity C.
O que são coleções? Coleções são classes
especializadas que armazenam séries de valores, objetos
ou elementos. Com a ajuda de coleções, podemos realizar
várias operações. Quais são essas
operações que podemos realizar com a ajuda
de classes de coleções? Podemos armazenar dados, nossos valores, podemos atualizar dados, nossos valores, podemos excluir dados, nossos valores, podemos recuperá-los e também podemos classificá-los. Quais são os tipos
de coleções? As coleções são
basicamente categorizadas em duas classes de coleções, e são as seguintes: coleções
genéricas e coleções
não genéricas O que são coleções genéricas? As coleções genéricas
são definidas no sistema. As coleções
pontuam o espaço genérico. Sempre que quisermos usar coleções
genéricas, precisamos usar o sistema de
namespaces. Faça coleções genéricas definidas por um conjunto de interfaces
e classes. A interface é um
modelo de um genérico. As coleções manipulam os dados
de forma segura e eliminam
o despacho de tipos Qual é o tipo de cofre? Digite Safe aqui simplesmente significa que um tipo de dados não pode ser
atribuído a outro tipo de dados. Aqui estão algumas classes genéricas
de coleções. Primeiro, sua lista contém
dados de um tipo específico. lista cresce automaticamente ao adicionar dados ou elementos a ela. lista ordenada por listas curtas sempre armazena dados em pares de chave
e valor Os dados que
serão armazenados na lista classificada sempre
estarão em pares de valores-chave Os elementos são adicionados na ordem crescente
do dicionário
de chaves dicionário armazena dados em pares de
valores-chave novamente, mas
os elementos adicionados a ele não estarão na ordem crescente da
chave Q. O que é Os valores são armazenados primeiro a
entrar e primeiro a sair. O que é o
primeiro a sair primeiro? Significa simplesmente que
os elementos
adicionados primeiro serão os
primeiros a serem recuperados Ele tem o método Q para adicionar valores
ao método Q e DQ para
recuperar os Quando você usa o método Q, ele não apenas recupera os valores, mas também remove
os valores
das coleções não
genéricas As coleções não genéricas
são definidas no namespace de
coleções de pontos do sistema Quando queremos usar coleções não
genéricas,
temos que especificar as coleções temos que especificar as pontos
do sistema como um
namespace dentro do script Ele pode lidar com qualquer
tipo de objeto, mas os dados não são tratados
de maneira segura. Aqui, essa é a
diferença entre uma coleção genérica e uma coleção
não genérica. As coleções genéricas
basicamente lidam com dados de maneira segura. Coleções não genéricas não manipulam dados
de maneira segura. Aqui estão algumas classes de
coleção não genéricas. A primeira é sua lista de matrizes. Tudo armazena objetos
de qualquer tipo de dados cresce automaticamente ao
adicionar o elemento. Então temos a tabela de hash. tabela de hash armazena dados
novamente em pares de valores-chave, os valores podem ser recuperados pelos valores de
hash das Em seguida, temos o stack que armazena os valores por último a entrar
e primeiro a sair, que é o seu estilo Lifo O que é a maneira Lifo? maneira Lifo significa simplesmente
que os dados a serem adicionados por último serão os
primeiros dados a serem recuperados O método push é usado novamente
para armazenar um valor aqui e os métodos
pop e peak
são usados para recuperar o valor armazenado na
pilha É isso para esta sessão.
Na próxima sessão, daremos uma
olhada em algumas classes de
coleções genéricas. Vamos dar
uma olhada em uma lista, como criar uma lista
dentro do Unity. C afiado. Obrigado, pessoal. Nos vemos na próxima sessão.
Muito obrigado.
22. Entendendo a lista e seu uso.: Olá amigos, Meu nome
é Rohan Vasudevn. Nesta sessão, falaremos
sobre a lista e como
criamos uma lista e alguns dos aspectos
importantes da lista
no Unity C sharp. Então, já criamos uma lista aqui e o nome
da lista é nomes de jogos. A lista é do
tipo de dados string aqui, então todos os valores
que podemos adicionar à lista serão do tipo de
dados string aqui. Além disso, inicializamos
a lista usando uma nova palavra-chave dentro
da função start Para o código um,
estamos adicionando os valores Dan e Sam à lista usando o método
add para a lista. Os valores Dan e Sam dentro da lista podem ser
acessados usando o índice. Aqui, o índice de uma lista sempre
começará do zero. Para o código dois, estamos imprimindo valor Dan, que está no índice
zero, e o valor Sam, que está no primeiro índice
na lista de nomes dos jogadores. Para o código três, novamente, estamos removendo o valor
no índice zero,
que é seu Dan. Quando você remove o valor
Dan do índice zero, o valor será substituído pelo valor
no primeiro
índice, que é Sam Nesse caso, Sam
substituirá Dan aqui quando
imprimirmos o valor dentro
dos nomes dos jogadores no zero no índice. Nesse caso, para o
código número três, Sam será impresso no console
do Unity usando a função
bug dot log aqui. Para o código quatro, estamos inserindo um valor
no primeiro índice Estamos inserindo um valor, Rachel no primeiro índice, usando o método
insert aqui para a lista Para o código cinco, estamos imprimindo todos os valores da
lista usando um loop de quatro. Já
declaramos um loop de quatro. O valor de I foi inicializado com zero número de pontos de nomes de
jogadores Aqui está o número de elementos dentro da lista de nomes de jogadores e eu fui
incrementado aqui em um em cada iteração Em seguida, estamos imprimindo
o valor Sam aqui, que está no índice zero
na primeira E na segunda iteração, estamos imprimindo o valor
Rachel dentro do console do Unity Quando o valor de I
se tornar dois aqui, o loop será
encerrado e encerrado Vamos entrar no
editor do Unity e ver a saída de todo o código
dentro do console do Unity. Ok, então aqui está. Aqui estão os valores de
impressão de saída da lista usando o índice. Está bem? Dan estava inicialmente no índice
08 e Sam
estava no primeiro índice. Então, estamos imprimindo Dan
e Sam aqui imprimindo valores da lista depois remover o valor no índice 08. Como Dan foi
removido da lista, agora Sam está no índice zero agora imprimindo todos os valores da lista usando
loop e Ok, então é isso, pessoal. Isso é tudo para a lista aqui. Na próxima sessão, novamente, continuaremos com algumas coleções de classes genéricas. Muito obrigado Nos
vemos na próxima sessão.
23. Entendendo a lista ordenada e seu uso.: Oi amigos. Meu nome
é Roan Masudev Na última sessão,
falamos sobre lista. Nesta sessão, falaremos sobre
a lista ordenada. lista ordenada terá todos os elementos em pares de
chave e valor Os elementos adicionados
à lista estarão em ordem crescente da chave Agora, neste script, já
declaramos uma lista
ordenada para o código um Estamos adicionando
pares de chaves e valores à lista classificada. No nosso caso, a
lista principal usando o método de adição três é a chave aqui e 100 é o valor
da chave três. Para o código dois, estamos imprimindo os valores da lista
classificada usando chaves Se colocarmos um dentro
dos colchetes aqui, obteremos o valor
dessa chave específica Quando usamos a função bug dot
log para imprimir uma lista de pontuação
dentro do colchete. Em seguida, o valor 200 será
impresso dentro do console. Novamente, a lista de pontuação três
dentro dos colchetes imprimirá 100 dentro do console
do Unity Aqui, para o código três, estamos criando uma chave aqui, dois, e atribuindo o
valor 150 à chave dois Para o código quatro, estamos usando um método de chave de conteúdo para verificar se uma
chave específica existe ou não. E se a chave existir
, imprimiremos um valor
dessa chave no console do Unity. Para o código cinco, estamos
imprimindo todas as chaves e valores da
lista classificada usando para cada loop Para cada loop, basicamente
iteraremos todos os itens, chaves e valores dentro
da lista de pontuação aqui, que é nossa lista ordenada
. Aqui está. Aqui estão os valores de
impressão de saída da lista classificada usando chaves Imprimimos
os valores das chaves específicas. Por fim, imprimimos todas
as chaves e valores da lista classificada usada para
cada loop Então, aqui está a saída para isso, chave é um e o valor é 200, chave é dois, o valor é 150, chave é três e o valor é 300. É isso mesmo. Isso é
tudo para a sessão. Nos vemos na próxima
sessão. Muito obrigado.
24. Entendendo o dicionário e seu uso.: Oi amigos. Meu nome
é Rohan Masugev Na última sessão,
falamos sobre uma lista mais curta. Nesta sessão, falaremos
sobre dicionário. dicionário armazena pares de
valores-chave, chave interna, dicionário não pode ser
nulo e deve ser exclusivo Agora, o valor dentro de
um dicionário pode ser nulo e
também pode ser duplicado Neste script,
já declaramos um
dicionário aqui. O tipo de dados para a
chave é string aqui, e o tipo de dados para o
valor será string aqui. Os detalhes do jogador são o nome
do dicionário aqui. E também inicializamos um dicionário usando uma nova palavra-chave dentro da função start Para o código um, estamos adicionando chaves e valores ao nome
do dicionário. Aqui está a chave e Danny, aqui está o valor
do nome da chave Novamente, o país aqui é a chave, e os EUA aqui são o valor
para o país chave. Código dois, estamos imprimindo os valores no dicionário
usando suas chaves. Para o código três, estamos
removendo o país da chave aqui, usando o método remove
para o dicionário. Para o código quatro, estamos
imprimindo todas as chaves e valores do dicionário
usando para cada loop. Então, vamos entrar
no editor Unity e executar o código. E vamos ver a saída aqui. Ok pessoal, então aqui
está a saída para o código imprimindo valores
do dicionário usando a chave. Então, temos nossa produção
como Danny e EUA aqui. Feito isso,
removeremos o
país da chave do código. E, por fim, estamos tendo uma saída como nome da chave e valor Danny, não há país
aqui porque
já removemos o país
do dicionário É isso aí pessoal,
muito obrigado pela sessão. Nos vemos na
próxima sessão.
25. Entendendo o ArrayList e seu uso.: Oi amigos. Meu nome
é Rohan Vasdev Na última sessão,
falamos sobre Q. Nesta sessão, falaremos
sobre uma lista muito importante A lista Ery é uma coleção
ordenada de elementos de qualquer tipo de dados. Eralst cresce automaticamente ao adicionar os elementos a O Eryalist também pode ter elementos
duplicados dentro dele. Neste script, já
declaramos um Eryallist e o nome
da lista Aral é minha lista Também inicializamos a lista Aral usando
uma nova palavra-chave e estamos adicionando dois elementos, Dan e John, à lista Após a inicialização dentro da
função de início no código um, estamos imprimindo todos os valores
da lista R usando a. Para cada loop,
já declaramos um
para cada loop aqui, que iterará
sobre todos os elementos
dentro da lista de matrizes, minha
lista Para cada loop, estamos imprimindo todos os elementos usando a função
rebug dot log Então, basicamente, isso imprimirá Dan e John
no console do Unity. No código dois, estamos adicionando
mais valores à lista de matrizes, Sam e Tina, usando o
método add para a
lista de matrizes no código três. Novamente, depois de adicionar
os elementos, estamos imprimindo todos os
elementos ou valores dentro da lista de matrizes novamente
usando para cada loop. Agora, no código quatro, estamos removendo um valor
ou o elemento
da lista Aral no índice zero
usando
a função remove at usando
a função remove Basicamente, no índice
zero eth, temos Dan aqui. Então, estamos removendo Dan
da própria lista. Agora, depois de removermos
Dan da lista ery, estamos inserindo um novo valor
no índice zero na
lista ery usando o método insert Agora, no código seis, estamos imprimindo todos
os valores da própria lista usando para cada
loop após remover e inserir o valor no
índice zero Então aqui está. Aqui está
a saída que imprime todos os valores do
realista usando para cada loop Inicialmente, adicionamos Dan e John à relista
durante o período de
inicialização Estamos imprimindo
Dan e John aqui, imprimindo todos os valores da Lista usando um para cada loop. Depois de adicionar mais valores, adicionamos Sam e
Tina à lista. Temos aqui Dan, John, Sam e Tina. Agora, por fim, imprimindo
todos os valores da lista usando
um para cada loop Depois de remover e inserir um valor no zero no índice, removemos Dan que
estava no zero no índice e adicionamos Jenny
e zero no Aqui está a saída para isso. Temos Jenny, John,
Sam e Tina. Então é isso, pessoal. Obrigado pela sessão. Nos vemos na próxima
sessão. Muito obrigada.
26. Entendendo o Hashtable e seu uso.: Oi amigos. Meu
nome é Rohan Dev Na última sessão,
falamos sobre uma lista. Nesta sessão, falaremos sobre
a tabela de hash. A tabela de hash armazena dados ou
elementos em pares de valores-chave. Os valores dentro da tabela de
hash podem ser recuperados usando as chaves
associadas Os elementos adicionados
à tabela de hash podem ser do mesmo tipo de dados ou de um tipo de dados
diferente As chaves dentro da
tabela de hash não podem ser nulas, mas os valores dentro da tabela de
hash podem ser classe de tabela de hash implementa coleção de
dicionários,
inúmeras interfaces Agora, neste script, já
declaramos uma hash e o nome da tabela de hash é dados dos jogadores Inicializamos a tabela de
hash aqui usando uma nova palavra-chave dentro
da função de início Para o código um, estamos adicionando pares de
valores-chave à
tabela de hash usando o método add Aqui, código dois, estamos imprimindo um valor
para uma chave específica. Nesse caso, estamos imprimindo o valor do nome da chave aqui. função Debug dot lock
aqui será impressa e qual é o valor
do nome da chave aqui Para o código três, estamos usando a coleção de
olhos para recuperar todas as chaves
da tabela de hash As chaves são recuperadas
usando teclas de ponto. Para o código quatro, estamos
imprimindo todas as chaves e valores da tabela de hash
aqui usando a para cada loop Já
declaramos a para cada brecha aqui, que passará
basicamente por todas as chaves dentro
da Todas as chaves são uma variável
ou um objeto no qual todas as chaves são armazenadas aqui usando a coleta de olhos
no código três, quando estamos usando uma função de bloqueio de
depuração Dentro do para cada loop. Aqui, aqui,
imprimirá todas as chaves. O valor de cada chave será impresso usando os dados dos jogadores, que são sua tabela de hash, e colocando uma chave dentro dela, que é, neste caso, 45 Aqui estamos removendo
uma chave específica. Nesse caso, estamos
basicamente removendo uma cidade-chave da tabela
de hash usando o método
remove para
a tabela de hash Para o código seis, estamos imprimindo todas as
chaves e valores
da tabela de hash usando um para cada loop após a remoção
de uma chave específica Então, vamos ao editor
Unity agora e vamos imprimir a saída. Ok pessoal, aqui está. Aqui está a saída
do código que imprime um valor para o nome
da chave da tabela de hash Portanto, o valor do
nome da chave está e em nosso código. Então, estamos imprimindo e aqui imprimindo todas as chaves e
valores da tabela de hash Então, basicamente, estamos imprimindo todas as chaves, o valor da cidade-chave, Nova York, o valor do nome chave
e o valor da idade-chave 18. Então, estamos imprimindo todas
as chaves e valores aqui dentro da nossa tabela de hash Agora, por fim, estamos imprimindo
todas as chaves e valores
da tabela de hash
usando uma aparência de forragem após a remoção de uma Nós o removemos da
tabela de hash e, portanto, estamos imprimindo o valor do nome da chave
e o valor da idade da chave 18 Portanto, não há nenhuma cidade aqui,
pois a removemos da tabela de hash usando
a
função remove para uma tabela de hash É isso aí, pessoal.
Obrigado pela sessão. Nos vemos na próxima
sessão. Muito obrigado
27. Entendendo o Stack e seu uso.: Oi amigos. Meu nome
é Rohan Vasudeven A última sessão sobre a
qual falamos tem mesa. Nesta sessão,
falaremos sobre pilha. Stack é um tipo especial
de coleção que armazena dados ou elementos da
maneira Lifo Lifo aqui significa uma maneira duradoura
e inédita. O elemento a ser
adicionado por último será o primeiro elemento a ser
recuperado da pilha Ok, então neste script, já
declaramos uma pilha e o nome
da pilha é meu lugar Inicializamos
a pilha usando uma nova palavra-chave dentro
da função de início Para o código um,
estamos adicionando valores à pilha usando
um método push Então, o método push é basicamente usado para adicionar valores à pilha Então, estamos adicionando Danny aqui, então estamos adicionando Sam aqui E por último, estamos adicionando, e aqui Andy é
o último elemento, ou o último valor a ser
adicionado aqui no código dois, estamos imprimindo todos os valores dentro de uma pilha usando
a para cada loop, já
declaramos a para cada Para isso e dentro
do loop for each, estamos usando a função debug
dot log para imprimir todos os
valores dentro de uma pilha Isso para cada loop basicamente
será impresso primeiro, porque a pilha funciona
de maneira Lifo, último a entrar e primeiro a sair, e é o último elemento adicionado Então, ele imprimirá e primeiro, depois imprimirá Sam
e, por último, imprimirá Danny Aqui no código três, estamos recuperando e imprimindo o último valor adicionado a uma
pilha usando o método peak método Peak retorna o último
elemento dentro da pilha, mas não remove o elemento Ele não remove o valor, então ele apenas recuperará
o valor aqui Ok, agora no código quatro, estamos usando um
método pop que
retornará o último valor
adicionado à pilha, mas também
removerá o último valor
adicionado à pilha Ok, então no código cinco, estamos imprimindo
todos os valores em uma pilha depois de usar
o método pop Agora usando um método pop. No código quatro, removemos aqui o valor e da pilha Então, depois de executarmos
isso para cada loop, vamos imprimir Danny e Sam aqui no console do Unity, já que Andy foi
recuperado e
removido da pilha no código quatro Agora vamos entrar
no editor Unity e ver a
saída desse código. Então aqui está. Aqui
está a saída, imprimindo todos os
valores em uma pilha Então, estamos imprimindo And Sam
and Danny, como eu disse anteriormente Ok, a pilha funciona
da maneira Lifo, então Andy foi o último
elemento a ser adicionado primeiro, então será o primeiro
elemento a ser Então, recuperamos e aqui primeiro, depois estamos imprimindo Sam
e, por último, estamos
imprimindo Danny Ok, recupere e imprima último valor adicionado a uma
pilha usando o método peak Então, novamente, aqui estamos recuperando o último elemento
adicionado à pilha, o último valor adicionado à pilha,
que é Andy, e o estamos Agora, por fim, estamos imprimindo todos os valores em uma pilha
depois de usar o método pop Então, usamos um método pop e
removemos o último elemento, recuperamos e removemos
o último elemento e imprimimos todos os
valores restantes dentro de uma pilha Então é isso, pessoal. Isso é tudo para a sessão. Te vejo na próxima
sessão. Muito obrigado
28. Introduções à interface do usuário no Unity e crie uma tela: Amigos, meu nome é Rohan. Hoje, falaremos
sobre Unity. Uy, Unity UI, em palavras simples, é usada para projetar e criar interfaces de
usuário para
jogos e aplicativos Nesta sessão, especificamente, falaremos sobre um dos componentes da interface do usuário
do Unity, que é sua tela de interface do usuário. Então, o que é tela? O Canvas é criado como um objeto de jogo com um
componente de tela anexado a ele. Então, sempre que você cria
uma tela dentro do Unity, ela é sempre criada
como um objeto de jogo que terá um
componente de tela anexado a ela. A tela é exibida como um
retângulo na vista da cena. Cada tela terá um componente de transformação
anexado a ela. Todos os outros elementos da interface do usuário devem
estar dentro de uma tela. O Canvas será sempre,
ou deve ser, aparente, de todos os outros elementos
ou componentes da interface do usuário. Todos os elementos dentro
da tela são desenhados na ordem em que aparecem
na hierarquia Agora, existem três
modos de renderização para a tela. A primeira é a sobreposição do
espaço na tela, que coloca os elementos da interface
na tela renderizada na parte superior
da cena Isso é basicamente como uma tela de sobreposição na
parte superior do espaço da tela A tela da câmera é colocada a
uma distância específica
do componente
escalar da tela da câmera Ele simplesmente controla a escala e densidade de
pixels dos elementos
da interface do usuário. A couve é do seu tamanho. densidade de pixels é o número
de pixels em uma determinada área, basicamente para os elementos da interface do usuário. Agora, existem alguns modos de escala disponíveis em tela, componente
escalar Primeiro, é o tamanho
constante do seu pixel. O tamanho em pixels dos elementos
da interface do usuário permanece constante aqui, independentemente
do tamanho da tela A segunda é sua escala. Com as escalas de tamanho da tela, os elementos da interface do usuário nos tamanhos de tela
maiores, os elementos da interface
do usuário colocados na tela aumentarão de
acordo com o tamanho da tela. Aqui, se você escolher o componente escalar da
tela. Por fim, temos tamanho físico
constante. O tamanho físico dos elementos
da interface do usuário permanece constante, independentemente
do tamanho da tela Estou aqui no editor Unity. Já criamos uma cena
e o nome
da cena é UIC Vamos criar um
componente de tela aqui. Como fazemos isso?
Clique com o botão direito aqui, na cena da interface do usuário,
selecione Objeto do jogo e selecione UI aqui. Dentro da interface do usuário, teremos que
escolher a tela aqui. Ok, e é isso. Nosso componente de tela aqui
é adicionado à cena. Não conseguiremos ver nada aqui porque
não adicionamos nenhum elemento. Basicamente, isso
será o pai de todos os outros elementos da interface do usuário, como caixas de texto e
botões, etc. Temos um
componente de transformação W anexado automaticamente ou adicionado
automaticamente à tela. transformação de objetos do jogo
basicamente colocará todos os outros elementos
da interface dentro da área especificada
ou da tela. Ok, então, como todos podemos ver aqui, novamente alguns valores
orientados pela tela. Portanto, esta é uma transformação de
gravação não editável. Não podemos editá-lo
agora porque renderizamos mais na sobreposição do espaço da
tela ou na câmera do espaço da tela, então não poderemos editar a transformação rec
da tela Mas
se mudarmos para o espaço mundial, poderemos mudar ou modificar a transformação aqui. Ok, então temos o
canvas scaler aqui. O primeiro é o tamanho
constante do pixel. Então, temos o tamanho da tela em escala e temos um tamanho
físico constante. Nos vemos na
próxima sessão com mais componentes de interface do usuário.
Muito obrigado.
29. Texto e componentes da interface do usuário: Olá amigos, Meu nome
é Rohan.
Na última sessão falamos
sobre UI Canvas Unity Nesta sessão, falaremos
sobre UI Text Unity. Então, o que é UI Text
Unity? Muito simples. Ele exibe uma informação
ou um texto para o usuário, que geralmente
não é interativo. Essas informações podem
ser uma pontuação, uma saúde,
número de moedas, etc., que geralmente são
exibidas usando o UYExt No jogo ou em uma interface
C, o componente de texto é anexado a um objeto do jogo. Isso significa que quando você cria
um componente de texto da interface do usuário, um objeto de jogo é criado ao qual o componente de texto da interface do usuário
é anexado. Agora,
há uma soma
de propriedades para um elemento de texto. O elemento de texto I é a fonte
usada pelo texto, a fonte usada pelo
texto. O tamanho da fonte, que especifica o tamanho do estilo ou o estilo usado pelo texto,
é o valor
que o
componente de texto exibe O espaçamento entre linhas é espécie,
fonte, altura da linha. E o alinhamento é o posicionamento do texto
no meio, no
centro, na parte superior e na parte inferior Ok, agora vamos entrar no editor
do Unity e
criar um
elemento de texto da interface do usuário dentro do Unity. Ok pessoal, eu estou
no editor Unity. E criar texto de interface de usuário, é semelhante à forma como
criamos o Unity Canvas. Clique com o botão direito na interface do usuário aqui
e vá para Game Object. E selecione UI. E selecione seu
elemento de texto aqui. Aqui está. Seu texto foi criado. Então, podemos ver
o texto na tela aqui. Portanto, este é um objeto de
jogo de texto aqui que terá uma transformação rec
aqui, que é editável Podemos modificar a
posição para ela. Agora, o objeto de jogo Text terá um componente de
texto anexado a ele. Agora você pode ver
aqui, é aqui que podemos
colocar o texto. Ok, agora é um novo texto. Vamos colocar um texto longo aqui. Vamos tentar
alterá-lo para que
possamos ver todo o conteúdo. O estilo da fonte é normal. Podemos alterá-lo para negrito, itálico, negrito e itálico Vamos mudar para negrito aqui. Então, podemos aumentar ou
diminuir o tamanho da fonte. Vamos mudar para 18 aqui, ok, ficou maior. Agora, no parágrafo, esse é o alinhamento em que
podemos alinhar o Basicamente, mantenha-o no centro. Esse retângulo que
você pode ver aqui é a transformação da caixa de texto Então temos o transbordamento
horizontal. Aqui temos um texto longo e não podemos
ver o texto, o texto inteiro no momento. Está embrulhado, podemos
alterá-lo para transbordar, mas ainda
não conseguimos ver O que podemos fazer é clicar aqui e aumentar a transformação
para a próxima. Vamos manter esse envoltório aqui e aumentar isso. Vamos aumentar isso de
acordo com nosso texto. Vamos mudar a cor do
texto aqui. Vamos mantê-lo em vermelho. Aqui está. É isso aí, pessoal.
Obrigado pela sessão. Na próxima sessão,
falaremos sobre componente de imagem da
interface do usuário no
Unity. Muito obrigado
30. Imagem de interface do usuário e componentes: Oi amigos. Meu nome
é Rohan Vasudev Nesta sessão, falaremos sobre o componente de imagem da
interface do usuário no Unity. O que é um componente de imagem da interface do usuário? componente de imagem da interface do usuário exibe uma imagem para o
usuário na tela. componente de imagem Ui
pode ser usado como fundo de
ícones para os componentes de
texto, etc Portanto, existem vários
cenários nos quais o componente de imagem da
interface do usuário pode ser usado imagem da interface do usuário requer que a imagem ou textura de
origem seja um sprite Portanto, a imagem de origem ou
a imagem do componente
da imagem deve ser um sprite O que é um sprite? Sprite é um objeto bidegráfico simples
com texturas. Agora, há algumas propriedades
para um componente de imagem da interface do usuário. Quais são essas propriedades? Imagem de origem, a
imagem de origem é basicamente a imagem a ser exibida
na forma de uma
textura ou um sprite Então temos outra
propriedade, que é a cor. Cor especifica a cor
aplicada à imagem. Então temos o material. Material é o material
usado para renderizar a imagem. Preserve o aspecto,
preserve o aspecto, preserva o aspecto ou dimensões
reais do tamanho nativo do conjunto de
imagens Ele altera as dimensões
da transformação de gravação da imagem para o
tamanho real em pixels da textura Em seguida, temos mais uma propriedade para o componente de imagem da interface do usuário, que é o tipo de imagem. tipo de imagem especificará como a imagem é exibida
na tela. Há quatro
tipos de imagem que podem ser usados. O primeiro é o seu simples. Nesse tipo de imagem, as imagens são esticadas
para se ajustarem à transformação do componente de imagem ou
ao jogo de verificação da imagem We have sliced especifica uma imagem fatiada para elementos
retangulares ou caixas decoradas retangulares Em seguida, temos uma imagem em mosaico com
a repetição de sprites. Os sprites ou as texturas
estão em forma de repetição. Se selecionarmos o tipo de
imagem para lado a lado. Por fim,
temos um tipo preenchido que é uma imagem parcial geralmente útil para sua
contagem regressiva, cronômetros, etc Ok, agora vamos entrar
no editor Unity e
criar um componente de imagem da interface do usuário. Aqui está, pessoal. Estou
aqui no editor Unity. Vamos criar nosso componente de imagem aqui no C. Ok,
como fazemos isso? Clique com o botão direito aqui
na cena UY, vá para Game Object, selecione UI aqui e
clique em Imagem Aqui. Criamos nosso componente de
imagem na cena. No momento, está em branco
porque
não anexamos nenhuma imagem
de origem aqui. Essa imagem de origem precisa ser um sprite para anexar
uma imagem de origem Vamos criar um
sprite dentro do Unity. Como fazemos isso? Vamos
criar uma pasta aqui, basta clicar com o botão direito aqui, dentro dos Atos, e
ir para Criar aqui. E clique em Pasta. Ok, vamos renomear a pasta para sprites e
abrir a Essa é a imagem que
vamos usar. Então, vamos arrastar e soltar essa imagem na pasta de
sprites aqui Basta arrastar e soltar
a imagem aqui. Está bem? Então, agora, essa imagem por padrão
é um formato de imagem, então precisamos alterá-la para um formato sprite. Então,
como fazemos isso? Clique aqui em Padrão e selecione Sprite para
D e U, Y aqui. E clique em Inscrever-se aqui. Ok,
criamos nosso sprite. Vamos anexar esse sprite
ao componente de imagem. Então, clique em
Componente de imagem novamente. Ok, e clique aqui. E selecione isso em, que agora é um sprite Ok, e é isso. Podemos ver nosso componente de imagem UY
adicionado dentro da cena Então, temos um
aspecto preservado aqui. Preservar aspecto realmente
preservará as dimensões originais da imagem. Vamos mudar a largura para 150. Está bem? No momento,
não parece bom, parece um pouco esticado Se você escolher
preservar aspecto aqui, ele retornará as
dimensões reais da imagem. Então, vamos ver o que é tamanho
nativo aqui. Isso é uma retransformação
para a imagem. Então, quando clicarmos
nesse tamanho nativo, ele retornará ou
alterará a transformação, esse retângulo aqui para o
tamanho real em pixels da textura Ok, então vamos clicar em Definir tamanho nativo aqui.
Ok, e é isso. Ele modificou a transformação
direta para o
tamanho real do pixel da textura. Então é isso, pessoal, isso é tudo para o componente de imagem aqui. Nos vemos na próxima sessão
com
o componente do botão de interface do usuário. Muito obrigado, pessoal.
31. UI Button e componentes: Oi amigos. Meu
nome é Rohan Dev Nesta sessão,
falaremos
sobre a imunidade aos botões da interface do usuário. O que é imunidade ao botão UI? É um
elemento de imunidade interativo que responde ao clique
do usuário É usado para executar ou iniciar uma ação
na cena ou em um jogo Um componente de imagem é
anexado ao botão sempre que você cria uma imunidade de
botão por padrão, um componente de imagem é
sempre anexado a ele. Assim, você pode aplicar qualquer imagem
ao botão de sua escolha. Então, quais são as propriedades
de um elemento de botão? Primeiro, é o seu interativo,
que especifica se o
botão é clicável que especifica se o
botão é clicável Depois, há a transição, que especifica o processo de mudança de um
estado para outro Ok, então, basicamente, quando você toca no
botão ou clica no botão, o estado do botão muda. E esses estados podem
ser seu estado normal, seu estado
destacado pressionado e estado desativado. Há quatro opções em transição. Quais
são essas opções? A primeira é sua freira. Então
temos a cor dez aqui. Então temos o sprite swap aqui. E, por fim, temos a animação. Agora vamos ver, uma por uma, o que essas opções de
transições basicamente significam Nenhum terá nenhum efeito
na mudança de estado. Não terá
efeito no botão,
basicamente sempre que o
botão for pressionado ou sempre que o botão for desativado ou sempre que o
botão for destacado. Depois, temos a tonalidade da cor, que muda a cor
do botão com a
mudança no estado Portanto, podemos ter cores diferentes para estados diferentes aqui, sprites, sprites diferentes podem ser exibidos para cada estado
individual Portanto, podemos aplicar sprites
diferentes para cada estado individual aqui Por fim, temos a
transição de animação aqui. As animações podem ser reproduzidas acordo com o
estado do botão, para que possamos aplicar animações ao botão de
acordo com o Um botão deve sempre ter um componente animador
anexado a ele para permitir que a transição da
animação funcione Ok, agora vamos entrar no editor
do Unity e
criar um botão de UI no Unity. Ok pessoal, aqui estou eu
no editor Unity. E vamos criar um botão
aqui para criar um botão. Basta clicar com o botão direito aqui
na cena da interface do usuário, ok? E vá até Game Object e selecione UI aqui. E depois clique no botão aqui. Ok, então temos nosso
botão criado aqui, como todos podemos ver
aqui na tela. Agora vamos ver quais
são os elementos anexados ao objeto do
jogo de botões aqui. Em primeiro lugar,
será uma transformação rec que será anexada
por padrão aqui Ok, então teremos
um componente de imagem que será anexado
quando criarmos um botão. Agora, indo para o componente
botão, aqui temos uma propriedade
interativa
que está verificada agora Vamos executar o ok. No momento, podemos
clicar no botão aqui, e é basicamente um
botão clicável Ok, vamos apenas desmarcar isso. E o botão está desativado aqui. Não podemos clicar no
botão aqui, ok? Em seguida, temos a propriedade de
transição, que terá
quatro opções: nenhuma, cor, tonalidade,
troca de sprite Escolher nenhum significa simplesmente
que o botão
não terá efeito na
mudança de estado aqui, ok? Mas, por padrão, ele está
configurado para tonalidade de cor aqui, então vamos tentar ver
o que é tonalidade de cor Ok, gráfico alvo. gráfico de destino significa simplesmente a imagem que está configurada
para o botão aqui. Nesse caso, essa imagem
foi configurada para o botão aqui. Então temos a cor normal. A cor normal é
basicamente a cor que é aplicada ao botão quando o estado
do botão é normal, quando não é pressionado
ou destacado, basicamente atualmente ele
é mantido na cor branca. Vamos mudar a
cor normal do botão. Vamos mantê-lo na cor amarela. Está bem? A cor destacada é basicamente quando você
pressiona o botão aqui, vamos mudar essa
cor para vermelho Está bem? E pressionou o estado quando você realmente
clica no botão. Atualmente é cinza. Então, vamos mudar
para essa cor. Ok. E a cor selecionada é basicamente quando o botão
está no estado selecionado, vamos mantê-lo em branco. Está bem? E a cor desativada é quando o botão não
é interativo,
basicamente, quando você
desmarca essa coisa. Por fim, temos uma função
onclick aqui. Está bem? A função ao clicar
é uma função Unity, que é acionada quando o
botão é pressionado aqui. Entraremos em
detalhes sobre isso
nas próximas sessões, quando aprendermos sobre eventos, gatilhos e
funções no Então, agora, o botão
está no estado normal. No estado normal, o botão
terá uma cor amarela. Está bem? A
cor destacada aqui é vermelha. Então, se eu passar
o mouse sobre o botão aqui, a cor do botão
ficará vermelha Ok, depois pressionado,
a cor é rosa. Então, quando eu clico no botão, ok, você pode ver aqui,
ele fica rosa. E quando eu sair do botão ou deixar o
clique, ele ficará
branco porque esse é um
estado selecionado do botão. Ok, fica branco aqui. Por fim, se você estender um componente de
botão aqui, ok, ou o objeto de jogo de botões aqui, dentro do objeto de jogo de botões, teremos um objeto de jogo de texto Ok, onde podemos realmente
aplicar o texto no botão. No momento, o botão de texto É, para que possamos alterá-lo para Enviar
ou para o texto de nossa escolha. Ok. O texto no botão
mudará para Enviar. Aqui. É isso aí, pessoal. Obrigado pela sessão. Te vejo
na próxima sessão. Muito obrigado, pessoal.
32. UI ScrollView e componentes: Oi amigos, Meu nome
é Rohan Vase. Nesta sessão,
falaremos sobre a visualização de rolagem
UY no Unity O que é a visualização de rolagem UY? visualização de rolagem Uy é
usada para exibir conteúdo dentro de um quadro de tabela de
rolagem Geralmente é usado
quando um conteúdo grande precisa ser colocado dentro de
uma pequena área em uma cena. Uma visualização em rolagem tem um fragmento de rolagem e um componente de imagem
anexado a ela Quando você cria um objeto de jogo com
visualização em rolagem, por padrão, um fragmento de rolagem e um componente de imagem são
anexados a ele Um scroll wreck fornece
funcionalidade percorra o conteúdo, que ocupa muito
espaço e precisa ser
encaixado em uma pequena
área em uma cena Agora, há alguns
elementos importantes em uma exibição de rolagem. O primeiro é o seu Viewport. visualização é filha do objeto raiz
do jogo,
que é a visualização de rolagem É uma transformação de gravação
que, na verdade, atua como uma janela para o conteúdo do nível de
rolagem Agora, o componente de máscara é
anexado à janela de exibição para ocultar qualquer conteúdo
fora da janela de visualização Em segundo lugar, temos o conteúdo. O conteúdo é filho do objeto
do jogo Viewport O
componente de conteúdo, teremos todo o
conteúdo de rolagem dentro dele Então, basicamente, qualquer
conteúdo que
colocarmos em uma visualização de rolagem
estará dentro do seu conteúdo, objeto de
jogo ou componente de
conteúdo. O tamanho do componente de
conteúdo precisa ser expandido para caber todo o conteúdo rolável. Somente
se o conteúdo for
maior que a janela de visualização,
o rolagem funcionará Então, suponha que se o conteúdo for
menor do que a janela de visualização, o efeito de rolagem
não funcionará, então ele deve ser
maior do que sua Então temos bolas de rolagem. Existem dois tipos
de barras de rolagem aqui, barras rolagem
horizontal e
vertical, que são filhas do objeto raiz
do jogo,
que é seu objeto de jogo de visualização de rolagem Novamente, eles são usados para definir a rolagem
horizontal e
vertical para os elementos da barra de rolagem Portanto, a barra de rolagem horizontal é usada para definir a rolagem
horizontal e a barra de rolagem vertical é usada para definir a rolagem
vertical Como criar uma visualização
dinâmica de rolagem. Agora, o conteúdo rolável é adicionado dentro do componente de
conteúdo Ok, então, quaisquer objetos que
vamos adicionar, todos
eles estarão dentro
do componente de conteúdo. O tamanho do componente de
conteúdo ou do objeto do jogo
é maior que o corpo da visualização de rolagem por padrão e pode ser
modificado conforme necessário. Agora, isso se
adequa perfeitamente ao conteúdo em
nível de rolagem estática, se soubermos exatamente quanto
conteúdo estará lá dentro da visualização de
rolagem, basicamente. Mas e se não soubermos quanto conteúdo estará lá? E se o conteúdo for adicionado
em tempo de execução? Então o que? Então, o componente de conteúdo não
ajustará seu tamanho adequadamente e o
conteúdo fora da área de conteúdo não
ficará visível. Portanto, o tamanho da exibição de
rolagem pode ser alterado dinamicamente
adicionando dois elementos ao componente de conteúdo E quais são esses elementos? Esses são seu grupo de layout
vertical. O que é grupo de layout vertical? grupo de layout vertical é usado para colocar elementos secundários
abaixo uns dos outros. Está bem? Abaixo um do outro. O
conteúdo rolável aqui será colocado verticalmente,
um abaixo do outro Em seguida, temos o grupo de
layout horizontal. grupo de layout horizontal é usado para colocar elementos
secundários lado a lado. O conteúdo rolável
aqui basicamente será colocado horizontalmente, Está bem? E, por fim,
temos o ajustador de tamanho de conteúdo O que é o Content Size Fitter? O aspecto mais importante aqui ajustador de tamanho de
conteúdo determinará o tamanho dos
transformadores de gravação Ok, então esse
ajustador de tamanho de conteúdo basicamente será adicionado ao seu
componente de conteúdo ou objeto do jogo Na verdade, até mesmo o grupo de layout
vertical ou grupo de layout
horizontal serão adicionados ou deverão ser
adicionados ao seu conteúdo, objeto de
jogo ou componente de
conteúdo. ajustador de tamanho do conteúdo determinará o tamanho da
transformação rec à qual está anexado, com base no layout
de seus filhos Ele só funciona em combinação
com um componente de layout , como seu grupo de
layout vertical
ou grupo de layout horizontal. Pode-se dizer que o ajustador de tamanho de conteúdo tem um tamanho de ajuste horizontal preferido para o grupo de layout horizontal Assim, podemos definir o ajuste horizontal tamanho preferido
para ajustadores de tamanho de
conteúdo Portanto, essa é uma propriedade do
ajustador
de tamanho de conteúdo que pode ser
definida para o tamanho preferido Isso basicamente
aumentará o ID ao adicionar mais objetos secundários e quais caberão em todos eles.
Então é isso, pessoal. Nos vemos na
próxima sessão. Na próxima sessão,
criaremos um exemplo para uma visualização em rolagem com
um grupo de layout
vertical e um ajustador de tamanho de conteúdo Muito obrigado, pessoal.
Muito obrigado.
33. Crie ScrollView vertical usando o grupo de layout vertical: Meus amigos, meu
nome é Rohan Sev. Na última sessão, falamos sobre a visualização de rolagem UY no Unity Nesta sessão,
vamos criar uma visualização de rolagem dentro do Unity com
grupo de layout vertical e conteúdo Size Bitter. Vamos criar uma visualização em rolagem
aqui. Como fazemos isso? Basta clicar com o botão direito aqui
na cena UY, que é o nome da cena, e vá para Game Object,
vá para UY e selecione
Scroll View Sim, nossa visualização de rolagem
foi criada aqui. Ok, podemos simplesmente ir
para o modo de cena aqui e ajustar a largura e a
altura da visualização de rolagem. Basta clicar na Ferramenta Wreck
aqui e ajustar o objeto do
jogo de visualização de rolagem interno da tela criado visualização de rolagem terá um
componente de imagem anexado a ela por padrão e um fragmento de rolagem anexado a ela por Horizontal e vertical, aqui está em que direção
ele rolará. No momento, os dois estão verificados. Então, temos um tipo de momento
que é mantido elástico. Elastic basicamente moverá a intenção em todas
as direções Nós não queremos fazer isso. Vamos mudar para fixado. Ok, então dentro
da visualização de rolagem, teremos uma janela de visualização aqui Vamos para a janela de exibição aqui. visualização, basicamente, novamente,
teremos um componente de imagem anexado a ela com
uma transformação rec e uma máscara anexada a Agora, dentro do Viewport, teremos um conteúdo que terá basicamente todo o conteúdo
rolável Está bem? Qualquer que seja o conteúdo
rolável que precisamos colocar aqui, precisa estar dentro desse componente de conteúdo ou objeto de jogo de conteúdo Vamos adicionar um
grupo de layout vertical ao conteúdo aqui. Está bem? E vamos adicionar um ajustador
de tamanho de conteúdo aqui. Ok, para o
grupo de layout vertical, temos preenchimento. Está bem? O preenchimento é
basicamente o espaço que será deixado da esquerda para a
direita, de cima para baixo Ok, vamos manter em 55. Também podemos ajustá-lo mais tarde. Ok, então o espaçamento é basicamente o espaço entre dois elementos
diferentes, elementos
secundários dentro
do objeto do jogo de conteúdo Vamos reduzir para cinco aqui. Novamente, a área rolável basicamente não
é horizontal aqui. Não precisamos
mudar isso, ok. Teremos que mudar de vertical. Ajuste aqui ao
tamanho preferido para que,
mesmo que você continue adicionando
mais elementos secundários, a área de
conteúdo basicamente se
redimensionará sozinha Todos os elementos se
encaixarão nele. Vamos começar a adicionar imagens
dentro desse conteúdo aqui. Mas precisamos fazer algumas
mudanças na imagem aqui. Queremos que seja um
pouco esticado. Ok, vamos ver a cena aqui. Selecione novamente, registre a ferramenta aqui e ajuste-a de
acordo com o. Basta arrastá-lo. Vamos clicar com o botão direito do mouse na imagem do objeto
do jogo aqui. Acesse a interface do usuário aqui novamente e clique no texto aqui. Adicionamos uma imagem
aqui à visualização em rolagem. Vamos adicionar mais imagens para que
possamos ver o efeito de rolagem Ok, então
vamos pressionar o controle D e continuar adicionando as imagens. Copiar as imagens basicamente para a barra de rolagem,
horizontal e vertical. Nesse caso, o Horizontal
será desativado porque usamos o Grupo de Layout
Vertical aqui. Clique na
barra de rolagem vertical aqui. E vamos mudar a largura para isso,
basta fazer com que seja cinco. Ok, para horizontal,
precisamos alterar a altura. Vamos manter isso em zero. Agora vamos rodar a cena e ver como fica. Aqui está. Temos uma visão
rolável aqui Conforme discutimos anteriormente, componente de
imagem
será anexado ao objeto
do
jogo Scroll View, ok? E uma imagem de origem é definida como plano de
fundo aqui por padrão, para que
possamos alterar
a cor dela. Vamos mudar para uma cor mais escura, ou talvez vermelha ou
algo parecido Está bem? Dependendo novamente,
depende da cor que você deseja, combinações de cores
que
você está usando. Ok, aqui está a visualização de rolagem usando um grupo de layout vertical
e um ajustador de tamanho de conteúdo Muito obrigado, pessoal. Na próxima sessão,
falaremos sobre ou
criaremos visualização em rolagem usando
um grupo de layout horizontal
e
um ajustador de tamanho de conteúdo Muito obrigado, pessoal. Nos vemos na próxima
sessão. Muito obrigado
34. Crie ScrollView horizontal usando o grupo de layout horizontal: Oi amigos. Meu nome
é Rohan Asad Na última sessão,
vimos um exemplo visualização de rolagem do
Unity usando grupo de layout
vertical
e um ajustador de tamanho de conteúdo Nesta sessão, veremos um exemplo da visualização de rolagem do
Unity usando o visualização de rolagem do
Unity usando Horizontal Layout Group
e o Content Size Fitter Então, basicamente, a
visualização de rolagem rolará, o conteúdo dentro da
visualização de rolagem rolará na direção horizontal
para criar uma visualização de rolagem. Clique com o botão direito aqui
na cena da interface do usuário. Vá para o objeto do jogo aqui, selecione UI aqui e
clique em Scroll View. Além disso, vamos ajustar a altura e a largura da visualização em rolagem. Há duas maneiras de fazer isso. Ou você pode clicar
aqui na ferramenta Re, ir para o modo de cena e simplesmente arrastar essa coisa. Ou então você pode definir diretamente a largura e a altura da roda
de rolagem. Vamos apenas alterar a
largura para 400 aqui, já que é uma visualização de
rolagem horizontal. E vamos manter a
altura em 150 aqui. Vamos apenas estender o objeto do jogo Scroll
View aqui. Ok, estenda o objeto do jogo
Viewport aqui e clique no conteúdo aqui Vamos para o modo cena aqui. Vamos ajustar a altura
do conteúdo para
corresponder à altura da visualização
de rolagem aqui usando uma ferramenta de transformação. Novamente, para as barras de rolagem aqui. Barra de rolagem horizontal. Ok, vamos ajustar
a altura para cinco. Ok, para a
barra de rolagem vertical, vamos manter a largura em zero, porque de qualquer forma, o conteúdo
não vai rolar
aqui verticalmente Vamos manter a largura em zero. Para a barra de rolagem
vertical aqui. Novamente, acesse Scroll View aqui. Clique no objeto do jogo de
visualização em rolagem aqui. E mantenha o tipo de momento para
fixar aqui e não elástico. Agora vamos adicionar algumas imagens
no conteúdo, ok? Mas antes de adicionar essas imagens, vamos adicionar dois componentes aqui. Está bem? Um é seu grupo de layout
horizontal, outro é seu ajustador de tamanho de
conteúdo Clique em Adicionar componente aqui
e selecione Grupo de
layout horizontal. Está bem? O preenchimento no canto superior esquerdo e
direito o ajustará posteriormente de acordo com a irmã e a aparência
da imagem aqui Ok, para o alinhamento da criança, queremos conteúdo rolável exatamente no centro
dessa visualização rolável, basicamente do canto superior esquerdo Mude para o
centro central aqui, ok? Em seguida, adicione outro componente que ajuste o tamanho do
conteúdo. Ok, ajuste horizontal,
vamos alterá-lo para o tamanho
preferido aqui. Tudo bem, depois de fazer isso, vamos adicionar uma imagem aqui. Para adicionar uma imagem ao
conteúdo, clique com o botão direito no objeto do jogo de conteúdo. Vá para UY e selecione Imagem aqui. Nossa imagem é adicionada
aqui no centro. Ok, agora vamos fazer uma coisa. Vamos definir um sprite
para essa imagem. Eu já
adicionei alguns sprites aqui na pasta sprites Vamos apenas arrastar e soltar para
esse usuário um sprite
na imagem de origem da imagem
que basicamente acabamos de adicionar OK. Clique em
preservar aspecto aqui, basta selecionar a imagem
e pressionar o controle D para copiar a imagem. Ok, vamos continuar
adicionando as imagens, ok? Agora clique na imagem um e vamos mudar
a imagem de origem. Para isso, basta alterá-la, arrastar e soltar a
imagem de origem aqui, certo? Basicamente, basta clicar
no conteúdo aqui, ok? E vá para o grupo de
layout horizontal aqui. E vamos ajustar o
preenchimento para isso. Vamos manter em cinco, ok, para a direita novamente, vamos manter em cinco. Para o topo, vamos
mudar para dez. Traga mais para o centro. Ok, parte inferior. Vamos
manter isso em zero. Não queremos
alterá-lo por espaçamento. Acho que o espaçamento parece bom aqui. OK. Ok, isso será tudo. Vamos examinar a cena e ver como essa coisa fica aqui. Acabamos de criar uma visualização de rolagem usando um grupo de layout horizontal
e um ajustador de tamanho de conteúdo, embora essa
visualização de rolagem basicamente role apenas na direção
horizontal Ok, obrigado pessoal. Obrigado pela
sessão. Nos
vemos na próxima sessão. Muito obrigado, pessoal.
35. Interface de usuário InpuField e componentes: Oi amigos, Meu nome
é Rohan Vase. Nesta sessão,
falaremos sobre a entrada de
interface do usuário preenchida no Unity. Basicamente, ele transforma
um rótulo simples em um elemento
de campo de entrada interativo onde você pode receber
entradas do usuário Portanto, geralmente é usado para
receber informações do usuário no Unity. Geralmente, ele é
usado para logins, registros ou para obter
qualquer tipo de dado flare Um componente de texto ou um jogo de
texto criado quando você cria um
componente de campo de entrada como um objeto filho. Agora, existem algumas propriedades
para o elemento do campo de entrada. Quais são essas propriedades? Interativo.
A propriedade interativa especifica o campo de entrada pode receber
qualquer entrada do usuário ou não Então, temos a propriedade de
transição. A propriedade de transição é
usada para determinar como um campo de entrada
reagiria no estado normal pressionado, destacado, selecionado
ou desativado. Ok, novamente, temos a propriedade
do componente de texto. A propriedade do componente de texto
se refere basicamente ao
componente de texto aqui. É uma referência ao componente de
texto, que é o objeto
do jogo de texto criado como um objeto filho para o componente do campo
de entrada. Então, temos o texto que é
a mensagem inicial de texto para o campo
de entrada antes de receber
a entrada do usuário, basicamente Ok. Então, temos o limite de
caracteres. limite de caracteres especifica
o número máximo de caracteres que o campo de
entrada pode ocupar Então, temos
mais algumas propriedades para a entrada da interface do usuário preenchidas no Unity. A propriedade do tipo de conteúdo
especifica o tipo de caracteres e o
campo de entrada pode dar um exemplo Pode ser um caractere
padrão, pode ser um endereço de e-mail
, pode ser uma senha, pode ser um número inteiro ou pode ser um número decimal Então, temos o tipo de linha. tipo de linha especifica o formato do texto no campo de entrada Esse formato pode ser ainda
classificado em três tipos. Linha única, o
texto pode
estar em uma única linha aqui, ok? Em seguida, temos o envio em várias linhas. O texto pode usar várias linhas
somente quando necessário. Significa simplesmente
que a nova linha é adicionada automaticamente
pelo campo de entrada aqui. Ok, então, com várias linhas, nova linha é novamente o texto
que pode usar várias linhas Uma nova linha pode ser adicionada
pelo usuário pressionando
a tecla de retorno aqui. Então, temos uma propriedade de
espaço reservado. espaço reservado é um caractere ou uma sequência
de caracteres que substitui o texto ou os dados finais
como uma dica ou legenda Então, basicamente, é uma dica
para seus dados de texto finais. Então, temos a taxa de intermitência da cenoura. de intermitência do cursor define
a taxa de intermitência da marca colocada no campo de entrada
indicando o local de inserção do texto Em seguida, temos a seleção de
cores. Cor é a cor de
fundo do texto selecionado
no campo de entrada. Qualquer que seja o texto selecionado
no campo de entrada, cor da
seleção especificará a cor de fundo
desse texto específico. Por fim, temos algumas funções para o campo
de entrada no Unity Primeiro, é sua função de mudança de
valor On. função On value changed é um evento Unity chamado quando o texto no campo
de entrada é alterado. Basicamente, quando você digita
algo dentro do campo de entrada no valor alterado, a função é
chamada ou invocada no Unity Por fim, temos uma função de edição
final. No final das contas, a função de edição é um evento do Unity
chamado quando o usuário envia o texto dentro do campo de entrada
enviando Ele é chamado até mesmo quando o foco é
removido do campo de entrada. Ok, então é isso, pessoal,
obrigado pela sessão. Na próxima sessão,
veremos um exemplo de
campo de entrada no Unity. Muito obrigado, pessoal.
36. Crie UI InputField e entenda os componentes: Olá amigos, Meu
nome é Rohan Sev. Nesta sessão,
vamos criar
um exemplo de imunidade de campo de
entrada UY Para criar um campo de entrada UY, clique com o botão direito do mouse
aqui na cena UY,
vá para o objeto do jogo, vá para UY e clique em campo
de entrada Ear
foi criado Agora vamos estender o objeto do jogo do campo
de entrada
dentro do objeto do jogo do campo de entrada. Teremos dois objetos de jogo,
espaço reservado e texto, que serão criados por
padrão, seu objeto de jogo Aqui está basicamente o texto da dica, que estará dentro
do campo de entrada Agora mesmo. Está
configurado para inserir texto. Vamos mudar para o nome. Aqui, sim, nosso
texto de espaço reservado mudou agora. Inicialmente, foi inserido o texto, nós o
alteramos para inserir o nome. Aqui podemos ver a mudança
aqui dentro do campo de entrada. Ok, este objeto de jogo de texto é basicamente o que será o usuário inserindo o texto que será
retirado do usuário aqui. Ok, vamos inserir o objeto do jogo de
campo aqui. Novamente, quando você cria um objeto de jogo Field de
entrada, ele terá um componente de
transformação Rec por padrão, anexado a ele No momento, a largura
e a altura da transformação
Rec estão definidas como 160,30
Vamos alterá-la para 170,70 Assim, podemos alterar o tamanho do
campo de entrada
ajustando a transformação rec do campo
de entrada novamente, ele terá um
componente de imagem anexado a ele, para que possamos alterar a cor Também podemos alterar a imagem de
origem. Está bem? Então, chegando ao componente de campo de entrada para o
objeto do jogo de campo de entrada aqui, ok? Ela terá uma propriedade
interativa momento em que estiver marcada Significa simplesmente que ele
será capaz de receber a entrada do usuário. Portanto, se você desmarcar
isso, não será possível receber
nenhuma entrada do usuário Então temos a propriedade de
transição. A propriedade de transição
basicamente especifica como o campo de entrada reagirá à mudança no estado ou à mudança de estado que chega à propriedade
do componente de texto aqui A propriedade do componente de texto aqui é a referência ao objeto do jogo de
texto aqui. Ok, novamente temos uma propriedade
de texto aqui. A propriedade de texto aqui
é o texto inicial que podemos adicionar antes de
receber a entrada do usuário. Então, temos a propriedade de
limite de caracteres. limite basicamente
especifica o número de caracteres que esse campo
de entrada específico pode ter, ok? Então, no momento não há
restrições sobre o personagem, vou definir o
limite de caracteres para zero, ok? Então, temos outra propriedade
que é um tipo de conteúdo. O tipo de conteúdo basicamente
especifica o tipo de conteúdo que esse
campo de entrada ocupará, ok? Há várias opções aqui. Temos um padrão, depois temos números inteiros corrigidos
automaticamente e podemos usar o número decimal Em seguida, temos nome, e-mail, ID, senha e filme. Também podemos definir um tipo de
conteúdo personalizado aqui. Então temos outra
propriedade que é o tipo de linha. tipo de linha especifica o formato do texto dentro
do campo de entrada Ok, existem três
opções para isso. Linha única. Uma única linha permite o texto somente
em uma única linha. Ok, não podemos ter
várias linhas. Se usarmos a propriedade de linha única
, teremos o envio de várias
linhas aqui Ok, vamos alterá-lo
para envio de várias linhas. E vamos comandar a cena. E vamos ver como essa
coisa funciona aqui. Ok, vamos tentar adicionar um texto longo aqui dentro
do campo de entrada. Este é um texto longo para uma
propriedade de envio de
várias linhas OK . Está bem? Então, como você pode ver aqui, uma nova linha é
criada automaticamente ao adicionar
o texto aqui. Está bem? Então, temos uma propriedade de
espaço reservado A propriedade de espaço reservado
é uma referência ao seu
objeto de jogo de espaço reservado aqui novamente Então temos uma cenoura. Cenoura é a marca, que na verdade é o local para a inserção do texto aqui Então você pode ver uma
marca piscando aqui, que é a cenoura
dentro do campo de entrada Está bem? Portanto, você pode aumentar ou diminuir o
piscar de olhos da cenoura aqui. Então temos uma largura de cenoura. Então, vamos tentar mudar
a largura da cenoura, ok, então a largura da
cenoura aumenta aqui. Se eu mudar para quatro, ok, então temos uma propriedade de cor de
cenoura personalizada
aqui, cor de cenoura personalizada Na verdade, podemos mudar
a cor da cenoura. No momento, está preto. Ok, podemos verificar essa propriedade personalizada de cenoura
aqui, propriedade de cor aqui E mude a cor
da cenoura da maneira que quisermos. Então, vamos mudar para vermelho. Então você pode ver aqui agora
que está na cor vermelha. Ok, então temos
outra propriedade que é uma propriedade de
cor de seleção. No momento, está definido como azul. propriedade da cor de seleção é basicamente a cor
de fundo do texto selecionado. Então, vamos selecionar um texto aqui. Portanto, essa é a cor de
fundo do texto selecionado,
que é azul. Vamos mudar a cor
para outra coisa. Ok, vamos deixar isso um
pouco escuro, provavelmente. Sim. Ok, então podemos alterar a cor de fundo
do texto selecionado aqui. Então, temos duas funções aqui. A primeira é sua própria mudança de valor. Na mudança de valor está o
evento Unity que é invocado quando o usuário está digitando algo
no campo de entrada aqui E, por fim, temos
uma função de edição, que é novamente um evento do Unity, que é invocada quando o usuário
envia o texto do campo de entrada ou mesmo se você remove o foco
do campo de Entraremos em detalhes
dessas funções quando
prosseguirmos com
as sessões em
que aprendermos sobre eventos
e funções. Ok, então é isso
para a sessão, pessoal. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
37. Slider de interface de usuário e componentes: Oi amigos. Meu nome
é Rohan Vasudev Nesta sessão,
falaremos sobre o controle deslizante de interface do usuário Unity O que é imunidade ao controle deslizante da interface do usuário? É um controle deslizante
padrão usado para definir um determinado valor entre o par de valores mínimo
e máximo É comumente usado
para controles de áudio e brilho da tela em
uma cena ou jogo. Agora, quando você cria um componente de controle deslizante de
interface do usuário, três objetos de jogo do
Unity, área de preenchimento de
fundo, alça área de
slide, também são criados
automaticamente como filhos Para o objeto de jogo root slider,
o que é objeto de jogo em segundo plano Aqui, o
objeto de fundo do jogo tem uma transformação Rec, um componente de imagem
anexado a ele Essa imagem será a imagem de fundo da área de preenchimento
do controle deslizante área de preenchimento novamente tem um componente de transformação Rec
anexado a ela e se estende do valor
mínimo ao
valor atual do controle deslizante Um objeto de jogo infantil para
o objeto de jogo da área de preenchimento
também é criado automaticamente. Esse objeto do jogo terá um componente de transformação e um componente de imagem
anexado a ele. Esse componente de imagem especifica a imagem e a cor do objeto de preenchimento
do jogo O que é alça? Área de slide? A área do slide da alça tem
um componente de transformação anexado a ela e segue o valor
atual de um controle deslizante Uma
alça de objeto de jogo infantil para a alça área do
slide também é
criada automaticamente Essa alça terá um componente de retransformação
e um componente de imagem
anexado a ela. Esse componente de imagem especifica a imagem e a cor do objeto
do jogo com alça Por padrão, o Unity
Knobprt é anexado ao objeto
do jogo handle como as propriedades
da imagem
de um propriedade interativa
especifica se
o controle deslizante é A propriedade de transição é usada para determinar como um controle deslizante
reagiria no estado normal pressionado, destacado, selecionado
e desativado Preencher é uma transformação para nós como preenchimento do controle deslizante
e é uma referência ao objeto
do jogo de preenchimento
que é criado quando você cria um
componente deslizante no Handle é novamente uma transformação a ser usada como alça para o
controle deslizante. É uma referência ao objeto
do jogo que é criado automaticamente quando você cria um componente deslizante no Direção é a
direção do controle deslizante do valor mínimo ao máximo Temos quatro opções de
direção da esquerda para a direita, direita para a esquerda, de cima para
baixo e de baixo para cima. valor mínimo é
o valor definido para o controle deslizante ou permitido
para o controle deslizante valor máximo é
o valor máximo definido para o controle deslizante ou
permitido para o controle deslizante, valor é o
valor atual do E, por fim, números inteiros são
basicamente um valor em ouro. Se estiver marcado ou
definido como verdadeiro, somente números inteiros
serão permitidos entre valores
mínimo e máximo para o controle deslizante É isso aí, pessoal. Nos
vemos na próxima sessão. Na próxima sessão,
veremos um exemplo de
controle deslizante de interface do usuário no Unity Muito obrigado, pessoal.
38. Crie o controle deslizante de interface de usuário e entenda os componentes: Oi amigos. Meu
nome é Rohan Dev Nesta sessão, veremos um exemplo de
controle deslizante de interface do usuário no Unity Para criar um controle deslizante de interface do usuário no Unity, clique com o botão
direito aqui
na cena UY, vá para o objeto do jogo, vá para a interface do usuário e selecione o controle deslizante Nosso controle deslizante é criado no Unity. Selecione o controle deslizante aqui e vá para o Inspetor Taber E podemos ver o componente de
transformação Rec anexado automaticamente ao objeto deslizante
do jogo Ao alterar a largura e a
altura da transformação Rec, podemos basicamente alterar o peso e a altura
do controle deslizante Chegando até aqui, temos um componente
deslizante anexado ao
objeto do jogo deslizante por padrão. Está bem? Então, podemos ver algumas propriedades aqui para o componente deslizante A propriedade interativa
basicamente
especificará se o controle deslizante
é interativo Agora está marcado, isso significa
que o controle deslizante
é interativo, ok? Então, temos a propriedade de
transição. A propriedade de transição é
usada para determinar como esse controle deslizante reagiria em uma mudança de estado ou reagiria em
uma mudança de estado específica Chegando à propriedade fill
wreck aqui fill wrecked property basicamente é usada como um
preenchimento Também é uma referência à Rec transform fill que é criada automaticamente dentro do objeto do jogo da área do campo Ok, a propriedade Handled Reck aqui é usada como uma alça para
o controle deslizante e, novamente, é uma referência ao objeto de jogo de
alça que
é criado automaticamente
dentro da área de
slide da alça . O objeto de jogo na propriedade de direção do
controle deslizante
especificará a direção de
um controle deslizante do valor mínimo Ok. Temos quatro opções para a propriedade de direção da
esquerda para a direita, direita para a esquerda, de baixo
para cima, de cima para baixo. Ok. Vamos executar a
cena aqui e ver como a propriedade de direção
funciona para um controle deslizante Atualmente, a direção
do controle deslizante está definida da esquerda
para a direita Esse controle deslizante se moverá
basicamente da esquerda para a direita. Ok, vamos mudar para
a direita para a esquerda. Esse controle deslizante basicamente
se moverá da direita para a esquerda
e, em seguida, teremos de baixo para cima Está bem? Esse controle deslizante
se moverá de baixo para cima E, por fim,
temos de cima para baixo. Esse controle deslizante se moverá
de cima para baixo. Ok, vamos
alterá-lo para o padrão, que é da esquerda para a direita aqui. Está bem? Então, temos o valor mínimo. valor mínimo é basicamente o
valor mínimo definido para o controle deslizante, atualmente está definido como zero E o valor máximo é o valor máximo definido para o controle deslizante Atualmente, está definido como um. Vamos mudar para 100, ok? Esse valor aqui é o valor
atual do controle deslizante. Está bem? Vamos mover o controle deslizante ou mover o **** aqui, ok? Podemos ver números decimais aqui quando movemos o
controle deslizante, basicamente E podemos ver que o
valor que muda é basicamente o
valor atual do controle deslizante No momento, é 24,83 e
está de volta a zero novamente. Então, vamos verificar os números
inteiros aqui. Números inteiros permitirão que o valor mínimo e máximo sejam
apenas números inteiros, ok? Então, vamos verificar a propriedade dos
números inteiros aqui. E vamos tentar mover
o controle deslizante novamente. O valor variável que podemos ver
aqui são todos os números inteiros. Não podemos mais ver
números decimais aqui, ok? E isso está acontecendo
porque acabamos de verificar a propriedade de números inteiros aqui. Está bem? Então é isso, pessoal. Isso é tudo para o
componente deslizante no Unity. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
39. Ancorar elementos de interface no Unity: Amigos, meu nome é Rohan Vdv. Nesta sessão, vamos
criar um exemplo para redimensionar, escalar e ancorar elementos de
interface do usuário Então, para fazer isso, vamos criar
um botão de UI no Unity. Ok, clique com
o botão
direito aqui na câmera principal, vá para UY e clique
no botão aqui Ok, então nosso botão é
criado aqui na cena do Unity. E se quisermos
exibir esse botão exatamente no
canto inferior esquerdo da cena, independentemente do
tamanho ou resolução da tela O Unity nos fornece
algumas proporções aqui. No momento, ele está configurado
para o aspecto livre. Temos uma proporção
de cinco é para quatro, que temos quatro é para três, que temos três para dois, que temos 16 por dez, temos 16 por nove e
temos sozinhos 1.024,2 Também podemos adicionar
mais proporções. Ok, vamos configurá-lo para aspecto
livre a partir de agora, que é basicamente a
proporção padrão. E se quisermos mostrar esse botão aqui
na extrema esquerda, parte inferior do C. Tente configurar esse botão aqui apenas
arrastando o botão aqui e definindo a
posição do botão Ok, para esse tamanho de tela
específico, o botão está aqui na
parte inferior esquerda da cena. Vamos tentar mudar a
proporção para cinco por quatro. Não, não está correto
, está saindo de cena. Ok, vamos tentar mudar a proporção
para quatro por três. Vamos tentar mudar a
proporção para 16 por nove. Não é adequado porque queremos que esse botão seja ancorado na posição exata, independentemente do tamanho da tela, da resolução da tela ou qualquer
proporção Ok, agora vamos tentar fazer isso. Para fazer isso primeiro, vamos clicar na tela aqui. Ok, para a tela, temos um
componente escalar de tela anexado
ao objeto de jogo de tela. Para a escala Y, mais alteramos o modo de escala de tamanho de pixel
constante para
escala com tamanho de tela Ok, agora vamos clicar
no botão aqui. Agora, queremos ancorar
esse botão
na parte inferior esquerda da tela Então, para fazer isso para
a transformação rec, Unity nos fornece
algumas predefinições de âncora aqui Ok, isso é ancoragem
vertical, e isso é basicamente
ancoragem horizontal Ok, então queremos que esse botão seja ancorado à esquerda verticalmente, então clique à esquerda aqui E queremos que esse botão seja ancorado na
parte inferior horizontalmente, então vamos clicar Ok, então desta forma
o botão será ancorado na posição inferior
esquerda Agora vamos para o modo de
cena aqui. E vamos
arrastar novamente o botão aqui e definir a posição do botão da
maneira que quisermos. Ok, agora vamos
para o modo de jogo novamente. E vamos ver a posição
agora para a tela de 16 por nove. Sim, está no canto
inferior esquerdo. Vamos tentar
alterá-lo para o aspecto livre. Sim, está na mesma posição. Vamos tentar mudar
para cinco por quatro. Sim, vamos tentar mudar
para quatro por três. Vamos tentar mudar
para três por dois, depois vamos tentar mudar
para 16 por dez. E vamos tentar transformá-lo em
autônomo, 1024 em 768. Vamos criar outro elemento
de texto. E vamos ancorá-lo
na posição superior esquerda
aqui na tela Ok, então para criar um texto de interface de usuário, clique com o botão direito do mouse
na tela aqui, vá para UY e vá para o texto aqui Ok, nosso texto é criado aqui, exatamente no centro
da tela. Ok, selecione seu objeto de jogo de
texto, vá para Rec Transform, Anchor presets aqui Verticalmente. Queremos que seja ancorado
à esquerda, ok, horizontalmente, queremos que
seja Vamos selecionar o topo aqui. Agora, novamente, vamos para
o modo de cena aqui. E vamos rastrear o elemento de texto aqui ou o objeto do jogo de texto aqui, exatamente no canto superior aqui. Agora vamos para o modo de
jogo novamente. Agora vamos tentar alterar
a proporção. Vamos tentar
alterá-lo para o aspecto livre. Vamos tentar mudar
para cinco por quatro. Vamos tentar mudar
para quatro por três. Vamos tentar mudar
para três por dois. Vamos tentar mudar
para 16 por dez. Vamos tentar mudar
para 16 por nove. Vamos manter o aspecto livre. Ok, então é assim que você
basicamente ancora, dimensiona ou redimensiona um elemento da interface do usuário ou
qualquer componente da interface do usuário no Unity Ok, isso é tudo para
a sessão, pessoal. Muito obrigado. Nos
vemos na próxima sessão. Muito obrigado, pessoal.
40. Introdução aos eventos Unity: Oi amigos. Meu
nome é Rowan Suv Nesta sessão,
falaremos
sobre funções de eventos no Unity. O que são
funções de eventos no Unity? O código dentro do
script Unity não funciona como um código tradicional em nenhum outro programa
ou em qualquer outro código. Em vez disso, o Unity passa
o controle para o script chamando
certas funções dentro dele. Essas funções são chamadas de funções de
evento, pois são executadas em resposta a determinados eventos durante
o jogo. Unity identifica
essas funções com base nos O Unity identifica
essas funções com base nos nomes
dados pelo próprio Unity e as executa de acordo com o evento durante o jogo Algumas das funções de
eventos importantes no Unity são as seguintes. Temos a função de ativação, temos a função de início,
temos atualização, temos atualização tardia e fixamos a função de ativação de
atualização. A primeira cena do jogo é carregada ao executar
o aplicativo do jogo. Então, quando você executa qualquer aplicativo de
jogo, a cena é carregada
e todos os objetos basicamente dentro da cena
ou dentro da cena, são inicializados após
o carregamento da cena Depois que os objetos são
criados e inicializados, função de
ativação dentro
do script Unity é invocada Ok, a função Awake
no script é basicamente uma função de
inicialização, que é a primeira função a ser executada dentro de um Essa função é chamada
somente uma vez e executada mesmo se o script não
estiver ativado ou ativo. Vamos ver o que é
a função inicial. função de início no script é chamada somente depois que uma
função de ativação é chamada. E é chamado uma vez
no ciclo de vida de um script. Ao contrário de uma função wake, ela é executada somente se o
script estiver habilitado no Unity. função de atualização é definida na
classe Monobehavior e será executada automaticamente em cada quadro do jogo se o
monocomportamento estiver ativo O que é moldura?
O quadro é basicamente uma imagem estática que é
renderizada na tela Está bem? A função de atualização é executada periodicamente enquanto
nosso jogo está em execução. A função de atualização é invocada
ou chamada uma vez por quadro. A chamada de uma função de
atualização
depende da taxa de quadros do
jogo. O que é taxa de quadros? taxa de quadros é basicamente
a frequência na qual as imagens consecutivas em aço
são renderizadas na tela O intervalo de tempo
será basicamente baixo para altas taxas de quadros e
alto para taxas de quadros baixas. função de atualização tardia é chamada uma vez por quadro após a conclusão da
atualização. Chamando. A função de
atualização tardia se comporta exatamente de maneira semelhante à de uma função de atualização, exceto pelo fato de ser chamada
somente após a
função de atualização Essa função é basicamente
usada para
fazer a câmera
seguir o jogador ou qualquer outro objeto do jogo. Por fim,
fixamos a função de atualização. A função de atualização fixa
não depende da taxa de quadros. A atualização fixa terá intervalos de tempo
constantes. função de atualização fixa pode ser
chamada várias vezes por quadro se a taxa de quadros for baixa ou não por quadro. Se a taxa de quadros for alta, é bem possível que a atualização
fixa seja chamada mais do que a função de
atualização. Ok, é isso aí pessoal, é
isso para a sessão. Na próxima sessão, veremos um exemplo das funções de atualização inicial, atualização
tardia e
atualização fixa. Também veremos a
diferença entre eles. Nos vemos
na próxima sessão. Muito obrigado, pessoal.
41. Entenda as funções do Unity Event em um roteiro: Olá amigos, meu
nome é Rohan Sev. Nesta sessão, veremos
um exemplo de funções de wake start,
update, late update e fix update
dentro do script no Unity. Para isso,
já criamos um objeto de jogo
vazio aqui. E o nome do
objeto vazio do jogo é funções de eventos. Também criamos um
script, funções de eventos. Vamos abrir o script aqui. Ok, vamos adicionar uma função de ativação, função de atualização
tardia e função de atualização
fixa
ao script. Ok, pessoal,
adicionamos a função de ativação, função de
atualização e função de atualização
fixa ao script aqui, ok? A função Awake é basicamente a função de
inicialização. E será a
primeira função a ser chamada dentro do script. Quando você executa um aplicativo, qualquer aplicativo de jogo, os objetos são
inicializados e criados primeiro Depois que os objetos forem
criados e inicializados, função
awake será invocada e chamada
dentro do Vamos imprimir algo
dentro da função de ativação. Esta é uma função de despertar, ok? Então, chegando à função inicial, a função inicial
basicamente será chamada somente após a função de ativação ser
executada, ok? A função Start
será chamada somente uma vez no
ciclo de vida do script. Vamos imprimir algo dentro
da função de início também. Função de partida. Ok, chegando à função de
atualização aqui, função de
atualização será chamada somente após a função de
início ser invocada A função de atualização será
chamada uma vez por quadro. A chamada da função de
atualização
depende totalmente da
taxa de quadros do jogo. Vamos imprimir algo dentro
da função de atualização também. Ok, a função de atualização
é executada. Vamos adicionar uma função no Unity que é time
dot delta time. Basicamente, o
tempo delta do ponto temporal realmente nos dirá o tempo necessário para a conclusão
do último quadro aqui.
OK, chegando à função de atualização
tardia, a função atualização novamente
é chamada de um quadro. É exatamente como a função de
atualização, mas a única diferença é
que a função de atualização será chamada somente após a execução da
função de atualização. função de atualização
pode ser usada se você quiser que sua câmera siga o jogador ou
algo parecido,
ou talvez queira que sua câmera siga qualquer outro objeto do jogo. Vamos imprimir algo dentro da função de atualização
tardia. função de atualização tardia é executada novamente Vamos adicionar o tempo delta de tempo. Isso nos dirá o
tempo necessário para a conclusão
do quadro. Basicamente, chegando à última função de atualização
fixa aqui, a função de atualização fixa
basicamente não depende da
taxa de quadros do jogo, ok? O intervalo de tempo entre as funções de atualização
fixa sendo chamadas é sempre
constante no Unity. Vamos imprimir algo novamente dentro da função de
atualização fixa. Está bem? A atualização é executada em, vamos adicionar o tempo delta de tempo novamente. Ok, vamos
dirigir o sênior. Ok, pessoal, aqui está a
saída do código. Esta é uma função de ativação. A função Awake será a
primeira função a ser executada. Então, temos a função de início que seguirá a função de ativação Posteriormente, as funções de
atualização fixa, atualização
e atualização tardia
serão executadas. A função de atualização fixa não depende da taxa de
quadros e o intervalo de tempo
na função de atualização fixa
sempre será constante, ok? Então, toda a
função de atualização fixa basicamente
terá 0,02 aqui, ok? Como função de atualização de saída
e funções de atualização tardia, ambas
têm 0,02 como
intervalo de tempo, ok? Mas se cairmos, esse tempo mudará aqui
tanto para a função de atualização quanto para a função de atualização
tardia, já que ambas
as funções dependem basicamente
da taxa de quadros do jogo. Ok, então é isso, pessoal. Obrigado pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
42. Introdução às funções personalizadas no Unity: Meus amigos, meu nome
é Rohan Vasudev. Nesta sessão,
aprenderemos sobre funções personalizadas ou definidas pelo usuário
no Unity C Sharp. Então, quais são
as funções personalizadas no Unity? Uma função basicamente
é um bloco de código usado para executar uma
única ação ou tarefa. Ele fornece extensibilidade
ao aplicativo de jogo
junto com reutilização do código e economiza tempo para
reescrever Uma função no Unity tem
os seguintes componentes. Nome da função, tipo de retorno, especificador de acesso ao
corpo
e parâmetros sintaxe de uma função básica no Unity C sharp é a seguinte Primeiro, especificamos o especificador de
acesso, que é seguido
pelo tipo de retorno, depois pelo nome da função, seguido por colchetes
e Dentro das calibragens,
fornecemos o bloco de código ou
o corpo da função Vamos ver um por um. O que é nome da função?
Qual é o tipo de devolução? O que é corpo? O que
é especificador de acesso E o que são parâmetros
em uma função? Nome da função. O
nome da função é um nome dado à função, ok? Então temos o tipo de retorno. tipo de retorno especifica qual tipo de
dados da função
retornaria como valor Então temos corpo, tem um bloco de código a ser
executado dentro da função. Esse corpo ou bloco de código estará dentro da
função, basicamente. Então, temos o especificador de acesso. O especificador de acesso
especifica a acessibilidade de uma função dentro
do aplicativo Pesameters são os argumentos
passados em uma função. Esse é um componente opcional. Agora, uma função pode ser uma função básica ou uma
função com tipo de retorno ou uma função com parâmetros. A função básica é basicamente uma função simples
com um bloco de código a ser executado internamente. Uma função com tipo de retorno especifica o tipo
de dados do valor retornado
de uma função Em palavras simples, ele especifica
o tipo de saída. Se o tipo de saída for número, o tipo de retorno poderá ser int, float, double etc Função com parâmetros. Os parâmetros são basicamente
as informações passadas para a função. Esses parâmetros atuam como uma
variável com tipo de dados. Essas são variáveis
basicamente com um tipo de dados. Esse tipo de dados pode ser int
ou uma string, etc. Eles são passados após declarar o
nome da função. Dentro do colchete, você especifica
o nome da função e o nome da função é seguido pelos
colchetes, basicamente Está bem? Dentro desses colchetes, você declara esses parâmetros Agora, não há nenhuma
restrição ao número de parâmetros que você
pode passar para uma função Mas cada parâmetro deve
ser separado usando. Você pode passar
vários parâmetros, mas cada parâmetro precisa
ser separado por uma vírgula Ok, é isso aí, cara. Na próxima sessão, veremos
um exemplo função
básica com tipo de retorno e função com parâmetros. Muito obrigado, pessoal. Nos vemos na próxima
sessão. Muito obrigado.
43. Escrever uma função básica em um roteiro: Oi amigos, Meu nome
é Rohan Vase. Nesta sessão, veremos um exemplo para
escrever uma função simples no Unity. Para escrever uma função simples, já
criamos
um objeto de jogo vazio. E o nome do
objeto vazio do jogo é uma função simples. Aqui também criamos o Act, e o nome do script
é uma função simples. Também anexamos
o script ao objeto vazio
do jogo, função
simples. Vamos abrir o script aqui e escrever um trecho de código. Para declarar uma função, precisamos especificar um
modificador de acesso para a Vamos usar o privado aqui. Privado significa simplesmente que
essa função não estará acessível fora
da classe ou fora desse script
específico. O modificador de acesso em uma função é seguido
por um tipo de retorno Nesse caso, é nulo porque essa função específica não
retornaria nada Está bem? Em seguida, precisamos especificar
o nome da função. Vamos colocar minha função. Esse nome pode ser de sua
escolha, pode ser qualquer coisa. Acabamos de colocar o nome
como minha função aqui. Está bem? E então
temos calibragens. E dentro das calibragens, escreveremos o trecho de código a ser executado dentro da função Nesse caso, vamos
imprimir algo no console exclusivo com
a
ajuda da função de bloqueio de bugs. Essa é uma função simples, ok? Como executamos a função logo após o nome
da função, que é minha função
no nosso caso. Dentro da função de partida. Aqui está minha função. Ok, vamos salvar
o script, ok? Então aqui está, pessoal.
Aqui está a saída. Essa é uma
função simples no Unity. Então, muito obrigado, pessoal. Nos vemos na próxima,
na próxima sessão sobre a qual
falaremos, veremos um
exemplo basicamente de função com um tipo de retorno. Muito obrigado, pessoal.
44. Escreva uma função com o tipo de retorno: Oi amigos. Meu nome
é Rohan Vasudev Nesta sessão,
veremos
um exemplo de função
com tipo de retorno. Já criamos uma função de
retorno de objeto de jogo vazia
e uma função de retorno de script. Já anexamos o script ao objeto
vazio do jogo. Aqui, vamos abrir o
script e escrever um trecho de código
dentro do script. Ok, então vamos adicionar
uma função aqui. Uma função com tipo de retorno especificará o tipo de dados ou a função de valor
retornará. Vamos adicionar um
modificador de acesso à função. E vamos adicionar o tipo de
retorno aqui. Vamos fazer com que essa função
retorne um número. Vamos adicionar um
tipo de retorno como oito aqui. E vamos nomear o tipo de
função da função. Esse é o nome da função. Esse nome pode ser qualquer coisa
de sua escolha. Está bem? Agora, como
é um tipo de retorno, temos que especificar os dados que serão retornados aqui da função
usando uma palavra-chave return. Ok, agora para fazer isso, vamos declarar uma variável dentro da função
em variável Vamos declarar a
variável número um, que é do tipo de dados interior E vamos atribuir a variável de
valor dez, ok? Vamos simplesmente retornar essa variável número um,
já que é um número, ok? Agora, vamos passar a função com retorno
dentro da função inicial. Então, vamos passar essa função dentro da função debug
dot lock, porque essa
função específica retornará um número, ok? Função com tipo de retorno, ok? Ok, é isso aí, pessoal.
Aqui está a saída. Então, temos dez aqui no console
do Unity. Muito obrigado, pessoal. Nos vemos na
próxima sessão. Na próxima sessão, veremos um exemplo de parâmetros de
função, como passar parâmetros, função
suficiente. Muito obrigado, pessoal.
45. Escreva uma função com parâmetros: Oi amigos. Meu
nome é Rohan Sue Nesta sessão, veremos um exemplo de parâmetros de
função
para essa finalidade. Já criamos
um objeto de jogo vazio. E o nome do objeto
vazio do jogo é função de parâmetro. E também criamos uma função de parâmetro de
script. E já
anexamos o script à função de
parâmetro
do objeto do jogo. Aqui, vamos abrir o script e escrever um código
dentro do script. Ok, vamos declarar a função com parâmetro
dentro desse script Agora, para declarar uma função, vamos começar com um modificador de
acesso Vamos especificar o tipo de
retorno como void, porque essa função não
retornará nada Vamos nomear a função
como minha função. Ok, agora teremos que
passar os parâmetros
dentro dos colchetes aqui O parâmetro é basicamente
uma informação passada para a função. Essas informações atuam como uma variável que
tem um tipo de dados. Vamos passar um parâmetro aqui
com um tipo de dados de string. Primeiro nome da string, este é um
parâmetro, função interna. Vamos passar outro parâmetro, sobrenome do tipo de dados string
usando uma vírgula, aqui podemos passar vários parâmetros, função
interna, ok Agora, imprima o
nome e o sobrenome aqui. Basicamente, para imprimir
os parâmetros aqui, vamos usar a função de registro de depuração E vamos imprimir algo
dentro do log de pontos do bug. Está bem? Vamos dar um
espaço aqui, ok. Bem-vindo. Primeiro nome, ok? Além de sobrenome duplo. Está bem? Usamos
códigos duplos aqui para fornecer um espaço entre o nome
e o sobrenome, basicamente. Está bem? Agora, vamos adicionar a função de função
dentro da função inicial. Então, quando executarmos a cena, minha função será executada. Minha função, temos que
passar os parâmetros aqui. Está bem? E os parâmetros devem
ser do tipo de dados de string. Então, vamos passar o primeiro
nome aqui, Danny. E usando uma vírgula, vamos passar o sobrenome OK. Santiago. Ok, é isso mesmo. Ok, bem-vindo, Danny Santiago. Temos a saída aqui. É isso aí, pessoal. Isso é
tudo para a sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
46. Introdução aos delegados de unidade: Olá amigos, Meu nome
é Rohan Vasudev. Nesta sessão, veremos
os delegados em união. Shaw. O que são delegados Os delegados são indicadores de
referência para as funções ou
métodos na unidade A função atribuída
ao delegado é tratada ou passada como uma variável para que possa ser
chamada ou executada Um delegado funciona como um serviço simples
baseado em assinatura, em que a função é
chamada ou executada ao assinar esse delegado
específico As funções são basicamente
subscritas ao delegado. Quando você chama o delegado, a função é
executada ou chamada Chamar o delegado
notificará todas as funções
que estão inscritas nele Sintaxe para um delegado na unidade, har public delegate Meu delegado público estático, Meu delegado, Meu delegado Um delegado no Unity
CR é definido usando a palavra-chave delegate
seguida por um Uma variável de membro
é declarada usando o tipo de membro seguido
pelo nome da variável. Então, vamos ver alguns
dos tipos de delegados no UnityChar Delegado de carros individuais. Carros individuais delegam pontos a uma única função ou método Uma única função
é inscrita ou atribuída ao delegado
usando o sinal igual Portanto, esta é uma sintaxe para um
único delegado de carros onde especificamos o delegado
com um sinal de igual a, especificamos o nome
da função Então, temos delegados
multicast. delegado multicast aponta para uma única ou várias
funções ou métodos. A invocação um delegado multicast invoca
todas as funções que se inscrevem nele de forma sequencial, uma por uma As funções são inscritas no delegado usando
mais igual a seno e cancelam a inscrição
usando menos igual a Portanto, essa é a sintaxe de
um delegado multicast. Delegar mais é igual ao
nome da função. É isso aí, pessoal.
Obrigado pela sessão. Na próxima sessão,
vamos criar um exemplo para
delegados em união C afiado. Muito obrigado, pessoal.
47. Entenda os delegados de elenco único: Oi amigos, Meu nome
é Rohan Vase. Nesta sessão,
vamos criar um exemplo
para delegado de elenco único no Unity Já criamos
aqui dois scripts aqui. Um é seu identificador de delegado
e o outro é meu script. Ok, agora, para começar, vamos começar criando
um objeto de jogo vazio. Para criar um objeto de
jogo vazio aqui, clique com
o botão direito aqui na cena
do delegado Ok, vá para o objeto do jogo e
vá para Criar, Vazio aqui. Está bem? Renomeie o objeto do jogo
para delegar o objeto, ok E basta anexar o identificador de delegado do
script a esse
objeto vazio do jogo aqui, ok? Clique em Adicionar componente
aqui e
pesquise o
script de identificador do delegado, ok? E vamos anexar o script. Vamos abrir o script aqui e escrever um trecho de código. Vamos definir basicamente o delegado aqui neste
script de identificador de delegado Ok, então vamos remover as funções de
início e atualização daqui. Não precisamos deles, ok? Agora, para definir o delegado, ok, primeiro temos que
especificar o modificador de acesso Nesse caso, será público. Ok, então vamos usar um delegado de palavra-chave para definir
um delegado basicamente. E então temos que
especificar o tipo de retorno, que é amplo porque não
retornaremos nada
desse delegado Ok, vamos especificar
o nome do delegado. Vamos mantê-lo como meu delegado. Ok, então vamos criar uma variável de membro para esse delegado específico
que acabamos de criar Está bem? Então, vamos manter
o acesso modificado para público aqui também.
Mantenha-o estático. Está bem? E então meu delegado, ok, o nome
do delegado que acabamos de criar aqui E depois é só passar a
variável para o delegado. Ok, então vamos
manter isso como meu acordo. Ok, é isso mesmo. Ok,
então criamos, definimos um delegado
como meu delegado aqui. Ok, esse é o nome
do delegado. E então criamos uma variável de
membro, my del, para meu delegado que
criamos aqui acima Ok, vamos criar uma
função aqui que realmente
funcionará
no botão. Clique no clique de um botão. Vamos criar
um botão na interface do usuário
e, por meio do botão, chamaremos esse delegado
específico Ok, vamos criar uma
função para isso aqui, vazio
público, meu clique Ok, vamos passar
a variável aqui, meu Dell. Dentro do clique. Quando clicarmos no
botão no clique do botão, chamaremos essa função
específica de meu clique. Então vamos passar isso do meu Dell dentro
da função my click, que chamará o
delegado que
acabamos de criar, ok? Ok, a imagem é criada
no centro. Não estamos adicionando nenhum
sprite à imagem, basicamente para este exemplo
em particular, ok? Vamos mudar
a cor da imagem. Agora está
na cor branca, ok? Então, vamos mudar a cor usando
o código, basicamente por meio do script e também usando o delegado Já criamos um script aqui,
que é meu script. Ok, vamos escrever um trecho
de código dentro do script para alterar basicamente
a cor da imagem. Ok, então não precisamos de uma função de atualização aqui
dentro do meu script. Vamos criar uma função aqui para alterar a cor da imagem. Ok, então d, vamos nomear a
função como mudança de cor. Está bem? Para alterar a
cor da imagem, precisamos chamar a imagem
componente do objeto do jogo de imagem.
Então, como fazemos isso? Ok, o objeto do jogo não
obtém a imagem do componente. Está bem? Cor é igual a. Para aplicar
cores aleatórias à imagem, vamos usar uma
função dentro do motor Unity, que é HSV com cor de ponto aleatório Para fazer isso, vamos chamar o motor
Unity primeiro. Está bem? Então vamos chamar a função
aleatória dentro dela, faça a cor H, a
cor aleatória H, ok? E o HSV colorido é uma função. Está bem? Então, isso basicamente aplicará cores aleatórias ao componente de cor da
imagem. Está bem? Agora, esse componente de imagem
aqui está mostrando um erro, basicamente porque precisamos
colocar o Unity Engine aqui. Ok, Unity Engine. Ok, agora precisamos chamar
nosso representante aqui. O delegado que
acabamos de definir
dentro do script de
identificador do delegado Precisamos chamar meu Dell aqui na
função de início do meu script, basicamente. Então, como fazemos isso? Simplesmente passamos a referência para o
script de identificador do delegado e depois
só precisamos chamar
meu del aqui, ok? É igual a. Podemos passar a
função change color para isso. Está bem? Portanto, a função de mudança de
cor é então
assinar o meu delegado. Ok, quando chamarmos meu delegado, função de
mudança de cor
será executada Ok, agora vamos apenas
dizer o roteiro. Vamos aplicar esse script ao objeto
do jogo de imagem
no botão. Clique em Queremos
chamar o delegado,
ok, que acabamos de definir Vá para o botão aqui, e então você pode ver
no clique aqui, ok? Basta clicar no sinal de mais aqui para adicionar a função
à lista aqui. Porque agora está vazio. Precisamos adicionar a função. Precisamos adicionar meu clique. Está bem? Quando chamarmos
essa função, meu clique, meu delegado
será chamado Ok, vamos adicionar minha
função de clique a isso, ok? Vamos apenas arrastar e soltar o objeto
delegado aqui, ok? E, no momento, não está mostrando
nenhuma função porque
não anexamos nenhuma função,
basta clicar nela. Acesse o
identificador de delegado, script aqui. Delegue o identificador e basta selecionar meu clique aqui. É isso mesmo. Agora, quando eu
clico no botão aqui, a cor da
imagem deve mudar. Está bem? Basta selecionar Image
Game Object aqui, e vamos ver a mudança de cor
aqui no botão e aqui também, ok. Sim, agora podemos mudar a
cor ao clicar no botão. É isso mesmo. Isso é
tudo para a sessão. Na próxima sessão, veremos um exemplo de
delegado multicast no Muito obrigado, pessoal.
Muito obrigado
48. Entenda os delegados de vários elenco: Olá amigos, meu nome
é Rohan Vase. Nesta sessão,
vamos criar
um exemplo para delegado de
multicasts Na última sessão, criamos um exemplo para delegado de
carros individuais E com um
clique de botão, pudemos mudar a cor
da imagem dessa forma. Ok, então nesta sessão, basicamente vamos
adicionar outra função
ao delegado. Quando você clica no botão, ele não apenas
muda a cor, mas também move
a posição da imagem no eixo x. Aqui, a diferença entre um único delegado de carros
e um delegado de multicast Em um único delegado de carros, somente uma única função pode ser atribuída ou inscrita
a um E no delegado multicast, várias funções
ou métodos podem ser
atribuídos ou inscritos
ao Vamos adicionar mais uma
função ao script. E vamos chamar essa função neste clique de botão também. Vamos adicionar uma função
aqui para alterar a posição da imagem. Vamos nomear a função como posição
alterada, ok? Agora, para mudar a posição, vamos usar a posição do ponto de
transformação para o objeto do jogo, ok? Basicamente,
vamos mudar a posição
do ponto de transformação e
vamos usar o novo vetor t aqui. novo vetor para funcionar aqui
especifica a direção
de quaisquer dois objetos do jogo Vamos alterar a
posição do ponto de transformação da imagem. Para fazer esse
objeto de jogo, transforme posição igual ao
novo vetor dois Está bem? Essa é a
função dentro da unidade. E temos que passar os parâmetros aqui
para uma função, ok? Queremos mudar a
posição do objeto do jogo. Basicamente, no eixo x, o
objeto do jogo transforma a posição x. Vamos adicionar 20 pontos flutuantes toda vez que clicarmos
no botão aqui. Ok, no eixo y, não
queremos
mudar a posição a partir de agora, queremos mantê-la constante. Mais uma coisa, vamos atribuir essa função de mudança de posição
ao delegado aqui, ok? Agora, na última sessão, já
inscrevemos essa
função de mudança de cor no del,
ok, usando igual a seno Agora, se você quiser que
várias funções sejam inscritas
no delegado, você precisa adicionar um seno
positivo Está bem? Então, vamos
alterá-lo para mais igual a. Está bem? Então, vamos novamente atribuir a
função de mudança de posição ao del. Ok, então faça isso. Vamos passar uma referência ao delegado do
Dl novamente. Ok, o p é igual a, vamos passar o nome da
função, mudar de posição. Ok, é isso mesmo. Ok, vamos salvar o script. Ok, vamos ver aqui a
saída do código. Basta clicar na imagem do objeto
do jogo aqui. No momento, a posição X objeto do jogo de imagem é zero e a posição do objeto do
jogo de imagem é zero. Não vamos mudar
a posição objeto do jogo de imagem, vamos apenas
mudar a posição objeto
do jogo de imagem toda
vez que clicarmos no botão. Ele vai adicionar 20 aqui. Ok, vamos rodar a cena e ver a saída. Ok, então vamos
clicar no botão. Ok, ele adicionou 20 a ele. Mais uma vez eu
clico no botão, são 40, agora 60, e sim, é. Mudando a posição
e a cor também. Então é isso, pessoal.
Obrigado por esta sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
49. Introdução aos eventos de delegação: Olá amigos, Meu
nome é Rohan Sud. Nesta sessão, veremos
o que são eventos em união. C afiado. Basicamente, podemos
usar eventos com delegados no Unity
Sharp. O que são eventos? Os eventos são delegados
multicast especiais que agem da
mesma forma que Ao contrário dos delegados, que podem
ser chamados por outros scripts, os eventos só podem ser chamados de
dentro de sua classe. Ou roteiro. A diferença entre delegados
e eventos é a seguinte. Agora, já vimos como você define um delegado
nas últimas sessões Definir um delegado em delegate handle public
delegate void,
My delegate public
static, my delegate del Chamando um delegado
de outro script, delegate handle dot del O código acima será executado
sem produzir nenhum erro. Esse identificador de delegado domidel, onde na verdade estamos chamando
o delegado passando a referência do script,
será executado no Unity Não produzirá nenhum erro ao definir um
evento em delegate handle,
Dotscript, public delegate void, my delegate public static
event, my delegate del Então, usamos uma palavra-chave de evento
basicamente para definir um evento, tentando chamar um evento de outro script,
delegar o identificador del Agora, o código acima
produzirá um erro e o erro será O
identificador de delegado del só pode aparecer no
lado esquerdo de mais igual
a ou menos igual a y. Del não pode ser passado diretamente
ou usado diretamente em outro script quando Ok, por que usar eventos
junto com delegados? Os eventos fornecem segurança,
pois não podem ser acionados
por outros scripts. A lógica do jogo não é
exposta quando usamos eventos. Event faz com que, quando um delegado é declarado
como parte da classe, ele exponha apenas
os
métodos de adição e remoção de acordo com o
modificador de acesso fornecido ao Ok, digamos que você tenha uma empresa de revistas
e as pessoas possam assinar sua empresa para receber uma nova
revista todo mês. Você pode pensar nesse delegado
como a empresa da revista. E o evento é
onde as pessoas podem assinar sua revista
ou sua empresa de revistas. Portanto, sempre que uma nova
edição for lançada, o evento basicamente informará a
todas as pessoas que já se inscreveram que uma
nova edição foi lançada. E sim, você está pronto
para receber a revista agora. OK. Então é isso, pessoal.
Obrigado pela sessão. Na próxima sessão, criaremos um exemplo para
eventos junto com o delegado. Muito obrigado, pessoal. Nos vemos na
próxima sessão.
50. Mova uma imagem de interface do usuário para a esquerda e a direita usando o Delegate-Events: Olá amigos, Meu nome é Ron Sede. Nesta sessão,
vamos criar um exemplo para
delegar com eventos Ok, para esse propósito,
criamos uma imagem
aqui no centro
e, em seguida, temos
dois botões aqui. Ok, também criamos
um objeto de jogo vazio, objeto de
evento, e
anexamos um evento de
delegado de script aqui Dentro do script de
evento delegado, declararemos
delegado e eventos também para a imagem.
Aqui anexamos um script de evento de script no
qual escreveremos
um código para mover a imagem para a esquerda ou para
a direita Vamos declarar um delegado
primeiro, delegado. Esse delegado não
vai devolver nada. Ok, vamos nomear o
delegado como delegado. Então, vamos declarar um
evento, público estático. Ok, declaramos um evento
usando uma palavra-chave de evento e depois deixamos o delegado, para a esquerda Ok, então vamos declarar
outro delegado. Delegado, delegado certo. Vamos declarar outro evento, evento público estático, delegado
certo Agora vamos criar
funções aqui para delegar separadamente na
função delegada esquerda E a outra função
chamará o delegado direito, delegado público esquerdo Dentro disso,
chamaremos o delegado esquerdo. Ok, vamos declarar
outra função aqui para chamar delegado certo,
público vazio, delegado público vazio, Dentro dessa função,
vamos chamar o delegado. Ok, vamos declarar
duas funções, id
público, à esquerda Isso serve para mover a
imagem para a esquerda
no eixo x. É isso mesmo. Esse código moverá a
imagem para a direita. Agora vamos inscrever
nossas funções aqui, mover para a esquerda e ir para a
direita para os eventos. Para fazer isso, vamos passar uma
referência ao script. Delegar evento para a esquerda mais é igual para ir para a esquerda E delegue o evento da maneira certa igual para É isso mesmo. Digamos que o roteiro. Ok, vamos até
o botão esquerdo aqui e clique
no ícone de adição aqui. Ok, vamos rastrear e soltar
o objeto do evento aqui. Está bem? E vamos anexar a função de delegar
evento aqui, ok? E anexe a função de
delegado esquerdo aqui. Está bem? Agora, do mesmo jeito. Vá para o botão direito aqui, clique no sinal de adição aqui, arraste e solte o objeto do evento aqui. Em seguida, vá para a função Delegar
evento. E selecione executar, certo? Delegue aqui. Ok, então é
isso. Vamos comandar a cena. E vamos ver a saída aqui. Ok, vamos clicar
no botão esquerdo do Moo. Ok, a imagem está
se movendo para a esquerda. Vamos clicar no botão direito. A imagem está se movendo
para a direita. Então é isso, pessoal.
Obrigado pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
51. Introdução ao sistema de entrada de unidade: Meus amigos, meu
nome é Rohan Sev. Nesta sessão,
aprenderemos
sobre o sistema de entrada no Unity. O que é um sistema de entrada? O sistema de entrada implementa um sistema para usar qualquer
tipo de dispositivo de entrada Pode ser seu mouse, pode ser seu teclado,
etc., para controlar
o conteúdo do Unity O sistema de entrada
é composto por duas partes, classe
de entrada e gerenciador de entrada. Métodos da classe de entrada são usados para implementar
entradas em um jogo Input Manager especifica
as configurações do projeto, nas quais os botões acessam as entradas Pressões de teclas e cliques
do mouse podem ser atribuídos de dispositivos reais
a entradas virtuais Esse gerenciador de entrada pode ser encontrado em Editar
configurações do projeto Gerenciador de entrada. É assim que um
gerenciador de entradas se pareceria. Ok, como dito anteriormente, sistema
de entrada no Unity pode implementar qualquer tipo de dispositivo de
entrada, basicamente. Vamos vê-los um por um. Entradas de teclado. O sistema
de entrada pode ser usado para implementar ou
detectar entradas de teclado Podemos obter informações de diferentes operações
realizadas no teclado. Algumas dessas operações são
as seguintes. Pressione a tecla para baixo. O pressionamento da tecla é acionado. Basicamente, quando você pressiona qualquer
tecla, insira um ponto para pressionar a tecla. função é acionada aqui e dentro da função
entre colchetes, precisamos especificar o código da
tecla. O espaço de pontos aqui é usado para identificar o botão de
espaço no teclado, existem vários desses valores Unity para aceitar as
entradas do teclado Manter a tecla pressionada,
a tecla
pressionada é acionada quando você
pressiona é acionada quando você
pressiona a tecla e a segura Basicamente, a função de entrada dot
get key é acionada quando você mantém
a tecla pressionada, ok? Dentro da função de entrada dot
get key, você precisa especificar
a chave novamente. A tecla liberada é acionada quando você pressiona a tecla
e a solta. tecla de ponto de entrada é
acionada quando você solta a tecla após
pressioná-la e dentro dos colchetes. Novamente, precisamos especificar as entradas
da tecla do mouse. O sistema de entrada também pode ser usado para implementar ou detectar entradas
do mouse Podemos obter informações a partir de cliques do mouse e operações
realizadas com o mouse Algumas dessas operações
são as seguintes. Botão do mouse clicado. O botão do mouse clicado novamente é acionado quando você
clica no botão do mouse Ok, input dot get mouse button down é a função
acionada aqui. E zero aqui é o botão
esquerdo do mouse. Da mesma forma, um é para o botão direito do mouse e dois é para o botão do
meio do mouse. botão do mouse é pressionado, ponto de
entrada e o botão do mouse é acionado quando você mantém
o botão do mouse pressionado, botão
do mouse solto
é acionado. Quando você clica no
botão do mouse e o solta, botão
input dot get mouse up é acionado quando você faz isso. Ok, vamos
às entradas do eixo. Agora, um eixo se refere
a um valor entre -1,1 com zero sendo
um valor padrão O stick analógico fornece valores nos eixos vertical e
horizontal entre -1,1 O mesmo vale para o teclado, onde as teclas de seta esquerda e direita são o eixo horizontal e
as teclas seta para cima
e para baixo são o eixo vertical, o eixo
horizontal Ponto de entrada para obter eixo. Horizontal é usado basicamente para definir o momento
no eixo horizontal. E para o eixo vertical, usamos a entrada dot
get axis vertical. É isso aí, pessoal.
Obrigado pela sessão. Nos vemos na
próxima sessão. Na próxima sessão, veremos um exemplo de como
implementar entradas de teclado Imunidade. Muito
obrigado, pessoal.
52. Entenda e implemente entradas de teclado no Unity: Olá amigos, meu nome é Roan Sev. Nesta sessão,
vamos implementar entradas de teclado no Unity Ok, para esse propósito, já
criamos
um objeto de jogo vazio, objeto do sistema
de entrada aqui. E também
criamos um script. E o nome do script
são entradas do teclado. Anexamos um script
ao objeto vazio do jogo,
que é o objeto do sistema de entrada. Vamos escrever um trecho de código
dentro do script de entrada do teclado. Dentro do script,
precisamos implementar todas as entradas do teclado dentro função de atualização
no Unity Primeiro, precisamos
verificar que tipo de operação está sendo
executada no teclado. Essas operações
seriam sua tecla pressionada, tecla pressionada continuamente
e, por último, seria sua tecla liberada Ok, para fazer isso, para começar, vamos verificar com
uma condição if, se a tecla
foi pressionada ou não. Está bem? Vamos declarar
uma condição if aqui. Insira a chave de obtenção
dentro do suporte. Aqui, precisamos especificar a chave. Nesse caso, vamos usar uma tecla de espaço aqui
no teclado, ok? Espaço para códigos-chave. Isso é basicamente para a barra de espaço
no teclado, ok? E dentro disso, vamos imprimir
algo no console. Vamos
pressionar a tecla de impressão , ok? Função de digitação de ponto de entrada. Verificaremos se
a tecla de espaço no teclado
foi pressionada ou não. Vamos implementar se a tecla foi pressionada
continuamente ou não. Ok, vamos escrever outra
condição para isso. Tecla de ponto de entrada, espaço
para código de tecla. Vamos imprimir algo sobre a disfunção
também continuamente Por fim, vamos verificar se a tecla pressionada
foi liberada ou não Para fazer isso, vamos escrever
se a condição aqui, entrada for digitada. Está bem? E vamos especificar a tecla, o espaço da
tecla, se a tecla de espaço foi liberada ou não
após ser pressionada. Ok, vamos publicar a versão impressa. Vamos adicionar mais duas funções aqui para verificar se
o jogador
pressionou a tecla de seta esquerda e a
tecla de
seta direita também. Ok, vamos escrever
mais uma condição aqui. Para fazer isso, insira o ponto, obtenha código da tecla,
pressione seta para a
esquerda dentro dela, imprimiremos e pressione OK. E para verificar se o jogador pressionou a tecla de seta
direita ou não, vamos fornecer
mais uma condição aqui. Se a entrada obtiver tecla para baixo código da
tecla para baixo (seta direita), vamos imprimir a
tecla de seta direita pressionada. OK. Em primeiro lugar,
vou pressionar
a tecla Spacebar no
meu teclado E vamos verificar qual
é a saída aqui. Ok, então a tecla
foi pressionada, tecla foi pressionada
continuamente. Foi quando eu mantive a tecla, basicamente
pressionada continuamente. E por último, a tecla
foi liberada, então foi quando eu soltei a tecla
da barra de espaço Ok, então vamos tentar com as teclas de seta
esquerda e direita. Vou pressionar minha tecla de seta
esquerda agora. Ok, então a
tecla de seta esquerda pressionada novamente. Tecla de seta esquerda pressionada. Vou pressionar
minha tecla de seta
direita agora no teclado. Ok,
tecla de seta direita pressionada novamente. Tecla de seta direita pressionada. Então é isso, pessoal,
muito obrigado pela sessão. Na próxima sessão, daremos
uma
olhada nas entradas do mouse no Unity Muito obrigado, pessoal.
53. Entenda e implemente entradas de mouse no Unity: Oi Franz. Meu nome é Rohan Sev. Nesta sessão,
implementaremos a entrada do mouse, a unidade. Para isso, já
criamos objeto
vazio do sistema de
entrada de objetos do jogo. Aqui também criamos
uma entrada de script para mouse. E anexamos
o script ao objeto vazio
do sistema de
entrada de objetos do jogo. Vamos abrir o script
e escrever um trecho de código. Para implementar
entradas de mouse no Unity, precisamos implementar entradas de
mouse dentro da função de atualização Da mesma forma que fizemos com as entradas do
teclado, precisamos verificar
as operações realizadas no mouse Essas operações seriam clicadas com
o botão do mouse pela primeira vez e, em
seguida, clicadas continuamente no botão do mouse Por fim, o botão do mouse é
liberado após ser pressionado. Vamos verificar se
o botão do mouse foi clicado ou não Para fazer isso, vamos escrever
uma condição aqui. A entrada faz com que o botão do mouse
caia dentro do suporte. Aqui, precisamos especificar
qual botão do mouse, se é o botão
esquerdo do mouse, se é o botão
direito do mouse ou o botão do meio do mouse. Ok, zero é para o botão
esquerdo do mouse, um é para o botão
direito do mouse e dois é para o botão do
meio do mouse. Ok, então vamos imprimir
algo dentro disso. Vamos escrever mais uma condição, ou vamos usar uma função no botão
pot get mouse para verificar se o botão do mouse foi pressionado
continuamente ou não. Está bem? Então, se a entrada
pegar o botão do mouse, vamos colocar zero
dentro disso, ok? E vamos imprimir algo
dentro disso continuamente. Está bem? Por fim, vamos
verificar se o botão do mouse foi
liberado ou não
após pressioná-lo Está bem? Se a entrada fizer com que
o botão do mouse seja pressionado, vamos adicionar zero novamente dentro dele para o botão esquerdo do mouse e, em
seguida, vamos imprimir o botão do
mouse e soltar o ponto. OK. Ok pessoal, então eu vou clicar com o botão
esquerdo do mouse aqui. Então, sim, o botão do mouse
clicou pela primeira vez e, em
seguida, pressionou o botão do mouse continuamente Foi quando mantive o botão do mouse clicado e não o
liberei aqui Então, continuou imprimindo
o botão do mouse pressionado continuamente até eu
soltar o botão do mouse. Por fim, aqui. Então é isso, pessoal. Obrigado pela
sessão. Nos
vemos na próxima sessão. Na próxima sessão,
implementaremos entradas de acesso no Unity Muito obrigado, pessoal.
54. Entenda e implemente entradas da Axis no Unity: Olá amigos, meu
nome é Rohan Dev. Nesta sessão,
aprenderemos as entradas de acesso no Unity As entradas de acesso se referirão aos eixos
horizontal e vertical, e o valor variará de menos um a um em pontos
flutuantes Ok, para isso, já
criamos um objeto
de sistema de entrada, que é um objeto de jogo vazio. E também criamos entradas
de acesso por script. E já
anexamos as entradas de
acesso ao script ao objeto vazio do sistema de entrada de
objetos do jogo sistema de entrada de
objetos Vamos escrever um trecho de
código dentro da entrada de acesso. entradas do eixo do script referem-se aos valores ou
valores flutuantes entre -1,1 nos eixos
horizontal e vertical Um stick analógico
fornece valores para os eixos
horizontal e
vertical entre -1,1 O mesmo vale para o teclado O eixo horizontal serão as teclas de seta esquerda e direita, e o eixo vertical serão as
teclas de seta para cima e para baixo do teclado. Flutue, flutue na vertical. Está bem? Dentro da função de atualização, vamos atribuir valor
à variável horizontal. E esse valor será
inserido, obtenha o eixo horizontal, horizontal igual à entrada, obtenha o eixo Dentro da
vertical dupla estará sua entrada para obter o eixo vertical, horizontal maior que zero
no eixo horizontal. Se o valor for
maior que zero, significa que o jogador pressionou a tecla de seta
direita. Ok, vamos imprimir o
valor para horizontal também. Vamos imprimir à direita, virar à direita. Vamos aplicar uma outra
condição aqui, L horizontal menor que zero Isso significa simplesmente que
o jogador está pressionando
a tecla de seta esquerda,
imprima na horizontal. Vamos imprimir a curva à esquerda
dentro desta curva à esquerda. Isso é para o eixo horizontal. Vamos aplicar algumas condições
para o eixo vertical, vatical maior que zero Isso verificará se o jogador pressionou a tecla de seta. Se o jogador
pressionar a tecla de seta, o valor de Tic
será maior que zero E se o jogador pressionar a tecla
de seta para baixo, o valor do Vatical
será Vamos trazer o
valor para vertical. Vamos aplicar uma condição L para esse Tic menor que zero. Ok pessoal, no meu teclado, vou pressionar minha tecla de seta
esquerda e imprimir o valor para o eixo
horizontal. Ok, então vamos rolar isso para baixo. Ok, é virar à esquerda e
está mostrando menos um aqui. Ok, então eu vou
pressionar minha tecla de seta para a direita. Agora, o valor do eixo
horizontal é um. E está imprimindo
à direita aqui. Vou pressionar
minha tecla de seta para cima. Agora, o valor do eixo vertical é um
aqui e está sendo impresso. Ok, vou pressionar
minha tecla de seta para baixo. Agora, o valor do
eixo vertical é menos um agora, e está sendo impresso aqui embaixo Ok, então é isso, pessoal. Obrigado pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
55. Introdução ao motor de física e ao corpo rígido: Amigos. Meu nome
é Rohan Vasudev Nesta sessão,
falaremos sobre física e
corpo frígido no Unity física no Unity é gerenciada pelo Built In Physics Engine.
O Unity está incorporado. Physics Engine executa a física para interações de objetos do jogo e vários efeitos, como aceleração
da gravidade,
colisões, etc Unity simula a
física para garantir que os objetos acelerem
e respondam corretamente às colisões, gravidade e a várias
outras forças Para ter um comportamento
físico convincente, um objeto em um jogo deve acelerar corretamente e
ser afetado por colisões, gravidade e outras forças As unidades integradas no Physics Engine fornecem componentes que lidam com a simulação física
para você e que se comportam passivamente
de forma realista Existem dois mecanismos de
física separados no Unity, um para Thredyphysics e
outro para duas físicas D. Os conceitos principais são idênticos
entre os dois mecanismos, mas sua implementação
é diferente. Por exemplo, há um componente de corpo
rígido para física tridimensional e dois componentes
D rígidos
para duas para Vamos falar sobre imunidade corporal
rígida. Agora, a imunidade corporal rígida permite que um objeto do jogo
tenha comportamento físico Ele interagirá com
outros objetos do jogo. O
motor de física Unity só sabe que um objeto deve ser acionado pela física se o componente
rígido do corpo estiver preso ao objeto do jogo Propriedades de uma massa
corporal rígida, arrasto, uso
angular. A gravidade é uma interpolação
nemática, detecção de
colisões e restrições colisões Vamos ver uma por uma, o que essas propriedades significam? Vamos falar sobre a missa aqui. Massa é a massa
do objeto do jogo. arrasto é o valor da resistência do ar aplicado ao
objeto do jogo. Arrasto angular. arrasto angular é o valor da resistência do
ar que afeta a rotação
do objeto e é cinemático Se ativado, o objeto não
será afetado pelo mecanismo de física na interpolação do
Unity É usado para suavizar o momento da detecção da
colisão do objeto Ele altera o tipo de
detecção de colisão no objeto, congelamentos
constantes, momento e rotação em determinado eixo
do objeto do jogo É isso aí, pessoal.
Obrigado pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
56. Aplicando Rigidbody ao objeto de jogo Sphere: Olá amigos, Meu
nome é Rohan Sud. Nesta sessão, vamos
criar um exemplo
para Rigid Body Para fins de demonstração,
vamos criar um objeto de jogo de três D
que será uma esfera. E vamos
aplicar um corpo
rígido na esfera basicamente Ok, então vamos
começar criando um piso que será um objeto de
jogo de três D que é plano. Para isso,
vá para o objeto do jogo, vá para três objetos D
e selecione a placa aqui. Está bem? No momento, o avião
não está visível na câmera. Para fazer isso, basta redefinir o valor de
transformação do plano. Ok, e sim, é
visível na câmera. Novamente, vamos criar um objeto de jogo de
três D,
que é uma esfera. Vá para o objeto do jogo, vá para três objetos D
e selecione Esfera aqui. Novamente, redefina
a transformação da esfera aqui. Ok, vá para o modo de cena aqui e leve
levemente a
esfera acima do solo. Ok, é assim
que deve ficar. A esfera basicamente permanece
flutuando no ar. No momento, não aplicamos nenhum corpo rígido na esfera Vamos parar de rodar a cena e vamos aplicar o
corpo rígido na esfera Agora, clique em Ad Component, vá para Rigid Body aqui, e sim, o componente rígido do corpo é anexado ao objeto esférico do
jogo Vamos executar a cena novamente e vamos ver a saída aqui. Ok, a esfera agora
cai no chão. Vamos entender as propriedades
do corpo rígido, uma por uma Ok, vamos parar de
rodar a cena aqui. A massa aqui é basicamente
a massa da esfera. No momento, está definido como um. arrasto é o valor da resistência do ar aplicado ao objeto
esférico do jogo. arrasto angular é o valor da
resistência do ar, novamente, aplicado ao objeto do jogo que afetará a
rotação da esfera. Ok, use a gravidade. Aqui está a força gravitacional aplicada ao objeto do jogo
esférico Se marcarmos a
caixa de seleção aqui ou se
marcarmos a opção Usar gravidade
como verdadeira aqui, isso significa que a força
gravitacional é aplicada aqui ao objeto do jogo
esférico Vamos desmarcar o Use Gravity aqui e vamos executar
a cena novamente. Como dissemos,
use a propriedade da gravidade aqui para cair agora, ela
não cai no chão. Vamos definir a
propriedade de uso da gravidade como verdadeira novamente. E a esfera cairá
sobre o objeto do plano do jogo. Ok, vamos parar de rodar a cena novamente, é
propriedade cinemática Aqui basicamente
definirá se o motor de física afetará
o objeto do jogo ou não. Vamos definir isso como verdadeiro aqui
e vamos executar a cena novamente definindo se
nemático é verdadeiro aqui A lança basicamente não é mais
afetada pelo
motor de física Ok, vamos desmarcar a propriedade e a esfera
cairá no chão Novamente, a detecção de colisão é basicamente o tipo
de detecção correta que atuará
na esfera Existem quatro opções:
discreta, contínua,
contínua, dinâmica e
contínua, especulativa Então temos a interpolação. Interpolar. Isso suaviza o
momento do objeto do jogo No momento, está definido como nenhum. Temos duas opções aqui,
interpolar e extrapolar. Nós entenderemos isso
ou aprenderemos mais sobre isso nas
próximas sessões. Ok, a propriedade de restrições
aqui é basicamente usada para congelar a posição ou rotação
do objeto do jogo no eixo x, y ou z. Vamos verificar o eixo y aqui e ver se a esfera
cai no chão ou não. Ok, a esfera
não cai no chão, ela está novamente flutuando no ar. Vamos desmarcar o eixo y aqui, e sim, a esfera cai
novamente no chão Então é assim que o corpo rígido funciona em qualquer objeto de jogo de três D. Então é isso, pessoal.
Obrigado pela sessão. Na próxima sessão,
veremos um exemplo de como mover a esfera usando
um componente de corpo rígido Muito obrigado, pessoal. vejo na próxima
sessão. Muito obrigada.
57. Aplicando material ao objeto de jogo Sphere: Olá amigos, Meu nome
é Rohan Vasudev. Na última sessão, aplicamos componente
de corpo
rígido na esfera Nesta sessão,
vamos mover
a esfera usando um
componente de corpo rígido dentro do script Esta sessão
será uma sessão de três partes. Na primeira sessão,
vamos criar uma textura e aplicar a
textura na esfera. Basicamente,
vamos criar um material. O que é um material? O material especifica as propriedades
ópticas do objeto do jogo Por exemplo, é cor, seja opaca ou
brilhante A textura é basicamente
uma imagem que é uma camada ou envolvente
ao redor do objeto do jogo, que novamente fornece
os efeitos visuais para o objeto do jogo Ok, então, para começar, vamos criar uma pasta
aqui e vamos criar
um Material para criar uma pasta, clique com o botão
direito aqui dentro da pasta
Assets para criar. E clique na pasta aqui, renomeie a pasta para Materiais Materiais. Está bem? Abra
a pasta Material, clique com
o botão
direito aqui dentro da pasta Material novamente e selecione Material
para criar um material. Está bem? Nomeie o material como bola de
praia ou o nome, pode ser qualquer coisa
de sua escolha. Ok, criamos um
material aqui para a bola. Precisamos aplicar a
textura aqui para a bola. Agora, a textura é basicamente,
como afirmei anteriormente, é uma imagem, então precisamos
baixar uma imagem
da Internet. O que faremos aqui
é aplicar uma textura de bola de praia aqui
em nossa bola, basicamente. Ok, basta clicar
no mapa de cores aqui. Está bem? E clique com o botão direito
aqui e salve as imagens. Ok, Images. Ok, então sua imagem
foi baixada agora. Basta clicar em Mostrar a
pasta, abrir seu Unity, ir até a pasta aqui e arrastar e soltar a imagem aqui dentro
da pasta Material. Ok, é isso mesmo. Selecione
o material novamente. Ok, clique em Albedo aqui,
ok, e basta selecionar a cor da bola de
praia Nós aplicamos a textura
aqui ao material. Precisamos aplicar esse material
ao nosso objeto de jogo esférico. Basta clicar no objeto esférico
do jogo aqui. E dentro da janela do inspetor, basta arrastar e soltar
o material aqui para o objeto do jogo de lança.
Ok, e é isso. Podemos ver aqui que o
material foi aplicado ou a textura
foi aplicada à bola aqui. Então é isso, pessoal,
obrigado pela sessão. Na próxima sessão,
criaremos um piso para
a bola se mover. Muito obrigado, pessoal. Te vejo
na próxima sessão.
58. Crie um piso para a esfera se mover: Amigos, meu nome
é Rohan Vasuev. Na última sessão,
aplicamos textura na bola. Nesta sessão,
vamos criar um piso. Já criamos um
material para o piso aqui. Ok. E também
baixamos textura para o chão
da Internet. Ok, vamos aplicar esse material ao objeto do jogo de avião aqui. Nesse caso, a planície será nosso piso. Teremos
vários objetos simples do jogo para criar um grande piso. Antes de criar vários objetos de jogo
simples, precisamos criar um objeto de jogo
vazio e nomeá-lo como Floor. Esse será o
objeto de jogo principal de todos os nossos objetos de
jogo simples , porque
precisamos manter
tudo organizado. Ok, vamos clicar com o botão direito aqui
na cena e criar um objeto de jogo
vazio. Renomeie o
objeto vazio do jogo aqui para chão, ok? E basta rastrear o objeto simples
dentro do objeto do jogo no chão. Ok, agora precisamos
replicar o avião aqui várias vezes para
criar um grande piso Para fazer isso, basta selecionar
Plan Game Object e clicar no controle D e ele
replicará o objeto do jogo Agora precisamos ajustar o plano, um objeto do jogo aqui. Para fazer isso, basicamente,
precisamos manter a ferramenta de movimentação selecionada aqui no
editor e apenas arrastá-la. Está bem? Parece bom? Sim, parece bom.
Sim, parece bom. Ok, de novo. Agora clique no plano
um objeto do jogo aqui e clique em Control D. Aqui
criamos nosso piso. Ok, vamos para o modo de jogo
e vamos ver como fica. Vamos colocar a câmera
na parte superior para
ter uma visão melhor. Muito obrigado, pessoal. Obrigado pela sessão. Na próxima sessão,
vamos mover
a bola usando um componente
rígido do corpo Muito obrigado, pessoal. Nos vemos na
próxima sessão.
59. Mova a esfera usando Rigidbody anexado a ela: Oi amigos. Meu
nome é Rohan Sev. Nesta sessão,
vamos mover a esfera usando um componente de corpo rígido
preso à esfera Para fins de demonstração, já
criamos um movimento de corpo rígido e
anexamos um script ao objeto
esférico do jogo aqui Agora, para mover a esfera, teremos que declarar
algumas variáveis aqui Ok, variável de flutuação,
vertical, variável de flutuação, horizontal A, velocidade de flutuação igual a cinco E corpo rígido R B. Ok? Esse corpo rígido R B é basicamente usado para obter o componente do corpo rígido
da esfera Para obter o componente do corpo rígido, teremos que usar a função get
component no Unity Está bem? Teremos que inicializar a variável de corpo rígido usando
get component function,
component, rigid body, Dentro da função de atualização. Já vimos isso
nas sessões anteriores. Como usamos o eixo de entrada
dot get? Nesta sessão,
vamos implementar a entrada. Basicamente, tenha acesso para mover
a esfera, mas para mover a esfera novamente, usaremos um componente de
corpo rígido da esfera Agora, dentro da
função de atualização, é igual à horizontal, igual Ok, vamos aplicar
as condições de L aqui dentro da função de atualização
para verificar se estamos pressionando
a tecla de seta para cima, se estamos pressionando
a tecla de seta para baixo,
se estamos pressionando a tecla de seta para a
esquerda
ou se estamos pressionando a tecla de seta para
a direita. Para fazer isso, vamos aplicar a primeira condição aqui
para o eixo vertical. Se a vertical for maior que zero, RB é um vetor de
força três para frente na velocidade Vamos aplicar outra condição
if. Se vertical menor que zero. Ok, então vamos aplicar força
ao corpo rígido novamente no vetor de
força três de volta à velocidade Agora vamos aplicar condições para o eixo horizontal para verificar se o jogador
pressionou a seta esquerda ou
a tecla de seta direita. Está bem? Para fazer isso, se a horizontal for maior que zero, essa condição será para
a tecla de seta para a direita. Está bem? R B um vetor de força três diretamente na velocidade. E por último, horizontal
menor que zero, R B, adicione o vetor de força três restante à velocidade, ok? Então a bola está se movendo agora. Podemos aumentar a velocidade, ou podemos diminuir
a velocidade, ok? Então, para esse propósito,
teremos que
declarar mais duas variáveis aqui Objeto de jogo público,
câmera, ok? E então vamos declarar
mais uma variável do vetor três. Vamos nomear a
variável como offset. Essa variável será
a distância, basicamente, que vamos
calcular entre a câmera e
o objeto
esférico do jogo. Ok, vamos atribuir algum valor aqui para a
variável de deslocamento, ok? O início do deslocamento da cena é igual a n Posição de transformação da
câmera x. Posição de y mais um. Está bem? Queremos manter a câmera basicamente um pouco
acima do eixo y. E então a transformação do ponto da câmera, posição s menos transformação da posição, transformação da posição é a
posição da esfera aqui Ok, agora definimos
o valor para offset. Primeira condição aqui. Se a vertical for maior que zero. Vamos adicionar mais uma
linha de código aqui. transformação da câmera posição de transformação da câmera é igual à
posição de transformação é a posição
da esfera, ok Mais seu deslocamento
mais a distância. Teremos que replicar
esse código, ok? Basicamente, em todas as
condições aqui. Por fim, também teremos que
especificar uma condição Ls
aqui Nesse caso, se a bola não
estiver se movendo, se a bola não estiver
se movendo, novamente, temos que especificar
o mesmo código Transformação da câmera e deslocamento. Ok, é isso mesmo.
Vamos salvar o script aqui e ir para o editor. Ok, clique no objeto do jogo
Sphere aqui. Basta clicar em Made
Camera e arrastar o objeto e
colocá-lo aqui. É isso mesmo. Ok. Ok, então é
isso. É isso mesmo. Também temos nossa câmera
seguindo a
esfera . Então é isso, pessoal. Muito obrigado
pela sessão. Te vejo na próxima
sessão. Muito obrigado
60. Introdução aos colisões e colisões no Unity: Oi amigos. Meu nome
é Rohan Masudev Nesta sessão, falaremos sobre colisores, gatilhos e
colisões no Unity Então, o que são colisores no Unity? Colliders são componentes
do Unity que fornecem detecção de colisão
entre os objetos do jogo Eles definem a forma do objeto do jogo para fins
de colisão física Também deve haver um corpo
rígido preso a um dos objetos do jogo
para detectar colisões Os Colliders permitem que você
ouça e responda às colisões Os colisores podem ser de vários tipos, mas principalmente existem dois tipos,
dois de colider e
três de colider Para dois jogos, objetos
de colisão são usados. E para três objetos do jogo, três aceleradores D são usados Vamos falar sobre Box collider
three D. Agora, quando você cria qualquer objeto de jogo no Unity colisor de
três D é
anexado a ele por padrão, o que é indicado por linhas
verdes
ao redor do objeto do jogo Na imagem aqui,
podemos ver que
criamos um
objeto de três jogos que são cubos. A linha verde ao redor daqui, o objeto do jogo em cubo, é
basicamente o colisor Esse colisor pode ser manipulado para ser maior ou
menor que a caixa, dependendo do
objetivo do seu jogo, de como você deseja que os colisores
do Unity interajam entre si, utilizando o mecanismo de física do Unity Vamos falar sobre gatilhos de
colisão. Agora, quando dois objetos do jogo
colidem, Unity fornece eventos
que são chamados Existem basicamente dois
tipos de eventos: eventos de gatilho de
colisão
e eventos de colisão. Os gatilhos de colisão são usados
principalmente quando queremos
acionar alguns eventos
que devem ser ignorados pelo mecanismo Quando dois objetos colidem, eles
passam um pelo outro, mas alguns eventos são disparados Pelo menos um deles deve ter um componente rígido do corpo
preso a ele Os eventos de gatilho podem ser
obtidos definindo a opção de gatilho como verdadeira
no componente do colisor Depois de configurá-lo como verdadeiro, ele será ignorado pelo mecanismo de física e
poderá ser usado para acionar eventos quando o objeto do jogo colidir com
outro objeto do jogo Existem três eventos
para acionadores de colisão e eles são os seguintes
em Trigger No Trigger, Enter é chamado quando um colisor entra em
contato com outro Com um dos colisores com o gatilho ativado,
ligou apenas uma vez Então, temos um gatilho suspenso. A permanência do gatilho é
chamada de estrutura quando há contato entre o
colisor e o gatilho, ela é chamada várias
vezes até que
haja contato entre
os dois colisores Na saída do gatilho,
a saída do gatilho é chamada quando o colisor
para de tocar no Liguei apenas uma vez. Ok, vamos falar
sobre colisões. Agora, uma colisão no
Unity acontece quando dois objetos do jogo com colisores conectados
interagem um com o outro Eles podem se tocar, ficar em contato um com o outro ou parar de colidir Pelo menos um deles deve ter
um componente de corpo rígido para motor de física
os
reconheça como colisores Há três
eventos de colisão. Eles são os seguintes
em Collision Enter, chamado quando um colisor
entra em contato com outro colisor
chamado apenas uma vez
na colisão , permaneça ligado para cada quadro quando há
contato entre colisores
chamado várias
vezes até que haja
contato na saída da colisão chamado quando o colisor para de tocar em outro colisor chamado apenas. chamado quando um colisor
entra em contato
com outro colisor
chamado apenas uma vez
na colisão, permaneça ligado para
cada quadro quando há
contato entre colisores
chamado várias
vezes até que haja
contato na saída da colisão chamado
quando o colisor para de tocar em outro colisor chamado apenas. Vamos ver a diferença
entre gatilho e colisão. Gatilho invocado pelo sistema de eventos quando dois objetos do jogo
se sobrepõem, colisão é invocada pelo Quando dois objetos do jogo
colidem um com o outro. As informações de colisão são compartilhadas por meio dos eventos de gatilho, que estão na entrada do gatilho, na permanência do gatilho e na saída do
gatilho.
As informações de colisão são compartilhadas os eventos de colisão que estão
na entrada, na permanência da colisão e
na saída da colisão A propriedade de gatilho no
componente do colisor está ativada. A propriedade de gatilho aqui no componente do
colisor está
desativada para colisão O gatilho é usado para detectar a presença de
outros objetos do jogo. A colisão é usada para
interagir fisicamente com outros objetos
do jogo É isso aí, pessoal. Nos
vemos na próxima sessão. Muito obrigado, pessoal.
61. Adicionando objetos de jogo 3D no chão e adicionando tags a eles: Amigos. Meu nome é Roan Suev Nesta sessão,
vamos criar
um exemplo para detecções de
colisões Vamos criar alguns
obstáculos no caminho aqui. Esses obstáculos
serão objetos de jogo em cubos. Basicamente, para começar, vamos criar um objeto de
jogo vazio aqui. Está bem? Crie um vazio e renomeie o objeto do
jogo para obstáculos. Agora, dentro do objeto de obstáculos, vamos
criar alguns cubos. Para fazer isso, clique com
o botão direito aqui nos obstáculos e vá para
três objetos D aqui. E clique em Q. Como todos podemos ver aqui, quando criamos um objeto de jogo em
cubo, box collider é anexado
a ele Vamos adicionar um corpo rígido
também ao cubo aqui. Ok, vamos aumentar
a massa do objeto
do jogo do cubo para dez aqui Vamos apenas arrastar e soltar um
material no cubo aqui. Dimensione um pouco o tamanho do objeto do jogo em
cubo. Parece muito pequeno. Vamos manter em 1,5 Ok, vamos aumentar um pouco. O objeto do jogo
já está selecionado aqui. Basta clicar no controle
D para replicar os objetos do jogo para que
possamos criar mais obstáculos No caminho para a esfera, criamos os obstáculos, criamos
123456 No caminho, a tag Sphere é basicamente identificar o objeto do
jogo por meio de um script, selecionar o objeto do jogo aqui, ir até Tags aqui e clicar em um T. Ok? Clique no sinal de mais aqui
e adicione um novo nome de tag. Mantenha-o como um só. Está bem? Adicione mais um nome de tag. Mantenha-o como um cubo dois. Cubo dois, salve. Tudo bem, então
criamos duas tags, cubo um e cubo Novamente, selecione no cubo aqui
as tags com as quais ele está marcado. Agora, basta
clicar no menu
suspenso e selecionar o cubo um aqui Em seguida, vá para o cubo um aqui e
selecione um aqui para isso. Ok, basicamente para
os cubos brancos, vamos
selecionar um como etiqueta. Para os
cubos pretos, vamos selecionar o cubo dois como etiqueta Ok, então vamos comandar a cena. E vamos mover a bola. Ok, vamos mover
a esfera aqui. No momento, a esfera está colidindo com os objetos do
jogo de cubos Ok, mas como não adicionamos nenhum
evento de colisão dentro do script, não
estamos realizando
nenhuma ação nele Basicamente, na próxima
sessão, usaremos eventos de colisão dentro do
script para detectar colisões E também vamos usar
as tags que
acabamos de criar aqui. Ok pessoal, muito obrigado. Te vejo
na próxima sessão. Muito obrigado, pessoal.
62. Detecte colisão com o Cúbere 3D usando tags: Amigos. Meu nome é Ron Vase Nesta sessão, implementaremos
eventos de colisão dentro
do script Unity Esses eventos de colisão
são na entrada da colisão, na permanência da colisão e
na Vamos escrever um trecho de código
dentro do script Unity. Vamos começar com On
collision Enter. A função na
entrada de colisão será chamada quando dois corpos rígidos
colidirem um com o outro, ou dois colisores
colidirem Em caso de colisão Enter, vamos
passar por uma classe de colisão. classe de colisão contém
todas as informações, por exemplo, impacto, velocidade
e pontos de contato, colisão interna Na entrada de colisão,
usaremos as tags que criamos
na última sessão Criamos duas etiquetas, cubo um e cubo Cube uma etiqueta para os cubos brancos e cubo duas etiquetas era
para os cubos pretos Basicamente, vamos escrever se condição dentro de uma
colisão, insira tag do objeto de chamada da
função a
igual ao cubo um Basicamente, se for um cubo branco , vamos
imprimir algo dentro dessa colisão de
log de depuração colisão de
log iniciada com Ok, essa condição
é para a fila branca. Vamos escrever uma condição Elsif. tag de objeto do jogo Elf call é igual a,
igual a duas colisões
de log
ruins iniciadas com colisões
de log
ruins iniciadas A
tag de objeto do jogo Elf call é igual a,
igual a duas colisões
de log
ruins iniciadas com o cubo. Está bem? Então, vamos escrever outra função aqui que
está em estado de colisão. Em caso de colisão, a função de permanência
é chamada uma vez por quadro. Ok, nulo em caso de colisão, permanência. Vamos escrever uma
condição if novamente. Aqui estamos, cubo preto Por fim, vamos usar a função de saída
de colisão. Na colisão, a função de saída
será chamada quando dois corpos ou
colisores de Richard pararem de colidir um
com o outro Ok, então implementamos todas as três funções aqui
na entrada da colisão, na permanência da colisão e
na saída da colisão Então, vamos rodar a cena e ver como essa coisa funciona. Vamos colidir com
o cubo branco aqui quando a lança colidiu
com o Todos nós podemos ver aqui que a
colisão começou com o cubo branco e depois a colisão ficou com cubo
branco, pois a lança ainda
está colidindo com a saída
da colisão On ainda não foi chamada Mas uma vez que eu
afasto o Pal do cubo aqui. Ok, a colisão que saiu com o cubo
branco será chamada. Então, vamos colidir
com o cubo preto agora. Ok, então esse é o cubo preto. Ok, então a colisão
fica com o cubo preto. Vamos afastar a lança
do cubo preto e vamos
ver o que ela Ok, a colisão ocorreu com
o preto. Então é isso, pessoal. Obrigado pela sessão. Te vejo
na próxima sessão. Muito obrigado, pessoal.
63. Introdução às animações 2D e 3D no Unity: Oi amigos, Meu nome
é Rohan Maze. Nesta sessão,
falaremos sobre Animations Unity Então, o que é o Unity da animação? sistema de animação da Unity é
baseado no conceito de clipes de
animação Que contêm
informações sobre como determinados objetos devem
mudar sua posição, rotação ou outras
propriedades ao longo do tempo. Esses clipes de animação
são então organizados em um fluxograma estruturado, como um
sistema chamado controlador de
animador O controlador do animador atua como uma máquina de estado que
monitora qual clipe deve
estar sendo reproduzido no momento e quando as animações devem ser
alteradas ou mescladas Um
controle de animador simples pode conter
apenas um ou dois clipes Por exemplo, para controlar
uma rotação ou um salto. Ou para animar a abertura
e o fechamento de uma porta no momento correto Um controlador de
animador mais avançado pode conter dezenas de animações
humanóides para todas as
ações dos personagens principais, como caminhar,
correr, atirar, etc Então é assim que um
controlador de animador se parece. Este controlador de animador
, que tem clipes de animação inativos e ambulantes, está anexado ao personagem humanóide Ok, agora vamos falar sobre a máquina de estado de
animação. O que é máquina de estado de animação? máquina de estado de animação
controla qual clipe deve estar
sendo reproduzido no momento e quando as animações devem ser
alteradas ou mescladas É comum que um personagem ou outro
objeto animado do jogo tenha várias
animações diferentes que correspondem
às diferentes ações que ele pode
realizar dentro do jogo Um personagem pode balançar um pouco enquanto anda ocioso
quando ordenado
e levantar os braços em pânico
ao cair de uma Uma porta pode ter
animações para abrir, fechar, travar
e ser arrombada A animação do Unity usa um sistema de layout
visual semelhante a um fluxograma para
representar uma máquina de estado. O que permite
controlar e sequenciar os clipes de animação
que você deseja usar em seu personagem ou em
qualquer outro objeto do jogo O que são transições
de máquina de estados? transição da máquina de estado simplifica máquinas de estado
grandes ou complexas Cada visualização na janela do animador tem um nó de entrada e saída, usado durante as transições da
máquina de estado O nó de entrada é usado na transição para
uma máquina de estado O nó de entrada será
avaliado e se ramificará para o estado de destino ou para o clipe de animação de
acordo com as condições definidas. O nó de saída é usado para indicar que uma
máquina de estado deve sair. Agora, na imagem abaixo, podemos ver que o nó de entrada está fazendo a transição para a animação
ociosa aqui,
sendo a animação inativa aqui o estado A animação inativa então
passará para a caminhada ou
para
o clipe de animação em execução,
dependendo da condição definida no controlador do animador
. É isso aí, pessoal. Obrigado pela sessão. Te vejo
na próxima sessão. Na próxima sessão, criaremos uma animação em um sprite Muito obrigado, pessoal.
64. Corte uma folha de flores em vários Sprites e aplique animação de caminhada: Meus amigos, meu
nome é Rohan Sev. Nesta sessão,
vamos criar uma animação no sprite Sprite é basicamente uma imagem para fins de demonstração Já criamos
dois projetos no Unity e também
criamos uma cena Sprite NM
dentro do projeto Para começar, precisamos importar a planilha de
sprites no projeto.
O que é sprite sheet folha Sprite consiste basicamente várias imagens em uma
única imagem em uma grade É assim que uma
folha de sprite ficaria. Essas são basicamente
várias imagens empacotadas em uma única imagem, e isso é chamado de folha
de sprite Tudo bem, vamos começar
baixando essa imagem aqui. Agora vamos ver a planilha de sprites dentro do projeto Unity aqui Mas antes de fazer
isso, vamos criar uma pasta e nomeá-la como sprite sheet Ok, clique em Criar aqui
e clique em Nome
da pasta, a pasta como Sprite Sheet Abra a pasta e arraste-a para dentro da pasta
da folha de sprite Tudo bem, então essa
é uma única imagem, agora precisamos
dividi-la em várias imagens Então, como fazemos isso?
Primeiro, selecione a imagem. Tudo bem, no modo
sprite aqui,
selecione vários, OK,
e clique em Aplicar aqui E clique no editor de
sprites aqui. Essa janela se abrirá. Tudo bem, depois de abrir esta janela, clique na opção Slice
Slice Clique em qualquer lugar na tela. E clique em Aplicar,
Feche a janela. E sim, temos
várias imagens aqui. OK. Como todos podem ver aqui, temos a estrela Sp, imagem
única em
várias imagens agora. Tudo bem, agora precisamos usar todas essas imagens múltiplas
para criar uma animação. Como criamos vários sprites a partir de
uma única folha de sprites, selecionaremos essa imagem
específica É uma imagem ideal para
a pessoa caminhando. Basta arrastar e soltar
a pessoa aqui. Vamos escalar o tamanho
do sprite aqui. Vamos escalá-lo para dois eixos x y. Está bem? Perfeito. Agora selecione o sprite aqui e
vá para a guia Animação Tudo bem, então vamos clicar em
Criar para adicionar uma animação. Renomeie a animação de animação
ambulante. Tudo bem, clique em Salvar aqui. Vamos arrastar a
guia Animação aqui em algum lugar. Estenda isso. O que faremos a seguir? selecionar todos os sprites aqui, exceto o
sprite original que
já está lá dentro da cena Ok, clique no
botão de controle aqui e continue selecionando todos os
outros sprites ou todas as outras animações
que queremos adicionar Novamente, isso depende do
tipo de animação. Talvez queiramos usar
apenas quatro sprites depois selecionar quatro sprites Se quisermos usar
todos os sprites, selecione todos os sprites Tudo bem, eu preciso de
todos os sprites, então eu estou selecionando todos
os sprites aqui, ok? Basta arrastar e soltar todos
os sprites aqui, ok? Novamente, acesse a guia aqui
para ficar mais confortável. Tudo bem, vamos ver como fica
a animação.
Agora, é muito rápida. O que fazemos aqui?
Ok, role o mouse e, ok, minimize essa coisa. OK. Para torná-lo um pouco lento, basta aumentar isso para, acho que 50 está bem aqui. Sim, tente a
animação novamente. Acho que está perfeito
agora. Está parecendo bom. Vamos parar com isso, salvar a cena, rodar a cena aqui e ver a saída.
Tudo bem, perfeito. Temos nosso sprite andando aqui. É assim que fazemos animações. Muito obrigado, pessoal.
Obrigado pela sessão. Na próxima sessão,
vamos criar uma imagem de fundo ou o plano de
fundo para a cena aqui. E também vamos mover
esse sprite para a esquerda ou para a direita, dependendo das teclas de seta que
você está pressionando lá embaixo Tudo bem. Então, muito
obrigado, pessoal. vejo na próxima
sessão. Muito obrigado.
65. Adicione fundo à cena: Amigos, meu nome
é Rohan Masudev. Na última sessão, criamos uma animação sobre o sprite aqui Criamos um
clipe de animação ambulante aqui para o sprite. Tudo bem, quando fizemos isso, esse
controlador de animador foi criado No momento,
aplicamos apenas um clipe de animação
ambulante a esse controlador de
animador específico aqui nesta sessão Vamos aplicar uma imagem de fundo aqui
para essa cena específica Antes disso, precisamos
ter uma imagem de fundo. Você pode
criá-lo ou baixá-lo da web. Vou baixar essa imagem e aplicá-la como
plano de fundo para o C. Eu já baixei
essa imagem aqui. Vamos colocar essa imagem
em nosso projeto. Basta rastrear essa imagem aqui. Nós importamos a imagem
aqui dentro do nosso projeto. Agora, o próximo passo seria criar um objeto de jogo vazio, que servirá basicamente como imagem de
fundo. Tudo bem, clique com o botão direito
aqui na cena e vá para Game Object e clique em Create
Empty aqui. Tudo bem. Renomeie o objeto do jogo
para plano de fundo, ok? E basta arrastar e
soltar esta imagem no objeto vazio do
jogo de fundo aqui. Tudo bem, no momento, a imagem não
está nada boa. Basicamente, precisamos ajustar
a escala da imagem. Tudo bem, vamos continuar assim, digamos 0,3 no eixo x, 0,3 no eixo y e 0,3 no referido eixo. Clique na guia da cena aqui. Agora, essa imagem não é suficiente. Queremos criar uma cena
enorme aqui porque eventualmente
caminharemos
usando as teclas de controle. Tudo bem, o que fazer a
seguir é escolher a imagem aqui dentro do objeto vazio do jogo de
fundo e clicar no controle
D. Tudo bem. Agora selecione a
ferramenta de movimentação aqui e apenas mova a imagem, ok? E, novamente, clique
nessa imagem específica, que está bem no centro. Novamente, clique no controle D.
Com a ajuda da ferramenta de movimentação, basta mover a imagem aqui. Tudo bem, agora o sprite está no ar e
está voando no ar Precisamos fazer com que
pareça que está no chão. O que fazer a seguir é selecionar seu sprite no mar
e derrubá-lo. Ok, vamos para o mar agora. E parece bem
agora. Parece melhor. Vamos clicar no botão
play aqui e ver como fica. Tudo bem, está parecendo bom. A animação está sendo
reproduzida e
também temos uma imagem de fundo definida para nossa cena. Atualmente, se você ver aqui, apesar de reproduzir
a animação ou aplicar a
animação no sprite,
atualmente o sprite não está na
direção para frente Ok, na próxima
sessão vamos aplicar o script
ao sprite Basicamente, para mover
o sprite na direção para frente e
para trás Novamente, criaremos uma animação que será uma animação inativa Se você não estiver
pressionando nenhuma tecla
, o sprite deve ficar inativo e
parar de andar aqui Tudo bem, pessoal,
obrigado pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
66. Mova o Sprite animado usando entradas de teclado: Amigos, meu nome é Rowan Suv. Na última sessão,
animamos o sprite. Nesta sessão,
vamos mover o sprite usando o script
Unity C sharp Ok, para esse propósito, vamos criar uma pasta
aqui chamada scripts. Abra a pasta de scripts aqui e vamos escrever um script em C sharp dentro da pasta de scripts. Sprite é o nome
do script. Vamos escrever um trecho de código dentro do script move sprite Ok, vamos declarar uma variável
flutuante aqui,
flutuante horizontal flutuante Vamos
mover o sprite no eixo horizontal,
flutuar na Tudo bem, vamos remover
o método inicial. Não precisamos de uma função de início aqui dentro da função de atualização. Vamos atribuir um valor à variável flutuante
horizontal, que será seu eixo de entrada, horizontal Ok, vamos aplicar uma
condição para verificar se o sprite está se movendo
na direção certa ou
na direção esquerda Para verificar se o sprite está
se movendo na direção certa, vamos aplicar uma condição se a
horizontal for maior que zero Tudo bem, dentro disso, vamos usar o componente get. E dentro do componente get, obteremos o
Sprite Renderer, que por padrão é
anexado ao Então, quando criamos um sprite, componente de renderização de
sprite
é anexado a ele Então, estamos recebendo o componente Sprite
Renderer,
ok, componente Sprite Renderer, flip X é igual a falls, Ok, flip X basicamente inverterá Por aqui, queremos
manter o sprite como está. Não queremos invertê-lo quando o sprite está se movendo
na direção certa Então, vamos fazer com
que caia novamente, vamos declarar um vetor três, vetor
variável três momento igual a n Está bem? No eixo x, eu quero aplicar 1,5 0,0 ok? Into é igual ao tempo delta de tempo. Tudo bem, vamos
mover o sprite
usando a função transform
translate Transforme a tradução
e traduza com insights. Vamos adicionar muito
movimento. Ok, então vamos aplicar outra condição que seja
horizontal menor que zero. Se o sprite do componente renderizar um flip x igual a true quando o sprite estiver
se movendo na direção esquerda, vamos virar o sprite no Basicamente, o vetor três momentos é igual a n, vetor três -1,5 no eixo x, zero no eixo y e zero no Tudo bem, novamente, movimento para dentro é igual ao tempo delta t. Por fim, alterando a posição ou transformação do
sprite Usando a função transform, translate no Unity translate e dentro do translate, vamos adicionar um momento Ok, vamos salvar o
script e anexar o script
ao sprite aqui Vamos apenas arrastar e soltar
o script no sprite. O script está anexado
aqui ao sprite. Agora vamos rodar o jogo e ver como ele funciona. Tudo bem, vamos pressionar a tecla de seta direita
no teclado, e o sprite começa a se mover
na direção certa Vamos pressionar a
tecla de seta esquerda no teclado e o sprite começa a se mover
na direção esquerda Funciona bem, mas
há um problema aqui. Mesmo que eu pare de pressionar
as teclas de seta, todos
nós podemos ver aqui que a
animação não está parando aqui. Ok, a animação continua. Então, na próxima sessão,
o que
faremos é basicamente aplicar
outra animação ao sprite, que será uma animação inativa Então, quando eu soltar as
teclas do teclado, tudo bem, a animação inativa
será reproduzida E quando eu
pressionar novamente as teclas, a animação de caminhada
será reproduzida novamente. Então, muito obrigado.
É isso aí, pessoal. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
67. Aplique animação ociosa ao Sprite e faça a câmera seguir o Sprite: Oi amigos. Meu nome
é Rohan Vasudev Na última sessão,
movemos o sprite usando a função
transformada ou traduzida no Unity Nesta sessão, aplicaremos a animação
inativa ao sprite para que, quando pararmos de
pressionar
a tecla de seta esquerda ou direita,
a animação ociosa
seja reproduzida e
a animação de caminhada pare de ser Tudo bem, então para fazer isso, vamos começar criando uma animação ociosa
para o sprite aqui Selecione o sprite
aqui na cena. Vá para a guia Animação e
clique no menu suspenso aqui. E crie um novo
clipe para o sprite. Ok, basta clicar em Criar
novo clipe aqui. Tudo bem. Agora, dentro de qualquer pasta ou pasta
da folha de sprite, podemos criar um novo clipe de
animação Nomeie o clipe como animação ociosa. Ok, salve o script. Traga a guia de animação aqui. Clique na planilha de sprites aqui e arraste o primeiro sprite aqui, que é um sprite de animação ocioso Basicamente, esse
é um sprite inativo que será usado
para animação inativa Novamente, traga a guia de
animação aqui. Basta clicar no botão play. Ok, não está fazendo nada porque é uma animação ociosa Quando pararmos de pressionar a tecla de seta
esquerda ou direita, essa animação será reproduzida. Temos duas animações aqui. Uma delas é a animação ambulante. Outra é a animação ociosa. Tudo bem, aqui, a animação padrão
é animação ambulante. Se apertarmos o botão play
, a animação inicial
será uma animação ambulante. Vamos mudar isso para animação
ociosa. Está bem? Porque esse deve
ser o ponto de entrada. Tudo bem, então vamos
para a aba do animador novamente. Clique na animação inativa aqui e clique em Definir
como estado padrão Esse será o estado
padrão quando começarmos com o
botão Jogar no jogo. Vamos criar algumas transições. Basicamente, quando
clicamos no botão Reproduzir, essa animação é
reproduzida, pois agora está definida como animação padrão. Mas quando clicamos na tecla de seta
esquerda ou direita, animação de
caminhada
será reproduzida. Para fazer isso, basta clicar com o botão direito
na animação inativa. Clique na transição para a animação de
caminhada. Tudo bem. Da mesma forma, clique com
o botão direito na animação de caminhada. Faça a transição e, em seguida ,
reduza-a para
a animação inativa Basta clicar na seta
aqui e desmarcar isso. Clique nas configurações aqui. E
a duração da transição chegue a zero porque não
queremos definir nenhuma duração. A duração da transição é basicamente a duração da transição entre as duas animações. Ok, novamente, clique
nesta seta e verifique se há
hora de saída. E defina a
duração da transição aqui para zero novamente. Tudo bem, agora precisamos definir algumas condições para verificar se o jogador está
pressionando as teclas seta
ou não. Ok, então faça isso. Precisamos
criar um parâmetro aqui. Vamos criar um novo parâmetro pressionando o botão de
adição aqui. Agora, existem quatro tipos de parâmetros que podemos criar. Vamos criar aqui um tipo de parâmetro de dados bool Ok, vamos dar
um nome, Can Walk. Esse é o nome
do parâmetro. Mais uma vez, clique aqui
na seta, ok? E defina a condição aqui. Se pode andar for verdade, animação de caminhada
será reproduzida. E se a capacidade de andar for falsa, animação inativa
será reproduzida Vamos definir uma condição
aqui. Pode andar de verdade. Isso significa simplesmente que se
pode andar for verdade, uma animação de caminhada
será reproduzida, ok? Clique na seta aqui, novamente, novamente, defina
uma condição, ok? Se a opção can walk for falsa, animação inativa
será reproduzida Agora precisamos chamar o animador que está conectado ao sprite Então, para fazer isso, vamos declarar um animador
aqui, o nome do animador Ok, não temos uma função de
início aqui. Vamos adicionar a função de início. Precisamos inicializar o
animador. Tudo bem. Assim que o jogo
começar, qualquer um é igual para obter o animador de componentes Tudo bem, agora, dentro disso precisamos definir a
enquete, que pode ser considerada verdadeira se
pressionarmos a tecla de seta Para fazer isso, anim dot set pool, o nome do parâmetro pode percorrer e defini-lo como verdadeiro aqui Ok, novamente, dentro
dessa condição, novamente precisamos definir
a bola como verdadeira. O conjunto B pode caminhar até a verdade. Tudo bem, vamos declarar
uma condição L aqui. Então, se o jogador não
estiver andando ou o
personagem não estiver andando, vamos definir o conjunto de anim O touro pode caminhar até as quedas novamente. Pode andar em quedas. Tudo bem, vamos salvar o script aqui. Tudo está definido aqui. Vamos rodar o jogo. E
vamos ver a saída. No momento, não estou pressionando
as teclas de seta aqui, a animação inativa
está sendo reproduzida Vamos clicar em, ou vamos pressionar a tecla de seta para a
direita aqui. E a animação ambulante
começa a ser reproduzida. Tudo bem, no momento em
que eu solto a tecla, animação
inativa está
sendo reproduzida novamente. Vamos para a esquerda novamente. Ok, a
animação ambulante começa. Deixe-me soltar a tecla de
seta aqui. Tudo bem, vamos fazer com que a câmera principal siga
o personagem aqui. Portanto, é muito simples de fazer. Então, vamos selecionar a
câmera principal aqui e torná-la o objeto filho do objeto do jogo do sprite
aqui ou do sprite Ok, então basta arrastá-lo e
colocá-lo dentro do seu sprite. Tudo bem, vamos reproduzir
a cena novamente. Tudo bem, então a câmera está
seguindo o jogador também. Ok, isso para. Ok, vamos lá. Parecendo bem. Tudo bem, então é isso.
Muito obrigado, pessoal. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
68. Importar personagem 3D no Unity e aplicar animação ambulante: Oi amigos. Meu nome
é Rohan Vasudev Nesta sessão,
vamos criar uma animação para três personagens
D aqui. Esses três caracteres D,
vamos baixar do nosso site, que é Mixamo.com Além disso,
vamos
baixar a animação
desse personagem em particular do Mixamo Tudo bem, então vamos
ao site e vamos começar a baixar o personagem e a animação para o mesmo. Aqui estamos no
Mixamo.com Tudo bem, você pode escolher qualquer um
dos personagens Ok, eu vou escolher
esse personagem aqui. Vamos clicar no botão de
download aqui. A postagem deve ser postagem. Baixamos o
personagem do Mixamo. Agora vamos colocar o personagem dentro da pasta de
três caracteres D, que criamos
dentro da pasta Assets. Vamos apenas arrastar
e soltar aqui. Antes de colocar o
personagem dentro da cena, vamos criar um piso para
o personagem andar. Tudo bem,
vamos para o objeto do jogo, vamos para três objetos D e
vamos criar um avião aqui. Ok, o avião não está visível. Basta ir para transformar
aqui e clicar em Redefinir. Tudo bem, isso é bom. Ok, vamos criar outro plano aqui para que possamos
ter um fluxo maior. E vamos sugerir a coisa, ok, então temos um fluxo
maior agora. Tudo bem, vamos tentar colocar esse personagem dentro da nossa cena, como arrastá-lo e soltá-lo aqui. Ok, então temos nosso personagem
dentro da cena agora, mas podemos ver, tudo bem, não
há materiais ou
texturas no personagem Para aplicar texturas
no personagem, o que precisamos
fazer é selecionar o personagem aqui, ok E clique em Materiais, clique em Usar materiais
externos, Legado e clique em Aplicar. E o material
deve ser aplicado. Agora, para o personagem. Podemos ver os materiais ou as texturas aplicadas
ao personagem Agora, do jeito que estava no Amo.com clique na guia Rig
aqui, Tipo de animação Este é um personagem humanóide, então é necessário selecionar Humanóide E clique no botão
Aplicar aqui. Agora vá para Animation aqui e confira Look Time aqui, ok? E clique em Aplicar aqui, mas não há
animação aplicada a ela. Para aplicar a animação, vamos novamente ao Amo.com e clique na guia de
animação aqui E nós queremos caminhar. Animação, busca por caminhada. Ok, vamos selecionar isso. Animação perfeita. Perfeito. Caminhada mutante é o nome do
clipe de animação que
vamos aplicar em nosso
personagem enquanto caminhamos Ok, clique no download aqui. O formato BX para Unity está bom. Tudo bem, e isso
deve ser sem a Sky. Clique no
botão de download aqui. Tudo bem, vamos colocar esse clipe de
animação em
nossa pasta de três caracteres D novamente, apenas arrastando-o
e soltando-o Vamos selecionar isso, que
é um clipe de animação. Ok, vá para o equipamento aqui e novamente tipo de
animação para humanóide
criar a partir E clique no botão Aplicar aqui. Vá para a guia Animação novamente, marque o tempo de loop e
comece a posar. Verifique isso com base na orientação
corporal. E clique em Inscrever-se aqui. Novamente, selecione meu personagem aqui. Agora, o que precisamos fazer é criar um controlador de
animador Ok, então vá para Criar aqui e clique no controlador do animador Ok, meu controlador nomeia o controlador animador do
meu controle Basta abrir o
controle do animador e vamos rastrear esse clipe de caminhada aqui dentro do controle do
animador Tudo bem, agora
vamos até meu personagem novamente aqui e aplicar este controlador de animador
para o personagem Vamos rodar a cena aqui. Sim, o personagem está andando. Vamos deixar o personagem um
pouco para trás na visão da câmera. Está bem? Tudo bem, o
personagem está andando, mas queremos que nosso personagem se
mova com as teclas de seta. Na próxima sessão,
aplicaremos o script ao personagem junto com
o controlador do
personagem. É isso aí, pessoal.
Obrigado pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
69. Mova o personagem 3D usando entradas de teclado: Amigos, meu nome
é Rohan Masrev. Na última sessão, aplicamos animação a esse personagem. Nesta sessão, vamos
fazer com que o personagem ande
na direção para frente quando
pressionamos as teclas de seta do teclado. Vamos selecionar meu personagem
aqui e desmarcar. Aplique o movimento da raiz. Basicamente, como
vamos mover esse personagem usando as teclas de seta, vamos desmarcar isso Aplique o movimento da raiz aqui. Em seguida, precisamos modificar
a animação de caminhada, que aplicamos
ao personagem aqui. Ok, vamos rodar a cena e ver a
diferença aqui. Vamos ver como fica a
animação. Agora, desmarcamos o movimento da raiz
aplicado. Tudo bem, então o personagem
caminha em um só lugar. Não está avançando
porque vamos
mover o personagem usando
as teclas de seta agora. Agora vamos rolar
até aqui e ir para a posição de transformação raiz y para o clipe de animação ambulante. Este é o clipe de
animação ambulante que aplicamos
no personagem. Está bem? Para a
transformação da raiz, a posição Y baseada em cadeias é
baseada em dois pés. Está bem? E clique em
se inscrever aqui, Perfeito. Essa é a animação
que queremos em nossa caverna. Aqui estamos no Mamo.com.
Eu já pesquisei
a animação inativa
e vou
aplicar essa animação inativa sem nome para nosso personagem Ok, é assim que
nosso personagem ficará quando estiver ocioso, quando não estiver andando Vamos baixar o clipe aqui. Vx para Unity BX. Tudo bem, e sem skin, vamos clicar no botão de
download e baixar o clipe de animação. Ok, eu baixei
a animação inativa. Vamos arrastar a animação dentro da pasta de três
caracteres D. Agora clique no meu clipe de
animação ocioso. Vá para rig aqui,
tipo de animação slcumanoid, e clique em Aplicar Verifique o tempo do loop, ok? E para a posição de
transformação da raiz y. Novamente, altere isso para pés
e clique em aplicar aqui. Clique no controlador do animador que criamos da última vez. E, assim, arraste a
minha animação ideal aqui dentro do controlador do
animador Clique com o botão direito na minha animação
ideal e defina-a como estado padrão da
camada. Tudo bem,
vamos até a aba do jogo aqui e vamos ver como fica
a animação. Ok, parece bom. Perfeito. Dentro do controlador do
animador Esse é o ponto de entrada. Essa é a animação inativa. Precisamos criar as
transições aqui. Clique com o botão direito aqui
na animação inativa. E faça
a transição para a caminhada mutante clique com
o botão direito aqui na animação da caminhada
mutante E faça a transição para
a animação inativa. Ok, clique na seta aqui
e selecione tem hora de saída. Clique aqui nesta seta
e verifique o horário de saída. Vamos criar um
parâmetro bool aqui. Está bem? E vamos nomear o
parâmetro como can walk. Vamos selecionar novamente
a seta aqui. E vamos adicionar o parâmetro. Vamos adicionar uma condição aqui. Suponha que se can walk
value seja um verdadeiro mutante, ou o personagem
começará a andar E se a lata andar for falsa, a animação inativa
será reproduzida aqui Vamos começar declarando uma variável
pública flutuante aqui. Velocidade de flutuação pública. Essa será a velocidade
do personagem. Vamos manter o
bronzeamento do animador de 2,0 F , a gravidade do flutuador público Essa é a gravidade
do personagem. Vamos manter em
nove, a velocidade
vertical do flutuador público é igual Ok, também vamos usar um
controlador de personagem aqui. O controlador de personagem é
basicamente usado para mover o personagem no controlador Unity Character
Controller. E então, dentro da
função de partida, o controlador é igual a obter o componente Character Está bem? E então é igual a
obter o componente Animador. não aplicamos Ainda não aplicamos o controle
de
personagem ao nosso personagem. Ok, uma vez que
escrevermos o roteiro, vamos aplicar o controlador de
personagem ao nosso personagem. Tudo bem, vamos declarar uma função aqui para
mover o personagem Vamos nomear a função como move. Ok, então florizontal é igual colocar, obtenha
o eixo a colocar, obtenha
o eixo horizontal. E flutuar na vertical é igual à
entrada para obter acesso Vamos escrever se
a condição para verificar se o
controlador está aterrado. Há uma propriedade no controlador de
personagem que verifica se o personagem
está aterrado ou não Vamos aplicar, se o controlador de
condição do estiver aterrado, velocidade
vertical é igual a
zero L, a velocidade vertical menos igual à Após a condição L, vamos
declarar novamente um vetor três, movimento
da gravidade é igual ao vetor n 30, velocidade
vertical Depois, há
mais um vetor três para realmente mover o jogador, o
vetor três é igual a se
transformar para frente em vertical
e transformar para transformar para frente em vertical
e transformar para realmente mover o jogador, o
vetor três é igual a se
transformar para frente em vertical
e transformar para a
direita em horizontal. direita em Vamos usar o
controle agora para basicamente mover o controle
do jogador, que é a função dentro do controle, dentro do controle do
personagem. Na função, precisamos
passar os parâmetros,
que são a velocidade do seu jogador para delta t em mais gravidade, passar para o tempo delta. A gravidade se move para
o tempo delta do tempo. Por fim, qualquer touro fixo pode andar na
vertical n igual a zero ou na horizontal n igual Vamos chamar essa função suave de função de atualização interna Vamos salvar o script. Ok, antes de rodar a cena, precisamos aplicar o controlador de
personagem
ao nosso personagem. Clique em Adicionar componente, selecione o
controlador de caracteres aqui. Ok, então
aplicamos controlador de personagem
ao personagem. Agora precisamos ajustar
o centro do controlador de personagem
no eixo y, basicamente. Ok, vamos trazer
isso aqui também, vamos mudar a altura. Aumente um pouco a altura. Vamos adicionar um script aqui,
que é a caminhada do personagem até o personagem antes de
executar a cena. Vamos colocar a câmera aqui dentro do meu personagem para que a câmera siga basicamente
o jogador. Vamos examinar a cena e
ver como fica. Sim, tudo bem.
Ok, está bem. É isso aí, pessoal.
Na próxima sessão, aplicaremos rotação na câmera e
também no personagem. Se quisermos retroceder, podemos
simplesmente girar
o mouse usando o mouse aqui Além disso, o player também será girado junto com
a câmera É isso aí, pessoal.
Obrigado pela sessão. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
70. Aplicar rotação à câmera e fazê-la seguir o personagem 3D: Oi amigos, Meu
nome é Rohan Sue. Na última sessão, aplicamos animação a esses
três personagens D. Nesta sessão,
aplicaremos rotação na câmera. Basicamente, vamos
adicionar um trecho de código na caminhada de
caracteres do script, que aplicamos a esse
personagem na última sessão. Vamos escrever um trecho de
código dentro do script de
caminhada de personagens. Aqui estamos no roteiro. Vamos declarar algumas
variáveis novamente. Agora, para girar a câmera. Basicamente,
transforme minha câmera em
público, lote público, sensibilidade ao mouse. Vamos girar
a câmera usando um mouse. Aqui, essa variável é para a sensibilidade do
mouse igual a dois. limite de flutuação pública é igual a -50 E o limite de flutuação
descendente pública é igual a 50 F.
Ok, então declaramos quatro variáveis aqui. Ok, então declaramos quatro variáveis aqui Vamos escrever uma função
aqui para girar a câmera que giramos Esse é o nome da
função dentro da função. Flutuar na horizontal é igual ao ponto
de entrada para obter o eixo, mouse x flutuar vertical é igual entrada
para obter o eixo, mouse Y transforma mouse x flutuar vertical é igual à entrada
para obter o eixo, mouse Y transforma Girar. Basicamente, para girar o
caractere zero no eixo x, horizontalmente até a sensibilidade do
mouse no eixo y e novamente zero no eixo z. Minha rotação é menos vertical na sensibilidade do mouse e 0,0 no eixo z. Agora vamos obter a rotação
atual da câmera
usando o vetor três. rotação atual do vetor três é igual a M ângulos urais locais ângulos de Euler locais são
basicamente usados para definir
a rotação de um objeto do jogo em relação ao seu sistema de
coordenadas pai Tudo bem, se a rotação x for maior que 180, rotação
atual x
menos é igual Agora, a próxima
rotação atual x é igual à função
lampada matlam no Unity. Basicamente, fixa o valor,
qualquer valor flutuante ou qualquer
valor inteiro entre um determinado intervalo,
entre um intervalo mínimo entre Tudo bem, a função clam
usa três parâmetros aqui. A primeira é a variável
que precisa ser clam. O segundo é o valor mínimo. E o terceiro parâmetro é
o valor máximo aqui. Tudo bem, precisamos
fixar a rotação atual x, ascendente e limite descendente Está bem? Agora, por fim, vamos definir a rotação
local da câmera Minha rotação local é igual ao ponto de quatérnio Dentro do Euler, precisamos passar
a rotação atual. Tudo bem, vamos declarar essa função de rotação dentro
da função de atualização Ok, então gire. Vamos salvar o script agora. E vamos ao editor do
Unity agora. Tudo bem, clique no
meu personagem aqui. E para o roteiro de
caminhada do personagem, ok, podemos ver uma propriedade
aqui que é minha, que não mostra nenhuma
transformação aqui. Então, precisamos apenas arrastar e soltar câmera
principal dentro dessa câmera perfeita. Então, podemos ver a
câmera girando aqui. E se quisermos
retroceder aqui? Podemos simplesmente girar a
câmera e voltar novamente. Tudo bem Tudo bem, perfeito. Parece ótimo. Oh, ok, isso é perfeito. Tudo bem, pessoal, muito
obrigado. Te vejo
na próxima sessão. Muito obrigado, pessoal.
71. Projetar um nível para o jogo 3D Knock the Cans: Oi amigos. Meu
nome é Rohan Sev. Nesta sessão,
vamos criar um jogo chamado Knock the Cans O objetivo deste jogo, basicamente, será
derrubar as latas Então, haverá cinco latas. Tudo bem, e vamos
bater nessas latas usando uma bola Vamos começar o processo
de criação de um jogo. Vamos criar o Plane aqui
primeiro para o jogo. Vá para Three D e
clique em Plane aqui. Reinicie o avião. 2000. Coloque a câmera no eixo z para -5,435 0,43 Ok, tudo bem Vá para o objeto Three D e
clique no avião aqui. Ok, vamos trazê-lo para zero. Vamos mantê-lo em 04.524 rotação de
0,06 no
eixo x Tudo bem, é isso. Vamos
criar um porta-bolas aqui. Basicamente, um
porta-bolas será um cubo. Ok, eu vou
criar um cubo. Você pode usar qualquer tipo
de ativo que quiser. Você pode usar tabelas. Você pode usar cadeiras, o que
quiser. Vou criar um cubo
aqui como suporte de bola. Tudo bem, então vamos
criar um cubo. Vamos escalar o cubo
no eixo x para um. No eixo y,
mantenha-o em 0,2 e
no eixo z mantenha-o em 0,3 Ok? Posicione o cubo
no eixo x de 00,51 a 4,68 Vamos criar outro aqui que eu possa segurar, e este Ok, vamos até o porta-latas. Novamente, posicione
o suporte
da lata no eixo x para zero aqui, 0,5 n no eixo z para -1,8. Eu baixei
algumas texturas Vamos apenas arrastar e soltar a textura do
porta-bolas aqui. Tudo bem, aqui nossa bola
será colocada basicamente
no centro. Ok, vamos aplicar a textura
para o porta-latas aqui. Vamos aplicar texturas
no solo aqui. Avião um, avião dois aqui. Agora vamos criar latas. Como criamos latas? Vamos
criar um cilindro,
basicamente, para as latas Tudo bem, vamos criar
sua primeira lata aqui. Então vá para Game Object, vá para Three D, clique
no cilindro aqui. Vamos ver Scene More
e escalar a lata. 20.30 0.30 0.3 Vamos
colocar a lata aqui Acho que é muito
grande. Vamos reduzi-lo para 0,2, provavelmente. Sim, 0,2 e 0,2 Ok, parece melhor embaixo. Ok, vamos colocá-lo aqui. Essa é a primeira lata. Nossa lata tem um colisor de
cápsulas aqui. Vamos remover um
colisor de cápsulas da lata. E vamos aplicar um colisor de labirintos. Está bem? E clique em convexo aqui. Vamos adicionar um
corpo rígido à lata. Agora vamos até o
porta-latas aqui. E vamos aplicar um
corpo rígido no suporte da lata também. Ok, vamos aumentar a
máscara para provavelmente 500. Selecione o
objeto do jogo cilíndrico aqui ou sua primeira lata e pressione o controle D para replicar a
lata basicamente Ok, vamos colocar
as latas aqui corretamente. Ok, eu criei tudo
então. Vamos dar uma aparência um pouco mais sombria para
a câmera principal aqui Não quero que uma caixa celeste
selecione uma cor sólida. Vamos aplicar uma cor preta nela. Para a luz direcional. Eu não quero uma luz
direcional aqui. Vamos escurecer. E vamos adicionar um
holofote a ele. Ok, vamos trazê-lo aqui. Vamos ajustar o holofote. Vamos adicionar mais um
holofote a ele. Sim, parece melhor. Vamos reduzir
um pouco o alcance até que comece a ficar bem aqui. Isso parece melhor. Tudo bem, vamos
criar uma bola aqui, que será colocada no suporte
da bola aqui. Basicamente, precisamos criar um
prefabire, que será gerado ou instanciado quando clicarmos
no botão de geração, que criaremos posteriormente Tudo bem, para a bola, vamos criar um objeto de jogo aqui. Vá para Game Object e
clique em Radio object, e clique em Speer aqui Tudo bem, escale a bola
para 0,15 no eixo x, 0,15 no eixo y e 0,15 no Na posição do eixo x, a bola para zero no eixo
y posição para a bola 20,691 na posição do eixo z para a bola dois -4,695 Tudo bem, vamos aplicar uma textura Ok, perfeito. Agora vamos criar
um botão aqui
na extrema esquerda
para gerar a bola, porque essa bola só será gerada quando você clicar
no botão de geração Clique com o botão direito aqui, objeto do jogo Y, e clique no botão aqui. Ok, canto inferior esquerdo, 55,5 no eixo y
até 26,60 está Mantenha a largura do
botão em 84.5 Tudo bem, vamos mudar a cor do botão aqui que
corresponde ao fundo Ok, vamos mudar a cor do
texto do botão. OK. E altere
o texto para gerar Tudo bem, é isso. Nós
criamos um nível aqui. Na próxima sessão,
criaremos um roteiro para atirar a bola, arrastar e chutar
a bola basicamente e derrubar as latas Além disso, vamos
criar um script para gerar
a bola assim que jogarmos
a bola na lata É isso aí, pessoal.
Obrigado pela sessão. Muito obrigado. Nos
vemos na próxima sessão, pessoal.
72. Aplicando a lógica para derrubar as latas - Parte 1: Amigos, meu nome é Rohan Sev. Na última sessão,
criamos um nível para o jogo. Tudo bem, nesta
sessão vamos
aplicar um script na bola para
que possamos jogá-la. Atire a bola nas latas aqui. Mas antes de fazer isso, vamos ao objeto
do jogo Sphere
aqui, que é nossa bola. E vamos aplicar um corpo
rígido a ele. Clique em Adicionar componente aqui
e selecione Corpo rígido aqui. Vamos escrever
um trecho de código. Vamos criar um script
aqui para que possamos anexar esse script ao objeto
do jogo Sphere. E então podemos jogar
a bola nas latas. Tudo bem, vamos começar a
escrever um trecho de código aqui. Antes de fazer isso, precisamos
declarar algumas variáveis aqui. Vetor privado três, posição de pressão do
mouse para baixo, depois vetor privado três, posição de liberação do
mouse e, em seguida, o corpo rígido para aplicar
o corpo rígido ao objeto
do jogo esférico, corpo rígido RB Então, temos
a variável privada de
touro para verificar se
lançamos a bola ou não. Para o vetor três, lance o destino y um e y dois. Ok, não precisamos de uma função de
atualização aqui, então vamos remover a função de
atualização dentro da função inicial, vamos chamar um corpo rígido, R B é igual a obter o corpo rígido do
componente Então, aqui vamos usar duas funções dentro da unidade
1, com o mouse pressionado. mouse down é usado
para detectar quando clicamos no botão
do mouse E a segunda função
é a função do mouse para cima. Ele é acionado quando você realmente solta
o botão do mouse. Tudo bem, então vamos criar um
vazio na função do mouse. Pressione o
mouse para baixo porque é
aqui que você clica
na bola para jogá-la. Tudo bem, a posição de pressionar o mouse para
baixo é igual à posição do mouse com o ponto de
entrada, o raio um é igual a dois, a tela principal
da câmera aponta tela principal
da câmera Pressione o mouse para baixo na posição. ponto de funcionamento da tela da câmera basicamente retorna um raio que vai da câmera através de
um ponto de tela. Depois disso, vamos
declarar uma função up. Isso é acionado quando
você solta o mouse. Tudo bem, a posição de
liberação do mouse é igual à posição do mouse de entrada Ok, é quando você solta o mouse para atirar
a bola novamente. raio dois é igual à câmera, tela
principal, tela
principal, aponte para a posição de liberação do mouse Vamos
criar um resultado de elenco, sucesso e sucesso. O que é fundido no Cast in Unity
é como um feixe de laser. Basicamente, é como
um raio, que começa do ponto de
origem, avança na direção
especificada e vai até a
distância máxima especificada. Tudo bem, o lançamento retornará verdadeiro se for
atingido por qualquer objeto que caia. Agora, esse objeto
precisa ter um colisor, depois física dois e seguida, o destino de lançamento é igual ao ponto de resultado F. Vamos criar outra função para realmente atirar a bola
nessa direção específica. Agora temos um destino de lançamento. Ok, então vamos criar uma
função aqui para realmente atirar a bola sem cath e, em
seguida, retornar igual ao
verdadeiro R B
para verdadeiro R B para Jogue o destino
x no eixo x, depois jogue o destino
no eixo y e jogue
o destino novamente no eixo z até 160 é bom. Vamos declarar essa função de conversão aqui dentro de uma função up Ok, então quando soltarmos o mouse, a função de reformulação de
disparo será acionada aqui Clique no objeto do jogo de lança. Aqui já
aplicamos o corpo rígido. Vamos aplicar o script agora. Arraste e lance. Ok, vamos rodar a
cena e ver se podemos atirar a
bola nas latas agora. Sim Tudo bem, pessoal, muito
obrigado. Te vejo
na próxima sessão. Muito obrigado, pessoal.
73. Aplicando a lógica para derrubar as latas - Parte 2: Meus amigos, meu nome
é Rohan Vase. Nesta sessão,
vamos criar dois scripts. Um deles é o script do gerente, que
gerenciará o jogo inteiro. E o outro é o
script em que
detectaremos se a lata
foi derrubada ou não Mas antes de fazer isso,
vamos criar uma tag e anexá-la ao objeto
simples do jogo aqui. Ok, então vá para o objeto simples
e selecione a tag aqui e clique em uma tag. Em seguida, nova etiqueta, nomeie minha multidão. Apenas salve-o. Tudo bem, então temos nossa etiqueta aqui
, que é minha base. Novamente. Clique no objeto
simples do jogo, vá até a tag e selecione
meu terreno aqui. Tudo bem, ok. Dentro do script do gerenciador, vamos declarar duas variáveis Público em número de latas é igual A
contagem de chances do público é igual a zero. Agora vamos criar um gerenciador de objetos de
jogo vazio. E vamos anexar
o script Managers ao objeto vazio do jogo. Tudo bem, objeto do jogo, crie um nome vazio para o objeto como Gerente, vá adicionar o componente
aqui e o script do gerenciador. Vamos começar declarando a variável bole
j é igual Então, dentro
da função de início, precisamos encontrar o objeto do
jogo ao qual esse script do gerenciador está
anexado. Como fazemos isso? M é igual a encontrar o gerenciador de tipos de
objetos
dentro da atualização Vamos escrever a condição para verificar se a lata foi
derrubada ou não Vamos verificar a posição
da lata. Basicamente, vamos
escrever a condição F. Se o objeto do jogo transformar, faça y menor que 0,5 verifique se é igual a falso,
número de batidas é igual a m, número de latas batidas mais uma e cheque é igual a latas batidas mais uma e cheque é Agora, para detectar a
colisão com o chão, vamos escrever sobre colisão,
inserir a função aqui,
vazio na colisão, inserir
chamada de colisão, chamada jogo, etiqueta de objeto igual a meu chão
e verificar quedas, número de
latas batidas é igual a m, número de
latas batidas mais uma marcada é igual a verdadeira vamos escrever sobre colisão,
inserir a função aqui,
vazio na colisão, inserir
chamada de colisão, chamada,
jogo, etiqueta de objeto igual a meu chão
e verificar quedas, número de
latas batidas é igual a m, número de
latas batidas mais uma marcada é igual a verdadeira. Clique no cilindro um aqui, ele pode descer para ver o
número de latas derrubadas. Clique no objeto do jogo manager aqui e vamos rodar a
cena. Vamos jogar a bola. Ok, temos um que
pode derrubar. Ok, vamos jogar o jogo novamente. Ok, batemos duas latas. Agora está funcionando perfeitamente. Mas podemos ver aqui que a
contagem de chances não está aumentando. Vamos também aumentar o
número de chances contadas. Aqui, vamos declarar uma ok? E, novamente, M
é igual a encontrar o objeto do gerenciador de
tipos dentro da função de tiro do
carro M, chances é igual a M a contagem de
chances Ok, então quatro latas, número de latas batidas é
quatro e a contagem de chances Está funcionando. Perfeito.
Obrigado pessoal. Obrigado pela sessão. Na próxima sessão,
vamos escrever um roteiro para gerar a bola Obrigado pessoal. Te vejo na próxima sessão.
Muito obrigado.
74. Criação e instanciação de pré-fabricadas no jogo Knock the Cans: Olá amigos, meu nome
é Rohan Suede. Nesta sessão,
vamos gerar
a bola usando este
botão de desova. Ao todo, o jogador terá cinco chances de gerar a Tudo bem, mas para
gerar a bola, precisamos criar um
pré-fabricado a partir da bola Um prefab é basicamente um modelo
simples que pode ser usado para criar instâncias
desse objeto de jogo específico Tudo bem, mas antes de criar
uma bola pré-fabricada, vamos marcar a bola primeiro Ok, vá até o objeto do
jogo de lança aqui e clique em Tag e
adicione uma nova tag aqui Nomeie a etiqueta como minha
bola e salve-a. Ok, novamente, clique no objeto
esférico do jogo aqui. Vá até a tag e selecione
minha bola aqui. Tudo bem, e a etiqueta, minha bola, agora é adicionada
ao objeto esférico do jogo. Ok, depois de fazer
isso, crie uma pasta chamada prefabs dentro
da pasta de ativos E basta arrastar e soltar o objeto do jogo
sphere dentro da pasta prefabs e
o prefab Como criamos
um prefab aqui, desativaremos o objeto
esférico do jogo E o objeto do jogo Sphere,
por padrão, não estará visível dentro da cena, a menos que
cliquemos no botão de geração aqui Ok, então vamos
escrever um trecho de código para gerar o objeto do jogo Sphere
ou a bola no jogo Tudo bem, então eu já criei um script aqui
chamado ball spawn Vamos declarar algumas
variáveis aqui. Gerente M, objeto do jogo, bola dentro da função inicial. Novamente, precisamos encontrar o
objeto do gerenciador de tipos, encontrar o objeto do gerenciador de tipos. Não precisamos de uma função de
atualização aqui. Vamos apenas remover
a função de atualização em vez da função de atualização. Vamos criar uma função,
uma função personalizada, public void spawn ball Vamos escrever uma condição if. Se o objeto do jogo encontrar
um objeto com etiqueta, minha bola será igual a null. Isso é para verificar se a bola já
foi gerada ou não Contagem de chances menor que cinco Estamos dando ao
jogador apenas cinco chances de derrubar
todas as latas Ok, a contagem de chances deve ser menor que cinco se
quisermos gerar a bola Para gerar a bola,
precisamos usar instanciate, que é uma função Vamos colocar uma bola e a posição em que
queremos gerar o objeto Zero no eixo x, 0,691 no eixo y,
-4,695 no eixo z
e para a identidade do squatanion e para Vamos escrever uma condição em que
também exista uma bola de impressão. Agora vá para arrastar e lançar o script. Uma vez que lançamos a
bola aqui e uma vez a contagem de chances é aumentada em uma aqui ou
incrementada em uma aqui Vamos destruir o objeto do
jogo aqui, destruir o objeto do jogo
após 3 segundos. Vamos criar um objeto de
jogo vazio aqui e nomear o
objeto de jogo como spawn Ok, crie vazio. Vamos nomear esse objeto
como objeto de geração. Ok, e vamos anexar o script ball spawn
a esse objeto Desova da bola. Ok, agora podemos ver nenhum
objeto de jogo aqui para a bola. Então, vamos arrastar e
soltar o prefab aqui. Dentro disso, abra
a tela aqui, vá até o botão, esse
é o botão de geração Basicamente, clique
neste Plus aqui, basta arrastar o objeto de desova aqui Vá para a função de spawn e
spawn ball. E vamos rodar a
cena e ver se somos capazes de
gerar a bola ou não Ok, vamos clicar
no botão de desova aqui. Sim, somos capazes
de gerar a bola. Ok, a bola já existe. Ok, vamos até o gerente aqui e vamos ver
a contagem de chances. Então, sim, são dois. Vamos criar a bola novamente. OK. Três, tudo bem. Três latas bateram e
quatro chances perdidas. Somos capazes de
gerar a bola agora? Oh, aqui mostra que a
bola já existe. A contagem de chances é de cinco anos
e, de fato, nosso jogo acabou. Então, na próxima sessão,
vamos criar um pop-up. Ok, aqui mostraremos
que o jogo acabou quando a contagem de
chances for cinco Tudo bem, pessoal, muito
obrigado. Nos vemos na
próxima sessão. Muito obrigado, pessoal.
75. Crie um sistema de vitória ou perda no jogo e nas palavras finais: Amigos, meu nome é Ron Masurev. Nesta sessão,
vamos criar um pop-up para saber se o jogador venceu o jogo ou se o
jogador perdeu o jogo. Certo, clique na tela aqui, vá para Y e clique em Painel. Vamos chamá-lo de
Wind Panel aqui. E mantenha-o esticado. Alongamento. Vamos ajustar o painel. Agora vamos mudar a
cor do painel aqui. Agora, dentro do painel,
vamos adicionar texto, certo? Clique no painel aqui, vá para Y e vá para o texto Mesio Vamos reduzir o tamanho para 16. Sim, tudo bem. Vamos mudar a cor
do texto aqui. Vamos mantê-lo na cor vermelha. Vamos mudar novamente a
cor do botão aqui. Vamos manter o botão amarelado. Estenda o botão aqui. Vamos mudar isso
para repetir novamente. Altere a cor da
fonte aqui ou do texto. Vamos manter tudo preto. Desmarque o painel de vento agora, porque não queremos
mostrá-lo no início do jogo, só
queremos mostrá-lo se o
jogador vencer o jogo aqui Vamos verificar isso
no texto aqui. Em vez de ganhar o jogo, basta alterá-lo para Perdeu o jogo. Mantenha o texto
do botão como está. Ok, criamos dois painéis, um é o painel de vento. Outro é o painel solto aqui. Desmarque o painel solto aqui. Agora vamos ao script do
gerente. E vamos escrever um trecho
de código para realmente exibir esses painéis com base
nos resultados, quer o jogador
tenha perdido o jogo ou se o jogador
tenha vencido o jogo. Vamos declarar uma variável de
alta aqui. Bol, decisão tomada
é igual a falsa. Painel de vento de jogo
público, objeto de jogo público, painel solto. Agora vamos criar uma função
coutina aqui. Tine é basicamente uma
função especial que o Unity usa para interromper qualquer tipo de execução até que alguma
condição seja atendida Novamente, continua de
onde parou. Carga do enumerador, retorno de rendimento do
painel de vento, novo peso por segundos, um painel de vento ativado até que a decisão
tomada seja igual Se o enumerador carregar o rendimento do painel
solto retornar um novo peso por segundos, 3,5 painéis soltos ativados, verdadeira decisão tomada é
igual à Dentro da função de atualização, se o número de latas batidas for
igual a cinco, a
decisão tomada é igual a quedas e a contagem de
chances é menor que igual a se o número de latas batidas for
igual a cinco, a
decisão tomada é igual a quedas e a contagem de
chances é menor que igual a
cinco. Para executar a função cortine, precisamos usar start curtin Dentro disso, podemos passar nossa função que
é o painel de carga de vento. Se o número de latas bater menor que cinco e a decisão
tomada for igual a igual a, a contagem de chances de
quedas é igual a chances de
quedas Em seguida, inicie a carga do painel
solto. É isso mesmo. Agora vá para o objeto do
jogo manager aqui. Basta arrastar e soltar o painel de
vento aqui para o painel de
vento e soltar o painel
aqui para o painel solto. Tudo bem, então esse
é um roteiro de replay. Não precisamos das funções de inicialização e
atualização aqui. Vamos criar uma função
aqui para reiniciar um jogo. Public void Restart
Scene Manager, Load scene, knock can level one Esse é o nome da nossa cena. Basicamente, é bater
latas de nível um. Mas podemos ver o erro aqui. Ok, gerenciamento do Unity Engine, precisamos importar o Unity Engine. Faça o Seen Management. Se quisermos usar o
gerenciador de cenas na cena, estenda o painel de vento aqui e vá até o botão
dentro do painel de vento. Clique em Ad Component
e Silplay, clique aqui, arraste o botão aqui para
reproduzir Silic Vamos rodar a cena agora e ver como o
jogo se parece agora. Ok, você ganhou
o jogo, ótimo. Então, vamos clicar no botão de
replay aqui. Ok, você perdeu o jogo. Vamos clicar no botão de
repetição novamente e podemos começar a
jogar novamente aqui Então é isso, pessoal,
esse é o fim dos jogos com
Unity, parte um. Aqui nesta série, começamos com a
instalação do Unity e os conceitos básicos do C Sharp,
como declaração de variáveis, controle, fluxo, instruções,
loops e coleções Além disso, criamos a interface
do usuário, eventos e delegados do
Unity
e aprendemos sobre o sistema de entrada do
Unity Também aprendemos sobre a imunidade
física do motor, que incluía
corpo rígido e colisões Prosseguindo,
aprendemos sobre animações
Tod e Three D Por fim, desenvolvemos um jogo chamado Knock
the Cans Down, mas esse não é o
fim do tutorial Em breve, abordarei tópicos
mais complexos sobre jogos. Wearing the End,
desenvolveremos um
jogo de RPG baseado em É isso aí pessoal, obrigado por todo o apoio e
obrigado por me ouvir. Muito obrigado, pessoal. Nos vemos em breve novamente.
Muito obrigado.