Appena ho visto il file Template.Cs, messo a disposizione da Paul Aspinall sul sito ufficiale di SDL.NET, ho subito trovato questa risorsa decisamente interessante. Dove molto spesso c’è confusione nell’approccio iniziale, questo file mette subito in chiaro tutti i metodi tendenzialmente usati e permette di avere il vantaggio di uno “scheletro” base già pronto.

Ho detto base perchè, volendo partire senza troppe pretese da questo file di certo non realizzeremo Assassin’s Creed 2. Comunque sia, riporto qui di seguito il codice del file per intero commentato, fornendo anche la disponibilità per il download. Buona lettura!

[code]]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[[/code]

Scarica il file Template.cs

Sapete bene però che un gioco non è solo Output. Un gioco è interazione, un gioco è anche Input. Per cui, adesso inizieremo a guardare le varie alternative che ci vengono proposte per gestire al meglio il modo in cui l’utente interagisce con il nostro gioco. Vi ricordate il sistema degli eventi, che avevo descritto ed introdotto qualche tempo fa? Inizieremo proprio da lì.

Riprendiamo l’esempio dell’Hello World, apportando però qualche modifica al codice:

[code]]czo3OTg6XCINCnVzaW5nIFN5c3RlbTsNCg0KdXNpbmcgU2RsRG90TmV0LkNvcmU7DQp1c2luZyBTZGxEb3ROZXQuR3JhcGhpY3M7DQp7WyYqJl19DQpuYW1lc3BhY2UgU2RsRG90TmV0RXhhbXBsZXMuU21hbGxEZW1vcw0Kew0KICAgIHB1YmxpYyBjbGFzcyBIZWxsb1dvcmxkDQogIHtbJiomXX0gIHsNCiAgICAgICAgW1NUQVRocmVhZF0NCiAgICAgICAgcHVibGljIHN0YXRpYyB2b2lkIE1haW4oKQ0KICAgICAgICB7DQogICAge1smKiZdfSAgICAgICAgSGVsbG9Xb3JsZCBhcHAgPSBuZXcgSGVsbG9Xb3JsZCgpOw0KICAgICAgICAgICAgYXBwLkdvKCk7DQogICAgICAgIH17WyYqJl19DQoNCiAgICAgICAgcHVibGljIEhlbGxvV29ybGQoKQ0KICAgICAgICB7DQogICAgICAgICAgICBWaWRlby5TZXRWaWRlb01vZGUoNHtbJiomXX0wMCwgMzAwKTsNCiAgICAgICAgICAgIFZpZGVvLldpbmRvd0NhcHRpb24gPSBcIkhlbGxvIFdvcmxkIVwiOw0KICAgICAgICB9DQoNCiB7WyYqJl19ICAgICAgIHB1YmxpYyB2b2lkIEdvKCkNCiAgICAgICAgew0KICAgICAgICAgICAgRXZlbnRzLktleWJvYXJkRG93biArPSBuZXcgRXtbJiomXX12ZW50SGFuZGxlcihFdmVudHNfS2V5Ym9hcmREb3duKTsNCiAgICAgICAgICAgIEV2ZW50cy5SdW4oKTsNCiAgICAgICAgfQ0KDQoge1smKiZdfSAgICAgICB2b2lkIEV2ZW50c19LZXlib2FyZERvd24ob2JqZWN0IHNlbmRlciwgU2RsRG90TmV0LklucHV0LktleWJvYXJkRXZlbnR7WyYqJl19QXJncyBlKQ0KICAgICAgICB7DQogICAgICAgICAgICBpZiAoZS5LZXkgPT0gU2RsRG90TmV0LklucHV0LktleS5Fc2NhcGUpIEV2ZXtbJiomXX1udHMuUXVpdEFwcGxpY2F0aW9uKCk7DQogICAgICAgIH0NCiAgICB9DQp9DQpcIjt7WyYqJl19[[/code]

Dunque, cosa abbiamo di diverso? Sicuramente l'istruzione

Events.KeyboardDown += new EventHandler<SdlDotNet.Input.KeyboardEventArgs>(Events_KeyboardDown);

E... cosa vorrebbe dire?

Semplicemente, che abbiamo gestito l'evento che si verificherà alla pressione di un tasto sulla nostra tastiera.
Ehm... cioè?

Spieghiamoci meglio: ogni volta che il nostro giocatore premerà un pulsante sulla tastiera, verrà eseguito il metodo Events_KeyboardDown. Ecco quindi che troviamo il codice del metodo:

void Events_KeyboardDown(object sender, SdlDotNet.Input.KeyboardEventArgs e)

{

if (e.Key == SdlDotNet.Input.Key.Escape) Events.QuitApplication();

}

Come parametri in ingresso passeremo un oggetto sender e un KeyboardEventArgs chiamato “e”. Soprattutto questo sarà importantissimo, come vedremo tra poco. Ed infatti ecco l'istruzione chiave che spiega questo nuovo concetto:

if (e.Key == SdlDotNet.Input.Key.Escape) Events.QuitApplication();

Non è molto difficile da capire: in poche parole qui si dice al nostro caro programma che ogni volta che l'utente premerà il tasto Escape (ESC) il programma dovrà terminare, tramite la chiamata al metodo QuitApplication, già menzionato precedentemente.

Avviando il nostro programma di prova premendo F5, potremo subito verificare i risultati. Premendo Esc, infatti, l'applicazione terminerà facendoci tornare alla schermata del nostro IDE (ho scritto F5 perchè do per scontato l'uso del Visual C# Express, che agevola di molto le cose).

L'oggetto "e" che passiamo, inoltre, offre svariate possibilità grazie alle sue proprietà: la booleana Down, che restituisce true se un tasto è stato premuto. Oppure ancora Unicode ed UnicodeCharacter, che forniscono informazioni sul carattere Unicode rappresentato dal tasto appena premuto. Ciò, quindi, lascia spazio per un buon numero di possibilità e personalizzazioni.

Passiamo ora a dare un occhiata al Mouse: anche in questo caso abbiamo un buon numero di eventi da gestire e metodi pronti da usare per facilitare il nostro lavoro. Un esempio pratico è rappresentato dal codice di seguito.

[code]]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[[/code]
Qui cosa abbiamo fatto? Andiamo con ordine. L'obiettivo di questo programma non è niente di eccezionale: leggendo ogni spostamento del mouse, riportiamo a schermo le sue coordinate. Queste saranno memorizzate in una stringa che verrà utilizzata con un font.

Ecco che dichiariamo la nostra stringa (inizialmente vuota) “posizione” e il nostro font f1(ricordate che il file del carattere da utilizzare dovrà essere ubicato nella stessa cartella dell'eseguibile che compileremo):

Font f1 = new Font("Calibri.ttf", 12);

string posizione = "";

Adesso andiamo a gestire l'evento relativo al movimento del mouse, che si chiama MouseMotion:

public void Go()

{

Events.KeyboardDown += new EventHandler<SdlDotNet.Input.KeyboardEventArgs>(Events_KeyboardDown);

Events.MouseMotion += new EventHandler<SdlDotNet.Input.MouseMotionEventArgs>(Events_MouseMotion);

Events.Tick += new EventHandler<TickEventArgs>(Events_Tick);

Events.Run();

}

Il metodo che lanceremo per gestire la procedura sarà Events_MouseMotion. Il nome è creato automaticamente dal sistema, ma potete crearne uno direttamente voi. L'ho fatto per comodità e per il fatto che viene generato al volo dall'Intellisense del Visual Studio, alla semplice pressione del tasto Tab. Comunque, ecco il nostro codice:

void Events_MouseMotion(object sender, SdlDotNet.Input.MouseMotionEventArgs e)

{

posizione = "Mouse - X: " + e.X.ToString() + ", Y: " + e.Y.ToString();

}

Anche stavolta abbiamo un oggetto sender ed uno “e”, stavolta però di tipo MouseMotionEventArgs. Quindi, cosa fa questo metodo? Semplicemente, ogni volta che il sistema rileva uno spostamento del mouse assegneremo alla stringa “posizione” i valori di X ed Y che il mouse assume in quel momento. Finchè il mouse non verrà mosso, i valori non cambieranno ulteriormente.

Una schermata del programma di Prova.

Occorre anche in questo caso fare una bella scarrellata di proprietà che ci vengono messe a disposizione dall'oggetto “e”. Non le riporto tutte ovviamente, ma solo alcune:

• X ed Y: due proprietà che indicano la posizione sull'asse X ed Y del mouse allo stato attuale del sistema;
• Button: restituisce il nome del pulsante del mouse attualmente premuto usando come valori possibili l'enumerazione Input.MouseButton;
• ButtonPressed: booleana che restituisce True nel caso un pulsante sia stato premuto.

Questi strumenti permettono di gestire al meglio l'input da parte dell'utente, sfruttando le potenzialità del classico metodo “mouse più tastiera” tipico della grande maggioranza di giochi in circolazione negli ultimi anni.

Spero di essere stato chiaro in queste spiegazioni. Vi consiglio assolutamente di fare molte prove e, come già detto precedentemente, sperimentare per bene il sistema ad eventi se non lo si è capito bene. Specialmente adesso, forti di queste nuove piccole nozioni. Con queste basi, molto presto saremo pronti ad affrontare la creazione di un piccolo gioco vero e proprio.

Alla prossima!

Insomma, per poter fare qualcosa di decente abbiamo bisogno di uno strumento versatile che ci consenta di gestire i fonts e l’output testuale senza troppi problemi. In nostro aiuto, per quanto riguarda l’SDL.NET, arriva la classe Font. E sarà proprio nelle prossime righe che cercheremo di analizzare, almeno nelle sue basi, questo utile strumento.

Per prima cosa vediamo come iniziare ad usare un oggetto di questo tipo.

Font f1 = new Font(“font1.ttf”, 14);

f1 è un oggetto di tipo Font. Nel nostro caso, al costruttore passiamo una stringa con il nome del font utilizzato ed un intero che indica la grandezza del testo. Nulla di più semplice ed intuitivo. Dopo questa dichiarazione, in memoria abbiamo già il nostro font pronto ad essere utilizzato.

Adesso però dobbiamo scrivere qualcosa: ecco, qui di seguito, il codice che ci serve.

Surface testo = f1.Render(“testo da scrivere!”, System.Drawing.Color.Black);

Surface testo = f1.Render(“testo da scrivere!”, System.Drawing.Color.Black, System.Drawing.Color.White);

Volendo spiegare in parole povere il funzionamento del meccanismo, pensate alla surface testo come un “foglio”, e all’oggetto f1 come una “stampante”. Nella prima riga di codice che ho riportato stiamo dicendo ad f1 di “stampare” sulla Surface “testo” la stringa “testo da scrivere!”, in colore nero. La surface, successivamente, sarà pronta per essere utilizzata. Il metodo Render ha svariati overload, tra cui l’altro che ho riportato: oltre al testo e il colore, nel metodo passiamo come terzo argomento anche il colore di sfondo da utilizzare.

La personalizzazione del testo, tuttavia, non finisce qui: la classe Font mette a disposizione svariate proprietà di customizzazione e formattazione, per fornire la massima flessibilità. Di seguito qualche esempio.

• Proprietà Bold: permette di decidere se il testo da renderizzare sarà in grassetto oppure no. Di default, questa proprietà è settata su False.
• Proprietà Italic: in questo caso possiamo decidere se il nostro testo sarà in corsivo oppure no. La proprietà è impostata su False di default.
• Proprietà Underline: Impostata su False normalmente, questa proprietà consente di decidere se il testo da renderizzare sarà sottolineato.

Oltre a queste proprietà c’è un’altra che riassume tutte e tre contemporaneamente, che si chiama Style. I valori che può assumere sono compresi nell’enumerazione SdlDotNet.Graphics.Styles. Ecco un esempio pratico qui di seguito.

f1.Style = Styles.Underline;

Insomma, la gestione del testo, almeno a livello base,è veramente molto semplice e facile da capire. Ovviamente, le cose si possono complicare se ci sono necessità riguardanti, per esempio, testi multilinea: a tutto però c’è una soluzione. Ma per adesso rimarremo sul semplice.

Come avete potuto notare dagli esempi (e se non l’avete notato ci penso io ) i colori usati nei testi e negli sfondi sono quelli compresi nella struct System.Drawing.Colors. In questo modo avremo già pronti un sacco di colori.

Ma cosa fare se abbiamo necessità di utilizzare un colore di cui conosciamo perfettamente i valori RGB? Non c’è problema, ecco la sintassi!

f1.Render(“testo da scrivere!”, System.Drawing.Color.FromArgb(0, 0, 0));

La struttura Color infatti presenta il metodo FromArgb, dove rgb sta per Red, Green e Blue. Un attimo.. ma la A? FromArgb presenta anche due overload, ed uno sguardo veloce all’intellisense permette di capire subito di cosa si tratta: parliamo di Alpha, ed il valore che può assumere va da 0 a 255.

Un’altro overload di FromArgb consente invece di fornire come parametro un int a 32 bit nel quale specificare il numero ARGB che rappresenta il nostro colore. Come potete vedere c’è l’imbarazzo della scelta anche in questo caso.

Prima di concludere questa parte, dovete sapere che esiste anche un altro strumento per gestire i testi: parlo di TextSprite, contenuto in SdlDotNet.Graphics.Sprites. Stavolta, però, ci si ferma alla gestione base dei fonts e riprenderemo il discorso successivamente.

Adesso, infatti, lasciamo perdere per un po’ il mondo della vista, per addentrarci in quello dell’udito Nel prossimo articolo parleremo di Audio per i nostri programmi.

“Le Surface in SDL.NET rappresentano, genericamente, delle informazioni grafiche. E’ possibile crearle da zero (e quindi disegnarci ciò che si vuole) oppure caricando dei files dal disco fisso o da un array di bytes. Ogni Surface ha una propria larghezza ed altezza e possiedono delle funzionalità di disegno sulla superficie stessa.”

Le cose non sono ancora chiare? Tranquilli, ecco un bel programma di prova, che verrà prontamente spiegato.

[code]]czoxMDg3OlwiDQp1c2luZyBTeXN0ZW07DQoNCnVzaW5nIFNkbERvdE5ldC5Db3JlOw0KdXNpbmcgU2RsRG90TmV0LkdyYXBoaWNzOw17WyYqJl19Cg0KbmFtZXNwYWNlIERlbW8NCnsNCiAgICBwdWJsaWMgY2xhc3MgR2FtZQ0KICAgIHsNCiAgICAgICAgU3VyZmFjZSBzY2hlcm1hdHtbJiomXX1hID0gVmlkZW8uU2V0VmlkZW9Nb2RlKDgwMCwgNjAwKTsNCiAgICAgICAgU3VyZmFjZSBpbW1hZ2luZSA9IG5ldyBTdXJmYWNlKFwiaXtbJiomXX1tbWFnaW5lLmpwZ1wiKTsNCg0KICAgICAgICBbU1RBVGhyZWFkXQ0KICAgICAgICBwdWJsaWMgc3RhdGljIHZvaWQgTWFpbigpDQogIHtbJiomXX0gICAgICB7DQogICAgICAgICAgICBHYW1lIGFwcCA9IG5ldyBHYW1lKCk7DQogICAgICAgICAgICBhcHAuR28oKTsNCiAgICAgICAge1smKiZdfX0NCg0KICAgICAgICBwdWJsaWMgR2FtZSgpDQogICAgICAgIHsNCiAgICAgICAgICAgIEV2ZW50cy5GcHMgPSA2MDsNCiAgICAgICB7WyYqJl19ICAgICBWaWRlby5XaW5kb3dDYXB0aW9uID0gXCJHZXN0aW9uZSBTdXJmYWNlIC0gU0RMLk5FVFwiOw0KICAgICAgICB9DQoNCiAgICAge1smKiZdfSAgIHB1YmxpYyB2b2lkIEdvKCkNCiAgICAgICAgew0KICAgICAgICAgICAgRXZlbnRzLlF1aXQgKz0gbmV3IEV2ZW50SGFuZGxlcjx7WyYqJl19UXVpdEV2ZW50QXJncz4odGhpcy5RdWl0KTsNCiAgICAgICAgICAgIEV2ZW50cy5UaWNrICs9IG5ldyBFdmVudEhhbmRsZXI8VGlja3tbJiomXX1FdmVudEFyZ3M+KEV2ZW50c19UaWNrKTsNCiAgICAgICAgICAgIEV2ZW50cy5SdW4oKTsNCiAgICAgICAgfQ0KDQogICAgICAgIHZve1smKiZdfWlkIEV2ZW50c19UaWNrKG9iamVjdCBzZW5kZXIsIFRpY2tFdmVudEFyZ3MgZSkNCiAgICAgICAgew0KICAgICAgICAgICAgc2NoZXJ7WyYqJl19bWF0YS5GaWxsKFN5c3RlbS5EcmF3aW5nLkNvbG9yLkJsYWNrKTsNCg0KICAgICAgICAgICAgc2NoZXJtYXRhLkJsaXQoaW1tYWdpbntbJiomXX1lKTsNCg0KICAgICAgICAgICAgc2NoZXJtYXRhLlVwZGF0ZSgpOw0KICAgICAgICB9DQoNCiAgICAgICAgcHJpdmF0ZSB2b2lkIFF1e1smKiZdfWl0KG9iamVjdCBzZW5kZXIsIFF1aXRFdmVudEFyZ3MgZSkNCiAgICAgICAgew0KICAgICAgICAgICAgRXZlbnRzLlF1aXRBcHBsaWN7WyYqJl19YXRpb24oKTsNCiAgICAgICAgfQ0KICAgIH0NCn0NClwiO3tbJiomXX0=[[/code]

Partiamo dalle prime righe:

using System;

using SdlDotNet.Core;

using SdlDotNet.Graphics;

Qua dovremmo esserci: includiamo i namespace che ci servono per i nostri scopi, attraverso la direttiva using.

Surface schermata = Video.SetVideoMode(800, 600);

Ecco la prima delle nostre Surface. Come detto precedentemente, queste possono essere create in vari modi: l'oggetto “schermata” che stiamo dichiarando è speciale: rappresenta infatti la finestra di gioco che noi utilizzeremo.

Il tutto viene reso possibile grazie al metodo SetVideoMode della classe Video, che restituisce appunto una Surface. In questo modo abbiamo deciso che la nostra finestra avrà una dimensione di 800 pixel per 600 pixel.

Ora abbiamo:

Surface immagine = new Surface("immagine.jpg");

Questa surface invece viene creata passando come argomento del metodo costruttore il nome del file da caricare. In questo caso caricheremo il file “immagine.jpg”, situato nella stessa cartella del nostro file exe compilato. Una volta che il nostro oggetto viene creato è pronto per essere mostrato. Continuiamo però con il codice:

public Game()

{

Events.Fps = 60;

Video.WindowCaption = "Gestione Surface - SDL.NET";

}

Qui abbiamo il metodo costruttore della nostra classe Game, che svolge essenzialmente due operazioni: imposta il limite dei frame per secondo a 60 utilizzando la proprietà Fps della classe Events e cambia il titolo alla finestra del programma, stavolta utilizzando WindowCaption di Video. Molto semplice come concetto. Adesso:

public void Go()

{

Events.Quit += new EventHandler<QuitEventArgs>(this.Quit);

Events.Tick += new EventHandler<TickEventArgs>(Events_Tick);

Events.Run();

}

Il metodo Go aggiunge gli Handler per gli eventi che vogliamo gestire: in questo caso ne abbiamo due: Quit, già visto in precedenza, e Tick. Tick permette di gestire ciò che succede ad ogni frame, risultando particolarmente utile nell'aggiornamento dei valori delle variabili in gioco. Stando al limite dato precedentemente, la nostra funzione Events_Tick viene eseguita 60 volte al secondo. Quello che facciamo nel metodo Events_Tick è spiegato nelle righe successive:

void Events_Tick(object sender, TickEventArgs e)

{

schermata.Fill(System.Drawing.Color.Black);

schermata.Blit(immagine);

schermata.Update();

}

Ed ecco l'utilizzo effettivo delle nostre Surface! Come si può vedere, in questo metodo eseguiamo tre operazioni:

1. Tramite la funzione Fill riempiamo tutta la schermata di nero. Può apparire insensato, ma pensate ad un file immagine con delle trasparenze (per esempio un file PNG) che si sposta nel tempo. Senza riempire lo schermo di nero tutte le volte avremmo un effetto fastidioso dovuto alla “non pulizia” della surface, se così la vogliamo chiamare.
2. Tramite il metodo Blit invece disegnamo la nostra immagine. Blit è un metodo che ha ben 8 overload: ciò vuol dire che ci sono ben 9 modalità diverse con cui disegnare sulle surface. Nel nostro caso abbiamo passato solo il nome della Surface da disegnare: questo vuol dire che le coordinate in cui verrà disegnata la nostra Surface saranno (0,0) rispetto alla “schermata”.
3. Il metodo Update si occupa infine di “aggiornare” il nostro frame e fare in modo che tutte le eventuali modifiche del sistema siano mostrate a schermo. Non dimenticatelo alla fine della fase di disegno, è importante!

Ma torniamo al punto 2: perchè queste coordinate sono (0,0)? E' semplice da spiegare: la Surface “schermata” rappresenta la finestra stessa del programma. Di conseguenza, il punto situato più in alto a sinistra avrà delle coordinate pari a 0 sull'asse x ed altrettanto sulla y.

Per disegnare la nostra immagine in una posizione differente, la sintassi sarà la seguente:

schermata.Blit(immagine, new System.Drawing.Point(20, 20));

Stavolta disegneremo la nostra immagine alle coordinate (20,20), e non più (0,0), sui nostri assi cartesiani. A tal proposito devo ricordarvi una cosa molto importante: gli assi cartesiani sullo schermo del pc sono ribaltati sull'asse Y. In poche parole, ecco due immagini per chiarire le idee.

Ciò che abbiamo dopo il metodo Events_Tick è il codice del metodo Quit, che ci consente di uscire dal programma.

Tornando a parlare genericamente, l'oggetto Surface supporta una buona quantità di formati grafici:

• BMP
• PNM
• XPM
• LBM
• PCX
• GIF
• JPEG
• PNG
• TGA

Trasparenza
Ovviamente non è solo questo quello che dobbiamo dire riguardo alle Surface e al loro utilizzo. Un'altra feature molto utile è quella della gestione della trasparenza, che avviene tramite due proprietà:

• TransparentColor
• Transparent

Facciamo un esempio. Abbiamo un'immagine in un file PNG che vogliamo utilizzare come cursore del mouse nel nostro gioco. Caricandola e mostrandola sullo schermo tramite la procedura sopra mostrata, tuttavia, non avremmo il risultato desiderato: oltre a mostrare il cursore, infatti, verrebbe mostrato anche il quadrato in cui è contenuta l'immagine, ovvero tutto il file immagine, per intero. Come facciamo ad evitare questo problema?

Per prima cosa, dobbiamo specificare il colore di trasparenza del nostro file. Ecco un veloce esempio, usando sempre la nostra surface “immagine”:

immagine.TransparentColor = System.Drawing.Color.White;

In questo modo diciamo al sistema che, quando mostrerà a schermo la surface “immagine” dovrà ignorare tutti i pixel di colore bianco. Dopo questo, usiamo anche la proprietà Transparent, semplicemente impostandola su True. Ricordate che questo step è necessario.

immagine.Transparent = true;

Adesso il nostro cursore sarà bello e pronto da mostrare senza problemi . Ovviamente queste istruzioni è bene non metterle nel loop senza condizioni: io per esempio le metto nel metodo costruttore della mia classe. Ecco un esempio completo, per mostrare dove ho posizionato le istruzioni.

public Game()

{

immagine.TransparentColor = System.Drawing.Color.White;

immagine.Transparent = true;

Events.Fps = 60;

Video.WindowCaption = "Gestione Surface - SDL.NET";

}

Alpha Blending

Anche l'Alpha Blending è decisamente semplice da utilizzare. Come per la trasparenza, dovremo scrivere solamente due righe di codice, utilizzando due proprietà:

• Alpha
• AlphaBlending

Alpha è di tipo byte e va da 0 a 255. Impostandolo su 0 avremo la totale trasparenza della surface. A 255 invece la surface sarà totalmente visibile. Dopo aver impostato l'Alpha procediamo quindi ad attivare l'AlphaBlending impostando la proprietà su true, proprio come per la trasparenza. Se non effettuiamo quest'ultimo passo la proprietà Alpha verrà ignorata.

Ecco un esempio:

immagine.Alpha = Convert.ToByte(255);

immagine.Alpha = Convert.ToByte(0);

immagine.AlphaBlending = true;

Come suggerisce anche la Wiki ufficiale, un uso saggio delle surface può essere anche l'uso delle SurfaceCollections, ovvero strutture dinamiche che permettono di gestire altrettanto dinamicamente questo tipo di oggetto. Tuttavia ne parleremo più in la, magari quando riuscirò a scrivere una sorta di sezione “avanzata” di questa guida. Per ora, per quanto riguarda le surface, è tutto!

–

[code]]czo3MTQ6XCINCnVzaW5nIFNkbERvdE5ldC5Db3JlOw0KDQp1c2luZyBTZGxEb3ROZXQuR3JhcGhpY3M7DQoNCm5hbWVzcGFjZSBTZGx7WyYqJl19RG90TmV0RXhhbXBsZXMuU21hbGxEZW1vcw0Kew0KDQogICAgcHVibGljIGNsYXNzIEhlbGxvV29ybGQNCiAgICB7DQogICAgICAgIHtbJiomXX1bU1RBVGhyZWFkXQ0KICAgICAgICBwdWJsaWMgc3RhdGljIHZvaWQgTWFpbigpDQogICAgICAgIHsNCiAgICAgICAgICAgIEhlbGxve1smKiZdfVdvcmxkIGFwcCA9IG5ldyBIZWxsb1dvcmxkKCk7DQogICAgICAgICAgICBhcHAuR28oKTsNCiAgICAgICAgfQ0KDQogICAgICAgIHB7WyYqJl19dWJsaWMgSGVsbG9Xb3JsZCgpDQogICAgICAgIHsNCiAgICAgICAgICAgIFZpZGVvLlNldFZpZGVvTW9kZSg0MDAsIDMwMCk7DQogIHtbJiomXX0gICAgICAgICAgVmlkZW8uV2luZG93Q2FwdGlvbiA9IFwiSGVsbG8gV29ybGQhXCI7DQogICAgICAgIH0NCg0KICAgICAgICBwdWJsaWN7WyYqJl19IHZvaWQgR28oKQ0KICAgICAgICB7DQogICAgICAgICAgICBFdmVudHMuUXVpdCArPSBuZXcgRXZlbnRIYW5kbGVyPFF1aXRFdmVudHtbJiomXX1BcmdzPih0aGlzLlF1aXQpOw0KICAgICAgICAgICAgRXZlbnRzLlJ1bigpOw0KICAgICAgICB9DQoNCiAgICAgICAgcHJpdmF0ZSB2e1smKiZdfW9pZCBRdWl0KG9iamVjdCBzZW5kZXIsIFF1aXRFdmVudEFyZ3MgZSkNCiAgICAgICAgew0KICAgICAgICAgICAgRXZlbnRzLlF1aXR7WyYqJl19QXBwbGljYXRpb24oKTsNCiAgICAgICAgfQ0KICAgIH0NCn0NClwiO3tbJiomXX0=[[/code]

--

Per prima cosa, analizziamo il metodo Go. All'interno di esso, analizziamo il primo comando, ovvero:

Events.Quit += new EventHandler<QuitEventArgs>(this.Quit);

Che cosa abbiamo fatto? Semplice, abbiamo appena gestito un evento del programma. Ma cosa vuol dire tutto questo? Quando noi creiamo un gioco con SDL.NET, esistono degli "Eventi" che vengono eseguiti in determinate condizioni: per esempio il OnKeyboardDown, che viene lanciato tutte le volte che premiamo un pulsante sulla tastiera.

Oppure l'evento Tick, che viene lanciato ad ogni fotogramma. O ancora, l'evento Quit, che abbiamo visto nel nostro codice, che viene eseguito prima di uscire dal programma. In questo modo il lavoro che il software deve fare può essere alleggerito di tanto.

Ecco quindi spiegata la riga di codice: in poche parole noi associamo un metodo da noi creato (il Quit) ad un evento previsto dal sistema (Events.Quit). Nel nostro caso il metodo Quit è un semplice metodo che consente di uscire dall'applicazione attraverso il metodo Events.QuitApplication(). Scritto in questo modo, potrebbe non significare molto.

Ma nel caso, in fase di uscita, si vogliano cancellare delle variabili, allora possiamo mettere nel nostro metodo Quit() ciò che serve. Spero di essere stato chiaro e vi consiglio di fare molte prove per capire bene il funzionamento del sistema.

Sulla Wiki ufficiale del progetto c'è scritto che il sistema degli eventi è molto utile ed intuitivo in fase di gestione dell'input. Senza dubbio vero, ma non è di certo tutto: c'è una grande agevolazione anche nella gestione di musica (per esempio l'evento MusicFinished, che come suggerisce il nome viene lanciato solo quando termina l'esecuzione di un brano musicale), delle finestre (VideoResize, indovinate che fa? ) e di altri aspetti che in seguito analizzeremo meglio.

Tra i comandi scritti nel metodo Go, inoltre, troviamo anche Run. Run è un metodo importantissimo per il gioco, in quanto è proprio esso che avvia il loop principale del programma, il ciclo che verrà eseguito fin quando non decideremo di uscire.

Oltre a Run ecco altri metodi della classe Events:

• CloseAudio, CloseMixer, CloseJoystick e così via, che chiudono i sottosistemi SDL indicati;
• Close, che chiude tutti i sottosistemi dell'SDL.
• QuitApplication, che permette l'uscita dal programma.

Un saggio uso degli eventi, insomma, aiuta tantissimo nello sviluppo della propria applicazione, oltre a garantire una facile lettura del codice e manutenzione. Che altro potrei dire? In realtà ben poco, ho già parlato abbastanza. Andiamo avanti ed iniziamo a vedere come si può caricare un immagine e visualizzarla su schermo.

In questa seconda parte della guida parleremo degli aspetti più importanti della libreria, legati essenzialmente all’input (tastiera, mouse e joypad) ed all’output (grafica, audio, gestione dei fonts TrueType).

Ma non è tutto: prima di iniziare a lavorare con tutti questi aspetti è importantissimo spiegare cosa sono gli Eventi, come funzionano e a cosa servono. Sulla Wiki ufficiale del progetto SDL.NET gli eventi vengono spostati avanti di una lezione rispetto agli elementi grafici: nonostante ciò ho preferito studiare (e quindi riportare su questa guida) prima gli eventi e poi occuparmi di tutti gli altri ambiti. Il motivo è presto spiegato: gli eventi sono il cuore del funzionamento di un programma realizzato con SDL.NET.

Per questo motivo quindi la seconda parte della guida provvederà prima a spiegare gli Eventi, poi la gestione dell’Output, poi dell’Input. Infine prenderemo in considerazione un template da usare per le proprie applicazioni, ovvero una sorta di codice “standard” pronto da usare per una buona quantità di programmi in SDL.NET.

Bene, proseguiamo!

Una libreria, nella sua accezione informatica, è un insieme di funzioni di utilità più o meno comune che sono state appositamente create per l’utilizzo in un programma. L’obiettivo principale di una libreria è risparmiare tempo. Una volta un mio professore disse che l’informatica è l’arte del riciclaggio. Nulla di più vero.

Una libreria serve proprio a questo: evitare di reinventare ogni volta la ruota diminuendo il lavoro del programmatore.

Chiarito questo concetto è necessario che io spieghi quello che voglio fare attraverso questa serie di guide ed articoli: il mio principale obiettivo è capire al meglio il funzionamento di questa libreria, tradurre i vari articoli presenti sul wiki e, così facendo, fornire un valido aiuto a tutti i programmatori italiani interessati a questa nicchia che, per un motivo o per un altro, non masticano bene l’inglese o vogliono vedere comunque un po di materiale nella loro lingua.

Proverò passo passo tutti i passaggi, sintetizzando dove necessario ma anche spiegando linea per linea dove essenziale. Così facendo sarà facile creare un piccolo progetto ed iniziare a buttare giù qualche idea, creando qualcosa di proprio.

Con questo smetto di parlare a vanvera e inizio a fare qualcosa di utile Spero possa esservi d’aiuto!