quinta-feira, 19 de dezembro de 2024

UEFN Verse: Classes and Instances

A class is a template that defines attributes and behaviors. When we create a Verse class, the editor provides us with some template options. These templates are classes that will be used as the parent class. The attributes and behaviors of the parent class will be inherited by the new class.



When we drag and drop a creative device onto the level, we are creating an instance of the creative device class. Each instance can have different values ​​for its attributes. As an analogy, we are instances of a Person class. The Person class has the Name attribute, and each of us can have different names.

When creating a class we use constants and variables to specify the attributes. Behavior is defined using functions.

Besides the classes available as templates in UEFN, we can create simple classes in Verse. The example below creates a class named health_item with three constants of different types and a function called PrintData() that writes the values ​​of the current instance to the screen.

health_item := class:
    Name : string 
    HealthPoints : int = 10
    Weight : float = 2.0

    PrintData() : void =
        Print("*** health_item instance ***")
        Print("Name = {Name}")
        Print("HealthPoints = {HealthPoints}")
        Print("Weight = {Weight}")
        Print("****************************")

The HealthPoints and Weight constants have default values ​​that will be used if no other values ​​are provided when creating the instance of this class.

The lines below are creating two instances of the health_item class. In the first instance, only the Name constant is being assigned a value. The other constants are using their default values. In the second instance, the three constants are receiving initialization values.

HealthItemInstance1 : health_item = health_item{Name := "Fruit"} 

HealthItemInstance2 : health_item = health_item{Name := "Potion", 
                                                HealthPoints := 15, 
                                                Weight := 1.5}

HealthItemInstance1 and HealthItemInstance2 are references used to access the instances of the health_item class that have been created.

With a reference we can access the constants/variables and functions of a class using "." as shown in the example below. 

HealthItemInstance1.PrintData()

HealthItemInstance2.PrintData()

if (HealthItemInstance1.Weight > HealthItemInstance2.Weight):
    Print("{HealthItemInstance1.Name} is heavier than {HealthItemInstance2.Name}")

Let's create a device in UEFN to show how this new class can be used in the new device file.

In any UEFN project, open Verse Explorer, right-click on the project name and choose the Add new Verse file to project option.

In Device Name put class_instance_device and click the Create Empty button.

Copy the Verse code below into the class_instance_device file:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

health_item := class:
    Name : string 
    HealthPoints : int = 10
    Weight : float = 2.0

    PrintData() : void =
        Print("*** health_item instance ***")
        Print("Name = {Name}")
        Print("HealthPoints = {HealthPoints}")
        Print("Weight = {Weight}")
        Print("****************************")


class_instance_device := class(creative_device):

    HealthItemInstance1 : health_item = health_item{Name := "Fruit"} 

    HealthItemInstance2 : health_item = health_item{Name := "Potion", 
                                                    HealthPoints := 15, 
                                                    Weight := 1.5}

    OnBegin<override>()<suspends>:void=

        HealthItemInstance1.PrintData()

        HealthItemInstance2.PrintData()

        if (HealthItemInstance1.Weight > HealthItemInstance2.Weight):
            Print("{HealthItemInstance1.Name} is heavier than {HealthItemInstance2.Name}")

The class_instance_device has two attributes that are references to instances of the health_item class. In the OnBegin function, we call the PrintData() function of the instances to write the values ​​of their attributes. Then, a comparison is made between the two instances using the Weight attribute.

Save the file and compile the Verse code using the Verse > Build Verse Code option from the UEFN menu.

Access the Content Drawer and add our class_instance_device to the level.

Click the Launch Session button located in the UEFN toolbar to load the level into Fortnite.

After starting the session in Fortnite, press the Tab key and select the Log tab to view the log with the messages written by the Print functions. 


Table of Contents Verse

UEFN Verse: Classes e Instâncias

Uma classe é um modelo que define atributos e comportamentos. Quando criamos uma classe Verse, o editor nos fornece algumas opções de modelos. Estes modelos são classes que serão usadas como classe pai. Os atributos e comportamentos da classe pai serão herdados pela nova classe.



Quando arrastamos um dispositivo criativo e soltamos no nível, estamos criando uma instância da classe do dispositivo criativo. Cada instância pode ter valores diferentes para os seus atributos. Fazendo uma analogia, nós somos instâncias de uma classe Pessoa. A classe Pessoa tem o atributo Nome e cada um de nós podemos ter nomes diferentes.

Na criação de uma classe usamos constantes e variáveis para especificar os atributos. O comportamento é definido usando funções.

Além das classes disponíveis como templates no UEFN podemos criar classes simples em Verse. O exemplo abaixo cria uma classe com o nome health_item com três constantes de tipos diferentes e uma função chamada PrintData() que escreve na tela os valores da instância atual.

health_item := class:
    Name : string 
    HealthPoints : int = 10
    Weight : float = 2.0

    PrintData() : void =
        Print("*** health_item instance ***")
        Print("Name = {Name}")
        Print("HealthPoints = {HealthPoints}")
        Print("Weight = {Weight}")
        Print("****************************")

As constantes HealthPoints e Weight possuem valores padrões que serão usados caso não sejam fornecidos outros valores na criação da instância desta classe.

As linhas abaixo estão criando duas instâncias da classe health_item. Na primeira instância está sendo atribuído valor somente para a constante Name. As outras constantes usam os valores padrões. Na segunda instância, as três constantes estão recebendo valores de inicialização.

HealthItemInstance1 : health_item = health_item{Name := "Fruit"} 

HealthItemInstance2 : health_item = health_item{Name := "Potion", 
                                                HealthPoints := 15, 
                                                Weight := 1.5}

HealthItemInstance1HealthItemInstance2 são referências usadas para acessar as instâncias da classe health_item que foram criadas.

Com uma referência podemos acessar as constantes/variáveis e funções de uma classe usando "." como mostra o exemplo abaixo. 

HealthItemInstance1.PrintData()

HealthItemInstance2.PrintData()

if (HealthItemInstance1.Weight > HealthItemInstance2.Weight):
    Print("{HealthItemInstance1.Name} is heavier than {HealthItemInstance2.Name}")

Vamos criar um dispositivo no UEFN para mostrar como esta nova classe pode ser usado no arquivo do novo dispositivo.

Em qualquer projeto UEFN, abra o Verse Explorer, clique com o botão-direito no nome do projeto e escolha a opção Add new Verse file to project.

Em Device Name coloque class_instance_device clique no botão Create Empty.

Copie o código Verse abaixo para o dispositivo class_instance_device:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

health_item := class:
    Name : string 
    HealthPoints : int = 10
    Weight : float = 2.0

    PrintData() : void =
        Print("*** health_item instance ***")
        Print("Name = {Name}")
        Print("HealthPoints = {HealthPoints}")
        Print("Weight = {Weight}")
        Print("****************************")


class_instance_device := class(creative_device):

    HealthItemInstance1 : health_item = health_item{Name := "Fruit"} 

    HealthItemInstance2 : health_item = health_item{Name := "Potion", 
                                                    HealthPoints := 15, 
                                                    Weight := 1.5}

    OnBegin<override>()<suspends>:void=

        HealthItemInstance1.PrintData()

        HealthItemInstance2.PrintData()

        if (HealthItemInstance1.Weight > HealthItemInstance2.Weight):
            Print("{HealthItemInstance1.Name} is heavier than {HealthItemInstance2.Name}")

A class_instance_device possui dois atributos que são referências para instâncias  da classe health_item. Na função OnBegin chamamos a função PrintData() das instâncias para escreverem os valores de seus atributos. Depois é feita uma comparação entre as duas instâncias usando o atributo Weight.

Salve o arquivo e compile o código Verse usando a opção Verse > Build Verse Code do menu do UEFN. 

Acesse o Content Drawer e adicione o nosso dispositivo Verse class_instance_device ao nível.

Clique no botão Launch Session localizado na barra de ferramentas do UEFN para carregar o nível no Fortnite. 

Após iniciar a partida no Fortnite, pressione a tecla Tab e selecione a aba  Registro para visualizar o log com as mensagens escritas pelas funções Print.


Sumário Verse

sábado, 7 de dezembro de 2024

UEFN Verse: Functions

A function is a block of code that can be executed in different parts of a program. A function is a simple way to reuse code.

For example, imagine that your game has a help message that can be executed in various situations, such as when entering a new environment or when the player presses a button. If we do not use a function, the block of code with this help message will have to be repeated in several places in the program. When there is a change in the text of the message, we will have to search for all the places in the code that have this message, with the risk of forgetting one of the places and the message becoming inconsistent.

We can create a function to display the help message. In the places of the code that need the message, we will place a call to the function. When we need to change the text of the message, we only need to change it in one place, which is inside the function.

The code below shows the creation of a function named ShowHelp:

ShowHelp():void = 
    Print("ShowHelp() function has no parameter or result.")

This is a very simple function that displays a message on the screen using the Verse language's Print() function. The void keyword indicates that the function does not return a result value.

A function can have parameters and return a result. A parameter is a value that is passed to the function. The function below has two integer parameters named Level and TimeLeft and the result is also of integer type. The function uses an expression with the parameters and the result of the expression is returned to the location where the function was called.

CalculateBonus(Level:int, TimeLeft:int):int =
    Level * 10 + TimeLeft


UEFN creative devices generate various types of events to indicate what is happening in the game. We can register a function on a device to be executed when a specific event occurs.

The function below was created to be called when a Timer Device finishes its countdown. 

HandleTimerFinished(MaybeAgent:?agent):void=
   Print("*** Time's Up! ***")

The function that will be registered in an event must have the parameters and return type specified in the event. In general, these functions do not have a return type (void type) and have a parameter of type agent or ?agent.

Note: ?agent is an optional agent. This means it can have a value or be empty.

The line below subscribes the HandleTimerFinished function on the success event of a TimerDevice:

TimerDevice.SuccessEvent.Subscribe(HandleTimerFinished)


Let's put the above examples together on a device in UEFN to see how they work in practice.

In any UEFN project, open Verse Explorer, right-click on the project name and choose the Add new Verse file to project option.

In Device Name put function_device and click the Create Empty button.

Copy the Verse code below into the function_device file:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

function_device := class(creative_device):

    @editable
    TimerDevice : timer_device = timer_device{}

    ShowHelp():void = 
        Print("ShowHelp() function has no parameter or result.")
        

    CalculateBonus(Level:int, TimeLeft:int):int =
        Level * 10 + TimeLeft


    HandleTimerFinished(MaybeAgent:?agent):void=
       Print("*** Time's Up! ***")
        

    OnBegin<override>()<suspends>:void=

        TimerDevice.SuccessEvent.Subscribe(HandleTimerFinished)

        ShowHelp()

        Bonus1 := CalculateBonus(3, 25)
        Print("Bonus 1 = {Bonus1}")

        Print("Bonus 2 = { CalculateBonus(6, 12) }")


The OnBegin function makes calls to the functions that were created and subscribes the HandleTimerFinished function in the success event of a Timer Device, which will be executed when the Timer Device finishes its countdown.

Save the file and compile the Verse code using the Verse > Build Verse Code option from the UEFN menu.

Access the Content Drawer and add our function_device to the level. Also drag onto the level a Timer Device which can be found in the Fortnite > Devices folder.

Click the Launch Session button located in the UEFN toolbar to load the level into Fortnite.

After starting the session in Fortnite, press the Tab key and select the Log tab to view the log with the messages written by the Print functions. 


Table of Contents Verse

UEFN Verse: Funções

Uma função é um bloco de código que pode ser executado em diferentes partes de um programa. A função é uma forma simples de reutilizar código.

Por exemplo, imagine que o seu jogo possui uma mensagem de ajuda que pode ser executada em várias situações como ao entrar em um ambiente novo ou quando o jogador pressionar um botão. Se não usarmos uma função, o bloco de código com esta mensagem de ajuda terá de ser repetido em vários locais do programa. Quando houver uma mudança no texto da mensagem, teremos de procurar todos os locais do código que tem esta mensagem tendo o risco de esquecermos um dos locais e a mensagem ficar inconsistente.

Podemos criar uma função com o objetivo de exibir a mensagem de ajuda. Nos locais do código que precisam da mensagem, colocaremos uma chamada à função. Quando for preciso mudar o texto da mensagem, basta mudar em um único lugar que é dentro da função.

O código abaixo mostra a criação de uma função com o nome ShowHelp:

ShowHelp():void = 
    Print("ShowHelp() function has no parameter or result.")

Esta é uma função bem simples que exibe uma mensagem na tela usando a função Print() da linguagem Verse. A palavra chave void indica que a função não retorna um valor de resultado.

Uma função pode ter parâmetros e retornar um resultado. Um parâmetro é um valor que é passado para a função. A função abaixo possui dois parâmetros do tipo inteiro com os nomes Level e TimeLeft e o resultado também é do tipo inteiro. A função usa uma expressão com os parâmetros e o resultado da expressão é devolvido para o local que foi feito a chamada à função.

CalculateBonus(Level:int, TimeLeft:int):int =
    Level * 10 + TimeLeft


Os dispositivos criativos do UEFN geram diversos tipos de eventos para indicar o que está acontecendo no jogo. Podemos registrar em um dispositivo uma função  para ser executada quando um evento específico ocorrer.

A função abaixo foi criada para ser chamada quando um Timer Device terminar sua contagem. 

HandleTimerFinished(MaybeAgent:?agent):void=
   Print("*** Time's Up! ***")

A função que será registrada em um evento precisa ter os parâmetros e tipo de retorno especificados no evento. Em geral estas funções não tem retorno (tipo void) e tem um parâmetro do tipo agent ou ?agent.

Nota: ?agent é um agent opcional. Isto significa que ele pode ter valor ou estar vazio. 

A linha abaixo registra a função HandleTimerFinished no evento de sucesso de um TimerDevice:

TimerDevice.SuccessEvent.Subscribe(HandleTimerFinished)


Vamos reunir os exemplos acima em um dispositivo no UEFN para vermos a sua execução na prática.

Em qualquer projeto UEFN, abra o Verse Explorer, clique com o botão-direito no nome do projeto e escolha a opção Add new Verse file to project.

Em Device Name coloque function_device e clique no botão Create Empty.

Copie o código Verse abaixo para o dispositivo function_device:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

function_device := class(creative_device):

    @editable
    TimerDevice : timer_device = timer_device{}

    ShowHelp():void = 
        Print("ShowHelp() function has no parameter or result.")
        

    CalculateBonus(Level:int, TimeLeft:int):int =
        Level * 10 + TimeLeft


    HandleTimerFinished(MaybeAgent:?agent):void=
       Print("*** Time's Up! ***")
        

    OnBegin<override>()<suspends>:void=

        TimerDevice.SuccessEvent.Subscribe(HandleTimerFinished)

        ShowHelp()

        Bonus1 := CalculateBonus(3, 25)
        Print("Bonus 1 = {Bonus1}")

        Print("Bonus 2 = { CalculateBonus(6, 12) }")


Na função OnBegin são feitas as chamadas para as funções que foram criadas e é feito o registro da função HandleTimerFinished no evento de sucesso de um Timer Device, que será executada quando o Timer Device terminar a contagem.

Salve o arquivo e compile o código Verse usando a opção Verse > Build Verse Code do menu do UEFN. 

Acesse o Content Drawer e adicione o nosso dispositivo Verse function_device ao nível. Arraste também para o nível um Timer Device que pode ser encontrado na pasta Fortnite > Devices.

Selecione o function_device no nível. Na aba Details, clique no drop-down de TimerDevice e selecione o Timer Device que adicionamos ao nível. 

Clique no botão Launch Session localizado na barra de ferramentas do UEFN para carregar o nível no Fortnite. 

Após iniciar a partida no Fortnite, pressione a tecla Tab e selecione a aba Registro para visualizar o log com as mensagens escritas pelas funções Print.


Sumário Verse

segunda-feira, 18 de novembro de 2024

UEFN Verse: if (control flow)

A program consists of a series of instructions. There are types of instructions that define when certain instructions should be executed. This defines the control flow of the program.

The if statement is widely used in control flow. The if tests one or more expressions that must result in success in order to execute the block of code associated with the if.

In the example below, GradeNumber and IntegerValue are variables. The Print() function will only be executed if the values ​​of the variables are different.

if (GradeNumber <> IntegerValue):
    Print("GradeNumber and IntegerValue are different")


If is an expression and can return value. It is also a failure context allowing the execution of failable expressions.

The example below shows the use of a single-line if statement. When the if test expression succeeds, the value of then is the result. When the expression fails, the value of else is the result. The result value is stored in the EvenOrOdd variable. 

set EvenOrOdd = if ( Mod[IntegerValue, 2] = 0) then "Even" else "Odd"
Print("IntegerValue is {EvenOrOdd}")

The Mod[] function returns the remainder of a division between integers. It is a failable expression. Failable functions use [ ] instead of ( ). In the example above, if the remainder of an integer divided by 2 is zero, then the number is even.

We can use an if expression after an else expression. This allows us to check other expressions until the successful expression is found.

In the example below, the if .. else if are used to define the scale of a grade using its numeric value. When one of the if .. else if expressions is successful, the others will be ignored. The resulting word will be stored in the GradeScale variable.  
set GradeScale = 
    if (GradeNumber >= 9):   
        "Excellent"
    else if (GradeNumber >= 7):
        "Good"
    else if (GradeNumber >= 5):
        "Average"
    else:
        "Insufficient"

Print("GradeScale is {GradeScale}")


The if expression has another format that is useful when there are multiple expressions that need to succeed for a block of code to execute. In this format, each if test expression can be written on one line, making the code more readable. The example below shows this format.

if: 
    GradeNumber > 0
    IntegerValue > 0
then: 
    Print("GradeNumber and IntegerValue are positive")

Let's create a device in UEFN to see the various forms of the if expression in action.

In any UEFN project, open Verse Explorer, right-click on the project name and choose the Add new Verse file to project option.

In Device Name put if_device and click the Create Empty button.

Copy the Verse code below into the if_device file:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

if_device := class(creative_device):

    @editable
    GradeNumber : int = 8

    @editable
    IntegerValue : int = 3
    
    var EvenOrOdd : string = ""
    var GradeScale : string = ""

    OnBegin<override>()<suspends>:void=

        if (GradeNumber <> IntegerValue):
            Print("GradeNumber and IntegerValue are different")

        set EvenOrOdd = if ( Mod[IntegerValue, 2] = 0) then "Even" else "Odd"
        Print("IntegerValue is {EvenOrOdd}")
    
        set GradeScale = 
            if (GradeNumber >= 9):   
                "Excellent"
            else if (GradeNumber >= 7):
                "Good"
            else if (GradeNumber >= 5):
                "Average"
            else:
                "Insufficient"

        Print("GradeScale is {GradeScale}")

        if: 
            GradeNumber > 0
            IntegerValue > 0
        then: 
            Print("GradeNumber and IntegerValue are positive")


Save the file and compile the Verse code using the Verse > Build Verse Code option from the UEFN menu.

Access the Content Drawer and add our Verse device operator_device to the level.

Select the if_device in the level. In the Details tab you can modify the values ​​of the constants that were marked with @editable.



Click the Launch Session button located in the UEFN toolbar to load the level into Fortnite. 

After starting the session in Fortnite, press the Tab key and select the Log tab to view the log with the messages written by the Print functions. 

 

Table of Contents Verse


UEFN Verse: if (controle de fluxo)

Um programa consiste de uma série de instruções. Existem tipos de instruções que definem quando algumas instruções devem ser executadas. Isto define o controle de fluxo do programa.

A instrução if é um exemplo muito usado no controle de fluxo. O if testa uma ou mais expressões que devem resultar em sucesso para que o bloco de código associado ao if seja executado.

No exemplo abaixo, GradeNumber e IntegerValue são variáveis. A função Print() só será executada se os valores das variáveis forem diferentes.

if (GradeNumber <> IntegerValue):
    Print("GradeNumber and IntegerValue are different")


O if é uma expressão e pode retornar valor. Ele também é um contexto de falha permitindo a execução de expressões falíveis.

O exemplo abaixo mostra o uso de um formato do comando if de uma única linha. Se a expressão de teste do if resultar em sucesso, o resultado é o valor de then. Se a expressão falhar, o resultado é o valor de else. O valor do resultado é armazenado na variável EvenOrOdd

set EvenOrOdd = if ( Mod[IntegerValue, 2] = 0) then "Even" else "Odd"
Print("IntegerValue is {EvenOrOdd}")

A função Mod[] retorna o resto da divisão entre inteiros. Ela é uma expressão falível. As funções falíveis usam [ ] ao invés de ( ). No exemplo acima, se o resta da divisão de um número inteiro por 2 for zero, então o número é par.

Podemos usar uma expressão if após uma expressão else. Isto permite a verificação de outras expressões até encontrar a expressão com sucesso.

No exemplo abaixo, está sendo usado o if .. else if para definir a escala de uma nota usando o seu valor numérico. Quando uma das expressões do if .. else if tiver sucesso, as demais serão ignoradas. A palavra resultante será armazenada na variável GradeScale.  

set GradeScale = 
    if (GradeNumber >= 9):   
        "Excellent"
    else if (GradeNumber >= 7):
        "Good"
    else if (GradeNumber >= 5):
        "Average"
    else:
        "Insufficient"

Print("GradeScale is {GradeScale}")


A expressão if possui mais um formato de escrita que é útil quando existem várias expressões que precisam ter sucesso para a execução do bloco de código do then. Neste formato, cada expressão do if pode ser escrita em uma linha deixando o código mais legível. O exemplo abaixo mostra este formato.

if: 
    GradeNumber > 0
    IntegerValue > 0
then: 
    Print("GradeNumber and IntegerValue are positive")

Vamos criar um dispositivo no UEFN para vermos as diferentes formas da expressão if em ação.

Em qualquer projeto UEFN, abra o Verse Explorer, clique com o botão-direito no nome do projeto e escolha a opção Add new Verse file to project.

Em Device Name coloque if_device e clique no botão Create Empty.

Copie o código Verse abaixo para o dispositivo if_device:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

if_device := class(creative_device):

    @editable
    GradeNumber : int = 8

    @editable
    IntegerValue : int = 3
    
    var EvenOrOdd : string = ""
    var GradeScale : string = ""

    OnBegin<override>()<suspends>:void=

        if (GradeNumber <> IntegerValue):
            Print("GradeNumber and IntegerValue are different")

        set EvenOrOdd = if ( Mod[IntegerValue, 2] = 0) then "Even" else "Odd"
        Print("IntegerValue is {EvenOrOdd}")
    
        set GradeScale = 
            if (GradeNumber >= 9):   
                "Excellent"
            else if (GradeNumber >= 7):
                "Good"
            else if (GradeNumber >= 5):
                "Average"
            else:
                "Insufficient"

        Print("GradeScale is {GradeScale}")

        if: 
            GradeNumber > 0
            IntegerValue > 0
        then: 
            Print("GradeNumber and IntegerValue are positive")


Salve o arquivo e compile o código Verse usando a opção Verse > Build Verse Code do menu do UEFN. 

Acesse o Content Drawer e adicione o nosso dispositivo Verse if_device ao nível.

Selecione o if_device no nível. Na aba Details você pode modificar os valores das constantes que foram marcadas com @editable.



Clique no botão Launch Session localizado na barra de ferramentas do UEFN para carregar o nível no Fortnite. 

Após iniciar a partida no Fortnite, pressione a tecla Tab e selecione a aba  Registro para visualizar o log com as mensagens escritas pelas funções Print

 

Sumário Verse


segunda-feira, 4 de novembro de 2024

UEFN Verse: Operators

Operators are symbols that represent arithmetic, relational, or logical operations.


  • Arithmetic Operators

Arithmetic operators perform mathematical operations between two values.

These are the main arithmetic operators:

Operator Operation
+ Addition
- Subtraction
* Multiplication
/ Division


The line below shows an example use of an arithmetic operator. Consider that Damage, AttackHit, and ShieldLevel are variables. The value of ShieldLevel is subtracted from the value of AttackHit. The result is stored in the Damage variable:

set Damage = AttackHit - ShieldLevel


Arithmetic operators can be combined with the assignment operator to modify the value of a variable.

For example, in the expression below, we are adding the initial value of the Damage variable with the value of the DamageAmplifier variable and storing the result in the Damage variable:

set Damage = Damage + DamageAmplifier


This same expression can be rewritten using the += operator like this:

set Damage += DamageAmplifier


Note 1: In the Verse language there are failable expressions. This means that the expression needs to be executed in a failure context, such as the if expression. 

Note 2: Division between integers is failable. You must use the Floor() function to get the integer part of the result or the Ceil() function to round the result up.

Note 3: The Verse language does not have the % (modulo) operator used to get the remainder of a division between integers. Instead you can use the Mod[] function.


  • Relational Operators

Relational (or comparison) operators are used to compare two values. The result of the comparison will be either success or failure.

Note this important difference between the Verse language and other languages ​​that use Boolean values ​​(true or false) as the result of comparison. Failure is an element of the Verse language used to control program flow.

Expressions that use relational operators are failable.


These are the relational operators:

Operator Comparison
< Less than
<= Less than or equal to
> Greater than
>= Greater than or equal to
= Equal to
< > Not equal to


The example below checks if the value of the PlayerHealth variable is less than or equal to zero. If the if statement succeeds then the GameOver() function will be executed.

if (PlayerHealth <= 0): 

    GameOver()


  • Logical Operators

Logical (or decision) operators perform operations with failable expressions (the result of each expression can be success or failure).

These are the logical operators:

Operator Decision
or Success if one of the expressions is success
and Success if both expressions are success
not It uses only one expression.
The result is the opposite value


Before showing an example of a logical operator, let's learn about another operator in the Verse language.


  • ? (query)

The ? operator is called query and is used to check whether a value of type logic is true resulting in success. The expression fails if the logic value is false.

The example below shows the use of the ? operator and the logical and operator. The variable HasKey is of type logic and the variable EnemyCount is of type int. The if expression will succeed if HasKey has the value true and EnemyCount is equal to zero.

if (HasKey? and EnemyCount = 0):

    OpenDoor()


  • Operator precedence

Operators have an order of precedence. This means that operators with higher precedence are executed first in an expression.

The list below shows the precedence of operators. 

Higher precedence
?
not
*  /
+  -
=  < >  <  <=  >  >=
and
or
set  =


When two operators have the same precedence in an expression, the operator on the left will be executed first.


  • Grouping expressions

You can group expressions using parentheses ( ) to define the order in which the expressions are executed. Expressions enclosed in ( ) take precedence over operators and must be executed first.

As an example, see the two lines below:

set Result1 = 5 * 2 + 4

set Result2 = 5 * (2 + 4)

In the first line, the variable Result1 will receive the value of 14. The multiplication will be performed first because the * operator has higher precedence than the + operator.

In the second line, the variable Result2 will receive the value of 30. The expression inside the parentheses will be executed first. Then the multiplication will be performed.


Let's create a device in UEFN to see the operators in action.

In any UEFN project, open Verse Explorer, right-click on the project name and choose the Add new Verse file to project option.

In Device Name put operator_device and click the Create Empty button.

Copy the Verse code below into the operator_device file:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

operator_device := class(creative_device):
        
    X : float = 6.0
    Y : float = 2.0

    LogicTrue : logic = true
    LogicFalse : logic = false

    OnBegin<override>()<suspends>:void=

        Print("X = {X} --- Y = {Y}")

        Print("X + Y = {X + Y}")
        Print("X - Y = {X - Y}")
        Print("X * Y = {X * Y}")
        Print("X / Y = {X / Y}")

        Print("X > Y  --- { if(X > Y) then "Success" else "Failure"} ")
        Print("X <= Y --- { if(X <= Y) then "Success" else "Failure"} ")
        Print("X = Y  --- { if(X = Y) then "Success" else "Failure"} ")
        Print("X <> Y --- { if(X <> Y) then "Success" else "Failure"} ")

        Print("LogicTrue? or LogicFalse? --- { 
                if(LogicTrue? or LogicFalse?) then "Success" else "Failure"} ")
                                               
        Print("LogicTrue? and LogicFalse? --- { 
                if(LogicTrue? and LogicFalse?) then "Success" else "Failure"} ")

        Print("not LogicFalse? --- { 
                if(not LogicFalse?) then "Success" else "Failure"} ")


The Print function allows the inclusion of an expression within the characters { }. The result of the expression will be part of the text that will be written.

In the Print functions that use relational and logical operators, if statements were used to test the success or failure of the expressions and return these results as text.

Save the file and compile the Verse code using the Verse > Build Verse Code option from the UEFN menu.

Access the Content Drawer and add our Verse device operator_device to the level.

Click the Launch Session button located in the UEFN toolbar to load the level into Fortnite. 

After starting the session in Fortnite, press the Tab key and select the Log tab to view the log with the messages written by the Print functions. 



Table of Contents Verse