1. Epic GamesDeveloper
  3. 4. Ein-/Ausschalten von Lichtern mit Tasten

4. Ein-/Ausschalten von Lichtern mit Tasten

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.

4. Ein-/Ausschalten von Lichtern mit Tasten
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 eine Gruppe von Lichtern ein-/ausschaltest je nachdem, mit welcher Taste der Spieler interagiert.

Lichter ein-/ausschalten

Du musst eine Zuordnung zwischen einer Taste und der Gruppe von Lichtern erstellen, die ein-/ausgeschaltet werden sollen, wenn der Spieler die Taste betätigt. Dazu kannst du jede Taste den Indizes zuordnen, welche die Lichter im Array Lights aufweisen.

In diesem Beispiel wird folgende Zuordnung zwischen Tasten und Lichtern verwendet:

  • Taste 1 ist dem Licht bei Index 0 sowie dem Licht bei Index 3 zugeordnet
  • Taste 2 ist dem Licht bei Index 0, dem Licht bei Index 1 sowie dem Licht bei Index 2 zugeordnet
  • Taste 3 ist dem Licht bei Index 0 sowie dem Licht bei Index 1 zugeordnet
  • Taste 4 ist dem Licht bei Index 1 zugeordnet

Du kannst diese Zuordnung mit einem Array namens ButtonsToLights repräsentieren, in dem jedes Element von ButtonsToLights ein eigenes Array mit den Indizes der Lichter ist. Der Typ von ButtonsToLights ist [][]int, um anzugeben, dass ButtonsToLights ein Array von ganzzahligen Arrays ist.

Index 0 1 2 3
Element Array{0, 3} Array{0, 1, 2} Array{0, 1} Array{1}

Führe folgende Schritte aus, um die Lichter ein-/auszuschalten:

  1. Erstelle an Array von ganzzahligen Arrays namens ButtonsToLights und initialisiere es mit der Zuordnung von Taste-und-Licht-Indizes aus der Tabelle oben. 
     ButtonsToLights : [][]int = array{array{0, 3}, array{0, 1, 2}, array{0, 1}, array{1}}

    Die Indizes eines Arrays beginnen bei 0 und enden bei der Anzahl der Elemente minus 1. Das erste Element von ButtonsToLights ist also bei Index 0, das letzte bei Index 3.
  2. Füge der tagged_lights_puzzle-Klasse eine neue Methode namens ToggleLights() hinzu. Mit dieser Methode werden die Lichter im Lights-Array je nach den Indizes ein-/ausgeschaltet, welche der Funktion als ganzzahliges Array (passend zu den Elementen des Arrays ButtonsToLights) zugeordnet sind, und die Elemente an den entsprechenden Indizes in LightsState werden aktualisiert.
    1. Füge der Methode ToggleLights() den Parameter LightIndices : []int hinzu und drucke jeden Index mithilfe des for-Ausdrucks ins Output-Log. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
 do:
     Logger.Print("Licht bei {LightIndex} wird ein-/ausgeschaltet")
    2. Rufe ToggleLights() in OnBegin() auf, um die Methode beim Erstellen zu testen. Verwende das erste Element von ButtonsToLights als Test. Das Indizieren in ein Array ist ein fehlbarer Ausdruck, daher musst du von einem Fehlerkontext aus auf das Array zugreifen. In diesem Beispiel wird der if-Ausdruck für den Fehlerkontext verwendet.
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()

     # Verwende das erste Element von „ButtonsToLights“, um die Methode „ToggleLights“ zu testen
     if (LightIndices : []int = ButtonsToLights[0]):
         ToggleLights(LightIndices)
  3. Nun liegt LightIndex vor. Greife bei diesem Index auf die Arrays Lights und LightsState zu, um die Referenz Benutzerdefiniertes-Licht-Gerät und ihren aktuellen Zustand zu erhalten. Licht ein-/ausschalten bedeutet: Ist das Licht eingeschaltet, so wird es ausgeschaltet; ist das Licht ausgeschaltet, so wird es eingeschaltet. Aktualisiere die Druckanweisung, um den neuen Zustand des Lichts anzugeben. 
     ToggleLights(LightIndices : []int) : void =
     for:
         LightIndex : LightIndices
         Light := Lights[LightIndex]
         IsLightOn := LightsState[LightIndex]
     do:
         Logger.Print("Licht bei {LightIndex} wird {if (IsLightOn?) then "aus" else "an"}geschaltet")
  4. Aktualisiere jetzt den Zustand des Benutzerdefiniertes-Licht-Geräts sowohl im Spiel als auch im LightsState-Array.
    1. Rufe TurnOn() beim Licht auf, wenn IsLightOn den Wert false aufweist, und rufe TurnOff() beim Licht auf, wenn IsLightOn den Wert true aufweist. Der letzte Ausdruck in einem Codeblock ist das Ergebnis. Das Einstellen von false oder true als letzten Ausdruck bedeutet also, dass der Wert in NewLightState gespeichert wird. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     Light := Lights[LightIndex]
     IsLightOn := LightsState[LightIndex]
 do:
     Logger.Print("Licht bei {LightIndex} wird {if (IsLightOn?) then "aus" else "an"}geschaltet")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             false
         else:
             Light.TurnOn()
             true
    2. Aktualisiere das Element LightsState bei LightIndex mit dem Wert in NewLightState. Das Indizieren in ein Array ist ein fehlbarer Ausdruck, daher benötigt LightsState einen Fehlerkontext. In diesem Beispiel ist der Fehlerkontext der if-Ausdruck. Drucke ins Output-Log, dass der Zustand aktualisiert wurde. 
       ToggleLights(LightIndices : []int) : void =
 for:
     LightIndex : LightIndices
     IsLightOn := LightsState[LightIndex]
     Light := Lights[LightIndex]
 do:
     Logger.Print("Licht bei {LightIndex} wird {if (IsLightOn?) then "aus" else "an"}geschaltet")
     NewLightState :=
         if (IsLightOn?):
             Light.TurnOff()
             false
         else:
             Light.TurnOn()
             true
     if (set LightsState[LightIndex] = NewLightState):
         Logger.Print("Zustand von Licht bei {LightIndex} aktualisiert")

    Es ist ratsam, ins Output-Log zu drucken, wenn Fehlerkontexte verwendet werden. Wenn ein Ausdruck in einem Fehlerkontext fehlschlägt, werden alle Änderungen im Fehlerkontext zurückgenommen, als hätten sie nicht stattgefunden. Wenn du ins Output-Log druckst, kannst du dich vergewissern, dass die Änderung erfolgreich war, sofern der Text im Output-Log erscheint, und musst dich dazu nicht ausschließlich auf den Spielzustand verlassen.

Tastendrücke mit Ein-/Ausschalten von Lichtern verbinden

Nun hast du definiert, wie die Lichter ein-/ausgeschaltet wrden. Im nächsten Schritt verbindest du Tastendrücke mit dem Ein-/Ausschalten von Lichtern.

Abonniere dazu das InteractedWithEvent der Taste. Siehe [Code für Geräteinteraktionen] (coding-device-interactions-in-verse) für weitere Einzelheiten zum Ereignisabonnement.

Das InteractedWithEvent erwartet einen Event-Handler mit einem Parameter InPlayer : agent und einem void-Rückgabetyp. Er muss außerdem wissen, mit welchen Lichtern die Taste verbunden ist, die das Event gesendet hat, sowie eine Referenz auf dein Verse-Gerät tagged_lights_puzzle enthalten, um die Methode ToggleLights() aufrufen zu können.

Du kannst all diese Informationen in einem benutzerdefinierten Objekt zusammenfassen, indem du eine neue Klasse erstellst, welche die Indizes und die zu abonnierende Funktion enthält. So weist jede Schaltfläche ihren eigenen Zustand und ihren eigenen Event-Handler auf wie in dieser neuen Klasse repräsentiert.

Führe folgende Schritte aus, um ein benutzerdefiniertes Objekt zum Event-Handling zu erstellen:

  1. Erstelle eine neue Klasse namens button_event_handler. Die Klassendefinition muss Folgendes enthalten:
    1. Ein ganzzahliges Array namens Indices.
    2. Ein Feld tagged_lights_puzzle namens PuzzleDevice, das als Referenz auf dein Verse-Gerät dient, damit du die ToggleLights()-Methode aufrufen kannst.
    3. Eine Methode namens OnButtonPressed() mit dem Parameter InPlayer : agent und einem void-Rückgabetyp, der ToggleLights() beim PuzzleDevice aufruft. 
       button_event_handler := class():
 # Positionen, die zum Zugreifen auf die Lichter dienen, die von dieser Schaltfläche gesteuert werden.
 Indices : []int

 # tagged_lights_puzzle, das diesen button_event_handler erstellt hat, damit du Funktionen darauf aufrufen kannst
 PuzzleDevice : tagged_lights_puzzle
    
 OnButtonPressed(InPlayer : agent) : void =
     # Teile dem PuzzleDevice mit, dass es die Lichter an den Positionen ein-/ausschalten soll, welche von dieser Schaltfläche gesteuert werden.
     PuzzleDevice.ToggleLights(Indices)
  2. Erstelle ein bearbeitbares button_device-Arrayfeld in der tagged_lights_puzzle-Klsse, um die Tasten zu referenzieren, mit denen der Spieler interagieren kann: 
     @editable
 Buttons : []button_device = array{}
  3. Aktualisiere jetzt OnBegin() in der tagged_lights_puzzle-Klasse, um eine button_event_handler-Instanz für jede Taste zu erstellen. Der button_event_handler benötigt folgende Informationen:
    • Indizes der Lichter, die mit der Taste verknüpft sind. Du erhältst sie über das ButtonsToLights-Array mithilfe des ButtonIndex, der vom for-Ausdruck bereitgestellt wird. Du kannst ihn als Filterbedingung des for-Ausdrucks abrufen, der zum Iterieren durch alle Buttons verwendet wird. Er dient auch als Schutz des Codes vor dem Indizieren ungültiger Daten; wenn das Indizieren fehlschlägt, wäre das Programm dennoch gültig, da die fehlerhafte Iteration übersprungen würde (zu so einem Fehlschlag könnte es kommen, wenn du vergisst, die Anzahl der ButtonsToLights mit der Anzahl der Buttons abzugleichen).
    • Eine Referenz auf dein Verse-Gerät, die Instanz von tagged_lights_puzzle. Um eine Referenz auf das aktuelle Objekt innerhalb einer Klassendefinition zu erhalten, kannst du Self verwenden.
    • Das Erstellen eines button_event_handler-Objekts mit diesen Daten sieht folgendermaßen aus: 
       OnBegin<override>()<suspends> : void =
  SetupPuzzleLights()
    
  for:
      ButtonIndex -> Schaltfläche : Schaltflächen
      LightIndices := ButtonsToLights[ButtonIndex]
  do:
      button_event_handler{Indices := LightIndices, PuzzleDevice := Self}
  4. Du kannst nun die OnButtonPressed()-Funktion des neu erstellten Handlers verwenden, um das InteractedWithEvent des Tastengeräts zu abonnieren. Wenn die OnButtonPressed()-Funktion aufgerufen wird, hast du Zugriff auf die Licht-Indizes sowie eine Referenz auf das tagged_lights_puzzle-Gerät, das mit der Taste verknüpft ist, mit welcher der Spieler interagiert hat. 
     OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
    
     for:
         ButtonIndex -> Schaltfläche : Schaltflächen
         LightIndices := ButtonsToLights[ButtonIndex]
     do:
         Button.InteractedWithEvent.Subscribe(button_event_handler{Indices := LightIndices, PuzzleDevice := Self}.OnButtonPressed)
  5. Speichere das Script in Visual Studio Code.
  6. Klicke in der UEFN-Symbolleiste auf Verse-Scripte erstellen, um dein Verse-Gerät im Level mit deinem neuen Code zu aktualisieren.
  7. Wähle im Outliner das Gerät tagged_lights_puzzle aus, um sein Detail-Panel zu öffnen.
  8. Füge dem Buttons-Array im Detail-Panel vier Elemente hinzu und weise jedem eine andere Taste zu. Die anderen Eigenschaften musst du nicht ändern, weil das Script diese Eigenschaften auffüllt.
  9. Klicke in der UEFN-Symbolleiste auf Spielen, um das Level einem Spieltest zu unterziehen.

Wenn du dein Level jetzt testest, solltest du mit den Schaltflächen interagieren können und jede Schaltfläche sollte je nach Einstellung der ButtonsLightsIndices ein anderes Set an Lichtern umschalten. Denke daran, dass GetCreativeObjectsWithTag() keine bestimmte Reihenfolge garantiert, so dass die Lichter, die aufgrund der Reihenfolge im Script umgeschaltet werden, möglicherweise nicht mit der Reihenfolge übereinstimmen, die du im Level siehst.

Der Spieler drückt die Tasten, und jede Taste schaltet eine andere Gruppe von Lichtern ein/aus.

Nächster Schritt

Im nächsten Schritt dieses 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.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page