Les vecteurs - Partie 9 - Combinaison barycentriques

Dans ce tutoriel, nous allons va parler de l'arithmétique des points. Grâce aux vecteurs de placement, nous savons maintenant comment travailler avec des points avec un ordinateur: il suffit simplement de faire des calculs sur les vecteurs de placement, le résultat donnant un nouveau vecteur de placement qui représente votre nouveau point.

On peut se demander pourquoi s'embêter avec l'arithmétique des points: n'est ce pas la même chose que l'arithmétique vectorielle? En fait, il y a une différence: la gestion du point d'origine. Comme nous avons vu dans le tutoriel précédent, le monde réel n'a pas cette notion de point d'origine, mais les données que vous stockez dans une machine, si.

Nous savons déjà comment représenter des vecteurs par des valeurs grâce aux les composantes de ces derniers. Nous allons apprendre maintenant à faire l'arithmétique vectorielle en n'utilisant plus que les valeurs composantes.

Comment allons nous faire cela? Nous avons vu dans les autres tutoriels que chaque vecteur peut être représenté par une combinaison linéaire de vecteurs unitaires. Ceci est notre clef pour traduire toutes les opérations de vecteurs en opérations numériques.

Nous connaissons déjà un moyen d'utiliser les vecteurs sur un plan 2D; dans les chapitres précédents, nous avons appris à les dessiner, et faire des opérations arithmétiques basiques.

Seulement, cette méthodologie ne nous permet pas de représenter les vecteurs d'une manière informatique: il nous reste à les transformer en structures algébriques compréhensibles pour les ordinateurs.

Introduction

Dans cette partie, nous allons apprendre comment effectuer des calculs avec les vecteurs: comment les ajouter, ou les soustraire entre eux, comment les multiplier avec des nombres réels ou d'autres vecteurs, etc...

La plupart du temps, on ne travaille qu'avec des vecteurs libres, car la plupart des applications n'ont pas besoin de connaitre le point de départ du vecteur. Vous pouvez par exemple représenter la vitesse d'une voiture grâce a deux vecteurs liés, mais chaque point de cette voiture aura la même vitesse.

Il n'y a donc pas besoin de représenter les deux vitesses avec deux vecteurs liés différents, car ils stockent la même information (direction, sens et longueur); il est donc possible d'utiliser un vecteur libre qu'on dessine à l'origine.

À partir de maintenant, quand nous parlerons de vecteurs, il s'agira toujours de vecteurs libres, sauf si l'on mentionne le contraire.

La jeune société française Kalezo, dont on avait déjà eu l'occasion de parler ici suite à sa participation au concours Imagine Cup 2010 avec son jeu HexoPlanet remet le couvert avec Plex, son adaptation de Hexo Planet sur Windows Phone 7.

Plex est un jeu de réflexion en 3D unique en son genre, où vous devez correspondre des couleurs pour détruire les blocs qui sont organisés en une sphère.

Plex demeure dans le même registre que Hexo Planet avec le scénario en moins mais une interface et une expérience de jeu revisitée. En effet, avec l’adaptation du jeu sur la nouvelle plateforme mobile de Microsoft, Plex s’inscrit dans les jeux tactiles et cherche à s’y forger une place dans le marché des smartphones.

Comme vous avez pu le constater, une nouvelle version du site vient de paraître aujourd'hui (c'est aussi la principale raison du peu de news ces derniers temps, toute mon énergie était focalisée sur cette nouvelle mouture).

Cette nouvelle version a plusieurs vocations importantes, mais toujours avec une connotation communautaire, comme:

• Plus se centraliser sur la communauté XNA  francophone naissante, en proposant notamment une sélection d'articles via des blogs et sites externes. J'ai fait pour le moment une pré-selection de blogs et sites français qui touchent au monde du développement indie, xna, ou xbox live! arcade. Si vous souhaitez proposer votre site, n'hésitez pas à me contacter (soit via Twitter, ou par mail, ou même via la page contribution), il m'est aisé de vous rajouter dans le flux communautaire.
• Permettre une plus grande interaction avec les utilisateurs via des sondages, mais aussi en leur permettant de participer au site, grâce à la nouvelle page de contribution. Vous avez créé un jeu Xbox live! Indie Games? Faites en de la pub sur XNA Connection! Vous avez écrit un tutoriel que vous aimeriez partager à la communauté XNA? Publiez le chez nous! Vous avez trouvé un lien ou un blog intéressant? Dites le nous!
• Proposer des médias concernant les jeux publiés régulièrement, grâce à la fonctionnalité "Les vidéos de la semaine", ainsi qu'une sélection de jeux parus dernièrement sur le Xbox Live! Indie Games.
• Et des recommandations sur des accessoires et livres concernant la Xbox et le développement sur cette console.
• Des fonctionnalités supplémentaires devraient apparaître bientôt, pour faciliter encore plus l'échange entre les développeurs indépendants et amateurs.

Notez bien que cette nouvelle version ne doit pas être exempte de bugs. Si jamais vous trouvez quelque chose qui semble ne pas fonctionner correctement, ou simplement si vous avez un commentaire sur l'ergonomie de la nouvelle version, n'hésitez pas à laisser un commentaire à la suite du billet!

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.