{dev} Blog - .NET - CSharp

Passage en revue de trois livres sur XNA

Helmut — Sat, 17 Jan 2009 21:01:00 +0100

Le net regorge de ressources pour les développeurs et XNA n'est pas une exception. Par contre, on a tendance à oublier d'autres média, tels que les livres. Je vous propose de passer en revue les quelques livres dont je dispose, certains proposant des informations intéressantes que l'on ne trouve nul part ailleurs. Notons déjà que ces livres ne sont pas destinés à vous apprendre à programmer en C#, donc si vous êtes un total débutant en quête d'XNA, il va d'abord falloir passer sérieusement par la case C#.

Quant à l'article, c'est dans la suite que cela se passe.

Avant de commencer ce petit tour, plusieurs constats sont à faire, histoire de ne pas vous effrayer. Premièrement, si il existe des dizaines de livres sur XNA en anglais, il n'en existe absolument aucun dans la langue de Molière, au grand damne des anglophobes. Ceci est surement du à la popularité plutôt faible d'XNA dans les communautés de développement francophones, aucun auteur/éditeur n'étant assez aventureux pour publier en français.
Autre point : il existe parfois 2 à 3 éditions pour un même livre. Il faut donc prendre garde. Ceci est du à la rapide évolution qu'a eu XNA avant d'arriver à l'aboutissement qu'est la version 3. Certains livres sont donc éditer pour chacune des versions d'XNA, voir parfois des versions intermédiaires comme des beta ou CTP. Si cela ne posera aucun problème pour des livres focalisés sur XNA 2 ou 3, les projets XNA 2 fonctionnant normalement avec XNA 3, ce n'est pas le cas de XNA 1, et encore moins des betas de celui ci. En effet, des changements majeurs ont eu lieux, et certains livrent sont basés sur des pré-versions, afin de pouvoir sortir en même temps que la version finale du framework (c'est un fait courant dans la publication de livres, les éditeurs de logiciels fournissant d'ailleurs souvent ces pré-versions aux auteurs lorsqu'elles ne sont pas publiques).
Dernier point : qui dit livre en anglais, dit importation nécessaire. Les livres techniques en import ont parfois une place dans les grands magasins, mais ce n'est pas le cas pour XNA, la meilleure solution étant de les commander, notamment en ligne. Et pour cela, rien de mieux que amazon.fr qui propose la grande majorité de ces ouvrages (les plus importants en tout cas) et à des prix qui n'ont rien à envier leur équivalent en dollars.
Trêves de commentaires, passons donc à ces livres.

Professional XNA Programming: Building Games for Xbox 360 and Windows with XNA Game Studio 2.0

Par Benjamin Nitschke
ISBN-13: 978-0470261286
Il s'agit de la seconde édition de ce livre. Pas de troisième édition envisagée.

Un petit mot sur l'auteur : Benjamin Nitschke est un développeur d'origine allemande, MVP DirectX/XNA. Il fait parti des fondateurs du studio exDream dans lequel il exerce la fonction de Lead Programmer. exDream est à l'origine de la série de jeux de stratégie Arena Wars, dont le premier a la particularité d'avoir été le premier jeu commercial réalisé en code managé (C# via MDX). Benjamin a également réalisé les starter kit 3D (racing et shooter) du Creator Club.

Le contenu du livre : ce livre se concentre essentiellement sur la 3D, mais consacre quelques chapitres à la 2D et d'autres aspects d'XNA, histoire de couvrir tous les aspects du framework. Il commence donc avec une mise en bouche sur la 2D, et propose de réaliser un Pong et deux casse-briques en 2D, en passant en revu les aspects nécessaires. Avant de passer à la programmation, l'auteur discute de problèmes de conception, tels que d'imaginer un gameplay et de mettre à plat ses idées. Concernant la façon dont la programmation est abordée, elle est faite suivant une méthodologie agile, principalement via des tests unitaires omniprésents dont l'auteur est très friand. Ce livre n'est donc déjà pas adressé aux débutants, mais plutôt aux professionnels et il faut adhéré aux tests unitaires. Tout le code n'est pas expliqué et certaines parties sont présentées comme des challenges à réaliser soi-même, même si le code source du livre est disponible au cas où. Le livre passe ensuite à la 3D et se concentre sur la réalisation d'un moteur 3D réutilisable, et qui sera d'ailleurs réutilisé et enrichi au fil des chapitres, passant par un shoot'them up à un jeu de course (très similaire aux starter kit d'XNA, normal, c'est Benjamin qui les a fait). Une bonne partie du livre est consacrée aux effets (shader), notamment en expliquant le principe de bump mapping et ses différentes techniques, pour ensuite attaquer des effets de post-processing (flou artistique etc). Dans sa seconde édition, le livre est désormais compatible XNA 2 (contre la beta du 1 pour la première édition, donc attention) et présente des chapitres additionnels pour réaliser un jeu de rôle, mais pas d'un point de vue programmation, ce sont plus des chapitres sur le design.

Critique du livre : le livre se veut abordable pour tout développeur, mais il rentre très vite dans des détails où la connaissance des API 3D est parfois requise. De plus, il ne couvre pas tous le code nécessaire, demandant au lecteur de ne pas être passif. Si cela est un plus pour ceux qui veulent apprendre d'eux mêmes sur les bases du livres, c'est un véritable frein aux débutants ou ceux qui ont besoin d'un code commenté pour le comprendre. Ces derniers seront d'autant plus freinés par la légion de tests unitaires que l'auteur emploi, ce qui peut devenir vraiment très lourd pour qui n'adhère pas aux méthodologies agile (la réalisation de jeux ne s'y prêtant pas toujours). Ceci rend l'exploitation du livre par des débutants complètement contre intuitive. Pour le reste du contenu, XNA est couvert dans tous ses aspects (son, réseaux, contrôle, composants, ...) ce qui rend le livre plutôt complet et intéressant à réaliser, notamment pour qui aimerait programmer le jeu de course ou le shoot'em up (ou un moteur réutilisable, tout simplement). Toutefois, les points expliqués précédemment demandent au lecteur d'être véritablement motivé et compétent pour venir à bout de tous ses chapitres.

XNA 2.0 Game Programming Recipes: A Problem-solution Approach

Par Riemer Grootjans
ISBN-13: 978-1590599259
Première édition, la seconde devant arriver fin mars 2009 (ISBN-13: 978-1430218555) et sera conforme à XNA 3.

Un petit mot sur l'auteur : Riemer Grootjans est un thèsard à l'Université de Bruxelles (en Belgique donc) en ingénierie électronique. Il a réalisé beaucoup de tutoriels autour de DirectX, qu'il a ensuite porté sur XNA, ce qui lui a valu le titre de MVP. A ce titre, son site web est une mine d'or avec beaucoup d'articles sur des concepts de base de la 3D (génération de terrains en autre). Son livre reflète beaucoup son passé actif sur Direct 3D.

Le contenu du livre : 100% consacré à la 3D, principalement aux méthodes de base de rendu, le livre ressemble étrangement à un livre Direct 3D. Normal pourra-t-on dire, étant donné l'actif de l'auteur. On se retrouve donc avec un contenu qui n'est pas vraiment focalisé sur XNA en lui même. Pour ce qui est de la 3D, tout comme le site de Riemer, les infos sont très complètes et intéressantes pour qui souhaite réaliser un moteur 3D propre et comprendre toutes les ficelles derrières des rendus efficaces. On passe donc par des rendus de base en 3D, à la génération de terrain (via heightmap et avec interpolation de vertices), en passant par des algorithmes de culling, de calcul de collision entre triangles, etc. Les shader ne sont pas laissés en reste mais se concentrent surtout sur l'éclairage de votre moteur de rendu de terrains fraîchement créé, en y ajoutant lumières et ombres. A la fin du livre, vous vous retrouverez avec un moteur de rendu de terrains complet d'un point de vu technique, mais vous n'aurez pas réalisé un jeu. A vous de voir comment y intégrer des modèles, et surtout le design du jeu. L'auteur fait aussi un petit effort pour couvrir quelques aspects d'XNA, et faisant deux chapitres plutôt maigres sur le son et le réseau.

Critique du livre : Son principal atout en fait peut être aussi sa faiblesse. Il est consacré uniquement au rendu de terrains, et il le fait très bien. De ce point de vu, il est complet et intéressant en présentant des algorithmes efficaces. Mais malheureusement, cela n'en fait pas un livre sur XNA a proprement parlé, mais un livre plus ou moins général sur la 3D. Le livre ne couvre pas vraiment les autres aspects du framework et ce n'est pas la timide tentative des deux derniers chapitres qui y changera quelque chose. On se retrouve donc avec un bon bouquin sur le rendu de terrain, mais aucunement sur le développement de jeu (aucune programmation de design n'étant traitée) et encore moins un vrai livre sur XNA. Ce livre sera donc intéressant pour tout développeur intéressé par la 3D et ses secrets, mais il ne le sera pas pour les débutants ou ceux qui pensaient qu'ils auraient réalisé un jeu à la fermeture du livre.

Building XNA 2.0 Games: A Practical Guide for Independent Game Development

Par James E. Silva
ISBN-13: 978-1430209799
Première édition, seconde en approche pour avril 2009 (ISBN-13: 978-1430218692).

Un petit mot sur l'auteur : James est un ingénieur logiciel diplomé de New York. Dans l'univers du jeu vidéo, c'est un développeur amateur. Sa popularité a explosé lorsqu'il a gagné le concours de développement de jeux Dream Build Play de Microsoft en 2007 avec son jeu The Dishwasher: Dead Samurai qu'il a développé en solo (seul les musiques ont nécessité une intervention externe). Son jeu sortira sous peu sur le Xbox Live Arcade.

Le contenu du livre : ce livre vous propose tout simplement de réaliser le moteur de The Dishwasher. Pas en aussi poli et complet, mais déjà un moteur 2D très moderne, loin des sprites et autres tileset. Avant tout, ce livre se veut "clé en main" pour XNA. C'est à dire qu'il est sensé se suffir à lui même pour apprendre à programmer un jeu avec XNA. Il commence donc par une introduction au langage C#, pour les débutants les plus complets. Attention toutefois, cette introduction est assez light (un seul chapitre ne pouvant être suffisant) et demandera donc des notions de programmation, et surtout de développement orienté objet. Passé cela, le livre propose donc de réaliser un moteur 2D, en passant d'abord par un éditeur de cartes. Cet éditeur pourra gérer plusieurs couches de rendu, des collisions basées sur une grille, mais aussi basées sur des lignes, afin de ne pas être limité à des carrés. Puis les choses deviennent sérieuses, avec la réalisation d'un éditeur de personnages, permettant de créer des animations basées sur un squelette 2D, très intéressant. Le tout sera appuyé par le moteur 2D en lui même. Animation interpolées, nombreux shader pour des effets en tout genre (tout en restant simple), moteur de particules, IA, scripts et réseau ! Tous les aspects d'XNA, en dehors de la 3D, sont couverts et à la clôture du livre, vous avez un jeu 2D très au point techniquement. L'auteur a une approche assez différente des autres livres. XNA étant destiné aux développeurs amateurs souhaitant avant tout se divertir, l'auteur prend le point de vu de l'amateur, reniant donc tout aspect professionnel dans le livre. Exit donc toutes méthodologies, ou approche rigide. A ce titre, la lecture en devient parfois humoristique et relève parfois du "cowboy-coding", tout en restant propre et efficace.

Critique du livre : le livre idéal pour les débutants, mais aussi une lecture très agréable pour les autres, de par le parti prit de l'auteur. Complet par rapport à XNA (3D exceptée), sa lecture se fait avec plaisir et son contenu est très abordable tout en proposant la réalisation d'un moteur 2D pointu aux standards d'aujourd'hui. Ce livre montre bien que l'on peut réaliser des jeux très simples mais très efficaces en tant qu'amateur et sans grande ambition. Une lecture vivement recommandée pour qui est motivé à faire de même, sans prise de tête.

SP1 de VS2008 et de .NET 3.5 en version finale

Helmut — Tue, 12 Aug 2008 17:15:00 +0200

En beta depuis mai dernier, les SP1 pour Visual Studio 2008 et le framework .NET 3.5 sont désormais disponibles en version finale.

Au menu :

Les corrections de bugs habituelles
Un meilleur designer pour les applications WPF
Un support pour SQL Server 2008 (passé en RTM récemment)
De nouveaux outils d'accès aux données (ADO.NET Entity Framework, Data Services et Entity Designer)
Des performances accrues pour les applications WPF et la machine .NET
Ajout du composant Ribbon, pour la réalisation de ruban dans le style d'Office 2007 (compatible C++ via une version MFC)
Le support de Silverligth 2 beta 2

Pour télécharger ces SP1, c'est par ici. A noter que si vous avez installé les versions beta, il vous faudra de préférence nettoyer votre installation via cet outil.

Les infos détaillées sur ces SP1 sont disponibles ici.

Tour d'horizon de C# 3 avec XNA 3

Helmut — Wed, 14 May 2008 15:03:00 +0200

Jusque là, XNA était conçu pour Visual Studio 2005 et ciblait le .NET Framwork 2. Avec l'arrivée de la CTP de XNA 3, le framework passe à Visual Studio 2008 qui, lui, introduit la version 3 du langage C# que vous pourrez utiliser dans vos jeux. L'occasion donc de faire un petit rappel concernant C# 3.
Cette nouvelle version du langage apporte quelques nouveautés pour faciliter l'écriture de votre code.
Nick Gravelyn, l'auteur des connus tutoriels vidéos pour réaliser son Tile Engine, propose un petit tour d'horizon de ces facilités d'écriture, toutes compatibles avec XNA sur 360 et Zune. Au menu donc:

Il ne manque que les lambda expressions pour être exhaustif.

Visual Studio 2008 apporte aussi le .NET 3.5, que vous pourrez donc utiliser pour vos jeux mais si vous ciblez la plateforme Zune ou Xbox 360 (non supportée dans la CTP), n'oubliez pas de vous restreindre à l'usage de classes et méthodes compatibles .NET Compact Framework.
Notons que C# 2 est compatible avec C# 3 (tout comme .NET 2 et 3, et XNA 2 et 3), vous n'aurez donc pas à modifier vos projets pour les recompiler sous VS2008 (contrairement à ce qu'est C# 2 par rapport à C# 1).

Les SP1 pour Visual Studio 2008 et .NET 3.5 sont de sortie en version beta

Helmut — Wed, 14 May 2008 12:07:00 +0200

Microsoft vient de lâcher dans la nature les SP1 pour son IDE Visual Studio 2008 et son Framework .NET 3.5.
Au programme, beaucoup de bug fix et pas mal de nouvelles features, notamment du côté ASP.NET et persistance de données avec l'intégration du Entity Framework pour ADO.NET et LINQ ainsi que le support du futur SQL Server 2008.
Les performances des applications .NET ont également été améliorées, principalement au niveau du temps de démarrage de grosses applications. WPF reçoit aussi son lot d'améliorations avec un meilleur designer et permet désormais d'intégrer complètement DirectX dans vos interfaces.

Scott Guthrie, développeur chez Microsoft, détail les nouveautés de ces SP1 plus en profondeur et répond à vos questions dans les commentaires de son blog.
Brian Harry, quant à lui, liste les améliorations des version Team Foundation de Visual Studio.

Si vous optez pour ces betas, il vous faudra passer au SP1 de Vista (si vous êtes sous Vista) et désinstaller le Toolkit et le SDK de Silverlight 2 car ceux ci ne sont pas supportés, ils seront très prochainement mis à jour.

Vous pouvez télécharger les différentes betas de ces SP1 en suivant les liens suivants:

Les versions finales de ces SP1 arriveront courant de l'été.

Afficher du texte à l'écran avec XNA

Helmut — Wed, 30 Apr 2008 00:49:00 +0200

XNA ne permet pas d'écrire directement du texte sur vos scènes. Il propose tout de même des classes pour faciliter tout ceci. Ce tutoriel vous explique comment cela fonctionne et les différentes façons d'y parvenir.

Bonne lecture.

Ecrire avec XNA : méthode "fichier descripteur"

Ecrire en XNA n'est rien de compliqué. Pour faire vos premiers pas, créez un nouveau projet (ou ouvrez un projet existant, si vous êtes sur de votre coup).
Dans l'explorateur de solutions, au niveau du Content de votre projet, faites un clic droit et ajoutez un nouvel élément. Choisissez le type Sprite Font, renommez le à votre guise et validez. Pour cet exemple, j'ai nommé mon Sprite Font "testFont.spriteFont".
Dès lors, un fichier XML s'ouvre à vous. Il s'agit d'un fichier descripteur de police de caractères (Font).

Explication : pour écrire du texte à l'écran, XNA peut piocher dans les polices de caractères installées sur votre PC (voir votre répertoire Windows/Fonts/). XNA va alors convertir votre police en graphisme compatible avec lui-même et afficher le résultat à l'écran car il ne peut pas utiliser directement une police Windows (TrueType Font ou OpenFont). Tout ceci, XNA le fait sans que vous vous en rendiez compte.

Le fichier XML .spriteFont est là pour indiquer à XNA quelle police vous voulez utilisez, mais aussi la taille qu'elle devra avoir et son style (gras, italique, ...). Voici son contenu et à quoi correspondent les différents champs.

<!--
Le nom de la police que vous souhaitez (Arial, Comics, Time New Roman...)
-->
<FontName>testFont</FontName>

Remarquez que la valeur par défaut est le nom que vous lui avez donné. Dans notre cas, testFont n'est évidement pas une police réelle. Changeons la, en Arial par exemple.

<FontName>Arial</FontName>

Voilà pour ce qui est du champ le plus important. Voyons les autres champs.

<!--
La taille de votre police, comparable à celle dans un éditeur de texte.
-->
<Size>14</Size>
 
<!--
L'espacement entre chaque lettre (en pixel). A laisser à zéro si vous souhaitez l'espacement par défaut de la police.
-->
<Spacing>0</Spacing>
 
<!--
Défini si vous voulez utilier le crénage de la police ou non. Le crénage est la façon dont certains caractères se chevauchent légèrement (comme le W qui peut monter un peu sur le A).
Mettez à true si vous voulez que le crénage de la police soit utilisé. Mettez false dans les autres cas.
-->
<UseKerning>true</UseKerning>
 
<!--
Le style de la police.
Pour un police normale, mettez "Regular".
Pour du gras "Bold", pour de l'italique "Italic"
Attention à respecter les majuscules.
-->
<Style>Regular</Style>

La dernière partie du XML sert à définir quel espace de la table ASCII vous souhaitez couvrir. Par défaut, le fichier est configuré pour supporter les caractères d'indices 32 à 126, c'est à dire les caractères alphabétiques, numériques et les ponctuations, mais aucun accent. Pour supporter tous les caractères, il faut aller jusqu'au caractère d'indice 255 en modifiant l'XML comme suit.

<Start>&#32;</Start>
<End>&#255;</End>

Notre police est fin prête à être utilisée.
Pour utiliser ce nouveau Sprite Font, nous avons besoin de déclarer un objet de type de SpriteFont. Pour l'exemple, on le déclarera en donnée membre, au côté du SpriteBatch et du GraphicsDeviceManager.

GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
SpriteFont font;

Ensuite, pour charger notre police via notre fichier descripteur, on utilise la méthode habituelle du Content Pipeline (dans la méthode LoadContent).

font = Content.Load<SpriteFont>("testFont");

Il ne nous reste plus qu'à écrire avec notre police (dans la méthode Draw). Ecrire avec XNA nécessite un SpriteBatch car notre police sera en interne une texture.

spriteBatch.Begin();
spriteBatch.DrawString(font, // notre SpriteFont
    "Hello world!\nWééé des accents!", // le texte à afficher ( \n représente un saut de ligne)
    new Vector2(100, 100), // la position en pixel où on souhaite afficher le texte
    Color.Black); // la couleur du texte
spriteBatch.End();

Vous pouvez créer autant de fichiers descripteurs que de polices nécessaires.
Il est aussi possible de télécharger des polices de caractères exotiques mais toutes ne sont pas compatibles.

La méthode : "Font Bitmap"

Comme je vous l'ai expliqué, en interne, XNA transforme votre police en texture et en affiche le contenu. La méthode de cette partie consiste à "sauter" l'étape du fichier descripteur en donnant directement à XNA une texture. Une texture de police (ou Font Bitmap) se présente comme ceci.

Règles de construction d'un Font Bitmap :

Les lettres doivent être disposées sur un fond magenta pur (#FF00FF).
Il y doit avoir un espacement entre chaque caractère.
La couleur noire sera considérée comme transparente à l'affichage.
Il doit y avoir 16 caractères par ligne.

Une fois que vous avez votre image (vous pouvez prendre celle du dessus pour tester), vous pouvez l'ajouter à votre projet via le Content Pipeline (clic droit/ ajouter élément existant sur Content). Il y a juste une chose particulière à faire : préciser à XNA qu'il s'agit d'une police et non du texture banale. Pour ce faire, sélectionné votre fichier image dans l'explorateur de solution et regardez ses propriétés. A la ligne Content Processor, il faut mettre Sprite Font Texture.

Ensuite, on charge notre SpriteFont exactement de la même manière sauf que l'on charge notre Asset du Font Bitmap au lieu du fichier descripteur.

font = Content.Load<SpriteFont>("arial");

Et voilà! Le résultat est le même que pour la première méthode vu que l'on a utilisé la police Arial dans les deux cas.

Vous l'avez surement remarqué, il est très long et embêtant de créer soi même une police en Bitmap. Heureusement, les gars derrière XNA ont mis à notre disposition un outil permettant de pondre tout seul un Bitmap tout prêt à partir de n'importe quelle police installée sur son PC. Ce logiciel n'est pas fourni en standard avec XNA mais il est disponible sur le site officiel et à compiler soi même. Je vais épargner cette peine, je l'ai compilé pour vous (7zip nécessaire pour décompresser).

Quels sont les avantages de cette méthode?

Pouvoir utiliser n'importe quelle police.
Créer sa propre police, ou table de symboles (si vous avez besoin d'icone dans vos textes par exemple).
Mettre des effets sur une police en modifiant la texture (mettre du relief, des dégradés, etc).
Ne pas s'encombrer avec des TTF ou autres lorsque l'on redistribue son code source.

Vous savez désormais tout ce qu'il y a à savoir à propos de l'affichage de texte avec XNA.

Votre premier jeu avec XNA 2.0: Pong!

Helmut — Fri, 25 Apr 2008 18:20:00 +0200

Voici le premier tutoriel que je vous propose: faire votre propre Pong. C'est probablement le jeu le plus simple à programmer et cela a l'avantage de servir de bonne introduction au XNA.
Je vous propose donc un petit tour d'horizon du XNA, et plus particulièrement des bases du système de rendu 2D, car ce Pong sera en 2D. Vous aurez aussi un topo sur le Content Pipeline et nous finirons avec l'ajout de sons à votre Pong en passant par un petit projet XACT.
Ce tutoriel se veut volontairement simpliste et perfectible, mais vous aurez des bases pour la suite. L'important est de vous familiariser avec XNA.
De bonnes bases en C# sont recommandées, je ne vais pas vous apprendre le C#. Si vous souhaitez apprendre à programmer en C#, je ne peux que vous orienter vers cette liste de liens et de livres.

Sommaire

Introduction

Si vous avez suivi mon introduction au XNA et installé les logiciels nécessaires, alors vous êtes prêt à démarrer.
Dans mes tutoriels, j'utiliserai Visual Studio 2005 Professional mais si vous avez une version C# Express, que ce soit le 2005 ou le 2008, les menus sont strictement identiques, vous ne devriez pas vous perdre.

Allons-y, démarrer XNA Game Studio 2.0 (en tant qu'administrateur, si vous êtes sous Vista), et créez un nouveau projet via Fichier / Nouveau / Projet. Dans les types de projets, vous aurez un dépliant Visual C# qui contient une section XNA Game Studio 2.0. Là, choisissez un projet de type Windows Game (2.0) et dans le champ Nom, mettez le nom de votre projet. Celui-ci n'a pas trop d'importance et peut être changé, mettez-y "MonPong" par exemple.
Vous pouvez également spécifier un emplacement d'enregistrement autre que celui par défaut.

Notre jeu va dont être destiné à la plate-forme Windows, bien qu'il devrait tourner sans problème sur Xbox 360. Pour faire un jeu sur Xbox 360, il faut faire un nouveau projet de type Xbox 360 Game (2.0), mais cela n'est pas vraiment nécessaire. Entre un jeu Windows et Xbox 360, le code est le même. Pourquoi deux types de projets différents alors? Simplement que dans l'un, Visual Studio exécutera votre code sur votre machine, et dans l'autre, Visual Studio cherchera à l'exécuter sur votre Xbox 360. En dehors de cette particularité, si vous avez codé votre jeu correctement, tout le reste est identique.
XNA propose une option pour convertir à la volée votre projet d'une plate-forme à l'autre via le menu Projet / Create a Copy for Xbox 360 et inversement.
En général, on ne test sur 360 que lorsque l'on a un prototype stable, si possible à chaques grandes étapes du développement. Ensuite on débug sur console avant de débuter la prochaine étape sur PC.
Lorsque l'on développe pour Windows, on peut utiliser toutes les librairies contenues dans .NET mais pour Xbox 360, on doit se limiter aux classes et méthodes compatibles avec le .NET Compact Framework car la 360 embarque une version compact de la machine .NET 2. Pour savoir qu'elles classes sont "Compact Compliant", visitez la librairie MSDN du .NET 2. N'hésitez pas à en user et abuser, elle est très complète et peut vous épargner des heures de recherches ou de reflexion. Beaucoup trop de développeur débutant la néglige.
Dans l'aide, vous pourrez immédiatement identifier une classes ou méthodes compatibles avec l'icone .
Autre astuce, dans votre Visual, à tout moment, si vous vous demandez comment fonctionne une classe qui est dans votre code, mettez le curseur sur son type (ou sur le nom d'une variable) et appuyez sur F1. L'aide MSDN sera automatiquement chargée à la page de classe concernée. Encore une fois, trop peu de personnes ont le réflexe d'appuyer sur F1.
F1 est une touche magique, peu importe ce que vous avez sélectionné dans Visual, notamment dans l'explorateur de propriété, la bonne aide apparaitra.

C'est parti

Dans votre nouveau projet, ouvrez le fichier Game1.cs, si il ne l'est pas par défaut.
Vous voici devant la classe principale de votre jeu. Elle dérive de la classe Game qui se charge de tout le boulot concernant la boucle principale de votre jeu.
Pour ceux qui se sont déjà aventuré dans la programmation d'un jeu, vous n'aurez donc pas à faire de boucle principale. La classe Game vous propose de factoriser votre code en séparant la logique du graphisme.

Voyons les méthodes que contient votre projet vide:

Initialize : ceux qui ont fait un peu du C# ne devrait pas être dépaysé. C'est dans cette méthode que l'on fait nos initialisation de base, si nécessaire. Elle est appelée toute seule après la création de l'instance du jeu.
LoadContent : cette méthode nous propose de charger nos contenus (graphismes, sons ou autres) ici. Elle est idéale pour de petits projets, mais pour des plus gros, on ne fera pas souvent attention à celle-ci et on aura notre propre gestionnaire de contenus. Elle est appelée toute seule au chargement de votre jeu.
UnloadContent : l'inverse de LoadContent. Elle est destinée à la dé-allocation des ressources. Cette méthode ne sert que si l'on créé plusieurs instances de la classe Game pour un même jeu, ce qui n'arrive quasiment pas. Bien souvent on n'utilisera pas du tout cette méthode et on aura aussi notre propre système de dé-allocation.
Update : cette méthode est appelée en boucle et est faite pour que vous gérez la logique de votre jeu à l'intérieur (interactions, déplacements, événements, gestion du pad,...). Par défaut, Update contient un code qui permet de quitter l'application en appuyant sur le bouton Back du pad 360.
Draw : également appelée en boucle, juste après Update, cette méthode est prévue pour que vous y fassiez votre travail graphique (2D/3D).

Par défaut, vous avez aussi deux membres d'initialisés:

graphics : instance d'un GraphicsDeviceManager. Si vous regardez, il est initialisé dans le constructeur. C'est cet objet qui permet de configurer le contexte graphique (résolution d'écran, etc). Il permet aussi d'avoir des infos sur la configuration actuelle et votre matériel.
spriteBatch : instance de SpriteBatch. Un outil qui vous permet de faire de la 2D en deux temps trois mouvements. Vous verrez que comparé à d'autres API 2D, le gros du travail est pré-mâché. Cet objet est facultatif, mais vous en aurez besoin dans ce tutoriel.

Importer vos images : introduction au Content Pipeline

Commencez par télécharger ce pack d'images faites maison (vous aurez besoin de 7zip pour les décompresser).
Décompressez l'archive n'importe où.

Pour ajouter du contenu à vos projets, regardez votre Explorateur de solutions. Dedans, vous verrez une ligne Content, c'est ici que viendra se glisser tout votre contenu. Ajoutons nos textures. Pour cela, je vous propose de vous organiser et de créer un dossier spécial. Faites un clic droit sur Content, Ajouter / Nouveau dossier (ou Add / New folder, si votre Visual est en anglais). Nommé se dossier à votre guise, je le nommerai "textures" pour ce tutoriel. On peut maintenant ajouter nos images. Cliquez sur votre nouveau dossier textures, puis faites clic droit Ajouter / Element existant et allez chercher les images décompressées précédemment. Une fois les trois images importer, celles-ci sont disponibles pour jeu. Vous pouvez, si vous le souhaitez, effacer le dossier où vous les avez décompressé, il ne sert plus à rien et vos images ont été copiées dans votre projet.

Tout les fichiers que vous ajoutez au dossier Content passerons automatiquement par le Content Pipeline.

Voici le résultat escompté dans votre explorateur de solutions.

Regardons vos textures de plus près. Sélectionnez une des textures, peut importe laquelle, et observez ce qui se trouve dans l'Explorateur de propriétés. Le moment est venu d'en apprendre un peu plus sur le Content Pipeline.
Le Content Pipeline est un système qui est propre au XNA. Avec d'autres API ou Framework graphique, pour importer du contenu, textures, modèles 3D ou autres, vous auriez du programmer votre importateur, notamment pour les modèles. Le Content Pipeline fait tout ça pour vous, et bien plus. Il va également compiler vos fichiers dans un format spécial (.xnb) qui sera apte à être lu sur Xbox 360 et qui réduit les temps de chargement. Il fait également automatiquement le lien entre les modèles, leurs textures et leurs shaders. Vous n'aurez donc pas à coder tout un lot d'importateur et de visualisateur.
Revers de la médaille, le Content Pipeline a un nombre de formats supportés réduit.

Formats de textures : .bmp, .dds, .dib, .hdr, .jpg, .pfm, .png, .ppm, et .tga, rien de bien particulier. Le XNA gère automatiquement les formats, que ce soit du 8 ou 32bit, avec ou sans canal alpha.
Fichiers sonores : uniquement des fichiers .xap, qui sont des projets XACT. XACT est seule et unique manière d'importer des sons avec XNA, ne verrons cela plus tard.
Modèles 3D : .x et .fbx, qui sont respectivement les formats de DirectX et d'AutoCAD.
Shaders : des shaders compilés, .fx, qui sont les formats de shaders de DirectX.
XML : tout document XML peut être importé.

Il y a donc largement de quoi faire avec ces formats. Seul le format .x de modèles pour s'avérer contraignant, puisqu'il ne gère pas les animations et n'enregistre pas les tangentes (vous n'avez pas besoin de savoir ce dont il s'agit, juste que c'est embêtant :p).
Heureusement, XNA permet de programmer nos propres importateurs.

Revenons à nos moutons et à notre Explorateur de propriétés.

Vous pouvez donc voir que XNA a automatiquement importé nos images avec l'importateur de textures. Déroulez la section Content Processor et tout en bas, vous pouvez voir la propriété Texture format. Il s'agit de la compression qui sera utilisée par votre carte graphique pour stocker cette texture dans sa mémoire. Lorsque cette propriété est à "No change", la texture sera dépourvu de toute compression, ce qui sera à peu près équivalent à la taille d'un bmp et ce peu importe que le fichier d'origine soit un jpg ou png ou autre plus petit. Heureusement, les cartes graphiques proposent des compressions matérielles, comme le DXT que vous pouvez choisir dans cette propriété. Le DXT garanti un taux de compression constant de 75% au détriment d'une très légère perte de qualité, qui ne se vera de toute façon pas si vous utilisez des images déjà compressées. En général, on vous recommande d'utiliser une compression DXT si vos textures sont destinées à des modèles 3D mais on ne vous le recommande pas si vous voulez afficher des sprites ou autres éléments 2D, afin de garantir leur finesse. Libre à vous donc de mettre DXT ou non pour ce tutoriel. J'emploierai le DXT pour mes trois textures, pour la simple raison que les images d'origines n'ont déjà pas une super qualité, autant économiser la mémoire de la carte graphique.
Toujours dans l'explorateur de propriétés d'une de vos textures, voyez la propriété Asset name. C'est le nom interne de votre texture. Vous devrez utiliser ce nom pour faire appel à celle-ci dans votre code. XNA donne un nom par défaut à vos contenus suivant leur nom de fichier, tronqué de leur extension. Si deux fichiers ont le même nom, XNA rajoute un chiffre à la suite. Vous pouvez changer ces noms à votre guise, mais pour garder un minimum de clarté, je vous recommande de les laisser tels quels.

Votre contenu est pret!
Une dernière précision autour du Content Pipeline. Sur une plate-forme Windows, vous n'êtes pas du tout obligé d'utiliser celui-ci, vous pouvez parfaitement charger vos fichiers "à l'ancienne", via les classes de .NET le permettant ou en écrivant vos propres importateurs qui font directement appel à votre arborescence de fichiers.
Sur 360, il est tout simplement interdit de charger un fichier sans passer par le Content Pipeline (auquel cas votre jeu plantera minablement). Donc de façon générale, si vous avez l'intention de faire un jeu cross-plateforme, n'utilisez que le Content Pipeline.

Affichons notre premier sprite

A ce stade, si vous lancer votre jeu (la petite flèche verte, ou plus simplement la touche F5), vous serez devant un fond bleu. Pour quitter, vous devrez cliquer la croix de la fenêtre, ou appuyer sur le bouton Back de votre pad 360, pour le peu que vous en possédiez un et qu'il soit branché.
Histoire d'être un peu plus productif, nous allons ajouter à ce comportement de pouvoir fermer notre jeu avec la touche Echap de votre clavier.
Pour ce faire, rendez-vous dans la méthode Update, vous y verrez le code qui vérifie l'appui du bouton Back. Modifions le comme suit.

// on récupère l'état du clavier
KeyboardState keyboard = Keyboard.GetState();
 
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || keyboard.IsKeyDown(Keys.Escape))
    this.Exit();

Pour pouvoir gérer le clavier, on créé une instance de la classe KeyboardSate qui représente un état du clavier (quelles touches sont enfoncées etc). Puis on fait appel à la méthode static GetState de la classe Keyboard pour récupérer l'état actuel du clavier. Ensuite, la méthode IsKeyDown renvoi true si la touche passé en paramètre est enfoncée.

Chargeons maintenant nos textures. Déclarons tout d'abord nos textures, en dehors de toutes méthodes, juste après le SpriteBatch par exemple.

GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
// pour nos textures
Texture2D fond, barres, balle;
Rectangle barreBleue = new Rectangle(0, 0, 32, 128),
    barreRouge = new Rectangle(32, 0, 32, 128);

Nous avons donc trois Texture2D. Vous remarquerez que dans le fichier bars.png, j'ai mis deux barres dans une seule texture. Il va donc falloir les dissocier. Pour cela, nous déclarons deux Rectangle qui serviront à délimiter notre texture. Nous avons une texture qui fait 64x128 pixels et chaque barre à une taille de 32x128 pixels, chaque Rectangle couvre donc une barre.
Il y a une chose importante à savoir concernant les API graphique. Dans votre tête, lorsque vous vous représenté un repère graphique, l'origine de ce repère est probablement en bas à gauche, comme en maths, or, dans les API graphique, dont XNA, l'origine du repère est en haut à gauche et l'axe Y est inversé (positif vers le bas donc), comme ci-dessous.

Nous allons maintenant charger nos textures. Dans la méthode LoadContent, ajoutez-y le code suivant.

fond = Content.Load<Texture2D>("Textures/fond_herbe");
barres = Content.Load<Texture2D>("Textures/bars");
balle = Content.Load<Texture2D>("Textures/balle");

Ceci est la méthode pour charger du contenu provenant du Content Pipeline. Pour charger un contenu, il faut utiliser la méthode statci Load de la classe Content. Cette méthode est une méthode générique qui doit prendre le type que vous cherchez à charger, Texture2D dans notre cas. La méthode prend ensuite en paramètre le chemin vers le contenu à charger. Attention, pour les noms de contenus, il s'agit de leur "Asset Name" et non des vrais nom de fichiers.
Vos textures sont maintenant prêtes à être affiché.

Petit détail concernant les textures qui vous utiliserez dans vos projets. Faites en sorte que les dimensions de vos textures soient toujours des puissances de 2 (2, 4, 8, 16, 32, 64,...). Ceci pour la simple raison que les cartes graphiques sont optimisées pour fonctionner avec des puissances de 2. Pire que cela, si vous n'utilisez pas de puissances de 2, les performances de vos jeux seront totalement exécrables suivant les cartes graphiques. Ceci n'est valable que pour les textures. Si vous avez plusieurs sprites dans une seule texture, ils peuvent avoir n'importe quelle taille, pourvu que la texture qui les contient ai les bonnes dimensions.

Trêve de commentaires, affichons le fond de notre pong. Pour cela, dans la méthode Draw, ajoutons ceci (avant base.Draw, qui doit être appelé en dernier, tout comme base.Update dans Update).

spriteBatch.Begin(); // indique que nous commençons à dessiner
// on dessine notre fond
spriteBatch.Draw(fond, // la texture à utiliser
    new Rectangle(0, 0, screenWidth, screenHeight), // le rectangle qui va dire sur quelle partie de l'écran afficher notre texture
    Color.White); // la composante de notre texture, à laisser à blanc pour avoir les couleurs originales
spriteBatch.End(); // on a fini de dessiner, on dit à la carte graphique d'afficher le résultat

On utilise donc le SpriteBatch qui a été créé par défaut avec notre projet. SpriteBatch est une classe outil qui permet d'afficher des groupes de sprites avec les mêmes paramètres très rapidement.
Les initiés aux API 3D remarqueront surement la présence des Begin et End. Pour la petite histoire, SpriteBatch ne fait pas de la "vrai 2D". Il s'agit en fait de véritable 3D, mais plaquée contre l'écran. C'est strictement pareil que si l'on avait aplati la matrice de projection dans un API 3D, c'est d'ailleurs la méthode que l'on utilise pour faire de la 2D avec un API 3D. La méthode Draw n'affiche donc pas des sprites approprement parlé, mais des quads texturés. Car en XNA, tout n'est que 3D, via une sur couche à DirectX. Fin de l'aparté.
Pour dessiner notre fond, il faut donc lui dire sur quelle partie de l'écran l'afficher. En l'occurrence, sur tout l'écran. On spécifie donc un Rectangle qui part de l'origine et qui va jusqu'au bout des dimensions de l'écran.
Pour récupérer les dimensions de l'écran, on utilise l'instance de la classe GraphicsDeviceManager. Dans mon cas, j'ai stocké ces valeurs dans les variables screenWidth et screenHeight (respectivement la largeur et la hauteur). Ces deux variables sont des int que j'ai déclaré en tant que membres après mes Texture2D.
Pour récuperer ces valeurs, j'ai ajouté ce bout de code dans la méthode Initialise.

screenWidth = graphics.GraphicsDevice.Viewport.Width;
screenHeight = graphics.GraphicsDevice.Viewport.Height;

Maintenant, il ne vous reste plus qu'à appuyer sur F5 pour admirer le résultat.
Félicitations, vous avez affiché votre première texture.

Afficher les barres et la balle

Tout d'abord, il va nous falloir des variables pour gérer la position des barres et de la balle. Déclarons les en tant que données membres.

int barreBleuePosition, // la position de la barre bleue sur l'axe Y
    barreRougePosition, // idem pour la rouge
    bleueX, // position sur X de la barre bleue, qui sera fixe
    rougeX; // idem
Vector2 ballePosition; // la position sur X et Y de la balle, via un vecteur

Dans Pong, les barres ne bougent que sur un seul axe, Y. Inutile donc de se préoccuper de l'axe X pour les barres, mais nous avons tout de même besoin de variables pour stocker leur position sur X, histoire d'avoir un code qui s'adapte à n'importe qu'elle résolution d'écran. Pour la balle, on utilise un Vector2, qui est un vecteur possédant 2 composantes, X et Y, idéale donc pour des positions 2D, d'autant plus que l'on peut faire facilement des opérations sur des Vector2 (addition, multiplication, etc par des composantes).

Afin que notre jeu s'adapte à toutes les résolutions, nous avons encore besoins de deux variables, le rapport sur la longueur et le rapport sur la hauteur. Imaginez que votre jeu est élaboré pour une résolution native de 1024x768. Que va-t-il se passer si on essai la résolution 1280x720? L'image sera généralement tronqué et la logique de votre jeu complètement chamboulée.
Pour remédier à cela, on se débrouille dès le début pour notre code soit indépendant de la résolution. Dans notre cas, nous prenons donc une résolution de base, disons 1024x768, dont nous nous servirons pour calculer un rapport de grossissement ou de rétrécissement suivant la résolution réellement appliquée.
Déclarons donc ceci à la suite.

float rapportWidth, rapportHeight;

Et initalisons ce beau monde dans la méthode Initialise.

rapportWidth = screenWidth / 1024.0f;
rapportHeight = screenHeight / (screenHeight / (float)screenWidth * 1024.0f);

Vous remarquerez que le rapport de hauteur est calculé par rapport au ratio de l'écran. Ce, afin que notre jeu s'adapte tout seul au 16/9 ou au 4/3 ou tout autre ratio.

Nous pouvons maintenant initialiser la position de nos objets, toujours à la suite dans la méthode Initialise.

barreBleuePosition = (int)((screenHeight / 2) - (barreBleue.Height / 2) * rapportHeight);
barreRougePosition = barreBleuePosition;
 
bleueX = (int)((screenWidth * 0.05) - (barreBleue.Width / 2) * rapportWidth);
rougeX = (int)((screenWidth * 0.95) - (barreRouge.Width / 2) * rapportWidth);
 
ballePosition.X = (screenWidth / 2) - (32 / 2) * rapportWidth;
ballePosition.Y = (screenHeight / 2) - (32 / 2) * rapportHeight;

Pour la position initiale des barres, on les affiches au milieu de l'écran. Il faut juste prendre soin de les décaler de la moitié de la hauteur du sprite, sinon il ne seront pas complètement au milieu.
Pour la position de chaque barre sur X, on position la première à 5% du bord gauche de l'écran, et la seconde à 5% du bord droit (donc 95% du gauche). On suit la même réflexion par rapport à la largeur du sprite pour qu'elles soient centrées.
Enfin, on dispose la balle en plein centre de l'écran, toujours par rapport à sa largeur/hauteur.
Notez que l'on prend scrupuleusement en compte les rapports de la hauteur et largeur de la résolution. Ceci aura pour effet de grossir ou rétrécir les sprites pour les adapter à la résolution.

On est maintenant prêt à afficher tout ceci.
Direction la méthode Draw, à la suite de l'affichage du fond.

// on commence à dessiner, cette fois avec des modes spéciaux
spriteBatch.Begin(SpriteBlendMode.AlphaBlend, // on gère la transparence
    SpriteSortMode.BackToFront, // on dessine de l'arrière vers l'avant de l'écran
    SaveStateMode.None); // mettre à none, ceci ne servira pas dans notre exemple
 
// on dessine la barre bleue
spriteBatch.Draw(barres, // la texture à utiliser
    new Rectangle(bleueX, // la position sur X de la barre, fixe
        barreBleuePosition, // la position du Y
        (int)(barreBleue.Width * rapportWidth), // sa largeur, en tenant compte du rapport de la résolution
        (int)(barreBleue.Height * rapportHeight)), // idem pour sa hauteur
    barreBleue, // le Rectangle qui délimite la barre bleue dans la texture des barres
    Color.White); // la composante, par défaut
 
// même reflexion pour la barre rouge
spriteBatch.Draw(barres, new Rectangle(rougeX, barreRougePosition, (int)(barreRouge.Width * rapportWidth), (int)(barreRouge.Height * rapportHeight)), barreRouge, Color.White);
 
// ainsi que pour la balle, à la différence que l'on utilise son Vector2
spriteBatch.Draw(balle, new Rectangle((int)ballePosition.X, (int)ballePosition.Y, (int)(balle.Width * rapportWidth), (int)(balle.Height * rapportHeight)), new Rectangle(0, 0, balle.Width, balle.Height), Color.White);
 
// on a fini, la carte graphique peut tout dessiner
spriteBatch.End();

Les barres et la balles sont donc dessinés à leur position initiale, et avec les bonnes proportions.
Vous remarquerez que l'on a dessiné les trois sprites en même temps entre les Begin et End. Lorsque l'on fait cela, tout ce qui est dessiner est soumis aux mêmes propriétés définies dans le Begin. En l'occurrence, gestion de la transparence etc.
Autre point très important à noter, on aurait pu encadrer chaque dessin par Begin et End, mais cela est beaucoup plus lourd pour la carte graphique. En effet, il vaut mieux dire à la carte graphique de tout dessiner d'un coup que de dessiner morceaux après morceaux.
On aurait aussi pu dessiner le fond en même temps que les sprites, mais suivant les cas, il n'est pas certifié que le fond soit dessiner en dessous ou au dessus des sprites. Il est donc préférable de forcer le fond à être dessiner en premier, pour de dessiner les sprites par au dessus.
Règles générales, regroupez au maximum les dessins entre des Begin et End, et dessinez toujours en premier ce qui est le plus au fond de votre scène. Ce que vous dessinez écrase toujours ce qui est derrière.

F5 et apprécions le résultat.

Gérer les commandes et bouger les barres

La méthode Update est appelée à chaque image rendue. Suivant la complexité de votre jeu, il se peut que votre jeu tourne à 30 images par seconde (fps), comme à 60, 200 ou 10. Ces fps ne sont pas forcément fixes et peuvent varier au cours du jeu. La méthode Update n'est donc peut être pas appelée à intervalles réguliers.
Imaginons que votre jeu tourne à 60fps et que vous avez choisi que le déplacement de votre barre se fasse à hauteur de 100 pixels par seconde. On imagine alors que Update est appelée toutes les 16,66 millisecondes (1000/60) et donc, dans la méthode Update, vous ferez un déplacement de 1,66 pixels pour vos 100 par seconde.
Or, si maintenant, pour une raison quelconque, votre jeu se met à ralentir à 40fps, voir à accélérer à 100fps, il y aura donc plus ou moins d'appel à Update et votre déplacement se vera complètement ralenti ou accéléré.
Pour palier à ce problème, il y a deux solutions:

Forcer votre jeu à tourner à 60fps au maximum.
Faire vos calculs de déplacement en fonction du temps écoulé entre deux appels à Update.

Ici, libre à vous de préférer une solution ou une autre. Par défaut, XNA bloque les fps à 60. Mais cela n'empêche pas à votre jeu de ralentir si les fps tombent en dessous de 60.
Personnellement, je préfère utiliser la deuxième méthode. Elle est peut être un peu plus fastidieuse à mettre en place, mais le comportement de votre jeu est assuré de tourner au même rythme peu importe les performances de la machine sur laquelle il tournera, Xbox 360 incluse.
Le top du top, c'est de combiner les deux mondes, avoir des fps fixes, pour mieux prévoir le comportement de son jeu, et calculer les déplacements en fonction du temps, pour ne pas ralentir en cas de chute d'fps.
Dans ce tutoriel, on fera tout en fonction du temps.

Etape numéro 1 : calculer le temps écoulé entre deux appels à Update.
Rien de plus simple, XNA met à notre disposition cette valeur via la variable gameTime, que l'on récupère ici en secondes (dans la méthodes Update).

float tempsEcoule = (float)gameTime.ElapsedRealTime.TotalMilliseconds / 1000.0f;

Maintenant que l'on a notre temps, il nous faut calculer le déplacement associé, tout de suite après.

int deplacement = (int)((screenHeight / 2) * tempsEcoule);

Ici, on souhaite que notre déplacement se fasse à la hauteur de "la moitié de l'écran" par seconde. Ainsi, le feeling de notre jeu sera le même peu importe un ratio de 4/3 ou 16/9 (ou autre).

Nous avons désormais tous les éléments pour appliquer notre mouvement. A la suite, nous gérons les commandes.

// joueur un
// si on appui sur la touche D du clavier, ou si on pouce le stick gauche vers le bas
if (keyboard.IsKeyDown(Keys.D) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < -0.5f)
    barreBleuePosition += deplacement; // on déplace la barre vers le bas
// sinon si on appui sur E, ou stick gauche en haut
else if (keyboard.IsKeyDown(Keys.E) || GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0.5f)
    barreBleuePosition -= deplacement; // on monte la barre
 
// meme reflexion pour le joueur deux, mais avec les touches Haut et Bas du clavier
if (keyboard.IsKeyDown(Keys.Down) || GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.Y < -0.5f)
    barreRougePosition += deplacement;
else if (keyboard.IsKeyDown(Keys.Up) || GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.Y > 0.5f)
    barreRougePosition -= deplacement;

Rien de bien compliqué donc. Chose amusante, si vous le souhaitez, vous pouvez faire jouer les deux joueurs sur le même gamepad, un sur le stick gauche, l'autre sur le droit. C'est également utile si vous n'avez pas deux gamepad.

Sous Windows, si vous souhaitez prendre en charge un gamepad autre que celui de la 360 ou tout autre matériel, il vous faut utiliser DirectInput et là, ça devient tout de suite beaucoup plus compliqué, mais possible. Par contre, si vous faites cela, oubliez tout de suite le support de la Xbox 360.
Pour avoir une compatibilité avec la 360, il faut se restreindre aux pad 360 (guitare et big button supportés) et au clavier (que l'on peut brancher en USB sur 360).

F5 et go!
Ho drame, vous remarquerez que les barres peuvent traverser l'écran. Remédions à cela, à la suite de votre précédent code.

// si la barre bleue dépasse le haut de l'écran, on la bloque à 0
if (barreBleuePosition < 0)
    barreBleuePosition = 0;
// si elle déplace le base de l'écran (en prenant en compte sa hauteur), on la bloc (toujours en prenant en compte sa hauteur)
else if (barreBleuePosition > screenHeight - (int)(barreBleue.Height * rapportHeight))
    barreBleuePosition = screenHeight - (int)(barreBleue.Height * rapportHeight);
 
// même reflexion pour la barre rouge
if (barreRougePosition < 0)
    barreRougePosition = 0;
else if (barreRougePosition > screenHeight - (int)(barreRouge.Height * rapportHeight))
    barreRougePosition = screenHeight - (int)(barreRouge.Height * rapportHeight);

Voilà, nos barres ont le comportement recherché et nous en avons fini avec cette partie.

Faisons avancer cette balle

Pour commencer, nous ne souhaitons pas que la balle commence à bouger dès que le jeu est démarré. Il faut pouvoir commander son départ afin que les joueurs puissent être prêts. Pour démarre la partie, nous allons donc programmer le "top départ" sur la barre d'espace du clavier ou la touche Start du gamepad 360.
Lors d'un départ, la balle doit aller dans une direction aléatoire et à une certaine vitesse. Nous avons donc besoin d'une variable qui représente cette direction et cette vitesse. Un Vector2 est parfait pour ce job, déclarons le en tant que donnée membre (parmi vos Texture2D et autres).

Vector2 balleVitesse = Vector2.Zero;

On lui donne une vitesse initiale nulle via la propriété static de Vector2 prévu à cet effet.
Nous allons maintenant programmer le lancement de la partie. Ce bout de code va être réutilisé pour lancer une nouvelle balle à chaque point marqué. Donc pour cela, nous avons d'abord besoin de booléens qui nous indique l'état de la partie (à la suite du Vector2 d'avant).

bool started = false, // est-ce que la partie a commencé?
    newGame = false; // est-ce que je dois relancer la balle?

Gérons le lancement de la balle, à la suite dans votre méthode Update.

if ( (!started && // si la partie n'a pas commencé
    (keyboard.IsKeyDown(Keys.Space) || GamePad.GetState(PlayerIndex.One).Buttons.Start== ButtonState.Pressed) || // et que "espace" ou "start" est appuyé
    newGame) // ou si on a besoin d'une nouvelle balle
{
    // on commence par placer la balle au milieu de l'écran
    ballePosition.X = (screenWidth / 2) - (32 / 2) * rapportWidth;
    ballePosition.Y = (screenHeight / 2) - (32 / 2) * rapportHeight;
 
    started = true; // on indique que la partie a commencé
    newGame = false; // que l'on a plus besoin de nouvelle balle
 
    // on prend un nombre au hasard, entre 0 et 3
    Random rand = new Random();
    int n = rand.Next(4);
    // on initialise la vitesse de la balle à 200 pixels par seconde (par rapport à la résolution toujours)
    int vitesseX = (int)(200 * rapportWidth);
    int vitesseY = (int)(200 * rapportHeight);
    // suivant le nombre tiré au hasard, on lance la balle dans une direction ou une autre (4 possibles donc)
    switch (n)
    {
        case 0: balleVitesse = new Vector2(vitesseX, vitesseY); break;
        case 1: balleVitesse = new Vector2(vitesseX, -vitesseY); break;
        case 2: balleVitesse = new Vector2(-vitesseX, vitesseY); break;
        case 3: balleVitesse = new Vector2(-vitesseX, -vitesseY); break;
    }
}

Nous avons la direction et la vitesse de la balle, mais la balle n'avance pas encore. Il faut appliquer ce vecteur de déplacement à la position actuelle de la balle. Juste après ce code, on a ceci.

// on déplace la balle, toujours suivant le temps écoulé
ballePosition += balleVitesse * tempsEcoule;

Un petit F5, et on appui sur espace ou Start. La balle avance, mais poursuit son chemin indifféremment.

Gestion des collisions

La balle doit rebondir contre les bords de l'écran et contre les barres. Commençons par gérer les bords de l'écran. Toujours à la suite du précédent code.

// si la balle dépasse le bord supérieur, on inverse la composante Y de sa vitesse (on la fait rebondir)
if (ballePosition.Y < 0)
    balleVitesse.Y = -balleVitesse.Y;
// si la balle dépasse le bord inférieur (en tenant compte de sa hauteur), on fait rebondir la balle
else if (ballePosition.Y > screenHeight - (int)(balle.Height * rapportHeight))
    balleVitesse.Y = -balleVitesse.Y;

La balle rebondi maintenant sur les bords mais traverse les barres. Pour gérer les collisions entres deux volumes (et donc des rectangles), XNA propose des classes toutes faites pour gérer cela, comme la classe BoundingBox que nous allons utiliser. Les BoundingBox sont des boîtes qui vont englober les objets dont vous voulez gérer les collisions. Ces boîtes sont normalement faites pour des collisions 3D, mais en faisans abstraction de la composante sur l'axe Z, on peut parfaitement gérer des collisions 2D. On défini une BoundingBox par deux points, le supérieur gauche avant et l'inférieur droit arrière. Voici un schéma pour illustrer les BoundingBox en 3D et 2D.

Voyons cela de plus près, encore une fois dans Update.

// boite pour la balle
BoundingBox balleBox = new BoundingBox(
    new Vector3(ballePosition.X, ballePosition.Y, 0), // on défini le premier point, avec la composante Z à 0 puisque l'on fait de la 2D
    new Vector3(ballePosition.X + balle.Width * rapportWidth, ballePosition.Y + balle.Height * rapportHeight, 0)); // le deuxième point, attention, contrairement aux Rectangle, une BoundingBox ne demande pas la largeur et la hauteur de la boite, mais les coordonnées du point, il ne faut donc pas oublier d'ajouter les origines du premier point
 
// même raisonnement pour les barres
BoundingBox barreBleueBox = new BoundingBox(
    new Vector3(bleueX, barreBleuePosition, 0),
    new Vector3(bleueX + barreBleue.Width * rapportWidth, barreBleuePosition + barreBleue.Height * rapportHeight, 0));
BoundingBox barreRougeBox = new BoundingBox(
    new Vector3(rougeX, barreRougePosition, 0),
    new Vector3(rougeX + barreRouge.Width * rapportWidth, barreRougePosition + barreRouge.Height * rapportHeight, 0));
 
// puis on utilise la méthode Intersects, qui prend en paramètre une autre BoundingBox et qui renvoi true si il y a collision
if (balleBox.Intersects(barreBleueBox) || balleBox.Intersects(barreRougeBox))
{
    // si la balle touche une des deux barres, on inverse son mouvement
    balleVitesse.X = -balleVitesse.X;
    // et on augmente sa vitesse pour pimenter le gameplay
    balleVitesse += balleVitesse * 0.05f;
}

Le gros du travail est donc de construire les boîtes. Notez que si la balle rebondi sur une barre, on augmente sa vitesse de 5%, ceci afin de rendre le gameplay plus amusant. La vitesse des barres étant fixe, il arrivera un moment où la vitesse de la balle sera trop rapide et ce sera alors le joueur qui anticipera le mieux les mouvements de la balle qui gagnera.
Notre gestion des collisions est loin d'être parfaite (tout comme la physique de la balle), mais ce tutoriel est là uniquement pour vous donner quelques notions de bases. On ne cherchera pas à aller plus loin dans cet exemple.

Un petit F5 et votre Pong est jouable. Mais il reste à gérer le score.

Buts et score

Dans cette partie, nous allons coder les scores et le marquage de points. Ceci sera très simple car nous n'allons pas afficher le score directement dans notre jeu mais dans le titre de la fenêtre. Pourquoi? Parce que XNA ne permet pas directement d'écrire du texte à l'écran et histoire d'alléger un peu ce tutoriel. Je vous montrerai dans un autre tutoriel comment afficher du texte.
Allons-y pour le score. D'abord, déclarons des données membres.

int scoreBleu = 0,
    scoreRouge = 0;

Ensuite, dans notre méthode Update, rajoutons la détection de la balle qui a dépassé les barres, et donc un but.

// si la balle dépasse à gauche
if (ballePosition.X < 0)
{
    // le joueur rouge marque
    scoreRouge++;
    // et on relance la balle
    newGame = true;
}
else if (ballePosition.X > screenWidth)
{
    // idem si la balle dépasse à droite
    scoreRouge++;
    newGame = true;
}

Il ne reste plus qu'à afficher le score. Direction la méthode Draw (rien ne vous empêche de le faire dans la méthode Update, mais histoire de bien dissocier la logique du graphisme, on le fera dans Draw).

Window.Title = "Pong : " + scoreBleu.ToString() + " - " + scoreRouge.ToString();

Et voilà, le comportement de votre Pong est terminé, ou presque.
Ajoutons-y une dernière touche.

Du son avec XACT

Pour ajouter du son à votre projet, on ne peut malheureusement pas ajouter des wav ou mp3 au Content Pipeline. XNA ne prend que des projets XACT au format .xap. Pourquoi cela? Parce que cela permet des sons compatibles avec toutes les plateformes car chacune a son propre format de son. La Xbox 360 ne supporte qu'un format spéciale à elle (XMA), sous Windows XP le son passera par DirectSound et sous Vista il passera par sa couche sonore spéciale. Pour palier à toutes ces différences, Microsoft a créé XACT qui est un outil également utilisé par les professionnels.
Tout comme les autres fichiers, sous Windows, vous n'êtes pas obliger de passer par XACT et le Content Pipeline. Vous pouvez très bien utiliser directement DirectSound, mais c'est autrement plus compliqué et vous casserez encore une fois la compatibilité de votre jeu avec la 360.
Enfin, sachez que XACT ne supporte que les fichiers WAV non compressés.

Allons-y avec les sons. Téléchargez ce petit pack de sons.

Pour lancer XACT, direction le menu démarrer, et dans le repertoire de XNA Game Studio, vous en trouverez un autre nommé Tools qui contient XACT. Il faut lancer Microsoft Cross-Platform Audio Creation Tool (XACT). Une fois lancé, faites Files/New Project et enregistrez ce projet où vous le souhaitez en le nommant "Pong" (sans les guillemets).

Concernant le son, ce tutoriel sera plus une marche à suivre qu'une réelle explication. XACT étant un outil de création à part entière, il est préférable de lui consacrer un article à lui seul.

Dans l'arborescence à droite, cliquez sur Wave Banks, puis clic droit New Wave Bank. Double cliquez sur la Wave Bank fraichement créée. Une fenêtre s'est ouverte. Dedans, glissez y vos fichiers wav ou faites clic droit Insert Wave File(s) et ajoutez vos fichiers.

Sélectionnez les deux entrées de votre Wave Bank et glissez les à droite sur Sound Banks. Ouvrez la nouvelle Sound Bank, sélectionnez les deux entrées et glissez les dans le tableau du dessous ("Cue").
Voici ce à quoi votre projet XACT devrait ressembler.

Petite explication :

Wave Banks : vos banques de fichiers originaux tout simplement.
Sound Banks : ici, vous pouvez définir des sons qui peuvent être composés de fragment de fichiers et aussi leur appliquer des effets, ou optimiser leur volume.
Sound Cues : servent à jouer vos sons. Ce sont en gros des déclencheur. Vous pouvez associer plusieurs son à un seul cue. Ceci aura pour effet de jouer tous les sons en même temps au déclenchement du cue.

Voilà! Sauvegardez votre projet (CTRL+S).

Retournez à votre projet XNA et ajoutez au Content Pipeline le fichier .xap de votre projet XACT. Chose importante, il faut également copiez les fichiers wav dans le dossier "Content" (le dossier! et non le Content Pipeline) de votre projet XNA.
Vous êtes fin prêt à jouer des sons dans votre jeu.

Il faut commencer par initialiser le moteur sonore et déclarer vos banques de sons. Alors déclarons le nécessaire en données membres.

AudioEngine moteurSonore;
WaveBank banqueWaves;
SoundBank banqueSons;

Puis, il faut initialiser tout ceci, dans la méthode Initialise.

moteurSonore = new AudioEngine("Content/Pong.xgs");
banqueWaves = new WaveBank(moteurSonore, "Content/Wave Bank.xwb");
if (banqueWaves != null)
    banqueSons = new SoundBank(moteurSonore, "Content/Sound Bank.xsb");

Vous vous demandez peut-être d'où sortent les fichiers xgs, xwb et xsd? Ces fichiers n'apparaissent pas dans votre dossier "Content," mais ils sont créé par XNA à la compilation grâce à vos sons et votre projet XACT. Ces fichiers auront le noms que vous leur aurez donné dans XACT. Comme nous n'y avons pas touché, ce sont les noms par défaut.

Jouons des sons maintenant!

Pour jouer un son, rien de plus simple.

// pour le son du rebond
banqueSons.PlayCue("rebond");
// pour le son du but
banqueSons.PlayCue("but");

Je vous laisse le soin de placer ces sons où vous le souhaitez. Vous pouvez les placer dans la méthode Update, là où les collisions sont gérées ainsi que le score.

Terminé!

Votre Pong est désormais fini. Du moins, ce tutoriel l'est!
Il y a évidement beaucoup de marge d'améliorations et le code ne prétend pas être propre ou optimal. Le but ayant été de vous familiariser avec l'outil.
En guise de challenge, vous propose de faire ceci par vous même :

Optimiser les collisions et la physique de la balle.
Ajouter un menu (pour le texte, vous pouvez afficher une texture avec votre texte écrit dessus).
Ajouter un une "intelligence artificielle" pour jouer seul (astuce : il suffit que la barre suive la balle).
Gérer un score maximum pour gagner.

Voilà qui conclu ce premier tutoriel. Vous pouvez télécharger les sources complètes de ce tutoriel ici.
Etant donné qu'il s'agit de mon tout premier article, les questions, remarques ou toutes autres réactions sont les bienvenues.

XNA/C#/.NET les sites et livres à retenir

Helmut — Mon, 21 Apr 2008 14:50:00 +0200

Le web regorge de sites très intéressants concernant XNA et ses technologies associées. Je vous propose donc de visiter une partie de mon bookmark personnel.
Il y en a pour tous les goûts et tous les niveaux, en passant par des tutoriels pour réaliser des jeux de A à Z.
Je vous propose également une petite sélection de livres.

Apprendre à programmer en C#

Developpez.com et plus précisement son méga cours qui s'adresse à des gens qui ont des notions de programmation, bien qu'avec un peu de motivation, un débutant puisse y trouver son compte.
Le livre Pratique de .NET 2 et C# 2 de Patrick Smacchia, aux éditions O'Reilly. Un livre très complet, ma référence personnelle (si il ne devait y en avoir qu'un seul), qui conviendra aussi bien aux débutants qu'aux développeurs confirmés. Il est tout de même recommandé d'avoir des notions d'informatique.

Les sites à retenir

La très grande partie des sites autour de XNA sont anglophones et les ressources françaises ne sont souvent pas au goût du jour ou populaire. Désolé dont à tous les anglophobes.

Ziggyware, surement la plus grosse communauté autour du XNA. Tutoriels, news sur les jeux, forums, la totale.
GameDev ou le plus gros site généraliste traitant du développement de jeux vidéo. La grosse partie de ses articles sont destinés à des programmeurs de niveau intermédiaire à avancé.
Les forums 2D, 3D, Jeux de developpez.com, entretenu par de très bon développeurs, dont des professionnels du jeux vidéo dont je citerai pas le nom. J'y participe assez rarement.
Le blog des développeurs du XNA, histoire de suivre les annonces autours de celui-ci.
Let's Kill Dave, tas de news et articles à propos du développement de jeux via les technologie Microsoft.
Le blog de Shawn Hargreaves, plein d'articles intéressants concernant la 3D et fonctionnement de vos GPU.
Cornflower Blue ou le blog d'un membre de l'équipe XNA, plein de bonnes choses.
The Z Buffer, tenu par ZMan. Principalement des news autour du XNA et de MDX.
Le blog de Benjamin Nitschke, lead programmer chez exDream et MVP DirectX/XNA. Son studio est le premier à avoir commercialisé un jeu réaliser avec MDX (Managed DirectX, la version .NET de DirectX). Il est également l'auteur d'un très bon livre sur XNA (cf. plus bas) et du starter kit XNA Racer. Son site regorge de beaucoup chose intéressante.

Les tutoriels intérressants pour débuter

Réaliser un jeu musical de A à Z en 14 vidéos, très sympa et vous demandera de posséder une guitare 360. Un bon niveau est recommandé. Le site de l'auteur, Dan Waters, est également très intéressant.
Réaliser votre Tile Engine en vidéos, très sympa aussi.

Les livres

Il n'y a pour l'instant pas beaucoup de livre sur XNA 2 et absolument aucun en français. La plupart sont encore au XNA 1, mais ils sont en bonne partie compatibles avec le XNA 2. Je préfères vous diriger vers les ouvrages récents.

Professional XNA Programming 2nd Edition de Benjamin Nitschke. Très complet et couvre beaucoup d'élément dont la réalisation d'un moteur 3D. Il propose de réaliser plusieurs jeux, en partant de pong en 2D à un RPG 3D en passant par un Shoot them up ou encore un jeu de course. Bon niveau requis. Ce livre a l'avantage de ne pas être un flot de code à repomper et beaucoup de ses chapitres ne sont que des théories et remplis de challenge "code yourself". Attention à ne pas tomber sur la première édition du livre, que ne couvre que XNA 1.0 beta.
Microsoft XNA Game Studio 2.0: Learn Programming Now de Rob Miles aux éditions Microsoft Press. Bien que je n'ai pas eu l'occasion de le lire, il peut être intéressant pour débuter, mais il a l'air un peu léger comparer au précédent livre.

Ceci clôture ma sélection. Bonne lecture.

Introduction au framework XNA

Helmut — Sat, 19 Apr 2008 21:56:00 +0200

Avec la sortie du XNA GS 2.0 et sa mise en avant de Microsoft à la GDC (Game Developers Conference) de février, la curiosité de beaucoup de personnes a été titillée. Les démos sur 360 de certains jeux tels que The Dishwasher (réalisé essentiellement par un seul gars) ont frappé un grand coup.

Pour mettre un pied dans le framework XNA, suivez le guide.

Article mis à jour le 19/01/2009 afin de refléter XNA3.

Qu'est-ce que XNA?

XNA (pour XNA's Not Acronymed, oui, c'est très recherché) est un ensemble d'outils facilitant le développement d'application cross-plateforme PC/Xbox360/Zune. Sa particularité, en plus d'être proposé gratuitement par Microsoft, est d'être axé communauté. On l'appel parfois "le youtube du jeux vidéo", bien que cela puisse se discuter.
En effet, vous pouvez soumettre vos créations à la communauté qui sera alors en charge de l'évaluer et de lui permettre d'être diffuser sur les Community Games de la 360.

Techniquement, c'est quoi?

Le framework XNA peut être comparé à un API tel que DirectX mais il n'en est pas un. C'est un ensemble d'outils.
Tout d'abord, XNA est une sur-couche au .NET Framework et s'appuie donc sur les langages et les librairies de .NET. Il est donc recommandé de programmer en C#.
Le framework XNA apporte des bibliothèques permettant de gérer le graphisme (sur-couche à DirectX 9), les périhpériques d'entrée (pad 360, guitar, big button pad,...), le son, le contenu et le réseau de vos applications (via Xbox Live / Game for Windows Live).
En dehors des bibliothèques, on a un environnement de développement qui se greffe entièrement à Visual Studio 2008 (Express ou non) et on peut donc profiter de toutes ses fonctions.
Une des forces du XNA (et parfois sa faiblesse), c'est le Content Pipeline. Il s'agit d'une sorte d'importateur automatique de contenu. Il permet d'importer et d'utiliser très facilement des textures, du son, des modèles et autres contenus en passant par les shaders. Le Content Pipeline va également cuisiner votre contenu pour qu'il transportable du PC à la Xbox360 ou au Zune de façon transparente (et optimisée). Le Content Pipeline compresse également vos données à la volée de façon efficace.
XNA, c'est aussi d'autres outils, tels que XACT, qui permet de cuisiner votre contenu sonore afin que celui-ci soit cross-plateforme PC/Xbox360. A noter qu'à l'origine, XACT est un outil qui fait parti du SDK de la 360 et que ce dernier n'est plus indispensable depuis XNA 3.

XNA est l'aboutissement de MDX, l'implémentation .NET de DirectX, dont le développement a été arrêté au profit de XNA.

A qui s'adresse le XNA?

Vous l'aurez peut-être deviné, XNA est principalement destiné aux développeurs. Microsoft vise en premier lieux les étudiants en informatique, les développeurs amateurs et les petits studios de développement indépendants.
Après la GDC 2008, quelques personnes s'attendaient à un outil simple, voir WYSIWYG, à l'image d'un RPG Maker. Autant faire déchanter ces personnes tout de suite. Il est largement préférable d'avoir de bonnes bases en programmation, notamment en C#, Java ou C++. Une connaissance des APIs graphiques OpenGL et/ou DirectX est également très utile à comprendre certains concepts.

De quoi ai-je besoin pour m'y mettre et combien cela coûte?

Concernant les coûts, tout dépend de ce que vous souhaitez en faire, mais de façon générale, le XNA et son utilisation sont gratuits, et un usage commercial est possible sans licence sur PC.

Pour débuter, votre PC devra disposer des logiciels suivants:

Windows XP SP2 ou Vista
Un DirectX à jour
Le .NET Framework 2 ou supérieur (intégré à Vista en version 3.0), la version la plus récente est la 3.5.
Visual C# Express 2008 qui est gratuit pour tous dans la limite d'une utilisation non commerciale (les professionnels peuvent utiliser les versions complètes de l'EDI).
XNA Game Studio 3.0

Si vous êtes étudiant dans l'enseignement supérieur, il y a de bonne chance que votre établissement soit dans le programme MSDN AA de Microsoft et vous pourrez profiter de logiciels comme les versions professionnelles de Visual Studio qui sont plus pratiques pour utiliser XNA, mais pas du tout indispensables. Dirigez vous vers le précédent lien pour plus d'infos ou aller voir le responsable informatique de votre établissement qui, en théorie, devrait pouvoir vous renseigner.

Côté matériels, il est nécessaire d'avoir une carte graphique DirectX 9.0c supportant au moins les shaders 2.0.
Posséder une manette d'Xbox 360 est un plus non négligeable (beaucoup d'exemples ou de livres n'utilisant pas le clavier). Attention à ne pas avoir des pilotes modifiés comme les XBCD qui rendent les manettes 360 incompatibles avec XNA.

Et pour tester mes applications sur une Xbox 360?

C'est la que les choses peuvent devenir contrariantes. Pour exécuter du code provenant du XNA sur une console, il est nécessaire d'avoir une licence XNA Creator Club, achetable via le Market Place pour la somme de 99€ par an, ou 49€ pour 4 mois.
Encore une fois, si vous êtes étudiants, Microsoft propose via son programme DreamSpark des logiciels de développement et autres, dont une licence Creator Club d'un an gratuite (mais uniquement valide pour débugger une appli sur 360).

Comment tester les applications des autres?

Sur PC, si vous trouvez un jeu développé avec XNA, vous n'aurez besoin que du Runtime XNA (qui est normalement intégré à l'installateur du jeu) et vous pourrez utiliser l'application sans restriction.
Pour tester sur 360, il y a deux options:

L'auteur met à disposition les executables Xbox sur le web, vous devrez alors les télécharger, et les transferer sur votre Xbox 360 via le XNA Game Studio.
Le jeu est dispo sur les Community Games de la console et vous n'avez plus qu'à le télécharger comme un jeu Xbox Live Arcade.

Depuis les Community Games, la licence Creator Club n'est utile que si vous souhaitez débugger vos créations sur 360 et les vendre.

Et maintenant, on fait des jeux!

Stop! Là, on va y aller tout en douceur, étapes par étapes. Dans les prochains temps, je vous proposerai des tutoriels de base, en commençant pour de la 2D.
Je ne vais pas vous apprendre un langage. Mes articles ne s'adresseront surement pas aux débutants complets et certains seront même d'un niveau avancé.
Je vous invite donc à vous renseigner sur la plate-forme .NET et le C# qui lui est associé.

Mon prochain billet concernera probablement un ensemble de liens et de livres qui vous permettront d'en apprendre plus, voir de commencer.
Pour ceux qui ont un train d'avance, je vous propose de réaliser votre premier jeu.

Et pour distribuer mon jeu sur le Xbox Live et le vendre ?

Direction les Community Games.
Voilà qui boucle mon introduction au XNA. Remarques et questions bienvenues.