1. Epic GamesDeveloper
  3. Specyfikatory i atrybuty

Specyfikatory i atrybuty

Informacje na temat specyfikatorów i atrybutów oraz sposobu stosowania dodatkowej semantyki i zachowania do kodu w Verse.

Specyfikatory i atrybuty

Specyfikatory w Verse opisują zachowanie powiązane z semantyką i można dodawać specyfikatory do identyfikatorów oraz określonych słów kluczowych. Składnia specyfikatora zawiera nawiasy ostre (< i >), między którymi umieszcza się słowo kluczowe. Na przykład w IsPuzzleSolved()<decides><transacts>:void specyfikatorami są "decides" i "transacts".

Atrybuty w Verse opisują zachowanie używane poza językiem Verse (w przeciwieństwie do specyfikatorów, które opisują semantykę języka Verse). Składnia atrybutu wykorzystuje symbol at (@), po którym następuje słowo kluczowe, np. @editable.

W poniższych sekcjach opisano wszystkie specyfikatory i atrybuty dostępne w Verse oraz okoliczności, w których się je stosuje.

Specyfikatory efektów

Efekty w Verse wskazują kategorie zachowania, jakie funkcja może przejawiać. Specyfikatory efektów można dodać do następujących elementów:

  • Po nawiasach () w definicji funkcji: name()<specifier>:type = codeblock.

  • Słowo kluczowe class: name := class<specifier>(){}.

Specyfikator Opis Przykład

no_rollback

Jest to efekt domyślny stosowany, gdy nie zostanie wskazany żaden efekt wyłączny. Efekt no_rollback wskazuje, że nie można cofnąć żadnej akcji wykonanej przez funkcję oraz że funkcji nie można zastosować w kontekście niepowodzenia. Tego efektu nie można zdefiniować ręcznie.

name():type = codeblock

transacts

Efekt <transacts> jest kombinacją tagów <allocates>, <reads> i <writes>.  Efektu <transacts> nie można łączyć z tymi specyfikatorami.

name()<transacts> : type = codeblock

# niedozwolone, ponieważ transacts implikuje reads

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

# niedozwolone, ponieważ transacts implikuje writes

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

allocates

Ten efekt wskazuje, że funkcja może tworzyć instancje obiektu w pamięci. Jeśli metoda zostanie wywołana w kontekście niepowodzenia, który zakończy się niepowodzeniem, efekty zostaną cofnięte.

name()<allocates> : type = codeblock

reads

Metoda z tym efektem może odczytywać ze stanu zmiennego.

name()<reads> : type = codeblock

writes

Metoda z takim efektem może zapisywać do stanu zmiennego. Jeśli metoda zostanie wywołana w kontekście niepowodzenia, który zakończy się niepowodzeniem, efekty zostaną cofnięte.

name()<writes> : type = codeblock

computes

Metoda <computes> gwarantuje, że dla każdego danego wejścia zawsze zwróci ten sam wynik. Metoda <computes> nie może być <transacts> <reads>, <writes> ani <allocates>.

name()<computes>

converges

Ten efekt gwarantuje, że wykonanie powiązanej funkcji nie przynosi efektów ubocznych, a dodatkowo funkcja zostanie zrealizowana (nie podlega nieskończonej rekursji). Ten efekt może występować tylko w funkcjach z specyfikatorem native, którego kompilator nie sprawdza. Kod, który wprowadza wartości domyślne klasy lub wartości zmiennych globalnych musi zawierać ten efekt.

name()<converges> : type = codeblock

decides

Ten efekt wskazuje, że funkcja może się zakończyć niepowodzeniem, a wywołanie takiej funkcji jest wyrażeniem zawodnym. Ponieważ funkcja <decides> może zakończyć się niepowodzeniem, wzajemnie się wyklucza z efektem <suspends>. Warto połączyć <decides> z efektem <transacts> lub <computes>, co pozwala na cofnięcie akcji wykonywanych przez tę funkcję (tak, jakby nigdy nie zostały wykonane), jeśli w dowolnym miejscu funkcji wystąpi niepowodzenie.

# dozwolone

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

# dozwolone

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

# niedozwolone, ponieważ decides i suspends wzajemnie się wykluczają

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

suspends

Ten efekt wskazuje, że funkcja jest asynchroniczna. Tworzy asynchroniczny kontekst ciała funkcji. Wzajemnie wyklucza się z efektem <decides>.

name()<suspends> : type = codeblock

# niedozwolone, ponieważ decides i suspends wzajemnie się wykluczają

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

W każdym przypadku wywołanie funkcji zawierające określony efekt wymaga, aby wywoływacz także zawierał dany efekt.

Specyfikatory dostępu

Specyfikatory dostępu określają, co i w jaki sposób może wchodzić w interakcje z elementem członkowskim. Specyfikatory dostępu można zastosować do następujących elementów:

  • Identyfikator elementu członkowskiego: name<specifier> : type = value

  • Słowo kluczowe var elementu członkowskiego: var<specifier> name : type = value

Specyfikator dostępu może być określony zarówno dla identyfikatora, jak i słowa kluczowego var dla zmiennej, aby rozróżnić, kto ma dostęp do odczytu i zapisu zmiennej. Na przykład poniższa zmienna MyInteger ma w identyfikatorze specyfikator public, dzięki czemu każdy może odczytać wartość, ale słowo kluczowe var ma specyfikator protected, aby tylko bieżąca klasa i podtypy mogły zapisywać w zmiennej.

Verse 
var<protected> MyInteger<public>:int = 2
Specyfikator Opis Użycie Przykład

public

Identyfikator jest powszechnie dostępny.

Ten specyfikator można dodawać do następujących elementów:

  • moduł

  • klasa

  • interfejs

  • struct

  • typ wyliczeniowy

  • metoda

  • dane

Verse 
name<public> : type = value

protected

Dostęp do identyfikatora mają jedynie bieżąca klasa i dowolne podtypy.

Ten specyfikator można dodawać do następujących elementów:

  • klasa

  • interfejs

  • struct

  • funkcje w klasie

  • typ wyliczeniowy

  • metoda niemodułowa

  • dane

Verse 
name<protected> : type = value

private

Dostęp do identyfikatora jest możliwy tylko w bieżącym, bezpośrednio otaczającym go zakresie (którym może być moduł, klasa, struktura itp.).

Ten specyfikator można dodawać do następujących elementów:

  • klasa

  • interfejs

  • struct

  • funkcje w klasie

  • typ wyliczeniowy

  • metoda niemodułowa

  • dane

Verse 
name<private> : type = value

internal

Dostęp do identyfikatora jest możliwy tylko w bieżącym, bezpośrednio otaczającym go module. Jest to domyślny poziom dostępu.

Ten specyfikator można dodawać do następujących elementów:

  • moduł

  • klasa

  • interfejs

  • struct

  • typ wyliczeniowy

  • metoda

  • dane

Verse 
name<internal> : type = value

scoped

Dostęp do identyfikatora jest możliwy tylko w bieżącym zakresie i wszystkich otaczających go zakresach. Wszelkie zasoby uwidaczniane w Verse, które pojawiają się w pliku Assets.digest.Verse, będą miały specyfikator <scoped>.

Ten specyfikator można dodawać do następujących elementów:

  • moduł

  • klasa

  • interfejs

  • funkcje

  • struct

  • typ wyliczeniowy

  • metoda niemodułowa

  • dane

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 {}

Specyfikatory klas

Specyfikatory klas określają konkretne cechy klas lub ich elementów członkowskich, takie jak możliwość utworzenia podklasy danej klasy.

Specyfikator Opis Przykład

abstract

Jeśli klasa lub metoda klasy zawiera specyfikator abstract, nie można utworzyć instancji danej klasy. Klasy abstrakcyjne służą jako nadklasy z częściową implementacją lub jako wspólny interfejs. Jest to przydatne, gdy tworzenie instancji nadklasy nie ma sensu i nie chcemy dublować właściwości oraz zachowań w podobnych klasach.

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

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

castable

Wskazuje, że ten typ można dynamicznie rzutować. Specyfikator <castable> ma ograniczenie kompatybilności wstecznej w swoim użyciu. Po opublikowaniu klasy lub interfejsu atrybutu <castable> nie można ani dodać, ani usunąć. Może to wprowadzić niebezpieczne zachowania rzutowania, więc jest to niedozwolone.

Typ castable_subtype działa bardzo podobnie jak subtype, ale wymaga, aby wszystkie używane typy były również oznaczone <castable>. Zwiększa to bezpieczeństwo kodu w miejscach, w których używa się rzutowania dynamicznego.

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

Gdy klasa ma specyfikator concrete, można skonstruować instancję klasy z pustym archetypem, co oznacza, że każde pole klasy musi mieć wartość domyślną. Każda podklasa klasy konkretnej w domyśle także jest konkretna. Klasa konkretna może dziedziczyć bezpośrednio z klasy abstrakcyjnej, jeśli obie klasy są zdefiniowane w tym samym module.

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

unique

Do każdej instancji klasy unique w Verse przypisywana jest unikatowa tożsamość. Oznacza to, że nawet jeśli dwie instancje tej samej unikatowej klasy mają te same wartości pól, nie są one równe, ponieważ są różnymi instancjami. Dzięki temu można porównywać instancje unikatowych klas pod względem równości, porównując ich tożsamości. Klasy bez specyfikatora unique nie mają takiej tożsamości, dlatego można je porównywać pod względem równości tylko na podstawie wartości ich pól. Oznacza to, że klasy unikatowe można porównywać za pomocą operatorów `=` oraz `<>` i że są one podtypami typu comparable.

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

Specyfikatora final można używać tylko w odniesieniu do klas i ich elementów członkowskich, z następującymi ograniczeniami:

  • Jeśli klasa ma specyfikator final, nie można tworzyć jej podklas.

  • Jeśli pole ma specyfikator final, nie można zastąpić tego pola w podklasie.

  • Jeśli metoda ma specyfikator final, nie można zastąpić tej metody w podklasie.

Verse 
cat := class<final>():

final_super

Specyfikator final_super ma zastosowanie tylko do definicji klas i wymaga, aby definicja klasy pochodziła z klasy nadrzędnej lub interfejsu. Specyfikator ten narzuca przyszłe ograniczenie kompatybilności, że dana klasa zawsze będzie bezpośrednio pochodzić od swojego elementu nadrzędnego; dla tej i wszystkich przyszłych publikowanych wersji tej definicji klasy.

W Scene Graph jest to konieczne dla bezpośrednich podtypów komponentu, aby ograniczyć liczbę instancji dokładnie do zera lub jednej na jednostkę Scene Graph. To ograniczenie dotyczy również podtypów tych typów.

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) {}

Specyfikator persystencji

Jeśli typ niestandardowy, jak np. klasa, posiada specyfikator <persistable>, oznacza to, że możesz użyć ich w swoich zmiennych weak_map o zasięgu modułowym i zachować ich wartości podczas sesji gry. Aby dowiedzieć się więcej na temat persystencji w Verse, patrz: Używanie persystentnych danych w Verse.

Specyfikator persystencji można stosować z następującymi typami. Pod tymi adresami można uzyskać więcej informacji.

Specyfikatory open i closed

Obecnie można ich używać tylko z wyliczeniami. Specyfikatory <open> i <closed> określają, w jaki sposób można zmienić definicję wyliczenia po opublikowaniu wyspy.

Specyfikatory open i closed można stosować z następującymi typami. Pod tymi adresami można uzyskać więcej informacji.

Specyfikator Opis Przykład

Open

Specyfikator, który obecnie ma zastosowanie tylko do wyliczeń.

W otwartym wyliczeniu można dodać wartości lub zmienić ich kolejność albo zmienić go na wyliczenie zamknięte (<closed>).

Otwarte wyliczenia najlepiej wykorzystywać, gdy oczekuje się, że liczba wartości w typie wyliczeniowym może w przyszłości wzrastać. Na przykład wyliczenie typów broni.

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}

Closed

Specyfikator, który obecnie ma zastosowanie tylko do wyliczeń.

Wyliczenia są domyślnie zamknięte.

Zamknięte wyliczenia najlepiej nadają się do zastosowań, w których wartości powinny pozostać takie same, na przykład dni tygodnia.

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}

Specyfikatory implementacji

Nie da się używać specyfikatorów implementacji podczas pisania kodu, jednak będą one widoczne przy przeglądaniu interfejsów API UEFN.

Specyfikator Opis Przykład

native

Wskazuje, że szczegóły definicji elementu są zaimplementowane w C++. Definicje Verse zawierające specyfikator native automatycznie generują definicje C++. Twórca Verse może wówczas wypełnić swoją implementację. Ten specyfikator można zastosować do następujących elementów:

  • klasa

  • interfejs

  • typ wyliczeniowy

  • metoda

  • dane

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

native_callable

Wskazuje, że metoda instancji jest zarówno natywna (zaimplementowana w C++), jak i może być wywoływana przez inny kod C++. Ten specyfikator jest używany w metodzie instancji. Nie propaguje się on do podklas, więc nie trzeba dodawać go do definicji podczas zastępowania metody, która ma ten specyfikator.

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

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

Atrybuty

Atrybuty w Verse opisują zachowanie używane poza językiem Verse (w przeciwieństwie do specyfikatorów, które opisują semantykę języka Verse). Atrybuty można dodać do wiersza kodu przed definicjami.

Składnia atrybutu wykorzystuje symbol at (@), po którym następuje słowo kluczowe.

Atrybut Opis Przykład

editable

Wskazuje, że dane pole jest właściwością uwidocznioną, którą można zmieniać bezpośrednio z poziomu UEFN, więc zmiana jej wartości nie wymaga modyfikowania kodu Verse. Aby dowiedzieć się więcej, patrz Dostosowywanie właściwości urządzeń.

Verse 
@editable
Platform : color_changing_tiles_device = color_changing_tiles_device{}

editable_text_box

Edytowalny ciąg tekstowy, który jest wyświetlany jako pole tekstowe w edytorze. Obecnie edytowalne pola tekstowe nie obsługują podpowiedzi ani kategorii.  Aby dowiedzieć się więcej, patrz Dostosowywanie właściwości urządzeń.  

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

Edytowalny suwak, który używa typu float. Suwak w edytorze można przeciągać, aby zwiększyć lub zmniejszyć wartość. Aby dowiedzieć się więcej, patrz Dostosowywanie właściwości urządzeń.  

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

Edytowalna liczba z wartością minimalną i maksymalną.  Aby dowiedzieć się więcej, patrz Dostosowywanie właściwości urządzeń.  

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

Edytowalny suwak wektora. Wartość każdego z komponentów wektora można zmienić, przeciągając ją.  Aby dowiedzieć się więcej, patrz Dostosowywanie właściwości urządzeń.  

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

Edytowalny numer wektora, który może przyjąć postać vector2, vector2i lub vector3.  Aby dowiedzieć się więcej, patrz Dostosowywanie właściwości urządzeń.  

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

Edytowalny kontener wartości. Obecnie obsługuje to tylko tablice.  Aby dowiedzieć się więcej, patrz Dostosowywanie właściwości urządzeń.  

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