Transcrições
1. 00 Introdução: Olá, pessoal. Meu nome
é Francisco Gollini E juntos, criaremos este pequeno e
incrível jogo lindo sobre um relógio que gira em torno de
seus ponteiros praticamente para sempre. Basta pressionar a
barra de espaço no teclado e nosso relógio começará.
E adivinha? Quando o ponteiro dos segundos
completar uma curva, o ponteiro dos minutos
dará um passo à frente E também temos uma interface bonita que nos
mostra os números de tempo. Então, veremos como importar esse relógio dentro de
um real do Maya e
definiremos o nível em uma câmera azurlight real para
ter um ponto de vista decente, e criaremos a
interface do usuário
e, claro
, o mapeamento de entrada que diz
ao ARL que, quando
pressionamos a barra de espaço,
o relógio e mapeamento de entrada que diz
ao ARL que , quando
pressionamos a barra de espaço,
o o Então, eu sei que você
está realmente empolgado com a perspectiva de criar um jogo
tão bom. Então, vamos pular agora
para a primeira a menos.
2. 01 Importação: Então, onde tudo começa? A começa em Maya, onde
temos nosso modelo de tendências. Mas se você usa um software
diferente, isso não é um problema,
porque o que conta é o fluxo de palavras
que seguiremos. Então, temos um lindo
relógio dentro do Maya. É constituído pela hierarquia. É composto por diferentes
objetos, como a base, o centro, os ponteiros das árvores e um pequeno bilhete
colocado na parte superior Então, para exportá-lo, selecionamos a raiz
da hierarquia E vamos ao
File Game Exporter. E nessa janela,
vamos até a guia Modelo. E aqui, vamos habilitar
a mídia incorporada. Então, vamos exportar
junto com o modelo, o fornecimento de material para
a superfície também. Vamos escolher o Pat, o nome do arquivo e depois clicar
no botão Exportar E o modelo
será exportado no formato FBX. Como essa. E vamos
importá-lo dentro de um real. Então, vamos pegar um real. Já temos uma cena
com o relógio dentro, mas vamos ver como
importá-la nesse espaço. Vamos usar o Content Driver e pegar uma pasta Eu criei aqui essa
pasta temporária onde colocar o relógio. E a forma errada de
importar o modelo é arrastar o FBX para dentro de
um real como esse Essa é a
janela de importação que será aberta. Dessa forma, quando
fazemos uma importação, as peças são
importantes separadas, não
temos a planta
representando o relógio com
todas as peças juntas Então, vamos excluir esses elementos. Excluir. Vamos importar o
relógio de uma forma diferente importação
de arquivos para o nível. Esse comando é mais
adequado para hierarquias. Importar para o nível. Vamos
pegar o relógio, abrir. A área pergunta onde colocar o
relógio que será importado. Digamos que, no tempo, teremos essa janela de importação que nos
mostra a hierarquia
existente para o relógio Então, vamos importar o relógio e teremos todos os elementos
separados como antes, mas mais ainda, temos a planta representando
o relógio inteiro Nós todas as peças, e
temos aqui à esquerda, todos os componentes
na mesma hierarquia
do relógio original Agora, quando usamos a
entrada no nível, o relógio é colocado
diretamente dentro da etiqueta. Aqui temos uma cópia. Mas se selecionarmos essa
cópia chamada FBX sin clock,
não conseguiremos movê-la porque dentro do
projeto que temos
é melhor que tenha sido
criada após Temos que definir a raiz da hierarquia com
o
parâmetro movabilidade móvel Vamos compilar e salvar. Vamos verificar se a
compilação sete está sempre ativada. OK. Vamos
voltar ao nível, e agora, se
pegarmos o objeto, poderemos movê-lo. Ok, mas não precisamos dessa cópia dentro da
cena. Vamos excluí-lo. E vamos deletar o
relógio importado também, porque dentro desse projeto, já
comunicamos o relógio, e ele está localizado aqui
nesta pasta de atores, onde temos o E temos uma
prévia melhor dessa forma, neste caso, provavelmente porque ela foi importada com uma versão
anterior do AA. Agora nós o atualizamos e
algo mudou. Mas de qualquer forma, é
só uma prévia. Quando organizamos os
ativos dentro do projeto, é
aconselhável criar
uma pasta de atores onde colocar as plantas
e uma pasta de malhas onde colocar todas as geometrias
que compõem a planta e
os materiais, além das mais
importantes, trazem junto com as geometrias Essas peças são
as geometrias e as bolas, as bolas coloridas
são os materiais Agora estamos felizes porque,
dentro da cena, temos um relógio que
faz parte de tudo o
que precisamos para fazê-lo funcionar. E é representado
pelo projeto, esse ator que temos aqui, e que foi criado
automaticamente depois em parte Na próxima lição,
veremos como ambientar a cena,
a fonte de luz e a câmera para capturar uma parte de você do
deserto.
3. 02 LuzesCâmera: Ok, aqui estamos. Nessa cena já
temos uma fonte de luz. É uma luz direcional. Para criá-lo, basta
acessar a guia de criação, luzes e luz direcional E nós temos essa luz. Podemos movê-lo e colocá-lo
em qualquer lugar que quisermos. Mas a posição não é
importante porque o que conta é a
orientação, essa luz. Isso afeta a semente. Porque esse tipo de fonte
produz uma série de raios de luz
paralelos que
iluminam toda a semente Mas vamos deletar essa luz porque
já configuramos essa. Então essa é a iluminação. Obviamente, essa luz uma série de parâmetros
que podemos encontrar aqui no painel de detalhes, e podemos definir a cor, a luz, a
intensidade e assim por diante. Ok. E a câmera? Nessa cena,
já está configurada uma câmera. Aqui está. Essa. E se a selecionarmos, podemos ter aqui uma
prévia da cena. Para criar uma câmera,
podemos ir aqui
na guia de criação e
na seção cinematográfica E aqui temos o ator da câmera de
cinema. Se a criarmos, quando
a câmera for selecionada, teremos sua prévia aqui
nesta caixa no canto
inferior direito. Mas temos a ideia de criar esta câmera e configurá-la como quisermos, para que possamos excluir esta. Ok. Agora, quando pressionamos play, a câmera não é
usada no início. Se fizermos isso agora, ele será usado porque
foi definido por um plano Vamos ver como dizer
ao sistema que use
a câmera que temos
presente dentro da cena, para ser usada quando
entrarmos no modo play. Para fazer isso, podemos criar uma planta dentro
do próprio nível. Aqui na gaveta de conteúdo, se formos para a pasta de nível, já
criamos esses ativos de nível 01 que representam a
cena que vemos aqui Agora, cada nível pode ter um
plano embutido em si mesmo. Vamos entrar nessa categoria, chame-a de modelo do Word E aqui podemos encontrar o plano de nível
aberto. E nós temos essa impressão digital. Temos uma
jogada ainda iniciada que inicia um sinal de execução
quando o jogo começa. E definimos aqui um controlador get player para
obter o controlador do player. O controle do jogador
neste jogo já
foi criado
aqui neste gerenciamento de pastas. E temos esse controlador de
player, chame-o de PC General para
criá-lo, clique com o botão direito do mouse, vá para a classe Blueprint e aqui você pode encontrar o controlador do
player Se você o criar, você tem
esse controlador de jogador, e esse controlador de jogador foi configurado dentro
do modo de jogo. Esta planta ao lado
dela, chamada GM General. Para criá-lo, clique com o botão direito na classe
Blueprint e
vá para a base do modo de jogo E aqui está, vamos deletar. Ok, o controle do jogador deve
estar configurado dentro do modo de jogo. Mas não precisamos
abri-lo, porque se entrarmos em nossa carta
e entrarmos nas configurações de recompensa,
aqui definimos a substituição do modo de
jogo, o general GM, o
modelo de jogo que criamos E dentro dele abaixo, encontramos seu parâmetro. E aqui no controle do player, configuramos o PC geral, o controlador do player
que temos aqui. Ok, então o sistema está configurado. Portanto, dentro do plano de nível, podemos usar esse controlador get
player que aponta diretamente para
o controlador do PC que configuramos no modo Ok. E também precisamos relógio
da câmera, da câmera que
criamos dentro da cena. Como podemos trazer
esse nó para dentro da planta retirando o
objeto da cena Bem, é bem simples. Vamos separar essa janela, a planta aqui. Um momento. E então temos a cena aqui, e aqui temos à direita a lista das coisas do
objeto na cena. Vamos pegar o relógio da câmera e arrastá-lo para dentro
da planta E temos a nota do relógio
da câmera. Ok, mas vamos excluí-lo
porque já temos dentro. E esse nó tem um subtítulo
do nível persistente. Isso significa que esse
nó faz referência a um objeto presente
dentro do C. Ok. Mas o nó principal de que
precisamos é esse, o alvo definido com mistura que podemos criar
facilmente pressionando Tab e escrevendo set you
target. Neste ponto, já
devemos ver o
nó, mas se não o fizermos, vamos desativar essa sensibilidade ao
contexto e finalmente encontraremos o
conjunto que você deseja com a combinação. O que esse nó faz? Simplesmente, ele pega o ponto de vista dado pelo controlador do
player, alvo e o overdt
com o ponto de vista
obtido da câmera conectada a
esse novo alvo de visão Ok, podemos deixar os outros
parâmetros como estão, e pronto, porque se
entrarmos em nosso nível, é
claro, vamos fazer uma compilação E certifique-se de ter habilitado a opção de compilação
acessando os três pontos, sete compilando e colocando
o ponto sempre Agora ele está desativado
por algum motivo, provavelmente porque
já foi salvo. Ok, tudo bem. Só para ter certeza de que podemos clicar
no disco aqui para
salvar a planta Mas se não tivermos
um asterisco aqui, esse é o nome, significa que a planta já
é sete Ok, vamos para o nível. Agora, quando entramos no modo de jogo, temos o ponto de vista de que fomos
configurados com a câmera.
4. 03 Interface do usuário: Ok, vamos ver como
a interface funciona. Se entrarmos no modo play e
pressionarmos play no teclado, a
hora começa e a
interface conta. Quando os segundos
atingirem o valor de 60, eles serão redefinidos e, em vez disso,
os minutos
serão aumentados em um. Então, vamos ver como
esse sistema funciona. Vamos aqui na pasta UI quando encontraremos os ativos
usados para criar a interface. Temos uma pasta de fontes contendo as fontes
que usamos. Basta arrastar uma fonte
dentro dessa pasta para
obtê-la e criar um contêiner que
será usado para as fontes. E temos uma pasta de ícones contendo os ícones usados
dentro da interface
e, claro,
temos um widget de interface de usuário
para criá-lo, clique com o botão direito do mouse na interface do usuário
e no modelo do widget Nesta janela, vamos
clicar no widget do usuário e será criado o
widget para a interface Mas vamos deletar esse. Já temos um set aqui. Vamos abri-lo. Eu clico. Ok, o widget é dividido em duas seções que podemos encontrar aqui no canto superior direito, a seção de designer
e a seção de gráficos A seção de design quando
definimos o design
da interface. Então, precisamos criar
um painel Canvas onde podemos colocar outros elementos
como imagem, ícone
e texto para a hora, e os dois pontos como separador, separador de
minutos, segundos e Ok, então
criamos graficamente nossa interface de usuário. Mas como vemos isso na tela quando
entramos no modo de jogo Precisamos definir
outro código dentro do esquema
do controlador do player. Então, vamos abri-lo. No final do conteúdo,
vamos para a pasta de gerenciamento. E aqui encontramos um general de PC que é o controle do jogador que está
usando neste jogo. Vamos abri-lo. E temos esse plano que faz
diferentes tipos de coisas Falaremos sobre
as entradas mais tarde, mas agora vamos nos concentrar nessa parte do
projeto em que
temos uma placa inicial que envia
um único sinal de execução Temos a sequência
que faz uma divisão
e, na segunda parte, continuamos com esta
nota que eles criam o Widget Para criar essa nota,
basta
continuar criando widget. Aqui está. E quando temos esse
nó nesse menu, podemos encontrar o widget que criamos
dentro do projeto Aqui no projeto,
temos na pasta UI, o widget de relógio
da interface do usuário Então, neste menu, podemos encontrá-lo aqui, relógio UI. Por isso, definimos
o widget de criação o aceno do widget criado
no widget que já
temos dentro Portanto, esse nó cria um
widget para o sistema, mas para exibi-lo na tela, precisamos de outro
nó chamado de porta de visualização que esteja diretamente conectado ao widget de criação e tenha como alvo
o próprio widget Dessa forma, exibimos a interface
do usuário na tela. Quando entramos no modo de jogo. É quando subimos
de nível e
pressionamos play, vemos a
interface aqui na tela. Esse é o único propósito
do widget de criação e da
adição à visualização por nós Mas agora vamos
voltar para concluir a definição
do nosso widget de interface de
usuário Portanto, a interface
é bem simples. É apenas um ícone com
algum texto ao lado. Mas vamos ver como é feita a seção gráfica em que
definimos como a interface funciona e a situação se torna um pouco
mais interessante. Com essas plantas. Ok, primeiro de tudo, criamos apenas um evento
personalizado chamado hora de
início que definiu uma variável como
uma variável booleana verdadeira A variável start
é criada aqui. Comece pela direita à esquerda. E o
evento personalizado para criá-lo basta pressionar tab e escrever eventos
personalizados
nos eventos personalizados e escolher o nome O costume, mesmo que seja, não
faz nada Ele precisa ser colorido partir de algumas outras
plantas para funcionar Portanto, é exatamente como nós que
ativamos a variável start. Como usamos essa variável? Bem, temos aqui a segunda
seção, bastante longa,
onde, no início, temos um
par clássico que envia um quadro a cada quadro enquanto
o modo de jogo está ativado. Todo o sinal que o tick
envia é filtrado por essa ramificação que verifica se a variável inicial
é verdadeira ou falsa Se for verdade, continuamos ou, se for falso,
tudo está bloqueado. Em seguida, definimos um atraso para deixar passar um sinal a cada 0,2 segundos. Em seguida, aumentamos
a variável de 10 segundos. Cuidado, essa variável,
10 segundos, é definida aqui à
esquerda como um número inteiro e é incrementada
por esse O nó positivo incrementa um o valor contido
na variável, mas, automaticamente, cria
um conjunto nessa variável Portanto, não precisamos colocar depois
do sinal de mais um nó definido para memorizar o novo valor dentro da variável que
escolhemos no início, o novo valor é alocado automaticamente na variável
interna Ok, enquanto o tempo em
segundos é aumentado, verificamos constantemente se
ele se torna maior que 60 porque sabemos que 1 minuto
é igual a 60 segundos. Nós fazemos essa verificação
com uma filial aqui. E se o martelo
atingir 60 segundos, continuamos e definimos o valor dos t
segundos dentro do texto. Caso contrário, fazemos a mesma coisa, mas redefinimos o valor de t
segundos para um. Agora, nesse nó, o
texto definido é bastante complicado porque quando
criamos esse nó,
acessamos a guia e
escrevemos o texto definido Vamos desmarcar o
contexto sensível. Temos um
tipo diferente de texto definido e é muito difícil
encontrá-lo entre todas essas
possibilidades. Portanto, o nó certo de que precisamos
é definir texto, texto entre colchetes. Esse é o nó que
estamos procurando. Ok, quando o
criamos, temos o nó que é o mesmo que já
configuramos. Então, vamos excluí-lo. Por
que precisa desse aceno Eu preciso da variável, elas representam o texto em
que recebemos o valor. Então essa variável
tem o nome de segundos, e podemos encontrá-la
aqui à esquerda. Mas essa variável não
foi criada diretamente
à esquerda, pois a outra variável de 10 segundos também
começa em 10 minutos. Mas é derivado
da seção de limpeza. Se formos aqui no Sanner
e pegarmos aqui à esquerda
o texto que
chamamos de segundos, que é
representado por essa caixa Percebemos que essa variável
está escrita em negrito, enquanto outros tipos de textos, como os separadores, são escritos
em um estilo normal Esse negrito é dado por essa verificação à
direita que é variável. Isso significa que esse elemento de texto que é visível
graficamente dentro do designer, é uma
variável que será passada dentro da seção gráfica. E automaticamente, quando a
verificação de variável está ativada, temos a variável
segundos vinculada ao elemento de texto que vimos
dentro do designer. Então, passamos a segunda variável que representa o texto para o nó de texto
definido como destino. E no texto,
temos que colocar um valor que é a string que
queremos escrever dentro do texto. E nós passamos isso com
essa conexão. Vamos conectar o tempo em segundos, o valor dos segundos que
usamos até agora diretamente
dentro do texto. Se fizermos a
conexão direta, automaticamente, será criado
esse aceno para texto, que é um
nó de transição usado para transformar o valor inteiro proveniente da
variável time seconds em um valor de string que é passado dentro do E essa é a
mecânica por trás dos segundos que acontecem
quando o tempo flui Vamos dar um passo
à frente e
armazenar o valor dentro
do texto por segundos dentro de outra variável
chamada seconds que está localizada dentro do Blueprint da
instância do jogo O que é a instância do jogo? Podemos encontrar aqui na
gaveta de conteúdo. Dentro da gerência. Em seguida,
criamos o controle do jogador
e o modo de jogo, bem como um nó geral da
instância do jogo. Podemos encontrá-lo aqui, clique com o botão
direito na classe Blueprint E aqui em todas as classes, o jogo é ans. Se encontrarmos aqui, o jogo é ans. Ok, mas vamos
excluí-lo, está pronto. O jogo começa agora. Se a abrirmos, ela
estará vazia, simplesmente. E eles têm apenas
essa variável aqui segundos definidos em
sua lista de variáveis A instância do jogo
é usada para armazenar valores que são mantidos
entre um nível e outro. Então, quando mudamos de
nível em um jogo, podemos salvar o
valor,
os pontos , a pontuação e outras
variáveis que foram coletadas
no nível anterior. Criamos esse jogo instantaneamente
apenas para garantir que
não percamos valores enquanto
continuamos com o jogo. Não
precisaríamos disso
neste jogo porque ele
é feito apenas de um nível e nunca mudamos o nível. Mas é um bom hábito
criar jogos. Vamos voltar à
nossa interface de usuário. E assim, o segundo valor o valor do
segundo da variável time seconds, é passado para a variável seconds
dentro da posição de jogo Para fazer isso, vamos transformar o nó
de posição de Gai no
lançamento da postura do jogo Nesse caso, o general GI
que criamos. E então vamos tirar da instância
do jogo um conjunto de variáveis que aponta para
a segunda variável. E dentro dela, vamos
colocar o valor vem da
variável de dez segundos aqui. OK. Mas, repito, neste caso, é apenas uma economia inútil desse valor. Nós não precisamos disso. Assim, podemos pular e passar
para a seção de minutos. Aqui temos os segundos
que vêm
da variável de 10 segundos que é comparada ao
valor de 60 por um nó de ramificação. Se os segundos ainda não
atingiram o valor de 60
, não fazemos nada. Mas se os segundos
chegarem a 60 como valor, a ramificação segue o caminho verdadeiro e aumentamos em
uma a variável que criamos e recebemos nome de minutos de tempo e
podemos encontrar aqui à esquerda. E, como antes, temos
aqui um aceno de texto definido que pega o texto da variável minutos e atribui a ele o valor de minutos de
tempo A variável minutos aqui é uma variável vinculada
ao texto negativo que podemos
encontrar na seção do designer Na verdade, aqui temos
aqui o texto negativo que negrito porque
está habilitado,
essa caixa de seleção é variável Então, automaticamente, o texto negativo que
temos aqui
foi transformado em
uma variável de minutos que podemos encontrar
na seção de grama
e usar aqui Dessa forma, quando entrarmos no modo de
jogo e
pressionarmos a barra de espaço, veremos mais tarde que
funciona a barra de espaço. Temos os segundos
que começam a aumentar
e, quando atingem
o valor 60, o valor é definido como um e os minutos são
aumentados em um. E assim por diante e assim por diante. O valor das horas não foi definido no
plano porque achamos que é difícil jogar uma única sessão neste
jogo por mais de uma hora Então, definimos apenas os
segundos e os minutos. Mas se você também quiser definir
as horas, podemos prosseguir, como
já vimos , nos
segundos e nos minutos. Ok, então deixe o tempo fluir e vamos
para a próxima lição.
5. 04 Entradas: Sabemos que quando
pressionamos a barra de espaço
no teclado, nosso relógio começa. Dessa forma, como isso é possível, precisamos definir novamente uma entrada dentro do
controlador do player. Então, vamos até aqui
e vamos abordar a pasta de gerenciamento
do PC general que é o controlador do player
usando neste projeto. E temos esse plano
em que já vimos como definir
a exibição da interface
do usuário
na tela OK. Mas também usamos o controlador do player para definir a entrada.
Como fazemos isso? Bem, temos o E e começamos a jogar, que é
dividido pela sequência, e uma ramificação aparece na
tela da interface,
e a outra
vai para esse nó,
adicionando o contexto de mapeamento que
é direcionado com o sistema de player local
de entrada aprimorado. Para criar esse
nó, podemos criar um contexto de mapeamento adicional. Adicione contexto de mapeamento, é isso mesmo. E o alvo aqui será a entrada aprimorada para o subsistema local de
presas. Aqui está. Não tem parâmetros. Ele identifica o alvo
apenas como uma entrada. Vamos deletar esse. Precisamos definir um contexto de
mapeamento
escolhendo-o neste
menu que contém, nesse caso, apenas esse
único relógio de mapeamento de entrada. E onde é fácil localizá-lo? Bem, nós o criamos manualmente dentro
do projeto aqui. Vamos até a gaveta de conteúdo, pasta
de entrada e encontramos
aqui o relógio de mapeamento de entrada E ao lado disso, a IUI começa. O IA é para toque de entrada e também é criado
manualmente. Para criar esse nó, tivemos que clicar com o botão direito do mouse e
acessar a entrada do submenu Você não consegue vê-lo porque
a tela aqui
está cortada abaixo, mas há um
submenu chamado input E dentro dele, encontraremos o contexto de mapeamento de entrada e o toque de entrada nos elementos. Temos que criar os dois. E então obtemos esses
dois elementos. Vamos abrir primeiro o toque de entrada no qual estamos
chamando de início da interface do usuário E é feito dessa maneira. Temos esses parâmetros, e o único em que estamos
interessados no momento é o tipo de valor que será definido no
digital bull que é identificar uma entrada como valor
booleano.
Isso é tudo. Poderíamos escolher um flutuador para números
reais, um vetor de dois d ou um divetor de três, mas estamos
interessados apenas na entrada
do Então, vamos identificar o valor de
Bleon como entrada. Ok, vamos fechá-lo. E vamos subir
o mapeamento de entrada. Onde precisamos identificar
a entrada que criamos
antes aqui nos mapeamentos Quando pressionamos o
sinal de adição nos mapeamentos, ele cria um novo slot
aqui onde podemos escolher o toque de entrada que
criamos dentro do projeto Ok, mas vamos
excluí-lo dentro desse lote. Temos as entradas que
podemos escolher entre
os diferentes tipos de dispositivos,
teclado, mouse,
gamepad e assim por diante Ok, estamos interessados
no teclado. Se
abrirmos o teclado, encontraremos aqui
todas as teclas do teclado e também da barra de
espaço, mas poderíamos escrever espaço e pularemos na barra de
espaço imediatamente. Ok, então
definimos a barra de espaço como
entrada, e isso é tudo. Isso significa que criamos uma entrada vinculada à barra de
espaço no teclado. Então, vamos fechá-lo. E vamos voltar ao controle do player,
o que precisamos para definir contexto de
mapeamento no relógio
de mapeamento de entrada. OK. Está bem? ainda
não está concluído
porque também precisamos descer e definir aqui, um evento personalizado vinculado
à barra de espaço. Ok, para criá-lo, vamos até
aqui na lista de nós e vamos escrever apenas o nome do toque de entrada
que criamos. Isso é IA que você e eu começamos. E encontraremos nosso
evento personalizado com base nessa entrada. Ok, mas vamos excluí-lo
porque já temos uma entrada de evento personalizada nesta impressora E onde nos
conectamos a esse nó? Começamos, nos conectamos
ao horário de início do evento personalizado que, se lembrarmos, é o
evento personalizado que
criamos dentro do esquema do widget
da interface do usuário Se tomarmos novamente o widget da interface do usuário
no gráfico, temos, se lembrarmos,
no início,
essa hora de início de eventos
personalizados que define a variável
booleana inicial como verdadeira, usada aqui para ativar essa ramificação no valor verdadeiro e, assim, acionar todo o bullprint que continua contando o tempo que
passa Essa é a função do
controlador do jogador em nosso projeto. Vamos começar a próxima
lição, quando finalmente
veremos como mover
as alças do relógio.
6. 05 Animação de relógio: Ok, é hora de mover as alças do relógio.
Como fazemos isso? Bem, precisamos pegar a planta
do ator
representando o relógio Então, vamos abri-lo e
encontraremos esse relógio, na exibição por seção, ele mostra a geometria Mas no gráfico par, temos a planta que
gerencia a animação das mãos Como é feito esse plano. Vamos ver. No início, temos um evento que envia
um sinal de execução a cada quadro
enquanto o modo de reprodução está ativado E cada quadro moldado para o modelo da
instância do jogo O Gistance é o modelo
que criamos aqui, o GI geral que,
vamos lembrar, contém apenas um número
variável de segundos que é atualizado pelo widget
da interface do usuário Se entrarmos na interface do
usuário, se lembrarmos, dentro dela, definiremos esta seção aqui. Onde os segundos
são armazenados, o jogo fica aqui. Então, enquanto o tempo passa, os segundos são armazenados
dentro dessa variável, e podemos buscar esse
valor fazendo uma conversão em outra planta como a impressora azul
que representa o relógio Então, fazemos um cast
no GI e obtemos a
variável segundos. Ok, então os segundos
que passamos para a interface do usuário também são
passados para o relógio. E o que fazemos
com esses segundos? Bem, multiplicamos cada
segundo por seis porque esse valor serão os graus de rotação
que serão passados para o
componente de movimento two nod O componente de movimento
dois é um aceno que aplica transformação
a um componente como uma translação, rotação Nesse caso, estamos
interessados na rotação, mas o mais
importante é
identificar o componente
sobre o qual atuar. Então, na
entrada do componente, temos que conectar o componente em
que estamos interessados,
neste caso, o ponteiro dos segundos para pegar esse nó, basta arrastar. Os componentes que estão listados aqui na hierarquia
do ator, e obtemos o nó Ok, mas vamos deletá-lo. Podemos encontrar esses
componentes aqui também
nesta lista de componentes.
E é a mesma coisa. Se pegarmos o ponteiro dos segundos aqui e arrastarmos para dentro
da planta, obtermos os segundos da mão,
obteremos o mesmo aceno Ok, mas vamos lê-lo. Então, aplicamos uma
rotação de seis graus ao ponteiro dos segundos. Cada vez que passa um segundo, o
ponteiro dos segundos gira. E quanto aos minutos? Bem, temos um plano
semelhante para as atas nesta seção Mas antes de aplicar a
rotação ao minuto e, configuramos uma ramificação que verifica se eu passei 60 segundos antes. Na verdade, temos aqui os
segundos que são armazenados dentro da instância do jogo
que são incrementados cada segundo e
são controlados aqui Para ver se já passaram 60
segundos e se estão, a ramificação nos fornece
a saída. E isso acontece somente quando a variável segundos
é igual a 60. Mas o que acontece
se for mais de 60? Esse controle não
funcionaria mais. Bem, se você se lembra esquema
da interface do usuário, definimos os segundos dentro da postura de jogo, mas temos aqui uma redefinição dos
segundos para o valor E quando isso acontece, bem, quando temos os segundos que
são mais de 60 como valor. Portanto, cada vez que a variável
segundos tem um valor de 61, ela é redefinida para um. Assim, podemos começar
novamente de 1 a 60 para contar em segundos e, dentro do ator
modelo do relógio, sempre
temos esse
controle que funciona Então, quando os segundos
atingem 60 como valor, a ramificação passa, e vamos aqui neste nó, faça uma vez que deixe passar um sinal de
execução apenas uma vez. E pegamos esses minutos
variáveis que criamos aqui. Dentro da planta
do relógio,
e nós a incrementamos em um Vamos lembrar que esse aceno
mais mais incrementa em um, a variável e também inicia o novo valor dentro
da variável Então, os minutos são
incrementados em um e multiplicados por seis, e esse valor é passado para a rotação
do ponteiro dos minutos Na verdade, temos aqui, novamente, um novo ponto que toma como alvo os minutos da mão. Uh, ele deveria ser chamado de
minu tanda, ok Vamos acendê-lo como está agora. Por isso, aplicamos uma rotação
ao menos bronzeado com um atraso de 1 segundo,
só porque
queremos girar o menos bronzeado
exatamente quando o ponteiro dos segundos
passa do meio-dia para a posição do meio dia OK. Então, quando
aplicamos a rotação, podemos começar de novo
e eles fazem uma vez. Ao reagir. E isso funcionará somente quando a ramificação
se tornar realidade novamente. É quando temos novamente, os segundos que têm um
valor de 60 e assim por diante. Dessa forma, também podemos
girar o ponteiro dos
minutos,
junto com o ponteiro dos
segundos, e tomar cuidado dentro do jogo sem armazenar apenas a variável de segundos
enquanto a variável de minutos Este é criado somente
dentro desse projeto, o projeto
do ator relógio Portanto, é inserido dentro da instância
do jogo. É uma maneira diferente de
lidar com essa variável. Então, finalmente, vamos
entrar no nosso nível. Vamos pressionar o modo de jogo. E quando pressionamos o
teclado, a barra de espaço, o relógio funciona e o ponteiro dos segundos faz
uma bela rodada. E quando atinge
a posição do meio-dia, o ponteiro dos minutos faz uma
rotação de seis graus. E assim podemos ver o tempo passar
pelo tempo que quisermos. Obrigado por ter seguido esse curso curto, mas intenso. Veremos novamente novas e
incríveis aventuras inimagináveis
Francesco Ugolini, 3D Graphics Designer
