Bienvenue, mes développeurs de jeux préférés.
Dans cette vidéo, comme vous pouvez le voir,
nous avons quelque chose d'un peu différent.
Nous avons des vagues, mais ces ondes ne sont pas
seulement des éléments réguliers ou des variables régulières.
Ils ont les variables d'amis à l'intérieur d'eux.
Et nous pouvons créer une autre vague et une autre vague.
Et comme vous pouvez le constater, chacun d'
eux a son propre élément.
Bienvenue dans la section Advanced C-sharp.
Ne perdons plus de temps et commençons.
Mais j'ai besoin de votre concentration totale,
toute votre durée d'attention et de votre chute.
patients avec moi.
Commençons donc.
Maintenant que nous avons nos niveaux aléatoires,
il est temps de créer des ondes NME aléatoires.
Nous n'allons donc pas seulement avoir
les ennemis réguliers ici.
Je viens de les installer dans
la vidéo précédente pour que nous sachions quelle
est l'idée générale à
chaque niveau et que nous ayons juste quelques
différences entre eux.
Mais dans cette vidéo, nous allons
créer un géniteur ennemi.
Commençons donc.
La première chose que nous allons faire, c'est
que nous allons ouvrir les gestionnaires.
Et nous n'avons pas de gestionnaires ici.
Nous allons donc passer à l'un d'entre
eux qui n'a pas de manager et c'est tout.
Et ce que je vais faire, c'est que je
vais entrer dans le préfabriqué.
Nous avons un manager ici et je vais juste ajouter le dossier entier des gestionnaires afin
que nous puissions
ajouter des gestionnaires à n'importe quelle scène dont nous avons besoin.
Je vais donc passer au
niveau du patron que nous avons tous les managers ici.
Oui, c'est le cas. Les lâches.
Nous n'avons pas les gestionnaires
gestionnaires préfabriqués et les gestionnaires ici. On y va.
Nous avons maintenant le niveau de jeu et tout votre manager.
Et revenons en arrière et voyons.
Donc, les lâches, oui, sauvent la santé.
Est-ce que nous avons des gestionnaires ?
Non, nous ne le faisons pas.
Encore une fois, nous allons voir les préfabriqués préfabriqués Managers.
Et on y va. Nous ajoutons les gestionnaires à la salle de santé.
Allons voir ce que nous avons de plus avec les nouveaux
gestionnaires. Nous ne le faisons plus.
Trouve donc les managers à ça.
Et si vous le souhaitez, vous pouvez simplement sauter
cette partie et aller directement au,
vous avez ici.
Mais ce n'est pas le préfabriqué,
donc je vais le supprimer.
Je vais ajouter
le préfabriqué du gestionnaire réel
aurait dû faire cela dans un précédent.
Aussi des scènes, qu'est-ce que cette boutique ?
C'est Kelly, pas de manager.
Et les gestionnaires.
Et les scènes grimpent, sauvez les gestionnaires.
On y va. Niveau Boss.
Les gestionnaires que nous voulons.
Ce n'est pas le manager que vous recherchez.
Alors les lâches le voient ?
Oui, oui.
Oui, oui, oui.
Ok, super.
Donc, partout où nous avons des gestionnaires
, il est temps de créer un géniteur.
Et le meilleur point de départ, je crois
, c'est dans ces Kelly ici.
Dans ce cas,
allez dans le gestionnaire de niveaux et allons de l'
avant et ajoutons un composant ici ou non,
en fait, passons dans les scripts.
Et où allons-nous ajouter le géniteur de vagues ?
Et ajoutons-le simplement à l'intérieur des gestionnaires
ici, nous allons créer un nouveau script C-sharp,
qui sera le gestionnaire de génération de vagues.
Appuyez sur Entrée, nous venons d'ajouter le Gestionnaire de noms.
Encore une fois, nous avons une excuse pour les autres cadres supérieurs.
Je vais donc aller de l'avant et l'ajouter au gestionnaire de niveau.
Et ici, je vais ouvrir le scénario.
Alors, que voulons-nous faire ici ?
Nous voulons créer un autre cours.
Pourquoi voulons-nous créer un autre cours ?
Eh bien, parce que tout d'abord,
c'est un C-sharp avancé.
Deuxièmement, nous voulons créer une classe différente pour les
une classe différente pour
vagues parce que les vagues
ont nommé les vagues ont des ennemis,
les vagues ont un équilibre entre les ennemis,
le délai entre chaque fois que nous sommes apparus. un ennemi,
et ainsi de suite.
Donc ici, je vais aller de l'avant
et créer un cours public.
Et ça va s'appeler la vague.
Et cette vague aura quelques choses.
Tout d'abord, il aura un nom de chaîne public.
Et de toute évidence, nous ne voulons pas qu'il soit toujours public,
mais dans ce cas,
nous pouvons gagner un peu de temps sans
avoir à créer toutes les choses supplémentaires.
Nous allons les rendre publics.
Ensuite, nous aurons un objet de jeu public
et un ensemble d'ennemis.
Quel éventail d'ennemis et de moi. On y va.
Ensuite, nous aurons un public et
le nombre d'ennemis qui apparaîtront.
Et enfin, nous aurons un retard de frai public à flotteur.
On y va. Ce sont donc tous les éléments,
ou disons la partie de l'onde,
toutes les variables à l'intérieur de la vague.
Si vous voulez appeler cette variable,
car il s'agit d'une classe,
c'est quelque chose de totalement différent.
Mais ce n'est pas la seule chose que nous devons faire.
Nous devons également nous assurer de dire qu'ici,
s'agit d'un point système sérialisable.
Nous sauvegardons donc cela.
Et que signifie sérialisable ?
Cela signifie que maintenant si j'ouvre
les scripts Unity ici,
vous le verrez.
D'accord, rien ne s'est passé.
Pourquoi est-ce que c'est ? Eh bien, parce que nous
devons également faire une autre chose.
Et ici, nous allons dire qu'il y a une vague publique.
Comme vous pouvez le constater maintenant, nous avons une classe totalement nouvelle,
un éventail de vagues.
Nous sauvegardons donc cela.
Maintenant, lorsque nous reviendrons dans Unity,
nous verrons que nous avons la possibilité de créer des vagues.
Et si je n'ajoute qu'une vague ici,
vous verrez que j'ai des éléments différents pour cette vague.
Et je peux avoir un but, avoir un montant,
avoir le retard de frai et les ennemis que je veux.
Et si j'ajoute un autre élément ici,
vous remarquerez encore une fois que
j'ai un nom différent, des ennemis différents,
quantités différentes et des retards différents.
Comme vous pouvez le constater, c'est pourquoi vous avez recréé ou veillé à
ce qu'il s'agisse d'un point système sérialisable.
Cela nous permettra de créer différents éléments
et nous permettra de créer
ces types de variables.
Nous avons donc créé
une nouvelle variable qui contient différentes variables à l'intérieur.
Continuons donc maintenant que nous avons tout cela,
la prochaine chose à faire est évidemment d'aller de l'avant et de commencer à
vérifier vague après vague.
La première chose que nous devons faire, c'est ici que nous créerons
une fin privée et nous tiendrons compte de la prochaine vague.
Et évidemment, nous commencerons à 0.
La première vague sera donc 0.
Et chaque fois que nous créons
une nouvelle vague avec un nouveau nombre d'ennemis,
avec les différents types d'ennemis,
nous passerons à la prochaine vague en l'augmentant d'un seul.
Ensuite, nous allons créer un champ sérialisé où
nous garderons une trace du temps entre les vagues.
Et il suffit de le définir à cinq F par défaut.
Ensuite, nous allons également
suivre le nombre de vagues.
Donc, float wave, je dis nombre de vagues,
je voulais dire compte à rebours.
Bon, garde ça.
Et maintenant, au début, nous devons initialiser le compte à
rebours des vagues pour qu'il s'agisse du temps entre les vagues.
Ensuite, nous allons faire
quelque chose pour plus tard et nous avons réfléchi,
mais maintenant nous voulons avoir quelque chose en plus.
Et je pense que c'est l'endroit idéal pour créer
quelque chose ou quelque chose que nous avons déjà couvert,
qui est une énumération.
Et pourquoi voulons-nous créer une énumération ?
Parce que les vagues seront dans trois états distincts,
nous aurons un frai.
C'est donc là que nous reproduisons chacun,
je ne connais pas le temps ou le délai entre les ennemis.
Par exemple, toutes les deux secondes, nous engendrons un nouvel ennemi.
Nous engendrons un nouvel ennemi.
moment, nous ne voulons pas faire certaines choses
avec notre contrôleur ou notre gestionnaire de générateurs de vagues.
Je veux dire, nous devons donc créer différents états.
Ce que je vais faire, c'est que je
vais lancer un défi.
Et votre défi consiste à créer une énumération
pour les différents états que nous allons avoir.
Nous avons donc déjà couvert les énumérations dans la section pick-up.
Donc, tout d'abord, créez un E rien pour
les différents états de frai qui auront,
devront avoir le frai, l'attente et le comptage.
Enfin, il suffit de créer une variable de ce type pour
que nous puissions l'utiliser comme référence.
Alors mettez la vidéo en pause maintenant et allez faire chacune d'elles.
Oh, d'accord, bon retour.
Comme je vous l'ai dit,
dans l'un des pick-up,
alors que le pick-up.
pick-up, une bicouche ?
Non. Article compte-gouttes, dope.
Où était-ce ? Où était-ce ?
Dans le oh, OK.
Ainsi, dans l'article de la boutique, comme vous pouvez le voir,
nous avons créé une énumération pour la restauration de la santé,
amélioration de la santé et l'arme.
Et sur la base de chacun de ces éléments,
nous avons une déclaration de commutateur.
Nous allons faire presque exactement la même chose.
Je vais donc créer une énumération privée et privée.
Et ce seront ces États battants.
Et nous allons avoir le bombardement,
l'attente et le décompte.
Ensuite, nous allons simplement créer
une variable de ce type qui sera
un état et un état fondateurs privés.
On y va, sauve ça.
Et ici, au début, par
quoi voulons-nous commencer ?
Eh bien, nous allons commencer par le comptage.
State est égal au comptage des points des états de frai.
Nous commençons donc par compter le compte à rebours , puis
commençons également nous assurer que nous nous sommes fixés.
Nous avons déjà dit le compte à rebours des vagues.
Nous voulons mettre à jour,
commencer à compter sur la vague.
Donc, si le compte à rebours des vagues est inférieur ou égal à 0,
nous allons tout d' abord vérifier
si l'
dans lequel nous sommes actuellement est différent de l'état
de frai, soit le frai des points.
Ensuite, ce que nous allons faire, c'est que nous commencerons
frayer tandis que si
nous n'avons pas terminé le compte à rebours,
nous allons obtenir le compte à rebours et
supprimer pour le temps d'inscription, le temps delta.
Alors, que se passe-t-il ici ?
Faisons simplement un petit récapitulatif
parce que tout cela est assez nouveau.
Tout d'abord, nous avons le gestionnaire de génération de vagues,
qui est rattaché au gestionnaire de niveau ici.
D'accord.
Attendez que cela soit compilé d'un jour à l'autre.
D'accord, merci. Alors, qu'avons-nous ?
Nous avons une vague et
chaque vague comporte des éléments différents.
Nous avons donc décidé de créer une
classe publique entièrement nouvelle pour la représenter.
Nous aurions pu, si nous le voulons,
créer une classe distincte juste pour celle-ci,
dans un script séparé, juste pour celui-ci,
et ne pas avoir un comportement mono,
juste une tige sérialisable et un système
des moyens sérialisables qui
nous permettent de créer cela ici.
Et cela nous permet de changer
les différents éléments ici, comme nous le voulons.
Cela peut donc nous permettre de changer les
objets de valeur beaucoup plus facilement.
Nous avons donc créé les vagues,
nous gardons une trace de la prochaine vague qui pourrait être publique
si vous voulez simplement vous assurer que nous voyons
tout de façon appropriée, la rendre publique.
Nous avons créé le temps entre les vagues,
les vagues descendent.
C'est assez simple.
Ensuite, nous avons créé une énumération pour les États reproducteurs
parce que nous avons différents états de frai.
Tout d'abord, nous pouvons frayer,
attendre ou compter à rebours.
Ensuite, nous en créons un pour suivre tout
ce qui se passe,
comme nous l'avions fait dans la boutique.
Plus tard, nous aurons des différences si je dis,
nous aurons différentes méthodes en cours d'
exécution et la mise à jour selon que nous,
dans quel état nous sommes,
nous aurons des éléments différents, des choses différentes.
Et c'est le premier exemple.
Si nous comptons à rebours,
si nous terminons le compte à rebours
et que nous ne sommes pas en état de frai,
nous commencerons à frayer.
Si nous n'avons pas terminé le compte à rebours,
nous allons simplement supprimer du compte à rebours l'heure, le temps
delta jusqu'à ce qu'il soit inférieur à 0.
Ensuite, nous vérifions notre réponse.
Si ce n'est pas le cas, nous commencerons à frayer dans la prochaine vidéo,
où nous allons réellement frayer des ennemis.
J'espère que ça vous plaira.
Je sais que c'est un peu compliqué,
mais c'est ce que vous vous êtes inscrit.
Vous êtes venu à la section avancée C-sharp en bonus.
J'espère que ça vous plaira.
J'espère que vous commettez vos changements et je vous verrai
dans la prochaine vidéo.