Willkommen zurück, Meine Lieblingsspielentwickler.
In diesem Video haben wir tatsächlich angefangen,
Feinde auf kluge Weise zu spawnen.
Jetzt, wenn wir das Spiel starten,
lass uns das vergrößern, damit du
richtig sehen kannst, was passiert.
Nachdem der Kandidat beendet ist,
erscheint der erste Feind,
der zweite Feind erscheint und sie sitzen einfach da und warten darauf,
dass wir ihn töten.
Sobald wir sie getötet haben,
versuchen wir sie zu gehen.
Okay.
Das ist eigentlich, oh, okay, das war peinlich.
Lass uns das Level neu starten.
Warte darauf. Also haben wir uns
Feinde so gut gemacht, dass wir sie nicht töten können.
Okay, also lass es mich versuchen.
Lassen Sie mich eine gewisse Distanz erreichen, damit wir es nicht mehr können.
Sobald wir sie anrufen, können Sie sehen
dass wir die Welle abgeschlossen haben.
Und dann bringen wir den Feind zum Laichen, weil wir die Anzahl der Feinde gemacht haben
und auch hier für diese Welle.
Verschwenden wir also keine Zeit mehr und lasst uns anfangen.
Oh, Fall.
Also lasst uns weitermachen und fangen tatsächlich an, Feinde zu besitzen.
Das erste, was wir tun werden, ist
offensichtlich hier eine Art Co-Routine zu schaffen
oder wir können auch einen Zähler erstellen.
Aber wir werden beim Coubertin bleiben
und diese Umwerbung wird jedes Mal aufgerufen
, wenn wir diese Spawnverzögerung haben.
Dieses Kernteam wird also die Feinde hervorbringen.
auch immer, lasst uns anfangen und wir werden
sehen, wie alles funktioniert.
Also werden wir hier einen Eye-Enumerator erstellen.
Und es wird die Spawnwelle genannt.
Und die Welle, die wir tatsächlich spawnen wollen.
Also winke zu Spot.
Wir haben also bereits die Welle, die wir überspannen wollen.
Es wird seine eigenen Feinde haben,
seinen Namen und die Anzahl der Feinde, die es hat.
Also werden wir eine for-Schleife erstellen.
In dieser for-Schleife beginnen wir
mit einer Ganzzahl, die ich gleich 0 ist.
Wir werden sicherstellen
, dass wir niemals über das Gewicht gehen, um zu laichen,
oder ist es die Welle zu spawnen,
die Anzahl der Feinde?
Und wir werden es auch jedes Mal um eins erhöhen
.
Also hier drin werden wir eine zufällige gegnerische Zahl erstellen.
Und es wird der Zufallsbereich sein.
Und dieser Bereich wird über 0 liegen.
Und die Welle, um Feinde zu spawnen, Punktlänge.
Also gehen wir los und erinnern uns an die Feinde,
und hier ist eine Reihe von Spielobjekten.
Also wollen wir einen zufälligen Feind da drin ausgeben.
Also gehe ich hier rein, wo wir sagen werden
, dass eine Art Methode
zum Spawnen ist, weil wir es außerhalb des haben wollen
, genau hier.
Dies wird nur die Spawnwelle sein.
Dies wird der feindliche Spawner hier drin sein.
Und was wir tun werden und wie dieser Zähler funktionieren wird,
und wie dieser Zähler funktionieren wird
wenn wir neue zurückgeben werden
, warten Sie vier Sekunden.
Und es wird auf der Welle sein.
Reagiere. Nicht verzögern, Punkt-Spawn-Verzögerung.
Was passiert hier drin?
Dies ist das erste Mal, dass ich glaube, dass wir
die Rendite innerhalb einer for-Schleife in einem Enumerator oder einer Coroutine verwenden
.
Also gehen wir diese Schleife durch.
Jedes Mal, wenn wir eine Zufallszahl wählen,
haben wir eine Art Feind hervorgebracht
und warten dann vier Sekunden.
Und dann haben wir wieder einen Feind hervorgebracht, wir haben einen Feind hervorgebracht.
So können wir die
Rendite zurückgeben und dies mehrmals aufrufen,
diese hervorgerufene Welle mehrmals.
Und nachdem wir dies getan haben,
werden wir auch die eigentliche Methode schaffen
, die den Feind hervorbringt.
Also spawne Feind.
Und hier drin werden wir sagen, dass wir ihm das Spielobjekt und den Feind zum Spawnen schicken werden
.
Und hier drin werden wir Debug Dot Log sagen, nur um
sicherzustellen, dass wir wissen, welcher Feind
hervorgebracht wird und alles richtig funktioniert.
Also laichen den Feind hervor.
Und wir geben ihm den Feind zum Spawnen.
Aber nenne.
Da sind wir los. Und wir werden einfach instanziieren.
Und dann hat sie den NMI gegessen. Zu klein.
Und es wird so sein, Oops, entschuldigen Sie mich.
Es wird also die gesamte Transformationspunkt-Position sein
und wir transformieren die Zeilenstation.
Was ist die Transformation?
Von welcher Transformation sprechen wir?
Da also der Wave-Spawner an den Level-Manager gebunden ist
,
dies die Position und die Rotation
des Level-Manager-Spielobjekts in unserer Szene.
Und später werden wir mehrere Punkte schaffen,
an denen die Feinde laichen werden.
So wird es also funktionieren.
Wir werden eine Art Array haben.
Wir werden uns später damit befassen, dass es sich nun
darauf konzentriert, diese Feinde tatsächlich zu instanziieren.
Spawne also Feind, die Welle, um Feinde an der Position der zufälligen gegnerischen Zahl zu
spawnen
, die wir gerade geschaffen haben.
Also füge ich hier eine Eingabe hinzu. Was machen wir?
Wir müssen auch die Coroutine nennen und hier,
also bevor wir es vergessen, also Co-Routine.
Spawnen, Spawnen, Feinde, winken.
Ja, da sind wir los.
Und auf welche Weise sollten wir laichen?
Während wir hier drin sind, werden wir nur sagen, dass es die Welle ist,
winkt die nächste Welle an der Position.
Also wird es jetzt wahrscheinlich 0 sein
, denn nächste Welle,
während die nächste Welle
hier bei 0 beginnt.
Es wird also die erste Welle sein , die
gerade zum Experimentieren dient,
die sich auf das konzentriert, was das tut.
Eine Co-Routine, die beginnt, wenn wir
sicherstellen, dass wir den Countdown nicht
laichen, ist weniger als 0,
wir laichen nicht,
wir sind bereit, mit dem Laichen zu beginnen.
Dann beginnen wir die Beschichtung hier drin. Wir haben die Schleife wird
die Anzahl der Feinde auf der Welle durchlaufen
, die wir erhalten.
Als Coroutine erstellen wir eine Zufallszahl.
Wir spawnen einen zufälligen Feind, der nur den Debug hat
um uns mitzuteilen, welcher Feind hervorgebracht wird
, wird dies wahrscheinlich später entfernen.
Und dann instanziieren wir den eigentlichen Feind des Managers.
Und was passiert dann? Wir geben Rückkehr zurück,
warten vier Sekunden und spawnen dann in anderen Feinden.
Bevor diese Schleife also wieder aufgerufen wird,
müssen wir die für uns angegebene Spawnverzögerung abwägen
.
Also werde ich das alles retten.
Ich gehe zurück und Einheit.
Und mal sehen, was wir hier als Levelmanager haben.
Warte, bis das etwas kompiliert.
Okay, also gehen wir zum
Level Manager des Managers und was haben wir hier drin?
Ich habe herumgespielt,
vielleicht habe ich das im Video nicht gemacht.
Also haben wir diese Welle genau hier.
Es ist die Skelettwelle.
Die Feinde, die wir hier haben, sind
der Skelettfeind und der feige fliegende Hoch.
Die Anzahl der Feinde, die wir wollen, ist
und reagieren wird zwei Sekunden betragen.
Ich hebe das auf.
Wo ist der Level Manager und unsere Welt?
Es ist nicht auf den 000.
Setzen wir es wieder auf 0,
also liegt es direkt vor unserem Spieler.
Und lasst uns das Spiel laufen und sehen, wie es aussieht.
Also jetzt 12 sollten wir den Wave-Countdown sehen.
Da gehen wir hin und whoa,
das sind zu viele Feinde.
Mal sehen, was wir hier falsch gemacht haben.
Also speichern wir das.
Was hier passiert, wir überprüfen,
dass der Countdown weniger als 0 ist.
Sind wir nicht im Laichzustand?
Nun, mal sehen. Wir
fangen mit dem Zählen an, also sind wir es nicht.
Offensichtlich müssen wir unsere Bundesstaaten hier drin ändern.
Bevor wir also tatsächlich die Schleife erstellen oder die Schleife starten,
werden wir sagen, dass wir uns in einem Zustand befinden
, der den Laichstaaten entspricht, aber laichend ist
.
Und wenn wir mit dem Laichen fertig sind,
werden wir in einen Zustand übergehen,
der die Gewichtung ist.
Wir warten also darauf, dass die Feinde spawnt werden.
Jetzt fangen wir an, bevor wir tatsächlich die Schleife durchlaufen,
sagten wir den Staat.
Jetzt wird das nicht jedes Mal aufgerufen
und wir werden nicht so viele Feinde haben.
Testen wir das noch einmal.
Führe das Spiel aus. Wir können den Countdown hier sehen.
Ich habe es öffentlich gemacht. Da sind wir los.
Also 0, wir kriegen den Feind und er fängt an zu schießen.
Dann kriegen wir einen weiteren Feind,
und dann gaben wir ihnen einen weiteren Feind,
und er wird alle zwei Sekunden gerufen.
Sieh dir diese kleinen Küken genau hier an.
Dies ist ein wirklich netter cooler Spielmechaniker, wie Sie sehen können,
alle zwei Sekunden 1212, und los geht's.
Wie Sie sehen können,
werden Feinde jede Sekunde aufgerufen.
Aber jetzt fragen Sie sich vielleicht,
warum haben wir so viele Feinde,
obwohl wir sagten, dass die Anzahl
der Feinde nur auch sein sollte.
Nun. Es liegt daran,
dass wir den Wave-Countdown nicht wirklich zurücksetzen lassen.
Wieder etwas, mit dem wir uns später beschäftigen werden.
Aber lasst uns zuerst darüber nachdenken, wann werden wir
die Welle tatsächlich zurücksetzen und wann winkt eine tatsächliche Welle?
Und so können wir entweder eine Zeit zwischen Welle schaffen.
Sagen wir also die erste Welle und die zweite Welle,
es gibt eine Verzögerung zwischen ihnen.
Oder wir können einen wirklich netten Mechaniker haben und unserer Ebene oder der Person, die unser Spiel spielt, die Chance geben
unserer Ebene oder der Person, die unser Spiel spielt
, alle Feinde in dieser Welle zu töten
, bevor die nächste Welle kommt.
Das werden wir also tun.
Und um das zu tun, werden wir
eine Art Methode entwickeln
, die verfolgen wird, ob ein Feind gestorben ist oder nicht.
Also lasst uns wieder hier runter gehen.
Und nach dem Spawnfeind
werden wir einen privaten schaffen.
Es wird einen Booleschen Wert geben,
und es wird die Feinde oder das Leben sein.
Und das wird wahr zurückkehren, wenn
alle Feinde am Leben sind oder nein.
Oh ja, wenn alle Feinde am Leben und falsch sind,
ob einer von ihnen oder keiner von ihnen am Leben ist.
Also hier drin, was ich sagen werde,
werde ich eine If-Bedingung schaffen.
Und ich werde das endgültige Objekt des Typs haben.
Und Objekte des Typs finden tatsächlich keine Objekte,
finden Objekte vom Typ.
Und der gegnerische Controller,
ich suche nach der Punktlänge des gegnerischen Controllers.
Und es wird gleich 0 sein.
Und wenn ja, dann werden wir falsch zurückgeben.
So falsch, das bedeutet, dass alle Feinde gestorben sind.
Und wenn wir das durchmachen
und nicht falsch zurückgeben,
werden wir wahr zurückkehren.
Das bedeutet, dass die Feinde noch am Leben sind.
Jetzt haben wir also eine Welle
oder um sicherzustellen, ob unsere Feinde
alle erschöpft sind, und wir werden
alle erschöpft sind, und wir werden sie hier irgendwie als Bedingung nutzen können.
Aber es gibt ein kleines Problem, das mich stört.
Die Suche nach Objekten des Typs auf
dem gegnerischen Controller ist eigentlich eine sehr umständliche, sagen wir,
Operation am System.
Es benötigt jedes Mal eine Menge Ressourcen
, um alle Objekte auf dem gegnerischen Controller zu durchlaufen
,
was manchmal nicht sehr notwendig ist.
Was wollen wir also tun, ist, dass wir eine Art Timer haben wollen
, wenn die Feinde lebendig Checker sind.
Wir überprüfen also nicht jeden
einzelnen Frame, ob alle Feinde tot sind.
Stattdessen lassen wir dies
alle paar Sekunden überprüfen.
Also werde ich es Ihnen als Herausforderung ausstellen, und Ihre Herausforderung besteht darin,
die Überprüfung zu verzögern.
Zunächst müssen Sie also
eine Variable für die Zeit zwischen der Suche nach Feinden erstellen
.
bei der booleschen Methode sicher, dass wir nicht
alle Feinde betrachten, außer wenn die Zeit vorbei ist.
Achte darauf, wo wir diesen Zähler zurücksetzen sollten.
Das wird also sehr wichtig sein.
also das
Halten Sie also das Video jetzt an und machen Sie jeden Shannon.
Okay, willkommen zurück.
Also scrolle ich hier rein.
Und ich erstelle einen privaten Float.
Die Zeit zwischen feindlicher Suche, zwischen feindlicher Suche.
Und sagen wir, es ist ein F.
Also 1 Sekunde. Jede Sekunde prüfen wir
nach allen Feinden der Schulden.
Und dann werde ich hier sagen, dass die Zeit zwischen der Suche um
die Zeit verkürzt wird.Deltatime,
jedes einzelne Frame, und dies wird
jedes einzelne Frame genannt.
Und dann werde ich hier unten nachsehen,
bevor wir tatsächlich nach
allen Objekten suchen.
Wenn die Zeit zwischen der Suche kleiner oder gleich 0 ist ,
werden wir suchen. Da sind wir los.
Und wann setzen wir das tatsächlich zurück?
Sobald die Zeit zwischen
Suche kleiner oder gleich 0 ist,
prüfen wir zunächst, ob alle Feinde gestorben sind.
Und wir können dieses Mal auch
zwischen den Suchanfragen zurücksetzen.
Und ich setze es auf 1.5, weil ich nicht glaube
, dass dies etwas ist
, das Sie im Inspektor ändern möchten,
die Zeit zwischen feindlichen Suchen,
das kann ziemlich Standard sein.
Aber wenn Sie denken, dass Sie
diese Variable möglicherweise ändern müssen,
funktioniert diese Variante offensichtlich nicht.
Du musst hier hochgehen, eine separate Variable erstellen,
eine separate Variable erstellen
wenn du das getan hast, herzlichen Glückwunsch,
das ist der bessere Schritt oder die bessere Denkweise,
je besser das Spieldesign vielleicht ist.
Aber für mich glaube ich, dass dies
etwas sehr Konstantes sein wird, etwas,
das sich nicht ändern wird.
Ich glaube nicht, dass wir jemals die Zeit zwischen feindlichen Suchvorgängen ändern
müssen.
Wird das fertig sein?
Lass uns wieder hier rein gehen.
Und wir müssen sicherstellen, dass wir,
wo ist es hier drin und aktualisieren.
Wir werden überprüfen, ob
der Zustand dem Punkt der Laichzustände entspricht, die warten.
Das bedeutet also, dass wir ständig
Feinde hervorbringen und wir warten.
Also prüfen wir, nachdem wir diese for-Schleife offensichtlich beendet haben, prüfen wir,
ob der Zustand wartet.
Wenn es dann hier drin ist,
werden wir prüfen, ob die Feinde am Leben sind.
Und beachten Sie, dass wir dieses Ausrufezeichen hinzugefügt haben,
was genau das Gegenteil bedeutet.
Wenn also alle Feinde Lloyd haben, wird das
Debug-Punktprotokoll speichern, winken.
Abgeschlossen.
Spar dir das auf.
Und sonst, wenn nicht ,
werden wir einfach zurückkehren.
Und warum machen wir das?
Warum sagen wir „Rückkehr“?
Wir sagten, dass zurückgegeben bedeutet, dass wir nichts anderes innerhalb der Methode tun
, insbesondere im Update.
Warum? Denn sobald die Welle abgeschlossen ist,
wollen wir nicht wieder in die Welle zurückkehren,
können jetzt prüfen, ob wir nicht laichen,
was wir nicht sein werden, weil wir
offensichtlich sind und das Warten
und die Aufnahme wieder starten und
fang wieder an, die Feinde zu erschaffen
Sobald die Welle abgeschlossen ist,
möchten wir verhindern, dass das gesamte Update funktioniert.
Also werde ich das speichern.
Ich gehe zurück in meinen Gewinn.
Und jetzt sollten wir das sehen, wenn wir das Spiel laufen.
Also bekommen wir, nach fünf Sekunden Countdown,
den Feind zählen.
Nach zwei Sekunden können wir den Feind noch einmal zählen.
Und los geht's.
Sie können sehen, dass wir alles gestoppt haben, damit wir
nicht mehr Feinde bekommen, die wir müssen.
Also werde ich versuchen, die umzubringen.
Also haben wir beide.
Und wie Sie sehen können, ist die Welle wieder
abgeschlossen und dann beginnen die Feinde
wieder zu laichen. Okay, großartig.
Wenn das aus dem Weg ist,
stellen Sie sicher, dass Sie Ihre Änderungen übernehmen.
Ich hoffe es gefällt dir und ich sehe dich im
nächsten Video, in dem wir
Punkte für mehrere Wellen spawnen
und alle vervollständigen,
alle Feinde töten und den ganzen Weg abschließen,
den ganzen Weg abschließen,
und vielleicht eine wirklich nette Botschaft haben.
Wir sehen uns dann.