XNA – Les composants et les services – Partie 1

Partie 1 : Les composants

Bonjour, ceci est mon premier article, j’espère qu’il sera utile à quelqu’un.

Le premier sujet que j’ai choisit d’aborder est « les composants » dans XNA.

XNA nous mets à disposition plusieurs outils nous permettant de bien organiser notre code, et de rendre certains éléments réutilisables d’un projet à l’autre. Le « composant » fait parti de ces outils.

Il existe deux types de composants dans XNA :

  • GameComponent
  • DrawableGameComponent

La classe GameComponent implémente les interfaces IGameComponent et IUpdateable, qui fournissent respectivement les méthodes Initialize et Update. Comme son nom l’indique, la méthode Initialize est appelée lorsque le composant doit être initialisé. La méthode update quant à elle, est appelée à chaque itération de la boucle de jeu, on y met à jour les informations du composant si nécessaire.

La classe DrawableGameComponent, elle, hérite de GameComponent. Elle possède donc également les méthodes Initialize et Update. Mais en plus, elle implémente l’interface IDrawable, qui lui fournit la méthode Draw. Cette méthode est appelé à chaque itération de la boucle de jeu, et sert à gérer l’affichage du composant.

Voici le diagramme de classe pour que ce soit un peu plus parlant :

Classes

Passons maintenant un peu à la pratique.

Dans notre exemple, nous allons créer un composant affichable (DrawableGameComponent), qui permet d’afficher la date et l’heure à l’écran.

Pour cela on crée d’abord notre nouveau projet. J’ai choisit un projet “Windows Game”, mais ça fonctionne pour wp7 et xbox360 aussi. On se retrouve donc avec l’arborescence de base suivante :

Arborescence de départ

Ajoutons une classe DateViewer au projet, avec le squelette suivant :

using Microsoft.Xna.Framework;

namespace ComposantsServices
{
    public class DateViewer : DrawableGameComponent {
        public DateViewer(Game game)
            : base(game)
        {
            // TODO : concevoir les composants enfants ici 
        }

        public override void Initialize()
        {
            // TODO : ajouter le code d’initialisation ici 
            base.Initialize();
        }

        protected override void LoadContent()
        {
            // TODO : Ajouter le code pour le chargement des ressources 
            base.LoadContent();
        }

        public override void Update(GameTime gameTime)
        {
            // TODO : ajouter le code de mise à jour ici 
            base.Update(gameTime);
        }

        public override void Draw(GameTime gameTime)
        {
            // TODO : ajouter le code pour l'affichage ici 
            base.Draw(gameTime);
        }
    }
}

 

Il faut noter ici que le constructeur de notre composant prend en paramètre une référence de la classe Game.

La méthode LoadContent est héritée de la classe DrawableGameComponent. Elle sera utilisée pour charger les différentes ressources graphiques.

Notre composant aura besoin des propriétés suivantes :

// Composant qui gère l'affiche
private SpriteBatch spriteBatch;
// Police de caractère
private SpriteFont spriteFont;
// La date 
private DateTime date;

Initialisation du SpriteBatch

public override void Initialize()
{
    // Création d'un nouveau SpriteBatch (sera amélioré dans la partie 2) 
    this.spriteBatch = new SpriteBatch(this.Game.GraphicsDevice);
    base.Initialize();
}

Pour une meilleure lisibilité et compréhension de l’article, nous créons un nouveau SpriteBatch pour le composant. Nous verrons dans la partie concernant les services comment partager le SpriteBatch entre les composants.

Chargement de la police de caractère :

protected override void LoadContent()
{
    // Chargement de la police de caractère grâce au Content Pipeline 
    this.spriteFont = this.Game.Content.Load<SpriteFont>("DateViewerFont");
    base.LoadContent();
}

Ne pas oublier de créer une SpriteFont nommée DateViewerFont dans le Content Pipeline :

Ajout au content Pipeline

 

Dans la méthode Update on ajoute le méthode qui permet de mettre à jour la date :

public override void Update(GameTime gameTime)
{
    // Mise à jour de la date par la date courant 
    // à chaque itération de la boucle de jeu 
    this.date = DateTime.Now;
    base.Update(gameTime);
}

Dans la méthode Draw, on affiche la date grâce au SpriteBatch :

public override void Draw(GameTime gameTime)
{
    // Initialise le Sprite Batch 
    this.spriteBatch.Begin();

    // Affiche notre date à l'écran 
    this.spriteBatch.DrawString(this.spriteFont,
                                date.ToString("dd/MM/yyyy HH:mm:ss"),
                                new Vector2(0, 0),
                                Color.White);

    // Restaure le périphérique graphique à son état de départ 
    this.spriteBatch.End();

    base.Draw(gameTime);
}

Maintenant que le composant est prêt, il suffit de l’ajouter dans la liste des composants de la classe principale de notre jeu Game1.

protected override void Initialize()
{
    // Créer un SpriteBatch, qui peut être utilisé pour dessiner des textures. 
    spriteBatch = new SpriteBatch(GraphicsDevice);

    // Ajout du composant au jeu 
    this.Components.Add(new DateViewer(this));

    base.Initialize();
}

Normalement, après un petit F5 voici le résultat obtenu (la date doit se mettre à jour automatiquement) :

resultat

Télécharger les sources finales

One comment on “XNA – Les composants et les services – Partie 1

  1. Je vois qu’il n’y a pas encore de commentaire? Je n’ai pas la date sortie de l’article, mais je trouve ça super claire, précis et concis. Je suis la pour la deuxième partie sur les services, mais la première partie m’a plus.

Répondre à Olivier JANIN Annuler la réponse.

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Vous pouvez utiliser ces balises et attributs HTML : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>