XNA

Préambule

Cette partie de l'exposé vous expliquera comment commencer le développement de votre jeu vidéo. Il est nécessaire d'avoir quelques connaissances en C# pour continuer ce tutoriel. Si vous êtes plutôt un développeur Java, sachez qu'il n'est pas difficile de s'adapter à ce langage. Une maitrise de l'IDE de Microsoft est souhaitable.

Comme dit précédemment, il vous faut l'IDE Visual Studio ou Visual C# ainsi que le framework XNA. Voici les différents liens permettant de les télécharger:

• Visual C# : Cliquez ici
• XNA : Cliquez ici

L'installation ne comporte pas de difficultés particulières et ressemble à une installation de logiciel classique sous Windows. Une fois l'installation terminée, il faut aller dans le menu " démarrer ", puis cliquer sur " Microsoft XNA Game Studio 3.1 " et enfin sur " Microsoft Visual C# 2008 Express Edition " (ou équivalent).

Ceci vous permettra de lancer l'IDE en ayant un environnement optimisé pour la création de votre jeu XNA. Créez votre premier projet en cliquant sur " Fichier " puis sur " Nouveau projet ". Vous devriez aboutir à cette fenêtre :

Il vous est donc possible de créer pour différentes plateformes, mais aussi des bibliothèques(libraries) pour les différentes plateformes Microsoft. Il est aussi possible de reprendre un projet fourni par XNA, via " Platformer Starter Kit ". Ce petit jeu vous offre un exemple concret des possibilités offertes par XNA et permet aussi de comprendre l'architecture d'un jeu XNA.

Notez que Windows Phone n'apparait pas sur les modèles de projet proposés. En effet, le développement de jeux XNA sur cette plateforme n'est disponible qu'à partir de la version 4.0 de XNA.

Dans cet exemple, nous allons créer un jeu pour PC. Vous devriez aboutir à l'écran suivant :

Sur la gauche, vous avez les éléments suivants :

• Properties contient les propriétés Système de votre jeu. Il n'est, à priori, pas nécessaire de modifier ces propriétés.
• References contient l'ensemble des bibliothèques qui seront utilisées par votre jeu.
• Content est un répertoire qui contiendra l'ensemble des ressources (textures, musiques, modèle 3D, etc.). C'est donc à cet endroit là qu'il faudra ajouter ces différentes ressources.
• Game.ico représente l'icône de votre jeu.
• Game1.cs représente la classe principale de votre jeu. C'est ici que seront gérées les différentes phases (Initialize, LoadContent etc.) de votre jeu.
• GameThumbNaiil.png contient une simple vignette.
• Program.cs est la classe qui lancera votre jeu. Il n'est pas nécessaire d'y toucher pour concevoir le jeu.

Voici ci-dessous, le contenu de la classe Game1.cs :

using System;
using System.Collections.Generic;
using System.Linq;
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.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace WindowsGame1
{
    /// 

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

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

        /// 

        /// 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.
        /// 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        /// 

        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// 
        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
        }

        /// 

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

        /// 


        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// 
        /// Provides a snapshot of timing values.
        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);
        }

        /// 

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

            // TODO: Add your drawing code here

            base.Draw(gameTime);
        }
    }
}
		
					

Celle-ci contient plusieurs méthodes, attributs et tâches :

• GraphicsDeviceManager graphics : cet attribut se charge de gérer et configurer la carte graphique.
• SpriteBatch spriteBatch : cet attibut contient des méthodes permettant de dessiner à l'écran et d'appliquer quelques effets graphiques.
• Le constructeur Game1() : celui-ci va initialiser le GraphicsDeviceManager et va spécifier le chemin qui contient les ressources de votre jeu (Content.RootDirectory = "Content";). Content permet donc de gérer l'ensemble des ressources de votre jeu.
• Les différentes phases expliquées dans le chapitre précédent. Ces méthodes ont été préremplies et effectuent les tâches suivantes :
  • La méthode Initialize appelle la méthode Initialize de la classe parente
  • La méthode LoadContent va initialiser le spriteBatch en spécifiant le gestionnaire de carte graphique concerné.
  • La méthode update se contente de quitter le jeu si le joueur appuie sur la touche " Back " de la manette XBOX 360. Par conséquent, les lignes suivantes peuvent être effacées :
    if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
    this.Exit();
    Elle appelle aussi la méthode update de la classe parente.
  • La méthode Draw se contente pour l'instant d'effacer le contenu de l'écran et de le " peindre " en bleu via l'appel suivant : GraphicsDevice.Clear(Color.CornflowerBlue); Elle appelle aussi la méthode Draw de la classe parente.

Premiers pas avec XNA

Pour commencer en douceur, nous souhaitons afficher simplement l'image suivante qui se déplacera de gauche à droite :

Dans un premier temps, il faut ajouter cette image à notre projet. Voici les opérations à effectuer :
Clic droit sur " Content " puis cliquer sur " Ajouter " et enfin sur " Ajouter un élément existant ". Un explorateur apparait, permettant de choisir l'élément à ajouter au jeu. Sélectionnez donc le ballon.

Il faut ensuite créer la classe Ballon.cs. Etant donné que ce ballon est un élément affichable à l'écran, elle va hériter de la classe DrawableGameComponent.

Tout d'abord, nous déclarons les attributs suivants :

private Texture2D texture; //texture de l'image
private Vector2 position; //vecteur pour la position de l'image
private int speedX; //vitesse de déplacement de l'image
private SpriteBatch spriteBatch; //spriteBatch de l'image
					

Nous déclarons ensuite le constructeur de notre élément :

public Ballon(Game game, Vector2 positionInitial, int speedX) : base(game)
{
    this.position = positionInitial;
    this.speedX = speedX;
    this.Game.Components.Add(this);
}	
					

Il faut ensuite mettre en place la méthode initialize :

public override void Initialize()
{
    base.Initialize();
    spriteBatch = new SpriteBatch(GraphicsDevice);
}
					

Ensuite, la méthode LoadContent :

protected override void LoadContent()
{
    texture = Game.Content.Load(@"ballon");
    base.LoadContent();
}

public override void Update(GameTime gameTime)
{
    position.X += speedX;
    base.Update(gameTime);
}
					

public override void Draw(GameTime gameTime)
{
    spriteBatch.Begin();
    spriteBatch.Draw(texture, position, Color.White);
    spriteBatch.End();
    base.Draw(gameTime);
}					
					

private double previousTimeMoved = 0;  //mémorisation du time lors du dernier mouvement
private double timeBetweenTwoMoves = 200; //temps qu'il doit s'écouler entre deux déplacements					
					

public override void Update(GameTime gameTime)
{
    double currentTime = gameTime.TotalGameTime.TotalMilliseconds;
    if (this.previousTimeMoved == 0)
    {
        this.previousTimeMoved = currentTime;
    }
    if (this.previousTimeMoved + this.timeBetweenTwoMoves < currentTime)
    {
        position.X += speedX;
        this.previousTimeMoved = currentTime;
    }     
    base.Update(gameTime);
}					
					

interface ControlManager
{
    Boolean isLeft();
    Boolean isRight();
}
					

class ControlManagerImpl : Microsoft.Xna.Framework.GameComponent, ControlManager
{
	public ControlManagerImpl(Game game) : base(game)
    {
        game.Services.AddService(typeof(ControlManager), this);
    }

    private KeyboardState getKeyboardState()
    {
        return Keyboard.GetState();
    }

    bool ControlManager.isLeft()
    {
        return getKeyboardState().IsKeyDown(Keys.Left);
    }

    bool ControlManager.isRight()
    {
        return getKeyboardState().IsKeyDown(Keys.Right);
    }
}
				

public override void Update(GameTime gameTime)
{
    ControlManager cm = (ControlManager)Game.Services.GetService(typeof(ControlManager));
    double currentTime = gameTime.TotalGameTime.TotalMilliseconds;
    if (this.previousTimeMoved == 0)
    {
        this.previousTimeMoved = currentTime;
    }
    if (this.previousTimeMoved + this.timeBetweenTwoMoves < currentTime)
    {
        if (cm.isRight())
        {
            position.X += speedX;
        }
        else if (cm.isLeft())
        {
            position.X -= speedX;
        }
        this.previousTimeMoved = currentTime;
    }
          
    base.Update(gameTime);
}