1. Epic GamesDeveloper
  3. Atributos y especificadores

Atributos y especificadores

Obtén más información sobre los especificadores y los atributos, y cómo aplicar semánticas y comportamientos adicionales en tu código Verse.

Atributos y especificadores

Los especificadores en Verse describen el comportamiento en relación con la semántica y pueden añadir especificadores a los identificadores y a determinadas palabras clave. La sintaxis del especificador utiliza paréntesis angulares (< y >) con la palabra clave en el medio. Por ejemplo, en IsPuzzleSolved()<decides><transacts>:void, se especifican "decides" y "transacts".

En Verse, los atributos describen el comportamiento que se usa fuera del lenguaje Verse (a diferencia de los especificadores, que describen la semántica de Verse). La sintaxis de los atributos utiliza el signo dearroba (@) seguido de la palabra clave, por ejemplo, @editable.

En las siguientes secciones, se describen todos los especificadores y los atributos en Verse y cuándo puedes usarlos.

Especificadores de efecto

Los efectos en Verse indican categorías de comportamiento que puede mostrar una función. Puedes añadir especificadores de efecto a:

  • Después de () en una definición de función: name()<specifier>:type = codeblock.

  • La palabra clave clase: name := class<specifier>(){}.

Especificador Descripción Ejemplo

no_rollback

Este es el efecto predeterminado cuando no se especifica ningún efecto exclusivo. El efecto no_rollback indica que cualquier acción que realice la función no podrá revertirse por lo que la función no puede usarse en un contexto de fallo. No es posible especificar manualmente este efecto.

name():type = codeblock

transacts

El efecto <transacts> es una combinación de <allocates>, <reads> y <writes>.  El efecto <transacts> no puede combinarse con estos especificadores.

name()<transacts> : type = codeblock

# no permitido porque las transacciones implican lecturas

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

# no permitido porque transacción implica escritura

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

allocates

Este efecto indica que la función puede instanciar un objeto en la memoria. Si el método se llama en un contexto de error que falla, los efectos se deshacen.

name()<allocates> : type = codeblock

reads

Un método con este efecto puede leer desde un estado mutable.

name()<reads> : type = codeblock

writes

Un método con este efecto puede escribir en un estado mutable. Si el método se llama en un contexto de error que falla, los efectos se deshacen.

name()<writes> : type = codeblock

computes

Un método <computes> promete devolver para siempre la misma salida para cualquier entrada dada. Un método <computes> no puede ser <transacts> <reads>, <writes> o <allocates>.

name()<computes>

converges

Este efecto garantiza que no solo no haya efectos secundarios de la ejecución de la función relacionada sino que la función se complete (no se repite infinitamente). Este efecto solo puede aparecer en funciones que tengan el especificador nativo, pero el compilador no lo comprueba. El código que brinda valores predeterminados de clase de campo o valores de variables globales debe tener este efecto.

name()<converges> : type = codeblock

decides

Este efecto indica que la función puede fallar y que llamar a esta función es una expresión falible. Debido a que una función <decides> puede fallar, es mutuamente excluyente con el efecto <suspends>. Puede ser útil combinar <decides> con el efecto <transacts> o <computes>, que permite revertir las acciones realizadas por esta función (como si nunca se hubieran realizado) si se produce un error en cualquier parte de la función.

# permitido

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

# permitido

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

# no se permite porque las decisiones y las suspensiones son mutuamente excluyentes

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

suspends

Este efecto indica que la función es asíncrona. Crea un contexto asíncrono para el cuerpo de la función. Es mutuamente excluyente con el efecto <decides>.

name()<suspends> : type = codeblock

# no se permite porque las decisiones y las suspensiones son mutuamente excluyentes

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

En todos los casos, llamar a una función que tiene un efecto específico requerirá que también el llamador tenga ese efecto.

Especificadores de acceso

Los especificadores de acceso definen qué puede interactuar con un miembro y cómo. Puedes aplicar especificadores de acceso a lo siguiente:

  • El identificador de un miembro: name<specifier> : type = value

  • La palabra clave var para un miembro: var<specifier> name : type = value

Puedes tener un especificador de acceso tanto en el identificador como en la palabra clave var para una variable, para diferenciar quién tiene acceso de lectura y escritura en la variable. Por ejemplo, la siguiente variable MyInteger tiene el especificador public en el identificador para que cualquiera pueda leer el valor, pero la palabra clave var tiene el especificador protected para que solo la clase y el subtipo actuales puedan escribir en la variable.

Verse 
var<protected> MyInteger<public>:int = 2
Especificador Descripción Uso Ejemplo

public

El identificador es accesible universalmente.

Puedes usar el especificador en:

  • módulo

  • clase

  • interfaz

  • struct

  • enum

  • método

  • datos

Verse 
name<public> : type = value

protected

Solo la clase actual y cualquier subtipo pueden acceder al identificador.

Puedes usar el especificador en:

  • clase

  • interfaz

  • struct

  • funciones dentro de una clase

  • enum

  • método distinto de módulo

  • datos

Verse 
name<protected> : type = value

private

Solo se puede acceder al identificador en el ámbito actual inmediatamente incluido (ya sea un módulo, clase, estructura, etc.).

Puedes usar el especificador en:

  • clase

  • interfaz

  • struct

  • funciones dentro de una clase

  • enum

  • método distinto de módulo

  • datos

Verse 
name<private> : type = value

internal

Solo se puede acceder al identificador en el módulo actual inmediatamente incluido. Este es el nivel de acceso predeterminado.

Puedes usar el especificador en:

  • módulo

  • clase

  • interfaz

  • struct

  • enum

  • método

  • datos

Verse 
name<internal> : type = value

scoped

Solo se puede acceder al identificador en el ámbito actual y en cualquier ámbito que lo incluya. Cualquier recurso que expongas a Verse y que aparezca en el archivo Assets.digest.Verse tendrá el especificador <scoped>.

Puedes usar el especificador en:

  • módulo

  • clase

  • interfaz

  • funciones

  • struct

  • enum

  • método distinto de módulo

  • datos

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

Especificadores de clase

Los especificadores de clase definen determinadas características de las clases o sus miembros, como, por ejemplo, si se puede crear una subclase de una clase.

Especificador Descripción Ejemplo

abstract

Cuando una clase o un método de clase tiene el especificador abstract, no se puede crear una instancia de la clase. La finalidad de las clases abstractas es usarlas como superclases con una implementación parcial o como una interfaz común. Esto es útil cuando no tiene sentido tener instancias de una superclase pero no deseas duplicar las propiedades y comportamientos en todas las clases similares.

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

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

castable

Indica que este tipo se puede convertir dinámicamente. El especificador <castable> tiene una restricción de retrocompatibilidad en su uso. Una vez que se publica una clase o interfaz, el atributo <castable> no puede añadirse ni eliminarse. Si lo haces, puedes introducir comportamientos de proyección no seguros, por lo que no está permitido.

El tipo castable_subtype funciona de manera muy similar a subtype, pero requiere que cualquier tipo que se use con él también esté marcado como <castable>. Esto aumenta la seguridad del código en lugares donde se utilizan moldes dinámicos.

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

Cuando una clase tiene el especificador concrete, puedes construir una instancia de la clase con un arquetipo vacío, lo que significa que cada campo de la clase debe tener un valor predeterminado. Todas las subclases de una clase concreta son implícitamente concretas. Una clase concreta solo puede heredar directamente de una clase abstracta si ambas clases están definidas en el mismo módulo.

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

unique

En Verse, a una clase unique se le asigna una identidad unique para cada instancia. Esto significa que, incluso si dos instancias de la misma clase unique tienen los mismos valores de campo, no son iguales, ya que son instancias distintas. Esto permite comparar la igualdad de las instancias de clases únicas mediante la comparación de sus identidades. Las clases sin el identificador unique no tienen dicha identidad y su igualdad solo pueden compararse con base en los valores de sus campos. Esto significa que las clases únicas pueden compararse con los operadores = y <> y son subtipos del tipo 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

Solo puedes usar el especificador final en clases y miembros de clases, con las siguientes restricciones:

  • Cuando una clase tiene el especificador final, no se puede crear una subclase de la clase.

  • Cuando un campo tiene el especificador final, no se puede anular el campo en una subclase.

  • Cuando un método tiene el especificador final, no se puede anular el método en una subclase.

Verse 
cat := class<final>():

final_super

El especificador final_super solo se aplica a definiciones de clase y requiere que la definición de clase se derive de una clase o interfaz base. Este especificador impone una restricción de compatibilidad futura de que la clase dada siempre derivará directamente de su base; para esta y todas las futuras versiones publicadas de esta definición de clase.

Esto es necesario en Scene Graph para los subtipos inmediatos de componente a fin de limitar el número de instancias a cero o una por entidad de Scene Graph. Este límite se extiende al subtipo de esos tipo también.

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

Especificador de persistencia

Cuando un tipo personalizado, como una clase, tiene el especificador <persistable>, significa que puedes usarlo en tus variables weak_map del módulo y hacer que sus valores persistan en las sesiones de juego. Para obtener más información sobre la persistencia en Verse, consulta Cómo usar datos persistentes en Verse.

Puedes usar el especificador persistente con los siguientes tipos. Sigue los enlaces para obtener más información.

Especificadores abiertos y cerrados

Actualmente solo se puede utilizar con enumeraciones. Los especificadores <open> y <closed> determinan cómo puedes cambiar la definición del enum una vez que se publica la isla.

Puedes usar los especificadores open y closed con los siguientes tipos. Sigue los enlaces para obtener más información.

Especificador Descripción Ejemplo

Abrir

Un especificador que actualmente solo se aplica a las enumeraciones.

Puedes agregar o reordenar valores de enum en una enum abierta, o cambiarla a una <closed> enum.

Las enumeraciones abiertas se utilizan mejor cuando se espera que la cantidad de valores en su enum aumente en el futuro. Por ejemplo, un enum de tipos de armas.

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}

Cerrado

Un especificador que actualmente solo se aplica a las enumeraciones.

Las enumeraciones se cierran de forma predeterminada.

Las enumeraciones cerradas se utilizan mejor para los casos en los que se espera que los valores permanezcan iguales, como los días de la semana.

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}

Especificadores de implementación

No es posible usar especificadores de implementación al escribir código, pero los verás en las API de UEFN.

Especificador Descripción Ejemplo

native

Indica que la información de definición del elemento se implementa en C++. Las definiciones de Verse con el especificador native generan automáticamente definiciones de C++. El desarrollador de Verse puede completar después sus implementaciones. Puedes ver que este especificador se usa en:

  • clase

  • interfaz

  • enum

  • método

  • datos

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

native_callable

Indica que un método de instancia es nativo (implementado en C++) y que otro código de C++ puede llamarlo. Puedes ver este especificador usado en un método de instancia. Este especificador no se propaga a subclases por lo que no es necesario que lo añadas a una definición cuando anules el método que tiene este especificador.

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

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

Atributos

En Verse, los atributos describen el comportamiento que se usa fuera del lenguaje Verse (a diferencia de los especificadores, que describen la semántica de Verse). Los atributos pueden añadirse en la línea de código antes de las definiciones.

La sintaxis de los atributos utiliza el signo de arroba (@) seguido de la palabra clave.

Atributo Descripción Ejemplo

editable

Indica que este campo es una propiedad expuesta que se puede cambiar directamente desde UEFN, por lo que no es necesario modificar el código de Verse para cambiar su valor. Para obtener más información, consulta Personaliza las propiedades del dispositivo.

Verse 
@editable
Platform : color_changing_tiles_device = color_changing_tiles_device{}

editable_text_box

Una cadena editable que se muestra como un cuadro de texto en el editor. Los cuadros de texto editables actualmente no admiten información sobre herramientas ni categorías.  Para obtener más información, consulta Personaliza las propiedades del 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

Un control deslizante editable que utiliza el tipo float. Puedes arrastrar el control deslizante en el editor para aumentar o disminuir el valor. Para obtener más información, consulta Personaliza las propiedades del 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

Un número editable con un mínimo y un máximo.  Para obtener más información, consulta Personaliza las propiedades del 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

Un control deslizante vectorial editable. Puedes arrastrar para cambiar los valores de cada uno de los componentes del vector.  Para obtener más información, consulta Personaliza las propiedades del 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

Un número de vector editable, que puede ser vector2, vector2i o vector3.  Para obtener más información, consulta Personaliza las propiedades del 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

Un contenedor editable de valores. Actualmente, esto solo admite matrices.  Para obtener más información, consulta Personaliza las propiedades del 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