Ein Wert ist eine Information – oder eine Anweisung, wie eine Informationen zu erhalten ist –, die der Eingabe einer Bedingung, einer Aktion oder eines anderen Werts zur Verfügung gestellt wird. Werte können miteinander kombiniert werden.

Es gibt sehr, sehr viele Werte, deswegen werden wir sie hier nicht alle ansprechen können. Sie werden aber im Editor des Workshops definiert. Hier sind einige, denen ihr wahrscheinlich begegnen werdet:

Ein Wert kann in einem Array, einer Sammlung mehrerer Werte, gespeichert werden.

• Es gibt einige Aktionen und Werte, mit denen ein Array erstellt oder modifiziert werden kann.
  • Zum Beispiel gibt der Wert [All Players] ein Array aller derzeit im Spiel befindlicher Spieler zurück.
  • Ihr könnt auch eure eigenen Arrays bilden, indem ihr die Operation [Append To Array] der Aktionen [Modify Global Variable] oder [Modify Player Variable] nutzt.
• Wenn als Eingabe ein Array erwartet wird, aber eine andere Art Wert zur Verfügung gestellt wird, wird dieser Wert für die Eingabe in ein Array mit einem einzelnen Element kopiert. Wenn umgekehrt ein Wert als Eingabe erwartet wird, aber ein Array empfangen wird, wird der erste Wert des Arrays genutzt (oder 0, wenn das Array leer ist).

In einer Variable kann ein Wert gespeichert werden, um später abgerufen zu werden. Mit Ausnahme von Strings kann jeder Wert in einer Variablen gespeichert werden. Alle Variablen beginnen mit einem Zahlenwert ([Number]) von 0.

Innerhalb eines Skripts gibt es zwei Variablentypen:

• Global Variable: Es gibt 26 globale Variablen, benannt von A bis Z. Jede Variable beinhaltet einen eigenen Wert oder ein Array an Werten.
• Player Variable: Jeder Spieler hat 26 Variablen, benannt von A bis Z. Jede Variable beinhaltet einen eigenen Wert oder ein Array an Werten.

Die drei folgenden Operationen können mit einer Variablen durchgeführt werden:

• "Set": Mit [Set Global Variable] und [Set Player Variable] gebt ihr der Variablen einen neuen Wert, der den alten ersetzt.
• "Modify": [Modify Global Variable] und [Modify Player Variable] modifizieren den Wert einer Variable mithilfe einer bestimmten arithmetischen Operation ([Add], also addieren, [Multiply], also multiplizieren usw.) oder einer Array-Operation (Append, also anhängen, Remove, also entfernen).
• Chase: [Chase Global Variable Over Time], [Chase Player Variable Over Time], [Chase Global Variable at Rate] und [Chase Player Variable at Rate] verändern die Variable allmählich – entweder in bestimmten Zeitabständen oder mit einer gewissen Geschwindigkeit.
  • Das Ziel dieser laufenden Veränderung kann eine Zahl oder ein Vektor sein (oder ein Wert, der zu einer Zahl oder einem Vektor führt).
    • Ist das Ziel eine Zahl, muss auch der Wert der Variable eine Zahl sein, ehe die laufende Veränderung beginnt, damit sie korrekt verfolgt werden kann.
    • Ist das Ziel ein Vektor, muss auch der Wert der Variable ein Vektor sein, ehe die laufende Veränderung beginnt, damit sie korrekt verfolgt werden kann.
    • Wenn für das Ziel [Reevaluation] aktiv ist, wird sich [Chase] nach Bedarf aktualisieren, um einen veränderten Zielwert zu verfolgen, selbst wenn der Zielwert vorher erreicht wurde. Weitere Informationen zu [Reevaluation] findet ihr unter Eine Aktion hinzufügen.
  • Mit den Aktionen [Stop Chasing Global Variable] und [Stop Chasing Player Variable] könnt ihr die Operation [Chase] abbrechen.
    • Wird [Chase] abgebrochen, behält die Variable ihren aktuellen Wert, der irgendwo zwischen dem Start- und dem Zielwert der Operation liegt.

Wir helfen euch dabei, den Modus „Vorsicht Lava“ zu erstellen, bei dem Helden entflammen und Schaden erleiden, wenn sie den Boden berühren.

1. Zuerst stellen wir sicher, dass ihr euer Spiel auf der gewünschten Karte bzw. auf den gewünschten Karten spielt.
   • Klickt auf Spielen > Spielbrowser > Erstellen > Einstellungen > Karten.
   • Wählt die Karte aus, auf der ihr das Spiel testen möchtet, und deaktiviert alle anderen.
2. Jetzt gehen wir in den Workshop.
   • Klickt auf Zurück.
   • Klickt auf Workshop.
3. Und jetzt ist es an der Zeit, ein Skript zu erstellen! Fügen wir unsere erste Regel hinzu.
   • Klickt auf Regel hinzufügen.
   • Im Kommentarbereich gebt ihr Zu brennen beginnen, falls am Boden ein. So wisst ihr, dass diese Regel dafür verantwortlich ist, dass Spieler in Brand gesetzt werden, wenn sie den Boden berühren.
   • Jetzt verändern wir den Eventtyp, um zu bestimmen, wann diese Regel ausgeführt werden soll.
     • Im Dropdown-Menü für das Event wählt ihr [Ongoing - Each Player]. Das sorgt dafür, dass diese Regel auf jeden Spieler im Spiel einzeln angewendet wird.
     • In den anderen Dropdown-Menüs lassen wir die Standardeinstellungen unverändert.
   • Als Nächstes fügen wir eine Bedingung hinzu. Diese Bedingung bestimmt, ob unsere Regel ausgeführt wird oder nicht. Ihr könnt auch keine Bedingung hinzufügen – dann wird die Regel immer ausgeführt!
     • Unter „Bedingungen“ klickt ihr auf Hinzufügen.
     • Im ersten Dropdown-Menü für den Wert wählt ihr [Is On Ground]. Dieser Wert gibt True zurück, wann immer der Spieler den Boden berührt.
     • In den anderen Dropdown-Menüs lasst ihr die Einstellungen unverändert und klickt einfach auf OK.
       • [Event Player] bezieht sich auf den „Spieler, für den die Regel derzeit gilt“.
   • Und schließlich fügen wir noch eine Aktion hinzu. Aktionen sind das, was passiert, wenn eine Bedingung erfüllt ist.
     • Diese Aktion wird dafür sorgen, dass ein Held entflammt, wenn er den Boden berührt.
       • Klickt unter „Aktionen“ auf Hinzufügen.
       • Im Dropdown-Menü für Aktionen wählt ihr [Set Status] aus.
       • Im Dropdown-Menü für den Status wählt ihr [Burning] aus.
       • Unter [Duration] setzt ihr den Zahlenschieber auf 10000.
       • In den anderen Dropdown-Menüs lasst ihr die Einstellungen unverändert und klickt einfach auf OK.
4. Probieren wir aus, ob euer Held brennt, während er auf dem Boden steht!
   • Klickt zweimal auf Zurück.
   • Klickt auf dem Bildschirm „Spiel erstellen“ auf Start.
   • Wählt einen Helden aus.
   • Sobald ihr das Spiel betretet, sollte euer Held in Flammen stehen.
   • Drückt Escape und klickt dann auf Workshop Editor öffnen, um weiter an eurem Skript zu arbeiten.
5. Lasst uns jetzt eine weitere Regel hinzufügen, die dafür sorgt, dass ein Held nicht brennt, während er in der Luft ist oder springt.
   • Wir müssen dafür nicht komplett von vorn anfangen, wir kopieren einfach die letzte Regel, die wir erstellt haben.
   • Dazu klickt ihr einfach neben der schon erstellten Regel auf Kopieren.
     • Jetzt klickt ihr auf Regel einfügen.
     • Die Beschreibung ändert ihr zu Nicht mehr brennen, falls nicht am Boden. So wisst ihr, dass diese Regel dafür sorgt, dass euer Held aufhört, zu brennen, wenn er sich in der Luft befindet oder springt.
     • Den Eventtyp behaltet ihr bei.
     • Jetzt bearbeiten wir die Bedingung. Diese Bedingung bestimmt, ob unsere Regel ausgeführt wird oder nicht.
       • Klickt auf die vorhandene Bedingung, die lautet [Is On Ground(Event Player) == True].
       • Im Dropdown-Menü für den Wert wählt ihr False.
       • In den anderen Dropdown-Menüs lasst ihr die Einstellungen unverändert und klickt einfach auf OK.
     • Als Nächstes bearbeiten wir die Aktion. Diese Aktion wird dafür sorgen, dass euer Held nicht mehr in Flammen steht, wenn er den Boden nicht berührt.
       • Klickt auf die vorhandene Aktion, die lautet [Set Status (Event Player, Null, Burning, 10000)].
       • Im Dropdown-Menü für Aktionen wählt ihr [Clear Status] aus.
       • Im Dropdown-Menü für den Status wählt ihr [Burning] aus.
       • In den anderen Dropdown-Menüs lasst ihr die Einstellungen unverändert und klickt einfach auf OK.
6. Probieren wir aus, ob euer Held in der Luft aufhört, zu brennen!
   • Klickt zweimal auf Zurück.
   • Sobald ihr das Spiel betretet, sollte euer Held in Flammen stehen. Springt, um zu sehen, ob das Feuer dann erlischt.
   • Drückt Escape und klickt dann auf Workshop Editor öffnen, um weiter an eurem Skript zu arbeiten.
7. Jetzt kümmern wir uns darum, dass ein Held Schaden erleidet, während er den Boden berührt.
   • Klappt die „Zu brennen beginnen, falls am Boden“-Regel aus.
   • Klickt unter „Aktionen“ auf Hinzufügen. Diese Aktion wird dafür sorgen, dass ein Held Schaden erleidet, während er den Boden berührt.
     • Im Dropdown-Menü für Aktionen wählt ihr [Damage Over Time] aus.
     • Unter [Duration] setzt ihr den Zahlenschieber auf 9999.
     • Unter [Damage Per Second] setzt ihr den Zahlenschieber auf 30.
     • In den anderen Dropdown-Menüs lasst ihr die Einstellungen unverändert und klickt einfach auf OK.
   • Klappt jetzt die „Nicht mehr brennen, falls nicht am Boden“-Regel aus.
     • Klickt unter „Aktionen“ auf Hinzufügen. Diese Aktion wird dafür sorgen, dass ein Held keinen Schaden erleidet, während er den Boden nicht berührt.
     • Im Dropdown-Menü für Aktionen wählt ihr [Stop All Damage Over Time] aus.
8. Probieren wir aus, ob euer Held Schaden erleidet, während er den Boden berührt, und keinen Schaden erleidet, während er in der Luft ist oder springt.
   1. Klickt zweimal auf Zurück.
   2. Verlasst den Startbereich und überprüft, ob euer Held Schaden erleidet.
   3. Springt, um zu sehen, ob euer Held nun keinen Schaden mehr erleidet.
9. Ihr habt es geschafft! Der Boden ist jetzt Lava!

Hier findet ihr eine ausführliche Erklärung des Spielmodus „Gespiegeltes Deathmatch“. In diesem Modus gibt es mehrere kurze Runden, in denen jeder denselben Helden spielt. Am Ende jeder Runde erscheint jeder Spieler dort, wo er zuletzt war, als nächster Held aus einer vorherbestimmten zufälligen Liste. Nach der letzten Runde hat der Spieler gewonnen, der die meisten Kills erzielen konnte.

Beispielsweise könnte in einem solchen Match jeder Spieler als McCree beginnen und in der nächsten Runde zu Pharah wechseln. In einem anderen Match beginnt ihr vielleicht als Widowmaker und wechselt in der zweiten Runde zu Ashe. So, wie diese Liste generiert wird, ist es äußerst unwahrscheinlich, dass ihr jemals die gleiche Heldenreihenfolge zweimal spielen werdet!

Also, wagen wir uns an die Erstellung eines Skripts für ein Gespiegeltes Deathmatch!

• Klickt auf Spielen > Spielbrowser > Erstellen > Einstellungen > Workshop.
• Zuerst erstellen wir die Regel, die eine Heldenliste erzeugt, die gespielt werden kann.
  • Diese Liste wird in der globalen Variable „L“ als Array gespeichert.
    • Arrays können alles Mögliche sein: eine Liste von Spielern, eine Heldenliste, eine Zahlenreihe, ein einzelner Wert – ein Array kann auch keine Werte beinhalten (das nennt man ein „leeres“ Array).
    • Jeder Wert in einem Array wird unter einem einzigartigen Index gespeichert, beginnend bei 0 und dann aufwärtszählend. Einen Index und seinen zugehörigen Wert nennt man auch Element des Arrays.
    • Die Reihenfolge innerhalb eines Arrays ist von Bedeutung, [Reaper, Winston, Mercy] ist also ein anderes Array als [Mercy, Winston, Reaper].
    • In einem Array kann es verschiedene Typen von Werten geben. So ist zum Beispiel folgendes Array denkbar: [123, Reaper, True, -4.5].
    • Wenn als Eingabe ein Array erwartet wird, aber ein einzelner Wert zur Verfügung gestellt wird, wird dieser Wert als einziges Element eines Arrays verstanden und ein Array erstellt.
    • Wenn umgekehrt ein einzelner Wert als Eingabe erwartet wird, aber ein Array empfangen wird, wird der erste Wert des Arrays als Eingabe genutzt (oder 0, wenn das Array leer ist).
  • Fügt eine Regel hinzu und gebt einen Kommentar ein, damit ihr wisst, was diese Regel tut.
  • Setzt den Eventtyp auf [Ongoing - Global]. Das bedeutet, dass nur eine einzelne Instanz dieser Regel ausgeführt werden wird.
  • Da wir dieser Regel keine Bedingungen hinzufügen, wird sie ausgeführt, sobald das Spiel beginnt.
  • Jetzt fügt wie folgt eine Aktion hinzu:
    • Aktion: Set Global Variable
      • Variable: L
    • Wert: Hero
      • Held: Wählt einen Helden aus, der im Spiel verfügbar sein soll.
    Damit wird das Helden-Array erstellt. Die Aktion [Set Global Variable] setzt für „L“ den ersten Helden auf der Liste fest.
  • Es wäre allerdings langweilig, wenn ihr nur einen spielbaren Helden hättet, also fügen wir noch mehr hinzu! Ergänzt wie folgt euer Skript um so viele Helden, wie ihr wollt:
    • Aktion: Modify Global Variable
      • Variable: L
    • Operation: Append
    • Wert: Hero
      • Held: Wählt einen Helden aus, der im Spiel verfügbar sein soll.
    Dadurch fügt ihr dem Array, das wir zuvor in „L“ erstellt haben, weitere Helden hinzu. Wenn unsere erste Aktion auch mit [Modify Global Variable] anstelle von [Set Global Variable] begonnen hätte, würde das Array mit 0 beginnen, da alle Variablen zunächst auf 0 gesetzt sind. Wenn ihr euren ersten Wert also nicht auf irgendetwas anderes setzt, habt ihr nachher ein Array, das zum Beispiel so aussieht: [0, Pharah, Hanzo, Ana, …] .
  • Fügen wir dieser Regel nun die letzte Aktion hinzu. Diese Aktion wird eine zufällig sortierte Kopie der globalen Variable „L“ (des Helden-Arrays) erstellen, einen Teil dieses nun zufällig sortierten Arrays kopieren (beginnend an Position 0) und dabei so viele Helden umfassen, wie dieser Spielmodus haben soll. Diese Kopie wird dann wieder in der globalen Variable „L“ abgespeichert, sodass wir dort nun eine zufällig sortierte Auswahl unserer ursprünglich festgelegten Heldenliste haben.
    • Ein Beispiel: Unsere ursprüngliche Heldenliste war [Ashe, Doomfist, Hanzo, McCree, Pharah, Soldier: 76, Zenyatta, Widowmaker, Ana]. Dann könnte das zufällige Array Folgendes sein: [Hanzo, Pharah, Widowmaker, Ana, Ashe, Doomfist, Soldier: 76, Zenyatta, McCree] und der ausgewählte Teil [Hanzo, Pharah, Widowmaker, Ana, Ashe, Doomfist].
• Die nächste Regel wird garantieren, dass alle Spieler zu jeder Zeit sicher den gleichen Helden spielen.
  • Fügt eine Regel hinzu und gebt einen Kommentar ein, damit ihr wisst, was diese Regel tut.
  • Setzt den Eventtyp auf [Ongoing - Each Player]. Das sorgt dafür, dass für jeden Spieler eine eigene Instanz der Regel ausgeführt wird.
  • Fügt zwei Bedingungen hinzu, die beide erfüllt sein müssen, damit ein Held zugeteilt wird:
    • Die Nummer der Runde, die globale Variable „R“, muss kleiner sein als die Anzahl aller Helden in der Heldenliste. Ist das nicht der Fall, wird das Spiel beendet, es wird kein Held mehr zugeteilt. Die Rundennummer beginnt bei 0 und wird aufwärtsgezählt, bei 6 Runden ist die letzte also Runde Nummer 5. Die globale Variable „R“ muss dazu nicht extra auf 0 gesetzt werden, da alle Variablen anfangs auf den Standardwert 0 gesetzt sind.
      • Wert: Global Variable
        • Variable: R
      • Operator: <
      • Wert: Count Of
        • Array: Global Variable
          • Variable: L
    • Hiermit wird überprüft, ob der Held, der derzeit von einem bestimmten Spieler gespielt wird, ein anderer ist als der gewünschte Held für diese Runde. Der „bestimmte“ Spieler ist der [Event Player], ein Wert, der sich auf den Spieler bezieht, für den aktuell eine Instanz der Regel ausgeführt wird. Der „gewünschte“ Held der aktuellen Runde ist der Held, der im entsprechenden Index der Heldenliste (globale Variable „L“) gespeichert ist. Da die Nummer der aktuellen Runde in der globalen Variable „R“ gespeichert ist, kann der gewünschte Held über [Value In Array] abgerufen werden.
      • Wert: Hero Of
        • Spieler: Event Player
      • Operator: !=
      • Wert: Value in Array
        • Array: Global Variable
          • Variable: L
        • Index: Global Variable
          • Variable: R
  • Sobald wir wissen, dass ein Spieler den Helden wechseln muss, werden zwei noch hinzuzufügende Aktionen ausgeführt:
    • Die erste Aktion wird dem [Event Player] den gewünschten Helden zuteilen. Die erste Eingabe für diese Aktion ist der Spieler, dessen Held ausgetauscht werden soll. Die zweite Eingabe ist der nächste Held, also wird der gewünschte Held zur Verfügung gestellt.
      • Aktion: Start Forcing Player To Be Hero
      • Spieler: Event Player
      • Held: Value In Array
        • Array: Global Variable
          • Variable: L
        • Index: Global Variable
          • Variable: R
    • Die zweite Aktion lädt schon einmal den nächsten Helden der Liste, damit der Spieler keine Verzögerung erlebt, während sein Held ausgetauscht wird. Der Held wird für jeden Spieler einzeln geladen, auch wenn jeder den gleichen Helden spielen wird. Das liegt daran, dass für die Spieler möglicherweise verschiedene Skins für den Helden geladen werden müssen. Der Wert [Add], mit dem die globale Variable „R“ um 1 erhöht wird, weist die Aktion an, den nächsten und nicht den aktuellen Helden zu laden. In der letzten Runde führt dies zu einem Index für das Array, der außerhalb der globalen Variable „L“ liegt. Das ist nicht problematisch, da alle Werte, die außerhalb des Arrays liegen, als 0 betrachtet werden. Jede Aktion, die einen Helden erwartet, aber 0 bekommt, tut also einfach nichts.
      • Aktion: Preload Hero
      • Spieler: Event Player
      • Held: Value In Array
        • Array: Global Variable
          • Variable: L
        • Index: Add
          • Wert: Global Variable
            • Variable: R
          • Wert: Number
            • Zahl: 1.00
• Die nächste Regel startet jede Runde, wenn diese noch nicht initialisiert wurde.
  • Fügt eine Regel hinzu und gebt einen Kommentar ein, damit ihr wisst, was diese Regel tut.
  • Setzt den Eventtyp auf [Ongoing - Global]. Das bedeutet, dass nur eine einzelne Instanz dieser Regel ausgeführt werden wird.
  • Jetzt fügt ihr drei Bedingungen hinzu, die erfüllt sein müssen, damit die Runde beginnt:
    • Das Spiel muss im Gange sein. Das bedeutet, dass die Teamzusammenstellung schon stattgefunden hat und die Aufstellungszeit abgelaufen ist, das Spiel aber noch nicht beendet ist.
      • Wert: Is Game In Progress
      • Operator: ==
      • Wert: True
    • Die globale Variable „I“ muss False sein. Mit dieser Variable wird angezeigt, ob die aktuelle Runde schon initialisiert wurde. Wurde die globale Variable „I“ nicht gesetzt, hat sie automatisch den Wert 0, was bei Vergleichen wie diesem gleichbedeutend mit False ist.
      • Wert: Global Variable
        • Variable: I
      • Operator: ==
      • Wert: False
    • Die Nummer der Runde, die globale Variable „R“, muss kleiner sein als die Anzahl aller Helden in der Heldenliste.
      • Wert: Global Variable
        • Variable: R
      • Operator: <
      • Wert: Count Of
        • Array: Global Variable
          • Variable: L
  • Sobald wir wissen, dass alle Bedingungen erfüllt sind, muss die Runde initialisiert werden. Fügt folgende Aktionen hinzu, die das übernehmen:
    • Die erste Aktion teilt dem ursprünglichen Spielmodus mit, dass das Match nicht aufgrund seiner normalen Kriterien enden sollte. Für ein Deathmatch bedeutet das, dass das Spiel nicht endet, weil die Zeit abläuft oder jemand die festgesetzte Punktzahl erreicht. Wenn diese Aktion ausgeführt wird, wird das Match erst beendet, wenn das Skript den Abschluss durch Spielmodus-Kriterien wieder aktiviert oder jemand explizit zum Sieger erklärt wird.
      • Aktion: Disable Built-in Game Mode Completion
    • Die nächste Aktion stellt den aktuellen Timer des Spielmodus auf die Länge einer Runde.
      • Aktion: Set Match Time
      • Zeit: Number
      • Zahl: 60.00
    • Diese Aktion setzt die globale Variable „I“ auf True, sodass erst dann wieder initialisiert wird, wenn die globale Variable „I“ zurück auf False gesetzt wird.
      • Aktion: Set Global Variable
      • Variable: I
      • Wert: True
• Diese Regel wartet darauf, dass die Zeit der aktuellen Runde abläuft, um dann mit der nächsten Runde weiterzumachen.
  • Fügt eine Regel hinzu und gebt einen Kommentar ein, damit ihr wisst, was diese Regel tut.
  • Setzt den Eventtyp auf [Ongoing - Global]. Das bedeutet, dass nur eine einzelne Instanz dieser Regel ausgeführt werden wird.
  • Jetzt fügt ihr zwei Bedingungen hinzu, die beide erfüllt sein müssen, damit das Spiel zur nächsten Runde übergeht:
    • Das Spiel muss im Gange sein. Das bedeutet, dass die Teamzusammenstellung schon stattgefunden hat und die Aufstellungszeit abgelaufen ist, das Spiel aber noch nicht beendet ist.
      • Wert: Is Game In Progress
      • Operator: ==
      • Wert: True
    • Die aktuelle Matchzeit muss 0 betragen, die Zeit der aktuellen Runde muss also abgelaufen sein.
      • Wert: Match Time
      • Operator: ==
      • Wert: Number
        • Zahl: 0.00
  • Sind beide Bedingungen erfüllt und ist die Runde beendet, wird das Match zur nächsten Rundennummer übergehen und die Runde wird als nicht initialisiert markiert. Damit das geschieht, fügt ihr die folgenden zwei Aktionen hinzu:
    • Diese Aktion meldet den anderen Regeln, dass das Match zur nächsten Runde übergegangen ist.
      • Aktion: Modify Global Variable
      • Variable: R
      • Operation: Add
      • Wert: Number
        • Zahl: 1.00
    • Diese Aktion setzt die globale Variable „I“ auf False, was den anderen Regeln signalisiert, dass eine neue Runde initialisiert werden muss.
      • Aktion: Set Global Variable
      • Variable: I
      • Wert: False
• Die letzte Regel beendet das Match, nachdem alle Runden gespielt wurden.
  • Fügt eine Regel hinzu und gebt einen Kommentar ein, damit ihr wisst, was diese Regel tut.
  • Setzt den Eventtyp auf [Ongoing - Global]. Das bedeutet, dass nur eine einzelne Instanz dieser Regel ausgeführt werden wird.
  • Fügt eine Bedingung hinzu, die überprüft, ob die globale Variable „R“ gleich der Anzahl der Elemente der globalen Variable „L“ ist. Ist dies der Fall, wurde mit jedem Helden auf der Heldenliste eine Runde gespielt. Dann sollte das Match enden.
    • Wert: Global Variable
      • Variable: R
    • Operator: ==
    • Wert: Count Of
      • Array: Global Variable
        • Variable: L
  • Sobald die Bedingung erfüllt ist, reaktiviert diese Aktion den Abschluss durch Spielmodus-Kriterien. Da der Timer auf 0 stehen wird, wird der Spielmodus das Match sofort beenden und der übliche Ablauf am Matchende beginnen.
    • Aktion: Enable Built-in Game Mode Completion