Einen Feind erstellen

In diesem Teil des Tutorials erstellst du einen Feind der den Spieler erkennt, verfolgt und ihm Schaden zufügt. Darüber hinaus kann der Feind Schaden erleiden und sich mithilfe eines Navigationsmeshs durch die Umgebung navigieren, um Hindernissen auszuweichen.

Zunächst erstellst du die Logik für den Feind mithilfe des Blueprint-Visual-Scripting-Systems, wie in den vorherigen Tutorials. Anschließend erstellst du das Navigationsmesh, um die Umgebung zu definieren, durch die die KI navigieren kann. Das Navigationsmesh legt die spezifischen Zonen und Bereiche auf der Karte fest, in denen sich die verschiedenen KI-Charaktere während des Gameplay bewegen können.

Einen Feind erschaffen

Zusätzlich zu der Arbeit, die du in den vorherigen Tutorials mit Blueprints durchgeführt hast, fügst du dieses Mal ein Objekt hinzu, um den Feind visuell darzustellen, und spielst eine Animation mit einem Animationsblueprint ab. Der Animationsblueprint wird in den Projektdateien bereitgestellt, du wirst ihn also nicht von Grund auf erstellen, es ist jedoch wichtig, dass du lernst, wie du einen in den Blueprint des feindlichen Charakters integrieren kannst.

Erstelle zuerst den Feind-Blueprint. Befolge diese Schritte:

1. Gehe zum Inhaltsbrowser und gehe zu Inhalt > AdventureGame > Blueprints > Charaktere.

2. Klicke mit der rechten Maustaste auf eine leere Stelle im Inhaltsbrowser und Blueprint-Klasse.

3. Wähle im neuen Fenster Charakter als Basis-Klasse.

4. Nenne diese Klasse „BP_Enemy“ und öffne diese im Blueprint-Editor durch einen Doppelklick.

Wenn du einen Blueprint erstellst, erstellst du auch eine Blueprint-Klasse, die Teil des Blueprint-Asset ist und die Funktionalität des Blueprints definiert. Wenn du also eine Funktionalität hinzufügst, bearbeitest du die Blueprint-Klasse. In diesem Fall erstellst du ein Blueprint-Asset mit dem Namen BP_Enemy, das denselben Namen wie die Blueprint-Klasse verwendet.

Die Basis-Klasse kann als eine Vorlage mit vorgefertigten Funktionalität betrachtet werden, die deine neue Blueprint-Klasse nutzen kann. In diesem Fall hat die Charakter Basis-Klasse Funktionalität, die für einen Spielcharakter relevant ist – wie Bewegung und Kameradrehung zum Schauen. Durch die Verwendung dieser Basis-Klasse kannst du die vorgefertigte Funktionalität nutzen und musst sie nicht neu erstellen.

Der Spieler-Blueprint, BP_AdventureCharacter verwendet ebenfalls die Charakter Basis-Klasse, sodass sowohl der Spieler als auch der Feind-Charakter dieselbe Basis-Funktionalität haben, die du wiederverwenden kannst.

Öffne im BP_Enemy-Blueprint-Fenster den Tab Viewport und schau dir das Komponenten-Panel an. Am Ende der Liste siehst du die Komponente Charakter-Bewegung (CharMoveComp). Dies ist die Komponente, die über eigene Funktionen und Variablen in Bezug auf Bewegung verfügt, wie beispielsweise die maximale Bewegungsgeschwindigkeit, die Teil der Basis-Klasse Charakter ist. Du kannst diese Komponente verwenden, um eine ähnliche  Funktionalität für die Gegner in deinem Projekt zu erstellen.

Hinzufügen eines 3D-Modells zum Feind

Zuerst beginnen wir damit, eine neue Komponente hinzuzufügen. Befolge diese Schritte:

1. Wähle die Skelett-Mesh-Komponente aus und suche im Details-Panel auf der rechten Seite des Fensters. Suche die Kategorie „Mesh“ und kicke auf das Dropdown-Menü neben „Skelett-Mesh Asset“.

2. Suche in der Liste nach dem Modell SKM_Manny_Simple und wähle es aus. Damit weist du dem Blueprint das Manny-Modell zu.

3. Schau dir als Nächstes die Kategorie Animation an. Klicke auf die Dropdown-Liste neben „Anim Klasse“ und weise den ABP_Unarmed Animationsblueprint zu. ABP steht in diesem Kontext für Animationsblueprint.

4. Modifiziere die Animationsblueprint, damit es korrekt mit unserem Feind funktioniert:

   1. Klicke in der Eigenschaft „Anim Klasse“ des feindlichen Meshs neben „ABP_Unarmed“ auf „Navigieren zu Asset“ im Inhaltsbrowser.

   2. Doppelklicke auf den ABP_Unarmed- Animationsblueprint, um ihn zu öffnen.

   3. Gehe zu der Gruppe von Logik, die nach dem Dann 1-Pin des Sequenzknotens kommt. Du möchtest nicht, dass die Beschleunigungsprüfung hier die Bewegung der feindlichen Charaktere verhindert, also entferne die Verbindung zwischen dem „Und“-Knoten und dem „Sollte sich bewegen festlegen“-Knoten.

   4. Verbinde den Output-Pin des Knotens „Größer als (>)“ mit „Set Sollte bewegen“ und umgehe dabei die Beschleunigungsprüfung.

      

   5. Speicher, kompiliere und schließe den Blueprint.

Jetzt sollte der Feind-Charakter im Viewport-Tab eine Idle-Animation abspielen.

Im Viewport wirst du eine Kapselform sehen, die sich um den feindlichen Charakter herum befindet. Die Kapsel-Komponente ist eine visuelle Darstellung des Kollisions-Colliders, der verwendet werden kann, um Kollisionen mit anderen Objekten (z. B. Wänden, Boden oder dem Spieler-Charakter) zu erkennen.

Im Viewport siehst du, dass der Charakter gerade einen Versatz vom Boden-Level hat und nicht an der Kapsel-Komponente ausgerichtet ist. Dies kann im Gameplay zu Fehlausrichtungen führen. Um sicherzustellen, dass das Mesh des Charakters richtig an der Kapsel-Komponente ausgerichtet ist, bewege den Charakter nach unten, sodass die Füße den unteren Teil der Kapsel-Komponente berühren.

Wähle erneut die Mesh-Komponente aus, um das 3D-Modell hervorzuheben. Verwende im Details-Panel die Kategorie Transformieren und das Feld Standort, um die Z Achse zu ändern, das letzte Feld mit blauer Farbe. Leg den Wert auf -96 fest. Dadurch wird das Mesh zum unteren Rand des Kapsel-Colliders bewegt, wodurch sichergestellt wird, dass der Feind im Spiel nicht über dem Boden schwebt.

Stelle sicher, dass die Vorderseite des Zeichens in Richtung des blauen Pfeils zeigt, der im Komponenten-Panel als Pfeil-Komponente (Pfeil) angezeigt wird. Der Pfeil zeigt an, in welche Richtung die Vorderseite des Blueprints zeigt. 

Im Komponenten-Panel siehst du eine Pfeil-Komponente. Der Pfeil ist auch im Tab Viewport als blauer hellblauer Pfeil zu sehen.

Die Pfeil-Komponente zeigt an, in welche Richtung der Charakter schauen muss, um sich korrekt in alle Richtungen zu bewegen. Die Richtung des Pfeils entspricht der Vorwärtsrichtung des Charakters. 

Wähle daher erneut die Komponente Mesh aus, und drehe den Charakter um die Z Achse über das Details-Panel, das letzte Feld unter „Transformieren“. Du solltest es vielleicht auf -90 festlegen, damit es richtig gedreht wird.

Ändern des Materials des 3D-Modells

Bevor du mit der Erstellung der Funktionalität fortfährst, ändere die Farbe des Feindmodells in Rot. Dadurch unterscheidet es sich vom Spieler und sieht eher wie ein Feind aus, anstatt wie die derzeitige weiße Farbe.

Im Abschnitt „Materialien“ im Details-Panel siehst du, dass es zwei Elemente gibt. MI_Manny_01_New ist das Material, das verschiedene Stellen des Feind-Modells beeinflusst, darunter die Oberarme, Beine und Kopf. MI_Manny_02_New ist das Material, das sich auf die Unterarme und den Torso auswirkt.

1. Neben der Eigenschaft Element 0 klicke auf die Schaltfläche Durchsuchen im Inhaltsbrowser, der wie ein Ordner und eine Lupe aussieht. Dadurch wiird die Inhalts-Schublade geöffnet und das ausgewählte Material durchsucht. Du wirst feststellen, dass das zweite Material, MI_Manny_02_New, ebenfalls hier ist.

2. Klicke mit der rechten Maustaste auf das Asset MI_Manny_01_New und klicke auf Materialinstanz erstellen. Dadurch wird eine Instanz des ausgewählten Materials erstellt. Eine Material-Instanz erbt alles vom Parent-Material und du kannst Parameter überschreiben, die du modifizieren möchtest. Du kannst beispielsweise die Farbe ändern, aber alle anderen Einstellungen, wie z. B. den Glanz des Materials, unverändert lassen.

   Bei der Erstellung einer neuen Material-Instanz weist die Unreal Engine dem neuen Asset automatisch einen Namen zu und verwendet das MI-Präfix. In diesem Fall steht MI für Material-Instanz. Du kannst eine Instanz eines Materials oder eine Material-Instanz erstellen, um weiterhin bestehende Materialien zu verzweigen. 

3. Nenne das Material-Instanz Asset MI_Enemy_01 und mache einen Doppelklick darauf, um es zu öffnen.

4. Vergrößere im Details-Panel auf der rechten Seite 01 - BaseColor und schalten die Eigenschaft Farbtönung um. Klicke auf das Farbfeld neben der Eigenschaft „Farbtönung“ und wähle im Farbwähler eine rote Farbe aus.

   Für dieses Tutorial haben wir uns für eine knallrote Farbe entschieden, die du verwenden kannst, indem du den Farbcode F60E6EFF in das Feld Hex sRGB in der unteren rechten Ecke des Farbwählers einfügst.

5. Klicke auf die Schaltfläche Speichern in der oberen linken Ecke des Materialfensters und schließe es.

6. Gehe als Nächstes erneut in den Inhaltsbrowser, klicke diesmal mit der rechten Maustaste auf das Asset MI_Manny_02_New und klicke auf Materialinstanz erstellen. 

7. Nenne diese Material-Instanz MI_Enemy_02 und wiederhole die vorherigen Schritte auch für dieses Material.

Nachdem du die Schritte wiederholt hast, solltest du über zwei neue Material-Instanzen verfügen, MI_Enemy_01 und MI_Enemy_02. Stelle sicher, dass du beide Material-Instanz-Assets mithilfe der Schaltfläche „Speichern“ in den Material-Editor-Fenstern speicherst.

Weise diesen Materialien als Nächstes dem feindlichen Charakter zu. Öffne den Blueprint BP_Enemy im Blueprint-Editor Fenster und durchsuche im Details-Panel den Abschnitt Materialien. Klicke auf die Dropdown-Liste für Element 0 und wähle das neu erstellte Material MI_Enemy_01 aus. Und wähle für Element 1 das Material MI_Enemy_02.

Dein feindlicher Charakter sollte jetzt rot sein und die neuen Material-Instanz Assets verwenden.

Richte den Feind ein, wenn das Gameplay startet

Nachdem der Feind nun visuell bereit ist, erstellen wir die Gameplay-Funktionalität. Zunächst richtest du die Eigenschaften ein, die der Feind beim Spawnen haben soll.

Befolge diese Schritte:

1. Geh im BP_Enemy Blueprint-Editor-Fenster auf den Tab EventGraph, der sich neben dem Tab Viewport befindet. Standardmäßig verfügst du über drei Events, über denen Kommentare darüber: Event BeginPlay, Event ActorBeginOverlap und Event Tick. Wähle den ActorBeginOverlap aus und lösche ihn, da er für dieses Tutorial nicht benötigt wird.

2. Ziehe zuerst über das Komponenten-Panel die Komponente Charakterbewegung in das Event-Diagramm. Dadurch erstellst du einen Knoten mit dem Namen Charakter-Bewegung. Ziehe den Pin dieses Knoten und erstelle einen Knoten Max. Gehgeschwindigkeit festlegen.

3. Klicke mit der rechten Maustaste auf den grünen Pin Max. Gehgeschwindigkeit des Knotens Set und wähle im Kontextmenü die Option Beförderung zu Variable aus. Damit erstellen eine neue Variable, die im Mein Blueprint-Panel auf der linken Seite des Blueprint-Editor unter der Variablen-Liste sichtbar ist.

4. Benenne die Variable in Max Geschwindigkeit um. Klicke auf das Augen-Symbol neben der Variable, um diese in eine öffentliche und bearbeitbare Variable umzuwandeln. Kompiliere den Blueprint und lege im Details-Panel den Standardwert von Max. Geschwindigkeit auf 200 fest.

   Da diese Variable öffentlich ist, kannst du ihren Wert im Level festlegen, wenn du einen Feind in deinen Level hinzufügst. Wenn du jedoch vergessen würdest, seinen Wert zu ändern, und der Standardwert auf 0 gesetzt wäre, könnte sich der Feind nicht bewegen. Durch Festlegen des Standardwerts auf 200 kannst du sicherstellen, dass der Feind über genügend Bewegungsgeschwindigkeit verfügt, um sich fortbewegen zu können.

5. Füge in der Variablenliste eine neue Variable mit dem Namen CurrentHP des Typs Float hinzu.  

6. Füge eine weitere Variable namens Eliminiert hinzu und ändere ihren Typ in Boolesch.  

7. Ziehe die Variable CurrentHP aus der Liste Variablen in das Event-Diagramm und klicke auf die Option Aktuellen KP festlegen im Kontextmenü. Ziehe den Pin Exec des Knotens „Max. Geschwindigkeit“ festlegen und verbinde ihn mit dem Knoten Aktuellen KP festlegen Exec Pin.  

   

8. Klicke im Knoten Aktuelles KP festlegen mit der rechten Maustaste auf den Float-Pin Aktuelles KP und klicke auf Beförderung zu Variable.

9. Benenne die Variable in TotalHP um. Lege den Typ auf Float fest und klicke auf das Augensymbol, um ihn öffentlich und bearbeitbar zu machen. Lege im Details-Panel die Kategorie auf Einrichtung fest. Kompiliere den Blueprint und lege den Standardwert auf 100 fest.

     Es ist wichtig, zwei Variablen zu haben, die den Gesundheitswert des Feinds verfolgen, da eine Variable, die Gesamt-KP, speichert, mit wie viel Gesundheit der gegnerische Charakter beginnt, während die Variable Aktuelle KP verfolgt, wie viel Gesundheit der Feind zu jedem Zeitpunkt hat, auch nachdem er Schaden vom Spieler erlitten hat. Wenn du die Variable „Gesamt-KP“ öffentlich machst, kannst du diesen Wert für jede Instanz eines feindlichen Charakter-Blueprints in deinem Level anpassen, d. h. du kannst die Stärke jedes Feindes anpassen, um es dem Spieler leichter oder schwerer zu machen, ihn zu besiegen.

10. Du wirst viele Actions mit dem Spieler-Charakter in diesem Event-Diagramm ausführen, so speichere als Nächstes eine Referenz zum Spieler-Charakter als Variable. Erstellen in der Liste Variablen eine neue Variable mit dem Namen PlayerRef und ändere ihren Typ in Charakter (Objekt-Referenz).

    

    Das Erstellen einer Referenzvariable für das Character-Objekt ist für die Performance deines Projekts besser, als jedes Mal, wenn du auf den Spieler verweisen musst, die Funktion Spieler-Charakter abrufen aufzurufen.

11. Verbinde nach dem Knoten Aktuelle KP festlegen einen Knoten PlayerRef festlegen. Verbinde für den Input-Pin „Spieler Ref“ einen Knoten „Spieler-Charakter abrufen“. Stelle sicher, dass der Wert Spieler Index dieses Knoten auf 0 festgelegt ist. Dies ist der Standardindex für den ersten Spieler-Charakter, der im Level spawnt.

12. Verbinde die Logik, die du erstellt hast, mit dem Event „BeginPlay“ Funktionsknoten. Dein EventGraph sollte wie folgt aussehen:

    

Lass den Feind den Spieler verfolgen

Als Nächstes erstellst du die Logik, um den Feind auf den Spieler zuzubewegen. Du kannst dazu tun, indem du ein Benutzerdefiniertes Event erstellen, das den anderen Event-Knoten, etwa BeginPlay ähnelt, aber ein benutzerdefinierter Event ist, das du von überall im Blueprint aufrufen kannst, ohne die Logik neu erstellen zu müssen.

Um einen benutzerdefinierten Event zu erstellen, führe die folgenden Schritte durch:

1. Klicke mit der rechten Maustaste auf eine beliebige Stelle im Event-Diagramm und gib Benutzerdefinierter Event in das Suchfeld ein. Klicke in der Liste auf die Option Benutzerdefiniertes Event hinzufügen und rufe den Event MoveToPlayer auf.

2. Ziehe den Pin des neu erstellten Event-Knoten MoveToPlayer und gib KI MoveTo in das Suchfeld ein. Wähle den KI MoveTo-Knoten, um ihn zu erstellen. 

   Der Knoten KI MoveTo ist ein Event, mit dem sich Pawns mit KI-Controller an einen bestimmten Ort bewegen können. In diesem Fall wirst du ihn nutzen, um den Feind zum Spieler zu bewegen.

3. Auf dem Knoten KI MoveTo ziehe den Pin Pawn und gib Selbst in das Suchfeld ein. Wähle die Option Referenz auf sich selbst erhalten aus, um einen Knoten zu erstellen, der auf den Actor dieses Blueprints in-game verweist.

4. Ziehe als Nächstes den Pin Ziel-Actor des Knotens KI MoveTo und erstelle einen Knoten vom Typ PlayerRef erhalten.

In diesem Fall definierst du den Pawn als diesen Feind, indem du den Eigen-Knoten verwendest, der verwendet wird, um zu definieren, welcher Actor in Bewegung ist. Dann legst du den Ziel-Actor der das Ziel, auf den sich der Pawn bewegen wird, auf den Spieler-Charakter im Level fest.

Der Knoten KI MoveTo verfügt über die Events Bei Erfolg und Bei Fehlgeschlagen. Mit ihnen definierst du, was passiert, wenn der Feind den Spieler erreicht, oder wenn dies fehlschlägt.

1. Ziehe den Pin Bei Erfolg und erstelle einen Verzögerungs-Knoten.

2. Klicke mit der rechten Maustaste auf den Pin Dauer des Knoten Verzögerung und wähle Beförderung zu Variable aus.

3. Nenne diese Variable WaitAtDestination, deren Typ standardmäßig auf Float festgelegt ist.

4. Kompiliere den Blueprint, wähle die WaitAtDestination -Variable und ändere den Standardwert auf 5 fest. Klicke auf das Augensymbol, um es bearbeitbar zu machen, und ändere die Kategorie in Einrichtung.

5. Ziehe als Nächstes im Event-Diagramm den Knoten Verzögerung des Pins Exec und erstellen einen Zu Spieler verschieben Knoten. Dadurch wird das von dir erstellte Event Zu Spieler verschieben auch dann ausgeführt, wenn der Feind den Spieler erreicht, aber nach einer bestimmten Zeit.

6. Ziehe als Nächstes auf dem Knoten KI MoveTo den Pin Bei Fehlgeschlagen und erstelle einen neuen Verzögerungs-Knoten. Ziehe den Pin Abgeschlossen dieses Knotens und erstelle einen Knoten vom Typ Zu Spieler verschieben. Belass das Feld Dauer dieses Verzögerungsknotens bei 0,2.

Dies stellt sicher, dass sich der Feind auch dann weiterbewegt, wenn er den Spieler nicht erreicht.

Kehren wir zurück zum Event BeginPlay-Knoten. Verbinde am Ende dieser Sequenz nach dem Knoten Spieler-Referenz festlegen einen Knoten Zu Spieler verschieben, um diesen Event auszulösen. Das bringt den Feind zu Beginn des Spiels in Bewegung, sodass du die Bewegung des Feinds testen kannst.

Es sollte so aussehen:

Dein gesamter Blueprint sollte jetzt so aussehen:

Dem Spieler Schaden zufügen

Machen wir weiter und fügen wir dem Spieler Schaden zu, wenn der Feind ihn erreicht. In diesem Tutorial erstellst du einen Feind, der sich bei Kontakt mit dem Spieler selbst zerstört, also fügst du eine Logik hinzu, um diesen Feind zu entfernen, nachdem er dem Spieler einmal Schaden zugefügt hat.

Befolge diese Schritte:

1. Im Komponenten-Panel wähle die Kapsel-Komponente (CollisionCylinder) aus.

2. Klicke im Details-Panel im Abschnitt Events auf Hinzufügen (+) neben „Bei Komponententreffer“. 

   

   Dies erstellt einen neuen Event-Knoten im Event-Diagramm, der ausgeführt wird, wenn die Komponente (in diesem Fall die ausgewählte Kapsel-Komponente) auf etwas trifft.

3. Ziehe den Pin des Knotens Bei Komponententreffer und erstelle einen Verzweigungs-Knoten. Ziehe den Pin Bedingung-des Verzweigungsknoten zum Pin Andere Actor des Bei Komponententreffer-Knoten, der dich auffordert, einen neuen Knoten zu erstellen.

4. Erstelle einen Equal Knoten, der überprüft, ob der vom „Bei Komponententreffer“-Knoten erkannte Andere Actor der beabsichtigte Actor ist, in diesem Fall der Spieler-Charakter. Ziehe den Pin Wähle Asset des Equal-Knoten ab und füge eine Referenz auf die PlayerRef-Variable hinzu.

   Das löst einen Event aus, wenn die feindliche Kapsel-Komponente etwas im Spiel trifft. Dieser Event überprüft, ob das andere Objekt, das die Kapsel-Komponente getroffen hat, der Spieler-Charakter ist. Mit dieser Information wird der Schaden auf den Spieler angewendet.

5. In diesem Tutorial erstellst du einen Feind, der den Spieler einmal trifft und sich selbst zerstört. Um sicherzustellen, dass sie den Spieler nur einmal schädigen, ziehe den Verzweigungs-Knoten True-Pin ab und erstelle einen Einmal machen-Knoten.

6. Aus dem Pin Abgeschlossen des Eimal machen-Knotens erstelle einen Schaden anwenden-Knoten. Aus dem Pin Beschädigter Actor ziehe und verbinde eine Referenz mit der Variable PlayerRef, um diese als den Actor zuzuweisen, dem der Schaden zugefügt werden soll.

7. Klicke dann mit der rechten Maustaste auf den Pin Basisschaden und wähle Beförderung zu Variable aus. Klicke in der Liste Variablen auf das Augen-Symbol von Basis Schaden, um es bearbeitbar zu machen, und ändere seine Kategorie zu Einrichtung. Kompiliere den Blueprint und lege den Standardschaden auf 25 fest.

8. Ziehe als Nächstes die Variable Eliminiert aus der Liste Variablen in das Event-Diagramm und wähle Festlegen aus.

9. Verbinde den Pin Exec des Knotens Schaden anwenden mit dem Knoten Eliminiert festlegen.

10. Schalte die Eigenschaft Eliminieren des Knoten Eliminieren festlegen auf True um.

11. Ziehe den Pin Exec des Knotens Eliminiert festlegen und erstelle einen Verzögerungs-Knoten. Lege die Dauer auf 2,0 fest.

12. Ziehe dann den Pin Exec des Knoten Verzögerung und erstelle einen Actor zerstören Knoten. Die Eigenschaft Ziel sollte standardmäßig auf Selbst festgelegt sein.

Wenn der Feind mit dem Spieler kollidiert, fügt er dem Spieler Schaden zu und killt den Feind nach einer Verzögerung von 2 Sekunden.

In dieser Phase kann der Feind auf den Spieler zulaufen, ihm Schaden zufügen und sich selbst zerstören, wenn er auf ihn trifft. Allerdings berücksichtigt es weder die Entfernung zwischen dem Spieler und dem Feind noch eventuelle Hindernisse zwischen den beiden, wie beispielsweise Wände. Der Feind wird den Spieler also immer verfolgen, egal was passiert.

Füge Entfernung- und Hindernis-Logik hinzu

Im nächsten Abschnitt dieses Dokuments erfährst du, wie du eine maximale Erkennungsreichweite festlegst, sodass der Feind den Spieler nur erkennen kann, wenn er nah genug an ihm dran ist. Im nächsten Schritt erstellst du eine Funktion, bei der der Feind den Spieler nicht durch Wände sehen kann. Der Spieler sollte sich also in der direkten Sichtlinie des Feindes befinden, um sichtbar zu sein. Dafür erstellst du zunächst eine neue Funktion in deiner Blueprint Bibliothek, die eine Linien- Trace zwischen dem Feind und dem Spieler durchführt.

Berechne Sichtlinie und Entfernung mit einer Linien-Trace

Ein Zeilen-Trace ist eine übliche Praxis in der Spieleentwicklung Linien-Traces zeichnen eine unsichtbare Linie vom Quell-Actor, die andere Spielobjekte und Actors zur Laufzeit überschneidet und erkennt. Du kannst dann die von Linien-Trace erkannten Actors und Spielobjekte verwenden, um die Spielelogik zu aktivieren. In diesem Tutorial demonstrieren wir eine Einrichtung, die einen Linien-Trace vom Feind-Charakter aus verwendet, die erkennt, wenn sich der Spieler-Charakter in der Sichtlinie des Feindes befindet. Weitere Informationen zu Linien-Traces findest du in der Dokumentation Traces mit Raycasts.

Um eine Funktion einrichten, die einen Linien-Trace verwendet, um die Entfernung und Sichtlinie zum Spieler zu testen, führe die folgenden Schritte durch: 

1. Gehe im Inhaltsbrowser in deinen Kern-Ordner und öffne die Blueprint-Bibliothek „BPL_FPGame“.

2. Füge eine neue Funktion mit dem Namen fnBPLFindPlayer hinzu.

3. Navigiere im Details-Panel der neuen Funktion zum Abschnitt „Inputs“ der Eigenschaften und füge mit Hinzufügen (+), die folgenden Input-Typen hinzu:

   • Spielerreferenz (Pawn-Objekt-Referenz)

   • Startposition (Vektor),

   • Max. Erkennungsentfernung (Float),

   • Debug (Boolean).

     

     Nachdem du diese Inputs hinzugefügt hast, wirst du feststellen, dass der Funktionsknoten „fnBPLFindPlayer“ über entsprechende Pins für jede der Variablen verfügt.

4. Navigiere als Nächstes, im Details-Panel Funktion, zu zum Abschnitt Outputs der Eigenschaften und verwende Hinzufügen (+), um eine Spieler gefunden-Boolesche-Output-Variable zu erstellen.

   

   Nach dem Hinzufügen der Variablen „Player Found Output“ wird in deinem Diagramm ein neuer Rückgabeknoten mit der Variablen „Player Found Output“ erstellt, der mit dem Einstiegsknoten verbunden ist.

5. Navigiere schließlich im Bereich „Mein Blueprint-Panel“ zum Abschnitt „Lokale Variablen“ und erstelle mit Hinzufügen (+) eine lokale Variable „PlayerFound“ (Boolean) und stelle sicher, dass ihr Standardwert „False“ ist.

   

Als Nächstes musst du eine Fehlerprüfung für den Spieler-Input hinzufügen. Um diese Prüfung hinzuzufügen, führe die folgenden Schritte durch:

1. Lösche den Draht zwischen dem Einstiegsknoten und dem Rückgabeknoten, indem du die ALT-Taste gedrückt hältst und auf den Exec-Pin entweder am Einstiegsknoten oder am Rückgabeknoten klickst.

2. Nach dem Knoten „Funktionseintrag“ erstelle einen Knoten Ist gültig und verbinde ihn. Nachdem du den Knoten erstellt hast, ziehst du den Spieler-Referenz-Pin vom Einstiegsknoten und verbindest ihn mit dem Input-Objekt-Pin am Knoten „Ist gültig“. „Ist gültig“ ist eine Bibliotheksfunktion, die jeder Blueprint verwenden kann, und die Spieler-Referenz ist entscheidend für die ordnungsgemäße Ausführung dieser Funktion. Füge daher eine Bedingung für eine ungültige Spieler-Referenz hinzu, um Fehler zu vermeiden.

3. Verbinde den „Ist nicht gültig“ Exec-Pin mit dem Rückgabe-Knoten. Für den Gefunden-Wert, verbinde eine Referenz mit der PlayerFound-Variable. Dies beendet die Funktion und gibt PlayerFound=False an das Event-Diagramm des Feinds zurück.

   

Um den Linien-Trace einzurichten, führe die folgenden Schritte durch:

1. Ist der Spieler gültig, sollte die Funktion das Linien-Trace-Objekt ausführen und dann PlayerFound zurückgeben. Füge einen Sequenzknoten hinzu, um deine Logik zu organisieren.

2. Ziehe den Pin „Dann 0“ des Sequenzknotens ab und füge einen Knoten „Linien-Trace nach Kanal“ hinzu. Hinweis: Informationen zu diesem Knoten findest du hier. Was ist nach Kanal? Irgendwelche Dokumente, die man dazu verlinken kann.

3. Richte den Knoten Line-Trace nach Kanal ein:

   • Ziehe vom Knoten „Eingang“ den Pin „Startposition“ und verbinde ihn mit dem Start-Input-Pin des Knotens „Linien-Trace nach Kanal“. Das verwendet den Standort des feindlichen Charakters als Startpunkt des Linien-Trace.

   • Zieehe als Nächstes den Spielerreferenz-Pin vom Eingangs-Knoten an eine andere Stelle im Diagramm, dadurch öffnet sich das Kontextmenü des Blueprint-Knoten. Suche und erstelle über das Kontextmenü einen Knoten Actor-Position erhalten. Dadurch wird ein neuer Knoten erstellen, der die Spielerreferenz als Ziel-Input verwendet. Damit endet der Linien-Trace an der Position des Spielers.

   • Stelle auf dem Knoten „Line-Trace nach Kanal“ die Eigenschaft „Trace-Kanal“ auf Kamera über das Dropdown Menü ein.

   

Als Nächstes erstelle die Funktionalität, um anhand des Ergebnisses des Linien-Trace den Spieler und die Trefferentfernung zu überprüfen, indem du die folgenden Schritte ausführst:

1. Ziehe den Out-Treffer-Pin des Linien-Trace ab und füge einen Break-Treffer-Ergebnis-Knoten hinzu. Wenn ein Linien-Trace auf ein Objekt trifft, werden viele Informationen erfasst; im Rahmen dieser Logik benötigen wir jedoch nur einige wenige spezifische Werte, sodass ein Break Trefferergebnis-Knoten erforderlich ist, um die Daten in die einzelnen Komponenten der zurückgegebenen Daten aufzuteilen.

2. Klicke im Break Trefferergebnis Knoten auf den Pfeil unten, um mehr Optionen zu sehen. Der Zweck dieser Funktion besteht darin, festzustellen, ob sich der Spieler in Sichtlinie und innerhalb einer bestimmten Entfernung zum Feind befindet, sodass du den Treffer-Actor verwendest, um nach dem Spieler zu suchen, und Trace-Start und Trace-Ende verwendest, um die Entfernung zum getroffenen Objekt zu messen.

3. Ziehe den Actor treffen-Pin und füge einen Equal-Operator-Knoten hinzu. Verbinde für den unteren Input eine Referenz mit dem Funktions-Input der Spielerreferenz.

4. Erstelle einen Entfernungs (Vektor) Knoten. Verbinde V1 mit Trace-Start und V2 mit Trace-Ende. Hinweis: Ein Vektor ist eine Reihe von X-, Y- und Z -Werten, die eine Objekt- oder Position im 3D Raum repräsentieren. Der Knoten „Entfernung“ berechnet die Entfernung zwischen zwei dieser Punkte, was zu einem Float-Wert führt.

5. Ziehe den Ergebniswert des Knotens „Entfernung“ ab und füge einen Knoten „Weniger (<)“ hinzu. Verbinde für den unteren Input eine Referenz zum Funktions-Input „Max. Erkennungsentfernung“.

6. Erstelle einen AND-Knoten (Boolean) und verbindee der boolesche Output der Knoten „Gleich“ (==) und „Kleiner als“ (<) mit den Input-Pins des AND-Knotens (Boolean). Mit dieser Logik gibt der AND-Knoten „True“ zurück, wenn der Linien-Trace auf einen Actor trifft, der mit „Spielerreferenz“ übereinstimmt, und der Abstand zwischen dem Startpunkt des Traces (dem Feind) und dem Endpunkt (dem getroffenen Objekt) kleiner als „Max Entdeckungsentfernung“ ist.

   

7. Ziehe den Output des AND-Knotens, füge einen Verzweigungsknotens hinzu und richte den Knoten ein:

   • Verbinde es so, dass es nach Line-Trace nach Kanal ausgeführt wird.

   • Erstellen vom „True Exec Pin“ des Verzweigungsknotens aus einen Set-Variable Knoten, um die lokale PlayerFound- Variable auf „True“ zu setzen.

   • Erstelle vom „False Exec Pin“ des Verzweigungsknotens aus einen Set-Variable Knoten, um die lokale PlayerFound-Variable auf „False“ zu setzen.

   

8. Du bist jetzt mit der Linien-Trace Logik fertig, gehe also zurück zum Sequenz-Knoten und verbinde den „Dann 1“-Pin mit dem Rückgabe-Knoten. um die Funktion zu beenden und das Ergebnis „PlayerFound“ an den Blueprint des Feinds zurückzusenden.

Du möchtest die visuelle Debugging-Funktion des Linien-Trace im Level-Editor einfach umschalten können. Allerdings kannst du mit dem Line Trace-Knoten nur eine Option aus der Zeichnen-Debug Typ-Liste auswählen. Du kannst einen Auswählen-Knoten verwenden, um die bearbeitbare Debug-Boolean-Variable mit zwei der Zeichnen-Debug Typ Optionen zu verbinden. 

Um eine benutzerdefinierte Debug-Option für die Linien-Trace einrichtenm, führe die folgenden Schritte durch:

1. Erstelle vom Pin „Debug Typ zeichnen“ des Knotens „Linien-Trace nach Kanal“ einen Auswahlknoten.

2. Verbinde den Index-Pin des Auswahl-Knotens mit dem Debug-Funktions-Input des Eintrags-Knotens. Der Index des Auswahl-Knotens ist ein Platzhalter, sodass sich die Optionen nach dem Verbinden der booleschen Debug-Referenz in die Optionen „False“ und „True“ ändern.

3. Lege „False“ auf Keine und „True“ auf „Für Dauer“ fest.

4. Speicher und kompiliere deine Blueprint-Funktion.

   

Diese Logik verwendet die Debug-Variable, um zu bestimmen, ob die Debug-Zeichnung für Line-Trace aktiv ist oder nicht. Wenn die Debug-Variable „False“ ist, wird der Debug-Modus auf „Keine“ festgelegt, was bedeutet, dass es keine Debug Zeichnung gerendert wird. Wenn die Debug-Variable auf „True“ festgelegt ist, aktiviert der Auswahlknoten die Option „Debug-Zeichnung für Dauer“, wodurch der Linien-Trace Dauer zur Laufzeit für die Dauer ihrer Aktivität gerendert wird. Du kannst optional auch andere Optionen nutzen, z. B. „Für einen Frame“, wodurch der Linien-Trace nur für einen einzigen Frame gezeichnet wird, oder „Persistent“, wodurch die Debug-Zeichnung so lange aktiv bleibt, wie das Projekt läuft. In diesem Fall ist „Für Dauer“ die hilfreichste Methode, um den Linien-Trace beim Debuggen zu zeichnen.

Lass Feinde den Spieler verfolgen

Da du jetzt eine Funktion aufrufen kannst, die nach dem Spieler sucht und dabei Entfernung und Sichtlinie berücksichtigt, füge dem Feind eine Logik hinzu, die ihn dazu bringt, den Spieler bei Sichtkontakt zu suchen und zu verfolgen. 

Befolge diese Schritte:

1. Navigiere im Inhaltsbrowser zu Inhalt > AdventureGame > Designer > Blueprints > Charaktere, und öffne „BP_Enemy“.

2. Ziehe im Event-Diagramm den Exec-Pin des Event-Tick Knoten und erstelle einen Verzweigungsknoten. Hinweis: Das „Bei Tick-Event“, wird in jedem Frame ausgeführt, während das Spiel läuft. Verwende es, damit der Feind konstant die Position des Spielers überprüft und entscheidet, ob er die Verfolgung aufnehmen soll.

3. Ziehe den Pin „Bedingung“ des Knotens „Verzweigung“ und erstelle einen NICHT-Boolean Knoten, der den inversen Wert eines Booleschen Werts zurückgibt. In diesem Fall willst du die Eliminiert-Variable negieren. also ziehe den Pin des NICHT-Boolean-Knotens und suche nach „Eliminiert erhalten”.

   

   Damit wird geprüft, ob der Feind nicht eliminiert wurde, in diesem Fall wird mit dem True-Pin des Verzweigungsknotens fortgefahren.

4. Ziehe den Pin „True“ des Verzweigungsknotens und erstelle einen FnBPLFind Spieler-Knoten. Dieser Knoten führt einen Line-Trace durch, um den Spieler in der Welt zu finden und die aktuelle Entfernung zwischen dem Feind und Spieler zu prüfen. 

5. Auf dem Knoten „Fn BPLFind“ Spieler, stelle die folgenden Verbindungen mithilfe der Pins her:

   • Spielerreferenz: Verbinde eine Referenz mit der PlayerRef-Variable.

   • Startposition: Erstelle einen „Actor Standort abrufen“-Knoten, dessen Ziel-Eigenschaft auf „Selbst“ eingestellt ist. Dadurch wird die Startposition des Line-Trace weiterhin der eigenen Position des Feinds in der Welt zugewiesen.

   • Maximale Erkennungsentfernung: Wähle „Beförderung zu Variable“ aus, klicke auf das Augensymbol, um es bearbeitbar zu machen, und ändere die Kategorie auf Einrichtung. Lege den Standardwert nach dem Kompilieren des Blueprints auf 20000 (200 Meter). Je kleiner dieser Wert ist, desto näher muss der Spieler sein, damit Feinde ihn erkennen können.

   • Debug: Wähle Beförderung zu Variable aus und nenne sie DebugDetection. Mache diese Variable außerdem editierbar und lasse sie in der Kategorie „Einrichtung“ erscheinen.

   

Wenn der Spieler vom Line-Trace gefunden wird, möchtest du die maximale Bewegungsgeschwindigkeit des Feinds auf einen gewünschten Wert festlegen und den Feind in Richtung des Spielers bewegen. Wenn nicht, solltest du die Geschwindigkeit auf 0 festlegen, damit der Feind sich nicht auf den Spieler zubewegen kann.

1. Klicke im Knoten „FnBPLFindPlayer“ mit der rechten Maustaste auf den Pin „Gefunden“ und befördere ihn zu ieiner Variable. Dadurch wird automatisch ein Set-Knoten für die neue Variable erstellt. Verbinde ebenfalls den Ausführungs-Pin des Knotens. Nun kannst du das gefundene Ergebnis an einer anderen Stelle im Diagramm verwenden.

2. Verbinde nach dem Set-Knoten einen Verzweigungsknotens. Ziehe den Pin „Bedingung“ des Verzweigungsknotens zum Output-Pin des Set Gefunden-Knotens.

3. Ziehe im Komponenten-Panel die Character-Bewegung (CharMoveComp) in das Event-Diagramm. Ziehe den Pin und erstelle einen Knoten Set Max. Gehgeschwindigkeit festlegen

4. Ziehe den True-Pin des Verzweigungsknotens und verbinde ihn mit dem Knoten „Max. Gehgeschwindigkeit festlegen“. 

5. Aus dem Variablen-Panel ziehe die Variable „Max Geschwindigkeit“ in das Event-Diagramm, wähle „Erhalten“ und verbinde sie mit dem Pin „Max Gehgeschwindigkeit“ des Knotens „Set“.

6. Dupliziere als Nächstes die Knoten „Max. Gehgeschwindigkeit festlgen“ und „Charakter-Bewegung“. Verbinde den False-Pin des Verzweigungsknotens mit dem neuen Set-Knoten. 

7. Lege die Max. Gehgeschwindigkeit-Eigenschaft auf 0 fest.

   Dadurch wird die Bewegung des Feinds gestoppt, ohne dass dessen KI-MoveTo Aufgabe abgebrochen wird und die Aufgabe erneut ausgeführt werden muss.

8. Verbinde nach dem Set-Knoten, der mit dem True-Pin des Verzweigungsknotens verbunden ist, einen MoveToPlayer-Knoten, um diesen Event aufzurufen und den Feind nur dann zu verschieben, wenn sie den Spieler gefunden haben.

9. Da der Feind nun in jedem Frame nach dem Spieler sucht, lösche den „Zu Spieler verschieben“-Knoten, den du am Ende der Event „BeginPlay“ Logik eingefügt hast. Dieser Knoten war nützlich zum Testen eines teilweise abgeschlossenen Feind, aber du brauchst ihn nicht mehr. 

10. Gehe zu der MoveToPlayer Event-Logik. Du möchtest nun, dass der Feind dies nur ausführt, wenn der Spieler gefunden wurde:

    1. Lösche den Draht zwischen dem Event-Knoten und KI Verschieben nach. Verbinde eine Verzweigung zwischen diesen beiden Knoten, indem du den True-Pin des Verzweigungsknotens verwendest.

    2. Füge für die Bedingung der Verzweigung eine Referenz zur Gefunden-Variable hinzu.

    

Befindet sich der Spieler innerhalb der vorgegebenen Entfernung zum Feind und befinden sich keine Hindernisse zwischen ihnen, wird das Bewegung des Gegners auf die MaxSpeed-Variable festgelegt und er führt die MoveToPlayer-Logik aus. Wenn eine dieser Bedingungen nicht erfüllt ist, wird die Bewegungsgeschwindigkeit des Feind auf 0 festgelegt, sodass er sich nicht mehr auf den Spieler zubewegen kann.

Erlaube Feinden, Schaden zu erleiden

Bevor du den Blueprint abschließt, musst du sicherstellen, dass der Feind ebenfalls Schaden erleiden kann. Befolge diese Schritte:

1. Klicke mit der rechten Maustaste auf eine beliebige Stelle im Event-Diagramm und erstelle einen Event „AnyDamage“-Knoten.

2. Ziehe die CurrentHP-Variable in das Event-Diagramm und wähle CurrentHP festlegen.

3. Du ziehst den verursachten Schaden von der CurrentHP ab. Ziehe zuerst den Exec Pin des Events „AnyDamage“ und verbinde ihn mit dem Set-Knoten.

4. Ziehe den Pin der Eigenschaft Aktuelles KP und erstelle einen Subtrahieren-Knoten.

5. Ziehe den unteren Pin des Subtrahieren-Knoten ab und verbinde ihn mit der Schaden-Eigenschaft des Event AnyDamage-Knoten.

6. Ziehe dann den oberen Pin des Knotens „Subtrahieren“ und erstelle einen Knoten „Aktuelle KP abrufen“.

   

Wenn diesem Actor also Schaden zugefügt wird, wird der Wert der Variablen „CurrentHP“ genommen, der Schaden davon abgezogen und der Wert von „CurrentHP“ auf den neuen Wert festgelegt.

Prüfen wir als Nächstes, ob CurrentHP kleiner oder gleich 0 ist, was den Feind killen sollte.

1. Ziehe den Pin des Knotens-Set und erstelle einen neuen Verzweigungsknoten.

2. Ziehe den Pin „Bedingung“ des Knotens „Verzweigung“ und erstelle einen Knoten „Kleiner gleich“ (<=).

3. Ziehe den oberen Pin und erstelle einen neuen Knoten vom Typ CurrentHP erhalten. Stelle sicher, dass die Eigenschaft des unteren Pins auf 0 festgelegt ist.

4. Ziehe den Pin „True“ des Verzweigungsknotens und erstelle einen Knoten „Einmal machen“. Ziehe den Abgeschlossen-Pin und erstelle einen-Knoten Eliminiert festlegen.

5. Im Set Knoten schalte die Eigenschaft „Eliminiert“ auf „True“ um.

6. Verbinde nach dem Set-Knoten einen Verzögerungs-Knoten, dessen Dauer auf 2 gesetzt ist.

7. Ziehe schließlich den Pin „Abgeschlossen“ des Verzögerungsknotens und erstelle einen „Actor zerstören“-Knoten, dessen Eigenschaft „Ziel“ auf „Selbst“ festgelegt ist.

   

Stelle sicher, dass du den Blueprint speicherst und kompilierst.

Erstellen eines NavMesh für die Navigation des Feindes

Bevor du den Gegner zu einem Level hinzufügen und ihn den Spieler verfolgen lassen kannst, musst du das NavMesh erstellen, das die Feind-KI zur Navigation im Level verwendet. 

NavMesh ist die Abkürzung für Navigationsmesh und kann verwendet werden, um Bereiche im Level zu definieren, innerhalb derer die KI navigieren kann. Durch die Erstellung eines NavMesh in diesem Tutorial definierst du einen Bereich, in dem sich der Feind bewegen kann, um den Spieler zu verfolgen.

Verlasse den „BP_Enemy“-Blueprint-Editor und wechsle zum Level-Editor in der Unreal Engine. Klicke in der Haupt-Symbolleiste auf die Schaltfläche „Hinzufügen“, navigiere zu „Volumen“ und erstelle ein „Nav Mesh Grenzen Volumen“. Damit erstellst du ein Objekt, mit dem du für die KI in deinem Projekt eine navigierbare Zone zuweisen kannst.

Wenn du die grünen Zonen nicht sehen kannst, drücke die Taste P auf deiner Tastatur, um die Debug-Ansicht umzuschalten. Hiermit kannst du NavMesh-Details im Level-Viewport betrachten, - darunter die navigierbaren Zonen im Level und textbasierte Debug-Informationen auf der linken Seite des Level-Viewport.

Mit den Transformationswerkzeugen kannst du das NavMesh bewegen und skalieren (W und R Tasten auf der Tastatur), um die NavMesh-Grenzen anzupassen. Skaliere diese Zone nach ihren Wünschen. In diesem Fall hast du das NavMeshBoundsVolume-Objekt ausgewählt und solltest es auf 6, 7, 1 in den X-, Y-, Z-Feldern im Details-Panel unter dem Abschnitt „Transformieren“ skalieren.

Wenn du das NavMesh skalierst und verschiebst, wirst du sehen, dass sich die grünen Zonen mit der Größe des Begrenzungsrahmens ausdehnen – es sei denn, du hast Objekte, die als Hindernisse gelten, wie z. B. Würfel.

Die roten ausgeschnittenen Teile bedeuten, dass sie in deinem Spiel für die KI nicht navigierbar sind.

Tipp: Wenn der Unreal Editor etwas in das NavMesh einfügt, das nicht sein sollte, wähle dieses Mesh-Level-Objekt aus und deaktiviere im Details-Panel „Kann jederzeit die Navigation beeinflussen“.

Hinzufügen des Feind zum Level

Nachdem du den NavMesh-Bereich für Deine feindlichen Charaktere erstellt und definiert hast, kannst Du diese zu deinem Level hinzufügen.

Öffne den Inhaltsbrowser und navigiere zum Speicherort deines Feind-Blueprints. Ziehe den Feind-Blueprint in den Level-Viewport und platziere ihn vor dem Spieler. Stelle sicher, dass beide innerhalb der Grenzen des NavMesh sind, das bedeutet in den grünen Zonen.

Wähle den Feind-Actor im Level-Viewport oder in den Outliner-Panels aus. Im Details-Panel werden die Variablen angezeigt, die du im Blueprint in den Abschnitten „Standard“ und „Einrichtung-Eigenschaft“ hinzugefügt hast. Du kannst diese Werte ändern, um deine Projektanforderungen zu erfüllen, oder die Debug-Erkennungsvariable aktivieren, um eine Debug Zeichnung des Linien-Trace zu einschalten.

Wenn du das Spiel jetzt spielst, bewegt sich der Feind je nach Entfernung zwischen ihm und dem Spieler möglicherweise nicht. Wenn du dich dem Feind näherst, sollte er beginnen, den Spieler zu verfolgen. 

Versuchen wir es mit einem Hindernis. Beende den Spielmodus und füge einen Würfel in der Mitte der grünen Zone hinzu, indem du auf die Schaltfläche „Hinzufügen“ in der Haupt-Symbolleiste klickst und „Formen“ > „Würfel“ auswählst. Dadurch wird der Ausschnitt ausgeführt, da ein Würfel automatisch als Hindernis betrachtet wird.

Wenn der Spieler sich hinter dem Würfel befindet, kann der Feind den Spieler nicht verfolgen, da der Line-Trace vom Würfel blockiert wird, wodurch der Feind den Spieler nicht finden kann. Wenn der Spieler um den Würfel herumgeht und der Feind direkten Sichtkontakt zum Spieler hat, verfolgt er den Spieler weiter.

Wenn etwas nicht wie vorgesehen funktioniert, überprüfe bitte noch einmal, ob die Variablen, die du im Blueprint erstellt hast, in BP_Enemy in der Szene die richtigen Werte haben. Wenn du die Werte für Max Geschwindigkeit oder Max Erkennungs-Entfernung nicht festlegst, wird sich die Feind KI nicht bewegen. Dasselbe könnte passieren, wenn die Werte zu niedrig sind.

Entwerfen von Feindorten in deinem Projekt

Für unseren Sample-Level haben wir mehrere Feinde in Flur 3 und Raum 3 platziert. Der erste Feind wurde allein in Flur 3 platziert, um dem Spieler eine einfache erste Begegnung zu ermöglichen, damit er den Feindcharakter und dessen Fähigkeiten kennenlernen und sich mit ihnen vertraut machen kann.

Nachdem wir dem einzelnen Feind im Flur begegnet waren, platzierten wir zwei weitere Feindcharaktere in Raum 3, um den Spieler vor eine größere Herausforderung zu stellen. Du kannst die Anzahl und Variante der Feinde verwenden, um in deinem Projekt verschiedene Levels an Schwierigkeitsgraden zu erzielen. Indem den Spielern nach und nach neue Gegner und Herausforderungen vorgestellt werden, entsteht eine ausgewogenere Schwierigkeitsgrad-Kurve, an die sich der Spieler mit der Zeit gewöhnen kann. Eine schwierige Begegnung mit einem Feind zu erstellen, nachdem der Spieler gelernt hat, sich zu orientieren und Feinde zu besiegen, stellt eine Herausforderung dar, die sich für den Spieler dann als lohnend anfühlen kann.

Als Nächstes

Im nächsten Modul erfährst du, wie du eine Sprint-Mechanik erstellst, mit der der Spieler Räume und Herausforderungen mit einer höheren Bewegungsgeschwindigkeit bewältigen kann. Dies kann dazu verwendet werden, dem Spieler ein Gefühl von mehr Effizienz bei der Navigation durch Räume zu vermitteln und ihm gleichzeitig ein Werkzeug an die Hand zu geben, mit dem er den Feinden ausweichen kann, die du gerade zum Projekt hinzugefügt hast.

Füge dem Spieler einen Sprint-Mechanik hinzu

Konfiguriere das Input Action Asset für den Spieler-Charakter, damit sie die zusätzliche Bewegung zum Sprinten hat.