Typecasting e conversione di tipo

Quando si utilizzano i dati, è spesso necessario convertire le variabili da un tipo di dato a un altro. Ad esempio, per visualizzare il risultato di un calcolo, è necessario convertire il tipo float in un tipo string.

In Verse, tutte le conversioni di tipo sono esplicite, richiedono quindi una funzione come ToString() o un operatore di moltiplicazione (*) per convertire un oggetto in un tipo di dati diverso. La conversione esplicita da un tipo all'altro è definita anche typecasting.

Conversione di float in int

La conversione da un tipo float in un tipo int richiede una funzione che specifichi esplicitamente come convertire un numero in virgola mobile in un numero intero. Le seguenti funzioni gestiscono tutte la conversione, ma operando in modo differente. Sta a te decidere quale funzione risulta più adatta a una determinata situazione.

• Round[]

• Floor[]

• Ceil[]

• Int[]

In questo esempio, diverse funzioni convertono quattro valori letterali float in valori int utilizzando l'operatore or per creare un contesto di errore. In seguito, set assegna i valori alle variabili di tipo 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

In questo esempio, l'espressione if crea il contesto di errore per queste funzioni fallibili e set assegna i valori alle variabili di tipo 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

Conversione di int in float

L' operatore di moltiplicazione (*) converte il numero intero in un numero a virgola mobile prima di eseguire la moltiplicazione.  Il metodo per convertire da un tipo int in un tipo di dati float prevede la moltiplicazione del numero intero per 1,0. 

Questo codice converte la variabile int StartingPositionX in un valore float tramite moltiplicazione in modo da utilizzarla nella dichiarazione di una variabile vector3. Il tipo di dati vector3 richiede valori di tipo float per i campi X, Y e 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}")

Conversione in una stringa

Puoi convertire diversi tipi di dati in una string utilizzando una funzione ToString() o l'interpolazione di stringhe, che richiama una funzione ToString(). Attualmente, i seguenti tipi hanno funzioni ToString() integrate in Verse.

• float

• int

• []char

• char

• vector2

• vector3

• rotation

In questo esempio, le variabili vengono convertite in una stringa utilizzando l'interpolazione delle stringhe e le funzioni ToString(). Entrambi i metodi hanno lo stesso risultato perché l'interpolazione di stringhe chiama 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

Conversione di un tipo di dati personalizzato in una stringa

I tipi di dati personalizzati si possono convertire in stringhe anche implementando la funzione ToString(custom_type) per il tipo di dati. Se esiste una funzione ToString(custom_type), l'interpolazione delle stringhe la utilizza per convertire automaticamente i tipi di dati in stringhe.

Ecco un esempio di funzione ToString() personalizzata per una enum di frutti.

fruit := enum:
    Apple 
    Banana 
    Strawberry

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

Ecco un esempio di funzione ToString() personalizzata per una classe personalizzata. Nota che la funzione ToString() è dichiarata al di fuori della classe waypoint. Nella funzione SetDestination(), l'interpolazione di stringhe di Destination chiama la funzione ToString() personalizzata.

# 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 =

Conversione di un riferimento oggetto in un tipo diverso

Puoi convertire esplicitamente i riferimenti a oggetti (o eseguirne il typecasting) in classi o interfacce diverse utilizzando la sintassi seguente:

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

object_type_to_cast_to rappresenta la classe o l'interfaccia in cui si sta cercando di convertire il riferimento. Si tratta di un'espressione fallibile, perché la conversione del tipo non riesce se l'oggetto non può essere convertito in quel tipo specifico. Il tentativo di convertire un riferimento a un oggetto in una classe non riesce se la classe non corrisponde al tipo dell'oggetto, al tipo di una superclasse o a un'interfaccia implementata dalla classe dell'oggetto.

Questo codice dichiara un'interfaccia positionable, una classe astratta shape che eredita dall'interfaccia positionable e due sottoclassi di shape: triangle e square. Poi, crea un oggetto di tipo square chiamato MyShape e tenta di eseguirne il typecasting in tre altri tipi. Ecco una panoramica dei risultati.

# 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

Esempi di conversione di tipo

Un caso di utilizzo del typecasting di un oggetto in UEFN comporta la ricerca di attori di un certo tipo e la chiamata di funzioni basate su quel tipo. Per scoprire come fare quanto descritto, consulta Trovare attori con un tag di gameplay in Tag di gameplay.