1. Epic GamesDeveloper
  3. 5. Erkennen, wann das Rätsel gelöst ist

5. Erkennen, wann das Rätsel gelöst ist

Erstelle ein Rätsel, bei dem der Spieler mit einem in Verse erstellten Gerät die richtige Kombination aus ein- und ausgeschalteten Lichtern finden muss, um ein Item zu spawnen.

5. Erkennen, wann das Rätsel gelöst ist
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

In diesem Schritt des „Tagged Lights“-Rätsel-Tutorials erfährst du, wie du erkennst, ob das Rätsel gelöst wurde, sodass ein Gegenstand gespawnt wird und keine weitere Interaktionen mit dem Rätsel möglich sind.

Gelöstes Rätsel erkennen

In diesem Abschnitt wird gezeigt, wie du erkennst, wenn der Spieler das Rätsel durch Finden der richtigen Kombination von Lichtern gelöst hat. Wenn das Rätsel gelöst ist, sollte das Item-Spawner-Gerät aktiviert werden, damit es sein Item spawnen kann.

Führe folgende Schritte aus, um zu erkennen, wenn der Spieler das Rätsel gelöst hat:

  1. Füge der tagged_lights_puzzle-Klasse ein bearbeitbares item_spawner_device-Feld namens ItemSpawner hinzu, um das Item-Spawner-Gerät zu repräsentieren. 
     @editable
 ItemSpawner : item_spawner_device = item_spawner_device{}
  2. Definiere als nächstes, in welchem Zustand die Lichter sich befinden müssen, damit das Rätsel gelöst ist. Da die Repräsentation des Zustands der Lichter ein logic-Array ist, muss der Gelöst-Zustand der Lichter ebenfalls ein logic-Array sein, damit beide problemlos verglichen werden können. Erstelle ein bearbeitbares logic-Array-Feld namens SolvedLightsState für die tagged_lights_puzzle-Klasse. In diesem Beispiel muss der Spieler alle Lichter einschalten, um das Rätsel zu lösen. Initialisiere also jedes Element mit dem Wert true, um den eingeschalteten Zustand des Lichts zu repräsentieren. 
     @editable
 SolvedLightsState : []logic = array{true, true, true, true}
  3. Speichere die Datei in Visual Studio Code.
  4. Klicke in der UEFN-Symbolleiste auf Verse-Scripte erstellen, um dein Verse-Gerät im Level zu aktualisieren.
  5. Wähle im Outliner das tagged_lights_puzzle aus, um sein Detail-Panel zu öffnen.
  6. Stelle im Detail-Panel die Eigenschaft Item Spawner auf das Item-Spawner-Gerät im Level ein.
  7. Entwickle nun den Code zum Prüfen, ob der aktuelle LightsState mit dem SolvedLightsState übereinstimmt. Füge der tagged_lights_puzzle-Klasse eine neue Methode namens IsPuzzleSolved() hinzu. Diese Methode soll erfolgreich sein, wenn das Rätsel gelöst wird, und anderenfalls fehlschlagen. Lass ihren Aufrufer also das Ergebnis der Prüfung wissen. Außerdem muss die Methode mit dem decides-Bezeichner als fehlbar gekennzeichnet werden. Wenn sie den decides-Bezeichner aufweist, muss sie auch den transacts-Bezeichner aufweisen, was bedeutet, dass die Aktionen dieser Methode zurückgenommen werden können (als wären sie nicht ausgeführt worden), wenn irgendwo innerhalb der Methode ein Fehlschlag auftritt. 
     IsPuzzleSolved()<decides><transacts> : void =
     Logger.Print("Prüfen, ob das Rätsel gelöst wurde")

    Verse verwendet Erfolg/Fehlschlag zur Entscheidungsfindung. Weitere Details dazu, wie Verse Fehlschläge verwendet, findest du unter Fehlschlag.
  8. Wann soll das Gerät prüfen, ob das Rätsel gelöst wurde? Der beste Zeitpunkt ist jeweils dann, wenn das LightsState-Array aktualisiert wurde. Dies findet innerhalb der ToggleLights()-Methode statt. Wenn der for-Ausdruck das LightsState-Array aktualisiert hat, rufe die IsPuzzleSolved[]-Methode auf, um zu bestimmen, ob das Rätsel gelöst ist, und ggf. durch Aufrufen von ItemSpawner.Enable() ein Item zu spawnen. Da IsPuzzleSolved[] ein fehlbarer Ausdruck ist (weswegen die Methode [] statt () aufweist, wenn du sie aufrufst), muss er in einem Fehlerkontext aufgerufen werden. In diesem Beispiel ist der Fehlerkontext ein if-Ausdruck, sodass du Ausdrücke bedingt ausführen kannst je nachdem, ob das Rätsel gelöst ist. 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         IsLightOn := LightsState[LightIndex]
         Light := Lights[LightIndex]
     do:
         Logger.Print("Turning light at index {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
         NewLightState :=
             if (IsLightOn?):
                 Light.TurnOff()
                 false
             else:
                 Light.TurnOn()
                 true
         if (set LightsState[LightIndex] = NewLightState):
             Logger.Print("Zustand von Licht bei {LightIndex} aktualisiert")
    
     if (IsPuzzleSolved[]):
         Logger.Print("Rätsel gelöst!")
         ItemSpawner.Enable()
  9. Lass dann die IsPuzzleSolved()-Methode ermitteln, ob das Rätsel gelöst ist. Da es sich bei IsPuzzleSolved() um einen Fehlerkontext handelt, kannst du fehlbare Ausdrücke im Methodenkörper verwenden, ohne einen weiteren Fehlerkontext wie einen if-Ausdruck zu benötigen. In diesem Fall musst du prüfen, ob der Zustand jedes Lichts dem Rätsel-gelöst-Zustand entspricht. Zum Prüfen, ob zwei logic-Werte gleich sind, kannst du den Ist-gleich-Operator = verwenden, der ein fehlbarer Ausdruck ist. Beim ersten Mal, wenn zwei geprüfte Werte nicht gleich sind, schlägt der Ausdruck fehl. Die Methode schlägt ebenfalls fehl und kehrt zum Kontext des Aufrufers (in diesem Fall der if-Ausdruck in der ToggleLights()-Methode) zurück. 
     IsPuzzleSolved()<decides><transacts> : void =
     Logger.Print("Prüfen, ob das Rätsel gelöst wurde")
        
     for:
         LightIndex -> IsLightOn : LightsState
         IsLightOnInSolution := SolvedLightsState[LightIndex]
     do:
         IsLightOn = IsLightOnInSolution
  10. Speichere die Änderungen in Visual Studio Code.
  11. Klicke in der UEFN-Symbolleiste auf Build Verse Scripts (Verse-Scripte erstellen), um deinen Code zu kompilieren.
  12. Klicke in der UEFN-Symbolleiste auf Spielen, um das Level zu testen.

Wenn du dein Level mit den Beispiel-Einstellungen testest, sollte eine einmalige Interaktion mit allen Tasten das Rätsel lösen, und der Gegenstand sollte gespawnt werden.

Der Spieler interagiert mit den Tasten, um die richtige Kombination von Lichtern zu finden und das Rätsel zu lösen, sodass ein Item gespawnt wird.

Tasten-Interaktion entfernen, wenn das Rätsel gelöst ist

Wenn der Spieler das Rätsel gelöst hat, soll er nicht mehr mit den Tasten interagieren und die Lichter nicht mehr ein-/ausschalten können. In diesem Abschnitt erfährst du, wie du ein Event-Abonnement aufhebst, sodass dein Event-Handler nicht mehr aufgerufen wird, wenn der Spieler mit den Tasten interagiert.

Wenn du bei einem Geräte-Event Subscribe() aufrufst, hat der Funktionsaufruf ein cancellable-Ergebnis. Wird Cancel() bei einer cancelable-Variable aufgerufen, so wird das Abonnement der Funktion aufgehoben, die das Event behandelt, sodass die Funktion nicht mehr aufgerufen wird, wenn das Event gesendet wird.

Führe folgende Schritte aus, um die Tasteninteraktionen zu entfernen, wenn das Rätsel gelöst wird:

  1. Füge der tagged_lights_puzzle-Klasse ein cancelable-Array-Variablenfeld namens ButtonSubscriptions hinzu, um das Ergebnis des Abonnements jedes Tasten-Events zu speichern, und initialisiere das Feld mit einem leeren Array. 
     var ButtonSubscriptions : []cancelable = array{}
  2. Da dies die letzte Anweisung des for-Ausdrucks ist, werden ihre Rückgabewerte bei allen erfolgreichen Iterationen in einem Array des Rückgabetyps des Ausdrucks gesammelt. Wie bereits erklärt, ist der Rückgabetyp eines Event Subscribe-Aufrufs cancelable; dies referenziert für ToggleLights die for Ergebnisse in einem Array von cancelable ([]cancelable). Dies stimmt mit dem ButtonsSubscription-Typ überein. Du kannst also das Ergebnis des for-Ausdrucks dem ButtonsSubscription-Array zuweisen. Füge der OnBegin-Funktion diesen Code hinter SetupPuzzleLights hinzu: 
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
    
     set ButtonSubscriptions = for:
         ButtonIndex -> Schaltfläche : Schaltflächen
         LightIndices := ButtonsToLights[ButtonIndex]
     do:
         Button.InteractedWithEvent.Subscribe(button_event_handler{Indices := LightIndices, PuzzleDevice := Self}.OnButtonPressed)
  3. Bedenke schließlich, dass die Tasten deaktiviert werden müssen, damit der Spieler den LightsState nicht mehr verändern kann. Dies erreichst du, indem du das Abonnement der InteractedWithEvent-Handler aufhebst, indem du ihr cancelable-Abonnement aufrufst. Diese ButtonSubscriptions wurden gespeichert, als die Event-Handler in OnBegin erstellt wurden. Nun bleibt nur noch, durch dieses Array zu iterieren und bei jedem ButtonSubcription cancel aufzurufen: 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         IsLightOn := LightsState[LightIndex]
         Light := Lights[LightIndex]
     do:
         Logger.Print("Turning light at index {LightIndex} {if (IsLightOn?) then "Off" else "On"}")
         NewLightState :=
             if (IsLightOn?):
                 Light.TurnOff()
                 false
             else:
                 Light.TurnOn()
                 true
         if (set LightsState[LightIndex] = NewLightState):
             Logger.Print("Zustand von Licht bei {LightIndex} aktualisiert")
    
     if (IsPuzzleSolved[]):
         Logger.Print("Rätsel gelöst!")
         ItemSpawner.Enable()
    
         für (ButtonSubscription : ButtonSubscriptions):
             ButtonSubscription.Cancel()
  4. Speichere die Änderungen in Visual Studio Code.
  5. Klicke in der UEFN-Symbolleiste auf Build Verse Scripts (Verse-Scripte erstellen), um deinen Code zu kompilieren.
  6. Klicke in der UEFN-Symbolleiste auf Spielen, um das Level zu testen.

Bei den Standardeigenschaften sollte eine einmalige Interaktion mit allen Tasten das Rätsel lösen, das Item spawnen und weitere Interaktionen mit den Tasten deaktivieren.

Nächster Schritt

Im letzten Schritt dieses Tutorials findest du das vollständige Script für dieses Tutorial sowie Ideen, wie du das Beispiel ändern kannst.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page