Transcrições
1. Introdução de Frogger: Tudo bem pessoal,
nesta seção, este é na verdade um módulo
de um curso maior, e aqui vamos
criar Frogger para
ajudar você a aprender como criar jogos
usando o motor Gatto recriando um jogo
clássico dos anos 80 Já faz muito tempo. Mas você pode ver com isso que
conseguiremos movimentar os jogadores. Música Temos algumas
zonas de vento, detecção de colisão. Poderemos usar mapas
de blocos. Entenda como os mapas de blocos funcionam. Temos uma
representação visual do tempo. Temos patrocinadores em andamento.
Temos colisões acontecendo. Temos um pouco de física
acontecendo acompanhando vidas e pontuações, bem
como alguns multiplicadores de
fundo Temos muitas
coisas acontecendo
neste pequeno jogo
clássico simples aqui. Então, espero que você goste
à medida que avançamos. E espero que você tenha pelo
menos um
conhecimento básico de programação, se não do script
G D, que o ajude a se manter atualizado e a
não se perder tanto
2. Baixe não há configuração: Bem-vindo aos futuros desenvolvedores. Se vamos desenvolver coisas usando o motor Gatto, seja videogame ou software policial de
mesa, primeira coisa que precisaremos é, bem, o motor Gatto Então, vamos dar uma olhada em como
podemos prosseguir e fazer o download
disso. Agora, a primeira coisa ou a
primeira maneira de dizer que podemos fazer isso é baixando o Gatto do site
oficial aqui, basta acessar goto engine.org Tudo como vemos aqui.
Aqui mesmo na tela. E uma vez aqui, você verá a seção de download
na parte superior da tela. Além de dois
botões de download no centro. Temos o LTS, que três pontos e o
mais recente, que é 4.1 Usaremos a
versão mais recente, que é 4.1. Não há nada de errado com
a versão x de três pontos. Ele ainda está sendo desenvolvido
e é o suporte de longo prazo. No entanto, se você a
usasse nessa versão enquanto
acompanha, pode
haver algumas funções ou coisas que
escrevemos que podem ter nomes
diferentes ou potencialmente nem mesmo existir
na versão antiga. Portanto, lembre-se disso
e, por isso, recomendo
que você use a versão
4.1 à medida que avançamos. Tudo bem Portanto, esta é
a versão estável e a 4.1 foi lançada. Assim, você pode
clicar no botão de download mais recente ou na guia de
download na parte superior. Ambos o levarão
a esta tela aqui. Tudo bem Então vá em frente
e baixe isso. Tudo o que precisaremos,
já que vamos usar
a linguagem de
programação de script GD Tudo o que precisamos é a versão
padrão aqui com o botão azul. E a diferença entre
esta e a versão.net é que a
versão.net
também suporta C E se você fosse usar isso
, teria que rolar para
baixo e também pegar o.net necessário
para usá-lo, bem
como, de preferência, programas
externos para Rachel Codin. São
muitas coisas extras que não
precisamos ao fazer este curso Portanto, se você quiser
obtê-lo no site, pode
clicar no botão
do motor Goto para 4.1 na versão
padrão Agora, há uma segunda maneira
de você conseguir isso. E isso seria do Steam. Você pode acessar o
Steam e fazer o download de lá,
se quiser, e isso
nos dará a versão padrão. Por padrão, a versão Steam
não tem a
versão dot p disponível. Portanto, você não precisa se
preocupar com nenhuma confusão se prosseguir
e obtê-lo no Steam.
3. O que vamos fazer: Tudo bem, esta semana
vamos acelerar as coisas. Uma opção, em vez
de usar apenas alguns textos, como
fizemos na semana passada. Nesta semana, criaremos ou
recriaremos um antigo jogo de dois D dos
anos 80 Agora, isso
nos dará a chance de trabalhar com duas colisões
de
controladores de D player Talvez entendamos algumas
partículas
com as quais possamos trabalhar e respondam, como você vê Se você nunca jogou Frog antes ou
nunca ouviu falar dele Veja aqui que
vamos trabalhar
com a interface do usuário para nosso
heads-up display. Temos pontos que
precisaremos para acompanhar meu mouse lá por um segundo. Mas não só isso, mas também veremos
se isso mostrará que aqui
temos uma certa quantidade
de progressão por jogador Obviamente, não
temos moedas, mas este é essencialmente o jogo Aqui temos duas
pequenas zonas seguras. Nesta pequena área roxa, temos uma estrada
no meio que tem cinco faixas de tráfego
alternando para frente e para trás Se o sapo for
atropelado por um desses carros, ele morre e o jogador perde uma vida. Eles
chegam ao topo. Eles podem pular nas
tartarugas e nos troncos para
entrar na zona segura Se eles pousarem na água, isso também é uma falha. Acho que agora que você
pensa sobre isso não faz muito
sentido, já que é um sapo Mas aí está.
Essa é a ideia do que vamos
criar, e é isso que o sapo é, se você nunca jogou
ou ouviu falar dele
4. Criando o fundo: Tudo bem, então vamos
dar um salto. Comece criando o Frogger. A primeira coisa que
você vai fazer é baixar os ativos e
mover a pasta de sprites
para o seu projeto Novamente, acabei de criar uma pasta vazia
especificamente para o Frogger, mas eu recomendaria que você criasse um novo
projeto para Dessa forma, você pode
exportá-lo
sem problemas no futuro. Tudo bem, então a primeira coisa que
precisaremos fazer, especialmente porque nossos
sprites são muito pequenos, é
precisarmos reduzi-los Ou não os reduza,
mas reduza nossa tela maior que o do gabinete de
fliperama Para fazer isso,
vamos entrar no projeto e entrar nas configurações do
nosso projeto. Tudo bem, então deve começar assim com as
configurações avançadas desativadas. E você verá no lado
esquerdo que desce até a
seção de exibição e entra na janela. E vamos
definir a largura 336 e a altura em 240 Tudo bem, este é o tamanho da tela de um gabinete de
fliperama. A resolução da tela para isso será perfeita
para nossos pequenos sprites Tudo bem, depois de definir isso, você pode ir em frente e
fechar e verá nossa pequena caixa azul
ficou muito menor do que costumava ser. A primeira coisa que
vamos fazer aqui é
criar o plano de fundo. Então, vamos criar
toda a estrada, a água,
a mediana roxa
que eles chamam, a área de pontuação para a qual
temos que chegar à frente Vamos configurar
todas essas coisas. Dessa forma, podemos começar a configurar e executar nosso
jogo e
tudo mais nos próximos vídeos
a seguir. Tudo bem, então vamos precisar
de uma cena em dois D aqui. Vamos clicar em dois D, e isso nos dará um nó
dois D para nosso nó raiz. Se você quiser
renomear isso, você pode. Você pode chamá-lo de
Maine, se quiser. Gerente de jogo,
realmente não importa. Se você realmente
quiser, pode simplesmente
deixá-lo como nome padrão. Vou me deixar
como padrão por enquanto. Para criar isso
em nosso pequeno plano de fundo, vou criar
um novo mapa temporal. Vou apertar o
botão de adição e selecionar Tile Map
no menu suspenso, veja em nosso nó de cortina Selecione o mapa de blocos. Vá em frente clique duas vezes nele
e selecione-o. Agora eu tenho a mente configurada aqui. Vou prosseguir e
excluir tudo isso. 1 segundo. Tudo bem, então você deve ficar assim quando tiver o mapa de
blocos selecionado. Se você não tiver uma seleção,
vá em frente e selecione-a. O que vamos
fazer é ir para
o lado direito. Vamos ver o conjunto
de peças aqui. Ele permanece vazio no momento, mas o que vamos fazer é clicar nele e ir
para o novo conjunto de peças. E então clique nesse conjunto de peças, e isso nos trará aqui. Agora, o que precisamos aqui é que
precisaremos da
pequena área da meta, da água, da estrada
e da mediana Se entrarmos em nosso
sprite e rolarmos para baixo, veremos a casa, o canteiro central,
a estrada e a água Se você apenas segurar o controle, poderá selecionar todos eles de uma
vez, desta
forma e
arrastá-los para nossa caixa de blocos aqui. Tudo bem. Antes que possamos
realmente usá-los aqui. Como você pode ver, não podemos
clicar em nada. O que queremos fazer rolar até
lá com minha roda de rolagem, ou você pode adicionar um sinal de menos A primeira coisa
que precisamos fazer é verificar se estamos
na guia de configuração aqui, selecionar nossa água e
clicar nela. E agora temos essa caixa
laranja ao redor dela. Isso significa que temos um bloco
que agora podemos usar. Vou fazer a
mesma coisa com a estrada, a casa central
, a sobrancelha do outro lado
. Agora a casa é um pouco maior. Acho que pode ser
maior do que isso. Vamos ver, o que temos? 2062 grandes. Como é isso? Acho que isso bastará. Perfeitamente divertido. Tudo bem. Eles nunca vão? Eu tenho um 16 por 24
aqui para este azulejo. Tudo bem, agora, se clicarmos
no mapa de blocos na parte inferior. Nossa tela aqui embaixo. Agora devemos ser capazes de
clicar e começar a desenhar
nossos sprites Clique na minha mediana, clique no meu azulejo roxo aqui Basta arrastar uma linha
até a parte inferior. Vá para a minha estrada, temos
cinco camadas de tráfego. Precisamos de cinco fileiras
de nossa cerveja preta 4.5 Se nos
referirmos à nossa imagem, teremos outra
camada de roxo, cinco camadas de água, 12345 Depois, temos uma camada de água que se enche
por baixo da Vamos fazer mais uma camada lá. Vamos pegar nossa casa. Basta
clicar em um spray e arrastar o mouse
para selecionar os três. Vamos colocá-lo. Oh, olha isso. Parece que temos esse problema.
Bem, o que está acontecendo? Estamos substituindo nossos ladrilhos de
água aqui. Não queremos fazer
isso. Precisamos realmente desenhar isso
em uma outra camada. E eu vou
continuar e terminar encher isso com nossa água. Até o topo
das duas últimas linhas. Vou clicar em nossa seção
inicial aqui. E não
queremos substituí-los, queremos construir em cima deles. Você notará aqui,
no lado direito
dos nossos mapas de blocos, temos algo
que diz camada zero. E se tivermos uma lista suspensa, não
há mais nada lá. O que queremos fazer é ir até o inspetor do
nosso mapa de blocos, abrir a seção de camadas clicar em adicionar novos elementos Agora, na verdade, temos uma
segunda camada
nos mapas de blocos com nossa linha
inicial selecionada. Podemos ir para a
camada suspensa e clicar na camada um. Agora podemos realmente
desenhar diretamente em cima dela sem
afetar nossa final. Temos sete
em frente com isso. Só para ter certeza de que nossa rosa, 1235, parece boa para mim. Se clicarmos novamente em nosso No TD, nada está ótimo. É com isso que estamos trabalhando. Se você se lembra, quando
analisamos a configuração do Alpro, aparência,
na verdade temos nossa pontuação Essa informação está
configurada bem no topo aqui nesta área azul vazia, nesse espaço vazio de água, temos nossos troncos, tartarugas que saltam e nos
ajudam a pular Dentro dessas
pequenas áreas vazias em casa é onde podemos marcar
pontos pegando nossos sapos O roxo é seguro e nossa estrada preta é onde nossos
carros vão aparecer Tudo bem, agora temos
nosso plano de fundo configurado desse jeito. Muito fácil de começar. O novo mapa de blocos é muito bom
para começar a usá-lo rapidamente. Não costumávamos ter camadas. Agora que fazemos isso configuração de coisas
desse tipo fica muito mais fácil. Tudo bem, esse é o
nosso histórico, vamos prosseguir e
pular para a próxima parte.
5. Criando o jogador: Tudo bem, vamos criar
nosso player. Mas antes disso, vou
salvar isso. Vai controlar
S. Entre no meu sapo ou suporte e salve minha
cena bem rápido Tudo bem, então para nosso jogador, nosso jogador realmente
terá sua própria cena que trazemos. Então, vamos clicar
no sinal positivo
aqui em cima ou adicionar uma nova costura Vamos escolher outro, pois esse é um jogador sobre o qual
precisamos ter controle. Este será o corpo dois de
um personagem D. Isso costumava ser
chamado de corpo cinemático Em outros motores, você pode ouvir
as pessoas se referirem a ele como tal, mas aqui agora ele é chamado
de corpo de personagem dois D. Agora esse corpo de personagem, temos esse triângulo amarelo aqui
que dá um pequeno aviso. Isso apenas nos diz que nosso
nó não tem nenhuma forma. Não pode colidir com nada. Não há colisão
por enquanto, tudo bem. Use isso para flutuar lá. O que vamos fazer é
, na verdade adicionar um,
outro nó aqui. E o que queremos
adicionar é um sprite. Dois D. Queremos adicionar
um sprite animado. Queremos que nosso sprite
seja animado. Temos duas molduras para isso. Vamos fazer
um sprite animado. Dois D no
lado direito do inspetor. Vamos abrir a
seção de animação versus quadros de sprites. Vamos clicar nele e
criar novos quadros de sprites. Então, vamos abrir esses
quadros de sprites apenas
clicando neles Tudo bem, vamos
usar nossa animação padrão, que vou
renomear para ficar inativa Em seguida, adicionaremos uma nova animação com esse
pequeno ícone aqui embaixo. Vou renomear
isso para Jump A Idle. Selecionado. Vou trazer
Proger inativo e G, pular Vamos
trazer o Proger Id, depois nosso ícone de salto Proger, e agora devemos
poder alternar entre os dois sempre que quisermos
jogar contra Tudo bem, se jogarmos lá, estamos pulando, estamos fazendo
nosso pequeno salto saltitante Você pode notar que o sprite está um pouco embaçado
aqui em nosso renderizador Mas aqui embaixo podemos ver que deveria ser bom e arriscado. Bem, para corrigir isso,
podemos seguir em frente e selecionar todos os nossos sprites aqui ao mesmo tempo Do nosso sistema de arquivos, vá
para
o lado esquerdo para que a importação não seja uma importação movida deixe-me seguir em frente e
informar onde está essa parte. Tudo bem, então se você
entrar nas configurações do seu projeto, eu entro nas configurações
do seu projeto e
localizo a seção de renderização e
textura aqui nas configurações
avançadas ou
precisamos dela nisso Não, não precisamos disso. Queremos um filtro de
textura padrão aqui, altere-o de
linear para o mais próximo. Vá em frente e feche
isso, e você verá seus sprites ficarem muito nítidos Se você vai fazer arte em
pixels dessa forma,
esse é o padrão que você deseja definir nas configurações
do seu projeto. E agora temos um
belo Roggio afiado. Isso é tudo o que realmente precisamos. Não precisamos nos preocupar com
a colisão, detecção ou
algo parecido por enquanto Nós nos preocuparemos com isso quando
chegarmos a essa parte. Então, eu vou seguir
em frente e, ha, salvar isso. E eu vou ligar
para esse jogador. Agora, se eu entrar na minha cena principal com meu nó, dois D selecionados. Posso clicar não nessa
vantagem para obter um novo nó, mas na cadeia ao lado dele. Isso nos permitirá
exemplificar uma cena que já existe para nós. Essa será a cena dos
nossos jogadores. Agora podemos ir em frente e pegá-lo e trazer
esse garotinho para cá. Nós podemos jogar,
podemos fazer o que
quisermos com esse garotinho. Então, vamos ver qual é a
nossa transformação. Sabemos que isso está em
valores de 16172, não
seria 176
se estivéssemos em valores E eu vou
mover meu sapinho para cima. Aqui vamos nós. Seja um pouco mais
centrado nisso. Agora eu tenho meu sapinho na minha cena principal com meu plano de fundo
e ele está pronto para começar Tudo bem,
isso bastará para este. Temos nosso jogador
configurado o quanto precisamos no momento, para passarmos para a próxima, onde
abordaremos para a próxima, onde
abordaremos a realização de
alguns movimentos do jogador.
6. Movimento de jogador: Tudo bem, vamos em frente
e vamos criar
o movimento para que nosso
sapinho possa se mover para cima, para
baixo, para a esquerda, para a extremidade, Para começar, precisaremos
de algumas entradas. Agora, se você quiser
usar as teclas de seta, então eu para baixo, eu para a esquerda e eu para a direita já existe, mas eu quero usar o WASD. Então, vou entrar
no meu projeto e acessar as configurações do projeto, e vou entrar no mapeador de entrada
na parte superior e adicionar uma nova ação E eu vou digitar add
à esquerda e à direita. Agora, para cada uma
dessas ações aqui, vou para
o lado direito e aperto o botão de adição. Eu vou atingir
o ponto positivo. Eu só vou pressionar no meu teclado. Eu vou te mostrar o
que isso parece, o que você vai
ver a partir daí. Vamos ver, esta é
essa janela aqui. Vou trazer isso
acima. Aqui está. Acabei de apertar a tecla
e temos isso. Se clicarmos em OK, vamos para baixo. Pressione o sinal de mais, pressione a tecla S novamente. A esquerda e D, no
momento, temos cima para baixo, esquerda e direita para nossos controles. Podemos sair de lá. Nosso jogador vai
precisar de um script. E vou anotar aqui no
meu sprite animado ao pular, eu não me livrei
do primeiro sprite, então vou pegar esse
com as pernas abertas e colocar um roteiro ao lado do corpo do nosso personagem, dois
D na cena do nosso jogador, só
temos um
vazio, assim Agora, o que vou
fazer é
criar uma função
chamada movimento. Então, isso é só para que
possamos manter tudo limpo e organizado e manter todo o nosso movimento
em um único local. Vamos fazer
para obter informações aqui, vamos usar
a instrução if na mesma instrução if que
usamos muito. Se, então, quisermos acessar o objeto de entrada ou
a entrada da classe de entrada
, queremos verificar a ação. Queremos continuar com o lançamento. Recém liberado ou apenas pressionado. Qualquer um deles funcionará para
este jogo, especificamente. Se a ação for pressionada, será enquanto o
botão estiver pressionado. Basta pressionar e
soltar significa, bem, basta pressionar quando o botão for ativado
quando você pressioná-lo. E liberar significa que o bloco de código será executado quando
você levantar o dedo. Vou usar apenas
pressionar, vamos tentar isso. Vou usar o botão e essa é uma string que
deveria ter aparecido Você automaticamente,
isso era dois pontos. Assim, podemos entrar nele
e criar o bloco de código. Tudo o que vamos fazer é
fazer duas coisas. Precisamos mover nossa pedrinha, precisamos
movê-la para cima na tela. E vamos subir um quarteirão e tudo
será dividido em 16 blocos 16 ou 16 blocos de tamanho. Então, vamos mover
nosso sapo para cima 16 quarteirões. Nesse caso, obteremos
nossa posição. Se fizer um pouco
mais de sentido para você, você pode dizer autoposição porque está se movendo, ao
qual esse script está anexado agora. Isso nos dará uma ordenança x e uma y que tem dois
números associados a ela Se clicarmos no corpo do nosso
personagem e olharmos para dentro do inspetor
em transformação, você verá que temos um
X e um Y e eles correspondem à localização em
que estão na tela Se clicarmos em nossa cena principal e formos até o corpo do nosso personagem, você verá que sua posição
é 169,2 33 no meu
caso, é por aqui que estamos
começando E vamos
somar ou subtrair disso o X
ou o
Y para obter nossos movimentos,
já que queremos subir Quando pressionarmos
para cima, afetaremos o número, diremos a posição. Estamos sozinhos, queremos obter
a propriedade de posição
e, em seguida, queremos que o número dela suba na tela; na verdade,
temos que
subtrair na verdade,
temos que
subtrair Então, vamos dizer que
menos é igual a isso. Poderíamos dizer que isso é igual
ao nosso número y da posição, é igual à posição
y menos algum número, cujo número neste
caso será 16 Se fôssemos deixar as
coisas assim e comandar nossa cena. Bem, que pena que
nosso sapinho não se mexa. Por que
não se move? Espero que você tenha percebido
ou entendido isso antes de eu
apertar Nunca ligamos para nenhum lugar para
nosso movimento, então nunca estamos realmente
verificando se há nada disso. Para isso, vamos
simplesmente colocá-lo dentro
da função de processo aqui. Movimento e
agora está sendo chamado. Opa. Pelo menos seria, se pudéssemos soletrar
corretamente. Lá vamos nós. Se tentarmos executar isso agora e apertar o botão para cima,
que para mim é W, você pode ver que estamos
avançando e movendo nossos 16 blocos por vez. Nós vencemos. Temos um
pequeno sapo lá em cima. Agora, é claro, o problema
é que ainda estamos nos movendo, mas não podemos retroceder Não temos animação
nem nada. Vamos fazer nossa animação
funcionar lá. Como reproduzimos nossa animação? Bem, se olharmos para a cena do
nosso jogador, podemos ver podemos seguir essa
linha facilmente, apenas um nível até o sprite
animado dois D. Vamos pegar esse nó A forma como mostrei isso antes foi usando esse cifrão.
Seria o mais fácil. Assim que você começar a digitar sprite animado,
ele aparecerá Lembre-se de que é apenas um sprite
animado dois D porque esse
é o nome dele Se eu fosse dar um nome a essa banana com uma grafia muito ruim de banana
, seria isso que
eu teria que
digitar aqui para acessá-la Vou apenas redefinir
esse nome para Deft. Tudo o que vamos fazer é
ligar para ele. Jogue, jogue. Você verá as animações
que criamos aparecerem. Vamos usar o salto. Tentamos que agora,
apenas com aquela edição de nossa linha, opa, temos que realmente jogar essa
cena e não nosso jogador, você pode ver que saltamos, mas estamos presos em nosso salto Agora, isso é um pouco
decepcionante. Como podemos consertar isso? Como
podemos voltar ao normal? Bem, podemos configurá-lo para que,
quando nossa animação for concluída, retornemos
à nossa forma ociosa Para fazer isso,
teremos que
acessar o
sprite animado do nosso jogador Vá para o
lado direito até a guia do nó e conectaremos um sinal que essa animação terminou. Se clicarmos duas vezes nele, veremos um pop-up para
conectar um sinal aqui. Vamos apenas
selecionar o corpo
dois do personagem em que nosso script está
e apertar o botão de conexão. Vou segurar tudo para usar
minhas teclas de seta para abri-la sempre que nossa animação terminar de ser reproduzida. Esse bloco
de código será executado Agora, o que queremos que
aconteça aqui é
que queremos voltar
ao nosso estado ocioso onde nosso sapo está
sentado lá A mesma coisa.
Vamos pegar nosso sprite animado em dois D, vamos chamar play Isso vai ficar
inativo se tentarmos isso. Agora, o que fazemos de novo se
tocarmos a cena certa,
como tentamos fazer isso. Agora vemos que agora temos esse pequeno salto que aparece quando
cruzamos a água Isso é incrível. Agora, o problema é que nosso
ídolo estará jogando
constantemente neste momento Nosso ídolo toca e
depois termina. E quando terminar,
vai jogar,
não, isso realmente
não será um problema Isso pode ser algo
a se ter em mente daqui para
frente para resolver esse problema. Na verdade, podemos corrigir
isso com uma escolha if. E como você pode ver minha
pequena saída, eu estava verificando as coisas
e vou te mostrar como fazer isso.
Vou limpar isso. Tudo o que precisamos fazer é
verificar os sprites animados. Quer o cifrão aí? Se animado, sprite
dois D Animation. Não, como se chamava? Bem, se entrarmos em
nosso sprite animado
e, a propósito, você
puder acessá-lo, basta segurar o
controle e clicar no sprite animado
dois D aqui em nosso código
, ele abrirá a página de
documentação Aqui está o que estamos
procurando aqui. Obtenha animação. Queremos obter animação. Como você vê, isso não
estava aparecendo. Às vezes, é útil
conferir a documentação qualquer maneira que desejamos fazer se o sprite
two animado receber animação Se dermos
uma olhada nisso, a animação atual
do recurso sprite frames no valor é alterada Contador de quadros,
progresso ou reinicialização do quadro. Mas o que queremos fazer é entender o que é
essa animação. Isso é basicamente retornar para nós qual animação está sendo reproduzida
ou selecionada atualmente. Então, vamos usar os
duplos iguais porque
queremos comparar o que é
devolvido para nós e
queremos escrever jump Então, quando
jogarmos nosso modo inativo, vamos
tocar em um, para que fique
dentro da nossa fechadura Agora, basicamente,
vamos verificar quando nossa animação termina Se o atual for pular, vamos jogar inativo Se executarmos isso, lá vamos nós. Nós temos nosso pequeno bebê. Parece exatamente o mesmo, mas não vamos reproduzir
constantemente
a inativa
repetidamente quando a animação inativa é
reproduzida Lembre-se de que ele toca uma vez
e depois está pronto. Não está girando. Se o seu, por exemplo, estiver em loop por qualquer motivo, vá em frente, aplique
seu spray animado E se estiver em loop, você
pode ver nosso mouse aqui. Isso é porque
isso está ligado. Então você simplesmente clica nele desligado, então
fica branco assim. Se for azul, então está ligado. Se for branco, está desligado. Agora, quando nossa animação terminar, depois de saltarmos, verificaremos se nossa animação
atual é pular Nesse caso, jogaremos inativo quando o
modo inativo terminar. Essa afirmação if não será verdadeira porque, quando
obtivermos a animação, ela ficará inativa, não pulará Como isso não é mais verdade, não
faremos mais nada. Não vamos continuar repetindo inatividade dessa vez É uma pequena diferença, uma
daquelas coisas que estão
no back-end que
o jogador nunca vai notar. Como eu disse, em um jogo
pequeno como esse, não
vai fazer
uma grande diferença, se é que alguma é perceptível. Mas é algo que vale a pena
conhecer daqui para frente. Mas quando você quer criar jogos
cada vez maiores. Tudo bem, então
vamos em frente e
agora podemos pegar nosso botão. Se apenas copiarmos e colarmos isso, podemos obter L se, em vez de an, se quisermos
pressionar para baixo em vez de para cima, quisermos mais 16 em vez de -16. Porque se o sinal de
menos estiver subindo, mais nos levará
para Então, agora podemos subir
e descer. Agora nosso sapinho
não se vira de jeito nenhum, o
que é um pouco decepcionante que é um pouco Mas podemos corrigir
isso facilmente adicionando
mais uma linha aqui. Podemos fazer isso falando sobre sua rotação antes de saltarmos, podemos obter a autorrotação. Se dermos uma olhada em nosso jogador, voltamos à cena do jogador, clicamos no
corpo do nosso personagem dentro do inspetor Se descermos, vemos
que temos rotação aqui. A rotação é em radianos em
vez de graus. O que podemos fazer é
dizer que rotação é igual. Podemos usar essa função embutida chamada deg two red Isso pode ter mudado aqui. Parece que sim. Parece que
foi renomeado aqui, deg dois d, tem os
sublinhados Então, vamos usar um argumento
na forma de graus. Se dissermos 180, isso será
uma reviravolta completa Viramos à direita, isso
vai ser 90 graus. Se você virar à esquerda, seremos
-90 De qualquer forma, temos que chegar a
180 positivos ou 180 negativos Eu só vou
fazer 180 graus aqui. Essa função vai
converter esses 180 graus em radianos para que
possam ser atribuídos à
nossa rotação aqui Agora, uma
rotação completa em radianos é 3,14 e é
daí que vem pi Isso seria o
mesmo aqui, 180. Como se fôssemos apenas copiar isso. Digamos que rotação seja igual a
pi dividido por quatro, então isso
nos dará uma Pi dividido por dois, isso
nos dará metade da nossa rotação
aqui em radianos Se eu fosse mostrar que
com pi dividido por dois, aí nos dividimos
do outro lado, talvez seja um pouco
mais do que dois. Agora, eu normalmente não
uso radianos sozinho. Podemos ver dividido por quatro. Temos esse pequeno
ângulo estranho. , pode ser um pouco estranho Às vezes, pode ser um pouco estranho
lidar com
radianos, que é um dos motivos pelos quais
prefiro usar graus radianos, só porque
é algo que
posso resolver
um pouco posso resolver Como você vê, lá vamos nós.
Nós viramos o rosto para baixo. Só que agora não estamos
voltados para cima. Então, agora temos
que corrigir isso dentro do nosso código. Faremos a mesma
coisa quando pressionarmos para cima, definimos nossa rotação para zero
se quisermos jogá-la. Agora, vamos lá. Agora podemos pular para cima
e podemos pular para baixo. Agora, e se quisermos
pular para a esquerda e para a direita? Bem, podemos obtê-los
com mais dois LCs aqui. Vou apenas
espaçá-los para ficarem um pouco mais legíveis. Aqui vamos nós. Começando pela segunda vez aqui, diremos que,
se a ação for deixada, em vez de modificar
o valor y, na verdade
modificaremos o x da nossa posição Como x é esquerda e
direita, se formos para a esquerda, temos que -16 aqui,
graus para vermelho Bem, poderíamos definir isso para 270 apenas para ficar do lado
positivo aqui. O que significa nosso último L aqui. Quando pressionamos para a direita, vamos modificar a
posição X em vez do Y, vamos mais 16. Se estivermos nos movendo para a direita, seremos girados
em 90 graus. Vamos em frente e tentamos isso agora. Deveria ver. Agora
podemos pular em todas as quatro direções em
que podemos contornar. Se seu sapo for colocado
no local correto, você poderá
pousar em todas essas pequenas metas domésticas aqui Não tem problema sem passar por cima. Aqui está. Agora vamos
manter nossa posição. Bem, na tela
seria bom. Podemos nos preocupar com todas
essas coisas mais tarde. Por enquanto, temos apenas nosso movimento girando e esse veículo está
ficando baixo por muito tempo. Eu só queria manter o movimento
em sua própria pequena seção. Aqui, lá vamos nós. Podemos correr por aí como nosso próprio sapinho Boeing.
Boeing. Mas tudo bem,
aí está. Agora podemos seguir em frente e passar para a próxima seção do nosso código. Acho que, em seguida,
vamos
criar nossos veículos
e fazer com que eles comecem a
atravessar a rua aqui.
7. Criando os carros: Tudo bem, hoje
vamos seguir em frente e criar os
veículos para atravessar. Agora temos
alguns diferentes. Vamos ver quantos temos aqui. Dentro de nossos sprites, temos cinco carros diferentes Lá vamos nós. E alguns deles vão para a esquerda, alguns
vão para a direita. E eles já estão
voltados para a direção que querem. Isso é ótimo. Tudo o que precisamos fazer é
criá-los e fazer com que eles se movam
pela tela. Tudo bem, vamos criar uma nova cena com nosso botão de
adição aqui na parte superior. Para nossas guias,
vamos para outro nó
e, assim como nosso jogador, vamos usar o corpo do
personagem dois D aqui Vamos dar a ele um sprite. Nesse caso, como não
temos animações para isso, vamos usar apenas
um sprite normal dois D, podemos atribuir
um dos primeiros sprites Agora, neste caso,
selecionei o pequeno caminhão, mas é claro que você pode escolher
o que quiser Especificamente, estou usando
um que está se movendo para a esquerda. No momento,
isso é digno de nota. Vou mudar
esse nome do personagem body two
D para ser truck. Vou guardar isso como
minha cena de caminhão. Vou precisar de
um pouco mais agora. Não vamos usar
uma forma de colisão, embora façamos
com que algum tipo de colisão possa
acontecer Porque, obviamente,
nosso sapo tem que ser esmagado de alguma
forma se for Para me preparar para isso,
vou criar uma área dois D que
praticamente me permitirá ter uma área
predefinida que eu possa verificar para obter essa área
com a área dois D selecionada Agora é onde eu posso trazer a
forma de colisão. Agora, a forma de colisão tem
esse pequeno triângulo, dando-nos uma forma de advertência de
colisão selecionada Passamos para a direita até nossa seção de formas e
criamos uma nova. Essa será apenas
uma nova forma de retângulo. Agora, não usamos formas
complicadas , como usar os polígonos Em vez disso, use polígono com forma com algumas dessas formas
básicas aqui Porque quanto maior a forma
da têmpora , melhor será
em termos de desempenho. No entanto, quanto mais
complicada for uma colisão, mais precisa
ela será É um equilíbrio que você mesmo teria que resolver. Mas, neste caso,
felizmente para nós, podemos apenas usar esses
retângulos e eles respondem,
especialmente porque para recriar
um jogo antigo como esse especialmente porque para recriar
um jogo antigo Tudo bem, agora que temos nossa forma de colisão
assim, e novamente, se você não percebeu
isso, certifique-se de que seu retângulo esteja
cobrindo Cada parte do caminhão aqui. Agora nosso caminhão realmente
vai precisar de um script nele. Vou adicionar um
a ele e, em vez de chamá-lo de script de caminhão, vou chamá-lo
de script de veículo. Agora, a razão pela qual
vamos chamá-lo script
do veículo
é porque poderemos usar esse script em todos os nossos veículos. Agora, para fazer isso,
vamos para uma variável. Para nós, o que isso vai fazer, essa palavra-chave
de exportação nos permitirá mudar
dentro do inspetor Vamos usar a
exportação com sinal de
arroba e criaremos uma variável e
chamaremos essa direção de
que será um número inteiro Por padrão, podemos
simplesmente enviá-lo para zero ou podemos enviá-lo para um. Realmente não
importa nesse caso. Se você salvar isso e
selecionar seu caminhão novamente, deverá ver a direção interna do inspetor
no lado direito Agora, no nosso caso,
precisaremos ser menos
um porque
vamos nos mover significa que estamos indo na direção
negativa. Eu simplesmente fui em frente e configurei
isso para menos um. Agora, na função de processo, vamos fazer com que nosso
personagem esteja correto, mas nosso caminhão se mova. Então, para nos
movermos, precisamos de algo chamado
deslizamento móvel ou colisão móvel Qualquer um deles funcionará
para ter movimento. No meu caso, a pele se move, slide. Mover código também é
bom. Praticamente define
o que acontece quando dois corpos
físicos colidem
um com o outro ali mesmo Ou batem um no
outro e ficam lá, ou eles podem
deslizar um sobre o outro No nosso caso, isso realmente não
importa pois
vamos usar
a área para determinar se nosso sapo foi
atropelado pelo caminhão Agora temos o slide móvel. Não podemos simplesmente jogar agora, porque ainda temos que
controlar esse movimento. Eu vou ter uma, outra
variável aqui chamada velocidade, que também será um número inteiro Eu acho. Eu vou configurar isso. Vamos tentar oito agora. Vamos ver o quão rápido isso se move. Isso pode ser um
pouco rápido demais. Na verdade, vou tentar com dois. Agora que penso nisso, tudo vamos fazer é
mudar
a velocidade e queremos
mudar o número x. Assim como a posição,
temos um x e um y
quando se trata de velocidade velocidade controlará
nosso objeto se movendo de forma consistente Vamos para a velocidade a partir de quatro,
interessante, talvez V maiúsculo porque eu sei que
existe uma embutida Tenho certeza que aqui está
baixo, ali mesmo. Devo ter acabado de colocar um erro de digitação
lá. Mas lá vamos nós. Então, podemos simplesmente fazer a velocidade x desta vez. Nós
vamos dizer iguais Não vamos
dizer menos ou mais, porque isso vai
depender da nossa direção,
digamos, velocidade vezes direção Vamos nos mover ao
longo do eixo x, então vamos nos mover para
a esquerda e direita na taxa de velocidade, que é duas vezes a direção
agora. No momento, estamos com menos um. Então, vai ser duas
vezes menos um e isso
vai nos dar menos
dois e deve
nos mover para a esquerda Entramos no inspetor e
mudamos para um positivo Então isso deve
ser duas vezes um. Traga dois positivos e faça-nos seguir
na direção certa. Eu só vou colocar o
meu de volta para menos um. Vou voltar à minha cena
principal e trazer um caminhão para
dar uma olhada. Vou colocá-lo aqui mesmo. Reproduza a cena e
veja se ela se move. Podemos ver que está se movendo, mas está se movendo muito devagar. Nós vamos ter que
ajustar isso. Vamos voltar para oito. Talvez oito fosse bom. Experimente isso. Oito não é bom,
mas é muito melhor. Vamos ver, queremos nos mover em 16 pixels? 16 parece bom, embora pareça muito fácil. Talvez queiramos aumentar isso. Lembre-se de que
sempre podemos voltar a isso
e, como estamos usando a
velocidade em todos os nossos veículos, podemos facilmente ajustá-la e
ajustá-la quando, na verdade, tivermos todas as cinco faixas sendo
usadas pelos Vamos ver, com 32, 32
está mais bonito aqui, acho que 32 é onde
vou deixá-lo e
ajustá-lo mais tarde Talvez você queira ir para 48 ou eu não acho que
conseguiremos
chegar a algo como
64, mas nunca se sabe. Acho que vou
usar apenas 32 como minha base. Tudo bem, então temos um caminhão
se movendo em uma direção. Agora também podemos criar nossos
outros veículos. Vamos ver, temos mais dois que se movem para a esquerda e dois
que se movem para a direita. Vamos ver o que temos aqui. E nós
vamos para a esquerda. Então, vamos
praticamente repetir esse processo e usar o
script do veículo em todos eles. Tudo bem, eu fui
em frente e, como você pode ver fiz minhas outras
quatro cenas de carro aqui. Tudo o que fiz foi entrar ajustar a
forma da colisão se precisasse substituir o sprite por
outro de nossos carros E então, se necessário, experimente a direção de
menos um para positivo, que controla todos os nossos carros E eu fui em frente e os
coloquei aproximadamente
onde eles estariam aqui, só para que eu pudesse testar
e dar uma olhada. Como você pode ver enquanto corremos, nossos carros seguem em frente
e dirigem e atravessam a tela na direção apropriada e nunca se
chocam . Incrível. Agora, tudo o que precisamos é de
mais carros com capacidade. Não queremos
colocar esses consistentes, exceto que precisamos
colocá-los manualmente. Então, precisamos
ter essa lista enorme
de carros que
não temos ideia de quanto tempo levará
para que eles apareçam Ou quanto tempo vai
levar para o jogador ficar sem vidas
ou completar o nível. O que vamos fazer é
criar geradores para esses carros. Tudo bem, esses geradores
estão basicamente em um horário definido para gerar Poderíamos ter cinco geradores
diferentes se quisermos, um
para cada pista Vamos ver, acho que é isso
que eu quero fazer. Acho que vou ter
cinco patrocinadores diferentes para que todos possam
ter seus próprios horários e, se você quisesse, poderia
definir como limite de desova
um limite de tempo para todos os veículos Isso também está perfeitamente bem. Vou
criar um e isso
vai ser um número básico de dois D. Vou chamar isso de Sp. Queremos chamar um
patrocinador aqui? Sim, patrocine um e
isso controlará meus principais spawns aqui Acho que também vou usá-lo como base,
então vou
conseguir um bom lugar então vou
conseguir um bom E como esse é o caminhão, eu o trarei de volta
para lá e isso me
mostrará que o caminhão
aparece nessa posição Estará
lá na minha prole. Vou criar
um novo script. Isso vai
ser apenas um script de spawn. Mais uma vez, vamos usar
isso muito bem em todas as extensões
que criamos aqui O que precisamos
fazer? Bem, precisamos esperar um determinado período de tempo. Isso vai excluir esse
comum de lá. Bem como o que
está aqui na linha nove. Tudo bem, então precisamos
esperar um determinado período de tempo. Esse tempo deve ser aleatório e, com base nesse spawn no nosso caso, vamos
carregar o caminhão Vou seguir em frente e fazer
variáveis aqui para o meu caminhão. Isso vai ser
uma pré-carga aqui. Sr. quer dizer que vamos
carregar a cena com antecedência. Dessa forma, podemos usá-lo,
podemos instanciá-lo a qualquer momento. Então, vou
pegar meu caminhão
do meu sistema de arquivos
e arrastá-lo para dentro. Dessa forma, temos a
localização correta aqui na cena. Com isso,
vou mostrar qual é
o único veículo aqui, porque então
só temos que
entrar e ajustar isso Mostre como podemos exportar. Bem, dessa forma,
podemos realmente usar esse script em tudo, em
vez de criar vários scripts apenas por causa
da diferença de uma variável. Eu vou te mostrar isso. Mas primeiro vamos colocar
isso em funcionamento. O que vamos fazer é que não
vamos usar esse processo de forma alguma. Na verdade, vamos
criar uma função chamada spawn vehicle. Aqui, precisamos de
um número aleatório Vamos
ligar até tarde. Basta chamar isso de tempo de espera. Vamos definir um valor flutuante e
defini-lo igual a,
vamos ver, um
número inteiro aleatório, sem erros Poderíamos fazer algo
assim e isso funcionaria. Não acho que precisemos usar
a faixa Rand, embora eu possa estar incorreto nisso. Tudo
bem, lá vamos nós. Já que quero
verificar isso, só por segurança,
vou manter o controle. Clique em Randy e isso vai
me abrir para esta página E sim, fiz isso corretamente
usando 20%. Nesse caso, um GC
nos dará um tituto entre 0,19%
100 nos dará 0-99. E se
fizermos por cento 100 mais um,
isso nos dará um número de 1 a 100. No meu caso,
se eu fizer três, se eu fizer três, teremos um tempo de
espera Vou adicionar um a isso. Agora temos que esperar pelo
menos 1 segundo, e entre as aparições de
caminhões serão 12-3 Podemos ver como isso parece Sempre poderíamos
ajustar isso mais tarde. Agora, nosso tempo de espera, temos isso, agora temos que realmente
esperar essa quantidade de tempo. Vamos dizer espere,
temos que pegar a árvore
para fazer isso. A palavra-chave await
aqui significa que vamos apenas esperar por isso No nosso caso, será um cronômetro, mas também pode
estar aguardando envio de
um sinal Mas agora vamos
dizer que uma árvore de obtenção cria Tim. Esse será
nosso tempo de espera aqui. Nosso tempo de espera aleatório em
que temos tempo, estamos ausentes para receber aquele sinal de tempo
limite que é enviado quando nosso Tim termina. Que será baseado em
um número aleatório, uma quantidade aleatória de segundos. Tudo bem, então, uma vez feito isso, podemos criar uma instância
do nosso caminhão, do nosso, diremos VT para veículo VI
para veículo, instância igual.
Nesse caso, vamos dizer caminhão mas devemos alterá-la para veículo Truck instanciate e depois adicioná-la ao
nosso próprio gerador,
uma criança para adicioná-la uma criança E eu Tudo bem, vamos ver como isso funciona agora. Não vai funcionar porque não
ligamos para ele. Vamos ver nossa função
pronta aqui
e nossa função de veículo
de desova que criamos Vamos experimentá-lo agora. Lá vamos nós. Então, geramos outro
caminhão, e não teremos
mais
porque só estamos desovando O que podemos fazer a partir daí
é que depois de adicionarmos a criança, logo após adicionarmos o
caminhão à nossa cena, que ele se chame
recursivamente Isso vai causar
um loop infinito. Vai continuar,
vai gerar um veículo e não fazer nada
e depois gerar um Quando terminar de
gerar outro veículo,
será gerado um veículo
e sempre será
um número aleatório toda vez que tivermos que
esperar entre os spawns Se dermos uma
olhada agora,
podemos ver que eles são bastante
consistentes em seu espaçamento. E então esse era um espaçamento
muito maior. Temos um
espaçamento muito próximo nesse. Parece que por cento três mais um pode ser o menor valor
que queremos, mas aí está.
Depende de você. São muitas pessoas
próximas. Depende de você, se
quiser ajustar um pouco
isso, brinque com ele E você decide como deseja que
eles sejam espaçados. Agora, a razão pela qual
não precisamos definir sua posição é porque estamos adicionando quando
criança ao meu observador E o observador está aqui, já que o caminhão aqui está
em 00 em sua posição O caminhão aqui está em 00
em sua posição aqui. E podemos ver que, se
formos transportar 00, será exatamente
o mesmo que seu pai, que neste caso
será o patrocinador 1 meu patrocinador diz que ele vai
aparecer naquele local, fora da tela o
suficiente Agora, como podemos
alterar esse script para ser
executado para poder usá-lo
em qualquer um de nossos veículos? O que precisamos fazer para isso funcione para todos os
nossos patrocinadores é que possamos ter o mínimo de
trabalho possível aqui Bem, primeiro, vou mudar o nome da minha variável de veículo de caminhão porque
agora vamos
usá-lo para mais de um
veículo, não apenas para o caminhão. Isso significa que teremos
que alterá-lo aqui em nosso spawn de
caminhão instantâneo para instanciado de veículo Queremos que essa
variável seja exposta dentro do nosso inspetor para que possamos
ajustá-la por nó Aqui vamos fazer o
arrombamento assinado com exportação. Agora, o que vamos
exportar aqui? Bem, poderíamos simplesmente
deixar isso como tal. E isso só funcionará se
olharmos para dentro do inspetor. Mas se você quiser ser específico, isso é chamado de pacote visto, é assim
que você o
exportaria. Então, poderíamos até mesmo
deletar a pré-carga aqui, só
temos uma placa, nosso veículo e o declarado
como pacote visto. Agora, se clicarmos em nosso
spawn e em nossa cena aqui, podemos simplesmente abrir o veículo e dizer Novo ritmo ou podemos carregar Obviamente, gostaríamos de carregar. Mas, para economizar
tempo, podemos simplesmente entrar em nosso sistema de arquivos, pegar nosso caminhão, arrastá-lo e soltá-lo lá. Se executarmos isso, veremos nossos caminhões aparecerem
exatamente como deveriam, assim como faziam antes Tudo bem, perfeito. Se fôssemos pegar,
digamos, vamos ver, carro um também está indo para
a esquerda, vamos pegar o carro. Substitua aquela cena lá dentro
e dê uma olhada nela. Aí está.
Nós o fizemos funcionar aqui com um veículo diferente. Tudo o que temos que fazer é
mudar isso. São muitos carros em uma fila. Novamente, posso ir
até você ajustando as coisas, mas aí está Vou substituir este por um caminhão novamente e
impedir que funcione. Agora, posso seguir em frente e
fazer mais vãos. Eu sei, nós fazemos história
e incompatibilidade. Isso é interessante. Não estou
fazendo nada com a história. Vou usar o controle D lá. E este é patrocinado por dois. Então, vou descer certificar que esse será
o carro três. Vou
procurar meu carro três, cena e arrastá-lo para dentro. Vá em frente e dê
uma olhada nisso. Lá vamos nós. Temos nossos
caminhões e nosso carro surgindo em nossos diferentes
intervalos. Fantástico. Podemos fazer a mesma coisa
com nossa bunda aqui. Vou duplicar isso mais
uma vez. E estou apenas
duplicando isso com o
controle D com o spawner E eu vou puxar isso aqui para este veículo. Essa é só vou estacionar o carro aqui, dar uma olhada e ver que todos os nossos carros
indo para a esquerda estão surgindo corretamente Fantástico. Agora
só temos que colocar os
dois à direita.
A mesma coisa. Vou apenas
duplicar meu spawn aqui e arrastá-lo
para o lado esquerdo E então eu o ajusto aqui. Nossa posição
deve ser boa. E esse é o carro, meu carro Fc o
duplicaria mais uma vez e o colocaria aqui
para a cena do meu carro dois Tudo bem, agora deve ser
capaz de vir aqui e deletar todos esses carros e caminhões
temporários. Se corrermos, ele deve estar
funcionando perfeitamente bem, gerando todos os nossos
veículos lá Nós o temos agora. Podemos andar por aí
com nosso pequeno, sim, nosso
pequeno sapinho aqui. Aí está agora. Só precisamos de uma maneira pular por essa água
para que possamos entrar lá de uma maneira de nosso pequeno
sapo ser esmagado. Acho que vamos lidar com
a compressão. Da próxima vez, teremos a morte
do jogador aqui.
8. Morte e Respawn do jogador: Tudo bem, então como
vamos fazer
nosso sapinho chegar se ele for atropelado por um carro Bem, a primeira coisa que
fiz foi adicionar uma colisão em forma de dois D para
cobrir o tamanho do meu sapo Vamos usar isso
para determinar
se você foi
atropelado por um carro em combinação com a área dois D que
está em nossos veículos. Dentro do meu sprite animado, criei uma nova
animação chamada Morte e trouxe o
sapo Sprite morto Agora que temos o que
também precisamos em nosso veículo, teremos que adicionar uma conexão
de sinal aqui. E o que vamos
querer é inserir o corpo. Poderíamos passar por aqui e conectá-los um
por um em todos os nossos veículos ou economizar um pouco de tempo e conectá-los
por meio do código. Acho que é isso que
vou fazer aqui, só assim economizamos
um pouco de tempo. Agora vamos dar uma
olhada em como conectaríamos esse sinal por meio do código
em vez da interface. A maneira mais fácil de
configurarmos isso é, como você pode ver a seguir, dentro do bloco pronto aqui, esse erro ocorre apenas porque
ainda não criamos essa função. Vemos que pegamos nossa área dois D porque é isso que está
enviando o sinal, o nome do sinal que
é o corpo inserido, você pode ver isso à direita. E vamos conectar esse sinal com a função de
conexão. Em seguida, criamos o que é chamado de chamável e passamos um nome E esse nome
será o nome da nossa função que queremos chamar. Jogador atingido, sapo acertou. Você pode dizer que é assim que
vou chamar de meu. Agora tudo o que precisamos fazer é
descer e criar uma nova função para o Funko Essa função também transmite
uma parte dos dados. Se dermos uma
olhada no
sinal do corpo inserido aqui no lado
direito, vemos que ele passa pelo corpo
e que é um nó dois D, será um nó dois
D de algum tipo. Temos que colocar esse
argumento no nó dois D. E,
desse jeito , isso agora deve conectar o sinal para todos
os nossos veículos. E para testar isso, podemos
seguir em frente e imprimir o corpo. E veremos isso.
Algo que eu também fiz
foi mudar meu player. Eu renomeei meu jogador do corpo do personagem TD para jogador Então eu tive que
entrar na minha cena principal aqui e substituí-la para que
o nome fosse atualizado. Agora, se prosseguirmos e
executarmos isso, devemos ter um corpo impresso toda vez que
formos atropelados por um veículo. Então, vamos testar a pista um. Sim. Pista dois, sim,
pista três, correto. Pista quatro. Nossa última pista, o
caminhão. Aqui vamos nós. Todos os nossos veículos
estão detectando quando somos atropelados e
podemos ver que temos muitos veículos
lá nesse momento, que pode ser uma boa quantidade Ou talvez você queira aumentar
o número mínimo de spawn entre eles. Novamente, depende totalmente de
você e de como você
quer fazer isso, faça o seu. Mas com isso, todos os nossos
veículos já foram conectados e configurados para
esmagar nosso sapinho A razão pela qual eu te disse que
li meu personagem Body TD. Para o jogador jogar, estou usando um Is maiúsculo
porque vamos usar esse nome no script do nosso veículo. Vamos dizer se e depois passar uma primavera aqui, jogador. Então, queremos ver se essa string está dentro de outra string. E a string que queremos
verificar é o nome do corpo. Agora lembre-se de que corpo é qualquer objeto com o qual
acabamos de colidir, qualquer corpo que acabou de entrar na área de
nossos veículos A propriedade do nome
dela
nos dará qualquer nome que esteja aqui, que no nosso caso é player. Veja se nosso nome é jogador
em vez de nome do corpo. Poderíamos fazer uma dupla igualdade se quiséssemos
ser um nome exato, depende totalmente de você Nesse caso, isso não deve
afetar nada. Terminamos nossa declaração
com nosso cólon. Desça até a próxima linha. Agora podemos executar
nosso trecho de código. O que queremos fazer
quando nosso jogador conseguir? Bem, vamos chamar a função de
morte em nosso player. Agora, essa função ainda
não existe, então teremos
que criá-la. Mas morte corporal se você quiser ter um caso extra. Segurança aqui. Você pode dizer que se o corpo tem um método que pode passar
na sequência da morte, então podemos inserir a
morte corporal em mais uma. Podemos fazer isso e
isso evitará um erro. Se
prosseguirmos e executarmos isso, veja
que não teremos
nenhum erro aqui. Porque estamos basicamente
dizendo, ok, estamos dizendo que se colidimos
com o jogador aqui,
jogador, se esse corpo tem
essa função, então chame No momento, ele não
tem essa função. Se você quiser colocar
essa camada extra de segurança
usando o método has, você certamente pode fazer isso. Vou entrar no meu
player agora e criar essa função bunk death Não estamos
discutindo nada com isso. O que vai acontecer
quando nosso jogador morrer. Mas precisamos reproduzir
nossa animação de morte para que possamos
corrigir nosso sprite . Vamos seguir
em frente e fazer isso. Sprite 2 animado, toque morte. Vamos dar uma olhada nisso agora. O que acontece quando somos
atropelados por um veículo? Um pobre sapinho
atravessando a rua? Ok, então vemos você morrer e então nós, um ou sprite
, estamos no caminho errado Não está virado para cima
do jeito que deveria. Vamos corrigir isso. Depois disso, vamos definir sua rotação. E nós
já fizemos isso. Quando pressionamos para cima, vamos adicionar
isso à nossa função de morte. Aqui vamos dar uma olhada que
agora deve estar funcionando perfeitamente. Estamos em uma posição incrível. Agora, o que você não pode ver
é que estamos constantemente sendo colididos porque nossa forma de colisão continua
atingindo E não só isso, também
podemos continuar nos movendo, então não podemos trazer o ser
e estamos vivos novamente, temos um sapo impossível de matar Tudo bem, uma prova de cada vez. Vamos impedir que nossa colisão
aconteça. E podemos ver isso,
e eu vou te mostrar que, se entrarmos em
nosso player, clique e eu vou imprimir um
sapo esmagado Você pode ver que,
apesar de estarmos mortos, ainda
estamos sendo
esmagados, sapo esmagado E continuaremos sendo esmagados mesmo que já
estejamos mortos Não queremos que isso
aconteça porque isso pode continuar
subtraindo vidas de nós, dependendo da
distância entre os spawns Vamos corrigir
isso em nosso player. Para fazer isso,
vamos pegar
nossa forma de colisão
que criamos,
a forma de colisão dois D que
adicionamos ao nosso player. E vamos
usar algo
chamado adiado nele O que isso basicamente fará
, se dermos uma olhada, é que chamar o método
no objeto
durante o tempo ocioso
sempre retorna nulo, não o resultado do método Aí está. Nossa palavra-chave aqui é chamá-lo
durante o tempo ocioso. Então, ele chamará
isso sempre que passarmos, quando tiver a próxima
chance que tiver,
basicamente, em vez de
tentar chamá-lo agora, quando
talvez não consiga carimbar funções, ele dirá para você
fazer isso antes de chamá-lo Você não precisa excluí-los. Eu só vou
te mostrar aqui o erro. Se entrarmos aqui e eu
ficar desativado é igual a verdadeiro, veremos que vamos
encontrar um erro Isso não impede que nosso
jogo seja executado. Vamos ver, fomos
esmagados duas vezes. Nossa desativação não está
funcionando por 12. Se entrarmos em nosso depurador
e observarmos os erros, isso nos dirá que não
podemos alterar o estado ao limpar as consultas deferred Então, está nos
dizendo especificamente para usar isso, é por isso
que estamos usando
call adied chamada adiada
aqui será uma sequência do que queremos fazer Nesse caso, ele será
desativado. Esse desativado requer
um segundo argumento e isso
será o que dissemos, no nosso caso, será definido como verdadeiro. Agora, se olharmos para
isso, esse erro desaparecerá e só seremos reduzidos a Aí está. Não vai
mais aparecer nosso código se você estiver
preocupado com o adiamento da chamada Quando somos atropelados por
uma grande variedade de veículos, como
quando são três
consecutivos , podemos
dar uma olhada aqui. Ele já foi
desativado antes mesmo de
o próximo veículo nos tocar. Tudo bem, então agora
podemos realmente morrer aqui. O que temos que ver é
como podemos nos recuperar. Certo. Agora somos apenas um sapo
impossível de matar porque não podemos
colidir com nada Então, temos
que resolver isso com nossa morte. Precisamos ter algum tipo de
respawn. Precisamos ter certeza de
que só podemos nos mover se estivermos vivos. Negocie um pouco
mais do que o pretendido lá. Tudo bem? Precisamos saber se
nosso sapo está vivo ou está
vivo ou não nosso sapo está vivo ou está
vivo ou Podemos fazer isso com uma função
simples que apenas verifica se está vivo ou se está morto. Com base nessa variável,
podemos nos mover ou não. Para isso, usaremos
um conjunto de estados, que será um enum, como você pode ver aqui
no exemplo aqui Podemos usar essas enumerações para
armazenar dados específicos. Suponho que você possa dizer: É basicamente como uma lista de opções que podemos selecionar. Isso torna tudo mais fácil quando
se trata de verificar as coisas. Você pode ver isso quando
se trata da forma básica de uma máquina de estado
usada para caracteres. Por exemplo, se você jogou Grand Theft Auto
Five, por exemplo. Você tem
controles diferentes quando está pé
em comparação com
quando está em um veículo. Isso é porque você está a pé. Os controles seriam um estado. A natação seria outro estado. Em um carro seria um estado, em uma aeronave seria
outro estado, etc Vamos usar isso para saber quando estamos vivos e quando
nosso sapo foi esmagado Para criar
isso, em vez de usar a palavra-chave Var, usamos enum. O nome do enum, que diz que vai
funcionar como uma máquina de estado, vou chamá-lo apenas de estado E então, em vez de
usar números iguais ou dois pontos, simplesmente
pulamos
direto para o colchete simplesmente
pulamos
direto para o Tradicionalmente, pelo
que eu sempre vi, eles sempre estarão na capital, então eu vou viver até
a próxima linha, morto. Estes são nossos dois estados, vivo e morto, vivo
será o estado padrão aqui. Vamos criar
uma nova variável chamada estado atual. Vamos apenas declarar isso como sendo um estado, um
dos nossos estados aqui Tudo bem, agora
com nosso movimento, tudo o que temos que fazer é
verificar se o estado atual é igual a dois é igual ao estado
vivo. E então introduza nosso movimento. Agora só podemos nos mover
quando estamos vivos. Agora, quando morremos,
temos que dizer que nosso estado atual agora está
sendo definido como morto. Se executarmos isso agora, não poderemos nos
mover. Quando morrermos e
formos esmagados, aí está. Estamos todos presos e não podemos
nos mover. Agora, tudo o que resta
é
prosseguirmos e criarmos o respawn Vamos criar uma função de Respawn quando tivermos vidas aqui É aqui que
vamos verificar
se o jogador ainda tem vidas. Vamos chamar
isso. Tudo bem, vamos ver como respondemos? Precisaremos fazer com que nossa
colisão volte a funcionar. Então, precisaremos chamar deferred em nossa forma de colisão E em vez de
configurá-lo como desativado, precisamos defini-lo
como falso para que ele
não seja mais desativado. Precisamos mudar nossa posição, posição
pessoal e
precisamos redefinir isso para onde nossa posição
inicial estará no momento. Isso é 169,2 33. Vou
copiar esse valor bem
rápido dentro da minha
cena principal. Vou adicionar um. Viu como eles o renomearam Aqui. Aqui vamos nós. Ele foi renomeado para marcar dois D e me dê apenas 1 segundo Vou preparar isso para você. Aí está. Então,
vamos usar um marcador dois D. Vou definir
sua transformação por enquanto Vou apenas
colar o valor e configurá-lo na mesma posição em
que nosso
sapo está começando Vou chamar esse
jogador de local de desova. Agora, quando respondemos, podemos dizer que a posição do ponto
próprio é igual Jogador que não vai
ser preenchido por nós. Só vou ter que digitar, posição do local de desova
do jogador Isso deve
acontecer instantaneamente. Então, vamos continuar com nosso processo aqui vamos
formar outra verificação, o estado atual
de LF é
igual ao estado morto. Podemos chamar o respawn. Isso deve aparecer
logo no início,
onde começamos Se você for morto,
parece que temos o que é. Oh, isso é justo. Local de desova dos jogadores. Não
podemos ter acesso
a ele porque, na verdade, precisamos subir na árvore para lembrar quem é nosso jogador, e o jogador
não tem acesso direto
à localização desse jogador Aqui precisamos subir,
seguir essa linha e subir um, e então isso
nos leva a esse nodo dois D.
E então não há dois D que tenham
acesso ao spawn de um jogador Temos que abordar algumas
maneiras de fazer isso Algumas maneiras pelas quais podemos seguir em frente
e obter o nó principal. Esse nó get é apenas uma forma longa de
escrever esse cifrão. Em seguida, dentro estaria uma string ou o caminho diretamente
para Playerspalocation Como alternativa, para manter
isso um pouco curto, podemos simplesmente fazer get node. Nós podemos transmitir coisas. Podemos dizer que use um ponto que
é igual a escrever self. Ou podemos fazer dois pontos que são iguais ao get
parent que acabamos de excluir E você pode ver que,
tanto quanto podemos dizer, faça isso com local de
desova do jogador principal Tudo bem, isso deve resolver isso. Agora, quando somos esmagados, você vê que voltamos
ao início Ainda não podemos nos mover porque
precisamos definir nosso estado
atual. Lembre-se de que não podemos mover o
estado atual para igual ao estado vivo. E não só isso,
temos que fazer com nossa animação volte
a ser nossos ídolos Vamos pegar nosso sprite animado
para interpretar nosso sprite ídolo. Volte ao normal
quando o executarmos. Agora, não podemos realmente dizer quando recebemos uma resposta. O que vou fazer em primeiro lugar
é usar calder e
colocá-lo depois de todo o resto,
porque percebo que colocá-lo depois de todo o resto estamos
sendo esmagados duas vezes Então, vamos ver se apenas movendo
essa linha, vamos corrigir isso. Isso não acontece. Ok, não é um problema. Só teremos que
ter um pequeno cronômetro, por exemplo, depois O que é bom. Tudo bem, então vamos
ver, o que precisávamos? Nosso símbolo morto não está funcionando muito bem
porque morremos. Nós reaparecemos instantaneamente. Não podemos dizer nada do
que está acontecendo. O que vamos fazer é
dentro desse respawn,
espere, fazemos o que fazíamos antes de usar get tree
e criar esse Vamos configurá-lo para 1 segundo. Parece muito tempo. E o sinal de tempo limite de
1 segundo pode parecer muito tempo aqui em um jogo
antigo como esse split. E então respondemos. Incrível, agora estamos sendo
esmagados várias vezes lá, que é um Vou vir
aqui e criar outro pequeno cronômetro para 0,5.
E vou ver o que consigo fazer ou quão pequeno posso reduzir
isso testando 0,5. Podemos escapar impunes. Vou tentar 0,2,
posso escapar com 0,2.
Talvez até consigamos escapar com
0,1 com um atraso muito
curto aqui. Lá vamos nós. Agora temos aquele 1 segundo em
que nossa imagem
de morte estará na tela de nossos pobres brônquios
esmagados E então acontece a resp. Incrível. Agora, se você quiser,
pode definir esse número em
uma variável aqui em cima para responder
Tim, ou tempo de resposta. E esse será o seu tempo
entre suas respostas. Agora, para mim, acho que
vou deixar tudo por uma vez. Isso não é um problema.
Acho que nunca vou querer
ajustar isso Agora, se você notar aqui, quando eu estava indo, se
eu me sentasse aqui, eu poderia ser esmagado pelo
carro embaixo, sem multa, mas eu fui esmagado lá Talvez eu queira ajustar minha posição
Y um pouco mais. Talvez eu queira ajustar minha
posição Y um pouco mais lá. Mas isso vai se resumir
a apenas brincar com a posição e
isso um pouco mais, mas sem problemas. Mas isso bastará para isso. Agora temos nosso sistema de morte
e ressurgimento de jogadores acontecendo Não temos nenhuma vida
acontecendo no momento, mas chegaremos a essas vidas
quando chegarmos à nossa seção. Mas com esse cuidado
, examinamos muitas informações. Espero que você esteja pronto
para passar para a próxima seção do jogo. Isso é.
9. Morte por água: Tudo bem, então vamos fazer com
que, quando pularmos
na água, morremos e tenhamos que responder. Bem, para fazer isso, poderíamos fazer isso de
algumas maneiras diferentes, mas a maneira mais fácil, então, vou dizer que podemos fazer isso, já que estamos usando um mapa de blocos, é tirar proveito disso e usar
o mapa
de blocos para nos dizer em qual
ladrilho estamos. Se estivermos na
água, morreremos. Se não, ficaremos
bem em fazer isso. Vamos continuar com
nosso script de camadas. Por outro lado, à medida
que
entraremos em nosso script de jogador, precisaremos de
uma nova variável para manter
nosso mapa de blocos aqui. Agora, não precisamos
definir isso no topo, mas não precisamos
configurá-lo constantemente em nossa função. Vamos fazer tudo, vamos ver isso e
vamos usar a
palavra-chave on ready. Tudo isso significa que a
variável que vamos
criar seria a mesma que se a
definíssemos aqui como pronta. Se disséssemos, por exemplo, que o
número
é igual a dez, seria a mesma coisa que se
criássemos um número e
depois o definíssemos como criássemos um número e dez aqui embaixo,
dentro do bloco pronto Tudo pronto
significa que isso é útil quando
queremos nos apossar de nós
específicos que estão
dentro de nossa cena Em nosso exemplo, queremos
obter esse mapa de blocos. Aqui vamos
fazer var tile map e vamos defini-lo
igual a yet parent node. É claro que atualmente é chamado
apenas de mapa de blocos. Agora lembre-se do que
eu disse , acho que foi
no último vídeo. Em vez de usar
get parent aqui, poderíamos
encurtar isso em nosso get No, apenas para fazer e ter o mesmo
equivalente de get parent Mas então eu vou
fazer isso apenas para manter as coisas novamente
um pouco mais curtas. Tudo bem, agora
temos nosso mapa de blocos. Agora, o que queremos
fazer é
verificar em qual ladrilho
estamos de pé. Vou seguir em frente e
criar uma nova função aqui. Vou ligar para
esse cheque a identificação do celular. Isso vai
nos dar uma chance vazia. O que isso vai
fazer por nós é basicamente usá-lo para primeiro obter a posição da célula em que
estamos. Então, vamos
dizer Pausa no mapa de barras, que será definido como nosso mapa
de blocos Local para mapear. E então isso
tomará uma posição, e
essa posição será apenas a posição do nosso jogador. Agora, o local a ser mapeado apenas
nos devolverá uma posição que
será a posição da célula em
que estamos. As células seriam cada um
desses quadrados alaranjados. Como estamos aqui imediatamente quando
o jogo começa, isso nos dirá essa célula aqui, a localização dessa célula. Então, a próxima variável que
vamos criar basicamente entrará lá e dirá, ok, isso é feito com esse
bloco. Agora, o que é esse ID? E ele vai nos
devolver um para obter esse ID, vamos criar uma variável aqui. Isso vai ser apenas
um mapa de blocos. Mapa de blocos, Sim, ID da fonte de venda. Isso só vai
exigir dois argumentos. A primeira será
a camada
em que está, que é a camada zero. A segunda
será a posição que
já obtivemos do nosso
mapa, uma variável aqui. Agora, esse ID agora deve ser
o que estamos usando. Se entrarmos e
imprimirmos essa identificação, vamos verificar e vender a identificação. Dentro do nosso processo, vemos uma
ser impressa imediatamente para a mediana para ser
impressa para a estrada e três para a água Quando executamos isso, podemos dar
uma olhada na saída, vemos uma ser
impressa para nossa mediana, duas para nossa estrada Se eu conseguir chegar
até a água aqui, teremos uma
para a mediana novamente. E depois três quando
atingimos a água. Lá vamos nós. Agora
sabemos que isso está funcionando perfeitamente, mesmo se viermos
até aqui, porque verificamos
que a camada zero será a nossa água. Bem, nós sabemos disso. Agora, o que
vamos fazer é agora I D é igual a três e é aqui
que mataríamos nosso jogador. Então entre, ligue para nossa função de
morte aqui. Agora, quando tocamos na
água, devemos morrer. Lá vamos nós. Agora podemos morrer quando nosso jogador
toca na água E espere pelo respawn. Agora, isso é um pouco cansativo quando o verificamos
constantemente desta forma Não importa qual seja a
próxima melhor localização para ligar aqui
somente quando estivermos vivos. Mas o melhor de tudo é que podemos chamá-lo sempre que realmente
nos mudarmos. Então, vou adicionar isso ao final de todos os
meus movimentos aqui. Agora, quando eu me movo em qualquer direção é a única vez que
vamos verificar. Em vez de enviar spam até agora. Bom, pule para cima, morto. Aguarde a resposta.
Agora nos movemos novamente. Tudo bem, então agora podemos afogar nosso sapo na água E podemos deixar nosso
sapo ser esmagado por um carro. Tudo bem, então temos
todos os nossos cheques de óbitos. Agora, tudo o que nos resta
fazer é fazer com que nossas plataformas funcionem e, em seguida, obter nossos pequenos pontos de vento no final pulando
para os locais certos E então configure nosso
heads-up display com nossa pontuação. Então eu acho que estará quase pronto. Acho que não vamos
perder nada depois disso. Pode estar errado. Mas aí está. Agora podemos arredondar nosso sapo com a água e
agora você sabe como obter
a identificação de qualquer ladrilho em que
seu jogador esteja. Tudo bem, faça
isso por este. Vejo vocês
no próximo vídeo.
10. Plataformas de água: Tudo bem,
vamos em frente e vamos configurar
nossa plataforma. Depois de configurarmos nossa
plataforma, a única coisa que podemos fazer ou
a única coisa que nos
resta para essas plataformas
é basicamente trocar os sprites e
torná-los cada vez mais
curtos para
minha plataforma aqui curtos para
minha plataforma Eu só vou usar os sprites
que temos aqui. Usando o registro para este exemplo, a extremidade no meio e
a outra
extremidade, termina no meio e começa. Isso significa que estou
usando três sprites aqui com minha cena principal A raiz da minha cena aqui é o corpo de um personagem que
eu renomeei como plataforma Eu poderia renomeá-lo
para log, se quisesse. Isso tem uma área dois D com uma forma de colisão
que cobre meu registro Aqui eu
conectei o sinal de entrada
e saída do corpo Depois de conectar
esses dois sinais, o script em sua plataforma
deve ter a seguinte aparência. E estamos prontos para adicionar informações ou adicionar
tudo a elas. Da maneira como
vamos fazer isso, também
vamos adicionar
coisas ao nosso script. A maior parte desse trabalho,
na verdade, estará no roteiro de nossos
jogadores. Por enquanto, vamos
acessar o script de nossos jogadores e adicionar algumas variáveis
que vamos usar. A primeira será uma plataforma, e essa será uma enxuta. E isso só vai
dizer ou deixar nossa água saber se estamos
seguros ou não porque estamos em uma plataforma ou se
não estamos em uma plataforma. A chamada
notificação de morte. Vamos pegar
nossa plataforma
ou plataforma atual , que é o corpo de um personagem em dois
D que passamos. Então, eventualmente, vamos começar a fazer isso. Por enquanto, basta
enviá-lo para saber se precisa uma direção de plataforma, que é uma falha inteira que
vamos definir como zero,
mesmo que isso não importe Novamente, usaremos a
plataforma, a plataforma atual e a direção da plataforma como nossas três novas variáveis
em nosso script de player. Vamos
prosseguir e descer até nosso ID
de celular de verificação. Vamos adicionar
à nossa declaração, então vamos dizer que ID é igual a três plataforma é
igual a falso Dessa forma, dizemos que se estivermos
na água e
não estivermos em uma plataforma
, mataremos o jogador. Temos nossas
condições definidas lá. Vamos ver o nosso jogador. Também vamos verificar, enquanto estivermos vivos, se nossa plataforma atual não
é igual a null, o que é apenas igual a ela Por enquanto, será um
objeto atribuído a ele. Quando nosso jogador
estiver em nosso registro, digamos que a plataforma atual não
seja igual a nula, podemos
seguir em frente e nossa posição mais é igual Então, vamos
fazer uma pequena massa. Precisamos abrir e fechar nossos parênteses
aqui porque
vamos usar a ordem das
operações quando
se trata de operações quando
se trata Vamos dizer que a
direção da plataforma é multiplicada por 16. Vamos usar
isso como mais um ou negativo, assim como fizemos
com nossos veículos. E multiplique por 16. Ou vamos mover
16 para a esquerda ou
16 para a direita. E vamos
fazer isso ao longo do tempo, então vamos
multiplicar isso por delta Dessa forma, não somos
baseados em quadros, mas sim no tempo. Então, a única coisa que nos resta
fazer é
definir a direção da nossa plataforma. E podemos fazer isso por meio de uma
função que queremos usar.
Sim, vamos seguir uma direção definida. E isso exigirá o argumento de que um número inteiro não retorna nada Tudo o que isso fará
é que ele defina a direção da
nossa plataforma igual a. Tudo bem, agora podemos ir para o
nosso script de plataforma. Não precisamos desse bloco pronto, podemos excluí-lo
dentro do nosso processo. Queremos que nosso diário, no meu caso, continue em movimento. Vou seguir em frente
e fazer a posição mais igual a 16 vezes delta. Isso o moverá
constantemente para
a direita quando entrarmos, quando nosso jogador entrar na área. Então, vamos definir a
plataforma aqui como verdadeira. E vamos configurar
nossa plataforma atual para nosso registro aqui. Minha plataforma aqui.
Vou dizer plataforma
corporal e
definir isso como verdade. Agora estamos na plataforma. Curva do Body Legos. Plataforma. Sim. A plataforma atual é igual a L. Quando o corpo sair,
faremos o oposto Então, vamos
definir em vez de verdadeiro, vamos defini-lo como falso
em vez de vender. Defina como não. Tudo bem, então o que estamos fazendo até agora
é quando nossa frente pula no tronco que está se movendo para a direita o
tempo todo Enquanto estiver fazendo
essa reinicialização, nosso registro está se movendo para a direita em 16 ao longo do
tempo e não com base no cérebro Agora, quando nosso jogador entrar na área de nossa plataforma em
que ele pode ficar de pé, definiremos a
variável de plataforma em nosso jogador verdadeira dessa forma, ao verificarmos definiremos a
variável de plataforma em nosso jogador como
verdadeira dessa forma, ao verificarmos
se
o ID da célula está correto na plataforma
aquática e se nosso jogador
não será morto. Em seguida, estamos definindo a variável
curva
da plataforma do nosso jogador para a
plataforma atual igual a self, o corpo do personagem aqui. Isso está se movendo,
representando nossa plataforma. Com base nisso, poderemos mover nosso personagem
até aqui. A plataforma atual
não é igual a nula. Se estivermos em uma plataforma atual
, moveremos
nosso sapo na mesma direção,
na mesma velocidade A última coisa que nos
resta é realmente
chamar essa função que
criamos de Definir direção. Corpo, direção definida,
que leva um número inteiro, que então vamos
mover para a direita, usaremos um positivo Agora, se adicionarmos
a plataforma à nossa cena e a executarmos, como você vê, lá está nosso registro
e, se pularmos
nele, acabamos morrendo. Talvez seja necessário
atualizar este apartamento. Um momento lá, um
novo, de volta. Siga em frente até lá.
Dê outra chance ao papai. Ok, estou morrendo. Então, meus sinais podem precisar ser reconectados Vou desconectar isso e reconectar e farei
o mesmo com minha saída Desconecte e
reconecte a saída do meu corpo e veremos se
esse foi o problema Ok. Ei, acho que
vi o que perdi aqui e estamos recebendo essas informações um
pouco rápido demais. Portanto, antes de termos
nossa instrução F dentro do nosso ID da célula de verificação, vou usar o botão de espera
e fazer o que fizemos antes com o cronômetro de criação
da árvore get E vamos fazer
uma pequena pose de 0,1 e obter aquele sinal de
tempo limite. Isso deve resolver isso para nós. Aqui vamos nós. Agora podemos pular em nosso pequeno
tronco e estamos bem. Podemos pular
para frente e para trás e ficar bem e nos mover.
Assim que pularmos, podemos correr de volta para o outro lado, se
quisermos ficar quietos. Se pularmos na água, seguimos em frente e morremos. Tudo bem, como podemos
fazer esse roteiro um pouco mais, eu acho. De uma forma modular, uma
forma que seja mais
amigável, para que possamos mudar constantemente
se temos dois sprites,
três sprites, um sprite, três sprites, um sprite, tamanho da nossa forma de colisão e
se temos tudo isso de qualquer
maneira e
se temos tudo isso Além disso, acho que defina nossa
direção para que possamos ter alguns se movendo para a direita e outros para a
direita ou outros para a esquerda. Bem, vamos
prosseguir e exportar
a direção de um
número inteiro para zero Por padrão, temos a
barra de palavras lá. Lá vamos nós. Então, agora eu quero
ir para minha plataforma. Eu posso mudar isso para
um em vez de zero. Podemos pegar a direção e
passá-la aqui quando chamamos a direção
definida mais igual a igual E poderíamos fazer a mesma
coisa aqui, onde
temos direção vezes 16. Podemos ir em frente e
verificar se
tudo ainda está funcionando.
Não quebramos nada. Nossa fechadura ainda está se movendo. Podemos pular nela e tudo bem, então ainda não quebramos
nada. Isso é ótimo. Vamos ver, o que mais precisamos? Bem, acho
que seria isso. E podemos simplesmente definir
ou criar todas as nossas plataformas
diferentes agora usando
o mesmo script de
quando criamos uma maravilha ou criar todas as nossas plataformas
diferentes agora usando
o mesmo script de o mesmo script , assim
como fizemos com nossos Tudo bem, eu volto já. Por que criar alguns desses? Tudo bem, então eu fui
em frente e fiz tartarugas
longas também e coloquei algumas
aqui na cena E como você vê, vá em
frente neste tronco, pule para as próximas
tartarugas, a próxima, pule para a direita,
suba na minha tartaruga, pule no tronco,
e eu estou pronto para pular no que
seria nosso Tudo bem, nossas plataformas
certamente estão funcionando muito bem. Agora é ótimo. Quero saber se
adicionei peso de 0,1 no corpo inserido antes de
mudar a plataforma em nosso script de plataforma. Eu quero
anotar isso agora. Tudo o que precisamos agora são nossos patrocinadores. Tudo bem, então vamos
em frente e criá-los. Vamos efetivamente fabricá-los exatamente como
os de nossos
caminhões aqui. Vamos comprar a nós mesmos ou adicionar um No two D, chamamos de patrocinador da plataforma Vamos
começar a alinhá-los. Então eu tenho um lá, eu tenho um lá, eu tenho
um, parece que está lá. Ok. Esse visual até faz isso. Na verdade, é um lugar um pouco
estranho. Sim, vá lá. E então precisamos de alguns para o
outro lado, para nossos obstáculos, superá-los e um
para o obstáculo de uma hora Tudo bem Então, esses parecem
bons pontos de desova. Esses estão um pouco
atrás. Esses estão um pouco acima. Teremos algo
semelhante à nossa geração de caminhões. Vou seguir em frente
e copiar nosso caminhão. Vamos ver, esses
terão o mesmo
nome diferente, o veículo? Praticamente.
Provavelmente poderíamos nos safar usando nosso script de
caminhão aqui. Nossas plataformas
seriam chamadas de veículo, mas acho que quero
fazer outras porque não
gosto do tempo de espera. Não acho que isso
seria bom para as plataformas. Eu só vou
usar isso como minha base. Vou clicar na
minha plataforma em breve adicionar um novo script aqui Vou seguir em frente e colar
o script do veículo. Vou ligar para essas plataformas. Vamos mudar para a plataforma. Instancie a instância
da plataforma self na criança. Espere, veja que é aqui que o
problema vai surgir Vamos ver, vamos de 1 a 2 e
adicionaremos três a isso. Vamos ver como isso funciona. Em seguida, mudaremos isso
de veículo de desova
para plataforma de desova Esta aqui será
nossa cena de plataforma de cena de log. A próxima, novamente,
vai ver, vá em frente e simplesmente
arraste meu script para cima e anexe-o a todas
as minhas plataformas. E a segunda é minha cena de registro, três é a plataforma de registro. E então 45 será meu. Tudo bem, então se agora nos
livrarmos dessas plataformas, mova meu player para
baixo para
que o C possa ficar em cima Vamos ver se estão funcionando. Sim, atravesse até o
outro lado, aí estão minhas tartarugas. Parece que precisamos
mudar esses tempos de espera. Isso fará com que
seja extremamente fácil para nosso jogador
simplesmente atravessar. É por isso que queríamos
usar um script diferente do nosso caminhão, porque
precisaremos de tempos de
espera
completamente diferentes para as plataformas. Tudo bem, então vamos
tentar mais dez. Isso nos dará uma
variação de 11,12 segundos. Oh, por que eu fiquei
entre esses carros? 11,12 segundos pode ser uma lacuna muito
pequena nesse caso. Neste ponto, vamos
ver o que se encaixa melhor aqui, talvez tentemos 5.6 Vou pular até o fim e ver como é esse
spread Mas, neste momento,
você está praticamente ajustando seus números
para ver o que parece bom para suas plataformas e o que
parece bom para seus caminhões Só quero ter certeza de que
eles não
serão totalmente
consistentes o
tempo todo e que não
pareçam estar, o que é ótimo. Como alternativa, se você
quiser
codificá-los um pouco mais ou
fazer a diferença
, venha aqui
e espere um pouco aqui E faremos com que seja um
carro alegórico, não um apartamento. Como alternativa, você
pode fazer isso aqui e excluir esta
linha completamente. Se você quisesse ter
uma quantidade específica, você queria ter controle
sobre a quantidade exata de
tempo de espera
por respondente Você pode fazer isso dessa forma, mas vou continuar com
esse pouco de randomização aqui Quer saber, eu
vou lá dez. Acho que isso bastará para isso. Porque agora
temos nossos respondedores, temos nossas plataformas Tudo parece estar
funcionando . Nós poderíamos
atravessar. Acho que a seguir poderemos
conquistar nossa vitória, nossa pequena vitória lá em cima quando pularmos para
a zona correta. Vamos ver, eu
gosto desses números? E pulamos na
água, morremos. Incrível. Acho que gosto desses
números por enquanto, pelo menos. Tudo bem, é isso. Terminamos de usar nosso
balanço de plataforma e de pilotá-lo. Em seguida, cobriremos a
área onde pulamos em nossa zona de vento e desovamos em
nosso pequeno sapo doméstico Tudo bem, vejo
vocês na próxima.
11. O espaço de vitória: Tudo bem, para a zona de vento, você pode ver que eu
tenho uma nova cena aqui. E essa é apenas uma
área dois D com forma de colisão e a direita dois D que só tem meu
sapo doméstico aqui como textura Ele está desativado ou visível
está desativado por padrão. Você pode fazer isso clicando
no pequeno globo ocular aqui. O espaço eólico tem um script
e um
sinal corporal inserido conectado a ele
. Simplesmente, tudo o que vamos fazer é definir o vinho corporal como verdadeiro. A zona de vento é uma nova variável que foi adicionada
ao corpo do jogador. O estado atual é
definido como estado corporal. Quando temos um novo
estado adicionado aqui, agora
temos um morto-vivo. E então, tudo o que
fazemos é pegar nosso sprite two D, obter a propriedade visible, configurá-la como verdadeira em nosso player para evitar problemas
e corrigir um pequeno bug Eu puxei aqui, estado atual do
LF é
igual ao estado morto. Coloquei nosso peso, nosso 1 segundo de peso
aqui e o tirei
da função de respawn que
costumava estar aqui no topo Acabei de
retirá-lo e movê-lo para o nosso estado. Isso deve ser tudo o que
temos que fazer agora. Podemos
voltar para nossa cena principal
e importar nossa zona de vento, nosso espaço eólico. Apenas morda lá dentro. Em cada um dos nossos pequenos espaços. Talvez seja necessário fazer alguns
testes para garantir que seu sapo
não o toque prematuramente para acionar
o vento Aqui eu tenho o meu cobrindo todas as minhas áreas. Se você quiser verificar as
zonas de colisão e todas essas áreas de depuração, basta acessar o menu
de depuração na E você terá
a opção de mostrar formas de colisão
visíveis. Se
fizer isso ao
executá-lo, verá que podemos ver todas as
nossas pequenas caixas de colisão
aqui para Lá vamos nós. Se você o estiver acionando
acidentalmente ou talvez esteja,
habilite-o habilite-o Dê uma olhada você mesmo. Você verá que quando
subirmos, devemos ter outro registro. Aí está. Podemos acionar nosso aviso de vento Aviso de que não fomos impressos em nosso
console lá embaixo. Quando nosso estado é
nosso estado atual, o
estado vence, respondemos e, em seguida, ajustamos a
zona de vento para quedas. Agora também estamos usando a zona de vento. No nosso ID de celular, adicionamos outra condição aqui. Se o ID for igual a três
e a plataforma for falsa, se estivermos na
água, não estamos
na plataforma e nossa zona de
vento não é verdadeira. Ou você pode dizer que a
zona de vento é igual a falsa, essa seria outra
forma de escrevê-la. Então podemos chamar de morte. Se não estamos na zona de vento, não
estamos na plataforma
e estamos na água. Então matamos nosso sapo. Caso contrário, nosso
estado de vento deve ser acionado e
podemos simplesmente responder sem
matar nosso jogador. Tudo bem. O
espaço eólico é muito simples, muito fácil de fazer lá. Agora, se você deixar
o sapo aqui ativado, o tempo todo depende de você Se você quisesse, você poderia
entrar e adicionar um nó temporizador. Você pode vir aqui e adicionar um cronômetro e depois definir isso para, eu não sei, vamos
dizer 5 segundos. Então, podemos entrar, ou melhor,
podemos conectar o sinal de tempo limite ao nosso
espaço de vento. No tempo limite, definiremos nosso sprite em
dois D visíveis como falsos Logo depois de tornarmos isso verdade, podemos começar o tempo. Podemos iniciar o cronômetro. Se fôssemos fazer dessa maneira, o que depende de você, é aqui que um pouco de
design entrará. Quão autêntico você
quer e quão personalizado você quer tornar seu
jogo, etc Então minhas madeixas
começam a
aparecer , então eu posso entrar aqui Esperamos para atravessar. Se usarmos o sapo Tim er here, nosso pequeno sapo doméstico vai aparecer
para o vento Depois de alguns segundos
, ele vai desaparecer. Então você o vê lá em cima, e
lá vai, ele desaparece. Se você quisesse desaparecer assim , é assim que
você faria. Podemos simplesmente adicionar esse
cronômetro ao seu espaço eólico. Defina-o no inspetor para
quanto tempo você deseja. Inicie o cronômetro depois de
definir o sprite para ficar visível quando o cronômetro
expirar, defina-o para Tudo bem,
isso bastará para o nosso espaço eólico. E só precisamos
dar uma olhada em nosso heads-up display, hud
ou gooey, e criar
um sistema de Tudo bem, é isso, e
nos vemos na próxima. Estamos quase terminando de criar
um clone do Frogger
12. Fix de vazamento de memória: Tudo bem, não vamos
adicionar nenhum recurso. Na verdade, vamos consertar
o que seria um suporte crucial, especialmente em um jogo maior Agora, o que temos é um vazamento de
memória em nosso jogo. Temos isso a partir de dois pontos,
tecnicamente estamos em torno de dez. Mas vamos dar uma olhada, se continuarmos
jogando este jogo, e eu
tirar isso aqui, terei que derrubar os caras prateados. Você pode ver tudo surgindo
fora da tela e eles vêm, basta olhar para aqueles carros partirem e as plataformas no
topo farão o mesmo Eles vão continuar e
vão embora para sempre. Eles nunca vão parar. Isso é
chamado de vazamento de memória. Tudo, vou deixar
aí só para que
possamos ver isso mais facilmente. Mas se eu pausar isso e clicar
na guia remota aqui no
topo da nossa árvore de cenas, que só está disponível quando
o programa está em execução Usamos o controle remoto, damos uma
olhada em todos esses carros em apenas um gerador que ainda existe, embora
provavelmente não precisemos da maioria deles O mesmo acontece com todos
os outros geradores. Nossa plataforma, nossos
geradores de plataformas, não são tão ruins porque têm uma taxa de desova muito mais lenta Mas eles vão durar para sempre e nunca
vão desaparecer. Eles nunca se
livrarão da memória. Eventualmente, você terá
esse pequeno jogo que pode ocupar 128 GB de
RAM apenas para continuar jogando Levaria muito tempo, mas eventualmente tudo
se encaixaria. Vamos corrigir isso crucial, acho que chamamos isso de bug. É muito simples para nós fazer isso. Só precisamos colocar uma
instrução if dentro
desses dois scripts. Agora, os números que você escolher aqui, obviamente,
dependerão do seu projeto. Mas, pelo que
testei e baseei em nossa janela, um conjunto de números que
vou usar aqui. O que vamos
fazer é agora que eu estou dentro do meu script de plataforma e dentro do processo aqui, vou apenas verificar
a posição global, agora a diferença
aqui entre e posição
global é se
entrarmos em nossa plataforma aqui, por exemplo, essa será nossa posição local, certo? Então, apenas a propriedade de posição. Mas quando estamos em nossa
cena principal, acima de tudo, isso será responsável pela nossa posição local
que vemos na tela, independentemente de quem seja o pai. Por exemplo, se dermos uma
olhada em nosso espaço aqui, podemos ver que sua posição em nossa tela principal aqui é às 24h45. Este será mais um espaço global, enquanto que se entrarmos aqui, podemos ver nosso espaço eólico, nossa posição local
aqui é 00 Esses são dois números diferentes. Espero que isso
faça sentido para você o motivo pelo qual estamos usando a posição
global aqui Obviamente, queremos
a propriedade X porque ela
controlará nossa esquerda e direita. Se nosso X for maior que 436, isso significa cerca de 100 pixels
fora da tela à direita, com base na localização de
nossos patrocinadores Isso ainda dá
espaço suficiente para superar isso. Se nossa posição global
x for maior que 4.436 ou a posição global x for
menor que menos 100, vamos sair cerca de 100 pixels tela na direção esquerda
e direita Se alguma dessas coisas for verdade, tudo o que
faremos é nos libertarmos. Tudo bem, então agora devemos
ver nossas plataformas caracterizando, desativando umas às outras ou excluindo umas às outras
de nossa memória Essa é apenas uma
solução potencial para
algo assim. Outra solução se,
dependendo do seu jogo, por exemplo, você estiver fazendo algo
como um inferno de balas, você vai
querer usar algo chamado agrupamento de objetos E podemos falar sobre o
agrupamento de objetos em um vídeo futuro. Tudo bem, então eu
vou até meu lugar aqui, meus veículos. Vamos ver, qual deles
estamos procurando aqui no roteiro do nosso veículo. Lá vamos nós. Então, não está no nosso
lugar no roteiro de um veículo. E a mesma coisa atribuída
ao processo será
colada no mesmo código. Se a posição de sublinhado global for
maior que 436 ou a posição de
sublinhado global x, será menor que menos 100 self
. Agora, se eu seguir em frente e executar isso, e estivermos na
cena certa, nossa cena principal aqui. Vou prosseguir e
pausar isso bem rápido. Construa nossa árvore remota, podemos dar uma olhada em nossos reprodutores regulares aqui, onde
os carros estarão Aqui está minha janela de jogo
para retirar isso. Se eu seguir em frente e deixar isso jogar. Tudo bem, temos
alguns carros surgindo aqui . Podemos ver isso aqui. Vou apenas estender a
janela para a direita. Eu tenho um erro aí. Parece que eu pego
Gato em vez disso. Aí está. Você
pode ver que eles estão no controle remoto e
também visualmente lá. Quando você vai longe o suficiente, eles estão se
excluindo completamente Agora, todos os nossos objetos estão sendo
gerenciados e,
potencialmente, só podemos ter alguns
ou tantos em nossa cena a qualquer
momento. Você pode ver as plataformas
na parte superior fazendo o mesmo, as mesmas coisas acontecendo no lado esquerdo da tela. O que não podemos ver agora. Vamos lá com
aquela simples, tecnicamente duas linhas de código Temos nossa memória,
nossa memória, acabei de sair da minha
mente agora, vazamento de memória É engraçado, já que
estamos falando sobre memória, mas aí está. Com isso, corrigimos
nosso problema de vazamento de memória. Vou
te mostrar um problema aqui. Não é realmente um problema, mas só para mostrar mais
um exemplo, aqui vamos para a plataforma. Se usarmos a posição em vez
da posição global, você verá
um exemplo aqui. Se dermos uma olhada,
você verá que, especialmente com as tartarugas, você verá as tartarugas
desovarem exatamente Tudo bem? Observe-os. Eles estão
chegando quando estamos usando aquela
posição local, aí está. Você vê que eles estão
desaparecendo muito cedo. Eles mal aparecem na tela
e desaparecem. Eles vêm até aqui
e vão embora. É por isso que temos que
usar a posição global. Então, eu só queria
demonstrar isso um pouco mais visualmente para você. Ali, não redesenhar Q free, como
eu disse, destrói
completamente o objeto e o tira
da memória Tudo bem, então aí está. É assim que podemos
consertar essa memória. Tudo bem,
em seguida, passaremos para a pontuação e a combinação, adicionando vidas de jogadores
e tudo
13. Sistema de pontuação: Tudo bem, no vídeo de hoje, vamos adicionar
o sistema de pontos. Como você pode ver aqui, essas
são as regras pelas quais seguimos. Dez pontos para cada etapa, 50 pontos para cada
progressão que entra e 1.000 pontos para cada
vez que obtemos cinco processos. É isso que precisamos ter
em mente quando fazemos isso. Vou começar
criando um script global, também conhecido como singleton
ou script de carregamento automático Para isso, basta clicar com o
botão direito do mouse no meu sistema de arquivos e
criar um novo script. E vou chamar isso de,
vou simplificar e me tornar global. Para ativar isso, acessamos
as configurações do nosso projeto. Vamos ver, temos isso
capturado agora? Nós fazemos. Vamos, pode ser um
pouco grande. Lá vamos nós. E entramos no autolite, nosso script global Ele receberá o nome global por padrão,
você pode alterá-lo, mas não vejo por que precisamos
adicionar. E lá vamos nós. Agora podemos usar esse
script em qualquer lugar do
nosso código agora, acho que é aí que
vamos manter nossa pontuação. É aí que vamos
manter nossa pontuação. Se
fecharmos isso, agora podemos abrir nosso script global
clicando duas vezes nele para
dar um exemplo. Aqui podemos vir até aqui, podemos criar outra função
aqui chamada pontuação de impressão. Eu tenho uma variável
aqui chamada pontuação. É um número inteiro que
diz que você tem 50. O objetivo
dessa função é apenas imprimir
a escola como sendo global. Eu poderia entrar no script do meu
jogador aqui. Eu poderia simplesmente escrever o nome
que tínhamos quando eu deixei, que foi chamado de global
para a capital. Então poderíamos usar a função que acabamos de criar, imprimir partitura. Então, quando executarmos isso, veremos essa pontuação impressa
aqui em nossa saída. Um script global
contém variáveis e funções que podemos
alterar e usar em nosso jogo, em qualquer script e a qualquer momento. Vamos seguir em frente e
podemos remover todas essas
coisas e definir
a pontuação para zero por padrão. Vamos seguir em frente
e ter uma função chamada pontuação de atualização. Tudo o que vamos fazer aqui é
imprimir nossa partitura. Nós exibimos na
tela neste vídeo? Agora, salvaremos a
exibição na tela para quando começarmos a
cobrir o Hud. Aqui, vamos apenas imprimir
a partitura. Quando isso acontecer, a pontuação de atualização usará o novo valor para adicionar a pontuação do que fazemos mais igual nova quantidade que podemos Bem, primeiro vamos garantir
que essas coisas funcionem. Toda vez que
pulamos, ganhamos dez pontos. Tudo o que
precisaremos é adicionar isso ao nosso movimento e a
todas as nossas peças. Então, vamos fazer a atualização global, pontuação da
atualização, porque ainda não a
salvamos. Atualize a pontuação e
passe dez pontos. E vamos
copiar isso em todos os nossos movimentos e
entrar no jogo. E à medida que avançamos, devemos ver dez pontos sendo adicionados constantemente. Pronto, 1030, 4050,
6070, 8090, 10110, etc Então, isso está funcionando com todos os
nossos botões. Fantástico. Podemos simplesmente aumentar nossos
pontos assim. Os pontos aqui são incríveis. Eu simplesmente fui em frente e
me livrei das outras impressões. Existem falsos? Só
para esclarecer isso, torne as coisas um pouco mais fáceis para você. medida que avançamos e corremos até
lá e corremos, você pode ver em nossa saída nosso número aumenta
toda vez que nos movemos. Lá vamos nós. Está
funcionando de forma fantástica. Agora, também precisamos
acompanhar quantos sapos obtemos no total Sapos. Não parece
a quantidade que queremos. Chamamos isso de combinação de sapos. Eu não sei. Vamos
chamá-lo de sapo múltiplo Multi frog, é um
int, começa em zero toda vez que você adiciona
ao multi Tudo bem, fazemos vários
sapos mais é igual a um. Eu lembro que com
cada combinação de cinco, ganhamos 1.000 pontos.
Aqui é onde vamos. Vários sapos com menos de cinco. Depois, vou tocar
nesta linha aqui. Então, vamos marcar
mais é igual a um novo valor. Marcamos mais é igual 1.000, obteremos 1.000.
Se conseguirmos cinco, isso só acontecerá se
entrarmos em uma área de pontuação Na verdade, não podemos
aumentar nossa multipodridão, ir até nosso espaço eólico e
entrar em nosso corpo É aqui que vamos
aumentar esse número. Seremos um
multisapo global mais igual a um. E vamos
colocá-lo ali mesmo, dentro do nosso espaço eólico. Em seguida, também chamaremos nossa atualização de pontuação de atualização global. E vamos ultrapassar
50 porque temos um sapo, já que estamos aumentando
nosso multisapo antes de atualizar Então, estamos atualizando nosso sapo
múltiplo por um. Então, verificaremos
basicamente se esse é nosso quinto sapo ou se não
é nosso quinto sapo, então faremos isso Vamos apenas adicionar esses 50. Caso contrário, adicionaremos 1.000.
E então, na verdade, precisamos reduzir o multi frog
para zero, porque isso
precisa ser
redefinido para zero, porque isso
precisa ser Vamos ver se isso funciona. Tudo bem, estamos até aqui. Vamos em frente e
entrar na zona. Estamos no tronco agora,
esperamos que essas
tartarugas venham, pequenas tartarugas no sapo tartaruga nas
tartarugas Então, vamos ter 290. Nós pulamos aqui. Agora vamos para a zona em que
devemos pular para 340. Subimos para 350 nessa porque também nos movemos ao
mesmo tempo, lembramos que
conquistamos nossos dez pontos. Faça esse sapo ou trabalhe dessa maneira. Na verdade, já faz muito
tempo que não foi lançado, então não tenho 100% de certeza disso. Se for esse o caso,
para resolver esse problema, é
claro que podemos simplesmente adicionar 40 e, em seguida, contaremos isso mais dez a partir do nosso salto até lá. Se fôssemos em frente
e entrássemos nisso, agora pareceria mais
50, e, como eu disse, não tenho certeza se isso
conta aquele salto real ou no jogo real. Talvez seja algo
que possamos dar uma olhada. Talvez você possa simplesmente
deixar isso para a escolha
pessoal de
permitir
ou não que isso
conte efetivamente que Froggy morreu. Disse que parece que tenho um
Brad Frog, aqui está. Parece que pegou
um pequeno inseto pulando em um lugar estranho Agora meu pequeno vestido está bem. Isso nos coloca às 05:50, então este próximo trabalho nos
colocará às 600 Aí está. Depende de você se você quer
fazer 40 ou 50 aqui. que basicamente se resume a
se você quer ou não contar isso como principal, conte esses dez como
sua coisa principal. E eu só lembro que provavelmente
deveríamos colocar cinco sapos lá para
realmente testar isso Talvez vá em
frente e avance rapidamente no vídeo aqui nesta parte para
que possamos incluir cinco. Tudo bem, eu
passei por isso e fiz meu ciclo várias vezes, cinco drogas, e continuei, obtivemos até 4.800 pontos Incrível. Parece estar
funcionando perfeitamente bem. Nosso sistema de pontuação funciona. Recebemos nossos mais 40 ou 50, dependendo de como você enviou, se você vai ou
não
contar a etapa extra como parte de seus 50 ou se você
deseja fazer um adicional de 50. Além disso, temos
nossos dez pontos por etapa. Aqui temos nossos mais 1.000 toda vez que
obtemos cinco sapos múltiplos Toda vez que resgatamos
cinco desses
sapos, tudo o que temos é configurado. Acho que, a seguir, podemos
dar uma olhada em como
exibir isso e
começar a exibir nosso heads-up. Hugo está pronto.
14. Pontuação de jogo HUD: Tudo bem, vamos
começar a criar o capuz do
nosso jogo hoje. Vamos seguir
em frente e colocar a pontuação aqui na nossa tela. Para isso,
fui ao meu No TD e adicionei uma camada de tela. Se eu entrar aqui, camada de
tela é o que
estamos procurando, não a camada de tela cultivada será
basicamente
tudo o que está no topo do nosso jogo, não
importa onde esteja em nossa cena. Então, como você
imagina, é onde vão todos os seus elementos
quentes. Se você estiver jogando,
digamos, Dark Soles, é
aqui que seus quatro quadrantes
estão no canto inferior esquerdo Por exemplo, se você estiver
jogando Sky Rim, suas três barras de vida,
resistência e mana, W estará na
parte inferior e assim por diante Para nós, basta fazer a partitura
aqui na minha camada Canvas que eu renomeei para Guy I Stanford Graphical
User Interface Fui em frente e
adicionei dois rótulos, dois rótulos apenas normais aqui. E eu o chamei de rótulo de pontuação, só tem a palavra
pontuação e o texto da
pontuação que tem
apenas cinco zeros Agora, o texto de
ambos era grande demais
para este projeto. Em ambos, fui até o inspetor
até o tema
substituir o tamanho do título. Minha tecnologia de pontuação está no tamanho dez e a
etiqueta de pontuação está no tamanho 12. Agora você pode notar
que eu tenho uma barra
preta extra na parte inferior. Entrei nas configurações do projeto
e, na janela de exibição, atualizei a altura da
minha janela de visualização, 240-256 Aí Você pode ver isso lá. Então, adicionei 16 pixels extras
para poder adicionar o preto na parte inferior, porque é
aí que nossa barra de saúde vai
acabar ficando, ou nossa barra de vidas
no próximo vídeo. Tudo bem, uma vez que temos nossos dois rótulos aqui em nossa camada de
tela para a partitura, você não consegue descobrir onde
alterar o texto para
isso, basta selecionar seu rótulo
e dentro do inspetor na parte superior você verá a
seção de texto, digite a pontuação para um e coloque cinco zeros para o outro Isso nos dará uma boa ideia da quantidade de espaço que
precisaremos. Tudo bem, agora para
fazer isso funcionar, tudo o que precisamos fazer
é adicionar uma linha ao nosso script global aqui, fora do nosso e do
nosso bloco L S. Fora desses dois. Independentemente da
quantidade de pontos que adicionamos, precisamos obter nosso rótulo de texto de
pontuação. Defina o texto para realmente mostrar nossa escola, já que estamos
vindo de nosso script global. Se eu seguir em frente e executar isso por um momento e
depois apenas postular, mude para o remoto
global aqui Ele não tem
acesso a nada. Na verdade, temos que
subir na árvore uma vez para criar raízes e depois
descer até nossos dois D e
depois descer até nosso
pegajoso depois descer até nosso
pegajoso Então, a partir daí, podemos pegar texto da
nossa pontuação, já que temos que subir e depois descer, podemos
seguir em frente e obter o nó. E lembre-se, isso usa
uma string como argumento. E como você pode ver, poderíamos simplesmente escrever todo o caminho apenas Roth, dois D neste caso Mas mesmo assim, como
só subimos até um nível, ainda
é mais rápido se
fizermos dois pontos
apenas para subir um e depois descermos ao nosso nó dois D. De lá
acessamos nosso Y, obtemos nosso texto de pontuação,
se você estiver se perguntando Estamos apenas seguindo
essa linha branca partir da nossa página global aqui, onde
estamos escrevendo esse código. Temos nossos dois pontos, que é o mesmo que
escrever para os pais Então subimos um até a raiz. Então, estamos apenas
seguindo todas as paradas
com essa linha branca. Vemos que essa
linha branca desce e depois entra em pontos. Não há dois D, é aí que
escrevemos lá. Seguimos a linha novamente, paramos e apontamos para o Y. Escrevemos isso para a próxima parada Em seguida, descemos e
ela finalmente aponta para o texto da nossa pontuação.
E terminamos aí. Sempre que você estiver em
delts,
clique no nó
que você está procurando Basta seguir essa linha
branca para obter seu caminho no texto da pontuação. Certo, neste objeto do tipo rótulo, teremos acesso
à propriedade de texto dele. Deixe-me tirar o jogo
da sua tela. Eu apenas olhei e
vi que estava coberto. Novamente, usamos dois pontos.
O mesmo que ter um pai. Isso nos leva
até o nó raiz e seguimos
essas linhas brancas, descendo os
pontos no nó dois. D desce pontos, depois se reduz a
pontos no texto da pontuação. E estamos apenas seguindo esse
caminho aqui até o fim. Queremos a propriedade de texto dela e vamos defini-la. Vamos
ajustá-lo à nossa pontuação. No entanto, se fizermos isso, todos esses zeros
desaparecerão Como você vê, não podemos realmente fazer muito com a partitura
nesse aspecto, o que vamos fazer é transformá-la em uma string com STR e seguida, dois parênteses.
Podemos escrever nossa partitura Essa pontuação agora será tratada como uma string
em vez de um número inteiro Agora podemos fazer pad, e podemos preenchê-lo com zeros Passamos o número cinco. Teremos cinco dígitos,
como vemos aqui, 12345. Então, vamos
ter esses 50 slots. Nossa pontuação vai mudar, mas mesmo
que diga apenas dez, ainda
teremos
todos esses cinco slots disponíveis visualmente. Vai ficar exatamente
como seria em um fliperama. E em um sistema de pontuação típico. Se continuarmos jogando agora, podemos ver nossa
pontuação no topo. Se
aparecermos, veremos nossa pontuação
aumentando como deveria. Há muitos carros lá em cima. Lá vamos nós. Vamos acompanhar
isso por muito tempo. Aqui vamos nós. Vamos pegar
alguns pontos. Monte no tronco, monte nas
tartarugas, monte no tronco. E podemos montar nas tartarugas, montar no tronco e pular para casa livres Tudo bem, então nosso sistema de pontuação parece estar funcionando
perfeitamente bem. Está sendo exibido com precisão. É fantástico. Tudo bem, a última coisa que
devemos fazer neste momento é, bem, neste vídeo, nada. Mas no próximo vídeo,
vamos seguir em frente e
configurar nossas vidas para que, quando
morrermos, percamos uma vida. E isso será
refletido visualmente na tela, mostrando quantas
vidas ainda temos.
15. Jogo HUD vive: Tudo bem, vamos continuar
e adicionar nossas vidas agora. Nossas vidas terão no máximo
seis vidas aqui. E vamos entrar em
nossa camada de tela pegajosa. Vamos adicionar um novo nó, eu sei que não está visível. Apenas 2 segundos. Aí está. Vamos pesquisar
a palavra textura. Estamos procurando a barra de
progresso da textura. Tudo bem. Vou renomear o
meu para o bar Lives. Vou passar
para a seção Texturas no inspetor
para ver o Vou passar pela barra de
saúde e entrar naquele espaço. Defina o valor máximo novamente
no inspetor para seis. Vou definir meu valor
atual para seis. Agora você deve vê-los. Vou pegar essa
pequena alça laranja e puxá-la para cima para que ela ocupe
apenas o espaço que precisamos. Vou
trazê-lo direto para
o fundo, para aquele espaço
vazio e preto. Essas vão
funcionar como nossas vidas. Você verá que, à medida que
ajustamos os valores 6 a 5, eles são divididos uniformemente, para que possamos determinar facilmente
quantas vidas ainda temos O seis,
é claro, será nosso padrão e
precisaremos ajustá-lo toda vez
que realmente
morrermos no meu mundo aqui Novamente, talvez um nome de gerente de jogo fizesse mais
sentido,
mas, por enquanto, vai
ficar assim. Vamos
viver, por padrão, seis. Vou criar
outra função, Update Lives, Nothing. E vamos seguir o
caminho salvo. Em vez de um texto de pontuação, vamos levar vidas distantes e acessar
a propriedade de valor aqui que
podemos ver no inspetor Vamos dizer
mais uma quantidade igual. A quantidade será um
parâmetro que
passaremos que
terminará quando perdermos uma vida, adicionaremos
menos um a ela, que fará com que
caia para cinco. Isso também nos dá a
capacidade de adicionar vidas no futuro, apenas colocando uma vida
positiva para ganhar uma vida. Mas também atualizando que
, na verdade, também precisamos atualizar
nossas vidas. A mesma coisa mais é
igual à quantidade. Agora podemos ir até nosso jogador, podemos procurar nossa morte. Aí está a morte. Também precisamos acessar
nosso script global. Atualize vidas e transmita uma
negativa. Isso deve bastar. coisa muito simples e pequena de se
fazer Agora, quando
morremos na tela, devemos perder uma vida e ver nossa
barra de vida lá embaixo, cair para cinco. Preciso levantar isso porque vocês não conseguem ver o
fundo. Aí está. Vamos ver se
diminuímos para cinco. Pronto, nos separamos. Eu corri para a traseira daquele carro. Eu estava vendo,
e você só ganha pontos quando
avança no Frogger Também perdemos uma vida quando
entramos na água. Podemos prosseguir e
atualizar isso, se você desejar. Se você quiser que seja um
pouco mais preciso. Só vamos
atualizar a pontuação quando
pressionamos para a esquerda e para a direita,
não nos valerá nenhum ponto. A única pressão para frente será, o
que faz sentido,
porque são muitos pontos que
você pode ganhar rapidamente. Onde estão meus registros? Lá estão eles, agora
montamos as tartarugas. Destruição para a tartaruga. Eu ia pegar o tronco, mas senti que
ia perdê-lo, então fiquei pulando
no tronco aqui, e depois pularemos sobre
aquelas tartarugas e
voltaremos para casa livres.
Neste tronco, estamos Tudo bem, incrível. Lá vamos nós de novo.
Podemos perder o elevador. Legal. Nosso sistema ao vivo funciona. Ele é atualizado visualmente na tela. Temos a capacidade de adicionar vidas
no futuro. Tudo bem, acho que isso
bastará para esta seção. A menos que queiramos adicionar ao vivo quando
começarmos a estudar, queremos fazer isso. Tudo bem. Se você quiser ganhar vidas
extras ao atingir
uma determinada quantidade de pontos, aqui está
o que vamos fazer. Vamos criar
uma variável chamada multiplicador dentro da
nossa pontuação de atualização Vamos fazer
uma nova verificação aqui. Vamos dizer pontuação dividida
pela pontuação dividida por, podemos dizer 10.000 se você quiser, vezes nosso multiplicador é
maior ou igual a um, então é aqui que
vamos adicionar às nossas vidas Então, precisaríamos viver vidas, normalmente
diríamos que mais é igual Mas como queremos limitar
a seis, o que realmente vamos
fazer é dizer que vidas são iguais. E vamos usar essa
função chamada clamp. Agora, o grampo permite que você
tenha três argumentos aqui. O primeiro argumento é o que você adicionaria em vez
de mais é igual Nosso primeiro
argumento aqui será um. Então, o próximo argumento
será o mínimo e o máximo de que esse valor pode ser o mínimo
, pode ser zero. Nossas vidas nunca
ficarão abaixo de zero. Aqui, o número máximo
que podemos ter é seis, então nunca será um número
maior que seis. É assim que a fixação funciona aqui. Podemos chamar de
vida de atualização com uma, certo, então
teremos um mais
um para adicionar a
isso: na verdade, podemos simplesmente mover nossa pinça
até aqui dentro de
nossas vidas de atualização e
substituir uma por uma montagem Então provavelmente poderíamos
escapar sem ter
nada lá dentro,
sem configurá-lo. Vamos resumir Update vive em e. Então
vamos querer aumentar nosso
multiplicador mais igual a E a razão pela qual queremos fazer isso é porque, se não o
fizermos, ganharemos
uma vida constantemente porque nossa pontuação
sempre será divisível Uma vez que ganhamos uma vida,
toda vez que nos
mudamos, continuaremos ganhando
. Queremos mudar isso. Se obtivermos uma vida a
cada 10.000 pontos, obteremos
10.000 10.000 vezes uma
ainda será 10.000, então a próxima vez será 10.000 vezes dois, precisaremos de 20.000 pontos para
obter uma nova vida E então serão
30.040 etc. Se fôssemos correr
isso agora com apenas isso, podemos ver se
entramos, perdemos uma vida, talvez até perdemos duas. Agora temos que subir passar por todo esse tráfego. Temos que ir
até esse registro. Então, podemos montar o tronco
das tartarugas novamente, transferir para as tartarugas, esperar que o tronco chegue até aqui
e, se nossa pontuação
for alta o suficiente, devemos obter 10.000 que eu não alterei
agora que penso nisso Então, isso é um pouco
decepcionante, mas podemos verificar isso
rapidamente
entrando em nosso espaço eólico
e diremos , ei, ganhamos 20.000. Agora, se verificássemos para ganhar pontos a
cada 10.020,
não cada 10.020 Deveria
nos dar apenas uma vida, o que é bom porque você nunca
deveria ter 20.001 cães De qualquer forma, o máximo que você deve
obter de uma vez será 1.000. O que você vê à medida que avançamos, boom, estamos quase lá. Devemos ver nossas vidas na
base aumentarem, mais uma. Lá vamos nós. Então, nossas
vidas aumentaram. Tudo bem, então nossas
vidas agora estão funcionando. Vou
prosseguir e redefinir isso para 40 pontos. Queremos ter certeza de que
podemos acabar com o jogo. Isso vai ser. Acho que dentro de nossas vidas
globais de atualização aqui, vamos seguir
em frente e ver isso. Vamos usar
um negativo por acaso. Não, não será. Isso é perfeito. Não precisamos nos
preocupar com isso. Poderíamos dizer que se vivesse,
na verdade, já não precisaríamos , porque estamos
configurando isso aqui. Nós verificamos com antecedência. Então, dizemos que se vidas, é menor que zero, na verdade, já
seria zero. Digamos que temos zero vidas
restantes, então morremos, certo? Estamos ultrapassando outro
negativo. Estamos dizendo que se nossas
vidas já são zero, então vamos ter,
digamos, o fim do jogo, mas vamos apenas recarregar
a cena em um jogo totalmente novo Se nossas vidas
ainda não são zero, então vamos
vir até aqui e vamos
subtrair nossa vida Para isso, usamos apenas três moedas de recarga e isso será o mesmo que se
tivéssemos acabado de começar a cena Se escrevermos que nossas vidas não estão sendo reiniciadas, provavelmente porque
elas não são
reiniciadas no Global. Vamos descobrir. Vamos ver nossa versão de prontidão e dar uma olhada em
como depuramos isso,
digamos, vidas de impressão, e
veremos se isso é reiniciado Estamos sendo esmagados. Na verdade, nunca estamos
nos preparando de volta e ele se redefine
constantemente. Tudo bem, então em vez
de estar pronto, vamos imprimi-lo aqui. Tentando descobrir por que
estamos constantemente pontilhados aqui. Ele reinicia depois de duas, como vamos 6-0? Tudo Não sei por que, mas
a pinça parece
ser o que estava causando a quebra, porque
não há nenhuma razão real para que
eu pudesse dizer que ela
deveria ter saltado de seis vidas para se decompor para zero seis vidas para se decompor para Mas tudo bem. Acabei de
transformá-lo de volta em vidas mais uma quantidade igual agora, se rodarmos o jogo e
vermos se podemos
passar ou voltar a perder
vidas, uma de cada vez Quando reduzimos
três vidas para uma, aqui vamos para a água. Ficamos sem vida
quando somos atropelados. Em seguida, o jogo terminará e nosso
jogo será reiniciado. Pronto, temos
um reset do nosso jogo. Nós nos
deparamos rapidamente, podemos voltar a
perder vidas novamente, mas aí está.
Nós temos essa reinicialização. Agora perdemos vidas
e exibimos na
tela de forma adequada. Quando nossas vidas estão muito baixas, reiniciamos completamente o
jogo e começamos de novo, além de ganhar vidas toda
vez que recebemos 10.000 moedas.
16. Temporizador e bônus: Tudo bem, vamos fazer nosso Tim
Er falar agora com nosso cara. Acabei de adicionar outro
rótulo aqui embaixo com a palavra hora com uma substituição, tamanho
da fonte definido como 12 Em seguida, tenho uma barra de
progresso de textura, assim como fizemos
com nossas vidas aqui. Mudei o modo de preenchimento para direita para a esquerda em vez
da esquerda para a direita. Vou
renomeá-lo aqui, Tim bar. Meu valor máximo 30, meu valor atual 30. Todo
o resto permanece o mesmo. Apliquei nove
remendos para poder esticar essa barra
para ter o formato largura que eu quiser. E estou apenas usando o
cronômetro e, que tenho aqui, basta arrastá-lo como barra de progresso
da textura de
progresso Aí está. Eu apenas
estico e coloco lá embaixo para
algo que pareça bom. Eu também tenho um cronômetro
que adicionei aqui embaixo com um script no meu
cara e o sinal de tempo limite aqui conectado a ele Isso é o que estamos
vendo aqui. O que precisamos fazer toda vez,
dessa vez ou vezes, por padrão, o cronômetro está configurado para
1 segundo, o que é bom Isso é o que nós queremos. O que
queremos fazer se quisermos obter nosso tempo ou barra e precisarmos subtrair
um do valor, podemos simplesmente
pegá-lo com nosso cifrão. Aqui está, já que
isso vem do
nosso valor de cara menos é igual Agora, se fôssemos dar uma olhada e executar isso, agora
veríamos nosso
cronômetro passando Linda. Isso é
exatamente o que queremos. Agora temos que verificar. Precisamos verificar se nosso valor da barra do cronômetro atingiu zero Nesse caso, infelizmente, nosso
sapinho tem que morrer. É assim que acontece
quando nosso cronômetro acaba. Vamos
pegar nosso nó F. Lembre-se de que estamos aqui, então teremos que
subir um para nosso nodo, dois D depois voltar para o jogador. E vamos simplesmente chamar
nossa função de morte nela. Opa. E isso deve
ser dois iguais, porque é uma comparação
se quisermos executá-la Agora, quando nosso cronômetro acabar, nosso sapinho
deve simplesmente morrer
e perderemos uma vida em e perderemos uma vida Espere um minuto
para que o cronômetro acabe. Agora, com esse cronômetro
aqui em 30 segundos, vejo que minhas plataformas
no topo precisam ser um pouco mais rápidas ou, pelo menos,
um pouco menores de atraso Acho que a velocidade pode ser a melhor opção em vez de alterar o atraso.
Mas lá vamos nós. Um pequeno sapo morreu. E continua morrendo,
isso não é ótimo. Precisamos realmente redefinir isso. Agora, quando chegar a zero
e nosso sapo morrer, vamos reiniciar nossa barra de cronômetro Vamos pegar a barra do cronômetro e
ajustar seu valor de volta para 30. Podemos ter uma
nova barra preenchida. Agora, esse não é o único momento
em que ele precisa ser reiniciado, ele também precisa ser reiniciado quando
atingirmos a meta Vamos fazer com que o nó
suba um, fique pegajoso, depois pegue nossa barra de cronômetro
e ajuste o valor de volta para 30 Agora, antes de testar isso, vou entrar na
minha plataforma aqui. Vou mudar isso para
32 e dobrar essa velocidade. Isso significa que eu tenho que ir até o
meu player e ajustar isso. Bem, quando estamos aqui, 32 agora devem
pelo menos se mover mais rápido e espero que eu possa continuar sem
errar Aí estão as tartarugas. Precisamos de alguns registros. Obrigada Registro. Eu não
sei se vou sobreviver. Eu não vou sobreviver. Eu vou perder meu sapo. Adeus por um abraço. Eu mal sabia que você vê, isso vai ser
um pouco difícil. Nosso tempo é
reiniciado ou não quando brincamos? Isso não acontece, então
precisamos definir isso
também em nosso player. Onde é que morremos? Aí está nossa morte. E nós respondemos. Ok, sim, vamos nos
aprofundar aqui novamente. Vamos subir e
depois voltar para a barra do cronômetro e definir
o valor de volta para 30 Dessa forma, quando
morremos, isso reinicia. Acho que vou
mudar que respawn, o spawn da plataforma de
valor do gerador. Vou remover o mais seis. Veja como isso parece agora, já que
temos números completamente novos. Ok, está tudo bem. Talvez possamos
realmente fazer isso agora. Lá vamos nós.
Conseguimos reinicializar nosso cronômetro E quando morremos, nosso
cronômetro. Então, reinicie também. Fantástico. Eu posso ver que ainda preciso
de um pouco de impulso lá. mínimo, vou fazer 3 segundos só porque
vi uma grande sobreposição
quando passei por lá Mas vimos que o cronômetro está
funcionando perfeitamente bem agora. Agora você tem, ou pelo menos
deveria receber um bônus no que diz respeito aos pontos, com base em quanto tempo
resta para marcar. Vamos seguir em frente e
implementar isso também. Eu só tenho que me
reativar com o que é o multiplicador Eu sei que é algo vezes a quantidade de tempo que resta. Então me dê 1 segundo
lá. Tudo bem É dez vezes o tempo
restante que resta. Vamos ver quando chegarmos
ao nosso espaço eólico Antes de reiniciá-lo, precisamos atualizar a
pontuação aqui novamente. Vamos adicionar 40
, mas também vamos
adicionar o que sobrar aqui. Vamos dizer, na verdade, vamos colocar isso em sua
própria variável aqui. Chamamos isso de bônus de torta. Bônus de dez. Bônus de torta. Claro, quero enviá-lo para esse valor vezes dez
antes de reiniciarmos. Agora, em nossa segunda
pontuação de atualização, aqui damos bônus de tempo. Tudo bem, então agora devemos
ter nosso bônus de tempo lá. Então, quanto mais rápido
chegarmos lá, maior
será
o bônus que receberemos no máximo, mais 300 pontos. Hipoteticamente, quero dizer,
você não vai chegar lá aos 300 ou 30 segundos
restantes porque começa aos Talvez eu nem chegue lá. Pode estar perto. Eu entendi. Mas você pode ver que eu tenho
190 pontos nessa. Tudo bem, lá vamos nós. Temos o cronômetro lá, bem
como as mortes
quando o cronômetro acaba e o bônus de pontuação quando ainda temos tempo ou sobra e chegamos ao fim Tudo bem, então é isso. Acho que pode
ser isso. Ou sapo. Acho que não estou
esquecendo nada aqui. Se esse é o fim do sapo, parabéns por ter chegado
ao fim, isso é incrível Espero que vocês tenham aprendido muito. Analisamos muitas coisas
ao longo deste projeto. As variáveis estão funcionando com
muitos scripts diferentes, mas recriamos completamente
esse jogo dos anos 80 E o que é ótimo
nesses jogos antigos é
que eles têm um conceito bastante
simples,
mas especialmente se você é
novo em programação, há muito que você pode
aprender com esses jogos. Tudo bem Cuide-se. Tenha um
bom dia e nos
vemos na próxima semana O que? Estou entrando em uma semana agora. Oh cara, a quarta semana
vai ser divertida. Temos muitas coisas
para conversar lá.
17. Frogger Audio: Tudo, vamos seguir em frente
e adicionar o áudio primeiro. Então, isso vai contar
nossos saltos quando movemos a música de fundo
e nossos sons de morte Tudo bem para nossa música
de fundo. Podemos simplesmente entrar em
nossa cena principal aqui. Selecione nosso nó raiz, que é nosso nó dois D, vá em frente e pressione o
sinal de mais ou adicione um novo nó. E o que vamos
adicionar é esse reprodutor
de stream de áudio aqui. Em seguida, vamos
entrar em nossa pasta de sons, pegar as três músicas, arrastá-las para lá e garantir que
você ative a reprodução automática. Dessa forma, não precisamos desperdiçar um script e
escrever código para reproduzi-lo. Começará sozinho. Agora, aviso, isso pode estar
um pouco alto ao iniciar. Se você quiser ajustar o
áudio apenas para a música aqui, pode
alterar o volume. D, B aqui, quanto mais baixo você colocar, mais silencioso será zero é o padrão para todos eles. No entanto, se você
quiser diminuir a música de todo o áudio de uma vez, clique em uma pequena
guia de áudio na parte inferior, lá embaixo. E aqui está todo o
seu barramento de áudio. Temos o master aqui
, e se você
alterou as configurações de áudio e os jogos antes de perceber, temos o controle deslizante master.
Isso é o que está aqui. Podemos alterar o volume
disso para o que quisermos. Se quiser adicionar
um barramento de áudio diferente, você pode
personalizar os efeitos sonoros
da música separadamente. Podemos simplesmente pegar
o ônibus adicional aqui. Vamos apenas renomear isso para música. Agora, com nosso reprodutor de
streaming de áudio selecionado, você notará na
seção de ônibus aqui no inspetor Agora temos uma peça musical
aqui no menu suspenso. Essa música virá primeiro por meio dessa peça de áudio
e depois sairá e será enviada
para a masterização, como seria de esperar. Certo. Então, depende de você
o que você quer fazer. Vou seguir em frente
e baixar minha música para talvez 0,6. Não tenho certeza. Vou me
certificar de que vocês sejam realmente capazes de ouvir isso. Espero que isso não
machuque os ouvidos de ninguém. Vou clicar em
play e descobrir. Tudo bem. Parece que está mais
silencioso do que eu, então vou assumir
que está tudo bem Mas se você quiser, você
sempre pode baixá-lo um pouco mais. Acho que vou
escolher menos dez aqui. Agora, o resto do nosso som realmente
estará no nosso player. Porque nosso jogador tem, o jogador tem que
pular, nosso jogador A outra
necessidade de efeitos sonoros, nossa outra morte. O molho, o
mole e o calor. Vamos falar
com nossos jogadores. O mesmo. Também adicionaremos um reprodutor de streaming de áudio
para eles. Não vamos tocar em mais
nada, inspetor, a menos que você queira
adicionar um barramento de áudio para efeitos
sonoros e depois alterar
o barramento especificamente Isso depende de você e, novamente,
uma preferência pessoal. Mas depois de
adicionar um reprodutor de streaming de
áudio à cena do seu player, podemos acessar o script do
player. O que
precisaremos fazer é configurar o fluxo de áudio
carregando o arquivo de áudio
e, em seguida, reproduzi-lo. O que vou fazer
é ir primeiro à nossa função de morte, e isso vai ter
uma identificação passada para ela. Obviamente, D será um número inteiro porque
obteremos dois ou três Então, vou chamar um
int e vou
defini-lo igual a dois por padrão. A razão pela qual estou usando
dois é que, se voltarmos ao nosso mapa de blocos e dermos uma
olhada nele, nosso caminho é o ID dois. Por padrão, deve ser nosso
caminho. Deveria ser um pouco apertado O que vou fazer
aqui é colocar nosso reprodutor de fluxo de áudio, o stream do reprodutor fluxo de
áudio em toda essa propriedade de fluxo. Você está no nosso player,
certo, aquela transmissão aqui. E vamos
defini-lo igual a, e vamos chamar a carga de
parênteses abertos e fechados E dentro daqui, o
caminho
para o nosso arquivo dois será nosso padrão, esse será nosso squish Então, eu vou comer
abóbora, abóbora. Saia da nossa
pasta Sons e arraste-a até lá. Dessa forma, eu não
preciso escrever isso. Agora, o que faremos é,
na próxima linha, dizer que se ID for igual a 33, lembre-se de ser nossa água. Se estivermos morrendo e
estiver na água, faremos
a mesma coisa que fizemos
na linha anterior
e definiremos nosso riacho. E carregue um novo arquivo,
desta vez, um conjunto de squash. Vamos carregar em pedaços. Além
dessa declaração if, tudo o que vamos fazer
é reproduzir nossa transmissão. Então, vamos
dizer que o
reprodutor de stream de áudio é reproduzido, sem mais nem menos. Agora, se seguirmos em frente e nos colocarmos na estrada, devemos ter um E se formos pular na
água, devemos ter outro. Ok, por enquanto, vou
desligar a reprodução automática da
música para que possamos ouvir Se pularmos na
água, atropelamos o carro. Ok, temos o mesmo
áudio tocando em ambos. Bem, isso é um
pouco interessante. Por que isso? Bem, aparentemente não
estamos passando nenhuma identificação para três. Nunca
serão três. A razão para isso,
lembre-se de que temos que
descer e verificar, vender a identidade. Na verdade, estamos verificando
se nosso sapo está se afogando, é
isso que temos que
passar para nossa morte Agora, não deu erro
porque dissemos que, se não
passássemos nada para ele, costumávamos passar nada para ele, mas como queremos
especificamente um ID de três, sempre que estivermos na
água, precisamos nos
certificar de passá-lo aqui em nossa função de verificação de ID da célula. Agora, se fôssemos fazer isso,
deveríamos ter nosso lixo
na água e
esmagado Lá vamos nós. Sabemos se isso está
funcionando perfeitamente bem. Agora, a única coisa que
nos resta é fazer nossas compras. Para isso, isso
será apenas uma parte importante do nosso movimento, onde
podemos verificar
nosso fluxo de áudio e definir que o fluxo reprodutor
de fluxo de
áudio é igual E corre o risco de pegar nosso efeito
sonoro e
arrastá-lo até lá. Na próxima linha,
podemos simplesmente reproduzir
nosso reprodutor de
streaming de áudio. Podemos copiar isso em
cada botão pressionado aqui. Se estiver inativo, podemos fazer isso. Boom, sobrou. E se for agora, se jogarmos, devemos
ser capazes de pular. Vamos entrar em nossa
cena principal e tentar que a água seja empurrada para baixo ,
bem como a água subterrânea,
para baixo, para baixo, para baixo, para
baixo, para baixo, para baixo. Incrível. Agora, tudo o que precisamos
fazer é ligar novamente a música em nosso
reprodutor de streaming
de áudio da cena principal , o
Autoplay, ligado desse jeito Temos o
jogo Frogger completo com nosso áudio e Eu fui atropelado pela traseira do
carro lá. Mas aí está. Adicionamos som a ele e agora nosso jogo parece
muito mais completo. Não há nada mais
que possamos realmente fazer aqui. Você pode se sentir à vontade para
adicionar mais informações. Você pode tentar adicionar captadores. Você pode encontrar novos sons
e substituí-los. Talvez, se você quiser criar seus próprios sprites e
usá-los para alterá-los um pouco, seja um pouco mais
personalizado para você Ou se você quiser mantê-lo
como seu próprio pequeno
remake de arcade, isso também é incrível Mas isso bastará para este. Cuide-se e tenha um bom pacote
na parte Concluímos Frogger. Na próxima semana, acho que
começaremos a falar sobre algumas
das diferenças e
semelhanças entre dois D e três D e
começaremos a abordar isso