Embed Size (px)
Citation preview
DAICHA Adil ROBINET Rémi
RAPPORT DE PROJET TUTORE
Formation : Licence informatique (L3) Enseignant Tuteur: M. DADEAU Frédéric Années : 2008-2009
2
3
REMERCIEMENTS
A,
- Mr MITSURU Furuta, (maître de conférences chez Microsoft France et en charge
des relations techniques avec les développeurs au sein de la division .Net), pour sa
disponibilité, malgré ses lourdes occupations.
- Mr LEBRUN Thomas, (auteur de l’excellent ouvrage « WPF par la pratique »), pour
sa disponibilité à toute épreuve sur le forum de developpez.net.
- Mr DADEAU Fréderic, (professeur et Maître de conférences à l’université de
Franche-Comté), pour nous avoir soutenus tout au long de notre projet.
- Mr HUFFLEN Jean-Michel, (professeur et Maître de conférences à l’université de
Franche-Comté), pour avoir accepté notre proposition de projet.
4
SOMMAIRE
I. INTRODUCTION.............................................. 5
II. PRESENTATION DU LANGAGE ........................ 6
III. PRESENTATION DE L’APPLICATION .............. 20
IV. CONCLUSION ............................................... 34
V. REFERENCES ................................................. 35
VI. GLOSSAIRE ................................................... 36
VII. TABLE DES MATIERES ................................... 38
5
I. INTRODUCTION Dans le monde de l’informatique, la théorie et la pratique ne peuvent coexister
l’une sans l’autre. Pour permettre aux étudiants de concrétiser les connaissances théoriques et pratiques enseignées par l’université, la 3ème année de licence générale d’informatique propose la création d’un projet d’une durée d’environ 3 mois.
Un des principaux buts de ce projet est de préparer les étudiants à leur stage de 3ème année. En effet, le projet donne lieu à la rédaction de ce présent rapport, et ainsi qu’à une soutenance notée.
Ce projet peut être proposé par l’enseignant ou par l’élève lui-même, si celui-ci est jugé conforme à ce que l’on attend d’un projet de licence.
Ce présent rapport de projet tutoré traite de l’étude d’un concept (théorie
appliquée à un/plusieurs langage(s) informatique) de programmation initié par Microsoft à travers la création d’un jeu (Pacman).
Il s’adresse plus particulièrement aux personnes ayant des connaissances en programmation. Cela dit, il peut quand même être lu par une personne novice en la matière.
Ce concept, nommé Windows Presentation Foundation (WPF) sera étudié tout
d’abord avec les différents outils et langages de développement que nous avons utilisés, ensuite nous verrons l’utilisation de ces langages à travers un jeu (Pacman « évolué ») que nous avons développé, avant de donner nos impressions finales sur ce concept.
6
II. PRESENTATION DU LANGAGE
1) Explications sur le choix du langage
Les langages informatiques sont nombreux et sensiblement différents les uns des autres. A l’université, nous essayons de voir les langages principalement utilisés sur linux et Windows, cela dit, aucune formation portant sur les langages et concepts propres à Microsoft n’existe avant le master (et pour le moment, WPF n’est à l’étude que dans de rares écoles prestigieuses). De nombreuses entreprises demandant des compétences en la matière, il nous a semblé important de nous pencher sur les technologies du monde de Microsoft.
En effet, WPF étant un concept très récent, beaucoup d’entreprises ont du mal à faire migrer (voir à tout refaire) leurs logiciels en WPF. Celles-ci sont donc fortement intéressées par des informaticiens « maîtrisant » ce concept. Posséder une référence à ce langage sur un CV devient donc de plus en plus important, car celui-ci est prévu pour durer plusieurs années !
Mais qu’est-ce que signifie WPF ?
2) WPF
a. Description
Windows Presentation Foundation (WPF) est nouvelle norme graphique de Microsoft .NET 3.0 (cf. d.). Il intègre le langage descriptif XAML qui permet de l'utiliser d'une manière proche d'une page HTML pour les non développeurs. Il permet notamment une excellente séparation entre le graphisme d’une application et sa logique. WPF est le fruit de nombreuses années de travail, et a été mené parallèlement au développement de Windows Vista.
Ce langage est une surcouche de DirectX, principalement utilisé pour la construction
d’interfaces utilisateurs. Il est entièrement vectoriel, ce qui permet d’augmenter la taille des objets sans effet de pixellisation, lors d’un redimensionnement de fenêtre par exemple.
7
IMAGE 1 : SCHEMA DES COUCHES DE WPF
- Kernel représente le noyau du système d’exploitation.
- User32 est un composant de gestion de thread et de messages entre processus.
- DirectX est une collection de bibliothèque pour Windows destinée à des usages
multimédia.
- Milcore est le seul composant WPF non managé (écrit en c++ natif). Il permet
notamment une très forte interaction entre Directx et WPF. Rappelons que milcore
est un des composants à la base du système d’affichage graphique de Windows
Vista
- La CLR (Common Language Runtime) désigne le composant de la machine virtuelle
.net (cf. d.)
- PresentationCore est une assembly (cf. glossaire) qui contient les fonctions
fondamentales de WPF.
- PresentationFramework est une assembly qui contient les spécifications propres
au langage XAML avec leur équivalence en langage .NET (C#, Visual basic, J#)
= Composants propres à WPF
= Composants intégré à Windows
8
b. Xaml
Le langage XAML (eXtensible Application Markup Language) est un langage déclaratif créé initialement pour la conception d’interfaces graphiques, mais il est aujourd’hui utilisé similairement au langage XML pour l’initialisation et certaines interactions d’objets.
Il est basé sur le langage XML pour permettre au développeur de développer une application client Windows d’une manière assez similaire à une application WEB. Le langage XAML permet également la manipulation d’objets graphiques vectoriels en 2D/3D.
Le XAML est très apprécié, car il permet de séparer le code de logique (fonctionnement du programme), de la couche de présentation (partie graphique de l’application.
c. C#
Le C# est un langage de programmation orienté objet à typage fort, créé par la société Microsoft et principalement par un de ses employés, déjà créateur du langage Delphi et du TurboPascal.
Ce langage a été créé afin que la plateforme Microsoft.NET puisse disposer d’un
langage permettant d’utiliser ses capacités au maximum. Il est syntaxiquement très proche de Java et par certains aspects, il est proche également de C/C++ (il est possible de surcharger des opérateurs, par exemple). Le C# permet de simplifier au maximum le code pour le rendre facilement lisible : on se débarrasse du superflu, tels que les fichiers d’entête (.h) et l’on compte sur la puissance de l’environnement de développement (voir II.4) pour clarifier l’affichage.
C# fonctionne également à l’aide d’une machine virtuelle, appelée Common
Language Runtime (CLR), de la même manière (bien plus rapidement même) que Java fonctionne avec la Java Virtual Machine (JVM). Cela dit, en interne, Microsoft travaille avec certaines versions natives de C#, qui sont cependant assez dures à compiler et, contrairement aux idées reçues, pas forcément plus rapides.
Il existe également des différences entre C# et les autres langages auxquels il
ressemble. Par exemple, le programmeur ne peut pas détruire explicitement des objets (du moins de manière simple), le ramasse-miettes (garbage collector) s’occupe de détruire les objets lors qu’il n’existe plus aucune référence pointant sur ces objets. On peut cela dit forcer la destruction de certains objets via l’implémentation d’une interface (nommée Idisposable).
Il existe d’autres différences syntaxiques et conceptuelles, elles sont nombreuses,
mais la documentation officielle de c# à l’avantage d’être ultra complète et facile d’utilisation (cf. bibliographie).
9
Exemple : Déclaration d’une propriété CLR (attribut évolué): public double PositionX // Propriété du déplacement horizontal du Pacman
{
get { return Canvas.GetLeft(this); }
set { Canvas.SetLeft(this, value);}
}
Comme le montre l’exemple ci-dessus, il est possible en C# de déclarer directement les accesseurs dans la déclaration des attributs. Cela simplifie énormément la lecture du code (on peut donc mettre directement l’attribut en public comme celui-ci est contrôlé).
d. .net 3.5
Microsoft.net est une technologie Microsoft comprenant un Framework et des outils d’exécution (machine virtuel, compilateurs). Le but de .net est de réunifier différents langage (C#, c++, J# et Visual basic) pour programmer une même application.
De plus comme .net est sur une machine virtuelle, il est censé pouvoir fonctionner
sur tous les systèmes d’exploitation, et son débogage en est grandement facilité (possibilité de traçage d’exécution précis). Cela dit, le fait de fonctionner sur une machine virtuelle peut créer des problèmes de sécurité, c’est pourquoi des éléments de .net sont dits managés (c’est-à-dire que ce sont des méthodes préprogrammées qui sont dites « safe », c'est-à-dire sécurisées).
Microsoft a ouvert les spécifications et les sources de .net via un accord avec Novell.
Le projet Mono s’occupe actuellement de porter la compatibilité sous les systèmes Unix. Cela dit, celui-ci souffre d’un retard de développement de 5 ans environ. En effet adapter .net ne s’avère pas facile du tout.
.net 3.5 et une évolution de .net 3.0 (introduit WPF avec Microsoft Windows Vista)
qui corrige nombre de défauts de la version 3. Cela dit, le projet Mono ne se penche pas encore sur .net 3, car son implémentation s’avère extrêmement compliquée (.net 3.0 est quand même le fruit de 5 ans de recherche chez Microsoft).
10
IMAGE 2 : SCHEMA DU FONCTIONNEMENT DE .NET
e. Avantages de WPF
- Simplification de la procédure de développement et de maintenance : En effet, WPF possède un langage descriptif (XAML) associé à des langages de logique (C++, C#, J#, Visual Basic...), ce qui permet de séparer le graphisme de l’application de son fonctionnement. Cela rend la maintenance facile, puisque changer l’interface ne demande pas de retoucher toute l’application.
D’autre part, WPF propose des composants d’interface préprogrammés (Jauge de chargement, bouton, feuille de calcul…) ce qui rend le développement d’application bureautique assez aisé.
- Application qui ne plante pas facilement : En effet pour WPF, Microsoft a revu
toutes les fondations des ses vieilles bibliothèques de programmation d’interface (WIN32). Cela rend les applications bien plus fluides, et les plantages inexpliqués quasi inexistants (on suppose que l’application est correctement programmée).
- Affichage vectoriel de l’application : WPF propose un moteur vectoriel pour l’affichage de composants. Le langage XAML supportant le vectoriel, il prend là toute sa puissance. En effet, une application vectorielle à l’avantage de ne pas perdre de qualité lors de son redimensionnement.
11
- Portabilité de l’application : WPF étant basé sur .net, les applications codées avec
celui-ci sont assurées d’être compatibles avec Windows 2000,XP,2003,Vista, 7. Mais aussi avec les systèmes linux dans le futur (une implémentation est prévue pour 2011).
- Classes 3D : Des classes permettant la manipulation assez aisée d’objets 3D (par rapport à directx natif ou la majorité des supports d’openGL) ont été développées. Cela peut par exemple servir à présenter des produits en 3 dimensions dans une application commerciale.
- Documentation très bien fournie : La documentation de Microsoft (voir la partie référence) à l’avantage d’être ultra complète et normalisée.
- Des applications pouvant être lues sur un navigateur : La version navigateur de WPF, Silverlight, anciennement nommée WPF/E, a déjà fait ses preuves. Il est assez aisé d’adapter une application WPF pour Silverlight.
f. Inconvénients de WPF
- Temps de formation : Le temps de formation à .net pour pouvoir coder correctement est déjà estimé à plus de 400 heures par Microsoft, pour coder correctement avec WPF, il faut compter 300 heures de plus.
- Difficulté des concepts : Certains concepts introduits par WPF sont assez difficiles à comprendre (les dependancy property par exemple) ou peuvent paraître faciles à comprendre au premier abord, mais ne sont souvent pas utilisés correctement.
En effet, il est difficile d’oublier les méthodes traditionnelles de programmation lorsque l’on code avec WPF, car celles-ci sont tout aussi valables, mais souvent moins rapides ou bien plus longues à mettre en place.
- Langage pas forcément pensé pour les jeux : En effet, WPF n’est pas pensé pour les gros jeux 3D où il n’est pas très performant. Cela dit, il s’avère excellent pour les petits jeux statiques.
- Des petits problèmes de jeunesse : WPF est sorti en 2006, et depuis, de nombreux correctifs sont sortis pour améliorer ses performances (.net 3.5 sp1 …).
12
3) Les nouveaux concepts de WPF
a. Les contrôles
Un contrôle est un objet d’interface utilisateur (hérité de la classe UserControl de System.Windows.Controls ou d’une sous–classe dépendante prédéfinie). Cet objet prédispose donc de différents attributs et événements propres à un élément d’interface utilisateur (hauteur, largeur, cliquable…).
Il est possible soit d’utiliser les contrôles préexistants, soit de créer des contrôles nouveaux ou d’en construire des personnalisés à partir de contrôles déjà existants (via l’héritage).
Un contrôle n’est pas un concept propre à WPF, cela dit, on peut le considérer comme tel, puisque les bases de celui-ci ont étés revus affin de permettre son intégration totale avec XAML.
b. Les Styles
Les styles WPF sont à .net ce que les styles CSS sont à html. Ils permettent de définir un élément graphique (couleurs, taille…) qui pourra être réutilisé dans le code. Cela permet d’assurer une meilleure cohésion des interfaces et une meilleure lisibilité/modularité du code.
Les styles couplés aux templates (cf. sous-partie suivante) permettent donc aux développeurs de travailler indépendament du design (réservé au infographistes) .
<!-- Définition d’un style de dégradé rouge.
L’attribut Key est important, c’est celui-ci qui sert à identifier le style
-->
<LinearGradientBrush x:Key="fond_rouge" EndPoint="1,0.5" StartPoint="0,0.5">
<GradientStop Color="#FFFF9A61" Offset="0"/>
<GradientStop Color="#FF671111" Offset="1"/>
<GradientStop Color="#FFC14F44" Offset="0.312"/>
</LinearGradientBrush>
<!—- On rappel le style au sein de l’application --> Background="{StaticResource fond_rouge}"
On peut rappeler le style en mode statique (StaticResource) ou en mode dynamique (DynamicResource). La différence étant que l’apparence de l’objet dont la ressource est déclarée dynamiquement changera en temps réel en cas de changement des propriétés de la ressource.
Les styles sont généralement regroupés dans un fichier général et/ou dans chaque
contrôle auquel ils sont associés. Ce fichier s’appelle le dictionnaire des ressources.
c. Les Templates
Les Templates sont complémentaire aux styles. Ils permettent de modifier l’organisation d’un contrôle, donc son affichage à l’écran. C'est grâce à eux que vous allez
13
par exemple pouvoir dire que vous voulez que votre bouton ne soit plus un rectangle mais devienne un cercle.
Les Templates sont aussi généralement regroupés dans le dictionnaire des ressources.
d. Le binding
Le terme anglais binding désigne l’action de relier différents éléments entre eux. On peut par exemple facilement relier la hauteur d’un bouton avec la valeur d’un champ de texte :
height="{Binding ElementName=TextBox1, Path=Value}"
Note : On peut aussi définir un binding via c#, VB…. Dans le cas d’un binding entre sources de données (feuilles de calcul Excel,
document XML, sources SQL), on parle de DataBinding. Le binding n’est pas une notion inventée avec WPF, mais son implémentation est
très bien réalisée et mérite le détour. Cette notion permet de réduire fortement la taille du code et de simplifier des opérations de liaisons qui n’étaient pas simples, via un langage classique (obligation d’instanciation des timers de contrôle…).
e. Les dependency properties
WPF propose de nombreux outils pour créer des interfaces graphiques. Par exemple, la prise en charge des styles et des templates, les animations ou bien le binding.
Tous ces outils s'appuient fortement sur les dependency properties qui composent le nouveau service de propriétés évoluées de WPF. Ce concept est un des plus compliqués et un des plus longs à comprendre, pour arriver à le mettre en œuvre efficacement.
Mais finalement, on peut se poser la question suivante : quelle est l’utilité d’un nouveau service de propriétés ?
En effet, .Net propose déjà une solution simple et claire pour construire des propriétés sur des objets.
Le principal problème avec les propriétés de .Net vient du fait qu'elles ne permettent pas nativement de construire la valeur de la propriété en fonction de plusieurs sources.
Cela confronte les développeurs de XAML à un problème très important : l'abondance des propriétés et leur multiplication sur tout l'arbre visuel.
Les dependency properties sont donc aussi présentes pour pallier ce problème.
14
Exemple de déclaration d’une Dependency Property (DP) : class Cercle : Control
{
// Déclaration de la DP en temps qu’attribut
public static readonly DependencyProperty DiametreProperty;
// Initialisation de la DP au sein du constructeur
static Cercle()
{
/* Valeur désigne le nom de la propriété (par exemple on peut
mettre type_pneu pour un objet voiture).
La propriété sera du type du contrôle, mais représentera un entier
*/
ValeurProperty = DependencyProperty.Register("Diametre",
typeof(float), typeof(Cercle));
}
// Déclaration de la propriété CLR utilisée par la DP
public float Cercle
{
get
{
return (float)GetValue(ValeurProperty);
}
set
{
SetValue(ValeurProperty, value);
}
}
}
Même si le code peut sembler plus lourd et moins lisible qu'une simple propriété il
faut voir plusieurs avantages à ce concept :
- Gain de mémoire : le stockage centralisé est optimisé et requiert moins de place, surtout lorsque de nombreuses propriétés sont gérées.
- Combinaison des types : permet de combiner le type de la valeur gérée par la Dependency Property avec le type de l’objet (par exemple si on a un attribut de type sexe, on peut faire en sorte de le combiner avec le type humain représentant l’objet de même nom).
- Gestion des notifications (pour permettre au programmeur de définir des erreurs de compilation/interprétation personnalisées).
- Comportements intégrés : Lors de la création d'une dependency property il est possible de préciser des comportements (remettre à jour l'affichage, support du data binding, afficher une info bulle ...).
- Intégration au XAML.
15
f. Le dispatcher (répartiteur)
Les applications WPF sont généralement constituées de deux threads (cf. Glossaire) :
- Un thread de gestion de l’affichage (thread de rendu) - Un thread de gestion des événements et des éléments de calculs indépendant du
rendu. (nommé thread d’interface utilisateur).
Ce mode permet de garantir la réactivité d’une application au cours d’un calcul. Le dispatcher est en fait une file d’attente, qui permet de définir par ordre de
priorité, l’ordre dans lequel les actions seront rendues. Lorsqu’une action est terminée ou en cours, celui-ci peut aisément le notifier à son utilisateur, ou au programme en lui-même.
Chaque thread utilise un ou plusieurs dispatchers associés qui, correctement utilisés, permettent de rendre l’application plus réactive.
Les classes dérivées du dispatcher (la majorité des classes propres à WPF) proposent
des objets dérivés telle que le DispatcherTimer, qui permet d’exécuter une action toutes les x millisecondes, secondes, minutes, sans perdre la cohésion des calculs en cas de dépassement du temps alloué à l’action.
4) L’environnement de développement (IDE)
a. Pourquoi ?
Pourquoi utiliser un environnement de développement ? En effet, s’il était il y a quelques années de pratique courante de décrier les environnements de développement, ce n’est aujourd’hui plus le cas.
En effet, coder une application via un logiciel conçu spécifiquement pour un ou plusieurs langages permet de gagner un temps considérable, tout en évitant les bugs.
D’autre part, WPF proposant la création de graphisme évolué via XAML, il est impératif de pouvoir visualiser rapidement ce que l’on code lorsque l’on retouche une interface.
Outre cela, il reste un avantage majeur dans le cas de .net. En effet, .net propose énormément de classes. Il est donc plus facile de s’y retrouver avec un IDE, car celui-ci peut proposer automatiquement les méthodes et événements associés à un objet utilisé.
16
b. Microsoft Visual Studio 2008
Nous avons utilisé l’environnement de développement le plus connu et performant actuellement pour le développement Microsoft : Microsoft Visual Studio 2008.
IMAGE 3 : MICROSOFT VISUAL STUDIO 2008
L’avantage majeur de Visual Studio est son débuggeur, lequel permet de pointer en
direct dans le code un problème survenant au cours de l’exécution d’une application. De plus l’organisation de l’éditeur rend le code facilement lisible et modifiable,
l’indentation est quasi parfaite. D’autre part, cet éditeur est disponible gratuitement en version express (version un
peu moins complète que la version professionnelle et disposant d’un peu de publicité intégrée). Cela dit, la licence gratuite interdit l’utilisation à des fins commerciales des applications développées.
c. Microsoft Expression design
Pour gérer l’apparence des applications WPF, il est nécessaire que les designers disposent d’une application performante de dessin générant du code XAML.
Nous avons donc choisi d’utiliser Microsoft Expression Design (codé lui-même via WPF) qui propose de nombreux outils de dessin vectoriel, tout en possédant une intégration efficace avec Visual Studio.
Le logiciel nous est apparu vraiment évolué par rapport à son prix et à sa jeunesse. Il propose notamment pas mal de textures et dégradés par défaut. Cela dit, pour l’utiliser
17
pleinement, il faut quand même avoir certaines notions en infographie, aussi bien en termes d’esthétisme que de compétences techniques.
Cela dit, de plus en plus de logiciels de dessin proposent maintenant la génération d’images Xaml, cela dit, le code généré est souvent moins propre que celui d’Expression Design.
IMAGE 4 : MICROSOFT EXPRESSION DESIGN
d. Microsoft WPF Performance suite
Voici un des logiciels qui nous a le plus surpris. En effet, lors du développement d’une grosse application WPF (ou d’une petite application développée par un programmeur débutant WPF), on peut s’étonner de voir des ralentissements apparaitre.
Ces ralentissements peuvent être dus à plusieurs causes :
- Problème d’efficacité des algorithmes du programmeur. - Mauvaise utilisation des concepts (pouvant notamment entraîner un rendu logiciel) - Problème interne à WPF. - Ordinateur pas assez puissant.
18
IMAGE 5 : WPF PERFORMANCE SUITE
Ce logiciel permet de développer précisément les principaux objets instanciés afin de déterminer celui qui consomme le plus (consommation indiquée en temps et en pourcentage). Il permet aussi de générer un rapport pour le soumettre à d’autres développeurs.
IMAGE 6 : AFFICHAGE DES RESSOURCES PRISES PAR L’APPLICATION
19
Par exemple, sur l’image si dessus, on peut nettement voir que l’élément le plus gourmand dans l’application testée est le thread de rendu (processus qui gère l’affichage de l’application). On peut donc facilement, et du premier coup d’œil, remarquer quel coté de l’application est trop gourmand. Cela permet de gagner un temps considérable dans le débogage de l’application.
20
III. PRESENTATION DE L’APPLICATION
1) Le principe du Pacman « évolué » et les innovations apportés
Le Pacman est un jeu très connu. Son principe est connu de tous : un sympathique personnage doit manger toutes les petites graines du niveau sans se faire « manger » par la horde de fantômes malfaisants lancés à ses trousses.
Nous avons décidé, pour innover, de remanier quelques aspects du Pacman :
- Les niveaux comportent parfois de grandes zones ouvertes, dans lesquelles le Pacman peut se déplacer diagonalement.
- Il n’est pas possible (sans la création de bonus nouveaux), contrairement à la version originale du Pacman, de « manger » les fantômes pour s’en débarrasser quelques temps.
- Le Pacman dispose maintenant d’un compteur de vie. Chaque contact avec un fantôme retire un certain nombre de points de vie au compteur. Plus le contact est prolongé, plus le nombre de points de vie retirés est important. D’autres par, certains fantômes sont plus fort que d’autres et tuent presque instantanément.
- Des bonus, sous la forme de cœurs, sont disséminés dans les niveaux. Ils redonnent
quelques points de vie au Pacman lorsqu’il les mange. Il existe un autre bonus en forme de logo Windows, qui permet d’augmenter la rapidité de déplacement du Pacman. Nous avons aussi voulus inclure un peu d’humour, par exemple voici le
« Pacwomen » Geneviève de Fontenay et le Pacman Harry Potter.
IMAGE 7 : CELEBRITES EN PACMANS
21
2) Installation et exécution de l’application
a. Configuration requise
Configuration minimale :
- Windows XP/2003/Vista/7 - Le Framework .net 3.5 sp1 minimum (disponible sur
http://www.microsoft.com/downloads/details.aspx?FamilyID=AB99342F-5D1A-413D-8319-81DA479AB0D7&displaylang=fr).
- Une carte graphique DirectX8 minimum. - 20 Megaoctets d’espace disque.
Configuration Recommandée :
- Processeur supérieur à 1,2 Gigahertz - 512 Megaoctets de mémoire vive et plus. - Une carte graphique DirectX 10 dédié. - Windows Vista ou dérivé (WPF est bien mieux supporté par vista).
b. Lancement de l’application
Il existe deux manières de démarrer l’application :
- En exécution directe (sans installation) : il suffit juste de double-cliquer sur le fichier Pacman.exe.
- En installant le Programme : il suffit dans ce cas de double-cliquer sur le fichier Pacman.application. Une Fenêtre de confirmation s’ouvre, cliquez sur installer. Ensuite l’application se trouvera dans le menu démarrer. Pour désinstaller l’application, il suffit de rechercher « Pacman UFR Besançon » dans le panneau d’ajout/suppression de programmes de Windows.
22
3) Explication fichier par fichier
a. Fichier sources
GETTER / SETTER
Les méthodes getter / setter (nommées propriétés CLR) sont utilisées en nombre dans le Pacman. Leur fonctionnement est très simple, aussi nous ne les détaillerons pas dans la suite de ce rapport chaque fois qu’elles apparaissent.
Un getter permet de récupérer la valeur d’une variable ou d’un attribut d’un objet alors que celui-ci n’est pas accessible en dehors de sa classe ou de son espace de nom.
Le setter permet, de la même manière que le getter, de fixer la valeur d’un attribut inaccessible depuis l’extérieur de sa classe.
NOTES DIVERSES
- Les méthodes dont le nom est préfixé par EVENT_ sont généralement des méthodes qui sont appellés à la suite d’un événement (clic de souris, animation terminée).
- Tout les attributs ne sont pas expliqués dans cette partie, en effet, le code étant largement commenté, nous avons jugé nécessaire de ne mettre que le plus important.
public Geometry Geometry() : Cette propriété est utilisée pour redéfinir les géométries par rapport au référentiel
du canevas.
private void InitClip() : Cette méthode permet de recalculer les géométries en cas d’agrandissement de
l’objet concerné.
private void Delete() : Cette méthode permet de supprimer les liaisons existantes avec l’objet en cours à
fin de permettre la destruction de celui-ci par le ramasse miette (Garbage collector).
App.xaml :
Ce fichier est utilisé par WPF pour définir le style par défaut de l’application. App.xaml comporte une référence vers Style.xaml, pour que ce dernier soit utilisé comme style par défaut pour l’application.
Cette manière d’implémenter le style permet de changer ce même style simplement en changeant le nom du fichier pointé par App.xaml (de Style.xaml vers Style2.xaml par exemple).
23
App.xaml.cs :
Ce fichier initialise l’application et définit un point de départ (comme il n’y a pas de « main »).
Fantome.xaml :
Ce fichier définit l’apparence d’un fantôme au sein du jeu. Il s’agit du code xaml associé à l’image que nous avons crée sous Microsoft Expression Studio. Ce code peut être modifié pour changer l’apparence du fantôme directement sous l’application Visual Studio (pour de petites retouches sans devoir redessiner le fantôme complètement).
Fantome.xaml.cs :
Ce fichier définit tous les attributs et toutes les méthodes associées à l’objet fantôme au sein du Pacman.
public double PositionX() :
Cette propriété permet de récupérer et modifier la position sur l’axe X de l’objet Pacman à l’instant t.
public double PositionY() :
Cette propriété permet de récupérer et modifier la position sur l’axe Y de l’objet Pacman à l’instant t.
Le fantôme dispose également de 3 constructeurs :
- Le premier constructeur est un constructeur par défaut, avec des valeurs arbitraires pour chacun des paramètres.
- Le second constructeur initialise les coordonnées du fantôme. - Le troisième constructeur initialise tous les paramètres du fantôme suivant les
valeurs passées en paramètres.
public void Deplacer(string Sens) : Cette méthode permet de déplacer le fantôme sur l’aire de jeu en respectant les
bornes de la zone de déplacement autorisée pour le fantôme.
public void deplacement_Auto(object sender, EventArgs e) : Cette méthode est appelée par le timer du fantôme. Si le fantôme peut se déplacer,
alors l’image du fantôme sur la zone de jeu est déplacée dans le sens souhaité, sinon il change de sens au prochain intervalle du timer. Cette méthode génère ( via l’appel de la méthode Deplacer() ) un semblant d’IA car les fantômes se déplacent seuls sur la zone de jeu en prenant en compte les différents obstacles.
24
public bool Test_Collision_Murs() : Cette méthode teste si le fantome rentre en collision avec un mur. Si c’est le cas, le
fantôme change de direction, sinon il peut continuer sur sa lancée jusqu’au prochain mur ou a la prochaine intersection.
public bool Test_Collision_Intersections() :
Cette méthode détecte si le fantome arrive à une intersection. Si c’est le cas, la fantôme choisit aléatoirement une direction qu’il emprunte immédiatement, jusqu'à ce qu’il rencontre un mur ou qu’il tombe sur une nouvelle intersection.
public string random_sens() :
Cette méthode permet de choisir aléatoirement un sens de déplacement pour le fantôme. Elle est appelée par la méthode de choix d’une direction lorsque que la pacman rencontre une intersection.
public void Changer_Etat(string Etat_m) :
Cette méthode permet de changer l’apparence du fantôme (passant de joyeux a colérique ou de vert à rouge par exemple). Elle change le style associé au pacman se trouvant sur la zone de jeu.
fnt_option.xaml
Ce fichier contient l’apparence de la fenêtre de gestion des options du pacman ( une sorte de formulaire constitué de contrôles WPF).
fnt_option.xaml.cs
Ce fichier contient toutes les méthodes et tous les attributs associés à la fenêtre de gestion des options du jeu.
private void EVENT_style_bleu_Click(object sender, RoutedEventArgs e):
Cette méthode permet de changer l’arrière plan du jeu en bleu. Il existe des méthodes similaires pour d’autres couleurs (rouge, noir, vert, jaune).
private void EVENT_Souris_invisible(object sender, RoutedEventArgs e) :
Cette méthode permet de rendre invisible le curseur de la souris. Il existe des méthode similaires pour augmenter la taille du curseur ou pour le transformer en curseur « main ».
private void EVENT_Sauvegarder_Options_Click(object sender, RoutedEventArgs e) :
Cette méthode sauvegarde les options personnalisées de l’utilisateur dans un fichier au format XML
public void Read_XML_on_Start() :
Cette méthode est appelée au démarrage de l’application pour recharger et réappliquer les paramètres utilisateurs personnalisés, ainsi que modifier les contrôles
25
d’options dans la fenêtre d’options (exemple : si le volume était en muet, le slider sera positionné sur muet dans le fenêtre d’options).
private void EVENT_ChangeMediaVolume(object sender, RoutedPropertyChangedEventArgs <double> args) :
Cette méthode permet de changer le volume d’un son et d’une musique. Elle est utilisée lorsque l’utilisateur change le volume du son depuis la fenêtre d’options.
private void EVENT_k_right_KeyDown(object sender, KeyEventArgs e):
Cette méthode permet de changer la touche du clavier contrôlant le déplacement vers le haut du pacman. Il existe une méthode similaire pour le déplacement vers la gauche, la droite et le bas.
Graine.xaml
Ce fichier contient le code définissant l’objet représentant une graine ( qui peut être un bonus) pour permettre son affichage à l’écran.
Graine.xaml.xs
Ce fichier contient les propriétés et les méthodes d’une graine. Une graine dispose de deux constructeurs. Le premier initialise tous les attributs
arbitrairement, tandis que le second constructeur utilise les valeurs qui lui sont passées en paramètres pour l’initialisation des attributs de la graine.
public void Changer_Etat(string Style) :
Cette méthode permet de changer le style de la graine. Par exemple, on peut transformer une graine « standard » en graine bonus, pour rajouter des points de vie ou augmenter le score.
Intersection.xaml
Ce fichier définit un objet « intersection » qui est utilisé pour déterminer si le pacman ou un fantôme entre en collision avec un mur du niveau ou si il arrive au niveau d’un carrefour.
Intersection.xaml.cs
Ce fichier regroupe les propriétés et les méthodes d’un objet « intersection » Une intersection dispose de deux constructeurs : le premier initialise arbitrairement
tous les attributs, le second les initialise en fonction des valeurs qui lui sont passées en paramètre.
26
Jeux.xaml
Ce fichier définit l’apparence de la fenêtre du jeu (contient les boutons d’accès au menu, option… et le plateau de jeu).
Jeux.xaml.cs
Ce fichier regroupe les propriétés et les méthodes de la fenêtre du jeu.
public Jeux() : Ce contructeur initialise une partie ainsi que le premier niveau du jeu.
public Jeux(string niveau, int vie, int loc_score) : Cette constructeur charge une partie avec les paramêtres renseignés.
private void EVENT_Menu_Option(object sender, RoutedEventArgs e) : Cette méthode permet d’afficher le menu d’options en cours de partie.
private void EVENT_btn_Abandonner_Partie_Click(object sender, RoutedEventArgs e) : Cette méthode est appelée lorsque le joueur souhaite abandonner la partie. Elle
désalloue la mémoire de tous les éléments du jeu et renvoie le joueur au menu principal.
private void EVENT_Sauvegarder_Click(object sender, RoutedEventArgs e) : Cette méthode permet au joueur de sauvegarder sa partie en cours dans
l’emplacement de son choix sur le disque dur de sa machine. Elle fait apparaître une boîte de dialogue Windows permettant de choisir l’emplacement de sauvegarde.
private void Charger_niveau(string niv) :
Cette méthode permet de charger un niveau particulier (le nom des niveaux est définit dans le fichier niveau.xaml.cs)
private void EVENT_Relancer_Partie_Click(object sender, RoutedEventArgs e) :
Cette méthode permet de mettre en pause le jeu et de le relancer si il est déjà en pause. Elle modifie également le texte du bouton pause (pause ou relancer la partie).
public void changer_vie(int Valeur, bool replace) :
Cette méthode est consacrée à la gestion du compteur de vie du pacman. Elle calcule, en fonction des collisions avec les fantômes, le nombre de points de vie à retirer au compteur du pacman ; elle rajoute également des points de vie dans la cas où le pacman attrape un bonus de vie au cours du jeu.
Cette méthode modifie également la couleur du compteur de points de vie lorsque
les points de vie du pacman atteignent un certain seuil (vert, orange puis rouge). Cette méthode (via l’appel à delete() ) désalloue également la mémoire allouée au niveau de jeu lorsque le pacman n’a plus de points de vie et que la partie est perdue.
27
public void changer_score(int Score_value, bool replace) : Cette méthode gère le compteur de points de score du pacman et le passage au
niveau supérieur. En effet, lorsque le score du pacman atteint un certain nombre (par exemple, 220), c’est que toutes les graines du niveau 1 ont été mangées, et donc que le niveau est terminé. Le niveau 2 est ensuite chargé, jusqu'à ce que le score atteigne un certain nombre, puis on passe au niveau 3 et ainsi de suite.
public void Charger_Animation(string Anim):
Cette méthode crée un thread alloué à la gestion de animations, par exemple celle du bonus de vie. Elle permet de charger une animation sans bloquer le jeu.
Menu.xaml
Cette fenêtre définit l’aspect de la fenêtre du menu principal.
Menu.xaml.cs
Cette fenêtre contient toutes les méthodes de la fenêtre de menu principal.
private void EVENT_Option_Click(object sender, RoutedEventArgs e) : Cette méthode permet d’afficher la fenêtre d’option.
private void EVENT_Play_Pacman_Click(object sender, RoutedEventArgs e) : Cette méthode permet de commencer une nouvelle partie ( on charge le niveau 1
du jeu).
private void Verif_Menu(object sender, RoutedEventArgs e): Cette méthode vérifie que le jeu a bien été chargé et modifie le texte du bouton
« nouvelle partie » en « reprendre la partie ».
private void Charger_Partie_Click(object sender, RoutedEventArgs e) : Cette méthode permet de charger une partie précédemment enregistrée, par
l’intermédiaire d’une boîte de dialogue Windows similaire à celle d’enregistrement de partie.
Mur.xaml
Ce fichier définit un objet mur qui sera utilisé dans les niveaux de jeu.
Mur.xaml.cs
L’objet mur dispose d’un constructeur par défaut et de 2 constructeur par initialisation.
Les attributs int Id_visuel et bool affiche_visuel du derniers contructeurs permettent d’attribuer un numéro au mur et de l’afficher afin de le distiguer de ses voisins (très utile lorsque l’on développe un niveau uniquement en code).
28
Niveau.xaml
Ce fichier définit le plateau de jeu, c’est à dire le conteneur ( bordure extérieure du niveau et la couleur de fond ) par dessus lequel viendront s’ajouter les graines, les murs, les fantômes etc…
Niveau.xaml.cs
Le fichier niveau recense toutes les propriétés et toutes les méthodes utilisées pour la création d’un niveau de jeu
Un niveau dispose de 5 tableaux dont le rôle est de référencer tous les objets présents dans le niveau. Il y a donc un tableau pour tous les pacmans du niveau, un pour toutes les graines, un pour les fantomes, un autre pour les murs et enfin un dernier tableau pour les intersections.
public Niveau(string Nom_niveau) :
Cette méthode est chargée d’appliquer un fond d’écran et de charger le niveau correspondant au nom du niveau passé en paramètre.
public void Delete( ) :
Cette méthode présente dans beaucoup de fichiers est très importante plus particulièrement pour ce niveau. En effet, elle supprime toutes les références aux objets du niveau pour que le Garbage Collector puisse effectuer correctement son nettoyage.
Elle fait également un appel au Garbage Collector pour supprimer immédiatement les liaisons. Si un oubli est commis dans cette méthode, l’objet ne sera pas désinstancié. Dans le cas d’un objet appelé de très nombreuses fois, la machine sera saturée très rapidement. Il a donc été très important de bien la réaliser et la tester.
public void n1( ) … nn() :
Chaque niveau est déclaré statiquement dans une méthode qui porte son nom. Chaque objet de ce niveau est donc déclaré dans cette méthode, en faisant appel au constructeur de cet objet.
Ensuite, les élements du niveau son placés sur l’arrière plan dans cet ordre : l’objet au premier plan est placé en dernier, et vice-versa.
private void Placer_Pacmans() : Cette méthode permet de placer le ou les pacman(s) sur le tableau de jeu. On
détecte d’abord d’éventuelles collisions afin d’éviter de se retrouver avec un pacman au beau milieu d’un mur. On ajoute ensuite le tout physiquement.
Il existe des méthodes similaires pour les murs, les graines, les intersections et les
fantômes.
29
private void Desinstancier_Pacmans() : Cette méthode est utilisée pour désinstancier le tableau référençant tous les
pacmans de la zone de jeu. Il existe des méthodes similaires pour les murs, les graines, les intersections et les
fantômes.
Pacman_c.xaml
Ce fichier définit l’objet pacman (plusieurs modèles sont actuellement disponibles « Mireille Mathieu, Harry Potter,… »).
Pacman_c.xaml.cs
Ce fichier contient tous les attributs et toutes les méthodes de l’objet pacman.
public void Deplacer( string Sens) : Cette méthode permet de déplacer le pacman dans la zone de jeu sans en sortir ni
entrer en collision avec les murs de la zone de jeu. Suivant le sens de déplacement passé en paramètres, la méthode fait pivoter le
pacman sur la zone de jeu (la tête du pacman s’oriente dans le sens du déplacement) et le déplace d’un cran dans la direction choisie.
public void recuperer_touche_deplacement(object sender, EventArgs e)
Cette méthode récupère la touche pressée au clavier. Si cette touche correspond à une touche de déplacement du pacman, alors la méthode précédente est appelée avec le sens de déplacement correspondant qui lui est passé en paramètre.
public bool Test_Collision_Murs():
Cette méthode teste si le pacman entre en collision avec un des murs du jeu. Elle retourne un booléen fixé à « true » si il y’a effectivement une collision entre le pacman et un des murs présent sur la surface de jeu.
L’inconvénient de cette méthode vient du fait qu’elle teste les collisions entre le
pacman et tous les murs présents sur la surface de jeu, ce qui est relativement gourmand en temps processeur dans le cas de nombreux murs et pacmans instancié.
Nous avons pour idée d’améliorer cette méthode, par exemple en divisant la zone de jeu en carrés de plus petites dimensions et en testant uniquement les collisions avec les murs présents dans le même petit carré que le pacman.
Il existe, bien évidemment, des méthodes similaires pour les collisions avec des
fantômes et des graines. Dans le cas des graines, on détecte également si la graine est une graine bonus. Si la
graine, bonus ou non, n’a pas été mangée au préalable, une action est décelenchée.
30
Dans le cas d’un fantôme, on diminue le compteur de vie du pacman.
public void Changer_Etat(string Etat_m) : Cette méthode permet de changer l’état du pacman, et donc son apparence. Le
pacman par défaut est le modèle « Mireille Mathieu ». Par exemple, si la pacman n’a presque plus de points de vie, il peut passer dans l’état « colérique » ou « triste ».
private int Trouver_Valeur_Rotation(string rotation_finale) :
Cette fonction permet de trouver rapidement de combien de degrés le pacman doit tourner suivant son sens de déplacement actuel et le sens de déplacement souhaité.
Style.xaml
Ce fichier définit le style des fenêtres et objets du jeu. En effet, la fenêtre pacman possède un style très proche de celui utilisé dans Windows Vista/7. C’est dans ce fichier que le style et les templates des boutons sont définit pour ressembler à ceux de Windows Vista (Transparence).
C’est en quelque sorte l’équivalent des fichiers style.css en html.
Window1.xaml
Ce fichier définit le style de la fenêtre principale au sein de laquelle les différents élements viennent s’ajouter. Concrètement, on définit un arrière plan par défaut ainsi que les trois boutons standards : réduire, niveau inférieur et fermer la fenêtre et un conteneur qui sert à charger les éléments (page de l’application dans la fenêtre.
Window1.xaml.cs
Ce fichier contient les méthodes de gestions des événements lorsque l’utilisateur clique sur un des trois boutons de la fenêtre.
Il contient également les variables globales du jeu ainsi que les timers, qui sont très utilisés au sein du pacman. Les timers servent pour la réactualisation de la fenêtre : toutes les x millisecondes du timer, le jeu est réactualisé, le pacman et les fantômes se déplacent et les collisions sont testées.
b. Fichiers compilés
Cette partie expose les fichiers présents dans le dossier racine du jeu.
- Les fichiers de ressources comme les sons se trouvent dans le dossier Application Files/Son.
- Les fichiers d’aides et de langue pour les bibliothèques se trouvent dans le dossier FR.
31
Pacman.exe :
Ce fichier est le fichier principal du Pacman. Il rassemble le programme sous sa forme compilée. C’est ce fichier qu’il faut exécuter pour lancer l’application.
Ce fichier utilise les autres fichiers présents (il en est donc dépendant).
Pacman.exe.manifest :
Ce fichier XML permet de témoigner de la confiance du fichier vis-à-vis du système d’exploitation. Cela permet de démarrer le programme avec des privilèges restraints, ou de demander la confirmation de l’utilisateur si l’application nécessite des privilèges administrateur.
Pacman.application Ce fichier contient l’installeur du jeu ( il n’est pas indispensable mais permet
d’installer le jeu comme un programme normal au lieu de l’éxécuter simplement dans un dossier).
Rapport.xps :
Ce fichier contient le rapport du projet ( ce présent rapport) afin qu’il puisse être lu au sein de l’application.
Perspective... ( type dll) :
Ces fichiers sont parties intégrante de la librairie perspective3D qui simplifie la gestion des objet 3D simple au sein de WPF. Cette librairie a du être modifiée par nos soins afin de la rendre plus simple d’utilisation (possibilité de positionner son objet 3D en temps réel).
32
4) Difficultés rencontrées
La principale difficulté que nous avons rencontré au cours de notre projet est due au
fait que la suite WPF de Microsoft ne gère pas l’accélération matérielle de l’affichage dans certains cas d’utilisations.
Cela peut entraîner des ralentissements et une impression de saccades, car la carte graphique n’est pas sollicitée, contrairement au processeur qui doit assumer sa charge en plus de celle dévolue normalement aux calculs.
Cela dit nous avons réussi à corriger ce problème en utilisant de manière plus adéquate les concepts associés (héritage à partir d’un type d’objet supportant l’accélération).
Cela dit, un autre problème persiste, WPF n’est en effet pas conçu pour faire des
jeux. Les méthodes d’implémentations de frappe simultanée au clavier (pour gérer la pression de plusieurs touches en même temps) ont été implantées manuellement (une implémentation des fonctions natives DirectX10 étant trop compliquée à notre niveau).
D’autre part, WPF contrairement à DirectX ne réactualise que les zones nécessaires
à l’écran, ce qui est excellent pour les applications bureautiques, mais assez problématique lors des jeux (10 Fantômes à 25 FPS =250 FPS nécessaires). Cela dit, la maitrise des concepts permet de pallier cela, mais on perd en lisibilité.
Cela dit la prochaine version de .net (.net 4) corrigera une grande partie de ces
problèmes. D’autre part, Visual studio 2008 est le premier IDE à gérer la compilation de programmes WPF, on peut donc fortement espérer des optimisations dans la version suivante qui est en cours de développement.
5) Possibilités d’évolution
L’avantage d’utiliser .net et la programmation orientée objet, est qu’il est très simple de rajouter des fonctionnalités à une application sans forcément l’alourdir.
Nous pensons améliorer le système de gestion des collisions, afin de soulager le
processeur en réduisant le nombre de calculs. Actuellement, chaque objet se pouvant se déplacer est testé pour voir si s’il entre en collisions avec tous les murs du niveau. Nous pensons par exemple diviser la zone de jeu en zone plus petite et ne tester les collisions de l’objet que dans la « sous-zone » qu’il occupe.
Cela dit cela n’est pas prioritaire, car le test des collisions au sein d’un niveau lourd n’utilise pas plus de 8% de ressources CPU.
Nous avons également pour projet de rajouter plusieurs niveaux au Pacman, ainsi
que de nouveaux bonus et la possibilité de manger les fantômes pour s’en débarrasser. De façon à créer un scénario et à rendre le jeu plus intéressant.
33
L’implémentation d’une intelligence artificielle de plus haut niveau est aussi envisagée. Elle se basera sur un algorithme de calcul de trajectoire entre les intersections (le fantôme choisira la destination la plus courte pour arriver à atteindre le Pacman). Cela dit il faudra aussi gérer dans cette IA le fait qu’un niveau peut contenir plusieurs Pacmans.
Le déplacement parfois chaotique du Pacman peut également être amélioré, mais
nous attendrons .net 4 qui proposera des méthodes de gestion de touches bien mieux adaptées.
D’autre part, l’arrivée de Visual studio 10 devrait nous permettre (via la gestion
graphique des collections de contrôles personnalisés) de pouvoir dessiner nous même les niveaux (à la souris) ce qui apporterait un gain de temps considérable.
34
IV. CONCLUSION Pour conclure, ce projet fut très intéressant à plusieurs points de vue. D’une part, la
mise en place d’une stratégie organisation entres les deux personnes du binôme fut enrichissante. En effet, la répartition des tâches fut agréable et productive.
D’autre part, le fait d’utiliser un langage productif nous à permis de nous mettre
plus proche de l’utilisateur, de façon à produire une application plus ergonomique. Cela nous à aussi permis d’explorer les multiples fonctionnalités de .net, et par la même occasion d’en apprendre plus sur le fonctionnement de Windows et sur la stratégie de développement des développeurs Microsoft.
Le jeu n’est pas entièrement terminé, mais ce n’était pas le but de créer une
application totalement finie. Cela dit, nous comptons continuer ce projet afin de le mettre en libre disposition à la communauté de développeur WPF. En effet, il existe très peu de jeux mettant en scène plusieurs objets en mouvement conçus via WPF. La mise en ligne du projet sera donc l’occasion de recevoir toutes les critiques nécessaires à notre perfectionnement. De plus cela fournira un support de programmation pour toute celles et ceux qui souhaitent apprendre WPF via la création d’un jeu.
Pour finir, nous nous devons de donner nos impressions sur la technologie WPF.
Nous avons étés totalement conquis par le confort de développement qu’offre celle-ci. Les performances pour une application bureautiques semblent excellentes. La simplicité qu’offre ce langage (malgré le prix d’un apprentissage long est pas aussi évident qu’il n’en à l’air) permet d’aborder le développement d’une application sans forcément ce soucier de sa maintenance.
WPF à déjà les faveurs d’une partie de la communauté de linux, ce qui est assez surprenant pour une technologie issus de l’entreprise. En effet, Microsoft à ouvert les spécifications de celle-ci, ce qui offre donc des possibilités de portabilité des programmes WPF sur linux. Quand les développeurs auront finit l’adaptation, l’utilisation de ce concept risque de monter en flèche.
Cela dit, WPF n’est pas encore conçus pour utiliser toute la puissance matérielle dans les jeux, mais cela nous permet d’entrevoir de très belles perspectives d’avenir pour les nouvelles applications.
Cela dit, la personnalisation à outrance ne saurait se faire sans prendre conscience que l’application doit respecter des normes d’ergonomie et d’intégration au système d’exploitation qui l’héberge pour être facilement adaptée.
35
V. REFERENCES
Sites internet :
http://msdn.microsoft.com/fr-fr/vcsharp/default.aspx : Documentation de tout les
outils et langages de développement Microsoft (C#, Visual basic, WPF, .net, Visual studio
…).
http://www.developpez.net/forums/f914/dotnet/general-dotnet/wpf/ : Excellent
forum pour débattre de vos problèmes avec WPF.
Livre :
« WPF par la pratique » Par Thomas LEBRUN : Un des meilleurs ouvrages en français
sur WPF.
Thomas Lebrun est un leader technique dans le pôle Rich Internet & Desktop Applications de la société Winwise, Thomas Lebrun est également consultant/formateur sur les technologies WPF et Silverlight. Pour le remercier de ses contributions communautaires, Microsoft lui a accordé le titre de MVP (Most Valuable Professionnel), d'abord dans la catégorie C# en 2007, puis dans la catégorie « Client Application Development » en 2008.
36
VI. GLOSSAIRE
Assembly Un assembly est une portion de code partiellement compilé. Elle remplace les dll (fichiers bibliothèques), elle est bien plus pratique que ces derniers car il n'y à pas de problèmes de mise à jour ou de duplicité. L'assembly sert à réutiliser des portions de codes déjà définis sans avoir à recompiler le code.
Bibliothèque de programmation Une bibliothèque de programmation est un ensemble de codes informatique réutilisable dans des programmes.
Charte graphique La charte graphique est un document de travail qui contient l'ensemble des règles fondamentales d'utilisation des signes graphiques qui constituent l'identité graphique d'une organisation, d'un projet, d'une entreprise.
Code source Le code source est un ensemble d'instructions écrites dans un langage de programmation informatique de haut niveau, compréhensible par un être humain entraîné, permettant d'obtenir un programme pour un ordinateur.
CSS CSS (Cascading Style Sheets ) : feuilles de style en cascade) sert à décrire la présentation des documents HTML et XML. Les standards définissant CSS sont publiés par le World Wide Web Consortium (W3C). Introduit au milieu des années 1990, CSS devient couramment utilisé dans la conception de sites web et bien supportés par les navigateurs web dans les années 2000.
Débogage Le débogage consiste à corriger les anomalies de fonctionnement d'une application informatique.
Evénement Un événement est une action (par exemple un clic de souris) en informatique qui va déclencher un traitement (par exemple l'ouverture d'une fenêtre).
37
Framework Un Framework est un espace de travail modulaire. C'est un ensemble de bibliothèques, d'outils et de conventions permettant le développement d'applications. Il est sensé faciliter la mise en place d'application et leur maintenance.
IDE Un IDE (Integrated Development Environment) est environnement de développement informatique (logiciel ou suite de logiciels). Il sert à faciliter le développement d'une application.
Linux Linux, ou GNU/Linux, est un système d’exploitation. Linux est basé sur le noyau Linux, un logiciel libre créé en 1991 par Linus Torvalds sur un ordinateur compatible PC.
Machine Virtuelle Une machine virtuelle permet de simuler un ordinateur complet sur un seul ordinateur. Cela est très intéressant au niveau de la sécurité ( un virus n'attaque que l'environnement virtuel), mais aussi pour le débogage de l'application et de la portabilité de celle-ci.
Navigateur web Un navigateur web est un logiciel conçu pour consulter le World Wide Web.
Propriété (C#) Les propriétés (en c#) remplacent les attributs du c++/java… . Elles permettent de simplifier l'écriture et la lecture des attributs.
Thread Un thread est un processus léger qui peut par exemple permettre la communication entre deux processus (par exemple la communication entre WPF et DirectX).
Timer Un Timer est une boucle qui s'exécute à intervalle de temps défini dans un programme qui permet d'exécuter une action à chaque passage de la boucle.
XAML XAML est un langage de balisage servant à décrire un élément graphique (dessin) ou une interface WPF (fenêtre Windows, contrôle utilisateur…)
XHTML XHTML est un langage de balisage servant à l'écriture de pages WEB.
38
VII. TABLE DES MATIERES
I. INTRODUCTION.............................................. 5
II. PRESENTATION DU LANGAGE ........................ 6
1) Explications sur le choix du langage .................................................................. 6
2) WPF ................................................................................................................. 6
a. Description ......................................................................................................... 6
b. Xaml ................................................................................................................... 8
c. C# ....................................................................................................................... 8
d. .net 3.5 ............................................................................................................... 9
e. Avantages de WPF ........................................................................................... 10
f. Inconvénients de WPF ...................................................................................... 11
3) Les nouveaux concepts de WPF ...................................................................... 12
a. Les contrôles..................................................................................................... 12
b. Les Styles .......................................................................................................... 12
c. Les Templates................................................................................................... 12
d. Le binding ......................................................................................................... 13
e. Les dependency properties ............................................................................... 13
f. Le dispatcher (répartiteur) ................................................................................ 15
4) L’environnement de développement (IDE) ...................................................... 15
a. Pourquoi ? ........................................................................................................ 15
b. Microsoft Visual Studio 2008 ............................................................................ 16
c. Microsoft Expression design ............................................................................. 16
d. Microsoft WPF Performance suite .................................................................... 17
III. PRESENTATION DE L’APPLICATION .............. 20
1) Le principe du Pacman « évolué » et les innovations apportés ........................ 20
2) Installation et exécution de l’application ........................................................ 21
a. Configuration requise ....................................................................................... 21
b. Lancement de l’application .............................................................................. 21
3) Explication fichier par fichier .......................................................................... 22
a. Fichier sources .................................................................................................. 22
39
GETTER / SETTER 22
NOTES DIVERSES 22
App.xaml : 22
App.xaml.cs : 23
Fantome.xaml : 23
Fantome.xaml.cs : 23
fnt_option.xaml 24
fnt_option.xaml.cs 24
Graine.xaml 25
Graine.xaml.xs 25
Intersection.xaml.cs 25
Jeux.xaml 26
Jeux.xaml.cs 26
Menu.xaml 27
Menu.xaml.cs 27
Mur.xaml 27
Mur.xaml.cs 27
Pacman_c.xaml 29
Pacman_c.xaml.cs 29
Style.xaml 30
Window1.xaml 30
Window1.xaml.cs 30
b. Fichiers compilés .............................................................................................. 30
Pacman.exe : 31
Pacman.exe.manifest : 31
Rapport.xps : 31
Perspective... ( type dll) : 31
4) Difficultés rencontrées ................................................................................... 32
5) Possibilités d’évolution .................................................................................. 32
IV. CONCLUSION ............................................... 34
40
V. REFERENCES ................................................. 35
Sites internet : 35
Livres : 35
VI. GLOSSAIRE .................................................... 36
VII. TABLE DES MATIERES ................................... 38
41
42
Ce rapport décrit un projet effectué par deux étudiants en Licence d’informatique.
Ce projet à consisté en l’apprentissage d’un nouveau concept de programmation Microsoft nommé WPF. Cet apprentissage s’est fait à travers la conception d’un Pacman. Ce projet vise notamment à préparer les étudiants de Faculté à leur stage de 3ème année.
This document presents the project and the objectives of two students from the Besançon University of Computer Science.
It consisted in learning a computer concept of Microsoft called WPF. This learning was done through the design of a Pacman. This project aims to prepare students for their 3rd degree of University of Computer Science.
