XNA Connection - Une nouvelle version!

La finition d'un jeu dénote souvent de sa qualité intrinsèque. C'est dans les petits détails que l'on reconnait qu'un jeu a été fignolé, et que ses développeurs sont des perfectionnistes. Par exemple, un jeu dont le menu fourmille de milliers de petites animations attirera bien plus l'œil qu'un jeu dont le menu est une liste classe d'éléments sans aucune vie.

Nous allons donc voir ensemble comment gérer ces animations ensemble, afin de pouvoir donner un peu plus de vie à notre jeu. Mais avant de commencer, il serait bon de prendre connaissances des tutoriaux "Gestion du temps - Chronomètre et décompte avec XNA", "Les horloges", "Rajout de méthodes et d'évènements pour la gestion du temps", car le code utilisé ici se base sur ces derniers. De plus, ce tutoriel abuse de la notion de génériques, dont vous pourrez trouver une introduction sur le site de la MSDN.

La première technique d'animation qui coute peu en développement est l'utilisation d'effets de transitions. Quand vous voyez un effet de fondu, un agrandissement d'un sprite au cours du temps, ce genre d'effets est réalisés grâce à l'interpolation de deux variables en fonction du temps.

Ainsi, un fondu est réalisé en modifiant une valeur d'opacité de 0 à 1 sur une certaine période de temps. Un agrandissement d'un sprite est réalisé en modifiant une valeur indiquant l'agrandissement du sprite suivant le temps passé.

Le système transitions que nous allons voir ici formalise ces effets dans une classe nommée Easing.

Les spécifications de XNA requièrent au minimum une carte graphique qui supporte le Shader Model version 1.1, et la plupart des exemples que vous trouverez sur le net (notamment ceux du creator's club) nécessitent un support du Shader Model version 2.0. Pour la Xbox 360, il n'y a pas de soucis, celle ci est équipée avec une carte graphique supportant le Shader Model version 3.0, et DirectX 10 défini le Shader Model version 4.0.

En théorie, vous ne pouvez pas faire tourner XNA sur des ordinateurs anciens qui n'ont pas la carte graphique nécessaire. Mais que se passe t'il quand vous vous retrouvez avec un vieux portable et une furieuse envie de compléter ce bout de code qui ne fonctionne pas depuis des jours, que vous avez une idée sur comment résoudre le problème, mais aucun moyen de le tester, car la carte graphique n'est pas assez puissante?

La gestion du temps dans un jeu vidéo est une chose que l'on retrouve partout. Que ce soit évident, comme un décompte avant un check-point dans un jeu de voiture, ou plus subtil, comme le temps d'un fondu progressif, la notion temporelle est utilisée intensément, et il en va de même pour un jeu XNA.

Heureusement pour nous, la méthode Update() et son objet GameTime passé en paramètre nous simplifie bien la vie, mais ce n'est pas suffisant pour faire du code propre. Après m'être renseigné sur le canal IRC #xna sur EFNet (qui rassemble une grande partie des développeurs XNA d'outre-manche et d'outre-Atlantique), je me suis rendu compte que la plupart du temps, les utilisateurs géraient le temps via des variables flottantes dans les GameComponent; cette méthode, très simple, a déjà fait ses preuves. Mais l'on peut mieux faire que:

• Mode texte
• Copier

    /// <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)
    {
      time += gameTime.ElapsedGameTime.TotalMilliseconds;
 
      if (time >= 60000)
      {
        DoSomething();
      }

Nous allons voir dans cet article deux petites classes, qui seront extensibles à souhait, pour gérer le temps. Nous commencerons avec la classe TimerBase qui représente une implémentation abstraite de base de gestion du temps, et une classe Countdown, qui représente un décompte temporel, et qui permet d'appeler une méthode à la fin de ce décompte.

S'il y a bien une chose qui manque dans les dizaines d'implémentations de collections du Framework.Net, c'est bien une implémentation de tableau circulaire; cela n'aurait pas été si grave si cette structure n'était pas si souvent utilisée dans la création de jeux-vidéos: en effet, l'on peut utiliser ce genre de structures pour différentes raisons:

• Historique d'états: parfois, il est nécessaire de maintenir l'état de certaines variables sur la durée, comme par exemple, les positions du curseur de la souris, afin de lisser les mouvements de la souris (l'option "smooth moves" disponible dans la configuration de FPS) pour éviter, notamment, les saccades d'un capteur optique parfois un peu sensible
• Historique d'état simplifié: souvent utilisé en conjonction avec les touches claviers, cet historique d'état ne stocke en fait que l'état courant et l'état précédent, mais est néanmoins très utile pour détecter des changement d'états du clavier; il est en effet parfois utile de détecter juste le changement d'état. Par exemple, imaginez un jeu ou l'on pilote un chasseur F-16; vous ne voudriez quand même que à chaque boucle de jeu, le F-16 lance un de ses missiles! Il est donc important de pouvoir capter le moment ou le joueur appuie sur une touche, mais de ne rien faire si la touche reste enfoncée. L'on obtient cet effet si la touche à vérifier est appuyée sur la frame courante, et qu'elle ne l'était pas sur la frame précédente. L'on peut comparer ce genre de choses à l'équivalent d'une détection d'un front montant ou descendant en électronique.
• Les fenêtres de visualisations glissantes: ce sujet est beaucoup plus complexe et fera le sujet d'un autre article beaucoup plus développé.

Avant d'entreprendre ce tutoriel, le lecteur aura pris soin de se familiariser avec la notion de génériques si cette notion ne lui est pas familière. En effet la totalité des exemples cités dans la suite de l'article abusent de cette notion.

Il y a peu de temps, nous avions vu ensemble comment gérer les entrées clavier avec XNA. Pour cela nous avions créer un composant qui était implémenté en tant que Service. Nous allons aujourd'hui utiliser le même paradigme pour contrôler un autre périphérique utilisé sur le PC, à savoir la souris.

Nous utiliserons de nombreux concepts vu lors de la conception du composant clavier, il sera donc bon d'y jeter un coup d'œil pour faire le lien avec ce code.

Cet article est une traduction de l'article anglais de Ska Software "A word about Xbox Live Community Games/Indies Games". Cet article a été publié avec l'aimable autorisation de l'auteur.

Je n'ai pas eu affaire au Xbox Live Community Games depuis un certain temps (cela va bientôt changer; j'ai juste besoin d'une pause sur mon Super Projet XNA 2.0 Secret), mais cela ne m'a pas empêché de lire quelques articles amusants fustigeant le service pour avoir promis amour, gloire et richesse sans fin, pour au final, enlever le pain de la bouche.

Comme les projets de librairie de classe, les projets d'extension du Content Pipeline de XNA ne peuvent être lancés directement. Toutefois, il est possible de les déboguer, après avoir suivi quelques étapes simples décrites ci-dessous.

Note: La boîte de dialogue "Démarrer un programme externe" ("Start external program" en anglais) située sur l'onglet débogage des propriétés de votre projet n'est pas accessible sur les versions Express de Visual Studio. Il est par contre possible de régler cette valeur manuellement avec Visual Studio 2008 Express (voir l'article à ce sujet).