Conversion de type

Lorsque vous utilisez des données, il est souvent nécessaire de convertir des variables d'un type de données en un autre type. Par exemple, l'affichage du résultat d'un calcul implique la conversion du type float en type string.

Dans Verse, toutes les conversions de type sont explicites, c'est pourquoi vous devez utiliser une fonction telle que ToString() ou un opérateur de multiplication (*) pour convertir un objet en un type de données différent. La conversion explicite d'un type en un autre est également appelée conversion de type.

Convertir le type float en int

La conversion d'un type float en type int requiert une fonction qui spécifie de manière explicite la manière dont elle convertira un nombre à virgule décimale en nombre entier. Les fonctions suivantes gèrent toutes la conversion, mais leur fonctionnement est différent. Vous êtes libre de choisir celle qui correspond le mieux à une situation donnée.

• Round[]

• Floor[]

• Ceil[]

• Int[]

Dans cet exemple, différentes fonctions convertissent quatre valeurs littérales float en valeurs int à l'aide de l'opérateur or pour créer un contexte d'échec. Ensuite, set affecte les valeurs aux variables de type int. 

# The Int[] method has the <decides> effect,
# This means that we need to account for failure as it is a failable expression.                  
# This results in the following
# var WoodInt:int = failable expression or the value if it fails.

var WoodCollectedFloat:float = 10.5
var WoodInt:int = Int[WoodCollectedFloat] or 0 
Print("Printing WoodInt Value (10): {WoodInt}")
        
# Similar to Int[], Floor[], Ceil[], and Round[] also have the <decides> effect

Dans cet exemple, l'expression if crée le contexte d'échec pour ces fonctions faillibles et set attribue les valeurs aux variables de type int. 

var WoodCollected:int = 0
var StoneCollected:int = 0
var GoldCollected:int = 0
var FoodCollected:int = 0 

if:
    # This block is the condition of the if expression
    # Which creates the failure context
    # If any fail, the entire chain of execution is rolled back
    # And the else branch, if it exists, is executed

Convertir le type int en float

L'opérateur de multiplication (*) convertit le nombre entier en nombre à virgule flottante avant d'effectuer la multiplication.  La méthode de conversion d'un type de données int en type de données float consiste à multiplier le nombre entier par 1,0. 

Ce code convertit la variable int StartingPositionX en float par multiplication pour pouvoir l'utiliser dans la déclaration d'une variable vector3. Le type de données vector3 requiert des valeurs de type float pour ses champs X, Y et Z.

# Required for the vector3 type
using { /UnrealEngine.com/Temporary/SpatialMath}

var StartingPositionX:int = 960

# CurrentX = 960.0
var CurrentX:float = StartingPositionX * 1.0
var CurrentPosition:vector3 = vector3{X := CurrentX, Y := 0.0, Z := 0.0}
Print("CurrentX: {CurrentX}")

Convertir en type string

Vous pouvez convertir plusieurs types de données en type string à l'aide d'une fonction ToString() ou d'une interpolation de chaîne, qui appelle une fonction ToString(). Actuellement, les types suivants ont des fonctions ToString() intégrées dans Verse.

• float

• int

• []char

• char (caractère)

• vector2

• vector3

• rotation

Dans cet exemple, les variables sont converties en chaîne par interpolation de chaîne et via les fonctions ToString(). Les deux méthodes donnent le même résultat, car l'interpolation de chaîne appelle ToString().

var WoodCollected:int = 100
# Convert using string interpolation
Print("WoodCollected: { WoodCollected }")
# or ToString() function
Print("WoodCollected: " + ToString(WoodCollected))

var InitialDistance:float = 3.625
# Convert using string interpolation
Print("InitialDistance: { InitialDistance }")
# or ToString() function

Convertir un type de données personnalisé en chaîne

Il est également possible de convertir les types de données personnalisés en chaînes en implémentant une fonction ToString(custom_type) pour le type de données. Si une fonction ToString(custom_type) existe, l'interpolation de chaîne l'utilise pour convertir automatiquement les types de données en chaînes.

Voici un exemple de fonction ToString() personnalisée pour une énumération (enum) de fruits.

fruit := enum:
    Apple 
    Banana 
    Strawberry

ToString(Fruit: fruit):string =
    case(Fruit):
        fruit.Apple => "Apple"
        fruit.Banana => "Banana"
        fruit.Strawberry => "Strawberry"

Voici un exemple de fonction ToString() personnalisée pour une classe personnalisée. Notez que la fonction ToString() est déclarée hors de la classe waypoint. Dans la fonction SetDestination(), l'interpolation de chaîne de Destination appelle la fonction ToString() personnalisée.

# Custom class with constructor and a ToString() function
waypoint := class():
    DisplayName:string
    Position:vector3 = vector3{}

MakeWaypoint<constructor>(Name:string, X:float, Y:float, Z:float) := waypoint:
    DisplayName := Name
    Position := vector3{X := X, Y := Y, Z := Z}

ToString(Waypoint: waypoint):string =

Convertir une référence d'objet en type différent

Vous pouvez convertir explicitement des références à des objets (ou conversion de type) en classes ou interfaces différentes à l'aide de la syntaxe suivante :

if (NewObjectReference := object_type_to_cast_to[ObjectReference]) {}

L'élément object_type_to_cast_to représente la classe ou l'interface vers laquelle vous tentez de convertir la référence. Cett expression est faillible, car la conversion de type échoue si l'objet ne peut pas être converti dans le type spécifié. La tentative de conversion d'une référence d'objet en classe échoue si la classe ne correspond pas au type de l'objet, au type d'une superclasse ou à une interface que la classe de l'objet implémente.

Ce code déclare une interface positionable, une classe abstraite shape qui hérite de l'interface positionable et deux sous-classes de shape : triangle et square. Il crée ensuite un objet de type square appelé MyShape et tente de le convertir en trois autres types. Voici un aperçu des résultats.

# Class and interface definitions
positionable := interface() {}
shape := class<abstract>(positionable) {}
triangle := class(shape) {}
square := class(shape) {}

# Create a square object referenced using the superclass type shape
MyShape:shape = square{}

# This will succeed since MySquare is a square object

MyDrawable:positionable = MyShape

Exemples d'utilisation de la conversion de type

Par exemple, une conversion de type d'objet dans l'UEFN peut consister à rechercher des acteurs d'un certain type et à appeler des fonctions basées sur ce type. Pour savoir comment procéder, consultez la page Rechercher des acteurs dotés d'une balise de jeu dans Balises de jeu.