Bem-vindo de volta meus colegas desenvolvedores de jogos
para outro vídeo muito longo.
Mas neste, vale a pena.
Como toda vez que somos atingidos, quebramos.
Podemos ver que temos esse item.
Nós não pegamos imediatamente,
mas depois de um certo tempo, não só isso,
mas agora quando devemos o inimigo e ele morre,
em algum momento, ele também cai e item.
E obviamente não corrigimos
a maneira como as camadas interagem umas com as outras.
Mas acho que porque esse vídeo foi muito longo,
não tivemos muito tempo.
Então, sem mais ou fazer Não vamos
perder mais tempo e vamos começar.
Oh, caso.
Então agora temos a coleta de saúde funcionando,
mas não muito divertida quando
você tem toda a saúde ao seu redor.
Você poderia fazer isso.
Você pode simplesmente definir
algumas captações de saúde em seu mundo e
depois pegá-las assim que encontrar
certos quartos ou o que quer que seja.
Mas acho que é muito melhor quando você pode ter algum tipo
de mecânico que derruba
os itens e permite que você os pegue.
Então, por exemplo, se tivermos o quebrável aqui,
essas urnas, se as esmagarmos ou quebramos,
então teremos algum tipo de
coleta de saúde ou quando matarmos um determinado inimigo,
então também temos a coleta de saúde caiu.
Então, vamos fazer isso primeiro,
vou para os Prefabs, onde
temos o onde está?
Onde estão as armas,
balas, sangue, balas, inimigo.
Então, aparentemente, não temos nada.
Oh, você sabe o quê?
Vamos criar uma nova pasta para os captadores.
E então vamos deixar a coleta de saúde lá dentro.
Ótimo. Então agora temos isso.
A próxima coisa que queremos fazer é
entrar nos scripts.
Vamos encontrar as
captações e vamos criar
um novo script C-sharp será chamado de item drop.
Agora, por que estamos fazendo isso?
Primeiro de tudo, eu queria fechar isso por um segundo.
Então, o que eu queria fazer é adicionar imediatamente
esse código aqui na coleta de saúde ou quero dizer,
desculpe, no quebrável.
Onde eles estão? Acabamos de fechá-lo,
então eu queria adicioná-lo imediatamente ao quebrável.
Então, assim que quebramos,
obtemos um determinado item.
Mas então eu pensei,
se eu quisesse que alguns inimigos soltem itens que não seriam
muito eficientes
porque queremos várias coisas.
Talvez para soltar itens,
queremos ganhos diferentes,
talvez não apenas o quebrável,
talvez eu não saiba nada que derrube itens.
Achei que seria melhor apenas criar
um script que é o conta-gotas do item e adicioná-lo
a qualquer objeto que quisermos soltar um item
quando ele morrer ou matar ou o que quer que seja.
Ok, então vamos seguir em frente e fazer isso.
Primeira coisa.
Primeiro, vamos seguir em frente
e criar um campo serializado, que garantirá
que tenhamos a opção de verificar se ele derruba itens, seja ele ou ela ou o
verificar se ele derruba itens, seja ele
que quer que seja que ele solte itens.
A segunda variável que eu quero criar
é um campo serializado,
que é do tipo objeto de jogo.
E vamos torná-lo um array e serão os
itens muito soltos.
Agora você pode estar se perguntando, nós só temos
um item para soltar, que é a saúde.
Mas, mais tarde, criaremos uma moeda
e talvez até você queira criar
algum tipo de sistemas de nivelamento ou você soltar
algo que viaja como temos no Hades.
Então, itens para soltar,
nós o temos como uma matriz.
A próxima coisa que teremos como um campo serializado,
haverá do tipo float
e ele será chamado de
itens ou queda de item.
Chance.
E vamos defini-lo em 0,5.
Portanto, é uma chance 5050.
E por que queremos ter isso?
Bem, não queremos ter todos os
nossos quebráveis ou todos os
nossos inimigos soltando esses itens.
Então, queremos ter uma chance 5050 de conseguir um item.
Ótimo.
Então agora vou prosseguir
e remover o início e a atualização.
Nós os criaremos se precisarmos deles.
E vou criar um item vazio público.
E isso simplesmente seguirá em frente e
criará um inteiro aleatório.
E antes de tudo, vamos verificar
algumas condições.
Então, o primeiro será aleatório.
O valor do ponto é menor que a chance dos itens de cair.
E o que é o valor de ponto aleatório que passa o mouse sobre ele e
veja retorna um flutuador aleatório entre 0, um.
Então, se obtivermos, por exemplo,
ponto zero, pois é menor que 0,5, queremos instanciar.
Esta é uma ótima maneira de evitar que
o todo seja menor que um,
mais de 0,5 ou onde quer que isso
nos dê um valor aleatório entre 01.
Se for maior, instanciamos.
Se não for, então queremos.
Então, vamos seguir em frente
e criar um inteiro aleatório.
Então, número de item aleatório e será igual ao
intervalo de pontos aleatórios e ao intervalo.
E aqui teremos um intervalo
entre 0 e os itens a serem soltos.
Comprimento do ponto. Tão bem simples o que estamos fazendo aqui.
Já sabemos tudo isso
e depois vamos seguir em frente e
instanciar os itens para cair.
E vamos tê-lo como o número de item aleatório.
Vamos configurá-lo na posição do ponto de transformação e na
rotação da transformação.
Lá vamos nós.
Então, vou salvar isso.
Eu vou, oh,
e antes de fazermos isso,
também vou criar uma condição aqui
que esqueci completamente por algum motivo.
Vou me certificar de que, se derrubar itens,
vamos seguir em frente e fazer tudo isso.
E vamos apenas adicionar alguns
suportes encaracolados em torno dele para que seja melhor assim.
Não gosto de ter várias linhas sob
um único item de descarte.
Certo, ótimo. Então, com isso,
não salve isso de volta em nosso jogo.
E vamos para o pote quebrável.
E isso é fechá-los um pouco.
E então vamos adicionar um conta-gotas de itens aqui.
E como você pode ver,
há um problema.
Você pode ver que não temos
os campos desserializados e
você pode ver que há algo esperado aqui,
que é que não fechamos um dos,
ok, então lá vamos nós.
Agora salvamos isso.
Agora devemos ver aqui o grande.
Então eu derrubo itens,
itens em gotículas, apenas dou a coleta de saúde.
Vamos fechar isso ou o bloqueio
realmente entrar nos Prefabs.
Onde está, onde está coleta e coleta de saúde.
Então agora só temos a coleta de saúde.
E apenas para fins de teste,
vou definir os itens para diminuir a chance para 1.
Então, sempre soltamos um item, salvamos isso.
E agora a última coisa que queremos
ter certeza é que
em onde deveria estar nas bolhas de ruptura?
Se formos, Onde está?
Onde está enterrado?
2ls quebrável.
E aqui vamos
verificar depois de nos certificar de que nós,
Onde está, instanciamos o objeto.
Também queremos ir em frente e verificar se o conta-gotas do
componente e do item Get.
E vamos verificar e esperar que tenhamos
uma pequena coisa em massa aqui que
fará porque é um campo serializado,
vamos apenas criar um retorno.
Portanto, bool público é item,
item conta-gotas.
E vamos apenas voltar aqui,
Verdadeiro ou seja lá o que for, o item de gotas.
Então, isso retornará verdadeiro se ele soltar um item para que possamos
voltar e a palavra era, ok,
O ponto quebrável é o conta-gotas do item.
Para este conta-gotas de item,
uma vez que o jogador entra nele,
acionamos a quebra,
instanciamos as partes e
verificamos se ele é um conta-gotas de item,
então vamos acessar novamente
o dropper Obter item componente, item de soltar.
Lá vamos nós, salve isso.
E você sabe, eu estava pensando que talvez
essa afirmação aqui não seja tão necessária.
Então, o que vamos apenas removê-lo.
E agora me lembro por que esqueci,
porque não era necessário lá.
Então, de volta aqui,
salve que tudo esteja funcionando bem.
A única coisa que ainda me incomoda é
que se tentássemos pegar o componente,
mas ele não está lá,
então não o adicionamos a algum tipo de pote quebrável.
Talvez isso cause um problema se isso acontecer,
a melhor maneira de corrigir isso é criar
uma condição se extra,
uma camada extra aqui de proteção
se o conta-gotas Obter item de componente,
e é diferente do nulo,
isso significa que temos este item aqui.
Então podemos ir em frente e verificar o conta-gotas do item.
Portanto, isso nos dará uma camada extra de
proteção se não tivermos o conta-gotas do item componente,
se for igual a nulo,
então vamos verificar se não podemos soltar itens e,
em seguida, vamos realmente soltar um item.
Então salve isso de volta agora novamente, vamos ver.
Agora isso é como, Honestamente,
eu não gosto muito disso porque deveríamos
estar sabendo como estamos criando este jogo,
Bu, mas esse é o pior cenário.
Então execute o jogo.
E agora, quando tentamos quebrar uma parte,
deixe-me destruir.
E então, quando tentamos quebrar
a parte que você vê, lá vamos nós.
Nós o destruímos.
E você pode ver que nossa saúde simplesmente
passa de 500 para 510.
Mas há um problema.
Você viu isso?
Você viu o item ser descartado?
Não, você não fez, mas a saúde aumentou.
Então, qual é o problema?
Bem, o problema aqui é que é extremamente
rápido e não queremos que isso aconteça instantaneamente.
Na verdade, queremos ver o item que deixamos
cair antes de pegá-lo imediatamente.
Então, vou emitir isso para você como um desafio.
E seu desafio é atrasar o tempo
antes de podermos pegar um item.
Então, antes de tudo, crie um novo script.
Pegue a camada novamente.
Por que isso? Este é
um vídeo incrível de como você estrutura seu jogo.
Como pegar a camada,
isso nos permitirá atrasar
o tempo antes de retirarmos um item.
E não queremos adicionar esse atraso apenas para
o script de saúde e depois ter que copiá-lo
todas as vezes e para todas as moedas,
os power-ups e etc.
Então, o que vamos fazer é apenas criar um novo script de
pegar a camada e adicionar a
cada item que queremos pegar,
que é muito mais fácil e saudável quando se trata
desenvolvimento de jogos e design de jogos estrutura e assim por diante.
É por isso que criamos um novo script.
Em seguida, você criará um float
para o tempo antes de podermos pegar,
você precisa criar uma variável booleana que verifique
se podemos realmente pegar o item ou não.
Crie uma equipe principal que depois do tempo,
após um certo período de tempo, que é o, obviamente,
a variável flutuante
recriada aqui nos permite pegar o item.
E, finalmente, onde deveríamos estar?
Devemos chamar esse revestimento?
Onde deveríamos chamar a rotina escolar?
Então, obviamente,
bom que eu não sou bom em codificar porque sou
horrível na gramática e tudo o resto,
sabe, qual é o sentido da última frase?
Pause o vídeo agora mesmo e vá para o desafio.
Certo, bem-vindo de volta.
Então, uma coisa que eu queria fazer é
que eu quero entrar na coleta de saúde.
Não, não a coleta de saúde, a parte quebrável.
E vou aplicar
alterações a todas as outras partes, mas certifique-se de
que sempre que você adicionar um pote,
certifique-se de verificar se
ele solta um item ou não
e você tem que mudar a chance de queda de itens obviamente.
E elétron, é claro que estaremos mudando isso.
Portanto, sempre tenha isso em mente ao adicionar novos bots.
E então precisamos entrar no,
onde está a sala, os inimigos.
Temos alguns inimigos.
Vamos apenas verificar este e adicionar a ele conta-gotas de item.
Lá vamos nós.
Então ele solta um item.
Qual é o item que ele derruba?
Será por isso que sempre o trancamos.
Em seguida, adicionamos o item que o definiu como 11.
Devemos deixar cair um item?
Vamos para o controlador NMI aqui.
Onde ele morre?
Danifique o inimigo se a saúde for menor que 0,
instancie os objetos do jogo de palha.
Então, o splatter surdo.
Também verificaremos aqui se o componente, e agora?
Enquanto o quebrável, copiamos este.
E então nós apenas colamos aqui.
Portanto, esse é um código redundante.
Mas vou deixá-lo deslizar por causa de todas as
outras coisas eficientes que criamos.
Então, verificamos se temos um conta-gotas de itens,
então verificamos se ele é um conta-gotas e,
em seguida, vamos em frente e soltamos o item.
Então, vamos tentar testar isso
no esqueleto inimigo aplicará as mudanças.
Então agora todos os inimigos devem ter
o script para executar o jogo.
E eu sei que isso não era parte do desafio,
mas eu só quero testá-lo, então devemos as balas
finalmente ele morrer e podemos pegar
um item que veja se funciona.
Eu entendo.
Eu pego o item. Excelente.
Agora, a próxima coisa é atrasar,
que é o desafio real.
Então, vamos entrar no,
eu sei que foi uma nota paralela,
mas talvez você não
soubesse exatamente o que fazer neste
caso. Não se preocupe com isso.
Vamos para os scripts.
As captações, e clique com o botão direito do mouse aqui,
criam um novo script C Sharp,
que será o PEC.
Pegue, o grande,
, pegue a camada, pressione Enter.
Aguarde que isso seja compilado e clique duas vezes aqui.
Clique duas vezes aqui.
E vamos ver o que vamos fazer.
Primeiro de tudo, vamos criar
o campo serializado para o flutuador,
que é o momento antes da retirada.
E vamos defini-lo em cerca de 0,5 segundos.
Então, vamos criar um bool privado
que pode ser retirado.
Salve isso agora e comece.
Vamos nos certificar de que isso pode ser
pego como igual a false.
E então vamos criar o Coubertin E aqui,
que vai ser o enumerador dos olhos.
E vai ser chamado de pick-up, esfriar.
Sim, claro, pegue, esfrie.
E então aqui vamos ceder, retornar, novo.
Aguarde quatro segundos.
E eu tenho certeza que neste ponto, você sabe,
co-rotinas tão bem que você está entediado de
mim toda vez dizendo rendimento devolvê-lo por segundos de peso.
Você provavelmente está dizendo Michael,
já sabemos como fazer isso.
Por favor, pare.
Não.
Vamos aprender.
Ele tem Gantt ser pego é igual a verdade.
Salve isso.
E agora vamos entrar no conta-gotas do item.
E eu sinto muito, quero dizer, a coleta de saúde.
E aqui vamos
verificar se foi apanhado.
E também vamos verificar.
E se o componente Get,
o captado, a camada,
o que deve ser chamado?
Onde está?
Pode ser pego? Vamos prosseguir e devolver isso.
Então, booleano público, ele pode ser apanhado.
E nós só vamos voltar.
Pode ser coletado variável.
Certo, nome não muito criativo para este, mas funciona.
E aqui está algum tipo de problema que
definição de vetores de tipo pode ser captada.
Certo?
Assim, pode ser retirado.
Claro, digamos que tenha chamado um método.
Então eu acredito que seja só por causa do nome.
Portanto, você não pode nomear a variável assim como
nomeia o método desejado.
Então, vamos chamá-lo de método
porque temos a imaginação de
uma pequena mosca da fruta e, em seguida, podemos pegar método.
E isso deve fazer o truque.
Agora, a última coisa e a última parte
deste desafio foi onde chamamos de Colton?
Espero que você tenha pensado sobre isso e espero descobrir que
ele deve ser chamado imediatamente e começar.
Então, no início, começamos a co-rotina.
Isso pode ser, não, quero dizer, pegar,
esfriar,
pegar, esfriar. Lá vamos nós.
Então, por que e começar?
Porque estamos instanciando o item.
Assim que instanciamos o item,
ele tem a camada D de coleta,
iniciamos imediatamente o Colton.
Então, de volta ao nosso jogo.
Vamos ver aqui, a camada.
Pegue a camada.
Quantos, quanto tempo espera?
E vou aplicar as alterações a todos.
Então, agora, quando executamos o jogo,
devemos ver que assim que atingirmos as
bolhas de ruptura, lá vamos nós.
Acertamos os parafusos de freio.
Não pegamos imediatamente o item.
Vemos isso cair.
Lá vamos nós.
Sim. Você pode ver agora que ele ainda está lá.
Nós não pegamos, mas agora podemos,
vamos tentar algo diferente.
Vamos adicionar o atraso a
cerca de três segundos e ver se ele funciona.
Na vida real.
Vamos ser atingidos.
Vamos destruir isso e tentar pegá-lo.
Ok, então isso funcionou muito
rápido e estou me perguntando qual é o problema aqui.
Oh, ok, bem-vindo de volta.
Então, o maior erro que já foi cometido,
mudei essa coleta de saúde para 10,
mas o pré-fabricado real não mudou.
Então, vamos aplicar as alterações.
Eu queria saber que tudo está funcionando sem problemas,
mas por algum motivo isso não estava funcionando.
Então lá vamos nós com o esteróide e agora temos 10,
10 segundos antes de podermos realmente pegá-lo,
mas vamos configurá-lo para cerca de 0,5. Salve isso.
Espero que você goste.
Espero que você tenha gostado
todas as diferentes mecânicas
e pequenas coisas de ajuste
adicionar e remover e garantir
que possamos aplicar coisas diferentes, itens diferentes.
Então eu sei que este foi um vídeo longo.
Obrigado por sua atenção.
Obrigado por preparar todos os seus arquivos todas as
vezes e fazer
todo o progresso que você fez.
Agradeço também pela refutação,
incrível crítica que você me deixou
e eu te vejo no próximo vídeo.