http://www.labo-dotnet.com/post/Tutoriel-XNA-e28093-2D-e28093-Introduction-au-XNA-31.aspx

Présentation du Framework XNA 3.1


Le Framework XNA est un ensemble d’outils créé et mis à disposition du grand public gratuitement par Microsoft dans le but de faciliter le développement de jeux-vidéos sur les plates-formes PC et Xbox 360. Techniquement, c’est une surcouche de DirectX. Il est ainsi plus aisé pour l’entreprise ou l’amateur l’utilisant de développer un jeu-vidéo, les nombreuses classes et structures, comme les matrices, les vecteurs, chargement de modèle 3d entre (beaucoup) autres, étant intégrées au Framework. Le travail est alors focalisé sur l’essentiel du jeu et le gain de temps est très appréciable.



Créer son premier projet avec le Framework XNA 3.1


Pour commencer, il faut installer Visual Studio 2008 Express (gratuite) ou alors toute autre version de Visual Studio 2008 pour ceux qui peuvent. Ensuite, il faut télécharger le XNA Game Studio 3.1 à cette adresse : http://www.microsoft.com/downloads/details.aspx?FamilyID=80782277-D584-42D2-8024-893FCD9D3E82&displaylang=en . XNA Game Studio contient toutes les bibliothèques que l’on va avoir besoin pour coder avec XNA, et une multitude d’outils que nous ne servirons pas dans ce tutoriel, sauf le Microsoft Cross-Platform Audio Creation Tool qui nous servira à intégrer du son dans nos jeux. Une fois Game Studio 3.1 installé, ouvrez Visual Studio 2008, cliquez sur le menu File => New => Project.









Une fois cela fait, dans la liste à gauche, sélectionnez XNA Game Studio 3.1, puis dans la partie de droite, cliquez sur Windows Game (3.1).





Choisissez un nom de projet (Chapitre1 par exemple), l’endroit ou vous voulez que votre projet soit enregistré, puis cliquez sur OK.


Présentation du projet de base


Nous voilà donc dans Visual Studio, au centre la zone où nous allons coder. Le fichier ouvert est l’onglet sélectionné juste au dessus. A droite se trouve l’explorateur de solution, qui contient les projets de la solution, et dans chaque projet les fichiers et dossiers correspondant. Par défaut, lorsqu’on ouvre un nouveau projet en XNA, c’est le fichier Game1.cs qui est ouvert. Nous devons nous retrouver avec cette vue :



Si nous sommes attentifs, nous remarquons que notre classe Game1 dérive de la classe Game, et hérite du coup de ses propriétés, comme la collection Components, la collection Services, le GraphicDevice et d’autres propriétés qui sont toutes aussi importantes les unes que les autres.

Si nous allons plus en profondeur dans le fichier, nous retrouvons deux champs, graphics de type GraphicsDeviceManager et spriteBatch de type SpriteBatch. Le premier nous servira à avoir accès à quelques propriétés de l’affichage, telles que la résolution de notre fenêtre (sa taille), activer la synchronisation verticale, l’anti aliasing, le plein écran, etc… tandis que le second nous permettra d’afficher des images ou du texte à l’écran, mais ceci fait l’objet d’un autre chapitre.

Encore un peu plus en profondeur dans le fichier et nous nous retrouvons face à pas moins de 6 ( !) méthodes. La première, Game1(), est en fait le constructeur de la classe Game1(). Nous y instancions notre champs graphics, et initialisons le dossier qui contiendra nos ressources, nous reviendrons dessus un peu plus tard. La deuxième est la méthode Initialize(). C’est ici que l’on récupèrera les services que nous aurons besoin, si nécessaire bien sûr, et qu’on chargera tout contenu qui n’est pas graphique, entendez par là autre que image et modèle 3D. Elle est appelée automatiquement juste après le constructeur. La troisième méthode se nomme LoadContent(). Comme son nom l’indique, c’est ici que vous chargerez le contenu de votre jeu, mais graphique cette fois ci. Elle est appelée elle aussi automatiquement après la méthode Initialize(). La quatrième méthode s’appelle UnloadContent(). Elle sert à décharger le contenu chargé précédemment afin de vider la mémoire et d’éviter ainsi des fuites de mémoire. Elle est appelée automatiquement par le Framework quand on ferme le jeu. La cinquième méthode est la méthode Update(). Pour ceux qui n’ont jamais codé de jeux-vidéos ou qui ne ce sont jamais intéressé au développement de jeux-vidéos, sachez que niveau code, un jeu, mis à part initialisation, chargement et déchargement de contenu, n’est ni plus ni moins qu’une boucle infinie, à laquelle on mettra fin lorsque l’on cliquera sur Quitter, par exemple. Cette boucle infinie se découpe en deux phases : la première phase met à jour l’état du clavier, de la souris ou tout autre périphérique d’entrée, l’état des objets à l’écran, c'est-à-dire la position, la vitesse, etc… teste les collisions, met à jour le son, et tout ce qui a besoin d’être mis à jour. La deuxième phase se charge d’actualiser l’affichage de l’écran. Le schéma ci-dessous montre ce principe :





Revenons à notre méthode Update(). Si vous avez bien compris le principe, vous aurez remarqué que cette méthode Update() correspond à la première phase de notre boucle infinie. C’est donc ici que nous mettrons le code pour la gestion des périphériques, du son, des personnages etc… La sixième et dernière méthode est la méthode Draw(). Comme son nom l’indique, la méthode Draw() sert à dessiner à l’écran, elle constitue la deuxième phase de notre boucle infinie.

Voici un résumé de notre classe Game1 :



/// <summary>

/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;


public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}


/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{

// TODO: Add your initialization logic here
base.Initialize();
}


/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{

// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);

// TODO: use this.Content to load your game content here
}


/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}


/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();


// TODO: Add your update logic here


base.Update(gameTime);
}


/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);


// TODO: Add your drawing code here


base.Draw(gameTime);
}
}



Après une longue explication, et si on lançait le projet pour voir ?








































Maintenant que vous connaissez tout de cette classe de base indispensable pour notre jeu, peut-être aimeriez-vous commencer par coder le prochain Call of Duty ? Bon, vous n’en êtes pas encore là, mais au moins appuyer sur la touche F5 dans Visual Studio (ou menu Debug => Start Debugging) pour voir ce qu’il se passe. Et… une belle fenêtre en 800x600 à fond bleu s’affiche. Ceci constituera notre fenêtre de base pour la suite.



Conclusion


Nous voici à la fin de votre première entrée dans le monde du XNA. Vous commencez à découvrir (un tout petit peu) tout ce que le Framework fait à votre place. En effet, vous n’avez même pas écrit une ligne de code, et une fenêtre s’affiche déjà. Aussi, le Framework a créé à votre place la boucle infinie, et tout ce qu’il faut pour charger du contenu. Tout a été pensé pour simplifier la vie du développeur, et vous n’en avez qu’un tout petit avant-goût.