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


UEFN Verse: Operadores

Operadores são símbolos que representam operações aritméticas, relacionais ou lógicas.


  • Operadores Aritméticos

Os operadores aritméticos efetuam operações matemáticas entre dois valores.

Estes são os principais operadores aritméticos:

Operador Operação
+ Adição
- Subtração
* Multiplicação
/ Divisão


A linha abaixo mostra um exemplo de uso de um operador aritmético. Considere que Damage, AttackHit e ShieldLevel são variáveis. O valor de AttackHit é subtraído pelo valor de ShieldLevel. O resultado é armazenado na variável Damage:

set Damage = AttackHit - ShieldLevel


Os operadores aritméticos podem ser combinados com o operador de atribuição para modificar o valor de uma variável.

Por exemplo, na expressão abaixo, estamos somando o valor inicial da variável Damage com o valor da variável DamageAmplifier e armazenando o resultado na variável Damage:

set Damage = Damage + DamageAmplifier


Esta mesma expressão pode ser reescrita usando o operador += desta forma:

set Damage += DamageAmplifier


Nota 1: Na linguagem Verse existem expressões falíveis. Isto significa que a expressão precisa ser executada em um contexto de falha, como a expressão if.

Nota 2: A divisão entre números inteiros é falível. É preciso usar a função Floor() para obter a parte inteira do resultado ou a função Ceil() para arredondar o resultado para cima.

Nota 3: A linguagem Verse não possui o operador % (módulo) usado para obter o resto de uma divisão entre números inteiros. No lugar você pode usar a função Mod[].


  • Operadores Relacionais

Os operadores relacionais (ou de comparação) são usados para comparar dois valores. O resultado da comparação será sucesso ou falha.

Observe esta diferença importante da linguagem Verse em relação a outras linguagens que usam valores Booleanos (verdadeiro ou falso) como resultado da comparação. A falha é um elemento da linguagem Verse usada no controle do fluxo do programa.

As expressões que usam os operadores relacionais são falíveis.

Estes são os operadores relacionais:

Operador Comparação
< Menor que
<= Menor ou igual a
> Maior que
>= Maior ou igual a
= Igual
< > Não é igual


O exemplo abaixo verifica se o valor da variável PlayerHealth é menor ou igual a zero. Se a expressão do if tiver sucesso então a função GameOver() será executada.

if (PlayerHealth <= 0): 

    GameOver()


  • Operadores Lógicos

Os operadores lógicos (ou de decisão) efetuam operações com expressões falíveis (o resultado de cada expressão pode ser sucesso ou falha).

Estes são os operadores lógicos:

Operador Decisão
or Sucesso se uma das expressões for sucesso
and Sucesso se ambas as expressões forem sucesso
not Usa somente uma expressão.
O resultado é a situação oposta


Antes de mostrar um exemplo de operador lógico, vamos conhecer mais um operador da linguagem Verse.


  • ? (query)

O operador ? é chamado de query e é usado para verificar se um valor do tipo logic é true resultando em sucesso. A expressão falha se o valor logic for false.

O exemplo abaixo mostra o uso do operador ? e do operador lógico and.  A variável HasKey é do tipo logic e a variável EnemyCount é do tipo int. A expressão do if terá sucesso se HasKey tiver o valor true e EnemyCount for igual a zero.

if (HasKey? and EnemyCount = 0):

    OpenDoor()


  • Precedência dos operadores

Os operadores possuem uma ordem de precedência. Isto significa que os operadores com maior precedência são executados primeiros em uma expressão.

A relação abaixo mostra a precedência dos operadores. 

Maior precedência
?
not
*  /
+  -
=  < >  <  <=  >  >=
and
or
set  =


Quando dois operadores tem a mesma precedência em uma expressão, o operador que está à esquerda será executado primeiro.


  • Agrupamento de expressões

Você pode agrupar expressões usando parênteses ( ) para definir a ordem de execução das expressões. As expressões que estiverem dentro de ( ) tem precedência em relação aos operadores e devem ser executadas antes.

Como exemplo, veja as duas linhas abaixo:

set Result1 = 5 * 2 + 4

set Result2 = 5 * (2 + 4)

Na primeira linha, a variável Result1 receberá o valor de 14. A multiplicação será realizada primeiro porque o operador * tem precedência maior do que o operador +.

Na segunda linha, a variável Result2 receberá o valor de 30. A expressão dentro dos parênteses será executada primeiro. Depois será realizada a multiplicação. 


Vamos criar um dispositivo no UEFN para vermos os operadores 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 operator_deviceclique no botão Create Empty.

Copie o código Verse abaixo para o dispositivo operator_device

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


A função Print permite a inclusão de uma expressão dentro dos caracteres { }. O resultado da expressão fará parte do texto que será escrito. 

Nas funções Print que usam operadores relacionais e lógicos foram usados if para testar o sucesso ou falha da expressão e retornar este resultado como texto.

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 operator_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


terça-feira, 15 de outubro de 2024

UEFN Verse: Constants and Variables

Constants and variables represent memory locations used to store values.

A constant receives its value at initialization and this value cannot be modified during program execution.

A variable can have its value modified at any time.

The creation of constants and variables are similar. The only difference is in the use of the var keyword to indicate that it is a variable. This is the creation format:

    var Identifier : type = initialization


Let's analyze each element from the line above:

  • var : Used to indicate the creation of a variable. If omitted, it means that a constant is being created.
  • Identifier : Name of the constant or variable.
  • type : Indicates the type of values ​​that can be stored.
  • initialization : Expression used to generate an initial value for the constant or variable.


There are several types that can be used in constants and variables. The most common types are described below:

  • logicIt can only store the Boolean values true or false.
  • int : Stores integer values.
  • float It can store numerical values that are not integers.
  • string : Used to store text (sequence of characters).
  • Reference : Used to reference instances of a class. For example, a creative device that is in the level.

The type of a constant can be omitted when creation is done inside a function (such as the OnBegin function). The format is as follows:

    Identifier := initialization


Let's create a simple device in UEFN to see examples of using constants and variables.

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

Select the Verse Device template. In Device Name, put const_var_device and click the Create button to use the template code.

Modify the Verse code of the const_var_device device to have this content:

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

const_var_device := class(creative_device):

    # logic: Boolean values ​​(true or false) 
    @editable
    StartTimer : logic = false

    # string: Stores text. "" is an empty string
    @editable 
    Name : string = ""

    # float: Accepts numeric values ​​that are not integers
    @editable 
    HeightInMeters : float = 1.80

    # var: Indicates that it is a variable.
    # int: Stores integer values.
    var NameLength : int = 0

    # This constant is a reference to an instance of the timer_device class
    @editable 
    TimerDevice : timer_device = timer_device{}

    # This function runs when the device starts in-game
    OnBegin<override>()<suspends>:void=

        # The string type of the WelcomeMsg constant was inferred from the expression.
        # {Name} will be replaced by the value of the Name constant.
        WelcomeMsg := "Welcome {Name} to UEFN"

        # Use set to modify the value of a variable
        set NameLength = Name.Length

        # Print: It writes text on the screen and in the log 
        Print(WelcomeMsg)
        Print("{Name} has {NameLength} characters")
        
        # if: It executes a block of code if the result of the expression is success
        if(StartTimer?):
            TimerDevice.Start()

Lines starting with the # character are comments that are ignored by the Verse code.

@editable is a Verse language attribute that indicates that the constant or variable can be modified directly in UEFN.

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

To add our Verse device to the level, access the Content Drawer and the folder that has the project name plus Content.

Drag the const_var_device and drop it onto the level. Also drag onto the level a Timer Device which can be found in the Fortnite > Devices folder.

Select the const_var_device in the level. In the Details tab you can modify the values ​​of the constants that were marked with @editable. Check the checkbox for the StartTimer constant. Enter your name in the Name constant. Click on the TimerDevice drop-down to select the Timer Device that we added 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. Also verify that the Timer Device is started by our Verse code if the StartTimer constant value is true.


Table of Contents Verse


UEFN Verse: Constantes e Variáveis

Constantes e variáveis representam locais de memória usados para armazenar valores.

Uma constante recebe seu valor na inicialização e este valor não pode ser modificado durante a execução do programa.

Uma variável pode ter seu valor modificado a qualquer momento.

A criação de constantes e variáveis é parecida. A única diferença está no uso da palavra chave var para indicar que é uma variável. Este é o formato da criação:

    var Identificador : tipo = inicialização


Vamos analisar cada elemento da linha acima:

  • var : Usado para indicar a criação de uma variável. Se for omitido, significa que uma constante está sendo criada.
  • Identificador : Nome da constante ou variável.
  • tipo : Indica o tipo de valores que poderá ser armazenado.
  • inicialização : Expressão usada para gerar um valor inicial para a constante ou variável.


Existem diversos tipos que podem ser usados nas constantes e variáveis. Os tipos mais comuns estão descritos abaixo:

  • logic : Só pode armazenar os valores Booleano true ou false.
  • int : Armazena valores inteiros.
  • float : Pode armazenar valores numéricos que não são inteiros.
  • string : Usado para armazenar texto (sequência de caracteres).
  • Reference : Usada para referenciar instâncias de uma classe. Por exemplo, um dispositivo criativo que está no nível.

O tipo de uma constante pode ser omitido quando a criação é feita dentro de uma função (como a função OnBegin). O formato fica assim:

    Identificador := inicialização


Vamos criar um dispositivo simples no UEFN para vermos exemplos de uso das constantes e variáveis.

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.

Selecione o template Verse Device. Em Device Name coloque const_var_deviceclique no botão Create para usar o código do template.

Modifique o código Verse do dispositivo const_var_device para ficar com este conteúdo:

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

const_var_device := class(creative_device):

    # logic: Valores Booleano (true ou false) 
    @editable
    StartTimer : logic = false

    # string: Armazena texto. "" é uma string vazia
    @editable 
    Name : string = ""

    # float: Aceita valores numéricos que não são inteiros
    @editable 
    HeightInMeters : float = 1.80

    # var: Indica que é uma variável.
    # int: Armazena valores inteiros. 
    var NameLength : int = 0

    # Esta constante é uma referência para uma instância da classe timer_device
    @editable 
    TimerDevice : timer_device = timer_device{}

    # Esta função executa quando o dispositivo é iniciado no jogo
    OnBegin<override>()<suspends>:void=

        # O tipo string da constante WelcomeMsg foi inferido a partir da expressão.
        # {Name} será substituído pelo valor da constante Name.
        WelcomeMsg := "Welcome {Name} to UEFN"

        # Use set para modificar o valor de uma variável
        set NameLength = Name.Length

        # Print: Escreve um texto na tela e no log 
        Print(WelcomeMsg)
        Print("{Name} has {NameLength} characters")
        
        # if: Executa um bloco de código se o resultado da expressão for sucesso
        if(StartTimer?):
            TimerDevice.Start()

As linhas que começam com o caractere # são comentários ignorados pelo código Verse.

O @editable é um atributo da linguagem Verse que indica que a constante ou variável pode ser modificada diretamente no UEFN.

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

Para adicionar o nosso dispositivo Verse ao nível, acesse o Content Drawer e a pasta que tem o nome do projeto mais Content.

Arraste o const_var_device e solte-o no nível. Arraste também para o nível um Timer Device que pode ser encontrado na pasta Fortnite > Devices.

Selecione o const_var_device no nível. Na aba Details você pode modificar os valores das constantes que foram marcadas com @editable. Marque o checkbox da constante StartTimer. Coloque o seu nome na constante Name. Clique no drop-down de TimerDevice para selecionar 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 Log para visualizar o log com as mensagens escritas pelas funções Print. Verifique também que o Timer Device é iniciado pelo nosso código Verse se o valor da constante StartTimer for true.


Sumário Verse


sábado, 12 de outubro de 2024

Translations of my Blueprints/UE5 book

The purpose of this post is to share with you the joy I feel when I see my book Blueprints Visual Scripting for Unreal Engine 5 being translated and published in other languages.

This is the result of many years of work with Unreal Engine that started with my tutorials on programming in UnrealScript:

https://romerounrealscript.blogspot.com/p/table-of-contents.html

It was something I started without any pretensions but which generated opportunities that I decided to dedicate myself to.

My book was published in 2022:


The Korean version was published in 2023:


The Chinese version was published in 2024:



Translation into Russian is underway.


Currently, the focus of my studies is on the new Verse programming language. It is part of UEFN (Unreal Editor for Fortnite) but later it will be available in the standard Unreal Engine editor.

This is the link to my Verse language tutorials:

https://romeroblueprints.blogspot.com/p/table-of-contents-verse.html