Premier tutoriel de création de jeu avec Windows Phone

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...).

Le site Progware.com a publié quelques tutos sur XNA, dont notamment:

• Premiers pas de programmation XNA
• Programmation XNA: décentralisation vers les GameComponent
• Développement XNA: Scènes et services
• Détection basique de collision 2D avec XNA
• Détection de collision 2D avec sprites tournés
• Détection de collision basique via la classe SceneSprite

Visiblement ces articles forment une série sur la création d'un moteur avec XNA, et l'auteur devrait publier prochainement d'autres articles concernant la programmation de jeux vidéos avec XNA. Si d'aventure Progware.com venait à publier de nouveaux tutoriaux, comptez sur nous pour vous prévenir.

Mise à jour: Ajout de trois nouveaux tutos concernant la détection de collision de sprites.

JeBuS vient de publier un tutoriel en 3 parties sur la génération d'une grille géodésique générée d'une manière procédurale. A l'origine, l'auteur souhaitait créer un jeu de type "Civilizations" mais dont le plateau, divisé en tuiles hexagonales serait une sphère (après tout, une planète est bien sphérique, et l'utilisation de cartes en deux dimensions pour ce genre de jeu était du souvent à des limitations techniques, levées aujourd'hui par la puissance des machines modernes). Le genre de plateau que l'on souhaite obtenir est donc un plateau similaire au dessin ci-dessous:

Si la technique pour générer ce genre de plateau vous intéresse, vous pouvez consulter les tutoriaux de JeBuS aux urls suivantes:

• Algorithme de grille géodésique, partie 1 - Les bases
• Algorithme de grille géodésique, partie 2 - Un isocahédron
• Algorithme de grille géodésique, partie 3 - Subdivisions

Daniel Saidi vient de poster un nouveau tutoriel sur son blog, qui nous explique comment charger toutes les ressources compilées au format XNB par dossier; en effet, il nous arrive souvent d'avoir besoin de charger de nombreuses ressources, et la gestion de ces chargement peut vite être fastidieuse, surtout lorsqu'on souhaite gérer un chargement asynchrone de ces dernières.

Pour cela, l'auteur a implémenté son code en étendant la classe ContentManager, classe de base qui s'occupe de charger les ressources dans le framework XNA, et implémente la méthode LoadContent<T> afin que celle ci renvoie un Dictionary (table de hashage) composée de clefs représentant le nom du fichier et de valeurs objets représentant la ressource elle même.

David Amador vient de publier sur son site un nouveau tutoriel concernant la gestion des états des écrans de jeu avec XNA. Le code n'est pas bien expliqué, et l'on devra malheureusement se débrouiller avec le source fourni en annexe de son tutoriel...

Offbyone, un membre de l'User Group XNA UK vient de mettre sur son blog un nouveau tutoriel d'utilisation du moteur de son de XNA et de XACT. Contrairement au précédent tutoriel que nous avions repéré sur XACT, celui s'attache plutôt au coté code du moteur de son, et explique l'intégration des banques de sons dans un jeu XNA. Le tutoriel montre peu de code, mais indique comment simplement jouer un son dans un jeu XNA; c'est donc une excellente base pour débuter.

La série de tutos de Roecode de développement d'un moteur 3D avec XNA est assez ancienne mais elle a le mérite toutefois d'être très complète. Composée de 18 tutoriaux, divisés en 7 chapitres Roecode couvre les éléments les plus importants de la conception d'un moteur, d'un ShaderManager en passant par la gestion des contrôles, puis la gestion d'une scène grâce à un SceneGraphManager, pour finir par la gestion du ciel et du terrain.

Trois choses remarquables sont toutefois à mentionner dans cette série de tutoriaux:

• Un des tutos parle de Test Driven Development (TDD) appliqué au développement de jeu vidéo avec XNA. De notre connaissance, Roecode est le seul qui applique la méthodologie TDD au développement XNA.
• Un des tutoriaux explique en détail le fonctionnement du geometry hardware instancing, qui permet d'accélérer le rendu d'objets nombreux (arbres, foules, etc...)
• Un système de plug-ins qui permet d'ajouter et supprimer des nouvelles fonctionnalités via un fichier de configuration XML.

Michael Quandt vient de publier un nouvel article sur son blog ou il propose un moyen unifié de gestion des actions utilisateurs via un système d'actions. Le code source d'exemple est fourni.

Dans le principe, il s'agit de rajouter une couche supplémentaire au dessus des entrées utilisateurs fournies par le framework XNA, et de convertir ces entrées, en fonction de leur état et d'un fichier XML de configuration, en actions communes. Par exemple, si l'utilisateur appuie sur la flèche gauche, une action "Aller à gauche" sera émise, mais cette action pourra aussi être émise si le contrôleur directionnel de la manette est poussé à gauche.

Casey Young, plus connu sous le pseudo d'ElementCy vient de publier le premier article d'une série sur la création d'un jeu de plateformes avec XNA, sur le site du Sergeant Conker. Le premier tutoriel de la série rentre directement dans le vif du sujet, et suppose donc que vous ayez déjà une connaissance minimale de la plateforme XNA.

Cette première partie vise notamment a créer les classes nécessaire au chargement d'un fichier texte contenant les données d'un niveau de jeu, ainsi qu'à son rendu. ElementCy met d'ailleurs à disposition le code source de son projet de jeu, que vous pourrez retrouver en annexe de cette brève.

Pour obtenir un résultat de qualité professionnelle au niveau d'un jeu vidéo, il faut non seulement faire de jolis graphismes, mais aussi être capable de gérer le paramètre gamma de l'écran d'un utilisateur (dont les réglages de contraste et de luminosité sont différents du poste du développeur).

Comme le soulève Matt Pettineo dans son blog, la gestion du gamma dans XNA n'est pas triviale, chose due notamment aux différences entre Xbox et Windows; il existe toutefois une solution pour faire de la correction gamma, mais cette solution n'est malheureusement valable que sous Windows.