Bem-vindo de volta, meus colegas desenvolvedores de jogos.
Este vídeo será um pouco mais longo porque essa é
uma das vezes que eu
realmente não tinha certeza do que vamos fazer.
Então, eu não tinha certeza se queria tornar
isso um gatilho ou queria fazer disso um objeto sólido.
Mas de qualquer forma, quando passamos por
isso, mas nada acontece,
mas se passarmos por isso,
você pode ver que podemos quebrá-lo. Quão legal é isso?
E ele desaparece sozinho depois de alguns segundos.
Então, não vamos perder mais tempo.
Certifique-se de colocar sua concentração SCAP.
Tenho pequenos erros
e algumas hesitações durante isso,
mas não se preocupe, expliquei
tudo o máximo possível.
Então, vamos começar.
Oh, ok, então agora é
hora de adicionar alguns objetos quebráveis.
Este é o ponto inteiro da seção.
Estamos no segundo vídeo e ainda não adicionamos
nada para destruir.
Então, vou entrar em meus sprites aqui.
E vou fazer isso um pouco maior.
Neste caminho. Acho que podemos até
fazer com que esses ícones sejam um pouco menores, então eles se encaixam bem.
Lá vamos nós. Então, vou
clicar com o botão direito do mouse em criar uma nova pasta,
e esses serão os objetos quebráveis.
Objetos quebráveis,
e é por isso que sempre criamos pastas.
Imagine se tivéssemos todos
os sprites completamente em uma única pasta,
teria sido um pesadelo.
De qualquer forma, entraremos nos recursos,
como você pode ver aqui,
temos muitos bots para destruir.
Vou escolher o caminho certo.
Vou escolher o objeto quebrável branco.
Lá vamos nós.
De repente entramos aqui.
E podemos ir em frente e dissecar isso.
Então, vou me certificar de que é múltiplo.
E eu vou fazer isso pode estar fora
da tela e vou avisá-lo quando eu terminar.
Certo.
Então, bem-vindo de volta.
Deixe-me dizer o que eu fiz.
Eu não queria te aborrecer com
todos os detalhes, então tudo o que fiz,
cortei 32 por 32 a caixa branca.
Temos três partes diferentes aqui e
três intervalos diferentes são usados.
O W1, W2 e W3 para descrever a maior quebra pop.
E eu me certifico de que temos
essas pequenas três peças aqui.
Eles serão úteis mais tarde.
Então, vou descartar quaisquer alterações.
Também criei uma animação para as partes de bicicleta.
Então lá vai você, você pode ver isso se separar.
Vamos nos certificar a partir de
agora que vamos para o quebrável.
Então você pode ver o branco comprado quebrando,
certifique-se de que ele não faça loop.
Vamos salvar tudo isso.
Agora o pote de travagem,
vou adicionar um ano
Box Collider ou uma circular mais não,
não uma tela. Remova o componente.
Vou adicionar um colisor de caixa.
Então box collider 2D.
Lá vamos contornar isso,
vou torná-lo um pouco menor.
Eu faço o tamanho do pixel no sprite.
Deixe-me mostrar o que eu fiz também.
Então você não fica confuso.
Você pode ver que o pote é
em torno de um bom tamanho para o jogador.
Vamos mantê-lo assim.
E o que podemos fazer é ir em frente e fazê-lo,
bem, isso dependerá de você.
Você quer que seu objeto seja capaz de querer
que possamos colidir com esse objeto,
ou queremos apenas torná-lo um gatilho.
Vou mantê-lo um gatilho por enquanto,
mais tarde, se você quiser mudar isso,
se você quiser ter interações com os potes,
você quer que eles o impeçam de andar por eles.
Do que eu recomendo que você o torne não gatilho.
Saiba o que, vamos mantê-lo como um não-gatilho.
E por esse motivo vamos adicionar
um corpo rígido a ele e vamos torná-lo estático.
Certo?
Portanto, é uma estática. Ele não se move,
mas podemos quebrá-lo.
Então, o que mais deveríamos estar fazendo aqui?
Bem, acho que é isso. Por enquanto.
Vamos salvar isso e vamos
em frente e adicionar um script a ele,
que será chamado de touros de separação.
Então, nos scripts,
porque queremos adicionar comportamento obviamente
ao local que queríamos quebrar.
Vamos lá, ok, então vamos ver a interface do jogador dos inimigos,
e vamos seguir em frente e criar uma pasta aqui.
E vamos fazer isso para o quebrável.
Break bubbles abre o botão direito do mouse Criar provavelmente
não terá um script diferente
ou outro script, ok, então quebrável.
Mas o bom de criar uma pasta e definir
apenas um script aqui
que podemos vê-la de fora.
Então, e os scripts aqui,
podemos ir em frente e verificar o
quebrável para que possamos encontrá-lo imediatamente.
Vou adicionar à parte de frenagem. Lá vamos nós.
Temos as bolhas de ruptura.
Vamos abrir isso aqui.
E o que vamos fazer?
Bem, porque não estamos usando um gatilho,
vamos usar algo chamado “
on collision enter”.
Então lá você pode ver na colisão é quando
o corpo coliders menos rígido começou
tocar em outro colisor ou corpo rígido,
e vamos nos certificar de que é 2D.
Então aqui você pode ver que, em vez de outros,
temos a colisão.
Então, o que vamos fazer é verificar se a
tag collision.com,
ela tem comparado tag? Não, não acontece.
Etiqueta.
Ou podemos acessar a tag collider.com.
Lá vamos nós. Então agora temos
o colisor da colisão.
E verificaremos se é o jogador.
E se for, então vamos destruir
o objeto do jogo.
Com licença, o objeto do jogo.
Salve isso.
E também entraremos aqui,
verificaremos o animador
e veremos que tipo de gatilho ele faz.
Então, precisaremos criar um ídolo aqui.
Então, entraremos nas animações de ativos.
Ou é, onde está?
Onde está isso? Quebrável?
Parte branca, ociosa.
Isso significa que não está se movendo
porque obviamente você pode ver que não queremos
tê-lo
quebrando assim que começarmos o jogo,
queremos mantê-lo assim.
Então, o que podemos fazer é clicar com o botão direito do mouse aqui
e definir isso como o estado padrão. Então lá vai você.
E vamos adicionar isso aqui.
Crie uma transição que terá algum tipo de gatilho,
que é a quebra,
Scott break para simplicidade,
sem tempo de saída, duração de transição 0.
E eu vou seguir em frente e fazer isso como o intervalo.
Então vamos voltar aqui.
Nós vamos,
porque isso é, isso não será muito complicado.
Vou pegar o animador imediatamente.
Então aqui vou dizer se a colisão
como jogador antes de destruirmos ou, na verdade,
você sabe, nós vamos remover isso.
Vou seguir em frente e pegar
o componente, o animador.
E no gatilho tor dot set e vai ser o ancinho.
E sei que é uma referência de string e não a copiei, mas
espero que a quebra seja fácil de entender.
E então vou criar um vazio público.
Destrua.
Bem, não, destrua.
Apenas, vamos chamar isso de destrói.
E talvez queiramos adicionar algum tipo de
frio para não queremos que o pote seja destruído.
Então deixe-me dizer o que estou procurando aqui para fazer.
O que sem uma corrotina,
simplesmente destrua o objeto do jogo.
O que eu queria dizer, eu queria
usar uma co-rotina para atrasar
o desaparecimento das pequenas peças aqui.
Mas, por outro lado, achei que poderia ser ainda melhor
apenas definir isso aqui, ligar para
o evento depois de talvez alguns segundos,
ou podemos escolher talvez no segundo três, vá,
marcar o evento.
Qual é a função? Destrua, salve isso, execute o jogo.
Então agora devemos ver que assim que
colidirmos com o pote,
ele é destruído.
E lá vamos nós,
o objeto desapareceu.
E o que também podemos fazer é, por exemplo,
ir na animação da parte de
frenagem e da animação.
Então, assim que o pote quebra,
digamos que ele se quebre aqui.
O que podemos fazer, podemos começar a gravar
e depois desligar o colisor de caixa.
Então você verá que agora a caixa está boa quando você
vê o pote completamente e quando ele quebra, lá vamos nós.
Não há mais colisor.
E se olharmos de perto,
podemos escolher o colisor e talvez movê-lo um pouco
antes que ele realmente quebre.
Então, parece que passamos por isso.
Então, salve isso. Execute o jogo. Oh, não. Fale.
Não.
Não é assim.
Desculpe.
Oh, então ele gravar Esqueci
de pressionar o botão direito. Nós executamos o jogo.
Nós tínhamos o pote.
Lá vai você nos intervalos.
Então parece realmente como se passássemos
por ele e você pode ver o pop desaparecendo.
Certo, ótimo.
Então, o que isso fez,
o que precisamos fazer é
ter certeza de que esse pote quebre,
não quando estamos apenas andando por ele,
queremos que ele quebre quando realmente atravessamos ele.
E acho que isso vai ser um desafio para você.
E seu desafio será retornar
um valor booleano.
O que eu senti que era quebrar quando estamos executando,
bem, quando estamos arrojados,
queremos criar
um método int player controller que
possamos acessar a partir do intervalo que vamos roteiro.
Por que isso?
Bem, precisaremos criar um método que
retorne um bool em vez de um vazio.
E esse método deve retornar
verdadeiro se formos arrojados e falsos,
se não formos e falsos se não,
não, isso não é w, é íngreme.
Por isso, precisaremos usar os jogadores,
a velocidade ou a velocidade de movimento do jogador
ou o que você quiser usar.
Então, por que estamos criando esse valor de retorno?
Porque nas bolhas de intervalo,
queremos ter certeza de que o jogador está realmente arrojado.
Então, vamos adicionar à
condição na colisão on enter.
Queremos ter certeza de que não é apenas a camada.
Queremos ter certeza de que é o jogador
arrojado que acabou de bater em nosso pote.
Assim, essas informações criam
o método que retornará um valor booleano.
Pause o vídeo agora mesmo.
Vá fazer o desafio. Vá fazer o seu melhor.
Sei que não fizemos esse tipo de
método que retorna algo diferente do vazio.
Mas eu sei que você está pronto para tentar fazer o seu melhor.
Certo, bem-vindo de volta.
Espero que isso não tenha sido muito difícil.
Vou entrar no controlador de camada.
Certo, então qual é o problema aqui?
Você pode dizer que, na verdade,
eu só quero acessar o movimento atual.
E posso saber imediatamente
qual é a velocidade do jogador.
Mas aqui você pode ver que
o movimento atual é privado.
Então, o que precisaremos fazer à medida que vamos
criar um método aqui.
E esse método vai ser
uma camada bool pública é arrojada.
E o que estamos fazendo aqui?
Vamos verificar se a
velocidade de movimento atual é igual à velocidade do traço.
Nós também poderíamos ter usado a vela,
mas eles podem traçar não é equivalente.
Onde está isso?
Onde estamos redefinindo o numerador.
Então ele pode correr não é
equivalente a quando a velocidade do movimento pára.
Assim, podemos traçar é apenas para esfriar o arrojado
enquanto a velocidade de movimento está
imediatamente relacionada ao comprimento tracejado.
Então, de volta aqui,
se a velocidade atual for igual à velocidade do traço,
vamos retornar verdadeiro.
Caso contrário, vamos retornar false.
E, a propósito, poderíamos ter
feito algo semelhante a isso,
que eu possa removê-los.
E como você pode ver, é muito mais limpo.
Por quê? Porque só temos uma linha de
código sob as instruções if e else.
Caso contrário, não poderíamos ter usado dessa maneira.
Agora temos isso como público.
Voltamos ao quebrável.
Vamos seguir em frente e
criar um booleano dentro do ano 4.
Destruímos o pote depois de verificarmos a colisão,
obviamente porque não queremos sempre saber
qual a velocidade do jogador
a menos que seja o jogador real colidiu, basta bater.
Então, vou seguir em frente e criar um bool.
E vai ser a camada é arrojada.
E será igual ao
componente get ponto do objeto do jogo de ponto de colisão.
Portanto, é um pouco diferente do que quando estamos usando um gatilho.
E aqui vamos simplesmente pegar
o controlador do jogador.
E vamos verificar se a
camada está arrojada, salve isso.
Então agora isso deve retornar verdadeiro ou falso.
E aqui vamos verificar se a camada está arrojada.
Então vamos iniciar a animação.
E quando a animação começa em
intervalos e destrua o objeto do jogo stick eventualmente.
Então, uma coisa que eu queria
mencionar aqui é que usamos o Collider.
Aqui usamos o objeto do jogo.
Poderíamos ter usado o objeto do jogo aqui, salvar isso,
e teria funcionado da mesma forma,
mas a colisão, você pode ver aqui,
retorna uma colisão.
Não tem o certo,
digamos que métodos que precisamos.
Então, se eu for, por exemplo,
e no outro lugar,
então saia de nível, por exemplo, aqui,
o collider 2D é diferente da colisão 2D.
Portanto, a colisão faz parte do
retorno detalhado à física.
Se olharmos na saída do nível,
o collider 2D realmente retorna os objetos do jogo
que possamos acessar imediatamente
a tag enquanto quando se trata da colisão,
é apenas um pouco diferente.
Eu recomendo que você passe pela documentação do Unity,
veja qual a diferença entre colision collider.
Essas são coisas pequenas,
mas saiba que estamos acessando
o objeto do jogo primeiro e depois usando o tack de comparação.
Com isso fora do caminho,
vamos salvar tudo isso.
Vamos voltar ao nosso jogo.
Vamos executar o jogo.
Vamos tentar quebrar a caminhada patois.
Ok, lá vai você. Portanto, não está quebrando.
E se eu tentasse correr,
opa, esqueci o traço inferior dos dois.
Se eu correr. Certo.
Também não está funcionando.
Por que isso?
Certo, então quebrou. Lá vai você.
Vamos tentar isso mais uma vez porque
há algo que foi um pouco lento.
E acredito que o problema é com o jogo.
Aguarde um segundo.
Então eu acho que quero mover isso,
a coisa que lida com o colisor.
Quero movê-lo para o começo.
Salve isso porque quero que o colisor
desapareça assim que começarmos a quebrar o dinheiro.
Então lá vamos nós.
Você pode ver agora que podemos simplesmente passar.
Agora, se você quiser adicionar um pouco mais,
talvez eu não saiba autenticidade
que queremos mantê-lo apenas um
pequeno segundo antes de irmos
em frente e quebrá-lo, é sua escolha.
Certifique-se de escolher o que quiser.
Deixe-me ver.
Ok, então se eu quiser me mover,
se você mover apenas o pote quebrável,
escolha a segunda linha.
Lá vai você e você pode ver que você pode movê-lo.
Então, salve isso.
Agora temos tudo funcionando.
Vamos tentar percorrer isso.
Não funcionará. Nós caminhamos por lá.
Não funciona com o traço através dele, ele quebra.
Ótimo.
Vamos e nos certificar de que encenamos tudo.
E no próximo vídeo,
queremos mostrar os pedaços quebrados do nosso pote.
Então, queremos ter algum tipo de peças que se espalham.
É por isso que eu criei e os sprites em
recebíveis aqui temos o P1, P2 e P3.
Estas são peças que
vão colocar em torno disso e elas
vão adicionar um pouco mais de uma sensação de potes quebrando.
Então, queremos ter peças voando
um pouco e depois desaparecem lentamente,
tornando as coisas um pouco mais autênticas,
um pouco menos rígidas.
Então, verei você.