1. Epic GamesDeveloper
  3. Especificadores e atributos

Especificadores e atributos

Aprenda sobre especificadores e atributos e a aplicar semântica e comportamento adicionais ao seu código Verse.

Especificadores e atributos

Em Verse, os Especificadores descrevem o comportamento relacionado à semântica e podem adicionar especificadores a identificadores e determinadas palavras-chave. A sintaxe do especificador usa colchetes angulares (< e >, com a palavra-chave no meio. Por exemplo, em IsPuzzleSolved()<decides><transacts>:void, "decides" and "transacts" são especificadores.

Atributos em Verse descrevem o comportamento que é usado fora da linguagem Verse (ao contrário dos especificadores, que descrevem a semântica em Verse). A sintaxe do atributo usa o sinal de arroba (@) seguido da palavra-chave, por exemplo: @editable.

As seções a seguir descrevem todos os especificadores e atributos disponíveis no Verse e quando você pode usá-los.

Especificadores de efeito

Os efeitos em Verse indicam categorias de comportamento que uma função pode exibir. Você pode adicionar especificadores de efeito:

  • Depois do () na definição de uma função: name()<specifier>:type = codeblock.

  • A palavra-chave class: name := class<specifier>(){}.

Especificador Descrição Exemplo

no_rollback

Esse é o efeito padrão quando nenhum efeito exclusivo é especificado. O efeito no_rollback indica que as ações executadas pela função não podem ser desfeitas e, portanto, a função não pode ser usada em um contexto de falha. Esse efeito não pode ser especificado manualmente.

name():type = codeblock

transacts

O efeito <transacts> é uma combinação de <allocates>, <reads> e <writes>.  O efeito <transacts> não pode ser combinado com esses especificadores.

name()<transacts> : type = codeblock

# não é permitido porque transacts implica reads

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

# não permitido porque transacts implica writes

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

allocates

Esse efeito indica que a função pode instanciar um objeto na memória. Se o método for chamado em um contexto de falha que fracassa, os efeitos serão cancelados.

name()<allocates> : type = codeblock

reads

Um método com esse efeito pode ler o estado mutável.

name()<reads> : type = codeblock

writes

Um método com este efeito pode gravar em estado mutável. Se o método for chamado em um contexto de falha que fracassa, os efeitos serão cancelados.

name()<writes> : type = codeblock

computes

Um método <computes> garante que retornará para sempre a mesma saída para qualquer entrada. Um método <computes> não pode ser <transacts> <reads>, <writes> ou <allocates>.

name()<computes>

converges

Além de garantir que não haja efeito colateral da execução da função relacionada, esse efeito também assegura que a função seja concluída (não recursiva infinitamente). Esse efeito só pode aparecer em funções que tenham o especificador native, mas isso não é verificado pelo compilador. Um código que forneça valores padrão de campos de classe ou valores para variáveis globais é necessário para ter esse efeito.

name()<converges> : type = codeblock

decides

Esse efeito indica que a função pode falhar e que a chamada dessa função é uma expressão falível. Como o chamado da função <decides> pode falhar, é mutuamente exclusivo com o efeito <suspends>. Pode ser útil combinar <decides> com o efeito <transacts> ou <computes>, o que permite que as ações realizadas por essa função sejam revertidas (como se nunca tivessem sido executadas) se houver uma falha em qualquer parte da função.

# permitido

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

# permitido

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

# não permitido porque decides e suspends são mutuamente exclusivos

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

suspends

Esse efeito indica que a função é assíncrona. Cria um contexto assíncrono para o corpo da função. Mutualmente exclusiva com o efeito <decides>.

name()<suspends> : type = codeblock

# não permitido porque decides e suspends são mutuamente exclusivos

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

Em todos os casos, chamar uma função que tenha um efeito específico exigirá que o chamador também tenha esse efeito.

Especificadores de acesso

Especificadores de acesso definem o que pode interagir com um membro e como. Você pode aplicar especificadores de acesso ao seguinte:

  • O identificador de um membro: name<specifier> : type = value

  • A palavra-chave var de um membro: var<specifier> name : type = value

Você pode ter um especificador de acesso tanto no identificador quanto na palavra-chave var de uma variável, para diferenciar entre quem tem acesso para ler e gravar a variável. Por exemplo, a variável a seguir MyInteger tem o especificador público no identificador para que qualquer pessoa possa ler o valor, mas a palavra-chave var tem o especificador protegido, para que somente a classe atual e os subtipos possam gravar na variável.

Verse 
var<protected> MyInteger<public>:int = 2
Especificador Descrição Uso Exemplo

public

O identificador é universalmente acessível.

Você pode usar esse especificador em:

  • módulo

  • classe

  • interface

  • struct

  • enum

  • método

  • dados

Verse 
name<public> : type = value

protected

O identificador só pode ser acessado pela classe atual e quaisquer subtipos.

Você pode usar esse especificador em:

  • classe

  • interface

  • struct

  • funções dentro de uma classe

  • enum

  • método não modular

  • dados

Verse 
name<protected> : type = value

private

O identificador só pode ser acessado no escopo atual imediatamente circundante (seja um módulo, classe, struct etc.).

Você pode usar esse especificador em:

  • classe

  • interface

  • struct

  • funções dentro de uma classe

  • enum

  • método não modular

  • dados

Verse 
name<private> : type = value

internal

O identificador só pode ser acessado no módulo imediatamente circundante atual. Este é o nível de acesso padrão.

Você pode usar esse especificador em:

  • módulo

  • classe

  • interface

  • struct

  • enum

  • método

  • dados

Verse 
name<internal> : type = value

scoped

O identificador só pode ser acessado no escopo atual e em qualquer escopo adjacente. Todos os recursos que você expor ao Verse e que aparecerem no arquivo Assets.digest.Verse terão o especificador <scoped>.

Você pode usar esse especificador em:

  • módulo

  • classe

  • interface

  • funções

  • struct

  • enum

  • método não modular

  • dados

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 classe

Especificadores de classe definem certas características de classes ou de seus membros (por exemplo, se você pode criar uma subclasse de uma classe).

Especificador Descrição Exemplo

abstract

Quando uma classe ou um método de classe tem o especificador abstract, você não pode criar uma instância dessa classe. Classes abstratas devem ser usadas como uma superclasse com implementação parcial ou como uma interface comum. Isso é útil quando não faz sentido ter instâncias de uma superclasse, mas você não deseja duplicar propriedades e comportamentos em classes semelhantes.

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

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

castable

Indica que esse tipo pode ser convertido dinamicamente. O especificador <castable> tem uma restrição de compatibilidade com versões anteriores sobre seu uso. Após a publicação de uma classe ou uma interface, o atributo <castable> não poderá ser adicionado nem removido. Fazer isso pode introduzir comportamentos de conversão perigosos e, por isso, não é permitido.

O tipo castable_subtype funciona de maneira muito semelhante a subtype, mas requer que todos os tipos usados com ele também sejam marcados como <castable>. Isso aumenta a segurança do código em locais onde conversões dinâmicas são usadas.

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 uma classe tiver o especificador concrete, você poderá construir uma instância da classe com um arquétipo vazio, o que significa que cada campo da classe deve ter um valor padrão. Cada subclasse de uma classe concrete é implicitamente concrete. Uma classe concrete só poderá herdar diretamente de uma classe abstract se ambas as classes estiverem definidas no mesmo módulo.

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

unique

Uma classe unique no Verse recebe uma identidade unique para cada instância. Isso significa que, mesmo que duas instâncias da mesma classe unique tenham os mesmos valores de campo, elas não serão iguais, pois são instâncias distintas. Assim, é possível comparar instâncias de classes exclusivas em termos de igualdade ao comparar suas identidades. Classes sem o especificador unique não têm essa identidade, por isso só podem ser comparadas em termos de igualdade baseadas nos valores dos seus campos. Isso significa que classes exclusivas podem ser comparadas com os operadores = e <> e são subtipos do tipo comparável.

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

Você pode usar o especificador final apenas em classes e membros de classes, com as seguintes restrições:

  • Quando uma classe tiver o especificador "final", não será possível criar uma subclasse da classe.

  • Quando um campo tiver o especificador "final", não será possível substituir o campo em uma subclasse.

  • Quando um método tiver o especificador final, não é possível substituir o método em uma subclasse.

Verse 
cat := class<final>():

final_super

O especificador final_super é aplicável apenas a definições de classe e requer que a definição de classe deriva de uma interface ou classe-pai. Esse especificador aplica uma restrição de compatibilidade futura de que a classe sempre derivará de seu pai diretamente, para esta e todas as versões futuras publicadas desta definição de classe.

Isso é necessário no Scene Graph para subtipos imediatos de component, a fim de limitar o número de instâncias a exatamente zero ou uma por entidade do Scene Graph. Esse limite também se estende a subtipos desses 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 "persistence"

Quando um tipo personalizado, como uma classe, tem o especificador <persistable>, você pode usá-lo nas variáveis weak_map com escopo de módulo e fazer com que seus valores persistam entre as sessões de jogo. Para obter mais detalhes sobre a persistência em Verse, consulte Como usar dados persistentes em Verse.

Você pode usar o especificador de persistência com os seguintes tipos: Siga os links para obter mais detalhes.

Especificadores aberto e fechado

Atualmente utilizável apenas com enumerações. Os especificadores <open> e <closed> determinam como você pode alterar a definição da enumeração depois que sua ilha for publicada.

Você pode usar os especificadores aberto e fechado com os seguintes tipos. Siga os links para obter mais detalhes.

Especificador Descrição Exemplo

Aberto

Um especificador que atualmente se aplica apenas a enumerações.

Você pode adicionar ou reordenar valores de enumeração em uma enumeração aberta ou alterá-la para uma enumeração <closed>.

Enumerações abertas são melhores quando se espera que o número de valores na enumeração possa aumentar no futuro. Por exemplo, uma enumeração 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}

Fechadas

Um especificador que atualmente se aplica apenas a enumerações.

As enumerações são fechadas por padrão.

Enumerações fechadas são mais eficientes para casos em que se espera que seus valores permaneçam os mesmos, como dias da 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 implementação

Não é possível usar especificadores de implementação ao criar código, mas você os verá ao analisar as APIs do UEFN.

Especificador Descrição Exemplo

native

Indica que os detalhes da definição do elemento são implementados em C++. As definições Verse com o especificador native geram automaticamente definições C++. Um desenvolvedor de Verse pode então complementar sua implementação. Você pode ver este especificador usado em:

  • classe

  • interface

  • enum

  • método

  • dados

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

native_callable

Indica que um método de instância é nativo (implementado em C++) e pode ser chamado por outro código C++. É possível ver esse especificador usado em um método de instância. Esse especificador não se propaga para subclasses e, portanto, não é necessário adicioná-lo a uma definição ao substituir um método que tenha esse especificador.

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

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

Atributos

Atributos em Verse descrevem o comportamento que é usado fora da linguagem Verse (ao contrário de especificadores, que descrevem a semântica em Verse). Atributos podem ser adicionados na linha de código antes de definições.

A sintaxe do atributo usa o sinal de arroba (@) seguido pela palavra-chave.

Atributo Descrição Exemplo

editable

Indica que esse campo é uma propriedade exposta que pode ser alterada diretamente no UEFN, de modo que você não precise modificar o código Verse para modificar seu valor. Para obter mais detalhes, consulte Como personalizar propriedades de dispositivos.

Verse 
@editable
Platform : color_changing_tiles_device = color_changing_tiles_device{}

editable_text_box

Uma string editável exibida como uma caixa de texto no editor. Caixas de texto editáveis atualmente não oferecem suporte para dicas de ferramentas ou categorias.  Para obter mais detalhes, consulte Como personalizar propriedades de 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

Um controle deslizante editável que usa o tipo "float". Você pode arrastar o controle deslizante no editor para aumentar ou diminuir o valor. Para obter mais detalhes, consulte Como personalizar propriedades de 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

Um número editável com mínimo e máximo.  Para obter mais detalhes, consulte Como personalizar propriedades de 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

Um controle deslizante vetorial editável. Você pode arrastar para alterar os valores de cada um dos componentes do vetor.  Para obter mais detalhes, consulte Como personalizar propriedades de 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

Um número vetorial editável, que pode ser vector2, vector2i ou vector3.  Para obter mais detalhes, consulte Como personalizar propriedades de 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

Um contêiner editável de valores. Atualmente, isso só é compatível com matrizes.  Para obter mais detalhes, consulte Como personalizar propriedades de 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