Développement XNA pour la Xbox et le PC

-

Livres
366 pages
Lire un extrait
Obtenez un accès à la bibliothèque pour le consulter en ligne
En savoir plus

Description

Grâce au tandem Live et XNA, la programmation de jeu vidéo pour PC et Xbox 360 est accessible au plus grand nombre : il n'est plus nécessaire d'investir dans de ruineux outils pour donner libre cours à ses idées de jeux et les réaliser. Cet ouvrage permettra au lecteur de s'approprier le framework XNA 3.0, mais également de comprendre comment s'organise un projet de développement de jeu vidéo.



Accéder aux dernières technologies de développement PC et Xbox 360 avec le framework XNA 3.0



Pour accompagner l'explosion du développement amateur favorisé par la plate-forme de distribution en ligne Live, Microsoft a mis au point le framework XNA pour fournir toutes les briques nécessaires à la création de jeu vidéo. Supports de référence du Live, Xbox 360 et PC sont, grâce à XNA, les deux plates-formes les plus propices pour les studios indépendants, les freelances et les particuliers qui souhaitent faire connaître, voire commercialiser, leurs réalisations.



Un manuel complet pour se lancer dans un projet de création de jeu vidéo



Ce livre accompagne le lecteur, débutant ou non, dans la conduite d'un projet de jeu en C#, qu'il s'agisse de programmer des événements, de créer un environnement sonore, ou de choisir ses moteurs graphique et physique et de les exploiter. L'auteur y détaille les techniques de programmation 2D et 3D. Il explore également les techniques graphiques et sonores avancées (effets, textures, défilement, transformations, animation, éclairage, design sonore, streaming) mais aussi certains algorithmes d'intelligence artificielle, sans oublier l'inclusion du mode multijoueur en réseau ou en écran splitté.




  • Débuter en C#


  • Prise en main de XNA


  • Afficher et animer des images : les sprites


  • Interactions avec le joueur


  • Cas pratiques : programmer en Pong


  • Enrichir les sprites : textures, défilement, transformation, animation


  • La sonorisation


  • Exceptions et gestion des fichiers : sauvegarder et charger un niveau


  • Pathfinding : programmer les déplacements des personnages


  • Collisions et physique : créer un simulateur de vaisseau spatial


  • Le mode multijoueur


  • Les bases de la programmation 3D


  • Améliorer le rendu avec le High Level Shader Langage




  • A. Visuel C# Express 2008


  • B. Les bienfaits de la documentation

Sujets

Informations

Publié par
Date de parution 07 juillet 2011
Nombre de visites sur la page 553
EAN13 9782212852783
Langue Français

Informations légales : prix de location à la page 0,0172 €. Cette information est donnée uniquement à titre indicatif conformément à la législation en vigueur.

Signaler un problème

Développement
XNA
pour la Xbox et le PC

Premiers pas en développement de jeu vidéo

L é o n a r dL a b a t

XNA
Développement
pour laXbox etlePC
Grâce au tandem Live et XNA, la programmation de jeu vidéo pour PC et Xbox 360 est accessible au plus
grand nombre : il n’est plus nécessaire d’investir dans de ruineux outils pour donner libre cours à ses
idées de jeux et les réaliser. Cet ouvrage permettra au lecteur de s’approprier le framework XNA 3.0,
mais également de comprendre comment s’organise un projet de développement de jeu vidéo.
Accéder aux dernières technologies de développement PC
et Xbox 360 avec le framework XNA 3.0
Pour accompagner l’explosion du développement amateur favorisé par la plate-forme de distribution en ligne Live,
Microsoft a mis au point le framework XNA pour fournir toutes les briques nécessaires à la création de jeu vidéo.
Supports de référence du Live, Xbox 360 et PC sont, grâce à XNA, les deux plates-formes les plus propices pour
les studios indépendants, les freelances et les particuliers qui souhaitent faire connaître, voire commercialiser,
leurs réalisations.
Un manuel complet pour se lancer dans un projet de création
de jeu vidéo
Ce livre accompagne le lecteur, débutant ou non, dans la conduite d’un projet de jeu en C#, qu’il s’agisse de
programmer des événements, de créer un environnement sonore, ou de choisir ses moteurs graphique et physique et
de les exploiter. L’auteur y détaille les techniques de programmation 2D et 3D. Il explore également les techniques
graphiques et sonores avancées (effets, textures, défilement, transformations, animation, éclairage, design sonore,
streaming) mais aussi certains algorithmes d’intelligence artificielle, sans oublier l’inclusion du mode multijoueur en
réseau ou en écran splitté.

Au sommaire
XNA et son environnement • Débuter en C# •Types de données•Commenter le code•Conditions•Fonctions et
procédures•Classes et espace de noms• Prise en main •EDI•Starter kit•Architecture d’un projet XNA•Créer un
projet•Outils pour la Xbox 360• Les sprites •Afficher plusieurs sprites•La classe Sprite•Gestionnaire d’images :
boucles, tableaux et collections•Mesure des performances• Interaction avec le joueur •Périphériques•Services•GUI
• Programmer un Pong •Pseudo-code•Création du projet•Arrière-plan, raquette, balle•Améliorer le jeu• Textures,
défilement, animation • Texturerun rectangle• Scrolling• Spritessheets• Variationde teinte• Transformations•
Spritefont• Sonorisation •XACT et SoundEffect•Créer un projet sonore•Lire un son et un morceau de musique•
Streaming•Design sonore• Exceptions et gestion des fichiers : sauvegarder et charger un niveau •Espace de stockage•
Sérialisation•Exceptions•Gamer Services•Un éditeur de cartes•Content Importers•Version démo• Pathfinding :
programmer le déplacement des personnages •Algorithme et intelligence artificielle•Implémenter l’algorithme A*•
Collisions et physique •Zone de collision•Moteur physique•Mode multijoueur•Partager l’écran•Gestion des caméras
•En réseau avec Live• Programmation 3D •Coordonnées, primitives, vertices, vecteurs, matrices, transformations,
effets, projection•Caméras•Matrices de vue et de projection•Appliquer une couleur à un vertex•Plaquer une
texture•Transformations des objets•Lumières•Éclairer la scène•Exploiter les modèles• Améliorer le rendu avec
le High Level Shader Language • Vertexshaders et pixel shaders• Syntaxedu HLSL•d’effet Fichier• Ondulation•
Textures : en négatif, netteté, flou, couleur• Annexes •Visual C# Express 2008•La documentation.

À qui s’adresse cet ouvrage ?
– Aux étudiants en programmation qui désirent adapter leurs connaissances aux spécificités du développement de
jeu pour PC et Xbox.
– Aux studios indépendants et freelances qui souhaitent passer à XNA.
– À l’amateur curieux qui a choisi XNA pour développer son premier jeu.

L. Labat
Passionné par le
développement et les jeux
vidéo,Léonard Labatassure
une veille sur les technologies
Microsoft en publiant
régulièrement sur son blog
(http://leonard-labat.blogspot.
com/). Il évolue au sein du
laboratoire des technologies
.Net de SUPINFO
(http://www.labo-dotnet.
com/).

Conception : Nord Compo

Développement
XNA
pour la Xbox et le PC

Chez le même éditeur

Dans la thématique du jeu vidéo

RPG Maker.Créez votre gameplay et déployez votre jeu de rôle.
S. ronce. – N°12562, à paraître.

Équideow.Le guide du bon éleveur.Perlineet l. Noisette. –
N°12521, à paraître.

Dans la même collection

ActionScript 3. Programmation séquentielle et orientée objet.
e
d. tardivau. – N°12552, 2édition, 2009,448 pages.

PHP/MySQL avec Dreamweaver CS4. Les clés pour réussir son
site marchand. J.-m.defrance. – N°12551, 2009, 548 pages.

Sécurité PHP 5 et MySQL.d. Seguyet P. Gamache. –
N°12554, 2009, 284 pages.

Sécurité informatique. Principes et méthode à l’usage des DSI,
RSSI et administrateurs. l. Bloch, C. Wolfhugel. – N°12525,
2009, 292 pages.

Programmation OpenOffice.org 3. Macros, OOoBASIC et API.
B. marcellyet l. Godard. – N°12522, 2009, 920 pages.

Dreamweaver CS4 Styles CSS. Composants Spry-XM,
comportements JavaScrip, comportements serveur PHP-MySQL.
t. Audouxet J.-m. defrance. – n°12462, 2009,620 pages.

Programmation Python. Conception et optimisation. t. Ziadé. –
e
n°12483,2009, 586 pages.2 édition,

CSS2.Pratique. du design web. r. goetter. – n°12461,
e
3 édition,2009, 318 pages.

Programmation Flex 3. Applications Internet riches avec Flash
ActionScript 3, MXML et Flex Builder.A. VannieuwenhuyZe. –
N°12387, 2008, 430 pages.

WPF par la pratique.t.lebrun. – N°12422, 2008, 318 pages.

PHP 5 avancé.e. daspetet P.pierre degeyer.– N°12369,
e
5 édition,2008, 884 pages.

Bien développer pour le Web 2.0.Bonnes pratiques Ajax
Prototype, Script.aculo.us, accessibilité, JavaScript, DOM,
e
XHTML/CSS. C. Porteneuveédition, 2008, 674. – N°12391, 2
pages.

Dans la collection « Accès Libre »

Linux aux petits oignons.K. Novak. – N°12424, 2009, 546
pages.

Inkscape.Premiers pas en dessin vectoriel.n. dufour, collab.
e.decastroguerra. – N°12444, 2009, 376 pages.

MediaWiki efficace.d. barrett.– N°12466, 2009, 372 pages.
Économie du logiciel libre.f. elie. – N°12463, 2009, 195 pages.

Freemind –Boostez votre efficacité.x. delengaigne, p. mongin.
N°12448, 2009, 272 pages.

Spip 2 –Premiers pas pour créer son site avec Spip 2.0.3.
A.-l. Quatravaux, d. Quatravaux.– N°12502, 2009, 300
pages.

Réussir son site web avec XHTML et CSS.m. nebra.–
e
N°12307, 2édition, 2008, 306 pages.

Réussir un site web d’association… avec des outils libres !
e
a.-l. Quatravaux etd. Quatravaux.– N°12000, 2édition,
2007, 372 pages.

Réussir son site e-commerce avec osCommerce.d. mercer.–
N°11932, 2007, 446 pages.

Open ERP–Pour une gestion d’entreprise efficace et intégrée.
f. pinckaers, g. gardiner.– N°12261, 2008, 276 pages.

PGP/GPG –Assurer la confidentialité de ses mails et fichiers.
m. lucas,ad. par d.garance,contrib. J.-m.thomas. –
N°12001, 2006, 248 pages.

Mozilla Thunderbird–Le mail sûr et sans spam.d. garance,
a.-l.et d.Quatravaux.– N°11609, 2005, 300 pages avec
Cd-rom.

Firefox. Retrouvez votre efficacité sur le Web !t. trubacZ,
préface de t.nitot.– N°11604, 2005, 250 pages.

Hackez votre Eee PC–L’ultraportable efficace.c. guelff.–
N°12437, 2009, 306 pages.

Monter son serveur de mails Postfix sous Linux.m. bäck et
al.,adapté par P.tonnerre. – N°11931, 2006, 360 pages.

Ergonomie web –Pour des sites web efficaces.
e
a. boucher.édition 2009, 440 pages.– N°12479, 2
Joomla et VirtueMart– Réussir sa boutique en ligne.
v. isaksen,avec la contribution det. tardif.– N°12381, 2008,
306 pages.
e
La 3D libre avec Blender.o. saraja.édition,– N°12385, 3
2008, 456pages avec dVd-rom.
Dessiner ses plans avec QCad–Le DAO pour tous. A.pascual
– N°12397, 2009, 278 pages.
Inkscape efficace.c. gémy– N°12425, 2009, 280 pages.
e
Ubuntu efficace.l.dricot.édition, à paraître– N°12362, 3
2009.
Gimp 2.6 – Débuter en retouche photo et graphisme libre.
e
d. robertédition, 2009, 350 pages.N°12480, 4. –

Gimp 2.4 efficace –Dessin et retouche photo.c. gémy.–
N°12152, 2008, 402 pages avec Cd-rom.

Dotclear 2– Créer et administrer son blog.a. caillau.–
N°12407, 2008, 242 pages.

Développement
XNA
pour la Xbox et le PC

Premiers pas en développement de jeu vidéo

L é o n a r dL a b a t

éditiONS eYrOlleS
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com

er
le code de la propriété intellectuelle du 1juillet 1992 interdit en effet expressément la photocopie à
usage collectif sans autorisation des ayants droit. Or, cette pratique s’est généralisée notamment dans les
établissements d’enseignement, provoquant une baisse brutale des achats de livres, au point que la possibilité
même pour les auteurs de créer des œuvres nouvelles et de les faire éditer correctement est aujourd’hui
menacée.
en application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le
présent ouvrage, sur quelque support que ce soit, sans autorisation de l’éditeur ou du Centre Français d’exploitation du
droit de Copie, 20, rue des Grands-Augustins, 75006 Paris.
© Groupe eyrolles, 2009, iSBN : 978-2-212-12458-3

Avan

t

-

p

ro

p

o

s

Si vous lisez ce livre, c’est que votre objectif est sûrement de créer un jeu vidéo,
c’est-àdire d’ordonner à l’ordinateur ou à la console d’effectuer un certains nombres de tâches.

La programmation de jeu vidéo

Lors d’une utilisation quotidienne d’un ordinateur ou de votre console, vous n’avez nul
besoin de programmer. Si vous devez faire une recherche sur l’Internet ou que vous
voulez jouer à un jeu, vous vous contenterez d’utiliser un programme écrit par quelqu’un
d’autre ; et ceci est tout à fait normal, nul besoin d’être plombier pour prendre un bain !

Définition
Un programme informatique a pour but d’indiquer à un ordinateur la liste des étapes nécessaires à la
réalisation d’une tâche. La programmation est le nom donné au processus de création d’un programme.

Pour certains, la programmation constitue une véritable passion, pour d’autres, c’est un
moyen pratique de donner une solution à un problème… Dans tous les cas, force est de
constater que la programmation devient un hobby et pénètre dans l’univers du grand
public. Pierre angulaire de la science informatique, c’est une activé fascinante qui attire
et motive de nombreux étudiants vers de réelles opportunités de travail, qu’il s’agisse de
l’univers du jeu ou non. Toutefois, elle n’en reste pas moins un domaine complexe et de
surcroît en constante évolution.

Mais la passion n’est pas le seul ingrédient requis pour réussir ses programmes… On ne
s’improvise pas spécialiste en informatique! En effet, la création d’un jeu n’est pas
seulement affaire de programmation : il faut aller au-delà et s’attaquer à la partie graphique,
audio et bien évidemment augameplay.

Les concepts qui seront abordés dans ce livre vous donneront de solides bases, mais ne
soyez pas déçu si vos premiers jeux n’égalent pas les réalisations sophistiquées auxquelles
vous êtes habitué. C’est une expérience incroyable que de voir une de ses créations
prendre forme, et même si le challenge est parfois difficile, la récompense est toujours
très gratifiante.

VI

Développement XNA pour la Xbox et le PC

Code intelligible, code machine
Un ordinateur ne comprend que des instructions très simples :
1. Récupérerle contenu d’un emplacement mémoire.
2. Luiappliquer une opération mathématique basique.
3. Déplacerle résultat vers un autre emplacement mémoire.
• Enplus de diviser à l’extrême chaque tâche, pour être compris directement par
l’ordinateur, vous devez lui parler en binaire, c’est-à-dire en une succession de 0 et 1. Imaginez
donc la complexité du code machine qui se cache derrière le démineur de Microsoft…
• Cetype de code n’étant pas du tout intelligible par un humain, il a donc fallu créer des
langages possédant une syntaxe plus proche de notre langue ainsi que les outils nécessaires
à la traduction du code écrit dans ces langages vers le code machine correspondant.
Ces derniers sont généralement appelés compilateurs.
• Ondistingue plusieurs types de langages : ceux dits de bas niveau et ceux de haut niveau.
Plus un langage est de bas niveau, plus il se rapproche de la machine, c’est-à-dire que
sa syntaxe est moins innée, que la gestion de la mémoire est plus difficile, etc. Prenons
deux exemples. L’assembleur étant un langage de bas niveau, il faut traiter directement
avec les registres du processeur, et il implique une bonne connaissance de l’architecture
système. À l’inverse, le Visual Basic est un langage plus abordable qui n’est pas soumis
aux mêmes contraintes que celles que nous venons de citer.
• Ilfaut surtout garder en tête qu’un langage qui pourrait être classé de plus haut niveau
n’est pas forcément plus facile à maîtriser qu’un autre. Tout dépend du programmeur,
bien sûr, mais aussi du besoin : à cause de sa simplicité, le Visual Basic n’offre pas les
mêmes possibilités d’optimisation que le C, par contre, il s’avère très pratique pour
développer rapidement une application.

Les algorithmes
Un algorithme est l’énoncé d’une suite d’opérations constituant une solution à un problème
donné. On peut présenter toutes les actions de notre quotidien sous la forme algorithmique.
Par exemple, pour la cuisson des pâtes :
1. Salerl’eau.
2. Porterà ébullition.
3. Plongerles pâtes.
4. Mélangerpour éviter qu’elles ne collent au fond.
5. Égoutter.
6. Rincer.
Grâce à cet algorithme, vous pouvez aisément expliquer à quelqu’un la façon de cuire des
pâtes, si besoin est.

Avant-propos

Le langage algorithmique est un compromis entre notre langage courant et un langage de
programmation. Ainsi, la compréhension d’une fonction d’un programme est plus aisée
qu’en se plongeant directement dans le code.

XNA et son environnement

Il existe une multitude de langage de programmation et de bibliothèques qui peuvent être
utilisés pour programmer un jeu vidéo. Comment faire le bon choix ?

Pourquoi choisir XNA ?
L’un des principaux critères qui peut motiver votre choix est la plate-forme cible. En
effet, vous n’utiliserez pas forcément les mêmes outils pour créer un jeu pour Xbox 360
ou téléphone mobile. D’une manière générale, pour développer un jeu pour console, vous
devrez utiliser un kit de développement adapté: la PSP possède son SDK utilisable
en C++, celui de la Nintendo DS repose quant à lui sur le C.
Du côté des PC, vous pouvez programmer un jeu vidéo dans un peu près n’importe quel
langage. En ce qui concerne la partie graphique du jeu, deux solutions s’offrent à vous : la
première consiste à utiliser des bibliothèques de très bas niveau telles que DirectX, OpenGL
ou encore SDL. La seconde possibilité consiste à utiliser un moteur graphique comme
OGRE ou Allegro. Elles est particulièrement intéressante car elle permet de gagner beaucoup
de temps.
XNA est une bibliothèque de bas niveau basée sur le framework Compact .Net dans son
implémentation pour Xbox 360 (ou le lecteur multimédia Zune de Microsoft) et sur le
framework .Net dans son implémentation pour PC.

Comprendre le framework .NET
• Leframework .NET (prononcez « dotNet »), est un composant Windows apparu dans
sa version 1.0 en 2002. Depuis, Microsoft a sorti régulièrement de nouvelles versions.
Avec le système d’exploitation Windows XP, ce composant était facultatif. Cependant
la version 3.0 du framework, .NET est directement intégré à Windows Vista.

En détail
Voici récapitulées les années de sortie des précédentes versions de notre framework :
1.1 en 2003 ;
2.0 en 2005 ;
3.0 en 2006 ;
3.5 en 2007.

Il dispose de deux atouts majeurs pour simplifier le développement d’applications web
ou Windows : le CLR (Common Language Runtime) et les bibliothèques de classes.

VII

VIII

Développement XNA pour la Xbox et le PC

Le CLR est une machine virtuelle (bien que Microsoft préfère utiliser le termeruntime)
utilisée pour exécuter une application .NET. Il possède, entre autres, un composant appelé
JIT (Just In Time, c’est-à-dire juste à temps), qui compile du code MSIL (Microsoft
Intermediate Language) vers du code compréhensible par la machine. Ainsi, tout langage
disposant d’un compilateur qui produit du code MSIL (les spécifications techniques
sont disponibles à cette adresse :http://www.ecma-international.org/publications/
standards/Ecma-335.htm/) est exécutable par le CLR et bénéficie des possibilités offertes
par la plate-forme. Il est donc possible de choisir un langage parmi un grand nombre
(C#, C++, VB.NET, J#, etc.), le choix ne dépendant plus forcément des performances
mais plutôt d’une affaire de goût. Le CLR comporte également une multitude d’autres
technologies dont vous ne saisiriez peut-être pas l’intérêt pour le moment, mais que
nous aborderons plus tard dans cet ouvrage.

MSIL
Langage ressemblant à de l’assembleur, MSIL ne comporte aucune instruction propre à un système
d’exploitation ou à du matériel.

Le framework .NET met également à la disposition du programmeur plus de 2 000 classes
utilitaires, qui lui permettent de gagner un temps précieux lors du développement. Ainsi,
manipulation de chaînes de caractères, communication réseau, accès aux données sont
choses faciles à réaliser. À chaque nouvelle version du framework, la bibliothèque de classes
s’étoffe davantage et les fonctionnalités disponibles sont de plus en plus performantes.

XNA : faciliter le développement de jeu vidéo

Le framework XNA (XNA’s Not Acronymed) est constitué de plusieurs bibliothèques .NET
et permet un développement multi-plate-forme : les classes fournies par XNA permettent
au programmeur de développer un jeu pour Windows puis de le porter très facilement
pour qu’il soit utilisable sur Xbox 360 ou sur le lecteur multimédia Zune.

L’un des buts de XNA est de simplifier au maximum le développement de jeu vidéo. Par
exemple, si vous avez déjà eu une expérience dans le développement avec l’api DirectX
ou OpenGL, vous savez certainement qu’écrire l’initialisation de votre programme vous
prendrait un certain temps alors qu’avec XNA tout est automatique. C’est précisément là
que réside tout l’intérêt du framework : avec XNA, il vous suffit seulement d’écrire quelques
lignes de code très facilement compréhensibles pour créer un jeu complet.

Bon à savoir
Soulignons également que le framework XNA est livré avec ce que l’on appelle desStarter Kit.Ces petits
projets de jeu vidéo montrent les possibilités offertes ainsi que le niveau d’accessibilité du développement.

Avant-propos

Officiellement, XNA ne peut être utilisé qu’avec le langage de programmationC#. En
pratique, vous pouvez également réaliser un jeu avec XNA en VB.NET, mais vous ne
pourrez pas utiliser tous les composants offerts par le framework.

Version
XNA 3.0 est disponible depuis le 30 octobre 2008, c’est sur cette version que ce livre se focalise.

C#, langage de programmation de XNA
Langage de programmation orienté objet à typage fort, C# (prononcez « C-Sharp ») a fait
son apparition avec la plate-forme .NET. Il est très proche à la fois du Java et du C++. Ses
détracteurs le qualifient souvent de copie propriétaire de Java.

Java
Très répandu dans le monde du logiciel libre, ce langage s’exécute lui aussi sur une machine virtuelle. À
l’heure actuelle et selon des sondages qui paraissent régulièrement sur l’Internet, il s’agit du langage le
plus populaire parmi les développeurs.

Tout comme le framework .NET dont il est indissociable, le langage C# est régulièrement
mis à jour et se voit ajouter des améliorations syntaxiques ou de conception.

Choisir son environnement de développement intégré
Pour utiliser XNA ou, d’une manière plus générale, programmer dans un langage
compatible .Net,vous aurez besoin d’un EDI (Environnement de Développement Intégré).
Microsoft en propose toute une gamme comprenant :
• VisualStudio Express.
• VisualStudio Standard.
• VisualStudio Professional.
• VisualStudio Team System.
Chaque version vise un public différent, les versions Express (il en existe une pour le
langage C#, une pour le C++, une pour le VB et une pour le développement web) sont
gratuites et s’adressent au développeur amateur tandis que la version Team System est
orientée pour le développement professionnel en équipe.
XNA 3.0est compatible avec les versions de Visual Studio2008. Dans ce livre, nous
utiliserons la version Microsoft Visual C# Express 2008.
Vous connaissez maintenant tous les outils nécessaires pour commencer, alors bonne
lecture et bienvenue dans le monde du C# et de XNA !

IX

X

Développement XNA pour la Xbox et le PC

À qui s’adresse le livre ?

Ce livre s’adresse à tous ceux qui désirent créer des jeux pour PC, pour Xbox 360 ou pour
le Zune sans avoir d’expérience préalable dans ce domaine ou même dans celui plus vaste
de la programmation. En effet, nous y présentons les notions de bases du C# nécessaires
à la compréhension de XNA.

Ainsi, ce livre vous sera utile si, étudiant en programmation, vous souhaitez découvrir
l’univers du développement de jeux vidéo ; si vous travaillez au sein d’un studio
indépendant ou en tant que freelance et que vous souhaitez vous former aux spécificités de
développement pour Xbox ; ou si, tout simplement, vous êtes curieux de vous initier au
développement de jeu et que vous avez choisi XNA.

Cependant, nous vous conseillons tout de même de vous munir d’un ouvrage sur le
langage de programmation C# : ce livre ne constitue pas un document de référence sur ce
langage, nous ne verrons ici que ce qui sera utile à la compréhension du framework
XNA, et certaines facettes du langage seront mieux détaillées dans un ouvrage spécialisé.

Structure de l’ouvrage
Lechapitre 1présente les notions de base du langage de programmation C#, qui vous
seront utiles dès lechapitre 2à la création d’une première application avec XNA.
Nous attaquerons les choses sérieuses dans lechapitre 3 enapprenant à afficher de
premières images à l’écran puis, dans lechapitre 4, nous apprendrons à récupérer les
entrées utilisateur sur le clavier, la souris ou la manette de la Xbox360. Ces notions
seront mises en pratique avec la création d’un clone de Pong dans lechapitre 5. Le
chapitre 6poussera plus loin les fonctions d’affichage d’images dans XNA.
Dans lechapitre 7, vous étofferez votre jeu en lui ajoutant un environnement sonore qu’il
s’agisse des sons ou de morceaux de musique. Puis, dans lechapitre 8, vous découvrirez
les techniques de lecture ou d’écriture de fichiers qui entrent en jeu dans les fonctionnalités
de sauvegarde.
Dans lechapitre 9, vous vous écarterez un peu du monde de XNA pour rejoindre celui
des sciences cognitives et plus particulièrement l’implémentation d’un algorithme de
recherche de chemin. Lechapitre 10abordera également un domaine qui n’est pas propre
à XNA : la gestion de la physique. Nous verrons donc comment implémenter un moteur
physique.
Dans lechapitre 11, le dernier à utiliser des exemples en deux dimensions, vous
découvrirez comment créer un jeu multijoueur avec XNA, qu’il s’agisse d’un jeu sur écran
splitté ou en réseau.
Lechapitre 12propose une introduction à la programmation de jeux en 3D avec XNA.
Pour terminer, dans lechapitre 13, vous apprendrez à réaliser des effets en HLSL.
Si vous n’avez jamais utilisé l’IDE Visual Studio, ou si vous souhaitez compléter vos
connaissances, l’annexe Aest consacrée à sa prise en main. L’annexe Bvous donne des

Avant-propos

pistes pour que vous puissiez pousser votre exploration de XNA au-delà de ce livre. Elle
présente donc différentes sources d’informations disponibles sur le Web, ainsi que des
méthodes de génération de documentation pour vos projets.

Remerciements
Je tiens tout d’abord à remercier Aurélie qui partage ma vie depuis un moment déjà et qui
sait toujours faire preuve de compréhension lorsque je passe des heures scotché à mon
ordinateur à coder encore et encore.
Merci également à mes parents qui ont tout mis en œuvre pour que j’accomplisse mes
rêves et sans qui je n’aurais sûrement jamais écrit ce livre.
Enfin je remercie les éditions Eyrolles, et tout particulièrement Sandrine et Muriel qui
m’ont accompagné tout au long de la rédaction de cet ouvrage.

Léonard Labat

Developper.xna@gmail.com

XI

Table des matières

Avant-propos .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La programmation de jeu vidéo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Code intelligible, code machine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les algorithmes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
XNA et son environnement .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pourquoi choisir XNA ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Comprendre le framework .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
XNA : faciliter le développement de jeu vidéo. . . . . . . . . . . . . . . . . . . . . . . .
C#, langage de programmation de XNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Choisir son environnement de développement intégré. . . . . . . . . . . . . . . . . .
À qui s’adresse le livre ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Structure de l’ouvrage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 1
Débuter en C#. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . .
Créez votre premier programme .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les types de données. . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . .
Organisation de la mémoire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Opérations de base sur les variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les instructions de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Commenter son code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les conditions : diversifier le cycle de vie des jeux. . . . . . . . . . . . . . . . . . . .

V
V
VI
VI
VII
VII
VII
VIII
IX
IX
X
X
XI

1
1
3
3
4
8
11
11
11

XIV

Développement XNA pour la XBox et le PC

Les fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Différencier fonction et procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Écrire une première procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Écrire une première fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Comprendre les classes et les objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Utiliser un objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Qu’est ce qu’un espace de noms ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Créer une classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 2
Prise en main de XNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Télécharger l’EDI et XNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Partir d’un starter kit .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Partager ses projets .. . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . .
L’architecture d’un projet XNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Structure du framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Structure du code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Créer un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
S’outiller pour développer sur Xbox 360 . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 3
Afficher et animer
des images : les sprites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les sprites. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .
Qu’est-ce qu’un sprite ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Afficher un sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Afficher plusieurs sprites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Un sprite en mouvement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Une classe pour gérer vos sprites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Créer une classe Sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Utiliser la classe Sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Classe héritée de Sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

14
15
15
17
18
18
18
19
20
24

25
25
26
28
29
29
30
30
33
34

35
35
36
37
40
41
45
45
47
50

Table des matières

Un gestionnaire d’images. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les boucles en C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Écriture du gestionnaire d’images. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mesure des performances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 4
Interactions avec le joueur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Utiliser les périphériques .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le clavier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La souris. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La manette de la Xbox 360. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Utilisation de périphériques spécialisés. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les services avec XNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les interfaces en C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Comment utiliser les services. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les méthodes génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Toujours plus d’interactions grâce à la GUI . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 5
Cas pratique : programmer un Pong. . . . . . . . . . . . . . . . . . . . . . . . . . .
Avant de se lancer dans l’écriture du code. . . . . . . . . . . . . . . . . . . . . . . . . .
Définir le principe du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Formaliser en pseudo-code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Développement du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Création du projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L’arrière-plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les raquettes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La balle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Améliorer l’intérêt du jeu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

55
55
57
58
60
63
65

67
67
67
70
71
73
73
74
75
77
80
81

83
83
83
84
85
85
86
88
91
95
96

XV

XVI

Développement XNA pour la XBox et le PC

CHAPITRE 6
Enrichir les sprites : textures, défilement, transformation,
animation. . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . .
Préparation de votre environnement de travail. . . . . . . . . . . . . . . . . . . . . .
Texturer un objet Rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Modifier la classe Sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Faire défiler le décor : le scrolling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Créer des animations avec les sprites sheets. . . . . . . . . . . . . . . . . . . . . . . . . .
Varier la teinte des textures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Opérer des transformations sur un sprite. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Afficher du texte avec Spritefont . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Afficher le nombre de FPS .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 7
La sonorisation. . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . .
Travailler avec XACT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Créer un projet sonore. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lire les fichiers créés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lire les fichiers en streaming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Compression .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ajouter un effet de réverbération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le son avec la nouvelle API SoundEffect . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lire un son. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lire un morceau de musique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pour un bon design sonore .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 8
Exceptions et gestion des fichiers : sauvegarder
et charger un niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le stockage des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les espaces de stockage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sérialisation et désérialisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

97
97
99
100
105
108
112
116
125
128
130

131
131
132
135
138
139
140
141
141
142
144
144

145
145
145
148
148

Table des matières

Les Gamer Services : interagir avec l’environnement . . . . . . . . . . . . . . . .
Dossier de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les méthodes asynchrones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La GamerCard : la carte d’identité du joueur. . . . . . . . . . . . . . . . . . . . . . . . .
Version démo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La sauvegarde en pratique : réalisation d’un éditeur de cartes. . . . . . . .
Identifier les besoins. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Chemin du dossier de jeu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gérer les dossiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Manipuler les fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Écrire dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lire un fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sérialiser des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Désérialiser des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les Content Importers, une solution compatible avec la Xbox 360. . . .
En résumé .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 9
Pathfinding : programmer les déplacements des personnages
Les enjeux de l’intelligence artificielle .. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Comprendre le pathfinding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L’algorithme A* : compromis entre performance et pertinence .. . . . . .
Principe de l’algorithme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Implanter l’algorithme dans un jeu de type STR. . . . . . . . . . . . . . . . . . . . . .
Cas pratique : implémenter le déplacement d’un personnage
sur une carte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Préparation : identifier et traduire les actions du joueur. . . . . . . . . . . . . . . . .
Créer le personnage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Implémenter l’algorithme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 10
Collisions et physique : créer un simulateur
de vaisseau spatial .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Comment détecter les collisions .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Créer les bases du jeu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Établir une zone de collision autour des astéroïdes . . . . . . . . . . . . . . . . . . . . .

XVII

152
152
154
158
160
162
162
168
169
172
174
176
178
180
181
184

185
185
186
187
187
190

200
200
201
204
206

207
207
208
213

XVIII

Développement XNA pour la XBox et le PC

Simuler un environnement spatial : la gestion de la physique .. . . . . . . .
Choisir un moteur physique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Télécharger et installer FarseerPhysics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Prise en main du moteur physique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les collisions avec FarseerPhysics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 11
Le mode multijoueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Jouer à plusieurs sur le même écran. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Du mode solo au multijoueur : la gestion des caméras. . . . . . . . . . . . . . .
Créer un jeu solo avec effet de scrolling. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Adapter les caméras au multijoueur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Personnaliser les différentes vues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le multijoueur en réseau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
S’appuyer sur la plate-forme Live. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Implémenter les fonctionnalités de jeu en réseau. . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 12
Les bases de la programmation 3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L’indispensable théorie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le système de coordonnées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Construire des primitives à partir de vertices. . . . . . . . . . . . . . . . . . . . . . . . .
Les vecteurs dans XNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les matrices et les transformations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gérer les effets sous XNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Comprendre la projection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dessiner des formes .. . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . .
La caméra et la matrice de projection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La matrice de vue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Des vertices à la forme à dessiner. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Déplacer la caméra. . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . .
Appliquer une couleur à un vertex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

217
217
219
222
227
230

231
231
232
232
237
244
248
248
249
257

259
259
259
260
262
263
263
264
265
265
266
267
277
279

Table des matières

Plaquer une texture sur un objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Texturer une face d’un objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Texturer un objet entier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Déplacer un objet avec les transformations. . . . . . . . . . . . . . . . . . . . . . . . .
Jouer avec les lumières .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les différents types de lumière. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Éclairer une scène pas à pas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Charger un modèle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE 13
Améliorer le rendu avec le High Level Shader Language .. . . . .
Les shaders et XNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vertex shaders et pixel shaders. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ajouter un fichier d’effet dans XNA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Syntaxe du langage HLSL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les variables HLSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les structures de contrôle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les fonctions fournies pas le langage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sémantiques et structures pour formats d’entrée et de sortie. . . . . . . . . . . . .
Écrire un vertex shader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Écrire un pixel shader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Finaliser un effet : les techniques et les passes. . . . . . . . . . . . . . . . . . . . . . . .
Créer le fichier d’effet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Faire onduler les objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La texture en négatif. . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . .
Jouer avec la netteté d’une texture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Flouter une texture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Modifier les couleurs d’une texture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE A
Visual C# Express 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Différencier solution et projet .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Personnaliser l’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

XIX

281
281
285
291
294
294
295
299
301

303
303
304
305
306
306
308
308
308
309
310
310
310
314
315
315
316
318
319

321
321
323

XX

Développement XNA pour la XBox et le PC

L’éditeur de texte .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les extraits de code .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Refactoriser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Déboguer une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Raccourcis clavier utiles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

CHAPITRE B
Les bienfaits de la documentation .. . . . . . . . . . . . . . . . . . . . . . . . . . . .
L’incontournable MSDN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ressources sur le Web .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Générer de la documentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

324
326
327
328
330

331
331
333
334

337

1

Débuter en C#

Ce premier chapitre a pour but de vous guider dans vos premiers pas de programmeurs et
notamment avec le langage C#. Commençant par la découverte des types de données et
allant jusqu’à la création de vos propres classes, ce chapitre constitue le minimum vital à
connaître avant de s’attaquer à la création d’un jeu.

Ne vous inquiétez pas si nous n’avons pas tout de suite recours à XNA, mais commençons
par le mode console. En effet, ce dernier est particulièrement adapté pour l’apprentissage
de C#.

Créez votre premier programme
Avant de nous lancer dans l’apprentissage du C#, découvrons ensemble l’environnement
dans lequel nous allons travailler.
Tout d’abord, démarrez Visual C# Express (figure 1-1).
Ensuite, créez un nouveau projet console en cliquant sur Fichier puis Nouveau Projet
(figure 1-2).

2

Développement XNA pour la XBox et le PC

Figure 1-1
Accueil de Microsoft Visual C# Express 2008

Figure 1-2
Création
d’un nouveau projet

Débuter en C#
CHAPITRE1

Le logiciel a automatiquement généré le code suivant dans un fichierProgram.cs:

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
using System.Text;

namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
}
}
}
Pour compiler l’application et l’exécuter (lorsque c’est possible), cliquez sur Générer
puis Générer la solution ou utilisez le raccourci clavier F5.
Tout au long de ce chapitre, nous allons analyser les possibilités qu’offre cette portion de
code. Ne fermez surtout pas Visual Studio, vous serez amené à l’utiliser parallèlement à
la lecture de ce chapitre.

Les types de données

Dans cette partie, nous allons dans un premier temps nous intéresser à la manière dont
s’organise globalement le stockage des données en informatique, puis nous passerons
en revue les différents types de données qui nous seront utiles pour la programmation
de jeux.

Organisation de la mémoire
Avant de se jeter tête la première dans le code, il est nécessaire de voir (ou de revoir)
quelques notions de base du fonctionnement de l’ordinateur et tout particulièrement celui
de la mémoire.
Ainsi, vous serez amené à travailler avec les deux grands types de mémoires :
•La mémoire vive –Généralement appelée RAM (Random Access Memory), elle est
volatile. Ce terme signifie qu’elle ne permet de stocker des données que lorsqu’elle est
alimentée électriquement. Ainsi, dès que vous redémarrez votre ordinateur, sa RAM
perd tout son contenu. Lire des données présentes sur ce type de mémoire se fait plus
rapidement que lire des données présentes sur de la mémoire physique.
•La mémoire physique –Cette mémoire correspond à votre disque dur ou à tous les
périphériques physiques de stockage de données (DVD-ROM, carte mémoire, etc.).
Elle n’est pas volatile, son contenu est conservé même lorsqu’elle n’est plus alimentée
électriquement.

3

4

Développement XNA pour la XBox et le PC

Sa capacité de stockage est souvent plus élevée que celle de la mémoire vive.
Les informations que l’on stocke dans la RAM s’appellent variables, tout simplement
parce que leur valeur peut changer au cours du temps.

Les variables

Le C# est un langage à typage fort : il existe plusieurs types de variables, chaque type
ayant des caractéristiques bien précises (utilisation mémoire, possibilité, précision, etc.).
En C#, comme dans la vie, on ne mélange pas les torchons et les serviettes.

Stocker des nombres entiers
Les premiers types de variables que nous allons découvrir servent à stocker les nombres
entiers. Leur particularité se situe au niveau de leur capacité de stockage, et donc de leur
occupation en mémoire.

Type
Byte
Short
Int
Long

Tableau 1-1Les types entiers

Stockage
1 octet
2 octets
4 octets
8 octets

Une variable se déclare de la façon suivante :

type identificateur;

Valeur minimale

0
– 32768
31
– 2

18
– 9.2¥10

Valeur maximale
255
32767

31
2 -1
18
9.2¥10

Par exemple, pour déclarer une variable entière correspondant au nombre de vies
restantes de joueur, il faut procéder de la manière suivante :
short nombreDeVies;
Il faut respecter certaines règles dans le nommage des identificateurs :
• Vousdevez faire attention à ce que le premier caractère soit une lettre majuscule ou
minuscule ou ununderscore(_).
• Pourtous les autres caractères, vous pouvez utiliser soit une lettre majuscule ou
minuscule, soit ununderscoreou alors un chiffre.
À ce stade, la variable étant uniquement déclarée, vous ne pouvez pas l’utiliser. Faites le
test en essayant de compiler le code suivant :
namespace PremierProgramme
{
class Program
{

static void Main(string[] args)
{
shortnombreDeVies;
Console.WriteLine(nombreDeVies);
}
}
}

Dans ce programme, une variable de typeshortest déclarée
la console.

Débuter en C#
CHAPITRE1

et son contenu s’affiche dans

Cependant, la compilation a échoué (figure 1-3) et ceci est tout à fait normal. En effet, la
variable a uniquement été déclarée, elle n’a pas été initialisée, c'est-à-dire qu’elle n’a pas
encore reçu de valeur.

Figure 1-3
La compilation du programme a échoué

L’initialisation d’une variable est très facile à réaliser :

identificateur = valeur;

À présent, remplacez le code précédent par celui ci-dessous et compilez-le :
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
shortnombreDeVies;
nombreDeVies= 7;
Console.WriteLine(nombreDeVies);
Console.ReadLine();
}
}
}
Cette fois-ci, vous constatez que le compilateur ne signale aucune erreur et que la valeur
qui a été affectée à la variable s’affiche correctement dans la console.
Notez que la ligneConsole.Read(); quin’était pas présente dans l’exemple précédent,
permet de figer la console tant que l’utilisateur n’appuie sur aucune touche du clavier.
Sans elle, la fenêtre s’ouvrirait et se fermerait toute seule en un éclair.

5

6

Développement XNA pour la XBox et le PC

Déclarer et initialiser une variable peut se faire sur une seule et même ligne :

short nombreDeVies = 7;

Enfin, il est également possible de déclarer et d’initialiser plusieurs variables sur la même
ligne :

short nombreDeVies = 7, score = 0;

Les booléens : vrai ou faux
Une variable de type booléen peut avoir deux états: vrai ou faux, soit respectivement
trueoufalse. Elle s’utilise de la manière suivante :
bool test = true;
Les booléens sont issus de l’algèbre de Boole. Les conditions et tests logiques sont basés
sur eux.

Découverte des nombres à virgule : les nombres réels
Comme pour les entiers, il existe plusieurs types de variables pour les nombres réels.

Type
float
double
decimal

Tableau 1-2Les types réels

Stockage
4 octets
8 octets
16 octets

Valeur minimale
–45
1.4¥10
–324
4.9¥10
–28
8¥10

Valeur maximale
38
3.4¥10
308
1.8¥10
28
8¥10

Il faut utiliser le point (.) comme séparateur entre la partie réelle et la partie décimale de
votre nombre. Par exemple :
double nombreReel = 4.56;
Notez qu’en utilisant les typesfloatetdouble, vous devrez faire face à un problème de
précision. Testez par exemple le programme suivant :
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
double total = ;0
while(total < 1)
total+= 0.0001;
Console.WriteLine(total);
Console.ReadLine();
}
}
}

Débuter en C#
CHAPITRE1

Le mot-cléwhilecorrespond à une structure algorithmique que nous étudierons plus tard.
Ce programme utilise une variabletotal detypedoublel’initialise à 0. Tant que la et
valeur totale est inférieure à 1, il faut lui ajouter 0,0001.

À l’exécution, voici ce qui s’affiche dans la console :

1,00009999999991

À présent, changez le type detotalet déclarez plutôt la variable en tant quedecimal.

namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
decimal total = 0;

while(total < 1)
total+= (decimal)0.0001;

Console.WriteLine(total);
Console.ReadLine();
}
}
}
Cette fois-ci, voici le resultat qui s’affiche à l’écran :
1
Le typedecimalprend plus de place en mémoire que les typesfloatetdouble, il nécessite
également un temps de traitement plus long.
Dans vos jeux, vous serez souvent amené à manipuler des nombres réels. Lorsque vous
effectuerez des tests sur ces variables, n’oubliez jamais que cette erreur de précision peut
entraîner des erreurs de logique que vous n’auriez pas prévues.
Lorsque vous choisissez le type d’une variable, analysez toujours au préalable vos
besoins et soupesez bien les avantages et inconvénients de chaque possibilité !

Stocker une lettre ou un signe avec char
Pour stocker un caractère, il existe le typechar. Celui-ci est codé sur deux octets en
mémoire.
Il s’utilise de la manière suivante :
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{

7

8

Développement XNA pour la XBox et le PC

charlettre = 'a';
Console.WriteLine(lettre);
Console.ReadLine();
}
}
}

Attention à bien utiliser des guillemets simples (ou apostrophes) «'» et pas des guillemets
doubles « " ».

Les chaînes de caractères
Une variable de typecharne correspond qu’à un seul caractère ; à l’inverse, une chaine
de caractère en contiendra un ou plusieurs. Pour en déclarer une, il faut utiliser le mot-clé
string.
Voici comment l’utiliser :

namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
stringchaine = "Test";
Console.WriteLine(chaine);
Console.ReadLine();
}
}
}

Cette fois-ci, il faudra bien utiliser les guillemets doubles.

Les constantes
Tous les types que nous avons vus jusqu’à maintenant peuvent être déclarés en tant que
constante grâce au mot-cléconst. Bien évidemment, et comme son nom l’indique, la
valeur d’une constante ne peut pas être modifiée durant le cycle de vie du programme.
const int N = 7;

Opérations de base sur les variables

Le tableau 1-3 répertorie les opérations arithmétiques de base qui peuvent être utilisées
sur les nombres en C# :

Opération
A + B

A – B
A * B
A / B
A % B

Tableau 1-3Opérateurs de base du langage

Description

Addition de A et de B

Soustraction de B à A

Multiplication de A par B

Division de A par B

Reste de la division de A par B

Débuter en C#
CHAPITRE1

Le programme suivant met en application ces opérations (le résultat est présenté sur la
figure 1-4) :

namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
intA=6;
int B = 3;
Console.WriteLine
Console.WriteLine
Console.WriteLine
Console.WriteLine
Console.WriteLine
Console.ReadLine();
}
}

Figure 1-4
Test des opérations arithmétiques

(A + B);
(A - B);
(A * B);
(A / B);
(A % B);

Vous pouvez stocker le résultat de chaque calcul dans une variable.
A = A + B;
Ce type d’opération peut également se factoriser de la manière suivante :
A += B;

9

10

Développement XNA pour la XBox et le PC

Vous pouvez utiliser ce genre de raccourci avec tous les opérateurs arithmétiques.
Les opérations de pré et post-incrémentations ou décrémentations sont également une
bonne manière de gagner du temps. Leur but est de raccourcir l’écriture de lignes telles
que :
A = A + 1;
En utilisant la post-incrémentation, la ligne précédente devient :
A++;

Opération
A++
++A
A--
--A

Tableau 1-4Opérateurs d’incrémentation et de décrémentation

Description
Post-incrémentation de A

Pré-incrémentation de A

Post-décrémentation de A

Pré-décrémentation de A

La post-incrémentation se fait après l’exécution d’une ligne d’instruction, alors que la
pré-incrémentation aura lieu avant. Un exemple valant mieux qu’un long discours, compilez
le programme suivant et observez les effets de chacune des opérations (figure 1-5).

namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
int A = 6;
Console.WriteLine
Console.WriteLine
Console.WriteLine
Console.WriteLine
Console.ReadLine();
}
}
}

Figure 1-5
Incrémentation et décrémentation

(A++);
(++A);
(A--);
(--A);

Les instructions de base

Débuter en C#
CHAPITRE1

Vous ne pouvez pas créer un programme, et a fortiori un jeu, juste en déclarant des variables,
ou si vous y arrivez, le résultat ne serait pas réellement intéressant. Dans cette partie,
nous allons nous intéresser aux instructions de base du langage grâce auxquelles vos
programmes vont se complexifier.

Commenter son code
Que vous soyez amené à partager du code avec d’autres personnes ou non, il est toujours
très important d’être clair et facilement compréhensible lorsque vous programmez. Une
bonne pratique à adopter est donc de commenter votre code.
En C#, il existe trois types de commentaires :
// Commentaire sur une ligne

/*
* Commentaire sur plusieurs lignes
*/

/// Commentaire pour la documentation automatique (voir Annexe A)

S’il est important de commenter votre code, attention cependant à ne pas tomber pas dans
l’excès : ne commentez que ce qui est réellement utile. Essayez d’avoir une vision critique
vis-à-vis de votre code, celle de quelqu’un qui n’a pas mené la réflexion qui vous a fait
aboutir à tel ou tel choix. Ajouter trop de commentaires inutiles risque de rendre vos
fichiers sources illisibles, et de vous faire perdre du temps.

Les conditions : diversifier le cycle de vie des jeux
L’écriture de tests logiques et de conditions est la base de la programmation. Voici la
structure algorithme d’un test simple :
SI CONDITION EST VRAIE
ALORS FAIRE…
FIN SI
En C#, le mot-clé utilisé pour faire un test est le mot-cléif. Voici un exemple d’utilisation
simple :
if (true)
{
Console.WriteLine("Bien!");
}
Si le code à exécuter dans le cas où la condition est vraie et ne tient que sur une ligne, il
est également possible d’écrire :
if (true)
Console.WriteLine("Bien!");

11

12

Développement XNA pour la XBox et le PC

Mais ce test n’a pas réellement d’intérêt. Dans l’exemple suivant, le test porte sur le
nombre de vies restantes à un joueur. S’il n’en a plus, le programme lui signale qu’il est
mort.

namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
ohs =;1ies eDeVombrrt n

if(nombreDeVies == 0)
ro"tsem ;)oClosnrW.eeLite(inou"Vêts

nombreDeVies--;

if(nombreDeVies == 0)
nooselW.CVo(" êusterineLi;)" settrom

Console.ReadLine();
}
}
}

Voici la liste des opérateurs conditionnels :

Opérateur
==
!=
>
>=
<
<=

Tableau 1-5Opérateurs conditionnels

Description
Test d’égalité

Test de différence

Strictement supérieur

Supérieur ou égal

Strictement inférieur

Inférieur ou égal

Si le test n’est pas concluant, il est possible d’effectuer d’autres actions.
SI CONDITION EST VRAIE
ALORSFAIRE…
SINON FAIRE…
FIN SI
En C#, l’instruction correspondant au termeSINON estl’instructionelse. Compilez le
programme suivant pour tester cette notion.

short nombreDeVies = 1;

if (nombreDeVies == 0)
osunso Cêtes mort");"Ve(ineLitWre.ol
else
");ie !oCsnlo.eitWrineL"Ve(s ousetêcne erov ne

Débuter en C#
CHAPITRE1

Il est possible d’ajouter un nombre infini de conditions. Ceci donne le code suivant :

SI CONDITION EST VRAIE
ALORSFAIRE…
SINONSI CONDITION EST VRAIE FAIRE…
SINON FAIRE…
FIN SI

Tout ceci se traduit en C# pari eslef

short nombreDeVies = 1;

. Voici un nouvel exemple :

if (nombreDeVies == 0)
etiLen"(oVsuê etConsole.Wri;tr)" som
else if (nombreDeVies == 1)
.elosnoCs ou"Ve(ineLitWrtntôm rotêseb eit...");
else
etireniLosnoW.els tecoenVo(" êusn vire e);e !"C

Vous avez à présent assez de connaissances pour effectuer un programme qui réagit aux
choix de l’utilisateur. Le code suivant demande à l’utilisateur son genre et affiche un
message en conséquence (figure 1-6).

namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
g intrs;erneg

Console.WriteLine("Entrez votre genre (M/F) :");
Liad()ne;ge ernoC =losneR.e

if (genre == "M")
Console.WriteLine("C'est noté Monsieur !");
else if (genre == "F")
Console.WriteLine("Bonjour Mademoiselle...");
else
.h..(eO"tsv C e'?");rai e.olnsCoineLitWr

Console.ReadLine();
}
}
}

13

14

Développement XNA pour la XBox et le PC

Figure 1-6
Vos programmes se compliquent…

Vous pouvez combiner plusieurs tests à la fois grâce aux opérateurs logiques.

Opérateur
&&
||
!

Tableau 1-6Opérateurs logiques

Description
Et
Ou
Non

Ces opérateurs vous permettent de factoriser votre code. Ainsi le test suivant…

if(A>B)
if(A > C)
CneLiteri.Wlesoonul selp se t"( A;d.")gran

… peut s’écrire de cette manière :

if(A > B && A > C)
esA ("nelu plet .dnarg s;)"CnooselW.iretiL
Dans l’exemple suivant, l’opérateurNotdonne raison à Jimi Hendrix en inversant le résultat
d’un test.
if(!))==9 ( 6
iteLe.WrnsolCo);"9 saw 6 fI"(eni
Il existe d’autres instructions de condition que vous découvrirez étape par étape dans la
suite de cet ouvrage.

Les fonctions
Dans cette partie vous apprendrez à factoriser votre code et à le rendre réutilisable en
utilisant les fonctions et les procédures.