1. Epic GamesDeveloper
  3. Specificatori e attributi

Specificatori e attributi

Impara a conoscere gli specificatori e gli attributi e ad applicare semantica e comportamenti aggiuntivi al tuo codice Verse.

Specificatori e attributi

Gli specificatori in Verse descrivono un comportamento relativo alla semantica e possono aggiungere specificatori a identificatori e determinate parole chiave. La sintassi dello specificatore utilizza le parentesi angolari (< e >) con la parola chiave in mezzo. Ad esempio, in IsPuzzleSolved()<decides><transacts>:void, "decides" e "transacts" sono specificatori.

Gli attributi in Verse descrivono un comportamento che viene utilizzato al di fuori del linguaggio Verse (a differenza degli specificatori che descrivono la semantica di Verse). La sintassi degli attributi utilizza il segno at (@) seguito dalla parola chiave, ad esempio @editable.

Le sezioni seguenti descrivono tutti gli specificatori e gli attributi disponibili in Verse e i diversi casi di utilizzo.

Specificatori di effetto

Gli effetti in Verse indicano le categorie di comportamento che una funzione può assumere. Puoi aggiungere specificatori di effetto a:

  • Dopo () in una definizione di funzione: name()<specifier>:type = codeblock.

  • La parola chiave class: name := class<specifier>(){}.

Specificatore Descrizione Esempio

no_rollback

È l'effetto predefinito quando non viene specificato un effetto esclusivo. L'effetto no_rollback indica che qualsiasi azione eseguita dalla funzione non può essere annullata e, di conseguenza, la funzione non può essere utilizzata in un contesto di errore. Questo effetto non può essere specificato manualmente.

name():type = codeblock

transacts

L'effetto <transacts> è una combinazione di <allocates>, <reads> e <writes>.  L'effetto <transacts> non può essere combinato con questi specificatori.

name()<transacts> : type = codeblock

# non consentito perché transacts implica letture

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

# non consentito perché le transazioni implicano scritture

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

allocates

Questo effetto indica che la funzione potrebbe istanziare un oggetto nella memoria. Se il metodo viene chiamato in un contesto di errore che non riesce, gli effetti vengono annullati.

name()<allocates> : type = codeblock

reads

Un metodo con questo effetto può leggere da uno stato mutabile.

name()<reads> : type = codeblock

writes

Un metodo con questo effetto può scrivere in uno stato mutabile. Se il metodo viene chiamato in un contesto di errore che non riesce, gli effetti vengono annullati.

name()<writes> : type = codeblock

computes

Un metodo <computes> promette di restituire per sempre lo stesso output per qualsiasi input. Un metodo <computes> non può essere <transacts>, <reads>, <writes> o <allocates>.

name()<computes>

converges

Questo effetto garantisce non solo che non ci siano effetti collaterali dall'esecuzione della funzione correlata, ma anche che la funzione si completi (non sia ricorsiva all'infinito). Questo effetto può essere visualizzato solo nelle funzioni che hanno lo specificatore native, ma ciò non viene controllato dal compilatore. Il codice che fornisce i valori predefiniti per i campi della classe o i valori delle variabili globali deve avere questo effetto.

name()<converges> : type = codeblock

decides

Questo effetto indica che la funzione può non riuscire e che la chiamata a questa funzione è un'espressione fallibile. Poiché una funzione <decides> può avere esito negativo, si esclude a vicenda con l'effetto <suspends>. Può essere utile combinare <decides> con l'effetto <transacts> o <computes>, che permette di eseguire il rollback delle azioni eseguite da questa funzione (come se le azioni non fossero mai state eseguite) se si verifica un errore in qualsiasi punto della funzione.

# consentito

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

# consentito

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

# non consentito perché decides e suspends si escludono a vicenda

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

suspends

Questo effetto indica che la funzione è asincrona. Crea un contesto asincrono per il corpo della funzione. Si escludono a vicenda con l'effetto <decides>.

name()<suspends> : type = codeblock

# non consentito perché decides e suspends si escludono a vicenda

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

In tutti i casi, la chiamata di una funzione che ha un effetto specifico richiede che anche il chiamante abbia quell'effetto.

Specificatori di accesso

Gli specificatori di accesso definiscono cosa può interagire con un membro e in che modo. Gli specificatori di accesso possono essere applicati a quanto segue:

  • L'identificatore di un membro: name<specifier> : type = value

  • La parola chiave var per un membro: var<specifier> name : type = value

Puoi avere uno specificatore di accesso sia sull'identificatore che sulla parola chiave var di una variabile per distinguere tra chi ha accesso per leggere e scrivere la variabile. Ad esempio, la seguente variabile MyInteger ha lo specificatore pubblico sull'identificatore in modo che chiunque possa leggere il valore, ma la parola chiave var ha lo specificatore protetto in modo che solo la classe e i sottotipi correnti possano scrivere nella variabile.

Verse 
var<protected> MyInteger<public>:int = 2
Specificatore Descrizione Utilizzo Esempio

public

L'identificatore è universalmente accessibile.

Puoi utilizzare questo specificatore su:

  • Modulo

  • classe

  • Interfaccia

  • struttura

  • enum

  • Metodo

  • dati

Verse 
name<public> : type = value

protected

L'identificatore può essere consultato solo alla classe corrente e agli eventuali sottotipi.

Puoi utilizzare questo specificatore su:

  • classe

  • Interfaccia

  • struttura

  • funzioni all'interno di una classe

  • enum

  • metodo non modulo

  • dati

Verse 
name<protected> : type = value

private

L'identificatore può essere consultato solo nell'ambito corrente, di inclusione immediata (sia esso un modulo, una classe, una struttura ecc.).

Puoi utilizzare questo specificatore su:

  • classe

  • Interfaccia

  • struttura

  • funzioni all'interno di una classe

  • enum

  • metodo non modulo

  • dati

Verse 
name<private> : type = value

internal

L'identificatore può essere consultato solo nel modulo corrente di inclusione immediata. È il livello di accesso predefinito.

Puoi utilizzare questo specificatore su:

  • Modulo

  • classe

  • Interfaccia

  • struttura

  • enum

  • Metodo

  • dati

Verse 
name<internal> : type = value

scoped

È possibile accedere all'identificatore solo nell'ambito corrente e in tutti gli ambiti di inclusione. Tutti gli asset che esponi a Verse e che appaiono nel file Assets.digest.Verse avranno lo specificatore <scoped>.

Puoi utilizzare questo specificatore su:

  • Modulo

  • classe

  • Interfaccia

  • funzioni

  • struttura

  • enum

  • metodo non modulo

  • dati

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

Specificatori di classe

Gli specificatori di classe definiscono alcune caratteristiche delle classi o dei loro membri, come la possibilità di creare una sottoclasse di una classe.

Specificatore Descrizione Esempio

abstract

Quando una classe o un metodo di classe ha lo specificatore abstract, non è possibile creare un'istanza della classe. Le classi astratte sono destinate a essere utilizzate come superclassi con implementazione parziale o come interfaccia comune. È utile quando non ha senso avere istanze di una superclasse, ma non si vogliono duplicare proprietà e comportamenti di classi simili.

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

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

castable

Indica che questo tipo è dinamicamente lanciabile. Lo specificatore <castable> ha una restrizione di compatibilità con le versioni precedenti sul suo utilizzo. Una volta pubblicata una classe o un'interfaccia, l'attributo <castable> non può essere né aggiunto né rimosso. In questo modo si possono introdurre comportamenti di lancio non sicuri, quindi l'operazione non è permessa.

Il tipo castable_subtype funziona in modo molto simile a subtype, ma richiede che tutti i tipi utilizzati con esso siano contrassegnati come <castable>. Ciò aumenta la sicurezza del codice nei punti in cui vengono utilizzati i cast dinamici.

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

Quando una classe ha lo specificatore concrete, puoi creare un'istanza della classe con un archetipo vuoto, il che significa che ogni campo della classe deve avere un valore predefinito. Ogni sottoclasse di una classe concreta è implicitamente concreta. Una classe concreta può ereditare direttamente da una classe astratta, solo se entrambe le classi sono definite nello stesso modulo.

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

unique

A una classe unique in Verse viene assegnata un'identità univoca per ogni istanza. Ciò significa che, anche se due istanze della stessa classe univoca hanno gli stessi valori di campo, non sono uguali poiché sono istanze distinte. Ciò consente di verificare l'uguaglianza tra istanze di classi univoche confrontando le loro identità con gli operatori =, < e >, il che le rende sottotipi del tipo confrontable. Le classi prive dello specificatore univoco non hanno tale identità e quindi si possono confrontare solo per l'uguaglianza in base ai valori dei loro campi. Ciò significa che le classi univoche si possono confrontare con gli operatori = e <> e sono sottotipi del tipo confrontabile.

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

È possibile utilizzare lo specificatore final solo su classi e membri di classi con le seguenti restrizioni:

  • Quando una classe ha lo specificatore final, non è possibile creare una sottoclasse della classe.

  • Quando un campo ha lo specificatore final, non è possibile eseguire l'override del campo in una sottoclasse.

  • Quando un metodo dispone dello specificatore final, non è possibile eseguire l'override del metodo in una sottoclasse.

Verse 
cat := class<final>():

final_super

Lo specificatore final_super è applicabile solo alle definizioni di classe e richiede che la definizione della classe derivi da una classe genitore o da un'interfaccia. Questo specificatore impone un vincolo di compatibilità futuro secondo cui la classe data deriverà sempre direttamente dal suo genitore; per questa e tutte le versioni pubblicate future di questa definizione di classe.

Ciò è necessario in Scene Graph per i sottotipi immediati di component per limitare il numero di istanze esattamente a zero o a una per entità Scene Graph. Questo limite si estende anche ai sottotipi di questi tipi.

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

Specificatore di persistenza

Quando un tipo personalizzato, come ad esempio una classe, presenta uno specificatore <persistable>, significa che puoi usarlo nelle tue variabili weak_map con ambito modulo e far sì che i loro valori persistano nelle varie sessioni di gioco. Per ulteriori dettagli sulla persistenza in Verse, consulta Utilizzo dei dati persistenti in Verse.

Puoi utilizzare lo specificatore persistente con i seguenti tipi. Segui i link per avere ulteriori dettagli.

Specificatori aperti e chiusi

Attualmente utilizzabili solo con le enumerazioni. Gli specificatori <open> e <closed> determinano come puoi modificare la definizione dell'enum una volta pubblicata la tua isola.

Puoi utilizzare gli specificatori open e closed con i seguenti tipi. Segui i link per avere ulteriori dettagli.

Specificatore Descrizione Esempio

Open

Specificatore attualmente applicabile solo alle enumerazioni.

Puoi aggiungere o riordinare i valori di un'enumerazione aperta, o modificarla in un'enum di tipo <closed>.

Le enumerazioni aperte sono ideali quando si prevede che il numero di valori intrinsechi possa aumentare in futuro. Ad esempio, un'enumerazione di tipi di armi.

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}

Enum chiusa

Specificatore attualmente applicabile solo alle enumerazioni.

Le enumerazioni sono chiuse per impostazione predefinita.

Le enumerazioni chiuse sono ideali nei casi in cui si prevede che i valori dell'enum rimangano invariati (ad esempio per i giorni della settimana).

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}

Specificatori di implementazione

Mentre non potrai utilizzare gli specificatori di implementazione quando scrivi il codice, potrai visualizzarli nelle API UEFN.

Specificatore Descrizione Esempio

native

Indica che i dettagli di definizione dell'elemento sono implementati in C++. Le definizioni di Verse con lo specificatore native generano automaticamente definizioni C++. Uno sviluppatore di Verse può successivamente compilare la sua implementazione. Puoi vedere questo specificatore utilizzato su:

  • classe

  • Interfaccia

  • enum

  • Metodo

  • dati

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

native_callable

Indica che un metodo di istanza è nativo (implementato in C++) e può essere richiamato da altro codice C++. Puoi vedere questo specificatore utilizzato su un metodo di istanza. Questo specificatore non si propaga alle sottoclassi e quindi non è necessario aggiungerlo a una definizione, quando esegui l'override di un metodo che include lo specificatore stesso

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

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

Attributi

Gli attributi in Verse descrivono un comportamento che viene utilizzato al di fuori del linguaggio Verse (a differenza degli specificatori, che descrivono la semantica di Verse). Gli attributi possono essere aggiunti nella riga di codice prima delle definizioni.

La sintassi degli attributi utilizza il simbolo @ (@) seguito dalla parola chiave.

Attributo Descrizione Esempio

editable

Indica che questo campo è una proprietà esposta che può essere modificata direttamente tramite UEFN, quindi non è necessario modificare il codice Verse per cambiarne il valore. Per maggiori dettagli, vedi Personalizzare le proprietà di un dispositivo.

Verse 
@editable
Platform : color_changing_tiles_device = color_changing_tiles_device{}

editable_text_box

Stringa modificabile che viene visualizzata come casella di testo nell'editor. Le caselle di testo modificabili attualmente non supportano i suggerimenti o le categorie.  Per maggiori dettagli, vedi Personalizzare le proprietà di un dispositivo.  

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

Cursore modificabile che utilizza il tipo float. Puoi trascinare il cursore nell'editor per aumentare o diminuire il valore. Per maggiori dettagli, vedi Personalizzare le proprietà di un dispositivo.  

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

Numero modificabile con minimo e massimo.  Per maggiori dettagli, vedi Personalizzare le proprietà di un dispositivo.  

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

Cursore vettoriale modificabile. Puoi trascinare per modificare i valori di ciascuno dei componenti del vettore.  Per maggiori dettagli, vedi Personalizzare le proprietà di un dispositivo.  

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

Numero vettoriale modificabile che può essere vector2, vector2i o vector3.  Per maggiori dettagli, vedi Personalizzare le proprietà di un dispositivo.  

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

Contenitore di valori modificabile. Attualmente, supporta solo gli array.  Per maggiori dettagli, vedi Personalizzare le proprietà di un dispositivo.  

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