Bem-vindo de volta, Meus desenvolvedores de jogos favoritos.
Neste vídeo, como você pode ver,
temos algo um pouco diferente.
Temos ondas, mas essas ondas não são
apenas elementos regulares ou variáveis regulares.
Eles têm as variáveis de amigos dentro delas.
E podemos criar uma outra onda e outra onda.
E como você pode ver, cada um deles
tem seu próprio elemento.
Então, bem-vindo à seção Avançado C-sharp.
Não vamos perder mais tempo e vamos começar.
Mas preciso de sua concentração total,
sua atenção total e sua queda.
Pacientes comigo.
Então, vamos começar.
Oh, ok, então agora que temos nossos níveis aleatórios,
é hora de criar ondas NME aleatórias.
Então, não vamos apenas ter
os inimigos regulares aqui.
Acabei de configurá-los no
vídeo anterior para que saibamos qual
é a ideia geral em
cada nível e apenas tenhamos
algumas diferenças entre eles.
Mas neste vídeo vamos
criar um criador inimigo.
Então, vamos começar.
A primeira coisa que vamos fazer é
abrir os gerentes.
E não temos gerentes aqui.
Então, vamos para um desses
que não tem um gerente e é isso.
E o que vou fazer é
entrar no pré-fabricado.
Temos um gerente aqui e vou adicionar toda a
pasta de gerentes para que possamos
adicionar gerentes a qualquer cena que precisarmos.
Então, vou para o
nível de chefe que temos todos os gerentes aqui.
Sim, nós fazemos. Os covardes.
Não temos os gerentes ou gerentes
pré-fabricados e os gerentes aqui. Lá vamos nós.
Agora temos o nível do jogo e todo o seu gerente.
E vamos voltar e ver.
Então, os covardes, sim, salvam a saúde.
Temos gerentes?
Não, nós não temos.
Então, novamente, vamos para os prefabs Prefabs Managers.
E lá vamos nós. Adicionamos os gerentes à sala de saúde.
Vamos ver o que mais temos o novo que temos
gerentes no topo. Nós não fazemos novamente.
Então encontre os gerentes nisso.
E se você quiser, você pode simplesmente pular
esta parte e ir direto para o,
você tem aqui.
Mas este não é o prefab,
então vou excluir isso.
Vou adicionar o
prefab do gerente real
deveria ter feito isso em um anterior.
Também cenas, o que é essa loja?
Esta Kelly está vendo, sem gerente.
E os gerentes.
E picos de cenas, salve gerentes.
Lá vamos nós. Nível de chefe.
Gerentes que queremos.
Este não é o gerente que você está procurando.
Então os covardes veem?
Sim, sim.
Sim, sim, sim.
Certo, ótimo.
Então, em todos os lugares, temos gerentes
agora é hora de realmente criar um criador.
E o melhor lugar que acredito para
começar é nestes Kelly aqui.
Então, neste caso,
vá para o gerenciador de níveis e vamos
em frente e adicione um componente aqui ou não,
na verdade, vamos para os scripts.
E onde vamos adicionar o criador de ondas?
E vamos adicioná-lo dentro dos gerentes
aqui, vamos criar um novo script C-sharp,
que será o gerenciador de geradores de ondas.
Pressione Enter, acabamos de adicionar o Gerenciador de nomes.
Então, novamente, temos uma desculpa para outros gerentes de topo.
Então, vou adiante e adicioná-lo ao gerenciador de níveis.
E aqui vou abrir o roteiro.
Então, o que queremos fazer aqui?
Queremos criar outra classe.
Por que queremos criar outra classe?
Bem, porque antes de tudo,
isso é avançado C-sharp.
Em segundo lugar, queremos criar
uma classe inteira diferente para
as ondas porque as ondas
nomearam as ondas têm inimigos,
as ondas têm um equilíbrio de inimigos,
o atraso entre cada vez que geramos um inimigo,
e assim por diante e assim por diante.
Então, aqui, vou seguir em frente
e criar uma classe pública.
E isso vai ser chamado de onda.
E essa onda terá algumas coisas.
Então, antes de tudo, ele terá um nome de String público.
E, obviamente, não queremos tê-lo sempre como público,
mas neste caso,
só para que possamos economizar um pouco de tempo sem
ter que criar todas as coisas extras.
Vamos torná-los públicos.
Então teremos um objeto de jogo público
e uma série de inimigos.
Que série de inimigos e eu somos. Lá vamos nós.
Então teremos um público e
a quantidade de inimigos que surgirão.
E, finalmente, teremos um atraso de desova de flutuação pública.
Lá vamos nós. Então, esses são todos os elementos,
ou digamos que a parte da onda,
todas as variáveis dentro da onda.
Se você quiser chamar essa variável,
porque esta é uma classe,
é algo totalmente diferente.
Mas essa não é a única coisa que precisamos fazer.
Também precisamos ter certeza de dizer que aqui em cima,
este é um ponto de sistema serializável.
Então, salvamos isso.
E o que significa serializável?
Isso significa que agora, se eu abrir
os scripts Unity aqui,
você verá isso.
Certo, nada aconteceu.
Por que isso? Bem, porque
também precisamos fazer mais uma coisa.
E aqui vamos dizer que isso tem uma onda pública.
Como você pode ver agora, temos uma classe totalmente nova,
uma série de ondas.
Então, salvamos isso.
Agora, quando voltarmos à Unity,
veremos que temos a opção de criar ondas.
E se eu apenas adicionar uma onda aqui,
você verá que eu tenho elementos diferentes para essa onda.
E eu posso ter um objetivo, posso ter uma quantia,
posso ter o atraso de desova e os inimigos que eu quero.
E se eu adicionar outro elemento aqui,
você notará que novamente,
tenho um nome diferente, inimigos diferentes,
quantidades diferentes e atrasos diferentes.
Então, como você pode ver, é por isso que recriou ou se certificou
de que este é um ponto do sistema serializável.
Isso nos permitirá criar diferentes elementos
disso e nos permitirá criar
esses tipos de variáveis.
Então, basicamente, criamos
uma nova variável que tem diferentes variáveis dentro dela.
Então, vamos continuar agora que temos tudo isso,
a próxima coisa a fazer é obviamente ir em frente
e começar a verificar onda após onda.
Então, a primeira coisa que precisamos fazer é aqui, criaremos
um fim privado e vamos manter a contagem da próxima onda.
E, obviamente, começaremos em 0.
Então, a primeira onda será 0.
E toda vez que criamos
uma nova onda com uma nova quantidade de inimigos,
com os novos tipos diferentes de inimigos,
iremos para a próxima onda aumentando-a em um.
Em seguida, vamos criar um campo serializado onde
vamos acompanhar o tempo entre as ondas.
E vamos defini-lo em cinco F como padrão.
E então também vamos
acompanhar a contagem de ondas.
Então, onda flutuante, eu digo contagem de ondas,
eu quis dizer contagem regressiva.
Certo, salve isso.
E agora, quando começar, precisamos inicializar
a contagem regressiva das ondas para ser o tempo entre as ondas.
E então vamos fazer
algo para mais tarde e estava pensando,
mas agora queremos ter algo também como um extra.
E acho que este é o lugar perfeito para criar
algo ou algo que já cobrimos,
que é um enum.
E por que queremos criar um enum?
Como as ondas estarão em três estados separados,
teremos uma desova.
Então é aqui que estamos gerando cada um,
eu não sei o tempo ou o atraso entre os inimigos.
Por exemplo, a cada dois segundos geramos um novo inimigo.
Nós geramos um novo inimigo.
Neste momento, não queremos fazer certas coisas
com nosso controlador ou gerente de geradores de ondas.
Quero dizer, então precisamos criar estados diferentes.
Então, o que vou fazer é
lançar um desafio.
E seu desafio é criar um enum
para os diferentes estados que teremos.
Então, já cobrimos enums na seção de coleta.
Então, antes de tudo, crie um E nada para
os diferentes estados de desova que terão,
precisará ter a desova, espera e contagem.
E, finalmente, tudo o que você precisa fazer é criar uma variável desse
tipo para que possamos usá-la como referência.
Então, pause o vídeo agora mesmo e vá fazer cada um.
Oh, ok, bem-vindo de volta.
Então, como eu te disse,
em uma das pickups,
enquanto a pick-up pickup.
Pickup pickup, uma bicamada?
Não. Conta-gotas de item, droga.
Onde estava? Onde estava?
No oh, ok.
Então, no item da loja, como você pode ver,
criamos um enum para a restauração de saúde,
atualização de saúde e a arma.
E com base em cada um desses,
temos uma instrução switch.
Vamos fazer quase exatamente a mesma coisa.
Então, aqui vou criar um enum privado e privado.
E estes serão esses Estados batendo.
E nós vamos ter o bombardeio,
a espera e a contagem.
E então vamos apenas criar
uma variável desse tipo que será
um estado e estados fundadores privados.
Lá vamos nós, salve isso.
E aqui no início,
o que queremos começar?
Bem, vamos começar com a contagem.
O estado é igual à contagem de pontos dos estados de desova.
Então, começamos com a contagem regressiva e
, em seguida, começamos também precisamos ter certeza de que definimos.
Oh, então já dissemos a contagem regressiva das ondas.
Queremos atualizar,
começar a contagem regressiva na onda.
Então, se a contagem regressiva de ondas for menor ou igual a 0,
então o que vamos fazer é verificar,
primeiro lugar, se
o estado em que estamos atualmente é diferente
do estado de desova, desova de pontos.
Então o que vamos fazer é começar
desova enquanto o caso
contrário não terminamos a contagem regressiva,
então vamos obter a contagem regressiva e
remover para o tempo de inscrição, hora delta.
Então, o que está acontecendo aqui?
Vamos fazer uma pequena recapitulação
porque tudo isso é bastante novo.
Primeiro de tudo, temos o gerente de geradores de ondas,
que é anexado ao gerente de nível aqui.
Certo.
Aguarde que isso seja compilado a qualquer dia agora.
Certo, obrigado. Então, o que temos?
Temos uma onda e
cada onda tem elementos diferentes ligados a ela.
Então, o que decidimos fazer é criar
uma classe pública totalmente nova apenas para representá-la.
Poderíamos ter, se quisermos,
criado uma classe separada apenas para esta,
em um script separado, apenas para este,
e não ter que seja um comportamento mono,
apenas um tronco serializável e sistema
meios serializáveis que
nos permitem criar isso aqui.
E isso nos permite mudar
os diferentes elementos aqui sobre como sempre quisermos.
Assim, pode nos dar a capacidade de mudar
os objetos de valor muito mais fácil.
Então criamos as ondas,
acompanhamos a próxima onda que pode ser pública
se você quiser apenas ter certeza de que vemos
tudo de forma adequada, torná-lo público.
Criamos o tempo entre as ondas,
as ondas caem.
Isso é bem simples.
Em seguida, criamos um enum para os Estados de desova
porque temos diferentes estados de desova.
Primeiro de tudo, podemos estar desova,
esperando ou podemos estar contando.
E então criamos um para
acompanhar tudo o que acontece,
assim como tínhamos no item da loja.
Mais tarde, teremos diferentes fora, caso eu diga,
teremos diferentes métodos sendo
executados e a atualização com base em se nós,
em que estado estamos,
teremos elementos diferentes, coisas diferentes.
E este é o primeiro exemplo disso.
Se estivermos em contagem regressiva,
se terminarmos a contagem regressiva
e não estivermos em um estado de desova,
então começaremos a desova.
Se não terminarmos a contagem regressiva,
vamos remover da contagem regressiva o tempo, hora
delta até ficar abaixo de 0.
Em seguida, verificamos nossa resposta.
Caso contrário, começaremos a desova no próximo vídeo,
onde na verdade estaremos gerando inimigos.
Então, espero que você goste.
Sei que isso é um pouco complicado,
mas é para isso que você se inscreveu.
Você veio para a seção avançada C-sharp em bônus um.
Então, espero que você goste.
Espero que você esteja cometendo suas alterações e eu
vejo no próximo vídeo.