1. Epic GamesDeveloper
  3. Bezeichner und Attribute

Bezeichner und Attribute

Erfahre mehr über Bezeichner und Attribute und wie du zusätzliche Semantik und Verhalten auf deinen Verse-Code anwenden kannst.

Bezeichner und Attribute

Bezeichner in Verse beschreiben Verhalten in Verbindung mit Semantik und können Bezeichner zu Kennungen und bestimmten Schlüsselwörtern hinzufügen. In der Syntax der Bezeichner werden Winkelklammern (< und >) mit dem Schlüsselwort dazwischen verwendet. Zum Beispiel sind in IsPuzzleSolved()<decides><transacts>:void sind „decides“ und „transacts“ Bezeichner.

Attribute in Verse beschreiben ein Verhalten, das außerhalb der Verse-Sprache verwendet wird (im Gegensatz zu Bezeichnern, die die Semantik von Verse beschreiben). Die Attribut-Syntax verwendet das At-Zeichen (@), gefolgt von dem Schlüsselwort, zum Beispiel @editable.

In den folgenden Abschnitten werden alle in Verse verfügbaren Bezeichner und Attribute beschrieben, und es wird erläutert, wann du sie verwenden kannst.

Effekt-Bezeichner

Effekte in Verse zeigen Kategorien von Verhalten an, die eine Funktion zeigen kann. Du kannst Effektbezeichner hinzufügen zu:

  • Nach dem () in einer Funktionsdefinition: name()<specifier>:type = codeblock.

  • Das Schlüsselwort class: name := class<specifier>(){}.

Bezeichner Beschreibung Beispiel

no_rollback

Dies ist der Standardeffekt, wenn kein exklusiver Effekt angegeben ist. Der Effekt no_rollback gibt an, dass alle von der Funktion ausgeführten Aktionen nicht rückgängig gemacht werden können, weshalb die Funktion nicht in einem Fehlerkontext verwendet werden kann. Dieser Effekt kann nicht manuell festgelegt werden.

name():type = codeblock

abschließen

Der <transacts>-Effekt ist eine Kombination aus <allocates>, <reads> und <writes>.  Der <transacts>-Effekt von kann nicht mit diesen Bezeichnern kombiniert werden.

name()<transacts> : type = codeblock

# nicht erlaubt, da „transacts“ Lesevorgänge impliziert

name()<transacts><reads>: type = codeblock

# nicht erlaubt, da „transacts“ Schreibvorgänge impliziert

name()<transacts><writes>: type = codeblock

zuweist

Dieser Effekt zeigt an, dass die Funktion ein Objekt im Speicher instanziieren kann. Wenn die Methode in einem Fehlerkontext aufgerufen wird, der fehlschlägt, werden die Effekte rückgängig gemacht.

name()<allocates> : type = codeblock

liest

Eine Methode mit diesem Effekt kann aus veränderlichem Zustand lesen.

name()<reads> : type = codeblock

schreibt

Eine Methode mit diesem Effekt kann in veränderlichen Zustand schreiben. Wenn die Methode in einem Fehlerkontext aufgerufen wird, der fehlschlägt, werden die Effekte rückgängig gemacht.

name()<writes> : type = codeblock

berechnet

Eine <computes>-Methode garantiert, dass sie für jeden Input immer denselben Output zurückgibt. Eine <computes>-Methode kann nicht <transacts>, <reads>, <writes> oder <allocates> sein.

name()<computes>

konvergiert

Dieser Effekt garantiert nicht nur, dass die Ausführung der zugehörigen Funktion keine Nebenwirkung hat, sondern auch, dass die Funktion abgeschlossen wird (nicht unendlich rekursiv). Dieser Effekt kann nur in Funktionen auftreten, die den nativen Bezeichner haben, aber dies wird nicht vom Compiler überprüft. Code, der Standardwerte für Klassenfelder oder Werte für globale Variablen bereitstellt, muss diesen Effekt haben.

name()<converges> : type = codeblock

entscheidet

Dieser Effekt zeigt an, dass die Funktion fehlschlagen kann und dass der Aufruf dieser Funktion ein fehlbarer Ausdruck ist. Da eine Funktion <decides> fehlschlagen kann, schließt sie sich mit dem Effekt <suspends> gegenseitig aus. Es kann nützlich sein, <decides> mit dem <transacts> oder <computes>-Effekt zu kombinieren, der es ermöglicht, die von dieser Funktion ausgeführten Actions zurückzunehmen (als ob die Actions nie ausgeführt worden wären), wenn irgendwo in der Funktion ein Fehler auftritt.

# Zulässig

name()<decides><transacts> : type = codeblock

# Zulässig

name()<decides><computes> : type = codeblock

# nicht zulässig, da sich Entscheidungen und Aussetzungen gegenseitig ausschließen

name()<decides><suspends> : type = codeblock

aussetzen

Dieser Effekt zeigt an, dass die Funktion asynchron ist. Erzeugt einen asynchronen Kontext für den Körper der Funktion. Schließt sich gegenseitig mit dem <decides> Effekt aus.

name()<suspends> : type = codeblock

# nicht zulässig, da sich Entscheidungen und Aussetzungen gegenseitig ausschließen

name()<decides><suspends> : type = codeblock

Der Aufruf einer Funktion, die einen bestimmten Effekt hat, setzt in jedem Fall voraus, dass auch der Aufrufer diesen Effekt hat.

Zugriffsbezeichner

Zugriffbezeichner definieren, was mit einem Mitglied interagieren kann und wie. Du kannst Zugriffsbezeichner auf Folgendes anwenden:

  • Die Kennung für ein Mitglied: name<specifier> : type = value

  • Das Schlüsselwort var für ein Mitglied: var<specifier> name : type = value

Du kannst einen Zugriffsbezeichner sowohl auf der Kennung als auch auf dem var-Schlüsselwort für eine Variable haben, um zu unterscheiden, wer Zugang zum Lesen und Schreiben der Variable hat. Zum Beispiel hat die folgende Variable MyInteger den öffentlichen Bezeichner auf der Kennung, so dass jeder den Wert lesen kann, aber das var-Schlüsselwort hat den geschützten Bezeichner, so dass nur die aktuelle Klasse und der aktuelle Subtyp in die Variable schreiben können.

Verse 
var<protected> MyInteger<public>:int = 2
Bezeichner Beschreibung Verwendung Beispiel

öffentlich

Die Kennung ist universell zugänglich.

Du kannst diesen Bezeichner verwenden bei:

  • Modul

  • Klasse

  • Schnittstelle

  • struct

  • Aufzählung

  • Methode

  • Daten

Verse 
name<public> : type = value

geschützt

Auf die Kennung kann nur von der aktuellen Klasse und ihren Subypen zugegriffen werden.

Du kannst diesen Bezeichner verwenden bei:

  • Klasse

  • Schnittstelle

  • struct

  • funktioniert innerhalb einer Klasse

  • Aufzählung

  • Nicht-Modul-Methode

  • Daten

Verse 
name<protected> : type = value

privat

Auf die Kennung kann nur im aktuellen, unmittelbar umschließenden Bereich zugegriffen werden (sei es ein Modul, eine Klasse, eine Struktur usw.).

Du kannst diesen Bezeichner verwenden bei:

  • Klasse

  • Schnittstelle

  • struct

  • funktioniert innerhalb einer Klasse

  • Aufzählung

  • Nicht-Modul-Methode

  • Daten

Verse 
name<private> : type = value

intern

Auf die Kennung kann nur im aktuellen, unmittelbar umschließenden Modul zugegriffen werden. Dies ist die Standard-Zugriffsebene.

Du kannst diesen Bezeichner verwenden bei:

  • Modul

  • Klasse

  • Schnittstelle

  • struct

  • Aufzählung

  • Methode

  • Daten

Verse 
name<internal> : type = value

umfasst

Auf die Kennung kann nur im aktuellen Bereich und in allen einschließenden Bereichen zugegriffen werden. Alle Assets, die du für Verse freigibst und die in der Datei Assets.digest.Verse erscheinen, haben den Bezeichner <scoped>.

Du kannst diesen Bezeichner verwenden bei:

  • Modul

  • Klasse

  • Schnittstelle

  • funktioniert

  • struct

  • Aufzählung

  • Nicht-Modul-Methode

  • Daten

Verse 
# Enclosing scope for ModuleB and ModuleC.
ModuleA<public> := module:
    
    ModuleB<public> := module:

        # Internal to ModuleB.
        class_b1 := class{}

        # Allows access from anywhere inside ModuleA.
        class_b2<scoped{ModuleA}> := class {}

Klassenbezeichner

Klassenbezeichner definieren bestimmte Eigenschaften von Klassen oder deren Mitgliedern, z. B. ob du eine Subklasse einer Klasse erstellen kannst.

Bezeichner Beschreibung Beispiel

abstrakt

Wenn eine Klasse oder eine Klassenmethode den abstract-Bezeichner hat, kannst du keine Instanz der Klasse erstellen. Abstrakte Klassen sind dazu bestimmt, als Oberklasse mit teilweiser Implementierung oder als gemeinsames Interface verwendet zu werden. Dies ist nützlich, wenn es keinen Sinn macht, Instanzen einer Oberklasse zu haben, du aber keine Eigenschaften und Verhaltensweisen in ähnlichen Klassen duplizieren willst.

Verse 
pet := class<abstract>():
    Speak() : void

cat := class(pet):
    Speak() : void = {}

castable

Gibt an, dass dieser Typ dynamisch belegbar ist. Der Bezeichner <castable> hat eine Abwärtskompatibilitäteinschränkung für seine Verwendung. Sobald eine Klasse oder Schnittstelle veröffentlicht ist, kann das Attribut <castable> weder hinzugefügt noch entfernt werden. Dies kann zu unsicherem Casting-Verhalten führen und ist daher nicht zulässig.

Der Typ castable_subtype funktioniert sehr ähnlich wie der Subtyp, erfordert aber, dass jeder mit ihm verwendete Typ auch als <castable> gekennzeichnet ist. Dies erhöht die Codesicherheit an Ort und Stelle, an denen dynamisches Werfen verwendet wird.

Verse 
my_base := class {}

my_castable_type := class<castable>(my_base) {}

my_child_type := class(my_castable_type) {}

MySubtypeFunction(t:castable_subtype(my_base)):void=
    return

Main()<decides>:void =

concrete

Wenn eine Klasse den Bezeichner concrete hat, kannst du eine Instanz der Klasse mit einem leeren Archetyp erstellen, was bedeutet, dass jedes Feld der Klasse einen Standardwert haben muss. Außerdem ist jede Subklasse einer konkreten Klasse selbst konkret. Eine konkrete Klasse kann nur dann direkt von einer abstrakten Klasse erben, wenn beide Klassen in demselben Modul definiert sind.

Verse 
cat := class<concrete>():
     # field must be initialized because the class is concrete
    Name : string = "Cat"

einzigartig

Einer einzigartigen Klasse in Verse wird für jede Instanz eine einzigartige Identität zugewiesen. Das heißt, selbst wenn zwei Instanzen derselben eindeutigen Klasse dieselben Feldwerte haben, sind sie nicht gleich, da es sich um unterschiedliche Instanzen handelt. So können Instanzen von einzigartigen Klassen auf Gleichheit verglichen werden, indem ihre Identitäten verglichen werden. Klassen ohne den `unique`-Bezeichner haben keine solche Identität und können daher nur auf der Grundlage der Werte ihrer Felder auf Gleichheit verglichen werden. Das bedeutet, dass einzigartige Klassen mit den Operatoren „=“ und „<>“ verglichen werden können und Subtypen des Typs „comparable“ sind.

Verse 
unique_class := class<unique>:
    Field : int

Main()<decides> : void =
    X := unique_class{Field := 1}
    X = X # X is equal to itself
    Y := unique_class{Field := 1}
    X <> Y # X and Y are unique and therefore not equal

final

Du kannst den Bezeichner final nur für Klassen und Mitglieder von Klassen verwenden, mit den folgenden Einschränkungen:

  • Wenn eine Klasse den final-Bezeichner hat, kannst du keine Subklasse der Klasse erstellen.

  • Wenn ein Feld den final-Bezeichner hat, kannst du das Feld nicht in einer Unterklasse außer Kraft setzen.

  • Wenn eine Methode den Bezeichner `final` hat, kannst du die Methode in einer Subklasse nicht außer Kraft setzen.

Verse 
cat := class<final>():

final_super

Der Bezeichner final_super gilt nur für Klassendefinitionen und erfordert, dass die Klassendefinition von einer Parent-Klasse oder einem Interface abgeleitet ist. Dieser Bezeichner legt eine zukünftige Kompatibilitätsbeschränkung fest, dass die angegebene Klasse immer direkt von ihrem Parent abgeleitet wird. Für diese und alle zukünftigen veröffentlichten Versionen dieser Klassendefinition.

Das ist in Scene Graph für unmittelbare Subtypen von component notwendig, um die Anzahl der Instanzen auf genau Null oder eine pro Scene Graph-Entität zu begrenzen. Diese Beschränkung gilt auch für Subtypen dieser Typen.

Verse 
component := class {}
my_final_class := class<final_super>(component) {}

# Not allowed since my_final_class has the final_super specifier.
my_subclass_type := class(my_final_class) {}

Persistenz-Bezeichner

Wenn ein benutzerdefinierter Typ, z. B. eine Klasse, den Bezeichner <persistable> hat, bedeutet dies, dass du ihn in deinen modulbezogenen weak_map-Variablen verwenden kannst und dass seine Werte über mehrere Spielsitzungen hinweg bestehen bleiben. Weitere Details zur Persistenz in Verse findest du unter Verwenden dauerhafter Daten in Verse.

Du kannst den dauerhaften Bezeichner mit folgenden Typen verwenden. Folge den Links für weitere Details.

Bezeichner für „Open“ und „Closed“.

Derzeit nur mit Aufzählungen anwendbar. Die Bezeichner <open> und <closed> bestimmen, wie du die Definition der Enum ändern kannst, sobald deine Insel veröffentlicht wurde.

Du kannst die Bezeichner „open“ und „closed“ mit folgenden Typen verwenden. Folge den Links für weitere Details.

Bezeichner Beschreibung Beispiel

Offen

Ein Bezeichner, der derzeit nur für Enums gilt.

Du kannst Enum-Werte in einer offenen Enum hinzufügen oder neu anordnen oder sie in eine <closed> Enum ändern.

Offene Enums werden am besten eingesetzt, wenn du davon ausgehst, dass die Anzahl der Werte in deiner Enum in Zukunft zunehmen wird. Zum Beispiel eine Enum von Waffentypen.

Verse 
# Enums are <closed> by default so you must explicitly define the enum as an open enum with the <open> specifier
my_enum := enum<open>{Value1, Value2, Value3}

Geschlossen

Ein Bezeichner, der derzeit nur für Enums gilt.

Enums sind standardmäßig geschlossen.

Geschlossene Enums werden am besten für Fälle verwendet, in denen deine Werte erwartungsgemäß gleich bleiben, z. B. für Wochentage.

Verse 
# Enums are <closed> by default so the specifier is not required.
my_enum := enum{Value1, Value2, Value3}

# You can also explicitly define the enum as closed by adding the <closed> specifier
my_enum := enum<closed>{Value1, Value2, Value3}

Implementierungsbezeichner

Es ist nicht möglich, Implementierungsbezeichner beim Schreiben von Code zu verwenden, aber du wirst diese sehen, wenn du dir die UEFN-APIs ansiehst.

Bezeichner Beschreibung Beispiel

Nativ

Gibt an, dass die Definitionsdetails des Elements in C++ implementiert sind. Verse-Definitionen mit dem Bezeichner native generieren automatisch C++ Definitionen. Ein Verse-Entwickler kann diese dann mit seiner Implementierung ausfüllen. Diesen Bezeichner siehst du verwendet für:

  • Klasse

  • Schnittstelle

  • Aufzählung

  • Methode

  • Daten

Verse 
GetCreativeObjectsWithTag<native><public>(Tags:tag)<transacts>:[]creative_object_interface

native_callable

Gibt an, dass eine Instanzmethode sowohl nativ (in C++ implementiert) ist als auch von anderem C++-Code aufgerufen werden kann. Diesen Bezeichner siehst du verwendet für eine Instanzmethode. Dieser Bezeichner wird nicht an Subklassen weitergegeben, so dass du ihn nicht zu einer Definition hinzufügen musst, wenn du eine Methode überschreibst, die diesen Bezeichner hat.

Verse 
creative_device<native><public> := class<concrete>:
    OnBegin<public>()<suspends>:void = external {}

    OnEnd<native_callable><public>():void = external {}

Attribute

Attribute in Verse beschreiben ein Verhalten, das außerhalb der Verse-Sprache verwendet wird (im Gegensatz zu Bezeichnern, die die Semantik von Verse beschreiben). Attribute können in der Codezeile vor den Definitionen hinzugefügt werden.

Die Attributsyntax verwendet das At-Zeichen (@), gefolgt von dem Schlüsselwort.

Attribut Beschreibung Beispiel

bearbeitbar

Gibt an, dass es sich bei diesem Feld um eine exponierte Eigenschaft handelt, die direkt von UEFN aus geändert werden kann, so dass du den Verse-Code nicht ändern musst, um seinen Wert zu ändern. Für weitere Einzelheiten, siehe Anpassen der Geräteeigenschaften.

Verse 
@editable
Platform : color_changing_tiles_device = color_changing_tiles_device{}

editable_text_box

Ein bearbeitbarer String, der im Editor als Textbox angezeigt wird. Bearbeitbare Textboxen unterstützen derzeit keine Tooltips oder Kategorien.  Für weitere Einzelheiten, siehe Anpassen der Geräteeigenschaften.  

Verse 
# An editable string that displays as a text box in the editor.
# Editable text boxes currently do not support tooltips or categories.
@editable_text_box:
    # Whether this text can span multiple lines.
    MultiLine := true

    # The maximum amount of characters this text block can display.
    MaxLength := 32
MessageBox:string = "This is a short message!"

editable_slider

Ein bearbeitbarer Schieberegler, der den Float-Typ verwendet. Du kannst den Schieberegler im Editor ziehen, um den Wert zu erhöhen oder zu verringern. Für weitere Einzelheiten, siehe Anpassen der Geräteeigenschaften.  

Verse 
# An editable slider that uses the float type. You can drag the slider in the editor to increase
# or decrease the value.
@editable_slider(float):
    # The categories this editable belongs to.
    Categories := array{FloatsCategory}

    # The tool tip for this editable.
    ToolTip := SliderTip

    # The minimum value of each component. You cannot set an editable value for this number lower

editable_number

Eine bearbeitbare Nummer mit Minimum und Maximum.  Für weitere Einzelheiten, siehe Anpassen der Geräteeigenschaften.  

Verse 
# An editable number with minimum and maximum
@editable_number(int):

    # The tool tip for this editable.
    ToolTip := EditableIntTip

    # The category this editable belongs to.
    Categories := array{IntsCategory}

    # The minimum value of each component. You cannot set an editable value for this number lower

editable_vector_slider

Ein bearbeitbarer Vektor-Schieberegler. Durch Ziehen kannst du die Werte jeder Vektorkomponente ändern.  Für weitere Einzelheiten, siehe Anpassen der Geräteeigenschaften.  

Verse 
# An editable vector slider. You can drag to change the values of each of the vector components.
@editable_vector_slider(float):
    # The tool tip for this editable.
    ToolTip := VectorSliderTip

    # The categories this editable belongs to.
    Categories := array{FloatsCategory}

    # Shows the option to preserve the ratio between vector values in the editor.
    ShowPreserveRatio := true

editable_vector_number

Eine bearbeitbare Vektorzahl, die ein vector2, vector2i oder vector3 sein kann.  Für weitere Einzelheiten, siehe Anpassen der Geräteeigenschaften.  

Verse 
# An editable vector number, which can be a vector2, vector2i, or vector3.
@editable_vector_number(float):

    # The categories this editable belongs to.
    Categories := array{FloatsCategory}

    # The tool tip for this editable.
    ToolTip := VectorFloatTip

    # Shows the option to preserve the ratio between vector values in the editor.

editable_container

Ein bearbeitbarer Container mit Werten. Derzeit werden nur Arrays unterstützt.  Für weitere Einzelheiten, siehe Anpassen der Geräteeigenschaften.  

Verse 
An editable container of values. Currently, this only supports arrays.
@editable_container:

    # The category this editable belongs to.
    Categories := array{IntsCategory}

    # The tool tip for this editable.
    ToolTip := IntArrayTip

    # Whether dragging elements to reorder this container is allowed.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page