GDScript - Variabili e tipi di dato, commenti

Facciamo un mini-tour nei fondamenti della programmazione in GDScript introducendo variabili e tipi, che rispettivamente memorizzano e definiscono la natura dei dati da manipolare. Vedremo quindi i tipi di dati fondamentali (numeri, booleani, stringhe) ed i commenti al codice.

Generalità

GDScript è un linguaggio di scripting creato specificatamente per il Godot Game Engine. La sua natura a tipizzazione dinamica offre flessibilità e rapidità di sviluppo, consentendo ai programmatori di concentrarsi sulla creatività e sulla logica del gioco. La sua sintassi è fortemente ispirata quella del linguaggio Python, chiara e concisa, facilita l'apprendimento e la scrittura di codice pulito. L'integrazione con il sistema a nodi di Godot semplifica la gestione della logica di gioco e delle interazioni tra gli oggetti. Questo rende GDScript uno strumento potente per creare videogame in modo efficiente e intuitivo.

Tra gli svantaggi di GDScript troviamo prestazioni inferiori rispetto a linguaggi compilati come C# e C++. La tipizzazione dinamica, pur offrendo flessibilità, può rendere complessa l'individuazione di errori runtime. Gli strumenti di sviluppo sono meno maturi rispetto a quelli dei motori più diffusi (Unreal, Unity).

La documentazione ufficiale di GDScript è disponibile al seguente URL: https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/index.html

Fatte queste premesse è ora di mettere le mani nella marmellata: la programmazione è una questione di esercizio, bisogna provare, sbagliare e riprovare. Scrivete codice, è l'unico modo di imparare e migliorare!

Variabili

Una variabile è un nome simbolico (detto identificatore) che si riferisce a una posizione di memoria del computer, usata per memorizzare e manipolare dati. Una variabile contiene un valore di un certo tipo (come un numero, un testo, ecc.). Il valore memorizzato può essere modificato oppure usato durante l'esecuzione del programma.

Prima di essere usata una variabile va dichiarata (cioè creata). Per dichiarare una variabile si usa la parola chiave var seguita dall' identificatore della variabile:

var nome_variabile

Un identificatore è una qualsiasi sequenza di uno o più caratteri che rispetti le seguenti regole:

• un identificatore può essere costituito da un solo carattere, a patto che sia un carattere alfabetico (minuscolo o maiuscolo).
  Esempio: a è un identificatore valido, quindi la dichiarazione var a è valida;
• un identificatore può iniziare con uno qualsiasi dei caratteri alfabetici (minuscoli o maiuscoli) oppure con il simbolo di sottolineatura _. Il simbolo di sottolineatura è consentito sia all'inizio che in qualsiasi altra posizione di un identificatore.
  Esempio: _sale_e_pepe_ è un identificatore legale quindi la dichiarazione var _sale_e_pepe_ è valida;
• un identificatore non può coincidere con una delle parole chiavi (keyword) del linguaggio. La lista delle parole chiavi di GDScript è disponibile al seguente URL: https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_basics.html#keywords
• un identificatore non può cominciare con una cifra. Le cifre sono consentite all'interno dell'identificatore ma non come primo carattere.
  Esempio: cane4 è un identificatore legale, quindi la dichiarazione var cane4 è valida;
• un identificatore non può contenere spazi né simboli speciali (parentesi, simboli di punteggiatura o di operazioni aritmetiche, apostrofi, accenti, ecc.);
• variabili diverse nello stesso blocco di codice devono avere identificatori differenti; la stessa regola vale per variabili con lo stesso campo di azione (visibilità o scope);
• gli identificatori sono sensibili al contesto (case sensitive), ossia la differenza tra maiuscole e minuscole è significativa: gli identificatori pippo, PIPPO, pIpPo sono diversi tra loro, quindi si possono usare per dichiarare variabili differenti (per ovvi motivi si sconsiglia di farne uso).

OPERATORE DI ASSEGNAZIONE (=)

Dopo la creazione di una variabile, per assegnarle un valore si usa l'operatore di assegnazione = (il simbolo uguale):

nome_variabile = valore

Per creare una variabile e contemporaneamente assegnarle un valore si usa la sintassi

var nome_variabile = valore

Quando ad una variabile viene assegnato un tipo si usa una sintassi leggermente differente, come specificato nei successivi paragrafi.

VALORI PREDEFINITI PER LE VARIABILI

Quando non si assegna un valore ad una variabile, il compilatore le assegna un valore predefinito che dipende dal tipo della variabile: in particolare assegna 0 a variabili che contengono numeri interi (int), 0.0 a quelle peri numeri decimali (float), false ai valori di verità (booleani bool), la stringa vuota "" alle stringhe di testo (String), null agli oggetti.

ESEMPIO (estendi l'area di testo se necessario):

var a var persone = 10 var zio_Paper = "Zio Paperone" var _spesaTotale = 100.75 var test = false print("a = ", a) print("persone = ", persone) print("zio_Paper = ", zio_Paper) print("_spesaTotale = ", _spesaTotale, " euro") print("test = ", test)

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

a = null persone = 10 zio_Paper = Zio Paperone _spesaTotale = 100.75 euro test = false

LETTERALI

Un letterale è un valore scritto direttamente nel codice sorgente, ossia qualcosa che scrivete "letteralmente" nel vostro script, invece di essere il risultato di un'espressione, di un'operazione o di una generica elaborazione. Ad esempio:

• 10 è un valore letterale per un numero intero;
• "Zio Paperone" è un letterale per una stringa di testo;
• 100.75 è un letterale per un numero decimale;
• false è un valore letterale per un booleano (valore di verità);
• 2 è un letterale, mentre 1+1 non lo è (1+1 è un'espressione che calcola il risultato dell'operazione di addizione tra due numeri interi).

Il letterale null indica l'assenza di dati: tale valore indica un tipo di dato "vuoto", ossia un dato a cui non è stato ancora assegnato alcun valore.

Tipi di dato

Un tipo è un attributo che viene assegnato ad un dato. Il tipo dice al compilatore o all'interprete (lo speciale programma che traduce le istruzioni GDScript in istruzioni macchina comprensibili per il computer) in che modo il programmatore intende usare i dati. Un tipo di dato definisce le operazioni che si possono compiere sul dato; ad esempio, il calcolo di una radice quadrata ha senso su tipi di dato numerici ma non su stringhe di testo.

I tipi di dato più comuni comprendono numeri (interi o decimali), stringhe, valori di verità (booleani) ossia variabili i cui valori possono essere solo vero (true) oppure falso (false).

Nei linguaggi a tipizzazione dinamica, il programmatore può omettere (se lo desidera) di assegnare esplicitamente il tipo di dato di una variabile: il tipo verrà assegnato dal compilatore a seconda dell'uso che ne viene fatto nel codice.

Quando non si usano istruzioni che indicano esplicitamente il tipo, le variabili possono essere riutilizzate per memorizzare valori di altri tipi: nel codice seguente, usiamo due variabili prima per memorizzare numeri interi e poi per memorizzare stringhe. Sebbene sia utile per  fare delle prove rapide, sconsiglio decisamente questo approccio, in quanto può portare ad errori di programmazione.

ESEMPIO (estendi l'area di testo se necessario):

print("Usiamo variabili a, b per numeri interi") # variabili a, b di tipo intero (int) var a = 1 var b = 2 print("a = ", a) print("b = ", b) # a + b = 3 print("a + b = ", a+b) print("Riusiamo le variabili a, b per stringhe di testo") # variabili a, b di tipo stringa (String) a = "4" b = "5" print("a = ", a) print("b = ", b) # a + b = 45 print("a + b = ", a+b, " --> stringhe concatenate")

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

Usiamo variabili a, b per numeri interi a = 1 b = 2 a + b = 3 Riusiamo le variabili a, b per stringhe di testo a = 4 b = 5 a + b = 45 --> stringhe concatenate

COMMENTI

Un commento è un testo (in linguaggio naturale) inseirto in uno script che descrive lo scopo di una variabile o la spiegazione del codice di programmazione. I commenti sono ignorati dal compilatore/interprete, quindi non vengono né compilati né eseguiti.

Un commento inizia con il carattere cancelletto # e si estende fino alla fine della riga che lo contiene, quindi un commento può:

• occupare solo la parte finale di una riga, quando il carattere # è inserito dopo un'istruzione valida;
• occupare una singola riga, quando il carattere # è inserito all'inizio della riga;
• occupare più righe consecutive, quando ciascuna delle righe che lo compongono iniziano con il carattere #.

Esempio (estendi l'area di testo se necessario):

# commento su singola riga var a = 3 # commento dopo istruzione var b = 4 # per il teorema di Pitagora, l'ipotenusa c rispetta l'espressione # c^2 = a^2 + b^2 var c = 5 # ipotenusa: 5^2 = 3^2 + 4^2

In Godot esistono diverse forme di commenti, per ulteriori informazioni riferirsi alla documentazione ufficiale all'URL https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_documentation_comments.html

Numeri

In Godot i numeri possono essere interi o decimali. Con variabili di tipo numerico si possono fare le usuali operazioni aritmetiche e usare le funzioni algebriche.

Numeri interi (int)

Il tipo int è il tipo di dato predefinito per i numeri interi. La rappresentazione binaria è a 64 bit con aritmetica in complemento a 2. L'intervallo numerico rappresentabile è
[-2⁶³ ; +2⁶³-1] = [-9223372036854775808 ; +9223372036854775807].
Un numero è considerato intero se non contiene il punto decimale: ad esempio, 36 è un tipo intero int, invece 36. (notare il punto decimale alla fine del numero) e 36.0 sono di tipo decimale float.

Per ulteriori informazioni riferirsi alla documentazione ufficiale: https://docs.godotengine.org/en/stable/classes/class_int.html#class-int

Numeri decimali (float)

Il tipo float è il tipo di dato predefinito per i numeri decimali, corrispondente al tipo double a 64 bit del linguaggio C++. La rappresentazione binaria è a 64 bit con aritmetica in virgola mobile standard IEEE 754. L'intervallo numerico rappresentabile è approssimativamente
[-1.79769e308 ; +1.79769e308] = [-1.79769*10³⁰⁸ ; +1.79769*10³⁰⁸].
I più piccoli (in modulo) numeri rappresentabili (ossia i numeri più vicini allo 0) sono approssimativamente -2.225*10^-308 e +2.225*10^-308.

Sebbene i numeri decimali abbiano una rappresentazione a 64 bit (con precisione di 14 cifre significative dopo il punto decimale) molte funzioni matematiche di Godot eseguono una conversione a 32 bit (singola precisione con 6 cifre significative); ad esempio, è ciò che avviene con le coordinate nel piano o nello spazio, dove non è necessaria una precisione estesa per la rappresentazione a video (risparmiando tempo di elaborazione e spazio di memoria).

Per ulteriori informazioni riferirsi alla documentazione ufficiale: https://docs.godotengine.org/en/stable/classes/class_float.html#class-float

Operazioni sui numeri

Quando si eseguono le operazioni aritmetiche che coinvologono numeri interi e decimali, occorre prestare attenzione al tipo dei numeri coninvolti nelle operazioni, altrimenti si corre il rischio di avere approssimazioni o troncamenti nel risultato delle operazioni.

ESEMPIO (estendi l'area di testo se necessario):

var a = 5.0 # float var b = 5 # int var d = 2 # int print("a : d = ", a, " : ", d, " = ", a / d) # float : int = float print("b : d = ", b, " : ", d, " = ", b / d) # int : int = int var k = 2.0 # float print("a : k = ", a, " : ", k, " = ", a / k) # float : float = float print("b : k = ", b, " : ", k, " = ", b / k) # int : float = float var c: int = a / k # conversione forzata di tipo --> float : float = int print("c = a : k = ", a, " : ", k, " = ", c)

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

a : d = 5.0 : 2 = 2.5 b : d = 5 : 2 = 2 a : k = 5.0 : 2.0 = 2.5 b : k = 5 : 2.0 = 2.5 c = a : k = 5.0 : 2.0 = 2

Booleani (bool)

Il tipo bool è il tipo di dato predefinito per i valori di verità (o booleani). Un valore booleano può rappresentare solo due condizioni: true (vero) oppure false (falso). Con vairiabili di tipo booleano si possono fare le usuali operazioni di and e or logici e la negazione (unaria) not.

ESEMPIO (estendi l'area di testo se necessario):

var a: bool = false print("Tabella di verita' del not (logico)") print("______________") print("a | not a") print("--------------") print(a, " | ", not a) a = true print(a, " | ", not a) print("") print("Tabella di verita' di and e or (logici)") print("_________________________________") print("a | b | a and b | a or b") print("---------------------------------") a = false var b: bool = false print(a , " | ", b, " | ", a and b, " | ", a or b) b = true print(a , " | ", b, " | ", a and b, " | ", a or b) a = true b = false print(a , " | ", b, " | ", a and b, " | ", a or b) b = true print(a , " | ", b, " | ", a and b, " | ", a or b)

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

Tabella di verita' del not (logico) ______________ a | not a -------------- false | true true | false Tabella di verita' di and e or (logici) _________________________________ a | b | a and b | a or b --------------------------------- false | false | false | false false | true | false | true true | false | false | true true | true | true | true

Per le operazioni logiche su variabili booleane si possono usare i simboli:

• ! al posto del not
• || al posto di or
• && al posto di and

tuttavia è una pratica sconsigliata. Analogamente ad altri linguaggi di programmazione, si possono assegnare alle variabili booleane valori numerici, dove lo 0 equivale a false, mentre un valore diverso da 0 equivale a true; anche in questo caso si tratta di una pratica sconsigliata.

Per ulteriori informazioni riferirsi alla documentazione ufficiale: https://docs.godotengine.org/en/stable/classes/class_bool.html

Stringhe (String)

Il tipo String è il tipo di dato predefinito per le stringhe di testo. Una stringa è una sequenza di caratteri (eventualmente vuota) racchiusa da una coppia di virgolette. La funzione print() stampa una stringa. L'operazione + esegue la concatenazione di stringhe.

ESEMPIO (estendi l'area di testo se necessario):

var vuota = "" # stringa vuota print("Vuota: ", vuota) var nome = "Paperino" print("Nome: ", nome) var cognome = "Paolino" print("Cognome: ", cognome) var tutto = nome + " " + cognome print("Nome e cognome: ", tutto)

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

Vuota: Nome: Paperino Cognome: Paolino Nome e cognome: Paperino Paolino

Per ulteriori informazioni riferirsi alla documentazione ufficiale: https://docs.godotengine.org/en/stable/classes/class_string.html#class-string

Assegnazione del tipo ad una variabile

In Godot ci sono tre modi di creare e assengare valori alle variabili: dichiarazione e/o assegnazione senza specificarne il tipo, dichiarazione e/o assegnazione specificando esplicitamente il tipo, dichiarazione implicita del tipo mediante l'assegnazione di uno specifico valore.

DICHIARAZIONE SENZA ATTRIBUZIONE DI TIPO (sconsigliato)

In questo caso la stessa variabile può assumenre valori di tipo diverso a seconda di come si usa, una pratica che può portare a errori anche gravi in fase di esecuzione del codice o a risultati inconsistenti.

Per dichiarare una variabile senza omettendone il tipo, si usa la parola chiave var seguita dall'identificatore della variabile ed eventualmente assegnandole un valore con l'operatore di assegnazione uguale (=):

var nome_variabile
var nome_variabile = valore

ESEMPIO (estendi l'area di testo se necessario):

var a print("a = ", a) # a=null valore predefinito a = "Pippo" print("a = ", a) a = 12 print("a = ", a) var b = 3.1415 #creazione ed assegnazione di valore print("b = ", b)

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

a = null a = Pippo a = 12 b = 3.1415

DICHIARAZIONE ESPLICITA DI TIPO (consigliato)

Il programmatore assegna direttamente un tipo alla variabile ed essa non potrà contenre alcun valore di tipo diverso: ad esempio, se una variabile viene dichiarata di tipo int, l'assegnazione di un valore decimale porterà al troncamento delle cifre dopo il punto decimale.

Per dichiarare una variabile esplicitandone il tipo, si usa la parola chiave var seguita dall' identificatore della variabile, seguito dai 2 punti (:) ed il tipo della variabile, ed eventualmente assegnandole un valore con l'operatore di assegnazione uguale (=):

var nome_variabile: tipo
var nome_variabile: tipo = valore

ESEMPIO (estendi l'area di testo se necessario):

var a: int print("a = ", a) # a=0 valore predefinito a = 666 print("a = ", a) var k: int = 555 # assegnazione diretta del valore print("k = ", k) var b: int = 3.1415 # essendo int si perdono le cifre decimali print("b = ", b) # b=3 var x = 5.6789 # float # incrementiamo b=3 con il valore di x=5.6789 b += x # b=b+x ossia 3+5.6789 = 8 per il troncamento dei decimali print("b = ", b) # b=8

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

a = 0 a = 666 k = 555 b = 3 b = 8

DICHIARAZIONE IMPLICITA DI TIPO (approccio intermedio)

Il programmatore crea una variabile senza specificarne il tipo ma assegnandole un determinato valore. Il compilatore deduce (inferisce) il tipo della variabile a partire dal valore che le è stato assegnato, mediante un meccanismo chiamato inferenza di tipo (type inference). Dopo che il tipo della variabile è stato inferito, non sarà più possibile assegnarle valori di tipo diverso (come nella dichiarazione esplicita di tipo).

Per dichiarare una variabile con tipo implicito, si usa la parola chiave var seguita dall' identificatore della variabile, seguito da := (2 punti uguale), seguiti dal valore che deve assumere la variabile (che serve a dedurne il tipo):

var nome_variabile := valore

ESEMPIO (estendi l'area di testo se necessario):

var a := 666 # inferisce int var b := 12.345 # inferisce float print("a = ", a) print("b = ", b) var c := a + b # inferisce float print("c = a + b = ", c) # c=678.345 var d: int = a + b # d esplicitamente di tipo int print("d = a + b = ", d) # d=678

OUTPUT dell'esecuzione (estendi l'area di testo se necessario):

a = 666 b = 12.345 c = a + b = 678.345 d = a + b = 678

Per ulteriori informazioni sulle variabili riferirsi alla documentazione ufficiale: https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_basics.html#variables

Precedente

Indice

Successivo