CREARE IL PROPRIO VIDEOGAMES IN C#: DECIMA PARTE sezione seconda

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;


Come già sappiamo, il primo spazio in alto alla nostra pagina è destinata alla dichiarazione dei namespace che vorremo utilizzare. Cosa sono i namespace lo abbiamo già visto nella lezione 3. In questo caso non avremo solo System ma ovviamente anche i namespace di XNA che ci consentiranno di utilizzare le centinaia di classi al loro interno.
Come si può intuire dai nomi, ognuno di essi contiene delle classi che riguardano un aspetto specifico del gioco. Potremo cancellare molti di questi namespace perché per il momento non ci servono.


namespace tutorial_XNA
{...

Questo sarà il nostro namespace quello cioè che identificherà tutti i file .cs (CSharp) del nostro progetto. Ogni classe che creeremo sarà contenuto nel nostro namespace che avrà il nome che abbiamo dato al progetto.


public class Game1 : Microsoft.Xna.Framework.Game
{...

Con questa riga apriamo la nostra classe principale. Come si nota essa è una classe particolare che identifica un tipo di classe che si riferisce a XNA.



GraphicsDeviceManager graphics;

Come da commento, anche GraphicsDeviceManager è una classe di XNA. Vedremo in seguito a cosa serve.
NOTA: Da questa riga incontriamo uno dei concetti che abbiamo solo accennato in precedenza (nella lezione , ovvero, la dichiarazione delle classi .
Vedremo anche che, dopo averla dichiarata con questa riga, andremo anche ad inizializzarla, proprio come se fossero una variabile.



SpriteBatch spriteBatch;

Anche questo elemento è una classe di XNA e ci sarà utile per "stampare a video" tutti gli elementi 2D come immagini, testi, sprites ecc..
Anche lei è stata, in queta riga, dichiarata e andrà inizializzata nel metodo Inizialize().





public Game1()
{...

Questa riga rappresenta il "costruttore" della classe Game1 che sarà necessario per impostare alcune delle nostre variabili nel momento della inizializzazione della classe.
Fin'ora avevamo visto solo la classe "Evviva" che non aveva nessun costruttore e non necessitava di parametri ( valori tra le parentesi ) per funzionare.
Da ora in poi le cose cambieranno un po'. Nulla di troppo complesso, semplicemente, dovremmo fornire alle nostre classi un costruttore, ovvero, un particolare metodo che porta lo stesso nome della classe e permette l'inizializzazione automatica dell'oggetto. D'ora in poi, anche se non avremo la necessità di usarlo, dovremo scrivere un costruttore (dunque un metodo con il nome della classe che lo contiene) in ogni classe che creeremo.
Ma perché questo?
Riprendiamo il discorso accennato nella lezione 8 dove avevamo detto che le classi di XNA avrebbero avuto bisogno di parametri di ingresso, avrebbero avuto bisogno cioè, di variabili che ora provvederemo ad inviargli tra le parentesi, quando inizializzeremo un nuovo oggetto di quella classe.
Se vi ricordate, nell'esempio avevamo scritto:

nuovo_oggetto_evviva = new Evvivia(parametro1,parametro2,...);

Dove inizializzavo per esempio, un nuovo oggetto della classe Evviva.
A quel punto della guida non avevamo bisogno ne di dichiarare e inizializzare un nuovo oggetto della classe Evviva, ne ovviamente, di inviarle parametri.
Ma avevamo fatto questo esempio proprio dicendo che in futuro, quando avremo dovuto usare una delle classi di XNA, avremo dovuto dichiararla e inizializzarla invandole delle variabili.
Questo ha a che fare strettamente con il costruttore di una classe. Perchè sarà proprio all'interno del costruttore che poi verranno "ricevute" le variabili che le abbiamo inviato quando l'abbiamo richiamata e dunque inizializzata.
Ancora una volta, vedremo questo concetto più dettagliatamente in seguito.





graphics = new GraphicsDeviceManager(this);

Ecco la riga che inizializza il nuovo oggetto della classe GraphicsDeviceManager che abbiamo dichiarato poche righe sopra.
Con questa riga imposteremo il nostro GraphicsDeviceManager che è una classe di XNA indispensabile per l'esecuzione di un gioco.
Lo abbiamo chiamato "graphics", ma lo avremmo potuto chiamare in qualunque altro modo, come si farebbe per una semplice variabile. Come notiamo, all'interno delle parentesi c'è scritta la parola " this" che sta ad indicare "questo". Il nostro GraphicsDeviceManager infatti ha bisogno di un parametro essenziale, ovvero ha bisogno di sapere a quale classe "Microsoft.Xna.Framework.Game" si riferisca. La parola this identifica la classe in cui è inserito, ovvero, nel nostro caso, Game1(), infatti, se passiamo il mouse sopra la parola this, vedremo la seguente descrizione:

Ci spiegherà che this identifica la classe Game1 che si trova all'interno del namespace "tutorial_XNA" (o come avete chiamato il vostro progetto).

Dobbiamo vedere meglio cosa significa la parola chiave new .
Sappiamo che in inglese significa "nuovo". Dunque, esaminando la sua posizione possiamo intuire che essa è una parola chiave necessaria per inizializzare un nuovo oggetto di quella classe. Dunque, in questo caso, avremo un nuovo oggetto della classe GraphicsDeviceManager.



Content.RootDirectory = "Content";

Anche con questa riga imposteremo un valore, in questo caso di tipo string (infatti, notiamo che il valore è un testo scritto tra le virgolette e dunque in rosso).
Più precisamente, con questa riga, imposteremo il nome della cartella in cui ci saranno tutti i contenuti del nostro gioco (immagini, modelli, suoni ecc..) . Questa cartella è stata generata automaticamente da Visual Studio nel momento in cui abbiamo aperto il nostro nuovo progetto. All'interno di essa potremmo, in seguito, creare delle sottocartelle per tenere più ordinati e suddivisi tutti gli elementi che useremo. Vi ricordo che per gestire i nostri files non dovremo andarli a creare o modificare direttamente nella cartella dell'hard disk ma useremo la finestra a sinistra del Visual Studio chiamata "esplora soluzioni"che abbiamo descritto brevemente nella lezione 4 e che esamineremo nel dettaglio nel caso di questo progetto.




protected override void Initialize()
{...

Come descritto dal commento, questo metodo verrà eseguito all'avvio del programma e lo utilizzeremo per inizializzare (dunque impostare) le nostre eventuali variabili.
Questo metodo sarà richiamato automaticamente e non sarà necessario (salvo scelte particolari del programmatore) eseguirlo di nuovo.
Nel metodo Initialize() non posso essere costruiti oggetti che contengono grafica (che devono essere inizializzati in LoadContent()).





protected override void LoadContent()
{...

All'interno del metodo LoadContent() ci saranno tutte le chiamate ai files che vorremo caricare.
Come avrete notato però al suo interno è stata inizializzata una variabile:

spriteBatch = new SpriteBatch(GraphicsDevice);

Questo ci fa intuire che all'interno del metodo LoadContent() potremmo, oltre a caricare i contenuti, anche inizializzare le variabili perché anch'esso verrà eseguito, come il metodo Inizialize(), all'inizio del programma e solo una volta. Infatti, se "spostassimo" la riga spriteBatch = new SpriteBatch(GraphicsDevice); nel metodo Inizialize(), il risultato sarebbe identico. E' buona norma però utilizzare il metodo LoadContent() per costruire tutto ciò che riguarda la grafica.
Come per la variabile graphics, anche la variabile spriteBatch identifica una classe di XNA. Questa sarà necessaria per la visualizzazione di tutto ciò che sarà 2D.





protected override void UnloadContent()
{...

Anche questo metodo è stato descritto esaurientemente nel commento. Quando vorremmo liberare la memoria di determinati oggetti, utilizzeremo questo metodo.




protected override void Update(GameTime gameTime)
{...

Questo è un metodo molto importante perché esso verrà eseguito automaticamente ad ogni fotogramma del gioco. Dunque tutto ciò che inseriremo in questo metodo sarà calcolato decine di volte al secondo. Se per esempio volessimo verificare una collisione tra modelli o sprites durante il gioco, l'istruzione if che rileva la collisione dovrà essere scritta all'interno di questo metodo così come, all'interno di questo metodo, dovranno essere chiamati tutti gli altri metodi che vogliamo che vengano eseguiti continuamente durante l'esecuzione del gioco.
Per esempio, se scrivessimo un metodo per muovere un personaggio, potremmo richiamarlo ad ogni fotogramma semplicemente scrivendolo all'interno del metodo Update(); :
protected override void Update(GameTime gameTime)
{

muovi_personaggio();

...

Anche questo metodo ha un parametro essenziale, GameTime, è un'altra delle classi di XNA che vedremo in seguito.


protected override void Draw(GameTime gameTime)
{ ...

Ecco il metodo che ci permetterà di visualizzare il nostro mondo, che sia 3D o 2D.
Anche Draw(); è un metodo che verrà eseguito ad ogni fotogramma ed è molto simile al metodo Update(); .
Qualunque elemento grafico vorremo visualizzare sullo schermo si dovrà trovare all'interno del metodo Draw(); o all'interno di un metodo che sarà richiamato in Draw();.

Siamo giunti alla fine del nostro programma ed ora, lo spero, ne sappiamo un po' più di prima.
Se provate ad eseguire il progetto, vi troverete con una finestra dallo sfondo celeste. Quello che state ammirando, è il vostro primo gioco! Peccato che però non faccia assolutamente nulla.



Una Soluzione in dettaglio

Ma.. i più attenti di voi avranno notato la mancanza di una cosa che ci ha sempre accompagnato nelle precedenti lezioni e che avevamo detto essere indispensabile per ogni applicazione/gioco.
L'ormai famoso metodo Main()! Che fine ha fatto?
C'è ma non si vede...almeno in questo file.cs.
Diamo uno sguardo alla nostra soluzione (cosa sia una soluzione è descritto nella Lezione4).



In questa immagine vediamo sia la finestra principale che la finestra Esplora soluzioni.
Come possiamo notare, oltre al file Game1.cs su cui lavoreremo, XNA ha generato un ulteriore file .cs: Program.cs .
E' propio in quest'ultimo che è posizionato il nostro metodo Main che, come vediamo, non fa altro che richiamare e far "partire" (Run) la classe Game1 .
I programmatori di XNA hanno pensato bene di posizionare il metodo Main in un altro file .cs così da non rendere troppo "confusionario" il file principale su cui lavoreremo. Per conto nostro, il file Program.cs non lo toccheremo mai.
L'aspetto da notare in questo codice è il namespace che è ovviamente lo stesso del file Game1.cs e del nostro progetto.

Vediamo che, oltre ai files .cs, sono presenti altri oggetti che andremo ora a visionare:
Properties :
Se cliccate su Properties troverete un altro file .cs, AssemblyInfo.cs. Su questo file sono presenti tutte le informazioni generali della vostra applicazione, dal nome del creatore al Copyright ed altre informazioni generali.
Riferimenti :
Questo oggetto della soluzione conterrà le librerie esterne che utilizzerà il nostro gioco. In seguito lo useremo per importare le tante librerie che si trovano in rete create dagli altri utenti di XNA.
Content :
Qui troveremo i files e le cartelle utilizzate dal nostro gioco.
Game.ico :
Questa è l'icona che identificherà il gioco una volta creato.
Game.cs :
Il nostro file .cs principale su cui lavoreremo.
GameThumbnail.png :
Anche questa immagine identificherà il nostro gioco.
Program.cs : Abbiamo appena visto che conterrà il nostro metodo Main.
Dunque potremo usare diversi files .cs così da dividere in maniera più ordinata il codice. In presenza di grandi programmi questo ci tornerà molto utile per non confonderci. Potremmo, per esempio, scrivere un file .cs per ogni classe così da orientarci meglio tra gli oggetti del nostro gioco. Basterà solo tenere conto del namespace e non servirà usare codice "include" come accade tipicamente in altri linguaggi.


Mamma mia quanta roba! Siete un po' confusi? Non mi stancherò mai di dire: continuate ad andare avanti, anche se alcuni concetti non sono chiarissimi.
Non c'è guida migliore dell'esperienza. Facendo le prime prove inzierete ad entrare nella mentalità giusta e vedrete che avrete tutto più chiaro.
E vi ricordo che, se non avete capito qualche cosa di questa guida, potete tranquillamante inviarmi una e-mai, cliccando sullo schermetto in alto a destra oppure direttamente a questo indirizzo: XNA_tutorial@wilez.it.