Appunti di migrazione: da ActionScript 3 a C#

0
Share:

Continuano i miei appunti di migrazione da Animate/AIR a Unity. La volta scorsa ho fatto una comparazione generale tra i due ambienti di sviluppo. Oggi voglio concentrarmi solo sui rispettivi codici. Come per le app AIR sviluppate in Animate, anche nel caso di Unity la programmazione ha un ruolo fondamentale. Purtroppo, a prescindere da slogan e promesse, se non sai programmare in modo perlomeno decente, non puoi realizzare applicativi professionali. Paradossalmente, durante i miei primi esperimenti con Unity, il linguaggio C# sembra essere l’ultimo dei problemi. Certo, ci sono una marea di oggetti, metodi e proprietà da imparare a memoria, ma il metodo di lavoro non è molto dissimile da AS3. Questo perché AS3 era un linguaggio di tutto rispetto: C oriented, solido, ben impostato e intuitivo da usare. Come mai ho usato l’imperfetto? Semplice, perché volevo farvi notare come, anche se è ancora (poco) usato, il linguaggio viene considerato dal web già morto. Basta fare un giretto qui per notare il verbo “was”. Dispiace, ma le cose stanno così.

Programmare con C# in Unity

Quando si lancia un nuovo progetto, il programma mette a disposizione due possibili alternative: il visual scripting e C#. Nel primo caso si tratta di usare elementi grafici per manipolare oggetti e comportamenti del gioco senza scrivere codice. Una tecnica molto usata in ambienti come Construct, ma che a dire la verità mi lascia freddino. Premesso che ho massimo rispetto per chi usa questo approccio, non lo reputo il modo migliore per spingere il programma al massimo delle sue possibilità. Inoltre C# (o se preferite C Sharp) oltre a fornirvi un controllo notevole sul progetto, vi consente di imparare qualcosa che può essere utile anche al di fuori dell’ambiente di sviluppo. Oltretutto, quando si scrive il codice, entra in gioco la versione free di Visual Studio. Per cui, niente pannellini stretti, scomodi e poco performanti. Qui si viaggia in prima classe.
Il codice è generalmente associato agli oggetti del gioco. Si seleziona un oggetto, e tramite l’opportuno pannello, si aggiunge una classe di partenza che si scrive direttamente ne celebre ambiente di sviluppo targato Microsoft. 

Un confronto essenziale con AS3: similitudini e differenze

Piccola premessa, quanto segue sono alcune considerazioni al volo sugli aspetti più rilevanti. Ci sarebbe anche altro da dire, ma mi riservo di approfondire C# in qualche articolo futuro. Cominciamo dagli aspetti più ovvi. Tutti i file C# hanno l’estensione file .cs invece di .as. Al loro interno troveremo la definizioni di classe proprio come con AS3. Come è possibile notare osservando il codice di esempio, le classi in C# hanno la stessa convenzione di denominazione di AS3. Abbiamo la parola chiave class a seguire il nome in maiuscolo e il corpo della classe compreso tra parentesi graffa. Ad esempio, ecco un file MiaClasse.cs:

class MiaClasse {
// fai qualcosa
}

Quando siamo in Unity non abbiamo bisogno di indicare un package relativo al percorso e nemmeno il namespace di C#. Questo perché Unity, facendo gioco di squadra con Visual Studio, assembla i nostri listati e gli elementi grafici usati per convertire il tutto in un gioco compatibile con le varie piattaforme. Il tool svolge gran parte del lavoro dietro le quinte, consentendoci di concentrarci solo sugli elementi interattivi del progetto. 
Tuttavia, anche nella versione di C# usata in Unity si importano i pacchetti. Solo che al posto di import c’è la parola chiave using. Per cui la nostra classe diventerebbe una cosa del genere: 

using System;
using System.Collections.Generic;
class MiaClasse {
// commento singolo
/* commento su
più righe
*/
}

Come è possibile osservare attraverso il codice di esempio, i commenti funzionano allo stesso modo. Possono essere costituiti da righe singole o da più righe di testo. I commenti singoli sono preceduti da una doppia barra rovesciata (//) e quelli distribuiti su più righe sfruttano la solita combinazione barra rovesciata e asterisco (/* commento */). 
Analogamente a quanto avveniva con AS3 anche C# è fortemente tipizzato. Per cui se volessimo inizializzare la proprietà Nome, dovremmo scrivere un codice di questo tipo:

// var nome:String="Paperino"; // <-- AS3
string nome="Paperino"; // <-- C#

In pratica non è più necessaria la parola chiave var. Inoltre cambia la collocazione del tipo di dato: in C# l’ordine è invertito senza i due punti. Resta il punto e virgola finale che serve a definire la fine di ogni istruzione. Per quanto riguarda l’ambito di validità valgono gli stessi meccanismi. Se inizializziamo una proprietà in un metodo, questa avrà valore solo in quell’ambito. Se invece creiamo una proprietà all’inizio della classe, avremo la possibilità di poterla richiamare da qualsia parte del codice. 
Ma se scompare la parola chiave var sopravvive const. Anche in C# come in AS3 esistono le costanti. Se per esempio volessimo creare una costante di tipo intero, dovremmo solo stare attenti al tipizzazione. Per il resto si usa comunque come al solito. Per fare un esempio:

const string Nome = "Topolino";

Per quanto riguarda i principali tipi di dato, in alcuni casi abbiamo delle piccole differenze sintattiche.

 Principali tipi di dato
ActionScript 3.0  C Sharp
String string
int int
uint uint
boolean bool
void void

 

Come possiamo osservare, sono quasi identici. Ci sono solo alcune piccole differenze. Il tipo string si si scrive in minuscolo e al posto di boolean, abbiamo bool. Inoltre manca qualcosa di equivalente al tipo Number di AS3. Questo tipo di dato si riferiva genericamente a tutti i tipi di numeri: positivi, negativi e a virgola mobile. Nel caso di C# abbiamo una maggiore specializzazione: diversi tipi di dati che, con livelli di precisione diversa, servono a gestire i numeri a virgola mobile: float, double e decimal.  

 

Operatori numerici
ActionScript 3.0  C Sharp
+ (addizione) + (addizione)
(sottrazione) (sottrazione)
* (prodotto) * (prodotto)
/ (divisione) / (divisione)
++ (incremento) ++ (incremento)
– – (decremento) – – (decremento)
% (resto della divisione) % (resto della divisione)

 

Nel caso degli operatori numerici non abbiamo nessun problema, sono praticamente identici. Analogo discorso per gli operatori di assegnazione e confronto.

Operatori di assegnazione e confronto
ActionScript 3.0  C Sharp
== (uguaglianza) == (uguaglianza)
!= (diseguaglianza) != (diseguaglianza)
= (assegnazione) = (assegnazione)
< (minore di) < (minore di)
> (maggiore di) > (maggore di)
<= (minore o uguale a) <= (minore o uguale a)
>= (maggiore o uguale a) >= (maggiore o uguale a)

 

Gli operatori logici and (&&) or (||) e not (!) funzionano allo stesso modo, cos’ come anche le istruzioni condizionali if else o switch. Bisogna fare un pizzico di attenzione quando si scrivono i cicli for e while. Si basano sullo stesso principio e funzionano allo stesso modo ma non dobbiamo dimenticare di indicare il tipo di dato come faremmo con una proprietà C#. Per cui se in AS3 un ciclo per stampare nel pannello Output tre volte una scritta aveva questa sintassi :

for(var conta:int=0; conta<3; conta++){
trace("Ciao "+conta+", ");
}
// stampa Ciao 0, Ciao 1, Ciao 2,

In C# diventa:

for (int conta = 0; conta < 3; conta++){
Console.WriteLine("Ciao "+conta+", ");
}
// stampa Ciao 0, Ciao 1, Ciao 2,

Osservando l’esempio possiamo notare che anche in C# il concatenamento tra una stringa e un valore numerico rispetta le stesse regole. Per cui (“Ciao “+1) restituisce Ciao 1.
I metodi hanno una sintassi leggermente diversa. Non si utilizza una parola chiave function, il tipo restituito si trova all’inizio anziché alla fine e, secondo la convenzione, bisognerebbe scrivere in maiuscolo il nome. Ecco un metodo con alcuni parametri:

class MiaClasse {
void MioMetodo(int x, int y)  {
     // fai qualcosa  
    }
}

Passiamo alla funzione costruttore. Non ci è permesso attribuirgli alcun tipo di dato (nemmeno void) e anche in questo caso non si può utilizzare la parola chiave function. Vediamo un esempio al volo:

class MiaClasse {
// costruttore
   MiaClasse (){
   // codice
   }
}

 
Infine due parole sugli array. In C# quando si vuole creare un array o una raccolta di oggetti, non crea esplicitamente un oggetto di tipo Array e nemmeno si usa il costruttore new Array() come in AS3. Tutto è molto più semplice. Se vogliamo creare una raccolta ordinata di interi possiamo usare questa sintassi:

int[] mioArray;
mioArray = new int[]{1,2,3};
Console.WriteLine(mioArray[0]); // restituisce 1

Si potrebbe anche optare per la creazione della matrice tramite una tipizzazione semplificata:

int[] mioArray = {1,2,3};

Bisogna ricordare che la lunghezza di una matrice si calcola con la proprietà Length in tutto e per tutto simile al length di AS3, solo che si scrive con la “L” iniziale maiuscola.

int[] mioArray = {1,2,3};
Console.WriteLine(mioArray.Length); // restituisce 3

Sempre a proposito degli array, ci sarebbe da dire molto altro, ma come ho scritto all’inizio dell’articolo, mi sono limitato a condividere sul blog un mio primo sguardo comparativo tra i due linguaggi.
Bisogna anche specificare che un conto è programmare con C# in ambiente .NET, un conto è lavorare in Unity. Le regole sintattiche non cambiano, ma l’approccio progettuale incide in modo rilevante sul nostro codice. Le classi usate da Unity hanno dei pacchetti e dei metodi standard preimpostati. Inoltre esiste un vasto archivio di metodi e proprietà mirati per gestire gli oggetti del gioco. Conto di tornare sull’argomento con qualche esempio concreto.

E con questo articolo chiudo definitivamente il discorso su ActionScript 3.0. I prossimi articoli li dedicherò a Unity e ad altri ambienti di sviluppo che mi sto divertendo a testare. Se siete capitati qui perché anche voi siete degli ex sviluppatori del glorioso Flash/Animate intenzionati a scoprire Unity, vi auguro uno grosso in bocca al lupo. Buona migrazione e mostrate a tutti di cosa è capace la vecchia scuola.

Share:

Leave a reply

*