Um das Debugging deines Spiels zu erleichtern, kannst du bestimmte Spieldaten zu Testzwecken anzeigen, während du diese Informationen vor dem Spieler verbirgst. Eine Möglichkeit, dies zu tun, ist die Protokollierung, aber du kannst einige Spieldaten auf eine visuellere Weise mit der Debug-Zeichnen-API anzeigen.

Mit der Debug-Zeichen-API kannst du einfache Formen zeichnen und ihre Position, Größe, Farbe und die Zeit, die sie auf dem Bildschirm erscheinen, festlegen. Du kannst z.B. die Sichtweite eines NPCs visualisieren oder die Entfernung, aus der Audio vom Ausgangspunkt aus zu hören ist. Mit der Box-Debug-Form kannst du eine Box mit Abmessungen und einer Position zeichnen, die zu einem beliebigen Volumen passt, selbst wenn dieses Volumen in deinem Spiel unsichtbar ist. Dies kann helfen, die Platzierung von Volumen mit bestimmten Effekten zu ermitteln.

Die Pfeil-Debug-Form, die vom Gesicht eines NPCs bis zur Grenze seines Sichtbereichs gezogen wird, kann verwendet werden, um die perfekte Platzierung für Wachen zu entwerfen.

Verse Debug-Zeichnen aktivieren

Als Erstes solltest du sicherstellen, dass du die von dir gezeichneten Formen sehen kannst.

Wähle Insel-Einstellungen in der UEFN-Gliederung.
Gib in der Suchleiste des Detail-Panels debug ein. Dadurch werden die Ergebnisse nach der Kategorie Benutzeroptionen - Debug gefiltert.
Klicke auf Debug, dann Verse Debug-Zeichnen, um Debug-Funktionen und Verse Debug-Zeichnen zu aktivieren.

Verse Debug-Zeichnen wird nur während einer Spielsitzung von UEFN aktiv sein. Die Funktion wird pro Nutzer aktiviert, d.h. nur diejenigen, die Debug und Verse Debug-Zeichnen aktiviert haben, sehen Debug-Formen. Debug-Shapes werden nicht im UEFN-Viewport oder auf einer veröffentlichten Insel angezeigt, selbst wenn diese Option in den Inseleinstellungen aktiviert ist.

Zeichne deine erste Debug-Form

So zeichnest du die erste Form mit der Debug-Zeichnen-API:

Füge diesen Importausdruck zu deiner Verse-Datei hinzu.
```
 using { /UnrealEngine.com/Temporary/Diagnostics }
```
Erstelle einen Kanal, indem du eine Subklasse deklarierst, die vom debug_draw_channel type erbt. Kanäle dienen dazu, zusammengehörige Formen zu gruppieren. Sie sind optional, aber es ist eine gute Praxis, sie zu verwenden. Es gibt Funktionen in der Debug-Zeichnen-API, mit denen du viele Formen auf einmal anzeigen, ausblenden oder löschen kannst, aber das Anzeigen und Ausblenden funktioniert nur auf Kanalebene.
```
 my_debug_draw := class(debug_draw_channel) {}
```
Deklariere eine neue Konstante des Typs debug_draw. Mit diesem Objekt wirst du die Methoden aufrufen, um Formen zu zeichnen. Dieses Beispiel zeigt die Verwendung des Kanal-Parameters (im vorherigen Schritt erstellt), dies ist jedoch optional.
```
 DebugDraw:debug_draw = debug_draw{Channel := my_debug_draw}
```
Rufe die DrawSphere-Methode auf. In diesem Beispiel werden zwei Parameter verwendet.

Center:= vector3{Z:= 150.0}: Dies ist ein erforderlicher Parameter vom Typ vector3, der die Position der Kugelmitte bestimmt. In diesem Beispiel verwendest du den Constructor des Typs vector3, um einen literalen Wert zu erstellen. Dies setzt die Mitte der Kugel auf die Position 0.0, 0.0, 150.0.
?DrawDurationPolicy:= debug_draw_duration_policy.Persistent: Dieser Parameter ist optional, aber sein Standardwert lässt die Kugel nach einigen Sekunden verschwinden. Setze ihn also auf Dauerhaft. Das bedeutet, dass die Kugel auf der Insel sichtbar bleibt, bis sie ausgeblendet oder durch anderen Code gelöscht wird.
```
  DebugDraw.DrawSphere(Center := vector3{Z:=150.0}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)
```

Nachdem du deinen Verse-Code kompiliert hast und eine Sitzung startest, solltest du eine Kugel an der vom Center-Parameter bestimmten Position sehen.

Formen

Mit der Debug-Zeichnen-API kannst du verschiedene Formen zeichnen, die als einfache Wireframes in einer laufenden UEFN-Sitzung erscheinen. Jede Form ist in verschiedenen Szenarien nützlich. In den folgenden Abschnitten werden die Methoden zum Zeichnen der einzelnen Formen und die Parameter erläutert, die für jede Methode gelten. In einem späteren Abschnitt werden die Parameter erläutert, die für alle Methoden gleich sind. Jedes Codebeispiel in diesem Abschnitt setzt voraus, dass du den Code aus "Deine erstes Debug-Form zeichnen" zu deiner Verse-Datei hinzugefügt hast.

Box

Verwende die Methode DrawBox(), um einen Würfel zu zeichnen.

DebugDraw.DrawBox(vector3{Z:=150.0}, rotation{}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Center:vector3	Legt den Mittelpunkt der Box fest
Rotation:rotation	Legt fest, wie die Box gedreht wird
?Extent:vector3	Legt die Länge, Breite und Tiefe der Box fest

Kapsel

Verwende die Methode DrawCapsule(), um eine Kapsel zu zeichnen. Eine Kapsel besteht aus einem Zylinder mit einer Kugelhälfte an beiden Enden.

DebugDraw.DrawCapsule(vector3{Z:=200.0}, rotation{}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Center:vector3	Legt den Mittelpunkt der Kapsel fest
Rotation:rotation	Legt fest, wie die Kapsel gedreht wird
?Height:float	Legt die Länge der Kapsel fest
?Radius:float	Legt den Radius der Kapsel an ihrer breitesten Stelle fest

Kugel

Verwende die Methode DrawSphere(), um eine Kugel zu zeichnen.

DebugDraw.DrawSphere(vector3{Z:=150.0}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Center:vector3	Legt den Mittelpunkt der Kugel fest
?Radius:float	Legt den Radius der Kugel an ihrer breitesten Stelle fest
?NumSegments:int	Legt die Anzahl der Linien fest, aus denen die Kugel besteht

Kegel

Verwende die Methode DrawCone(), um einen Kegel zu zeichnen.

DebugDraw.DrawCone(vector3{Z:=150.0}, vector3{Z:=-1.0}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Origin:vector3	Legt die Position der Spitze des Kegels fest
Direction:vector3	Legt die Richtung fest, in der sich der Kegel öffnet
?Height:float	Legt die Länge des Kegels fest
?NumSides:int	Legt die Anzahl der Seiten fest
?AngleWidthRadians:float	Legt die Breite des Kegels in X-Richtung fest
?AngleHeightRadians:float	Legt die Breite des Kegels in Y-Richtung fest

Um den Boden des Kegels zu einem perfekten Kreis zu machen, müssen AngleWidthRadians und AngleHeightRadians gleich sein.

Zylinder

Verwende die Methode DrawCylinder(), um einen Zylinder zu zeichnen.

DebugDraw.DrawCylinder(vector3{Z:=100.0}, vector3{Z:=200.0}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Start:vector3	Legt die Position eines Endes des Zylinders fest
End:vector3	Legt die Position des anderen Endes des Zylinders fest
?NumSegments:int	Legt die Anzahl der Linien fest, die ein Ende des Zylinders mit dem anderen verbinden
?Radius:float	Legt den Radius der beiden Kreise fest, die die beiden Enden des Zylinders bilden

Linie

Verwende die Methode DrawLine(), um eine Linie zu zeichnen.

DebugDraw.DrawLine(vector3{Z:=100.0}, vector3{Z:=200.0}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Start:vector3	Legt die Position eines Endes der Linie fest
End:vector3	Legt die Position des anderen Endes der Linie fest

Pfeil

Verwende die Methode DrawArrow(), um einen Pfeil zu zeichnen.

DebugDraw.DrawArrow(vector3{Z:=100.0}, vector3{Z:=200.0}, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Start:vector3	Legt die Position des Pfeilanfangs fest
End:vector3	Legt die Position der Pfeilspitze fest
?ArrowSize:float	Legt die Länge der beiden Linien fest, die die Spitze des Pfeils bilden

Punkt

Verwende die Methode DrawPoint(), um einen Punkt zu zeichnen.

DebugDraw.DrawPoint(vector3{Z:=200.0}, ?Thickness:= 10.0, ?DrawDurationPolicy := debug_draw_duration_policy.Persistent)

Einzigartiger Parameter	Wie er funktioniert
Position:vector3	Legt die Position des Punktes fest

Die voreingestellte Thickness von DrawPoint ist zu klein, um sichtbar zu sein. Setze Thickness auf einen größeren Wert, wie im obigen Beispiel gezeigt, um den Punkt zu sehen.

Gemeinsame Parameter

Diese Parameter gelten für alle Methoden, die Formen zeichnen. Sie sind auch alle optional und müssen beim Aufruf einer Methode nicht als Argumente angegeben werden. Wenn du dich dafür entscheidest, sie einzubeziehen, achte darauf, dass du den Parameternamen mit einem vorangestellten ? verwendest. Siehe Aufruf von Funktionen in Funktionen für weitere Informationen über benannte und optionale Argumente.

Farbe

Lege die Farbe von Formen mit dem Parameter Color fest. Die Werte müssen vom Typ color sein. Die Liste der gültigen Farben ist im Modul NamedColors zu finden. Achte darauf, dass der Importausdruck für das Modul Colors am Anfang deiner Verse-Datei steht. Nachfolgend siehst du ein Beispiel für das Setzen eines Punktes auf eine andere Farbe.

DebugDraw.DrawPoint(Position := vector3{Z:= 200.0}, ?Thickness := 20.0, ?Color := NamedColors.MediumSeaGreen)

DrawDurationPolicy

Die DrawDurationPolicy bestimmt, wie lange eine Debug-Form auf dem Bildschirm bleibt. Es gibt drei mögliche Werte.

SingleFrame : Die Form bleibt auf dem Bildschirm für die Dauer eines einzigen Frame. Diese Richtlinie kann nützlich sein, wenn du eine Form häufig neu zeichnen möchtest.
FiniteDuration: Diese Richtlinie wird zusammen mit dem Parameter Duration verwendet, um eine Form für eine bestimmte Anzahl von Sekunden anzuzeigen.
Persistent: Mit der Richtlinie Persistent bleibt die Form auf dem Bildschirm, bis sie ausgeblendet oder durch anderen Code gelöscht wird.

Dauer

Der Parameter Duration wird mit der Richtlinie FiniteDuration verwendet, um eine Form für eine bestimmte Anzahl von Sekunden anzuzeigen. Im Folgenden findest du ein Beispiel für Code, der eine Kugel zeichnet, die 30 Sekunden lang angezeigt wird.

DebugDraw.DrawSphere(vector3{}, ?DrawDurationPolicy := debug_draw_duration_policy.FiniteDuration, ?Duration := 30.0)

Dicke

Der Parameter Thickness bestimmt die Dicke der Linien, aus denen die einzelnen Debug-Formen bestehen. Im Fall von DrawPoint() wird die Dicke des einzelnen Punktes festgelegt.

Kanäle

Mithilfe von Kanälen kannst du zusammengehörige Formen gruppieren und dann alle Formen in einem Kanal gleichzeitig ausblenden, einblenden oder löschen.

Um einen Kanal zu erstellen, verwende den Parameter Channel, wenn du eine Instanz von debug_draw deklarierst.

DebugDraw:debug_draw = debug_draw{Channel := debug_draw_defaults}

Jetzt kann jede Form, die du mit der DebugDraw-Instanz zeichnest, mit einer einzigen Methode versteckt, gezeigt oder gelöscht werden. Wenn du zum Beispiel einen Punkt, eine Kugel und einen Pfeil mit der DebugDraw-Instanz zeichnest, kannst du sie für einige Zeit ausblenden, dann wieder einblenden und schließlich löschen, wenn sie nicht mehr benötigt werden.

# Punkt
DebugDraw.DrawPoint(vector3{Z := 200.0}, ?Thickness:= 50.0, ?DrawDurationPolicy:= debug_draw_duration_policy.Persistent)

# Kugel
DebugDraw.DrawSphere(vector3{Z := 200.0}, ?DrawDurationPolicy:= debug_draw_duration_policy.Persistent)

# Pfeil
DebugDraw.DrawArrow(vector3{Z := 200.0}, vector3{Z := 400.0}, ?DrawDurationPolicy:= debug_draw_duration_policy.Persistent)

Sleep(5.0)
DebugDraw.HideChannel()
Sleep(5.0)
DebugDraw.ShowChannel()
Sleep(5.0)
DebugDraw.ClearChannel()

Standard-Parameterwerte

Parameter	Wert
?Color:color	`NamedColors.Yellow`
?DrawDurationPolicy:debug_draw_duration_policy	`debug_draw_duration_policy.FiniteDuration`
?Duration:float	`5.0`
?Thickness:float	`0.0`
?Radius:float	`10.0`

Beispiele

Visualisiere die Reichweite eines Audioplayer-Geräts

Das Audioplayer-Gerät verfügt über eine Einstellung zur Visualisierung der Dämpfung. Diese Visualisierung kannst du aber nur im Bearbeitungsmodus sehen. Befolge diese Schritte, um zu lernen, wie du die Dämpfungsvisualisierung in einer Spielsitzung nachstellen kannst.

Ziehe ein Audio-Player-Gerät in deinen Level. Stelle sicher, dass Dämpfungsvisualisierung aktivieren im Detail-Panel markiert ist. Auf diese Weise kannst du überprüfen, ob du das Bildmaterial mit den Debug-Formen korrekt nachbildest.
Erstelle in deiner Verse-Datei eine neue debug_draw-Instanz namens DebugDrawAudio. Gib ihm einen Kanal mit dem Namen debug_draw_audio.
```
 DebugDrawAudio:debug_draw = debug_draw{Channel := debug_draw_audio}
```
Füge zwei @editable Konstanten vom Typ float hinzu. Nenne sie DebugAttenuationMinDistance und DebugAttenuationFalloffDistance. Dies sind die beiden Radien der Kugeln, die gezeichnet werden, um die Dämpfung des Audioplayers zu visualisieren.
```
 @editable
 DebugAttenuationMinDistance:float = 100.0

 @editable
 DebugAttenuationFalloffDistance:float = 100.0
```
Füge ein weiteres @editable hinzu, um das Audioplayer-Gerät darzustellen. Nenne es AudioPlayerDevice.
```
 @editable
 AudioPlayerDevice:audio_player_device = audio_player_device{}
```
Deklariere eine Funktion namens DrawAudioDeviceRange() und gib ihr zwei Parameter vom Typ Float: AttenuationMinDistance und AttenuationFalloffDistance.
```
 DrawAudioDeviceRange(AttenuationMinDistance:float, AttenuationFalloffDistance:float):void =
```
Hole in der neuen Funktion das Transform-Objekt des Audioplayer-Geräts.
```
 AudioPlayerDeviceTransform:= AudioPlayerDevice.GetTransform()
```

Zeichne mit der Funktion DrawSphere aus der Debug-Zeichnen-API zwei Kugeln, die den Dämpfungsminimalabstand und den Dämpfungs-Falloff-Abstand darstellen. Der Radius im zweiten DrawSphere-Aufruf muss auf die Summe von AttenuationMinDistance und AttenuationFalloffDistance gesetzt werden, da die Dämpfung nur außerhalb des Radius der Attenuation Min Distance beginnt.

 DebugDrawAudio.DrawSphere(
     AudioPlayerDeviceTransform.Translation,
     ?Radius:= AttenuationMinDistance,
     ?DrawDurationPolicy:= debug_draw_duration_policy.Persistent)
 DebugDrawAudio.DrawSphere(
     AudioPlayerDeviceTransform.Translation,
     ?Radius:= AttenuationMinDistance + AttenuationFalloffDistance,
     ?DrawDurationPolicy:= debug_draw_duration_policy.Persistent)

Rufe in der Funktion OnBegin() deiner Verse-Datei die Funktion DrawAudioDeviceRange() auf.

 OnBegin<override>()<suspends>:void=
 DrawAudioDeviceRange(DebugAttenuationMinDistance, DebugAttenuationFalloffDistance)

Erstelle deinen Verse-Code. Stelle sicher, dass du die Werte für DebugAttenuationMinDistance und DebugAttenuationFalloffDistance im Detail-Panel deines Verse-Geräts einstellst. Diese Werte sollten den Werten Attenuation Min Distance und Attenuation FalloffDistance für dein Audioplayer-Gerät multipliziert mit 100 entsprechen.

Das Audioplayer-Gerät verwendet Meter für Dämpfungsminimalabstand und Dämpfungs-Falloff-Abstand. Da die Debug-Zeichnen-API mit Zentimetern arbeitet, musst du die Werte konvertieren.

Vollständiges Script

 using { /Fortnite.com/Devices }
 using { /Fortnite.com/Characters }
 using { /Fortnite.com/Playspaces }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 using { /UnrealEngine.com/Temporary/SpatialMath }

 debug_audio_device := class(creative_device):

     @editable
     AudioPlayerDevice:audio_player_device = audio_player_device{}

     @editable
     DebugAttenuationMinDistance:float = 100.0

     @editable
     DebugAttenuationFalloffDistance:float = 100.0

     DebugDrawAudio:debug_draw = debug_draw{Channel := debug_draw_audio}

     OnBegin<override>()<suspends>:void=

         DrawAudioDeviceRange(DebugAttenuationMinDistance, DebugAttenuationFalloffDistance)

     DrawAudioDeviceRange(AttenuationMinDistance:float, AttenuationFalloffDistance:float):void =
         AudioPlayerDeviceTransform:= AudioPlayerDevice.GetTransform()
         DebugDrawAudio.DrawSphere(
             AudioPlayerDeviceTransform.Translation,
             ?Radius:= AttenuationMinDistance,
             ?DrawDurationPolicy:= debug_draw_duration_policy.Persistent)
         DebugDrawAudio.DrawSphere(
             AudioPlayerDeviceTransform.Translation,
             ?Radius:= AttenuationMinDistance + AttenuationFalloffDistance,
             ?DrawDurationPolicy:= debug_draw_duration_policy.Persistent)