Bem-vindo de volta, Meus desenvolvedores de jogos favoritos.
Neste vídeo, na verdade, começamos
a gerar inimigos de forma inteligente.
Então, agora, quando executamos o jogo,
vamos aumentar isso para que você possa
ver corretamente o que está acontecendo.
Depois que o candidato terminar,
o primeiro inimigo aparece,
o segundo inimigo aparece,
e eles ficam lá esperando que nós os matemos.
Então, uma vez que os matamos,
vamos tentar ir com eles.
Certo.
Na verdade, oh, ok, isso foi embaraçoso.
Vamos reiniciar o nível.
Espere por isso. Então,
tornamos os inimigos tão bons que não podemos matá-los.
Ok, então deixe-me tentar.
Deixe-me chegar a uma certa distância para que não possamos mais.
Então, uma vez que os chamamos, você pode ver
que temos a onda completa.
E, novamente, temos o inimigo surgindo porque fizemos
a quantidade de inimigos e aqui também para esta onda.
Então, não vamos perder mais tempo e vamos começar.
Oh, caso.
Então, vamos em frente e, na verdade, começamos a possuir inimigos.
A primeira coisa que vamos fazer é
obviamente criar aqui algum tipo
de co-rotina ou podemos criar também um contador.
Mas vamos ficar com
o Coubertin e esse cortejo será
chamado toda vez que tivermos esse atraso na geração.
Então, essa equipe principal estará gerando os inimigos.
De qualquer forma, vamos começar e veremos
como tudo está funcionando.
Então, vamos criar um enumerador de olhos aqui.
E vai ser chamado de onda de desova.
E a onda que queremos realmente gerar.
Então acene para detectar.
Então, já temos a onda que queremos abranger.
Ele terá seus próprios inimigos,
seu nome e a quantidade de inimigos que tem.
Então, vamos criar um loop for.
Neste loop for, vamos começar
com um número inteiro I igual a 0.
Vamos nos certificar
que nunca ultrapassamos o peso para gerar,
ou é a onda para gerar,
a quantidade de inimigos?
E também vamos aumentá-lo em um a
cada vez.
Então, aqui vamos criar um número inimigo aleatório.
E vai ser o alcance aleatório.
E esse intervalo será superior a 0.
E a onda para gerar o comprimento do ponto dos inimigos.
Então lá vamos nós e nos lembramos desses inimigos,
e aqui está uma variedade de objetos de jogo.
Então, queremos gastar um inimigo aleatório lá dentro.
Então eu vou aqui onde diremos
que algum tipo de método
para gerar porque queremos tê-lo
fora do, isso aqui mesmo.
Esta será apenas a onda de desova.
Este será o criador inimigo aqui.
E o que faremos,
e a forma como esse numerador funcionará
à medida que vamos dar retorno
novo, aguarde quatro segundos.
E vai estar na onda.
Responda. Não demora, atraso na geração de pontos.
Então, o que está acontecendo aqui?
Esta é a primeira vez que acredito que usamos
o retorno de rendimento
dentro de um loop for em um enumerador ou uma corrotina.
Então, passamos por esse loop.
Toda vez que escolhemos um número aleatório,
geramos algum tipo de inimigo,
e então esperamos quatro segundos.
E, novamente, geramos um inimigo, geramos um inimigo.
Então isso nos permitirá dar
retorno e chamar isso várias vezes,
essa onda gerada várias vezes.
E depois que fizermos isso,
também criaremos
o método real que gerará o inimigo.
Então gere o inimigo.
E aqui vamos dizer que enviaremos
objeto do jogo e o inimigo para gerar.
E aqui vamos dizer log de pontos de depuração apenas para
garantir que saibamos qual inimigo está
sendo gerado e tudo está funcionando corretamente.
Então, gerando o inimigo.
E vamos dar a ele o inimigo para gerar.
Mas o nome.
Lá vamos nós. E estamos simplesmente vindo para instanciar.
E então ela comeu o NMI. Muito pequeno.
E vai ser, opa, com licença.
Então, será toda a posição do ponto de transformação
e transformamos a estação de linha.
Então, qual é a transformação?
qual transformação estamos falando?
Então, como o gerador de ondas está ligado ao gerenciador
de níveis,
esta será a posição e a rotação do
objeto de jogo do gerenciador de níveis em nossa cena.
E mais tarde, estaremos criando
vários pontos nos quais os inimigos serão gerados.
Então, funcionará assim.
Teremos algum tipo de matriz.
Vamos lidar com isso mais tarde que agora está
focado em instanciar esses inimigos.
Então gere o inimigo, a onda para
gerar inimigos na posição do
número inimigo aleatório que acabamos de criar.
Então, vou adicionar uma entrada aqui. O que estamos fazendo?
Precisamos também chamar a corrotina e aqui,
então antes de esquecermos, então co-rotina.
Spawn, spawn, inimigos, onda.
Sim, lá vamos nós.
E de que maneira deveríamos estar gerando?
Enquanto aqui vamos dizer que é a onda,
ondas na posição próxima onda.
Então, provavelmente será
0 agora porque a próxima onda,
enquanto a próxima onda,
começa em 0 aqui.
Então, será a primeira onda
que é por apenas experimentar por enquanto,
que está focada no que isso faz.
Portanto, uma co-rotina que começa se nos
certivermos de que não estamos
gerando a contagem regressiva é menor que 0,
não estamos desova,
estamos prontos para começar a desova.
Então começamos o revestimento aqui, temos o loop que
percorre a quantidade de inimigos na
onda que recebemos.
Como uma corrotina, criamos um número aleatório.
Nós geramos um inimigo aleatório que só tem a depuração
para nos dizer qual inimigo está sendo gerado
provavelmente removerá isso mais tarde.
E então instanciamos o inimigo real no gerente.
E então o que acontece? Nós rendemos o retorno,
esperamos quatro segundos e depois surgimos em outro inimigo.
Então, antes que esse loop seja chamado novamente,
temos que pesar o atraso de desova
que é designado para nós.
Então, vou salvar tudo isso.
Vou voltar e unir.
E vamos ver o que temos aqui como gerente de níveis.
Espere que isso compile qualquer coisa.
Ok, então vamos ao
gerente de nível do gerente e o que temos aqui?
Eu estava brincando,
talvez eu não tenha feito isso no vídeo.
Então, temos essa onda aqui.
É a onda do esqueleto.
Os inimigos que temos aqui são
o inimigo esqueleto e o covarde voando alto.
A quantidade de inimigos que queremos é responder a
leigos será de dois segundos.
Vou salvar isso.
Onde está o gerente de níveis e o nosso mundo?
Não está no 000.
Vamos colocá-lo de volta em 0,
então está bem na frente do nosso jogador.
E vamos executar o jogo e ver como ele se parece.
Então agora 12, devemos ver a contagem regressiva das ondas.
Lá vamos nós e whoa,
são inimigos demais.
Vamos ver o que fizemos de errado aqui.
Então, salvamos isso.
O que está acontecendo aqui,
estamos verificando se a contagem regressiva é menor que 0.
Não estamos no estado de desova?
Bem, vamos ver.
Começamos com a contagem, então não estamos.
Então, obviamente, precisamos mudar nossos estados aqui.
Então, antes de criarmos o loop ou iniciar o loop,
vamos dizer que estamos em
um estado que é igual aos
Estados de desova, mas desova.
E então, quando terminarmos a desova,
vamos entrar em um estado,
que é a ponderação.
Então, estamos esperando que os inimigos sejam gerados.
Então, agora começamos antes de passarmos pelo loop,
dissemos o estado.
Então agora isso não será chamado toda vez
e não teremos tantos inimigos.
Vamos testar isso novamente.
Execute o jogo. Podemos ver a contagem regressiva aqui.
Eu o tornei público. Lá vamos nós.
Então 0, pegamos o inimigo e ele começa a atirar.
Então pegamos outro inimigo,
e depois demos outro inimigo,
e ele está sendo chamado a cada dois segundos.
Então olhe para esses pequenos cowers aqui.
Esta é uma mecânica de jogo muito legal, como você pode ver,
cada dois segundos, 1212, e lá vamos nós.
Então, como você pode ver,
os inimigos estão sendo chamados a cada segundo.
Mas agora você pode estar se perguntando,
por que temos tantos inimigos,
mesmo que tenhamos dito que a quantidade
de inimigos deve ser apenas também.
Bem. É porque aqui, na
verdade, não temos a contagem regressiva das ondas reiniciando.
Mais uma vez, algo com o qual lidaremos mais tarde.
Mas vamos antes de tudo pensar em quando vamos
realmente redefinir a onda e quando é que uma onda real?
E assim podemos criar um tempo entre a onda.
Então, digamos que a primeira onda e a segunda onda,
haja um atraso entre elas.
Ou podemos ter um mecânico muito legal e dar à
nossa camada ou à pessoa que está jogando nosso jogo
uma chance de ir em frente e matar todos os
inimigos nesta onda antes que a próxima onda apareça.
Então é isso que vamos fazer.
E para fazer isso, vamos criar
algum tipo de método
que acompanhará se um inimigo morreu ou não.
Então, vamos voltar aqui.
E depois do inimigo da geração,
vamos criar um privado.
Haverá um booleano,
e será o inimigo ou vivo.
E isso retornará verdade se
todos os inimigos estiverem vivos ou não.
Ah, sim, se todos os inimigos estiverem vivos e falsos,
se um deles ou nenhum deles estiver vivo.
Então, aqui o que vou dizer,
vou criar uma condição if.
E vou ter o objeto final do tipo.
E objetos do tipo realmente não encontram objetos,
encontram objetos do tipo.
E o controlador inimigo,
estarei procurando o comprimento do ponto do controlador inimigo.
E vai ser igual a 0.
E se for, então vamos retornar falso.
Tão falso, isso significa que todos os inimigos morreram.
E então, se passarmos por
este e não retornarmos falso,
então retornaremos verdadeiros.
Isso significa que os inimigos ainda estão vivos.
Então, agora temos uma onda
ou de garantir se nossos inimigos
foram todos esgotados e poderemos
usá-lo aqui como uma condição de alguma forma.
Mas há um pequeno problema que está me incomodando.
O achar objetos do tipo no
controlador inimigo é, na verdade, uma operação muito complicada,
digamos que no sistema.
É preciso muitos recursos toda
vez para passar por todos os objetos no
controlador inimigo, o
que às vezes não é muito necessário.
Então, o que queremos fazer é que queremos ter algum tipo
de temporizador nos inimigos estão vivos verificador.
Então, na verdade, não verificamos
cada quadro se todos os inimigos estão mortos.
Mas em vez disso, temos isso
sendo verificado a cada dois segundos.
Então, vou lançá-lo para você como um desafio,
e seu desafio é atrasar a verificação.
Então, antes de tudo,
você precisará criar uma variável para
o tempo entre verificar se há inimigos.
No método booleano, certifique-se de que não olhamos
todos os inimigos, exceto quando o tempo terminar.
Preste atenção em onde devemos redefinir este contador.
Então, isso será muito importante.
Então, com isso dito,
pause o vídeo agora mesmo e vá fazer cada Shannon.
Certo, bem-vindo de volta.
Então, vou rolar para cima aqui.
E vou criar um flutuador particular.
O tempo entre a busca do inimigo, entre a busca do inimigo.
E digamos que seja um F.
Então 1 segundo. A cada 1 segundo, verificamos
todos os inimigos da dívida.
E então aqui vou dizer que o tempo entre a
pesquisa está sendo reduzido pelo tempo. DeltaTime,
cada quadro, e isso será
chamado de cada quadro.
E então aqui,
vou verificar antes de verificarmos
todos os objetos.
Se o tempo entre a pesquisa for menor ou igual a 0,
então estaremos pesquisando. Lá vamos nós.
E então, quando realmente redefinimos isso?
Assim que o tempo entre
busca for menor ou igual a 0,
começamos verificando se todos os inimigos morreram.
E também podemos ir
em frente e redefinir esse tempo entre as pesquisas.
E vou defini-lo para 1.5 porque não acho
que isso seja algo que
você pode querer mudar no inspetor, o
tempo entre as buscas inimigas,
isso pode ser bastante padrão.
Mas se você acha que
talvez precise mudar essa variável,
obviamente esta f não funcionará.
Você precisa subir aqui,
criar uma variável separada
se você fez isso, parabéns,
este é o melhor passo ou a melhor maneira de pensar,
o melhor design de jogo talvez.
Mas para mim, acredito que isso
será algo muito constante,
algo que não mudará.
Acho que nunca teremos que mudar
o tempo entre as buscas inimigas.
Isso vai terminar?
Vamos voltar aqui.
E precisamos ter certeza de que nós,
Onde está aqui e atualizamos.
Vamos verificar se
o estado é igual aos estados de desova ponto em espera.
Então isso significa que estamos constantemente
gerando inimigos e estamos à espera.
Então, verificamos depois que obviamente terminamos esse loop for,
verificamos que o estado está esperando.
Então, se estiver aqui,
vamos verificar se os inimigos estão vivos.
E observe que adicionamos esse ponto de exclamação,
que significa exatamente o oposto.
Então, se todos os inimigos tiverem o Lloyd salvará o
log de pontos de depuração, wave.
Completo.
Salve isso.
E caso contrário, se não for,
então vamos simplesmente retornar.
E por que estamos fazendo isso?
Por que estamos dizendo retornar?
Dissemos que o retorno significa que não fazemos
mais nada dentro do método, especialmente em atualização.
Por quê? Porque uma vez que a onda esteja completa,
não queremos voltar para a onda,
agora podemos verificar se não estamos em desova,
que não estaremos n
porque estamos obviamente e a espera e
iniciamos a gravação novamente e
comece a criar os inimigos novamente.
Assim que a onda estiver completa,
queremos impedir que toda a atualização funcione.
Então, vou salvar isso.
Vou voltar ao meu ganho.
E agora devemos ver isso quando executamos o jogo.
Então conseguimos, depois de cinco segundos de Contagem Regressiva,
obtemos a contagem do inimigo.
Depois de dois segundos, outro podemos contar o inimigo.
E lá vamos nós.
Você pode ver que paramos tudo para que não tenhamos
mais inimigos que precisamos.
Então, vou tentar matá-los.
Então, temos os dois.
E como você pode ver, novamente,
a onda foi completada e, em seguida, os inimigos
começam a surgir novamente. Certo, ótimo.
Então, com isso fora do caminho,
certifique-se de confirmar suas alterações.
Espero que você goste e te vejo no
próximo vídeo, onde iremos
gerar pontos para várias ondas
e completar todas elas,
matando todos os inimigos,
completando todo o caminho,
e talvez ter algum tipo de mensagem muito boa.
Então, vejo você.