Einen Feind erstellen

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

Zunächst erstellst du wie in den vorherigen Tutorials die Logik für den Gegner mithilfe des Blueprint-Visual-Scripting-Systems. Anschließend erstellst du das Navigations-Mesh, um die Zonen zu definieren, durch die vom KI-Controller gesteuerte Charaktere während des Spiels navigieren können.

Bevor du anfängst

Stelle sicher, dass du diese Themen verstehst, die im vorherigen Abschnitt von Entwerfen eines Rätsel-Abenteuers behandelt wurden:

• Blueprints und Blueprint-Funktionen

Du benötigst aus Erstellen eines Schlüssels folgende Assets:

• Blueprint-Funktionsbibliothek BPL_FPGame

Erstellen eines NavMesh für die Navigation des Gegners

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 Navigations-Mesh und definiert Bereiche im Level, 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.

Befolge diese Schritte, um dem Level ein Navigations-Mesh hinzuzufügen:

1. Klicke im Level-Editor von Unreal Editor in der Haupt-Symbolleiste auf die Schaltfläche Erstellen, navigiere zu Volumes und wähle Nav-Mesh-Grenzen-Volumen. Dies erstellt eine navigierbare Zone für die KI in deinem Projekt. 

   

2. Verwende die Transformationswerkzeuge, um das NavMesh in deinem Level so zu verschieben, dass es sich mit dem Boden überschneidet.

3. Drücke die Taste P auf der Tastatur, um die Debug-Ansicht umzuschalten. Verwende dies, um die NavMesh-Details im Level-Viewport anzuzeigen – einschließlich der navigierbaren Zonen im Level sowie textbasierter Debug-Informationen auf der linken Seite des Viewport. 

   Wenn du in den Debug-Infos die Meldung „NavMesh muss neu erstellt werden“ siehst, navigiere in der Menüleiste zu Build > Pfade erstellen. Dies erstellt dein NavMesh neu.

4. Fahre fort, das NavMesh zu verschieben und zu skalieren (W- und R-Tasten auf deiner Tastatur), um die NavMesh-Grenzen zu verändern. Skaliere dieses Volumen nach deinen Wünschen. 

   Stelle sicher, dass der untere Teil des NavMesh niedrig genug ist, um vertiefte Bodenstücke einzuschließen, und dass der obere Teil des NavMesh hoch genug ist, um die Höhe des Gegners zu berücksichtigen. 

   Wenn du das Tutorial-Beispiel-Level verwendest, erstelle und skaliere zwei NavMesh-Grenzvolumen, sodass sie Flur 3 und Raum 3 ausfüllen.

   

   Wenn du das NavMesh skalierst und verschiebst, siehst du, dass sich die grünen Zonen mit der Größe des Begrenzungsrahmens ausdehnen – es sei denn, es sind Hindernisse vorhanden, wie zum Beispiel Würfel. Alle Teile, die rot abgeschnitten sind, zeigen, dass sie in deinem Spiel für die KI nicht navigierbar sind.

Einen Feind erstellen

Du erstellst den Gegner aus der Charakterklasse, da diese bereits über Bewegungs- und Animationsfunktionen verfügt, die für einen humanoiden Gegner sinnvoll sind. Die Charakterklasse erweitert Pawn, einen allgemeineren „kontrollierbaren Actor“, der für Dinge wie Fahrzeuge, Kameras oder nicht-humanoide Kreaturen verwendet wird. Für Gegner in Menschenform ist der Charakter der bessere Ausgangspunkt.

Da du diesen Charakter von Grund auf neu erstellst, fügst du ein Mesh hinzu, um den Gegner visuell darzustellen, und spielst eine Animation mit einem Animations-Blueprint ab. Der Animations-Blueprint 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. Navigiere im Inhaltsbrowser zu Inhalt > AdventureGame > Designer > Blueprints > Charaktere.

2. Klicke mit der rechten Maustaste auf eine leere Stelle im Inhaltsbrowser und wähle die Option Blueprint-Klasse aus.

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

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

Beim Erstellen einer Blueprint-Klasse wählst du eine Parent-Klasse aus, auf der aufgebaut werden soll. Dieses Parent-Element verfügt bereits über integrierte Funktionen. Wenn du zum Beispiel Blueprints aus der Actor-Klasse erstellt hast, hast du mit einer Transformation und der Fähigkeit begonnen, Komponenten zu speichern und Logik auszuführen. Wenn du nun mit der Charakterklasse beginnst, erhältst du auch Unterstützung für Bewegung, Kollision und Animation. Die Basisklasse verwendest du ähnlich wie eine Vorlage. Wenn du Funktionalität hinzufügst, erweiterst du diese Basisklasse. 

Ö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). Alle Charakterklassen verfügen über eine Charakterbewegungskomponente. Klicke auf die Komponente und sieh dir das Details-Panel an, um alle Einstellungen zu sehen. Du überschreibst einige dieser Einstellungen, wenn du die Gegner in deinem Projekt erstellst.

Hinzufügen eines 3D-Modells zum Gegner

Dein Charakter verfügt auch über eine Mesh-Komponente, aber statt eines statischen Mesh ist diese Komponente ein Skelett-Mesh. Die statischen Meshs, mit denen du bisher gearbeitet hast, sind feste 3D-Modelle, die sich nicht bewegen, während ein Skelett-Mesh ein internes Skelett hat und animiert sowie verformt werden kann.

Richte zuerst das Mesh und die Animationen des Charakters ein. Befolge diese Schritte:

1. Wähle die Mesh-Komponente aus und sieh dir das Details-Panel an. Suche die Mesh-Kategorie und klicke auf das Dropdown-Menü neben Skelett-Mesh-Asset. Suche in der Liste nach dem Modell SKM_Manny_Simple und wähle es aus. Dies weist dem Blueprint das Manny-Modell zu.

2. Wechsle im Details-Panel zur Kategorie Animation. Klicke auf die Dropdown-Liste neben Animationsklasse und weise den Animations-Blueprint ABP_Unarmed zu. Jetzt sollte der Gegnercharakter im Viewport-Tab eine Idle-Animation abspielen.

   

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

   1. Klicke in der Eigenschaft Animationsklasse des Gegner-Mesh neben ABP_Unarmed auf Im Inhaltsbrowser zum Asset navigieren.

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

   3. Navigiere zu der Logikgruppe, die auf den Then 1-Pin des Sequence-Knotens folgt. 

   4. Du möchtest nicht, dass die Beschleunigungsprüfung hier verhindert, dass sich die feindlichen Charaktere bewegen. Entferne daher die Verbindung zwischen dem „And“-Knoten und dem „Set Should Move“-Knoten.  

   5. Verbinde den Output-Pin des Knotens Greater (>) mit dem Pin Should Move, und umgehe so die Beschleunigungsprüfung.

      

   6. Kompiliere, speichere und schließe den Blueprint.

Im Viewport kannst du eine zylindrische Kapselform um den gegnerischen Charakter sehen. Dies ist eine visuelle Darstellung der Kapsel-Komponente, die Kollisionen mit anderen Objekten, einschließlich des Bodens, erkennt. Das Mesh des Charakters hat eine komplexere Form. Daher glättet ein einfacher Kollisionszylinder die Form, um die Leistung der Kollisionserkennung zu verbessern.

Das Mesh ist versetzt und nicht an der Kapsel ausgerichtet. Um die Mesh-Linie des Charakters an der Kapsel-Komponente auszurichten, bewege den Charakter nach unten, sodass die Füße den unteren Teil der Kapsel-Komponente berühren.

Befolge diese Schritte, um das Charakter-Mesh an seinem Kollisionsvolumen auszurichten:

1. Wähle erneut die Mesh-Komponente aus, um das 3D-Modell hervorzuheben.

2. Verwende im Details-Panel das Feld Standort der Kategorie Transformieren, um die Z-Achse zu ändern, das letzte Feld mit blauer Farbe. Leg den Wert auf -96 fest.

Jetzt sind beide Komponenten im Ursprung zentriert, sodass der Gegner im Spiel nicht über dem Boden schwebt.

Zu guter Letzt siehst du, dass der Charakter eine Pfeil-Komponente (Pfeil) hat. Der Pfeil zeigt die nach vorne gerichtete Richtung des Blueprint an. Achte darauf, dass dieser Pfeil in die Richtung zeigt, in die das Mesh zeigt, damit der Charakter in die richtige Richtung läuft.

Befolge diese Schritte, um das Charakter-Mesh nach vorne auszurichten:

1. Wähle erneut die Mesh-Komponente aus. Verwende das Dreh-Gizmo oder die Kategorie Transformieren des Details-Panels, um den Charakter um 90 Grade auf der Z-Achse zu drehen. Der letzte Drehung-Wert sollte -90 sein.

Falsche Ausrichtung	Korrekte Ausrichtung

Ändern des Materials des 3D-Modells

Bevor du mit der Erstellung der Funktionalität fortfährst, ändere die Farbe des Gegnermodells in Rot. Dadurch unterscheidet es sich vom Spieler und sieht eher als bei der derzeitigen weißen Farbe wie ein Gegner aus.

Befolge diese Schritte, um dem Gegnercharakter eine andere Farbe zu geben:

1. Im Abschnitt Materialien im Details-Panel gibt es zwei Elemente:

   • MI_Manny_01_New ist das Material, das verschiedene Stellen des Gegnermodells beeinflusst, darunter die Oberarme, Beine und den Kopf.

   • MI_Manny_02_New ist das Material, das sich auf die Unterarme und den Torso auswirkt.

2. Klicke neben Element 0 auf die Schaltfläche Im Inhaltsbrowser durchsuchen, die wie ein Ordner mit einer Lupe aussieht. Damit öffnest du den Ordner mit dem Material im Inhaltsbrowser. Das zweite Material, MI_Manny_02_New, befindet sich ebenfalls hier.

3. Klicke mit der rechten Maustaste auf das Asset MI_Manny_01_New und klicke auf Materialinstanz erstellen.

4. Nenne die Material-Instanz MI_Enemy_01 und doppelklicke darauf, um sie zu öffnen.

5. Erweitere im Details-Panel 01 - BaseColor und aktiviere die Eigenschaft Farbtönung.   

6. Klicke auf das Farbfeld neben der Eigenschaft Farbtönung und wähle eine Farbe aus. Dieses Tutorial verwendet Hex sRGB = F60E6EFF.

   

7. Klicke auf Speichern und schließe das Fenster.

8. Wechsle zurück zum Inhaltsbrowser, klicke mit der rechten Maustaste auf MI_Manny_02_New und klicke auf Materialinstanz erstellen.

9. Nenne diese Materialinstanz MI_Enemy_02 und wiederhole die vorherigen Schritte, um die Farbe zu ändern und das Asset zu speichern.

Nachdem du die Schritte wiederholt hast, solltest du zwei neue Material-Instanzen haben: MI_Enemy_01 und MI_Enemy_02.

Befolge diese Schritte, um diese Materialien dem gegnerischen Charakter zuzuweisen: 

1. Navigiere im BP_Enemy-Blueprint im Details-Panel zum Abschnitt Materialien.

2. Klicke auf die Dropdown-Liste für Element 0 und wähle das neu erstellte Material MI_Enemy_01 aus.

3. Ändere es für Element 1 zum Material MI_Enemy_02.  

Hinzufügen eines Gegners zum Level

Füge deinem Level einen Gegner hinzu, um zu sehen, wie er aussieht und sich verhält. 

Ziehe den Gegner-Blueprint aus dem Inhaltsbrowser in den Level-Viewport und platziere ihn vor dem Spieler. 

Wenn du das Spiel spielst, solltest du sehen, wie sich der Gegner mit einer Idle-Animation bewegt.

Richte den Feind ein, wenn das Gameplay startet

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

Befolge diese Schritte, um die Bewegungsgeschwindigkeit des Gegners beim Spielstart festzulegen:

1. Navigiere im BP_Enemy-Blueprint-Editor-Fenster zum Tab EventGraph. Standardmäßig gibt es drei Events: Event BeginPlay, Event ActorBeginOverlap und Event Tick. Wähle ActorBeginOverlap aus und lösche es, da es für dieses Tutorial nicht benötigt wird.

2. Verwende das Komponenten-Panel, um die Komponente Charakterbewegung in das Event-Diagramm zu ziehen. Dies erstellt einen Character Movement-Knoten. Mit diesem Komponentenknoten kannst du die Eigenschaften dieser Komponente im Diagramm prüfen oder ändern.

3. Ziehe den Pin vom Knoten Character Movement und erstelle einen Set Max Walk Speed-Knoten.

4. Klicke mit der rechten Maustaste auf den grünen Max Walk Speed-Pin des Set-Knotens und wähle Auf Variable hochstufen aus. 

   Damit wird eine neue Variable im Panel „Mein Blueprint“ erstellt, unter der Variablenliste.  

5. Benenne diese Variable in Max Speed um. Klicke auf das Augen-Symbol neben der Variable, um diese in eine öffentliche und bearbeitbare Variable umzuwandeln.

6. Ändere ihre Kategorie in Setup.

7. Kompiliere den Blueprint und lege im Details-Panel den Standardwert von Max Speed auf 200 fest.

   Weise deinen bearbeitbaren Variablen immer einen Standardwert zu. Wenn du vergessen hast, ihren Wert im Level-Editor zu ändern, und der Standardwert 0 wäre, könnte sich der Gegner nicht bewegen.

8. Verbinde Event BeginPlay mit dem Knoten Set Max Walk Speed.

   

Als Nächstes werden zwei Variablen die Gesundheit des Gegners verfolgen. TotalHP, eine instanz-bearbeitbare Variable, legt die anfänglichen KP des Gegners fest. CurrentHP verfolgt während des Spiels, wie viel Gesundheit der Gegner hat, wenn er durch den Spieler oder die Umgebung Schaden nimmt.

Befolge diese Schritte, um die KP des Gegners festzulegen:

1. Füge in der Variablen-Liste eine neue Variable mit dem Namen CurrentHP des Typs Float hinzu.

2. Ziehe die Variable CurrentHP aus der Liste Variablen in das Event-Diagramm und wähle die Option Aktuelle KP festlegen. Ziehe den Exec-Pin des Knotens Set Max Speed und verbinde ihn mit dem Exec-Pin des Knotens Set Current HP.

   

3. Klicke auf dem Knoten Set Current HP mit der rechten Maustaste auf den Float-Pin Current HP und klicke auf Auf Variable hochstufen.

4. Benenne die Variable in TotalHP um. Stelle sicher, dass der Typ Float ist, und klicke auf das Augen-Symbol, um sie öffentlich und bearbeitbar zu machen. Lege im Details-Panel die Kategorie auf Einrichtung fest. Kompiliere den Blueprint und lege den Standardwert auf 100 fest.

5. Verbinde die Exec-Pins zwischen den Set-Knoten.

Du wirst in diesem Event-Diagramm viele Aktionen mit dem Spieler-Charakter ausführen. Speichere daher als Nächstes eine Referenz zum Spieler als Variable. 

Befolge diese Schritte, um eine Variable für den Spieler-Charakter festzulegen:

1. Erstelle in der Variablen-Liste 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.

2. Verbinde nach dem Knoten „Set Current HP“ einen „Set PlayerRef“-Knoten.   

3. Verbinde für seinen Player Ref-Input-Pin einen Get Player Character-Knoten. Stelle sicher, dass der Player Index-Wert auf 0 gesetzt ist. Dies ist der Standardindex für den ersten Spieler-Charakter, der im Level spawnt.

   

Lass den Feind den Spieler verfolgen

Als Nächstes erstellst du die Logik, um den Feind auf den Spieler zuzubewegen. Erstelle dazu ein benutzerdefiniertes Event. Rufe benutzerdefinierte Events an beliebigen Stellen im Blueprint auf, um Logik auszulösen und auszuführen.

Befolge diese Schritte, um ein benutzerdefiniertes Event zu erstellen, das eine Bewegungsaktion auslöst:

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

2. Ziehe den Pin des MoveToPlayer-Eventknotens, suche nach und erstelle einen AI MoveTo-Knoten. Dieser Knoten ist eine Aktion, die Pawns mit einem KI-Controller verwenden, um sich an einen bestimmten Ort zu bewegen. In diesem Fall verwendest du ihn, um den Gegner zum Spieler zu bewegen. 

   Genauso wie dein Spielercharakter von einem Spieler-Controller gesteuert wird, können NPC-Charaktere von einem KI-Controller gesteuert werden. Wähle die Stammkomponente und navigiere zur Pawn-Kategorie im Details-Panel, um die Einstellungen Automatische KI-Besitzer im BP_Enemy-Blueprint anzuzeigen.

   

3. Ziehe auf dem Knoten AI MoveTo den Pin Pawn und gib Self in das Suchfeld ein. Wähle Referenz auf sich selbst erhalten aus, um einen Knoten zu erstellen, der auf den Actor dieses Blueprint im Spiel verweist.

4. Ziehe den Pin Target Actor des Knotens AI MoveTo und erstelle einen Get PlayerRef-Knoten.

5. Setze Akzeptanzradius auf 10. Das ist die Entfernung in Zentimetern, bei der der Gegner sich als am Ziel angekommen betrachtet. Dies bietet dir mehr Kontrolle als Bei Überlappung stoppen.

   

In diesem Fall nutzt du den Self-Knoten, um diesen Gegner als den Pawn zu definieren, der sich bewegen soll. Dann legst du den Spieler als den Ziel-Actor fest, also das Ziel, auf das sich der Pawn zubewegt.

Der Knoten AI MoveTo verfügt über die Events Bei Erfolg und Bei Fehlgeschlagen. Diese definieren, was passiert, wenn der Gegner den Spieler erreicht oder dies fehlschlägt.

Befolge diese Schritte, um festzulegen, was passiert, wenn sich der Gegner bewegt:

1. Ziehe auf dem Knoten AI MoveTo den Pin On Success und erstelle einen Delay-Knoten.

2. Klicke mit der rechten Maustaste auf den Pin Duration des Knoten Delay und wähle Auf Variable hochstufen aus.

3. Nenne diese Variable WaitAtDestination und stelle sicher, dass ihr Typ Float ist.

4. Kompiliere den Blueprint und ändere den Standardwert von WaitAtDestination zu 5. Klicke auf das Augen-Symbol, um es bearbeitbar zu machen, und ändere die Kategorie zu Einrichtung.

5. Ziehe im Event-Diagramm den Exec-Pin des Delay-Knotens und erstelle einen Move To Player-Knoten. Das stellt sicher, dass der Gegner den Spieler weiterhin verfolgt, wenn er sich wegbewegt, jedoch mit einer Verzögerung, die dem Spieler die Möglichkeit gibt, etwas Abstand zu gewinnen.

6. Ziehe den Pin On Fail vom Knoten AI MoveTo und erstelle einen neuen Delay-Knoten.

7. Ziehe den Pin Completed des Delay-Knotens und erstelle einen Knoten vom Typ Move To Player. Belass die Dauer bei 0,2. Dies stellt sicher, dass sich der Gegner weiterbewegt, wenn er den Spieler noch nicht erreicht hat.

   

8. Verbinde in der Event BeginPlay-Gruppe der Logik am Ende dieser Sequenz nach dem Set Player Ref-Knoten einen Move To Player-Knoten, um dieses Ereignis auszulösen. Das bringt den Feind zu Beginn des Spiels in Bewegung, sodass du die Bewegung des Feinds testen kannst.

   

9. Speichere und kompiliere den Blueprint.

Dein Ereignisdiagramm sollte nun so aussehen:

Testen der Gegnerbewegung

Bewege den Gegner-Actor in deinem Level so, dass er sich innerhalb der Grenzen des NavMesh befindet, also in den grünen Zonen.

Wähle den Actor BP_Enemy im Level-Viewport oder im Outliner aus. Im Details-Panel siehst du die Variablen, die du im Blueprint im Abschnitt Einrichtung hinzugefügt hast. Du kannst diese Werte ändern, damit sie deinen Projektanforderungen entsprechen, oder die Debug-Erkennung aktivieren, um eine Debug Zeichnung des Linien-Trace zu aktivieren.

Spiele dein Level erneut und beobachte, wie sich der Gegner jetzt verhält. Er sollte auf den Spieler zugehen, anhalten, wenn er den Spieler erreicht, fünf Sekunden warten und dann erneut versuchen, auf den Spieler zuzugehen.

Wenn etwas nicht wie vorgesehen funktioniert, überprüfe, 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 Speed oder Max Detection Distance nicht festlegst, wird sich der Gegner nicht bewegen. Dasselbe könnte passieren, wenn die Werte zu niedrig sind.

Verursachen von Schaden beim Spieler

Da der Gegner den Spieler jetzt erreichen kann, kannst du Funktionalität hinzufügen, die dafür sorgt, dass der Gegner dem Spieler Schaden zufügt, wenn sie kollidieren. In diesem Tutorial erstellst du einen Gegner, der sich bei Kontakt mit dem Spieler selbst zerstört. Also fügst du eine Logik hinzu, um diesen Gegner zu entfernen, nachdem er dem Spieler einmal Schaden zugefügt hat.

Befolge diese Schritte, um zu prüfen, ob der Gegner mit dem Spieler kollidiert ist:

1. Klicke im Komponenten-Panel mit der rechten Maustaste auf die Kapsel-Komponente (CollisionCylinder), gehe zu Event hinzufügen und wähle OnComponentHit hinzufügen aus. 

   

   Dies erstellt einen neuen Event-Knoten im Event-Diagramm, der ausgeführt wird, wenn die Kapsel-Komponente auf etwas trifft.

2. Ziehe den Pin des Knotens On Component Hit und erstelle einen Branch-Knoten.

3. Verbinde den Pin Condition mit dem Pin Other Actor des Knotens On Component Hit, wodurch du aufgefordert wirst, einen neuen Knoten zu erstellen.

4. Erstelle einen Equal-Knoten. Ziehe den Pin Wähle Asset des Equal-Knoten ab und füge eine Referenz auf die PlayerRef-Variable hinzu.

   

Nun löst diese Logik einen Event aus, wenn die gegnerische Kapsel-Komponente etwas im Spiel trifft. Dieses Event überprüft, ob die Kapsel-Komponente den Spieler-Charakter getroffen hat.

Befolge diese Schritte, um dem Spieler einen Treffer Schaden zuzufügen und den Gegner zu entfernen:

1. Erstelle in der Liste Variablen eine neue Variable mit dem Namen Eliminiert und ändere ihren Typ in Boolesch. Dies verwendest du, wenn der Gegner besiegt wurde und aus dem Spiel entfernt werden soll.

2. Um sicherzustellen, dass sie dem Spieler nur einmal Schaden zufügen, ziehe den True-Pin des Branch-Knotens weg und erstelle einen Do Once-Knoten.

3. Erstelle aus dem Completed-Pin des Knotens Do Once einen Apply Damage-Knoten. Ziehe den Damaged Actor-Pin und verbinde eine Referenz mit der PlayerRef-Variable. Dies ist der Actor, der den Schaden erhalten soll.

4. Klicke mit der rechten Maustaste auf den Pin Base Damage und wähle Auf Variable hochstufen aus.

   

5. Klicke in der Liste Variablen auf das Augen-Symbol von Basisschaden, um sie bearbeitbar zu machen, und ändere ihre Kategorie zu „Einrichtung“. Kompiliere den Blueprint und lege den Standardwert auf 25 fest.

6. Ziehe die Eliminated-Variable aus der Variablen-Liste in das Event-Diagramm und wähle Festlegen aus. Klicke im Knoten auf das Kontrollkästchen, um Eliminated auf „True“ zu setzen.

7. Verbinde den Exec-Pin des Knotens Apply Damage mit dem Knoten Set Eliminated.

8. Ziehe den Exec-Pin des Knotens Set Eliminated und erstelle einen Delay-Knoten. Lege die Dauer auf 2,0 fest.

9. Ziehe den Exec-Pin des Delay-Knotens und erstelle einen Destroy Actor-Knoten. Die Eigenschaft Ziel sollte standardmäßig auf Selbst festgelegt sein.

Wenn der Gegner mit dem Spieler kollidiert, fügt er dem Spieler Schaden zu und tötet den Gegner nach einer 2-sekündigen Verzögerung.

Jetzt kann der Gegner auf den Spieler zulaufen, ihm Schaden zufügen und sich selbst zerstören, wenn er mit dem Spieler kollidiert. Allerdings berücksichtigt dies nicht die Entfernung oder Hindernisse zwischen dem Spieler und dem Gegner. Der Gegner verfolgt den Spieler also immer, unabhängig von der Entfernung oder Sichtlinie.

Die fertige On Component Hit-Logik von BP_Enemy sollte wie folgt aussehen:

Füge Entfernung- und Hindernis-Logik hinzu

Füge als Nächstes eine maximale Erkennungsreichweite hinzu, sodass der Gegner den Spieler nur erkennen kann, wenn dieser dem Gegner nah genug ist. Dann implementierst du zum Abschluss die Sichtlinienbeschränkungen des Gegners, sodass er den Spieler nicht durch Wände sehen kann. 

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 Linien-Trace (oder Raycast) ist eine gängige Praxis in der Spieleentwicklung. Linien-Traces ziehen eine unsichtbare Linie von einem Punkt in der Welt (wie einem Quell-Actor), um zu prüfen, was die Linie trifft. Das wird häufig verwendet, um Objekte oder Oberflächen während der Laufzeit zu erkennen, sodass du Logik in Abhängigkeit vom Ergebnis des Trace auslösen kannst. 

In diesem Tutorial wirfst du eine Linien-Trace vom Gegner-Charakter, um zu erkennen, wann sich der Spieler-Charakter in der Sichtlinie des Gegners befindet. 

Weitere Informationen zu Linien-Traces findest du in der Dokumentation Traces with Raycasts. 

Befolge diese Schritte, um eine Funktion einzurichten, die einen Linien-Trace verwendet, um den Spieler zu finden: 

1. Wechsle im Inhaltsbrowser zu deinem Core-Ordner und öffne die Blueprint-Bibliothek BPL_FPGame.

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

3. Klicke im Details-Panel der neuen Funktion im Abschnitt Inputs auf Hinzufügen (+), um die folgenden Inputs hinzuzufügen:

   1. Player Reference (Pawn-Objekt-Referenz)

   2. Start Location (Vektor)

   3. Max Detection Distance (Float)

   4. Debug (Boolean) 

      

      Nachdem du diese Inputs hinzugefügt hast, verfügt der Funktionsknoten fnBPLFindPlayer nun über entsprechende Pins für jede der Variablen.

4. Klicke im Details-Panel der Funktion im Abschnitt Outputs auf Hinzufügen (+), um einen Output-Wert vom Typ Boolean mit dem Namen Found zu erstellen. 

   

   Nachdem du den Found-Output hinzugefügt hast, erscheint ein neuer Return Node mit dem Found-Pin in deinem Diagramm.

5. Klicke im Panel Mein Blueprint im Abschnitt Lokale Variablen auf Hinzufügen (+), um die lokale Variable PlayerFound vom Typ Boolean zu erstellen. Stelle sicher, dass der Standardwert False ist.

   

Die Spielerreferenz ist entscheidend für die korrekte Ausführung der Funktion. Überprüfe daher beim Start der Funktion, ob eine gültige Spielerreferenz vorhanden ist, um Fehler zu vermeiden. 

Befolge diese Schritte, um zu prüfen, ob gültige Inputs vorhanden sind:

1. Lösche den Draht zwischen dem Einstiegsknoten und dem Return Node, indem du die Alt-Taste gedrückt hältst und auf den Draht oder einen der Exec-Pins klickst.

2. Erstelle nach dem Einstiegsknoten der Funktion einen Is Valid-Knoten und verbinde ihn. 

   Stelle sicher, dass du einen Is Valid-Knoten erstellst, der durch ein Fragezeichen (?) am unteren Ende der Knoten-Aktionsliste dargestellt wird.

3. Verbinde den Pin Player Reference vom Eingangsknoten mit dem Pin Input Object auf dem Knoten Is Valid.

4. Verbinde den Is Not Valid-Exec-Pin mit dem Return Node.

5. Verbinde für den Found-Rückgabewert eine Referenz mit der PlayerFound-Variable. Dies beendet die Funktion und gibt PlayerFound=False an das Event-Diagramm des Gegners zurück.

   

Wenn der Spieler gültig ist, sollte die Funktion das Linien-Trace-Objekt ausführen und dann PlayerFound zurückgeben.

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

1. Füge vom Is Valid-Exec-Pin einen Sequence-Knoten hinzu, um deine Logik zu organisieren.

2. Ziehe den Pin Then 0 des Sequence-Knotens weg und füge einen Line Trace By Channel-Knoten hinzu. 

   

   Line Trace By Channel erkennt Objekte auf einem bestimmten Kollisionskanal. Wähle die Kollisionskomponente des Blueprint aus und navigiere im Details-Panel zu Kollision > Kollisionsvoreinstellungen, um die Kollisionskanal-Einstellungen für einen Blueprint anzuzeigen. Der Abschnitt Trace Responses verfügt über Sichtbarkeit- und Kamera-Kanäle.

3. Ziehe den Start Location-Pin vom Funktions-Eingangsknoten und verbinde ihn mit dem Start-Pin des Line Trace By Channel-Knotens. Dies legt den Standort des gegnerischen Charakters als Startpunkt des Linien-Trace fest.

4. Erstellen einen Get Player Reference-Knoten, damit dein Diagramm ordentlich bleibt. Das f-Symbol in der oberen rechten Ecke des Knotens zeigt an, dass es sich um einen Funktions-Input handelt. Du kannst diesen Inputs wie jeder anderen Variable Referenzen hinzufügen.

5. Ziehe den Player Reference-Pin zu einer leeren Stelle im Diagramm. Dadurch wird die Knoten-Aktionen-Liste geöffnet. Suche und erstelle in der Liste einen Get Actor Location-Knoten.

6. Verbinde den Return Value mit dem End-Pin des Line Trace-Knotens. Damit endet der Linien-Trace an der Position des Spielers.

7. Setze auf dem Line Trace By Channel-Knoten die Eigenschaft Trace Channel mit dem Dropdown-Menü auf Camera.

   

Nachdem du jetzt festgelegt hast, wo der Linien-Trace beginnt und endet, definiere, was passiert, wenn der Trace auf etwas trifft.

Befolge diese Schritte, um zu überprüfen, ob ein Linien-Trace den Spieler getroffen hat:

1. Ziehe den Out Hit-Pin des Linien-Trace weg und füge einen Break Hit Result-Knoten hinzu. Wenn ein Linien-Trace ein Objekt trifft, werden zahlreiche Informationen gesammelt. Du musst nur einige wenige spezifische Werte verwenden. Daher ist ein Break Hit Result-Knoten erforderlich, um die Daten in die einzelnen Komponenten der zurückgegebenen Daten aufzuteilen.

2. Klicke im Break Hit Result-Knoten auf den Pfeil unten, um mehr Optionen anzuzeigen. 

   Du möchtest wissen, ob sich der Spieler in Sichtlinie und innerhalb einer bestimmten Entfernung zum Gegner befindet. Daher verwendest du den Hit Actor-Pin, um nach dem Spieler zu suchen, und nutzt Trace Start und Trace End, um die Entfernung zum getroffenen Objekt zu messen.  

3. Ziehe den Hit Actor-Pin weg und füge einen Equal-Operator-Knoten hinzu. Verbinde für den unteren Input eine Referenz mit dem Player Reference-Funktions-Input. 

   Um Funktions-Input-Werte zu verweisen, kannst du einen Get-Knoten hinzufügen, ähnlich wie bei anderen Variablen.

   

4. Erstelle einen Distance (Vector)-Knoten. Verbinde V1 mit Trace Start und V2 mit Trace End. 

   Ein Vektor ist ein Satz mit X-, Y- und Z-Werten, die die Position eines Objekts oder Punktes im 3D-Raum darstellen. Der Distance-Knoten berechnet die Entfernung zwischen zwei dieser Punkte, was zu einem Float-Wert führt.

5. Ziehe den Return Value des Distance-Knotens weg und füge einen Less (<)-Knoten hinzu. Verbinde für den unteren Input eine Referenz mit dem Max Detection Distance-Funktions-Input.

6. Erstelle einen AND (Boolean)-Knoten.

7. Verbinde die booleschen Output-Pins der Knoten Equals (==) und Less (<) mit den Input-Pins des AND-Knotens. 

   

   Mit dieser Logik gibt der AND-Knoten „True“ zurück, wenn der Linien-Trace auf einen Actor trifft, der mit Player Reference übereinstimmt, wenn der Abstand zwischen dem Startpunkt des Trace (dem Gegner) und dem Endpunkt (dem getroffenen Objekt) kleiner als Max Detection Distance ist.

Befolge diese Schritte, um mit dem Trace-Ergebnis den Wert von PlayerFound festzulegen und zurückzugeben:

1. Ziehe den Output des AND-Knotens und füge einen Branch-Knoten hinzu.

2. Verbinde seinen Exec-Pin so, dass er nach Line Trace By Channel ausgeführt wird.

3. Erstelle vom True-Exec-Pin des Branch-Knotens einen Set-Variablenknoten, um die lokale PlayerFound-Variable auf „True“ zu setzen.

4. Erstelle vom False-Pin des Branch-Knotens eine Set PlayerFound-Variable. Belasse den Wert auf False.

   

5. Du hast die Linien-Trace-Logik abgeschlossen. Gehe daher zurück zum Sequence-Knoten und verbinde dessen Then 1-Pin mit dem Return Node, um die Funktion zu beenden und das PlayerFound-Ergebnis an den Gegner-Blueprint zurückzusenden.

   

Hinzufügen einer Linien-Trace-Debug-Option

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 Liste Debug-Typ zeichnen auswählen. Du kannst einen Select-Knoten verwenden, um den Debug-Typ im Level-Editor bearbeitbar zu machen.  

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

1. Ziehe vom Draw Debug Type-Pin des Line Trace By Channel-Knotens und erstelle einen Select-Knoten.

2. Verbinde den Index-Pin des Select-Knotens mit einer Referenz zum Debug-Input der Funktion. 

   Der Index des Select-Knotens ist ein Platzhalter. Wenn du also den Debug-Wert vom booleschen Typ verbindest, ändern sich die Optionen zu False und True.

3. Setze die Option False auf Keine. Setze die Option For Duration auf True.

4. Klicke am unteren Rand des Line Trace By Channel-Knotens auf die Pfeil-Schaltfläche, um mehr Optionen anzuzeigen. Ändere die Draw Time zu 0,1 Sekunden.

   

5. Speichere und kompiliere deine Blueprint-Funktionsbibliothek.

Diese Logik verwendet die Debug-Variable, um zu bestimmen, ob die Debug-Zeichnung für den Linien-Trace aktiv ist: 

• Wenn die Debug-Variable auf „False“ gesetzt ist, wird Debug-Typ zeichnen auf Keine gesetzt, was bedeutet, dass keine Debug-Zeichnung gerendert wird.

• Wenn Debug auf „True“ gesetzt ist, ändert der Select-Knoten Debug-Typ zeichnen zu For Duration, wodurch der Linien-Trace zur Laufzeit für eine festgelegte Dauer gerendert wird.

Die fertige fnBPLFindPlayer-Funktion sollte wie folgt aussehen:

Aktualisieren der Bewegung-zum-Spieler-Logik

Da du jetzt eine Funktion aufrufen kannst, die nach dem Spieler sucht und dabei Entfernung und Sichtlinie berücksichtigt, füge dem Gegner Logik hinzu, die ihn dazu bringt, den Spieler nur bei Sichtkontakt oder wenn die Linienprüfung den Spieler erfolgreich findet, zu suchen und zu verfolgen. 

Befolge diese Schritte, damit der Gegner den Spieler jagt, nachdem er ihn gefunden hat:

1. Geh zurück zum Blueprint BP_Enemy. Suche im Event-Diagramm den bereitgestellten Event Tick-Knoten.

2. Ziehe den Exec-Pin des Event Tick-Knotens und erstelle einen Branch-Knoten. 

   Das On 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 Condition-Pin des Branch-Knotens und erstelle einen NOT Boolean-Knoten, der den inversen Wert eines Booleschen Werts zurückgibt.

4. In diesem Fall willst du die Eliminated-Variable negieren. Ziehe also den Input-Pin des NOT-Knotens und suche nach Get Eliminated. 

   

   Dies prüft, ob der Gegner nicht eliminiert wurde, bevor mit dem True-Pin des Branch-Knotens fortgefahren wird.

5. Ziehe den True-Pin des Branch-Knotens und erstelle einen FnBPLFindPlayer-Knoten. Dieser Knoten führt einen Linien-Trace durch, um den Spieler in der Welt zu finden, und prüft die aktuelle Entfernung zwischen dem Gegner und dem Spieler.

6. Stelle auf dem Fn BPLFind Player-Knoten die folgenden Verbindungen mithilfe seiner Pins her: 

   • Player Reference: Verbinde eine Referenz mit der PlayerRef-Variable.

   • Start Location: Erstelle einen Get Actor Location-Knoten, dessen Target-Eigenschaft auf self gesetzt ist. Dies weist die Startposition des Linien-Trace der Position des Gegners in der Welt zu.

   • Max Detection Distance: Rechtsklicke auf den Pin und wähle Auf Variable hochstufen aus. Klicke auf das Augen-Symbol, um es bearbeitbar zu machen, und ändere die Kategorie zu Einrichtung. Kompiliere alles und lege seinen Standardwert auf 20.000 (200 Meter) fest. Je kleiner dieser Wert ist, desto näher muss der Spieler sein, damit Feinde ihn erkennen können.

   • Debug: Wähle Auf Variable hochstufen aus und nenne sie DebugDetection. Mache diese Variable außerdem editierbar und lasse sie in der Setup-Kategorie erscheinen.

     

Wenn der Spieler vom Linien-Trace gefunden wird, wird die maximale Bewegungsgeschwindigkeit des Gegners auf einen gewünschten Wert gesetzt, wodurch sich der Gegner in Richtung des Spielers bewegt. Wenn nicht, solltest du die Geschwindigkeit auf 0 festlegen, damit der Feind sich nicht auf den Spieler zubewegen kann.

Befolge diese Schritte, um den Gegner zu bewegen, wenn der Spieler gefunden wird, und anzuhalten, wenn der Spieler nicht gefunden wird:

1. Klicke auf dem FnBPLFindPlayer-Knoten mit der rechten Maustaste auf den Found-Pin und wähle Auf Variable hochstufen. Dies verbindet automatisch einen Set-Knoten mit dieser neuen Variable. Nun kannst du dieses Found-Ergebnis an einer anderen Stelle im Diagramm verwenden.

2. Verbinde nach dem Set-Knoten einen Branch-Knoten. Ziehe den Condition-Pin des Branch-Knotens zum Output-Pin des Set Found -Knotens.

   

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

4. Ziehe den True-Pin des Knotens Branch und verbinde ihn mit dem Set Max Walk Speed-Knoten.

5. Verbinde für den Pin Max Walk Speed des Set-Knotens eine Referenz mit der Variable Max Speed.

6. Verbinde nach dem Set-Knoten einen MoveToPlayer-Knoten, um dieses Event aufzurufen und den Gegner sich nur dann zu bewegen zu lassen, wenn er den Spieler gefunden hat.

   

7. Dupliziere die Knoten Set Max Walk Speed und Character Movement. Verbinde den False-Pin des Branch-Knotens mit dem neuen Set-Knoten.

8. Stelle im zweiten Set Max Walk Speed-Knoten sicher, dass der Gehgeschwindigkeitswert 0 ist. Dadurch wird die Bewegung des Gegners gestoppt, ohne dass dessen AI MoveTo-Aufgabe abgebrochen wird und die Aufgabe erneut ausgeführt werden muss.

   

9. Da der Gegner nun in jedem Frame nach dem Spieler sucht, lösche den Move to Player-Knoten, den du am Ende der Logik Event BeginPlay hinzugefügt hast. Dieser Knoten war zum Testen eines teilweise abgeschlossenen Gegners nützlich, aber du brauchst ihn nicht mehr.

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

    1. Ziehe den Knoten MoveToPlayer weg und erstelle einen Branch-Knoten.

    2. Füge für die Condition von Branch eine Referenz zur Found-Variable hinzu.

       

Befindet sich der Spieler innerhalb der vorgegebenen Entfernung zum Gegner und befinden sich keine Hindernisse zwischen ihnen, wird die Bewegungsgeschwindigkeit 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 Gegners auf 0 festgelegt, sodass er sich nicht mehr auf den Spieler zubewegen kann.

Die endgültige Variablenliste von BP_Enemy sollte wie folgt aussehen:

Die endgültige Event BeginPlay -Logik von BP_Enemy sollte wie folgt aussehen:

Die endgültige MoveToPlayer -Logik von BP_Enemy sollte wie folgt aussehen:

Die endgültige Event Tick-Logik von BP_Enemy sollte wie folgt aussehen:

Erlaube Feinden, Schaden zu erleiden

Bevor du diesen Blueprint abschließt, musst du sicherstellen, dass der Gegner ebenfalls Schaden erleiden kann. Wenn du über dieses Tutorial hinaus an deinem Spiel arbeitest, möchtest du vielleicht, dass Gegner durch die Fallen Schaden nehmen oder dem Spieler einen ausrüstbaren Gegenstand geben, der Gegnern Schaden zufügt und sie eliminieren kann.

Befolge diese Schritte, um Gegner Schaden nehmen zu lassen:

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

2. Ziehe den Exec-Pin von Event AnyDamage und erstelle einen Set CurrentHP-Knoten.

3. Um den verursachten Schaden von den CurrentHP zu subtrahieren, ziehe den Pin der Eigenschaft Current HP und erstelle einen Subtract-Knoten.

4. Ziehe den oberen Pin des Subtract-Knotens und erstelle einen Get Current HP-Knoten.

5. Verbinde den unteren Pin des Subtract-Knotens mit der Damage-Eigenschaft des Event AnyDamage-Knotens.

   

Wenn diesem Actor Schaden zugefügt wird, wird der Schaden vom Wert der Variable CurrentHP abgezogen und der Wert von CurrentHP anschließend auf den neuen Wert gesetzt.

Prüfe als Nächstes, ob CurrentHP kleiner oder gleich 0 ist, wodurch der Gegner eliminiert werden sollte.

Befolge diese Schritte, um den Gegner zu entfernen, wenn seine KP 0 erreicht: 

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

2. Ziehe den Condition-Pin des Branch-Knotens und erstelle einen Less Equal (<=)-Knoten.

3. Verbinde den Output-Pin des Knotens Set Current HP mit dem oberen Input-Pin des Knotens Less Equal. Stelle sicher, dass der untere Pin auf 0 gesetzt ist.

4. Ziehe den True-Pin des Branch-Knotens und erstelle einen Do Once-Knoten.

5. Ziehe den Completed-Pin und erstelle einen Set Eliminated-Knoten. Schalte im Set-Knoten die Eigenschaft Eliminated auf True um.

6. Verbinde nach dem Set-Knoten einen Delay-Knoten, dessen Duration auf 2 gesetzt ist.

7. Ziehe den Completed-Pin des Delay-Knotens und erstelle einen Destroy Actor-Knoten, dessen Ziel-Eigenschaft auf Selbst gesetzt ist.

   

8. Speichere und kompiliere den Blueprint.

Die fertige Event AnyDamage-Logik von BP_Enemy sollte wie folgt aussehen:

Testen des fertigen feindlichen Charakters

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 Gegner näherst, sollte er beginnen, den Spieler zu verfolgen. 

Versuch es mit einem Hindernis. Beende den Spielmodus und füge einen Blockout-Würfel oder eine Wand in der Mitte der NavMesh-Zone hinzu, indem du auf die Schaltfläche Erstellen in der Haupt-Symbolleiste klickst und Formen > Würfel auswählst. Dieses Hindernis schneidet das NavMesh.

Wenn der Spieler hinter diesem Hindernis startet, kann der Gegner den Spieler nicht verfolgen, da der Linien-Trace durch den Würfel blockiert wird, wodurch der Gegner den Spieler nicht finden kann. Wenn der Spieler um den Würfel herumgeht und der Gegner direkten Sichtkontakt zum Spieler hat, beginnt er, den Spieler zu verfolgen. Sobald der Gegner seine „AI MoveTo“-Aktion beginnt, wird das Verstecken hinter einem Hindernis die Verfolgung durch den Gegner nicht aufhalten. 

Wenn du möchtest, dass ein Gegner den Spieler durch ein Hindernis sehen kann, wähle das Level-Objekt aus und navigiere im Details-Panel zu Kollision > Kollisionsvoreinstellungen. Ändere die Voreinstellung zu Benutzerdefiniert und aktiviere Ignorieren im Kamera-Kanal. Damit ein Objekt den Linien-Trace blockiert, ändere die Voreinstellung zurück zu Standard.

Platzieren von Gegnerpositionen in deinem Projekt

Für unseren Sample-Level haben wir mehrere Gegner in Flur 3 und Raum 3 platziert. Der erste Gegner ist allein in Flur 3, um dem Spieler eine einfache erste Begegnung zu bieten und ihm zu helfen, das Verhalten und die Fähigkeiten des Gegnercharakters kennenzulernen. Nach der Begegnung mit dem einzelnen Gegner im Flur haben wir zwei weitere Gegnercharaktere in Raum 3 platziert, um den Spieler vor eine größere Herausforderung zu stellen. 

Du kannst die Anzahl und Arten der Gegner variieren, um in deinem Projekt unterschiedliche Schwierigkeitsgrade zu bieten. Indem den Spielern langsam neue Gegner und Herausforderungen vorgestellt werden, entsteht eine ausgewogene Schwierigkeitskurve, an die sich der Spieler mit der Zeit gewöhnen kann. Eine schwierige Begegnung mit einem Gegner zu erstellen, nachdem der Spieler gelernt hat, sich zu orientieren und Gegner zu besiegen, stellt eine Herausforderung dar, die der Spieler dann als lohnend empfindet.

Als Nächstes

Im nächsten Modul lernst du, wie du eine Sprint-Mechanik zum Bewegungssatz des Spielers hinzufügst. Dies hilft dem Spieler, sich durch vertraute Orte im Level zu bewegen, und gibt ihm außerdem ein Werkzeug an die Hand, mit dem er den Gegnern ausweichen kann, die du gerade zum Projekt hinzugefügt hast.

• 

  Füge dem Spieler einen Sprint-Mechanik hinzu

  Verwende Input-Aktionen, um den Bewegungen des Spielercharakters eine Sprint-Mechanik hinzuzufügen.