Gameplay mit strukturiertem Output in Unreal Editor für Fortnite steuern | Fortnite Dokumentation

Strukturierter Output verleiht deinem Gameplay mit NPCs zusätzliche Tiefe. Strukturierter Output ist ein Mechanismus, über den das deinem NPC zugrunde liegende LLM benutzerdefinierte, vom LLM instanziierte Strukturen zurückgibt, die die Gameplay-Logik steuern.

Damit kann dein LLM-Charakter komplexere Interaktionen ausführen, etwa Multiple-Choice-Fragen beantworten oder beurteilen, ob ein Gegenstand seinen Preis wert ist.

Sowohl die Antwort als auch der strukturierte Output müssen auf Englisch verfasst sein.

Overview

In diesem Abschnitt passt du dein persona_npc_behavior mit einem einzelnen strukturierten Output für deine Persona an. Die Struktur interactions_response:

Zeichnet auf, wie oft dieser NPC mit dem Spieler interagiert hat.
Das aktuelle Gefühl, das die Persona bezüglich dieser Interaktion mit dem Spieler hat.
Ein Array, das den Verlauf der Gefühle der Persona bei sämtlichen Interaktionen mit dem Spieler aufzeichnet.

Für strukturierten Output ist Folgendes erforderlich:

Erstelle eine Struktur, die den strukturierten Output definiert.
Gib Anweisungen dazu, wie die Persona die Struktur des strukturierten Outputs ausfüllen soll.
Definiere und abonniere ein Event, das beim Empfang eines strukturierten Outputs ausgelöst wird.

Du kannst für eine einzelne Persona mehrere strukturierte Outputs gleichzeitig konfigurieren und für jeden Typ ein eigenes Abonnement festlegen.

Unterstützte Typen

Strukturierter Output unterstützt die folgenden Verse-Typen als Felder in Strukturen:

int
float
bool
enum
Nachricht

Anzeigen von Nachrichten

Nachrichtentypen werden unkenntlich gemacht, wenn sie im Protokoll oder im Spiel ausgegeben werden. Du kannst sie jedoch mit Geräten anzeigen, die dafür vorgesehen sind, beispielsweise:

Reklametafel_Gerät
hud_message_device
popup_dialog_device

Voraussetzungen

Einen NPC zu einem Gespräch hinzufügen

Strukturierten Output zum NPC-Verhaltens-Script hinzufügen

Der folgende Code erweitert die Fähigkeiten mehrerer LLMs mithilfe des Typs prompt_binding_definition und der Funktion RegisterAction(). Dadurch werden auf Basis der Spieler-Prompts neue Antworttypen eingeführt.

Prompt Binding ist eine Struktur, die der KI übergeben wird, um eine in der Funktion RegisterAction() definierte Aktion zu registrieren. Zusammen teilen sie dem LLM auf Grundlage des Spieler-Prompts mit, wann eine bestimmte Aktion ausgeführt beziehungsweise warum sie verwendet werden soll.

Unten findest du ein Verse-Script mit einer erweiterten Version von persona_npc_behavior im Abschnitt persona_npc_behavior.verse. Dies erweitert den Code aus der Dokumentation Einen NPC zu einem Gespräch hinzufügen um strukturierten Output.

Gehe wie folgt vor, um den Code in deinem vorhandenen persona_npc_behavior zu bearbeiten:

Stelle sicher, dass dein Verse-Projekt in VS Code geöffnet ist:
1. Wähle in der Menüleiste Verse > Projekt in VS Code öffnen… aus.
2. Suche nach dem Öffnen von VS Code nach deiner Datei persona_npc_behavior.verse im VS-Code-Explorer.
Kopiere den unten stehenden Inhalt von persona_npc_behavior.verse und füge ihn in die Verse-Datei deines Projekts ein.
Kompiliere deinen Verse-Code entweder über die Werkzeugleiste von UEFN oder in VS Code.

Eine schrittweise Erläuterung des Verse-Scripts findest du unter Erklärung der Script-Änderungen. Dieser Abschnitt setzt unmittelbar dort an, wo die Script-Erklärung unter Persona zu einem NPC-Charakter hinzufügen endet.

persona_npc_behavior.verse

Verse

using { /Fortnite.com/AI }
using { /Fortnite.com/Devices }
using { /Fortnite.com/Playspaces }

using { /UnrealEngine.com/Conversations }
using { /UnrealEngine.com/Temporary/Diagnostics }

using { /Verse.org/Chat }
using { /Verse.org/SceneGraph }
using { /Verse.org/Simulation }

Erläuterung der Script-Änderungen

Eine Struktur namens interactions_response enthält Variablen, die von den Funktionen an das LLM übergeben werden. Das LLM verwendet die Variablen, um den Prompt zu auswerten und zu entscheiden, wie es antworten soll.
Verse
```
interactions_response := struct:
    @ai_description("Use the Number field to output the number of times you have spoken to this player.")
    Number:int
 
 
    @ai_description("Use the Feeling field to output how you are feeling about your current interaction with the player.")
    Feeling:message
```
interactions_response := struct: @ai_description("Use the Number field to output the number of times you have spoken to this player.") Number:int @ai_description("Use the Feeling field to output how you are feeling about your current interaction with the player.") Feeling:message
Zwei verschiedene @ai_descriptions erklären dem LLM, wofür die Variablen stehen und warum es sie beim Erstellen einer Antwort verwenden soll.
Verse
```
    @ai_description("Use the Number field to output the number of times you have spoken to this player.")
    Number:int
 
 
    @ai_description("Use the Feeling field to output how you are feeling about your current interaction with the player.")
    Feeling:message
```
@ai_description("Use the Number field to output the number of times you have spoken to this player.") Number:int @ai_description("Use the Feeling field to output how you are feeling about your current interaction with the player.") Feeling:message
OnInteractionsResponse ist die Funktion, die die Gameplay-Logik mithilfe von strukturiertem Output steuert. Dieser Callback wird immer dann ausgelöst, wenn die KI-Sitzung einen strukturierten Output erzeugt, der der Struktur interactions_response entspricht. Dabei handelt es sich um den Handler, den RegisterAction in AddStruktururedOutput() registriert. Sein Response-Parameter enthält die vom Modell ausgefüllten Daten.
Verse
```
OnInteractionsResponse(Response:interactions_response):void =
        Logger.Print("Structured response received")
        Logger.Print("Number of Interactions: {Response.Number}")
        Logger.Print("Feeling: {Localize(Response.Feeling)}")
        # Drive gameplay logic here
```
OnInteractionsResponse(Response:interactions_response):void = Logger.Print("Structured response received") Logger.Print("Number of Interactions: {Response.Number}") Logger.Print("Feeling: {Localize(Response.Feeling)}") # Drive gameplay logic here
Die Funktion AddStruktururedOutput registriert die Aktion des NPC für den strukturierten Output in seiner KI-Sitzung. Dadurch kann das Modell Interaktionsdaten an das Gameplay zurückmelden. Dieser Code tut zwei Dinge. Zunächst wird eine prompt_binding_definition erstellt. Dieser kleine Deskriptor weist der Aktion einen Namen und eine Beschreibung zu. Beide werden mithilfe der Hilfsfunktion MakeMessage eingeschlossen, um die String-Literale in Nachrichtenwerte umzuwandeln. Der Beschreibungstext gibt an, wann das Modell diese Aktion ausführen soll: hier, immer dann, wenn der Spieler mit dem NPC gesprochen hat.
Anschließend ruft der Code Session.RegisterAction auf und übergibt das Binding, true, den Struktur-Typ interactions_response und den Handler OnInteractionsResponse. Dies weist die Sitzung an, strukturierte Outputs in Form von interactions_response an OnInteractionsResponse weiterzuleiten. RegisterAction gibt ein abbrechbares Objekt zurück. Dieses wird in option{} eingeschlossen und in InteractionsResponseSubscription gespeichert, damit das Abonnement in der Methode OnEnd beendet werden kann.
Verse
```
    AddStructuredOutput():void =
        if:
            NPCEntity := GetEntity[]
            PersonaComponent := NPCEntity.GetComponent[persona_component]
             Session := PersonaComponent.GetAISession()
        then:
            # Create a prompt_binding so that we can use it on RegisterAction
            InteractionBinding:prompt_binding_definition = prompt_binding_definition:
                Name := MakeMessage("InteractionBinding")
                Description := MakeMessage("Signals whenever the player has spoken to you.")
```
OnBegin fügt der Sitzung den strukturierten Output hinzu und legt den Spieler als Gesprächsziel fest. In einem Spiel, dem Spieler später beitreten können, solltest du sie beim PlayerAddedEvent hinzufügen – oder wenn sie sich über einen Trigger einem NPC nähern.
Verse
```
    OnBegin<override>()<suspends>:void=
        AddStructuredOutput()
        AddPlayersAsConversationTarget()
```
OnBegin<override>()<suspends>:void= AddStructuredOutput() AddPlayersAsConversationTarget()
In OnEnd wird die Variable InteractionsResponseSubscription bereinigt und von allen Spielern entfernt. Dies ist eine gute Vorgehensweise.
Verse
```
    OnEnd<override>():void=
        if (Subscription := InteractionsResponseSubscription?):
            Subscription.Cancel()
        for (Player : GetEntity[].GetPlayspaceForEntity[].GetPlayers()):
            RemovePlayerAsConversationTarget(Player)
```
OnEnd<override>():void= if (Subscription := InteractionsResponseSubscription?): Subscription.Cancel() for (Player : GetEntity[].GetPlayspaceForEntity[].GetPlayers()): RemovePlayerAsConversationTarget(Player)

Test des strukturierten Outputs

Der NPC ist jetzt mit strukturiertem Output konfiguriert. Jedes Mal, wenn die Persona spricht, wird ein Signal für interactions_response ausgelöst.

Teste das Verhalten deines LLM-Charakters, um im Spiel interessantere Antworten und Reaktionen auf deine Prompts zu erhalten.