10. Verse Schalterzustand-Rätsel

Es gibt zwei Rätsel, die mit Verse erstellt wurden. Das erste ist das Tagged-Lights-Rätsel. Das Tagged-Lights-Rätsel wird in dem versteckten Raum hinter der Treppe im Untergeschoss verwendet.

Du kannst den Code aus dem letzten Abschnitt des Tutorials kopieren und einfügen, aber es wird dringend empfohlen, dass du das Rätsel Stück für Stück zusammensetzt, um ein Verständnis dafür zu bekommen, wie die Sprache Verse funktioniert.

Das zweite Rätsel verwendet einen fest kodierten Logikschlüssel, um jeden Schalter zu überprüfen und sicherzustellen, dass der richtige Schalter in der richtigen Reihenfolge ausgelöst wurde.

Wenn der richtige Schalter betätigt wird, ertönt ein Erfolgsgeräusch. Wenn der falsche Schalter während der Sequenz betätigt wird, ertönt entsprechend ein Fehlersignal und eine Meldung wird angezeigt. Ein abschließender Erfolgssound und eine Nachricht werden abgespielt, und vier Gegenstände werden aktiviert, wenn das Rätsel gelöst ist.

Mit einem Array kannst du gültige und ungültige Zustände prüfen und jedes Gerät auslösen, das mit einem Zustand verbunden ist. Für dieses Beispiel wurde der Antwortschlüssel hartcodiert, um denjenigen zu helfen, die noch wenig Erfahrung in der Programmierung haben, den Code zu verstehen.

Die Rätsel-Geräte einrichten

Für dieses Rätsel benötigst du die folgenden Geräte:

• 4 x Schaltergerät

• 3 Audio-Player-Gerät

• 4 Gegenstands-Spawnpunkte

• 2 x HUD-Nachrichtenübermittler

• 1 x Auslöser-Gerät

• 1 x Verse-Gerät

Benenne deine Gegenstands-Spawnpunkte nach dem von ihnen gespawnten Gegenstand um.

Schaltergerät

Platziere ein Schaltergerät an der Wand neben der Tür und stelle die folgenden Optionen ein

Kopiere drei weitere Schaltergeräte an der Wand und platziere sie in einer Reihe.

Audio-Gerät

Platziere in der Mitte des Quadrats ein Audiogerät. Setze die Audio-Optionen auf die folgenden Werte.

Kopiere zwei weitere Audio-Geräte. Benenne die Geräte um und füge für jedes einen Sound-Einsatz hinzu:

• Gültig - Für die Wiedergabe des gültigen Audiogeräts, Match_Round_Change_01_Cue.

• Ungültig - Für die Wiedergabe des ungültigen Audiogeräts, Player_Checkpoint_Trigger_Cue.

• Abgeschlossen - Für die Wiedergabe des abgeschlossenen Audiogeräts, CTF_Return_Team_Cue

Auslöser-Gerät

Setze das Auslöser-Gerät rechts neben die Schalter und lege die folgenden Optionen fest.

Benenne das Gerät um in Invalid Trigger.

HUD-Nachrichtenübermittler

Richte den ersten HUD-Nachrichtenübermittler mit den folgenden Optionen ein.

Verschiebe anschließend den HUD-Nachrichtenübermittler außerhalb der Kellerwand, so dass er im Raum nicht sichtbar ist, und kopiere ihn.

Benenne jedes der HUD-Nachrichtenübermittler-Geräte um

• „Gegenstände finden“-HUD-Nachricht

• „Ungültig“-HUD-Nachricht

Verse-Gerät

Jetzt kannst du das Verse-Programm erstellen, das das Rätsel steuert. Erstelle mit dem Verse-Explorer ein neues Verse-Gerät mit dem Namen switch_state_puzzle und ziehe das Gerät in das Level. (Schritte zum Erstellen eines neuen Verse-Geräts findest du unter Eigenes Gerät mit Verse erstellen.

Rätsel-Design

Durch das Betätigen von Schaltern in der richtigen Reihenfolge können die Spieler diesen Teil des Escape Room überwinden.

Wenn der Spieler einen Schalter in der richtigen Reihenfolge betätigt, ertönt eine Glocke. Wenn der falsche Schalter eingeschaltet wird, ertönt ein Summer und setzt die Schalter zurück. Bei ungültigen Zuständen erscheint eine Meldung, und bei erfolgreichem Abschluss des Rätsels ertönt ein Erfolgsgeräusch, eine hilfreiche Meldung wird angezeigt und es werden Gegenstände erzeugt.

Du kannst die Logik des Rätsels anhand des folgenden Flussdiagramms veranschaulichen.

Klicke auf das Bild, um es zu vergrößern.

Die richtige Lösung des Rätsels ist in der nachstehenden Tabelle angegeben.

Verwendete Sprachfunktionen in Verse

• if, then, else: Mit den Ausdrücken if, then und else kannst du gültige und ungültige Zustände für jedes Schaltergerät und andere Geräte, die von Zuständen abhängig sind, finden.

• failure: Fehlerkontexte werden verwendet, um den aktuellen Zustand des Rätsels und seine Lösung zu bestimmen.

• for: Der for-Ausdruck wird verwendet, um die einzelnen Schalter im Rätsel zu durchlaufen und Operationen an ihnen durchzuführen.

Verwendete APIs

• Bearbeitbare Eigenschaften: Mehrere von Verse erstellte Geräteeigenschaften werden UEFN zur Verfügung gestellt, damit du sie im Editor anpassen kannst. Du kannst neue Rätselkonfigurationen erstellen, indem du diese Eigenschaften änderst.

• Geräte-Events: Das InteractedWithEvent der Schaltflächen wird zur Steuerung des Spielzustands verwendet.

Schalter-Interaktion

Überlege dir, welche Schritte erforderlich sind, um das Rätsel zu lösen. Zunächst musst du überprüfen, ob das Verse-Gerät ein Event registriert, wenn ein Spieler das Kästchen markiert. Um dies zu erreichen, schreibe zunächst Pseudocode, um das Interaktionskonzept zu beweisen.

1. Füge unterhalb der switch_state_puzzle-Klassendefinition die folgenden bearbeitbaren Felder hinzu.

   1. Ein bearbeitbares Array vom Typ switch_device mit dem Namen Switches. Dies verweist auf alle deine Schalter im Rätsel.

   2. Ein Variablen-Array vom Typ cancelable mit dem Namen SwitchSubscriptions. Dieses enthält eine Referenz auf jedes switch_device-Abonnement, die du zum Zurücksetzen der Schalter verwenden kannst.

    switch_state_puzzle := class(creative_device):
    
    @editable
    Switches : []switch_device = array{} #Referenziert die Schalter, mit denen Spieler interagieren können

    var SwitchSubscriptions : []cancelable = array{}

Copy full snippet

switch_state_puzzle := class(creative_device): @editable Switches : []switch_device = array{} #Referenziert die Schalter, mit denen Spieler interagieren können var SwitchSubscriptions : []cancelable = array{}

1. Erstelle in derselben Datei eine neue Klasse mit dem Namen switch_event_handler. In dieser Klasse identifizierst du das Verse-Gerät und die Schalter.

2. Füge eine neue Methode OnSwitchPressed() zur Klasse switch_event_handler hinzu. Diese Methode prüft das Verse-Gerät auf Spielerinteraktion durch den Aufruf von CheckSequence() in der Klasse item_switch_puzzle. Zudem wird jedes Mal, wenn ein Schalter betätigt wird, Geklickt ausgegeben.

## Eine Event-Handler-Klasse zur Behandlung von Schalter-Interaktionen
## Dieser Event-Handler wird in der obigen Schleife an Events angehängt.
switch_event_handler := class():
    PuzzleDevice : item_switch_puzzle
    Switch : switch_device

    OnSwitchPressed(InPlayer : agent) : void =
        Print("Geklickt")
        PuzzleDevice.CheckSequence(InPlayer)

Copy full snippet

## Eine Event-Handler-Klasse zur Behandlung von Schalter-Interaktionen ## Dieser Event-Handler wird in der obigen Schleife an Events angehängt. switch_event_handler := class(): PuzzleDevice : item_switch_puzzle Switch : switch_device OnSwitchPressed(InPlayer : agent) : void = Print("Geklickt") PuzzleDevice.CheckSequence(InPlayer)

Drucklogger hinzufügen

Eine Möglichkeit zu überprüfen, ob dein Code erfolgreich ist oder nicht, ist die Ausgabe in einem Log. So kannst du visuell sehen, welche Teile deines Codes wie geplant funktionieren, indem du Meldungen ausdruckst. Füge den Drucklogger oberhalb der Kreativmodus-Geräteklasse hinzu.

    Print<native><public>(Message:[]char, Level:log_level):void

Copy full snippet

Print<native><public>(Message:[]char, Level:log_level):void

Referenzieren von Schaltern

Jetzt brauchst du eine Möglichkeit, um deine Schalter im Rätsel zu referenzieren. Durch die Referenzierung der Schaltergeräte kannst du alle Schalter in einer Schleife durchlaufen und jedem Schalter Event-Handler hinzufügen, wenn das Spiel läuft.

1. Füge in OnBegin() in der Klasse switch_state_puzzle einen for Ausdruck hinzu, um jeden Switch im Switches Array zu durchlaufen. Ermittle den Index jedes Switch und speichere ihn in einer Variablen SwitchIndex.

2. Füge eine Print-Funktion unter dem for-Ausdruck hinzu, die den Schalter identifiziert, mit dem während der Laufzeit interagiert wird, indem du Schalter {SwitchIndex} hinzugefügt in den Print-Befehl eingibst.

3. Da die Lösung des Rätsels von einer bestimmten Reihenfolge der Schalterzustände abhängt, musst du überprüfen, ob das Rätsel gelöst ist, sobald ein Schalter seinen Zustand ändert. Dazu wird die zuvor definierte Klasse switch_event_handler verwendet, um auf zwei verschiedene Events pro Schalter zu warten. Erstelle für jeden Schalter zwei Abonnements, eines für die Schalter TurnedOnEvent und eines für die Schalter TurnedOffEvent. Abonniere beide Events mit der Funktion OnSwitchPressed() deiner Klasse switch_event_handler. Übergib eine Referenz sowohl auf das switch_state_puzzle als auch auf den aktuellen Switch.

    ## Wird ausgeführt, wenn das Gerät in einem laufenden Spiel gestartet wird
    OnBegin<override>()<suspends>:void=
        Print("Schalter-Rätsel wird geladen")

        # Durchlaufen jedes Schalters und Hinzufügen von Event-Handlern für jeden Schalter
        für (SwitchIndex -> Switch : Switches):
            Print("Schalter {SwitchIndex} hinzugefügt")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

Copy full snippet

## Wird ausgeführt, wenn das Gerät in einem laufenden Spiel gestartet wird OnBegin<override>()<suspends>:void= Print("Schalter-Rätsel wird geladen") # Durchlaufen jedes Schalters und Hinzufügen von Event-Handlern für jeden Schalter für (SwitchIndex -> Switch : Switches): Print("Schalter {SwitchIndex} hinzugefügt") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

1. Speichere das Script in Visual Studio Code, und klicke in UEFN auf Verse -> Build Verse Code.

Beim Testen deines Levels solltest du jedes Mal, wenn du einen Schalter ein- oder ausschaltest, sowohl den Index des Schalters, mit dem du interagiert hast, als auch das Wort Geklickt angezeigt bekommen.

Rätsel-Zustände

Jeder Schalter im Rätsel kann zwei Zustände haben, einen gültigen und einen ungültigen.

Um das Rätsel zu lösen, muss der Spieler die Schalter in einer bestimmten Reihenfolge umlegen. Um diese Reihenfolge im Code zu implementieren, musst du eine Abfolge von gültigen Zuständen für jeden Schalter definieren und diese Abfolge jedes Mal überprüfen, wenn ein Spieler den Schalterzustand aktualisiert.

1. Füge eine neue Methode ValidState() zur Klasse switch_state_puzzle hinzu. Diese Methode nimmt einen String und spielt einen Audioclip ab, sobald ein Spieler einen Schalter auf einen gültigen Zustand umlegt, und gibt ihm damit ein Audio-Feedback, dass er auf dem richtigen Weg ist.

2. In ValidState() gibst du den übergebenen State-String aus und rufst Play() für den zuvor eingerichteten ValidAudioPlayer auf.

    # Aktionen, die durchzuführen sind, wenn der Status gültig ist
    ValidState(State : string) : void =
        # Validierungssound abspielen
        Print("Gültiger {State}")
        ValidAudioPlayer.Play()

Copy full snippet

# Aktionen, die durchzuführen sind, wenn der Status gültig ist ValidState(State : string) : void = # Validierungssound abspielen Print("Gültiger {State}") ValidAudioPlayer.Play()

1. Füge eine neue Methode InvalidState() zur Klasse switch_state_puzzle hinzu. Diese Methode setzt alle Schalter zurück, nachdem ein Sound gespielt wurde, wenn der Spieler einen ungültigen Zustand ausgelöst hat.

    # Aktionen, die durchzuführen sind, wenn der Status ungültig ist
    InvalidState(InPlayer : agent) : void =
        # Summton abspielen 
        # Alle Schalter zurücksetzen
        Print("Ungültig")
        
Copy full snippet

# Aktionen, die durchzuführen sind, wenn der Status ungültig ist InvalidState(InPlayer : agent) : void = # Summton abspielen # Alle Schalter zurücksetzen Print("Ungültig")

1. In InvalidState() wird dem Spieler mitgeteilt, dass er einen ungültigen Zustand ausgelöst hat, indem Ungültig ausgegeben und ein Audioclip durch Aufruf von Play() auf dem zuvor eingerichteten InvalidAudioPlayer abgespielt wird. Du musst auch Trigger() für deinen InvalidTrigger und Show() für deine InvalidHUDMessage aufrufen.

	# Aktionen, die durchzuführen sind, wenn der Status ungültig ist
    InvalidState(InPlayer : agent) : void =
        # Summton abspielen 
        # Alle Schalter zurücksetzen
        Print("Ungültig")
        InvalidAudioPlayer.Play()
        InvalidTrigger.Trigger()
        InvalidHUDMessage.Show()
        
Copy full snippet

# Aktionen, die durchzuführen sind, wenn der Status ungültig ist InvalidState(InPlayer : agent) : void = # Summton abspielen # Alle Schalter zurücksetzen Print("Ungültig") InvalidAudioPlayer.Play() InvalidTrigger.Trigger() InvalidHUDMessage.Show()

Erstelle eine for-Schleife, die Events auf den Schalter-Geräten abonniert. Die print-Anweisung identifiziert, welche Schalter ein Spieler umlegt und die Sequenz, in der die Schalter umgelegt werden.

        # Durchlaufen jedes Schalters und Hinzufügen von Event-Handlern für jeden Schalter
        für (SwitchIndex -> Switch : Switches):
            Print("Schalter {SwitchIndex} hinzugefügt")
            Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)
            
Copy full snippet

# Durchlaufen jedes Schalters und Hinzufügen von Event-Handlern für jeden Schalter für (SwitchIndex -> Switch : Switches): Print("Schalter {SwitchIndex} hinzugefügt") Switch.TurnedOnEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed) Switch.TurnedOffEvent.Subscribe(switch_event_handler{PuzzleDevice := Self, Switch := Switch}.OnSwitchPressed)

Gehe in einer for-Schleife durch alle Schalter und schalte jeden einzelnen aus. Da die Methode TurnOff() des Schalters einen Spieler als Auslöser benötigt, gib den Spieler an, der den ungültigen Zustand ausgelöst hat.

        ## Durchlaufen der Schalter und Ausschalten jedes einzelnen 
        für (SwitchIndex -> Switch : Switches):
            Switch.TurnOff(InPlayer)

Copy full snippet

## Durchlaufen der Schalter und Ausschalten jedes einzelnen für (SwitchIndex -> Switch : Switches): Switch.TurnOff(InPlayer)

1. Speichere deinen Code und gehe zurück zu UEFN und wähle Verse > Build Verse Code.

Als Nächstes musst du die Logik in der Klasse item_switch_puzzle erstellen, die jeden Schalter in einer Schleife durchläuft und seinen Zustand anhand der Rätselmatrix prüft, um festzustellen, unter welchen Zustand (gültig oder ungültig) das Umlegen des Schalters fällt.

Sortierung der Schalterzustände

Die Überprüfung der Gültigkeit eines umgeschalteten Schalters erfolgt durch die Erstellung einer CheckSequence-Methode, die einen for-Ausdruck verwendet, um den aktuellen Zustand des Schalters zu überprüfen. Um festzulegen, ob der Zustandswechsel eines Schalters gültig ist oder nicht, kannst du eine if-Anweisung verwenden, um zu definieren, welche Schalterumschaltungen in der Sequenz gültig sind und welche nicht.

1. Füge eine neue Methode CheckSequence() hinzu. Diese Methode nimmt den Spieler als Auslöser für den Wechsel des Schalterzustands und ein Array von Logikwerten, die den Schalterzuständen entsprechen. Erstelle in CheckSequence() eine for-Schleife, um jeden Schalter im Switches-Array zu durchlaufen. Ermittle den Index jedes Schalters und speichere ihn in einer Variablen SwitchIndex. Prüfe in der for-Schleife jeden Schalterzustand durch den Aufruf von GetCurrentState[]. Gib dann den Zustand des Schalters im Log aus.

    # Funktion zur Validierung der Sequenz der Schalter
    CheckSequence(InPlayer : agent) : void =
        für (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")

Copy full snippet

# Funktion zur Validierung der Sequenz der Schalter CheckSequence(InPlayer : agent) : void = für (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")

Nun musst du eine Abfolge von Zuständen erstellen, gegen die du mit CheckSequence() prüfen kannst. Dazu wird die OnSwitchPressed()-Methode des switch_event_handler um eine neue Funktionalität erweitert.

Sequenzzustände

Erstelle die Sequenz für die Schaltzustände mit Hilfe von Arrays. Jedes Array prüft die Gültigkeit der Reihenfolge, in der die Schalter umgelegt werden. Protokolliere die Abfolge der Aktionen des Spielers auf den Schaltern, indem du den Drucklogger verwendest, um zu protokollieren, ob die Schalter angeklickt wurden und ob die Abfolge gültig ist, indem du die Nummer der Abfolge in den Logger druckst („Eins“, „Zwei“, „Drei“ und „Vier“).

1. Rufe in OnSwitchPressed() innerhalb einer if-Anweisung CheckSequence() auf und übergib sowohl den Spieler als auch ein neues Array mit logischen Werten. Dieses neue Array sollte deiner Reihe von Schaltern entsprechen, wobei false-Werte für Aus-Schalter und true-Werte für Ein-Schalter stehen. Setze den Schalter, den die Spieler zuerst drücken sollen, auf true und alle anderen Werte auf false. Wenn der Aufruf von CheckSequence[] erfolgreich ist, rufe ValidState() auf und übergebe "Eins", um den ersten gedrückten Schalter darzustellen.

    OnSwitchPressed(InPlayer : agent) : void =
        Print("Geklickt")
        PuzzleDevice.CheckSequence(InPlayer)

Copy full snippet

OnSwitchPressed(InPlayer : agent) : void = Print("Geklickt") PuzzleDevice.CheckSequence(InPlayer)

1. Hartcodiere den Antwortschlüssel für das Umlegen des Schalters für jeden der Schalter in deinem Rätsel in der Reihenfolge, in der sie gedrückt werden sollen.

    if:
            # Auf gültige Status prüfen und die Validierung der Status hartcodieren
            # [Aus],[Aus],[Ein],[Aus] Status eins
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

        else if:
            # Auf gültige Status prüfen
            #[Ein], [Aus], [Ein], [Aus] Status zwei
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Two")

        else if:
            # Auf gültige Status prüfen
            #[Ein], [Ein], [Ein], [Aus] Status Drei
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Three")
            
        else if:
            # Auf gültige Status prüfen
            #[Ein], [Ein], [Ein], [Ein] Status Vier, Puzzle ist abgeschlossen
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

Copy full snippet

if: # Auf gültige Status prüfen und die Validierung der Status hartcodieren # [Aus],[Aus],[Ein],[Aus] Status eins not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("One") else if: # Auf gültige Status prüfen #[Ein], [Aus], [Ein], [Aus] Status zwei Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Two") else if: # Auf gültige Status prüfen #[Ein], [Ein], [Ein], [Aus] Status Drei Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Three") else if: # Auf gültige Status prüfen #[Ein], [Ein], [Ein], [Ein] Status Vier, Puzzle ist abgeschlossen Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState()

1. Füge am Ende einen else-Ausdruck hinzu, der InvalidState() aufruft. Dies geschieht, wenn einer der Aufrufe von CheckSequence[] fehlschlägt.

    
    else:
            # Es ist kein gültiger Status, also ist es ein ungültiger.
            InvalidState(InPlayer)

Copy full snippet

else: # Es ist kein gültiger Status, also ist es ein ungültiger. InvalidState(InPlayer)

1. Dein switch_event_handler Code sollte nun wie folgt aussehen.

    # Funktion zur Validierung der Sequenz der Schalter
    CheckSequence(InPlayer : agent) : void =
        für (SwitchIndex -> Switch : Switches):
            if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off")
        
        if:
            # Auf gültige Status prüfen und die Validierung der Status hartcodieren
            # [Aus],[Aus],[Ein],[Aus] Status eins
            not Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("One")

        else if:
            # Auf gültige Status prüfen
            #[Ein], [Aus], [Ein], [Aus] Status zwei
            Switches[0].GetCurrentState[]
            not Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Two")

        else if:
            # Auf gültige Status prüfen
            #[Ein], [Ein], [Ein], [Aus] Status Drei
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            not Switches[3].GetCurrentState[]
        then:
            ValidState("Three")
            
        else if:
            # Auf gültige Status prüfen
            #[Ein], [Ein], [Ein], [Ein] Status Vier, Puzzle ist abgeschlossen
            Switches[0].GetCurrentState[]
            Switches[1].GetCurrentState[]
            Switches[2].GetCurrentState[]
            Switches[3].GetCurrentState[]
        then:
            CompletedState()

        else:
            # Es ist kein gültiger Status, also ist es ein ungültiger.
            InvalidState(InPlayer)

Copy full snippet

# Funktion zur Validierung der Sequenz der Schalter CheckSequence(InPlayer : agent) : void = für (SwitchIndex -> Switch : Switches): if(Switch.GetCurrentState[]) then Print("{SwitchIndex} On") else Print("{SwitchIndex} Off") if: # Auf gültige Status prüfen und die Validierung der Status hartcodieren # [Aus],[Aus],[Ein],[Aus] Status eins not Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("One") else if: # Auf gültige Status prüfen #[Ein], [Aus], [Ein], [Aus] Status zwei Switches[0].GetCurrentState[] not Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Two") else if: # Auf gültige Status prüfen #[Ein], [Ein], [Ein], [Aus] Status Drei Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] not Switches[3].GetCurrentState[] then: ValidState("Three") else if: # Auf gültige Status prüfen #[Ein], [Ein], [Ein], [Ein] Status Vier, Puzzle ist abgeschlossen Switches[0].GetCurrentState[] Switches[1].GetCurrentState[] Switches[2].GetCurrentState[] Switches[3].GetCurrentState[] then: CompletedState() else: # Es ist kein gültiger Status, also ist es ein ungültiger. InvalidState(InPlayer)

1. Speichere deinen Code und gehe zurück zu UEFN und wähle Verse > Build Verse Code.

Wenn du jetzt im Spiel Schalter betätigst, wird der Log ausgedruckt:

• Schalter-Rätsel wird geladen - wenn das Spiel beginnt

• Schalter {SwitchIndex} hinzugefügt - wenn ein Schalter zur Schleife hinzugefügt wird

• Geklickt - wenn ein Spieler einen Schalter betätigt

Gültiger Zustand {State} - wenn der Spieler den richtigen Schalter in der richtigen Reihenfolge einschaltet

• Ungültig - wenn der Spieler den falschen Schalter betätigt

Wenn das Log die Schalter korrekt meldet, kannst du der Klasse item_switch_puzzle weitere bearbeitbare Geräte hinzufügen und dafür sorgen, dass jeder dieser Zustände etwas bewirkt.

Geräte hinzufügen

Wenn der Spieler das Rätsel erfolgreich abgeschlossen hat und das Rätsel eine Schleife durch die ValidStates der Schalter bis hin zum CompletedState durchlaufen hat, sollte das Erfolgsergebnis etwas bewirken, z. B. Gegenstände gewähren.

Dasselbe gilt für die InvalidStates. Wenn ein Spieler das Rätsel falsch löst, sollte das Script dies berücksichtigen und die Spieler wissen lassen, dass sie es noch einmal versuchen müssen. Um dies zu erreichen, musst du der Klasse item_switch_puzzle zusätzliche Geräte hinzufügen.

Wenn du deinem Script bearbeitbare Geräte hinzufügst, werden diese in den Benutzeroptionen des Verse-Geräts angezeigt, wo du die Geräte mit dem Verse-Gerät verbinden kannst, damit sie im Spiel so funktionieren, wie es im Verse-Script beschrieben ist.

1. Füge die folgenden @editable devices unter dem item_switch_puzzle hinzu:

	@editable 
	InvalidTrigger : trigger_device = trigger_device{}

	@editable 
	InvalidHUDMessage : hud_message_device = hud_message_device{}

	@editable 
	InvalidAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	ValidAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	FindItemsHUDMessage : hud_message_device = hud_message_device{}

	@editable 
	CompletedAudioPlayer : audio_player_device = audio_player_device{}

	@editable 
	ItemSpawners : item_spawner_device = item_spawner_device{} #Dies erfasst alle Gegenstands-Spawnpunkte, die mit diesem Rätsel verbunden sind.
    
Copy full snippet

@editable InvalidTrigger : trigger_device = trigger_device{} @editable InvalidHUDMessage : hud_message_device = hud_message_device{} @editable InvalidAudioPlayer : audio_player_device = audio_player_device{} @editable ValidAudioPlayer : audio_player_device = audio_player_device{} @editable FindItemsHUDMessage : hud_message_device = hud_message_device{} @editable CompletedAudioPlayer : audio_player_device = audio_player_device{} @editable ItemSpawners : item_spawner_device = item_spawner_device{} #Dies erfasst alle Gegenstands-Spawnpunkte, die mit diesem Rätsel verbunden sind.

1. Füge eine neue Methode CompletedState() zu der Klasse item_switch_puzzle hinzu. Diese Methode behandelt die Aktionen, die durchgeführt werden, wenn das Rätsel abgeschlossen ist.

    ## Aktionen, die ausgeführt werden sollen, wenn das Rätsel gelöst ist
    CompletedState() : void =
        # Erfolgssound abspielen
        # Alle Schalter auf deaktiviert setzen
        # Gegenstände auf den beigefügten Gegenstands-Spawnpunkten ablegen.
        Print("Fertig!")

Copy full snippet

## Aktionen, die ausgeführt werden sollen, wenn das Rätsel gelöst ist CompletedState() : void = # Erfolgssound abspielen # Alle Schalter auf deaktiviert setzen # Gegenstände auf den beigefügten Gegenstands-Spawnpunkten ablegen. Print("Fertig!")

1. Füge einen for-Ausdruck zur Methode CompletedState() hinzu, der durch jeden Gegenstands-Spawnpunkt in ItemSpawners iteriert. Aktiviere jeden Gegenstands-Spawnpunkt mit Enable() und rufe dann SpawnItem() auf, um dem Spieler die Belohnung für das Lösen des Rätsels zu geben.

    ## Ausführung einer Schleife durch die Gegenstands-Spawnpunkte, sodass du jeden Gegenstands-Spawnpunkt aufrufen kannst, um seinen Gegenstand zu aktivieren und zu spawnen
        für (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

Copy full snippet

## Ausführung einer Schleife durch die Gegenstands-Spawnpunkte, sodass du jeden Gegenstands-Spawnpunkt aufrufen kannst, um seinen Gegenstand zu aktivieren und zu spawnen für (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem()

1. Sobald das Rätsel erfolgreich abgeschlossen wurde, musst du Play() auf CompletedAudioPlayer aufrufen, das du zuvor eingerichtet hast, die Metallstücke auf den Gegenstands-Spawnpunkten mit ItemSpawnerIndex spawnen lassen und Enable1 und SpawnItem aufrufen. Lass den Spieler wissen, dass er nach den neu gespawnten Gegenständen suchen soll, indem du Show() auf der FindItemsHUDMessage aufrufst. Außerdem möchtest du, dass der Spieler nicht weiter mit deinen Schaltern interagiert. Füge einen zweiten for-Ausdruck hinzu, um jeden Schalter in Switches in einer Schleife zu durchlaufen und sie durch den Aufruf von Disable() zu deaktivieren.

    # Aktionen, die ausgeführt werden, wenn das Rätsel gelöst ist
    CompletedState() : void =
        # Erfolgssound abspielen
        # Alle Schalter auf deaktiviert setzen
        # Gegenstände auf den beigefügten Gegenstands-Spawnpunkten ablegen.
        Print("Fertig!")
        
        # Schleife durch die Gegenstands-Spawnpunkte, so dass du jeden Gegenstands-Spawnpunkt aufrufen kannst, um seinen Gegenstand zu aktivieren und zu spawnen
        für (ItemSpawnerIndex -> ItemSpawner : ItemSpawners):
            ItemSpawner.Enable()
            ItemSpawner.SpawnItem()

        # Spielt den speziellen Audiohinweis für das Abschließen der Rätselsequenz ab
        CompletedAudioPlayer.Play()

        # Spielt eine HUD-Nachricht ab, um die Spieler aufzufordern, nach neu gespawnten Gegenständen zu suchen
        FindItemsHUDMessage.Show()

	    # Deaktiviert alle Schalter, wenn das Rätsel erfolgreich gelöst wurde
        für (SwitchIndex -> Switch : Switches):
            Switch.Disable()

Copy full snippet

# Aktionen, die ausgeführt werden, wenn das Rätsel gelöst ist CompletedState() : void = # Erfolgssound abspielen # Alle Schalter auf deaktiviert setzen # Gegenstände auf den beigefügten Gegenstands-Spawnpunkten ablegen. Print("Fertig!") # Schleife durch die Gegenstands-Spawnpunkte, so dass du jeden Gegenstands-Spawnpunkt aufrufen kannst, um seinen Gegenstand zu aktivieren und zu spawnen für (ItemSpawnerIndex -> ItemSpawner : ItemSpawners): ItemSpawner.Enable() ItemSpawner.SpawnItem() # Spielt den speziellen Audiohinweis für das Abschließen der Rätselsequenz ab CompletedAudioPlayer.Play() # Spielt eine HUD-Nachricht ab, um die Spieler aufzufordern, nach neu gespawnten Gegenständen zu suchen FindItemsHUDMessage.Show() # Deaktiviert alle Schalter, wenn das Rätsel erfolgreich gelöst wurde für (SwitchIndex -> Switch : Switches): Switch.Disable()

1. Speichere deinen Code und gehe zurück zu UEFN und wähle Verse > Build Verse Code.

Jetzt wurden diese Geräte dem Gegenstands-Schalter-Rätsel-Gerät in UEFN hinzugefügt.

Geräte auswählen

Alle @editable Geräte werden dem Gerät Verse hinzugefügt. Jetzt musst du die Geräte, die du zum Erstellen des Rätsels herausgezogen hast, an dem Verse-Gerät befestigen. Wähle dazu item_switch_puzzle im Outliner und alle Geräte-Slots sind im Detail-Panel sichtbar. Du musst nur das Gerät an den Slot anschließen.

1. Füge die Geräte des Schalterrätsels zu den 4 Feldelementen des Schalterrätsels unter Gegenstand Schalterrätsel hinzu.

   

2. Füge den Ungültig-Auslöser zum InvalidTrigger-Slot hinzu

3. Füge die Ungültige HUD-Meldung zum Slot InvalidHUDMessage hinzu.

4. Füge den ungültigen Audioplayer zum InvalidAudioPlayer-Slot hinzu.

   

5. Füge den Gültig-Audioplayer zum ValidAudioPlayer-Slot hinzu.

6. Füge das Gerät HUD-Nachricht finden zum Slot FindHUDMessage hinzu.

7. Füge den Vollständig-Audioplayer zum CompletedAudioPlayer-Slot hinzu.

   

8. Füge die Gegenstands-Spawnpunkte zu den 4 ItemSpawners Array-Elementen hinzu.

   

9. Deaktiviere die Option Im Spiel sichtbar, um das Verse-Gerät während des Spiels zu verstecken.

   

Jetzt kannst du dein Level testen und herausfinden, wie die Rätsel das Escape-Room-Erlebnis bereichern.

Nächster Abschnitt

Wenn das Schalterzustand-Puzzle funktioniert, kannst du das Verse-Script für die automatische Teleportation erstellen, das die Spieler von der Eröffnungssequenz in den Warteraum im Untergeschoss der Hütte bringt, sobald die Kinosequenz zu Ende ist.