Algorithme de Perlin Noise en C#

Les effets de "parallax side scrolling" (défilement parallaxe en français) son notamment utilisés dans les jeux vidéos (notamment les jeux de plate-forme et les shoot'em up) pour simuler un effet de profondeur tout en évitant l'utilisation d'algorithmes 3D.

Cet effet est obtenu en superposant plusieurs couches (calques) représentant des objets à plus ou moins grande distance, que l'on fait se mouvoir selon une même direction, mais à des vitesses différentes.

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?

Dans la série "je suis pas en avance", je demande un nouveau tutoriel de David Amador. Cette fois ci, le développeur XNA freelance nous explique comment tracer des lignes basiques dans un jeu XNA grâce à sa classe statique LineBatch.

Comme à son habitude, David nous fourni le code source complet de sa classe dans un exemple fonctionnel de tracé de lignes, qui se trouve en fait être une toute petite application de dessin, comme le montre cette vidéo:

Pour dessiner ses lignes, David utilise en fait un objet Texture2D dans lequel il stocke ses lignes. Je n'aurai personnellement pas utilisé cette technique, et je pense que j'aurai largement préférer des VertexBuffer dynamiques contenant la définition des points, ainsi que leur couleur (j'avais déjà utilisée cette technique pour représenter des repères dans un monde 3D, et cela marchait plutôt bien, j'essaierai d'en faire un tutoriel complet un jour...).

Nous avons vu dernièrement comment créer des classes utilitaires pour nous faciliter la tâche de la gestion du temps, en permettant l'utilisateur d'appeler une fonction après n secondes. Toutefois, ce tutoriel n'est pas complet, et il est tout a fait possible de créer d'autres classes qui s'occupent de gérer le temps, basées sur le code écrit la dernière fois. Nous allons donc voir aujourd'hui comment appeler une fonction à intervalles régulier grâce à notre classe Timer.

Ceux d'entre vous connaissant le monde du développement web pourront faire l'analogie entre la classe Countdown et la méthode setTimeout de Javascript (dont il n'existe malheureusement pas d'équivalent en C#) et la classe Timer que nous allons écrire avec la méthode setInterval du même langage.

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.

Victor Porof, à qui l'on doit déjà quelques autres tutoriaux notamment sur la gestion de terrains, vient de publier un nouveau billet sur son blog. Il s'attaque cette fois ci à un effet de post-processing, le motion blur (flou de mouvement). Le motion blur est souvent utilisé pour rajouter une impression de fluidité dans les mouvements. et est notamment utilisé dans certains jeux de voitures (le premier à ma connaissance l'ayant utilisé intensivement est Need For Speed Underground).

Victor explore les différentes manières d'effectuer le flou de mouvement, et se base au final sur la différenciation de la position de la caméra entre deux frames (chose qui peut être réalisée par la classe BufferedState) pour connaitre le vecteur de mouvement à appliquer à un point donné de l'écran.

C'est connu, les développeurs font souvent de mauvais artistes; parfois, ils essaient de se cacher derrière des techniques de rendus procédurales (surtout quand il n'y a pas d'artiste pour les seconder), et avec un peu de chance (et beaucoup de tweaks) le rendu arrive à être correct pour être inséré dans un jeu. C'est le cas de Dave Bollinger, qui a inventé une technique pour générer des sprites de vaisseaux spatiaux et de robots, qu'il nomme tout simplement PixelSpaceShips et PixelRobots. Cette technique a ensuite été récupérée par le site XNAFan.net et implémentée en XNA. Le résultat semble relativement convaincant (surtout si on aime le style old-school).

Nous restons persuadés que quelqu'un trouvera un gameplay assez déjanté à calquer sur cette librairie. Après tout, Arkedo a bien créé un jeu basé sur des gros pixels...

Neil Reed vient de publier un tutoriel sur deux articles sur son blog (l'article originel contenait un bug qu'il a corrigé dans un billet ultérieur): il nous explique comment afficher une barre de vie via un tutoriel assez complet.

Son code se base sur l'utilisation du SpriteBatch avec une utilisation du Color tinting pour effectuer un rendu 2D par dessus l'écran courant, via l'utilisation de RenderTarget2D (ce qui crée quelques soucis de rendus si l'ordre de rendu n'est pas respecté). Nous avons même pu récupérer une petite vidéo de démonstration de son helper: