Développement XNA pour la Xbox et le PC

turnmaryΛογισμικό & κατασκευή λογ/κού

5 Ιουλ 2012 (πριν από 5 χρόνια και 6 μήνες)

1.714 εμφανίσεις

Développement
XNA
pour la Xbox et le PC
Premiers pas en développement de jeu vidéo

L é o nar d L abat
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. r
once
. – N°12562, à paraître.
Équideow. Le guide du bon éleveur. P
erline
et l. N
oisette
. –
N°12521, à paraître.
Dans la même collection
ActionScript 3. Programmation séquentielle et orientée objet.
d. t
ardivau
. – N°12552, 2
e
édition, 2009,448 pages.
PHP/MySQL avec Dreamweaver CS4. Les clés pour réussir son
site marchand. J.-m. d
efrance
. – N°12551, 2009, 548 pages.
Sécurité PHP 5 et MySQL. d. S
eguy
et P. G
amache
. –
N°12554, 2009, 284 pages.
Sécurité informatique. Principes et méthode à l’usage des DSI,
RSSI et administrateurs. l. B
loch
, C. W
olfhugel
. – N°12525,
2009, 292 pages.
Programmation OpenOffice.org 3. Macros, OOoBASIC et API.
B. m
arcelly
et l. G
odard
. – N°12522, 2009, 920 pages.
Dreamweaver CS4 Styles CSS. Composants Spry-XM,
comportements JavaScrip, comportements serveur PHP-MySQL.
t. A
udoux
et J.-m. d
efrance
. – n°12462, 2009, 620 pages.
Programmation Python. Conception et optimisation. t. Z
iadé
. –
n°12483, 2
e
édition, 2009, 586 pages.
CSS2. Pratique. du design web. r. g
oetter
. – n°12461,
3
e
édition, 2009, 318 pages.
Programmation Flex 3. Applications Internet riches avec Flash
ActionScript 3, MXML et Flex Builder. A. V
annieuwenhuyZe
. –
N°12387, 2008, 430 pages.
WPF par la pratique. t. l
ebrun
. – N°12422, 2008, 318 pages.
PHP 5 avancé. e. d
aspet
et P. p
ierre

de
g
eyer
. – N°12369,
5
e
édition, 2008, 884 pages.
Bien développer pour le Web 2.0. Bonnes pratiques Ajax -
Prototype, Script.aculo.us, accessibilité, JavaScript, DOM,
XHTML/CSS. C. P
orteneuve
. – N°12391, 2
e
édition, 2008, 674
pages.
Dans la collection « Accès Libre »
Linux aux petits oignons. K. N
ovak
. – N°12424, 2009, 546
pages.
Inkscape. Premiers pas en dessin vectoriel. n. d
ufour
, collab.
e.
de
c
astro
g
uerra
. – N°12444, 2009, 376 pages.
MediaWiki efficace. d. b
arrett
. – N°12466, 2009, 372 pages.
Économie du logiciel libre. f. e
lie
. – N°12463, 2009, 195 pages.
Freemind – Boostez votre efficacité. x. d
elengaigne
, p. m
ongin
.
N°12448, 2009, 272 pages.
Spip 2 – Premiers pas pour créer son site avec Spip 2.0.3.
A.-l. Q
uatravaux
, d. Q
uatravaux
. – N°12502, 2009, 300
pages.
Réussir son site web avec XHTML et CSS. m. n
ebra
. –
N°12307, 2
e
édition, 2008, 306 pages.
Réussir un site web d’association… avec des outils libres !
a.-l. Q
uatravaux
et d. Q
uatravaux
. – N°12000, 2
e
édition,
2007, 372 pages.
Réussir son site e-commerce avec osCommerce. d. m
ercer
. –
N°11932, 2007, 446 pages.
Open ERP – Pour une gestion d’entreprise efficace et intégrée.
f. p
inckaers
, g. g
ardiner
. – N°12261, 2008, 276 pages.
PGP/GPG – Assurer la confidentialité de ses mails et fichiers.
m. l
ucas
, ad. par d. g
arance
, contrib. J.-m. t
homas
. –
N°12001, 2006, 248 pages.
Mozilla Thunderbird – Le mail sûr et sans spam. d. g
arance
,
a.-l. et d. Q
uatravaux
. – N°11609, 2005, 300 pages avec
Cd-rom.
Firefox. Retrouvez votre efficacité sur le Web ! t. t
rubacZ
,
préface de t. n
itot
. – N°11604, 2005, 250 pages.
Hackez votre Eee PC – L’ultraportable efficace. c. g
uelff
. –
N°12437, 2009, 306 pages.
Monter son serveur de mails Postfix sous Linux. m. b
äck
et
al., adapté par P. t
onnerre
. – N°11931, 2006, 360 pages.
Ergonomie web – Pour des sites web efficaces.
a. b
oucher
. – N°12479, 2
e
édition 2009, 440 pages.
Joomla et VirtueMart – Réussir sa boutique en ligne.
v. i
saksen
, avec la contribution de t. t
ardif
. – N°12381, 2008,
306 pages.
La 3D libre avec Blender. o. s
araja
. – N°12385, 3
e
édition,
2008, 456 pages avec dVd-rom.
Dessiner ses plans avec QCad – Le DAO pour tous. A. p
ascual

– N°12397, 2009, 278 pages.
Inkscape efficace. c
. g
émy
– N°12425, 2009, 280 pages.
Ubuntu efficace. l. d
ricot
. – N°12362, 3
e
édition, à paraître
2009.
Gimp 2.6 – Débuter en retouche photo et graphisme libre.
d. r
obert
. – N°12480, 4
e
édition, 2009, 350 pages.
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. c
aillau
. –
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 nar d L abat
éditiONS eYrOlleS
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com
le code de la propriété intellectuelle du 1
er
juillet 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
Avant-propos
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 !
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 au gameplay.
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.
Définition
Un programme informatique a pour but d’indiquer à un ordinateur la liste des étapes nécessaires à la réali-
sation d’une tâche. La programmation est le nom donné au processus de création d’un programme.
=Labat FM.book Page V Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la Xbox et le PC
VI
Code intelligible, code machine
Un ordinateur ne comprend que des instructions très simples :
1.Récupérer le contenu d’un emplacement mémoire.
2.Lui appliquer une opération mathématique basique.
3.Déplacer le résultat vers un autre emplacement mémoire.
• En plus de diviser à l’extrême chaque tâche, pour être compris directement par l’ordi-
nateur, 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…
• Ce type 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.
• On distingue 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.
• Il faut 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.Saler l’eau.
2.Porter à ébullition.
3.Plonger les pâtes.
4.Mélanger pour é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.
=Labat FM.book Page VI Vendredi, 19. juin 2009 4:01 16
Avant-propos
VII
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
• Le framework .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.
• 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.
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.
=Labat FM.book Page VII Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la Xbox et le PC
VIII
• Le CLR est une machine virtuelle (bien que Microsoft préfère utiliser le terme runtime)
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.
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.
MSIL
Langage ressemblant à de l’assembleur, MSIL ne comporte aucune instruction propre à un système
d’exploitation ou à du matériel.
Bon à savoir
Soulignons également que le framework XNA est livré avec ce que l’on appelle des Starter Kit. Ces petits
projets de jeu vidéo montrent les possibilités offertes ainsi que le niveau d’accessibilité du développement.
=Labat FM.book Page VIII Vendredi, 19. juin 2009 4:01 16
Avant-propos
IX
Officiellement, XNA ne peut être utilisé qu’avec le langage de programmation C#. 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.
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.
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 compa-
tible .Net, vous aurez besoin d’un EDI (Environnement de Développement Intégré).
Microsoft en propose toute une gamme comprenant :
• Visual Studio Express.
• Visual Studio Standard.
• Visual Studio Professional.
• Visual Studio 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.0 est compatible avec les versions de Visual Studio 2008. 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 !
Version
XNA 3.0 est disponible depuis le 30 octobre 2008, c’est sur cette version que ce livre se focalise.
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.
=Labat FM.book Page IX Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la Xbox et le PC
X
À 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
Le chapitre 1 présente les notions de base du langage de programmation C#, qui vous
seront utiles dès le chapitre 2 à la création d’une première application avec XNA.
Nous attaquerons les choses sérieuses dans le chapitre 3 en apprenant à afficher de
premières images à l’écran puis, dans le chapitre 4, nous apprendrons à récupérer les
entrées utilisateur sur le clavier, la souris ou la manette de la Xbox 360. Ces notions
seront mises en pratique avec la création d’un clone de Pong dans le chapitre 5. Le
chapitre 6 poussera plus loin les fonctions d’affichage d’images dans XNA.
Dans le chapitre 7, vous étofferez votre jeu en lui ajoutant un environnement sonore qu’il
s’agisse des sons ou de morceaux de musique. Puis, dans le chapitre 8, vous découvrirez
les techniques de lecture ou d’écriture de fichiers qui entrent en jeu dans les fonctionnalités
de sauvegarde.
Dans le chapitre 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. Le chapitre 10 abordera également un domaine qui n’est pas propre
à XNA : la gestion de la physique. Nous verrons donc comment implémenter un moteur
physique.
Dans le chapitre 11, le dernier à utiliser des exemples en deux dimensions, vous décou-
vrirez comment créer un jeu multijoueur avec XNA, qu’il s’agisse d’un jeu sur écran
splitté ou en réseau.
Le chapitre 12 propose une introduction à la programmation de jeux en 3D avec XNA.
Pour terminer, dans le chapitre 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 A est consacrée à sa prise en main. L’annexe B vous donne des
=Labat FM.book Page X Vendredi, 19. juin 2009 4:01 16
Avant-propos
XI
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
=Labat FM.book Page XI Vendredi, 19. juin 2009 4:01 16
=Labat FM.book Page XII Vendredi, 19. juin 2009 4:01 16
Table des matières
Avant-propos
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .V
La programmation de jeu vidéo
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .V
Code intelligible, code machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .VI
Les algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .VI
XNA et son environnement
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .VII
Pourquoi choisir XNA ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .VII
Comprendre le framework .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .VII
XNA : faciliter le développement de jeu vidéo . . . . . . . . . . . . . . . . . . . . . . . .VIII
C#, langage de programmation de XNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . .IX
Choisir son environnement de développement intégré . . . . . . . . . . . . . . . . . .IX
À qui s’adresse le livre ?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .X
Structure de l’ouvrage
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .X
Remerciements
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .XI
CHAPITRE 1
Débuter en C#
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
Créez votre premier programme
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
Les types de données
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3
Organisation de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3
Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4
Opérations de base sur les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8
Les instructions de base
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
Commenter son code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
Les conditions : diversifier le cycle de vie des jeux . . . . . . . . . . . . . . . . . . . .11
=Labat FM.book Page XIII Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
XIV
Les fonctions
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14
Différencier fonction et procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15
Écrire une première procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15
Écrire une première fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17
Les classes
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .18
Comprendre les classes et les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .18
Utiliser un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .18
Qu’est ce qu’un espace de noms ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19
Créer une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .20
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .24
CHAPITRE 2
Prise en main de XNA
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25
Télécharger l’EDI et XNA
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25
Partir d’un starter kit
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26
Partager ses projets
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28
L’architecture d’un projet XNA
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29
Structure du framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29
Structure du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30
Créer un projet
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30
S’outiller pour développer sur Xbox 360
. . . . . . . . . . . . . . . . . . . . . . . . . . .33
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34
CHAPITRE 3
Afficher et animer
des images : les sprites
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
Les sprites
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35
Qu’est-ce qu’un sprite ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36
Afficher un sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37
Afficher plusieurs sprites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40
Un sprite en mouvement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41
Une classe pour gérer vos sprites
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45
Créer une classe Sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45
Utiliser la classe Sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47
Classe héritée de Sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50
=Labat FM.book Page XIV Vendredi, 19. juin 2009 4:01 16
Table des matières
XV
Un gestionnaire d’images
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .55
Les boucles en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .55
Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .58
Écriture du gestionnaire d’images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .60
Mesure des performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .63
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
CHAPITRE 4
Interactions avec le joueur
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67
Utiliser les périphériques
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67
Le clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .67
La souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .70
La manette de la Xbox 360 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71
Utilisation de périphériques spécialisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73
Les services avec XNA
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73
Les interfaces en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .74
Comment utiliser les services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .75
Les méthodes génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .77
Toujours plus d’interactions grâce à la GUI
. . . . . . . . . . . . . . . . . . . . . . . .80
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .81
CHAPITRE 5
Cas pratique : programmer un Pong
. . . . . . . . . . . . . . . . . . . . . . . . . . .83
Avant de se lancer dans l’écriture du code
. . . . . . . . . . . . . . . . . . . . . . . . . .83
Définir le principe du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .83
Formaliser en pseudo-code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .84
Développement du jeu
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .85
Création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .85
L’arrière-plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .86
Les raquettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
La balle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91
Améliorer l’intérêt du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .96
=Labat FM.book Page XV Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
XVI
CHAPITRE 6
Enrichir les sprites : textures, défilement, transformation,
animation
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .97
Préparation de votre environnement de travail
. . . . . . . . . . . . . . . . . . . . . .97
Texturer un objet Rectangle
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99
Modifier la classe Sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .100
Faire défiler le décor : le scrolling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105
Créer des animations avec les sprites sheets . . . . . . . . . . . . . . . . . . . . . . . . . .108
Varier la teinte des textures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .112
Opérer des transformations sur un sprite . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116
Afficher du texte avec Spritefont
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .125
Afficher le nombre de FPS
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .130
CHAPITRE 7
La sonorisation
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
Travailler avec XACT
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
Créer un projet sonore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .132
Lire les fichiers créés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .135
Lire les fichiers en streaming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .138
Compression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .139
Ajouter un effet de réverbération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .140
Le son avec la nouvelle API SoundEffect
. . . . . . . . . . . . . . . . . . . . . . . . . . .141
Lire un son . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .141
Lire un morceau de musique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .142
Pour un bon design sonore
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .144
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .144
CHAPITRE 8
Exceptions et gestion des fichiers : sauvegarder
et charger un niveau
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
Le stockage des données
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
Les espaces de stockage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145
Sérialisation et désérialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .148
Les exceptions
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .148
=Labat FM.book Page XVI Vendredi, 19. juin 2009 4:01 16
Table des matières
XVII
Les Gamer Services : interagir avec l’environnement
. . . . . . . . . . . . . . . .152
Dossier de l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .152
Les méthodes asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .154
La GamerCard : la carte d’identité du joueur . . . . . . . . . . . . . . . . . . . . . . . . .158
Version démo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .160
La sauvegarde en pratique : réalisation d’un éditeur de cartes
. . . . . . . .162
Identifier les besoins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .162
Chemin du dossier de jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .168
Gérer les dossiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .169
Manipuler les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .172
Écrire dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .174
Lire un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .176
Sérialiser des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .178
Désérialiser des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .180
Les Content Importers, une solution compatible avec la Xbox 360
. . . .181
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .184
CHAPITRE 9
Pathfinding : programmer les déplacements des personnages
185
Les enjeux de l’intelligence artificielle
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .185
Comprendre le pathfinding
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .186
L’algorithme A* : compromis entre performance et pertinence
. . . . . . .187
Principe de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .187
Implanter l’algorithme dans un jeu de type STR . . . . . . . . . . . . . . . . . . . . . .190
Cas pratique : implémenter le déplacement d’un personnage
sur une carte
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .200
Préparation : identifier et traduire les actions du joueur . . . . . . . . . . . . . . . . .200
Créer le personnage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .201
Implémenter l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .204
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .206
CHAPITRE 10
Collisions et physique : créer un simulateur
de vaisseau spatial
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207
Comment détecter les collisions
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207
Créer les bases du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .208
Établir une zone de collision autour des astéroïdes . . . . . . . . . . . . . . . . . . . . .213
=Labat FM.book Page XVII Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
XVIII
Simuler un environnement spatial : la gestion de la physique
. . . . . . . . .217
Choisir un moteur physique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .217
Télécharger et installer FarseerPhysics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .219
Prise en main du moteur physique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .222
Les collisions avec FarseerPhysics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .227
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .230
CHAPITRE 11
Le mode multijoueur
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231
Jouer à plusieurs sur le même écran
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231
Du mode solo au multijoueur : la gestion des caméras
. . . . . . . . . . . . . . .232
Créer un jeu solo avec effet de scrolling . . . . . . . . . . . . . . . . . . . . . . . . . . . . .232
Adapter les caméras au multijoueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237
Personnaliser les différentes vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .244
Le multijoueur en réseau
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248
S’appuyer sur la plate-forme Live . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248
Implémenter les fonctionnalités de jeu en réseau . . . . . . . . . . . . . . . . . . . . . .249
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257
CHAPITRE 12
Les bases de la programmation 3D
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .259
L’indispensable théorie
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .259
Le système de coordonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .259
Construire des primitives à partir de vertices . . . . . . . . . . . . . . . . . . . . . . . . .260
Les vecteurs dans XNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .262
Les matrices et les transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263
Gérer les effets sous XNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263
Comprendre la projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .264
Dessiner des formes
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
La caméra et la matrice de projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
La matrice de vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .266
Des vertices à la forme à dessiner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .267
Déplacer la caméra
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .277
Appliquer une couleur à un vertex
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .279
=Labat FM.book Page XVIII Vendredi, 19. juin 2009 4:01 16
Table des matières
XIX
Plaquer une texture sur un objet
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281
Texturer une face d’un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281
Texturer un objet entier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285
Déplacer un objet avec les transformations
. . . . . . . . . . . . . . . . . . . . . . . . .291
Jouer avec les lumières
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .294
Les différents types de lumière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .294
Éclairer une scène pas à pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .295
Charger un modèle
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301
CHAPITRE 13
Améliorer le rendu avec le High Level Shader Language
. . . . . .303
Les shaders et XNA
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303
Vertex shaders et pixel shaders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .304
Ajouter un fichier d’effet dans XNA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .305
Syntaxe du langage HLSL
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .306
Les variables HLSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .306
Les structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308
Les fonctions fournies pas le langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308
Sémantiques et structures pour formats d’entrée et de sortie . . . . . . . . . . . . .308
Écrire un vertex shader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .309
Écrire un pixel shader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310
Finaliser un effet : les techniques et les passes . . . . . . . . . . . . . . . . . . . . . . . .310
Créer le fichier d’effet
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310
Faire onduler les objets
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .314
La texture en négatif
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315
Jouer avec la netteté d’une texture
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315
Flouter une texture
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .316
Modifier les couleurs d’une texture
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .318
En résumé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .319
CHAPITRE A
Visual C# Express 2008
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .321
Différencier solution et projet
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .321
Personnaliser l’interface
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .323
=Labat FM.book Page XIX Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
XX
L’éditeur de texte
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324
Les extraits de code
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326
Refactoriser
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327
Déboguer une application
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328
Raccourcis clavier utiles
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .330
CHAPITRE B
Les bienfaits de la documentation
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .331
L’incontournable MSDN
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331
Ressources sur le Web
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .333
Générer de la documentation
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .334
Index
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .337
=Labat FM.book Page XX Vendredi, 19. juin 2009 4:01 16
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).
=Labat FM.book Page 1 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
2
Figure 1-1
Accueil de Microsoft Visual C# Express 2008
Figure 1-2
Création
d’un nouveau projet
=Labat FM.book Page 2 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
3
Le logiciel a automatiquement généré le code suivant dans un fichier
Program.cs
:
using System;
using System.Collections.Generic;
using System.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.
=Labat FM.book Page 3 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
4
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.
Une variable se déclare de la façon suivante :
type identificateur;
Par exemple, pour déclarer une variable entière correspondant au nombre de vies restan-
tes de joueur, il faut procéder de la manière suivante :
short nombreDeVies;
Il faut respecter certaines règles dans le nommage des identificateurs :
• Vous devez faire attention à ce que le premier caractère soit une lettre majuscule ou
minuscule ou un underscore (_).
• Pour tous les autres caractères, vous pouvez utiliser soit une lettre majuscule ou
minuscule, soit un underscore ou 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
{
Tableau 1-1 Les types entiers
Type
Stockage
Valeur minimale
Valeur maximale
Byte
1 octet 0 255
Short
2 octets – 32768 32767
Int
4 octets – 2
31
2
31
-1
Long
8 octets – 9.2
¥
10
18
9.2
¥
10
18
=Labat FM.book Page 4 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
5
static void Main(string[] args)
{
short nombreDeVies;
Console.WriteLine(nombreDeVies);
}
}
}
Dans ce programme, une variable de type
short
est déclarée

et son contenu s’affiche dans
la console.
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.
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)
{
short nombreDeVies;
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 ligne
Console.Read();
qui n’é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.
Figure 1-3
La compilation du programme a échoué
=Labat FM.book Page 5 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
6
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
true
ou
false
. 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.
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 types
float
et
double
, 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();
}
}
}
Tableau 1-2 Les types réels
Type
Stockage
Valeur minimale
Valeur maximale
float
4 octets 1.4
¥
10
–45
3.4
¥
10
38
double
8 octets 4.9
¥
10
–324
1.8
¥
10
308
decimal
16 octets 8
¥
10
–28
8
¥
10
28
=Labat FM.book Page 6 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
7
Le mot-clé
while
correspond à une structure algorithmique que nous étudierons plus tard.
Ce programme utilise une variable
total
de type
double
et l’initialise à 0. Tant que la
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 de
total
et déclarez plutôt la variable en tant que
decimal
.
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 type
decimal
prend plus de place en mémoire que les types
float
et
double
, 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 type
char
. 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)
{
=Labat FM.book Page 7 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
8
char lettre = '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 type
char
ne 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)
{
string chaine = "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# :
=Labat FM.book Page 8 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
9
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)
{
int A = 6;
int B = 3;
Console.WriteLine(A + B);
Console.WriteLine(A - B);
Console.WriteLine(A * B);
Console.WriteLine(A / B);
Console.WriteLine(A % B);
Console.ReadLine();
}
}
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;
Tableau 1-3 Opérateurs de base du langage
Opération
Description
A + B
Addition de A et de B
A – B
Soustraction de B à A
A * B
Multiplication de A par B
A / B
Division de A par B
A % B
Reste de la division de A par B
Figure 1-4
Test des opérations arithmétiques
=Labat FM.book Page 9 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
10
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++;
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(A++);
Console.WriteLine(++A);
Console.WriteLine(A--);
Console.WriteLine(--A);
Console.ReadLine();
}
}
}
Tableau 1-4 Opérateurs d’incrémentation et de décrémentation
Opération
Description
A++
Post-incrémentation de A
++A
Pré-incrémentation de A
A--
Post-décrémentation de A
--A
Pré-décrémentation de A
Figure 1-5
Incrémentation et décrémentation
=Labat FM.book Page 10 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
11
Les instructions de base
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!");
=Labat FM.book Page 11 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
12
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)
{
short nombreDeVies = 1;
if (nombreDeVies == 0)
Console.WriteLine("Vous êtes mort");
nombreDeVies--;
if (nombreDeVies == 0)
Console.WriteLine("Vous êtes mort");
Console.ReadLine();
}
}
}
Voici la liste des opérateurs conditionnels :
Si le test n’est pas concluant, il est possible d’effectuer d’autres actions.
SI CONDITION EST VRAIE
ALORS FAIRE…
SINON FAIRE…
FIN SI
En C#, l’instruction correspondant au terme
SINON
est l’instruction
else
. Compilez le
programme suivant pour tester cette notion.
Tableau 1-5 Opérateurs conditionnels
Opérateur
Description
==
Test d’égalité
!=
Test de différence
>
Strictement supérieur
>=
Supérieur ou égal
<
Strictement inférieur
<=
Inférieur ou égal
=Labat FM.book Page 12 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
13
short nombreDeVies = 1;
if (nombreDeVies == 0)
Console.WriteLine("Vous êtes mort");
else
Console.WriteLine("Vous êtes encore en vie !");
Il est possible d’ajouter un nombre infini de conditions. Ceci donne le code suivant :
SI CONDITION EST VRAIE
ALORS FAIRE…
SINON SI CONDITION EST VRAIE FAIRE…
SINON FAIRE…
FIN SI
Tout ceci se traduit en C# par
else if
. Voici un nouvel exemple :
short nombreDeVies = 1;
if (nombreDeVies == 0)
Console.WriteLine("Vous êtes mort");
else if (nombreDeVies == 1)
Console.WriteLine("Vous êtes bientôt mort...");
else
Console.WriteLine("Vous êtes encore en vie !");
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)
{
string genre;
Console.WriteLine("Entrez votre genre (M/F) :");
genre = Console.ReadLine();
if (genre == "M")
Console.WriteLine("C'est noté Monsieur !");
else if (genre == "F")
Console.WriteLine("Bonjour Mademoiselle...");
else
Console.WriteLine("Oh... C'est vrai ?");
Console.ReadLine();
}
}
}
=Labat FM.book Page 13 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
14
Vous pouvez combiner plusieurs tests à la fois grâce aux opérateurs logiques.
Ces opérateurs vous permettent de factoriser votre code. Ainsi le test suivant…
if(A > B)
if(A > C)
Console.WriteLine("A est le plus grand.");
… peut s’écrire de cette manière :
if(A > B && A > C)
Console.WriteLine("A est le plus grand.");
Dans l’exemple suivant, l’opérateur
Not
donne raison à Jimi Hendrix en inversant le résultat
d’un test.
if(!(6 == 9))
Console.WriteLine("If 6 was 9");
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.
Figure 1-6
Vos programmes se compliquent…
Tableau 1-6 Opérateurs logiques
Opérateur
Description
&&
Et
||
Ou
!
Non
=Labat FM.book Page 14 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
15
Différencier fonction et procédure
Vous ne pouvez pas écrire tout un programme ou tout un jeu, même s’il contient peu de
lignes de codes, dans le même fichier : cela serait illisible et impossible à maintenir. Vous
feriez mieux d’utiliser les fonctions et les procédures.
Une fonction exécute certaines actions (des calculs, de l’extraction de données, etc.), puis
renvoie un résultat. Par exemple, la fonction
Carre()
attend un nombre en argument, et
renvoie ce même nombre élevé au carré. Dans un jeu, vous pourriez avoir une fonction
GetFriends()
qui retournerait la liste des amis de votre personnage.
Contrairement à une fonction, une procédure ne retournera pas de résultat. Ainsi, la
procédure
AfficherMenu()
affichera un menu dans la console, mais ne retournera pas de
valeur. Dans votre jeu, la procédure
Draw()
contient les mécanismes de dessin de votre
jeu, mais ne retourne pas de valeur.
Utiliser une fonction ou une procédure vous permet de gagner du temps en factorisant
le nombre de lignes de code que vous écrivez. De plus, créer des fonctions ou des procé-
dures offre l’avantage non négligeable d’écrire du code réutilisable. Ainsi, au fur et à
mesure de vos projets, vous vous construirez une véritable bibliothèque de « briques »
réutilisables.
Écrire une première procédure
Tout d’abord, sachez que jusqu’ici vous avez déjà utilisé plusieurs procédures, peut-être
à votre insu si ce livre constitue votre première expérience de programmation.
L’extrait de code ci-dessous comporte la fonction principale d’un programme. Si vous
l’exécutez, le message « Bonjour »s’affiche dans la console, puis dès que vous appuyez
sur une touche, la console se ferme.
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Bonjour");
Console.ReadLine();
}
}
}
Dans cette petite portion de code se cachent deux procédures. La procédure
Main
, que
vous définissez et la procédure
WriteLine
, que vous appelez.
En pratique
Main est le point d’entrée de l’application : c’est ici que tout commence.
=Labat FM.book Page 15 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
16
Appeler une procédure se fait donc très simplement, il suffit d’écrire son nom, et si
besoin, de lui passer des arguments. Dans l’exemple précédent, vous appelez
WriteLine
en lui passant une variable de type
string
, qui correspond au texte à afficher dans la
console.
Il est temps d’écrire votre première procédure. Celle-ci servira à afficher quelques lignes
de Lorem Ipsum (faux texte bien connu des développeurs web).
La déclaration d’une procédure se fait de la manière suivante :
Void NomDeLaProcedure(typeA argumentA, ...)
{
}
Le mot-clé
void
signifie qu’il n’y a pas de valeur en retour, ce qui correspond bien à la
définition d’une procédure.
Le nom d’une procédure est régi par les mêmes règles qui s’appliquent aux noms de
variables. Le nombre d’arguments à passer à la fonction dépend bien évidemment de vos
besoins. Sachez qu’il est également possible de passer les arguments par référence plutôt
que par valeur. Pour l’instant tous les passages que nous allons voir se font par valeur
(nous aborderons les autres plus tard).
Dernière règle à respecter lors de la déclaration d’une procédure : son corps doit être
entouré de deux accolades ouvrante « { » et fermante « } ».
Voici donc la définition et, bien sûr, l’appel de cette première procédure :
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
AfficherLoremIpsum();
Console.ReadLine();
}
static void AfficherLoremIpsum()
{
Console.WriteLine("Lorem ipsum dolor sit amet, consectetuer adipiscing


elit.");
Console.WriteLine("Aliquam pretium, leo non scelerisque porttitor,


tellus turpis feugiat lacus, sed ullamcorper nisl felis non nibh.");
Console.WriteLine("Fusce posuere mollis justo.");
}
}
}
=Labat FM.book Page 16 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
17
Écrire une première fonction
Depuis le début de la lecture de ce livre, vous utilisez la fonction
ReadLine
. Celle-ci lit
l’entrée clavier et renvoie une chaîne de caractères. Il est donc possible d’imaginer sa
définition :
string ReadLine()
{
// ...
return valeur;
}
Les règles pour la définition d’une fonction sont les mêmes que celles qui s’appliquent
aux procédures, sauf pour le type. En effet, vous n’êtes pas restreint au type
void
, mais
vous pouvez utiliser celui que vous voulez.
Le code suivant contient la définition d’une fonction qui renvoie la valeur absolue d’un
nombre passé en argument, ainsi que l’utilisation de cette fonction :
namespace PremierProgramme
{
class Program
{
static int ValeurAbsolue(int number)
{
if (number < 0)
return -number;
else
return number;
}
static void Main(string[] args)
{
int a = ValeurAbsolue(-45);
Console.WriteLine(a);
Console.WriteLine(ValeurAbsolue(5));
Console.ReadLine();
}
}
}
Cet exemple n’a de but autre que pédagogique. Sachez que plusieurs milliers de fonctions
sont fournies par le framework .NET, répondant à des besoins extrêmement variés. Vous
Renvoi
Remarquez la présence du mot-clé
static
devant
void
. Nous reviendrons sur la signification de ce mot-
clé dans la section « Créer une classe » de ce chapitre.
=Labat FM.book Page 17 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
18
avez également la possibilité de vous procurer des fonctions spécifiques sur l’Internet ou
bien de créer les vôtres et les communiquer à d’autres développeurs.
Lorsque vous utilisez une procédure ou bien une fonction, Visual Studio vous fournit des
informations sur le type de la fonction ou les paramètres attendus (figure 1-7).
Les classes
Piliers du C# et donc de XNA, les classes et les objets sont indispensables dans la création
de n’importe quel programme : chaque programme écrit en C# (qu’il s’agisse d’un jeu,
d’une application Windows, d’une application console, etc.) en possède au moins une.
Dans cette section, nous nous intéresserons tout d’abord à la différence entre une classe et
un objet. Nous pourrons alors voir comment utiliser un objet, et enfin, écrire votre première
classe.
Comprendre les classes et les objets
Avant de nous lancer dans les aspects techniques, il est nécessaire de bien cerner les
notions de classes et d’objets.
Pour prendre un exemple concret, une classe est comparable à une recette de gâteau et un
objet à un gâteau. En somme, en réalisant un gâteau, vous avez donné vie à votre recette.
En programmation orientée objet (POO), l’objet gâteau est alors qualifié d’instance de la
classe recette de gâteau.
Un objet possède des propriétés et des méthodes (il peut s’agir de fonctions ou de procé-
dures). Le tableau ci-dessous liste celles d’un objet instancié à partir de la classe Homme.
Utiliser un objet
Vous avez déjà utilisé des objets sans le savoir. Derrière les types de données que nous
avons vus précédemment se cachent des classes. Ainsi, pour déclarer une chaîne de
caractères, il est également possible d’écrire :
String chaine = "Test";
Figure 1-7
Visual Studio sait se rendre très utile
Tableau 1-7 Différence entre propriétés et méthodes
Propriétés
Méthodes
Taille, force, agilité, etc.Marcher, boire, se défendre, etc.
=Labat FM.book Page 18 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
19
String
(avec un S majuscule) correspond donc à la classe.
Les propriétés et méthodes d’un objet
String
sont visibles en inscrivant un point (
.
), puis
en choisissant ce à quoi vous voulez accéder.
Console.WriteLine(chaine.Length); // Longueur de la chaîne
Console.WriteLine(chaine.Substring(1, 2)); // Sous-chaîne commençant à la position 1

et d'une longueur de 2 caractères
Dans le framework .Net, un grand nombre de classes est disponible et répondront à bon
nombre de vos besoins :
File
pour la gestion de fichiers,
Directory
pour la gestion de
répertoire,
Socket
pour les communications réseaux, etc. Prenons, par exemple, la classe
TimeSpan
, qui représente un intervalle de temps :
TimeSpan time = new TimeSpan(26, 14, 30, 10);
Console.WriteLine(time.ToString());
L’initialisation d’un objet se fait via le mot-clé
new
, qui appelle le constructeur de la
classe
TimeSpan
. Un constructeur est une fonction un peu spéciale, nous y reviendrons lors
de la création de votre première classe.
Qu’est ce qu’un espace de noms ?
Un espace de noms (
namespace)
organise les classes de manière logique : tout comme les
répertoires permettent de classer les fichiers, les espaces de noms servent à organiser les
classes.
Ainsi, il ne peut y avoir deux classes du même nom dans le même espace de noms.
Cependant, deux classes peuvent tout à fait porter le même nom si elles ne sont pas dans
le même espace.
La directive
using
sert à définir des alias pour rendre plus facile l’identification des espaces
de noms ou des classes. Elle permet aussi d’accéder à des types sans avoir à préciser à
chaque fois l’espace auquel elles appartiennent.
Cas particulier
Si vous parcourez un peu les classes fournies par le framework (en utilisant IntelliSense, reportez-vous
l’annexe A pour plus de détails), vous découvrirez sûrement la classe
Math
, qui est un peu spéciale. En
effet, la création d’un objet de type
Math
est impossible. En fait, cette classe est statique, c'est-à-dire
qu’elle n’est pas instanciable. Cependant, elle possède tout de même des propriétés et des méthodes,
elles aussi statiques, qui sont accessibles de la manière suivante :
Console.WriteLine(Math.PI);
Console.WriteLine(Math.Abs(-15));
=Labat FM.book Page 19 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
20
Analysons le programme suivant :
using System;
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(Math.PI);
Console.ReadLine();
}
}
}
La classe
Math
et la classe
Console
sont contenues dans l’espace de noms
System
. Si nous
supprimions la ligne qui contient la directive
using
, le programme ne pourrait plus être
compilé puisqu’il ne saurait plus à quoi correspondent les noms
Math
et
Console
. Il
faudrait donc le récrire de la manière suivante :
System.Console.WriteLine(System.Math.PI);
System.Console.ReadLine();
Le code ci-dessous présente la directive
using
dans la définition d’alias.
using A = System.Console;
using B = System.Math;
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
A.WriteLine(B.PI);
A.ReadLine();
}
}
}
Créer une classe
Il est temps à présent d’écrire une première classe. Cliquez sur Projet, puis sur Ajouter
une classe. Nommez le fichier
Humain.cs
(figure 1-8).
=Labat FM.book Page 20 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
21
Voici le code de base généré par Visual Studio :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PremierProgramme
{
class Humain
{
}
}
Nous reconnaissons la syntaxe de déclaration d’une classe. Vous notez également que
toute classe doit être contenue dans un espace de noms. Ici, l’espace de noms correspond
au nom de notre projet.
L’une des choses les plus importantes dans la création d’une classe est la notion d’encap-
sulation. Derrière ce terme, se cache la notion de droits d’accès aux éléments d’une classe.
Figure 1-8
Création d’une nouvelle classe
Tableau 1-8 Visibilité d’un élément
Droit
Description
Public
Accessible depuis l’extérieur de l’objet
Private
Accès restreint à l’objet
=Labat FM.book Page 21 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
22
Il existe d’autres mots-clés pour les droits d’accès que vous rencontrerez dès le chapitre 2.
Si vous ne précisez aucun mot-clé, la valeur par défaut est
private
.
Rappelez-vous, nous avons vu précédemment que pour pouvoir instancier un objet, une
classe doit posséder un constructeur. Un constructeur a la syntaxe suivante :
droit NomDeLaClasse(typeA argumentA, ...)
{
}
Pour que le constructeur soit accessible, il faut donc le déclarer en temps que
public
.
namespace PremierProgramme
{
class Humain
{
public Humain()
{
}
}
}
Il est dès maintenant possible de créer un objet en instanciant la classe Humain. Ouvrez
le fichier
Program.cs
et procédez aux modifications nécessaires.
static void Main(string[] args)
{
Humain heros = new Humain();
Console.ReadLine();
}
Il est temps de rendre les choses un peu plus excitantes et de donner un nom à votre humain,
ainsi que la possibilité de se présenter. Ajoutez donc un champ à notre classe Humain,
mais ne le déclarez pas
public
.
C# fournit un mécanisme très souple pour la lecture (
get
) ou l’écriture (
set
) dans les
champs d’une classe. Ce mécanisme relève des propriétés, et en voici la syntaxe :
public type Nom
{
get { return variable; }
Thème avancé
Les classes partielles sont des classes dont la définition est fractionnée entre plusieurs fichiers. Pour créer
une telle classe, il faut utiliser le mot-clé
partial
:
Public partial class ClassTest
{
}
Depuis l’arrivée du framework .Net 2.0, le designer d’interface de Visual Studio utilise les classes partielles
pour séparer le code qu’il génère de celui que vous écrivez.
=Labat FM.book Page 22 Vendredi, 19. juin 2009 4:01 16
Débuter en C#
C
HAPITRE
1
23
set { variable = value; }
}
Mais, pour appliquer ce concept à notre cas d’étude, il faut rester logique. En effet,
implémenter l’opérateur d’écriture n’est peut être pas nécessaire puisqu’il est très rare
qu’un humain puisse changer de nom.
public string Nom
{
get { return nom; }
}
Dernière chose à faire, le nom du personnage doit lui être attribué à sa création. Il faut
donc ajouter un argument au constructeur et initialiser le champ.
public Humain(string nom)
{
this.nom = nom;
}
Un problème se pose ici. En effet, le nom de l’argument attendu par le constructeur (
nom
)
est le même que le nom du champ à initialiser. Dans ce cas, l’usage du mot-clé
this
permet alors de désigner l’instance courante de la classe, et ainsi accéder au champ
nom
et
pas à l’attribut du constructeur.
Si, à ce stade, vous essayez de compiler le programme, vous obtiendrez une erreur :
'PremierProgramme.Humain' ne contient pas de constructeur qui accepte des arguments

'0'
En effet, votre constructeur attend un argument. Or vous ne lui en passez aucun lors de la
création de votre objet. Retournez donc dans le fichier
Program.cs
et modifiez la ligne
comme bon vous semble.
Humain heros = new Humain("Moi");
Vous pouvez afficher le nom de notre humain en utilisant la propriété que vous avez définie
plus tôt :
Console.WriteLine(heros.Nom);
Pour finir, écrivez une méthode appelée « SePresenter » à la classe
Humain
. Elle a pour
fonction d’afficher une petite phrase de présentation dans la console. Puis, utilisez-la
dans la fonction
Main
. Voici ci-dessous le code source final de votre classe.
Humain.cs
namespace PremierProgramme
{
class Humain
{
string nom;
public string Nom
{
=Labat FM.book Page 23 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
24
get { return nom; }
}
public Humain(string nom)
{
this.nom = nom;
}
public void SePresenter()
{
System.Console.WriteLine("Bonjour, je m'appelle " + nom);
}
}
}
Program.cs
using System;
namespace PremierProgramme
{
class Program
{
static void Main(string[] args)
{
Humain heros = new Humain("Moi");
heros.SePresenter();
Console.ReadLine();
}
}
}
En résumé
Vous disposez à présent du bagage de connaissances nécessaires à la compréhension des
bases de XNA, à savoir :
• choix et utilisation de types de données ;
• écriture de structures conditionnelles ;
• écriture et utilisation de fonctions ou de procédures ;
• compréhension des bases de la programmation orientée objet, des classes et des objets.
Dans le chapitre suivant, vous allez appliquer les notions que nous venons de voir, et
vous ferez vos premiers pas dans l’univers de la création de jeu.
En pratique
L’opérateur
+
sert à concaténer plusieurs chaînes de caractères.
=Labat FM.book Page 24 Vendredi, 19. juin 2009 4:01 16
2
Prise en main de XNA
Connaissez-vous réellement les possibilités qu’offre le framework XNA ? Ce chapitre les
présente afin que vous vous rendiez compte de quoi vous serez capable après quelques
heures de pratique avec XNA.
Après avoir lu ce premier chapitre, vous serez en mesure de créer votre premier projet, de
comprendre les différents éléments qui le composent et de le déployer sur une Xbox 360.
Télécharger l’EDI et XNA
Si l’EDI Microsoft Visual C# Express 2008 et le framework ne sont pas déjà sur votre
ordinateur, voici la procédure à suivre pour vous en équiper :
1.Téléchargez Microsoft Visual C# Express 2008 en vous rendant à cette adresse :
http://www.microsoft.com/express/download/
Figure 2-1
Téléchargement de Microsoft
Visual C# Express 2008
=Labat FM.book Page 25 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
26
2.Une fois le fichier téléchargé, exécutez-le pour démarrer l’installation.
3.Il ne reste plus qu’à télécharger et installer XNA en vous rendant sur le site officiel à
cette adresse :
http://creators.xna.com/en-us/xnags_islive
Partir d’un starter kit
En général, les starter kits sont des projets de jeux prêts à l’emploi et à compiler. Ils sont
faciles à modifier et constituent une bonne base pour vos projets : vous pouvez analyser
leur code source, en utiliser une partie dans vos jeux et le modifier.
Penchons-nous sur celui livré avec XNA 3.0 :
1.Ouvrez Visual Studio.
2.Cliquez sur Fichier puis Nouveau projet.
3.Dans la section XNA Game Studio 3.0, sélectionnez Platformer Starter Kit (3.0).
4.Validez.
Dans l’explorateur de solutions situé à droite de l’écran, vous trouvez trois projets : un
pour Windows, un pour la Xbox 360 et le dernier pour Zune.
Figure 2-2
Création d’un projet basé sur un starter kit
=Labat FM.book Page 26 Vendredi, 19. juin 2009 4:01 16
Prise en main de XNA
C
HAPITRE
2
27
Appuyez sur F5 pour lancer la compilation du projet sélectionné par défaut (ici, le projet
Platformer).
Le petit jeu qui s’ouvre alors est un bon exemple de ce que vous pouvez facilement réaliser
avec XNA : afficher des graphismes, déclencher des sons et enchaîner plusieurs niveaux.
D’autres starter kits sont disponibles et téléchargeables sur le site Internet de la commu-
nauté d’XNA :
http://creators.xna.com/en-US/education/starterkits/
Jeux de rôles, shoot’em up, jeux de course et puzzles : il suffit de jeter un œil à la liste des
kits pour voir que les possibilités de créations avec XNA sont presque illimitées !
Nous vous conseillons de prendre le temps d’explorer plus en détail les kits, et notamment
de regarder leur code. Vous reconnaîtrez sûrement les facettes du langage abordées dans le
chapitre précédent, mais certaines parties du code vous sembleront au contraire obscures :
ceci est tout à fait normal pour le moment. Cependant, revenir sur les kits plus tard peut
Zune
Zune est le lecteur multimédia de Microsoft, concurrent de l’iPod d’Apple. Depuis la version 3.0 d’XNA, il
est possible de développer des jeux sur cette plate-forme.
Toutefois, sachez qu’à l’heure où nous écrivons ces lignes, Zune est commercialisé uniquement aux États-
Unis et qu’aucune date officielle n’a été annoncée pour une éventuelle apparition sur le marché français.
Figure 2-3
Le jeu est agréable à jouer.
=Labat FM.book Page 27 Vendredi, 19. juin 2009 4:01 16
Développement XNA pour la XBox et le PC
28
être intéressant et très instructif, ne serait-ce que pour comparer vos méthodes de
programmation avec celle d’un autre développeur, ou encore pour savoir comment telle
ou telle partie du jeu a été réalisée.
Partager ses projets
Les starter kits restent des projets assez simples et leur vocation est essentiellement
didactique. La plupart d’entre eux sont basés sur des jeux en 2D. Mais rassurez-vous, il
est tout à fait possible de réaliser des jeux en 3D avec XNA.
Pour vous en convaincre, il vous suffit de faire un petit tour sur le site de la communauté
(
http://creators.xna.com/en-US/
) et de vous intéresser aux projets des autres membres. En
effet, sur ce site, vous pourrez parcourir le catalogue des jeux développés par des amateurs,
des développeurs patentés, voire des studios indépendants. Vous pourrez également
visualiser des vidéos de présentation et même en acheter certains.
Nous conseillons vivement de vous y inscrire et de participer aux forums de discussion,
car c’est le meilleur endroit pour obtenir de l’aide sur XNA et, d’une manière générale,
sur la programmation de jeux.
Figure 2-4
Le catalogue de jeux disponible sur le site de la communauté
=Labat FM.book Page 28 Vendredi, 19. juin 2009 4:01 16
Prise en main de XNA
C
HAPITRE
2
29
Vous aurez sûrement envie de partager vos projets. Ceci est intéressant à plusieurs titres :
vous pourrez ainsi présenter vos créations à vos amis, mais surtout, vous récolterez par ce