1. Epic GamesDeveloper
  3. Especificadores y atributos

Especificadores y atributos

Aquí aprenderás acerca de los especificadores y los atributos, y a cómo aplicar semántica y comportamientos adicionales al código Verse.

Especificadores y atributos

Los especificadores en Verse describen el comportamiento relacionado con la semántica; es posible añadir especificadores a los identificadores y a ciertas palabras clave. La sintaxis de los especificadores utiliza corchetes angulares (< y >) con la palabra clave en medio. Por ejemplo, en IsPuzzleSolved()<decides><transacts>:void, "decides" y "transacts" son especificadores.

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

Las siguientes secciones describen todos los especificadores y atributos disponibles en Verse y cuándo se pueden utilizar.

Especificadores de efectos

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

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

  • La palabra clave class: 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 no es posible deshacer las acciones realizadas por la función y, por tanto, no se puede utilizar la función en un contexto de fallo. Este efecto no se puede especificar manualmente.

name():type = codeblock

transacts

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

name()<transacts> : type = codeblock

# no permitido porque `transacts` implica `reads`

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

# no permitido porque `transacts` implica `writes`

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

allocates

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

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 se llama al método en un contexto de fallo que falla, se deshacen los efectos.

name()<writes> : type = codeblock

computes

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

name()<computes>

converges

Este efecto garantiza que no solo no hay ningún efecto secundario de la ejecución de la función relacionada, sino que la función se completa (no es infinitamente recursiva). Este efecto solo puede aparecer en funciones que tengan el especificador nativo, pero el compilador no lo comprueba. El código que proporciona valores predeterminados de campos de clases o valores para las 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. Como una función <decides> puede fallar, es mutuamente excluyente con el efecto <suspends>. Puede ser util combinar <decides> con el efecto <transacts> o <computes>, lo que significa que es posible revertir las acciones realizadas por la función (como si nunca se hubieran producido) si surge un fallo en cualquier parte de la función.

# permitido

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

# permitido

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

# no permitido porque `decides` y `suspends` 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. Mutuamente excluyente con el efecto <decides>.

name()<suspends> : type = codeblock

# no permitido porque `decides` y `suspends` 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 el autor de la llamada tenga también 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 de un miembro: var<specifier> name : type = value

Puedes tener un especificador de acceso tanto en el identificador como en la palabra clave var de 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 los subtipos actuales puedan escribir en la variable.

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

público

El identificador es de acceso universal.

Es posible usar este especificador en:

  • módulo

  • clase

  • interfaz

  • struct

  • enum

  • método

  • datos

Verse 
name<public> : type = value

protegido

Solo pueden acceder al identificador la clase actual y sus subtipos.

Es posible usar este especificador en:

  • clase

  • interfaz

  • struct

  • funciones dentro de una clase

  • enum

  • métodos que no sean de módulos

  • datos

Verse 
name<protected> : type = value

privado

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

Es posible usar este especificador en:

  • clase

  • interfaz

  • struct

  • funciones dentro de una clase

  • enum

  • métodos que no sean de módulos

  • datos

Verse 
name<private> : type = value

interno

Solo se puede acceder al identificador en el módulo actual y envolvente inmediato. Este es el nivel de acceso predeterminado.

Es posible usar este especificador en:

  • módulo

  • clase

  • interfaz

  • struct

  • enum

  • método

  • datos

Verse 
name<internal> : type = value

seleccionado

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

Es posible usar este especificador en:

  • módulo

  • clase

  • interfaz

  • funciones

  • struct

  • enum

  • métodos que no sean de módulos

  • 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 ciertas características de las clases o de sus miembros, por ejemplo, si es posible crear una subclase de una clase.

Especificador Descripción Ejemplo

abstract

Cuando una clase o un método de una clase tiene el especificador abstract, no puedes crear una instancia de la clase. Las clases abstractas están pensadas para ser utilizadas como una superclase con implementación parcial o como una interfaz común. Esto es útil cuando no tiene sentido tener instancias de una superclase pero tampoco se desea duplicar propiedades y comportamientos en clases similares.

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

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

castable

Indica que este tipo se puede proyectar dinámicamente. El especificador <castable> tiene una restricción de uso por compatibilidad con versiones anteriores. Una vez publicada una clase o interfaz, el atributo `<castable> no se puede añadir ni eliminar. Si lo haces, puedes introducir comportamientos de casting que no sean seguros, por lo que no está permitido.

El tipo castable_subtype funciona de forma muy similar a subtype, pero requiere que todos los tipos utilizados con él también estén 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 `concrete` son implícitamente `concrete`. Una clase `concrete` 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

A una clase `unique` en Verse se le asigna una identidad `unique` para cada instancia. Esto significa que, aunque dos instancias de la misma clase `unique` tengan los mismos valores de campo, no son iguales, ya que son instancias distintas. Esto permite comparar instancias de clases únicas para la igualdad mediante la comparación de sus identidades. Las clases sin el especificador `unique` no tienen esta identidad, así que solo se pueden comparar para determinar su igualdad sobre la base de los valores de sus campos. Esto significa que las clases `unique` se pueden comparar con los operadores = y <>, y que 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 utilizar 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 es aplicable a las definiciones de clase y requiere que la definición de la clase se derive de una interfaz o clase padre. Este especificador impone una restricción de compatibilidad futura de que la clase dada siempre derivará directamente de su padre; para esta y todas las futuras versiones publicadas de esta definición de clase.

Es obligatorio en Scene Graph para los subtipos inmediatos de component para limitar el número de instancias a exactamente cero o una por entidad de Scene Graph. Este límite se extiende también a los subtipos de esos tipos.

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 utilizarlo en las variables `weak_map` de tu ámbito de módulo y hacer que sus valores se mantengan a lo largo de las sesiones de juego. Para obtener más información sobre la persistencia en Verse, consulta la sección Cómo utilizar datos persistentes en Verse.

Puedes utilizar el especificador de persistencia 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 de la enumeración una vez publicada tu isla.

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

Especificador Descripción Ejemplo

Open

Especificador que actualmente se aplica solo a las enumeraciones.

Puedes añadir o reordenar valores de enumeración en una enumeración abierta, o cambiarla a una enumeración <closed>.

Las enumeraciones abiertas se utilizan mejor cuando se espera que el número de valores de la enumeración aumente en el futuro. Por ejemplo, un enumeración 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}

Closed

Especificador que actualmente se aplica solo a las enumeraciones.

Las enumeraciones están cerradas por defecto.

Las enumeraciones cerradas funcionan mejor en 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 utilizar especificadores de implementación al escribir código, pero sí verlos al examinar las API de UEFN.

Especificador Descripción Ejemplo

native

Indica que los detalles de definición del elemento están implementados en C++. Las definiciones de Verse con el especificador native generan definiciones en C++ automáticamente. Un desarrollador puede rellenarlas con su implementación. Puedes ver este especificador utilizado 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 puede llamarse desde otro código C++. Es posible ver este especificador utilizado en un método de instancia. Este especificador no se propaga a subclases y, en consecuencia, no es necesario añadirlo a una definición para anular otro método que sí lo tiene.

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

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

Atributos

Los atributos en Verse describen un comportamiento que se utiliza fuera del lenguaje de 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 anterior a 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 hace falta modificar el código de Verse para cambiar su valor. Para obtener más información, consulta Cómo personalizar las propiedades de los dispositivos.

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. Actualmente, las cajas de texto editables no admiten burbujas informativas ni categorías.  Para obtener más información, consulta Cómo personalizar las propiedades de los dispositivos.  

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 Cómo personalizar las propiedades de los dispositivos.  

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 Cómo personalizar las propiedades de los dispositivos.  

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 Cómo personalizar las propiedades de los dispositivos.  

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 vectorial editable, que puede ser un vector2, un vector2i o un vector3.  Para obtener más información, consulta Cómo personalizar las propiedades de los dispositivos.  

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, solo admite matrices.  Para obtener más información, consulta Cómo personalizar las propiedades de los dispositivos.  

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